PKZuUUXSUB.hnuW+A/* XSUB.h * * Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, * 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #ifndef _INC_PERL_XSUB_H #define _INC_PERL_XSUB_H 1 /* first, some documentation for xsubpp-generated items */ /* =head1 Variables created by C and C internal functions =for apidoc Amn|char*|CLASS Variable which is setup by C to indicate the class name for a C++ XS constructor. This is always a C. See C. =for apidoc Amn|(whatever)|RETVAL Variable which is setup by C to hold the return value for an XSUB. This is always the proper type for the XSUB. See L. =for apidoc Amn|(whatever)|THIS Variable which is setup by C to designate the object in a C++ XSUB. This is always the proper type for the C++ object. See C and L. =for apidoc Amn|I32|ax Variable which is setup by C to indicate the stack base offset, used by the C, C and C macros. The C macro must be called prior to setup the C variable. =for apidoc Amn|I32|items Variable which is setup by C to indicate the number of items on the stack. See L. =for apidoc Amn|I32|ix Variable which is setup by C to indicate which of an XSUB's aliases was used to invoke it. See L. =for apidoc Am|SV*|ST|int ix Used to access elements on the XSUB's stack. =for apidoc AmU||XS Macro to declare an XSUB and its C parameter list. This is handled by C. It is the same as using the more explicit XS_EXTERNAL macro. =for apidoc AmU||XS_INTERNAL Macro to declare an XSUB and its C parameter list without exporting the symbols. This is handled by C and generally preferable over exporting the XSUB symbols unnecessarily. =for apidoc AmU||XS_EXTERNAL Macro to declare an XSUB and its C parameter list explicitly exporting the symbols. =for apidoc Ams||dAX Sets up the C variable. This is usually handled automatically by C by calling C. =for apidoc Ams||dAXMARK Sets up the C variable and stack marker variable C. This is usually handled automatically by C by calling C. =for apidoc Ams||dITEMS Sets up the C variable. This is usually handled automatically by C by calling C. =for apidoc Ams||dXSARGS Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. Sets up the C and C variables by calling C and C. This is usually handled automatically by C. =for apidoc Ams||dXSI32 Sets up the C variable for an XSUB which has aliases. This is usually handled automatically by C. =for apidoc Ams||dUNDERBAR Sets up any variable needed by the C macro. It used to define C, but it is currently a noop. However, it is strongly advised to still use it for ensuring past and future compatibility. =for apidoc AmU||UNDERBAR The SV* corresponding to the $_ variable. Works even if there is a lexical $_ in scope. =cut */ #ifndef PERL_UNUSED_ARG # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ # include # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) # else # define PERL_UNUSED_ARG(x) ((void)x) # endif #endif #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(x) ((void)x) #endif #define ST(off) PL_stack_base[ax + (off)] /* XSPROTO() is also used by SWIG like this: * * typedef XSPROTO(SwigPerlWrapper); * typedef SwigPerlWrapper *SwigPerlWrapperPtr; * * This code needs to be compilable under both C and C++. * * Don't forget to change the __attribute__unused__ version of XS() * below too if you change XSPROTO() here. */ /* XS_INTERNAL is the explicit static-linkage variant of the default * XS macro. * * XS_EXTERNAL is the same as XS_INTERNAL except it does not include * "STATIC", ie. it exports XSUB symbols. You probably don't want that. */ #define XSPROTO(name) void name(pTHX_ CV* cv) #undef XS #undef XS_EXTERNAL #undef XS_INTERNAL #if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING) # define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name) # define XS_INTERNAL(name) STATIC XSPROTO(name) #endif #if defined(__SYMBIAN32__) # define XS_EXTERNAL(name) EXPORT_C XSPROTO(name) # define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name) #endif #ifndef XS_EXTERNAL # if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) # define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__) # define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__) # else # ifdef __cplusplus # define XS_EXTERNAL(name) extern "C" XSPROTO(name) # define XS_INTERNAL(name) static XSPROTO(name) # else # define XS_EXTERNAL(name) XSPROTO(name) # define XS_INTERNAL(name) STATIC XSPROTO(name) # endif # endif #endif /* We do export xsub symbols by default for the public XS macro. * Try explicitly using XS_INTERNAL/XS_EXTERNAL instead, please. */ #define XS(name) XS_EXTERNAL(name) #define dAX const I32 ax = (I32)(MARK - PL_stack_base + 1) #define dAXMARK \ I32 ax = POPMARK; \ register SV **mark = PL_stack_base + ax++ #define dITEMS I32 items = (I32)(SP - MARK) #if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ # define dXSARGS \ NOTE(ARGUNUSED(cv)) \ dSP; dAXMARK; dITEMS #else # define dXSARGS \ dSP; dAXMARK; dITEMS #endif #define dXSTARG SV * const targ = ((PL_op->op_private & OPpENTERSUB_HASTARG) \ ? PAD_SV(PL_op->op_targ) : sv_newmortal()) /* Should be used before final PUSHi etc. if not in PPCODE section. */ #define XSprePUSH (sp = PL_stack_base + ax - 1) #define XSANY CvXSUBANY(cv) #define dXSI32 I32 ix = XSANY.any_i32 #ifdef __cplusplus # define XSINTERFACE_CVT(ret,name) ret (*name)(...) # define XSINTERFACE_CVT_ANON(ret) ret (*)(...) #else # define XSINTERFACE_CVT(ret,name) ret (*name)() # define XSINTERFACE_CVT_ANON(ret) ret (*)() #endif #define dXSFUNCTION(ret) XSINTERFACE_CVT(ret,XSFUNCTION) #define XSINTERFACE_FUNC(ret,cv,f) ((XSINTERFACE_CVT_ANON(ret))(f)) #define XSINTERFACE_FUNC_SET(cv,f) \ CvXSUBANY(cv).any_dxptr = (void (*) (pTHX_ void*))(f) #define dUNDERBAR dNOOP #define UNDERBAR find_rundefsv() /* Simple macros to put new mortal values onto the stack. */ /* Typically used to return values from XS functions. */ /* =head1 Stack Manipulation Macros =for apidoc Am|void|XST_mIV|int pos|IV iv Place an integer into the specified position C on the stack. The value is stored in a new mortal SV. =for apidoc Am|void|XST_mNV|int pos|NV nv Place a double into the specified position C on the stack. The value is stored in a new mortal SV. =for apidoc Am|void|XST_mPV|int pos|char* str Place a copy of a string into the specified position C on the stack. The value is stored in a new mortal SV. =for apidoc Am|void|XST_mNO|int pos Place C<&PL_sv_no> into the specified position C on the stack. =for apidoc Am|void|XST_mYES|int pos Place C<&PL_sv_yes> into the specified position C on the stack. =for apidoc Am|void|XST_mUNDEF|int pos Place C<&PL_sv_undef> into the specified position C on the stack. =for apidoc Am|void|XSRETURN|int nitems Return from XSUB, indicating number of items on the stack. This is usually handled by C. =for apidoc Am|void|XSRETURN_IV|IV iv Return an integer from an XSUB immediately. Uses C. =for apidoc Am|void|XSRETURN_UV|IV uv Return an integer from an XSUB immediately. Uses C. =for apidoc Am|void|XSRETURN_NV|NV nv Return a double from an XSUB immediately. Uses C. =for apidoc Am|void|XSRETURN_PV|char* str Return a copy of a string from an XSUB immediately. Uses C. =for apidoc Ams||XSRETURN_NO Return C<&PL_sv_no> from an XSUB immediately. Uses C. =for apidoc Ams||XSRETURN_YES Return C<&PL_sv_yes> from an XSUB immediately. Uses C. =for apidoc Ams||XSRETURN_UNDEF Return C<&PL_sv_undef> from an XSUB immediately. Uses C. =for apidoc Ams||XSRETURN_EMPTY Return an empty list from an XSUB immediately. =head1 Variables created by C and C internal functions =for apidoc AmU||newXSproto|char* name|XSUBADDR_t f|char* filename|const char *proto Used by C to hook up XSUBs as Perl subs. Adds Perl prototypes to the subs. =for apidoc AmU||XS_VERSION The version identifier for an XS module. This is usually handled automatically by C. See C. =for apidoc Ams||XS_VERSION_BOOTCHECK Macro to verify that a PM module's $VERSION variable matches the XS module's C variable. This is usually handled automatically by C. See L. =for apidoc Ams||XS_APIVERSION_BOOTCHECK Macro to verify that the perl api version an XS module has been compiled against matches the api version of the perl interpreter it's being loaded into. =head1 Simple Exception Handling Macros =for apidoc Ams||dXCPT Set up necessary local variables for exception handling. See L. =for apidoc AmU||XCPT_TRY_START Starts a try block. See L. =for apidoc AmU||XCPT_TRY_END Ends a try block. See L. =for apidoc AmU||XCPT_CATCH Introduces a catch block. See L. =for apidoc Ams||XCPT_RETHROW Rethrows a previously caught exception. See L. =cut */ #define XST_mIV(i,v) (ST(i) = sv_2mortal(newSViv(v)) ) #define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) #define XST_mNV(i,v) (ST(i) = sv_2mortal(newSVnv(v)) ) #define XST_mPV(i,v) (ST(i) = sv_2mortal(newSVpv(v,0))) #define XST_mPVN(i,v,n) (ST(i) = newSVpvn_flags(v,n, SVs_TEMP)) #define XST_mNO(i) (ST(i) = &PL_sv_no ) #define XST_mYES(i) (ST(i) = &PL_sv_yes ) #define XST_mUNDEF(i) (ST(i) = &PL_sv_undef) #define XSRETURN(off) \ STMT_START { \ const IV tmpXSoff = (off); \ PL_stack_sp = PL_stack_base + ax + (tmpXSoff - 1); \ return; \ } STMT_END #define XSRETURN_IV(v) STMT_START { XST_mIV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_NV(v) STMT_START { XST_mNV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_PV(v) STMT_START { XST_mPV(0,v); XSRETURN(1); } STMT_END #define XSRETURN_PVN(v,n) STMT_START { XST_mPVN(0,v,n); XSRETURN(1); } STMT_END #define XSRETURN_NO STMT_START { XST_mNO(0); XSRETURN(1); } STMT_END #define XSRETURN_YES STMT_START { XST_mYES(0); XSRETURN(1); } STMT_END #define XSRETURN_UNDEF STMT_START { XST_mUNDEF(0); XSRETURN(1); } STMT_END #define XSRETURN_EMPTY STMT_START { XSRETURN(0); } STMT_END #define newXSproto(a,b,c,d) newXS_flags(a,b,c,d,0) #ifdef XS_VERSION # define XS_VERSION_BOOTCHECK \ Perl_xs_version_bootcheck(aTHX_ items, ax, STR_WITH_LEN(XS_VERSION)) #else # define XS_VERSION_BOOTCHECK #endif #define XS_APIVERSION_BOOTCHECK \ Perl_xs_apiversion_bootcheck(aTHX_ ST(0), STR_WITH_LEN("v" PERL_API_VERSION_STRING)) #ifdef NO_XSLOCKS # define dXCPT dJMPENV; int rEtV = 0 # define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) # define XCPT_TRY_END JMPENV_POP; # define XCPT_CATCH if (rEtV != 0) # define XCPT_RETHROW JMPENV_JUMP(rEtV) #endif /* The DBM_setFilter & DBM_ckFilter macros are only used by the *DB*_File modules */ #define DBM_setFilter(db_type,code) \ STMT_START { \ if (db_type) \ RETVAL = sv_mortalcopy(db_type) ; \ ST(0) = RETVAL ; \ if (db_type && (code == &PL_sv_undef)) { \ SvREFCNT_dec(db_type) ; \ db_type = NULL ; \ } \ else if (code) { \ if (db_type) \ sv_setsv(db_type, code) ; \ else \ db_type = newSVsv(code) ; \ } \ } STMT_END #define DBM_ckFilter(arg,type,name) \ STMT_START { \ if (db->type) { \ if (db->filtering) { \ croak("recursion detected in %s", name) ; \ } \ ENTER ; \ SAVETMPS ; \ SAVEINT(db->filtering) ; \ db->filtering = TRUE ; \ SAVE_DEFSV ; \ if (name[7] == 's') \ arg = newSVsv(arg); \ DEFSV_set(arg) ; \ SvTEMP_off(arg) ; \ PUSHMARK(SP) ; \ PUTBACK ; \ (void) perl_call_sv(db->type, G_DISCARD); \ SPAGAIN ; \ PUTBACK ; \ FREETMPS ; \ LEAVE ; \ if (name[7] == 's'){ \ arg = sv_2mortal(arg); \ } \ } } STMT_END #if 1 /* for compatibility */ # define VTBL_sv &PL_vtbl_sv # define VTBL_env &PL_vtbl_env # define VTBL_envelem &PL_vtbl_envelem # define VTBL_sigelem &PL_vtbl_sigelem # define VTBL_pack &PL_vtbl_pack # define VTBL_packelem &PL_vtbl_packelem # define VTBL_dbline &PL_vtbl_dbline # define VTBL_isa &PL_vtbl_isa # define VTBL_isaelem &PL_vtbl_isaelem # define VTBL_arylen &PL_vtbl_arylen # define VTBL_glob &PL_vtbl_glob # define VTBL_mglob &PL_vtbl_mglob # define VTBL_nkeys &PL_vtbl_nkeys # define VTBL_taint &PL_vtbl_taint # define VTBL_substr &PL_vtbl_substr # define VTBL_vec &PL_vtbl_vec # define VTBL_pos &PL_vtbl_pos # define VTBL_bm &PL_vtbl_bm # define VTBL_fm &PL_vtbl_fm # define VTBL_uvar &PL_vtbl_uvar # define VTBL_defelem &PL_vtbl_defelem # define VTBL_regexp &PL_vtbl_regexp # define VTBL_regdata &PL_vtbl_regdata # define VTBL_regdatum &PL_vtbl_regdatum # ifdef USE_LOCALE_COLLATE # define VTBL_collxfrm &PL_vtbl_collxfrm # endif # define VTBL_amagic &PL_vtbl_amagic # define VTBL_amagicelem &PL_vtbl_amagicelem #endif #include "perlapi.h" #if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_NO_GET_CONTEXT) && !defined(PERL_CORE) # undef aTHX # undef aTHX_ # define aTHX PERL_GET_THX # define aTHX_ aTHX, #endif #if defined(PERL_IMPLICIT_SYS) && !defined(PERL_CORE) # ifndef NO_XSLOCKS # if defined (NETWARE) && defined (USE_STDIO) # define times PerlProc_times # define setuid PerlProc_setuid # define setgid PerlProc_setgid # define getpid PerlProc_getpid # define pause PerlProc_pause # define exit PerlProc_exit # define _exit PerlProc__exit # else # undef closedir # undef opendir # undef stdin # undef stdout # undef stderr # undef feof # undef ferror # undef fgetpos # undef ioctl # undef getlogin # undef setjmp # undef getc # undef ungetc # undef fileno /* Following symbols were giving redefinition errors while building extensions - sgp 17th Oct 2000 */ #ifdef NETWARE # undef readdir # undef fstat # undef stat # undef longjmp # undef endhostent # undef endnetent # undef endprotoent # undef endservent # undef gethostbyaddr # undef gethostbyname # undef gethostent # undef getnetbyaddr # undef getnetbyname # undef getnetent # undef getprotobyname # undef getprotobynumber # undef getprotoent # undef getservbyname # undef getservbyport # undef getservent # undef inet_ntoa # undef sethostent # undef setnetent # undef setprotoent # undef setservent #endif /* NETWARE */ /* to avoid warnings: "xyz" redefined */ #ifdef WIN32 # undef popen # undef pclose #endif /* WIN32 */ # undef socketpair # define mkdir PerlDir_mkdir # define chdir PerlDir_chdir # define rmdir PerlDir_rmdir # define closedir PerlDir_close # define opendir PerlDir_open # define readdir PerlDir_read # define rewinddir PerlDir_rewind # define seekdir PerlDir_seek # define telldir PerlDir_tell # define putenv PerlEnv_putenv # define getenv PerlEnv_getenv # define uname PerlEnv_uname # define stdin PerlSIO_stdin # define stdout PerlSIO_stdout # define stderr PerlSIO_stderr # define fopen PerlSIO_fopen # define fclose PerlSIO_fclose # define feof PerlSIO_feof # define ferror PerlSIO_ferror # define clearerr PerlSIO_clearerr # define getc PerlSIO_getc # define fgets PerlSIO_fgets # define fputc PerlSIO_fputc # define fputs PerlSIO_fputs # define fflush PerlSIO_fflush # define ungetc PerlSIO_ungetc # define fileno PerlSIO_fileno # define fdopen PerlSIO_fdopen # define freopen PerlSIO_freopen # define fread PerlSIO_fread # define fwrite PerlSIO_fwrite # define setbuf PerlSIO_setbuf # define setvbuf PerlSIO_setvbuf # define setlinebuf PerlSIO_setlinebuf # define stdoutf PerlSIO_stdoutf # define vfprintf PerlSIO_vprintf # define ftell PerlSIO_ftell # define fseek PerlSIO_fseek # define fgetpos PerlSIO_fgetpos # define fsetpos PerlSIO_fsetpos # define frewind PerlSIO_rewind # define tmpfile PerlSIO_tmpfile # define access PerlLIO_access # define chmod PerlLIO_chmod # define chsize PerlLIO_chsize # define close PerlLIO_close # define dup PerlLIO_dup # define dup2 PerlLIO_dup2 # define flock PerlLIO_flock # define fstat PerlLIO_fstat # define ioctl PerlLIO_ioctl # define isatty PerlLIO_isatty # define link PerlLIO_link # define lseek PerlLIO_lseek # define lstat PerlLIO_lstat # define mktemp PerlLIO_mktemp # define open PerlLIO_open # define read PerlLIO_read # define rename PerlLIO_rename # define setmode PerlLIO_setmode # define stat(buf,sb) PerlLIO_stat(buf,sb) # define tmpnam PerlLIO_tmpnam # define umask PerlLIO_umask # define unlink PerlLIO_unlink # define utime PerlLIO_utime # define write PerlLIO_write # define malloc PerlMem_malloc # define realloc PerlMem_realloc # define free PerlMem_free # define abort PerlProc_abort # define exit PerlProc_exit # define _exit PerlProc__exit # define execl PerlProc_execl # define execv PerlProc_execv # define execvp PerlProc_execvp # define getuid PerlProc_getuid # define geteuid PerlProc_geteuid # define getgid PerlProc_getgid # define getegid PerlProc_getegid # define getlogin PerlProc_getlogin # define kill PerlProc_kill # define killpg PerlProc_killpg # define pause PerlProc_pause # define popen PerlProc_popen # define pclose PerlProc_pclose # define pipe PerlProc_pipe # define setuid PerlProc_setuid # define setgid PerlProc_setgid # define sleep PerlProc_sleep # define times PerlProc_times # define wait PerlProc_wait # define setjmp PerlProc_setjmp # define longjmp PerlProc_longjmp # define signal PerlProc_signal # define getpid PerlProc_getpid # define gettimeofday PerlProc_gettimeofday # define htonl PerlSock_htonl # define htons PerlSock_htons # define ntohl PerlSock_ntohl # define ntohs PerlSock_ntohs # define accept PerlSock_accept # define bind PerlSock_bind # define connect PerlSock_connect # define endhostent PerlSock_endhostent # define endnetent PerlSock_endnetent # define endprotoent PerlSock_endprotoent # define endservent PerlSock_endservent # define gethostbyaddr PerlSock_gethostbyaddr # define gethostbyname PerlSock_gethostbyname # define gethostent PerlSock_gethostent # define gethostname PerlSock_gethostname # define getnetbyaddr PerlSock_getnetbyaddr # define getnetbyname PerlSock_getnetbyname # define getnetent PerlSock_getnetent # define getpeername PerlSock_getpeername # define getprotobyname PerlSock_getprotobyname # define getprotobynumber PerlSock_getprotobynumber # define getprotoent PerlSock_getprotoent # define getservbyname PerlSock_getservbyname # define getservbyport PerlSock_getservbyport # define getservent PerlSock_getservent # define getsockname PerlSock_getsockname # define getsockopt PerlSock_getsockopt # define inet_addr PerlSock_inet_addr # define inet_ntoa PerlSock_inet_ntoa # define listen PerlSock_listen # define recv PerlSock_recv # define recvfrom PerlSock_recvfrom # define select PerlSock_select # define send PerlSock_send # define sendto PerlSock_sendto # define sethostent PerlSock_sethostent # define setnetent PerlSock_setnetent # define setprotoent PerlSock_setprotoent # define setservent PerlSock_setservent # define setsockopt PerlSock_setsockopt # define shutdown PerlSock_shutdown # define socket PerlSock_socket # define socketpair PerlSock_socketpair # endif /* NETWARE && USE_STDIO */ # ifdef USE_SOCKETS_AS_HANDLES # undef fd_set # undef FD_SET # undef FD_CLR # undef FD_ISSET # undef FD_ZERO # define fd_set Perl_fd_set # define FD_SET(n,p) PERL_FD_SET(n,p) # define FD_CLR(n,p) PERL_FD_CLR(n,p) # define FD_ISSET(n,p) PERL_FD_ISSET(n,p) # define FD_ZERO(p) PERL_FD_ZERO(p) # endif /* USE_SOCKETS_AS_HANDLES */ # endif /* NO_XSLOCKS */ #endif /* PERL_IMPLICIT_SYS && !PERL_CORE */ #endif /* _INC_PERL_XSUB_H */ /* include guard */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ"r handy.hnuW+A/* handy.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, * 2001, 2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #if !defined(__STDC__) #ifdef NULL #undef NULL #endif #ifndef I286 # define NULL 0 #else # define NULL 0L #endif #endif #ifndef PERL_CORE # define Null(type) ((type)NULL) /* =head1 Handy Values =for apidoc AmU||Nullch Null character pointer. (No longer available when C is defined.) =for apidoc AmU||Nullsv Null SV pointer. (No longer available when C is defined.) =cut */ # define Nullch Null(char*) # define Nullfp Null(PerlIO*) # define Nullsv Null(SV*) #endif #ifdef TRUE #undef TRUE #endif #ifdef FALSE #undef FALSE #endif #define TRUE (1) #define FALSE (0) /* The MUTABLE_*() macros cast pointers to the types shown, in such a way * (compiler permitting) that casting away const-ness will give a warning; * e.g.: * * const SV *sv = ...; * AV *av1 = (AV*)sv; <== BAD: the const has been silently cast away * AV *av2 = MUTABLE_AV(sv); <== GOOD: it may warn */ #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define MUTABLE_PTR(p) ({ void *_p = (p); _p; }) #else # define MUTABLE_PTR(p) ((void *) (p)) #endif #define MUTABLE_AV(p) ((AV *)MUTABLE_PTR(p)) #define MUTABLE_CV(p) ((CV *)MUTABLE_PTR(p)) #define MUTABLE_GV(p) ((GV *)MUTABLE_PTR(p)) #define MUTABLE_HV(p) ((HV *)MUTABLE_PTR(p)) #define MUTABLE_IO(p) ((IO *)MUTABLE_PTR(p)) #define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p)) #ifdef I_STDBOOL # include # ifndef HAS_BOOL # define HAS_BOOL 1 # endif #endif /* bool is built-in for g++-2.6.3 and later, which might be used for extensions. <_G_config.h> defines _G_HAVE_BOOL, but we can't be sure _G_config.h will be included before this file. _G_config.h also defines _G_HAVE_BOOL for both gcc and g++, but only g++ actually has bool. Hence, _G_HAVE_BOOL is pretty useless for us. g++ can be identified by __GNUG__. Andy Dougherty February 2000 */ #ifdef __GNUG__ /* GNU g++ has bool built-in */ # ifndef HAS_BOOL # define HAS_BOOL 1 # endif #endif /* The NeXT dynamic loader headers will not build with the bool macro So declare them now to clear confusion. */ #if defined(NeXT) || defined(__NeXT__) # undef FALSE # undef TRUE typedef enum bool { FALSE = 0, TRUE = 1 } bool; # define ENUM_BOOL 1 # ifndef HAS_BOOL # define HAS_BOOL 1 # endif /* !HAS_BOOL */ #endif /* NeXT || __NeXT__ */ #ifndef HAS_BOOL # if defined(UTS) || defined(VMS) # define bool int # else # define bool char # endif # define HAS_BOOL 1 #endif /* a simple (bool) cast may not do the right thing: if bool is defined * as char for example, then the cast from int is implementation-defined * (bool)!!(cbool) in a ternary triggers a bug in xlc on AIX */ #define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0) /* Try to figure out __func__ or __FUNCTION__ equivalent, if any. * XXX Should really be a Configure probe, with HAS__FUNCTION__ * and FUNCTION__ as results. * XXX Similarly, a Configure probe for __FILE__ and __LINE__ is needed. */ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || (defined(__SUNPRO_C)) /* C99 or close enough. */ # define FUNCTION__ __func__ #else # if (defined(_MSC_VER) && _MSC_VER < 1300) || /* Pre-MSVC 7.0 has neither __func__ nor __FUNCTION and no good workarounds, either. */ \ (defined(__DECC_VER)) /* Tru64 or VMS, and strict C89 being used, but not modern enough cc (in Tur64, -c99 not known, only -std1). */ # define FUNCTION__ "" # else # define FUNCTION__ __FUNCTION__ /* Common extension. */ # endif #endif /* XXX A note on the perl source internal type system. The original intent was that I32 be *exactly* 32 bits. Currently, we only guarantee that I32 is *at least* 32 bits. Specifically, if int is 64 bits, then so is I32. (This is the case for the Cray.) This has the advantage of meshing nicely with standard library calls (where we pass an I32 and the library is expecting an int), but the disadvantage that an I32 is not 32 bits. Andy Dougherty August 1996 There is no guarantee that there is *any* integral type with exactly 32 bits. It is perfectly legal for a system to have sizeof(short) == sizeof(int) == sizeof(long) == 8. Similarly, there is no guarantee that I16 and U16 have exactly 16 bits. For dealing with issues that may arise from various 32/64-bit systems, we will ask Configure to check out SHORTSIZE == sizeof(short) INTSIZE == sizeof(int) LONGSIZE == sizeof(long) LONGLONGSIZE == sizeof(long long) (if HAS_LONG_LONG) PTRSIZE == sizeof(void *) DOUBLESIZE == sizeof(double) LONG_DOUBLESIZE == sizeof(long double) (if HAS_LONG_DOUBLE). */ #ifdef I_INTTYPES /* e.g. Linux has int64_t without */ # include # ifdef INT32_MIN_BROKEN # undef INT32_MIN # define INT32_MIN (-2147483647-1) # endif # ifdef INT64_MIN_BROKEN # undef INT64_MIN # define INT64_MIN (-9223372036854775807LL-1) # endif #endif typedef I8TYPE I8; typedef U8TYPE U8; typedef I16TYPE I16; typedef U16TYPE U16; typedef I32TYPE I32; typedef U32TYPE U32; #ifdef PERL_CORE # ifdef HAS_QUAD typedef I64TYPE I64; typedef U64TYPE U64; # endif #endif /* PERL_CORE */ #if defined(HAS_QUAD) && defined(USE_64_BIT_INT) # ifndef UINT64_C /* usually from */ # if defined(HAS_LONG_LONG) && QUADKIND == QUAD_IS_LONG_LONG # define INT64_C(c) CAT2(c,LL) # define UINT64_C(c) CAT2(c,ULL) # else # if LONGSIZE == 8 && QUADKIND == QUAD_IS_LONG # define INT64_C(c) CAT2(c,L) # define UINT64_C(c) CAT2(c,UL) # else # if defined(_WIN64) && defined(_MSC_VER) # define INT64_C(c) CAT2(c,I64) # define UINT64_C(c) CAT2(c,UI64) # else # define INT64_C(c) ((I64TYPE)(c)) # define UINT64_C(c) ((U64TYPE)(c)) # endif # endif # endif # endif #endif #if defined(UINT8_MAX) && defined(INT16_MAX) && defined(INT32_MAX) /* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type. Please search CHAR_MAX in perl.h for further details. */ #define U8_MAX UINT8_MAX #define U8_MIN UINT8_MIN #define I16_MAX INT16_MAX #define I16_MIN INT16_MIN #define U16_MAX UINT16_MAX #define U16_MIN UINT16_MIN #define I32_MAX INT32_MAX #define I32_MIN INT32_MIN #ifndef UINT32_MAX_BROKEN /* e.g. HP-UX with gcc messes this up */ # define U32_MAX UINT32_MAX #else # define U32_MAX 4294967295U #endif #define U32_MIN UINT32_MIN #else /* I8_MAX and I8_MIN constants are not defined, as I8 is an ambiguous type. Please search CHAR_MAX in perl.h for further details. */ #define U8_MAX PERL_UCHAR_MAX #define U8_MIN PERL_UCHAR_MIN #define I16_MAX PERL_SHORT_MAX #define I16_MIN PERL_SHORT_MIN #define U16_MAX PERL_USHORT_MAX #define U16_MIN PERL_USHORT_MIN #if LONGSIZE > 4 # define I32_MAX PERL_INT_MAX # define I32_MIN PERL_INT_MIN # define U32_MAX PERL_UINT_MAX # define U32_MIN PERL_UINT_MIN #else # define I32_MAX PERL_LONG_MAX # define I32_MIN PERL_LONG_MIN # define U32_MAX PERL_ULONG_MAX # define U32_MIN PERL_ULONG_MIN #endif #endif /* log(2) is pretty close to 0.30103, just in case anyone is grepping for it */ #define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */ #define TYPE_DIGITS(T) BIT_DIGITS(sizeof(T) * 8) #define TYPE_CHARS(T) (TYPE_DIGITS(T) + 2) /* sign, NUL */ #define Ctl(ch) ((ch) & 037) /* =head1 SV-Body Allocation =for apidoc Ama|SV*|newSVpvs|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Ama|SV*|newSVpvs_flags|const char* s|U32 flags Like C, but takes a literal string instead of a string/length pair. =for apidoc Ama|SV*|newSVpvs_share|const char* s Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. =for apidoc Am|void|sv_catpvs_flags|SV* sv|const char* s|I32 flags Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|void|sv_catpvs_nomg|SV* sv|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|void|sv_catpvs|SV* sv|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|void|sv_catpvs_mg|SV* sv|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|void|sv_setpvs|SV* sv|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|void|sv_setpvs_mg|SV* sv|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|SV *|sv_setref_pvs|const char* s Like C, but takes a literal string instead of a string/length pair. =head1 Memory Management =for apidoc Ama|char*|savepvs|const char* s Like C, but takes a literal string instead of a string/length pair. =for apidoc Ama|char*|savesharedpvs|const char* s A version of C which allocates the duplicate string in memory which is shared between threads. =head1 GV Functions =for apidoc Am|HV*|gv_stashpvs|const char* name|I32 create Like C, but takes a literal string instead of a string/length pair. =head1 Hash Manipulation Functions =for apidoc Am|SV**|hv_fetchs|HV* tb|const char* key|I32 lval Like C, but takes a literal string instead of a string/length pair. =for apidoc Am|SV**|hv_stores|HV* tb|const char* key|NULLOK SV* val Like C, but takes a literal string instead of a string/length pair and omits the hash parameter. =head1 Lexer interface =for apidoc Amx|void|lex_stuff_pvs|const char *pv|U32 flags Like L, but takes a literal string instead of a string/length pair. =cut */ /* concatenating with "" ensures that only literal strings are accepted as argument */ #define STR_WITH_LEN(s) ("" s ""), (sizeof(s)-1) /* note that STR_WITH_LEN() can't be used as argument to macros or functions that * under some configurations might be macros, which means that it requires the full * Perl_xxx(aTHX_ ...) form for any API calls where it's used. */ /* STR_WITH_LEN() shortcuts */ #define newSVpvs(str) Perl_newSVpvn(aTHX_ STR_WITH_LEN(str)) #define newSVpvs_flags(str,flags) \ Perl_newSVpvn_flags(aTHX_ STR_WITH_LEN(str), flags) #define newSVpvs_share(str) Perl_newSVpvn_share(aTHX_ STR_WITH_LEN(str), 0) #define sv_catpvs_flags(sv, str, flags) \ Perl_sv_catpvn_flags(aTHX_ sv, STR_WITH_LEN(str), flags) #define sv_catpvs_nomg(sv, str) \ Perl_sv_catpvn_flags(aTHX_ sv, STR_WITH_LEN(str), 0) #define sv_catpvs(sv, str) \ Perl_sv_catpvn_flags(aTHX_ sv, STR_WITH_LEN(str), SV_GMAGIC) #define sv_catpvs_mg(sv, str) \ Perl_sv_catpvn_flags(aTHX_ sv, STR_WITH_LEN(str), SV_GMAGIC|SV_SMAGIC) #define sv_setpvs(sv, str) Perl_sv_setpvn(aTHX_ sv, STR_WITH_LEN(str)) #define sv_setpvs_mg(sv, str) Perl_sv_setpvn_mg(aTHX_ sv, STR_WITH_LEN(str)) #define sv_setref_pvs(rv, classname, str) \ Perl_sv_setref_pvn(aTHX_ rv, classname, STR_WITH_LEN(str)) #define savepvs(str) Perl_savepvn(aTHX_ STR_WITH_LEN(str)) #define savesharedpvs(str) Perl_savesharedpvn(aTHX_ STR_WITH_LEN(str)) #define gv_stashpvs(str, create) \ Perl_gv_stashpvn(aTHX_ STR_WITH_LEN(str), create) #define gv_fetchpvs(namebeg, add, sv_type) \ Perl_gv_fetchpvn_flags(aTHX_ STR_WITH_LEN(namebeg), add, sv_type) #define gv_fetchpvn(namebeg, len, add, sv_type) \ Perl_gv_fetchpvn_flags(aTHX_ namebeg, len, add, sv_type) #define sv_catxmlpvs(dsv, str, utf8) \ Perl_sv_catxmlpvn(aTHX_ dsv, STR_WITH_LEN(str), utf8) #define hv_fetchs(hv,key,lval) \ ((SV **)Perl_hv_common(aTHX_ (hv), NULL, STR_WITH_LEN(key), 0, \ (lval) ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \ : HV_FETCH_JUST_SV, NULL, 0)) #define hv_stores(hv,key,val) \ ((SV **)Perl_hv_common(aTHX_ (hv), NULL, STR_WITH_LEN(key), 0, \ (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), (val), 0)) #define lex_stuff_pvs(pv,flags) Perl_lex_stuff_pvn(aTHX_ STR_WITH_LEN(pv), flags) #define get_cvs(str, flags) \ Perl_get_cvn_flags(aTHX_ STR_WITH_LEN(str), (flags)) /* =head1 Miscellaneous Functions =for apidoc Am|bool|strNE|char* s1|char* s2 Test two strings to see if they are different. Returns true or false. =for apidoc Am|bool|strEQ|char* s1|char* s2 Test two strings to see if they are equal. Returns true or false. =for apidoc Am|bool|strLT|char* s1|char* s2 Test two strings to see if the first, C, is less than the second, C. Returns true or false. =for apidoc Am|bool|strLE|char* s1|char* s2 Test two strings to see if the first, C, is less than or equal to the second, C. Returns true or false. =for apidoc Am|bool|strGT|char* s1|char* s2 Test two strings to see if the first, C, is greater than the second, C. Returns true or false. =for apidoc Am|bool|strGE|char* s1|char* s2 Test two strings to see if the first, C, is greater than or equal to the second, C. Returns true or false. =for apidoc Am|bool|strnNE|char* s1|char* s2|STRLEN len Test two strings to see if they are different. The C parameter indicates the number of bytes to compare. Returns true or false. (A wrapper for C). =for apidoc Am|bool|strnEQ|char* s1|char* s2|STRLEN len Test two strings to see if they are equal. The C parameter indicates the number of bytes to compare. Returns true or false. (A wrapper for C). =cut */ #define strNE(s1,s2) (strcmp(s1,s2)) #define strEQ(s1,s2) (!strcmp(s1,s2)) #define strLT(s1,s2) (strcmp(s1,s2) < 0) #define strLE(s1,s2) (strcmp(s1,s2) <= 0) #define strGT(s1,s2) (strcmp(s1,s2) > 0) #define strGE(s1,s2) (strcmp(s1,s2) >= 0) #define strnNE(s1,s2,l) (strncmp(s1,s2,l)) #define strnEQ(s1,s2,l) (!strncmp(s1,s2,l)) #ifdef HAS_MEMCMP # define memNE(s1,s2,l) (memcmp(s1,s2,l)) # define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) #else # define memNE(s1,s2,l) (bcmp(s1,s2,l)) # define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) #endif #define memEQs(s1, l, s2) \ (sizeof(s2)-1 == l && memEQ(s1, ("" s2 ""), (sizeof(s2)-1))) #define memNEs(s1, l, s2) !memEQs(s1, l, s2) /* * Character classes. * * Unfortunately, the introduction of locales means that we * can't trust isupper(), etc. to tell the truth. And when * it comes to /\w+/ with tainting enabled, we *must* be able * to trust our character classes. * * Therefore, the default tests in the text of Perl will be * independent of locale. Any code that wants to depend on * the current locale will use the tests that begin with "lc". */ #ifdef HAS_SETLOCALE /* XXX Is there a better test for this? */ # ifndef CTYPE256 # define CTYPE256 # endif #endif /* =head1 Character classes There are three variants for all the functions in this section. The base ones operate using the character set of the platform Perl is running on. The ones with an C<_A> suffix operate on the ASCII character set, and the ones with an C<_L1> suffix operate on the full Latin1 character set. All are unaffected by locale and by C. For ASCII platforms, the base function with no suffix and the one with the C<_A> suffix are identical. The function with the C<_L1> suffix imposes the Latin-1 character set onto the platform. That is, the code points that are ASCII are unaffected, since ASCII is a subset of Latin-1. But the non-ASCII code points are treated as if they are Latin-1 characters. For example, C will return true when called with the code point 0xA0, which is the Latin-1 NO-BREAK SPACE. For EBCDIC platforms, the base function with no suffix and the one with the C<_L1> suffix should be identical, since, as of this writing, the EBCDIC code pages that Perl knows about all are equivalent to Latin-1. The function that ends in an C<_A> suffix will not return true unless the specified character also has an ASCII equivalent. =for apidoc Am|bool|isALPHA|char ch Returns a boolean indicating whether the specified character is an alphabetic character in the platform's native character set. See the L for an explanation of variants C and C. =for apidoc Am|bool|isASCII|char ch Returns a boolean indicating whether the specified character is one of the 128 characters in the ASCII character set. On non-ASCII platforms, it is if this character corresponds to an ASCII character. Variants C and C are identical to C. =for apidoc Am|bool|isDIGIT|char ch Returns a boolean indicating whether the specified character is a digit in the platform's native character set. Variants C and C are identical to C. =for apidoc Am|bool|isLOWER|char ch Returns a boolean indicating whether the specified character is a lowercase character in the platform's native character set. See the L for an explanation of variants C and C. =for apidoc Am|bool|isOCTAL|char ch Returns a boolean indicating whether the specified character is an octal digit, [0-7] in the platform's native character set. Variants C and C are identical to C. =for apidoc Am|bool|isSPACE|char ch Returns a boolean indicating whether the specified character is a whitespace character in the platform's native character set. This is the same as what C<\s> matches in a regular expression. See the L for an explanation of variants C and C. =for apidoc Am|bool|isUPPER|char ch Returns a boolean indicating whether the specified character is an uppercase character in the platform's native character set. See the L for an explanation of variants C and C. =for apidoc Am|bool|isWORDCHAR|char ch Returns a boolean indicating whether the specified character is a character that is any of: alphabetic, numeric, or an underscore. This is the same as what C<\w> matches in a regular expression. C is a synonym provided for backward compatibility. Note that it does not have the standard C language meaning of alphanumeric, since it matches an underscore and the standard meaning does not. See the L for an explanation of variants C and C. =for apidoc Am|bool|isXDIGIT|char ch Returns a boolean indicating whether the specified character is a hexadecimal digit, [0-9A-Fa-f]. Variants C and C are identical to C. =head1 Character case changing =for apidoc Am|char|toUPPER|char ch Converts the specified character to uppercase in the platform's native character set, if possible; otherwise returns the input character itself. =for apidoc Am|char|toLOWER|char ch Converts the specified character to lowercase in the platform's native character set, if possible; otherwise returns the input character itself. =cut Note that these macros are repeated in Devel::PPPort, so should also be patched there. The file as of this writing is cpan/Devel-PPPort/parts/inc/misc */ /* Specify the widest unsigned type on the platform. Use U64TYPE because U64 * is known only in the perl core, and this macro can be called from outside * that */ #ifdef HAS_QUAD # define WIDEST_UTYPE U64TYPE #else # define WIDEST_UTYPE U32 #endif /* FITS_IN_8_BITS(c) returns true if c doesn't have a bit set other than in * the lower 8. It is designed to be hopefully bomb-proof, making sure that no * bits of information are lost even on a 64-bit machine, but to get the * compiler to optimize it out if possible. This is because Configure makes * sure that the machine has an 8-bit byte, so if c is stored in a byte, the * sizeof() guarantees that this evaluates to a constant true at compile time. */ #define FITS_IN_8_BITS(c) ((sizeof(c) == 1) || !(((WIDEST_UTYPE)(c)) & ~0xFF)) #ifdef EBCDIC # define isASCII(c) (FITS_IN_8_BITS(c) && (NATIVE_TO_UNI((U8) (c)) < 128)) #else # define isASCII(c) ((WIDEST_UTYPE)(c) < 128) #endif #define isASCII_A(c) isASCII(c) #define isASCII_L1(c) isASCII(c) /* ASCII range only */ #ifdef H_PERL /* If have access to perl.h, lookup in its table */ /* Bits for PL_charclass[]. These use names used in l1_char_class_tab.h but * their actual definitions are here. If that has a name not used here, it * won't compile. */ # define _CC_ALNUMC_A (1<<0) # define _CC_ALNUMC_L1 (1<<1) # define _CC_ALPHA_A (1<<2) # define _CC_ALPHA_L1 (1<<3) # define _CC_BLANK_A (1<<4) # define _CC_BLANK_L1 (1<<5) # define _CC_CHARNAME_CONT (1<<6) # define _CC_CNTRL_A (1<<7) # define _CC_CNTRL_L1 (1<<8) # define _CC_DIGIT_A (1<<9) # define _CC_GRAPH_A (1<<10) # define _CC_GRAPH_L1 (1<<11) # define _CC_IDFIRST_A (1<<12) # define _CC_IDFIRST_L1 (1<<13) # define _CC_LOWER_A (1<<14) # define _CC_LOWER_L1 (1<<15) # define _CC_OCTAL_A (1<<16) # define _CC_PRINT_A (1<<17) # define _CC_PRINT_L1 (1<<18) # define _CC_PSXSPC_A (1<<19) # define _CC_PSXSPC_L1 (1<<20) # define _CC_PUNCT_A (1<<21) # define _CC_PUNCT_L1 (1<<22) # define _CC_SPACE_A (1<<23) # define _CC_SPACE_L1 (1<<24) # define _CC_UPPER_A (1<<25) # define _CC_UPPER_L1 (1<<26) # define _CC_WORDCHAR_A (1<<27) # define _CC_WORDCHAR_L1 (1<<28) # define _CC_XDIGIT_A (1<<29) # define _CC_NONLATIN1_FOLD (1<<30) # define _CC_QUOTEMETA (1U<<31) /* 1U keeps Solaris from griping */ /* Unused: None * If more are needed, can give up some of the above. The first ones to go * would be those that require just two tests to verify, either there are two * code points, like BLANK_A, or occupy a single range like OCTAL_A, DIGIT_A, * UPPER_A, and LOWER_A. */ # ifdef DOINIT EXTCONST U32 PL_charclass[] = { # include "l1_char_class_tab.h" }; # else /* ! DOINIT */ EXTCONST U32 PL_charclass[]; # endif # define isALNUMC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_A)) # define isALPHA_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_A)) # define isBLANK_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_A)) # define isCNTRL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_A)) # define isDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_DIGIT_A)) # define isGRAPH_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_A)) # define isIDFIRST_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_A)) # define isLOWER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_A)) # define isOCTAL_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_OCTAL_A)) # define isPRINT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_A)) # define isPSXSPC_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_A)) # define isPUNCT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_A)) # define isSPACE_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_A)) # define isUPPER_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_A)) # define isWORDCHAR_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_A)) # define isXDIGIT_A(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_XDIGIT_A)) /* Either participates in a fold with a character above 255, or is a * multi-char fold */ # define _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(c) ((! cBOOL(FITS_IN_8_BITS(c))) || (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_NONLATIN1_FOLD)) # define _isQUOTEMETA(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_QUOTEMETA)) #else /* No perl.h. */ # define isOCTAL_A(c) ((c) <= '7' && (c) >= '0') # ifdef EBCDIC # define isALNUMC_A(c) (isASCII(c) && isALNUMC(c)) # define isALPHA_A(c) (isASCII(c) && isALPHA(c)) # define isBLANK_A(c) (isASCII(c) && isBLANK(c)) # define isCNTRL_A(c) (isASCII(c) && isCNTRL(c)) # define isDIGIT_A(c) (isASCII(c) && isDIGIT(c)) # define isGRAPH_A(c) (isASCII(c) && isGRAPH(c)) # define isIDFIRST_A(c) (isASCII(c) && isIDFIRST(c)) # define isLOWER_A(c) (isASCII(c) && isLOWER(c)) # define isPRINT_A(c) (isASCII(c) && isPRINT(c)) # define isPSXSPC_A(c) (isASCII(c) && isPSXSPC(c)) # define isPUNCT_A(c) (isASCII(c) && isPUNCT(c)) # define isSPACE_A(c) (isASCII(c) && isSPACE(c)) # define isUPPER_A(c) (isASCII(c) && isUPPER(c)) # define isWORDCHAR_A(c) (isASCII(c) && isWORDCHAR(c)) # define isXDIGIT_A(c) (isASCII(c) && isXDIGIT(c)) # else /* ASCII platform, no perl.h */ # define isALNUMC_A(c) (isALPHA_A(c) || isDIGIT_A(c)) # define isALPHA_A(c) (isUPPER_A(c) || isLOWER_A(c)) # define isBLANK_A(c) ((c) == ' ' || (c) == '\t') # define isCNTRL_A(c) (FITS_IN_8_BITS(c) && ((U8) (c) < ' ' || (c) == 127)) # define isDIGIT_A(c) ((c) <= '9' && (c) >= '0') # define isGRAPH_A(c) (isWORDCHAR_A(c) || isPUNCT_A(c)) # define isIDFIRST_A(c) (isALPHA_A(c) || (c) == '_') # define isLOWER_A(c) ((c) >= 'a' && (c) <= 'z') # define isPRINT_A(c) (((c) >= 32 && (c) < 127)) # define isPSXSPC_A(c) (isSPACE_A(c) || (c) == '\v') # define isPUNCT_A(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126)) # define isSPACE_A(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) =='\r' || (c) == '\f') # define isUPPER_A(c) ((c) <= 'Z' && (c) >= 'A') # define isWORDCHAR_A(c) (isALPHA_A(c) || isDIGIT_A(c) || (c) == '_') # define isXDIGIT_A(c) (isDIGIT_A(c) || ((c) >= 'a' && (c) <= 'f') || ((c) <= 'F' && (c) >= 'A')) # endif #endif /* ASCII range definitions */ /* Latin1 definitions */ #ifdef H_PERL # define isALNUMC_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALNUMC_L1)) # define isALPHA_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_ALPHA_L1)) # define isBLANK_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_BLANK_L1)) /* continuation character for legal NAME in \N{NAME} */ # define isCHARNAME_CONT(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CHARNAME_CONT)) # define isCNTRL_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_CNTRL_L1)) # define isGRAPH_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_GRAPH_L1)) # define isIDFIRST_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_IDFIRST_L1)) # define isLOWER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_LOWER_L1)) # define isPRINT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PRINT_L1)) # define isPSXSPC_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PSXSPC_L1)) # define isPUNCT_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_PUNCT_L1)) # define isSPACE_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_SPACE_L1)) # define isUPPER_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_UPPER_L1)) # define isWORDCHAR_L1(c) cBOOL(FITS_IN_8_BITS(c) && (PL_charclass[(U8) NATIVE_TO_UNI(c)] & _CC_WORDCHAR_L1)) #else /* No access to perl.h. Only a few provided here, just in case needed * for backwards compatibility */ /* ALPHAU includes Unicode semantics for latin1 characters. It has an extra * >= AA test to speed up ASCII-only tests at the expense of the others */ # define isALPHA_L1(c) (isALPHA(c) || (NATIVE_TO_UNI((U8) c) >= 0xAA \ && ((NATIVE_TO_UNI((U8) c) >= 0xC0 \ && NATIVE_TO_UNI((U8) c) != 0xD7 && NATIVE_TO_UNI((U8) c) != 0xF7) \ || NATIVE_TO_UNI((U8) c) == 0xAA \ || NATIVE_TO_UNI((U8) c) == 0xB5 \ || NATIVE_TO_UNI((U8) c) == 0xBA))) # define isCHARNAME_CONT(c) (isALNUM_L1(c) || (c) == ' ' || (c) == '-' || (c) == '(' || (c) == ')' || (c) == ':' || NATIVE_TO_UNI((U8) c) == 0xA0) #endif /* Macros for backwards compatibility and for completeness when the ASCII and * Latin1 values are identical */ #define isALNUM(c) isWORDCHAR(c) #define isALNUMU(c) isWORDCHAR_L1(c) #define isALPHAU(c) isALPHA_L1(c) #define isDIGIT_L1(c) isDIGIT_A(c) #define isOCTAL(c) isOCTAL_A(c) #define isOCTAL_L1(c) isOCTAL_A(c) #define isXDIGIT_L1(c) isXDIGIT_A(c) /* Macros that differ between EBCDIC and ASCII. Where C89 defines a function, * that is used in the EBCDIC form, because in EBCDIC we do not do locales: * therefore can use native functions. For those where C89 doesn't define a * function, use our function, assuming that the EBCDIC code page is isomorphic * with Latin1, which the three currently recognized by Perl are. Some libc's * have an isblank(), but it's not guaranteed. */ #ifdef EBCDIC # define isALNUMC(c) isalnum(c) # define isALPHA(c) isalpha(c) # define isBLANK(c) ((c) == ' ' || (c) == '\t' || NATIVE_TO_UNI(c) == 0xA0) # define isCNTRL(c) iscntrl(c) # define isDIGIT(c) isdigit(c) # define isGRAPH(c) isgraph(c) # define isIDFIRST(c) (isALPHA(c) || (c) == '_') # define isLOWER(c) islower(c) # define isPRINT(c) isprint(c) # define isPSXSPC(c) isspace(c) # define isPUNCT(c) ispunct(c) # define isSPACE(c) (isPSXSPC(c) && (c) != '\v') # define isUPPER(c) isupper(c) # define isXDIGIT(c) isxdigit(c) # define isWORDCHAR(c) (isalnum(c) || (c) == '_') # define toLOWER(c) tolower(c) # define toUPPER(c) toupper(c) #else /* Not EBCDIC: ASCII-only matching */ # define isALNUMC(c) isALNUMC_A(c) # define isALPHA(c) isALPHA_A(c) # define isBLANK(c) isBLANK_A(c) # define isCNTRL(c) isCNTRL_A(c) # define isDIGIT(c) isDIGIT_A(c) # define isGRAPH(c) isGRAPH_A(c) # define isIDFIRST(c) isIDFIRST_A(c) # define isLOWER(c) isLOWER_A(c) # define isPRINT(c) isPRINT_A(c) # define isPSXSPC(c) isPSXSPC_A(c) # define isPUNCT(c) isPUNCT_A(c) # define isSPACE(c) isSPACE_A(c) # define isUPPER(c) isUPPER_A(c) # define isWORDCHAR(c) isWORDCHAR_A(c) # define isXDIGIT(c) isXDIGIT_A(c) /* ASCII casing. These could also be written as #define toLOWER(c) (isASCII(c) ? toLOWER_LATIN1(c) : (c)) #define toUPPER(c) (isASCII(c) ? toUPPER_LATIN1_MOD(c) : (c)) which uses table lookup and mask instead of subtraction. (This would work because the _MOD does not apply in the ASCII range) */ # define toLOWER(c) (isUPPER(c) ? (c) + ('a' - 'A') : (c)) # define toUPPER(c) (isLOWER(c) ? (c) - ('a' - 'A') : (c)) #endif /* Use table lookup for speed; return error character for input * out-of-range */ #define toLOWER_LATIN1(c) (FITS_IN_8_BITS(c) \ ? UNI_TO_NATIVE(PL_latin1_lc[ \ NATIVE_TO_UNI( (U8) (c)) ]) \ : UNICODE_REPLACEMENT) /* Modified uc. Is correct uc except for three non-ascii chars which are * all mapped to one of them, and these need special handling; error * character for input out-of-range */ #define toUPPER_LATIN1_MOD(c) (FITS_IN_8_BITS(c) \ ? UNI_TO_NATIVE(PL_mod_latin1_uc[ \ NATIVE_TO_UNI( (U8) (c)) ]) \ : UNICODE_REPLACEMENT) #ifdef USE_NEXT_CTYPE # define isALNUM_LC(c) \ (NXIsAlNum((unsigned int)(c)) || (char)(c) == '_') # define isIDFIRST_LC(c) \ (NXIsAlpha((unsigned int)(c)) || (char)(c) == '_') # define isALPHA_LC(c) NXIsAlpha((unsigned int)(c)) # define isASCII_LC(c) isASCII((unsigned int)(c)) # define isBLANK_LC(c) isBLANK((unsigned int)(c)) # define isSPACE_LC(c) NXIsSpace((unsigned int)(c)) # define isDIGIT_LC(c) NXIsDigit((unsigned int)(c)) # define isUPPER_LC(c) NXIsUpper((unsigned int)(c)) # define isLOWER_LC(c) NXIsLower((unsigned int)(c)) # define isALNUMC_LC(c) NXIsAlNum((unsigned int)(c)) # define isCNTRL_LC(c) NXIsCntrl((unsigned int)(c)) # define isGRAPH_LC(c) NXIsGraph((unsigned int)(c)) # define isPRINT_LC(c) NXIsPrint((unsigned int)(c)) # define isPUNCT_LC(c) NXIsPunct((unsigned int)(c)) # define toUPPER_LC(c) NXToUpper((unsigned int)(c)) # define toLOWER_LC(c) NXToLower((unsigned int)(c)) #else /* !USE_NEXT_CTYPE */ # if defined(CTYPE256) || (!defined(isascii) && !defined(HAS_ISASCII)) /* Note that the foo_LC() macros in this case generally are defined only on * code points 0-256, and give undefined, unwarned results if called with * values outside that range */ # define isALNUM_LC(c) (isalnum((unsigned char)(c)) || (char)(c) == '_') # define isIDFIRST_LC(c) (isalpha((unsigned char)(c)) || (char)(c) == '_') # define isALPHA_LC(c) isalpha((unsigned char)(c)) # ifdef HAS_ISASCII # define isASCII_LC(c) isascii((unsigned char)(c)) # else # define isASCII_LC(c) isASCII((unsigned char)(c)) # endif # ifdef HAS_ISBLANK # define isBLANK_LC(c) isblank((unsigned char)(c)) # else # define isBLANK_LC(c) isBLANK((unsigned char)(c)) # endif # define isSPACE_LC(c) isspace((unsigned char)(c)) # define isDIGIT_LC(c) isdigit((unsigned char)(c)) # define isUPPER_LC(c) isupper((unsigned char)(c)) # define isLOWER_LC(c) islower((unsigned char)(c)) # define isALNUMC_LC(c) isalnum((unsigned char)(c)) # define isCNTRL_LC(c) iscntrl((unsigned char)(c)) # define isGRAPH_LC(c) isgraph((unsigned char)(c)) # define isPRINT_LC(c) isprint((unsigned char)(c)) # define isPUNCT_LC(c) ispunct((unsigned char)(c)) # define toUPPER_LC(c) toupper((unsigned char)(c)) # define toLOWER_LC(c) tolower((unsigned char)(c)) # else # define isALNUM_LC(c) (isascii(c) && (isalnum(c) || (c) == '_')) # define isIDFIRST_LC(c) (isascii(c) && (isalpha(c) || (c) == '_')) # define isALPHA_LC(c) (isascii(c) && isalpha(c)) # define isASCII_LC(c) isascii(c) # ifdef HAS_ISBLANK # define isBLANK_LC(c) (isascii(c) && isblank(c)) # else # define isBLANK_LC(c) isBLANK(c) # endif # define isSPACE_LC(c) (isascii(c) && isspace(c)) # define isDIGIT_LC(c) (isascii(c) && isdigit(c)) # define isUPPER_LC(c) (isascii(c) && isupper(c)) # define isLOWER_LC(c) (isascii(c) && islower(c)) # define isALNUMC_LC(c) (isascii(c) && isalnum(c)) # define isCNTRL_LC(c) (isascii(c) && iscntrl(c)) # define isGRAPH_LC(c) (isascii(c) && isgraph(c)) # define isPRINT_LC(c) (isascii(c) && isprint(c)) # define isPUNCT_LC(c) (isascii(c) && ispunct(c)) # define toUPPER_LC(c) toupper(c) # define toLOWER_LC(c) tolower(c) # endif #endif /* USE_NEXT_CTYPE */ #define isPSXSPC_LC(c) (isSPACE_LC(c) || (c) == '\v') /* For use in the macros just below. If the input is Latin1, use the Latin1 * (_L1) version of the macro; otherwise use the function. Won't compile if * 'c' isn't unsigned, as won't match function prototype. The macros do bounds * checking, so have duplicate checks here, so could create versions of the * macros that don't, but experiments show that gcc optimizes them out anyway. */ #define generic_uni(macro, function, c) ((c) < 256 \ ? CAT2(macro, _L1)(c) \ : function(c)) /* Note that all ignore 'use bytes' */ #define isALNUM_uni(c) generic_uni(isWORDCHAR, is_uni_alnum, c) #define isIDFIRST_uni(c) generic_uni(isIDFIRST, is_uni_idfirst, c) #define isALPHA_uni(c) generic_uni(isALPHA, is_uni_alpha, c) #define isSPACE_uni(c) generic_uni(isSPACE, is_uni_space, c) #define isDIGIT_uni(c) generic_uni(isDIGIT, is_uni_digit, c) #define isUPPER_uni(c) generic_uni(isUPPER, is_uni_upper, c) #define isLOWER_uni(c) generic_uni(isLOWER, is_uni_lower, c) #define isASCII_uni(c) isASCII(c) /* All controls are in Latin1 */ #define isCNTRL_uni(c) ((c) < 256 && isCNTRL_L1(c)) #define isGRAPH_uni(c) generic_uni(isGRAPH, is_uni_graph, c) #define isPRINT_uni(c) generic_uni(isPRINT, is_uni_print, c) #define isPUNCT_uni(c) generic_uni(isPUNCT, is_uni_punct, c) #define isXDIGIT_uni(c) generic_uni(isXDIGIT, is_uni_xdigit, c) #define toUPPER_uni(c,s,l) to_uni_upper(c,s,l) #define toTITLE_uni(c,s,l) to_uni_title(c,s,l) #define toLOWER_uni(c,s,l) to_uni_lower(c,s,l) #define toFOLD_uni(c,s,l) to_uni_fold(c,s,l) /* Posix and regular space differ only in U+000B, which is in Latin1 */ #define isPSXSPC_uni(c) ((c) < 256 ? isPSXSPC_L1(c) : isSPACE_uni(c)) #define isBLANK_uni(c) isBLANK(c) /* could be wrong */ #define isALNUM_LC_uvchr(c) (c < 256 ? isALNUM_LC(c) : is_uni_alnum_lc(c)) #define isIDFIRST_LC_uvchr(c) (c < 256 ? isIDFIRST_LC(c) : is_uni_idfirst_lc(c)) #define isALPHA_LC_uvchr(c) (c < 256 ? isALPHA_LC(c) : is_uni_alpha_lc(c)) #define isSPACE_LC_uvchr(c) (c < 256 ? isSPACE_LC(c) : is_uni_space_lc(c)) #define isDIGIT_LC_uvchr(c) (c < 256 ? isDIGIT_LC(c) : is_uni_digit_lc(c)) #define isUPPER_LC_uvchr(c) (c < 256 ? isUPPER_LC(c) : is_uni_upper_lc(c)) #define isLOWER_LC_uvchr(c) (c < 256 ? isLOWER_LC(c) : is_uni_lower_lc(c)) #define isCNTRL_LC_uvchr(c) (c < 256 ? isCNTRL_LC(c) : is_uni_cntrl_lc(c)) #define isGRAPH_LC_uvchr(c) (c < 256 ? isGRAPH_LC(c) : is_uni_graph_lc(c)) #define isPRINT_LC_uvchr(c) (c < 256 ? isPRINT_LC(c) : is_uni_print_lc(c)) #define isPUNCT_LC_uvchr(c) (c < 256 ? isPUNCT_LC(c) : is_uni_punct_lc(c)) #define isPSXSPC_LC_uni(c) (isSPACE_LC_uni(c) ||(c) == '\f') #define isBLANK_LC_uni(c) isBLANK(c) /* could be wrong */ /* For use in the macros just below. If the input is ASCII, use the ASCII (_A) * version of the macro; if the input is in the upper Latin1 range, use the * Latin1 (_L1) version of the macro, after converting from utf8; otherwise use * the function. This relies on the fact that ASCII characters have the same * representation whether utf8 or not */ #define generic_utf8(macro, function, p) (isASCII(*(p)) \ ? CAT2(CAT2(macro,_),A)(*(p)) \ : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ ? CAT2(macro, _L1) \ (TWO_BYTE_UTF8_TO_UNI(*(p), \ *((p)+1))) \ : function(p)) /* Note that all assume that the utf8 has been validated, and ignore 'use * bytes' */ #define isALNUM_utf8(p) generic_utf8(isWORDCHAR, is_utf8_alnum, p) /* To prevent S_scan_word in toke.c from hanging, we have to make sure that * IDFIRST is an alnum. See * http://rt.perl.org/rt3/Ticket/Display.html?id=74022 for more detail than you * ever wanted to know about. XXX It is unclear if this should extend to * isIDFIRST_uni() which it hasn't so far. (In the ASCII range, there isn't a * difference.) This used to be not the XID version, but we decided to go with * the more modern Unicode definition */ #define isIDFIRST_utf8(p) (isASCII(*(p)) \ ? isIDFIRST_A(*(p)) \ : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ ? isIDFIRST_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \ *((p)+1)))\ : Perl__is_utf8__perl_idstart(aTHX_ p)) #define isIDCONT_utf8(p) generic_utf8(isWORDCHAR, is_utf8_xidcont, p) #define isALPHA_utf8(p) generic_utf8(isALPHA, is_utf8_alpha, p) #define isSPACE_utf8(p) generic_utf8(isSPACE, is_utf8_space, p) #define isDIGIT_utf8(p) generic_utf8(isDIGIT, is_utf8_digit, p) #define isUPPER_utf8(p) generic_utf8(isUPPER, is_utf8_upper, p) #define isLOWER_utf8(p) generic_utf8(isLOWER, is_utf8_lower, p) /* Because ASCII is invariant under utf8, the non-utf8 macro works */ #define isASCII_utf8(p) isASCII(p) #define isCNTRL_utf8(p) generic_utf8(isCNTRL, is_utf8_cntrl, p) #define isGRAPH_utf8(p) generic_utf8(isGRAPH, is_utf8_graph, p) #define isPRINT_utf8(p) generic_utf8(isPRINT, is_utf8_print, p) #define isPUNCT_utf8(p) generic_utf8(isPUNCT, is_utf8_punct, p) #define isXDIGIT_utf8(p) generic_utf8(isXDIGIT, is_utf8_xdigit, p) #define toUPPER_utf8(p,s,l) to_utf8_upper(p,s,l) #define toTITLE_utf8(p,s,l) to_utf8_title(p,s,l) #define toLOWER_utf8(p,s,l) to_utf8_lower(p,s,l) /* Posix and regular space differ only in U+000B, which is in ASCII (and hence * Latin1 */ #define isPSXSPC_utf8(p) ((isASCII(*(p))) \ ? isPSXSPC_A(*(p)) \ : (UTF8_IS_DOWNGRADEABLE_START(*(p)) \ ? isPSXSPC_L1(TWO_BYTE_UTF8_TO_UNI(*(p), \ *((p)+1)))\ : isSPACE_utf8(p))) #define isBLANK_utf8(c) isBLANK(c) /* could be wrong */ #define isALNUM_LC_utf8(p) isALNUM_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isIDFIRST_LC_utf8(p) isIDFIRST_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isALPHA_LC_utf8(p) isALPHA_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isSPACE_LC_utf8(p) isSPACE_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isDIGIT_LC_utf8(p) isDIGIT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isUPPER_LC_utf8(p) isUPPER_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isLOWER_LC_utf8(p) isLOWER_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isALNUMC_LC_utf8(p) isALNUMC_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isCNTRL_LC_utf8(p) isCNTRL_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isGRAPH_LC_utf8(p) isGRAPH_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isPRINT_LC_utf8(p) isPRINT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isPUNCT_LC_utf8(p) isPUNCT_LC_uvchr(valid_utf8_to_uvchr(p, 0)) #define isPSXSPC_LC_utf8(c) (isSPACE_LC_utf8(c) ||(c) == '\f') #define isBLANK_LC_utf8(c) isBLANK(c) /* could be wrong */ /* This conversion works both ways, strangely enough. On EBCDIC platforms, * CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII */ # define toCTRL(c) (toUPPER(NATIVE_TO_UNI(c)) ^ 64) /* Line numbers are unsigned, 32 bits. */ typedef U32 line_t; #define NOLINE ((line_t) 4294967295UL) /* Helpful alias for version prescan */ #define is_LAX_VERSION(a,b) \ (a != Perl_prescan_version(aTHX_ a, FALSE, b, NULL, NULL, NULL, NULL)) #define is_STRICT_VERSION(a,b) \ (a != Perl_prescan_version(aTHX_ a, TRUE, b, NULL, NULL, NULL, NULL)) #define BADVERSION(a,b,c) \ if (b) { \ *b = c; \ } \ return a; /* =head1 Memory Management =for apidoc Am|void|Newx|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. In 5.9.3, Newx() and friends replace the older New() API, and drops the first parameter, I, a debug aid which allowed callers to identify themselves. This aid has been superseded by a new build option, PERL_MEM_LOG (see L). The older API is still there for use in XS modules supporting older perls. =for apidoc Am|void|Newxc|void* ptr|int nitems|type|cast The XSUB-writer's interface to the C C function, with cast. See also C. =for apidoc Am|void|Newxz|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. The allocated memory is zeroed with C. See also C. =for apidoc Am|void|Renew|void* ptr|int nitems|type The XSUB-writer's interface to the C C function. =for apidoc Am|void|Renewc|void* ptr|int nitems|type|cast The XSUB-writer's interface to the C C function, with cast. =for apidoc Am|void|Safefree|void* ptr The XSUB-writer's interface to the C C function. =for apidoc Am|void|Move|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C function. The C is the source, C is the destination, C is the number of items, and C is the type. Can do overlapping moves. See also C. =for apidoc Am|void *|MoveD|void* src|void* dest|int nitems|type Like C but returns dest. Useful for encouraging compilers to tail-call optimise. =for apidoc Am|void|Copy|void* src|void* dest|int nitems|type The XSUB-writer's interface to the C C function. The C is the source, C is the destination, C is the number of items, and C is the type. May fail on overlapping copies. See also C. =for apidoc Am|void *|CopyD|void* src|void* dest|int nitems|type Like C but returns dest. Useful for encouraging compilers to tail-call optimise. =for apidoc Am|void|Zero|void* dest|int nitems|type The XSUB-writer's interface to the C C function. The C is the destination, C is the number of items, and C is the type. =for apidoc Am|void *|ZeroD|void* dest|int nitems|type Like C but returns dest. Useful for encouraging compilers to tail-call optimise. =for apidoc Am|void|StructCopy|type src|type dest|type This is an architecture-independent macro to copy one structure to another. =for apidoc Am|void|PoisonWith|void* dest|int nitems|type|U8 byte Fill up memory with a byte pattern (a byte repeated over and over again) that hopefully catches attempts to access uninitialized memory. =for apidoc Am|void|PoisonNew|void* dest|int nitems|type PoisonWith(0xAB) for catching access to allocated but uninitialized memory. =for apidoc Am|void|PoisonFree|void* dest|int nitems|type PoisonWith(0xEF) for catching access to freed memory. =for apidoc Am|void|Poison|void* dest|int nitems|type PoisonWith(0xEF) for catching access to freed memory. =cut */ /* Maintained for backwards-compatibility only. Use newSV() instead. */ #ifndef PERL_CORE #define NEWSV(x,len) newSV(len) #endif #define MEM_SIZE_MAX ((MEM_SIZE)~0) /* The +0.0 in MEM_WRAP_CHECK_ is an attempt to foil * overly eager compilers that will bleat about e.g. * (U16)n > (size_t)~0/sizeof(U16) always being false. */ #ifdef PERL_MALLOC_WRAP #define MEM_WRAP_CHECK(n,t) MEM_WRAP_CHECK_1(n,t,PL_memory_wrap) #define MEM_WRAP_CHECK_1(n,t,a) \ (void)(sizeof(t) > 1 && ((MEM_SIZE)(n)+0.0) > MEM_SIZE_MAX/sizeof(t) && (Perl_croak_nocontext("%s",(a)),0)) #define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t), #define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (Perl_croak_nocontext("%s",PL_memory_wrap),0):0),((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1))) #else #define MEM_WRAP_CHECK(n,t) #define MEM_WRAP_CHECK_1(n,t,a) #define MEM_WRAP_CHECK_2(n,t,a,b) #define MEM_WRAP_CHECK_(n,t) #define PERL_STRLEN_ROUNDUP(n) (((n-1+PERL_STRLEN_ROUNDUP_QUANTUM)&~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM-1))) #endif #ifdef PERL_MEM_LOG /* * If PERL_MEM_LOG is defined, all Newx()s, Renew()s, and Safefree()s * go through functions, which are handy for debugging breakpoints, but * which more importantly get the immediate calling environment (file and * line number, and C function name if available) passed in. This info can * then be used for logging the calls, for which one gets a sample * implementation unless -DPERL_MEM_LOG_NOIMPL is also defined. * * Known problems: * - not all memory allocs get logged, only those * that go through Newx() and derivatives (while all * Safefrees do get logged) * - __FILE__ and __LINE__ do not work everywhere * - __func__ or __FUNCTION__ even less so * - I think more goes on after the perlio frees but * the thing is that STDERR gets closed (as do all * the file descriptors) * - no deeper calling stack than the caller of the Newx() * or the kind, but do I look like a C reflection/introspection * utility to you? * - the function prototypes for the logging functions * probably should maybe be somewhere else than handy.h * - one could consider inlining (macrofying) the logging * for speed, but I am too lazy * - one could imagine recording the allocations in a hash, * (keyed by the allocation address?), and maintain that * through reallocs and frees, but how to do that without * any News() happening...? * - lots of -Ddefines to get useful/controllable output * - lots of ENV reads */ PERL_EXPORT_C Malloc_t Perl_mem_log_alloc(const UV n, const UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); PERL_EXPORT_C Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); PERL_EXPORT_C Malloc_t Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); # ifdef PERL_CORE # ifndef PERL_MEM_LOG_NOIMPL enum mem_log_type { MLT_ALLOC, MLT_REALLOC, MLT_FREE, MLT_NEW_SV, MLT_DEL_SV }; # endif # if defined(PERL_IN_SV_C) /* those are only used in sv.c */ void Perl_mem_log_new_sv(const SV *sv, const char *filename, const int linenumber, const char *funcname); void Perl_mem_log_del_sv(const SV *sv, const char *filename, const int linenumber, const char *funcname); # endif # endif #endif #ifdef PERL_MEM_LOG #define MEM_LOG_ALLOC(n,t,a) Perl_mem_log_alloc(n,sizeof(t),STRINGIFY(t),a,__FILE__,__LINE__,FUNCTION__) #define MEM_LOG_REALLOC(n,t,v,a) Perl_mem_log_realloc(n,sizeof(t),STRINGIFY(t),v,a,__FILE__,__LINE__,FUNCTION__) #define MEM_LOG_FREE(a) Perl_mem_log_free(a,__FILE__,__LINE__,FUNCTION__) #endif #ifndef MEM_LOG_ALLOC #define MEM_LOG_ALLOC(n,t,a) (a) #endif #ifndef MEM_LOG_REALLOC #define MEM_LOG_REALLOC(n,t,v,a) (a) #endif #ifndef MEM_LOG_FREE #define MEM_LOG_FREE(a) (a) #endif #define Newx(v,n,t) (v = (MEM_WRAP_CHECK_(n,t) (t*)MEM_LOG_ALLOC(n,t,safemalloc((MEM_SIZE)((n)*sizeof(t)))))) #define Newxc(v,n,t,c) (v = (MEM_WRAP_CHECK_(n,t) (c*)MEM_LOG_ALLOC(n,t,safemalloc((MEM_SIZE)((n)*sizeof(t)))))) #define Newxz(v,n,t) (v = (MEM_WRAP_CHECK_(n,t) (t*)MEM_LOG_ALLOC(n,t,safecalloc((n),sizeof(t))))) #ifndef PERL_CORE /* pre 5.9.x compatibility */ #define New(x,v,n,t) Newx(v,n,t) #define Newc(x,v,n,t,c) Newxc(v,n,t,c) #define Newz(x,v,n,t) Newxz(v,n,t) #endif #define Renew(v,n,t) \ (v = (MEM_WRAP_CHECK_(n,t) (t*)MEM_LOG_REALLOC(n,t,v,saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t)))))) #define Renewc(v,n,t,c) \ (v = (MEM_WRAP_CHECK_(n,t) (c*)MEM_LOG_REALLOC(n,t,v,saferealloc((Malloc_t)(v),(MEM_SIZE)((n)*sizeof(t)))))) #ifdef PERL_POISON #define Safefree(d) \ ((d) ? (void)(safefree(MEM_LOG_FREE((Malloc_t)(d))), Poison(&(d), 1, Malloc_t)) : (void) 0) #else #define Safefree(d) safefree(MEM_LOG_FREE((Malloc_t)(d))) #endif #define Move(s,d,n,t) (MEM_WRAP_CHECK_(n,t) (void)memmove((char*)(d),(const char*)(s), (n) * sizeof(t))) #define Copy(s,d,n,t) (MEM_WRAP_CHECK_(n,t) (void)memcpy((char*)(d),(const char*)(s), (n) * sizeof(t))) #define Zero(d,n,t) (MEM_WRAP_CHECK_(n,t) (void)memzero((char*)(d), (n) * sizeof(t))) #define MoveD(s,d,n,t) (MEM_WRAP_CHECK_(n,t) memmove((char*)(d),(const char*)(s), (n) * sizeof(t))) #define CopyD(s,d,n,t) (MEM_WRAP_CHECK_(n,t) memcpy((char*)(d),(const char*)(s), (n) * sizeof(t))) #ifdef HAS_MEMSET #define ZeroD(d,n,t) (MEM_WRAP_CHECK_(n,t) memzero((char*)(d), (n) * sizeof(t))) #else /* Using bzero(), which returns void. */ #define ZeroD(d,n,t) (MEM_WRAP_CHECK_(n,t) memzero((char*)(d), (n) * sizeof(t)),d) #endif #define PoisonWith(d,n,t,b) (MEM_WRAP_CHECK_(n,t) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))) #define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) #define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) #define Poison(d,n,t) PoisonFree(d,n,t) #ifdef USE_STRUCT_COPY #define StructCopy(s,d,t) (*((t*)(d)) = *((t*)(s))) #else #define StructCopy(s,d,t) Copy(s,d,1,t) #endif #define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) #define C_ARRAY_END(a) (a) + (sizeof(a)/sizeof((a)[0])) #ifdef NEED_VA_COPY # ifdef va_copy # define Perl_va_copy(s, d) va_copy(d, s) # else # if defined(__va_copy) # define Perl_va_copy(s, d) __va_copy(d, s) # else # define Perl_va_copy(s, d) Copy(s, d, 1, va_list) # endif # endif #endif /* convenience debug macros */ #ifdef USE_ITHREADS #define pTHX_FORMAT "Perl interpreter: 0x%p" #define pTHX__FORMAT ", Perl interpreter: 0x%p" #define pTHX_VALUE_ (void *)my_perl, #define pTHX_VALUE (void *)my_perl #define pTHX__VALUE_ ,(void *)my_perl, #define pTHX__VALUE ,(void *)my_perl #else #define pTHX_FORMAT #define pTHX__FORMAT #define pTHX_VALUE_ #define pTHX_VALUE #define pTHX__VALUE_ #define pTHX__VALUE #endif /* USE_ITHREADS */ /* Perl_deprecate was not part of the public API, and did not have a deprecate() shortcut macro defined without -DPERL_CORE. Neither codesearch.google.com nor CPAN::Unpack show any users outside the core. */ #ifdef PERL_CORE # define deprecate(s) Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), "Use of " s " is deprecated") #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZMa iperlsys.hnuW+A/* * iperlsys.h - Perl's interface to the system * * This file defines the system level functionality that perl needs. * * When using C, this definition is in the form of a set of macros * that can be #defined to the system-level function (or a wrapper * provided elsewhere). * * GSAR 21-JUN-98 */ #ifndef __Inc__IPerl___ #define __Inc__IPerl___ /* * PerlXXX_YYY explained - DickH and DougL @ ActiveState.com * * XXX := functional group * YYY := stdlib/OS function name * * Continuing with the theme of PerlIO, all OS functionality was * encapsulated into one of several interfaces. * * PerlIO - stdio * PerlLIO - low level I/O * PerlMem - malloc, realloc, free * PerlDir - directory related * PerlEnv - process environment handling * PerlProc - process control * PerlSock - socket functions * * * The features of this are: * 1. All OS dependant code is in the Perl Host and not the Perl Core. * (At least this is the holy grail goal of this work) * 2. The Perl Host (see perl.h for description) can provide a new and * improved interface to OS functionality if required. * 3. Developers can easily hook into the OS calls for instrumentation * or diagnostic purposes. * * What was changed to do this: * 1. All calls to OS functions were replaced with PerlXXX_YYY * */ /* Interface for perl stdio functions, or whatever we are Configure-d to use. */ #include "perlio.h" #ifndef Sighandler_t # if defined(HAS_SIGACTION) && defined(SA_SIGINFO) typedef Signal_t (*Sighandler_t) (int, siginfo_t*, void*); # else typedef Signal_t (*Sighandler_t) (int); # endif #endif #if defined(PERL_IMPLICIT_SYS) /* IPerlStdIO */ struct IPerlStdIO; struct IPerlStdIOInfo; typedef FILE* (*LPStdin)(struct IPerlStdIO*); typedef FILE* (*LPStdout)(struct IPerlStdIO*); typedef FILE* (*LPStderr)(struct IPerlStdIO*); typedef FILE* (*LPOpen)(struct IPerlStdIO*, const char*, const char*); typedef int (*LPClose)(struct IPerlStdIO*, FILE*); typedef int (*LPEof)(struct IPerlStdIO*, FILE*); typedef int (*LPError)(struct IPerlStdIO*, FILE*); typedef void (*LPClearerr)(struct IPerlStdIO*, FILE*); typedef int (*LPGetc)(struct IPerlStdIO*, FILE*); typedef STDCHAR* (*LPGetBase)(struct IPerlStdIO*, FILE*); typedef int (*LPGetBufsiz)(struct IPerlStdIO*, FILE*); typedef int (*LPGetCnt)(struct IPerlStdIO*, FILE*); typedef STDCHAR* (*LPGetPtr)(struct IPerlStdIO*, FILE*); typedef char* (*LPGets)(struct IPerlStdIO*, char*, int, FILE*); typedef int (*LPPutc)(struct IPerlStdIO*, int, FILE*); typedef int (*LPPuts)(struct IPerlStdIO*, const char *, FILE*); typedef int (*LPFlush)(struct IPerlStdIO*, FILE*); typedef int (*LPUngetc)(struct IPerlStdIO*, int,FILE*); typedef int (*LPFileno)(struct IPerlStdIO*, FILE*); typedef FILE* (*LPFdopen)(struct IPerlStdIO*, int, const char*); typedef FILE* (*LPReopen)(struct IPerlStdIO*, const char*, const char*, FILE*); typedef SSize_t (*LPRead)(struct IPerlStdIO*, void*, Size_t, Size_t, FILE *); typedef SSize_t (*LPWrite)(struct IPerlStdIO*, const void*, Size_t, Size_t, FILE *); typedef void (*LPSetBuf)(struct IPerlStdIO*, FILE*, char*); typedef int (*LPSetVBuf)(struct IPerlStdIO*, FILE*, char*, int, Size_t); typedef void (*LPSetCnt)(struct IPerlStdIO*, FILE*, int); #ifndef NETWARE typedef void (*LPSetPtr)(struct IPerlStdIO*, FILE*, STDCHAR*); #elif defined(NETWARE) typedef void (*LPSetPtr)(struct IPerlStdIO*, FILE*, STDCHAR*, int); #endif typedef void (*LPSetlinebuf)(struct IPerlStdIO*, FILE*); typedef int (*LPPrintf)(struct IPerlStdIO*, FILE*, const char*, ...); typedef int (*LPVprintf)(struct IPerlStdIO*, FILE*, const char*, va_list); typedef Off_t (*LPTell)(struct IPerlStdIO*, FILE*); typedef int (*LPSeek)(struct IPerlStdIO*, FILE*, Off_t, int); typedef void (*LPRewind)(struct IPerlStdIO*, FILE*); typedef FILE* (*LPTmpfile)(struct IPerlStdIO*); typedef int (*LPGetpos)(struct IPerlStdIO*, FILE*, Fpos_t*); typedef int (*LPSetpos)(struct IPerlStdIO*, FILE*, const Fpos_t*); typedef void (*LPInit)(struct IPerlStdIO*); typedef void (*LPInitOSExtras)(struct IPerlStdIO*); typedef FILE* (*LPFdupopen)(struct IPerlStdIO*, FILE*); struct IPerlStdIO { LPStdin pStdin; LPStdout pStdout; LPStderr pStderr; LPOpen pOpen; LPClose pClose; LPEof pEof; LPError pError; LPClearerr pClearerr; LPGetc pGetc; LPGetBase pGetBase; LPGetBufsiz pGetBufsiz; LPGetCnt pGetCnt; LPGetPtr pGetPtr; LPGets pGets; LPPutc pPutc; LPPuts pPuts; LPFlush pFlush; LPUngetc pUngetc; LPFileno pFileno; LPFdopen pFdopen; LPReopen pReopen; LPRead pRead; LPWrite pWrite; LPSetBuf pSetBuf; LPSetVBuf pSetVBuf; LPSetCnt pSetCnt; LPSetPtr pSetPtr; LPSetlinebuf pSetlinebuf; LPPrintf pPrintf; LPVprintf pVprintf; LPTell pTell; LPSeek pSeek; LPRewind pRewind; LPTmpfile pTmpfile; LPGetpos pGetpos; LPSetpos pSetpos; LPInit pInit; LPInitOSExtras pInitOSExtras; LPFdupopen pFdupopen; }; struct IPerlStdIOInfo { unsigned long nCount; /* number of entries expected */ struct IPerlStdIO perlStdIOList; }; /* These do not belong here ... NI-S, 14 Nov 2000 */ #ifdef USE_STDIO_PTR # define PerlSIO_has_cntptr(f) 1 # ifdef STDIO_PTR_LVALUE # ifdef STDIO_CNT_LVALUE # define PerlSIO_canset_cnt(f) 1 # ifdef STDIO_PTR_LVAL_NOCHANGE_CNT # define PerlSIO_fast_gets(f) 1 # endif # else /* STDIO_CNT_LVALUE */ # define PerlSIO_canset_cnt(f) 0 # endif # else /* STDIO_PTR_LVALUE */ # ifdef STDIO_PTR_LVAL_SETS_CNT # define PerlSIO_fast_gets(f) 1 # endif # endif #else /* USE_STDIO_PTR */ # define PerlSIO_has_cntptr(f) 0 # define PerlSIO_canset_cnt(f) 0 #endif /* USE_STDIO_PTR */ #ifndef PerlSIO_fast_gets #define PerlSIO_fast_gets(f) 0 #endif #ifdef FILE_base #define PerlSIO_has_base(f) 1 #else #define PerlSIO_has_base(f) 0 #endif /* Now take FILE * via function table */ #define PerlSIO_stdin \ (*PL_StdIO->pStdin)(PL_StdIO) #define PerlSIO_stdout \ (*PL_StdIO->pStdout)(PL_StdIO) #define PerlSIO_stderr \ (*PL_StdIO->pStderr)(PL_StdIO) #define PerlSIO_fopen(x,y) \ (*PL_StdIO->pOpen)(PL_StdIO, (x),(y)) #define PerlSIO_fclose(f) \ (*PL_StdIO->pClose)(PL_StdIO, (f)) #define PerlSIO_feof(f) \ (*PL_StdIO->pEof)(PL_StdIO, (f)) #define PerlSIO_ferror(f) \ (*PL_StdIO->pError)(PL_StdIO, (f)) #define PerlSIO_clearerr(f) \ (*PL_StdIO->pClearerr)(PL_StdIO, (f)) #define PerlSIO_fgetc(f) \ (*PL_StdIO->pGetc)(PL_StdIO, (f)) #define PerlSIO_get_base(f) \ (*PL_StdIO->pGetBase)(PL_StdIO, (f)) #define PerlSIO_get_bufsiz(f) \ (*PL_StdIO->pGetBufsiz)(PL_StdIO, (f)) #define PerlSIO_get_cnt(f) \ (*PL_StdIO->pGetCnt)(PL_StdIO, (f)) #define PerlSIO_get_ptr(f) \ (*PL_StdIO->pGetPtr)(PL_StdIO, (f)) #define PerlSIO_fputc(c,f) \ (*PL_StdIO->pPutc)(PL_StdIO, (c),(f)) #define PerlSIO_fputs(s,f) \ (*PL_StdIO->pPuts)(PL_StdIO, (s),(f)) #define PerlSIO_fflush(f) \ (*PL_StdIO->pFlush)(PL_StdIO, (f)) #define PerlSIO_fgets(s, n, f) \ (*PL_StdIO->pGets)(PL_StdIO, s, n, (f)) #define PerlSIO_ungetc(c,f) \ (*PL_StdIO->pUngetc)(PL_StdIO, (c),(f)) #define PerlSIO_fileno(f) \ (*PL_StdIO->pFileno)(PL_StdIO, (f)) #define PerlSIO_fdopen(f, s) \ (*PL_StdIO->pFdopen)(PL_StdIO, (f),(s)) #define PerlSIO_freopen(p, m, f) \ (*PL_StdIO->pReopen)(PL_StdIO, (p), (m), (f)) #define PerlSIO_fread(buf,sz,count,f) \ (*PL_StdIO->pRead)(PL_StdIO, (buf), (sz), (count), (f)) #define PerlSIO_fwrite(buf,sz,count,f) \ (*PL_StdIO->pWrite)(PL_StdIO, (buf), (sz), (count), (f)) #define PerlSIO_setbuf(f,b) \ (*PL_StdIO->pSetBuf)(PL_StdIO, (f), (b)) #define PerlSIO_setvbuf(f,b,t,s) \ (*PL_StdIO->pSetVBuf)(PL_StdIO, (f),(b),(t),(s)) #define PerlSIO_set_cnt(f,c) \ (*PL_StdIO->pSetCnt)(PL_StdIO, (f), (c)) #define PerlSIO_set_ptr(f,p) \ (*PL_StdIO->pSetPtr)(PL_StdIO, (f), (p)) #define PerlSIO_setlinebuf(f) \ (*PL_StdIO->pSetlinebuf)(PL_StdIO, (f)) #define PerlSIO_printf Perl_fprintf_nocontext #define PerlSIO_stdoutf Perl_printf_nocontext #define PerlSIO_vprintf(f,fmt,a) \ (*PL_StdIO->pVprintf)(PL_StdIO, (f),(fmt),a) #define PerlSIO_ftell(f) \ (*PL_StdIO->pTell)(PL_StdIO, (f)) #define PerlSIO_fseek(f,o,w) \ (*PL_StdIO->pSeek)(PL_StdIO, (f),(o),(w)) #define PerlSIO_fgetpos(f,p) \ (*PL_StdIO->pGetpos)(PL_StdIO, (f),(p)) #define PerlSIO_fsetpos(f,p) \ (*PL_StdIO->pSetpos)(PL_StdIO, (f),(p)) #define PerlSIO_rewind(f) \ (*PL_StdIO->pRewind)(PL_StdIO, (f)) #define PerlSIO_tmpfile() \ (*PL_StdIO->pTmpfile)(PL_StdIO) #define PerlSIO_init() \ (*PL_StdIO->pInit)(PL_StdIO) #undef init_os_extras #define init_os_extras() \ (*PL_StdIO->pInitOSExtras)(PL_StdIO) #define PerlSIO_fdupopen(f) \ (*PL_StdIO->pFdupopen)(PL_StdIO, (f)) #else /* PERL_IMPLICIT_SYS */ #define PerlSIO_stdin stdin #define PerlSIO_stdout stdout #define PerlSIO_stderr stderr #define PerlSIO_fopen(x,y) fopen(x,y) #ifdef __VOS__ /* Work around VOS bug posix-979, wrongly setting errno when at end of file. */ #define PerlSIO_fclose(f) (((errno==1025)?errno=0:0),fclose(f)) #define PerlSIO_feof(f) (((errno==1025)?errno=0:0),feof(f)) #define PerlSIO_ferror(f) (((errno==1025)?errno=0:0),ferror(f)) #else #define PerlSIO_fclose(f) fclose(f) #define PerlSIO_feof(f) feof(f) #define PerlSIO_ferror(f) ferror(f) #endif #define PerlSIO_clearerr(f) clearerr(f) #define PerlSIO_fgetc(f) fgetc(f) #ifdef FILE_base #define PerlSIO_get_base(f) FILE_base(f) #define PerlSIO_get_bufsiz(f) FILE_bufsiz(f) #else #define PerlSIO_get_base(f) NULL #define PerlSIO_get_bufsiz(f) 0 #endif #ifdef USE_STDIO_PTR #define PerlSIO_get_cnt(f) FILE_cnt(f) #define PerlSIO_get_ptr(f) FILE_ptr(f) #else #define PerlSIO_get_cnt(f) 0 #define PerlSIO_get_ptr(f) NULL #endif #define PerlSIO_fputc(c,f) fputc(c,f) #define PerlSIO_fputs(s,f) fputs(s,f) #define PerlSIO_fflush(f) Fflush(f) #define PerlSIO_fgets(s, n, f) fgets(s,n,f) #if defined(VMS) && defined(__DECC) /* Unusual definition of ungetc() here to accommodate fast_sv_gets()' * belief that it can mix getc/ungetc with reads from stdio buffer */ int decc$ungetc(int __c, FILE *__stream); # define PerlSIO_ungetc(c,f) ((c) == EOF ? EOF : \ ((*(f) && !((*(f))->_flag & _IONBF) && \ ((*(f))->_ptr > (*(f))->_base)) ? \ ((*(f))->_cnt++, *(--(*(f))->_ptr) = (c)) : decc$ungetc(c,f))) #else # define PerlSIO_ungetc(c,f) ungetc(c,f) #endif #define PerlSIO_fileno(f) fileno(f) #define PerlSIO_fdopen(f, s) fdopen(f,s) #define PerlSIO_freopen(p, m, f) freopen(p,m,f) #define PerlSIO_fread(buf,sz,count,f) fread(buf,sz,count,f) #define PerlSIO_fwrite(buf,sz,count,f) fwrite(buf,sz,count,f) #define PerlSIO_setbuf(f,b) setbuf(f,b) #define PerlSIO_setvbuf(f,b,t,s) setvbuf(f,b,t,s) #if defined(USE_STDIO_PTR) && defined(STDIO_CNT_LVALUE) #define PerlSIO_set_cnt(f,c) FILE_cnt(f) = (c) #else #define PerlSIO_set_cnt(f,c) PerlIOProc_abort() #endif #if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) #define PerlSIO_set_ptr(f,p) (FILE_ptr(f) = (p)) #else #define PerlSIO_set_ptr(f,p) PerlIOProc_abort() #endif #define PerlSIO_setlinebuf(f) setlinebuf(f) #define PerlSIO_printf fprintf #define PerlSIO_stdoutf printf #define PerlSIO_vprintf(f,fmt,a) vfprintf(f,fmt,a) #define PerlSIO_ftell(f) ftell(f) #define PerlSIO_fseek(f,o,w) fseek(f,o,w) #define PerlSIO_fgetpos(f,p) fgetpos(f,p) #define PerlSIO_fsetpos(f,p) fsetpos(f,p) #define PerlSIO_rewind(f) rewind(f) #define PerlSIO_tmpfile() tmpfile() #define PerlSIO_fdupopen(f) (f) #endif /* PERL_IMPLICIT_SYS */ /* * Interface for directory functions */ #if defined(PERL_IMPLICIT_SYS) /* IPerlDir */ struct IPerlDir; struct IPerlDirInfo; typedef int (*LPMakedir)(struct IPerlDir*, const char*, int); typedef int (*LPChdir)(struct IPerlDir*, const char*); typedef int (*LPRmdir)(struct IPerlDir*, const char*); typedef int (*LPDirClose)(struct IPerlDir*, DIR*); typedef DIR* (*LPDirOpen)(struct IPerlDir*, const char*); typedef struct direct* (*LPDirRead)(struct IPerlDir*, DIR*); typedef void (*LPDirRewind)(struct IPerlDir*, DIR*); typedef void (*LPDirSeek)(struct IPerlDir*, DIR*, long); typedef long (*LPDirTell)(struct IPerlDir*, DIR*); #ifdef WIN32 typedef char* (*LPDirMapPathA)(struct IPerlDir*, const char*); typedef WCHAR* (*LPDirMapPathW)(struct IPerlDir*, const WCHAR*); #endif struct IPerlDir { LPMakedir pMakedir; LPChdir pChdir; LPRmdir pRmdir; LPDirClose pClose; LPDirOpen pOpen; LPDirRead pRead; LPDirRewind pRewind; LPDirSeek pSeek; LPDirTell pTell; #ifdef WIN32 LPDirMapPathA pMapPathA; LPDirMapPathW pMapPathW; #endif }; struct IPerlDirInfo { unsigned long nCount; /* number of entries expected */ struct IPerlDir perlDirList; }; #define PerlDir_mkdir(name, mode) \ (*PL_Dir->pMakedir)(PL_Dir, (name), (mode)) #define PerlDir_chdir(name) \ (*PL_Dir->pChdir)(PL_Dir, (name)) #define PerlDir_rmdir(name) \ (*PL_Dir->pRmdir)(PL_Dir, (name)) #define PerlDir_close(dir) \ (*PL_Dir->pClose)(PL_Dir, (dir)) #define PerlDir_open(name) \ (*PL_Dir->pOpen)(PL_Dir, (name)) #define PerlDir_read(dir) \ (*PL_Dir->pRead)(PL_Dir, (dir)) #define PerlDir_rewind(dir) \ (*PL_Dir->pRewind)(PL_Dir, (dir)) #define PerlDir_seek(dir, loc) \ (*PL_Dir->pSeek)(PL_Dir, (dir), (loc)) #define PerlDir_tell(dir) \ (*PL_Dir->pTell)(PL_Dir, (dir)) #ifdef WIN32 #define PerlDir_mapA(dir) \ (*PL_Dir->pMapPathA)(PL_Dir, (dir)) #define PerlDir_mapW(dir) \ (*PL_Dir->pMapPathW)(PL_Dir, (dir)) #endif #else /* PERL_IMPLICIT_SYS */ #define PerlDir_mkdir(name, mode) Mkdir((name), (mode)) #ifdef VMS # define PerlDir_chdir(n) Chdir((n)) #else # define PerlDir_chdir(name) chdir((name)) #endif #define PerlDir_rmdir(name) rmdir((name)) #define PerlDir_close(dir) closedir((dir)) #define PerlDir_open(name) opendir((name)) #define PerlDir_read(dir) readdir((dir)) #define PerlDir_rewind(dir) rewinddir((dir)) #define PerlDir_seek(dir, loc) seekdir((dir), (loc)) #define PerlDir_tell(dir) telldir((dir)) #ifdef WIN32 #define PerlDir_mapA(dir) dir #define PerlDir_mapW(dir) dir #endif #endif /* PERL_IMPLICIT_SYS */ /* Interface for perl environment functions */ #if defined(PERL_IMPLICIT_SYS) /* IPerlEnv */ struct IPerlEnv; struct IPerlEnvInfo; typedef char* (*LPEnvGetenv)(struct IPerlEnv*, const char*); typedef int (*LPEnvPutenv)(struct IPerlEnv*, const char*); typedef char* (*LPEnvGetenv_len)(struct IPerlEnv*, const char *varname, unsigned long *len); typedef int (*LPEnvUname)(struct IPerlEnv*, struct utsname *name); typedef void (*LPEnvClearenv)(struct IPerlEnv*); typedef void* (*LPEnvGetChildenv)(struct IPerlEnv*); typedef void (*LPEnvFreeChildenv)(struct IPerlEnv*, void* env); typedef char* (*LPEnvGetChilddir)(struct IPerlEnv*); typedef void (*LPEnvFreeChilddir)(struct IPerlEnv*, char* dir); #ifdef HAS_ENVGETENV typedef char* (*LPENVGetenv)(struct IPerlEnv*, const char *varname); typedef char* (*LPENVGetenv_len)(struct IPerlEnv*, const char *varname, unsigned long *len); #endif #ifdef WIN32 typedef unsigned long (*LPEnvOsID)(struct IPerlEnv*); typedef char* (*LPEnvLibPath)(struct IPerlEnv*, const char*, STRLEN *const len); typedef char* (*LPEnvSiteLibPath)(struct IPerlEnv*, const char*, STRLEN *const len); typedef char* (*LPEnvVendorLibPath)(struct IPerlEnv*, const char*, STRLEN *const len); typedef void (*LPEnvGetChildIO)(struct IPerlEnv*, child_IO_table*); #endif struct IPerlEnv { LPEnvGetenv pGetenv; LPEnvPutenv pPutenv; LPEnvGetenv_len pGetenv_len; LPEnvUname pEnvUname; LPEnvClearenv pClearenv; LPEnvGetChildenv pGetChildenv; LPEnvFreeChildenv pFreeChildenv; LPEnvGetChilddir pGetChilddir; LPEnvFreeChilddir pFreeChilddir; #ifdef HAS_ENVGETENV LPENVGetenv pENVGetenv; LPENVGetenv_len pENVGetenv_len; #endif #ifdef WIN32 LPEnvOsID pEnvOsID; LPEnvLibPath pLibPath; LPEnvSiteLibPath pSiteLibPath; LPEnvVendorLibPath pVendorLibPath; LPEnvGetChildIO pGetChildIO; #endif }; struct IPerlEnvInfo { unsigned long nCount; /* number of entries expected */ struct IPerlEnv perlEnvList; }; #define PerlEnv_putenv(str) \ (*PL_Env->pPutenv)(PL_Env,(str)) #define PerlEnv_getenv(str) \ (*PL_Env->pGetenv)(PL_Env,(str)) #define PerlEnv_getenv_len(str,l) \ (*PL_Env->pGetenv_len)(PL_Env,(str), (l)) #define PerlEnv_clearenv() \ (*PL_Env->pClearenv)(PL_Env) #define PerlEnv_get_childenv() \ (*PL_Env->pGetChildenv)(PL_Env) #define PerlEnv_free_childenv(e) \ (*PL_Env->pFreeChildenv)(PL_Env, (e)) #define PerlEnv_get_childdir() \ (*PL_Env->pGetChilddir)(PL_Env) #define PerlEnv_free_childdir(d) \ (*PL_Env->pFreeChilddir)(PL_Env, (d)) #ifdef HAS_ENVGETENV # define PerlEnv_ENVgetenv(str) \ (*PL_Env->pENVGetenv)(PL_Env,(str)) # define PerlEnv_ENVgetenv_len(str,l) \ (*PL_Env->pENVGetenv_len)(PL_Env,(str), (l)) #else # define PerlEnv_ENVgetenv(str) \ PerlEnv_getenv((str)) # define PerlEnv_ENVgetenv_len(str,l) \ PerlEnv_getenv_len((str),(l)) #endif #define PerlEnv_uname(name) \ (*PL_Env->pEnvUname)(PL_Env,(name)) #ifdef WIN32 #define PerlEnv_os_id() \ (*PL_Env->pEnvOsID)(PL_Env) #define PerlEnv_lib_path(str, lenp) \ (*PL_Env->pLibPath)(PL_Env,(str),(lenp)) #define PerlEnv_sitelib_path(str, lenp) \ (*PL_Env->pSiteLibPath)(PL_Env,(str),(lenp)) #define PerlEnv_vendorlib_path(str, lenp) \ (*PL_Env->pVendorLibPath)(PL_Env,(str),(lenp)) #define PerlEnv_get_child_IO(ptr) \ (*PL_Env->pGetChildIO)(PL_Env, ptr) #endif #else /* PERL_IMPLICIT_SYS */ #define PerlEnv_putenv(str) putenv((str)) #define PerlEnv_getenv(str) getenv((str)) #define PerlEnv_getenv_len(str,l) getenv_len((str), (l)) #ifdef HAS_ENVGETENV # define PerlEnv_ENVgetenv(str) ENVgetenv((str)) # define PerlEnv_ENVgetenv_len(str,l) ENVgetenv_len((str), (l)) #else # define PerlEnv_ENVgetenv(str) PerlEnv_getenv((str)) # define PerlEnv_ENVgetenv_len(str,l) PerlEnv_getenv_len((str), (l)) #endif #define PerlEnv_uname(name) uname((name)) #ifdef WIN32 #define PerlEnv_os_id() win32_os_id() #define PerlEnv_lib_path(str, lenp) win32_get_privlib(str, lenp) #define PerlEnv_sitelib_path(str, lenp) win32_get_sitelib(str, lenp) #define PerlEnv_vendorlib_path(str, lenp) win32_get_vendorlib(str, lenp) #define PerlEnv_get_child_IO(ptr) win32_get_child_IO(ptr) #define PerlEnv_clearenv() win32_clearenv() #define PerlEnv_get_childenv() win32_get_childenv() #define PerlEnv_free_childenv(e) win32_free_childenv((e)) #define PerlEnv_get_childdir() win32_get_childdir() #define PerlEnv_free_childdir(d) win32_free_childdir((d)) #else #define PerlEnv_clearenv() clearenv() #define PerlEnv_get_childenv() get_childenv() #define PerlEnv_free_childenv(e) free_childenv((e)) #define PerlEnv_get_childdir() get_childdir() #define PerlEnv_free_childdir(d) free_childdir((d)) #endif #endif /* PERL_IMPLICIT_SYS */ /* Interface for perl low-level IO functions */ #if defined(PERL_IMPLICIT_SYS) /* IPerlLIO */ struct IPerlLIO; struct IPerlLIOInfo; typedef int (*LPLIOAccess)(struct IPerlLIO*, const char*, int); typedef int (*LPLIOChmod)(struct IPerlLIO*, const char*, int); typedef int (*LPLIOChown)(struct IPerlLIO*, const char*, uid_t, gid_t); typedef int (*LPLIOChsize)(struct IPerlLIO*, int, Off_t); typedef int (*LPLIOClose)(struct IPerlLIO*, int); typedef int (*LPLIODup)(struct IPerlLIO*, int); typedef int (*LPLIODup2)(struct IPerlLIO*, int, int); typedef int (*LPLIOFlock)(struct IPerlLIO*, int, int); typedef int (*LPLIOFileStat)(struct IPerlLIO*, int, Stat_t*); typedef int (*LPLIOIOCtl)(struct IPerlLIO*, int, unsigned int, char*); typedef int (*LPLIOIsatty)(struct IPerlLIO*, int); typedef int (*LPLIOLink)(struct IPerlLIO*, const char*, const char *); typedef Off_t (*LPLIOLseek)(struct IPerlLIO*, int, Off_t, int); typedef int (*LPLIOLstat)(struct IPerlLIO*, const char*, Stat_t*); typedef char* (*LPLIOMktemp)(struct IPerlLIO*, char*); typedef int (*LPLIOOpen)(struct IPerlLIO*, const char*, int); typedef int (*LPLIOOpen3)(struct IPerlLIO*, const char*, int, int); typedef int (*LPLIORead)(struct IPerlLIO*, int, void*, unsigned int); typedef int (*LPLIORename)(struct IPerlLIO*, const char*, const char*); #ifdef NETWARE typedef int (*LPLIOSetmode)(struct IPerlLIO*, FILE*, int); #else typedef int (*LPLIOSetmode)(struct IPerlLIO*, int, int); #endif /* NETWARE */ typedef int (*LPLIONameStat)(struct IPerlLIO*, const char*, Stat_t*); typedef char* (*LPLIOTmpnam)(struct IPerlLIO*, char*); typedef int (*LPLIOUmask)(struct IPerlLIO*, int); typedef int (*LPLIOUnlink)(struct IPerlLIO*, const char*); typedef int (*LPLIOUtime)(struct IPerlLIO*, const char*, struct utimbuf*); typedef int (*LPLIOWrite)(struct IPerlLIO*, int, const void*, unsigned int); struct IPerlLIO { LPLIOAccess pAccess; LPLIOChmod pChmod; LPLIOChown pChown; LPLIOChsize pChsize; LPLIOClose pClose; LPLIODup pDup; LPLIODup2 pDup2; LPLIOFlock pFlock; LPLIOFileStat pFileStat; LPLIOIOCtl pIOCtl; LPLIOIsatty pIsatty; LPLIOLink pLink; LPLIOLseek pLseek; LPLIOLstat pLstat; LPLIOMktemp pMktemp; LPLIOOpen pOpen; LPLIOOpen3 pOpen3; LPLIORead pRead; LPLIORename pRename; LPLIOSetmode pSetmode; LPLIONameStat pNameStat; LPLIOTmpnam pTmpnam; LPLIOUmask pUmask; LPLIOUnlink pUnlink; LPLIOUtime pUtime; LPLIOWrite pWrite; }; struct IPerlLIOInfo { unsigned long nCount; /* number of entries expected */ struct IPerlLIO perlLIOList; }; #define PerlLIO_access(file, mode) \ (*PL_LIO->pAccess)(PL_LIO, (file), (mode)) #define PerlLIO_chmod(file, mode) \ (*PL_LIO->pChmod)(PL_LIO, (file), (mode)) #define PerlLIO_chown(file, owner, group) \ (*PL_LIO->pChown)(PL_LIO, (file), (owner), (group)) #define PerlLIO_chsize(fd, size) \ (*PL_LIO->pChsize)(PL_LIO, (fd), (size)) #define PerlLIO_close(fd) \ (*PL_LIO->pClose)(PL_LIO, (fd)) #define PerlLIO_dup(fd) \ (*PL_LIO->pDup)(PL_LIO, (fd)) #define PerlLIO_dup2(fd1, fd2) \ (*PL_LIO->pDup2)(PL_LIO, (fd1), (fd2)) #define PerlLIO_flock(fd, op) \ (*PL_LIO->pFlock)(PL_LIO, (fd), (op)) #define PerlLIO_fstat(fd, buf) \ (*PL_LIO->pFileStat)(PL_LIO, (fd), (buf)) #define PerlLIO_ioctl(fd, u, buf) \ (*PL_LIO->pIOCtl)(PL_LIO, (fd), (u), (buf)) #define PerlLIO_isatty(fd) \ (*PL_LIO->pIsatty)(PL_LIO, (fd)) #define PerlLIO_link(oldname, newname) \ (*PL_LIO->pLink)(PL_LIO, (oldname), (newname)) #define PerlLIO_lseek(fd, offset, mode) \ (*PL_LIO->pLseek)(PL_LIO, (fd), (offset), (mode)) #define PerlLIO_lstat(name, buf) \ (*PL_LIO->pLstat)(PL_LIO, (name), (buf)) #define PerlLIO_mktemp(file) \ (*PL_LIO->pMktemp)(PL_LIO, (file)) #define PerlLIO_open(file, flag) \ (*PL_LIO->pOpen)(PL_LIO, (file), (flag)) #define PerlLIO_open3(file, flag, perm) \ (*PL_LIO->pOpen3)(PL_LIO, (file), (flag), (perm)) #define PerlLIO_read(fd, buf, count) \ (*PL_LIO->pRead)(PL_LIO, (fd), (buf), (count)) #define PerlLIO_rename(oname, newname) \ (*PL_LIO->pRename)(PL_LIO, (oname), (newname)) #define PerlLIO_setmode(fd, mode) \ (*PL_LIO->pSetmode)(PL_LIO, (fd), (mode)) #define PerlLIO_stat(name, buf) \ (*PL_LIO->pNameStat)(PL_LIO, (name), (buf)) #define PerlLIO_tmpnam(str) \ (*PL_LIO->pTmpnam)(PL_LIO, (str)) #define PerlLIO_umask(mode) \ (*PL_LIO->pUmask)(PL_LIO, (mode)) #define PerlLIO_unlink(file) \ (*PL_LIO->pUnlink)(PL_LIO, (file)) #define PerlLIO_utime(file, time) \ (*PL_LIO->pUtime)(PL_LIO, (file), (time)) #define PerlLIO_write(fd, buf, count) \ (*PL_LIO->pWrite)(PL_LIO, (fd), (buf), (count)) #else /* PERL_IMPLICIT_SYS */ #define PerlLIO_access(file, mode) access((file), (mode)) #define PerlLIO_chmod(file, mode) chmod((file), (mode)) #define PerlLIO_chown(file, owner, grp) chown((file), (owner), (grp)) #if defined(HAS_TRUNCATE) # define PerlLIO_chsize(fd, size) ftruncate((fd), (size)) #elif defined(HAS_CHSIZE) # define PerlLIO_chsize(fd, size) chsize((fd), (size)) #else # define PerlLIO_chsize(fd, size) my_chsize((fd), (size)) #endif #define PerlLIO_close(fd) close((fd)) #define PerlLIO_dup(fd) dup((fd)) #define PerlLIO_dup2(fd1, fd2) dup2((fd1), (fd2)) #define PerlLIO_flock(fd, op) FLOCK((fd), (op)) #define PerlLIO_fstat(fd, buf) Fstat((fd), (buf)) #define PerlLIO_ioctl(fd, u, buf) ioctl((fd), (u), (buf)) #define PerlLIO_isatty(fd) isatty((fd)) #define PerlLIO_link(oldname, newname) link((oldname), (newname)) #define PerlLIO_lseek(fd, offset, mode) lseek((fd), (offset), (mode)) #define PerlLIO_stat(name, buf) Stat((name), (buf)) #ifdef HAS_LSTAT # define PerlLIO_lstat(name, buf) lstat((name), (buf)) #else # define PerlLIO_lstat(name, buf) PerlLIO_stat((name), (buf)) #endif #define PerlLIO_mktemp(file) mktemp((file)) #define PerlLIO_mkstemp(file) mkstemp((file)) #define PerlLIO_open(file, flag) open((file), (flag)) #define PerlLIO_open3(file, flag, perm) open((file), (flag), (perm)) #define PerlLIO_read(fd, buf, count) read((fd), (buf), (count)) #define PerlLIO_rename(old, new) rename((old), (new)) #define PerlLIO_setmode(fd, mode) setmode((fd), (mode)) #define PerlLIO_tmpnam(str) tmpnam((str)) #define PerlLIO_umask(mode) umask((mode)) #define PerlLIO_unlink(file) unlink((file)) #define PerlLIO_utime(file, time) utime((file), (time)) #define PerlLIO_write(fd, buf, count) write((fd), (buf), (count)) #endif /* PERL_IMPLICIT_SYS */ /* Interface for perl memory allocation */ #if defined(PERL_IMPLICIT_SYS) /* IPerlMem */ struct IPerlMem; struct IPerlMemInfo; typedef void* (*LPMemMalloc)(struct IPerlMem*, size_t); typedef void* (*LPMemRealloc)(struct IPerlMem*, void*, size_t); typedef void (*LPMemFree)(struct IPerlMem*, void*); typedef void* (*LPMemCalloc)(struct IPerlMem*, size_t, size_t); typedef void (*LPMemGetLock)(struct IPerlMem*); typedef void (*LPMemFreeLock)(struct IPerlMem*); typedef int (*LPMemIsLocked)(struct IPerlMem*); struct IPerlMem { LPMemMalloc pMalloc; LPMemRealloc pRealloc; LPMemFree pFree; LPMemCalloc pCalloc; LPMemGetLock pGetLock; LPMemFreeLock pFreeLock; LPMemIsLocked pIsLocked; }; struct IPerlMemInfo { unsigned long nCount; /* number of entries expected */ struct IPerlMem perlMemList; }; /* Interpreter specific memory macros */ #define PerlMem_malloc(size) \ (*PL_Mem->pMalloc)(PL_Mem, (size)) #define PerlMem_realloc(buf, size) \ (*PL_Mem->pRealloc)(PL_Mem, (buf), (size)) #define PerlMem_free(buf) \ (*PL_Mem->pFree)(PL_Mem, (buf)) #define PerlMem_calloc(num, size) \ (*PL_Mem->pCalloc)(PL_Mem, (num), (size)) #define PerlMem_get_lock() \ (*PL_Mem->pGetLock)(PL_Mem) #define PerlMem_free_lock() \ (*PL_Mem->pFreeLock)(PL_Mem) #define PerlMem_is_locked() \ (*PL_Mem->pIsLocked)(PL_Mem) /* Shared memory macros */ #ifdef NETWARE #define PerlMemShared_malloc(size) \ (*PL_Mem->pMalloc)(PL_Mem, (size)) #define PerlMemShared_realloc(buf, size) \ (*PL_Mem->pRealloc)(PL_Mem, (buf), (size)) #define PerlMemShared_free(buf) \ (*PL_Mem->pFree)(PL_Mem, (buf)) #define PerlMemShared_calloc(num, size) \ (*PL_Mem->pCalloc)(PL_Mem, (num), (size)) #define PerlMemShared_get_lock() \ (*PL_Mem->pGetLock)(PL_Mem) #define PerlMemShared_free_lock() \ (*PL_Mem->pFreeLock)(PL_Mem) #define PerlMemShared_is_locked() \ (*PL_Mem->pIsLocked)(PL_Mem) #else #define PerlMemShared_malloc(size) \ (*PL_MemShared->pMalloc)(PL_MemShared, (size)) #define PerlMemShared_realloc(buf, size) \ (*PL_MemShared->pRealloc)(PL_MemShared, (buf), (size)) #define PerlMemShared_free(buf) \ (*PL_MemShared->pFree)(PL_MemShared, (buf)) #define PerlMemShared_calloc(num, size) \ (*PL_MemShared->pCalloc)(PL_MemShared, (num), (size)) #define PerlMemShared_get_lock() \ (*PL_MemShared->pGetLock)(PL_MemShared) #define PerlMemShared_free_lock() \ (*PL_MemShared->pFreeLock)(PL_MemShared) #define PerlMemShared_is_locked() \ (*PL_MemShared->pIsLocked)(PL_MemShared) #endif /* Parse tree memory macros */ #define PerlMemParse_malloc(size) \ (*PL_MemParse->pMalloc)(PL_MemParse, (size)) #define PerlMemParse_realloc(buf, size) \ (*PL_MemParse->pRealloc)(PL_MemParse, (buf), (size)) #define PerlMemParse_free(buf) \ (*PL_MemParse->pFree)(PL_MemParse, (buf)) #define PerlMemParse_calloc(num, size) \ (*PL_MemParse->pCalloc)(PL_MemParse, (num), (size)) #define PerlMemParse_get_lock() \ (*PL_MemParse->pGetLock)(PL_MemParse) #define PerlMemParse_free_lock() \ (*PL_MemParse->pFreeLock)(PL_MemParse) #define PerlMemParse_is_locked() \ (*PL_MemParse->pIsLocked)(PL_MemParse) #else /* PERL_IMPLICIT_SYS */ /* Interpreter specific memory macros */ #define PerlMem_malloc(size) malloc((size)) #define PerlMem_realloc(buf, size) realloc((buf), (size)) #define PerlMem_free(buf) free((buf)) #define PerlMem_calloc(num, size) calloc((num), (size)) #define PerlMem_get_lock() #define PerlMem_free_lock() #define PerlMem_is_locked() 0 /* Shared memory macros */ #define PerlMemShared_malloc(size) malloc((size)) #define PerlMemShared_realloc(buf, size) realloc((buf), (size)) #define PerlMemShared_free(buf) free((buf)) #define PerlMemShared_calloc(num, size) calloc((num), (size)) #define PerlMemShared_get_lock() #define PerlMemShared_free_lock() #define PerlMemShared_is_locked() 0 /* Parse tree memory macros */ #define PerlMemParse_malloc(size) malloc((size)) #define PerlMemParse_realloc(buf, size) realloc((buf), (size)) #define PerlMemParse_free(buf) free((buf)) #define PerlMemParse_calloc(num, size) calloc((num), (size)) #define PerlMemParse_get_lock() #define PerlMemParse_free_lock() #define PerlMemParse_is_locked() 0 #endif /* PERL_IMPLICIT_SYS */ /* Interface for perl process functions */ #if defined(PERL_IMPLICIT_SYS) #ifndef jmp_buf #include #endif /* IPerlProc */ struct IPerlProc; struct IPerlProcInfo; typedef void (*LPProcAbort)(struct IPerlProc*); typedef char* (*LPProcCrypt)(struct IPerlProc*, const char*, const char*); typedef void (*LPProcExit)(struct IPerlProc*, int) __attribute__noreturn__; typedef void (*LPProc_Exit)(struct IPerlProc*, int) __attribute__noreturn__; typedef int (*LPProcExecl)(struct IPerlProc*, const char*, const char*, const char*, const char*, const char*); typedef int (*LPProcExecv)(struct IPerlProc*, const char*, const char*const*); typedef int (*LPProcExecvp)(struct IPerlProc*, const char*, const char*const*); typedef uid_t (*LPProcGetuid)(struct IPerlProc*); typedef uid_t (*LPProcGeteuid)(struct IPerlProc*); typedef gid_t (*LPProcGetgid)(struct IPerlProc*); typedef gid_t (*LPProcGetegid)(struct IPerlProc*); typedef char* (*LPProcGetlogin)(struct IPerlProc*); typedef int (*LPProcKill)(struct IPerlProc*, int, int); typedef int (*LPProcKillpg)(struct IPerlProc*, int, int); typedef int (*LPProcPauseProc)(struct IPerlProc*); typedef PerlIO* (*LPProcPopen)(struct IPerlProc*, const char*, const char*); typedef PerlIO* (*LPProcPopenList)(struct IPerlProc*, const char*, IV narg, SV **args); typedef int (*LPProcPclose)(struct IPerlProc*, PerlIO*); typedef int (*LPProcPipe)(struct IPerlProc*, int*); typedef int (*LPProcSetuid)(struct IPerlProc*, uid_t); typedef int (*LPProcSetgid)(struct IPerlProc*, gid_t); typedef int (*LPProcSleep)(struct IPerlProc*, unsigned int); typedef int (*LPProcTimes)(struct IPerlProc*, struct tms*); typedef int (*LPProcWait)(struct IPerlProc*, int*); typedef int (*LPProcWaitpid)(struct IPerlProc*, int, int*, int); typedef Sighandler_t (*LPProcSignal)(struct IPerlProc*, int, Sighandler_t); typedef int (*LPProcFork)(struct IPerlProc*); typedef int (*LPProcGetpid)(struct IPerlProc*); #ifdef WIN32 typedef void* (*LPProcDynaLoader)(struct IPerlProc*, const char*); typedef void (*LPProcGetOSError)(struct IPerlProc*, SV* sv, DWORD dwErr); typedef int (*LPProcSpawnvp)(struct IPerlProc*, int, const char*, const char*const*); #endif typedef int (*LPProcLastHost)(struct IPerlProc*); typedef int (*LPProcGetTimeOfDay)(struct IPerlProc*, struct timeval*, void*); struct IPerlProc { LPProcAbort pAbort; LPProcCrypt pCrypt; LPProcExit pExit; LPProc_Exit p_Exit; LPProcExecl pExecl; LPProcExecv pExecv; LPProcExecvp pExecvp; LPProcGetuid pGetuid; LPProcGeteuid pGeteuid; LPProcGetgid pGetgid; LPProcGetegid pGetegid; LPProcGetlogin pGetlogin; LPProcKill pKill; LPProcKillpg pKillpg; LPProcPauseProc pPauseProc; LPProcPopen pPopen; LPProcPclose pPclose; LPProcPipe pPipe; LPProcSetuid pSetuid; LPProcSetgid pSetgid; LPProcSleep pSleep; LPProcTimes pTimes; LPProcWait pWait; LPProcWaitpid pWaitpid; LPProcSignal pSignal; LPProcFork pFork; LPProcGetpid pGetpid; #ifdef WIN32 LPProcDynaLoader pDynaLoader; LPProcGetOSError pGetOSError; LPProcSpawnvp pSpawnvp; #endif LPProcLastHost pLastHost; LPProcPopenList pPopenList; LPProcGetTimeOfDay pGetTimeOfDay; }; struct IPerlProcInfo { unsigned long nCount; /* number of entries expected */ struct IPerlProc perlProcList; }; #define PerlProc_abort() \ (*PL_Proc->pAbort)(PL_Proc) #define PerlProc_crypt(c,s) \ (*PL_Proc->pCrypt)(PL_Proc, (c), (s)) #define PerlProc_exit(s) \ (*PL_Proc->pExit)(PL_Proc, (s)) #define PerlProc__exit(s) \ (*PL_Proc->p_Exit)(PL_Proc, (s)) #define PerlProc_execl(c, w, x, y, z) \ (*PL_Proc->pExecl)(PL_Proc, (c), (w), (x), (y), (z)) #define PerlProc_execv(c, a) \ (*PL_Proc->pExecv)(PL_Proc, (c), (a)) #define PerlProc_execvp(c, a) \ (*PL_Proc->pExecvp)(PL_Proc, (c), (a)) #define PerlProc_getuid() \ (*PL_Proc->pGetuid)(PL_Proc) #define PerlProc_geteuid() \ (*PL_Proc->pGeteuid)(PL_Proc) #define PerlProc_getgid() \ (*PL_Proc->pGetgid)(PL_Proc) #define PerlProc_getegid() \ (*PL_Proc->pGetegid)(PL_Proc) #define PerlProc_getlogin() \ (*PL_Proc->pGetlogin)(PL_Proc) #define PerlProc_kill(i, a) \ (*PL_Proc->pKill)(PL_Proc, (i), (a)) #define PerlProc_killpg(i, a) \ (*PL_Proc->pKillpg)(PL_Proc, (i), (a)) #define PerlProc_pause() \ (*PL_Proc->pPauseProc)(PL_Proc) #define PerlProc_popen(c, m) \ (*PL_Proc->pPopen)(PL_Proc, (c), (m)) #define PerlProc_popen_list(m, n, a) \ (*PL_Proc->pPopenList)(PL_Proc, (m), (n), (a)) #define PerlProc_pclose(f) \ (*PL_Proc->pPclose)(PL_Proc, (f)) #define PerlProc_pipe(fd) \ (*PL_Proc->pPipe)(PL_Proc, (fd)) #define PerlProc_setuid(u) \ (*PL_Proc->pSetuid)(PL_Proc, (u)) #define PerlProc_setgid(g) \ (*PL_Proc->pSetgid)(PL_Proc, (g)) #define PerlProc_sleep(t) \ (*PL_Proc->pSleep)(PL_Proc, (t)) #define PerlProc_times(t) \ (*PL_Proc->pTimes)(PL_Proc, (t)) #define PerlProc_wait(t) \ (*PL_Proc->pWait)(PL_Proc, (t)) #define PerlProc_waitpid(p,s,f) \ (*PL_Proc->pWaitpid)(PL_Proc, (p), (s), (f)) #define PerlProc_signal(n, h) \ (*PL_Proc->pSignal)(PL_Proc, (n), (h)) #define PerlProc_fork() \ (*PL_Proc->pFork)(PL_Proc) #define PerlProc_getpid() \ (*PL_Proc->pGetpid)(PL_Proc) #define PerlProc_setjmp(b, n) Sigsetjmp((b), (n)) #define PerlProc_longjmp(b, n) Siglongjmp((b), (n)) #ifdef WIN32 #define PerlProc_DynaLoad(f) \ (*PL_Proc->pDynaLoader)(PL_Proc, (f)) #define PerlProc_GetOSError(s,e) \ (*PL_Proc->pGetOSError)(PL_Proc, (s), (e)) #define PerlProc_spawnvp(m, c, a) \ (*PL_Proc->pSpawnvp)(PL_Proc, (m), (c), (a)) #endif #define PerlProc_lasthost() \ (*PL_Proc->pLastHost)(PL_Proc) #define PerlProc_gettimeofday(t,z) \ (*PL_Proc->pGetTimeOfDay)(PL_Proc,(t),(z)) #else /* PERL_IMPLICIT_SYS */ #define PerlProc_abort() abort() #define PerlProc_crypt(c,s) crypt((c), (s)) #define PerlProc_exit(s) exit((s)) #define PerlProc__exit(s) _exit((s)) #define PerlProc_execl(c,w,x,y,z) \ execl((c), (w), (x), (y), (z)) #define PerlProc_execv(c, a) execv((c), (a)) #define PerlProc_execvp(c, a) execvp((c), (a)) #define PerlProc_getuid() getuid() #define PerlProc_geteuid() geteuid() #define PerlProc_getgid() getgid() #define PerlProc_getegid() getegid() #define PerlProc_getlogin() getlogin() #define PerlProc_kill(i, a) kill((i), (a)) #define PerlProc_killpg(i, a) killpg((i), (a)) #define PerlProc_pause() Pause() #define PerlProc_popen(c, m) my_popen((c), (m)) #define PerlProc_popen_list(m,n,a) my_popen_list((m),(n),(a)) #define PerlProc_pclose(f) my_pclose((f)) #define PerlProc_pipe(fd) pipe((fd)) #define PerlProc_setuid(u) setuid((u)) #define PerlProc_setgid(g) setgid((g)) #define PerlProc_sleep(t) sleep((t)) #define PerlProc_times(t) times((t)) #define PerlProc_wait(t) wait((t)) #define PerlProc_waitpid(p,s,f) waitpid((p), (s), (f)) #define PerlProc_setjmp(b, n) Sigsetjmp((b), (n)) #define PerlProc_longjmp(b, n) Siglongjmp((b), (n)) #define PerlProc_signal(n, h) signal((n), (h)) #define PerlProc_fork() my_fork() #define PerlProc_getpid() getpid() #define PerlProc_gettimeofday(t,z) gettimeofday((t),(z)) #ifdef WIN32 #define PerlProc_DynaLoad(f) \ win32_dynaload((f)) #define PerlProc_GetOSError(s,e) \ win32_str_os_error((s), (e)) #define PerlProc_spawnvp(m, c, a) \ win32_spawnvp((m), (c), (a)) #undef PerlProc_signal #define PerlProc_signal(n, h) win32_signal((n), (h)) #endif #endif /* PERL_IMPLICIT_SYS */ /* Interface for perl socket functions */ #if defined(PERL_IMPLICIT_SYS) /* PerlSock */ struct IPerlSock; struct IPerlSockInfo; typedef u_long (*LPHtonl)(struct IPerlSock*, u_long); typedef u_short (*LPHtons)(struct IPerlSock*, u_short); typedef u_long (*LPNtohl)(struct IPerlSock*, u_long); typedef u_short (*LPNtohs)(struct IPerlSock*, u_short); typedef SOCKET (*LPAccept)(struct IPerlSock*, SOCKET, struct sockaddr*, int*); typedef int (*LPBind)(struct IPerlSock*, SOCKET, const struct sockaddr*, int); typedef int (*LPConnect)(struct IPerlSock*, SOCKET, const struct sockaddr*, int); typedef void (*LPEndhostent)(struct IPerlSock*); typedef void (*LPEndnetent)(struct IPerlSock*); typedef void (*LPEndprotoent)(struct IPerlSock*); typedef void (*LPEndservent)(struct IPerlSock*); typedef int (*LPGethostname)(struct IPerlSock*, char*, int); typedef int (*LPGetpeername)(struct IPerlSock*, SOCKET, struct sockaddr*, int*); typedef struct hostent* (*LPGethostbyaddr)(struct IPerlSock*, const char*, int, int); typedef struct hostent* (*LPGethostbyname)(struct IPerlSock*, const char*); typedef struct hostent* (*LPGethostent)(struct IPerlSock*); typedef struct netent* (*LPGetnetbyaddr)(struct IPerlSock*, long, int); typedef struct netent* (*LPGetnetbyname)(struct IPerlSock*, const char*); typedef struct netent* (*LPGetnetent)(struct IPerlSock*); typedef struct protoent*(*LPGetprotobyname)(struct IPerlSock*, const char*); typedef struct protoent*(*LPGetprotobynumber)(struct IPerlSock*, int); typedef struct protoent*(*LPGetprotoent)(struct IPerlSock*); typedef struct servent* (*LPGetservbyname)(struct IPerlSock*, const char*, const char*); typedef struct servent* (*LPGetservbyport)(struct IPerlSock*, int, const char*); typedef struct servent* (*LPGetservent)(struct IPerlSock*); typedef int (*LPGetsockname)(struct IPerlSock*, SOCKET, struct sockaddr*, int*); typedef int (*LPGetsockopt)(struct IPerlSock*, SOCKET, int, int, char*, int*); typedef unsigned long (*LPInetAddr)(struct IPerlSock*, const char*); typedef char* (*LPInetNtoa)(struct IPerlSock*, struct in_addr); typedef int (*LPListen)(struct IPerlSock*, SOCKET, int); typedef int (*LPRecv)(struct IPerlSock*, SOCKET, char*, int, int); typedef int (*LPRecvfrom)(struct IPerlSock*, SOCKET, char*, int, int, struct sockaddr*, int*); typedef int (*LPSelect)(struct IPerlSock*, int, char*, char*, char*, const struct timeval*); typedef int (*LPSend)(struct IPerlSock*, SOCKET, const char*, int, int); typedef int (*LPSendto)(struct IPerlSock*, SOCKET, const char*, int, int, const struct sockaddr*, int); typedef void (*LPSethostent)(struct IPerlSock*, int); typedef void (*LPSetnetent)(struct IPerlSock*, int); typedef void (*LPSetprotoent)(struct IPerlSock*, int); typedef void (*LPSetservent)(struct IPerlSock*, int); typedef int (*LPSetsockopt)(struct IPerlSock*, SOCKET, int, int, const char*, int); typedef int (*LPShutdown)(struct IPerlSock*, SOCKET, int); typedef SOCKET (*LPSocket)(struct IPerlSock*, int, int, int); typedef int (*LPSocketpair)(struct IPerlSock*, int, int, int, int*); #ifdef WIN32 typedef int (*LPClosesocket)(struct IPerlSock*, SOCKET s); #endif struct IPerlSock { LPHtonl pHtonl; LPHtons pHtons; LPNtohl pNtohl; LPNtohs pNtohs; LPAccept pAccept; LPBind pBind; LPConnect pConnect; LPEndhostent pEndhostent; LPEndnetent pEndnetent; LPEndprotoent pEndprotoent; LPEndservent pEndservent; LPGethostname pGethostname; LPGetpeername pGetpeername; LPGethostbyaddr pGethostbyaddr; LPGethostbyname pGethostbyname; LPGethostent pGethostent; LPGetnetbyaddr pGetnetbyaddr; LPGetnetbyname pGetnetbyname; LPGetnetent pGetnetent; LPGetprotobyname pGetprotobyname; LPGetprotobynumber pGetprotobynumber; LPGetprotoent pGetprotoent; LPGetservbyname pGetservbyname; LPGetservbyport pGetservbyport; LPGetservent pGetservent; LPGetsockname pGetsockname; LPGetsockopt pGetsockopt; LPInetAddr pInetAddr; LPInetNtoa pInetNtoa; LPListen pListen; LPRecv pRecv; LPRecvfrom pRecvfrom; LPSelect pSelect; LPSend pSend; LPSendto pSendto; LPSethostent pSethostent; LPSetnetent pSetnetent; LPSetprotoent pSetprotoent; LPSetservent pSetservent; LPSetsockopt pSetsockopt; LPShutdown pShutdown; LPSocket pSocket; LPSocketpair pSocketpair; #ifdef WIN32 LPClosesocket pClosesocket; #endif }; struct IPerlSockInfo { unsigned long nCount; /* number of entries expected */ struct IPerlSock perlSockList; }; #define PerlSock_htonl(x) \ (*PL_Sock->pHtonl)(PL_Sock, x) #define PerlSock_htons(x) \ (*PL_Sock->pHtons)(PL_Sock, x) #define PerlSock_ntohl(x) \ (*PL_Sock->pNtohl)(PL_Sock, x) #define PerlSock_ntohs(x) \ (*PL_Sock->pNtohs)(PL_Sock, x) #define PerlSock_accept(s, a, l) \ (*PL_Sock->pAccept)(PL_Sock, s, a, l) #define PerlSock_bind(s, n, l) \ (*PL_Sock->pBind)(PL_Sock, s, n, l) #define PerlSock_connect(s, n, l) \ (*PL_Sock->pConnect)(PL_Sock, s, n, l) #define PerlSock_endhostent() \ (*PL_Sock->pEndhostent)(PL_Sock) #define PerlSock_endnetent() \ (*PL_Sock->pEndnetent)(PL_Sock) #define PerlSock_endprotoent() \ (*PL_Sock->pEndprotoent)(PL_Sock) #define PerlSock_endservent() \ (*PL_Sock->pEndservent)(PL_Sock) #define PerlSock_gethostbyaddr(a, l, t) \ (*PL_Sock->pGethostbyaddr)(PL_Sock, a, l, t) #define PerlSock_gethostbyname(n) \ (*PL_Sock->pGethostbyname)(PL_Sock, n) #define PerlSock_gethostent() \ (*PL_Sock->pGethostent)(PL_Sock) #define PerlSock_gethostname(n, l) \ (*PL_Sock->pGethostname)(PL_Sock, n, l) #define PerlSock_getnetbyaddr(n, t) \ (*PL_Sock->pGetnetbyaddr)(PL_Sock, n, t) #define PerlSock_getnetbyname(c) \ (*PL_Sock->pGetnetbyname)(PL_Sock, c) #define PerlSock_getnetent() \ (*PL_Sock->pGetnetent)(PL_Sock) #define PerlSock_getpeername(s, n, l) \ (*PL_Sock->pGetpeername)(PL_Sock, s, n, l) #define PerlSock_getprotobyname(n) \ (*PL_Sock->pGetprotobyname)(PL_Sock, n) #define PerlSock_getprotobynumber(n) \ (*PL_Sock->pGetprotobynumber)(PL_Sock, n) #define PerlSock_getprotoent() \ (*PL_Sock->pGetprotoent)(PL_Sock) #define PerlSock_getservbyname(n, p) \ (*PL_Sock->pGetservbyname)(PL_Sock, n, p) #define PerlSock_getservbyport(port, p) \ (*PL_Sock->pGetservbyport)(PL_Sock, port, p) #define PerlSock_getservent() \ (*PL_Sock->pGetservent)(PL_Sock) #define PerlSock_getsockname(s, n, l) \ (*PL_Sock->pGetsockname)(PL_Sock, s, n, l) #define PerlSock_getsockopt(s,l,n,v,i) \ (*PL_Sock->pGetsockopt)(PL_Sock, s, l, n, v, i) #define PerlSock_inet_addr(c) \ (*PL_Sock->pInetAddr)(PL_Sock, c) #define PerlSock_inet_ntoa(i) \ (*PL_Sock->pInetNtoa)(PL_Sock, i) #define PerlSock_listen(s, b) \ (*PL_Sock->pListen)(PL_Sock, s, b) #define PerlSock_recv(s, b, l, f) \ (*PL_Sock->pRecv)(PL_Sock, s, b, l, f) #define PerlSock_recvfrom(s,b,l,f,from,fromlen) \ (*PL_Sock->pRecvfrom)(PL_Sock, s, b, l, f, from, fromlen) #define PerlSock_select(n, r, w, e, t) \ (*PL_Sock->pSelect)(PL_Sock, n, (char*)r, (char*)w, (char*)e, t) #define PerlSock_send(s, b, l, f) \ (*PL_Sock->pSend)(PL_Sock, s, b, l, f) #define PerlSock_sendto(s, b, l, f, t, tlen) \ (*PL_Sock->pSendto)(PL_Sock, s, b, l, f, t, tlen) #define PerlSock_sethostent(f) \ (*PL_Sock->pSethostent)(PL_Sock, f) #define PerlSock_setnetent(f) \ (*PL_Sock->pSetnetent)(PL_Sock, f) #define PerlSock_setprotoent(f) \ (*PL_Sock->pSetprotoent)(PL_Sock, f) #define PerlSock_setservent(f) \ (*PL_Sock->pSetservent)(PL_Sock, f) #define PerlSock_setsockopt(s, l, n, v, len) \ (*PL_Sock->pSetsockopt)(PL_Sock, s, l, n, v, len) #define PerlSock_shutdown(s, h) \ (*PL_Sock->pShutdown)(PL_Sock, s, h) #define PerlSock_socket(a, t, p) \ (*PL_Sock->pSocket)(PL_Sock, a, t, p) #define PerlSock_socketpair(a, t, p, f) \ (*PL_Sock->pSocketpair)(PL_Sock, a, t, p, f) #ifdef WIN32 #define PerlSock_closesocket(s) \ (*PL_Sock->pClosesocket)(PL_Sock, s) #endif #else /* PERL_IMPLICIT_SYS */ #define PerlSock_htonl(x) htonl(x) #define PerlSock_htons(x) htons(x) #define PerlSock_ntohl(x) ntohl(x) #define PerlSock_ntohs(x) ntohs(x) #define PerlSock_accept(s, a, l) accept(s, a, l) #define PerlSock_bind(s, n, l) bind(s, n, l) #define PerlSock_connect(s, n, l) connect(s, n, l) #define PerlSock_gethostbyaddr(a, l, t) gethostbyaddr(a, l, t) #define PerlSock_gethostbyname(n) gethostbyname(n) #define PerlSock_gethostent gethostent #define PerlSock_endhostent endhostent #define PerlSock_gethostname(n, l) gethostname(n, l) #define PerlSock_getnetbyaddr(n, t) getnetbyaddr(n, t) #define PerlSock_getnetbyname(n) getnetbyname(n) #define PerlSock_getnetent getnetent #define PerlSock_endnetent endnetent #define PerlSock_getpeername(s, n, l) getpeername(s, n, l) #define PerlSock_getprotobyname(n) getprotobyname(n) #define PerlSock_getprotobynumber(n) getprotobynumber(n) #define PerlSock_getprotoent getprotoent #define PerlSock_endprotoent endprotoent #define PerlSock_getservbyname(n, p) getservbyname(n, p) #define PerlSock_getservbyport(port, p) getservbyport(port, p) #define PerlSock_getservent getservent #define PerlSock_endservent endservent #define PerlSock_getsockname(s, n, l) getsockname(s, n, l) #define PerlSock_getsockopt(s,l,n,v,i) getsockopt(s, l, n, v, i) #define PerlSock_inet_addr(c) inet_addr(c) #define PerlSock_inet_ntoa(i) inet_ntoa(i) #define PerlSock_listen(s, b) listen(s, b) #define PerlSock_recv(s, b, l, f) recv(s, b, l, f) #define PerlSock_recvfrom(s, b, l, f, from, fromlen) \ recvfrom(s, b, l, f, from, fromlen) #define PerlSock_select(n, r, w, e, t) select(n, r, w, e, t) #define PerlSock_send(s, b, l, f) send(s, b, l, f) #define PerlSock_sendto(s, b, l, f, t, tlen) \ sendto(s, b, l, f, t, tlen) #define PerlSock_sethostent(f) sethostent(f) #define PerlSock_setnetent(f) setnetent(f) #define PerlSock_setprotoent(f) setprotoent(f) #define PerlSock_setservent(f) setservent(f) #define PerlSock_setsockopt(s, l, n, v, len) \ setsockopt(s, l, n, v, len) #define PerlSock_shutdown(s, h) shutdown(s, h) #define PerlSock_socket(a, t, p) socket(a, t, p) #define PerlSock_socketpair(a, t, p, f) socketpair(a, t, p, f) #ifdef WIN32 #define PerlSock_closesocket(s) closesocket(s) #endif #endif /* PERL_IMPLICIT_SYS */ #endif /* __Inc__IPerl___ */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ~perl.hnuW+A/* perl.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #ifndef H_PERL #define H_PERL 1 #ifdef PERL_FOR_X2P /* * This file is being used for x2p stuff. * Above symbol is defined via -D in 'x2p/Makefile.SH' * Decouple x2p stuff from some of perls more extreme eccentricities. */ #undef MULTIPLICITY #undef USE_STDIO #define USE_STDIO #endif /* PERL_FOR_X2P */ #if defined(DGUX) #include #endif #ifdef VOIDUSED # undef VOIDUSED #endif #define VOIDUSED 1 #ifdef PERL_MICRO # include "uconfig.h" #else # ifndef USE_CROSS_COMPILE # include "config.h" # else # include "xconfig.h" # endif #endif /* See L for detailed notes on * PERL_IMPLICIT_CONTEXT and PERL_IMPLICIT_SYS */ /* Note that from here --> to <-- the same logic is * repeated in makedef.pl, so be certain to update * both places when editing. */ #ifdef PERL_IMPLICIT_SYS /* PERL_IMPLICIT_SYS implies PerlMemShared != PerlMem so use slab allocator to avoid lots of MUTEX overhead */ # ifndef PL_OP_SLAB_ALLOC # define PL_OP_SLAB_ALLOC # endif #endif #ifdef USE_ITHREADS # if !defined(MULTIPLICITY) # define MULTIPLICITY # endif #endif #ifdef PERL_GLOBAL_STRUCT_PRIVATE # ifndef PERL_GLOBAL_STRUCT # define PERL_GLOBAL_STRUCT # endif #endif #ifdef PERL_GLOBAL_STRUCT # ifndef MULTIPLICITY # define MULTIPLICITY # endif #endif #ifdef MULTIPLICITY # ifndef PERL_IMPLICIT_CONTEXT # define PERL_IMPLICIT_CONTEXT # endif #endif /* undef WIN32 when building on Cygwin (for libwin32) - gph */ #ifdef __CYGWIN__ # undef WIN32 # undef _WIN32 #endif #if defined(__SYMBIAN32__) || (defined(__VC32__) && defined(WINS)) # ifndef SYMBIAN # define SYMBIAN # endif #endif #ifdef __SYMBIAN32__ # include "symbian/symbian_proto.h" #endif /* Any stack-challenged places. The limit varies (and often * is configurable), but using more than a kilobyte of stack * is usually dubious in these systems. */ #if defined(EPOC) || defined(__SYMBIAN32__) /* EPOC/Symbian: need to work around the SDK features. * * On WINS: MS VC5 generates calls to _chkstk, * * if a "large" stack frame is allocated. * * gcc on MARM does not generate calls like these. */ # define USE_HEAP_INSTEAD_OF_STACK #endif #/* Use the reentrant APIs like localtime_r and getpwent_r */ /* Win32 has naturally threadsafe libraries, no need to use any _r variants. */ #if defined(USE_ITHREADS) && !defined(USE_REENTRANT_API) && !defined(NETWARE) && !defined(WIN32) && !defined(PERL_DARWIN) # define USE_REENTRANT_API #endif /* <--- here ends the logic shared by perl.h and makedef.pl */ /* * PERL_DARWIN for MacOSX (__APPLE__ exists but is not officially sanctioned) * (The -DPERL_DARWIN comes from the hints/darwin.sh.) * __bsdi__ for BSD/OS */ #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(PERL_DARWIN) || defined(__bsdi__) || defined(BSD41) || defined(BSD42) || defined(BSD43) || defined(BSD44) # ifndef BSDish # define BSDish # endif #endif #undef START_EXTERN_C #undef END_EXTERN_C #undef EXTERN_C #ifdef __cplusplus # define START_EXTERN_C extern "C" { # define END_EXTERN_C } # define EXTERN_C extern "C" #else # define START_EXTERN_C # define END_EXTERN_C # define EXTERN_C extern #endif /* Fallback definitions in case we don't have definitions from config.h. This should only matter for systems that don't use Configure and haven't been modified to define PERL_STATIC_INLINE yet. */ #if !defined(PERL_STATIC_INLINE) # ifdef HAS_STATIC_INLINE # define PERL_STATIC_INLINE static inline # else # define PERL_STATIC_INLINE static # endif #endif #ifdef PERL_GLOBAL_STRUCT # ifndef PERL_GET_VARS # ifdef PERL_GLOBAL_STRUCT_PRIVATE EXTERN_C struct perl_vars* Perl_GetVarsPrivate(); # define PERL_GET_VARS() Perl_GetVarsPrivate() /* see miniperlmain.c */ # ifndef PERLIO_FUNCS_CONST # define PERLIO_FUNCS_CONST /* Can't have these lying around. */ # endif # else # define PERL_GET_VARS() PL_VarsPtr # endif # endif #endif #define pVAR register struct perl_vars* my_vars PERL_UNUSED_DECL #ifdef PERL_GLOBAL_STRUCT # define dVAR pVAR = (struct perl_vars*)PERL_GET_VARS() #else # define dVAR dNOOP #endif #ifdef PERL_IMPLICIT_CONTEXT # ifndef MULTIPLICITY # define MULTIPLICITY # endif # define tTHX PerlInterpreter* # define pTHX register tTHX my_perl PERL_UNUSED_DECL # define aTHX my_perl # ifdef PERL_GLOBAL_STRUCT # define dTHXa(a) dVAR; pTHX = (tTHX)a # else # define dTHXa(a) pTHX = (tTHX)a # endif # ifdef PERL_GLOBAL_STRUCT # define dTHX dVAR; pTHX = PERL_GET_THX # else # define dTHX pTHX = PERL_GET_THX # endif # define pTHX_ pTHX, # define aTHX_ aTHX, # define pTHX_1 2 # define pTHX_2 3 # define pTHX_3 4 # define pTHX_4 5 # define pTHX_5 6 # define pTHX_6 7 # define pTHX_7 8 # define pTHX_8 9 # define pTHX_9 10 # if defined(DEBUGGING) && !defined(PERL_TRACK_MEMPOOL) # define PERL_TRACK_MEMPOOL # endif #else # undef PERL_TRACK_MEMPOOL #endif #define STATIC static #ifndef PERL_CORE /* Do not use these macros. They were part of PERL_OBJECT, which was an * implementation of multiplicity using C++ objects. They have been left * here solely for the sake of XS code which has incorrectly * cargo-culted them. */ #define CPERLscope(x) x #define CPERLarg void #define CPERLarg_ #define _CPERLarg #define PERL_OBJECT_THIS #define _PERL_OBJECT_THIS #define PERL_OBJECT_THIS_ #define CALL_FPTR(fptr) (*fptr) #define MEMBER_TO_FPTR(name) name #endif /* !PERL_CORE */ #define CALLRUNOPS PL_runops #define CALLREGCOMP(sv, flags) Perl_pregcomp(aTHX_ (sv),(flags)) #define CALLREGCOMP_ENG(prog, sv, flags) (prog)->comp(aTHX_ sv, flags) #define CALLREGEXEC(prog,stringarg,strend,strbeg,minend,screamer,data,flags) \ RX_ENGINE(prog)->exec(aTHX_ (prog),(stringarg),(strend), \ (strbeg),(minend),(screamer),(data),(flags)) #define CALLREG_INTUIT_START(prog,sv,strpos,strend,flags,data) \ RX_ENGINE(prog)->intuit(aTHX_ (prog), (sv), (strpos), \ (strend),(flags),(data)) #define CALLREG_INTUIT_STRING(prog) \ RX_ENGINE(prog)->checkstr(aTHX_ (prog)) #define CALLREGFREE(prog) \ Perl_pregfree(aTHX_ (prog)) #define CALLREGFREE_PVT(prog) \ if(prog) RX_ENGINE(prog)->free(aTHX_ (prog)) #define CALLREG_NUMBUF_FETCH(rx,paren,usesv) \ RX_ENGINE(rx)->numbered_buff_FETCH(aTHX_ (rx),(paren),(usesv)) #define CALLREG_NUMBUF_STORE(rx,paren,value) \ RX_ENGINE(rx)->numbered_buff_STORE(aTHX_ (rx),(paren),(value)) #define CALLREG_NUMBUF_LENGTH(rx,sv,paren) \ RX_ENGINE(rx)->numbered_buff_LENGTH(aTHX_ (rx),(sv),(paren)) #define CALLREG_NAMED_BUFF_FETCH(rx, key, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_FETCH)) #define CALLREG_NAMED_BUFF_STORE(rx, key, value, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), (value), ((flags) | RXapif_STORE)) #define CALLREG_NAMED_BUFF_DELETE(rx, key, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx),(key), NULL, ((flags) | RXapif_DELETE)) #define CALLREG_NAMED_BUFF_CLEAR(rx, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_CLEAR)) #define CALLREG_NAMED_BUFF_EXISTS(rx, key, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), (key), NULL, ((flags) | RXapif_EXISTS)) #define CALLREG_NAMED_BUFF_FIRSTKEY(rx, flags) \ RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), NULL, ((flags) | RXapif_FIRSTKEY)) #define CALLREG_NAMED_BUFF_NEXTKEY(rx, lastkey, flags) \ RX_ENGINE(rx)->named_buff_iter(aTHX_ (rx), (lastkey), ((flags) | RXapif_NEXTKEY)) #define CALLREG_NAMED_BUFF_SCALAR(rx, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, ((flags) | RXapif_SCALAR)) #define CALLREG_NAMED_BUFF_COUNT(rx) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, RXapif_REGNAMES_COUNT) #define CALLREG_NAMED_BUFF_ALL(rx, flags) \ RX_ENGINE(rx)->named_buff(aTHX_ (rx), NULL, NULL, flags) #define CALLREG_PACKAGE(rx) \ RX_ENGINE(rx)->qr_package(aTHX_ (rx)) #if defined(USE_ITHREADS) #define CALLREGDUPE(prog,param) \ Perl_re_dup(aTHX_ (prog),(param)) #define CALLREGDUPE_PVT(prog,param) \ (prog ? RX_ENGINE(prog)->dupe(aTHX_ (prog),(param)) \ : (REGEXP *)NULL) #endif /* * Because of backward compatibility reasons the PERL_UNUSED_DECL * cannot be changed from postfix to PERL_UNUSED_DECL(x). Sigh. * * Note that there are C compilers such as MetroWerks CodeWarrior * which do not have an "inlined" way (like the gcc __attribute__) of * marking unused variables (they need e.g. a #pragma) and therefore * cpp macros like PERL_UNUSED_DECL cannot work for this purpose, even * if it were PERL_UNUSED_DECL(x), which it cannot be (see above). * */ #if defined(__SYMBIAN32__) && defined(__GNUC__) # ifdef __cplusplus # define PERL_UNUSED_DECL # else # define PERL_UNUSED_DECL __attribute__((unused)) # endif #endif #ifndef PERL_UNUSED_DECL # if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) # define PERL_UNUSED_DECL __attribute__unused__ # else # define PERL_UNUSED_DECL # endif #endif /* gcc -Wall: * for silencing unused variables that are actually used most of the time, * but we cannot quite get rid of, such as "ax" in PPCODE+noargs xsubs */ #ifndef PERL_UNUSED_ARG # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ # include # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) # else # define PERL_UNUSED_ARG(x) ((void)x) # endif #endif #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(x) ((void)x) #endif #ifdef USE_ITHREADS # define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) #else # define PERL_UNUSED_CONTEXT #endif #define NOOP /*EMPTY*/(void)0 /* cea2e8a9dd23747f accidentally lost the comment originally from the first check in of thread.h, explaining why we need dNOOP at all: */ /* Rats: if dTHR is just blank then the subsequent ";" throws an error */ /* Declaring a *function*, instead of a variable, ensures that we don't rely on being able to suppress "unused" warnings. */ #define dNOOP extern int Perl___notused(void) #ifndef pTHX /* Don't bother defining tTHX and sTHX; using them outside * code guarded by PERL_IMPLICIT_CONTEXT is an error. */ # define pTHX void # define pTHX_ # define aTHX # define aTHX_ # define dTHXa(a) dNOOP # define dTHX dNOOP # define pTHX_1 1 # define pTHX_2 2 # define pTHX_3 3 # define pTHX_4 4 # define pTHX_5 5 # define pTHX_6 6 # define pTHX_7 7 # define pTHX_8 8 # define pTHX_9 9 #endif #ifndef dVAR # define dVAR dNOOP #endif /* these are only defined for compatibility; should not be used internally */ #if !defined(pTHXo) && !defined(PERL_CORE) # define pTHXo pTHX # define pTHXo_ pTHX_ # define aTHXo aTHX # define aTHXo_ aTHX_ # define dTHXo dTHX # define dTHXoa(x) dTHXa(x) #endif #ifndef pTHXx # define pTHXx register PerlInterpreter *my_perl # define pTHXx_ pTHXx, # define aTHXx my_perl # define aTHXx_ aTHXx, # define dTHXx dTHX #endif /* Under PERL_IMPLICIT_SYS (used in Windows for fork emulation) * PerlIO_foo() expands to PL_StdIO->pFOO(PL_StdIO, ...). * dTHXs is therefore needed for all functions using PerlIO_foo(). */ #ifdef PERL_IMPLICIT_SYS # ifdef PERL_GLOBAL_STRUCT_PRIVATE # define dTHXs dVAR; dTHX # else # define dTHXs dTHX # endif #else # ifdef PERL_GLOBAL_STRUCT_PRIVATE # define dTHXs dVAR # else # define dTHXs dNOOP # endif #endif /* Some platforms require marking function declarations * for them to be exportable. Used in perlio.h, proto.h * is handled either by the makedef.pl or by defining the * PERL_CALLCONV to be something special. See also the * definition of XS() in XSUB.h. */ #ifndef PERL_EXPORT_C # ifdef __cplusplus # define PERL_EXPORT_C extern "C" # else # define PERL_EXPORT_C extern # endif #endif #ifndef PERL_XS_EXPORT_C # ifdef __cplusplus # define PERL_XS_EXPORT_C extern "C" # else # define PERL_XS_EXPORT_C # endif #endif #ifdef OP_IN_REGISTER # ifdef __GNUC__ # define stringify_immed(s) #s # define stringify(s) stringify_immed(s) register struct op *Perl_op asm(stringify(OP_IN_REGISTER)); # endif #endif /* gcc (-ansi) -pedantic doesn't allow gcc statement expressions, * g++ allows them but seems to have problems with them * (insane errors ensue). * g++ does not give insane errors now (RMB 2008-01-30, gcc 4.2.2). */ #if defined(PERL_GCC_PEDANTIC) || \ (defined(__GNUC__) && defined(__cplusplus) && \ ((__GNUC__ < 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ < 2)))) # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN # define PERL_GCC_BRACE_GROUPS_FORBIDDEN # endif #endif #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus) # ifndef PERL_USE_GCC_BRACE_GROUPS # define PERL_USE_GCC_BRACE_GROUPS # endif #endif /* * STMT_START { statements; } STMT_END; * can be used as a single statement, as in * if (x) STMT_START { ... } STMT_END; else ... * * Trying to select a version that gives no warnings... */ #if !(defined(STMT_START) && defined(STMT_END)) # ifdef PERL_USE_GCC_BRACE_GROUPS # define STMT_START (void)( /* gcc supports "({ STATEMENTS; })" */ # define STMT_END ) # else /* Now which other defined()s do we need here ??? */ # if (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) # define STMT_START if (1) # define STMT_END else (void)0 # else # define STMT_START do # define STMT_END while (0) # endif # endif #endif #ifndef BYTEORDER /* Should never happen -- byteorder is in config.h */ # define BYTEORDER 0x1234 #endif /* Overall memory policy? */ #ifndef CONSERVATIVE # define LIBERAL 1 #endif #if 'A' == 65 && 'I' == 73 && 'J' == 74 && 'Z' == 90 #define ASCIIish #else #undef ASCIIish #endif /* * The following contortions are brought to you on behalf of all the * standards, semi-standards, de facto standards, not-so-de-facto standards * of the world, as well as all the other botches anyone ever thought of. * The basic theory is that if we work hard enough here, the rest of the * code can be a lot prettier. Well, so much for theory. Sorry, Henry... */ /* define this once if either system, instead of cluttering up the src */ #if defined(MSDOS) || defined(atarist) || defined(WIN32) || defined(NETWARE) #define DOSISH 1 #endif #if defined(__STDC__) || defined(_AIX) || defined(__stdc__) || defined(__cplusplus) || defined(EPOC) || defined(NETWARE) || defined(__SYMBIAN32__) # define STANDARD_C 1 #endif #if defined(__cplusplus) || defined(WIN32) || defined(__sgi) || defined(__EMX__) || defined(__DGUX) || defined(EPOC) || defined(__QNX__) || defined(NETWARE) || defined(PERL_MICRO) # define DONT_DECLARE_STD 1 #endif #if defined(HASVOLATILE) || defined(STANDARD_C) # define VOL volatile #else # define VOL #endif #define TAINT (PL_tainted = TRUE) #define TAINT_NOT (PL_tainted = FALSE) #define TAINT_IF(c) if (c) { PL_tainted = TRUE; } #define TAINT_ENV() if (PL_tainting) { taint_env(); } #define TAINT_PROPER(s) if (PL_tainting) { taint_proper(NULL, s); } /* flags used internally only within pp_subst and pp_substcont */ #ifdef PERL_CORE # define SUBST_TAINT_STR 1 /* string tainted */ # define SUBST_TAINT_PAT 2 /* pattern tainted */ # define SUBST_TAINT_REPL 4 /* replacement tainted */ # define SUBST_TAINT_RETAINT 8 /* use re'taint' in scope */ # define SUBST_TAINT_BOOLRET 16 /* return is boolean (don't taint) */ #endif /* XXX All process group stuff is handled in pp_sys.c. Should these defines move there? If so, I could simplify this a lot. --AD 9/96. */ /* Process group stuff changed from traditional BSD to POSIX. perlfunc.pod documents the traditional BSD-style syntax, so we'll try to preserve that, if possible. */ #ifdef HAS_SETPGID # define BSD_SETPGRP(pid, pgrp) setpgid((pid), (pgrp)) #else # if defined(HAS_SETPGRP) && defined(USE_BSD_SETPGRP) # define BSD_SETPGRP(pid, pgrp) setpgrp((pid), (pgrp)) # else # ifdef HAS_SETPGRP2 /* DG/UX */ # define BSD_SETPGRP(pid, pgrp) setpgrp2((pid), (pgrp)) # endif # endif #endif #if defined(BSD_SETPGRP) && !defined(HAS_SETPGRP) # define HAS_SETPGRP /* Well, effectively it does . . . */ #endif /* getpgid isn't POSIX, but at least Solaris and Linux have it, and it makes our life easier :-) so we'll try it. */ #ifdef HAS_GETPGID # define BSD_GETPGRP(pid) getpgid((pid)) #else # if defined(HAS_GETPGRP) && defined(USE_BSD_GETPGRP) # define BSD_GETPGRP(pid) getpgrp((pid)) # else # ifdef HAS_GETPGRP2 /* DG/UX */ # define BSD_GETPGRP(pid) getpgrp2((pid)) # endif # endif #endif #if defined(BSD_GETPGRP) && !defined(HAS_GETPGRP) # define HAS_GETPGRP /* Well, effectively it does . . . */ #endif /* These are not exact synonyms, since setpgrp() and getpgrp() may have different behaviors, but perl.h used to define USE_BSDPGRP (prior to 5.003_05) so some extension might depend on it. */ #if defined(USE_BSD_SETPGRP) || defined(USE_BSD_GETPGRP) # ifndef USE_BSDPGRP # define USE_BSDPGRP # endif #endif /* HP-UX 10.X CMA (Common Multithreaded Architecture) insists that pthread.h must be included before all other header files. */ #if defined(USE_ITHREADS) && defined(PTHREAD_H_FIRST) && defined(I_PTHREAD) # include #endif #ifndef _TYPES_ /* If types.h defines this it's easy. */ # ifndef major /* Does everyone's types.h define this? */ # include # endif #endif #ifdef __cplusplus # ifndef I_STDARG # define I_STDARG 1 # endif #endif #ifdef I_STDARG # include #else # ifdef I_VARARGS # include # endif #endif #ifdef USE_NEXT_CTYPE #if NX_CURRENT_COMPILER_RELEASE >= 500 # include #else # if NX_CURRENT_COMPILER_RELEASE >= 400 # include # else /* NX_CURRENT_COMPILER_RELEASE < 400 */ # include # endif /* NX_CURRENT_COMPILER_RELEASE >= 400 */ #endif /* NX_CURRENT_COMPILER_RELEASE >= 500 */ #else /* !USE_NEXT_CTYPE */ #include #endif /* USE_NEXT_CTYPE */ #ifdef METHOD /* Defined by OSF/1 v3.0 by ctype.h */ #undef METHOD #endif #ifdef PERL_MICRO # define NO_LOCALE #endif #ifdef I_LOCALE # include #endif #if !defined(NO_LOCALE) && defined(HAS_SETLOCALE) # define USE_LOCALE # if !defined(NO_LOCALE_COLLATE) && defined(LC_COLLATE) \ && defined(HAS_STRXFRM) # define USE_LOCALE_COLLATE # endif # if !defined(NO_LOCALE_CTYPE) && defined(LC_CTYPE) # define USE_LOCALE_CTYPE # endif # if !defined(NO_LOCALE_NUMERIC) && defined(LC_NUMERIC) # define USE_LOCALE_NUMERIC # endif #endif /* !NO_LOCALE && HAS_SETLOCALE */ #include #ifdef I_SYS_PARAM # ifdef PARAM_NEEDS_TYPES # include # endif # include #endif /* Use all the "standard" definitions? */ #if defined(STANDARD_C) && defined(I_STDLIB) # include #endif /* If this causes problems, set i_unistd=undef in the hint file. */ #ifdef I_UNISTD # include #endif /* for WCOREDUMP */ #ifdef I_SYS_WAIT # include #endif #ifdef __SYMBIAN32__ # undef _SC_ARG_MAX /* Symbian has _SC_ARG_MAX but no sysconf() */ #endif #if defined(HAS_SYSCALL) && !defined(HAS_SYSCALL_PROTO) && !defined(PERL_MICRO) EXTERN_C int syscall(int, ...); #endif #if defined(HAS_USLEEP) && !defined(HAS_USLEEP_PROTO) && !defined(PERL_MICRO) EXTERN_C int usleep(unsigned int); #endif /* Funky places that do not have socket stuff. */ #if defined(__LIBCATAMOUNT__) # define MYSWAP #endif #ifdef PERL_MICRO /* Last chance to export Perl_my_swap */ # define MYSWAP #endif #ifdef PERL_CORE /* macros for correct constant construction */ # if INTSIZE >= 2 # define U16_CONST(x) ((U16)x##U) # else # define U16_CONST(x) ((U16)x##UL) # endif # if INTSIZE >= 4 # define U32_CONST(x) ((U32)x##U) # else # define U32_CONST(x) ((U32)x##UL) # endif # ifdef HAS_QUAD # if INTSIZE >= 8 # define U64_CONST(x) ((U64)x##U) # elif LONGSIZE >= 8 # define U64_CONST(x) ((U64)x##UL) # elif QUADKIND == QUAD_IS_LONG_LONG # define U64_CONST(x) ((U64)x##ULL) # else /* best guess we can make */ # define U64_CONST(x) ((U64)x##UL) # endif # endif /* byte-swapping functions for big-/little-endian conversion */ # define _swab_16_(x) ((U16)( \ (((U16)(x) & U16_CONST(0x00ff)) << 8) | \ (((U16)(x) & U16_CONST(0xff00)) >> 8) )) # define _swab_32_(x) ((U32)( \ (((U32)(x) & U32_CONST(0x000000ff)) << 24) | \ (((U32)(x) & U32_CONST(0x0000ff00)) << 8) | \ (((U32)(x) & U32_CONST(0x00ff0000)) >> 8) | \ (((U32)(x) & U32_CONST(0xff000000)) >> 24) )) # ifdef HAS_QUAD # define _swab_64_(x) ((U64)( \ (((U64)(x) & U64_CONST(0x00000000000000ff)) << 56) | \ (((U64)(x) & U64_CONST(0x000000000000ff00)) << 40) | \ (((U64)(x) & U64_CONST(0x0000000000ff0000)) << 24) | \ (((U64)(x) & U64_CONST(0x00000000ff000000)) << 8) | \ (((U64)(x) & U64_CONST(0x000000ff00000000)) >> 8) | \ (((U64)(x) & U64_CONST(0x0000ff0000000000)) >> 24) | \ (((U64)(x) & U64_CONST(0x00ff000000000000)) >> 40) | \ (((U64)(x) & U64_CONST(0xff00000000000000)) >> 56) )) # endif /*----------------------------------------------------------------------------*/ # if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678 /* little-endian */ /*----------------------------------------------------------------------------*/ # define my_htole16(x) (x) # define my_letoh16(x) (x) # define my_htole32(x) (x) # define my_letoh32(x) (x) # define my_htobe16(x) _swab_16_(x) # define my_betoh16(x) _swab_16_(x) # define my_htobe32(x) _swab_32_(x) # define my_betoh32(x) _swab_32_(x) # ifdef HAS_QUAD # define my_htole64(x) (x) # define my_letoh64(x) (x) # define my_htobe64(x) _swab_64_(x) # define my_betoh64(x) _swab_64_(x) # endif # define my_htoles(x) (x) # define my_letohs(x) (x) # define my_htolei(x) (x) # define my_letohi(x) (x) # define my_htolel(x) (x) # define my_letohl(x) (x) # if SHORTSIZE == 1 # define my_htobes(x) (x) # define my_betohs(x) (x) # elif SHORTSIZE == 2 # define my_htobes(x) _swab_16_(x) # define my_betohs(x) _swab_16_(x) # elif SHORTSIZE == 4 # define my_htobes(x) _swab_32_(x) # define my_betohs(x) _swab_32_(x) # elif SHORTSIZE == 8 # define my_htobes(x) _swab_64_(x) # define my_betohs(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOBES # define PERL_NEED_MY_BETOHS # endif # if INTSIZE == 1 # define my_htobei(x) (x) # define my_betohi(x) (x) # elif INTSIZE == 2 # define my_htobei(x) _swab_16_(x) # define my_betohi(x) _swab_16_(x) # elif INTSIZE == 4 # define my_htobei(x) _swab_32_(x) # define my_betohi(x) _swab_32_(x) # elif INTSIZE == 8 # define my_htobei(x) _swab_64_(x) # define my_betohi(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOBEI # define PERL_NEED_MY_BETOHI # endif # if LONGSIZE == 1 # define my_htobel(x) (x) # define my_betohl(x) (x) # elif LONGSIZE == 2 # define my_htobel(x) _swab_16_(x) # define my_betohl(x) _swab_16_(x) # elif LONGSIZE == 4 # define my_htobel(x) _swab_32_(x) # define my_betohl(x) _swab_32_(x) # elif LONGSIZE == 8 # define my_htobel(x) _swab_64_(x) # define my_betohl(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOBEL # define PERL_NEED_MY_BETOHL # endif # define my_htolen(p,n) NOOP # define my_letohn(p,n) NOOP # define my_htoben(p,n) my_swabn(p,n) # define my_betohn(p,n) my_swabn(p,n) /*----------------------------------------------------------------------------*/ # elif BYTEORDER == 0x4321 || BYTEORDER == 0x87654321 /* big-endian */ /*----------------------------------------------------------------------------*/ # define my_htobe16(x) (x) # define my_betoh16(x) (x) # define my_htobe32(x) (x) # define my_betoh32(x) (x) # define my_htole16(x) _swab_16_(x) # define my_letoh16(x) _swab_16_(x) # define my_htole32(x) _swab_32_(x) # define my_letoh32(x) _swab_32_(x) # ifdef HAS_QUAD # define my_htobe64(x) (x) # define my_betoh64(x) (x) # define my_htole64(x) _swab_64_(x) # define my_letoh64(x) _swab_64_(x) # endif # define my_htobes(x) (x) # define my_betohs(x) (x) # define my_htobei(x) (x) # define my_betohi(x) (x) # define my_htobel(x) (x) # define my_betohl(x) (x) # if SHORTSIZE == 1 # define my_htoles(x) (x) # define my_letohs(x) (x) # elif SHORTSIZE == 2 # define my_htoles(x) _swab_16_(x) # define my_letohs(x) _swab_16_(x) # elif SHORTSIZE == 4 # define my_htoles(x) _swab_32_(x) # define my_letohs(x) _swab_32_(x) # elif SHORTSIZE == 8 # define my_htoles(x) _swab_64_(x) # define my_letohs(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOLES # define PERL_NEED_MY_LETOHS # endif # if INTSIZE == 1 # define my_htolei(x) (x) # define my_letohi(x) (x) # elif INTSIZE == 2 # define my_htolei(x) _swab_16_(x) # define my_letohi(x) _swab_16_(x) # elif INTSIZE == 4 # define my_htolei(x) _swab_32_(x) # define my_letohi(x) _swab_32_(x) # elif INTSIZE == 8 # define my_htolei(x) _swab_64_(x) # define my_letohi(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOLEI # define PERL_NEED_MY_LETOHI # endif # if LONGSIZE == 1 # define my_htolel(x) (x) # define my_letohl(x) (x) # elif LONGSIZE == 2 # define my_htolel(x) _swab_16_(x) # define my_letohl(x) _swab_16_(x) # elif LONGSIZE == 4 # define my_htolel(x) _swab_32_(x) # define my_letohl(x) _swab_32_(x) # elif LONGSIZE == 8 # define my_htolel(x) _swab_64_(x) # define my_letohl(x) _swab_64_(x) # else # define PERL_NEED_MY_HTOLEL # define PERL_NEED_MY_LETOHL # endif # define my_htolen(p,n) my_swabn(p,n) # define my_letohn(p,n) my_swabn(p,n) # define my_htoben(p,n) NOOP # define my_betohn(p,n) NOOP /*----------------------------------------------------------------------------*/ # else /* all other byte-orders */ /*----------------------------------------------------------------------------*/ # define PERL_NEED_MY_HTOLE16 # define PERL_NEED_MY_LETOH16 # define PERL_NEED_MY_HTOBE16 # define PERL_NEED_MY_BETOH16 # define PERL_NEED_MY_HTOLE32 # define PERL_NEED_MY_LETOH32 # define PERL_NEED_MY_HTOBE32 # define PERL_NEED_MY_BETOH32 # ifdef HAS_QUAD # define PERL_NEED_MY_HTOLE64 # define PERL_NEED_MY_LETOH64 # define PERL_NEED_MY_HTOBE64 # define PERL_NEED_MY_BETOH64 # endif # define PERL_NEED_MY_HTOLES # define PERL_NEED_MY_LETOHS # define PERL_NEED_MY_HTOBES # define PERL_NEED_MY_BETOHS # define PERL_NEED_MY_HTOLEI # define PERL_NEED_MY_LETOHI # define PERL_NEED_MY_HTOBEI # define PERL_NEED_MY_BETOHI # define PERL_NEED_MY_HTOLEL # define PERL_NEED_MY_LETOHL # define PERL_NEED_MY_HTOBEL # define PERL_NEED_MY_BETOHL /*----------------------------------------------------------------------------*/ # endif /* end of byte-order macros */ /*----------------------------------------------------------------------------*/ /* The old value was hard coded at 1008. (4096-16) seems to be a bit faster, at least on FreeBSD. YMMV, so experiment. */ #ifndef PERL_ARENA_SIZE #define PERL_ARENA_SIZE 4080 #endif /* Maximum level of recursion */ #ifndef PERL_SUB_DEPTH_WARN #define PERL_SUB_DEPTH_WARN 100 #endif #endif /* PERL_CORE */ /* We no longer default to creating a new SV for GvSV. Do this before embed. */ #ifndef PERL_CREATE_GVSV # ifndef PERL_DONT_CREATE_GVSV # define PERL_DONT_CREATE_GVSV # endif #endif #if !defined(HAS_WAITPID) && !defined(HAS_WAIT4) || defined(HAS_WAITPID_RUNTIME) #define PERL_USES_PL_PIDSTATUS #endif #if !defined(OS2) && !defined(WIN32) && !defined(DJGPP) && !defined(EPOC) && !defined(__SYMBIAN32__) #define PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION #endif #define MEM_SIZE Size_t /* Round all values passed to malloc up, by default to a multiple of sizeof(size_t) */ #ifndef PERL_STRLEN_ROUNDUP_QUANTUM #define PERL_STRLEN_ROUNDUP_QUANTUM Size_t_size #endif /* sv_grow() will expand strings by at least a certain percentage of the previously *used* length to avoid excessive calls to realloc(). The default is 25% of the current length. */ #ifndef PERL_STRLEN_EXPAND_SHIFT # define PERL_STRLEN_EXPAND_SHIFT 2 #endif #if defined(STANDARD_C) && defined(I_STDDEF) # include # define STRUCT_OFFSET(s,m) offsetof(s,m) #else # define STRUCT_OFFSET(s,m) (Size_t)(&(((s *)0)->m)) #endif #ifndef __SYMBIAN32__ # if defined(I_STRING) || defined(__cplusplus) # include # else # include # endif #endif /* This comes after so we don't try to change the standard * library prototypes; we'll use our own in proto.h instead. */ #ifdef MYMALLOC # ifdef PERL_POLLUTE_MALLOC # ifndef PERL_EXTMALLOC_DEF # define Perl_malloc malloc # define Perl_calloc calloc # define Perl_realloc realloc # define Perl_mfree free # endif # else # define EMBEDMYMALLOC /* for compatibility */ # endif # define safemalloc Perl_malloc # define safecalloc Perl_calloc # define saferealloc Perl_realloc # define safefree Perl_mfree # define CHECK_MALLOC_TOO_LATE_FOR_(code) STMT_START { \ if (!PL_tainting && MallocCfg_ptr[MallocCfg_cfg_env_read]) \ code; \ } STMT_END # define CHECK_MALLOC_TOO_LATE_FOR(ch) \ CHECK_MALLOC_TOO_LATE_FOR_(MALLOC_TOO_LATE_FOR(ch)) # define panic_write2(s) write(2, s, strlen(s)) # define CHECK_MALLOC_TAINT(newval) \ CHECK_MALLOC_TOO_LATE_FOR_( \ if (newval) { \ panic_write2("panic: tainting with $ENV{PERL_MALLOC_OPT}\n");\ exit(1); }) # define MALLOC_CHECK_TAINT(argc,argv,env) STMT_START { \ if (doing_taint(argc,argv,env)) { \ MallocCfg_ptr[MallocCfg_skip_cfg_env] = 1; \ }} STMT_END; #else /* MYMALLOC */ # define safemalloc safesysmalloc # define safecalloc safesyscalloc # define saferealloc safesysrealloc # define safefree safesysfree # define CHECK_MALLOC_TOO_LATE_FOR(ch) ((void)0) # define CHECK_MALLOC_TAINT(newval) ((void)0) # define MALLOC_CHECK_TAINT(argc,argv,env) #endif /* MYMALLOC */ /* diag_listed_as: "-T" is on the #! line, it must also be used on the command line */ #define TOO_LATE_FOR_(ch,what) Perl_croak(aTHX_ "\"-%c\" is on the #! line, it must also be used on the command line%s", (char)(ch), what) #define TOO_LATE_FOR(ch) TOO_LATE_FOR_(ch, "") #define MALLOC_TOO_LATE_FOR(ch) TOO_LATE_FOR_(ch, " with $ENV{PERL_MALLOC_OPT}") #define MALLOC_CHECK_TAINT2(argc,argv) MALLOC_CHECK_TAINT(argc,argv,NULL) #if !defined(HAS_STRCHR) && defined(HAS_INDEX) && !defined(strchr) #define strchr index #define strrchr rindex #endif #ifdef I_MEMORY # include #endif #ifdef HAS_MEMCPY # if !defined(STANDARD_C) && !defined(I_STRING) && !defined(I_MEMORY) # ifndef memcpy extern char * memcpy (char*, char*, int); # endif # endif #else # ifndef memcpy # ifdef HAS_BCOPY # define memcpy(d,s,l) bcopy(s,d,l) # else # define memcpy(d,s,l) my_bcopy(s,d,l) # endif # endif #endif /* HAS_MEMCPY */ #ifdef HAS_MEMSET # if !defined(STANDARD_C) && !defined(I_STRING) && !defined(I_MEMORY) # ifndef memset extern char *memset (char*, int, int); # endif # endif #else # undef memset # define memset(d,c,l) my_memset(d,c,l) #endif /* HAS_MEMSET */ #if !defined(HAS_MEMMOVE) && !defined(memmove) # if defined(HAS_BCOPY) && defined(HAS_SAFE_BCOPY) # define memmove(d,s,l) bcopy(s,d,l) # else # if defined(HAS_MEMCPY) && defined(HAS_SAFE_MEMCPY) # define memmove(d,s,l) memcpy(d,s,l) # else # define memmove(d,s,l) my_bcopy(s,d,l) # endif # endif #endif #if defined(mips) && defined(ultrix) && !defined(__STDC__) # undef HAS_MEMCMP #endif #if defined(HAS_MEMCMP) && defined(HAS_SANE_MEMCMP) # if !defined(STANDARD_C) && !defined(I_STRING) && !defined(I_MEMORY) # ifndef memcmp extern int memcmp (char*, char*, int); # endif # endif # ifdef BUGGY_MSC # pragma function(memcmp) # endif #else # ifndef memcmp # define memcmp my_memcmp # endif #endif /* HAS_MEMCMP && HAS_SANE_MEMCMP */ #ifndef memzero # ifdef HAS_MEMSET # define memzero(d,l) memset(d,0,l) # else # ifdef HAS_BZERO # define memzero(d,l) bzero(d,l) # else # define memzero(d,l) my_bzero(d,l) # endif # endif #endif #ifndef PERL_MICRO #ifndef memchr # ifndef HAS_MEMCHR # define memchr(s,c,n) ninstr((char*)(s), ((char*)(s)) + n, &(c), &(c) + 1) # endif #endif #endif #ifndef HAS_BCMP # ifndef bcmp # define bcmp(s1,s2,l) memcmp(s1,s2,l) # endif #endif /* !HAS_BCMP */ #ifdef I_NETINET_IN # include #endif #ifdef I_ARPA_INET # include #endif #if defined(SF_APPEND) && defined(USE_SFIO) && defined(I_SFIO) /* defines SF_APPEND and might define SF_APPEND * (the neo-BSD seem to do this). */ # undef SF_APPEND #endif #ifdef I_SYS_STAT # include #endif /* Microsoft VC's sys/stat.h defines all S_Ixxx macros except S_IFIFO. This definition should ideally go into win32/win32.h, but S_IFIFO is used later here in perl.h before win32/win32.h is being included. */ #if !defined(S_IFIFO) && defined(_S_IFIFO) # define S_IFIFO _S_IFIFO #endif /* The stat macros for Amdahl UTS, Unisoft System V/88 (and derivatives like UTekV) are broken, sometimes giving false positives. Undefine them here and let the code below set them to proper values. The ghs macro stands for GreenHills Software C-1.8.5 which is the C compiler for sysV88 and the various derivatives. This header file bug is corrected in gcc-2.5.8 and later versions. --Kaveh Ghazi (ghazi@noc.rutgers.edu) 10/3/94. */ #if defined(uts) || (defined(m88k) && defined(ghs)) # undef S_ISDIR # undef S_ISCHR # undef S_ISBLK # undef S_ISREG # undef S_ISFIFO # undef S_ISLNK #endif #ifdef I_TIME # include #endif #ifdef I_SYS_TIME # ifdef I_SYS_TIME_KERNEL # define KERNEL # endif # include # ifdef I_SYS_TIME_KERNEL # undef KERNEL # endif #endif #if defined(HAS_TIMES) && defined(I_SYS_TIMES) # include #endif #if defined(HAS_STRERROR) && (!defined(HAS_MKDIR) || !defined(HAS_RMDIR)) # undef HAS_STRERROR #endif #include #if defined(WIN32) && defined(PERL_IMPLICIT_SYS) # define WIN32SCK_IS_STDSCK /* don't pull in custom wsock layer */ #endif /* In Tru64 use the 4.4BSD struct msghdr, not the 4.3 one. * This is important for using IPv6. * For OSF/1 3.2, however, defining _SOCKADDR_LEN would be * a bad idea since it breaks send() and recv(). */ #if defined(__osf__) && defined(__alpha) && !defined(_SOCKADDR_LEN) && !defined(DEC_OSF1_3_X) # define _SOCKADDR_LEN #endif #if defined(HAS_SOCKET) && !defined(WIN32) /* WIN32 handles sockets via win32.h */ # include # if defined(USE_SOCKS) && defined(I_SOCKS) # if !defined(INCLUDE_PROTOTYPES) # define INCLUDE_PROTOTYPES /* for */ # define PERL_SOCKS_NEED_PROTOTYPES # endif # include # ifdef PERL_SOCKS_NEED_PROTOTYPES /* keep cpp space clean */ # undef INCLUDE_PROTOTYPES # undef PERL_SOCKS_NEED_PROTOTYPES # endif # endif # ifdef I_NETDB # ifdef NETWARE # include # endif # include # endif # ifndef ENOTSOCK # ifdef I_NET_ERRNO # include # endif # endif #endif /* sockatmark() is so new (2001) that many places might have it hidden * behind some -D_BLAH_BLAH_SOURCE guard. The __THROW magic is required * e.g. in Gentoo, see http://bugs.gentoo.org/show_bug.cgi?id=12605 */ #if defined(HAS_SOCKATMARK) && !defined(HAS_SOCKATMARK_PROTO) # if defined(__THROW) && defined(__GLIBC__) int sockatmark(int) __THROW; # else int sockatmark(int); # endif #endif #if defined(__osf__) && defined(__cplusplus) && !defined(_XOPEN_SOURCE_EXTENDED) /* Tru64 "cxx" (C++), see hints/dec_osf.sh for why the _XOPEN_SOURCE_EXTENDED cannot be defined. */ EXTERN_C int fchdir(int); EXTERN_C int flock(int, int); EXTERN_C int fseeko(FILE *, off_t, int); EXTERN_C off_t ftello(FILE *); #endif #if defined(__SUNPRO_CC) /* SUNWspro CC (C++) */ EXTERN_C char *crypt(const char *, const char *); EXTERN_C char **environ; #endif #if defined(__cplusplus) # if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) EXTERN_C char **environ; # elif defined(__CYGWIN__) EXTERN_C char *crypt(const char *, const char *); #endif #endif #ifdef SETERRNO # undef SETERRNO /* SOCKS might have defined this */ #endif #ifdef VMS # define SETERRNO(errcode,vmserrcode) \ STMT_START { \ set_errno(errcode); \ set_vaxc_errno(vmserrcode); \ } STMT_END # define dSAVEDERRNO int saved_errno; unsigned saved_vms_errno # define dSAVE_ERRNO int saved_errno = errno; unsigned saved_vms_errno = vaxc$errno # define SAVE_ERRNO ( saved_errno = errno, saved_vms_errno = vaxc$errno ) # define RESTORE_ERRNO SETERRNO(saved_errno, saved_vms_errno) # define LIB_INVARG LIB$_INVARG # define RMS_DIR RMS$_DIR # define RMS_FAC RMS$_FAC # define RMS_FEX RMS$_FEX # define RMS_FNF RMS$_FNF # define RMS_IFI RMS$_IFI # define RMS_ISI RMS$_ISI # define RMS_PRV RMS$_PRV # define SS_ACCVIO SS$_ACCVIO # define SS_DEVOFFLINE SS$_DEVOFFLINE # define SS_IVCHAN SS$_IVCHAN # define SS_NORMAL SS$_NORMAL #else # define SETERRNO(errcode,vmserrcode) (errno = (errcode)) # define dSAVEDERRNO int saved_errno # define dSAVE_ERRNO int saved_errno = errno # define SAVE_ERRNO (saved_errno = errno) # define RESTORE_ERRNO (errno = saved_errno) # define LIB_INVARG 0 # define RMS_DIR 0 # define RMS_FAC 0 # define RMS_FEX 0 # define RMS_FNF 0 # define RMS_IFI 0 # define RMS_ISI 0 # define RMS_PRV 0 # define SS_ACCVIO 0 # define SS_DEVOFFLINE 0 # define SS_IVCHAN 0 # define SS_NORMAL 0 #endif #define ERRSV GvSVn(PL_errgv) #define CLEAR_ERRSV() STMT_START { \ if (!GvSV(PL_errgv)) { \ sv_setpvs(GvSV(gv_add_by_type(PL_errgv, SVt_PV)), ""); \ } else if (SvREADONLY(GvSV(PL_errgv))) { \ SvREFCNT_dec(GvSV(PL_errgv)); \ GvSV(PL_errgv) = newSVpvs(""); \ } else { \ SV *const errsv = GvSV(PL_errgv); \ sv_setpvs(errsv, ""); \ if (SvMAGICAL(errsv)) { \ mg_free(errsv); \ } \ SvPOK_only(errsv); \ } \ } STMT_END #ifdef PERL_CORE # define DEFSV (0 + GvSVn(PL_defgv)) # define DEFSV_set(sv) \ (SvREFCNT_dec(GvSV(PL_defgv)), GvSV(PL_defgv) = SvREFCNT_inc(sv)) # define SAVE_DEFSV \ ( \ save_gp(PL_defgv, 0), \ GvINTRO_off(PL_defgv), \ SAVEGENERICSV(GvSV(PL_defgv)), \ GvSV(PL_defgv) = NULL \ ) #else # define DEFSV GvSVn(PL_defgv) # define DEFSV_set(sv) (GvSV(PL_defgv) = (sv)) # define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) #endif #define ERRHV GvHV(PL_errgv) /* XXX unused, here for compatibility */ #ifndef errno extern int errno; /* ANSI allows errno to be an lvalue expr. * For example in multithreaded environments * something like this might happen: * extern int *_errno(void); * #define errno (*_errno()) */ #endif #ifdef HAS_STRERROR # ifdef VMS char *strerror (int,...); # else #ifndef DONT_DECLARE_STD char *strerror (int); #endif # endif # ifndef Strerror # define Strerror strerror # endif #else # ifdef HAS_SYS_ERRLIST extern int sys_nerr; extern char *sys_errlist[]; # ifndef Strerror # define Strerror(e) \ ((e) < 0 || (e) >= sys_nerr ? "(unknown)" : sys_errlist[e]) # endif # endif #endif #ifdef I_SYS_IOCTL # ifndef _IOCTL_ # include # endif #endif #if defined(mc300) || defined(mc500) || defined(mc700) || defined(mc6000) # ifdef HAS_SOCKETPAIR # undef HAS_SOCKETPAIR # endif # ifdef I_NDBM # undef I_NDBM # endif #endif #ifndef HAS_SOCKETPAIR # ifdef HAS_SOCKET # define socketpair Perl_my_socketpair # endif #endif #if INTSIZE == 2 # define htoni htons # define ntohi ntohs #else # define htoni htonl # define ntohi ntohl #endif /* Configure already sets Direntry_t */ #if defined(I_DIRENT) # include /* NeXT needs dirent + sys/dir.h */ # if defined(I_SYS_DIR) && (defined(NeXT) || defined(__NeXT__)) # include # endif #else # ifdef I_SYS_NDIR # include # else # ifdef I_SYS_DIR # ifdef hp9000s500 # include /* may be wrong in the future */ # else # include # endif # endif # endif #endif #ifdef PERL_MICRO # ifndef DIR # define DIR void # endif #endif #ifdef FPUTS_BOTCH /* work around botch in SunOS 4.0.1 and 4.0.2 */ # ifndef fputs # define fputs(sv,fp) fprintf(fp,"%s",sv) # endif #endif /* * The following gobbledygook brought to you on behalf of __STDC__. * (I could just use #ifndef __STDC__, but this is more bulletproof * in the face of half-implementations.) */ #if defined(I_SYSMODE) && !defined(PERL_MICRO) #include #endif #ifndef S_IFMT # ifdef _S_IFMT # define S_IFMT _S_IFMT # else # define S_IFMT 0170000 # endif #endif #ifndef S_ISDIR # define S_ISDIR(m) ((m & S_IFMT) == S_IFDIR) #endif #ifndef S_ISCHR # define S_ISCHR(m) ((m & S_IFMT) == S_IFCHR) #endif #ifndef S_ISBLK # ifdef S_IFBLK # define S_ISBLK(m) ((m & S_IFMT) == S_IFBLK) # else # define S_ISBLK(m) (0) # endif #endif #ifndef S_ISREG # define S_ISREG(m) ((m & S_IFMT) == S_IFREG) #endif #ifndef S_ISFIFO # ifdef S_IFIFO # define S_ISFIFO(m) ((m & S_IFMT) == S_IFIFO) # else # define S_ISFIFO(m) (0) # endif #endif #ifndef S_ISLNK # ifdef _S_ISLNK # define S_ISLNK(m) _S_ISLNK(m) # else # ifdef _S_IFLNK # define S_ISLNK(m) ((m & S_IFMT) == _S_IFLNK) # else # ifdef S_IFLNK # define S_ISLNK(m) ((m & S_IFMT) == S_IFLNK) # else # define S_ISLNK(m) (0) # endif # endif # endif #endif #ifndef S_ISSOCK # ifdef _S_ISSOCK # define S_ISSOCK(m) _S_ISSOCK(m) # else # ifdef _S_IFSOCK # define S_ISSOCK(m) ((m & S_IFMT) == _S_IFSOCK) # else # ifdef S_IFSOCK # define S_ISSOCK(m) ((m & S_IFMT) == S_IFSOCK) # else # define S_ISSOCK(m) (0) # endif # endif # endif #endif #ifndef S_IRUSR # ifdef S_IREAD # define S_IRUSR S_IREAD # define S_IWUSR S_IWRITE # define S_IXUSR S_IEXEC # else # define S_IRUSR 0400 # define S_IWUSR 0200 # define S_IXUSR 0100 # endif #endif #ifndef S_IRGRP # ifdef S_IRUSR # define S_IRGRP (S_IRUSR>>3) # define S_IWGRP (S_IWUSR>>3) # define S_IXGRP (S_IXUSR>>3) # else # define S_IRGRP 0040 # define S_IWGRP 0020 # define S_IXGRP 0010 # endif #endif #ifndef S_IROTH # ifdef S_IRUSR # define S_IROTH (S_IRUSR>>6) # define S_IWOTH (S_IWUSR>>6) # define S_IXOTH (S_IXUSR>>6) # else # define S_IROTH 0040 # define S_IWOTH 0020 # define S_IXOTH 0010 # endif #endif #ifndef S_ISUID # define S_ISUID 04000 #endif #ifndef S_ISGID # define S_ISGID 02000 #endif #ifndef S_IRWXU # define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR) #endif #ifndef S_IRWXG # define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP) #endif #ifndef S_IRWXO # define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH) #endif /* BeOS 5.0 and Haiku R1 seem to define S_IREAD and S_IWRITE in * which would get included through , but that is 3000 * lines in the future. --jhi */ #if !defined(S_IREAD) && !(defined(__BEOS__) || defined(__HAIKU__)) # define S_IREAD S_IRUSR #endif #if !defined(S_IWRITE) && !(defined(__BEOS__) || defined(__HAIKU__)) # define S_IWRITE S_IWUSR #endif #ifndef S_IEXEC # define S_IEXEC S_IXUSR #endif #ifdef ff_next # undef ff_next #endif #if defined(cray) || defined(gould) || defined(i860) || defined(pyr) # define SLOPPYDIVIDE #endif #ifdef UV #undef UV #endif #ifdef SPRINTF_E_BUG # define sprintf UTS_sprintf_wrap #endif /* For the times when you want the return value of sprintf, and you want it to be the length. Can't have a thread variable passed in, because C89 has no varargs macros. */ #ifdef SPRINTF_RETURNS_STRLEN # define my_sprintf sprintf #else # define my_sprintf Perl_my_sprintf #endif /* * If we have v?snprintf() and the C99 variadic macros, we can just * use just the v?snprintf(). It is nice to try to trap the buffer * overflow, however, so if we are DEBUGGING, and we cannot use the * gcc statement expressions, then use the function wrappers which try * to trap the overflow. If we can use the gcc statement expressions, * we can try that even with the version that uses the C99 variadic * macros. */ /* Note that we do not check against snprintf()/vsnprintf() returning * negative values because that is non-standard behaviour and we use * snprintf/vsnprintf only iff HAS_VSNPRINTF has been defined, and * that should be true only if the snprintf()/vsnprintf() are true * to the standard. */ #if defined(HAS_SNPRINTF) && defined(HAS_C99_VARIADIC_MACROS) && !(defined(DEBUGGING) && !defined(PERL_USE_GCC_BRACE_GROUPS)) && !defined(PERL_GCC_PEDANTIC) # ifdef PERL_USE_GCC_BRACE_GROUPS # define my_snprintf(buffer, len, ...) ({ int __len__ = snprintf(buffer, len, __VA_ARGS__); if ((len) > 0 && (Size_t)__len__ >= (len)) Perl_croak_nocontext("panic: snprintf buffer overflow"); __len__; }) # define PERL_MY_SNPRINTF_GUARDED # else # define my_snprintf(buffer, len, ...) snprintf(buffer, len, __VA_ARGS__) # endif #else # define my_snprintf Perl_my_snprintf # define PERL_MY_SNPRINTF_GUARDED #endif #if defined(HAS_VSNPRINTF) && defined(HAS_C99_VARIADIC_MACROS) && !(defined(DEBUGGING) && !defined(PERL_USE_GCC_BRACE_GROUPS)) && !defined(PERL_GCC_PEDANTIC) # ifdef PERL_USE_GCC_BRACE_GROUPS # define my_vsnprintf(buffer, len, ...) ({ int __len__ = vsnprintf(buffer, len, __VA_ARGS__); if ((len) > 0 && (Size_t)__len__ >= (len)) Perl_croak_nocontext("panic: vsnprintf buffer overflow"); __len__; }) # define PERL_MY_VSNPRINTF_GUARDED # else # define my_vsnprintf(buffer, len, ...) vsnprintf(buffer, len, __VA_ARGS__) # endif #else # define my_vsnprintf Perl_my_vsnprintf # define PERL_MY_VSNPRINTF_GUARDED #endif #ifdef HAS_STRLCAT # define my_strlcat strlcat #else # define my_strlcat Perl_my_strlcat #endif #ifdef HAS_STRLCPY # define my_strlcpy strlcpy #else # define my_strlcpy Perl_my_strlcpy #endif /* Configure gets this right but the UTS compiler gets it wrong. -- Hal Morris */ #ifdef UTS # undef UVTYPE # define UVTYPE unsigned #endif /* The IV type is supposed to be long enough to hold any integral value or a pointer. --Andy Dougherty August 1996 */ typedef IVTYPE IV; typedef UVTYPE UV; #if defined(USE_64_BIT_INT) && defined(HAS_QUAD) # if QUADKIND == QUAD_IS_INT64_T && defined(INT64_MAX) # define IV_MAX INT64_MAX # define IV_MIN INT64_MIN # define UV_MAX UINT64_MAX # ifndef UINT64_MIN # define UINT64_MIN 0 # endif # define UV_MIN UINT64_MIN # else # define IV_MAX PERL_QUAD_MAX # define IV_MIN PERL_QUAD_MIN # define UV_MAX PERL_UQUAD_MAX # define UV_MIN PERL_UQUAD_MIN # endif # define IV_IS_QUAD # define UV_IS_QUAD #else # if defined(INT32_MAX) && IVSIZE == 4 # define IV_MAX INT32_MAX # define IV_MIN INT32_MIN # ifndef UINT32_MAX_BROKEN /* e.g. HP-UX with gcc messes this up */ # define UV_MAX UINT32_MAX # else # define UV_MAX 4294967295U # endif # ifndef UINT32_MIN # define UINT32_MIN 0 # endif # define UV_MIN UINT32_MIN # else # define IV_MAX PERL_LONG_MAX # define IV_MIN PERL_LONG_MIN # define UV_MAX PERL_ULONG_MAX # define UV_MIN PERL_ULONG_MIN # endif # if IVSIZE == 8 # define IV_IS_QUAD # define UV_IS_QUAD # ifndef HAS_QUAD # define HAS_QUAD # endif # else # undef IV_IS_QUAD # undef UV_IS_QUAD # undef HAS_QUAD # endif #endif #define SSize_t_MAX (SSize_t)(~(size_t)0 >> 1) #ifndef HAS_QUAD # undef PERL_NEED_MY_HTOLE64 # undef PERL_NEED_MY_LETOH64 # undef PERL_NEED_MY_HTOBE64 # undef PERL_NEED_MY_BETOH64 #endif #if defined(uts) || defined(UTS) # undef UV_MAX # define UV_MAX (4294967295u) #endif #define IV_DIG (BIT_DIGITS(IVSIZE * 8)) #define UV_DIG (BIT_DIGITS(UVSIZE * 8)) #ifndef NO_PERL_PRESERVE_IVUV #define PERL_PRESERVE_IVUV /* We like our integers to stay integers. */ #endif /* * The macros INT2PTR and NUM2PTR are (despite their names) * bi-directional: they will convert int/float to or from pointers. * However the conversion to int/float are named explicitly: * PTR2IV, PTR2UV, PTR2NV. * * For int conversions we do not need two casts if pointers are * the same size as IV and UV. Otherwise we need an explicit * cast (PTRV) to avoid compiler warnings. */ #if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) # define PTRV UV # define INT2PTR(any,d) (any)(d) #else # if PTRSIZE == LONGSIZE # define PTRV unsigned long # define PTR2ul(p) (unsigned long)(p) # else # define PTRV unsigned # endif #endif #ifndef INT2PTR # define INT2PTR(any,d) (any)(PTRV)(d) #endif #ifndef PTR2ul # define PTR2ul(p) INT2PTR(unsigned long,p) #endif #define NUM2PTR(any,d) (any)(PTRV)(d) #define PTR2IV(p) INT2PTR(IV,p) #define PTR2UV(p) INT2PTR(UV,p) #define PTR2NV(p) NUM2PTR(NV,p) #define PTR2nat(p) (PTRV)(p) /* pointer to integer of PTRSIZE */ /* According to strict ANSI C89 one cannot freely cast between * data pointers and function (code) pointers. There are at least * two ways around this. One (used below) is to do two casts, * first the other pointer to an (unsigned) integer, and then * the integer to the other pointer. The other way would be * to use unions to "overlay" the pointers. For an example of * the latter technique, see union dirpu in struct xpvio in sv.h. * The only feasible use is probably temporarily storing * function pointers in a data pointer (such as a void pointer). */ #define DPTR2FPTR(t,p) ((t)PTR2nat(p)) /* data pointer to function pointer */ #define FPTR2DPTR(t,p) ((t)PTR2nat(p)) /* function pointer to data pointer */ #ifdef USE_LONG_DOUBLE # if defined(HAS_LONG_DOUBLE) && LONG_DOUBLESIZE == DOUBLESIZE # define LONG_DOUBLE_EQUALS_DOUBLE # endif # if !(defined(HAS_LONG_DOUBLE) && (LONG_DOUBLESIZE > DOUBLESIZE)) # undef USE_LONG_DOUBLE /* Ouch! */ # endif #endif #ifdef OVR_DBL_DIG /* Use an overridden DBL_DIG */ # ifdef DBL_DIG # undef DBL_DIG # endif # define DBL_DIG OVR_DBL_DIG #else /* The following is all to get DBL_DIG, in order to pick a nice default value for printing floating point numbers in Gconvert (see config.h). (It also has other uses, such as figuring out if a given precision of printing can be done with a double instead of a long double - Allen). */ #ifdef I_LIMITS #include #endif #ifdef I_FLOAT #include #endif #ifndef HAS_DBL_DIG #define DBL_DIG 15 /* A guess that works lots of places */ #endif #endif #ifdef OVR_LDBL_DIG /* Use an overridden LDBL_DIG */ # ifdef LDBL_DIG # undef LDBL_DIG # endif # define LDBL_DIG OVR_LDBL_DIG #else /* The following is all to get LDBL_DIG, in order to pick a nice default value for printing floating point numbers in Gconvert. (see config.h) */ # ifdef I_LIMITS # include # endif # ifdef I_FLOAT # include # endif # ifndef HAS_LDBL_DIG # if LONG_DOUBLESIZE == 10 # define LDBL_DIG 18 /* assume IEEE */ # else # if LONG_DOUBLESIZE == 12 # define LDBL_DIG 18 /* gcc? */ # else # if LONG_DOUBLESIZE == 16 # define LDBL_DIG 33 /* assume IEEE */ # else # if LONG_DOUBLESIZE == DOUBLESIZE # define LDBL_DIG DBL_DIG /* bummer */ # endif # endif # endif # endif # endif #endif /* * This is for making sure we have a good DBL_MAX value, if possible, * either for usage as NV_MAX or for usage in figuring out if we can * fit a given long double into a double, if bug-fixing makes it * necessary to do so. - Allen */ #ifdef I_LIMITS # include #endif #ifdef I_VALUES # if !(defined(DBL_MIN) && defined(DBL_MAX) && defined(I_LIMITS)) # include # if defined(MAXDOUBLE) && !defined(DBL_MAX) # define DBL_MAX MAXDOUBLE # endif # if defined(MINDOUBLE) && !defined(DBL_MIN) # define DBL_MIN MINDOUBLE # endif # endif #endif /* defined(I_VALUES) */ typedef NVTYPE NV; #ifdef I_IEEEFP # include #endif #ifdef USE_LONG_DOUBLE # ifdef I_SUNMATH # include # endif # define NV_DIG LDBL_DIG # ifdef LDBL_MANT_DIG # define NV_MANT_DIG LDBL_MANT_DIG # endif # ifdef LDBL_MIN # define NV_MIN LDBL_MIN # endif # ifdef LDBL_MAX # define NV_MAX LDBL_MAX # endif # ifdef LDBL_MIN_10_EXP # define NV_MIN_10_EXP LDBL_MIN_10_EXP # endif # ifdef LDBL_MAX_10_EXP # define NV_MAX_10_EXP LDBL_MAX_10_EXP # endif # ifdef LDBL_EPSILON # define NV_EPSILON LDBL_EPSILON # endif # ifdef LDBL_MAX # define NV_MAX LDBL_MAX /* Having LDBL_MAX doesn't necessarily mean that we have LDBL_MIN... -Allen */ # else # ifdef HUGE_VALL # define NV_MAX HUGE_VALL # else # ifdef HUGE_VAL # define NV_MAX ((NV)HUGE_VAL) # endif # endif # endif # ifdef HAS_SQRTL # define Perl_cos cosl # define Perl_sin sinl # define Perl_sqrt sqrtl # define Perl_exp expl # define Perl_log logl # define Perl_atan2 atan2l # define Perl_pow powl # define Perl_floor floorl # define Perl_ceil ceill # define Perl_fmod fmodl # endif /* e.g. libsunmath doesn't have modfl and frexpl as of mid-March 2000 */ # ifdef HAS_MODFL # define Perl_modf(x,y) modfl(x,y) /* eg glibc 2.2 series seems to provide modfl on ppc and arm, but has no prototype in */ # ifndef HAS_MODFL_PROTO EXTERN_C long double modfl(long double, long double *); # endif # else # if defined(HAS_AINTL) && defined(HAS_COPYSIGNL) extern long double Perl_my_modfl(long double x, long double *ip); # define Perl_modf(x,y) Perl_my_modfl(x,y) # endif # endif # ifdef HAS_FREXPL # define Perl_frexp(x,y) frexpl(x,y) # else # if defined(HAS_ILOGBL) && defined(HAS_SCALBNL) extern long double Perl_my_frexpl(long double x, int *e); # define Perl_frexp(x,y) Perl_my_frexpl(x,y) # endif # endif # ifndef Perl_isnan # ifdef HAS_ISNANL # define Perl_isnan(x) isnanl(x) # endif # endif # ifndef Perl_isinf # ifdef HAS_FINITEL # define Perl_isinf(x) !(finitel(x)||Perl_isnan(x)) # endif # endif #else # define NV_DIG DBL_DIG # ifdef DBL_MANT_DIG # define NV_MANT_DIG DBL_MANT_DIG # endif # ifdef DBL_MIN # define NV_MIN DBL_MIN # endif # ifdef DBL_MAX # define NV_MAX DBL_MAX # endif # ifdef DBL_MIN_10_EXP # define NV_MIN_10_EXP DBL_MIN_10_EXP # endif # ifdef DBL_MAX_10_EXP # define NV_MAX_10_EXP DBL_MAX_10_EXP # endif # ifdef DBL_EPSILON # define NV_EPSILON DBL_EPSILON # endif # ifdef DBL_MAX /* XXX Does DBL_MAX imply having DBL_MIN? */ # define NV_MAX DBL_MAX # define NV_MIN DBL_MIN # else # ifdef HUGE_VAL # define NV_MAX HUGE_VAL # endif # endif # define Perl_cos cos # define Perl_sin sin # define Perl_sqrt sqrt # define Perl_exp exp # define Perl_log log # define Perl_atan2 atan2 # define Perl_pow pow # define Perl_floor floor # define Perl_ceil ceil # define Perl_fmod fmod # define Perl_modf(x,y) modf(x,y) # define Perl_frexp(x,y) frexp(x,y) #endif /* rumor has it that Win32 has _fpclass() */ /* SGI has fpclassl... but not with the same result values, * and it's via a typedef (not via #define), so will need to redo Configure * to use. Not worth the trouble, IMO, at least until the below is used * more places. Also has fp_class_l, BTW, via fp_class.h. Feel free to check * with me for the SGI manpages, SGI testing, etcetera, if you want to * try getting this to work with IRIX. - Allen */ #if !defined(Perl_fp_class) && (defined(HAS_FPCLASS)||defined(HAS_FPCLASSL)) # ifdef I_IEEFP # include # endif # ifdef I_FP # include # endif # if defined(USE_LONG_DOUBLE) && defined(HAS_FPCLASSL) # define Perl_fp_class() fpclassl(x) # else # define Perl_fp_class() fpclass(x) # endif # define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_CLASS_SNAN) # define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_CLASS_QNAN) # define Perl_fp_class_nan(x) (Perl_fp_class(x)==FP_CLASS_SNAN||Perl_fp_class(x)==FP_CLASS_QNAN) # define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_CLASS_NINF) # define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_CLASS_PINF) # define Perl_fp_class_inf(x) (Perl_fp_class(x)==FP_CLASS_NINF||Perl_fp_class(x)==FP_CLASS_PINF) # define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_CLASS_NNORM) # define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_CLASS_PNORM) # define Perl_fp_class_norm(x) (Perl_fp_class(x)==FP_CLASS_NNORM||Perl_fp_class(x)==FP_CLASS_PNORM) # define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_CLASS_NDENORM) # define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_CLASS_PDENORM) # define Perl_fp_class_denorm(x) (Perl_fp_class(x)==FP_CLASS_NDENORM||Perl_fp_class(x)==FP_CLASS_PDENORM) # define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_CLASS_NZERO) # define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_CLASS_PZERO) # define Perl_fp_class_zero(x) (Perl_fp_class(x)==FP_CLASS_NZERO||Perl_fp_class(x)==FP_CLASS_PZERO) #endif #if !defined(Perl_fp_class) && defined(HAS_FP_CLASS) && !defined(PERL_MICRO) # include # if !defined(FP_SNAN) && defined(I_FP_CLASS) # include # endif # define Perl_fp_class(x) fp_class(x) # define Perl_fp_class_snan(x) (fp_class(x)==FP_SNAN) # define Perl_fp_class_qnan(x) (fp_class(x)==FP_QNAN) # define Perl_fp_class_nan(x) (fp_class(x)==FP_SNAN||fp_class(x)==FP_QNAN) # define Perl_fp_class_ninf(x) (fp_class(x)==FP_NEG_INF) # define Perl_fp_class_pinf(x) (fp_class(x)==FP_POS_INF) # define Perl_fp_class_inf(x) (fp_class(x)==FP_NEG_INF||fp_class(x)==FP_POS_INF) # define Perl_fp_class_nnorm(x) (fp_class(x)==FP_NEG_NORM) # define Perl_fp_class_pnorm(x) (fp_class(x)==FP_POS_NORM) # define Perl_fp_class_norm(x) (fp_class(x)==FP_NEG_NORM||fp_class(x)==FP_POS_NORM) # define Perl_fp_class_ndenorm(x) (fp_class(x)==FP_NEG_DENORM) # define Perl_fp_class_pdenorm(x) (fp_class(x)==FP_POS_DENORM) # define Perl_fp_class_denorm(x) (fp_class(x)==FP_NEG_DENORM||fp_class(x)==FP_POS_DENORM) # define Perl_fp_class_nzero(x) (fp_class(x)==FP_NEG_ZERO) # define Perl_fp_class_pzero(x) (fp_class(x)==FP_POS_ZERO) # define Perl_fp_class_zero(x) (fp_class(x)==FP_NEG_ZERO||fp_class(x)==FP_POS_ZERO) #endif #if !defined(Perl_fp_class) && defined(HAS_FPCLASSIFY) # include # define Perl_fp_class(x) fpclassify(x) # define Perl_fp_class_nan(x) (fp_classify(x)==FP_SNAN||fp_classify(x)==FP_QNAN) # define Perl_fp_class_inf(x) (fp_classify(x)==FP_INFINITE) # define Perl_fp_class_norm(x) (fp_classify(x)==FP_NORMAL) # define Perl_fp_class_denorm(x) (fp_classify(x)==FP_SUBNORMAL) # define Perl_fp_class_zero(x) (fp_classify(x)==FP_ZERO) #endif #if !defined(Perl_fp_class) && defined(HAS_CLASS) # include # ifndef _cplusplus # define Perl_fp_class(x) class(x) # else # define Perl_fp_class(x) _class(x) # endif # define Perl_fp_class_snan(x) (Perl_fp_class(x)==FP_NANS) # define Perl_fp_class_qnan(x) (Perl_fp_class(x)==FP_NANQ) # define Perl_fp_class_nan(x) (Perl_fp_class(x)==FP_SNAN||Perl_fp_class(x)==FP_QNAN) # define Perl_fp_class_ninf(x) (Perl_fp_class(x)==FP_MINUS_INF) # define Perl_fp_class_pinf(x) (Perl_fp_class(x)==FP_PLUS_INF) # define Perl_fp_class_inf(x) (Perl_fp_class(x)==FP_MINUS_INF||Perl_fp_class(x)==FP_PLUS_INF) # define Perl_fp_class_nnorm(x) (Perl_fp_class(x)==FP_MINUS_NORM) # define Perl_fp_class_pnorm(x) (Perl_fp_class(x)==FP_PLUS_NORM) # define Perl_fp_class_norm(x) (Perl_fp_class(x)==FP_MINUS_NORM||Perl_fp_class(x)==FP_PLUS_NORM) # define Perl_fp_class_ndenorm(x) (Perl_fp_class(x)==FP_MINUS_DENORM) # define Perl_fp_class_pdenorm(x) (Perl_fp_class(x)==FP_PLUS_DENORM) # define Perl_fp_class_denorm(x) (Perl_fp_class(x)==FP_MINUS_DENORM||Perl_fp_class(x)==FP_PLUS_DENORM) # define Perl_fp_class_nzero(x) (Perl_fp_class(x)==FP_MINUS_ZERO) # define Perl_fp_class_pzero(x) (Perl_fp_class(x)==FP_PLUS_ZERO) # define Perl_fp_class_zero(x) (Perl_fp_class(x)==FP_MINUS_ZERO||Perl_fp_class(x)==FP_PLUS_ZERO) #endif /* rumor has it that Win32 has _isnan() */ #ifndef Perl_isnan # ifdef HAS_ISNAN # define Perl_isnan(x) isnan((NV)x) # else # ifdef Perl_fp_class_nan # define Perl_isnan(x) Perl_fp_class_nan(x) # else # ifdef HAS_UNORDERED # define Perl_isnan(x) unordered((x), 0.0) # else # define Perl_isnan(x) ((x)!=(x)) # endif # endif # endif #endif #ifdef UNDER_CE int isnan(double d); #endif #ifndef Perl_isinf # ifdef HAS_ISINF # define Perl_isinf(x) isinf((NV)x) # else # ifdef Perl_fp_class_inf # define Perl_isinf(x) Perl_fp_class_inf(x) # else # define Perl_isinf(x) ((x)==NV_INF) # endif # endif #endif #ifndef Perl_isfinite # ifdef HAS_FINITE # define Perl_isfinite(x) finite((NV)x) # else # ifdef HAS_ISFINITE # define Perl_isfinite(x) isfinite(x) # else # ifdef Perl_fp_class_finite # define Perl_isfinite(x) Perl_fp_class_finite(x) # else # define Perl_isfinite(x) !(Perl_is_inf(x)||Perl_is_nan(x)) # endif # endif # endif #endif /* The default is to use Perl's own atof() implementation (in numeric.c). * Usually that is the one to use but for some platforms (e.g. UNICOS) * it is however best to use the native implementation of atof. * You can experiment with using your native one by -DUSE_PERL_ATOF=0. * Some good tests to try out with either setting are t/base/num.t, * t/op/numconvert.t, and t/op/pack.t. Note that if using long doubles * you may need to be using a different function than atof! */ #ifndef USE_PERL_ATOF # ifndef _UNICOS # define USE_PERL_ATOF # endif #else # if USE_PERL_ATOF == 0 # undef USE_PERL_ATOF # endif #endif #ifdef USE_PERL_ATOF # define Perl_atof(s) Perl_my_atof(s) # define Perl_atof2(s, n) Perl_my_atof2(aTHX_ (s), &(n)) #else # define Perl_atof(s) (NV)atof(s) # define Perl_atof2(s, n) ((n) = atof(s)) #endif /* Previously these definitions used hardcoded figures. * It is hoped these formula are more portable, although * no data one way or another is presently known to me. * The "PERL_" names are used because these calculated constants * do not meet the ANSI requirements for LONG_MAX, etc., which * need to be constants acceptable to #if - kja * define PERL_LONG_MAX 2147483647L * define PERL_LONG_MIN (-LONG_MAX - 1) * define PERL ULONG_MAX 4294967295L */ #ifdef I_LIMITS /* Needed for cast_xxx() functions below. */ # include #endif /* Included values.h above if necessary; still including limits.h down here, * despite doing above, because math.h might have overridden... XXX - Allen */ /* * Try to figure out max and min values for the integral types. THE CORRECT * SOLUTION TO THIS MESS: ADAPT enquire.c FROM GCC INTO CONFIGURE. The * following hacks are used if neither limits.h or values.h provide them: * U_MAX: for types >= int: ~(unsigned TYPE)0 * for types < int: (unsigned TYPE)~(unsigned)0 * The argument to ~ must be unsigned so that later signed->unsigned * conversion can't modify the value's bit pattern (e.g. -0 -> +0), * and it must not be smaller than int because ~ does integral promotion. * _MAX: () (U_MAX >> 1) * _MIN: -_MAX - . * The latter is a hack which happens to work on some machines but * does *not* catch any random system, or things like integer types * with NaN if that is possible. * * All of the types are explicitly cast to prevent accidental loss of * numeric range, and in the hope that they will be less likely to confuse * over-eager optimizers. * */ #define PERL_UCHAR_MIN ((unsigned char)0) #ifdef UCHAR_MAX # define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) #else # ifdef MAXUCHAR # define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) # else # define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) # endif #endif /* * CHAR_MIN and CHAR_MAX are not included here, as the (char) type may be * ambiguous. It may be equivalent to (signed char) or (unsigned char) * depending on local options. Until Configure detects this (or at least * detects whether the "signed" keyword is available) the CHAR ranges * will not be included. UCHAR functions normally. * - kja */ #define PERL_USHORT_MIN ((unsigned short)0) #ifdef USHORT_MAX # define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) #else # ifdef MAXUSHORT # define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) # else # ifdef USHRT_MAX # define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) # else # define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) # endif # endif #endif #ifdef SHORT_MAX # define PERL_SHORT_MAX ((short)SHORT_MAX) #else # ifdef MAXSHORT /* Often used in */ # define PERL_SHORT_MAX ((short)MAXSHORT) # else # ifdef SHRT_MAX # define PERL_SHORT_MAX ((short)SHRT_MAX) # else # define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) # endif # endif #endif #ifdef SHORT_MIN # define PERL_SHORT_MIN ((short)SHORT_MIN) #else # ifdef MINSHORT # define PERL_SHORT_MIN ((short)MINSHORT) # else # ifdef SHRT_MIN # define PERL_SHORT_MIN ((short)SHRT_MIN) # else # define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) # endif # endif #endif #ifdef UINT_MAX # define PERL_UINT_MAX ((unsigned int)UINT_MAX) #else # ifdef MAXUINT # define PERL_UINT_MAX ((unsigned int)MAXUINT) # else # define PERL_UINT_MAX (~(unsigned int)0) # endif #endif #define PERL_UINT_MIN ((unsigned int)0) #ifdef INT_MAX # define PERL_INT_MAX ((int)INT_MAX) #else # ifdef MAXINT /* Often used in */ # define PERL_INT_MAX ((int)MAXINT) # else # define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) # endif #endif #ifdef INT_MIN # define PERL_INT_MIN ((int)INT_MIN) #else # ifdef MININT # define PERL_INT_MIN ((int)MININT) # else # define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) # endif #endif #ifdef ULONG_MAX # define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) #else # ifdef MAXULONG # define PERL_ULONG_MAX ((unsigned long)MAXULONG) # else # define PERL_ULONG_MAX (~(unsigned long)0) # endif #endif #define PERL_ULONG_MIN ((unsigned long)0L) #ifdef LONG_MAX # define PERL_LONG_MAX ((long)LONG_MAX) #else # ifdef MAXLONG /* Often used in */ # define PERL_LONG_MAX ((long)MAXLONG) # else # define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) # endif #endif #ifdef LONG_MIN # define PERL_LONG_MIN ((long)LONG_MIN) #else # ifdef MINLONG # define PERL_LONG_MIN ((long)MINLONG) # else # define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) # endif #endif #ifdef UV_IS_QUAD # define PERL_UQUAD_MAX (~(UV)0) # define PERL_UQUAD_MIN ((UV)0) # define PERL_QUAD_MAX ((IV) (PERL_UQUAD_MAX >> 1)) # define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) #endif struct RExC_state_t; struct _reg_trie_data; typedef MEM_SIZE STRLEN; #ifdef PERL_MAD typedef struct token TOKEN; typedef struct madprop MADPROP; typedef struct nexttoken NEXTTOKE; #endif typedef struct op OP; typedef struct cop COP; typedef struct unop UNOP; typedef struct binop BINOP; typedef struct listop LISTOP; typedef struct logop LOGOP; typedef struct pmop PMOP; typedef struct svop SVOP; typedef struct padop PADOP; typedef struct pvop PVOP; typedef struct loop LOOP; typedef struct block_hooks BHK; typedef struct custom_op XOP; typedef struct interpreter PerlInterpreter; /* Amdahl's has struct sv */ /* SGI's has struct sv */ #if defined(UTS) || defined(__sgi) # define STRUCT_SV perl_sv #else # define STRUCT_SV sv #endif typedef struct STRUCT_SV SV; typedef struct av AV; typedef struct hv HV; typedef struct cv CV; typedef struct p5rx REGEXP; typedef struct gp GP; typedef struct gv GV; typedef struct io IO; typedef struct context PERL_CONTEXT; typedef struct block BLOCK; typedef struct magic MAGIC; typedef struct xpv XPV; typedef struct xpviv XPVIV; typedef struct xpvuv XPVUV; typedef struct xpvnv XPVNV; typedef struct xpvmg XPVMG; typedef struct xpvlv XPVLV; typedef struct xpvav XPVAV; typedef struct xpvhv XPVHV; typedef struct xpvgv XPVGV; typedef struct xpvcv XPVCV; typedef struct xpvbm XPVBM; typedef struct xpvfm XPVFM; typedef struct xpvio XPVIO; typedef struct mgvtbl MGVTBL; typedef union any ANY; typedef struct ptr_tbl_ent PTR_TBL_ENT_t; typedef struct ptr_tbl PTR_TBL_t; typedef struct clone_params CLONE_PARAMS; #include "handy.h" #if defined(USE_LARGE_FILES) && !defined(NO_64_BIT_RAWIO) # if LSEEKSIZE == 8 && !defined(USE_64_BIT_RAWIO) # define USE_64_BIT_RAWIO /* implicit */ # endif #endif /* Notice the use of HAS_FSEEKO: now we are obligated to always use * fseeko/ftello if possible. Don't go #defining ftell to ftello yourself, * however, because operating systems like to do that themself. */ #ifndef FSEEKSIZE # ifdef HAS_FSEEKO # define FSEEKSIZE LSEEKSIZE # else # define FSEEKSIZE LONGSIZE # endif #endif #if defined(USE_LARGE_FILES) && !defined(NO_64_BIT_STDIO) # if FSEEKSIZE == 8 && !defined(USE_64_BIT_STDIO) # define USE_64_BIT_STDIO /* implicit */ # endif #endif #ifdef USE_64_BIT_RAWIO # ifdef HAS_OFF64_T # undef Off_t # define Off_t off64_t # undef LSEEKSIZE # define LSEEKSIZE 8 # endif /* Most 64-bit environments have defines like _LARGEFILE_SOURCE that * will trigger defines like the ones below. Some 64-bit environments, * however, do not. Therefore we have to explicitly mix and match. */ # if defined(USE_OPEN64) # define open open64 # endif # if defined(USE_LSEEK64) # define lseek lseek64 # else # if defined(USE_LLSEEK) # define lseek llseek # endif # endif # if defined(USE_STAT64) # define stat stat64 # endif # if defined(USE_FSTAT64) # define fstat fstat64 # endif # if defined(USE_LSTAT64) # define lstat lstat64 # endif # if defined(USE_FLOCK64) # define flock flock64 # endif # if defined(USE_LOCKF64) # define lockf lockf64 # endif # if defined(USE_FCNTL64) # define fcntl fcntl64 # endif # if defined(USE_TRUNCATE64) # define truncate truncate64 # endif # if defined(USE_FTRUNCATE64) # define ftruncate ftruncate64 # endif #endif #ifdef USE_64_BIT_STDIO # ifdef HAS_FPOS64_T # undef Fpos_t # define Fpos_t fpos64_t # endif /* Most 64-bit environments have defines like _LARGEFILE_SOURCE that * will trigger defines like the ones below. Some 64-bit environments, * however, do not. */ # if defined(USE_FOPEN64) # define fopen fopen64 # endif # if defined(USE_FSEEK64) # define fseek fseek64 /* don't do fseeko here, see perlio.c */ # endif # if defined(USE_FTELL64) # define ftell ftell64 /* don't do ftello here, see perlio.c */ # endif # if defined(USE_FSETPOS64) # define fsetpos fsetpos64 # endif # if defined(USE_FGETPOS64) # define fgetpos fgetpos64 # endif # if defined(USE_TMPFILE64) # define tmpfile tmpfile64 # endif # if defined(USE_FREOPEN64) # define freopen freopen64 # endif #endif #if defined(OS2) # include "iperlsys.h" #endif #if defined(__OPEN_VM) # include "vmesa/vmesaish.h" # define ISHISH "vmesa" #endif #ifdef DOSISH # if defined(OS2) # include "os2ish.h" # else # include "dosish.h" # endif # define ISHISH "dos" #endif #if defined(VMS) # include "vmsish.h" # define ISHISH "vms" #endif #if defined(PLAN9) # include "./plan9/plan9ish.h" # define ISHISH "plan9" #endif #if defined(MPE) # include "mpeix/mpeixish.h" # define ISHISH "mpeix" #endif #if defined(__VOS__) # ifdef __GNUC__ # include "./vos/vosish.h" # else # include "vos/vosish.h" # endif # define ISHISH "vos" #endif #if defined(EPOC) # include "epocish.h" # define ISHISH "epoc" #endif #ifdef __SYMBIAN32__ # include "symbian/symbianish.h" # define ISHISH "symbian" #endif #if defined(__HAIKU__) # include "haiku/haikuish.h" # define ISHISH "haiku" #elif defined(__BEOS__) # include "beos/beosish.h" # define ISHISH "beos" #endif #ifndef ISHISH # include "unixish.h" # define ISHISH "unix" #endif /* NSIG logic from Configure --> */ /* Strange style to avoid deeply-nested #if/#else/#endif */ #ifndef NSIG # ifdef _NSIG # define NSIG (_NSIG) # endif #endif #ifndef NSIG # ifdef SIGMAX # define NSIG (SIGMAX+1) # endif #endif #ifndef NSIG # ifdef SIG_MAX # define NSIG (SIG_MAX+1) # endif #endif #ifndef NSIG # ifdef _SIG_MAX # define NSIG (_SIG_MAX+1) # endif #endif #ifndef NSIG # ifdef MAXSIG # define NSIG (MAXSIG+1) # endif #endif #ifndef NSIG # ifdef MAX_SIG # define NSIG (MAX_SIG+1) # endif #endif #ifndef NSIG # ifdef SIGARRAYSIZE # define NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */ # endif #endif #ifndef NSIG # ifdef _sys_nsig # define NSIG (_sys_nsig) /* Solaris 2.5 */ # endif #endif /* Default to some arbitrary number that's big enough to get most of the common signals. */ #ifndef NSIG # define NSIG 50 #endif /* <-- NSIG logic from Configure */ #ifndef NO_ENVIRON_ARRAY # define USE_ENVIRON_ARRAY #endif /* * initialise to avoid floating-point exceptions from overflow, etc */ #ifndef PERL_FPU_INIT # ifdef HAS_FPSETMASK # if HAS_FLOATINGPOINT_H # include # endif /* Some operating systems have this as a macro, which in turn expands to a comma expression, and the last sub-expression is something that gets calculated, and then they have the gall to warn that a value computed is not used. Hence cast to void. */ # define PERL_FPU_INIT (void)fpsetmask(0) # else # if defined(SIGFPE) && defined(SIG_IGN) && !defined(PERL_MICRO) # define PERL_FPU_INIT PL_sigfpe_saved = (Sighandler_t) signal(SIGFPE, SIG_IGN) # define PERL_FPU_PRE_EXEC { Sigsave_t xfpe; rsignal_save(SIGFPE, PL_sigfpe_saved, &xfpe); # define PERL_FPU_POST_EXEC rsignal_restore(SIGFPE, &xfpe); } # else # define PERL_FPU_INIT # endif # endif #endif #ifndef PERL_FPU_PRE_EXEC # define PERL_FPU_PRE_EXEC { # define PERL_FPU_POST_EXEC } #endif #ifndef PERL_SYS_INIT3_BODY # define PERL_SYS_INIT3_BODY(argvp,argcp,envp) PERL_SYS_INIT_BODY(argvp,argcp) #endif /* =for apidoc Am|void|PERL_SYS_INIT|int argc|char** argv Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. =for apidoc Am|void|PERL_SYS_INIT3|int argc|char** argv|char** env Provides system-specific tune up of the C runtime environment necessary to run Perl interpreters. This should be called only once, before creating any Perl interpreters. =for apidoc Am|void|PERL_SYS_TERM| Provides system-specific clean up of the C runtime environment after running Perl interpreters. This should be called only once, after freeing any remaining Perl interpreters. =cut */ #define PERL_SYS_INIT(argc, argv) Perl_sys_init(argc, argv) #define PERL_SYS_INIT3(argc, argv, env) Perl_sys_init3(argc, argv, env) #define PERL_SYS_TERM() Perl_sys_term() #ifndef PERL_WRITE_MSG_TO_CONSOLE # define PERL_WRITE_MSG_TO_CONSOLE(io, msg, len) PerlIO_write(io, msg, len) #endif #ifndef MAXPATHLEN # ifdef PATH_MAX # ifdef _POSIX_PATH_MAX # if PATH_MAX > _POSIX_PATH_MAX /* POSIX 1990 (and pre) was ambiguous about whether PATH_MAX * included the null byte or not. Later amendments of POSIX, * XPG4, the Austin Group, and the Single UNIX Specification * all explicitly include the null byte in the PATH_MAX. * Ditto for _POSIX_PATH_MAX. */ # define MAXPATHLEN PATH_MAX # else # define MAXPATHLEN _POSIX_PATH_MAX # endif # else # define MAXPATHLEN (PATH_MAX+1) # endif # else # define MAXPATHLEN 1024 /* Err on the large side. */ # endif #endif /* In case Configure was not used (we are using a "canned config" * such as Win32, or a cross-compilation setup, for example) try going * by the gcc major and minor versions. One useful URL is * http://www.ohse.de/uwe/articles/gcc-attributes.html, * but contrary to this information warn_unused_result seems * not to be in gcc 3.3.5, at least. --jhi * Also, when building extensions with an installed perl, this allows * the user to upgrade gcc and get the right attributes, rather than * relying on the list generated at Configure time. --AD * Set these up now otherwise we get confused when some of the <*thread.h> * includes below indirectly pull in (which needs to know if we * have HASATTRIBUTE_FORMAT). */ #ifndef PERL_MICRO #if defined __GNUC__ && !defined(__INTEL_COMPILER) # if __GNUC__ == 3 && __GNUC_MINOR__ >= 1 || __GNUC__ > 3 /* 3.1 -> */ # define HASATTRIBUTE_DEPRECATED # endif # if __GNUC__ >= 3 /* 3.0 -> */ /* XXX Verify this version */ # define HASATTRIBUTE_FORMAT # if defined __MINGW32__ # define PRINTF_FORMAT_NULL_OK # endif # endif # if __GNUC__ >= 3 /* 3.0 -> */ # define HASATTRIBUTE_MALLOC # endif # if __GNUC__ == 3 && __GNUC_MINOR__ >= 3 || __GNUC__ > 3 /* 3.3 -> */ # define HASATTRIBUTE_NONNULL # endif # if __GNUC__ == 2 && __GNUC_MINOR__ >= 5 || __GNUC__ > 2 /* 2.5 -> */ # define HASATTRIBUTE_NORETURN # endif # if __GNUC__ >= 3 /* gcc 3.0 -> */ # define HASATTRIBUTE_PURE # endif # if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 /* 3.4 -> */ # define HASATTRIBUTE_UNUSED # endif # if __GNUC__ == 3 && __GNUC_MINOR__ == 3 && !defined(__cplusplus) # define HASATTRIBUTE_UNUSED /* gcc-3.3, but not g++-3.3. */ # endif # if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 /* 3.4 -> */ # define HASATTRIBUTE_WARN_UNUSED_RESULT # endif #endif #endif /* #ifndef PERL_MICRO */ /* USE_5005THREADS needs to be after unixish.h as includes * which defines NSIG - which will stop inclusion of * this results in many functions being undeclared which bothers C++ * May make sense to have threads after "*ish.h" anyway */ #if defined(USE_ITHREADS) # ifdef NETWARE # include # else # ifdef FAKE_THREADS # include "fakethr.h" # else # ifdef WIN32 # include # else # ifdef OS2 # include "os2thread.h" # else # ifdef I_MACH_CTHREADS # include # if (defined(NeXT) || defined(__NeXT__)) && defined(PERL_POLLUTE_MALLOC) # define MUTEX_INIT_CALLS_MALLOC # endif typedef cthread_t perl_os_thread; typedef mutex_t perl_mutex; typedef condition_t perl_cond; typedef void * perl_key; # else /* Posix threads */ # ifdef I_PTHREAD # include # endif typedef pthread_t perl_os_thread; typedef pthread_mutex_t perl_mutex; typedef pthread_cond_t perl_cond; typedef pthread_key_t perl_key; # endif /* I_MACH_CTHREADS */ # endif /* OS2 */ # endif /* WIN32 */ # endif /* FAKE_THREADS */ #endif /* NETWARE */ #endif /* USE_ITHREADS */ #if defined(WIN32) # include "win32.h" #endif #ifdef NETWARE # include "netware.h" #endif #define STATUS_UNIX PL_statusvalue #ifdef VMS # define STATUS_NATIVE PL_statusvalue_vms /* * vaxc$errno is only guaranteed to be valid if errno == EVMSERR, otherwise * its contents can not be trusted. Unfortunately, Perl seems to check * it on exit, so it when PL_statusvalue_vms is updated, vaxc$errno should * be updated also. */ # include # include /* Presume this because if VMS changes it, it will require a new * set of APIs for waiting on children for binary compatibility. */ # define child_offset_bits (8) # ifndef C_FAC_POSIX # define C_FAC_POSIX 0x35A000 # endif /* STATUS_EXIT - validates and returns a NATIVE exit status code for the * platform from the existing UNIX or Native status values. */ # define STATUS_EXIT \ (((I32)PL_statusvalue_vms == -1 ? SS$_ABORT : PL_statusvalue_vms) | \ (VMSISH_HUSHED ? STS$M_INHIB_MSG : 0)) /* STATUS_NATIVE_CHILD_SET - Calculate UNIX status that matches the child * exit code and shifts the UNIX value over the correct number of bits to * be a child status. Usually the number of bits is 8, but that could be * platform dependent. The NATIVE status code is presumed to have either * from a child process. */ /* This is complicated. The child processes return a true native VMS status which must be saved. But there is an assumption in Perl that the UNIX child status has some relationship to errno values, so Perl tries to translate it to text in some of the tests. In order to get the string translation correct, for the error, errno must be EVMSERR, but that generates a different text message than what the test programs are expecting. So an errno value must be derived from the native status value when an error occurs. That will hide the true native status message. With this version of perl, the true native child status can always be retrieved so that is not a problem. But in this case, Pl_statusvalue and errno may have different values in them. */ # define STATUS_NATIVE_CHILD_SET(n) \ STMT_START { \ I32 evalue = (I32)n; \ if (evalue == EVMSERR) { \ PL_statusvalue_vms = vaxc$errno; \ PL_statusvalue = evalue; \ } else { \ PL_statusvalue_vms = evalue; \ if (evalue == -1) { \ PL_statusvalue = -1; \ PL_statusvalue_vms = SS$_ABORT; /* Should not happen */ \ } else \ PL_statusvalue = Perl_vms_status_to_unix(evalue, 1); \ set_vaxc_errno(evalue); \ if ((PL_statusvalue_vms & C_FAC_POSIX) == C_FAC_POSIX) \ set_errno(EVMSERR); \ else set_errno(Perl_vms_status_to_unix(evalue, 0)); \ PL_statusvalue = PL_statusvalue << child_offset_bits; \ } \ } STMT_END # ifdef VMSISH_STATUS # define STATUS_CURRENT (VMSISH_STATUS ? STATUS_NATIVE : STATUS_UNIX) # else # define STATUS_CURRENT STATUS_UNIX # endif /* STATUS_UNIX_SET - takes a UNIX/POSIX errno value and attempts to update * the NATIVE status to an equivalent value. Can not be used to translate * exit code values as exit code values are not guaranteed to have any * relationship at all to errno values. * This is used when Perl is forcing errno to have a specific value. */ # define STATUS_UNIX_SET(n) \ STMT_START { \ I32 evalue = (I32)n; \ PL_statusvalue = evalue; \ if (PL_statusvalue != -1) { \ if (PL_statusvalue != EVMSERR) { \ PL_statusvalue &= 0xFFFF; \ if (MY_POSIX_EXIT) \ PL_statusvalue_vms=PL_statusvalue ? SS$_ABORT : SS$_NORMAL;\ else PL_statusvalue_vms = Perl_unix_status_to_vms(evalue); \ } \ else { \ PL_statusvalue_vms = vaxc$errno; \ } \ } \ else PL_statusvalue_vms = SS$_ABORT; \ set_vaxc_errno(PL_statusvalue_vms); \ } STMT_END /* STATUS_UNIX_EXIT_SET - Takes a UNIX/POSIX exit code and sets * the NATIVE error status based on it. * * When in the default mode to comply with the Perl VMS documentation, * 0 is a success and any other code sets the NATIVE status to a failure * code of SS$_ABORT. * * In the new POSIX EXIT mode, native status will be set so that the * actual exit code will can be retrieved by the calling program or * shell. * * If the exit code is not clearly a UNIX parent or child exit status, * it will be passed through as a VMS status. */ # define STATUS_UNIX_EXIT_SET(n) \ STMT_START { \ I32 evalue = (I32)n; \ PL_statusvalue = evalue; \ if (MY_POSIX_EXIT) { \ if (evalue <= 0xFF00) { \ if (evalue > 0xFF) \ evalue = (evalue >> child_offset_bits) & 0xFF; \ PL_statusvalue_vms = \ (C_FAC_POSIX | (evalue << 3 ) | \ ((evalue == 1) ? (STS$K_ERROR | STS$M_INHIB_MSG) : 1)); \ } else /* forgive them Perl, for they have sinned */ \ PL_statusvalue_vms = evalue; \ } else { \ if (evalue == 0) \ PL_statusvalue_vms = SS$_NORMAL; \ else if (evalue <= 0xFF00) \ PL_statusvalue_vms = SS$_ABORT; \ else { /* forgive them Perl, for they have sinned */ \ if (evalue != EVMSERR) PL_statusvalue_vms = evalue; \ else PL_statusvalue_vms = vaxc$errno; \ /* And obviously used a VMS status value instead of UNIX */ \ PL_statusvalue = EVMSERR; \ } \ set_vaxc_errno(PL_statusvalue_vms); \ } \ } STMT_END /* STATUS_EXIT_SET - Takes a NATIVE/UNIX/POSIX exit code * and sets the NATIVE error status based on it. This special case * is needed to maintain compatibility with past VMS behavior. * * In the default mode on VMS, this number is passed through as * both the NATIVE and UNIX status. Which makes it different * that the STATUS_UNIX_EXIT_SET. * * In the new POSIX EXIT mode, native status will be set so that the * actual exit code will can be retrieved by the calling program or * shell. * * A POSIX exit code is from 0 to 255. If the exit code is higher * than this, it needs to be assumed that it is a VMS exit code and * passed through. */ # define STATUS_EXIT_SET(n) \ STMT_START { \ I32 evalue = (I32)n; \ PL_statusvalue = evalue; \ if (MY_POSIX_EXIT) \ if (evalue > 255) PL_statusvalue_vms = evalue; else { \ PL_statusvalue_vms = \ (C_FAC_POSIX | (evalue << 3 ) | \ ((evalue == 1) ? (STS$K_ERROR | STS$M_INHIB_MSG) : 1));} \ else \ PL_statusvalue_vms = evalue ? evalue : SS$_NORMAL; \ set_vaxc_errno(PL_statusvalue_vms); \ } STMT_END /* This macro forces a success status */ # define STATUS_ALL_SUCCESS \ (PL_statusvalue = 0, PL_statusvalue_vms = SS$_NORMAL) /* This macro forces a failure status */ # define STATUS_ALL_FAILURE (PL_statusvalue = 1, \ vaxc$errno = PL_statusvalue_vms = MY_POSIX_EXIT ? \ (C_FAC_POSIX | (1 << 3) | STS$K_ERROR | STS$M_INHIB_MSG) : SS$_ABORT) #else # define STATUS_NATIVE PL_statusvalue_posix # if defined(WCOREDUMP) # define STATUS_NATIVE_CHILD_SET(n) \ STMT_START { \ PL_statusvalue_posix = (n); \ if (PL_statusvalue_posix == -1) \ PL_statusvalue = -1; \ else { \ PL_statusvalue = \ (WIFEXITED(PL_statusvalue_posix) ? (WEXITSTATUS(PL_statusvalue_posix) << 8) : 0) | \ (WIFSIGNALED(PL_statusvalue_posix) ? (WTERMSIG(PL_statusvalue_posix) & 0x7F) : 0) | \ (WIFSIGNALED(PL_statusvalue_posix) && WCOREDUMP(PL_statusvalue_posix) ? 0x80 : 0); \ } \ } STMT_END # elif defined(WIFEXITED) # define STATUS_NATIVE_CHILD_SET(n) \ STMT_START { \ PL_statusvalue_posix = (n); \ if (PL_statusvalue_posix == -1) \ PL_statusvalue = -1; \ else { \ PL_statusvalue = \ (WIFEXITED(PL_statusvalue_posix) ? (WEXITSTATUS(PL_statusvalue_posix) << 8) : 0) | \ (WIFSIGNALED(PL_statusvalue_posix) ? (WTERMSIG(PL_statusvalue_posix) & 0x7F) : 0); \ } \ } STMT_END # else # define STATUS_NATIVE_CHILD_SET(n) \ STMT_START { \ PL_statusvalue_posix = (n); \ if (PL_statusvalue_posix == -1) \ PL_statusvalue = -1; \ else { \ PL_statusvalue = \ PL_statusvalue_posix & 0xFFFF; \ } \ } STMT_END # endif # define STATUS_UNIX_SET(n) \ STMT_START { \ PL_statusvalue = (n); \ if (PL_statusvalue != -1) \ PL_statusvalue &= 0xFFFF; \ } STMT_END # define STATUS_UNIX_EXIT_SET(n) STATUS_UNIX_SET(n) # define STATUS_EXIT_SET(n) STATUS_UNIX_SET(n) # define STATUS_CURRENT STATUS_UNIX # define STATUS_EXIT STATUS_UNIX # define STATUS_ALL_SUCCESS (PL_statusvalue = 0, PL_statusvalue_posix = 0) # define STATUS_ALL_FAILURE (PL_statusvalue = 1, PL_statusvalue_posix = 1) #endif /* flags in PL_exit_flags for nature of exit() */ #define PERL_EXIT_EXPECTED 0x01 #define PERL_EXIT_DESTRUCT_END 0x02 /* Run END in perl_destruct */ #ifndef PERL_CORE /* format to use for version numbers in file/directory names */ /* XXX move to Configure? */ /* This was only ever used for the current version, and that can be done at compile time, as PERL_FS_VERSION, so should we just delete it? */ # ifndef PERL_FS_VER_FMT # define PERL_FS_VER_FMT "%d.%d.%d" # endif #endif #ifndef PERL_FS_VERSION # define PERL_FS_VERSION PERL_VERSION_STRING #endif /* This defines a way to flush all output buffers. This may be a * performance issue, so we allow people to disable it. Also, if * we are using stdio, there are broken implementations of fflush(NULL) * out there, Solaris being the most prominent. */ #ifndef PERL_FLUSHALL_FOR_CHILD # if defined(USE_PERLIO) || defined(FFLUSH_NULL) || defined(USE_SFIO) # define PERL_FLUSHALL_FOR_CHILD PerlIO_flush((PerlIO*)NULL) # else # ifdef FFLUSH_ALL # define PERL_FLUSHALL_FOR_CHILD my_fflush_all() # else # define PERL_FLUSHALL_FOR_CHILD NOOP # endif # endif #endif #ifndef PERL_WAIT_FOR_CHILDREN # define PERL_WAIT_FOR_CHILDREN NOOP #endif /* the traditional thread-unsafe notion of "current interpreter". */ #ifndef PERL_SET_INTERP # define PERL_SET_INTERP(i) (PL_curinterp = (PerlInterpreter*)(i)) #endif #ifndef PERL_GET_INTERP # define PERL_GET_INTERP (PL_curinterp) #endif #if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_GET_THX) # ifdef MULTIPLICITY # define PERL_GET_THX ((PerlInterpreter *)PERL_GET_CONTEXT) # endif # define PERL_SET_THX(t) PERL_SET_CONTEXT(t) #endif /* This replaces the previous %_ "hack" by the "%p" hacks. All that is required is that the perl source does not use "%-p" or "%-p" or "%p" formats. These formats will still work in perl code. See comments in sv.c for further details. Robin Barker 2005-07-14 No longer use %1p for VDf = %vd. RMB 2007-10-19 */ #ifndef SVf_ # define SVf_(n) "-" STRINGIFY(n) "p" #endif #ifndef SVf # define SVf "-p" #endif #ifndef SVf32 # define SVf32 SVf_(32) #endif #ifndef SVf256 # define SVf256 SVf_(256) #endif #define SVfARG(p) ((void*)(p)) #ifndef HEKf # define HEKf "2p" #endif /* Not ideal, but we cannot easily include a number in an already-numeric * format sequence. */ #ifndef HEKf256 # define HEKf256 "3p" #endif #define HEKfARG(p) ((void*)(p)) #ifdef PERL_CORE /* not used; but needed for backward compatibility with XS code? - RMB */ # undef VDf #else # ifndef VDf # define VDf "vd" # endif #endif #ifdef PERL_CORE /* not used; but needed for backward compatibility with XS code? - RMB */ # undef UVf #else # ifndef UVf # define UVf UVuf # endif #endif #ifdef HASATTRIBUTE_DEPRECATED # define __attribute__deprecated__ __attribute__((deprecated)) #endif #ifdef HASATTRIBUTE_FORMAT # define __attribute__format__(x,y,z) __attribute__((format(x,y,z))) #endif #ifdef HASATTRIBUTE_MALLOC # define __attribute__malloc__ __attribute__((__malloc__)) #endif #ifdef HASATTRIBUTE_NONNULL # define __attribute__nonnull__(a) __attribute__((nonnull(a))) #endif #ifdef HASATTRIBUTE_NORETURN # define __attribute__noreturn__ __attribute__((noreturn)) #endif #ifdef HASATTRIBUTE_PURE # define __attribute__pure__ __attribute__((pure)) #endif #ifdef HASATTRIBUTE_UNUSED # define __attribute__unused__ __attribute__((unused)) #endif #ifdef HASATTRIBUTE_WARN_UNUSED_RESULT # define __attribute__warn_unused_result__ __attribute__((warn_unused_result)) #endif /* If we haven't defined the attributes yet, define them to blank. */ #ifndef __attribute__deprecated__ # define __attribute__deprecated__ #endif #ifndef __attribute__format__ # define __attribute__format__(x,y,z) #endif #ifndef __attribute__malloc__ # define __attribute__malloc__ #endif #ifndef __attribute__nonnull__ # define __attribute__nonnull__(a) #endif #ifndef __attribute__noreturn__ # define __attribute__noreturn__ #endif #ifndef __attribute__pure__ # define __attribute__pure__ #endif #ifndef __attribute__unused__ # define __attribute__unused__ #endif #ifndef __attribute__warn_unused_result__ # define __attribute__warn_unused_result__ #endif /* For functions that are marked as __attribute__noreturn__, it's not appropriate to call return. In either case, include the lint directive. */ #ifdef HASATTRIBUTE_NORETURN # define NORETURN_FUNCTION_END /* NOTREACHED */ #else # define NORETURN_FUNCTION_END /* NOTREACHED */ return 0 #endif /* Some OS warn on NULL format to printf */ #ifdef PRINTF_FORMAT_NULL_OK # define __attribute__format__null_ok__(x,y,z) __attribute__format__(x,y,z) #else # define __attribute__format__null_ok__(x,y,z) #endif #ifdef HAS_BUILTIN_EXPECT # define EXPECT(expr,val) __builtin_expect(expr,val) #else # define EXPECT(expr,val) (expr) #endif #define LIKELY(cond) EXPECT(cond,1) #define UNLIKELY(cond) EXPECT(cond,0) #ifdef HAS_BUILTIN_CHOOSE_EXPR /* placeholder */ #endif /* Some unistd.h's give a prototype for pause() even though HAS_PAUSE ends up undefined. This causes the #define below to be rejected by the compiler. Sigh. */ #ifdef HAS_PAUSE #define Pause pause #else #define Pause() sleep((32767<<16)+32767) #endif #ifndef IOCPARM_LEN # ifdef IOCPARM_MASK /* on BSDish systems we're safe */ # define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK) # else # if defined(_IOC_SIZE) && defined(__GLIBC__) /* on Linux systems we're safe; except when we're not [perl #38223] */ # define IOCPARM_LEN(x) (_IOC_SIZE(x) < 256 ? 256 : _IOC_SIZE(x)) # else /* otherwise guess at what's safe */ # define IOCPARM_LEN(x) 256 # endif # endif #endif #if defined(__CYGWIN__) /* USEMYBINMODE * This symbol, if defined, indicates that the program should * use the routine my_binmode(FILE *fp, char iotype, int mode) to insure * that a file is in "binary" mode -- that is, that no translation * of bytes occurs on read or write operations. */ # define USEMYBINMODE /**/ # include /* for setmode() prototype */ # define my_binmode(fp, iotype, mode) \ (PerlLIO_setmode(fileno(fp), mode) != -1 ? TRUE : FALSE) #endif #ifdef __CYGWIN__ void init_os_extras(void); #endif #ifdef UNION_ANY_DEFINITION UNION_ANY_DEFINITION; #else union any { void* any_ptr; I32 any_i32; IV any_iv; UV any_uv; long any_long; bool any_bool; void (*any_dptr) (void*); void (*any_dxptr) (pTHX_ void*); }; #endif typedef I32 (*filter_t) (pTHX_ int, SV *, int); #define FILTER_READ(idx, sv, len) filter_read(idx, sv, len) #define FILTER_DATA(idx) \ (PL_parser ? AvARRAY(PL_parser->rsfp_filters)[idx] : NULL) #define FILTER_ISREADER(idx) \ (PL_parser && PL_parser->rsfp_filters \ && idx >= AvFILLp(PL_parser->rsfp_filters)) #define PERL_FILTER_EXISTS(i) \ (PL_parser && PL_parser->rsfp_filters \ && (i) <= av_len(PL_parser->rsfp_filters)) #if defined(_AIX) && !defined(_AIX43) #if defined(USE_REENTRANT) || defined(_REENTRANT) || defined(_THREAD_SAFE) /* We cannot include to get the struct crypt_data * because of setkey prototype problems when threading */ typedef struct crypt_data { /* straight from /usr/include/crypt.h */ /* From OSF, Not needed in AIX char C[28], D[28]; */ char E[48]; char KS[16][48]; char block[66]; char iobuf[16]; } CRYPTD; #endif /* threading */ #endif /* AIX */ #if !defined(OS2) # include "iperlsys.h" #endif #ifdef __LIBCATAMOUNT__ #undef HAS_PASSWD /* unixish.h but not unixish enough. */ #undef HAS_GROUP #define FAKE_BIT_BUCKET #endif /* [perl #22371] Algorimic Complexity Attack on Perl 5.6.1, 5.8.0. * Note that the USE_HASH_SEED and USE_HASH_SEED_EXPLICIT are *NOT* * defined by Configure, despite their names being similar to the * other defines like USE_ITHREADS. Configure in fact knows nothing * about the randomised hashes. Therefore to enable/disable the hash * randomisation defines use the Configure -Accflags=... instead. */ #if !defined(NO_HASH_SEED) && !defined(USE_HASH_SEED) && !defined(USE_HASH_SEED_EXPLICIT) # define USE_HASH_SEED #endif /* Win32 defines a type 'WORD' in windef.h. This conflicts with the enumerator * 'WORD' defined in perly.h. The yytokentype enum is only a debugging aid, so * it's not really needed. */ #if defined(WIN32) # define YYTOKENTYPE #endif #include "perly.h" #ifdef PERL_MAD struct nexttoken { YYSTYPE next_val; /* value of next token, if any */ I32 next_type; /* type of next token */ MADPROP *next_mad; /* everything else about that token */ }; #endif /* macros to define bit-fields in structs. */ #ifndef PERL_BITFIELD8 # define PERL_BITFIELD8 unsigned #endif #ifndef PERL_BITFIELD16 # define PERL_BITFIELD16 unsigned #endif #ifndef PERL_BITFIELD32 # define PERL_BITFIELD32 unsigned #endif #include "sv.h" #include "regexp.h" #include "util.h" #include "form.h" #include "gv.h" #include "pad.h" #include "cv.h" #include "opnames.h" #include "op.h" #include "hv.h" #include "cop.h" #include "av.h" #include "mg.h" #include "scope.h" #include "warnings.h" #include "utf8.h" /* these would be in doio.h if there was such a file */ #define my_stat() my_stat_flags(SV_GMAGIC) #define my_lstat() my_lstat_flags(SV_GMAGIC) /* defined in sv.c, but also used in [ach]v.c */ #undef _XPV_HEAD #undef _XPVMG_HEAD #undef _XPVCV_COMMON typedef struct _sublex_info SUBLEXINFO; struct _sublex_info { U8 super_state; /* lexer state to save */ U16 sub_inwhat; /* "lex_inwhat" to use */ OP *sub_op; /* "lex_op" to use */ char *super_bufptr; /* PL_parser->bufptr that was */ char *super_bufend; /* PL_parser->bufend that was */ }; #include "parser.h" typedef struct magic_state MGS; /* struct magic_state defined in mg.c */ struct scan_data_t; /* Used in S_* functions in regcomp.c */ struct regnode_charclass_class; /* Used in S_* functions in regcomp.c */ struct ptr_tbl_ent { struct ptr_tbl_ent* next; const void* oldval; void* newval; }; struct ptr_tbl { struct ptr_tbl_ent** tbl_ary; UV tbl_max; UV tbl_items; struct ptr_tbl_arena *tbl_arena; struct ptr_tbl_ent *tbl_arena_next; struct ptr_tbl_ent *tbl_arena_end; }; #if defined(iAPX286) || defined(M_I286) || defined(I80286) # define I286 #endif #if defined(htonl) && !defined(HAS_HTONL) #define HAS_HTONL #endif #if defined(htons) && !defined(HAS_HTONS) #define HAS_HTONS #endif #if defined(ntohl) && !defined(HAS_NTOHL) #define HAS_NTOHL #endif #if defined(ntohs) && !defined(HAS_NTOHS) #define HAS_NTOHS #endif #ifndef HAS_HTONL #if (BYTEORDER & 0xffff) != 0x4321 #define HAS_HTONS #define HAS_HTONL #define HAS_NTOHS #define HAS_NTOHL #define MYSWAP #define htons my_swap #define htonl my_htonl #define ntohs my_swap #define ntohl my_ntohl #endif #else #if (BYTEORDER & 0xffff) == 0x4321 #undef HAS_HTONS #undef HAS_HTONL #undef HAS_NTOHS #undef HAS_NTOHL #endif #endif /* * Little-endian byte order functions - 'v' for 'VAX', or 'reVerse'. * -DWS */ #if BYTEORDER != 0x1234 # define HAS_VTOHL # define HAS_VTOHS # define HAS_HTOVL # define HAS_HTOVS # if BYTEORDER == 0x4321 || BYTEORDER == 0x87654321 # define vtohl(x) ((((x)&0xFF)<<24) \ +(((x)>>24)&0xFF) \ +(((x)&0x0000FF00)<<8) \ +(((x)&0x00FF0000)>>8) ) # define vtohs(x) ((((x)&0xFF)<<8) + (((x)>>8)&0xFF)) # define htovl(x) vtohl(x) # define htovs(x) vtohs(x) # endif /* otherwise default to functions in util.c */ #ifndef htovs short htovs(short n); short vtohs(short n); long htovl(long n); long vtohl(long n); #endif #endif /* *MAX Plus 1. A floating point value. Hopefully expressed in a way that dodgy floating point can't mess up. >> 2 rather than 1, so that value is safely less than I32_MAX after 1 is added to it May find that some broken compiler will want the value cast to I32. [after the shift, as signed >> may not be as secure as unsigned >>] */ #define I32_MAX_P1 (2.0 * (1 + (((U32)I32_MAX) >> 1))) #define U32_MAX_P1 (4.0 * (1 + ((U32_MAX) >> 2))) /* For compilers that can't correctly cast NVs over 0x7FFFFFFF (or 0x7FFFFFFFFFFFFFFF) to an unsigned integer. In the future, sizeof(UV) may be greater than sizeof(IV), so don't assume that half max UV is max IV. */ #define U32_MAX_P1_HALF (2.0 * (1 + ((U32_MAX) >> 2))) #define UV_MAX_P1 (4.0 * (1 + ((UV_MAX) >> 2))) #define IV_MAX_P1 (2.0 * (1 + (((UV)IV_MAX) >> 1))) #define UV_MAX_P1_HALF (2.0 * (1 + ((UV_MAX) >> 2))) /* This may look like unnecessary jumping through hoops, but converting out of range floating point values to integers *is* undefined behaviour, and it is starting to bite. */ #ifndef CAST_INLINE #define I_32(what) (cast_i32((NV)(what))) #define U_32(what) (cast_ulong((NV)(what))) #define I_V(what) (cast_iv((NV)(what))) #define U_V(what) (cast_uv((NV)(what))) #else #define I_32(n) ((n) < I32_MAX_P1 ? ((n) < I32_MIN ? I32_MIN : (I32) (n)) \ : ((n) < U32_MAX_P1 ? (I32)(U32) (n) \ : ((n) > 0 ? (I32) U32_MAX : 0 /* NaN */))) #define U_32(n) ((n) < 0.0 ? ((n) < I32_MIN ? (UV) I32_MIN : (U32)(I32) (n)) \ : ((n) < U32_MAX_P1 ? (U32) (n) \ : ((n) > 0 ? U32_MAX : 0 /* NaN */))) #define I_V(n) ((n) < IV_MAX_P1 ? ((n) < IV_MIN ? IV_MIN : (IV) (n)) \ : ((n) < UV_MAX_P1 ? (IV)(UV) (n) \ : ((n) > 0 ? (IV)UV_MAX : 0 /* NaN */))) #define U_V(n) ((n) < 0.0 ? ((n) < IV_MIN ? (UV) IV_MIN : (UV)(IV) (n)) \ : ((n) < UV_MAX_P1 ? (UV) (n) \ : ((n) > 0 ? UV_MAX : 0 /* NaN */))) #endif #define U_S(what) ((U16)U_32(what)) #define U_I(what) ((unsigned int)U_32(what)) #define U_L(what) U_32(what) #ifdef HAS_SIGNBIT # define Perl_signbit signbit #endif /* These do not care about the fractional part, only about the range. */ #define NV_WITHIN_IV(nv) (I_V(nv) >= IV_MIN && I_V(nv) <= IV_MAX) #define NV_WITHIN_UV(nv) ((nv)>=0.0 && U_V(nv) >= UV_MIN && U_V(nv) <= UV_MAX) /* Used with UV/IV arguments: */ /* XXXX: need to speed it up */ #define CLUMP_2UV(iv) ((iv) < 0 ? 0 : (UV)(iv)) #define CLUMP_2IV(uv) ((uv) > (UV)IV_MAX ? IV_MAX : (IV)(uv)) #ifndef MAXSYSFD # define MAXSYSFD 2 #endif #ifndef __cplusplus #if !(defined(UNDER_CE) || defined(SYMBIAN)) Uid_t getuid (void); Uid_t geteuid (void); Gid_t getgid (void); Gid_t getegid (void); #endif #endif #ifndef Perl_debug_log # define Perl_debug_log PerlIO_stderr() #endif #ifndef Perl_error_log # define Perl_error_log (PL_stderrgv \ && isGV(PL_stderrgv) \ && GvIOp(PL_stderrgv) \ && IoOFP(GvIOp(PL_stderrgv)) \ ? IoOFP(GvIOp(PL_stderrgv)) \ : PerlIO_stderr()) #endif #define DEBUG_p_FLAG 0x00000001 /* 1 */ #define DEBUG_s_FLAG 0x00000002 /* 2 */ #define DEBUG_l_FLAG 0x00000004 /* 4 */ #define DEBUG_t_FLAG 0x00000008 /* 8 */ #define DEBUG_o_FLAG 0x00000010 /* 16 */ #define DEBUG_c_FLAG 0x00000020 /* 32 */ #define DEBUG_P_FLAG 0x00000040 /* 64 */ #define DEBUG_m_FLAG 0x00000080 /* 128 */ #define DEBUG_f_FLAG 0x00000100 /* 256 */ #define DEBUG_r_FLAG 0x00000200 /* 512 */ #define DEBUG_x_FLAG 0x00000400 /* 1024 */ #define DEBUG_u_FLAG 0x00000800 /* 2048 */ /* U is reserved for Unofficial, exploratory hacking */ #define DEBUG_U_FLAG 0x00001000 /* 4096 */ #define DEBUG_H_FLAG 0x00002000 /* 8192 */ #define DEBUG_X_FLAG 0x00004000 /* 16384 */ #define DEBUG_D_FLAG 0x00008000 /* 32768 */ /* 0x00010000 is unused, used to be S */ #define DEBUG_T_FLAG 0x00020000 /* 131072 */ #define DEBUG_R_FLAG 0x00040000 /* 262144 */ #define DEBUG_J_FLAG 0x00080000 /* 524288 */ #define DEBUG_v_FLAG 0x00100000 /*1048576 */ #define DEBUG_C_FLAG 0x00200000 /*2097152 */ #define DEBUG_A_FLAG 0x00400000 /*4194304 */ #define DEBUG_q_FLAG 0x00800000 /*8388608 */ #define DEBUG_M_FLAG 0x01000000 /*16777216*/ #define DEBUG_B_FLAG 0x02000000 /*33554432*/ #define DEBUG_MASK 0x03FEEFFF /* mask of all the standard flags */ #define DEBUG_DB_RECURSE_FLAG 0x40000000 #define DEBUG_TOP_FLAG 0x80000000 /* XXX what's this for ??? Signal that something was done? */ # define DEBUG_p_TEST_ (PL_debug & DEBUG_p_FLAG) # define DEBUG_s_TEST_ (PL_debug & DEBUG_s_FLAG) # define DEBUG_l_TEST_ (PL_debug & DEBUG_l_FLAG) # define DEBUG_t_TEST_ (PL_debug & DEBUG_t_FLAG) # define DEBUG_o_TEST_ (PL_debug & DEBUG_o_FLAG) # define DEBUG_c_TEST_ (PL_debug & DEBUG_c_FLAG) # define DEBUG_P_TEST_ (PL_debug & DEBUG_P_FLAG) # define DEBUG_m_TEST_ (PL_debug & DEBUG_m_FLAG) # define DEBUG_f_TEST_ (PL_debug & DEBUG_f_FLAG) # define DEBUG_r_TEST_ (PL_debug & DEBUG_r_FLAG) # define DEBUG_x_TEST_ (PL_debug & DEBUG_x_FLAG) # define DEBUG_u_TEST_ (PL_debug & DEBUG_u_FLAG) # define DEBUG_U_TEST_ (PL_debug & DEBUG_U_FLAG) # define DEBUG_H_TEST_ (PL_debug & DEBUG_H_FLAG) # define DEBUG_X_TEST_ (PL_debug & DEBUG_X_FLAG) # define DEBUG_D_TEST_ (PL_debug & DEBUG_D_FLAG) # define DEBUG_T_TEST_ (PL_debug & DEBUG_T_FLAG) # define DEBUG_R_TEST_ (PL_debug & DEBUG_R_FLAG) # define DEBUG_J_TEST_ (PL_debug & DEBUG_J_FLAG) # define DEBUG_v_TEST_ (PL_debug & DEBUG_v_FLAG) # define DEBUG_C_TEST_ (PL_debug & DEBUG_C_FLAG) # define DEBUG_A_TEST_ (PL_debug & DEBUG_A_FLAG) # define DEBUG_q_TEST_ (PL_debug & DEBUG_q_FLAG) # define DEBUG_M_TEST_ (PL_debug & DEBUG_M_FLAG) # define DEBUG_B_TEST_ (PL_debug & DEBUG_B_FLAG) # define DEBUG_Xv_TEST_ (DEBUG_X_TEST_ && DEBUG_v_TEST_) # define DEBUG_Uv_TEST_ (DEBUG_U_TEST_ && DEBUG_v_TEST_) # define DEBUG_Pv_TEST_ (DEBUG_P_TEST_ && DEBUG_v_TEST_) #ifdef DEBUGGING # define DEBUG_p_TEST DEBUG_p_TEST_ # define DEBUG_s_TEST DEBUG_s_TEST_ # define DEBUG_l_TEST DEBUG_l_TEST_ # define DEBUG_t_TEST DEBUG_t_TEST_ # define DEBUG_o_TEST DEBUG_o_TEST_ # define DEBUG_c_TEST DEBUG_c_TEST_ # define DEBUG_P_TEST DEBUG_P_TEST_ # define DEBUG_m_TEST DEBUG_m_TEST_ # define DEBUG_f_TEST DEBUG_f_TEST_ # define DEBUG_r_TEST DEBUG_r_TEST_ # define DEBUG_x_TEST DEBUG_x_TEST_ # define DEBUG_u_TEST DEBUG_u_TEST_ # define DEBUG_U_TEST DEBUG_U_TEST_ # define DEBUG_H_TEST DEBUG_H_TEST_ # define DEBUG_X_TEST DEBUG_X_TEST_ # define DEBUG_D_TEST DEBUG_D_TEST_ # define DEBUG_T_TEST DEBUG_T_TEST_ # define DEBUG_R_TEST DEBUG_R_TEST_ # define DEBUG_J_TEST DEBUG_J_TEST_ # define DEBUG_v_TEST DEBUG_v_TEST_ # define DEBUG_C_TEST DEBUG_C_TEST_ # define DEBUG_A_TEST DEBUG_A_TEST_ # define DEBUG_q_TEST DEBUG_q_TEST_ # define DEBUG_M_TEST DEBUG_M_TEST_ # define DEBUG_B_TEST DEBUG_B_TEST_ # define DEBUG_Xv_TEST DEBUG_Xv_TEST_ # define DEBUG_Uv_TEST DEBUG_Uv_TEST_ # define DEBUG_Pv_TEST DEBUG_Pv_TEST_ # define PERL_DEB(a) a # define PERL_DEBUG(a) if (PL_debug) a # define DEBUG_p(a) if (DEBUG_p_TEST) a # define DEBUG_s(a) if (DEBUG_s_TEST) a # define DEBUG_l(a) if (DEBUG_l_TEST) a # define DEBUG_t(a) if (DEBUG_t_TEST) a # define DEBUG_o(a) if (DEBUG_o_TEST) a # define DEBUG_c(a) if (DEBUG_c_TEST) a # define DEBUG_P(a) if (DEBUG_P_TEST) a /* Temporarily turn off memory debugging in case the a * does memory allocation, either directly or indirectly. */ # define DEBUG_m(a) \ STMT_START { \ if (PERL_GET_INTERP) { dTHX; if (DEBUG_m_TEST) {PL_debug&=~DEBUG_m_FLAG; a; PL_debug|=DEBUG_m_FLAG;} } \ } STMT_END # define DEBUG__(t, a) \ STMT_START { \ if (t) STMT_START {a;} STMT_END; \ } STMT_END # define DEBUG_f(a) DEBUG__(DEBUG_f_TEST, a) #ifndef PERL_EXT_RE_BUILD # define DEBUG_r(a) DEBUG__(DEBUG_r_TEST, a) #else # define DEBUG_r(a) STMT_START {a;} STMT_END #endif /* PERL_EXT_RE_BUILD */ # define DEBUG_x(a) DEBUG__(DEBUG_x_TEST, a) # define DEBUG_u(a) DEBUG__(DEBUG_u_TEST, a) # define DEBUG_U(a) DEBUG__(DEBUG_U_TEST, a) # define DEBUG_H(a) DEBUG__(DEBUG_H_TEST, a) # define DEBUG_X(a) DEBUG__(DEBUG_X_TEST, a) # define DEBUG_D(a) DEBUG__(DEBUG_D_TEST, a) # define DEBUG_Xv(a) DEBUG__(DEBUG_Xv_TEST, a) # define DEBUG_Uv(a) DEBUG__(DEBUG_Uv_TEST, a) # define DEBUG_Pv(a) DEBUG__(DEBUG_Pv_TEST, a) # define DEBUG_T(a) DEBUG__(DEBUG_T_TEST, a) # define DEBUG_R(a) DEBUG__(DEBUG_R_TEST, a) # define DEBUG_v(a) DEBUG__(DEBUG_v_TEST, a) # define DEBUG_C(a) DEBUG__(DEBUG_C_TEST, a) # define DEBUG_A(a) DEBUG__(DEBUG_A_TEST, a) # define DEBUG_q(a) DEBUG__(DEBUG_q_TEST, a) # define DEBUG_M(a) DEBUG__(DEBUG_M_TEST, a) # define DEBUG_B(a) DEBUG__(DEBUG_B_TEST, a) #else /* DEBUGGING */ # define DEBUG_p_TEST (0) # define DEBUG_s_TEST (0) # define DEBUG_l_TEST (0) # define DEBUG_t_TEST (0) # define DEBUG_o_TEST (0) # define DEBUG_c_TEST (0) # define DEBUG_P_TEST (0) # define DEBUG_m_TEST (0) # define DEBUG_f_TEST (0) # define DEBUG_r_TEST (0) # define DEBUG_x_TEST (0) # define DEBUG_u_TEST (0) # define DEBUG_U_TEST (0) # define DEBUG_H_TEST (0) # define DEBUG_X_TEST (0) # define DEBUG_D_TEST (0) # define DEBUG_T_TEST (0) # define DEBUG_R_TEST (0) # define DEBUG_J_TEST (0) # define DEBUG_v_TEST (0) # define DEBUG_C_TEST (0) # define DEBUG_A_TEST (0) # define DEBUG_q_TEST (0) # define DEBUG_M_TEST (0) # define DEBUG_B_TEST (0) # define DEBUG_Xv_TEST (0) # define DEBUG_Uv_TEST (0) # define DEBUG_Pv_TEST (0) # define PERL_DEB(a) # define PERL_DEBUG(a) # define DEBUG_p(a) # define DEBUG_s(a) # define DEBUG_l(a) # define DEBUG_t(a) # define DEBUG_o(a) # define DEBUG_c(a) # define DEBUG_P(a) # define DEBUG_m(a) # define DEBUG_f(a) # define DEBUG_r(a) # define DEBUG_x(a) # define DEBUG_u(a) # define DEBUG_U(a) # define DEBUG_H(a) # define DEBUG_X(a) # define DEBUG_D(a) # define DEBUG_T(a) # define DEBUG_R(a) # define DEBUG_v(a) # define DEBUG_C(a) # define DEBUG_A(a) # define DEBUG_q(a) # define DEBUG_M(a) # define DEBUG_B(a) # define DEBUG_Xv(a) # define DEBUG_Uv(a) # define DEBUG_Pv(a) #endif /* DEBUGGING */ #define DEBUG_SCOPE(where) \ DEBUG_l( \ Perl_deb(aTHX_ "%s scope %ld (savestack=%ld) at %s:%d\n", \ where, (long)PL_scopestack_ix, (long)PL_savestack_ix, \ __FILE__, __LINE__)); #if defined(DEBUGGING) && defined(I_ASSERT) # include #endif /* Keep the old croak based assert for those who want it, and as a fallback if the platform is so heretically non-ANSI that it can't assert. */ #define Perl_assert(what) PERL_DEB( \ ((what) ? ((void) 0) : \ (Perl_croak_nocontext("Assertion %s failed: file \"" __FILE__ \ "\", line %d", STRINGIFY(what), __LINE__), \ (void) 0))) #ifndef assert # define assert(what) Perl_assert(what) #endif struct ufuncs { I32 (*uf_val)(pTHX_ IV, SV*); I32 (*uf_set)(pTHX_ IV, SV*); IV uf_index; }; /* In pre-5.7-Perls the PERL_MAGIC_uvar magic didn't get the thread context. * XS code wanting to be backward compatible can do something * like the following: #ifndef PERL_MG_UFUNC #define PERL_MG_UFUNC(name,ix,sv) I32 name(IV ix, SV *sv) #endif static PERL_MG_UFUNC(foo_get, index, val) { sv_setsv(val, ...); return TRUE; } -- Doug MacEachern */ #ifndef PERL_MG_UFUNC #define PERL_MG_UFUNC(name,ix,sv) I32 name(pTHX_ IV ix, SV *sv) #endif /* Fix these up for __STDC__ */ #ifndef DONT_DECLARE_STD char *mktemp (char*); #ifndef atof double atof (const char*); #endif #endif #ifndef STANDARD_C /* All of these are in stdlib.h or time.h for ANSI C */ Time_t time(); struct tm *gmtime(), *localtime(); #if defined(OEMVS) || defined(__OPEN_VM) char *(strchr)(), *(strrchr)(); char *(strcpy)(), *(strcat)(); #else char *strchr(), *strrchr(); char *strcpy(), *strcat(); #endif #endif /* ! STANDARD_C */ #ifdef I_MATH # include #else START_EXTERN_C double exp (double); double log (double); double log10 (double); double sqrt (double); double frexp (double,int*); double ldexp (double,int); double modf (double,double*); double sin (double); double cos (double); double atan2 (double,double); double pow (double,double); END_EXTERN_C #endif #if !defined(NV_INF) && defined(USE_LONG_DOUBLE) && defined(LDBL_INFINITY) # define NV_INF LDBL_INFINITY #endif #if !defined(NV_INF) && defined(DBL_INFINITY) # define NV_INF (NV)DBL_INFINITY #endif #if !defined(NV_INF) && defined(INFINITY) # define NV_INF (NV)INFINITY #endif #if !defined(NV_INF) && defined(INF) # define NV_INF (NV)INF #endif #if !defined(NV_INF) && defined(USE_LONG_DOUBLE) && defined(HUGE_VALL) # define NV_INF (NV)HUGE_VALL #endif #if !defined(NV_INF) && defined(HUGE_VAL) # define NV_INF (NV)HUGE_VAL #endif #if !defined(NV_NAN) && defined(USE_LONG_DOUBLE) # if !defined(NV_NAN) && defined(LDBL_NAN) # define NV_NAN LDBL_NAN # endif # if !defined(NV_NAN) && defined(LDBL_QNAN) # define NV_NAN LDBL_QNAN # endif # if !defined(NV_NAN) && defined(LDBL_SNAN) # define NV_NAN LDBL_SNAN # endif #endif #if !defined(NV_NAN) && defined(DBL_NAN) # define NV_NAN (NV)DBL_NAN #endif #if !defined(NV_NAN) && defined(DBL_QNAN) # define NV_NAN (NV)DBL_QNAN #endif #if !defined(NV_NAN) && defined(DBL_SNAN) # define NV_NAN (NV)DBL_SNAN #endif #if !defined(NV_NAN) && defined(QNAN) # define NV_NAN (NV)QNAN #endif #if !defined(NV_NAN) && defined(SNAN) # define NV_NAN (NV)SNAN #endif #if !defined(NV_NAN) && defined(NAN) # define NV_NAN (NV)NAN #endif #ifndef __cplusplus # if defined(NeXT) || defined(__NeXT__) /* or whatever catches all NeXTs */ char *crypt (); /* Maybe more hosts will need the unprototyped version */ # else # if !defined(WIN32) && !defined(VMS) #ifndef crypt char *crypt (const char*, const char*); #endif # endif /* !WIN32 */ # endif /* !NeXT && !__NeXT__ */ # ifndef DONT_DECLARE_STD # ifndef getenv char *getenv (const char*); # endif /* !getenv */ # if !defined(HAS_LSEEK_PROTO) && !defined(EPOC) && !defined(__hpux) # ifdef _FILE_OFFSET_BITS # if _FILE_OFFSET_BITS == 64 Off_t lseek (int,Off_t,int); # endif # endif # endif # endif /* !DONT_DECLARE_STD */ #ifndef getlogin char *getlogin (void); #endif #endif /* !__cplusplus */ /* Fixme on VMS. This needs to be a run-time, not build time options */ /* Also rename() is affected by this */ #ifdef UNLINK_ALL_VERSIONS /* Currently only makes sense for VMS */ #define UNLINK unlnk I32 unlnk (pTHX_ const char*); #else #define UNLINK PerlLIO_unlink #endif /* some versions of glibc are missing the setresuid() proto */ #if defined(HAS_SETRESUID) && !defined(HAS_SETRESUID_PROTO) int setresuid(uid_t ruid, uid_t euid, uid_t suid); #endif /* some versions of glibc are missing the setresgid() proto */ #if defined(HAS_SETRESGID) && !defined(HAS_SETRESGID_PROTO) int setresgid(gid_t rgid, gid_t egid, gid_t sgid); #endif #ifndef HAS_SETREUID # ifdef HAS_SETRESUID # define setreuid(r,e) setresuid(r,e,(Uid_t)-1) # define HAS_SETREUID # endif #endif #ifndef HAS_SETREGID # ifdef HAS_SETRESGID # define setregid(r,e) setresgid(r,e,(Gid_t)-1) # define HAS_SETREGID # endif #endif /* Sighandler_t defined in iperlsys.h */ #ifdef HAS_SIGACTION typedef struct sigaction Sigsave_t; #else typedef Sighandler_t Sigsave_t; #endif #define SCAN_DEF 0 #define SCAN_TR 1 #define SCAN_REPL 2 #ifdef DEBUGGING # ifndef register # define register # endif # define RUNOPS_DEFAULT Perl_runops_debug #else # define RUNOPS_DEFAULT Perl_runops_standard #endif #ifdef USE_PERLIO EXTERN_C void PerlIO_teardown(void); # ifdef USE_ITHREADS # define PERLIO_INIT MUTEX_INIT(&PL_perlio_mutex) # define PERLIO_TERM \ STMT_START { \ PerlIO_teardown(); \ MUTEX_DESTROY(&PL_perlio_mutex);\ } STMT_END # else # define PERLIO_INIT # define PERLIO_TERM PerlIO_teardown() # endif #else # define PERLIO_INIT # define PERLIO_TERM #endif #ifdef MYMALLOC # ifdef MUTEX_INIT_CALLS_MALLOC # define MALLOC_INIT \ STMT_START { \ PL_malloc_mutex = NULL; \ MUTEX_INIT(&PL_malloc_mutex); \ } STMT_END # define MALLOC_TERM \ STMT_START { \ perl_mutex tmp = PL_malloc_mutex; \ PL_malloc_mutex = NULL; \ MUTEX_DESTROY(&tmp); \ } STMT_END # else # define MALLOC_INIT MUTEX_INIT(&PL_malloc_mutex) # define MALLOC_TERM MUTEX_DESTROY(&PL_malloc_mutex) # endif #else # define MALLOC_INIT # define MALLOC_TERM #endif #if defined(PERL_IMPLICIT_CONTEXT) struct perl_memory_debug_header; struct perl_memory_debug_header { tTHX interpreter; # ifdef PERL_POISON MEM_SIZE size; # endif struct perl_memory_debug_header *prev; struct perl_memory_debug_header *next; }; # define sTHX (sizeof(struct perl_memory_debug_header) + \ (MEM_ALIGNBYTES - sizeof(struct perl_memory_debug_header) \ %MEM_ALIGNBYTES) % MEM_ALIGNBYTES) #else # define sTHX 0 #endif #ifdef PERL_TRACK_MEMPOOL # define INIT_TRACK_MEMPOOL(header, interp) \ STMT_START { \ (header).interpreter = (interp); \ (header).prev = (header).next = &(header); \ } STMT_END # else # define INIT_TRACK_MEMPOOL(header, interp) #endif #ifdef I_MALLOCMALLOC /* Needed for malloc_size(), malloc_good_size() on some systems */ # include #endif #ifdef MYMALLOC # define Perl_safesysmalloc_size(where) Perl_malloced_size(where) #else # ifdef HAS_MALLOC_SIZE # ifdef PERL_TRACK_MEMPOOL # define Perl_safesysmalloc_size(where) \ (malloc_size(((char *)(where)) - sTHX) - sTHX) # else # define Perl_safesysmalloc_size(where) malloc_size(where) # endif # endif # ifdef HAS_MALLOC_GOOD_SIZE # ifdef PERL_TRACK_MEMPOOL # define Perl_malloc_good_size(how_much) \ (malloc_good_size((how_much) + sTHX) - sTHX) # else # define Perl_malloc_good_size(how_much) malloc_good_size(how_much) # endif # else /* Having this as the identity operation makes some code simpler. */ # define Perl_malloc_good_size(how_much) (how_much) # endif #endif typedef int (*runops_proc_t)(pTHX); typedef void (*share_proc_t) (pTHX_ SV *sv); typedef int (*thrhook_proc_t) (pTHX); typedef OP* (*PPADDR_t[]) (pTHX); typedef bool (*destroyable_proc_t) (pTHX_ SV *sv); typedef void (*despatch_signals_proc_t) (pTHX); /* NeXT has problems with crt0.o globals */ #if defined(__DYNAMIC__) && \ (defined(NeXT) || defined(__NeXT__) || defined(PERL_DARWIN)) # if defined(NeXT) || defined(__NeXT) # include # define environ (*environ_pointer) EXT char *** environ_pointer; # else # if defined(PERL_DARWIN) && defined(PERL_CORE) # include /* for the env array */ # define environ (*_NSGetEnviron()) # endif # endif #else /* VMS and some other platforms don't use the environ array */ # ifdef USE_ENVIRON_ARRAY # if !defined(DONT_DECLARE_STD) || \ (defined(__svr4__) && defined(__GNUC__) && defined(sun)) || \ defined(__sgi) || \ defined(__DGUX) extern char ** environ; /* environment variables supplied via exec */ # endif # endif #endif #define PERL_PATCHLEVEL_H_IMPLICIT #include "patchlevel.h" #undef PERL_PATCHLEVEL_H_IMPLICIT #define PERL_VERSION_STRING STRINGIFY(PERL_REVISION) "." \ STRINGIFY(PERL_VERSION) "." \ STRINGIFY(PERL_SUBVERSION) #define PERL_API_VERSION_STRING STRINGIFY(PERL_API_REVISION) "." \ STRINGIFY(PERL_API_VERSION) "." \ STRINGIFY(PERL_API_SUBVERSION) START_EXTERN_C /* handy constants */ EXTCONST char PL_warn_uninit[] INIT("Use of uninitialized value%s%s%s"); EXTCONST char PL_warn_uninit_sv[] INIT("Use of uninitialized value%"SVf"%s%s"); EXTCONST char PL_warn_nosemi[] INIT("Semicolon seems to be missing"); EXTCONST char PL_warn_reserved[] INIT("Unquoted string \"%s\" may clash with future reserved word"); EXTCONST char PL_warn_nl[] INIT("Unsuccessful %s on filename containing newline"); EXTCONST char PL_no_wrongref[] INIT("Can't use %s ref as %s ref"); /* The core no longer needs these here. If you require the string constant, please inline a copy into your own code. */ EXTCONST char PL_no_symref[] __attribute__deprecated__ INIT("Can't use string (\"%.32s\") as %s ref while \"strict refs\" in use"); EXTCONST char PL_no_symref_sv[] __attribute__deprecated__ INIT("Can't use string (\"%" SVf32 "\") as %s ref while \"strict refs\" in use"); EXTCONST char PL_no_usym[] INIT("Can't use an undefined value as %s reference"); EXTCONST char PL_no_aelem[] INIT("Modification of non-creatable array value attempted, subscript %d"); EXTCONST char PL_no_helem_sv[] INIT("Modification of non-creatable hash value attempted, subscript \"%"SVf"\""); EXTCONST char PL_no_modify[] INIT("Modification of a read-only value attempted"); EXTCONST char PL_no_mem[] INIT("Out of memory!\n"); EXTCONST char PL_no_security[] INIT("Insecure dependency in %s%s"); EXTCONST char PL_no_sock_func[] INIT("Unsupported socket function \"%s\" called"); EXTCONST char PL_no_dir_func[] INIT("Unsupported directory function \"%s\" called"); EXTCONST char PL_no_func[] INIT("The %s function is unimplemented"); EXTCONST char PL_no_myglob[] INIT("\"%s\" variable %s can't be in a package"); EXTCONST char PL_no_localize_ref[] INIT("Can't localize through a reference"); EXTCONST char PL_memory_wrap[] INIT("panic: memory wrap"); EXTCONST char PL_Yes[] INIT("1"); EXTCONST char PL_No[] INIT(""); EXTCONST char PL_hexdigit[] INIT("0123456789abcdef0123456789ABCDEF"); /* This is constant on most architectures, a global on OS/2 */ #ifndef OS2 EXTCONST char PL_sh_path[] INIT(SH_PATH); /* full path of shell */ #endif #ifdef CSH EXTCONST char PL_cshname[] INIT(CSH); # define PL_cshlen (sizeof(CSH "") - 1) #endif /* These are baked at compile time into any shared perl library. In future releases this will allow us in main() to sanity test the library we're linking against. */ EXTCONST U8 PL_revision INIT(PERL_REVISION); EXTCONST U8 PL_version INIT(PERL_VERSION); EXTCONST U8 PL_subversion INIT(PERL_SUBVERSION); EXTCONST char PL_uuemap[65] INIT("`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"); #ifdef DOINIT EXTCONST char PL_uudmap[256] = # ifdef PERL_MICRO # include "uuudmap.h" # else # include "uudmap.h" # endif ; EXTCONST char PL_bitcount[256] = # ifdef PERL_MICRO # include "ubitcount.h" #else # include "bitcount.h" # endif ; EXTCONST char* const PL_sig_name[] = { SIG_NAME }; EXTCONST int PL_sig_num[] = { SIG_NUM }; #else EXTCONST char PL_uudmap[256]; EXTCONST char PL_bitcount[256]; EXTCONST char* const PL_sig_name[]; EXTCONST int PL_sig_num[]; #endif /* fast conversion and case folding tables. The folding tables complement the * fold, so that 'a' maps to 'A' and 'A' maps to 'a', ignoring more complicated * folds such as outside the range or to multiple characters. */ #ifdef DOINIT #ifndef EBCDIC /* The EBCDIC fold table depends on the code page, and hence is found in * utfebcdic.h */ EXTCONST unsigned char PL_fold[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 91, 92, 93, 94, 95, 96, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 }; EXTCONST unsigned char PL_fold_latin1[] = { /* Full latin1 complement folding, except for three problematic code points: * Micro sign (181 = 0xB5) and y with diearesis (255 = 0xFF) have their * fold complements outside the Latin1 range, so can't match something * that isn't in utf8. * German lower case sharp s (223 = 0xDF) folds to two characters, 'ss', * not one, so can't be represented in this table. * * All have to be specially handled */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 91, 92, 93, 94, 95, 96, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181 /*micro */, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192+32, 193+32, 194+32, 195+32, 196+32, 197+32, 198+32, 199+32, 200+32, 201+32, 202+32, 203+32, 204+32, 205+32, 206+32, 207+32, 208+32, 209+32, 210+32, 211+32, 212+32, 213+32, 214+32, 215, 216+32, 217+32, 218+32, 219+32, 220+32, 221+32, 222+32, 223 /* ss */, 224-32, 225-32, 226-32, 227-32, 228-32, 229-32, 230-32, 231-32, 232-32, 233-32, 234-32, 235-32, 236-32, 237-32, 238-32, 239-32, 240-32, 241-32, 242-32, 243-32, 244-32, 245-32, 246-32, 247, 248-32, 249-32, 250-32, 251-32, 252-32, 253-32, 254-32, 255 /* y with diaeresis */ }; #endif /* !EBCDIC, but still in DOINIT */ /* If these tables are accessed through ebcdic, the access will be converted to * latin1 first */ EXTCONST unsigned char PL_latin1_lc[] = { /* lowercasing */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192+32, 193+32, 194+32, 195+32, 196+32, 197+32, 198+32, 199+32, 200+32, 201+32, 202+32, 203+32, 204+32, 205+32, 206+32, 207+32, 208+32, 209+32, 210+32, 211+32, 212+32, 213+32, 214+32, 215, 216+32, 217+32, 218+32, 219+32, 220+32, 221+32, 222+32, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 }; /* upper and title case of latin1 characters, modified so that the three tricky * ones are mapped to 255 (which is one of the three) */ EXTCONST unsigned char PL_mod_latin1_uc[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 255 /*micro*/, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 255 /*sharp s*/, 224-32, 225-32, 226-32, 227-32, 228-32, 229-32, 230-32, 231-32, 232-32, 233-32, 234-32, 235-32, 236-32, 237-32, 238-32, 239-32, 240-32, 241-32, 242-32, 243-32, 244-32, 245-32, 246-32, 247, 248-32, 249-32, 250-32, 251-32, 252-32, 253-32, 254-32, 255 }; #else /* ! DOINIT */ EXTCONST unsigned char PL_fold[]; EXTCONST unsigned char PL_fold_latin1[]; EXTCONST unsigned char PL_mod_latin1_uc[]; EXTCONST unsigned char PL_latin1_lc[]; #endif #ifndef PERL_GLOBAL_STRUCT /* or perlvars.h */ #ifdef DOINIT EXT unsigned char PL_fold_locale[] = { /* Unfortunately not EXTCONST. */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 91, 92, 93, 94, 95, 96, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 }; #else EXT unsigned char PL_fold_locale[]; /* Unfortunately not EXTCONST. */ #endif #endif /* !PERL_GLOBAL_STRUCT */ #ifdef DOINIT #ifdef EBCDIC EXTCONST unsigned char PL_freq[] = {/* EBCDIC frequencies for mixed English/C */ 1, 2, 84, 151, 154, 155, 156, 157, 165, 246, 250, 3, 158, 7, 18, 29, 40, 51, 62, 73, 85, 96, 107, 118, 129, 140, 147, 148, 149, 150, 152, 153, 255, 6, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26, 27, 28, 226, 29, 30, 31, 32, 33, 43, 44, 45, 46, 47, 48, 49, 50, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 94, 95, 234, 181, 233, 187, 190, 180, 96, 97, 98, 99, 100, 101, 102, 104, 112, 182, 174, 236, 232, 229, 103, 228, 226, 114, 115, 116, 117, 118, 119, 120, 121, 122, 235, 176, 230, 194, 162, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 201, 205, 163, 217, 220, 224, 5, 248, 227, 244, 242, 255, 241, 231, 240, 253, 16, 197, 19, 20, 21, 187, 23, 169, 210, 245, 237, 249, 247, 239, 168, 252, 34, 196, 36, 37, 38, 39, 41, 42, 251, 254, 238, 223, 221, 213, 225, 177, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 205, 208, 186, 202, 200, 218, 198, 179, 178, 214, 88, 89, 90, 91, 92, 93, 217, 166, 170, 207, 199, 209, 206, 204, 160, 212, 105, 106, 108, 109, 110, 111, 203, 113, 216, 215, 192, 175, 193, 243, 172, 161, 123, 124, 125, 126, 127, 128, 222, 219, 211, 195, 188, 193, 185, 184, 191, 183, 141, 142, 143, 144, 145, 146 }; #else /* ascii rather than ebcdic */ EXTCONST unsigned char PL_freq[] = { /* letter frequencies for mixed English/C */ 1, 2, 84, 151, 154, 155, 156, 157, 165, 246, 250, 3, 158, 7, 18, 29, 40, 51, 62, 73, 85, 96, 107, 118, 129, 140, 147, 148, 149, 150, 152, 153, 255, 182, 224, 205, 174, 176, 180, 217, 233, 232, 236, 187, 235, 228, 234, 226, 222, 219, 211, 195, 188, 193, 185, 184, 191, 183, 201, 229, 181, 220, 194, 162, 163, 208, 186, 202, 200, 218, 198, 179, 178, 214, 166, 170, 207, 199, 209, 206, 204, 160, 212, 216, 215, 192, 175, 173, 243, 172, 161, 190, 203, 189, 164, 230, 167, 248, 227, 244, 242, 255, 241, 231, 240, 253, 169, 210, 245, 237, 249, 247, 239, 168, 252, 251, 254, 238, 223, 221, 213, 225, 177, 197, 171, 196, 159, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 141, 142, 143, 144, 145, 146 }; #endif #else EXTCONST unsigned char PL_freq[]; #endif #ifdef DEBUGGING #ifdef DOINIT EXTCONST char* const PL_block_type[] = { "NULL", "WHEN", "BLOCK", "GIVEN", "LOOP_FOR", "LOOP_PLAIN", "LOOP_LAZYSV", "LOOP_LAZYIV", "SUB", "FORMAT", "EVAL", "SUBST" }; #else EXTCONST char* PL_block_type[]; #endif #endif /* These are all the compile time options that affect binary compatibility. Other compile time options that are binary compatible are in perl.c Both are combined for the output of perl -V However, this string will be embedded in any shared perl library, which will allow us add a comparison check in perlmain.c in the near future. */ #ifdef DOINIT EXTCONST char PL_bincompat_options[] = # ifdef DEBUG_LEAKING_SCALARS " DEBUG_LEAKING_SCALARS" # endif # ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP " DEBUG_LEAKING_SCALARS_FORK_DUMP" # endif # ifdef FAKE_THREADS " FAKE_THREADS" # endif # ifdef FCRYPT " FCRYPT" # endif # ifdef HAS_TIMES " HAS_TIMES" # endif # ifdef HAVE_INTERP_INTERN " HAVE_INTERP_INTERN" # endif # ifdef MULTIPLICITY " MULTIPLICITY" # endif # ifdef MYMALLOC " MYMALLOC" # endif # ifdef PERLIO_LAYERS " PERLIO_LAYERS" # endif # ifdef PERL_DEBUG_READONLY_OPS " PERL_DEBUG_READONLY_OPS" # endif # ifdef PERL_GLOBAL_STRUCT " PERL_GLOBAL_STRUCT" # endif # ifdef PERL_IMPLICIT_CONTEXT " PERL_IMPLICIT_CONTEXT" # endif # ifdef PERL_IMPLICIT_SYS " PERL_IMPLICIT_SYS" # endif # ifdef PERL_MAD " PERL_MAD" # endif # ifdef PERL_MICRO " PERL_MICRO" # endif # ifdef PERL_NEED_APPCTX " PERL_NEED_APPCTX" # endif # ifdef PERL_NEED_TIMESBASE " PERL_NEED_TIMESBASE" # endif # ifdef PERL_OLD_COPY_ON_WRITE " PERL_OLD_COPY_ON_WRITE" # endif # ifdef PERL_POISON " PERL_POISON" # endif # ifdef PERL_TRACK_MEMPOOL " PERL_TRACK_MEMPOOL" # endif # ifdef PERL_USES_PL_PIDSTATUS " PERL_USES_PL_PIDSTATUS" # endif # ifdef PL_OP_SLAB_ALLOC " PL_OP_SLAB_ALLOC" # endif # ifdef USE_64_BIT_ALL " USE_64_BIT_ALL" # endif # ifdef USE_64_BIT_INT " USE_64_BIT_INT" # endif # ifdef USE_IEEE " USE_IEEE" # endif # ifdef USE_ITHREADS " USE_ITHREADS" # endif # ifdef USE_LARGE_FILES " USE_LARGE_FILES" # endif # ifdef USE_LOCALE_COLLATE " USE_LOCALE_COLLATE" # endif # ifdef USE_LOCALE_NUMERIC " USE_LOCALE_NUMERIC" # endif # ifdef USE_LONG_DOUBLE " USE_LONG_DOUBLE" # endif # ifdef USE_PERLIO " USE_PERLIO" # endif # ifdef USE_REENTRANT_API " USE_REENTRANT_API" # endif # ifdef USE_SFIO " USE_SFIO" # endif # ifdef USE_SOCKS " USE_SOCKS" # endif # ifdef VMS_DO_SOCKETS " VMS_DO_SOCKETS" # endif # ifdef VMS_SHORTEN_LONG_SYMBOLS " VMS_SHORTEN_LONG_SYMBOLS" # endif # ifdef VMS_WE_ARE_CASE_SENSITIVE " VMS_SYMBOL_CASE_AS_IS" # endif ""; #else EXTCONST char PL_bincompat_options[]; #endif #ifndef PERL_SET_PHASE # define PERL_SET_PHASE(new_phase) \ PHASE_CHANGE_PROBE(PL_phase_names[new_phase], PL_phase_names[PL_phase]); \ PL_phase = new_phase; #endif /* The interpreter phases. If these ever change, PL_phase_names right below will * need to be updated accordingly. */ enum perl_phase { PERL_PHASE_CONSTRUCT = 0, PERL_PHASE_START = 1, PERL_PHASE_CHECK = 2, PERL_PHASE_INIT = 3, PERL_PHASE_RUN = 4, PERL_PHASE_END = 5, PERL_PHASE_DESTRUCT = 6 }; #ifdef DOINIT EXTCONST char *const PL_phase_names[] = { "CONSTRUCT", "START", "CHECK", "INIT", "RUN", "END", "DESTRUCT" }; #else EXTCONST char *const PL_phase_names[]; #endif #ifndef PERL_CORE /* Do not use this macro. It only exists for extensions that rely on PL_dirty * instead of using the newer PL_phase, which provides everything PL_dirty * provided, and more. */ # define PL_dirty (PL_phase == PERL_PHASE_DESTRUCT) #endif /* !PERL_CORE */ END_EXTERN_C /*****************************************************************************/ /* This lexer/parser stuff is currently global since yacc is hard to reenter */ /*****************************************************************************/ /* XXX This needs to be revisited, since BEGIN makes yacc re-enter... */ #ifdef __Lynx__ /* LynxOS defines these in scsi.h which is included via ioctl.h */ #ifdef FORMAT #undef FORMAT #endif #ifdef SPACE #undef SPACE #endif #endif #define LEX_NOTPARSING 11 /* borrowed from toke.c */ typedef enum { XOPERATOR, XTERM, XREF, XSTATE, XBLOCK, XATTRBLOCK, XATTRTERM, XTERMBLOCK, XTERMORDORDOR /* evil hack */ /* update exp_name[] in toke.c if adding to this enum */ } expectation; /* Hints are now stored in a dedicated U32, so the bottom 8 bits are no longer special and there is no need for HINT_PRIVATE_MASK for COPs However, bitops store HINT_INTEGER in their op_private. */ #define HINT_INTEGER 0x00000001 /* integer pragma */ #define HINT_STRICT_REFS 0x00000002 /* strict pragma */ #define HINT_LOCALE 0x00000004 /* locale pragma */ #define HINT_BYTES 0x00000008 /* bytes pragma */ #define HINT_LOCALE_NOT_CHARS 0x00000010 /* locale ':not_characters' pragma */ #define HINT_EXPLICIT_STRICT_REFS 0x00000020 /* strict.pm */ #define HINT_EXPLICIT_STRICT_SUBS 0x00000040 /* strict.pm */ #define HINT_EXPLICIT_STRICT_VARS 0x00000080 /* strict.pm */ #define HINT_BLOCK_SCOPE 0x00000100 #define HINT_STRICT_SUBS 0x00000200 /* strict pragma */ #define HINT_STRICT_VARS 0x00000400 /* strict pragma */ #define HINT_UNI_8_BIT 0x00000800 /* unicode_strings feature */ /* The HINT_NEW_* constants are used by the overload pragma */ #define HINT_NEW_INTEGER 0x00001000 #define HINT_NEW_FLOAT 0x00002000 #define HINT_NEW_BINARY 0x00004000 #define HINT_NEW_STRING 0x00008000 #define HINT_NEW_RE 0x00010000 #define HINT_LOCALIZE_HH 0x00020000 /* %^H needs to be copied */ #define HINT_LEXICAL_IO_IN 0x00040000 /* ${^OPEN} is set for input */ #define HINT_LEXICAL_IO_OUT 0x00080000 /* ${^OPEN} is set for output */ #define HINT_RE_TAINT 0x00100000 /* re pragma */ #define HINT_RE_EVAL 0x00200000 /* re pragma */ #define HINT_FILETEST_ACCESS 0x00400000 /* filetest pragma */ #define HINT_UTF8 0x00800000 /* utf8 pragma */ #define HINT_NO_AMAGIC 0x01000000 /* overloading pragma */ #define HINT_RE_FLAGS 0x02000000 /* re '/xism' pragma */ #define HINT_FEATURE_MASK 0x1c000000 /* 3 bits for feature bundles */ /* Note: Used for NATIVE_HINTS, currently defined by vms/vmsish.h: 0x40000000 0x80000000 */ /* The following are stored in $^H{sort}, not in PL_hints */ #define HINT_SORT_SORT_BITS 0x000000FF /* allow 256 different ones */ #define HINT_SORT_QUICKSORT 0x00000001 #define HINT_SORT_MERGESORT 0x00000002 #define HINT_SORT_STABLE 0x00000100 /* sort styles (currently one) */ /* Various states of the input record separator SV (rs) */ #define RsSNARF(sv) (! SvOK(sv)) #define RsSIMPLE(sv) (SvOK(sv) && (! SvPOK(sv) || SvCUR(sv))) #define RsPARA(sv) (SvPOK(sv) && ! SvCUR(sv)) #define RsRECORD(sv) (SvROK(sv) && (SvIV(SvRV(sv)) > 0)) /* A struct for keeping various DEBUGGING related stuff, * neatly packed. Currently only scratch variables for * constructing debug output are included. Needed always, * not just when DEBUGGING, though, because of the re extension. c*/ struct perl_debug_pad { SV pad[3]; }; #define PERL_DEBUG_PAD(i) &(PL_debug_pad.pad[i]) #define PERL_DEBUG_PAD_ZERO(i) (SvPVX(PERL_DEBUG_PAD(i))[0] = 0, \ (((XPV*) SvANY(PERL_DEBUG_PAD(i)))->xpv_cur = 0), \ PERL_DEBUG_PAD(i)) /* Enable variables which are pointers to functions */ typedef void (*peep_t)(pTHX_ OP* o); typedef regexp* (*regcomp_t) (pTHX_ char* exp, char* xend, PMOP* pm); typedef I32 (*regexec_t) (pTHX_ regexp* prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, void* data, U32 flags); typedef char* (*re_intuit_start_t) (pTHX_ regexp *prog, SV *sv, char *strpos, char *strend, U32 flags, re_scream_pos_data *d); typedef SV* (*re_intuit_string_t) (pTHX_ regexp *prog); typedef void (*regfree_t) (pTHX_ struct regexp* r); typedef regexp* (*regdupe_t) (pTHX_ const regexp* r, CLONE_PARAMS *param); typedef I32 (*re_fold_t)(const char *, char const *, I32); typedef void (*DESTRUCTORFUNC_NOCONTEXT_t) (void*); typedef void (*DESTRUCTORFUNC_t) (pTHX_ void*); typedef void (*SVFUNC_t) (pTHX_ SV* const); typedef I32 (*SVCOMPARE_t) (pTHX_ SV* const, SV* const); typedef void (*XSINIT_t) (pTHX); typedef void (*ATEXIT_t) (pTHX_ void*); typedef void (*XSUBADDR_t) (pTHX_ CV *); typedef OP* (*Perl_ppaddr_t)(pTHX); typedef OP* (*Perl_check_t) (pTHX_ OP*); typedef void(*Perl_ophook_t)(pTHX_ OP*); typedef int (*Perl_keyword_plugin_t)(pTHX_ char*, STRLEN, OP**); typedef void(*Perl_cpeep_t)(pTHX_ OP *, OP *); typedef void(*globhook_t)(pTHX); #define KEYWORD_PLUGIN_DECLINE 0 #define KEYWORD_PLUGIN_STMT 1 #define KEYWORD_PLUGIN_EXPR 2 /* Interpreter exitlist entry */ typedef struct exitlistentry { void (*fn) (pTHX_ void*); void *ptr; } PerlExitListEntry; /* if you only have signal() and it resets on each signal, FAKE_PERSISTENT_SIGNAL_HANDLERS fixes */ /* These have to be before perlvars.h */ #if !defined(HAS_SIGACTION) && defined(VMS) # define FAKE_PERSISTENT_SIGNAL_HANDLERS #endif /* if we're doing kill() with sys$sigprc on VMS, FAKE_DEFAULT_SIGNAL_HANDLERS */ #if defined(KILL_BY_SIGPRC) # define FAKE_DEFAULT_SIGNAL_HANDLERS #endif #if !defined(MULTIPLICITY) struct interpreter { char broiled; }; #else /* If we have multiple interpreters define a struct holding variables which must be per-interpreter If we don't have threads anything that would have be per-thread is per-interpreter. */ /* Set up PERLVAR macros for populating structs */ # define PERLVAR(prefix,var,type) type prefix##var; # define PERLVARA(prefix,var,n,type) type prefix##var[n]; # define PERLVARI(prefix,var,type,init) type prefix##var; # define PERLVARIC(prefix,var,type,init) type prefix##var; struct interpreter { # include "intrpvar.h" }; EXTCONST U16 PL_interp_size INIT(sizeof(struct interpreter)); # define PERL_INTERPRETER_SIZE_UPTO_MEMBER(member) \ STRUCT_OFFSET(struct interpreter, member) + \ sizeof(((struct interpreter*)0)->member) /* This will be useful for subsequent releases, because this has to be the same in your libperl as in main(), else you have a mismatch and must abort. */ EXTCONST U16 PL_interp_size_5_16_0 INIT(PERL_INTERPRETER_SIZE_UPTO_MEMBER(PERL_LAST_5_16_0_INTERP_MEMBER)); # ifdef PERL_GLOBAL_STRUCT /* MULTIPLICITY is automatically defined when PERL_GLOBAL_STRUCT is defined, hence it's safe and sane to nest this within #ifdef MULTIPLICITY */ struct perl_vars { # include "perlvars.h" }; EXTCONST U16 PL_global_struct_size INIT(sizeof(struct perl_vars)); # ifdef PERL_CORE # ifndef PERL_GLOBAL_STRUCT_PRIVATE EXT struct perl_vars PL_Vars; EXT struct perl_vars *PL_VarsPtr INIT(&PL_Vars); # undef PERL_GET_VARS # define PERL_GET_VARS() PL_VarsPtr # endif /* !PERL_GLOBAL_STRUCT_PRIVATE */ # else /* PERL_CORE */ # if !defined(__GNUC__) || !defined(WIN32) EXT # endif /* WIN32 */ struct perl_vars *PL_VarsPtr; # define PL_Vars (*((PL_VarsPtr) \ ? PL_VarsPtr : (PL_VarsPtr = Perl_GetVars(aTHX)))) # endif /* PERL_CORE */ # endif /* PERL_GLOBAL_STRUCT */ /* Done with PERLVAR macros for now ... */ # undef PERLVAR # undef PERLVARA # undef PERLVARI # undef PERLVARIC #endif /* MULTIPLICITY */ struct tempsym; /* defined in pp_pack.c */ #include "thread.h" #include "pp.h" #ifndef PERL_CALLCONV # ifdef __cplusplus # define PERL_CALLCONV extern "C" # else # define PERL_CALLCONV # endif #endif #undef PERL_CKDEF #undef PERL_PPDEF #define PERL_CKDEF(s) PERL_CALLCONV OP *s (pTHX_ OP *o); #define PERL_PPDEF(s) PERL_CALLCONV OP *s (pTHX); #ifdef MYMALLOC # include "malloc_ctl.h" #endif #include "proto.h" /* this has structure inits, so it cannot be included before here */ #include "opcode.h" /* The following must follow proto.h as #defines mess up syntax */ #if !defined(PERL_FOR_X2P) # include "embedvar.h" #endif #ifndef PERL_MAD # undef PL_madskills # undef PL_xmlfp # define PL_madskills 0 # define PL_xmlfp 0 #endif /* Now include all the 'global' variables * If we don't have threads or multiple interpreters * these include variables that would have been their struct-s */ #define PERLVAR(prefix,var,type) EXT type PL_##var; #define PERLVARA(prefix,var,n,type) EXT type PL_##var[n]; #define PERLVARI(prefix,var,type,init) EXT type PL_##var INIT(init); #define PERLVARIC(prefix,var,type,init) EXTCONST type PL_##var INIT(init); #if !defined(MULTIPLICITY) START_EXTERN_C # include "intrpvar.h" END_EXTERN_C #endif #ifdef PERL_CORE /* All core uses now exterminated. Ensure no zombies can return: */ # undef PL_na #endif /* Now all the config stuff is setup we can include embed.h In particular, need the relevant *ish file included already, as it may define HAVE_INTERP_INTERN */ #include "embed.h" #ifndef PERL_MAD # undef op_getmad # define op_getmad(arg,pegop,slot) NOOP #endif #ifndef PERL_GLOBAL_STRUCT START_EXTERN_C # include "perlvars.h" END_EXTERN_C #endif #undef PERLVAR #undef PERLVARA #undef PERLVARI #undef PERLVARIC START_EXTERN_C /* dummy variables that hold pointers to both runops functions, thus forcing * them *both* to get linked in (useful for Peek.xs, debugging etc) */ EXTCONST runops_proc_t PL_runops_std INIT(Perl_runops_standard); EXTCONST runops_proc_t PL_runops_dbg INIT(Perl_runops_debug); /* PERL_GLOBAL_STRUCT_PRIVATE wants to keep global data like the * magic vtables const, but this is incompatible with SWIG which * does want to modify the vtables. */ #ifdef PERL_GLOBAL_STRUCT_PRIVATE # define EXT_MGVTBL EXTCONST MGVTBL #else # define EXT_MGVTBL EXT MGVTBL #endif #define PERL_MAGIC_READONLY_ACCEPTABLE 0x40 #define PERL_MAGIC_VALUE_MAGIC 0x80 #define PERL_MAGIC_VTABLE_MASK 0x3F #define PERL_MAGIC_TYPE_READONLY_ACCEPTABLE(t) \ (PL_magic_data[(U8)(t)] & PERL_MAGIC_READONLY_ACCEPTABLE) #define PERL_MAGIC_TYPE_IS_VALUE_MAGIC(t) \ (PL_magic_data[(U8)(t)] & PERL_MAGIC_VALUE_MAGIC) #include "mg_vtable.h" #ifdef DOINIT EXTCONST U8 PL_magic_data[256] = # ifdef PERL_MICRO # include "umg_data.h" # else # include "mg_data.h" # endif ; #else EXTCONST U8 PL_magic_data[256]; #endif #ifdef DOINIT /* NL BD IV NV PV PI PN MG RX GV LV AV HV CV FM IO */ EXTCONST bool PL_valid_types_IVX[] = { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0 }; EXTCONST bool PL_valid_types_NVX[] = { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0 }; EXTCONST bool PL_valid_types_PVX[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 }; EXTCONST bool PL_valid_types_RV[] = { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1 }; EXTCONST bool PL_valid_types_IV_set[] = { 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1 }; EXTCONST bool PL_valid_types_NV_set[] = { 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; #else EXTCONST bool PL_valid_types_IVX[]; EXTCONST bool PL_valid_types_NVX[]; EXTCONST bool PL_valid_types_PVX[]; EXTCONST bool PL_valid_types_RV[]; EXTCONST bool PL_valid_types_IV_set[]; EXTCONST bool PL_valid_types_NV_set[]; #endif #include "overload.h" END_EXTERN_C struct am_table { U8 flags; U8 fallback; U16 spare; U32 was_ok_sub; long was_ok_am; CV* table[NofAMmeth]; }; struct am_table_short { U8 flags; U8 fallback; U16 spare; U32 was_ok_sub; long was_ok_am; }; typedef struct am_table AMT; typedef struct am_table_short AMTS; #define AMGfallNEVER 1 #define AMGfallNO 2 #define AMGfallYES 3 #define AMTf_AMAGIC 1 #define AMTf_OVERLOADED 2 #define AMT_AMAGIC(amt) ((amt)->flags & AMTf_AMAGIC) #define AMT_AMAGIC_on(amt) ((amt)->flags |= AMTf_AMAGIC) #define AMT_AMAGIC_off(amt) ((amt)->flags &= ~AMTf_AMAGIC) #define AMT_OVERLOADED(amt) ((amt)->flags & AMTf_OVERLOADED) #define AMT_OVERLOADED_on(amt) ((amt)->flags |= AMTf_OVERLOADED) #define AMT_OVERLOADED_off(amt) ((amt)->flags &= ~AMTf_OVERLOADED) #define StashHANDLER(stash,meth) gv_handler((stash),CAT2(meth,_amg)) /* * some compilers like to redefine cos et alia as faster * (and less accurate?) versions called F_cos et cetera (Quidquid * latine dictum sit, altum viditur.) This trick collides with * the Perl overloading (amg). The following #defines fool both. */ #ifdef _FASTMATH # ifdef atan2 # define F_atan2_amg atan2_amg # endif # ifdef cos # define F_cos_amg cos_amg # endif # ifdef exp # define F_exp_amg exp_amg # endif # ifdef log # define F_log_amg log_amg # endif # ifdef pow # define F_pow_amg pow_amg # endif # ifdef sin # define F_sin_amg sin_amg # endif # ifdef sqrt # define F_sqrt_amg sqrt_amg # endif #endif /* _FASTMATH */ #define PERLDB_ALL (PERLDBf_SUB | PERLDBf_LINE | \ PERLDBf_NOOPT | PERLDBf_INTER | \ PERLDBf_SUBLINE| PERLDBf_SINGLE| \ PERLDBf_NAMEEVAL| PERLDBf_NAMEANON | \ PERLDBf_SAVESRC) /* No _NONAME, _GOTO */ #define PERLDBf_SUB 0x01 /* Debug sub enter/exit */ #define PERLDBf_LINE 0x02 /* Keep line # */ #define PERLDBf_NOOPT 0x04 /* Switch off optimizations */ #define PERLDBf_INTER 0x08 /* Preserve more data for later inspections */ #define PERLDBf_SUBLINE 0x10 /* Keep subr source lines */ #define PERLDBf_SINGLE 0x20 /* Start with single-step on */ #define PERLDBf_NONAME 0x40 /* For _SUB: no name of the subr */ #define PERLDBf_GOTO 0x80 /* Report goto: call DB::goto */ #define PERLDBf_NAMEEVAL 0x100 /* Informative names for evals */ #define PERLDBf_NAMEANON 0x200 /* Informative names for anon subs */ #define PERLDBf_SAVESRC 0x400 /* Save source lines into @{"_<$filename"} */ #define PERLDBf_SAVESRC_NOSUBS 0x800 /* Including evals that generate no subroutines */ #define PERLDBf_SAVESRC_INVALID 0x1000 /* Save source that did not compile */ #define PERLDB_SUB (PL_perldb && (PL_perldb & PERLDBf_SUB)) #define PERLDB_LINE (PL_perldb && (PL_perldb & PERLDBf_LINE)) #define PERLDB_NOOPT (PL_perldb && (PL_perldb & PERLDBf_NOOPT)) #define PERLDB_INTER (PL_perldb && (PL_perldb & PERLDBf_INTER)) #define PERLDB_SUBLINE (PL_perldb && (PL_perldb & PERLDBf_SUBLINE)) #define PERLDB_SINGLE (PL_perldb && (PL_perldb & PERLDBf_SINGLE)) #define PERLDB_SUB_NN (PL_perldb && (PL_perldb & (PERLDBf_NONAME))) #define PERLDB_GOTO (PL_perldb && (PL_perldb & PERLDBf_GOTO)) #define PERLDB_NAMEEVAL (PL_perldb && (PL_perldb & PERLDBf_NAMEEVAL)) #define PERLDB_NAMEANON (PL_perldb && (PL_perldb & PERLDBf_NAMEANON)) #define PERLDB_SAVESRC (PL_perldb && (PL_perldb & PERLDBf_SAVESRC)) #define PERLDB_SAVESRC_NOSUBS (PL_perldb && (PL_perldb & PERLDBf_SAVESRC_NOSUBS)) #define PERLDB_SAVESRC_INVALID (PL_perldb && (PL_perldb & PERLDBf_SAVESRC_INVALID)) #ifdef USE_LOCALE_NUMERIC #define SET_NUMERIC_STANDARD() \ set_numeric_standard(); #define SET_NUMERIC_LOCAL() \ set_numeric_local(); /* Returns non-zero If the plain locale pragma without a parameter is in effect */ #define IN_LOCALE_RUNTIME (CopHINTS_get(PL_curcop) & HINT_LOCALE) /* Returns non-zero If either form of the locale pragma is in effect */ #define IN_SOME_LOCALE_FORM_RUNTIME \ (CopHINTS_get(PL_curcop) & (HINT_LOCALE|HINT_LOCALE_NOT_CHARS)) #define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) #define IN_SOME_LOCALE_FORM_COMPILETIME \ (PL_hints & (HINT_LOCALE|HINT_LOCALE_NOT_CHARS)) #define IN_LOCALE \ (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) #define IN_SOME_LOCALE_FORM \ (IN_PERL_COMPILETIME ? IN_SOME_LOCALE_FORM_COMPILETIME \ : IN_SOME_LOCALE_FORM_RUNTIME) #define STORE_NUMERIC_LOCAL_SET_STANDARD() \ bool was_local = PL_numeric_local && IN_LOCALE; \ if (was_local) SET_NUMERIC_STANDARD(); #define STORE_NUMERIC_STANDARD_SET_LOCAL() \ bool was_standard = PL_numeric_standard && IN_LOCALE; \ if (was_standard) SET_NUMERIC_LOCAL(); #define RESTORE_NUMERIC_LOCAL() \ if (was_local) SET_NUMERIC_LOCAL(); #define RESTORE_NUMERIC_STANDARD() \ if (was_standard) SET_NUMERIC_STANDARD(); #define Atof my_atof #else /* !USE_LOCALE_NUMERIC */ #define SET_NUMERIC_STANDARD() /**/ #define SET_NUMERIC_LOCAL() /**/ #define IS_NUMERIC_RADIX(a, b) (0) #define STORE_NUMERIC_LOCAL_SET_STANDARD() /**/ #define STORE_NUMERIC_STANDARD_SET_LOCAL() /**/ #define RESTORE_NUMERIC_LOCAL() /**/ #define RESTORE_NUMERIC_STANDARD() /**/ #define Atof my_atof #define IN_LOCALE_RUNTIME 0 #endif /* !USE_LOCALE_NUMERIC */ #if !defined(Strtol) && defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG # ifdef __hpux # define strtoll __strtoll /* secret handshake */ # endif # ifdef WIN64 # define strtoll _strtoi64 /* secret handshake */ # endif # if !defined(Strtol) && defined(HAS_STRTOLL) # define Strtol strtoll # endif # if !defined(Strtol) && defined(HAS_STRTOQ) # define Strtol strtoq # endif /* is there atoq() anywhere? */ #endif #if !defined(Strtol) && defined(HAS_STRTOL) # define Strtol strtol #endif #ifndef Atol /* It would be more fashionable to use Strtol() to define atol() * (as is done for Atoul(), see below) but for backward compatibility * we just assume atol(). */ # if defined(USE_64_BIT_INT) && defined(IV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG && defined(HAS_ATOLL) # ifdef WIN64 # define atoll _atoi64 /* secret handshake */ # endif # define Atol atoll # else # define Atol atol # endif #endif #if !defined(Strtoul) && defined(USE_64_BIT_INT) && defined(UV_IS_QUAD) && QUADKIND == QUAD_IS_LONG_LONG # ifdef __hpux # define strtoull __strtoull /* secret handshake */ # endif # ifdef WIN64 # define strtoull _strtoui64 /* secret handshake */ # endif # if !defined(Strtoul) && defined(HAS_STRTOULL) # define Strtoul strtoull # endif # if !defined(Strtoul) && defined(HAS_STRTOUQ) # define Strtoul strtouq # endif /* is there atouq() anywhere? */ #endif #if !defined(Strtoul) && defined(HAS_STRTOUL) # define Strtoul strtoul #endif #if !defined(Strtoul) && defined(HAS_STRTOL) /* Last resort. */ # define Strtoul(s, e, b) strchr((s), '-') ? ULONG_MAX : (unsigned long)strtol((s), (e), (b)) #endif #ifndef Atoul # define Atoul(s) Strtoul(s, NULL, 10) #endif /* if these never got defined, they need defaults */ #ifndef PERL_SET_CONTEXT # define PERL_SET_CONTEXT(i) PERL_SET_INTERP(i) #endif #ifndef PERL_GET_CONTEXT # define PERL_GET_CONTEXT PERL_GET_INTERP #endif #ifndef PERL_GET_THX # define PERL_GET_THX ((void*)NULL) #endif #ifndef PERL_SET_THX # define PERL_SET_THX(t) NOOP #endif #ifndef PERL_SCRIPT_MODE #define PERL_SCRIPT_MODE "r" #endif /* * Some operating systems are stingy with stack allocation, * so perl may have to guard against stack overflow. */ #ifndef PERL_STACK_OVERFLOW_CHECK #define PERL_STACK_OVERFLOW_CHECK() NOOP #endif /* * Some nonpreemptive operating systems find it convenient to * check for asynchronous conditions after each op execution. * Keep this check simple, or it may slow down execution * massively. */ #ifndef PERL_MICRO # ifndef PERL_ASYNC_CHECK # define PERL_ASYNC_CHECK() if (PL_sig_pending) PL_signalhook(aTHX) # endif #endif #ifndef PERL_ASYNC_CHECK # define PERL_ASYNC_CHECK() NOOP #endif /* * On some operating systems, a memory allocation may succeed, * but put the process too close to the system's comfort limit. * In this case, PERL_ALLOC_CHECK frees the pointer and sets * it to NULL. */ #ifndef PERL_ALLOC_CHECK #define PERL_ALLOC_CHECK(p) NOOP #endif #ifdef HAS_SEM # include # include # ifndef HAS_UNION_SEMUN /* Provide the union semun. */ union semun { int val; struct semid_ds *buf; unsigned short *array; }; # endif # ifdef USE_SEMCTL_SEMUN # ifdef IRIX32_SEMUN_BROKEN_BY_GCC union gccbug_semun { int val; struct semid_ds *buf; unsigned short *array; char __dummy[5]; }; # define semun gccbug_semun # endif # define Semctl(id, num, cmd, semun) semctl(id, num, cmd, semun) # else # ifdef USE_SEMCTL_SEMID_DS # ifdef EXTRA_F_IN_SEMUN_BUF # define Semctl(id, num, cmd, semun) semctl(id, num, cmd, semun.buff) # else # define Semctl(id, num, cmd, semun) semctl(id, num, cmd, semun.buf) # endif # endif # endif #endif /* * Boilerplate macros for initializing and accessing interpreter-local * data from C. All statics in extensions should be reworked to use * this, if you want to make the extension thread-safe. See * ext/XS/APItest/APItest.xs for an example of the use of these macros, * and perlxs.pod for more. * * Code that uses these macros is responsible for the following: * 1. #define MY_CXT_KEY to a unique string, e.g. * "DynaLoader::_guts" XS_VERSION * XXX in the current implementation, this string is ignored. * 2. Declare a typedef named my_cxt_t that is a structure that contains * all the data that needs to be interpreter-local. * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. * 4. Use the MY_CXT_INIT macro such that it is called exactly once * (typically put in the BOOT: section). * 5. Use the members of the my_cxt_t structure everywhere as * MY_CXT.member. * 6. Use the dMY_CXT macro (a declaration) in all the functions that * access MY_CXT. */ #if defined(PERL_IMPLICIT_CONTEXT) /* START_MY_CXT must appear in all extensions that define a my_cxt_t structure, * right after the definition (i.e. at file scope). The non-threads * case below uses it to declare the data as static. */ # ifdef PERL_GLOBAL_STRUCT_PRIVATE # define START_MY_CXT # define MY_CXT_INDEX Perl_my_cxt_index(aTHX_ MY_CXT_KEY) # define MY_CXT_INIT_ARG MY_CXT_KEY # else # define START_MY_CXT static int my_cxt_index = -1; # define MY_CXT_INDEX my_cxt_index # define MY_CXT_INIT_ARG &my_cxt_index # endif /* #ifdef PERL_GLOBAL_STRUCT_PRIVATE */ /* Creates and zeroes the per-interpreter data. * (We allocate my_cxtp in a Perl SV so that it will be released when * the interpreter goes away.) */ # define MY_CXT_INIT \ my_cxt_t *my_cxtp = \ (my_cxt_t*)Perl_my_cxt_init(aTHX_ MY_CXT_INIT_ARG, sizeof(my_cxt_t)); \ PERL_UNUSED_VAR(my_cxtp) # define MY_CXT_INIT_INTERP(my_perl) \ my_cxt_t *my_cxtp = \ (my_cxt_t*)Perl_my_cxt_init(my_perl, MY_CXT_INIT_ARG, sizeof(my_cxt_t)); \ PERL_UNUSED_VAR(my_cxtp) /* This declaration should be used within all functions that use the * interpreter-local data. */ # define dMY_CXT \ my_cxt_t *my_cxtp = (my_cxt_t *)PL_my_cxt_list[MY_CXT_INDEX] # define dMY_CXT_INTERP(my_perl) \ my_cxt_t *my_cxtp = (my_cxt_t *)(my_perl)->Imy_cxt_list[MY_CXT_INDEX] /* Clones the per-interpreter data. */ # define MY_CXT_CLONE \ my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ Copy(PL_my_cxt_list[MY_CXT_INDEX], my_cxtp, 1, my_cxt_t);\ PL_my_cxt_list[MY_CXT_INDEX] = my_cxtp \ /* This macro must be used to access members of the my_cxt_t structure. * e.g. MY_CXT.some_data */ # define MY_CXT (*my_cxtp) /* Judicious use of these macros can reduce the number of times dMY_CXT * is used. Use is similar to pTHX, aTHX etc. */ # define pMY_CXT my_cxt_t *my_cxtp # define pMY_CXT_ pMY_CXT, # define _pMY_CXT ,pMY_CXT # define aMY_CXT my_cxtp # define aMY_CXT_ aMY_CXT, # define _aMY_CXT ,aMY_CXT #else /* PERL_IMPLICIT_CONTEXT */ # define START_MY_CXT static my_cxt_t my_cxt; # define dMY_CXT_SV dNOOP # define dMY_CXT dNOOP # define dMY_CXT_INTERP(my_perl) dNOOP # define MY_CXT_INIT NOOP # define MY_CXT_CLONE NOOP # define MY_CXT my_cxt # define pMY_CXT void # define pMY_CXT_ # define _pMY_CXT # define aMY_CXT # define aMY_CXT_ # define _aMY_CXT #endif /* !defined(PERL_IMPLICIT_CONTEXT) */ #ifdef I_FCNTL # include #endif #ifdef __Lynx__ # include #endif #ifdef I_SYS_FILE # include #endif #if defined(HAS_FLOCK) && !defined(HAS_FLOCK_PROTO) int flock(int fd, int op); #endif #ifndef O_RDONLY /* Assume UNIX defaults */ # define O_RDONLY 0000 # define O_WRONLY 0001 # define O_RDWR 0002 # define O_CREAT 0100 #endif #ifndef O_BINARY # define O_BINARY 0 #endif #ifndef O_TEXT # define O_TEXT 0 #endif #if O_TEXT != O_BINARY /* If you have different O_TEXT and O_BINARY and you are a CLRF shop, * that is, you are somehow DOSish. */ # if defined(__BEOS__) || defined(__HAIKU__) || defined(__VOS__) || \ defined(__CYGWIN__) /* BeOS/Haiku has O_TEXT != O_BINARY but O_TEXT and O_BINARY have no effect; * BeOS/Haiku is always UNIXoid (LF), not DOSish (CRLF). */ /* VOS has O_TEXT != O_BINARY, and they have effect, * but VOS always uses LF, never CRLF. */ /* If you have O_TEXT different from your O_BINARY but you still are * not a CRLF shop. */ # undef PERLIO_USING_CRLF # else /* If you really are DOSish. */ # define PERLIO_USING_CRLF 1 # endif #endif #ifdef I_LIBUTIL # include /* setproctitle() in some FreeBSDs */ #endif #ifndef EXEC_ARGV_CAST #define EXEC_ARGV_CAST(x) (char **)x #endif #define IS_NUMBER_IN_UV 0x01 /* number within UV range (maybe not int). value returned in pointed- to UV */ #define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 /* pointed to UV undefined */ #define IS_NUMBER_NOT_INT 0x04 /* saw . or E notation */ #define IS_NUMBER_NEG 0x08 /* leading minus sign */ #define IS_NUMBER_INFINITY 0x10 /* this is big */ #define IS_NUMBER_NAN 0x20 /* this is not */ #define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) /* Input flags: */ #define PERL_SCAN_ALLOW_UNDERSCORES 0x01 /* grok_??? accept _ in numbers */ #define PERL_SCAN_DISALLOW_PREFIX 0x02 /* grok_??? reject 0x in hex etc */ #define PERL_SCAN_SILENT_ILLDIGIT 0x04 /* grok_??? not warn about illegal digits */ #define PERL_SCAN_SILENT_NON_PORTABLE 0x08 /* grok_??? not warn about very large numbers which are <= UV_MAX */ /* Output flags: */ #define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 /* should this merge with above? */ /* to let user control profiling */ #ifdef PERL_GPROF_CONTROL extern void moncontrol(int); #define PERL_GPROF_MONCONTROL(x) moncontrol(x) #else #define PERL_GPROF_MONCONTROL(x) #endif #ifdef UNDER_CE #include "wince.h" #endif /* ISO 6429 NEL - C1 control NExt Line */ /* See http://www.unicode.org/unicode/reports/tr13/ */ #ifdef EBCDIC /* In EBCDIC NEL is just an alias for LF */ # if '^' == 95 /* CP 1047: MVS OpenEdition - OS/390 - z/OS */ # define NEXT_LINE_CHAR 0x15 # else /* CDRA */ # define NEXT_LINE_CHAR 0x25 # endif #else # define NEXT_LINE_CHAR 0x85 #endif /* The UTF-8 bytes of the Unicode LS and PS, U+2028 and U+2029 */ #define UNICODE_LINE_SEPA_0 0xE2 #define UNICODE_LINE_SEPA_1 0x80 #define UNICODE_LINE_SEPA_2 0xA8 #define UNICODE_PARA_SEPA_0 0xE2 #define UNICODE_PARA_SEPA_1 0x80 #define UNICODE_PARA_SEPA_2 0xA9 #ifndef PIPESOCK_MODE # define PIPESOCK_MODE #endif #ifndef SOCKET_OPEN_MODE # define SOCKET_OPEN_MODE PIPESOCK_MODE #endif #ifndef PIPE_OPEN_MODE # define PIPE_OPEN_MODE PIPESOCK_MODE #endif #define PERL_MAGIC_UTF8_CACHESIZE 2 #define PERL_UNICODE_STDIN_FLAG 0x0001 #define PERL_UNICODE_STDOUT_FLAG 0x0002 #define PERL_UNICODE_STDERR_FLAG 0x0004 #define PERL_UNICODE_IN_FLAG 0x0008 #define PERL_UNICODE_OUT_FLAG 0x0010 #define PERL_UNICODE_ARGV_FLAG 0x0020 #define PERL_UNICODE_LOCALE_FLAG 0x0040 #define PERL_UNICODE_WIDESYSCALLS_FLAG 0x0080 /* for Sarathy */ #define PERL_UNICODE_UTF8CACHEASSERT_FLAG 0x0100 #define PERL_UNICODE_STD_FLAG \ (PERL_UNICODE_STDIN_FLAG | \ PERL_UNICODE_STDOUT_FLAG | \ PERL_UNICODE_STDERR_FLAG) #define PERL_UNICODE_INOUT_FLAG \ (PERL_UNICODE_IN_FLAG | \ PERL_UNICODE_OUT_FLAG) #define PERL_UNICODE_DEFAULT_FLAGS \ (PERL_UNICODE_STD_FLAG | \ PERL_UNICODE_INOUT_FLAG | \ PERL_UNICODE_LOCALE_FLAG) #define PERL_UNICODE_ALL_FLAGS 0x01ff #define PERL_UNICODE_STDIN 'I' #define PERL_UNICODE_STDOUT 'O' #define PERL_UNICODE_STDERR 'E' #define PERL_UNICODE_STD 'S' #define PERL_UNICODE_IN 'i' #define PERL_UNICODE_OUT 'o' #define PERL_UNICODE_INOUT 'D' #define PERL_UNICODE_ARGV 'A' #define PERL_UNICODE_LOCALE 'L' #define PERL_UNICODE_WIDESYSCALLS 'W' #define PERL_UNICODE_UTF8CACHEASSERT 'a' #define PERL_SIGNALS_UNSAFE_FLAG 0x0001 /* Use instead of abs() since abs() forces its argument to be an int, * but also beware since this evaluates its argument twice, so no x++. */ #define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) #if defined(__DECC) && defined(__osf__) #pragma message disable (mainparm) /* Perl uses the envp in main(). */ #endif #define do_open(g, n, l, a, rm, rp, sf) \ do_openn(g, n, l, a, rm, rp, sf, (SV **) NULL, 0) #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION # define do_exec(cmd) do_exec3(cmd,0,0) #endif #ifdef OS2 # define do_aexec Perl_do_aexec #else # define do_aexec(really, mark,sp) do_aexec5(really, mark, sp, 0, 0) #endif #if defined(OEMVS) #define NO_ENV_ARRAY_IN_MAIN #endif /* These are used by Perl_pv_escape() and Perl_pv_pretty() * are here so that they are available throughout the core * NOTE that even though some are for _escape and some for _pretty * there must not be any clashes as the flags from _pretty are * passed straight through to _escape. */ #define PERL_PV_ESCAPE_QUOTE 0x0001 #define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE #define PERL_PV_PRETTY_ELLIPSES 0x0002 #define PERL_PV_PRETTY_LTGT 0x0004 #define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 #define PERL_PV_ESCAPE_UNI 0x0100 #define PERL_PV_ESCAPE_UNI_DETECT 0x0200 #define PERL_PV_ESCAPE_NONASCII 0x0400 #define PERL_PV_ESCAPE_ALL 0x1000 #define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 #define PERL_PV_ESCAPE_NOCLEAR 0x4000 #define PERL_PV_ESCAPE_RE 0x8000 #define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR /* used by pv_display in dump.c*/ #define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE #define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII /* (KEEP THIS LAST IN perl.h!) Mention NV_PRESERVES_UV HAS_MKSTEMP HAS_MKSTEMPS HAS_MKDTEMP HAS_GETCWD HAS_MMAP HAS_MPROTECT HAS_MSYNC HAS_MADVISE HAS_MUNMAP I_SYSMMAN Mmap_t NVef NVff NVgf HAS_UALARM HAS_USLEEP HAS_SETITIMER HAS_GETITIMER HAS_SENDMSG HAS_RECVMSG HAS_READV HAS_WRITEV I_SYSUIO HAS_STRUCT_MSGHDR HAS_STRUCT_CMSGHDR HAS_NL_LANGINFO HAS_DIRFD so that Configure picks them up. (KEEP THIS LAST IN perl.h!) */ #endif /* Include guard */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ$ll intrpvar.hnuW+A/* intrpvar.h * * Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, * 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* =head1 Per-Interpreter Variables */ /* These variables are per-interpreter in threaded/multiplicity builds, * global otherwise. * Don't forget to re-run regen/embed.pl to propagate changes! */ /* New variables must be added to the very end for binary compatibility. */ /* Don't forget to add your variable also to perl_clone()! (in sv.c) */ /* The 'I' prefix is only needed for vars that need appropriate #defines * generated when built with or without MULTIPLICITY. It is also used * to generate the appropriate export list for win32. If the variable * needs to be initialized, use PERLVARI. * * When building without MULTIPLICITY, these variables will be truly global. * * Important ones in the first cache line (if alignment is done right) */ PERLVAR(I, stack_sp, SV **) /* top of the stack */ #ifdef OP_IN_REGISTER PERLVAR(I, opsave, OP *) #else PERLVAR(I, op, OP *) /* currently executing op */ #endif PERLVAR(I, curpad, SV **) /* active pad (lexicals+tmps) */ PERLVAR(I, stack_base, SV **) PERLVAR(I, stack_max, SV **) PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */ /* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be present always, as -DDEUBGGING must be binary compatible with non. */ PERLVARI(I, scopestack_name, const char * *, NULL) PERLVAR(I, scopestack_ix, I32) PERLVAR(I, scopestack_max, I32) PERLVAR(I, savestack, ANY *) /* items that need to be restored when LEAVEing scopes we've ENTERed */ PERLVAR(I, savestack_ix, I32) PERLVAR(I, savestack_max, I32) PERLVAR(I, tmps_stack, SV **) /* mortals we've made */ PERLVARI(I, tmps_ix, I32, -1) PERLVARI(I, tmps_floor, I32, -1) PERLVAR(I, tmps_max, I32) PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in assignment? */ PERLVAR(I, markstack, I32 *) /* stack_sp locations we're remembering */ PERLVAR(I, markstack_ptr, I32 *) PERLVAR(I, markstack_max, I32 *) PERLVAR(I, Sv, SV *) /* used to hold temporary values */ PERLVAR(I, Xpv, XPV *) /* used to hold temporary values */ /* =for apidoc Amn|STRLEN|PL_na A convenience variable which is typically used with C when one doesn't care about the length of the string. It is usually more efficient to either declare a local variable and use that instead or to use the C macro. =cut */ PERLVAR(I, na, STRLEN) /* for use in SvPV when length is Not Applicable */ /* stat stuff */ PERLVAR(I, statbuf, Stat_t) PERLVAR(I, statcache, Stat_t) /* _ */ PERLVAR(I, statgv, GV *) PERLVARI(I, statname, SV *, NULL) #ifdef HAS_TIMES PERLVAR(I, timesbuf, struct tms) #endif /* Fields used by magic variables such as $@, $/ and so on */ PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */ /* =for apidoc mn|SV*|PL_rs The input record separator - C<$/> in Perl space. =for apidoc mn|GV*|PL_last_in_gv The GV which was last used for a filehandle input operation. (C<< >>) =for apidoc mn|GV*|PL_ofsgv The glob containing the output field separator - C<*,> in Perl space. =cut */ PERLVAR(I, rs, SV *) /* input record separator $/ */ PERLVAR(I, last_in_gv, GV *) /* GV used in last */ PERLVAR(I, ofsgv, GV *) /* GV of output field separator *, */ PERLVAR(I, defoutgv, GV *) /* default FH for output */ PERLVARI(I, chopset, const char *, " \n-") /* $: */ PERLVAR(I, formtarget, SV *) PERLVAR(I, bodytarget, SV *) PERLVAR(I, toptarget, SV *) /* Stashes */ PERLVAR(I, defstash, HV *) /* main symbol table */ PERLVAR(I, curstash, HV *) /* symbol table for current package */ PERLVAR(I, restartop, OP *) /* propagating an error from croak? */ PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */ PERLVAR(I, curcop, COP *) PERLVAR(I, curstack, AV *) /* THE STACK */ PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */ PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is happening */ PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */ PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */ PERLVARI(I, errors, SV *, NULL) /* outstanding queued errors */ /* statics "owned" by various functions */ PERLVAR(I, hv_fetch_ent_mh, HE*) /* owned by hv_fetch_ent() */ PERLVAR(I, lastgotoprobe, OP*) /* from pp_ctl.c */ /* sort stuff */ PERLVAR(I, sortcop, OP *) /* user defined sort routine */ PERLVAR(I, sortstash, HV *) /* which is in some package or other */ PERLVAR(I, firstgv, GV *) /* $a */ PERLVAR(I, secondgv, GV *) /* $b */ /* float buffer */ PERLVAR(I, efloatbuf, char *) PERLVAR(I, efloatsize, STRLEN) /* regex stuff */ PERLVAR(I, reg_state, struct re_save_state) PERLVAR(I, regdummy, regnode) /* from regcomp.c */ PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump indentation level */ PERLVAR(I, utf8locale, bool) /* utf8 locale detected */ PERLVARI(I, rehash_seed_set, bool, FALSE) /* 582 hash initialized? */ PERLVARA(I, colors,6, char *) /* from regcomp.c */ /* =for apidoc Amn|peep_t|PL_peepp Pointer to the per-subroutine peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each subroutine that is compiled, and is passed, as sole parameter, a pointer to the op that is the entry point to the subroutine. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate on ops throughout the subroutine's structure, rather than just at the top level, it is likely to be more convenient to wrap the L hook. =cut */ PERLVARI(I, peepp, peep_t, Perl_peep) /* =for apidoc Amn|peep_t|PL_rpeepp Pointer to the recursive peephole optimiser. This is a function that gets called at the end of compilation of a Perl subroutine (or equivalently independent piece of Perl code) to perform fixups of some ops and to perform small-scale optimisations. The function is called once for each chain of ops linked through their C fields; it is recursively called to handle each side chain. It is passed, as sole parameter, a pointer to the op that is at the head of the chain. It modifies the op tree in place. The peephole optimiser should never be completely replaced. Rather, add code to it by wrapping the existing optimiser. The basic way to do this can be seen in L. If the new code wishes to operate only on ops at a subroutine's top level, rather than throughout the structure, it is likely to be more convenient to wrap the L hook. =cut */ PERLVARI(I, rpeepp, peep_t, Perl_rpeep) /* =for apidoc Amn|Perl_ophook_t|PL_opfreehook When non-C, the function pointed by this variable will be called each time an OP is freed with the corresponding OP as the argument. This allows extensions to free any extra attribute they have locally attached to an OP. It is also assured to first fire for the parent OP and then for its kids. When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own. =cut */ PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */ PERLVARI(I, watchaddr, char **, 0) PERLVAR(I, watchok, char *) /* the currently active slab in a chain of slabs of regmatch states, * and the currently active state within that slab */ PERLVARI(I, regmatch_slab, regmatch_slab *, NULL) PERLVAR(I, regmatch_state, regmatch_state *) /* Put anything new that is pointer aligned here. */ PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */ PERLVAR(I, localizing, U8) /* are we processing a local() list? */ PERLVAR(I, colorset, bool) /* from regcomp.c */ PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */ PERLVAR(I, tainted, bool) /* using variables controlled by $< */ PERLVAR(I, tainting, bool) /* doing taint checks */ /* This value may be set when embedding for full cleanup */ /* 0=none, 1=full, 2=full with checks */ /* mod_perl is special, and also assigns a meaning -1 */ PERLVARI(I, perl_destruct_level, signed char, 0) /* current phase the interpreter is in */ PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT) PERLVAR(I, perldb, U32) PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */ /* pseudo environmental stuff */ PERLVAR(I, origargc, int) PERLVAR(I, origargv, char **) PERLVAR(I, envgv, GV *) PERLVAR(I, incgv, GV *) PERLVAR(I, hintgv, GV *) PERLVAR(I, origfilename, char *) PERLVAR(I, diehook, SV *) PERLVAR(I, warnhook, SV *) /* switches */ PERLVAR(I, patchlevel, SV *) PERLVAR(I, apiversion, SV *) PERLVAR(I, localpatches, const char * const *) PERLVARI(I, splitstr, const char *, " ") PERLVAR(I, minus_c, bool) PERLVAR(I, minus_n, bool) PERLVAR(I, minus_p, bool) PERLVAR(I, minus_l, bool) PERLVAR(I, minus_a, bool) PERLVAR(I, minus_F, bool) PERLVAR(I, doswitches, bool) PERLVAR(I, minus_E, bool) /* =for apidoc mn|bool|PL_dowarn The C variable which corresponds to Perl's $^W warning variable. =cut */ PERLVAR(I, dowarn, U8) PERLVAR(I, sawampersand, bool) /* must save all match strings */ PERLVAR(I, unsafe, bool) PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */ PERLVARI(I, reginterp_cnt, I32, 0) /* Whether "Regexp" was interpolated. */ PERLVAR(I, inplace, char *) PERLVAR(I, e_script, SV *) /* magical thingies */ PERLVAR(I, basetime, Time_t) /* $^T */ PERLVAR(I, formfeed, SV *) /* $^L */ PERLVARI(I, maxsysfd, I32, MAXSYSFD) /* top fd to pass to subprocesses */ PERLVAR(I, statusvalue, I32) /* $? */ #ifdef VMS PERLVAR(I, statusvalue_vms, U32) #else PERLVAR(I, statusvalue_posix, I32) #endif PERLVARI(I, sig_pending, int, 0) /* Number if highest signal pending */ PERLVAR(I, psig_pend, int *) /* per-signal "count" of pending */ /* shortcuts to various I/O objects */ PERLVAR(I, stdingv, GV *) /* *STDIN */ PERLVAR(I, stderrgv, GV *) /* *STDERR */ PERLVAR(I, defgv, GV *) PERLVAR(I, argvgv, GV *) /* *ARGV */ PERLVAR(I, argvoutgv, GV *) /* *ARGVOUT */ PERLVAR(I, argvout_stack, AV *) /* shortcuts to regexp stuff */ PERLVAR(I, replgv, GV *) /* *^R */ /* shortcuts to misc objects */ PERLVAR(I, errgv, GV *) /* *@ */ /* shortcuts to debugging objects */ PERLVAR(I, DBgv, GV *) /* *DB::DB */ PERLVAR(I, DBline, GV *) /* *DB::line */ /* =for apidoc mn|GV *|PL_DBsub When Perl is run in debugging mode, with the B<-d> switch, this GV contains the SV which holds the name of the sub being debugged. This is the C variable which corresponds to Perl's $DB::sub variable. See C. =for apidoc mn|SV *|PL_DBsingle When Perl is run in debugging mode, with the B<-d> switch, this SV is a boolean which indicates whether subs are being single-stepped. Single-stepping is automatically turned on after every step. This is the C variable which corresponds to Perl's $DB::single variable. See C. =for apidoc mn|SV *|PL_DBtrace Trace variable used when Perl is run in debugging mode, with the B<-d> switch. This is the C variable which corresponds to Perl's $DB::trace variable. See C. =cut */ PERLVAR(I, DBsub, GV *) /* *DB::sub */ PERLVAR(I, DBsingle, SV *) /* $DB::single */ PERLVAR(I, DBtrace, SV *) /* $DB::trace */ PERLVAR(I, DBsignal, SV *) /* $DB::signal */ PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */ /* symbol tables */ PERLVAR(I, debstash, HV *) /* symbol table for perldb package */ PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */ PERLVAR(I, curstname, SV *) /* name of current package */ PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */ PERLVAR(I, endav, AV *) /* names of END subroutines */ PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */ PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */ PERLVAR(I, initav, AV *) /* names of INIT subroutines */ PERLVAR(I, strtab, HV *) /* shared string table */ PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */ /* funky return mechanisms */ PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */ /* memory management */ PERLVAR(I, sv_count, I32) /* how many SV* are currently allocated */ PERLVAR(I, sv_objcount, I32) /* how many objects are currently allocated */ PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */ PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */ /* subprocess state */ PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */ /* internal state */ PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */ /* current interpreter roots */ PERLVAR(I, main_cv, CV *) PERLVAR(I, main_root, OP *) PERLVAR(I, main_start, OP *) PERLVAR(I, eval_root, OP *) PERLVAR(I, eval_start, OP *) /* runtime control stuff */ PERLVARI(I, curcopdb, COP *, NULL) PERLVAR(I, filemode, int) /* so nextargv() can preserve mode */ PERLVAR(I, lastfd, int) /* what to preserve mode on */ PERLVAR(I, oldname, char *) /* what to preserve mode on */ PERLVAR(I, Argv, const char **) /* stuff to free from do_aexec, vfork safe */ PERLVAR(I, Cmd, char *) /* stuff to free from do_aexec, vfork safe */ /* Elements in this array have ';' appended and are injected as a single line into the tokeniser. You can't put any (literal) newlines into any program you stuff in into this array, as the point where it's injected is expecting a single physical line. */ PERLVAR(I, preambleav, AV *) PERLVAR(I, mess_sv, SV *) PERLVAR(I, ors_sv, SV *) /* output record separator $\ */ /* statics moved here for shared library purposes */ PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */ PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */ PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */ PERLVARI(I, laststype, U16, OP_STAT) PERLVARI(I, laststatval, int, -1) /* interpreter atexit processing */ PERLVARI(I, exitlistlen, I32, 0) /* length of same */ PERLVARI(I, exitlist, PerlExitListEntry *, NULL) /* list of exit functions */ /* =for apidoc Amn|HV*|PL_modglobal C is a general purpose, interpreter global HV for use by extensions that need to keep information on a per-interpreter basis. In a pinch, it can also be used as a symbol table for extensions to share data among each other. It is a good idea to use keys prefixed by the package name of the extension that owns the data. =cut */ PERLVAR(I, modglobal, HV *) /* per-interp module data */ /* these used to be in global before 5.004_68 */ PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */ PERLVAR(I, compiling, COP) /* compiling/done executing marker */ PERLVAR(I, compcv, CV *) /* currently compiling subroutine */ PERLVAR(I, comppad, AV *) /* storage for lexically scoped temporaries */ PERLVAR(I, comppad_name, AV *) /* variable names for "my" variables */ PERLVAR(I, comppad_name_fill, I32) /* last "introduced" variable offset */ PERLVAR(I, comppad_name_floor, I32) /* start of vars in innermost block */ #ifdef HAVE_INTERP_INTERN PERLVAR(I, sys_intern, struct interp_intern) /* platform internals */ #endif /* more statics moved here */ PERLVAR(I, DBcv, CV *) /* from perl.c */ PERLVARI(I, generation, int, 100) /* from op.c */ PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */ PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */ PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */ PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */ PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */ PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */ PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */ PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */ PERLVARI(I, an, U32, 0) /* malloc sequence number */ #ifdef DEBUGGING /* exercise wrap-around */ #define PERL_COP_SEQMAX (U32_MAX-50) #else #define PERL_COP_SEQMAX 0 #endif PERLVARI(I, cop_seqmax, U32, PERL_COP_SEQMAX) /* statement sequence number */ #undef PERL_COP_SEQMAX PERLVARI(I, evalseq, U32, 0) /* eval sequence number */ PERLVAR(I, origalen, U32) PERLVAR(I, origenviron, char **) #ifdef PERL_USES_PL_PIDSTATUS PERLVAR(I, pidstatus, HV *) /* pid-to-status mappings for waitpid */ #endif PERLVAR(I, osname, char *) /* operating system */ PERLVAR(I, sighandlerp, Sighandler_t) PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */ PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ PERLVARI(I, maxo, int, MAXO) /* maximum number of ops */ PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT) /* =for apidoc Amn|SV|PL_sv_undef This is the C SV. Always refer to this as C<&PL_sv_undef>. =for apidoc Amn|SV|PL_sv_no This is the C SV. See C. Always refer to this as C<&PL_sv_no>. =for apidoc Amn|SV|PL_sv_yes This is the C SV. See C. Always refer to this as C<&PL_sv_yes>. =cut */ PERLVAR(I, sv_undef, SV) PERLVAR(I, sv_no, SV) PERLVAR(I, sv_yes, SV) PERLVAR(I, subname, SV *) /* name of current subroutine */ PERLVAR(I, subline, I32) /* line this subroutine began on */ PERLVAR(I, min_intro_pending, I32) /* start of vars to introduce */ PERLVAR(I, max_intro_pending, I32) /* end of vars to introduce */ PERLVAR(I, padix, I32) /* max used index in current "register" pad */ PERLVAR(I, padix_floor, I32) /* how low may inner block reset padix */ PERLVAR(I, hints, U32) /* pragma-tic compile-time flags */ PERLVAR(I, debug, VOL U32) /* flags given to -D switch */ /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */ PERLVARI(I, breakable_sub_gen, U32, 0) PERLVARI(I, amagic_generation, long, 0) #ifdef USE_LOCALE_COLLATE PERLVAR(I, collation_name, char *) /* Name of current collation */ PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm() */ PERLVARI(I, collxfrm_mult,Size_t, 2) /* Expansion factor in *xfrm() */ PERLVARI(I, collation_ix, U32, 0) /* Collation generation index */ PERLVARI(I, collation_standard, bool, TRUE) /* Assume simple collation */ #endif /* USE_LOCALE_COLLATE */ #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING) # define PERL___I -1 #else # define PERL___I 1 #endif PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */ #undef PERL___I #ifdef USE_LOCALE_NUMERIC PERLVARI(I, numeric_standard, bool, TRUE) /* Assume simple numerics */ PERLVARI(I, numeric_local, bool, TRUE) /* Assume local numerics */ PERLVAR(I, numeric_name, char *) /* Name of current numeric locale */ PERLVAR(I, numeric_radix_sv, SV *) /* The radix separator if not '.' */ #endif /* !USE_LOCALE_NUMERIC */ /* Unicode inversion lists */ PERLVAR(I, ASCII, SV *) PERLVAR(I, Latin1, SV *) PERLVAR(I, AboveLatin1, SV *) PERLVAR(I, PerlSpace, SV *) PERLVAR(I, XPerlSpace, SV *) PERLVAR(I, L1PosixAlnum,SV *) PERLVAR(I, PosixAlnum, SV *) PERLVAR(I, L1PosixAlpha,SV *) PERLVAR(I, PosixAlpha, SV *) PERLVAR(I, PosixBlank, SV *) PERLVAR(I, XPosixBlank, SV *) PERLVAR(I, L1Cased, SV *) PERLVAR(I, PosixCntrl, SV *) PERLVAR(I, XPosixCntrl, SV *) PERLVAR(I, PosixDigit, SV *) PERLVAR(I, L1PosixGraph,SV *) PERLVAR(I, PosixGraph, SV *) PERLVAR(I, L1PosixLower,SV *) PERLVAR(I, PosixLower, SV *) PERLVAR(I, L1PosixPrint,SV *) PERLVAR(I, PosixPrint, SV *) PERLVAR(I, L1PosixPunct,SV *) PERLVAR(I, PosixPunct, SV *) PERLVAR(I, PosixSpace, SV *) PERLVAR(I, XPosixSpace, SV *) PERLVAR(I, L1PosixUpper,SV *) PERLVAR(I, PosixUpper, SV *) PERLVAR(I, L1PosixWord, SV *) PERLVAR(I, PosixWord, SV *) PERLVAR(I, PosixXDigit, SV *) PERLVAR(I, XPosixXDigit, SV *) PERLVAR(I, VertSpace, SV *) /* utf8 character class swashes */ PERLVAR(I, utf8_alnum, SV *) PERLVAR(I, utf8_alpha, SV *) PERLVAR(I, utf8_space, SV *) PERLVAR(I, utf8_graph, SV *) PERLVAR(I, utf8_digit, SV *) PERLVAR(I, utf8_upper, SV *) PERLVAR(I, utf8_lower, SV *) PERLVAR(I, utf8_print, SV *) PERLVAR(I, utf8_punct, SV *) PERLVAR(I, utf8_xdigit, SV *) PERLVAR(I, utf8_mark, SV *) PERLVAR(I, utf8_X_begin, SV *) PERLVAR(I, utf8_X_extend, SV *) PERLVAR(I, utf8_X_prepend, SV *) PERLVAR(I, utf8_X_non_hangul, SV *) PERLVAR(I, utf8_X_L, SV *) PERLVAR(I, utf8_X_LV, SV *) PERLVAR(I, utf8_X_LVT, SV *) PERLVAR(I, utf8_X_T, SV *) PERLVAR(I, utf8_X_V, SV *) PERLVAR(I, utf8_X_LV_LVT_V, SV *) PERLVAR(I, utf8_toupper, SV *) PERLVAR(I, utf8_totitle, SV *) PERLVAR(I, utf8_tolower, SV *) PERLVAR(I, utf8_tofold, SV *) PERLVAR(I, utf8_quotemeta, SV *) PERLVAR(I, last_swash_hv, HV *) PERLVAR(I, last_swash_tmps, U8 *) PERLVAR(I, last_swash_slen, STRLEN) PERLVARA(I, last_swash_key,12, U8) PERLVAR(I, last_swash_klen, U8) /* Only needs to store 0-12 */ #ifdef FCRYPT PERLVARI(I, cryptseen, bool, FALSE) /* has fast crypt() been initialized? */ #endif PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */ PERLVAR(I, srand_called, bool) PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */ PERLVAR(I, parser, yy_parser *) /* current parser state */ /* Array of signal handlers, indexed by signal number, through which the C signal handler dispatches. */ PERLVAR(I, psig_ptr, SV **) /* Array of names of signals, indexed by signal number, for (re)use as the first argument to a signal handler. Only one block of memory is allocated for both psig_name and psig_ptr. */ PERLVAR(I, psig_name, SV **) #if defined(PERL_IMPLICIT_SYS) PERLVAR(I, Mem, struct IPerlMem *) PERLVAR(I, MemShared, struct IPerlMem *) PERLVAR(I, MemParse, struct IPerlMem *) PERLVAR(I, Env, struct IPerlEnv *) PERLVAR(I, StdIO, struct IPerlStdIO *) PERLVAR(I, LIO, struct IPerlLIO *) PERLVAR(I, Dir, struct IPerlDir *) PERLVAR(I, Sock, struct IPerlSock *) PERLVAR(I, Proc, struct IPerlProc *) #endif PERLVAR(I, ptr_table, PTR_TBL_t *) PERLVARI(I, beginav_save, AV *, NULL) /* save BEGIN{}s when compiling */ PERLVAR(I, body_arenas, void *) /* pointer to list of body-arenas */ #if defined(USE_ITHREADS) PERLVAR(I, regex_pad, SV **) /* Shortcut into the array of regex_padav */ PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the values in op_pmoffset of pmop. Entry 0 is an SV whose PV is a "packed" list of IVs listing the now-free slots in the array */ #endif #ifdef USE_REENTRANT_API PERLVAR(I, reentrant_buffer, REENTR *) /* here we store the _r buffers */ #endif PERLVAR(I, custom_op_names, HV *) /* Names of user defined ops */ PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */ #ifdef PERLIO_LAYERS PERLVARI(I, perlio, PerlIOl *, NULL) PERLVARI(I, known_layers, PerlIO_list_t *, NULL) PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL) #endif PERLVARI(I, encoding, SV *, NULL) /* character encoding */ PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */ PERLVAR(I, utf8_idstart, SV *) PERLVAR(I, utf8_idcont, SV *) PERLVAR(I, utf8_xidstart, SV *) PERLVAR(I, utf8_perl_idstart, SV *) PERLVAR(I, utf8_xidcont, SV *) PERLVAR(I, sort_RealCmp, SVCOMPARE_t) PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */ PERLVARI(I, unitcheckav_save, AV *, NULL) /* save UNITCHECK{}s when compiling */ PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */ PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */ /* Hooks to shared SVs and locks. */ PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing) PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing) #ifdef NO_MATHOMS # define PERL_UNLOCK_HOOK Perl_sv_nosharing #else /* This reference ensures that the mathoms are linked with perl */ # define PERL_UNLOCK_HOOK Perl_sv_nounlocking #endif PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK) PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook) /* Can shared object be destroyed */ PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable) #ifndef PERL_MICRO PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals) #endif PERLVARI(I, hash_seed, UV, 0) /* Hash initializer */ PERLVARI(I, rehash_seed, UV, 0) /* 582 hash initializer */ PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */ /* Register of known Method Resolution Orders. What this actually points to is an implementation detail (it may change to a structure incorporating a reference count - use mro_get_from_name to retrieve a C */ PERLVAR(I, registered_mros, HV *) /* Compile-time block start/end hooks */ PERLVAR(I, blockhooks, AV *) /* Everything that folds to a given character, for case insensitivity regex * matching */ PERLVARI(I, utf8_foldclosures, HV *, NULL) /* List of characters that participate in folds (except marks, etc in * multi-char folds) */ PERLVARI(I, utf8_foldable, SV *, NULL) PERLVAR(I, custom_ops, HV *) /* custom op registrations */ /* Hook for File::Glob */ PERLVARI(I, globhook, globhook_t, NULL) PERLVARI(I, glob_index, int, 0) PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */ /* The last unconditional member of the interpreter structure when 5.10.0 was released. The offset of the end of this is baked into a global variable in any shared perl library which will allow a sanity test in future perl releases. */ #define PERL_LAST_5_16_0_INTERP_MEMBER Ireentrant_retint #ifdef PERL_IMPLICIT_CONTEXT PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */ PERLVARI(I, my_cxt_size, int, 0) /* size of PL_my_cxt_list */ # ifdef PERL_GLOBAL_STRUCT_PRIVATE PERLVARI(I, my_cxt_keys, const char **, NULL) /* per-module array of pointers to MY_CXT_KEY constants */ # endif #endif #ifdef PERL_TRACK_MEMPOOL /* For use with the memory debugging code in util.c */ PERLVAR(I, memory_debug_header, struct perl_memory_debug_header) #endif #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP /* File descriptor to talk to the child which dumps scalars. */ PERLVARI(I, dumper_fd, int, -1) #endif #ifdef PERL_MAD PERLVARI(I, madskills, bool, FALSE) /* preserve all syntactic info */ /* (MAD = Misc Attribute Decoration) */ PERLVARI(I, xmlfp, PerlIO *, NULL) #endif #ifdef PL_OP_SLAB_ALLOC PERLVAR(I, OpPtr, I32 **) PERLVARI(I, OpSpace, I32, 0) PERLVAR(I, OpSlab, I32 *) #endif #ifdef PERL_DEBUG_READONLY_OPS PERLVARI(I, slabs, I32**, NULL) /* Array of slabs that have been allocated */ PERLVARI(I, slab_count, U32, 0) /* Size of the array */ #endif #ifdef DEBUG_LEAKING_SCALARS PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */ #endif /* If you are adding a U8 or U16, check to see if there are 'Space' comments * above on where there are gaps which currently will be structure padding. */ /* Within a stable branch, new variables must be added to the very end, before * this comment, for binary compatibility (the offsets of the old members must * not change). * (Don't forget to add your variable also to perl_clone()!) * XSUB.h provides wrapper functions via perlapi.h that make this * irrelevant, but not all code may be expected to #include XSUB.h. */ PKZform.hnuW+A/* form.h * * Copyright (C) 1991, 1992, 1993, 2000, 2004, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #define FF_END 0 /* tidy up, then return */ #define FF_LINEMARK 1 /* start (or end) of a line */ #define FF_LITERAL 2 /* append literal chars */ #define FF_SKIP 3 /* skip chars in format */ #define FF_FETCH 4 /* get next item and set field size to */ #define FF_CHECKNL 5 /* find max len of item (up to \n) that fits field */ #define FF_CHECKCHOP 6 /* like CHECKNL, but up to highest split point */ #define FF_SPACE 7 /* append padding space (diff of field, item size) */ #define FF_HALFSPACE 8 /* like FF_SPACE, but only append half as many */ #define FF_ITEM 9 /* append a text item, while blanking ctrl chars */ #define FF_CHOP 10 /* (for ^*) chop the current item */ #define FF_LINEGLOB 11 /* process @* */ #define FF_DECIMAL 12 /* do @##, ^##, where =(precision|flags) */ #define FF_NEWLINE 13 /* delete trailing spaces, then append \n */ #define FF_BLANK 14 /* for arg==0: do '~'; for arg>0 : do '~~' */ #define FF_MORE 15 /* replace long end of string with '...' */ #define FF_0DECIMAL 16 /* like FF_DECIMAL but for 0### */ #define FF_LINESNGL 17 /* process ^* */ PKZl&&scope.hnuW+A/* scope.h * * Copyright (C) 1993, 1994, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #define SAVEt_ITEM 0 #define SAVEt_SV 1 #define SAVEt_AV 2 #define SAVEt_HV 3 #define SAVEt_INT 4 #define SAVEt_LONG 5 #define SAVEt_I32 6 #define SAVEt_IV 7 #define SAVEt_SPTR 8 #define SAVEt_APTR 9 #define SAVEt_HPTR 10 #define SAVEt_PPTR 11 #define SAVEt_NSTAB 12 #define SAVEt_SVREF 13 #define SAVEt_GP 14 #define SAVEt_FREESV 15 #define SAVEt_FREEOP 16 #define SAVEt_FREEPV 17 #define SAVEt_CLEARSV 18 #define SAVEt_DELETE 19 #define SAVEt_DESTRUCTOR 20 #define SAVEt_REGCONTEXT 21 #define SAVEt_STACK_POS 22 #define SAVEt_I16 23 #define SAVEt_AELEM 24 #define SAVEt_HELEM 25 #define SAVEt_OP 26 #define SAVEt_HINTS 27 #define SAVEt_ALLOC 28 #define SAVEt_GENERIC_SVREF 29 #define SAVEt_DESTRUCTOR_X 30 #define SAVEt_VPTR 31 #define SAVEt_I8 32 #define SAVEt_COMPPAD 33 #define SAVEt_GENERIC_PVREF 34 #define SAVEt_PADSV_AND_MORTALIZE 35 #define SAVEt_MORTALIZESV 36 #define SAVEt_SHARED_PVREF 37 #define SAVEt_BOOL 38 #define SAVEt_SET_SVFLAGS 39 #define SAVEt_SAVESWITCHSTACK 40 #define SAVEt_RE_STATE 42 #define SAVEt_COMPILE_WARNINGS 43 #define SAVEt_STACK_CXPOS 44 #define SAVEt_PARSER 45 #define SAVEt_ADELETE 46 #define SAVEt_I32_SMALL 47 #define SAVEt_INT_SMALL 48 #define SAVEt_GVSV 49 #define SAVEt_FREECOPHH 50 #define SAVEf_SETMAGIC 1 #define SAVEf_KEEPOLDELEM 2 #define SAVE_TIGHT_SHIFT 6 #define SAVE_MASK 0x3F #define save_aelem(av,idx,sptr) save_aelem_flags(av,idx,sptr,SAVEf_SETMAGIC) #define save_helem(hv,key,sptr) save_helem_flags(hv,key,sptr,SAVEf_SETMAGIC) #ifndef SCOPE_SAVES_SIGNAL_MASK #define SCOPE_SAVES_SIGNAL_MASK 0 #endif #define SSCHECK(need) if (PL_savestack_ix + (I32)(need) > PL_savestack_max) savestack_grow() #define SSGROW(need) if (PL_savestack_ix + (I32)(need) > PL_savestack_max) savestack_grow_cnt(need) #define SSPUSHINT(i) (PL_savestack[PL_savestack_ix++].any_i32 = (I32)(i)) #define SSPUSHLONG(i) (PL_savestack[PL_savestack_ix++].any_long = (long)(i)) #define SSPUSHBOOL(p) (PL_savestack[PL_savestack_ix++].any_bool = (p)) #define SSPUSHIV(i) (PL_savestack[PL_savestack_ix++].any_iv = (IV)(i)) #define SSPUSHUV(u) (PL_savestack[PL_savestack_ix++].any_uv = (UV)(u)) #define SSPUSHPTR(p) (PL_savestack[PL_savestack_ix++].any_ptr = (void*)(p)) #define SSPUSHDPTR(p) (PL_savestack[PL_savestack_ix++].any_dptr = (p)) #define SSPUSHDXPTR(p) (PL_savestack[PL_savestack_ix++].any_dxptr = (p)) #define SSPOPINT (PL_savestack[--PL_savestack_ix].any_i32) #define SSPOPLONG (PL_savestack[--PL_savestack_ix].any_long) #define SSPOPBOOL (PL_savestack[--PL_savestack_ix].any_bool) #define SSPOPIV (PL_savestack[--PL_savestack_ix].any_iv) #define SSPOPUV (PL_savestack[--PL_savestack_ix].any_uv) #define SSPOPPTR (PL_savestack[--PL_savestack_ix].any_ptr) #define SSPOPDPTR (PL_savestack[--PL_savestack_ix].any_dptr) #define SSPOPDXPTR (PL_savestack[--PL_savestack_ix].any_dxptr) /* =head1 Callback Functions =for apidoc Ams||SAVETMPS Opening bracket for temporaries on a callback. See C and L. =for apidoc Ams||FREETMPS Closing bracket for temporaries on a callback. See C and L. =for apidoc Ams||ENTER Opening bracket on a callback. See C and L. =for apidoc Ams||LEAVE Closing bracket on a callback. See C and L. =over =item ENTER_with_name(name) Same as C, but when debugging is enabled it also associates the given literal string with the new scope. =item LEAVE_with_name(name) Same as C, but when debugging is enabled it first checks that the scope has the given name. Name must be a literal string. =back =cut */ #define SAVETMPS save_int((int*)&PL_tmps_floor), PL_tmps_floor = PL_tmps_ix #define FREETMPS if (PL_tmps_ix > PL_tmps_floor) free_tmps() #ifdef DEBUGGING #define ENTER \ STMT_START { \ push_scope(); \ DEBUG_SCOPE("ENTER") \ } STMT_END #define LEAVE \ STMT_START { \ DEBUG_SCOPE("LEAVE") \ pop_scope(); \ } STMT_END #define ENTER_with_name(name) \ STMT_START { \ push_scope(); \ if (PL_scopestack_name) \ PL_scopestack_name[PL_scopestack_ix-1] = name; \ DEBUG_SCOPE("ENTER \"" name "\"") \ } STMT_END #define LEAVE_with_name(name) \ STMT_START { \ DEBUG_SCOPE("LEAVE \"" name "\"") \ if (PL_scopestack_name) { \ assert(((char*)PL_scopestack_name[PL_scopestack_ix-1] \ == (char*)name) \ || strEQ(PL_scopestack_name[PL_scopestack_ix-1], name)); \ } \ pop_scope(); \ } STMT_END #else #define ENTER push_scope() #define LEAVE pop_scope() #define ENTER_with_name(name) ENTER #define LEAVE_with_name(name) LEAVE #endif #define LEAVE_SCOPE(old) if (PL_savestack_ix > old) leave_scope(old) #define SAVEI8(i) save_I8((I8*)&(i)) #define SAVEI16(i) save_I16((I16*)&(i)) #define SAVEI32(i) save_I32((I32*)&(i)) #define SAVEINT(i) save_int((int*)&(i)) #define SAVEIV(i) save_iv((IV*)&(i)) #define SAVELONG(l) save_long((long*)&(l)) #define SAVEBOOL(b) save_bool(&(b)) #define SAVESPTR(s) save_sptr((SV**)&(s)) #define SAVEPPTR(s) save_pptr((char**)&(s)) #define SAVEVPTR(s) save_vptr((void*)&(s)) #define SAVEPADSVANDMORTALIZE(s) save_padsv_and_mortalize(s) #define SAVEFREESV(s) save_freesv(MUTABLE_SV(s)) #define SAVEMORTALIZESV(s) save_mortalizesv(MUTABLE_SV(s)) #define SAVEFREEOP(o) save_freeop((OP*)(o)) #define SAVEFREEPV(p) save_freepv((char*)(p)) #define SAVECLEARSV(sv) save_clearsv((SV**)&(sv)) #define SAVEGENERICSV(s) save_generic_svref((SV**)&(s)) #define SAVEGENERICPV(s) save_generic_pvref((char**)&(s)) #define SAVESHAREDPV(s) save_shared_pvref((char**)&(s)) #define SAVESETSVFLAGS(sv,mask,val) save_set_svflags(sv,mask,val) #define SAVEFREECOPHH(h) save_pushptr((void *)(h), SAVEt_FREECOPHH) #define SAVEDELETE(h,k,l) \ save_delete(MUTABLE_HV(h), (char*)(k), (I32)(l)) #define SAVEHDELETE(h,s) \ save_hdelete(MUTABLE_HV(h), (s)) #define SAVEADELETE(a,k) \ save_adelete(MUTABLE_AV(a), (I32)(k)) #define SAVEDESTRUCTOR(f,p) \ save_destructor((DESTRUCTORFUNC_NOCONTEXT_t)(f), (void*)(p)) #define SAVEDESTRUCTOR_X(f,p) \ save_destructor_x((DESTRUCTORFUNC_t)(f), (void*)(p)) #define SAVESTACK_POS() \ STMT_START { \ SSCHECK(2); \ SSPUSHINT(PL_stack_sp - PL_stack_base); \ SSPUSHUV(SAVEt_STACK_POS); \ } STMT_END #define SAVEOP() save_op() #define SAVEHINTS() save_hints() #define SAVECOMPPAD() save_pushptr(MUTABLE_SV(PL_comppad), SAVEt_COMPPAD) #define SAVESWITCHSTACK(f,t) \ STMT_START { \ save_pushptrptr(MUTABLE_SV(f), MUTABLE_SV(t), SAVEt_SAVESWITCHSTACK); \ SWITCHSTACK((f),(t)); \ PL_curstackinfo->si_stack = (t); \ } STMT_END /* Need to do the cop warnings like this, rather than a "SAVEFREESHAREDPV", because realloc() means that the value can actually change. Possibly could have done savefreesharedpvREF, but this way actually seems cleaner, as it simplifies the code that does the saves, and reduces the load on the save stack. */ #define SAVECOMPILEWARNINGS() save_pushptr(PL_compiling.cop_warnings, SAVEt_COMPILE_WARNINGS) #define SAVESTACK_CXPOS() \ STMT_START { \ SSCHECK(3); \ SSPUSHINT(cxstack[cxstack_ix].blk_oldsp); \ SSPUSHINT(cxstack_ix); \ SSPUSHUV(SAVEt_STACK_CXPOS); \ } STMT_END #define SAVEPARSER(p) save_pushptr((p), SAVEt_PARSER) #ifdef USE_ITHREADS # define SAVECOPSTASH(c) (SAVEPPTR(CopSTASHPV(c)), \ SAVEI32(CopSTASH_len(c))) # define SAVECOPSTASH_FREE(c) (SAVESHAREDPV(CopSTASHPV(c)), \ SAVEI32(CopSTASH_len(c))) # define SAVECOPFILE(c) SAVEPPTR(CopFILE(c)) # define SAVECOPFILE_FREE(c) SAVESHAREDPV(CopFILE(c)) #else # define SAVECOPSTASH(c) SAVESPTR(CopSTASH(c)) # define SAVECOPSTASH_FREE(c) SAVECOPSTASH(c) /* XXX not refcounted */ # define SAVECOPFILE(c) SAVESPTR(CopFILEGV(c)) # define SAVECOPFILE_FREE(c) SAVEGENERICSV(CopFILEGV(c)) #endif #define SAVECOPLINE(c) SAVEI32(CopLINE(c)) /* SSNEW() temporarily allocates a specified number of bytes of data on the * savestack. It returns an integer index into the savestack, because a * pointer would get broken if the savestack is moved on reallocation. * SSNEWa() works like SSNEW(), but also aligns the data to the specified * number of bytes. MEM_ALIGNBYTES is perhaps the most useful. The * alignment will be preserved through savestack reallocation *only* if * realloc returns data aligned to a size divisible by "align"! * * SSPTR() converts the index returned by SSNEW/SSNEWa() into a pointer. */ #define SSNEW(size) Perl_save_alloc(aTHX_ (size), 0) #define SSNEWt(n,t) SSNEW((n)*sizeof(t)) #define SSNEWa(size,align) Perl_save_alloc(aTHX_ (size), \ (I32)(align - ((size_t)((caddr_t)&PL_savestack[PL_savestack_ix]) % align)) % align) #define SSNEWat(n,t,align) SSNEWa((n)*sizeof(t), align) #define SSPTR(off,type) ((type) ((char*)PL_savestack + off)) #define SSPTRt(off,type) ((type*) ((char*)PL_savestack + off)) #define save_freesv(op) save_pushptr((void *)(op), SAVEt_FREESV) #define save_mortalizesv(op) save_pushptr((void *)(op), SAVEt_MORTALIZESV) #define save_freeop(op) save_pushptr((void *)(op), SAVEt_FREEOP) #define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV) #define save_op() save_pushptr((void *)(PL_op), SAVEt_OP) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ6&6&charclass_invlists.hnuW+A/* -*- buffer-read-only: t -*- * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/mk_invlists.pl from Unicode::UCD. * Any changes made here will be lost! */ /* See the generating file for comments */ UV Latin1_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 256, 0 }; UV AboveLatin1_invlist[] = { 1, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 256 }; UV ASCII_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 128, 0 }; UV L1Cased_invlist[] = { 16, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91, 97, 123, 170, 171, 181, 182, 186, 187, 192, 215, 216, 247, 248, 443 }; UV VertSpace_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 10, 14, 133, 134, 8232, 8234 }; UV PerlSpace_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 11, 12, 14, 32, 33 }; UV XPerlSpace_invlist[] = { 24, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 11, 12, 14, 32, 33, 133, 134, 160, 161, 5760, 5761, 6158, 6159, 8192, 8203, 8232, 8234, 8239, 8240, 8287, 8288, 12288, 12289 }; UV PosixAlnum_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 91, 97, 123 }; UV L1PosixAlnum_invlist[] = { 18, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 91, 97, 123, 170, 171, 181, 182, 186, 187, 192, 215, 216, 247, 248, 706 }; UV PosixAlpha_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91, 97, 123 }; UV L1PosixAlpha_invlist[] = { 16, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91, 97, 123, 170, 171, 181, 182, 186, 187, 192, 215, 216, 247, 248, 706 }; UV PosixBlank_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 10, 32, 33 }; UV XPosixBlank_invlist[] = { 18, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 10, 32, 33, 160, 161, 5760, 5761, 6158, 6159, 8192, 8203, 8239, 8240, 8287, 8288, 12288, 12289 }; UV PosixCntrl_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, 127, 128, 0 }; UV XPosixCntrl_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 0, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, 127, 160, 0 }; UV PosixDigit_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58 }; UV PosixGraph_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, 127 }; UV L1PosixGraph_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, 127, 161, 888 }; UV PosixLower_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 97, 123 }; UV L1PosixLower_invlist[] = { 12, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 97, 123, 170, 171, 181, 182, 186, 187, 223, 247, 248, 256 }; UV PosixPrint_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, 127 }; UV L1PosixPrint_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 32, 127, 160, 888 }; UV PosixPunct_invlist[] = { 8, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, 48, 58, 65, 91, 97, 123, 127 }; UV L1PosixPunct_invlist[] = { 20, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 33, 48, 58, 65, 91, 97, 123, 127, 161, 162, 167, 168, 171, 172, 182, 184, 187, 188, 191, 192 }; UV PosixSpace_invlist[] = { 4, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 14, 32, 33 }; UV XPosixSpace_invlist[] = { 22, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 9, 14, 32, 33, 133, 134, 160, 161, 5760, 5761, 6158, 6159, 8192, 8203, 8232, 8234, 8239, 8240, 8287, 8288, 12288, 12289 }; UV PosixUpper_invlist[] = { 2, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91 }; UV L1PosixUpper_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 65, 91, 192, 215, 216, 223 }; UV PosixWord_invlist[] = { 8, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 91, 95, 96, 97, 123 }; UV L1PosixWord_invlist[] = { 20, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 91, 95, 96, 97, 123, 170, 171, 181, 182, 186, 187, 192, 215, 216, 247, 248, 706 }; UV PosixXDigit_invlist[] = { 6, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 71, 97, 103 }; UV XPosixXDigit_invlist[] = { 12, /* Number of elements */ 0, /* Current iteration position */ 1064334010, /* Version and data structure type */ 1, /* 0 if this is the first element of the list proper; 1 if the next element is the first */ 48, 58, 65, 71, 97, 103, 65296, 65306, 65313, 65319, 65345, 65351 }; /* ex: set ro: */ PKZVp#c#cutf8.hnuW+A/* utf8.h * * Copyright (C) 2000, 2001, 2002, 2005, 2006, 2007, 2009, * 2010, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* Use UTF-8 as the default script encoding? * Turning this on will break scripts having non-UTF-8 binary * data (such as Latin-1) in string literals. */ #ifdef USE_UTF8_SCRIPTS # define USE_UTF8_IN_NAMES (!IN_BYTES) #else # define USE_UTF8_IN_NAMES (PL_hints & HINT_UTF8) #endif /* For to_utf8_fold_flags, q.v. */ #define FOLD_FLAGS_LOCALE 0x1 #define FOLD_FLAGS_FULL 0x2 #define to_uni_fold(c, p, lenp) _to_uni_fold_flags(c, p, lenp, 1) #define to_utf8_fold(c, p, lenp) _to_utf8_fold_flags(c, p, lenp, \ FOLD_FLAGS_FULL, NULL) #define to_utf8_lower(a,b,c) _to_utf8_lower_flags(a,b,c,0, NULL) #define to_utf8_upper(a,b,c) _to_utf8_upper_flags(a,b,c,0, NULL) #define to_utf8_title(a,b,c) _to_utf8_title_flags(a,b,c,0, NULL) /* Source backward compatibility. */ #define uvuni_to_utf8(d, uv) uvuni_to_utf8_flags(d, uv, 0) #define is_utf8_string_loc(s, len, ep) is_utf8_string_loclen(s, len, ep, 0) #define foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2) \ foldEQ_utf8_flags(s1, pe1, l1, u1, s2, pe2, l2, u2, 0) #define FOLDEQ_UTF8_NOMIX_ASCII (1 << 0) #define FOLDEQ_UTF8_LOCALE (1 << 1) #define FOLDEQ_S1_ALREADY_FOLDED (1 << 2) #define FOLDEQ_S2_ALREADY_FOLDED (1 << 3) /* =for apidoc ibcmp_utf8 This is a synonym for (! foldEQ_utf8()) =cut */ #define ibcmp_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2) \ cBOOL(! foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2)) #ifdef EBCDIC /* The equivalent of these macros but implementing UTF-EBCDIC are in the following header file: */ #include "utfebcdic.h" #else /* ! EBCDIC */ START_EXTERN_C #ifdef DOINIT EXTCONST unsigned char PL_utf8skip[] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ascii */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* bogus */ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, /* scripts */ 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6, /* cjk etc. */ 7,13, /* Perl extended (not official UTF-8). Up to 72bit allowed (64-bit + reserved). */ }; #else EXTCONST unsigned char PL_utf8skip[]; #endif END_EXTERN_C /* Native character to iso-8859-1 */ #define NATIVE_TO_ASCII(ch) (ch) #define ASCII_TO_NATIVE(ch) (ch) /* Transform after encoding */ #define NATIVE_TO_UTF(ch) (ch) #define UTF_TO_NATIVE(ch) (ch) /* Transforms in wide UV chars */ #define UNI_TO_NATIVE(ch) (ch) #define NATIVE_TO_UNI(ch) (ch) /* Transforms in invariant space */ #define NATIVE_TO_NEED(enc,ch) (ch) #define ASCII_TO_NEED(enc,ch) (ch) /* As there are no translations, avoid the function wrapper */ #define utf8n_to_uvchr utf8n_to_uvuni #define uvchr_to_utf8 uvuni_to_utf8 /* The following table is from Unicode 3.2. Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte U+0000..U+007F 00..7F U+0080..U+07FF * C2..DF 80..BF U+0800..U+0FFF E0 * A0..BF 80..BF U+1000..U+CFFF E1..EC 80..BF 80..BF U+D000..U+D7FF ED 80..9F 80..BF U+D800..U+DFFF +++++++ utf16 surrogates, not legal utf8 +++++++ U+E000..U+FFFF EE..EF 80..BF 80..BF U+10000..U+3FFFF F0 * 90..BF 80..BF 80..BF U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF U+100000..U+10FFFF F4 80..8F 80..BF 80..BF Note the gaps before several of the byte entries above marked by '*'. These are caused by legal UTF-8 avoiding non-shortest encodings: it is technically possible to UTF-8-encode a single code point in different ways, but that is explicitly forbidden, and the shortest possible encoding should always be used (and that is what Perl does). */ /* Another way to look at it, as bits: Code Points 1st Byte 2nd Byte 3rd Byte 4th Byte 0aaaaaaa 0aaaaaaa 00000bbbbbaaaaaa 110bbbbb 10aaaaaa ccccbbbbbbaaaaaa 1110cccc 10bbbbbb 10aaaaaa 00000dddccccccbbbbbbaaaaaa 11110ddd 10cccccc 10bbbbbb 10aaaaaa As you can see, the continuation bytes all begin with C<10>, and the leading bits of the start byte tell how many bytes there are in the encoded character. Perl's extended UTF-8 means we can have start bytes up to FF. */ #define UNI_IS_INVARIANT(c) (((UV)c) < 0x80) #define UTF8_IS_START(c) (((U8)c) >= 0xc2) #define UTF8_IS_CONTINUATION(c) (((U8)c) >= 0x80 && (((U8)c) <= 0xbf)) #define UTF8_IS_CONTINUED(c) (((U8)c) & 0x80) /* Masking with 0xfe allows low bit to be 0 or 1; thus this matches 0xc[23] */ #define UTF8_IS_DOWNGRADEABLE_START(c) (((U8)c & 0xfe) == 0xc2) #define UTF_START_MARK(len) (((len) > 7) ? 0xFF : (0xFE << (7-(len)))) #define UTF_START_MASK(len) (((len) >= 7) ? 0x00 : (0x1F >> ((len)-2))) #define UTF_CONTINUATION_MARK 0x80 #define UTF_ACCUMULATION_SHIFT 6 #define UTF_CONTINUATION_MASK ((U8)0x3f) /* This sets the UTF_CONTINUATION_MASK in the upper bits of a word. If a value * is anded with it, and the result is non-zero, then using the original value * in UTF8_ACCUMULATE will overflow, shifting bits off the left */ #define UTF_ACCUMULATION_OVERFLOW_MASK \ (((UV) UTF_CONTINUATION_MASK) << ((sizeof(UV) * CHARBITS) - UTF_ACCUMULATION_SHIFT)) #ifdef HAS_QUAD #define UNISKIP(uv) ( (uv) < 0x80 ? 1 : \ (uv) < 0x800 ? 2 : \ (uv) < 0x10000 ? 3 : \ (uv) < 0x200000 ? 4 : \ (uv) < 0x4000000 ? 5 : \ (uv) < 0x80000000 ? 6 : \ (uv) < UTF8_QUAD_MAX ? 7 : 13 ) #else /* No, I'm not even going to *TRY* putting #ifdef inside a #define */ #define UNISKIP(uv) ( (uv) < 0x80 ? 1 : \ (uv) < 0x800 ? 2 : \ (uv) < 0x10000 ? 3 : \ (uv) < 0x200000 ? 4 : \ (uv) < 0x4000000 ? 5 : \ (uv) < 0x80000000 ? 6 : 7 ) #endif #endif /* EBCDIC vs ASCII */ /* Rest of these are attributes of Unicode and perl's internals rather than the * encoding, or happen to be the same in both ASCII and EBCDIC (at least at * this level; the macros that some of these call may have different * definitions in the two encodings */ #define NATIVE8_TO_UNI(ch) NATIVE_TO_ASCII(ch) /* a clearer synonym */ #define UTF8_ACCUMULATE(old, new) (((old) << UTF_ACCUMULATION_SHIFT) | (((U8)new) & UTF_CONTINUATION_MASK)) /* Convert a two (not one) byte utf8 character to a unicode code point value. * Needs just one iteration of accumulate. Should not be used unless it is * known that the two bytes are legal: 1) two-byte start, and 2) continuation. * Note that the result can be larger than 255 if the input character is not * downgradable */ #define TWO_BYTE_UTF8_TO_UNI(HI, LO) \ UTF8_ACCUMULATE((NATIVE_TO_UTF(HI) & UTF_START_MASK(2)), \ NATIVE_TO_UTF(LO)) #define UTF8SKIP(s) PL_utf8skip[*(const U8*)(s)] #define UTF8_IS_INVARIANT(c) UNI_IS_INVARIANT(NATIVE_TO_UTF(c)) #define NATIVE_IS_INVARIANT(c) UNI_IS_INVARIANT(NATIVE8_TO_UNI(c)) #define MAX_PORTABLE_UTF8_TWO_BYTE 0x3FF /* constrained by EBCDIC */ /* The macros in the next sets are used to generate the two utf8 or utfebcdic * bytes from an ordinal that is known to fit into two bytes; it must be less * than 0x3FF to work across both encodings. */ /* Nocast allows these to be used in the case label of a switch statement */ #define UTF8_TWO_BYTE_HI_nocast(c) UTF_TO_NATIVE(((c) >> UTF_ACCUMULATION_SHIFT) | (0xFF & UTF_START_MARK(2))) #define UTF8_TWO_BYTE_LO_nocast(c) UTF_TO_NATIVE(((c) & UTF_CONTINUATION_MASK) | UTF_CONTINUATION_MARK) #define UTF8_TWO_BYTE_HI(c) ((U8) (UTF8_TWO_BYTE_HI_nocast(c))) #define UTF8_TWO_BYTE_LO(c) ((U8) (UTF8_TWO_BYTE_LO_nocast(c))) /* This name is used when the source is a single byte */ #define UTF8_EIGHT_BIT_HI(c) UTF8_TWO_BYTE_HI((U8)(c)) #define UTF8_EIGHT_BIT_LO(c) UTF8_TWO_BYTE_LO((U8)(c)) /* * 'UTF' is whether or not p is encoded in UTF8. The names 'foo_lazy_if' stem * from an earlier version of these macros in which they didn't call the * foo_utf8() macros (i.e. were 'lazy') unless they decided that *p is the * beginning of a utf8 character. Now that foo_utf8() determines that itself, * no need to do it again here */ #define isIDFIRST_lazy_if(p,UTF) ((IN_BYTES || !UTF ) \ ? isIDFIRST(*(p)) \ : isIDFIRST_utf8((const U8*)p)) #define isALNUM_lazy_if(p,UTF) ((IN_BYTES || (!UTF )) \ ? isALNUM(*(p)) \ : isALNUM_utf8((const U8*)p)) #define isIDFIRST_lazy(p) isIDFIRST_lazy_if(p,1) #define isALNUM_lazy(p) isALNUM_lazy_if(p,1) #define UTF8_MAXBYTES 13 /* How wide can a single UTF-8 encoded character become in bytes. * NOTE: Strictly speaking Perl's UTF-8 should not be called UTF-8 * since UTF-8 is an encoding of Unicode and given Unicode's current * upper limit only four bytes is possible. Perl thinks of UTF-8 * as a way to encode non-negative integers in a binary format. */ #define UTF8_MAXLEN UTF8_MAXBYTES /* The maximum number of UTF-8 bytes a single Unicode character can * uppercase/lowercase/fold into; this number depends on the Unicode * version. An example of maximal expansion is the U+03B0 which * uppercases to U+03C5 U+0308 U+0301. The Unicode databases that * tell these things are UnicodeData.txt, CaseFolding.txt, and * SpecialCasing.txt. The value is 6 for strict Unicode characters, but it has * to be as big as Perl allows for a single character */ #define UTF8_MAXBYTES_CASE UTF8_MAXBYTES /* A Unicode character can fold to up to 3 characters */ #define UTF8_MAX_FOLD_CHAR_EXPAND 3 #define IN_BYTES (CopHINTS_get(PL_curcop) & HINT_BYTES) #define DO_UTF8(sv) (SvUTF8(sv) && !IN_BYTES) #define IN_UNI_8_BIT \ (CopHINTS_get(PL_curcop) & (HINT_UNI_8_BIT|HINT_LOCALE_NOT_CHARS) \ && ! IN_LOCALE_RUNTIME && ! IN_BYTES) #define UTF8_ALLOW_EMPTY 0x0001 /* Allow a zero length string */ /* Allow first byte to be a continuation byte */ #define UTF8_ALLOW_CONTINUATION 0x0002 /* Allow second... bytes to be non-continuation bytes */ #define UTF8_ALLOW_NON_CONTINUATION 0x0004 /* expecting more bytes than were available in the string */ #define UTF8_ALLOW_SHORT 0x0008 /* Overlong sequence; i.e., the code point can be specified in fewer bytes. */ #define UTF8_ALLOW_LONG 0x0010 #define UTF8_DISALLOW_SURROGATE 0x0020 /* Unicode surrogates */ #define UTF8_WARN_SURROGATE 0x0040 #define UTF8_DISALLOW_NONCHAR 0x0080 /* Unicode non-character */ #define UTF8_WARN_NONCHAR 0x0100 /* code points */ #define UTF8_DISALLOW_SUPER 0x0200 /* Super-set of Unicode: code */ #define UTF8_WARN_SUPER 0x0400 /* points above the legal max */ /* Code points which never were part of the original UTF-8 standard, the first * byte of which is a FE or FF on ASCII platforms. */ #define UTF8_DISALLOW_FE_FF 0x0800 #define UTF8_WARN_FE_FF 0x1000 #define UTF8_CHECK_ONLY 0x2000 /* For backwards source compatibility. They do nothing, as the default now * includes what they used to mean. The first one's meaning was to allow the * just the single non-character 0xFFFF */ #define UTF8_ALLOW_FFFF 0 #define UTF8_ALLOW_SURROGATE 0 #define UTF8_DISALLOW_ILLEGAL_INTERCHANGE (UTF8_DISALLOW_SUPER|UTF8_DISALLOW_NONCHAR|UTF8_DISALLOW_SURROGATE|UTF8_DISALLOW_FE_FF) #define UTF8_WARN_ILLEGAL_INTERCHANGE \ (UTF8_WARN_SUPER|UTF8_WARN_NONCHAR|UTF8_WARN_SURROGATE|UTF8_WARN_FE_FF) #define UTF8_ALLOW_ANY \ (~(UTF8_DISALLOW_ILLEGAL_INTERCHANGE|UTF8_WARN_ILLEGAL_INTERCHANGE)) #define UTF8_ALLOW_ANYUV \ (UTF8_ALLOW_EMPTY \ & ~(UTF8_DISALLOW_ILLEGAL_INTERCHANGE|UTF8_WARN_ILLEGAL_INTERCHANGE)) #define UTF8_ALLOW_DEFAULT (ckWARN(WARN_UTF8) ? 0 : \ UTF8_ALLOW_ANYUV) /* Surrogates, non-character code points and above-Unicode code points are * problematic in some contexts. This allows code that needs to check for * those to to quickly exclude the vast majority of code points it will * encounter */ #ifdef EBCDIC # define UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE UTF_TO_NATIVE(0xF1) #else # define UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE 0xED #endif /* ASCII EBCDIC I8 * U+D7FF: \xED\x9F\xBF \xF1\xB5\xBF\xBF last before surrogates * U+D800: \xED\xA0\x80 \xF1\xB6\xA0\xA0 1st surrogate * U+DFFF: \xED\xBF\xBF \xF1\xB7\xBF\xBF final surrogate * U+E000: \xEE\x80\x80 \xF1\xB8\xA0\xA0 next after surrogates */ #ifdef EBCDIC /* Both versions assume well-formed UTF8 */ # define UTF8_IS_SURROGATE(s) (*(s) == UTF_TO_NATIVE(0xF1) \ && ((*((s) +1) == UTF_TO_NATIVE(0xB6)) || *((s) + 1) == UTF_TO_NATIVE(0xB7))) #else # define UTF8_IS_SURROGATE(s) (*(s) == 0xED && *((s) + 1) >= 0xA0) #endif /* ASCII EBCDIC I8 * U+10FFFF: \xF4\x8F\xBF\xBF \xF9\xA1\xBF\xBF\xBF max legal Unicode * U+110000: \xF4\x90\x80\x80 \xF9\xA2\xA0\xA0\xA0 * U+110001: \xF4\x90\x80\x81 \xF9\xA2\xA0\xA0\xA1 */ #ifdef EBCDIC /* Both versions assume well-formed UTF8 */ # define UTF8_IS_SUPER(s) (*(s) >= UTF_TO_NATIVE(0xF9) \ && (*(s) > UTF_TO_NATIVE(0xF9) || (*((s) + 1) >= UTF_TO_NATIVE(0xA2)))) #else # define UTF8_IS_SUPER(s) (*(s) >= 0xF4 \ && (*(s) > 0xF4 || (*((s) + 1) >= 0x90))) #endif /* ASCII EBCDIC I8 * U+FDCF: \xEF\xB7\x8F \xF1\xBF\xAE\xAF last before non-char block * U+FDD0: \xEF\xB7\x90 \xF1\xBF\xAE\xB0 first non-char in block * U+FDEF: \xEF\xB7\xAF \xF1\xBF\xAF\xAF last non-char in block * U+FDF0: \xEF\xB7\xB0 \xF1\xBF\xAF\xB0 first after non-char block * U+FFFF: \xEF\xBF\xBF \xF1\xBF\xBF\xBF * U+1FFFF: \xF0\x9F\xBF\xBF \xF3\xBF\xBF\xBF * U+2FFFF: \xF0\xAF\xBF\xBF \xF5\xBF\xBF\xBF * U+3FFFF: \xF0\xBF\xBF\xBF \xF7\xBF\xBF\xBF * U+4FFFF: \xF1\x8F\xBF\xBF \xF8\xA9\xBF\xBF\xBF * U+5FFFF: \xF1\x9F\xBF\xBF \xF8\xAB\xBF\xBF\xBF * U+6FFFF: \xF1\xAF\xBF\xBF \xF8\xAD\xBF\xBF\xBF * U+7FFFF: \xF1\xBF\xBF\xBF \xF8\xAF\xBF\xBF\xBF * U+8FFFF: \xF2\x8F\xBF\xBF \xF8\xB1\xBF\xBF\xBF * U+9FFFF: \xF2\x9F\xBF\xBF \xF8\xB3\xBF\xBF\xBF * U+AFFFF: \xF2\xAF\xBF\xBF \xF8\xB5\xBF\xBF\xBF * U+BFFFF: \xF2\xBF\xBF\xBF \xF8\xB7\xBF\xBF\xBF * U+CFFFF: \xF3\x8F\xBF\xBF \xF8\xB9\xBF\xBF\xBF * U+DFFFF: \xF3\x9F\xBF\xBF \xF8\xBB\xBF\xBF\xBF * U+EFFFF: \xF3\xAF\xBF\xBF \xF8\xBD\xBF\xBF\xBF * U+FFFFF: \xF3\xBF\xBF\xBF \xF8\xBF\xBF\xBF\xBF * U+10FFFF: \xF4\x8F\xBF\xBF \xF9\xA1\xBF\xBF\xBF */ #define UTF8_IS_NONCHAR_(s) ( \ *(s) >= UTF8_FIRST_PROBLEMATIC_CODE_POINT_FIRST_BYTE \ && ! UTF8_IS_SUPER(s) \ && UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_FIRST_PROBLEMATIC(s) \ #ifdef EBCDIC /* Both versions assume well-formed UTF8 */ # define UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) \ ((*(s) == UTF_TO_NATIVE(0xF1) \ && (*((s) + 1) == UTF_TO_NATIVE(0xBF) \ && ((*((s) + 2) == UTF_TO_NATIVE(0xAE) \ && *((s) + 3) >= UTF_TO_NATIVE(0xB0)) \ || (*((s) + 2) == UTF_TO_NATIVE(0xAF) \ && *((s) + 3) <= UTF_TO_NATIVE(0xAF))))) \ || (UTF8SKIP(*(s)) > 3 \ /* (These were all derived by inspection and experimentation with an */ \ /* editor) The next line checks the next to final byte in the char */ \ && *((s) + UTF8SKIP(*(s)) - 2) == UTF_TO_NATIVE(0xBF) \ && *((s) + UTF8SKIP(*(s)) - 3) == UTF_TO_NATIVE(0xBF) \ && (NATIVE_TO_UTF(*((s) + UTF8SKIP(*(s)) - 4)) & 0x81) == 0x81 \ && (NATIVE_TO_UTF(*((s) + UTF8SKIP(*(s)) - 1)) & 0xBE) == 0XBE)) #else # define UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC(s) \ ((*(s) == 0xEF \ && ((*((s) + 1) == 0xB7 && (*((s) + 2) >= 0x90 && (*((s) + 2) <= 0xAF)))\ /* Gets U+FFF[EF] */ \ || (*((s) + 1) == 0xBF && ((*((s) + 2) & 0xBE) == 0xBE)))) \ || ((*((s) + 2) == 0xBF \ && (*((s) + 3) & 0xBE) == 0xBE \ /* Excludes things like U+10FFE = \xF0\x90\xBF\xBE */ \ && (*((s) + 1) & 0x8F) == 0x8F))) #endif #define UNICODE_SURROGATE_FIRST 0xD800 #define UNICODE_SURROGATE_LAST 0xDFFF #define UNICODE_REPLACEMENT 0xFFFD #define UNICODE_BYTE_ORDER_MARK 0xFEFF /* Though our UTF-8 encoding can go beyond this, * let's be conservative and do as Unicode says. */ #define PERL_UNICODE_MAX 0x10FFFF #define UNICODE_WARN_SURROGATE 0x0001 /* UTF-16 surrogates */ #define UNICODE_WARN_NONCHAR 0x0002 /* Non-char code points */ #define UNICODE_WARN_SUPER 0x0004 /* Above 0x10FFFF */ #define UNICODE_WARN_FE_FF 0x0008 /* Above 0x10FFFF */ #define UNICODE_DISALLOW_SURROGATE 0x0010 #define UNICODE_DISALLOW_NONCHAR 0x0020 #define UNICODE_DISALLOW_SUPER 0x0040 #define UNICODE_DISALLOW_FE_FF 0x0080 #define UNICODE_WARN_ILLEGAL_INTERCHANGE \ (UNICODE_WARN_SURROGATE|UNICODE_WARN_NONCHAR|UNICODE_WARN_SUPER) #define UNICODE_DISALLOW_ILLEGAL_INTERCHANGE \ (UNICODE_DISALLOW_SURROGATE|UNICODE_DISALLOW_NONCHAR|UNICODE_DISALLOW_SUPER) /* For backward source compatibility, as are now the default */ #define UNICODE_ALLOW_SURROGATE 0 #define UNICODE_ALLOW_SUPER 0 #define UNICODE_ALLOW_ANY 0 #define UNICODE_IS_SURROGATE(c) ((c) >= UNICODE_SURROGATE_FIRST && \ (c) <= UNICODE_SURROGATE_LAST) #define UNICODE_IS_REPLACEMENT(c) ((c) == UNICODE_REPLACEMENT) #define UNICODE_IS_BYTE_ORDER_MARK(c) ((c) == UNICODE_BYTE_ORDER_MARK) #define UNICODE_IS_NONCHAR(c) ((c >= 0xFDD0 && c <= 0xFDEF) \ /* The other noncharacters end in FFFE or FFFF, which \ * the mask below catches both of, but beyond the last \ * official unicode code point, they aren't \ * noncharacters, since those aren't Unicode \ * characters at all */ \ || ((((c & 0xFFFE) == 0xFFFE)) && ! UNICODE_IS_SUPER(c))) #define UNICODE_IS_SUPER(c) ((c) > PERL_UNICODE_MAX) #define UNICODE_IS_FE_FF(c) ((c) > 0x7FFFFFFF) #ifdef HAS_QUAD # define UTF8_QUAD_MAX UINT64_C(0x1000000000) #endif #define UNICODE_GREEK_CAPITAL_LETTER_SIGMA 0x03A3 #define UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA 0x03C2 #define UNICODE_GREEK_SMALL_LETTER_SIGMA 0x03C3 #define GREEK_SMALL_LETTER_MU 0x03BC #define GREEK_CAPITAL_LETTER_MU 0x039C /* Upper and title case of MICRON */ #define LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS 0x0178 /* Also is title case */ #define LATIN_CAPITAL_LETTER_SHARP_S 0x1E9E #define UNI_DISPLAY_ISPRINT 0x0001 #define UNI_DISPLAY_BACKSLASH 0x0002 #define UNI_DISPLAY_QQ (UNI_DISPLAY_ISPRINT|UNI_DISPLAY_BACKSLASH) #define UNI_DISPLAY_REGEX (UNI_DISPLAY_ISPRINT|UNI_DISPLAY_BACKSLASH) #ifndef EBCDIC # define LATIN_SMALL_LETTER_SHARP_S 0x00DF # define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0x00FF # define MICRO_SIGN 0x00B5 # define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x00C5 # define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x00E5 #endif #define ANYOF_FOLD_SHARP_S(node, input, end) \ (ANYOF_BITMAP_TEST(node, LATIN_SMALL_LETTER_SHARP_S) && \ (ANYOF_NONBITMAP(node)) && \ (ANYOF_FLAGS(node) & ANYOF_LOC_NONBITMAP_FOLD) && \ ((end) > (input) + 1) && \ toLOWER((input)[0]) == 's' && \ toLOWER((input)[1]) == 's') #define SHARP_S_SKIP 2 #ifndef EBCDIC # define IS_UTF8_CHAR_1(p) \ ((p)[0] <= 0x7F) # define IS_UTF8_CHAR_2(p) \ ((p)[0] >= 0xC2 && (p)[0] <= 0xDF && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF) # define IS_UTF8_CHAR_3a(p) \ ((p)[0] == 0xE0 && \ (p)[1] >= 0xA0 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF) # define IS_UTF8_CHAR_3b(p) \ ((p)[0] >= 0xE1 && (p)[0] <= 0xEC && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF) # define IS_UTF8_CHAR_3c(p) \ ((p)[0] == 0xED && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF) /* In IS_UTF8_CHAR_3c(p) one could use * (p)[1] >= 0x80 && (p)[1] <= 0x9F * if one wanted to exclude surrogates. */ # define IS_UTF8_CHAR_3d(p) \ ((p)[0] >= 0xEE && (p)[0] <= 0xEF && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF) # define IS_UTF8_CHAR_4a(p) \ ((p)[0] == 0xF0 && \ (p)[1] >= 0x90 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ (p)[3] >= 0x80 && (p)[3] <= 0xBF) # define IS_UTF8_CHAR_4b(p) \ ((p)[0] >= 0xF1 && (p)[0] <= 0xF3 && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ (p)[3] >= 0x80 && (p)[3] <= 0xBF) /* In IS_UTF8_CHAR_4c(p) one could use * (p)[0] == 0xF4 * if one wanted to stop at the Unicode limit U+10FFFF. * The 0xF7 allows us to go to 0x1fffff (0x200000 would * require five bytes). Not doing any further code points * since that is not needed (and that would not be strict * UTF-8, anyway). The "slow path" in Perl_is_utf8_char() * will take care of the "extended UTF-8". */ # define IS_UTF8_CHAR_4c(p) \ ((p)[0] >= 0xF4 && (p)[0] <= 0xF7 && \ (p)[1] >= 0x80 && (p)[1] <= 0xBF && \ (p)[2] >= 0x80 && (p)[2] <= 0xBF && \ (p)[3] >= 0x80 && (p)[3] <= 0xBF) # define IS_UTF8_CHAR_3(p) \ (IS_UTF8_CHAR_3a(p) || \ IS_UTF8_CHAR_3b(p) || \ IS_UTF8_CHAR_3c(p) || \ IS_UTF8_CHAR_3d(p)) # define IS_UTF8_CHAR_4(p) \ (IS_UTF8_CHAR_4a(p) || \ IS_UTF8_CHAR_4b(p) || \ IS_UTF8_CHAR_4c(p)) /* IS_UTF8_CHAR(p) is strictly speaking wrong (not UTF-8) because it * (1) allows UTF-8 encoded UTF-16 surrogates * (2) it allows code points past U+10FFFF. * The Perl_is_utf8_char() full "slow" code will handle the Perl * "extended UTF-8". */ # define IS_UTF8_CHAR(p, n) \ ((n) == 1 ? IS_UTF8_CHAR_1(p) : \ (n) == 2 ? IS_UTF8_CHAR_2(p) : \ (n) == 3 ? IS_UTF8_CHAR_3(p) : \ (n) == 4 ? IS_UTF8_CHAR_4(p) : 0) # define IS_UTF8_CHAR_FAST(n) ((n) <= 4) #else /* EBCDIC */ /* This is an attempt to port IS_UTF8_CHAR to EBCDIC based on eyeballing. * untested. If want to exclude surrogates and above-Unicode, see the * definitions for UTF8_IS_SURROGATE and UTF8_IS_SUPER */ # define IS_UTF8_CHAR_1(p) \ (NATIVE_TO_ASCII((p)[0]) <= 0x9F) # define IS_UTF8_CHAR_2(p) \ (NATIVE_TO_I8((p)[0]) >= 0xC5 && NATIVE_TO_I8((p)[0]) <= 0xDF && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF) # define IS_UTF8_CHAR_3(p) \ (NATIVE_TO_I8((p)[0]) == 0xE1 && NATIVE_TO_I8((p)[1]) <= 0xEF && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF) # define IS_UTF8_CHAR_4a(p) \ (NATIVE_TO_I8((p)[0]) == 0xF0 && \ NATIVE_TO_I8((p)[1]) >= 0xB0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) # define IS_UTF8_CHAR_4b(p) \ (NATIVE_TO_I8((p)[0]) >= 0xF1 && NATIVE_TO_I8((p)[0]) <= 0xF7 && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) # define IS_UTF8_CHAR_5a(p) \ (NATIVE_TO_I8((p)[0]) == 0xF8 && \ NATIVE_TO_I8((p)[1]) >= 0xA8 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) # define IS_UTF8_CHAR_5b(p) \ (NATIVE_TO_I8((p)[0]) >= 0xF9 && NATIVE_TO_I8((p)[1]) <= 0xFB && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[1]) >= 0xA0 && NATIVE_TO_I8((p)[1]) <= 0xBF && \ NATIVE_TO_I8((p)[2]) >= 0xA0 && NATIVE_TO_I8((p)[2]) <= 0xBF && \ NATIVE_TO_I8((p)[3]) >= 0xA0 && NATIVE_TO_I8((p)[3]) <= 0xBF) # define IS_UTF8_CHAR_4(p) \ (IS_UTF8_CHAR_4a(p) || \ IS_UTF8_CHAR_4b(p)) # define IS_UTF8_CHAR_5(p) \ (IS_UTF8_CHAR_5a(p) || \ IS_UTF8_CHAR_5b(p)) # define IS_UTF8_CHAR(p, n) \ ((n) == 1 ? IS_UTF8_CHAR_1(p) : \ (n) == 2 ? IS_UTF8_CHAR_2(p) : \ (n) == 3 ? IS_UTF8_CHAR_3(p) : \ (n) == 4 ? IS_UTF8_CHAR_4(p) : \ (n) == 5 ? IS_UTF8_CHAR_5(p) : 0) # define IS_UTF8_CHAR_FAST(n) ((n) <= 5) #endif /* IS_UTF8_CHAR() for UTF-8 */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ{% unixish.hnuW+A/* unixish.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, * 2003, 2006, 2007, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * The following symbols are defined if your operating system supports * functions by that name. All Unixes I know of support them, thus they * are not checked by the configuration script, but are directly defined * here. */ #ifndef PERL_MICRO /* HAS_IOCTL: * This symbol, if defined, indicates that the ioctl() routine is * available to set I/O characteristics */ #define HAS_IOCTL /**/ /* HAS_UTIME: * This symbol, if defined, indicates that the routine utime() is * available to update the access and modification times of files. */ #define HAS_UTIME /**/ /* HAS_GROUP * This symbol, if defined, indicates that the getgrnam() and * getgrgid() routines are available to get group entries. * The getgrent() has a separate definition, HAS_GETGRENT. */ #define HAS_GROUP /**/ /* HAS_PASSWD * This symbol, if defined, indicates that the getpwnam() and * getpwuid() routines are available to get password entries. * The getpwent() has a separate definition, HAS_GETPWENT. */ #define HAS_PASSWD /**/ #define HAS_KILL #define HAS_WAIT #endif /* !PERL_MICRO */ /* USEMYBINMODE * This symbol, if defined, indicates that the program should * use the routine my_binmode(FILE *fp, char iotype) to insure * that a file is in "binary" mode -- that is, that no translation * of bytes occurs on read or write operations. */ #undef USEMYBINMODE /* Stat_t: * This symbol holds the type used to declare buffers for information * returned by stat(). It's usually just struct stat. It may be necessary * to include and to get any typedef'ed * information. */ #define Stat_t struct stat /* USE_STAT_RDEV: * This symbol is defined if this system has a stat structure declaring * st_rdev */ #define USE_STAT_RDEV /**/ /* ACME_MESS: * This symbol, if defined, indicates that error messages should be * should be generated in a format that allows the use of the Acme * GUI/editor's autofind feature. */ #undef ACME_MESS /**/ /* UNLINK_ALL_VERSIONS: * This symbol, if defined, indicates that the program should arrange * to remove all versions of a file if unlink() is called. This is * probably only relevant for VMS. */ /* #define UNLINK_ALL_VERSIONS / **/ /* VMS: * This symbol, if defined, indicates that the program is running under * VMS. It is currently automatically set by cpps running under VMS, * and is included here for completeness only. */ /* #define VMS / **/ /* ALTERNATE_SHEBANG: * This symbol, if defined, contains a "magic" string which may be used * as the first line of a Perl program designed to be executed directly * by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG * begins with a character other then #, then Perl will only treat * it as a command line if it finds the string "perl" in the first * word; otherwise it's treated as the first line of code in the script. * (IOW, Perl won't hand off to another interpreter via an alternate * shebang sequence that might be legal Perl code.) */ /* #define ALTERNATE_SHEBANG "#!" / **/ # include #ifndef SIGABRT # define SIGABRT SIGILL #endif #ifndef SIGILL # define SIGILL 6 /* blech */ #endif #define ABORT() kill(PerlProc_getpid(),SIGABRT); /* * fwrite1() should be a routine with the same calling sequence as fwrite(), * but which outputs all of the bytes requested as a single stream (unlike * fwrite() itself, which on some systems outputs several distinct records * if the number_of_items parameter is >1). */ #define fwrite1 fwrite #define Stat(fname,bufptr) stat((fname),(bufptr)) #define Fstat(fd,bufptr) fstat((fd),(bufptr)) #define Fflush(fp) fflush(fp) #define Mkdir(path,mode) mkdir((path),(mode)) #ifndef PERL_SYS_INIT_BODY # define PERL_SYS_INIT_BODY(c,v) \ MALLOC_CHECK_TAINT2(*c,*v) PERL_FPU_INIT; PERLIO_INIT; MALLOC_INIT #endif #ifndef PERL_SYS_TERM_BODY # define PERL_SYS_TERM_BODY() \ HINTS_REFCNT_TERM; OP_CHECK_MUTEX_TERM; \ OP_REFCNT_TERM; PERLIO_TERM; MALLOC_TERM; #endif #define BIT_BUCKET "/dev/null" #define dXSUB_SYS #ifndef NO_ENVIRON_ARRAY #define USE_ENVIRON_ARRAY #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ' overload.hnuW+A/* -*- buffer-read-only: t -*- * * overload.h * * Copyright (C) 1997, 1998, 2000, 2001, 2005, 2006, 2007, 2011 * by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/overload.pl. * Any changes made here will be lost! */ enum { fallback_amg, /* 0x00 fallback */ to_sv_amg, /* 0x01 ${} */ to_av_amg, /* 0x02 @{} */ to_hv_amg, /* 0x03 %{} */ to_gv_amg, /* 0x04 *{} */ to_cv_amg, /* 0x05 &{} */ inc_amg, /* 0x06 ++ */ dec_amg, /* 0x07 -- */ bool__amg, /* 0x08 bool */ numer_amg, /* 0x09 0+ */ string_amg, /* 0x0a "" */ not_amg, /* 0x0b ! */ copy_amg, /* 0x0c = */ abs_amg, /* 0x0d abs */ neg_amg, /* 0x0e neg */ iter_amg, /* 0x0f <> */ int_amg, /* 0x10 int */ lt_amg, /* 0x11 < */ le_amg, /* 0x12 <= */ gt_amg, /* 0x13 > */ ge_amg, /* 0x14 >= */ eq_amg, /* 0x15 == */ ne_amg, /* 0x16 != */ slt_amg, /* 0x17 lt */ sle_amg, /* 0x18 le */ sgt_amg, /* 0x19 gt */ sge_amg, /* 0x1a ge */ seq_amg, /* 0x1b eq */ sne_amg, /* 0x1c ne */ nomethod_amg, /* 0x1d nomethod */ add_amg, /* 0x1e + */ add_ass_amg, /* 0x1f += */ subtr_amg, /* 0x20 - */ subtr_ass_amg, /* 0x21 -= */ mult_amg, /* 0x22 * */ mult_ass_amg, /* 0x23 *= */ div_amg, /* 0x24 / */ div_ass_amg, /* 0x25 /= */ modulo_amg, /* 0x26 % */ modulo_ass_amg, /* 0x27 %= */ pow_amg, /* 0x28 ** */ pow_ass_amg, /* 0x29 **= */ lshift_amg, /* 0x2a << */ lshift_ass_amg, /* 0x2b <<= */ rshift_amg, /* 0x2c >> */ rshift_ass_amg, /* 0x2d >>= */ band_amg, /* 0x2e & */ band_ass_amg, /* 0x2f &= */ bor_amg, /* 0x30 | */ bor_ass_amg, /* 0x31 |= */ bxor_amg, /* 0x32 ^ */ bxor_ass_amg, /* 0x33 ^= */ ncmp_amg, /* 0x34 <=> */ scmp_amg, /* 0x35 cmp */ compl_amg, /* 0x36 ~ */ atan2_amg, /* 0x37 atan2 */ cos_amg, /* 0x38 cos */ sin_amg, /* 0x39 sin */ exp_amg, /* 0x3a exp */ log_amg, /* 0x3b log */ sqrt_amg, /* 0x3c sqrt */ repeat_amg, /* 0x3d x */ repeat_ass_amg, /* 0x3e x= */ concat_amg, /* 0x3f . */ concat_ass_amg, /* 0x40 .= */ smart_amg, /* 0x41 ~~ */ ftest_amg, /* 0x42 -X */ regexp_amg, /* 0x43 qr */ DESTROY_amg, /* 0x44 DESTROY */ max_amg_code /* Do not leave a trailing comma here. C9X allows it, C89 doesn't. */ }; #define NofAMmeth max_amg_code /* ex: set ro: */ PKZs}t.{.{regcharclass.hnuW+A/* -*- buffer-read-only: t -*- * * regcharclass.h * * Copyright (C) 2007, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/regcharclass.pl. * Any changes made here will be lost! */ /* LNBREAK: Line Break: \R "\x0D\x0A" # CRLF - Network (Windows) line ending 0x0A # LF | LINE FEED 0x0B # VT | VERTICAL TAB 0x0C # FF | FORM FEED 0x0D # CR | CARRIAGE RETURN 0x85 # NEL | NEXT LINE 0x2028 # LINE SEPARATOR 0x2029 # PARAGRAPH SEPARATOR */ /*** GENERATED CODE ***/ #define is_LNBREAK(s,is_utf8) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ #define is_LNBREAK_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( is_utf8 ) ? \ ( ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( !( is_utf8 ) ) ? \ ( 0x85 == ((U8*)s)[0] ) \ : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_utf8(s) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_utf8_safe(s,e) \ ( ((e)-(s) > 2) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) \ : 0 ) /*** GENERATED CODE ***/ #define is_LNBREAK_latin1(s) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ #define is_LNBREAK_latin1_safe(s,e) \ ( ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0C ) ? 1 \ : ( 0x0D == ((U8*)s)[0] ) ? \ ( ( 0x0A == ((U8*)s)[1] ) ? 2 : 1 ) \ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x85 == ((U8*)s)[0] )\ : 0 ) /* HORIZWS: Horizontal Whitespace: \h \H 0x09 # HT 0x20 # SPACE 0xa0 # NBSP 0x1680 # OGHAM SPACE MARK 0x180e # MONGOLIAN VOWEL SEPARATOR 0x2000 # EN QUAD 0x2001 # EM QUAD 0x2002 # EN SPACE 0x2003 # EM SPACE 0x2004 # THREE-PER-EM SPACE 0x2005 # FOUR-PER-EM SPACE 0x2006 # SIX-PER-EM SPACE 0x2007 # FIGURE SPACE 0x2008 # PUNCTUATION SPACE 0x2009 # THIN SPACE 0x200A # HAIR SPACE 0x202f # NARROW NO-BREAK SPACE 0x205f # MEDIUM MATHEMATICAL SPACE 0x3000 # IDEOGRAPHIC SPACE */ /*** GENERATED CODE ***/ #define is_HORIZWS(s,is_utf8) \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xA0 == ((U8*)s)[1] ) ? \ ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ : ( 0x81 == ((U8*)s)[1] ) ? \ ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE3 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : 0 ) \ : ( 0xA0 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ #define is_HORIZWS_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xA0 == ((U8*)s)[1] ) ? \ ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ : ( 0x81 == ((U8*)s)[1] ) ? \ ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE3 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ( 0xA0 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( is_utf8 ) ? \ ( ( ( 0xC2 == ((U8*)s)[0] ) && ( 0xA0 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ( 0xA0 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( !( is_utf8 ) ) ? \ ( 0xA0 == ((U8*)s)[0] ) \ : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_utf8(s) \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xA0 == ((U8*)s)[1] ) ? \ ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ : ( 0x81 == ((U8*)s)[1] ) ? \ ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE3 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_utf8_safe(s,e) \ ( ((e)-(s) > 2) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0x9A == ((U8*)s)[1] ) ? \ ( ( 0x80 == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xA0 == ((U8*)s)[1] ) ? \ ( ( 0x8E == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( 0x80 == ((U8*)s)[1] ) ? \ ( ( ( 0x80 <= ((U8*)s)[2] && ((U8*)s)[2] <= 0x8A ) || 0xAF == ((U8*)s)[2] ) ? 3 : 0 )\ : ( 0x81 == ((U8*)s)[1] ) ? \ ( ( 0x9F == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : ( 0xE3 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0x80 == ((U8*)s)[2] ) ) ? 3 : 0 ) \ : 0 ) \ : ((e)-(s) > 1) ? \ ( ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0xA0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] ) \ : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_latin1(s) \ ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] || 0xA0 == ((U8*)s)[0] ) /*** GENERATED CODE ***/ #define is_HORIZWS_latin1_safe(s,e) \ ( ((e)-(s) > 0) ? \ ( 0x09 == ((U8*)s)[0] || 0x20 == ((U8*)s)[0] || 0xA0 == ((U8*)s)[0] ) \ : 0 ) /*** GENERATED CODE ***/ #define is_HORIZWS_cp(cp) \ ( 0x09 == cp || ( 0x09 < cp && \ ( 0x20 == cp || ( 0x20 < cp && \ ( 0xA0 == cp || ( 0xA0 < cp && \ ( 0x1680 == cp || ( 0x1680 < cp && \ ( 0x180E == cp || ( 0x180E < cp && \ ( ( 0x2000 <= cp && cp <= 0x200A ) || ( 0x200A < cp && \ ( 0x202F == cp || ( 0x202F < cp && \ ( 0x205F == cp || ( 0x205F < cp && \ 0x3000 == cp ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) /* VERTWS: Vertical Whitespace: \v \V 0x0A # LF 0x0B # VT 0x0C # FF 0x0D # CR 0x85 # NEL 0x2028 # LINE SEPARATOR 0x2029 # PARAGRAPH SEPARATOR */ /*** GENERATED CODE ***/ #define is_VERTWS(s,is_utf8) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ #define is_VERTWS_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( is_utf8 ) ? \ ( ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( is_utf8 ) ? \ ( ( ( 0xC2 == ((U8*)s)[0] ) && ( 0x85 == ((U8*)s)[1] ) ) ? 2 : 0 ) \ : ( 0x85 == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( !( is_utf8 ) ) ? \ ( 0x85 == ((U8*)s)[0] ) \ : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define is_VERTWS_utf8(s) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) /*** GENERATED CODE ***/ #define is_VERTWS_utf8_safe(s,e) \ ( ((e)-(s) > 2) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE2 == ((U8*)s)[0] ) ? \ ( ( ( 0x80 == ((U8*)s)[1] ) && ( 0xA8 == ((U8*)s)[2] || 0xA9 == ((U8*)s)[2] ) ) ? 3 : 0 )\ : 0 ) \ : ((e)-(s) > 1) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) ? 1 \ : ( 0xC2 == ((U8*)s)[0] ) ? \ ( ( 0x85 == ((U8*)s)[1] ) ? 2 : 0 ) \ : 0 ) \ : ((e)-(s) > 0) ? \ ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) \ : 0 ) /*** GENERATED CODE ***/ #define is_VERTWS_latin1(s) \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x85 == ((U8*)s)[0] ) /*** GENERATED CODE ***/ #define is_VERTWS_latin1_safe(s,e) \ ( ((e)-(s) > 0) ? \ ( ( 0x0A <= ((U8*)s)[0] && ((U8*)s)[0] <= 0x0D ) || 0x85 == ((U8*)s)[0] )\ : 0 ) /*** GENERATED CODE ***/ #define is_VERTWS_cp(cp) \ ( ( 0x0A <= cp && cp <= 0x0D ) || ( 0x0D < cp && \ ( 0x85 == cp || ( 0x85 < cp && \ ( 0x2028 == cp || ( 0x2028 < cp && \ 0x2029 == cp ) ) ) ) ) ) /* TRICKYFOLD: Problematic fold case letters. When adding to this list, also should add them to regcomp.c and fold_grind.t 0x00DF # LATIN SMALL LETTER SHARP S 0x0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS 0x03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS 0x1E9E # LATIN CAPITAL LETTER SHARP S, because maps to same as 00DF 0x1FD3 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA; maps same as 0390 0x1FE3 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA; maps same as 03B0 */ /*** GENERATED CODE ***/ #define is_TRICKYFOLD(s,is_utf8) \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] || 0xA3 == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ) /*** GENERATED CODE ***/ #define is_TRICKYFOLD_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? 3 : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] || 0xA3 == ((U8*)s)[2] ) ? 3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ) \ : ((e)-(s) > 1) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 2 : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] || 0xB0 == ((U8*)s)[1] ) ? 2 : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ) \ : ((e)-(s) > 0) ? \ ( ( !( is_utf8 ) ) ? \ ( 0xDF == ((U8*)s)[0] ) \ : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define is_TRICKYFOLD_cp(cp) \ ( 0xDF == cp || ( 0xDF < cp && \ ( 0x390 == cp || ( 0x390 < cp && \ ( 0x3B0 == cp || ( 0x3B0 < cp && \ ( 0x1E9E == cp || ( 0x1E9E < cp && \ ( 0x1FD3 == cp || ( 0x1FD3 < cp && \ 0x1FE3 == cp ) ) ) ) ) ) ) ) ) ) /*** GENERATED CODE ***/ #define what_TRICKYFOLD(s,is_utf8) \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? 0x1E9E : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] ) ? 0x1FD3 \ : ( 0xA3 == ((U8*)s)[2] ) ? 0x1FE3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) /*** GENERATED CODE ***/ #define what_TRICKYFOLD_safe(s,e,is_utf8) \ ( ((e)-(s) > 2) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? 0x1E9E : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] ) ? 0x1FD3 \ : ( 0xA3 == ((U8*)s)[2] ) ? 0x1FE3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) \ : ((e)-(s) > 1) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? 0x3B0 : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? 0xDF : 0 ) \ : ((e)-(s) > 0) ? \ ( ( ( !( is_utf8 ) ) && ( 0xDF == ((U8*)s)[0] ) ) ? 0xDF : 0 ) \ : 0 ) /*** GENERATED CODE ***/ #define what_len_TRICKYFOLD(s,is_utf8,len) \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? len=3, 0x1E9E : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] ) ? len=3, 0x1FD3 \ : ( 0xA3 == ((U8*)s)[2] ) ? len=3, 0x1FE3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) /*** GENERATED CODE ***/ #define what_len_TRICKYFOLD_safe(s,e,is_utf8,len) \ ( ((e)-(s) > 2) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ : ( 0xE1 == ((U8*)s)[0] ) ? \ ( ( 0xBA == ((U8*)s)[1] ) ? \ ( ( 0x9E == ((U8*)s)[2] ) ? len=3, 0x1E9E : 0 ) \ : ( 0xBF == ((U8*)s)[1] ) ? \ ( ( 0x93 == ((U8*)s)[2] ) ? len=3, 0x1FD3 \ : ( 0xA3 == ((U8*)s)[2] ) ? len=3, 0x1FE3 : 0 ) \ : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) \ : ((e)-(s) > 1) ? \ ( ( is_utf8 ) ? \ ( ( 0xC3 == ((U8*)s)[0] ) ? \ ( ( 0x9F == ((U8*)s)[1] ) ? len=2, 0xDF : 0 ) \ : ( 0xCE == ((U8*)s)[0] ) ? \ ( ( 0x90 == ((U8*)s)[1] ) ? len=2, 0x390 \ : ( 0xB0 == ((U8*)s)[1] ) ? len=2, 0x3B0 : 0 ) \ : 0 ) \ : ( 0xDF == ((U8*)s)[0] ) ? len=1, 0xDF : 0 ) \ : ((e)-(s) > 0) ? \ ( ( ( !( is_utf8 ) ) && ( 0xDF == ((U8*)s)[0] ) ) ? len=1, 0xDF : 0 ) \ : 0 ) /* ex: set ro: */ PKZ5Bperly.hnuW+A/* -*- buffer-read-only: t -*- !!!!!!! DO NOT EDIT THIS FILE !!!!!!! This file is built by regen_perly.pl from perly.y. Any changes made here will be lost! */ #ifdef PERL_CORE /* A Bison parser, made by GNU Bison 2.3. */ /* Skeleton interface for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE /* Put the tokens into the symbol table, so that GDB and other debuggers know about them. */ enum yytokentype { GRAMPROG = 258, GRAMEXPR = 259, GRAMBLOCK = 260, GRAMBARESTMT = 261, GRAMFULLSTMT = 262, GRAMSTMTSEQ = 263, WORD = 264, METHOD = 265, FUNCMETH = 266, THING = 267, PMFUNC = 268, PRIVATEREF = 269, QWLIST = 270, FUNC0OP = 271, FUNC0SUB = 272, UNIOPSUB = 273, LSTOPSUB = 274, PLUGEXPR = 275, PLUGSTMT = 276, LABEL = 277, FORMAT = 278, SUB = 279, ANONSUB = 280, PACKAGE = 281, USE = 282, WHILE = 283, UNTIL = 284, IF = 285, UNLESS = 286, ELSE = 287, ELSIF = 288, CONTINUE = 289, FOR = 290, GIVEN = 291, WHEN = 292, DEFAULT = 293, LOOPEX = 294, DOTDOT = 295, YADAYADA = 296, FUNC0 = 297, FUNC1 = 298, FUNC = 299, UNIOP = 300, LSTOP = 301, RELOP = 302, EQOP = 303, MULOP = 304, ADDOP = 305, DOLSHARP = 306, DO = 307, HASHBRACK = 308, NOAMP = 309, LOCAL = 310, MY = 311, MYSUB = 312, REQUIRE = 313, COLONATTR = 314, PREC_LOW = 315, DOROP = 316, OROP = 317, ANDOP = 318, NOTOP = 319, ASSIGNOP = 320, DORDOR = 321, OROR = 322, ANDAND = 323, BITOROP = 324, BITANDOP = 325, SHIFTOP = 326, MATCHOP = 327, REFGEN = 328, UMINUS = 329, POWOP = 330, POSTDEC = 331, POSTINC = 332, PREDEC = 333, PREINC = 334, ARROW = 335, PEG = 336 }; #endif /* Tokens. */ #define GRAMPROG 258 #define GRAMEXPR 259 #define GRAMBLOCK 260 #define GRAMBARESTMT 261 #define GRAMFULLSTMT 262 #define GRAMSTMTSEQ 263 #define WORD 264 #define METHOD 265 #define FUNCMETH 266 #define THING 267 #define PMFUNC 268 #define PRIVATEREF 269 #define QWLIST 270 #define FUNC0OP 271 #define FUNC0SUB 272 #define UNIOPSUB 273 #define LSTOPSUB 274 #define PLUGEXPR 275 #define PLUGSTMT 276 #define LABEL 277 #define FORMAT 278 #define SUB 279 #define ANONSUB 280 #define PACKAGE 281 #define USE 282 #define WHILE 283 #define UNTIL 284 #define IF 285 #define UNLESS 286 #define ELSE 287 #define ELSIF 288 #define CONTINUE 289 #define FOR 290 #define GIVEN 291 #define WHEN 292 #define DEFAULT 293 #define LOOPEX 294 #define DOTDOT 295 #define YADAYADA 296 #define FUNC0 297 #define FUNC1 298 #define FUNC 299 #define UNIOP 300 #define LSTOP 301 #define RELOP 302 #define EQOP 303 #define MULOP 304 #define ADDOP 305 #define DOLSHARP 306 #define DO 307 #define HASHBRACK 308 #define NOAMP 309 #define LOCAL 310 #define MY 311 #define MYSUB 312 #define REQUIRE 313 #define COLONATTR 314 #define PREC_LOW 315 #define DOROP 316 #define OROP 317 #define ANDOP 318 #define NOTOP 319 #define ASSIGNOP 320 #define DORDOR 321 #define OROR 322 #define ANDAND 323 #define BITOROP 324 #define BITANDOP 325 #define SHIFTOP 326 #define MATCHOP 327 #define REFGEN 328 #define UMINUS 329 #define POWOP 330 #define POSTDEC 331 #define POSTINC 332 #define PREDEC 333 #define PREINC 334 #define ARROW 335 #define PEG 336 #endif /* PERL_CORE */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE { I32 ival; /* __DEFAULT__ (marker for regen_perly.pl; must always be 1st union member) */ char *pval; OP *opval; GV *gvval; #ifdef PERL_IN_MADLY_C TOKEN* p_tkval; TOKEN* i_tkval; #else char *p_tkval; I32 i_tkval; #endif #ifdef PERL_MAD TOKEN* tkval; #endif } /* Line 1529 of yacc.c. */ YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif /* Generated from: * 047d7d5048e78a17bc586b7bb9a0f0e9dedd5cd43b30e486482b1ff8f955ddcb perly.y * 53f57d7143a42b3c008841a14d158bcf9cab64b2904b07ef5e95051fe9a8a875 regen_perly.pl * ex: set ro: */ PKZЊ3parser.hnuW+A/* parser.h * * Copyright (c) 2006, 2007, 2009, 2010, 2011 Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * This file defines the layout of the parser object used by the parser * and lexer (perly.c, toke.c). */ #define YYEMPTY (-2) typedef struct { YYSTYPE val; /* semantic value */ short state; I32 savestack_ix; /* size of savestack at this state */ CV *compcv; /* value of PL_compcv when this value was created */ #ifdef DEBUGGING const char *name; /* token/rule name for -Dpv */ #endif } yy_stack_frame; typedef struct yy_parser { /* parser state */ struct yy_parser *old_parser; /* previous value of PL_parser */ YYSTYPE yylval; /* value of lookahead symbol, set by yylex() */ int yychar; /* The lookahead symbol. */ /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; int stack_size; int yylen; /* length of active reduction */ yy_stack_frame *stack; /* base of stack */ yy_stack_frame *ps; /* current stack frame */ /* lexer state */ I32 lex_brackets; /* square and curly bracket count */ I32 lex_casemods; /* casemod count */ char *lex_brackstack;/* what kind of brackets to pop */ char *lex_casestack; /* what kind of case mods in effect */ U8 lex_defer; /* state after determined token */ bool lex_dojoin; /* doing an array interpolation */ U8 lex_expect; /* expect after determined token */ U8 expect; /* how to interpret ambiguous tokens */ I32 lex_formbrack; /* bracket count at outer format level */ OP *lex_inpat; /* in pattern $) and $| are special */ OP *lex_op; /* extra info to pass back on op */ SV *lex_repl; /* runtime replacement from s/// */ U16 lex_inwhat; /* what kind of quoting are we in */ OPCODE last_lop_op; /* last list operator */ I32 lex_starts; /* how many interps done on level */ SV *lex_stuff; /* runtime pattern from m// or s/// */ I32 multi_start; /* 1st line of multi-line string */ I32 multi_end; /* last line of multi-line string */ char multi_open; /* delimiter of said string */ char multi_close; /* delimiter of said string */ char pending_ident; /* pending identifier lookup */ bool preambled; I32 lex_allbrackets;/* (), [], {}, ?: bracket count */ SUBLEXINFO sublex_info; SV *linestr; /* current chunk of src text */ char *bufptr; char *oldbufptr; char *oldoldbufptr; char *bufend; char *linestart; /* beginning of most recently read line */ char *last_uni; /* position of last named-unary op */ char *last_lop; /* position of last list operator */ line_t copline; /* current line number */ U16 in_my; /* we're compiling a "my"/"our" declaration */ U8 lex_state; /* next token is determined */ U8 error_count; /* how many compile errors so far, max 10 */ HV *in_my_stash; /* declared class of this "my" declaration */ PerlIO *rsfp; /* current source file pointer */ AV *rsfp_filters; /* holds chain of active source filters */ #ifdef PERL_MAD SV *endwhite; I32 faketokens; I32 lasttoke; SV *nextwhite; I32 realtokenstart; SV *skipwhite; SV *thisclose; MADPROP * thismad; SV *thisopen; SV *thisstuff; SV *thistoken; SV *thiswhite; /* What we know when we're in LEX_KNOWNEXT state. */ NEXTTOKE nexttoke[5]; /* value of next token, if any */ I32 curforce; #else YYSTYPE nextval[5]; /* value of next token, if any */ I32 nexttype[5]; /* type of next token */ I32 nexttoke; #endif COP *saved_curcop; /* the previous PL_curcop */ char tokenbuf[256]; U8 lex_fakeeof; /* precedence at which to fake EOF */ U8 lex_flags; PERL_BITFIELD16 in_pod:1; /* lexer is within a =pod section */ PERL_BITFIELD16 filtered:1; /* source filters in evalbytes */ } yy_parser; /* flags for lexer API */ #define LEX_STUFF_UTF8 0x00000001 #define LEX_KEEP_PREVIOUS 0x00000002 #ifdef PERL_CORE # define LEX_START_SAME_FILTER 0x00000001 # define LEX_IGNORE_UTF8_HINTS 0x00000002 # define LEX_EVALBYTES 0x00000004 # define LEX_START_COPIED 0x00000008 # define LEX_DONT_CLOSE_RSFP 0x00000010 # define LEX_START_FLAGS \ (LEX_START_SAME_FILTER|LEX_START_COPIED \ |LEX_IGNORE_UTF8_HINTS|LEX_EVALBYTES|LEX_DONT_CLOSE_RSFP) #endif /* flags for parser API */ #define PARSE_OPTIONAL 0x00000001 /* values for lex_fakeeof */ enum { LEX_FAKEEOF_NEVER, /* don't fake EOF */ LEX_FAKEEOF_CLOSING, /* fake EOF at unmatched closing punctuation */ LEX_FAKEEOF_NONEXPR, /* ... and at token that can't be in expression */ LEX_FAKEEOF_LOWLOGIC, /* ... and at low-precedence logic operator */ LEX_FAKEEOF_COMMA, /* ... and at comma */ LEX_FAKEEOF_ASSIGN, /* ... and at assignment operator */ LEX_FAKEEOF_IFELSE, /* ... and at ?: operator */ LEX_FAKEEOF_RANGE, /* ... and at range operator */ LEX_FAKEEOF_LOGIC, /* ... and at logic operator */ LEX_FAKEEOF_BITWISE, /* ... and at bitwise operator */ LEX_FAKEEOF_COMPARE, /* ... and at comparison operator */ LEX_FAKEEOF_MAX }; /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZd֔$$ mg_vtable.hnuW+A/* -*- buffer-read-only: t -*- * * mg_vtable.h * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/mg_vtable.pl. * Any changes made here will be lost! */ /* These constants should be used in preference to raw characters * when using magic. Note that some perl guts still assume * certain character properties of these constants, namely that * isUPPER() and toLOWER() may do useful mappings. */ #define PERL_MAGIC_sv '\0' /* Special scalar variable */ #define PERL_MAGIC_arylen '#' /* Array length ($#ary) */ #define PERL_MAGIC_rhash '%' /* extra data for restricted hashes */ #define PERL_MAGIC_pos '.' /* pos() lvalue */ #define PERL_MAGIC_symtab ':' /* extra data for symbol tables */ #define PERL_MAGIC_backref '<' /* for weak ref data */ #define PERL_MAGIC_arylen_p '@' /* to move arylen out of XPVAV */ #define PERL_MAGIC_overload 'A' /* %OVERLOAD hash */ #define PERL_MAGIC_overload_elem 'a' /* %OVERLOAD hash element */ #define PERL_MAGIC_bm 'B' /* Boyer-Moore (fast string search) */ #define PERL_MAGIC_overload_table 'c' /* Holds overload table (AMT) on stash */ #define PERL_MAGIC_regdata 'D' /* Regex match position data (@+ and @- vars) */ #define PERL_MAGIC_regdatum 'd' /* Regex match position data element */ #define PERL_MAGIC_env 'E' /* %ENV hash */ #define PERL_MAGIC_envelem 'e' /* %ENV hash element */ #define PERL_MAGIC_fm 'f' /* Formline ('compiled' format) */ #define PERL_MAGIC_study 'G' /* study()ed string */ #define PERL_MAGIC_regex_global 'g' /* m//g target */ #define PERL_MAGIC_hints 'H' /* %^H hash */ #define PERL_MAGIC_hintselem 'h' /* %^H hash element */ #define PERL_MAGIC_isa 'I' /* @ISA array */ #define PERL_MAGIC_isaelem 'i' /* @ISA array element */ #define PERL_MAGIC_nkeys 'k' /* scalar(keys()) lvalue */ #define PERL_MAGIC_dbfile 'L' /* Debugger %_",(f)[1]))))) #else /* !VMS */ # if defined(WIN32) || defined(__CYGWIN__) # define PERL_FILE_IS_ABSOLUTE(f) \ (*(f) == '/' || *(f) == '\\' /* UNC/rooted path */ \ || ((f)[0] && (f)[1] == ':')) /* drive name */ # else /* !WIN32 */ # ifdef NETWARE # define PERL_FILE_IS_ABSOLUTE(f) \ (((f)[0] && (f)[1] == ':') /* drive name */ \ || ((f)[0] == '\\' && (f)[1] == '\\') /* UNC path */ \ || ((f)[3] == ':')) /* volume name, currently only sys */ # else /* !NETWARE */ # if defined(DOSISH) || defined(EPOC) || defined(__SYMBIAN32__) # define PERL_FILE_IS_ABSOLUTE(f) \ (*(f) == '/' \ || ((f)[0] && (f)[1] == ':')) /* drive name */ # else /* NEITHER DOSISH NOR EPOCISH NOR SYMBIANISH */ # define PERL_FILE_IS_ABSOLUTE(f) (*(f) == '/') # endif /* DOSISH */ # endif /* NETWARE */ # endif /* WIN32 */ #endif /* VMS */ /* =for apidoc ibcmp This is a synonym for (! foldEQ()) =for apidoc ibcmp_locale This is a synonym for (! foldEQ_locale()) =cut */ #define ibcmp(s1, s2, len) cBOOL(! foldEQ(s1, s2, len)) #define ibcmp_locale(s1, s2, len) cBOOL(! foldEQ_locale(s1, s2, len)) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZk7 7 opnames.hnuW+A/* -*- buffer-read-only: t -*- * * opnames.h * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, * 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/opcode.pl from its data. * Any changes made here will be lost! */ typedef enum opcode { OP_NULL = 0, OP_STUB = 1, OP_SCALAR = 2, OP_PUSHMARK = 3, OP_WANTARRAY = 4, OP_CONST = 5, OP_GVSV = 6, OP_GV = 7, OP_GELEM = 8, OP_PADSV = 9, OP_PADAV = 10, OP_PADHV = 11, OP_PADANY = 12, OP_PUSHRE = 13, OP_RV2GV = 14, OP_RV2SV = 15, OP_AV2ARYLEN = 16, OP_RV2CV = 17, OP_ANONCODE = 18, OP_PROTOTYPE = 19, OP_REFGEN = 20, OP_SREFGEN = 21, OP_REF = 22, OP_BLESS = 23, OP_BACKTICK = 24, OP_GLOB = 25, OP_READLINE = 26, OP_RCATLINE = 27, OP_REGCMAYBE = 28, OP_REGCRESET = 29, OP_REGCOMP = 30, OP_MATCH = 31, OP_QR = 32, OP_SUBST = 33, OP_SUBSTCONT = 34, OP_TRANS = 35, OP_TRANSR = 36, OP_SASSIGN = 37, OP_AASSIGN = 38, OP_CHOP = 39, OP_SCHOP = 40, OP_CHOMP = 41, OP_SCHOMP = 42, OP_DEFINED = 43, OP_UNDEF = 44, OP_STUDY = 45, OP_POS = 46, OP_PREINC = 47, OP_I_PREINC = 48, OP_PREDEC = 49, OP_I_PREDEC = 50, OP_POSTINC = 51, OP_I_POSTINC = 52, OP_POSTDEC = 53, OP_I_POSTDEC = 54, OP_POW = 55, OP_MULTIPLY = 56, OP_I_MULTIPLY = 57, OP_DIVIDE = 58, OP_I_DIVIDE = 59, OP_MODULO = 60, OP_I_MODULO = 61, OP_REPEAT = 62, OP_ADD = 63, OP_I_ADD = 64, OP_SUBTRACT = 65, OP_I_SUBTRACT = 66, OP_CONCAT = 67, OP_STRINGIFY = 68, OP_LEFT_SHIFT = 69, OP_RIGHT_SHIFT = 70, OP_LT = 71, OP_I_LT = 72, OP_GT = 73, OP_I_GT = 74, OP_LE = 75, OP_I_LE = 76, OP_GE = 77, OP_I_GE = 78, OP_EQ = 79, OP_I_EQ = 80, OP_NE = 81, OP_I_NE = 82, OP_NCMP = 83, OP_I_NCMP = 84, OP_SLT = 85, OP_SGT = 86, OP_SLE = 87, OP_SGE = 88, OP_SEQ = 89, OP_SNE = 90, OP_SCMP = 91, OP_BIT_AND = 92, OP_BIT_XOR = 93, OP_BIT_OR = 94, OP_NEGATE = 95, OP_I_NEGATE = 96, OP_NOT = 97, OP_COMPLEMENT = 98, OP_SMARTMATCH = 99, OP_ATAN2 = 100, OP_SIN = 101, OP_COS = 102, OP_RAND = 103, OP_SRAND = 104, OP_EXP = 105, OP_LOG = 106, OP_SQRT = 107, OP_INT = 108, OP_HEX = 109, OP_OCT = 110, OP_ABS = 111, OP_LENGTH = 112, OP_SUBSTR = 113, OP_VEC = 114, OP_INDEX = 115, OP_RINDEX = 116, OP_SPRINTF = 117, OP_FORMLINE = 118, OP_ORD = 119, OP_CHR = 120, OP_CRYPT = 121, OP_UCFIRST = 122, OP_LCFIRST = 123, OP_UC = 124, OP_LC = 125, OP_QUOTEMETA = 126, OP_RV2AV = 127, OP_AELEMFAST = 128, OP_AELEMFAST_LEX = 129, OP_AELEM = 130, OP_ASLICE = 131, OP_AEACH = 132, OP_AKEYS = 133, OP_AVALUES = 134, OP_EACH = 135, OP_VALUES = 136, OP_KEYS = 137, OP_DELETE = 138, OP_EXISTS = 139, OP_RV2HV = 140, OP_HELEM = 141, OP_HSLICE = 142, OP_BOOLKEYS = 143, OP_UNPACK = 144, OP_PACK = 145, OP_SPLIT = 146, OP_JOIN = 147, OP_LIST = 148, OP_LSLICE = 149, OP_ANONLIST = 150, OP_ANONHASH = 151, OP_SPLICE = 152, OP_PUSH = 153, OP_POP = 154, OP_SHIFT = 155, OP_UNSHIFT = 156, OP_SORT = 157, OP_REVERSE = 158, OP_GREPSTART = 159, OP_GREPWHILE = 160, OP_MAPSTART = 161, OP_MAPWHILE = 162, OP_RANGE = 163, OP_FLIP = 164, OP_FLOP = 165, OP_AND = 166, OP_OR = 167, OP_XOR = 168, OP_DOR = 169, OP_COND_EXPR = 170, OP_ANDASSIGN = 171, OP_ORASSIGN = 172, OP_DORASSIGN = 173, OP_METHOD = 174, OP_ENTERSUB = 175, OP_LEAVESUB = 176, OP_LEAVESUBLV = 177, OP_CALLER = 178, OP_WARN = 179, OP_DIE = 180, OP_RESET = 181, OP_LINESEQ = 182, OP_NEXTSTATE = 183, OP_DBSTATE = 184, OP_UNSTACK = 185, OP_ENTER = 186, OP_LEAVE = 187, OP_SCOPE = 188, OP_ENTERITER = 189, OP_ITER = 190, OP_ENTERLOOP = 191, OP_LEAVELOOP = 192, OP_RETURN = 193, OP_LAST = 194, OP_NEXT = 195, OP_REDO = 196, OP_DUMP = 197, OP_GOTO = 198, OP_EXIT = 199, OP_METHOD_NAMED = 200, OP_ENTERGIVEN = 201, OP_LEAVEGIVEN = 202, OP_ENTERWHEN = 203, OP_LEAVEWHEN = 204, OP_BREAK = 205, OP_CONTINUE = 206, OP_OPEN = 207, OP_CLOSE = 208, OP_PIPE_OP = 209, OP_FILENO = 210, OP_UMASK = 211, OP_BINMODE = 212, OP_TIE = 213, OP_UNTIE = 214, OP_TIED = 215, OP_DBMOPEN = 216, OP_DBMCLOSE = 217, OP_SSELECT = 218, OP_SELECT = 219, OP_GETC = 220, OP_READ = 221, OP_ENTERWRITE = 222, OP_LEAVEWRITE = 223, OP_PRTF = 224, OP_PRINT = 225, OP_SAY = 226, OP_SYSOPEN = 227, OP_SYSSEEK = 228, OP_SYSREAD = 229, OP_SYSWRITE = 230, OP_EOF = 231, OP_TELL = 232, OP_SEEK = 233, OP_TRUNCATE = 234, OP_FCNTL = 235, OP_IOCTL = 236, OP_FLOCK = 237, OP_SEND = 238, OP_RECV = 239, OP_SOCKET = 240, OP_SOCKPAIR = 241, OP_BIND = 242, OP_CONNECT = 243, OP_LISTEN = 244, OP_ACCEPT = 245, OP_SHUTDOWN = 246, OP_GSOCKOPT = 247, OP_SSOCKOPT = 248, OP_GETSOCKNAME = 249, OP_GETPEERNAME = 250, OP_LSTAT = 251, OP_STAT = 252, OP_FTRREAD = 253, OP_FTRWRITE = 254, OP_FTREXEC = 255, OP_FTEREAD = 256, OP_FTEWRITE = 257, OP_FTEEXEC = 258, OP_FTIS = 259, OP_FTSIZE = 260, OP_FTMTIME = 261, OP_FTATIME = 262, OP_FTCTIME = 263, OP_FTROWNED = 264, OP_FTEOWNED = 265, OP_FTZERO = 266, OP_FTSOCK = 267, OP_FTCHR = 268, OP_FTBLK = 269, OP_FTFILE = 270, OP_FTDIR = 271, OP_FTPIPE = 272, OP_FTSUID = 273, OP_FTSGID = 274, OP_FTSVTX = 275, OP_FTLINK = 276, OP_FTTTY = 277, OP_FTTEXT = 278, OP_FTBINARY = 279, OP_CHDIR = 280, OP_CHOWN = 281, OP_CHROOT = 282, OP_UNLINK = 283, OP_CHMOD = 284, OP_UTIME = 285, OP_RENAME = 286, OP_LINK = 287, OP_SYMLINK = 288, OP_READLINK = 289, OP_MKDIR = 290, OP_RMDIR = 291, OP_OPEN_DIR = 292, OP_READDIR = 293, OP_TELLDIR = 294, OP_SEEKDIR = 295, OP_REWINDDIR = 296, OP_CLOSEDIR = 297, OP_FORK = 298, OP_WAIT = 299, OP_WAITPID = 300, OP_SYSTEM = 301, OP_EXEC = 302, OP_KILL = 303, OP_GETPPID = 304, OP_GETPGRP = 305, OP_SETPGRP = 306, OP_GETPRIORITY = 307, OP_SETPRIORITY = 308, OP_TIME = 309, OP_TMS = 310, OP_LOCALTIME = 311, OP_GMTIME = 312, OP_ALARM = 313, OP_SLEEP = 314, OP_SHMGET = 315, OP_SHMCTL = 316, OP_SHMREAD = 317, OP_SHMWRITE = 318, OP_MSGGET = 319, OP_MSGCTL = 320, OP_MSGSND = 321, OP_MSGRCV = 322, OP_SEMOP = 323, OP_SEMGET = 324, OP_SEMCTL = 325, OP_REQUIRE = 326, OP_DOFILE = 327, OP_HINTSEVAL = 328, OP_ENTEREVAL = 329, OP_LEAVEEVAL = 330, OP_ENTERTRY = 331, OP_LEAVETRY = 332, OP_GHBYNAME = 333, OP_GHBYADDR = 334, OP_GHOSTENT = 335, OP_GNBYNAME = 336, OP_GNBYADDR = 337, OP_GNETENT = 338, OP_GPBYNAME = 339, OP_GPBYNUMBER = 340, OP_GPROTOENT = 341, OP_GSBYNAME = 342, OP_GSBYPORT = 343, OP_GSERVENT = 344, OP_SHOSTENT = 345, OP_SNETENT = 346, OP_SPROTOENT = 347, OP_SSERVENT = 348, OP_EHOSTENT = 349, OP_ENETENT = 350, OP_EPROTOENT = 351, OP_ESERVENT = 352, OP_GPWNAM = 353, OP_GPWUID = 354, OP_GPWENT = 355, OP_SPWENT = 356, OP_EPWENT = 357, OP_GGRNAM = 358, OP_GGRGID = 359, OP_GGRENT = 360, OP_SGRENT = 361, OP_EGRENT = 362, OP_GETLOGIN = 363, OP_SYSCALL = 364, OP_LOCK = 365, OP_ONCE = 366, OP_CUSTOM = 367, OP_REACH = 368, OP_RKEYS = 369, OP_RVALUES = 370, OP_COREARGS = 371, OP_RUNCV = 372, OP_FC = 373, OP_max } opcode; #define MAXO 374 /* the OP_IS_* macros are optimized to a simple range check because all the member OPs are contiguous in regen/opcodes table. opcode.pl verifies the range contiguity, or generates an OR-equals expression */ #define OP_IS_SOCKET(op) \ ((op) >= OP_SEND && (op) <= OP_GETPEERNAME) #define OP_IS_FILETEST(op) \ ((op) >= OP_FTRREAD && (op) <= OP_FTBINARY) #define OP_IS_FILETEST_ACCESS(op) \ ((op) >= OP_FTRREAD && (op) <= OP_FTEEXEC) #define OP_IS_NUMCOMPARE(op) \ ((op) >= OP_LT && (op) <= OP_I_NCMP) #define OP_IS_DIRHOP(op) \ ((op) >= OP_READDIR && (op) <= OP_CLOSEDIR) /* ex: set ro: */ PKZG perlsfio.hnuW+A/* perlsfio.h * * Copyright (C) 1996, 1999, 2000, 2001, 2002, 2003, 2005, 2007, * by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* The next #ifdef should be redundant if Configure behaves ... */ #ifndef FILE #define FILE FILE #endif #ifdef I_SFIO #include #endif /* sfio 2000 changed _stdopen to _stdfdopen */ #if SFIO_VERSION >= 20000101L #define _stdopen _stdfdopen #endif extern Sfio_t* _stdopen _ARG_((int, const char*)); extern int _stdprintf _ARG_((const char*, ...)); #define PerlIO Sfio_t #define PerlIO_stderr() sfstderr #define PerlIO_stdout() sfstdout #define PerlIO_stdin() sfstdin #define PerlIO_isutf8(f) 0 #define PerlIO_printf sfprintf #define PerlIO_stdoutf _stdprintf #define PerlIO_vprintf(f,fmt,a) sfvprintf(f,fmt,a) #define PerlIO_read(f,buf,count) sfread(f,buf,count) #define PerlIO_write(f,buf,count) sfwrite(f,buf,count) #define PerlIO_open(path,mode) sfopen(NULL,path,mode) #define PerlIO_fdopen(fd,mode) _stdopen(fd,mode) #define PerlIO_reopen(path,mode,f) sfopen(f,path,mode) #define PerlIO_close(f) sfclose(f) #define PerlIO_puts(f,s) sfputr(f,s,-1) #define PerlIO_putc(f,c) sfputc(f,c) #define PerlIO_ungetc(f,c) sfungetc(f,c) #define PerlIO_sprintf sfsprintf #define PerlIO_getc(f) sfgetc(f) #define PerlIO_eof(f) sfeof(f) #define PerlIO_error(f) sferror(f) #define PerlIO_fileno(f) sffileno(f) #define PerlIO_clearerr(f) sfclrerr(f) #define PerlIO_flush(f) sfsync(f) #define PerlIO_tell(f) sftell(f) #define PerlIO_seek(f,o,w) sfseek(f,o,w) #define PerlIO_rewind(f) (void) sfseek((f),0L,0) #define PerlIO_tmpfile() sftmp(0) #define PerlIO_exportFILE(f,fl) Perl_croak(aTHX_ "Export to FILE * unimplemented") #define PerlIO_releaseFILE(p,f) Perl_croak(aTHX_ "Release of FILE * unimplemented") #define PerlIO_setlinebuf(f) sfset(f,SF_LINE,1) /* Now our interface to equivalent of Configure's FILE_xxx macros */ #define PerlIO_has_cntptr(f) 1 #define PerlIO_get_ptr(f) ((f)->next) #define PerlIO_get_cnt(f) ((f)->endr - (f)->next) #define PerlIO_canset_cnt(f) 1 #define PerlIO_fast_gets(f) 1 #define PerlIO_set_ptrcnt(f,p,c) STMT_START {(f)->next = (unsigned char *)(p); assert(PerlIO_get_cnt(f) == (c));} STMT_END #define PerlIO_set_cnt(f,c) STMT_START {(f)->next = (f)->endr - (c);} STMT_END #define PerlIO_has_base(f) 1 #define PerlIO_get_base(f) ((f)->data) #define PerlIO_get_bufsiz(f) ((f)->endr - (f)->data) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZlSLSL embedvar.hnuW+A/* -*- buffer-read-only: t -*- * * embedvar.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/embed.pl from data in embed.fnc, * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h. * Any changes made here will be lost! * * Edit those files and run 'make regen_headers' to effect changes. */ /* (Doing namespace management portably in C is really gross.) */ /* The following combinations of MULTIPLICITY and PERL_IMPLICIT_CONTEXT are supported: 1) none 2) MULTIPLICITY # supported for compatibility 3) MULTIPLICITY && PERL_IMPLICIT_CONTEXT All other combinations of these flags are errors. only #3 is supported directly, while #2 is a special case of #3 (supported by redefining vTHX appropriately). */ #if defined(MULTIPLICITY) /* cases 2 and 3 above */ # if defined(PERL_IMPLICIT_CONTEXT) # define vTHX aTHX # else # define vTHX PERL_GET_INTERP # endif #define PL_ASCII (vTHX->IASCII) #define PL_AboveLatin1 (vTHX->IAboveLatin1) #define PL_Argv (vTHX->IArgv) #define PL_Cmd (vTHX->ICmd) #define PL_DBcv (vTHX->IDBcv) #define PL_DBgv (vTHX->IDBgv) #define PL_DBline (vTHX->IDBline) #define PL_DBsignal (vTHX->IDBsignal) #define PL_DBsingle (vTHX->IDBsingle) #define PL_DBsub (vTHX->IDBsub) #define PL_DBtrace (vTHX->IDBtrace) #define PL_Dir (vTHX->IDir) #define PL_Env (vTHX->IEnv) #define PL_L1Cased (vTHX->IL1Cased) #define PL_L1PosixAlnum (vTHX->IL1PosixAlnum) #define PL_L1PosixAlpha (vTHX->IL1PosixAlpha) #define PL_L1PosixGraph (vTHX->IL1PosixGraph) #define PL_L1PosixLower (vTHX->IL1PosixLower) #define PL_L1PosixPrint (vTHX->IL1PosixPrint) #define PL_L1PosixPunct (vTHX->IL1PosixPunct) #define PL_L1PosixUpper (vTHX->IL1PosixUpper) #define PL_L1PosixWord (vTHX->IL1PosixWord) #define PL_LIO (vTHX->ILIO) #define PL_Latin1 (vTHX->ILatin1) #define PL_Mem (vTHX->IMem) #define PL_MemParse (vTHX->IMemParse) #define PL_MemShared (vTHX->IMemShared) #define PL_OpPtr (vTHX->IOpPtr) #define PL_OpSlab (vTHX->IOpSlab) #define PL_OpSpace (vTHX->IOpSpace) #define PL_PerlSpace (vTHX->IPerlSpace) #define PL_PosixAlnum (vTHX->IPosixAlnum) #define PL_PosixAlpha (vTHX->IPosixAlpha) #define PL_PosixBlank (vTHX->IPosixBlank) #define PL_PosixCntrl (vTHX->IPosixCntrl) #define PL_PosixDigit (vTHX->IPosixDigit) #define PL_PosixGraph (vTHX->IPosixGraph) #define PL_PosixLower (vTHX->IPosixLower) #define PL_PosixPrint (vTHX->IPosixPrint) #define PL_PosixPunct (vTHX->IPosixPunct) #define PL_PosixSpace (vTHX->IPosixSpace) #define PL_PosixUpper (vTHX->IPosixUpper) #define PL_PosixWord (vTHX->IPosixWord) #define PL_PosixXDigit (vTHX->IPosixXDigit) #define PL_Proc (vTHX->IProc) #define PL_Sock (vTHX->ISock) #define PL_StdIO (vTHX->IStdIO) #define PL_Sv (vTHX->ISv) #define PL_VertSpace (vTHX->IVertSpace) #define PL_XPerlSpace (vTHX->IXPerlSpace) #define PL_XPosixBlank (vTHX->IXPosixBlank) #define PL_XPosixCntrl (vTHX->IXPosixCntrl) #define PL_XPosixSpace (vTHX->IXPosixSpace) #define PL_XPosixXDigit (vTHX->IXPosixXDigit) #define PL_Xpv (vTHX->IXpv) #define PL_amagic_generation (vTHX->Iamagic_generation) #define PL_an (vTHX->Ian) #define PL_apiversion (vTHX->Iapiversion) #define PL_argvgv (vTHX->Iargvgv) #define PL_argvout_stack (vTHX->Iargvout_stack) #define PL_argvoutgv (vTHX->Iargvoutgv) #define PL_basetime (vTHX->Ibasetime) #define PL_beginav (vTHX->Ibeginav) #define PL_beginav_save (vTHX->Ibeginav_save) #define PL_blockhooks (vTHX->Iblockhooks) #define PL_body_arenas (vTHX->Ibody_arenas) #define PL_body_roots (vTHX->Ibody_roots) #define PL_bodytarget (vTHX->Ibodytarget) #define PL_breakable_sub_gen (vTHX->Ibreakable_sub_gen) #define PL_checkav (vTHX->Icheckav) #define PL_checkav_save (vTHX->Icheckav_save) #define PL_chopset (vTHX->Ichopset) #define PL_clocktick (vTHX->Iclocktick) #define PL_collation_ix (vTHX->Icollation_ix) #define PL_collation_name (vTHX->Icollation_name) #define PL_collation_standard (vTHX->Icollation_standard) #define PL_collxfrm_base (vTHX->Icollxfrm_base) #define PL_collxfrm_mult (vTHX->Icollxfrm_mult) #define PL_colors (vTHX->Icolors) #define PL_colorset (vTHX->Icolorset) #define PL_compcv (vTHX->Icompcv) #define PL_compiling (vTHX->Icompiling) #define PL_comppad (vTHX->Icomppad) #define PL_comppad_name (vTHX->Icomppad_name) #define PL_comppad_name_fill (vTHX->Icomppad_name_fill) #define PL_comppad_name_floor (vTHX->Icomppad_name_floor) #define PL_cop_seqmax (vTHX->Icop_seqmax) #define PL_cryptseen (vTHX->Icryptseen) #define PL_curcop (vTHX->Icurcop) #define PL_curcopdb (vTHX->Icurcopdb) #define PL_curpad (vTHX->Icurpad) #define PL_curpm (vTHX->Icurpm) #define PL_curstack (vTHX->Icurstack) #define PL_curstackinfo (vTHX->Icurstackinfo) #define PL_curstash (vTHX->Icurstash) #define PL_curstname (vTHX->Icurstname) #define PL_custom_op_descs (vTHX->Icustom_op_descs) #define PL_custom_op_names (vTHX->Icustom_op_names) #define PL_custom_ops (vTHX->Icustom_ops) #define PL_cv_has_eval (vTHX->Icv_has_eval) #define PL_dbargs (vTHX->Idbargs) #define PL_debstash (vTHX->Idebstash) #define PL_debug (vTHX->Idebug) #define PL_debug_pad (vTHX->Idebug_pad) #define PL_def_layerlist (vTHX->Idef_layerlist) #define PL_defgv (vTHX->Idefgv) #define PL_defoutgv (vTHX->Idefoutgv) #define PL_defstash (vTHX->Idefstash) #define PL_delaymagic (vTHX->Idelaymagic) #define PL_delaymagic_egid (vTHX->Idelaymagic_egid) #define PL_delaymagic_euid (vTHX->Idelaymagic_euid) #define PL_delaymagic_gid (vTHX->Idelaymagic_gid) #define PL_delaymagic_uid (vTHX->Idelaymagic_uid) #define PL_destroyhook (vTHX->Idestroyhook) #define PL_diehook (vTHX->Idiehook) #define PL_doswitches (vTHX->Idoswitches) #define PL_dowarn (vTHX->Idowarn) #define PL_dumper_fd (vTHX->Idumper_fd) #define PL_dumpindent (vTHX->Idumpindent) #define PL_e_script (vTHX->Ie_script) #define PL_efloatbuf (vTHX->Iefloatbuf) #define PL_efloatsize (vTHX->Iefloatsize) #define PL_encoding (vTHX->Iencoding) #define PL_endav (vTHX->Iendav) #define PL_envgv (vTHX->Ienvgv) #define PL_errgv (vTHX->Ierrgv) #define PL_errors (vTHX->Ierrors) #define PL_eval_root (vTHX->Ieval_root) #define PL_eval_start (vTHX->Ieval_start) #define PL_evalseq (vTHX->Ievalseq) #define PL_exit_flags (vTHX->Iexit_flags) #define PL_exitlist (vTHX->Iexitlist) #define PL_exitlistlen (vTHX->Iexitlistlen) #define PL_fdpid (vTHX->Ifdpid) #define PL_filemode (vTHX->Ifilemode) #define PL_firstgv (vTHX->Ifirstgv) #define PL_forkprocess (vTHX->Iforkprocess) #define PL_formfeed (vTHX->Iformfeed) #define PL_formtarget (vTHX->Iformtarget) #define PL_generation (vTHX->Igeneration) #define PL_gensym (vTHX->Igensym) #define PL_glob_index (vTHX->Iglob_index) #define PL_globalstash (vTHX->Iglobalstash) #define PL_globhook (vTHX->Iglobhook) #define PL_hash_seed (vTHX->Ihash_seed) #define PL_hintgv (vTHX->Ihintgv) #define PL_hints (vTHX->Ihints) #define PL_hv_fetch_ent_mh (vTHX->Ihv_fetch_ent_mh) #define PL_in_clean_all (vTHX->Iin_clean_all) #define PL_in_clean_objs (vTHX->Iin_clean_objs) #define PL_in_eval (vTHX->Iin_eval) #define PL_in_load_module (vTHX->Iin_load_module) #define PL_incgv (vTHX->Iincgv) #define PL_initav (vTHX->Iinitav) #define PL_inplace (vTHX->Iinplace) #define PL_isarev (vTHX->Iisarev) #define PL_known_layers (vTHX->Iknown_layers) #define PL_last_in_gv (vTHX->Ilast_in_gv) #define PL_last_swash_hv (vTHX->Ilast_swash_hv) #define PL_last_swash_key (vTHX->Ilast_swash_key) #define PL_last_swash_klen (vTHX->Ilast_swash_klen) #define PL_last_swash_slen (vTHX->Ilast_swash_slen) #define PL_last_swash_tmps (vTHX->Ilast_swash_tmps) #define PL_lastfd (vTHX->Ilastfd) #define PL_lastgotoprobe (vTHX->Ilastgotoprobe) #define PL_laststatval (vTHX->Ilaststatval) #define PL_laststype (vTHX->Ilaststype) #define PL_localizing (vTHX->Ilocalizing) #define PL_localpatches (vTHX->Ilocalpatches) #define PL_lockhook (vTHX->Ilockhook) #define PL_madskills (vTHX->Imadskills) #define PL_main_cv (vTHX->Imain_cv) #define PL_main_root (vTHX->Imain_root) #define PL_main_start (vTHX->Imain_start) #define PL_mainstack (vTHX->Imainstack) #define PL_markstack (vTHX->Imarkstack) #define PL_markstack_max (vTHX->Imarkstack_max) #define PL_markstack_ptr (vTHX->Imarkstack_ptr) #define PL_max_intro_pending (vTHX->Imax_intro_pending) #define PL_maxo (vTHX->Imaxo) #define PL_maxsysfd (vTHX->Imaxsysfd) #define PL_memory_debug_header (vTHX->Imemory_debug_header) #define PL_mess_sv (vTHX->Imess_sv) #define PL_min_intro_pending (vTHX->Imin_intro_pending) #define PL_minus_E (vTHX->Iminus_E) #define PL_minus_F (vTHX->Iminus_F) #define PL_minus_a (vTHX->Iminus_a) #define PL_minus_c (vTHX->Iminus_c) #define PL_minus_l (vTHX->Iminus_l) #define PL_minus_n (vTHX->Iminus_n) #define PL_minus_p (vTHX->Iminus_p) #define PL_modcount (vTHX->Imodcount) #define PL_modglobal (vTHX->Imodglobal) #define PL_my_cxt_keys (vTHX->Imy_cxt_keys) #define PL_my_cxt_list (vTHX->Imy_cxt_list) #define PL_my_cxt_size (vTHX->Imy_cxt_size) #define PL_na (vTHX->Ina) #define PL_nomemok (vTHX->Inomemok) #define PL_numeric_local (vTHX->Inumeric_local) #define PL_numeric_name (vTHX->Inumeric_name) #define PL_numeric_radix_sv (vTHX->Inumeric_radix_sv) #define PL_numeric_standard (vTHX->Inumeric_standard) #define PL_ofsgv (vTHX->Iofsgv) #define PL_oldname (vTHX->Ioldname) #define PL_op (vTHX->Iop) #define PL_op_mask (vTHX->Iop_mask) #define PL_opfreehook (vTHX->Iopfreehook) #define PL_opsave (vTHX->Iopsave) #define PL_origalen (vTHX->Iorigalen) #define PL_origargc (vTHX->Iorigargc) #define PL_origargv (vTHX->Iorigargv) #define PL_origenviron (vTHX->Iorigenviron) #define PL_origfilename (vTHX->Iorigfilename) #define PL_ors_sv (vTHX->Iors_sv) #define PL_osname (vTHX->Iosname) #define PL_pad_reset_pending (vTHX->Ipad_reset_pending) #define PL_padix (vTHX->Ipadix) #define PL_padix_floor (vTHX->Ipadix_floor) #define PL_parser (vTHX->Iparser) #define PL_patchlevel (vTHX->Ipatchlevel) #define PL_peepp (vTHX->Ipeepp) #define PL_perl_destruct_level (vTHX->Iperl_destruct_level) #define PL_perldb (vTHX->Iperldb) #define PL_perlio (vTHX->Iperlio) #define PL_phase (vTHX->Iphase) #define PL_pidstatus (vTHX->Ipidstatus) #define PL_preambleav (vTHX->Ipreambleav) #define PL_profiledata (vTHX->Iprofiledata) #define PL_psig_name (vTHX->Ipsig_name) #define PL_psig_pend (vTHX->Ipsig_pend) #define PL_psig_ptr (vTHX->Ipsig_ptr) #define PL_ptr_table (vTHX->Iptr_table) #define PL_reentrant_buffer (vTHX->Ireentrant_buffer) #define PL_reentrant_retint (vTHX->Ireentrant_retint) #define PL_reg_state (vTHX->Ireg_state) #define PL_regdummy (vTHX->Iregdummy) #define PL_regex_pad (vTHX->Iregex_pad) #define PL_regex_padav (vTHX->Iregex_padav) #define PL_reginterp_cnt (vTHX->Ireginterp_cnt) #define PL_registered_mros (vTHX->Iregistered_mros) #define PL_regmatch_slab (vTHX->Iregmatch_slab) #define PL_regmatch_state (vTHX->Iregmatch_state) #define PL_rehash_seed (vTHX->Irehash_seed) #define PL_rehash_seed_set (vTHX->Irehash_seed_set) #define PL_replgv (vTHX->Ireplgv) #define PL_restartjmpenv (vTHX->Irestartjmpenv) #define PL_restartop (vTHX->Irestartop) #define PL_rpeepp (vTHX->Irpeepp) #define PL_rs (vTHX->Irs) #define PL_runops (vTHX->Irunops) #define PL_savebegin (vTHX->Isavebegin) #define PL_savestack (vTHX->Isavestack) #define PL_savestack_ix (vTHX->Isavestack_ix) #define PL_savestack_max (vTHX->Isavestack_max) #define PL_sawampersand (vTHX->Isawampersand) #define PL_scopestack (vTHX->Iscopestack) #define PL_scopestack_ix (vTHX->Iscopestack_ix) #define PL_scopestack_max (vTHX->Iscopestack_max) #define PL_scopestack_name (vTHX->Iscopestack_name) #define PL_secondgv (vTHX->Isecondgv) #define PL_sharehook (vTHX->Isharehook) #define PL_sig_pending (vTHX->Isig_pending) #define PL_sighandlerp (vTHX->Isighandlerp) #define PL_signalhook (vTHX->Isignalhook) #define PL_signals (vTHX->Isignals) #define PL_slab_count (vTHX->Islab_count) #define PL_slabs (vTHX->Islabs) #define PL_sort_RealCmp (vTHX->Isort_RealCmp) #define PL_sortcop (vTHX->Isortcop) #define PL_sortstash (vTHX->Isortstash) #define PL_splitstr (vTHX->Isplitstr) #define PL_srand_called (vTHX->Isrand_called) #define PL_stack_base (vTHX->Istack_base) #define PL_stack_max (vTHX->Istack_max) #define PL_stack_sp (vTHX->Istack_sp) #define PL_start_env (vTHX->Istart_env) #define PL_stashcache (vTHX->Istashcache) #define PL_statbuf (vTHX->Istatbuf) #define PL_statcache (vTHX->Istatcache) #define PL_statgv (vTHX->Istatgv) #define PL_statname (vTHX->Istatname) #define PL_statusvalue (vTHX->Istatusvalue) #define PL_statusvalue_posix (vTHX->Istatusvalue_posix) #define PL_statusvalue_vms (vTHX->Istatusvalue_vms) #define PL_stderrgv (vTHX->Istderrgv) #define PL_stdingv (vTHX->Istdingv) #define PL_strtab (vTHX->Istrtab) #define PL_sub_generation (vTHX->Isub_generation) #define PL_subline (vTHX->Isubline) #define PL_subname (vTHX->Isubname) #define PL_sv_arenaroot (vTHX->Isv_arenaroot) #define PL_sv_count (vTHX->Isv_count) #define PL_sv_no (vTHX->Isv_no) #define PL_sv_objcount (vTHX->Isv_objcount) #define PL_sv_root (vTHX->Isv_root) #define PL_sv_serial (vTHX->Isv_serial) #define PL_sv_undef (vTHX->Isv_undef) #define PL_sv_yes (vTHX->Isv_yes) #define PL_sys_intern (vTHX->Isys_intern) #define PL_taint_warn (vTHX->Itaint_warn) #define PL_tainted (vTHX->Itainted) #define PL_tainting (vTHX->Itainting) #define PL_threadhook (vTHX->Ithreadhook) #define PL_timesbuf (vTHX->Itimesbuf) #define PL_tmps_floor (vTHX->Itmps_floor) #define PL_tmps_ix (vTHX->Itmps_ix) #define PL_tmps_max (vTHX->Itmps_max) #define PL_tmps_stack (vTHX->Itmps_stack) #define PL_top_env (vTHX->Itop_env) #define PL_toptarget (vTHX->Itoptarget) #define PL_unicode (vTHX->Iunicode) #define PL_unitcheckav (vTHX->Iunitcheckav) #define PL_unitcheckav_save (vTHX->Iunitcheckav_save) #define PL_unlockhook (vTHX->Iunlockhook) #define PL_unsafe (vTHX->Iunsafe) #define PL_utf8_X_L (vTHX->Iutf8_X_L) #define PL_utf8_X_LV (vTHX->Iutf8_X_LV) #define PL_utf8_X_LVT (vTHX->Iutf8_X_LVT) #define PL_utf8_X_LV_LVT_V (vTHX->Iutf8_X_LV_LVT_V) #define PL_utf8_X_T (vTHX->Iutf8_X_T) #define PL_utf8_X_V (vTHX->Iutf8_X_V) #define PL_utf8_X_begin (vTHX->Iutf8_X_begin) #define PL_utf8_X_extend (vTHX->Iutf8_X_extend) #define PL_utf8_X_non_hangul (vTHX->Iutf8_X_non_hangul) #define PL_utf8_X_prepend (vTHX->Iutf8_X_prepend) #define PL_utf8_alnum (vTHX->Iutf8_alnum) #define PL_utf8_alpha (vTHX->Iutf8_alpha) #define PL_utf8_digit (vTHX->Iutf8_digit) #define PL_utf8_foldable (vTHX->Iutf8_foldable) #define PL_utf8_foldclosures (vTHX->Iutf8_foldclosures) #define PL_utf8_graph (vTHX->Iutf8_graph) #define PL_utf8_idcont (vTHX->Iutf8_idcont) #define PL_utf8_idstart (vTHX->Iutf8_idstart) #define PL_utf8_lower (vTHX->Iutf8_lower) #define PL_utf8_mark (vTHX->Iutf8_mark) #define PL_utf8_perl_idstart (vTHX->Iutf8_perl_idstart) #define PL_utf8_print (vTHX->Iutf8_print) #define PL_utf8_punct (vTHX->Iutf8_punct) #define PL_utf8_quotemeta (vTHX->Iutf8_quotemeta) #define PL_utf8_space (vTHX->Iutf8_space) #define PL_utf8_tofold (vTHX->Iutf8_tofold) #define PL_utf8_tolower (vTHX->Iutf8_tolower) #define PL_utf8_totitle (vTHX->Iutf8_totitle) #define PL_utf8_toupper (vTHX->Iutf8_toupper) #define PL_utf8_upper (vTHX->Iutf8_upper) #define PL_utf8_xdigit (vTHX->Iutf8_xdigit) #define PL_utf8_xidcont (vTHX->Iutf8_xidcont) #define PL_utf8_xidstart (vTHX->Iutf8_xidstart) #define PL_utf8cache (vTHX->Iutf8cache) #define PL_utf8locale (vTHX->Iutf8locale) #define PL_warnhook (vTHX->Iwarnhook) #define PL_watchaddr (vTHX->Iwatchaddr) #define PL_watchok (vTHX->Iwatchok) #define PL_xmlfp (vTHX->Ixmlfp) #endif /* MULTIPLICITY */ #if defined(PERL_GLOBAL_STRUCT) #define PL_appctx (my_vars->Gappctx) #define PL_Gappctx (my_vars->Gappctx) #define PL_check (my_vars->Gcheck) #define PL_Gcheck (my_vars->Gcheck) #define PL_check_mutex (my_vars->Gcheck_mutex) #define PL_Gcheck_mutex (my_vars->Gcheck_mutex) #define PL_csighandlerp (my_vars->Gcsighandlerp) #define PL_Gcsighandlerp (my_vars->Gcsighandlerp) #define PL_curinterp (my_vars->Gcurinterp) #define PL_Gcurinterp (my_vars->Gcurinterp) #define PL_do_undump (my_vars->Gdo_undump) #define PL_Gdo_undump (my_vars->Gdo_undump) #define PL_dollarzero_mutex (my_vars->Gdollarzero_mutex) #define PL_Gdollarzero_mutex (my_vars->Gdollarzero_mutex) #define PL_fold_locale (my_vars->Gfold_locale) #define PL_Gfold_locale (my_vars->Gfold_locale) #define PL_hints_mutex (my_vars->Ghints_mutex) #define PL_Ghints_mutex (my_vars->Ghints_mutex) #define PL_keyword_plugin (my_vars->Gkeyword_plugin) #define PL_Gkeyword_plugin (my_vars->Gkeyword_plugin) #define PL_malloc_mutex (my_vars->Gmalloc_mutex) #define PL_Gmalloc_mutex (my_vars->Gmalloc_mutex) #define PL_mmap_page_size (my_vars->Gmmap_page_size) #define PL_Gmmap_page_size (my_vars->Gmmap_page_size) #define PL_my_ctx_mutex (my_vars->Gmy_ctx_mutex) #define PL_Gmy_ctx_mutex (my_vars->Gmy_ctx_mutex) #define PL_my_cxt_index (my_vars->Gmy_cxt_index) #define PL_Gmy_cxt_index (my_vars->Gmy_cxt_index) #define PL_op_mutex (my_vars->Gop_mutex) #define PL_Gop_mutex (my_vars->Gop_mutex) #define PL_op_seq (my_vars->Gop_seq) #define PL_Gop_seq (my_vars->Gop_seq) #define PL_op_sequence (my_vars->Gop_sequence) #define PL_Gop_sequence (my_vars->Gop_sequence) #define PL_perlio_debug_fd (my_vars->Gperlio_debug_fd) #define PL_Gperlio_debug_fd (my_vars->Gperlio_debug_fd) #define PL_perlio_fd_refcnt (my_vars->Gperlio_fd_refcnt) #define PL_Gperlio_fd_refcnt (my_vars->Gperlio_fd_refcnt) #define PL_perlio_fd_refcnt_size (my_vars->Gperlio_fd_refcnt_size) #define PL_Gperlio_fd_refcnt_size (my_vars->Gperlio_fd_refcnt_size) #define PL_perlio_mutex (my_vars->Gperlio_mutex) #define PL_Gperlio_mutex (my_vars->Gperlio_mutex) #define PL_ppaddr (my_vars->Gppaddr) #define PL_Gppaddr (my_vars->Gppaddr) #ifdef OS2 #define PL_sh_path (my_vars->Gsh_path) #define PL_Gsh_path (my_vars->Gsh_path) #endif #define PL_sig_defaulting (my_vars->Gsig_defaulting) #define PL_Gsig_defaulting (my_vars->Gsig_defaulting) #define PL_sig_handlers_initted (my_vars->Gsig_handlers_initted) #define PL_Gsig_handlers_initted (my_vars->Gsig_handlers_initted) #define PL_sig_ignoring (my_vars->Gsig_ignoring) #define PL_Gsig_ignoring (my_vars->Gsig_ignoring) #define PL_sig_trapped (my_vars->Gsig_trapped) #define PL_Gsig_trapped (my_vars->Gsig_trapped) #define PL_sigfpe_saved (my_vars->Gsigfpe_saved) #define PL_Gsigfpe_saved (my_vars->Gsigfpe_saved) #define PL_sv_placeholder (my_vars->Gsv_placeholder) #define PL_Gsv_placeholder (my_vars->Gsv_placeholder) #define PL_thr_key (my_vars->Gthr_key) #define PL_Gthr_key (my_vars->Gthr_key) #define PL_timesbase (my_vars->Gtimesbase) #define PL_Gtimesbase (my_vars->Gtimesbase) #define PL_use_safe_putenv (my_vars->Guse_safe_putenv) #define PL_Guse_safe_putenv (my_vars->Guse_safe_putenv) #define PL_veto_cleanup (my_vars->Gveto_cleanup) #define PL_Gveto_cleanup (my_vars->Gveto_cleanup) #define PL_watch_pvx (my_vars->Gwatch_pvx) #define PL_Gwatch_pvx (my_vars->Gwatch_pvx) #endif /* PERL_GLOBAL_STRUCT */ /* ex: set ro: */ PKZBB uconfig.hnuW+A/* This file was produced by running the config_h.SH script, which * gets its values from uconfig.sh, which is generally produced by * running Configure. * * Feel free to modify any of this as the need arises. Note, however, * that running config_h.SH again will wipe out any changes you've made. * For a more permanent change edit uconfig.sh and rerun config_h.SH. */ /* Package name : perl5 * Source directory : . * Configuration time: Thu Jan 1 00:00:00 GMT 1970 * Configured by : root@localhost * Target system : unknown */ #ifndef _config_h_ #define _config_h_ /* LOC_SED: * This symbol holds the complete pathname to the sed program. */ #define LOC_SED "" /**/ /* HAS_ALARM: * This symbol, if defined, indicates that the alarm routine is * available. */ /*#define HAS_ALARM / **/ /* HAS_BCMP: * This symbol is defined if the bcmp() routine is available to * compare blocks of memory. */ /*#define HAS_BCMP / **/ /* HAS_BCOPY: * This symbol is defined if the bcopy() routine is available to * copy blocks of memory. */ /*#define HAS_BCOPY / **/ /* HAS_BZERO: * This symbol is defined if the bzero() routine is available to * set a memory block to 0. */ /*#define HAS_BZERO / **/ /* HAS_CHOWN: * This symbol, if defined, indicates that the chown routine is * available. */ /*#define HAS_CHOWN / **/ /* HAS_CHROOT: * This symbol, if defined, indicates that the chroot routine is * available. */ /*#define HAS_CHROOT / **/ /* HAS_CHSIZE: * This symbol, if defined, indicates that the chsize routine is available * to truncate files. You might need a -lx to get this routine. */ /*#define HAS_CHSIZE / **/ /* HAS_CRYPT: * This symbol, if defined, indicates that the crypt routine is available * to encrypt passwords and the like. */ /*#define HAS_CRYPT / **/ /* HAS_CTERMID: * This symbol, if defined, indicates that the ctermid routine is * available to generate filename for terminal. */ /*#define HAS_CTERMID / **/ /* HAS_CUSERID: * This symbol, if defined, indicates that the cuserid routine is * available to get character login names. */ /*#define HAS_CUSERID / **/ /* HAS_DBL_DIG: * This symbol, if defined, indicates that this system's * or defines the symbol DBL_DIG, which is the number * of significant digits in a double precision number. If this * symbol is not defined, a guess of 15 is usually pretty good. */ /*#define HAS_DBL_DIG / **/ /* HAS_DIFFTIME: * This symbol, if defined, indicates that the difftime routine is * available. */ /*#define HAS_DIFFTIME / **/ /* HAS_DLERROR: * This symbol, if defined, indicates that the dlerror routine is * available to return a string describing the last error that * occurred from a call to dlopen(), dlclose() or dlsym(). */ /*#define HAS_DLERROR / **/ /* HAS_DUP2: * This symbol, if defined, indicates that the dup2 routine is * available to duplicate file descriptors. */ /*#define HAS_DUP2 / **/ /* HAS_FCHMOD: * This symbol, if defined, indicates that the fchmod routine is available * to change mode of opened files. If unavailable, use chmod(). */ /*#define HAS_FCHMOD / **/ /* HAS_FCHOWN: * This symbol, if defined, indicates that the fchown routine is available * to change ownership of opened files. If unavailable, use chown(). */ /*#define HAS_FCHOWN / **/ /* HAS_FCNTL: * This symbol, if defined, indicates to the C program that * the fcntl() function exists. */ /*#define HAS_FCNTL / **/ /* HAS_FGETPOS: * This symbol, if defined, indicates that the fgetpos routine is * available to get the file position indicator, similar to ftell(). */ /*#define HAS_FGETPOS / **/ /* HAS_FLOCK: * This symbol, if defined, indicates that the flock routine is * available to do file locking. */ /*#define HAS_FLOCK / **/ /* HAS_FORK: * This symbol, if defined, indicates that the fork routine is * available. */ #define HAS_FORK /**/ /* HAS_FSETPOS: * This symbol, if defined, indicates that the fsetpos routine is * available to set the file position indicator, similar to fseek(). */ /*#define HAS_FSETPOS / **/ /* HAS_GETTIMEOFDAY: * This symbol, if defined, indicates that the gettimeofday() system * call is available for a sub-second accuracy clock. Usually, the file * needs to be included (see I_SYS_RESOURCE). * The type "Timeval" should be used to refer to "struct timeval". */ /*#define HAS_GETTIMEOFDAY / **/ #ifdef HAS_GETTIMEOFDAY #define Timeval struct timeval /* Structure used by gettimeofday() */ #endif /* HAS_GETGROUPS: * This symbol, if defined, indicates that the getgroups() routine is * available to get the list of process groups. If unavailable, multiple * groups are probably not supported. */ /*#define HAS_GETGROUPS / **/ /* HAS_GETLOGIN: * This symbol, if defined, indicates that the getlogin routine is * available to get the login name. */ /*#define HAS_GETLOGIN / **/ /* HAS_GETPGID: * This symbol, if defined, indicates to the C program that * the getpgid(pid) function is available to get the * process group id. */ /*#define HAS_GETPGID / **/ /* HAS_GETPGRP2: * This symbol, if defined, indicates that the getpgrp2() (as in DG/UX) * routine is available to get the current process group. */ /*#define HAS_GETPGRP2 / **/ /* HAS_GETPPID: * This symbol, if defined, indicates that the getppid routine is * available to get the parent process ID. */ /*#define HAS_GETPPID / **/ /* HAS_GETPRIORITY: * This symbol, if defined, indicates that the getpriority routine is * available to get a process's priority. */ /*#define HAS_GETPRIORITY / **/ /* HAS_INET_ATON: * This symbol, if defined, indicates to the C program that the * inet_aton() function is available to parse IP address "dotted-quad" * strings. */ /*#define HAS_INET_ATON / **/ /* HAS_KILLPG: * This symbol, if defined, indicates that the killpg routine is available * to kill process groups. If unavailable, you probably should use kill * with a negative process number. */ /*#define HAS_KILLPG / **/ /* HAS_LINK: * This symbol, if defined, indicates that the link routine is * available to create hard links. */ /*#define HAS_LINK / **/ /* HAS_LOCALECONV: * This symbol, if defined, indicates that the localeconv routine is * available for numeric and monetary formatting conventions. */ /*#define HAS_LOCALECONV / **/ /* HAS_LOCKF: * This symbol, if defined, indicates that the lockf routine is * available to do file locking. */ /*#define HAS_LOCKF / **/ /* HAS_LSTAT: * This symbol, if defined, indicates that the lstat routine is * available to do file stats on symbolic links. */ /*#define HAS_LSTAT / **/ /* HAS_MBLEN: * This symbol, if defined, indicates that the mblen routine is available * to find the number of bytes in a multibye character. */ /*#define HAS_MBLEN / **/ /* HAS_MBSTOWCS: * This symbol, if defined, indicates that the mbstowcs routine is * available to covert a multibyte string into a wide character string. */ /*#define HAS_MBSTOWCS / **/ /* HAS_MBTOWC: * This symbol, if defined, indicates that the mbtowc routine is available * to covert a multibyte to a wide character. */ /*#define HAS_MBTOWC / **/ /* HAS_MEMCMP: * This symbol, if defined, indicates that the memcmp routine is available * to compare blocks of memory. */ #define HAS_MEMCMP /**/ /* HAS_MEMCPY: * This symbol, if defined, indicates that the memcpy routine is available * to copy blocks of memory. */ #define HAS_MEMCPY /**/ /* HAS_MEMMOVE: * This symbol, if defined, indicates that the memmove routine is available * to copy potentially overlapping blocks of memory. This should be used * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your * own version. */ /*#define HAS_MEMMOVE / **/ /* HAS_MEMSET: * This symbol, if defined, indicates that the memset routine is available * to set blocks of memory. */ #define HAS_MEMSET /**/ /* HAS_MKDIR: * This symbol, if defined, indicates that the mkdir routine is available * to create directories. Otherwise you should fork off a new process to * exec /bin/mkdir. */ /*#define HAS_MKDIR / **/ /* HAS_MKFIFO: * This symbol, if defined, indicates that the mkfifo routine is * available to create FIFOs. Otherwise, mknod should be able to * do it for you. However, if mkfifo is there, mknod might require * super-user privileges which mkfifo will not. */ /*#define HAS_MKFIFO / **/ /* HAS_MKTIME: * This symbol, if defined, indicates that the mktime routine is * available. */ /*#define HAS_MKTIME / **/ /* HAS_MSYNC: * This symbol, if defined, indicates that the msync system call is * available to synchronize a mapped file. */ /*#define HAS_MSYNC / **/ /* HAS_MUNMAP: * This symbol, if defined, indicates that the munmap system call is * available to unmap a region, usually mapped by mmap(). */ /*#define HAS_MUNMAP / **/ /* HAS_NICE: * This symbol, if defined, indicates that the nice routine is * available. */ /*#define HAS_NICE / **/ /* HAS_PATHCONF: * This symbol, if defined, indicates that pathconf() is available * to determine file-system related limits and options associated * with a given filename. */ /* HAS_FPATHCONF: * This symbol, if defined, indicates that pathconf() is available * to determine file-system related limits and options associated * with a given open file descriptor. */ /*#define HAS_PATHCONF / **/ /*#define HAS_FPATHCONF / **/ /* HAS_PAUSE: * This symbol, if defined, indicates that the pause routine is * available to suspend a process until a signal is received. */ /*#define HAS_PAUSE / **/ /* HAS_PIPE: * This symbol, if defined, indicates that the pipe routine is * available to create an inter-process channel. */ /*#define HAS_PIPE / **/ /* HAS_POLL: * This symbol, if defined, indicates that the poll routine is * available to poll active file descriptors. Please check I_POLL and * I_SYS_POLL to know which header should be included as well. */ /*#define HAS_POLL / **/ /* HAS_READDIR: * This symbol, if defined, indicates that the readdir routine is * available to read directory entries. You may have to include * . See I_DIRENT. */ #define HAS_READDIR /**/ /* HAS_SEEKDIR: * This symbol, if defined, indicates that the seekdir routine is * available. You may have to include . See I_DIRENT. */ /*#define HAS_SEEKDIR / **/ /* HAS_TELLDIR: * This symbol, if defined, indicates that the telldir routine is * available. You may have to include . See I_DIRENT. */ /*#define HAS_TELLDIR / **/ /* HAS_REWINDDIR: * This symbol, if defined, indicates that the rewinddir routine is * available. You may have to include . See I_DIRENT. */ /*#define HAS_REWINDDIR / **/ /* HAS_READLINK: * This symbol, if defined, indicates that the readlink routine is * available to read the value of a symbolic link. */ /*#define HAS_READLINK / **/ /* HAS_RENAME: * This symbol, if defined, indicates that the rename routine is available * to rename files. Otherwise you should do the unlink(), link(), unlink() * trick. */ #define HAS_RENAME /**/ /* HAS_RMDIR: * This symbol, if defined, indicates that the rmdir routine is * available to remove directories. Otherwise you should fork off a * new process to exec /bin/rmdir. */ /*#define HAS_RMDIR / **/ /* HAS_SELECT: * This symbol, if defined, indicates that the select routine is * available to select active file descriptors. If the timeout field * is used, may need to be included. */ /*#define HAS_SELECT / **/ /* HAS_SETEGID: * This symbol, if defined, indicates that the setegid routine is available * to change the effective gid of the current program. */ /*#define HAS_SETEGID / **/ /* HAS_SETEUID: * This symbol, if defined, indicates that the seteuid routine is available * to change the effective uid of the current program. */ /*#define HAS_SETEUID / **/ /* HAS_SETGROUPS: * This symbol, if defined, indicates that the setgroups() routine is * available to set the list of process groups. If unavailable, multiple * groups are probably not supported. */ /*#define HAS_SETGROUPS / **/ /* HAS_SETLINEBUF: * This symbol, if defined, indicates that the setlinebuf routine is * available to change stderr or stdout from block-buffered or unbuffered * to a line-buffered mode. */ /*#define HAS_SETLINEBUF / **/ /* HAS_SETLOCALE: * This symbol, if defined, indicates that the setlocale routine is * available to handle locale-specific ctype implementations. */ /*#define HAS_SETLOCALE / **/ /* HAS_SETPGID: * This symbol, if defined, indicates that the setpgid(pid, gpid) * routine is available to set process group ID. */ /*#define HAS_SETPGID / **/ /* HAS_SETPGRP2: * This symbol, if defined, indicates that the setpgrp2() (as in DG/UX) * routine is available to set the current process group. */ /*#define HAS_SETPGRP2 / **/ /* HAS_SETPRIORITY: * This symbol, if defined, indicates that the setpriority routine is * available to set a process's priority. */ /*#define HAS_SETPRIORITY / **/ /* HAS_SETREGID: * This symbol, if defined, indicates that the setregid routine is * available to change the real and effective gid of the current * process. */ /* HAS_SETRESGID: * This symbol, if defined, indicates that the setresgid routine is * available to change the real, effective and saved gid of the current * process. */ /*#define HAS_SETREGID / **/ /*#define HAS_SETRESGID / **/ /* HAS_SETREUID: * This symbol, if defined, indicates that the setreuid routine is * available to change the real and effective uid of the current * process. */ /* HAS_SETRESUID: * This symbol, if defined, indicates that the setresuid routine is * available to change the real, effective and saved uid of the current * process. */ /*#define HAS_SETREUID / **/ /*#define HAS_SETRESUID / **/ /* HAS_SETRGID: * This symbol, if defined, indicates that the setrgid routine is available * to change the real gid of the current program. */ /*#define HAS_SETRGID / **/ /* HAS_SETRUID: * This symbol, if defined, indicates that the setruid routine is available * to change the real uid of the current program. */ /*#define HAS_SETRUID / **/ /* HAS_SETSID: * This symbol, if defined, indicates that the setsid routine is * available to set the process group ID. */ /*#define HAS_SETSID / **/ /* HAS_STRCHR: * This symbol is defined to indicate that the strchr()/strrchr() * functions are available for string searching. If not, try the * index()/rindex() pair. */ /* HAS_INDEX: * This symbol is defined to indicate that the index()/rindex() * functions are available for string searching. */ /*#define HAS_STRCHR / **/ /*#define HAS_INDEX / **/ /* HAS_STRCOLL: * This symbol, if defined, indicates that the strcoll routine is * available to compare strings using collating information. */ /*#define HAS_STRCOLL / **/ /* HAS_STRTOD: * This symbol, if defined, indicates that the strtod routine is * available to provide better numeric string conversion than atof(). */ /*#define HAS_STRTOD / **/ /* HAS_STRTOL: * This symbol, if defined, indicates that the strtol routine is available * to provide better numeric string conversion than atoi() and friends. */ /*#define HAS_STRTOL / **/ /* HAS_STRXFRM: * This symbol, if defined, indicates that the strxfrm() routine is * available to transform strings. */ /*#define HAS_STRXFRM / **/ /* HAS_SYMLINK: * This symbol, if defined, indicates that the symlink routine is available * to create symbolic links. */ /*#define HAS_SYMLINK / **/ /* HAS_SYSCALL: * This symbol, if defined, indicates that the syscall routine is * available to call arbitrary system calls. If undefined, that's tough. */ /*#define HAS_SYSCALL / **/ /* HAS_SYSCONF: * This symbol, if defined, indicates that sysconf() is available * to determine system related limits and options. */ /*#define HAS_SYSCONF / **/ /* HAS_SYSTEM: * This symbol, if defined, indicates that the system routine is * available to issue a shell command. */ /*#define HAS_SYSTEM / **/ /* HAS_TCGETPGRP: * This symbol, if defined, indicates that the tcgetpgrp routine is * available to get foreground process group ID. */ /*#define HAS_TCGETPGRP / **/ /* HAS_TCSETPGRP: * This symbol, if defined, indicates that the tcsetpgrp routine is * available to set foreground process group ID. */ /*#define HAS_TCSETPGRP / **/ /* HAS_TRUNCATE: * This symbol, if defined, indicates that the truncate routine is * available to truncate files. */ /*#define HAS_TRUNCATE / **/ /* HAS_TZNAME: * This symbol, if defined, indicates that the tzname[] array is * available to access timezone names. */ /*#define HAS_TZNAME / **/ /* HAS_UMASK: * This symbol, if defined, indicates that the umask routine is * available to set and get the value of the file creation mask. */ /*#define HAS_UMASK / **/ /* HAS_USLEEP: * This symbol, if defined, indicates that the usleep routine is * available to let the process sleep on a sub-second accuracy. */ /*#define HAS_USLEEP / **/ /* HAS_WAIT4: * This symbol, if defined, indicates that wait4() exists. */ /*#define HAS_WAIT4 / **/ /* HAS_WAITPID: * This symbol, if defined, indicates that the waitpid routine is * available to wait for child process. */ /*#define HAS_WAITPID / **/ /* HAS_WCSTOMBS: * This symbol, if defined, indicates that the wcstombs routine is * available to convert wide character strings to multibyte strings. */ /*#define HAS_WCSTOMBS / **/ /* HAS_WCTOMB: * This symbol, if defined, indicates that the wctomb routine is available * to covert a wide character to a multibyte. */ /*#define HAS_WCTOMB / **/ /* Groups_t: * This symbol holds the type used for the second argument to * getgroups() and setgroups(). Usually, this is the same as * gidtype (gid_t) , but sometimes it isn't. * It can be int, ushort, gid_t, etc... * It may be necessary to include to get any * typedef'ed information. This is only required if you have * getgroups() or setgroups().. */ #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS) #define Groups_t int /* Type for 2nd arg to [sg]etgroups() */ #endif /* I_ARPA_INET: * This symbol, if defined, indicates to the C program that it should * include to get inet_addr and friends declarations. */ /*#define I_ARPA_INET / **/ /* I_DBM: * This symbol, if defined, indicates that exists and should * be included. */ /* I_RPCSVC_DBM: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_DBM / **/ /*#define I_RPCSVC_DBM / **/ /* I_DLFCN: * This symbol, if defined, indicates that exists and should * be included. */ /*#define I_DLFCN / **/ /* I_FCNTL: * This manifest constant tells the C program to include . */ /*#define I_FCNTL / **/ /* I_FLOAT: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like DBL_MAX or * DBL_MIN, i.e. machine dependent floating point values. */ /*#define I_FLOAT / **/ /* I_GDBM: * This symbol, if defined, indicates that exists and should * be included. */ /*#define I_GDBM / **/ /* I_LIMITS: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like WORD_BIT or * LONG_MAX, i.e. machine dependant limitations. */ /*#define I_LIMITS / **/ /* I_LOCALE: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_LOCALE / **/ /* I_MATH: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_MATH /**/ /* I_MEMORY: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MEMORY / **/ /* I_NETINET_IN: * This symbol, if defined, indicates to the C program that it should * include . Otherwise, you may try . */ /*#define I_NETINET_IN / **/ /* I_SFIO: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SFIO / **/ /* I_STDDEF: * This symbol, if defined, indicates that exists and should * be included. */ #define I_STDDEF /**/ /* I_STDLIB: * This symbol, if defined, indicates that exists and should * be included. */ #define I_STDLIB /**/ /* I_STRING: * This symbol, if defined, indicates to the C program that it should * include (USG systems) instead of (BSD systems). */ #define I_STRING /**/ /* I_SYS_DIR: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_DIR / **/ /* I_SYS_FILE: * This symbol, if defined, indicates to the C program that it should * include to get definition of R_OK and friends. */ /*#define I_SYS_FILE / **/ /* I_SYS_IOCTL: * This symbol, if defined, indicates that exists and should * be included. Otherwise, include or . */ /* I_SYS_SOCKIO: * This symbol, if defined, indicates the should be included * to get socket ioctl options, like SIOCATMARK. */ /*#define I_SYS_IOCTL / **/ /*#define I_SYS_SOCKIO / **/ /* I_SYS_NDIR: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_NDIR / **/ /* I_SYS_PARAM: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_PARAM / **/ /* I_SYS_POLL: * This symbol, if defined, indicates that the program may include * . When I_POLL is also defined, it's probably safest * to only include . */ /*#define I_SYS_POLL / **/ /* I_SYS_RESOURCE: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_RESOURCE / **/ /* I_SYS_SELECT: * This symbol, if defined, indicates to the C program that it should * include in order to get definition of struct timeval. */ /*#define I_SYS_SELECT / **/ /* I_SYS_STAT: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_STAT /**/ /* I_SYS_TIMES: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_TIMES / **/ /* I_SYS_TYPES: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_TYPES / **/ /* I_SYS_UN: * This symbol, if defined, indicates to the C program that it should * include to get UNIX domain socket definitions. */ /*#define I_SYS_UN / **/ /* I_SYS_WAIT: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_WAIT / **/ /* I_TERMIO: * This symbol, if defined, indicates that the program should include * rather than . There are also differences in * the ioctl() calls that depend on the value of this symbol. */ /* I_TERMIOS: * This symbol, if defined, indicates that the program should include * the POSIX termios.h rather than sgtty.h or termio.h. * There are also differences in the ioctl() calls that depend on the * value of this symbol. */ /* I_SGTTY: * This symbol, if defined, indicates that the program should include * rather than . There are also differences in * the ioctl() calls that depend on the value of this symbol. */ /*#define I_TERMIO / **/ /*#define I_TERMIOS / **/ /*#define I_SGTTY / **/ /* I_UNISTD: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_UNISTD / **/ /* I_UTIME: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_UTIME / **/ /* I_VALUES: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like MINFLOAT or * MAXLONG, i.e. machine dependant limitations. Probably, you * should use instead, if it is available. */ /*#define I_VALUES / **/ /* I_VFORK: * This symbol, if defined, indicates to the C program that it should * include vfork.h. */ /*#define I_VFORK / **/ /* CAN_VAPROTO: * This variable is defined on systems supporting prototype declaration * of functions with a variable number of arguments. */ /* _V: * This macro is used to declare function parameters in prototypes for * functions with a variable number of parameters. Use double parentheses. * For example: * * int printf _V((char *fmt, ...)); * * Remember to use the plain simple _() macro when declaring a function * with no variable number of arguments, since it might be possible to * have a non-effect _V() macro and still get prototypes via _(). */ /*#define CAN_VAPROTO / **/ #ifdef CAN_VAPROTO #define _V(args) args #else #define _V(args) () #endif /* OSNAME: * This symbol contains the name of the operating system, as determined * by Configure. You shouldn't rely on it too much; the specific * feature tests from Configure are generally more reliable. */ /* OSVERS: * This symbol contains the version of the operating system, as determined * by Configure. You shouldn't rely on it too much; the specific * feature tests from Configure are generally more reliable. */ #define OSNAME "unknown" /**/ #define OSVERS "unknown" /**/ /* USE_CROSS_COMPILE: * This symbol, if defined, indicates that Perl is being cross-compiled. */ /* PERL_TARGETARCH: * This symbol, if defined, indicates the target architecture * Perl has been cross-compiled to. Undefined if not a cross-compile. */ #ifndef USE_CROSS_COMPILE /*#define USE_CROSS_COMPILE / **/ #define PERL_TARGETARCH "" /**/ #endif /* MULTIARCH: * This symbol, if defined, signifies that the build * process will produce some binary files that are going to be * used in a cross-platform environment. This is the case for * example with the NeXT "fat" binaries that contain executables * for several CPUs. */ /*#define MULTIARCH / **/ /* MEM_ALIGNBYTES: * This symbol contains the number of bytes required to align a * double, or a long double when applicable. Usual values are 2, * 4 and 8. The default is eight, for safety. */ #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) # define MEM_ALIGNBYTES 8 #else #define MEM_ALIGNBYTES 4 #endif /* ARCHLIB: * This variable, if defined, holds the name of the directory in * which the user wants to put architecture-dependent public * library files for perl5. It is most often a local directory * such as /usr/local/lib. Programs using this variable must be * prepared to deal with filename expansion. If ARCHLIB is the * same as PRIVLIB, it is not defined, since presumably the * program already searches PRIVLIB. */ /* ARCHLIB_EXP: * This symbol contains the ~name expanded version of ARCHLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /*#define ARCHLIB "/usr/local/lib/perl5/5.16/unknown" / **/ /*#define ARCHLIB_EXP "/usr/local/lib/perl5/5.16/unknown" / **/ /* ARCHNAME: * This symbol holds a string representing the architecture name. * It may be used to construct an architecture-dependant pathname * where library files may be held under a private library, for * instance. */ #define ARCHNAME "unknown" /**/ /* BIN: * This symbol holds the path of the bin directory where the package will * be installed. Program must be prepared to deal with ~name substitution. */ /* BIN_EXP: * This symbol is the filename expanded version of the BIN symbol, for * programs that do not want to deal with that at run-time. */ /* PERL_RELOCATABLE_INC: * This symbol, if defined, indicates that we'd like to relocate entries * in @INC at run time based on the location of the perl binary. */ #define BIN "/usr/local/bin" /**/ #define BIN_EXP "/usr/local/bin" /**/ /*#define PERL_RELOCATABLE_INC / **/ /* INTSIZE: * This symbol contains the value of sizeof(int) so that the C * preprocessor can make decisions based on it. */ /* LONGSIZE: * This symbol contains the value of sizeof(long) so that the C * preprocessor can make decisions based on it. */ /* SHORTSIZE: * This symbol contains the value of sizeof(short) so that the C * preprocessor can make decisions based on it. */ #define INTSIZE 4 /**/ #define LONGSIZE 4 /**/ #define SHORTSIZE 2 /**/ /* BYTEORDER: * This symbol holds the hexadecimal constant defined in byteorder, * in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc... * If the compiler supports cross-compiling or multiple-architecture * binaries (eg. on NeXT systems), use compiler-defined macros to * determine the byte order. * On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture * Binaries (MAB) on either big endian or little endian machines. * The endian-ness is available at compile-time. This only matters * for perl, where the config.h can be generated and installed on * one system, and used by a different architecture to build an * extension. Older versions of NeXT that might not have * defined either *_ENDIAN__ were all on Motorola 680x0 series, * so the default case (for NeXT) is big endian to catch them. * This might matter for NeXT 3.0. */ #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) # ifdef __LITTLE_ENDIAN__ # if LONGSIZE == 4 # define BYTEORDER 0x1234 # else # if LONGSIZE == 8 # define BYTEORDER 0x12345678 # endif # endif # else # ifdef __BIG_ENDIAN__ # if LONGSIZE == 4 # define BYTEORDER 0x4321 # else # if LONGSIZE == 8 # define BYTEORDER 0x87654321 # endif # endif # endif # endif # if !defined(BYTEORDER) && (defined(NeXT) || defined(__NeXT__)) # define BYTEORDER 0x4321 # endif #else #define BYTEORDER 0x1234 /* large digits for MSB */ #endif /* NeXT */ /* CHARBITS: * This symbol contains the size of a char, so that the C preprocessor * can make decisions based on it. */ #define CHARBITS 8 /**/ /* CAT2: * This macro concatenates 2 tokens together. */ /* STRINGIFY: * This macro surrounds its token with double quotes. */ #if 42 == 1 #define CAT2(a,b) a/**/b #define STRINGIFY(a) "a" #endif #if 42 == 42 #define PeRl_CaTiFy(a, b) a ## b #define PeRl_StGiFy(a) #a #define CAT2(a,b) PeRl_CaTiFy(a,b) #define StGiFy(a) PeRl_StGiFy(a) #define STRINGIFY(a) PeRl_StGiFy(a) #endif #if 42 != 1 && 42 != 42 #include "Bletch: How does this C preprocessor concatenate tokens?" #endif /* CPPSTDIN: * This symbol contains the first part of the string which will invoke * the C preprocessor on the standard input and produce to standard * output. Typical value of "cc -E" or "/lib/cpp", but it can also * call a wrapper. See CPPRUN. */ /* CPPMINUS: * This symbol contains the second part of the string which will invoke * the C preprocessor on the standard input and produce to standard * output. This symbol will have the value "-" if CPPSTDIN needs a minus * to specify standard input, otherwise the value is "". */ /* CPPRUN: * This symbol contains the string which will invoke a C preprocessor on * the standard input and produce to standard output. It needs to end * with CPPLAST, after all other preprocessor flags have been specified. * The main difference with CPPSTDIN is that this program will never be a * pointer to a shell wrapper, i.e. it will be empty if no preprocessor is * available directly to the user. Note that it may well be different from * the preprocessor used to compile the C program. */ /* CPPLAST: * This symbol is intended to be used along with CPPRUN in the same manner * symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "". */ #define CPPSTDIN "cc -E" #define CPPMINUS "-" #define CPPRUN "cc -E" #define CPPLAST "-" /* HAS_ACCESS: * This manifest constant lets the C program know that the access() * system call is available to check for accessibility using real UID/GID. * (always present on UNIX.) */ /*#define HAS_ACCESS / **/ /* HAS_ACCESSX: * This symbol, if defined, indicates that the accessx routine is * available to do extended access checks. */ /*#define HAS_ACCESSX / **/ /* HAS_ASCTIME_R: * This symbol, if defined, indicates that the asctime_r routine * is available to asctime re-entrantly. */ /* ASCTIME_R_PROTO: * This symbol encodes the prototype of asctime_r. * It is zero if d_asctime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r * is defined. */ /*#define HAS_ASCTIME_R / **/ #define ASCTIME_R_PROTO 0 /**/ /* HASATTRIBUTE_FORMAT: * Can we handle GCC attribute for checking printf-style formats */ /* PRINTF_FORMAT_NULL_OK: * Allows __printf__ format to be null when checking printf-style */ /* HASATTRIBUTE_MALLOC: * Can we handle GCC attribute for malloc-style functions. */ /* HASATTRIBUTE_NONNULL: * Can we handle GCC attribute for nonnull function parms. */ /* HASATTRIBUTE_NORETURN: * Can we handle GCC attribute for functions that do not return */ /* HASATTRIBUTE_PURE: * Can we handle GCC attribute for pure functions */ /* HASATTRIBUTE_UNUSED: * Can we handle GCC attribute for unused variables and arguments */ /* HASATTRIBUTE_DEPRECATED: * Can we handle GCC attribute for marking deprecated APIs */ /* HASATTRIBUTE_WARN_UNUSED_RESULT: * Can we handle GCC attribute for warning on unused results */ /*#define HASATTRIBUTE_DEPRECATED / **/ /*#define HASATTRIBUTE_FORMAT / **/ /*#define PRINTF_FORMAT_NULL_OK / **/ /*#define HASATTRIBUTE_NORETURN / **/ /*#define HASATTRIBUTE_MALLOC / **/ /*#define HASATTRIBUTE_NONNULL / **/ /*#define HASATTRIBUTE_PURE / **/ /*#define HASATTRIBUTE_UNUSED / **/ /*#define HASATTRIBUTE_WARN_UNUSED_RESULT / **/ /* CASTI32: * This symbol is defined if the C compiler can cast negative * or large floating point numbers to 32-bit ints. */ /*#define CASTI32 / **/ /* CASTNEGFLOAT: * This symbol is defined if the C compiler can cast negative * numbers to unsigned longs, ints and shorts. */ /* CASTFLAGS: * This symbol contains flags that say what difficulties the compiler * has casting odd floating values to unsigned long: * 0 = ok * 1 = couldn't cast < 0 * 2 = couldn't cast >= 0x80000000 * 4 = couldn't cast in argument expression list */ /*#define CASTNEGFLOAT / **/ #define CASTFLAGS 0 /**/ /* VOID_CLOSEDIR: * This symbol, if defined, indicates that the closedir() routine * does not return a value. */ /*#define VOID_CLOSEDIR / **/ /* HASCONST: * This symbol, if defined, indicates that this C compiler knows about * the const type. There is no need to actually test for that symbol * within your programs. The mere use of the "const" keyword will * trigger the necessary tests. */ /*#define HASCONST / **/ #ifndef HASCONST #define const #endif /* HAS_CRYPT_R: * This symbol, if defined, indicates that the crypt_r routine * is available to crypt re-entrantly. */ /* CRYPT_R_PROTO: * This symbol encodes the prototype of crypt_r. * It is zero if d_crypt_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r * is defined. */ /*#define HAS_CRYPT_R / **/ #define CRYPT_R_PROTO 0 /**/ /* HAS_CSH: * This symbol, if defined, indicates that the C-shell exists. */ /* CSH: * This symbol, if defined, contains the full pathname of csh. */ /*#define HAS_CSH / **/ #ifdef HAS_CSH #define CSH "" /**/ #endif /* HAS_CTERMID_R: * This symbol, if defined, indicates that the ctermid_r routine * is available to ctermid re-entrantly. */ /* CTERMID_R_PROTO: * This symbol encodes the prototype of ctermid_r. * It is zero if d_ctermid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r * is defined. */ /*#define HAS_CTERMID_R / **/ #define CTERMID_R_PROTO 0 /**/ /* HAS_CTIME_R: * This symbol, if defined, indicates that the ctime_r routine * is available to ctime re-entrantly. */ /* CTIME_R_PROTO: * This symbol encodes the prototype of ctime_r. * It is zero if d_ctime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r * is defined. */ /*#define HAS_CTIME_R / **/ #define CTIME_R_PROTO 0 /**/ /* SETUID_SCRIPTS_ARE_SECURE_NOW: * This symbol, if defined, indicates that the bug that prevents * setuid scripts from being secure is not present in this kernel. */ /* DOSUID: * This symbol, if defined, indicates that the C program should * check the script that it is executing for setuid/setgid bits, and * attempt to emulate setuid/setgid on systems that have disabled * setuid #! scripts because the kernel can't do it securely. * It is up to the package designer to make sure that this emulation * is done securely. Among other things, it should do an fstat on * the script it just opened to make sure it really is a setuid/setgid * script, it should make sure the arguments passed correspond exactly * to the argument on the #! line, and it should not trust any * subprocesses to which it must pass the filename rather than the * file descriptor of the script to be executed. */ /*#define SETUID_SCRIPTS_ARE_SECURE_NOW / **/ /*#define DOSUID / **/ /* HAS_DRAND48_R: * This symbol, if defined, indicates that the drand48_r routine * is available to drand48 re-entrantly. */ /* DRAND48_R_PROTO: * This symbol encodes the prototype of drand48_r. * It is zero if d_drand48_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r * is defined. */ /*#define HAS_DRAND48_R / **/ #define DRAND48_R_PROTO 0 /**/ /* HAS_DRAND48_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the drand48() function. Otherwise, it is up * to the program to supply one. A good guess is * extern double drand48(void); */ /*#define HAS_DRAND48_PROTO / **/ /* HAS_EACCESS: * This symbol, if defined, indicates that the eaccess routine is * available to do extended access checks. */ /*#define HAS_EACCESS / **/ /* HAS_ENDGRENT: * This symbol, if defined, indicates that the getgrent routine is * available for finalizing sequential access of the group database. */ /*#define HAS_ENDGRENT / **/ /* HAS_ENDGRENT_R: * This symbol, if defined, indicates that the endgrent_r routine * is available to endgrent re-entrantly. */ /* ENDGRENT_R_PROTO: * This symbol encodes the prototype of endgrent_r. * It is zero if d_endgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r * is defined. */ /*#define HAS_ENDGRENT_R / **/ #define ENDGRENT_R_PROTO 0 /**/ /* HAS_ENDHOSTENT: * This symbol, if defined, indicates that the endhostent() routine is * available to close whatever was being used for host queries. */ /*#define HAS_ENDHOSTENT / **/ /* HAS_ENDHOSTENT_R: * This symbol, if defined, indicates that the endhostent_r routine * is available to endhostent re-entrantly. */ /* ENDHOSTENT_R_PROTO: * This symbol encodes the prototype of endhostent_r. * It is zero if d_endhostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r * is defined. */ /*#define HAS_ENDHOSTENT_R / **/ #define ENDHOSTENT_R_PROTO 0 /**/ /* HAS_ENDNETENT: * This symbol, if defined, indicates that the endnetent() routine is * available to close whatever was being used for network queries. */ /*#define HAS_ENDNETENT / **/ /* HAS_ENDNETENT_R: * This symbol, if defined, indicates that the endnetent_r routine * is available to endnetent re-entrantly. */ /* ENDNETENT_R_PROTO: * This symbol encodes the prototype of endnetent_r. * It is zero if d_endnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r * is defined. */ /*#define HAS_ENDNETENT_R / **/ #define ENDNETENT_R_PROTO 0 /**/ /* HAS_ENDPROTOENT: * This symbol, if defined, indicates that the endprotoent() routine is * available to close whatever was being used for protocol queries. */ /*#define HAS_ENDPROTOENT / **/ /* HAS_ENDPROTOENT_R: * This symbol, if defined, indicates that the endprotoent_r routine * is available to endprotoent re-entrantly. */ /* ENDPROTOENT_R_PROTO: * This symbol encodes the prototype of endprotoent_r. * It is zero if d_endprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r * is defined. */ /*#define HAS_ENDPROTOENT_R / **/ #define ENDPROTOENT_R_PROTO 0 /**/ /* HAS_ENDPWENT: * This symbol, if defined, indicates that the getgrent routine is * available for finalizing sequential access of the passwd database. */ /*#define HAS_ENDPWENT / **/ /* HAS_ENDPWENT_R: * This symbol, if defined, indicates that the endpwent_r routine * is available to endpwent re-entrantly. */ /* ENDPWENT_R_PROTO: * This symbol encodes the prototype of endpwent_r. * It is zero if d_endpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r * is defined. */ /*#define HAS_ENDPWENT_R / **/ #define ENDPWENT_R_PROTO 0 /**/ /* HAS_ENDSERVENT: * This symbol, if defined, indicates that the endservent() routine is * available to close whatever was being used for service queries. */ /*#define HAS_ENDSERVENT / **/ /* HAS_ENDSERVENT_R: * This symbol, if defined, indicates that the endservent_r routine * is available to endservent re-entrantly. */ /* ENDSERVENT_R_PROTO: * This symbol encodes the prototype of endservent_r. * It is zero if d_endservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r * is defined. */ /*#define HAS_ENDSERVENT_R / **/ #define ENDSERVENT_R_PROTO 0 /**/ /* HAS_FD_SET: * This symbol, when defined, indicates presence of the fd_set typedef * in */ /*#define HAS_FD_SET / **/ /* FLEXFILENAMES: * This symbol, if defined, indicates that the system supports filenames * longer than 14 characters. */ /*#define FLEXFILENAMES / **/ /* Gconvert: * This preprocessor macro is defined to convert a floating point * number to a string without a trailing decimal point. This * emulates the behavior of sprintf("%g"), but is sometimes much more * efficient. If gconvert() is not available, but gcvt() drops the * trailing decimal point, then gcvt() is used. If all else fails, * a macro using sprintf("%g") is used. Arguments for the Gconvert * macro are: value, number of digits, whether trailing zeros should * be retained, and the output buffer. * The usual values are: * d_Gconvert='gconvert((x),(n),(t),(b))' * d_Gconvert='gcvt((x),(n),(b))' * d_Gconvert='sprintf((b),"%.*g",(n),(x))' * The last two assume trailing zeros should not be kept. */ #define Gconvert(x,n,t,b) sprintf((b),"%.*g",(n),(x)) /* HAS_GETGRENT: * This symbol, if defined, indicates that the getgrent routine is * available for sequential access of the group database. */ /*#define HAS_GETGRENT / **/ /* HAS_GETGRENT_R: * This symbol, if defined, indicates that the getgrent_r routine * is available to getgrent re-entrantly. */ /* GETGRENT_R_PROTO: * This symbol encodes the prototype of getgrent_r. * It is zero if d_getgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r * is defined. */ /*#define HAS_GETGRENT_R / **/ #define GETGRENT_R_PROTO 0 /**/ /* HAS_GETGRGID_R: * This symbol, if defined, indicates that the getgrgid_r routine * is available to getgrgid re-entrantly. */ /* GETGRGID_R_PROTO: * This symbol encodes the prototype of getgrgid_r. * It is zero if d_getgrgid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r * is defined. */ /*#define HAS_GETGRGID_R / **/ #define GETGRGID_R_PROTO 0 /**/ /* HAS_GETGRNAM_R: * This symbol, if defined, indicates that the getgrnam_r routine * is available to getgrnam re-entrantly. */ /* GETGRNAM_R_PROTO: * This symbol encodes the prototype of getgrnam_r. * It is zero if d_getgrnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r * is defined. */ /*#define HAS_GETGRNAM_R / **/ #define GETGRNAM_R_PROTO 0 /**/ /* HAS_GETHOSTBYADDR: * This symbol, if defined, indicates that the gethostbyaddr() routine is * available to look up hosts by their IP addresses. */ /*#define HAS_GETHOSTBYADDR / **/ /* HAS_GETHOSTBYNAME: * This symbol, if defined, indicates that the gethostbyname() routine is * available to look up host names in some data base or other. */ /*#define HAS_GETHOSTBYNAME / **/ /* HAS_GETHOSTENT: * This symbol, if defined, indicates that the gethostent() routine is * available to look up host names in some data base or another. */ /*#define HAS_GETHOSTENT / **/ /* HAS_GETHOSTNAME: * This symbol, if defined, indicates that the C program may use the * gethostname() routine to derive the host name. See also HAS_UNAME * and PHOSTNAME. */ /* HAS_UNAME: * This symbol, if defined, indicates that the C program may use the * uname() routine to derive the host name. See also HAS_GETHOSTNAME * and PHOSTNAME. */ /* PHOSTNAME: * This symbol, if defined, indicates the command to feed to the * popen() routine to derive the host name. See also HAS_GETHOSTNAME * and HAS_UNAME. Note that the command uses a fully qualified path, * so that it is safe even if used by a process with super-user * privileges. */ /* HAS_PHOSTNAME: * This symbol, if defined, indicates that the C program may use the * contents of PHOSTNAME as a command to feed to the popen() routine * to derive the host name. */ /*#define HAS_GETHOSTNAME / **/ /*#define HAS_UNAME / **/ /*#define HAS_PHOSTNAME / **/ #ifdef HAS_PHOSTNAME #define PHOSTNAME "/bin/hostname" /* How to get the host name */ #endif /* HAS_GETHOSTBYADDR_R: * This symbol, if defined, indicates that the gethostbyaddr_r routine * is available to gethostbyaddr re-entrantly. */ /* GETHOSTBYADDR_R_PROTO: * This symbol encodes the prototype of gethostbyaddr_r. * It is zero if d_gethostbyaddr_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r * is defined. */ /*#define HAS_GETHOSTBYADDR_R / **/ #define GETHOSTBYADDR_R_PROTO 0 /**/ /* HAS_GETHOSTBYNAME_R: * This symbol, if defined, indicates that the gethostbyname_r routine * is available to gethostbyname re-entrantly. */ /* GETHOSTBYNAME_R_PROTO: * This symbol encodes the prototype of gethostbyname_r. * It is zero if d_gethostbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r * is defined. */ /*#define HAS_GETHOSTBYNAME_R / **/ #define GETHOSTBYNAME_R_PROTO 0 /**/ /* HAS_GETHOSTENT_R: * This symbol, if defined, indicates that the gethostent_r routine * is available to gethostent re-entrantly. */ /* GETHOSTENT_R_PROTO: * This symbol encodes the prototype of gethostent_r. * It is zero if d_gethostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r * is defined. */ /*#define HAS_GETHOSTENT_R / **/ #define GETHOSTENT_R_PROTO 0 /**/ /* HAS_GETHOST_PROTOS: * This symbol, if defined, indicates that includes * prototypes for gethostent(), gethostbyname(), and * gethostbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ /*#define HAS_GETHOST_PROTOS / **/ /* HAS_GETLOGIN_R: * This symbol, if defined, indicates that the getlogin_r routine * is available to getlogin re-entrantly. */ /* GETLOGIN_R_PROTO: * This symbol encodes the prototype of getlogin_r. * It is zero if d_getlogin_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r * is defined. */ /*#define HAS_GETLOGIN_R / **/ #define GETLOGIN_R_PROTO 0 /**/ /* HAS_GETNETBYADDR: * This symbol, if defined, indicates that the getnetbyaddr() routine is * available to look up networks by their IP addresses. */ /*#define HAS_GETNETBYADDR / **/ /* HAS_GETNETBYNAME: * This symbol, if defined, indicates that the getnetbyname() routine is * available to look up networks by their names. */ /*#define HAS_GETNETBYNAME / **/ /* HAS_GETNETENT: * This symbol, if defined, indicates that the getnetent() routine is * available to look up network names in some data base or another. */ /*#define HAS_GETNETENT / **/ /* HAS_GETNETBYADDR_R: * This symbol, if defined, indicates that the getnetbyaddr_r routine * is available to getnetbyaddr re-entrantly. */ /* GETNETBYADDR_R_PROTO: * This symbol encodes the prototype of getnetbyaddr_r. * It is zero if d_getnetbyaddr_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r * is defined. */ /*#define HAS_GETNETBYADDR_R / **/ #define GETNETBYADDR_R_PROTO 0 /**/ /* HAS_GETNETBYNAME_R: * This symbol, if defined, indicates that the getnetbyname_r routine * is available to getnetbyname re-entrantly. */ /* GETNETBYNAME_R_PROTO: * This symbol encodes the prototype of getnetbyname_r. * It is zero if d_getnetbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r * is defined. */ /*#define HAS_GETNETBYNAME_R / **/ #define GETNETBYNAME_R_PROTO 0 /**/ /* HAS_GETNETENT_R: * This symbol, if defined, indicates that the getnetent_r routine * is available to getnetent re-entrantly. */ /* GETNETENT_R_PROTO: * This symbol encodes the prototype of getnetent_r. * It is zero if d_getnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r * is defined. */ /*#define HAS_GETNETENT_R / **/ #define GETNETENT_R_PROTO 0 /**/ /* HAS_GETNET_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getnetent(), getnetbyname(), and * getnetbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ /*#define HAS_GETNET_PROTOS / **/ /* HAS_GETPAGESIZE: * This symbol, if defined, indicates that the getpagesize system call * is available to get system page size, which is the granularity of * many memory management calls. */ /*#define HAS_GETPAGESIZE / **/ /* HAS_GETPROTOENT: * This symbol, if defined, indicates that the getprotoent() routine is * available to look up protocols in some data base or another. */ /*#define HAS_GETPROTOENT / **/ /* HAS_GETPGRP: * This symbol, if defined, indicates that the getpgrp routine is * available to get the current process group. */ /* USE_BSD_GETPGRP: * This symbol, if defined, indicates that getpgrp needs one * arguments whereas USG one needs none. */ /*#define HAS_GETPGRP / **/ /*#define USE_BSD_GETPGRP / **/ /* HAS_GETPROTOBYNAME: * This symbol, if defined, indicates that the getprotobyname() * routine is available to look up protocols by their name. */ /* HAS_GETPROTOBYNUMBER: * This symbol, if defined, indicates that the getprotobynumber() * routine is available to look up protocols by their number. */ /*#define HAS_GETPROTOBYNAME / **/ /*#define HAS_GETPROTOBYNUMBER / **/ /* HAS_GETPROTOBYNAME_R: * This symbol, if defined, indicates that the getprotobyname_r routine * is available to getprotobyname re-entrantly. */ /* GETPROTOBYNAME_R_PROTO: * This symbol encodes the prototype of getprotobyname_r. * It is zero if d_getprotobyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r * is defined. */ /*#define HAS_GETPROTOBYNAME_R / **/ #define GETPROTOBYNAME_R_PROTO 0 /**/ /* HAS_GETPROTOBYNUMBER_R: * This symbol, if defined, indicates that the getprotobynumber_r routine * is available to getprotobynumber re-entrantly. */ /* GETPROTOBYNUMBER_R_PROTO: * This symbol encodes the prototype of getprotobynumber_r. * It is zero if d_getprotobynumber_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r * is defined. */ /*#define HAS_GETPROTOBYNUMBER_R / **/ #define GETPROTOBYNUMBER_R_PROTO 0 /**/ /* HAS_GETPROTOENT_R: * This symbol, if defined, indicates that the getprotoent_r routine * is available to getprotoent re-entrantly. */ /* GETPROTOENT_R_PROTO: * This symbol encodes the prototype of getprotoent_r. * It is zero if d_getprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r * is defined. */ /*#define HAS_GETPROTOENT_R / **/ #define GETPROTOENT_R_PROTO 0 /**/ /* HAS_GETPROTO_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getprotoent(), getprotobyname(), and * getprotobyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ /*#define HAS_GETPROTO_PROTOS / **/ /* HAS_GETPWENT: * This symbol, if defined, indicates that the getpwent routine is * available for sequential access of the passwd database. * If this is not available, the older getpw() function may be available. */ /*#define HAS_GETPWENT / **/ /* HAS_GETPWENT_R: * This symbol, if defined, indicates that the getpwent_r routine * is available to getpwent re-entrantly. */ /* GETPWENT_R_PROTO: * This symbol encodes the prototype of getpwent_r. * It is zero if d_getpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r * is defined. */ /*#define HAS_GETPWENT_R / **/ #define GETPWENT_R_PROTO 0 /**/ /* HAS_GETPWNAM_R: * This symbol, if defined, indicates that the getpwnam_r routine * is available to getpwnam re-entrantly. */ /* GETPWNAM_R_PROTO: * This symbol encodes the prototype of getpwnam_r. * It is zero if d_getpwnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r * is defined. */ /*#define HAS_GETPWNAM_R / **/ #define GETPWNAM_R_PROTO 0 /**/ /* HAS_GETPWUID_R: * This symbol, if defined, indicates that the getpwuid_r routine * is available to getpwuid re-entrantly. */ /* GETPWUID_R_PROTO: * This symbol encodes the prototype of getpwuid_r. * It is zero if d_getpwuid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r * is defined. */ /*#define HAS_GETPWUID_R / **/ #define GETPWUID_R_PROTO 0 /**/ /* HAS_GETSERVENT: * This symbol, if defined, indicates that the getservent() routine is * available to look up network services in some data base or another. */ /*#define HAS_GETSERVENT / **/ /* HAS_GETSERVBYNAME_R: * This symbol, if defined, indicates that the getservbyname_r routine * is available to getservbyname re-entrantly. */ /* GETSERVBYNAME_R_PROTO: * This symbol encodes the prototype of getservbyname_r. * It is zero if d_getservbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r * is defined. */ /*#define HAS_GETSERVBYNAME_R / **/ #define GETSERVBYNAME_R_PROTO 0 /**/ /* HAS_GETSERVBYPORT_R: * This symbol, if defined, indicates that the getservbyport_r routine * is available to getservbyport re-entrantly. */ /* GETSERVBYPORT_R_PROTO: * This symbol encodes the prototype of getservbyport_r. * It is zero if d_getservbyport_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r * is defined. */ /*#define HAS_GETSERVBYPORT_R / **/ #define GETSERVBYPORT_R_PROTO 0 /**/ /* HAS_GETSERVENT_R: * This symbol, if defined, indicates that the getservent_r routine * is available to getservent re-entrantly. */ /* GETSERVENT_R_PROTO: * This symbol encodes the prototype of getservent_r. * It is zero if d_getservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r * is defined. */ /*#define HAS_GETSERVENT_R / **/ #define GETSERVENT_R_PROTO 0 /**/ /* HAS_GETSERV_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getservent(), getservbyname(), and * getservbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ /*#define HAS_GETSERV_PROTOS / **/ /* HAS_GETSPNAM_R: * This symbol, if defined, indicates that the getspnam_r routine * is available to getspnam re-entrantly. */ /* GETSPNAM_R_PROTO: * This symbol encodes the prototype of getspnam_r. * It is zero if d_getspnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r * is defined. */ /*#define HAS_GETSPNAM_R / **/ #define GETSPNAM_R_PROTO 0 /**/ /* HAS_GETSERVBYNAME: * This symbol, if defined, indicates that the getservbyname() * routine is available to look up services by their name. */ /* HAS_GETSERVBYPORT: * This symbol, if defined, indicates that the getservbyport() * routine is available to look up services by their port. */ /*#define HAS_GETSERVBYNAME / **/ /*#define HAS_GETSERVBYPORT / **/ /* HAS_GMTIME_R: * This symbol, if defined, indicates that the gmtime_r routine * is available to gmtime re-entrantly. */ /* GMTIME_R_PROTO: * This symbol encodes the prototype of gmtime_r. * It is zero if d_gmtime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r * is defined. */ /*#define HAS_GMTIME_R / **/ #define GMTIME_R_PROTO 0 /**/ /* HAS_GNULIBC: * This symbol, if defined, indicates to the C program that * the GNU C library is being used. A better check is to use * the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc. */ /*#define HAS_GNULIBC / **/ #if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE) # define _GNU_SOURCE #endif /* HAS_HTONL: * This symbol, if defined, indicates that the htonl() routine (and * friends htons() ntohl() ntohs()) are available to do network * order byte swapping. */ /* HAS_HTONS: * This symbol, if defined, indicates that the htons() routine (and * friends htonl() ntohl() ntohs()) are available to do network * order byte swapping. */ /* HAS_NTOHL: * This symbol, if defined, indicates that the ntohl() routine (and * friends htonl() htons() ntohs()) are available to do network * order byte swapping. */ /* HAS_NTOHS: * This symbol, if defined, indicates that the ntohs() routine (and * friends htonl() htons() ntohl()) are available to do network * order byte swapping. */ /*#define HAS_HTONL / **/ /*#define HAS_HTONS / **/ /*#define HAS_NTOHL / **/ /*#define HAS_NTOHS / **/ /* HAS_ISASCII: * This manifest constant lets the C program know that isascii * is available. */ /*#define HAS_ISASCII / **/ /* HAS_LCHOWN: * This symbol, if defined, indicates that the lchown routine is * available to operate on a symbolic link (instead of following the * link). */ /*#define HAS_LCHOWN / **/ /* HAS_LOCALTIME_R: * This symbol, if defined, indicates that the localtime_r routine * is available to localtime re-entrantly. */ /* LOCALTIME_R_NEEDS_TZSET: * Many libc's localtime_r implementations do not call tzset, * making them differ from localtime(), and making timezone * changes using $ENV{TZ} without explicitly calling tzset * impossible. This symbol makes us call tzset before localtime_r */ /*#define LOCALTIME_R_NEEDS_TZSET / **/ #ifdef LOCALTIME_R_NEEDS_TZSET #define L_R_TZSET tzset(), #else #define L_R_TZSET #endif /* LOCALTIME_R_PROTO: * This symbol encodes the prototype of localtime_r. * It is zero if d_localtime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r * is defined. */ /*#define HAS_LOCALTIME_R / **/ #define LOCALTIME_R_PROTO 0 /**/ /* HAS_LONG_DOUBLE: * This symbol will be defined if the C compiler supports long * doubles. */ /* LONG_DOUBLESIZE: * This symbol contains the size of a long double, so that the * C preprocessor can make decisions based on it. It is only * defined if the system supports long doubles. */ /*#define HAS_LONG_DOUBLE / **/ #ifdef HAS_LONG_DOUBLE #define LONG_DOUBLESIZE 8 /**/ #endif /* HAS_LONG_LONG: * This symbol will be defined if the C compiler supports long long. */ /* LONGLONGSIZE: * This symbol contains the size of a long long, so that the * C preprocessor can make decisions based on it. It is only * defined if the system supports long long. */ /*#define HAS_LONG_LONG / **/ #ifdef HAS_LONG_LONG #define LONGLONGSIZE 8 /**/ #endif /* HAS_LSEEK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the lseek() function. Otherwise, it is up * to the program to supply one. A good guess is * extern off_t lseek(int, off_t, int); */ /*#define HAS_LSEEK_PROTO / **/ /* HAS_MEMCHR: * This symbol, if defined, indicates that the memchr routine is available * to locate characters within a C string. */ #define HAS_MEMCHR /**/ /* HAS_MKSTEMP: * This symbol, if defined, indicates that the mkstemp routine is * available to exclusively create and open a uniquely named * temporary file. */ /*#define HAS_MKSTEMP / **/ /* HAS_MMAP: * This symbol, if defined, indicates that the mmap system call is * available to map a file into memory. */ /* Mmap_t: * This symbol holds the return type of the mmap() system call * (and simultaneously the type of the first argument). * Usually set to 'void *' or 'caddr_t'. */ /*#define HAS_MMAP / **/ #define Mmap_t void * /**/ /* HAS_MSG: * This symbol, if defined, indicates that the entire msg*(2) library is * supported (IPC mechanism based on message queues). */ /*#define HAS_MSG / **/ /* HAS_OPEN3: * This manifest constant lets the C program know that the three * argument form of open(2) is available. */ /*#define HAS_OPEN3 / **/ /* OLD_PTHREAD_CREATE_JOINABLE: * This symbol, if defined, indicates how to create pthread * in joinable (aka undetached) state. NOTE: not defined * if pthread.h already has defined PTHREAD_CREATE_JOINABLE * (the new version of the constant). * If defined, known values are PTHREAD_CREATE_UNDETACHED * and __UNDETACHED. */ /*#define OLD_PTHREAD_CREATE_JOINABLE / **/ /* HAS_PTHREAD_ATFORK: * This symbol, if defined, indicates that the pthread_atfork routine * is available to setup fork handlers. */ /*#define HAS_PTHREAD_ATFORK / **/ /* HAS_PTHREAD_YIELD: * This symbol, if defined, indicates that the pthread_yield * routine is available to yield the execution of the current * thread. sched_yield is preferable to pthread_yield. */ /* SCHED_YIELD: * This symbol defines the way to yield the execution of * the current thread. Known ways are sched_yield, * pthread_yield, and pthread_yield with NULL. */ /* HAS_SCHED_YIELD: * This symbol, if defined, indicates that the sched_yield * routine is available to yield the execution of the current * thread. sched_yield is preferable to pthread_yield. */ /*#define HAS_PTHREAD_YIELD / **/ #define SCHED_YIELD sched_yield() /**/ /*#define HAS_SCHED_YIELD / **/ /* HAS_RANDOM_R: * This symbol, if defined, indicates that the random_r routine * is available to random re-entrantly. */ /* RANDOM_R_PROTO: * This symbol encodes the prototype of random_r. * It is zero if d_random_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r * is defined. */ /*#define HAS_RANDOM_R / **/ #define RANDOM_R_PROTO 0 /**/ /* HAS_READDIR64_R: * This symbol, if defined, indicates that the readdir64_r routine * is available to readdir64 re-entrantly. */ /* READDIR64_R_PROTO: * This symbol encodes the prototype of readdir64_r. * It is zero if d_readdir64_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r * is defined. */ /*#define HAS_READDIR64_R / **/ #define READDIR64_R_PROTO 0 /**/ /* HAS_READDIR_R: * This symbol, if defined, indicates that the readdir_r routine * is available to readdir re-entrantly. */ /* READDIR_R_PROTO: * This symbol encodes the prototype of readdir_r. * It is zero if d_readdir_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r * is defined. */ /*#define HAS_READDIR_R / **/ #define READDIR_R_PROTO 0 /**/ /* HAS_SAFE_BCOPY: * This symbol, if defined, indicates that the bcopy routine is available * to copy potentially overlapping memory blocks. Normally, you should * probably use memmove() or memcpy(). If neither is defined, roll your * own version. */ /*#define HAS_SAFE_BCOPY / **/ /* HAS_SAFE_MEMCPY: * This symbol, if defined, indicates that the memcpy routine is available * to copy potentially overlapping memory blocks. If you need to * copy overlapping memory blocks, you should check HAS_MEMMOVE and * use memmove() instead, if available. */ /*#define HAS_SAFE_MEMCPY / **/ /* HAS_SANE_MEMCMP: * This symbol, if defined, indicates that the memcmp routine is available * and can be used to compare relative magnitudes of chars with their high * bits set. If it is not defined, roll your own version. */ /*#define HAS_SANE_MEMCMP / **/ /* HAS_SEM: * This symbol, if defined, indicates that the entire sem*(2) library is * supported. */ /*#define HAS_SEM / **/ /* HAS_SETGRENT: * This symbol, if defined, indicates that the setgrent routine is * available for initializing sequential access of the group database. */ /*#define HAS_SETGRENT / **/ /* HAS_SETGRENT_R: * This symbol, if defined, indicates that the setgrent_r routine * is available to setgrent re-entrantly. */ /* SETGRENT_R_PROTO: * This symbol encodes the prototype of setgrent_r. * It is zero if d_setgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r * is defined. */ /*#define HAS_SETGRENT_R / **/ #define SETGRENT_R_PROTO 0 /**/ /* HAS_SETHOSTENT: * This symbol, if defined, indicates that the sethostent() routine is * available. */ /*#define HAS_SETHOSTENT / **/ /* HAS_SETHOSTENT_R: * This symbol, if defined, indicates that the sethostent_r routine * is available to sethostent re-entrantly. */ /* SETHOSTENT_R_PROTO: * This symbol encodes the prototype of sethostent_r. * It is zero if d_sethostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r * is defined. */ /*#define HAS_SETHOSTENT_R / **/ #define SETHOSTENT_R_PROTO 0 /**/ /* HAS_SETLOCALE_R: * This symbol, if defined, indicates that the setlocale_r routine * is available to setlocale re-entrantly. */ /* SETLOCALE_R_PROTO: * This symbol encodes the prototype of setlocale_r. * It is zero if d_setlocale_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r * is defined. */ /*#define HAS_SETLOCALE_R / **/ #define SETLOCALE_R_PROTO 0 /**/ /* HAS_SETNETENT: * This symbol, if defined, indicates that the setnetent() routine is * available. */ /*#define HAS_SETNETENT / **/ /* HAS_SETNETENT_R: * This symbol, if defined, indicates that the setnetent_r routine * is available to setnetent re-entrantly. */ /* SETNETENT_R_PROTO: * This symbol encodes the prototype of setnetent_r. * It is zero if d_setnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r * is defined. */ /*#define HAS_SETNETENT_R / **/ #define SETNETENT_R_PROTO 0 /**/ /* HAS_SETPROTOENT: * This symbol, if defined, indicates that the setprotoent() routine is * available. */ /*#define HAS_SETPROTOENT / **/ /* HAS_SETPGRP: * This symbol, if defined, indicates that the setpgrp routine is * available to set the current process group. */ /* USE_BSD_SETPGRP: * This symbol, if defined, indicates that setpgrp needs two * arguments whereas USG one needs none. See also HAS_SETPGID * for a POSIX interface. */ /*#define HAS_SETPGRP / **/ /*#define USE_BSD_SETPGRP / **/ /* HAS_SETPROTOENT_R: * This symbol, if defined, indicates that the setprotoent_r routine * is available to setprotoent re-entrantly. */ /* SETPROTOENT_R_PROTO: * This symbol encodes the prototype of setprotoent_r. * It is zero if d_setprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r * is defined. */ /*#define HAS_SETPROTOENT_R / **/ #define SETPROTOENT_R_PROTO 0 /**/ /* HAS_SETPWENT: * This symbol, if defined, indicates that the setpwent routine is * available for initializing sequential access of the passwd database. */ /*#define HAS_SETPWENT / **/ /* HAS_SETPWENT_R: * This symbol, if defined, indicates that the setpwent_r routine * is available to setpwent re-entrantly. */ /* SETPWENT_R_PROTO: * This symbol encodes the prototype of setpwent_r. * It is zero if d_setpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r * is defined. */ /*#define HAS_SETPWENT_R / **/ #define SETPWENT_R_PROTO 0 /**/ /* HAS_SETSERVENT: * This symbol, if defined, indicates that the setservent() routine is * available. */ /*#define HAS_SETSERVENT / **/ /* HAS_SETSERVENT_R: * This symbol, if defined, indicates that the setservent_r routine * is available to setservent re-entrantly. */ /* SETSERVENT_R_PROTO: * This symbol encodes the prototype of setservent_r. * It is zero if d_setservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r * is defined. */ /*#define HAS_SETSERVENT_R / **/ #define SETSERVENT_R_PROTO 0 /**/ /* HAS_SETVBUF: * This symbol, if defined, indicates that the setvbuf routine is * available to change buffering on an open stdio stream. * to a line-buffered mode. */ /*#define HAS_SETVBUF / **/ /* HAS_SHM: * This symbol, if defined, indicates that the entire shm*(2) library is * supported. */ /*#define HAS_SHM / **/ /* Shmat_t: * This symbol holds the return type of the shmat() system call. * Usually set to 'void *' or 'char *'. */ /* HAS_SHMAT_PROTOTYPE: * This symbol, if defined, indicates that the sys/shm.h includes * a prototype for shmat(). Otherwise, it is up to the program to * guess one. Shmat_t shmat(int, Shmat_t, int) is a good guess, * but not always right so it should be emitted by the program only * when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs. */ #define Shmat_t void * /**/ /*#define HAS_SHMAT_PROTOTYPE / **/ /* HAS_SIGACTION: * This symbol, if defined, indicates that Vr4's sigaction() routine * is available. */ /*#define HAS_SIGACTION / **/ /* HAS_SIGSETJMP: * This variable indicates to the C program that the sigsetjmp() * routine is available to save the calling process's registers * and stack environment for later use by siglongjmp(), and * to optionally save the process's signal mask. See * Sigjmp_buf, Sigsetjmp, and Siglongjmp. */ /* Sigjmp_buf: * This is the buffer type to be used with Sigsetjmp and Siglongjmp. */ /* Sigsetjmp: * This macro is used in the same way as sigsetjmp(), but will invoke * traditional setjmp() if sigsetjmp isn't available. * See HAS_SIGSETJMP. */ /* Siglongjmp: * This macro is used in the same way as siglongjmp(), but will invoke * traditional longjmp() if siglongjmp isn't available. * See HAS_SIGSETJMP. */ /*#define HAS_SIGSETJMP / **/ #ifdef HAS_SIGSETJMP #define Sigjmp_buf sigjmp_buf #define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask)) #define Siglongjmp(buf,retval) siglongjmp((buf),(retval)) #else #define Sigjmp_buf jmp_buf #define Sigsetjmp(buf,save_mask) setjmp((buf)) #define Siglongjmp(buf,retval) longjmp((buf),(retval)) #endif /* HAS_SOCKET: * This symbol, if defined, indicates that the BSD socket interface is * supported. */ /* HAS_SOCKETPAIR: * This symbol, if defined, indicates that the BSD socketpair() call is * supported. */ /* HAS_MSG_CTRUNC: * This symbol, if defined, indicates that the MSG_CTRUNC is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_DONTROUTE: * This symbol, if defined, indicates that the MSG_DONTROUTE is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_OOB: * This symbol, if defined, indicates that the MSG_OOB is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_PEEK: * This symbol, if defined, indicates that the MSG_PEEK is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_PROXY: * This symbol, if defined, indicates that the MSG_PROXY is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_SCM_RIGHTS: * This symbol, if defined, indicates that the SCM_RIGHTS is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_SOCKADDR_SA_LEN: * This symbol, if defined, indicates that the struct sockaddr * structure has a member called sa_len, indicating the length of * the structure. */ /* HAS_SOCKADDR_IN6: * This symbol, if defined, indicates the availability of * struct sockaddr_in6; */ /* HAS_SIN6_SCOPE_ID: * This symbol, if defined, indicates that the struct sockaddr_in6 * structure has a member called sin6_scope_id. */ /* HAS_IPV6_MREQ: * This symbol, if defined, indicates the availability of * struct ipv6_mreq; */ /*#define HAS_SOCKET / **/ /*#define HAS_SOCKETPAIR / **/ /*#define HAS_SOCKADDR_SA_LEN / **/ /*#define HAS_MSG_CTRUNC / **/ /*#define HAS_MSG_DONTROUTE / **/ /*#define HAS_MSG_OOB / **/ /*#define HAS_MSG_PEEK / **/ /*#define HAS_MSG_PROXY / **/ /*#define HAS_SCM_RIGHTS / **/ /*#define HAS_SOCKADDR_IN6 / **/ /*#define HAS_SIN6_SCOPE_ID / **/ /*#define HAS_IPV6_MREQ / **/ /* HAS_SRAND48_R: * This symbol, if defined, indicates that the srand48_r routine * is available to srand48 re-entrantly. */ /* SRAND48_R_PROTO: * This symbol encodes the prototype of srand48_r. * It is zero if d_srand48_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r * is defined. */ /*#define HAS_SRAND48_R / **/ #define SRAND48_R_PROTO 0 /**/ /* HAS_SRANDOM_R: * This symbol, if defined, indicates that the srandom_r routine * is available to srandom re-entrantly. */ /* SRANDOM_R_PROTO: * This symbol encodes the prototype of srandom_r. * It is zero if d_srandom_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r * is defined. */ /*#define HAS_SRANDOM_R / **/ #define SRANDOM_R_PROTO 0 /**/ /* USE_STAT_BLOCKS: * This symbol is defined if this system has a stat structure declaring * st_blksize and st_blocks. */ #ifndef USE_STAT_BLOCKS /*#define USE_STAT_BLOCKS / **/ #endif /* HAS_STATIC_INLINE: * This symbol, if defined, indicates that the C compiler supports * C99-style static inline. That is, the function can't be called * from another translation unit. */ /* PERL_STATIC_INLINE: * This symbol gives the best-guess incantation to use for static * inline functions. If HAS_STATIC_INLINE is defined, this will * give C99-style inline. If HAS_STATIC_INLINE is not defined, * this will give a plain 'static'. It will always be defined * to something that gives static linkage. * Possibilities include * static inline (c99) * static __inline__ (gcc -ansi) * static __inline (MSVC) * static _inline (older MSVC) * static (c89 compilers) */ /*#define HAS_STATIC_INLINE / **/ #define PERL_STATIC_INLINE static /**/ /* USE_STDIO_PTR: * This symbol is defined if the _ptr and _cnt fields (or similar) * of the stdio FILE structure can be used to access the stdio buffer * for a file handle. If this is defined, then the FILE_ptr(fp) * and FILE_cnt(fp) macros will also be defined and should be used * to access these fields. */ /* FILE_ptr: * This macro is used to access the _ptr field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_PTR is defined. */ /* STDIO_PTR_LVALUE: * This symbol is defined if the FILE_ptr macro can be used as an * lvalue. */ /* FILE_cnt: * This macro is used to access the _cnt field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_PTR is defined. */ /* STDIO_CNT_LVALUE: * This symbol is defined if the FILE_cnt macro can be used as an * lvalue. */ /* STDIO_PTR_LVAL_SETS_CNT: * This symbol is defined if using the FILE_ptr macro as an lvalue * to increase the pointer by n has the side effect of decreasing the * value of File_cnt(fp) by n. */ /* STDIO_PTR_LVAL_NOCHANGE_CNT: * This symbol is defined if using the FILE_ptr macro as an lvalue * to increase the pointer by n leaves File_cnt(fp) unchanged. */ /*#define USE_STDIO_PTR / **/ #ifdef USE_STDIO_PTR #define FILE_ptr(fp) ((fp)->_IO_read_ptr) /*#define STDIO_PTR_LVALUE / **/ #define FILE_cnt(fp) ((fp)->_IO_read_end - (fp)->_IO_read_ptr) /*#define STDIO_CNT_LVALUE / **/ /*#define STDIO_PTR_LVAL_SETS_CNT / **/ /*#define STDIO_PTR_LVAL_NOCHANGE_CNT / **/ #endif /* USE_STDIO_BASE: * This symbol is defined if the _base field (or similar) of the * stdio FILE structure can be used to access the stdio buffer for * a file handle. If this is defined, then the FILE_base(fp) macro * will also be defined and should be used to access this field. * Also, the FILE_bufsiz(fp) macro will be defined and should be used * to determine the number of bytes in the buffer. USE_STDIO_BASE * will never be defined unless USE_STDIO_PTR is. */ /* FILE_base: * This macro is used to access the _base field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_BASE is defined. */ /* FILE_bufsiz: * This macro is used to determine the number of bytes in the I/O * buffer pointed to by _base field (or equivalent) of the FILE * structure pointed to its argument. This macro will always be defined * if USE_STDIO_BASE is defined. */ /*#define USE_STDIO_BASE / **/ #ifdef USE_STDIO_BASE #define FILE_base(fp) ((fp)->_IO_read_base) #define FILE_bufsiz(fp) ((fp)->_IO_read_end - (fp)->_IO_read_base) #endif /* USE_STRUCT_COPY: * This symbol, if defined, indicates that this C compiler knows how * to copy structures. If undefined, you'll need to use a block copy * routine of some sort instead. */ /*#define USE_STRUCT_COPY / **/ /* HAS_STRERROR: * This symbol, if defined, indicates that the strerror routine is * available to translate error numbers to strings. See the writeup * of Strerror() in this file before you try to define your own. */ /* HAS_SYS_ERRLIST: * This symbol, if defined, indicates that the sys_errlist array is * available to translate error numbers to strings. The extern int * sys_nerr gives the size of that table. */ /* Strerror: * This preprocessor symbol is defined as a macro if strerror() is * not available to translate error numbers to strings but sys_errlist[] * array is there. */ /*#define HAS_STRERROR / **/ /*#define HAS_SYS_ERRLIST / **/ #define Strerror(e) strerror(e) /* HAS_STRERROR_R: * This symbol, if defined, indicates that the strerror_r routine * is available to strerror re-entrantly. */ /* STRERROR_R_PROTO: * This symbol encodes the prototype of strerror_r. * It is zero if d_strerror_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r * is defined. */ /*#define HAS_STRERROR_R / **/ #define STRERROR_R_PROTO 0 /**/ /* HAS_STRTOUL: * This symbol, if defined, indicates that the strtoul routine is * available to provide conversion of strings to unsigned long. */ #define HAS_STRTOUL /**/ /* HAS_TIME: * This symbol, if defined, indicates that the time() routine exists. */ /* Time_t: * This symbol holds the type returned by time(). It can be long, * or time_t on BSD sites (in which case should be * included). */ #define HAS_TIME /**/ #define Time_t time_t /* Time type */ /* HAS_TIMES: * This symbol, if defined, indicates that the times() routine exists. * Note that this became obsolete on some systems (SUNOS), which now * use getrusage(). It may be necessary to include . */ /*#define HAS_TIMES / **/ /* HAS_TMPNAM_R: * This symbol, if defined, indicates that the tmpnam_r routine * is available to tmpnam re-entrantly. */ /* TMPNAM_R_PROTO: * This symbol encodes the prototype of tmpnam_r. * It is zero if d_tmpnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r * is defined. */ /*#define HAS_TMPNAM_R / **/ #define TMPNAM_R_PROTO 0 /**/ /* HAS_TTYNAME_R: * This symbol, if defined, indicates that the ttyname_r routine * is available to ttyname re-entrantly. */ /* TTYNAME_R_PROTO: * This symbol encodes the prototype of ttyname_r. * It is zero if d_ttyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r * is defined. */ /*#define HAS_TTYNAME_R / **/ #define TTYNAME_R_PROTO 0 /**/ /* HAS_UNION_SEMUN: * This symbol, if defined, indicates that the union semun is * defined by including . If not, the user code * probably needs to define it as: * union semun { * int val; * struct semid_ds *buf; * unsigned short *array; * } */ /* USE_SEMCTL_SEMUN: * This symbol, if defined, indicates that union semun is * used for semctl IPC_STAT. */ /* USE_SEMCTL_SEMID_DS: * This symbol, if defined, indicates that struct semid_ds * is * used for semctl IPC_STAT. */ /*#define HAS_UNION_SEMUN / **/ /*#define USE_SEMCTL_SEMUN / **/ /*#define USE_SEMCTL_SEMID_DS / **/ /* HAS_VFORK: * This symbol, if defined, indicates that vfork() exists. */ /*#define HAS_VFORK / **/ /* HAS_PSEUDOFORK: * This symbol, if defined, indicates that an emulation of the * fork routine is available. */ /*#define HAS_PSEUDOFORK / **/ /* Signal_t: * This symbol's value is either "void" or "int", corresponding to the * appropriate return type of a signal handler. Thus, you can declare * a signal handler using "Signal_t (*handler)()", and define the * handler using "Signal_t handler(sig)". */ #define Signal_t int /* Signal handler's return type */ /* HASVOLATILE: * This symbol, if defined, indicates that this C compiler knows about * the volatile declaration. */ /*#define HASVOLATILE / **/ #ifndef HASVOLATILE #define volatile #endif /* HAS_VPRINTF: * This symbol, if defined, indicates that the vprintf routine is available * to printf with a pointer to an argument list. If unavailable, you * may need to write your own, probably in terms of _doprnt(). */ /* USE_CHAR_VSPRINTF: * This symbol is defined if this system has vsprintf() returning type * (char*). The trend seems to be to declare it as "int vsprintf()". It * is up to the package author to declare vsprintf correctly based on the * symbol. */ #define HAS_VPRINTF /**/ /*#define USE_CHAR_VSPRINTF / **/ /* DOUBLESIZE: * This symbol contains the size of a double, so that the C preprocessor * can make decisions based on it. */ #define DOUBLESIZE 8 /**/ /* EBCDIC: * This symbol, if defined, indicates that this system uses * EBCDIC encoding. */ /*#define EBCDIC / **/ /* Fpos_t: * This symbol holds the type used to declare file positions in libc. * It can be fpos_t, long, uint, etc... It may be necessary to include * to get any typedef'ed information. */ #define Fpos_t int /* File position type */ /* Gid_t_f: * This symbol defines the format string used for printing a Gid_t. */ #define Gid_t_f "lu" /**/ /* Gid_t_sign: * This symbol holds the signedess of a Gid_t. * 1 for unsigned, -1 for signed. */ #define Gid_t_sign 1 /* GID sign */ /* Gid_t_size: * This symbol holds the size of a Gid_t in bytes. */ #define Gid_t_size 4 /* GID size */ /* Gid_t: * This symbol holds the return type of getgid() and the type of * argument to setrgid() and related functions. Typically, * it is the type of group ids in the kernel. It can be int, ushort, * gid_t, etc... It may be necessary to include to get * any typedef'ed information. */ #define Gid_t int /* Type for getgid(), etc... */ /* I_DIRENT: * This symbol, if defined, indicates to the C program that it should * include . Using this symbol also triggers the definition * of the Direntry_t define which ends up being 'struct dirent' or * 'struct direct' depending on the availability of . */ /* DIRNAMLEN: * This symbol, if defined, indicates to the C program that the length * of directory entry names is provided by a d_namlen field. Otherwise * you need to do strlen() on the d_name field. */ /* Direntry_t: * This symbol is set to 'struct direct' or 'struct dirent' depending on * whether dirent is available or not. You should use this pseudo type to * portably declare your directory entries. */ #define I_DIRENT /**/ /*#define DIRNAMLEN / **/ #define Direntry_t struct dirent /* I_GRP: * This symbol, if defined, indicates to the C program that it should * include . */ /* GRPASSWD: * This symbol, if defined, indicates to the C program that struct group * in contains gr_passwd. */ /*#define I_GRP / **/ /*#define GRPASSWD / **/ /* I_MACH_CTHREADS: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MACH_CTHREADS / **/ /* I_NDBM: * This symbol, if defined, indicates that exists and should * be included. */ /* I_GDBMNDBM: * This symbol, if defined, indicates that exists and should * be included. This was the location of the ndbm.h compatibility file * in RedHat 7.1. */ /* I_GDBM_NDBM: * This symbol, if defined, indicates that exists and should * be included. This is the location of the ndbm.h compatibility file * in Debian 4.0. */ /* NDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /* GDBMNDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /* GDBM_NDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /*#define I_NDBM / **/ /*#define I_GDBMNDBM / **/ /*#define I_GDBM_NDBM / **/ /*#define NDBM_H_USES_PROTOTYPES / **/ /*#define GDBMNDBM_H_USES_PROTOTYPES / **/ /*#define GDBM_NDBM_H_USES_PROTOTYPES / **/ /* I_NETDB: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_NETDB / **/ /* I_NET_ERRNO: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_NET_ERRNO / **/ /* I_PTHREAD: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_PTHREAD / **/ /* I_PWD: * This symbol, if defined, indicates to the C program that it should * include . */ /* PWQUOTA: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_quota. */ /* PWAGE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_age. */ /* PWCHANGE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_change. */ /* PWCLASS: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_class. */ /* PWEXPIRE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_expire. */ /* PWCOMMENT: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_comment. */ /* PWGECOS: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_gecos. */ /* PWPASSWD: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_passwd. */ /*#define I_PWD / **/ /*#define PWQUOTA / **/ /*#define PWAGE / **/ /*#define PWCHANGE / **/ /*#define PWCLASS / **/ /*#define PWEXPIRE / **/ /*#define PWCOMMENT / **/ /*#define PWGECOS / **/ /*#define PWPASSWD / **/ /* I_SYS_ACCESS: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_ACCESS / **/ /* I_SYS_SECURITY: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_SECURITY / **/ /* I_SYSUIO: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYSUIO / **/ /* I_TIME: * This symbol, if defined, indicates to the C program that it should * include . */ /* I_SYS_TIME: * This symbol, if defined, indicates to the C program that it should * include . */ /* I_SYS_TIME_KERNEL: * This symbol, if defined, indicates to the C program that it should * include with KERNEL defined. */ /* HAS_TM_TM_ZONE: * This symbol, if defined, indicates to the C program that * the struct tm has a tm_zone field. */ /* HAS_TM_TM_GMTOFF: * This symbol, if defined, indicates to the C program that * the struct tm has a tm_gmtoff field. */ #define I_TIME /**/ /*#define I_SYS_TIME / **/ /*#define I_SYS_TIME_KERNEL / **/ /*#define HAS_TM_TM_ZONE / **/ /*#define HAS_TM_TM_GMTOFF / **/ /* I_STDARG: * This symbol, if defined, indicates that exists and should * be included. */ /* I_VARARGS: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_STDARG /**/ /*#define I_VARARGS / **/ /* PERL_INC_VERSION_LIST: * This variable specifies the list of subdirectories in over * which perl.c:incpush() and lib/lib.pm will automatically * search when adding directories to @INC, in a format suitable * for a C initialization string. See the inc_version_list entry * in Porting/Glossary for more details. */ /*#define PERL_INC_VERSION_LIST NULL / **/ /* INSTALL_USR_BIN_PERL: * This symbol, if defined, indicates that Perl is to be installed * also as /usr/bin/perl. */ /*#define INSTALL_USR_BIN_PERL / **/ /* Off_t: * This symbol holds the type used to declare offsets in the kernel. * It can be int, long, off_t, etc... It may be necessary to include * to get any typedef'ed information. */ /* LSEEKSIZE: * This symbol holds the number of bytes used by the Off_t. */ /* Off_t_size: * This symbol holds the number of bytes used by the Off_t. */ #define Off_t int /* type */ #define LSEEKSIZE 4 /* size */ #define Off_t_size 4 /* size */ /* Free_t: * This variable contains the return type of free(). It is usually * void, but occasionally int. */ /* Malloc_t: * This symbol is the type of pointer returned by malloc and realloc. */ #define Malloc_t void * /**/ #define Free_t void /**/ /* PERL_MALLOC_WRAP: * This symbol, if defined, indicates that we'd like malloc wrap checks. */ /*#define PERL_MALLOC_WRAP / **/ /* MYMALLOC: * This symbol, if defined, indicates that we're using our own malloc. */ /*#define MYMALLOC / **/ /* Mode_t: * This symbol holds the type used to declare file modes * for systems calls. It is usually mode_t, but may be * int or unsigned short. It may be necessary to include * to get any typedef'ed information. */ #define Mode_t int /* file mode parameter for system calls */ /* VAL_O_NONBLOCK: * This symbol is to be used during open() or fcntl(F_SETFL) to turn on * non-blocking I/O for the file descriptor. Note that there is no way * back, i.e. you cannot turn it blocking again this way. If you wish to * alternatively switch between blocking and non-blocking, use the * ioctl(FIOSNBIO) call instead, but that is not supported by all devices. */ /* VAL_EAGAIN: * This symbol holds the errno error code set by read() when no data was * present on the non-blocking file descriptor. */ /* RD_NODATA: * This symbol holds the return code from read() when no data is present * on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is * not defined, then you can't distinguish between no data and EOF by * issuing a read(). You'll have to find another way to tell for sure! */ /* EOF_NONBLOCK: * This symbol, if defined, indicates to the C program that a read() on * a non-blocking file descriptor will return 0 on EOF, and not the value * held in RD_NODATA (-1 usually, in that case!). */ #define VAL_O_NONBLOCK O_NONBLOCK #define VAL_EAGAIN EAGAIN #define RD_NODATA -1 #undef EOF_NONBLOCK /* Netdb_host_t: * This symbol holds the type used for the 1st argument * to gethostbyaddr(). */ /* Netdb_hlen_t: * This symbol holds the type used for the 2nd argument * to gethostbyaddr(). */ /* Netdb_name_t: * This symbol holds the type used for the argument to * gethostbyname(). */ /* Netdb_net_t: * This symbol holds the type used for the 1st argument to * getnetbyaddr(). */ #define Netdb_host_t const char * /**/ #define Netdb_hlen_t int /**/ #define Netdb_name_t const char * /**/ #define Netdb_net_t unsigned long /**/ /* PERL_OTHERLIBDIRS: * This variable contains a colon-separated set of paths for the perl * binary to search for additional library files or modules. * These directories will be tacked to the end of @INC. * Perl will automatically search below each path for version- * and architecture-specific directories. See PERL_INC_VERSION_LIST * for more details. */ /*#define PERL_OTHERLIBDIRS " " / **/ /* Pid_t: * This symbol holds the type used to declare process ids in the kernel. * It can be int, uint, pid_t, etc... It may be necessary to include * to get any typedef'ed information. */ #define Pid_t int /* PID type */ /* PRIVLIB: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. */ /* PRIVLIB_EXP: * This symbol contains the ~name expanded version of PRIVLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ #define PRIVLIB "/usr/local/lib/perl5/5.16" /**/ #define PRIVLIB_EXP "/usr/local/lib/perl5/5.16" /**/ /* CAN_PROTOTYPE: * If defined, this macro indicates that the C compiler can handle * function prototypes. */ /* _: * This macro is used to declare function parameters for folks who want * to make declarations with prototypes using a different style than * the above macros. Use double parentheses. For example: * * int main _((int argc, char *argv[])); */ /*#define CAN_PROTOTYPE / **/ #ifdef CAN_PROTOTYPE #define _(args) args #else #define _(args) () #endif /* PTRSIZE: * This symbol contains the size of a pointer, so that the C preprocessor * can make decisions based on it. It will be sizeof(void *) if * the compiler supports (void *); otherwise it will be * sizeof(char *). */ #define PTRSIZE 4 /**/ /* HAS_QUAD: * This symbol, if defined, tells that there's a 64-bit integer type, * Quad_t, and its unsigned counterpart, Uquad_t. QUADKIND will be one * of QUAD_IS_INT, QUAD_IS_LONG, QUAD_IS_LONG_LONG, QUAD_IS_INT64_T, * or QUAD_IS___INT64. */ /*#define HAS_QUAD / **/ #ifdef HAS_QUAD # define Quad_t int64_t /**/ # define Uquad_t uint64_t /**/ # define QUADKIND 4 /**/ # define QUAD_IS_INT 1 # define QUAD_IS_LONG 2 # define QUAD_IS_LONG_LONG 3 # define QUAD_IS_INT64_T 4 # define QUAD_IS___INT64 5 #endif /* Drand01: * This macro is to be used to generate uniformly distributed * random numbers over the range [0., 1.[. You may have to supply * an 'extern double drand48();' in your program since SunOS 4.1.3 * doesn't provide you with anything relevant in its headers. * See HAS_DRAND48_PROTO. */ /* Rand_seed_t: * This symbol defines the type of the argument of the * random seed function. */ /* seedDrand01: * This symbol defines the macro to be used in seeding the * random number generator (see Drand01). */ /* RANDBITS: * This symbol indicates how many bits are produced by the * function used to generate normalized random numbers. * Values include 15, 16, 31, and 48. */ #define Drand01() ((rand() & 0x7FFF) / (double) ((unsigned long)1 << 15)) /**/ #define Rand_seed_t int /**/ #define seedDrand01(x) srand((Rand_seed_t)x) /**/ #define RANDBITS 48 /**/ /* Select_fd_set_t: * This symbol holds the type used for the 2nd, 3rd, and 4th * arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET * is defined, and 'int *' otherwise. This is only useful if you * have select(), of course. */ #define Select_fd_set_t int /**/ /* SH_PATH: * This symbol contains the full pathname to the shell used on this * on this system to execute Bourne shell scripts. Usually, this will be * /bin/sh, though it's possible that some systems will have /bin/ksh, * /bin/pdksh, /bin/ash, /bin/bash, or even something such as * D:/bin/sh.exe. */ #define SH_PATH "/bin/sh" /**/ /* SIG_NAME: * This symbol contains a list of signal names in order of * signal number. This is intended * to be used as a static array initialization, like this: * char *sig_name[] = { SIG_NAME }; * The signals in the list are separated with commas, and each signal * is surrounded by double quotes. There is no leading SIG in the signal * name, i.e. SIGQUIT is known as "QUIT". * Gaps in the signal numbers (up to NSIG) are filled in with NUMnn, * etc., where nn is the actual signal number (e.g. NUM37). * The signal number for sig_name[i] is stored in sig_num[i]. * The last element is 0 to terminate the list with a NULL. This * corresponds to the 0 at the end of the sig_name_init list. * Note that this variable is initialized from the sig_name_init, * not from sig_name (which is unused). */ /* SIG_NUM: * This symbol contains a list of signal numbers, in the same order as the * SIG_NAME list. It is suitable for static array initialization, as in: * int sig_num[] = { SIG_NUM }; * The signals in the list are separated with commas, and the indices * within that list and the SIG_NAME list match, so it's easy to compute * the signal name from a number or vice versa at the price of a small * dynamic linear lookup. * Duplicates are allowed, but are moved to the end of the list. * The signal number corresponding to sig_name[i] is sig_number[i]. * if (i < NSIG) then sig_number[i] == i. * The last element is 0, corresponding to the 0 at the end of * the sig_name_init list. * Note that this variable is initialized from the sig_num_init, * not from sig_num (which is unused). */ /* SIG_SIZE: * This variable contains the number of elements of the SIG_NAME * and SIG_NUM arrays, excluding the final NULL entry. */ #define SIG_NAME 0 /**/ #define SIG_NUM 0 /**/ #define SIG_SIZE 1 /**/ /* SITEARCH: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. * The standard distribution will put nothing in this directory. * After perl has been installed, users may install their own local * architecture-dependent modules in this directory with * MakeMaker Makefile.PL * or equivalent. See INSTALL for details. */ /* SITEARCH_EXP: * This symbol contains the ~name expanded version of SITEARCH, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /*#define SITEARCH "/usr/local/lib/perl5/5.16/unknown" / **/ /*#define SITEARCH_EXP "/usr/local/lib/perl5/5.16/unknown" / **/ /* SITELIB: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. * The standard distribution will put nothing in this directory. * After perl has been installed, users may install their own local * architecture-independent modules in this directory with * MakeMaker Makefile.PL * or equivalent. See INSTALL for details. */ /* SITELIB_EXP: * This symbol contains the ~name expanded version of SITELIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /* SITELIB_STEM: * This define is SITELIB_EXP with any trailing version-specific component * removed. The elements in inc_version_list (inc_version_list.U) can * be tacked onto this variable to generate a list of directories to search. */ #define SITELIB "/usr/local/lib/perl5/5.16" /**/ #define SITELIB_EXP "/usr/local/lib/perl5/5.16" /**/ #define SITELIB_STEM "/usr/local/lib/perl5" /**/ /* Size_t_size: * This symbol holds the size of a Size_t in bytes. */ #define Size_t_size 4 /**/ /* Size_t: * This symbol holds the type used to declare length parameters * for string functions. It is usually size_t, but may be * unsigned long, int, etc. It may be necessary to include * to get any typedef'ed information. */ #define Size_t size_t /* length parameter for string functions */ /* Sock_size_t: * This symbol holds the type used for the size argument of * various socket calls (just the base type, not the pointer-to). */ #define Sock_size_t int /**/ /* SSize_t: * This symbol holds the type used by functions that return * a count of bytes or an error condition. It must be a signed type. * It is usually ssize_t, but may be long or int, etc. * It may be necessary to include or * to get any typedef'ed information. * We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). */ #define SSize_t int /* signed count of bytes */ /* STDCHAR: * This symbol is defined to be the type of char used in stdio.h. * It has the values "unsigned char" or "char". */ #define STDCHAR char /**/ /* Uid_t_f: * This symbol defines the format string used for printing a Uid_t. */ #define Uid_t_f "lu" /**/ /* Uid_t_sign: * This symbol holds the signedess of a Uid_t. * 1 for unsigned, -1 for signed. */ #define Uid_t_sign 1 /* UID sign */ /* Uid_t_size: * This symbol holds the size of a Uid_t in bytes. */ #define Uid_t_size 4 /* UID size */ /* Uid_t: * This symbol holds the type used to declare user ids in the kernel. * It can be int, ushort, uid_t, etc... It may be necessary to include * to get any typedef'ed information. */ #define Uid_t int /* UID type */ /* USE_ITHREADS: * This symbol, if defined, indicates that Perl should be built to * use the interpreter-based threading implementation. */ /* USE_5005THREADS: * This symbol, if defined, indicates that Perl should be built to * use the 5.005-based threading implementation. * Only valid up to 5.8.x. */ /* OLD_PTHREADS_API: * This symbol, if defined, indicates that Perl should * be built to use the old draft POSIX threads API. */ /* USE_REENTRANT_API: * This symbol, if defined, indicates that Perl should * try to use the various _r versions of library functions. * This is extremely experimental. */ /*#define USE_5005THREADS / **/ /*#define USE_ITHREADS / **/ #if defined(USE_5005THREADS) && !defined(USE_ITHREADS) #define USE_THREADS /* until src is revised*/ #endif /*#define OLD_PTHREADS_API / **/ /*#define USE_REENTRANT_API / **/ /* PERL_VENDORARCH: * If defined, this symbol contains the name of a private library. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. * It may have a ~ on the front. * The standard distribution will put nothing in this directory. * Vendors who distribute perl may wish to place their own * architecture-dependent modules and extensions in this directory with * MakeMaker Makefile.PL INSTALLDIRS=vendor * or equivalent. See INSTALL for details. */ /* PERL_VENDORARCH_EXP: * This symbol contains the ~name expanded version of PERL_VENDORARCH, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /*#define PERL_VENDORARCH "" / **/ /*#define PERL_VENDORARCH_EXP "" / **/ /* PERL_VENDORLIB_EXP: * This symbol contains the ~name expanded version of VENDORLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /* PERL_VENDORLIB_STEM: * This define is PERL_VENDORLIB_EXP with any trailing version-specific component * removed. The elements in inc_version_list (inc_version_list.U) can * be tacked onto this variable to generate a list of directories to search. */ /*#define PERL_VENDORLIB_EXP "" / **/ /*#define PERL_VENDORLIB_STEM "" / **/ /* VOIDFLAGS: * This symbol indicates how much support of the void type is given by this * compiler. What various bits mean: * * 1 = supports declaration of void * 2 = supports arrays of pointers to functions returning void * 4 = supports comparisons between pointers to void functions and * addresses of void functions * 8 = supports declaration of generic void pointers * * The package designer should define VOIDUSED to indicate the requirements * of the package. This can be done either by #defining VOIDUSED before * including config.h, or by defining defvoidused in Myinit.U. If the * latter approach is taken, only those flags will be tested. If the * level of void support necessary is not present, defines void to int. */ #ifndef VOIDUSED #define VOIDUSED 1 #endif #define VOIDFLAGS 1 #if (VOIDFLAGS & VOIDUSED) != VOIDUSED #define void int /* is void to be avoided? */ #define M_VOID /* Xenix strikes again */ #endif /* PERL_USE_DEVEL: * This symbol, if defined, indicates that Perl was configured with * -Dusedevel, to enable development features. This should not be * done for production builds. */ /*#define PERL_USE_DEVEL / **/ /* HAS_ATOLF: * This symbol, if defined, indicates that the atolf routine is * available to convert strings into long doubles. */ /*#define HAS_ATOLF / **/ /* HAS_ATOLL: * This symbol, if defined, indicates that the atoll routine is * available to convert strings into long longs. */ /*#define HAS_ATOLL / **/ /* HAS__FWALK: * This symbol, if defined, indicates that the _fwalk system call is * available to apply a function to all the file handles. */ /*#define HAS__FWALK / **/ /* HAS_AINTL: * This symbol, if defined, indicates that the aintl routine is * available. If copysignl is also present we can emulate modfl. */ /*#define HAS_AINTL / **/ /* HAS_BUILTIN_CHOOSE_EXPR: * Can we handle GCC builtin for compile-time ternary-like expressions */ /* HAS_BUILTIN_EXPECT: * Can we handle GCC builtin for telling that certain values are more * likely */ /*#define HAS_BUILTIN_EXPECT / **/ /*#define HAS_BUILTIN_CHOOSE_EXPR / **/ /* HAS_C99_VARIADIC_MACROS: * If defined, the compiler supports C99 variadic macros. */ /*#define HAS_C99_VARIADIC_MACROS / **/ /* HAS_CLASS: * This symbol, if defined, indicates that the class routine is * available to classify doubles. Available for example in AIX. * The returned values are defined in and are: * * FP_PLUS_NORM Positive normalized, nonzero * FP_MINUS_NORM Negative normalized, nonzero * FP_PLUS_DENORM Positive denormalized, nonzero * FP_MINUS_DENORM Negative denormalized, nonzero * FP_PLUS_ZERO +0.0 * FP_MINUS_ZERO -0.0 * FP_PLUS_INF +INF * FP_MINUS_INF -INF * FP_NANS Signaling Not a Number (NaNS) * FP_NANQ Quiet Not a Number (NaNQ) */ /*#define HAS_CLASS / **/ /* HAS_CLEARENV: * This symbol, if defined, indicates that the clearenv () routine is * available for use. */ /*#define HAS_CLEARENV / **/ /* HAS_STRUCT_CMSGHDR: * This symbol, if defined, indicates that the struct cmsghdr * is supported. */ /*#define HAS_STRUCT_CMSGHDR / **/ /* HAS_COPYSIGNL: * This symbol, if defined, indicates that the copysignl routine is * available. If aintl is also present we can emulate modfl. */ /*#define HAS_COPYSIGNL / **/ /* USE_CPLUSPLUS: * This symbol, if defined, indicates that a C++ compiler was * used to compiled Perl and will be used to compile extensions. */ /*#define USE_CPLUSPLUS / **/ /* HAS_DBMINIT_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the dbminit() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int dbminit(char *); */ /*#define HAS_DBMINIT_PROTO / **/ /* HAS_DIR_DD_FD: * This symbol, if defined, indicates that the the DIR* dirstream * structure contains a member variable named dd_fd. */ /*#define HAS_DIR_DD_FD / **/ /* HAS_DIRFD: * This manifest constant lets the C program know that dirfd * is available. */ /*#define HAS_DIRFD / **/ /* DLSYM_NEEDS_UNDERSCORE: * This symbol, if defined, indicates that we need to prepend an * underscore to the symbol name before calling dlsym(). This only * makes sense if you *have* dlsym, which we will presume is the * case if you're using dl_dlopen.xs. */ /*#define DLSYM_NEEDS_UNDERSCORE / **/ /* HAS_FAST_STDIO: * This symbol, if defined, indicates that the "fast stdio" * is available to manipulate the stdio buffers directly. */ /*#define HAS_FAST_STDIO / **/ /* HAS_FCHDIR: * This symbol, if defined, indicates that the fchdir routine is * available to change directory using a file descriptor. */ /*#define HAS_FCHDIR / **/ /* FCNTL_CAN_LOCK: * This symbol, if defined, indicates that fcntl() can be used * for file locking. Normally on Unix systems this is defined. * It may be undefined on VMS. */ /*#define FCNTL_CAN_LOCK / **/ /* HAS_FINITE: * This symbol, if defined, indicates that the finite routine is * available to check whether a double is finite (non-infinity non-NaN). */ /*#define HAS_FINITE / **/ /* HAS_FINITEL: * This symbol, if defined, indicates that the finitel routine is * available to check whether a long double is finite * (non-infinity non-NaN). */ /*#define HAS_FINITEL / **/ /* HAS_FLOCK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the flock() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int flock(int, int); */ /*#define HAS_FLOCK_PROTO / **/ /* HAS_FP_CLASS: * This symbol, if defined, indicates that the fp_class routine is * available to classify doubles. Available for example in Digital UNIX. * The returned values are defined in and are: * * FP_SNAN Signaling NaN (Not-a-Number) * FP_QNAN Quiet NaN (Not-a-Number) * FP_POS_INF +infinity * FP_NEG_INF -infinity * FP_POS_NORM Positive normalized * FP_NEG_NORM Negative normalized * FP_POS_DENORM Positive denormalized * FP_NEG_DENORM Negative denormalized * FP_POS_ZERO +0.0 (positive zero) * FP_NEG_ZERO -0.0 (negative zero) */ /*#define HAS_FP_CLASS / **/ /* HAS_FPCLASS: * This symbol, if defined, indicates that the fpclass routine is * available to classify doubles. Available for example in Solaris/SVR4. * The returned values are defined in and are: * * FP_SNAN signaling NaN * FP_QNAN quiet NaN * FP_NINF negative infinity * FP_PINF positive infinity * FP_NDENORM negative denormalized non-zero * FP_PDENORM positive denormalized non-zero * FP_NZERO negative zero * FP_PZERO positive zero * FP_NNORM negative normalized non-zero * FP_PNORM positive normalized non-zero */ /*#define HAS_FPCLASS / **/ /* HAS_FPCLASSIFY: * This symbol, if defined, indicates that the fpclassify routine is * available to classify doubles. Available for example in HP-UX. * The returned values are defined in and are * * FP_NORMAL Normalized * FP_ZERO Zero * FP_INFINITE Infinity * FP_SUBNORMAL Denormalized * FP_NAN NaN * */ /*#define HAS_FPCLASSIFY / **/ /* HAS_FPCLASSL: * This symbol, if defined, indicates that the fpclassl routine is * available to classify long doubles. Available for example in IRIX. * The returned values are defined in and are: * * FP_SNAN signaling NaN * FP_QNAN quiet NaN * FP_NINF negative infinity * FP_PINF positive infinity * FP_NDENORM negative denormalized non-zero * FP_PDENORM positive denormalized non-zero * FP_NZERO negative zero * FP_PZERO positive zero * FP_NNORM negative normalized non-zero * FP_PNORM positive normalized non-zero */ /*#define HAS_FPCLASSL / **/ /* HAS_FPOS64_T: * This symbol will be defined if the C compiler supports fpos64_t. */ /*#define HAS_FPOS64_T / **/ /* HAS_FREXPL: * This symbol, if defined, indicates that the frexpl routine is * available to break a long double floating-point number into * a normalized fraction and an integral power of 2. */ /*#define HAS_FREXPL / **/ /* HAS_STRUCT_FS_DATA: * This symbol, if defined, indicates that the struct fs_data * to do statfs() is supported. */ /*#define HAS_STRUCT_FS_DATA / **/ /* HAS_FSEEKO: * This symbol, if defined, indicates that the fseeko routine is * available to fseek beyond 32 bits (useful for ILP32 hosts). */ /*#define HAS_FSEEKO / **/ /* HAS_FSTATFS: * This symbol, if defined, indicates that the fstatfs routine is * available to stat filesystems by file descriptors. */ /*#define HAS_FSTATFS / **/ /* HAS_FSYNC: * This symbol, if defined, indicates that the fsync routine is * available to write a file's modified data and attributes to * permanent storage. */ /*#define HAS_FSYNC / **/ /* HAS_FTELLO: * This symbol, if defined, indicates that the ftello routine is * available to ftell beyond 32 bits (useful for ILP32 hosts). */ /*#define HAS_FTELLO / **/ /* HAS_FUTIMES: * This symbol, if defined, indicates that the futimes routine is * available to change file descriptor time stamps with struct timevals. */ /*#define HAS_FUTIMES / **/ /* HAS_GETADDRINFO: * This symbol, if defined, indicates that the getaddrinfo() function * is available for use. */ /*#define HAS_GETADDRINFO / **/ /* HAS_GETCWD: * This symbol, if defined, indicates that the getcwd routine is * available to get the current working directory. */ /*#define HAS_GETCWD / **/ /* HAS_GETESPWNAM: * This symbol, if defined, indicates that the getespwnam system call is * available to retrieve enhanced (shadow) password entries by name. */ /*#define HAS_GETESPWNAM / **/ /* HAS_GETFSSTAT: * This symbol, if defined, indicates that the getfsstat routine is * available to stat filesystems in bulk. */ /*#define HAS_GETFSSTAT / **/ /* HAS_GETITIMER: * This symbol, if defined, indicates that the getitimer routine is * available to return interval timers. */ /*#define HAS_GETITIMER / **/ /* HAS_GETMNT: * This symbol, if defined, indicates that the getmnt routine is * available to get filesystem mount info by filename. */ /*#define HAS_GETMNT / **/ /* HAS_GETMNTENT: * This symbol, if defined, indicates that the getmntent routine is * available to iterate through mounted file systems to get their info. */ /*#define HAS_GETMNTENT / **/ /* HAS_GETNAMEINFO: * This symbol, if defined, indicates that the getnameinfo() function * is available for use. */ /*#define HAS_GETNAMEINFO / **/ /* HAS_GETPRPWNAM: * This symbol, if defined, indicates that the getprpwnam system call is * available to retrieve protected (shadow) password entries by name. */ /*#define HAS_GETPRPWNAM / **/ /* HAS_GETSPNAM: * This symbol, if defined, indicates that the getspnam system call is * available to retrieve SysV shadow password entries by name. */ /*#define HAS_GETSPNAM / **/ /* HAS_HASMNTOPT: * This symbol, if defined, indicates that the hasmntopt routine is * available to query the mount options of file systems. */ /*#define HAS_HASMNTOPT / **/ /* HAS_ILOGBL: * This symbol, if defined, indicates that the ilogbl routine is * available. If scalbnl is also present we can emulate frexpl. */ /*#define HAS_ILOGBL / **/ /* HAS_INETNTOP: * This symbol, if defined, indicates that the inet_ntop() function * is available to parse IPv4 and IPv6 strings. */ /*#define HAS_INETNTOP / **/ /* HAS_INETPTON: * This symbol, if defined, indicates that the inet_pton() function * is available to parse IPv4 and IPv6 strings. */ /*#define HAS_INETPTON / **/ /* HAS_INT64_T: * This symbol will defined if the C compiler supports int64_t. * Usually the needs to be included, but sometimes * is enough. */ /*#define HAS_INT64_T / **/ /* HAS_ISBLANK: * This manifest constant lets the C program know that isblank * is available. */ /*#define HAS_ISBLANK / **/ /* HAS_ISFINITE: * This symbol, if defined, indicates that the isfinite routine is * available to check whether a double is finite (non-infinity non-NaN). */ /*#define HAS_ISFINITE / **/ /* HAS_ISINF: * This symbol, if defined, indicates that the isinf routine is * available to check whether a double is an infinity. */ /*#define HAS_ISINF / **/ /* HAS_ISNAN: * This symbol, if defined, indicates that the isnan routine is * available to check whether a double is a NaN. */ /*#define HAS_ISNAN / **/ /* HAS_ISNANL: * This symbol, if defined, indicates that the isnanl routine is * available to check whether a long double is a NaN. */ /*#define HAS_ISNANL / **/ /* HAS_LDBL_DIG: * This symbol, if defined, indicates that this system's * or defines the symbol LDBL_DIG, which is the number * of significant digits in a long double precision number. Unlike * for DBL_DIG, there's no good guess for LDBL_DIG if it is undefined. */ /*#define HAS_LDBL_DIG / * */ /* LIBM_LIB_VERSION: * This symbol, if defined, indicates that libm exports _LIB_VERSION * and that math.h defines the enum to manipulate it. */ /*#define LIBM_LIB_VERSION / **/ /* HAS_MADVISE: * This symbol, if defined, indicates that the madvise system call is * available to map a file into memory. */ /*#define HAS_MADVISE / **/ /* HAS_MALLOC_SIZE: * This symbol, if defined, indicates that the malloc_size * routine is available for use. */ /*#define HAS_MALLOC_SIZE / **/ /* HAS_MALLOC_GOOD_SIZE: * This symbol, if defined, indicates that the malloc_good_size * routine is available for use. */ /*#define HAS_MALLOC_GOOD_SIZE / **/ /* HAS_MKDTEMP: * This symbol, if defined, indicates that the mkdtemp routine is * available to exclusively create a uniquely named temporary directory. */ /*#define HAS_MKDTEMP / **/ /* HAS_MKSTEMPS: * This symbol, if defined, indicates that the mkstemps routine is * available to exclusively create and open a uniquely named * (with a suffix) temporary file. */ /*#define HAS_MKSTEMPS / **/ /* HAS_MODFL: * This symbol, if defined, indicates that the modfl routine is * available to split a long double x into a fractional part f and * an integer part i such that |f| < 1.0 and (f + i) = x. */ /* HAS_MODFL_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the modfl() function. Otherwise, it is up * to the program to supply one. */ /* HAS_MODFL_POW32_BUG: * This symbol, if defined, indicates that the modfl routine is * broken for long doubles >= pow(2, 32). * For example from 4294967303.150000 one would get 4294967302.000000 * and 1.150000. The bug has been seen in certain versions of glibc, * release 2.2.2 is known to be okay. */ /*#define HAS_MODFL / **/ /*#define HAS_MODFL_PROTO / **/ /*#define HAS_MODFL_POW32_BUG / **/ /* HAS_MPROTECT: * This symbol, if defined, indicates that the mprotect system call is * available to modify the access protection of a memory mapped file. */ /*#define HAS_MPROTECT / **/ /* HAS_STRUCT_MSGHDR: * This symbol, if defined, indicates that the struct msghdr * is supported. */ /*#define HAS_STRUCT_MSGHDR / **/ /* HAS_NL_LANGINFO: * This symbol, if defined, indicates that the nl_langinfo routine is * available to return local data. You will also need * and therefore I_LANGINFO. */ /*#define HAS_NL_LANGINFO / **/ /* HAS_OFF64_T: * This symbol will be defined if the C compiler supports off64_t. */ /*#define HAS_OFF64_T / **/ /* HAS_PRCTL: * This symbol, if defined, indicates that the prctl routine is * available to set process title. */ /* HAS_PRCTL_SET_NAME: * This symbol, if defined, indicates that the prctl routine is * available to set process title and supports PR_SET_NAME. */ /*#define HAS_PRCTL / **/ /*#define HAS_PRCTL_SET_NAME / **/ /* HAS_PROCSELFEXE: * This symbol is defined if PROCSELFEXE_PATH is a symlink * to the absolute pathname of the executing program. */ /* PROCSELFEXE_PATH: * If HAS_PROCSELFEXE is defined this symbol is the filename * of the symbolic link pointing to the absolute pathname of * the executing program. */ /*#define HAS_PROCSELFEXE / **/ #if defined(HAS_PROCSELFEXE) && !defined(PROCSELFEXE_PATH) #define PROCSELFEXE_PATH /**/ #endif /* HAS_PTHREAD_ATTR_SETSCOPE: * This symbol, if defined, indicates that the pthread_attr_setscope * system call is available to set the contention scope attribute of * a thread attribute object. */ /*#define HAS_PTHREAD_ATTR_SETSCOPE / **/ /* HAS_READV: * This symbol, if defined, indicates that the readv routine is * available to do gather reads. You will also need * and there I_SYSUIO. */ /*#define HAS_READV / **/ /* HAS_RECVMSG: * This symbol, if defined, indicates that the recvmsg routine is * available to send structured socket messages. */ /*#define HAS_RECVMSG / **/ /* HAS_SBRK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the sbrk() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern void* sbrk(int); * extern void* sbrk(size_t); */ /*#define HAS_SBRK_PROTO / **/ /* HAS_SCALBNL: * This symbol, if defined, indicates that the scalbnl routine is * available. If ilogbl is also present we can emulate frexpl. */ /*#define HAS_SCALBNL / **/ /* HAS_SENDMSG: * This symbol, if defined, indicates that the sendmsg routine is * available to send structured socket messages. */ /*#define HAS_SENDMSG / **/ /* HAS_SETITIMER: * This symbol, if defined, indicates that the setitimer routine is * available to set interval timers. */ /*#define HAS_SETITIMER / **/ /* HAS_SETPROCTITLE: * This symbol, if defined, indicates that the setproctitle routine is * available to set process title. */ /*#define HAS_SETPROCTITLE / **/ /* USE_SFIO: * This symbol, if defined, indicates that sfio should * be used. */ /*#define USE_SFIO / **/ /* HAS_SIGNBIT: * This symbol, if defined, indicates that the signbit routine is * available to check if the given number has the sign bit set. * This should include correct testing of -0.0. This will only be set * if the signbit() routine is safe to use with the NV type used internally * in perl. Users should call Perl_signbit(), which will be #defined to * the system's signbit() function or macro if this symbol is defined. */ /*#define HAS_SIGNBIT / **/ /* HAS_SIGPROCMASK: * This symbol, if defined, indicates that the sigprocmask * system call is available to examine or change the signal mask * of the calling process. */ /*#define HAS_SIGPROCMASK / **/ /* USE_SITECUSTOMIZE: * This symbol, if defined, indicates that sitecustomize should * be used. */ #ifndef USE_SITECUSTOMIZE /*#define USE_SITECUSTOMIZE / **/ #endif /* HAS_SNPRINTF: * This symbol, if defined, indicates that the snprintf () library * function is available for use. */ /* HAS_VSNPRINTF: * This symbol, if defined, indicates that the vsnprintf () library * function is available for use. */ /*#define HAS_SNPRINTF / **/ /*#define HAS_VSNPRINTF / **/ /* HAS_SOCKATMARK: * This symbol, if defined, indicates that the sockatmark routine is * available to test whether a socket is at the out-of-band mark. */ /*#define HAS_SOCKATMARK / **/ /* HAS_SOCKATMARK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the sockatmark() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int sockatmark(int); */ /*#define HAS_SOCKATMARK_PROTO / **/ /* HAS_SOCKS5_INIT: * This symbol, if defined, indicates that the socks5_init routine is * available to initialize SOCKS 5. */ /*#define HAS_SOCKS5_INIT / **/ /* SPRINTF_RETURNS_STRLEN: * This variable defines whether sprintf returns the length of the string * (as per the ANSI spec). Some C libraries retain compatibility with * pre-ANSI C and return a pointer to the passed in buffer; for these * this variable will be undef. */ /*#define SPRINTF_RETURNS_STRLEN / **/ /* HAS_SQRTL: * This symbol, if defined, indicates that the sqrtl routine is * available to do long double square roots. */ /*#define HAS_SQRTL / **/ /* HAS_SETRESGID_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the setresgid() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int setresgid(uid_t ruid, uid_t euid, uid_t suid); */ /*#define HAS_SETRESGID_PROTO / **/ /* HAS_SETRESUID_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the setresuid() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int setresuid(uid_t ruid, uid_t euid, uid_t suid); */ /*#define HAS_SETRESUID_PROTO / **/ /* HAS_STRUCT_STATFS_F_FLAGS: * This symbol, if defined, indicates that the struct statfs * does have the f_flags member containing the mount flags of * the filesystem containing the file. * This kind of struct statfs is coming from (BSD 4.3), * not from (SYSV). Older BSDs (like Ultrix) do not * have statfs() and struct statfs, they have ustat() and getmnt() * with struct ustat and struct fs_data. */ /*#define HAS_STRUCT_STATFS_F_FLAGS / **/ /* HAS_STRUCT_STATFS: * This symbol, if defined, indicates that the struct statfs * to do statfs() is supported. */ /*#define HAS_STRUCT_STATFS / **/ /* HAS_FSTATVFS: * This symbol, if defined, indicates that the fstatvfs routine is * available to stat filesystems by file descriptors. */ /*#define HAS_FSTATVFS / **/ /* HAS_STRFTIME: * This symbol, if defined, indicates that the strftime routine is * available to do time formatting. */ /*#define HAS_STRFTIME / **/ /* HAS_STRLCAT: * This symbol, if defined, indicates that the strlcat () routine is * available to do string concatenation. */ /*#define HAS_STRLCAT / **/ /* HAS_STRLCPY: * This symbol, if defined, indicates that the strlcpy () routine is * available to do string copying. */ /*#define HAS_STRLCPY / **/ /* HAS_STRTOLD: * This symbol, if defined, indicates that the strtold routine is * available to convert strings to long doubles. */ /*#define HAS_STRTOLD / **/ /* HAS_STRTOLL: * This symbol, if defined, indicates that the strtoll routine is * available to convert strings to long longs. */ /*#define HAS_STRTOLL / **/ /* HAS_STRTOQ: * This symbol, if defined, indicates that the strtoq routine is * available to convert strings to long longs (quads). */ /*#define HAS_STRTOQ / **/ /* HAS_STRTOULL: * This symbol, if defined, indicates that the strtoull routine is * available to convert strings to unsigned long longs. */ /*#define HAS_STRTOULL / **/ /* HAS_STRTOUQ: * This symbol, if defined, indicates that the strtouq routine is * available to convert strings to unsigned long longs (quads). */ /*#define HAS_STRTOUQ / **/ /* HAS_SYSCALL_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the syscall() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int syscall(int, ...); * extern int syscall(long, ...); */ /*#define HAS_SYSCALL_PROTO / **/ /* HAS_TELLDIR_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the telldir() function. Otherwise, it is up * to the program to supply one. A good guess is * extern long telldir(DIR*); */ /*#define HAS_TELLDIR_PROTO / **/ /* HAS_CTIME64: * This symbol, if defined, indicates that the ctime64 () routine is * available to do the 64bit variant of ctime () */ /* HAS_LOCALTIME64: * This symbol, if defined, indicates that the localtime64 () routine is * available to do the 64bit variant of localtime () */ /* HAS_GMTIME64: * This symbol, if defined, indicates that the gmtime64 () routine is * available to do the 64bit variant of gmtime () */ /* HAS_MKTIME64: * This symbol, if defined, indicates that the mktime64 () routine is * available to do the 64bit variant of mktime () */ /* HAS_DIFFTIME64: * This symbol, if defined, indicates that the difftime64 () routine is * available to do the 64bit variant of difftime () */ /* HAS_ASCTIME64: * This symbol, if defined, indicates that the asctime64 () routine is * available to do the 64bit variant of asctime () */ /*#define HAS_CTIME64 / **/ /*#define HAS_LOCALTIME64 / **/ /*#define HAS_GMTIME64 / **/ /*#define HAS_MKTIME64 / **/ /*#define HAS_DIFFTIME64 / **/ /*#define HAS_ASCTIME64 / **/ /* HAS_TIMEGM: * This symbol, if defined, indicates that the timegm routine is * available to do the opposite of gmtime () */ /*#define HAS_TIMEGM / **/ /* U32_ALIGNMENT_REQUIRED: * This symbol, if defined, indicates that you must access * character data through U32-aligned pointers. */ #ifndef U32_ALIGNMENT_REQUIRED #define U32_ALIGNMENT_REQUIRED /**/ #endif /* HAS_UALARM: * This symbol, if defined, indicates that the ualarm routine is * available to do alarms with microsecond granularity. */ /*#define HAS_UALARM / **/ /* HAS_UNORDERED: * This symbol, if defined, indicates that the unordered routine is * available to check whether two doubles are unordered * (effectively: whether either of them is NaN) */ /*#define HAS_UNORDERED / **/ /* HAS_UNSETENV: * This symbol, if defined, indicates that the unsetenv () routine is * available for use. */ /*#define HAS_UNSETENV / **/ /* HAS_USLEEP_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the usleep() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int usleep(useconds_t); */ /*#define HAS_USLEEP_PROTO / **/ /* HAS_USTAT: * This symbol, if defined, indicates that the ustat system call is * available to query file system statistics by dev_t. */ /*#define HAS_USTAT / **/ /* HAS_WRITEV: * This symbol, if defined, indicates that the writev routine is * available to do scatter writes. */ /*#define HAS_WRITEV / **/ /* USE_DYNAMIC_LOADING: * This symbol, if defined, indicates that dynamic loading of * some sort is available. */ /*#define USE_DYNAMIC_LOADING / **/ /* FFLUSH_NULL: * This symbol, if defined, tells that fflush(NULL) does flush * all pending stdio output. */ /* FFLUSH_ALL: * This symbol, if defined, tells that to flush * all pending stdio output one must loop through all * the stdio file handles stored in an array and fflush them. * Note that if fflushNULL is defined, fflushall will not * even be probed for and will be left undefined. */ /*#define FFLUSH_NULL / **/ /*#define FFLUSH_ALL / **/ /* I_ASSERT: * This symbol, if defined, indicates that exists and * could be included by the C program to get the assert() macro. */ #define I_ASSERT /**/ /* I_CRYPT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_CRYPT / **/ /* DB_Prefix_t: * This symbol contains the type of the prefix structure element * in the header file. In older versions of DB, it was * int, while in newer ones it is u_int32_t. */ /* DB_Hash_t: * This symbol contains the type of the prefix structure element * in the header file. In older versions of DB, it was * int, while in newer ones it is size_t. */ /* DB_VERSION_MAJOR_CFG: * This symbol, if defined, defines the major version number of * Berkeley DB found in the header when Perl was configured. */ /* DB_VERSION_MINOR_CFG: * This symbol, if defined, defines the minor version number of * Berkeley DB found in the header when Perl was configured. * For DB version 1 this is always 0. */ /* DB_VERSION_PATCH_CFG: * This symbol, if defined, defines the patch version number of * Berkeley DB found in the header when Perl was configured. * For DB version 1 this is always 0. */ #define DB_Hash_t u_int32_t /**/ #define DB_Prefix_t size_t /**/ #define DB_VERSION_MAJOR_CFG 0 /**/ #define DB_VERSION_MINOR_CFG 0 /**/ #define DB_VERSION_PATCH_CFG 0 /**/ /* I_FP: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_FP / **/ /* I_FP_CLASS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_FP_CLASS / **/ /* I_IEEEFP: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_IEEEFP / **/ /* I_INTTYPES: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_INTTYPES / **/ /* I_LANGINFO: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_LANGINFO / **/ /* I_LIBUTIL: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_LIBUTIL / **/ /* I_MALLOCMALLOC: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MALLOCMALLOC / **/ /* I_MNTENT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_MNTENT / **/ /* I_NETINET_TCP: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_NETINET_TCP / **/ /* I_POLL: * This symbol, if defined, indicates that exists and * should be included. (see also HAS_POLL) */ /*#define I_POLL / **/ /* I_PROT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_PROT / **/ /* I_SHADOW: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SHADOW / **/ /* I_SOCKS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SOCKS / **/ /* I_STDBOOL: * This symbol, if defined, indicates that exists and * can be included. */ /*#define I_STDBOOL / **/ /* I_SUNMATH: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SUNMATH / **/ /* I_SYSLOG: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYSLOG / **/ /* I_SYSMODE: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYSMODE / **/ /* I_SYS_MOUNT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYS_MOUNT / **/ /* I_SYS_STATFS: * This symbol, if defined, indicates that exists. */ /*#define I_SYS_STATFS / **/ /* I_SYS_STATVFS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYS_STATVFS / **/ /* I_SYSUTSNAME: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYSUTSNAME / **/ /* I_SYS_VFS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYS_VFS / **/ /* I_USTAT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_USTAT / **/ /* PERL_PRIfldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'f') for output. */ /* PERL_PRIgldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'g') for output. */ /* PERL_PRIeldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'e') for output. */ /* PERL_SCNfldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'f') for input. */ /*#define PERL_PRIfldbl "llf" / **/ /*#define PERL_PRIgldbl "llg" / **/ /*#define PERL_PRIeldbl "lle" / **/ /*#define PERL_SCNfldbl "llf" / **/ /* PERL_MAD: * This symbol, if defined, indicates that the Misc Attribution * Declaration code should be conditionally compiled. */ /*#define PERL_MAD / **/ /* NEED_VA_COPY: * This symbol, if defined, indicates that the system stores * the variable argument list datatype, va_list, in a format * that cannot be copied by simple assignment, so that some * other means must be used when copying is required. * As such systems vary in their provision (or non-provision) * of copying mechanisms, handy.h defines a platform- * independent macro, Perl_va_copy(src, dst), to do the job. */ #define NEED_VA_COPY /**/ /* IVTYPE: * This symbol defines the C type used for Perl's IV. */ /* UVTYPE: * This symbol defines the C type used for Perl's UV. */ /* I8TYPE: * This symbol defines the C type used for Perl's I8. */ /* U8TYPE: * This symbol defines the C type used for Perl's U8. */ /* I16TYPE: * This symbol defines the C type used for Perl's I16. */ /* U16TYPE: * This symbol defines the C type used for Perl's U16. */ /* I32TYPE: * This symbol defines the C type used for Perl's I32. */ /* U32TYPE: * This symbol defines the C type used for Perl's U32. */ /* I64TYPE: * This symbol defines the C type used for Perl's I64. */ /* U64TYPE: * This symbol defines the C type used for Perl's U64. */ /* NVTYPE: * This symbol defines the C type used for Perl's NV. */ /* IVSIZE: * This symbol contains the sizeof(IV). */ /* UVSIZE: * This symbol contains the sizeof(UV). */ /* I8SIZE: * This symbol contains the sizeof(I8). */ /* U8SIZE: * This symbol contains the sizeof(U8). */ /* I16SIZE: * This symbol contains the sizeof(I16). */ /* U16SIZE: * This symbol contains the sizeof(U16). */ /* I32SIZE: * This symbol contains the sizeof(I32). */ /* U32SIZE: * This symbol contains the sizeof(U32). */ /* I64SIZE: * This symbol contains the sizeof(I64). */ /* U64SIZE: * This symbol contains the sizeof(U64). */ /* NVSIZE: * This symbol contains the sizeof(NV). */ /* NV_PRESERVES_UV: * This symbol, if defined, indicates that a variable of type NVTYPE * can preserve all the bits of a variable of type UVTYPE. */ /* NV_PRESERVES_UV_BITS: * This symbol contains the number of bits a variable of type NVTYPE * can preserve of a variable of type UVTYPE. */ /* NV_OVERFLOWS_INTEGERS_AT: * This symbol gives the largest integer value that NVs can hold. This * value + 1.0 cannot be stored accurately. It is expressed as constant * floating point expression to reduce the chance of decimal/binary * conversion issues. If it can not be determined, the value 0 is given. */ /* NV_ZERO_IS_ALLBITS_ZERO: * This symbol, if defined, indicates that a variable of type NVTYPE * stores 0.0 in memory as all bits zero. */ #define IVTYPE long /**/ #define UVTYPE unsigned long /**/ #define I8TYPE signed char /**/ #define U8TYPE unsigned char /**/ #define I16TYPE short /**/ #define U16TYPE unsigned short /**/ #define I32TYPE long /**/ #define U32TYPE unsigned long /**/ #ifdef HAS_QUAD #define I64TYPE int64_t /**/ #define U64TYPE uint64_t /**/ #endif #define NVTYPE double /**/ #define IVSIZE 4 /**/ #define UVSIZE 4 /**/ #define I8SIZE 1 /**/ #define U8SIZE 1 /**/ #define I16SIZE 2 /**/ #define U16SIZE 2 /**/ #define I32SIZE 4 /**/ #define U32SIZE 4 /**/ #ifdef HAS_QUAD #define I64SIZE 8 /**/ #define U64SIZE 8 /**/ #endif #define NVSIZE 8 /**/ #undef NV_PRESERVES_UV #define NV_PRESERVES_UV_BITS 0 #define NV_OVERFLOWS_INTEGERS_AT 256.0*256.0*256.0*256.0*256.0*256.0*2.0*2.0*2.0*2.0*2.0 #undef NV_ZERO_IS_ALLBITS_ZERO #if UVSIZE == 8 # ifdef BYTEORDER # if BYTEORDER == 0x1234 # undef BYTEORDER # define BYTEORDER 0x12345678 # else # if BYTEORDER == 0x4321 # undef BYTEORDER # define BYTEORDER 0x87654321 # endif # endif # endif #endif /* IVdf: * This symbol defines the format string used for printing a Perl IV * as a signed decimal integer. */ /* UVuf: * This symbol defines the format string used for printing a Perl UV * as an unsigned decimal integer. */ /* UVof: * This symbol defines the format string used for printing a Perl UV * as an unsigned octal integer. */ /* UVxf: * This symbol defines the format string used for printing a Perl UV * as an unsigned hexadecimal integer in lowercase abcdef. */ /* UVXf: * This symbol defines the format string used for printing a Perl UV * as an unsigned hexadecimal integer in uppercase ABCDEF. */ /* NVef: * This symbol defines the format string used for printing a Perl NV * using %e-ish floating point format. */ /* NVff: * This symbol defines the format string used for printing a Perl NV * using %f-ish floating point format. */ /* NVgf: * This symbol defines the format string used for printing a Perl NV * using %g-ish floating point format. */ #define IVdf "ld" /**/ #define UVuf "lu" /**/ #define UVof "lo" /**/ #define UVxf "lx" /**/ #define UVXf "lX" /**/ #define NVef "e" /**/ #define NVff "f" /**/ #define NVgf "g" /**/ /* SELECT_MIN_BITS: * This symbol holds the minimum number of bits operated by select. * That is, if you do select(n, ...), how many bits at least will be * cleared in the masks if some activity is detected. Usually this * is either n or 32*ceil(n/32), especially many little-endians do * the latter. This is only useful if you have select(), naturally. */ #define SELECT_MIN_BITS 32 /**/ /* ST_INO_SIZE: * This variable contains the size of struct stat's st_ino in bytes. */ /* ST_INO_SIGN: * This symbol holds the signedess of struct stat's st_ino. * 1 for unsigned, -1 for signed. */ #define ST_INO_SIGN 1 /* st_ino sign */ #define ST_INO_SIZE 4 /* st_ino size */ /* STARTPERL: * This variable contains the string to put in front of a perl * script to make sure (one hopes) that it runs with perl and not * some shell. */ #define STARTPERL "#!perl" /**/ /* HAS_STDIO_STREAM_ARRAY: * This symbol, if defined, tells that there is an array * holding the stdio streams. */ /* STDIO_STREAM_ARRAY: * This symbol tells the name of the array holding the stdio streams. * Usual values include _iob, __iob, and __sF. */ /*#define HAS_STDIO_STREAM_ARRAY / **/ #ifdef HAS_STDIO_STREAM_ARRAY #define STDIO_STREAM_ARRAY #endif /* GMTIME_MAX: * This symbol contains the maximum value for the time_t offset that * the system function gmtime () accepts, and defaults to 0 */ /* GMTIME_MIN: * This symbol contains the minimum value for the time_t offset that * the system function gmtime () accepts, and defaults to 0 */ /* LOCALTIME_MAX: * This symbol contains the maximum value for the time_t offset that * the system function localtime () accepts, and defaults to 0 */ /* LOCALTIME_MIN: * This symbol contains the minimum value for the time_t offset that * the system function localtime () accepts, and defaults to 0 */ #define GMTIME_MAX 2147483647 /**/ #define GMTIME_MIN 0 /**/ #define LOCALTIME_MAX 2147483647 /**/ #define LOCALTIME_MIN 0 /**/ /* USE_64_BIT_INT: * This symbol, if defined, indicates that 64-bit integers should * be used when available. If not defined, the native integers * will be employed (be they 32 or 64 bits). The minimal possible * 64-bitness is used, just enough to get 64-bit integers into Perl. * This may mean using for example "long longs", while your memory * may still be limited to 2 gigabytes. */ /* USE_64_BIT_ALL: * This symbol, if defined, indicates that 64-bit integers should * be used when available. If not defined, the native integers * will be used (be they 32 or 64 bits). The maximal possible * 64-bitness is employed: LP64 or ILP64, meaning that you will * be able to use more than 2 gigabytes of memory. This mode is * even more binary incompatible than USE_64_BIT_INT. You may not * be able to run the resulting executable in a 32-bit CPU at all or * you may need at least to reboot your OS to 64-bit mode. */ #ifndef USE_64_BIT_INT /*#define USE_64_BIT_INT / **/ #endif #ifndef USE_64_BIT_ALL /*#define USE_64_BIT_ALL / **/ #endif /* USE_DTRACE: * This symbol, if defined, indicates that Perl should * be built with support for DTrace. */ /*#define USE_DTRACE / **/ /* USE_FAST_STDIO: * This symbol, if defined, indicates that Perl should * be built to use 'fast stdio'. * Defaults to define in Perls 5.8 and earlier, to undef later. */ #ifndef USE_FAST_STDIO /*#define USE_FAST_STDIO / **/ #endif /* USE_KERN_PROC_PATHNAME: * This symbol, if defined, indicates that we can use sysctl with * KERN_PROC_PATHNAME to get a full path for the executable, and hence * convert $^X to an absolute path. */ /*#define USE_KERN_PROC_PATHNAME / **/ /* USE_LARGE_FILES: * This symbol, if defined, indicates that large file support * should be used when available. */ #ifndef USE_LARGE_FILES /*#define USE_LARGE_FILES / **/ #endif /* USE_LONG_DOUBLE: * This symbol, if defined, indicates that long doubles should * be used when available. */ #ifndef USE_LONG_DOUBLE /*#define USE_LONG_DOUBLE / **/ #endif /* USE_MORE_BITS: * This symbol, if defined, indicates that 64-bit interfaces and * long doubles should be used when available. */ #ifndef USE_MORE_BITS /*#define USE_MORE_BITS / **/ #endif /* MULTIPLICITY: * This symbol, if defined, indicates that Perl should * be built to use multiplicity. */ #ifndef MULTIPLICITY /*#define MULTIPLICITY / **/ #endif /* USE_NSGETEXECUTABLEPATH: * This symbol, if defined, indicates that we can use _NSGetExecutablePath * and realpath to get a full path for the executable, and hence convert * $^X to an absolute path. */ /*#define USE_NSGETEXECUTABLEPATH / **/ /* USE_PERLIO: * This symbol, if defined, indicates that the PerlIO abstraction should * be used throughout. If not defined, stdio should be * used in a fully backward compatible manner. */ #ifndef USE_PERLIO /*#define USE_PERLIO / **/ #endif /* USE_SOCKS: * This symbol, if defined, indicates that Perl should * be built to use socks. */ #ifndef USE_SOCKS /*#define USE_SOCKS / **/ #endif #endif /* Generated from: * d9b6a68b192c72c0695b560fae6e4916b381f55df5fdf7911b0ef434840f092e config_h.SH * 2678333a6d6676f8aa39b7011bf5133dce5be453df10a8d04cb3187103a10caf uconfig.sh * ex: set ro: */ PKZ? fakethr.hnuW+A/* fakethr.h * * Copyright (C) 1999, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ typedef int perl_mutex; typedef int perl_key; typedef struct perl_thread *perl_os_thread; /* With fake threads, thr is global(ish) so we don't need dTHR */ #define dTHR extern int errno struct perl_wait_queue { struct perl_thread * thread; struct perl_wait_queue * next; }; typedef struct perl_wait_queue *perl_cond; /* Ask thread.h to include our per-thread extras */ #define HAVE_THREAD_INTERN struct thread_intern { perl_os_thread next_run, prev_run; /* Linked list of runnable threads */ perl_cond wait_queue; /* Wait queue that we are waiting on */ IV private; /* Holds data across time slices */ I32 savemark; /* Holds MARK for thread join values */ }; #define init_thread_intern(t) \ STMT_START { \ t->self = (t); \ (t)->i.next_run = (t)->i.prev_run = (t); \ (t)->i.wait_queue = 0; \ (t)->i.private = 0; \ } STMT_END /* * Note that SCHEDULE() is only callable from pp code (which * must be expecting to be restarted). We'll have to do * something a bit different for XS code. */ #define SCHEDULE() return schedule(), PL_op #define MUTEX_LOCK(m) #define MUTEX_UNLOCK(m) #define MUTEX_INIT(m) #define MUTEX_DESTROY(m) #define COND_INIT(c) perl_cond_init(c) #define COND_SIGNAL(c) perl_cond_signal(c) #define COND_BROADCAST(c) perl_cond_broadcast(c) #define COND_WAIT(c, m) \ STMT_START { \ perl_cond_wait(c); \ SCHEDULE(); \ } STMT_END #define COND_DESTROY(c) #define THREAD_CREATE(t, f) f((t)) #define THREAD_POST_CREATE(t) NOOP #define YIELD NOOP /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ+44 perliol.hnuW+A#ifndef _PERLIOL_H #define _PERLIOL_H typedef struct { PerlIO_funcs *funcs; SV *arg; } PerlIO_pair_t; struct PerlIO_list_s { IV refcnt; IV cur; IV len; PerlIO_pair_t *array; }; struct _PerlIO_funcs { Size_t fsize; const char *name; Size_t size; U32 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); }; /*--------------------------------------------------------------------------------------*/ /* Kind values */ #define PERLIO_K_RAW 0x00000001 #define PERLIO_K_BUFFERED 0x00000002 #define PERLIO_K_CANCRLF 0x00000004 #define PERLIO_K_FASTGETS 0x00000008 #define PERLIO_K_DUMMY 0x00000010 #define PERLIO_K_UTF8 0x00008000 #define PERLIO_K_DESTRUCT 0x00010000 #define PERLIO_K_MULTIARG 0x00020000 /*--------------------------------------------------------------------------------------*/ struct _PerlIO { PerlIOl *next; /* Lower layer */ PerlIO_funcs *tab; /* Functions for this layer */ U32 flags; /* Various flags for state */ PerlIOl *head; /* our ultimate parent pointer */ }; /*--------------------------------------------------------------------------------------*/ /* Flag values */ #define PERLIO_F_EOF 0x00000100 #define PERLIO_F_CANWRITE 0x00000200 #define PERLIO_F_CANREAD 0x00000400 #define PERLIO_F_ERROR 0x00000800 #define PERLIO_F_TRUNCATE 0x00001000 #define PERLIO_F_APPEND 0x00002000 #define PERLIO_F_CRLF 0x00004000 #define PERLIO_F_UTF8 0x00008000 #define PERLIO_F_UNBUF 0x00010000 #define PERLIO_F_WRBUF 0x00020000 #define PERLIO_F_RDBUF 0x00040000 #define PERLIO_F_LINEBUF 0x00080000 #define PERLIO_F_TEMP 0x00100000 #define PERLIO_F_OPEN 0x00200000 #define PERLIO_F_FASTGETS 0x00400000 #define PERLIO_F_TTY 0x00800000 #define PERLIO_F_NOTREG 0x01000000 #define PERLIO_F_CLEARED 0x02000000 /* layer cleared but not freed */ #define PerlIOBase(f) (*(f)) #define PerlIOSelf(f,type) ((type *)PerlIOBase(f)) #define PerlIONext(f) (&(PerlIOBase(f)->next)) #define PerlIOValid(f) ((f) && *(f)) /*--------------------------------------------------------------------------------------*/ /* Data exports - EXTCONST rather than extern is needed for Cygwin */ #undef EXTPERLIO #ifdef PERLIO_FUNCS_CONST #define EXTPERLIO EXTCONST #else #define EXTPERLIO EXT #endif EXTPERLIO PerlIO_funcs PerlIO_unix; EXTPERLIO PerlIO_funcs PerlIO_perlio; EXTPERLIO PerlIO_funcs PerlIO_stdio; EXTPERLIO PerlIO_funcs PerlIO_crlf; EXTPERLIO PerlIO_funcs PerlIO_utf8; EXTPERLIO PerlIO_funcs PerlIO_byte; EXTPERLIO PerlIO_funcs PerlIO_raw; EXTPERLIO PerlIO_funcs PerlIO_pending; #ifdef WIN32 EXTPERLIO PerlIO_funcs PerlIO_win32; #endif PERL_EXPORT_C PerlIO *PerlIO_allocate(pTHX); PERL_EXPORT_C SV *PerlIO_arg_fetch(PerlIO_list_t *av, IV n); #define PerlIOArg PerlIO_arg_fetch(layers,n) #ifdef PERLIO_USING_CRLF #define PERLIO_STDTEXT "t" #else #define PERLIO_STDTEXT "" #endif /*--------------------------------------------------------------------------------------*/ /* perlio buffer layer As this is reasonably generic its struct and "methods" are declared here so they can be used to "inherit" from it. */ 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_EXPORT_C int PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode, PerlIO_list_t *layers, IV n, IV max); PERL_EXPORT_C int PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names); PERL_EXPORT_C PerlIO_funcs *PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def); PERL_EXPORT_C SV *PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param); PERL_EXPORT_C void PerlIO_cleantable(pTHX_ PerlIOl **tablep); PERL_EXPORT_C SV * PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab); PERL_EXPORT_C void PerlIO_default_buffer(pTHX_ PerlIO_list_t *av); PERL_EXPORT_C void PerlIO_stdstreams(pTHX); PERL_EXPORT_C int PerlIO__close(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO_list_t * PerlIO_resolve_layers(pTHX_ const char *layers, const char *mode, int narg, SV **args); PERL_EXPORT_C PerlIO_funcs * PerlIO_default_layer(pTHX_ I32 n); PERL_EXPORT_C PerlIO_list_t * PerlIO_default_layers(pTHX); PERL_EXPORT_C PerlIO * PerlIO_reopen(const char *path, const char *mode, PerlIO *f); PERL_EXPORT_C int PerlIO_vsprintf(char *s, int n, const char *fmt, va_list ap) __attribute__format__(__printf__,3,0); PERL_EXPORT_C PerlIO_list_t *PerlIO_list_alloc(pTHX); PERL_EXPORT_C PerlIO_list_t *PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param); PERL_EXPORT_C void PerlIO_list_free(pTHX_ PerlIO_list_t *list); PERL_EXPORT_C void PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg); PERL_EXPORT_C void PerlIO_list_free(pTHX_ PerlIO_list_t *list); /* PerlIO_teardown doesn't need exporting, but the EXTERN_C is needed * for compiling as C++. Must also match with what perl.h says. */ EXTERN_C void PerlIO_teardown(void); /*--------------------------------------------------------------------------------------*/ /* Generic, or stub layer functions */ PERL_EXPORT_C IV PerlIOBase_binmode(pTHX_ PerlIO *f); PERL_EXPORT_C void PerlIOBase_clearerr(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_close(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO * PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags); PERL_EXPORT_C IV PerlIOBase_eof(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_error(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_fileno(pTHX_ PerlIO *f); PERL_EXPORT_C void PerlIOBase_flush_linebuf(pTHX); PERL_EXPORT_C IV PerlIOBase_noop_fail(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_noop_ok(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_popped(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C PerlIO * PerlIOBase_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args); PERL_EXPORT_C SSize_t PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); PERL_EXPORT_C void PerlIOBase_setlinebuf(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); /* Buf */ PERL_EXPORT_C Size_t PerlIOBuf_bufsiz(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBuf_close(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO * PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags); PERL_EXPORT_C IV PerlIOBuf_fill(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBuf_flush(pTHX_ PerlIO *f); PERL_EXPORT_C STDCHAR * PerlIOBuf_get_base(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOBuf_get_cnt(pTHX_ PerlIO *f); PERL_EXPORT_C STDCHAR * PerlIOBuf_get_ptr(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO * PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args); PERL_EXPORT_C IV PerlIOBuf_popped(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C SSize_t PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); PERL_EXPORT_C IV PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence); PERL_EXPORT_C void PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt); PERL_EXPORT_C Off_t PerlIOBuf_tell(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); PERL_EXPORT_C SSize_t PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); /* Crlf */ PERL_EXPORT_C IV PerlIOCrlf_binmode(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOCrlf_flush(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOCrlf_get_cnt(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C void PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt); PERL_EXPORT_C SSize_t PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); PERL_EXPORT_C SSize_t PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); PERL_EXPORT_C SSize_t PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); /* Pending */ PERL_EXPORT_C IV PerlIOPending_close(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOPending_fill(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOPending_flush(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C SSize_t PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); PERL_EXPORT_C IV PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence); PERL_EXPORT_C void PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt); /* Pop */ PERL_EXPORT_C IV PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); /* Raw */ PERL_EXPORT_C IV PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); /* Stdio */ PERL_EXPORT_C void PerlIOStdio_clearerr(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOStdio_close(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO * PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags); PERL_EXPORT_C IV PerlIOStdio_eof(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOStdio_error(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOStdio_fileno(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOStdio_fill(pTHX_ PerlIO *f); PERL_EXPORT_C IV PerlIOStdio_flush(pTHX_ PerlIO *f); PERL_EXPORT_C STDCHAR * PerlIOStdio_get_base(pTHX_ PerlIO *f); PERL_EXPORT_C char * PerlIOStdio_mode(const char *mode, char *tmode); PERL_EXPORT_C PerlIO * PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args); PERL_EXPORT_C IV PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C SSize_t PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); PERL_EXPORT_C IV PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence); PERL_EXPORT_C void PerlIOStdio_setlinebuf(pTHX_ PerlIO *f); PERL_EXPORT_C Off_t PerlIOStdio_tell(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); PERL_EXPORT_C SSize_t PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); /* Unix */ PERL_EXPORT_C IV PerlIOUnix_close(pTHX_ PerlIO *f); PERL_EXPORT_C PerlIO * PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags); PERL_EXPORT_C IV PerlIOUnix_fileno(pTHX_ PerlIO *f); PERL_EXPORT_C int PerlIOUnix_oflags(const char *mode); PERL_EXPORT_C PerlIO * PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args); PERL_EXPORT_C IV PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); PERL_EXPORT_C SSize_t PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); PERL_EXPORT_C int PerlIOUnix_refcnt_dec(int fd); PERL_EXPORT_C void PerlIOUnix_refcnt_inc(int fd); PERL_EXPORT_C int PerlIOUnix_refcnt(int fd); PERL_EXPORT_C IV PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence); PERL_EXPORT_C Off_t PerlIOUnix_tell(pTHX_ PerlIO *f); PERL_EXPORT_C SSize_t PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); /* Utf8 */ PERL_EXPORT_C IV PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab); #endif /* _PERLIOL_H */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ\\ perlapi.hnuW+A/* -*- buffer-read-only: t -*- * * perlapi.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/embed.pl from data in embed.fnc, * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h. * Any changes made here will be lost! * * Edit those files and run 'make regen_headers' to effect changes. */ /* declare accessor functions for Perl variables */ #ifndef __perlapi_h__ #define __perlapi_h__ #if defined (MULTIPLICITY) && defined (PERL_GLOBAL_STRUCT) START_EXTERN_C #undef PERLVAR #undef PERLVARA #undef PERLVARI #undef PERLVARIC #define PERLVAR(p,v,t) EXTERN_C t* Perl_##p##v##_ptr(pTHX); #define PERLVARA(p,v,n,t) typedef t PL_##v##_t[n]; \ EXTERN_C PL_##v##_t* Perl_##p##v##_ptr(pTHX); #define PERLVARI(p,v,t,i) PERLVAR(p,v,t) #define PERLVARIC(p,v,t,i) PERLVAR(p,v, const t) #include "perlvars.h" #undef PERLVAR #undef PERLVARA #undef PERLVARI #undef PERLVARIC END_EXTERN_C #if defined(PERL_CORE) /* accessor functions for Perl "global" variables */ /* these need to be mentioned here, or most linkers won't put them in the perl executable */ #ifndef PERL_NO_FORCE_LINK START_EXTERN_C #ifndef DOINIT EXTCONST void * const PL_force_link_funcs[]; #else EXTCONST void * const PL_force_link_funcs[] = { #undef PERLVAR #undef PERLVARA #undef PERLVARI #undef PERLVARIC #define PERLVAR(p,v,t) (void*)Perl_##p##v##_ptr, #define PERLVARA(p,v,n,t) PERLVAR(p,v,t) #define PERLVARI(p,v,t,i) PERLVAR(p,v,t) #define PERLVARIC(p,v,t,i) PERLVAR(p,v,t) /* In Tru64 (__DEC && __osf__) the cc option -std1 causes that one * cannot cast between void pointers and function pointers without * info level warnings. The PL_force_link_funcs[] would cause a few * hundred of those warnings. In code one can circumnavigate this by using * unions that overlay the different pointers, but in declarations one * cannot use this trick. Therefore we just disable the warning here * for the duration of the PL_force_link_funcs[] declaration. */ #if defined(__DECC) && defined(__osf__) #pragma message save #pragma message disable (nonstandcast) #endif #include "perlvars.h" #if defined(__DECC) && defined(__osf__) #pragma message restore #endif #undef PERLVAR #undef PERLVARA #undef PERLVARI #undef PERLVARIC }; #endif /* DOINIT */ END_EXTERN_C #endif /* PERL_NO_FORCE_LINK */ #else /* !PERL_CORE */ #undef PL_appctx #define PL_appctx (*Perl_Gappctx_ptr(NULL)) #undef PL_check #define PL_check (*Perl_Gcheck_ptr(NULL)) #undef PL_check_mutex #define PL_check_mutex (*Perl_Gcheck_mutex_ptr(NULL)) #undef PL_csighandlerp #define PL_csighandlerp (*Perl_Gcsighandlerp_ptr(NULL)) #undef PL_curinterp #define PL_curinterp (*Perl_Gcurinterp_ptr(NULL)) #undef PL_do_undump #define PL_do_undump (*Perl_Gdo_undump_ptr(NULL)) #undef PL_dollarzero_mutex #define PL_dollarzero_mutex (*Perl_Gdollarzero_mutex_ptr(NULL)) #undef PL_fold_locale #define PL_fold_locale (*Perl_Gfold_locale_ptr(NULL)) #undef PL_hints_mutex #define PL_hints_mutex (*Perl_Ghints_mutex_ptr(NULL)) #undef PL_keyword_plugin #define PL_keyword_plugin (*Perl_Gkeyword_plugin_ptr(NULL)) #undef PL_malloc_mutex #define PL_malloc_mutex (*Perl_Gmalloc_mutex_ptr(NULL)) #undef PL_mmap_page_size #define PL_mmap_page_size (*Perl_Gmmap_page_size_ptr(NULL)) #undef PL_my_ctx_mutex #define PL_my_ctx_mutex (*Perl_Gmy_ctx_mutex_ptr(NULL)) #undef PL_my_cxt_index #define PL_my_cxt_index (*Perl_Gmy_cxt_index_ptr(NULL)) #undef PL_op_mutex #define PL_op_mutex (*Perl_Gop_mutex_ptr(NULL)) #undef PL_op_seq #define PL_op_seq (*Perl_Gop_seq_ptr(NULL)) #undef PL_op_sequence #define PL_op_sequence (*Perl_Gop_sequence_ptr(NULL)) #undef PL_perlio_debug_fd #define PL_perlio_debug_fd (*Perl_Gperlio_debug_fd_ptr(NULL)) #undef PL_perlio_fd_refcnt #define PL_perlio_fd_refcnt (*Perl_Gperlio_fd_refcnt_ptr(NULL)) #undef PL_perlio_fd_refcnt_size #define PL_perlio_fd_refcnt_size (*Perl_Gperlio_fd_refcnt_size_ptr(NULL)) #undef PL_perlio_mutex #define PL_perlio_mutex (*Perl_Gperlio_mutex_ptr(NULL)) #undef PL_ppaddr #define PL_ppaddr (*Perl_Gppaddr_ptr(NULL)) #undef PL_sh_path #define PL_sh_path (*Perl_Gsh_path_ptr(NULL)) #undef PL_sig_defaulting #define PL_sig_defaulting (*Perl_Gsig_defaulting_ptr(NULL)) #undef PL_sig_handlers_initted #define PL_sig_handlers_initted (*Perl_Gsig_handlers_initted_ptr(NULL)) #undef PL_sig_ignoring #define PL_sig_ignoring (*Perl_Gsig_ignoring_ptr(NULL)) #undef PL_sig_trapped #define PL_sig_trapped (*Perl_Gsig_trapped_ptr(NULL)) #undef PL_sigfpe_saved #define PL_sigfpe_saved (*Perl_Gsigfpe_saved_ptr(NULL)) #undef PL_sv_placeholder #define PL_sv_placeholder (*Perl_Gsv_placeholder_ptr(NULL)) #undef PL_thr_key #define PL_thr_key (*Perl_Gthr_key_ptr(NULL)) #undef PL_timesbase #define PL_timesbase (*Perl_Gtimesbase_ptr(NULL)) #undef PL_use_safe_putenv #define PL_use_safe_putenv (*Perl_Guse_safe_putenv_ptr(NULL)) #undef PL_veto_cleanup #define PL_veto_cleanup (*Perl_Gveto_cleanup_ptr(NULL)) #undef PL_watch_pvx #define PL_watch_pvx (*Perl_Gwatch_pvx_ptr(NULL)) #endif /* !PERL_CORE */ #endif /* MULTIPLICITY && PERL_GLOBAL_STRUCT */ #endif /* __perlapi_h__ */ /* ex: set ro: */ PKZy~ ~ proto.hnuW+A/* -*- buffer-read-only: t -*- * * proto.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/embed.pl from data in embed.fnc, * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h. * Any changes made here will be lost! * * Edit those files and run 'make regen_headers' to effect changes. */ START_EXTERN_C PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ assert(stash) PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); PERL_CALLCONV bool Perl__is_utf8__perl_idstart(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__IS_UTF8__PERL_IDSTART \ assert(p) PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const bool flags) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ assert(p); assert(lenp) PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags, bool* tainted_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ assert(p); assert(ustrp) PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ assert(p); assert(ustrp) PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ assert(p); assert(ustrp) PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ assert(p); assert(ustrp) PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_ALLOCMY \ assert(name) PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_CALL \ assert(left); assert(right) PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_APPLY \ assert(mark); assert(sp) PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ assert(stashpv); assert(cv); assert(attrstr) PERL_CALLCONV void Perl_atfork_lock(void); PERL_CALLCONV void Perl_atfork_unlock(void); PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ assert(av) PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_CLEAR \ assert(av) PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ assert(avp); assert(val) PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ assert(avp); assert(val) PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_DELETE \ assert(av) PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, I32 key) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_EXISTS \ assert(av) PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, I32 key) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_EXTEND \ assert(av) PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_FETCH \ assert(av) PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, I32 fill) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_FILL \ assert(av) PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_ITER_P \ assert(av) PERL_CALLCONV I32 Perl_av_len(pTHX_ AV *av) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_LEN \ assert(av) PERL_CALLCONV AV* Perl_av_make(pTHX_ I32 size, SV **strp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AV_MAKE \ assert(strp) PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_POP \ assert(av) PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AV_PUSH \ assert(av); assert(val) PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_REIFY \ assert(av) PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_SHIFT \ assert(av) PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_STORE \ assert(av) PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNDEF \ assert(av) PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, I32 num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_AV_UNSHIFT \ assert(av) PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_BIND_MATCH \ assert(left); assert(right) PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq) __attribute__warn_unused_result__; PERL_CALLCONV I32 Perl_block_gimme(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_block_start(pTHX_ int full) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ assert(hk) PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); PERL_CALLCONV void Perl_boot_core_mro(pTHX); PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ assert(b); assert(u) PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ assert(s); assert(len) PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ assert(s); assert(len) PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CALL_LIST \ assert(paramList) PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CALL_METHOD \ assert(methname) PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CALL_PV \ assert(sub_name) PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CALL_SV \ assert(sv) PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CANDO \ assert(statbufp) PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f) __attribute__warn_unused_result__; PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f) __attribute__warn_unused_result__; PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f) __attribute__warn_unused_result__; PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ assert(s) PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_ANONCODE \ assert(o) PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_BITOP \ assert(o) PERL_CALLCONV OP * Perl_ck_chdir(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_CHDIR \ assert(o) PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_CMP \ assert(o) PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_CONCAT \ assert(o) PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_DEFINED \ assert(o) PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_DELETE \ assert(o) PERL_CALLCONV OP * Perl_ck_die(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_DIE \ assert(o) PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EACH \ assert(o) PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ assert(entersubop) PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ assert(entersubop); assert(namegv); assert(protosv) PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EOF \ assert(o) PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EVAL \ assert(o) PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EXEC \ assert(o) PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EXISTS \ assert(o) PERL_CALLCONV OP * Perl_ck_exit(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_EXIT \ assert(o) PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_FTST \ assert(o) PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_FUN \ assert(o) PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_GLOB \ assert(o) PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_GREP \ assert(o) PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_INDEX \ assert(o) PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_JOIN \ assert(o) PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_LENGTH \ assert(o) PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_LFUN \ assert(o) PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_LISTIOB \ assert(o) PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_MATCH \ assert(o) PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_METHOD \ assert(o) PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_NULL \ assert(o) PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_OPEN \ assert(o) PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_READLINE \ assert(o) PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_REPEAT \ assert(o) PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_REQUIRE \ assert(o) PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_RETURN \ assert(o) PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_RFUN \ assert(o) PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_RVCONST \ assert(o) PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SASSIGN \ assert(o) PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SELECT \ assert(o) PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SHIFT \ assert(o) PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SMARTMATCH \ assert(o) PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SORT \ assert(o) PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SPAIR \ assert(o) PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SPLIT \ assert(o) PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SUBR \ assert(o) PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SUBSTR \ assert(o) PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_SVCONST \ assert(o) PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_TELL \ assert(o) PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CK_TRUNC \ assert(o) PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CK_WARNER \ assert(pat) PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CK_WARNER_D \ assert(pat) PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w); PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w); PERL_CALLCONV OP* Perl_convert(pTHX_ I32 optype, I32 flags, OP* o) __attribute__warn_unused_result__; PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ assert(cop) PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ assert(cop); assert(label) PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ assert(name) PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *coreargssv, const int code, const int opnum) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CORESUB_OP \ assert(coreargssv) PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags); PERL_CALLCONV void Perl_croak(pTHX_ const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); PERL_CALLCONV void Perl_croak_no_modify(pTHX) __attribute__noreturn__; PERL_CALLCONV void Perl_croak_sv(pTHX_ SV *baseex) __attribute__noreturn__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CROAK_SV \ assert(baseex) PERL_CALLCONV void Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) __attribute__noreturn__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ assert(cv); assert(params) PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ assert(o) PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ assert(o) PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ assert(ppaddr); assert(xop) PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o) __attribute__pure__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CUSTOM_OP_XOP \ assert(o) PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ assert(cv) PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CV_CLONE \ assert(proto) PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ assert(cv); assert(ckfun_p); assert(ckobj_p) PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ assert(cv); assert(ckfun); assert(ckobj) PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CV_UNDEF \ assert(cv) PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_SET \ assert(cv) PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CVSTASH_SET \ assert(cv) PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CX_DUMP \ assert(cx) PERL_CALLCONV I32 Perl_cxinc(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DEB \ assert(pat) PERL_CALLCONV void Perl_deb_stack_all(pTHX); PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DEBOP \ assert(o) PERL_CALLCONV void Perl_debprofdump(pTHX); PERL_CALLCONV I32 Perl_debstack(pTHX); PERL_CALLCONV I32 Perl_debstackptrs(pTHX); PERL_CALLCONV void Perl_delete_eval_scope(pTHX); PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4) __attribute__nonnull__(6); #define PERL_ARGS_ASSERT_DELIMCPY \ assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) PERL_CALLCONV void Perl_despatch_signals(pTHX); PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...) __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DIE_SV \ assert(baseex) PERL_CALLCONV void Perl_die_unwind(pTHX_ SV* msv) __attribute__noreturn__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DIE_UNWIND \ assert(msv) /* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ #define PERL_ARGS_ASSERT_DO_AEXEC \ assert(mark); assert(sp) PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_AEXEC5 \ assert(mark); assert(sp) PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_BINMODE \ assert(fp) PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ assert(file) PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_EOF \ assert(gv) PERL_CALLCONV void Perl_do_execfree(pTHX); PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_GV_DUMP \ assert(file); assert(name) PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ assert(file); assert(name) PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_HV_DUMP \ assert(file); assert(name) PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_DO_JOIN \ assert(sv); assert(delim); assert(mark); assert(sp) PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ assert(file); assert(mg) PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV *const left, SV *const right) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_NCMP \ assert(left); assert(right) PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) /* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_DO_OPEN \ assert(gv); assert(name) PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_8); #define PERL_ARGS_ASSERT_DO_OPEN9 \ assert(gv); assert(name); assert(svs) PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_OPENN \ assert(gv); assert(oname) PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ assert(file) PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_PRINT \ assert(fp) PERL_CALLCONV OP* Perl_do_readline(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_SPRINTF \ assert(sv); assert(sarg) PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_SV_DUMP \ assert(file) PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_SYSSEEK \ assert(gv) PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TELL \ assert(gv) PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, I32 offset, I32 size) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_VECSET \ assert(sv) PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_DO_VOP \ assert(sv); assert(left); assert(right) PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOFILE \ assert(term) PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) __attribute__warn_unused_result__; PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOREF \ assert(o) PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); PERL_CALLCONV I32 Perl_dowantarray(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_dump_all(pTHX); PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); PERL_CALLCONV void Perl_dump_eval(pTHX); PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_FORM \ assert(gv) PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) __attribute__format__(__printf__,pTHX_3,pTHX_4) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_INDENT \ assert(file); assert(pat) PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ assert(stash) PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ assert(stash) PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_SUB \ assert(gv) PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ assert(gv) PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ assert(file); assert(pat) PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ assert(c); assert(sv) PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_PV \ assert(p) PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_EVAL_SV \ assert(sv) PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FBM_COMPILE \ assert(sv) PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_FBM_INSTR \ assert(big); assert(bigend); assert(littlestr) PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \ assert(name) PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FILTER_DEL \ assert(funcp) PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_FILTER_READ \ assert(buf_sv) PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ assert(o) PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_find_rundefsv(pTHX); PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FIND_RUNDEFSV2 \ assert(cv) PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) __attribute__deprecated__; PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) PERL_CALLCONV I32 Perl_foldEQ(const char* a, const char* b, I32 len) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_FOLDEQ \ assert(a); assert(b) PERL_CALLCONV I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ assert(a); assert(b) PERL_CALLCONV I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ assert(a); assert(b) /* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_5); */ PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ assert(s1); assert(s2) PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORM \ assert(pat) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); PERL_CALLCONV void Perl_free_tmps(pTHX); PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_AV \ assert(name) PERL_CALLCONV void* Perl_get_context(void) __attribute__warn_unused_result__; PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_CV \ assert(name) PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ assert(name) PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv) PERL_CALLCONV UV Perl_get_hash_seed(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_HV \ assert(name) PERL_CALLCONV const char* Perl_get_no_modify(pTHX) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV char** Perl_get_op_descs(pTHX) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV char** Perl_get_op_names(pTHX) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV U32* Perl_get_opargs(pTHX) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_SV \ assert(name) PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GETCWD_SV \ assert(sv) PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GROK_BIN \ assert(start); assert(len_p); assert(flags) PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GROK_HEX \ assert(start); assert(len_p); assert(flags) PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER \ assert(pv) PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ assert(sp); assert(send) PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GROK_OCT \ assert(start); assert(len_p); assert(flags) /* PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); */ /* PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); */ /* PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); */ PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); /* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); */ PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ assert(namepv) PERL_CALLCONV GV* Perl_gv_autoload_pvn(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ assert(name) PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ assert(namesv) PERL_CALLCONV void Perl_gv_check(pTHX_ const HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_CHECK \ assert(stash) PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_CONST_SV \ assert(gv) PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_DUMP \ assert(gv) PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_EFULLNAME \ assert(sv); assert(gv) /* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ assert(sv); assert(gv) PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ assert(sv); assert(gv) PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) /* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) __attribute__nonnull__(pTHX_2); */ /* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) __attribute__nonnull__(pTHX_2); */ PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ assert(namesv) PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) /* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ assert(stash); assert(name) PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ assert(stash); assert(name) PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ assert(stash); assert(name) PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ assert(stash); assert(name) PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ assert(stash); assert(namesv) PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPV \ assert(nambeg) PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ assert(name) PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FULLNAME \ assert(sv); assert(gv) /* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ assert(sv); assert(gv) PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ assert(sv); assert(gv) PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) __attribute__warn_unused_result__; /* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PV \ assert(gv); assert(name) PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_PVN \ assert(gv); assert(name) PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_GV_INIT_SV \ assert(gv); assert(namesv) PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GV_NAME_SET \ assert(gv); assert(name) PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPV \ assert(name) PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHPVN \ assert(name) PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_STASHSV \ assert(sv) PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ assert(gv) PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ assert(hv) PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ assert(hv) PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ assert(key) PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ assert(hv) /* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_DELETE \ assert(key) /* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_DELETE_ENT \ assert(keysv) PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_EITER_P \ assert(hv) PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_EITER_SET \ assert(hv) PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ assert(hv); assert(name) PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ assert(hv); assert(name) /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_EXISTS \ assert(key) /* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ assert(keysv) /* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_FETCH \ assert(key) /* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_HV_FETCH_ENT \ assert(keysv) PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV const *const hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_FILL \ assert(hv) PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entryK) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_FREE_ENT \ assert(hv) PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_ITERINIT \ assert(hv) PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_ITERKEY \ assert(entry); assert(retlen) PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) /* PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_HV_ITERNEXT \ assert(hv) PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ assert(hv) PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ assert(hv); assert(key); assert(retlen) PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV *hv, HE *entry) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HV_ITERVAL \ assert(hv); assert(entry) PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv) /* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_HV_MAGIC \ assert(hv) PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_NAME_SET \ assert(hv) PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ assert(hv) PERL_CALLCONV I32* Perl_hv_placeholders_p(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ assert(hv) PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ assert(hv) PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_RITER_P \ assert(hv) PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_RITER_SET \ assert(hv) PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_SCALAR \ assert(hv) /* PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ /* PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ /* PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ /* PERL_CALLCONV void hv_undef(pTHX_ HV *hv); */ PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); /* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ /* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ /* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_5); */ PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ assert(argv) PERL_CALLCONV void Perl_init_dbargs(pTHX); PERL_CALLCONV void Perl_init_debugger(pTHX); PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn); PERL_CALLCONV void Perl_init_stacks(pTHX); PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INIT_TM \ assert(ptm) PERL_CALLCONV char* Perl_instr(const char* big, const char* little) __attribute__warn_unused_result__ __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_INSTR \ assert(big); assert(little) PERL_CALLCONV U32 Perl_intro_my(pTHX); PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_ASCII_STRING \ assert(s) PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV bool Perl_is_utf8_X_L(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_L \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_LV(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_LV \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_LVT(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_T(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_T \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_V(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_V \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_begin(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_extend(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL \ assert(p) PERL_CALLCONV bool Perl_is_utf8_X_prepend(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND \ assert(p) PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ assert(p) PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \ assert(p) PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \ assert(p) PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) __attribute__deprecated__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR \ assert(s) PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ assert(buf); assert(buf_end) PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \ assert(p) PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \ assert(p) PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ assert(p) PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \ assert(p) PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_MARK \ assert(p) PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \ assert(p) PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \ assert(p) PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ assert(p) PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_UTF8_STRING \ assert(s) /* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p) __attribute__nonnull__(1); */ #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ assert(s) PERL_CALLCONV bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ assert(s) PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xidcont(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT \ assert(p) PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \ assert(p) PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_JMAYBE \ assert(o) PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) __attribute__pure__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_KEYWORD \ assert(name) PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ assert(keyword_ptr); assert(op_ptr) PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); PERL_CALLCONV bool Perl_lex_bufutf8(pTHX); PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ assert(ptr) PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len); PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags); PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags); PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags); PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_READ_TO \ assert(ptr) PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags); PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ assert(pv) PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char* pv, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ assert(pv) PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ assert(sv) PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ assert(ptr) PERL_CALLCONV OP* Perl_list(pTHX_ OP* o); PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_LOAD_MODULE \ assert(name) PERL_CALLCONV OP* Perl_localize(pTHX_ OP *o, I32 lex) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LOCALIZE \ assert(o) PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV *const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ assert(sv) PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ assert(mg) PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ assert(sv); assert(mg) PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_get(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GET \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV* sv, const MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ assert(sv); assert(mg) PERL_CALLCONV U32 Perl_magic_len(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_LEN \ assert(sv); assert(mg) PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ assert(sv); assert(mg); assert(meth) PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ assert(sv); assert(mg); assert(key) PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) __attribute__noreturn__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ assert(sv); assert(mg) PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ assert(hv); assert(mg) PERL_CALLCONV int Perl_magic_set(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SET \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setamagic(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETAMAGIC \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETENV \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETISA \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ assert(mg) PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setvstring(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETVSTRING \ assert(sv); assert(mg) PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ assert(sv); assert(mg) PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_markstack_grow(pTHX); PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MESS \ assert(pat) PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MESS_SV \ assert(basemsg) PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_CLEAR \ assert(sv) PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MG_COPY \ assert(sv); assert(nsv) PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type) __attribute__warn_unused_result__; PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE \ assert(sv) PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV* sv, int how) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ assert(sv) PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_GET \ assert(sv) PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_LENGTH \ assert(sv) PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MG_LOCALIZE \ assert(sv); assert(nsv) PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_MAGICAL \ assert(sv) PERL_CALLCONV int Perl_mg_set(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_SET \ assert(sv) PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MG_SIZE \ assert(sv) PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MINI_MKTIME \ assert(ptm) PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len); PERL_CALLCONV void * Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size); PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MORESWITCHES \ assert(s) PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ assert(name) PERL_CALLCONV AV* Perl_mro_get_linear_isa(pTHX_ HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ assert(stash) PERL_CALLCONV SV* Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ assert(smeta); assert(which) PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ assert(stash) PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_META_INIT \ assert(stash) PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ assert(stash) PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ assert(gv) PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_REGISTER \ assert(mro) PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MRO_SET_MRO \ assert(meta); assert(name) PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which, SV *const data) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ assert(smeta); assert(which); assert(data) PERL_CALLCONV void Perl_munge_qwlist_to_paren_list(pTHX_ OP* qwlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MUNGE_QWLIST_TO_PAREN_LIST \ assert(qwlist) PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_ATOF \ assert(s) PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *s, NV* value) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MY_ATOF2 \ assert(s); assert(value) PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_ATTRS \ assert(o) PERL_CALLCONV void Perl_my_clearenv(pTHX); PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir); PERL_CALLCONV void Perl_my_exit(pTHX_ U32 status) __attribute__noreturn__; PERL_CALLCONV void Perl_my_failure_exit(pTHX) __attribute__noreturn__; PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); PERL_CALLCONV Pid_t Perl_my_fork(void); /* PERL_CALLCONV I32 Perl_my_lstat(pTHX); */ PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ assert(mode); assert(args) PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val); PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) __attribute__format__(__printf__,3,4) __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_MY_SNPRINTF \ assert(buffer); assert(format) PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); /* PERL_CALLCONV I32 Perl_my_stat(pTHX); */ PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_STRFTIME \ assert(fmt) PERL_CALLCONV void Perl_my_swabn(void* ptr, int n) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MY_SWABN \ assert(ptr) PERL_CALLCONV void Perl_my_unexec(pTHX); PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap) __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ assert(buffer); assert(format) PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block); PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV CV* Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); PERL_CALLCONV CV* Perl_newATTRSUB_flags(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, U32 flags); /* PERL_CALLCONV AV* Perl_newAV(pTHX) __attribute__warn_unused_result__; */ PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWAVREF \ assert(o) PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWCONDOP \ assert(first) PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv); PERL_CALLCONV CV* Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv); PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWFOROP \ assert(expr) PERL_CALLCONV OP* Perl_newGIVENOP(pTHX_ OP* cond, OP* block, PADOFFSET defsv_off) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWGIVENOP \ assert(cond); assert(block) PERL_CALLCONV GP * Perl_newGP(pTHX_ GV *const gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWGP \ assert(gv) PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWGVOP \ assert(gv) PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o) __attribute__malloc__ __attribute__warn_unused_result__; /* PERL_CALLCONV GV* newGVgen(pTHX_ const char* pack) __attribute__nonnull__(pTHX_1); */ PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ assert(pack) /* PERL_CALLCONV HV* Perl_newHV(pTHX) __attribute__warn_unused_result__; */ PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWHVREF \ assert(o) PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv) __attribute__malloc__ __attribute__warn_unused_result__; /* PERL_CALLCONV IO* Perl_newIO(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; */ PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_NEWLOGOP \ assert(first); assert(other) PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWLOOPEX \ assert(label) PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWPROG \ assert(o) PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWRANGE \ assert(left); assert(right) PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWRV \ assert(sv) PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWRV_NOINC \ assert(sv) PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) __attribute__malloc__ __attribute__warn_unused_result__; /* PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */ PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWSVOP \ assert(sv) PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWSVREF \ assert(o) PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpv_share(pTHX_ const char* s, U32 hash) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWSVPVF \ assert(pat) PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWWHENOP \ assert(block) PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV CV* Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS \ assert(subaddr); assert(filename) PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ assert(subaddr); assert(filename) PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char *const filename, const char *const proto, SV **const_svp, U32 flags) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ assert(subaddr); assert(filename) PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll); PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEW_CTYPE \ assert(newctype) PERL_CALLCONV void Perl_new_numeric(pTHX_ const char* newcoll); PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEW_VERSION \ assert(ver) PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits, STRLEN size) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ assert(bits) PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEXTARGV \ assert(gv) PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4); #define PERL_ARGS_ASSERT_NINSTR \ assert(big); assert(bigend); assert(little); assert(lend) PERL_CALLCONV int Perl_nothreadhook(pTHX); PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OOPSAV \ assert(o) PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OOPSHV \ assert(o) PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_CLEAR \ assert(o) PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv) __attribute__warn_unused_result__; PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ assert(o) PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_DUMP \ assert(o) PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg); PERL_CALLCONV OP* Perl_op_linklist(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_LINKLIST \ assert(o) /* PERL_CALLCONV OP* op_lvalue(pTHX_ OP* o, I32 type); */ PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags); PERL_CALLCONV void Perl_op_null(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_NULL \ assert(o) PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5) __attribute__nonnull__(pTHX_6); #define PERL_ARGS_ASSERT_PACK_CAT \ assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) PERL_CALLCONV void Perl_package_version(pTHX_ OP* v) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ assert(v) PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_PACKLIST \ assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist) PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV* func, I32 optype) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ assert(func) PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ assert(name) PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ assert(namepv) PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ assert(name) PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full); PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po) __attribute__warn_unused_result__; PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ assert(name) PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char* namepv, STRLEN namelen, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ assert(namepv) PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV* name, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ assert(name) PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ assert(padlist); assert(old_cv); assert(new_cv) PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); PERL_CALLCONV void Perl_pad_leavemy(pTHX); PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_PUSH \ assert(padlist) PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_fullexpr(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags); PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags); PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ assert(popt) PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PARSER_FREE \ assert(parser) PERL_CALLCONV void Perl_peep(pTHX_ OP* o); PERL_CALLCONV PerlInterpreter* perl_alloc(void); PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ assert(my_perl) PERL_CALLCONV int perl_destruct(PerlInterpreter *my_perl) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ assert(my_perl) PERL_CALLCONV void perl_free(PerlInterpreter *my_perl) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_FREE \ assert(my_perl) PERL_CALLCONV int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_PARSE \ assert(my_perl) PERL_CALLCONV int perl_run(PerlInterpreter *my_perl) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_RUN \ assert(my_perl) PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PMRUNTIME \ assert(o); assert(expr) PERL_CALLCONV void Perl_pop_scope(pTHX); PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_POPULATE_ISA \ assert(name) PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PREGCOMP \ assert(pattern) PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_6); #define PERL_ARGS_ASSERT_PREGEXEC \ assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r); PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PREGFREE2 \ assert(rx) PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ assert(s) PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl) __attribute__deprecated__; PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ assert(tbl) PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl); PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ assert(tbl) PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ assert(tbl); assert(newsv) PERL_CALLCONV void Perl_push_scope(pTHX); PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PV_DISPLAY \ assert(dsv); assert(pv) PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PV_ESCAPE \ assert(dsv); assert(str) PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PV_PRETTY \ assert(dsv); assert(str) PERL_CALLCONV char* Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ assert(dsv); assert(spv) PERL_CALLCONV void Perl_qerror(pTHX_ SV* err) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_QERROR \ assert(err) PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RE_COMPILE \ assert(pattern) PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_RE_INTUIT_START \ assert(rx); assert(strpos); assert(strend) PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ assert(r) PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; /* PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); */ PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ assert(key) PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ assert(keypv) PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ assert(key) PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ assert(key) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ assert(keypv) PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ assert(key) PERL_CALLCONV SV* Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ assert(rx) PERL_CALLCONV SV* Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ assert(rx) PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ assert(rx); assert(key) PERL_CALLCONV SV* Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ assert(rx); assert(namesv) PERL_CALLCONV SV* Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ assert(rx) PERL_CALLCONV SV* Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ assert(rx) PERL_CALLCONV SV* Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ assert(rx) PERL_CALLCONV SV* Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ assert(rx) PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren, SV * const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ assert(rx) PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ assert(rx); assert(sv) PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ assert(rx) PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ assert(rx) PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* ret_x, REGEXP* rx) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ assert(rx) PERL_CALLCONV SV* Perl_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGCLASS_SWASH \ assert(node) PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, I32 minend, SV *sv, void *data, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_6); #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv) PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ assert(rx) PERL_CALLCONV void Perl_reginitcolors(pTHX); PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGPROP \ assert(sv); assert(o) PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_REPEATCPY \ assert(to); assert(from) PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv); PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have); PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REQUIRE_PV \ assert(pv) PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4); #define PERL_ARGS_ASSERT_RNINSTR \ assert(big); assert(bigend); assert(little); assert(lend) PERL_CALLCONV void Perl_rpeep(pTHX_ OP* o); PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t); PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t); PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ assert(save) PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); PERL_CALLCONV int Perl_runops_debug(pTHX); PERL_CALLCONV int Perl_runops_standard(pTHX); PERL_CALLCONV CV* Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ assert(cvop) PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_RXRES_SAVE \ assert(rsp); assert(rx) PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where); PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I16 \ assert(intp) PERL_CALLCONV void Perl_save_I32(pTHX_ I32* intp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I32 \ assert(intp) PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_I8 \ assert(bytep) PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, I32 key) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ assert(av) /* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, I32 idx, SV **sptr, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ assert(av); assert(sptr) PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad); PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_APTR \ assert(aptr) PERL_CALLCONV AV* Perl_save_ary(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ARY \ assert(gv) PERL_CALLCONV void Perl_save_bool(pTHX_ bool* boolp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_BOOL \ assert(boolp) PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV** svp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ assert(svp) PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DELETE \ assert(hv); assert(key) PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ assert(p) PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p); /* PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); */ /* PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); */ /* PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); */ PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ assert(str) PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV** sptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ assert(sptr) PERL_CALLCONV void Perl_save_gp(pTHX_ GV* gv, I32 empty) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_GP \ assert(gv) PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HASH \ assert(gv) PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ assert(hv); assert(keysv) /* PERL_CALLCONV void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ assert(hv); assert(key); assert(sptr) PERL_CALLCONV void Perl_save_hints(pTHX); PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_HPTR \ assert(hptr) PERL_CALLCONV void Perl_save_int(pTHX_ int* intp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_INT \ assert(intp) PERL_CALLCONV void Perl_save_item(pTHX_ SV* item) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_ITEM \ assert(item) PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_LIST \ assert(sarg) PERL_CALLCONV void Perl_save_long(pTHX_ long* longp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_LONG \ assert(longp) /* PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ assert(sv) PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_NOGV \ assert(gv) /* PERL_CALLCONV void Perl_save_op(pTHX); */ PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_PPTR \ assert(pptr) PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type); PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type); PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type); PERL_CALLCONV void Perl_save_re_context(pTHX); PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SCALAR \ assert(gv) PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ assert(sv) PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char** str) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ assert(str) PERL_CALLCONV void Perl_save_sptr(pTHX_ SV** sptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SPTR \ assert(sptr) PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SVREF \ assert(sptr) PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_VPTR \ assert(ptr) PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, I32 len) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ assert(sv) PERL_CALLCONV void Perl_savestack_grow(pTHX); PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need); PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVESVPV \ assert(sv) PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o); PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o); PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCALARVOID \ assert(o) PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char* start, STRLEN len, STRLEN* retlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_BIN \ assert(start); assert(retlen) PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char* start, STRLEN len, STRLEN* retlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_HEX \ assert(start); assert(retlen) PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_NUM \ assert(s); assert(lvalp) PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_OCT \ assert(start); assert(retlen) PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SCAN_VERSION \ assert(s); assert(rv) PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, SV *sv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_VSTRING \ assert(s); assert(e); assert(sv) PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_SCREAMINSTR \ assert(bigstr); assert(littlestr); assert(old_posp) PERL_CALLCONV U32 Perl_seed(pTHX); PERL_CALLCONV void Perl_set_context(void *t) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SET_CONTEXT \ assert(t) PERL_CALLCONV void Perl_set_numeric_local(pTHX); PERL_CALLCONV void Perl_set_numeric_radix(pTHX); PERL_CALLCONV void Perl_set_numeric_standard(pTHX); PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SHARE_HEK \ assert(str) PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV \ assert(cmp) PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ assert(cmp) PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, int n) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_STACK_GROW \ assert(sp); assert(p) PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_START_GLOB \ assert(tmpglob); assert(io) PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); PERL_CALLCONV bool Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_STASHPV_HVNAME_MATCH \ assert(c); assert(hv) PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_STR_TO_VERSION \ assert(sv) PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ assert(cv) /* PERL_CALLCONV bool sv_2bool(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); */ PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *const sv, const I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ assert(sv) PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const I32 lref) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SV_2CV \ assert(st); assert(gvp) PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IO \ assert(sv) /* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv); */ PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags); PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv); PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2NUM \ assert(sv) PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags); /* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags); /* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ assert(sv) PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVBYTE \ assert(sv) /* PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ assert(sv) PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2PVUTF8 \ assert(sv) /* PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ assert(sv) /* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv); */ PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags); PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_BACKOFF \ assert(sv) PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV *const sv, HV *const stash) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_BLESS \ assert(sv); assert(stash) PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV \ assert(sv) PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV *dstr, const char *sstr, const I32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ assert(dstr); assert(sstr) PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATPV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ assert(sv); assert(pat) /* PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_SV_CATPVN \ assert(dsv); assert(sstr) PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV *const dstr, const char *sstr, const STRLEN len, const I32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ assert(dstr); assert(sstr) /* PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_SV_CATPVN_MG \ assert(sv); assert(ptr) /* PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_CATSV \ assert(dstr) PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ assert(dsv) /* PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_CATSV_MG \ assert(dsv) PERL_CALLCONV void Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_CHOP \ assert(sv) PERL_CALLCONV I32 Perl_sv_clean_all(pTHX); PERL_CALLCONV void Perl_sv_clean_objs(pTHX); PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const orig_sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_CLEAR \ assert(orig_sv) PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); PERL_CALLCONV OP* Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp) __attribute__deprecated__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SV_COMPILE_2OP \ assert(sv); assert(startop); assert(code); assert(padp) PERL_CALLCONV OP* Perl_sv_compile_2op_is_broken(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SV_COMPILE_2OP_IS_BROKEN \ assert(sv); assert(startop); assert(code); assert(padp) PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_COPYPV \ assert(dsv); assert(ssv) PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ assert(tsv); assert(sv) PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV* sv, const char *const name) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV* sv, const char *const name, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ assert(sv); assert(namesv) PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DOES \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV* sv, const char *const name, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DOES_PV \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DOES_PVN \ assert(sv); assert(name) PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DOES_SV \ assert(sv); assert(namesv) PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_DUMP \ assert(sv) /* PERL_CALLCONV I32 sv_eq(pTHX_ SV* sv1, SV* sv2); */ PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); /* PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ assert(sv) PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ assert(sv) PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) PERL_CALLCONV void Perl_sv_free_arenas(pTHX); PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_GETS \ assert(sv); assert(fp) PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_GROW \ assert(sv) PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV *const sv); /* PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4); */ #define PERL_ARGS_ASSERT_SV_INSERT \ assert(bigstr); assert(little) PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ assert(bigstr); assert(little) PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_ISA \ assert(name) PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_IV \ assert(sv) PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGIC \ assert(sv) PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_MAGICEXT \ assert(sv) PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_sv_newmortal(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv); /* PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv); */ PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_NV \ assert(sv) PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_B2U \ assert(offsetp) PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_POS_U2B \ assert(offsetp) PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ assert(sv) /* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_PV \ assert(sv) /* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_PVBYTE \ assert(sv) PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_PVBYTEN \ assert(sv); assert(lp) PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_PVN \ assert(sv); assert(lp) /* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ assert(sv) PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ assert(sv) /* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_PVUTF8 \ assert(sv) PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_PVUTF8N \ assert(sv); assert(lp) PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ assert(sv) PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ assert(sv); assert(encoding) PERL_CALLCONV SV* Perl_sv_ref(pTHX_ SV *dst, const SV *const sv, const int ob) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_REF \ assert(sv) PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_REFTYPE \ assert(sv) PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_REPLACE \ assert(sv); assert(nsv) PERL_CALLCONV void Perl_sv_report_used(pTHX); PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_RESET \ assert(s) PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ assert(sv) PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETHEK \ assert(sv) PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV \ assert(sv) PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETIV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV \ assert(sv) PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETNV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV \ assert(sv) PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVIV \ assert(sv) PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \ assert(sv) PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETPVN \ assert(sv) PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ assert(sv); assert(ptr) PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_IV \ assert(rv) PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_NV \ assert(rv) PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_PV \ assert(rv) PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ assert(rv); assert(pv) PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETREF_UV \ assert(rv) /* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_SETSV \ assert(dstr) PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ assert(dstr) PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETSV_MG \ assert(dstr) PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV \ assert(sv) PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ assert(sv) /* PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_TAINT \ assert(sv) PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_TAINTED \ assert(sv) PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ assert(dsv); assert(ssv) PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGIC \ assert(sv) PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ assert(sv) /* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_UNREF \ assert(sv) PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ assert(ref) PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNTAINT \ assert(sv) PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UPGRADE \ assert(sv) /* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_USEPVN \ assert(sv) PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ assert(sv) /* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_USEPVN_MG \ assert(sv) PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ assert(sv) PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ assert(sv) /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags) __attribute__nonnull__(pTHX_1); */ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); */ PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UV \ assert(sv) PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VCATPVFN \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_VSETPVFN \ assert(sv); assert(pat) PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SWASH_FETCH \ assert(swash); assert(ptr) PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SWASH_INIT \ assert(pkg); assert(name); assert(listsv) PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SYS_INIT \ assert(argc); assert(argv) PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_SYS_INIT3 \ assert(argc); assert(argv); assert(env) PERL_CALLCONV void Perl_sys_term(void); PERL_CALLCONV void Perl_taint_env(pTHX); PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TAINT_PROPER \ assert(s) PERL_CALLCONV OP * Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_TIED_METHOD \ assert(methname); assert(sp); assert(sv); assert(mg) PERL_CALLCONV void Perl_tmps_grow(pTHX_ I32 n); /* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_TO_UTF8_CASE \ assert(p); assert(ustrp); assert(swashp); assert(normal) /* PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_TO_UTF8_FOLD \ assert(p); assert(ustrp) /* PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \ assert(p); assert(ustrp) /* PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \ assert(p); assert(ustrp) /* PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \ assert(p); assert(ustrp) PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); PERL_CALLCONV I32 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_UNPACK_STR \ assert(pat); assert(patend); assert(s); assert(strend) PERL_CALLCONV I32 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UNPACKSTRING \ assert(pat); assert(patend); assert(s); assert(strend) PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UPG_VERSION \ assert(ver) PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ assert(p); assert(d); assert(newlen) PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ assert(p); assert(d); assert(newlen) PERL_CALLCONV IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) __attribute__warn_unused_result__ __attribute__pure__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ assert(a); assert(b) PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off) __attribute__warn_unused_result__ __attribute__pure__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UTF8_HOP \ assert(s) PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) __attribute__warn_unused_result__ __attribute__pure__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_LENGTH \ assert(s); assert(e) PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ assert(s); assert(len) PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ assert(s) PERL_CALLCONV UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ assert(s); assert(send) PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ assert(s) PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \ assert(s); assert(send) PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ assert(s) PERL_CALLCONV U8* Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS \ assert(d) /* PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ assert(d) PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ assert(d) PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ assert(s) PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ assert(s) PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_VCMP \ assert(lhv); assert(rhv) PERL_CALLCONV void Perl_vcroak(pTHX_ const char* pat, va_list* args) __attribute__noreturn__; PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VDEB \ assert(pat) PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VFORM \ assert(pat) PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ assert(sv) PERL_CALLCONV SV* Perl_vivify_ref(pTHX_ SV* sv, U32 to_what) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VIVIFY_REF \ assert(sv) PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_VLOAD_MODULE \ assert(name) PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VMESS \ assert(pat) PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VNEWSVPVF \ assert(pat) PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VNORMAL \ assert(vs) PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VNUMIFY \ assert(vs) PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VSTRINGIFY \ assert(vs) PERL_CALLCONV SV* Perl_vverify(pTHX_ SV *vs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VVERIFY \ assert(vs) PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VWARN \ assert(pat) PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_VWARNER \ assert(pat) PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_WAIT4PID \ assert(statusp) PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WARN \ assert(pat) PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WARN_SV \ assert(baseex) PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_WARNER \ assert(pat) PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_watch(pTHX_ char** addr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WATCH \ assert(addr) /* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig) __attribute__nonnull__(pTHX_1); */ PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ assert(sig) PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char* sig, STRLEN len) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ assert(sig) PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV* sigsv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WHICHSIG_SV \ assert(sigsv) PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ assert(new_checker); assert(old_checker_p) PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ assert(msv) PERL_CALLCONV void Perl_xs_apiversion_bootcheck(pTHX_ SV *module, const char *api_p, STRLEN api_len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK \ assert(module); assert(api_p) PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ assert(xs_p) PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_YYERROR \ assert(s) PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_YYERROR_PV \ assert(s) PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_YYERROR_PVN \ assert(s) PERL_CALLCONV int Perl_yylex(pTHX); PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); PERL_CALLCONV void Perl_yyunlex(pTHX); #if !(defined(DEBUGGING)) # if !defined(NV_PRESERVES_UV) # if defined(PERL_IN_SV_C) STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) # endif # endif #endif #if !(defined(EBCDIC)) /* PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ assert(s) /* PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) __attribute__nonnull__(pTHX_1); */ #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ assert(d) #endif #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) PERL_CALLCONV Signal_t Perl_csighandler(int sig); PERL_CALLCONV Signal_t Perl_sighandler(int sig); #endif #if !(defined(NO_MATHOMS)) PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); #endif #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) #endif #if !(defined(PERL_GLOBAL_STRUCT_PRIVATE)) # if defined(PERL_IMPLICIT_CONTEXT) PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_CXT_INIT \ assert(index) # endif #endif #if !(defined(PERL_MAD)) PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); PERL_CALLCONV void Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) __attribute__noreturn__; PERL_CALLCONV void Perl_package(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PACKAGE \ assert(o) PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) #endif #if !(defined(USE_ITHREADS)) # if defined(PERL_IN_OP_C) STATIC void S_forget_pmop(pTHX_ PMOP *const o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) # endif #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MY_BZERO \ assert(loc) #endif #if !defined(HAS_GETENV_LEN) PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GETENV_LEN \ assert(env_elem); assert(len) #endif #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) PERL_CALLCONV I32 Perl_my_memcmp(const char* s1, const char* s2, I32 len) __attribute__pure__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_MY_MEMCMP \ assert(s1); assert(s2) #endif #if !defined(HAS_MEMSET) PERL_CALLCONV void* Perl_my_memset(char* loc, I32 ch, I32 len) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MY_MEMSET \ assert(loc) #endif #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) # if defined(PERL_IN_PP_SYS_C) STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DOONELINER \ assert(cmd); assert(filename) # endif #endif #if !defined(HAS_RENAME) PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAME_DIRENT \ assert(a); assert(b) #endif #if !defined(HAS_SIGNBIT) PERL_CALLCONV int Perl_signbit(NV f) __attribute__pure__; #endif #if !defined(HAS_STRLCAT) PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); #endif #if !defined(HAS_STRLCPY) PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); #endif #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) __attribute__warn_unused_result__; #endif #if !defined(NV_PRESERVES_UV) # if defined(DEBUGGING) # if defined(PERL_IN_SV_C) STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ assert(sv) # endif # endif #endif #if !defined(PERL_DISABLE_PMC) # if defined(PERL_IN_PP_CTL_C) STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOOPEN_PM \ assert(name) # endif #endif #if !defined(PERL_IMPLICIT_SYS) PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MY_POPEN \ assert(cmd); assert(mode) #endif #if !defined(PERL_IS_MINIPERL) # if defined(PERL_IN_PERL_C) STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ assert(av); assert(dir); assert(stem) # endif #endif #if !defined(PERL_NO_UTF16_FILTER) # if defined(PERL_IN_TOKE_C) STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ assert(s) STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ assert(sv) # endif #endif #if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) # if defined(PERL_IN_PERL_C) STATIC void S_validate_suid(pTHX_ PerlIO *rsfp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VALIDATE_SUID \ assert(rsfp) # endif #endif #if !defined(SPRINTF_RETURNS_STRLEN) PERL_CALLCONV int Perl_my_sprintf(char *buffer, const char *pat, ...) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_MY_SPRINTF \ assert(buffer); assert(pat) #endif #if !defined(WIN32) PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_EXEC3 \ assert(incmd) #endif #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY)) PERL_CALLCONV char* Perl_my_bcopy(const char* from, char* to, I32 len) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_MY_BCOPY \ assert(from); assert(to) #endif #if defined(DEBUGGING) PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ assert(s) PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_ASSERT \ assert(hv) PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PAD_SETSV \ assert(sv) PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); # if defined(PERL_IN_PAD_C) STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CV_DUMP \ assert(cv); assert(title) # endif # if defined(PERL_IN_REGCOMP_C) STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_TRIE \ assert(trie); assert(revcharmap) STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ assert(trie); assert(revcharmap) STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ assert(trie); assert(revcharmap) STATIC const regnode* S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV* sv, I32 indent, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_6); #define PERL_ARGS_ASSERT_DUMPUNTIL \ assert(r); assert(start); assert(node); assert(sv) STATIC void S_put_byte(pTHX_ SV* sv, int c) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PUT_BYTE \ assert(sv) STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); STATIC U8 S_regtail_study(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ assert(pRExC_state); assert(p); assert(val) # endif # if defined(PERL_IN_REGEXEC_C) STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ assert(prog); assert(start); assert(end); assert(blurb) STATIC void S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry) # endif # if defined(PERL_IN_SV_C) STATIC void S_del_sv(pTHX_ SV *p) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DEL_SV \ assert(p) # endif # if defined(PERL_IN_TOKE_C) STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PRINTBUF \ assert(fmt); assert(s) STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOKEREPORT \ assert(lvalp) # endif #endif #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ assert(sv) #endif #if defined(DUMP_FDS) PERL_CALLCONV void Perl_dump_fds(pTHX_ char* s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_FDS \ assert(s) #endif #if defined(EBCDIC) PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ assert(s) PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ assert(d) #endif #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_IPCCTL \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_IPCGET \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV** mark, SV** sp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_MSGRCV \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV** mark, SV** sp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_MSGSND \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV** mark, SV** sp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_SEMOP \ assert(mark); assert(sp) PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_SHMIO \ assert(mark); assert(sp) #endif #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap); PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap); #endif #if defined(HAVE_INTERP_INTERN) PERL_CALLCONV void Perl_sys_intern_clear(pTHX); PERL_CALLCONV void Perl_sys_intern_init(pTHX); # if defined(USE_ITHREADS) PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ assert(src); assert(dst) # endif #endif #if defined(MYMALLOC) PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUMP_MSTATS \ assert(s) PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_MSTATS \ assert(buf) PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) __attribute__warn_unused_result__; PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MALLOCED_SIZE \ assert(p) #endif #if defined(MYSWAP) PERL_CALLCONV long Perl_my_htonl(pTHX_ long l) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV long Perl_my_ntohl(pTHX_ long l) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; PERL_CALLCONV short Perl_my_swap(pTHX_ short s) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__pure__; #endif #if defined(NO_MATHOMS) /* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */ #endif #if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); STATIC void S_strip_return(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_STRIP_RETURN \ assert(sv) # endif #endif #if defined(PERL_DEBUG_READONLY_OPS) # if defined(PERL_IN_OP_C) # if defined(PL_OP_SLAB_ALLOC) STATIC void S_Slab_to_rw(pTHX_ void *op) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SLAB_TO_RW \ assert(op) # endif # endif # if defined(PL_OP_SLAB_ALLOC) PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ assert(o) PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); PERL_CALLCONV void Perl_pending_Slabs_to_ro(pTHX); # endif #endif #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) /* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) __attribute__nonnull__(pTHX_1); */ #endif #if defined(PERL_DONT_CREATE_GVSV) /* PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); */ #endif #if defined(PERL_GLOBAL_STRUCT) PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX); PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \ assert(plvarsp) PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX); #endif #if defined(PERL_GLOBAL_STRUCT_PRIVATE) # if defined(PERL_IMPLICIT_CONTEXT) PERL_CALLCONV int Perl_my_cxt_index(pTHX_ const char *my_cxt_key) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_CXT_INDEX \ assert(my_cxt_key) PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MY_CXT_INIT \ assert(my_cxt_key) # endif #endif #if defined(PERL_IMPLICIT_CONTEXT) PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ assert(pat) PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) __attribute__format__null_ok__(__printf__,1,2); PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ assert(pat) PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ assert(stream); assert(format) PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ assert(name) PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ assert(pat) PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ assert(pat) PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ assert(format) PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ assert(sv); assert(pat) PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ assert(pat) PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) __attribute__format__(__printf__,2,3) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ assert(pat) #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4) __attribute__nonnull__(5) __attribute__nonnull__(6) __attribute__nonnull__(7) __attribute__nonnull__(8) __attribute__nonnull__(9); #define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) # if defined(USE_ITHREADS) PERL_CALLCONV PerlInterpreter* perl_clone_using(PerlInterpreter *proto_perl, UV flags, struct IPerlMem* ipM, struct IPerlMem* ipMS, struct IPerlMem* ipMP, struct IPerlEnv* ipE, struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO, struct IPerlDir* ipD, struct IPerlSock* ipS, struct IPerlProc* ipP) __attribute__nonnull__(1) __attribute__nonnull__(3) __attribute__nonnull__(4) __attribute__nonnull__(5) __attribute__nonnull__(6) __attribute__nonnull__(7) __attribute__nonnull__(8) __attribute__nonnull__(9) __attribute__nonnull__(10) __attribute__nonnull__(11); #define PERL_ARGS_ASSERT_PERL_CLONE_USING \ assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) # endif #endif #if defined(PERL_IN_AV_C) STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_AUX_MG \ assert(av) #endif #if defined(PERL_IN_DEB_C) STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DEB_STACK_N \ assert(stack_base) #endif #if defined(PERL_IN_DOIO_C) STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_EXEC_FAILED \ assert(cmd) STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) __attribute__warn_unused_result__; #endif #if defined(PERL_IN_DOOP_C) STATIC I32 S_do_trans_complex(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ assert(sv) STATIC I32 S_do_trans_complex_utf8(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \ assert(sv) STATIC I32 S_do_trans_count(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ assert(sv) STATIC I32 S_do_trans_count_utf8(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8 \ assert(sv) STATIC I32 S_do_trans_simple(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ assert(sv) STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8 \ assert(sv) #endif #if defined(PERL_IN_DQUOTE_STATIC_C) STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning) __attribute__warn_unused_result__; STATIC bool S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_GROK_BSLASH_O \ assert(s); assert(uv); assert(len); assert(error_msg) PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s) __attribute__warn_unused_result__ __attribute__pure__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGCURLY \ assert(s) #endif #if defined(PERL_IN_DUMP_C) STATIC CV* S_deb_curcv(pTHX_ const I32 ix); STATIC void S_debprof(pTHX_ const OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DEBPROF \ assert(o) STATIC SV* S_pm_description(pTHX_ const PMOP *pm) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ assert(pm) STATIC UV S_sequence_num(pTHX_ const OP *o); # if defined(PERL_MAD) STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...) __attribute__format__(__printf__,pTHX_3,pTHX_4) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_XMLDUMP_ATTR \ assert(file); assert(pat) # endif #endif #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ assert(hv) #endif #if defined(PERL_IN_GV_C) STATIC HV* S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_GET_SUPER_PKG \ assert(name) STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ assert(gv) STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) STATIC void S_gv_magicalize_overload(pTHX_ GV *gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_MAGICALIZE_OVERLOAD \ assert(gv) STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ assert(gv); assert(varpv); assert(namesv); assert(methpv) #endif #if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ assert(tsv); assert(sv) #endif #if defined(PERL_IN_HV_C) STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ assert(hv) STATIC void S_hfreeentries(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HFREEENTRIES \ assert(hv) STATIC void S_hsplit(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HSPLIT \ assert(hv) STATIC struct xpvhv_aux* S_hv_auxinit(HV *hv) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_HV_AUXINIT \ assert(hv) STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entryK) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ assert(hv) STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ assert(hv); assert(needs_copy); assert(needs_store) STATIC void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) __attribute__noreturn__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_HV_NOTALLOWED \ assert(key); assert(msg) STATIC HE* S_new_he(pTHX) __attribute__malloc__ __attribute__warn_unused_result__; STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ assert(he) STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ assert(str) STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ assert(str) STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); #endif #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ assert(sv) #endif #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ assert(hv); assert(indexp) #endif #if defined(PERL_IN_LOCALE_C) # if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE) STATIC char* S_stdize_locale(pTHX_ char* locs) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ assert(locs) # endif #endif #if defined(PERL_IN_MG_C) STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, int n, SV *val) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ assert(sv); assert(mg); assert(meth) STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ assert(sv); assert(mg); assert(meth) STATIC void S_restore_magic(pTHX_ const void *p); STATIC void S_save_magic(pTHX_ I32 mgs_ix, SV *sv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_MAGIC \ assert(sv) STATIC void S_unwind_handler_stack(pTHX_ const void *p); #endif #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) __attribute__nonnull__(pTHX_6) __attribute__nonnull__(pTHX_7); #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ assert(posp); assert(lenp) #endif #if defined(PERL_IN_MRO_C) STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ assert(isa); assert(name) STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ assert(stashes); assert(seen_stashes); assert(namesv) STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ assert(stash) #endif #if defined(PERL_IN_NUMERIC_C) STATIC NV S_mulexp10(NV value, I32 exponent); #endif #if defined(PERL_IN_OP_C) PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o); STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_APPLY_ATTRS \ assert(stash); assert(target) STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ assert(stash); assert(target); assert(imopsp) STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_BAD_TYPE_PV \ assert(t); assert(name); assert(kid) STATIC void S_bad_type_sv(pTHX_ I32 n, const char *t, SV *namesv, U32 flags, const OP *kid) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_BAD_TYPE_SV \ assert(t); assert(namesv); assert(kid) STATIC void S_cop_free(pTHX_ COP *cop) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_COP_FREE \ assert(cop) STATIC OP * S_dup_attrlist(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DUP_ATTRLIST \ assert(o) STATIC void S_finalize_op(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FINALIZE_OP \ assert(o) STATIC void S_find_and_forget_pmops(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ assert(o) STATIC OP* S_fold_constants(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) STATIC OP* S_force_list(pTHX_ OP* arg); STATIC OP* S_gen_constant_list(pTHX_ OP* o); STATIC SV* S_gv_ename(pTHX_ GV *gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GV_ENAME \ assert(gv) STATIC void S_inplace_aassign(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ assert(o) STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ assert(o) STATIC I32 S_is_list_assignment(pTHX_ const OP *o) __attribute__warn_unused_result__; STATIC OP* S_listkids(pTHX_ OP* o); STATIC bool S_looks_like_bool(pTHX_ const OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ assert(o) STATIC OP* S_modkids(pTHX_ OP *o, I32 type); STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MY_KID \ assert(imopsp) STATIC OP* S_newDEFSVOP(pTHX) __attribute__warn_unused_result__; STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ assert(block) STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_NEW_LOGOP \ assert(firstp); assert(otherp) STATIC void S_no_bareword_allowed(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ assert(o) STATIC OP* S_no_fh_allowed(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ assert(o) PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_INTEGERIZE \ assert(o) PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_STD_INIT \ assert(o) STATIC OP* S_opt_scalarhv(pTHX_ OP* rep_op) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OPT_SCALARHV \ assert(rep_op) STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_PMTRANS \ assert(o); assert(expr); assert(repl) STATIC void S_process_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ assert(fullname); assert(gv); assert(cv) STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); STATIC OP* S_refkids(pTHX_ OP* o, I32 type); STATIC bool S_scalar_mod_type(const OP *o, I32 type) __attribute__warn_unused_result__; STATIC OP* S_scalarboolean(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ assert(o) STATIC OP* S_scalarkids(pTHX_ OP* o); STATIC OP* S_scalarseq(pTHX_ OP* o); STATIC OP* S_search_const(pTHX_ OP *o) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SEARCH_CONST \ assert(o) STATIC void S_simplify_sort(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ assert(o) STATIC OP* S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ assert(o); assert(name) STATIC OP* S_too_few_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV \ assert(o); assert(namesv) STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ assert(o); assert(name) STATIC OP* S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \ assert(o); assert(namesv) # if defined(USE_ITHREADS) STATIC void S_forget_pmop(pTHX_ PMOP *const o, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) # endif #endif #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ assert(name); assert(old_cv) #endif #if defined(PERL_IN_PAD_C) STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ assert(namesv) STATIC void S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ assert(name) STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_8) __attribute__nonnull__(pTHX_9); #define PERL_ARGS_ASSERT_PAD_FINDLEX \ assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags) STATIC void S_pad_reset(pTHX); #endif #if defined(PERL_IN_PERL_C) STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_FIND_BEGINNING \ assert(linestr_sv); assert(rsfp) STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INCPUSH \ assert(dir) STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ assert(p) STATIC void S_init_ids(pTHX); STATIC void S_init_interp(pTHX); STATIC void S_init_main_stash(pTHX); STATIC void S_init_perllib(pTHX); STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ assert(argv) STATIC void S_init_predump_symbols(pTHX); STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MAYBERELOCATE \ assert(dir) STATIC void S_minus_v(pTHX) __attribute__noreturn__; STATIC void S_my_exit_jump(pTHX) __attribute__noreturn__; STATIC void S_nuke_stacks(pTHX); STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ assert(scriptname); assert(suidscript) STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); STATIC void S_run_body(pTHX_ I32 oldscope) __attribute__noreturn__; STATIC void S_usage(pTHX) __attribute__noreturn__; #endif #if defined(PERL_IN_PP_C) STATIC void S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_CHOMP \ assert(retval); assert(sv) STATIC OP* S_do_delete_local(pTHX); STATIC SV* S_refto(pTHX_ SV* sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REFTO \ assert(sv) #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SOFTREF2XV \ assert(sv); assert(what); assert(spp) #endif #if defined(PERL_IN_PP_CTL_C) STATIC SV ** S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_ADJUST_STACK_ON_LEAVE \ assert(newsp); assert(sp); assert(mark) STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ assert(name) STATIC void S_destroy_matcher(pTHX_ PMOP* matcher) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ assert(matcher) STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); STATIC OP* S_docatch(pTHX_ OP *o) __attribute__warn_unused_result__; STATIC bool S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq, HV* hh); STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_5) __attribute__nonnull__(pTHX_6); #define PERL_ARGS_ASSERT_DOFINDLABEL \ assert(o); assert(label); assert(opstack); assert(oplimit) STATIC MAGIC * S_doparseform(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOPARSEFORM \ assert(sv) STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) __attribute__warn_unused_result__; STATIC I32 S_dopoptogiven(pTHX_ I32 startingblock) __attribute__warn_unused_result__; STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOPOPTOLABEL \ assert(label) STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) __attribute__warn_unused_result__; STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ assert(cxstk) STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) __attribute__warn_unused_result__; STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MAKE_MATCHER \ assert(re) STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ assert(matcher); assert(sv) STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) __attribute__warn_unused_result__; STATIC bool S_path_is_absolute(const char *name) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PATH_IS_ABSOLUTE \ assert(name) STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_RUN_USER_FILTER \ assert(buf_sv) STATIC void S_rxres_free(pTHX_ void** rsp) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RXRES_FREE \ assert(rsp) STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_RXRES_RESTORE \ assert(rsp); assert(rx) STATIC void S_save_lines(pTHX_ AV *array, SV *sv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SAVE_LINES \ assert(sv) #endif #if defined(PERL_IN_PP_HOT_C) STATIC void S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_ODDBALL \ assert(hash); assert(relem); assert(firstrelem) STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_METHOD_COMMON \ assert(meth) #endif #if defined(PERL_IN_PP_PACK_C) STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_BYTES_TO_UNI \ assert(start); assert(dest) STATIC int S_div128(pTHX_ SV *pnum, bool *done) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DIV128 \ assert(pnum); assert(done) STATIC char S_first_symbol(const char *pat, const char *patend) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_FIRST_SYMBOL \ assert(pat); assert(patend) STATIC const char * S_get_num(pTHX_ const char *patptr, I32 *lenptr) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GET_NUM \ assert(patptr); assert(lenptr) STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GROUP_END \ assert(patptr); assert(patend) STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_IS_AN_INT \ assert(s) STATIC I32 S_measure_struct(pTHX_ struct tempsym* symptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MEASURE_STRUCT \ assert(symptr) STATIC SV* S_mul128(pTHX_ SV *sv, U8 m) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_MUL128 \ assert(sv) STATIC bool S_need_utf8(const char *pat, const char *patend) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_NEED_UTF8 \ assert(pat); assert(patend) STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEXT_SYMBOL \ assert(symptr) STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym* symptr, SV **beglist, SV **endlist) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_PACK_REC \ assert(cat); assert(symptr); assert(beglist); assert(endlist) STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_EXP_GROW \ assert(sv) STATIC I32 S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UNPACK_REC \ assert(symptr); assert(s); assert(strbeg); assert(strend) #endif #if defined(PERL_IN_PP_SORT_C) STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_CMP \ assert(str1); assert(str2) STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ assert(str1); assert(str2) STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ assert(a); assert(b) STATIC I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_AMAGIC_NCMP \ assert(a); assert(b) STATIC void S_qsortsvu(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t compare) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_QSORTSVU \ assert(compare) STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SORTCV \ assert(a); assert(b) STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SORTCV_STACKED \ assert(a); assert(b) STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SORTCV_XSUB \ assert(a); assert(b) STATIC I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_I_NCMP \ assert(a); assert(b) STATIC I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_NCMP \ assert(a); assert(b) #endif #if defined(PERL_IN_PP_SYS_C) STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DOFORM \ assert(cv); assert(gv); assert(retop) STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL \ assert(array) #endif #if defined(PERL_IN_REGCOMP_C) STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ assert(invlist) PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ assert(invlist) STATIC SV* S__new_invlist_C_array(pTHX_ UV* list) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ assert(list) STATIC void S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_ADD_ALTERNATE \ assert(alternate_ptr); assert(string) PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; STATIC U32 S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_ADD_DATA \ assert(pRExC_state); assert(s) STATIC void S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CHECKPOSIXCC \ assert(pRExC_state) STATIC void S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_CL_AND \ assert(cl); assert(and_with) STATIC void S_cl_anything(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_CL_ANYTHING \ assert(pRExC_state); assert(cl) STATIC void S_cl_init(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_CL_INIT \ assert(pRExC_state); assert(cl) STATIC int S_cl_is_anything(const struct regnode_charclass_class *cl) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_CL_IS_ANYTHING \ assert(cl) STATIC void S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_CL_OR \ assert(pRExC_state); assert(cl); assert(or_with) PERL_STATIC_INLINE UV* S_get_invlist_iter_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ assert(invlist) PERL_STATIC_INLINE UV* S_get_invlist_len_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_INVLIST_LEN_ADDR \ assert(invlist) PERL_STATIC_INLINE UV* S_get_invlist_version_id_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_INVLIST_VERSION_ID_ADDR \ assert(invlist) PERL_STATIC_INLINE UV* S_get_invlist_zero_addr(pTHX_ SV* invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GET_INVLIST_ZERO_ADDR \ assert(invlist) PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ assert(invlist) PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_CLONE \ assert(invlist) STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ assert(invlist) PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ assert(invlist) STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ assert(invlist); assert(start); assert(end) PERL_STATIC_INLINE UV S_invlist_len(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_LEN \ assert(invlist) PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_MAX \ assert(invlist) STATIC IV S_invlist_search(pTHX_ SV* const invlist, const UV cp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_SEARCH \ assert(invlist) PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ assert(invlist) PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INVLIST_TRIM \ assert(invlist) STATIC U32 S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *has_exactf_sharp_s, U32 flags, regnode *val, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_JOIN_EXACT \ assert(pRExC_state); assert(scan); assert(min_subtract); assert(has_exactf_sharp_s) STATIC I32 S_make_trie(pTHX_ struct RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_MAKE_TRIE \ assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) STATIC void S_make_trie_failtable(pTHX_ struct RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \ assert(pRExC_state); assert(source); assert(stclass) STATIC char * S_nextchar(pTHX_ struct RExC_state_t *pRExC_state) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEXTCHAR \ assert(pRExC_state) STATIC void S_rck_elide_nothing(pTHX_ regnode *node) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING \ assert(node) STATIC void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) __attribute__noreturn__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_RE_CROAK2 \ assert(pat1); assert(pat2) STATIC regnode* S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REG \ assert(pRExC_state); assert(flagp) STATIC regnode* S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp, U32 depth) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NAMEDSEQ \ assert(pRExC_state) STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_NODE \ assert(pRExC_state) STATIC UV S_reg_recode(pTHX_ const char value, SV **encp) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_RECODE \ assert(encp) STATIC SV * S_reg_scan_name(pTHX_ struct RExC_state_t *pRExC_state, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ assert(pRExC_state) STATIC bool S_reg_skipcomment(pTHX_ struct RExC_state_t *pRExC_state) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ assert(pRExC_state) STATIC regnode* S_reganode(pTHX_ struct RExC_state_t *pRExC_state, U8 op, U32 arg) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGANODE \ assert(pRExC_state) STATIC regnode* S_regatom(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGATOM \ assert(pRExC_state); assert(flagp) STATIC regnode* S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGBRANCH \ assert(pRExC_state); assert(flagp) STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, U32 depth) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGCLASS \ assert(pRExC_state) STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGINSERT \ assert(pRExC_state); assert(opnd) STATIC regnode* S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGPIECE \ assert(pRExC_state); assert(flagp) STATIC I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGPPOSIXCC \ assert(pRExC_state) STATIC void S_regtail(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGTAIL \ assert(pRExC_state); assert(p); assert(val) STATIC STRLEN S_reguni(pTHX_ const struct RExC_state_t *pRExC_state, UV uv, char *s) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGUNI \ assert(pRExC_state); assert(s) STATIC char * S_regwhite(struct RExC_state_t *pRExC_state, char *p) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_REGWHITE \ assert(pRExC_state); assert(p) STATIC void S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct scan_data_t *data, I32 *minlenp, int is_inf) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_COMMIT \ assert(pRExC_state); assert(data); assert(minlenp) PERL_STATIC_INLINE U8 S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_SET_REGCLASS_BIT \ assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr) STATIC U8 S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \ assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr) STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth, bool was_mutate_ok) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_STUDY_CHUNK \ assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, bool return_if_undef, SV* invlist, bool passed_in_invlist_has_user_defined_property) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__CORE_SWASH_INIT \ assert(pkg); assert(name); assert(listsv) PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ assert(invlist) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end) __attribute__warn_unused_result__; /* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, bool complement_b, SV** i) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(i) PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__INVLIST_INVERT \ assert(invlist) PERL_CALLCONV void Perl__invlist_invert_prop(pTHX_ SV* const invlist) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__INVLIST_INVERT_PROP \ assert(invlist) PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \ assert(invlist); assert(swatch) /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); */ PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, bool complement_b, SV** output) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(output) PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) __attribute__warn_unused_result__; PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ assert(swash) PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__SWASH_TO_INVLIST \ assert(swash) #endif #if defined(PERL_IN_REGEXEC_C) STATIC SV* S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \ assert(node) STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_FIND_BYCLASS \ assert(prog); assert(c); assert(s); assert(strend) STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ assert(rex); assert(scan) STATIC char* S_regcppop(pTHX_ const regexp *rex) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_REGCPPOP \ assert(rex) STATIC CHECKPOINT S_regcppush(pTHX_ I32 parenfloor); STATIC U8* S_reghop3(U8 *s, I32 off, const U8 *lim) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_REGHOP3 \ assert(s); assert(lim) STATIC U8* S_reghopmaybe3(U8 *s, I32 off, const U8 *lim) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ assert(s); assert(lim) STATIC bool S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, STRLEN *lenp, bool const do_utf8sv_is_utf8) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_REGINCLASS \ assert(n); assert(p) STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGMATCH \ assert(reginfo); assert(prog) STATIC I32 S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGREPEAT \ assert(prog); assert(p) STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startpos) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGTRY \ assert(reginfo); assert(startpos) STATIC void S_to_byte_substr(pTHX_ regexp * prog) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ assert(prog) STATIC void S_to_utf8_substr(pTHX_ regexp * prog) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ assert(prog) # if defined(XXX_dmq) STATIC U8* S_reghop4(U8 *s, I32 off, const U8 *llim, const U8 *rlim) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(3) __attribute__nonnull__(4); #define PERL_ARGS_ASSERT_REGHOP4 \ assert(s); assert(llim); assert(rlim) # endif #endif #if defined(PERL_IN_SCOPE_C) STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ assert(sptr) #endif #if defined(PERL_IN_SV_C) STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len) __attribute__nonnull__(2) __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_F0CONVERT \ assert(endbuf); assert(len) STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ assert(gv); assert(cv) STATIC void S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN from_cache, STRLEN real, SV *const sv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ assert(func); assert(sv) STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CURSE \ assert(sv) STATIC I32 S_expect_number(pTHX_ char **const pattern) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ assert(pattern) STATIC I32 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ assert(val) STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ assert(val) STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top); STATIC bool S_glob_2number(pTHX_ GV* const gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GLOB_2NUMBER \ assert(gv) STATIC void S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ assert(dstr); assert(sstr) STATIC void S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \ assert(dstr); assert(sstr) STATIC SV * S_more_sv(pTHX); STATIC void S_not_a_number(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ assert(sv) STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ assert(tbl) STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ assert(sv) STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ assert(ptr) STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ assert(s); assert(target); assert(end) STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV *const sv, MAGIC **const mgp, const U8 *const start, const U8 *const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ assert(sv); assert(mgp); assert(start); assert(send) STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STRLEN *const uoffset, bool *const at_end) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__nonnull__(3) __attribute__nonnull__(4); #define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ assert(start); assert(send); assert(uoffset); assert(at_end) STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, const STRLEN uend) __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ assert(start); assert(send) PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_UNGLOB \ assert(sv) STATIC char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(5); #define PERL_ARGS_ASSERT_UIV_2BUF \ assert(buf); assert(peob) STATIC void S_utf8_mg_len_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN ulen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ assert(sv); assert(mgp) STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ assert(sv); assert(mgp) STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_VISIT \ assert(f) # if defined(PERL_OLD_COPY_ON_WRITE) STATIC void S_sv_release_COW(pTHX_ SV *sv, const char *pvx, SV *after) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SV_RELEASE_COW \ assert(sv); assert(pvx); assert(after) # endif # if defined(USE_ITHREADS) STATIC SV* S_sv_dup_common(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DUP_COMMON \ assert(sstr); assert(param) STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ assert(source); assert(dest); assert(param) STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ assert(unreferenced) # endif #endif #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) PERL_CALLCONV SV * Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, I32 aindex, int subscript_type) __attribute__warn_unused_result__; #endif #if defined(PERL_IN_TOKE_C) STATIC int S_ao(pTHX_ int toketype); STATIC void S_check_uni(pTHX); STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_CHECKCOMMA \ assert(s); assert(name); assert(what) STATIC int S_deprecate_commaless_var_list(pTHX); STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FILTER_GETS \ assert(sv) STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ assert(pkgname) STATIC void S_force_ident(pTHX_ const char *s, int kind) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORCE_IDENT \ assert(s) STATIC void S_force_next(pTHX_ I32 type); STATIC char* S_force_strict_version(pTHX_ char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ assert(s) STATIC char* S_force_version(pTHX_ char *s, int guessing) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORCE_VERSION \ assert(s) STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_tick) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORCE_WORD \ assert(start) STATIC void S_incline(pTHX_ const char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INCLINE \ assert(s) STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INTUIT_METHOD \ assert(s) STATIC int S_intuit_more(pTHX_ char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INTUIT_MORE \ assert(s) STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_LOP \ assert(s) STATIC void S_missingterm(pTHX_ char *s) __attribute__noreturn__; STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_NEW_CONSTANT \ assert(key); assert(sv) STATIC void S_no_op(pTHX_ const char *const what, char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NO_OP \ assert(what) STATIC void S_readpipe_override(pTHX); STATIC char* S_scan_const(pTHX_ char *start) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_CONST \ assert(start) STATIC char* S_scan_formline(pTHX_ char *s) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_FORMLINE \ assert(s) STATIC char* S_scan_heredoc(pTHX_ char *s) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_HEREDOC \ assert(s) STATIC char* S_scan_ident(pTHX_ char *s, const char *send, char *dest, STRLEN destlen, I32 ck_uni) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_SCAN_IDENT \ assert(s); assert(send); assert(dest) STATIC char* S_scan_inputsymbol(pTHX_ char *start) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ assert(start) STATIC char* S_scan_pat(pTHX_ char *start, I32 type) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_PAT \ assert(start) STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_STR \ assert(start) STATIC char* S_scan_subst(pTHX_ char *start) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_SUBST \ assert(start) STATIC char* S_scan_trans(pTHX_ char *start) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_TRANS \ assert(start) STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_5); #define PERL_ARGS_ASSERT_SCAN_WORD \ assert(s); assert(dest); assert(slp) STATIC char* S_skipspace(pTHX_ char *s) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SKIPSPACE \ assert(s) STATIC I32 S_sublex_done(pTHX) __attribute__warn_unused_result__; STATIC I32 S_sublex_push(pTHX) __attribute__warn_unused_result__; STATIC I32 S_sublex_start(pTHX) __attribute__warn_unused_result__; STATIC char* S_swallow_bom(pTHX_ U8 *s) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SWALLOW_BOM \ assert(s) STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_TOKENIZE_USE \ assert(s) STATIC SV* S_tokeq(pTHX_ SV *sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TOKEQ \ assert(sv) STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); STATIC int S_yywarn(pTHX_ const char *const s, U32 flags) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_YYWARN \ assert(s) # if defined(PERL_MAD) STATIC void S_curmad(pTHX_ char slot, SV *sv); STATIC char* S_skipspace0(pTHX_ char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SKIPSPACE0 \ assert(s) STATIC char* S_skipspace1(pTHX_ char *s) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SKIPSPACE1 \ assert(s) STATIC char* S_skipspace2(pTHX_ char *s, SV **sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SKIPSPACE2 \ assert(s) STATIC void S_start_force(pTHX_ int where); # endif #endif #if defined(PERL_IN_UNIVERSAL_C) STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_ISA_LOOKUP \ assert(stash); assert(name) #endif #if defined(PERL_IN_UTF8_C) STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ assert(p); assert(ustrp); assert(lenp) STATIC STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) __attribute__warn_unused_result__ __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ assert(s) STATIC bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ assert(p); assert(swash); assert(swashname) STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SWATCH_GET \ assert(swash) STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp) __attribute__warn_unused_result__; #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) PERL_CALLCONV bool Perl__is_utf8_quotemeta(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT__IS_UTF8_QUOTEMETA \ assert(p) PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ assert(p); assert(lenp) #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const bool flags) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ assert(p); assert(lenp) #endif #if defined(PERL_IN_UTIL_C) STATIC bool S_ckwarn_common(pTHX_ U32 w); STATIC const COP* S_closest_cop(pTHX_ const COP *cop, const OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CLOSEST_COP \ assert(cop) STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn); STATIC SV* S_mess_alloc(pTHX); STATIC SV * S_with_queued_errors(pTHX_ SV *ex) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ assert(ex) STATIC char * S_write_no_mem(pTHX) __attribute__noreturn__; # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) __attribute__nonnull__(4) __attribute__nonnull__(8) __attribute__nonnull__(10); #define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ assert(type_name); assert(filename); assert(funcname) # endif #endif #if defined(PERL_MAD) PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot); PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot); PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \ assert(file) PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \ assert(file) PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp); PERL_CALLCONV int Perl_madlex(pTHX); PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype); PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen); PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_NEWMADSV \ assert(sv) PERL_CALLCONV OP * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) __attribute__noreturn__; PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_OP_XMLDUMP \ assert(o) PERL_CALLCONV OP* Perl_package(pTHX_ OP* o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PACKAGE \ assert(o) PERL_CALLCONV void Perl_pad_peg(const char* s) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PAD_PEG \ assert(s) PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm); PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot); PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATXMLPV \ assert(dsv); assert(pv) PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATXMLPVN \ assert(dsv); assert(pv) PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_CATXMLSV \ assert(dsv); assert(ssv) PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SV_XMLPEEK \ assert(sv) PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TOKEN_FREE \ assert(tk) PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_TOKEN_GETMAD \ assert(tk) PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) PERL_CALLCONV void Perl_xmldump_all(pTHX); PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl); PERL_CALLCONV void Perl_xmldump_eval(pTHX); PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_XMLDUMP_FORM \ assert(gv) PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) __attribute__format__(__printf__,pTHX_3,pTHX_4) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_XMLDUMP_INDENT \ assert(file); assert(pat) PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \ assert(stash) PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \ assert(stash) PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_XMLDUMP_SUB \ assert(gv) PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \ assert(gv) PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \ assert(file); assert(pat) #endif #if defined(PERL_NEED_MY_BETOH16) PERL_CALLCONV U16 Perl_my_betoh16(U16 n); #endif #if defined(PERL_NEED_MY_BETOH32) PERL_CALLCONV U32 Perl_my_betoh32(U32 n); #endif #if defined(PERL_NEED_MY_BETOH64) PERL_CALLCONV U64 Perl_my_betoh64(U64 n); #endif #if defined(PERL_NEED_MY_BETOHI) PERL_CALLCONV int Perl_my_betohi(int n); #endif #if defined(PERL_NEED_MY_BETOHL) PERL_CALLCONV long Perl_my_betohl(long n); #endif #if defined(PERL_NEED_MY_BETOHS) PERL_CALLCONV short Perl_my_betohs(short n); #endif #if defined(PERL_NEED_MY_HTOBE16) PERL_CALLCONV U16 Perl_my_htobe16(U16 n); #endif #if defined(PERL_NEED_MY_HTOBE32) PERL_CALLCONV U32 Perl_my_htobe32(U32 n); #endif #if defined(PERL_NEED_MY_HTOBE64) PERL_CALLCONV U64 Perl_my_htobe64(U64 n); #endif #if defined(PERL_NEED_MY_HTOBEI) PERL_CALLCONV int Perl_my_htobei(int n); #endif #if defined(PERL_NEED_MY_HTOBEL) PERL_CALLCONV long Perl_my_htobel(long n); #endif #if defined(PERL_NEED_MY_HTOBES) PERL_CALLCONV short Perl_my_htobes(short n); #endif #if defined(PERL_NEED_MY_HTOLE16) PERL_CALLCONV U16 Perl_my_htole16(U16 n); #endif #if defined(PERL_NEED_MY_HTOLE32) PERL_CALLCONV U32 Perl_my_htole32(U32 n); #endif #if defined(PERL_NEED_MY_HTOLE64) PERL_CALLCONV U64 Perl_my_htole64(U64 n); #endif #if defined(PERL_NEED_MY_HTOLEI) PERL_CALLCONV int Perl_my_htolei(int n); #endif #if defined(PERL_NEED_MY_HTOLEL) PERL_CALLCONV long Perl_my_htolel(long n); #endif #if defined(PERL_NEED_MY_HTOLES) PERL_CALLCONV short Perl_my_htoles(short n); #endif #if defined(PERL_NEED_MY_LETOH16) PERL_CALLCONV U16 Perl_my_letoh16(U16 n); #endif #if defined(PERL_NEED_MY_LETOH32) PERL_CALLCONV U32 Perl_my_letoh32(U32 n); #endif #if defined(PERL_NEED_MY_LETOH64) PERL_CALLCONV U64 Perl_my_letoh64(U64 n); #endif #if defined(PERL_NEED_MY_LETOHI) PERL_CALLCONV int Perl_my_letohi(int n); #endif #if defined(PERL_NEED_MY_LETOHL) PERL_CALLCONV long Perl_my_letohl(long n); #endif #if defined(PERL_NEED_MY_LETOHS) PERL_CALLCONV short Perl_my_letohs(short n); #endif #if defined(PERL_OLD_COPY_ON_WRITE) PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_SETSV_COW \ assert(sstr) #endif #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) STATIC void S_pidgone(pTHX_ Pid_t pid, int status); #endif #if defined(PL_OP_SLAB_ALLOC) PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) #endif #if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_UNLNK \ assert(f) #endif #if defined(USE_ITHREADS) PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_ANY_DUP \ assert(proto_perl) PERL_CALLCONV void Perl_clone_params_del(CLONE_PARAMS *param) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ assert(param) PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter *const from, PerlInterpreter *const to) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(1) __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ assert(from); assert(to) PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_CX_DUP \ assert(param) PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_DIRP_DUP \ assert(param) PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_FP_DUP \ assert(param) PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_GP_DUP \ assert(param) PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_HE_DUP \ assert(param) PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_HEK_DUP \ assert(param) PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MG_DUP \ assert(param) PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MRO_META_DUP \ assert(smeta); assert(param) PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_NEWPADOP \ assert(sv) PERL_CALLCONV AV* Perl_padlist_dup(pTHX_ AV *srcpad, CLONE_PARAMS *param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PADLIST_DUP \ assert(param) PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PARSER_DUP \ assert(param) PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_PERL_CLONE \ assert(proto_perl) PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS* param) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_RE_DUP_GUTS \ assert(sstr); assert(dstr); assert(param) PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ assert(r); assert(param) PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_RVPV_DUP \ assert(dstr); assert(sstr); assert(param) PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SI_DUP \ assert(param) PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param) __attribute__malloc__ __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SS_DUP \ assert(proto_perl); assert(param) PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DUP \ assert(param) PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_DUP_INC \ assert(param) #endif #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ assert(sv); assert(mg) PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ assert(s); assert(xlen) /* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); */ PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ assert(sv); assert(nxp) #endif #if defined(USE_PERLIO) && !defined(USE_SFIO) PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); PERL_CALLCONV int Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) __attribute__warn_unused_result__; PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PERLIO_READ \ assert(vbuf) PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt); PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, int cnt); PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ assert(vbuf) PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PERLIO_WRITE \ assert(vbuf) #endif #if defined(USE_REENTRANT_API) PERL_CALLCONV void Perl_reentrant_free(pTHX); PERL_CALLCONV void Perl_reentrant_init(pTHX); PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...) __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ assert(f) PERL_CALLCONV void Perl_reentrant_size(pTHX); #endif #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); #define PERL_ARGS_ASSERT_DO_ASPAWN \ assert(mark); assert(sp) PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_SPAWN \ assert(cmd) PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ assert(cmd) #endif #ifdef PERL_CORE # include "pp_proto.h" #endif END_EXTERN_C /* ex: set ro: */ PKZÁ:͸͸opcode.hnuW+A/* -*- buffer-read-only: t -*- * * opcode.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/opcode.pl from its data. * Any changes made here will be lost! */ #ifndef PERL_GLOBAL_STRUCT_INIT #define Perl_pp_scalar Perl_pp_null #define Perl_pp_padany Perl_unimplemented_op #define Perl_pp_regcmaybe Perl_pp_null #define Perl_pp_transr Perl_pp_trans #define Perl_pp_chomp Perl_pp_chop #define Perl_pp_schomp Perl_pp_schop #define Perl_pp_i_preinc Perl_pp_preinc #define Perl_pp_predec Perl_pp_preinc #define Perl_pp_i_predec Perl_pp_preinc #define Perl_pp_i_postinc Perl_pp_postinc #define Perl_pp_postdec Perl_pp_postinc #define Perl_pp_i_postdec Perl_pp_postinc #define Perl_pp_slt Perl_pp_sle #define Perl_pp_sgt Perl_pp_sle #define Perl_pp_sge Perl_pp_sle #define Perl_pp_bit_xor Perl_pp_bit_or #define Perl_pp_cos Perl_pp_sin #define Perl_pp_exp Perl_pp_sin #define Perl_pp_log Perl_pp_sin #define Perl_pp_sqrt Perl_pp_sin #define Perl_pp_hex Perl_pp_oct #define Perl_pp_rindex Perl_pp_index #define Perl_pp_lcfirst Perl_pp_ucfirst #define Perl_pp_aelemfast_lex Perl_pp_aelemfast #define Perl_pp_avalues Perl_pp_akeys #define Perl_pp_values Perl_do_kv #define Perl_pp_keys Perl_do_kv #define Perl_pp_rv2hv Perl_pp_rv2av #define Perl_pp_pop Perl_pp_shift #define Perl_pp_mapstart Perl_unimplemented_op #define Perl_pp_dor Perl_pp_defined #define Perl_pp_andassign Perl_pp_and #define Perl_pp_orassign Perl_pp_or #define Perl_pp_dorassign Perl_pp_defined #define Perl_pp_lineseq Perl_pp_null #define Perl_pp_scope Perl_pp_null #define Perl_pp_dump Perl_pp_goto #define Perl_pp_dbmclose Perl_pp_untie #define Perl_pp_read Perl_pp_sysread #define Perl_pp_say Perl_pp_print #define Perl_pp_seek Perl_pp_sysseek #define Perl_pp_fcntl Perl_pp_ioctl #ifdef HAS_SOCKET #define Perl_pp_send Perl_pp_syswrite #define Perl_pp_recv Perl_pp_sysread #else #define Perl_pp_send Perl_unimplemented_op #define Perl_pp_recv Perl_unimplemented_op #define Perl_pp_socket Perl_unimplemented_op #endif #ifdef HAS_SOCKET #define Perl_pp_connect Perl_pp_bind #define Perl_pp_gsockopt Perl_pp_ssockopt #define Perl_pp_getsockname Perl_pp_getpeername #else #define Perl_pp_bind Perl_unimplemented_op #define Perl_pp_connect Perl_unimplemented_op #define Perl_pp_listen Perl_unimplemented_op #define Perl_pp_accept Perl_unimplemented_op #define Perl_pp_shutdown Perl_unimplemented_op #define Perl_pp_gsockopt Perl_unimplemented_op #define Perl_pp_ssockopt Perl_unimplemented_op #define Perl_pp_getsockname Perl_unimplemented_op #define Perl_pp_getpeername Perl_unimplemented_op #endif #define Perl_pp_lstat Perl_pp_stat #define Perl_pp_ftrwrite Perl_pp_ftrread #define Perl_pp_ftrexec Perl_pp_ftrread #define Perl_pp_fteread Perl_pp_ftrread #define Perl_pp_ftewrite Perl_pp_ftrread #define Perl_pp_fteexec Perl_pp_ftrread #define Perl_pp_ftsize Perl_pp_ftis #define Perl_pp_ftmtime Perl_pp_ftis #define Perl_pp_ftatime Perl_pp_ftis #define Perl_pp_ftctime Perl_pp_ftis #define Perl_pp_fteowned Perl_pp_ftrowned #define Perl_pp_ftzero Perl_pp_ftrowned #define Perl_pp_ftsock Perl_pp_ftrowned #define Perl_pp_ftchr Perl_pp_ftrowned #define Perl_pp_ftblk Perl_pp_ftrowned #define Perl_pp_ftfile Perl_pp_ftrowned #define Perl_pp_ftdir Perl_pp_ftrowned #define Perl_pp_ftpipe Perl_pp_ftrowned #define Perl_pp_ftsuid Perl_pp_ftrowned #define Perl_pp_ftsgid Perl_pp_ftrowned #define Perl_pp_ftsvtx Perl_pp_ftrowned #define Perl_pp_ftbinary Perl_pp_fttext #define Perl_pp_unlink Perl_pp_chown #define Perl_pp_chmod Perl_pp_chown #define Perl_pp_utime Perl_pp_chown #define Perl_pp_symlink Perl_pp_link #define Perl_pp_kill Perl_pp_chown #define Perl_pp_localtime Perl_pp_gmtime #define Perl_pp_shmget Perl_pp_semget #define Perl_pp_shmctl Perl_pp_semctl #define Perl_pp_shmread Perl_pp_shmwrite #define Perl_pp_msgget Perl_pp_semget #define Perl_pp_msgctl Perl_pp_semctl #define Perl_pp_msgsnd Perl_pp_shmwrite #define Perl_pp_msgrcv Perl_pp_shmwrite #define Perl_pp_semop Perl_pp_shmwrite #define Perl_pp_dofile Perl_pp_require #define Perl_pp_ghbyname Perl_pp_ghostent #define Perl_pp_ghbyaddr Perl_pp_ghostent #define Perl_pp_gnbyname Perl_pp_gnetent #define Perl_pp_gnbyaddr Perl_pp_gnetent #define Perl_pp_gpbyname Perl_pp_gprotoent #define Perl_pp_gpbynumber Perl_pp_gprotoent #define Perl_pp_gsbyname Perl_pp_gservent #define Perl_pp_gsbyport Perl_pp_gservent #define Perl_pp_snetent Perl_pp_shostent #define Perl_pp_sprotoent Perl_pp_shostent #define Perl_pp_sservent Perl_pp_shostent #define Perl_pp_enetent Perl_pp_ehostent #define Perl_pp_eprotoent Perl_pp_ehostent #define Perl_pp_eservent Perl_pp_ehostent #define Perl_pp_gpwnam Perl_pp_gpwent #define Perl_pp_gpwuid Perl_pp_gpwent #define Perl_pp_spwent Perl_pp_ehostent #define Perl_pp_epwent Perl_pp_ehostent #define Perl_pp_ggrnam Perl_pp_ggrent #define Perl_pp_ggrgid Perl_pp_ggrent #define Perl_pp_sgrent Perl_pp_ehostent #define Perl_pp_egrent Perl_pp_ehostent #define Perl_pp_custom Perl_unimplemented_op #define Perl_pp_reach Perl_pp_rkeys #define Perl_pp_rvalues Perl_pp_rkeys START_EXTERN_C #ifndef DOINIT EXTCONST char* const PL_op_name[]; #else EXTCONST char* const PL_op_name[] = { "null", "stub", "scalar", "pushmark", "wantarray", "const", "gvsv", "gv", "gelem", "padsv", "padav", "padhv", "padany", "pushre", "rv2gv", "rv2sv", "av2arylen", "rv2cv", "anoncode", "prototype", "refgen", "srefgen", "ref", "bless", "backtick", "glob", "readline", "rcatline", "regcmaybe", "regcreset", "regcomp", "match", "qr", "subst", "substcont", "trans", "transr", "sassign", "aassign", "chop", "schop", "chomp", "schomp", "defined", "undef", "study", "pos", "preinc", "i_preinc", "predec", "i_predec", "postinc", "i_postinc", "postdec", "i_postdec", "pow", "multiply", "i_multiply", "divide", "i_divide", "modulo", "i_modulo", "repeat", "add", "i_add", "subtract", "i_subtract", "concat", "stringify", "left_shift", "right_shift", "lt", "i_lt", "gt", "i_gt", "le", "i_le", "ge", "i_ge", "eq", "i_eq", "ne", "i_ne", "ncmp", "i_ncmp", "slt", "sgt", "sle", "sge", "seq", "sne", "scmp", "bit_and", "bit_xor", "bit_or", "negate", "i_negate", "not", "complement", "smartmatch", "atan2", "sin", "cos", "rand", "srand", "exp", "log", "sqrt", "int", "hex", "oct", "abs", "length", "substr", "vec", "index", "rindex", "sprintf", "formline", "ord", "chr", "crypt", "ucfirst", "lcfirst", "uc", "lc", "quotemeta", "rv2av", "aelemfast", "aelemfast_lex", "aelem", "aslice", "aeach", "akeys", "avalues", "each", "values", "keys", "delete", "exists", "rv2hv", "helem", "hslice", "boolkeys", "unpack", "pack", "split", "join", "list", "lslice", "anonlist", "anonhash", "splice", "push", "pop", "shift", "unshift", "sort", "reverse", "grepstart", "grepwhile", "mapstart", "mapwhile", "range", "flip", "flop", "and", "or", "xor", "dor", "cond_expr", "andassign", "orassign", "dorassign", "method", "entersub", "leavesub", "leavesublv", "caller", "warn", "die", "reset", "lineseq", "nextstate", "dbstate", "unstack", "enter", "leave", "scope", "enteriter", "iter", "enterloop", "leaveloop", "return", "last", "next", "redo", "dump", "goto", "exit", "method_named", "entergiven", "leavegiven", "enterwhen", "leavewhen", "break", "continue", "open", "close", "pipe_op", "fileno", "umask", "binmode", "tie", "untie", "tied", "dbmopen", "dbmclose", "sselect", "select", "getc", "read", "enterwrite", "leavewrite", "prtf", "print", "say", "sysopen", "sysseek", "sysread", "syswrite", "eof", "tell", "seek", "truncate", "fcntl", "ioctl", "flock", "send", "recv", "socket", "sockpair", "bind", "connect", "listen", "accept", "shutdown", "gsockopt", "ssockopt", "getsockname", "getpeername", "lstat", "stat", "ftrread", "ftrwrite", "ftrexec", "fteread", "ftewrite", "fteexec", "ftis", "ftsize", "ftmtime", "ftatime", "ftctime", "ftrowned", "fteowned", "ftzero", "ftsock", "ftchr", "ftblk", "ftfile", "ftdir", "ftpipe", "ftsuid", "ftsgid", "ftsvtx", "ftlink", "fttty", "fttext", "ftbinary", "chdir", "chown", "chroot", "unlink", "chmod", "utime", "rename", "link", "symlink", "readlink", "mkdir", "rmdir", "open_dir", "readdir", "telldir", "seekdir", "rewinddir", "closedir", "fork", "wait", "waitpid", "system", "exec", "kill", "getppid", "getpgrp", "setpgrp", "getpriority", "setpriority", "time", "tms", "localtime", "gmtime", "alarm", "sleep", "shmget", "shmctl", "shmread", "shmwrite", "msgget", "msgctl", "msgsnd", "msgrcv", "semop", "semget", "semctl", "require", "dofile", "hintseval", "entereval", "leaveeval", "entertry", "leavetry", "ghbyname", "ghbyaddr", "ghostent", "gnbyname", "gnbyaddr", "gnetent", "gpbyname", "gpbynumber", "gprotoent", "gsbyname", "gsbyport", "gservent", "shostent", "snetent", "sprotoent", "sservent", "ehostent", "enetent", "eprotoent", "eservent", "gpwnam", "gpwuid", "gpwent", "spwent", "epwent", "ggrnam", "ggrgid", "ggrent", "sgrent", "egrent", "getlogin", "syscall", "lock", "once", "custom", "reach", "rkeys", "rvalues", "coreargs", "runcv", "fc", }; #endif #ifndef DOINIT EXTCONST char* const PL_op_desc[]; #else EXTCONST char* const PL_op_desc[] = { "null operation", "stub", "scalar", "pushmark", "wantarray", "constant item", "scalar variable", "glob value", "glob elem", "private variable", "private array", "private hash", "private value", "push regexp", "ref-to-glob cast", "scalar dereference", "array length", "subroutine dereference", "anonymous subroutine", "subroutine prototype", "reference constructor", "single ref constructor", "reference-type operator", "bless", "quoted execution (``, qx)", "glob", "", "append I/O operator", "regexp internal guard", "regexp internal reset", "regexp compilation", "pattern match (m//)", "pattern quote (qr//)", "substitution (s///)", "substitution iterator", "transliteration (tr///)", "transliteration (tr///)", "scalar assignment", "list assignment", "chop", "scalar chop", "chomp", "scalar chomp", "defined operator", "undef operator", "study", "match position", "preincrement (++)", "integer preincrement (++)", "predecrement (--)", "integer predecrement (--)", "postincrement (++)", "integer postincrement (++)", "postdecrement (--)", "integer postdecrement (--)", "exponentiation (**)", "multiplication (*)", "integer multiplication (*)", "division (/)", "integer division (/)", "modulus (%)", "integer modulus (%)", "repeat (x)", "addition (+)", "integer addition (+)", "subtraction (-)", "integer subtraction (-)", "concatenation (.) or string", "string", "left bitshift (<<)", "right bitshift (>>)", "numeric lt (<)", "integer lt (<)", "numeric gt (>)", "integer gt (>)", "numeric le (<=)", "integer le (<=)", "numeric ge (>=)", "integer ge (>=)", "numeric eq (==)", "integer eq (==)", "numeric ne (!=)", "integer ne (!=)", "numeric comparison (<=>)", "integer comparison (<=>)", "string lt", "string gt", "string le", "string ge", "string eq", "string ne", "string comparison (cmp)", "bitwise and (&)", "bitwise xor (^)", "bitwise or (|)", "negation (-)", "integer negation (-)", "not", "1's complement (~)", "smart match", "atan2", "sin", "cos", "rand", "srand", "exp", "log", "sqrt", "int", "hex", "oct", "abs", "length", "substr", "vec", "index", "rindex", "sprintf", "formline", "ord", "chr", "crypt", "ucfirst", "lcfirst", "uc", "lc", "quotemeta", "array dereference", "constant array element", "constant lexical array element", "array element", "array slice", "each on array", "keys on array", "values on array", "each", "values", "keys", "delete", "exists", "hash dereference", "hash element", "hash slice", "boolkeys", "unpack", "pack", "split", "join or string", "list", "list slice", "anonymous list ([])", "anonymous hash ({})", "splice", "push", "pop", "shift", "unshift", "sort", "reverse", "grep", "grep iterator", "map", "map iterator", "flipflop", "range (or flip)", "range (or flop)", "logical and (&&)", "logical or (||)", "logical xor", "defined or (//)", "conditional expression", "logical and assignment (&&=)", "logical or assignment (||=)", "defined or assignment (//=)", "method lookup", "subroutine entry", "subroutine exit", "lvalue subroutine return", "caller", "warn", "die", "symbol reset", "line sequence", "next statement", "debug next statement", "iteration finalizer", "block entry", "block exit", "block", "foreach loop entry", "foreach loop iterator", "loop entry", "loop exit", "return", "last", "next", "redo", "dump", "goto", "exit", "method with known name", "given()", "leave given block", "when()", "leave when block", "break", "continue", "open", "close", "pipe", "fileno", "umask", "binmode", "tie", "untie", "tied", "dbmopen", "dbmclose", "select system call", "select", "getc", "read", "write", "write exit", "printf", "print", "say", "sysopen", "sysseek", "sysread", "syswrite", "eof", "tell", "seek", "truncate", "fcntl", "ioctl", "flock", "send", "recv", "socket", "socketpair", "bind", "connect", "listen", "accept", "shutdown", "getsockopt", "setsockopt", "getsockname", "getpeername", "lstat", "stat", "-R", "-W", "-X", "-r", "-w", "-x", "-e", "-s", "-M", "-A", "-C", "-O", "-o", "-z", "-S", "-c", "-b", "-f", "-d", "-p", "-u", "-g", "-k", "-l", "-t", "-T", "-B", "chdir", "chown", "chroot", "unlink", "chmod", "utime", "rename", "link", "symlink", "readlink", "mkdir", "rmdir", "opendir", "readdir", "telldir", "seekdir", "rewinddir", "closedir", "fork", "wait", "waitpid", "system", "exec", "kill", "getppid", "getpgrp", "setpgrp", "getpriority", "setpriority", "time", "times", "localtime", "gmtime", "alarm", "sleep", "shmget", "shmctl", "shmread", "shmwrite", "msgget", "msgctl", "msgsnd", "msgrcv", "semop", "semget", "semctl", "require", "do \"file\"", "eval hints", "eval \"string\"", "eval \"string\" exit", "eval {block}", "eval {block} exit", "gethostbyname", "gethostbyaddr", "gethostent", "getnetbyname", "getnetbyaddr", "getnetent", "getprotobyname", "getprotobynumber", "getprotoent", "getservbyname", "getservbyport", "getservent", "sethostent", "setnetent", "setprotoent", "setservent", "endhostent", "endnetent", "endprotoent", "endservent", "getpwnam", "getpwuid", "getpwent", "setpwent", "endpwent", "getgrnam", "getgrgid", "getgrent", "setgrent", "endgrent", "getlogin", "syscall", "lock", "once", "unknown custom operator", "each on reference", "keys on reference", "values on reference", "CORE:: subroutine", "__SUB__", "fc", }; #endif END_EXTERN_C #endif /* !PERL_GLOBAL_STRUCT_INIT */ START_EXTERN_C #ifdef PERL_GLOBAL_STRUCT_INIT # define PERL_PPADDR_INITED static const Perl_ppaddr_t Gppaddr[] #else # ifndef PERL_GLOBAL_STRUCT # define PERL_PPADDR_INITED EXT Perl_ppaddr_t PL_ppaddr[] /* or perlvars.h */ # endif #endif /* PERL_GLOBAL_STRUCT */ #if (defined(DOINIT) && !defined(PERL_GLOBAL_STRUCT)) || defined(PERL_GLOBAL_STRUCT_INIT) # define PERL_PPADDR_INITED = { Perl_pp_null, Perl_pp_stub, Perl_pp_scalar, /* implemented by Perl_pp_null */ Perl_pp_pushmark, Perl_pp_wantarray, Perl_pp_const, Perl_pp_gvsv, Perl_pp_gv, Perl_pp_gelem, Perl_pp_padsv, Perl_pp_padav, Perl_pp_padhv, Perl_pp_padany, /* implemented by Perl_unimplemented_op */ Perl_pp_pushre, Perl_pp_rv2gv, Perl_pp_rv2sv, Perl_pp_av2arylen, Perl_pp_rv2cv, Perl_pp_anoncode, Perl_pp_prototype, Perl_pp_refgen, Perl_pp_srefgen, Perl_pp_ref, Perl_pp_bless, Perl_pp_backtick, Perl_pp_glob, Perl_pp_readline, Perl_pp_rcatline, Perl_pp_regcmaybe, /* implemented by Perl_pp_null */ Perl_pp_regcreset, Perl_pp_regcomp, Perl_pp_match, Perl_pp_qr, Perl_pp_subst, Perl_pp_substcont, Perl_pp_trans, Perl_pp_transr, /* implemented by Perl_pp_trans */ Perl_pp_sassign, Perl_pp_aassign, Perl_pp_chop, Perl_pp_schop, Perl_pp_chomp, /* implemented by Perl_pp_chop */ Perl_pp_schomp, /* implemented by Perl_pp_schop */ Perl_pp_defined, Perl_pp_undef, Perl_pp_study, Perl_pp_pos, Perl_pp_preinc, Perl_pp_i_preinc, /* implemented by Perl_pp_preinc */ Perl_pp_predec, /* implemented by Perl_pp_preinc */ Perl_pp_i_predec, /* implemented by Perl_pp_preinc */ Perl_pp_postinc, Perl_pp_i_postinc, /* implemented by Perl_pp_postinc */ Perl_pp_postdec, /* implemented by Perl_pp_postinc */ Perl_pp_i_postdec, /* implemented by Perl_pp_postinc */ Perl_pp_pow, Perl_pp_multiply, Perl_pp_i_multiply, Perl_pp_divide, Perl_pp_i_divide, Perl_pp_modulo, Perl_pp_i_modulo, Perl_pp_repeat, Perl_pp_add, Perl_pp_i_add, Perl_pp_subtract, Perl_pp_i_subtract, Perl_pp_concat, Perl_pp_stringify, Perl_pp_left_shift, Perl_pp_right_shift, Perl_pp_lt, Perl_pp_i_lt, Perl_pp_gt, Perl_pp_i_gt, Perl_pp_le, Perl_pp_i_le, Perl_pp_ge, Perl_pp_i_ge, Perl_pp_eq, Perl_pp_i_eq, Perl_pp_ne, Perl_pp_i_ne, Perl_pp_ncmp, Perl_pp_i_ncmp, Perl_pp_slt, /* implemented by Perl_pp_sle */ Perl_pp_sgt, /* implemented by Perl_pp_sle */ Perl_pp_sle, Perl_pp_sge, /* implemented by Perl_pp_sle */ Perl_pp_seq, Perl_pp_sne, Perl_pp_scmp, Perl_pp_bit_and, Perl_pp_bit_xor, /* implemented by Perl_pp_bit_or */ Perl_pp_bit_or, Perl_pp_negate, Perl_pp_i_negate, Perl_pp_not, Perl_pp_complement, Perl_pp_smartmatch, Perl_pp_atan2, Perl_pp_sin, Perl_pp_cos, /* implemented by Perl_pp_sin */ Perl_pp_rand, Perl_pp_srand, Perl_pp_exp, /* implemented by Perl_pp_sin */ Perl_pp_log, /* implemented by Perl_pp_sin */ Perl_pp_sqrt, /* implemented by Perl_pp_sin */ Perl_pp_int, Perl_pp_hex, /* implemented by Perl_pp_oct */ Perl_pp_oct, Perl_pp_abs, Perl_pp_length, Perl_pp_substr, Perl_pp_vec, Perl_pp_index, Perl_pp_rindex, /* implemented by Perl_pp_index */ Perl_pp_sprintf, Perl_pp_formline, Perl_pp_ord, Perl_pp_chr, Perl_pp_crypt, Perl_pp_ucfirst, Perl_pp_lcfirst, /* implemented by Perl_pp_ucfirst */ Perl_pp_uc, Perl_pp_lc, Perl_pp_quotemeta, Perl_pp_rv2av, Perl_pp_aelemfast, Perl_pp_aelemfast_lex, /* implemented by Perl_pp_aelemfast */ Perl_pp_aelem, Perl_pp_aslice, Perl_pp_aeach, Perl_pp_akeys, Perl_pp_avalues, /* implemented by Perl_pp_akeys */ Perl_pp_each, Perl_pp_values, /* implemented by Perl_do_kv */ Perl_pp_keys, /* implemented by Perl_do_kv */ Perl_pp_delete, Perl_pp_exists, Perl_pp_rv2hv, /* implemented by Perl_pp_rv2av */ Perl_pp_helem, Perl_pp_hslice, Perl_pp_boolkeys, Perl_pp_unpack, Perl_pp_pack, Perl_pp_split, Perl_pp_join, Perl_pp_list, Perl_pp_lslice, Perl_pp_anonlist, Perl_pp_anonhash, Perl_pp_splice, Perl_pp_push, Perl_pp_pop, /* implemented by Perl_pp_shift */ Perl_pp_shift, Perl_pp_unshift, Perl_pp_sort, Perl_pp_reverse, Perl_pp_grepstart, Perl_pp_grepwhile, Perl_pp_mapstart, /* implemented by Perl_unimplemented_op */ Perl_pp_mapwhile, Perl_pp_range, Perl_pp_flip, Perl_pp_flop, Perl_pp_and, Perl_pp_or, Perl_pp_xor, Perl_pp_dor, /* implemented by Perl_pp_defined */ Perl_pp_cond_expr, Perl_pp_andassign, /* implemented by Perl_pp_and */ Perl_pp_orassign, /* implemented by Perl_pp_or */ Perl_pp_dorassign, /* implemented by Perl_pp_defined */ Perl_pp_method, Perl_pp_entersub, Perl_pp_leavesub, Perl_pp_leavesublv, Perl_pp_caller, Perl_pp_warn, Perl_pp_die, Perl_pp_reset, Perl_pp_lineseq, /* implemented by Perl_pp_null */ Perl_pp_nextstate, Perl_pp_dbstate, Perl_pp_unstack, Perl_pp_enter, Perl_pp_leave, Perl_pp_scope, /* implemented by Perl_pp_null */ Perl_pp_enteriter, Perl_pp_iter, Perl_pp_enterloop, Perl_pp_leaveloop, Perl_pp_return, Perl_pp_last, Perl_pp_next, Perl_pp_redo, Perl_pp_dump, /* implemented by Perl_pp_goto */ Perl_pp_goto, Perl_pp_exit, Perl_pp_method_named, Perl_pp_entergiven, Perl_pp_leavegiven, Perl_pp_enterwhen, Perl_pp_leavewhen, Perl_pp_break, Perl_pp_continue, Perl_pp_open, Perl_pp_close, Perl_pp_pipe_op, Perl_pp_fileno, Perl_pp_umask, Perl_pp_binmode, Perl_pp_tie, Perl_pp_untie, Perl_pp_tied, Perl_pp_dbmopen, Perl_pp_dbmclose, /* implemented by Perl_pp_untie */ Perl_pp_sselect, Perl_pp_select, Perl_pp_getc, Perl_pp_read, /* implemented by Perl_pp_sysread */ Perl_pp_enterwrite, Perl_pp_leavewrite, Perl_pp_prtf, Perl_pp_print, Perl_pp_say, /* implemented by Perl_pp_print */ Perl_pp_sysopen, Perl_pp_sysseek, Perl_pp_sysread, Perl_pp_syswrite, Perl_pp_eof, Perl_pp_tell, Perl_pp_seek, /* implemented by Perl_pp_sysseek */ Perl_pp_truncate, Perl_pp_fcntl, /* implemented by Perl_pp_ioctl */ Perl_pp_ioctl, Perl_pp_flock, Perl_pp_send, /* implemented by Perl_pp_syswrite */ Perl_pp_recv, /* implemented by Perl_pp_sysread */ Perl_pp_socket, Perl_pp_sockpair, Perl_pp_bind, Perl_pp_connect, /* implemented by Perl_pp_bind */ Perl_pp_listen, Perl_pp_accept, Perl_pp_shutdown, Perl_pp_gsockopt, /* implemented by Perl_pp_ssockopt */ Perl_pp_ssockopt, Perl_pp_getsockname, /* implemented by Perl_pp_getpeername */ Perl_pp_getpeername, Perl_pp_lstat, /* implemented by Perl_pp_stat */ Perl_pp_stat, Perl_pp_ftrread, Perl_pp_ftrwrite, /* implemented by Perl_pp_ftrread */ Perl_pp_ftrexec, /* implemented by Perl_pp_ftrread */ Perl_pp_fteread, /* implemented by Perl_pp_ftrread */ Perl_pp_ftewrite, /* implemented by Perl_pp_ftrread */ Perl_pp_fteexec, /* implemented by Perl_pp_ftrread */ Perl_pp_ftis, Perl_pp_ftsize, /* implemented by Perl_pp_ftis */ Perl_pp_ftmtime, /* implemented by Perl_pp_ftis */ Perl_pp_ftatime, /* implemented by Perl_pp_ftis */ Perl_pp_ftctime, /* implemented by Perl_pp_ftis */ Perl_pp_ftrowned, Perl_pp_fteowned, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftzero, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftsock, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftchr, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftblk, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftfile, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftdir, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftpipe, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftsuid, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftsgid, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftsvtx, /* implemented by Perl_pp_ftrowned */ Perl_pp_ftlink, Perl_pp_fttty, Perl_pp_fttext, Perl_pp_ftbinary, /* implemented by Perl_pp_fttext */ Perl_pp_chdir, Perl_pp_chown, Perl_pp_chroot, Perl_pp_unlink, /* implemented by Perl_pp_chown */ Perl_pp_chmod, /* implemented by Perl_pp_chown */ Perl_pp_utime, /* implemented by Perl_pp_chown */ Perl_pp_rename, Perl_pp_link, Perl_pp_symlink, /* implemented by Perl_pp_link */ Perl_pp_readlink, Perl_pp_mkdir, Perl_pp_rmdir, Perl_pp_open_dir, Perl_pp_readdir, Perl_pp_telldir, Perl_pp_seekdir, Perl_pp_rewinddir, Perl_pp_closedir, Perl_pp_fork, Perl_pp_wait, Perl_pp_waitpid, Perl_pp_system, Perl_pp_exec, Perl_pp_kill, /* implemented by Perl_pp_chown */ Perl_pp_getppid, Perl_pp_getpgrp, Perl_pp_setpgrp, Perl_pp_getpriority, Perl_pp_setpriority, Perl_pp_time, Perl_pp_tms, Perl_pp_localtime, /* implemented by Perl_pp_gmtime */ Perl_pp_gmtime, Perl_pp_alarm, Perl_pp_sleep, Perl_pp_shmget, /* implemented by Perl_pp_semget */ Perl_pp_shmctl, /* implemented by Perl_pp_semctl */ Perl_pp_shmread, /* implemented by Perl_pp_shmwrite */ Perl_pp_shmwrite, Perl_pp_msgget, /* implemented by Perl_pp_semget */ Perl_pp_msgctl, /* implemented by Perl_pp_semctl */ Perl_pp_msgsnd, /* implemented by Perl_pp_shmwrite */ Perl_pp_msgrcv, /* implemented by Perl_pp_shmwrite */ Perl_pp_semop, /* implemented by Perl_pp_shmwrite */ Perl_pp_semget, Perl_pp_semctl, Perl_pp_require, Perl_pp_dofile, /* implemented by Perl_pp_require */ Perl_pp_hintseval, Perl_pp_entereval, Perl_pp_leaveeval, Perl_pp_entertry, Perl_pp_leavetry, Perl_pp_ghbyname, /* implemented by Perl_pp_ghostent */ Perl_pp_ghbyaddr, /* implemented by Perl_pp_ghostent */ Perl_pp_ghostent, Perl_pp_gnbyname, /* implemented by Perl_pp_gnetent */ Perl_pp_gnbyaddr, /* implemented by Perl_pp_gnetent */ Perl_pp_gnetent, Perl_pp_gpbyname, /* implemented by Perl_pp_gprotoent */ Perl_pp_gpbynumber, /* implemented by Perl_pp_gprotoent */ Perl_pp_gprotoent, Perl_pp_gsbyname, /* implemented by Perl_pp_gservent */ Perl_pp_gsbyport, /* implemented by Perl_pp_gservent */ Perl_pp_gservent, Perl_pp_shostent, Perl_pp_snetent, /* implemented by Perl_pp_shostent */ Perl_pp_sprotoent, /* implemented by Perl_pp_shostent */ Perl_pp_sservent, /* implemented by Perl_pp_shostent */ Perl_pp_ehostent, Perl_pp_enetent, /* implemented by Perl_pp_ehostent */ Perl_pp_eprotoent, /* implemented by Perl_pp_ehostent */ Perl_pp_eservent, /* implemented by Perl_pp_ehostent */ Perl_pp_gpwnam, /* implemented by Perl_pp_gpwent */ Perl_pp_gpwuid, /* implemented by Perl_pp_gpwent */ Perl_pp_gpwent, Perl_pp_spwent, /* implemented by Perl_pp_ehostent */ Perl_pp_epwent, /* implemented by Perl_pp_ehostent */ Perl_pp_ggrnam, /* implemented by Perl_pp_ggrent */ Perl_pp_ggrgid, /* implemented by Perl_pp_ggrent */ Perl_pp_ggrent, Perl_pp_sgrent, /* implemented by Perl_pp_ehostent */ Perl_pp_egrent, /* implemented by Perl_pp_ehostent */ Perl_pp_getlogin, Perl_pp_syscall, Perl_pp_lock, Perl_pp_once, Perl_pp_custom, /* implemented by Perl_unimplemented_op */ Perl_pp_reach, /* implemented by Perl_pp_rkeys */ Perl_pp_rkeys, Perl_pp_rvalues, /* implemented by Perl_pp_rkeys */ Perl_pp_coreargs, Perl_pp_runcv, Perl_pp_fc, } #endif #ifdef PERL_PPADDR_INITED ; #endif #ifdef PERL_GLOBAL_STRUCT_INIT # define PERL_CHECK_INITED static const Perl_check_t Gcheck[] #else # ifndef PERL_GLOBAL_STRUCT # define PERL_CHECK_INITED EXT Perl_check_t PL_check[] /* or perlvars.h */ # endif #endif #if (defined(DOINIT) && !defined(PERL_GLOBAL_STRUCT)) || defined(PERL_GLOBAL_STRUCT_INIT) # define PERL_CHECK_INITED = { Perl_ck_null, /* null */ Perl_ck_null, /* stub */ Perl_ck_fun, /* scalar */ Perl_ck_null, /* pushmark */ Perl_ck_null, /* wantarray */ Perl_ck_svconst, /* const */ Perl_ck_null, /* gvsv */ Perl_ck_null, /* gv */ Perl_ck_null, /* gelem */ Perl_ck_null, /* padsv */ Perl_ck_null, /* padav */ Perl_ck_null, /* padhv */ Perl_ck_null, /* padany */ Perl_ck_null, /* pushre */ Perl_ck_rvconst, /* rv2gv */ Perl_ck_rvconst, /* rv2sv */ Perl_ck_null, /* av2arylen */ Perl_ck_rvconst, /* rv2cv */ Perl_ck_anoncode, /* anoncode */ Perl_ck_null, /* prototype */ Perl_ck_spair, /* refgen */ Perl_ck_null, /* srefgen */ Perl_ck_fun, /* ref */ Perl_ck_fun, /* bless */ Perl_ck_open, /* backtick */ Perl_ck_glob, /* glob */ Perl_ck_readline, /* readline */ Perl_ck_null, /* rcatline */ Perl_ck_fun, /* regcmaybe */ Perl_ck_fun, /* regcreset */ Perl_ck_null, /* regcomp */ Perl_ck_match, /* match */ Perl_ck_match, /* qr */ Perl_ck_match, /* subst */ Perl_ck_null, /* substcont */ Perl_ck_match, /* trans */ Perl_ck_match, /* transr */ Perl_ck_sassign, /* sassign */ Perl_ck_null, /* aassign */ Perl_ck_spair, /* chop */ Perl_ck_null, /* schop */ Perl_ck_spair, /* chomp */ Perl_ck_null, /* schomp */ Perl_ck_defined, /* defined */ Perl_ck_lfun, /* undef */ Perl_ck_fun, /* study */ Perl_ck_lfun, /* pos */ Perl_ck_lfun, /* preinc */ Perl_ck_lfun, /* i_preinc */ Perl_ck_lfun, /* predec */ Perl_ck_lfun, /* i_predec */ Perl_ck_lfun, /* postinc */ Perl_ck_lfun, /* i_postinc */ Perl_ck_lfun, /* postdec */ Perl_ck_lfun, /* i_postdec */ Perl_ck_null, /* pow */ Perl_ck_null, /* multiply */ Perl_ck_null, /* i_multiply */ Perl_ck_null, /* divide */ Perl_ck_null, /* i_divide */ Perl_ck_null, /* modulo */ Perl_ck_null, /* i_modulo */ Perl_ck_repeat, /* repeat */ Perl_ck_null, /* add */ Perl_ck_null, /* i_add */ Perl_ck_null, /* subtract */ Perl_ck_null, /* i_subtract */ Perl_ck_concat, /* concat */ Perl_ck_fun, /* stringify */ Perl_ck_bitop, /* left_shift */ Perl_ck_bitop, /* right_shift */ Perl_ck_cmp, /* lt */ Perl_ck_cmp, /* i_lt */ Perl_ck_cmp, /* gt */ Perl_ck_cmp, /* i_gt */ Perl_ck_cmp, /* le */ Perl_ck_cmp, /* i_le */ Perl_ck_cmp, /* ge */ Perl_ck_cmp, /* i_ge */ Perl_ck_null, /* eq */ Perl_ck_null, /* i_eq */ Perl_ck_null, /* ne */ Perl_ck_null, /* i_ne */ Perl_ck_null, /* ncmp */ Perl_ck_null, /* i_ncmp */ Perl_ck_null, /* slt */ Perl_ck_null, /* sgt */ Perl_ck_null, /* sle */ Perl_ck_null, /* sge */ Perl_ck_null, /* seq */ Perl_ck_null, /* sne */ Perl_ck_null, /* scmp */ Perl_ck_bitop, /* bit_and */ Perl_ck_bitop, /* bit_xor */ Perl_ck_bitop, /* bit_or */ Perl_ck_null, /* negate */ Perl_ck_null, /* i_negate */ Perl_ck_null, /* not */ Perl_ck_bitop, /* complement */ Perl_ck_smartmatch, /* smartmatch */ Perl_ck_fun, /* atan2 */ Perl_ck_fun, /* sin */ Perl_ck_fun, /* cos */ Perl_ck_fun, /* rand */ Perl_ck_fun, /* srand */ Perl_ck_fun, /* exp */ Perl_ck_fun, /* log */ Perl_ck_fun, /* sqrt */ Perl_ck_fun, /* int */ Perl_ck_fun, /* hex */ Perl_ck_fun, /* oct */ Perl_ck_fun, /* abs */ Perl_ck_length, /* length */ Perl_ck_substr, /* substr */ Perl_ck_fun, /* vec */ Perl_ck_index, /* index */ Perl_ck_index, /* rindex */ Perl_ck_lfun, /* sprintf */ Perl_ck_fun, /* formline */ Perl_ck_fun, /* ord */ Perl_ck_fun, /* chr */ Perl_ck_fun, /* crypt */ Perl_ck_fun, /* ucfirst */ Perl_ck_fun, /* lcfirst */ Perl_ck_fun, /* uc */ Perl_ck_fun, /* lc */ Perl_ck_fun, /* quotemeta */ Perl_ck_rvconst, /* rv2av */ Perl_ck_null, /* aelemfast */ Perl_ck_null, /* aelemfast_lex */ Perl_ck_null, /* aelem */ Perl_ck_null, /* aslice */ Perl_ck_each, /* aeach */ Perl_ck_each, /* akeys */ Perl_ck_each, /* avalues */ Perl_ck_each, /* each */ Perl_ck_each, /* values */ Perl_ck_each, /* keys */ Perl_ck_delete, /* delete */ Perl_ck_exists, /* exists */ Perl_ck_rvconst, /* rv2hv */ Perl_ck_null, /* helem */ Perl_ck_null, /* hslice */ Perl_ck_fun, /* boolkeys */ Perl_ck_fun, /* unpack */ Perl_ck_fun, /* pack */ Perl_ck_split, /* split */ Perl_ck_join, /* join */ Perl_ck_null, /* list */ Perl_ck_null, /* lslice */ Perl_ck_fun, /* anonlist */ Perl_ck_fun, /* anonhash */ Perl_ck_fun, /* splice */ Perl_ck_fun, /* push */ Perl_ck_shift, /* pop */ Perl_ck_shift, /* shift */ Perl_ck_fun, /* unshift */ Perl_ck_sort, /* sort */ Perl_ck_fun, /* reverse */ Perl_ck_grep, /* grepstart */ Perl_ck_null, /* grepwhile */ Perl_ck_grep, /* mapstart */ Perl_ck_null, /* mapwhile */ Perl_ck_null, /* range */ Perl_ck_null, /* flip */ Perl_ck_null, /* flop */ Perl_ck_null, /* and */ Perl_ck_null, /* or */ Perl_ck_null, /* xor */ Perl_ck_null, /* dor */ Perl_ck_null, /* cond_expr */ Perl_ck_null, /* andassign */ Perl_ck_null, /* orassign */ Perl_ck_null, /* dorassign */ Perl_ck_method, /* method */ Perl_ck_subr, /* entersub */ Perl_ck_null, /* leavesub */ Perl_ck_null, /* leavesublv */ Perl_ck_fun, /* caller */ Perl_ck_fun, /* warn */ Perl_ck_die, /* die */ Perl_ck_fun, /* reset */ Perl_ck_null, /* lineseq */ Perl_ck_null, /* nextstate */ Perl_ck_null, /* dbstate */ Perl_ck_null, /* unstack */ Perl_ck_null, /* enter */ Perl_ck_null, /* leave */ Perl_ck_null, /* scope */ Perl_ck_null, /* enteriter */ Perl_ck_null, /* iter */ Perl_ck_null, /* enterloop */ Perl_ck_null, /* leaveloop */ Perl_ck_return, /* return */ Perl_ck_null, /* last */ Perl_ck_null, /* next */ Perl_ck_null, /* redo */ Perl_ck_null, /* dump */ Perl_ck_null, /* goto */ Perl_ck_exit, /* exit */ Perl_ck_null, /* method_named */ Perl_ck_null, /* entergiven */ Perl_ck_null, /* leavegiven */ Perl_ck_null, /* enterwhen */ Perl_ck_null, /* leavewhen */ Perl_ck_null, /* break */ Perl_ck_null, /* continue */ Perl_ck_open, /* open */ Perl_ck_fun, /* close */ Perl_ck_fun, /* pipe_op */ Perl_ck_fun, /* fileno */ Perl_ck_fun, /* umask */ Perl_ck_fun, /* binmode */ Perl_ck_fun, /* tie */ Perl_ck_fun, /* untie */ Perl_ck_fun, /* tied */ Perl_ck_fun, /* dbmopen */ Perl_ck_fun, /* dbmclose */ Perl_ck_select, /* sselect */ Perl_ck_select, /* select */ Perl_ck_eof, /* getc */ Perl_ck_fun, /* read */ Perl_ck_fun, /* enterwrite */ Perl_ck_null, /* leavewrite */ Perl_ck_listiob, /* prtf */ Perl_ck_listiob, /* print */ Perl_ck_listiob, /* say */ Perl_ck_fun, /* sysopen */ Perl_ck_fun, /* sysseek */ Perl_ck_fun, /* sysread */ Perl_ck_fun, /* syswrite */ Perl_ck_eof, /* eof */ Perl_ck_tell, /* tell */ Perl_ck_tell, /* seek */ Perl_ck_trunc, /* truncate */ Perl_ck_fun, /* fcntl */ Perl_ck_fun, /* ioctl */ Perl_ck_fun, /* flock */ Perl_ck_fun, /* send */ Perl_ck_fun, /* recv */ Perl_ck_fun, /* socket */ Perl_ck_fun, /* sockpair */ Perl_ck_fun, /* bind */ Perl_ck_fun, /* connect */ Perl_ck_fun, /* listen */ Perl_ck_fun, /* accept */ Perl_ck_fun, /* shutdown */ Perl_ck_fun, /* gsockopt */ Perl_ck_fun, /* ssockopt */ Perl_ck_fun, /* getsockname */ Perl_ck_fun, /* getpeername */ Perl_ck_ftst, /* lstat */ Perl_ck_ftst, /* stat */ Perl_ck_ftst, /* ftrread */ Perl_ck_ftst, /* ftrwrite */ Perl_ck_ftst, /* ftrexec */ Perl_ck_ftst, /* fteread */ Perl_ck_ftst, /* ftewrite */ Perl_ck_ftst, /* fteexec */ Perl_ck_ftst, /* ftis */ Perl_ck_ftst, /* ftsize */ Perl_ck_ftst, /* ftmtime */ Perl_ck_ftst, /* ftatime */ Perl_ck_ftst, /* ftctime */ Perl_ck_ftst, /* ftrowned */ Perl_ck_ftst, /* fteowned */ Perl_ck_ftst, /* ftzero */ Perl_ck_ftst, /* ftsock */ Perl_ck_ftst, /* ftchr */ Perl_ck_ftst, /* ftblk */ Perl_ck_ftst, /* ftfile */ Perl_ck_ftst, /* ftdir */ Perl_ck_ftst, /* ftpipe */ Perl_ck_ftst, /* ftsuid */ Perl_ck_ftst, /* ftsgid */ Perl_ck_ftst, /* ftsvtx */ Perl_ck_ftst, /* ftlink */ Perl_ck_ftst, /* fttty */ Perl_ck_ftst, /* fttext */ Perl_ck_ftst, /* ftbinary */ Perl_ck_chdir, /* chdir */ Perl_ck_fun, /* chown */ Perl_ck_fun, /* chroot */ Perl_ck_fun, /* unlink */ Perl_ck_fun, /* chmod */ Perl_ck_fun, /* utime */ Perl_ck_fun, /* rename */ Perl_ck_fun, /* link */ Perl_ck_fun, /* symlink */ Perl_ck_fun, /* readlink */ Perl_ck_fun, /* mkdir */ Perl_ck_fun, /* rmdir */ Perl_ck_fun, /* open_dir */ Perl_ck_fun, /* readdir */ Perl_ck_fun, /* telldir */ Perl_ck_fun, /* seekdir */ Perl_ck_fun, /* rewinddir */ Perl_ck_fun, /* closedir */ Perl_ck_null, /* fork */ Perl_ck_null, /* wait */ Perl_ck_fun, /* waitpid */ Perl_ck_exec, /* system */ Perl_ck_exec, /* exec */ Perl_ck_fun, /* kill */ Perl_ck_null, /* getppid */ Perl_ck_fun, /* getpgrp */ Perl_ck_fun, /* setpgrp */ Perl_ck_fun, /* getpriority */ Perl_ck_fun, /* setpriority */ Perl_ck_null, /* time */ Perl_ck_null, /* tms */ Perl_ck_fun, /* localtime */ Perl_ck_fun, /* gmtime */ Perl_ck_fun, /* alarm */ Perl_ck_fun, /* sleep */ Perl_ck_fun, /* shmget */ Perl_ck_fun, /* shmctl */ Perl_ck_fun, /* shmread */ Perl_ck_fun, /* shmwrite */ Perl_ck_fun, /* msgget */ Perl_ck_fun, /* msgctl */ Perl_ck_fun, /* msgsnd */ Perl_ck_fun, /* msgrcv */ Perl_ck_fun, /* semop */ Perl_ck_fun, /* semget */ Perl_ck_fun, /* semctl */ Perl_ck_require, /* require */ Perl_ck_fun, /* dofile */ Perl_ck_svconst, /* hintseval */ Perl_ck_eval, /* entereval */ Perl_ck_null, /* leaveeval */ Perl_ck_eval, /* entertry */ Perl_ck_null, /* leavetry */ Perl_ck_fun, /* ghbyname */ Perl_ck_fun, /* ghbyaddr */ Perl_ck_null, /* ghostent */ Perl_ck_fun, /* gnbyname */ Perl_ck_fun, /* gnbyaddr */ Perl_ck_null, /* gnetent */ Perl_ck_fun, /* gpbyname */ Perl_ck_fun, /* gpbynumber */ Perl_ck_null, /* gprotoent */ Perl_ck_fun, /* gsbyname */ Perl_ck_fun, /* gsbyport */ Perl_ck_null, /* gservent */ Perl_ck_fun, /* shostent */ Perl_ck_fun, /* snetent */ Perl_ck_fun, /* sprotoent */ Perl_ck_fun, /* sservent */ Perl_ck_null, /* ehostent */ Perl_ck_null, /* enetent */ Perl_ck_null, /* eprotoent */ Perl_ck_null, /* eservent */ Perl_ck_fun, /* gpwnam */ Perl_ck_fun, /* gpwuid */ Perl_ck_null, /* gpwent */ Perl_ck_null, /* spwent */ Perl_ck_null, /* epwent */ Perl_ck_fun, /* ggrnam */ Perl_ck_fun, /* ggrgid */ Perl_ck_null, /* ggrent */ Perl_ck_null, /* sgrent */ Perl_ck_null, /* egrent */ Perl_ck_null, /* getlogin */ Perl_ck_fun, /* syscall */ Perl_ck_rfun, /* lock */ Perl_ck_null, /* once */ Perl_ck_null, /* custom */ Perl_ck_each, /* reach */ Perl_ck_each, /* rkeys */ Perl_ck_each, /* rvalues */ Perl_ck_null, /* coreargs */ Perl_ck_null, /* runcv */ Perl_ck_fun, /* fc */ } #endif #ifdef PERL_CHECK_INITED ; #endif /* #ifdef PERL_CHECK_INITED */ #ifndef PERL_GLOBAL_STRUCT_INIT #ifndef DOINIT EXTCONST U32 PL_opargs[]; #else EXTCONST U32 PL_opargs[] = { 0x00000000, /* null */ 0x00000000, /* stub */ 0x00001b04, /* scalar */ 0x00000004, /* pushmark */ 0x00000004, /* wantarray */ 0x00000604, /* const */ 0x00000644, /* gvsv */ 0x00000644, /* gv */ 0x00011240, /* gelem */ 0x00000044, /* padsv */ 0x00000040, /* padav */ 0x00000040, /* padhv */ 0x00000040, /* padany */ 0x00000540, /* pushre */ 0x00000144, /* rv2gv */ 0x00000144, /* rv2sv */ 0x00000104, /* av2arylen */ 0x00000140, /* rv2cv */ 0x00000600, /* anoncode */ 0x00001b04, /* prototype */ 0x00002101, /* refgen */ 0x00001106, /* srefgen */ 0x00009b8c, /* ref */ 0x00091404, /* bless */ 0x00009b88, /* backtick */ 0x00009408, /* glob */ 0x0000eb08, /* readline */ 0x00000608, /* rcatline */ 0x00001104, /* regcmaybe */ 0x00001104, /* regcreset */ 0x00001304, /* regcomp */ 0x00000540, /* match */ 0x00000504, /* qr */ 0x00001544, /* subst */ 0x00000344, /* substcont */ 0x00001804, /* trans */ 0x00001804, /* transr */ 0x00000004, /* sassign */ 0x00022208, /* aassign */ 0x00002b0d, /* chop */ 0x00009b8c, /* schop */ 0x00002b1d, /* chomp */ 0x00009b9c, /* schomp */ 0x00009b84, /* defined */ 0x00009b04, /* undef */ 0x00009b84, /* study */ 0x00009b8c, /* pos */ 0x00001164, /* preinc */ 0x00001144, /* i_preinc */ 0x00001164, /* predec */ 0x00001144, /* i_predec */ 0x0000116c, /* postinc */ 0x0000115c, /* i_postinc */ 0x0000116c, /* postdec */ 0x0000115c, /* i_postdec */ 0x0001121e, /* pow */ 0x0001123e, /* multiply */ 0x0001121e, /* i_multiply */ 0x0001123e, /* divide */ 0x0001121e, /* i_divide */ 0x0001123e, /* modulo */ 0x0001121e, /* i_modulo */ 0x00012209, /* repeat */ 0x0001123e, /* add */ 0x0001121e, /* i_add */ 0x0001123e, /* subtract */ 0x0001121e, /* i_subtract */ 0x0001121e, /* concat */ 0x0000141e, /* stringify */ 0x0001121e, /* left_shift */ 0x0001121e, /* right_shift */ 0x00011226, /* lt */ 0x00011206, /* i_lt */ 0x00011226, /* gt */ 0x00011206, /* i_gt */ 0x00011226, /* le */ 0x00011206, /* i_le */ 0x00011226, /* ge */ 0x00011206, /* i_ge */ 0x00011226, /* eq */ 0x00011206, /* i_eq */ 0x00011226, /* ne */ 0x00011206, /* i_ne */ 0x0001122e, /* ncmp */ 0x0001120e, /* i_ncmp */ 0x00011206, /* slt */ 0x00011206, /* sgt */ 0x00011206, /* sle */ 0x00011206, /* sge */ 0x00011206, /* seq */ 0x00011206, /* sne */ 0x0001120e, /* scmp */ 0x0001120e, /* bit_and */ 0x0001120e, /* bit_xor */ 0x0001120e, /* bit_or */ 0x0000112e, /* negate */ 0x0000111e, /* i_negate */ 0x00001106, /* not */ 0x0000110e, /* complement */ 0x00000204, /* smartmatch */ 0x0001141e, /* atan2 */ 0x00009b9e, /* sin */ 0x00009b9e, /* cos */ 0x00009b1c, /* rand */ 0x00009b1c, /* srand */ 0x00009b9e, /* exp */ 0x00009b9e, /* log */ 0x00009b9e, /* sqrt */ 0x00009b9e, /* int */ 0x00009b9e, /* hex */ 0x00009b9e, /* oct */ 0x00009b9e, /* abs */ 0x00009b9e, /* length */ 0x0991140c, /* substr */ 0x0011140c, /* vec */ 0x0091141c, /* index */ 0x0091141c, /* rindex */ 0x0002140f, /* sprintf */ 0x00021405, /* formline */ 0x00009b9e, /* ord */ 0x00009b9e, /* chr */ 0x0001141e, /* crypt */ 0x00009b8e, /* ucfirst */ 0x00009b8e, /* lcfirst */ 0x00009b8e, /* uc */ 0x00009b8e, /* lc */ 0x00009b8e, /* quotemeta */ 0x00000148, /* rv2av */ 0x00013604, /* aelemfast */ 0x00013040, /* aelemfast_lex */ 0x00013204, /* aelem */ 0x00023401, /* aslice */ 0x00003b00, /* aeach */ 0x00003b08, /* akeys */ 0x00003b08, /* avalues */ 0x00004b00, /* each */ 0x00004b08, /* values */ 0x00004b08, /* keys */ 0x00001b00, /* delete */ 0x00001b04, /* exists */ 0x00000148, /* rv2hv */ 0x00014204, /* helem */ 0x00024401, /* hslice */ 0x00004b00, /* boolkeys */ 0x00091480, /* unpack */ 0x0002140d, /* pack */ 0x00111408, /* split */ 0x0002140d, /* join */ 0x00002401, /* list */ 0x00224200, /* lslice */ 0x00002405, /* anonlist */ 0x00002405, /* anonhash */ 0x02993401, /* splice */ 0x0002341d, /* push */ 0x0000bb04, /* pop */ 0x0000bb04, /* shift */ 0x0002341d, /* unshift */ 0x0002d441, /* sort */ 0x00002409, /* reverse */ 0x00025441, /* grepstart */ 0x00000348, /* grepwhile */ 0x00025441, /* mapstart */ 0x00000348, /* mapwhile */ 0x00011300, /* range */ 0x00011100, /* flip */ 0x00000100, /* flop */ 0x00000300, /* and */ 0x00000300, /* or */ 0x00011206, /* xor */ 0x00000300, /* dor */ 0x00000340, /* cond_expr */ 0x00000304, /* andassign */ 0x00000304, /* orassign */ 0x00000304, /* dorassign */ 0x00000140, /* method */ 0x00002149, /* entersub */ 0x00000100, /* leavesub */ 0x00000100, /* leavesublv */ 0x00009b08, /* caller */ 0x0000240d, /* warn */ 0x0000244d, /* die */ 0x00009b04, /* reset */ 0x00000400, /* lineseq */ 0x00000a04, /* nextstate */ 0x00000a04, /* dbstate */ 0x00000004, /* unstack */ 0x00000000, /* enter */ 0x00000400, /* leave */ 0x00000400, /* scope */ 0x00000940, /* enteriter */ 0x00000000, /* iter */ 0x00000940, /* enterloop */ 0x00000200, /* leaveloop */ 0x00002441, /* return */ 0x00000d44, /* last */ 0x00000d44, /* next */ 0x00000d44, /* redo */ 0x00000d44, /* dump */ 0x00000d44, /* goto */ 0x00009b44, /* exit */ 0x00000640, /* method_named */ 0x00000340, /* entergiven */ 0x00000100, /* leavegiven */ 0x00000340, /* enterwhen */ 0x00000100, /* leavewhen */ 0x00000000, /* break */ 0x00000000, /* continue */ 0x0029640d, /* open */ 0x0000eb04, /* close */ 0x00066404, /* pipe_op */ 0x00006b0c, /* fileno */ 0x00009b0c, /* umask */ 0x00096404, /* binmode */ 0x00217445, /* tie */ 0x00007b04, /* untie */ 0x00007b04, /* tied */ 0x00114404, /* dbmopen */ 0x00004b04, /* dbmclose */ 0x01111408, /* sselect */ 0x0000e40c, /* select */ 0x0000eb0c, /* getc */ 0x0917640d, /* read */ 0x0000eb44, /* enterwrite */ 0x00000100, /* leavewrite */ 0x0002e405, /* prtf */ 0x0002e405, /* print */ 0x0002e405, /* say */ 0x09116404, /* sysopen */ 0x00116404, /* sysseek */ 0x0917640d, /* sysread */ 0x0991640d, /* syswrite */ 0x0000eb04, /* eof */ 0x0000eb0c, /* tell */ 0x00116404, /* seek */ 0x00011404, /* truncate */ 0x0011640c, /* fcntl */ 0x0011640c, /* ioctl */ 0x0001641c, /* flock */ 0x0911640d, /* send */ 0x0117640d, /* recv */ 0x01116404, /* socket */ 0x11166404, /* sockpair */ 0x00016404, /* bind */ 0x00016404, /* connect */ 0x00016404, /* listen */ 0x0006640c, /* accept */ 0x0001640c, /* shutdown */ 0x00116404, /* gsockopt */ 0x01116404, /* ssockopt */ 0x00006b04, /* getsockname */ 0x00006b04, /* getpeername */ 0x0000ec80, /* lstat */ 0x0000ec80, /* stat */ 0x00006c84, /* ftrread */ 0x00006c84, /* ftrwrite */ 0x00006c84, /* ftrexec */ 0x00006c84, /* fteread */ 0x00006c84, /* ftewrite */ 0x00006c84, /* fteexec */ 0x00006c84, /* ftis */ 0x00006c8c, /* ftsize */ 0x00006c8c, /* ftmtime */ 0x00006c8c, /* ftatime */ 0x00006c8c, /* ftctime */ 0x00006c84, /* ftrowned */ 0x00006c84, /* fteowned */ 0x00006c84, /* ftzero */ 0x00006c84, /* ftsock */ 0x00006c84, /* ftchr */ 0x00006c84, /* ftblk */ 0x00006c84, /* ftfile */ 0x00006c84, /* ftdir */ 0x00006c84, /* ftpipe */ 0x00006c84, /* ftsuid */ 0x00006c84, /* ftsgid */ 0x00006c84, /* ftsvtx */ 0x00006c84, /* ftlink */ 0x00006c04, /* fttty */ 0x00006c84, /* fttext */ 0x00006c84, /* ftbinary */ 0x00009b1c, /* chdir */ 0x0000241d, /* chown */ 0x00009b9c, /* chroot */ 0x0000249d, /* unlink */ 0x0000241d, /* chmod */ 0x0000241d, /* utime */ 0x0001141c, /* rename */ 0x0001141c, /* link */ 0x0001141c, /* symlink */ 0x00009b8c, /* readlink */ 0x0009949c, /* mkdir */ 0x00009b9c, /* rmdir */ 0x00016404, /* open_dir */ 0x00006b00, /* readdir */ 0x00006b0c, /* telldir */ 0x00016404, /* seekdir */ 0x00006b04, /* rewinddir */ 0x00006b04, /* closedir */ 0x0000000c, /* fork */ 0x0000001c, /* wait */ 0x0001141c, /* waitpid */ 0x0002941d, /* system */ 0x0002945d, /* exec */ 0x0000245d, /* kill */ 0x0000001c, /* getppid */ 0x00009b1c, /* getpgrp */ 0x0009941c, /* setpgrp */ 0x0001141c, /* getpriority */ 0x0011141c, /* setpriority */ 0x0000001c, /* time */ 0x00000000, /* tms */ 0x00009b08, /* localtime */ 0x00009b08, /* gmtime */ 0x00009b8c, /* alarm */ 0x00009b1c, /* sleep */ 0x0011140d, /* shmget */ 0x0011140d, /* shmctl */ 0x0111140d, /* shmread */ 0x0111140d, /* shmwrite */ 0x0001140d, /* msgget */ 0x0011140d, /* msgctl */ 0x0011140d, /* msgsnd */ 0x1111140d, /* msgrcv */ 0x0001140d, /* semop */ 0x0011140d, /* semget */ 0x0111140d, /* semctl */ 0x00009bc0, /* require */ 0x00001140, /* dofile */ 0x00000604, /* hintseval */ 0x00009bc0, /* entereval */ 0x00001100, /* leaveeval */ 0x00000340, /* entertry */ 0x00000400, /* leavetry */ 0x00001b00, /* ghbyname */ 0x00011400, /* ghbyaddr */ 0x00000000, /* ghostent */ 0x00001b00, /* gnbyname */ 0x00011400, /* gnbyaddr */ 0x00000000, /* gnetent */ 0x00001b00, /* gpbyname */ 0x00001400, /* gpbynumber */ 0x00000000, /* gprotoent */ 0x00011400, /* gsbyname */ 0x00011400, /* gsbyport */ 0x00000000, /* gservent */ 0x00001b04, /* shostent */ 0x00001b04, /* snetent */ 0x00001b04, /* sprotoent */ 0x00001b04, /* sservent */ 0x00000004, /* ehostent */ 0x00000004, /* enetent */ 0x00000004, /* eprotoent */ 0x00000004, /* eservent */ 0x00001b00, /* gpwnam */ 0x00001b00, /* gpwuid */ 0x00000000, /* gpwent */ 0x00000004, /* spwent */ 0x00000004, /* epwent */ 0x00001b00, /* ggrnam */ 0x00001b00, /* ggrgid */ 0x00000000, /* ggrent */ 0x00000004, /* sgrent */ 0x00000004, /* egrent */ 0x0000000c, /* getlogin */ 0x0002140d, /* syscall */ 0x00007b04, /* lock */ 0x00000300, /* once */ 0x00000000, /* custom */ 0x00001b00, /* reach */ 0x00001b08, /* rkeys */ 0x00001b08, /* rvalues */ 0x00000600, /* coreargs */ 0x00000004, /* runcv */ 0x00009b8e, /* fc */ }; #endif #endif /* !PERL_GLOBAL_STRUCT_INIT */ END_EXTERN_C /* ex: set ro: */ PKZEXTERN.hnuW+A/* EXTERN.h * * Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999, * 2000, 2001, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * EXT designates a global var which is defined in perl.h * dEXT designates a global var which is defined in another * file, so we can't count on finding it in perl.h * (this practice should be avoided). */ #undef EXT #undef dEXT #undef EXTCONST #undef dEXTCONST #if defined(VMS) && !defined(__GNUC__) /* Suppress portability warnings from DECC for VMS-specific extensions */ # ifdef __DECC # pragma message disable (GLOBALEXT,NOSHAREEXT,READONLYEXT) # endif # define EXT globalref # define dEXT globaldef {"$GLOBAL_RW_VARS"} noshare # define EXTCONST globalref # define dEXTCONST globaldef {"$GLOBAL_RO_VARS"} readonly #else # if (defined(WIN32) || defined(__SYMBIAN32__)) && !defined(PERL_STATIC_SYMS) # if defined(PERLDLL) || defined(__SYMBIAN32__) # define EXT extern __declspec(dllexport) # define dEXT # define EXTCONST extern __declspec(dllexport) const # define dEXTCONST const # else # define EXT extern __declspec(dllimport) # define dEXT # define EXTCONST extern __declspec(dllimport) const # define dEXTCONST const # endif # else # if defined(__CYGWIN__) && defined(USEIMPORTLIB) # define EXT extern __declspec(dllimport) # define dEXT # define EXTCONST extern __declspec(dllimport) const # define dEXTCONST const # else # define EXT extern # define dEXT # define EXTCONST extern const # define dEXTCONST const # endif # endif #endif #undef INIT #define INIT(x) #undef DOINIT PKZ warnings.hnuW+A/* -*- buffer-read-only: t -*- !!!!!!! DO NOT EDIT THIS FILE !!!!!!! This file is built by regen/warnings.pl. Any changes made here will be lost! */ #define Off(x) ((x) / 8) #define Bit(x) (1 << ((x) % 8)) #define IsSet(a, x) ((a)[Off(x)] & Bit(x)) #define G_WARN_OFF 0 /* $^W == 0 */ #define G_WARN_ON 1 /* -w flag and $^W != 0 */ #define G_WARN_ALL_ON 2 /* -W flag */ #define G_WARN_ALL_OFF 4 /* -X flag */ #define G_WARN_ONCE 8 /* set if 'once' ever enabled */ #define G_WARN_ALL_MASK (G_WARN_ALL_ON|G_WARN_ALL_OFF) #define pWARN_STD NULL #define pWARN_ALL (((STRLEN*)0)+1) /* use warnings 'all' */ #define pWARN_NONE (((STRLEN*)0)+2) /* no warnings 'all' */ #define specialWARN(x) ((x) == pWARN_STD || (x) == pWARN_ALL || \ (x) == pWARN_NONE) /* if PL_warnhook is set to this value, then warnings die */ #define PERL_WARNHOOK_FATAL (&PL_sv_placeholder) /* Warnings Categories added in Perl 5.008 */ #define WARN_ALL 0 #define WARN_CLOSURE 1 #define WARN_DEPRECATED 2 #define WARN_EXITING 3 #define WARN_GLOB 4 #define WARN_IO 5 #define WARN_CLOSED 6 #define WARN_EXEC 7 #define WARN_LAYER 8 #define WARN_NEWLINE 9 #define WARN_PIPE 10 #define WARN_UNOPENED 11 #define WARN_MISC 12 #define WARN_NUMERIC 13 #define WARN_ONCE 14 #define WARN_OVERFLOW 15 #define WARN_PACK 16 #define WARN_PORTABLE 17 #define WARN_RECURSION 18 #define WARN_REDEFINE 19 #define WARN_REGEXP 20 #define WARN_SEVERE 21 #define WARN_DEBUGGING 22 #define WARN_INPLACE 23 #define WARN_INTERNAL 24 #define WARN_MALLOC 25 #define WARN_SIGNAL 26 #define WARN_SUBSTR 27 #define WARN_SYNTAX 28 #define WARN_AMBIGUOUS 29 #define WARN_BAREWORD 30 #define WARN_DIGIT 31 #define WARN_PARENTHESIS 32 #define WARN_PRECEDENCE 33 #define WARN_PRINTF 34 #define WARN_PROTOTYPE 35 #define WARN_QW 36 #define WARN_RESERVED 37 #define WARN_SEMICOLON 38 #define WARN_TAINT 39 #define WARN_THREADS 40 #define WARN_UNINITIALIZED 41 #define WARN_UNPACK 42 #define WARN_UNTIE 43 #define WARN_UTF8 44 #define WARN_VOID 45 /* Warnings Categories added in Perl 5.011 */ #define WARN_IMPRECISION 46 #define WARN_ILLEGALPROTO 47 /* Warnings Categories added in Perl 5.013 */ #define WARN_NON_UNICODE 48 #define WARN_NONCHAR 49 #define WARN_SURROGATE 50 #define WARNsize 13 #define WARN_ALLstring "\125\125\125\125\125\125\125\125\125\125\125\125\125" #define WARN_NONEstring "\0\0\0\0\0\0\0\0\0\0\0\0\0" #define isLEXWARN_on (PL_curcop->cop_warnings != pWARN_STD) #define isLEXWARN_off (PL_curcop->cop_warnings == pWARN_STD) #define isWARN_ONCE (PL_dowarn & (G_WARN_ON|G_WARN_ONCE)) #define isWARN_on(c,x) (IsSet((U8 *)(c + 1), 2*(x))) #define isWARNf_on(c,x) (IsSet((U8 *)(c + 1), 2*(x)+1)) #define DUP_WARNINGS(p) \ (specialWARN(p) ? (STRLEN*)(p) \ : (STRLEN*)CopyD(p, PerlMemShared_malloc(sizeof(*p)+*p), sizeof(*p)+*p, \ char)) #define ckWARN(w) Perl_ckwarn(aTHX_ packWARN(w)) #define ckWARN2(w1,w2) Perl_ckwarn(aTHX_ packWARN2(w1,w2)) #define ckWARN3(w1,w2,w3) Perl_ckwarn(aTHX_ packWARN3(w1,w2,w3)) #define ckWARN4(w1,w2,w3,w4) Perl_ckwarn(aTHX_ packWARN4(w1,w2,w3,w4)) #define ckWARN_d(w) Perl_ckwarn_d(aTHX_ packWARN(w)) #define ckWARN2_d(w1,w2) Perl_ckwarn_d(aTHX_ packWARN2(w1,w2)) #define ckWARN3_d(w1,w2,w3) Perl_ckwarn_d(aTHX_ packWARN3(w1,w2,w3)) #define ckWARN4_d(w1,w2,w3,w4) Perl_ckwarn_d(aTHX_ packWARN4(w1,w2,w3,w4)) #define WARNshift 8 #define packWARN(a) (a ) #define packWARN2(a,b) ((a) | ((b)<<8) ) #define packWARN3(a,b,c) ((a) | ((b)<<8) | ((c)<<16) ) #define packWARN4(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d) <<24)) #define unpackWARN1(x) ((x) & 0xFF) #define unpackWARN2(x) (((x) >>8) & 0xFF) #define unpackWARN3(x) (((x) >>16) & 0xFF) #define unpackWARN4(x) (((x) >>24) & 0xFF) #define ckDEAD(x) \ ( ! specialWARN(PL_curcop->cop_warnings) && \ ( isWARNf_on(PL_curcop->cop_warnings, WARN_ALL) || \ isWARNf_on(PL_curcop->cop_warnings, unpackWARN1(x)) || \ isWARNf_on(PL_curcop->cop_warnings, unpackWARN2(x)) || \ isWARNf_on(PL_curcop->cop_warnings, unpackWARN3(x)) || \ isWARNf_on(PL_curcop->cop_warnings, unpackWARN4(x)))) /* end of file warnings.h */ /* ex: set ro: */ PKZI=33pad.hnuW+A/* pad.h * * Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008, * 2009, 2010, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * This file defines the types and macros associated with the API for * manipulating scratchpads, which are used by perl to store lexical * variables, op targets and constants. */ /* =head1 Pad Data Structures */ /* a padlist is currently just an AV; but that might change, * so hide the type. Ditto a pad. */ typedef AV PADLIST; typedef AV PAD; /* offsets within a pad */ #if PTRSIZE == 4 typedef U32TYPE PADOFFSET; #else # if PTRSIZE == 8 typedef U64TYPE PADOFFSET; # endif #endif #define NOT_IN_PAD ((PADOFFSET) -1) /* a value that PL_cop_seqmax is guaranteed never to be, * flagging that a lexical is being introduced, or has not yet left scope */ #define PERL_PADSEQ_INTRO U32_MAX /* B.xs needs these for the benefit of B::Deparse */ /* Low range end is exclusive (valid from the cop seq after this one) */ /* High range end is inclusive (valid up to this cop seq) */ #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define COP_SEQ_RANGE_LOW(sv) \ (({ const SV *const _sv_cop_seq_range_low = (const SV *) (sv); \ assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV \ || SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV); \ assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV); \ assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV); \ assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV); \ assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM); \ assert(!isGV_with_GP(_sv_cop_seq_range_low)); \ ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_low)))->xnv_u.xpad_cop_seq.xlow; \ })) # define COP_SEQ_RANGE_HIGH(sv) \ (({ const SV *const _sv_cop_seq_range_high = (const SV *) (sv); \ assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV \ || SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV); \ assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV); \ assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV); \ assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV); \ assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM); \ assert(!isGV_with_GP(_sv_cop_seq_range_high)); \ ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_high)))->xnv_u.xpad_cop_seq.xhigh; \ })) # define PARENT_PAD_INDEX(sv) \ (({ const SV *const _sv_parent_pad_index = (const SV *) (sv); \ assert(SvTYPE(_sv_parent_pad_index) == SVt_NV \ || SvTYPE(_sv_parent_pad_index) >= SVt_PVNV); \ assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV); \ assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV); \ assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV); \ assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM); \ assert(!isGV_with_GP(_sv_parent_pad_index)); \ ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_pad_index)))->xnv_u.xpad_cop_seq.xlow; \ })) # define PARENT_FAKELEX_FLAGS(sv) \ (({ const SV *const _sv_parent_fakelex_flags = (const SV *) (sv); \ assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV \ || SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV); \ assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV); \ assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV); \ assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV); \ assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM); \ assert(!isGV_with_GP(_sv_parent_fakelex_flags)); \ ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_fakelex_flags)))->xnv_u.xpad_cop_seq.xhigh; \ })) #else # define COP_SEQ_RANGE_LOW(sv) \ (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow)) # define COP_SEQ_RANGE_HIGH(sv) \ (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh)) # define PARENT_PAD_INDEX(sv) \ (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow)) # define PARENT_FAKELEX_FLAGS(sv) \ (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh)) #endif /* Flags set in the SvIVX field of FAKE namesvs */ #define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */ #define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */ /* flags for the pad_new() function */ #define padnew_CLONE 1 /* this pad is for a cloned CV */ #define padnew_SAVE 2 /* save old globals */ #define padnew_SAVESUB 4 /* also save extra stuff for start of sub */ /* values for the pad_tidy() function */ typedef enum { padtidy_SUB, /* tidy up a pad for a sub, */ padtidy_SUBCLONE, /* a cloned sub, */ padtidy_FORMAT /* or a format */ } padtidy_type; /* flags for pad_add_name_pvn. */ #define padadd_OUR 0x01 /* our declaration. */ #define padadd_STATE 0x02 /* state declaration. */ #define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */ #define padadd_UTF8_NAME SVf_UTF8 /* name is UTF-8 encoded. */ /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine * whether PL_comppad and PL_curpad are consistent and whether they have * active values */ #ifndef PERL_MAD # define pad_peg(label) #endif #ifdef DEBUGGING # define ASSERT_CURPAD_LEGAL(label) \ pad_peg(label); \ if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \ Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%"UVxf"[0x%"UVxf"]",\ label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); # define ASSERT_CURPAD_ACTIVE(label) \ pad_peg(label); \ if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \ Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%"UVxf"[0x%"UVxf"]",\ label, PTR2UV(PL_comppad), PTR2UV(PL_curpad)); #else # define ASSERT_CURPAD_LEGAL(label) # define ASSERT_CURPAD_ACTIVE(label) #endif /* Note: the following three macros are actually defined in scope.h, but * they are documented here for completeness, since they directly or * indirectly affect pads. =for apidoc m|void|SAVEPADSV |PADOFFSET po Save a pad slot (used to restore after an iteration) XXX DAPM it would make more sense to make the arg a PADOFFSET =for apidoc m|void|SAVECLEARSV |SV **svp Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my') =for apidoc m|void|SAVECOMPPAD save PL_comppad and PL_curpad =for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv Set the slot at offset C in the current pad to C =for apidoc m|void|PAD_SV |PADOFFSET po Get the value at offset C in the current pad =for apidoc m|SV *|PAD_SVl |PADOFFSET po Lightweight and lvalue version of C. Get or set the value at offset C in the current pad. Unlike C, does not print diagnostics with -DX. For internal use only. =for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po Get the value from slot C in the base (DEPTH=1) pad of a padlist =for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n Set the current pad to be pad C in the padlist, saving the previous current pad. NB currently this macro expands to a string too long for some compilers, so it's best to replace it with SAVECOMPPAD(); PAD_SET_CUR_NOSAVE(padlist,n); =for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n like PAD_SET_CUR, but without the save =for apidoc m|void|PAD_SAVE_SETNULLPAD Save the current pad then set it to null. =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad Save the current pad to the local variable opad, then make the current pad equal to npad =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL() =cut */ #ifdef DEBUGGING # define PAD_SV(po) pad_sv(po) # define PAD_SETSV(po,sv) pad_setsv(po,sv) #else # define PAD_SV(po) (PL_curpad[po]) # define PAD_SETSV(po,sv) PL_curpad[po] = (sv) #endif #define PAD_SVl(po) (PL_curpad[po]) #define PAD_BASE_SV(padlist, po) \ (AvARRAY(padlist)[1]) \ ? AvARRAY(MUTABLE_AV((AvARRAY(padlist)[1])))[po] : NULL; #define PAD_SET_CUR_NOSAVE(padlist,nth) \ PL_comppad = (PAD*) (AvARRAY(padlist)[nth]); \ PL_curpad = AvARRAY(PL_comppad); \ DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ "Pad 0x%"UVxf"[0x%"UVxf"] set_cur depth=%d\n", \ PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth))); #define PAD_SET_CUR(padlist,nth) \ SAVECOMPPAD(); \ PAD_SET_CUR_NOSAVE(padlist,nth); #define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \ PL_comppad = NULL; PL_curpad = NULL; \ DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n")); #define PAD_SAVE_LOCAL(opad,npad) \ opad = PL_comppad; \ PL_comppad = (npad); \ PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ "Pad 0x%"UVxf"[0x%"UVxf"] save_local\n", \ PTR2UV(PL_comppad), PTR2UV(PL_curpad))); #define PAD_RESTORE_LOCAL(opad) \ assert(!opad || !SvIS_FREED(opad)); \ PL_comppad = opad; \ PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ DEBUG_Xv(PerlIO_printf(Perl_debug_log, \ "Pad 0x%"UVxf"[0x%"UVxf"] restore_local\n", \ PTR2UV(PL_comppad), PTR2UV(PL_curpad))); /* =for apidoc m|void|CX_CURPAD_SAVE|struct context Save the current pad in the given context block structure. =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po Access the SV at offset po in the saved current pad in the given context block structure (can be used as an lvalue). =cut */ #define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po]) /* =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po Return the flags for the current compiling pad name at offset C. Assumes a valid slot entry. =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po Return the name of the current compiling pad name at offset C. Assumes a valid slot entry. =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po Return the type (stash) of the current compiling pad name at offset C. Must be a valid name. Returns null if not typed. =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po Return the stash associated with an C variable. Assumes the slot entry is a valid C lexical. =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po The generation number of the name at offset C in the current compiling pad (lvalue). Note that C is hijacked for this purpose. =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen Sets the generation number of the name at offset C in the current ling pad (lvalue) to C. Note that C is hijacked for this purpose. =cut */ #define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE)) #define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po)) #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po)) #define PAD_COMPNAME_PV(po) SvPV_nolen(PAD_COMPNAME_SV(po)) #define PAD_COMPNAME_TYPE(po) pad_compname_type(po) #define PAD_COMPNAME_OURSTASH(po) \ (SvOURSTASH(PAD_COMPNAME_SV(po))) #define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po])) #define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen)) /* =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param Clone the state variables associated with running and compiling pads. =cut */ /* NB - we set PL_comppad to null unless it points at a value that * has already been dup'ed, ie it points to part of an active padlist. * Otherwise PL_comppad ends up being a leaked scalar in code like * the following: * threads->create(sub { threads->create(sub {...} ) } ); * where the second thread dups the outer sub's comppad but not the * sub's CV or padlist. */ #define PAD_CLONE_VARS(proto_perl, param) \ PL_comppad = av_dup(proto_perl->Icomppad, param); \ PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \ PL_comppad_name = av_dup(proto_perl->Icomppad_name, param); \ PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \ PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \ PL_min_intro_pending = proto_perl->Imin_intro_pending; \ PL_max_intro_pending = proto_perl->Imax_intro_pending; \ PL_padix = proto_perl->Ipadix; \ PL_padix_floor = proto_perl->Ipadix_floor; \ PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \ PL_cop_seqmax = proto_perl->Icop_seqmax; /* =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash Exactly like L, but takes a literal string instead of a string/length pair. =cut */ #define pad_add_name_pvs(name,flags,typestash,ourstash) \ Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash) /* =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags Exactly like L, but takes a literal string instead of a string/length pair. =cut */ #define pad_findmy_pvs(name,flags) \ Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZU^;?!! perlvars.hnuW+A/* perlvars.h * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, * by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* =head1 Global Variables These variables are global to an entire process. They are shared between all interpreters and all threads in a process. =cut */ /* Don't forget to re-run regen/embed.pl to propagate changes! */ /* This file describes the "global" variables used by perl * This used to be in perl.h directly but we want to abstract out into * distinct files which are per-thread, per-interpreter or really global, * and how they're initialized. * * The 'G' prefix is only needed for vars that need appropriate #defines * generated in embed*.h. Such symbols are also used to generate * the appropriate export list for win32. */ /* global state */ #if defined(USE_ITHREADS) PERLVAR(G, op_mutex, perl_mutex) /* Mutex for op refcounting */ #endif PERLVAR(G, curinterp, PerlInterpreter *) /* currently running interpreter * (initial parent interpreter under * useithreads) */ #if defined(USE_ITHREADS) PERLVAR(G, thr_key, perl_key) /* key to retrieve per-thread struct */ #endif /* XXX does anyone even use this? */ PERLVARI(G, do_undump, bool, FALSE) /* -u or dump seen? */ #ifndef PERL_USE_SAFE_PUTENV PERLVARI(G, use_safe_putenv, bool, TRUE) #endif #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS) PERLVARI(G, sig_handlers_initted, int, 0) #endif #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS PERLVARA(G, sig_ignoring, SIG_SIZE, int) /* which signals we are ignoring */ #endif #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS PERLVARA(G, sig_defaulting, SIG_SIZE, int) #endif /* XXX signals are process-wide anyway, so we * ignore the implications of this for threading */ #ifndef HAS_SIGACTION PERLVARI(G, sig_trapped, int, 0) #endif #ifndef PERL_MICRO /* If Perl has to ignore SIGPFE, this is its saved state. * See perl.h macros PERL_FPU_INIT and PERL_FPU_{PRE,POST}_EXEC. */ PERLVAR(G, sigfpe_saved, Sighandler_t) PERLVARI(G, csighandlerp, Sighandler_t, Perl_csighandler) /* Pointer to C-level sighandler */ #endif /* This is constant on most architectures, a global on OS/2 */ #ifdef OS2 PERLVARI(G, sh_path, char *, SH_PATH) /* full path of shell */ #endif #ifdef USE_PERLIO # if defined(USE_ITHREADS) PERLVAR(G, perlio_mutex, perl_mutex) /* Mutex for perlio fd refcounts */ # endif PERLVARI(G, perlio_fd_refcnt, int *, 0) /* Pointer to array of fd refcounts. */ PERLVARI(G, perlio_fd_refcnt_size, int, 0) /* Size of the array */ PERLVARI(G, perlio_debug_fd, int, 0) /* the fd to write perlio debug into, 0 means not set yet */ #endif #ifdef HAS_MMAP PERLVARI(G, mmap_page_size, IV, 0) #endif #if defined(USE_ITHREADS) PERLVAR(G, hints_mutex, perl_mutex) /* Mutex for refcounted he refcounting */ #endif #ifdef DEBUGGING PERLVAR(G, watch_pvx, char *) #endif /* =for apidoc AmU|Perl_check_t *|PL_check Array, indexed by opcode, of functions that will be called for the "check" phase of optree building during compilation of Perl code. For most (but not all) types of op, once the op has been initially built and populated with child ops it will be filtered through the check function referenced by the appropriate element of this array. The new op is passed in as the sole argument to the check function, and the check function returns the completed op. The check function may (as the name suggests) check the op for validity and signal errors. It may also initialise or modify parts of the ops, or perform more radical surgery such as adding or removing child ops, or even throw the op away and return a different op in its place. This array of function pointers is a convenient place to hook into the compilation process. An XS module can put its own custom check function in place of any of the standard ones, to influence the compilation of a particular type of op. However, a custom check function must never fully replace a standard check function (or even a custom check function from another module). A module modifying checking must instead B the preexisting check function. A custom check function must be selective about when to apply its custom behaviour. In the usual case where it decides not to do anything special with an op, it must chain the preexisting op function. Check functions are thus linked in a chain, with the core's base checker at the end. For thread safety, modules should not write directly to this array. Instead, use the function L. =cut */ #if defined(USE_ITHREADS) PERLVAR(G, check_mutex, perl_mutex) /* Mutex for PL_check */ #endif #ifdef PERL_GLOBAL_STRUCT PERLVAR(G, ppaddr, Perl_ppaddr_t *) /* or opcode.h */ PERLVAR(G, check, Perl_check_t *) /* or opcode.h */ PERLVARA(G, fold_locale, 256, unsigned char) /* or perl.h */ #endif #ifdef PERL_NEED_APPCTX PERLVAR(G, appctx, void*) /* the application context */ #endif #if defined(HAS_TIMES) && defined(PERL_NEED_TIMESBASE) PERLVAR(G, timesbase, struct tms) #endif /* allocate a unique index to every module that calls MY_CXT_INIT */ #ifdef PERL_IMPLICIT_CONTEXT # ifdef USE_ITHREADS PERLVAR(G, my_ctx_mutex, perl_mutex) # endif PERLVARI(G, my_cxt_index, int, 0) #endif /* this is currently set without MUTEX protection, so keep it a type which * can be set atomically (ie not a bit field) */ PERLVARI(G, veto_cleanup, int, FALSE) /* exit without cleanup */ /* =for apidoc AmUx|Perl_keyword_plugin_t|PL_keyword_plugin Function pointer, pointing at a function used to handle extended keywords. The function should be declared as int keyword_plugin_function(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr) The function is called from the tokeniser, whenever a possible keyword is seen. C points at the word in the parser's input buffer, and C gives its length; it is not null-terminated. The function is expected to examine the word, and possibly other state such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it as an extended keyword. If it does not, the function should return C, and the normal parser process will continue. If the function wants to handle the keyword, it first must parse anything following the keyword that is part of the syntax introduced by the keyword. See L for details. When a keyword is being handled, the plugin function must build a tree of C structures, representing the code that was parsed. The root of the tree must be stored in C<*op_ptr>. The function then returns a constant indicating the syntactic role of the construct that it has parsed: C if it is a complete statement, or C if it is an expression. Note that a statement construct cannot be used inside an expression (except via C and similar), and an expression is not a complete statement (it requires at least a terminating semicolon). When a keyword is handled, the plugin function may also have (compile-time) side effects. It may modify C<%^H>, define functions, and so on. Typically, if side effects are the main purpose of a handler, it does not wish to generate any ops to be included in the normal compilation. In this case it is still required to supply an op tree, but it suffices to generate a single null op. That's how the C<*PL_keyword_plugin> function needs to behave overall. Conventionally, however, one does not completely replace the existing handler function. Instead, take a copy of C before assigning your own function pointer to it. Your handler function should look for keywords that it is interested in and handle those. Where it is not interested, it should call the saved plugin function, passing on the arguments it received. Thus C actually points at a chain of handler functions, all of which have an opportunity to handle keywords, and only the last function in the chain (built into the Perl core) will normally return C. =cut */ PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard) PERLVAR(G, op_sequence, HV *) /* dump.c */ PERLVARI(G, op_seq, UV, 0) /* dump.c */ #ifdef USE_ITHREADS PERLVAR(G, dollarzero_mutex, perl_mutex) /* Modifying $0 */ #endif /* Restricted hashes placeholder value. * The contents are never used, only the address. */ PERLVAR(G, sv_placeholder, SV) #if defined(MYMALLOC) && defined(USE_ITHREADS) PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */ #endif PKZl instead) =head1 Array Manipulation Functions =for apidoc Am|int|AvFILL|AV* av Same as C. Deprecated, use C instead. =cut */ #ifndef PERL_CORE # define Nullav Null(AV*) #endif #define AvARRAY(av) ((av)->sv_u.svu_array) #define AvALLOC(av) ((XPVAV*) SvANY(av))->xav_alloc #define AvMAX(av) ((XPVAV*) SvANY(av))->xav_max #define AvFILLp(av) ((XPVAV*) SvANY(av))->xav_fill #define AvARYLEN(av) (*Perl_av_arylen_p(aTHX_ MUTABLE_AV(av))) #define AvREAL(av) (SvFLAGS(av) & SVpav_REAL) #define AvREAL_on(av) (SvFLAGS(av) |= SVpav_REAL) #define AvREAL_off(av) (SvFLAGS(av) &= ~SVpav_REAL) #define AvREAL_only(av) (AvREIFY_off(av), SvFLAGS(av) |= SVpav_REAL) #define AvREIFY(av) (SvFLAGS(av) & SVpav_REIFY) #define AvREIFY_on(av) (SvFLAGS(av) |= SVpav_REIFY) #define AvREIFY_off(av) (SvFLAGS(av) &= ~SVpav_REIFY) #define AvREIFY_only(av) (AvREAL_off(av), SvFLAGS(av) |= SVpav_REIFY) #define AvREALISH(av) (SvFLAGS(av) & (SVpav_REAL|SVpav_REIFY)) #define AvFILL(av) ((SvRMAGICAL((const SV *) (av))) \ ? mg_size(MUTABLE_SV(av)) : AvFILLp(av)) #define NEGATIVE_INDICES_VAR "NEGATIVE_INDICES" /* =for apidoc newAV Creates a new AV. The reference count is set to 1. Perl equivalent: C. =cut */ #define newAV() MUTABLE_AV(newSV_type(SVt_PVAV)) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ$w w mg.hnuW+A/* mg.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, * 2000, 2002, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #ifdef STRUCT_MGVTBL_DEFINITION STRUCT_MGVTBL_DEFINITION; #else struct mgvtbl { int (*svt_get) (pTHX_ SV *sv, MAGIC* mg); int (*svt_set) (pTHX_ SV *sv, MAGIC* mg); U32 (*svt_len) (pTHX_ SV *sv, MAGIC* mg); int (*svt_clear)(pTHX_ SV *sv, MAGIC* mg); int (*svt_free) (pTHX_ SV *sv, MAGIC* mg); int (*svt_copy) (pTHX_ SV *sv, MAGIC* mg, SV *nsv, const char *name, I32 namlen); int (*svt_dup) (pTHX_ MAGIC *mg, CLONE_PARAMS *param); int (*svt_local)(pTHX_ SV *nsv, MAGIC *mg); }; #endif struct magic { MAGIC* mg_moremagic; MGVTBL* mg_virtual; /* pointer to magic functions */ U16 mg_private; char mg_type; U8 mg_flags; I32 mg_len; SV* mg_obj; char* mg_ptr; }; #define MGf_TAINTEDDIR 1 /* PERL_MAGIC_envelem only */ #define MGf_MINMATCH 1 /* PERL_MAGIC_regex_global only */ #define MGf_REFCOUNTED 2 #define MGf_GSKIP 4 /* skip further GETs until after next SET */ #define MGf_COPY 8 /* has an svt_copy MGVTBL entry */ #define MGf_DUP 0x10 /* has an svt_dup MGVTBL entry */ #define MGf_LOCAL 0x20 /* has an svt_local MGVTBL entry */ #define MgTAINTEDDIR(mg) (mg->mg_flags & MGf_TAINTEDDIR) #define MgTAINTEDDIR_on(mg) (mg->mg_flags |= MGf_TAINTEDDIR) #define MgTAINTEDDIR_off(mg) (mg->mg_flags &= ~MGf_TAINTEDDIR) #define MgPV(mg,lp) ((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ? \ SvPV(MUTABLE_SV((mg)->mg_ptr),lp) : \ (mg)->mg_ptr) #define MgPV_const(mg,lp) ((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ? \ SvPV_const(MUTABLE_SV((mg)->mg_ptr),lp) : \ (const char*)(mg)->mg_ptr) #define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \ SvPV_nolen_const(MUTABLE_SV((mg)->mg_ptr)) : \ (const char*)(mg)->mg_ptr) #define SvTIED_mg(sv,how) (SvRMAGICAL(sv) ? mg_find((sv),(how)) : NULL) #define SvTIED_obj(sv,mg) \ ((mg)->mg_obj ? (mg)->mg_obj : sv_2mortal(newRV(sv))) #define whichsig(pv) whichsig_pv(pv) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZVmg_raw.hnuW+A/* -*- buffer-read-only: t -*- * * mg_raw.h * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/mg_vtable.pl. * Any changes made here will be lost! */ { '\0', "want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE", "/* sv '\\0' Special scalar variable */" }, { '#', "want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC", "/* arylen '#' Array length ($#ary) */" }, { '%', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* rhash '%' extra data for restricted hashes */" }, { '.', "want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC", "/* pos '.' pos() lvalue */" }, { ':', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* symtab ':' extra data for symbol tables */" }, { '<', "want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* backref '<' for weak ref data */" }, { '@', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC", "/* arylen_p '@' to move arylen out of XPVAV */" }, { 'A', "want_vtbl_amagic", "/* overload 'A' %OVERLOAD hash */" }, { 'a', "want_vtbl_amagicelem", "/* overload_elem 'a' %OVERLOAD hash element */" }, { 'B', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* bm 'B' Boyer-Moore (fast string search) */" }, { 'c', "want_vtbl_ovrld", "/* overload_table 'c' Holds overload table (AMT) on stash */" }, { 'D', "want_vtbl_regdata", "/* regdata 'D' Regex match position data (@+ and @- vars) */" }, { 'd', "want_vtbl_regdatum", "/* regdatum 'd' Regex match position data element */" }, { 'E', "want_vtbl_env", "/* env 'E' %ENV hash */" }, { 'e', "want_vtbl_envelem", "/* envelem 'e' %ENV hash element */" }, { 'f', "want_vtbl_regdata | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* fm 'f' Formline ('compiled' format) */" }, { 'G', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* study 'G' study()ed string */" }, { 'g', "want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC", "/* regex_global 'g' m//g target */" }, { 'H', "want_vtbl_hints", "/* hints 'H' %^H hash */" }, { 'h', "want_vtbl_hintselem", "/* hintselem 'h' %^H hash element */" }, { 'I', "want_vtbl_isa", "/* isa 'I' @ISA array */" }, { 'i', "want_vtbl_isaelem", "/* isaelem 'i' @ISA array element */" }, { 'k', "want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC", "/* nkeys 'k' scalar(keys()) lvalue */" }, { 'L', "magic_vtable_max", "/* dbfile 'L' Debugger %_. */ #ifndef PERL_REENTR_API # if defined(PERL_CORE) || defined(PERL_EXT) # define PERL_REENTR_API 1 # else # define PERL_REENTR_API 0 # endif #endif #ifdef USE_REENTRANT_API /* Deprecations: some platforms have the said reentrant interfaces * but they are declared obsolete and are not to be used. Often this * means that the platform has threadsafed the interfaces (hopefully). * All this is OS version dependent, so we are of course fooling ourselves. * If you know of more deprecations on some platforms, please add your own * (by editing reentr.pl, mind!) */ #ifdef __hpux # undef HAS_CRYPT_R # undef HAS_DRAND48_R # undef HAS_ENDGRENT_R # undef HAS_ENDPWENT_R # undef HAS_GETGRENT_R # undef HAS_GETPWENT_R # undef HAS_SETLOCALE_R # undef HAS_SRAND48_R # undef HAS_STRERROR_R # define NETDB_R_OBSOLETE #endif #if defined(__osf__) && defined(__alpha) /* Tru64 aka Digital UNIX */ # undef HAS_CRYPT_R # undef HAS_STRERROR_R # define NETDB_R_OBSOLETE #endif /* * As of OpenBSD 3.7, reentrant functions are now working, they just are * incompatible with everyone else. To make OpenBSD happy, we have to * memzero out certain structures before calling the functions. */ #if defined(__OpenBSD__) # define REENTR_MEMZERO(a,b) memzero(a,b) #else # define REENTR_MEMZERO(a,b) 0 #endif #ifdef NETDB_R_OBSOLETE # undef HAS_ENDHOSTENT_R # undef HAS_ENDNETENT_R # undef HAS_ENDPROTOENT_R # undef HAS_ENDSERVENT_R # undef HAS_GETHOSTBYADDR_R # undef HAS_GETHOSTBYNAME_R # undef HAS_GETHOSTENT_R # undef HAS_GETNETBYADDR_R # undef HAS_GETNETBYNAME_R # undef HAS_GETNETENT_R # undef HAS_GETPROTOBYNAME_R # undef HAS_GETPROTOBYNUMBER_R # undef HAS_GETPROTOENT_R # undef HAS_GETSERVBYNAME_R # undef HAS_GETSERVBYPORT_R # undef HAS_GETSERVENT_R # undef HAS_SETHOSTENT_R # undef HAS_SETNETENT_R # undef HAS_SETPROTOENT_R # undef HAS_SETSERVENT_R #endif #ifdef I_PWD # include #endif #ifdef I_GRP # include #endif #ifdef I_NETDB # include #endif #ifdef I_STDLIB # include /* drand48_data */ #endif #ifdef I_CRYPT # ifdef I_CRYPT # include # endif #endif #ifdef HAS_GETSPNAM_R # ifdef I_SHADOW # include # endif #endif #define REENTRANT_PROTO_B_B 1 #define REENTRANT_PROTO_B_BI 2 #define REENTRANT_PROTO_B_BW 3 #define REENTRANT_PROTO_B_CCD 4 #define REENTRANT_PROTO_B_CCS 5 #define REENTRANT_PROTO_B_IBI 6 #define REENTRANT_PROTO_B_IBW 7 #define REENTRANT_PROTO_B_SB 8 #define REENTRANT_PROTO_B_SBI 9 #define REENTRANT_PROTO_I_BI 10 #define REENTRANT_PROTO_I_BW 11 #define REENTRANT_PROTO_I_CCSBWR 12 #define REENTRANT_PROTO_I_CCSD 13 #define REENTRANT_PROTO_I_CII 14 #define REENTRANT_PROTO_I_CIISD 15 #define REENTRANT_PROTO_I_CSBI 16 #define REENTRANT_PROTO_I_CSBIR 17 #define REENTRANT_PROTO_I_CSBWR 18 #define REENTRANT_PROTO_I_CSBWRE 19 #define REENTRANT_PROTO_I_CSD 20 #define REENTRANT_PROTO_I_CWISBWRE 21 #define REENTRANT_PROTO_I_CWISD 22 #define REENTRANT_PROTO_I_D 23 #define REENTRANT_PROTO_I_H 24 #define REENTRANT_PROTO_I_IBI 25 #define REENTRANT_PROTO_I_IBW 26 #define REENTRANT_PROTO_I_ICBI 27 #define REENTRANT_PROTO_I_ICSBWR 28 #define REENTRANT_PROTO_I_ICSD 29 #define REENTRANT_PROTO_I_ID 30 #define REENTRANT_PROTO_I_IISD 31 #define REENTRANT_PROTO_I_ISBWR 32 #define REENTRANT_PROTO_I_ISD 33 #define REENTRANT_PROTO_I_LISBI 34 #define REENTRANT_PROTO_I_LISD 35 #define REENTRANT_PROTO_I_LS 36 #define REENTRANT_PROTO_I_SB 37 #define REENTRANT_PROTO_I_SBI 38 #define REENTRANT_PROTO_I_SBIE 39 #define REENTRANT_PROTO_I_SBIH 40 #define REENTRANT_PROTO_I_SBIR 41 #define REENTRANT_PROTO_I_SBWR 42 #define REENTRANT_PROTO_I_SBWRE 43 #define REENTRANT_PROTO_I_SD 44 #define REENTRANT_PROTO_I_ST 45 #define REENTRANT_PROTO_I_St 46 #define REENTRANT_PROTO_I_TISD 47 #define REENTRANT_PROTO_I_TS 48 #define REENTRANT_PROTO_I_TSBI 49 #define REENTRANT_PROTO_I_TSBIR 50 #define REENTRANT_PROTO_I_TSBWR 51 #define REENTRANT_PROTO_I_TSR 52 #define REENTRANT_PROTO_I_TsISBWRE 53 #define REENTRANT_PROTO_I_UISBWRE 54 #define REENTRANT_PROTO_I_iS 55 #define REENTRANT_PROTO_I_lS 56 #define REENTRANT_PROTO_I_uISBWRE 57 #define REENTRANT_PROTO_S_CBI 58 #define REENTRANT_PROTO_S_CCSBI 59 #define REENTRANT_PROTO_S_CIISBIE 60 #define REENTRANT_PROTO_S_CSBI 61 #define REENTRANT_PROTO_S_CSBIE 62 #define REENTRANT_PROTO_S_CWISBIE 63 #define REENTRANT_PROTO_S_CWISBWIE 64 #define REENTRANT_PROTO_S_ICSBI 65 #define REENTRANT_PROTO_S_ISBI 66 #define REENTRANT_PROTO_S_LISBI 67 #define REENTRANT_PROTO_S_SBI 68 #define REENTRANT_PROTO_S_SBIE 69 #define REENTRANT_PROTO_S_SBW 70 #define REENTRANT_PROTO_S_TISBI 71 #define REENTRANT_PROTO_S_TSBI 72 #define REENTRANT_PROTO_S_TSBIE 73 #define REENTRANT_PROTO_S_TWISBIE 74 #define REENTRANT_PROTO_V_D 75 #define REENTRANT_PROTO_V_H 76 #define REENTRANT_PROTO_V_ID 77 /* Defines for indicating which special features are supported. */ /* The getgrent getgrgid getgrnam using buffer? */ #if defined(HAS_GETGRENT_R) && (GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIR || GETGRENT_R_PROTO == REENTRANT_PROTO_S_SBW || GETGRENT_R_PROTO == REENTRANT_PROTO_S_SBI || GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBI || GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIH) # define GETGRENT_R_HAS_BUFFER #else # undef GETGRENT_R_HAS_BUFFER #endif #if defined(HAS_GETGRGID_R) && (GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBWR || GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBIR || GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBI || GETGRGID_R_PROTO == REENTRANT_PROTO_S_TSBI) # define GETGRGID_R_HAS_BUFFER #else # undef GETGRGID_R_HAS_BUFFER #endif #if defined(HAS_GETGRNAM_R) && (GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR || GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR || GETGRNAM_R_PROTO == REENTRANT_PROTO_S_CBI || GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBI || GETGRNAM_R_PROTO == REENTRANT_PROTO_S_CSBI) # define GETGRNAM_R_HAS_BUFFER #else # undef GETGRNAM_R_HAS_BUFFER #endif /* Any of the getgrent getgrgid getgrnam using buffer? */ #if (defined(GETGRENT_R_HAS_BUFFER) || defined(GETGRGID_R_HAS_BUFFER) || defined(GETGRNAM_R_HAS_BUFFER)) # define USE_GRENT_BUFFER #else # undef USE_GRENT_BUFFER #endif /* The getgrent getgrgid getgrnam using ptr? */ #if defined(HAS_GETGRENT_R) && (GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIR) # define GETGRENT_R_HAS_PTR #else # undef GETGRENT_R_HAS_PTR #endif #if defined(HAS_GETGRGID_R) && (GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBWR || GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBIR) # define GETGRGID_R_HAS_PTR #else # undef GETGRGID_R_HAS_PTR #endif #if defined(HAS_GETGRNAM_R) && (GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR || GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR) # define GETGRNAM_R_HAS_PTR #else # undef GETGRNAM_R_HAS_PTR #endif /* Any of the getgrent getgrgid getgrnam using ptr? */ #if (defined(GETGRENT_R_HAS_PTR) || defined(GETGRGID_R_HAS_PTR) || defined(GETGRNAM_R_HAS_PTR)) # define USE_GRENT_PTR #else # undef USE_GRENT_PTR #endif /* The getpwent getpwnam getpwuid using ptr? */ #if defined(HAS_GETPWENT_R) && (GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIR) # define GETPWENT_R_HAS_PTR #else # undef GETPWENT_R_HAS_PTR #endif #if defined(HAS_GETPWNAM_R) && (GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR || GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR) # define GETPWNAM_R_HAS_PTR #else # undef GETPWNAM_R_HAS_PTR #endif #if defined(HAS_GETPWUID_R) && (GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBWR || GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBIR) # define GETPWUID_R_HAS_PTR #else # undef GETPWUID_R_HAS_PTR #endif /* Any of the getpwent getpwnam getpwuid using ptr? */ #if (defined(GETPWENT_R_HAS_PTR) || defined(GETPWNAM_R_HAS_PTR) || defined(GETPWUID_R_HAS_PTR)) # define USE_PWENT_PTR #else # undef USE_PWENT_PTR #endif /* The getspent getspnam using ptr? */ #if defined(HAS_GETSPNAM_R) && (GETSPNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR) # define GETSPNAM_R_HAS_PTR #else # undef GETSPNAM_R_HAS_PTR #endif /* Any of the getspent getspnam using ptr? */ #if (defined(GETSPENT_R_HAS_PTR) || defined(GETSPNAM_R_HAS_PTR)) # define USE_SPENT_PTR #else # undef USE_SPENT_PTR #endif /* The getgrent getgrgid getgrnam setgrent endgrent using fptr? */ #if defined(HAS_GETGRENT_R) && (GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIH) # define GETGRENT_R_HAS_FPTR #else # undef GETGRENT_R_HAS_FPTR #endif #if defined(HAS_SETGRENT_R) && (SETGRENT_R_PROTO == REENTRANT_PROTO_I_H || SETGRENT_R_PROTO == REENTRANT_PROTO_V_H) # define SETGRENT_R_HAS_FPTR #else # undef SETGRENT_R_HAS_FPTR #endif #if defined(HAS_ENDGRENT_R) && (ENDGRENT_R_PROTO == REENTRANT_PROTO_I_H || ENDGRENT_R_PROTO == REENTRANT_PROTO_V_H) # define ENDGRENT_R_HAS_FPTR #else # undef ENDGRENT_R_HAS_FPTR #endif /* Any of the getgrent getgrgid getgrnam setgrent endgrent using fptr? */ #if (defined(GETGRENT_R_HAS_FPTR) || defined(GETGRGID_R_HAS_FPTR) || defined(GETGRNAM_R_HAS_FPTR) || defined(SETGRENT_R_HAS_FPTR) || defined(ENDGRENT_R_HAS_FPTR)) # define USE_GRENT_FPTR #else # undef USE_GRENT_FPTR #endif /* The getpwent getpwnam getpwuid setpwent endpwent using fptr? */ #if defined(HAS_GETPWENT_R) && (GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIH) # define GETPWENT_R_HAS_FPTR #else # undef GETPWENT_R_HAS_FPTR #endif #if defined(HAS_SETPWENT_R) && (SETPWENT_R_PROTO == REENTRANT_PROTO_I_H || SETPWENT_R_PROTO == REENTRANT_PROTO_V_H) # define SETPWENT_R_HAS_FPTR #else # undef SETPWENT_R_HAS_FPTR #endif #if defined(HAS_ENDPWENT_R) && (ENDPWENT_R_PROTO == REENTRANT_PROTO_I_H || ENDPWENT_R_PROTO == REENTRANT_PROTO_V_H) # define ENDPWENT_R_HAS_FPTR #else # undef ENDPWENT_R_HAS_FPTR #endif /* Any of the getpwent getpwnam getpwuid setpwent endpwent using fptr? */ #if (defined(GETPWENT_R_HAS_FPTR) || defined(GETPWNAM_R_HAS_FPTR) || defined(GETPWUID_R_HAS_FPTR) || defined(SETPWENT_R_HAS_FPTR) || defined(ENDPWENT_R_HAS_FPTR)) # define USE_PWENT_FPTR #else # undef USE_PWENT_FPTR #endif /* The getpwent getpwgid getpwnam using buffer? */ #if defined(HAS_GETPWENT_R) && (GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIR || GETPWENT_R_PROTO == REENTRANT_PROTO_S_SBW || GETPWENT_R_PROTO == REENTRANT_PROTO_S_SBI || GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBI || GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIH) # define GETPWENT_R_HAS_BUFFER #else # undef GETPWENT_R_HAS_BUFFER #endif #if defined(HAS_GETPWNAM_R) && (GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR || GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR || GETPWNAM_R_PROTO == REENTRANT_PROTO_S_CSBI || GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBI) # define GETPWNAM_R_HAS_BUFFER #else # undef GETPWNAM_R_HAS_BUFFER #endif /* Any of the getpwent getpwgid getpwnam using buffer? */ #if (defined(GETPWENT_R_HAS_BUFFER) || defined(GETPWGID_R_HAS_BUFFER) || defined(GETPWNAM_R_HAS_BUFFER)) # define USE_PWENT_BUFFER #else # undef USE_PWENT_BUFFER #endif /* The gethostent gethostbyaddr gethostbyname using ptr? */ #if defined(HAS_GETHOSTENT_R) && (GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBWRE) # define GETHOSTENT_R_HAS_PTR #else # undef GETHOSTENT_R_HAS_PTR #endif #if defined(HAS_GETHOSTBYADDR_R) && (GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISBWRE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_TsISBWRE) # define GETHOSTBYADDR_R_HAS_PTR #else # undef GETHOSTBYADDR_R_HAS_PTR #endif #if defined(HAS_GETHOSTBYNAME_R) && (GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE) # define GETHOSTBYNAME_R_HAS_PTR #else # undef GETHOSTBYNAME_R_HAS_PTR #endif /* Any of the gethostent gethostbyaddr gethostbyname using ptr? */ #if (defined(GETHOSTENT_R_HAS_PTR) || defined(GETHOSTBYADDR_R_HAS_PTR) || defined(GETHOSTBYNAME_R_HAS_PTR)) # define USE_HOSTENT_PTR #else # undef USE_HOSTENT_PTR #endif /* The getnetent getnetbyaddr getnetbyname using ptr? */ #if defined(HAS_GETNETENT_R) && (GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBWRE) # define GETNETENT_R_HAS_PTR #else # undef GETNETENT_R_HAS_PTR #endif #if defined(HAS_GETNETBYADDR_R) && (GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_UISBWRE || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_uISBWRE) # define GETNETBYADDR_R_HAS_PTR #else # undef GETNETBYADDR_R_HAS_PTR #endif #if defined(HAS_GETNETBYNAME_R) && (GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE) # define GETNETBYNAME_R_HAS_PTR #else # undef GETNETBYNAME_R_HAS_PTR #endif /* Any of the getnetent getnetbyaddr getnetbyname using ptr? */ #if (defined(GETNETENT_R_HAS_PTR) || defined(GETNETBYADDR_R_HAS_PTR) || defined(GETNETBYNAME_R_HAS_PTR)) # define USE_NETENT_PTR #else # undef USE_NETENT_PTR #endif /* The getprotoent getprotobyname getprotobynumber using ptr? */ #if defined(HAS_GETPROTOENT_R) && (GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBWR) # define GETPROTOENT_R_HAS_PTR #else # undef GETPROTOENT_R_HAS_PTR #endif #if defined(HAS_GETPROTOBYNAME_R) && (GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWR) # define GETPROTOBYNAME_R_HAS_PTR #else # undef GETPROTOBYNAME_R_HAS_PTR #endif #if defined(HAS_GETPROTOBYNUMBER_R) && (GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISBWR) # define GETPROTOBYNUMBER_R_HAS_PTR #else # undef GETPROTOBYNUMBER_R_HAS_PTR #endif /* Any of the getprotoent getprotobyname getprotobynumber using ptr? */ #if (defined(GETPROTOENT_R_HAS_PTR) || defined(GETPROTOBYNAME_R_HAS_PTR) || defined(GETPROTOBYNUMBER_R_HAS_PTR)) # define USE_PROTOENT_PTR #else # undef USE_PROTOENT_PTR #endif /* The getservent getservbyname getservbyport using ptr? */ #if defined(HAS_GETSERVENT_R) && (GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBWR) # define GETSERVENT_R_HAS_PTR #else # undef GETSERVENT_R_HAS_PTR #endif #if defined(HAS_GETSERVBYNAME_R) && (GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSBWR) # define GETSERVBYNAME_R_HAS_PTR #else # undef GETSERVBYNAME_R_HAS_PTR #endif #if defined(HAS_GETSERVBYPORT_R) && (GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSBWR) # define GETSERVBYPORT_R_HAS_PTR #else # undef GETSERVBYPORT_R_HAS_PTR #endif /* Any of the getservent getservbyname getservbyport using ptr? */ #if (defined(GETSERVENT_R_HAS_PTR) || defined(GETSERVBYNAME_R_HAS_PTR) || defined(GETSERVBYPORT_R_HAS_PTR)) # define USE_SERVENT_PTR #else # undef USE_SERVENT_PTR #endif /* The gethostent gethostbyaddr gethostbyname using buffer? */ #if defined(HAS_GETHOSTENT_R) && (GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBWRE || GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBIE || GETHOSTENT_R_PROTO == REENTRANT_PROTO_S_SBIE || GETHOSTENT_R_PROTO == REENTRANT_PROTO_S_SBI || GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBI) # define GETHOSTENT_R_HAS_BUFFER #else # undef GETHOSTENT_R_HAS_BUFFER #endif #if defined(HAS_GETHOSTBYADDR_R) && (GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISBWRE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBWIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TWISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CIISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CSBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TSBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_TsISBWRE) # define GETHOSTBYADDR_R_HAS_BUFFER #else # undef GETHOSTBYADDR_R_HAS_BUFFER #endif #if defined(HAS_GETHOSTBYNAME_R) && (GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE || GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBIE) # define GETHOSTBYNAME_R_HAS_BUFFER #else # undef GETHOSTBYNAME_R_HAS_BUFFER #endif /* Any of the gethostent gethostbyaddr gethostbyname using buffer? */ #if (defined(GETHOSTENT_R_HAS_BUFFER) || defined(GETHOSTBYADDR_R_HAS_BUFFER) || defined(GETHOSTBYNAME_R_HAS_BUFFER)) # define USE_HOSTENT_BUFFER #else # undef USE_HOSTENT_BUFFER #endif /* The getnetent getnetbyaddr getnetbyname using buffer? */ #if defined(HAS_GETNETENT_R) && (GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBWRE || GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBIE || GETNETENT_R_PROTO == REENTRANT_PROTO_S_SBIE || GETNETENT_R_PROTO == REENTRANT_PROTO_S_SBI || GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBI) # define GETNETENT_R_HAS_BUFFER #else # undef GETNETENT_R_HAS_BUFFER #endif #if defined(HAS_GETNETBYADDR_R) && (GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_UISBWRE || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_LISBI || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_S_TISBI || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_S_LISBI || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_uISBWRE) # define GETNETBYADDR_R_HAS_BUFFER #else # undef GETNETBYADDR_R_HAS_BUFFER #endif #if defined(HAS_GETNETBYNAME_R) && (GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE || GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBI || GETNETBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBI) # define GETNETBYNAME_R_HAS_BUFFER #else # undef GETNETBYNAME_R_HAS_BUFFER #endif /* Any of the getnetent getnetbyaddr getnetbyname using buffer? */ #if (defined(GETNETENT_R_HAS_BUFFER) || defined(GETNETBYADDR_R_HAS_BUFFER) || defined(GETNETBYNAME_R_HAS_BUFFER)) # define USE_NETENT_BUFFER #else # undef USE_NETENT_BUFFER #endif /* The getprotoent getprotobyname getprotobynumber using buffer? */ #if defined(HAS_GETPROTOENT_R) && (GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBI || GETPROTOENT_R_PROTO == REENTRANT_PROTO_S_SBI) # define GETPROTOENT_R_HAS_BUFFER #else # undef GETPROTOENT_R_HAS_BUFFER #endif #if defined(HAS_GETPROTOBYNAME_R) && (GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWR || GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBI) # define GETPROTOBYNAME_R_HAS_BUFFER #else # undef GETPROTOBYNAME_R_HAS_BUFFER #endif #if defined(HAS_GETPROTOBYNUMBER_R) && (GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISBWR || GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_S_ISBI) # define GETPROTOBYNUMBER_R_HAS_BUFFER #else # undef GETPROTOBYNUMBER_R_HAS_BUFFER #endif /* Any of the getprotoent getprotobyname getprotobynumber using buffer? */ #if (defined(GETPROTOENT_R_HAS_BUFFER) || defined(GETPROTOBYNAME_R_HAS_BUFFER) || defined(GETPROTOBYNUMBER_R_HAS_BUFFER)) # define USE_PROTOENT_BUFFER #else # undef USE_PROTOENT_BUFFER #endif /* The getservent getservbyname getservbyport using buffer? */ #if defined(HAS_GETSERVENT_R) && (GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBWR || GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBI || GETSERVENT_R_PROTO == REENTRANT_PROTO_S_SBI) # define GETSERVENT_R_HAS_BUFFER #else # undef GETSERVENT_R_HAS_BUFFER #endif #if defined(HAS_GETSERVBYNAME_R) && (GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSBWR || GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_S_CCSBI) # define GETSERVBYNAME_R_HAS_BUFFER #else # undef GETSERVBYNAME_R_HAS_BUFFER #endif #if defined(HAS_GETSERVBYPORT_R) && (GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSBWR || GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_S_ICSBI) # define GETSERVBYPORT_R_HAS_BUFFER #else # undef GETSERVBYPORT_R_HAS_BUFFER #endif /* Any of the getservent getservbyname getservbyport using buffer? */ #if (defined(GETSERVENT_R_HAS_BUFFER) || defined(GETSERVBYNAME_R_HAS_BUFFER) || defined(GETSERVBYPORT_R_HAS_BUFFER)) # define USE_SERVENT_BUFFER #else # undef USE_SERVENT_BUFFER #endif /* The gethostent gethostbyaddr gethostbyname using errno? */ #if defined(HAS_GETHOSTENT_R) && (GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBWRE || GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBIE || GETHOSTENT_R_PROTO == REENTRANT_PROTO_S_SBIE) # define GETHOSTENT_R_HAS_ERRNO #else # undef GETHOSTENT_R_HAS_ERRNO #endif #if defined(HAS_GETHOSTBYADDR_R) && (GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISBWRE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBWIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TWISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CIISBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CSBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TSBIE || GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_TsISBWRE) # define GETHOSTBYADDR_R_HAS_ERRNO #else # undef GETHOSTBYADDR_R_HAS_ERRNO #endif #if defined(HAS_GETHOSTBYNAME_R) && (GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE || GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBIE) # define GETHOSTBYNAME_R_HAS_ERRNO #else # undef GETHOSTBYNAME_R_HAS_ERRNO #endif /* Any of the gethostent gethostbyaddr gethostbyname using errno? */ #if (defined(GETHOSTENT_R_HAS_ERRNO) || defined(GETHOSTBYADDR_R_HAS_ERRNO) || defined(GETHOSTBYNAME_R_HAS_ERRNO)) # define USE_HOSTENT_ERRNO #else # undef USE_HOSTENT_ERRNO #endif /* The getnetent getnetbyaddr getnetbyname using errno? */ #if defined(HAS_GETNETENT_R) && (GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBWRE || GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBIE || GETNETENT_R_PROTO == REENTRANT_PROTO_S_SBIE) # define GETNETENT_R_HAS_ERRNO #else # undef GETNETENT_R_HAS_ERRNO #endif #if defined(HAS_GETNETBYADDR_R) && (GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_UISBWRE || GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_uISBWRE) # define GETNETBYADDR_R_HAS_ERRNO #else # undef GETNETBYADDR_R_HAS_ERRNO #endif #if defined(HAS_GETNETBYNAME_R) && (GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE) # define GETNETBYNAME_R_HAS_ERRNO #else # undef GETNETBYNAME_R_HAS_ERRNO #endif /* Any of the getnetent getnetbyaddr getnetbyname using errno? */ #if (defined(GETNETENT_R_HAS_ERRNO) || defined(GETNETBYADDR_R_HAS_ERRNO) || defined(GETNETBYNAME_R_HAS_ERRNO)) # define USE_NETENT_ERRNO #else # undef USE_NETENT_ERRNO #endif typedef struct { #ifdef HAS_ASCTIME_R char* _asctime_buffer; size_t _asctime_size; #endif /* HAS_ASCTIME_R */ #ifdef HAS_CRYPT_R #if CRYPT_R_PROTO == REENTRANT_PROTO_B_CCD CRYPTD* _crypt_data; #else struct crypt_data *_crypt_struct_buffer; #endif #endif /* HAS_CRYPT_R */ #ifdef HAS_CTIME_R char* _ctime_buffer; size_t _ctime_size; #endif /* HAS_CTIME_R */ #ifdef HAS_DRAND48_R struct drand48_data _drand48_struct; double _drand48_double; #endif /* HAS_DRAND48_R */ #ifdef HAS_GETGRNAM_R struct group _grent_struct; char* _grent_buffer; size_t _grent_size; # ifdef USE_GRENT_PTR struct group* _grent_ptr; # endif # ifdef USE_GRENT_FPTR FILE* _grent_fptr; # endif #endif /* HAS_GETGRNAM_R */ #ifdef HAS_GETHOSTBYNAME_R struct hostent _hostent_struct; # if GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD struct hostent_data _hostent_data; # else char* _hostent_buffer; size_t _hostent_size; # endif # ifdef USE_HOSTENT_PTR struct hostent* _hostent_ptr; # endif # ifdef USE_HOSTENT_ERRNO int _hostent_errno; # endif #endif /* HAS_GETHOSTBYNAME_R */ #ifdef HAS_GETLOGIN_R char* _getlogin_buffer; size_t _getlogin_size; #endif /* HAS_GETLOGIN_R */ #ifdef HAS_GETNETBYNAME_R struct netent _netent_struct; # if GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD struct netent_data _netent_data; # else char* _netent_buffer; size_t _netent_size; # endif # ifdef USE_NETENT_PTR struct netent* _netent_ptr; # endif # ifdef USE_NETENT_ERRNO int _netent_errno; # endif #endif /* HAS_GETNETBYNAME_R */ #ifdef HAS_GETPROTOBYNAME_R struct protoent _protoent_struct; # if GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD struct protoent_data _protoent_data; # else char* _protoent_buffer; size_t _protoent_size; # endif # ifdef USE_PROTOENT_PTR struct protoent* _protoent_ptr; # endif # ifdef USE_PROTOENT_ERRNO int _protoent_errno; # endif #endif /* HAS_GETPROTOBYNAME_R */ #ifdef HAS_GETPWNAM_R struct passwd _pwent_struct; char* _pwent_buffer; size_t _pwent_size; # ifdef USE_PWENT_PTR struct passwd* _pwent_ptr; # endif # ifdef USE_PWENT_FPTR FILE* _pwent_fptr; # endif #endif /* HAS_GETPWNAM_R */ #ifdef HAS_GETSERVBYNAME_R struct servent _servent_struct; # if GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD struct servent_data _servent_data; # else char* _servent_buffer; size_t _servent_size; # endif # ifdef USE_SERVENT_PTR struct servent* _servent_ptr; # endif # ifdef USE_SERVENT_ERRNO int _servent_errno; # endif #endif /* HAS_GETSERVBYNAME_R */ #ifdef HAS_GETSPNAM_R struct spwd _spent_struct; char* _spent_buffer; size_t _spent_size; # ifdef USE_SPENT_PTR struct spwd* _spent_ptr; # endif # ifdef USE_SPENT_FPTR FILE* _spent_fptr; # endif #endif /* HAS_GETSPNAM_R */ #ifdef HAS_RANDOM_R struct random_data _random_struct; # if RANDOM_R_PROTO == REENTRANT_PROTO_I_iS int _random_retval; # endif # if RANDOM_R_PROTO == REENTRANT_PROTO_I_lS long _random_retval; # endif # if RANDOM_R_PROTO == REENTRANT_PROTO_I_St int32_t _random_retval; # endif #endif /* HAS_RANDOM_R */ #ifdef HAS_READDIR_R struct dirent* _readdir_struct; size_t _readdir_size; # if READDIR_R_PROTO == REENTRANT_PROTO_I_TSR struct dirent* _readdir_ptr; # endif #endif /* HAS_READDIR_R */ #ifdef HAS_READDIR64_R struct dirent64* _readdir64_struct; size_t _readdir64_size; # if READDIR64_R_PROTO == REENTRANT_PROTO_I_TSR struct dirent64* _readdir64_ptr; # endif #endif /* HAS_READDIR64_R */ #ifdef HAS_SETLOCALE_R char* _setlocale_buffer; size_t _setlocale_size; #endif /* HAS_SETLOCALE_R */ #ifdef HAS_SRANDOM_R struct random_data _srandom_struct; #endif /* HAS_SRANDOM_R */ #ifdef HAS_STRERROR_R char* _strerror_buffer; size_t _strerror_size; #endif /* HAS_STRERROR_R */ #ifdef HAS_TTYNAME_R char* _ttyname_buffer; size_t _ttyname_size; #endif /* HAS_TTYNAME_R */ int dummy; /* cannot have empty structs */ } REENTR; /* The wrappers. */ #ifdef HAS_ASCTIME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef asctime # if !defined(asctime) && ASCTIME_R_PROTO == REENTRANT_PROTO_B_SB # define asctime(a) asctime_r(a, PL_reentrant_buffer->_asctime_buffer) # endif # if !defined(asctime) && ASCTIME_R_PROTO == REENTRANT_PROTO_B_SBI # define asctime(a) asctime_r(a, PL_reentrant_buffer->_asctime_buffer, PL_reentrant_buffer->_asctime_size) # endif # if !defined(asctime) && ASCTIME_R_PROTO == REENTRANT_PROTO_I_SB # define asctime(a) (asctime_r(a, PL_reentrant_buffer->_asctime_buffer) == 0 ? PL_reentrant_buffer->_asctime_buffer : 0) # endif # if !defined(asctime) && ASCTIME_R_PROTO == REENTRANT_PROTO_I_SBI # define asctime(a) (asctime_r(a, PL_reentrant_buffer->_asctime_buffer, PL_reentrant_buffer->_asctime_size) == 0 ? PL_reentrant_buffer->_asctime_buffer : 0) # endif # endif #endif /* HAS_ASCTIME_R */ #ifdef HAS_CRYPT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef crypt # if !defined(crypt) && CRYPT_R_PROTO == REENTRANT_PROTO_B_CCS # define crypt(a, b) crypt_r(a, b, PL_reentrant_buffer->_crypt_struct_buffer) # endif # if !defined(crypt) && CRYPT_R_PROTO == REENTRANT_PROTO_B_CCD # define crypt(a, b) crypt_r(a, b, &PL_reentrant_buffer->_crypt_data) # endif # endif #endif /* HAS_CRYPT_R */ #ifdef HAS_CTERMID_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef ctermid # if !defined(ctermid) && CTERMID_R_PROTO == REENTRANT_PROTO_B_B # define ctermid(a) ctermid_r(a) # endif # endif #endif /* HAS_CTERMID_R */ #ifdef HAS_CTIME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef ctime # if !defined(ctime) && CTIME_R_PROTO == REENTRANT_PROTO_B_SB # define ctime(a) ctime_r(a, PL_reentrant_buffer->_ctime_buffer) # endif # if !defined(ctime) && CTIME_R_PROTO == REENTRANT_PROTO_B_SBI # define ctime(a) ctime_r(a, PL_reentrant_buffer->_ctime_buffer, PL_reentrant_buffer->_ctime_size) # endif # if !defined(ctime) && CTIME_R_PROTO == REENTRANT_PROTO_I_SB # define ctime(a) (ctime_r(a, PL_reentrant_buffer->_ctime_buffer) == 0 ? PL_reentrant_buffer->_ctime_buffer : 0) # endif # if !defined(ctime) && CTIME_R_PROTO == REENTRANT_PROTO_I_SBI # define ctime(a) (ctime_r(a, PL_reentrant_buffer->_ctime_buffer, PL_reentrant_buffer->_ctime_size) == 0 ? PL_reentrant_buffer->_ctime_buffer : 0) # endif # endif #endif /* HAS_CTIME_R */ #ifdef HAS_DRAND48_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef drand48 # if !defined(drand48) && DRAND48_R_PROTO == REENTRANT_PROTO_I_ST # define drand48() (drand48_r(&PL_reentrant_buffer->_drand48_struct, &PL_reentrant_buffer->_drand48_double) == 0 ? PL_reentrant_buffer->_drand48_double : 0) # endif # endif #endif /* HAS_DRAND48_R */ #ifdef HAS_ENDGRENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endgrent # if !defined(endgrent) && ENDGRENT_R_PROTO == REENTRANT_PROTO_I_H # define endgrent() (endgrent_r(&PL_reentrant_buffer->_grent_fptr) == 0 ? 1 : 0) # endif # if !defined(endgrent) && ENDGRENT_R_PROTO == REENTRANT_PROTO_V_H # define endgrent() endgrent_r(&PL_reentrant_buffer->_grent_fptr) # endif # endif #endif /* HAS_ENDGRENT_R */ #ifdef HAS_ENDHOSTENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endhostent # if !defined(endhostent) && ENDHOSTENT_R_PROTO == REENTRANT_PROTO_I_D # define endhostent() (endhostent_r(&PL_reentrant_buffer->_hostent_data) == 0 ? 1 : 0) # endif # if !defined(endhostent) && ENDHOSTENT_R_PROTO == REENTRANT_PROTO_V_D # define endhostent() endhostent_r(&PL_reentrant_buffer->_hostent_data) # endif # endif #endif /* HAS_ENDHOSTENT_R */ #ifdef HAS_ENDNETENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endnetent # if !defined(endnetent) && ENDNETENT_R_PROTO == REENTRANT_PROTO_I_D # define endnetent() (endnetent_r(&PL_reentrant_buffer->_netent_data) == 0 ? 1 : 0) # endif # if !defined(endnetent) && ENDNETENT_R_PROTO == REENTRANT_PROTO_V_D # define endnetent() endnetent_r(&PL_reentrant_buffer->_netent_data) # endif # endif #endif /* HAS_ENDNETENT_R */ #ifdef HAS_ENDPROTOENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endprotoent # if !defined(endprotoent) && ENDPROTOENT_R_PROTO == REENTRANT_PROTO_I_D # define endprotoent() (endprotoent_r(&PL_reentrant_buffer->_protoent_data) == 0 ? 1 : 0) # endif # if !defined(endprotoent) && ENDPROTOENT_R_PROTO == REENTRANT_PROTO_V_D # define endprotoent() endprotoent_r(&PL_reentrant_buffer->_protoent_data) # endif # endif #endif /* HAS_ENDPROTOENT_R */ #ifdef HAS_ENDPWENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endpwent # if !defined(endpwent) && ENDPWENT_R_PROTO == REENTRANT_PROTO_I_H # define endpwent() (endpwent_r(&PL_reentrant_buffer->_pwent_fptr) == 0 ? 1 : 0) # endif # if !defined(endpwent) && ENDPWENT_R_PROTO == REENTRANT_PROTO_V_H # define endpwent() endpwent_r(&PL_reentrant_buffer->_pwent_fptr) # endif # endif #endif /* HAS_ENDPWENT_R */ #ifdef HAS_ENDSERVENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef endservent # if !defined(endservent) && ENDSERVENT_R_PROTO == REENTRANT_PROTO_I_D # define endservent() (endservent_r(&PL_reentrant_buffer->_servent_data) == 0 ? 1 : 0) # endif # if !defined(endservent) && ENDSERVENT_R_PROTO == REENTRANT_PROTO_V_D # define endservent() endservent_r(&PL_reentrant_buffer->_servent_data) # endif # endif #endif /* HAS_ENDSERVENT_R */ #ifdef HAS_GETGRENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getgrent # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBWR # define getgrent() ((PL_reentrant_retint = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIR # define getgrent() ((PL_reentrant_retint = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_S_SBW # define getgrent() (getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size) ? &PL_reentrant_buffer->_grent_struct : ((errno == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_S_SBI # define getgrent() (getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size) ? &PL_reentrant_buffer->_grent_struct : ((errno == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBI # define getgrent() ((PL_reentrant_retint = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # if !defined(getgrent) && GETGRENT_R_PROTO == REENTRANT_PROTO_I_SBIH # define getgrent() ((PL_reentrant_retint = getgrent_r(&PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_fptr)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrent") : 0)) # endif # endif #endif /* HAS_GETGRENT_R */ #ifdef HAS_GETGRGID_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getgrgid # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBWR # define getgrgid(a) ((PL_reentrant_retint = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrgid", a) : 0)) # endif # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBIR # define getgrgid(a) ((PL_reentrant_retint = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrgid", a) : 0)) # endif # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_I_TSBI # define getgrgid(a) ((PL_reentrant_retint = getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrgid", a) : 0)) # endif # if !defined(getgrgid) && GETGRGID_R_PROTO == REENTRANT_PROTO_S_TSBI # define getgrgid(a) (getgrgid_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size) ? &PL_reentrant_buffer->_grent_struct : ((errno == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrgid", a) : 0)) # endif # endif #endif /* HAS_GETGRGID_R */ #ifdef HAS_GETGRNAM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getgrnam # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # define getgrnam(a) ((PL_reentrant_retint = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrnam", a) : 0)) # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR # define getgrnam(a) ((PL_reentrant_retint = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size, &PL_reentrant_buffer->_grent_ptr)) == 0 ? PL_reentrant_buffer->_grent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrnam", a) : 0)) # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_S_CBI # define getgrnam(a) (getgrnam_r(a, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size) ? PL_reentrant_buffer->_grent_buffer : ((errno == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrnam", a) : 0)) # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_I_CSBI # define getgrnam(a) ((PL_reentrant_retint = getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size)) == 0 ? &PL_reentrant_buffer->_grent_struct : ((PL_reentrant_retint == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrnam", a) : 0)) # endif # if !defined(getgrnam) && GETGRNAM_R_PROTO == REENTRANT_PROTO_S_CSBI # define getgrnam(a) (getgrnam_r(a, &PL_reentrant_buffer->_grent_struct, PL_reentrant_buffer->_grent_buffer, PL_reentrant_buffer->_grent_size) ? &PL_reentrant_buffer->_grent_struct : ((errno == ERANGE) ? (struct group *) Perl_reentrant_retry("getgrnam", a) : 0)) # endif # endif #endif /* HAS_GETGRNAM_R */ #ifdef HAS_GETHOSTBYADDR_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef gethostbyaddr # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISBWRE # define gethostbyaddr(a, b, c) ((PL_reentrant_retint = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBWIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CWISBIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TWISBIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CIISBIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_CSBIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? 1 : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_S_TSBIE # define gethostbyaddr(a, b, c) (gethostbyaddr_r(a, b, c, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? 1 : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CWISD # define gethostbyaddr(a, b, c) ((PL_reentrant_retint = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CIISD # define gethostbyaddr(a, b, c) ((PL_reentrant_retint = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_CII # define gethostbyaddr(a, b, c) ((PL_reentrant_retint = gethostbyaddr_r(a, b, c)) == 0 ? 1 : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # if !defined(gethostbyaddr) && GETHOSTBYADDR_R_PROTO == REENTRANT_PROTO_I_TsISBWRE # define gethostbyaddr(a, b, c) ((PL_reentrant_retint = gethostbyaddr_r(a, b, c, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyaddr", a, b, c) : 0)) # endif # endif #endif /* HAS_GETHOSTBYADDR_R */ #ifdef HAS_GETHOSTBYNAME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef gethostbyname # if !defined(gethostbyname) && GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE # define gethostbyname(a) ((PL_reentrant_retint = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyname", a) : 0)) # endif # if !defined(gethostbyname) && GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBIE # define gethostbyname(a) (gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyname", a) : 0)) # endif # if !defined(gethostbyname) && GETHOSTBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # define gethostbyname(a) ((PL_reentrant_retint = gethostbyname_r(a, &PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostbyname", a) : 0)) # endif # endif #endif /* HAS_GETHOSTBYNAME_R */ #ifdef HAS_GETHOSTENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef gethostent # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBWRE # define gethostent() ((PL_reentrant_retint = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_ptr, &PL_reentrant_buffer->_hostent_errno)) == 0 ? PL_reentrant_buffer->_hostent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBIE # define gethostent() ((PL_reentrant_retint = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_S_SBIE # define gethostent() (gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size, &PL_reentrant_buffer->_hostent_errno) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_S_SBI # define gethostent() (gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size) ? &PL_reentrant_buffer->_hostent_struct : ((errno == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SBI # define gethostent() ((PL_reentrant_retint = gethostent_r(&PL_reentrant_buffer->_hostent_struct, PL_reentrant_buffer->_hostent_buffer, PL_reentrant_buffer->_hostent_size)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # if !defined(gethostent) && GETHOSTENT_R_PROTO == REENTRANT_PROTO_I_SD # define gethostent() ((PL_reentrant_retint = gethostent_r(&PL_reentrant_buffer->_hostent_struct, &PL_reentrant_buffer->_hostent_data)) == 0 ? &PL_reentrant_buffer->_hostent_struct : ((PL_reentrant_retint == ERANGE) ? (struct hostent *) Perl_reentrant_retry("gethostent") : 0)) # endif # endif #endif /* HAS_GETHOSTENT_R */ #ifdef HAS_GETLOGIN_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getlogin # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_I_BW # define getlogin() ((PL_reentrant_retint = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_reentrant_retint == ERANGE) ? (char *) Perl_reentrant_retry("getlogin") : 0)) # endif # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_I_BI # define getlogin() ((PL_reentrant_retint = getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size)) == 0 ? PL_reentrant_buffer->_getlogin_buffer : ((PL_reentrant_retint == ERANGE) ? (char *) Perl_reentrant_retry("getlogin") : 0)) # endif # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_B_BW # define getlogin() getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size) # endif # if !defined(getlogin) && GETLOGIN_R_PROTO == REENTRANT_PROTO_B_BI # define getlogin() getlogin_r(PL_reentrant_buffer->_getlogin_buffer, PL_reentrant_buffer->_getlogin_size) # endif # endif #endif /* HAS_GETLOGIN_R */ #ifdef HAS_GETNETBYADDR_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getnetbyaddr # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_UISBWRE # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_LISBI # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_S_TISBI # define getnetbyaddr(a, b) (getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size) ? &PL_reentrant_buffer->_netent_struct : ((errno == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_S_LISBI # define getnetbyaddr(a, b) (getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size) ? &PL_reentrant_buffer->_netent_struct : ((errno == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_TISD # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_LISD # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_IISD # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # if !defined(getnetbyaddr) && GETNETBYADDR_R_PROTO == REENTRANT_PROTO_I_uISBWRE # define getnetbyaddr(a, b) ((PL_reentrant_retint = getnetbyaddr_r(a, b, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyaddr", a, b) : 0)) # endif # endif #endif /* HAS_GETNETBYADDR_R */ #ifdef HAS_GETNETBYNAME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getnetbyname # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWRE # define getnetbyname(a) ((PL_reentrant_retint = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyname", a) : 0)) # endif # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBI # define getnetbyname(a) ((PL_reentrant_retint = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyname", a) : 0)) # endif # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBI # define getnetbyname(a) (getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size) ? &PL_reentrant_buffer->_netent_struct : ((errno == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyname", a) : 0)) # endif # if !defined(getnetbyname) && GETNETBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # define getnetbyname(a) ((PL_reentrant_retint = getnetbyname_r(a, &PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetbyname", a) : 0)) # endif # endif #endif /* HAS_GETNETBYNAME_R */ #ifdef HAS_GETNETENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getnetent # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBWRE # define getnetent() ((PL_reentrant_retint = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_ptr, &PL_reentrant_buffer->_netent_errno)) == 0 ? PL_reentrant_buffer->_netent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBIE # define getnetent() ((PL_reentrant_retint = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_S_SBIE # define getnetent() (getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size, &PL_reentrant_buffer->_netent_errno) ? &PL_reentrant_buffer->_netent_struct : ((errno == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_S_SBI # define getnetent() (getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size) ? &PL_reentrant_buffer->_netent_struct : ((errno == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SBI # define getnetent() ((PL_reentrant_retint = getnetent_r(&PL_reentrant_buffer->_netent_struct, PL_reentrant_buffer->_netent_buffer, PL_reentrant_buffer->_netent_size)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # if !defined(getnetent) && GETNETENT_R_PROTO == REENTRANT_PROTO_I_SD # define getnetent() ((PL_reentrant_retint = getnetent_r(&PL_reentrant_buffer->_netent_struct, &PL_reentrant_buffer->_netent_data)) == 0 ? &PL_reentrant_buffer->_netent_struct : ((PL_reentrant_retint == ERANGE) ? (struct netent *) Perl_reentrant_retry("getnetent") : 0)) # endif # endif #endif /* HAS_GETNETENT_R */ #ifdef HAS_GETPROTOBYNAME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getprotobyname # if !defined(getprotobyname) && GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSBWR # define getprotobyname(a) ((PL_reentrant_retint = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobyname", a) : 0)) # endif # if !defined(getprotobyname) && GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_S_CSBI # define getprotobyname(a) (getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size) ? &PL_reentrant_buffer->_protoent_struct : ((errno == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobyname", a) : 0)) # endif # if !defined(getprotobyname) && GETPROTOBYNAME_R_PROTO == REENTRANT_PROTO_I_CSD # define getprotobyname(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)),(PL_reentrant_retint = getprotobyname_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobyname", a) : 0)) # endif # endif #endif /* HAS_GETPROTOBYNAME_R */ #ifdef HAS_GETPROTOBYNUMBER_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getprotobynumber # if !defined(getprotobynumber) && GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISBWR # define getprotobynumber(a) ((PL_reentrant_retint = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobynumber", a) : 0)) # endif # if !defined(getprotobynumber) && GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_S_ISBI # define getprotobynumber(a) (getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size) ? &PL_reentrant_buffer->_protoent_struct : ((errno == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobynumber", a) : 0)) # endif # if !defined(getprotobynumber) && GETPROTOBYNUMBER_R_PROTO == REENTRANT_PROTO_I_ISD # define getprotobynumber(a) (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)),(PL_reentrant_retint = getprotobynumber_r(a, &PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotobynumber", a) : 0)) # endif # endif #endif /* HAS_GETPROTOBYNUMBER_R */ #ifdef HAS_GETPROTOENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getprotoent # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBWR # define getprotoent() ((PL_reentrant_retint = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size, &PL_reentrant_buffer->_protoent_ptr)) == 0 ? PL_reentrant_buffer->_protoent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotoent") : 0)) # endif # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SBI # define getprotoent() ((PL_reentrant_retint = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotoent") : 0)) # endif # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_S_SBI # define getprotoent() (getprotoent_r(&PL_reentrant_buffer->_protoent_struct, PL_reentrant_buffer->_protoent_buffer, PL_reentrant_buffer->_protoent_size) ? &PL_reentrant_buffer->_protoent_struct : ((errno == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotoent") : 0)) # endif # if !defined(getprotoent) && GETPROTOENT_R_PROTO == REENTRANT_PROTO_I_SD # define getprotoent() (REENTR_MEMZERO(&PL_reentrant_buffer->_protoent_data, sizeof(PL_reentrant_buffer->_protoent_data)),(PL_reentrant_retint = getprotoent_r(&PL_reentrant_buffer->_protoent_struct, &PL_reentrant_buffer->_protoent_data)) == 0 ? &PL_reentrant_buffer->_protoent_struct : ((PL_reentrant_retint == ERANGE) ? (struct protoent *) Perl_reentrant_retry("getprotoent") : 0)) # endif # endif #endif /* HAS_GETPROTOENT_R */ #ifdef HAS_GETPWENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getpwent # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBWR # define getpwent() ((PL_reentrant_retint = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIR # define getpwent() ((PL_reentrant_retint = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_S_SBW # define getpwent() (getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size) ? &PL_reentrant_buffer->_pwent_struct : ((errno == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_S_SBI # define getpwent() (getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size) ? &PL_reentrant_buffer->_pwent_struct : ((errno == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBI # define getpwent() ((PL_reentrant_retint = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # if !defined(getpwent) && GETPWENT_R_PROTO == REENTRANT_PROTO_I_SBIH # define getpwent() ((PL_reentrant_retint = getpwent_r(&PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_fptr)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwent") : 0)) # endif # endif #endif /* HAS_GETPWENT_R */ #ifdef HAS_GETPWNAM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getpwnam # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # define getpwnam(a) ((PL_reentrant_retint = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwnam", a) : 0)) # endif # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBIR # define getpwnam(a) ((PL_reentrant_retint = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwnam", a) : 0)) # endif # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_S_CSBI # define getpwnam(a) (getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size) ? &PL_reentrant_buffer->_pwent_struct : ((errno == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwnam", a) : 0)) # endif # if !defined(getpwnam) && GETPWNAM_R_PROTO == REENTRANT_PROTO_I_CSBI # define getpwnam(a) ((PL_reentrant_retint = getpwnam_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwnam", a) : 0)) # endif # endif #endif /* HAS_GETPWNAM_R */ #ifdef HAS_GETPWUID_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getpwuid # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBWR # define getpwuid(a) ((PL_reentrant_retint = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwuid", a) : 0)) # endif # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBIR # define getpwuid(a) ((PL_reentrant_retint = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size, &PL_reentrant_buffer->_pwent_ptr)) == 0 ? PL_reentrant_buffer->_pwent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwuid", a) : 0)) # endif # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_I_TSBI # define getpwuid(a) ((PL_reentrant_retint = getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size)) == 0 ? &PL_reentrant_buffer->_pwent_struct : ((PL_reentrant_retint == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwuid", a) : 0)) # endif # if !defined(getpwuid) && GETPWUID_R_PROTO == REENTRANT_PROTO_S_TSBI # define getpwuid(a) (getpwuid_r(a, &PL_reentrant_buffer->_pwent_struct, PL_reentrant_buffer->_pwent_buffer, PL_reentrant_buffer->_pwent_size) ? &PL_reentrant_buffer->_pwent_struct : ((errno == ERANGE) ? (struct passwd *) Perl_reentrant_retry("getpwuid", a) : 0)) # endif # endif #endif /* HAS_GETPWUID_R */ #ifdef HAS_GETSERVBYNAME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getservbyname # if !defined(getservbyname) && GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSBWR # define getservbyname(a, b) ((PL_reentrant_retint = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyname", a, b) : 0)) # endif # if !defined(getservbyname) && GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_S_CCSBI # define getservbyname(a, b) (getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size) ? &PL_reentrant_buffer->_servent_struct : ((errno == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyname", a, b) : 0)) # endif # if !defined(getservbyname) && GETSERVBYNAME_R_PROTO == REENTRANT_PROTO_I_CCSD # define getservbyname(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)),(PL_reentrant_retint = getservbyname_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyname", a, b) : 0)) # endif # endif #endif /* HAS_GETSERVBYNAME_R */ #ifdef HAS_GETSERVBYPORT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getservbyport # if !defined(getservbyport) && GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSBWR # define getservbyport(a, b) ((PL_reentrant_retint = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyport", a, b) : 0)) # endif # if !defined(getservbyport) && GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_S_ICSBI # define getservbyport(a, b) (getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size) ? &PL_reentrant_buffer->_servent_struct : ((errno == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyport", a, b) : 0)) # endif # if !defined(getservbyport) && GETSERVBYPORT_R_PROTO == REENTRANT_PROTO_I_ICSD # define getservbyport(a, b) (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)),(PL_reentrant_retint = getservbyport_r(a, b, &PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservbyport", a, b) : 0)) # endif # endif #endif /* HAS_GETSERVBYPORT_R */ #ifdef HAS_GETSERVENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getservent # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBWR # define getservent() ((PL_reentrant_retint = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size, &PL_reentrant_buffer->_servent_ptr)) == 0 ? PL_reentrant_buffer->_servent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservent") : 0)) # endif # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SBI # define getservent() ((PL_reentrant_retint = getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservent") : 0)) # endif # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_S_SBI # define getservent() (getservent_r(&PL_reentrant_buffer->_servent_struct, PL_reentrant_buffer->_servent_buffer, PL_reentrant_buffer->_servent_size) ? &PL_reentrant_buffer->_servent_struct : ((errno == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservent") : 0)) # endif # if !defined(getservent) && GETSERVENT_R_PROTO == REENTRANT_PROTO_I_SD # define getservent() (REENTR_MEMZERO(&PL_reentrant_buffer->_servent_data, sizeof(PL_reentrant_buffer->_servent_data)),(PL_reentrant_retint = getservent_r(&PL_reentrant_buffer->_servent_struct, &PL_reentrant_buffer->_servent_data)) == 0 ? &PL_reentrant_buffer->_servent_struct : ((PL_reentrant_retint == ERANGE) ? (struct servent *) Perl_reentrant_retry("getservent") : 0)) # endif # endif #endif /* HAS_GETSERVENT_R */ #ifdef HAS_GETSPNAM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef getspnam # if !defined(getspnam) && GETSPNAM_R_PROTO == REENTRANT_PROTO_I_CSBWR # define getspnam(a) ((PL_reentrant_retint = getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size, &PL_reentrant_buffer->_spent_ptr)) == 0 ? PL_reentrant_buffer->_spent_ptr : ((PL_reentrant_retint == ERANGE) ? (struct spwd *) Perl_reentrant_retry("getspnam", a) : 0)) # endif # if !defined(getspnam) && GETSPNAM_R_PROTO == REENTRANT_PROTO_S_CSBI # define getspnam(a) (getspnam_r(a, &PL_reentrant_buffer->_spent_struct, PL_reentrant_buffer->_spent_buffer, PL_reentrant_buffer->_spent_size) ? &PL_reentrant_buffer->_spent_struct : ((errno == ERANGE) ? (struct spwd *) Perl_reentrant_retry("getspnam", a) : 0)) # endif # endif #endif /* HAS_GETSPNAM_R */ #ifdef HAS_RANDOM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef random # if !defined(random) && RANDOM_R_PROTO == REENTRANT_PROTO_I_iS # define random() (random_r(&PL_reentrant_buffer->_random_retval, &PL_reentrant_buffer->_random_struct) == 0 ? PL_reentrant_buffer->_random_retval : 0) # endif # if !defined(random) && RANDOM_R_PROTO == REENTRANT_PROTO_I_lS # define random() (random_r(&PL_reentrant_buffer->_random_retval, &PL_reentrant_buffer->_random_struct) == 0 ? PL_reentrant_buffer->_random_retval : 0) # endif # if !defined(random) && RANDOM_R_PROTO == REENTRANT_PROTO_I_St # define random() (random_r(&PL_reentrant_buffer->_random_struct, &PL_reentrant_buffer->_random_retval) == 0 ? PL_reentrant_buffer->_random_retval : 0) # endif # endif #endif /* HAS_RANDOM_R */ #ifdef HAS_READDIR_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef readdir # if !defined(readdir) && READDIR_R_PROTO == REENTRANT_PROTO_I_TSR # define readdir(a) (readdir_r(a, PL_reentrant_buffer->_readdir_struct, &PL_reentrant_buffer->_readdir_ptr) == 0 ? PL_reentrant_buffer->_readdir_ptr : 0) # endif # if !defined(readdir) && READDIR_R_PROTO == REENTRANT_PROTO_I_TS # define readdir(a) (readdir_r(a, PL_reentrant_buffer->_readdir_struct) == 0 ? PL_reentrant_buffer->_readdir_struct : 0) # endif # endif #endif /* HAS_READDIR_R */ #ifdef HAS_READDIR64_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef readdir64 # if !defined(readdir64) && READDIR64_R_PROTO == REENTRANT_PROTO_I_TSR # define readdir64(a) (readdir64_r(a, PL_reentrant_buffer->_readdir64_struct, &PL_reentrant_buffer->_readdir64_ptr) == 0 ? PL_reentrant_buffer->_readdir64_ptr : 0) # endif # if !defined(readdir64) && READDIR64_R_PROTO == REENTRANT_PROTO_I_TS # define readdir64(a) (readdir64_r(a, PL_reentrant_buffer->_readdir64_struct) == 0 ? PL_reentrant_buffer->_readdir64_struct : 0) # endif # endif #endif /* HAS_READDIR64_R */ #ifdef HAS_SETGRENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setgrent # if !defined(setgrent) && SETGRENT_R_PROTO == REENTRANT_PROTO_I_H # define setgrent() (setgrent_r(&PL_reentrant_buffer->_grent_fptr) == 0 ? 1 : 0) # endif # if !defined(setgrent) && SETGRENT_R_PROTO == REENTRANT_PROTO_V_H # define setgrent() setgrent_r(&PL_reentrant_buffer->_grent_fptr) # endif # endif #endif /* HAS_SETGRENT_R */ #ifdef HAS_SETHOSTENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef sethostent # if !defined(sethostent) && SETHOSTENT_R_PROTO == REENTRANT_PROTO_I_ID # define sethostent(a) (sethostent_r(a, &PL_reentrant_buffer->_hostent_data) == 0 ? 1 : 0) # endif # if !defined(sethostent) && SETHOSTENT_R_PROTO == REENTRANT_PROTO_V_ID # define sethostent(a) sethostent_r(a, &PL_reentrant_buffer->_hostent_data) # endif # endif #endif /* HAS_SETHOSTENT_R */ #ifdef HAS_SETLOCALE_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setlocale # if !defined(setlocale) && SETLOCALE_R_PROTO == REENTRANT_PROTO_I_ICBI # define setlocale(a, b) (setlocale_r(a, b, PL_reentrant_buffer->_setlocale_buffer, PL_reentrant_buffer->_setlocale_size) == 0 ? PL_reentrant_buffer->_setlocale_buffer : 0) # endif # endif #endif /* HAS_SETLOCALE_R */ #ifdef HAS_SETNETENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setnetent # if !defined(setnetent) && SETNETENT_R_PROTO == REENTRANT_PROTO_I_ID # define setnetent(a) (setnetent_r(a, &PL_reentrant_buffer->_netent_data) == 0 ? 1 : 0) # endif # if !defined(setnetent) && SETNETENT_R_PROTO == REENTRANT_PROTO_V_ID # define setnetent(a) setnetent_r(a, &PL_reentrant_buffer->_netent_data) # endif # endif #endif /* HAS_SETNETENT_R */ #ifdef HAS_SETPROTOENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setprotoent # if !defined(setprotoent) && SETPROTOENT_R_PROTO == REENTRANT_PROTO_I_ID # define setprotoent(a) (setprotoent_r(a, &PL_reentrant_buffer->_protoent_data) == 0 ? 1 : 0) # endif # if !defined(setprotoent) && SETPROTOENT_R_PROTO == REENTRANT_PROTO_V_ID # define setprotoent(a) setprotoent_r(a, &PL_reentrant_buffer->_protoent_data) # endif # endif #endif /* HAS_SETPROTOENT_R */ #ifdef HAS_SETPWENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setpwent # if !defined(setpwent) && SETPWENT_R_PROTO == REENTRANT_PROTO_I_H # define setpwent() (setpwent_r(&PL_reentrant_buffer->_pwent_fptr) == 0 ? 1 : 0) # endif # if !defined(setpwent) && SETPWENT_R_PROTO == REENTRANT_PROTO_V_H # define setpwent() setpwent_r(&PL_reentrant_buffer->_pwent_fptr) # endif # endif #endif /* HAS_SETPWENT_R */ #ifdef HAS_SETSERVENT_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef setservent # if !defined(setservent) && SETSERVENT_R_PROTO == REENTRANT_PROTO_I_ID # define setservent(a) (setservent_r(a, &PL_reentrant_buffer->_servent_data) == 0 ? 1 : 0) # endif # if !defined(setservent) && SETSERVENT_R_PROTO == REENTRANT_PROTO_V_ID # define setservent(a) setservent_r(a, &PL_reentrant_buffer->_servent_data) # endif # endif #endif /* HAS_SETSERVENT_R */ #ifdef HAS_SRAND48_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef srand48 # if !defined(srand48) && SRAND48_R_PROTO == REENTRANT_PROTO_I_LS # define srand48(a) (srand48_r(a, &PL_reentrant_buffer->_drand48_struct) == 0 ? &PL_reentrant_buffer->_drand48_struct : 0) # endif # endif #endif /* HAS_SRAND48_R */ #ifdef HAS_SRANDOM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef srandom # if !defined(srandom) && SRANDOM_R_PROTO == REENTRANT_PROTO_I_TS # define srandom(a) (srandom_r(a, &PL_reentrant_buffer->_srandom_struct) == 0 ? &PL_reentrant_buffer->_srandom_struct : 0) # endif # endif #endif /* HAS_SRANDOM_R */ #ifdef HAS_STRERROR_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef strerror # if !defined(strerror) && STRERROR_R_PROTO == REENTRANT_PROTO_I_IBW # define strerror(a) (strerror_r(a, PL_reentrant_buffer->_strerror_buffer, PL_reentrant_buffer->_strerror_size) == 0 ? PL_reentrant_buffer->_strerror_buffer : 0) # endif # if !defined(strerror) && STRERROR_R_PROTO == REENTRANT_PROTO_I_IBI # define strerror(a) (strerror_r(a, PL_reentrant_buffer->_strerror_buffer, PL_reentrant_buffer->_strerror_size) == 0 ? PL_reentrant_buffer->_strerror_buffer : 0) # endif # if !defined(strerror) && STRERROR_R_PROTO == REENTRANT_PROTO_B_IBW # define strerror(a) strerror_r(a, PL_reentrant_buffer->_strerror_buffer, PL_reentrant_buffer->_strerror_size) # endif # endif #endif /* HAS_STRERROR_R */ #ifdef HAS_TMPNAM_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef tmpnam # if !defined(tmpnam) && TMPNAM_R_PROTO == REENTRANT_PROTO_B_B # define tmpnam(a) tmpnam_r(a) # endif # endif #endif /* HAS_TMPNAM_R */ #ifdef HAS_TTYNAME_R # if defined(PERL_REENTR_API) && (PERL_REENTR_API+0 == 1) # undef ttyname # if !defined(ttyname) && TTYNAME_R_PROTO == REENTRANT_PROTO_I_IBW # define ttyname(a) (ttyname_r(a, PL_reentrant_buffer->_ttyname_buffer, PL_reentrant_buffer->_ttyname_size) == 0 ? PL_reentrant_buffer->_ttyname_buffer : 0) # endif # if !defined(ttyname) && TTYNAME_R_PROTO == REENTRANT_PROTO_I_IBI # define ttyname(a) (ttyname_r(a, PL_reentrant_buffer->_ttyname_buffer, PL_reentrant_buffer->_ttyname_size) == 0 ? PL_reentrant_buffer->_ttyname_buffer : 0) # endif # if !defined(ttyname) && TTYNAME_R_PROTO == REENTRANT_PROTO_B_IBI # define ttyname(a) ttyname_r(a, PL_reentrant_buffer->_ttyname_buffer, PL_reentrant_buffer->_ttyname_size) # endif # endif #endif /* HAS_TTYNAME_R */ #endif /* USE_REENTRANT_API */ #endif /* ex: set ro: */ PKZ fakesdio.hnuW+A/* fakestdio.h * * Copyright (C) 2000, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * This is "source level" stdio compatibility mode. * We try and #define stdio functions in terms of PerlIO. */ #define _CANNOT "CANNOT" #undef FILE #define FILE PerlIO #undef clearerr #undef fclose #undef fdopen #undef feof #undef ferror #undef fflush #undef fgetc #undef fgetpos #undef fgets #undef fileno #undef flockfile #undef fopen #undef fprintf #undef fputc #undef fputs #undef fread #undef freopen #undef fscanf #undef fseek #undef fsetpos #undef ftell #undef ftrylockfile #undef funlockfile #undef fwrite #undef getc #undef getc_unlocked #undef getw #undef pclose #undef popen #undef putc #undef putc_unlocked #undef putw #undef rewind #undef setbuf #undef setvbuf #undef stderr #undef stdin #undef stdout #undef tmpfile #undef ungetc #undef vfprintf #undef printf /* printf used to live in perl.h like this - more sophisticated than the rest */ #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC) #define printf(fmt,args...) PerlIO_stdoutf(fmt,##args) #else #define printf PerlIO_stdoutf #endif #define fprintf PerlIO_printf #define stdin PerlIO_stdin() #define stdout PerlIO_stdout() #define stderr PerlIO_stderr() #define tmpfile() PerlIO_tmpfile() #define fclose(f) PerlIO_close(f) #define fflush(f) PerlIO_flush(f) #define fopen(p,m) PerlIO_open(p,m) #define vfprintf(f,fmt,a) PerlIO_vprintf(f,fmt,a) #define fgetc(f) PerlIO_getc(f) #define fputc(c,f) PerlIO_putc(f,c) #define fputs(s,f) PerlIO_puts(f,s) #define getc(f) PerlIO_getc(f) #define getc_unlocked(f) PerlIO_getc(f) #define putc(c,f) PerlIO_putc(f,c) #define putc_unlocked(c,f) PerlIO_putc(c,f) #define ungetc(c,f) PerlIO_ungetc(f,c) #if 0 /* return values of read/write need work */ #define fread(b,s,c,f) PerlIO_read(f,b,(s*c)) #define fwrite(b,s,c,f) PerlIO_write(f,b,(s*c)) #else #define fread(b,s,c,f) _CANNOT fread #define fwrite(b,s,c,f) _CANNOT fwrite #endif #define fseek(f,o,w) PerlIO_seek(f,o,w) #define ftell(f) PerlIO_tell(f) #define rewind(f) PerlIO_rewind(f) #define clearerr(f) PerlIO_clearerr(f) #define feof(f) PerlIO_eof(f) #define ferror(f) PerlIO_error(f) #define fdopen(fd,p) PerlIO_fdopen(fd,p) #define fileno(f) PerlIO_fileno(f) #define popen(c,m) my_popen(c,m) #define pclose(f) my_pclose(f) #define fsetpos(f,p) _CANNOT _fsetpos_ #define fgetpos(f,p) _CANNOT _fgetpos_ #define __filbuf(f) _CANNOT __filbuf_ #define _filbuf(f) _CANNOT _filbuf_ #define __flsbuf(c,f) _CANNOT __flsbuf_ #define _flsbuf(c,f) _CANNOT _flsbuf_ #define getw(f) _CANNOT _getw_ #define putw(v,f) _CANNOT _putw_ #if SFIO_VERSION < 20000101L #define flockfile(f) _CANNOT _flockfile_ #define ftrylockfile(f) _CANNOT _ftrylockfile_ #define funlockfile(f) _CANNOT _funlockfile_ #endif #define freopen(p,m,f) _CANNOT _freopen_ #define setbuf(f,b) _CANNOT _setbuf_ #define setvbuf(f,b,x,s) _CANNOT _setvbuf_ #define fscanf _CANNOT _fscanf_ #define fgets(s,n,f) _CANNOT _fgets_ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZoԚ!$$cv.hnuW+A/* cv.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* This structure must match the beginning of XPVFM in sv.h */ struct xpvcv { _XPV_HEAD; _XPVCV_COMMON; I32 xcv_depth; /* >= 2 indicates recursive call */ }; /* =head1 Handy Values =for apidoc AmU||Nullcv Null CV pointer. (deprecated - use C<(CV *)NULL> instead) =head1 CV Manipulation Functions This section documents functions to manipulate CVs which are code-values, or subroutines. For more information, see L. =for apidoc Am|HV*|CvSTASH|CV* cv Returns the stash of the CV. A stash is the symbol table hash, containing the package-scoped variables in the package where the subroutine was defined. For more information, see L. This also has a special use with XS AUTOLOAD subs. See L. =cut */ #ifndef PERL_CORE # define Nullcv Null(CV*) #endif #define CvSTASH(sv) (0+((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_stash) #define CvSTASH_set(cv,st) Perl_cvstash_set(aTHX_ cv, st) #define CvSTART(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_start #define CvROOT(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root #define CvXSUB(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub #define CvXSUBANY(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany #define CvGV(sv) (0+((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv) #define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv) #define CvFILE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file #ifdef USE_ITHREADS # define CvFILE_set_from_cop(sv, cop) \ (CvFILE(sv) = savepv(CopFILE(cop)), CvDYNFILE_on(sv)) #else # define CvFILE_set_from_cop(sv, cop) \ (CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv)) #endif #define CvFILEGV(sv) (gv_fetchfile(CvFILE(sv))) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define CvDEPTH(sv) (*({const CV *const _cvdepth = (const CV *)sv; \ assert(SvTYPE(_cvdepth) == SVt_PVCV); \ &((XPVCV*)SvANY(_cvdepth))->xcv_depth; \ })) #else # define CvDEPTH(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth #endif #define CvPADLIST(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist #define CvOUTSIDE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside #define CvFLAGS(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_flags #define CvOUTSIDE_SEQ(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside_seq /* These two are sometimes called on non-CVs */ #define CvPROTO(sv) \ ( \ SvPOK(sv) \ ? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \ ? SvEND(sv)+1 : SvPVX_const(sv) \ : NULL \ ) #define CvPROTOLEN(sv) \ ( \ SvPOK(sv) \ ? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \ ? SvLEN(sv)-SvCUR(sv)-2 \ : SvCUR(sv) \ : 0 \ ) #define CVf_METHOD 0x0001 /* CV is explicitly marked as a method */ #define CVf_LVALUE 0x0002 /* CV return value can be used as lvalue */ #define CVf_CONST 0x0004 /* inlinable sub */ #define CVf_ISXSUB 0x0008 /* CV is an XSUB, not pure perl. */ #define CVf_WEAKOUTSIDE 0x0010 /* CvOUTSIDE isn't ref counted */ #define CVf_CLONE 0x0020 /* anon CV uses external lexicals */ #define CVf_CLONED 0x0040 /* a clone of one of those */ #define CVf_ANON 0x0080 /* CV is not pointed to by a GV */ #define CVf_UNIQUE 0x0100 /* sub is only called once (eg PL_main_cv, * require, eval). */ #define CVf_NODEBUG 0x0200 /* no DB::sub indirection for this CV (esp. useful for special XSUBs) */ #define CVf_CVGV_RC 0x0400 /* CvGV is reference counted */ #define CVf_DYNFILE 0x1000 /* The filename isn't static */ #define CVf_AUTOLOAD 0x2000 /* SvPVX contains AUTOLOADed sub name */ /* This symbol for optimised communication between toke.c and op.c: */ #define CVf_BUILTIN_ATTRS (CVf_METHOD|CVf_LVALUE) #define CvCLONE(cv) (CvFLAGS(cv) & CVf_CLONE) #define CvCLONE_on(cv) (CvFLAGS(cv) |= CVf_CLONE) #define CvCLONE_off(cv) (CvFLAGS(cv) &= ~CVf_CLONE) #define CvCLONED(cv) (CvFLAGS(cv) & CVf_CLONED) #define CvCLONED_on(cv) (CvFLAGS(cv) |= CVf_CLONED) #define CvCLONED_off(cv) (CvFLAGS(cv) &= ~CVf_CLONED) #define CvANON(cv) (CvFLAGS(cv) & CVf_ANON) #define CvANON_on(cv) (CvFLAGS(cv) |= CVf_ANON) #define CvANON_off(cv) (CvFLAGS(cv) &= ~CVf_ANON) #define CvUNIQUE(cv) (CvFLAGS(cv) & CVf_UNIQUE) #define CvUNIQUE_on(cv) (CvFLAGS(cv) |= CVf_UNIQUE) #define CvUNIQUE_off(cv) (CvFLAGS(cv) &= ~CVf_UNIQUE) #define CvNODEBUG(cv) (CvFLAGS(cv) & CVf_NODEBUG) #define CvNODEBUG_on(cv) (CvFLAGS(cv) |= CVf_NODEBUG) #define CvNODEBUG_off(cv) (CvFLAGS(cv) &= ~CVf_NODEBUG) #define CvMETHOD(cv) (CvFLAGS(cv) & CVf_METHOD) #define CvMETHOD_on(cv) (CvFLAGS(cv) |= CVf_METHOD) #define CvMETHOD_off(cv) (CvFLAGS(cv) &= ~CVf_METHOD) #define CvLVALUE(cv) (CvFLAGS(cv) & CVf_LVALUE) #define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE) #define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE) #define CvEVAL(cv) (CvUNIQUE(cv) && !SvFAKE(cv)) #define CvEVAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_off(cv)) #define CvEVAL_off(cv) CvUNIQUE_off(cv) /* BEGIN|CHECK|INIT|UNITCHECK|END */ #define CvSPECIAL(cv) (CvUNIQUE(cv) && SvFAKE(cv)) #define CvSPECIAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_on(cv)) #define CvSPECIAL_off(cv) (CvUNIQUE_off(cv),SvFAKE_off(cv)) #define CvCONST(cv) (CvFLAGS(cv) & CVf_CONST) #define CvCONST_on(cv) (CvFLAGS(cv) |= CVf_CONST) #define CvCONST_off(cv) (CvFLAGS(cv) &= ~CVf_CONST) #define CvWEAKOUTSIDE(cv) (CvFLAGS(cv) & CVf_WEAKOUTSIDE) #define CvWEAKOUTSIDE_on(cv) (CvFLAGS(cv) |= CVf_WEAKOUTSIDE) #define CvWEAKOUTSIDE_off(cv) (CvFLAGS(cv) &= ~CVf_WEAKOUTSIDE) #define CvISXSUB(cv) (CvFLAGS(cv) & CVf_ISXSUB) #define CvISXSUB_on(cv) (CvFLAGS(cv) |= CVf_ISXSUB) #define CvISXSUB_off(cv) (CvFLAGS(cv) &= ~CVf_ISXSUB) #define CvCVGV_RC(cv) (CvFLAGS(cv) & CVf_CVGV_RC) #define CvCVGV_RC_on(cv) (CvFLAGS(cv) |= CVf_CVGV_RC) #define CvCVGV_RC_off(cv) (CvFLAGS(cv) &= ~CVf_CVGV_RC) #define CvDYNFILE(cv) (CvFLAGS(cv) & CVf_DYNFILE) #define CvDYNFILE_on(cv) (CvFLAGS(cv) |= CVf_DYNFILE) #define CvDYNFILE_off(cv) (CvFLAGS(cv) &= ~CVf_DYNFILE) #define CvAUTOLOAD(cv) (CvFLAGS(cv) & CVf_AUTOLOAD) #define CvAUTOLOAD_on(cv) (CvFLAGS(cv) |= CVf_AUTOLOAD) #define CvAUTOLOAD_off(cv) (CvFLAGS(cv) &= ~CVf_AUTOLOAD) /* Flags for newXS_flags */ #define XS_DYNAMIC_FILENAME 0x01 /* The filename isn't static */ /* =head1 CV reference counts and CvOUTSIDE =for apidoc m|bool|CvWEAKOUTSIDE|CV *cv Each CV has a pointer, C, to its lexically enclosing CV (if any). Because pointers to anonymous sub prototypes are stored in C<&> pad slots, it is a possible to get a circular reference, with the parent pointing to the child and vice-versa. To avoid the ensuing memory leak, we do not increment the reference count of the CV pointed to by C in the I that the parent has a C<&> pad slot pointing back to us. In this case, we set the C flag in the child. This allows us to determine under what circumstances we should decrement the refcount of the parent when freeing the child. There is a further complication with non-closure anonymous subs (i.e. those that do not refer to any lexicals outside that sub). In this case, the anonymous prototype is shared rather than being cloned. This has the consequence that the parent may be freed while there are still active children, eg BEGIN { $a = sub { eval '$x' } } In this case, the BEGIN is freed immediately after execution since there are no active references to it: the anon sub prototype has C set since it's not a closure, and $a points to the same CV, so it doesn't contribute to BEGIN's refcount either. When $a is executed, the C causes the chain of Cs to be followed, and the freed BEGIN is accessed. To avoid this, whenever a CV and its associated pad is freed, any C<&> entries in the pad are explicitly removed from the pad, and if the refcount of the pointed-to anon sub is still positive, then that child's C is set to point to its grandparent. This will only occur in the single specific case of a non-closure anon prototype having one or more active references (such as C<$a> above). One other thing to consider is that a CV may be merely undefined rather than freed, eg C. In this case, its refcount may not have reached zero, but we still delete its pad and its C etc. Since various children may still have their C pointing at this undefined CV, we keep its own C for the time being, so that the chain of lexical scopes is unbroken. For example, the following should print 123: my $x = 123; sub tmp { sub { eval '$x' } } my $a = tmp(); undef &tmp; print $a->(); =cut */ typedef OP *(*Perl_call_checker)(pTHX_ OP *, GV *, SV *); /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZmB..thread.hnuW+A/* thread.h * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, * by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #if defined(USE_ITHREADS) #if defined(VMS) #include #endif #ifdef WIN32 # include #else #ifdef NETWARE # include #else # ifdef OLD_PTHREADS_API /* Here be dragons. */ # define DETACH(t) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_detach(&(t)->self))) { \ MUTEX_UNLOCK(&(t)->mutex); \ Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } \ } STMT_END # define PERL_GET_CONTEXT Perl_get_context() # define PERL_SET_CONTEXT(t) Perl_set_context((void*)t) # define PTHREAD_GETSPECIFIC_INT # ifdef DJGPP # define pthread_addr_t any_t # define NEED_PTHREAD_INIT # define PTHREAD_CREATE_JOINABLE (1) # endif # ifdef __OPEN_VM # define pthread_addr_t void * # endif # ifdef OEMVS # define pthread_addr_t void * # define pthread_create(t,a,s,d) pthread_create(t,&(a),s,d) # define pthread_keycreate pthread_key_create # endif # ifdef VMS # define pthread_attr_init(a) pthread_attr_create(a) # define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_setdetach_np(a,s) # define PTHREAD_CREATE(t,a,s,d) pthread_create(t,a,s,d) # define pthread_key_create(k,d) pthread_keycreate(k,(pthread_destructor_t)(d)) # define pthread_mutexattr_init(a) pthread_mutexattr_create(a) # define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t) # endif # if defined(__hpux) && defined(__ux_version) && __ux_version <= 1020 # define pthread_attr_init(a) pthread_attr_create(a) /* XXX pthread_setdetach_np() missing in DCE threads on HP-UX 10.20 */ # define PTHREAD_ATTR_SETDETACHSTATE(a,s) (0) # define PTHREAD_CREATE(t,a,s,d) pthread_create(t,a,s,d) # define pthread_key_create(k,d) pthread_keycreate(k,(pthread_destructor_t)(d)) # define pthread_mutexattr_init(a) pthread_mutexattr_create(a) # define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t) # endif # if defined(DJGPP) || defined(__OPEN_VM) || defined(OEMVS) # define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,&(s)) # define YIELD pthread_yield(NULL) # endif # endif # if !defined(__hpux) || !defined(__ux_version) || __ux_version > 1020 # define pthread_mutexattr_default NULL # define pthread_condattr_default NULL # endif #endif /* NETWARE */ #endif #ifndef PTHREAD_CREATE /* You are not supposed to pass NULL as the 2nd arg of PTHREAD_CREATE(). */ # define PTHREAD_CREATE(t,a,s,d) pthread_create(t,&(a),s,d) #endif #ifndef PTHREAD_ATTR_SETDETACHSTATE # define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,s) #endif #ifndef PTHREAD_CREATE_JOINABLE # ifdef OLD_PTHREAD_CREATE_JOINABLE # define PTHREAD_CREATE_JOINABLE OLD_PTHREAD_CREATE_JOINABLE # else # define PTHREAD_CREATE_JOINABLE 0 /* Panic? No, guess. */ # endif #endif #ifdef DGUX # define THREAD_CREATE_NEEDS_STACK (32*1024) #endif #ifdef __VMS /* Default is 1024 on VAX, 8192 otherwise */ # ifdef __ia64 # define THREAD_CREATE_NEEDS_STACK (48*1024) # else # define THREAD_CREATE_NEEDS_STACK (32*1024) # endif #endif #ifdef I_MACH_CTHREADS /* cthreads interface */ /* #include is in perl.h #ifdef I_MACH_CTHREADS */ #define MUTEX_INIT(m) \ STMT_START { \ *m = mutex_alloc(); \ if (*m) { \ mutex_init(*m); \ } else { \ Perl_croak_nocontext("panic: MUTEX_INIT [%s:%d]", \ __FILE__, __LINE__); \ } \ } STMT_END #define MUTEX_LOCK(m) mutex_lock(*m) #define MUTEX_UNLOCK(m) mutex_unlock(*m) #define MUTEX_DESTROY(m) \ STMT_START { \ mutex_free(*m); \ *m = 0; \ } STMT_END #define COND_INIT(c) \ STMT_START { \ *c = condition_alloc(); \ if (*c) { \ condition_init(*c); \ } \ else { \ Perl_croak_nocontext("panic: COND_INIT [%s:%d]", \ __FILE__, __LINE__); \ } \ } STMT_END #define COND_SIGNAL(c) condition_signal(*c) #define COND_BROADCAST(c) condition_broadcast(*c) #define COND_WAIT(c, m) condition_wait(*c, *m) #define COND_DESTROY(c) \ STMT_START { \ condition_free(*c); \ *c = 0; \ } STMT_END #define THREAD_CREATE(thr, f) (thr->self = cthread_fork(f, thr), 0) #define THREAD_POST_CREATE(thr) #define THREAD_RET_TYPE any_t #define THREAD_RET_CAST(x) ((any_t) x) #define DETACH(t) cthread_detach(t->self) #define JOIN(t, avp) (*(avp) = MUTABLE_AV(cthread_join(t->self))) #define PERL_SET_CONTEXT(t) cthread_set_data(cthread_self(), t) #define PERL_GET_CONTEXT cthread_data(cthread_self()) #define INIT_THREADS cthread_init() #define YIELD cthread_yield() #define ALLOC_THREAD_KEY NOOP #define FREE_THREAD_KEY NOOP #define SET_THREAD_SELF(thr) (thr->self = cthread_self()) #endif /* I_MACH_CTHREADS */ #ifndef YIELD # ifdef SCHED_YIELD # define YIELD SCHED_YIELD # else # ifdef HAS_SCHED_YIELD # define YIELD sched_yield() # else # ifdef HAS_PTHREAD_YIELD /* pthread_yield(NULL) platforms are expected * to have #defined YIELD for themselves. */ # define YIELD pthread_yield() # endif # endif # endif #endif #ifdef __hpux # define MUTEX_INIT_NEEDS_MUTEX_ZEROED #endif #ifndef MUTEX_INIT # ifdef MUTEX_INIT_NEEDS_MUTEX_ZEROED /* Temporary workaround, true bug is deeper. --jhi 1999-02-25 */ # define MUTEX_INIT(m) \ STMT_START { \ int _eC_; \ Zero((m), 1, perl_mutex); \ if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default))) \ Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # else # define MUTEX_INIT(m) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default))) \ Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # endif # define MUTEX_LOCK(m) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_mutex_lock((m)))) \ Perl_croak_nocontext("panic: MUTEX_LOCK (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define MUTEX_UNLOCK(m) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_mutex_unlock((m)))) \ Perl_croak_nocontext("panic: MUTEX_UNLOCK (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define MUTEX_DESTROY(m) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_mutex_destroy((m)))) \ Perl_croak_nocontext("panic: MUTEX_DESTROY (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END #endif /* MUTEX_INIT */ #ifndef COND_INIT # define COND_INIT(c) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_cond_init((c), pthread_condattr_default))) \ Perl_croak_nocontext("panic: COND_INIT (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define COND_SIGNAL(c) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_cond_signal((c)))) \ Perl_croak_nocontext("panic: COND_SIGNAL (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define COND_BROADCAST(c) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_cond_broadcast((c)))) \ Perl_croak_nocontext("panic: COND_BROADCAST (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define COND_WAIT(c, m) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_cond_wait((c), (m)))) \ Perl_croak_nocontext("panic: COND_WAIT (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END # define COND_DESTROY(c) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_cond_destroy((c)))) \ Perl_croak_nocontext("panic: COND_DESTROY (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END #endif /* COND_INIT */ /* DETACH(t) must only be called while holding t->mutex */ #ifndef DETACH # define DETACH(t) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_detach((t)->self))) { \ MUTEX_UNLOCK(&(t)->mutex); \ Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } \ } STMT_END #endif /* DETACH */ #ifndef JOIN # define JOIN(t, avp) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_join((t)->self, (void**)(avp)))) \ Perl_croak_nocontext("panic: pthread_join (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END #endif /* JOIN */ /* Use an unchecked fetch of thread-specific data instead of a checked one. * It would fail if the key were bogus, but if the key were bogus then * Really Bad Things would be happening anyway. --dan */ #if (defined(__ALPHA) && (__VMS_VER >= 70000000)) || \ (defined(__alpha) && defined(__osf__) && !defined(__GNUC__)) /* Available only on >= 4.0 */ # define HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP /* Configure test needed */ #endif #ifdef HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP # define PTHREAD_GETSPECIFIC(key) pthread_unchecked_getspecific_np(key) #else # define PTHREAD_GETSPECIFIC(key) pthread_getspecific(key) #endif #ifndef PERL_GET_CONTEXT # define PERL_GET_CONTEXT PTHREAD_GETSPECIFIC(PL_thr_key) #endif #ifndef PERL_SET_CONTEXT # define PERL_SET_CONTEXT(t) \ STMT_START { \ int _eC_; \ if ((_eC_ = pthread_setspecific(PL_thr_key, (void *)(t)))) \ Perl_croak_nocontext("panic: pthread_setspecific (%d) [%s:%d]", \ _eC_, __FILE__, __LINE__); \ } STMT_END #endif /* PERL_SET_CONTEXT */ #ifndef INIT_THREADS # ifdef NEED_PTHREAD_INIT # define INIT_THREADS pthread_init() # endif #endif #ifndef ALLOC_THREAD_KEY # define ALLOC_THREAD_KEY \ STMT_START { \ if (pthread_key_create(&PL_thr_key, 0)) { \ write(2, STR_WITH_LEN("panic: pthread_key_create failed\n")); \ exit(1); \ } \ } STMT_END #endif #ifndef FREE_THREAD_KEY # define FREE_THREAD_KEY \ STMT_START { \ pthread_key_delete(PL_thr_key); \ } STMT_END #endif #ifndef PTHREAD_ATFORK # ifdef HAS_PTHREAD_ATFORK # define PTHREAD_ATFORK(prepare,parent,child) \ pthread_atfork(prepare,parent,child) # else # define PTHREAD_ATFORK(prepare,parent,child) \ NOOP # endif #endif #ifndef THREAD_RET_TYPE # define THREAD_RET_TYPE void * # define THREAD_RET_CAST(p) ((void *)(p)) #endif /* THREAD_RET */ # define LOCK_DOLLARZERO_MUTEX MUTEX_LOCK(&PL_dollarzero_mutex) # define UNLOCK_DOLLARZERO_MUTEX MUTEX_UNLOCK(&PL_dollarzero_mutex) #endif /* USE_ITHREADS */ #ifndef MUTEX_LOCK # define MUTEX_LOCK(m) #endif #ifndef MUTEX_UNLOCK # define MUTEX_UNLOCK(m) #endif #ifndef MUTEX_INIT # define MUTEX_INIT(m) #endif #ifndef MUTEX_DESTROY # define MUTEX_DESTROY(m) #endif #ifndef COND_INIT # define COND_INIT(c) #endif #ifndef COND_SIGNAL # define COND_SIGNAL(c) #endif #ifndef COND_BROADCAST # define COND_BROADCAST(c) #endif #ifndef COND_WAIT # define COND_WAIT(c, m) #endif #ifndef COND_DESTROY # define COND_DESTROY(c) #endif #ifndef LOCK_DOLLARZERO_MUTEX # define LOCK_DOLLARZERO_MUTEX #endif #ifndef UNLOCK_DOLLARZERO_MUTEX # define UNLOCK_DOLLARZERO_MUTEX #endif /* THR, SET_THR, and dTHR are there for compatibility with old versions */ #ifndef THR # define THR PERL_GET_THX #endif #ifndef SET_THR # define SET_THR(t) PERL_SET_THX(t) #endif #ifndef dTHR # define dTHR dNOOP #endif #ifndef INIT_THREADS # define INIT_THREADS NOOP #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ:^^hv.hnuW+A/* hv.h * * Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999, * 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* entry in hash value chain */ struct he { /* Keep hent_next first in this structure, because sv_free_arenas take advantage of this to share code between the he arenas and the SV body arenas */ HE *hent_next; /* next entry in chain */ HEK *hent_hek; /* hash key */ union { SV *hent_val; /* scalar value that was hashed */ Size_t hent_refcount; /* references for this shared hash key */ } he_valu; }; /* hash key -- defined separately for use as shared pointer */ struct hek { U32 hek_hash; /* hash of key */ I32 hek_len; /* length of hash key */ char hek_key[1]; /* variable-length hash key */ /* the hash-key is \0-terminated */ /* after the \0 there is a byte for flags, such as whether the key is UTF-8 */ }; struct shared_he { struct he shared_he_he; struct hek shared_he_hek; }; /* Subject to change. Don't access this directly. Use the funcs in mro.c */ struct mro_alg { AV *(*resolve)(pTHX_ HV* stash, U32 level); const char *name; U16 length; U16 kflags; /* For the hash API - set HVhek_UTF8 if name is UTF-8 */ U32 hash; /* or 0 */ }; struct mro_meta { /* a hash holding the different MROs private data. */ HV *mro_linear_all; /* a pointer directly to the current MROs private data. If mro_linear_all is NULL, this owns the SV reference, else it is just a pointer to a value stored in and owned by mro_linear_all. */ SV *mro_linear_current; HV *mro_nextmethod; /* next::method caching */ U32 cache_gen; /* Bumping this invalidates our method cache */ U32 pkg_gen; /* Bumps when local methods/@ISA change */ const struct mro_alg *mro_which; /* which mro alg is in use? */ HV *isa; /* Everything this class @ISA */ }; #define MRO_GET_PRIVATE_DATA(smeta, which) \ (((smeta)->mro_which && (which) == (smeta)->mro_which) \ ? (smeta)->mro_linear_current \ : Perl_mro_get_private_data(aTHX_ (smeta), (which))) /* Subject to change. Don't access this directly. */ union _xhvnameu { HEK *xhvnameu_name; /* When xhv_name_count is 0 */ HEK **xhvnameu_names; /* When xhv_name_count is non-0 */ }; struct xpvhv_aux { union _xhvnameu xhv_name_u; /* name, if a symbol table */ AV *xhv_backreferences; /* back references for weak references */ HE *xhv_eiter; /* current entry of iterator */ I32 xhv_riter; /* current root of iterator */ /* Concerning xhv_name_count: When non-zero, xhv_name_u contains a pointer * to an array of HEK pointers, this being the length. The first element is * the name of the stash, which may be NULL. If xhv_name_count is positive, * then *xhv_name is one of the effective names. If xhv_name_count is nega- * tive, then xhv_name_u.xhvnameu_names[1] is the first effective name. */ I32 xhv_name_count; struct mro_meta *xhv_mro_meta; }; /* hash structure: */ /* This structure must match the beginning of struct xpvmg in sv.h. */ struct xpvhv { HV* xmg_stash; /* class package */ union _xmgu xmg_u; STRLEN xhv_keys; /* total keys, including placeholders */ STRLEN xhv_max; /* subscript of last element of xhv_array */ }; /* hash a key */ /* FYI: This is the "One-at-a-Time" algorithm by Bob Jenkins * from requirements by Colin Plumb. * (http://burtleburtle.net/bob/hash/doobs.html) */ /* The use of a temporary pointer and the casting games * is needed to serve the dual purposes of * (a) the hashed data being interpreted as "unsigned char" (new since 5.8, * a "char" can be either signed or unsigned, depending on the compiler) * (b) catering for old code that uses a "char" * * The "hash seed" feature was added in Perl 5.8.1 to perturb the results * to avoid "algorithmic complexity attacks". * * If USE_HASH_SEED is defined, hash randomisation is done by default * If USE_HASH_SEED_EXPLICIT is defined, hash randomisation is done * only if the environment variable PERL_HASH_SEED is set. * For maximal control, one can define PERL_HASH_SEED. * (see also perl.c:perl_parse()). */ #ifndef PERL_HASH_SEED # if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) # define PERL_HASH_SEED PL_hash_seed # else # define PERL_HASH_SEED 0 # endif #endif #define PERL_HASH(hash,str,len) PERL_HASH_INTERNAL_(hash,str,len,0) /* Only hv.c and mod_perl should be doing this. */ #ifdef PERL_HASH_INTERNAL_ACCESS #define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH_INTERNAL_(hash,str,len,1) #endif /* Common base for PERL_HASH and PERL_HASH_INTERNAL that parameterises * the source of the seed. Not for direct use outside of hv.c. */ #define PERL_HASH_INTERNAL_(hash,str,len,internal) \ STMT_START { \ register const char * const s_PeRlHaSh_tmp = str; \ register const unsigned char *s_PeRlHaSh = (const unsigned char *)s_PeRlHaSh_tmp; \ register I32 i_PeRlHaSh = len; \ register U32 hash_PeRlHaSh = (internal ? PL_rehash_seed : PERL_HASH_SEED); \ while (i_PeRlHaSh--) { \ hash_PeRlHaSh += *s_PeRlHaSh++; \ hash_PeRlHaSh += (hash_PeRlHaSh << 10); \ hash_PeRlHaSh ^= (hash_PeRlHaSh >> 6); \ } \ hash_PeRlHaSh += (hash_PeRlHaSh << 3); \ hash_PeRlHaSh ^= (hash_PeRlHaSh >> 11); \ (hash) = (hash_PeRlHaSh + (hash_PeRlHaSh << 15)); \ } STMT_END /* =head1 Hash Manipulation Functions =for apidoc AmU||HEf_SVKEY This flag, used in the length slot of hash entries and magic structures, specifies the structure contains an C pointer where a C pointer is to be expected. (For information only--not to be used). =head1 Handy Values =for apidoc AmU||Nullhv Null HV pointer. (deprecated - use C<(HV *)NULL> instead) =head1 Hash Manipulation Functions =for apidoc Am|char*|HvNAME|HV* stash Returns the package name of a stash, or NULL if C isn't a stash. See C, C. =for apidoc Am|STRLEN|HvNAMELEN|HV *stash Returns the length of the stash's name. =for apidoc Am|unsigned char|HvNAMEUTF8|HV *stash Returns true if the name is in UTF8 encoding. =for apidoc Am|char*|HvENAME|HV* stash Returns the effective name of a stash, or NULL if there is none. The effective name represents a location in the symbol table where this stash resides. It is updated automatically when packages are aliased or deleted. A stash that is no longer in the symbol table has no effective name. This name is preferable to C for use in MRO linearisations and isa caches. =for apidoc Am|STRLEN|HvENAMELEN|HV *stash Returns the length of the stash's effective name. =for apidoc Am|unsigned char|HvENAMEUTF8|HV *stash Returns true if the effective name is in UTF8 encoding. =for apidoc Am|void*|HeKEY|HE* he Returns the actual pointer stored in the key slot of the hash entry. The pointer may be either C or C, depending on the value of C. Can be assigned to. The C or C macros are usually preferable for finding the value of a key. =for apidoc Am|STRLEN|HeKLEN|HE* he If this is negative, and amounts to C, it indicates the entry holds an C key. Otherwise, holds the actual length of the key. Can be assigned to. The C macro is usually preferable for finding key lengths. =for apidoc Am|SV*|HeVAL|HE* he Returns the value slot (type C) stored in the hash entry. =for apidoc Am|U32|HeHASH|HE* he Returns the computed hash stored in the hash entry. =for apidoc Am|char*|HePV|HE* he|STRLEN len Returns the key slot of the hash entry as a C value, doing any necessary dereferencing of possibly C keys. The length of the string is placed in C (this is a macro, so do I use C<&len>). If you do not care about what the length of the key is, you may use the global variable C, though this is rather less efficient than using a local variable. Remember though, that hash keys in perl are free to contain embedded nulls, so using C or similar is not a good way to find the length of hash keys. This is very similar to the C macro described elsewhere in this document. See also C. If you are using C to get values to pass to C to create a new SV, you should consider using C as it is more efficient. =for apidoc Am|char*|HeUTF8|HE* he Returns whether the C value returned by C is encoded in UTF-8, doing any necessary dereferencing of possibly C keys. The value returned will be 0 or non-0, not necessarily 1 (or even a value with any low bits set), so B blindly assign this to a C variable, as C may be a typedef for C. =for apidoc Am|SV*|HeSVKEY|HE* he Returns the key as an C, or C if the hash entry does not contain an C key. =for apidoc Am|SV*|HeSVKEY_force|HE* he Returns the key as an C. Will create and return a temporary mortal C if the hash entry contains only a C key. =for apidoc Am|SV*|HeSVKEY_set|HE* he|SV* sv Sets the key to a given C, taking care to set the appropriate flags to indicate the presence of an C key, and returns the same C. =cut */ /* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */ #define HEf_SVKEY -2 /* hent_key is an SV* */ #ifndef PERL_CORE # define Nullhv Null(HV*) #endif #define HvARRAY(hv) ((hv)->sv_u.svu_hash) #define HvFILL(hv) Perl_hv_fill(aTHX_ (const HV *)(hv)) #define HvMAX(hv) ((XPVHV*) SvANY(hv))->xhv_max /* This quite intentionally does no flag checking first. That's your responsibility. */ #define HvAUX(hv) ((struct xpvhv_aux*)&(HvARRAY(hv)[HvMAX(hv)+1])) #define HvRITER(hv) (*Perl_hv_riter_p(aTHX_ MUTABLE_HV(hv))) #define HvEITER(hv) (*Perl_hv_eiter_p(aTHX_ MUTABLE_HV(hv))) #define HvRITER_set(hv,r) Perl_hv_riter_set(aTHX_ MUTABLE_HV(hv), r) #define HvEITER_set(hv,e) Perl_hv_eiter_set(aTHX_ MUTABLE_HV(hv), e) #define HvRITER_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_riter : -1) #define HvEITER_get(hv) (SvOOK(hv) ? HvAUX(hv)->xhv_eiter : NULL) #define HvNAME(hv) HvNAME_get(hv) #define HvNAMELEN(hv) HvNAMELEN_get(hv) #define HvENAME(hv) HvENAME_get(hv) #define HvENAMELEN(hv) HvENAMELEN_get(hv) /* Checking that hv is a valid package stash is the caller's responsibility */ #define HvMROMETA(hv) (HvAUX(hv)->xhv_mro_meta \ ? HvAUX(hv)->xhv_mro_meta \ : Perl_mro_meta_init(aTHX_ hv)) #define HvNAME_HEK_NN(hv) \ ( \ HvAUX(hv)->xhv_name_count \ ? *HvAUX(hv)->xhv_name_u.xhvnameu_names \ : HvAUX(hv)->xhv_name_u.xhvnameu_name \ ) /* This macro may go away without notice. */ #define HvNAME_HEK(hv) \ (SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvNAME_HEK_NN(hv) : NULL) #define HvNAME_get(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \ ? HEK_KEY(HvNAME_HEK_NN(hv)) : NULL) #define HvNAMELEN_get(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \ ? HEK_LEN(HvNAME_HEK_NN(hv)) : 0) #define HvNAMEUTF8(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \ ? HEK_UTF8(HvNAME_HEK_NN(hv)) : 0) #define HvENAME_HEK_NN(hv) \ ( \ HvAUX(hv)->xhv_name_count > 0 ? HvAUX(hv)->xhv_name_u.xhvnameu_names[0] : \ HvAUX(hv)->xhv_name_count < -1 ? HvAUX(hv)->xhv_name_u.xhvnameu_names[1] : \ HvAUX(hv)->xhv_name_count == -1 ? NULL : \ HvAUX(hv)->xhv_name_u.xhvnameu_name \ ) #define HvENAME_HEK(hv) \ (SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvENAME_HEK_NN(hv) : NULL) #define HvENAME_get(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \ ? HEK_KEY(HvENAME_HEK_NN(hv)) : NULL) #define HvENAMELEN_get(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \ ? HEK_LEN(HvENAME_HEK_NN(hv)) : 0) #define HvENAMEUTF8(hv) \ ((SvOOK(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvAUX(hv)->xhv_name_count != -1) \ ? HEK_UTF8(HvENAME_HEK_NN(hv)) : 0) /* the number of keys (including any placeholders) */ #define XHvTOTALKEYS(xhv) ((xhv)->xhv_keys) /* * HvKEYS gets the number of keys that actually exist(), and is provided * for backwards compatibility with old XS code. The core uses HvUSEDKEYS * (keys, excluding placeholders) and HvTOTALKEYS (including placeholders) */ #define HvKEYS(hv) HvUSEDKEYS(hv) #define HvUSEDKEYS(hv) (HvTOTALKEYS(hv) - HvPLACEHOLDERS_get(hv)) #define HvTOTALKEYS(hv) XHvTOTALKEYS((XPVHV*) SvANY(hv)) #define HvPLACEHOLDERS(hv) (*Perl_hv_placeholders_p(aTHX_ MUTABLE_HV(hv))) #define HvPLACEHOLDERS_get(hv) (SvMAGIC(hv) ? Perl_hv_placeholders_get(aTHX_ (const HV *)hv) : 0) #define HvPLACEHOLDERS_set(hv,p) Perl_hv_placeholders_set(aTHX_ MUTABLE_HV(hv), p) #define HvSHAREKEYS(hv) (SvFLAGS(hv) & SVphv_SHAREKEYS) #define HvSHAREKEYS_on(hv) (SvFLAGS(hv) |= SVphv_SHAREKEYS) #define HvSHAREKEYS_off(hv) (SvFLAGS(hv) &= ~SVphv_SHAREKEYS) /* This is an optimisation flag. It won't be set if all hash keys have a 0 * flag. Currently the only flags relate to utf8. * Hence it won't be set if all keys are 8 bit only. It will be set if any key * is utf8 (including 8 bit keys that were entered as utf8, and need upgrading * when retrieved during iteration. It may still be set when there are no longer * any utf8 keys. * See HVhek_ENABLEHVKFLAGS for the trigger. */ #define HvHASKFLAGS(hv) (SvFLAGS(hv) & SVphv_HASKFLAGS) #define HvHASKFLAGS_on(hv) (SvFLAGS(hv) |= SVphv_HASKFLAGS) #define HvHASKFLAGS_off(hv) (SvFLAGS(hv) &= ~SVphv_HASKFLAGS) #define HvLAZYDEL(hv) (SvFLAGS(hv) & SVphv_LAZYDEL) #define HvLAZYDEL_on(hv) (SvFLAGS(hv) |= SVphv_LAZYDEL) #define HvLAZYDEL_off(hv) (SvFLAGS(hv) &= ~SVphv_LAZYDEL) #define HvREHASH(hv) (SvFLAGS(hv) & SVphv_REHASH) #define HvREHASH_on(hv) (SvFLAGS(hv) |= SVphv_REHASH) #define HvREHASH_off(hv) (SvFLAGS(hv) &= ~SVphv_REHASH) #ifndef PERL_CORE # define Nullhe Null(HE*) #endif #define HeNEXT(he) (he)->hent_next #define HeKEY_hek(he) (he)->hent_hek #define HeKEY(he) HEK_KEY(HeKEY_hek(he)) #define HeKEY_sv(he) (*(SV**)HeKEY(he)) #define HeKLEN(he) HEK_LEN(HeKEY_hek(he)) #define HeKUTF8(he) HEK_UTF8(HeKEY_hek(he)) #define HeKWASUTF8(he) HEK_WASUTF8(HeKEY_hek(he)) #define HeKREHASH(he) HEK_REHASH(HeKEY_hek(he)) #define HeKLEN_UTF8(he) (HeKUTF8(he) ? -HeKLEN(he) : HeKLEN(he)) #define HeKFLAGS(he) HEK_FLAGS(HeKEY_hek(he)) #define HeVAL(he) (he)->he_valu.hent_val #define HeHASH(he) HEK_HASH(HeKEY_hek(he)) #define HePV(he,lp) ((HeKLEN(he) == HEf_SVKEY) ? \ SvPV(HeKEY_sv(he),lp) : \ ((lp = HeKLEN(he)), HeKEY(he))) #define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \ SvUTF8(HeKEY_sv(he)) : \ (U32)HeKUTF8(he)) #define HeSVKEY(he) ((HeKEY(he) && \ HeKLEN(he) == HEf_SVKEY) ? \ HeKEY_sv(he) : NULL) #define HeSVKEY_force(he) (HeKEY(he) ? \ ((HeKLEN(he) == HEf_SVKEY) ? \ HeKEY_sv(he) : \ newSVpvn_flags(HeKEY(he), \ HeKLEN(he), SVs_TEMP)) : \ &PL_sv_undef) #define HeSVKEY_set(he,sv) ((HeKLEN(he) = HEf_SVKEY), (HeKEY_sv(he) = sv)) #ifndef PERL_CORE # define Nullhek Null(HEK*) #endif #define HEK_BASESIZE STRUCT_OFFSET(HEK, hek_key[0]) #define HEK_HASH(hek) (hek)->hek_hash #define HEK_LEN(hek) (hek)->hek_len #define HEK_KEY(hek) (hek)->hek_key #define HEK_FLAGS(hek) (*((unsigned char *)(HEK_KEY(hek))+HEK_LEN(hek)+1)) #define HVhek_UTF8 0x01 /* Key is utf8 encoded. */ #define HVhek_WASUTF8 0x02 /* Key is bytes here, but was supplied as utf8. */ #define HVhek_REHASH 0x04 /* This key is in an hv using a custom HASH . */ #define HVhek_UNSHARED 0x08 /* This key isn't a shared hash key. */ #define HVhek_FREEKEY 0x100 /* Internal flag to say key is malloc()ed. */ #define HVhek_PLACEHOLD 0x200 /* Internal flag to create placeholder. * (may change, but Storable is a core module) */ #define HVhek_KEYCANONICAL 0x400 /* Internal flag - key is in canonical form. If the string is UTF-8, it cannot be converted to bytes. */ #define HVhek_MASK 0xFF /* Which flags enable HvHASKFLAGS? Somewhat a hack on a hack, as HVhek_REHASH is only needed because the rehash flag has to be duplicated into all keys as hv_iternext has no access to the hash flags. At this point Storable's tests get upset, because sometimes hashes are "keyed" and sometimes not, depending on the order of data insertion, and whether it triggered rehashing. So currently HVhek_REHASH is exempt. Similarly UNSHARED */ #define HVhek_ENABLEHVKFLAGS (HVhek_MASK & ~(HVhek_REHASH|HVhek_UNSHARED)) #define HEK_UTF8(hek) (HEK_FLAGS(hek) & HVhek_UTF8) #define HEK_UTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_UTF8) #define HEK_UTF8_off(hek) (HEK_FLAGS(hek) &= ~HVhek_UTF8) #define HEK_WASUTF8(hek) (HEK_FLAGS(hek) & HVhek_WASUTF8) #define HEK_WASUTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_WASUTF8) #define HEK_WASUTF8_off(hek) (HEK_FLAGS(hek) &= ~HVhek_WASUTF8) #define HEK_REHASH(hek) (HEK_FLAGS(hek) & HVhek_REHASH) #define HEK_REHASH_on(hek) (HEK_FLAGS(hek) |= HVhek_REHASH) /* calculate HV array allocation */ #ifndef PERL_USE_LARGE_HV_ALLOC /* Default to allocating the correct size - default to assuming that malloc() is not broken and is efficient at allocating blocks sized at powers-of-two. */ # define PERL_HV_ARRAY_ALLOC_BYTES(size) ((size) * sizeof(HE*)) #else # define MALLOC_OVERHEAD 16 # define PERL_HV_ARRAY_ALLOC_BYTES(size) \ (((size) < 64) \ ? (size) * sizeof(HE*) \ : (size) * sizeof(HE*) * 2 - MALLOC_OVERHEAD) #endif /* Flags for hv_iternext_flags. */ #define HV_ITERNEXT_WANTPLACEHOLDERS 0x01 /* Don't skip placeholders. */ #define hv_iternext(hv) hv_iternext_flags(hv, 0) #define hv_magic(hv, gv, how) sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0) #define hv_undef(hv) Perl_hv_undef_flags(aTHX_ hv, 0) #define Perl_sharepvn(pv, len, hash) HEK_KEY(share_hek(pv, len, hash)) #define sharepvn(pv, len, hash) Perl_sharepvn(pv, len, hash) #define share_hek_hek(hek) \ (++(((struct shared_he *)(((char *)hek) \ - STRUCT_OFFSET(struct shared_he, \ shared_he_hek))) \ ->shared_he_he.he_valu.hent_refcount), \ hek) #define hv_store_ent(hv, keysv, val, hash) \ ((HE *) hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISSTORE, \ (val), (hash))) #define hv_exists_ent(hv, keysv, hash) \ (hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash)) \ ? TRUE : FALSE) #define hv_fetch_ent(hv, keysv, lval, hash) \ ((HE *) hv_common((hv), (keysv), NULL, 0, 0, \ ((lval) ? HV_FETCH_LVALUE : 0), NULL, (hash))) #define hv_delete_ent(hv, key, flags, hash) \ (MUTABLE_SV(hv_common((hv), (key), NULL, 0, 0, (flags) | HV_DELETE, \ NULL, (hash)))) #define hv_store_flags(hv, key, klen, val, hash, flags) \ ((SV**) hv_common((hv), NULL, (key), (klen), (flags), \ (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), (val), \ (hash))) #define hv_store(hv, key, klen, val, hash) \ ((SV**) hv_common_key_len((hv), (key), (klen), \ (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), \ (val), (hash))) #define hv_exists(hv, key, klen) \ (hv_common_key_len((hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0) \ ? TRUE : FALSE) #define hv_fetch(hv, key, klen, lval) \ ((SV**) hv_common_key_len((hv), (key), (klen), (lval) \ ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \ : HV_FETCH_JUST_SV, NULL, 0)) #define hv_delete(hv, key, klen, flags) \ (MUTABLE_SV(hv_common_key_len((hv), (key), (klen), \ (flags) | HV_DELETE, NULL, 0))) /* This refcounted he structure is used for storing the hints used for lexical pragmas. Without threads, it's basically struct he + refcount. With threads, life gets more complex as the structure needs to be shared between threads (because it hangs from OPs, which are shared), hence the alternate definition and mutex. */ struct refcounted_he; /* flags for the refcounted_he API */ #define REFCOUNTED_HE_KEY_UTF8 0x00000001 #ifdef PERL_CORE # define REFCOUNTED_HE_EXISTS 0x00000002 #endif #ifdef PERL_CORE /* Gosh. This really isn't a good name any longer. */ struct refcounted_he { struct refcounted_he *refcounted_he_next; /* next entry in chain */ #ifdef USE_ITHREADS U32 refcounted_he_hash; U32 refcounted_he_keylen; #else HEK *refcounted_he_hek; /* hint key */ #endif union { IV refcounted_he_u_iv; UV refcounted_he_u_uv; STRLEN refcounted_he_u_len; void *refcounted_he_u_ptr; /* Might be useful in future */ } refcounted_he_val; U32 refcounted_he_refcnt; /* reference count */ /* First byte is flags. Then NUL-terminated value. Then for ithreads, non-NUL terminated key. */ char refcounted_he_data[1]; }; /* =for apidoc m|SV *|refcounted_he_fetch_pvs|const struct refcounted_he *chain|const char *key|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define refcounted_he_fetch_pvs(chain, key, flags) \ Perl_refcounted_he_fetch_pvn(aTHX_ chain, STR_WITH_LEN(key), 0, flags) /* =for apidoc m|struct refcounted_he *|refcounted_he_new_pvs|struct refcounted_he *parent|const char *key|SV *value|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define refcounted_he_new_pvs(parent, key, value, flags) \ Perl_refcounted_he_new_pvn(aTHX_ parent, STR_WITH_LEN(key), 0, value, flags) /* Flag bits are HVhek_UTF8, HVhek_WASUTF8, then */ #define HVrhek_undef 0x00 /* Value is undef. */ #define HVrhek_delete 0x10 /* Value is placeholder - signifies delete. */ #define HVrhek_IV 0x20 /* Value is IV. */ #define HVrhek_UV 0x30 /* Value is UV. */ #define HVrhek_PV 0x40 /* Value is a (byte) string. */ #define HVrhek_PV_UTF8 0x50 /* Value is a (utf8) string. */ /* Two spare. As these have to live in the optree, you can't store anything interpreter specific, such as SVs. :-( */ #define HVrhek_typemask 0x70 #ifdef USE_ITHREADS /* A big expression to find the key offset */ #define REF_HE_KEY(chain) \ ((((chain->refcounted_he_data[0] & 0x60) == 0x40) \ ? chain->refcounted_he_val.refcounted_he_u_len + 1 : 0) \ + 1 + chain->refcounted_he_data) #endif # ifdef USE_ITHREADS # define HINTS_REFCNT_LOCK MUTEX_LOCK(&PL_hints_mutex) # define HINTS_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_hints_mutex) # else # define HINTS_REFCNT_LOCK NOOP # define HINTS_REFCNT_UNLOCK NOOP # endif #endif #ifdef USE_ITHREADS # define HINTS_REFCNT_INIT MUTEX_INIT(&PL_hints_mutex) # define HINTS_REFCNT_TERM MUTEX_DESTROY(&PL_hints_mutex) #else # define HINTS_REFCNT_INIT NOOP # define HINTS_REFCNT_TERM NOOP #endif /* Hash actions * Passed in PERL_MAGIC_uvar calls */ #define HV_DISABLE_UVAR_XKEY 0x01 /* We need to ensure that these don't clash with G_DISCARD, which is 2, as it is documented as being passed to hv_delete(). */ #define HV_FETCH_ISSTORE 0x04 #define HV_FETCH_ISEXISTS 0x08 #define HV_FETCH_LVALUE 0x10 #define HV_FETCH_JUST_SV 0x20 #define HV_DELETE 0x40 #define HV_FETCH_EMPTY_HE 0x80 /* Leave HeVAL null. */ /* Must not conflict with HVhek_UTF8 */ #define HV_NAME_SETALL 0x02 /* =for apidoc newHV Creates a new HV. The reference count is set to 1. =cut */ #define newHV() MUTABLE_HV(newSV_type(SVt_PVHV)) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZRx_ keywords.hnuW+A/* -*- buffer-read-only: t -*- * * keywords.h * * Copyright (C) 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2005, * 2006, 2007 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/keywords.pl from its data. * Any changes made here will be lost! */ #define KEY_NULL 0 #define KEY___FILE__ 1 #define KEY___LINE__ 2 #define KEY___PACKAGE__ 3 #define KEY___DATA__ 4 #define KEY___END__ 5 #define KEY___SUB__ 6 #define KEY_AUTOLOAD 7 #define KEY_BEGIN 8 #define KEY_UNITCHECK 9 #define KEY_CORE 10 #define KEY_DESTROY 11 #define KEY_END 12 #define KEY_INIT 13 #define KEY_CHECK 14 #define KEY_abs 15 #define KEY_accept 16 #define KEY_alarm 17 #define KEY_and 18 #define KEY_atan2 19 #define KEY_bind 20 #define KEY_binmode 21 #define KEY_bless 22 #define KEY_break 23 #define KEY_caller 24 #define KEY_chdir 25 #define KEY_chmod 26 #define KEY_chomp 27 #define KEY_chop 28 #define KEY_chown 29 #define KEY_chr 30 #define KEY_chroot 31 #define KEY_close 32 #define KEY_closedir 33 #define KEY_cmp 34 #define KEY_connect 35 #define KEY_continue 36 #define KEY_cos 37 #define KEY_crypt 38 #define KEY_dbmclose 39 #define KEY_dbmopen 40 #define KEY_default 41 #define KEY_defined 42 #define KEY_delete 43 #define KEY_die 44 #define KEY_do 45 #define KEY_dump 46 #define KEY_each 47 #define KEY_else 48 #define KEY_elsif 49 #define KEY_endgrent 50 #define KEY_endhostent 51 #define KEY_endnetent 52 #define KEY_endprotoent 53 #define KEY_endpwent 54 #define KEY_endservent 55 #define KEY_eof 56 #define KEY_eq 57 #define KEY_eval 58 #define KEY_evalbytes 59 #define KEY_exec 60 #define KEY_exists 61 #define KEY_exit 62 #define KEY_exp 63 #define KEY_fc 64 #define KEY_fcntl 65 #define KEY_fileno 66 #define KEY_flock 67 #define KEY_for 68 #define KEY_foreach 69 #define KEY_fork 70 #define KEY_format 71 #define KEY_formline 72 #define KEY_ge 73 #define KEY_getc 74 #define KEY_getgrent 75 #define KEY_getgrgid 76 #define KEY_getgrnam 77 #define KEY_gethostbyaddr 78 #define KEY_gethostbyname 79 #define KEY_gethostent 80 #define KEY_getlogin 81 #define KEY_getnetbyaddr 82 #define KEY_getnetbyname 83 #define KEY_getnetent 84 #define KEY_getpeername 85 #define KEY_getpgrp 86 #define KEY_getppid 87 #define KEY_getpriority 88 #define KEY_getprotobyname 89 #define KEY_getprotobynumber 90 #define KEY_getprotoent 91 #define KEY_getpwent 92 #define KEY_getpwnam 93 #define KEY_getpwuid 94 #define KEY_getservbyname 95 #define KEY_getservbyport 96 #define KEY_getservent 97 #define KEY_getsockname 98 #define KEY_getsockopt 99 #define KEY_given 100 #define KEY_glob 101 #define KEY_gmtime 102 #define KEY_goto 103 #define KEY_grep 104 #define KEY_gt 105 #define KEY_hex 106 #define KEY_if 107 #define KEY_index 108 #define KEY_int 109 #define KEY_ioctl 110 #define KEY_join 111 #define KEY_keys 112 #define KEY_kill 113 #define KEY_last 114 #define KEY_lc 115 #define KEY_lcfirst 116 #define KEY_le 117 #define KEY_length 118 #define KEY_link 119 #define KEY_listen 120 #define KEY_local 121 #define KEY_localtime 122 #define KEY_lock 123 #define KEY_log 124 #define KEY_lstat 125 #define KEY_lt 126 #define KEY_m 127 #define KEY_map 128 #define KEY_mkdir 129 #define KEY_msgctl 130 #define KEY_msgget 131 #define KEY_msgrcv 132 #define KEY_msgsnd 133 #define KEY_my 134 #define KEY_ne 135 #define KEY_next 136 #define KEY_no 137 #define KEY_not 138 #define KEY_oct 139 #define KEY_open 140 #define KEY_opendir 141 #define KEY_or 142 #define KEY_ord 143 #define KEY_our 144 #define KEY_pack 145 #define KEY_package 146 #define KEY_pipe 147 #define KEY_pop 148 #define KEY_pos 149 #define KEY_print 150 #define KEY_printf 151 #define KEY_prototype 152 #define KEY_push 153 #define KEY_q 154 #define KEY_qq 155 #define KEY_qr 156 #define KEY_quotemeta 157 #define KEY_qw 158 #define KEY_qx 159 #define KEY_rand 160 #define KEY_read 161 #define KEY_readdir 162 #define KEY_readline 163 #define KEY_readlink 164 #define KEY_readpipe 165 #define KEY_recv 166 #define KEY_redo 167 #define KEY_ref 168 #define KEY_rename 169 #define KEY_require 170 #define KEY_reset 171 #define KEY_return 172 #define KEY_reverse 173 #define KEY_rewinddir 174 #define KEY_rindex 175 #define KEY_rmdir 176 #define KEY_s 177 #define KEY_say 178 #define KEY_scalar 179 #define KEY_seek 180 #define KEY_seekdir 181 #define KEY_select 182 #define KEY_semctl 183 #define KEY_semget 184 #define KEY_semop 185 #define KEY_send 186 #define KEY_setgrent 187 #define KEY_sethostent 188 #define KEY_setnetent 189 #define KEY_setpgrp 190 #define KEY_setpriority 191 #define KEY_setprotoent 192 #define KEY_setpwent 193 #define KEY_setservent 194 #define KEY_setsockopt 195 #define KEY_shift 196 #define KEY_shmctl 197 #define KEY_shmget 198 #define KEY_shmread 199 #define KEY_shmwrite 200 #define KEY_shutdown 201 #define KEY_sin 202 #define KEY_sleep 203 #define KEY_socket 204 #define KEY_socketpair 205 #define KEY_sort 206 #define KEY_splice 207 #define KEY_split 208 #define KEY_sprintf 209 #define KEY_sqrt 210 #define KEY_srand 211 #define KEY_stat 212 #define KEY_state 213 #define KEY_study 214 #define KEY_sub 215 #define KEY_substr 216 #define KEY_symlink 217 #define KEY_syscall 218 #define KEY_sysopen 219 #define KEY_sysread 220 #define KEY_sysseek 221 #define KEY_system 222 #define KEY_syswrite 223 #define KEY_tell 224 #define KEY_telldir 225 #define KEY_tie 226 #define KEY_tied 227 #define KEY_time 228 #define KEY_times 229 #define KEY_tr 230 #define KEY_truncate 231 #define KEY_uc 232 #define KEY_ucfirst 233 #define KEY_umask 234 #define KEY_undef 235 #define KEY_unless 236 #define KEY_unlink 237 #define KEY_unpack 238 #define KEY_unshift 239 #define KEY_untie 240 #define KEY_until 241 #define KEY_use 242 #define KEY_utime 243 #define KEY_values 244 #define KEY_vec 245 #define KEY_wait 246 #define KEY_waitpid 247 #define KEY_wantarray 248 #define KEY_warn 249 #define KEY_when 250 #define KEY_while 251 #define KEY_write 252 #define KEY_x 253 #define KEY_xor 254 #define KEY_y 255 /* Generated from: * e5a540774760ea54c761ef17ee4a153cc264e9a700b817d561e390730c457406 regen/keywords.pl * ex: set ro: */ PKZ"wdosish.hnuW+A/* dosish.h * * Copyright (C) 1993, 1994, 1996, 1997, 1998, 1999, * 2000, 2001, 2002, 2007, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #define ABORT() abort(); #ifndef SH_PATH #define SH_PATH "/bin/sh" #endif #ifdef DJGPP # define BIT_BUCKET "nul" # define OP_BINARY O_BINARY # define PERL_SYS_INIT_BODY(c,v) \ MALLOC_CHECK_TAINT2(*c,*v) Perl_DJGPP_init(c,v); PERLIO_INIT # define init_os_extras Perl_init_os_extras # define HAS_UTIME # define HAS_KILL char *djgpp_pathexp (const char*); void Perl_DJGPP_init (int *argcp,char ***argvp); # if (DJGPP==2 && DJGPP_MINOR < 2) # define NO_LOCALECONV_MON_THOUSANDS_SEP # endif # ifndef PERL_CORE # define PERL_FS_VER_FMT "%d_%d_%d" # endif # define PERL_FS_VERSION STRINGIFY(PERL_REVISION) "_" \ STRINGIFY(PERL_VERSION) "_" \ STRINGIFY(PERL_SUBVERSION) #else /* DJGPP */ # ifdef WIN32 # define PERL_SYS_INIT_BODY(c,v) \ MALLOC_CHECK_TAINT2(*c,*v) Perl_win32_init(c,v); PERLIO_INIT # define PERL_SYS_TERM_BODY() Perl_win32_term() # define BIT_BUCKET "nul" # else # ifdef NETWARE # define PERL_SYS_INIT_BODY(c,v) \ MALLOC_CHECK_TAINT2(*c,*v) Perl_nw5_init(c,v); PERLIO_INIT # define BIT_BUCKET "nwnul" # else # define PERL_SYS_INIT_BODY(c,v) \ MALLOC_CHECK_TAINT2(*c,*v); PERLIO_INIT # define BIT_BUCKET "\\dev\\nul" /* "wanna be like, umm, Newlined, or somethin?" */ # endif /* NETWARE */ # endif #endif /* DJGPP */ #ifndef PERL_SYS_TERM_BODY # define PERL_SYS_TERM_BODY() \ HINTS_REFCNT_TERM; OP_CHECK_MUTEX_TERM; \ OP_REFCNT_TERM; PERLIO_TERM; MALLOC_TERM #endif #define dXSUB_SYS /* * 5.003_07 and earlier keyed on #ifdef MSDOS for determining if we were * running on DOS, *and* if we had to cope with 16 bit memory addressing * constraints, *and* we need to have memory allocated as unsigned long. * * with the advent of *real* compilers for DOS, they are not locked together. * MSDOS means "I am running on MSDOS". HAS_64K_LIMIT means "I have * 16 bit memory addressing constraints". * * if you need the last, try #DEFINE MEM_SIZE unsigned long. */ #ifdef MSDOS # ifndef DJGPP # define HAS_64K_LIMIT # endif #endif /* USEMYBINMODE * This symbol, if defined, indicates that the program should * use the routine my_binmode(FILE *fp, char iotype, int mode) to insure * that a file is in "binary" mode -- that is, that no translation * of bytes occurs on read or write operations. */ #undef USEMYBINMODE /* Stat_t: * This symbol holds the type used to declare buffers for information * returned by stat(). It's usually just struct stat. It may be necessary * to include and to get any typedef'ed * information. */ #if defined(WIN64) || defined(USE_LARGE_FILES) #define Stat_t struct _stati64 #else #if defined(UNDER_CE) #define Stat_t struct xcestat #else #define Stat_t struct stat #endif #endif /* USE_STAT_RDEV: * This symbol is defined if this system has a stat structure declaring * st_rdev */ #define USE_STAT_RDEV /**/ /* ACME_MESS: * This symbol, if defined, indicates that error messages should be * should be generated in a format that allows the use of the Acme * GUI/editor's autofind feature. */ #undef ACME_MESS /**/ /* ALTERNATE_SHEBANG: * This symbol, if defined, contains a "magic" string which may be used * as the first line of a Perl program designed to be executed directly * by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG * begins with a character other then #, then Perl will only treat * it as a command line if it finds the string "perl" in the first * word; otherwise it's treated as the first line of code in the script. * (IOW, Perl won't hand off to another interpreter via an alternate * shebang sequence that might be legal Perl code.) */ /* #define ALTERNATE_SHEBANG "#!" / **/ #include /* * fwrite1() should be a routine with the same calling sequence as fwrite(), * but which outputs all of the bytes requested as a single stream (unlike * fwrite() itself, which on some systems outputs several distinct records * if the number_of_items parameter is >1). */ #define fwrite1 fwrite #define Fstat(fd,bufptr) fstat((fd),(bufptr)) #ifdef DJGPP # define Fflush(fp) djgpp_fflush(fp) #else # define Fflush(fp) fflush(fp) #endif #define Mkdir(path,mode) mkdir((path),(mode)) #ifndef WIN32 # define Stat(fname,bufptr) stat((fname),(bufptr)) #else # define HAS_IOCTL # define HAS_UTIME # define HAS_KILL # define HAS_WAIT # define HAS_CHOWN #endif /* WIN32 */ /* * : The DJGPP port has code that converts * the return code of system() into the form that Unixy wait usually * returns: * * - signal number in bits 0-6; * - core dump flag in bit 7; * - exit code in bits 8-15. * * Bits 0-7 are always zero for DJGPP, because it uses system(). * See djgpp.c. * * POSIX::W* use the W* macros from to decode * the return code. Unfortunately the W* macros for DJGPP use * a different format than Unixy wait does. So there's a mismatch * and, say, WEXITSTATUS($?) will return bogus values. * * So here we add hack to redefine the W* macros from DJGPP's * to work with our return-code conversion. */ #ifdef DJGPP #include #undef WEXITSTATUS #undef WIFEXITED #undef WIFSIGNALED #undef WIFSTOPPED #undef WNOHANG #undef WSTOPSIG #undef WTERMSIG #undef WUNTRACED #define WEXITSTATUS(stat_val) ((stat_val) >> 8) #define WIFEXITED(stat_val) 0 #define WIFSIGNALED(stat_val) 0 #define WIFSTOPPED(stat_val) 0 #define WNOHANG 0 #define WSTOPSIG(stat_val) 0 #define WTERMSIG(stat_val) 0 #define WUNTRACED 0 #endif /* Don't go reading from /dev/urandom */ #define PERL_NO_DEV_RANDOM /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ-7 malloc_ctl.hnuW+A#ifndef MALLOC_CTL_H # define MALLOC_CTL_H struct perl_mstats { UV *nfree; UV *ntotal; IV topbucket, topbucket_ev, topbucket_odd, totfree, total, total_chain; IV total_sbrk, sbrks, sbrk_good, sbrk_slack, start_slack, sbrked_remains; IV minbucket; /* Level 1 info */ UV *bucket_mem_size; UV *bucket_available_size; UV nbuckets; }; typedef struct perl_mstats perl_mstats_t; PERL_CALLCONV Malloc_t Perl_malloc (MEM_SIZE nbytes); PERL_CALLCONV Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size); PERL_CALLCONV Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes); /* 'mfree' rather than 'free', since there is already a 'perl_free' * that causes clashes with case-insensitive linkers */ PERL_CALLCONV Free_t Perl_mfree (Malloc_t where); #ifndef NO_MALLOC_DYNAMIC_CFG /* IV configuration data */ enum { MallocCfg_FIRST_SBRK, MallocCfg_MIN_SBRK, MallocCfg_MIN_SBRK_FRAC1000, MallocCfg_SBRK_ALLOW_FAILURES, MallocCfg_SBRK_FAILURE_PRICE, MallocCfg_sbrk_goodness, MallocCfg_filldead, MallocCfg_fillalive, MallocCfg_fillcheck, MallocCfg_skip_cfg_env, MallocCfg_cfg_env_read, MallocCfg_emergency_buffer_size, MallocCfg_emergency_buffer_last_req, MallocCfg_emergency_buffer_prepared_size, MallocCfg_last }; /* char* configuration data */ enum { MallocCfgP_emergency_buffer, MallocCfgP_emergency_buffer_prepared, MallocCfgP_last }; START_EXTERN_C extern IV *MallocCfg_ptr; extern char **MallocCfgP_ptr; END_EXTERN_C #endif #endif PKZ1time64_config.hnuW+A#ifndef TIME64_CONFIG_H # define TIME64_CONFIG_H /* Configuration ------------- Define as appropriate for your system. Sensible defaults provided. */ /* Debugging TIME_64_DEBUG Define if you want debugging messages */ /* #define TIME_64_DEBUG */ /* INT_64_T A numeric type to store time and others. Must be defined. */ #define INT_64_T NV /* USE_TM64 Should we use a 64 bit safe replacement for tm? This will let you go past year 2 billion but the struct will be incompatible with tm. Conversion functions will be provided. */ #define USE_TM64 /* Availability of system functions. HAS_GMTIME_R Define if your system has gmtime_r() HAS_LOCALTIME_R Define if your system has localtime_r() HAS_TIMEGM Define if your system has timegm(), a GNU extension. */ /* Set in config.h */ /* Details of non-standard tm struct elements. HAS_TM_TM_GMTOFF True if your tm struct has a "tm_gmtoff" element. A BSD extension. HAS_TM_TM_ZONE True if your tm struct has a "tm_zone" element. A BSD extension. */ /* Set in config.h */ /* USE_SYSTEM_LOCALTIME USE_SYSTEM_GMTIME Should we use the system functions if the time is inside their range? Your system localtime() is probably more accurate, but our gmtime() is fast and safe. Except on VMS, where we need the homegrown gmtime() override to shift between UTC and local for the vmsish 'time' pragma. */ #define USE_SYSTEM_LOCALTIME #ifdef VMS # define USE_SYSTEM_GMTIME #endif /* SYSTEM_LOCALTIME_MAX SYSTEM_LOCALTIME_MIN SYSTEM_GMTIME_MAX SYSTEM_GMTIME_MIN Maximum and minimum values your system's gmtime() and localtime() can handle. We will use your system functions if the time falls inside these ranges. */ #define SYSTEM_LOCALTIME_MAX CAT2(LOCALTIME_MAX,.0) #define SYSTEM_LOCALTIME_MIN CAT2(LOCALTIME_MIN,.0) #define SYSTEM_GMTIME_MAX CAT2(GMTIME_MAX,.0) #define SYSTEM_GMTIME_MIN CAT2(GMTIME_MIN,.0) #endif /* TIME64_CONFIG_H */ PKZDDconfig.hnuW+A/* This file was produced by running the config_h.SH script, which * gets its values from config.sh, which is generally produced by * running Configure. * * Feel free to modify any of this as the need arises. Note, however, * that running config_h.SH again will wipe out any changes you've made. * For a more permanent change edit config.sh and rerun config_h.SH. */ /* Package name : perl5 * Source directory : . * Configuration time: Wed Oct 25 12:40:04 UTC 2023 * Configured by : Red Hat, Inc. * Target system : linux buildfarm04-new.corp.cloudlinux.com 4.18.0-477.21.1.el8_8.x86_64 #1 smp thu aug 10 13:51:50 edt 2023 x86_64 x86_64 x86_64 gnulinux */ #ifndef _config_h_ #define _config_h_ /* LOC_SED: * This symbol holds the complete pathname to the sed program. */ #define LOC_SED "/usr/bin/sed" /**/ /* HAS_ALARM: * This symbol, if defined, indicates that the alarm routine is * available. */ #define HAS_ALARM /**/ /* HAS_BCMP: * This symbol is defined if the bcmp() routine is available to * compare blocks of memory. */ #define HAS_BCMP /**/ /* HAS_BCOPY: * This symbol is defined if the bcopy() routine is available to * copy blocks of memory. */ #define HAS_BCOPY /**/ /* HAS_BZERO: * This symbol is defined if the bzero() routine is available to * set a memory block to 0. */ #define HAS_BZERO /**/ /* HAS_CHOWN: * This symbol, if defined, indicates that the chown routine is * available. */ #define HAS_CHOWN /**/ /* HAS_CHROOT: * This symbol, if defined, indicates that the chroot routine is * available. */ #define HAS_CHROOT /**/ /* HAS_CHSIZE: * This symbol, if defined, indicates that the chsize routine is available * to truncate files. You might need a -lx to get this routine. */ /*#define HAS_CHSIZE / **/ /* HAS_CRYPT: * This symbol, if defined, indicates that the crypt routine is available * to encrypt passwords and the like. */ #define HAS_CRYPT /**/ /* HAS_CTERMID: * This symbol, if defined, indicates that the ctermid routine is * available to generate filename for terminal. */ #define HAS_CTERMID /**/ /* HAS_CUSERID: * This symbol, if defined, indicates that the cuserid routine is * available to get character login names. */ #define HAS_CUSERID /**/ /* HAS_DBL_DIG: * This symbol, if defined, indicates that this system's * or defines the symbol DBL_DIG, which is the number * of significant digits in a double precision number. If this * symbol is not defined, a guess of 15 is usually pretty good. */ #define HAS_DBL_DIG /**/ /* HAS_DIFFTIME: * This symbol, if defined, indicates that the difftime routine is * available. */ #define HAS_DIFFTIME /**/ /* HAS_DLERROR: * This symbol, if defined, indicates that the dlerror routine is * available to return a string describing the last error that * occurred from a call to dlopen(), dlclose() or dlsym(). */ #define HAS_DLERROR /**/ /* HAS_DUP2: * This symbol, if defined, indicates that the dup2 routine is * available to duplicate file descriptors. */ #define HAS_DUP2 /**/ /* HAS_FCHMOD: * This symbol, if defined, indicates that the fchmod routine is available * to change mode of opened files. If unavailable, use chmod(). */ #define HAS_FCHMOD /**/ /* HAS_FCHOWN: * This symbol, if defined, indicates that the fchown routine is available * to change ownership of opened files. If unavailable, use chown(). */ #define HAS_FCHOWN /**/ /* HAS_FCNTL: * This symbol, if defined, indicates to the C program that * the fcntl() function exists. */ #define HAS_FCNTL /**/ /* HAS_FGETPOS: * This symbol, if defined, indicates that the fgetpos routine is * available to get the file position indicator, similar to ftell(). */ #define HAS_FGETPOS /**/ /* HAS_FLOCK: * This symbol, if defined, indicates that the flock routine is * available to do file locking. */ #define HAS_FLOCK /**/ /* HAS_FORK: * This symbol, if defined, indicates that the fork routine is * available. */ #define HAS_FORK /**/ /* HAS_FSETPOS: * This symbol, if defined, indicates that the fsetpos routine is * available to set the file position indicator, similar to fseek(). */ #define HAS_FSETPOS /**/ /* HAS_GETTIMEOFDAY: * This symbol, if defined, indicates that the gettimeofday() system * call is available for a sub-second accuracy clock. Usually, the file * needs to be included (see I_SYS_RESOURCE). * The type "Timeval" should be used to refer to "struct timeval". */ #define HAS_GETTIMEOFDAY /**/ #ifdef HAS_GETTIMEOFDAY #define Timeval struct timeval /* Structure used by gettimeofday() */ #endif /* HAS_GETGROUPS: * This symbol, if defined, indicates that the getgroups() routine is * available to get the list of process groups. If unavailable, multiple * groups are probably not supported. */ #define HAS_GETGROUPS /**/ /* HAS_GETLOGIN: * This symbol, if defined, indicates that the getlogin routine is * available to get the login name. */ #define HAS_GETLOGIN /**/ /* HAS_GETPGID: * This symbol, if defined, indicates to the C program that * the getpgid(pid) function is available to get the * process group id. */ #define HAS_GETPGID /**/ /* HAS_GETPGRP2: * This symbol, if defined, indicates that the getpgrp2() (as in DG/UX) * routine is available to get the current process group. */ /*#define HAS_GETPGRP2 / **/ /* HAS_GETPPID: * This symbol, if defined, indicates that the getppid routine is * available to get the parent process ID. */ #define HAS_GETPPID /**/ /* HAS_GETPRIORITY: * This symbol, if defined, indicates that the getpriority routine is * available to get a process's priority. */ #define HAS_GETPRIORITY /**/ /* HAS_INET_ATON: * This symbol, if defined, indicates to the C program that the * inet_aton() function is available to parse IP address "dotted-quad" * strings. */ #define HAS_INET_ATON /**/ /* HAS_KILLPG: * This symbol, if defined, indicates that the killpg routine is available * to kill process groups. If unavailable, you probably should use kill * with a negative process number. */ #define HAS_KILLPG /**/ /* HAS_LINK: * This symbol, if defined, indicates that the link routine is * available to create hard links. */ #define HAS_LINK /**/ /* HAS_LOCALECONV: * This symbol, if defined, indicates that the localeconv routine is * available for numeric and monetary formatting conventions. */ #define HAS_LOCALECONV /**/ /* HAS_LOCKF: * This symbol, if defined, indicates that the lockf routine is * available to do file locking. */ #define HAS_LOCKF /**/ /* HAS_LSTAT: * This symbol, if defined, indicates that the lstat routine is * available to do file stats on symbolic links. */ #define HAS_LSTAT /**/ /* HAS_MBLEN: * This symbol, if defined, indicates that the mblen routine is available * to find the number of bytes in a multibye character. */ #define HAS_MBLEN /**/ /* HAS_MBSTOWCS: * This symbol, if defined, indicates that the mbstowcs routine is * available to covert a multibyte string into a wide character string. */ #define HAS_MBSTOWCS /**/ /* HAS_MBTOWC: * This symbol, if defined, indicates that the mbtowc routine is available * to covert a multibyte to a wide character. */ #define HAS_MBTOWC /**/ /* HAS_MEMCMP: * This symbol, if defined, indicates that the memcmp routine is available * to compare blocks of memory. */ #define HAS_MEMCMP /**/ /* HAS_MEMCPY: * This symbol, if defined, indicates that the memcpy routine is available * to copy blocks of memory. */ #define HAS_MEMCPY /**/ /* HAS_MEMMOVE: * This symbol, if defined, indicates that the memmove routine is available * to copy potentially overlapping blocks of memory. This should be used * only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your * own version. */ #define HAS_MEMMOVE /**/ /* HAS_MEMSET: * This symbol, if defined, indicates that the memset routine is available * to set blocks of memory. */ #define HAS_MEMSET /**/ /* HAS_MKDIR: * This symbol, if defined, indicates that the mkdir routine is available * to create directories. Otherwise you should fork off a new process to * exec /bin/mkdir. */ #define HAS_MKDIR /**/ /* HAS_MKFIFO: * This symbol, if defined, indicates that the mkfifo routine is * available to create FIFOs. Otherwise, mknod should be able to * do it for you. However, if mkfifo is there, mknod might require * super-user privileges which mkfifo will not. */ #define HAS_MKFIFO /**/ /* HAS_MKTIME: * This symbol, if defined, indicates that the mktime routine is * available. */ #define HAS_MKTIME /**/ /* HAS_MSYNC: * This symbol, if defined, indicates that the msync system call is * available to synchronize a mapped file. */ #define HAS_MSYNC /**/ /* HAS_MUNMAP: * This symbol, if defined, indicates that the munmap system call is * available to unmap a region, usually mapped by mmap(). */ #define HAS_MUNMAP /**/ /* HAS_NICE: * This symbol, if defined, indicates that the nice routine is * available. */ #define HAS_NICE /**/ /* HAS_PATHCONF: * This symbol, if defined, indicates that pathconf() is available * to determine file-system related limits and options associated * with a given filename. */ /* HAS_FPATHCONF: * This symbol, if defined, indicates that pathconf() is available * to determine file-system related limits and options associated * with a given open file descriptor. */ #define HAS_PATHCONF /**/ #define HAS_FPATHCONF /**/ /* HAS_PAUSE: * This symbol, if defined, indicates that the pause routine is * available to suspend a process until a signal is received. */ #define HAS_PAUSE /**/ /* HAS_PIPE: * This symbol, if defined, indicates that the pipe routine is * available to create an inter-process channel. */ #define HAS_PIPE /**/ /* HAS_POLL: * This symbol, if defined, indicates that the poll routine is * available to poll active file descriptors. Please check I_POLL and * I_SYS_POLL to know which header should be included as well. */ #define HAS_POLL /**/ /* HAS_READDIR: * This symbol, if defined, indicates that the readdir routine is * available to read directory entries. You may have to include * . See I_DIRENT. */ #define HAS_READDIR /**/ /* HAS_SEEKDIR: * This symbol, if defined, indicates that the seekdir routine is * available. You may have to include . See I_DIRENT. */ #define HAS_SEEKDIR /**/ /* HAS_TELLDIR: * This symbol, if defined, indicates that the telldir routine is * available. You may have to include . See I_DIRENT. */ #define HAS_TELLDIR /**/ /* HAS_REWINDDIR: * This symbol, if defined, indicates that the rewinddir routine is * available. You may have to include . See I_DIRENT. */ #define HAS_REWINDDIR /**/ /* HAS_READLINK: * This symbol, if defined, indicates that the readlink routine is * available to read the value of a symbolic link. */ #define HAS_READLINK /**/ /* HAS_RENAME: * This symbol, if defined, indicates that the rename routine is available * to rename files. Otherwise you should do the unlink(), link(), unlink() * trick. */ #define HAS_RENAME /**/ /* HAS_RMDIR: * This symbol, if defined, indicates that the rmdir routine is * available to remove directories. Otherwise you should fork off a * new process to exec /bin/rmdir. */ #define HAS_RMDIR /**/ /* HAS_SELECT: * This symbol, if defined, indicates that the select routine is * available to select active file descriptors. If the timeout field * is used, may need to be included. */ #define HAS_SELECT /**/ /* HAS_SETEGID: * This symbol, if defined, indicates that the setegid routine is available * to change the effective gid of the current program. */ #define HAS_SETEGID /**/ /* HAS_SETEUID: * This symbol, if defined, indicates that the seteuid routine is available * to change the effective uid of the current program. */ #define HAS_SETEUID /**/ /* HAS_SETGROUPS: * This symbol, if defined, indicates that the setgroups() routine is * available to set the list of process groups. If unavailable, multiple * groups are probably not supported. */ #define HAS_SETGROUPS /**/ /* HAS_SETLINEBUF: * This symbol, if defined, indicates that the setlinebuf routine is * available to change stderr or stdout from block-buffered or unbuffered * to a line-buffered mode. */ #define HAS_SETLINEBUF /**/ /* HAS_SETLOCALE: * This symbol, if defined, indicates that the setlocale routine is * available to handle locale-specific ctype implementations. */ #define HAS_SETLOCALE /**/ /* HAS_SETPGID: * This symbol, if defined, indicates that the setpgid(pid, gpid) * routine is available to set process group ID. */ #define HAS_SETPGID /**/ /* HAS_SETPGRP2: * This symbol, if defined, indicates that the setpgrp2() (as in DG/UX) * routine is available to set the current process group. */ /*#define HAS_SETPGRP2 / **/ /* HAS_SETPRIORITY: * This symbol, if defined, indicates that the setpriority routine is * available to set a process's priority. */ #define HAS_SETPRIORITY /**/ /* HAS_SETREGID: * This symbol, if defined, indicates that the setregid routine is * available to change the real and effective gid of the current * process. */ /* HAS_SETRESGID: * This symbol, if defined, indicates that the setresgid routine is * available to change the real, effective and saved gid of the current * process. */ #define HAS_SETREGID /**/ #define HAS_SETRESGID /**/ /* HAS_SETREUID: * This symbol, if defined, indicates that the setreuid routine is * available to change the real and effective uid of the current * process. */ /* HAS_SETRESUID: * This symbol, if defined, indicates that the setresuid routine is * available to change the real, effective and saved uid of the current * process. */ #define HAS_SETREUID /**/ #define HAS_SETRESUID /**/ /* HAS_SETRGID: * This symbol, if defined, indicates that the setrgid routine is available * to change the real gid of the current program. */ /*#define HAS_SETRGID / **/ /* HAS_SETRUID: * This symbol, if defined, indicates that the setruid routine is available * to change the real uid of the current program. */ /*#define HAS_SETRUID / **/ /* HAS_SETSID: * This symbol, if defined, indicates that the setsid routine is * available to set the process group ID. */ #define HAS_SETSID /**/ /* HAS_STRCHR: * This symbol is defined to indicate that the strchr()/strrchr() * functions are available for string searching. If not, try the * index()/rindex() pair. */ /* HAS_INDEX: * This symbol is defined to indicate that the index()/rindex() * functions are available for string searching. */ #define HAS_STRCHR /**/ /*#define HAS_INDEX / **/ /* HAS_STRCOLL: * This symbol, if defined, indicates that the strcoll routine is * available to compare strings using collating information. */ #define HAS_STRCOLL /**/ /* HAS_STRTOD: * This symbol, if defined, indicates that the strtod routine is * available to provide better numeric string conversion than atof(). */ #define HAS_STRTOD /**/ /* HAS_STRTOL: * This symbol, if defined, indicates that the strtol routine is available * to provide better numeric string conversion than atoi() and friends. */ #define HAS_STRTOL /**/ /* HAS_STRXFRM: * This symbol, if defined, indicates that the strxfrm() routine is * available to transform strings. */ #define HAS_STRXFRM /**/ /* HAS_SYMLINK: * This symbol, if defined, indicates that the symlink routine is available * to create symbolic links. */ #define HAS_SYMLINK /**/ /* HAS_SYSCALL: * This symbol, if defined, indicates that the syscall routine is * available to call arbitrary system calls. If undefined, that's tough. */ #define HAS_SYSCALL /**/ /* HAS_SYSCONF: * This symbol, if defined, indicates that sysconf() is available * to determine system related limits and options. */ #define HAS_SYSCONF /**/ /* HAS_SYSTEM: * This symbol, if defined, indicates that the system routine is * available to issue a shell command. */ #define HAS_SYSTEM /**/ /* HAS_TCGETPGRP: * This symbol, if defined, indicates that the tcgetpgrp routine is * available to get foreground process group ID. */ #define HAS_TCGETPGRP /**/ /* HAS_TCSETPGRP: * This symbol, if defined, indicates that the tcsetpgrp routine is * available to set foreground process group ID. */ #define HAS_TCSETPGRP /**/ /* HAS_TRUNCATE: * This symbol, if defined, indicates that the truncate routine is * available to truncate files. */ #define HAS_TRUNCATE /**/ /* HAS_TZNAME: * This symbol, if defined, indicates that the tzname[] array is * available to access timezone names. */ #define HAS_TZNAME /**/ /* HAS_UMASK: * This symbol, if defined, indicates that the umask routine is * available to set and get the value of the file creation mask. */ #define HAS_UMASK /**/ /* HAS_USLEEP: * This symbol, if defined, indicates that the usleep routine is * available to let the process sleep on a sub-second accuracy. */ #define HAS_USLEEP /**/ /* HAS_WAIT4: * This symbol, if defined, indicates that wait4() exists. */ #define HAS_WAIT4 /**/ /* HAS_WAITPID: * This symbol, if defined, indicates that the waitpid routine is * available to wait for child process. */ #define HAS_WAITPID /**/ /* HAS_WCSTOMBS: * This symbol, if defined, indicates that the wcstombs routine is * available to convert wide character strings to multibyte strings. */ #define HAS_WCSTOMBS /**/ /* HAS_WCTOMB: * This symbol, if defined, indicates that the wctomb routine is available * to covert a wide character to a multibyte. */ #define HAS_WCTOMB /**/ /* Groups_t: * This symbol holds the type used for the second argument to * getgroups() and setgroups(). Usually, this is the same as * gidtype (gid_t) , but sometimes it isn't. * It can be int, ushort, gid_t, etc... * It may be necessary to include to get any * typedef'ed information. This is only required if you have * getgroups() or setgroups().. */ #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS) #define Groups_t gid_t /* Type for 2nd arg to [sg]etgroups() */ #endif /* I_ARPA_INET: * This symbol, if defined, indicates to the C program that it should * include to get inet_addr and friends declarations. */ #define I_ARPA_INET /**/ /* I_DBM: * This symbol, if defined, indicates that exists and should * be included. */ /* I_RPCSVC_DBM: * This symbol, if defined, indicates that exists and * should be included. */ #define I_DBM /**/ /*#define I_RPCSVC_DBM / **/ /* I_DLFCN: * This symbol, if defined, indicates that exists and should * be included. */ #define I_DLFCN /**/ /* I_FCNTL: * This manifest constant tells the C program to include . */ /*#define I_FCNTL / **/ /* I_FLOAT: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like DBL_MAX or * DBL_MIN, i.e. machine dependent floating point values. */ #define I_FLOAT /**/ /* I_GDBM: * This symbol, if defined, indicates that exists and should * be included. */ #define I_GDBM /**/ /* I_LIMITS: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like WORD_BIT or * LONG_MAX, i.e. machine dependant limitations. */ #define I_LIMITS /**/ /* I_LOCALE: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_LOCALE /**/ /* I_MATH: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_MATH /**/ /* I_MEMORY: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MEMORY / **/ /* I_NETINET_IN: * This symbol, if defined, indicates to the C program that it should * include . Otherwise, you may try . */ #define I_NETINET_IN /**/ /* I_SFIO: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SFIO / **/ /* I_STDDEF: * This symbol, if defined, indicates that exists and should * be included. */ #define I_STDDEF /**/ /* I_STDLIB: * This symbol, if defined, indicates that exists and should * be included. */ #define I_STDLIB /**/ /* I_STRING: * This symbol, if defined, indicates to the C program that it should * include (USG systems) instead of (BSD systems). */ #define I_STRING /**/ /* I_SYS_DIR: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_DIR /**/ /* I_SYS_FILE: * This symbol, if defined, indicates to the C program that it should * include to get definition of R_OK and friends. */ #define I_SYS_FILE /**/ /* I_SYS_IOCTL: * This symbol, if defined, indicates that exists and should * be included. Otherwise, include or . */ /* I_SYS_SOCKIO: * This symbol, if defined, indicates the should be included * to get socket ioctl options, like SIOCATMARK. */ #define I_SYS_IOCTL /**/ /*#define I_SYS_SOCKIO / **/ /* I_SYS_NDIR: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_NDIR / **/ /* I_SYS_PARAM: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_PARAM /**/ /* I_SYS_POLL: * This symbol, if defined, indicates that the program may include * . When I_POLL is also defined, it's probably safest * to only include . */ #define I_SYS_POLL /**/ /* I_SYS_RESOURCE: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_RESOURCE /**/ /* I_SYS_SELECT: * This symbol, if defined, indicates to the C program that it should * include in order to get definition of struct timeval. */ #define I_SYS_SELECT /**/ /* I_SYS_STAT: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_STAT /**/ /* I_SYS_TIMES: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_TIMES /**/ /* I_SYS_TYPES: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_TYPES /**/ /* I_SYS_UN: * This symbol, if defined, indicates to the C program that it should * include to get UNIX domain socket definitions. */ #define I_SYS_UN /**/ /* I_SYS_WAIT: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_SYS_WAIT /**/ /* I_TERMIO: * This symbol, if defined, indicates that the program should include * rather than . There are also differences in * the ioctl() calls that depend on the value of this symbol. */ /* I_TERMIOS: * This symbol, if defined, indicates that the program should include * the POSIX termios.h rather than sgtty.h or termio.h. * There are also differences in the ioctl() calls that depend on the * value of this symbol. */ /* I_SGTTY: * This symbol, if defined, indicates that the program should include * rather than . There are also differences in * the ioctl() calls that depend on the value of this symbol. */ /*#define I_TERMIO / **/ #define I_TERMIOS /**/ /*#define I_SGTTY / **/ /* I_UNISTD: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_UNISTD /**/ /* I_UTIME: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_UTIME /**/ /* I_VALUES: * This symbol, if defined, indicates to the C program that it should * include to get definition of symbols like MINFLOAT or * MAXLONG, i.e. machine dependant limitations. Probably, you * should use instead, if it is available. */ #define I_VALUES /**/ /* I_VFORK: * This symbol, if defined, indicates to the C program that it should * include vfork.h. */ /*#define I_VFORK / **/ /* CAN_VAPROTO: * This variable is defined on systems supporting prototype declaration * of functions with a variable number of arguments. */ /* _V: * This macro is used to declare function parameters in prototypes for * functions with a variable number of parameters. Use double parentheses. * For example: * * int printf _V((char *fmt, ...)); * * Remember to use the plain simple _() macro when declaring a function * with no variable number of arguments, since it might be possible to * have a non-effect _V() macro and still get prototypes via _(). */ #define CAN_VAPROTO /**/ #ifdef CAN_VAPROTO #define _V(args) args #else #define _V(args) () #endif /* OSNAME: * This symbol contains the name of the operating system, as determined * by Configure. You shouldn't rely on it too much; the specific * feature tests from Configure are generally more reliable. */ /* OSVERS: * This symbol contains the version of the operating system, as determined * by Configure. You shouldn't rely on it too much; the specific * feature tests from Configure are generally more reliable. */ #define OSNAME "linux" /**/ #define OSVERS "4.18.0-477.21.1.el8_8.x86_64" /**/ /* USE_CROSS_COMPILE: * This symbol, if defined, indicates that Perl is being cross-compiled. */ /* PERL_TARGETARCH: * This symbol, if defined, indicates the target architecture * Perl has been cross-compiled to. Undefined if not a cross-compile. */ #ifndef USE_CROSS_COMPILE /*#define USE_CROSS_COMPILE / **/ #define PERL_TARGETARCH "" /**/ #endif /* MULTIARCH: * This symbol, if defined, signifies that the build * process will produce some binary files that are going to be * used in a cross-platform environment. This is the case for * example with the NeXT "fat" binaries that contain executables * for several CPUs. */ /*#define MULTIARCH / **/ /* MEM_ALIGNBYTES: * This symbol contains the number of bytes required to align a * double, or a long double when applicable. Usual values are 2, * 4 and 8. The default is eight, for safety. */ #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) # define MEM_ALIGNBYTES 8 #else #define MEM_ALIGNBYTES 8 #endif /* ARCHLIB: * This variable, if defined, holds the name of the directory in * which the user wants to put architecture-dependent public * library files for perl5. It is most often a local directory * such as /usr/local/lib. Programs using this variable must be * prepared to deal with filename expansion. If ARCHLIB is the * same as PRIVLIB, it is not defined, since presumably the * program already searches PRIVLIB. */ /* ARCHLIB_EXP: * This symbol contains the ~name expanded version of ARCHLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ #define ARCHLIB "/usr/lib64/perl5" /**/ #define ARCHLIB_EXP "/usr/lib64/perl5" /**/ /* ARCHNAME: * This symbol holds a string representing the architecture name. * It may be used to construct an architecture-dependant pathname * where library files may be held under a private library, for * instance. */ #define ARCHNAME "x86_64-linux-thread-multi" /**/ /* BIN: * This symbol holds the path of the bin directory where the package will * be installed. Program must be prepared to deal with ~name substitution. */ /* BIN_EXP: * This symbol is the filename expanded version of the BIN symbol, for * programs that do not want to deal with that at run-time. */ /* PERL_RELOCATABLE_INC: * This symbol, if defined, indicates that we'd like to relocate entries * in @INC at run time based on the location of the perl binary. */ #define BIN "/usr/bin" /**/ #define BIN_EXP "/usr/bin" /**/ /*#define PERL_RELOCATABLE_INC / **/ /* INTSIZE: * This symbol contains the value of sizeof(int) so that the C * preprocessor can make decisions based on it. */ /* LONGSIZE: * This symbol contains the value of sizeof(long) so that the C * preprocessor can make decisions based on it. */ /* SHORTSIZE: * This symbol contains the value of sizeof(short) so that the C * preprocessor can make decisions based on it. */ #define INTSIZE 4 /**/ #define LONGSIZE 8 /**/ #define SHORTSIZE 2 /**/ /* BYTEORDER: * This symbol holds the hexadecimal constant defined in byteorder, * in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc... * If the compiler supports cross-compiling or multiple-architecture * binaries (eg. on NeXT systems), use compiler-defined macros to * determine the byte order. * On NeXT 3.2 (and greater), you can build "Fat" Multiple Architecture * Binaries (MAB) on either big endian or little endian machines. * The endian-ness is available at compile-time. This only matters * for perl, where the config.h can be generated and installed on * one system, and used by a different architecture to build an * extension. Older versions of NeXT that might not have * defined either *_ENDIAN__ were all on Motorola 680x0 series, * so the default case (for NeXT) is big endian to catch them. * This might matter for NeXT 3.0. */ #if defined(USE_CROSS_COMPILE) || defined(MULTIARCH) # ifdef __LITTLE_ENDIAN__ # if LONGSIZE == 4 # define BYTEORDER 0x1234 # else # if LONGSIZE == 8 # define BYTEORDER 0x12345678 # endif # endif # else # ifdef __BIG_ENDIAN__ # if LONGSIZE == 4 # define BYTEORDER 0x4321 # else # if LONGSIZE == 8 # define BYTEORDER 0x87654321 # endif # endif # endif # endif # if !defined(BYTEORDER) && (defined(NeXT) || defined(__NeXT__)) # define BYTEORDER 0x4321 # endif #else #define BYTEORDER 0x12345678 /* large digits for MSB */ #endif /* NeXT */ /* CHARBITS: * This symbol contains the size of a char, so that the C preprocessor * can make decisions based on it. */ #define CHARBITS 8 /**/ /* CAT2: * This macro concatenates 2 tokens together. */ /* STRINGIFY: * This macro surrounds its token with double quotes. */ #if 42 == 1 #define CAT2(a,b) a/**/b #define STRINGIFY(a) "a" #endif #if 42 == 42 #define PeRl_CaTiFy(a, b) a ## b #define PeRl_StGiFy(a) #a #define CAT2(a,b) PeRl_CaTiFy(a,b) #define StGiFy(a) PeRl_StGiFy(a) #define STRINGIFY(a) PeRl_StGiFy(a) #endif #if 42 != 1 && 42 != 42 #include "Bletch: How does this C preprocessor concatenate tokens?" #endif /* CPPSTDIN: * This symbol contains the first part of the string which will invoke * the C preprocessor on the standard input and produce to standard * output. Typical value of "cc -E" or "/lib/cpp", but it can also * call a wrapper. See CPPRUN. */ /* CPPMINUS: * This symbol contains the second part of the string which will invoke * the C preprocessor on the standard input and produce to standard * output. This symbol will have the value "-" if CPPSTDIN needs a minus * to specify standard input, otherwise the value is "". */ /* CPPRUN: * This symbol contains the string which will invoke a C preprocessor on * the standard input and produce to standard output. It needs to end * with CPPLAST, after all other preprocessor flags have been specified. * The main difference with CPPSTDIN is that this program will never be a * pointer to a shell wrapper, i.e. it will be empty if no preprocessor is * available directly to the user. Note that it may well be different from * the preprocessor used to compile the C program. */ /* CPPLAST: * This symbol is intended to be used along with CPPRUN in the same manner * symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "". */ #define CPPSTDIN "gcc -E" #define CPPMINUS "-" #define CPPRUN "gcc -E" #define CPPLAST "-" /* HAS_ACCESS: * This manifest constant lets the C program know that the access() * system call is available to check for accessibility using real UID/GID. * (always present on UNIX.) */ #define HAS_ACCESS /**/ /* HAS_ACCESSX: * This symbol, if defined, indicates that the accessx routine is * available to do extended access checks. */ /*#define HAS_ACCESSX / **/ /* HAS_ASCTIME_R: * This symbol, if defined, indicates that the asctime_r routine * is available to asctime re-entrantly. */ /* ASCTIME_R_PROTO: * This symbol encodes the prototype of asctime_r. * It is zero if d_asctime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r * is defined. */ #define HAS_ASCTIME_R /**/ #define ASCTIME_R_PROTO REENTRANT_PROTO_B_SB /**/ /* HASATTRIBUTE_FORMAT: * Can we handle GCC attribute for checking printf-style formats */ /* PRINTF_FORMAT_NULL_OK: * Allows __printf__ format to be null when checking printf-style */ /* HASATTRIBUTE_MALLOC: * Can we handle GCC attribute for malloc-style functions. */ /* HASATTRIBUTE_NONNULL: * Can we handle GCC attribute for nonnull function parms. */ /* HASATTRIBUTE_NORETURN: * Can we handle GCC attribute for functions that do not return */ /* HASATTRIBUTE_PURE: * Can we handle GCC attribute for pure functions */ /* HASATTRIBUTE_UNUSED: * Can we handle GCC attribute for unused variables and arguments */ /* HASATTRIBUTE_DEPRECATED: * Can we handle GCC attribute for marking deprecated APIs */ /* HASATTRIBUTE_WARN_UNUSED_RESULT: * Can we handle GCC attribute for warning on unused results */ #define HASATTRIBUTE_DEPRECATED /**/ #define HASATTRIBUTE_FORMAT /**/ /*#define PRINTF_FORMAT_NULL_OK / **/ #define HASATTRIBUTE_NORETURN /**/ #define HASATTRIBUTE_MALLOC /**/ #define HASATTRIBUTE_NONNULL /**/ #define HASATTRIBUTE_PURE /**/ #define HASATTRIBUTE_UNUSED /**/ #define HASATTRIBUTE_WARN_UNUSED_RESULT /**/ /* CASTI32: * This symbol is defined if the C compiler can cast negative * or large floating point numbers to 32-bit ints. */ /*#define CASTI32 / **/ /* CASTNEGFLOAT: * This symbol is defined if the C compiler can cast negative * numbers to unsigned longs, ints and shorts. */ /* CASTFLAGS: * This symbol contains flags that say what difficulties the compiler * has casting odd floating values to unsigned long: * 0 = ok * 1 = couldn't cast < 0 * 2 = couldn't cast >= 0x80000000 * 4 = couldn't cast in argument expression list */ #define CASTNEGFLOAT /**/ #define CASTFLAGS 0 /**/ /* VOID_CLOSEDIR: * This symbol, if defined, indicates that the closedir() routine * does not return a value. */ /*#define VOID_CLOSEDIR / **/ /* HASCONST: * This symbol, if defined, indicates that this C compiler knows about * the const type. There is no need to actually test for that symbol * within your programs. The mere use of the "const" keyword will * trigger the necessary tests. */ #define HASCONST /**/ #ifndef HASCONST #define const #endif /* HAS_CRYPT_R: * This symbol, if defined, indicates that the crypt_r routine * is available to crypt re-entrantly. */ /* CRYPT_R_PROTO: * This symbol encodes the prototype of crypt_r. * It is zero if d_crypt_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r * is defined. */ #define HAS_CRYPT_R /**/ #define CRYPT_R_PROTO REENTRANT_PROTO_B_CCS /**/ /* HAS_CSH: * This symbol, if defined, indicates that the C-shell exists. */ /* CSH: * This symbol, if defined, contains the full pathname of csh. */ #define HAS_CSH /**/ #ifdef HAS_CSH #define CSH "/usr/bin/csh" /**/ #endif /* HAS_CTERMID_R: * This symbol, if defined, indicates that the ctermid_r routine * is available to ctermid re-entrantly. */ /* CTERMID_R_PROTO: * This symbol encodes the prototype of ctermid_r. * It is zero if d_ctermid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r * is defined. */ /*#define HAS_CTERMID_R / **/ #define CTERMID_R_PROTO 0 /**/ /* HAS_CTIME_R: * This symbol, if defined, indicates that the ctime_r routine * is available to ctime re-entrantly. */ /* CTIME_R_PROTO: * This symbol encodes the prototype of ctime_r. * It is zero if d_ctime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r * is defined. */ #define HAS_CTIME_R /**/ #define CTIME_R_PROTO REENTRANT_PROTO_B_SB /**/ /* SETUID_SCRIPTS_ARE_SECURE_NOW: * This symbol, if defined, indicates that the bug that prevents * setuid scripts from being secure is not present in this kernel. */ /* DOSUID: * This symbol, if defined, indicates that the C program should * check the script that it is executing for setuid/setgid bits, and * attempt to emulate setuid/setgid on systems that have disabled * setuid #! scripts because the kernel can't do it securely. * It is up to the package designer to make sure that this emulation * is done securely. Among other things, it should do an fstat on * the script it just opened to make sure it really is a setuid/setgid * script, it should make sure the arguments passed correspond exactly * to the argument on the #! line, and it should not trust any * subprocesses to which it must pass the filename rather than the * file descriptor of the script to be executed. */ /*#define SETUID_SCRIPTS_ARE_SECURE_NOW / **/ /*#define DOSUID / **/ /* HAS_DRAND48_R: * This symbol, if defined, indicates that the drand48_r routine * is available to drand48 re-entrantly. */ /* DRAND48_R_PROTO: * This symbol encodes the prototype of drand48_r. * It is zero if d_drand48_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r * is defined. */ #define HAS_DRAND48_R /**/ #define DRAND48_R_PROTO REENTRANT_PROTO_I_ST /**/ /* HAS_DRAND48_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the drand48() function. Otherwise, it is up * to the program to supply one. A good guess is * extern double drand48(void); */ #define HAS_DRAND48_PROTO /**/ /* HAS_EACCESS: * This symbol, if defined, indicates that the eaccess routine is * available to do extended access checks. */ #define HAS_EACCESS /**/ /* HAS_ENDGRENT: * This symbol, if defined, indicates that the getgrent routine is * available for finalizing sequential access of the group database. */ #define HAS_ENDGRENT /**/ /* HAS_ENDGRENT_R: * This symbol, if defined, indicates that the endgrent_r routine * is available to endgrent re-entrantly. */ /* ENDGRENT_R_PROTO: * This symbol encodes the prototype of endgrent_r. * It is zero if d_endgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r * is defined. */ /*#define HAS_ENDGRENT_R / **/ #define ENDGRENT_R_PROTO 0 /**/ /* HAS_ENDHOSTENT: * This symbol, if defined, indicates that the endhostent() routine is * available to close whatever was being used for host queries. */ #define HAS_ENDHOSTENT /**/ /* HAS_ENDHOSTENT_R: * This symbol, if defined, indicates that the endhostent_r routine * is available to endhostent re-entrantly. */ /* ENDHOSTENT_R_PROTO: * This symbol encodes the prototype of endhostent_r. * It is zero if d_endhostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r * is defined. */ /*#define HAS_ENDHOSTENT_R / **/ #define ENDHOSTENT_R_PROTO 0 /**/ /* HAS_ENDNETENT: * This symbol, if defined, indicates that the endnetent() routine is * available to close whatever was being used for network queries. */ #define HAS_ENDNETENT /**/ /* HAS_ENDNETENT_R: * This symbol, if defined, indicates that the endnetent_r routine * is available to endnetent re-entrantly. */ /* ENDNETENT_R_PROTO: * This symbol encodes the prototype of endnetent_r. * It is zero if d_endnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r * is defined. */ /*#define HAS_ENDNETENT_R / **/ #define ENDNETENT_R_PROTO 0 /**/ /* HAS_ENDPROTOENT: * This symbol, if defined, indicates that the endprotoent() routine is * available to close whatever was being used for protocol queries. */ #define HAS_ENDPROTOENT /**/ /* HAS_ENDPROTOENT_R: * This symbol, if defined, indicates that the endprotoent_r routine * is available to endprotoent re-entrantly. */ /* ENDPROTOENT_R_PROTO: * This symbol encodes the prototype of endprotoent_r. * It is zero if d_endprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r * is defined. */ /*#define HAS_ENDPROTOENT_R / **/ #define ENDPROTOENT_R_PROTO 0 /**/ /* HAS_ENDPWENT: * This symbol, if defined, indicates that the getgrent routine is * available for finalizing sequential access of the passwd database. */ #define HAS_ENDPWENT /**/ /* HAS_ENDPWENT_R: * This symbol, if defined, indicates that the endpwent_r routine * is available to endpwent re-entrantly. */ /* ENDPWENT_R_PROTO: * This symbol encodes the prototype of endpwent_r. * It is zero if d_endpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r * is defined. */ /*#define HAS_ENDPWENT_R / **/ #define ENDPWENT_R_PROTO 0 /**/ /* HAS_ENDSERVENT: * This symbol, if defined, indicates that the endservent() routine is * available to close whatever was being used for service queries. */ #define HAS_ENDSERVENT /**/ /* HAS_ENDSERVENT_R: * This symbol, if defined, indicates that the endservent_r routine * is available to endservent re-entrantly. */ /* ENDSERVENT_R_PROTO: * This symbol encodes the prototype of endservent_r. * It is zero if d_endservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r * is defined. */ /*#define HAS_ENDSERVENT_R / **/ #define ENDSERVENT_R_PROTO 0 /**/ /* HAS_FD_SET: * This symbol, when defined, indicates presence of the fd_set typedef * in */ #define HAS_FD_SET /**/ /* FLEXFILENAMES: * This symbol, if defined, indicates that the system supports filenames * longer than 14 characters. */ #define FLEXFILENAMES /**/ /* Gconvert: * This preprocessor macro is defined to convert a floating point * number to a string without a trailing decimal point. This * emulates the behavior of sprintf("%g"), but is sometimes much more * efficient. If gconvert() is not available, but gcvt() drops the * trailing decimal point, then gcvt() is used. If all else fails, * a macro using sprintf("%g") is used. Arguments for the Gconvert * macro are: value, number of digits, whether trailing zeros should * be retained, and the output buffer. * The usual values are: * d_Gconvert='gconvert((x),(n),(t),(b))' * d_Gconvert='gcvt((x),(n),(b))' * d_Gconvert='sprintf((b),"%.*g",(n),(x))' * The last two assume trailing zeros should not be kept. */ #define Gconvert(x,n,t,b) gcvt((x),(n),(b)) /* HAS_GETGRENT: * This symbol, if defined, indicates that the getgrent routine is * available for sequential access of the group database. */ #define HAS_GETGRENT /**/ /* HAS_GETGRENT_R: * This symbol, if defined, indicates that the getgrent_r routine * is available to getgrent re-entrantly. */ /* GETGRENT_R_PROTO: * This symbol encodes the prototype of getgrent_r. * It is zero if d_getgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r * is defined. */ #define HAS_GETGRENT_R /**/ #define GETGRENT_R_PROTO REENTRANT_PROTO_I_SBWR /**/ /* HAS_GETGRGID_R: * This symbol, if defined, indicates that the getgrgid_r routine * is available to getgrgid re-entrantly. */ /* GETGRGID_R_PROTO: * This symbol encodes the prototype of getgrgid_r. * It is zero if d_getgrgid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r * is defined. */ #define HAS_GETGRGID_R /**/ #define GETGRGID_R_PROTO REENTRANT_PROTO_I_TSBWR /**/ /* HAS_GETGRNAM_R: * This symbol, if defined, indicates that the getgrnam_r routine * is available to getgrnam re-entrantly. */ /* GETGRNAM_R_PROTO: * This symbol encodes the prototype of getgrnam_r. * It is zero if d_getgrnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r * is defined. */ #define HAS_GETGRNAM_R /**/ #define GETGRNAM_R_PROTO REENTRANT_PROTO_I_CSBWR /**/ /* HAS_GETHOSTBYADDR: * This symbol, if defined, indicates that the gethostbyaddr() routine is * available to look up hosts by their IP addresses. */ #define HAS_GETHOSTBYADDR /**/ /* HAS_GETHOSTBYNAME: * This symbol, if defined, indicates that the gethostbyname() routine is * available to look up host names in some data base or other. */ #define HAS_GETHOSTBYNAME /**/ /* HAS_GETHOSTENT: * This symbol, if defined, indicates that the gethostent() routine is * available to look up host names in some data base or another. */ #define HAS_GETHOSTENT /**/ /* HAS_GETHOSTNAME: * This symbol, if defined, indicates that the C program may use the * gethostname() routine to derive the host name. See also HAS_UNAME * and PHOSTNAME. */ /* HAS_UNAME: * This symbol, if defined, indicates that the C program may use the * uname() routine to derive the host name. See also HAS_GETHOSTNAME * and PHOSTNAME. */ /* PHOSTNAME: * This symbol, if defined, indicates the command to feed to the * popen() routine to derive the host name. See also HAS_GETHOSTNAME * and HAS_UNAME. Note that the command uses a fully qualified path, * so that it is safe even if used by a process with super-user * privileges. */ /* HAS_PHOSTNAME: * This symbol, if defined, indicates that the C program may use the * contents of PHOSTNAME as a command to feed to the popen() routine * to derive the host name. */ #define HAS_GETHOSTNAME /**/ #define HAS_UNAME /**/ /*#define HAS_PHOSTNAME / **/ #ifdef HAS_PHOSTNAME #define PHOSTNAME "" /* How to get the host name */ #endif /* HAS_GETHOSTBYADDR_R: * This symbol, if defined, indicates that the gethostbyaddr_r routine * is available to gethostbyaddr re-entrantly. */ /* GETHOSTBYADDR_R_PROTO: * This symbol encodes the prototype of gethostbyaddr_r. * It is zero if d_gethostbyaddr_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r * is defined. */ #define HAS_GETHOSTBYADDR_R /**/ #define GETHOSTBYADDR_R_PROTO REENTRANT_PROTO_I_TsISBWRE /**/ /* HAS_GETHOSTBYNAME_R: * This symbol, if defined, indicates that the gethostbyname_r routine * is available to gethostbyname re-entrantly. */ /* GETHOSTBYNAME_R_PROTO: * This symbol encodes the prototype of gethostbyname_r. * It is zero if d_gethostbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r * is defined. */ #define HAS_GETHOSTBYNAME_R /**/ #define GETHOSTBYNAME_R_PROTO REENTRANT_PROTO_I_CSBWRE /**/ /* HAS_GETHOSTENT_R: * This symbol, if defined, indicates that the gethostent_r routine * is available to gethostent re-entrantly. */ /* GETHOSTENT_R_PROTO: * This symbol encodes the prototype of gethostent_r. * It is zero if d_gethostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r * is defined. */ #define HAS_GETHOSTENT_R /**/ #define GETHOSTENT_R_PROTO REENTRANT_PROTO_I_SBWRE /**/ /* HAS_GETHOST_PROTOS: * This symbol, if defined, indicates that includes * prototypes for gethostent(), gethostbyname(), and * gethostbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ #define HAS_GETHOST_PROTOS /**/ /* HAS_GETLOGIN_R: * This symbol, if defined, indicates that the getlogin_r routine * is available to getlogin re-entrantly. */ /* GETLOGIN_R_PROTO: * This symbol encodes the prototype of getlogin_r. * It is zero if d_getlogin_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r * is defined. */ #define HAS_GETLOGIN_R /**/ #define GETLOGIN_R_PROTO REENTRANT_PROTO_I_BW /**/ /* HAS_GETNETBYADDR: * This symbol, if defined, indicates that the getnetbyaddr() routine is * available to look up networks by their IP addresses. */ #define HAS_GETNETBYADDR /**/ /* HAS_GETNETBYNAME: * This symbol, if defined, indicates that the getnetbyname() routine is * available to look up networks by their names. */ #define HAS_GETNETBYNAME /**/ /* HAS_GETNETENT: * This symbol, if defined, indicates that the getnetent() routine is * available to look up network names in some data base or another. */ #define HAS_GETNETENT /**/ /* HAS_GETNETBYADDR_R: * This symbol, if defined, indicates that the getnetbyaddr_r routine * is available to getnetbyaddr re-entrantly. */ /* GETNETBYADDR_R_PROTO: * This symbol encodes the prototype of getnetbyaddr_r. * It is zero if d_getnetbyaddr_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r * is defined. */ #define HAS_GETNETBYADDR_R /**/ #define GETNETBYADDR_R_PROTO REENTRANT_PROTO_I_uISBWRE /**/ /* HAS_GETNETBYNAME_R: * This symbol, if defined, indicates that the getnetbyname_r routine * is available to getnetbyname re-entrantly. */ /* GETNETBYNAME_R_PROTO: * This symbol encodes the prototype of getnetbyname_r. * It is zero if d_getnetbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r * is defined. */ #define HAS_GETNETBYNAME_R /**/ #define GETNETBYNAME_R_PROTO REENTRANT_PROTO_I_CSBWRE /**/ /* HAS_GETNETENT_R: * This symbol, if defined, indicates that the getnetent_r routine * is available to getnetent re-entrantly. */ /* GETNETENT_R_PROTO: * This symbol encodes the prototype of getnetent_r. * It is zero if d_getnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r * is defined. */ #define HAS_GETNETENT_R /**/ #define GETNETENT_R_PROTO REENTRANT_PROTO_I_SBWRE /**/ /* HAS_GETNET_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getnetent(), getnetbyname(), and * getnetbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ #define HAS_GETNET_PROTOS /**/ /* HAS_GETPAGESIZE: * This symbol, if defined, indicates that the getpagesize system call * is available to get system page size, which is the granularity of * many memory management calls. */ #define HAS_GETPAGESIZE /**/ /* HAS_GETPROTOENT: * This symbol, if defined, indicates that the getprotoent() routine is * available to look up protocols in some data base or another. */ #define HAS_GETPROTOENT /**/ /* HAS_GETPGRP: * This symbol, if defined, indicates that the getpgrp routine is * available to get the current process group. */ /* USE_BSD_GETPGRP: * This symbol, if defined, indicates that getpgrp needs one * arguments whereas USG one needs none. */ #define HAS_GETPGRP /**/ /*#define USE_BSD_GETPGRP / **/ /* HAS_GETPROTOBYNAME: * This symbol, if defined, indicates that the getprotobyname() * routine is available to look up protocols by their name. */ /* HAS_GETPROTOBYNUMBER: * This symbol, if defined, indicates that the getprotobynumber() * routine is available to look up protocols by their number. */ #define HAS_GETPROTOBYNAME /**/ #define HAS_GETPROTOBYNUMBER /**/ /* HAS_GETPROTOBYNAME_R: * This symbol, if defined, indicates that the getprotobyname_r routine * is available to getprotobyname re-entrantly. */ /* GETPROTOBYNAME_R_PROTO: * This symbol encodes the prototype of getprotobyname_r. * It is zero if d_getprotobyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r * is defined. */ #define HAS_GETPROTOBYNAME_R /**/ #define GETPROTOBYNAME_R_PROTO REENTRANT_PROTO_I_CSBWR /**/ /* HAS_GETPROTOBYNUMBER_R: * This symbol, if defined, indicates that the getprotobynumber_r routine * is available to getprotobynumber re-entrantly. */ /* GETPROTOBYNUMBER_R_PROTO: * This symbol encodes the prototype of getprotobynumber_r. * It is zero if d_getprotobynumber_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r * is defined. */ #define HAS_GETPROTOBYNUMBER_R /**/ #define GETPROTOBYNUMBER_R_PROTO REENTRANT_PROTO_I_ISBWR /**/ /* HAS_GETPROTOENT_R: * This symbol, if defined, indicates that the getprotoent_r routine * is available to getprotoent re-entrantly. */ /* GETPROTOENT_R_PROTO: * This symbol encodes the prototype of getprotoent_r. * It is zero if d_getprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r * is defined. */ #define HAS_GETPROTOENT_R /**/ #define GETPROTOENT_R_PROTO REENTRANT_PROTO_I_SBWR /**/ /* HAS_GETPROTO_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getprotoent(), getprotobyname(), and * getprotobyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ #define HAS_GETPROTO_PROTOS /**/ /* HAS_GETPWENT: * This symbol, if defined, indicates that the getpwent routine is * available for sequential access of the passwd database. * If this is not available, the older getpw() function may be available. */ #define HAS_GETPWENT /**/ /* HAS_GETPWENT_R: * This symbol, if defined, indicates that the getpwent_r routine * is available to getpwent re-entrantly. */ /* GETPWENT_R_PROTO: * This symbol encodes the prototype of getpwent_r. * It is zero if d_getpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r * is defined. */ #define HAS_GETPWENT_R /**/ #define GETPWENT_R_PROTO REENTRANT_PROTO_I_SBWR /**/ /* HAS_GETPWNAM_R: * This symbol, if defined, indicates that the getpwnam_r routine * is available to getpwnam re-entrantly. */ /* GETPWNAM_R_PROTO: * This symbol encodes the prototype of getpwnam_r. * It is zero if d_getpwnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r * is defined. */ #define HAS_GETPWNAM_R /**/ #define GETPWNAM_R_PROTO REENTRANT_PROTO_I_CSBWR /**/ /* HAS_GETPWUID_R: * This symbol, if defined, indicates that the getpwuid_r routine * is available to getpwuid re-entrantly. */ /* GETPWUID_R_PROTO: * This symbol encodes the prototype of getpwuid_r. * It is zero if d_getpwuid_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r * is defined. */ #define HAS_GETPWUID_R /**/ #define GETPWUID_R_PROTO REENTRANT_PROTO_I_TSBWR /**/ /* HAS_GETSERVENT: * This symbol, if defined, indicates that the getservent() routine is * available to look up network services in some data base or another. */ #define HAS_GETSERVENT /**/ /* HAS_GETSERVBYNAME_R: * This symbol, if defined, indicates that the getservbyname_r routine * is available to getservbyname re-entrantly. */ /* GETSERVBYNAME_R_PROTO: * This symbol encodes the prototype of getservbyname_r. * It is zero if d_getservbyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r * is defined. */ #define HAS_GETSERVBYNAME_R /**/ #define GETSERVBYNAME_R_PROTO REENTRANT_PROTO_I_CCSBWR /**/ /* HAS_GETSERVBYPORT_R: * This symbol, if defined, indicates that the getservbyport_r routine * is available to getservbyport re-entrantly. */ /* GETSERVBYPORT_R_PROTO: * This symbol encodes the prototype of getservbyport_r. * It is zero if d_getservbyport_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r * is defined. */ #define HAS_GETSERVBYPORT_R /**/ #define GETSERVBYPORT_R_PROTO REENTRANT_PROTO_I_ICSBWR /**/ /* HAS_GETSERVENT_R: * This symbol, if defined, indicates that the getservent_r routine * is available to getservent re-entrantly. */ /* GETSERVENT_R_PROTO: * This symbol encodes the prototype of getservent_r. * It is zero if d_getservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r * is defined. */ #define HAS_GETSERVENT_R /**/ #define GETSERVENT_R_PROTO REENTRANT_PROTO_I_SBWR /**/ /* HAS_GETSERV_PROTOS: * This symbol, if defined, indicates that includes * prototypes for getservent(), getservbyname(), and * getservbyaddr(). Otherwise, it is up to the program to guess * them. See netdbtype.U for probing for various Netdb_xxx_t types. */ #define HAS_GETSERV_PROTOS /**/ /* HAS_GETSPNAM_R: * This symbol, if defined, indicates that the getspnam_r routine * is available to getspnam re-entrantly. */ /* GETSPNAM_R_PROTO: * This symbol encodes the prototype of getspnam_r. * It is zero if d_getspnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r * is defined. */ #define HAS_GETSPNAM_R /**/ #define GETSPNAM_R_PROTO REENTRANT_PROTO_I_CSBWR /**/ /* HAS_GETSERVBYNAME: * This symbol, if defined, indicates that the getservbyname() * routine is available to look up services by their name. */ /* HAS_GETSERVBYPORT: * This symbol, if defined, indicates that the getservbyport() * routine is available to look up services by their port. */ #define HAS_GETSERVBYNAME /**/ #define HAS_GETSERVBYPORT /**/ /* HAS_GMTIME_R: * This symbol, if defined, indicates that the gmtime_r routine * is available to gmtime re-entrantly. */ /* GMTIME_R_PROTO: * This symbol encodes the prototype of gmtime_r. * It is zero if d_gmtime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r * is defined. */ #define HAS_GMTIME_R /**/ #define GMTIME_R_PROTO REENTRANT_PROTO_S_TS /**/ /* HAS_GNULIBC: * This symbol, if defined, indicates to the C program that * the GNU C library is being used. A better check is to use * the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc. */ #define HAS_GNULIBC /**/ #if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE) # define _GNU_SOURCE #endif /* HAS_HTONL: * This symbol, if defined, indicates that the htonl() routine (and * friends htons() ntohl() ntohs()) are available to do network * order byte swapping. */ /* HAS_HTONS: * This symbol, if defined, indicates that the htons() routine (and * friends htonl() ntohl() ntohs()) are available to do network * order byte swapping. */ /* HAS_NTOHL: * This symbol, if defined, indicates that the ntohl() routine (and * friends htonl() htons() ntohs()) are available to do network * order byte swapping. */ /* HAS_NTOHS: * This symbol, if defined, indicates that the ntohs() routine (and * friends htonl() htons() ntohl()) are available to do network * order byte swapping. */ #define HAS_HTONL /**/ #define HAS_HTONS /**/ #define HAS_NTOHL /**/ #define HAS_NTOHS /**/ /* HAS_ISASCII: * This manifest constant lets the C program know that isascii * is available. */ #define HAS_ISASCII /**/ /* HAS_LCHOWN: * This symbol, if defined, indicates that the lchown routine is * available to operate on a symbolic link (instead of following the * link). */ #define HAS_LCHOWN /**/ /* HAS_LOCALTIME_R: * This symbol, if defined, indicates that the localtime_r routine * is available to localtime re-entrantly. */ /* LOCALTIME_R_NEEDS_TZSET: * Many libc's localtime_r implementations do not call tzset, * making them differ from localtime(), and making timezone * changes using $ENV{TZ} without explicitly calling tzset * impossible. This symbol makes us call tzset before localtime_r */ #define LOCALTIME_R_NEEDS_TZSET /**/ #ifdef LOCALTIME_R_NEEDS_TZSET #define L_R_TZSET tzset(), #else #define L_R_TZSET #endif /* LOCALTIME_R_PROTO: * This symbol encodes the prototype of localtime_r. * It is zero if d_localtime_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r * is defined. */ #define HAS_LOCALTIME_R /**/ #define LOCALTIME_R_PROTO REENTRANT_PROTO_S_TS /**/ /* HAS_LONG_DOUBLE: * This symbol will be defined if the C compiler supports long * doubles. */ /* LONG_DOUBLESIZE: * This symbol contains the size of a long double, so that the * C preprocessor can make decisions based on it. It is only * defined if the system supports long doubles. */ #define HAS_LONG_DOUBLE /**/ #ifdef HAS_LONG_DOUBLE #define LONG_DOUBLESIZE 16 /**/ #endif /* HAS_LONG_LONG: * This symbol will be defined if the C compiler supports long long. */ /* LONGLONGSIZE: * This symbol contains the size of a long long, so that the * C preprocessor can make decisions based on it. It is only * defined if the system supports long long. */ #define HAS_LONG_LONG /**/ #ifdef HAS_LONG_LONG #define LONGLONGSIZE 8 /**/ #endif /* HAS_LSEEK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the lseek() function. Otherwise, it is up * to the program to supply one. A good guess is * extern off_t lseek(int, off_t, int); */ #define HAS_LSEEK_PROTO /**/ /* HAS_MEMCHR: * This symbol, if defined, indicates that the memchr routine is available * to locate characters within a C string. */ #define HAS_MEMCHR /**/ /* HAS_MKSTEMP: * This symbol, if defined, indicates that the mkstemp routine is * available to exclusively create and open a uniquely named * temporary file. */ #define HAS_MKSTEMP /**/ /* HAS_MMAP: * This symbol, if defined, indicates that the mmap system call is * available to map a file into memory. */ /* Mmap_t: * This symbol holds the return type of the mmap() system call * (and simultaneously the type of the first argument). * Usually set to 'void *' or 'caddr_t'. */ #define HAS_MMAP /**/ #define Mmap_t void * /**/ /* HAS_MSG: * This symbol, if defined, indicates that the entire msg*(2) library is * supported (IPC mechanism based on message queues). */ #define HAS_MSG /**/ /* HAS_OPEN3: * This manifest constant lets the C program know that the three * argument form of open(2) is available. */ #define HAS_OPEN3 /**/ /* OLD_PTHREAD_CREATE_JOINABLE: * This symbol, if defined, indicates how to create pthread * in joinable (aka undetached) state. NOTE: not defined * if pthread.h already has defined PTHREAD_CREATE_JOINABLE * (the new version of the constant). * If defined, known values are PTHREAD_CREATE_UNDETACHED * and __UNDETACHED. */ /*#define OLD_PTHREAD_CREATE_JOINABLE / **/ /* HAS_PTHREAD_ATFORK: * This symbol, if defined, indicates that the pthread_atfork routine * is available to setup fork handlers. */ #define HAS_PTHREAD_ATFORK /**/ /* HAS_PTHREAD_YIELD: * This symbol, if defined, indicates that the pthread_yield * routine is available to yield the execution of the current * thread. sched_yield is preferable to pthread_yield. */ /* SCHED_YIELD: * This symbol defines the way to yield the execution of * the current thread. Known ways are sched_yield, * pthread_yield, and pthread_yield with NULL. */ /* HAS_SCHED_YIELD: * This symbol, if defined, indicates that the sched_yield * routine is available to yield the execution of the current * thread. sched_yield is preferable to pthread_yield. */ #define HAS_PTHREAD_YIELD /**/ #define SCHED_YIELD sched_yield() /**/ #define HAS_SCHED_YIELD /**/ /* HAS_RANDOM_R: * This symbol, if defined, indicates that the random_r routine * is available to random re-entrantly. */ /* RANDOM_R_PROTO: * This symbol encodes the prototype of random_r. * It is zero if d_random_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r * is defined. */ #define HAS_RANDOM_R /**/ #define RANDOM_R_PROTO REENTRANT_PROTO_I_St /**/ /* HAS_READDIR64_R: * This symbol, if defined, indicates that the readdir64_r routine * is available to readdir64 re-entrantly. */ /* READDIR64_R_PROTO: * This symbol encodes the prototype of readdir64_r. * It is zero if d_readdir64_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r * is defined. */ #define HAS_READDIR64_R /**/ #define READDIR64_R_PROTO REENTRANT_PROTO_I_TSR /**/ /* HAS_READDIR_R: * This symbol, if defined, indicates that the readdir_r routine * is available to readdir re-entrantly. */ /* READDIR_R_PROTO: * This symbol encodes the prototype of readdir_r. * It is zero if d_readdir_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r * is defined. */ #define HAS_READDIR_R /**/ #define READDIR_R_PROTO REENTRANT_PROTO_I_TSR /**/ /* HAS_SAFE_BCOPY: * This symbol, if defined, indicates that the bcopy routine is available * to copy potentially overlapping memory blocks. Normally, you should * probably use memmove() or memcpy(). If neither is defined, roll your * own version. */ /*#define HAS_SAFE_BCOPY / **/ /* HAS_SAFE_MEMCPY: * This symbol, if defined, indicates that the memcpy routine is available * to copy potentially overlapping memory blocks. If you need to * copy overlapping memory blocks, you should check HAS_MEMMOVE and * use memmove() instead, if available. */ /*#define HAS_SAFE_MEMCPY / **/ /* HAS_SANE_MEMCMP: * This symbol, if defined, indicates that the memcmp routine is available * and can be used to compare relative magnitudes of chars with their high * bits set. If it is not defined, roll your own version. */ #define HAS_SANE_MEMCMP /**/ /* HAS_SEM: * This symbol, if defined, indicates that the entire sem*(2) library is * supported. */ #define HAS_SEM /**/ /* HAS_SETGRENT: * This symbol, if defined, indicates that the setgrent routine is * available for initializing sequential access of the group database. */ #define HAS_SETGRENT /**/ /* HAS_SETGRENT_R: * This symbol, if defined, indicates that the setgrent_r routine * is available to setgrent re-entrantly. */ /* SETGRENT_R_PROTO: * This symbol encodes the prototype of setgrent_r. * It is zero if d_setgrent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r * is defined. */ /*#define HAS_SETGRENT_R / **/ #define SETGRENT_R_PROTO 0 /**/ /* HAS_SETHOSTENT: * This symbol, if defined, indicates that the sethostent() routine is * available. */ #define HAS_SETHOSTENT /**/ /* HAS_SETHOSTENT_R: * This symbol, if defined, indicates that the sethostent_r routine * is available to sethostent re-entrantly. */ /* SETHOSTENT_R_PROTO: * This symbol encodes the prototype of sethostent_r. * It is zero if d_sethostent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r * is defined. */ /*#define HAS_SETHOSTENT_R / **/ #define SETHOSTENT_R_PROTO 0 /**/ /* HAS_SETLOCALE_R: * This symbol, if defined, indicates that the setlocale_r routine * is available to setlocale re-entrantly. */ /* SETLOCALE_R_PROTO: * This symbol encodes the prototype of setlocale_r. * It is zero if d_setlocale_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r * is defined. */ /*#define HAS_SETLOCALE_R / **/ #define SETLOCALE_R_PROTO 0 /**/ /* HAS_SETNETENT: * This symbol, if defined, indicates that the setnetent() routine is * available. */ #define HAS_SETNETENT /**/ /* HAS_SETNETENT_R: * This symbol, if defined, indicates that the setnetent_r routine * is available to setnetent re-entrantly. */ /* SETNETENT_R_PROTO: * This symbol encodes the prototype of setnetent_r. * It is zero if d_setnetent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r * is defined. */ /*#define HAS_SETNETENT_R / **/ #define SETNETENT_R_PROTO 0 /**/ /* HAS_SETPROTOENT: * This symbol, if defined, indicates that the setprotoent() routine is * available. */ #define HAS_SETPROTOENT /**/ /* HAS_SETPGRP: * This symbol, if defined, indicates that the setpgrp routine is * available to set the current process group. */ /* USE_BSD_SETPGRP: * This symbol, if defined, indicates that setpgrp needs two * arguments whereas USG one needs none. See also HAS_SETPGID * for a POSIX interface. */ #define HAS_SETPGRP /**/ /*#define USE_BSD_SETPGRP / **/ /* HAS_SETPROTOENT_R: * This symbol, if defined, indicates that the setprotoent_r routine * is available to setprotoent re-entrantly. */ /* SETPROTOENT_R_PROTO: * This symbol encodes the prototype of setprotoent_r. * It is zero if d_setprotoent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r * is defined. */ /*#define HAS_SETPROTOENT_R / **/ #define SETPROTOENT_R_PROTO 0 /**/ /* HAS_SETPWENT: * This symbol, if defined, indicates that the setpwent routine is * available for initializing sequential access of the passwd database. */ #define HAS_SETPWENT /**/ /* HAS_SETPWENT_R: * This symbol, if defined, indicates that the setpwent_r routine * is available to setpwent re-entrantly. */ /* SETPWENT_R_PROTO: * This symbol encodes the prototype of setpwent_r. * It is zero if d_setpwent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r * is defined. */ /*#define HAS_SETPWENT_R / **/ #define SETPWENT_R_PROTO 0 /**/ /* HAS_SETSERVENT: * This symbol, if defined, indicates that the setservent() routine is * available. */ #define HAS_SETSERVENT /**/ /* HAS_SETSERVENT_R: * This symbol, if defined, indicates that the setservent_r routine * is available to setservent re-entrantly. */ /* SETSERVENT_R_PROTO: * This symbol encodes the prototype of setservent_r. * It is zero if d_setservent_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r * is defined. */ /*#define HAS_SETSERVENT_R / **/ #define SETSERVENT_R_PROTO 0 /**/ /* HAS_SETVBUF: * This symbol, if defined, indicates that the setvbuf routine is * available to change buffering on an open stdio stream. * to a line-buffered mode. */ #define HAS_SETVBUF /**/ /* HAS_SHM: * This symbol, if defined, indicates that the entire shm*(2) library is * supported. */ #define HAS_SHM /**/ /* Shmat_t: * This symbol holds the return type of the shmat() system call. * Usually set to 'void *' or 'char *'. */ /* HAS_SHMAT_PROTOTYPE: * This symbol, if defined, indicates that the sys/shm.h includes * a prototype for shmat(). Otherwise, it is up to the program to * guess one. Shmat_t shmat(int, Shmat_t, int) is a good guess, * but not always right so it should be emitted by the program only * when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs. */ #define Shmat_t void * /**/ #define HAS_SHMAT_PROTOTYPE /**/ /* HAS_SIGACTION: * This symbol, if defined, indicates that Vr4's sigaction() routine * is available. */ #define HAS_SIGACTION /**/ /* HAS_SIGSETJMP: * This variable indicates to the C program that the sigsetjmp() * routine is available to save the calling process's registers * and stack environment for later use by siglongjmp(), and * to optionally save the process's signal mask. See * Sigjmp_buf, Sigsetjmp, and Siglongjmp. */ /* Sigjmp_buf: * This is the buffer type to be used with Sigsetjmp and Siglongjmp. */ /* Sigsetjmp: * This macro is used in the same way as sigsetjmp(), but will invoke * traditional setjmp() if sigsetjmp isn't available. * See HAS_SIGSETJMP. */ /* Siglongjmp: * This macro is used in the same way as siglongjmp(), but will invoke * traditional longjmp() if siglongjmp isn't available. * See HAS_SIGSETJMP. */ #define HAS_SIGSETJMP /**/ #ifdef HAS_SIGSETJMP #define Sigjmp_buf sigjmp_buf #define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask)) #define Siglongjmp(buf,retval) siglongjmp((buf),(retval)) #else #define Sigjmp_buf jmp_buf #define Sigsetjmp(buf,save_mask) setjmp((buf)) #define Siglongjmp(buf,retval) longjmp((buf),(retval)) #endif /* HAS_SOCKET: * This symbol, if defined, indicates that the BSD socket interface is * supported. */ /* HAS_SOCKETPAIR: * This symbol, if defined, indicates that the BSD socketpair() call is * supported. */ /* HAS_MSG_CTRUNC: * This symbol, if defined, indicates that the MSG_CTRUNC is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_DONTROUTE: * This symbol, if defined, indicates that the MSG_DONTROUTE is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_OOB: * This symbol, if defined, indicates that the MSG_OOB is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_PEEK: * This symbol, if defined, indicates that the MSG_PEEK is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_MSG_PROXY: * This symbol, if defined, indicates that the MSG_PROXY is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_SCM_RIGHTS: * This symbol, if defined, indicates that the SCM_RIGHTS is supported. * Checking just with #ifdef might not be enough because this symbol * has been known to be an enum. */ /* HAS_SOCKADDR_SA_LEN: * This symbol, if defined, indicates that the struct sockaddr * structure has a member called sa_len, indicating the length of * the structure. */ /* HAS_SOCKADDR_IN6: * This symbol, if defined, indicates the availability of * struct sockaddr_in6; */ /* HAS_SIN6_SCOPE_ID: * This symbol, if defined, indicates that the struct sockaddr_in6 * structure has a member called sin6_scope_id. */ /* HAS_IPV6_MREQ: * This symbol, if defined, indicates the availability of * struct ipv6_mreq; */ #define HAS_SOCKET /**/ #define HAS_SOCKETPAIR /**/ /*#define HAS_SOCKADDR_SA_LEN / **/ #define HAS_MSG_CTRUNC /**/ #define HAS_MSG_DONTROUTE /**/ #define HAS_MSG_OOB /**/ #define HAS_MSG_PEEK /**/ #define HAS_MSG_PROXY /**/ #define HAS_SCM_RIGHTS /**/ #define HAS_SOCKADDR_IN6 /**/ #define HAS_SIN6_SCOPE_ID /**/ #define HAS_IPV6_MREQ /**/ /* HAS_SRAND48_R: * This symbol, if defined, indicates that the srand48_r routine * is available to srand48 re-entrantly. */ /* SRAND48_R_PROTO: * This symbol encodes the prototype of srand48_r. * It is zero if d_srand48_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r * is defined. */ #define HAS_SRAND48_R /**/ #define SRAND48_R_PROTO REENTRANT_PROTO_I_LS /**/ /* HAS_SRANDOM_R: * This symbol, if defined, indicates that the srandom_r routine * is available to srandom re-entrantly. */ /* SRANDOM_R_PROTO: * This symbol encodes the prototype of srandom_r. * It is zero if d_srandom_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r * is defined. */ #define HAS_SRANDOM_R /**/ #define SRANDOM_R_PROTO REENTRANT_PROTO_I_TS /**/ /* USE_STAT_BLOCKS: * This symbol is defined if this system has a stat structure declaring * st_blksize and st_blocks. */ #ifndef USE_STAT_BLOCKS #define USE_STAT_BLOCKS /**/ #endif /* HAS_STATIC_INLINE: * This symbol, if defined, indicates that the C compiler supports * C99-style static inline. That is, the function can't be called * from another translation unit. */ /* PERL_STATIC_INLINE: * This symbol gives the best-guess incantation to use for static * inline functions. If HAS_STATIC_INLINE is defined, this will * give C99-style inline. If HAS_STATIC_INLINE is not defined, * this will give a plain 'static'. It will always be defined * to something that gives static linkage. * Possibilities include * static inline (c99) * static __inline__ (gcc -ansi) * static __inline (MSVC) * static _inline (older MSVC) * static (c89 compilers) */ #define HAS_STATIC_INLINE /**/ #define PERL_STATIC_INLINE static __inline__ /**/ /* USE_STDIO_PTR: * This symbol is defined if the _ptr and _cnt fields (or similar) * of the stdio FILE structure can be used to access the stdio buffer * for a file handle. If this is defined, then the FILE_ptr(fp) * and FILE_cnt(fp) macros will also be defined and should be used * to access these fields. */ /* FILE_ptr: * This macro is used to access the _ptr field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_PTR is defined. */ /* STDIO_PTR_LVALUE: * This symbol is defined if the FILE_ptr macro can be used as an * lvalue. */ /* FILE_cnt: * This macro is used to access the _cnt field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_PTR is defined. */ /* STDIO_CNT_LVALUE: * This symbol is defined if the FILE_cnt macro can be used as an * lvalue. */ /* STDIO_PTR_LVAL_SETS_CNT: * This symbol is defined if using the FILE_ptr macro as an lvalue * to increase the pointer by n has the side effect of decreasing the * value of File_cnt(fp) by n. */ /* STDIO_PTR_LVAL_NOCHANGE_CNT: * This symbol is defined if using the FILE_ptr macro as an lvalue * to increase the pointer by n leaves File_cnt(fp) unchanged. */ #define USE_STDIO_PTR /**/ #ifdef USE_STDIO_PTR #define FILE_ptr(fp) ((fp)->_IO_read_ptr) #define STDIO_PTR_LVALUE /**/ #define FILE_cnt(fp) ((fp)->_IO_read_end - (fp)->_IO_read_ptr) /*#define STDIO_CNT_LVALUE / **/ #define STDIO_PTR_LVAL_SETS_CNT /**/ /*#define STDIO_PTR_LVAL_NOCHANGE_CNT / **/ #endif /* USE_STDIO_BASE: * This symbol is defined if the _base field (or similar) of the * stdio FILE structure can be used to access the stdio buffer for * a file handle. If this is defined, then the FILE_base(fp) macro * will also be defined and should be used to access this field. * Also, the FILE_bufsiz(fp) macro will be defined and should be used * to determine the number of bytes in the buffer. USE_STDIO_BASE * will never be defined unless USE_STDIO_PTR is. */ /* FILE_base: * This macro is used to access the _base field (or equivalent) of the * FILE structure pointed to by its argument. This macro will always be * defined if USE_STDIO_BASE is defined. */ /* FILE_bufsiz: * This macro is used to determine the number of bytes in the I/O * buffer pointed to by _base field (or equivalent) of the FILE * structure pointed to its argument. This macro will always be defined * if USE_STDIO_BASE is defined. */ #define USE_STDIO_BASE /**/ #ifdef USE_STDIO_BASE #define FILE_base(fp) ((fp)->_IO_read_base) #define FILE_bufsiz(fp) ((fp)->_IO_read_end - (fp)->_IO_read_base) #endif /* USE_STRUCT_COPY: * This symbol, if defined, indicates that this C compiler knows how * to copy structures. If undefined, you'll need to use a block copy * routine of some sort instead. */ #define USE_STRUCT_COPY /**/ /* HAS_STRERROR: * This symbol, if defined, indicates that the strerror routine is * available to translate error numbers to strings. See the writeup * of Strerror() in this file before you try to define your own. */ /* HAS_SYS_ERRLIST: * This symbol, if defined, indicates that the sys_errlist array is * available to translate error numbers to strings. The extern int * sys_nerr gives the size of that table. */ /* Strerror: * This preprocessor symbol is defined as a macro if strerror() is * not available to translate error numbers to strings but sys_errlist[] * array is there. */ #define HAS_STRERROR /**/ #define HAS_SYS_ERRLIST /**/ #define Strerror(e) strerror(e) /* HAS_STRERROR_R: * This symbol, if defined, indicates that the strerror_r routine * is available to strerror re-entrantly. */ /* STRERROR_R_PROTO: * This symbol encodes the prototype of strerror_r. * It is zero if d_strerror_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r * is defined. */ #define HAS_STRERROR_R /**/ #define STRERROR_R_PROTO REENTRANT_PROTO_B_IBW /**/ /* HAS_STRTOUL: * This symbol, if defined, indicates that the strtoul routine is * available to provide conversion of strings to unsigned long. */ #define HAS_STRTOUL /**/ /* HAS_TIME: * This symbol, if defined, indicates that the time() routine exists. */ /* Time_t: * This symbol holds the type returned by time(). It can be long, * or time_t on BSD sites (in which case should be * included). */ #define HAS_TIME /**/ #define Time_t time_t /* Time type */ /* HAS_TIMES: * This symbol, if defined, indicates that the times() routine exists. * Note that this became obsolete on some systems (SUNOS), which now * use getrusage(). It may be necessary to include . */ #define HAS_TIMES /**/ /* HAS_TMPNAM_R: * This symbol, if defined, indicates that the tmpnam_r routine * is available to tmpnam re-entrantly. */ /* TMPNAM_R_PROTO: * This symbol encodes the prototype of tmpnam_r. * It is zero if d_tmpnam_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r * is defined. */ #define HAS_TMPNAM_R /**/ #define TMPNAM_R_PROTO REENTRANT_PROTO_B_B /**/ /* HAS_TTYNAME_R: * This symbol, if defined, indicates that the ttyname_r routine * is available to ttyname re-entrantly. */ /* TTYNAME_R_PROTO: * This symbol encodes the prototype of ttyname_r. * It is zero if d_ttyname_r is undef, and one of the * REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r * is defined. */ #define HAS_TTYNAME_R /**/ #define TTYNAME_R_PROTO REENTRANT_PROTO_I_IBW /**/ /* HAS_UNION_SEMUN: * This symbol, if defined, indicates that the union semun is * defined by including . If not, the user code * probably needs to define it as: * union semun { * int val; * struct semid_ds *buf; * unsigned short *array; * } */ /* USE_SEMCTL_SEMUN: * This symbol, if defined, indicates that union semun is * used for semctl IPC_STAT. */ /* USE_SEMCTL_SEMID_DS: * This symbol, if defined, indicates that struct semid_ds * is * used for semctl IPC_STAT. */ /*#define HAS_UNION_SEMUN / **/ #define USE_SEMCTL_SEMUN /**/ #define USE_SEMCTL_SEMID_DS /**/ /* HAS_VFORK: * This symbol, if defined, indicates that vfork() exists. */ /*#define HAS_VFORK / **/ /* HAS_PSEUDOFORK: * This symbol, if defined, indicates that an emulation of the * fork routine is available. */ /*#define HAS_PSEUDOFORK / **/ /* Signal_t: * This symbol's value is either "void" or "int", corresponding to the * appropriate return type of a signal handler. Thus, you can declare * a signal handler using "Signal_t (*handler)()", and define the * handler using "Signal_t handler(sig)". */ #define Signal_t void /* Signal handler's return type */ /* HASVOLATILE: * This symbol, if defined, indicates that this C compiler knows about * the volatile declaration. */ #define HASVOLATILE /**/ #ifndef HASVOLATILE #define volatile #endif /* HAS_VPRINTF: * This symbol, if defined, indicates that the vprintf routine is available * to printf with a pointer to an argument list. If unavailable, you * may need to write your own, probably in terms of _doprnt(). */ /* USE_CHAR_VSPRINTF: * This symbol is defined if this system has vsprintf() returning type * (char*). The trend seems to be to declare it as "int vsprintf()". It * is up to the package author to declare vsprintf correctly based on the * symbol. */ #define HAS_VPRINTF /**/ /*#define USE_CHAR_VSPRINTF / **/ /* DOUBLESIZE: * This symbol contains the size of a double, so that the C preprocessor * can make decisions based on it. */ #define DOUBLESIZE 8 /**/ /* EBCDIC: * This symbol, if defined, indicates that this system uses * EBCDIC encoding. */ /*#define EBCDIC / **/ /* Fpos_t: * This symbol holds the type used to declare file positions in libc. * It can be fpos_t, long, uint, etc... It may be necessary to include * to get any typedef'ed information. */ #define Fpos_t fpos_t /* File position type */ /* Gid_t_f: * This symbol defines the format string used for printing a Gid_t. */ #define Gid_t_f "u" /**/ /* Gid_t_sign: * This symbol holds the signedess of a Gid_t. * 1 for unsigned, -1 for signed. */ #define Gid_t_sign 1 /* GID sign */ /* Gid_t_size: * This symbol holds the size of a Gid_t in bytes. */ #define Gid_t_size 4 /* GID size */ /* Gid_t: * This symbol holds the return type of getgid() and the type of * argument to setrgid() and related functions. Typically, * it is the type of group ids in the kernel. It can be int, ushort, * gid_t, etc... It may be necessary to include to get * any typedef'ed information. */ #define Gid_t gid_t /* Type for getgid(), etc... */ /* I_DIRENT: * This symbol, if defined, indicates to the C program that it should * include . Using this symbol also triggers the definition * of the Direntry_t define which ends up being 'struct dirent' or * 'struct direct' depending on the availability of . */ /* DIRNAMLEN: * This symbol, if defined, indicates to the C program that the length * of directory entry names is provided by a d_namlen field. Otherwise * you need to do strlen() on the d_name field. */ /* Direntry_t: * This symbol is set to 'struct direct' or 'struct dirent' depending on * whether dirent is available or not. You should use this pseudo type to * portably declare your directory entries. */ #define I_DIRENT /**/ /*#define DIRNAMLEN / **/ #define Direntry_t struct dirent /* I_GRP: * This symbol, if defined, indicates to the C program that it should * include . */ /* GRPASSWD: * This symbol, if defined, indicates to the C program that struct group * in contains gr_passwd. */ #define I_GRP /**/ #define GRPASSWD /**/ /* I_MACH_CTHREADS: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MACH_CTHREADS / **/ /* I_NDBM: * This symbol, if defined, indicates that exists and should * be included. */ /* I_GDBMNDBM: * This symbol, if defined, indicates that exists and should * be included. This was the location of the ndbm.h compatibility file * in RedHat 7.1. */ /* I_GDBM_NDBM: * This symbol, if defined, indicates that exists and should * be included. This is the location of the ndbm.h compatibility file * in Debian 4.0. */ /* NDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /* GDBMNDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /* GDBM_NDBM_H_USES_PROTOTYPES: * This symbol, if defined, indicates that uses real ANSI C * prototypes instead of K&R style function declarations without any * parameter information. While ANSI C prototypes are supported in C++, * K&R style function declarations will yield errors. */ /*#define I_NDBM / **/ #define I_GDBMNDBM /**/ /*#define I_GDBM_NDBM / **/ /*#define NDBM_H_USES_PROTOTYPES / **/ #define GDBMNDBM_H_USES_PROTOTYPES /**/ /*#define GDBM_NDBM_H_USES_PROTOTYPES / **/ /* I_NETDB: * This symbol, if defined, indicates that exists and * should be included. */ #define I_NETDB /**/ /* I_NET_ERRNO: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_NET_ERRNO / **/ /* I_PTHREAD: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_PTHREAD /**/ /* I_PWD: * This symbol, if defined, indicates to the C program that it should * include . */ /* PWQUOTA: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_quota. */ /* PWAGE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_age. */ /* PWCHANGE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_change. */ /* PWCLASS: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_class. */ /* PWEXPIRE: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_expire. */ /* PWCOMMENT: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_comment. */ /* PWGECOS: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_gecos. */ /* PWPASSWD: * This symbol, if defined, indicates to the C program that struct passwd * contains pw_passwd. */ #define I_PWD /**/ /*#define PWQUOTA / **/ /*#define PWAGE / **/ /*#define PWCHANGE / **/ /*#define PWCLASS / **/ /*#define PWEXPIRE / **/ /*#define PWCOMMENT / **/ #define PWGECOS /**/ #define PWPASSWD /**/ /* I_SYS_ACCESS: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_ACCESS / **/ /* I_SYS_SECURITY: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_SYS_SECURITY / **/ /* I_SYSUIO: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYSUIO /**/ /* I_TIME: * This symbol, if defined, indicates to the C program that it should * include . */ /* I_SYS_TIME: * This symbol, if defined, indicates to the C program that it should * include . */ /* I_SYS_TIME_KERNEL: * This symbol, if defined, indicates to the C program that it should * include with KERNEL defined. */ /* HAS_TM_TM_ZONE: * This symbol, if defined, indicates to the C program that * the struct tm has a tm_zone field. */ /* HAS_TM_TM_GMTOFF: * This symbol, if defined, indicates to the C program that * the struct tm has a tm_gmtoff field. */ #define I_TIME /**/ #define I_SYS_TIME /**/ /*#define I_SYS_TIME_KERNEL / **/ #define HAS_TM_TM_ZONE /**/ #define HAS_TM_TM_GMTOFF /**/ /* I_STDARG: * This symbol, if defined, indicates that exists and should * be included. */ /* I_VARARGS: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_STDARG /**/ /*#define I_VARARGS / **/ /* PERL_INC_VERSION_LIST: * This variable specifies the list of subdirectories in over * which perl.c:incpush() and lib/lib.pm will automatically * search when adding directories to @INC, in a format suitable * for a C initialization string. See the inc_version_list entry * in Porting/Glossary for more details. */ /*#define PERL_INC_VERSION_LIST 0 / **/ /* INSTALL_USR_BIN_PERL: * This symbol, if defined, indicates that Perl is to be installed * also as /usr/bin/perl. */ /*#define INSTALL_USR_BIN_PERL / **/ /* Off_t: * This symbol holds the type used to declare offsets in the kernel. * It can be int, long, off_t, etc... It may be necessary to include * to get any typedef'ed information. */ /* LSEEKSIZE: * This symbol holds the number of bytes used by the Off_t. */ /* Off_t_size: * This symbol holds the number of bytes used by the Off_t. */ #define Off_t off_t /* type */ #define LSEEKSIZE 8 /* size */ #define Off_t_size 8 /* size */ /* Free_t: * This variable contains the return type of free(). It is usually * void, but occasionally int. */ /* Malloc_t: * This symbol is the type of pointer returned by malloc and realloc. */ #define Malloc_t void * /**/ #define Free_t void /**/ /* PERL_MALLOC_WRAP: * This symbol, if defined, indicates that we'd like malloc wrap checks. */ #define PERL_MALLOC_WRAP /**/ /* MYMALLOC: * This symbol, if defined, indicates that we're using our own malloc. */ /*#define MYMALLOC / **/ /* Mode_t: * This symbol holds the type used to declare file modes * for systems calls. It is usually mode_t, but may be * int or unsigned short. It may be necessary to include * to get any typedef'ed information. */ #define Mode_t mode_t /* file mode parameter for system calls */ /* VAL_O_NONBLOCK: * This symbol is to be used during open() or fcntl(F_SETFL) to turn on * non-blocking I/O for the file descriptor. Note that there is no way * back, i.e. you cannot turn it blocking again this way. If you wish to * alternatively switch between blocking and non-blocking, use the * ioctl(FIOSNBIO) call instead, but that is not supported by all devices. */ /* VAL_EAGAIN: * This symbol holds the errno error code set by read() when no data was * present on the non-blocking file descriptor. */ /* RD_NODATA: * This symbol holds the return code from read() when no data is present * on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is * not defined, then you can't distinguish between no data and EOF by * issuing a read(). You'll have to find another way to tell for sure! */ /* EOF_NONBLOCK: * This symbol, if defined, indicates to the C program that a read() on * a non-blocking file descriptor will return 0 on EOF, and not the value * held in RD_NODATA (-1 usually, in that case!). */ #define VAL_O_NONBLOCK O_NONBLOCK #define VAL_EAGAIN EAGAIN #define RD_NODATA -1 #define EOF_NONBLOCK /* Netdb_host_t: * This symbol holds the type used for the 1st argument * to gethostbyaddr(). */ /* Netdb_hlen_t: * This symbol holds the type used for the 2nd argument * to gethostbyaddr(). */ /* Netdb_name_t: * This symbol holds the type used for the argument to * gethostbyname(). */ /* Netdb_net_t: * This symbol holds the type used for the 1st argument to * getnetbyaddr(). */ #define Netdb_host_t char * /**/ #define Netdb_hlen_t size_t /**/ #define Netdb_name_t const char * /**/ #define Netdb_net_t in_addr_t /**/ /* PERL_OTHERLIBDIRS: * This variable contains a colon-separated set of paths for the perl * binary to search for additional library files or modules. * These directories will be tacked to the end of @INC. * Perl will automatically search below each path for version- * and architecture-specific directories. See PERL_INC_VERSION_LIST * for more details. */ /*#define PERL_OTHERLIBDIRS " " / **/ /* Pid_t: * This symbol holds the type used to declare process ids in the kernel. * It can be int, uint, pid_t, etc... It may be necessary to include * to get any typedef'ed information. */ #define Pid_t pid_t /* PID type */ /* PRIVLIB: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. */ /* PRIVLIB_EXP: * This symbol contains the ~name expanded version of PRIVLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ #define PRIVLIB "/usr/share/perl5" /**/ #define PRIVLIB_EXP "/usr/share/perl5" /**/ /* CAN_PROTOTYPE: * If defined, this macro indicates that the C compiler can handle * function prototypes. */ /* _: * This macro is used to declare function parameters for folks who want * to make declarations with prototypes using a different style than * the above macros. Use double parentheses. For example: * * int main _((int argc, char *argv[])); */ #define CAN_PROTOTYPE /**/ #ifdef CAN_PROTOTYPE #define _(args) args #else #define _(args) () #endif /* PTRSIZE: * This symbol contains the size of a pointer, so that the C preprocessor * can make decisions based on it. It will be sizeof(void *) if * the compiler supports (void *); otherwise it will be * sizeof(char *). */ #define PTRSIZE 8 /**/ /* HAS_QUAD: * This symbol, if defined, tells that there's a 64-bit integer type, * Quad_t, and its unsigned counterpart, Uquad_t. QUADKIND will be one * of QUAD_IS_INT, QUAD_IS_LONG, QUAD_IS_LONG_LONG, QUAD_IS_INT64_T, * or QUAD_IS___INT64. */ #define HAS_QUAD /**/ #ifdef HAS_QUAD # define Quad_t long /**/ # define Uquad_t unsigned long /**/ # define QUADKIND 2 /**/ # define QUAD_IS_INT 1 # define QUAD_IS_LONG 2 # define QUAD_IS_LONG_LONG 3 # define QUAD_IS_INT64_T 4 # define QUAD_IS___INT64 5 #endif /* Drand01: * This macro is to be used to generate uniformly distributed * random numbers over the range [0., 1.[. You may have to supply * an 'extern double drand48();' in your program since SunOS 4.1.3 * doesn't provide you with anything relevant in its headers. * See HAS_DRAND48_PROTO. */ /* Rand_seed_t: * This symbol defines the type of the argument of the * random seed function. */ /* seedDrand01: * This symbol defines the macro to be used in seeding the * random number generator (see Drand01). */ /* RANDBITS: * This symbol indicates how many bits are produced by the * function used to generate normalized random numbers. * Values include 15, 16, 31, and 48. */ #define Drand01() drand48() /**/ #define Rand_seed_t long /**/ #define seedDrand01(x) srand48((Rand_seed_t)x) /**/ #define RANDBITS 48 /**/ /* Select_fd_set_t: * This symbol holds the type used for the 2nd, 3rd, and 4th * arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET * is defined, and 'int *' otherwise. This is only useful if you * have select(), of course. */ #define Select_fd_set_t fd_set * /**/ /* SH_PATH: * This symbol contains the full pathname to the shell used on this * on this system to execute Bourne shell scripts. Usually, this will be * /bin/sh, though it's possible that some systems will have /bin/ksh, * /bin/pdksh, /bin/ash, /bin/bash, or even something such as * D:/bin/sh.exe. */ #define SH_PATH "/bin/sh" /**/ /* SIG_NAME: * This symbol contains a list of signal names in order of * signal number. This is intended * to be used as a static array initialization, like this: * char *sig_name[] = { SIG_NAME }; * The signals in the list are separated with commas, and each signal * is surrounded by double quotes. There is no leading SIG in the signal * name, i.e. SIGQUIT is known as "QUIT". * Gaps in the signal numbers (up to NSIG) are filled in with NUMnn, * etc., where nn is the actual signal number (e.g. NUM37). * The signal number for sig_name[i] is stored in sig_num[i]. * The last element is 0 to terminate the list with a NULL. This * corresponds to the 0 at the end of the sig_name_init list. * Note that this variable is initialized from the sig_name_init, * not from sig_name (which is unused). */ /* SIG_NUM: * This symbol contains a list of signal numbers, in the same order as the * SIG_NAME list. It is suitable for static array initialization, as in: * int sig_num[] = { SIG_NUM }; * The signals in the list are separated with commas, and the indices * within that list and the SIG_NAME list match, so it's easy to compute * the signal name from a number or vice versa at the price of a small * dynamic linear lookup. * Duplicates are allowed, but are moved to the end of the list. * The signal number corresponding to sig_name[i] is sig_number[i]. * if (i < NSIG) then sig_number[i] == i. * The last element is 0, corresponding to the 0 at the end of * the sig_name_init list. * Note that this variable is initialized from the sig_num_init, * not from sig_num (which is unused). */ /* SIG_SIZE: * This variable contains the number of elements of the SIG_NAME * and SIG_NUM arrays, excluding the final NULL entry. */ #define SIG_NAME "ZERO", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "BUS", "FPE", "KILL", "USR1", "SEGV", "USR2", "PIPE", "ALRM", "TERM", "STKFLT", "CHLD", "CONT", "STOP", "TSTP", "TTIN", "TTOU", "URG", "XCPU", "XFSZ", "VTALRM", "PROF", "WINCH", "IO", "PWR", "SYS", "NUM32", "NUM33", "RTMIN", "NUM35", "NUM36", "NUM37", "NUM38", "NUM39", "NUM40", "NUM41", "NUM42", "NUM43", "NUM44", "NUM45", "NUM46", "NUM47", "NUM48", "NUM49", "NUM50", "NUM51", "NUM52", "NUM53", "NUM54", "NUM55", "NUM56", "NUM57", "NUM58", "NUM59", "NUM60", "NUM61", "NUM62", "NUM63", "RTMAX", "IOT", "CLD", "POLL", "UNUSED", 0 /**/ #define SIG_NUM 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 6, 17, 29, 31, 0 /**/ #define SIG_SIZE 69 /**/ /* SITEARCH: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. * The standard distribution will put nothing in this directory. * After perl has been installed, users may install their own local * architecture-dependent modules in this directory with * MakeMaker Makefile.PL * or equivalent. See INSTALL for details. */ /* SITEARCH_EXP: * This symbol contains the ~name expanded version of SITEARCH, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ #define SITEARCH "/usr/local/lib64/perl5" /**/ #define SITEARCH_EXP "/usr/local/lib64/perl5" /**/ /* SITELIB: * This symbol contains the name of the private library for this package. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. The program * should be prepared to do ~ expansion. * The standard distribution will put nothing in this directory. * After perl has been installed, users may install their own local * architecture-independent modules in this directory with * MakeMaker Makefile.PL * or equivalent. See INSTALL for details. */ /* SITELIB_EXP: * This symbol contains the ~name expanded version of SITELIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /* SITELIB_STEM: * This define is SITELIB_EXP with any trailing version-specific component * removed. The elements in inc_version_list (inc_version_list.U) can * be tacked onto this variable to generate a list of directories to search. */ #define SITELIB "/usr/local/share/perl5" /**/ #define SITELIB_EXP "/usr/local/share/perl5" /**/ #define SITELIB_STEM "/usr/local/share/perl5" /**/ /* Size_t_size: * This symbol holds the size of a Size_t in bytes. */ #define Size_t_size 8 /**/ /* Size_t: * This symbol holds the type used to declare length parameters * for string functions. It is usually size_t, but may be * unsigned long, int, etc. It may be necessary to include * to get any typedef'ed information. */ #define Size_t size_t /* length parameter for string functions */ /* Sock_size_t: * This symbol holds the type used for the size argument of * various socket calls (just the base type, not the pointer-to). */ #define Sock_size_t socklen_t /**/ /* SSize_t: * This symbol holds the type used by functions that return * a count of bytes or an error condition. It must be a signed type. * It is usually ssize_t, but may be long or int, etc. * It may be necessary to include or * to get any typedef'ed information. * We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). */ #define SSize_t ssize_t /* signed count of bytes */ /* STDCHAR: * This symbol is defined to be the type of char used in stdio.h. * It has the values "unsigned char" or "char". */ #define STDCHAR char /**/ /* Uid_t_f: * This symbol defines the format string used for printing a Uid_t. */ #define Uid_t_f "u" /**/ /* Uid_t_sign: * This symbol holds the signedess of a Uid_t. * 1 for unsigned, -1 for signed. */ #define Uid_t_sign 1 /* UID sign */ /* Uid_t_size: * This symbol holds the size of a Uid_t in bytes. */ #define Uid_t_size 4 /* UID size */ /* Uid_t: * This symbol holds the type used to declare user ids in the kernel. * It can be int, ushort, uid_t, etc... It may be necessary to include * to get any typedef'ed information. */ #define Uid_t uid_t /* UID type */ /* USE_ITHREADS: * This symbol, if defined, indicates that Perl should be built to * use the interpreter-based threading implementation. */ /* USE_5005THREADS: * This symbol, if defined, indicates that Perl should be built to * use the 5.005-based threading implementation. * Only valid up to 5.8.x. */ /* OLD_PTHREADS_API: * This symbol, if defined, indicates that Perl should * be built to use the old draft POSIX threads API. */ /* USE_REENTRANT_API: * This symbol, if defined, indicates that Perl should * try to use the various _r versions of library functions. * This is extremely experimental. */ /*#define USE_5005THREADS / **/ #define USE_ITHREADS /**/ #if defined(USE_5005THREADS) && !defined(USE_ITHREADS) #define USE_THREADS /* until src is revised*/ #endif /*#define OLD_PTHREADS_API / **/ /*#define USE_REENTRANT_API / **/ /* PERL_VENDORARCH: * If defined, this symbol contains the name of a private library. * The library is private in the sense that it needn't be in anyone's * execution path, but it should be accessible by the world. * It may have a ~ on the front. * The standard distribution will put nothing in this directory. * Vendors who distribute perl may wish to place their own * architecture-dependent modules and extensions in this directory with * MakeMaker Makefile.PL INSTALLDIRS=vendor * or equivalent. See INSTALL for details. */ /* PERL_VENDORARCH_EXP: * This symbol contains the ~name expanded version of PERL_VENDORARCH, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ #define PERL_VENDORARCH "/usr/lib64/perl5/vendor_perl" /**/ #define PERL_VENDORARCH_EXP "/usr/lib64/perl5/vendor_perl" /**/ /* PERL_VENDORLIB_EXP: * This symbol contains the ~name expanded version of VENDORLIB, to be used * in programs that are not prepared to deal with ~ expansion at run-time. */ /* PERL_VENDORLIB_STEM: * This define is PERL_VENDORLIB_EXP with any trailing version-specific component * removed. The elements in inc_version_list (inc_version_list.U) can * be tacked onto this variable to generate a list of directories to search. */ #define PERL_VENDORLIB_EXP "/usr/share/perl5/vendor_perl" /**/ #define PERL_VENDORLIB_STEM "/usr/share/perl5/vendor_perl" /**/ /* VOIDFLAGS: * This symbol indicates how much support of the void type is given by this * compiler. What various bits mean: * * 1 = supports declaration of void * 2 = supports arrays of pointers to functions returning void * 4 = supports comparisons between pointers to void functions and * addresses of void functions * 8 = supports declaration of generic void pointers * * The package designer should define VOIDUSED to indicate the requirements * of the package. This can be done either by #defining VOIDUSED before * including config.h, or by defining defvoidused in Myinit.U. If the * latter approach is taken, only those flags will be tested. If the * level of void support necessary is not present, defines void to int. */ #ifndef VOIDUSED #define VOIDUSED 15 #endif #define VOIDFLAGS 15 #if (VOIDFLAGS & VOIDUSED) != VOIDUSED #define void int /* is void to be avoided? */ #define M_VOID /* Xenix strikes again */ #endif /* PERL_USE_DEVEL: * This symbol, if defined, indicates that Perl was configured with * -Dusedevel, to enable development features. This should not be * done for production builds. */ /*#define PERL_USE_DEVEL / **/ /* HAS_ATOLF: * This symbol, if defined, indicates that the atolf routine is * available to convert strings into long doubles. */ /*#define HAS_ATOLF / **/ /* HAS_ATOLL: * This symbol, if defined, indicates that the atoll routine is * available to convert strings into long longs. */ #define HAS_ATOLL /**/ /* HAS__FWALK: * This symbol, if defined, indicates that the _fwalk system call is * available to apply a function to all the file handles. */ /*#define HAS__FWALK / **/ /* HAS_AINTL: * This symbol, if defined, indicates that the aintl routine is * available. If copysignl is also present we can emulate modfl. */ /*#define HAS_AINTL / **/ /* HAS_BUILTIN_CHOOSE_EXPR: * Can we handle GCC builtin for compile-time ternary-like expressions */ /* HAS_BUILTIN_EXPECT: * Can we handle GCC builtin for telling that certain values are more * likely */ #define HAS_BUILTIN_EXPECT /**/ #define HAS_BUILTIN_CHOOSE_EXPR /**/ /* HAS_C99_VARIADIC_MACROS: * If defined, the compiler supports C99 variadic macros. */ #define HAS_C99_VARIADIC_MACROS /**/ /* HAS_CLASS: * This symbol, if defined, indicates that the class routine is * available to classify doubles. Available for example in AIX. * The returned values are defined in and are: * * FP_PLUS_NORM Positive normalized, nonzero * FP_MINUS_NORM Negative normalized, nonzero * FP_PLUS_DENORM Positive denormalized, nonzero * FP_MINUS_DENORM Negative denormalized, nonzero * FP_PLUS_ZERO +0.0 * FP_MINUS_ZERO -0.0 * FP_PLUS_INF +INF * FP_MINUS_INF -INF * FP_NANS Signaling Not a Number (NaNS) * FP_NANQ Quiet Not a Number (NaNQ) */ /*#define HAS_CLASS / **/ /* HAS_CLEARENV: * This symbol, if defined, indicates that the clearenv () routine is * available for use. */ #define HAS_CLEARENV /**/ /* HAS_STRUCT_CMSGHDR: * This symbol, if defined, indicates that the struct cmsghdr * is supported. */ #define HAS_STRUCT_CMSGHDR /**/ /* HAS_COPYSIGNL: * This symbol, if defined, indicates that the copysignl routine is * available. If aintl is also present we can emulate modfl. */ #define HAS_COPYSIGNL /**/ /* USE_CPLUSPLUS: * This symbol, if defined, indicates that a C++ compiler was * used to compiled Perl and will be used to compile extensions. */ /*#define USE_CPLUSPLUS / **/ /* HAS_DBMINIT_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the dbminit() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int dbminit(char *); */ #define HAS_DBMINIT_PROTO /**/ /* HAS_DIR_DD_FD: * This symbol, if defined, indicates that the the DIR* dirstream * structure contains a member variable named dd_fd. */ /*#define HAS_DIR_DD_FD / **/ /* HAS_DIRFD: * This manifest constant lets the C program know that dirfd * is available. */ #define HAS_DIRFD /**/ /* DLSYM_NEEDS_UNDERSCORE: * This symbol, if defined, indicates that we need to prepend an * underscore to the symbol name before calling dlsym(). This only * makes sense if you *have* dlsym, which we will presume is the * case if you're using dl_dlopen.xs. */ /*#define DLSYM_NEEDS_UNDERSCORE / **/ /* HAS_FAST_STDIO: * This symbol, if defined, indicates that the "fast stdio" * is available to manipulate the stdio buffers directly. */ #define HAS_FAST_STDIO /**/ /* HAS_FCHDIR: * This symbol, if defined, indicates that the fchdir routine is * available to change directory using a file descriptor. */ #define HAS_FCHDIR /**/ /* FCNTL_CAN_LOCK: * This symbol, if defined, indicates that fcntl() can be used * for file locking. Normally on Unix systems this is defined. * It may be undefined on VMS. */ #define FCNTL_CAN_LOCK /**/ /* HAS_FINITE: * This symbol, if defined, indicates that the finite routine is * available to check whether a double is finite (non-infinity non-NaN). */ #define HAS_FINITE /**/ /* HAS_FINITEL: * This symbol, if defined, indicates that the finitel routine is * available to check whether a long double is finite * (non-infinity non-NaN). */ #define HAS_FINITEL /**/ /* HAS_FLOCK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the flock() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int flock(int, int); */ #define HAS_FLOCK_PROTO /**/ /* HAS_FP_CLASS: * This symbol, if defined, indicates that the fp_class routine is * available to classify doubles. Available for example in Digital UNIX. * The returned values are defined in and are: * * FP_SNAN Signaling NaN (Not-a-Number) * FP_QNAN Quiet NaN (Not-a-Number) * FP_POS_INF +infinity * FP_NEG_INF -infinity * FP_POS_NORM Positive normalized * FP_NEG_NORM Negative normalized * FP_POS_DENORM Positive denormalized * FP_NEG_DENORM Negative denormalized * FP_POS_ZERO +0.0 (positive zero) * FP_NEG_ZERO -0.0 (negative zero) */ /*#define HAS_FP_CLASS / **/ /* HAS_FPCLASS: * This symbol, if defined, indicates that the fpclass routine is * available to classify doubles. Available for example in Solaris/SVR4. * The returned values are defined in and are: * * FP_SNAN signaling NaN * FP_QNAN quiet NaN * FP_NINF negative infinity * FP_PINF positive infinity * FP_NDENORM negative denormalized non-zero * FP_PDENORM positive denormalized non-zero * FP_NZERO negative zero * FP_PZERO positive zero * FP_NNORM negative normalized non-zero * FP_PNORM positive normalized non-zero */ /*#define HAS_FPCLASS / **/ /* HAS_FPCLASSIFY: * This symbol, if defined, indicates that the fpclassify routine is * available to classify doubles. Available for example in HP-UX. * The returned values are defined in and are * * FP_NORMAL Normalized * FP_ZERO Zero * FP_INFINITE Infinity * FP_SUBNORMAL Denormalized * FP_NAN NaN * */ /*#define HAS_FPCLASSIFY / **/ /* HAS_FPCLASSL: * This symbol, if defined, indicates that the fpclassl routine is * available to classify long doubles. Available for example in IRIX. * The returned values are defined in and are: * * FP_SNAN signaling NaN * FP_QNAN quiet NaN * FP_NINF negative infinity * FP_PINF positive infinity * FP_NDENORM negative denormalized non-zero * FP_PDENORM positive denormalized non-zero * FP_NZERO negative zero * FP_PZERO positive zero * FP_NNORM negative normalized non-zero * FP_PNORM positive normalized non-zero */ /*#define HAS_FPCLASSL / **/ /* HAS_FPOS64_T: * This symbol will be defined if the C compiler supports fpos64_t. */ /*#define HAS_FPOS64_T / **/ /* HAS_FREXPL: * This symbol, if defined, indicates that the frexpl routine is * available to break a long double floating-point number into * a normalized fraction and an integral power of 2. */ #define HAS_FREXPL /**/ /* HAS_STRUCT_FS_DATA: * This symbol, if defined, indicates that the struct fs_data * to do statfs() is supported. */ /*#define HAS_STRUCT_FS_DATA / **/ /* HAS_FSEEKO: * This symbol, if defined, indicates that the fseeko routine is * available to fseek beyond 32 bits (useful for ILP32 hosts). */ #define HAS_FSEEKO /**/ /* HAS_FSTATFS: * This symbol, if defined, indicates that the fstatfs routine is * available to stat filesystems by file descriptors. */ #define HAS_FSTATFS /**/ /* HAS_FSYNC: * This symbol, if defined, indicates that the fsync routine is * available to write a file's modified data and attributes to * permanent storage. */ #define HAS_FSYNC /**/ /* HAS_FTELLO: * This symbol, if defined, indicates that the ftello routine is * available to ftell beyond 32 bits (useful for ILP32 hosts). */ #define HAS_FTELLO /**/ /* HAS_FUTIMES: * This symbol, if defined, indicates that the futimes routine is * available to change file descriptor time stamps with struct timevals. */ #define HAS_FUTIMES /**/ /* HAS_GETADDRINFO: * This symbol, if defined, indicates that the getaddrinfo() function * is available for use. */ #define HAS_GETADDRINFO /**/ /* HAS_GETCWD: * This symbol, if defined, indicates that the getcwd routine is * available to get the current working directory. */ #define HAS_GETCWD /**/ /* HAS_GETESPWNAM: * This symbol, if defined, indicates that the getespwnam system call is * available to retrieve enhanced (shadow) password entries by name. */ /*#define HAS_GETESPWNAM / **/ /* HAS_GETFSSTAT: * This symbol, if defined, indicates that the getfsstat routine is * available to stat filesystems in bulk. */ /*#define HAS_GETFSSTAT / **/ /* HAS_GETITIMER: * This symbol, if defined, indicates that the getitimer routine is * available to return interval timers. */ #define HAS_GETITIMER /**/ /* HAS_GETMNT: * This symbol, if defined, indicates that the getmnt routine is * available to get filesystem mount info by filename. */ /*#define HAS_GETMNT / **/ /* HAS_GETMNTENT: * This symbol, if defined, indicates that the getmntent routine is * available to iterate through mounted file systems to get their info. */ #define HAS_GETMNTENT /**/ /* HAS_GETNAMEINFO: * This symbol, if defined, indicates that the getnameinfo() function * is available for use. */ #define HAS_GETNAMEINFO /**/ /* HAS_GETPRPWNAM: * This symbol, if defined, indicates that the getprpwnam system call is * available to retrieve protected (shadow) password entries by name. */ /*#define HAS_GETPRPWNAM / **/ /* HAS_GETSPNAM: * This symbol, if defined, indicates that the getspnam system call is * available to retrieve SysV shadow password entries by name. */ #define HAS_GETSPNAM /**/ /* HAS_HASMNTOPT: * This symbol, if defined, indicates that the hasmntopt routine is * available to query the mount options of file systems. */ #define HAS_HASMNTOPT /**/ /* HAS_ILOGBL: * This symbol, if defined, indicates that the ilogbl routine is * available. If scalbnl is also present we can emulate frexpl. */ #define HAS_ILOGBL /**/ /* HAS_INETNTOP: * This symbol, if defined, indicates that the inet_ntop() function * is available to parse IPv4 and IPv6 strings. */ #define HAS_INETNTOP /**/ /* HAS_INETPTON: * This symbol, if defined, indicates that the inet_pton() function * is available to parse IPv4 and IPv6 strings. */ #define HAS_INETPTON /**/ /* HAS_INT64_T: * This symbol will defined if the C compiler supports int64_t. * Usually the needs to be included, but sometimes * is enough. */ #define HAS_INT64_T /**/ /* HAS_ISBLANK: * This manifest constant lets the C program know that isblank * is available. */ #define HAS_ISBLANK /**/ /* HAS_ISFINITE: * This symbol, if defined, indicates that the isfinite routine is * available to check whether a double is finite (non-infinity non-NaN). */ /*#define HAS_ISFINITE / **/ /* HAS_ISINF: * This symbol, if defined, indicates that the isinf routine is * available to check whether a double is an infinity. */ #define HAS_ISINF /**/ /* HAS_ISNAN: * This symbol, if defined, indicates that the isnan routine is * available to check whether a double is a NaN. */ #define HAS_ISNAN /**/ /* HAS_ISNANL: * This symbol, if defined, indicates that the isnanl routine is * available to check whether a long double is a NaN. */ #define HAS_ISNANL /**/ /* HAS_LDBL_DIG: * This symbol, if defined, indicates that this system's * or defines the symbol LDBL_DIG, which is the number * of significant digits in a long double precision number. Unlike * for DBL_DIG, there's no good guess for LDBL_DIG if it is undefined. */ #define HAS_LDBL_DIG /* */ /* LIBM_LIB_VERSION: * This symbol, if defined, indicates that libm exports _LIB_VERSION * and that math.h defines the enum to manipulate it. */ #define LIBM_LIB_VERSION /**/ /* HAS_MADVISE: * This symbol, if defined, indicates that the madvise system call is * available to map a file into memory. */ #define HAS_MADVISE /**/ /* HAS_MALLOC_SIZE: * This symbol, if defined, indicates that the malloc_size * routine is available for use. */ /*#define HAS_MALLOC_SIZE / **/ /* HAS_MALLOC_GOOD_SIZE: * This symbol, if defined, indicates that the malloc_good_size * routine is available for use. */ /*#define HAS_MALLOC_GOOD_SIZE / **/ /* HAS_MKDTEMP: * This symbol, if defined, indicates that the mkdtemp routine is * available to exclusively create a uniquely named temporary directory. */ #define HAS_MKDTEMP /**/ /* HAS_MKSTEMPS: * This symbol, if defined, indicates that the mkstemps routine is * available to exclusively create and open a uniquely named * (with a suffix) temporary file. */ #define HAS_MKSTEMPS /**/ /* HAS_MODFL: * This symbol, if defined, indicates that the modfl routine is * available to split a long double x into a fractional part f and * an integer part i such that |f| < 1.0 and (f + i) = x. */ /* HAS_MODFL_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the modfl() function. Otherwise, it is up * to the program to supply one. */ /* HAS_MODFL_POW32_BUG: * This symbol, if defined, indicates that the modfl routine is * broken for long doubles >= pow(2, 32). * For example from 4294967303.150000 one would get 4294967302.000000 * and 1.150000. The bug has been seen in certain versions of glibc, * release 2.2.2 is known to be okay. */ #define HAS_MODFL /**/ #define HAS_MODFL_PROTO /**/ /*#define HAS_MODFL_POW32_BUG / **/ /* HAS_MPROTECT: * This symbol, if defined, indicates that the mprotect system call is * available to modify the access protection of a memory mapped file. */ #define HAS_MPROTECT /**/ /* HAS_STRUCT_MSGHDR: * This symbol, if defined, indicates that the struct msghdr * is supported. */ #define HAS_STRUCT_MSGHDR /**/ /* HAS_NL_LANGINFO: * This symbol, if defined, indicates that the nl_langinfo routine is * available to return local data. You will also need * and therefore I_LANGINFO. */ #define HAS_NL_LANGINFO /**/ /* HAS_OFF64_T: * This symbol will be defined if the C compiler supports off64_t. */ #define HAS_OFF64_T /**/ /* HAS_PRCTL: * This symbol, if defined, indicates that the prctl routine is * available to set process title. */ /* HAS_PRCTL_SET_NAME: * This symbol, if defined, indicates that the prctl routine is * available to set process title and supports PR_SET_NAME. */ #define HAS_PRCTL /**/ #define HAS_PRCTL_SET_NAME /**/ /* HAS_PROCSELFEXE: * This symbol is defined if PROCSELFEXE_PATH is a symlink * to the absolute pathname of the executing program. */ /* PROCSELFEXE_PATH: * If HAS_PROCSELFEXE is defined this symbol is the filename * of the symbolic link pointing to the absolute pathname of * the executing program. */ #define HAS_PROCSELFEXE /**/ #if defined(HAS_PROCSELFEXE) && !defined(PROCSELFEXE_PATH) #define PROCSELFEXE_PATH "/proc/self/exe" /**/ #endif /* HAS_PTHREAD_ATTR_SETSCOPE: * This symbol, if defined, indicates that the pthread_attr_setscope * system call is available to set the contention scope attribute of * a thread attribute object. */ #define HAS_PTHREAD_ATTR_SETSCOPE /**/ /* HAS_READV: * This symbol, if defined, indicates that the readv routine is * available to do gather reads. You will also need * and there I_SYSUIO. */ #define HAS_READV /**/ /* HAS_RECVMSG: * This symbol, if defined, indicates that the recvmsg routine is * available to send structured socket messages. */ #define HAS_RECVMSG /**/ /* HAS_SBRK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the sbrk() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern void* sbrk(int); * extern void* sbrk(size_t); */ #define HAS_SBRK_PROTO /**/ /* HAS_SCALBNL: * This symbol, if defined, indicates that the scalbnl routine is * available. If ilogbl is also present we can emulate frexpl. */ #define HAS_SCALBNL /**/ /* HAS_SENDMSG: * This symbol, if defined, indicates that the sendmsg routine is * available to send structured socket messages. */ #define HAS_SENDMSG /**/ /* HAS_SETITIMER: * This symbol, if defined, indicates that the setitimer routine is * available to set interval timers. */ #define HAS_SETITIMER /**/ /* HAS_SETPROCTITLE: * This symbol, if defined, indicates that the setproctitle routine is * available to set process title. */ /*#define HAS_SETPROCTITLE / **/ /* USE_SFIO: * This symbol, if defined, indicates that sfio should * be used. */ /*#define USE_SFIO / **/ /* HAS_SIGNBIT: * This symbol, if defined, indicates that the signbit routine is * available to check if the given number has the sign bit set. * This should include correct testing of -0.0. This will only be set * if the signbit() routine is safe to use with the NV type used internally * in perl. Users should call Perl_signbit(), which will be #defined to * the system's signbit() function or macro if this symbol is defined. */ #define HAS_SIGNBIT /**/ /* HAS_SIGPROCMASK: * This symbol, if defined, indicates that the sigprocmask * system call is available to examine or change the signal mask * of the calling process. */ #define HAS_SIGPROCMASK /**/ /* USE_SITECUSTOMIZE: * This symbol, if defined, indicates that sitecustomize should * be used. */ #ifndef USE_SITECUSTOMIZE #define USE_SITECUSTOMIZE /**/ #endif /* HAS_SNPRINTF: * This symbol, if defined, indicates that the snprintf () library * function is available for use. */ /* HAS_VSNPRINTF: * This symbol, if defined, indicates that the vsnprintf () library * function is available for use. */ #define HAS_SNPRINTF /**/ #define HAS_VSNPRINTF /**/ /* HAS_SOCKATMARK: * This symbol, if defined, indicates that the sockatmark routine is * available to test whether a socket is at the out-of-band mark. */ #define HAS_SOCKATMARK /**/ /* HAS_SOCKATMARK_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the sockatmark() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int sockatmark(int); */ #define HAS_SOCKATMARK_PROTO /**/ /* HAS_SOCKS5_INIT: * This symbol, if defined, indicates that the socks5_init routine is * available to initialize SOCKS 5. */ /*#define HAS_SOCKS5_INIT / **/ /* SPRINTF_RETURNS_STRLEN: * This variable defines whether sprintf returns the length of the string * (as per the ANSI spec). Some C libraries retain compatibility with * pre-ANSI C and return a pointer to the passed in buffer; for these * this variable will be undef. */ #define SPRINTF_RETURNS_STRLEN /**/ /* HAS_SQRTL: * This symbol, if defined, indicates that the sqrtl routine is * available to do long double square roots. */ #define HAS_SQRTL /**/ /* HAS_SETRESGID_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the setresgid() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int setresgid(uid_t ruid, uid_t euid, uid_t suid); */ #define HAS_SETRESGID_PROTO /**/ /* HAS_SETRESUID_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the setresuid() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int setresuid(uid_t ruid, uid_t euid, uid_t suid); */ #define HAS_SETRESUID_PROTO /**/ /* HAS_STRUCT_STATFS_F_FLAGS: * This symbol, if defined, indicates that the struct statfs * does have the f_flags member containing the mount flags of * the filesystem containing the file. * This kind of struct statfs is coming from (BSD 4.3), * not from (SYSV). Older BSDs (like Ultrix) do not * have statfs() and struct statfs, they have ustat() and getmnt() * with struct ustat and struct fs_data. */ #define HAS_STRUCT_STATFS_F_FLAGS /**/ /* HAS_STRUCT_STATFS: * This symbol, if defined, indicates that the struct statfs * to do statfs() is supported. */ #define HAS_STRUCT_STATFS /**/ /* HAS_FSTATVFS: * This symbol, if defined, indicates that the fstatvfs routine is * available to stat filesystems by file descriptors. */ #define HAS_FSTATVFS /**/ /* HAS_STRFTIME: * This symbol, if defined, indicates that the strftime routine is * available to do time formatting. */ #define HAS_STRFTIME /**/ /* HAS_STRLCAT: * This symbol, if defined, indicates that the strlcat () routine is * available to do string concatenation. */ /*#define HAS_STRLCAT / **/ /* HAS_STRLCPY: * This symbol, if defined, indicates that the strlcpy () routine is * available to do string copying. */ /*#define HAS_STRLCPY / **/ /* HAS_STRTOLD: * This symbol, if defined, indicates that the strtold routine is * available to convert strings to long doubles. */ #define HAS_STRTOLD /**/ /* HAS_STRTOLL: * This symbol, if defined, indicates that the strtoll routine is * available to convert strings to long longs. */ #define HAS_STRTOLL /**/ /* HAS_STRTOQ: * This symbol, if defined, indicates that the strtoq routine is * available to convert strings to long longs (quads). */ #define HAS_STRTOQ /**/ /* HAS_STRTOULL: * This symbol, if defined, indicates that the strtoull routine is * available to convert strings to unsigned long longs. */ #define HAS_STRTOULL /**/ /* HAS_STRTOUQ: * This symbol, if defined, indicates that the strtouq routine is * available to convert strings to unsigned long longs (quads). */ #define HAS_STRTOUQ /**/ /* HAS_SYSCALL_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the syscall() function. Otherwise, it is up * to the program to supply one. Good guesses are * extern int syscall(int, ...); * extern int syscall(long, ...); */ #define HAS_SYSCALL_PROTO /**/ /* HAS_TELLDIR_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the telldir() function. Otherwise, it is up * to the program to supply one. A good guess is * extern long telldir(DIR*); */ #define HAS_TELLDIR_PROTO /**/ /* HAS_CTIME64: * This symbol, if defined, indicates that the ctime64 () routine is * available to do the 64bit variant of ctime () */ /* HAS_LOCALTIME64: * This symbol, if defined, indicates that the localtime64 () routine is * available to do the 64bit variant of localtime () */ /* HAS_GMTIME64: * This symbol, if defined, indicates that the gmtime64 () routine is * available to do the 64bit variant of gmtime () */ /* HAS_MKTIME64: * This symbol, if defined, indicates that the mktime64 () routine is * available to do the 64bit variant of mktime () */ /* HAS_DIFFTIME64: * This symbol, if defined, indicates that the difftime64 () routine is * available to do the 64bit variant of difftime () */ /* HAS_ASCTIME64: * This symbol, if defined, indicates that the asctime64 () routine is * available to do the 64bit variant of asctime () */ /*#define HAS_CTIME64 / **/ /*#define HAS_LOCALTIME64 / **/ /*#define HAS_GMTIME64 / **/ /*#define HAS_MKTIME64 / **/ /*#define HAS_DIFFTIME64 / **/ /*#define HAS_ASCTIME64 / **/ /* HAS_TIMEGM: * This symbol, if defined, indicates that the timegm routine is * available to do the opposite of gmtime () */ #define HAS_TIMEGM /**/ /* U32_ALIGNMENT_REQUIRED: * This symbol, if defined, indicates that you must access * character data through U32-aligned pointers. */ #ifndef U32_ALIGNMENT_REQUIRED #define U32_ALIGNMENT_REQUIRED /**/ #endif /* HAS_UALARM: * This symbol, if defined, indicates that the ualarm routine is * available to do alarms with microsecond granularity. */ #define HAS_UALARM /**/ /* HAS_UNORDERED: * This symbol, if defined, indicates that the unordered routine is * available to check whether two doubles are unordered * (effectively: whether either of them is NaN) */ /*#define HAS_UNORDERED / **/ /* HAS_UNSETENV: * This symbol, if defined, indicates that the unsetenv () routine is * available for use. */ #define HAS_UNSETENV /**/ /* HAS_USLEEP_PROTO: * This symbol, if defined, indicates that the system provides * a prototype for the usleep() function. Otherwise, it is up * to the program to supply one. A good guess is * extern int usleep(useconds_t); */ #define HAS_USLEEP_PROTO /**/ /* HAS_USTAT: * This symbol, if defined, indicates that the ustat system call is * available to query file system statistics by dev_t. */ #define HAS_USTAT /**/ /* HAS_WRITEV: * This symbol, if defined, indicates that the writev routine is * available to do scatter writes. */ #define HAS_WRITEV /**/ /* USE_DYNAMIC_LOADING: * This symbol, if defined, indicates that dynamic loading of * some sort is available. */ #define USE_DYNAMIC_LOADING /**/ /* FFLUSH_NULL: * This symbol, if defined, tells that fflush(NULL) does flush * all pending stdio output. */ /* FFLUSH_ALL: * This symbol, if defined, tells that to flush * all pending stdio output one must loop through all * the stdio file handles stored in an array and fflush them. * Note that if fflushNULL is defined, fflushall will not * even be probed for and will be left undefined. */ #define FFLUSH_NULL /**/ /*#define FFLUSH_ALL / **/ /* I_ASSERT: * This symbol, if defined, indicates that exists and * could be included by the C program to get the assert() macro. */ #define I_ASSERT /**/ /* I_CRYPT: * This symbol, if defined, indicates that exists and * should be included. */ #define I_CRYPT /**/ /* DB_Prefix_t: * This symbol contains the type of the prefix structure element * in the header file. In older versions of DB, it was * int, while in newer ones it is u_int32_t. */ /* DB_Hash_t: * This symbol contains the type of the prefix structure element * in the header file. In older versions of DB, it was * int, while in newer ones it is size_t. */ /* DB_VERSION_MAJOR_CFG: * This symbol, if defined, defines the major version number of * Berkeley DB found in the header when Perl was configured. */ /* DB_VERSION_MINOR_CFG: * This symbol, if defined, defines the minor version number of * Berkeley DB found in the header when Perl was configured. * For DB version 1 this is always 0. */ /* DB_VERSION_PATCH_CFG: * This symbol, if defined, defines the patch version number of * Berkeley DB found in the header when Perl was configured. * For DB version 1 this is always 0. */ #define DB_Hash_t u_int32_t /**/ #define DB_Prefix_t size_t /**/ #define DB_VERSION_MAJOR_CFG 5 /**/ #define DB_VERSION_MINOR_CFG 3 /**/ #define DB_VERSION_PATCH_CFG 21 /**/ /* I_FP: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_FP / **/ /* I_FP_CLASS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_FP_CLASS / **/ /* I_IEEEFP: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_IEEEFP / **/ /* I_INTTYPES: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_INTTYPES /**/ /* I_LANGINFO: * This symbol, if defined, indicates that exists and * should be included. */ #define I_LANGINFO /**/ /* I_LIBUTIL: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_LIBUTIL / **/ /* I_MALLOCMALLOC: * This symbol, if defined, indicates to the C program that it should * include . */ /*#define I_MALLOCMALLOC / **/ /* I_MNTENT: * This symbol, if defined, indicates that exists and * should be included. */ #define I_MNTENT /**/ /* I_NETINET_TCP: * This symbol, if defined, indicates to the C program that it should * include . */ #define I_NETINET_TCP /**/ /* I_POLL: * This symbol, if defined, indicates that exists and * should be included. (see also HAS_POLL) */ #define I_POLL /**/ /* I_PROT: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_PROT / **/ /* I_SHADOW: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SHADOW /**/ /* I_SOCKS: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SOCKS / **/ /* I_STDBOOL: * This symbol, if defined, indicates that exists and * can be included. */ #define I_STDBOOL /**/ /* I_SUNMATH: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SUNMATH / **/ /* I_SYSLOG: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYSLOG /**/ /* I_SYSMODE: * This symbol, if defined, indicates that exists and * should be included. */ /*#define I_SYSMODE / **/ /* I_SYS_MOUNT: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYS_MOUNT /**/ /* I_SYS_STATFS: * This symbol, if defined, indicates that exists. */ #define I_SYS_STATFS /**/ /* I_SYS_STATVFS: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYS_STATVFS /**/ /* I_SYSUTSNAME: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYSUTSNAME /**/ /* I_SYS_VFS: * This symbol, if defined, indicates that exists and * should be included. */ #define I_SYS_VFS /**/ /* I_USTAT: * This symbol, if defined, indicates that exists and * should be included. */ #define I_USTAT /**/ /* PERL_PRIfldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'f') for output. */ /* PERL_PRIgldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'g') for output. */ /* PERL_PRIeldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'e') for output. */ /* PERL_SCNfldbl: * This symbol, if defined, contains the string used by stdio to * format long doubles (format 'f') for input. */ #define PERL_PRIfldbl "Lf" /**/ #define PERL_PRIgldbl "Lg" /**/ #define PERL_PRIeldbl "Le" /**/ #define PERL_SCNfldbl "Lf" /**/ /* PERL_MAD: * This symbol, if defined, indicates that the Misc Attribution * Declaration code should be conditionally compiled. */ /*#define PERL_MAD / **/ /* NEED_VA_COPY: * This symbol, if defined, indicates that the system stores * the variable argument list datatype, va_list, in a format * that cannot be copied by simple assignment, so that some * other means must be used when copying is required. * As such systems vary in their provision (or non-provision) * of copying mechanisms, handy.h defines a platform- * independent macro, Perl_va_copy(src, dst), to do the job. */ #define NEED_VA_COPY /**/ /* IVTYPE: * This symbol defines the C type used for Perl's IV. */ /* UVTYPE: * This symbol defines the C type used for Perl's UV. */ /* I8TYPE: * This symbol defines the C type used for Perl's I8. */ /* U8TYPE: * This symbol defines the C type used for Perl's U8. */ /* I16TYPE: * This symbol defines the C type used for Perl's I16. */ /* U16TYPE: * This symbol defines the C type used for Perl's U16. */ /* I32TYPE: * This symbol defines the C type used for Perl's I32. */ /* U32TYPE: * This symbol defines the C type used for Perl's U32. */ /* I64TYPE: * This symbol defines the C type used for Perl's I64. */ /* U64TYPE: * This symbol defines the C type used for Perl's U64. */ /* NVTYPE: * This symbol defines the C type used for Perl's NV. */ /* IVSIZE: * This symbol contains the sizeof(IV). */ /* UVSIZE: * This symbol contains the sizeof(UV). */ /* I8SIZE: * This symbol contains the sizeof(I8). */ /* U8SIZE: * This symbol contains the sizeof(U8). */ /* I16SIZE: * This symbol contains the sizeof(I16). */ /* U16SIZE: * This symbol contains the sizeof(U16). */ /* I32SIZE: * This symbol contains the sizeof(I32). */ /* U32SIZE: * This symbol contains the sizeof(U32). */ /* I64SIZE: * This symbol contains the sizeof(I64). */ /* U64SIZE: * This symbol contains the sizeof(U64). */ /* NVSIZE: * This symbol contains the sizeof(NV). */ /* NV_PRESERVES_UV: * This symbol, if defined, indicates that a variable of type NVTYPE * can preserve all the bits of a variable of type UVTYPE. */ /* NV_PRESERVES_UV_BITS: * This symbol contains the number of bits a variable of type NVTYPE * can preserve of a variable of type UVTYPE. */ /* NV_OVERFLOWS_INTEGERS_AT: * This symbol gives the largest integer value that NVs can hold. This * value + 1.0 cannot be stored accurately. It is expressed as constant * floating point expression to reduce the chance of decimal/binary * conversion issues. If it can not be determined, the value 0 is given. */ /* NV_ZERO_IS_ALLBITS_ZERO: * This symbol, if defined, indicates that a variable of type NVTYPE * stores 0.0 in memory as all bits zero. */ #define IVTYPE long /**/ #define UVTYPE unsigned long /**/ #define I8TYPE signed char /**/ #define U8TYPE unsigned char /**/ #define I16TYPE short /**/ #define U16TYPE unsigned short /**/ #define I32TYPE int /**/ #define U32TYPE unsigned int /**/ #ifdef HAS_QUAD #define I64TYPE long /**/ #define U64TYPE unsigned long /**/ #endif #define NVTYPE double /**/ #define IVSIZE 8 /**/ #define UVSIZE 8 /**/ #define I8SIZE 1 /**/ #define U8SIZE 1 /**/ #define I16SIZE 2 /**/ #define U16SIZE 2 /**/ #define I32SIZE 4 /**/ #define U32SIZE 4 /**/ #ifdef HAS_QUAD #define I64SIZE 8 /**/ #define U64SIZE 8 /**/ #endif #define NVSIZE 8 /**/ #undef NV_PRESERVES_UV #define NV_PRESERVES_UV_BITS 53 #define NV_OVERFLOWS_INTEGERS_AT 256.0*256.0*256.0*256.0*256.0*256.0*2.0*2.0*2.0*2.0*2.0 #define NV_ZERO_IS_ALLBITS_ZERO #if UVSIZE == 8 # ifdef BYTEORDER # if BYTEORDER == 0x1234 # undef BYTEORDER # define BYTEORDER 0x12345678 # else # if BYTEORDER == 0x4321 # undef BYTEORDER # define BYTEORDER 0x87654321 # endif # endif # endif #endif /* IVdf: * This symbol defines the format string used for printing a Perl IV * as a signed decimal integer. */ /* UVuf: * This symbol defines the format string used for printing a Perl UV * as an unsigned decimal integer. */ /* UVof: * This symbol defines the format string used for printing a Perl UV * as an unsigned octal integer. */ /* UVxf: * This symbol defines the format string used for printing a Perl UV * as an unsigned hexadecimal integer in lowercase abcdef. */ /* UVXf: * This symbol defines the format string used for printing a Perl UV * as an unsigned hexadecimal integer in uppercase ABCDEF. */ /* NVef: * This symbol defines the format string used for printing a Perl NV * using %e-ish floating point format. */ /* NVff: * This symbol defines the format string used for printing a Perl NV * using %f-ish floating point format. */ /* NVgf: * This symbol defines the format string used for printing a Perl NV * using %g-ish floating point format. */ #define IVdf "ld" /**/ #define UVuf "lu" /**/ #define UVof "lo" /**/ #define UVxf "lx" /**/ #define UVXf "lX" /**/ #define NVef "e" /**/ #define NVff "f" /**/ #define NVgf "g" /**/ /* SELECT_MIN_BITS: * This symbol holds the minimum number of bits operated by select. * That is, if you do select(n, ...), how many bits at least will be * cleared in the masks if some activity is detected. Usually this * is either n or 32*ceil(n/32), especially many little-endians do * the latter. This is only useful if you have select(), naturally. */ #define SELECT_MIN_BITS 64 /**/ /* ST_INO_SIZE: * This variable contains the size of struct stat's st_ino in bytes. */ /* ST_INO_SIGN: * This symbol holds the signedess of struct stat's st_ino. * 1 for unsigned, -1 for signed. */ #define ST_INO_SIGN 1 /* st_ino sign */ #define ST_INO_SIZE 8 /* st_ino size */ /* STARTPERL: * This variable contains the string to put in front of a perl * script to make sure (one hopes) that it runs with perl and not * some shell. */ #define STARTPERL "#!/usr/bin/perl" /**/ /* HAS_STDIO_STREAM_ARRAY: * This symbol, if defined, tells that there is an array * holding the stdio streams. */ /* STDIO_STREAM_ARRAY: * This symbol tells the name of the array holding the stdio streams. * Usual values include _iob, __iob, and __sF. */ /*#define HAS_STDIO_STREAM_ARRAY / **/ #ifdef HAS_STDIO_STREAM_ARRAY #define STDIO_STREAM_ARRAY #endif /* GMTIME_MAX: * This symbol contains the maximum value for the time_t offset that * the system function gmtime () accepts, and defaults to 0 */ /* GMTIME_MIN: * This symbol contains the minimum value for the time_t offset that * the system function gmtime () accepts, and defaults to 0 */ /* LOCALTIME_MAX: * This symbol contains the maximum value for the time_t offset that * the system function localtime () accepts, and defaults to 0 */ /* LOCALTIME_MIN: * This symbol contains the minimum value for the time_t offset that * the system function localtime () accepts, and defaults to 0 */ #define GMTIME_MAX 67768036191676799 /**/ #define GMTIME_MIN -62167219200 /**/ #define LOCALTIME_MAX 67768036191676799 /**/ #define LOCALTIME_MIN -62167219200 /**/ /* USE_64_BIT_INT: * This symbol, if defined, indicates that 64-bit integers should * be used when available. If not defined, the native integers * will be employed (be they 32 or 64 bits). The minimal possible * 64-bitness is used, just enough to get 64-bit integers into Perl. * This may mean using for example "long longs", while your memory * may still be limited to 2 gigabytes. */ /* USE_64_BIT_ALL: * This symbol, if defined, indicates that 64-bit integers should * be used when available. If not defined, the native integers * will be used (be they 32 or 64 bits). The maximal possible * 64-bitness is employed: LP64 or ILP64, meaning that you will * be able to use more than 2 gigabytes of memory. This mode is * even more binary incompatible than USE_64_BIT_INT. You may not * be able to run the resulting executable in a 32-bit CPU at all or * you may need at least to reboot your OS to 64-bit mode. */ #ifndef USE_64_BIT_INT #define USE_64_BIT_INT /**/ #endif #ifndef USE_64_BIT_ALL #define USE_64_BIT_ALL /**/ #endif /* USE_DTRACE: * This symbol, if defined, indicates that Perl should * be built with support for DTrace. */ #define USE_DTRACE /**/ /* USE_FAST_STDIO: * This symbol, if defined, indicates that Perl should * be built to use 'fast stdio'. * Defaults to define in Perls 5.8 and earlier, to undef later. */ #ifndef USE_FAST_STDIO /*#define USE_FAST_STDIO / **/ #endif /* USE_KERN_PROC_PATHNAME: * This symbol, if defined, indicates that we can use sysctl with * KERN_PROC_PATHNAME to get a full path for the executable, and hence * convert $^X to an absolute path. */ /*#define USE_KERN_PROC_PATHNAME / **/ /* USE_LARGE_FILES: * This symbol, if defined, indicates that large file support * should be used when available. */ #ifndef USE_LARGE_FILES #define USE_LARGE_FILES /**/ #endif /* USE_LONG_DOUBLE: * This symbol, if defined, indicates that long doubles should * be used when available. */ #ifndef USE_LONG_DOUBLE /*#define USE_LONG_DOUBLE / **/ #endif /* USE_MORE_BITS: * This symbol, if defined, indicates that 64-bit interfaces and * long doubles should be used when available. */ #ifndef USE_MORE_BITS /*#define USE_MORE_BITS / **/ #endif /* MULTIPLICITY: * This symbol, if defined, indicates that Perl should * be built to use multiplicity. */ #ifndef MULTIPLICITY #define MULTIPLICITY /**/ #endif /* USE_NSGETEXECUTABLEPATH: * This symbol, if defined, indicates that we can use _NSGetExecutablePath * and realpath to get a full path for the executable, and hence convert * $^X to an absolute path. */ /*#define USE_NSGETEXECUTABLEPATH / **/ /* USE_PERLIO: * This symbol, if defined, indicates that the PerlIO abstraction should * be used throughout. If not defined, stdio should be * used in a fully backward compatible manner. */ #ifndef USE_PERLIO #define USE_PERLIO /**/ #endif /* USE_SOCKS: * This symbol, if defined, indicates that Perl should * be built to use socks. */ #ifndef USE_SOCKS /*#define USE_SOCKS / **/ #endif #endif PKZA?[[ mg_data.hnuW+A{ /* sv '\0' Special scalar variable */ want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* arylen '#' Array length ($#ary) */ want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC, 0, /* rhash '%' extra data for restricted hashes */ magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, 0, 0, 0, 0, 0, 0, 0, 0, /* pos '.' pos() lvalue */ want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* symtab ':' extra data for symbol tables */ magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, 0, /* backref '<' for weak ref data */ want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, 0, 0, 0, /* arylen_p '@' to move arylen out of XPVAV */ magic_vtable_max | PERL_MAGIC_VALUE_MAGIC, /* overload 'A' %OVERLOAD hash */ want_vtbl_amagic, /* bm 'B' Boyer-Moore (fast string search) */ want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, 0, /* regdata 'D' Regex match position data (@+ and @- vars) */ want_vtbl_regdata, /* env 'E' %ENV hash */ want_vtbl_env, 0, /* study 'G' study()ed string */ want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC, /* hints 'H' %^H hash */ want_vtbl_hints, /* isa 'I' @ISA array */ want_vtbl_isa, 0, 0, /* dbfile 'L' Debugger %_ --- patchlevel.h *** 38,43 *** --- 38,44 --- ,"FOO1235 - some patch" ,"BAR3141 - another patch" ,"BAZ2718 - and another patch" + ,"MINE001 - my new patch" ,NULL }; please change it to *** patchlevel.h.orig --- patchlevel.h *** 41,43 *** --- 41,44 --- + ,"MINE001 - my new patch" ,NULL }; (Note changes to line numbers as well as removal of context lines.) This will prevent patch from choking if someone has previously applied different patches than you. History has shown that nobody distributes patches that also modify patchlevel.h. Do it yourself. The following perl program can be used to add a comment to patchlevel.h: #!perl die "Usage: perl -x patchlevel.h comment ..." unless @ARGV; open PLIN, "patchlevel.h" or die "Couldn't open patchlevel.h : $!"; open PLOUT, ">patchlevel.new" or die "Couldn't write on patchlevel.new : $!"; my $seen=0; while () { if (/\t,NULL/ and $seen) { while (my $c = shift @ARGV){ $c =~ s|\\|\\\\|g; $c =~ s|"|\\"|g; print PLOUT qq{\t,"$c"\n}; } } $seen++ if /local_patches\[\]/; print PLOUT; } close PLOUT or die "Couldn't close filehandle writing to patchlevel.new : $!"; close PLIN or die "Couldn't close filehandle reading from patchlevel.h : $!"; close DATA; # needed to allow unlink to work win32. unlink "patchlevel.bak" or warn "Couldn't unlink patchlevel.bak : $!" if -e "patchlevel.bak"; rename "patchlevel.h", "patchlevel.bak" or die "Couldn't rename patchlevel.h to patchlevel.bak : $!"; rename "patchlevel.new", "patchlevel.h" or die "Couldn't rename patchlevel.new to patchlevel.h : $!"; __END__ Please keep empty lines below so that context diffs of this file do not ever collect the lines belonging to local_patches() into the same hunk. */ #if !defined(PERL_PATCHLEVEL_H_IMPLICIT) && !defined(LOCAL_PATCH_COUNT) # if defined(PERL_IS_MINIPERL) # define PERL_PATCHNUM "UNKNOWN-miniperl" # define PERL_GIT_UNPUSHED_COMMITS /*leave-this-comment*/ # elif defined(PERL_MICRO) # define PERL_PATCHNUM "UNKNOWN-microperl" # define PERL_GIT_UNPUSHED_COMMITS /*leave-this-comment*/ # else #include "git_version.h" # endif static const char * const local_patches[] = { NULL #ifdef PERL_GIT_UNCOMMITTED_CHANGES ,"uncommitted-changes" #endif PERL_GIT_UNPUSHED_COMMITS /* do not remove this line */ ,"Fedora Patch1: Removes date check, Fedora/RHEL specific" ,"Fedora Patch3: support for libdir64" ,"Fedora Patch4: use libresolv instead of libbind" ,"Fedora Patch5: USE_MM_LD_RUN_PATH" ,"Fedora Patch6: Skip hostname tests, due to builders not being network capable" ,"Fedora Patch7: Dont run one io test due to random builder failures" ,"Fedora Patch9: Fix find2perl to translate ? glob properly (RT#113054)" ,"Fedora Patch10: Fix broken atof (RT#109318)" ,"Fedora Patch13: Clear $@ before \"do\" I/O error (RT#113730)" ,"Fedora Patch14: Do not truncate syscall() return value to 32 bits (RT#113980)" ,"Fedora Patch15: Override the Pod::Simple::parse_file (CPANRT#77530)" ,"Fedora Patch16: Do not leak with attribute on my variable (RT#114764)" ,"Fedora Patch17: Allow operator after numeric keyword argument (RT#105924)" ,"Fedora Patch18: Extend stack in File::Glob::glob, (RT#114984)" ,"Fedora Patch19: Do not crash when vivifying $|" ,"Fedora Patch20: Fix misparsing of maketext strings (CVE-2012-6329)" ,"Fedora Patch21: Add NAME headings to CPAN modules (CPANRT#73396)" ,"Fedora Patch22: Fix leaking tied hashes (RT#107000) [1]" ,"Fedora Patch23: Fix leaking tied hashes (RT#107000) [2]" ,"Fedora Patch24: Fix leaking tied hashes (RT#107000) [3]" ,"Fedora Patch25: Fix dead lock in PerlIO after fork from thread (RT#106212)" ,"Fedora Patch26: Make regexp safe in a signal handler (RT#114878)" ,"Fedora Patch27: Update h2ph(1) documentation (RT#117647)" ,"Fedora Patch28: Update pod2html(1) documentation (RT#117623)" ,"Fedora Patch29: Document Math::BigInt::CalcEmu requires Math::BigInt (CPAN RT#85015)" ,"RHEL Patch30: Use stronger algorithm needed for FIPS in t/op/crypt.t (RT#121591)" ,"RHEL Patch31: Make *DBM_File desctructors thread-safe (RT#61912)" ,"RHEL Patch32: Use stronger algorithm needed for FIPS in t/op/taint.t (RT#123338)" ,"RHEL Patch33: Remove CPU-speed-sensitive test in Benchmark test" ,"RHEL Patch34: Make File::Glob work with threads again" ,"RHEL Patch35: Fix CRLF conversion in ASCII FTP upload (CPAN RT#41642)" ,"RHEL Patch36: Do not leak the temp utf8 copy of namepv (CPAN RT#123786)" ,"RHEL Patch37: Fix duplicating PerlIO::encoding when spawning threads (RT#31923)" ,"RHEL Patch38: Add SSL support to Net::SMTP (CPAN RT#93823) [1]" ,"RHEL Patch39: Add SSL support to Net::SMTP (CPAN RT#93823) [2]" ,"RHEL Patch40: Add SSL support to Net::SMTP (CPAN RT#93823) [3]" ,"RHEL Patch41: Add SSL support to Net::SMTP (CPAN RT#93823) [4]" ,"RHEL Patch42: Do not overload \"..\" in Math::BigInt (CPAN RT#80182)" ,"RHEL Patch43: Fix CVE-2018-18311 Integer overflow leading to buffer overflow" ,"RHEL Patch44: Fix a spurious timeout in Net::FTP::close (CPAN RT#18504)" ,"RHEL Patch45: Fix day of year parsing (CPAN RT#88211)" ,"RHEL Patch47: Fix CVE-2020-12723 (GH#16947)" ,"RHEL Patch48: Fix CVE-2020-10543" ,"RHEL Patch49: Fix CVE-2020-10878" ,NULL }; /* Initial space prevents this variable from being inserted in config.sh */ # define LOCAL_PATCH_COUNT \ ((int)(sizeof(local_patches)/sizeof(local_patches[0])-2)) /* the old terms of reference, add them only when explicitly included */ #define PATCHLEVEL PERL_VERSION #undef SUBVERSION /* OS/390 has a SUBVERSION in a system header */ #define SUBVERSION PERL_SUBVERSION #endif PKZ} 2((gv.hnuW+A/* gv.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ struct gp { SV * gp_sv; /* scalar value */ struct io * gp_io; /* filehandle value */ CV * gp_cv; /* subroutine value */ U32 gp_cvgen; /* generational validity of cached gv_cv */ U32 gp_refcnt; /* how many globs point to this? */ HV * gp_hv; /* hash value */ AV * gp_av; /* array value */ CV * gp_form; /* format value */ GV * gp_egv; /* effective gv, if *glob */ line_t gp_line; /* line first declared at (for -w) */ HEK * gp_file_hek; /* file first declared in (for -w) */ }; #define GvXPVGV(gv) ((XPVGV*)SvANY(gv)) #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__INTEL_COMPILER) # define GvGP(gv) \ (0+(*({GV *const _gvgp = (GV *) (gv); \ assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \ assert(isGV_with_GP(_gvgp)); \ &((_gvgp)->sv_u.svu_gp);}))) # define GvGP_set(gv,gp) \ {GV *const _gvgp = (GV *) (gv); \ assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \ assert(isGV_with_GP(_gvgp)); \ (_gvgp)->sv_u.svu_gp = (gp); } # define GvFLAGS(gv) \ (*({GV *const _gvflags = (GV *) (gv); \ assert(SvTYPE(_gvflags) == SVt_PVGV || SvTYPE(_gvflags) == SVt_PVLV); \ assert(isGV_with_GP(_gvflags)); \ &(GvXPVGV(_gvflags)->xpv_cur);})) # define GvSTASH(gv) \ (*({ GV * const _gvstash = (GV *) (gv); \ assert(isGV_with_GP(_gvstash)); \ assert(SvTYPE(_gvstash) == SVt_PVGV || SvTYPE(_gvstash) >= SVt_PVLV); \ &(GvXPVGV(_gvstash)->xnv_u.xgv_stash); \ })) # define GvNAME_HEK(gv) \ (*({ GV * const _gvname_hek = (GV *) (gv); \ assert(isGV_with_GP(_gvname_hek)); \ assert(SvTYPE(_gvname_hek) == SVt_PVGV || SvTYPE(_gvname_hek) >= SVt_PVLV); \ assert(!SvVALID(_gvname_hek)); \ &(GvXPVGV(_gvname_hek)->xiv_u.xivu_namehek); \ })) # define GvNAME_get(gv) ({ assert(GvNAME_HEK(gv)); (char *)HEK_KEY(GvNAME_HEK(gv)); }) # define GvNAMELEN_get(gv) ({ assert(GvNAME_HEK(gv)); HEK_LEN(GvNAME_HEK(gv)); }) # define GvNAMEUTF8(gv) ({ assert(GvNAME_HEK(gv)); HEK_UTF8(GvNAME_HEK(gv)); }) #else # define GvGP(gv) (0+(gv)->sv_u.svu_gp) # define GvGP_set(gv,gp) ((gv)->sv_u.svu_gp = (gp)) # define GvFLAGS(gv) (GvXPVGV(gv)->xpv_cur) # define GvSTASH(gv) (GvXPVGV(gv)->xnv_u.xgv_stash) # define GvNAME_HEK(gv) (GvXPVGV(gv)->xiv_u.xivu_namehek) # define GvNAME_get(gv) HEK_KEY(GvNAME_HEK(gv)) # define GvNAMELEN_get(gv) HEK_LEN(GvNAME_HEK(gv)) # define GvNAMEUTF8(gv) HEK_UTF8(GvNAME_HEK(gv)) #endif #define GvNAME(gv) GvNAME_get(gv) #define GvNAMELEN(gv) GvNAMELEN_get(gv) #define GvASSIGN_GENERATION(gv) (0 + ((XPV*) SvANY(gv))->xpv_len) #define GvASSIGN_GENERATION_set(gv,val) \ STMT_START { assert(SvTYPE(gv) == SVt_PVGV); \ (((XPV*) SvANY(gv))->xpv_len = (val)); } STMT_END /* =head1 GV Functions =for apidoc Am|SV*|GvSV|GV* gv Return the SV from the GV. =cut */ #define GvSV(gv) (GvGP(gv)->gp_sv) #ifdef PERL_DONT_CREATE_GVSV #define GvSVn(gv) (*(GvGP(gv)->gp_sv ? \ &(GvGP(gv)->gp_sv) : \ &(GvGP(gv_SVadd(gv))->gp_sv))) #else #define GvSVn(gv) GvSV(gv) #endif #define GvREFCNT(gv) (GvGP(gv)->gp_refcnt) #define GvIO(gv) \ ( \ (gv) \ && ( \ SvTYPE((const SV*)(gv)) == SVt_PVGV \ || SvTYPE((const SV*)(gv)) == SVt_PVLV \ ) \ && GvGP(gv) \ ? GvIOp(gv) \ : NULL \ ) #define GvIOp(gv) (GvGP(gv)->gp_io) #define GvIOn(gv) (GvIO(gv) ? GvIOp(gv) : GvIOp(gv_IOadd(gv))) #define GvFORM(gv) (GvGP(gv)->gp_form) #define GvAV(gv) (GvGP(gv)->gp_av) #define GvAVn(gv) (GvGP(gv)->gp_av ? \ GvGP(gv)->gp_av : \ GvGP(gv_AVadd(gv))->gp_av) #define GvHV(gv) ((GvGP(gv))->gp_hv) #define GvHVn(gv) (GvGP(gv)->gp_hv ? \ GvGP(gv)->gp_hv : \ GvGP(gv_HVadd(gv))->gp_hv) #define GvCV(gv) (0+GvGP(gv)->gp_cv) #define GvCV_set(gv,cv) (GvGP(gv)->gp_cv = (cv)) #define GvCVGEN(gv) (GvGP(gv)->gp_cvgen) #define GvCVu(gv) (GvGP(gv)->gp_cvgen ? NULL : GvGP(gv)->gp_cv) #define GvLINE(gv) (GvGP(gv)->gp_line) #define GvFILE_HEK(gv) (GvGP(gv)->gp_file_hek) #define GvFILE(gv) (GvFILE_HEK(gv) ? HEK_KEY(GvFILE_HEK(gv)) : NULL) #define GvFILEGV(gv) (gv_fetchfile(GvFILE(gv))) #define GvEGV(gv) (GvGP(gv)->gp_egv) #define GvEGVx(gv) (isGV_with_GP(gv) ? GvEGV(gv) : NULL) #define GvENAME(gv) GvNAME(GvEGV(gv) ? GvEGV(gv) : gv) #define GvENAMELEN(gv) GvNAMELEN(GvEGV(gv) ? GvEGV(gv) : gv) #define GvENAMEUTF8(gv) GvNAMEUTF8(GvEGV(gv) ? GvEGV(gv) : gv) #define GvENAME_HEK(gv) GvNAME_HEK(GvEGV(gv) ? GvEGV(gv) : gv) #define GvESTASH(gv) GvSTASH(GvEGV(gv) ? GvEGV(gv) : gv) #define GVf_INTRO 0x01 #define GVf_MULTI 0x02 #define GVf_ASSUMECV 0x04 #define GVf_IN_PAD 0x08 #define GVf_IMPORTED 0xF0 #define GVf_IMPORTED_SV 0x10 #define GVf_IMPORTED_AV 0x20 #define GVf_IMPORTED_HV 0x40 #define GVf_IMPORTED_CV 0x80 #define GvINTRO(gv) (GvFLAGS(gv) & GVf_INTRO) #define GvINTRO_on(gv) (GvFLAGS(gv) |= GVf_INTRO) #define GvINTRO_off(gv) (GvFLAGS(gv) &= ~GVf_INTRO) #define GvMULTI(gv) (GvFLAGS(gv) & GVf_MULTI) #define GvMULTI_on(gv) (GvFLAGS(gv) |= GVf_MULTI) #define GvMULTI_off(gv) (GvFLAGS(gv) &= ~GVf_MULTI) #define GvASSUMECV(gv) (GvFLAGS(gv) & GVf_ASSUMECV) #define GvASSUMECV_on(gv) (GvFLAGS(gv) |= GVf_ASSUMECV) #define GvASSUMECV_off(gv) (GvFLAGS(gv) &= ~GVf_ASSUMECV) #define GvIMPORTED(gv) (GvFLAGS(gv) & GVf_IMPORTED) #define GvIMPORTED_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED) #define GvIMPORTED_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED) #define GvIMPORTED_SV(gv) (GvFLAGS(gv) & GVf_IMPORTED_SV) #define GvIMPORTED_SV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_SV) #define GvIMPORTED_SV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_SV) #define GvIMPORTED_AV(gv) (GvFLAGS(gv) & GVf_IMPORTED_AV) #define GvIMPORTED_AV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_AV) #define GvIMPORTED_AV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_AV) #define GvIMPORTED_HV(gv) (GvFLAGS(gv) & GVf_IMPORTED_HV) #define GvIMPORTED_HV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_HV) #define GvIMPORTED_HV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_HV) #define GvIMPORTED_CV(gv) (GvFLAGS(gv) & GVf_IMPORTED_CV) #define GvIMPORTED_CV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_CV) #define GvIMPORTED_CV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_CV) #define GvIN_PAD(gv) (GvFLAGS(gv) & GVf_IN_PAD) #define GvIN_PAD_on(gv) (GvFLAGS(gv) |= GVf_IN_PAD) #define GvIN_PAD_off(gv) (GvFLAGS(gv) &= ~GVf_IN_PAD) #ifndef PERL_CORE # define Nullgv Null(GV*) #endif #define DM_RUID 0x001 #define DM_EUID 0x002 #define DM_UID (DM_RUID|DM_EUID) #define DM_ARRAY_ISA 0x004 #define DM_RGID 0x010 #define DM_EGID 0x020 #define DM_GID (DM_RGID|DM_EGID) #define DM_DELAY 0x100 /* * symbol creation flags, for use in gv_fetchpv() and get_*v() */ #define GV_ADD 0x01 /* add, if symbol not already there For gv_name_set, adding a HEK for the first time, so don't try to free what's there. */ #define GV_ADDMULTI 0x02 /* add, pretending it has been added already; used also by gv_init_* */ #define GV_ADDWARN 0x04 /* add, but warn if symbol wasn't already there */ #define GV_ADDINEVAL 0x08 /* add, as though we're doing so within an eval */ #define GV_NOINIT 0x10 /* add, but don't init symbol, if type != PVGV */ /* This is used by toke.c to avoid turing placeholder constants in the symbol table into full PVGVs with attached constant subroutines. */ #define GV_NOADD_NOINIT 0x20 /* Don't add the symbol if it's not there. Don't init it if it is there but ! PVGV */ #define GV_NOEXPAND 0x40 /* Don't expand SvOK() entries to PVGV */ #define GV_NOTQUAL 0x80 /* A plain symbol name, not qualified with a package (so skip checks for :: and ') */ #define GV_AUTOLOAD 0x100 /* gv_fetchmethod_flags() should AUTOLOAD */ #define GV_CROAK 0x200 /* gv_fetchmethod_flags() should croak */ #define GV_ADDMG 0x400 /* add if magical */ #define GV_NO_SVGMAGIC 0x800 /* Skip get-magic on an SV argument; used only by gv_fetchsv(_nomg) */ /* Flags for gv_autoload_*/ #define GV_AUTOLOAD_ISMETHOD 1 /* autoloading a method? */ /* SVf_UTF8 (more accurately the return value from SvUTF8) is also valid as a flag to various gv_* functions, so ensure it lies outside this range. */ #define GV_NOADD_MASK \ (SVf_UTF8|GV_NOADD_NOINIT|GV_NOEXPAND|GV_NOTQUAL|GV_ADDMG|GV_NO_SVGMAGIC) /* The bit flags that don't cause gv_fetchpv() to add a symbol if not found (with the exception GV_ADDMG, which *might* cause the symbol to be added) */ #define gv_fullname3(sv,gv,prefix) gv_fullname4(sv,gv,prefix,TRUE) #define gv_efullname3(sv,gv,prefix) gv_efullname4(sv,gv,prefix,TRUE) #define gv_fetchmethod(stash, name) gv_fetchmethod_autoload(stash, name, TRUE) #define gv_fetchsv_nomg(n,f,t) gv_fetchsv(n,(f)|GV_NO_SVGMAGIC,t) #define gv_init(gv,stash,name,len,multi) \ gv_init_pvn(gv,stash,name,len,GV_ADDMULTI*!!(multi)) #define gv_fetchmeth(stash,name,len,level) gv_fetchmeth_pvn(stash, name, len, level, 0) #define gv_fetchmeth_autoload(stash,name,len,level) gv_fetchmeth_pvn_autoload(stash, name, len, level, 0) #define gv_fetchmethod_flags(stash,name,flags) gv_fetchmethod_pv_flags(stash, name, flags) #define gv_autoload4(stash, name, len, method) \ gv_autoload_pvn(stash, name, len, !!(method)) #define newGVgen(pack) newGVgen_flags(pack, 0) #define gv_AVadd(gv) gv_add_by_type((gv), SVt_PVAV) #define gv_HVadd(gv) gv_add_by_type((gv), SVt_PVHV) #define gv_IOadd(gv) gv_add_by_type((gv), SVt_PVIO) #define gv_SVadd(gv) gv_add_by_type((gv), SVt_NULL) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ9INTERN.hnuW+A/* INTERN.h * * Copyright (C) 1991, 1992, 1993, 1995, 1996, 1998, 2000, 2001, * by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * EXT designates a global var which is defined in perl.h * dEXT designates a global var which is defined in another * file, so we can't count on finding it in perl.h * (this practice should be avoided). */ #undef EXT #undef dEXT #undef EXTCONST #undef dEXTCONST #if defined(VMS) && !defined(__GNUC__) /* Suppress portability warnings from DECC for VMS-specific extensions */ # ifdef __DECC # pragma message disable (GLOBALEXT,NOSHAREEXT,READONLYEXT) # endif # define EXT globaldef {"$GLOBAL_RW_VARS"} noshare # define dEXT globaldef {"$GLOBAL_RW_VARS"} noshare # define EXTCONST globaldef {"$GLOBAL_RO_VARS"} readonly # define dEXTCONST globaldef {"$GLOBAL_RO_VARS"} readonly #else # if (defined(WIN32) && defined(__MINGW32__)) || defined(__SYMBIAN32__) # define EXT __declspec(dllexport) # define dEXT # define EXTCONST __declspec(dllexport) const # define dEXTCONST const # else # ifdef __cplusplus # define EXT # define dEXT # define EXTCONST extern const # define dEXTCONST const # else # define EXT # define dEXT # define EXTCONST const # define dEXTCONST const # endif # endif #endif #undef INIT #define INIT(x) = x #define DOINIT PKZ," ؁؁ regcomp.hnuW+A/* regcomp.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, * 2000, 2001, 2002, 2003, 2005, 2006, 2007, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #include "regcharclass.h" typedef OP OP_4tree; /* Will be redefined later. */ /* Convert branch sequences to more efficient trie ops? */ #define PERL_ENABLE_TRIE_OPTIMISATION 1 /* Be really aggressive about optimising patterns with trie sequences? */ #define PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION 1 /* Should the optimiser take positive assertions into account? */ #define PERL_ENABLE_POSITIVE_ASSERTION_STUDY 0 /* Not for production use: */ #define PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS 0 /* Activate offsets code - set to if 1 to enable */ #ifdef DEBUGGING #define RE_TRACK_PATTERN_OFFSETS #endif /* Unless the next line is uncommented it is illegal to combine lazy matching with possessive matching. Frankly it doesn't make much sense to allow it as X*?+ matches nothing, X+?+ matches a single char only, and X{min,max}?+ matches min times only. */ /* #define REG_ALLOW_MINMOD_SUSPEND */ /* * The "internal use only" fields in regexp.h are present to pass info from * compile to execute that permits the execute phase to run lots faster on * simple cases. They are: * * regstart sv that must begin a match; NULL if none obvious * reganch is the match anchored (at beginning-of-line only)? * regmust string (pointer into program) that match must include, or NULL * [regmust changed to SV* for bminstr()--law] * regmlen length of regmust string * [regmlen not used currently] * * Regstart and reganch permit very fast decisions on suitable starting points * for a match, cutting down the work a lot. Regmust permits fast rejection * of lines that cannot possibly match. The regmust tests are costly enough * that pregcomp() supplies a regmust only if the r.e. contains something * potentially expensive (at present, the only such thing detected is * or + * at the start of the r.e., which can involve a lot of backup). Regmlen is * supplied because the test in pregexec() needs it and pregcomp() is computing * it anyway. * [regmust is now supplied always. The tests that use regmust have a * heuristic that disables the test if it usually matches.] * * [In fact, we now use regmust in many cases to locate where the search * starts in the string, so if regback is >= 0, the regmust search is never * wasted effort. The regback variable says how many characters back from * where regmust matched is the earliest possible start of the match. * For instance, /[a-z].foo/ has a regmust of 'foo' and a regback of 2.] */ /* * Structure for regexp "program". This is essentially a linear encoding * of a nondeterministic finite-state machine (aka syntax charts or * "railroad normal form" in parsing technology). Each node is an opcode * plus a "next" pointer, possibly plus an operand. "Next" pointers of * all nodes except BRANCH implement concatenation; a "next" pointer with * a BRANCH on both ends of it is connecting two alternatives. (Here we * have one of the subtle syntax dependencies: an individual BRANCH (as * opposed to a collection of them) is never concatenated with anything * because of operator precedence.) The operand of some types of node is * a literal string; for others, it is a node leading into a sub-FSM. In * particular, the operand of a BRANCH node is the first node of the branch. * (NB this is *not* a tree structure: the tail of the branch connects * to the thing following the set of BRANCHes.) The opcodes are defined * in regnodes.h which is generated from regcomp.sym by regcomp.pl. */ /* * A node is one char of opcode followed by two chars of "next" pointer. * "Next" pointers are stored as two 8-bit pieces, high order first. The * value is a positive offset from the opcode of the node containing it. * An operand, if any, simply follows the node. (Note that much of the * code generation knows about this implicit relationship.) * * Using two bytes for the "next" pointer is vast overkill for most things, * but allows patterns to get big without disasters. * * [The "next" pointer is always aligned on an even * boundary, and reads the offset directly as a short. Also, there is no * special test to reverse the sign of BACK pointers since the offset is * stored negative.] */ /* This is the stuff that used to live in regexp.h that was truly private to the engine itself. It now lives here. */ typedef struct regexp_internal { int name_list_idx; /* Optional data index of an array of paren names */ union { U32 *offsets; /* offset annotations 20001228 MJD data about mapping the program to the string - offsets[0] is proglen when this is used */ U32 proglen; } u; regnode *regstclass; /* Optional startclass as identified or constructed by the optimiser */ struct reg_data *data; /* Additional miscellaneous data used by the program. Used to make it easier to clone and free arbitrary data that the regops need. Often the ARG field of a regop is an index into this structure */ regnode program[1]; /* Unwarranted chumminess with compiler. */ } regexp_internal; #define RXi_SET(x,y) (x)->pprivate = (void*)(y) #define RXi_GET(x) ((regexp_internal *)((x)->pprivate)) #define RXi_GET_DECL(r,ri) regexp_internal *ri = RXi_GET(r) /* * Flags stored in regexp->intflags * These are used only internally to the regexp engine * * See regexp.h for flags used externally to the regexp engine */ #define PREGf_SKIP 0x00000001 #define PREGf_IMPLICIT 0x00000002 /* Converted .* to ^.* */ #define PREGf_NAUGHTY 0x00000004 /* how exponential is this pattern? */ #define PREGf_VERBARG_SEEN 0x00000008 #define PREGf_CUTGROUP_SEEN 0x00000010 /* this is where the old regcomp.h started */ struct regnode_string { U8 str_len; U8 type; U16 next_off; char string[1]; }; /* Argument bearing node - workhorse, arg1 is often for the data field */ struct regnode_1 { U8 flags; U8 type; U16 next_off; U32 arg1; }; /* Similar to a regnode_1 but with an extra signed argument */ struct regnode_2L { U8 flags; U8 type; U16 next_off; U32 arg1; I32 arg2; }; /* 'Two field' -- Two 16 bit unsigned args */ struct regnode_2 { U8 flags; U8 type; U16 next_off; U16 arg1; U16 arg2; }; #define ANYOF_BITMAP_SIZE 32 /* 256 b/(8 b/B) */ #define ANYOF_CLASSBITMAP_SIZE 4 /* up to 32 (8*4) named classes */ /* also used by trie */ struct regnode_charclass { U8 flags; U8 type; U16 next_off; U32 arg1; /* used as ptr in S_regclass */ char bitmap[ANYOF_BITMAP_SIZE]; /* only compile-time */ }; /* has runtime (locale) \d, \w, ..., [:posix:] classes */ struct regnode_charclass_class { U8 flags; /* ANYOF_CLASS bit must go here */ U8 type; U16 next_off; U32 arg1; /* used as ptr in S_regclass */ char bitmap[ANYOF_BITMAP_SIZE]; /* both compile-time */ char classflags[ANYOF_CLASSBITMAP_SIZE]; /* and run-time */ }; /* XXX fix this description. Impose a limit of REG_INFTY on various pattern matching operations to limit stack growth and to avoid "infinite" recursions. */ /* The default size for REG_INFTY is I16_MAX, which is the same as SHORT_MAX (see perl.h). Unfortunately I16 isn't necessarily 16 bits (see handy.h). On the Cray C90, sizeof(short)==4 and hence I16_MAX is ((1<<31)-1), while on the Cray T90, sizeof(short)==8 and I16_MAX is ((1<<63)-1). To limit stack growth to reasonable sizes, supply a smaller default. --Andy Dougherty 11 June 1998 */ #if SHORTSIZE > 2 # ifndef REG_INFTY # define REG_INFTY ((1<<15)-1) # endif #endif #ifndef REG_INFTY # define REG_INFTY I16_MAX #endif #define ARG_VALUE(arg) (arg) #define ARG__SET(arg,val) ((arg) = (val)) #undef ARG #undef ARG1 #undef ARG2 #define ARG(p) ARG_VALUE(ARG_LOC(p)) #define ARG1(p) ARG_VALUE(ARG1_LOC(p)) #define ARG2(p) ARG_VALUE(ARG2_LOC(p)) #define ARG2L(p) ARG_VALUE(ARG2L_LOC(p)) #define ARG_SET(p, val) ARG__SET(ARG_LOC(p), (val)) #define ARG1_SET(p, val) ARG__SET(ARG1_LOC(p), (val)) #define ARG2_SET(p, val) ARG__SET(ARG2_LOC(p), (val)) #define ARG2L_SET(p, val) ARG__SET(ARG2L_LOC(p), (val)) #undef NEXT_OFF #undef NODE_ALIGN #define NEXT_OFF(p) ((p)->next_off) #define NODE_ALIGN(node) #define NODE_ALIGN_FILL(node) ((node)->flags = 0xde) /* deadbeef */ #define SIZE_ALIGN NODE_ALIGN #undef OP #undef OPERAND #undef MASK #undef STRING #define OP(p) ((p)->type) #define FLAGS(p) ((p)->flags) /* Caution: Doesn't apply to all \ regnode types. For some, it's the \ character set of the regnode */ #define OPERAND(p) (((struct regnode_string *)p)->string) #define MASK(p) ((char*)OPERAND(p)) #define STR_LEN(p) (((struct regnode_string *)p)->str_len) #define STRING(p) (((struct regnode_string *)p)->string) #define STR_SZ(l) ((l + sizeof(regnode) - 1) / sizeof(regnode)) #define NODE_SZ_STR(p) (STR_SZ(STR_LEN(p))+1) #undef NODE_ALIGN #undef ARG_LOC #undef NEXTOPER #undef PREVOPER #define NODE_ALIGN(node) #define ARG_LOC(p) (((struct regnode_1 *)p)->arg1) #define ARG1_LOC(p) (((struct regnode_2 *)p)->arg1) #define ARG2_LOC(p) (((struct regnode_2 *)p)->arg2) #define ARG2L_LOC(p) (((struct regnode_2L *)p)->arg2) #define NODE_STEP_REGNODE 1 /* sizeof(regnode)/sizeof(regnode) */ #define EXTRA_STEP_2ARGS EXTRA_SIZE(struct regnode_2) #define NODE_STEP_B 4 #define NEXTOPER(p) ((p) + NODE_STEP_REGNODE) #define PREVOPER(p) ((p) - NODE_STEP_REGNODE) #define FILL_ADVANCE_NODE(ptr, op) STMT_START { \ (ptr)->type = op; (ptr)->next_off = 0; (ptr)++; } STMT_END #define FILL_ADVANCE_NODE_ARG(ptr, op, arg) STMT_START { \ ARG_SET(ptr, arg); FILL_ADVANCE_NODE(ptr, op); (ptr) += 1; } STMT_END #define REG_MAGIC 0234 #define SIZE_ONLY (RExC_emit == &PL_regdummy) /* If the bitmap doesn't fully represent what this ANYOF node can match, the * ARG is set to this special value (since 0, 1, ... are legal, but will never * reach this high). */ #define ANYOF_NONBITMAP_EMPTY ((U32) -1) /* The information used to be stored as as combination of the ANYOF_UTF8 and * ANYOF_NONBITMAP_NON_UTF8 bits in the flags field, but was moved out of there * to free up a bit for other uses. This tries to hide the change from * existing code as much as possible. Now, the data structure that goes in ARG * is not allocated unless it is needed, and that is what is used to determine * if there is something outside the bitmap. The code now assumes that if * that structure exists, that any UTF-8 encoded string should be tried against * it, but a non-UTF8-encoded string will be tried only if the * ANYOF_NONBITMAP_NON_UTF8 bit is also set. */ #define ANYOF_NONBITMAP(node) (ARG(node) != ANYOF_NONBITMAP_EMPTY) /* Flags for node->flags of ANYOF. These are in short supply, so some games * are done to share them, as described below. If necessary, the ANYOF_LOCALE * and ANYOF_CLASS bits could be shared with a space penalty for locale nodes, * but this isn't quite so easy, as the optimizer also uses ANYOF_CLASS. * Another option would be to push them into new nodes. E.g. there could be an * ANYOF_LOCALE node that would be in place of the flag of the same name. * Once the planned change to compile all the above-latin1 code points is done, * then the UNICODE_ALL bit can be freed up, with a small performance penalty. * If flags need to be added that are applicable to the synthetic start class * only, with some work, they could be put in the next-node field, or in an * unused bit of the classflags field. */ #define ANYOF_LOCALE 0x01 /* /l modifier */ /* The fold is calculated and stored in the bitmap where possible at compile * time. However there are two cases where it isn't possible. These share * this bit: 1) under locale, where the actual folding varies depending on * what the locale is at the time of execution; and 2) where the folding is * specified in a swash, not the bitmap, such as characters which aren't * specified in the bitmap, or properties that aren't looked at at compile time */ #define ANYOF_LOC_NONBITMAP_FOLD 0x02 #define ANYOF_INVERT 0x04 /* Set if this is a struct regnode_charclass_class vs a regnode_charclass. This * is used for runtime \d, \w, [:posix:], ..., which are used only in locale * and the optimizer's synthetic start class. Non-locale \d, etc are resolved * at compile-time */ #define ANYOF_CLASS 0x08 #define ANYOF_LARGE ANYOF_CLASS /* Same; name retained for back compat */ /* EOS, meaning that it can match an empty string too, is used for the * synthetic start class only. */ #define ANYOF_EOS 0x10 /* ? Is this node the synthetic start class (ssc). This bit is shared with * ANYOF_EOS, as the latter is used only for the ssc, and then not used by * regexec.c. And, the code is structured so that if it is set, the ssc is * not used, so it is guaranteed to be 0 for the ssc by the time regexec.c * gets executed, and 0 for a non-ssc ANYOF node, as it only ever gets set for * a potential ssc candidate. Thus setting it to 1 after it has been * determined that the ssc will be used is not ambiguous */ #define ANYOF_IS_SYNTHETIC ANYOF_EOS /* Can match something outside the bitmap that isn't in utf8 */ #define ANYOF_NONBITMAP_NON_UTF8 0x20 /* Matches every code point 0x100 and above*/ #define ANYOF_UNICODE_ALL 0x40 /* Match all Latin1 characters that aren't ASCII when the target string is not * in utf8. */ #define ANYOF_NON_UTF8_LATIN1_ALL 0x80 #define ANYOF_FLAGS_ALL 0xff /* These are the flags that ANYOF_INVERT being set or not doesn't affect * whether they are operative or not. e.g., the node still has LOCALE * regardless of being inverted; whereas ANYOF_UNICODE_ALL means something * different if inverted */ #define INVERSION_UNAFFECTED_FLAGS (ANYOF_LOCALE \ |ANYOF_LOC_NONBITMAP_FOLD \ |ANYOF_CLASS \ |ANYOF_EOS \ |ANYOF_NONBITMAP_NON_UTF8) /* Character classes for node->classflags of ANYOF */ /* Should be synchronized with a table in regprop() */ /* 2n should pair with 2n+1 */ #define ANYOF_ALNUM 0 /* \w, PL_utf8_alnum, utf8::IsWord, ALNUM */ #define ANYOF_NALNUM 1 #define ANYOF_SPACE 2 /* \s */ #define ANYOF_NSPACE 3 #define ANYOF_DIGIT 4 /* \d */ #define ANYOF_NDIGIT 5 #define ANYOF_ALNUMC 6 /* [[:alnum:]] isalnum(3), utf8::IsAlnum, ALNUMC */ #define ANYOF_NALNUMC 7 #define ANYOF_ALPHA 8 #define ANYOF_NALPHA 9 #define ANYOF_ASCII 10 #define ANYOF_NASCII 11 #define ANYOF_CNTRL 12 #define ANYOF_NCNTRL 13 #define ANYOF_GRAPH 14 #define ANYOF_NGRAPH 15 #define ANYOF_LOWER 16 #define ANYOF_NLOWER 17 #define ANYOF_PRINT 18 #define ANYOF_NPRINT 19 #define ANYOF_PUNCT 20 #define ANYOF_NPUNCT 21 #define ANYOF_UPPER 22 #define ANYOF_NUPPER 23 #define ANYOF_XDIGIT 24 #define ANYOF_NXDIGIT 25 #define ANYOF_PSXSPC 26 /* POSIX space: \s plus the vertical tab */ #define ANYOF_NPSXSPC 27 #define ANYOF_BLANK 28 /* GNU extension: space and tab: non-vertical space */ #define ANYOF_NBLANK 29 #define ANYOF_MAX 32 /* pseudo classes, not stored in the class bitmap, but used as flags during compilation of char classes */ #define ANYOF_VERTWS (ANYOF_MAX+1) #define ANYOF_NVERTWS (ANYOF_MAX+2) #define ANYOF_HORIZWS (ANYOF_MAX+3) #define ANYOF_NHORIZWS (ANYOF_MAX+4) /* Backward source code compatibility. */ #define ANYOF_ALNUML ANYOF_ALNUM #define ANYOF_NALNUML ANYOF_NALNUM #define ANYOF_SPACEL ANYOF_SPACE #define ANYOF_NSPACEL ANYOF_NSPACE /* Utility macros for the bitmap and classes of ANYOF */ #define ANYOF_SIZE (sizeof(struct regnode_charclass)) #define ANYOF_CLASS_SIZE (sizeof(struct regnode_charclass_class)) #define ANYOF_FLAGS(p) ((p)->flags) #define ANYOF_BIT(c) (1 << ((c) & 7)) #define ANYOF_CLASS_BYTE(p, c) (((struct regnode_charclass_class*)(p))->classflags[((c) >> 3) & 3]) #define ANYOF_CLASS_SET(p, c) (ANYOF_CLASS_BYTE(p, c) |= ANYOF_BIT(c)) #define ANYOF_CLASS_CLEAR(p, c) (ANYOF_CLASS_BYTE(p, c) &= ~ANYOF_BIT(c)) #define ANYOF_CLASS_TEST(p, c) (ANYOF_CLASS_BYTE(p, c) & ANYOF_BIT(c)) #define ANYOF_CLASS_ZERO(ret) Zero(((struct regnode_charclass_class*)(ret))->classflags, ANYOF_CLASSBITMAP_SIZE, char) #define ANYOF_CLASS_SETALL(ret) \ memset (((struct regnode_charclass_class*)(ret))->classflags, 255, ANYOF_CLASSBITMAP_SIZE) #define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char) #define ANYOF_BITMAP(p) (((struct regnode_charclass*)(p))->bitmap) #define ANYOF_BITMAP_BYTE(p, c) (ANYOF_BITMAP(p)[(((U8)(c)) >> 3) & 31]) #define ANYOF_BITMAP_SET(p, c) (ANYOF_BITMAP_BYTE(p, c) |= ANYOF_BIT(c)) #define ANYOF_BITMAP_CLEAR(p,c) (ANYOF_BITMAP_BYTE(p, c) &= ~ANYOF_BIT(c)) #define ANYOF_BITMAP_TEST(p, c) (ANYOF_BITMAP_BYTE(p, c) & ANYOF_BIT(c)) #define ANYOF_BITMAP_SETALL(p) \ memset (ANYOF_BITMAP(p), 255, ANYOF_BITMAP_SIZE) #define ANYOF_BITMAP_CLEARALL(p) \ Zero (ANYOF_BITMAP(p), ANYOF_BITMAP_SIZE) /* Check that all 256 bits are all set. Used in S_cl_is_anything() */ #define ANYOF_BITMAP_TESTALLSET(p) /* Assumes sizeof(p) == 32 */ \ memEQ (ANYOF_BITMAP(p), "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", ANYOF_BITMAP_SIZE) #define ANYOF_SKIP ((ANYOF_SIZE - 1)/sizeof(regnode)) #define ANYOF_CLASS_SKIP ((ANYOF_CLASS_SIZE - 1)/sizeof(regnode)) #if ANYOF_CLASSBITMAP_SIZE != 4 # error ANYOF_CLASSBITMAP_SIZE is expected to be 4 #endif #define ANYOF_CLASS_TEST_ANY_SET(p) ((ANYOF_FLAGS(p) & ANYOF_CLASS) \ && memNE (((struct regnode_charclass_class*)(p))->classflags, \ "\0\0\0\0", ANYOF_CLASSBITMAP_SIZE)) /*#define ANYOF_CLASS_ADD_SKIP (ANYOF_CLASS_SKIP - ANYOF_SKIP) * */ /* * Utility definitions. */ #ifndef CHARMASK # define UCHARAT(p) ((int)*(const U8*)(p)) #else # define UCHARAT(p) ((int)*(p)&CHARMASK) #endif #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode)) #define REG_SEEN_ZERO_LEN 0x00000001 #define REG_SEEN_LOOKBEHIND 0x00000002 #define REG_SEEN_GPOS 0x00000004 #define REG_SEEN_EVAL 0x00000008 #define REG_SEEN_CANY 0x00000010 #define REG_SEEN_SANY REG_SEEN_CANY /* src bckwrd cmpt */ #define REG_SEEN_RECURSE 0x00000020 #define REG_TOP_LEVEL_BRANCHES 0x00000040 #define REG_SEEN_VERBARG 0x00000080 #define REG_SEEN_CUTGROUP 0x00000100 #define REG_SEEN_RUN_ON_COMMENT 0x00000200 #define REG_SEEN_EXACTF_SHARP_S 0x00000400 START_EXTERN_C #ifdef PLUGGABLE_RE_EXTENSION #include "re_nodes.h" #else #include "regnodes.h" #endif #ifndef PLUGGABLE_RE_EXTENSION #ifndef DOINIT EXTCONST regexp_engine PL_core_reg_engine; #else /* DOINIT */ EXTCONST regexp_engine PL_core_reg_engine = { Perl_re_compile, Perl_regexec_flags, Perl_re_intuit_start, Perl_re_intuit_string, Perl_regfree_internal, Perl_reg_numbered_buff_fetch, Perl_reg_numbered_buff_store, Perl_reg_numbered_buff_length, Perl_reg_named_buff, Perl_reg_named_buff_iter, Perl_reg_qr_package, #if defined(USE_ITHREADS) Perl_regdupe_internal #endif }; #endif /* DOINIT */ #endif /* PLUGGABLE_RE_EXTENSION */ END_EXTERN_C /* .what is a character array with one character for each member of .data * The character describes the function of the corresponding .data item: * a - AV for paren_name_list under DEBUGGING * f - start-class data for regstclass optimization * n - Root of op tree for (?{EVAL}) item * o - Start op for (?{EVAL}) item * p - Pad for (?{EVAL}) item * s - swash for Unicode-style character class, and the multicharacter * strings resulting from casefolding the single-character entries * in the character class * t - trie struct * u - trie struct's widecharmap (a HV, so can't share, must dup) * also used for revcharmap and words under DEBUGGING * T - aho-trie struct * S - sv for named capture lookup * 20010712 mjd@plover.com * (Remember to update re_dup() and pregfree() if you add any items.) */ struct reg_data { U32 count; U8 *what; void* data[1]; }; /* Code in S_to_utf8_substr() and S_to_byte_substr() in regexec.c accesses anchored* and float* via array indexes 0 and 1. */ #define anchored_substr substrs->data[0].substr #define anchored_utf8 substrs->data[0].utf8_substr #define anchored_offset substrs->data[0].min_offset #define anchored_end_shift substrs->data[0].end_shift #define float_substr substrs->data[1].substr #define float_utf8 substrs->data[1].utf8_substr #define float_min_offset substrs->data[1].min_offset #define float_max_offset substrs->data[1].max_offset #define float_end_shift substrs->data[1].end_shift #define check_substr substrs->data[2].substr #define check_utf8 substrs->data[2].utf8_substr #define check_offset_min substrs->data[2].min_offset #define check_offset_max substrs->data[2].max_offset #define check_end_shift substrs->data[2].end_shift #define RX_ANCHORED_SUBSTR(rx) (((struct regexp *)SvANY(rx))->anchored_substr) #define RX_ANCHORED_UTF8(rx) (((struct regexp *)SvANY(rx))->anchored_utf8) #define RX_FLOAT_SUBSTR(rx) (((struct regexp *)SvANY(rx))->float_substr) #define RX_FLOAT_UTF8(rx) (((struct regexp *)SvANY(rx))->float_utf8) /* trie related stuff */ /* a transition record for the state machine. the check field determines which state "owns" the transition. the char the transition is for is determined by offset from the owning states base field. the next field determines which state is to be transitioned to if any. */ struct _reg_trie_trans { U32 next; U32 check; }; /* a transition list element for the list based representation */ struct _reg_trie_trans_list_elem { U16 forid; U32 newstate; }; typedef struct _reg_trie_trans_list_elem reg_trie_trans_le; /* a state for compressed nodes. base is an offset into an array of reg_trie_trans array. If wordnum is nonzero the state is accepting. if base is zero then the state has no children (and will be accepting) */ struct _reg_trie_state { U16 wordnum; union { U32 base; reg_trie_trans_le* list; } trans; }; /* info per word; indexed by wordnum */ typedef struct { U16 prev; /* previous word in acceptance chain; eg in * zzz|abc|ab/ after matching the chars abc, the * accepted word is #2, and the previous accepted * word is #3 */ U32 len; /* how many chars long is this word? */ U32 accept; /* accept state for this word */ } reg_trie_wordinfo; typedef struct _reg_trie_state reg_trie_state; typedef struct _reg_trie_trans reg_trie_trans; /* anything in here that needs to be freed later should be dealt with in pregfree. refcount is first in both this and _reg_ac_data to allow a space optimisation in Perl_regdupe. */ struct _reg_trie_data { U32 refcount; /* number of times this trie is referenced */ U32 lasttrans; /* last valid transition element */ U16 *charmap; /* byte to charid lookup array */ reg_trie_state *states; /* state data */ reg_trie_trans *trans; /* array of transition elements */ char *bitmap; /* stclass bitmap */ U16 *jump; /* optional 1 indexed array of offsets before tail for the node following a given word. */ reg_trie_wordinfo *wordinfo; /* array of info per word */ U16 uniquecharcount; /* unique chars in trie (width of trans table) */ U32 startstate; /* initial state - used for common prefix optimisation */ STRLEN minlen; /* minimum length of words in trie - build/opt only? */ STRLEN maxlen; /* maximum length of words in trie - build/opt only? */ U32 prefixlen; /* #chars in common prefix */ U32 statecount; /* Build only - number of states in the states array (including the unused zero state) */ U32 wordcount; /* Build only */ #ifdef DEBUGGING STRLEN charcount; /* Build only */ #endif }; /* There is one (3 under DEBUGGING) pointers that logically belong in this structure, but are held outside as they need duplication on thread cloning, whereas the rest of the structure can be read only: HV *widecharmap; code points > 255 to charid #ifdef DEBUGGING AV *words; Array of words contained in trie, for dumping AV *revcharmap; Map of each charid back to its character representation #endif */ #define TRIE_WORDS_OFFSET 2 typedef struct _reg_trie_data reg_trie_data; /* refcount is first in both this and _reg_trie_data to allow a space optimisation in Perl_regdupe. */ struct _reg_ac_data { U32 refcount; U32 trie; U32 *fail; reg_trie_state *states; }; typedef struct _reg_ac_data reg_ac_data; /* ANY_BIT doesn't use the structure, so we can borrow it here. This is simpler than refactoring all of it as wed end up with three different sets... */ #define TRIE_BITMAP(p) (((reg_trie_data *)(p))->bitmap) #define TRIE_BITMAP_BYTE(p, c) (TRIE_BITMAP(p)[(((U8)(c)) >> 3) & 31]) #define TRIE_BITMAP_SET(p, c) (TRIE_BITMAP_BYTE(p, c) |= ANYOF_BIT((U8)c)) #define TRIE_BITMAP_CLEAR(p,c) (TRIE_BITMAP_BYTE(p, c) &= ~ANYOF_BIT((U8)c)) #define TRIE_BITMAP_TEST(p, c) (TRIE_BITMAP_BYTE(p, c) & ANYOF_BIT((U8)c)) #define IS_ANYOF_TRIE(op) ((op)==TRIEC || (op)==AHOCORASICKC) #define IS_TRIE_AC(op) ((op)>=AHOCORASICK) #define BITMAP_BYTE(p, c) (((U8*)p)[(((U8)(c)) >> 3) & 31]) #define BITMAP_TEST(p, c) (BITMAP_BYTE(p, c) & ANYOF_BIT((U8)c)) /* these defines assume uniquecharcount is the correct variable, and state may be evaluated twice */ #define TRIE_NODENUM(state) (((state)-1)/(trie->uniquecharcount)+1) #define SAFE_TRIE_NODENUM(state) ((state) ? (((state)-1)/(trie->uniquecharcount)+1) : (state)) #define TRIE_NODEIDX(state) ((state) ? (((state)-1)*(trie->uniquecharcount)+1) : (state)) #ifdef DEBUGGING #define TRIE_CHARCOUNT(trie) ((trie)->charcount) #else #define TRIE_CHARCOUNT(trie) (trie_charcount) #endif #define RE_TRIE_MAXBUF_INIT 65536 #define RE_TRIE_MAXBUF_NAME "\022E_TRIE_MAXBUF" #define RE_DEBUG_FLAGS "\022E_DEBUG_FLAGS" /* RE_DEBUG_FLAGS is used to control what debug output is emitted its divided into three groups of options, some of which interact. The three groups are: Compile, Execute, Extra. There is room for a further group, as currently only the low three bytes are used. Compile Options: PARSE PEEP TRIE PROGRAM OFFSETS Execute Options: INTUIT MATCH TRIE Extra Options TRIE OFFSETS If you modify any of these make sure you make corresponding changes to re.pm, especially to the documentation. */ /* Compile */ #define RE_DEBUG_COMPILE_MASK 0x0000FF #define RE_DEBUG_COMPILE_PARSE 0x000001 #define RE_DEBUG_COMPILE_OPTIMISE 0x000002 #define RE_DEBUG_COMPILE_TRIE 0x000004 #define RE_DEBUG_COMPILE_DUMP 0x000008 #define RE_DEBUG_COMPILE_FLAGS 0x000010 /* Execute */ #define RE_DEBUG_EXECUTE_MASK 0x00FF00 #define RE_DEBUG_EXECUTE_INTUIT 0x000100 #define RE_DEBUG_EXECUTE_MATCH 0x000200 #define RE_DEBUG_EXECUTE_TRIE 0x000400 /* Extra */ #define RE_DEBUG_EXTRA_MASK 0xFF0000 #define RE_DEBUG_EXTRA_TRIE 0x010000 #define RE_DEBUG_EXTRA_OFFSETS 0x020000 #define RE_DEBUG_EXTRA_OFFDEBUG 0x040000 #define RE_DEBUG_EXTRA_STATE 0x080000 #define RE_DEBUG_EXTRA_OPTIMISE 0x100000 #define RE_DEBUG_EXTRA_BUFFERS 0x400000 #define RE_DEBUG_EXTRA_GPOS 0x800000 /* combined */ #define RE_DEBUG_EXTRA_STACK 0x280000 #define RE_DEBUG_FLAG(x) (re_debug_flags & x) /* Compile */ #define DEBUG_COMPILE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_MASK) x ) #define DEBUG_PARSE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x ) #define DEBUG_OPTIMISE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_OPTIMISE) x ) #define DEBUG_PARSE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_PARSE) x ) #define DEBUG_DUMP_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_DUMP) x ) #define DEBUG_TRIE_COMPILE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_TRIE) x ) #define DEBUG_FLAGS_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_COMPILE_FLAGS) x ) /* Execute */ #define DEBUG_EXECUTE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXECUTE_MASK) x ) #define DEBUG_INTUIT_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXECUTE_INTUIT) x ) #define DEBUG_MATCH_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXECUTE_MATCH) x ) #define DEBUG_TRIE_EXECUTE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXECUTE_TRIE) x ) /* Extra */ #define DEBUG_EXTRA_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_MASK) x ) #define DEBUG_OFFSETS_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_OFFSETS) x ) #define DEBUG_STATE_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_STATE) x ) #define DEBUG_STACK_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_STACK) x ) #define DEBUG_BUFFERS_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_BUFFERS) x ) #define DEBUG_OPTIMISE_MORE_r(x) DEBUG_r( \ if ((RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE) == \ (re_debug_flags & (RE_DEBUG_EXTRA_OPTIMISE|RE_DEBUG_COMPILE_OPTIMISE)) ) x ) #define MJD_OFFSET_DEBUG(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_OFFDEBUG) \ Perl_warn_nocontext x ) #define DEBUG_TRIE_COMPILE_MORE_r(x) DEBUG_TRIE_COMPILE_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x ) #define DEBUG_TRIE_EXECUTE_MORE_r(x) DEBUG_TRIE_EXECUTE_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_TRIE) x ) #define DEBUG_TRIE_r(x) DEBUG_r( \ if (re_debug_flags & (RE_DEBUG_COMPILE_TRIE \ | RE_DEBUG_EXECUTE_TRIE )) x ) #define DEBUG_GPOS_r(x) DEBUG_r( \ if (re_debug_flags & RE_DEBUG_EXTRA_GPOS) x ) /* initialization */ /* get_sv() can return NULL during global destruction. re_debug_flags can get * clobbered by a longjmp, so must be initialized */ #define GET_RE_DEBUG_FLAGS DEBUG_r({ \ SV * re_debug_flags_sv = NULL; \ re_debug_flags = 0; \ re_debug_flags_sv = get_sv(RE_DEBUG_FLAGS, 1); \ if (re_debug_flags_sv) { \ if (!SvIOK(re_debug_flags_sv)) \ sv_setuv(re_debug_flags_sv, RE_DEBUG_COMPILE_DUMP | RE_DEBUG_EXECUTE_MASK ); \ re_debug_flags=SvIV(re_debug_flags_sv); \ }\ }) #ifdef DEBUGGING #define GET_RE_DEBUG_FLAGS_DECL VOL IV re_debug_flags \ PERL_UNUSED_DECL = 0; GET_RE_DEBUG_FLAGS; #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) \ const char * const rpv = \ pv_pretty((dsv), (pv), (l), (m), \ PL_colors[(c1)],PL_colors[(c2)], \ PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) ); \ const int rlen = SvCUR(dsv) #define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m) \ const char * const rpv = \ pv_pretty((dsv), (SvPV_nolen_const(sv)), (SvCUR(sv)), (m), \ PL_colors[(c1)],PL_colors[(c2)], \ PERL_PV_ESCAPE_RE|PERL_PV_ESCAPE_NONASCII |((isuni) ? PERL_PV_ESCAPE_UNI : 0) ) #define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m) \ const char * const rpv = \ pv_pretty((dsv), (pv), (l), (m), \ PL_colors[0], PL_colors[1], \ ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_ESCAPE_NONASCII | PERL_PV_PRETTY_ELLIPSES | \ ((isuni) ? PERL_PV_ESCAPE_UNI : 0)) \ ) #define RE_SV_DUMPLEN(ItEm) (SvCUR(ItEm) - (SvTAIL(ItEm)!=0)) #define RE_SV_TAIL(ItEm) (SvTAIL(ItEm) ? "$" : "") #else /* if not DEBUGGING */ #define GET_RE_DEBUG_FLAGS_DECL #define RE_PV_COLOR_DECL(rpv,rlen,isuni,dsv,pv,l,m,c1,c2) #define RE_SV_ESCAPE(rpv,isuni,dsv,sv,m) #define RE_PV_QUOTED_DECL(rpv,isuni,dsv,pv,l,m) #define RE_SV_DUMPLEN(ItEm) #define RE_SV_TAIL(ItEm) #endif /* DEBUG RELATED DEFINES */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ`G"" libperl.sonuW+AELF>"@@8@l,l, 44848 hh8h800$$PtdIII::QtdRtd44848`;`;GNUswC!278V ]hd BR3" @@P  B AD P P " r H(@r ")" @ hp%@6 %A%"H 2N @@ "cA'H0`4@(#P%,!"a0 T0 A "0#!@<@ F9! aLa"PEd4 $D ( !P "B! b  + @ D(P TC F bBA@A C0@P ! B $( cBB|"D4`! H   F@Q & 4G@(@DP"@@L@N@ D(@Pc"`0H"(0 D *@ R#DHCP B @DA$A(!%H @P  20 X IL$f  $@HHBi*tHH0@X# RE"8i@ 8B8RT2X#TX$A $@*( 9`U8  8( 0 $d 0$@E P$@BLP( A `$P@@\   B$ @ CB$"`(R"a `1H0:B08 P HAL* FD"!`I @0`AP 0P0 *P@A CR@`T@HA 4C 1 q()R0F"  `!"!0GN2 mHd( рL fDe_B"!8 hKDL2#8@ " $T \ pS0R2  B A D#@QB*()1* 1 BB #H#5(@` @I1P  `0 Q @0 3 38 AJ JP  U8e  DHB@ tTIPPJH @@#Y B0y  d @mQ%(8 @3$@1HH $ BAQNx@ vB@<*7$%X B@ 0@ @@r  P0  9 )A,H 8@(e@  @@a( "H0,00Pe!B c(N0 @P  "#%)*-./1258;=ACDGHJKMOPTUXZ[^_acefghikmoqsvyz{~   #'+-2358:<=>@ACDFINQRUW[]^_adhilopstvz{}  !#&*+-/136789;=>?@ABEIKPRUVXZ[\^abcegjklmpqsvx|~     "#()*+-.2489:<=@DFIJLORTWZ]_`fhjmqrsuwz{~   !#&*./025679;>@BCHIJLMQTVXY[\]`dgkmoswx|~    "%'*+-.13678:;>BCDEFHJKLMPRV\]abfhjkmpqsvwz{}  "#'+-0167:<@ACGILPQRSTY\]_aefgjqstvwz{}~PWdawQ῀!e ;3Դ$-Y<%i\P<= % e̜&?P j[a.nkت̒i*}zT-@!Qۦo7xg/N$ڰT0Z< mh."ӪvTb8 ͤ>}׉\+(F#_QI e΀^lHӀBh#j_wቌk7Q̩ga-;:?q7)ݼ~k/n6{7D!45}]Exuұ%\#_ga'DnG Ja+cQnRcXWyנ+^GK.I C-D1PF-P-sEיִ@E飼 'P^.4>k o\bmY -E%%y(d9Főn3QnYSP!Vn udr@^Mvm~EIhaY^1NK7ĝ^xkXHL8]]%^écn5<QRtTYB5A xZ,Gkv2Nh@YԌ(? KBV'$GV-eNnqb̷c~|D BE= \nY$rG-9|Zg(9'T}> ĢVYŰҥ`Io#_ tfJA1F g]$*#Q8|g!VC}IYN٩ItYz+(Pn"BHOΎhLYn}f$go*82 "(Q~:ptQ(&d!| k2_3'+kc=(,Иv"xY_ sMHO&ߋ5Wtr]dlsZY /¢UZ 1S*;>#oD.dSRďA]HWjj>r^n? A(G 0m&.4w?yw.lE\<=|LJ?yL3^O;zҖE%k<.ϥZ%'l Y94Aj $2kJ \\ld/$:Ϗ.?&fxC&(_^r62?bha* bY^o[0T8}[IsWRXq 6ALY DI}MxhvQpaz` <7?ƞ:*=')驪q!~7.:zWF iA8O}mA< bt{Ύ)5Bv"Ia][̔AbWY66 Ѳn;v8qyD* 7ɏAb;QnLIYe6NJ_J;w`P$hasYn=H7QyS#NO٪bi *7lIiY4 sךּ0I@YO;ER~WrCTZRYP]2{{Kzx&A-n+bFԛCN, 6|5H_j;=7)d 3]2IvtvkX~ӞǪ=8\˟GBOG5LI1 =PFKJ30OKV&ga 6i" (`2޻JSl_˹=62_b'gz ZTꖷ^ {*J8ha7n*͗q| Y?zl}܊x ~em:=.`E>mDxTG_{v@r3ّ;b)v,U_xjm1((kJK}qXl*>BD qYUƄZ Z55\!1W*=cKRM̉N41=+\SwK- *3xtq–>2|6ELV FPֶ(ԛ])I6y9hKȍ@0)d_3c:\ڛOlXFEoD QHd(Vȇղ1q>'V 4!4;} ,Շ.>&zFp#3Cop1V **.f@SRx{oݙu\AǬ@Rr9e什R+ΗLXx7z&bGUI'xdӻ=s@?x);ܜ7+B|Buu<=,JOyX7inj-Mtpݙmc [jPB+CAAHD)>Jg/:N(9A|S2F ՋRGׅ OWCɒ5Z6ǑJ;4j&CGs>.=߅ O.D)$Vh4+oXa ONW#O;hzߨ9f9l WYn'R=s|P'`@<oHj` yhg;R![I \=j0L'a=ga\.okДpҗyhd<1HRlKsYDBҫ{uo8Lhtha,I>E^&>nvLGF(hB4أ@IA)/lls.XJ{6hdn2a33wsFsғOnf6o*iv"^ɿkjڅr[FGeF=d9ܾ1_fO̧a"hS<_6}2jE]iq_Z⿚0q'q(wu ˖iGyj81_=Nd RCT]W~E d]xU $_r7  W,gP\P'M^t͋k}_HHipy+m`"L]?H3N$'~pYyvpc ֌[@f$dEyzuir pUsx':o $Csf4 Vlc%]X;@ŋ[ ի;$C~Y\hajR;ch6QUY rv{L=;>o !σ- h`Fn gV-l2Tw'-ֿh12LQL_0<\Ύ{ VZǐk+UmwbHT?R 'ԚufKd,SIl} ddÒ6"yf}òh0>8X~et6Wq/@dĝ$ ?}`tmY=2}а̥|p(ĉkhi} L\5'65ndek}~HvTI"hY_0IFUQ6c1-'exH޿Ù)iF~gQ uB.V$P5 _|W=D_=NYLCNkjrʙ)aaL (rHHlY̌yk=kIr`ڂ"aдWZRXl7D?4ӥQÔu QgTTB}Z'ұM֌QA˽('ɍ͗ U$jV描}98[͗l0L {/JHoY#ˑ L'94w{uN3EHYk/n',3Akz="~7 J6)4[-_DXs)F_3 e}Z(?\u0k"]s3坚k6W}LDv-6۳WMk ]A<;dǶI F)X,C}_ztGeZ kSM&WUI٘LTA'ҩ㐛*R.0&xZzcfh_FۆKik :F۞ɢƿRH=V \g\~e 5\Gq.D;6E> "UyBD׆6zY>0;#ɮsIӄsKQܪ^;o(c`Uz7G\ !\ݛV)-:!ZUeCZu7cd;"z"ou{@X_@-dEx`8*̜%l5:-;뢐A13֋5 7-7eb* 7Zj*J`o_>VHns5罜ژmKޟc s,[9zcwJUV\#w}LV10>Q%\]'lpcLG!o4mOC`c$`_ܗ")XZd,HIp̒$ŊdL\;95]4Ld.[{{p*wnKC(+^Rw}_1>/?SƜ\ML|?߫ʟ.BDN2]@^> s9vH< dKS;15̒eCZy}`l0Gt;".Mں9ԸbI?&~^q!j*Xk!6^Z$ c =1/?UT BE~Zù"$%UT *!avD70l@"f}M)c}j{B,Pp*P=XGLqTZ8MGg&~CmsF*dgb":Uv3K'BJAk4=<\;Ygu= Qu"ed'|Cm1ga"%]d3R]b,$/ *lJ rrx2>ӌ_4Ͻk;{̛Y)+shP5S3՛ޱ,}_Ͻ\p ۼK|SખR!JIS #>;vFx`F 'y<;R4{Z8'l #SZM/~Z`- vp[M/S9)zIv+&'%Wx2]U|$K:nJpOK_dVZuGkr:u%TGv7B`AW>AIL@rY#Q㊪0f6jPG:f?btvѧsy|K_ZRpN.'B`Y97m{q(P[bOn:De(+ˣXT3D<0ޯ!zJkhaH\݌svo72ik.  d(Tud%cty#7D 4qq6³03鄾ת"iY pH 'IٲPBBMKl#{TFSZx㜒H:_~,)ha" OdVC?A?.--   t46i Zy3oj)CW}X.FؤP|1&)x]9SnQX**:paEi>EX⍸hu2d˼PĪaT,(*3[my$@+8"&Ů0!e) UXלbPn "Y #@NJA1՜BDՌGHs^:]6^4_\  ]r[[v?k Z?4lt)Zh_^z[R>D]DSQGZur^GZ>>[Z_?<DG?4#Y^[GzM@6\F.R?|&,NY_?T6Y{Pl]J\=4eN'^%\P2^al#!!|!s4Z7H_$27z_]W7^ _4l *Xs"|s- 6x^|=]\K{%?6812]2|l_zY^\Y-6dP_[YGl>G7{=Y[=028m"^Y-_6._Yhs<6&HP\_Z_>^;_?[ [I^<4Z]SZrP6__N__Y^\,E6?\n] |.[9|\Y/l_ ?2 vP)?>_V{P ,]d^LL"9q#|]=6\V\{Q!a,Y=w `b p  8 d L Pi u!f M -980N 4y @L{`O "V 0<y  R 4 & 3J% P|z {JX `O P k  5r T7s pn!t td?j  3 v *`8(% @U & y  $ 1 _Z ? 7F - U Q  S 0X@8(oj @ +wE IU PBX 46   k_I 0 SK  2m F(: 0  B M @ lL W x _ /  ;z 0Q m `& Q  @lx  Q@ @ & 07  h<  }8 @  @O;   0a6F t p S @`" V vz! V @hX =,8C @,wD 02 a /`?8[+80P  2  Yi \ `m n  +H\ r `" wn+8P#  `25 p n pK8  X A P L0 RU P\!R `]QO  C W Gz `Y @K>D 2mv  [/B87 P J ! ]V u8K Vh* N rR pa v( , 6R : P N +8@ p Lc7 P e! P~L  S Z8l 5> PG f1 paN_L @"h p` u ^ rl  5 x Н X _vN   - > O> K = K  12u Г:  #RA jM @ 4z  m KjP ,Dd 0a `v4 IE xZ5 .+ 8v  xL X TjN г ` ?s cZCS e+H !_ Pc PM*|*86O  1 P[| `|)H R )!m d 0f8 0 3T ] 0CC2 b x_[ @!b &L j ! tJ *:84 ) oj 00C w Йb c PMZ Tr MG P T  jl   = V pc: O OI5 'o p*$ =M  e Y 0P yl Dn@82B % V  `(-  $N 0 ~) @ 5hR 0y E 0%$, k   ?ji$ ,$M oE @"b ~  *l Jr^ P&f <X  F   N  C& . Q( @X G  Iq @gE E 0 ka P7E p$ p]L PmFI n B U  p@f] P9") @Z-Q .\ pu 4 ` X |Z JB  2K  1z$  + 8P[Q `C [ @>Z$] Ѝ%A $ >~j @*i B V JWw - 8v  g G @O+j z_ 'Z% ` K AN 0 fjw 0P w.b Z P 4 eK ` 98 c & < I J J !" a l8 0 L P/;9Q `m puB : EE I @ {5 r pX:! 0DWN Y  @YR , @!.#G v X S {@ p0 8}6 y 8u  o1@G8V ]t  $ 0{A  )3 x w `EwX 90@891G8 N v  Gq B(P: !kQ @ `lC d   "5 /@t vH Xq# ,7 SD` P K@ `[3 q Y5q BT Pid8 ux A{Y %I sv' H @ 2L g a p8c 03S p_x @ n@8L3 s vG !` PB @ , QF @s2 k C8< Pdx 0*L i H |Oi  `?  ; #S ]C p 6 t  k ` vR 2& ~` Щ  #   U c2* tU$ ,&w# &W Z^ U pMek  U ;f pm p lF  P*f8` @_j/A8PI 0.D l ;]  F+ 80\-   p=}C  B   pacY ,e c BF ` B IMC V , (   +M @ qD #]4 ;  +jI @ Sn8= @5  @V4 4a1F83 Wd PM` мo2 " @(]W `d, P] 2>k  6  O oy m= ! tU ?#V ivI D ^ B $ "Y 4R Ѝ= 6 >SП8}( _d PM83 r \2 id :f /D p  c  Q>\ \;  :  PbT h8T @%&< @ f" 'C Pl cZ PM 7i idk p&  , ~[ gauih8 >*8P,8E)  1F8d{  -Dw ) P!b 3y P2 l C: y m @   0?a  -  B' ЭH*  u p* 8X `}2 a x  0s blZ /yS zE  >  0|w   Qc' `F p d /U @g 0/`C8x@ B 8o P+te Psxy  bg p 3 ' r  % = @7 5RF  o  [9) ^ p:Kc PMP }5 @ P 0J>.  l   @ f 0+{q FaC @IY3 v 6 S }A ?5 o *@ @ 5LX A mz ТfS !s pp  3 Sk 6 B)8 0  Ap <ih8  T ]nY ]Q Uy/ `O Q IiA p [; @ X % P~ z+`8@5a Ш/ M Fn 0#2K4 SD  PJ* @xUs fuV з21n8B_ /3 A  Fx -  'E4 @ 8G `"C c %v Hg\ 0z~;  (7 0 4v +G<  F `ZX p Pp  pi  zz2 `n kPt pvVP ` 4Y !g Pm kf 8 H / K P-2  K P 8)1F8M 2 @ @v8 p d  pSE ?=1 I8pO2 @c I, ' PN =o 2 (8a o? \ 75 R3   С8 h 3 P A' HH pF 9  @"P 9 @ b pw P  ? 7 @/b W @ Q.= \J P  qX  0X @n7 F D ~2 < T t  p n8n`8x I  EPV sGo +Z+@8 ) kL  fh P 0 g ?Z =Rr Q@e E  c?   @j'  vk t  0`G8\ |9 'c y 1s r4 uE `9pv 8(Q 0 + sx h U?G @ AC [ W `  @Nj B U |r S AY ` WB7 g) @e 'r M]' i Jf `U `A) `- @y `b ] ЏI p ^Y jKG @ M iQ1 G8O P h PO  _b @Md! vb PY @(H-  ,<  U SSP . `# T `. em  U iY 6l4 0t @DD r u @ Ja w)> H ' S "C  r t] @7X ` X1G8c g @'3 / m- s  ]6 B @T l ` " БWO @ N н  <d ЦM Нo 8o ,Z/ %  `< Dp :> m I Y 0lO ]% |* i$p8t P / & (io @,9T* AqD ! |  p   ~< @ f 0j  Gi K `=_8 1m (Y 2D @q Gj `@ @Z5:  +8s aW3  !4  : p |o ,h8 T prc ФM2 m {h  qX  Л +8PW z P`dKb  o p-v `G_ pJIj[ `\q BIH PH h EP 0 Ow @L? [ d0 QN p w3 Pv ;-  A2G @ Ue Y+8@z h'J z3 `x i p"wx `, ? [ ^b 08(?@ w R Mh .e s @~k ,' p\G D c&8y OjV ІQZ= !  9)  I  =1  O   * x jk  ;  =I] ;s= = '$ /&IM = 33+8@E oF P2K  =m B M o&O  q JJy[ a 5 R p#MDp 6 HL  Z[ /+  p[6 o 0*9\y  $  w 0>n8N ` $q Ai Ѝ ?N! h6  K'.  H- p ) EQ @  `, X\ t82 a ` pMB ) Rp 9/; 0 e]c v gI ` t phU =8 P 6 <:  Qv o `00I m ku  q G.g @  U e G ` + 8`X ,cE l yK 0 <9 ` ~I p o + i `L.[ 0U6  PDm p R pI  p> [ pE ` Zo ."E %9 3T_ /+&  3H  ~w `I k &D$ P,&Y 0~d G vmC[ 0\g3 `8bwV 0j W4 U+80 PC/ A8@~k  E v p |  PKQ4 ;n i |e p.8 Th ,k  iz ` u ] 0Z  u  8] 6 *  K ( @t ``z p{66b p+`80J 1Hu     p~ P  r UM    a  A t t{R U Rk ! S  x  U Sh 1 p 8ATL 1 "i* Ћoge E S e O p m 0^ > P=\ t\ |}a p9{ CV qK -R2D ']6l PS {V;\ p\ nJ 0 :)L >UMj  Y 5<, #    a ~E и X l ` @  l~ XL P 7 `  I & @ |A mlq Dn p#C e $ 0}E 0 [ }3 , |# vXj  rF l` MWW Q[ 0`a  @YJ s1G8@X' `v dO" Pf_ `?`1  m 9:J @ M-  % B ( m Qv D w !  P.PH> ) B|4  L\I v ,Z `9H.&  h& ` ,,8P;  0_# |   b2g R 5w" 0F2 (G 8 y+8@. W_ '  /P P P ] Pv `U L X =Oq IhW g ?q|P81`H8` PL]  P(#c H - n %NU ' 0X9a 0P  % @p>\ `}6) " o w0 p : 3  @ 6w  7 @ hT R1 % 9 p~ ! ` /B D Pk @   P -   W ih8r pM+d C G# %^t pt @sY  B I Ny p d `q  @ @ AR L} p 8Pl p v% 0L ?Z Y `+8 ]< 0  0 spn !\E =  d[ @ig 89  1 _0 U en PE? \ Ty  [ c< B L8 H 00 W 00 P> R Bk Z, q gX 0ax 0JRD P X8 ` }f M& <] :n; о 8(Y -oy   P |  P d ЧM s `  `, { W_  iM  x] n+8wm +`8x J p 3WS ( P, V4 @ r kA tg f5*8K    zx Q"X (5 @  "< У! иl# Ц zz P{ W p <w> H xp `82d 0q IbF ?KP ` " Xp 8.r O6 p )   Xu (#  n$M 81t u}7 { 0 <   yh `S7T8=83W %Dv 0 J ` 10G8A"  M  <Cm  0+P  e_ e *80 T  l0 V $R #N `\J 1T k %Y 0fo P'(B T gU1F8.J8pf <; P z:! @&  ;: @ "<8(jh d6 P t P( pD. `$ y О /d h ` [ dLn ! I  @cC @]  X8^H + "% p r V  @8 z{ xhJ 0 ( > 2,WM n    ,c Vo 0,d b> G 1^G \ vC 0k ?# 9]u  3   S 0{D*8@@ P e ЮE\ ! @  WG 3 P*^  h iB F  \ ng ` @+ LT T 0wZ PGF ?x 0[ pf^ I  PWy_ F [ b,w @L pg Pjy   `     0 ' `OM) pzd80f @5 ^e 0'k Pz hM- X 1 ` MTp 7#R @6n zu  i`83* ~sjT @s ju 0   'dw M %{ }yT P$ 0, v: A (08_@ ` z5 Ppl Gl  `c2x J{- 'j J  1g 0E/B85 " 9  #r U$` s n E &< -x '" @ g W2 ` J0$ @, O Xk- w#6 p W] 06.I8`l 0Dh @ C= P! %a vJ t P_.  &A eP  ДPrC Pb @ 5k ]ug u c Ps i9 @ <-   ; b#  `ZS ,   `b2S^ , sv @@$> > ( CK  ("-8Y< Q p  M1wH - u  Pm OEW X8 M  ` v 0 r @[lSf 0w p  ! NR `&. #{:. .P1K  0 Y / u9 E* Й m IE6 { }[U * @yR pDgQS `hy  f `M~8( S=v && 0 ^9 `  `aqF 7 *sG d j9 | &, @u  Y>BO 0h 0M  0PG8+80y 0 q L%N P: y& -]n !n&w   B fp 8; p`d889 { J9  QR& C @g q `HR<8 .d2 g /` N P ! 7n8x Pb e" o @3XZ QP# @bi 6  KW { \J ;  u @*ws i]a P17% |* z D @ ] SC \ $ , y   @z$ 0#F 03p* 80N  .H8P! 0azt =H 1r V# C `V GM |dj ! 0 * Ѓ w u 0 !D PF  6 f(5 P  ]= X z  М9 P  T)u ";  o\ 'G y:yN V  PQ U  `4c ХM2+`8@"y @ W Tf З+2 a :  (7 ` bD vW  <  NY p#17 Z :,3p 4T S0  P :%W Tm `2 `l CA iz \  @\c P A< @. uO p o> = kG1G8c 0j @&~ k!* s  PI @ <=L ?P @0 `Rg H @wvj @ D/ P ' F ` d %  v @ w 1H p.  P P  }L @%@b &NH 0+ P1-H8 p  :c PA Q( BK S @\M ^ WR Hcr Qs nb P  f+83 {  ] > ?9 p 4-@ g( ex] 0A lO 1 pH_   __gmon_start___fini_ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalize_Jv_RegisterClassesPerl_yyerrorPerl_gv_stashpvPerl_mg_findPerl_safesysfreePerl_refcounted_he_freePerl_messPerl_qerrorPerl_sv_newmortalPerl_gv_efullname4Perl_ckwarnPerl_warnerPerl_pad_allocPerl_sv_setsv_flagsPerl_sv_free2Perl_av_fetchPerl_hv_commonPerl_hv_common_key_lenPerl_newSVpvn_sharePerl_croakPerl_sv_freePerl_sv_backoffPerl_sv_2pv_flags__stack_chk_failPerl_stack_growstrrchrPerl_push_scopePerl_save_pptrPerl_save_I32Perl_save_vptrPerl_av_create_and_pushPerl_call_listPerl_pop_scopePerl_av_create_and_unshift_onePerl_ck_warnerPL_ppaddrPL_opargsPerl_allocmyPL_charclassPerl_pad_add_name_pvnPerl_formPerl_yyerror_pvstrchrPerl__is_utf8__perl_idstartPerl_op_clearPerl_sv_catpvn_flagsPerl_pad_freePerl_pad_swipePL_checkPerl_ck_ftstPerl_gv_try_downgradePerl_op_freePL_op_mutexpthread_mutex_lockpthread_mutex_unlockPerl_croak_nocontextPerl_op_nullPerl_op_refcnt_lockPerl_op_refcnt_unlockPerl_op_linklistPerl_finalize_optreePerl_sawparensPerl_block_startPerl_pad_block_startPerl_save_hintsPerl_save_pushptrPerl_av_lenmemcpyPerl_blockhook_registerPerl_newSVivPerl_newPMOPPerl_refcounted_he_fetch_pvnPerl_av_pushPerl_sv_2iv_flagsPL_op_descPerl_packagePerl_save_generic_svrefPerl_save_itemPerl_gv_stashsvPerl_package_versionPerl_gv_fetchpvn_flagsPerl_cv_ckproto_len_flagsPerl_ckwarn_dmemcmpPerl_bytes_cmp_utf8Perl_sv_setpvnPerl_sv_catpvfPerl_newSVpvn_flagsPerl_cv_const_svPerl_op_const_svPerl_newSVsvPerl_newMYSUBPerl_ck_anoncodePerl_pad_add_anonPerl_ck_bitopPerl_ck_concatPerl_ck_rvconstPerl_gv_fetchsvPerl_ck_matchPerl_pad_findmy_pvnPerl_ck_nullPerl_rv2cv_op_cvPerl_cv_get_call_checkerPerl_ck_entersub_args_proto_or_listPerl_cv_set_call_checkerPerl_sv_magicPerl_mg_free_typePerl_ck_svconstPerl_peepPerl_custom_op_registerPerl_sv_2mortalPerl_newSV_typePerl_custom_op_xopPerl_safesyscallocPerl_savepvnPerl_scalarvoidPerl_scalarstrlenstrncmpPerl_sv_2nv_flagsPerl_newSVpvfPerl_newSVpvnPerl_pv_prettyPerl_dorefPerl_oopsAVPerl_ck_warner_dPerl_oopsHVPerl_newOPPerl_newNULLLISTPerl_newLISTOPPerl_op_append_elemPerl_op_prepend_elemPerl_op_append_listPerl_newSTATEOPPerl_intro_myPerl_refcounted_he_incPerl_cop_store_labelPerl_savesharedpvPerl_savesharedpvnPerl_gv_fetchfilePerl_op_scopePerl_newSVOPPerl_ck_methodPerl_newPADOPPerl_newGVOPPerl_create_eval_scopePL_sv_placeholder__sigsetjmpPerl_delete_eval_scopePerl_mg_freePerl_gv_add_by_typePerl_newBINOPPerl_newPVOPPerl_ck_repeatPerl_convertPerl_newANONLISTPerl_newANONHASHPerl_newUNOPPerl_invertPerl_pmruntimePerl_pregcompPerl_safesysmallocPerl_utf8n_to_uvuniqsortPerl_uvuni_to_utf8_flagsPerl_swash_initPerl_bytes_to_utf8Perl_newSVuvPL_memory_wrapPerl_newRANGEPerl_sv_upgradePerl_newGVREFPerl_ck_readlinePerl_ck_entersub_args_corePerl_sv_2uv_flagsPerl_newSVpvPerl_newSVhekPerl_sv_2bool_flagsPerl_newLOGOPPerl_newCONDOPPerl_ck_sassignPerl_newAVREFPerl_newHVREFPerl_newCVREFPerl_newSVREFPerl_jmaybePerl_ck_evalPerl_feature_is_enabledPerl_hv_copy_hints_hvPerl_listPerl_pp_pushmarkPerl_pp_anonlistPerl_newSLICEOPPerl_ck_sortPerl_op_contextualizePerl_block_endPerl_pad_leavemyPerl_leave_scopePerl_newFORMPerl_cvgv_setPerl_savepvPerl_pad_tidyPerl_newPROGPerl_get_cvn_flagsPerl_call_svPerl_markstack_growPerl_op_lvalue_flagsPerl_bind_matchPerl_varnamePerl_newASSIGNOPPerl_sv_setivPerl_newLOOPOPPerl_newWHILEOPPerl_newFOROPPerl_newLOOPEXPerl_newGIVENOPPerl_newWHENOPPerl_ck_smartmatchPerl_ck_listiobPerl_ck_returnPerl_ck_entersub_args_listPerl_ck_subrPerl_dofilePerl_ck_cmpPerl_ck_splitPerl_rpeepPerl_newRVPerl_sv_rvweakenPerl_cop_fetch_labelPerl_ck_entersub_args_protoPerl_gv_fullname4Perl_ck_funPerl_ck_spairPerl_ck_deletePerl_ck_diePerl_ck_eofPerl_ck_exitPerl_ck_execPerl_ck_existsPerl_ck_indexPerl_fbm_compilePerl_ck_lfunPerl_ck_rfunPerl_ck_definedPerl_ck_openPerl_mode_from_disciplinePerl_ck_requirememmovePerl_sv_force_normal_flagsPerl_ck_selectPerl_ck_shiftPerl_ck_joinPerl_ck_chdirPerl_ck_truncPerl_ck_substrPerl_ck_tellPerl_ck_eachPerl_ck_lengthPerl_ck_grepPerl_core_prototypePL_op_namestrcmpPerl_coresub_opPerl_report_redefined_cvPerl_sv_cmp_flagsPerl_newXS_len_flagsPerl_sv_setpvPerl_gv_fetchpvPerl_mro_method_changed_inPerl_cv_undefPerl_newCONSTSUB_flagsPerl_newCONSTSUBPerl_newXS_flagsPerl_newXSPerl_newATTRSUB_flagsPerl_sv_setpvfPerl_sv_catpvPerl_cvstash_setPerl_pad_fixup_inner_anonsPerl_newATTRSUBPerl_utilizePerl_new_versionPerl_sv_setnvPerl_upg_versionPerl_vcmpPerl_newSVnvPerl_vload_modulePerl_lex_startPerl_start_subparsePerl_load_modulePerl_apply_attrs_stringPerl_pad_compname_typePerl_my_attrsPerl_localizePerl_ck_globPerl_newGVgen_flagsPerl_load_module_nocontextPL_thr_keypthread_getspecificPerl_newANONATTRSUBPerl_newANONSUBPerl_wrap_op_checkerPL_check_mutexPerl_nothreadhookgetuidgeteuidgetgidgetegidPerl_sv_chopPerl_filter_delPL_bincompat_options__xstat64Perl_av_unshiftPerl_av_storememchrPerl_sys_initPL_sigfpe_savedPL_perlio_mutexpthread_mutex_initPerl_sys_init3Perl_sys_termPL_veto_cleanupPL_hints_mutexpthread_mutex_destroyPerlIO_teardownperl_allocPL_curinterppthread_setspecificpthread_key_createPL_dollarzero_mutexPL_my_ctx_mutexperl_freepthread_key_deletePerl_call_atexitPerl_safesysreallocPerl_get_svPerl_get_avPerl_get_hvPerl_get_cvPerl_my_unexecgetpidkillPerl_doing_taintPerl_init_dbargsPerl_av_clearPerl_init_debuggerPerl_init_stacksPerl_new_stackinfoperl_constructPerl_runops_standardPerl_sv_nosharingPerl_sv_nounlockingPerl_sv_destroyablePerl_despatch_signalsPL_NoPL_YesPerl_sighandlerPerl_init_i18nl10nPerl_set_numeric_standardPerlIO_initPerl_reentrant_initPerl_hv_ksplitsysconfPL_mmap_page_size__errno_locationPerl_populate_isaPerl_init_argv_symbolsPerl_sv_utf8_decodePerl_mg_setPerl_my_exitPerl_sv_derived_fromPerl_vstringifyPerl_PerlIO_stdoutPerlIO_printfPerlIO_putsPerl_moreswitchesPerl_my_setenvPL_do_undumpPerl_parse_unicode_optsPerl_grok_hexPerl_sv_growPerl_grok_octPerl_dounwindPerl_PerlIO_stderr__longjmp_chkPerl_save_intPerl_free_tmpsPerl_call_pvPerl_call_argvPerl_call_methodPerl_eval_svPerl_taint_properPerl_eval_pvPerl_av_shiftperl_destructPerl_my_fflush_allPerlIO_destructPL_use_safe_putenvPerl_PerlIO_closePerl_sv_clean_allPerl_ptr_table_freePerl_sv_clearPerlIO_cleanupPerl_free_tied_hv_poolPerl_reentrant_freePerl_sv_free_arenasPerl_sv_clean_objsPL_phase_namesperl_parsegetenvstrtolPerl_hv_name_setPerl_get_hash_seedPerlIO_fdopenPerl_PerlIO_filenofcntlPerl_rsignal_statePerl_sv_getsPerl_instrPerlIO_ungetcPerl_pad_newPerl_boot_core_PerlIOPerl_boot_core_UNIVERSALPerl_boot_core_mroPerl_PerlIO_stdinPerl_setdefoutPerl_yyparsePerlIO_open__fxstat64strerror_rPerl_filter_addPerl_find_scriptPerl_rsignalPerlIO_binmodePerl_gv_checkperl_runPerl_require_pvPerl_my_failure_exitPerl_gv_const_svPerl_newGPPerl_share_hekPerl_sv_add_backrefPerl_sv_del_backrefPerl_sv_catsv_flagsPerl_gp_refPerl_gp_freePerl_unshare_hekPerl_diePerl_magic_freeovrldPerl_amagic_is_enabledPerl_amagic_callPerl_try_amagic_unPerl_sv_2numPerl_mg_getPerl_try_amagic_binPerl_report_uninitPerl_amagic_deref_callPerl_gv_name_setPerl_gv_init_pvnPerl_sv_usepvn_flagsPerl_sv_reftypePerl_gv_fetchfile_flagsPerl_gv_init_svPerl_gv_init_pvPerl_keywordPerl_newSVPerl_gv_autoload_pvnPerl_gv_fetchmeth_pvnPerl_sv_utf8_upgrade_flags_growPerl_gv_fetchmethod_pvn_flagsPerl_gv_stashpvnPerl_gv_fetchmethod_sv_flagsPerl_gv_fetchmethod_pv_flagsPerl_gv_fetchmethod_autoloadPerl_save_scalarPerl_mro_package_movedPL_sig_namePerl_vnumifyPerl_mro_get_linear_isaPerl_mro_meta_initPerl_gv_fetchmeth_svPerl_gv_fetchmeth_pvPerl_gv_fetchmeth_pvn_autoloadPerl_gv_fetchmeth_sv_autoloadPerl_gv_fetchmeth_pv_autoloadPerl_Gv_AMupdatePerl_sv_unmagicPerl_gv_handlerPerl_gv_autoload_svPerl_gv_autoload_pvPL_utf8skipPerl_is_utf8_alnumPerl_is_utf8_markPerl_is_ascii_stringPerl_is_utf8_stringPerl_save_I8__memcpy_chkPerl_parser_freePerl_PerlIO_clearerrPerl_lex_bufutf8Perl_lex_grow_linestrPerl_lex_stuff_pvnPerl_save_sptrPerl_lex_stuff_pvPerl_lex_stuff_svPerl_lex_unstuffPerl_lex_read_toPerl_lex_discard_toPerl_yyunlexPerl_str_to_versionPerl_av_popPerl_filter_readPerl_PerlIO_readPerl_PerlIO_errorPerl_lex_next_chunkPerl_lex_peek_unicharPerl_lex_read_unicharPerl_lex_read_spacePerl_utf8_to_uvchr_bufPerl_sv_cat_decodePerl_utf16_to_utf8_reversedPerl_utf16_to_utf8Perl_yyerror_pvn__ctype_b_locPerl_sv_pvn_force_flagsPerl_sv_magicextPerl_scan_vstringPerl_scan_numPerl_grok_numberPerl_my_atofsetlocalePerl_yylexPL_no_myglobPerl_save_boolPerl_save_I16Perl_save_generic_pvrefPerl_utf8_hopPL_keyword_pluginPerl_delimcpyPerl_PerlIO_tellPerl_sv_uni_displayPerl_utf8_lengthPerl_sv_recode_to_utf8PL_warn_reservedPL_warn_nosemiPerl_rsignal_saveexecvPerl_rsignal_restore__snprintf_chkPerl_prescan_versionPerl_scan_versionPerlIO_apply_layersPerl_keyword_plugin_standardPerl_parse_arithexprPerl_parse_termexprPerl_parse_listexprPerl_parse_fullexprPerl_parse_blockPerl_parse_barestmtPerl_parse_labelPerl_sv_copypvPerl_parse_fullstmtPerl_parse_stmtseqPerl_munge_qwlist_to_paren_listPerl_save_destructor_xPerl_sv_eq_flagsPerl_bytes_from_utf8Perl_pad_add_name_pvPerl_pad_add_name_svPerl_pad_findmy_pvPerl_pad_findmy_svPerl_find_rundefsvoffsetPerl_find_runcvPerl_find_rundefsvPerl_find_rundefsv2Perl_do_dump_padPerl_dump_indentPerl_cv_clonePerl_av_fillPerl_pad_pushPerl_padlist_dupPerl_sv_dup_incPerl_ptr_table_fetchPerl_ptr_table_storePerl_av_extendPerl_re_intuit_stringPerl_reg_qr_packagememsetPerl_sv_len_utf8Perl_reg_numbered_buff_storePerl_croak_no_modifyPerl_reg_numbered_buff_fetchPerl_sv_untaintPerl_reg_numbered_buff_lengthPerl_is_utf8_string_loclenPerl_regfree_internalPerl_regdupe_internalPerl_vmessPerl_reginitcolorsPerl_reg_named_buff_fetchPerl_newRV_noincPerl_reg_named_buff_existsPerl_reg_named_buff_firstkeyPerl_hv_iterinitPerl_reg_named_buff_nextkeyPerl_hv_iternext_flagsPerl_reg_named_buff_iterPerl_reg_named_buff_scalarPerl_reg_named_buff_allPerl_reg_named_buffPerl__new_invlistPerl__invlist_populate_swatchPerl__invlist_intersection_maybe_complement_2ndPerl__invlist_invertPerl__invlist_union_maybe_complement_2ndPerl__add_range_to_invlistPL_fold_latin1PL_foldPerl__invlist_invert_propPerl__invlist_contentsPerl_regdumpPerl_regpropPerl_pregfreePerl_pregfree2Perl_reg_temp_copyPerl_re_dup_gutsPerl_regnextPL_fold_localePerl__to_fold_latin1PL_reg_namePL_regkindPL_varies_bitmaskPL_simple_bitmaskPerl_repeatcpyPerl_save_re_contextPerl_savestack_grow_cntPerl_sv_compile_2op_is_brokenPerl_re_compilePL_core_reg_engineAboveLatin1_invlistASCII_invlistL1PosixAlnum_invlistL1PosixAlpha_invlistXPosixBlank_invlistL1Cased_invlistXPosixCntrl_invlistPosixDigit_invlistL1PosixGraph_invlistL1PosixLower_invlistL1PosixPrint_invlistL1PosixPunct_invlistXPerlSpace_invlistXPosixSpace_invlistL1PosixUpper_invlistVertSpace_invlistL1PosixWord_invlistXPosixXDigit_invlistPerl__to_uni_fold_flagsPL_latin1_lcPerl__swash_inversion_hashPerl__swash_to_invlistPerl__to_utf8_fold_flags__sprintf_chkPerl__core_swash_initPerl_valid_utf8_to_uvchrPerl_regexec_flagsPerl_re_intuit_startPL_simplePL_variesPL_reg_extflags_namePL_op_sequencePL_op_seqPerl_dump_vindentPerlIO_vprintfPerl_pv_escapePerl_pv_displayPerl_sv_peekPerl_sv_taintedPerl_set_numeric_localPerl_op_dumpPerl_do_op_dumpPerl_dump_sub_perlPerl_dump_subPerl_dump_formPerl_dump_packsubs_perlPerl_dump_packsubsPerl_dump_all_perlPerl_PerlIO_setlinebufPerl_dump_allPerl_dump_evalPerl_do_pmop_dumppmflags_flags_namesPerl_pmop_dumpop_flags_namesop_entersub_namesop_private_namesPerl_gv_dumpPerlIO_putcPerl_do_hv_dumpPerl_do_gv_dumpPerl_do_gvgv_dumpPerl_do_sv_dumpfirst_sv_flags_namessecond_sv_flags_namescv_flags_nameshv_flags_namesPerl_do_magic_dumpPerl_hv_placeholders_getPerl_av_arylen_pregexp_flags_namesgp_flags_namesgp_flags_imported_namesPerl_hv_fillPerl_hv_iterkeysvPerl_hv_backreferences_pPL_magic_vtablesPL_magic_vtable_namesPerl_magic_dumpPerl_sv_dumpPerl_debopPerl_stashpv_hvname_matchPerl_debPerl_runops_debugPerl_deb_stack_allPerl_debstackPerl_watchPerl_debprofdumpop_leavesub_namesop_aassign_namesop_die_namesop_delete_namesop_exists_namesop_exit_namesop_flip_namesop_gv_namesop_list_namesop_sassign_namesop_repeat_namesop_rv2cv_namesop_trans_namesop_const_namesop_sort_namesop_open_namesop_reverse_namesPL_no_memPerl_sv_mortalcopyPerl_sv_2cvPerl_mallocPerl_callocPerl_reallocPerl_mfreePerl_ninstrPerl_rninstrPL_freqPerl_fbm_instrPerl_foldEQPerl_foldEQ_latin1Perl_foldEQ_localePerl_savesvpvPerl_savesharedsvpvPerl_write_to_stderrPerl_do_printPerl_PerlIO_flushPerl_magic_methcallPerl_vcroakPerl_vformPerl_sv_vsetpvfnPerl_form_nocontextPerl_mess_svPerl_croak_svPerl_die_unwindPerl_die_svPerl_mess_nocontextPerl_die_nocontextPerl_screaminstrPL_no_modifyPerl_warn_svPerl_vwarnPerl_warn_nocontextPerl_warnPerl_vwarnerPerl_warner_nocontextPerl_new_warnings_bitfieldunsetenvhtovshtovlvtohsvtohlPerl_my_swabnPerl_atfork_lockPerl_atfork_unlockPerl_my_forksigemptysetsigactionPerl_wait4pidPerl_my_popen_listpipePerl_do_execfreedup2Perl_taint_envPerl_do_aexec5Perl_my_popenPerl_do_exec3Perl_my_pclosePerlIOUnix_refcntPerl_get_contextPerl_set_contextPerl_get_op_namesPerl_get_op_descsPerl_get_no_modifyPerl_get_opargsPerl_get_ppaddrPerl_getenv_lenPerl_get_vtblPerl_report_wrongway_fhPerl_report_evil_fhPerl_init_tmlocaltimePerl_mini_mktimePerl_my_strftimePerl_getcwd_svgetcwdPerl_newSVrvPerl_sv_insert_flagsPerl_sv_lenPerl_sv_isobjectPerl_vverifydivPerl_vnormalPerl_my_socketpairPerl_seedgettimeofdaysrand48_rdrand48_rstrtoulPerl_my_snprintf__vsnprintf_chkPerl_my_vsnprintfPerl_my_clearenvPerl_my_cxt_initPL_my_cxt_indexPerl_xs_version_bootcheckPerl_xs_apiversion_bootcheckPerl_my_strlcatPerl_my_strlcpyPerl_candoPerl_get_db_subPerl_sv_sethekPerl_my_dirfdPerl_get_re_argsigprocmaskPerl_mg_magicalPerl_save_allocPL_magic_dataPerl_mg_lengthPerl_mg_sizePerl_mg_clearPerl_mg_findextPerl_mg_copyPerl_mg_localizePerl_magic_regdata_cntPerl_magic_regdatum_getPerl_magic_regdatum_setPerl_emulate_cop_ioPerl_magic_getgetgroupsPerl_sv_setuvPerl_magic_lenPerl_magic_getuvarPerl_magic_setenvPerl_magic_clearenvPerl_magic_set_all_envPerl_hv_itervalPerl_hv_iterkeyPerl_magic_clear_all_envPerl_csighandlersigaddsetsigismemberPerl_magic_clearisaPerl_mro_isa_changed_inPerl_magic_setisaPerl_magic_setamagicPerl_magic_getnkeysPerl_magic_setnkeysPerl_magic_getpackPerl_magic_setpackPerl_magic_clearpackPerl_magic_sizepackPerl_magic_wipepackPerl_magic_nextpackPerl_magic_existspackPerl_magic_scalarpackPerl_hv_eiter_setPerl_magic_setdblinePerl_magic_getarylenPerl_magic_setarylenPerl_magic_freearylen_pPerl_magic_getposPerl_sv_pos_b2uPerl_magic_setposPerl_sv_pos_u2bPerl_magic_getsubstrPerl_translate_substr_offsetsPerl_sv_pos_u2b_flagsPerl_magic_setsubstrPerl_magic_gettaintPerl_magic_settaintPerl_magic_getvecPerl_do_vecgetPerl_magic_setvecPerl_do_vecsetPerl_magic_setvstringPerl_magic_getdefelemPerl_vivify_defelemPL_no_helem_svPL_no_aelemPerl_magic_setdefelemPerl_magic_killbackrefsPerl_sv_kill_backrefsPerl_magic_setmglobPerl_magic_setuvarPerl_magic_setregexpPerl_magic_setcollxfrmPerl_magic_setutf8Perl_magic_setprctlsetgroupssetregidseteuidsetreuidsetegidPerl_whichsig_pvnPL_sig_numPerl_magic_getsigPerl_magic_setsigPL_csighandlerpPerl_magic_clearsigPerl_whichsig_svPerl_whichsig_pvPerl_magic_sethintPerl_refcounted_he_new_svPerl_magic_clearhintPerl_magic_clearhintsPerl_reentrant_sizePerl_reentrant_retrygethostbyname_rgetnetbyname_rgetprotobyname_rgetservbyname_rgetpwnam_rgetgrnam_rgetnetbyaddr_rgetprotoent_rgetprotobynumber_rgetgrgid_rgetpwent_rgetservent_rgetnetent_rgetgrent_rgetservbyport_rgethostent_rgethostbyaddr_rgetpwuid_rPerl_mro_get_private_dataPerl_mro_set_private_dataPerl_mro_get_from_namePerl_mro_registerPerl_newHVhvPerl_hv_ename_deletePerl_hv_ename_addPerl_mro_meta_dupPerl_hv_clearXS_mro_method_changed_inPerl_croak_xs_usagePerl_mro_set_mroPerl_more_bodiesPerl_hv_scalarPerl_hv_riter_pPerl_hv_eiter_pPerl_hv_riter_setPerl_hv_kill_backrefsPerl_unsharepvnPerl_hv_free_entPerl_hv_delayfree_entPerl_hfree_next_entryPerl_hv_placeholders_pPerl_hv_iternextsvPerl_hv_placeholders_setPerl_hv_clear_placeholdersPerl_hek_dupPerl_he_dupPerl_hv_undef_flagsPerl_refcounted_he_chain_2hvPerl_refcounted_he_fetch_pvPerl_refcounted_he_fetch_svPerl_refcounted_he_new_pvnPerl_refcounted_he_new_pvPerl_av_reifyPerl_av_makePerl_av_undefPerl_av_deletePerl_av_existsPerl_av_iter_pPerl_pp_constPerl_pp_nextstatePerl_pp_gvsvPerl_pp_nullPerl_pp_stringifyPerl_pp_gvPerl_pp_andPerl_pp_sassignPerl_block_gimmePerl_pp_cond_exprPerl_pp_unstackPerl_pp_concatPerl_pp_eqPerl_do_ncmpPerl_pp_preincPerl_sv_decPerl_sv_incPerl_pp_orPerl_pp_definedPerl_pp_addPerl_pp_aelemfastPerl_pp_joinPerl_do_joinPerl_pp_pushrePerl_pp_printPerl_tied_methodPerl_PerlIO_writePerl_pp_rv2avPerl_softref2xvPerl_save_hashPL_no_localize_refPerl_save_aryPerl_is_lvalue_subPerl_do_kvPerl_pp_aassignsetresuidsetresgidPerl_tmps_growPerl_pp_qrPerl_sv_blessPerl_pp_matchPerl_dowantarrayPerl_do_readline__lxstat64Perl_nextargvPerl_do_closePerl_start_globPerl_sv_unref_flagsPerl_do_opennPerl_pp_readlinePerl_pp_rv2gvPerl_pp_iterPerl_pp_substPerl_rxres_savePerl_cxincPerl_pp_grepwhilePerl_pp_leavesubPerl_sub_crush_depthPerl_pp_entersubPerl_was_lvalue_subPL_no_usymPerl_vivify_refPerl_pp_padsvPerl_save_clearsvPerl_pp_helemPerl_save_gpPerl_save_helem_flagsPerl_save_hdeletePerl_pp_aelemPerl_save_aelem_flagsPerl_save_adeletePerl_pp_methodPerl_pp_method_namedPerl_sv_report_usedPerl_sv_newrefPerl_sv_truePerl_sv_isaPerl_ptr_table_newPerl_ptr_table_splitPerl_fp_dupPerlIO_fdupopenPerl_dirp_dupopendirfchdirreaddir64_rPerl_ptr_table_clearPerl_any_dupPL_warn_uninit_svPL_warn_uninitPerl_cast_ivPerl_cast_uvPerl_sv_vcatpvfngcvtPL_hexdigitfrexpPerl_sv_setuv_mgPerl_sv_vcatpvfPerl_sv_catpvf_nocontextPerl_sv_vcatpvf_mgPerl_sv_catpvf_mg_nocontextPerl_sv_catpvf_mgPerl_vnewSVpvfPerl_newSVpvf_nocontextPerl_sv_setsv_mgPerl_sv_refPerl_newSVpv_sharePerl_io_closePerl_sv_unmagicextPerl_clone_params_delPerl_clone_params_newPerl_rvpv_dupPerl_sv_dupPerl_mg_dupPerl_gp_dupPerl_parser_dupPerl_cx_dupPerl_si_dupPerl_ss_dupPerl_sv_resetPerl_looks_like_numberPerl_sv_collxfrm_flagsPerl_mem_collxfrmPerl_sv_utf8_downgradePerl_utf8_to_bytesPerl_sv_2pvbytePerl_sv_setpvn_mgPerl_sv_cmpPerl_sv_cmp_locale_flagsPerl_sv_cmp_localePerl_sv_setpvivPerl_sv_setpviv_mgPerl_sv_setpv_mgPerl_sv_replacePerl_sv_setref_pvnPerl_sv_setiv_mgPerl_sv_setref_uvPerl_sv_setref_ivPerl_sv_setnv_mgPerl_sv_inc_nomgPerl_sv_dec_nomgPerl_sv_setref_nvPerl_sv_utf8_encodePerl_sv_catpv_flagsPerl_sv_catpv_mgPerl_sv_pvbyten_forcePerl_sv_pvutf8n_forcePerl_sv_2pvutf8PerlIO_isutf8PerlIO_getcPerl_PerlIO_eofPerlIO_fast_getsPerl_PerlIO_get_cntPerl_PerlIO_get_ptrPerl_PerlIO_set_ptrcntperl_clonePerlIO_clonePerl_sv_2ioPerl_sv_setref_pvPerl_sv_vsetpvfPerl_sv_setpvf_nocontextPerl_sv_vsetpvf_mgPerl_sv_setpvf_mg_nocontextPerl_sv_setpvf_mgPerl_pp_stubPerl_pp_padavPerl_pp_padhvPerl_pp_rv2svPerl_pp_av2arylenPerl_pp_posPerl_pp_rv2cvPerl_pp_prototypePerl_pp_anoncodePerl_pp_srefgenPerl_pp_refgenPerl_pp_refPerl_pp_blessPerl_pp_gelemPerl_pp_studyPerl_pp_transPerl_do_transPerl_pp_schopPerl_pp_chopPerl_pp_undefPerl_pp_postincPerl_pp_powPerl_pp_multiplyPerl_pp_dividePerl_pp_modulofloorfmodPerl_pp_repeatPerl_pp_subtractPerl_pp_left_shiftPerl_pp_right_shiftPerl_pp_ltPerl_pp_gtPerl_pp_lePerl_pp_gePerl_pp_nePerl_pp_ncmpPerl_pp_slePerl_pp_seqPerl_pp_snePerl_pp_scmpPerl_pp_bit_andPerl_do_vopPerl_pp_bit_orPerl_pp_negatePerl_pp_notPerl_pp_complementPerl_uvchr_to_utf8_flagsPerl_pp_i_multiplyPerl_pp_i_dividePerl_pp_i_moduloPerl_pp_i_addPerl_pp_i_subtractPerl_pp_i_ltPerl_pp_i_gtPerl_pp_i_lePerl_pp_i_gePerl_pp_i_eqPerl_pp_i_nePerl_pp_i_ncmpPerl_pp_i_negatePerl_pp_atan2Perl_pp_sinsqrtlogcosPerl_pp_randPerl_pp_srandPerl_pp_intceilPerl_pp_absPerl_pp_octPerl_grok_binPerl_pp_lengthPerl_pp_substrPerl_pp_vecPerl_pp_indexPerl_pp_sprintfPerl_do_sprintfPerl_pp_ordPerl_pp_chrPerl_pp_cryptcrypt_rPerl_pp_ucfirstPerl__to_utf8_lower_flags__ctype_toupper_loc__ctype_tolower_locPerl__to_upper_title_latin1Perl__to_utf8_title_flagsPerl_pp_ucPerl__to_utf8_upper_flagsPL_mod_latin1_ucPerl_pp_lcPerl_pp_quotemetaPerl__is_utf8_quotemetaPerl_pp_fcPerl_pp_aslicePerl_pp_aeachPerl_pp_akeysPerl_pp_eachPerl_pp_rkeysPerl_pp_deletePerl_pp_existsPerl_pp_hslicePerl_pp_listPerl_pp_lslicePerl_pp_anonhashPerl_pp_splicePerl_pp_pushPerl_pp_shiftPerl_pp_unshiftPerl_pp_reversePerl_pp_splitPerl_save_pushptrptrPerl_is_utf8_spacePerl_pp_oncePerl_pp_lockPerl_unimplemented_opPL_no_sock_funcPerl_pp_boolkeysPerl_pp_coreargsPerl_pp_runcv_LIB_VERSIONPerl_savestack_growPerl_save_shared_pvrefPerl_save_set_svflagsPerl_save_pushi32ptrPerl_save_padsv_and_mortalizePerl_save_hptrPerl_save_aptrPerl_save_deletePerl_save_destructorPerl_save_svrefPerl_cx_dumpPerlIO_opennPerl_pp_regcresetPerl_pp_regcompPerl_pp_substcontPerl_pp_formlinePerl_pp_grepstartPerl_pp_mapwhilePerl_pp_rangePerl_pp_flipPerl_pp_flopPerl_pp_xorPerl_caller_cxPerl_pp_wantarrayPerl_pp_callerPerl_pp_resetPerl_pp_dbstatePerl_pp_enterPerl_pp_leavePerl_pp_enteriterPerl_pp_enterloopPerl_pp_leaveloopPerl_pp_returnPerl_pp_leavesublvPerl_pp_lastPerl_pp_nextPerl_pp_redoPerl_pp_gotoPerl_pp_exitPerl_sv_compile_2opPerl_pp_requirestrstrPerl_pp_hintsevalPerl_pp_enterevalPerl_pp_leaveevalPerl_pp_entertryPerl_pp_leavetryPerl_pp_entergivenPerl_pp_leavegivenPerl_pp_smartmatchPerl_pp_enterwhenPerl_pp_leavewhenPerl_pp_continuePerl_pp_breakPerl_pp_backtickPerl_PerlIO_context_layersPerl_pp_globPL_no_securityPerl_pp_rcatlinePerl_pp_warnPerl_pp_diePerl_pp_openPerl_pp_closePerl_pp_pipe_opPerl_pp_filenoPerl_pp_umaskPerl_pp_binmodePerl_pp_tiePerl_pp_untiePerl_pp_tiedPerl_pp_dbmopenPerl_pp_sselectPerl_pp_selectPerl_pp_getcPerl_do_eofPerl_pp_enterwritePerl_pp_leavewritePerl_pp_prtfPerl_pp_sysopenPerl_pp_sysreadrecvfromPerl_pp_syswritesendtosendPerl_pp_eofPerl_pp_tellPerl_do_tellPerl_pp_sysseekPerl_do_sysseekPerl_do_seekPerl_pp_truncateftruncate64Perl_pp_ioctlPerl_pp_flockPerl_pp_socketPerl_pp_sockpairPerl_pp_bindconnectPerl_pp_listenPerl_pp_acceptPerl_pp_shutdownPerl_pp_ssockoptsetsockoptgetsockoptPerl_pp_getpeernamegetsocknamePerl_pp_statPL_warn_nlPerl_pp_ftrreadeaccessPerl_my_stat_flagsPerl_pp_ftisPerl_pp_ftrownedPerl_pp_ftlinkPerl_my_lstat_flagsPerl_pp_ftttyisattyPerl_pp_fttextPerlIO_has_basePerl_PerlIO_get_bufsizPerl_PerlIO_get_basePerl_pp_chdirPerl_pp_chownPerl_applyPerl_pp_chrootPerl_pp_renamePerl_pp_linksymlinkPerl_pp_readlinkPerl_pp_mkdirPerl_pp_rmdirPerl_pp_open_dirPerl_pp_readdirPerl_pp_telldirPerl_pp_seekdirPerl_pp_rewinddirPerl_pp_closedirPerl_pp_forkPerl_pp_waitPerl_pp_waitpidPerl_pp_systemPerl_pp_execPerl_pp_getppidPerl_pp_getpgrpgetpgidPerl_pp_setpgrpsetpgidPerl_pp_getpriorityPerl_pp_setpriorityPerl_pp_timePerl_pp_tmsPerl_pp_gmtimetzsetlocaltime_rPerl_pp_alarmPerl_pp_sleeppausePerl_pp_shmwritePerl_do_shmioPerl_do_msgsndPerl_do_semopPerl_do_msgrcvPerl_pp_semgetPerl_do_ipcgetPerl_pp_semctlPerl_do_ipcctlPerl_pp_ghostent__h_errno_locationPerl_pp_gnetentPerl_pp_gprotoentPerl_pp_gserventPerl_pp_shostentsetserventsetprotoentsethostentsetnetentPerl_pp_ehostentendhostentendgrentendnetentendprotoentendserventsetpwentendpwentsetgrentPerl_pp_gpwentgetspnam_rPerl_pp_ggrentPerl_pp_getlogingetlogin_rPerl_pp_syscallPerl_swash_fetchPerlIO_intmode2strfchmodunlinkfchownPerlIO_has_cntptrPerlIO_canset_cntPerl_PerlIO_set_cntPerl_PerlIO_seeklseek64Perl_check_utf8_printexecvpPL_cshnamePL_sh_pathexeclfutimeskillpgshmgetmsggetshmctlmsgctlshmatshmdtPerl_foldEQ_utf8_flagsPerl_is_uni_space_lcPerl_is_uni_alnum_lcPerl_is_uni_digit_lcPerl_is_utf8_digitPerl_is_uni_alnumPerl_is_utf8_X_VPerl_is_utf8_X_TPerl_is_utf8_X_LV_LVT_VPerl_is_utf8_X_LVTPerl_is_utf8_X_LVPerl_is_utf8_X_LPerl_is_utf8_X_prependPerl_is_utf8_X_extendPerl_is_utf8_X_non_hangulPerl_is_utf8_X_beginPerl_utf8_distancePerl_pregexecPerl_regclass_swashPerl_is_utf8_char_bufPerl_is_utf8_charPerl_utf8_to_uvchrPerl_utf8_to_uvuni_bufPerl_valid_utf8_to_uvuniPerl_utf8_to_uvuniPerl_is_uni_asciiPerl_is_uni_cntrlPerl_is_uni_ascii_lcPerl_is_uni_cntrl_lcPerl_is_utf8_asciiPerl_is_utf8_perl_spacePerl_is_utf8_perl_wordPerl_is_utf8_posix_digitPerl_is_utf8_cntrlPerl_is_utf8_idfirstPerl_is_uni_idfirstPerl_is_uni_idfirst_lcPerl_is_utf8_xidfirstPerl_is_utf8_idcontPerl_is_utf8_xidcontPerl_is_utf8_alphaPerl_is_uni_alphaPerl_is_uni_alpha_lcPerl_is_uni_spacePerl_is_uni_digitPerl_is_utf8_upperPerl_is_uni_upperPerl_is_uni_upper_lcPerl_is_utf8_lowerPerl_is_uni_lowerPerl_is_uni_lower_lcPerl_is_utf8_graphPerl_is_uni_graphPerl_is_uni_graph_lcPerl_is_utf8_printPerl_is_uni_printPerl_is_uni_print_lcPerl_is_utf8_punctPerl_is_uni_punctPerl_is_uni_punct_lcPerl_is_utf8_xdigitPerl_is_uni_xdigitPerl_is_uni_xdigit_lcPerl_to_utf8_casePerl_to_uni_upperPerl_to_uni_upper_lcPerl_to_uni_titlePerl_to_uni_title_lcPerl_to_uni_lowerPerl_to_uni_lower_lcPerl_uvchr_to_utf8Perl_utf8n_to_uvchrPerl_pv_uni_displayPerl_deb_nocontextPerl_vdebPerl_debstackptrsXS_Internals_HvREHASHXS_version_qvXS_Internals_hash_seedXS_Internals_rehash_seedPerl_sv_derived_from_pvnPerl_sv_derived_from_svXS_UNIVERSAL_VERSIONPerl_sv_derived_from_pvPerl_sv_does_svXS_UNIVERSAL_DOESPerl_sv_doesPerl_sv_does_pvPerl_sv_does_pvnXS_UNIVERSAL_isaXS_UNIVERSAL_canXS_version_newXS_version_stringifyXS_version_numifyXS_version_normalXS_version_vcmpXS_version_booleanXS_version_noopXS_version_is_alphaXS_version_is_qvXS_utf8_is_utf8XS_utf8_validXS_utf8_encodeXS_utf8_decodeXS_utf8_upgradeXS_utf8_downgradeXS_utf8_native_to_unicodeXS_utf8_unicode_to_nativeXS_Internals_SvREADONLYXS_Internals_SvREFCNTXS_Internals_hv_clear_placeholdXS_PerlIO_get_layersXS_re_is_regexpXS_re_regnames_countXS_re_regnameXS_re_regnamesXS_re_regexp_patterndetailsPL_valid_types_NV_setPL_valid_types_IV_setPL_valid_types_RVPL_valid_types_PVXPL_valid_types_NVXPL_valid_types_IVXPL_runops_dbgPL_runops_stdPL_perlio_debug_fdPL_perlio_fd_refcnt_sizePL_perlio_fd_refcntPerl_pp_unpackPerl_pp_packPerl_pp_sortPL_interp_size_5_16_0PL_interp_sizePL_bitcountPL_uudmapPL_uuemapPL_subversionPL_versionPL_revisionPL_no_funcPL_no_dir_funcPL_no_symref_svPL_no_symrefPL_no_wrongrefPerlIOUtf8_pushedPerlIOBase_poppedPerlIOBase_noop_okPerlIOBase_noop_failPerlIOBase_eofPerlIOBase_errorPerlIOBase_setlinebufPerlIOUnix_filenoPerlIOStdio_get_basePerlIOStdio_get_bufsizPerlIOStdio_get_ptrPerlIOStdio_get_cntPerlIOBuf_get_basePerlIOBuf_poppedPerlIOUnix_tellPerlIOUnix_readPerlIOUnix_writePerlIOStdio_errorferrorPerlIOStdio_readfreadfgetcPerlIOStdio_writefwritePerlIOStdio_seekfseeko64PerlIOStdio_tellftello64PerlIOStdio_flushfflushPerlIOStdio_eoffeofPerlIOStdio_clearerrPerlIOStdio_setlinebufPerlIOUnix_seekPerlIOStdio_filenoperlsio_binmodePerlIO_debugXS_PerlIO__Layer__NoWarningsPerlIO_allocatePerlIO_list_allocPerlIO_list_freePerlIO_list_pushPerlIO_clone_listPerlIO_popPerlIOBase_binmodePerlIOPending_flushPerlIOCrlf_binmodePerlIO_find_layerPerlIO_tab_svXS_PerlIO__Layer__findPerlIO_define_layerPerlIO_parse_layersPerlIO_default_bufferPerlIO_stdioPerlIO_perlioPerlIO_arg_fetchPerlIO_layer_fetchPerlIO_default_layersPerlIO_unixPerlIO_rawPerlIO_crlfPerlIO_utf8PerlIO_removePerlIO_bytePerlIO_default_layerPerlIO_pushPerlIO_apply_layeraPerlIOBase_filenoPerlIOPop_pushedPerlIORaw_pushedPerlIOBuf_seekPerlIOBuf_tellPerlIOPending_fillPerlIOPending_seekPerlIOBase_flush_linebufPerl_PerlIO_fillPerlIOBase_clearerrPerlIOBuf_flushPerlIOCrlf_flushPerlIOBuf_unreadPerlIOBase_unreadPerlIO_pendingPerl_PerlIO_unreadPerlIOStdio_unreadPerlIOStdio_fillPerlIOBuf_writePerlIOBuf_get_ptrPerlIOBuf_get_cntPerlIOBuf_bufsizPerlIOBuf_set_ptrcntPerlIOPending_set_ptrcntPerlIOCrlf_unreadPerlIOCrlf_get_cntPerlIOCrlf_set_ptrcntPerlIOCrlf_writePerlIO_modestrPerlIOBase_pushedPerlIOBuf_pushedPerlIOCrlf_pushedPerlIOPending_pushedPerlIOBase_readPerlIOBuf_fillPerlIOBuf_readPerlIOPending_readPerlIOBase_closePerlIO__closePerlIO_cleantablePerlIOBase_openPerlIOBuf_openPerlIOPending_closePerlIOBuf_closePerlIO_sv_dupPerlIOBase_dupPerlIOBuf_dupPerlIOUnix_refcnt_decPerlIOUnix_closePerlIOStdio_closefclosePerlIOUnix_oflagsPerlIOStdio_modePerlIOStdio_pushedPerlIOStdio_set_ptrcntPerlIO_releaseFILEPerlIO_getnamePerlIO_rewindPerlIO_resolve_layersPerlIO_stdstreamsPerlIO_tmpfilePerlIO_stdoutfPerlIOUnix_refcnt_incPerlIOUnix_pushedPerlIOUnix_openPerlIOUnix_dupPerlIO_importFILEPerlIOStdio_openfreopen64fopen64PerlIOStdio_dupPerlIO_exportFILEPerlIO_findFILEmkstemp64PerlIO_reopenPerlIO_setposPerlIO_getposPerlIO_vsprintfPerlIO_sprintfPerl_cast_ulongPerl_cast_i32Perl_scan_binPerl_scan_octPerl_scan_hexPerl_grok_numeric_radixPerl_my_atof2strtodPerl_refPerl_sv_unrefPerl_sv_taintPerl_sv_2ivPerl_sv_2uvPerl_sv_2nvPerl_sv_2pvPerl_sv_2pv_nolenPerl_sv_2pvbyte_nolenPerl_sv_2pvutf8_nolenPerl_sv_force_normalPerl_sv_setsvPerl_sv_catpvnPerl_sv_catpvn_mgPerl_sv_catsvPerl_sv_catsv_mgPerl_sv_ivPerl_sv_uvPerl_sv_nvPerl_sv_pvnPerl_sv_pvn_nomgPerl_sv_pvPerl_sv_pvn_forcePerl_sv_pvbytePerl_sv_pvbytenPerl_sv_pvutf8Perl_sv_pvutf8nPerl_sv_utf8_upgradePerl_fprintf_nocontextPerl_printf_nocontextPerl_hugePerl_gv_fullnamePerl_gv_efullnamePerl_gv_fullname3Perl_gv_efullname3Perl_gv_fetchmethodPerl_hv_iternextPerl_hv_magicPerl_do_openPerl_do_open9Perl_do_binmodePerl_do_aexecPerl_init_i18nl14nPerl_uvuni_to_utf8Perl_is_utf8_string_locPerl_sv_nolockingPerl_save_longPerl_save_ivPerl_save_nogvPerl_save_listPerl_sv_usepvn_mgPerl_sv_usepvnPerl_unpack_strPerl_unpackstringPerl_pack_catPerl_packlistPerl_hv_store_entPerl_hv_exists_entPerl_hv_fetch_entPerl_hv_delete_entPerl_hv_store_flagsPerl_hv_storePerl_hv_existsPerl_hv_fetchPerl_hv_deletePerl_newAVPerl_newHVPerl_sv_insertPerl_save_freesvPerl_save_mortalizesvPerl_save_freeopPerl_save_freepvPerl_save_opPerl_gv_SVaddPerl_gv_AVaddPerl_gv_HVaddPerl_gv_IOaddPerl_newIOPerl_my_statPerl_my_lstatPerl_sv_eqPerl_sv_collxfrmPerl_sv_2boolPerl_custom_op_namePerl_custom_op_descPerl_newSUBPerl_to_utf8_foldPerl_to_utf8_lowerPerl_to_utf8_titlePerl_to_utf8_upperPerl_set_numeric_radixlocaleconvPerl_new_numericPerl_new_ctypePerl_new_collatestrxfrmnl_langinfomodfPerl_sortsv_flagsPerl_sortsvXS_DynaLoader_dl_undef_symbolsXS_DynaLoader_dl_install_xsubXS_DynaLoader_dl_errorXS_DynaLoader_CLONEXS_DynaLoader_dl_find_symboldlsymdlerrorXS_DynaLoader_dl_unload_filedlcloseXS_DynaLoader_dl_load_filedlopenboot_DynaLoaderlibresolv.so.2libnsl.so.1libdl.so.2libm.so.6libcrypt.so.1libutil.so.1libpthread.so.0libc.so.6__environ_edata__bss_startGLIBC_2.2.5GLIBC_2.11GLIBC_2.14GLIBC_2.4GLIBC_2.3.4GLIBC_2.3      { ui =|{ ui =|{ ui =|| ui =|| I| T|ii _|ti i|ii u|ui =|48p748074864848@4848485858858` 58(58058858P@58H58ȽP58X58X`58h58p588x58x585858858p585858058x585858P585858H58586868P6868 68 (68`068868@688H68P68X68`6868ߨ686868686868686868h68H686868C686878787878 78(78078878@78H78P78X78`78 h78Qp78x7878787878)78786787878787878#78(78,78178488888;88?88B 88(88088F888I@88PH88UP88ZX88_`88dh88jp88mx88q88t88x88|888888é88(88é88!88.98é98998é98@ 98F@98éH98%P98éX98R`98X98R98R98T98R98R98R98R98R98R98R98R98R98S98S98S98#S:83S:8=S:8GS:8NS :8XS(:8cS0:8sS8:8S@:8SH:8SP:8SX:8v`:8Sh:8vp:8vx:8S:8:8S:8R:8R:8R:8S:8S:8S:8S:8S:8S:8S:8S:8S:8S:8S;8S;8 S;8S;8S ;8S(;8T0;8T8;8T@;8TH;8TP;8&TX;8T`;8Th;8Tp;8%Tx;8.T;85T;8=T;8ET;8-T;84T;8U=8 =8FU(=8MU0=8UU8=8[U@=8`UH=8fUP=8rUX=8U`=8Uh=8Up=8Ux=8U=8U=8U=8O=8U=8O=8U=8=8O=8U=8U=8U=8U=8U=8U=8U=8U>8U>8U>8V>8V >8V(>8)V0>84V8>8DV@>8QVH>8cVP>8pVX>8V`>8Vh>8Vp>8Vx>8V>8V>8V>8V>8V>8W>8W>8W>8*W>84W>8CW>8UW>8lW>8xW>8W>8W>8W?8W?8W?8W?8W ?8W(?8W0?8 X8?8 X@?8+Xh?8x?8?8Ƃ?8Ђ?8ނ?8?8?8?8 ?8@8"@8.(@8?8@8JH@8UX@8]h@8hx@8t@8@8@8@8@8@8@8ʃ@8փA8ڃA8(A88A8HA8XA8hA8xA8A8A8A8A8"A8+A86A8>B8IB8O(B8W8B8^HB8fXB8mhB8vxB8~B8B8B8B8B8B8B8C8„C8̄(C8ӄ8C8݄HC8XC8hC8xC8C8C8C8C8ބC8C8C8C8 D8D8(D8&8D80HD8;XD8GhD8SxD8dD8jD8|D8D8D8D8D8D8E8ąE8ͅ(E8څ8E8HE8XE8hE8xE8 E8E8$E80E88E8DE8RE8XE8_F8jF8s(F8{8F8HF8XF8hF8xF8F8F8ĆF8ˆF8؆F8F8F8G8G8w(G88G8HG8XG8#hG8/G87G8ˆG8DG8LG8UG8^G8hG8qH8zH8(H88H8HH8hH8xH8H8H8H8H8LJH8ЇH8ԇH8݇H8I8(I88I8HI8XI8hI8xI8&I8-I85I8;I8CI8HI8MI8VJ8_J8f(J8l8J8tHJ8~XJ8hJ8J8uJ8J8J8wJ8J8J8J8J8J8|J8J8J8J8J8ӈJ8)K8SK8K8K8w K8(K80K88K8@K8HK8PK8XK8ˆ`K8LjhK8̈pK8шxK8ֈK8] K8K8nK8!K8{K8%K8L8L8L8L8 L8(L80L8@L8HL8PL8XL8`L8hL8pL8xL8L8L8L8L8L8L8jL8vL8qL8L8L8;L8M8M8M8M8 M8(M80M88M8@M8 HM8PM8$XM85`M8HhM8UpM8lxM8M8M8M8M8M8M8M8M8M8M8.M8DM8WM8kM8M8M8N8N8N8N8 N8(N80N88N8@N8HN8UPN8XN84`N8,hN8NpN8FxN8hN8`N8N8{N8N8N8N8N8N8N8N8N8N8N8N8N8&O8vO8BO8UO8i O8x(O80O88O8@O8HO8PO8XO8`O8hO8pO8xO8%O8>O8WO8aO8kO8uO8O8O8O8O8O8O8O8O8O8O8P8JP8VP8QP8 P8(P8[0P8`8P8e@P8HP8PP8XP8D`P8`hP8jpP8xP8!P8 P8'P8P8P8%P8/P85P8=P8EP8HP8KP8UP8gP8(P8pP8~Q8Q8Q8Q8# Q8#(Q8#0Q88Q8@Q8HQ8PQ8XQ8`Q8:hQ8:pQ8xQ8Q8AQ8Q8Q8#Q87Q8>Q8CQ8"Q8GQ8HQ8OQ8WQ8\Q8jQ8nQ8{R8R8R8R8 R8(R80R88R8@R8HR81PR8MXR8*`R8[hR8kpR8xR8R8R8R8R8R8R8R8R8R8R8R8R8R8R8}R8"R8VS8'S8,S8qS8  S81(S8H0S8P8S8b@S8iHS8zPS8XS8<`S8hS8ZpS8xS8%S8S8S8S8S8S8S8S8$S8S8-%S85%S8S8(S8S8ŜS8T8T8T8T8 T8(T80T88T8@T8HT8PT8 XT8`T8~hT8pT8xT8T8"T8)T80T89T8DT8OT8[T8T8T8gT8jT8}T8mT8pT8sT8ŪU8vU8yU8|U8 U8(U80U88U8@U8HU8PU8XU8`U8hU8pU8xU8U8U8U8U8U8U8U8U8U8U8U8U8U8U8U8U8V8V8V8V8 V8(V8 0V8 8V8 @V8 HV8PV8>%XV8 `V8 hV8( pV8xV80 V8V8Z%V8< V8V8 V8B V8H V8N V8U V8\ V8d V8m V8t V8V8{ V8 W8 W8 W8W8  W8 (W8 0W8 8W8 @W8 HW8PW8XW8͙`W8hW8pW8 xW82W8AW8RW8^W8lW8zW8 W8 W8!W8 !W8!W8"!W8,!W88!W8W8 W8)X8C!X8L!X8ؙX8 X8(X8U!0X8^!8X8q@X8HX8PX8g!XX8l!`X8!hX8!pX8!xX8!X8X8œX8X8X8;X8X8X8!X8!X8!X8dX8!X8!X8!Y8!Y8!Y8!Y8! Y8"(Y8"0Y8"8Y8@Y8"HY8"PY8HXY8`Y8hY8pY8xY8&"Y8/"Y89"Y8YPY8 Y8Y8C"Y8I"Y8S"Y8Y"Y8`"Y8h"Y8Y8p"Y8Y8v"Y8Z8Z8UZ8MZ8" Z8}"(Z8"0Z8"8Z8"@Z8"HZ8"PZ8"XZ8"`Z8"hZ8"pZ8"xZ8"Z8"Z8"Z8"Z8"Z8"Z8"Z8"Z8"Z8UZ8"Z8"Z8^Z8"Z8hZ8"Z8r[8#[8|[8 #[8 [8#([80[8#8[8#@[8#H[8#P[8##X[8'#`[8+#h[8L$p[8/#x[83#[88#[8@#[8H#[8Q#[8O#[8[8X#[8c#[8J[8V[8Q[8[8[8[[8`[8e\8\8\8\8D \8`(\8j0\88\8!@\8 H\8'P\8X\8`\8%h\8/p\85x\8=\8E\8H\8K\8n#\8t#\8~#\8,\8#\8#\8#\8#\8#\8#\8#\8\8]8#]8#]8#]8 ]8:(]8:0]88]8#@]8AH]8#P]8#X]8#`]87h]8>p]8Cx]8"]8G]8H]8O]8#]8#]8#]8#]8#]8$]8]8<#]8L#]8]8 $]8 $]8$^8"$^8!$^8^8+$ ^84$(^8=$0^88^8@^8H^8>P^8H$X^8P$`^8Z$h^8b$p^8j$x^8p$^8=^8v$^8{$^8$^8$^8}^8"^8V^8'^8,^8q^8 ^8$^8$^8$^8$_8$_8z_8_8< _8(_8$0_88_8%@_8H_8P_8X_8`_8h_8p_8$x_8$_8_8-%_8$_8$_8$_8_8Ŝ_8_8_8_8_8_8_8_8_8`8`8`8 `8 `8~(`8$0`88`8@`8"H`8)P`80X`8$``8%h`8Op`8[x`8`8`8%`8%`8"%`8*%`82%`8;%`8C%`8H%`8O%`8W%`8_%`8g%`8p%`8y%`8%a8%a8%a8%a8% a8%(a8%0a8%8a8%@a8%Ha8%Pa8%Xa8%`a8ha8pa8xa8a8a8a8a8a8a8a8a8a8%a8a8a8a8a8 a8 a8 b8 b8b8>%b8  b8 (b8( 0b88b80 @b8Hb8Z%Pb8%Xb8`b8 hb8B pb8H xb8N b8U b8\ b8d b8m b8t b8b8{ b8 b8 b8 b8b8%b8%b8b8%b8&c8 &c8&c8&c8%& c8.&(c87&0c8@&8c8H&@c8Q&Hc8\&Pc8f&Xc8o&`c8x&hc8&pc8&xc8&c8&c8&c8&c8&c8&c8&c8&c8&c8&c8&c8&c8&c8&c8'c8'c8qd8d8d8g!d8' d8'(d8'0d8"'8d8*'@d83'Hd8œ`d89'hd8Upd8ޏxd8d8d8d8d8C'd8H'd8d8L'd8d'd8Q'd8V'd8['d8_'d8c'd8h'd8m'e8r'e8w'e8'e8L e8|'(e8Œ0e8'8e8'@e8'He8'Pe8'Xe8'`e8'he8'pe8'xe8'e8'e8)e8'e8'e8'e8'e8'e8'e8'e8'e8'e8'e8'e8'e8(e8(f8 (f8(f8(f8( f8$((f8*(0f80(8f86(@f8<(Hf8B(Pf8H(Xf8N(`f8T(hf8Z(pf8`(xf8f(f8l(f8r(f8x(f8~(f8(f8(f8ʒf8(f8(f8f8888(8@8X8#p808?8L8_Р8l8|8808H8`8x8888ء888  8-88:P8Hh8[8i8{8Ȣ8888(8@8X8p888)8?8Hȣ8?У8h8\8_8r8v8é8(8é08@8\H8X8`8p8x88E88é88@8H8P8"X8`8h8p8x8 888 8 88*82888>8:8D8M8Q8Y86P8b8j8"8q8` 8w(808|H8+(8+8+8+8+8Q08h8`H8Cf8@f8f8f82g8g88g8Lg8= g8(g8s0g88g8Hg8"Xg8"hg8"xg8"g8g8 g8g8g8@g8g8g8Gh8h87(h848h8'Hh8Xh8hh8xh8nh8nh8h8l8j8Uj8j8bj8j8j8k8zk8k8k8i k8/(k80k8:8k8#@k8 Hk8Pk8wXk8`k8hk8fpk8xk8}k8Xk8k8k8 k8@k8jk8k85k8k8k8k8]k8k8888888ȵ8е8ص888888888 8(80888@8H8P8X8`8h8p8x8k8k8jl8Pl8Ql8l8d l8(l80l88l8A@l8rHl8Pl8uXl8`l8hl8pl8xl8l8l8Hl8 l8$l8l8Rl8Dl8 l8Ul8l8l8\l8l8l8Lm8nm8m8m8 m8&(m80m88m8@m8Hm8$Pm8Xm8`m8hm8tpm8xm8m8xm8m8m8:m8m8m8/m8m8m8m8m8#m8 m8m8m8n8n8n8n8 n8(n8 0n88n8@n8Hn8Pn8Xn8"`n8Zhn8pn8Dxn8^n80n8Xn8n8n8n8n8xn8zn8n8n86n8n8n8Rn8n8go8o8o8o8 o8(o80o898o8?@o8PHo8Po8(Xo8/`o8ho8Tpo8xo8`o8o8o81o8,o8Oo8o8o8?o8=o8o8o8o8o88X88K08H8888ȡ8888(8@8X8p8`8x8888ؠ88?8 888P8Fh8F8188Т88)8808H8`8x8b888أ8P878 888P8h8 88.888(8@8`8mh88 8(8h8v8J888j(8881x888n8(88h8g8188M08'88N`8Dh8x8888c 8P(8!h888K88B8 8(808`8Eh8888 8(8h8?8L88ȭ8ح88888888 8(8@8X8h888Ю8888x888888888ȯ8Я888@8H8P8X8`8h8p8x8888888Ȱ88ȱ8б8ر8(808`8h88в8ز888888888 8(8@8H8p8x8888888888г8س88888888 8(808888@8h8p88 888P8h888888ظ88888880888X8`8Э8p8x888(8888888888 8(80888P8p8x8888888888@8H8p8x88888P8X8h8@8H8P8X8`8h8p8x88888ش88888 8(80888@8H8P8X8`8h8p8x888888888888ȶ8ж8ض8888888 888H8P8X8`8x8888888888ȷ8з8ط8888(808@8H8X8`8p8x88888ȸ8и888 8h8880888H88 8P8d`8888 88 8888Ȯ8خ888-8 80888@8H8P8X8`8h8p8h88[د8 8D8D8D8D8Dа8D88888 8(808ذ8@8H8TX8`8888888@8H8P88M8P8X88M8M88Ȳ80888`8ȳ8A8@88888ȴ8д88l8l88(8O08O8 88(888`808`88Y888.88Z8ȹ8Lй8(ع88I8I8I88b838888h 86(808 88@8}H8P8X8h8p8Sx8K8888,8,8e8y8Ⱥ88[к8[غ8`Ⱦ8`8`858888888u 8u(8u08u88@8H8P8X8`89h8p8x8388p8 8\8 82888>Ȼ8Sл81ػ8w8*88888888+ 8(8A08A88A@8AH8P8X8 `8h8p8x8d8888888ȼ8м8ؼ88q8R88888R888O 8O(890888@8#H8P8X8`8th8qp8@x888q8q88-88u8u88NȽ8Nн8ؽ88h8 818+888 8(80888@8H8}P8X8`8oh8p8^x868T8>888 8ؾ88G8G8о888888+8B 8(888F@8H8LP8%X82h8p8x8b88888E88m8m88cȿ8п8ؿ81888j8g8w88K8 8(808bH8b88@8P8>X8`8dh888p8x8w8h8 8 8888=8=8R88W8888888 8O(808~88@8H8P8X8!`8!h8p8x888888888888888888888 8(8>0888@8H8kX8k`8kh8k8kP8mp8x8888X88888 88K88J8W888B888 8n(8A0888z@8zH8P8X8x88`888h8p88888J8J8H88888888888 8(80888@8H8P8X8`8h8p8x8888888888P8P8P8~88v8 8888] 8F(8`8Rh8H8(8p808x888Eh8EH8E8!p8!P8!8YX8Y88m8Cp8C88x88888^8^888X8888`8888h8888p88888888888;8@8CX88888x8T8`88h88D8%808l8-8-8  88888+8888(80888V@8H8~P8HX8`8h8p8x8886888h88 88-88G8 8=(80888s@8H8LP88888p888`8p8 p8(p80p88p8@p8Hp8{Pp8Xp8`p8hp8Ipp8cxp8"p8p8p8p84p8wp8kp8zp8p8 p8p8p8p8p8p8p8aq8q8q8eq8 q8(q80q858q8@q8'Hq8xPq8Xq8b`q8 hq8pq8xq8q8q8q8Qq8q8q8q8q8q8wq8q8q8q8q8;q8q8r8r8 r8r8 r8(r8|0r88r8@r8Hr8 Pr8hXr8``r8 hr8"pr8 xr87r8r8r8r8|r8r8r8r8r8r8r8<r8Gr8r8kr8r8bs8s8s8s8 s8(s880s8W8s8@s8Hs8#Ps8Xs8{`s8hs8ps8Rxs8as8s8s8s85s83s8s8s8s8Ms8s8s8s8s8Ds8s8t8{t8*t8t8] t8(t80t8C8t8@t8Ht8Pt8Xt8`t8ht8pt8#xt8mt8t8t8t8Wt8t8*t8t8~t8t8t8!t8t8t83t8"t8 u8 u8u8u8 u82(u80u88u8k@u8Hu8#Pu8$Xu8`u8hu8Kpu8%xu8u8u8u8&u8u8'u8.u8au8fu8&u8]u8u8(u8-u8u8u8@v8Bv8v8v8f v8(v8]0v88v8@v8Hv8)Pv8xXv8*`v8hv8pv8xv83v8v8v8v8+v8"v8,v8-v8v8v8+v8.v8(v8v8v8v8/w8Jw8w8w8& w80(w8l0w868w8@w8Hw8YPw8Xw81`w8hw82pw8xw8cw8vw8Nw83w8w8w8~w84w8 w85w8w8w8ow8w86w8w8=x8x8x8x87 x8(x8Z0x888x8@x8Hx89Px8}Xx8:`x8\hx8;px8xx8<x8Qx8x8fx8=x8 x8x8x8x8x8x8>x8x8x8x8x8y8ay8y8?y8 y8(y8 0y88y8@@y8AHy8lPy8BXy8`y8hy8py8xy8y8sy8Cy8y8Dy8y8 y8'y8y8y8y8y8Ey8y8y8y8z8!z8z8tz8F z8(z80z88z8G@z8Hz8gPz8Xz8_`z8Hhz8>pz8nxz8z8Iz8z8Jz8z8oz8Fz8 z8z8z8z89z8z8z8Kz8pz8L{8{8s{8:{8 {8({8M0{8N8{8@{8H{8OP{8PX{8T`{8h{8p{8Qx{8{8{8s{8{8V{8S{8T{8{8{8U{8{8V{8W{8p{8{8{8C|8s|8|8J|8X |8}(|8A0|8Y8|8Z@|8[H|8>P|8X|8`|8|h|8p|8_x|8Y|8|8!|8|8|8|8|8|8(|8|8_|8]|80|8]|8|8Z|8)}8^}8}8}8_ }8`(}8^0}8a8}8@}8cH}8P}8:X}8|`}8h}8p}8x}8d}8f}8e}8}8q}8_}8}8u}8{}8f}8g}8o}8/}8h}8'}8}8~8~8i~8~8C ~8(~8z0~88~8j@~8kH~8P~8xX~8l`~8,h~8mp~8ax~8n~8~8~8~83~8i~8~8,~8~8~8'~8~8~87~8o~8~8p88888 8(808F88q@8rH8|P8X8`8h8qp8x8s8d88t8u888v8888j8A8x8w888y8l8z8 8e(8B08/88{@8XH8P8X8|`8h8p8x888}8~84888r8~8Ȁ8Ѐ8^؀8`88888888t 8W(80888@8qH80P8JX8`8h8p80x888888,888Q8ȁ8Ё8؁8#8888t8888! 8?(8v08@88<@8H8P8X8`8h84p8x888I8?88898 88Ȃ8kЂ8؂8888(88888 8(8=0888@8H8P8NX8`8mh8p8x88488E8888y88ȃ8KЃ8؃888M88 8d888 8(8X0888i@8H8vP8qX8p`8*h8p8x8888K88888*8"Ȅ8KЄ8؄888888u888 8(8}0888k@8H8uP8X8r`8h8p8x888888G888p8Gȅ8Ѕ8؅88>888$8888S 8(80888@8H8P8NX8`8h8p8x88p88[88+888^8Ȇ8І8؆88 88h8)8O888c 8,(80888$@8H8P8X8`8th8Yp8x8w8F888%828H8-88ȇ8Ї8؇888888W8.8o8( 8(80888@8H8P8X8`8h8p8Px88888j8=8888Ȉ8Ј8b؈888Z8U888[8E8 8H(808488@8H8P8X8{`8h8ep8x8z8f888&88888ȉ8%Љ8؉8888:8I888<8 8(80888@8kH8;P8fX8`8h8p8x8.8888888888Ȋ8Њ8؊88888t8888 8&(8c0888@8xH8P8vX8`8h8gp8gx88Q888488888<ȋ8Ћ8؋888888888 8(80888G@80H8P8X8``85h8p8x88888888y88Ȍ8MЌ8،8888888}8$8* 8(8u08n88%@8CH8P8X8`8h8Zp8\x88888888858ȍ8Ѝ8<؍8V8Y88u88888[ 8\(808X88@8H8P8X8`8h8Tp8x8D88[88;88888oȎ8hЎ86؎88y8Y88S87888 8(8|0888&@8H8P8X8`8h8p8{x888r888S8888ȏ8Џ8؏8H8l8)88E8"888 8(8!0888o@8iH8P8X8`8h8:p8`x88888e88888iȐ8А8ؐ8Q8878e888y8S8 8(80888@8H8P8-X8`8h8np8x88878888888ȑ8Б8ؑ8O8888HHM5Ht H5ґ5%ԑ5@%ґ5h%ʑ5h%‘5h%5h%5h%5h%5h%5hp%5h`%5h P%5h @%z5h 0%r5h %j5h %b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڐ5h%Ґ5h %ʐ5h!%5h"%5h#%5h$%5h%%5h&%5h'p%5h(`%5h)P%5h*@%z5h+0%r5h, %j5h-%b5h.%Z5h/%R5h0%J5h1%B5h2%:5h3%25h4%*5h5%"5h6%5h7p%5h8`% 5h9P%5h:@%5h;0%5h< %5h=%5h>%ڏ5h?%ҏ5h@%ʏ5hA%5hB%5hC%5hD%5hE%5hF%5hGp%5hH`%5hIP%5hJ@%z5hK0%r5hL %j5hM%b5hN%Z5hO%R5hP%J5hQ%B5hR%:5hS%25hT%*5hU%"5hV%5hWp%5hX`% 5hYP%5hZ@%5h[0%5h\ %5h]%5h^%ڎ5h_%Ҏ5h`%ʎ5ha%Ž5hb%5hc%5hd%5he%5hf%5hgp%5hh`%5hiP%5hj@%z5hk0%r5hl %j5hm%b5hn%Z5ho%R5hp%J5hq%B5hr%:5hs%25ht%*5hu%"5hv%5hwp%5hx`% 5hyP%5hz@%5h{0%5h| %5h}%5h~%ڍ5h%ҍ5h%ʍ5h%5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڌ5h%Ҍ5h%ʌ5h%Œ5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڋ5h%ҋ5h%ʋ5h%‹5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڊ5h%Ҋ5h%ʊ5h%Š5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ډ5h%҉5h%ʉ5h%‰5h%5h%5h%5h%5h%5hp%5h`%5h P%5h @%z5h 0%r5h  %j5h %b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڈ5h%҈5h %ʈ5h!%ˆ5h"%5h#%5h$%5h%%5h&%5h'p%5h(`%5h)P%5h*@%z5h+0%r5h, %j5h-%b5h.%Z5h/%R5h0%J5h1%B5h2%:5h3%25h4%*5h5%"5h6%5h7p%5h8`% 5h9P%5h:@%5h;0%5h< %5h=%5h>%ڇ5h?%҇5h@%ʇ5hA%‡5hB%5hC%5hD%5hE%5hF%5hGp%5hH`%5hIP%5hJ@%z5hK0%r5hL %j5hM%b5hN%Z5hO%R5hP%J5hQ%B5hR%:5hS%25hT%*5hU%"5hV%5hWp%5hX`% 5hYP%5hZ@%5h[0%5h\ %5h]%5h^%چ5h_%҆5h`%ʆ5ha%†5hb%5hc%5hd%5he%5hf%5hgp%5hh`%5hiP%5hj@%z5hk0%r5hl %j5hm%b5hn%Z5ho%R5hp%J5hq%B5hr%:5hs%25ht%*5hu%"5hv%5hwp%5hx`% 5hyP%5hz@%5h{0%5h| %5h}%5h~%څ5h%҅5h%ʅ5h%…5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڄ5h%҄5h%ʄ5h%„5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڃ5h%҃5h%ʃ5h%ƒ5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڂ5h%҂5h%ʂ5h%‚5h%5h%5h%5h%5h%5hp%5h`%5hP%5h@%z5h0%r5h %j5h%b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ځ5h%ҁ5h%ʁ5h%5h%5h%5h%5h%5h%5hp%5h`%5h P%5h @%z5h 0%r5h  %j5h %b5h%Z5h%R5h%J5h%B5h%:5h%25h%*5h%"5h%5hp%5h`% 5hP%5h@%5h0%5h %5h%5h%ڀ5h%Ҁ5h %ʀ5h!%€5h"%5h#%5h$%5h%%5h&%5h'p%5h(`%5h)P%5h*@%z5h+0%r5h, %j5h-%b5h.%Z5h/%R5h0%J5h1%B5h2%:5h3%25h4%*5h5%"5h6%5h7p%5h8`% 5h9P%5h:@%5h;0%5h< %5h=%5h>%5h?%5h@%5hA%5hB%5hC%5hD%5hE%5hF%5hGp%5hH`%5hIP%5hJ@%z5hK0%r5hL %j5hM%b5hN%Z5hO%R5hP%J5hQ%B5hR%:5hS%25hT%*5hU%"5hV%5hWp%5hX`% 5hYP%5hZ@%~5h[0%~5h\ %~5h]%~5h^%~5h_%~5h`%~5ha%~5hb%~5hc%~5hd%~5he%~5hf%~5hgp%~5hh`%~5hiP%~5hj@%z~5hk0%r~5hl %j~5hm%b~5hn%Z~5ho%R~5hp%J~5hq%B~5hr%:~5hs%2~5ht%*~5hu%"~5hv%~5hwp%~5hx`% ~5hyP%~5hz@%}5h{0%}5h| %}5h}%}5h~%}5h%}5h%}5h%}5h%}5h%}5h%}5h%}5h%}5hp%}5h`%}5hP%}5h@%z}5h0%r}5h %j}5h%b}5h%Z}5h%R}5h%J}5h%B}5h%:}5h%2}5h%*}5h%"}5h%}5hp%}5h`% }5hP%}5h@%|5h0%|5h %|5h%|5h%|5h%|5h%|5h%|5h%|5h%|5h%|5h%|5h%|5hp%|5h`%|5hP%|5h@%z|5h0%r|5h %j|5h%b|5h%Z|5h%R|5h%J|5h%B|5h%:|5h%2|5h%*|5h%"|5h%|5hp%|5h`% |5hP%|5h@%{5h0%{5h %{5h%{5h%{5h%{5h%{5h%{5h%{5h%{5h%{5h%{5h%{5hp%{5h`%{5hP%{5h@%z{5h0%r{5h %j{5h%b{5h%Z{5h%R{5h%J{5h%B{5h%:{5h%2{5h%*{5h%"{5h%{5hp%{5h`% {5hP%{5h@%z5h0%z5h %z5h%z5h%z5h%z5h%z5h%z5h%z5h%z5h%z5h%z5h%z5hp%z5h`%z5hP%z5h@%zz5h0%rz5h %jz5h%bz5h%Zz5h%Rz5h%Jz5h%Bz5h%:z5h%2z5h%*z5h%"z5h%z5hp%z5h`% z5hP%z5h@%y5h0%y5h %y5h%y5h%y5h%y5h%y5h%y5h%y5h%y5h%y5h%y5h%y5hp%y5h`%y5h P%y5h @%zy5h 0%ry5h  %jy5h %by5h%Zy5h%Ry5h%Jy5h%By5h%:y5h%2y5h%*y5h%"y5h%y5hp%y5h`% y5hP%y5h@%x5h0%x5h %x5h%x5h%x5h%x5h %x5h!%x5h"%x5h#%x5h$%x5h%%x5h&%x5h'p%x5h(`%x5h)P%x5h*@%zx5h+0%rx5h, %jx5h-%bx5h.%Zx5h/%Rx5h0%Jx5h1%Bx5h2%:x5h3%2x5h4%*x5h5%"x5h6%x5h7p%x5h8`% x5h9P%x5h:@%w5h;0%w5h< %w5h=%w5h>%w5h?%w5h@%w5hA%w5hB%w5hC%w5hD%w5hE%w5hF%w5hGp%w5hH`%w5hIP%w5hJ@%zw5hK0%rw5hL %jw5hM%bw5hN%Zw5hO%Rw5hP%Jw5hQ%Bw5hR%:w5hS%2w5hT%*w5hU%"w5hV%w5hWp%w5hX`% w5hYP%w5hZ@%v5h[0%v5h\ %v5h]%v5h^%v5h_%v5h`%v5ha%v5hb%v5hc%v5hd%v5he%v5hf%v5hgp%v5hh`%v5hiP%v5hj@%zv5hk0%rv5hl %jv5hm%bv5hn%Zv5ho%Rv5hp%Jv5hq%Bv5hr%:v5hs%2v5ht%*v5hu%"v5hv%v5hwp%v5hx`% v5hyP%v5hz@%u5h{0%u5h| %u5h}%u5h~%u5h%u5h%u5h%u5h%u5h%u5h%u5h%u5h%u5hp%u5h`%u5hP%u5h@%zu5h0%ru5h %ju5h%bu5h%Zu5h%Ru5h%Ju5h%Bu5h%:u5h%2u5h%*u5h%"u5h%u5hp%u5h`% u5hP%u5h@%t5h0%t5h %t5h%t5h%t5h%t5h%t5h%t5h%t5h%t5h%t5h%t5h%t5hp%t5h`%t5hP%t5h@%zt5h0%rt5h %jt5h%bt5h%Zt5h%Rt5h%Jt5h%Bt5h%:t5h%2t5h%*t5h%"t5h%t5hp%t5h`% t5hP%t5h@%s5h0%s5h %s5h%s5h%s5h%s5h%s5h%s5h%s5h%s5h%s5h%s5h%s5hp%s5h`%s5hP%s5h@%zs5h0%rs5h %js5h%bs5h%Zs5h%Rs5h%Js5h%Bs5h%:s5h%2s5h%*s5h%"s5h%s5hp%s5h`% s5hP%s5h@%r5h0%r5h %r5h%r5h%r5h%r5h%r5h%r5h%r5h%r5h%r5h%r5h%r5hp%r5h`%r5hP%r5h@%zr5h0%rr5h %jr5h%br5h%Zr5h%Rr5h%Jr5h%Br5h%:r5h%2r5h%*r5h%"r5h%r5hp%r5h`% r5hP%r5h@%q5h0%q5h %q5h%q5h%q5h%q5h%q5hп%q5h%q5h鰿%q5h頿%q5h鐿%q5h逿%q5hp%q5h`%q5h P%q5h @%zq5h 0%rq5h  %jq5h %bq5h%Zq5h%Rq5h%Jq5hо%Bq5h%:q5h鰾%2q5h頾%*q5h鐾%"q5h逾%q5hp%q5h`% q5hP%q5h@%p5h0%p5h %p5h%p5h%p5h%p5h %p5h!н%p5h"%p5h#鰽%p5h$頽%p5h%鐽%p5h&逽%p5h'p%p5h(`%p5h)P%p5h*@%zp5h+0%rp5h, %jp5h-%bp5h.%Zp5h/%Rp5h0%Jp5h1м%Bp5h2%:p5h3鰼%2p5h4頼%*p5h5鐼%"p5h6逼%p5h7p%p5h8`% p5h9P%p5h:@%o5h;0%o5h< AWAVI1AUIATEULSHH(Ht$HDHIuBHLHD$ALM}<[D$AA$OAt*Ht$Ll1HHLjHI`H@Hu( LI`HPI`HBH@(@ LHHBIXM+}HILzHHRIUHH HIH IM HH HIH1IUHI`1IXHT$I`IUH@HuQI`Htx uH@H@Ht HH@(HuLH5iH1L*IXI+ULH HHQHHRIUHH HIH IM HH HIHIUHI`IX1HLOHIuL$H5AIL1ZHHLHuL$H5AIIL$CtȅCuHL HL̺H(L[]A\A]A^A_AVAUIATIUSHH> ~(HT$HT$HCu H=G5t(u ))HԊDtHtH=HT$HHHT$uHHL1I$ HH9w 1Ҁ;(H* H"G5DtHH5 G5DtHH9rI$P@<u&HHt@ u)Qu A$uHF5 NxHF5 5ƒu S? HF5  HLI$ HHt@ tI$P@<tQuA$tHI5,HI$P@<u.I$ HHt@ u*Qu A$uUHE5OExHE55ƒu U? HE5 HLCM$ tQIHt@ tI$P@<tAQuA$tEH H5HIH9w },UHD5DtHH)1HމLIHt@ tI$P @<t1AQuA$ A HHLHtH@xuHxuH5zLL1H[]A\A]A^UHSHHdH%(HD$1Ht HHtNIH HC5H㊀ȋ€t$^@@tH@L$D$$D$"HHH5WHH1'A\AVAUATIUH1SHH dH%(H$1}$@HHt\z uHBHtHxt1 Ht7A t2< HAuHB] t HRHDHt1Ҁ8;€<*uE1Ll$LL$AHLp}$IupMuH fxjfqPHB5DXLHFH HH BK8( HHl$1LH߉fH|,:HE|,:HD$D,H HT$LHLcDrt1HHJH HHcDH@#@H @KFhH LA>(* uH HHt@ tHP @<t1Qu A HLH~Ht3HPzuWHzJH$dH3<%(Mu:LH覘IH HL)HxMt@ v|H HHt@ tHP @<t1Qu T$LHHiA>=;A~>0Hz?tH []A\A]A^AWEAVAAUAATEUSHHdH%(HD$1詗HHP@<u+H HHt@ u2Qu u UH?5Du$EEx1AVMAUIATIUHHSH4H5wƃMMLHH1 H45H8t Hd65tH^558Hh5H=Z5UH)HHw]H$45Ht]@H15H=*5UH)HHHH?HHu]H?85Ht]H@= 5u'H=g85UHt H=/5h]5@f.H=@4t&Ho75HtUH=*4H]WKf.F#E}V$~A%utG f%f@~@t(t t1D#} !ufDf.}\wfD/w@f.G %=t%~.=t~E=t=$t 1@t;@=t=t=t1=uf.HH9r w!H1H9WC@f.V t.Huf.v1fF"tHN(fDQ tttH;N0uHHIHuHv0V n@F"tHv(V QUSHHF %=IRGDtuDtu F"1H[]==tjV==uHn(HH]t&HuYHF(HXH9tXH@H9H[]@=t9=rHv(D=q=}=KH[]@at~)ct1#DtӃ+t1 Uv1f-v1Df.ATHUSHtdfF HV"teK %=t{=t\u7t2fft&=t []A\fDEtf[]A\fDtH^(S"댐uۀ{#y1@HC(HHpHAHC(HH@Hp1uD tH5HHy1DATAUHSHHFAt,HvPHt#SXHtH tu=H9Et1CAtH{PH[]A\颣fH[]A\:HHHtHcHHP Hy΃H4H9t"u{HDžpHHPHHx HD$HD$H@ (DF"tfATUSH^(HtUHAfHHH[Ht4K  wLHt1HHfD[]A\fUHSHHH~0kH{(HC0ZH{HHtHt Ht@HsPHH[]@f.UHSHHHV(Ht+H5FH1ZHHc#H[]@HVHGHfATIUSHLHHA1H[H]A\AWAVAUATUHSHH8dH%(HD$(1F %=xy[!R=uHV0B f%f5DC"t&H[(HtfHHeH[HuHD$(dH3%(H8[]A\A]A^A_f==.HFHt@ f%f-fm[HKHAHJ@ f%Mff-f=#HPQ$HD`$P$H+E1$HEE1HHPD`$fDF#t @H{(HIC f%f=t6HS(B G<H(H9HEJ4HtF~FcHC(H HEHS(JHEJH HC(Lc-HPfDHvHHFF# # HS(HEL$A|$ ID$H@HrHxgH1LHHAInHCL#H1U(HEHJ4HEJH Hs(HFFH.f~#HF(H@@ f%f=HV0B f%f=HB(P ff t"fpH@0P ff YHPH@HyL0AF %@=@*ID$H LHD$$ E11AHH0zHIHH@Hx HC(H@H@(L`MHD$ HD$Md$MAD$ f%fuIt$(HMl$(F HHHHL$ IuHFA HF EIE1HRHr $HPHwIE1H@t$HH@HRHDHHt xItLL@=HLb(MOLj(AL$ % = tjweu`_I$HPHT$ ID$Hށ E1HEAT$IƅAT$u LHMu{#8HS(B f%f="HR(B f%f  HRH@H,L AD$ %@=@I$D$H ^JHD$$ E11AHH0+HIHH@Hx IuF fHH@HD$ IMHAA L$ tIE1A HHRHr $HYH(I$E1H@t$HH@HRHDHHt xItLLIUH5?H1T@HHHHEJ` _HEJ4F u1 F HEJH lHRHGL,MeHHEJ4F LH臘HT$ "LH}AL$ HT$ IHT$ "HWIMIT$HEL,IuiHT$"H&IuHL$ gATUSHH?HCpHPHSpHHj(D`Ht@HC H)H~HSIcH,HSHH[]A\HHH}HSMcJDH[]A\@AUIATIUHSH:HH蝩HpHHDID$HH@H HH[]A\A]Ÿf~NL~DB~8HLH,fDH=F  HLHID$H@H[]A\A]f.H=yFHXtH`F-H1,HLH:H=FrHXtHE-H1ܥHLH*CDSH0mP fʏfP H.$5Hx@"@#HX(HPHHHSK"0HHPS HCff t[ÐK"[f.AWAVAUATUSHHF(HHD$0IL=~$5c@Pf;I@HL$H@HQHIcXHH9P gHP HD$@"u~HD$H@HHD$HD$@ f%HA@tfzHD$HP(IFHI9hHIcX;PHPHD$@"tHD$L`(MpAD$ f%HA@t?fPfNI@IT$H@HIcXHH9P tsHP AD$"uMd$MuftRff=Pff u+HD$H@HHIVHI;h@H[]A\A]A^A_@Il$(HurfHmH\E f%HA@tKf#PfI@HUH@HIcXHH9P mHP fE"tLm(Mu|@MmMkAE f%HA@tBfPf{I@IUH@HIcXHH9P HP AE"tI](HufDH[HsC f%HA@tCfPfwPI@HSH@HIcXHH9P iHP DC"tHLtFfDf6fft~f=txPfvof HCHHtIVHI;hHIcX;PHPt@HS(IFHI;hufDHC(@ f%f:Dffft~f=txPfvof eIEHHxIVHI;hCHIcX;P-HPD@IU(IFHI;hufDIE(@ f%f fftqf=tkPfvbf HEHHOIVHI;hHIcX;PHPHU(IFHI;hudHE(@ f%fIf?ftyf=tsPfvjf  ID$HHIVHI;hHIcX;PHPrIT$(IFHI;hufDID$(@ f%f:@HD$H@(@ f%f"1~fAWAVAUIATUSHHH fMItpupNL55A4@LE11fLL H 貖H ftPH[]A\A]A^A_ÐtL8MtA<$$uA|$_uA|$uL0L@H0HJ\t fJ\H[]A\A]A^A_AA t _WEE4AfH=HML$EEHDA@@A$H53H$H1͹HHH ΃@A|$? @AD `IH=LEfH5=LDLEH1IDHHH H=<T$ L$9HL$T$ |Ƀ @fA<$$IIt$LH AL$[H5<21軬f.AUATUHSHHV dH%(HD$1%$#  a} HvHHHHHCHH HtCHS8H$HHH0~ &H(E1HHH HH0ϏHsHtH螻HCHD$dH3%( H[]A\A]==Ht>=It =KHCfDtHs(HtFnFHsHC(HMHF@=D|^>wSC"C#Hs(HHHC(=KDC"H 5HH=5H9<@ffFHs(E1E1HE[El$EAEAD$cA2LH薐"!gHvH螯fFtFt_HH H興H H$H@֏KHh[LHEHHH H$HN@H{(HC([f.HcHC(fDHEHHs(L$MAD$AAD$Hs(fDH萇LHcAVHAUATUSHF!tH[]A\A]A^@Dn IfAF#@t$fAfAfAJI$xHtHLC"t Hs(Hu_@AIfvfEuCf-fw HL HL!C!IC![]A\A]A^fDHHnLQHuf.fAsAPfGH-5HuPHCHLpLspuMHL[]A\A]A^H6H= -ƹ1DH6H=,ƹ1(SfF Hu[f+C Hf%fC H5HSHHC[fHH=E50uHH&6H=Q,ƹC1諫f.HH=5耩uHH5H=1,ƹK1kf.ATUHSHHt []A\@H^(HtWHIHtUHEHsHtHHt HH[HsHuH+HE[]A\@LpfDHuHHWDUHSHH蟿HPHpHHHH[]wHHtN"fAVIAUATAUSDoH9LQAI +LI HtHuxHI( I HtRL肌xDHcHDI( H@H (HH@ tH@HtDLЃHu[]A\DA]A^@HtHHhH^HHH0^f.SH臿H( HH[鄅@AUAATLc`UHSHH@ DfDk"ADk#f% fC H5JHCt K@@C@$ C@H HHHPHBHIHTH2H)HPHs8H@Ht B< He5HHJH[]A\A]uzC@$@C@iDH(H2E1E1H菎Ht0P tDk@H@ A Dk@H(H?2E1E1H9HP |H@ S@ ЉC@@H H(H:H H軉HHC8H H@H fDHHA wDHHA DHH言\HH萀HH@H5H5'HJ1t@ATUHSLf(H8H趤HHGLHHt@HH8HL0H HHǀH @K[]A\鋦f.AUAATUHSHHDDLn(H5 H@HLH0薫DHH[H]A\A] f.AWAVAUEATIUHSHH(F HT$LD$tT< H!Mt$HRMIH8tBD#H軗H([]A\A]A^A_@E1E1H8uHtD1 uL;|$uLHLWu뮐A cLD$HLLH荰m}H8H|$HD$HHT$H1AHHD$ҥHt$H.HٳHD$HtHt$H.HH1覍AL$ 8 LLHHt$HJ/HH1eL|$Hp.AHLsHHT$DHH衛H.HLH1 HL$H(H[]A\A]A^A_Hih#1ьHT$MLHH* DB] HrIL$HRLt1LzMI)f.Ht$Hg-HwfHt$Hd-AHq@Ht$H>-AHI @Ht#V 1 wHB\tHB(1fD@f.AUATUSHHH F IHf%f=B1M(oC"tZHfHf HE@\SI@1LBH1BIEDHHtHK fHtJH9t5ftfuftftftf\fDH[]A\A]DH9uftf8f1H[]A\A]HC(HcHtHEH@HH@H@HtHSH@HH41HF(HHXH1H@HH@H@HtHSH@H4Hl~bLH @f.AUHIATMULSHHHt MtLHMtLHΝHtHH蹝H5*H1踚SV HHv(yHC(HCH[SHF"@F#uiF f%PfwXHN(Q Hqf¹ff wDA"u>f^|tf\&^EHF !1:f.H[N ff wF"uf^|uHN(HQ ffCt A#uHQ(B" uN"@Ðf.AWAVAUIATUHSHN Lf( F#ffF#SAD$ f%ftHH[]A\A]A^A_ÐMt$(AF %=wE#ED$#1fuHDED$#Auu ALLADƒ ̚HItAD$ It$(f%HfAD$ tF<F~Lt'Lc(MtfDLHEoMd$MuH[]A\=t/==uHs()=t=LuLc(HLnIt$Hu@胂LLfMtoF Hf%f=unHs(Hn_HC(L`MGLHmnMd$Mu&fDHPnHHPDH -H12tf.AVAUATAԉUHSH HHt C %=   X' At AVAS# t@A`EK" ЈC#f.HH[]A\A]A^MmD[]A\A]HA^@=== =uA+t AVC"@LC Hf%fC H4HHCHC(Hp(vK"c#T@_tO9A+Hs(ɉH>f==tK=tK"fAS#@D1=C"Hs0HD跘fHC(LhMDLDDH臘MmMuYfHs(ɉH_f.(C"@Hs(DH(K"@A+t"Hs(ɺHfK"f.K"xSF H t[tH^1H[fDf%fF HT4HHF\H[f% fF H4H@PHF[&fDSV H%t\: w7H4f fV H@XHF[זtH1H[C H޹f% fC Hv4H`HC~H[fAVAAUIATAUSf(MyH@ Ds"AHDs#f% IcfC H4Hc!HCH4D4Au6AuAI@Ht<(ueH4HL[H]A\A]A^HLhAtDLlHCfAIAI-HL>H4H5LH1rf1Ҿ@AWIAVAUA8McATMUHSHT$ xH@ DfT$ f% HfC H4JHCMutupS"tYMuTIAHk(Lc0thI@Ht B<0~H4HLJH[]A\A]A^A_HttLe렐tLfD1ҾLّK"MHhHC(tHC0kHLHY4H52LJ1~@HtkHtnB %9u1B"tt1HB0HHHJ0Hft@IH1_HJ(HJ0B"HfDH@H@HHA %9tIH1^@=t9A"t!HA(HBA"HQ(A"HHQ0A"@HA(H@HBHA(HPB"A"uDH@Hff.HtkHtnB %9uAq 9u;HB0Hq(HpHA0HB0A"B"A!t5A!Hc驌fH@H@HHHT$[HT$HHfAWAVAUAEATIAUSHHH $tXAtHŅt U H4fʷfU HHED}"U<HmDu@HPLxHIt MLHEHHPHHpPMHEPt=LgELHHA H衃LH'~H Hg8E$H Ht ǀHPHHp0\cHE0H81HtBBtHP1LLTIL1ҾL/HHLzHZPHE(f.AWIAVAAUA0ATMcUHSHtmH@ DfDHf% кfC H!4JHCaHC(HUHH0Ht%FFHS(HEHL8H4AO Ds"HF4Au`Au:H@Ht B< |H4HHJH[]A\A]A^A_fDHp`HCf.HH\HHRTHHHS(HEHDHHxHu4H5NHJ10sHHHADf.UHSH@ HH4$H|$dH4%(H$1H\$%D$At4_K f%f HcfK H 4HHC_tIHHL[]A\A]A^A_ADS#11LDT$ IuHS(b#fDHLTHS(J ffPB#@FpHa4H5:LH1kff.AWIAVAAUA0ATIUIcSHcH@ DfDs"A L{(Hf% AfC Hv4HHCЃC#H-4D4Au;AuFI$@Ht<(uIH4HLHH[]A\A]A^A_HLeSAtDLVHCHLoHG4H5 LH1jfATUHSF Hf%f%tHH[]A\RfHV(B f%fuրz"xо螃tH HPHDb$ttB$HF1HXHPD`$wDf.SHHv(F"uHZRH[DK#@wHC(H[@f.AWAAVAUATIUSHHtA f%f=E11ҾL)JHL-W4HcHq(ADLvMtAF f%f=sPA L5K4fHLf% fA IDy"HAI$@Ht <(sH\4I@ %9tQHL[]A\A]A^A_LHL$ZHL$qAπDa"!Al@tIuLTIGAG f%HcAD t:A$t/_AO f%f HcfAO IIG_tJ#@1iH\4H55HH1dHt#SH"MHH[a @1DAWIAVAUATIUHSHdH%(H$1F f%Pfv1f!u"IZ0IR(HHBH9uHBIR0`AD$ f%#fQfE1AB f%fYAD$B} L1H'I¾8LT$[I@ LT$HLf%fAE H4HIEKIE(AM"LT$ |EAu @AE# Me0AM"HLT$.OLT$IE tƅAD$BI:bMUIB(L(LH9KAt$ LHHfHAD$B@jHPH R|9P$8ZI@ HHf%"fAE Hi4HIEJAM"IE(AE#Me0HHCIELL+HJID$HIEH/ID$PIEH$dH3<%(LDH[]A\A]A^A_fDAB f%f=uIB(LhM;j0VAD$ f%#fAB f%f=uLHLT$ASLT$XD vf.C f%fnL+ML9Y1E1wfH4Hց@tGf HEIU(H=+AHHBH@8HHDHH@ pNHucIEHH9taLIAU fEfqftsftlBfvcBff tL9EwIT$8H HЀx MAL$@HLA f%fuIEH>LHq.@fEfDkAD AE#Me0AE"@El$@Ir(D A|$"DHF tCHPB<t6?HHPH$HvHLT$[LT$HDHLT$aIL$8H HLT$HLc3fP$XIHaIEM*Mz(Ls(AG = IM_H@H$AF  IH@H$IFHD$AD$#AʼnƒA AG E|$D$AL\$ME|$#1fA4HH=uLE1E<11AD|$<=f.E?A3I4vf> DID99}A;@I4vf>u@H|$Hc xEHfH$L$AE|$#$~!1AfA4VPH;$|LE1E11ҾH|$DD$<(DEtSfHf8uH$A9}Icσ DHAfHtIcLffDfHHmLHmH@:3AL$@HH DAt$ LHH_LHLT$mmLT$D$<t L$H$I9 L9- EtAL$#@LH`HH`T$ID$(HULT$HH0Ht&F7FiIT$(HEHH|$(L(AM HtG GRH|$XHtGGIEtEtH$DD$0EtAL$#@H$LT$5^H|$x+^LT$7fH$L$4Ht$(H^LH1A5?LL$hHHcIHyLT$ H1m?LT$H$H D$uAL$#11fAL$mH$HD$XqD$<eH$L\$H$HD$PHD$@ALHLT$SbLT$H@LIB0H.UML;\$H;$Ht$LLT$ L\$GL\$LT$ DD$8HLH)HLHR`IH$pA9DyD)ljD)fAIcH|$1pfAFH$HD)9|H$L$LHLT$ LH$SUIH$H$LT$ HD$PHt$XHLT$-LT$5HLT$,IT$(HELT$HHt$(HLT$,LT$HLT$gIT$(HELT$HHHLT$gLT$HHLT$gLT$L\$MLT$Ht3L$Ht$HLT$0L\$ LH$5THHD$xH$H|$LT$0L\$ HD$@t$pHLT${ZIuHI$A$HaLT$HH*XHT$@IDD$8HL$`IHLLL$hL)]L$HLL$hHD$L)IL|$E1AD$pD$0D$ bIcLT$H)LH XH$IID$(LT$D6H|$`H <1LT$ E11H$LT$ HD$PH$HD$H9H54H=K1Pf.AWAVIAUIATA8UHSHDH@ MEf% MfC H@4HLk(C"HCIHHC0DDHپHL$C#MuHEh1HHI0h1IH1HhI?HL$MMeHM>H $L7HCHUHH4º9Hr7ID$HUHH4ºh9AU @1H $ffEAD$#AV ffEAw#tAE#uStAF#u0A|$#I $tA#uH9tOHH[]A\A]A^A_DLHH $艇H $LHuAW#H $f.HHH $q\H $LHL$Y\L$MLHHD$@\HL$L$fLH%\If.UHHSHt:=t.OfHH[]H^HH1[]1f@f.ATUSF"Ht3HN(HQ fft []A\I#[]A\HpH1ҾJHH1ҾeHHI*N[]LA\fAWAVIAUIATIUSHA < >HD@ EIU(%LzMHBL HHHkHuHBS#HLDD$ ҁT$MI9LLLDtMDD$ T$AIVH?4Icȋ%=!Mt>IH5LDD$HP 1H-S1HL?LLLDD$1At3HLD[]A\A]A^A_ZHV(HrHH f.HHHHuH9t)IH5LHP 1HR1HLf>LL[LIH@ @ 7fDHq(HF HHH@HxHHF80bf.HH1H $0H $ DIT$(HIB f%f7HRH*B f%fDC"A HZC HS(HJ%%B fff%fHzulBftcH HPL HDr$J$PfH4H HHLF1.HPDp$MAUwAL$#@88I@ DfMcI^(f% fAF H4JIF$AF"I$HIF0$AF#HHIL3LLcH@HHt B<(H4Bt$ LH1ރay\I$H[]A\A]A^A_fDukHfWf.@(hbDuSHfWf.@(2DAL$#8DHHx  DHHx xDHB@ ]f.HHL[]A\A]A^A_1[H~H fDH^LHPHHHPUHA f%fA"@B"<%f f%ftft[6CH4H5HJ1j=f.HHL$HL$L$IvHÐAWMAVAUATIUHSHHMHtAH LH^uHIHp(HF HH=HPH:AE#MHHL>K#H@AWLcAVIAUI8ATIUDSHLL$0H@ DfLL$HLC"C#f% fC H4JHC1IIE1HCTMHtuLL HC(IEMuH}HEI]I$@HLHtB<8ukH4BIHt8HHk0HI.H[]A\A]A^A_@Ls(K"H"HLLILLIstHHPf.HH[]A\A]ft|fuHs(Hu+LLfMtF Hf%f=ui>H1[]A\A]tL,Lc(HL->It$fDHs(H>H?@0HC(L`MLH=Md$MuHs(F f%f=H=HHDm\=H Ht L#MLLeHHhHUIH LeH&Dm\C Lc(Hf%fC HR4Hc!HCC"C"HEHPHUH1҃ABLHC(H2H;$HH?HH?I4UHSHH^(HtfDHH}fHL:H H[]A\A]A^DI}f=E1f=LLA$hC f%f=6LuK"HC(H5SzALHh)-HH5~IALHH-HHHHU(B f%f=HB0H SHHH(Q ffHI(Q ffI|$HQ(HHHr(I;$8HR Jabz qL@0AP ffYM@(AP ffAIP(HHH;r(,HR ezaec"?tK#P ffSuK#P ffTuK#HC(LHpHVHP.MuIEC f%f=tVIEMu(LfDHLHLL:;AE f%gLLQMu(MmIfDHYHL9t,P ffuH@HHHu0fDHHMu(z 1Ezb1z @ft3t&tH5HHc1'@$;7ATHIUHSF f%f=ugI\$(Ht%DH{tHH.$H[HuDHHPAD$"AD$"tAD$"[]LA\Effvf=Lu}[]A\1Ҿl:ff.AWAVAHAUATUSHHDdH%(HD$1 H( AH$HtVH.xHLcIIfDH( H@J8HH@ tH@HtLHЃIuD9sHE䉃t H0H( HtPH xBLcIIH( H@J HH@ tH@HtLHЃIuHL$dH3 %(H$u$H[]A\A]A^A_DDH3J;f.AWIAVAAUIATUSHHHHr(J'II$HHID$Hh0HH>t]H HPHDB$ttB$MDD$ IM(HPH1nDD$ HPD@$ECEmID$H0LHHh0H4HPLeHHp0AID$@HEHfH\LeLH1ҾHHCAID$0HEH@0H#@HEH@0H@LeIt$0HHID$(HEHH@0HHEHp(hHEHHp0-LH])H Ht ǀD9sHH[]A\A]A^A_fHHD[]A\A]A^A_0HH%H5ŴA%I@HHaHHVHHHHPHPHHrHXH#@HHPH@HPHHXhHPH,Hǃ0C;H51ɺ HHIHCpH+HPH;SxHSpHH+KH HS H)HH1LmHtHo4HEL+HHL[]A\A]:fDHLJ@HLJ0F!F!H[]A\A]DHJ*>H`H`HHHcQ HHHQR H`Hi3HhH`HH߀H#@H`H@H`HDcHf#H~:HhHhH`HO*HWDcHH[]A\A]HH[]A\A]fDHHHHdD/#HH2HHPtfDHF4HSpf.AUATUHcSHHHoH IHt S#Dk AuAq@HmDHc4HDS H%4H=>4H9H4Hx HB(P fu5HxtP HHH5ǠL17H@(P ftfHP(ID$HH@H@HH@\HJHH5 L1AWAVIAUATIUHSH(aD$?ECf1ҾL3H1HLS4HEn ] fAffAfAAAMff!Aff!|$tf$uH5rL ,fHE"RU#tHEU#@3@f$E"t fE LLf%#f4HHL^|$8H([]A\A]A^A_@ LT$DD$:/f!DD$T$ADŽf%fv EtfA H 84AA ELIV(B f%f.HLEHޞLپ LEL1M]fE#H@f.ATHIUHSHt y2t%HHL[]A\E1ADHHHH:HHIHcHWHfAUATUSHH~"xPHv(ILnHFLHHC(LsU HEfftVP fftHH[]A\A]f fP H-f4HHPHH[]A\A]@f fU He4HHUATIUSH^(HtfD1HމLH[Hu[]1A\fUHSHHHv(HF f%ftQC"@tHFHtIS"fH~C f%f=tLt HHeHH[]HvHuHs HHHoS"릃tHHC"tHH뜐N ffjF#@`@HC"HHHS(HBHC0H@H~HHp(@ATIUHSHF(HXH0H@\u@H1ɺHVH[Hu[]LA\DATIUHSHF(HXHu*7HHH1ɺHH[H{u[]LA\H@(HXfDAWAVAUATIUHSH(dH%(HD$1HF(LpML fDHHCHuHHdE1HItHHIIAL$#AL$# A|$#ttHH98tA|$#K ffftfuAF f%ff=MtwHL$HT$LHHL$LLHT$Ht$dH34%(H([]A\A]A^A_ÐH@(LpC#HHAD$#YMuLHAf#fIF(HPHUB f%fCb#:DUHSHH(t(HH%H(HH[]1ҾG DH5ZA LHHPJuxHztqHBthHH1Ҿ1HH߾HHHHHH߾H@qH(HH[]HH E11D$HD$$ AHHHHHHQHyHBfDUHSHH t6HS(Ht-B f%ft/fuHRHtB f%ftrfHH[]fDB"tHJ(HtA f%fuHI(HEHHH@ x[ux uHBHt@ f%ft]HH[]B"tHR(HtB f%foHR(HEHHH@ x[Rx HC f%f=ot2H_4%H HC|H1,HH[]fHH%tHHf.Hy_4Hx UHSHHV ffotM}AO ffhIN(H[fA OHyDHIH7fA +HyL;a0HI(Hq ffL;aIt$(HDF fAfAMD$0MM; HFHtP ffHHHIDHF"A"I8HLHAN#AO#I$DID$H-HvAd$!|@LPI|t%I$HuP IfufM6MAV ftfLH#II$AF$AD$$IF(ID$(AF8AD$8IF0ID$0AFf T$H|$H1HHm*f|$t |$u MU f%fwf tftH|$H蠸HHm@I1Ee@|$HH=4HL$ Eg#AG"H|$LDAuuE f%f=H|$HHHmHL fH}LUHmHE f%D$fDH|$LT$љLT$HD$I@H|$HHHm@E#@nHE(H@ tH@x qH&<4H|$ Ht$IE1H H|$E f%&DE#@fH|$ H;4Ht$IE1H H|$[fDE1HD$(HHEHl$LT$@DD$8T$0HiT$0HHUHDD$8HD$(DE#LT$@HELeI*11҅۹wEuXAW#LO@E#@Hu(H|$LT$(H|$1HAG#LT$(u I9o0KH|$HLT$0HD$(HD$(LT$0H3fDH\$LHH蠗t$H1H?f.H|$LütWHPDAG f%f=otcH :4%H ‹t$H|$HPIE1LT$(LT$(H94Hx 3HD$( H|$LLT$(,LT$(-HHHu(H|$ LT$0CH|$H1ҾH|$HHt$ HD$(HqWH*94HM(MH|$L 1H|$HL\$(LT$0McLMHu(H|$ LT$0H|$H1ҾH|$HH|$ HD$(HVH84HM(ML H|$1~H|$HL\$(LT$0McMLAC f%p|$$H-84HL$ H5 [Hf=H|$HLT$0HD$(jLT$0HT$(|H|$L^HPlf%HU(B f%fHD$HR(H@HHHR HJHcRHL$0HT$`HH@ HcPD D$8d$8 H|$0D$PHD$HMH@HH74HL$ HTH|$LT$(H 1LT$( HƺHLT$XHD$@腷LT$XHD$@H64Hx cHD$U1LT$(H@H%LLT$(A@ t6IIHHRHL$0HT$`% D$8HZ64Hx MHT$HH|$Lƹ"LT$8LD$(ݻLD$(HD$0LT$8A@ HD$AP1LT$8LL$0LD$(H@HHLD$(LL$0LT$8@ HD$LT$0LL$(IPH@H-t uN@#@~#x8HHD$臷HD$H[@ʀP"ҁuʀP"~#yȀH#fDP ffot(H24HH5PH1>fDHHtHPfHI24Hx [f.ATUSF"Ht5HF(H@ f%ft>HH#HP(HB f%ftH[]A\fDJ#H[]A\@Hp1Ҿs HHHIHL髼f.UHSHHF"@uu8HH[]fDsHH@(HpF f%fuHHH[]ÐATUHS4P"Ht+L`(AD$ f%f=t4f=tf=umLH荵H[]A\DʀS"S LHVAD$ f%ftH Ht>t5K#@C f%f=otPHf04%HH5.OH1C f%f=ot7H704%HH5NH1HH袲tHPHH茲tHPH/4Hx H/4Hx 룐ATUHSF"Ht$HF(H@HtHPHtB f%ftHH[]A\魺DDHr(1腰DHH[]A\Df.ATIUSn `HfHt@"tHLH[]A\AUATUHSHDf IfAHt7@"t1HX(Ht(EH޹DHmH[HuHL[]A\A]fDUHSHHF"tLHF(@ %&t\J tU fu,H8SH1hHiMH1RHHH[]!t =tfHRATUHSHH0dH%(HD$(1HH@L` MH RE11D$HD$A$ LHt7H8t1HD$ H0F HHRHT$ HHpH|H \RE11D$HD$A$ LHHt7H8t1HD$ H0F 6HHRHT$ HHpH E f%ftMHU0HM(B f%ftoHHHHL$(dH3 %(HH0[]A\fE"uH҉1HHpHIHLDB#ƃH@HuHIHuHqHhN ffUHN(A GHIH:9>1y&'H9VB#fHT$ "H~HT$ HHT$ "H^HT$ H-,ff.AWAVAUATUHSHH(F"tHv(N ffH5LPA H脿HIt H@HuHxtI$@HH OE11D$HD$$ AHHt.L Mt&ID$PuHxtI$@DHH赵H(HH[]A\A]A^A_l@F#@L~(AG AAFIGIILrL9HfI9Lx:HL`u8:uL@/LH)HI)H@E"Lm(HE(HHOLH1Ҿ荽1HH߾HH萤LHHH߾H@hH(HH[]A\A]A^A_ߠIIGI)ALrHLHE o U"HXI6u%AG 1LE1軦fDAWAVAUATUSHHF"HF(H@HHxF L%6(4f% fF I$HF裳Dx L-(4HAIcEtA At H}E f%HcAD t6t-_M f%f HcfM IHE_HHH[]A\A]A^A_F@HHP(HJHtQ fftH[]A\A]A^A_Da#H[]A\A]A^A_DDHHE%HU(B#B#`DHH5HU(J ffJ#@AUATUHSHHDf F"fAu-H0HB]u=ȀF"HH[]A\A]f۱HHH[]A\A]閡fDHp1Ҿ]HHr1HH`HIHLHGHHA[]A\A]H1,ff.ATIUHSHF(HXHtC f%ft[HL]A\@tHS8I$ HЋP tJH5pcLɴHHDLI1[HL]A\鮰fDH8с HHpHHWLgHfN"tHF(HtP fftJf.@#@tɀN"`#+f.V"t'HF(H fuH@HtH fft@#@tʀV"`#ӯHǯ@"tx#t HfDHP(fB u HRHtJ" HfH臯@"t'HP(J fuHRHtJ fft HDJ#HATIUSH1C"tHs(C %=&=@@@qHtaV  tRCtn C HLf% fC H2#4HHC[]A\驮ftƁuS9HL[]A\zf.~#@tHN(HtA tHQJ ƒ wDC Lff% ЉfC H"4HHCS 9wH[]A\pHNIT$H o@f.ATUSHH谭HH@E"HE(HP ffAf A ̃w wbAHHH0$E1ɃE1H߃%êHHtUHFL\EH[AIɾLEH1MHH[]A\ÐuHP(B f%ft&EuaHAH1 fHR(HCH4HtA$H1E1ɃE1% HD@H@H1誡XDAWAVAUE1ATUHSHHF L5 4f%f=IAE1F"@G-HFHC(fAHHp覛HH˫IH Ht IG(H@P fuMHX(AAD$ f%D EfAD$ IcIID$AG"AL$"M|$(HHH5%BID$01L#H8HHH@1ɉHxH@ %@=@t~AD$#AG#I_I\$IG(H@HHXH@1H޺HNH[HuHL[]A\A]A^A_HL[]A\A]A^A_fDAD$#AG#DHݝID$q軘HH@(H@Lx(AG f%f-fvHHH[]A\A]A^A_逿IIHu8薩IIĀc"fDLHecAG f%f=otAH4%HH5CH1H1HHL[]A\A]A^A_ÐLHՠt-HPHH8ۨIH 4Hx H5 CH1迯Df.AWAVMAUIATUSHHHdH%(HD$81HH|$L$D$=nHsQHcH@HBD$E1L%40HY4HJ4t$IIvK4HD٨uŀ|$iH{4HcՋA AE11lẢ؃wtIcAD \HBHcAL$McBD$ EtEtAH| $5A߉ڃAtEAAsD$HAH|$H<LM6AL@HL$8dH3 %(]HH[]A\A]A^A_DH|$H ALwMALfH|$H@LGMALwH|$H|LMvAL?H|$H'V1LMAAL fM_D$DH|$HLMALH|$H@LWMALH|$H?LMALOH|$H?LMNALD$fD1T$DL$DT$DT$DL$T$%IcAT$mD [AD$HcHD $AD$HD @AD$D %HcЍHHD *D ]EttBÃfDaHcAD ;l1|$t |$vu HcD ;H|$HT$ HcLD 躿Mt%A.Lf.D _E1cLHD &AD$"sI1A.12fAVA1AUIATUHsSH螿Iu EjH4HcՋ ) 1HLNHHtAL$#1tAL$#@qH[tAL$#H[]A\A]A^DA1ҾHVUUUHDDH)RA)Ic1HH覾HH1HfHLH[]A\A]A^[IL!1H߉-H6H#DDt1҃HOD1LH薐H߾I1HHtH߾HHH1Ҿ½Hh1H߾IYHHnMHH1ҾI虝HHM[]A\A]A^H1^fD5fDK#NHߺIAHH#AWAVIAUE1ATIUHSHHHD@\fAEAH|HEH@8Ht?HH@(Ht3@t-HH@HRHDHHt@zt<@H5H:EHDHHL[]A\A]A^A_1鳕HrH=:u@Eu3H[]A\A]A^A_@H踓MI#I;$;HstMtI$LHvtH4SfDHH"'Df.AWAVIAUATMUHSHHHL $L$XIA LT$菨IH@LT$LhM@IEHx0T@\"H HPHDZ$ttB$L$XLHHD\$ ʢHL$PHLHHPD\$DX$AEKAE H蟺IIGLhIG@IHp(FLLH誴LHIELLHHL`@IEfH\IELp0%D$XtImLHHE@IEfH\H$LHHL[]A\A]A^A_ËT$XH$8H5'8 H8HD腟 HH赹IHHLHfH\۳LH IEL`@IEfH\IELp0=fLHՂHHPHFHDHH@~uH:HFLH蕽dHLT$莽LT$%@IBLHЃS}HzzAWEAVIAUATUHSHLH8HPHT$LL$(L`0%L9PtIHPHH +H٥HPHpHHHH LPIu$HH HPHtA$H讟HH8H̥HPHHp()HPHHp8膒E1H8EHPtBHUHrHUHTH2Ht)ztH6HtHcVHHHL$_HL$HA(1EHPB8L JHD$(Ht$AMMH ~MDLD|$H$HFHT$(IHHP(I$fH\HtHPHx(HqH8L[]A\A]A^A_HkH_HHt$ HPHHT$HT$Ht$ H՞/HMHqHMHLH1HIt H6HHcFD t FFAUIATIUHSHHHt-H HHHH[]LME1A\A]鼌@1@AWEAVMAUIATIUHSHHHt;H賌HD|$H$MMLHH迭H[]A\A]A^A_1ff.E1E1%DAWAVAUIATIULSHHdH%(H$1Mɉt$LD$ MHD$HD$-D$.|$-H0H@\fEAAD$HD$XAHE^Hs(F HH@HD$XHFHD$EmHC(@ _MD$0A_It$(F HHNHRHL$HT$H% ED$KH|$Hs(D L蛠D$/IH޺LIL]MtLLH|$-tHt$ L/S ƒ 0H|$HCE1PuLxHD$(H|$t |$(HD$PMIHx0 DL$LD$HHHL$LLJ|$(OI IPHDb$ttB$Iv(HL$PLLIPD`$AGAGu LL)LL$PM\DD$0AA1HCHL$XLHT$AAH@A RI f.ADHD$8|$-I0H@\1HLHD$P@AMD$0ED$HD$f.D$/E1HT$X"LHD$&@HT$H"LDT$HD$ID$(DT$@ EftFu%t HHx tH/#L1DL$LD$H1HL$HLFHT$HHL$HHLhL$tK I0HtFFTIDž0E1I Ht ǀD$A9EH~ L謨H$dH3 %(L HĨ[]A\A]A^A_At <I8DT$(A DH5r.LAE f%fM!M7HLAF\=n1ɺHL軕1HLٲIF0IH@0H#@IH@0H@M7Iv0HHDIF(ILH@0HIHp(AhILHp0VILp\f谋I@\ tH|$tHD$8il$.@"l$/|$-E[m1HL +@HL腚H|$Lt$:LDžHpHH=#IDHBEGIN noAƄ$HD$`Ht safe aHD$hHfter errHD$pHors--comHD$xHpilationH$H abortedH$ IHPH2HHT$`L辪IHFHHH5^L1֓1AG tDL$LD$HHHL$LL4H@HD$PH@H<1LLAIHT$PH 2HP(IHH0IfH\IfH\IHB8HHHp(Ht{Ft6HHPHFHDHHt@H:tLoHL蔘I0HtFtAFtGIDž0aHr HxI8lLXqfDLX므|$.IjB\HJHHrPAg I0H?f G\fB\I0IHHRPHPPI0IHRXPXI0IHHRHHPHI0HHpPI0HHHHM7I~@Ht AF]IPLHp0IF@ILLfH\I8II0LLHpHdAt tAI0HtFt:FtGM0@6Hz)@Lo聞M7:LI0H@\f B\w111LHILxMLD$.LHLHIfH\sHHLLIPM7LHp0蘭IF@ILLfH\I8ɊLI0LHlHt$`L1 LusI0IHJ\@\GHx:HHL]rHbH LUH@Hp C}H L1~rL H@HmH1LH@H00LãIEpf.H$pHÐf.AWAVAUATMUSHHA@ $f%fbHAILMHQ(AE f%fB 0It$(H:1HHȣH5Ѓ1ɺHI迩1HH蝣LHHD$͝LHH HL$H¾HEHHPIHtE f%fM|$(AG 0Ez111H̆L11HH躆L1ҾFHI赪11HH薆LH¾H裝HH¾H萝H5}1ɺHH觨1HH腢4$1IE1HHϠLH蔃HHYHIޫ3IHƋHbm1LH腩LHH'v  b3H HPH9KA<׉q/f(H~1HHHH菗LHHuC u @u `XfLH蕈1HH#1EIH5HH1ҾHHHI!LHH^LH¾H蛛HH覦HH11HTL11HHBL1ҾFHI=1H1HLH¾H+HH¾HH51ɺHH/1HH 4$IE11HHWH ǀH @KtBJtH[]A\A]A^A_DAL$#1ftH[]A\A]A^A_H5HL6 u @u fDE1B 0HE1>H5ǀH $輈 $ @Љ%f(LH $i1LH该LHHQr $3/LHLi1LHoLHHr $сf.H5FH1tH5G1ffDAWE1AVAAUATIH1ULSHH脝H#@MItL1ҾHfIAAUt 0HEUL 0HEUHE1HutfDHEUHHtZ1ҾHLHH貗UIă0rHEHPHUfH}HHgIHRHPH#H11貘H11vDHMML HH[]A\A]A^A_n@HEHPHUHEHPHUHLD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$IHD$HD$ $ D$0HD$HD$dH3%(uHsfAWIAVIAUATIUHSLHMu HVrHE1Ht>MH3Du@HtHDEHBDuHLLbLH1ҾLLH¾=LL1H轇LH1Ҿ苚HLH¾H5!L H1HIL[]A\A]A^A_H1ɾ1鬉H HtHHDtHHLH)Hբ1HLLHLIAVIAUIATIUDSHH p@1AD$t'I$HPID$HDHHt @HօtH2HjLHI LHH1HH@HHH¾轈LH1H߾HHH¾蕈H5HHߺ 辡IH1ɾH1G`DHHPHr HH lE11D$HD$A $ HFHt!H(H9tH H[]A\A]A^!kH5 Hߺ 1H¾H1訇fDHƺ H萟H@Hp [AWAVIAUIATIUHSHH Ht1fGHt 1ۀtHL[]A\A]A^A_Ht1fAV ցG,tǃ@ǃA@EN@ǃ3@*H f=tf=H HDHEffoH3HcHH5H1qHH覗MV(AJ ffH f=tf=H HHEffoHg3HcHH5FH1HH$AN#f.I^(HxHLLHH[HuVMAN" AF#ȐAF#.fMtIJ(HUE1@H fDH HǀEHHE1LHHp(#LHH $pH $t HPȀAF#@H!3Hx @1HfH HǀIveHIHEIVALLHH H5 H蕝1HH賔H$1AGt%IHPIGHDHHt @HօtH2HeHD$1Ҿ H蕒IIFLHIGL1ɺHI~1HHLH¾H襃HL$I1ҾHLH¾H{H51ɺHI1HHLHIH$HH.LH¾HkHHvIUHHBIEBLHH $nH $t"HP6HAHHAHP(~H3Hx HAHP ^HEIVAL8LHHLH5 H蔛1HH貒H$H@MHD$%HATIUHSHH dH%(HD$1Ht HHL$HLHHD$!HT$Ht6H ff r HfftQH¾HAuH 1H|$dH3<%(fH HǂusH []A\fDHr(HtV ffuHVHHD$HQ(HL$HD$s@HHtHH%eH#[iAWAVAUATAUHSHHF"uH HH;wLE#11HH{H 1fH HǂH[]A\A]A^A_z,u PtL MA6@u%IA6@tH=b'jHuA6E1@H=CjHAFINH5 3DuAFINtDuy:HuI1Af.1HHfD1@IIA6@tH=GiHuA6IEtA<=t<;dEH t+AH f=tf=H H] HEH H1hI$fDAUATUHSH^"rIă@"tH@(Hx0H菓H5  H苗HHE1E11ɾ1~HYaAd$"H5 1HR~HHHߕHcP BIՉP HCH0HLH1HپHzLHHAD$"Lt(I\$(HtHHaH[HuLH[]A\A]fDH5 A HzHHtH@pH5 1A HzHHH@H[H#H5_  HE1HE111ɾH|H_HCPfDHxtH@gAL$"HhdID$HcP HFP 軒1HH蹌LHH膇E1L1ҾHXH1ҾHI,y1HH:HH/`LHH,@HHHH\1H1HH@'HxH@HCHx;H@u-H1H+H@H0cHALHHtDf.ATUHSHHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1IH38xH$HL$ HI$HT$HL$HLD$0LyHD$dH3%(u H[]A\cf.SMHIH1HH1ҾzHH1[7I1sfDH9t fSH H3HL$HT$t$ H^t$ HT$HL$u0H9tHwu:H [@H3HRHD$LLHHHHL[]A\A]A^A_HHLLHLHHHAHD$QHD$LLHHfDLHH_DD$ D FH@Hh(fAWAAVIAUATUSHHHu HYHL, H9tHDHH)L7H]M:HI)LmdHHuL9t HHL[]A\A]LDA^A_H[]A\A]A^A_ÐAUH5AATUSHHdH%(H$1oHtXH@H=HHL(^T~bPLcB<$tMLcL/HcHt=LHLHH$dH3%(u0H[]A\A]u@HLHHc^Yff.HeH3H=31H赉uHHH=nƹ1pHeHf3H=_31HeuHHjH=ƹ1ppH3tfHH=M3[u:H=%3ZuFH=3ZuRwlH=3ZuYHHH=ƹ1oHH=ƹ1oHH=ƹ1oHH=pƹ1ofUh SHPnHH3H8t0H3Hދ8Z1H߹HHH[]H-y31HHw}HYH=31H=31͇uyH=31軇u`H=p31詇u\H=31藇XmHH=L1nvH|H=1nkƹj뿹lH5S!lQҁi둹h@Ha3tÐHf.ATIUHSHHHxcH*X^f.>3wfHHH9vHcHHH,HcHHL`[]A\ÐHHHH H*XH5W3H=31qmHRcHt H@HHÐ1ff.U HSHctHPHR(Ht*HH[]Ht2H@HP(H[]Hf HHsH@HP(1DU HSHbtHPHR Ht*HH[]Ht2H@HP H[]Hf HHH@HP 1DAUA IATIUHSHitpH@pu H@HunLLH dHH1Ҿ|H11HoHHH[]A\A]E1E11ɉNzfDHt#HP1JtH[]A\A]HBf1ff.ATAUHHSHRHHD[]A\HSfDHNHeAVAUATIUSSGYAofAmtA9A9u1~ IT$:-t[]A\A]A^fB[]A\ Hr HH8rH5A1HH={H@ H"HP1HqHX H1HqHp H1HqH51HzH HH=H HH@H w HqH` ߺHHWH+3HHodH HOHH qH5HH ,zH5HHzH-3HH}u+=IToHHEzH5YHߺm]HH pH HHH@[]A\{uHHH:dDHHXYdDHH:LZDHHYL1DA$HHFH(HE <HUH5*H1Z@E1HfDG@HfDƃxHyZH5H17ZH51H1$Z@1ҹ"HHMHYfDHHHE .1HvH@H( fAUATUSHHXHL$8LD$@A LL$HdH%(HD$1\HPLb(MI$Hxt(HD$dH3%(HX[]A\A]fH$$HD$HD$ HD$cHD$$H(Ht$0scHD$$L(HHIUwLHHXA LHHM[$0rHD$HPHT$DHD$HPHT$뚺 HHPuH@L`(>F@f.AVAUATLbUnSHLjA}-tc|@=L+GHIIuHHAH)ZH@IVHH0_JIt&M,$A}-uAEt<-uA}uIH5nA H!ZHHpH HHHHp5tHpHPHr(HHwItyI4$1HYIHpHPHr(HtbHLW@@t 6t@ tAM tLHImu[]A\A]A^DHƺ HhsH@Hp(fDH߹QH@HH0s~Hƺ HsH@Hp(AWAVAUIATIUHSHkH91HH(HjHekH1HH HjH LHƅH(RH58AH)XHtH@HHH0GH5MIA HWHHHHHHHFLp MGE1E11ҹELH'mMH3HD$I9tH3D$H9*I$HuII$Hts=HCHItH9tHp1HWL$IH)A$HLHI4i|$tILH]I$HuDƅuH[]A\A]A^A_ÐHHH5[]A\A]A^A_~jHfL MtD$ fD HpH@Lp @f.Ht1ttDLJDLJHLJDLJHϐUHGSHHH:HH}1HHr3H5HH1eHtEEH83H /KH5,H1eH3H5H1eH2H5H1ye1HGHHKo:HH[1vHH[lffDATIUSHr32HI$H5HH1dH5HHtpH3HuLTG@AWHAVAUATUHSH8Ht$D6dH%(HD$(1AxH jAHcH1ҾMy1ҾmHjHD$HPHT$P] -H5H HoHT$L 3I1D"HAADuA:uNH{H|$;:DctAHADufA:t HHCHD$DcHDH9: k HH$[=A=L<H$hLALH)H4AmHLHL|$1HD$@Ht$(dH34%( H8[]A\A]A^A_11ҾdHD$HHHL$Pt3 =HAHD$y- H5 H%nHLd$LuH5)H1G)QHf H|$ H51HeHHHH1(6:>H5HD$ieHt$H1HXHL$H>0E1HHT$ HT$ @HD$HD$ zPL 3ADH2nH5HHHD$\LHL$H%Ht$Ht$HD$dHHS%HT$>HQ`Ht$B`HT$H5`HddHHD$H5 H HHL$6dH 1ҹ"HH9HjL)LHHA)HD$HHHHH1HL${4HH{$DH51HcHHHHRPHw8HJBfD1HH&_1Hw H D1xHwH2HwHHv=HH5AH1DH5H1DHwh`H)H5rHEƉH1_DHH1HHpW:HHH5^AH1DHH1HHp:HHSH(HHt$F%F!Hǃ(HhH9XujHXH+SH HHQHHRHSHH HIH HK HH HIHHHH9hH`HXt\HU9H`HH@HuH`Ht x H^HH5b1UH&8H8{H~ 1HKPHpH?t(HQ{!fD{\D;[H@H@HnHHx(HiYDAVAUATUHSHHHpL+T$H<$dH<%(H$x1DHCD$,HHD$D$>D$u D$D$H\$`1L4$HHD$T$L@ к$DIIF I^H)HH $HBHHjHApD$ A8D$tD$D$'H$HT$`HpƀHCH9Ht H$H H$HcT$ HCHHH)HD$,HpDD$t1H<$HcT$ D$,HGHHG\9GXH<$(H$Ht$HpD$,H$xdH3%(%HĀ[]A\A]A^HH98HP^} D$@H$H@H#H$t$HD$`H$HkpH4HCpHpH$1H$H$\H<$H$$pƄ$tHp@H4$H@HHdžHHFHdž@HT$01HHH<$H 3HGHD$0HpHD$@D$Pf% fD$PHxHWHD$p$f% f$H$LH|!H3@HXHs\HL_CXHsC\DQfDH$H@HT$`H9Ht H$H H<$HcT$ HGHHH)HD$,D$ uZHHFHHC`CC=H<$H51HHX[HH$\$;X8H$H$HpfDHUH;B V6DH$ǀDǀHH<$H8H0H9t5HtFQFtH0Ht@H<$H8H$X\9XX H$H<$Hp@HHG-H$HHRHRHHPiH$HVH0pH<$H1HkQC %_DC H<$HcT$ HGHЋD$HH<$HBD$,HH(HB_fDH3HxHCHHOH$HH0H<$HH$H3HxHCPH<$HUH<$HDC HHXH@H1HH0@PD$,)fUպSHH0HH߉[]HSAWAVAAUIATIUHSHHGpHHH;GxHGpHI+T$HH}u7[fDHu1LHL{*=LHEHCH}t4LID$ H)HHH޹L0HIM<$HL[]A\LDA]A^A_HNID$pTATAUHSHH&HHH¹X7HDH[]A\ʀRAVUHSH@HdH%(H$81H<$T$ HH+GHD$(HGD$,HD$HƉЃD$2L4$LC H$HQH@H1HH0ID$,"ATA1USH7HHH\IHtEtpEtvH H)HEH tCHHFH8HA 7fHH HPHv5u[[H]A\fHHHHMz1HtHHFHHH@80HHFH8H0F HFH5#HH13@1HNPH@H8OHHFHH 1HPH@HHHV@ H t$H1HOH@HDHt[A u/A HHfWf.B(DHHHx D1HvOH@HHHV@ H uHu1HLOH@HHHV@ H bHu1HOH@HHH11HNH@H>1HNH@H1HNH@H "1H%+1HNH@AVSHHHPdH %(H$81H|$t$HHT$@$D$THD$H HD$@HD$`HD$(HD$hHD$0HD$XHD$8Ht$H|$H\$Lt$HLD_HD$ BL9HD$Ht$H9HD$HL$H9'HD$H|$01HpHD$`MHT$Ht$($0Ƅ$4Hp[uZHD$H@HD$H`Ht x 7H|$KHH5K1BHD$x\9xXHD$`H|$HpDHD$ǀDǀHHD$L$;H8}H\$HL$;K8|HD$x\9xX HL$H8H0H9t:Ht FF#H0Ht@Ht$H8HT$HHHHPD$THD$`HpD@HD$HHpHQH;PxHL$HHPpH\$Ht$ HH+CHH GHHFHHjC HH@HD$XHHL$HHHPD$THD$H9HD$Ht$H H9t)H9H tH9H oHHEH|$HH1HD$t$;p8}Lt$Lt$A9v8HD$`HL$H5*HHpH1-f.Ht$ H|$0H|$@H\$Hc H0 H@P1fH\$H3GH0HT$8H|$"H !HD$XhH@H@HHHx(HfHT$ H H,HT$ H H HT$ Ht$@H H$8dH3%(HH[A^HH@HSp[H|$1IH@H~HHH|$`HPD$TtH|$(H:H|$GH5HǺ1>DH|$HA!HAWAVAUATUSHdH%(H$1H|$D$H\$HS\9SXH\$HIH xHT$HPHHHPHtBHHHH@HHtH@H@H8H@HBH\$H0HǃPHD$HHHǀXHtFF4HD$HǀHH3f8H\$ǃH $[HD$HHtFyFHD$HHǀHtFSFHL$HǁB҉~6H\$HHHHHpB҉H\$H7H HǃǃHtFFH03HT$HH9t!H3:uH3H*H;l$D$jHD$H HtFFLHD$H Hǀ Hǀ HtF9FH\$H Hǃ Ht&HHtHH HǀHD$H\$H ƃƃƃƃƃƃƃƃƃ5HHǃ HtFFXHD$HHtFLFHD$H(Ht)FMFHD$Hǀ(HD$HǀHtF.FdHD$HHǀHtFyF HD$HHǀHtF4FH\$HHǃ54HHǃHtFFH\$HHǃHǃ3HHǃHǃHtFFHD$H HtFLFNHD$HHtFF4HD$HHtFFHD$H HtFFHD$HHtFdFHD$H HtF*FHD$HHtFFHD$HHǀHǀ HǀHǀHǀ HHǀHǀ HǀHǀHǀHǀHǀHǀpHǀxHǀXHǀ`HǀHǀHǀHǀHǀHǀHǀHǀHǀPHǀHǀtFFoHD$HHǀHtFHF*HD$HHǀHtFF-HD$HpHǀHtFFHD$H(HǀpHtFyFHD$H Hǀ(HtF4FH\$HHǃ Hǃ/HHǃ/HHǃHtFFHD$H HǀHtF FHD$H HtFW FHD$H HtF FHD$H HtF FHD$H HtF FkHD$H HtFo FHD$H HtF5 FHD$H HtF FHD$H HtF FHD$H HtF F HD$H HtFM FHD$Hx HtF FHD$H HtF FHD$H HtF F!HD$H HtFe FHD$H HtF) F~HD$H HtF FEHD$H0 HtFW F9HD$H Hǀ Hǀ Hǀ Hǀ Hǀ HHǀ Hǀ Hǀ Hǀ Hǀ Hǀ Hǀx Hǀ Hǀ Hǀ Hǀ Hǀ Hǀ0 t HLt$I(LIdž IIdž(IIdžI0HE1$ADLH2HIdž0tCr C HD$HHtF F HD$HPHǀHtF F HD$H HǀPHtFF HD$P\9PXaD$<~qHD$@8f HD$@H H|$HcG\tHHHh1 *H|$H`Hc@ tHHHl1)HD$HX )H|$HT$H8` H8HtFDFV HD$L-%1Hǀ8HHLpDbIHtKH|$tHCHKLH|$L;L@1 H=)MtLHuA9| HcIHBP8L)HT$HH@HHH@HHtF8FJ H\$H HHXHHǃ ǃ`H@HǃXǃdǃHHHHǃ@ǃLH H@ H|$CHHHCCH9uHD$ H\$Hǃ 4Hǃ0'HHǃ'HHǃǃ{'H o'H!H@['H O'HPHǃ Hǃ HǃP"'H`Hǃ8HPHu (DHHD$H`HBHuHHHxHX&Lt$I`&HI`uH\$H{P&H{h&H{(&H{@&Hƃƃǃǃ6H8HHt(@HH\$H0&HHuHD$HHH8H_Hu>HH{ H+Ht{gt Cx%H%HuHD$HH8Ht"@Hx%HD$HH8%H\$H%HǃHD$DH$dH3%(H[]A\A]A^A_DH!3HD$DfDH|$*;HpH|$(1HD$ 4HT$$HD$ Ƅ$HpHHHt4u+H3f81HD$p8ǀHuHD$ HT$HpH\$Hǃ$H|$}H|$%H|$H|$H\$H*HNHHǃ7D~H|$R0H|$C0H|$10@H|$!0HHQHuHQH)HT$HHH` HH|$/fH fHD$HHc H1n?H(HH #Hǃ)H|$RH|$CH|$1H|$!_H|$%H|$H|$H|$wH|$=H|$H|$H|$H|$UH|$H|$qH|$aH|$QmH|$AH|$1xH|$HH|$CH|$H|$H|$H|$H|$H|$mH|$kH|$&H|$H|$qH|$aHH|$QH|$AH|$1@H|$!H|$H|$qH|$H|$H|$H|$`H|$&H|$H|$H|$xH|$qH|$HHcȾ1HD$@HH|$HHcȾ1_H|$H|$,H|$,H|$+H|$+TH|$+H|$+H|$+H|$+iH|$+%H|$+H|$+H|$q+*H|$a+H|$Q+^H|$A+$H|$1+H|$!+H|$H+jH|$*H|$*sH|$*H*H*H|$*6H|$*H|$*H|$*hH|$q*H|$a*H|$Q*]H|$A*H|$1*9H|$!*H|$*mH|$*3H|$)QH|$)H|$)H|$)KH|$) H|$)H|$)H|$)H|$q)!H|$a)H|$Q)UH|$A)H8Ht'fDH |3HH<HHuHHH{3HHL$H}3HT$H}3JfAWAVAUATAUHSHHt$8H|$(dH4%(H$17LD$0 H=`Ht1 H G HD$(|DHHy3ǀ|;AH\$(HPHtHHǃPHD$(HHHǀXHtFz F{ H\$(H0HǃHK8HpH$ƃ1H\$(L$HH$*HL$(Aĉ$H$AƄ$Hp2AAuHtf.H;uHE1HH9AAtZAD$H}HLfHHSH9tMt9H9HSHH98HtDH;uHH9uHD$(HHH2y3:HHSH9t#MH9HSHH98Htf.H;uLt$(H51L!IHAHHdfHSH9t#MIH97HSHH9&8Ht @H;uHHAHuDEHD$(Ƅ$DHHe3f8 Lt$( LAdž& @ L H5 1ɺLI0I8%H5AIA L HH@Hp HtFsFLt$(HE1I0LI0HEHt BI0Lt$(HP H5M A LU HL& HLu&HIt @IHLt$(H5AHHL IHH5A LHH HIht@Lt$(H5AL HL%HIt @IHLt$(H5AHHL= IHHH5LHH1fI1LE%IHPH2HLt$(LIHFH(H.EEE$H|$(H5)1HHh$&HEH|$(H8H0H9tNHFFOH0HH|$(@H0HL$(H8HEBHHHHBHLHHIt HH}Lt$(HcPHpL#I0IHa1Hl$(H58A ALsHx H@H5 A HH@ HJ H@H5HH@ H HٚHH`ELCA8-AHHL=D$O1Ƅ$HD$@Ƅ$Ht$PDd$XM`xyIc LHHD$(HH0H)CHq3H|$(;|Lt$(HuL#II`L@ LAƆԘHL$0AƆHDL91HD$(ǀDǀHHD$(t$H;p8}l$HH\$(fHX;k8|HD$(H\9HXEH|$(H8H0H9t:Ht FFfH0Ht@Ht$(H8HD$(HHt t$HH HD$(HHt,H#3f8HD$(t$HǀH HD$(DDwHH H|$('H|$((vH$13H\$(HH0%HD$(H HH5H1HH|$(#HD$(Hǀ1BH HRHIHLHHyqH HbHcAD qt HHAB91ҾIHA|$ I LHLH3MAMt$E~MD$A8-u AHDd$XA|$O ID$Ƅ$MHD$@뭀ƅƅID$O@A $fƄ$e1ҾeH?H(A|$BIVHH(MfHAH(HlAHA|$:H5PHI HHt$PHHH-8ƅƅI!1ҾSHrIƄ$ƅƄ$ELDd$XEtmHm3Du_HEH=HNH=H H|$(îLHHIy@AIHD$(5H=UZHHH l3Dtf.HEDu<-9L|$(1H\$hDd$`Dl$dHDEH l3DtHEDu<-v DmIEtqAH=/HHLEtH9l3DU HuEAt AuAƇAƇHHDd$`Dl$dH\$hL|$(AƇLܒ|$OAƇ HHD$(H(tHMAIHD$( L|$(H5 LґH5 L蹑H5Ө L蠑H5ר L臑H5ۨ LnH5Ө LUHD$( L|$($I(MH5LTIE1Hl$(T$pHPHx0 HPHH|$(H@0HPHHE0HD$(T$pH8- H5HH H|$(HvǾ1D$\D$t 6$T$tH|$xH99$$s k H|$( Hy$ AL|$(xLLL$\Hf.H|$(1HHHI8#u݀x!uH5%&HxHuH5LdHt HH$ H$u"fD<#HHh3Dt< HH< t< t<-uSH={h3HADup@v<_tHqH=[%uHBH|$(HHuH|$@tH|$@cL|$( L;I0IHLHH1HL$(fH\I0L8 IGHL|$(LLI LkL H HH5LHD$8HtLL|$(H5rLH:HƹLH5,sALxHt@L|$(L BH JH5PA IHELHD$HD$ HD$H$1H5 ALIXHLH|$(HHIXH@LxIƀIH$H$H$H|$(IGHB(XH|$(H5AHH5AHJH@AGLxL|$(LI`HLH|$(HHI`H@LxIƀ>IH$H$H|$(H5IGAHB(=HH5ơHJ1H@AGLxL|$(LIH d38JHD$(@tHt$(6twt!HL$(HXHtJ  t!H|$(HHtJ  t!Ht$(H`HtJ 9  H=CHt#H=HHD$(L$\H|$(HH' HtEE H\$(H5ˋH$HpfH|$(q "HD$(H  HL$(HP@$H8H0H9t:Ht F8 F H0Ht@HL$(H8HD$(H(Ht/F Fu H|$(`HD$(Hǀ(Ha38 HD$( J H\$(HQs\9sX~ H|$(o H\$(H2HHǃHHǃ@Ht t$HHDHD$(HHHP3f8 HD$(t$HǀHLH|$(H5H1MƄ$e;TH53H}HiMfMtAIA<$ H|$(H516fDH51ɺH*bHcBD BH|$(H@LLDmH`3LeADsLHEHE$H\$(HiH0H@H@HMHHx(HJ8H|$(H^1H E %_DE #H(IT$HM HD$(HH5ОH1H|$(Lt$(LI0H|$( d1H=aHl HD$(Lt$(LJ I0H|$(H!*HD$(Hǀ1 1HD$(H5zHH1H|$(Hމ$HL$(ƿH$tHL$(H9k$@f.V t1tHFHF1PuHp2fAWAVAUIATUSHHHPHL`0MLA t6ITLHD@DAA ADD1H9u܍ɾP 1AAAIPIHtWB$DLLAF@I^8IFHLAFH[]A\A]A^A_fA 1L%Sw1ATUHSHHHp8H9tcHIt1@]FFHEf`\HEHHX8t!C tHEfH\C[]A\f wHCHtH9htH9h0uHHL[]A\fDH@HEf.+gfD+WfDATUHSHHHp H9t2HIt HHEHHX tHHL[]A\[]A\AVHEAUIATUHSHHHHEL`(2MAD$I$HPID$HDLMDPEuvIPLELcHEt MMIc@AD <EAALHH#HAHH1@IHHPu@HUA HHӿIEHHp HHHH[]A\A]A^H=DIH=oINHH9@A@4DB AAAt E wHBEH@8HHEAWAVAUIATUSHHVH*HHHE1E1E1J:HuUfwD ftgPHF3 ftHCx HHHCHcPJHcɀ|:t-H_tHPF<tHF3 DHKHtʀy uHIHq HtH90tL9tH^HHufDIEAID;pIUHBEHPHJHR@HqHIDHHPV$HPHJ01AEHL@ t&IEHPIEHTHHt RHtHH(H1@HPB HsE3 Dуu.@ ? HCE3ҋ Zf.HpHT?H[]A\A]A^A_fHSHtWFHvHHt*St#Ft)FtHCCH[cKf1[ff.AWAVAUATUSH8HHt$(tF tH8[]A\A]A^A_ wH^Ht݋CIbC7HsHD$$df.HH HS(L{ LsHkLc0HCHHHC(HC HCHCHC0tLHT$HL$[HT$HL$HtA)AHtB+BMt AG < 4MtAFAFHtEt`EMtAD$tTAD$HsHHtOl$$H5١L1HsHfDHL]LLMHsHHuH;uH{(uH{ uH{uH{uH{0uHfDHLHT$HT$fDHLݴLLŴtgIHPIGHDHHtO@I Ht8f.BADHcD: $LDHE12AGAGCLL<3LL%ƀ1@|$(LHI`LL$pD$bBHHH HA(MA LLL$ HH@IXM+FHIL@HH@IFHHHRHIV HHHRLHI`IXIvLALL$ MNtM>L?IF L)HH9D$01AFMgIXMoIoT$8IGHD$ILI$H>3M&xHIFt LA LAIHHH0I`IH@HgIXI+N|$(HHHJHHJINHHHRHIV HHHRHIHI`IpIX@D$,HHcHAE 7IE@)HH0HcLDD$ DL$(HL$,HHL$DL$(DD$ H@ HPHcAHH@80@HƺLDL$(sfW1DL$(f.vy?I1LD$,AH"A4HAXA HHD$HA`HHD$1A CHHHD$1D$,A HHHD$1D$,ALLH HI$HHtBHt+HHx lL腡tJHfW1ɸf.B(D1貯A Z1SACHLDL$(DL$(I`Htx t&L?H5iH1>L豶H@H@HtHH@(HuH5oL1E1D$,E1A f.AVAAUAATUHSL'I$C uNt HC@uOE1AtC u[]A\A]DA^@HH赫I$D[]A\A]A^DHHC H(A DHH腽HtA uHUHJHUHCu$I$LeA[]A\A]DA^f.HHHMC@uI$HHV@AWAAVAAUIATUSHL'I\$I,$C H9t E C HC@E1AtIED@"AADHHL葼HtbA IUB"@tIl$I\$HHLwE@uIl$I]H[]A\A]A^A_E u:H9AtIt$F uxE uZH1[]A\A]A^A_fHE@t%HxHLeI\$ID$iHL蕩I$L耩ID$vfDC ULNIID$C <)L0I@1LLDC HLf.HJIUI\$H,E{ID$HL {1HLLHC@ FHLSf.AU1AATL(UHSHHv JHSBtAA DLHH7Ht:p t=H9tHKH9HtHÁuHHDH[]A\A]HH[]A\A]H5+H1ټfAVAUAATUHSHAIHL&uIt$ HtDD$ sM&DD$ E틅 t4AUIL\@IEQDAA ADD1M9u܍HH 1DA ADID$ H[]A\A]A^H51@f.AWIAVAUATEUHSHH8F HL$LD$ȅD$pE1HD$ D$,MoM1AU @ƃ IGAG t$(w v IH@ LH IHxAG %LH߀̀AG IGIHHh(tLHHEL$HT$A LHApA&|$.IHHHMHL$HT$HMEHǦHIGHxT$(YHaIHHp(ªLHHHPLeHHp0MID$@HEHHfH\H8|MtzHL$ ALHH~D$,tYM H8[]A\A]A^A_E1HD$ D$,E1D$(oJIHH|$H8[]A\A]A^A_fDMIGH@AG , t@MwMsIǁ |$,HrHt$ jfDIHHtpt1LH߉L$(ʤAG L$(11HH0IGHhGEIGHh*I_f.Qw31LH6H5τHH1BfAWAVAUIATLbUHSHdH%(H$1H0tLt$IILLH{LL_C<覵H0E1$A0DHHaLAz t@H0MLE1HHLT$'LT$LLHMbLT$I$u=L9LtHH$dH3 %(HHĨ[]A\A]A^A_ÐtIBHx(uLֺ HLT$H@LT$ Hx LtSHH@LT$E1E1L1HHp LT$LT$FLXH1@f.AVEAUIATIUHHSHѡHHL[]A\LEIA]A^fAWIAVAUI͹LATUHDSHHXdH%(HD$H1LD$AA1D$DED؃ =hH]HcHHHIH}#3HLHAD$PHAT$uLHHl$;HD$fDHL$HdH3 %(HX[]A\A]A^A_DD$HrHEHH|$HHP111HHD$(H HD$0hH01Hǃ01HHD$ L0D$AT$NIHzHOHJIHBHD$>fHT$ "LH۠AL$ HT$ HfЃ tq MW I7t{HNH1LHLT$gLT$D%AG bf.1LH3H@L8I7F] tHVIO LTnF] {HNH+NvB] HrHNH+J|@LHHD$ЊHD$fDLHHD$薙ff.AWDE1%AVIAUIATIUSHHHD$ DHt$0% ~ DD$D$$LGH1퐄uI9tGAFIt<'uI^AFLID<:AFu<:uI^AFLIfHIM)IL$$DLLLL$(蠚HIHD$8LL$(DL$I)E1LHLLLt$()HIL$ tIFHHLHHz0/HH[]A\A]A^A_DH5>zL$t0L$$LLHI5HD$8\fDI$PHp(HP8Lщ 1ƒ)詙@I$PHp(H1P8Lщ1 )hLxI$PHp(HoP8Lщ 1ƒ)-HH@I|I$PHp(HP8Lщ1 )LxI$PHp(HMP8Lщ1 )ƒ記HI$PH@Hr(EL$EH^R8Lщ1 )\LxI$PHp(H\P8Lщ 1ƒ)!HH@IDHB\=H0LHV Hv(HcJD <H%D НHID@HD$0HD$8'H=;HtH=; HMIXID$;MAGIHPIGLtI.HA~HEHHxxH5(w I$HPHr HH vE11D$HD$A $LHu3H5vL蔓DL$HL$(E1HLL9H4AG %,IHPIGLtI.HAvHmfDL1H5/vL1LH袱HH LHpHR IHD$8OI~HuH=uHD$8E1 HR8Lщ1 )LxI$PHp(HP8Lщ 1ƒ)DHH@IT1L$$HT$(HL觢H5XrHHL1PDD$ EDD$HL$(HHt$8LAԚHIMHB8HPH9JIE1L$$AQLLLL$(蒔HLL$(L$LLD2IHD$8H}HCL<%1H%IH%HRAT$tI1H%H%I1Hƺ LH@Hp 111Ht]Dt$$HLL)LAD=HHT$(DHL'H5qHIHL1ͣH%1Ht$0LcLHDt$$HAAUIATIUSHHDB dH%(HD$1AtNHHRHHH $LL A ADE_Ht$dH34%(u,H[]A\A]@HHDC HH $讐@f.AUAATIUHHSHHBHHH[]LEHA\A]ԅ@с.@f.AWI%߉AV AUATUH,SHhD$PHt$ L$TDD$X|$0t`I;IP@<"AE H63D HcyHcHHLl$ I9I(E1L|$8LE1LuHD$@D$PM׃D$\D$0 D$\f<'tHH9oL9s<:u{:uMDAT$OH9\$ IM)<:AGD$,M|$Pt$,LD|$0H|$8$L\$HكED@0DE1L裵HL\$HL8Mt4L;|$@t-A LcD$,DL$\LH|$8LLNL\$HM9tL ML;|$@IWLb MAD$I$HPID$HDHHD@Et H:<:LlI9S LH9DD)ML|$8u1@M0M8AD$D$PA tA0Dt$0$LLLEDE1PHL0I(D$,I9AF MЃ t$T@0Z@t L%D$8D$TDL$PHcLILLLAD L$0讼IP@<AUH 3 t.IPHxHD L赸tIHHM0M9 AEIufH|$8 HT$H謭HT$HIHB @t0HHPID$HDHHtDPEH:IHt$8H0H9p(HT$ DD$0HH|$8LH)čIH@(HH@HRDL$EzH|$8AL1LL]H OH=gLL A}AZA}ROA}GDA}V9A}O.A}U#A}TfA}SA}TA}DA}IA}N@AED$HD$$0E1A1L蔡LxƒAU? H3D IOHx AV HxHHtB <AFAFLL賮fD_AUVYIESIH'lHc HA#t)H$dH3%(H[]A\A]A^A_VHF H t tH=|GHuP u{Lh@< IAE< t< tL52AD[AELADtHADuPv2< t.t* f t < @ufDH< t<"$ IHADu.IA $ADtLH t tA<vt 1L I)fMIDhHPHp0HH|H@HHHpHHPH HHPHx0IHPLHHH@0LP衅IF0HPDh$  L{"LWHIHPHL< 11QRYLzHD$@IHD$HD$HD$Hx_@x%AADIA>yLH躁uLL)LlL9,$rLHMaLiHPB<u0Ht"A tAT$ADQt]AT$ADqIE:E:H@A|$:>A|$$2E:AD$HIEtAT$u׃@u"A|$? AD qMl$HLJitMYA$@ATH51>A USHH )eH HBt HPrtkHH =E11D$HD$$ AHbnHtHHtP сH []A\DHztHBtHH1ҾL cHH1jeH(HH1Ҿ!wHHH¾qHH@~ID$XH []A\҃ [HPJLHzAHBR/f.UHSHHHP@<uDH HHt@ uQu"tHHHT$ZHT$t1HHH[] ^HH%s<HT$с fAUAATAUSHHzH`HxH Hǃ`HHp0PH HcE0dHU8HH߉M0@H HPH HǀH HP [H DHDPCttH tH`HGH[H]A\A]fH5<;H1^HHdhfH}8 Hc1mHE8H HcE0&f.H H9=t fHCHt5BtAt=@H @@@H @@@H @@ff.AVAUATAUHSHHGKIH HHA HP B<LHH[1HHsH IƾHHcDLEA$AF#AtA@A tE1A%AGD@ H HɃ Ht@ u\1Qu% HHL[]A\A]A^ ;`1Q DHP F<t@[]A\A]A^Df.AUIATUSHH L%m2HADt'HHI HADuIPJI9L1ېHHH?HH9uHHLH@ItHuI$ J ;H $LHI| HLL)JcI$ J;H $HHHPI$ HAEIII9Ayƒ?IȀAEAUQuA$K,>I9A<>I$LE1HL$HCH9;SIƒLL$mHt$Lw0H2HHH)E11LI$dL:L$HLH9t(@<<wHHH9uMI$ HHLH@ItWsI$ HHJ<;HHH)aI$ HLLHHLxI$ LH[]A\A]A^A_ODIH+IHLHH@ItL)rI$ LM)L)H $HHH< HHH)`I$ H $HHLxI$ HHCDPIHL9t(AyANI? ʈPf.H[]A\A]A^A_H55L1PH,H5Z51PLSfATAUHHSH;=HHD[]A\H'fDHFtLH HfDDHAEH HLrAu,HH5#>fSHKMtE tqH HHtA t HPA<t#Qu uH[HH=B2147HH[HPB$HH5m"1=@f.AWIAVAUAATUSHH L%ک2E1HHfD<#tm< t ADtuCH<#tR< uDHKH9HHLHL$HL$CI HH9H< uf.H9DEHIPDL@$CIPj$I HHtiEt+Ht!HLE1I @A1CI HAHH[]A\A]A^A_H7H5 1x)AADIA>yLL2WuLH)LlL9l$HHL*7LH9L$(_Hl$( H;l$MHHEADuHD$(E8:I$ tƀHHH[]A\A]A^A_I$PB<ukI$ HHtNB tHs@ADvFD{:VE:CHHEfDQtGSADHE:E:HfHL5Ej A$ts@]@{? @AD <$<{t$0HD$8H;\$ I$ HHt B QeA$VHn2 HD$(1Ht9fH|$(HH9wH"H HAoHD$(<^ H|$8CADtHH;\$ sAHC tyfHP _H;D$ uHD$(H\$ HD$(I$P@<uJI$ HHt"A tHD$(A Qu A$uA HL$(L-32AlI$ HHHB I$PB<IL;t$ sII$P@<uI$ HHEB ;AADuA>:>fDAADIL9t$ vA>yLLRurHD$(AADHL$(HiH9l$wDH;l$ HHECHSADuH9l$ECHLI$ HH9L<I$PB<Hl$(<}HD$(H\$8hQuA$AADQuA$:HHEADu<:mH;l$rH52L13CI$PB<I$ HHt]A tWygƒK? AD~<{vHsH=O^Qu A$uAD3<$u*@H\$8HeHL$(HA<^+@@E,A/@A@tE@HL$(HI$ H< < LkLHt$(1LH)!ubI$ HHtB tI$P B<t1QuA$ Ht$(HLHI$ HHtB tI$P B<t,QuA$%Ɂ Ht$(HL.|$7I@H,L$@#@LE1A dfD HL$(HÈMHHI)LL.L;t$ EAT< t@D< II^H;\$ AFu<[t(<{eHD$(8suxuuxbu xMLJt\L|$(H1LL)Lt@;[L$7H L HL|$MLLEȉ $1LL$I$ HcP0HH8rp0I$ ,< ,LkLLa6tULI$ @0HLI$ ƀfD`H= @HH9l$INƒAV? ADƒHL$(Q? A J0ƂI$ @KI$ MLL;ZE< LHt$(L5qHsL;C^AWAVAUIATUSH^H8ndH%(H$(1H<$E<j]H5IǸMhHT$ 1 @$AHHtFH'2@ADt.AUA]tDAtA}]DDL9H$ HD$i@@@\uyDkEtAH= tHAdD$HغHAAI9Ft, v|h@-A@$@&H82DIcDDMcAAD$DE9Ft, DDAAA)HHI9Ft, wDH$(dH3<%(H8[]A\A]A^A_kAD$2H=T$@\DDlAL$H=H@DEPT$AL$HDE7HA-Dt$M-Hf.DFt, AƍA)H$HP@<RH$H HH*@  C$H՗2L[%HL$H<$E1ALHL\$~HL$L\$H!%tDHQHDHH+L$Hc H$H HHv@ lH$ HP@<RHt$H<$AL\$I-HL\$HAdL^f.QSH2L[;$ H؉LDD̓Mc$L@CB8K,ы<@HT$@s@uF<[f.NH2DtHDHDu<,t <}FHNDtHDuf.AWAVIAUATUSHHxdH%(HD$h1H2L$(D H HP9Q$FQ$AD$&H HHB HPB<HHL$HLHHT$HH|$P LLc!|$&H yqHPt$&D$'R$PxH @t$&H=cHt`@D$&D$PDNQt$&HD$H@t$PDHPt$&D$'R$@PxH @ut$&H H@:IHHxOLx AD$ t$(%_DAD$ ^H|$PH Lt$HE1AH|$H|$DHH|$H8 Ht+HHA HPG<M$HIHHL)HTI9PIL$8I9|$'Qf.<\t|::t@uH IHL9A< uHuRuHP@$AH <\u@IVH;suAF::\HAFIcf.AE3@|$'HI+T$I$HPH L;IHI+D$H-A< :< XA< DHP1H߃@$H HH*H HLAQuf.LH+ALL$LD$LH߉D$DHD$H$H It$HHcT$DHQI $HIL9HtvMMDII9t7A; uH HuRuHPIA$I9uMބI$Hxv ~\H @8IL$IcHH9HIw9f.H :@@AH LzH9v@L\u΅uH H:tw\HHHHH9Lz wL9v D$&LzBBLI+T$I$HPIL$AA)EH H8 HEDHOIT$HFH9r ~\uH fD8\u HH9uHVH)ƒuD$&FI$HhvHHtB t HPB<tQfL$(uI$HhI$IT$H@H8 t2H HHB HPB<D$(Lt$H|$'AL$ HPH R$P|I$HPHJH;HH HxpL``LHt$hdH34%(=Hx[]A\A]A^A_QylD$([HL$HALLH(=ILHI$H HHHH@H8 lfI9$Dl$8Ld$0D|$/H@HfHHL$#/H@HL$HfHPH LHDf.UHHSHH|HHH[]1H*fDAWIAVIAUIATMULSHH(H HLH@H@ tH= LHtIE1L$A HHL\$&HHtHL\$A <%H5[L D%L H H|$hHH50HET$hMH1.HHuH&EPL҉Uu0HHLd$q*HD$H([]A\A]A^A_DH(H([]A\A]A^A_H5L3 t3H|$hH=H5tHET$hH1-HWH5=H(.H50HHD$.H5 HHD$-LL$LD$11HH$1HsHLH@Hp HPCE1L$A HL\$$HHL\$HHA <a,LHHT$L\$wHT$H|$`L\$HHD$qH|$`A)L(H`HHHIHA(HA HH@HXL+[HILXHH@HCHHHRHHS HHHRH,H+HH`HXu(Hs\H.SXHCpS\HPH;SxHSpHH+KH HS H)H/E HD$`HULeLuHEHHHt$҃&L3BHHFH8HA LA A HHfWf.@(z HHPH2HTHA H7HHPH2HF iHvH*#IFAD$HHH(L[]A\A]A^A_H<1H)H@HHHV@ H HHH M&IFMtAD$HC\9CXHwH`HH@HHXH+SH HHQHHRHSHH HIH HK HH HIHHHH`HXAD$ <u Lk@L H 1H{(H@H8HHFHH1HL(H@HHHV@ H )HpHHH@HHHHFHHH@80HA@ f.HHHHDH|$hHT$pHt$hHL\$L\$IMLLHL\$HD$`dDHID$@ \H1H&H@HHHV@ H 'H+HHx k~HULeHA@ HuH1H&H@H0"1HHH.HSpX HL\$NHH`L\$HAH`HH}1HH&H@HHHQ@ H2YHH1H%H@H0H1H%H@H01H%H@Hz1H%H@H1H~%H@H1Hh%H@H1HR%H@H\H`Htx t&H$H5ͰH1HH@H@HtHH@(HuAUIATIUSH8dH%(HD$(1HHD$ HxV с 2HT$ HAD$ <vI$Hz HT$ H,H9r HH9;\u{\uH9tsAL H9HKHH9HDBHHDHrA\uH9DCA\B\HfLALt1H5H<$HD$MA1Ht$HL1H|$(dH3<%(uyH8[]A\A]@H@H^HD$ @H\I+\$I$HXpDH% It$LHHff.AVAUATUSHHdH%(HD$1H hA(H fH HPXHH ƀH @KH HPXHvHPH H@X HL$dH3 %(H[]A\A]A^DHPXHPH H@X f.HppHH IŀL 1LH?IFH EH@p `H BKPfDHPXHHR(HppHR(HjfHE(H HPXHPH H@XH H@p tMHIuHPH$ HvAUIƅtEAUtGM+H"HHAM H$HLHLHAWAVIAUIATUHSHL9H|$LL$ADDHL$u!Ho2Du31H[]A\A]A^A_fC<wiH HcHfDH|$H1hfDAGHH@HIHLHHt&ItHHtHcPT  DAWXLHH1sHHgeH8E1$E1:1HHILH8?H5HHHE1H5k2H=m1ff.ATAUHHSHKHHD[]A\HfDAWIAVAUATUHSHH HLLLHH HHA HP B<HH5H1HHH'M9|H HHHPP<uvHHt@ uQu[tR H5h2DBDLMfD1Q0 D Hnh2DHHt @ RQu%Ɂ LLHL)'HHH1~H LH[]A\A]A^A_ÐHH@ Lg2ADu(<:HPHR<փHtJ@ tDu@H Vj2H փyHJg2DtHHuQutQut@AAAHHH +1fDH9Hf2DHHt@ tHP @<t*Qu%Ɂ HHH)HVHH*DCA?D Lf2AD^fDHP @<DM?΃@uODCA?D Le2@AD A?HH1 H HHH HHP PHT$(Ht$HH|$H) H\$(fH|$HdH3<%(HD$(uwHX[]A\A]A^A_Lt$LD$(AH|$V1AN DE)LpAN H\$(HXPH؀.HL=fb2.Df.AWAVAUIATUHSHdH%(HD$x1HT$(<9I<1<.<0Nʃ߀XBFLfE1A1<_H$.2McIE1E1DJ4H-2ILl$ fWIL5sDHt$0J4H`-2I\$J<ҍPHt$86H|$@IcL.6L MuE1H +a2MPMJ(<_Mt IL9IAII^Dt<_tM9 A$IfDIHHx '8LH+t$hLI HD$PLxHH`@ VIPA<@fzh#D$@D$`g9H$Lt$hD$XD$HHD$xH$H$H$H$H$H$DM9I fzh# A<( <#i <@1 AF\ IPA<kHH=A 3AVTHR2?I LI HpII LHp0I LHI LHP4I LHp4qI LHpl^I LHI LHpPI LHphIPLHp$I LHI LHsI LH]I LHGI LH1I LHI LHI LHI LHp8 I LHp@I LHPpHI H@pI HHRHHHHHI HHHRHI HǀHǀI H?I x@II @0I ǀI ƀPI HC8I HC@I @4I H@@I @lI ƀI IPRxP$I fPhM fAh$5AGhf4IGP(II9 <AGKH H:@@IH ƀ L AIg5AGlPAWlk6I H4Hc6HxPX6@KI H,'AƇ H H51LHA>. I AtHHH HZHYHA>#, L9F4LE1 A^fAHH9sDA~uـy~uHEHxtI @KI ƀIP@<uAI HH4B 4HEH}Hp4M I 1HLLcD LJ,tI -LHcDDŽvtM AGLAGKI L;vII;oC<$pHzPtCInI9A^H=̹H\uHLH|$PAL+HLxHHPHHH95H|$PO DI8 H-|$@W-H|$PO I fxh# HHPHJH;Hi+M M9%*IGPAHH AtaAWhH=)f#tf!H=C0HD$hLL$PLHt$H|$LH$H)HM HD$PHL$P1ҾLIGA>\I +ƀM M9,IcDIW LII @KkI BlHJlI +P4*HxP*@KI L,fDA>-vD$X,@LIN@DD< t2A t,A tI H;E15DHfRIE1HD$PL+xHH@HH9PHD$PIcHHqQLy@9)1HTHH9uID$XD$H^QuAHC2A^H=sTHI HxP-+fInI9gL9t$h\|$Xty|$@AII{ eHUHEHB@ @HEHhCH{PAFH B2Dj<0T4AvDRHAL1A$@HL$xLE1L)LLwHTH|$PHH+OHHHHLO DL)HHLLHH[HX{A~{AFHA2I^Dt+HH0@Du@,Hh@8}}HHL$pHHHL$pNHt |$@A~Uu A~+LHHLH)HHL$pYHL$pI11A LLt$H$HAH BHD$H$1LHHD$pH|$pG iHH@H$HGH$H$H$I HxP.H$HA\N{}IH|$pGGLtw|$`AFHP@2bIFH9vMAN@tHH9t9@uHPHAH)A)IH$HL1xLu|$Hv"Ht$PL3RL LLL)HXHID AFp@K@H5VHcH82#LIA IEM MI E1LL$HLLHP0fM L$IIPLH_D$`u A>:)II9DAH-72LDuDt HH9u;=u {>IMLI HL$@LHPH82I LpGHM 1L$LMPDLL$pLLT$hQ|$`ALT$hLL$pu AK&E#E111AyDH= DHcHIM A D><#=II9r}[II9t A> uILL^M AGL`A;G0VMI LƀM AG0d~I8 HcIG8M IcG0IW8M^HAO0I I ABKI LANI |33=Pɍ 93LMfM LAG0d~I8 HcIG8M AK/AWKH]HcHAFH-$52M DAKAG>I M^0L@KI L-i11LL聡HI xKuH53HLH)LeI IPL9Q$FQ$I @KI HI ](1A~=P 9=(LFI I^P0x:H51LI M A 2IPA9B$FB$AI @KI H]M I^fAhtANHX32DLAKuH5רHLYM AGKI HHUA~~M <9AGKI M^L~"M IcG0IW8|@AG0I^IW8AG0HAGKI M AGLA9G0}A ~AGLM A aAGK}LXI H;_A~:7M IvAGK<7<71AJOAI @KI H:AFIN<>;I <=9.1BII M^@KI L.M AKuH5LLTM AƇP@I E1ALLHHQ܉M HAQl!AGKI H@I {KhM^I @KI L?AFH-d02M DAWKIFuHtu_t./Jv IHtB tIP B<t1AQuA L)A LHLH>I LLHP,I IP9N$FN$I BKI H M AK#A~LHNA~<T LIP±HIPITIVL$A>LHH/$HD$@?L;d$@>AP$>M u3(DIP@<u~HI12HW(IPB<u"IHB +H.2Du<'t<: (IHt @ uAQuAs`I #IPM^9A$FA$I @KI L;A^IN=r>Jr~rtAFH-9-2DWJM MfLAKCoH--2D1oIHI9t A~ oAtIeMARI u P8IvLQ8{I [7IP9N$FN$I BKI H)I IvHH97H;7@KL̃I I H(&AVH+2AVDI IVI^HI AnHH9kAV tkk XkHH9uSkfDI zK$A~= PLMD11LL蹗HI xKu"PLt ;P0pH5THLHQ{I @M IwpF H1HHNH@H$H$Htf<$#<@<\Hy/@<$<@<\HHHH$uIPAL9B$FB$AI @KI HxAFI^<=")<~I "@KI M^L!I CK<6AF=4qI"/LLLM ARMMMMI HHH@HAHI HǀHǀIPM x$ dAGLA;G0MI LƀfM IGM;ILJI HǀAM AAƇEEH-g 2D H59]1ҹLWHI HHtB t IPB<tQC>A5>AH"2 LLA HHLLHII LMtAD$ t IP@<tQx.Aj.HLL8H H$^.MtAD$ t IP@<tQ..A .LLHAHL?I HHtB t IPB<tQuAtM L$H50HLL1AlAƇP-M H]IH9s!E< t=< =HH9uLM2IcG0IW8HAO0I I @KIPI R$PEAD"<#I H{"IcG0IW8L2HAO0I I @KEWLEBAGKI L3II9s,AF< t!kfE<  kHH9uAƇPM I;}-HIP@<;L2A IQL$E1HLLT$@JM LT$@IH9r@HH9t  t t8}?uHL1ҵLL§I IPL9N$FN$I BKI H髿L購雿I HcDDŽz.H5>ALn@C0V@MV@AVI HLwLAFA:<>LM I^AKH2DuIDuII9sAGKI H-髾顾ID$P1:IHt@ tIP @<t1AQuA A LLL HH H@DxEH@HHHRH@\HDII HHtB t IPB<tQn^A`^$IHPE1$A LHI7HHtC ^AA./AMA IGHLH@8HIDHHH 1HwiA~:YE1HLM Qa<7R*A/HLL98 L u-H=HHt#HL98 HLHuHPH5L1t@H5LInH$HT$xE1HLHDŽ$DŽ$ITL$H2I9%;:{:ILMLsHt@ tIP @<t1AQuA HLLܠ1HLڸIGI IP9Q$FQ$I L齺DA .AK2II9AƇ@I IP9Q$FQ$I @KI H@?AƇP$I E1ALLHHQgM HAKAQ{ I;SAGKI H$AVHm2D[1A~:YH=rHBE111II;,n@D$HA<'m<:D$PmAKu-II9mH5LLM H$HvAN:2iHdHDŽ$IPL؍LHL?MIHD$@t[H5UJLILD$@HLIL螯LD$@Mt"A@hA@u LLºIPI L9Q$FQ$LM 1H$ID$I H@@#@D$H%<v |$H*I HHtB tIP B<t,QuAہ HPH舌HHL8\$HHIL1HёA؉پL1I LB]I M^DL@KI L?߶AFIV<<Y<=YAIVjAGGI @KI H.鈶I HcDDŽ|B<I M^0L@KI LI?4I^}H賍HXIIH5=}I)L)IHH$H$HT$xE1LLLT$pH$ٗL$L$HLT$pM9t#C HML1NLT$pNt-I HcDDŽ} UH݌HFHnjH#fI ǀPLE1DE1E1,I@1DLHP 1@@U1@t'HH@HRHDHHtDPHEtH2LƃHlHALHրI HHtB tIPAB<t0QA@u!AEAAHMHQHLdI H1ҾL諱HEI H@@#I P<$t 1<@ AHL҃ rI HcDDŽ~A~>KAƇM DAG\I EL@KI H'BKM APIPt&LHI IPL9Q$FQ$I @KI H鱰II9IcG0IW8HAO0z<I LL\H<}&<<'9D<"1D<`(D 8AGKI H4fDAQtA.aPL鯮A~.A~.AGKI M^L(qA +tAG0tHLZM HAKII9AGKM A @AƇ$I H$AGKI ƀ#I H2­ƒ( S? HY2DPM YI^BH5rL1ȃudH$HBI IP9Q$FQ$I @KH5tdL1gH5FdL1VH5/tHPL1>H$HBI IP9Q$FQ$I @KlAGL1ҾL51HL@#@T1HLHD$@eM IIHt#I;sI;I;LAGKLiFI<=D<(F<{t<$u MgFu]IPB<u4I HHt A QuAH.1DA>$MI|$H-aLLnHHHt$@LiM IGHp(Ht FEFvEM IGCHX(I H@@#I H@H"I L鳘I LHpI H|$@HxI H@H#I HHI fPjAD$ < I$HPID$HI IP9Q$FQ$I @KI LI HHt@ tIP @<t+QuA%ہ H$HPHuHlHLH:}HqIHL1@] HxIL$HWH+PH@HD8;u H8;t$_r@\&uwA>{uqI8IpHLM AuAPvAƇPM AGKI LhI LHcDHHHI @KM AuAPvAƇPM M5H"LF1p@lPu$kE|$X(M tAGjf=t7MEfAP_}AWjH1%= ^II9AGKI Pjfv ffwAtH@H#|$H-%LxI L1PHPAD@tHHAD@uHHtB tIP A<t1QuA LUyHjI Hn1%LHP1xiAALL轨HOkAȾL1iM W@KI LM͑L~1ADII9t;AGKM HL>Rt<[<{tJM HfAjt+H=v[LT$@hHLT$@(AGKM $I ƀP%M AQSARIASGATLWT}HRhH>=HA=AGKI H4pƒS? Hl1 I\$9H=5ALT$HLD$@HHLD$@LT$HHA8M9vA$I\$\t[8tLA8I9IwHI\$I9HA\HL^NuI9vI\$I IP@$BI @KI LoI A@I @KI LI HHI fD@jA>(up*;oP.o`I Ao@oI @KI LI HHI fDxjA>(tLLJ8(t,nLLPnLL6nLLmnI IP@$BI @KI L(nI ,@,I @KI LI HHI fxjA>(I @I @KI LI HHI fpjA>(2PemLrLFmI @I @KI LI HHI fHjA>(LL考lLLI BKI HlL,L3lI @+I @KI L)SlI @I @KI L)"lM H]I fDHH9s#8t\HKuS\t8uHKHL1mHeƒu S? AD 8HL at)M E:u 1A~:IAA>#A~!LHAFH-=1DtHDuI܄u@IA$tDtH52L]mHu3HDt u H t t I fBjI BI @KI H,i뺸본문 른랸뗸HE1E11L~I BKI H-8iG=3AGLA9G0|DAtAGI @KI L@hfDH t< t<#t < DuAGK߇H=2LT$@!@HLT$@IPtD@<u.IHt B AQuASAD@<M IHt@ uAQu]AtS5A ADuP<.tYj-~Z"~Af@ƒuQS? A  =y=HLLT$@JULT$@`I tWBKI H,#fI t?BOI @KI H/ePvLeP vLeI @I @KI HGeAP~Mse,Mt$>ILII HL9vA|$]tII9tA>]uLLH=L1L)?INAAGKI @KI H.\A~=AAPM\LH)HfH5&H<JIP@<u-HHt @ QuAUH1DAP M\t}AGSI @KI H/[AGEI FL@KI H[Ex1HN1D_hAP uMl[ƒ` U? H1DM MAKuRA>=uAuAP[AG>I 0L@KI LZII9LLM 81L#kIFHG1AFH5!1HH91oHxHH 1@nHH9woHL\knHt$pL~!YnуuH? 띉ƒkAV? EH$H$AH<HH$H|$PL+LL$mSAuH$8DEH$L!1}!H$LcLH)H$HTHD$PLHH9P HD$PH@H$H$LHHZ?J8L$L$L;$Lx}l|$@tpH$H9$s9H|$PLH)HT HGH7I)LH9VsHL>H$IH$LH>L$D$@wlH|$PLH+WHHHPO DLAH$H)ILHLa>IH$MLxH$H\$PL$H$H+CH$AH$LLL)IQAu A?fDEH$L1HcH$JT HHH9PHCJ H$HH=L$H(L9$?L$H$H$)Ht$PL$=H5,LUjH$Ht$p"L13H$jH=+1fDHLM H|$PLLH)HH+WHHHPO DAIL;ID$@MLxhA~>AƇM ivH5iLISVI HxP HLLL)HHI;iA~>QDD$PECHt$@L8CI IPL9Q$FQ$I HPH@Hp(/M IHte@ IPt@<t[AQuAt@<tAA9P$FP$AI @KI LATIPH$IPOtI H@H@(H M IPIHt@ tIP @<t,AQ uA%Ɂ IPA L>M H飚LUM } hSL_Ht$@LAI HHI fpjM AuAPvAƇPM AGKI L RIPI 9Q$FQ$M䉐t%AFIn< u HE< t< t<)^I Ht$@LHcDHHHI @K@LI @I L&1R|$@H|$PLH+WHHPO DHAvNHvCHv8Hv-Hv"HvHH9HɃHL|$PLH)LHLL7IMLxHw)AD$@I5fLLR@L1HL/D$@IfLL&HHLuI tqIP@$BI @KI LPI t?IP@$BI @KI L$PPP뀀PzPH5w ALi;I @I @KI LI HHI fPjA>()HuLȄI HH9LLhAO:LRthI HHtB tIP B<t1QuA H$HPA LG:HtLH$HPI HH$ƄP3I L1HP.I锖I HHtB tIP B<t,QuAɁ H$HPLH4Hq(HL1%(AH1DLHLL__AyHt$@LS'I H\H΁HEHHt@ tIP @<t+QuA%Ɂ HPH$L90H5HHL12IPAL9B$FB$LAI HP]1HLGHCI H@@#@I IP9Q$FQ$I @KI LICKI M^ALLICKI M^ALLydIƒAV? H1D ~I Az@zI @KI LI HHI fDHjA>(L Lg_HLqLM_HI A-@-I @KI LI HHI fD`jA>(lI A@I @KI LI HHI fDxjA>(I @hI @KI LI HHI hfPjA>(II k@kI @KI LI HHI fHjA>(YLuL]GLL]FLL]FI H ALLHPfSLL5I LE1AHBK1[HL!]rFLL]XFLL\>FI :@:I @KI LI HHI fpjA>(I e@eI @KI LI HHI fxjA>(HLL\nEL>L\TEI &@&I @KI LI HHI fXjA>($I @I @KI LI HHI fhjA>(^LL3[DL-L[jDLLZPDLLZ6DLLZDLlLZDI @6I @KI L)CI @5I @KI L)CI A@I @KI LI HHI fDXjA>(nLLY)CLLYCLLnZI IPL9N$FN$I BKI H"%BI A|@|I @KI LI HHI fDPjA>( LLE1问L=LX.BL;LXBL<LXAI A@I @KI LI HHI fD@jA>(]LL2XAI A\@\I @KI LI HHI fDPjA>(QI @dI @KI L)@I A[@[I @KI LI HHI fDHjA>(XL4L-W~@L2LWd@I AZ@ZI @KI LI HHI fDXjA>(2I Y@YI @KI LI HHI fXjA>(lI @iI @KI L){?LLVa?LCLUG?LDLU-?LELU?LLU>L'LU>LLtU>I @I @KI LI HHI fhjA>(*I H ! LLHPJLLT0>I Ƅ$11LL@HH$I @8xu HH$H$Zx11LCHH$I Xx1Ҿ!LL$1 HX@IH$( HL$@H5(MHL!4AD$B tHUL1^I L`XI @!I H$HxIPL9N$FN$I @KI H#I H@pH5kL1q$L9H;H5b 1LeBH$HI HI HHI @|AL$@@DuAEHHLDLtLQ;I (@(I @KI LI HHI fHjA>(I A@I @KI LI HHI fDXjA>('LLHI L1@KAD(eH޺LLT$@P8vHLT$@IPL$gI E1E1LL@KzJI BI BKI H&5LL9L5I @I @KI LI HHI fpjA>(ZI @!I @KI LI HHI !fPjA>(I @I @KI LI HHI fxjA>(9I A%@%I @KI LI HHI fD@jA>(GLLJ4I Ag@gI @KI LI HHI fDPjA>(e11LLHHLBI IPL9Q$FQ$I @KI H;311LLHHD$PqI @KI H@pHHxLIM IwpHt/Ft`FuL65I H@pM AGKI LLH|$PHCI Hx2L먾$L4DI HppF % =HH^H@H$E1ELd$@HH$HUL%1ADHHH$UADHuI A~@~I @KI LI HHI fDxjA>(/LL /I IPL9N$FN$I BKI H}1HDD ШEADH$HHt HHH$ADuHuAAI 1H@p@ tIP@<Ɂ HHLH)ALH1HL4.HT$@HL(HD$@Ld$@M8(HT$HL`HHAAGEHAD1H$"Eu<,taEuQ<#uH $L1AH$HHPH$ADHuAHV $L1A11LLHI BDM IWpHHz 'uHB M IPAL9Q$FQ$AI BKI H#.11LL/HI LBI IP9N$FN$I BKI HQ.LLD7.I @I @KI LI HHI fpjA>(I H LLHPb:LLQD-I H Y LLHP(:LLDh-I @.I @KI LI HHI .fPjA>(ͽ8I @I @KI LI HHI fHjA>(rݽLLGC,E11ALL"ALHHDŽ$HL1ADtHADuHL$@E1E1HD$H$HL&H91LHH1HL/H1ҾLH)I LHcDHI @JI @KI H+LLBp+I Aw@wI @KI LI HHI fD@jA>(ӻ>I BI @KI L=*A>(I @aI @KI L**LLHIP@<u4I HHt B QuAEL~1A dL~1HMIP@<u4I HHt B QuA}AI HHt@ t IPA<tQuAt H5*1 HHt@ tIP@<Q2Auj#HLu/ I HHt@ t IP@<tQuAtH1HÀ;xMIADtHADuH= 'H!L<=1<:L1HH)L1I HHtB tIP B<t+QuA%Ɂ HHL HIH!L1 HL^>'ExLX|1A \ƒu\UL4|1? A -x@Az{:t{>bHLƒ:S? AI E1E1LL@Kn;I BI BKI H&&L$L-=~&ƒ⿀;<}HLHƒ⿀;<}I HH$HgL$ZI n@nI @KI LI HHI fxjA>(wLL,8(IM EEuAPvAƇPM AGKI L?W%1uL1L@I BKI H %P%I t:BZI @KI L/$HLXP v$ALJPARGVEHtB tIP B<t1QuA Hc$HLFHHjI@1ɉLH@ %@=@1Ҿ L! EHhII ZH1ҾLx1HLLHL@HLc)HEXEI H@XH"郂IPI H5LP$1)1HL>!HCI IP9Q$FQ$I @KI L#IPI 1LHp0 1HL HCI IP9Q$FQ$I @KI L"H1ҾL>(I@1ɉLHP 1@@uI@1ɉLHHH@1@t%HH@HRHDHHt @HօtH2L^LHH~ HALHcIQHL!!HuAI H҃ Ht@ tIP G<t1QuA% ¹LEHM H1ҾL 1HLG H1ҾLH 1HL&HH¾L@HL&IFX0IQ1LHQ 1LH_&1HLM&M Dd$PMAK gMLLHIP@<u5M IHt @ +AQuA*Lt1ADQ,<'F,<:J,|$PVI H L1@KIp+D$`HD$X|$PG1Ҁ;(1<:<{t|$P ,tEM L1McDINpBKI LH@p螚@urI8IptKHZ LtI H{:]|$`I @xKVH L)I Ht$X1AALH>3|$PI H3s/L 11HLD$xHH$I HppF 1HH@H$H^H$NLr1E1@$L$D$HE1D$pD$h E1L$D$@1ADIIAH$D|$xAD=E"|$pH=0 D$L$AAEΉ$HL$D$xE䋌$hEt-H= D$D$L$HEDA[A]A%tA@ut HcA|\t|$@t:D$HA_AADD$HH$IHHH$tHcDd$hE1D$p̉ALLcE$L$B;t%L$hMpH Iپ/L1tEI H$LH@pHLxHXHT$@LZHE1D$@#E1D$@A E1늀;=uI x0WPL@t.I Ht$XAA1ɺLH0I @KI HJ8@H5 LH5ͬ 1ҹLII H@p@ X' LHLALHLL#|$HHp H MpI/LHDH 1rH5 L1I LLDd$PfDIIPM @<u.IHt @ HAQuA0ALn1A `AGI @KI L7I @*I @KI L)I 8@8I @KI LI HHI fxjA>(eELL//IPI R$PI @KI L#LL/I A@I @KI LI HHI fDPjA>(A鬩I @XI @KI L)PLWL.6LVL.I Ab@bI @KI LI HHI fD`jA>(I Aa@aI @KI LI HHI fDxjA>("鍨I @cI @KI L)1I @UI @KI L)LTL-I @SI @KI LI HHI SfPjA>(K鶧L3L -qI @0I @KI L)@I 1@1I @KI LI HHI fHjA>(I @I @KI LI HHI fhjA>(J鵦I @RI @KI L)YI AP@PI @KI LI HHI fDXjA>('LQL+I @kI @KI L)I @OI @KI L)I M@MI @KI LI HHI fXjA>(PLNL* I Af@fI @KI LI HHI fDHjA>(n٤I Ag@gI @KI LI HHI fD@jA>(|I @hI @KI L) I @I @KI LI HHI fpjA>(I tNBXI @KI L.LvL)pDd$PP vXI Ap@pI @KI LI HHI fD`jA>(&I BWI @KI L.I A{@{I @KI LI HHI fDxjA>(銢I @}I @KI LI HHI }fPjA>(ġ/P I E1E1LL@Kq%I BI BKI H&L/L0'I @I @KI LI HHI fHjA>(QLL& LL&I l@lI @KI LI HHI fpjA>(W LsL,&}I 7IP@$BI @KI L8I m@mI @KI LI HHI fxjA>(LLr%I E1E1LL@KB#I BI BKI H&lI t(5頞P lc I j@jI @KI LI HHI fXjA>(ȝ3I Am@mI @KI LI HHI fDXjA>(k֝I 7@7I @KI LI HHI fhjA>({I @I @KI L6 LL" LL" L@L" L"Lf" LLL" LL]I IPL9N$FN$I BKI HF LBL!, L?L! LAL! AL_1A I f@fI @KI LI HHI fxjA>(;馛I @_I @KI L)J I @^I @KI L) I @]I @KI L) I @jI @KI L) IPI R$PI @KI L  I @KI L] I A@I @KI LI HHI fDPjA>(+I E1E1LL@KI BI BKI H&LL{t]'tE1AHL-I VBI BKI H39I BKI H3I @KI L%H L H H5 LHD$8HD$(H HD$0 HD$ HD$ A HD$H H$ HD$1YLL_I A@I @KI LI HHI fDxjA>(—-LyLI @I @KI LI HHI fPjA>(M鸗I +@+I @KI LI HHI fHjA>(]ALL BI A@I @KI LI HHI fD`jA>(dϖL.L9I @KI @I LI HHA>(jLL贱8{HI @KI @II HI HH>( I BYI @KI L/I @`I @KI L)nI @I @KI LI HHI fXjA>(Ӕ>@KI @KI @eI @KI L)P LLNI Au@uI @KI LI HHI fDHjA>(mI Ai@iI @KI LI HHI fDXjA>(I @I @KI LI HHI fhjA>(J鵓LLpI A@I @KI LI HHI fD@jA>(Ӓ>I u PIPLL@$B]M HAKAGKI H"LL$HIPLALIH$IHM H=B IPLHHDŽ$|:IHt@ tIP @<t1AQuA H$A HLHt7H@HpHt*LBHt@ ,HHRH$HhI HHtB tIP B<t1QuA $HLHM I!MI L$L0 LLP1=0I HHtB tIP A<t1QuA LLM |HT$@"HLH|:*IHt@ tIP @<t1AQuA A HLHH@H@ IP@<u.IHt @ AQuAsHkS1 IHH)H~bH=v uKH,S1HsDuI A9@9I @KI LI HHI fD`jA>(!錌A>:]A~:f]I LL$HIvE1LLT$pHP}M L$LIMPDLD$hLLL$`ALL$`LD$hLT$ptZxP-tC=tA6IHt@ tIP @<t,AQuA%Ɂ LLLH5 HL1M I)ApARD)I8HuI0@2HH@HRHTHHRHHHH0HHcnt H1HtHcP\  H5 L1HUAHL'HHHHC Hk KLHEHkI HELHHPI H1҃¾11HCLH@HI HH9HCH@Hƀ,LI1AD AGKI HH$LL$HHAH+HH|$XLwL$:HHLHtWIpLHL I H@ tIpH HLD$`HIIpLIpH LAIpH$AHL]ƒu'SLH1? AD HLM {:D$H$E1A<LHLL1@t-<}D<;IpH5 L1H5s L1LL I '@'I @KI LI HHI fhjA>(I A)@)I @KI LI HHI fD`jA>('钃LLMH5A L9I @I @KI LI HHI fXjA>(I A@I @KI LI HHI fDHjA>(6顂I @I @KI L)ELL+I A)@)I @KI LI HHI fDPjA>(I A@I @KI LI HHI fDXjA>(1霁I @I @KI LI HHI fpjA>(րAI Ax@xI @KI LI HHI fD@jA>(yLLNI B[I @KI L/`LL՛8{I tlBI BKI H)ƒuTAVLC1? A P XBKI H!LLM f.USHHH BlHJlH H4HH`HtPhf!HH HHRHH HHHRH1H @KH f)H[]H5 1H HA tH H BKH HH1Ҿ{HEH []ƀH[]fDHH H@PH HHRHHHHHH HHHRHH HǀHǀH HTH @IH @0H ǀH ƀPH @4H H@@H @lH HP`B@ƀ H @l,KƀH H@`,*1f. x@x@x@x@u 1ҾsHv PH5 1:f.u 1Ҿ`sHR PH5a 1 f.AUATUSHHdH%(HD$1L A$uS>AD$H xHM1+HL$dH3 %(H[]A\A]@1HPH B<Lu.HHt B QufA$H1 H@THH HHH@HP(WH<ƒu)AT$? H=1 LHzz:HHHH HH HH HHt@ tHP @<t1Qu H$H9a课H0 H51 ff.u 1ҾpH PH5 1f.USHHu^o1HH7}uHH[]tH5ǫ H1ZHHHH[]H H5w 1 UH` 1HSHHA)HbE f%ft6H HHcDHbHH߾([]bHHUAVAUIATUHSH~ H^(HiHcV~eIE1҉Vt.IcUAID9~=IvHtVuH HAIIcUD9I} HRHH)H9L5) L% t IuH苩IuHAuIMI1H誵IcwHIuHRIuHHCAuIH1HoIcwHAMIUо@MEHIcwHIU11HIcwHrIMIU1HйIcwHTIMIU1H貹IcwH6IuH蚨1HHH@HxIcwHIuH`1HHIUHHOH@H*IcwHIuH1HHeIUHHH@HIcwH`IuHħ1HHH@HIcwH&IuHZIuHH+HH&I辍H1H葳HH @KIcwIuHIuHHHHI辍H1H5HH @KIcwnIuH袹IuHHcI辍H1HHH @KIcw'IuH苦IuHH|HH'I辂H1H蒲IcwHIuH:IuHH+HHI辂H1HAIcwHIuHIuHHI辂H1HIcwHIIuH譥IMI1HױHH @KIcwImIU辔IMH'HH¾HdH@H?IcwHH0Ht@AuME11H蟺IcwHAuIM1H!IcwHuAuIM1HIcwHWIM1ҾHIMIUHžH\HH¾HH@HIcwHIM1ҾHUIUIMHžHHH¾H:H@HEIcwHIM1ҾHIuHHHH¾HH@HIcwHCIM1ҾHIMIuHHHL$(舣HL$(H¾H3HH¾HpH@H{IcwHImIUHAu HH¾HؾAuH@H4IcwHImIUHAuĝHH¾H葾AuH@HIcwHAIUIMHIcwH ImIMME1H耲IcwHAuЃaHHIcwIuH2H@HIcwHImImAu1HQIcwHuAu1H7IcwH[IuH迡IUHHH@HIcwHIuH~H@HiIcwHA}IMFHҁ=IcwHA}FHҁuIcwHAuIM1HIcwH{AuIM1HIcwH]Au1HIcwHCIuH觠aH1HIcwHAuIUHIcwHAuHHIcwIuH:IUHH6H@HIcwHIuHIUHHH@HIcwHTIuH踟H@HIcwH'IuH苟H1HyIcwHImIuHHHIuHHIH1ҾH_1HžHmH龎HH躺HH @KIcwsIuHIuHH.IH1ҾH1HžHH龃HHDIcwHImIuHH1HGIcwHImImImImH/HH贔IcwHImIuH蓔IcwHgIuHkIcwRAEHH!H 9Im01)Im 1ImImImH膪HH IcwHIuHIcwHIuAUH藜IcwHIuIUHKIcwHH5 H1HH 1HžH'I辴H1HIcwH6IuIUHQIcwHAuIM1HsIcwHIU1H9IcwHIuHAIcwHIuHٵIcwHIuHIcwHIuH9IcwH}AuIUH=IcwHaH 1HfIu1IcwH7AEHH!H ImIuH艮IcwHIuHaIcwHIuHIIcwHAuIM1MEH7IcwHIMME1HIcwHH 1@KIcwrImi1bImY1RImI1B1;1ҾHܹH0HH!HߺH FIcw1H螹H0HH!HߺH Icw11HcH0HH!HߺH ͳIcw1}ImtHIm舩Icw_HImsIcwJHIm^Icw5IuH虙HHIcwHHT$ H5HHl$@Icw1|1t 1;HHH!H ڨIcwIuH%IcwH1AUH H߉MEIuLD$(IM1ҾHH趨LD$(H1HHѹHIcw+IEH߀H"Iu藫IcwH 1IuHxIuHHiIcwHMEIM11E1H膬AUHH IcwMEIMHIcwHImIuHIHHIcwHOMEIM1H踧IcwH,MEIM1H蕧IcwH Im1H 1@KH ǀIcwH @KImIcwIUAuH蚻E111IHD$H$IuHHtIpHtH`H AU9* Icw@IUHJ!ȃD$(J!IuJIUЋD$( B! ȈB!IUH J!H߉ȃD$(J!Iu耓D$(IU B! ȈB!IcwIMMM1ME1HTAuHHuApHH IcweMMD$1IEE11ɺHH$蝌IcwH1MMME1IpImHLL$0LD$(ELL$0LD$(HH1H諩AuHH̹AXHH IcwIMIU1MMMEHbApHH耹A@HH IcwpAMIUHMMIuIXL$HB])IcwY11HIcwHAIm8IEHImH@(HpIUHHHR(r H aIcwHIEHImH@(Hp]IUHHHR(r H IcwHImIM1H11HIcwHIUIMH]ƃ I}HI}Icw:131H蹴HIcwH!H H AU9vAuIUHճIcwHH5X6 1H3HIcwH!H H+HIcwH!H H AU9vAuIUHGIcwHKIEH`HIcwH!*AGK ƃ IEHH`HH!AGIcwAGKƃ IEHH`HH!跧AGIcwAGKƃ IEHH`HH!uAGIcwdAGKZIEH`HIcwH!9AGK/AuIUHHHĞHIcwH!H @KIcwIwHީ'Io(IG H9w'Ft+IG HH9aHuHtFuH譂H賽IG IuHtFbFImI;o L5̨ H% Io(wSf.HUA<tPHuHtV҉VHI9o Io(u 9sH~HHD$觰HD$HUHtHMH;0t)H0HHRHHRHRH8HRHSHUHD$b!HHu|HD$RHHD$腁HD$]HHD$~HD$FIG(1@H1HXIcwIcwIcwH1H耽1HH~AuH1H="1HNH=M1 HqH=1 HZH=0 Ha>IcwaIcwXH耻VH51H=m1豦Icw(AVAUEATIUSH DN dH%(HD$1DD1ȩ HH8 HLvHL$HPHT$SA HLH8 HHH趼E THELeH@HD$EHHA HD$HT$ILHLH誱 H~H9HL(H\$dH3%(H []A\A]A^fLXH8 HHHE tuHELuH@HD$EAEHD$HT$A >ILLH^HKfDHT$"HHsIfDHT$"HHSI_HH=eAV@AUAATUSH 莴 HH~ HInAI1LH1訕HUHBHUHBHUHB HEL0L`L@L8ID$ǃHǃ|ǃƃHCH[]A\A]A^DH8!OH@H{A H虳 HH艳 HIyIH߾ iLIHH1AU AU 蘔HUHBHUHBHUHB HEL0L`L@L8ID$HCH[]A\A]A^f.HH豍HHH袍H|H蓍HH脍HHuAu? H育 HHr HIbIf.H H!Df.AWAVAUATIUHSH8HHx@LpHHt @]H@@I$@\urHx0tkA|$ }H腶H8!HQHDž8HEHI$Hp0I$HH@0I$H@(.Ad$ 1LH訫MA~ I$IvHHP@XLVD$ HH $IRHXHH@AvHL(HHHHHAHHtL9tHp>&uL EYHpp9AzfEtIL9`PuH $Hqf`\|$ IHHPIxXAaIVIH@~iHcHH)L,!fD҉VbIVHL9t-H4HtH98WVuHPyfDH2H9@HtF8H yI$H@H` I$HpHHtFF[I$H@HAD$I$u8HpPHt/@\uFFI$H@PI$H\t9Hp(Ht!FF I$H\fH\I$P\tHx0tH@0I$P\ffP\H8[]A\A]A^A_fH(IVHDž8HEFHDx`xH5 H1@KI$0fHAAtqAADAsfHHHT$(LL$ LT$D\$QwHT$(LL$ LT$D\$'H(w8LHHT$(LT$ D\$LL$wHT$(LT$ D\$LL$fHv1HHHT$(LL$ LT$D\$ɱD\$LT$LL$ HT$(Hv&H蘱I$H@HHDž@(HhI$H\H@PLHHT$(LT$ D\$LL$/LL$D\$LT$ HT$(HBHI$Gf.AVAAUATUSH8HHOHVH9 tƇ AH@L(L`HHhfDBHcЉH9|I HtL9uH1HQ u tt6H8%=uH@uuːHcA Dq H8HRHS[]A\A]A^HHHP裦HH8HQ Hc@H5 1迕Df.AWA׺AVAUIATMUHSH HTHItHK @EH(Mt>HK @L`AD$I@HDL-HL[]A\A]A^A_AtЁK fAWAVAUATUHSHHdH%(HD$81HT$(SMIMMMHIĉD$7mHL$(LLHZAA߀|$7tAL$ AADLMLHI$B(I$B,|…u|H|$(tA@P%HL$8dH3 %(UHH[]A\A]A^A_@ fDH@HHxN HD$芭D$1DЃ$H@LXHHX9L7L(Lt$L|$ILl$ DT$ LIMfDIE9L?J\HtL9tCuHx(tx,u˹HLLtD $IILLDT$ Lt$L|$ELl$ tA@ %@=@I<$L H & x,HLEȅu"H H ! fHHEH_ H1L\$DT$ DT$ L\$H4$HL(z,t6f.HMMtM9tA@ uIz(u%@1=@I9uL¹LHLL$L\$DT$ L$藒L$DT$ L\$LL$tH 1L HD$9LD$H H1D$@HL$7HT$(LHIvHUHH$H4º H$fDILLDT$ Lt$L|$Ll$ fDHJHUHH$H4º wH$I~H5R {f.AVMAUIATAUHHSH|HHD[]A\MMHA]A^wfAUIATIUHSH(DV dH%(HD$1AtNHHvHPHT$ML A ME؉]wHL$dH3 %(u4H([]A\A]fHT$LD$|DU HHT$LD$D}@AWIAVAUATUSHIHt$(H$dH%(HT$x1H@HH|$ Ht$8H$L$DLD$PDL$dHD$XHt$HH$Ht$0?HD$0HD$XHDH@HHxHLHH|$hED!HD$ McD$`N$ML(D$D% D$@LMIIII$HtL9tHL9huDD$@HT$(LH|$ HtCH Q(tI,X91;T$ds;L$dzD$`MOI$Ht$HHHD$PHQ\€u0u Hy0HT$0LD$`2T$`MHc\$`HD$hHT$HHt$0HHH@,H|$8HD$HH@ %@=@HD$PHHx0ZP\ff@$HD$8MHHD$(<@o<%~L|$ L7LHHt$8HH@l$`HD$PHL@PMH|$8DHXHD$0LL$DHt$(H|$ $HD$HD$HHD$HD$8HD$HtMHD$PH1Hz0H|$xdH3<%(IHĈ[]A\A]A^A_;T$dHH|$0tDH|$hHߋR t*$tH|$ 葥xHD$PHL$`tP\ffP`Ht$XHNtHcHHH|$8H@HH@ %=lHD$hH؋@ %=PL$DLt$ LHt$( L/H HL1z;T$ds/D$d)=„%HD$8HHt+T$d@\H|$PHT$p HDT$8HT$8H|$ AH|$8HL|$XMLl$HH\$ IuHIIGHH@L8E1HH@IGH@H8H@HBIUB @@1Ɂ@@%1H|$ =LHt$0AL$ II$P,I$@(AD$ %@=@tIHD$PH@\HD$Px HD$8HHtAHD$ DH8H{HD$HH|$0ML I$@,HD$ H@L8IFHt$ HFIc@cDHXL@PLLt$HHD$0L$DHt$(H|$ I.HD$HD$8Lt$HD$$$ I.HZL|$ LНLH赓H|$8HI$h(HD$PHfH\ HH qH LAO11L$DLt$ LHt$( LGuRf. H3H8H1HHlU U DHHL$cYHHL$HC.fHHL$SHHL$HCfHHOHtBH8HPH9u7Ht@HHtH(H9t` 9~ HH5] 1yH5 1yAWAVAUIATIUSHHHHT$(DD$<H11ALw1LHH(bHH  LLeIDHLpH$1MLt$!HUHz"H(AAHD$0jf.OLHMɋr(J,HPAAHL$H Ht$HT$H$HT$(DH1襈HULIH;BKDEEHtJH;D$0tC@uOLHpHMɋH,P(t~AAHL$Ht$H y HT$H$fDD$I@(IHt/H t@f.tHC LL1LD$cLD$I@<&<@LD$<%1La^LD$H ʁP AP  H f.Hl$Ld$(L\HE@\H8H[]A\A]A^A_fDсHA|f@L1L荀A|$ HD$H:fI$HRPH Hy0H9x0HHT$ f.Hp(HLvHH EEI$HL1Hp H8[]A\A]A^A_9\fHD$J0H@DI$IT$HLHH蘇Hp@L LLD$5HLfU1fH% L資LD$HLQ HEf`\+H H= ƹ1?wḪ H= ƹ1#wAWAVAUATUSHHVHHRHhHLzH@D`HIH1L(IHII HL9toHDHtL9tH@8&uIp @փ t7tR„uH@HHrPHtVt>҉VtTAHHL9HHPuH[]A\A]A^A_ÐHPB LHL$H$OHL$H$ALHL$H$诊HL$H$AAWHcAVIHAUATUSH8HD$IT$$H;pH8[]A\A]A^A_ MfHυHHD$I$IDHzH H@H|$H(HID$H|$DaHH@LcȅN< Lt$(IMAfHD$J0H;D$HP@ '&@r%Q1HYILDHHL$aL$AJ IAt^E9mKL5HtA < 1HI?YDHHHH$aL$AJ AuLt$(H߾ fHIHH1`AT$ HHLAT$ T$$`IH|$HxH8[]A\A]A^A_KL5HtADHH`HBufD H賃I H蛃IHH@1~H1Q @@uHHHÐf.AWAVAUATUSHH8HBIHuHVHBxvH8HH[]A\A]LA^A_0]HHH H@HLaHD$HJHHL$bsHt!@H8[]A\A]A^A_f.1 LE蜂I HIHLHD$_MLLOHCL|$HMLH0\IHD$ LH@HLx4DHLHHL$EHAHXHCHD$(HH@H-HIcHBLHL$HIL$HL$(HI(HD$ @IH;D$ HP@ &F %=@%1LUHH IHIAI4$HtYD;l$fF < t_u01LUHI$Bt5H 먃~ufDHL[HH|H puHBuHD$H8t' L肀P HL$(P HHD$ LQ L?f.HFH8HpH9sPL@LNLHNDI4H2HPH9sHrHpIHHfDHH@1DHW0HH9vSLu0DADtHH9w#u%HDHx tH9wOhÐff.HHPHHBHHtfDHBPUHSHHHHhHBHHHH H HJHPHzrp?uH[]H5y H1oiDf.HFXL0L9t(LFPL9s$P1fPHPHHVXFlH5d QH1i@f.HFXH0H9t LFPL9sP1fPHPHVXfFlH5 QH1hfDATUHSHF8HHN0HPHV8HH)H~ :(t=D2L0DCDtAHHH)HS8H~̀:(uȀz?u€z#uH9tJHHS8:)u@#t&HHS8z hH9rKh[]A\LCH0L)H9CXItHSH5KHLCH L 3\IuH! H5 ANLNH1gHtFtFt+F3H5o _Df.AUATUHSHHD&AtH~(H5 ^D+ADD1DAtHi@ H1IHL$(dH3 %(H8[]A\A]A^A_fDL~I}LD$IELAPHLD$LKHL)L)HHHUIHD$ uH? 1IuHL$HT$ E1LLLL$cZEIEFLD$ M98BLLL$HL L1ODHH? HE1I:Nf.ATIHUHSHHH>t.LH߹ ]HuHH[]A\H?` HL$yuHT$HE@f.AVAUATIԺUHSH @t$ Ht$ HD$dH%(HD$1\I$HHtXHHu{IHLjMtC u@AL9l$t I$HL$dH3 %(uAH []A\A]A^LpfH,3yHL$LDLHipLfATL H0USAHFXH9DeMcLIN MLFXtUD^p1E1EELIMI9rMMILML9wMMAHD9NpH9vDH0IH9A0r*1HyQfAX f. wH1[]A\`QDfl[]A\H5(0H=)1BcfAWIAVEAUIATIUSHHHSHHhHC HHH@H9HC H0H9t"LhHC H0F@3HSH9s(=HCPCECTCd KdLkXC`HH@HsF tu/CcdH[]A\A]A^A_DCdt8DwLqHt@DHsgvHA$HC LH0EvHS@CECPCCdCTωCdfDLeHC H0@Hu+C0Cdt$ KdLk8C@@CCdHS%Df.AWAVIAUAATUHSHL IHEdAD$H4?iIGuOHE LHXWR1HC1HE LLH@D HE H@Hx=YH[]A\A]A^A_@HE DLxIhIG@AE1EH4hIGrftPZDf.AWAVAUATIUSHHH.LmxM\{:B;UP9HEpHcHHc"DrAA)IEDIcLƃHLHHD$oDU811„AL$ tvE;cA|$ 'I$HhƃI$HUHPt#tE1E1t1LHqfI$H@Ht HEI$HhH[]A\A]A^A_HEp@ud@HH(H[]LA\A]A^A_kdHEpD0ADAd$ fDDHcIA)}EHt$L-kƃHH[]LE1E1A\A]A^A_t1pHHL[]A\A]A^A_WOSH0LdH%(HD$(1uZI@pDHAAD)ȅA@:fH|$(dH3<%(H0[fDA;HPH'I@pHcHDAtHt D)ȅ~뜾)HHT$qHT$uU1두I@pE1ɋɉ~A@:vIcIxxD)HL$ HT$Hc(dE\$ Jf.HHn1. EfAWAVAUATUSH(HHXXHCHuH(H[]A\A]A^A_|d@(IHxL% HD$LcMhoB/r@"@Ic4LLcH=F0INHL$L4$vAH="0DHEDL$YDL$dEsHCHxIjf.HcH|cHCHxfHcHtHtFFuLoHCHx@H=0HcHL$Lt_uAH=]0DHEDL$XDL$E;I~=5I~45I~+5I~ Ht5I~(Ht5I~05HCHL$H|4fDHcHLHL$fDH|$HD$M8x VILJ81H=0IGqtHCLcH=k0ILL$JHHHQHPHT$WHT$LL$^HMM8-IFHL$IGAAtCHCHxHD$DH5 L1/TL2Ht$LmfHCLJ4Y^I~3I~3HCHL$HH$H@f.AVAUIATUSHHHH@HL@HFH(Huc1MHtHPLeM9HCH0L HHPIHNl&tpHJL&H[]A\A]A^f.HPLMHtNII9AI9uHHI H[]A\A]A^fDHCHUHHH(HPH[]A\A]A^fHL40L9pr'HCL HLpHCHPHt LHHL$FHL$AIEAAfH5w L1HDLHHHPAtfUHH= SH&HtnHH1eHH8 e7Ht0HxH@HH(uƅH[]fH< H@H@H$ ƅH8H@HHHPHXH`H[]fAWAVAUIATUSHHHL&Ht$8l ]HMEIt$0H7E1E11D$HD$L$HlSHLpE1H(HD$ IMnHz fIL$pH8t|xtvH5 1HeIHD$0HD$8LLL$(HHHLR CTAR(HLL$(HD$0t_HHHFIIL9z ~&KcDA9D$PvHtHt$ H4CfHt+HHHH[]A\A]A^A_(HHL[]A\A]A^A_HH1[]A\A]A^A_1HHLP0MSHH u:H@ A1P@HH@tXP҉VtaH [D$HD$E1$E11LQHH [@1DHX$H [DH߉D$L_D$fD1fATUSHHHt9Hp0Ht0AHNHHD[H?1H@ ɀ]A\H@H[]1A\ÐAUATUSHL.MI]0HHAԐ1HH9HtuHPHzHHr H~3EM`1@ D9MEpLcOA8tAxu(HH9uEtHpHH[]A\A]+@uE{H1[]A\A]ff.@utb$H5$ P1D@ATUSHHHtqHH0HthH@ 1A1P@HpHHV+UAąt<҉Uu HHw]HA[]IcA\^@H([]A\@HH5"HH[]A\Hp^H5 1?CDf.AVAUAATUSL6 HuXMIIn0HHHAjLf.1HH7Ht~HPHzHHr H~2EN`1@DE9IVpMcJ҃:tzu1HH9uEtHpH7)LHHyBEufHL[]A\A]A^m$f.ASHuVAufAu"ADuNA tP[<Dp^HXH@HDH[[DM[+uAH5& 1AH HpHHIH+HPHHHB HPHBHPHBHPHBrp?HÐATUSHFH(Hu[]A\HHHLdI;$ I1 fDHHI9~)I HI;sH9I~HHI;sH9IIH9sHA@ItAtIL9wK4H9jIHL9~ K H9HGHIH)I)H9s fHƉDHHA<0L9uL9~K4H9w[]A\HHҸH։HA0DI*ff.AWIAVAUATUSHHHFH|$H$L$L(MuFIL9H9$H|$1L$p+L$IHH[]A\A]A^A_f.HrL6MtM98LD$tH|$Iu$+HIHPHHPH{Iw=H9$LD$IuH$BNBrH|$HHH[]A\A]A^A_XHPHTHFH\ZH;LSID$K.H|$LD$(HT$ LT$HHD$0j*HT$ ILT$LD$(H:uM9fICE1111LL0HHL9sKL9sFHI H9HރHH@IIuIHL9r@L9HL9Iv H|$0H)H)ICH;8tiH8IH4 HT$(LD$8HL$0LT$ HpIL\$HPHrHpI{KL\$LD$8HL$0HT$(LT$ ICHpLLIvYI)MI*X f. H4I>HH5ו0H=B 1-AWAVAUIATIUHSHL6HAFPxHcH`H*X f.# D$L<LL$HCpf. IvpLH&H{ht L$f. LHChH{HIFHHPHH%H;PAǿ`HCHIVHHH HHJHHHJHHHJHHHJ HH HJ(HH(HJ0HH0HJ8HH8HJ@HH@HJHHHHHJPHHPHRXHPXLsHLIvIFLsHLHIvIFLsHLHIv(IF(LsHLHIv0IF0HCHHxHZEHP(HPHHCHHP0HPPHs0LHvH{XHC0tI$LLHH@ PXHCXI$@;tyHsx1HtHp(HCxHS(HtIt$H;rtxHC(CDH[]A\A]A^A_f.HPHPHHCHHPHPPRHCxfDHHHH H*X1HtHHHP'ID$HS(I$HHRHHPNfDHxH9xPAHxPEtHPHPPHP0HPPH50H= 1*fDHt;FHr LHDŽ$D$0HDŽ$$$X0H HcHL%0`@<Iŋ$P$AEXIF H@LlrIEAEX x]H|$H5q IE0'@ H$uH|$HC@H$H9$H$HHD$xH\$hH$H9ZHD$HH$H\$E1HD$HD$@H$L|$ HD$PH$H$HL$HIE QHDŽ$y7fHD$(t2L\$HD$(AKσ@@@48A{4YHD$HLxII9HD$HD$p@L;%0KAHDŽ$H$MHA4IM@HQf8AM8fAM8fEEHHT$X LHHT$X1HHD$`LLL$XLD$`LL$XIL)HBAH D LHt$8Hf!IMH$HAf8u{AM8QfAU8fAH LHH$H1HD$`LLL$XLD$`LL$XHHt$8IL)HBAH D L |$(H$׉ȃIE @8Mt $A ȃIE AD$(u2H$Hv$H‰IU @2fL$HEL9|$HEHD$ EDD$0H$ LH#1H=H$H|$ HT$@Ht$E1ɹ$A0HL4HHH0Ht0F <HH HP1H(AE8H߃fAE8H1MIulIUJ|Hd$@I}HD$@LD$`D\$XDT$PH4HT$@fWIEHH*Xf.߸ % H1H<RIELD$`D\$XDT$PJ| w DE׉4IuA^E։lIUJ|\H$H|$*,H$}$PHL$PLD$Hx HL$PIE(LD$HLd$0Lt$HI}HA]/IE$XD$PH$H9$ H$HD$hH)HfCI} AE<t H|$ IEHH$H\$hHHEHH$H\$xH$H)HfC$CIU(HtH$H)HfAEt~L5u HA<t|^ALfDQuCPt<D9}5HHHt#HH5l0р<7uPtD9|AEA<u$fA][]A\A]A^fD^A@A][]A\A]A^AWAVAUATUSHHHH$H|$8Ht$XH$H$L$H\$h$LL$@L$H$H$0D$L$dH%(H$81$tAGdD$Ll$Ld$LH$DŽ$@<@D$L$Eu;LH\$8 f@<@uH0HHuL$0H$H$@E1DŽ$HDŽ$D$pH$H$,D$tDŽ$DŽ$H$H$0HDŽ$H$H$H$LMIM/AD$!L9d$@$@Mt A0L-j0A|0Ƅ$D$`11H|$8LL$0AD$<.IFx$$HHHPHSHPHSHPHSHP HS @(H$@C(IFxHH$HHPH$PHPH$XHPH$`HP $hP(IFx$MAGd $AGdIxH$<Ѓ<2B11LH)I9+11AHx SD$HPH$0A$D$xA$AFdl$L$%t@AFdEۋ$HDŽ$2 ߋ$‹t$`LL$@L$H$HD$ۉt$0D‰$|$(D$ HD$hH$Ht$XH|$8L4$HD$$D$D$D$D$D$Et H$IFx$t E$$hH$0DT$xEia|$PV$,$|$PD$xDO1ɁD$P L$p|$p |$L+D$xD$tA|$>Mj$%$$MEFD$`E$.|$`#AF$Iv9LF $ HHJH$8LF$)ЉHD$XH|$8LH$L$.L$H$L)HH)HH$8 H|$8I4Iŋ$,u$9$T$xL$LAv)AVAVR|$PO|AN-DD$LH$LHt$XH|$8@AL$<<LA Fd@(IvxHFHFHFHF IvxDIFx IFx $$,MAFd}|$P*oHD$XH|$8Hw L@HH81L)M $,7LL)HAAAFdf.IH|$8H$8"qAVH$8ID$IvxH|$X΅I~x3$t 1A D t~  tI~xƃD@ L7u‹$Kz1$tHPv=uIvxƒ L=u=Pw=us1$t!PZ=uDfDPv=uIvx‰\=u$ IFx`(1H?0~At:DuI~xƃD@ L7HH=uDuI~xƃD@ L7HH=u_$ I~xl$?<$tOInxE u'E H}(H5~*  H|$XH?$`IFx` $IFx, H>0`(A1DuI~xƃD@ L7HH=uWf$' IFx0`(1H=>0~%At9DtI~xƃD@ L7HH=ufDtI~xƃD@ L7HH=uf$IFx`(1H=0~!At9DuI~xƃD@ L7HH=u0fDuI~xƃD@ L7HH=uf$jIFx`(1H<0~At9DtI~xƃD@ L7HH=ufDtI~xƃD@ L7HH=uGf$IFx u`(H3<01ADtI~xƃD@ L7HH=u$1  ~€  =uH$H$0.IvxH|$XH$pрI~xH$ hIvxH|$XH$p襀M" IFpȈH$05IFxH$0eAD$9$;$L4M/IFpVH|$8LyXH|$8H54 @ H$H|$8HzI~xH$p$gM!ANdLA$9$D$PHcH)HH$81,H|$8HH$IFxH$$$HHHPHWHPHWHPHWHP HW @(H$pG(IFxHH$xHPH$HPH$HPH$HP $P(IFxI~xH$eIuIFxHIFxHI~x$Lt2Ht$XDD$LLH$H|$8n$H$0M~b$$ANd9OÉ$MHD$XH@P8@u}\$t \$LusMt E^Eueu$tP8HD$XH@$9XD XDLD$LD$tZH|$8L{I@LP8HD$XH@@D#H|$8L$$$INj$CHcIMHH$H$8HHH9QIu{Hcω$H<vIEH$H|$8HPHPIFH$8HH)PLIvIvF t H$8$AF$,AVy1A @ t~  tI~xƉ@DÃ\7uwH$H$+IVxtJ(F<Hb60At=DtI~xƉ@DÃ\7HH=uf.DtI~xƉ@DÃ\7HH=uDI~xH$ptbtIFxhDHH|$XIvxz$IVxtJ(F<Hs50At6DuI~xƉ@DÃ\7HH=uDuI~xƉ@DÃ\7HH=uD1 ~€ =uIVxtJ(FHALt$PALHLUZ8LHE&bPAHLLH>D$\AIG0I9G8 LH~P8)At At$0A;wpHD$PAwp@D$D>wBH HcHDD$0D$  A&LHOHD$HHL$HALLH|$kH0I9GX|$XwHD$PHL%#0Lt$HI(f1H0I9oXLHLT$ LMG8LT$ IM9A;D$DI;oX!LHtID$DZD$D,AOhAIMg8AD$0D$ D$lHD$PIO8I1 LIW82@- L0@ADt"HIW82H@ADu@)L0|$D- |$D+r [LHGM9oXI IG;hPHAPAAD$IGXAOh A1L0M9oXLHhKHH@(d1AAOhLҹ(<{t <})HBIG8 HP <\ùzHH0I9GXIO8tIWH5HHIO8MGH H5 H1L)M A|$)LT$ *=x1L0L9fXHIMG8LT$ HM9A8)1M;gXt,H LRIW HHRHltEA7AGdG@tKt JLH EAHLHEH;D.AD. Ѓ@A LD$PE/AD$xDŽ$AEu#EEJ EEDEH$L\$xE1H-M Ld$HLt$8Ht$ H0ED$(MEHt$0)HL9uI $HqHVH9QsLHI $HqHHqAWpBI$H@ AAaIG8t A>8I$AL$ H@ %LH)U1LLH|57HD$ I|$H~8AD$Pπ<&1ɺ^A|$E:H0I9GXtIWH5H9HIO8IGHy H5Z HAIH $A)1T@[HD$0I9GXMGHH 1HL)M 肏IG8YfI Lf81\IW8HLF 0HADHIW8HADuLHYDgLH~I@ HHHIIHmIG8D1AoƒT$(g T$(IWHL WH H { H)L;d$ H4uL H HT$H Ht$D$D$1H詍IG8諌҃HeH0I9GXtIWH5=7HMGIO8Hv H5 H1L)M 莞MGIo0H0L)I9GXtIWH56H裸MGHL gG ~ L ͒ uH H5H H1,HD$`IG8H0I9GXtIWH56HCMGIO8HS H5 H1L)M ܝM4H0I9GXtIWH5;6HIGMO8Hl H5 MHHLL$H$A)1qQH5: H1pMGIO0L tF L)H~ L ӑ uH H5N H14H0I9GXtIWH55HTMGIO8HU H5 H1L)M H0I9GXtIWH5U5H MGIO8H6 H5 H1L)M 覜A|$FA|$IA|$NA|$E1ɺ_H3AIIG8+LFHn0H0L)H9FXtHVH54HiMGHL -E ~ L uH H5 H1H0I9GXtIWH5Z4HIGMO8MHLL$H$A)Hy H5 H1OHH0I9GXLd$HIO8H0I9GXtIWH53H蕵IGMO8MLL$H$A)|M;gXtIWH53H[MG8IGHL$`H H5X L$HIA)1NM;gXtIWH5[3HMG8MOM)A>Kt?AH{ H5 H$H1NID$HF8H0H9FX<ID$HF8H0H9FXH0I9GXtIWH52HyMGIO8H H5 H1L)M MGIO0L C L)H~ L u uH H5 H1֙IG8cHH0I9GXIO8tIWH5,2HMG8IGH] H5 HAHIL$A)1eMHAAaEIG8H0D8)tXI9GXtIWH51HDT$ vDT$ MO8IGH H5[ AHEALL$A)H$1LI9GXtIWH5k1H#MG8IGH H5 HAHIL$A)1LI9GXtIWH5#1H۲IGMG8HT H5] aHL$IA)1\LH0I9GXtIWH50H茲MGIO8Hi H5& H1L)M %IH01H9FXLf8H2HH@H5 H1ޗH0I9GXtIWH5F0HMGIO8H H5 H1L)M 藗I;oXtIWH50H辱MG8t$DIG<H. L$H߃>IEH5 A)15KI;oXMrMw8@f.AWAVAUATUSHXdH%(H$H1HH|$hH$$DŽ$H$C HHPHCH$HH$DŽ$tDŽ$pDŽ$xDŽ$HD$hH$x1HpH$pJH|$hÉ$@H$pƄ$DHp"H$*H$H$pH|$hHpH8"H|$h胱H5m> H1eH$DŽ$xDŽ$@ % $t$p 1H$H$$%t$$pt$u $$@$ DŽ$H$DŽ$4H$DŽ$8DŽ$H$H|$hAH$$$H$8^DŽ$TDŽ$LDŽ$H$DŽ$0DŽ$@DŽ$H1DŽ$<DŽ$HDŽ$XHDŽ$`HDŽ$h$PH$HDŽ$HDŽ$DŽ$H$H$H$HH0H$H$(H@tH$pH|$hHp$pu $xt$u$$@$$<=~$LDŽ$L$~ DŽ$H|$h舨HD$pL $<H<(̉HHD$8GM>D$HD$8EHH@AH@H@H@ AID$XAHf/Et$8AAAID$ $8AA @H$HT1EtH|$hHt$pHT D$ڏH|$pH$D$O DO R EHHW (@?tHH@^EtDAD$8%H HcHH5 AHL胏HLEtpHH+ mDAtHHPfAuLA:H$H$L%IHD$pLH+PA$ A$LH$@t HH|$p)HH+GHHBAD$T$@AD$P$8 Hc$@HH*XP7 f.X7 蠓H|$hHH$XvHc$@HEH*X7 f.7 PH|$hHH$`&Hc$<HL$pH|$8H$L$H$H$$GHD$H$HW H$DŽ$0$H$ $TA$DŽ$@H$H$( H9$A$eHG$G H$(H|$hH$H$1AH`ID$HHc$tMHH*X5 f.5 4H|$hHƺH$ёID$HH\$8Hl$hD$XH$H\$`H$PH\$HH$xH$@DŽ$AD$<HǺ` @ @ 1Ht Ht 1HfGtD$X2$8H$H$H@ $8@H$XtrH$xHtF F! H$HtF F H$XHtF F H|$H1H$AD$8$pt HD$pH $0 HD$8H@~AL$T$8@HD$`H$HHDŽ$H$E1E1R1.f>L:TL/HcA<8@;7@LZ/A<H0 H4HHH$ĦH$V@g@Afx..uf>Lhʻ뙀:uAfDADTgfDf~V77@\$xHAAAL\$8f.H=/<уm _ <iEtD$4E9FH /Ѐ<AT$8$8<DAEAL$T AD$8H$HPHH /<0H^IKHLHy@ W(脃HH$HHHCHGHCHGHCHGHC HG H$@H$KH@ʉ$LTH% IBAzTAZ8EZL$DH|$\H$AD$D$-AH$Dp迂HHD$@H$$H@J|Dt$\OLHHH$耍I*H|$@fWHGXf.S $L$H$HIrL$$f. WLLHD$PD$H|$@I@L$D$DHG)1Dȉ'9wA9vIJH y* D9u؅L$1D$D$AH$1ҍxt$\HD$P$1D,DHIBh)؉D$|fD9w$A9vD$|8IBHD;h3fDAAHD$@DLHf.AHAt 79wA9v܉)D<8IBJ;PuD8EtHL$@DAHHIHf8uHftfD1At$\HD$PD49D9$$9wA9v)؍ 0IBHȃxqHEdAL$8Dt DAE AD$8H$HfAL$8HH$D$D$L$H$H|$PA@AHD$8H$HXDD$xDt$Et $4u$8u AL$T@H5D/ 1H1EH51/ 1HH$x,H5/ 1HH$HL$8H$X$H$HyH$pH$H$MLc$<H$|$ H|$HH$H$H$H$D$0D$(HD$N L$H<$HD$D$Hk$@$ D\$XEID$HD$XffDL$ H$DŽ$LH5H$Hc$<H$H$L$D$0H$HD$HHD$(D$ (HD$HD$H$H$D$L$L H耂$@$t T$XID$HH@0H@(H@H@H@PH@HH$VA9\$HD$hDʒHD$8H$H$(HHHH H*XgHD$8x)Ht$`H|$h)xAL$8@H$xH9$pD$dED$`ED$PEo$8`AD$8t N AD$8?HHHH H*XqHH$HHAH5aU ID$0H5/IH5/LIH5/LIH-/LIHH;/LIHH52/LI {H5/LI eH5./LI OH5/LI 9H5J/LI #H5L/LI( H5v/LI0 H5/LI8 H5/LI@ H5/LIH LHIP LHI H5Z/LI { H5,/LIX e H56/LI` O H5/LIh 9 H5/LIp # H5/LIx H5/LI H5/LI H5/LI H5/LI H5./LI H5/LI H5/LI s H5/LI ] H5/LI G H5/LI 1 H5B/LI  I H$xH|$hmIHHHH H*XH$xIT$H@ HBID$HH@H$HBH$xIL$H@ %=+$$D)ЉA$+$IT$H$1Ҩ tt$ڃH$xH|$h.d1HBID$HH@SI}FIHHPHxPfDH|$hE1sH|$hTSHHHH H*XGHB(ID$HH@0GH|$h1SH$H|$hH$1gHt$pH|$hR1H|$H1H$HH$H`H5/H==? 1xwaL$H$H$L)H;$(t!H$H|$hH5 蹍L$H} L g H|$hHuH H5W NLN19sHxDH< H$H$,H$LhiH\$8HIDH$H$H@H2HH0HrHpHrHpHrHpHr Hp R(P(H$H@HHCAd$TMl$Hxf.ATAUHSHH HH@Hp HtcH E11D$HD$A$ ~Ht/H@ t&HH@ HtHH H[HD]A\@H HH[]DA\[fAWAVEAUIATIUHSHH8dH%(HD$(1ufHF88{tnMHC8HHHH]A $C`Hk8HL$(dH3 %(H8[]A\A]A^A_@Hv8H8{uPH 4/Dt+HPH2@Du@,y@}UL{8A?{IW}HS8HH$_HIH$H9 H)HH=7 Hu$HpH?WH*DIwMHs81L0L9cXD$AG.}IO.tH}t IτuM9LHL$HT$ H)E1HL$HD$ vIEHD$ HLH+S8L$H9ICM9HC8HC8rHz@Dp@H7@DuULCLH H1L$L)M A^Hs8L$5H謊H5 HǺ*1要茇L[8H0H9CXtHSH5@HLCHK8H H5 H1L)M nMH0H9CXIEHC8IH5  HL$kLS8L$IHC0M9HD$A-.$}IB@.tH}t IDŽuH LHL$芄HS8LALHH)QHI LH]L$MWLS8M9hH LHL$2AE L$IEHPIEHT$ HHC8HEFLHHHC0ǃL$L$IHD$ǃHHL[8HC0?LMLCHH H1IL)M [L{88HT$ LHL$u`HT$ L$511I7HL{8HhZH0H9CXtHSH5H~LCHK8Hߴ H5 H1L)M lH0H9CXtHSH5H7L{8LCLHGK H5Ϋ H1L)M kHC8HC8tH /HI9IFL;cXHC8tHSH5 H…LCHK8HW H5\ H1L)M [kH0H9CXuff.AW1IAVIAUATUI0SH(dH%(H$1HFX$HDŽ$HDŽ$HDŽ$HDŽ$H$HF8HDŽ$H$HIVXIH9tIVXIF8D$w8^H9AH$IVX% SH5 IEIEIELIE MHD$PHIVXH@HD$hIF8I9F0vk0H9@t_H:t H.R@:t @=<HH=/HPDtfDH Dut88] IV0HD$(E1HDŽ$HD$HHD$xƄ$HD$@HD$0NaH9v-8]t(MHD$@HD$xHHD$xI;nXAH$I8 HDŽ$HI0 .H$L$H1L|H$HFH@H$HD$`H$HD$XD$wD$0H$HD$8H$HD$ H$HD$@HL$`HT$XLvL$L;${HT$ DD$0LHL$8LbHvKH=vAH=v7H=v-H=v#H=vHH9H҃HfH$H9AHD$ ILwA% HD$ I9vuA>-D@yFփ@t;H5L/HI9v:u0IAD8u@@@xt9HH9Iv8uI^8fH=t[AL4L3ZLL3H$H$HD$PH|$hHH9xAEDH|$(8H|$(H$HuH/HcD@`H/H9IƒAT/H$In8IFXH$IF8H/ A%H$r3wH҃3LLAHIn8H$ HC$?ȀCIFXH|$PGGjHLamZ@LPm1ɺHLIEH$HHL(EH$L`HHLEEEHCIF8 H$AЃH#H HcHHD$0HIV8HBI;F0:-z]HIF8ELsltFIF8LL$@1LHD)I9FIVHD$A1H)HT$H 4$@I;nXyL$L$-LLL E1IV0HD$(IF8@,LkIv8IV0H$DLH)cH$H$HIV8H@H8,I HLOI8 L$IC0 1&A% HDŽ$I HE1HAL(IF8IV0HE1HAL(IF8IV0A%@v%I A%@vYI@ Ht$PH J HO 1L%A%II Ht$PH + H 1L9%A% HDŽ$I@ A%@I@ L$1A%tIICHHDŽ$HAL(IA%t0IICA%@vEI HHDŽ$L$H1ɃAL(IIHt$PH & H؅ 1L$A% HDŽ$I A%@vFI IVH5wL/OMFIN8H H5t L1L)M 4Ht$PH H4 1Lk#A%bI I z6"H\$PH H\$hH9YHL,H\$HHt CCu HL N1E1H=!ALAuHtULLHL4IIYDDAt@ωrL$ At뼾LnIH$L$1L{GIFXHAdžI^8 Ht$HLIxHpH E11D$HD$$ ALNHH@ H $H$PL$t+HT$8H$1LbALHT$8H$L4AH|$HGtVGt3HD$HHt$HLHJ IV8IcHLIHD$HaHt$HL HD$HFHBIPHppH=/HEIF8H$RDHIIF8DuLC}H߈L$ HL$XMF8LD$8}HLD$8SH=/HHL$XDtII^8HADuL9IM)CtIQDII;nXItIVH5L9HMF8H$IFHx H5} L$IA)L1I;nXtIVH53LGMF8IFL$ H_x H5} L$LIA)1lH^I;nXtIVH5LGIFMF8L$ cIFX$IFXH$D$1LLHMHtFIF8IV0H5| HϺH$$H$u)|$ HH:H$H$HH5| HϺH$N$H$U|$ HHH5e| HϺH$$H$|$ HHHDŽ$IFXvIF81I;nXELHp1EIv80HH$HHDŽ$HDŽ$IFXIFX"IFXH5H{ H#Z|$ HH H5{ H"-|$ HHH5z H"|$ HHUH5z H"|$ HH (H5z H\"|$ HH H5lz H/"y|$ HHH5Iz H"L|$ HHH55z H!|$ HHtH$xxL*H$H$+!+!LLD$X*AH$LD$XH0/HLBH*H$H$Ln*HLH$Q*H$LL(M;gXt AW|7LL&DD$LHHLLM;gX AG`DAG`۸ND$EEND9D$M9gXf]fDuYf.$ D$<}qMI8 MD1A>,INtIO81HϺ HL$@}AHL$@ 90fDEMg8LLs^fDIL$HL$pLALD$LL$L$H$ID$I<L9>$yGA7LЁ$DL/A HH9yuAAAuH$1LLD$RID$vFIv8Iv-Iv"IvHL9HHH$yfHt$@H/FDHHfDHDu,}OHH)EEEM0M9gXDuHD$@LLHIG8~HfDfEfLLH8LLHD$A1$AW`DD$LHLLM0D;AG`^f2D$`2ILHDŽ$H$D?Ȁ$@,LLT$@0LT$@IW0HL$(DLL)L+(LT$@L$ILT$@LLHLL蠭HIBE1A HD$@Az{MZKH$HT$(LE1LL\$@DŽ$HDŽ$dL\$@L$IL\$@I8 0IAI8 HT$(ALH$յH$IAIpH8Hx*e$DIBE1A HD$@IBE1A HD$@LD$(H$LH$ALL\$@H$_L\$@L$L\$@kI8 L$FIA/|$`3AIA!IBE1A HD$@IO0I9I0I9OXH /1Az{IGMؾLL$L\$@H$MLHFa LL$A)1dL$L\$@ABM0tJARH1/DF1Lߺ L$L\$@A9GpL\$@L$H$HT$(E1LLL\$@DŽ$HDŽ$ H=IL\$@AL$E1L\$@@IB1ArLHD$@I0I9GXA1҅DLE1MIBE1AHD$@6IBE1AHD$@AG|XDALIADIEADuAGlUR-HD$86D$`6H$LD$L$ L$D$MDD$LH9LLM0AEAG`DD$LHQLL̲DD$LH7LL贲fMfLL \$LHTLLA聲HMAHLL|IW8I;W0rLL軨LL[\$LHHLLA3AHLLN LLE8AHHLLtT$Ht$P mMDD$LH:LLM0A蠱ED$AG`I=mI0I9GXtIWH5L*IGMG8H8[ H5] LL$IA)1@HMHAG@AG|'HLT$@kL߾}L$L\$@HIL\$@L$ H$HT$(L)IrHE1LLL$@DŽ$H$H=ILL$@vAIAHD$@fL$I8 L\$@fDt}A{'EMG8L9i A8` 1M;wXt,H]- L脲IW HHRHltEA7AGdG@t KtJw ҃HLL蹤LLHŃ$S>LLAOh$HfDLLAAAOhRH HcHA-H HcHLLa$HAqAH} HcHlLL $H%-LL$HAtH% HcHj뙀{{Io0HCH9rIG0D$HI_8LLP@Io8HIo0LLH趣$DD$LHH$I_81LLwHoAAAOhH~~ HcHAHm~ HcHmkA[HH~ HcHAiLL臢$HAOhnPI_0H9MGI0L)I9GXtIWH5Lt%MGH< L HuH\ H5Y NLNL1 f.zALLΡ$HLL计AOhHŃ$A0H1} HcHHH@DtfHDu,&)+(*'LLHA%EI0$I9GXIO8y{MGHU L1L)M r%h!^ LLfHA%EI0$I9GXdIO8y{VMGHU L1L)M M0 e [ Q"x$n#d&Zk aWH5U L1CPHHDDHDuL7LHt$8HHEHD$8YHH@Dtf.HDu*1 tAOp)MG8H5s/AD'LHIG8DuI9@t}?HIG8I0I9GXt IG9HPAAGdBt%FtEw ҃CLL臝$HIo8Hŋ$ $IAH$|H$IIf.HLHL迹H$H$HIHH9s.H)HH$tHT$(HLQH$IuLL}HIG0HIG0NI0I9GXMGHL$@HcP L1L)M HI8VH{I8C6HLLLǸHH.M0 I0I9GXtIWH5LoMGIO8HV H5 E L1L)M I0I9WXtIWH5pL(IG8MGHmV H5D LL)M H1I0I9GXtIWH5&LMGIO8HU H5xD L1L)M wI0I9GXtIWH5ߜLMGIO8HQ H51D L1L)M 0M;wXtIWH5LWMG8IGHL$ HN H5TH L$LIA)1طI0I9GXLGMG8tIWH5HLMG8IGHL$ HtN H5UP L$LIA)1職L9H5# HǺ*13IWH5ޛLMGIO8HH H50C L1L)M /1 S ~ A9Gp1{1I0I9GXI_8tIWH5hL I_8MGHHS H5B L1L)M $OI0I9GXLM_8tIWH5 LIO8MGH$H5\B L1L)M [ I0I9GXLCDcIo0MG8tIWH5L`MG8IGHL H55R L$ALIA)1I0I9WXIBIG8tIWH5RL IG8MGH H5A LL)M H1MGI0L)I9GXH>PI0I9GXtIWH5LI_8MGHHR H57A L1L)M 6LHM9gXtIWH5LLMGIO8HR H5@ L1L)M I0I9GXtIWH5MLMGIO8HrR H5@ L1L)M fDHL$pH$LALD$9D$IfAVIAUIATMUSHHL9s+tHSLLHL9r[]A\A]A^fAUATUSH(dH%(HD$1HtuH9 HHH E t}HELeH@HD$H-n/HuHL$E1$A LH1HtlH0F tKHH@ HL$dH3 %(H([]A\A]DHT$"HHIwHfL-1m/HIEHpIuU $L$IHuA$LHIE]f@ HHEH d@AT1MUHH SH4HH5Ns 1HHL[]A\Df.HLD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$IHD$HD$ $ D$0HD$fHD$dH3%(uHifAWAVAUATULSHHdH%(H$1$Ht$(D$H|$ HT$HLL$P%HDŽ$HDŽ$HD$hD$0d$07"D$0%$t$0DAD$^H%1234567HD$pH89ABCDF@t$pHD$xDD$]HH$@HD$$HD$L|$HI9D$0D$HD$_M1AD$XHD$pHD$HD$hHD$@f.|$]eE>E$uIv$^$ u0T$^A9;D$XHh/HcDAfHt IDH9rQIwHT$Ht$(AH|$ LLEu"Lt$hL9t$vH9-|$_"fMHD$PHt ML+T$HLHD$(H$dH3<%(H@HĨ[]A\A]A^A_fDA >A"fDZA D$qrAHL$@HT$LH|$ iH=AIzEt2H|$L| 1  w;LcL $H|$LLo DL$X1  vH= 1rfHt$(H|$ Hj A1HA &A D$qtAfDH|$HH+ |$]E@|$]fHt$(HǢ 1}A%tA\uO;D$XAD$0AD$qD$qvA|$^"AD$q"AuLHT$hH9T$v HTe/Du]DL$XLn $H|$1  gDD$qnAD$qfA$DL$XLm L|$H@hAWIAVAUIATIUSH8l$xHT$dH%(HD$(1LD$Lt$pۃ"@"@/MtLLLLD$HT$@LL$ L$LLoMtLLL" @tL;|$ w-HL$(dH3 %(ID$H8[]A\A]A^A_DH ALLs봐H 1LL$= "LL$Ho ALLLL$-LL$Hb ALL5fDH3 ALLLL$LL$@Hyn ALLqAVMME1AUIATIUHSHHD$H$L9sA<tHEH[]A\A]A^DHBk AHL+fAWIAVAUATUSHHH# 1HHH MsIUUUUXA UMHXL(L@E1HD$fM9M9L9|$L;=`/FAOtcCXxfDHL9zuLC vHEj HH1AG HF HH HUIcHBH MMIUUUUt A UEl$Hi HHn Et%fHD HHAJ Au䀻tAG cE CHEH[]A\A]A^A_HXi HH AG % =ZH HH AG DA 4AH=/DHHH EAG @NIjH5Ŝ 1HHs HHIS AGtBIGHHuHHH)LHHAE1Hh HHH1 IIWALHHHL@H HH1HAG SM/AE.AELHEl$ !Hr HHAr DHg HHV d[ЩfNHXHxfDH[]A\A]A^A_f1fUSHHHHeHPHtHH0HH[@]1fH`@AWAVAUAATIUHH a SHH(HH a 1EuE@HU8%H EAHA?x H ` LDH1E f%f t*H}Ht#H ` DHL1HuHHE@HU8H HЀx t~H W` H(HL[]A\D1A]A^A_QE#@H H` EDHHDHDH ` ALHHT$D$L10fDHH@HHxHpH5B 1HEHU8IH }@H 1|$Q HD HtOHQ8!HIHHyHtz> tH_ LHTH eU/T$LHLAp*IL HxuIH a_ 1LDHAGAGqLH aIGL@fDH^ LHHD$HD$H^ LHHD$HM8H HD$HʋR DH^ LHHD$YHD$HQ8fLHEHX^ LHHD$HD$HP8fH^ LHHD$HD$HR8_fUHSHHHHH[]H1 fAW1AVAAUEnATIUHSHHDy H O] _HHfAHH5] HL1AC f%f=oHT/%L4H5r] H ] 1LAՃH3HEH%fC H H5 ] LHEH1LCMt!fEH W] LDH1C Y{#fA[fAfAH ] D1LH4Hs8H6HoH5f HL1H ] D1LHHs@HH/H5& HL1H l] D1LHHsHHZHH5 HL1C"t'H[(Ht@HLDHwH[HuHHL[]A\A]DH ,[ 1A^A_9fH5[ 1L/C f%f=oHHL@HR/H m[ LDHN1H{:DC$ELC(MtH F[ LDH111HHtH11HH\H [ IDfAfAfAfAC#@LCH [ fAfA!1fAs!fATfA)fA >HLDH((H5 1HH R/IAHclC#HZ C" t {#IHxEAAAALH_f.H5| 1HIC"HY <t<HY t<HY tHY LHLL$H N/LL$HS"LA`LLL$C!LL$hIL HxuOH f\ 1LDHLL$[LL$AAAALH`IAL@fDfA|H mN/S#LHLL$LAPC#LL$@fAfAHX >LHLL$LL$$fAUfAJIDHO/Lx FDDC$ELC(MtH W LDH1#11HHH11HHH W ILDH1RDHW V@fAtGw4fAǀ LC(H X fDH5W L1fAfAH X D1LHZHs0HH5W L1LHW LH.C!LL$xMAH tW LDH1LL$ILL$fHV LHLL$LL$7HV LHLL$C!LL$fAfAAtff|AffvjfAtbH5[L/DC#HPDHH99uHNvAHLL$HL1LLL${fDC#ƒ`@` tnHU LHLL$C#LL$LH譽LH蕽fAfA6HkU LHLL$SC#LL$mH T LDH1H&U H%U H5U L1&H5U L1H U LHLL$C#LL$H FT LDH1HT LHLL$LL$HJ/H H/H9 C DffwuHT H{T LHLL$*C#LL$Df.AUATIUSHHHHH5R H11ALHHLmHH sT H¾1MHID$HP8L9t;HA1HpHmHdH 7T H¾IH1HH@ HsH+HHH R []A\A]H11 f.AUM1ATIUHSLIH S HHCHHPHCHDHHHu{H5 LjL11CHt#HHPHCH|LMt GudIcHLLAE1HHH5)S []A\A]H1>fDHHy@HH []A\A]AMMufDUM1HSLIH R HHt+HHP HtHHH5R []1HH []f.UM1HSLIH IR H`HHHx H59R 1HHH HA(HtE@t?HH@HRHDHHt'@tHHtH5Q HH1H HQ HH[]H5Q H1HH []f.AWIAVAUATIUSHH$t$DD$0DL$D$ D$4dH%(H$1H D4H Di DD$HD$L H5a EDD$AH$I$1HD%@=@D =@AH C/DHHLD%D$(H ZE/DHHLmAtEA B AD$  %= HP HH/AFHCa HcHfI$H =C/HHP\LAD$ 3HUHMHB|,HpHv' HHt$H 1P L1HLmADvYH5P 1LL}EEdH$dH3%(%HĘ[]A\A]A^A_H!/H5O LLH1EhA ARAHAFv]AtuAT$ %=R@u8I$H bO L@ xH `O t$HL1 LAFwAD$ %@=@EtGAvAAFv8AAAT$ %=@t DAur HPHH9@<HI$HH0Ht |$ Dl$L@8H hO LHDI$H P LDHL@@1A I$D@\Dl$H P 1LHDI$H O LDHD@X1AI$t$H O LHL@H1qD$9D$0I$L { L@PMtOIL HJ B\u=L9HL 7J t-L 0J u!HB8L *J HtHLH IfDt$H N 1LHD$9D$0}FI$@\`tG 1LHCD$9D$0D$IL$LDL$HߍpH$HD$D$ $D$0D@,eAAfI$HHHt5H$DL$Lt$HHD$D$ $D$0D@LI$LMtt$H F LHA AD$@ I$Dl$H F LHD@,D1?I$H F LDHL@ 1 I$H F LDHLc@(1 I$t$H PM LAH@(AT$ @AN1I$LHHAH@H @HH5A HL1y@IT$L$HHE1LL)H5RE HL1;,fD AD$ %@=@I$L@MJt$H E LHLI$+MD$t$H :E 1LHI|$z I$1HxLhtLHHcI9R I$1HzLjt LHsDLE1)1t$(H5K FH|$`d1It$AIHI<$H1HtDHHuAOHcƒD`A9DLH9OHQ@HHfDDt$MD$H 9D 1LHDI$IT$H@ H9H)H5D LH1I$H D LDHL@ 1RI$Dt$H C LHL@D1.I$H C LDHL@1I$E1HxtLH֬Lt$H C 1LHH7s 1HHAD$ @YHELs HxtHEL@t$H ~C 1LH}D$9D$0LHTD$Hl$(E1l$D$D$0D$0D$4D$ qA9}u1DLH#t$H C IM1LHMt.H$DD$0At$LHHD$D$ $IILH裰A9~Hl$( @M$$Hq HHEl$8EH 4/HHDLiHULMHBA|,HH|Dt$H LG 1ELHD.ED$TH FG 1LDHED$PH >G 1LDHED$`H 3G 1LDHED$dH *G 1LDHMcD$AD$ @H8 HHAD$ @H|8 HHAD$ @HC HHAD$ ]AI$1HzLrtLHL$(L$(HI) I*f(I*ݾ LL$8\Wf Y^XD$(D$(H \9 L$8t$LH߸^YH  LPI$1HxLhtLHHcDt$H 9 MI)1LHDLHH w8 IL1DHI$H g8 LDHL@1AD$ItI$HPID$LcD t$H 8 1LHRE1AD$tI$HPID$LDDt$H w8 1LHD:LHIHt L@MtH S8 LDH1AD$t\I$HPID$HTHH&Rt HHt$IH 8 I1LHAD$D$9D$0IT$Ht$0|$4HD$HHl$()t$8t$|$4t$Ht$XHt$@Ht$HL,MhYHHHHL$XIVIEL$E1Ht$(HHD$ t$H =8 IL1HAF AD$tI$HPID$L;lIEHcPD T$0H58 L1qH$DL$LDD$8HL$ Hߋt$HD$D$4$_MmMhIELHߋD$0Q@ IHT$@"HHHL$XHfH5b7 L1Df.IHt$(LHAH@H @HH57 HL1ƒ LH萨II$t$H Q7 LHL@01-MI$ L@(t$H 47 LH1D$DL$LLHߍpH$HD$D$ $D$0D@I$I$E1LHHHHD$pW?ƒ nvE1H\$@Hl$8LMEDEtAH H c H5d4 LHD1SD9tH5 L1=HA9})LHl$8H\$@MEfWt#@IcƋ|`AAA*XuD$(AEuH5C5 L1Dt$H 8 LH1DI$DL$AvLHHHXH$HD$D$ $D$0D@Dt$H 7 LH1D0I$DL$AvLHHHhH$HD$D$ $D$0D@'zDt$H 7 LH1DI$DL$AvLHHHxH$HD$D$ $D$0D@sLHHHD$(I$HPID$HDLc@Lh E#HHD@EtH:H5a 1ҹHDD$8贵HD$@I$DD$8HPID$LtIcLHH L9HD$85LHl$HMHIH\$@`H`2 HHI$AHHHcJHH/ AHHÛIL9d$8I<$AuH1 HH萛I$HD$HHt$HH9pIT$D$LHߍp'I$t$H A0 LH1H0 HHAD$ AA6t2EPHE1AD$H Q1 LE‹t$LH1Lt$(MtRt$H 71 MLH1iD$DL$LLHߍpH$HD$D$ $D$0D@bMIE Dt$H 0 LHD@LHDH$1EEH 0 1LDHEEH 0 1LDHMEMtLH 0 LDH1H$DL$AvLHHD$D$ $D$0IMD@MEMtQDt$H 0 LH1DLH$IMAvDL$LHHD$D$ $D$0D@GMEMtQDt$H R0 LH1DH$IMAvDL$LHHD$D$ $D$0D@ME(M0Dt$H 0 LH1DH$IM(AvDL$LHHD$D$ $D$0D@Dt$Lc@`H 0 LH1D:I$H 2 LDHD@\1I$H {0 LDHD@X1eI$t$H h0 LHL@`1@HJHEHUH@LMgt$H 3 LH1 L3HT$X"LH蠧LD$XIRI$Dt$H 0 LHD@HD1>I$H / LDHL@01I$H / LDHL@81I$H / LDHL@@1I$H / LDHL@I1I$BH `H / HDH1;DfDH / HDH1e@H . HDH1@M~ MIGH / E1HDHH$M1辽IGMOH / AHDHH$1蕽D$(INHDL$DD$ Ht$$Ll$$fI)H/H - IENHI#FHwH9H55 HM~HA<HAW IE1@HJIW|$H$Ht$,H .. IHH1菼EGt$,H ) HH1sH - 1HDHWAFH - 1HDH6AFH o- 1HDHAFH <- 1HDHAFxhH - 1HDH˻AFGAF:H , 1HDH蝻AF H b, HDH1|LH茊WLHGH5- HD$(IN HDL$DD$ Ht$$Ll$$O"f.UHSHHHD$$HHE1E1H1艛H[]fUHSHHF u6HD$$E1HHE1H1H[]@HD$$AŐf.ATUHSHHHtHP^>E f%f=oKH/%HH5u 1HE %  L`AI MAHcHHI4ID>DAAf wAy(HmHwH5+ H1HsH[H5= H1Z[]1A\/uHu(HMH}HHH59 HH1@tE f%f=oHHޙ]HP@/8HHPDAAHF(HH11HHpH~UH01HnH0HF HnHHH5 ) H1uHH9PaHUHCH4LHŅ=HH @AUATUSHHHu1@HCHPHHCtHHt2LmLM9t"HH5/ HMLH1t2HߩH5b: H1߸H7IHsH蝧@=Hku#HHtHPH蓖 HHtZU @#wfDLuƃH1[]A\A]f.H ׾vFHH' 1jUSHHHH.HHHH[]H5- H1餷@AUATIUS1HHHuUHHtEI$,tH/LL,XH=H5t& Hlj1L7HuH[]A\A]ATHUHStdH9WIt[B"tMHZ(HuBf.H[Ht/fC u H{HDHHLHt[]A\[]1A\Ð[H]A\HPHHHHt.Hu/t!@ƒTs1DSHHPHHtHHzt@ t[H¹HPHHPHHB[Ðf.AWAVAUATAUHSHH8dH%(HD$(1HHDLmMIHHhHL$ HT$E1LHHExHI轊MIEP`Hx0HL3菼HELHH HƺHI9H`HHHAHA ҃Q(HH@HXL+sHILpHHPHSHHH@HHC HHH@H4H3HH`HXHCpHH;CxHCpHH)HHHC H)HHnL~LHH+,H`HH@HHXH+SHH HHQHHRHSHH HIH HK HH HIHHHH`HX1Ht$(dH34%(H8[]A\A]A^A_HHM~HEBHHPHHHt$HCpHSHt$ H.HH`HAH`HH H`Htx t&HѻH5H H1вHCH@H@HtHH@(HuHSHEH軣HHt H[fDH /8躢^uH~fHt 6fD@f.HStJHt HHtH[[HH /8B^uH苬1f.f.髪f.~f.E1H9Hr&SD9tKH9s HWHAH9v/\uPD9tH9v\HAHH9vE@DHEuUfLtFD9LOuFLFt,At)8u1LtH8uATuHÐ1Ðf.H9HsaHDH)H)H9w[SLZL9rCLLOE8QuL9Lv#A8ZuMA8uHIH9u[HD1[1H9DHsdHH)H)H9Hw`SHr @L9wKLLPE:ZuH9LHIv(AZ8ZtfDAA8uIII9u[fD1[1Df.AWAVAUATUSHH(dH%(HD$1F t@t%HD$dH3%(H([]A\A]A^A_fIt2 t DH0 AHL7C % =dHT$BHL}IHD$HiC <%1E1 @H޹BC H/L$L܂HT$IHHHAHFADFDFH)¿IDHD$@8u$)fH9t#Q@8&HA8tHH9s@fDHH9+D8uD8AH9D8AHA8T$+ID$8]A8JIUIvH}ՌH %輂ff.t.DJ1If 8t L]/A:uHL9u޸1f.t.DJ1If 8t L.A:uHL9u޸1f.t.DJ1If 8t Lu.A:uHL9u޸1f.USHHHt2HjHhH螊HHH[]H隑f.H1[]ATDbUMcLSHXHtHcHH[]A\MD[]L1HA\闆ATHUSHt4IHHhH-HtHHH[]A\fD[]1A\LATIHzUHSHHtHH[]A\H鯐LSHdH%(HD$1F tEHH^HxHH<$]H$HH^HL$dH3 %(u$H[H"CH<$HDSHHdH%(HD$1F t2HHvHPH$H苮HL$dH3 %(u!H[DH"ӅH$HDATIUSHHH`HtPP u; HZHLHH9HHH[]A\鶉fDJwHHHtHiHtEtqHCHHtYH | L$$HHAA1'H[]A\fDH@H@HUHHh(HP@H`H0P fSHHt$(HT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH.8cHt$ H$HH$D$0Ht$HHL$~Df.HStQ1HHH9r@HuڈHHt H[DH1.8ڒ^uHH5.H=%[ 1Ԕ@USHHuHHt*H[]HH58 []1韌0HſՃD)+l$D9fAfAfA)HcIvMI)D$MfD9~yfDT$=Dy, LAI@H9A HD$H@IHpD86Ht$HP HcLHt$ H3I9H|$Hp HcLtLHt$A|UHH|$HQ,wAEAEH|$0fH|$@fD3DS8 :H H߾ 1_*Ax<H`EBt0B|09u^B|0VeBT0BT0H8HL8A IIc@HP DLl$(E1|$@DHH)LgHBAAvً|$@dB|0dA\QLl$,H D}u1LDH2[tD$(E1/fB|0vdB|0ldEt|$@^d|$DUd1HL$HdH3 %(HX[]A\A]A^A_HUH H5 HˆDEu+B|0Ht$nfcBT0|$@cB|0Ht$nh|$Dc3f.|$@cEB|0Ht$on'LHj];@\H5 DH1lnEt|$@>c|$D1IVHl$1B|0}r@9tV|\B|0c}rB|09tbHcD$HT$HDD$DE1HLHRU[QB|0@AWAVAUIATUHSHHHdH%(HD$81>-81HeDeH|$ cAwH|$0AȃL$ $bAAA8SO8 IH H߾ 1A\w2Ax]EfLc4$1}rB| @9[B| aLct$ 1}rB| 9taEǃ1HL$8dH3 %(HH[]A\A]A^A_@~1d}wH|$ ȃL$ $axE1E1 HcD$ | `Hc$| `EEbH A>HHmH5~ HH1kfH(RHM H5K H2DH[ELc,$HcD$ Bt | H$9\YL<$B| 6`BT BT H8H{L(A} bIEIcEHP DLl$E1A|$0DLH)LbHAAvً|$0_H$| _A LLd$Hf.}u1LDH VtD$E1|$0G_|$4>_]|$00_|$41;RLLct$ B| ~Eu)H$H| i~^H$T |$0^̋|$4^Y|$0^EtDLHXnWH5 DH1iT$4HDL8xL@f.AWAVAUATUHSHHdH%(H$1IA臊H8DHAAyH0Iƀ~ FFH(HHL|$0IL$WD$ JHŋLH߉D$HLHHH$pHHHD$HAtHLHxYLHhYHT$HVY|$ 1@Ll$,f}1LDHvStLH߉D$XLHXHT$HX|$ L$tuɉxT$,1t EH$dH3%(uAH[]A\A]A^A_fHD` FbH&FcH(UTD$ELH߉D$;XLH+XHT$HX|$ tL$PAWAVAUATIUSHHHHIHcINI1@H~1DEHH9uIHH9HAMLOIM9|-f.ILHMMLdIMM9}M9(H[]A\A]A^A_6HH[]A\A]A^A_0YLHHL)LH[]A\A]A^A_cH5.H=I1 1jH.8hfHH.H8kUuHH= 1jfH.H.H.H.H.UHHSHCHHt HQHEHH[]ÐwHcHH.@1D1 ]fATAUHSH~tmHE Ѓ tq%1tPH & H A>HEHt@ t HP:ufHH []A\1R@[]A\ wHEHH@8HHEHEHp JHHVoqHHN I[]A\H1R1IfAWAVAUATUHSHH(HtF ?HC HDh }A2E1HA L - aE Ѓ b%E1=?AAH-\D LT MHJ2 tI$sH HDMtAF t IV:dH@H E1HT$H HL$H$M1HDHLT$VQMtQI$Hx0tF@u=EL , LT$uL@L H L4$MHDH1QH([]A\A]A^A_ÐLL Hb.DAA H,H fD @HEH@8HHHR zHHLL$Hp HHHmLL$Icf.AH- mNLAH+ HFHL`HGDh AMt I$ tK H{A L fDE1HEH@ xtHzAL ]fDUSHHHdH%(HD$1`HBHt6HHHPHSHPHSHPHSHP HS HP(HS(H@0HC0HD$dH3%(uH[]NVNFDN x E]gfffli)A1ҍAAѺQimIljAˉ)A)ËD1Aу)iʐiұ:A)кDDB<d)ljºsmiǬA)DD)DiҵA)кDDB )imAA)+RAAFDF Ng@A{׀+C< :gfff)i)A AAEFuF NAJAQimDIAA‰ω))ADA)ǃ~~A$IDDD))A)DNfDȺE.)AiҀQ)2AkK@A@fDȺE.AAAD)iQA)xD)DA^fD)A)AELEiQD<i1AVDAWEAVIAUATAUSHHLl$DL$dH%(H$1LT$DL$LH߉l$D|$Dd$D$ $DL$D$$$D$($D$,$D$0IHD$H|$PHD$PHD$HD$XHD$ HD$`HD$(HD$hHD$0HD$pHD$8HD$xHD$@H$bHD$x@HD$8H$HD$@NRLL@HIjPL>uA>tLGX@LHD$LcLhHT$HŸdADHu%~fDA9|kHLcLhHHt[LLLHj9~΅~f.H$dH3 %(Hu&HĘ[]A\A]A^A_Hh1_HDf.ATIUSHHdH%(H$1uKHVNHtQHLHLH$dH3 %(uFH[]A\E1E1t1r@H(LH e1GAWMHAVAUAATUStcA8t]6L.@ADtGHDŽ?@05D_CDHlH H]@01@vY@-oLh.@EHEAEDHDGAu.ރ@;A}H9_8WADNHH H@.f@0+xL.AD DE1G4AEAtfDHDAADuA.rt>Ht H H[]A\A]A^A_@pL.@ADtHx9D1۽AEDL$HDD$|$Xu7H\$ ;vt-Lq H$A11HHD$ 4HD$ Ht$0H D$HD$$$E1A1HZ_T$LL|$@Ht$(H5))…1HsiHt$(HH3NCEH5 HlH\$0H  E11AHD$HD$H$$YHhH D$HD$$$E1A1HHYoHhHt$0H 2D D$HD$$$E1A1HVYaHthHt$0H C D$HD$$$E1A1HYHcH1hHt$0H 1D$HD$E1$$AHXT$L1HgHt$(HHL T$LIE1HD$ 8v|LxxH5 H1]L:AWAVAUATAUHSHHhdH%(HD$X1F U4H@(f.$ 1XHHiH5j IXHLl$L @@L@(3+?HE1HD$LSXLXHD$ELL@A0<Hu`MOMLD$GLMPA0tA.HT$uLT$LLHLMItpAFAFuYLHdLDkIHC fDqHHsH@HD$HgIAHLHe8tH{ IL H19LWHL$XdH3 %(H)Hh[]A\A]A^A_VHH_H PHp HKIf1@H31IVHHfH5h IVMHH LH@(=dAF t&IMnH@HD$LH5(HT$LH+=IHT$H޹H=HM6H=5 1;NC FAWAVAUATUH1SHH(2HHIwCuCE HLHSH(HL[]A\A]A^A_1HeH< HH/t H]H< LHI^ IHH%7AN E H? E1$AHH\Ht>H:cH > D$HD$$$E1A1LHSH> E1$AHHR\Ht>HbH N> D$HD$$$E1A1LHoSH@ E1$AHH[HH  E11AHHD$HD$$ SHAAH HH@ D$HD$$ RH0H%HcHaH x D$HD$$$E1A1LHvRHo E1$AHHZHtqH C E1A1HHD$HD$$ RH0HBH  D$HD$$$E1A1LHQH 2: HD$HD$$ E1A1HQH1Lx1f;VHHHcp H߃`LHHhELH,91ɉLHUH1ɉLH@ uUH0H#HcfVHHYH!LchHp HDFLHHLHYUHݰ.DuHRL[g $A11LH*LH&H 8 D$HD$$$LHE1A1LPH(L[]A\A]A^A_f.HmPHH@ [f.UHSHH(F tH^C < }H68 E1$AHHVXHtQH 8 E11D$HD$A$ HH|OHH@Htx u H(H[]H(1[]AWAVAUATUSHH(OHHH9 E1AHH$AWH E1$AHHHD$uWHH E11AHHD$HD$$ NHAAH Y HH@ D$HD$$ ,ONHHDh H 6 E11D$HD$A$ HHNHL`MLH)A11LHRH11LH@ nRH0H ‰H5 1H߽1)=_AIm#RHAHD@ d DED1)}CHd IAI 1DLH/D9tg1ɉLHQH1ɉLH@ yQH0HAApH 1DLH߃e/D9u1DLHPQH1DLH@ 3QHAHh H ADLH1/H(L[]A\A]A^A_@PHHP D#LH0HAH(HH5a []A\A]A^A_]fDPH0HAOH|$CH ALHv#!EHx AHHK#H5r H1E?DAWAVAUATUSHH(KHHmH5 E1AHH$SH `3 E11AHHD$HD$I$ JHHL`LM&A11LHROH11LH@ 6OH0HVHcH5 1H߽ \AI7NHHHcH Hr 1LH߃,D9t]1ɉLHNH1ɉLH@ uNH0HHc먐NHHHcP YE~w1DLH`NH1DLH@ CNHH@ MHctjHb LH1,A~H(L[]A\A]A^A_fDD)tfDH ALH!u@HQ LH1+fMH0H\fDH(HH5 []A\A]A^A_1ZH5 H1HHsEH$XdH3 %(gHh[]A\A]A^A_f.H=в tHItHtM$M9HD$LH$PHl$D$7HD$(HD$HL$HD$PHH$LHD$8IHL$ HcAD|$LDP/uD$7|$P.DD$7H4$K|5L)A>HT$ LHL$@txtrH|$(L9LL$Ht$HA:LL\$LH<$L9HHD{LMcLH=w&E1GfDHL$ H|$ mHL$ H|$@~ LH|$(Hl$3H\$8D|$7Hl$H$t3D$0H|$(31H|$L?CHD$(H|$(uHH޿x%HD$(%=@D$7HD$(D$7uH|$(u9|$7L HL L< HN HLDH5B H1l%Lx HL$(H M@AWAVIAUATIUSHHHHFH(HDHƃHt@I$MLx8u@\u/IHB xEx Nx Dx LH9IHHH/MtAD$AD$EtƃH[]A\A]A^A_fE ЃE HEL` ĐIOL9aM>A dIGL9`VIHp(HFFH AHHAD$>u []A\It$PHU HE1E1HH[]A\HZ f.HH([]A\It$PH HE1E11HHH7fAVAUATUHSH HB 8~L@p|HH= Hc HfD@t H= LuDH Hu HtxH HHPHH%E %_DE @H 1[]A\A]A^ÐH= LuHHtHJ8H L$A|$ ' H(HHDHHtHP8H H4Ѐ~ uHHHH@ P(]D@ H=e LtH=Z L%DHHZHP8H H4Ѐ~ AHHHH@ P(D1HH,fDH HHH F Hm.xE1E1t1HH '[HHHP 8H@H+H@HHHHHP +HHP H@HH@HHHHHPH+HHP H@H{H@HnHHHHƒ +KSHH+1HH߁*@@>H= LHcHHH*f HH*11HcAHBH*X f.!  H<DHI~-MMlA $H 1HHIM9uLgM +HT$~HT$LcHrN tHH@ L9LHH)HH[fDHHHP8H H4Ѐ~ HP`H@ HHP(wKHH.)f+D(IHHA*uA<$H HHGE @tDE E,$E tXLEH}IPHFLH5w.HBDu@THHDtHHuI@E "E f.HHP pH@HcH@HVHHHHP8(?HcDHH'!HHqHFHHHPPHHHHHHHH=.< L$H= L#H= L{HHH8'c@H= L@1Ҁt€HuH҃Hf@H H E _U HHH HHf@@PxExNvxlHHH UD@gH=I L0H8 HH@HHJHP8H H4Ѐ~ 1HPd#K@H= LHw.L$LLHHHf.Hc@HH>%ifHH%Jf.HH$)fHHqHFHtHHP`HHF8HHDHHP HHHP H@HH@HHHHHP@d$1 HpI$HLHLB AP(dHHHH H*XHF8HHHHDHHP HVH. AHHHHH" D(IHHA*A<$H ZHHE,$E LEH}IPHLH5^r.HBDu"fDTHHDHHuH HHHH$HHH߁"HH߃"HH"H0HHp"HHZ"HHo6HHXH HHHH5V 1H&HH E11D$HD$A$ HHHHHHHH HH71Hʕ HHmH5@q.H= 1Z f.UHSHHHz LG H1[]A\tFHt@tHHtHE1E1t1HHD$ HD$zqtH z fD1DSH E1AHHH$Ht6@ tHH@ |)H[HHH1[H5y H1wH  HE1A1U1H@f.UHSHHA <tmtCH ̃ H$AE1H1HtHHH H1[]@H E1E1H1HA@ H j t@AUATIUHSHHHBHH@H 1HHH0Ht@H k E1E1H1HLH(<HHDH[]A\A]f.AD$t(I$HPID$H|tHHX[]A\A]ÐHHHLHI 1LHAE <t7uH@tf{HH IE@ AUATUHSHHF LHHH@AH}tyH} 1 GIU1HHr(Ht"HB tHHP Ht Eb"H1[]A\A]t+HE1Hx Aă}uHu F t4H~xtSHfW1Af.@(DDFH߹"1AH6fE1DDJ"H1[]A\A]E0HHFE180AUHSHHHrHt;Fu%HHPHH H1[]f.HcfDC _S tH뾐UHSHHZHt>F t HP HHGH1[]fD.f.HI 1MĐf.]t1@HHr#HtH@1Hf.ATIUSHHdH%(HD$1HHh@} v}HEHxtrgH}Ht`HcPxXE T$t#I$P@<uHT$HLxHcT$HLX 1HL$dH3 %(u0H[]A\DC _S tHL(AVAUIATUSHH dH%(HD$1HHh@} HEHxgHHIC <E BHELpC HHX 1E tIPB<@HI9HINHAd$AT$1HL$dH3 %(6H []A\A]A^fDC <uHX.$E1ɹg1HLLI-fAD$yfHC@ DT$HT$1HLHcT$4H޺L@HHLID1LHIf.HLHLEfHC@ AVAUATIUHSHPHdH%(HD$H1HY@C #HLkHRHT$0HQ8HA0IIIHT$@HD$8I؉AAɉLDHƒH@EHDЁ Ht$0uxHD$8Lt$@LLt$H$5C HT$8HL$@LHLC tM 1H|$HdH3<%(HP[]A\A]A^HLL$,DL$(HT$ LD$:L$,HDL$(HT$ LD$OHT$0"HFHM{ IHT$8A LHL'HD$8H,f.Hz LEt HL+t$Lp01H|$HdH3<%(HX[]A\A]A^A_HLp8I$P@<e1ɺLLHT$8LA LLLL$(LD$HHL$@LL$HD$8 HLAO I,LL]HD$0HrH~ 1LAG 3LL%AG @HT$("IHHD$@HT$8LA LL/Ht$HT$(LHD$8Lt$(LL$(HL$@IHT$8L$LHD$HD$H]EHT$0L1LHt$0H5w Lt BtƇ1ub1ÃJ1fUHSHHHHp@Ht(HP0HH8;HHHH1[]@C _S tH3H1[]f.H'1HAUATIUHSHHF @t4IcT$It$ IHHH1HLHu#AT$HH[H]A\A]H1[]A\A]AVAUATUHSHH HHx8IHRHHp@E1E11D$HD$$'HLhMH(I9tnHHp@HtFFAEHLh@HH@8It$HtFFAd$ID$LHHH 1[]A\A]A^DHP@HuH(fDLh@Lcp0AEuiIEH@L9|HHP0IEL,HmH#HMHLH@AVAUATUSHH HHx8uH []A\A]A^f.yIsHHtHPHHHp@E1E11D$HD$$LOHiLhM\I$(I9KAEHHp@HtFFtbHLh@HH@8HuHtFFt"HEeH []A\A]A^fLxfDLhHP8Lh@xeHP0LL!HL(I$(I9M##fDLaL!AELcp0u%IUHRL9}H@@E1LLHcHHUH5BK.L1HH5N.LHP01UHSHHHHx8uJHp@HtHHHHp@F@u H1[]HH1[]HfDHHR1Hff.B1fDHB Ht'HHHtHIHpL1H1f.Rrt BtBGt F t F fȃ wf ?@SHz HHtHC C1[Ðf.SHz HHC C1[AWAVAUATUSHHdH%(HD$81HB 8~L@IH=t HHc HIHttP whH@Ht_HhHtVF  HHx HE7u)Hp(HtLHE@1Ht$8dH34%(HH[]A\A]A^A_úIHtHI8I H4Ȁ~  AuL1뾺 1HH-L.HJA|C % = HH[HPHT$0HH9IH8 QH+IA|HA~&MIHA9E1111H޿HHn H=b ƹ 1IHtFEFuLoHL4I0IF H@H@H( HH@ HE8Hr~  BtFFBHT$BLHc>HT$HBA <ILY|@x A^F RHR ƒ A8XF  HH@ AAdf fAF  H@ AF 2 H@ A@F W H@ t%ADx?F  H@ AnI`LSxO H=< H/C  HHkLhLl$01LHA A IċK H' IHpLI)IUOIIH _k 1E1ALH@Hp D$Ll$$$LLK LH) HLHIH j LE1A1H@Hp D$H\$$$zHLH= L)҃H= LHLAF  HH@ I0I CC <A 1t HLI ]F {HHx A_!EeEELl$0L$LLDLL1MHLHHHIH5LHLZH McHJN,#EHH J,E %E H H9uE1ue<A% =HEL}H@HD$(HHH:LͶHEcEI.MtAEAEuhLHm[HtSH[HL$(LHHD$H$E1E1rHY HH1if1H$8dH3 %(HH[]A\A]A^A_DHD$(H1H'HtHHL$(LHHD$H$E1E1H5X HH1DIu F HLvH@HD$(JDHT$(LHЩAfAE@HH H0Ht#FFHH HH JDEC1DHH)DHT$("詹IH5W LlH:LLHMHЃ 3H!3.DHH3TfDH f.H57W L̼*EGDHfDHUB f.H5V LlLMQM.MtL;-/.ILDHE E1HT$(HH IHD$(GfDH5V L='L H=Ll $A11HHfHT$(LHHL$HL$HH JH E THHT$\HT$]HHT$UHT$HH FHb..H9E1f.ATI1UHSHLHUL[]A\YfSHHdH%(HD$1F t2HHvHPH$H;HL$dH3 %(u!H[DH"胶H$HUDUHHSHHHHH[]HإAWAVAUATAMcUSHdH%(H$1H-.Ht$8HT$H8.IHHD$`AmHHD$@IHD$ IEHD$(IHD$0I J4HAF tLvMtA~ t$HL$`HT$hALUHIIHx0I JHGCHLCI`H@HoH@(@ L|$@HHBIXM+}HILzHHRIUHH HIH IM HH HIH IMH0I`IEpIXHI;ExIEpH1LyH)HDHHD$pHYHHD$@t M}LL(I`IUH@HpIXI+UH HHQHIHRIUHH HIH IM HH HIHIUHI`IXHFH8eHA HHHPHt7H|$8AH|$H5IHPH2HL&HAmHtCjCtHD$(IEHD$ IHD$0IH$dH3%(H[]A\A]A^A_f.EA;EL0EH5ٝ1LAEHI J4$>H|$82 LLHHD$PHD$XHD$8LHc0Ht$PH P E11ALD$HD$$$YHD$8LHcpxHt$PH  E11D$HD$$$ALIE L)HHD$XHt$8LIGIGHD$P IGL|$PADHT$`HHBH@8HHEHL@ IHy*.HbV LJ 1蟬AmHfDLt$@L3DL1L詜@1HtIHFHHH@80NHL轛HL| LI`HPI`HBdLHL$@#IEpIUHL$@1L6H@H8IHFHHo1LH@IHHV@ H t$HS1LH@H=DHt[A u5A HHfWf.B(DfDHWHHx 1L^H@IHHV@ H uHu1L4H@IHHV@ H bHu1LH@HHL舚rH (.1LJ4{H1HfLLL荝IDH@8HtNHPHR8HHEHL@ IH1LSH@H0 HT$`HLN D1LH@H1LH@HR1LH@HH '.JI`Htx twLH5R HH1DI`Htx t&LvH5'b H1uLH@H@HtHH@(HuH@H@HxHH@(HpcUHHSHHHcRtHHp zHH(IHE11&H(H1[]fDHP f.SHHR H(E1E11H(1[Df.SH(H@Hǃ(1[ÐH H@H H@ H H@pH HǀH HǀH HǀH Hǀ(H HǀpH HǀH HǀH HǀXH HǀpH HǀH Hǀff.USHH=HH ΨH H}HEH H@H H} HEH H}pHEhH HЭHH H趭HH H蜭HH H(肭H H HphHhH HNHH H4HH HXHPH HpHhH HHH H̬HH[]@f.SH HH8MH Hx=H Hx-H HxhH H H HH HH H H HhH HH HH HPH HhrH H_H HLH [?Df.AUATUSHhdH%(HD$(1H.Ht$8HT$@HL$HLD$PLL$X8菷HH$D$HD$HD$0HD$ HC@ %-MwHN HcHfD1HL$(dH3 %(c Hh[]A\A]H H`pH HupH}hyHEhHC@ %=g=hr=f˕"1pfDH HѠH HHHHC@ %=NA =O=MuD$0Q HT$ D$H H*HHHLLHT )"H=K H1'fH HѠH HH(HHC@ %=Q9=R=PD$0 HT$ D$H H*HHHLLH賝T "H=EK H1KfDH HѠ(H H(H HH HC@ %=TQ=U=SD$0Q HT$ D$H H*H(H HL0HZT "H=J H1rDH HѠH HHpHHC@ %=W=X=VT$0JHD$ փ/L$H,0HȉT$L H HHLHLLظT j"H=I LH1}H HѠpH HpHhxHhHC@ %=by=c^=aD$0HT$ D$H H*HpHhH8LxHڻT "#H=H H1袗DD$0NHT$ D$H H*HHpHPhHpHL@xHT ti"H= H H17fH HDH HwDH Hx_DH H@xJH H/DH H0DT$0uJHD$ փ/L$,0HȉT$D H HLHHLH4$DT V"H=F D1 wDH H(H H0H踯T "1H=F 1賕 fDD$0qHT$ D$H *H(H HL0T "H=tF 1:DD$0GHT$ D$H *HHpHPhHpHL@xոT "NH=E 1Δ;fH HpHhHxH8hT "H=E 1sfDH HHHHǀ`T "H=E 1fDH HHHHLqT ":H=D 1輓)H HWpHwhHOxHHԊT "H=PD 1of.T$0VJHD$ փ/L$,0LHȉT$L H HLHLLT "XH==D L1ՒBH HHHHL!T {"H=@C 1|L$0AHT$ ΃/D$H,2GƍAL$2/D$'HЉL$D(H DHLLHHHHT$H$D赼T ">H=hB DLH1跑$fD$0syHT$ D$H *HpHhH8Lx=T _"H=_B 1FHT$HBHD$HT$HBHD$HD$HH*HD$HPHT$HD$HH*HD$HPHT$HT$HBHD$HD$HHH*HD$HHL"HD$HPHT$pHT$HBHD$HT$HBHD$HD$HHH*HD$HPHT$wHT$HBHD$EHT$HBHD$HT$HBHD$rHD$HD$[HD$BHD$HD$AWAVAUIATUSH8dH%(HD$(1H~HT$HHME辰nA Lt$$E|$D1LHHI7LLH葷MHt8IGL$$HcPD tE1$AHLHfHuIGL$$HcPD tH E1$A HH*HYLL$E1HT$$ADHLL\$L\$I{t0I1HzHJtLHHL$HL$HH9IGHcPD uZL$$H E1$ADHH脺HD$(dH3%(u H8[]A\A]A^A_fL$$SUHSHH(BDJDBHJ1HD$$ D$H6eHt H9] t HH([]HHU1ff.AUIATIUHSHH(H6HtRH9] DKDC1ҋCHKLLd$$D$ݰHtvH(L[]A\A]f.H9U tR HHHBHMHEHtHU HLFHukDLegHMSDCH5> HKL6fDH(HH E1E11D$HD$$ HtHHH@ H(f1ff.ATUHSHH DKDCIċCHK1H HLd$$D$蘯Ht H []A\Mt AD$t5AD$u LH5SDCH5= HKH17LHf.SH0 HH=-HJHSHD(@@Hx [fAWAVAUIATUHSHxdH%(HD$h1HHPHFHDHHHL"Md2H@ HHD$0<HD$0H@ HtH'-H9Ht$0H-H誖HHL$hdH3 %(Hx[]A\A]A^A_fD|+IsAEu6H5< H1ߡLbMDFtՅL"M*fDHD$0H@HefD HHHȬLIHHD$(%LHHHD$HbH K E11D$HD$A$ LH-HtHHtP с HL(EHH*H}q $MA$ HHI`HT$H1LHD$Ld$$E1E1蔬AE HL$(HD-Ht$0AEH% AE Ln(A A% A LH赼HD$0I҃ H@HP(HHH@HE1HRL(E1HT$8HDLl$ HD$@CD$PfHD$81HH0Ht$`YHIJT$PHHHXHH|$ L@AHL4L9HHSHt$ E1E11D$HD$H$!LhM9tLxL`LHЍIGIGIEIcWIEHPAE D AU IcWAD t D)AE Ht$(LH貞L9SHD$8HD$@H9D$8Ll$ fIHPIFHD(HHp(HL$TLD$X袃HH臩Lt$(L$THHD$ L\L$TIHcхHPMniLD$XE1EJI3f.t HHxtQHyKD5IM9J43F  uωuPwHvHH0LHL$TLD$ L$TLD$ H5=8 LH18H|$ tH\$`@H kHHPHm MH$A$ HHHD$ 聱HT$`E1E11HHD$Ld$$赨HpHYHt$(HH虜@AWHIAVAUATUSHHHL$xHT$0dH %(H$1HLD$pLL$hHD$8t @H|$p3Ht$0Hl$p1E1D$HD$$AHHHpH(H9LXL9H@H9Ht$pIDHPHHPHFLl(M$IE(H< @MM(L$A$HH IuH3FF IEIEHD$p@KHH@HRHTHH/R#HHHD$  Ht$hF < Lt$h1҉H$1IL1Ll$@L|$PH|$HAHL$Hl$(IfDHHHH$LfH Ht,$AD؅LEHE1H$Ht$pALHbEHD$p1@t&HH@HIHLHHtIHH9T$ thHD$@Hp(Ht H~tH$AE1LH1틌$tH E1$A@LHA,HD$(M9 I6F I HT$H"H!H$IHHPHAHDHH@ HHD$8H|$pHD$1D$ E1!HD$pHL$xHD$1D$ E1H: Ht$hF < Ll$h1҉L$ILHL$I6f.HHHH$HVHt$xHM9tcIuF AIA u"LHDD$(H$HDD$(HHPHFHD$I fDLd$xHt$01E1D$HD$$ALHLX蹣HPL9 H@H9 H(H9ID̀|$8HHHt$xHHPHFLt(M IF(H @MN(L$A$LH̫I6He F F? IIFH|$xAf|$ ZHD$pHHD$hHL$hAHL$x  |$ L$>HHD1HH[H HHWv1HHHH$tHHJHPLt(MDIF(H@MN(L$A$LH蟪I6Ht7Ft FtnIIFJfHtfDIvH+FFIFDLX]@H@fD|$ HD$EEuH D$E1HD$$E1H1HLhHHhLEHtHD$[HHeIDHs1H萮!@E 11H E1$A H.HHD$tH(HsHt$pHH1HxHht HHcH9HD$p HE1HIHD$vHH[HD$ IFHXL$L|$@IHL$HA9L0f.HT$pHRN,MMDM6MIFx uHLL,Iŋ$HcA|:uA|:uIVHt$xHRHHJ HL$8OIVHcJ]T $A لLDLE1躧HL$8H;L$pJH HHH@H@ HHD$PHt$h~ $LhLH$HD$(AJHt$(Hzb LkvIFHcPVD <$Ht$(LL%DHc%vLL$(LD$8LHL$PHT$0Ht$@IFHcPD $tLL$HHt$ A$$LL|M6MHD$H@IA9Ht$xLL|$@HulH$dH3%(~HĘ[]A\A]A^A_A}:LEHt$xHD$ HtH1HxHht HHcH9xHD$xL$1L|$(MHHH@I@9HHT$xHRL HHYfDHhHLvHPt\I6F HD$ H@HHD$ H@@ HI/HPHL$xLt$1D$ AHHPHDHhHpHc~D>  HHpH@v|HcpD0 ˃HHPf.AUIATI0UHSHcHuHH0HEHHCHUHSHUHSHU HS HU(HS(t\LLwHCHHsHtLLwHCHs(HtLLwHC(HH[]A\A]HtLHLwHCAWAVAUIATUHSH8FHHPHFLd(MIID$ H1LHIHg-I9D$ -AE"IEHPIEHTHHRxH8fpH0HmHIIHx)IGL¹HLD$ H0LD$ IH@I_ HLD$(Lt.HHIHHHHD$ HRHHQHD$ LD$(L9HPLHxHOs!HHSHHtBI9HQwII|$(H8L[]A\A]A^A_ÐHHuFHfDA@A@uLH֟@H@H8wkDu{f HHIMwAEHD$(H@IDHD$ tKIEHPIEHTHHt2R'H0Ht$(H|$(uHD$(tHHD$(fDL;t$ L(s8fIIVE1E11D$Ll$$HHL9t$ wHD$(1HHLc@HHFL Ll$$D$ȐH[U $MA$ HHAK I\$(-LHEcIHH&HxtHpf.H|HD$(HpHt$(H5 HH5 1AWIAVAUATUSHdH%(H$1FHt$xteHHPHFHTHHtMRtESHHYH\$P*HHcYH\$XHHcPD$`D uHD$XHD$PD$`H|$P[H\$xHHPHCHD(HHD$HHD$HH0HGFF HD$HHH@H\$HHD$pHs(HtLHC(HD$pHD$HHT$PA L@HD$XI $ـ|$`DE1HHH|$X 0HHR E1$A HLӖHAHD$HHpHtLHHLcHD$0M(L$1HLvH^HLa1HLbHH$tHHJHPLt(MI6HFtyFIIF@uAFIvHtL!MN(Ht$0A$$LLMMD褕IF('L_Ht$xLIbHPHH@HZH|$XMXLt$PAA܀|$`DDHl2$MA$DLHLH H9t[I D$E1HD$$E1H1L4H@x wHƺ LHD$ nHD$ {H|$pt>HD$pHxt2DL$`H\$HHHL$XHT$PLALC(AA 5H$dH3%(HĘ[]A\A]A^A_Ld4IvH6FFIFHL葊Ht$0@HYLMX蠈I(HD$@@Ht$01LsH"HPH@1HzHD$(IH|$8HLR`AEHPHHZH@t4H|$8HHqHOHtHHtvH)H&LmLd;fEMA$LLHcЉD $LDHL9t_I D$E1HD$$E1H1LLPAz wLֺ LLT$ lLT$ kHD$@H9D$(H\$8HcMHDL HPHCAHD(A HL@(Ht$(HULk|GHH)HH)HLԙIHD$H1@HiHt$PH=M  LXLH=HD$0L[L[pL衖HD$HHpHFFHD$HH@1LOH@HHHHHHHL賘HD$HLZ|HLDL$ 茘HcMDL$ YLƕQiH5 L1{f.AWAVAUIATUSHH(AHt$HT$IUHB(HH@HIHlDeESHExHHbHH蟆IIEAH@ x?HK LH _IEHP Bt2HcHL HHcDL^ H.HH HIHHLD$HL$MHLHLXLH1LH[oHH/HELhAEtIEHPIEHDHHtHtgH2HtLx M Iw(HUH9t7HtFLFNHU1L9HEIG(HELHҌEDHHp(Ht|FtvHHJHVHTH Ht^RtVH HtEHP A BHcD: $HDHE1HtL9(DH([]A\A]A^A_ÐHmA H_HHDEI HHpH=+ IEH@ xH5! 1H轖If.IUHR Jt3HcHt2 @HHcDL=\LLHOxHAVHExKHH^IUIAHR zt!HG HH[UDHG HH[4@HHrHpVHpHUHpH= HB xH5a 1HtI@HA@H5G H4I|@LH荓IHF LHZUHILH5F HsIf.AVAUATIUSHHF HHPHFHDHHPL)IH@LctH1HcVD ufH E1$A LH謊H#H(MI$HPID$HD(HT@I tZHt3H`F E1$A HHFHtAH[]A\A]A^D1E1E1KH= F LuHH~D1HH#jHtHH#U1HH|HtHHJHPHT(HtHrBHtHDHHeH1fHHqzHZHAQI3Li*LHH5 H1WtATUSHWpHHHJHOpHc*HOHH)H)Hu+Ld)1L{Ht#HHdHkH+[]A\H pH5 LHsfDAUIATIUSHHH蕐HHtjHS H9tDHKHtH;tEHsCHk HCHtHL[]A\A]jf.H[]A\A]DHLH5 LL1/sDf.SH5-HaHH&-L!k [H  H5 E1(~H+H HcH>g1Hfm<  H HcHd<!H HcHE<3!H3 HcHC<4!H HcHB<5Q!H HcHa<!H7 HcHD<3 Hg HcHA<3 H HcHU<"H HcHg~e~t~n~e~t~b{~yqFg'~e~tFg~e}~ts~pi~r_~oU~tK~oA~b7~ y-~ n#~ a~ m1~ eD@1~e~t~p~r~o~t~o~b~ y~ n~ u~ mx~ bn~ed1~rDS<_ ~_>~P4~A*~C ~K~A ~G~E~ _1~ _D@@~e~tF*1~s=D-FH5 =[¸ fF~k4~e*1~t4D~m F~c4~k*~n ~a~ m 1~ eDf~n~d~p~r~o~t~o~e~ n1~ tD1{~toFFFD\ʁ4=16~r*~e ~n1~tED1~u~l~tɸ)HPHH9J<ʁrH5V- 9¸)ib~wXFD$EHL>;@IE1HkuHHDT$L $IE>L $DT$IiE1$E1IDLH@A#QL,I]HcHD$HLt$Hl$ MLL$(D\$ADT$D IHHtULcA9,$uE9|$uI|$L9tHT$L=(uHD$AD ;$uLL$(DT$M MD\$DT$Hl$ Lt$AL EHT$@LHcHL$?DD$HD$@D$?'D\$?L$@DD$DځI9IDEAEډ4$AHE1mrE1$E1HDVAAIMcBD A8t,HEtSLcHL@H1A9uH~H9t@LL&HHcMHL/@HffSHVHЃp< <u,H͙-[<@t,USHHHPHFHDHXHtH@HH8{ tH[]f.Ct!CuHHH[]n?fDHHH[]GSHHHNdH%(HD$1At$HFHH\$dH3%(u?H[@HqF tHHFHRHH$@f.SHvH HH[0AUATUHSHHFuHEH[]A\A]PI{9HtL^CHMIDAAt%HHHLHL[]A\A]DHIHHL@AȉH1E111@ATHUSHHHzLbt7F u!T1HHHL[]A\HH4HwHtƋFtFtH{HXfDHX=H{f1ff.Ht SHBHtPt҉Pt[fHH[@HH[<@ATHUSHtTIHrHHtFH9.HCxtHHL[]A\ ADHpHtFH.Ґ[]A\Ðf.USHHF tMHHJHVHlHUHt@uEHEHH@H[]%F @ԐHHHH@H[]f.AUIATIUHSHN dH%(HD$1Ht:HpHUH\Ht(HSHt@CHCHEHxHUI $H@LAHM$LMI9IvZLHHtHHHEHhAtEuHHHL:H|$dH3<%(H[]A\A]I$1wfHEHPHEHDHHt@tHHtHCHyx oH@H@ H^@THH@HRHTHH8R,HHHCHcPH$HHvg|:|:HKE11LHAHP 1@1HM @>3HR8:HpF t+HHPHFH$\0H@'[ HLkH$,fAUATUHSHHL.dH%(HD$1H$IfLHHHt%PtF҉PuHH9I}uHD$dH3%(uH[]A\A]HH @f.AT%IUHSH3HHtHHC[]A\E1E11$%LHHHuH54 H1fDH%B3Ht @HD1HfAWAAVAUATIUHSHF L>LeHVHMLlMut zMWAIH~„HuTA}DGEEE;G@HMIcHHH }-HHH9KtMtE @I]HH[]A\A]A^A_DHtH ,- fHHtH9Kt1H~HVtHLHT$=HT$HH91'AEsHiAEEE;GAE1HfDHT$&HuE DD$~%LHE L:PHLDD$C1HHDD$L;MIIFHHHcPLCH¹LL'IFHt x@IFH@LHHL3AG <tTIF@AGIFLxL>1AdLHPeHuzIG@ HpHcFtFtIFILL4IF.I$(IvHtFFuL4I~>(I$IM$1IEe aL]IEM @IHH@H@iIF@L!uff.AVIAUI1ATIUSHHHt-LHH*HHL[]A\IEA]A^u5D[]A\A]1A^DATAԺ%UHSHH.HtD`H[]A\EtE1E11D$$%HHHuHHH5W []A\AWAVAUATIUSHHHL6[3AD$LH%AD$ID$HE1Nff.AWAVAUATUHSHFIEHHPHFLlIEHH$AEHAHcH"H$HPHLyH9vGHH+$HH HH)H@HD$ LIHq1E11HIWH;T$uH$H0HtE111HH<$MAEHHIDžD t5CMITfDIABAD DAAA1I9uCɉ 1ЉMLHA D8IH[]A\A]A^A_fDAtH4$E111MVfIIEH$AEIG.f.~{HHH*X f. H<$H4IEIHPIcEIIIGAUMAE1H$H0IHE1112HcHHHHH H*XIH5 1R H5Sw-H= 1mf.AWAVAUIATUHSH(FDD$HHPHFL|A t/SHtHHJȉ 1H9u 1ЉЉD$ AGD$M'LcI$D$O4 L|$H|$M% ADIIGI9OI7FHcD uoEuj19tDЄtML|$M9D$D$AGH([]A\A]A^A_DHT$H~HDD$HLMAD$HcAD uD$ DD$HLLu?!IAWL D$ M'L$ HLDID$H([]A\A]A^A_DH I D$L|$AGD$HHH*Xc f.k L$I?L:ڋL$ Nd D$ IHLD$I$H([]A\A]A^A_Ð19tGAAMcIAo\$VHHHH H*XPI|$H‰IH5s-H=] 1 H5y L1fAWAVAUATUHSHH$H|$LD$hD$HD$ dH%(H$1HF <%`II=`M A"AE IUMeHRHT$h‰E1  T$~$@$Lu D$XE H} AM AA@HD$T$h t*I|LfHr Ɖ1H9u 1AAADȃEDEADD$(HE#PHEHHL\$hLt$0Ll$@Hl$8MIcMEHHD$`@HHHkD9}uD9euH}L9t!LLL$PDL$HwDL$HL$PuHl$`T$(EHu1ƒuD$MMLt$0Hl$8Ll$@A 9D$(t2  HD$H9=D$(AtM HsH;50o-P$t'HtFFHD$ HCAu |$XHSH؅HE=fDt$ Y $ $IFHH5o-1PDtP HHu@D$(HD$M} M$HD$t1AE zH|$LLl$DL$0LLHLl$2HT$ H|$AHHITDL$0t HD$ƀ|$(@AS1H$dH3<%(HĘ[]A\A]A^A_EMtAE   HD$T$hE1 MLt$0Hl$8Ll$@t&$uL$hH|$L LD>6D$AE+$D$0t#$HD$   HEH DA#VH|$DL$(H1E IDL$(~HD$H9t$hDDLDL$(vDL$(IEH|$ H;=)l-I}HIEL+ AtM IFHI;FIF|$XIEIDC@$rH|$UDL$(HIDL$(ML@ Ix>MHXHc$H|$LMnHDL$(E1I@MnDL$(I^H|$HT$h"L IAE DL E1ɃIEHxDAfD|$~H|$HT$hHL$~LDL$(DL$(DA|$~DEI9AM AIAAfL H6)fDT$~LD$hL$E DЃD$d$EHEHD$ tIH@Ht@H5k-1f.PDtPYHHu@\HuHr|$)DM H|$ AEA‰D$@D#GL4IH L$Hl$PLLl$XEDIcEMHD$HIHHL{A;/uE9GuIH9t-HLDL$8DD$0HL$(HL$(DD$0DL$8uHD$HAD 3D$@uHD$Hl$PEMILl$XH;HCH;h-NAtZHtUP tJс uҁ uH|$L  DLD1@AIM2E HEHPHEHDHH@ HHMM AE % IEMeHHH$H E1A| : H LCE1䋄$D$(BHZg-MHCt A@ < M HIE tHUHJHUH9\> E %B=BH|$HHLD$0LD$0H|$ HGHD$ HHHGue D$(t#MtA@ A@ E1AALuXH|$ALL1 >DȃD$~d$~S@EIA AtL1Hf.$bIFDL$(H<DL$(HEfHD$$ t/MDLHJȉ 1L9u 1AAAfHqe-H9CnH|$PHDL$(3HDL$(QMDL$ H|$LDL$ IH\$DL$ HHALHHIvHHXDL$ HHHXHCH@ HCH|$LDL$ LhLsoIDL$ @HTIAHX@L~H|$H$HL$LDT$(CDT$(DA|$DEI9tA&ADM HuIH}ADM qH|$HVT$hH|$EDL*DL$(IEMtAE  8HD$$ H|$PHDL$(a HDL$(aLt$DL$ L1LH&MIDL$ MDL$ H|$LDL$ L|$HDL$ LPAHLHLyDL$ ALLt$pL HHLtHC PHHH@HHDD$(H|$DDLDL$8DT$0HsH|$HD$(HD$(DT$0DL$8HCLL{|$~HT$hLH|$с 1DL$ IE E1E1E1ZD$(oLDL$0HD$(DL$0HD$(1ZBIEHx3IEDx1H|$ED|$AHD$$LLHDT$ 7HDT$ tLpMtAF HEHD$ MME1E1E1rH|$1DL$(M HD$ DL$(|$~xDD$hHT$ LH|$HDL$0E1DL$0HD$ LD$hLH|$D|$LHHD$D$X$djHHx H|$HLD$ TLD$ _H|$LZIE -LHD$0DT$(QHD$0DT$($HM Lt$1DL$(LHLHD$ (DL$(|$~DDD$hH|$LHHDL$ DL$ nLnH|$HDL$ cDL$ %=I@PHxM HEHPHEHTHHr:HHuH|$HLD$0M LD$0VIFDL$(H<uDL$(HEmIEHxIEDxPHEHPHEHDH9 HHH|$DL$(DL$(;HfWf.@(D7H|$HLD$ LD$ LvH|$LDL$0DL$0jH9t$ wH|$HDL$((DL$(XH|$DL$(# DL$(?H|$pLHH|$pLLYH|$LDT$ DT$ H|$LFH|$L E141H6HC80'HT$hH|$ LDL$ qH|$H$LLIH$J H|$DL$ HDL$ HC^LHRCHT$hH|$ LDL$00DL$0IP3H=P LLCAGA<$:tLLCE1E1+H|$HA| :HuHD$H;0E1A IGLh MAEIEHPIEHTHHRHHuH|$LA0@LCf1I @E DHT$hH|$LLD$0Ɂ LD$0IDL$(7$H|$L4 LD#SH@JH5 LHL$(HL$(E1AtLi$H Hߑ H|$H5' HD1AtH+H|$H H5 1AtLH |$0똃HHPf.H(1ELcx(L$0LL$AD$L$H1BH(DٰLcDf.AWIAVAUATUSHHHt$h JMHD$XIHxH@HD$`HD$hP qD$0HD$(t#HD$hH|$`H@HDHH@L$0HD$(Ht$hHhH|$`Ht)HWHH9rHDHJH9wHuHT$`HD$XHL$`H(Ll$hLXL@HHLHH1LHHIoLLHQHIF1Ht xH9t(L9t#L9tH;5W-tHHT$ CHT$ HHHt$Ht$XE1D$$E11Hi\HD$pHHD$PHD$PH9D$`JHL$XH|$`HHxH|$hHHHRHPHHL$pHHHD$XHĈ[]A\A]A^A_H|$hW tH@HD$`fHPIF1HLc@HHFL Ht$Ht$X$$D$L|$hT$0HL|HT$(LH MH@ T$:uHtH:HtV pPE‰HFf.ATUHSDHAuVIHHʹ ItH It$PH $HE1QID$PH[]A\H5x D1fHH@-E1$@1LhHHDf.F@LSMXIXACHKHcH9~AH(H E)H@LFIAHILHMHIM9مHcLNL(H I L9tBLNHuLIP I)IEt=EAIcH(HL)H fDHHR H<HH9uF % @F [LNAWAVAULcATUHSHH(FGL3McINI9MF HsI9MvHL)HIAxI*fWf(cx Xf.ILD$LL$HL$HL$IHL$D$HcHPHC@Hp Hst&t"MH(IDHHAuHHHHADI9GHcHH*Xf.<HHHHPH9wHDjHcHMcH*Xf.H<D$L$aH IL$D$HQHH*Xf.Hq HL.HHx HLp HHP H@A)H;XHtC@t9Et4H(IcHHDHTAuHH)DHHH9uHHP HSL`H([]A\A]A^A_fDPHIHAIcHHIH u L$$LHHAA1nH([]A\A]A^A_LLHH H*XpMHHgfffffffH?HfWu HH)ALHHHH H*XHHHH H*X?HHHH H*XHUH+UHUHH@ HEJHE II1EAAMMAD$HHxTH*Xt f.t wlwUH<IF HH(H@ HC@HpEMcHHHH H*XH5:-H=G 1H5os H=2 1AWH(AVAAUIATIUHSH(V HLDE>Ict)HEH@H9+E @jLUI9ZIBHUH9E@ I9XLI(DHIBH LUIBH9|N<IZM'E@HEHXHL8-I(D$fDKADtII9t+ EE1HLLHD$LT$cHD$LT$Aft {IfHHu|$H(L[]A\A]A^A_E@L<;I7H/FFL HL~PHEI(I9tE1LHLE1@DD$fADHLLU fHEH@AxE @LIZN<$H@HH@HZp E1A LH$H0eHtBHH@H0Ht3F HHSHPH EHEH@AHL=DHL%HfDHLMLȨ$U oIuIMLH)HH9LIuLUIBtHHx )tkHfWf.B(DHLs1HHF80HL&LHS1L肨LDAVAUATIUSHHFufHHcH;B2HSI$(HHH9t{ yHt z uH0f1H[]A\A]A^fPL$ rHIffDL@ IHL-1ALHLʫMtUIE@HtIELh@IEH[]A\A]H@A^L1HHމ[]LHA\A]A^ڹf.Ae fDCHH@IFHH@Hm E1A LH$H0H|HH@H0HtmF HH>HPH1HHF80DHLHL$ CHH@dHLL$ L$ DtcHHx tLdLIź HQA1LHL$fHLEiDt;HfWf.B(DHLLHTd1hLKVfDAWAVAUIATUHS H IHcHH*X4l f.L411HFIITHHHIL9uHL[]A\A]A^A_fHHHH H*XOH51-H=_ 1@f.AWAVAUATIUHSHF }t-HH@ftHt xIEHLZHEHxxFDu ADL$ukHUH+P HtHcHPHEHP HU|$H@uH[]A\A]A^A_f.HL[]A\A]A^A_ f.LhLH]EHE}LEtaEMcM$(IJ\E1I@҉VtFIHM9t'H3L3HtVuLIH7M9uHEfL(fDfff.ATUHSHHF uoIu&HHHLHPH[]A\δfDPHHtH Rh L$$HHAA1H[]A\T@UHSHHH6HtHH[]~fD@ HT$HT$HEHHH[]QATUHSF HuaHH@H?L(u;HHCHJHHL HJH(HC@tHHfD[]LA\PHHt>H ?g E1E11HHHt[HH]A\0[E1]LA\0CEHH[=AWAVAUATIUSHHF C @uWHHCH+B HLzE1HLEEIDBT=A HHcHBIcHLsH*XMKT>KD>HH)L HH9uHMcL)hHL)hILkH[]A\A]A^A_@PHHHHA[]LH e AA\A]A^A_19OHcHJHHJHH)K)tHfHLHHHH H*X>H5,-H= 1fATIUHSH6HHt+Hߺ^HHuL[]A\1f@ xHEHDf.ATUHSF HuqHH@H?L(uKC@HCL tH(HHCHHCHHhHHhC@tHH[]LA\PVHHt>H c E1E11HHDHt[HH]A\[E1]LA\C5HH -Fu HH@ff.AWAVAUIATIUSHHFI$LcL;xAD$@HPIt$ 9|HcƒI(H)LtHHI)҉V"H HL9t6H3HtVuLHL$HHL$HKL9uI$LxAD$@tyHLL[]A\A]A^A_'PHILHcHLHH Kb H$AALLL1H[]A\A]A^A_9\HcI(HDHHTDHHH9u'LHL$HL$fHL[]A\I(LA]A^A_ޭ@f.AVAUATIUSDv HA AAugHHx HH@ HHCH@H@CuEu []A\A]A^Ð[]LA\A]A^pHL5HLLhQCHAmLjHcEH,L)L,fDFt.HL92HCH4(HtFuL蝙LfDPHtHLDs AWAVAUIATUSHHF ANHLcH@I9dS @JHHsI9L>uI(HC@)At3MtAGRAG#1H[]A\A]A^A_fC@LH[]A\A]A^A_@pHLݺHH@YPvHDHLHHLH'pHL'HKHLpnHH[]A\A]A^A_@Cu2HH@1fHLHLŷLL1fDI(HHHCHHH9hHHhuSH@HYH@H] E1A LH$H0HHH@H0HF HHHPH1HHF80f.HLL[]A\A]A^A_LLe1DHLnHDCu4HH@ht%HHx HL#t8HfWf.B(DHLLH:1멺L4荶f.AWAVAUIATUHcSHH(FuKHHcE1H;hHCI(HL9tHAH(D[]A\A]A^A_P>DIHL+MAHAEEtLDT$IDT$xlECuMHH@H9Ayf.CuHH@-E1OHL赴HL襴H뫐E7IGHH@H[ E1A LL\$DT$H$H0HHH@H0HF DT$L\$HHH@HME1LAHLL\$uL\$pLLH$L\$HLLtL\$MAC tsIHH@HE1HIC80ACumHL`AAAAt'HHx A$tIIHx AHfWAf.@(DDHLD`tlIfWAf.@(DDHE1HHF80AHLL\$mLHҾL\$DT$E1eH(L[]A\A]A^A_L魒LL\$蛒L\$A(@f.U@HSHHHtHH[]f.HHeHH[]f.AT@IUHSHHtHC Ht+[]A\fDLHHHC HufCjHC []A\ÐSHGHHPHHCuLt H ƃ1[AWIAVAUIATUSHHHdH%(HD$81HGpHcHGHlHM LeMAD$ u?< %=ID$HL`MAD$I$1L MtAAE1E11HD$$LLH߉D$EHtLpA~ MHIELH藚x H|$8dH3<%(HH[]A\A]A^A_f.„-HELuH@HD$0MH E1ɉE1$LHȈD$ L$0HHpF HH@ I1fDHȻM OH@H@D$ E1ML$ HT$0ALHOHtP BA<M HPB<ƒaAV? H-D uvH U HX H5X LHHD1(HUB MtA<PH-D L$ T$0LH }HIZHH|$ IL$0tH A$$LH15HT$0 HHKM IIVHBH.jGI$DHPID$HD(HDxLD9IFH@DHUB /DD$ AE LH5S HH1詭fH背NfDM uDHPHLbMHSpHHHc HSHl#HH舸HEtLHLHt M @軚HH5R 1t\IE8ixsxaxH5 HHE@ 9"1LHWDSHHHW H)H~$HKHpHQ(Ht+HPHCH3[HHH؎fDHIHSHHPHCH3[H@SH`HHGƇHPHcB HHHBHcPHGHHG\9GXLt H HC[H۾fATUSH/HHG H)H~9HCLex#HP(HCH4x7HFHHtCHEHCL#[]HA\HHHH`HEf.1HH@Hf.HGHSHGpHHPH;WxHWptHH+CHHC[H@;HSpDATUSHGHL'HPHGH,I$HE@t HH詳I,$HCL#[]HA\fDSHHHW H)HHH܌HSHHJ(HSHHHHC[HfUSHHLH/HuHt}F uEHHx u]HSHMB f%f=HDH+HB0H[]HHHP1HwHҸtHF80fHCH+HH[] WDt#HfWf.B(DVHc:-@f.AWAVAUATUSHHHWL'B#Mt$I,$Ml$@t HLÌt uoHHH#EHH9NL9tLHHvE@Il$HCL3HH[]A\A]A^A_fDAE zƃB#xM}E Aw $Av;B"<l<v%HDD$8DD$Jf.H HDD$薩DD$HEAG IGH@Ht@AWAWIEDHHeE t5 HHQM H1蒕oDЃ wT A'DLHHSoq@LHHD$PHD$(fD HHDD$VH DD$у @@yMo͈MLhH AEHIGH@IOHE1HHp(IEAGt=AGt?H認DLHHD$PHD$8fDLH5LH8HpF @ 1pHƺHHD$HD$H fATUSLHH/u|HuLeHt/F u7trHHx tHCL#[]H@0A\HCL#[]HA\ÐHHtxHPHw0HtHF80 yDt#HfW1ɸf.B(DyDH蛃_1UfSLHH`ƃHcB HHHBHcPHCHHC\9CXAHCx"xHcK8HS(t;sH|H[fH(HC[HHжfD fmf.AWAVAUATUSHH8L/dH%(HD$(1HG@"@MeMImE A G  II9I9M HEHuHPHT$ AtHPDpHƚHXH@HDHEL#HC[]HA\f.B %=uHHH@ H9A fD0uHuHUF gDUSHHHGH/@ Huf%/fF Ѓ ǁtkF %=t,uHH`HuF@tHnHCHH[]HHP t:1PL$WLHixD$4IHD$HHD$8HD$pLl$XMHD$@IHD$PL$4HT$ LILWgHIuAAƆIH@ I AE@M&IF L)H*|$0I\$Ml$6AE #H|$8uBu=IUHJHBH)HPv(HA(HLQt0H@ IHPHr(H/LSNYIL|XHHD$ TI1LzIDLL@U I_ d11LLGAE LDAE <X„]u% =t11LLGIEMH@HD$HD$4H3LLLc|HHD$ eL`AE 1LLLLAE fHqHrI}rIEfDPLLbʃ PIEHxeI UIB <A:Ht$ Ln%LLUpAE _IUB LL`AU :LLm6LLePAE M pF8I$I$)fH H1L`q|$0MLl$XI1Lwu6ADH Lu LLDH} 1RgAE  tLLOAE _AU @I.t LLlH]LmIH E1E1LID$HD$HD$$vHIHFHHHZ HƹLwIH@H0F@uUIGHD$ ||$0AU -HB@ Hƺ L<H@Hp(LkDPLLp^1LH@HILIpf.ATUSH/HHuH)V H HKA"@HyHKH,tHVB HPHHHB tvtHJA Ɓ6HHK H)H~vHPHHHcpHHPHHHH[]A\HHmZȃ {lHH0V DH¹HHCHkHpHH/H fDH(A H]HtqH¹HHL#kHSID$B"@LEE@t HHiI,$HCL#[]HA\fD HDH^AWAVAUATUHSH(L'dH%(HD$1HG L)H;H`HcP HHHXЃ <HC0H/HK(HIHLxmLs8E1MHE@#1EHC@t K QHcH9AV IVHHC@L,MiAE =`AE%AE EuH(I9I7M/HtFFHXH@L<Hs@Lk8HD$F yHH^HRHT$AE +IEHL$H9HM7HI#FHLHZIAFAFMI}HWx1LH{#fDH5 H14BH|$dH3<%( H([]A\A]A^A_ÐLLP@IELk@HcCL9~:AF ;3HC@IVHHC@L, f.H@ID$HEILeHLHs8H;s@M/HI#EHHFHC8H+xIAEAEHH9C8HH9S@HHC@Hs8fDE1AFIH@fHPDD$ 1HS@LHmHDD$ L(HC@DD$ HPLH:DHT$"HOH}fDH:LXAQfDHuL(@LHDD$ ZDD$ H @LH]VHI7HrxLLHjf1LHuhLH9 HxpIHE1E11ҹyLH@HyrMIEtAFLp@IEHS@HP0IEH@8LHtrHH5 IH1Zf.AWAVAUATUSHHL7dH%(H$1HGHHP8HD$8H L$иA|$ LEE1GBCHD$xtM.ILHD$8@"@8I.IE  HD$8@Bu2E Ѓ - vE %= HD$8L3IHD$PD$fD$0D$gHD$XH$HD$HH$HD$hAV IH@H$IFHD$p@Z ED$0D$0HD$8@@D$@t^1U I$R8҃ HD$X@@%@Ѓ 1|$@ ƃT$gAV tHP@<I$Ld$ MHl$p`8ƃk^AA@DDDA`Ht$ HELD$(HLHHH@ H$PHIHD$ HHA DE1ɃHD$L$$IHL$(T$Ht$ LHPMAE  HP@<AD$ |$fAU IEH@H$IE D$ftHPR<׃@|$fH&Ht$ H$H9Q@ |$@u AA9|$ft AD$ H|$8GBL$0 @AD$ % =I$H@H$Il$D$0HH|$ H$L7HtHt$(E~8AtHHH0hD ALD$`IFH)H)qPAT$ AfDD$f1T$0HD$8@B%LHjRHH`IID$11LHHD$pGSH;$HD$pI9D$ fAD$ HP@<AU HT$h"LHIAU I'HT$HLH6HmHHHH8H H<ʀ H|$ tFH %HD$XHD$ Dy8LHstL$gAE Ht$ HD$XHDy8Qf.H(sI9HD$PtLHHK_H8 HHt$PHoH|$PG /HD$fH@H$HGfD$0@#HhHFH(HHC L)HLLH;6II$Hl$pLd$ MH8HƃHT$XH5' 1H17fDHD$8@@%XfDHPHCH,Ht$8HH@LFBLbHEHBD$x;CH} t$xHA`HCL#HH$dH3%( HĨ[]A\A]A^A_fDHT$HBLHSFAV HD$p"DH HC1HH>,fDHl$pLLd$ |$gL|$hIǹI$B;EE @|$gOHT$hHt$pHH)NHD$0HD$XD$|HDMD$XHl$HH\$ LHl$pDl$|L|$pDt$gLd$hfH|$PHt$PH|$ LL)L fLd$PH|$ 1ɺAd$ LNHt$0H|$ L_HH$H@pHLcPNd|$@H|$XM9Ht$HAIEHL$(LH@ |$H4$HD$HH|$ P=AAE;D$`DHDP8DEt*HPxH9t!MHt$(LI)HN$H)I<4H|$(H@pLc8I|$ftHD$0@ Ht$0H|$ LL)AL3HT$pHt$0AH|$ 3HT$hHt$P"HCD$fLHn%=HP@<Ɂ MLd$ |$fLd$hIHl$HDl$|Dt$gH\$ QE tHP@<:H|$PHL$(HT$hHHt$PH)cL|$P1ɺHAg LLHt$0LHH]HD$8@BHHt$0LxHpHHD$8@BuE %|$fC D E D$g I$H8D$gD$gtI71E1E1tHfD$g҈tZtVE1E1t1HHe<HL$(HT$hAHt$0HH)1D$gE@D$x;CHƃnHCL;HH|$ LL)LJHD$PHt$P1ɺHJ)H\$ H5+ 1H1eP!HEHxt3E H}tWHuHWH)%H}E AZHEH|$0HWHUHHRHPHHEHRHP1G T$ftHP@< H߈D$fHD$0H@L+HkHcT$|HHIEM}`iT$g DE I7HBHYHH9U_L`L+AG A;G$AG H`t$`H|$0HcB HHHB|$@T$gpt$xfPHxH|$h@p Ht$pDpLHx(Hh HHpHp0Ht$(H@@L`HHp8Hp@F=AD$L+HCH@Hy1HgH@H(kL|$hIHD$XHl$pLLd$ He |$@t$gI$Lt$(@;H@pLchEHc@t$gHt$pHIHM)H)L9HtHL`HHH$E~McHLLYHLH+L$pHEHHHHXLxHPHT$(Ht$hHH)hGHD$P2HDAG 8HD$hHl$0E1L|$PLH\$ L|$p\$gIIXHEHt$0MH|$ HPpH@ LcRH4$HD$HD$O$I9LHL$(AEPAAE;D$`@HEڃ@;H@pHcELHL)t0M9Lct%LcLLLHL$HLD$@XHL$HLD$@MH$H2Ht$PLHL$@FL$HL$@HI)HHL KI$ƅIM9szDHG L)HH(MIEQ@H[HhH@HHHfH1[]A\A]A^A_HHMHT$THT$tI7HHH#FH9uPIt$MHXZ'ML+gL1L #HEIMcN,HMIID$@IT$G\9GXHHM]KCSIT$HC(HHH8H@(HQHR8HHDHHR H f.ATUHSHH@\uE^IHEHL1AHP8:FHLH []A\1.D[]A\H 1.AWAVAUATUSHHXHwdH%(HD$H1HD~"H(L`AAHHl$0HU ƒ H } HcH@%=HEPwH@HjHHXHs\H;_CXC\HEP\ t @Hx0HKAA"<t+<At!<AtHTAHEHKP\A#t~HH@HxtlugHt$0HH"HE@\tHPHpHE@\iHH@HhH$ HEHx0 P\f'HCpHSL`HHHKpHcHHD$HEH@HHD$AF A;F$1AF H`HcP L4ILpHD$AH+CHAFHPIFHCpH+ChHAFC8AFHEnAIFHC@"u@#A`HM -f8In(HEDڃ @` IF AAF@HE@`HCD"h#EfEnHCHIF HE@`HEP`~ Ht$H&H8!H;?HEEHcP`HD$H@HH8H@HCL8AG@HhH|$MH@I)LoIIcH@(IF0HhH@AGLx(H8M~8IFHIHpH~H9Hx MOI9t&I)ILHpIIHHHqH9ApHHcHpH*X f.IH4D$(LD$ L$HT$HI7D$(LD$ L$HT$HF IGoHXH9 H8HnE < H5 H1 H|$HdH3<%(+HX[]A\A]A^A_f.HCpED0L#uqHhH@L@(IHHtVHC LcL)HL9MI*Xf.IpII|$LM7L;Hpt(HPHQHpHǃpHPHEHHP0AH!HCHHH@HD$@HFHHSB#H|$@!HvH - HT$0H5 HHB1DH 3AF H HSAMcHH)HI9HJH(J HCH#f.H5 H1 f.HH*X 2:f.LD$IHLC6LD$IA@EHcHrt$H|$HTIEHt` II9uAFf%fHEx`dfL#HEH@(YfDHCHt$0V H@8HHD$8HPHRH9HEHH:HE@\bH5{ H1@EHkpL#HHL$8HT$@E1HHDHHuH,QHs\HWCXC\HD$8H0HHF Hv(HcHHPDD AA ,HgH@HhH*f.HCpHSHHHKpHcL$:LLHLD$1LD$I5H5 A H8 HHSH@HhHoRLLHH H*XH5X H1aO@HT$@ H)ZHT$0HHߋJ HT$@ o#HHOttHH@H9hbHHRH#AA6A`hLHeUAG % AG fDHHhHD$0E 4f.H J HHHH H*X%H5,H HHx(H5 H1HHHH H*X )"HASHT$8HHA1H:H5 HH1HEHx8H@(HWHR8HHDHHR H2H5,H=m 19ff.ATAUHSF H ȃ„tucA@A`nA C €@S  uH[]A\fDHH>C tH RHHHI5>[]LA\D>C ȃ;HSB .HHzt/H{tWHuHWH)%H{C @HHBHA@H@ HGHC@ HGHCf.HH;S DHH f.1HHCH1DAUATUSHHHGH/HPHGL,HG H)H~[LmHCLe@" t P#xY`uL#HH[]A\A]L#P#HHu`JNHEL#HCDHHHuHPHCHH4BHCP#f.AWAVAUATUSHH8HGH/@" LmLeDx#t]AAAE E1҉ nAD$ < tUH(HEHCHH+HH8[]A\A]A^A_DE1E1AtE1HCAEDx#DɈL$nPLHDT$$D\$ )EHD\$ DT$$H@HYH@HLMH LHDT$$D\$ LD$(04HD\$ DT$$LD$(H? HL4HD\$ DT$$~E1E11D$HD$L$LHDT$(D\$$v;HD\$$DT$(D$ AAAi1E1E11DT$HD$L$LH);HEHHHpHH(H9|${AD$I$HzIT$HTH:HRt H?~ HSHHD$R"HD$HpI)E1҃oIEHx`IEDPSELHDT$$D\$ BHD\$ DT$$UAD$ AAE۸1@|$ HD$HSLHDB"LAA9HD$Hp@LhMtGEuAD$tAE oLmHCHH+HH8[]A\A]A^A_Eu*fL(PAEHK IHHILH@Hy)E1IE1yHLHDMtAEAEIAD$HL`@IH@8LuHCH+HHC@#`HIH5,H8H[]A\L1A]A^A_vfDLLHb, @MtDIG LH9wH9tH9s LHM)H)LLH)M)LfHHHH H1HHH1H#GHHHtH9pu DH9ptHHu1fDff.Ht{F urLFMtiHHpHYH(H9tMx6HcI9H<t7ID8f.HH9Ptuf.ÉSHH0@@ HHPH0H(HH IHH9sDHBH9HRwHB H(H H([@S)H2=tDHsH 3 HtF f%f=ot0HI,%H H )H1H@[ÐHt HHDH,Hx H)H H9sDH9Hv*Ht%L, fDHtA HH9wH9HGH)HHt6fDFHVHփL`MMI*fWXf.q J4F$HLL)H*fWXf.:J,H1H<+ MUE1MIMVtkfDH HHuKHHH+HH +HHt/HqHIHH IL1H1L!L9uHHHuIHM9u[]A\A]A^LHH*XHHHH H*XH5,H=% 1@AVIAUATIUHSHHHHtL`[]A\A]A^IHHI I1HHI1HC L#kH;C(tOHPHS HhL`HJHHJHKHQHSH8tH;SvHL[]A\A]A^2 HSHH HCHHS(f.ATHUHStTH HHIHt []A\DLHHH IHHHL1ff.AWAVAUATUHSH(dH%(H$1HH HHHt)H$dH3 %([H([]A\A]A^A_H=F HIHHyH= HIaLHL\ HIH HHPH`,H L`MILIHD$IH$hH<$LLa"LHfLHD$fLxIH LHPH`(H L`MIL I9uH<$LL9 uLLH<$HtHD$H9tH LHH}L,L D1LHDLH LIHPH`XuH H`uLL8qHt$L#DfDL`H$RfATHIUSt{H~ttHVH^HxoH*Xf.wuI<$H1yHufHH+HHuID$ID$ID$ ID$([]A\@HHHH H*XyH5},H=O 1@f.UHSHHtBH~Hu HHHuH}HH[]fH[]fATHUSHtDH IHH/Ht []A\DL9rI$h H9sL)HH[]A\1ff.USHHHH1HtFH{t?1HHHjHHt#L $A11HHH{W ffotEH},L H@H{,HL HEHH߾)[]1HHtLHfHY},Lx L ,HBy,MLf.AUATUSHH(dH%(HD$1HF H @t]tC 0@H Hy  H{(HsHf fup jЩ )H(fWgHKA uH(A HH HwP tHKH9HoH@( @H@(HD$dH3%(H([]A\A]ÐЃ4 utaHH*@ @(C tHHL` @(-HI9ċC "C B(c@tHHz)%=wH H*A f.HH@C T$ T$ zHKf.Hx;H*HHC  C DHȃHH H*XVHRHsHL$HC AuoL+HsHAE(H@(f.#3H}HH9HA>A:HD$HH9|K "HBHKA HH"DHA HH*ifeHP HH*ifЃ HH&fWDH1Lb IZB(HHI9HC <1HH*C C €"ES H C J(HƒHH H*XRHуHH H*XHH#L` H*I9K HHHs1HHPHHG : fW H$#|HHlHD$K 0HxaHHB AsH  @(f.=HH;D$Ht4K HH؁K 0HB jHHB K Hz tŁK "뼁K "@f.AWAVIAUATUHSHHdH%(H$1F H|$PLD$L$D$^ tHPR<׃@|$^% = H|$PH$LH]H,H|$H ˆT$\;%+H|$D$_H|$_+D$^D$]L,+L9H$@IHDŽ$HDŽ$Ƅ$HDŽ$H$H$A?%H$D$hHD$@H$H$HDŽ$Hl$PH$qDIWfHRz%rL9HH$uLI9sqL)|$] |$^ H|$@#Ht$@LHEH\$@1ɺHc HHLHL$LL`I9L$|$\H$tMx-H$HHLcH$HPH$8px L$HHD$ HHHD$8iH$D$ D$0H  D$ D$ZD$[PHcH;%B{.8D+f<(CE1LkPЀ wCIDdPAEPЀ vELH)HH9$bH$H0F /H@(A}gtuEH$H$o9HH$H|$PAHLoH$dH3%(*H[]A\A]A^A_AD$dw5L$@DL"H|$PLL$@u|$_$pH$|$^H@|$]@ ZHD$PHP@<|$^ELjD$]2HFH$D$H$f1E11E1E1<*It@|$\^HD$0H\$ЃHCHHFHLT$ H$D$`LT$ D$hE|$[|$\VHD$0rH|$ЃHG\$`HE1D$ E1D$[\$h D$ EhIH@+$|$\$>AVA$Hc EJc HE|$\1HD$0" H\$ЃHCHcH=w HvAF tHPB< $D$`H$HDŽ$D$hD$ Aq1D$ $D$ D$ AqH$H<D$`IωD$hD$hD$HD$`Hɗ H$HHHD$D\$pH$ D\$pD$=H$D$`;$|$`_HcH\$`HD$0H\$ЃHCHH]|$0\$0|$`AD$ |$h$ HD$0H|$ЃHGH\$ 0HS HHHD$`L$D$huH|$0ʃHWHD$0 H|$ЃHGHc#H|$0HWHD$`L$D$hBl$ H$L$D$D\$hDŽ$ݜ$$$D\$hD$L$=iȒ2 )ʃHcHD$0 H|$ЃHGH+HD$0^ H|$ЃHGHH\$ 0HS HfD$`L$D$hf|$\AVA$H EJcHHD$0H\$ЃHC\$`HE1\$h}HD$0uH|$ЃHG|$`HE1|$hJHD$0H\$ЃHC\$`E1\$hHD$0H|$ЃHG|$`E1|$hHD$0{H|$ЃHG|$`E1|$h{sHD$H0ZH|$ЃHGHH H|$PLHHEH HDŽ$Ƅ$H$+HHT,Hr$AqƄ$$H$HH}|$pH= HDŽ$AHD$8D$ H$Ƅ$D$ZD$[$ H$HDŽ$H)H$E1|$0H$t\$0A$ |$`D$ |$h6|$\HD$0-H\$ЃHCLcDD$D$pH|$HGHPHWIH$@ HH@ AcAh\$`E1\$hH|$HGHPHWtH|$HGHPHWH$Lֹ"HD$D$D\$pLT$HLT$HH$D$D$D\$pAB 4|$`D$ E1|$hH\$HCHPHSH|$HGHPHW,H\$HCHPHSLl$ HZ AHH'Hl Hپ"H1$Ƅ$$H$Ƅ$LHH|OH$"HHL$D$L$H$D$C A0HMHL$D$D\$hH{(H#L$HD$D\$hH|$HGHPHWIBH$AD$H|$HGHPHWHZ A HHLHD$D$D\$px1ɺHHHD$HaLT$HD\$pD$D$AB ID$HH@H$IBH$\$`HƄ$ -D$ A\$hl$ HHH1<$AH|$HGHPHW.H\$HCHPHSH|$HGHPHW;${H$LTD$hD$`\$`E1\$h|$`E1|$hH$HL$DL$hD\$0L$DL$hD\$0H$H$AHLT$hD\$ BH$H$D\$ LT$hH\$HCHPHS3ED9$AAHHH$H4F HH@ Ɖlj1)H$HD$8dH|$HGHHHPHW(|$ H|$HGHPHWcH$@ HH@ AcHAhHD?H\$HCHPHS111`D$`;$}|$`HcǃH|$` H$@ H@(D$ D$ |$ HH\$HCHPHS$H$H|$PLHH$01HHLT$ H#H)D$HLT$ H$D$`D$hD$`HDŽ$H~ D$hH|$HGHPHWtHcD$h9$x|$`H$LH|$HGHPHWH\$HCHPHStH$"LHD$D$D\$pD$HH$D\$pD$D$H$@ MHH@ ED;$AAHHH$H4F HH@ Lc$D$p\$`H$E1D$ \$h\$\Aۈ\$[H|$0HWHD$`L$D$h|$]HH$HHD$`L$D$hRH$G HH_HRH$ 3HP@<"|$p)L;$MsML$HLT$ L2LT$ H$LHL9IG1ɉ$Lc$LT$ H|$8D$`MD$HD$h@H\$HCHPHS:H$HL$DL$hD\$ L$DL$hD\$ H$HL$DL$hD\$ L$DL$hD\$ H=G1LH-[HDL$pD\$8aDL$pD\$8H|$PHL$D$H$HHHHH$5C D$L$tvHH[HRH$H$ Ƅ$tHP@<$H$L$D$ D$L$H$"HHL$D$?L$H$D$C ]H5@F,H= 1ZHD$DD$pD\$HI‹D$hD\$HDD$pD$D$`GHD$DD$pD\$H脵I‹D$hD$DD$pD\$HD$` H$HLT$ 舷LT$ oH|$8tzL$MH$H L|$8MD$HH)D$8D$`D$h L$H$"HLT$0D\$ LLT$0HD\$ AG .D$`E1D$ E1D$HE1D$hMl$ H$H$L$D$D\$hHxݜ$$g HHD\$hD$L$D$`E1D$ E1D$pE1HD$8D$ZD$hD$[=Msl$ HDD$D$LT$hݜ$$HLT$hD$D$;t)HLT$0D\$ SD\$ H$LT$0)$H5 H1$L$D$D\$h@H|$HWHJHOH|$HWHJHO H$L9HT$8D$HL)MJ<"H|$8|$`|$hH|$HWHJHO?HD\$pD\$p3E11.D$`;$}\$`HcÃH\$`H|$PH|$HWHJHOIAUIATIUHHSHHHD$$MHLHE1HkH[]A\A]USHHHT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH@,8H$Ht$ HH$D$0HT$Ht$HHMHD$dH3%(u H[]@f.HHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$葹HD$dH3%(uHd@AUIATIHUHSHHE1HD$$MHHHLC@uH[]A\A]f.HHL[]A\A]kf.USHHHT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH >,8H$Ht$ HH$D$0HT$Ht$HHHD$dH3%(u H[]@f.HHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$!HD$dH3%(uHT@AWAVAUI1ATIHzUHSHHDt$PL|$XLD$L $%L|$XDt$PHL $LD$H[HLL]A\A]A^A_SAUIATIUHSHH(HtiH H(LHCC SHD$$MHLHHE1_S ]HL2MDAn fDC Du ȍQQ&EAr'f_S 2HEHt@D { HCE HL}AAyE1E1t1HL!\@Du A D%= A C O A9DfDAHL蕺AfDADu A/A"Aq C _1HL#IuHH\N ffoHH9,H H5|v L1DTA@_DD$S D DD~E1H{Ht5HHzt+tWHuHW%]H)׀DH{C EHEHPHHHEH@HEHCHHHHHPK UD[HULbHIT$H9P1HuH{L1HL`HHSH@A tHUHB(@(AC A3 A Ds E VHLVHDHL@ V1HLCK AvA„tpAHEHPHT$0LeHHH9PH{LA HHT$0HPC %_DD C Hf`\6_S HL H{HHHzt+tWHuHWH)%H{C HHBHH@C DA0_S D%3 AC tHUHHR HP A VHUHB(@(@D1HL胰IuHH N ffoH5,H H5s L1]DHLmQLeAT$ QyMtAD$AD$ HD$HBƃt$t(HHBIPHCR$P@HCHX8HHBHHBD$  H HcHHCfDQAHu L1虵@AsHHL蘷A H~ JcHfDD$HLDu EDD;Aփ +H ZAHHLh>HLED$}HUHzALHD$#HT$[HH@HLC _S HS HUHR HP E ?K 3HLLx0E1|$LL!HD$|$ 1EM't,HLpu#HP(HtIPLTuHL p|$ VL;d$|$ HHB xIx Sx Ax HB(H@HH@HRHTHHtRtwdHHtfHD$E1Ht @@,AD$@dMSIVIE1E1LLILL{HH1L+H|$HD$@5Ht$FL$|$LxAxTHpHtFuFVHCH@HC@Lx A@Lx(A LxE1HUB D<fDHUHEHR HP C  Aƃ TA JDHHL-jhLHD$ӲHT$HH@HT$0"HLõHT$0IfDHLeHD$0HPHEHCHUHHRHPHUHHRHPc E _U HEHEH@HEH@e fDHa/,Hx DHL5S HL"S H#/,Hx yAHL裯 HLH9I(HH@ HcPHHE1E1|:/H{t HLIt$L4EHCMHp %1AGt2IHJIWHTH HtRtTHHE1HLLlHLgL9qLHLgHLpAAx:HCLx MLLA@|:IHD$rHt$LHH@ HcPH|:}|:rHD$HtL@jHt$HHPHFHTHHIR=0HH(HT$E1HLL1II9HD$ pH|$ HCxHD$ HHx0@\I$@\1HD$0I$E1HD$0B\LEHCH@8HHD1HHH HH@(@t$H0H@HvHDH0Ht xHtHH5i L1LD$(lLHLD$(HT$ HLL |$u=AD$ AA < I$L@IL$Ht$ HLվHC@HHHHHp(HuL蚭hH |$L{AL|$ HH5k 1Ѽ茪H5k HHL1赼HHAA"E1E113LLmTL[/x:@XHHPHt*HP(HtIPLHu HHHHH;HCx;H5g L1׻H5^g L1ƻ@] ^HpHPIL$LFHLI)IIHL~IH@H@HILL:HHH@x t2 LHL$HL$HLIHQHL$LyMIFx ueLxHE1LpA)IILHL$I@HqIWǺHL$E9u LHCL_@LHL$HqIV聺HL$CHLHqHL$_HL$DUHSHHJC@u H[]DHHH[]GATUSHHdH%(HD$1HHcJIHID  F  <HCHCHEHcSHEHPHEH@E D U HcSD uX% D E HD$dH3%(H[]A\fDHRHcCD M  D)E fDHsHH $ȿH $AHHLpM q@HL萧 螤E fDe 1@HR(UHSHHHHtTFtNHH@tjHH@HRHDHHtR@tHHtCHH0HH[]fDH1ƠHHHHHH[]fDHjKHHHH[]L$ H$sL$ HH4$;ATIUSHDF t Au#A>Ho HcHfDH141@ HLH@[]A\HGH AAHFtHX> fH> HFHFHeb t@AHFHNb AHDKAuHPHHSF߀THb HEH"> @H, @[]L"1A\HͩDVHLHHa HDC ff.AWHwv AVAUATUHSH(V DEMIIA9Itс ALUH,n Jc HMIHJH1HLT$LL$H $IA.AGH $LL$LT$H) HME _U r U HAA/HEIRHPHEIHAAIKHILH([]A\A]A^A_DLUAAE1A9ڋM II0I كM H5#m LcL@M A`E1ۻM bAPE1ۻyfM AG@MIHhHH1LT$L\$LL$H $IA荦AGH $LL$L\$LT$H)HMAQtFAAA@8s )Hc)H<1HcLL\$LL$L$ͰL\$LL$L$AKL]A=H([]A\A]A^A_~A<1HLHD$L $膞HD$L $LsHPHUHH([]A\A]A^A_DHEHEHEH([]A\A]A^A_ÐE1IIL]L r A`L r A?AGLT$L\$L $Hc誴LT$HL\$L $R@H5 a L1HEA`E1۳1HL&H5.] HALL1,@AT$tDHAHEH@E % @E A91HEH@ H5\ A LLT$L\$L $#M HLI HCHUL $L\$LT$H@ Ht@HHEH@@<mHLLT$L $\U HMLT$L $eHLD$HLLT$HHL\$L $ELD$HLT$L\$L $RHLD$HLLT$HHL $LD$HLT$L $zH5^ DL1舯AWAAVIAULcATIUHSH(dH%(HD$1ED$-EuXEA$ t7AEIHDIEHDAA ADD1I9u܍ɉ 1AAAI$(HHA$ I$(HLHCC ~DDHڀ|$LAD"HHCHLhHH@C D |$S t D)C L9tH讻Ht$dH34%(HuSH([]A\A]A^A_@AHL$HT$McD$Ll$Lcl$H@LH蓛ATAUHHSH;HHD[]A\UHSHH(HtAH H(HHHCC 8HH[]fDt$ _T$ HfDSHc HXH [@f.F'AWAVAUATUHSHHH0T$* HEL3L(DH{pHWH;SxHSpBHH+KHLHH L8-H+H`HH@HdHXH+SHH HHQHHRHSHH HIH HK HH HIL4L3HH`HXAGAGkE HUHL9IպDLH蔩HItHB\uu$HB(HtHB f%f=tfHH>H HI\H`HHHHA(A HH@HXL+sHILpHH@HCHHHRHHS H1H6HvHHH1H)HH`HXHHHWfE t>HUH2HtFFlE <U t$H[]A\A]A^A_mIGAGAg .LH݈E 5@|$XUM\t1AEt%IEHHIEHDHHt xHtHH5JY H1蘩H@ f%f=fDLHEH(HHD$ӽHSpHD$D HHH`HAH`HHHE H`Htx t&HH57QH1腻HH@H@HtHH@(Huf.H`HtHPHtH 1 vMH9tXHHtHPHtH 1 vH9t01IfHBf.HBf.@f.AWIAVAULXATL(U1SHHHHL$0Ht$dH%(HD$81HL$ F H@HL$fDDAAEIwI% AG H0h IA@@DA@HIHHHLIH;D$t1Pu*P @ uH(HH( MtAGtWAGHtSDu A 9A uHT$ HH H3IAGuLHUHuHD$8dH3%( HH[]A\A]A^A_DAG M9tM9tL;|$tL;=9,AGCAv^A AIHxtLHߺ<)LHAG AAW AF H^ HcHH@@HPHrHt FFIH@@HXHIH@@HXfDAG BL9fL9EIAW ItGHH)IHWLHLD$(艉AG 1LD$(7fA8LI_HUHBHHMHpHrHHf% AG LE1f.H0IHxtMt=LD$(~AG 1LD$(fDI?Ht$([Ht$(LI@ufA1A A CAAADAHwHLD$(_AG 1LD$(%AG fDLH`:E1LAG @@5IHrHtFvFAG AW %@=@ApAL;8AG@IHPHzIOHrHpHIHJIWH,LIIPHTtHp@HFnFH@LH5A IWHt`HHT$(HT$(H9tIIGHHD$(H9D$(t1IGHHD$(聽H9D$(It@u1LH葟IHx0Ht @xH@0IHxPIHx`IHxpܮL9AJHǃ:LH螁IHp HLHEIHGEw A LHIHxt LH/Ag L9 IHxHttAGtmHHIGHLHHtXqH HPHt(HcHD Ht$E1ADH1E11LH/IH*ILHT$0HHD$0LHPHT$ qIEAG 1I1| IGHuRHxtKIHp(Ht?Ft9HHPHFHTHHt!ztAHHtHLHIHp HtHCAG@(IHp(HLH Hx 藬AG A1IH0H$FTF HƸH}DEYA(KEHǃILH膰A AG A1 HǃYHEHxDu HHH@HIHL$(HD$0'EE 1IHl$(I{Hǃ 9Hǃ8HC&HHVHrHEIHz HHD$(-E A1Hl$(6Hp|Hc|AG HR|HUDhHCIH@@HHPf.UHSHHFt-H(H9tjHXH9t^H@H9tRH;5,tIHHCu)C C uH(HH( H[]CH[]f.USHHHtjFHuhF uV]uMt1H(H9~HXH9trH@H9tfH;57,t]Hu$@H[]ÐFuH[]۵HHI[HHK ]1醊fDCUSHHHFHFHH0Ht*Ft$HFsFHCHp(Ht+Ft%H@(FOFHCHp Ht+Ft%H@ FFHCHpHt0Ft*H@FFfCtCt'H[]HHH[]oyHHH[]g[HCfHHHC"H0HC>HcHxHxCxfDHxSHHvFt2C t?HCC FtFt[fD[rxf[zf.HX~c HC[USHHHFHt8H9`Ht,H9t#N ~W VvtG҉StVH[]HpHtFtH@FtBFtHSuHHH[]wHHH[]韲HwfDH耲SdUH5SHHƇ\zrH5 HarH5 HHrH5H/rHHǃHtE H`Hǃ`HtF tGHtEtEtqƃ\H[]HHevƃ\H[] wH hHHXfHHƃ\H[]H98t!H9tFN tFt@uðAWAAVIAUIATEUSHH.H|$H]HHu@HH]HCHKD9uEtL9uHHHEtHA Ht HLH|$H{ HtC H=C>1*x5AVIAUATL%@+UHSA<$H9ItzA<$H莁(l HH@LpHhH` HHզA<$HC L5u~H[]A\A]A^D(LLpLh H@H膦` HL oHC H[]A\A]A^ù5H = H=,=15ff.AWMAVIAUMATIUHSH~ I(L$ 薓HHEML$ HPHHXtI9ufqLcD$PMKCtLLHC HLL{蒋E tE HH[]A\A]A^A_Ã#t:tA|$ AD$LcKqz} mMdAD$ XID$HJP :H@H-H;h#LLL$ ݢL$ @|$PtqLk L$ 2~L$ fID$H9(H9h H9h(H9hH9hH9h0AELk f.AVAUIATUSH H |+HcI?ЃItHH-++AD$ t1  II9Pt @tGI$HxtALLDL$LD$HLD$DL$ttu?HAd$ 0ftt;D $MLILLtttA~tWLtRH []A\A]A^D<qD $tMLILLt@H []A\A]A^AL$ H []A\A]A^f.tLrwH5D= L1AVIAUATUHSF H< 4E1E1<1HHѤ<HH象IMeI$H{ t[ H` @HI<$t+HH赭HHKHBHHBI$HMI$tAMHHPH;P}HKHHPL4[]A\A]A^fDHHRHHPf<HI,DA~ .M4$[]A\A]A^諕E1IATIUSF H<to„uWHkHLH{nK HtEt@EtH[]A\fDHVB HLH[]A\DHLiH[]A\DH"7 L1 zL萊H56 L1迊Df.ATIUHSHHB t/%HrH= zHEH[]A\fDHrHHHRHt'HEC % = ue thC % = tiHuH[]A\@HL$HL$HEAdHHL[]A\HlDHE< w)HHLQ|HHE @AWAVAUATUHSH8~ H IHH@HtH8[]A\A]A^A_@AD$tE < % L(M7 I H(ILHAGAG HH iE AG%AG Dm AtHUHB EAAEDH=I IIIAE  AF@LIH} HIAVH)IAvAVH<0HuۅAEAG XAuM7A@LHLHnAIAAHA JcHfD1>fIL$M/AEHAFHcSvi oD;AM7QAG %@=@=IvLHnIFM7=HELHHp8nL-+L蘞IHP0HSHBIHR0HP0LpM/AE\ M/LHIu bqIE M/LHIu(uIE(AD$tILHHp(aHuLHߞHIGA@AW puIEXM/LHIuhZuIEhM/LHIuxDuIExM/Iu0HtLHoIE0M/AHuLH[IGIu(LHSmIE(AINDHLD$LD$aHELHHp8tIIGH@ IH@IH@AW IGIE(M}@L1Hk[IE@HL$HT$MLH:mIGAW }HD$ LHH0oHL$HHHHH H*XHƃHH H*XZ1!lH@IH( H=6ƹ/1萁Hq( H=:ƹ/1tH5( H13|H54+H=G 1N@f.Ht+HHt @H@1Hf1f.AWAVAUATIUHSHH~1IIM1@I4LL)kHDHL9uHlHH[]A\A]A^A_@HtKUHSHHHt-Cu'Pu @Hs HHHD$={HD$H[]Ð1f.AVHAUATUSHLH IHI׀IMt[]A\A]A^fDX}I$ HHHLZHEHE xHE(ELC0E0C4E4{0xMS0Hs84|HE8{4 MS4Hs@L|HE@CHLLEHCIEICJEJCLELHCPHEPChfEhHCXHEXHs`iHE`ClLLElHspxiHEpLL爅CxExC|E|HHHHHHHHHhHCKL<LEKCjfEjH~HHLLhHLLfHpHLL爅H>hHHHHHHRHH)H9IGHHHHHH)H9IGHHHHHH)H9IGHHHHHH)H9IGHHHHHH)H9IGHHHHHH)H9HPLFHPILHHH@H@1@1HHHHHHHH H H(H(H0H0H8H8@@DDHfp@ f HS6f.1PHQHQPHHWHHfWAUATUSHHHH IHH|HtH[]A\A]DPyH HHHI)VH3LHkeIEHsLHXeIEHs0LHEeIE0Hs(LH2eIE(Hs LHeIE Hs8LHlIE8HsLHdIECLHAEC@AE@HsHhIEHL@1AVAUATUHSHdH%(HD$1HH$IIIxD{<qdHs HCHt'{gt!SLv{cHC CtHCHtH@0Ht LHLHmHAD$t}HcDH@AFH$LAHL<N ;LL$It$nLL$INL;LL$Kt=H$LnLL$EIiH(H[]A\A]A^A_fDNL;H$LALL$Kt=mLL$IKD=JD;fNL;H$LALL$Kt=mLL$ICD=BD;f.Kt=HT$ENLNt;DL$ ]DL$IAHT$LIcDL$ItL<\DL$IEqHT$LIcItL<\IYfENH$LIcDL$ItLH*YH9YXX0I)I*(HH)YOH*YHH)XXH*HdH*YYXX..wH[]A\A]A^A_ÐH9HHCHSL3HkH[]A\A]A^A_fDAD$ @It$LLT$H.>qI9LT$H5 MHLL豔.gHCHKH@LsHkH[]A\A]A^A_ÐH9I)HI*HH)H*YH)YXXH*HH*YYXX..mDH+L$E1ɹw1LLT$L8ELT$I@I|I)I*HH)H*HH*YH)YYXXH*YXX..fD.f.wLT$arHILT$LT$D`HILT$HX HփHH H*XfDHփHH H*XfDHHHH H*X.'FfHуHH H*XfDHуHH H*XfDLAHL H*XcDHHHH H*XHƒHH H*XhHHHH H*X)HփHH H*XLAHL H*XHHHH H*X.HƒHH H*XHуHH H*XLAHL H*Xf.AWAVAUATUSH(dH%(HD$1MLL$D$?I׋V HIILtuL+L$`LH|$hHT$HL$HLL$5HD$hIHD$`HD$LH\$dH3%(H([]A\A]A^A_f.tIHHp HHL9HVL9L9L9H9T$`sHFHT$`HD$hLLH+L$`H+T$`HFMLd$hHLW7HD$hH$L$$fD1fLD$|$tLLLHCLL)LLILHLfH9L$`sHvHL$`Ht$hHcHMLd$hLH+L$`H+T$`HL6HD$hH$2HL$HT$LHHD$`H)D$3HD$hHL$`HL$IHL$#L9$$IfHF wmHILL$!@HcȐHFHLLH+L$`H+T$`HFHHKHP5fDHLKHHKHPH9aHH+pH4HluH5+H=  1TDf.AWAVAUATIUHSHxdH%(HD$h1HF I˩ tT@Mt HEH@I$HEHL$hdH3 %(Hx[]A\A]A^A_f. DLuAF 1I(A HLKHIP tLuM9wMIGtIHRI$AW IM #E 0Nf.U 0 <VH]C(f.D$/H{"INjD$D$LuL]D$AA>IA>uÁ<H}E1ɅLG Lt$ HI^f.LHHHHHI)A0HDIuEHtH@-II)IVH9WlHMLHHR\IAL+uMtM4$HELpM Df.MJIA?@m<„WMtI$)LTfHLcH]D_HELt$ LH sL1@@L+?vHc؋E L{<MtI$HML9ypH}HYM @LLIHL:HL-IHDHtHH;VE AF <uXIPB? M ItAMt IH@I$IFD1LL3HHD$MS7AFH-IL5_H@tAHH@HIHLHHt)ItHHtHcXLpD TM HlfMtI$AE u(t)LclE <HL8HDHUB(f._D$ 0D$!ALt$ @Hh1E1HHT$B@HT$HHD$H+HMEE)fLIHM<8@9uLyHt$AxA0A(I)LFMtIGAG=HLH)HIFIM)IMtM$Ht$LKLH{HELp0@HL{7 ;L_gH AHHLHOMt HH@I$C tM HC LZ6AF DLt$ LLWH!%tDHSHDE HL)L{HVB  L1oLuM?H5LKIAIHD$nLLHDHMHzfDHL6De e e #HLDIHE@(%HLetAƅAW *LLL:AW EHL=DHL ^C4H=$31KDSHV dH%(HD$1%3Dt!Ht4HHvHPH$1HK;HL$dH3 %(u!H[DH 9H$H3DHdH%(HD$1HtWF u%t0HH@HL$dH3 %(u5H@[fDH"k9H$D173AVAUATUSHH dH%(HD$1HXF H HLfH@HD$tMC HD$LHT$LHVHT$HHHIVfDLLHT$LHVHL$dH3 %(H []A\A]A^@HT$"a8I[fZwHH@YHHD$CPLctWZLHT$LHVI9>H5IHLHyfD14fLp MLLHT$IvHUIM.zl1ff.AWIAVAUIATUHSHHHdH%(HD$81F tPHLvL@MLD$(uUHHEE1HL$8dH3 %(LHH[]A\A]A^A_ÐHT$(D6LD$(IMtKLT$0HD$H$MLILHLHD$HD$0LT$bHIoHELT$H]LD$N 8Ld$L<$LLHL!L)HE.DE1!#0UHSHHdH%(HD$1Ht?HcHcHA"H$1EH$HD$dH3%(u#H[]HcA"10E/fDAWAVAUIATUSHH8Lc"dH%(HD$(1HHD$ tvF HnHLvH@HD$HI9C O<&tdLLHfSAEt$LL$HT$ M96ILHHeHD$(dH3%(H8[]A\A]A^A_ft<vwHHUHHD$ qL@ MIPL9IpL9I9@LHL$I4MLcM)LHL $5L $LH$H$LLH[RH9$H$H5IHHuHT$"4HT$I@HHHLc@A{LHL$LLHH$VIAE@I9v MHI MLI@AEfI 6M@I4HLLD$}QLD$H$IH$#-H5 LH1O?Df.AVAAUIATIUHS1H0dH%(HD$(1F u|HEHuHPHT$HL$ LeJHIHHD$ Ls CHcCIEHC HHt$(dH34%(H0[]A\A]A^ovSHHtHx Ht A$9tKE UHT$DH L"2HT$HCDHtHC CIE1YDH+$E1ɹo1HLL@$H+AUATUSHHdH%(HD$1F % =t41C @u$HL$dH3 %(9H[]A\A]DHCfHPH@<uB ItL/_WHu\H]EXHE\LHEpHH;ExHEpLH+UHHE L)HCMeHU IEH)HHXH54 HHEH"HEH0HHEF HLfH@H$H{L9t(H$HPHH9PLKHH$HPE\9EXoHo$C <vLH HytBgHH,QHt@wHHQHtHHHES HCS \H0OH"H/I6HHHsLLH[IHE L)HLLH4I{HH9H$H{HPHOHEp0 )f.AVAUATIUSF Ht* JI$I9$PPtC %=t []A\A]A^HHxLAOL+HHIUHPHH@HHEHHHHHHEHRHPHEHxFHHRHPHH@C %D C HEHE Lm0 E E:E3[HL]A\A]A^SfHމL[]A\A]A^;!AH %@LkLqC HCHAHIVH9PH{LLHHHSH@IuL JC <Ѓ I%E1C HKHtXquFHyt?HHp(Ht3Ft-HHPHFHTHHtRAH87HL<6H Hq(HtHLeHH@(H HaHHp HtLNIC €< S j=C _S 9I;$I;$UIDŽ$DDHHsLHP9HHCHEHRHHPf[HL]A\A]A^Dc `Ld7@H8LALL+HL DJMHL4L Vc H pAHHLI= 1LHL&BHL3LHH HHJHHHJHHHJHHHJ HH HR(HP(I$HH I$HC 6IDŽ$L&AWAVIAUEATIUHSHHF  e<M%H{Ht5HHxt+C tWHuHWH)%H{C fCAHEH,L}LILXCHLzHHjHC(C %DC A$t)A$tE1E1t1HLvMfDAt C@H[]A\A]A^A_fDHHUHPHHhLs{DHL#MC _S tHL1zf. C fDHHL[]A\A]A^A_=H5+H= 19f.AVAUATUSHHdH%(HD$1F @ @ t.c ߸H|$dH3<%( H[]A\A]A^ÐAHHztʼnH AIwCHHsH@H$LHH'HH$HPaHHzgHHHHI@$HHH$IAFE1wHHEHHtHHHHwHII9  Hu8LoLsLLHLL?HHSH@C H; 1҉C HwH)HwHH)hHHHCHHCwc@h[]A\A]A^fDLGMHCPHuHPDHL1H;C Hw&@@HhfDLH--H{&H5eIL1p/AUIATIUHSHHF  MH{ HHUH9PHKHLHn>(HHhC %DC A$t*A$tE1E1t1HLFC @< u Hf`\H[]A\A]MIC _S tHHL[]A\A]*HL+H1DHLH5<HL1.Df.ATIUHSHHdH%(HD$1B tYHHRHHH $HLBC u)e HD$dH3%(u;H[]A\fM H"H`!H $H2fAUATIUHSHHF  uY 1HHwMC tPHH@I$HCH[]A\A]fD tjHKHIHHLN9@1LHHH[]A\A] fDЃ v ^HH'8Nfȁt=uC tHCH[]A\A]11tqw9UHSHH@C@u H[]fHHH[]/5Df.ATAUHSHH(HH H(HHHCC HH[@D c AtEX;E`}#HUPEXHHHH[]A\f.HGEXHT$H4$JHT$HH4$hfAWAVAUATUSHHhdH%(HD$X1F H<$tHP@<L{HML`M90HD$Ll$HHD$HOf  \E\C0HIL9sOM9vJE7AƀAt#WJHHcDp@uDMC-H u\CnHIL9rM9Hv.C.H@.HL$H$HpHbV ffoH+LH<$H 1THD$XdH3%(.Hh[]A\A]A^A_Ð\CrH\CfHkIHHcDP@t@+Hf\C\HH=Q+^@HsD@tE@CHDHHL$HL$tIL@%H51I & AHHLHHfHɖ+Lx H\$H\$H<$HH 1f.ATIUSH!GH xHALHH. HBt HH[]A\f.ATIUHSHH(Ht^H H(HHCC u+Mt&LHLHH]I8 HHL/HH 1HL$dH3 %(vH([]D u` Z)HZ0tHH-1t@HC@b WH(HA HHHP tHCH9FcHH@ D€HH@ fH3H~HVHsHL$H ƒHsHHc6fDHH@ |@T$ T$ *fDHH@( 6KHC@ ȁt=Z1HHS Et_HT$HHH;qƒw H.HHHqHD$HH9HCvfD f.USHH(dH%(HD$1HtPF H @teC  @>HHz 1HL$dH3 %(NH([]D u` Z)HJ-tHH*1t@HC@b WH(HA H HHP tHCH9FXHH@ D€HH@ fH3H~HVHsHL$HƒHsH{HcfDHH@ |@T$ T$ *fDHH@( KHC@ ȁt2Z1HHS EPHD$qƒw$ H+"HH~HHC)fAVAUIATUHSDf HA HHAIHMfL9`H{LH` HLpC %DC At)AtE1E1t1HL(C @< u Hf`\[]A\A]A^fHDc TD%_AC tHL[]A\A]A^ fLHL >DHLUHSHHC@u H[]fHHH[]?Df.ATIUHSH(HtrH H(MHCC uH[]A\HHpHIT$H9PsHH H[]A\H@f.AVAUATIUHSHHHt>v I@ƃ rW v* uMHH@ HHHH[]A\A]A^@HEI$H[]A\A]1A^f h%=u@ !D¹ HހLDD$ HII$DD$ jAF R CIFH@8HIDAHH@(HEIFXpu H@HL (1LAH1HLLH1ҾL#11HL1E1E1HLS!LIFHu H@HzC <VI@H5BLHE1T @HSB H<  H5L1 HEH1[]A\A]A^fHLDD$ ps DD$ P1fDHLDD$ 8C DD$ c eI$IDI$HH@ HEHDDH޺LDD$ HXDD$ C HC@ H@fDAUATIUHSHHF  DnEC uwCHLHEHHEHC{ HEHCDkE EE uI$(HEI$(A$ H[]A\A]E tgHLHHEHRHPC % E Hc H@DfHCHP@HLH5ϼL1 f.AUATIUHSHF H^IՋS ulЉ<S t A$$S HAEL(I$E t HE` C@u}HH[]A\A]щЁ Tj<t A$$HH0HtFFC 1~HLHHLHH[]A\A]fD1LL HEH  HL LC %=tQ1HLC UHLH@fL"qЃwH51L[f.AVAUIATIUSH(HHHE H(HEEE K  XtHC` K ttHsHtF`F2K %_C MHkC tLLHHL\[H]A\A]A^ÃvHHxt1H{tGHuHGH)ǁH{K HH@HH@MHLMC LDDsHCLC DsHLK HLK L K DLhK H&AUMATIUHSHHLLHH$HH[]A\A]fDATIUHSF H ȃw(H5HcHDHHC _S HS L` t)t HHE1[]A\E1t1@[]A\uHuF f%f=oHs+%L$1HH5H5HLH1>fDHHC +C fDHHS DHtL`xf.Hr+Lx [f.UHSHH!C@u H[]fHHH[] Df.UHSHHHxH[]d!@1Y!HK Hh H[]@UHSHHC@u H[]fHHH[]? Df.UHHSHH(Ht@H H(HHHCC WHH[]DHt$HT$H@AUL(ATIUHSHN @t HuH9steH݀}HuFtOA LHL"HHt*H tHL$"t AƄ$K fHuLDHLH[]A\A]HH[]A\A]f.ATIUHSHNLHH@H[]A\UHHSHH(Ht@H H(HHHCC GHH[]DHt$>HT$H@AWAVAUATUHSHHA F IB IHMMHD$Hs\HY"SXH߉S\+HCpHPH;SxHD$HSpHH+KH HS H)H/HxLhHC H)HLgHC HwH)HxLfHnIc6HmIHC L)H1LHIl$Y ID$HC H)HHcT$PLHHH5߭HEH+HL#I4$H_F uW^HHx @AE tkIE@ AC\9CXL#~HHvH[]A\A]A^A_DHHH@Hw1HtHF80@돐LHfDHHHHDLLHIDHHhHpHHHMH<DH¹HH-HS H)HHHH @1ft#HfWf.@(DHkr@HHSpHD$ZH5sH1fATIUHSHnLHHH[]A\ATUHSHHF  ,Ѓw0H 1HcH@HHD$2D$H@(C _S "S t,t#HHH[]A\E1E1t1H[]A\%=uHuF f%f=oHk+%L$1HHH5RHLH1f.HHD$JD$D$HC D$f.HHES DHt L`TfH)k+Lx ?f.UHSHHOC@u H[]fHHH[]Df.UHSHH(Ht;H H(HHHCC HH[]D$eD$Hf.ATUSHHHF H tv IotHH9Pt.LcAD$W1HHLHHC 0 с0 HJ(f. 5_S tHHL$DS L$X H"S H(H[]A\úHHC oHHH9J y_K K HB H[]A\HHgC D@tHs$҃HHҍTRC _S tHH4S HS H@ H[]A\Hz ߩK $HHK Hfȁs1HHC DЃ H(A HHCH5LczL%Qe+AHtfDHAut@HADuHHHPHALL9s"ND9z@0H{HHHH9PADu̍JHAPf(HM.HL$C L$HHH[]A\Hq0HH}HPDHHHHQH9PHHHHSHHHxH9HfPHPH9Cr1ADDʈ1HtuHsHuXHH[H]A\>HHHHHQWH@f.USHHHt2F HuHHH[]{fH[]fATUSHHHF H tv ytHH9PMt.LcAD$1HHLHH<C 0 @1҃HHTRHH@ C _S tHHS S H[]A\úHH~C 3f…HHH9J t3_K %K Hj H[]A\fHHHH(f.C _S u^\ H"S H(H[]A\Hz u_K K HB HHL$S L$@f(Hm.HL$}L$?fߩK @HH=K Hfȁo1HHC fDЃ RH(A HHHLcJHHK Hf.HHs1HHP{tHsHS\ۙHH[H]A\qHUSHHHt2F HuHHH[]8kfH[]fUHSHHD$ID$HHHH[]@f.AUATIUHSHH(dH%(HD$1F t  t t5Hft HH@HEHt$dH34%(HCH([]A\A]éЃ%=u HT$HLHIt HD$HEL;ktMC C<#HD$H HPH9Q=H{HLHHD$HBHSC +DC A$A$E1E1t1HL D@ 1HLIt$HHTN ffoH^+H H5ݣL11HLL$C L$QL$C L$)HL01HLC HLHD$LHD$HT$t HHLH!^+Hx 9 It$F f%f=ot4H]+%H,1HLH50HHL1LHtHhH5ޢL1lH]+Hx ff.AWAVAUATUHSHH(dH%(HD$1H(H9F AIuBHD$t p tDHT$HރHC   H8 Ht AL MiMHsIAHIE1E1KD7LH)H xI;IK I9vHyIL9uLLIT$HH)HqIAIEI9vDHH9HHyH?πN@~f.HH MH HAIH9Qr{H|$dH3<%(.H([]A\A]A^A_L9s)>LfM9tID$xIM9uK MIAtII9QsHHHH@nfMt M;qIC C IABDHT$DC MtHLHPH9Ps HH=HD$AHHxtDC H{tWHuHWH)%H{C LD$H $HLD$H $M)LCLpHHHC L <0Iy%gHHHt5HcH~-L9v(HsL)J>t@:HHHuH)PwHHHtHHHFC L 1HHkfD1fMLAI)@HHt$H $MIIH $Ht$M9ruDAIM9`IAT$yЃ?IʀAVAFfDP3LHH:C L HIE1ALH9MH $O4>J@UHSHHFt17HH1ɺc H[]AWAVIAUEATIUHSHHdH%(HD$1F % =pHDIA@t E At E H<$HEJT7H9P]I9lHEHLHHELpHEHUH@E %DE A$tA$At E@HD$dH3%(?H[]A\A]A^A_@H$HMN<3JTpH9QHUHL9r?HL9t)HSyу?HʀPHL9uHUHMH)HAHLIHL~H@H$@E1E1t1HL0LHI9H<$H]H@INL1HHEHxH<$YfDHLmH$Df.AUAATIUHSHH(dH%(HD$1HtKB HHRH@HD$Ht,E t AC A@uBHL$HL*AtE@uKHD$dH3%(H([]A\A]@I$P@<EA@A@@HLHT$ HHMHLHT$@C HT$A@AD@AUAATIUHHSHHHHH[]LEHA\A]4@AWAVAUATUHSH(dH%(HD$1HF IH% =HT$L;Lt$HD$HYITI9WIH9l$H{IT$LHHL`C %DC At)AtE1E1t1HLgHD$dH3%(uWH([]A\A]A^A_ÐL>HFMwHD$Lt$EfDHLH9l$Lt$IHkHA@UHSHHC@u H[]fHHH[]Df.AWAVIAUIATIULSHH8dH%(HD$(1F LD$ L$pHT$ AF H|$ O<,%DI9AF v)IIWH9PL1H)I~IILxt |IM)IIHHITH9P.IFHJ48NH9AsfDHIH9AuHt$J< HLD$ILD$L@AF@HD$(dH3%(H8[]A\A]A^A_DHHzH|$ M~ILHHMO,I9LL)L)H9HOH~HLLHL$AHL$IA$IM)L`AF@GLH7LHLD$8ILD$HJE1E1t1LHhgHLH|$ !LI~Ht$LAF@e@HuAHt)I)LHLMBHt$HLR#LLHI)LLMH)H#LHHHHt$LHHL$LT$IHL$LT$H5'LH1j%DATIUHSH HL1HH@HEHC[]A\ATIUHSHHL1ɺHH@HEHC[]A\UHHSHH(HtxH H(HHCC HEX;E`|HEXHUPEXHHK HH[]fDHt$fHT$Hff.ATIUHSF H uW}1ɺHLC tC Ht5HH@HEHC[]A\Ð tBHLgHf1HHL[]A\l@ tȁt-Cft HC[]A\f11f.qwqAWAVAUIATUSHH dH%(H$ 1F H|$L$, t҃AE <W|$,€AU %_DAE IEHH@5Ht$HHH9PHD$HB <(HrF Hl$,Hy Dq IEBT5H9PIELcH|$DN< HL1ɅIIET HcHcHPAIEL;`1AM "HD$HB tuHHxukH5HD$8D$(Ht$ Ht$ ,t$(u"fH AH|$HtcH軽HD$HF  HH@HD$8HvHt$ HHD$(RHYAE  Lt$11LLNHT$,1LLAE ^H|$LAAE H|$HۼHT$@ƿ xHD$8HD$ D$(1E1HL$ cH$Ht$HL$8fHWL|$I@8AGtM9tHvAuD+|$EXIcϋT$,HT$H|$ALiAtcHL$8Ht/IEHxH9w"H)I}Ht$ HHL$HL$t*AD$,EH|$Hx"D$(tAtfH tHIUHcD$,H9BIEH$ dH34%(lH []A\A]A^A_fHT$H|$L^fHT$H|$ H9A~$HD1E1AHJA  @T$,%_DAE TH蕺`,% = H|$HT$8yHD$ HD$8D$X%=tH|$HH]HcT$,HL$pH4H9FH)IEHT H9P0H|$LH=%H|$H˼AIEAWHHD$,)9=H|$8tAP~9}D`A)C4H|$莵HHD$l$,HHpF 5H|$ظA@H|$LEPHcH9lH|$LD$,D$VH|$HT$8"HD$ HD$8#Lt$L<IF Lt$1Lcd$,LLHHL1HHL&11HLGIEHLLL`LtIEL;`1} E1/HH|$H5E1'HHUHSHF < uQH(Ht]H H(HHCC HHH[]DHT$>HT$HHT$裰HT$Hf1DH911띐ATIUSHHdH%(HD$1HIHcV|D  H(HgHE H(HEHEE LHCHCHEHcSHEHPHEH@U D E HcKHD t D)U HL$dH3 %(H[]A\fHvgHcSD tƁH H$HsHLHH $HAHLM HsfH(HtQH H(H@@ 3fHvGf諮H蛮4@AWAVAUATUSH(HH|$HT$B =< IALd$HLTDЍJ A~ HH@ EtHEHL9-H]HtC uHC_S %@C tH|$HH|$H=DH([]A\A]A^A_fHjHtHH@LdL9]fHH@BtBuH|$HDIFH9XIH@(HtV@tPHH@HRHTHHt8R-H0Ht%t HpH f.H|$H5-d1ɺIH|$HdA LFH|$ LOMtAUtjAUHfJ\HfJ\HHt@HB8 @HH@(H|$HS 0H|$LHD$膮HD$E7HT$eDHH|$CIH|$LHD$FHD$9@x\{RHH@8E@]H51DH|$H541f.AWAVAUATUHh SHXHt$dH%(HD$H1H5" HH质H9+Hދ8c!E1乍HLLt$HHHl$0H\$8Lt$(HD$@H H H Hǃ(ǃ0ǃ4ǃHH ǃLwHǃ`ǃdwHXHǃHHHHHHHHHHHHHHHHHHHHH H H(H(HHHHHHH0H0@@DDHHLHǃHǃHXHXH`H`HhHhxx||HHǃHǃHfHǃHǃXX\\]]``ddhhll^^ppxxHH||HHH H xxHHHHHH66H H  H H T T H H H H H H H H H H H H HH Hǃ ƃ ƃ Hǃ HH Hǃ P P  LHD$t*EXCXE`C`E\C\E8C8EHMte []A\A]A^ÐLLH}IoDHfDHIfDH HCpHF SHH~HHHxw|H@~tHHL(H<1HHH7Hu @HHt8H9PuL9tH;+tHpHt*~t,H謐HH[0HH9u1[@HHv[{1DATUHSF Hȃ r vVuH[]A\fuKHSB „HsF u.Hft(H踴HsF HCHt H@HdHH5VHHP 1ڨf.HH˪Ht P vBC ItHyHHHI裳H5ULH1oH@HtH@HH5q+HwwH18ATHIUHSHtɽLHHH[]A\H(C@tHHff.AWIAVAAUMATIUSHH8dH%(HD$(1DL$yMHA L/HHpHH 11H#H01DHHHH`|$ptA|$pN|$pHpHL$(dH3 %(H8[]A\A]A^A_D1HIHEE1A LH$IEIUHHD$H$ԥH THH1H]MOAD$/PHAT$TLHHl$DHD$:f.Ld$ E1LHHDt$ LD$!ͬHE@<@$AMHHD$ ^D$! HEHcL$H2RHH$1耔HL S$A11HHHl$訋HD$^fD1HNH1>fDLHH%HAWAVAUATUHSHHHIHAAt"HH(H9H;+t|M %=iH_HcHffAf  A f3Hu(F f%fQI9l$AfD1HH[]A\A]A^A_E" tI$@ t H9XGfE"tLm(MtL1@"tHu]HH@Ht)P fftrftfuH@HufDHt#AHHHL[]A\A]A^A_~fDHLLeH&MmMufDHP(HJ tXKDHRB =0f.HU(ID$H4HEt HFH9HHx(DEHMtID$H9p$E1E1$1L謙QHu(F f%f'HV(ID$H4HHHx(Et HFH9$E1E11ɺ$L8E"AE"@E#mHUID$HH9LH+2HHƹL貶Htf.AHu(I9l$DLu(Lm0AF f%Pff=@t fIV(B f%fHB(IT$HHHD$ @HD$ H@LP(MMt"AE D$/f%f_ffHLfL?~|ErAF INf%ff %Ht$ $E1E1L芗/DHE(Hf@ HPHAHp0fH5MAL豢HH@H5MH9HHL[]A\A]A^A_4@HU(B f%fqHzB f%fUHR(ID$H45HU(ID$L,M*Et;IEHp(HF U#1L$HH9DM#E1$1ɺ$LL!@E"@Lm(AE Af%fIELh@Et@HUID$H4HmFcU#1L}HLH9CDM#HM$fDHHIT$HAOHRHUID$E1EH4BHLyE1ACAHML҉4$L%IFIT$HD$ LH5IKINA$Ht$ E1@L袔GI$hHFHH1LKH@HrM](M2AC <J|$/>MEAB E f%f= |$/IE(xH@ 7HLL\$8LT$0{LT$0L\$81LLL\$0}HLH9L\$0>E f%f=|$/IE(!H;@ "HƺLR{AAIN$Mm(M3AE D$/f%HV(ID$L4MEIFHp HLzE1HIEuE1H]V@@+HIINHt$ E1$%LoHp(*AHu0H9@ HƺL1zAIEH4‹F <HH@@ H5xBLLT$0LH9IU(ILT$0HUL޹LLT$8L\$0JL\$0LT$8iH@LP bHDH 6H@ HLL\$8LT$0UyL\$8LT$0@HLH AIUID$HIELIUID$HE1E11D$HD$L$LLL\$0HlH9XL\$0XHHP INHt$ E1$Mغ%L$HP IUID$HIUID$HL0IUID$H@AUIATIUHHSHH袅HD$$MHLHE1H苰H[]A\A]USHHHT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH+8脛H$Ht$ HH$D$0HT$Ht$HHݳHD$dH3%(u H[]ޅ@f.HHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$!HD$dH3%(uH$@AUIATIHUHSHHƒE1HD$$MHHHL諮C@uH[]A\A]f.HHL[]A\A]+f.USHHHT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH+8tH$Ht$ HH$D$0HT$Ht$HH]HD$dH3%(u H[]΃@f.HHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$衝HD$dH3%(uH@USHHF < tp Hu6t HCP t5H5WH1tyHCH[]f蛠C fDtH5qXH17yHCHH[]fDAVAUATUHSHHDN D% t A 0AtgHCDH AHARDʁu HHH5FV[]A\A]A^1xD%=AA.H(H9Aq HEH@HHPL`(MP8LHщ 1ƒ)/@%HPHp(HP8Hщ1 )LhHPHp(H P8Hщ 1ƒ)赂HH@I|HPHp(HLP8Hщ1 )lLhHPHp(H$ P8Hщ1 )ƒ2HHPH@Hr(A|$H^R8Hщ1 )ƒHPLhHr(HR8щ1 )H讁HH@IDH8HPHr(HR8Hщ1 )ƒbHPLhHr(HR8Hщ1 )(HHPH@Hr(AL$)HR8Hщ1 )ƒހHPLhHr(HrR8щ1 )H褀HPHr(HH@IDL(HoR8Hщ1 )_LpHPHp(H$P8Hщ1 )ƒ%HHPH@Hr(AD$HR8Hщ1 )LpHPHp(HP8щ1 )HHH@IDHHc@AT  |f.EoAH 8tHHx HHGHHH[]A\A]A^LQH5V1sDDD$ L$T$DK DD$ L$T$pHC@ HE@"unH5*HH[]A\A]A^HP1*sf.H޺HqHXDK 4H޹ H蛐HHDK ADK AItHE@#HL[]A\A]A^fDHEI@#<tH޹ H)H@HH IE1HA 1H舫ID$HXCLEL$ ^fDHR8Hщ1 )ƒM}HPLhHr(HR8щ1 )H}HH@I|h1LHcIċK уvQHHxt1H{tGHuHGH)ǁH{K bHH@HH@C Lc@S EL$ LFDH舫LH1HHI貗c 0fD)Hct HHL(HH{C VHH]H[DK HU1HL,uIHPHp(H~P8HЉ% 1ʃ)ʉt{HE1LLHvkHR8Hщ1 )-{LpHPHp(HP8щ1 )HzHH@IDPfH8R8Hщ1 )ƒzHPLhHr(HBR8щ1 )H{zHPHr(HH@Ml1"L,%1H%IH%HRA|$tmI1k1H%IH%HRA|$tpI1HH%IH %HIA|$t3I11%H%I1H%|H%I11H%I1H%yH%1h11f1H%Y1{H%H%11gHUHSHHF Ѓ tq tTt|%C CHHHƺHD$wHD$HXH H[]@@uyC HzHyt/u D t3HHHHxHz8u9HZ@H`H(XuHB/뮐HfDAWAVAUIATIUSHH8dH%(HD$(1@tbHB <t4u<HD$(dH3%(H8[]A\A]A^A_DHrF tZf.AD$ Ѓ  .t1LHwsAD$ H8 Ht I$Mt$H@HD$@M~HD$HpHHPIHT$O  HT$ H"HzHIW LL$ AD$ 1Щ  "H8 HT$ LH貤H8 HHHME gHELEH@HD$ HHLD$LD$IE1HT$ HHD$HJH9I)HLI~H)LL$HD$}LL$ucIELH AD$ % =t11LHgI$HT$HPI$IT$H@AD$ @AT$ ~HU҉UHHMH|$AD$ t3u. HT$1LHfIAD$ MtHD$HH.1LH辙AD$ @LHfDI$DpEL(1D$@1ɉLHIHtHL9tL$LH-A9}hHrF JHHx LHP@<MHL$HLHiI9s)Axf.HL9t Ey .IMHA Ht/A~ u(HPI) HA| uIEHT$H@ Hu1E1I$Mt$HRHT$YfHH5aHt$ LGqHLIHHD$LAI$HT$HPAD$ %_AD$ #@H߉L$`HL$5D1E1fDHHLD$`IHLD$P AA8IEH@ HL$HT$ LHLL$D$oy|$ILL$I1 HLLHEI$L)HhAd$ AM ZLHQrHT$ "HHtIHT$ LHLL$1踇LL$IInH{f.AVAUATUSHGHH/@"@LeLHuJ F ʁ HHuLuF Lh HMH@ 1ItHILH9AD$@u9LeL3HC[]A\A]HA^f.HPHGL$HU^LH&HuHuF Hf1HLu^HuIF @1Hw^M=HH5A1[]A\A]A^cDUSHHHGH/H"tt't赕ftHCH+HH[]DHC H)H~#H(HHEHCH+HH[]HHHaHAWAVAUATUSHHHGHWH/HH@#H4ʄL.HC H)HHCP"u_@#t0HӔHCH+HH[]A\A]A^A_LmHCHH+HH[]A\A]A^A_HHH`HQD3K)fDH_HCP".AEIELpAHC McH)HL9RAE E1EuHE9HD1ALHDHHTuH(HC@"/<H5@H1|fMI*XR#f.Z#IuIH}LhzLHCO@IfHXAEIu>IEHPHcLHeHLeP"LH%{PHHDH^HLHzDpc@LLHH H*X H耆E1H5*H=G1ȀAUATUSHHHGH/HPHGL,HG H)H~sLmHKLeA#xA"u?A#<t.<<H螑HKL#HH[]A\A]HH]HuyHQHCHH44HK\H\tDu@HC@"t_<ufHCL#HqL#HH[]A\A][~HKA"<8LH5tHE HH5=H1 zf.USHHHGH/P"HuxTP E1ffA@#1H߉`HSz#x,HEHCH+HH[] AtR"HHHD$^HD$AVIAUAATMUHSHGH@#tTF <t„|H /"tHEHx HmHGH5@MHH1O]HCu @@"t%H@ f%f=tH5*LH1])H腒At,HC@"Pv<HI$H(H1[]A\A]A^f@"DxHH[]A\A]A^-zD uߺ HHzHuDHUB DHHUADkfDHVB „H5*LH1[HCD[]I,$1A\A]A^USHHdH%(HD$1HH$H(E tjHEP 71 HKA" H$HH$HHCHHt$dH34%(KH[]|HHIHxHHtHEHHt1HH=H@H[Q#`SHH@ ufDHE H5K8H1_Zf.HHXH@P @HA(f@ tHt0HHH$HH0ٕOcH*H5@H1wuAUATUSHHHGH/@" LeuR@#uI$AHHkE@t HHnI,$HCL#HH[]A\A]Ð1H膂@AWAVAUATUHSHHGpHWL/HHHOpLc8HGHOHp@ JL$f%f)AI9Ev fDHHDLHI9wAD$@HEJuFHE H)HHH޹HvGHLcHEHH]HH[]A\A]A^A_ÐLHm1L薁bAWAVAUATUSHHHGH/x#u:HG H)H~mH(HHEHCH+HH[]A\A]A^A_DLeMAD$  ЃH t*Hc4HDHHFH{^I|$HtWI$HztLtWHuHWH)%I|$AD$ pI$ID$H@AD$ _AT$ @tLHelDL(LmHCH+HH[]A\A]A^A_@LHOHtTI$@\JHP8HHBH@8HHDHHp xIHHmHH[' H1QI$LHLh8BLHLL( rN1LHCtL(.LHL(qfH(HEHGH/HfDAfLMAD$ fL(M9LLHlAD$@LHjxH5# H^HLH}]AT$ ID$E1PuMHxtFI$HR(Ht9Bt3H HRHIHLHHtqtH HALh MtXAEHIEHPIEHTHH+R@HH LHk@LH^P|cHHQp1IID$H_JIHPID$R$P@ID$L`8I$HHMtE1LL1HqI$HB xIux Suyx Ausx umHr(HtdEuCFHHPHFHTHHR~qHHHL(rE1EjHr(HL(OYH@HUHJL}H@AUATUSHHHGHWH/HH@ L$HUf%3fB Aȃ !ƁLHiHuF %=tbEH UHuF@Et$AD$ <t 1LH{LeHCHH[]A\A]@HEHP HH9HhHuF@HRgrDH|HUI@ H]ID$@ 9HHH9HHP HE` @f.AWAVAUATUSHHHGH/@"@LmMLeAV AD$  AD$ AV u AD$ E1AF I$H(I@(~PLHLu?=AE@ELmucHCL3HH[]A\A]A^A_f1LHs;AD$ fDtOf.HPHGLuL,AD$ utu1LH;wf(HNdLeLuAD$ @ET$ D%=I$H@ t H"IHr HVAHH}H*Ψf(uHtYtHYuLHLu;AE@LmAD$ ~f1LH3YAF f()1LHL$YL$fDLHdHHHVHE1A @@I)IMHDAuHH@HEHtHtHHuELeHHLH6wAE@LmL#HCHH[]A\A]A^A_fDDAf.1LH8AV f.HH* fWDE1DLHb@HH95AF@MuIL+HCHH[]A\A]A^@1LHs3AL$ fDPo1LHyRE f(g1HHL$XRL$f. WQHHH5[]A\A]A^1a8HPHGImL4$H\&MeImAL$ |@AL$ %ʁI$Hr AH\=HEHx t HAH H9IH9@1HHHH9+E8ImHH9HLHH pAF@MuHCH+H;@HFHE1A@LH[1HH1E HE11DHxRH* fLHfW2AF@mLH[]HLHLAF@DHƒHH H*Xf.AWAVAUATUSHH(HGH/@"@LuMLmAT$ AE  $AE %=IEHH t HoAT$ fWE1E1E1f(EwnI$H@ DE1H1HHt H)E8HEEHH9@HLH nAF@LH$Z1LH/AE  FIEP(fWf.Av fWf.E1A1AT$ 1LH\$DD$H $T$/AT$ \$DD$T$H $DHPHGLeL4 I$`(f.Av fWEukf.qyDD$\$H $XT$eDD$f(H $T$\$EH`H*f.f(f(\$$D\$$f.D„t E8t\f(EuLLH{/AF@LuHH+HCHH([]A\A]A^A_HH* fW@&HVuLmLeAE ,H(HH5[]A\A]A^A_12$\$Xc$$f(\$fWHE1E1Af(@HHAf1LH\$DD$H $T$K\$f(T$DD$H $f(H\$E1$TAH$\$D1LH{Kf(fLHGEf(HH $0TH $HЃHH H*XLfDHȃHH H*XfDAWAVAUATUSHH(HWL'dH%(HD$1B"@Il$<I4$IT$F z I lj Ml$:yIH@ E1HLIHCP"IUH9tHH%WE  HUHRHT$E1 tHPR<AAItqM1HHL$ILHH9bHFHuHH9FHuIL$H<*HEL`L`HEHUH@E EH%DE HCMe@#@tHCpHSHHHKpHcL$E@nMl$Il$L+HCH|$dH3<%(HH([]A\A]A^A_HrHOH,HkU HSB#@M4$Ml$AF  LHVAF  I@(fWE1f.HCL,P"HTHC@#@HCpLCMHPHSpHcI,I)IDALcMuI*XPf.X~ EMHC H)HL9II9v5LHHta HH9rHHLHHIHuBMcIL$OlJH:HXH@HDHEL#HC[]HA\fB %=uHHH@ H9A fD09EuHuHUF gDATUSH/HHuHUF J  uv%Le=t>HF9HXH@HDHEL#HC[]HA\fB %=uHHH@ H9A fD0yDuHuHUF gDATUSH/HHuHUF J  uv%Le=t>H8HXH@HDHEL#HC[]HA\f.B %=uHHH@ H9A fD0CuHuHUF gDATUSH/HHuHUF J  uv%Le=t>H7HXH@HDHUL#HC[]HA\B %=uHHH@ H9A fD0BuHuHUF gDATUSH/HHuHUF J  uv%Le=t>H7HXH@HDHEL#HC[]HA\f.B %=uHHH@ H9A fD09BuHuHUF gDAUATUSHHH/HuHUB F  t4AuEHUHuHLe46t?HSHHJHSL,HcLVAE@u*LmL#HCHH[]A\A]ÐH(HELHuBAVAUATUSHGHH/@ %UHe AAd$ fD.H<IoM'HCM ?1LHHL$vHL$Y@1HHAD$ HY1LHHL$HL$E1HH#HLH]=AWAVAUATUSHH(HGL?@"@>MwLM'DX U AD$ A Щ t9A^H@D\$@t60;IoM'D\$U IG0HD$E El$ %0=HCD$A0@#wHEHH AD$ I$H@ HLHH H1A^HE PAF@I9Mwt|$te AnHD$HHCHH([]A\A]A^A_HHHWIoL4AD$ 0 MHLDH2AF@zMw@tktsHEHH AD$ I$H@ HLHH H1A^HE,AF@LH?;f.HMA u1@"@ufHMA 1@"@pfD1HHD\$D\$H\f1HHD\$D\$HAd$ f1LHD\$HL$)D\$HL$f.1LHD\$HL$yD\$HL$f.LH%:vAVAUATUSHHL/dH%(HD$1HGImHPHGL$ЋE  AAA0A0F@=HELuH@H$AHa*D-2+)E tOHPB<uButuc1HHE uN5HE@(u#E tu1HHE Dts(HEHP HH9=HLHoLAD$@uhMeL+HCHL$dH3 %(HH[]A\A]A^HE @(fWLHwAD$@tLH$8f;yImE A&fDHHE  HH_ E HUHHR H9HLH(AD$@%@1HH#, fWfHLH8AD$ % =uwI$H@H$ID$A>-T+fH LH߹YBHLH*uHuLmF @fD1HI/fDLH*U1H#AVAUATUSHGHH/@"@LeLHuz F lj LmHLp HuN tktsHH@ L)LHH->AD$@LeL+HC[]A\A]HA^f.HPHGL$HU^HF@ uHS1B"@uuh H(uHuLmF 0fD1HfIfDLH)G1H6AUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HNHUL#HCHH[]A\A] 'uHuF u1HLeHuIF u1HkfAUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HMHUL#HCHH[]A\A] !'uHuF u1HLeHuIF u1HfAUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HLHUL#HCHH[]A\A] Q&uHuF u1HLeHuIF u1HfAUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HOHUL#HCHH[]A\A] %uHuF u1HLeHuIF u1HfAUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HEHUL#HCHH[]A\A] $uHuF u1HLeBHuIF u1H+fAUATUSHHH/HUHuJ F ʁ uVtqHHuLeF Lh twHH@ HXH@I9HDHUL#HCHH[]A\A] #uHuF u1HLerHuIF u1H[fAVAUATUSHGHH/HPHGHuL$HUF J ʁ uxHHuLmF Lp HH@ I9ƺ}5LH7AD$@~LeL+HC[]A\A]HA^Hc1Ҿ4"uHuF q1HLmrHuIF k1HWcfLH#rATUSHGHH/HPHGHuL$ЋF  u8tSHH@ HLHH7AD$@uCLeH+HC[]HA\1Ҿ&uHuF u@1H@LH"AUATUSHHHGH/HPHGHuL$HUF J ʁ uVtqHHuLmF H(twH@( LHAD$@u{LeL+HCHH[]A\A]f1Ҿ7T!uHuF u@1HLmHuf(F u1HL$L$vfLH!uAWAVAUATUSHHHGHWL'h HHL,ʁi+jkL=**L5<I$H  IH@(MtjfWf.ALHwAE@,HC L)HMl$IL#HCHH[]A\A]A^A_fI$L=*L5N;H  O1Hp$uI$IH :1HHs(fDfL=h*E18f.HD$"D$HHLH5[]A\A]A^A_@LLH}IDLHL=*E1:N@L=*E196@AUATUSHHHGHWH/@#HHL$t+HuHHtF H@(f.˼z uǼ H D$Hw@H(,fWD$u H H@YLHWAD$@uGHC H)HHHH_HLeHCHH+HH[]A\A]LHH HD$Lh(_,Le#ƃ D$)VAUATUSHHHGHWH/@#HHL$HuHHF HLh H LHp("Mƃ t]LLHgAD$@ufHC H)HHHH?HHELeHHCHH[]A\A]H  LH!)AD$@tLH~@IBfDH+A,AUATUSHHL'HGI,$HPHGM L, HEHP @@un=HE@(f.,> f.)LHAE@u?DM,$L#HCHH[]A\A]LH=0AE@tLH[fuI,$M D1HHM H€ HE@ @@1LHW AE@*H8[]A\A]A^L1A_?PLLHtXH@HtgH@HHHt@HlbHLHt$H XHLHD$D$HLL/LHLpfAWAVAUATAUSHHHGHH"LjL2t"AtAtHT$eHT$ALHHT$譱H(ILHHEIUHHT$H9~1AIHCL+HH[]A\A]A^A_HC L)H~CHM}?HIEHH]At_HCL;HH[]A\A]A^A_fDLLHűIH(HHCHHH[]A\A]A^A_D1ɉLHM}HtHIE}@H(AVAUATUSHGHL'@"Il$M,$<<<tJLAHGAHEAt;HCH+H[]A\A]A^f.ALHAHuLH觵HS HLcHcH)HH9:HCP ffqfE1My#qf.HIHEM9O1DLHHHHuH(f.A;DL8HHCLHHPHCH,ִPHHHc5E@uI,$LHCH+[]A\A]HA^DHH5ME1@HHLHEHHIM9}g@HHHRHf.AVAUATAUSHHHhL(HGP"tAtAtAH+1LH-H+HK IH)H~bMt5LHAHUHEt\HCHH[]A\A]A^fAHuH(HHEHCH+H@HHHeHHLLHH HQHAfATUSL'HI,$E uHtHEP ʍqvAHCHH53[]P Hv9*A\H1铯HE uHSz"x.I$HSHR ffqfvOx tY[]A\ uH R HH8*H5\[I ]A\HH 1x t[]A\A[]A\[]A\wAWAVIAUATUSHxHOL?dH%(HD$h1Q#A"u<U<u<ZIND$ Q#(E1@IFI_HHD$0IFpHPIVpHcI/HHD$(E l u7y"HD$(H+D$0HEIVHHIFIHH5.L1ϭHt$hdH34%( Hx[]A\A]A^A_@I_I7C L uy"F HP DHL'I(HI_HDE`I_IGSD$ ADD$ D$ H5L1f.|$ IVHHH9HXVIWHPHD$(LhL9DI(Dd$8@L|$@MAIfDD$HD$E1D$$IE11HLHIDIIGL9sDd$8L|$@f.<<r<#IVD$0R#@nIFHHD$@IFpHPIVpHcI/HHD$8IGHD$ E mD$(E1  IFx"HD$8H+D$@H|$0|$0qHD$ IIFH~DDHD$@HD$E1ɉ$E11HLHD$(LhL9I(L|$8MI2f.HP DHL茺HIDIIGL9r(I7F uϺL2D$0L|$8yfDI_E1I/C HD$` 5 eIFx"7E \HEh A2EHL]HHHD$`EHL$`HALEHt$`EH|$0IGHD$ HD$`IG1fL@D$0tI(HPlD$0LPHLHE AũPHLHH@HfH@HHHH?VHLHHKHLHE D$(PHLHC Aĩ PHLHH@HH@HL(MHULLHH1KLLHC HD$8HXH;\$ YI(L|$XHD$HHD$`HD$PrE1E11$LHLSHH@HD$`EHL$PALHLEHD$`HHH9\$ |$(L#AHD$`uvED$HD$\E1E11$@LHLHHD$``@WLHLHD$HHgDE1E11D$HD$L$HLBHAPHt$`LHHt$`LL|$XIVHHHD$ EHLH3C HD$` 1EHLHE D$(HIVHHH9D$ HXH\$ IWHPdIGHD$ VHD$8HXH9\$ I(Ld$`L|$XHD$HLd$PlfDDHLHHHD$`EHL$PADHLEHD$`HHH9\$ H3F tHD` |$(HD$`AuOEk1DHL蛴HHD$`q@h@DHLHD$HH|DHLA랺LAsHt$`LHHt$`L2HމL螝Ht$`1ɉHLHHD$`;@2E1E11D$HD$H$HLHAED$HD$E1E11$HHLbHtZH@HD$`EtLHL$`HAHLEHt$`LHt$`HLH\$`HHHLEHt$`~E1E11$@HHLHHD$`l@cI(HPI(HD$`2HLAHLL$ ML$ HL"LHEHLLHlD$(AyfUSHHHH/dH%(HD$81HG@#@uzHuH}N Ht$(  uCx"H@HEHCHH+HHT$8dH3%(/HH[]DH5&H1ǡDHuHL$0HT$(E1 HHXHEHCH+Hf.G HP HOHXJ@E1E11HD$HD$$HHu HD$0Htx tHEHCL#HH[]A\A]DHHHmHHؖHAW AVAUATUSHH(HGpHWL/HHHOpLc8J,L|$I9If.1HLeBIHEI9vNHHULH>E1E11D$L|$L$LHI9wEDH)y H1D$L|$E1$E11LLH踿HCHL$H,HC H)H~>HCLeLx"xMHžHEHCL#HH([]A\A]A^A_HHHHHXHAWAVIAUATUSH8HGpLgL?HPHWpHcIHsLkF < 2P HŁ,IGLkL9HD$HU1D$BD$HBHHH9L$L$)ȉD$(HD$L)HD$ H|$ HL$ +D$ɉD$,L)H|$,d DL$EKHcT$HH*XXf.XD$/ L<L謨D$If.X HcT$HELH4L药HPHLHIIVM)MIR"A t!A tLHD$LD$AAH5sD$$HHL1nH8[]A\A]A^A_HsF H@ D$Dl$E LkL9l$HsLk F QHH@ D$HUHct$HB@A TDE @uyHL诱HD$ MIDHD$I7LIIGL;|$uL)H|$,HcD$ HH*XVf.V. L$D$L襦D$If.|V LLH萭IFHcH\IF@"<NIF Lcl$H)HL9M I*XUf.VJHcT$HHHD$HEH4HE@t@D$AFXA;F`D$t&ILdfDIuLI@M9uHD$H\HEHc|$,HxD$(9D$Dd$EZLHUIHEILEHx|$,I(HcHHHD2HH)HHHH9uDT$ ExHcD$ HH*XTf.T`HcL$HULHHH*XTLD$f. TH讼HuHELD$LHuL@HEL@fDL$ tBHcT$ HdH*XSf.S*HcL$HEHLH<讪IFHcH\IF@"<T$Lcl$MI*X%Sf.-SILHL=E@D$AFXA;F`=D$I߃HDHD$DI7LIyL;|$uhDD$Dl$AIcI4L<H3E@LO|<*F%AIEI7HtFuLjHEHHJH;Pt$(HPBHEHPHEHJHHH)HʋL$(HH)Hw@HHJHH9HHufDHUHct$BD$HB[@I(HLNE ueIFIHH8[]A\A]A^A_@E1J\+HHHH H*XHHHH H*X\@HL襳D$Hz D$(1HL|LaDLD$fHqo1 LHUHBDHEL$H@DD$D\$(EtC*D$(X0PHcD$HcT$HHEf.'PH4HcT$(H<HøHEHPHEHTDT$T$HEHcHtH3E@FLoD$HcT$D`HEEL,FtyA IIuHtFuL蠇fDT$,HLLD$HELD$LHP#LuLHLUzLSt$HULIHcƅHDJ VHHH)HvfDHHPHH9HQuHUYHU|$HJ)D1HHcD$H?H51*H8L[]A\A]A^A_1I܋L$M+fHt$HLLIFIMcJ LLHH H*XLLHH H*XHHHH H*XHHHH H*Xt$Lt$LHHHH H*X_E1 H5*H=9r1AWAVAUATUSHHHGpHWL/HHHOpLc8HGJ,HPHGHuL4ЋF < P IāHI9fr\1H0HUHtHƹHHD$2HD$I$HLHHHRI9sV1fIpPLH蟺HWH@HHEHCpHH;CxHCpH+kHH(L+zH5JHߺ膋H^HCHSJ,B"<toAD$u?I$HPHLH(AF@u9LuHSHEHHH[]A\A]A^A_LHHcH@LH HHHHCp0LH}HHDLH轭AUATUSHHHWHz"L HhA|$ tLHSIB LHf%f=t`諨IHS H)H~3AD$@t LHHLmHCHH+HH[]A\A]HHHuHۋIfDHhHHILa(efAWAVAUATUSHHHGpHWL7HHHOpLc8HGJ,HPHGHuL,ЋF <  P IāHELLHH)HD$H1HD$I9vGI)I IIFE1HD$JtH蓟DHLHI辔L;t$uHCHSJ,B"<AD$I$HPHLH蒿AE@LmHSHEHHH[]A\A]A^A_fDIPLHHH@HHEHCpHH;CxHCpH+kHH(L3H5GHߺHމ fLH9LH襠HcH fHHHCppLH=HH袬4f.AWIAVAUATUSH8HWH/dH%(HD$(1HGpHHHOpHcHOHA"l<tkA#HH9v'HDHHHHH9HKHPrIOH|$(dH3<%(I/HH8[]A\A]A^A_IGHQL$HH)Ad$ HH9HULL^AD$ <„c I$Il$HRHT$ HO IP@<Il$LlL9rEHL9+}y1LHL=}H EH*HHBH9v$fM0HHH9@uHrHIopLmAE !IEHIUHRHH9HH2HHH9HpHJrIOH8fID$HDH9sUHHH9ňMPrAD$ %DAD$ @HkLc@CIO@HT$ LLHT$ HAD$ LfI@IHLLXAD$ fDLAEHD$D$LLE1荅GfDLLRLL=EDAA9|$uDLLFHLLHD$,HT$Ht$L0LrHt$LL貰HT$LL袰諶u1DLL7IƉLL­H0LLd?LLCLȭHr)L裶ufAD$ DIT$B a@HT$ Il$HfD1ɉLL聐IDDHLL辳덺PLLHtXH@HtYH@HH(Ht@H-HLHHt$Hj#HL,HD$D$LL蚰LHhAWAVAUATUSHHL7dH%(H$1I6F  HH@ HD$pIFHHD$`@  HLgLZL$ tHP@<O,D$ D$XLL)HD$D$D$T D$HD$|HC@"<t$<D$Tt<D$Tt H8D$TM~CHMInM$ˆT$@D IW8H HЀx HǸHDHD$8HP8с |$ tP8ƃIGHHtHSH4HFH@(HH$|$Tu AGAA L$1HH+LLHAF L;D$0\ @uUH$% @G HHPx5HcʉH(HH)H DHWH4HH9uL$HX(HL`HXL+{HDŽ$D$xDŽ$HILxIFHCIHRHHS IHRLXH,H`H+L0PP8ƃIGHHD$@HDŽ$HDŽ$D$xDŽ$HCH$H$HD$8HDq8A |$ Mu~D% . A$HW*MDtDIADuD^O,LHLD$ HD$D$XAH*IA? tLH=wuHD$8HQ8|$TD$@D$0 D$0HD$pHHD$@uD$HHHD$@@D$ D$HMD$D$xT$Xd$X D$XHl$@ti|$ M9sYA? Mu"bf.IM9s9A} ELHrv#AEH *LL)H9}M|$0u'HH+SH$H+$HH)lj|$D$|9D$ M9T$D$pt|$0 Dl$EL(Dt$x@HALe HuHtHHt Hx EuHUM9(MHIM9AEDB tM9fD|$0=D$HD$M9EljD$H|$ AEL%*E<MM9*f.A? tLHtAAIM9rHD$8H@8% M9?AH+*MDt<@AUD(IM9ufHD$8M}H@8% M9jAUH*DuRfADAIM9u3L$XLLL)H蛑HS IH)H~LeHfDHHHvHM9"HDIM9ADB u|$0uAL$ LLL)H L$xHS IH)HLeHD$$;CHH+$H$HrH58H~yHV{|$TH+HCHHPHCL$HcT$L(AD$@8LeHH+HCHH$dH3 %( H[]A\A]A^A_ÐDMDDd$ 1LD$MIAAA D d$xDd$8Ld$@ItQfDL9Is> u A8 t IM9uMpM9s#|$0t1D$I9EILul$HLMIGL$8LHH)>IHC L)H~M]I@|$TLLHL\$@htL\$@IL|$`H$"HLqL$IAG KcpHD$p `HD$8ƃHP8H5TLLH1u0FHD$8@ ;D$XAPD$D$HM9D$|HD$@HH$D$ Dt$0MLl$@Ll$8D$D$xT$Xd$X D$X1AfDH|$`AMLH+W IEL\$8HL$@H@ H@H<$HD$H߉T$LЅH+L\$8hIEP8tƃIEP8t&HPxL9tH|$@LM)IIH)I<;H|$@HHpHcLEAD$L9DEpPE1DHLl$8ELIIA%END$AH9ED;XPxHHpHHkHHc2HcRLLEuL9L9L$XH)LLD$HkLD$HII@ L)HHD$8M]IH;XP~LHHpLl$8DLEALcYML9\$@vH$-D|$HLl$@MHDŽ$D$xDŽ$ HHH,qHHC HcT$H)HH9Dl$EIE1L$HJDIE91DLH۞HuH(HL$0MHL$0H fDIADB uM9|$0u+D$@HH9D$HC H)HcHH9 |$ HD$@E1MdHHHAIM9:M91|$0uߺHLm|$xH…&HSH@I@ M(L)HLLLǹL\$hLD$HoL\$hILD$HfL$XL)LHIHC H)H~LEIEHHHpHHHLD$8AoLD$8HɉHH+H5\OH1peH$PH:HH$HCpHH;CxHCpFLH+SHHC L)H~EH$IoH@HIGD$xDŽ$QLH LLHanIH$@@|$TWHC Lcd$H)HL9}L$HHHnHMI*X1f.1H$IH}LLHpHCH+HD$Hl` Lt$8HA H߉T$LPHD$XIT$Hc@@HH$SM9HD$@HHD$@Dd$ D$HT$8D$AAA D d$xPD$HD$M9ED$H|$ C$LHJIM9BHl$@6DD$8HL$XLLHuHI|$0uLLDL)HHS IH)HHHHPlHL}HYD$H)D$L$HHH!lHDl$ HH@H@(HH$3D$@HDŽ$D$xDŽ$HHEH+cH$H͝HH2HeHCpDt$x11ILH\$8D|$0H\$@A Dt$MAEA1I9DM9LHH)D$IEuċL$H|$8LH)LL$@肅LL$@IAIHDt$HD$HHLHHHD$XHT$D$HD$L$M1Dl$l$HIMLH\$8Dl$l$HMLH\$8MHcT$H)HH9L$HHH#jHLLHH H*XHD$8@ HD$X@ H@Dd$ LD$HD$AAD$8A D d$xHl$@t(L9s#D$8I8u2fD$8A8t&IM9uIH5)H=!R1Ћ|$0tzD$HD$I9ED$H|$ tH$LH蕡HpHt$X"1H)z$H$@ ysLH$2LDHH)NHS IH)HHHHhHL}H]f.HGHWLHHHʋJ ΁t HfDJ HGLH@0Ðf.ATUSL'HI,$H E wHHHI,$HCL#[]HA\ff.HGHHH uwH\)HcHЍ vH5J1Li@H5Y)1:if.AVAUATUSHHL HhAD$ < tJHG H)H~%H@HEHHCH+[]A\A]HA^HH gHuaHC H)HI$1LmHzLrt LHHHXH@I9HDHUL+HC[]A\A]HA^fPLHItHK H)H~6LLH -HHHefH]DHHHEfHAWAVAUATUHSH(HLO(M>AA H)D0D%D$HhH@H@(HXHL`ADo#E1E11AE9YD9EHaFuPMdAA L@"1HvH5;FHHH1ǂEHEtH7F f%f=oH)%HDH`HcB HHHBHcPHEL<EHE L)HHcH9}%LLHD\$ DD$dD\$ DD$IA L}EADl$ A@MoLHE1ɉD$DIEAIcLHuF#HHHB }HJ y 9`MIMf.EGHH3HF \HFP сA҃ 2MIE~fAt$EHljuDHHt)HHtHHuH(HHufHDHEHEHH([]A\A]A^A_ÐHHH@ H@x MIEAEtHAEtIE_|$ THEL}H]EMthEHtHHuH(fH(HD[]A\A]A^A_H5MC1+dL}HH([]A\A]A^A_DD$t1D9L$;L`E|$ E%AGAD$ 1HDL$D\$LT$DL`E|$ HH`HMHcQ HHHQHRR@_LT$IED\$DL$MIEAE1f1Amƒ ^HEHPM@#JmfDHcWHB;GL|Ht$肃HcSHHt$BHK@CHH/H4HcCHHS@HKHH,H[]@f.HH6 @YHH60YHH6 YUHSHHGH;GL|HCH@HcCHHS@HKHHKH H HcCHHS@HKHH8H HcCHHS@HKHH,HcCHHS@HKHH#H[]fDHH6 XHH6 pXATLcUHSHcOHHA;GL| BHcKHAHS@CHH,HcCHHS@HKHL$[]A\fATHUHSLGHL)HIILHH9u4HcGH;GL| ׁHcCHHS@HIKHL$HE` []A\HH521jFHAHHfDATIUHSHHR dH%(HD$1t_HEHuHHH $ ͉t݃CLkAHHىLHD$dH3%(u*H[]A\D"HH]H $HƋE WFй.H[jf.ATIUHSHcGHHP;WL| 蒀HcCHHS@HKHH,HcCHHS@HKHL$HcCHHS@HKHH[]A\ATIUHSHcGHHP;WL| 2HcCHHS@HKHH,HcCHHS@HKHL$HcCHHS@HKHH[]A\ATUSH(HluH߹H[]A\[iHHHAHRHj HHHHH@H@ HL`kID$ []A\AUEATIUHSHHH A ACAHLC @uDHLtAu CHmuH[]A\A]fPHL|HtHHL[]A\A]rfDHΉT$ 4sHMT$ HZQfDHEHi@`fAWAVIAUEATIUHSHHH1F HcCHP;SLHS@HLH߉KHEH,HcCHHS@HL<‰KHcIHcCHHS@HH‰KHI$Ht@HHcCHLHS@HߍHKHHD.Au EM$$uH[]A\A]A^A_PHHh{HtHHL[]A\A]A^A_qf.HX}HcCHq@f.UHSHHHB u+BHH SHHH[]aHxqHHu@f.AUATUSHHDGH|HcHF,HIILHH9u@AD(;CLD~uHXSHHC@IUHcSHL$H[]A\DA]ÉH5`-A1HH0eAWAVAUATUSHHXD~LGHLH|$(H(H|$ HH|$09}lHLC@HcщKHIHL$AL+[HLHIDLuH+!HH+H@HHEC\9CX~HwBH?HCH+H^AG uLAF <~„t-MfAT$ ƒ   fDE1E11D$HD$L$LH:H@uGAF t(I~W H|$ R <_LHL\$ AL\$  1M9fDHHHPH\FA9Iw1ɉH>HtMuHI11HIEL+=H H1LiHtF ztHHx DHfW1f.J(@DWIuHtHHHy8Ht$8E1E11D$HD$$HH 9HI4$HH HHH%8H|$@Ht$0E1E11HD$$H|$H8IuHGHH7H|$@Ht$8E1E11HD$$H|$Hl8IEHt$01HT$8HHEI$HEH+H H1HiHt3F } HHj HPH EHH@HEHCH+HfDHHHx HE@O@F0HHF80LHL\$(Ht$ AHA9L\$(BHt$ HL\$0MD$(L\$0U M" |$(H(E1LLd$0Ll$8HD$@M@MtI$B <MtIUB <"AD9t$(Iw1DHN;Ht$ 1DHI9;HItMtI4$HEHH5Ht$0E1E11D$HD$$HH56HIEI9$`IH@ICHCILH+1HfW1ɸf.B(DM믺HHL$  HL$ HXHHCH HIVB u0HzHF80hLHE1Ay#8LAE9Iw1DH9H%HB <uHB@ u IF@ MMLHMnHIL.2%@HHLHH91LHjHuLHe1tH_HL3tZI6MnHtHF tVHHHPHt@tMC\9CXH )1f1H9f\HHx LHL\$0E D$(H{\1AL\$0H|$ ILd$0LiH3HKHt4F HHHPHtEuE1HAF\A9FXL 9l$(Ht$01ɉL5LI>Ht$ L{EAVXIFpAV\HPI;VxIVpHI+NHM tXI$HSHCILLL=IE1RL7Rt3HHx HLH-LHXHfW1f.j(@DLHLT$ E1 DhLT$ M1DLH4Ht8IvD$E1HD$$E1H1H/HAE9uIHXvEIL`HfW1f.Z(E=@M+L7IVpfHB@ GLHE1 MDp1DLH3Ht7D$HD$E1$HE11LH.HAE9uHB@ qH7HSp0H-HF800HAHF80/LH+$LֺPHLT$ A6HLT$ E1AD$t!PLHLT$ 6LT$ HAEPLHLT$ E16HLT$ tLAMI1QLHL$8HL$821\HGLHE1*A1LHHuAT$ 10H HF80 HL\$0A6HHI#,L\$0 H6HHI+L\$01tHHx tHfW1f.z(EgHHL$HHL$HHS1HdH%(H$1HpH|$H|$HD$=HL$É$HD$Ƅ$HptRtcHD$Ht$HpH8tuH|$c;H5MHlj1`2F8fDH|$13HD$HT$HpH$dH3%(uH[HD$D7 Hx-AWIAVAUIATUSH8HHot$LL$(HD$HPHItE f%f=FfD$#AIGpHI;GxIGpk HT$I+W LDD$$HL$H3HHL$DD$$fH\c I`HcB HHHBHX@I`HcB HHHBHHL$HHD@XHtAHHPL#L$ID$HHIGL I8H>IPL'ILH L 3HIL IL L2IHLQ MI0LIHI0ILJ`IPtE f%f=Ft }"IHFL MAD$AD$AD$ IH51LL`:I$M2I( HtYL/AxJHcL4DI( HRJ42HHR tHR HtHLAIAuƀ|$#uIp LV0>I I`sHjM^ALJIuAHE f%f=FH5I1ɺ L: HItrIGpM'HPI;WxIWpLI+GHIG L)HmI1Mt$HtL .ID$M7LL3IHtMhAw8LA MhH@`IGpIWHHIOpHcIoHI Ƃ IH8[]A\A]A^A_I8LIPHp(HP8Lщ1 ) Ht:IPHp(H#P8Lщ 1ƒ) @IPHp(H(P8Lщ 1ƒ) I8f.Io/I`HtLD$[D$ILJ`IWpIOMHrIwpHcHH\$LD${|$#D$tsI`HcJ HrAB HkPHHPIPHcHIWhHIWpPAW8HPIPAHP0I`Hp(HtL4$IHFH8u1L5H@H8 IHFH8u1L`5H@HH52HL1DIoD$#fH\1LL -AD$ uW%_DAD$ rfDLAOLL1LL!AD$ LL1I`1HcP HXJH HHHHCIPHcSIGhHIGpCAG8HCICD$CAHC0I`Hs(Ht L"Hk(L3|$#IHPH2HF tkHF8u+IHPH2HHL+|$tHH\$I(HHSHIH81[]A\A]A^A_D"1La HD$De LfAfAI}E#AFHufDH<>tE1<|t<< 1AE1<. HH)@BɉBHB tHBJ E HPt HP@@  HH1rfH<|tAvD{~AuHKAHDH$IHD$IHHPHXH0KI9IȍpI)A)tEt HDBHI9Z  HEt$1EtHBH+D$HBHI9HT$HHE1E1E1H1fH>LOJTH9WLHL$pLD$IHL$pLD$HLH7HD$H@(fW1T$(E =f.)D% AD)ҍBtDY˃uEAEt[^ӃufWf.Xf.|$(HD$OHTHH@#H9uHD$AHDHD$arHUfDHE11f.H$LLmIIHD$N1 @f(fW T\f.>At!IPIH9@<E1IH|$HDL$(HpHH)HpD,$I|IHQH L)HQt HH9 E_HcD$(HD$A<@|$N'I11LLD$EHD$@ILD$HLNHPt+H x\)LD8H<9HHuL)HD$@HD$P1D$NLt$H$"LDD$,LH$HD$ DD$,AF HH$LE eHL RAVIE1E1t1L5@D$NGW LD$0IHD$0A~1҃@|$,fDIH|$@l$HHzH|$fHBHH$?HT$ H [)2HH$41HHuH+T$ H$MLD$ 1A f.@H{BBB HHE11DD$(Ld$pDd$ODl$,MLc$LLt$ LHIfDI9s,A6HHW)@Dt5EME@ tPII9ruEAHW)Dt3A6D@tD$,IIHtMLLd$pMHH+D$ Dl$,D$,M扄$Ht$LLD$pLD$p{#DAAAA@<#u fH<#t<.HH)B DB JH@t$HE11)H$HLHH$RHt$8H$"LHD$0@L@H$Lt$H$"LLVH$HD$ AF H\$H$"LH#S HD$ H$7I@HLHD$1<-HL$HQB +H5еL1>ID$HD$8Mt$ ;H$HLL$HHt$8LFA8B HH E11LjLLG{#*HA1E1HL$HMLD$ HE1AH+QHH$T$,"T$NKIIGH@(H<<H<HHHRHRDHUB |IUB f軻f.H`HcP HpxMHcH HH<vHPuHNfQ1ftHI(H A\EDH HHH`H HpxMHcHHH<vHPuHVfJ1ftHR(HB\EDHcHHHAVAUATUHSH`HP AL- D9HcHHHX;NwIIcLL@Hs8HlHs8HtFFH`P P H`P D9[]A\A]A^fP Ls@MtI>LHC@HsHHtF%FuH뗐SHS0H`Hs(HhH#H`P T@H/)f8d HhH@Hp(Ht$FFHhH@HS0HP(Hs8F@HLpFF HDHC8HHYHC8` HC8H HCHHS8H@HHs(HmC@HB`\FCH蓩DfD@tr@.HxH`P fHHFH+B HHBHC8HHR HPHC8HH@Vf.Hs8HtFFtbHs@HtFFt13GfH踨yH訨ZH3HHqfHxHhH@HH3DH09H HC(HHH8H@(HQHR8HHDHHR Hmff.UHSHHtIueHHPH2HtrHHbH HtH[]HPHuH5ْH1뿐HH1 誷H1&H@H0xf.AWAVAUATUSHH8dH%(HD$(1DHEAH`DLcO Ex3IcHWDHHHDAA HPuHH߾̽H`HHzHHXH+CHHHBHH@HCHHHRHHS HHHRHHHH`HX;D9MkPAAG LsIIEIcUHPIcMHChHHCpAEC8IEHAEAM< E HEHmH@HD$ H`Ht y 4HNHHԐ HWH`Ld$ Ht ~  HHHLH#H膻` HHFH8H0HH7HH'HH`Ht x 5HHH5?n1HAEIE0E}H`Iu(fAHtH߉L$T$HcT$Iu(L$I}HIMuMm H|$HHHt$\fAFLPHt$!EHHFH8H0HH#HD$L@HHHpH8HxHT$ H"H蜸HH@H@HHHx(HH覺H`HWLcO CHAH@HHHp(HHFH@HHHp(H1HH@F L(HL`ALnHHFH@ H$MA$DLHHkHHH5 HH1H(HH,1H>H@KHH H1茲TD`VHH5kHǺ1 HH@H@ 0H5H3?@f.AVAUATUSH/HHuLuLeHF uuHE1Hx AMAT$ ~I$HHPH6A9trHXHEL3HC[]A\A]HA^HHtxH@AHwE0HtHFE180ApDt{I$Hx A9uH@HEL3HC[]A\A]HA^Ð1cfE1tKHfW1Af.@(DDt;I$fW1ɸf.B(D@趠DDLH蘠0HID$80fL`AJ MJx-HcLIMA<vIPuDx|HHH@H@HLcOIK;D(pt0HcLIMA<vIPuAz(tIMRAJ MJeHcLIMA<EIPuAz(uf1DpcHcH4HHM1tLALvÃtIT1<v HPuHHt,H@HPLHttHcH HLH;Q(HDL@f.USHHH/HG H)HHCx#xiH`HcP H@x.H HPHH9Hȃ@vMHPH9u@H(HEHCHH+HH[]1ҾHHt@@<t0<uHXHH0HEH@AWAVAUATUSHH8L'dH%(HD$(1HGH#t/I4$HF 0HHp IA DE11HT$ HHHH@Hp(HP8H߉щ 1ƒ)Z@E1HC@"<HC  L)HMHCHHPHCH,LHwID$Il$HHCHH|$(dH3<%(H8[]A\A]A^A_HEHp(H7P8H߉щ1 )荬LpHEHp(HP8H߉щ 1ƒ)VHH@I|HEHp(HP8H߉щ1 )LpHEHp(HP8H߉щ1 )ƒ٫HHUH@Hr(AD$HR8H߉щ1 )蒫LpHEHp(HP8H߉щ 1ƒ)[HH@IDL0HC@"HCHC L)HWMkHCHHPHCLMcJ :H9OITHH*X[f.[HHp HHy袲IHLzHLxHE8MeIEH@IEWH5F HHDHIHPNHHHH H*XD1H%H5,!)H=1F1d1ATL% ]USHGHH/@#tHuHHt F tbLfHPHr(HtmR8H߉щ1 )ƒLHLHH:HXHEHCH+[]HA\1ҹ"DHPIHr(Hu1f.AUATUSHHH`HGƇHPHcB HHHBHcPHGHHG\9GXLHCx"xHF HHx HH@HhHhHEH`~@HHs\HCXHH߉C\蛢HcSHB;CLcCHHH+CHK@HHcCHHS@HKHHǃHEL+@\L`AD$ A;D$$~AD$ H`HcP L$IL`LA$H+CHAD$HPID$HCpH+ChHAD$C8AD$HAD$ID$H~)f8kIl$(HE@`ID$ AD$@HEP`1Hߺ!fAD$HCHID$ HE@`H8 HEH@HH@H@H8H@L+HCHEH@(H[]A\A]@HÏHHF )HHx HF BHHx @HCHH[]A\A]fD@`HCpHH;CxHCp>L+kHHID(HEP0HEh`C\9CX^H6HCHH[]A\A]@KLH HHcSHB@HHЗHCHEHH茲NHsHDHXAD$ xfDH;HDHHH5y[]A\A]1}DHHCpHEHH8H@(HQHR8HHDHHR Hif.AUATUSHHHGL'h"@t@t @tHHs\H(CXL`C\AE A;E$}yAE H`HcP HHHPLH+CHBHPHBHCpH+ChHBC8BH@jHBHCL#HH[]A\A]fDHAE f.ATUSHGHHx"H`Hcq HyFA HHKHHHcpH4HHHPHcxHKhH HKpHK8HhHHC@"<<At<AtH`A@ DIHƃA Hd[HHI"HCL#[]HA\H`HHcA HHHAHpfAAWAVAUATUSHHHGpHWL/HHHOpHcHHD$HGD`"AAtAtAtAHqHs\HCXC\HCHpHvx#DH蜨L8HCH@#<EH`AAE ;E$E H`LHcH H,HHhD}H+SHUHPHEHCpH+ChHEC8EHDeHEHD$H+CHE HCHE8HE@Lu0HE(HC@"@MeAD$ < MuMmAE  AE 0u"ȃ@@EEAE <tj9IU lB(f.nf.NQv<#IUHz LIE@(f.;,@AD$ <tf=I$ 1lB(f.f.Pv8I$Hz I$@(f..;AE IEH@ HE8AD$ I$H@ HE@Mc@MuImMnIUHtB1LH迖1H蕓IEIdf@#u*L|$L+{IL}@HCL+HH[]A\A]A^A_ÃHcHU@@H(E DLe8AD$HHSB#tHu8FHH@HIHE@fHCHH` HCHPHCH4к/HCHp~fIT$B 8fIUB rAT$ 0jt @PLHtGAE @t>IE80t5AD$ <pLHՇDELH߃E耤Le@HE8AD$Hu8F % =t1H`AD$ s<<M @1LH胥f.8UDHHH5bt[]A\A]A^A_1鑋LHŲLH赲AD$ IUB zfHHHDI|$G mq1LHӤf.7-P1LH賤 khf.1AE 1LH臤f.LAE 1LH3ifD1LH9fD1LH3 gf.AD$ j1LHf.vLAD$ fDI}G yffM1LHH"AE f1LHÇHAD$ AD$t_AD$t{H@J"1LHAD$ qID$@ kIT$B 3LH蝃IUB wDLH腾uID$@ I$B(9IUB(f.AUATUSHHHGL'h"@t@t @t论H4Hs\HCXH߉C\L`AE A;E$AE H`HcP HHHPLH+CHBHPHBHCpH+ChHBC8BH@jHBLH+CHB HCHB8HB@HB0HB(HCL#HH[]A\A]@H8AE QDf.ATE1USH`HHHcH Hhqp HHHHGHuHcMHPHc}HshH H4HHspus8Hcu DELeƃH4PHE<tX<t$LH襊H蝊HC[]HA\ÐHu8HtӋF|FuH:Hu8HtFt0FtVHu@HtFt&FtLEhH؀fDHȀfDH踀?H踻fDH註Eff.AWAVAUATUSHH8HGpL`L7HoHPHWpAP Lc IHx6Hc‰HHH8II)AAAAv<HPu.H8HH5qn[]A\A]A^A_1x9t3@FE1H8L[]A\A]A^A_JDHD$Ic@ LPIAP HCN<IcWL$IGHPIcWHChHHCpAGC8AIGEGHD$  tNuH8HH5j[]A\A]A^A_1铄HHL`IHJ)8 AG@IG0AWH`Mo(Mt!LH߉T$ DD$Mo(T$ DD$IG HD$AODD$ L$pHcU HCE1LHAH4HE(LH@HL8ƃ@HHzH`h ARE<<H~z.fL} ALLLHƃ~@HHCzH`h H_)f8E HhH@Hp(Ht$FFHhH@HU0HP(Hu8F@HL`FF HDHE8HHHE8` HE8H HEHHU8H@HHu(HE@HB`LFtFH@HHA[]A\A]A^A_H5[1MuDH`p HHHH5S^[]A\A]A^A_1ufHxooHu8HFHFHRDHu8HtFFu H"fHu@HtFFEfHHFH+B HHBHE8HHR HPHE8HH@f.H訩HhH@HxnHDD$ L$_nDD$ L$HXL$DD$ f.H(nsHnHnHmHEHcHE(HHH8H@(HQHR8HHDHHR HATUSHGHx"Sh#L`(L "{HLHGx~H`HcJ 9H,HCs8HHjHcUHHHcUHChHHCpHcEC8HU9HHEHPLu^HE([]H@@A\ÐHCh#L`(L mzLH߉HHH5[H[]A\1%rDH HE([]H@@A\f.HS(Hߋ4Y@H螃H`HcJ fDH`p EHH5[1[]A\qff.ATUSHHHGx"h#L`(L ~yHLHEH`Hcq 9;HHiHHHD(L`8AT$ ff6HHCHHHcUHHHcUHChHHCpHcEC8HUHHS(t;sHC\9CXHEHPLuhHL[]A\@HCh#L`(L xLH߉H5HHH5/Z[]A\H19pfH HL[]A\H^H BH߉D$ 誁H`D$ Hcq fDq H`M$$HhHcp fH`p CSHHH5KY[]A\1oAWAVAUATUSHHhHWH/dH%(H$X1HD$HB f%f=B"D$@tpHEHmHD$(Du ArA}HEL}H@HD$HA |$Dt$uUA?uOH5t]H1nDPDr#Lz(LADt$d$ vHl$(HD$HLMA?H`Hǃ`HD$Ph Ht$PHcL5Z\L$HD$0D$?HD$>Ht$IH|$ f.LHP ȃ< iIcLDD$>HBLhMtJHD$ LL$LDD$HL$HLHH$DHIUHtB f%f=,L`IPH`YfH5XH1?mH$XdH3<%(wHh[]A\A]A^A_fDHB(HP`tuLh0)@pHBD$?Lh fDOJHD$0HLh0HT$0D$>LmA} t=AHT$H"HH{Du IsHt,IIEHx0Hh8HHEH@L9uHEHHP Hp(HcJHDD AA R}Ht H@H@HuHhHHHA1IH5ULH1kwfD1ɀ|$cLHD$(HHFDx LP@H f.HrHHD$ LL$LDD$HL$HHH$ BH|$>H<H|$PtzHt$XHtpF HT$Hf%f=u4@@ Hf%f=HHuF f%f=HUH1HL$eHL$H`9h ~q1HIHL$ |H`HL$HcB HHHBHSHcpHHHcpHShHHSpHcPS8H@HHC(4;sHFH|$PIHD$XH;P HkAffHCP Iffu$HCP ffAHPIcHDPHuLHkD|$Hl$(D$E1H-a(H@HHL$ELHǃ@EHL$jHL$H HL$RL`HT$0D$>f.L$HT$HLH߁膁H5"OHH1hNDAEC\9CXH`HcP LHx)Hc‰H HL<v'HPuH5SH1*hD9HHM4HCIcVH,HChH+IcVHHCpAFC8IFHAƒ /<(aIE@\HhH@Lx(IH@xHHC Hcщ|$H)HH9Lcd$MI*X)f.)JIwH}HHD$蛀AD$HD$L|nHcS8HC(t;sHLIEHx0^Hs\HCXLH߉C\VIE@\|$IF HD$t5D$~-MwMHI)I4$HIhM9uH`HcJ HrAB HHHHPHPHcHHShHHSpHK8H@HHBH;CxHCpiH+kLHH(L;IEP0HiDLHD$EHD$H HD$H|$P:Ht$XH'H5PH1eKHh8HDH5KH1ge#H:H wH`LHHcP !|$?cHD$`AHR/<*aH5^OH1d|$?LH|$``;H@HHD$ A< Mn(IE@`AF@IE@`IEP`dHt$ HSjIFH8!HHPIEHcP`HD$ H@HH8H@HCA &LHhH@MH@(IF0HhH@tABLP(H8MV8HcT$IFHIHHH9}0Hx IrH9!H)HHHHIIzH;PfW %MHMI*Xf.HT$IzHLT$ HL$|D$LT$ HL$|$IHcHrtAR @AR |$t"HTDHHt` HH9u苃tLt H L;IEH@(HD$E1D$D$HՋHL$HËIF(HAF@B`|Iv(HoFFVHڗIM~8IH@xHHC Hcщ|$H)HH9Lcd$MI*XF$f.N$JIwH}HHD$S{HhH@Hp(Ht$FFHhH@IV0HP(IIGH+B HHBIHP IWH@AG@GAGAGu LHЖ HCINjD$HLPAG D$% AG HCM~8L8AH5_GHcH1`H5eKH1`AFIF0H`AH5JH1`WAE HHH^HLLHH H*XHHH^HHZ1LH_H5iF1ɺHMiHHHSpHH;SxHSpH H+KHHH BH+t$VHcHPFHHH*fWLT$0 !XT$(L$ f.H4茈LT$0T$(L$ IHB IBLLHH H*XH薔HhH@[H艔uwIEP`YLAHL H*X5H6YLH&Ya hHԎHCpHHHH H*XLHayH5(H=zE1)H聎HSpmSHG1HH@#tH HtA tHH@ ƀHnHκXDf.Ht HP@@L`MtFIcB x5HHHIJDDDAAv$< t@HPHuMRMuHHDHHA(tLMt LM;A tAOAJtHA@ÐHA@@DAWIAVAUATIUHSHHL7dH%(H$1LD$裒1H޹LI Iw\LI9PAGXAG\yAt UAxLl$PLDCM**LAxH$1W)oLcILjIuLQ`IIL hDLLALJE1yI0DHLZ\LtIwLvI;PAE1EHD$ I`D$BIGD$@f%f IfD$@B ;B$B I`*HcB HHHBI;P EшM+wIDpIPHPIWpI+WhHPAW8PI@HPIWAR H@( fPI`HP0I HHHP8H@@EH@ IpHPHIpDƀ)I0EtE1HLWIpDI`HcJ HrAB HHHHPIPHcHIWhHIWpPAW8HPIPAHP0I`Hp(HtLHEH`(f` HEHHPI8Ht @I8H|$HLp]I;PCH$dH3%(IhHĘ[]A\A]A^A_IPE1LHLD@@Uf.IP@$L趓IIPLLLL\$P$LH0AxD@1ExH$H?CL\$IMkL`fDLHT$[nHT$B (fD1L.IPIċB<AtIHHHq Ht+FFIIPHHHrPL1HL$1YHL$E1E11LHA IHH@Hp 贋I +LvIPHpHHHHt+HHt$HPHHT$NwHT$Ht$HqI(I LdIPLHpPSwI(AADH1bfILeILcI8H Bu\ILJ1Bt9H HRHIHTH Ht!RHcAD AfA@HHHHBHDHHtpuyHcQHqL葎I8IHi1fDLPLȋIIPHHAiH HGXH H{ILJ15P_H=1^1vfdf.AWIAVAAUATUSHL'dH%(H$1HG@"<t<At<At螇AI$C 0 HHkH@H$HH$H}AHD$P5IG@ f%f=FEIHHL1R0C EJf.H5l9L1RH$dH3 %(YHĨ[]A\A]A^A_fDH$"HLaHHKH݀y  LD$(Ht$H91LTHD$LH@HD$8螇HD$XLHHD$HAGXAG\IG L)HIGpHI;GxIGpz LI+WIHLHHD$`I\$I$M'gH5L1S…M'HcHMdI,$E HEHD$0@ ȃ Ht$0AHD$0a E HD$ D$xtHEx  1HD$@H|$  IAG\A9GXM'L:TIH$HPHr HR HT$(E1$A L蝀HtH0F HFHD$8H|$ k HL$0HtAaAs HL$@HtAVA@ HtEE IAEDIEH@L97LL{AEHC EH|$(/t.< „ HH[HPH$H$HLHD$HH9HHD$HHHHjhHH$Ht$(/H$HyHPBhHL$H$H$HHHBI DAHD$HxHH|$8L2HHD$ k 1L8Ht$LHl$(FuIG@ f%f=F IHFHH C CG CI IH51LHX誇HI(II$IGM'HJf@#IHLRILSLHrtHLHSLHYtH59HHL1RMDIL$PHPHr H E1$A HLa}HI(H9IXI$IGM'H_fDH1LH$HD$PDLLDt$ @gT$ HDPLL}HHLsHL赀fDAHD$0>@ILlLzqLLL=JI%D;xH0L[FA1HD$@HD$0HD$ D$xfDHDŽ$1H.IfD"1LZHD$8%EqH(HL HI}H5HHLG1ɺHLpH1ɺHL@ pHH@ d=X LʙH5+LD1}LHHn|ILOJLHjHLIjLH+JLHjHLHJLHjH5/HMHL1C)IcD$xAI,ċE @A8mH|$IHFL`(MH51L1\Hl$IYI$H@HH9@H(ALLBDLLKoHLLmAD$AHtLL_]HHHl$XHl$(HH\$(Ht$H|$0LDt$| viA@IHFH@ Hu LzH@H@ H|$PE1$A HHƉALzrHHD$(@IHPHr HLL$($A$DHL0rRHl$L$H5(L%nHy(J|5 UJ|5H5(IETH -H5&.MIHIEL1gAH1HLqC %_DC IHƺ LL$|yH@L$Hp HD$8Dt$|Hl$(8.Ht$Lg>IG\HD$HHL2;HL2vf LxH@Lh(HLveC >Hƺ LxH@Hp aLxH@H1LH0pPx/:HD$8HD$8H8/tHD$8jII HH{]H5&HHL1?PHD$ N LxH@L`(TH5&HL1?1 8kH0L9 ATUSH/HHG H)H~9HCLeHp(Ht@H]HHfHEHCL#[]HA\fHHP=HHPHCH4f.AWIAVAUATUSHHWH/dH%(H$1D$8B"<t%<D$8t<D$8t pIWD$8AD$<B#cH}HEHH|$0GHLeHEHD$ AD$  Hl$XL"LHMAL$ HT$XHL VIċ@ L@ALbsIG@#u Ƀ 1LLjIw\LyAGXAG\AttIPp$CAxH\$`L$  HDH1ExL8aHH\$(HD$HILJHD$(LHp@IILHHt$XALJL9eI`HD$@C ;C$C I`|$8HcB HHHBHT$ *I+WHPIPHPIWpI+WhHPAW8PI@xHPIWAR H@( fPI`HP0I H}HH@ HP8H@@IpHPHIWHHP AmA\II98HII HD$HHtLiH@H@(HD$LsHMLhM9MLl$D@LhLHLDeLL)kHt$HىLHL9l$v[MtVDMLkLd$ LHM)LMHuLLHL"kHt$HىL0H1HD$ LL$01DD$XHL$@Lt$8I6D$<A9(A1ouIpIhH$dH3%(ZHĘ[]A\A]A^A_A"HD$0IP@>HpP1L:E1E1H1HLHD$0=mZ  )HLLsfAD$ fH\$HHt$(LVI0HL9fD1; 0LLHQLIH_AD$  )HT$XLLeAD$ A9KAt(AtIGHRf.uI0L$HE1HT$($ADLhfLLreAAƇ]Hx1L/m@f.LxMC EA~DIP@HrH\$HHt$(L UI0HL7@1fIhLa4@A fDA1 f.LqHIPH+HLDH$L@0AxH1Ax!mHCHD$(HH@HD$H@H=>1tW@AWAVAUIATUSH8HGL7@"D$/LI`HcH HPqp HHHIEHcJL$HBIPHcJIEhHIEpBAE8HBjHD$BAHB0ZI`Lz(fMtLLHT$\HT$Lz(HB AHD$HB@AƅHD$ LLALLwH|$IHD$ fFIH@`L9|$/xYIHFHHCCC IH51LHXnHMuHD$H8[]A\A]A^A_fDM9hAG IHII_HPHr HE1ADHL$dH5LL1z4HD$jA @H 1HLdC %_DC (fDHHXDHLiI6HF tLHH H@HdHHF80NHL.{u+HfWf.@(DHHx fHL=XC DLkH@H1LH0cfDHƺ LL$\kH@L$Hp BL-hLLALLIHD$fFIHD$ H@`#ff.USHHH`HcJ HrAB HHHHPHPHcHHWhHHWpPW8PHhHP0H`Hp(HtXHHH[]5AUAATUSHHHGD`"AAtAtAtcAHagHs\HmCXH`C\E ;E$\E H`HcP H,HHhEJHH+CHEHPHEHCpH+ChHEC8EHDeHEHC@ HE( fEH`HE0H HHHE8HE@A HE HpHEHƃt-ƃAt HCH`HH[]A\A]@HHFL MAD$tqAD$tHAD$HH51HL`iI$fDHEE LH*1 fH1LH\`AD$ u`%_DAD$ fDLH=e`HߺhH@HK1HH0_fDLHeTAD$ @f.S1H?HSHR0HHP HpHCu H[DHH0[ ff.AVAUATUSLHL'$H`HcQ HqBA HHSHHHcHH,HPHPHcHHShHHSpPS8PLhDpHP0H`Hp(HtHeUHHLA EHƃ4LHI1HHFH(HEteEEu HHcHH51HHhgHEL#HC[]A\A]HA^f DHl1HH^E u"%_DE DHH'{HHeRE HߺeH@H 1HH0]afDAUATUSHHHGL'h"@t@t @t._HMl$bHs\H3iCXH߉C\HCHPHCH4YHCHHPHCH4I$[L`AD$ A;D$$AD$ H`HcP HHHPLH+CHBHPHBHCpH+ChHBC8BH@jHBHCH@0HB HCL+HH[]A\A]fHAAD$ t@f.ATA USH`HHHcq HyFA HHKHHHcpH4HHHPHcxHKhH HHKpHK8D@HHhƃhHHI&/HCL#[]HA\111DAUATUSHHHWL'J"ȃ<t!<t<t3]HSJ"I4$Ml$H#F HHHPHTHd`Hs\HfCXL`C\AD$ A;D$$AD$ H`HcP HHHPLH+CHBHPHBHKpH+KhHJC8BH@jHBHCH@0HB HCL+HH[]A\A]uSHfW1ɸf.B(DfHSL+HB0HH[]A\A]HHx DH ?AD$ fDM0HHF801fH3$gf.AVAUATUSL`HL7Mce DoHcAD$I}A AE KHHHCHcWH4HGHHPHcWHChHLHCpGC8DGLoHƃkLHI),H`;i |uHTHqHH,Eƒ tnLL#HE []A\A]A^HCHHx[]A\x"HgH5A]A^HI1'DH9H`uf<tHcA S8H,HCHHHcMHHHcMHChHHCpHcEC8HM9HBLHEHPt H [HE(]A\A]H@@A^H fHS(Hߋ4aPDf.ATUSH`HHcQ x*HcHiHHt`H51=7I%HALHHLHHPH;u[]LA\[]A\H@`CAWAVAUATUSHH(HSdH%(H$1HHJHHD$HCH7HoLHH[]A\A]A^A_HEML$LPMt_IIHx0t@HEH?HLT$(LL$ H@8HHDHHH 13LT$(LL$ ABM9HEH0H{F HHVHHHL$0M)IE1ILL$HE1D|$HD$$HM)s HSIMcJ,H(HHEHCH+HML$It$[qLHLL$(LT$ :HILL$(LT$ M)H5yIA LD<$H1LIHT$0"HLL$ HL$0HLL$ HcLHBAE@uHELmHHCH1@LH.H1HLL$ AH@LL$ H0bsAUATUSHHHGH/@#tfLeHMAD$ vrLH8HXH@LmHDHUHCL+HH[]A\A]fDHG LH)HMtAD$ wID$HtLhMwAElqLH8HIPH5x$LHHA1H[]A\A]HHH-MH^@LDff.AWAVAUATUSHHH/dH%(HD$1LeLmMtMuBH(HEHCHH+HHL$dH3 %(H[]A\A]A^A_fDAE u  v!H5ڏ(HH1AD$ u wIEHLxMID$H LpMIt 1LH5I~t 1LH5H<$H5@!|$IGH5@M&!ID$(IIWHP(IH@(IFIƀIwHIHx(<$1;@1 |$1;@1f HXGLH >H@LxAD$ LH=H@LpH+IHp(HtHf<$֋|$AUATUSHHHGHWH/@#HHL,t:HEHt P vMH(HEHCH+HH[]A\A]DH(HHEHGH/HH[]A\A]@H@HtL`MtAD$uFIt$HtHLHcH=AE@ugLmHCH+HH[]A\A]fDqL4HItHUH56$LHA1H[]A\A]LH(AUATUSHHHGHWH/@#HHL$HuHHF HHx AŀukDLH5DLH HXIIEHCL+HH([]A\A]A^A_DLHR)HItH@HULpLD$MtIH1HH0xHHt x LD$tmANZH)H+H1;f ID$L`MWAL$ @H@LHMtHCpHH;CxHCpL+kID(I@HHEHC H)HAFHLL$HDh2LHEHH=0HH+2-LL$HL+HL+ODLHLD$'HH-LD$HHHLL$hLL$HSHLL$~'HHLL$HLL$Ht$'HCpLL$Ht$LD$HXHEHGH/HDATUSH/HLeAD$ ȉƍQҁ߃qt\uH(HEHCH+[]HA\LH&HtH@HuLH&HH@ wuID$L`MtAD$ ff.AWH5:I AVAUATUSHHH(LpHXH@HD$1HLIHAHHLH$^HIL$fL+IGpHI;GxIGpHI+WHIG H)H'LcLsE PHEHx HKLH $ l/HCHL( E H $<I@HEHiHIIELHp(ILH3 ugIGpHSHI;GxIGpI+WLHHLcLs.1HCHL H+IIELHp(IH3LR unLIGIHH[]A\A]A^A_Dc.BHCHL H $fDHL@HDLt$LPL{HE1E1PLL'_DHH޹LH+DH5ILHLH5[]A\A]A^A_1HE@ :DH5wILL$2L$HrLILHIZfDL"IGp_LH$"IGpH$Df.AWE1AVAUATIUSHxH/dH%(HD$h1HGHPHGL,HEH$HL3AF TЃcuAƉ ]HIHx:1A9DLHH9uHuDDF <@E1tIHfW@(f.H,H*\YH,Lt$0HD$0HT$8HD$@L\$HEJ1McHD$HLA <2AHHPH1D;PHqHcHA9~!D)HT8fDH@H9uHqI4HHuLT$HHT$PB<HL$XM0LLT$ LL$LT$HcIMMt HtF@uHHt/MMtHtF@tLHT$&HHcT$uLL(AE@LmID$L<$@"{<tDMt?H*L$8^ >H*D$0LL}X$R*$HHELID$M<$H|$hdH3<%(HHx[]A\A]A^A_Ɓu r1LLAN a@u$@% =t11LLwIH@A9DLHH9;HA@ ILLAF ЃINA f.LwDLLMCHVB DH1 LAF fLHLDL$,L\$ DT$(LD$HL$9HL$DL$,L\$ DT$(LD$HHP@LDT$~fWDT$f.711IfLff.UHSHHHtFHHtFtFt.HH[]HHH[]f.H"HH[]f.AWAVIAUIATIUSHHHGh"@t@t @tI@\ H]"Hs\H(CXL`C\AG A;G$AG H`HcP HHSR"HHD$LD$H5'AA$1LHHHA"HHL9LH AF@LH @AH5$LHH1AHHH H.DH\LHƃIEMfH@HxA$IEH@HxIFH q(D$Iv:IIT$H9QHPIEIL$HH@HpIHHBAF AF bfDH5$ALHH1I$>nLH^AF @uLuHCHH+HYLHS LHIF(f.ATUSHGHH@#uLHH HH)HHt M v8H@HHHHC[]HA\H)HAHuHHMHtHQHtHL`hMtZIL$Hq0Ht\HHHC[]A\HHHHHPWHq0IHu@HE1H1LHHE t HE8uHH51[]A\fDHHH5[]A\1AWAVAUATUHSH(HH$H`p HcLH$H@HSHCH HUHH(L[]A\A]A^A_HHH@`HHH@HHHPHAHuZH<$HXHWHGwfHHH{=<LH"LHH6H1DMHD$LH+T$HL$HLhHPHT$HHL$HHLLhHsHHHHRHH)P`L+MuHjfHE1I1HHHAD$ t ID$8uXH5JH(H1[]A\A]A^A_!HPHz09HHBXL+MuHfDLH]H(HL[]A\A]A^A_H51H5AHHL3H5HIFPHHpPI$HHp H3IE`f.AWAVAUATUSHH(HGpHWL'HHHOpHcH,IHG@"@LmHMtAE 1HLHHD$L LD$MtA@A@HCH(JHPHHHCHH([]A\A]A^A_@L`@IEHeLpMXAF1HIILH(MLHMLH)HLL$HLD$LL$LD$HLL+LD$LL$ IMt"A@A@u LH"HCHXJfDqLH HI)LkK|H9t>I)HUH5ILHD$$A 1%H([]A\A]A^A_fDHC L)H~SHoLH)HHxH*X*f.2DHHHLD$ILD$cLLH߹LD$L)IHCHHcLD$HIT$LLL\$( L\$(HrHLHD$('L\$(HT$hLLID$0MILl$kAE @4HD$ HuA$H|$HL|$PLID$LHL AG@t Ht$PLHD$PHCID$HI$HLHPD$dIEH9P:MuHD$ LL|$pHpHT$LL$dMLHH|$IUH9HONj|$4HBIEIUH@AE %_LDAE @HD$ HuA$ID$H|$HLL$dL|$PHLLqLL|HHD$8H@HxHXHkCaqHL;HIEIWH5A HL1H)LH,$dHD$hHHHH9H5L1GHT$hLLrIAE tLLLT$LT$ D AE HT$1LLLAE LT$vLLHD$hmMLl$MAE AE DH5L1LLII$(HHEID$I,$HE1E1t1LLLT$LT$LL E1E1t1LLHt$8>LODf.AWAVAUATUSHHXHWLdH%(HD$H1HGpHHHOpLc(HGJ,HH@ HWLl$Lu%L$MD$AF va$LHHD$HD$ E1LHHCHt$H(HHPHHHCHMDIFHt|$LxuMt AGQLL$LmMLL$aIHTI<AE uIUMuHRHT$8HT$1ҩ tHP@<ƒLL$ T$3E1ۅLL$ AE |$J|$3MIHEI9YHuLEF HH@ HHM9Hu F HHP HEH;T$WHHl$H)H9HG|$3mM LHL\$LHHI<L\$HL)IwHL\$HL#L\$HH|$3HCHL$L,tI.LHL\$L\$HL HLHAD$@t LHMeHCIL+HHt$HdH34%(HX[]A\A]A^A_DE1PqLLL$HILL$LeIAI9M)H5LIHHD $1A $o|$3HD$8HL$3HT$@LHLL$ HD$@|$3I!HD$@MLL$ HD$8@<LHHD$kHD$hHL$11fHD$8HD${HC M)L)HLHLD$LL$LL$HIMiLL$HLHIAL+MLD$@IHT$8"HLLL$ HL$8IIAE LL$ HL$hHuLEF HLh M9Dl$Hu F tQHLHLL$@HnIwLl$8HL\$LL$ LL$ L$ILLKL\$H#HT$@HL\$LL$@HL\$HT$8LHD$3IILL$ HLD$(L\$ LL$|LD$(L\$ LL$HL\$HD$ IHL$ HL\$LLιHLD$LD$IH|$HHHHH9HLcH5H1B}DHl$8IwHL\$RHDLBL\$HDHLD$ L\$LL$tLD$ IL\$LL$AE tIE@LHL\$ LL$LL$HD$L\$ lAE tIE@T$4HL$@HT$4LHL\$l$@^HcD$4Hcl$@L\$ILHT$8LHL\$ LL$LL$HD$L\$ LH5.H1311HsF f%f=ot!HP(%HH5H17HtHPHMP(Hx @AWAVAUATUSHH(HGH/@#LeAHLMAT$ E1 @#u x"{LHLm HXH@HDHUHCL+HH([]A\A]A^A_HW H)Hx"LE1MjH@HEHCHH+HH([]A\A]A^A_fIT$HGLjM:AE/qLHHIDH#H5+HD$$MLHHA1H([]A\A]A^A_HH HHCx"HpE1Q ցtrLAWM|I}qIEtID$Hp(HHx=LHH2HX҃ HQLb8rIEHE1E1LHH@ IED$HD$HD$$Ml$IuHtPHH ID$H0F@HcsL HH@Hp(H5lH IEHC#@f.AVAUATUSHHHGHWH/@#HHL,tpLeHMtcLAD$ LHgHLHyAE@LmHCHH+HH[]A\A]A^HC H)HLMu6u H덐ID$HpLpMcAFXqLHHIMgMt(LHLH(LAEuAE H(f. u)t1AT$ сHIt$F fD wI.DH֭1H3f.1ҹLHHtP 3IH1H/ f.L 1H^IfDAWAVAUATUSHH8L'HWdH%(HD$(1HGIt$HJI,$F L<HH@ HD$Dr Ml$fAMDAE LHH@LHMH IyE % =HT$ HHLL$HHt$ LL$IŋD$%?=B‰H9HEEH@ADAIqH请t$L1E HcHELhA}WHsF f%f=oH"D(%HH5JH1"@2HEH@ IEFHD(Ic1HLL$DD$HDD$LL$HAIqɶt$L1E HcHtlHLHAG@LH,HELmHpHt$ Of.LH腷з H(II$HCL#HHL$(dH3 %(PH8[]A\A]A^A_fDηHSHD$3IEHPLHM[>Hc LHAG@ID$M|$HHCHdDHHP fDHQHHLL$HL$WHL$IHELL$HHFDAEE@mHHHT$HT$SHHLL$CLL$fHA(Hx dAVAUATUSH/HHGHuHPHGF L$txHLp HuHt F vlH褵1 LHAD$@t LHLeHHCH+[]A\A]HA^fI뀐HFHtH@HtLhMuLHvLH˳D1HcHH?bfAWAVAUATUSHHH/HuF HH@ HuAF HH@ HuAF nHHMH@ HAtA HκHHL$RH@HL$L`M9I|$t 1HHjDDD AH5M4$H5ID$DIF(I$ƀsIt$Ht:I$Hx(t'1D9@D1ܹHXJHI$Hp(HtHI|$uI$Hx(uDxH(HEHCHH+HH[]A\A]A^A_HCHMAHHHS H(@H/fDfHZ1Hof.HAHL`M: AWAVAUATUSHH8H/dH%(HD$(1HuF HH@ HD$HuF HH@ HD$HuF HL}LmH@ MHD$AG LHH@L`MkAE LHH@LpMMMtI|$t 1LHFMI~t 1LH)MsT$t$HL$ |$mU|$ H5M,$|$ H5ID$IE(I$H5|$$ƀsM.|$$H5IFIE(IƀsIt$HtfI$Hx(tSI~tLIHx(tB|$ 1;@1觶|$$1;@1茶HXH蘽I$Hp(HtH能I|$uI$Hx(u|$ 'IvHtHOIHp(HtH;I~uIHx(u |$$H(HEHCH HL$(dH3 %(H+HH8[]A\A]A^A_@H裬L}HD$LmMpE1ME1HcHD$fFHD$@IEHQLpM\?fIGHL`MHߡ1Hwf.LH襮LH蕮{f.AWAVAUATUSHHH/dH%(HD$1LeLuMtAD$ LHH@LhHCDx AMI}AF IMfH@H$AL4$IuH}DLu?H(HEHCHHL$dH3 %(H+HH[]A\A]A^A_HXID$H LhMHGDx AI}!fLH` ^DHY9(Ic1HH H"LHݾID{DL^菸Df.AUATUSHHH/HuF HLh LeMtZAD$ LH0H@HPHt+HrHt"HDxx"HX LHH H(HEHCHH+HH[]A\A]fDިIKfDID$HRHPHb@AWAVAUATUSHH8H/dH%(H$(1HGHPHGL4D$L}HEMt'Ht P v`HH%p H(HHEHCH+HH$(dH3 %(H8[]A\A]A^A_HPHtLjMtIuHtAG \LHH@IuL`HD$ HIHD$3HT$LA?I|$t 1LHH5+D5I$H5ID$DH$H$HB(I$ƀsIt$HttI$Hx(ta1D;@D1L$HT$LHAF@t LH LuHCHH+HfHضI$Hp(HtHöI|$MI$Hx(>D`1IGHL`M@AVAUATUSH/HHGHuHPHGF L,HLp LeMtAD$ LHH@HPHteHrHt\HdDHcLHHH?AE@uLmHHCH+[]A\A]HA^LHLHHA茨 H(HEH+HC[]A\A]HA^&IfDID$HHPH(AWAVAUATUSHH8L'dH%(HD$(1HGDh AAM4$Il$HuF HLx HuF HH@ HD$LeMtAD$ LHH@H@HHpHHƥAAtrAAF @I@ HL$ D$ D$At$DD{HXHEHUCIHx_AV t$LD$D_DAV H@IIVH@IDINH@D$謼x>L$IHHIIVH@HELuLH@ H(HHEHCH+HHL$(dH3 %(H8[]A\A]A^A_fDH転HD$:H裢I ID$H.H@HBHEHHCHlDtkIINL@DD$dfDLHIL#HHhIZLHHT$ "LHöLD$ H蔰@AVAUATUSHHL'dH%(HD$1HGI,$Dh fAHtE FHH6H@LpMI~HEIHHHŋ@ D$H%_DE HEH@HEHUH@Iv荢AtdAuHuHT$x_L$HEHHHEHUH@I,$HCL#HHL$dH3 %(u|H[]A\A]A^HuHT$y@H(I$HCL#H봐HH%p HEHLpMܮff.AVAUATUSHL/HG"HW(HCL$G E1f%f=SL9h(MfHHi1LHbAD$ HǃL;H{LDG"AAԃA <"HjMeImAD$ `ptIIt$V w/ %=AD$ t ~ IuIT$HHL( HSHǃHB f%fB f%f=CF HvLH{A G"<<t<tYHtLHC H)HbHXH@EHUHDHEH{HH[]A\A]A^fEHC IcH)HH9`CXD;C`AL(HbHHEHLL0HAHHEHLD@H HHEHL޸L8HHHE HL轸DDHHHE(HL蜸DHHHHE0HL{LPHHHE8HLLXH{HHE@HLLpHZHHEHHLxLH9HHEPHLWLHHHEXHL6L`HHHE`HLLeh豷LhHHHEhHLL荷H+HC[]A\A]HA^f.LHUAD$ Ѓ H{IL9hMID$HH@8HIDHHp HHH LIH H1PHHC@ f%f=RIfHHdL1HE1MHIvHt_HGH(ƿtH{L.fHHH-HDH{H@IHp0HHhfD1ҹ LHHvfDF HvLf.ID$HbLpf"1H衮Hdf HtAHF H~ 耩HtH%(H f H1H{E1"fDHHHDHߜH"1HHfHIt$V ҃ IDfuELYLf.L@IE1H baH߹"1hHH59H1oDf.AW?AVAUATUSHHHGL'P h#w H5T4I $A  t @"MH@D4HDoHt[@#tJ@"HtHp(HCHHHBHCH H[ÐH(H[nH@H[nHXHJHBHCf.AUATUSHHH/dH%(HD$1HE@  HGP"t HP(HCE1L$MtAD$ MtAUH:(DHC@#H(HEHCHH+HHt$dH34%(H[]A\A]Ð@#LeuHAL$ %=ct,It$F < w t?AL$ I$Ml$HPH$ ALH蹰I wIfE1ID$HH@HHpHH}膓HCt|@#@"HtHH(HCHHHEHCHHtlHHCP".1 L衪 HCu@#u\H@^H(H!l\@ @HXHUHEHCUH@Hk @H耸It$F TH1LH蠠AL$ IH$_jf.AWAVAUATUSHH(L'dH%(H$1I$@  HGP"tqtl@ Tf%f=BEnkHt9fH$dH3 %(H([]A\A]A^A_HCP"HP(HCE1H,HC L)HH H9hHHT1HHbHHtP ǃf{HI HAE HC@#H(ID$HCIL#Hf@#M,$uI<5AE cIUHH(HHǃH5]Hx覰HHHHfH(ƿ0 Lt$E11ɺ<HH踼LHHHIHA4EA.1E1@uO@E<vE<v 1@AIFE9An@I@yHP@<tT$ H@͋T$ DHu@vSH(DD)(9}>eANy,w'p1H9IA|@yH@v@PLMtkAE ~ IEHJrImU   %=AE HHǃH5NHx藮HH H^tJHF H~ KHt&H(H ą H1ٖfHC@#H(HffDHcAILLH}IDHh@H@H-LhǃfM I}H>IuHH(ƿ@%=@uoHCP ff@#@"LtHH(HCHHID$HCHHH5H!@IuHLIuH8~|IuHA蒫IuHDIDN1EQ@HCD9P ff8&@#H@HC@#HXIT$ID$HC Ѓ L1DRmDR`HHMImU ƒ DǃfD1ҹ LH6HfDHH]H@Hd@@%=@HCP ffI}蜼/I}Ȳǃf*H߹"1vH9IfAVAUATUSHH HWHGL'HJH,B#<HHFLh MH MAD$ CLHh賅1 HHE@IEImHHCHH []A\A]A^@z"Ml$M$$AD$ uqtqt0It$V w# =%=@AD$ Mt$Mt A>OMxLXAD$ 뀐Ѓ wE1DHHͫHw1Hf.ID$HHPHHHp0Ht!HQZHcHH?HrHhH蓂,f.LxfD 1LH讕IH^It$V ƒ I HMH@Lh IE11LqHI"1H!MIE1hHL{H1]6H "vE11D$HD$A$ LHHI1HHڽE@u3Il$Ml$tHu1H0HCL+H0HHƩ@ATUSHGpHHWHHpHwpHcH,HGHWHpL$p H荝LHcH?AD$@u?HC H)HHHH跂HLeHHCH+[]HA\DLH봐f.AUATUSHHL'HGI4$HPHGF H,tnLnuILHcHHHH?茼E@t HH諨I,$HCL#HH[]A\A]fHgt1HϸD1 IAWAVAUATUSHHH/HGHuHPLmHGF L$LvHuF t|L~uWLL脲HcLHHH?迻AD$@t LHܧLeHCL+HH[]A\A]A^A_Hs1HD"1H1Iqf"1IFff.AWAVAUATUSHHHGH/HWDp HuLmHHAF L$L~HuF HFu_ALH觍HcLHHH?袺AD$@t LH迦LeHCL+HH[]A\A]A^A_fH (Ic1HHD$HӶHD$ALH膵z"1HD@"1ܐI@AUATUSHHH/dH%(H$1HGHPHGL$ƇHuF tyH~H舄xLHcHLHSAD$@ucLeHCH+HH$dH3 %(uOH[]A\A]@H(HEHCH+HĐ"1Hw@LHMƉfDAWAAVAUATUSHHHWH/dH%(HD$1HGHH@#L,ʃ~!HuHHtF CHH@ AHuF  HHHH $HEL`E1HvA| /HQDLwHcLHHH?BAE@ELmtL膨HCH+H|$dH3<%(HH[]A\A]A^A_fA|/HJu HHH$uLHA膜ITHo1H%>LHţY"HHPH $I@Fy ff.AVAUATUSHHL'dH%(HD$1HGI4$HPHGF L,HH@H$I$HjE1Hv|/HPHHcLHHH?軶AE@EM,$tHHCL#HL$dH3 %(HH[]A\A]A^@|/HBu HHH$uHHAH_HRn1H覲ILHE`H"ӌHH$袆fAWAVAUATUSHHL'I4$F L~Il$HtE HHPH@LhMI}HEHrHH@8HHEHEHH 1臥MuI~0Ht MuL)HIF0t0HXID$HCIL#HH[]A\A]A^A_ zu H(fD"1褋I@HEH LhMI}MuI~(<Df.AWAVAUATUSHHHGL'@"E1<AAM4$Il$MtAF LHϳH@L`MI$Hx0Hu1@LHLu)AHEKI$LHx0H HPH`H H`Ht{H1HII$u u4HS H)HkHHHxHPE1E1t1LHfDAt%xt?HC@"tE<uH(HHEHCH+HH[]A\A]A^A_Ð HC@"uHeDSAMIHCL3HH[]A\A]A^A_IFHoHH@8HIDHHH 1d%IFHL`MfAUATUSHHL'HGI,$HPHGHL,tE HHwH@H@HtRHHx0HtF9LHH蛱AE@uM,$HCL#HH[]A\A]LH蝝HEH oHH@8HHEHEHH 1[Fvu H(I$HCL#HH[]A\A]f.HEHH@H, AUATUSHHH/HuF HLh LeMtAD$ LH@H@HPHt;HHx0Ht/LϙHXHEHCHH+HH[]A\A]ID$HnHH@8HLEI$HH 1:%uu H(똺qI3fDID$H:HPHJ(ATUSL'HI,$HtE HH=H@H@Ht0HHx0Ht$_HXI$HCL#[]HA\DHEHUmHH@8HHEHEHH 1C.tu H(I$HCL#[]HA\HEHFH@HV4AUATUSHHL'I,$HtE HHGH@LhMtJIEHx0Ht=HIEH@0xUHXI$HCL#HH[]A\A]HEHulHH@8HHEHEHH 13st(H(I$HCL#HH[]A\A] HEHLhM, ATUSHGHH/HPHGL$HG H)H~i1H蟈蚩x6HcLHhAD$@uXLeHHCH+[]HA\fH(HEHCH+[]HA\fDHHrHLH-뛐f.AUATUSHHL'dH%(HD$1HGHl$HPHGL,t&=Dq8L1HHztͅ"L$HΉ1ҁD֍w @ON ʉDHcLHAE@HC L)HLLHqIMl$HCIHL$dH3 %(L#HurH[]A\A]@HǃHǃDuH fLH襗cHT$1ɾyHcD{HcfDAWAVAUATUSHH(L7dH%(HD$1HGI6HPHGF LLHLH]艢AE@urHE H)HHH޹HhHLkHHEH][]A\A]HA^IGHE1E1L1HzrwfLH5~HsHSE1E1LHGrDHO1HGfHƹ1H~xHfDATUSHGHH/HPHGL$HHcLsAD$@u;HC H)HHHHfHLeHHCH+[]HA\ÐLHUATUSHWHHGH/1B#HJL$tHuHHtF tsHH@ ]LHcHϠAD$@u?HC H)HHHHGfHLeHHCH+[]HA\DLH譌HߺKbAVAUE1ATUSHGHHWH/HHL$P#HuH*F HE1Hx AƀuPDDHcLHHH?؟AD$@t LHLeH+HC[]A\A]HA^fDHW1HDHuHHXF tiHLh CHLHXAD$@upHC H)H~sLeE1H2HE1aHA@`HSIR#E1LHHHH]dHrDAVAUATUSH/HHGHuLmHPHGF L$ttHLp HuF tKHx DcLHcHWAD$@t LHtLeL+HC[]A\A]HA^DHߺ__I널AWAVAUATUSHHH/HGHuHPHGF L$HH@ HuALmF HLp HuF H@ uVDDrHcLHHH?lAD$@t LH艉LeHCL+HH[]A\A]A^A_@HhU1H߉D$ 裙D$ DH^ofDH^I@^fATUSHGHH/HPHG1L$HHL衜AD$@uAHC H)HHHHbHLeHHCH+[]HA\LH}벐f.ATUSHHH/HG H)HIH%H* H*^HD$D$HHEHL_HC@"<LeH* H*^HLe D$bD$HHEH^H* H*^HD$)D$HHEH^H*H* ^HD$D$HHE H{^HCL#HH[]A\H蘈DHHh`HAVAUATL%RUSHHHWH/dH%(H$1B f%f=7HRLEB#DHuHH3F IH@(Ēf.f(KXf.f. X^HC@ f%f=7hf(H|$0L$=L$IMHCP"1HC *D$DXyXH)HCX;C`mMHcT$@H'DL$8DD$CX ;C`Lcd$0H芚HHEHL記Lcd$4HkHHEHL艘Lcd$8HLHHEHLjLcd$HD$蝒MD$zH(HHEHCH+HHHHD$gXD$Hf H3fDHH H%XHDLME1AQfDlAAAAD)i9t!E0uAdD)AE19AMcC+IEED[FT H Hl$LHC H)HfHHH=DHHC@"kH1lbHLu7MHEt$AVAT$HHf:~HCL3HH[]A\A]A^A_ÐHuF % =1bTIHuLuF % =HFHD$H 1LHLH€MtA?IEH|$iT H LL;H L%DLvL~HE1"Hl$MA>LIEH=D1ZHHl$ID1HNSHD$ @E1"LMtyA?LIEHt$H=S1LGIcI$HHQR@HAEfDH=#1GI181Ґ@f.USHHH/HuF tjHx HSR Zt^~<[t,\uTHXHEHCH+HH[]UڐYuCqʐ=frfUSHHHGH/@ %-] wH4HcHD{HC H)HHHH@HHXHHEHCH+HH[]D;뱐k\f?ftfXvfDcffD+MVfDAWAVAUATUSHHHGH/Dh AAbwAcE1AaHC H)HOHC@"<SMII4$1Hy_HHNh1HHE0xHHI2hHE>H ID0HHHLI<$WGT !H HHE7tHPHt LHNAE El$H*{HHHELVEl$H {HHHE LL@VLHeLHHE(eHE0It$1HU^HH*gHE8IIt$ 1HLmH&^HHfHE@It$(1H^HHfHEH\HCL+HH[]A\A]A^A_HuL}F % =m1NIH LHpHhH8LxgT jE1"LH=SL1BCIf.HLuyMHEtAaI$HHMHCL3HH[]A\A]A^A_fDH8eBDHH H=H DH HpHhHxH8PHT H LxHuL}F 6HLp H DHpHhH8LxFT E1"LEH=D1AI,fD"E7AE IT$LHKE1E1t1LH,qE1E1t1HHqE1"H=f1FAIfDLvAT$HHhS7IfDH LLx0fE1E1t1HHhpI4$H= .1@fAWAVAUATUSHHHGH/Dh AAfAgH HWpHwhHOxHH7T @H L`xHC H)H@HHHU:HHC@"HIbHLuOvMHEtAf)I$HHIHCL3HH[]A\A]A^A_ÐHuL}F HLp H DHHpHPhHpHL@x8cT zH LL`xHC H)HHC@")<2MItoI4$1HI YHHaHEIt$1HXHHaHEEt$H9uHHHELPIt$HHE HCL+HH[]A\A]A^A_DHuL}F % =1fIIH LHHpHPhHpHL@xlT E1"LH=L1>IfDE1"H=1=IfDE1"LH=D1=IlLvDAT$HHO3IfDATUSHGHH/HPHGL$HG H)HH HHaT u9H HHt+LHH_lLeHCH+[]HA\@"tCH(HHEHCH+[]HA\DHH6HcH=)1tOL9% =HFHD HHHI9H3F ttxHH@ L@rHI9rH3F uHI9sAIFHL$HAH(1L^l+fL1FfDAVHS)EJcH1L94 @HD fAƆYH5,(L16H$dH3 %(H[]A\A]A^A_H|$ 1MHfL|$INLHD$LHnAG@hHD$HHIFIHuDHD$XHT$0LL$HLD$@HL$8Ht$(HD$HD$PH|$ H$1@MHxHt$(H|$ 1MHWHT$0Ht$(1H|$ LH2fHT$0HL$81Ht$(H|$ LH DHT$0LD$@1HL$8Ht$(H|$ LHHT$0LL$H1LD$@HL$8Ht$(H|$ {LHHD$PHT$0LL$HLD$@HL$8Ht$(H|$ H$1BLHzf.Ht$LYfDH5 &L14=f.AWIAVAUATUSHdH%(H$1HGHt$X#F t HD$HH@H$HsIWJ#ȉ%!Y$PH|$G HH_HHH$Lj(L$ MHD$@  B# L9MHH1.fDΈHHL9IHHL9:@ALMyă1ɃHD$@ @D$ u( KHL$HHRH$H|$%DG IWJ#f. LM@hHR(IGH *E1ALL$1It$D$HD$$ YHH0F HLp MnLt$ H|$G HLwHZH$ P LI9 A>IFy DHxH9uHD$0D$(" f.1H$dH3<%(#HĨ[]A\A]A^A_DHt$H$"L@H$-f@HR(E1H (AD$@IGLH1HXD$HD$$ HD$(HXHH0F nHH@ HxHD$0H|$8H|$W 8HHOH@HL$PH$ dHD$PD$hHD$ H E11D$HD$A$ HLWHH0F HH@ HD$`D$@rH\$PHH$HD$ H9D$PIPLd$PH'D$HMIfZH;D$8AAvII9v6HD$@I)H)H$Hn .HHXHIHL;t$ UHt$(LL/H9D$0vAL1LD$HAIH@IuHL$A AHHYL`L$Lj(IMHD$@ 1L9s(HCfA|EL9u fH|$G HHoH@H$Lj(H\MTHL$I H9b1DEADEfxEHH9uHD$T$ H @D$ kfȉ̓@HR(E1ALD$XH ]%D$@IGH1HXD$HD$$ HD$(HKUHH0F HH@ HxHD$0H|$PH|$G WHHHRH|$hH$  HT$hD$wHT$ H E11D$HD$A$ HLTHH0F  HD$vH@ HD$`\$@MH\$hIL$@HD$hH|$ E11IH9HrGH5 L1v-HUH9wEAT-AD-H0H(HAD-H8HAD-H HAT-HcHHUH9AT-wJAD-H0H(HAD-H8HAD-H HAD-HHAD-HHAD-H0H(HAD-H8*Df.AWAVAUATUSHH8dH%(HD$(1HHh@HGU I% =WHT$ HU I P_DU C HL@ HP0AHX8CA֙DDAAATH|$ DHcH9vBHELIL9HL}L1HL$H)LLD$HEHL$LD$HHٸMcDMPHcI!A"ID AE@t HLh4HD$(dH3%(H8[]A\A]A^A_DHE L}H@HD$ HL#U E1AAD@/6 @KH=1LLD$McLD$LGD'H8C'LH0CD'LH(CD'LH CD'LHCD'LHCD'LHCD'@HL` IHDLMcHGD'C'LHCD'LHCD'wLLHHL$LD$LL$3'H|$ ILL$LD$HL$McG'+@LMcHGD'C'H5LL17)H5L1!)AWAVIAUATMUHSHHXdH%(HD$H1H9ʉ4$*H1L=E HEL}H@HD$0AF % =t11LH_ AD$ )I$Ml$HRHT$8E1E tHPDR LHfAHEt<|H|$ .Ht$(HtH HD$ Ht$(H9tHE9DDH8DH%L8A  IDHLx H@ H8$L(A}  |$PIEMcLHLx AʼnwAD1LH߉D$0DD T$0D1DLd$ HL@ LHAEx11D9@IžDL$01TL$0AMHELeߋ$tHU'Lb(H$dH3 %(H[]A\A]A^A_D<-EHD C%=tIHE<<H$H$DDŽ$'HEƀsED$n AHD$(HD$ AD|$0Ht$HHDIcIHƺHL<AL~'ADtIAADuM9r#fIAM9t AGADuD$E%ELE)AHEA+!|>tC<*${-HL$HT$0H5zH1tH1HL\$P*L\$PA~>IƄ$w|$XDŽ$Ƅ$bA<&uf.IAADu<- D$E MAHD$@H$H$E1E1LHL\$XHD$$D$.L\$XID$PMEAt<:tADfDHE<HL$ |$nHMHL$(HH(HE@1fDHFH#HhH0B#@L$P@|$`d$PL$Xd$`d$XD$o>@HEHD$ HB(HD$(GfKfDIAADu|$PƄ$rLƄ$bA<&<- D$D$PEk HD$@H$H$E1E1LHL\$XHD$$D$ -L\$XIMu|$PeD$PPfDHD$@H0F <uu iHL\$pL\$pHHκHL\$xHL$pDD$0HL$pL\$x~f.E%= $<#tmD$PQLLLH8HEfDAF<2LHH8$IHEL\$0ƀ|HL\$XHL$0L\$XHL$0H1HL\$XHL$0L\$XHL$0y$tHL\$PL\$PHD$@H0F HL\$PL\$PADL\$` D$PAL\$`H@HH@HD$PsHEƀsHEƀu*fHEx"yL9puLHHtH{Ht_tHsHH{ID8 AuKE<$H{tH{AyHsHMdHsDHPH{E<$H1[]A\A]A^A_ú>vD1f.HF v V HH@HFHtH@HtH@HtHHyfHHt F v 1H@HFHtH@HtH@HtHMHUSHF vI HH[]HFHtH@HtH@HtHHӉHHމ[] fDUSHHHt1H@t#:toH ^'Dt1KHHuH1[]{wfDH{:H+HHDH)HHfC@f.AUAATUSHHH7dH%(HD$1HG@"HW H)HNHP(HCH,H9hHdE E1 HfHH1HHMIt$HtHHLD IE;ht~yHA[De]A\A]A^D[7fDUI []A\@A]A^@CfDH[ADe]A\A]A^@HHHH H*XH5<'H=G1fDAWAVAUATIUHSHHrF H@(E1?HED,tLuHEHpF t~HHh 肱?AD;tH[]A\A]A^A_DAF IHp HDD[]A\A]A^A_DLӭHt5fAF tiIp HDD[]A\A]A^A_麮f.HD[]A\A]A^A_xLLаHJLL0ff.AWAVAUATAUHSHHHrdH%(HD$x1F  HAEH@ D$#LsD$ IvF HH@ 1ۃD$A@Mn AEA<t|AE IEH@ IE1莯A@AE~A<HL$xdH3 %(HĈ[]A\A]A^A_@xApfHӫfD辫AED$HsLsF HH@ D$ Ax|$ t|$HL$1غ1StfLt$`Mt$|$Lx1A21A}HD$pD$xfD$|HD$`IHH|$XLl$H$HD$ MM9L\$8IHD$hH\$(Hl$@E1HD$0H$Dt$KLۉDd$LHD$^Ht$HM萫AEH'|$ ID*D$@D@L9l$8BD4p+LHT$HL$0E1H|$(AL٨HT$hL$ML+t$ I nDt$KIHl$@H\$(Dd$LLHt$XE1HD$hHUHl$(Dd$IDt$ Hl$ ;HHHHL$hH~IM9rLH荤u BD4puOHt$XAHNA9Ht$X1DHSH0F uH߹"LZLt$hHHl$(Dt$ Dd$HtHEfEH|$D$ 詹D$ ID@HI'ƒATfDIIFfDt$ Dd$1^fDH$Ht$HL$`E1AHHHD$ EL|$`tHD$Hz'BDIcLL)M,H9MMAsF<\ HHcHMADE1ASH AC<4; ʍPπ H5HcHfASƒv zM9AL9tn9HL9uD)fM9AH<'1LDtSDHL9uD)/A$M9tLT$(LT$(HLHL9[DBtD)M9BAH'1LDtDHL9uD)wM9SAH4'1LDuKDRHL9uD)'A$M9bLT$(LT$(HLHL9gDBuD)\M9UAH|'1LDuDHL9uD)oM9UAH,'1LDuCDaHL9uD) M9wAH'1LDuDHL9uD)A$M9;LT$(\LT$(HLӐQu<_HL9uD)ifH M9AH'LDuDDtHL9uD)M9AH'1LDuDHL9uD) M9AHt'1LDuD.HL9uD)gA$nM9LT$(LT$(HLHL9DB uD)h M9AH'LDuDDHL9uD)M9lAƒ P< Lu'Dfƒ < HL9uމD)GM9L&@ƒ 7< /D)f.H|$HdH3<%(I$NHX[]A\A]A^A_\M9XAPHI9w'E^M9UL1PfD÷L(1HLӥADE H'HI9A91HL葥H=v1HL|LHQvtEDM9L1H-' A9WHI9w@M9 A H'LD H'D D, HI9wD)I$  E<1M9Lw0-DH~'HI9A9I$ HLzHtxEDM9L1@1HL+H=wsL(1HLADE1HL<_ f.H'HI9A9f1HL裣LHwtEM9L1IKL(1HL[ADEt`H.'HI9SA9J1HLH=v1HLLHwu@1HL<_EfD*M9!A< <  L1LfDIGHt$pHD$PIG HD$`HH`HHHd$H$HFpǃHMI߅9HH$H@HH99H߹7A@EHIXI9sLLIxLMwAM9AD$ t A,MmIGMHD$`"=L9%$E++P+HL9QLRL P&1DD$|HHAa}D=AHcHφD$XH HNLHke2D$X} 8d.D]HE H|$PHD$P@0AG01H$IG(DEtHD$PHH(HHP8H H HD$PHp(HH HH$H6HL$`HHt$pHvXGHH$1WAG4HE`HHHHEdHCHAG8HD$PLkH@8CHfHt$P$kH$IwHFLV@AsHD$PfDMoMMwHIXAHxI9*LLAD$ IG HCH$MƄ$IE11HD$p@T6$A;GH} L臌H$dH3<%(7OH[]A\A]A^A_AƒT/}0\9$$$$H$UH@уL\HDIS H$ACMLE`EW0EtHDAw9sH~HAG0A;G4AG0 >HLjILHD$PHt@@>@/?1H!!|!HD$8H8!HLT$0HCtHD$XLT$0HH8m3H@HCHD$@HPHD$HHD$x#|$xd.MX;AB 0.IH>BH@Ƅ$H6LT$(D$xEIHDH9HǸHEIHD$(HI$AGHD$(IG CHAGLA>2EHDH9zIiHEƄ$;@H|$'$Iꉃg IAGILD$xMW IAD$xAGAGEtF% HLyH IHAGEuILwHV&HDŽ$FH$H&HD$hHt$pHH߉L$X襱L$XHƋH2H;B9HcHB?E $ DD;D$ tLcD$ L$C:\)HcI4H;Ht$XAF6B'6LwfHl$XEILT$(D$ @H!&HDŽ$EH$H&HD$hH&DHDŽ$H$H&HD$hH&HDŽ$CH$HH&HD$h]HDŽ$HDŽ$BHD$h2H\&HDŽ$H$H&HD$hMEH)&HDŽ$H$H&HD$hH&HDŽ$H$H&HD$hH&HDŽ$H$He&HD$hoHDŽ$HDŽ$HD$hIEHHH H+ LH+HtH;Ht$PHH29F<)ELT$(lj‰$HL4; Ht$`HF xPHHD$XHvH BIHP<;Hc01^m5l$hHD$`Ht$`~4-$9G Hl$`Hߋu8{AG Lu@CHLT$XA{AG$H|$(IE77HH|$`$L|$`Ƅ$IKHMW Aw4AG<9IG@NAO0AG8HD$(IG(LPLAuIo@EHU;vH;vE H,IG@kEAG;v AGH9EAG4EAG8HD$PHt@<:t:&L &$H}M4Et$ 9t HcA:HDL)L9у~LL$XLAЅLL$XMLT$(AD$ T1$H}MIL r&LC&UfDL &Lg&у1L &L&$LMM@փ9I @HD$X,"I9AL;Hl$hMHLADD$| HL$0HHL$H$2xH9$4L$H$@IH9\$X#L9wHHl$hIG Ƅ$Ƅ$HHD$H$I_HI9$$LI|$ 1BDL;D$ HcHD&DL;h$t |$ 0T$ HDP;AFLT$(ID$ dL;$t |$ 0T$ H&DL;hL;$t |$ -LT$ HDPYL;$t |$ /T$ H&D[L;ID$ HcH&D-L;$t |$ 'T$ H&DL;$t |$ ,\T$ HDP iL;$t |$ *'T$ H.&Dk+L;YL;G$t |$ |(T$ H&DL;$t |$ ,舃T$ HDP L;$t |$ 'T$ HZ&DWL;D$ HcH,&Di$ H&IL;;$t |$ %T$ H&DL;$t |$ +|T$ HP|$ _f.L;$t |$ d%T$ H:&Dw7L;eT$ H&DNL;<$t |$ T$ H&DL;$t |$ :)}T$ HP|$ _L;$8|$ -H H6LHEHiH &HcT$ t$HHL)I9H$@D$LD$0LHt$pHH螨LH$@LT$(ID$ DD$ EL;uDL$ Eu L;$PHcD$ L '&AIL;jAD$ LT$(Aw$9sHHt$pH^H|$`IG(o<HG@AW4!IcG0H Aw09sHFIGHD$`AOAW1AGIG $xNMwLAD$ IG PLI9Aw$9sHmHt$pH蛟LHD$`x<MH|$`IHGLW(AHD$`0IGMH$B]DT$ E|$  HL)H%D\$ E3|$ HAWL9|$ |$ H$L9p H$HteIw H^tPI(H9$s*)#H1H;HCH$HF(IG HDŽ$H$IGHH$!H@ H$L9 D$ A~ Aw(IGVAW(IG@Ht$PLHtVIƄ$ IGHHD$`IG(n<HF@AW4IcG0H Aw$9sHIGHD$`IHt$pH觛Ht$`HV F<R9=Ht$`FeL$L$H$@H=tH$thHT$0H$E1$A HL$L$EhHL$L$tH0F H@ 1H$8HDŽ$0A2AHT$8HL$@HL$L$oHH$@L$L$vIH=v?H=v5H=v+H=v!H=vHH9H҃HH)$8HT$8H$DD$|H$ H$HL$L$cH$0H$@H)$8H$HDŽ$0L$L$:H$8uHL$@HT$8E1LAHL$L$gML$H$@HH &L$AH$0H=HHIIIHL$L$C0L$L$H _&D$XD$ >D$XHICf8nI{(HHH|$(Io0AG$AG(AGI8$A,SH@AW  fxƄ$LAMW0x f HdދIL;IG@@=tA9G(uHI9wlELTAzOIBLDLH)H;HDD$xEAw(IABII9]ID$xDIG Mw(ALT$(?AG0AwLIG IAO9L9r)A9uf.II9w A9t9uD)t$XI9yt$X8LAGtpAO0HCH,HLHHL$ HL$ )LEAWH+HLHAWHD$PHt@IrV w@ t$ t9HPB<t,IHPH$@IrH?I1LHLT$0(FLT$0HAB *pD$ HV\tHD$`@HDŽ$%I(H9$s*eH ~H$HF(H$H&H@ Ƅ$H$ѶD$xFH H$H>UHJH52HH#H Ƅ$cD1IHǀHIH*1H}HH$HH$H HHHƄ$ IB80$H H$T$h8ZH$HD$XT$h_D$XDǃAI$EG(E'H5DoP1H&AGAG4Hy zAG4@HLHHL$ ,HL$ AF<<mA~bfAF< <FA~;A~+A~@LHD$hЅHHt$pE1E1LHHqdAB \A~  I@H  1LHMFH=g XH1LHHL$X'FHL$X1Qu1LH F<_=H ; 1LHEH= WH1LHHL$XEHL$XAf fH $ 1LHEH= TWH1LHHL$X_EHL$XAf ?@A~uH ` 1LH EH=' VH1LHHL$XDHL$XAf @H 1LHDH=]|VH1LHHL$XDHL$XиQk1LHcD<_TfLT$(D$xƄ$鶲ELH+H D )ѺHHHc "AG0l$hAW4HD$`2A~AFIVIHHl$hH HQHkOHDH5ÆHEHLH I9B-< %LrBfDH  1LHCH= TH1LHHL$XBHL$XAf H HHNHDH5HDHH DA~ůK1LHsBHHZH@ L¹HLD$XHLD$XAL &E4HMI9r)4fAH&IHL9H0 LH7HuHfD<6H &HcAGEHHuG-HHfW AFHAFIVA_IfWҾLT$(D$xf.P(Dˆ$闯HHW<@ rLLT$ H'LT$ AB HA+G$ZDD$|1ɺ LHLT$XCLT$XAGAGHHl$h鯭HGLHAH5H ?H(H !HLH|AH5HmHH LHH &HcAGLֺH LT$($D$xAHҜ&AGAGHHl$h׬H5H1V1rHLT$ 4FLT$ HLֹH%H$@H]HKH@H5HH=H;HJH[@H5HH5n~H;HA$uIfUH&A  IɃu1X$AMƄ$D$ MW0HH1A~Ѵ釩AFM7MnXHF(AF:t:I$H+IVpI$HIF`HIFdHAF`AFdǃIFpHANP9wQIHHH*Xrf.tH4I5HANPt9HH; ~'H@H9 |IU$HHDsH~HE(HtI$1D;sHmH[]A\A]A^A_fDHcWHLJB;GLH`BHs@H߉CHHcA HHHA@HcCHHs\HS@HKHH`I HcCHHS@HKHH,H`HcB HHHBHH+SHP%GCXC\HMHHhHFHHH9Hh1Hq HhHHH`HhHp)HhH@HHhHPH2Ht$FoFnHhHPHEHt@HHu~ HHxgH:HH@H5LH߉?HHH H@8H4€~ 9AGHHP8H L'< 6't!Ht$@HHLTH$HI9H$w1H$dH3<%(nHH[]A\A]A^A_À|$g.H$H9D$(H$w+D< t-H$HH9D$(H$v uυt!Ht$@HHL므|$gH$7(H9D$(H$Ld$(p@vTAFXHLAF\HHLHHhK D)C LT$0L\$8>HCHD$H1$tIE HHBHD$pH;$H$IMLt$XH$H$H$H$H$H$H$H|$X, 7L$1L;t$(HDŽ$$HDŽ$HDŽ$IT$HD$0HD$xXfIIIуAft@Iu0H@H+PH1Ht$PHD$HHH;D$0rH|$0uHD$0G1҉D$8Ht$PHD$HL4Ћ$Q 0AHDŽ$H$IUBIT$E1"f.It$AHHL }ftEM8qD)xA;usMMHcI49^utL$E @L;t$(|$8AII 1|$g3AAIkHT 3|$gz8HM&H-&E#L|$(ICHD$8DAHD$0H$HcIH|$@&8A[D,2D86HH$I9HD$(s.@A8t'H$HI9H$H8uH|$0tDHt$8ՅtH|$@tHT$(Ht$@LtH$T|$g3!H&H-R&|$gH$$H9D$(H$w6f5H9L$(AH$MwS fDEt!Ht$@HHLAH$HHH9L$(H$A?^ЃуADuAH|$(H;$H$nLd$(Ll$@؅tMHLLsH$HI9H$w|$gG$H$H9 0BL-t&H-w&A\D|LH9T$(Q*H$H|$0Wf.Ht$@HBHT$0L-LH$H$D|LH9T$()AD9u빀|$g$HH$H9.~,HL!AH-v&A1HELT=G$HcH$E1I +H$DlJ*H9D$((H$OHt$@HHL LH$H$DlJ(H9T$((HI LHD9uD맃|$g$HH$H9-},HL AH-u&A1HELT=AN%L<m&HB8u 1A_I ,H$DlJ.H9D$(&H$HD$0&H$L81L1AW 9 Ht$@HHT$0LLH$H$DlJ.H9D$( &1LH=jH$1LLHl|$g"HH$H9+*|,HLAH-t&A1HELT#=H%HcH%E1I *H$DlJ*H9D$(_%H$OHt$@HOHLLL+LH$H$Dl5J4(I9\r@wĀxu@X<@낀xxI9LBPH$H-f&L|$(Dl J *I9< Hѿ@< L$@ <<<<Dtttgt!Ht$@H6LL#LH$H$DlJ)I9T< @< @ r빀yuy@yyhA<<Ry@EA< <1y@$fH$H9D$(L-b&H$Ld$(ADuOt!Ht$@H'HLH$HI9H$TADtH$H-e&DdJ&H9D$(H$AHD$0H$L81LAGf Et#Ht$@H]HT$0LHALH$H$DdJ&H9D$(y1LpH=`H$1LRLHlAH-d&L|$(Dl J (I9JL$vO1ɀthȄu9LH$H$Dl J (I9Jwt!Ht$@H9LL&룀xu@X<넀xzH$H-;c&DdJ&H9D$(:H$AHD$0H$L81L 1AWEt#Ht$@H~HT$0LiALH$H$DdJ&H9D$(1LH=bH$1LsLHlAH$1LC<_@H$H-b&L|$(Dl J *I9 < L$Ht_< t[<<H$L&H$H9D$(lL-[[&H$Ld$(ADuOt!Ht$@HHL\H$HI9H$ADtED$Q HHDD$$H)HHPLPffH|$H@ HJ,<u4z, iHBHH9B WHD$@ %=?L+l$0HT$IHt$H$ELC .HItHD$@;tHD$HL+pLt$0H$HHL0~fD|$@Dt$8H|$H@ HJ,<5@DD$$Enfu+HD$@Tu HD$HHt@ uHD$(H9D$0AE@AmDM9D$8|$#EmXHD$H@H|$W )A$tHT$(Ht$LT)DŽ$D9DM1Dl$@Ll$(DHL$H@ HJ,fLLH>IDŽ$Lc|$8L|$(L|$P&IxHHL$H+L$PH@HcH9}HcH9nH9=H\$H{H\$P8DLD$8IcH\$`IH\ H|$(HD$E1@IM3HUHLL)B D9}EAAEHL$I)Ā|$(Ld$L$te-H$H9D$Lh!&A HH$LLH蒉t H$H9D$HHH$LLH\tHy0|$(HHHMHLQ(D)HIMI)MJL9L$$HQLLLT$@HL$8LD$0LL$@LL$LD$0HL$8LT$@teL9T$|$PvLHLLT$LT$wH$Lֹ"HLT$LT$I M@H$H+L$L$Ht$E1L$H,HIt9E;HL$HD$H$H+AH$HL$|$(u%HHlHEHHHHL$8DDD$0HIHHL$8uHHiHEHHHHL$8H5+&H={1E1i@f.H(1DT$8HD$ED$HD$0H$H(Df.SH4HH[XAWIAVIAUATUSHHX$H$H|$LD$D$ D$$dH%(HD$H1}TM HI)LL$D$4L臦Ll$8ILl$4HD$8H|$E1LHHHD$(*HT$8ILL$Ht@H H5&|$$Ht$HuiIID$MID@ID$MWMIDH|$HdH3<%(gHX[]A\A]A^A_D1}oD$ fDD$ It@HYHT$(H|$LE1LH)HLL$D$4HD$81<qGgC@wKQ?y@thW vD@tn@SKG9KQ?'KyKFKKAUIATIUH,SHHp<LHEHH)[HLA]A\A]鶜fDHF HHiAVHMAUIATIUSvfH-T%HIDLII9sHX[]A\A]A^A_@I$ HL\$(!y L\$(e@HT$8LoIHD$8HH5kLL1 {fA$B<D|$$EDAAC;H<D|$$C;*fI$ H߉L$(\rL$(1LL\$(\HL\$( LL\$(\HL\$(J}gE1Df.AWH E11AAVAUATUSHHHnD$HD$$ HdH%(H$1ӅH cE11AHHD$HD$$ HD$@虅H JE11AHHD$HD$I$ aH 2UE11HD$HD$$ AHI)I6IF %HFIuF HD$P0HLh I4$LHHD$`F $HH@ HD$0H }bE11HAHD$HD$$ 蠄 HHIHD$8t I+HHE HL$L`襍HIL跁H$HD$ 6H(Hc$H$H߹ @uHHHxHT$ LLHpHIAE 5IEIUE1A LHHH$OHv HHIEIUIA$LHHH$H9H5'hH1EwDI H5wgLH1"wfH$HD$ H$HD$(LH^HL$ HT$(LHoHIuMt"AGAGu LH荐H|$@H7F HH@H$HHzH|$HH|$HHH9HD$X61H|$`AD$`H$HD$xH$HD$pH$HD$hH$HD$@HD$PLt$XHLL$xLD$pHL$hHt$HHD$D$`L$LI9HD$HH$H;$HD$ Lt$@H$1HLkHt$8HE1L)$A LH.HL E1E11BHH@ H;$EDHH@ H;D$ EHLH\HH91ɉLHHHQ uHHHL$(EWHL$(Q H;$EDnHHWH;D$ eAE_fH|$0H$tH9D$0v HH$HD$ HD$ H9$HD$HH9D$XH$dH3<%(HD$8H[]A\A]A^A_fDEuH$HKLHHsETHt$ H'LHHs4 HHT$@Ht$8I$A$HI0HfH5idH1_sE1LHL|$HL|$8ZA9  H葈1DLHIރHHtHE1A LHHHJHP$蝇HHEbHMA$LHHJHP$jH[1TD1ɉLHYH H1H߃HpHHHPPHHLHHirLHY9~ALHYA9L|$H7LHPH|$@H7F pH$HeHD$HH$d1ҹHeIuHD$PF H%TIHTHD$0Q_H5 bH1~qHPH5bH1iqfAWH E11AAVAUATUSHHdH%(HD$x1HFD$HD$$ D$wHIHD$( }H ;ZE11ALHD$HD$H$ |H BAE11ALHD$HD$I$ |H YE11ALHD$HD$I$ a|H YE11LD$HD$$ A HHD$@'|IuHD$HF L~I4$F HH@ HD$ HD$ HHD$0HE@ JHHhLjNd-HE1 fHxI ^HuA$< t ILHI[L9HD$Ps|E1HD$`H|$0Ll$hHD$8HD$XAHD$0(HL$`HT$XHHt$P9pI9HD$Pv,LD$8HL$0HL|$D4$MLH[I9HsHD$HHt H0F HHx HT$@H2F gHLpLt$hHL`HD$PMHD$0M9sSA,$Ml$@ tsM LM)Le@-tw@+tq@!tk@&teHtL`M9rHT$xdH3%(HD$PuHĈ[]A\A]A^A_DM9tIAm@ ufDHWIL`M)Ht$(E1LA DH$bIHH ->E11AHHpD$HD$$ yH0F HH@ HL$ H9HIuHna@&Iv?@+tJ@-u#LD$0Ht$PHH fLHK`@!uHH?eLD$0Ht$P1LH~fDH#OLfDLD$0Ht$P1HH葀ME1Hl$wMA|$ IfHT$hH`Lt$hIHNHD$ 3f1H_IfHSNH Ht$PHLHT$ H5\HH1keYDAWIAVIAUIATUHSHh$DD$(DL$,D$HH$HD$@$D$LdH%(HD$X1H(H9HD$ lHM&WLHHD$0W1ɉHLHD$8ZHI`H@HH@(L@ HHBIXM+fHILbHHRIVHH HIH IN HH HIHIHI`IX腄LgLyI Ht H TE1AHLSHIHIFpIHI;FxIFp'HI+VHIF H)H'HT$0HLH(gHT$8HCLLfLkHCL臈HcT$(HCHL裆LkHcT$,HHL舆IIHPH2HLfMHLLH\$ tIHPIHHtCIHFH8HWG DHHHHP1HHtEE-LPI`IHJH IXI+FHHHBHH@IFHHHRHIV HHHRHIIHI`IXIPH9C t HSz tN`|$HU1H\$XdH3%(:Hh[]A\A]A^A_:H\$ |$(HuH;\$ HD$PLcH E11D$HD$$ ALLssHtHHD$PHt$@Ht*HT$PHsLD$P1L1x|$L@@HIHFH8HHHLqHH޹LmIHDHLuEHLaI ƀ2fDHLMAP<7H5PLwcHL~DHҸ?IHFHHH@80@LhzIFpH1L{H@H0Q1L^H@IH8HVH:Hz1L/H@IHHV@ H:`HG uG HHfWf.B(DCfD LiI`HPI`HBL~IHPH2HnLaaILHdHT$0HLAƆ观1H¾1L3iIHFH8H*G }HyHH7HP1HHtCC5LLf.HL1 XHD$PHHHx 1L^H@IHHV@ H:uH=1L0H@IHHV@ H:HuL1H@H8HLBUL1H@H8!f.L1H@H8f.E11fDHD$PHsH E11D$$$ALHD$nHH5aSL1bIHFH8H{HHLnm$LoH E11D$HD$A $$LLnHmDHL@L1~H@H8HL{ LwLHIvHHD$@HD$PqL1K~H@H8UHҸDIHFHHH@80H1L}H@H0y1L}H@IH8HVH:H1L}H@IHHV@ H:HtNG u/G H1HfWf.B(DsHHHx Z1L=}H@IHHV@ H:uHu1L}H@IHHV@ H:oHuL1|H@H8HLn?1L|H@HL1|H@H8oL1|H@H8qL1p|H@H8 _MH58QHL1_L1A|H@H8I`Htx t_tH H fGf.UH1SHH(HdH%(HD$1ZSHHooHL$dH3 %(uH([]J;Pf.>_tH H F8f.H H F f.H H Ff.H H Ff.H H mFf.UH1SHH(HdH%(HD$1JRHHAHL$dH3 %(uH([]I\f.H H E-f.UH1SHH(HdH%(HD$1QHH/;HL$dH3 %(uH([]SI=f.H H Ef.UH1SHH(HdH%(HD$1JQHHkHL$dH3 %(uH([]H]f.H H E-f.UH1SHH(HdH%(HD$1PHHBHL$dH3 %(uH([]SH Lf.H H Df.UH1SHH(HdH%(HD$1JPHHo^HL$dH3 %(uH([]G;pf.H H "D-f.UH1SHH(HdH%(HD$1OHHOhHL$dH3 %(uH([]SG8f.H H Cf.UH1SHH(HdH%(HD$1JOHH?uHL$dH3 %(uH([]FLf.H H 2C-f.UH1SHH(HdH%(HD$1NHH/sHL$dH3 %(uH([]SFif.H H Bf.UH1SHH(HdH%(HD$1JNHHooHL$dH3 %(uH([]ETf.H H CB-f.H( H 'B f.H0 H Bf.H8 H Af.H@ H Af.HH H Af.HP H Amf.HX H AMf.H` H A-f.Hh H tA f.Hp H ZAf.H H FAf.AWMAVAUIATUSHHXHT$1LL$dH%(HD$H1L$HD$(gdH=HvH=H=4Ld$01HHLLI?M1LHwHHE1$A LHHYjHH0HF HLrLt$(HIHpH|$L0SMtUMtMu1MtHt$1HicHL$HdH3 %(HX[]A\A]A^A_fDLt$(MuI7Ht#LH~9HLt$(MuL|$1HHLJL)HD$(I^fDHHHHHHH9Ƀ2H LHsHF f%f=o@H=%%H HEI2H1BfD0HKHsHF f%f=oH%%H HEI0H13BjfDHT$("HFGLt$(HILt$1HLOIL)HD$(I$L|$1HHL#IL)HD$(I#HT$H(H5E1AH,`IHCt3HHHL$HlCt&HHHL$H%Hx }H%Hx )@fATIUHSHHHvFH1HIHH<Lx L <LHHH$HqH[]A\fDHAS[]A\=<f.H8HT$HL$dH%(HD$(1 lHT$(dH3%(uH8fD[?f.ATIUHSHHHvFH1HyGH?<L L ,<LHHH$HpH[]A\fDHAs[]A\m;f.H8HT$HL$dH%(HD$(1ZHT$(dH3%(uH8fD>f.ATUHSHHHw)H2%Hc0x_HH[]A\DH1HIFHZ;M$ L F;HHHH$LoH[]A\@ƒ?ʀSHH[]A\H8HT$HL$dH%(HD$(1[oHT$(dH3%(uH8fD=f.AUEATIUHSHHHvQ1HHEH:1EL L :LHEHHH$HoH[]A\A]fDHE[]A\A]=kf.AWIEAVIAUMATIUHSHxiE,HHcHv>Uƒ?ʀUIMtAEH[]A\A]A^A_EI@؃Uƒ?ʀUIMtAEH[]A\A]A^A_EI@؃L$ wLLHL$H2H0L151Ff.42LL$ >L$ LLHL=$H8H2L1451@CUH@Hp Hƺ H!UH@Hp H+H5ƅHQvHT$ "H,Ld$ H%f.@@f.H(dH%(HD$1HD$0HD$HD$dH3%(uH(x%@f.1f.SHHHtHPD(u HSH5++H1J1[u1[Df.f.@HHOpHHQHWpHc HWHH4 HHH)H2HF tMHvuDF < u=u H@HHOHHf.HXHHOHHH5f*16ff.AWAVL5AUATUSHH(HWpL/dH%(HD$1$HBLHGpLc"HGIJ IL$H)HHcHI)HL:HD$AG twVLHJHtbLHW,HHAIuwHT$H=#*LHHNH9tT $LH߃@%LHH2(3HXTIHLH@LHRtMeIHD$dH3%(L+H([]A\A]A^A_NL AA <$L5H2HLL$H $w/H $LL$HCJD H@HH@HHHHRHtHH%vL2MIHcRHT$HH@HDHH@tHHtvHcBD tkM$ IA@  DHKH1F tKHH@HD$HLp@ Mω$$$ HD$E1M$DHT$HL $z'IHCL $JD I HH 1DE11!fATUSHGpHH HPHWp(HcHILg~@HHc>I$HkH+[]A\ATUSHGpHH HPHWp(HcHILg.@HH>I$HkH+[]A\AWAVEAUIATIUHSHH(F tHH[1HHOHtLH?,¸CFHHfDH1H9HHHHPHCHT(HVLz(M!E1D$AHD$$AMLLH=HtH([]A\A]A^A_f.DDLH?!H1@t>HH@HIHLHHt&IHHuHt HfLcBHJLHFL 1҉D$HD$$=HHfDH(1[]A\A]A^A_HP)AUIATIUSHHDB dH%(HD$1AtNHHRHHH $LL A ADE9Ht$dH34%(u,H[]A\A]@HH#DC HH $@f.ATIUHHSH;HHL[]A\E1H9AWAVAUATUSHH(HWpH/HBHGpLc"HGIJ Jt Mt$H)HF HF@fHL(MtGH $E11D$HD$A$ LH;Ht Hx L(H,~sHKHMD$Jl!M1AEt&IEHHIEHDHHt pHʅtHH5'HH1.1I6I/MD$AG <HCN| HCJDHH([]A\A]A^A_fH@HH*B <HHT$LHT$IHƹH9LH|(tHA"LH1҄1LH_J1IG@ 9H!LHLD$LD$LsLH HH8LD$I@HB@ #4f.HHLD$'LD$t Hp!HHLD$@LD$u#HHLD$W#HH8LD$HLHHLD$LD$9HuHm#E1H$A,AHLHto HH7HHIHH71AEt&IMHqIMHLH1Ht IHtHH5%HMH1,- HHB7HHI H53$1+JT!H5$H1+@f.AUAATIUHHSHHHHH[]LEHA\A]T5@AUIATUHSHHL'eEHs\HKCXC\M LZ!uHEHxHH%HLH+HCpHH;CxHCp!LH+SHHC L)H{Il$Ml$H5IHL#'H HƺH"CHH0HcF ^HHx @ŋC\9CXH.H[]A\A]ÐE %@ =@ tQH 1H[]A\A]@HH}5M HE@ tfDHEHxfDHHH@HG1HHXH@HDILkL+[]A\A]A^@H01E HS<N4*XHMA pHHe"DAUATUSHHHWpHHJHOpHc*HOHH)H)HpLd)AD$ <tHunt)I$HxtL1H,L(HaDAD$ %@ =@ HCH(HT(HCHD(HH[]A\A]@ID$L(Le@t-HH0HLetHC1HHT( Htx tuHCLl(HCJD HH[]A\A]DL/AD$ < IT$B FhI$Hx H@HHp8HH.IhH fAWAVAUATUSHH(HWpL'dH%(HD$1HBLHGpLc:HGIJ8H)HJt8HcNt8HMoI)LkIuF HH@HD$IEHxH|$Dh A cAF <FNLH1HT$Ht$H= HHHNH9t!Ht$DH߃&HHHHHI-I$L#HD$dH3%(H([]A\A]A^A_HCJD8H@HH@HHHHRHtHHvHHH|$HcRHT$HH@HTHHtuRtHHtfHcPA D ODIF@ HO@HrHHI%6HD$HD$E1SfDH:HCHD$1H@HT$HHD$HCJD8HH 1 DH?IHCJt8F t&HNH#LH1N;f"1HaHH+f.ATUSHH?HCpHKIHPHSpHcHHI)LH~nHlHHH)IHHt=HsHHHt'HuHIHH)+I$L#[]A\H5LH1H1Hf.ATUSHH?HCpHKIHPHSpHcHHI)LH~nHlHHH)IHHt=HHHt'HuHI3HHi*I$L#[]A\H5H1HqHf.ATUSHH?HCpHKIHPHSpHcHHI)LH~nHlHHH)IHH.t=HHHt'HuHI HH)I$L#[]A\H5H1<HH=f.AVAUATUSHGpHHHPHWpLc HWHIJ"H)HHJl"HHHH)HIfXH'HH>HCLuJt Jl F HHHL` U HHHHH(MHuLuHLHI}HHcR8HHW(IEL+[]A\A]A^HHHIu_H6HH xU EHEH@ 6H5mHHH5H1UHHVfDATUSHGpHHHPHWpHc(HWHHH*H)HHHHt*HHH)IHCHJHHt(tvHCH55mHIHD(Hh9HH&HHHH&HHHHHc6HH&I$L#[]A\H5H1BHHCUSHHHWpHHJHOpHc*HOHH)H)H~>Ht)tHCHUHHt((u$H5SH1H5@H5H1Df.ATUSHHHWpHHJHOpHc*HOHH)H)HHt)LeHCHHHt(ytyHCHE1AHHD(Hp$.HHCt#HXHT(LcL#H[]A\H@HT(LcL#H[]A\H5+H1H6Df.ATUSHHHWpHHJHOpHc*HOHH)H)HHt)LeHCH HHt(ityHCHE1AHHD(Hp$-HHCt#HXHT(LcL#H[]A\H@HT(LcL#H[]A\H5 H1H& Df.ATHUSHOpHHQHWpHc)HWHH *H)HueHHL"AD$ u9 uH@HHkH+[]A\@HXHHkH+[]A\fL#HAD$ HSH%9@f.ATUSHHHWpdH%(HD$1HHJHOpHc*HOHH)H)HLd)AT$ I$I|$H@H$ u;HCHXHT(HCHD(HHD$dH3%(uhH[]A\fDH4$W)uHCH@HT(HCHD(HDH"L AT$ HpH8rfUSHHHWpHHJHOpHc*HOHH)H)HuHt)HkH+H[]H7ifATUSHWpHHHJHOpHcHOHH<H)Hu_HlLbE % =t1HHHH-LHKHXH@HDHLcL#[]A\H 7HAUATUSHHHWpHHJHOpLc"HWA|$IJ "H)HHCLcJt"@#t^HPHCH,1ɺHHHHLcA2E@t HH`Il$HCJHH[]A\A]DHHt$3Ht$HH46Hf.AUATUSHHHWpHHJHOpHcHOHH<H)HxHjLlLb~`HtF t]H1ҋ@ LHHkHXH@HDHUHCJD HH[]A\A]f.1@H1҅HHAUIATUSHHHGpH/HPHWpHcHWHH HtL`H)HF tHHtH@AHwHfArHF80DE]t#HHx EAA:t#HfWf.@(zA@H HKuHHDf.AWAVAUATUSHHHWpL7HBLHGpLc"HGIJ H)HGHHtHJ8H L,A} t,H(JT HCJD HH[]A\A]A^A_DA Hc11HLHI)L3IEH@ P@HHD$L;HD$HLhL:A1,IH߃Mg@I1 A9IGM1ɉLHHI<HC L)HLLHL $L $IJt H"F tYHHH@HA MfHL$AtDAtIL#H[]A\A]A^A_t?HHx HCkHt$HCHHFtHfWf.@(f`[HFAHD3HF80&!H5H1Hf.AWAVAUATUSHH(L'dH%(HD$1HGpLHPHWpHc(HWHH*H)HHHt*I-IHCMP"B<vtrHteLHHHHS IL)H3Ml$HCHD(HHD$dH3%(bH([]A\A]A^A_ID@8D%Ll$E1H EmfDAt B|4IHyfA@uIAO H HIwHHPHS IL)HMD$HC M|$L)HLLHIǹLLHIIGHCHD(H@LLHIDAH55JLl$LLbID@8fD@"Pva<t HuPHCH(HT(HCHD(H-LLHHD$LD$IHCH@HT(HCHD(HAH50AH5EAH5AI AH54WHf.ATUHSHc%LHSLCH 2H3E1HHL9rHH5PHVH1HHBHHHx@sHH HH@Hf`\[]A\Ht3HHt+MtA@u`1DH1fDH1f.1f.HHtHHt@ff.HtHHt@ ff.HtHHtHf.HFhHHc@ HH@ H@@HHP HBH+BHH@ H@@HHP HBH+BSHHC Ht[ÐH{@Hu HC@ f aHHC tHC0HC([fDHCHHC@HC fDUHSHH]H{ HtHSHH9tHD$rHD$HC HC(HC0HUbH[]H1x n@f.UHSHHH5HHHC@Lu;H;GuBGtHHH;HuH_H[]H H;GuH6H1[]f.AWIAVAUATUSHHFpI1IIHDh @% =t.HH[]A\A]A^A_DuDALuQHLD3HHxuHtI1ہH tIHLLtHfDAWIAVAUATUSHHFpIIHIDh fDuADHt E1ADt@utCrF+fatF+rwfDAVAUATUSHH$HH$PH$XL$`L$ht@)$p)$)$)$)$)$)$)$IdH%(H$81HX[%;H-\%H$ H$@D$D$0HL$ Ht$(UuEЅ;Ld$0HPL LLHP0@$HLEH$1=LcLL$L)K<,MHHHH9}J(L:H$8dH3%(u}H[]A\A]A^AA95AA9H=H8HǺA1bE%H=v1H=1yfUSHHHOpHHQHWpHc HWHH4 HiH)Ht!Ht F t/HvH="1HSHD*HH[]f."1HDf.SH H Ht=HH @H9t#H H8u@H@H@[@H뻾 @THtHP H@0H@(HP8H[1[ff.H  HHÐATHUHSH.IH~HtWH~~K1҉VtNH}HH;]}(HHHtHtVuL`fD[H]A\LHH}f[]A\Ðf.ATIUHSHHNHvH9}.HCHQHHHHSL HhtE[]A\fDH{HHsHt7HxjH*X}f.]H^HKHC@HxSH*XFf.&wVHHXHKHCYHHHH H*XfDHHHH H*XH5OX%H=1ifAWAVAUATUHSHHHHT$tyIjH}I~pHۻAfHLLHHH;E}EIIMxLHUEHJtHtHT$HLLHHUE1fDHL[]A\A]A^A_@f.AVL AUIATIUSHLJ HH( I$( H0 LLI$ I$0 tdH=G1HLM6Mt?I^ IDH;tL1HLJH H9uM6Mu[]A\A]A^þ @I$ ATUSH.HHtgHEIHHtHPH=1HiHEHtH@(Ht HLHu HC@tH@HH@[]A\DHEHH[]A\mf.HHt7HHt/HPHtBu1H@`1HfHUHSHHH{ Ht HSHH9tHt$Ht$HC H#H1[]f.HP@u1fHP1Hf.AVAUATI USHHdH%(HD$1TMHI$HH$I1H.H $IHIHLA@M11LHAILHHLHHH$HߋpHHHdH$HHH$tDHBHt HpHfH $L(HIHlfDL(w@H|$dH3<%(Hu H[]A\A]A^f.AWHHAVAUATUHSH8HL$H H|$Ht$HD$(HL$ SHD$H( L`M~=LpE1fIHt$HLkLu A|-)IIM9űD$8HL$Hp%H0 HHx  #Lt$H5\LHt$HLHH5<1ɺLI`LIHt$ LMtHt$(LAGMHD$E11H1MHƀ H1H\HD$H|$HfHT$H={ HىH8H[]A\A]A^A_HT$H= 1H81[]A\A]A^A_H5 H1AT UHH5O SHPHHIHHHLH[]A\%DAUATUSHHH/dH%(HD$1HGpHPHWpLc HWIJ"H)HRJD"H0F HHRH$HLh1ɃujH$ILHLHkHH(tHHHHHHULcHD$dH3%(L#H[]A\A]ÐHCJt HtF tRHHtH@Hd0HYHF1ɀ80HfH"I*u#t6HfW1ҹf.@(DH1Hx fDH;H5D1UHSHHH( Ht(HH1HsHH[]H=; 1HH( Df.AWIAVAUATIUH(SHH(Ht3At+H VN% @IAЋu<:tu1H([]A\A]A^A_ÀMDIAEDuE1E1<(LtM9MzMuLLh(t*~0)\u xLhtLLh(uփLuIMH> L)L1|H([]A\A]A^A_L)ƹLHHt$LLD$LL$HILD$LT$MLL$trLLLHIt\HLHLAFt3AFLLL)ILLVHLHL蠿DH# 1<'H L$L"DL1A`Kf.ATIUHSHL%HtEHsH=1HsH11[H(HL]A\Hf.H N%HHwHFUSHHHHxH;S|HtDHH[]f.HCHH=<HH(HP1OHCH(H[]H5A 1"fATUSH0 HHt-Hx~[]A\ÐHHH0 []A\f1퀿H)L%L%H0 HL萿H59K%H聿H5L%HrH5kK%HcH5K%HTH5J%HEH5&M%H6H57K%H'It$11HH0 H(HHMHH0 t9HHFH0 f.H=TH @HH0 @HaI%SH H5HHH0J%H [H5@UHSHyXH BJ%HHc[HH]@f.AWAVIAUATIUSHHH HHzHMHHHHItqHEI_H MH=MIEHIHEIGL}1HSIGH@ HILLHLHtiHL2fH1[]A\A]A^A_HtH HRMH=IE1CHC HtILLHLHuHH[]A\A]A^A_LH4H5UA1LH H5[HA L1AWIAVAUMATIUHSLHM9HT$}Pf1HHLHIt&HHMHL$ILLLWHt"HL9uH1[]A\A]A^A_H[]A\A]A^A_ff.AVIAUATIUHSHHHMu1H[]A\A]A^fDHtH HHHItLH9MME1LLLHx@ATHMIUHIMESH6LHt HvHtHFH=AHH1$HtH1HL[]A\fHyF%E11HL[H]A\Ðf.HHt7HHt/H@HtH@HHt HfD HfD蛻 @f.HtH6HtHڹHHHHHtGHHt?H@HtH@hHt HHHf HHt?HHt7H@HtH@pHt HfD軺fD裺 fDHHtGHHt?H@HtH@xHt H[HHf; AWAVAUIATUSHHt8HHH@HH1HtH[]A\A]A^A_L 1AM?Mt;I_ MDH;tHLAEH L9uM?MuH[]A\A]A^A_1H=1]h gAVH1AUL ATUSHH=MmMtKIm MfIIHtHPHtBu&IIHuH L9uMmMu[]A\A]A^HrH=51LHLHHfDUSHHHt"H>tHHH1H[]HAUIATUSHHH>ILEI]Ht0HCHLHt\H@8HtSHulHEH9tSHHuIEHtRH@HHtHPH=\L1H1[]A\A][H]DHHuDHH[]A\A]@f.AVAAUIATIUHSwHcHtH[]A\A]A^HEDLL`HuHcHuHmLH|HE8H[]A\A]A^ff.ATUHSHSHC8  t!HK Ht HS0H)H[]A\fIHuL HC8fDH1HAUAATIUHSHHDLHHHH[]A\A]AUL ATIUSH@MmMtt@f.HHt7HHt/H@HtHHt H@H軳 HHt#HHtH@HtH1DHt3H1Ht!B@tHRHt1H@fD1DHt+HHt#H@HtHtHÐ1f.Ht#HHtH@HtH1DHHt?HHt7H@HtHHt H@蛲1HfD胲 f.AWAVAUIATUHSHL>AWMI_ H\$DIO0H9s#H)HLHH~xIO0HH9rE1H+\$I_8IW IW(IW0IUbMI<$LHMcHIDH[]A\A]A^A_fuLHSIEAHlDE1a IO0HHH)IW8I;O(IW8=MtI?t1LHt3IW8IO0H)HIG81OHIc[]A\A]A^A_MeHL?IG8fDHHPPHt  H@P@AWIAVIAUIATIUSHH.EHE HIUBH]@HHE(HE0IEHHE@H)E8L9~MIIHHK4'HHH}0HH9H}0tHIEI)܁`MtLLLL~HHH[]A\A]A^A_fH]0H)x@LLeHE H,1@ fDAVAUIATIUHSH׷Hp;%H HHE1IHHHHLLLp8[]A\A]A^HHt7HHt/H@HtH@`Ht HH HHfAWAVAUIATUSH(HH|$HHt$HT$Hh HD$LeLML)M1I)HEIL9uk0D9ucHIt3IGt/HDA9tHT$Ht$LH|$HH(H[]A\A]A^A_@1MtM@Hp1f.AUIATUSHdH%(HD$1HFPuhHI@Hh tHucHct/z8Hu"A$LtLLtHHL$dH3 %(ukH[]A\A]fDLPtHT$LL\$#Ht)Hs9HH<0fifAWIAVIAUATIUSHH.H<$H} HP(\MMHD$u3of.H]0LE LE@L9MIPH] H+]0H]@L9~MIIM9vI<LL)I9HFށHۉPtH}0HLI)IH\$H]0M9H]0yH<$Ld@O,'M9r5fIM9&A} uH<$L0IfE1HL[]A\A]A^A_ILl$PtH<$L9H<$L$uIPN褲IWE1fDSHH{ t HC0[sHC0[f.UHSHHH{ Ht1BtHC(H+C0H[]+HUDSHHS HtHC([H)f.HS HC([H)@f.USHHH.H} tHU0HHH[]HT$覱HT$Df.H~ FfDۿf.AUATIUHSHHHCPHt HCPHC@*L, HC H#HUBH.Hs0LC I9LHyH)-DLFLC0NHHtMHs0LC HHL9vp : uHNI9HNHK0F wHK0HHqHs0A HufH[]A\A]DHC@HC0HC(HEHHC@H)C8<@HH[]A\A]f.HLHL$耾HL$fDHHL[]A\A]HLHL$HC HL$HH1[]A\A]ff.AUIATUHSHHH{ IAT$1t@IT$Pu&HHBH+C0H[]A\A]f.H: uHC(H9s: t[HH9rIT$P@HC0H9wwHC Hk@HHC0HLHK HC@HQHS HS0A uHC(HJH9sz tKHDHC(N軮LefIT$PHH+C0*HS0= IT$PfUHSHHH{ tUHHCPt4HtH9v HHCPHS0HEHH[]DHt3HPH9S(t1H)@HL$H$ HL$H$HS(f8 HDAWAVIAUATIUHSHHS@6H{ H>E1L| L9LC ILC@PfDHK0L9|IE%DHQHS0PHK0L9sFI9vtHx HPIuHqI9HQHS0 HS0HJHK0 IBtLLXM9ILC LC@H`IH)IŋRt LLHL[]A\A]A^A_LLHT$HT$IHH[]A\A]A^A_HL$dIHL$PII)PfDHHt?HHt7H@HtHHt H[fDC fDHHt?HHt7H@HtHHt H@1HfD f.HHt?HHt7H@HtHHt H蛣fD胣 fDHHtGHHt?H@HtHHtHcH13H HHHt7HHt/H@HtHHt HcHۢHˢ HHHtXHHtPR tatHH@+@truHHHtHNwDHfHHAMAtIt @AH蛟x 蠤uDH3H>tHkHtIG8HHH[]LLMA\A]A^A_HHff.UHSHHHH@HHt"H HtH=+%H9ytAtJH[]@q@t5HtHHt BtIHHHD$HD$@@qH fSHH HqR@ Q[AWAVIAUATIUSHHHT$HPHHILL%HcHH9~THxOHLLH)8LIHHIILLHun1f.LLH)LIHHIκI/1LL轠XHtLL@8LH+D$H[]A\A]A^A_ÀP辞 H1[]A\A]A^A_HHt7HHt/H@HtH@XHt HH釮[ HHfAWAVAUATIUHSHH4HE@HC H9HHC(HC0H;HuJHK@HS0HLwIMLk Lk(HEH1H[]A\A]A^A_HLLcMHL.Lk@H{ IHM9MNLDK/HD)LsLMu+HEHHH[]A\A]A^A_f.HEHHH[]A\A]A^A_HLmHC @HLLcHLMtt2MeMfLcfDHHL.USHHHt*HHt"Hx0Ht(HHH[]/H1[]HL$H$蚣HL$H$Df.AVIAUIATIUHS7HcH9~HHIH~3LLLůHHH?H9|"H[]A\A]A^f.1۸H9}ބtHILH)LHxHH[]A\A]A^HtfAUATUHSHHHHt~I HULcb@HHt$HJHt HHu#bHHuHL[]A\A]fDHLHHLEH[]A\LA]I HHt7HHt/H@HtHHt HHfD+ @f.ATUHSHHAt-fH;tHHHSBtHHu[]DA\@AVIAUATUSL.MtFIL?IvfDH;t HLH uLI[]A\A]A^@f.AWEAVMAUIATIUImSHH8Ht$(1sHHLHBHLP0MH$EHMHH1HT$ $T$H$HT$T$xT$T$p$LAHIt,LLnHT$(ILLHxHHt'LH8H[]A\A]A^A_c1LHNff.AWIAVMAUIATIUHSHHH$HLMILQLDL$H@|$<LX0MH$$M$LT$(HH\$DL$0HT$ $L$<$LHT$LAHHtbLLGHHILLSHIHHtU |$rtF@>tPHj7HpPE1E1H袑P t2t tKH@[D@>u*f.1[@HHA H6H߹"1[H]f.AWIAVAAUATUHSHHLD$H ILD$>EAt M0AF uyHt<;t7EHLH@LH[]A\A]A^A_@LHHHt8uELtI$H[]A\A]A^A_@LH=tIFP ƒ сu HH56H-HIHE1薸H(LHHINfL1HþIHLD$fDLH腇1\f t~v;  ucH51ɺHuIMAB] u1H571ɺHCIHH1xAH5̄1ɺHIH51ɺHIr@AWAVAUATUSHHhL$Ht$@dH%(HD$X1HT$(L$4MDD$8DL$/밐+HD$PIWH5H1Lff.UHSH(H %87HD$D$H$HE1E11HyH([]fSH Ht[þ @ѡH59H 1茞H5'{[H5ifSH HHtH [f.苷H [H @f.SH HHtH@[f.KH [H@@f.SHHt$(HT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1HH%8裠H$Ht$ H$D$0HL$Ht$}HHH跟H\$dH3%(u H[fSH HHtH`[f.+H [H`@f.AWAVAUATUSHH9%8I L% %LHHa %D0D9}QH-%HEHcӃHEH=1耰L舟:H[]A\A]A^A_ÐAH=1ADAD?H-x%IcHH}اHH %McH=sHED9E)N4D1LIcHx3H*XfBf.H1LDHHHH H*XfDL蠞* uVH%HI`HHty tILHL{HމHsLf[ HH= 1:HAH@HtHHp(HuH5mL1ښHH= ƹL 1H5uHlj1諚H5%H=f1ƟfDSHHH=W1苮1yyyH HQ1J@6H( HtH}Hǃ( H0 HtH}Hǃ0 [fDAVAUATIUHSHH3IH>Ht=HAMt L`AH3H2zHljB Dr$xH I L[]A\A]A^Ðf.AWIAVIAUMATIUSHH\$`H4$l$PHtHHtHPHt @ D$h~RA}#LDL$ 蹔DL$ D$Xt&HD$pH0F H~T$X1§AE&1A}IIHttHHDH h$DwHH A}aHH[]A\A]A^A_fImDL$ HDL$ LDL$ ӅHHDL$ nLLDL$ H$HILL HHtUHDL$ @L"1豋Hf1HL讍%f1fATUHSH L"AA\$ u7xkH HHt[AT$$H߉X P$nvH H[]A\fDD$HL$HT$H4$趈DD$HL$HT$H4$H 1[]A\f.AUATUHSHHH9%8HHItQ;tLLTH%E1HHL謈HHtHHHh uHH[]A\A]HHRH5?AIHt$H̀{H1H[]A\A]H5ڴDHu*H5ôDHHuD1NJdHfAWIIAVIAUIATMUSH(H\$pL$dH%(HD$1HH+HI0F dLnH} Ǖ`Lu Ht$LoLHL衒H} HHE 芕CtHHL$dH3 %(IH([]A\A]A^A_DD$x~:I0F H~A<$#L$T$ht$`1I譣L$AE]A<$IbHt$LL$DL$ 謄DL$ HIDyL$HHHqLLELILHLQI1MI$HHh 胔HHt HHHtLH{cqCt$CNHL>fDHLm(Lq1zf{|f.ATIUHSH0dH%(HD$(1H$8蔑1HLHHH蹙HD$ HD$ E1E11HD$D$HH$H責HL$(dH3 %(u H0[]A\{@AUIATIUHSH8dH%(HD$(1HF$81HLH?HHHD$ HD$ E1E11HD$D$HL,$HHL$(dH3 %(u H8[]A\A]1{ATUHSHHdH%(HD$1H$8TS IĀtYtwtZHH@H$HCHt^H<$uWH1HL诅HL$dH3 %(uIH[]A\fDHC@ HHL蝀nazATIUHSHdH%(HD$1H$8脏LHHvHHHH$1H<$HL$dH3 %(u H[]A\yDAVHw$IAUIATIUS81 MMIHHcL苕~9s []A\A]A^H=۶1ff.HHL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$ApHT$dH3%(uHx@x\tC1 ^1t1YtYɅuYut^O1YߺfWf.w&f.w1f.H,f йf.w, f.v" f.w,,f. f.w1f.0ÐH,f. f.v" KHf.w(H,@f.w1f.00Hf.r\HH,H1fWf.wNf.w1f.Hf. hf.r2\HH,H1 JHf.wH,f.AWIIIAVAUATUSH8H*H<$u/HE1E1M)AH8L[]A\A]A^A_@IHHEA]E1fWE1:M?K6DMl$A0McI HHEtwA\$tmSЀHe_\OA]C<?MeHEtf(ȃ0HAMl$HEX*XuM)Eef.t~H<$H۵1LD$ LL$D\$D$vD\$LL$D$LD$ EM)MAHtAH8[]A\A]A^A_f.HM.DH<$H1LD$ LL$LT$L$6LLLD$ HLL$H LT$L$H*XfD_AH<$H1˾LD$(LL$ LT$D$D\$uD\$LT$D$LL$ LD$(M)EI9Af.M)؃f.IE1L$MNHPH9H$P߀AHPH9H$P߀NHA$H$IL9'ADL$ADIu AIDL9ML$wHPH9H$3P߀F#L@L9L$P߀IHPH9H$P߀NHPH9H$P߀IHPH9H$P߀THPH9H$P߀Y~HH$IAfI ^H58 LmBMtILMIfcH9! HBH9H$vRDtHA@f.AWAVAUATUSHH|$HHT$ dH%(H$1Ht$PH4$HD$pHD$xHDŽ$HD$`HD$hqaH $H-$D$@D$D1@DHQHT$P2IH@Du@+@-2H\$PD$փ@N6@IH&HDt$E1E1E11E1HD$HBHD$PD"A0$DD @AARA,$HHHT$PAtuEAxHT$H|$Ht$P@q(AHT$Pt(D$IXH\$Pփ@N|$Ht$XHD$H $HHYHT$XH $HD$H9HD$ HH$dH3<%(BHĘ[]A\A]A^A_DRE1E1AtHt@LcHJL`H9wiHKfDfDF tHH@ xNfDfDF t H@(ÐjfDF tHH@HHF_@f.F tHH@HHF1_F t HFD1d_@6MfDU1HSHHQC tHCH[]@HHH[]1_ATI1UHSHlQHHL[]A\Zf.U1ɺHSHHhC tHCH[]HHH[]1^AT1IԺUHSHWhHHL[]A\uZD1ɺ4h@HHT$0HL$8LD$@LL$Ht7)D$P)L$`)T$p)$)$)$)$)$dH%(HD$1H$HHD$HD$ $D$0HD$Hǃ[xuHHtދFtσFuHyH1H3bH[f.ATHUHSHtyLMtLmYLlHH|HHH}CtbH=}HƃH[]A\MDHlHǃƃƃ[]A\}t두f.SHt[ÐH5}kƃƃH[(MSHt[ÐHOkƃƃH[LAUATU1S1H]~L-$I!~H(B+HHHt0I$ZuӀt;H(B+DB+fH[]A\A]DATUHSHHpdH%(HD$h1HLMtLWLjHHzHHH}CH=HH5ڬdH爃VH5bdHHVHH)HH1H)H9HGHHHD$hdH3%(u}Hp[]A\D}v]@HHtjHǃƃHǃHǃfDHH u 1e$JH55HHH1M\f.AWAAVAUATUSHH=bHHdH%(HD$81:H=KIq:H=KHD$`:H5HD$hH1:iH51hHHD$tHHxD$H1iH5ThHIHHxI1hH5o"hHHHnx|$IHHAO\LHt`LHR_H0H5HHD$ oHL$uH5{Hn„tƃ6H=X9HHD$0Ht$0HYtƃHgLgLgH\$8dH3%(DHH[]A\A]A^A_fE11E1A^H`Ht x HuHH51lH`Ht x HuHH51L=ylMH`MEIEAA"IEAA"Ht x NHDD$!uDD$HH5LD1L=lHD$HLEHEAA"HH`EAA"Ht x ~HDD$tDD$HH5]LD1kH$L8M7MH=?LuuH=0Ltb=LGHtPL@L)HH`Ht x HHT$ LD$tHT$ LD$HH5ԉL1kIM7MhHD$H WHHEHEAA"HH`҃"Ht x LHDD$,HL$ T$sDD$,HL$ HNjT$H5W1wjH`Ht x HIsHH51HjH5QvGdHvH`Ht x HsHH51E1iHd11cHHPtLHd1cHH.tLIcd1cHH tIo[HH|$HH5ZjuH|$H5@jHt6H5 HjuH5H}jH|$HH5܇YjjH|$H5è;jFǃzH@H@HoHHx(H~Zf.EH5tvbHAAVfH@H@HqHHx(Hv\f.H@H@HGHHx(HB2f.H@H@HHHx(Hf.H@H@HHHx(Hf.H@H@HHHx(H f.H@H@HHHx(Hf.D$fDH@H@HHHx(Hf.H=r2H1 H t#HH9uH5sAH1PDHA D)HH@Hpw[]A\A]A^]HHHpGHFvL V$Dƃ0CDu'D  HLN0DCDuމ H5H1OUA HSHHH6HdH%(HD$1H)`HPH@w.H$HJHw H $?EHDE1H\$dH3%(uH[]=AWIAVAUIATUDSHH8L6dH<%(H|$(1Ht$L,DL$h<EAA II9pE1IDHD$HD$ H$BfDALս$AIH=vIL;|$AGt5I9H $HEL)LL_HT$ HJHwI뮅@ty,L5h<HD$EAL8M9sLL9vGL8$ fDL9v3H $HLL)ELL\$6_AL\$AIM9rI9LGt,D$tVL$LHL1`A!>H\$D l$L9Ht$ADA*A[HD$L@(@$EH5-$DHH9rIofDH-EHDD$:HD$D %=Dt$A D%=Dt7HD$L HH|$ H~A̾*@0HLD1v:IL;|$AH-CH-+H=D9HED$D$8HEH9} u`8 OHH9ufEEHD$@(@$HD$Dh L8HX[]A\A]A^A_HD$L@0AH|$ *L$dL$"HL$H|$ *A0ƒQ0LH΂ID18L$EH=$Db<*Z<[RHl$H|$ L)HL}^},cHELxHD$HWH|$ H5{@0HHD1^IfDHhR<#u0L}L9} tII9A? uIo!7I9HuMHL9uHHsH9tIcE,ITH9t IcE,IH+$IE8Mm@MuLHt$:NHD$Ht$P u@HHxuzH $H|$HT$H)HOHpHHPO H8[]A\A]A^A_HD$HHH HtH|$HHHL+x H@ W HH|$W HxtLHt$MHD$Ht$HgHHHH H*XH5$H=a 1ELHMH<$?MEE,H|$H5sLH1?fHHAIL+AI9wH9HBHTH9r HF=f.AUAATIUHSH,HdH%(HD$10YH3<HEHLAH)`PHH$HPHwPHv"HWs1A;*L@.H$HH\$dH3%(u H[]A\A],H5rAL1>f.AWIHIHAVL)AUMATU1SHHM'dH%(H$81H$V0LI+_HG8Ht$ HL$8L$H$HD$(H\$pH|$p\$p@t$cփHD$@@t$SC\$THH$H$ HD$XH$!HD$xLAHHt$ Hi.HD$ |$c@ D$ tLH+EHH;$.HD$ @(D$d9LH+D$8$H$Ld$AEHD$fD\$ H$H=]HD$0Hc tmLH+D$0H΃?HHHc$H9}$xEu=|$c$t3HcHE H+D$HH9cEX;E`&%S0HvHcH|$S$VP$,L;$,Lt$H\$?H,H*X$$$P$,L;$|,,HUH$<LEHHAH)MH$HHAH2H$E&A@[HT$(iDŽ$H%XST$ H5tH1X;Ht$HH$HD$|HD$ @$$$u DŽ$|$S 2H$Ht$8HLHc1HЅtm)À|$SHcÉ$;~RH$I9=H=©$I9# $ HʅH$uEH\$\$ H=sO)HZ&DA*~AY LAfWf.4$v$fWXf.$w$H|$ $^h* $HYf( $N,HD$@HE H+D$HfL|$Ht$@HI_DIGHD$ @0HH+EHcT$THH)H9Lt$ HL-7A~(37L;l$0F7H3HCHD$F HH@ $+7HD$ E1E1@ D$ $L$P$_Ll$HLt$\$SDl$ L|$h/@A*X$$$P$E }H$HAnH$f$AAv$EA@IHT$(뉋$\$ H$H|$hP$Ll$HL|$EDt$S*fH*X$$$P$pE?H$HHH$H$u HH$E!A@HT$(떋$Dt$ H$H|$hPA$Ll$HL|$E\$S2HI&H*X$$$P$H$HHH$H$Au HH$EK!A@HT$(떀|$SHc$H$LH)H9H5kH1c6H$$E1D$HAD$H|$hLH$I9)|$Sb!HPH$HHHÃH ӄLd$HTHHHID$Mt$1n0$Lt$D$H$pL;$D$8)DE0|$S)H$H$L$L$HD$hH$HD$HfHL$hLHH=E%$#uD$$WHL$HLHHLLHHLLHHHL$LHH$$ Ȉ$ $ $ E䈔$!$"N$HT$XN$Ht$@AHHcD$EuDŽ$A|$S'HD$8H$DIH9s!H5$ HȃuH9DIrI9*L$4$L$P$Ll$HLt$\$SDl$ L|$h0A*X$$$P$@H$HANH$$APAV9ERA@IcHT$(댋$\$ H$H|$hP$=Ll$HL|$EDt$S3A*X$$$P$E,H$HH$f$AԁuDff$AEA@IHT$(눋$\$ L$P$kL|$Ll$HELt$Dt$S)H*X$$$P$PE'H$H0HH$H$u HH$EA@Ht$(떋$\$ L$P$Dd$HD|$SLd$rf.H$H0HH$H$u HH$1HI03HHKH$fDL$ HL$AHT$HHt$hHD$fDL$ HL$AHT$HHt$hHD$fHMfD%HH)#IFMDHHT$Mg6HT$IGHHMP IGHHD$g6DIGHH%L|$IGHHD$76IcIGHHU4L|$2HD$M~6D$HIFHMfH|$a5M@$IFHD$HHD$5D$HHIFH3Lt$8fL5fDHHT$MgW5HT$IGHHMp3IGHHD$'5IcIGHHE3L|$IGHT$HHD$4T$HIGHHL|$fDHHT$Mg4HT$IGHHM2HMg0HH IGMDIGHHD$g4IIGHH2L|$f.HHT$Mg/4HT$IGHHM+Av,f$AVa $LHHT$M~3HT$IFHHM{H$HPH$-L$ Ht$hLH&$:HEDt$HH|$ Dd$HD$D#G0$H$HH$HGH$HGH$HGH$HG H$HG(H$HG0H$HG8H$HG@|A@~hH=hMHtkD*D$AA=+f$ALL|$Ll$htDHHH!D$(Ht$(H HD$@Lt$H5LHٺH10IH$I9|$SHPH$D0DAD$ zI$MD$H@H$H=MLLƹH$IL9u @H9tI9ȉs6H04A)ƃ0L9@quE1Ld$@HD$@D$H@ HP H:0tLd$@HLWLt$LHWIF$I^H\$1ۃ$fH5RK H/HLHHD$@D AD$L\$@AD$ AC tWIMCMH@H$HT$LH;I~L$ Ht$hLHA8HT$L޹HL\$@L\$@IH$MLHЃHH H*XNHHH H*XHЃHH H*XLHL\$@tL\$@EIE)HD$@AL+xHLHBHE H+D$HHD$H|$@HXHxLd$Dd$HELt$Ll$HHЃHH H*XH$8  HPI9v x L9s8W߀?0EeHE H+D$HSHt$HHOHD$4Lt$D$SLH[)L\$@Ld$@HD$@@  Ht$@1ҹ"H)HMHl$HE$HL$8H$H9`HH)EHH:*HU H+T$IHjL|$LH$I_IGH\$R|$ /2H$IHt H$HLI+GM'H+D$pH$8dH3%( HH[]A\A]A^A_LH+$HcH9~ $EAɉ$H$I9L$\$SHL$XHt$AUALHH$莾f$ H|$AUHL$xHt$HLD@DP(,H{'Ht$XLDLHHH$EH$A@HH*X$$$P$H$I9,H&H$LLDHH)HH$HHHH$EUHD$HHT$HLpt+H|$HT$HHHGH+Lt$>HT$(4HЃHH H*XD$T$HH5AH1( H$McHH+L$8HHIH$HcH9 H)D$SH$jH$I9!HHt$(5H$I9$|$SHPH$|$ bQ$HL$(zH ;t HH9uHIH)Hi!|$dHD$@1I9LH+$Љ$DŽ$Ht$HHHD$H57H1HWH\$(ugH5;H1HH9HwH=q$HHc$YHc$HH57H1?D  1 oH5E8H1 H57H1IH1H57H1H5q;H1H5L6H1f.)fAWLH)AVHIAUATUSHHHt$(H|$dH4%(H$1HHL$HLD$hHD$0ŋC0,LD$@S,$uG@&HD$(HH@HC8H$dH3<%(HD$HEH[]A\A]A^A_HD$(@HH@HC8tDs H$DIHD$XH$HD$ H$H$H$HD$xH$H$@AE(H\$(ljD$PHCHIHD$L{%H=9@5HE1IEHt$XH|$H$IEH$IEH$IEH$IE H$IE(H$IE0H$IE8H$IE@H$^AE0$L D$H=D9H$D$01~`HD$HH0F tHNA H|$tHD$HP@<$H1ZHH\$$DŽ$HHH IƉ%=SyH >HcH2HHPHD$HH$HHqI H|$ H|$HHHP !H\$I]8|$@t 5L)AAb6HD$(H|$McK'HHxH9-3L1L'HH+D$H|$(HHBH$$IEH$IEH$IEH$IEH$IE H$IE(H$IE0H$IE8H$IE@WAm fDE1%=SH|$H56@1#Ee$EH:BH@?IcHЀ|$@HHEHD$HCI H9H\$(H|$HIHD$HLxuHc$$1Hct$0Dd$0S $H]EDD|$@3LH+D$IcHHA)ąIEDD|$@E3HD$L9?H k$DH041HuDHI9wL9F@HH+D$DL$l$@Lt$`Ll$(#fDHD$`HIw*AD$ #I$B(fWf.?AT$ V#-vf.t$H|$LL$`IN fDHHʀHuMf IE$iH|$I)@K$IDHxI4H9x%@%J4!H9w>@HAIH9t*yƒ?HȀIAGAWH9uփLL$H+D$L{M8<A0A--AV 0I HHH$IFH$0H|$HPB<0H|$HLHD$`AH$HID 1H|$IHHHAHHHHH|$@HDHD$(I4HHxH928HJ=L$Dl$@H$ LL$`HH|$P9ADLE2HL$PHT$`AuHt$ H|$Eĩ<Ht$PDLMc試Eo2L9vDLfDH HH9t* y΃?H@ɀHK@sH9uH$L)HH$CL$Ll$Pl$@MMELd$"y\؃?IˀA]AEAE,ML+F >(HHX HH= (@uA]I봀|$@27E L9|$s'L@HYAoH9\$rH|$H5D.@1HD$H|$(IcH\$L$@MLl$`HPI@<D$PHH@HDHH HDA)ILEM9r.AILH)I (HPIH@HH9s1LlE1IHA,+ML*F 'HLP |$PuulIvAG +AI)IH\$`H|$LLT$L@HгHC8I_$LT$H$IIL@H@LlM9v2AILH)HPIHU I4H@H H9*LlH|$1LL'IE-Ht$(H|$IcMLl$`HHIIHh|$@HEHDH$`HHD$g|$@HLH I9r3AILL)HPIHS I4H@ILH9/IlH|$L1LpIAHE/MLI/F zH|$LD$P|$@ILD$PeHt$H|$1LLD$PHH+L$LD$PH IH9w,AILL)LHrI7HIHnH93HD$H4H9w@DAIHH9'yу?IʀAPAHHD$(|$@H|$HHHHxHI H9[2LE1L$Ll$PAMEƐML'#E <.„HDŽ$AuH$HH$|$@HD$ fDHHL9t(yу?HʀHSKL9uAAFIHLl$PH+D$_M4AV 1IH@H$MVI< H$3)D$pE1|$PH|$DDAD$Љ$Ѽ$Hc$|$@HHEHD$(I HHxH91|$@"*HCD9EH$I9HL$ DD$pL)H|$LLT$`xH$LT$`HJH6IH=H -^$Hc  ōCD9bt0|$@.@}.?ÌAoAG1ۃ|$Pt$)HcH1LLHH+D$HD$xLl$PEEH$Al$@HML$H|$5A$L"@*"HD$xHAIH9t*yу?HʀIAWAOH9uAEqLl$PLLH+D$E&Ll$@EMI$yX؃?IˀA\$AD$AE*ML*F )HHX H)@uA$IM/AV ,IH@H$I^H< H|$p'D$`E1|$PH|$(DDAL$DHщ$$Hc$|$@H HEHH|$I4HyH9_-D9L$DNBi,EWHT$pH9$HL$ DD$`H)H|$HXH$HJHw3HӉʀEAt,@DA9D`c$EuHt׃̀AuԀ|$@@?ÌAo1AGM8/AV ,IH@H$Iv H$HD$HP@<|$@/|$P-.H$H$D$@ /fDAE0I]E}(IUAE,Lt$(H\$0HL$HD|$IU|$PDd$P!l$PH|$X D$PD|$@I}@AE0\fD AE0HD$0LD$hLH|$Ef LIEAV A H D9DE|$ AE0"EuAE0뛃|$PH\$t EL2&M.AF )ID` H|$H5&1HD$ EA\$Hh7MLl$PDd$@Ll$ Ltnf.F H@ f$oEf$L`AIHH9uMLu|$0(H|$HD$0H7HGHD$HF vH|$iEA\$YMLl$PDd$@ALH$fF H@($EHD$ fHAIH9t*yу?HʀIAWAOH9uAAMLl|$0'H|$HD$0H7HGHD$HF FH|$:HD$ A\$EHh>ILLl$PHADl$@HF H@ uE퉄$HD$ HAIL9t*yу?HʀIAWAOL9uAAHHt|$0J%H|$HD$0H7HGHD$HF NH|$@EA\$1LLl$PHADl$@L$HF HH@ uHEH$CHD$ @HAIL9t*yу?HʀIAWAOL9uAAHHt|$0O$H|$HD$0H7HGHD$HF NH|$AHD$ A\$EHhILLl$PHADl$@HF H@ uE퉄$HD$ HAIL9t*yу?HʀIAWAOL9uAAhHHt|$0 $H|$HD$0H7HGHD$HF NH|$-@HD$ A\$EHhILLl$PHADl$@HtgF H@ ufEf$jHD$  AIHL9uAA|HHu|$0d"H|$HD$0H7HGHD$HF vH|$EiEA\$!LLl$PHADl$@L$HF HH@ uHEH$HD$ @HAIL9t*yу?HʀIAWAOL9uAApHHt|$0!H|$HD$0H7HGHD$HF NH|$5AHD$ EA\$HhMLl$PDd$@Ll$ LDF H@ lj$:E䉄$"LDHAIH9t*yу?HʀIAWAOH9uփjMLv|$0 !H|$HD$0H7HGHD$HF PH|$/BHD$ EA\$HhHLLl$PHADl$@Ld$ HHtF HE@ ȉ$LHAIH9t*yу?HʀIAWAOH9uAAhHHu|$0zH|$HD$0H7HGHD$HF bH|$1Eȉ$YAAIAuHD$ A\$EHhILLl$PHADl$@HF H@ uE퉄$HD$ HAIL9t*yу?HʀIAWAOL9uAA0HHt|$0SH|$HD$0H7HGHD$HF NH|$@EA\$LLl$PHADl$@L$HF HH@ uHEH$HD$ @HAIL9t*yу?HʀIAWAOL9uAA HHt|$0H|$HD$0H7HGHD$HF NH|$AHD$ A\$EHhILLl$PHADl$@HF H@ uE퉄$HD$ HAIL9t*yу?HʀIAWAOL9uAAHHt|$0UH|$HD$0H7HGHD$HF NH|$M@HD$ EA\$HhMLl$PDd$@ALDF H@(ffZ$EHD$ fHAIH9t*yу?HʀIAWAOH9uAAMLd|$0JH|$HD$0H7HGHD$HF >H|$]2EA\$LLl$PHADl$@L$HF HH@ uHEH$KHD$ @HAIL9t*yу?HʀIAWAOL9uAAHHt|$0H|$HD$0H7HGHD$HF NH|$AEA\$yLLl$PHADl$@L$HF HH@ uHEH$cHD$ @HAIL9t*yу?HʀIAWAOL9uAAHHt|$0H|$HD$0H7HGHD$HF NH|$荿AHD$ A\$EHh^ILLl$PHADl$@HtgF H@ ufEf$ HD$ AIHL9uAAHHu|$0H|$HD$0H7HGHD$HF vH|$%iEA\$LLl$PHADl$@L$HF HH@ uHEH$ HD$ @HAIL9t*yу?HʀIAWAOL9uAAHHt|$0\H|$HD$0H7HGHD$HF NH|$AEED$L=HD$ EA\$HhXHLLl$PHADl$@Ld$ HHt]F t|H@ fEf$ LAIHH9uAAHHu|$0UH|$HD$0H7HGHD$HF uH|$'wDs AU)HD$(HH@HC8N|$@  Ѓ?Iʀ1AWAGCA9E H$I9HL$ DD$pL)H|$LLT$`H$LT$`HJHIH=H E$HcqP  8]|$@H$}|$P1A9IcHD$(H|$I HHxH9AH$H$LH$IA)Mc1 ALLDK'HD$Ht$(E1E1t1Hu<A@f.IM8HD$HH9HnH+D$L fDHJ8H9s HB8HR@HuH$DI$H@ U с{L HEH$H|$LAHC$I| |$@ƒ?IȀ1AGAWfу?IʀAWAOу?IʀAWAOу?IʀAWAO>@E <If(L$`T$PMYT$Pf(1L$PYM9L$Pf(f(IfWY\,ƒȀf.A$wIƛIE$M)@H|$K6IDHxI4H9@K44L9wUAIII9>A$yƒ?IȀAGAWу?IʀAWAOf t@ML+L$AIEH|$LHL$PLH芕IHD$IEHL$PLx@MLLHMH$AHHCAFH|$HkE <HUB DA/I1f.A1IYI$HRH$MT$H|$LLT$Pr@ ILT$PL@AMÄtEH 1B<QHcH1@u AI@IAuAI$IM)LXH$IL$$Lt$H\$ E1@$HD$pLDHAD$ I$H@H$ID$H¿1fD4tqЉAEH0J uI $HH)ƒ΀@HQ@uxI닜$$fIAfD@AD$>AD$H|$H5& 1HLLDT$PXDT$PI$I$$H@AHD$pH$H|$dHL)IE@H HDHxI4H90@LL9w>IAII9t+Ayƒ?IȀIAGAWI9uH|$pAD$AD$H|$L^% =H|$11HH|$H' 1kU cH9D$hHD$HD|$@AE0sD$0PHD$HT$0L HHD$H` |$0H|$HD$0HGH/HD$HAH<$It  =$AIfAGAf$AIAGAfDAIAfAIAeDHL1LȮHH$AIIGAB D$AIAGAfDH$AIIGADH|$LD$@L$谱LD$@I‹L$XH$AIIGAQl@H$AIIGAEDH|$ A#H$IAIG H|$x$AIAGARDfAIH$AIIGADH$AIIGAmD$AIAGACFfD$AIfAGA@H$AIIGAD$AIAGAfDH|$ kA1IfH|$1HLT$P LT$PIH|$H$"LH$IHLLHL$PHL$PI!ML+L$AIEH|$LH$L\$PLHIHD$IEH$L\$PLxHT$ H|$"RH|$HH$HH|$0kH|$HD$0HGH7HD$H |$0H|$HD$0HGH7HD$H|$0PH|$HD$0HGH7HD$HH|$ 1H西H|$L耪(H|$L~H|$H1LD$@LT$觺LT$LD$@E$HD$T$0L@MLL$@Ll$`H)LHH|$LLT$nHILT$IL@H@H|$D$0H@Hc$;t$0TH\$(H|$LHIHD$HLxK'D|$@HL$HHT$hH+T$HHHT$0T$P!‰$L$U@|$@!@?I_̀AoAAD$1|$Pt$)HcHH1H2HH+D$ Eu0LADD$@LH+D$H|$HPB<$A|$pd$pDVUUUAD),R?Lc7H|$H1A??艸AV H|$H$"LAV H$H$ E1HD$`,AE0D$@Ht$(H|$LIE8$H$LH+L$IcHHHAMcI9LL)IHt$H|$LIc1HFH$A9DOE I9v.Et)H b7$ EtAHI9wI9 EI94ELH+L$A)JH|$HPB<$A|$`d$`LAH+L$|$PA9 IcH|$(HI4HH|$HyH9r)H\$(H|$H赇IHD$HLxH$A)HuH$H\$LHH1H/H$HOH$H$HWHH$uIALu#HIAH@@uH6H\$HX8fDH$DLMcBtL$EL)HLHHD$p;HL$pHH|$?HH'H|$Hs1W |$0vH|$HD$0HGH7HD$H|$06H|$HD$0HGH7HD$HH|$LLL$P IILL$PML@H@(H|$HLLT$څHILT$IL@H@]LMH+D$LtLLLl$`H)L^H|$D$0H@IML+L$AIEH|$LLH`IHD$IELx@LLLM[H|$D$0H@H|$D$0H@H|$D$0H@H|$D$0H@H|$D$0H@5H|$D$0H@H|$D$0H@H|$D$0H@H|$D$0H@H|$D$0H@H|$D$0H@/H|$D$0H@H|$D$0H@EH|$D$0H@0H|$D$0H@H|$D$0H@H|$D$0H@I$@D$0;H|$D$0H@H|$D$0H@fA/II_A/H|$LAH|$H$"LжAV HH$EADTHT$pH9HL$ DD$`H)H|$HH$HJHHD At'D4D9D`~NEuHD Auـ|$@t#yƒ?IȀE1AGAWAE1I맨DL$ L@Ht$(H|$IIHD$HD$(HLxH$qH\$(H|$HIHD$HLxH|$H5f1H|$H$L"eAV HH|$H$"L?AV IH$-H\$(H|$H艁IHD$HH$LxH\$(H|$LT$`HVIHD$HLT$`LxHH|$LHL$P+IIHL$PMLL@Hh LH+L$H|$D$0H@[H|$D$0H@PH\$`H|$L?IcăZH$HB1H7HPH$H#|$0H|$HD$0HGL7HD$H ЉH$D$@ZAHH$HZAHH$HH\$(H|$HIHD$HLxIc̃ZH$HHHHH$|$0H|$HD$0HGL7HD$HHD$(@ ~|$PH$uDcHZIcH$HH~/H9v*H -$H9v8HH$<9H҉H9!|$@1҃ZH)H$D$UAI|$0H|$HD$0HGL7HD$H |$0~zH|$HD$0HGL7HD$H|$0~>H|$HD$0HGL7HD$HHt$(H|$H){K0Ds D$@H|$D$0L@hH|$D$0L@H|$D$0L@ZH|$HLHzIE8H{$H$HH|$HxI&H|$D$0L@D`H|$D$0L@$D`yfIcHH)׃ZH[|$PH$H-HD$(H|$I HHxH9r!Lt$(H|$L }IHD$ILxD$Ht$ AH|$ALH3mH$H$AH|$H5MIDH$1HAD$H@H\$TLUHD$(HH+l$LD$PH5>HL$`H|$McHHhH$1HD$(LH+T$AH|$H5VHHP1踻H$ZAtHcHDbIcAH|$H51tH|$H5c@f.AWAVMAUIDATIUDSHHhdH%(HD$X1H|$@L9L|$sH<#HDHxI9v%@<#HL H)'Hu҉ EH|$E1LMLLH\$Ll$HD$ HD$(D$0D$4D$8D$<l$@HD$HHD$P{HL$XdH3 %(Hh[]A\A]A^A_D_1HHMHD$e MFLLHHLHE@t HH%HCJHhHHHCH|$dH3<%(Hu/H([]A\A]A^A_@HT$"yL|$IZGHH Hff.UHHSHHHH6 u H9ݰH9FH[]f.UHHSHHHH6 u!H9ݸH9FH[]f.H[]AWAVAUATUSH dH%(H$ 1HH<$Ht$pD$~AIHD$xtH L L%HL$xH HH*XZf.Z HHHD$hH$pH$Lt$pH<$LIVI6IH\$(1AԅM9HL$hHD$ HL$HL$(IFInHD$0H9vJLt$IIL<$HIMnL9vIVI6LAԅ9tLLt$Ll$0L<$MHl$IH;D$HD$)H@HL9+HuHULAԅ9tI9M9s[IEH9D$zIHD$LHD$ L)HDžH8H|$t)IEI9s IHIHINHPI9rH|$L9vbMMHT$LHHHRtHpHxHpHxHH9wHEHL$ L)HHPHDHHT$HD$ H9l$H;l$Ll$IfDHD$HD$HfDLl$Lt$MMAH\$$fDHuIVLAՅA9u IInH9rDMMLt$Hl$HD$0H9D$(t5Hl$H9l$(IHD$0H9D$(Ll$oHL$HD$ HHHHD$HhH$H|$hH9t螾$tH$HL$xH H$ dH3%(H []A\A]A^A_HD$ HL$pHD$ 1HDŽ$DŽ$MH$H$HL$hH$H$H$HL$@H$HcЃHHԐHĐHL$PHD$XHD$@HL$PH|$XHHHD$HHHIHD$`HMHHH)HHD$HH)|$HHHD$HHT$8HT$HD$0HD$0H9D$L;l$8yHD$IuH<$HAօHD$0Ld$LD$HD$E1AMH\$(Ll$ ML/IUHuH<$A9D$HK$MHLMO,L9l$wHD$MLl$ H\$(LxM9ML|$IM9viLl$H\$ MMDd$ fL{M9v:LHuH<$L)HHHH?HHIHAA9|IM9wMH\$ Ll$L9u fDHIIUHCM9HrHL$HHHCHHHD$HD$0H9D$|L;l$8MHHL$ HT$8fIID$HL9HCwH|$XHL$PHt$`H)HH؃$HHl$@HD$@H@HHH|$PHD$XMH\$(MLl$ HD$8Hl$MD$HD$HD$fHHHHHSL9H rHD$HELmHHCnHPHuH<$A9D$H9L$0HH|$0HHpHH9HswHD$0HHHH\Ht$HHHL$@HHAb$HHHHH2H)HJH㉼$$Ht|HB$HrHBHD$@1HL$pHH|$hL HHHH)HLH)HLHHxHH9HzwM1ItPHD$pH\$hH H<HH1H)HLHHLHHI9LIwLHBHT$@;$pHBHT$@IUIuLAԅ9HD$(HHD${HT$@HHHH H*XH$pHH$HD$hH5*$H=v1D@AWAVAUIATUSHdH%(H$1HH|$HIHHILt$w-@H,II HHHIHHHXx\H*I D$Hp@Hx(4fWD$u I H@Yf.n;r\d;H,L1|HƒHH H*XH$dH3%(H[]A\A]A^A_AED$<D$0D$8D$D$+D$09D$ files in place (makes backup if extension supplied) -Idirectory specify @INC/#include directory (several -I's allowed) -l[octal] enable line ending processing, specifies line terminator -[mM][-]module execute "use/no module..." before executing program -n assume "while (<>) { ... }" loop around program -p assume loop like -n but print line also, like sed -s enable rudimentary parsing for switches after programfile -S look for programfile using PATH environment variable -t enable tainting warnings -T enable tainting checks -u dump core after parsing program -U allow unsafe operations -v print version, patchlevel and license -V[:variable] print configuration summary (or a single Config.pm variable) -w enable many useful warnings -W enable all warnings -x[directory] ignore text before #!perl line (optionally cd to directory) -X disable all warnings Run 'perldoc perl' for more help with Perl. Fedora Patch1: Removes date check, Fedora/RHEL specificFedora Patch3: support for libdir64Fedora Patch4: use libresolv instead of libbindFedora Patch5: USE_MM_LD_RUN_PATHFedora Patch6: Skip hostname tests, due to builders not being network capableFedora Patch7: Dont run one io test due to random builder failuresFedora Patch9: Fix find2perl to translate ? glob properly (RT#113054)Fedora Patch10: Fix broken atof (RT#109318)Fedora Patch13: Clear $@ before "do" I/O error (RT#113730)Fedora Patch14: Do not truncate syscall() return value to 32 bits (RT#113980)Fedora Patch15: Override the Pod::Simple::parse_file (CPANRT#77530)Fedora Patch16: Do not leak with attribute on my variable (RT#114764)Fedora Patch17: Allow operator after numeric keyword argument (RT#105924)Fedora Patch18: Extend stack in File::Glob::glob, (RT#114984)Fedora Patch19: Do not crash when vivifying $|Fedora Patch20: Fix misparsing of maketext strings (CVE-2012-6329)Fedora Patch21: Add NAME headings to CPAN modules (CPANRT#73396)Fedora Patch22: Fix leaking tied hashes (RT#107000) [1]Fedora Patch23: Fix leaking tied hashes (RT#107000) [2]Fedora Patch24: Fix leaking tied hashes (RT#107000) [3]Fedora Patch25: Fix dead lock in PerlIO after fork from thread (RT#106212)Fedora Patch26: Make regexp safe in a signal handler (RT#114878)Fedora Patch27: Update h2ph(1) documentation (RT#117647)Fedora Patch28: Update pod2html(1) documentation (RT#117623)Fedora Patch29: Document Math::BigInt::CalcEmu requires Math::BigInt (CPAN RT#85015)RHEL Patch30: Use stronger algorithm needed for FIPS in t/op/crypt.t (RT#121591)RHEL Patch31: Make *DBM_File desctructors thread-safe (RT#61912)RHEL Patch32: Use stronger algorithm needed for FIPS in t/op/taint.t (RT#123338)RHEL Patch33: Remove CPU-speed-sensitive test in Benchmark testRHEL Patch34: Make File::Glob work with threads againRHEL Patch35: Fix CRLF conversion in ASCII FTP upload (CPAN RT#41642)RHEL Patch36: Do not leak the temp utf8 copy of namepv (CPAN RT#123786)RHEL Patch37: Fix duplicating PerlIO::encoding when spawning threads (RT#31923)RHEL Patch38: Add SSL support to Net::SMTP (CPAN RT#93823) [1]RHEL Patch39: Add SSL support to Net::SMTP (CPAN RT#93823) [2]RHEL Patch40: Add SSL support to Net::SMTP (CPAN RT#93823) [3]RHEL Patch41: Add SSL support to Net::SMTP (CPAN RT#93823) [4]RHEL Patch42: Do not overload ".." in Math::BigInt (CPAN RT#80182)RHEL Patch43: Fix CVE-2018-18311 Integer overflow leading to buffer overflowRHEL Patch44: Fix a spurious timeout in Net::FTP::close (CPAN RT#18504)RHEL Patch45: Fix day of year parsing (CPAN RT#88211)RHEL Patch47: Fix CVE-2020-12723 (GH#16947)RHEL Patch48: Fix CVE-2020-10543RHEL Patch49: Fix CVE-2020-10878 split(/,/,q)zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzczzzzzzzzzzzzzzzzzz4OzzzzzzzzzzKzzzzzzzz;z+ zzzz{zzZGB%:utf8:utf8:utf8:utf8E4AAAAAAAAAAAA86AAAAAAAAAAAAAAAAAA86AAAAAAAAAAAA5AA86AAAAAAAAAAAAAAAAAA8686586AA4AAA86AAAAA5586M58686AAAAAAAA86A868644A8686AA868686A86AA864868686x4C&CORE::%s cannot be called directlyName "%2p::%2p" used only once: possible typoAttempt to free unreferenced glob pointers, Perl interpreter: 0x%ppanic: gp_free failed to free glob pointer - something is repeatedly re-creating entries, right argument has no overloaded magic, right argument in overloaded package Operation "%s": no method found,%sargument %s%-p%s%-pCopy method did not return a referenceOverloaded dereference did not return a referenceCannot convert a reference to %s to typeglobUse of inherited AUTOLOAD for non-method %-p::%-p() is deprecatedCan't locate object method "%-p" via package "%2p"Can't locate object method "%-p" via package "%-p" (perhaps you forgot to load "%-p"?)panic: Can't use %c%c because %-p is not availablepanic: Can't use %c%c because %-p does not support method %sVariable "%c%-p" is not imported (Did you mean &%-p instead?) Global symbol "%s%-p" requires explicit package nameHad to create %-p unexpectedlyCan't use anonymous symbol table for method lookupCan't locate package %-p for @%2p::ISA%s method "%-256p" overloading "%s" in package "%3p"filehandledirhandleBad symbol for %s__ANON__::overloadingin overloaded package has no overloaded magic left panic: gv name too long (%lu)%2p::SUPERIO::FileIO/File.pmCORE::ErrnoTIEHASHTie::Hash::NamedCapturearybaseFETCHXPORTVERLOADHILD_ERROR_NATIVENCODINGLOBAL_PHASEREMATCHOSTMATCHTF8LOCALETF8CACHEARNING_BITS$%c is no longer supportedUNIVERSALStub found while resolvingCan't resolveoverloadDESTROY%-p::_GEN_%ld(${}(@{}(%{}(*{}(&{}(++(--(!(=(neg(<>(int(<(<=(>(>=(==(!=(lt(le(gt(ge(eq(ne(%(%=(**(**=(<<(<<=(>>(>>=(&(&=(|(|=(^(^=(~(atan2(cos(sin(exp(log(sqrt(x(x=(.(.=(~~(-X(qrN8N8N8N8N8N8N8N8NN8NN NNNPNddccc@dcccccdddd0eedddd0ee\i4`4`4`4`4`h\hih,hgggf-`-`\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i\i-`-`yzzzzzzzyzzzzzz()-=])} =wds]rnftbxcavaA01! zZ79~([{< )]}> )]}>at EOFnext token ???at end of linewithin patternwithin stringnext char ^%c\%03onear "%-p" %-p%s has too many errors. at %s line %ld, %-p undef} is not definedCall to &{$^H{:short:full_charnamesConstant(%s) unknownConstant(%s): %s%s%sPropagatedmsixopadlumsixopadlugcSearch pattern not terminatedfloatintegerpanic: scan_num, *s=%dMisplaced _ in numberIllegal octal digit '%c'Illegal binary digit '%c'Integer overflow in %s number%s number > %s non-portable+-0123456789_qqFormat not terminatedUnterminated attribute listafter '_' Number with no digitsMissing right brace on \o{Missing braces on \o{}Useless use of \EL\uU\lpanic: yylex, *s=%u:'{$()| \%c better written as $%clLuUEQFMissing right brace on \x{}Missing braces on \N{}Missing right brace on \N{}\N{U+%X.%X\x%02Xuse feature ':5.16';LINE: while (<>) {chomp;our @F=split(%s);our @F=split(' ');=cutperl -indirCan't exec %sToo late for "-%.*s" optionuniqueUse of :unique is deprecatedlvaluelockedUse of :locked is deprecatedsyntax errorUnmatched right curly bracket+-*/%.^&|<Reversed %c= operator!=~ should be !~Excessively long <> operatorUnterminated <> operatorGlob not terminatedreadline{$:+-@Array lengthScalarFinal $ should be \$ or $nameYou need to quote "%-p"$@"'`q&*<%Array $#+-'"studyNumberStringBackticksBackslashBad name after %-p%sBareword%*s::DATA:encoding(%-p)CORE::%-p is not a keywordDB_File::NDBM_File::AnyDBM_File::ISAODBM_File::SDBM_File::GDBM_File::Missing $ on loop variable__PACKAGE__No such class %.1000s|&*+-=!?:.<> should be quotesmsixopadlugcereval do subroutine nameMissing name in "my sub"Prototype not terminated$@%*;[]&\_+parse_blockparse_barestmtparse_labelparse_fullstmtparse_stmtseq0377777777770xffffffffBinaryOctalHexadecimaloctalhexadecimal%s (...) interpreted as functionCan't find string terminator %c%s%c anywhere before EOFWarning: Use of "%.*s" without parentheses is ambiguousParsing code internal error (%s)Lexing code internal error (%s)Lexing code attempted to stuff non-Latin-1 character into Latin-1 inputSource filters apply only to byte streamsfilter_del can only delete in reverse order (currently);}continue{print or die qq(-p destination: $!\n);}Ambiguous use of %c{%s%s} resolved to %c%s%sAmbiguous use of %c{%-p} resolved to %c%-pTransliteration pattern not terminatedTransliteration replacement not terminatedpanic: utf16_textfilter called in block mode (for %d characters)panic: utf16_textfilter called after error (status=%ld) (Might be a runaway multi-line %c%c string starting on line %ld) }} did not return a defined valueAmbiguous use of 's//le...' resolved as 's// le...'; Rewrite as 's//el' if you meant 'use locale rules and evaluate rhs as an expression'. In Perl 5.18, it will be resolved the other wayHaving no space between pattern and following word is deprecatedRegexp modifiers "/%c" and "/%c" are mutually exclusiveRegexp modifier "/%c" may not appear twiceRegexp modifier "/a" may appear a maximum of twiceSearch pattern not terminated or ternary operator parsed as search patternUse of /c modifier is meaningless without /g%s found where operator expected (Missing semicolon on previous line?) (Do you need to predeclare %-p?) (Missing operator before %-p?) Integer overflow in decimal number"%s" not allowed in expressionMissing right curly or square bracketNo package name allowed for variable %s in "our"Can't use "my %s" in sort comparisonPossible unintended interpolation of %-p in stringBad evalled substitution patternInvalid range "%c-%c" in transliteration operatorAmbiguous range in transliteration operatorPossible unintended interpolation of $\ in regexUnrecognized escape \%c passed throughNon-octal character '%c'. Resolved as "\o{%.*s}"Missing right brace on \N{} or unescaped left brace after \N.Invalid hexadecimal number in \N{U+...}Malformed UTF-8 returned by \Npanic: snprintf buffer overflowCharacter following "\c" must be ASCII"\c{" is deprecated and is more clearly written as ";""\c%c" is more clearly written simply as "%s"Missing control char name in \cpanic: constant overflowed allocated space, %lu >= %luUnrecognized character %s; marked by <-- HERE after %-p<-- HERE near column %dBEGIN { require 'perl5db.pl' };Unsupported script encoding UTF-32LEUnsupported script encoding UTF-32BEpanic: input overflow, %p > %pUse of := for an empty attribute list is not allowedUnterminated attribute parameter in attribute listThe 'unique' attribute may only be applied to 'our' variablesInvalid separator character %c%c%c in attribute listUnmatched right square bracketUse of bare << to mean <<"" is deprecatedDelimiter for here document is too longUse of comma-less variable list is deprecatedMultidimensional syntax %.*s not supportedScalar value %-p better written as $%-pUse of ?PATTERN? without explicit operator is deprecatedCan't use \%c to mean $%c in expressionBad plugin affecting keyword '%s'dump() better written as CORE::dump()Ambiguous call resolved as CORE::%s(), qualify as such or use &Bareword "%-p" refers to nonexistent packageAmbiguous use of -%-p resolved as -&%-p()Operator or semicolon missing before %c%-pAmbiguous use of %c resolved as operator %cPrecedence problem: open %-p should be open(%-p)Possible attempt to separate words with commasPossible attempt to put comments in qw() listSubstitution pattern not terminatedSubstitution replacement not terminatedUse of /c modifier is meaningless in s///Prototype after '%c' for %-p : %sIllegal character %sin prototype for %-p : %sIllegal declaration of anonymous subroutineIllegal declaration of subroutine %-pDeprecated character in \N{...}; marked by <-- HERE in \N{%.*s<-- HERE %.*sUse of qw(...) as parentheses is deprecated0b11111111111111111111111111111111``` `0 ``0@ ` P `` p ` ``hhxxxxxxXxxxxxxour @F=split(q*M'*!'!B!&U#(RHUHUHUPHUHUHUHU.?7?.?.?.?HUHUHUHUHUHUHUHUHUHUHUHUPHUHUHUHUHU.?=LK7?UOJMHMILINXN O*JL}LtPtPtPtPtPtPtPtPtPtPCEHFH`DIED==========================?B BA=@A=====================E=@==@9@.CBw;;;2;2;2;2;2;2;2;2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;%;;Q:;G:;;;;;;;;=::;;9;9;;;8h'$$("p#f"5"""!,,Q,++`++*.-V-,.k..N"1<{$m< (F#?kD _  v  s B ( ?>$eF,uaG2 2 h ) yRmS95PrHfX"P)s`# _E+x/*AD*@ lR+S"gWiFS9ްİѱM aQ7QsisiPPQQZZZZZZZZZZZZZZZxqjZZZZZZZZZZZxZZZݵZZӵɵZcZ\UZNumber too long?@@ @0@Identifier too long@@AUnimplementedUse of "do" to call subroutines is deprecated55\q\g\F\<\\[[[[v[U[ [ZZZmZfZZYYYhY_YGYXXXfX?XXW_WWVV[VV0UToTS;T`SRRRRRtRQRRQQQQuQQQPPP5P5kPVPAP,P#PPOOeO$5^O5WONOGO>O7O.OONNG5G_G5GF]FFEIE+E EDD55WDDCyC2CBzB@BAAjALA.AA@@r@7@???K??>>>n>N>$>>===O==<<<<{NOQRSTUVW\]^a nDm.z()*+/1tus cbmbb bG bb cbrvnnnnnnnnm~b Gbbbb b  cbPbb   m }~~x|nobmbbb  b nbbbbbb bmw{{ ppp}bbprppq,-yybzpp zzrpp{z zbbppy *cDt2 & JSTUVWXY  - ) ,8*+, 0M W& R) ct[v*+b c lc  ZWDaca*efIJK cw IJKM~ "c$zccIJK ij . c cbIJK,-IJKcIJKbIJKIJKIJK G 6bNIJKIJKG b$  )',K/c134567IJKb  ()*+ 6 / 1bIJK!"#$&X)bbbIJKbIJK%IJK;=>IJK8Dbb bNb]^VWa \]^babbbIJKijIJK=>bbb VW;<=>\]^aa#0IJKIJKIJK0VW\]^abb b   !"#$%&'()*+=/012356789:IJK?@ABCDEFWL\]^abXYZ_`cdI  !"#$%&'()*+/012356789:IJK?@ABCDEFIJKWL\]^baXYZ_`bcd  !"#$%&'()*+/012356789:?@ABCDEFLXYZ_`cd  !"#$%&'()*+/012356789:?@ABCDEF\]^LaXYZ_`cd  !"#$%&'()*+/012356789:?@ABCDEFLXYZ_`cd  !"#$%&'()*+/012356789:?@ABCDEFLXYZ_`cd  !#$%&'()*+/012356789:?@ABCDEFLXYZ_`=>cd  W%\]^a;<=>356789:?@ABCDFSTUVWL\]^aXYZ_`c  %356789:?@ABCD F LXYZ_`bc()*+/14;<=>IJKMNOPQRSTUVW \]^ab;<=>()*+/14TUVW;<=>\]^aIJKMNOPQRSTUVW\]^ab  %;<=>356789:?@ABCDFUVWL\]^aXYZ_` c  %;<=>356789:?@ABCDFVWL\]^aXYZ_` c  %()*+/1356789:?@ABCDFIJKLXYZ_`c  %356789:?@ABCDFLXYZ_` c  %356789:?@ABCDFLXYZ_` c  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDFLXYZ_`bc  %356789:?@ABCDF4L;<=>XYZ_`cNOPQRSTUVW4\]^a;<=>NOQRSTUVW4\]^a;<=>OQRSTUVW4\]^a;<=>QRSTUVW\]^a9vhf^dK]]Jnnnnnnn n5pqrstuwfFkXxY4}W~3]l]]QS9J]`t'!"#$%&()dynE,./012N+{9ij;P=?7yJB:|@CDiRkGlZmToJKvM|}~\._.]hV_xc=pu99==__    A_\b={*]L_HOJq]M !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12r345L678\wJM !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12s345L67z8\JUM !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12345L678\JM !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12345L678\JM !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12345L678\JM !"NaOP#QRSTUVWXYZ$%&'()*+,-./0[12345L678\JM !"NOP#QRSTUVWXYZ$%&'()*+,-./0[12345L678\ !"#$%&'()*+,-./012345L678 !"#$%&'()*]+,-./01]2]345678]]]]]]]]]]]]]]>]]]]]]]]]]]>]]]>]]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Jl !"#$%&'()*+,-./01234567J8 !"#$%&'()*+,-./01234567J8 !"#$%&'()*+,-./012345678g !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./012345678 !"#$%&'()*+,-./01234567<8 !"#$%&'()*+,-./01234567>8 !"#$%&'()*+,-./01234567L8 !"#$%&'()*+,-./012345678I=vvvvvvvvvvt*vvwvWvvnv?@ABCbDEFGHIo JJĺYè\10KIII< 2 Mϴc“͟˷ZH%,/aeNO]SXWV[s|}yzw~{xg`hGLMAM=56C3478uQdRlrpϮjOBDF@E2ObfP^vokqmi->>Atn_UT99<$ <<!"+><#.&':<*)9(; egfhfifjfkflfmnopqrrssttuuuuuuvuuuuuuuuuuuuuwuuuxxxxxxxxyyyzz{||}}~XcbM PO    Y !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLNQRSTUVWZ[\]^_`adUUUUUUCCan't undef active subroutinepanic: pad_alloc, %p!=%pscope"our" variable %-p redeclared%-p never introducedpanic: pad_free po%2d. 0x%lx<%lu> pad.cpanic: pad_add_name_pvn illegal flag bits 0x%lx"%s" variable %-p masks earlier declaration in same %s (Did you mean "local" instead of "our"?) panic: pad_findlex illegal flag bits 0x%lxVariable "%-p" is not availableVariable "%-p" will not stay sharedpanic: pad_findmy_pvn illegal flag bits 0x%lxpanic: pad_swipe curpad, %p!=%ppanic: pad_swipe po=%ld, fill=%ldpanic: pad_free curpad, %p!=%pPADNAME = 0x%lx(0x%lx) PAD = 0x%lx(0x%lx) %2d. 0x%lx<%lu> FAKE "%s" flags=0x%lx index=%lu %2d. 0x%lx<%lu> (%lu,%lu) "%s" panic: Incorrect version for previously generated inversion listpanic: reg_node overrun trying to emit %d, %p>=%pSequence (?#... not terminatedpanic: no svname in reg_scan_nameReference to nonexistent named group%s in regex; marked by <-- HERE in m/%.*s <-- HERE %s/panic: bad flag %lx in reg_scan_namepanic: re_dup unknown data code '%c'panic: attempting to append to an inversion list, but wasn't at the end of the list, final=%lu, start=%lu, match=%cpanic: Unknown flags %d in named_buff_iterpanic: Unknown flags %d in named_buff_scalarpanic: Unknown flags %d in named_buffPerl folding rules are not up-to-date for 0x%x; please use the perlbug utility to report; in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Corrupted regexp opcode %d > %dpanic! In trie construction, unknown node type %u %serror creating/fetching widecharmap entry for 0x%lXpanic! In trie construction, no char mapping for %ldQuantifier unexpected on zero-length expression in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Variable length lookbehind not implementedLookbehind longer than %lu not implemented in regex m/%.*s%s/Unterminated verb pattern argumentVerb pattern '%.*s' may not have an argumentVerb pattern '%.*s' has a mandatory argumentSequence %.3s... not terminatedSequence (%.*s...) not recognizedSequence (?%c... not terminatedpanic: reg_scan_name returned NULLpanic: paren_name hash element allocation failedSequence (?%c...) not implementedReference to nonexistent groupSequence (?{...}) not terminated or not {}-balancedEval-group not allowed at runtime, use re 'eval'Eval-group in insecure regular expressionSequence (?(%c... not terminatedSwitch condition not recognized(?(DEFINE)....) does not allow branchesSwitch (?(condition)... contains too many branchesUnknown switch condition (?(%.2sRegexp modifier "%c" may appear a maximum of twiceRegexp modifier "%c" may not appear twiceRegexp modifiers "%c" and "%c" are mutually exclusiveRegexp modifier "%c" may not appear after the "-"Useless (%s%c) - %suse /%c modifier in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Useless (%sc) - %suse /gc modifier in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Useless use of (?-p) in regex; marked by <-- HERE in m/%.*s <-- HERE %s/\N in a character class must be a named character: \N{...}\N{NAME} must be resolved by the lexerIgnoring zero length \N{} in character class in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Using just the first character returned by \N{} in character class in regex; marked by <-- HERE in m/%.*s <-- HERE %s/POSIX syntax [%c %c] belongs inside character classes in regex; marked by <-- HERE in m/%.*s <-- HERE %s/POSIX syntax [%c %c] is reserved for future extensionsInvalid escape in the specified encoding in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Unrecognized escape \%c in character class passed through in regex; marked by <-- HERE in m/%.*s <-- HERE %s/False [] range "%*.*s" in regex; marked by <-- HERE in m/%.*s <-- HERE %s/panic: invalid PL_utf8_foldclosures structure"\b{" is deprecated; use "\b\{" instead in regex; marked by <-- HERE in m/%.*s <-- HERE %s/"\B{" is deprecated; use "\B\{" instead in regex; marked by <-- HERE in m/%.*s <-- HERE %s/Sequence %.2s... not terminatedReference to nonexistent or unclosed groupUnrecognized escape \%.*s passed through in regex; marked by <-- HERE in m/%.*s <-- HERE %s/panic: Unknown regex character set encoding: %uQuantifier in {,} bigger than %d%.*s matches null string many times in regex; marked by <-- HERE in m/%.*s <-- HERE %s/%s in regex m/%.*s%s/Regexppanic: pregfree comppadregcomp.cpanic: regfree data code '%c'PERL_RE_COLORS%04lX INFINITY %04lX %04lX tuE_TRIE_MAXBUFdon't ?-Unterminated verb patternACCEPTCOMMITPRUNEUnknown verb pattern '%.*s'Sequence (?R) not terminatedIllegal patternExpecting close bracketnopSequence (? incompleteUnmatched (Unmatched )Junk on end of regexpaamsixRegexp out of spaceregcompU+?:\x{_iCasedXPosixLowerXPosixUpperalphspacgrapasciblancntralnuloweuppedigiprinpuncxdigitEmpty \%c{}Missing right brace on \%c{}%s%.*s%s INVLIST%cutf8::%s USER_DEFINEDXPosixAlnum+utf8::%s !utf8::%s XPosixAlphaXPosixDigitXPosixGraphXPosixPrintXPosixPunctXPosixWordInvalid [::] classInvalid [] range "%*.*s"ȀPOSIX class [:%.*s:] unknownUnmatched [Internal urpQuantifier follows nothingReference to invalid group 0Unterminated \g... patternUnterminated \g{...} patternTrailing \Internal disasterCan't do {n,m} with n > mNested quantifiersMULTILINESINGLELINEEXTENDEDKEEPCOPYCHARSETUNUSED_BIT_8ANCH_BOLANCH_MBOLANCH_SBOLANCH_GPOSGPOS_SEENGPOS_FLOATLOOKBEHIND_SEENEVAL_SEENCANY_SEENNOSCANCHECK_ALLMATCH_UTF8USE_INTUIT_NOMLUSE_INTUIT_MLINTUIT_TAILSPLITCOPY_DONETAINTED_SEENSTART_ONLYNULLSUCCEEDEOSMEOLSEOLNBOUNDNBOUNDLNBOUNDUNBOUNDAREG_ANYSANYCANYANYOFANYOFVNALNUMNALNUMLNALNUMUNALNUMANSPACENSPACELNSPACEUNSPACEANDIGITNDIGITLNDIGITACLUMPBRANCHBACKEXACTEXACTFEXACTFLEXACTFUEXACTFU_SSEXACTFU_TRICKYFOLDEXACTFANOTHINGSTARPLUSCURLYCURLYNCURLYMCURLYXWHILEMOPENCLOSENREFNREFFNREFFLNREFFUNREFFAIFMATCHUNLESSMSUSPENDIFTHENLONGJMPBRANCHJMINMODLOGICALRENUMTRIETRIECAHOCORASICKAHOCORASICKCGOSUBGOSTARTNGROUPPINSUBPDEFINEPENDLIKEOPFAILVERBMARKPOINTCUTGROUPKEEPSLNBREAKNVERTWSNHORIZWSOPTIMIZEDPSEUDOTRIE_nextTRIE_next_failEVAL_ABEVAL_AB_failCURLYX_endCURLYX_end_failWHILEM_A_preWHILEM_A_pre_failWHILEM_A_minWHILEM_A_min_failWHILEM_A_maxWHILEM_A_max_failWHILEM_B_minWHILEM_B_min_failWHILEM_B_maxWHILEM_B_max_failBRANCH_nextBRANCH_next_failCURLYM_ACURLYM_A_failCURLYM_BCURLYM_B_failIFMATCH_AIFMATCH_A_failCURLY_B_min_knownCURLY_B_min_known_failCURLY_B_minCURLY_B_min_failCURLY_B_maxCURLY_B_max_failCOMMIT_nextCOMMIT_next_failMARKPOINT_nextMARKPOINT_next_failSKIP_nextSKIP_next_failCUTGROUP_nextCUTGROUP_next_failKEEPS_nextKEEPS_next_failHRQ(T(T(T(T(T(T(T(T(T(T(T(THR(T(T(T(T(R(T(T(T(T(T(T(TRHS0S(T(THRRHRLWVtWtWtWtWtWtWtWtWtWtWtWtWLWtWtWtWtWVtWtWtWtWtWtWtWV|VLWtWtWLW VLWvwwwwvwvvvwvwvwwwwwvwwvwvwwwwwwwvwwwwvwvvvwvwvwwwwwvwwvwvwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwtwwwwwwwwwwwwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwvwwwww wwwwwwwwwwwwwwwwwwwwwwwwwwv~?X`lZUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU*UHUUUDUU}U2*UUUUUUUUUUUUUUU{U}UUUUUUUUUUUsUUUUUUUUUUUUUUUUUUUUUUUUUUUUSS++++++++++++++++++++++++++++++++++++++++++++++++++++++9+DDDDDDDDD4DDDDDDDDDD,hj\c"] """G.u.u.u.uG.uGGGuG.uG.u.u.u.utG.u.uG.uG.u.u.u.u.u.u.uG.u.u.u.uG.uGGGuG.uG.u.u.u.utG.u.uG.uG.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.ut.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u?t.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.uF.u.u.u.u.u?t.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.u.ut:;;;;:;:::;:;:;;;;~;:;;:;:;;;;;;;:;;;;:;:::;:;:;;;;~;:;;:;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;:HHHHHHHH^I^I^I^I^I^I^I^I^I^I^I^Ij^I^I^Ij^I^I^I^I^Ij^Ie^I^Il^I^Ill^I^I^I^I^I^I^I^I^IslXlllkP^IP^I^I^I^I^IBPOe^IOOO^IxOKJrM8P8P8P8PrM8PrMrMrMPrM8PrM8P8P8P8POrM8P8PrM8PrM8P8P8P8P8P8P8PrM8P8P8P8PrM8PrMrMrMPrM8PrM8P8P8P8POrM8P8PrM8PrM8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8PO8P8P8P8P8P8P8P8P8P8P8P8P8P8P8PP8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8PgP8P8P8P8P8PP8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P8P.Q^I^"^]]]\[[Vq[2ZZWIVIVVVXvXTTqTRdRR'RQ^^F=QvQ;QYNhz`z`z`^hz`z`1hhz`hhiz`z`z`z`fz`mf0sr8r8r8rqsrr8r8rxs8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8rr8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8rpo8ro8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8r8rxmsH!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!l!lPPPPPPPPP!l!l!l!l!l!l!lʆ!l!l>!l!l!l!lW!l!lӄ!l!lg!l?!l!l!l!l!l!l!l!l!l!lP؅!l!l!l!l!l!l!l!l!l!l!l!l{ { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { { {{{{{{{{{{{ { { { { { { { r r r r { { r r { { r { { r { r { r r { { r r r { r { { { { { {| rl| r|4z r r { { r { {Kzbz r {z r3y { r rJy { rpfփzz  vlhv,,=!<,>x !"#$%&'()*+,klmn@-./9:;<=>?BCDEFGHIJKNOR   ####'''***-./0000000779:;;;;?@ABBBBBBBBBBRRRRPQRSTURWWWW[\]^_```ccccccijklmn7pWWSS>>??????????..====LL;;;;;;ggeeffhhiiC%*s%cx{%lx}%c%03o%c%o\0WILDSV_UNDEFSV_NOSV_YESSV_PLACEHOLDER<%lu%s>CV(%s)[%s] [UTF8 "%s"](%ld) [tainted](%g) SUB %s = (xsub 0x%lx %d) FORMAT %s = (RUNTIME){} { PMf_PRE %c%s%c%s PMf_PRE (RUNTIME) PMf_REPL = ,ONCE:USED,TAINTED,SCANFIRST,ALL,SKIPWHITEPMFLAGS = (%s) (%lu) %-4lu????%*sTYPE = %s ===> NULL (was %s) LINE = %lu PACKAGE = "%s" LABEL = "%s" TARG = %ld ,VOID,SCALAR,LIST,UNKNOWN,LATEFREE,LATEFREED,ATTACHED,TARGET_MY,SV,AV,HV,MAYBE_LVSUB,LVAL_DEFER,STRICT_REFS,OUR_INTRO,FT_ACCESS,FT_STACKED,INTROPRIVATE = (%s) PADIX = %ld REDO ===> DONE NEXT ===> LAST ===> OTHER ===> REFCNT = %lu GV_NAME = %s-> %s%s = 0x%lx %s "%s" "%s" :: "ANONMAINUNIQUEUNDEFINEDSV = 0 PADSTALE,PADTMP,PADMY,ROK,WEAKREF,PCS_IMPORTED,SCREAM,IMPORT ),EVALED,IsUV,VALID,TYPED,OUR,STATE,SV = %s%s UNKNOWN(0x%lx) %s UV = %lu IV = %ld COP_LOW = %lu COP_HIGH = %lu RV = 0x%lx OFFSET = %lu PV = 0x%lx ( %s . ) CUR = %ld LEN = %ld PV = 0 OURSTASH STASH RARE = %u PREVIOUS = %lu USEFUL = %ld ARRAY = 0x%lx (offset=%ld) ALLOC = 0x%lx FILL = %ld MAX = %ld ARYLEN = 0x%lx ,REAL,REIFY FLAGS = (%s) Elt No. %ld %d%s:%d hash quality = %.1f%% KEYS = %ld RITER = %ld EITER = 0x%lx PMROOT = 0x%lx NAME = "%s" NAMECOUNT = %ld , ", (null) ENAME = %s ENAME = "%s" BACKREFS = 0x%lx MRO_WHICH = "%.*s" (0x%lx) CACHE_GEN = 0x%lx PKG_GEN = 0x%lx MRO_LINEAR_ALL = 0x%lx MRO_LINEAR_CURRENT = 0x%lx MRO_NEXTMETHOD = 0x%lx ISA = 0x%lx Elt %s [UTF8 "%s"] [CURRENT] [REHASH] HASH = 0x%lx AUTOLOAD = "%.*s" PROTOTYPE = "%.*s" COMP_STASH START = 0x%lx ===> %ld ROOT = 0x%lx XSUB = 0x%lx XSUBANY = 0x%lx (CONST SV) XSUBANY = %ld GVGV::GV DEPTH = %ld OUTSIDE_SEQ = %lu LINES = %ld PADLIST = 0x%lx OUTSIDE = 0x%lx (%s) TYPE = %c TARGOFF = %ld TARGLEN = %ld TARG = 0x%lx FLAGS = %ld NAMELEN = %ld GvSTASH GP = 0x%lx SV = 0x%lx REFCNT = %ld IO = 0x%lx FORM = 0x%lx AV = 0x%lx HV = 0x%lx CV = 0x%lx CVGEN = 0x%lx LINE = %ld FILE = "%s" FLAGS = 0x%lx EGV IFP = 0x%lx OFP = 0x%lx DIRP = 0x%lx PAGE = %ld PAGE_LEN = %ld LINES_LEFT = %ld TOP_NAME = "%s" TOP_GV TOP_GV = 0x%lx FMT_NAME = "%s" FMT_GV FMT_GV = 0x%lx BOTTOM_NAME = "%s" BOTTOM_GV BOTTOM_GV = 0x%lx TYPE = '%c' TYPE = '\%o' EXTFLAGS = 0x%lx (%s) INTFLAGS = 0x%lx NPARENS = %lu LASTPAREN = %lu LASTCLOSEPAREN = %lu MINLEN = %ld MINLENRET = %ld GOFS = %lu PRE_PREFIX = %lu SEEN_EVALS = %lu SUBLEN = %ld SUBBEG = 0x%lx %s SUBBEG = 0x0 ENGINE = 0x%lx MOTHER_RE = 0x%lx PAREN_NAMES = 0x%lx SUBSTRS = 0x%lx PPRIVATE = 0x%lx OFFS = 0x%lx NV = %.*g (sv(\0) MAGIC = 0x%lx MG_VIRTUAL = &PL_vtbl_%s MG_VIRTUAL = 0x%lx MG_VIRTUAL = 0 MG_PRIVATE = %d MG_FLAGS = 0x%02X TAINTEDDIR MINMATCH REFCOUNTED GSKIP COPY DUP LOCAL MG_OBJ = 0x%lx PAT = %s MG_LEN = %ld MG_PTR = 0x%lx => HEf_SVKEY %2ld: %lu -> %lu MG_TYPE = PERL_MAGIC_%s MG_TYPE = UNKNOWN(\%o) (NULL)[%lu]NULL OP IN RUN%5lu %s PMf_MULTILINE,PMf_SINGLELINE,PMf_FOLD,PMf_EXTENDED,PMf_KEEPCOPY,ANCH_BOL,ANCH_MBOL,ANCH_SBOL,ANCH_GPOS,GPOS_SEEN,GPOS_FLOAT,LOOKBEHIND_SEEN,EVAL_SEEN,CANY_SEEN,NOSCAN,CHECK_ALL,MATCH_UTF8,USE_INTUIT_NOML,USE_INTUIT_ML,INTUIT_TAIL,SPLIT,COPY_DONE,TAINTED_SEEN,TAINTED,START_ONLY,SKIPWHITE,NULL, SV AV HV CVINTRO,MULTI,ASSUMECV,IN_PAD,SHAREKEYS,LAZYDEL,HASKFLAGS,REHASH,CLONEABLE,ANON,UNIQUE,CLONE,CLONED,CONST,NODEBUG,LVALUE,METHOD,WEAKOUTSIDE,CVGV_RC,DYNFILE,AUTOLOAD,ISXSUB,OOK,FAKE,READONLY,BREAK,OVERLOAD,pIOK,pNOK,pPOK,TEMP,OBJECT,GMG,SMG,RMG,arylen(#)rhash(%)pos(.)symtab(:)backref(<)arylen_p(@)overload(A)overload_elem(a)bm(B)overload_table(c)regdata(D)regdatum(d)env(E)envelem(e)fm(f)study(G)regex_global(g)hints(H)hintselem(h)isa(I)isaelem(i)nkeys(k)dbfile(L)dbline(l)shared(N)shared_scalar(n)collxfrm(o)tied(P)tiedelem(p)tiedscalar(q)qr(r)sig(S)sigelem(s)taint(t)uvar(U)uvar_elem(u)vstring(V)vec(v)utf8(w)substr(x)defelem(y)checkcall(])ext(~),HUSH_VMSISH,EXISTS_SUB,SLICE,GUESSED,EARLY_CV,LINENUM,INPLACE,DOLIST,BACKWARDS,REFCOUNTED,COMMON,EXIT_VMSISH,IN_RAW,IN_CRLF,OUT_RAW,OUT_CRLF,NUMERIC,INTEGER,REVERSE,DESCEND,QSORT,STABLE,NOVER,SHORTCIRCUIT,STRICT,ENTERED,BARE,WARNING,DB,HASTARG,AMPER,NOPAREN,INARGS,FROM_UTF,TO_UTF,IDENTICAL,SQUASH,COMPLEMENT,GROWS,DELETE,KIDS,PARENS,REF,MOD,STACKED,SPECIAL,CONST,KEEP,GLOBAL,CONTINUE,RETAINT,EVAL,NONDESTRUCTBINDPVPVIVPVNVPVMGREGEXPPVLVPVGVPVAVPVHVPVCVPVFMPVIO(0x%lx) at 0x%lx %*s REFCNT = %ld %*s FLAGS = ( ???? - dump.c does not know how to handle this MG_LENWARNING: %lx changed from %lx to %lx WATCHING, %lx is currently %lx HXȞȞlY@PRINT at %s line %ld, <%-p> %s %ld during global destructionpanic: unknown study size %uutil.cEXECInsecure %s%sCan't fork: %sunopenedclosedsocket%s%s on %s %s%s%-pwidthInteger overflow in versionv.Inforiginalvinf%.9fInvalid version object%d.%0*d_%d%0*dv%ld.%ld/dev/urandomPERL_HASH_SEEDXS_VERSION%-p::%s$%-p::%s %-pbootstrap parameter %-pexecute on PATH, '.' not in PATHCan't %s %s%s%sCan't fork, trying again in 5 secondspanic: kid popen errno read, n=%upanic: pthread_setspecific, error=%dFilehandle %-p opened only for %sputFilehandle opened only for %sput (Are you trying to call %s%s on dirhandle%s%-p?) Invalid version format (dotted-decimal versions require at least three parts)Invalid version format (no leading zeros)Invalid version format (maximum 3 digits between decimals)Invalid version format (no underscores)Invalid version format (multiple underscores)Invalid version format (underscores before decimal)Invalid version format (0 before decimal required)Invalid version format (negative version number)Invalid version format (version required)Invalid version format (non-numeric data)Invalid version format (alpha without decimal)Invalid version format (misplaced underscore)Invalid version format (fractional part required)Invalid version format (dotted-decimal versions must begin with 'v')Integer overflow in version %dVersion string '%s' contains invalid data; ignoring: '%s'Unknown Unicode option letter '%c'Unknown Unicode option value %luYour random numbers are not that randompanic: my_snprintf buffer overflowpanic: my_vsnprintf buffer overflow%-p object version %-p does not match Perl API version %-p of %-p does not match %-p99988999899899899989999999999999899999998999998vaJCC@Size magic not implementedopen<open>warnings::BitsUUUUUUUUUUUUUpanic: magic_len: %ldSTOREFETCHSIZECLEARNEXTKEYFIRSTKEYEXISTSsubstr outside of stringassigning to $^Omg.cCan't set $0 with prctl(): %sCHLDCLDIGNORE__DIE____WARN__No such hook: %sNo such signal: SIG%sDEFAULTsigno\^\__tdDedded\\\\d$dl]\\cdcc\d\\\\\\\\\\ta\\`4b\]_Ta\a\^l^\\\\\\\\\\\\\ee|_b\\\\\\\\\\\\\\\\\\\\\\\\\\\]b\b\,]\\\\\\\\\\\\\\\\\\\\\\\\\\\_\ehhggggggggggggggggggggggg+hhggghggggghhhhhhhhhggggggggggggggggggggggggggggggggggggggxh(YސY< xRX;tHo\\\\\\\\\tHŽ3ȔtpϓMaximal count of pending signals (%lu) exceededFETCHSIZE returned a negative valueAttempt to set length of freed arrayAttempt to use reference as lvalue in substrAssigning non-zero to $[ is no longer possibleSignal SIG%s received, but no signal handler set. SIG%s handler "%s" not defined. gethostbyaddrgethostbynamegethostentgetgrnamgetgrgidgetgrentgetnetbyaddrgetnetbynamegetnetentgetpwnamgetpwuidgetpwentgetprotobynamegetprotobynumbergetprotoentgetservbynamegetservbyportgetserventhhhHHH  panic: hv_store() failed in set_mro_private_data() for '%.*s' %dpanic: hv_store() failed in mro_register() for '%.*s' %dCan't linearize anonymous symbol tableRecursive inheritance detected in package '%2p'Can't call mro_isa_changed_in() on anonymous symbol tableCan't call mro_method_changed_in() on anonymous symbol tablepanic: invalid MRO!classnameNo such class: '%-p'!Invalid mro name: '%-p'mro::method_changed_indfsmro.cfcsayelseif should be elsif__SUB__ (Px@hX tWO+}jvuuuuuuuuuuuuuuuuuuuuuuuuuuuOuuuu.ufC& uc<H  o #  K  $ ?t4 \ a>L|~`panic: pp_iter, type=%upanic: pp_subst, pm=%p, s=%pSubstitution loopNot a CODE referencea subroutineClosure prototype calledUndefined subroutine calledDB::lsubNo DB::sub routine definedOut of memory during array extenda HASHan ARRAYsv_vcatpvfn()Missing argument in %ssv_vcatpvfnpanic: del_backref, svp=0 in panic: frexp"%\%03loend of stringBizarre copy of %s in %sBizarre copy of %sCannot copy to %s in %sCannot copy to %s%2p::%2pVSTRINGFORMATGLOBLVALUECan't upgrade %s (%lu) to %luIO::File::sv.cCan't weaken a nonreferenceReference is already weakBizarre SvTYPE [%ld]utf8_mg_pos_cache_updatesv_pos_u2b_cacheNULLREFsv_len_utf8sv_pos_b2uWide character in %sWide characterArgument "%s" isn't numericNot a subroutine referencecat_decodeWide character in $/CLONE_SKIPBad filehandle: %2pBad filehandle: %-p{%s}within $.${$/}Integer overflow in format string for %spanic: %s cache %lu real %lu for %-ppanic: del_backref, *svp=%p phase=%s refcnt=%lupanic: del_backref, *svp=%p, sv=%pinternal %%p might conflict with future printf extensionsvector argument not supported with alpha versionsInvalid conversion in %sprintf: panic: attempt to copy value %-p to a freed scalar %ppanic: attempt to copy freed scalar %p to %pUndefined value assigned to typeglobsv_upgrade from type %d down to type %dpanic: sv_upgrade to unknown type %luDESTROY created new reference to dead object '%2p'Attempt to free unreferenced scalar: SV 0x%lx, Perl interpreter: 0x%pDon't know how to handle magic of type \%oCloning substitution context is unimplementedpanic: ss_dup inconsistency (%ld)panic: sv_pos_b2u: bad byte offset, blen=%lu, byte=%lupanic: sv_chop ptr=%p, start=%p, end=%ppanic: sv_setpvn called with negative strlen %ldArgument "%s" isn't numeric in %ssv_2iv assumed (U_V(fabs((double)SvNVX(sv))) < (UV)IV_MAX) but SvNVX(sv)=%g U_V is 0x%lx, IV_MAX is 0x%lx Unable to create sub named "%-p"panic: reference miscount on nsv in sv_replace() (%lu != 1)Can't bless non-reference valueCan't coerce %s to integer in %sInvalid argument to sv_cat_decodeCan't coerce %s to number in %sLost precision when incrementing %f by 1Lost precision when decrementing %f by 1Can't coerce readonly %s to string in %sCan't coerce readonly %s to stringCan't coerce %s to string in %spanic: sv_insert, midend=%p, bigend=%psemi-panic: attempt to dup freed stringpanic: magic_killbackrefs (freed backref AV/SV)panic: magic_killbackrefs (flags=%lx)WATCHING: %lx cloned as %lx with value %lx HGGHGGGGGGGHGHGGGTTTTTTTTTT]STTTTTTTTTTTTTTTTTTTTTTTTTTTTTT]STTTTT]S_@HCTTTT@H@H@H@H@H@H@H_@H@H@H@H@H_@H@H_@H@H@H@H@H@H@H@H@H__ITTTT@HIT@H@H@H@H^^`^@H@H]@H]@H@H__````````````a````a````````_``_``````_llllllllllll `llllAalll_llll_ll_lllll_aaaaaaaaaaaaaaaaaaaaaaLaaaaaaaaaaaaaaLaz|X|y|(|z{@|{{||||Ʉ]؄@PPPPPP0|0|ttttttt4ܐT̐d˒4 ˒˒˒˒llUUUULUUđđUUUt  ?C@C@Not an ARRAY referenceNot a GLOB referencea symbolIllegal modulus zeroNot a SCALAR referenceCORE::ILEHANDLEACKAGE(anonymous)Illegal division by zeroCan't take %s of %g0 but trueNot a HASH referenceSPLICEpanic: pp_split, pm=%p, s=%pSplit loop[out of range]Not enoughscalar referencereference to one of [$@%*]reference to one of [$@%&*]Too many%s arguments for %spanic: unknown OA_*: %xNot an unblessed ARRAY referenceCan't return array to lvalue scalar contextCan't return hash to lvalue scalar contextCan't find an opnumber for "%s"Attempt to bless into a referenceExplicit blessing to '' (assuming package main)Use of *glob{FILEHANDLE} is deprecatedConstant subroutine %-p undefinedType of argument to %s must be unblessed hashref or arrayrefpanic: avhv_delete no longer supportedOdd number of elements in anonymous hashsplice() offset past end of arraypanic: unimplemented op %s (#%d) calledType of arg %d to &CORE::%s must be hash referenceType of arg %d to &CORE::%s must be %s8@dD$X(HXXOut of memory during string extendOut of memory during list extendCan't use string ("%-32p"%s) as %s ref while "strict refs" in usepanic: leave_scope pad codepanic: pad offset %lu out of range (%p-%p)panic: save_alloc elems %lu out of range (%ld-%ld)panic: corrupt saved stack index %ldpanic: leave_scope inconsistency %ud<, , 32 non-portableNegative offset to vec in lvalue contextpanic: do_vop called for op %u (%s)Can't exec "%s": %ssysopenUnknown open() mode '%.*s'Missing command in piped openCan't open bidirectional pipeARGVOUTinplace openCan't open %s: %sprintUse of -l on filehandle %2plstat -ccsh$&*(){}[]'";\|?<>~` Arg too short for msgsnd -cf 'set nonomatch; glob ' 2>/dev/null |Warning: unable to close filehandle %2p properly. panic: sysopen with multiple args, num_svs=%ldMore than one argument to '%c&' openMore than one argument to '>%c' openMore than one argument to '<%c' openFilehandle STD%s reopened as %2p only for inputFilehandle STDIN reopened as %2p only for outputCan't do inplace edit: %s is not a regular fileCan't rename %s to %-p: %s, skipping fileCan't remove %s: %s, skipping fileCan't do inplace edit on %s: %sUnrecognized signal name "%-p"Can't kill a non-numeric process IDBad arg length for %s, is %lu, should be %ldAP@C`DEP@P@P@P@P@P@P@P@P@P@P@P@P@P@P@P@P@@The stat preceding -l _ wasn't an lstatUUUUUUCpanic: Unexpected op %ucorrupted regexp pointers̀Infinite recursion in regexREGMARK%lx %d regexp memory corruptionREGERRORpanic: unknown regstclass %dcorrupted regexp programMalformed UTF-8 character (fatal)panic: paren_elems_to_push, %i < 0panic: paren_elems_to_push offset %lu out of range (%lu-%ld)panic: Unexpected FLAGS %u in op %uPattern subroutine nesting without pos change exceeded limit in regexEVAL without pos change exceeded limit in regexComplex regular subexpression recursion limit (%d) exceededzzzyy\vuuTu|{\{{w\wwvl} }}yttLtss>>h(U!R{ QQ   V Bof35EDjcJ%s: illegal mapping '%s'TYPEEXTRASINVERT_ITUTF-16 surrogate U+%04lXMalformed UTF-8 character%s (empty string)Malformed UTF-16 surrogateSPECIALSSWASHNEWIsWordXIdStart_Perl_IDStartXIdContinueIsAlphaIsXPerlSpaceIsDigitIsUppercaseIsLowercaseIsGraphIsPrintIsPunctIsXDigitIsM_X_Begin_X_ExtendGCB=PrependHST=Not_ApplicableGCB=LGCB=LVGCB=LVTGCB=TGCB=V_X_LV_LVT_V_Perl_QuotemetaToUcutf8::ToSpecUcToTcutf8::ToSpecTcToLcutf8::ToSpecLcutf8::ToSpecCfToCf\x{%lx}panic: swatch_get doesn't expect bits %lupanic: swatch_get found swatch size mismatch, bits=%lu, otherbits=%lupanic: swatch_get got improper swatchpanic: swatch_get found swatch length mismatch, slen=%lu, olen=%luCode point 0x%04lX is not Unicode, may not be portableUnicode non-character U+%04lX is illegal for open interchange%s (unexpected continuation byte 0x%02x, with no preceding start byte)%s (unexpected non-continuation byte 0x%02x, immediately after start byte 0x%02x)%s (unexpected non-continuation byte 0x%02x, %d bytes after start byte 0x%02x, expected %d bytes)%s (%d byte%s, need %d, after start byte 0x%02x)%s Code point beginning with byte 0x%02X is not Unicode, and not portable%s (overflow at byte 0x%02x, after start byte 0x%02x)Malformed UTF-8 character (unexpected non-continuation byte 0x%02x, immediately after start byte 0x%02x)%s%spanic: utf16_to_utf8: odd bytelen %lupanic: utf16_to_utf8_reversed: odd bytelen %lupanic: to_upper_title_latin1 did not expect '%c' to map to '%c'panic: swash_fetch got improper swatch, svp=%p, tmps=%p, slen=%lu, needents=%luCode point 0x%04lX is not Unicode, all \p{} matches fail; all \P{} matches succeedpanic: swash_fetch got swatch of unexpected bit width, slen=%lu, needents=%lupanic: swash_inversion_hash doesn't expect bits %lupanic: value returned from hv_iternextsv() unexpectedly is not a string, flags=%lupanic: hv_store() unexpectedly failedpanic: av_fetch() unexpectedly failedpanic: unexpected entry for %spanic: _swash_to_invlist only operates on boolean properties, bits=%lu, otherbits=%luCan't find Unicode property definition "%-p"Operation "%s" returns its argument for UTF-16 surrogate U+%04lXOperation "%s" returns its argument for non-Unicode code point 0x%04lXUnicode surrogate U+%04lX is illegal in UTF-8Malformed UTF-8 character (unexpected end of string) while running setuid while running setgid while running with -t switch while running with -T switchIFSanother variable%%ENV is aliased to %s%s%%ENV is aliased to %%%s%s$ENV{PATH}Insecure directory in %s%sTERM-_.+Insecure $ENV{%s}%sCDPATHBASH_ENV => Internals::HvREHASH $hashrefUsage: invocant->DOES(kind)Usage: %2p::%2p(%s)Usage: %2p(%s)Usage: CODE(0x%lx)(%s)reference, kindobject-ref, methodclass, versionv%slobj, ...lobj is not of type versionlobjsv, failok=0SCALAR[, ON]SCALAR[, REFCOUNT]filehandle[,args]inputoutputdetails%-p(%-p)name[, all ][all]msixpRegexp::UNIVERSAL::isaUNIVERSAL::canUNIVERSAL::DOESUNIVERSAL::VERSIONversion::()version::newversion::parseversion::(""version::stringifyversion::(0+version::numifyversion::normalversion::(cmpversion::(<=>version::vcmpversion::(boolversion::booleanversion::(+version::(-version::(*version::(/version::(+=version::(-=version::(*=version::(/=version::(absversion::(nomethodversion::noopversion::is_alphaversion::qvversion::declareversion::is_qvutf8::is_utf8utf8::validutf8::encodeutf8::decodeutf8::upgradeutf8::downgradeutf8::native_to_unicodeutf8::unicode_to_nativeInternals::SvREADONLY\[$%@];$Internals::SvREFCNT\%PerlIO::get_layers*;@Internals::hash_seedInternals::rehash_seedInternals::HvREHASHre::is_regexpre::regname;$$re::regnamesre::regnames_countre::regexp_patternCannot find version of an unblessed reference%2p does not define $%2p::VERSION--version check failed%-p defines neither package nor VERSION--version check failed%2p version %-p required--this is only version %-poperation not supported with version objectget_layers: unknown argument '%s'NULL array element in re::regnames()Internals::hv_clear_placeholdersuniversal.cY  DD@D@@@@DD@! @DD" ++dDdDl\l\>>> ">>&&&&&&..  H6@024;;;KKKHBDK  $B"$$444A $ATHATH@@I! $M$  @ @ A$D D D D D D@@@ d)d k d Et!{{DK d Dd d d d  d d dd d dddddd d dddkklllllllllllllllllllllllllll$$$$ dk kdkk ]]$            @@ {X h HAS_TIMES MULTIPLICITY PERLIO_LAYERS PERL_IMPLICIT_CONTEXT USE_64_BIT_ALL USE_64_BIT_INT USE_ITHREADS USE_LARGE_FILES USE_LOCALE_COLLATE USE_LOCALE_NUMERIC USE_PERLIO USE_REENTRANT_APIT(3>IU`kvͮü¢кƳ֦̠󬡾˽ūğ  !"#$%&')*+,-./012456789:;<=?@ABCDEFGHJKLMNOPQRSVWXYZ[\]^_abcdefghijlmnopqrstuwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~  !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~  !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~  !"#$%&'()*+,-./0123456789:;<=>?@  !"#$%&'()*+,-./0123456789:;<=>?`!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_/usr/bin/csh/bin/sh0123456789abcdef0123456789ABCDEF1panic: memory wrapCan't localize through a reference"%s" variable %s can't be in a packageThe %s function is unimplementedUnsupported directory function "%s" calledUnsupported socket function "%s" calledInsecure dependency in %s%sOut of memory! Modification of a read-only value attemptedModification of non-creatable hash value attempted, subscript "%-p"Modification of non-creatable array value attempted, subscript %dCan't use an undefined value as %s referenceCan't use string ("%-32p") as %s ref while "strict refs" in useCan't use string ("%.32s") as %s ref while "strict refs" in useCan't use %s ref as %s refUnsuccessful %s on filename containing newlineUnquoted string "%s" may clash with future reserved wordSemicolon seems to be missingUse of uninitialized value%-p%s%sUse of uninitialized value%s%s%s p f f f f f f f@ f@ f f f f@ f f fC8C8C8C8C8C8C8C8C8C8@ f f f f f f fO<~O<>O<>O<>O<>O<~O<O<^O<^O<^O<^O<^O<O<^O<O<O<O<O<^O<^O<O<O<^O<O<^O< f f f f@append I/O operatorregexp internal guardregexp internal resetregexp compilationpattern match (m//)pattern quote (qr//)substitution (s///)substitution iteratortransliteration (tr///)scalar assignmentlist assignmentscalar chopscalar chompdefined operatorundef operatormatch positioninteger preincrement (++)integer predecrement (--)integer postincrement (++)integer postdecrement (--)exponentiation (**)integer multiplication (*)integer division (/)integer modulus (%)repeat (x)integer addition (+)integer subtraction (-)concatenation (.) or stringleft bitshift (<<)right bitshift (>>)numeric lt (<)integer lt (<)numeric gt (>)integer gt (>)numeric le (<=)integer le (<=)numeric ge (>=)integer ge (>=)numeric eq (==)integer eq (==)numeric ne (!=)integer ne (!=)numeric comparison (<=>)integer comparison (<=>)string ltstring gtstring lestring gestring eqstring nestring comparison (cmp)bitwise and (&)bitwise xor (^)bitwise or (|)integer negation (-)not1's complement (~)smart matchsrandhexoctrindexsprintfcryptucfirstlcfirstuclcquotemetaarray dereferenceconstant array elementarray sliceeach on arraykeys on arrayvalues on arrayexistshash dereferencehash elementhash sliceboolkeyssplitjoin or stringlist sliceanonymous list ([])anonymous hash ({})splicepushpopunshiftreversegrepgrep iteratormapmap iteratorflipfloprange (or flip)range (or flop)logical and (&&)logical or (||)logical xordefined or (//)conditional expressionlogical and assignment (&&=)logical or assignment (||=)defined or assignment (//=)method lookupsubroutine exitlvalue subroutine returncallerwarndiesymbol resetline sequencedebug next statementiteration finalizerblock entryblock exitforeach loop entryforeach loop iteratorloop exitlastredodumpmethod with known namegiven()leave given blockwhen()leave when blockbreakcontinuefilenobinmodeuntietieddbmopendbmcloseselect system callgetcwrite exitsysseeksysreadsyswriteeoftellfcntlioctlflocksendrecvbindconnectlistenacceptshutdowngetsockoptsetsockoptgetsocknamegetpeername-R-W-r-w-x-s-M-A-C-O-o-z-S-b-f-d-u-g-k-l-t-T-Bchownunlinkchmodutimesymlinkreadlinkopendirreaddirtelldirseekdirrewinddirclosedirforkwaitwaitpidkillgetppidgetpgrpgetprioritytimesalarmsleepshmgetshmctlshmreadshmwritemsggetmsgctlmsgrcvsemopsemgetsemctldo "file"eval hintseval "string"eval "string" exiteval {block}eval {block} exitsethostentsetnetentsetprotoentsetserventendhostentendnetentendprotoentendserventsetpwentendpwentsetgrentendgrentonceunknown custom operatoreach on referencekeys on referencevalues on referenceCORE:: subroutineconstgvsvpadsvpadavpadhvpadanypushrerv2gvrv2svav2arylenrv2cvanoncodesrefgenrcatlineregcmayberegcresetsubstsubstconttranstransrsassignaassignschopschompi_preinci_predeci_postinci_postdecpowi_multiplyi_dividei_modulorepeati_addi_subtractconcatleft_shiftright_shifti_lti_gti_lei_gei_eqi_nei_ncmpsltsgtslesgesnescmpbit_andbit_xorbit_ori_negatecomplementsmartmatchrv2avaelemfastaelemfast_lexasliceaeachakeysavaluesrv2hvhelemhslicejoinlsliceanonlistanonhashgrepstartgrepwhilemapstartmapwhilerangeflipdorcond_exprandassigndorassignentersubleavesubleavesublvlineseqnextstatedbstateunstackenterleaveenteriterenterloopleaveloopmethod_namedentergivenleavegivenenterwhenleavewhenpipe_opsselectenterwriteleavewriteprtfsockpairgsockoptssockoptftrreadftrwriteftrexecftereadftewritefteexecftisftsizeftmtimeftatimeftctimeftrownedfteownedftzeroftsockftchrftblkftfileftdirftpipeftsuidftsgidftsvtxftlinkftttyfttextftbinaryopen_dirtmsdofilehintsevalleaveevalentertryleavetryghbynameghbyaddrghostentgnbynamegnbyaddrgnetentgpbynamegpbynumbergprotoentgsbynamegsbyportgserventshostentsnetentsprotoentsserventehostentenetenteprotoenteserventgpwnamgpwuidgpwentspwentepwentggrnamggrgidggrentsgrentegrentcustomreachrkeysrvaluescoreargsruncvCONSTRUCTZEROHUPQUITTRAPABRTBUSFPEKILLUSR1SEGVUSR2PIPESTKFLTCONTSTOPTSTPTTINTTOUURGXCPUXFSZVTALRMPROFWINCHPWRSYSNUM32NUM33RTMINNUM35NUM36NUM37NUM38NUM39NUM40NUM41NUM42NUM43NUM44NUM45NUM46NUM47NUM48NUM49NUM50NUM51NUM52NUM53NUM54NUM55NUM56NUM57NUM58NUM59NUM60NUM61NUM62NUM63RTMAXIOTPOLLUNUSEDconstant lexical array element(none)PERLIO_DEBUG%.40s:%ld warning:%s Clone %p from %p (Null)PerlIO_pop f=%p %s %.*s => %p PerlIOPerlIO::Layer::NoWarningsCannot find %.*s PerlIO::Layerdefine %s %p Unknown PerlIO layer "%.*s"Pushing %s Layer %ld is %s PERLIOperlio.cPerlIO::Layer::findsize expected by this perlPerlIO layer instance sizePerlIO_push f=%p %s %s %p Cannot flush f=%p Destruct %p Destruct popping %s :raw f=%p :%s fdupopen f=%p param=%p refcnt_dec: fd %d: %d <= 0 refcnt_dec: fd %d refcnt=%d refcnt_dec: fd %d < 0 refcnt: fd %d: %d <= 0 refcnt: fd %d < 0 Unknown PerlIO layer "scalar"HashCodeIrIwZeroing %p, %d refcnt_inc: fd %d: %d <= 0 refcnt_inc: fd %d refcnt=%d refcnt_inc: fd %d < 0 Cleanup layers for %p r+TMPDIRw+crlfpendingperliostdiounixpanic: vsnprintf buffer overflowRecursive call to Perl_load_module in PerlIO_find_layerUsage class->find(name[,load])Invalid separator character %c%c%c in PerlIO layer specification %sArgument list not closed for PerlIO layer "%.*s"panic: PerlIO layer array corruptPerlIO layer function table size%s (%lu) does not match %s (%lu)%s (%lu) smaller than %s (%lu)PerlIO_binmode f=%p %s %c %x %s PerlIOBase_dup %s f=%p o=%p param=%p refcnt_dec: fd %d >= refcnt_size %d refcnt: fd %d >= refcnt_size %d Don't know how to get file nameMore than one argument to open(,':%s')openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p) More fds - old=%d, need %d, new=%d Integer overflow in binary numberIllegal binary digit '%c' ignoredBinary number > 0b11111111111111111111111111111111 non-portableInteger overflow in hexadecimal numberIllegal hexadecimal digit '%c' ignoredHexadecimal number > 0xffffffff non-portableInteger overflow in octal numberIllegal octal digit '%c' ignoredOctal number > 037777777777 non-portableAA0@ @:rawCan't fix broken locale name "%s"panic: strxfrm() gets absurd - a => %lu, ab => %luperl: warning: Setting locale failed. perl: warning: Please check that your locale settings: are supported and installed on your system. perl: warning: Falling back to the standard locale ("C"). perl: warning: Failed to fall back to the standard locale ("C"). POSIXabunsetLANGUAGELC_ALLPERL_BADLANG LANGUAGE = %c%s%c, LC_ALL = %c%s%c, LC_LC_ALL= %.*s = "%s", LANG = %c%s%c UTF-8PERL_UNICODENo group ending character '%c' found in templatepack/unpack repeat count overflowCharacter(s) in '%c' format wrapped in %s()-group starts with a count in %sToo deeply nested ()-groups in %s'%c' allowed only after types %s in %sCan't use both '<' and '>' after type '%c' in %sCan't use '%c' in a group with different byte-order in %sDuplicate modifier '%c' after '%c' in %s'/' does not take a repeat count in %sWithin []-length '*' not allowed in %sWithin []-length '%c' not allowed in %spanic: marks beyond string end, m=%p, marks=%p, level=%dMalformed UTF-8 string in '%c' format in unpackCharacter in '%c' format wrapped in unpack'@' outside of string in unpack'@' outside of string with malformed UTF-8 in unpackMalformed UTF-8 string in unpack'X' outside of string in unpack'x' outside of string in unpack'/' must follow a numeric type in unpackUnterminated compressed integer in unpack'P' must have an explicit size in unpackCount after length/code in unpacklength/code after end of string in unpackCode missing after '/' in unpackCode missing after '/' in packMalformed UTF-8 string in pack'%c' outside of string in packpanic: predicted utf8 length not available, for '%c', aptr=%p end=%p cur=%p, fromlen=%luCharacter in 'c' format wrapped in packCharacter in 'C' format wrapped in packCharacter in 'W' format wrapped in packCannot compress negative numbers in packCannot compress integer in packAttempt to pack pointer to temporary valueField too wide in 'u' format in packpanic: string is shorter than advertised, aptr=%p, aend=%p, buffer=%p, todo=%ldCan only compress unsigned integers in packsSiIlLqQjJfFdDpP(sSiIlLxXnNvV@.Invalid type ',' in %sMalformed integer in [] in %sInvalid type '%c' in %s'X' outside of string in %sInvalid type '%c' in unpackU0 mode on a byte string%.*lu0000000000fFdDcCsSiIlLnNUWvVqQjJNegative '/' count in unpack@XxuaAZInvalid type '%c' in pack'%%' may not be used in packןȢ*ԠϜa[٢bԠԠYxR*LLבɍ͊ffffffflfffffffffffffffffOff5fY fff?fffffffff"fHfY0fffpff={ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffflfffffffffffffffffOffffffffffxffffffff~ffffffffffffffff0ffhffffffffEX`DDDDDDDDDDAA@?`@Undefined subroutine in sortSort subroutine didn't return single valueUndefined sort subroutine "%-p" calledDynaLoaderlibhandle, symbolnamelibreffilename, flags=01.14DynaLoader.cDynaLoader::dl_load_fileDynaLoader::dl_unload_fileDynaLoader::dl_find_symbolDynaLoader::dl_undef_symbolsDynaLoader::dl_install_xsubDynaLoader::dl_errorDynaLoader::CLONEPERL_DL_NONLAZYperl_name, symref, filename="$Package";:Q:dw<}L~tuĆf,adh::$;d;$4;|;;<44<\<<< =TD=t==T>T |>d>$?TD?d??d??@D@d@@4@ AtAAATB$B4DBt\B B4!BD!B4"C"LC#C#C#Ct$D&LDD0D2D$5F>F?4G@GtAGTBGCLHCdHIHKHMLIM|IMITPJtPJP4JRJ$SJDk Km\KnKnK4rLy\MytM} N~LN$NĀNd O4OTOtOOt PԆ\PP4P Q$lQdQ$Q R$tRdR4dSSĮLTT4T4UļdUTUUUL>>d>D?T?@tT@@d@41DA1\A1A42At3A;BC?Ct@CADATYEYEY\ Z\AL C m5DT A (5DT A <HBAD I ABE H ABE $49ADG cDA\<tBEB D(A0 (A BEBE hAV<hBEI I(D0 (A ABBI ,BAD AB4DXvBRA D(G0E(D DBBd|BBB E(D0D8G`W 8A0A(B BBBE  8D0A(B BBBT 82L`BBA A(G0 (A ABBF f (A ABBD $LxBHD D(G0tH(AfXA D 5LBBB E(A0D8D@} 8D0A(B BBBB 4BAA ~ ABK HABTHl@4_ADG0[ AAG lAAL@BED D(G@ (A ABBC V (I ABBL  $ 4< BAD G@_  AABG Dt h$BBB A(D0G` 0A(A BBBF l P BBB A(D0G@ 0D(A BBBA y 0G(A BBBE l 0D(A BBBA ,, BDA  ABA L\ BBB F(D0 (A BBBJ A (A BBEE $ Ap G p H e$ XAC L \ D v< BKE D(A0 (E BBBE < LT LBJB M(D0D8DP 8A0A(B BBBJ  |   VL @BBB H(K0A8GP 8D0I(B BBBF $< LADG zDA<d BDA E ABQ I ABD L BEE J(I0D8D@w 8A0A(B BBBH 4 8BDA z DBA IAK<, BEB A(A0W (A BBBG Ll PBEE J(D0I8D@ 8A0A(B BBBD  , ADG AAD d4BEJ J(D0A8DP 8D0A(B BBBG  8G0A(B BBBE LlBEE J(I0D8D@ 8A0A(B BBBC ,BAD X ABN 02AY F Qd PYBEB B(D0A8FP 8D0A(B BBBH  8G0A(B BBBH tHPdXYBEE B(A0D8G@ 8A0A(B BBBF  8G0A(B BBBM  P+FTL,`BEB B(D0D8G 8A0A(B BBBG L|0 SBBE E(I0I8DP 8D0A(B BBBF 4@"bAGF g FAT DFADx"~BAA ` ABI E ABH wAEL"BBE E(D0A8DP, 8G0A(B BBBM  8D0A(B BBBG { 8F0A(B BBBN R 8G0A(B BBBN E 8G0A(B BBBK N 8F0A(B BBBL %fBEE E(A0D8DP 8A0A(B BBBD r 8D0A(B BBBI E 8D0A(M BBBK  8A0A(B BBBG  8G0A(B BBBL @,D ZH,>BEB B(D0D8G@ 8A0A(B BBBF t 8A0A(B BBBB T 8G0A(B BBBL N 8D0A(B BBBE <|.BIE D(A0E (A BBBG Lp0YBEE J(I0D8DP 8A0A(B BBBE 4 1AAG n GAQ DA4D1AAG n GAQ DA$|P2+AFG IFAX2NRQ42AAG T DAF SGA42AOG J AAE ZGAD483pBAA } ABD ] JBO Q PBM L|`4`BBA D(G0 (A ABBD  (A ABBK Lp6BBA A(G0 (A ABBC d (C ABBD $@95ADD gCA4DX9]BEA F(G0m(F AMB\|9BBB D(A0GPW 0D(A BBBD  0D(A BBBF ==ZN4=BGD q AED ]ABL,`>eBBH B(A0A8GP) 8A0A(B BBBF d|?BEE E(A0A8GP 8A0A(B BBBC D 8G0A(B BBBL A3BBA D(G0] (A ABBE 4 (L ABBK l (A ABBF  (A ABBI D (D ABBK dl`DBBA D(G@ (A ABBC  (D ABBE D (C ABBD dLBBE B(D0D8D`J 8A0A(B BBBE 4 8G0A(B BBBL |<0P BEB B(A0C8G`S 8F0A(B BBJE u 8D0A(B BBBE ) 8D0A(B BBBA DpZBBB D(D0GP 0A(A BBBD L]BEE B(D0A8G` 8A0A(B BBBH LTHbABEE E(A0A8Gj 8A0A(B BBBB ,Hf?BJD l ABA $XgJt B Z F X,g2BDD RAB,,g~BGD X ABX L\ hBBA A(G0Z (D ABBH b (D ABBE ,h7BDC hAD,h<ADG c DAD , iKBDD zAE,<iZBDD  AEA LljBBB B(D0D8D`0 8A0A(B BBBB 4kZADG@S GAQ  GAE DlADL C DAG W DAD  DAC ,<mADG A DAF Ll@nBBD D(D0? (D ABBH t (A ABBF dpdBBB B(D0A8Ds 8A0A(B BBBB  8D0A(B BBBE 4$~BGD D0@  FABN L\ BBE B(A0A8D 8A0A(B BBBB @P,xAFG0v FAM L؈BEB B(A0A8D* 8A0A(B BBBK LDBBA D(G0S (D ABBD t (A ABBF $ؗAG Z AE <BAA B ABG H ABE  4, _ADG P DAG qDA,d OBAD @ ABF 4 8qBAD t ABJ aAB, 9BDA nAB4 jBBA D(D0S(D ABB,4!ȚADG V GAF 4d!(tBAD GPT  AABJ d!pBBB B(A0D8G` 8G0A(B BBBI  8G0A(B BBBL |"BBB B(A0A8G@ 8G0A(B BBBI h 8A0A(B BBBF H 8A0A(B BBBF \"BBA D(G0m (D ABBJ I (G ABBK M(H ABB<"BDD \ GBI \ GBK $#(E<#`MT#>DU G ]t#IDv F HD#rBDA  ABN ^ ABO t ABI 4# {BAA G0  DABB $h1BBB E(A0D8G@ 8D0A(B BBBD D 8D0A(B BBBG S 8G0A(B BBBE  8D0A(B BBBB L$>BBE E(A0A8G 8A0A(B BBBF d$BGE A(K0 (A BBBF d (A BBBM  (A BBBP dd%8qBBE E(D0D8G@ 8G0A(B BBBO a 8A0A(B BBBE L%PBBE B(D0D8GP 8D0A(B BBBA L&BEE B(A0D8Np 8D0A(B BBBH <l&PLBED D(G0T (G AKBI L&`dBEE E(D0D8GPu 8A0A(B BBBA & L'xBBB E(D0D8J 8A0A(B BBBA d'D Pd|'BBB B(D0A8GP 8A0A(B BBBF } 8A0A(B BBBI L'(BEJ B(I0D8G@C 8D0A(B BBBI 4(G A LT(xBEE B(D0D8G@ 8G0A(B BBBQ D(HBEE D(D0GPD 0D(A BBBF L(BBE E(D0D8DPo 8D0A(B BBBA 4<)9BDD G@  AABG Lt)*BBB B(D0D8G@[ 8A0A(B BBBD <)BBA D(D0 (A ABBG 4*8BAD I  AABA <*9An\* $t*QD0E AE **xeD J A 4*bBBA A(G0N(A ABBL +BJA D(D0R (F ABBF S (C ABBE <\+`BBA D(D0 (A ABBA <+0BED I(J_ (A ABBE +wBJI M(D0A8GP 8A0A(B BBBB  8A0A(B BBBI D 8G0A(B EBBI D 8G0A(B BBBL  8G0A(B BBBL \,pBEE B(A0A8G@] 8G0A(B BHBF D8A0A(B BBB<,BYA A(J  (A ABBD ,-`PDo A L-PDo A l-TI A ,-p\AFD  DAA --x),-BDD q ABB .$DZ B 4<. kAIF Z DAA Q AAM 4t.XkAIF Z DAA Q AAM L.BKD D(F0\ (G ABBU V (A ABBD ,.*BDG RAB,/DPLD/uBBB D(C0B (A BBBJ E(A BGE,/HAXG H AAF D/AAG t AAA C AAK SAA 0A,,00>BTH  ABH <\0@RBBA A(Gc (A ABBJ <0` BBB E(D0 (A BBBF d0@rBBB E(D0D8KP 8A0A(B BBBB D 8K0A(B BBBJ D1XOD\1 AHG |1\BDA L1BEB B(A0D8Dp 8A0A(B BBBA 1AD2BBB A(D0J 0A(A BBBD $L2(AHG IFALt2BBE E(D0D8D@ 8D0A(B HBBE ,2h=BDD hAB42x8BAD G6  AABH ,,3BFA  DBJ ,\3PBAG; ABA L3 BBB B(A0A8G 8A0A(B BBBF L39:%BBB B(D0D8G 8A0A(B BBBG ,,4^xBFG ABA ,\4dADG0, AAF 4e@A4e$D44eAAG o DAC ^ DAE ,4fWADG j AAH ,$5fWADG g CAI T5fl5g.L5g BBB E(A0A8G@ 8A0A(B BBBJ <5hhBAD s ABC j ABK 46iMBAD v ABH AAB<L60i{BHE A(D0  (A BBBM 6pj@L6jWBBB E(A0A8D@;8A0A(B BBB6ldD@ D [d7lBBB B(A0A8Dpa 8A0A(B BBBA  8K0A(B BBBJ ,|7pwBAA mAD$7pA K P H CL7XqBBE E(A0D8I 8A0A(B BBBG d$8( BEE A(D0p (A BBEE S (A BBBF [ (A BBEK d8ЃBEE E(A0A8D@ 8F0A(B BBBA j 8C0A(B BBBJ L8BGH D(G0b (A ABBD D (D ABBA DD9XBBE A(D0D@ 0A(A BBBA d9BEB B(D0D8Gp  8A0A(B BBBA G 8A0A(B BBBG L98BBB E(E0D8G 8A0A(B BBBB $D:ȋ*AGG IGADl:ЋBEE D(D0G@c 0A(A BBBJ <:H>BEE D(G0R(A BKBL:HBEB M(A0G8G 8A0A(B BBBF LD;BBL E(D0A8Gp 8A0A(B BBBJ L;)BME E(D0A8G 8A0A(B BBBF <;BED C(G@` (A ABBE 4$<h<BED G(G0I(G AKB\<pLt<XaBBG E(D0D8G`8D0A(B BBBL<( BNH B(A0E8D\ 8D0A(B BBBC L=BEE E(A0C8J 8A0A(B BBBF Ld=x5BED D(GPN (A ABBF  (D ABBA ,=h)BDG RAB4=hBDD G0L  AABG L>LBBE E(K0D8I 8A0A(B BBBE <l>BEE D(GPh (A BBBJ <>@>BEE D(G0R(A BKBL>@"BEE E(D0D8GPQ 8D0A(B BBBB <BEE D(G0R(A BKBL?BBB B(A0A8J: 8A0A(B BBBH L @BBB B(A0D8GP 8D0A(B BBBD 4\@`<BED G(G0I(G AKB4@hxBED A(G0J(I ABB<@BED D(G@i (A ABBK < A BED C(G@` (A ABBE 4LA<BED G(G0I(G AKB4A BAA G0j  AABG AVdABEE E(A0A8G@o 8A0A(B BBBM D 8A0A(B BBBB BEE D(G0R(A BKB<|UBED D(FPb (A ABBC LU0BEB B(A0A8G_ 8A0A(B BBBA < V:BEA I(G0 (D ABBC LLVBBE E(A0A8D 8A0A(B BBBJ ,V@*BDG RAB4V@BDD F0U  AABG ,WACG`s AAA ,4WACG` AAD ,dWAQN` AAJ $WXAJG AAWLWBBBB A(A0 (A BBBD J(A BBB,$XBAA  ABK LTXx>BBB B(A0C8GPP 8A0A(B BBBC XhpDO A LXBBB E(D0A8D 8A0A(B BBBB dYX BFB E(D0A8Dp 8D0A(B BBBG  8A0A(B BBBN L|Y0BBB B(A0A8DP 8A0A(B BBBB dYBEH B(A0A8DpV 8A0A(B BBBI  8A0A(B BBBA 4Z5DpdLZ0BBB B(A0A8Gpg 8G0A(B BEBE { 8A0A(B BBBK ZkZ@dZ,ZaAIG | AAA ,[RED[(J},\[`(BAD  ABA [`-[x\[BBA D(G0{ (A ABBG j (A ABBH  (A ABBK D\BBE A(D0GP^ 0A(A BBBE $d\(AD  AH L\VBBB B(A0D8GpK 8A0A(B BBBG 4\ bBGD G0^  DABO D]XBGB I(D0DP 0A(A BBBD <\]BRA  ABE E ABA L]BEE E(D0A8G@ 8A0A(B BBBF L]BBE E(A0D8D@p 8C0A(B BBBE <^ LT^(iBBB B(D0A8GPI 8A0A(B BBBI T 8K0A(J BBBH  8D0A(K BBBO D8G0A(B BBB$^7AD@s AG L_\BBB B(A0A8D`T 8D0A(B BBBI Ld_(HBBB B(A0A8Dp 8D0A(B BBBJ _(C_`Ah G L_nBBD D(G0n (A ABBI  (A ABBA <`vQWT`xNQ,t`BEE A(A0Gl`xBBE A(A0G@k 0A(A BBBK A 0A(A BBBG ^ 0A(A BBBJ 4aAKD T AAJ TAA|LaPBBB E(A0A8GE 8G0A(B BBBE D 8D0A(B BBBA D 8C0A(B BBBA <apZG0z AD rAM0L FF 4 bOBAA i PBI AADLDb(BBA A(D0 (D ABBI S(C ABBb,eDbBAA m AEI H ABE W ABI <bHBBE A(A0(A BBB,4cEg L ` H A O A E dch_LR<|cDBAA M ABA  ABA cBEB B(A0A8DJ 8A0A(B BBBK ~ 8D0A(B BBBE  8A0A(B BBBD  8A0A(B BBBL \d>tdBHE B(A0C8D 8A0A(B BBBA g 8A0A(B BBBO h 8A0A(B BBBF D 8G0A(B BBBL 4 epAAG@v AAG q AAE DDe8BME D(D0FP" 0C(A BBBA LeBBA D(G0_ (A ABBK Z (A ABBH De BGB A(K0GP 0A(A BBBA $fADG0oAA,p`eADG0u AAE ,p`BAD  ADD < qdBBA A(G0` (C ABBK $Lqf<AAG ZGA4tqf}BBD A(F0g(A ABBDq`fxBDD W ABD A ADB ADBqfK rE>xBGH ,rfUAc A oLLrfHBBB B(D0H8Gp? 8A0A(B BBBD riGIX G r j$r(jYDX D A O r`jsXj,sPjDsHj\s@jltsje$sjx[KJC$sHk^QICLskPBBB B(A0A8G`B 8A0A(B BBBC L,tnBEB B(D0D8G` 8A0A(B BBBD |tsCt8sCtpsC4tsIAAG ] GAR DCA4tsIBEI [ ABJ AAJ44usOBDA k ABK A ADA ,lus9BHD X ABH $ut{AD Q AI $uXtkAG A AF DutBDA G0}  GABK ]  AABG 4vhuAGTvvlDn F 4tvXvAAG Y AAD D MAN 4vvYBED D(D@(A ABB$vvAG AA  wwG A \,w xvBBA D(G0T (D ABBC  (D ABBJ J (D ABBE w@z6ACG w`z D4wXzdBED A(G@{(G ABB$wzAG AA $x8{G A Dx{iAAG dx(|AGx|GxP}ODi C x}GLx~BBB B(D0D8G` 8D0A(B BBBD $yȁD4BDD G0x  AABC Lx5BBB E(A0D8JF 8A0A(B BBBF ,ԗh!'BFD SAB$h!kAG A AF $,!(AGG IGALT!BBB B(G0A8G4 8A0A(B BBBK ,h*fAGG F CAG Ԙ*1Ao*A]*,,+AAL AA\ -!A<|0.= BBA A(D (A ABBH L0;BBB E(A0A8Dp 8A0A(B BBBJ , BAD G@C  AABA Ԛx>>A|L>\BBB E(A0D8F 8A0A(B BBBG LDDBHB B(A0A8J 8A0A(B BBBH <XBEI D(D0 (D ABBI LԛXBBB E(A0D8Dp 8D0A(B BBBB L$X\&BEB B(A0A8GE 8A0A(B BBBA Lt8dBBB E(A0A8G` 8A0A(B BBBB DĜiIBBB D(A0G@ 0A(A BBBF , kzBAA T ABA L<`kBED A(J0B (D ABBO D (A ABBF k8Aak?Dr J D̝qBEE E(D0H8D@B8D0A(B BBBDAZ E c44lBEE E(D0A8D@lAe J LBEE B(A0D8DH 8A0A(B BBBG $ܞDC I d L Z F 4xAk D M S \ D A O A$<WADD KAALdHBBB E(A0A8DPS 8A0A(B BBBB ;\̟@BBA D(G0Y (G ABBK f (D ABBA q(D ABB,5dLD5dL\Ad \t3A^ A d8UBBB B(D0A8Dp; 8A0A(B BBBJ  8A0A(B BBBG 05dLLXGAD vAAL U GAK DGA$dAG z AE ASLBBA D(G0N (A ABBD A (D ABBF @8 ,,0BDA z ABD ,\LF_KG I G4жeBDA t ABJ YAB4ĢvAAG D AAA cAA<PBED D(D@ (A ABBD <<BBA D(G@v (A ABBD 4| jBID D0Q  EABD X'DV F FLԣhBEB B(D0D8DP 8A0A(B BBBF L$[BEG D(A0h (A BFBJ A(A BBD<tmBID G0R  AABD j KABdHBBB B(D0A8D@ 8D0A(B BBBE K 8A0A(B BBBA dtBEB E(A0C8D@ 8G0A(B BBBH R 8A0A(B BBBD 4?AAG Z GAM DAAd BBB B(A0D8Dp 8A0A(B BBBA  8A0A(B BBBA L$BBB B(I0A8Dp 8A0A(B BBBE ,ttBDA b ABD L8mBBB B(A0D8DPj 8A0A(B BBBK 4XBGD G@  AABI L, BBB B(A0D8FP| 8A0A(B BBBG ||gBBB E(A0D8F` 8A0A(B BBBF  8A0A(B BBBF  8A0A(B BBBB LSBBB B(A0D8G9 8A0A(B BBBI LAD0n F LlWBEB B(A0A8J  8A0A(B BBBD LBBB B(I0D8Dpo 8D0A(B BBBK d )BEB B(A0D8GP 8A0A(B BBBI  8D0A(B BBBO LtHBBB B(D0A8DP 8D0A(B BBBG |ĩBBB B(D0A8DP 8A0A(B BBBE D 8C0A(B BBBH  8G0A(B BBBE <D>BEE D(G0R(A BKB<"BED A(DP (A ABBA LĪBHB B(A0A8G 8A0A(B BBBC D8RBEE E(D0G8GPd8A0A(B BBB<\PBBBE A(D` (A BBBE ,`BDA J ABA ,̫sAAG l DAA V4X~BAD G0Z  AABA L1D ld NBdBBB E(A0D8G`@ 8A0A(B BBBG ^ 8A0A(B BBBH LBIE E(D0D8D`f 8D0A(B BBBD l< *BBB D(C0G@Z 0A(A BBBJ s 0A(A BBFA N 0F(A HBBO LBBB E(A0D8K@ 8D0A(B BBBC d BBB B(D0D8DP 8A0A(B BBBK D 8D0A(B BBBO Dd BAD G0h  AABN z  AABA 40 OADG0L DAK ZGADH BAD j AEI r GBE A DEA d, BBB B(D0A8G@ 8A0A(B BBBE Z 8G0A(R BBBN ,x QBDD c ABP Dį BAD z AEI r GBE A DEA  `|$hBGB E(D0C8DP 8G0A(B BBBL ] 8A0A(B BBBI d8F0A(B LBBLPBBB D(A0\ (A BBBB A (A EBBE BBB E(A0A8GP 8A0A(B BBBC Q 8A0A(B BBBE  8D0A(B BBBE L 8G0A(B BBBL d BBB E(A0D8G`| 8D0A(B BBBH  8I0A(B BBBH 4XFAIG N EAK OEA4,poBID W ABG {ABd=A{LBEB E(A0A8G$ 8A0A(B BBBK Բ(lAp G pxgA[ D ,BAA E AEA D8\0;Ag H ,|PJBAA AEpGAB4̳AAG ] AAH ~ AAH LBBB B(A0A8GP 8A0A(B BBBG <T#BAA D AFA H AEB $#Ae J M K L@$BBB B(A0A8Gp 8A0A(B BBBI , )BAA [ AEK ,<)AAG t AAA 4l`*AAG H AAE c AAC d8+BBB B(A0A8G@h 8A0A(B BBBE : 8A0A(B BBBD d ,BBB B(A0A8GP. 8A0A(B BBBG  8A0A(B BBBF <tx0BBB A(A0 (A BBEF 4X1cBBA A(G0O(A ABB1;Avd 1BBB B(A0A8GP 8A0A(B BBBJ  8A0A(B BBBD LtX6BBH B(A0A8G`x 8A0A(B BBBG Lķ; BEB B(A0A8GB 8A0A(B BBBH LHGBBB B(A0A8G@ 8A0A(B BBBC LdH] BBB B(A0A8J 8A0A(B BBBE LU BBE B(A0A8G 8A0A(B BBBJ <HaBAA  ABH  AEG LDcBBB B(A0D8D`S 8A0A(B BBBB LHhBBB B(A0A8J 8A0A(B BBBG LzXBBA A(G0 (A ABBE  (A ABBF d4}BBB B(A0D8DP 8A0A(B BBBI  8C0A(B BBBA 4oBAD } ABQ AABLԺHd BBB B(A0A8G 8A0A(B BBBK <$hBDD  ABG t AEF <dBBA A(G0I (A ABBD |BBB B(A0A8Gpg 8A0A(B BBBF V 8A0A(B BBBA   8D0A(B GBBK |$BBB B(A0A8G` 8A0A(B BBBH f 8A0A(B BBBH / 8F0A(B BBBJ $?AAG sAA4̼BAA G0  AABD LxBBB B(A0A8DP 8C0A(B BBBA TؙglT`ؚAԽHA] B $ @AU J C A 4Z,LGBEE D(K0|,BDA AB<ܾBEE D(A0 (A BBBH `FC[ B e<fAE J D\BHD  CDA \ ADG  AGI DBDD W ABD A ABD  ABF С$ȡAG l AK ,,0AAG e AAH \tN$t8BDY S C E ,`AG f DF D CA У-TW,AjMAK$(<<0\BEB A(A0 (A BBBA L|PBEB D(D0X (A BBBH i (A BBBH ,dBDD ] ABF L BBB B(A0D8GQ 8A0A(B BBBA ,LBGA ~ ABE 4|0WADD t DAN DAA4XTBDA ` ABF \ ABA ,AAG0 IAJ <PBBA A(GP (A ABBB L\2BBE B(A0D8J 8A0A(B BBBA 4@PBED G(G@p(A ABB,XAAJ AAA G A L4uBEG D(G@v (A ABBK D(G ABB,AAJ AAA xG A DmBBB G(K0D8GPr8A0J(B BBB<0BED D(D@e (D ABBG $\AG AA 8G A LBBB B(A0D8G4 8A0A(B BBBF 489AIG O AAF DGA4,@BAA G0  AABG DdADJ0U DAG \ DAG [ DAH <@BFC f ABD  ALM (BIB B(A0D8F`& 8A0A(B BBBF  8A0A(B BBBH h 8A0A(B BBBF T 8A0A(B BBBB LhBEE E(D0D8D`< 8A0A(B BBBE ,)BDG RAB,jAFD0A DAG 4"A`T LlSBBB B(A0D8GP 8A0A(B BBBH  L BEB I(H0C8Gt 8A0A(B BBBF 4$ADG r AAH KAAD\AAG s AAB N AAH D GPM DAAG  AAI D GAL D GAL ,yA@ G A G A O XDAAG E AAH s GAM D GAL DdxiARG  AAD V AAH VAA=|BEE E(D0A8DP 8A0A(B BBBJ i 8A0A(B BBBE V 8A0A(B BBBH D8%TP\P&TQ4thA H M K A O A O X\%BED A(D0 (A ABBH T (G ABBE _(G ABB< BBA A(G0{ (A ABBB LL0BEB H(D0~ (A BBBF I (A BBBA LBEE E(D0D8DP 8D0A(B BBBA l BBE A(A0FP 0A(A BBBF p 0A(A BBBH M 0A(A BBBK L\"`BEB A(D0 (A BBBG P (A BBBI D#BDA o ABG _ ABF O ABF T#,BDD G0l  AABG g  AABE a  GABM LL$b BBB B(A0D8Dph 8A0A(B BBBE 13IR E FD1\BBB B(D0D8D@z8D0A(B BBB,1SFDG0{AA<4(2BEB A(A0g (A BBBG <t6BBA A(G0g (A ABBF D7BBB A(D0D@ 0A(A BBBH d9<BBB E(A0D8DPj 8A0A(B BBBH  8A0A(B BBBF <d;BBA A(G0g (A ABBF L< BBB B(D0A8D` 8D0A(B BBBG LFBBB E(A0A8G/ 8A0A(B BBBC <DIBBD A(G@p (A ABBJ |JeBBB B(D0D8DP  8A0A(B BBBB _ 8A0A(B BBBG t 8A0A(B BBBB LOWBBB B(A0A8D` 8A0A(B BBBK TR BEB B(D0D8G@N 8A0A(B BBBF  8A0A(B BBBH  8G0A(B BHBJ o 8A0A(B BBBO ,XQBDD  AEA L$Y BBB B(D0D8Dg 8A0A(B BBBK $tb{AD T AF byD  E D@cBBB A(A0GP 0A(A BBBE Ld=BEB E(A0D8GZ 8A0A(B BBBB ,TezADG0J AAH LfBBB E(A0A8Gp 8A0A(B BBBC DXhoBEE D(D0F` 0A(A BBBD <iBBA A(G@ (A ABBF t\kBBB D(C0k (A BBBA  (G BBBN I (A BBBH  (G BBBJ d(pBBE E(D0D8G@ 8A0A(B BBBG  8G0A(B BBBE D<qsBBB A(A0G@G 0A(A BBBB Ls0BBA A(G0O (C ABBD U (C CBBI LtpKBB A(A0(A BBBH0L$uQBED D(G0 (A ABBI l (G ABBH 4tvBDD G0Q  AABJ \PwMBBD D(G0X (A ABBG y (G ABBK ^ (A ABBD 4 @x1ADG O AAC DGA4DHxBDD D0p  DABK L|xBBB B(A0A8Gs 8A0A(B BBBB ,P{SBDA CAG4{BDD D0Y  DABB ,4{|ADD0G DAK Dd(|BBE D(D0G` 0A(A BBBG LiBBE B(D0D8Gp 8A0A(B BBBF  D؂BBB D(D0GP 0A(A BBBG \ tD0 F 481ADG O AAC DGAD@ BBB A(D0GP 0A(A BBBB ,AAG@ AAF ,DAAG@ AAF Lt-BBE A(D0 (A BBBC r (A BBBG 4x1ADG O AAC DGA4BDD { ABH m ABH l4JBBB D(D0G@v 0A(A BBBE T 0A(A BBDJ  0C(A BBBJ <ȓEBBD D(G0 (A ABBA LؔBBD D(D0w (D ABBH  (D ABBG <4 BBE D(A0 (D BBBA 4tx:BED D(G0Z(D ABB<BDD  ABS A ABD 4Й1ADG O AAC DGA4$ؙ<ADG I AAI YAA4\1ADG O AAC DGA,lAGD0A DAF L(BID D(D0 (G ABBL D(D ABB,(BDD ZAB,DlAGD0A DAF Lt7BBB B(A0D8GP 8C0A(B BBBF ,؝(BDD ZABD؝BAD G0  GABU D  AABH 4<P1ADG O AAC DGA,tXfADD0A DAA tBAA G0$  AABA `  AABH   AABH   GABR   DDBE 4@GAAG R GAM TAAdTXBAA G0  AABA `  AABJ \  AABH   DDBM 4GAAG R GAM TAA$ȧ2ADG0`DA<BBD D(GPf (A ABBA L\BBB B(A0D8G` 8A0A(B BBBI $p9ADG jAALQBBE E(D0D8GP 8A0A(B BBBE <$,BED D(GP (A ABBE 4d<BED G(G0I(G AKBLLBBB B(A0D8D` 8A0A(B BBBB 41ADG O AAC DGAL$KBBE E(D0D8Gp3 8A0A(B BBBF ,t8BID eAB,=BID jAB,AGD0x DAG D8 BDD a ABB l ABI B ABC LL BBB E(A0A8JBU 8A0A(B BBBJ <MDD0[ AAF xH04@BDA G0  AABJ LuBBB B(A0A8D` 8A0A(B BBBJ Ld"BBB B(A0I8D 8A0A(B BBBK <BBB A(D0, (A BBBB ,W E S E H,$xBAD \ ABJ ,TTBGD \ ABD LBEE E(D0A8Gp 8A0A(B BBBF |h BBB B(A0D8D 8A0A(B BBBH  8G0A(B BBBK  8D0A(B BBBI 4TPBED G(G@p(A ABB,AAJ AAA G A L0uBEG D(G@v (A ABBK D(G ABB,,`AAJ AAA \G A 4|AAG { AAJ tDAp BBB A(D0G@m 0K(A BBBO  0G(A BBBZ } 0D(A BBBX n 0D(A BBBG ,< ADG0] AAE Ll BBB E(D0C8GpG 8A0A(B BBBF LKBBB A(A0 (A BBEK (A BBB4 AAG w AAF j AAD dDX8BBB B(A0A8G@ 8A0A(B BBBI V 8A0A(B BBBH L0BBA A(G0 (A ABBH  (D ABBH ,pAAG0] AAH \,BEE D(D0 (A BBBC W (A BBBJ (A IBB,pAAG0 AAI <@BBA A(G0L (A ABBA <BBA A(G@d (A ABBI ,<0AAG@x AAE <lnBBH A(GP (A ABBE , xBAA S AEC $p*AAG ^AALxBBA D(D0g (A ABBF V (A ABBD LT(BBA A(G0F (A ABBG n (A ABBD <oBBA A(G@ (A ABBJ 4 BAA G0  AABH 4$BAA G0z  AABG <Th%BBA A(G@ (A ABBD <&|BBA A(G0[ (A ABBB L('BBB B(A0D8D@ 8A0A(B BBBB d$'@BBB B(A0A8G@w 8A0A(B BBBF ! 8A0A(B BBBE <,BBA A(G0 (A ABBE d .BBB B(A0A8GP 8A0A(B BBBC  8A0A(B BBBG D4x24BBB A(A0G@ 0A(A BBBG \|p5fBBB A(A0G@ 0A(A BBBE v 0K(A BBBH d8*BBB B(A0A8G`% 8A0A(B BBBH R 8K0A(B BBBJ LDH=BBB B(A0A8G` 8A0A(B BBBH dBBBB B(A0A8GP" 8A0A(B BBBC  8A0A(B BBBF LFBBB B(A0A8G@ 8A0A(B BBBE LLGBBB B(A0A8G@ 8A0A(B BBBE TIBDD G0]  AABF c  ADDD l  FABC ,JBAA \ AEJ ,$hKBAA \ AEJ ,TKBAA [ AEK ,LBAA ^ AEH ,MBAA [ AEK <MBBA A(G0{ (A ABBB <$NBBB A(A0 (A BBEI ,dNoBAA dAE,OoBAA dAE<HOBBA A(G0k (A ABBB LOBBB B(A0A8G` 8A0A(B BBBA LTR0BBB B(A0A8G`D 8A0A(B BBBA DTBBB A(A0G@ 0A(A BBBI ,PX"AAG T AAA LPYBBB B(A0A8GC 8A0A(B BBBB <l ^ BBB A(A0 (A BBEJ d_XBBB B(A0A8G@ 8A0A(B BBBA z 8K0A(B BBBJ L_kBBB A(A0 (A BBEF (A BBB<daOBBB A(A0 (A BBEE <(b_BBB A(A0 (A BBEK <HcBBA A(G0e (A ABBH <$cBBA A(G0e (A ABBH <dhdBBA A(G0e (A ABBH <dBBA A(G0e (A ABBH <eBBA A(G0e (A ABBH <$fBBA A(G0e (A ABBH <dfBBB A(A0 (A BBEH ,xgBAA U AEA <gBBA A(G@z (A ABBC dh,BBB B(A0A8GP 8A0A(B BBBJ  8N0A(B BBBJ <|pjOBBA A(G@ (A ABBH <k BBA A(G0 (A ABBH <`lBBA A(G0 (A ABBH <<nBBA A(G0 (A ABBD D|oBBB D(A0DPx 0A(A BBBA <rBBA A(G@ (A ABBC sbLuBBB B(A0A8G 8A0A(B BBBD Llp|yBBB B(A0A8G@ 8A0A(B BBBK L}KBBB E(A0A8D 8A0A(B BBBH < BBB A(A0 (A BBEF <L0BBA A(G@ (A ABBD <BBB A(A0 (A BBEJ L0BBB B(A0A8G` 8A0A(B BBBF LBBB B(A0A8G& 8A0A(B BBBG LlpIBBB B(D0A8G 8A0A(B BBBF LpBBB B(A0D8D) 8A0A(B BBBD L NBBB E(A0A8DPs 8A0A(B BBBB L\.BBB B(D0A8GN 8A0A(B BBBD dBEB B(A0F8Dp 8A0A(B BBBE S 8C0A(B BBGE |(yBBB B(G0A8GP 8A0A(B BBBH  8A0A(B BBBG p 8A0A(B BBBF T(BBB A(A0f (A BBBK   (A BBEF <BBB G(A0 (A BBBJ d,BAA z AMT H ABE ^ EHU G ABF A ABL AABLhn BBE B(A0A8D 8A0A(B BBBE ,AAG`w AAF dgBBB B(D0A8DF 8A0A(B BBBG  8D0A(B GBBE <| BBA A(G0R (A ABBK dpBBB B(A0D8DP 8A0A(B BBBH  8A0A(B BBBA <$BBA A(G0w (A ABBF Ldh}BGB B(A0A8G`' 8A0A(B BBBI |h BBE B(A0A8Dp 8A0A(B BBBH A 8A0A(B BBBE  8D0A(B BBBI L48BBB B(A0A8GP 8A0A(B BBBA <xBBA A(G0 (A ABBD LCBBB B(A0A8GP 8A0A(B BBBG LBEB B(A0A8Dp 8A0A(B BBBI LdhBBB B(A0A8J 8A0A(B BBBB E, DBAA yAE@VL@BBB A(A0z (A BBED s (A BBEC dxBBB B(A0D8D` 8A0A(B BBBB  8G0A(B BBBQ K 8A0A(B BBBF  8G0A(B BBBQ i 8K0A(B BBBJ <BBB A(A0j (A BBED LTBED D(D@ (A ABBH a (A ABBI 'Ae</BED I(D@ (D ABBB , "BAA  AEM $4 A] B P H ,\ BAD a ABE  AI F 4 PBED D(G@j(A ABB oAz E  DS I ,$ hBHA f ABD 4T hBED D(G0K(A ABB, BAD S ABK  ` h ` 4 X~BED D(G0a(A ABB<< BID k ABC U ABH <| @BEA A(G0q (D ABBF < BEA A(G0_ (D ABBH $ `'ADG IGA$$ hWADG HAA4L fBED C(G0J(A ABB4 AAG0X IAM GAA$ 0XADG IAA$ hXADG IAA4 AAG0X IAM GAAD \ t $ ADG {AA H @, 8GBDD yAB,XpBDD Q ABA D4\BDD G0m  AABF , ]BDD OAB,P]BDD OAB4 BAA i ABH TABLDBED D(G@Z (A ABBJ Y (G ABBK dx2BBE E(D0D8G@ 8A0A(B BBBH Y 8G0A(B BBBO ,PRADG a GAK <,BBA A(G0` (A ABEA LlBBB B(A0C8G 8A0A(B BBBC @%XPntDBEE E(D0D8G@i 8A0A(B BBBE  8A0A(B BBBH v8D0A(B BBB|ATLBEE E(D0A8GPb 8A0A(B BBBG T@"#BBB A(A0F@ 0F(A BBBF d 0C(A BBBJ LD#eBBE B(A0A8D 8A0A(B BBBD L8%BBB B(A0A8G 8A0A(B BBBF $'AGx AG L )BEB B(A0D8D 8A0A(B BBBH $\0AJ AB 41DBAD Jr  AABI ,2rBFI ZAEL3ADG V AAD p AAF D IAJ DCA|<3BBB E(D0A8G 8A0A(B BBBD [ 8A0A(B BBBK J 8A0A(B BBBL $pGAI AD dhH BEB E(A0A8Dp\ 8A0A(B BBGA  8C0A(B BBBF LTLdTBEB B(A0A8Dp 8A0A(B BBBD ,8\%ADG  AAE 8]. BBB B(D0A8D| 8A0A(B BBBI  8A0A(B BBBH  8K0A(B BBBG LlfiBJB B(A0A8GH 8A0A(B BBBE nJ<xSBAA  AFA  ABE dBDB H(A0A8G` 8A0A(B BBBG S 8A0A(B BBBC |ЊDT$؊ AV I D D dBBB A(A0 (A FBFE c (A BBBF H (A BBFE L$XBBB B(A0A8Gp 8A0A(B BBBJ tm`p<BBB A(D0 (A BBBC ,xADG I AAI 4bBBB B(A0A8GpLL@BBB A(A0 (A BBED d (A BBEB ,hAAG | AAI L(X BBB B(A0A8Gp4 8A0A(B BBBA ,48BHA ~ AEA tdȮeBBA A(G0H (A ABBE c (A ABBG U (A ABBE  (K ABBL <BBA A(G0 (A ABBG ,pBAA  AED dL`SBBB B(A0A8GPT 8A0A(B BBBA  8K0A(B BBBH <X!BBA A(G0 (A ABBE ,HtBDA  AEB $ BBB B(A0A8Gpl 8K0A(B BBBO j 8D0A(B BBBI  8K0A(B BBBM  8G0A(B BBBN <BBA D(D@ (A ABBE `=BBB B(A0A8GP 8K0A(B BBBM  8D0A(B BBBC  8H0A(B BBBS [ 8K0A(B BBBI LBAA  AFB A ABL N AFK \AB\XBAA G0  DABE w  KABS M  DABD  KABLD8BBB B(A0A8JK 8A0A(B BBBG QA@LNBEB B(D0D8J 8A0A(B BBBD L,hBEH B(A0A8GU 8A0A(B BBBG ,|vBAA C AEC L@<BEB B(A0A8G 8A0A(B BBBH L0 BBB E(A0A8Dp 8A0A(B BBBG $L AAG vDA<t hBEA A(G0B (D ABBE  DAq F G< BBB A(A0+ (A BBEC <!x2BBA A(G0  (A ABBC ,T!xBGA AE! L!%BBA F(G0, (A ABBD J (A ABBH d!BBB A(A0 (A BBBA O (A BTBP  (E BBFD <T"HBAA I ABH ] AEE <"BAA  ABE U ABH "xL<"BEA A(G@ (A ABBH L,#BMB B(A0D8DP 8A0A(B BBBJ 4|#BAD _ AED AABL#BBB B(A0A8J 8A0A(B BBBA d$"0BBA A(G0j (A ABBC  (A ABBC z (D ABBE l$$<$$BBA A(G@Q (A ABBD L$X'BBB B(A0A8GP 8A0A(B BBBC L%*BEB E(D0A8GT 8A0A(B BBBH Ld%x/BBB B(A0A8G 8A0A(B BBBH L%2TBBA A(G@f (A ABBG  (A ABBI L&3}BBB B(A0A8GPV 8A0A(B BBBG tT&H5=BBA A(G@G (A ABBF ] (A ABBE S (A ABBG ~ (A ABBD <&6BBA A(G0 (A ABBF L '6nBBB B(A0A8Gp 8A0A(B BBBC d\'9BEB B(A0A8D` 8A0A(B BBBC  8C0A(B BBBG L'?BBB B(A0A8G`l 8A0A(B BBBI ,(BBAA J AED dD(BaBVB B(A0A8DP 8A0A(B BBBF  8K0A(B BBBN L(EBEB B(D0A8D 8A0A(B BBBH <(PJvADG q AAA S AAK SAAL<)JBBE E(D0A8G@' 8A0A(B BBBE L)KBBB B(D0A8GP 8A0A(B BBBC D)NBBB A(A0G@ 0A(A BBBI L$*XQ`BAA R AED V ABO r ABK NABt*hRBBB B(A0D8D`R 8D0A(E BBBM  8D0A(B BBBH  8F0A(B BBBF | 8G0A(B BBBN d +pWBBB B(A0A8G` 8A0A(B BBBE G 8A0A(B BBBG <t+Z|BBG A(Gp (A ABBE L+\ BBB B(D0A8G!o 8A0A(B BBBA L,elBBB B(A0A8G' 8A0A(B BBBF |T,n2BBB B(A0A8G` 8A0A(B BBBD K 8A0A(B BBBC } 8A0A(B BBBI \,pBBB A(A0G@y 0A(A BBBH  0A(A BBBF d4-qBBB B(A0A8G` 8A0A(B BBBF  8A0A(B BBBA L-sBBB B(A0A8G@ 8A0A(B BBBA L-vHBBB B(A0A8Gp 8A0A(B BBBG <<.zBBB A(A0 (A BBEH L|.zoBBB B(A0A8GP 8A0A(B BBBI L.|BBB B(A0A8Gp 8A0A(B BBBE L/BBB B(A0A8GP 8A0A(B BBBD <l/@BBA A(G0 (A ABBG L/lBBB B(A0A8J  8A0A(B BBBI L/ HBBB A(A0 (A BBED } (A BBEI LL0 ,BBB B(A0A8Gp 8A0A(B BBBG D0BBB A(A0G@( 0A(A BBBA T0xBBB A(A0> (A BBBC  (A BBEK <1БBGB B(A0A8G@ 8A0A(B BBBG  8A0A(B BBBH Z 8A0A(B BBBD y 8A0A(B BBBE C8D0A(B BBB1ГBBGA A(G0# (A ABBE r (A ABBH U (A ABBE i (A ABBA g (D ABBH ] (A ABBE T2BFA  AEE r ABK K ABJ B ABC 42Ad K h H n B K E K E <3șBBA A(G@ (A ABBB LT3xBBB B(A0A8Jz 8A0A(B BBBH D3HBBB A(A0GP 0A(A BBBE ,3BAA  AEF <4BBA A(G0j (A ABBC L\4BBB B(A0A8G@ 8A0A(B BBBH L4,BBB B(A0A8GP 8A0A(B BBBC <4BBA A(J  (A ABBE L<50BHB B(A0A8GP 8A0A(B BBBJ D5^BBB A(A0G@ 0A(A BBBE L5aBBB B(A0A8G@ 8A0A(B BBBH d$6خgBBB B(A0A8G@ 8A0A(B BBBB N 8A0A(B BBBH L6/BBA A(G0 (A ABBD g (A ABBK <6BBA A(G0 (A ABBD <7BAA ` AEF Q AEI L\7PBBA A(G0t (A ABBI Q (A ABBI <7 BAA \ AEJ S AEG <7BBA A(G@  (A ABBE L,8BBB B(A0A8G`: 8A0A(B BBBK L|8BBB B(A0A8J> 8A0A(B BBBD <8 BBB A(D07 (A BBED , 9о}BAA d AEB ,<9 BAA  AEF <l9BBE A(A0 (A BBEG <9 BBB A(A0p (A BBEF L9'BBB B(A0A8GP 8A0A(B BBBE ,<:pBAA f AEH 4l:BAA G08  AABI D:! BBB H(A0J 0A(A BBBD <:BAA R AED S AEG 4,;`%BAA G@  AABG ,d;XBAA  AEG <;BAA j AED W AEK 4;hBAA w AEG {AED <BBB A(D0DP 0A(A BBBE dT<HBBB B(A0A8GP 8A0A(B BBBJ G 8A0A(B BBBG d<:BBB B(A0A8G@ 8A0A(B BBBB  8A0A(B BBBE d$=rBBB B(A0A8GP* 8A0A(B BBBK D 8A0A(B BBBB ,=AAG Y AAD ,= AAG w AAF d=WBBB B(A0A8G@! 8A0A(B BBBD  8A0A(B BBBG dT>:BBB B(A0A8G@ 8A0A(B BBBB  8A0A(B BBBF <>BAA y AEE \ AEF L>`BBE B(A0A8G 8A0A(B BBBH LL?BEB B(A0A8G 8A0A(B BBBF L?`IBOE B(D0A8D 8A0A(B BBBF D?` BEB D(D0G` 0A(A BBBF D4@ BEB D(D0F@ 0A(A BBBF L|@PBBB B(A0A8Gp 8A0A(B BBBF L@ BBE B(D0D8G~ 8A0A(B BBBF |ABGB B(A0A8GP 8A0A(B BBBK   8A0A(B BBBE f 8A0A(B BBBA <A "BED C(G@^ (A ABBG LA"IBEE B(A0A8J 8A0A(B BBBF <,B:sBBA A(G@ (C ABBG ,lB;BDA m CBG LB<BEB B(A0A8G  8A0A(B BBBB dBDFBBB E(A0A8D@U 8A0A(B BBBH  8C0A(B BBBA TCEWDg E btCF]Dg E i4CHFjAAD ` HAA lFA,CFAAG z CAI <CpGBBA A(GP (A ABBD < 8A0A(B BBBH ,ahMBAA EAB,aMBAA EABdb/BBE E(D0D8G` 8A0A(B BBBK  8C0A(B BBBH <|bpBED C(G@` (A ABBE ,b-BDG RABLbBBB B(A0A8G`R 8A0A(B BBBC 4BEA D(D0 (A ABBK ,~9ADD0 AAF d~p9BBE B(D0D8DP 8D0A(B BBBA ^ 8D0A(B BBBE T:ZDh D t:UDf F Q G (;ZDh D $h;`Di K O I O$;PDi C O A O;g$ <Di C r F LD<BBE E(D0D8G@v 8G0A(K BBBL ,8=ADG0} AAE Ā=(Afd=IBBE B(D0A8DP 8A0A(B BBBA U8C0A(B BBB$L>WDc I D L V|t>BBB B(D0D8D@ 8A0A(B BBBH  8H0A(B BBBK O 8H0A(B BBBH 4X@aAAG0[ GAL D CAH L,@BEE D(D0z (A BBBK q (A BBBH L|@BBA D(D0[ (D ABBG Z (A ABEA ̂PARDh D I G ,ALBAD ~AE<AbBEB A(A0O(A BBBL\ABEE E(D0E8Gp 8D0A(B BBBD LBJBEE E(D0D8D 8D0A(B BBBH $D%ADG TCA$$D]ADD0QAALD+NMLdDBBE E(A0D8G` 8A0A(B BBBB \HFBEB A(A0L (A BKBI O (A BBHL N(A BBBF,F<DFBBA A(F0{ (C ABBA 4XGBDA h ABF ` AIF DGBAD } ADG K ABB F ADE <HHBBA A(F0_ (D ABBA $DH=AAD tAAlI D@ D J7L(JBBE E(D0D8GP 8A0A(B BBBJ J$4 JAAG0` GAO DAAD(K#D$\@KhAG Y AA ,KyADF0^ AAE ,K_ACG0L AAA ,L9BKA gAB$L:AAG dGA<<0L BED A(Gp (A ABBC |MG A $MAY F S E sdĈ8NlBEE B(A0D8GPg 8A0A(B BBBE i 8A0A(B BBBE L,@PBBB B(A0A8G 8A0A(B BBBB $|SNADF@@AASWAN A vĉT2AT K M8T2AT K M$XTAG AA ,U2AT K MLL0UZBBB B(A0A8F@ 8A0A(B BBBB @WA<WuBBB D(D0_(A BBBLXBEE E(D0A8DP 8D0A(B BBBC <LYBAD D@{  DABC | CABLYBBA D(G0f (D ABBA D (F ABBA L܋ZBHE E(D0A8D` 8A0A(B BBBF D,]BBB D(D0D@~ 0A(A BBBH <t(^BBA D(G@ (A ABBE 4_nAAD S DAB HDA<@_BBA A(DP (A ABBG 4,`BDD DP  AABA <d`BED D(D` (A ABBA 4XaBAD G0w  AABG 4܍a{BDD D0c  AABA <8bdBLE D(C0t (A BBBA ThbG A tbiPcHcVcmԎ(dvdd.BKB B(A0A8Dpo 8D0A(B BBBE S 8A0A(B BBBK dTXgzBBB B(A0A8D 8A0A(B BBBF   8D0A(B BBBH dpjBBB E(A0D8Da 8A0A(B BBBA  8A0A(B BBBB $$mAG@_ AH $LmAG@_ AH $tmAG@_ AH <pnBBD D(D@ (A ABBF Lܐ0oBBE E(D0A8HPR 8A0A(B BBBI L,uBBB B(A0A8Go 8A0A(B BBBF <|`|BBA D(G@ (A ABBC 0} ԑ(} }(}  } 4} L} d} |}||Ē| ܒ| |  | $| <|*T|*l||"}}̓ } 4}@AFG S AAE DGA, }&BFD RAB4L }HAKG S AAH DGA,8}+BKD RAB8} ̔0}G A $}AG AA ~ ,~ D~ \~ t~ ~ x~p~ ԕh~0D0k~1D0l~ ~ 4~L~d~|~x~$p~bADG SAA$Ԗ~bADG SAA$LADG }AA<$(BGB G(E0(A BBBd | ė'D0bܗ0D0k1D0l *D0e$,D0g<AD0n F \@JD0v F |pJD0z B JD0t H Ѐ ԘȀ D PȀ  4 L d|  ę ܙ x  p $h <` TX lP1D\ H Hp1D\ H H Ěܚ x  p ,$hBDA wAB$TȀAm J T D E<|@BDD q ABJ i ABD Ё8AM B cܛ8AM B c4{BBA C(F0f(A ABB44XBAD G  AABF LlBEB B(A0A8N 8A0A(B BBBJ L0.BBH B(A0D8D` 8A0A(B BBBF   <$BHB D(D0 (A BBBH dȎ_X,|AJG0s AAA LpBEB E(A0D8Gp 8A0A(B BBBE d BBB B(A0A8DY 8C0A(B BBBE q 8A0A(B BBGH LdؗhBEB E(A0A8G 8D0A(B BBBG dBBB B(A0A8DpZ 8A0A(B BBBA  8A0A(B BBBA 5<4ȝBED D(L@ (A ABBA LtX<BNE E(A0C8G0 8A0A(B BBBA LğBFBHI B(A0A8J 8A0A(B BBBA L!BBE H(D0D8G 8A0A(B BBBF Ld"BBB B(A0A8G` 8A0A(B BBBF <($BED D(G (A ABBA L$BBB B(A0A8G` 8A0A(B BBBE D%DM$\%3AGG aAA4%IAGG d AAK DCAL% BBB B(A0A8G 8A0A(B BBBA L P/bBBB E(A0A8G  8A0A(B BBBA L\p6BBB E(A0A8J  8A0A(B BBBD ,@8eBDD f GDE Tܢ8BDD @ AGF Z ABK ` GDE D DDD T49BDD @ AGF Z ABK ` GDE D DDD T9BDD @ AGF Z ABK ` GDE D DDD 4:ADG0C AAG  AAA T:BDD @ AGF Z ABK ` GDE D DDD Ltx;NBHB B(A0A8GP 8D0A(B BBBH LĤx<'BBB B(A0A8G@ 8D0A(B BBBH LX=BEB B(A0A8G` 8D0A(B BBBH d(?|0?L(?dBBB B(A0A8J 8A0A(B BBBE UFUMUUU[U`UfUrUUUUUUUUOUOUOUUUUUUUUUUVVV)V4VDVQVcVpVVVVVVVVVVWWW*W4WCWUWlWxWWWWWWWWWW X X+XƂЂނ  @".?JU]h t@ʃ փ@ڃ @ @"+6>IO W@^fmv~ „̄ӄ݄ @ @ބ# %.:&<0@;AGaSBdcjD|dEefGgHąhͅIڅikLlN no$P0p8qDrRSXs_tjUsu{Vvwxy]~Ć@ˆ@؆@@ @w@@@#@/7@ˆD L@U^hqz @@LJЇԇ݇ @&-5;C H@MV_fl t@~@uw|ӈ)SwˆLj̈шֈ] n!{%jvq; $5HUl.DWkU4,NFh`{&vBUix%>WakuJVQ[`eD`j! '%/5=EHKUg(p~###::A#7>C"GHOW\jn{1M*[k}"V',q 1HPbiz<Z%$-%5%(Ŝ ~")09DO[gj}mpsŪvy|    >%  ( 0 Z%<  B H N U \ d m t {          ͙ 2AR^lz  ! !!"!,!8! )C!L!ؙU!^!qg!l!!!!!œ;!!!d!!!!!!!"""""H&"/"9"YP C"I"S"Y"`"h"p"v"UM"}""""""""""""""""""""U""^"h"r#| ########'#+#L$/#3#8#@#H#Q#O#X#c#JVQ[`eD`j! '%/5=EHKn#t#~#,##########::#A###7>C"GHO#####$<#L# $ $$"$!$+$4$=$>H$P$Z$b$j$p$=v${$$$}"V',q $$$$$z<$%$$-%$$$Ŝ ~$")0$%O[%%"%*%2%;%C%H%O%W%_%g%p%y%%%%%%%%%%%%%%%    >%  ( 0 Z%% B H N U \ d m t {    %%%& &&&%&.&7&@&H&Q&\&f&o&x&&&&&&&&&&&&&&&&&''qg!'''"'*'3'œ9'UޏC'H'L'd'Q'V'['_'c'h'm'r'w''L|'Œ''''''''''')''''''''''''(( (((($(*(0(6(<(B(H(N(T(Z(`(f(l(r(x(~(((ʒ((f8&%>#{{{{{{||  4848op5 | p8eXx o~oonoh8FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv  & 6 F V f v           & 6 F V f v           & 6 F V f v           & 6 F V f v           & 6 F V f v         &6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv  & 6 F V f v         !!&!6!F!V!f!v!!!!!!!!!" PERL_DONT_CREATE_GVSV PERL_MALLOC_WRAP PERL_PRESERVE_IVUV USE_LOCALE USE_LOCALE_CTYPE USE_PERL_ATOF USE_SITECUSTOMIZE rp?0:AGag!'AGrp?0:AGagrp?0:A[_`a{rp?0:A[_`a{rp?A[rp?A[rp?  ! ( * / 0 _ ` 00rp?  !rp?!0:A[a{rp?!0:A[a{rp? xrp?  rp?a{rp?a{rp?!xrp?!rp?0:rp? rp? rp? ! / 0 _ ` 00rp? !rp?A[a{rp?A[a{rp?0:A[a{rp?0:A[a{rp?  ! ( * / 0 _ ` 00rp?  !rp? ( * rp?A[a{rp?rp?rp?#0?L_l| -:H[i{)?H?h\_rvéé\Eé  !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~"   *28>:DMQY6Pbj"q`w|+X+P+P+(+(Q0`CFstapsdtI(8perlphase__change8@40(%rax) 8@(%rax,%rcx,8)FstapsdtI(8perlphase__change8@48(%rax) 8@(%rax,%rdx,8)EstapsdtI(8perlphase__change8@8(%rax) 8@(%rax,%rdx,8)FstapsdtI(8perlphase__change8@16(%rax) 8@(%rax,%rcx,8)FstapsdtI(8perlphase__change8@16(%rax) 8@(%rax,%rcx,8)Fstapsdt9I(8perlphase__change8@40(%rax) 8@(%rax,%rcx,8)FstapsdtPI(8perlphase__change8@24(%rax) 8@(%rax,%rcx,8)FstapsdtI(8perlphase__change8@32(%rdx) 8@(%rdx,%rcx,8)Qstapsdt I&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)Pstapsdt I$8perlsub__entry8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)QstapsdtGI&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)Qstapsdt϶I&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)Qstapsdt7I&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)PstapsdtQI$8perlsub__entry8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)QstapsdtiI&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)QstapsdtkI&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)QstapsdtqI&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)Pstapsdt/{I$8perlsub__entry8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)Qstapsdt^{I&8perlsub__return8@%rdx 8@48(%rax) 4@36(%rax) 8@40(%rax)libperl.so.debug%7zXZִF!t/D]?Eh=ڊ2NdwK6]0@#iKΥrEWn)vB(W@ <2ڡTi[wz)x GjUt`>F?P>ê('{HKD٘OMf?$%P$XVMmK? WhlSb a3nSS1ԅs۔ \,z~5~ }5(r$G}s8C%|{NamYYka 9%a#&'k!8QR|9O S@yaV- )j(ҫzojqmߊV6o^j>a[*=]"ɷ,tGUV0:_Ut*f43[||* ԹT!`,qxn$gE7U}`U"y wРyUCoNhs SbB`M8l鱻ꀎd16İH-2Q,L7H?gFK_׾~w,rQWŦ؂º:㪣pkscurȳ}t v˻PwhO<5nn_SXU֦)ZW/. RPrvKϯ9[TJ /M]١~U֝VS0uy&3ORK͂n$VSٮ1Xoyb*~J楠pQowg8ףczQ)7y.A²t˷W™Y} Sb>rp @[fpXՍCQKvַC:`uXü_2;UbҠ2Mfа*ly[ 5M^w~0Y6u捄~B*22T 6’W.2gOfca4ě\JV Wcg;_qKTep!ny LՍaݐRcT&kRTª)v6Yۊڬ- Lo.Ay5jY/B42[mVbPz50Œ0_mhU0$\] 1ǔ<)5t>Q< ٘ݾ4{9\rgg!Wml<54o+,4Ov"5~6oʊӊy/2I0(2  E?ɚM`8`mNذY.NuzW?sVv O1/GdxӭV* a|HV;Q֙m7U'kphG"K*[xDcXD7 o Nm?8?~+=ZSscSktFzFnɃǀeOS|.=~҆35e& XEPǨɥyWTiXbe1=d3ӻkw2XC9-P6|UIt28 Ld6u9 Ңd2jotA8ECU^y&;1cmQ$F ޓjvt?`:&Xjnº̰S"=f˓"α_1уC Ql~Ρ(8"J,8?w'Q)|Qn>&"nTZÞ]g:ZL\K!!↪u?;GZzfJYPI!9e/=JBQ? f y\?*Oe(V FY{g^'BK۾P* f/Ϳmrv]kMG9'&{Rs㎝$A!a+ۏ%ONUZjk+L5z-\Dl:ZȬ%NJ-&OB_~`Gp󻘕=AC8g{{AQm[dKsNNojMw-fqf9nI Di8X@#nR;m>cj No;wRg=tE5qXͣEV#ь26 m'[llS+XvQbURE(MhomdɄՂd'07WEG̵GȒe n?3a|w%~Mv'&$&&: 7o %U5TzRpLNh&5bqځI} Rپ>błpf-@0@ 08;\`*Q` Çmx\žzZsA_C:<ִ~bKmϲ`WN}}.^iNP'ѱ[]ta69qK y]پ{4x0x ViHS]uk8 D#RHHEں^zքզX/  {=Ke՞V[Hq ~To1ɜJPEI%d`PX?2geIܓUo5iX'/EC%XI Cyx$F-I߃} oq:1gU)dt%K yQ,K WMu}g?Y:xݩT3g".,Xӗ@hg,@DO=`G$CYڬO5B&?iLL^Yֻ &L480XP D<1i:Q$ 18 Ovwي77ܦ^۳0hǺ6Άt^Rk5YXz-jAhZ]ྵDL*d^l ̲kʹG%Ѿ\-y =~AǭX|>>&n_-z1%GM($M~ȅ7F+S!o=]: 4&ʖlf+p颟'=6[H,5V*Y+(HyO֘mm+ 9; 9 sq5ogs\0ҹ`S6hwTzZz蕧Ǝ6nꯓ8 fY\p:;4P 5q"7nV"lD1a]I_j ,PRI+D~:Ya:~/d߻1,ԁu+߮tD,;.lFfG!o;k"_)B<p,9=L/ D@5wg!͓l`["*[hڀ^0Ak [H+`4}E[B4O:$kK 䕍*VCP2sM3YDu[ r"(9"u*uT,fg0W)T04 tf>VHe% *9~.ZyPG濦BfҮ'&U Znb=pQ/dd-hҀ/S\WT3Tv\ix% :52H(bq7KL}# 1/:i|̷ECdViQa$Vѱ0Bކϳ̨R)H7; c!IJ?)ǠxFiaT$>=_%"~`uǓ/l*ȁJDi`(J'$# 9e 5ܷc{8[MsP5ΒdSF*3*9<b}x1TQfG*[hX~!Dyvg KIDP'']UkI/A60ڪ&-# ueW|F [C% *R DAʭ-]@x,lG{tYz(JwhظB]T3暽 *7RkO&kMb G-ID냣]dfc/-"\H{LBYZp0J#owC.s_&VbJCxA[g!G+oCYO 4'33U5v+26Ldzs{0_\^F)ަbfe8bcJP¤3j9hr/Dž{ ֟}-Qb3H8V?_.؈Mւ[PyA,!&ߎ(/)eu pSJ!eAVTrѯJ)nK*ZViTrtN)tnmsҰUA)3/ [<A g E 釾zg4@ՅԺsY)DOn;{nÔAqQofI漉OR _#7d+Co=M&!+l;M{ 5/ G$( `/9:>SmYJO0h0hJQH ,bHg%+W)Iut-Hc7<" ӧj(hr&QJk`(Q3gKd7}<ЏU?B>r7 z4F {](5^cnb,'1ְ7iv֒0!?0EY0{lXWX t @ fnGD{fsRh;6.#E5ry%L;"eZC{w6/ӉH ;bi bөyjV*8c$x}[;I6\ dxrZ6I ҩM~4j'3 h{芡%Axؑ~nu]y܊fFlVz 8Fm:: 3flo0OҚ,9Ky?ZarÕy[Pv&nu؎;AIN0.֪[)H g#nwAi[<(\™wh pmgYZ`ӉL|ckd ̖o٦e I@1OCf# V s.]KORWoQG4Phޘ AYl|ވMρR"xSV5BgJ%D* ~rb;7FȊsZwu/9C+=^$k , KR ⩟_&nJR)k|J QߤO@G<O>qgV T!+Md9sexڰ;_ oWL &bM Hg/Fa @~Ƒ|a_lS&B1j'?P/bψ"'BĴ?Wc3b$h^Er(xXO9v-,0 ,c\3[V1a~rRbFydH*7y=ѾpC"zp;˲I~}iQLqcSӕG}䶗~ml2ZEX `zy5 ^C%3D2D[S)b8ƨ㴖EՍ~o25 ,V* u3bFZل5߱'Q^XOFr,v pK8=zXAf|(`$}[ LQ_0s(*~`jBԖ;Kz8jXp%Z9j)WH&-pPAoKT2jɟ! CbYb[^ ڒg'OGcӅoIzI|]bvR;|O!EK_38EjdΧ\'Db[o@c/s!6g᠏,dzdPux;rEy]?a|9k@G`NIMe+G8Tso^ZrlX;92w{)'zW0g%} ӵL3k,34M \W3~2CbȪ֛>Cp'Ic c$ k{=fٵ Ɇ@,՗x~L9)uYNYFth22bܭWV^Z$SEzOxKC@$Y/vr򅔉w/D'UxqPpl2lKuTtSlY,3'Ͽ/i>*r.% 9k}ZAo琳K32~ CD åx1휶5;xY(kiB.RNC*]ЩBZquk$[%-`Rܼg@Puuj? fyA\A`%.ˀƭ盧o} #%Ah^2E3? <LD!Ƽ7r j堤 , /+_]Gfaʍ!"gjg?u`/L>篦#T!1XQ.cgϭ]j}{(|b+ZUU3Q#;HK& mIA xN, B)) Ɔ'Ę@#2z-Ε(/Mv$ Ov#WD֔zsNv ~n\!p҃lg&k NI3#xQ+ȭ,TYvǷ[[nhUp3+:6Fx'X\LQy"n$A-Q%?өx- щt(B?Z]M%OHGKw`+uڭh$fؖ *E!S PG.adw='.a95ݥ$V0jXс= g6YY`CRa{d> FE>HtqGf$tJN,Cnsw`%AˁGf뭣_I15{RVwk`md*5 \+o:~ p+ _[1in|Me`f+U/mF')G)U]?4(=BSʘn( dpiq\*`wf(;F!q2~B43n&F 1l>;G3ix(d",P +ؙ@+w-~Y V)V4WBzeޡa@Sd_KsƊ4b!1 )' U+lbuՍ~` MB#lVɓ ѡܫqEq%y`H0r0`zbΩ7}z4*]e|q-Zt60RB|FƱMGXҡ%v=7?z '>smJkSImiIK.ljbkR^_ꉞ* յaI^|*(#MbXnj9?|t< q҇qC[(𲸄Kh&8gl]?fku^}-Ht)h(ٸD",klG|Ä˾9lTS+ɵ&0ffrҵqUh~Mh+_'U/.t<6zqӂ`̉fj!ٕ|Eܺ+tq}(c߈jO{|lLc% :+XirÝ3 qҾT,k$K@*e!K&>.]U4)2&Q@IMJISs*Z:s+|yK8k(g Эqܬ+ "},l.(K_y߆jjtrr,$cZ@yyc7{;xo%ۮ‹$y$Rq3 ﲐd.MR~,~oYzDk-7N5 1'!CkрA(7Ns~ƮbTus /} w/m\^lyI^$'?Qȵ Vΐ[[}?W#2Llh1A<1_]^`l$ n]G[nrbC̔G M=S f˷S0LWRicLOu Ja-vfj.+=hF2ϸ S1)5U/%2+4J˛mC6b#g.? ?똞Ogxn*sGtI?6'2%!Tz~gL) <4d'X+P-0xP}QF6`$5 ŵS ;7($^>_)D:B %u'?:-U1g^` 틄 /wʷ¼90BWb1WB=.}hBS^j}tCi+:pN1:y$ Q'w~oϰԥȍ" ^uvI/?]kRA"AQ Ơs-R(;M1N=BMӬ?"ӤӆOA ːg2e<ăiO*۽{R'>*[}S$?7  @HNwN.JY 6Lk:vs k&f_U A}M~v? 1Ù5v.sGK,~ ;8RMGm^JVAb6a!9,GިutY<(X8ةP[8nޞ,=ku/I-h*bp rԄrΚ O {I")ڤdE_.Cz%AgjVX: Gy_c{*.7]k xD $А L!IwEf\g{C:l+9¼B/x:#i5kOʢ!?%<.nUA}Ljncv.t-` O8S>l,Ec.ĻI{lJȬCIhftZ|dEOcs0bLO"=b)JB{l̺Il;݇޾[L#ծ>eЭQW?vq6 WF< >k@;YXYeA'q&W +>+_|WaHG{a[2 \b&gicա3nVo6 n1OW&Sa=LD *:+r'r(0*Me8voa^w@LevZfgba/M  fHÛ#ۍu+4ǴN }U QuQ~44HF5>t2xVٱWPZ0]3QDuhku¥i$Т@I{oe/XQQ$LPO7$LJ ̾WFQ0#&{)KڐS3cuϥ)'4w>D&Z2)q}+G11Zy&:L}{ Rbl޺/P\t74އ0%LU{,5HVaFV&2|^@I%d_ $s's/Lƈ~##eET.-+ $EuM, 7NLh_VEy=qqK'IeKnf/@ZhX==ub|ў a R9h, K#fI!$~9Kx$Ҩ:|ϺYҭ,AK{o@fF_l5X?E7vgy=Kh/{7nB/pS^az=|Tݜ%ey g Q@t0tRV-L+ŗsRipx;y^|nqL7q0f+عIXS. N[`W+H;4KJvY]$-28tMuOzbz?/cB2-Czt(A&òVՄ.Zۈc!Qж M٨嬽o͖}S4XUw$fw& 5#N?ƒ%H6w::ϹطҺouI?8ƩioB6\Ld`OA(NXky,'&,DR(4 P}|LZ{+j+fH`M ?ӿ kgΫDPS]rv\m !S@Xe!@8#+8PvLZŌHYŜsKr 0ajq bi?q\$̙Λ4~Vy2X۩aj4 u_c}Z)hR(]қ5D4foy%Zsz*0PnRp [Xw3&`7]BfȞ46|3<.79McUMJ=kۖι7yZPdZDA$dŁ<,ź2YQpo dxam~;?hMq!cO _a1 grnA9   kW,vM2?RO]՝JtN]XAs^"&>OAeRHơ K&^v f׹LFAOJA\}4fʠ*&x#cv"Gqlt08k F:ꕭVЁ@UznéYDyР*O{#& 4nQ2\ݒ9v6%pGĦc*G3cql=ܢkd`'V[9Csk'STʬ:wNԗ =)u]Gp.3wfTLWEXCv)!&glK/"*a*yH?8;:,~ֳ֞@xWctn&к}3ăVCa5ᓛP?SN3 Nk!$bIsAfbudz ΅S2`[R!kag]"U@Y1&/;ᓓե&y4gaxHtӅey췟U|in"P$s;GBcv9M[j<Ggm+;[tQjFl鄋V5{T+PHpߵc"cIQ:AN/ bUlU[ȏY/HZm1)ȹYn/}ogyO+|x;t保+/݉(r9)M -:}aX 4 vG ICT U.sĀG*B8Y 9.ޢ \\;T}1/F*GKLECl!(Fc0yQ]31g˱&pTzuȔ:Z,_flag & _IONBF) && \ ((*(f))->_ptr > (*(f))->_base)) ? \ ((*(f))->_cnt++, *(--(*(f))->_ptr) = (c)) : decc$ungetc(c,f))) # else # define PerlIO_ungetc(f,c) ungetc(c,f) # endif /* Work around bug in DECCRTL/AXP (DECC v5.x) and some versions of old * VAXCRTL which causes read from a pipe after EOF has been returned * once to hang. */ # define PerlIO_getc(f) \ (feof(f) ? EOF : getc(f)) # define PerlIO_read(f,buf,count) \ (feof(f) ? 0 : (SSize_t)fread(buf,1,count,f)) # define PerlIO_tell(f) ftell(f) #else # define PerlIO_getc(f) PerlSIO_fgetc(f) # define PerlIO_ungetc(f,c) PerlSIO_ungetc(c,f) # define PerlIO_read(f,buf,count) (SSize_t)PerlSIO_fread(buf,1,count,f) # define PerlIO_tell(f) PerlSIO_ftell(f) #endif #define PerlIO_eof(f) PerlSIO_feof(f) #define PerlIO_getname(f,b) fgetname(f,b) #define PerlIO_error(f) PerlSIO_ferror(f) #define PerlIO_fileno(f) PerlSIO_fileno(f) #define PerlIO_clearerr(f) PerlSIO_clearerr(f) #define PerlIO_flush(f) PerlSIO_fflush(f) #if defined(VMS) && !defined(__DECC) /* Old VAXC RTL doesn't reset EOF on seek; Perl folk seem to expect this */ #define PerlIO_seek(f,o,w) (((f) && (*f) && ((*f)->_flag &= ~_IOEOF)),fseek(f,o,w)) #else # define PerlIO_seek(f,o,w) PerlSIO_fseek(f,o,w) #endif #define PerlIO_rewind(f) PerlSIO_rewind(f) #define PerlIO_tmpfile() PerlSIO_tmpfile() #define PerlIO_importFILE(f,fl) (f) #define PerlIO_exportFILE(f,fl) (f) #define PerlIO_findFILE(f) (f) #define PerlIO_releaseFILE(p,f) ((void) 0) #ifdef HAS_SETLINEBUF #define PerlIO_setlinebuf(f) PerlSIO_setlinebuf(f); #else #define PerlIO_setlinebuf(f) PerlSIO_setvbuf(f, NULL, _IOLBF, 0); #endif /* Now our interface to Configure's FILE_xxx macros */ #ifdef USE_STDIO_PTR #define PerlIO_has_cntptr(f) 1 #define PerlIO_get_ptr(f) PerlSIO_get_ptr(f) #define PerlIO_get_cnt(f) PerlSIO_get_cnt(f) #ifdef STDIO_CNT_LVALUE #define PerlIO_canset_cnt(f) 1 #define PerlIO_set_cnt(f,c) PerlSIO_set_cnt(f,c) #ifdef STDIO_PTR_LVALUE #ifdef STDIO_PTR_LVAL_NOCHANGE_CNT #define PerlIO_fast_gets(f) 1 #endif #endif /* STDIO_PTR_LVALUE */ #else /* STDIO_CNT_LVALUE */ #define PerlIO_canset_cnt(f) 0 #define PerlIO_set_cnt(f,c) abort() #endif #ifdef STDIO_PTR_LVALUE #ifdef STDIO_PTR_LVAL_NOCHANGE_CNT #define PerlIO_set_ptrcnt(f,p,c) STMT_START {PerlSIO_set_ptr(f,p), PerlIO_set_cnt(f,c);} STMT_END #else #ifdef STDIO_PTR_LVAL_SETS_CNT /* assert() may pre-process to ""; potential syntax error (FILE_ptr(), ) */ #define PerlIO_set_ptrcnt(f,p,c) STMT_START {PerlSIO_set_ptr(f,p); assert(PerlSIO_get_cnt(f) == (c));} STMT_END #define PerlIO_fast_gets(f) 1 #else #define PerlIO_set_ptrcnt(f,p,c) abort() #endif #endif #endif #else /* USE_STDIO_PTR */ #define PerlIO_has_cntptr(f) 0 #define PerlIO_canset_cnt(f) 0 #define PerlIO_get_cnt(f) (abort(),0) #define PerlIO_get_ptr(f) (abort(),(void *)0) #define PerlIO_set_cnt(f,c) abort() #define PerlIO_set_ptrcnt(f,p,c) abort() #endif /* USE_STDIO_PTR */ #ifndef PerlIO_fast_gets #define PerlIO_fast_gets(f) 0 #endif #ifdef FILE_base #define PerlIO_has_base(f) 1 #define PerlIO_get_base(f) PerlSIO_get_base(f) #define PerlIO_get_bufsiz(f) PerlSIO_get_bufsiz(f) #else #define PerlIO_has_base(f) 0 #define PerlIO_get_base(f) (abort(),(void *)0) #define PerlIO_get_bufsiz(f) (abort(),0) #endif #endif /* NETWARE */ #endif /* PERLIO_IS_STDIO */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ= perldtrace.hnuW+A/* Generated by the Systemtap dtrace wrapper */ #define _SDT_HAS_SEMAPHORES 1 #define STAP_HAS_SEMAPHORES 1 /* deprecated */ #include /* PERL_SUB_ENTRY ( const char *, const char *, int, const char * ) */ #if defined STAP_SDT_V1 #define PERL_SUB_ENTRY_ENABLED() __builtin_expect (sub__entry_semaphore, 0) #define perl_sub__entry_semaphore sub__entry_semaphore #else #define PERL_SUB_ENTRY_ENABLED() __builtin_expect (perl_sub__entry_semaphore, 0) #endif __extension__ extern unsigned short perl_sub__entry_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes"))); #define PERL_SUB_ENTRY(arg1, arg2, arg3, arg4) \ DTRACE_PROBE4 (perl, sub__entry, arg1, arg2, arg3, arg4) /* PERL_SUB_RETURN ( const char *, const char *, int, const char * ) */ #if defined STAP_SDT_V1 #define PERL_SUB_RETURN_ENABLED() __builtin_expect (sub__return_semaphore, 0) #define perl_sub__return_semaphore sub__return_semaphore #else #define PERL_SUB_RETURN_ENABLED() __builtin_expect (perl_sub__return_semaphore, 0) #endif __extension__ extern unsigned short perl_sub__return_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes"))); #define PERL_SUB_RETURN(arg1, arg2, arg3, arg4) \ DTRACE_PROBE4 (perl, sub__return, arg1, arg2, arg3, arg4) /* PERL_PHASE_CHANGE ( const char *, const char * ) */ #if defined STAP_SDT_V1 #define PERL_PHASE_CHANGE_ENABLED() __builtin_expect (phase__change_semaphore, 0) #define perl_phase__change_semaphore phase__change_semaphore #else #define PERL_PHASE_CHANGE_ENABLED() __builtin_expect (perl_phase__change_semaphore, 0) #endif __extension__ extern unsigned short perl_phase__change_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes"))); #define PERL_PHASE_CHANGE(arg1, arg2) \ DTRACE_PROBE2 (perl, phase__change, arg1, arg2) PKZ2<< mydtrace.hnuW+A/* mydtrace.h * * Copyright (C) 2008, 2010, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * Provides macros that wrap the various DTrace probes we use. We add * an extra level of wrapping to encapsulate the _ENABLED tests. */ #if defined(USE_DTRACE) && defined(PERL_CORE) # include "perldtrace.h" # if defined(STAP_PROBE_ADDR) && !defined(DEBUGGING) /* SystemTap 1.2 uses a construct that chokes on passing a char array * as a char *, in this case hek_key in struct hek. Workaround it * with a temporary. */ # define ENTRY_PROBE(func, file, line, stash) \ if (PERL_SUB_ENTRY_ENABLED()) { \ const char *tmp_func = func; \ PERL_SUB_ENTRY(tmp_func, file, line, stash); \ } # define RETURN_PROBE(func, file, line, stash) \ if (PERL_SUB_RETURN_ENABLED()) { \ const char *tmp_func = func; \ PERL_SUB_RETURN(tmp_func, file, line, stash); \ } # else # define ENTRY_PROBE(func, file, line, stash) \ if (PERL_SUB_ENTRY_ENABLED()) { \ PERL_SUB_ENTRY(func, file, line, stash); \ } # define RETURN_PROBE(func, file, line, stash) \ if (PERL_SUB_RETURN_ENABLED()) { \ PERL_SUB_RETURN(func, file, line, stash); \ } # endif # define PHASE_CHANGE_PROBE(new_phase, old_phase) \ if (PERL_PHASE_CHANGE_ENABLED()) { \ PERL_PHASE_CHANGE(new_phase, old_phase); \ } #else /* NOPs */ # define ENTRY_PROBE(func, file, line, stash) # define RETURN_PROBE(func, file, line, stash) # define PHASE_CHANGE_PROBE(new_phase, old_phase) #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZrrregexp.hnuW+A/* regexp.h * * Copyright (C) 1993, 1994, 1996, 1997, 1999, 2000, 2001, 2003, * 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * Definitions etc. for regexp(3) routines. * * Caveat: this is V8 regexp(3) [actually, a reimplementation thereof], * not the System V one. */ #ifndef PLUGGABLE_RE_EXTENSION /* we don't want to include this stuff if we are inside of an external regex engine based on the core one - like re 'debug'*/ struct regnode { U8 flags; U8 type; U16 next_off; }; typedef struct regnode regnode; struct reg_substr_data; struct reg_data; struct regexp_engine; struct regexp; struct reg_substr_datum { I32 min_offset; I32 max_offset; SV *substr; /* non-utf8 variant */ SV *utf8_substr; /* utf8 variant */ I32 end_shift; }; struct reg_substr_data { struct reg_substr_datum data[3]; /* Actual array */ }; #ifdef PERL_OLD_COPY_ON_WRITE #define SV_SAVED_COPY SV *saved_copy; /* If non-NULL, SV which is COW from original */ #else #define SV_SAVED_COPY #endif typedef struct regexp_paren_pair { I32 start; I32 end; } regexp_paren_pair; #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) #define _invlist_union(a, b, output) _invlist_union_maybe_complement_2nd(a, b, FALSE, output) #define _invlist_intersection(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, FALSE, output) /* Subtracting b from a leaves in a everything that was there that isn't in b, * that is the intersection of a with b's complement */ #define _invlist_subtract(a, b, output) _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output) #endif /* The regexp/REGEXP struct, see L for further documentation on the individual fields. The struct is ordered so that the most commonly used fields are placed at the start. Any patch that adds items to this struct will need to include changes to F (C) and F (C). This involves freeing or cloning items in the regexp's data array based on the data item's type. */ #define _REGEXP_COMMON \ /* what engine created this regexp? */ \ const struct regexp_engine* engine; \ REGEXP *mother_re; /* what re is this a lightweight copy of? */ \ HV *paren_names; /* Optional hash of paren names */ \ /* Information about the match that the perl core uses to */ \ /* manage things */ \ U32 extflags; /* Flags used both externally and internally */ \ I32 minlen; /* mininum possible length of string to match */\ I32 minlenret; /* mininum possible length of $& */ \ U32 gofs; /* chars left of pos that we search from */ \ /* substring data about strings that must appear in the */ \ /* final match, used for optimisations */ \ struct reg_substr_data *substrs; \ U32 nparens; /* number of capture buffers */ \ /* private engine specific data */ \ U32 intflags; /* Engine Specific Internal flags */ \ void *pprivate; /* Data private to the regex engine which */ \ /* created this object. */ \ /* Data about the last/current match. These are modified */ \ /* during matching */ \ U32 lastparen; /* last open paren matched */ \ U32 lastcloseparen; /* last close paren matched */ \ regexp_paren_pair *swap; /* Unused: 5.10.1 and later */ \ /* Array of offsets for (@-) and (@+) */ \ regexp_paren_pair *offs; \ /* saved or original string so \digit works forever. */ \ char *subbeg; \ SV_SAVED_COPY /* If non-NULL, SV which is COW from original */\ I32 sublen; /* Length of string pointed by subbeg */ \ /* Information about the match that isn't often used */ \ /* offset from wrapped to the start of precomp */ \ PERL_BITFIELD32 pre_prefix:4; \ /* number of eval groups in the pattern - for security checks */\ PERL_BITFIELD32 seen_evals:28 typedef struct regexp { _XPV_HEAD; _REGEXP_COMMON; } regexp; #define RXp_PAREN_NAMES(rx) ((rx)->paren_names) /* used for high speed searches */ typedef struct re_scream_pos_data_s { char **scream_olds; /* match pos */ I32 *scream_pos; /* Internal iterator of scream. */ } re_scream_pos_data; /* regexp_engine structure. This is the dispatch table for regexes. * Any regex engine implementation must be able to build one of these. */ typedef struct regexp_engine { REGEXP* (*comp) (pTHX_ SV * const pattern, U32 flags); I32 (*exec) (pTHX_ REGEXP * const rx, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, void* data, U32 flags); char* (*intuit) (pTHX_ REGEXP * const rx, SV *sv, char *strpos, char *strend, const U32 flags, re_scream_pos_data *data); SV* (*checkstr) (pTHX_ REGEXP * const rx); void (*free) (pTHX_ REGEXP * const rx); void (*numbered_buff_FETCH) (pTHX_ REGEXP * const rx, const I32 paren, SV * const sv); void (*numbered_buff_STORE) (pTHX_ REGEXP * const rx, const I32 paren, SV const * const value); I32 (*numbered_buff_LENGTH) (pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren); SV* (*named_buff) (pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags); SV* (*named_buff_iter) (pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags); SV* (*qr_package)(pTHX_ REGEXP * const rx); #ifdef USE_ITHREADS void* (*dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS *param); #endif } regexp_engine; /* These are passed to the numbered capture variable callbacks as the paren name. >= 1 is reserved for actual numbered captures, i.e. $1, $2 etc. */ #define RX_BUFF_IDX_PREMATCH -2 /* $` / ${^PREMATCH} */ #define RX_BUFF_IDX_POSTMATCH -1 /* $' / ${^POSTMATCH} */ #define RX_BUFF_IDX_FULLMATCH 0 /* $& / ${^MATCH} */ /* Flags that are passed to the named_buff and named_buff_iter callbacks above. Those routines are called from universal.c via the Tie::Hash::NamedCapture interface for %+ and %- and the re:: functions in the same file. */ /* The Tie::Hash::NamedCapture operation this is part of, if any */ #define RXapif_FETCH 0x0001 #define RXapif_STORE 0x0002 #define RXapif_DELETE 0x0004 #define RXapif_CLEAR 0x0008 #define RXapif_EXISTS 0x0010 #define RXapif_SCALAR 0x0020 #define RXapif_FIRSTKEY 0x0040 #define RXapif_NEXTKEY 0x0080 /* Whether %+ or %- is being operated on */ #define RXapif_ONE 0x0100 /* %+ */ #define RXapif_ALL 0x0200 /* %- */ /* Whether this is being called from a re:: function */ #define RXapif_REGNAME 0x0400 #define RXapif_REGNAMES 0x0800 #define RXapif_REGNAMES_COUNT 0x1000 /* =head1 REGEXP Functions =for apidoc Am|REGEXP *|SvRX|SV *sv Convenience macro to get the REGEXP from a SV. This is approximately equivalent to the following snippet: if (SvMAGICAL(sv)) mg_get(sv); if (SvROK(sv)) sv = MUTABLE_SV(SvRV(sv)); if (SvTYPE(sv) == SVt_REGEXP) return (REGEXP*) sv; NULL will be returned if a REGEXP* is not found. =for apidoc Am|bool|SvRXOK|SV* sv Returns a boolean indicating whether the SV (or the one it references) is a REGEXP. If you want to do something with the REGEXP* later use SvRX instead and check for NULL. =cut */ #define SvRX(sv) (Perl_get_re_arg(aTHX_ sv)) #define SvRXOK(sv) (Perl_get_re_arg(aTHX_ sv) ? TRUE : FALSE) /* Flags stored in regexp->extflags * These are used by code external to the regexp engine * * Note that the flags whose names start with RXf_PMf_ are defined in * op_reg_common.h, being copied from the parallel flags of op_pmflags * * NOTE: if you modify any RXf flags you should run regen.pl or * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ #include "op_reg_common.h" #define RXf_PMf_STD_PMMOD (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_FOLD|RXf_PMf_EXTENDED) #define CASE_STD_PMMOD_FLAGS_PARSE_SET(pmfl) \ case IGNORE_PAT_MOD: *(pmfl) |= RXf_PMf_FOLD; break; \ case MULTILINE_PAT_MOD: *(pmfl) |= RXf_PMf_MULTILINE; break; \ case SINGLE_PAT_MOD: *(pmfl) |= RXf_PMf_SINGLELINE; break; \ case XTENDED_PAT_MOD: *(pmfl) |= RXf_PMf_EXTENDED; break /* Note, includes charset ones, assumes 0 is the default for them */ #define STD_PMMOD_FLAGS_CLEAR(pmfl) \ *(pmfl) &= ~(RXf_PMf_FOLD|RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_EXTENDED|RXf_PMf_CHARSET) /* chars and strings used as regex pattern modifiers * Singular is a 'c'har, plural is a "string" * * NOTE, KEEPCOPY was originally 'k', but was changed to 'p' for preserve * for compatibility reasons with Regexp::Common which highjacked (?k:...) * for its own uses. So 'k' is out as well. */ #define DEFAULT_PAT_MOD '^' /* Short for all the default modifiers */ #define EXEC_PAT_MOD 'e' #define KEEPCOPY_PAT_MOD 'p' #define ONCE_PAT_MOD 'o' #define GLOBAL_PAT_MOD 'g' #define CONTINUE_PAT_MOD 'c' #define MULTILINE_PAT_MOD 'm' #define SINGLE_PAT_MOD 's' #define IGNORE_PAT_MOD 'i' #define XTENDED_PAT_MOD 'x' #define NONDESTRUCT_PAT_MOD 'r' #define LOCALE_PAT_MOD 'l' #define UNICODE_PAT_MOD 'u' #define DEPENDS_PAT_MOD 'd' #define ASCII_RESTRICT_PAT_MOD 'a' #define ONCE_PAT_MODS "o" #define KEEPCOPY_PAT_MODS "p" #define EXEC_PAT_MODS "e" #define LOOP_PAT_MODS "gc" #define NONDESTRUCT_PAT_MODS "r" #define LOCALE_PAT_MODS "l" #define UNICODE_PAT_MODS "u" #define DEPENDS_PAT_MODS "d" #define ASCII_RESTRICT_PAT_MODS "a" #define ASCII_MORE_RESTRICT_PAT_MODS "aa" /* This string is expected by regcomp.c to be ordered so that the first * character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of extflags; the next * character is bit +1, etc. */ #define STD_PAT_MODS "msix" #define CHARSET_PAT_MODS ASCII_RESTRICT_PAT_MODS DEPENDS_PAT_MODS LOCALE_PAT_MODS UNICODE_PAT_MODS /* This string is expected by XS_re_regexp_pattern() in universal.c to be ordered * so that the first character is the flag in bit RXf_PMf_STD_PMMOD_SHIFT of * extflags; the next character is in bit +1, etc. */ #define INT_PAT_MODS STD_PAT_MODS KEEPCOPY_PAT_MODS #define EXT_PAT_MODS ONCE_PAT_MODS KEEPCOPY_PAT_MODS #define QR_PAT_MODS STD_PAT_MODS EXT_PAT_MODS CHARSET_PAT_MODS #define M_PAT_MODS QR_PAT_MODS LOOP_PAT_MODS #define S_PAT_MODS M_PAT_MODS EXEC_PAT_MODS NONDESTRUCT_PAT_MODS /* * NOTE: if you modify any RXf flags you should run regen.pl or * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ /* Leave some space, so future bit allocations can go either in the shared or * unshared area without affecting binary compatibility */ #define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+1) /* Manually decorate this function with gcc-style attributes just to * avoid having to restructure the header files and their called order, * as proto.h would have to be included before this file, and isn't */ PERL_STATIC_INLINE const char * get_regex_charset_name(const U32 flags, STRLEN* const lenp) __attribute__warn_unused_result__; #define MAX_CHARSET_NAME_LENGTH 2 PERL_STATIC_INLINE const char * get_regex_charset_name(const U32 flags, STRLEN* const lenp) { /* Returns a string that corresponds to the name of the regex character set * given by 'flags', and *lenp is set the length of that string, which * cannot exceed MAX_CHARSET_NAME_LENGTH characters */ *lenp = 1; switch (get_regex_charset(flags)) { case REGEX_DEPENDS_CHARSET: return DEPENDS_PAT_MODS; case REGEX_LOCALE_CHARSET: return LOCALE_PAT_MODS; case REGEX_UNICODE_CHARSET: return UNICODE_PAT_MODS; case REGEX_ASCII_RESTRICTED_CHARSET: return ASCII_RESTRICT_PAT_MODS; case REGEX_ASCII_MORE_RESTRICTED_CHARSET: *lenp = 2; return ASCII_MORE_RESTRICT_PAT_MODS; default: return "?"; /* Unknown */ } } /* Anchor and GPOS related stuff */ #define RXf_ANCH_BOL (1<<(RXf_BASE_SHIFT+0)) #define RXf_ANCH_MBOL (1<<(RXf_BASE_SHIFT+1)) #define RXf_ANCH_SBOL (1<<(RXf_BASE_SHIFT+2)) #define RXf_ANCH_GPOS (1<<(RXf_BASE_SHIFT+3)) #define RXf_GPOS_SEEN (1<<(RXf_BASE_SHIFT+4)) #define RXf_GPOS_FLOAT (1<<(RXf_BASE_SHIFT+5)) /* two bits here */ #define RXf_ANCH (RXf_ANCH_BOL|RXf_ANCH_MBOL|RXf_ANCH_GPOS|RXf_ANCH_SBOL) #define RXf_GPOS_CHECK (RXf_GPOS_SEEN|RXf_ANCH_GPOS) #define RXf_ANCH_SINGLE (RXf_ANCH_SBOL|RXf_ANCH_GPOS) /* What we have seen */ #define RXf_LOOKBEHIND_SEEN (1<<(RXf_BASE_SHIFT+6)) #define RXf_EVAL_SEEN (1<<(RXf_BASE_SHIFT+7)) #define RXf_CANY_SEEN (1<<(RXf_BASE_SHIFT+8)) /* Special */ #define RXf_NOSCAN (1<<(RXf_BASE_SHIFT+9)) #define RXf_CHECK_ALL (1<<(RXf_BASE_SHIFT+10)) /* UTF8 related */ #define RXf_MATCH_UTF8 (1<<(RXf_BASE_SHIFT+11)) /* Intuit related */ #define RXf_USE_INTUIT_NOML (1<<(RXf_BASE_SHIFT+12)) #define RXf_USE_INTUIT_ML (1<<(RXf_BASE_SHIFT+13)) #define RXf_INTUIT_TAIL (1<<(RXf_BASE_SHIFT+14)) /* Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will be used by regex engines to check whether they should set RXf_SKIPWHITE */ #define RXf_SPLIT (1<<(RXf_BASE_SHIFT+15)) #define RXf_USE_INTUIT (RXf_USE_INTUIT_NOML|RXf_USE_INTUIT_ML) /* Copy and tainted info */ #define RXf_COPY_DONE (1<<(RXf_BASE_SHIFT+16)) /* during execution: pattern temporarily tainted by executing locale ops; * post-execution: $1 et al are tainted */ #define RXf_TAINTED_SEEN (1<<(RXf_BASE_SHIFT+17)) /* this pattern was tainted during compilation */ #define RXf_TAINTED (1<<(RXf_BASE_SHIFT+18)) /* Flags indicating special patterns */ #define RXf_START_ONLY (1<<(RXf_BASE_SHIFT+19)) /* Pattern is /^/ */ #define RXf_SKIPWHITE (1<<(RXf_BASE_SHIFT+20)) /* Pattern is for a split / / */ #define RXf_WHITE (1<<(RXf_BASE_SHIFT+21)) /* Pattern is /\s+/ */ #define RXf_NULL (1U<<(RXf_BASE_SHIFT+22)) /* Pattern is // */ #if RXf_BASE_SHIFT+22 > 31 # error Too many RXf_PMf bits used. See regnodes.h for any spare in middle #endif /* * NOTE: if you modify any RXf flags you should run regen.pl or * regen/regcomp.pl so that regnodes.h is updated with the changes. * */ #define RX_HAS_CUTGROUP(prog) ((prog)->intflags & PREGf_CUTGROUP_SEEN) #define RXp_MATCH_TAINTED(prog) (RXp_EXTFLAGS(prog) & RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED(prog) (RX_EXTFLAGS(prog) & RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED_on(prog) (RX_EXTFLAGS(prog) |= RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_TAINTED_SEEN) #define RX_MATCH_TAINTED_set(prog, t) ((t) \ ? RX_MATCH_TAINTED_on(prog) \ : RX_MATCH_TAINTED_off(prog)) #define RXp_MATCH_COPIED(prog) (RXp_EXTFLAGS(prog) & RXf_COPY_DONE) #define RX_MATCH_COPIED(prog) (RX_EXTFLAGS(prog) & RXf_COPY_DONE) #define RXp_MATCH_COPIED_on(prog) (RXp_EXTFLAGS(prog) |= RXf_COPY_DONE) #define RX_MATCH_COPIED_on(prog) (RX_EXTFLAGS(prog) |= RXf_COPY_DONE) #define RXp_MATCH_COPIED_off(prog) (RXp_EXTFLAGS(prog) &= ~RXf_COPY_DONE) #define RX_MATCH_COPIED_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_COPY_DONE) #define RX_MATCH_COPIED_set(prog,t) ((t) \ ? RX_MATCH_COPIED_on(prog) \ : RX_MATCH_COPIED_off(prog)) #define RXp_EXTFLAGS(rx) ((rx)->extflags) /* For source compatibility. We used to store these explicitly. */ #define RX_PRECOMP(prog) (RX_WRAPPED(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) #define RX_PRECOMP_const(prog) (RX_WRAPPED_const(prog) + ((struct regexp *)SvANY(prog))->pre_prefix) /* FIXME? Are we hardcoding too much here and constraining plugin extension writers? Specifically, the value 1 assumes that the wrapped version always has exactly one character at the end, a ')'. Will that always be true? */ #define RX_PRELEN(prog) (RX_WRAPLEN(prog) - ((struct regexp *)SvANY(prog))->pre_prefix - 1) #define RX_WRAPPED(prog) SvPVX(prog) #define RX_WRAPPED_const(prog) SvPVX_const(prog) #define RX_WRAPLEN(prog) SvCUR(prog) #define RX_CHECK_SUBSTR(prog) (((struct regexp *)SvANY(prog))->check_substr) #define RX_REFCNT(prog) SvREFCNT(prog) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define RX_EXTFLAGS(prog) \ (*({ \ const REGEXP *const _rx_extflags = (prog); \ assert(SvTYPE(_rx_extflags) == SVt_REGEXP); \ &RXp_EXTFLAGS(SvANY(_rx_extflags)); \ })) # define RX_ENGINE(prog) \ (*({ \ const REGEXP *const _rx_engine = (prog); \ assert(SvTYPE(_rx_engine) == SVt_REGEXP); \ &SvANY(_rx_engine)->engine; \ })) # define RX_SUBBEG(prog) \ (*({ \ const REGEXP *const _rx_subbeg = (prog); \ assert(SvTYPE(_rx_subbeg) == SVt_REGEXP); \ &SvANY(_rx_subbeg)->subbeg; \ })) # define RX_OFFS(prog) \ (*({ \ const REGEXP *const _rx_offs = (prog); \ assert(SvTYPE(_rx_offs) == SVt_REGEXP); \ &SvANY(_rx_offs)->offs; \ })) # define RX_NPARENS(prog) \ (*({ \ const REGEXP *const _rx_nparens = (prog); \ assert(SvTYPE(_rx_nparens) == SVt_REGEXP); \ &SvANY(_rx_nparens)->nparens; \ })) #else # define RX_EXTFLAGS(prog) RXp_EXTFLAGS((struct regexp *)SvANY(prog)) # define RX_ENGINE(prog) (((struct regexp *)SvANY(prog))->engine) # define RX_SUBBEG(prog) (((struct regexp *)SvANY(prog))->subbeg) # define RX_OFFS(prog) (((struct regexp *)SvANY(prog))->offs) # define RX_NPARENS(prog) (((struct regexp *)SvANY(prog))->nparens) #endif #define RX_SUBLEN(prog) (((struct regexp *)SvANY(prog))->sublen) #define RX_MINLEN(prog) (((struct regexp *)SvANY(prog))->minlen) #define RX_MINLENRET(prog) (((struct regexp *)SvANY(prog))->minlenret) #define RX_GOFS(prog) (((struct regexp *)SvANY(prog))->gofs) #define RX_LASTPAREN(prog) (((struct regexp *)SvANY(prog))->lastparen) #define RX_LASTCLOSEPAREN(prog) (((struct regexp *)SvANY(prog))->lastcloseparen) #define RX_SEEN_EVALS(prog) (((struct regexp *)SvANY(prog))->seen_evals) #define RX_SAVED_COPY(prog) (((struct regexp *)SvANY(prog))->saved_copy) #endif /* PLUGGABLE_RE_EXTENSION */ /* Stuff that needs to be included in the pluggable extension goes below here */ #ifdef PERL_OLD_COPY_ON_WRITE #define RX_MATCH_COPY_FREE(rx) \ STMT_START {if (RX_SAVED_COPY(rx)) { \ SV_CHECK_THINKFIRST_COW_DROP(RX_SAVED_COPY(rx)); \ } \ if (RX_MATCH_COPIED(rx)) { \ Safefree(RX_SUBBEG(rx)); \ RX_MATCH_COPIED_off(rx); \ }} STMT_END #else #define RX_MATCH_COPY_FREE(rx) \ STMT_START {if (RX_MATCH_COPIED(rx)) { \ Safefree(RX_SUBBEG(rx)); \ RX_MATCH_COPIED_off(rx); \ }} STMT_END #endif #define RXp_MATCH_UTF8(prog) (RXp_EXTFLAGS(prog) & RXf_MATCH_UTF8) #define RX_MATCH_UTF8(prog) (RX_EXTFLAGS(prog) & RXf_MATCH_UTF8) #define RX_MATCH_UTF8_on(prog) (RX_EXTFLAGS(prog) |= RXf_MATCH_UTF8) #define RX_MATCH_UTF8_off(prog) (RX_EXTFLAGS(prog) &= ~RXf_MATCH_UTF8) #define RX_MATCH_UTF8_set(prog, t) ((t) \ ? (RX_MATCH_UTF8_on(prog), (PL_reg_match_utf8 = 1)) \ : (RX_MATCH_UTF8_off(prog), (PL_reg_match_utf8 = 0))) /* Whether the pattern stored at RX_WRAPPED is in UTF-8 */ #define RX_UTF8(prog) SvUTF8(prog) #define REXEC_COPY_STR 0x01 /* Need to copy the string. */ #define REXEC_CHECKED 0x02 /* check_substr already checked. */ #define REXEC_SCREAM 0x04 /* use scream table. */ #define REXEC_IGNOREPOS 0x08 /* \G matches at start. */ #define REXEC_NOT_FIRST 0x10 /* This is another iteration of //g. */ #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define ReREFCNT_inc(re) \ ({ \ /* This is here to generate a casting warning if incorrect. */ \ REGEXP *const _rerefcnt_inc = (re); \ assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP); \ SvREFCNT_inc(_rerefcnt_inc); \ _rerefcnt_inc; \ }) # define ReREFCNT_dec(re) \ ({ \ /* This is here to generate a casting warning if incorrect. */ \ REGEXP *const _rerefcnt_dec = (re); \ SvREFCNT_dec(_rerefcnt_dec); \ }) #else # define ReREFCNT_dec(re) SvREFCNT_dec(re) # define ReREFCNT_inc(re) ((REGEXP *) SvREFCNT_inc(re)) #endif /* FIXME for plugins. */ #define FBMcf_TAIL_DOLLAR 1 #define FBMcf_TAIL_DOLLARM 2 #define FBMcf_TAIL_Z 4 #define FBMcf_TAIL_z 8 #define FBMcf_TAIL (FBMcf_TAIL_DOLLAR|FBMcf_TAIL_DOLLARM|FBMcf_TAIL_Z|FBMcf_TAIL_z) #define FBMrf_MULTILINE 1 /* some basic information about the current match that is created by * Perl_regexec_flags and then passed to regtry(), regmatch() etc */ typedef struct { REGEXP *prog; char *bol; char *till; SV *sv; char *ganch; char *cutpoint; } regmatch_info; /* structures for holding and saving the state maintained by regmatch() */ #ifndef MAX_RECURSE_EVAL_NOCHANGE_DEPTH #define MAX_RECURSE_EVAL_NOCHANGE_DEPTH 1000 #endif typedef I32 CHECKPOINT; typedef struct regmatch_state { int resume_state; /* where to jump to on return */ char *locinput; /* where to backtrack in string on failure */ union { /* this is a fake union member that matches the first element * of each member that needs to store positive backtrack * information */ struct { struct regmatch_state *prev_yes_state; } yes; /* branchlike members */ /* this is a fake union member that matches the first elements * of each member that needs to behave like a branch */ struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; U32 lastparen; CHECKPOINT cp; } branchlike; struct { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; CHECKPOINT cp; regnode *next_branch; /* next branch node */ } branch; struct { /* the first elements must match u.branchlike */ struct regmatch_state *prev_yes_state; U32 lastparen; CHECKPOINT cp; U32 accepted; /* how many accepting states left */ U16 *jump; /* positive offsets from me */ regnode *B; /* node following the trie */ regnode *me; /* Which node am I - needed for jump tries*/ U8 *firstpos;/* pos in string of first trie match */ U32 firstchars;/* len in chars of firstpos from start */ U16 nextword;/* next word to try */ U16 topword; /* longest accepted word */ bool longfold;/* saw a fold with a 1->n char mapping */ } trie; /* special types - these members are used to store state for special regops like eval, if/then, lookaround and the markpoint state */ struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; struct regmatch_state *prev_eval; struct regmatch_state *prev_curlyx; REGEXP *prev_rex; U32 toggle_reg_flags; /* what bits in PL_reg_flags to flip when transitioning between inner and outer rexen */ CHECKPOINT cp; /* remember current savestack indexes */ CHECKPOINT lastcp; U32 close_paren; /* which close bracket is our end */ regnode *B; /* the node following us */ } eval; struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; I32 wanted; I32 logical; /* saved copy of 'logical' var */ regnode *me; /* the IFMATCH/SUSPEND/UNLESSM node */ } ifmatch; /* and SUSPEND/UNLESSM */ struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; struct regmatch_state *prev_mark; SV* mark_name; char *mark_loc; } mark; struct { int val; } keeper; /* quantifiers - these members are used for storing state for for the regops used to implement quantifiers */ struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; struct regmatch_state *prev_curlyx; /* previous cur_curlyx */ regnode *me; /* the CURLYX node */ regnode *B; /* the B node in /A*B/ */ CHECKPOINT cp; /* remember current savestack index */ bool minmod; int parenfloor;/* how far back to strip paren data */ /* these two are modified by WHILEM */ int count; /* how many instances of A we've matched */ char *lastloc;/* where previous A matched (0-len detect) */ } curlyx; struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; struct regmatch_state *save_curlyx; CHECKPOINT cp; /* remember current savestack indexes */ CHECKPOINT lastcp; char *save_lastloc; /* previous curlyx.lastloc */ I32 cache_offset; I32 cache_mask; } whilem; struct { /* this first element must match u.yes */ struct regmatch_state *prev_yes_state; I32 c1, c2; /* case fold search */ CHECKPOINT cp; I32 alen; /* length of first-matched A string */ I32 count; bool minmod; regnode *A, *B; /* the nodes corresponding to /A*B/ */ regnode *me; /* the curlym node */ } curlym; struct { U32 paren; CHECKPOINT cp; I32 c1, c2; /* case fold search */ char *maxpos; /* highest possible point in string to match */ char *oldloc; /* the previous locinput */ int count; int min, max; /* {m,n} */ regnode *A, *B; /* the nodes corresponding to /A*B/ */ } curly; /* and CURLYN/PLUS/STAR */ } u; } regmatch_state; /* how many regmatch_state structs to allocate as a single slab. * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev * pointers, plus 1 for any mythical malloc overhead. */ #define PERL_REGMATCH_SLAB_SLOTS \ ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state)) typedef struct regmatch_slab { regmatch_state states[PERL_REGMATCH_SLAB_SLOTS]; struct regmatch_slab *prev, *next; } regmatch_slab; #define PL_reg_flags PL_reg_state.re_state_reg_flags #define PL_bostr PL_reg_state.re_state_bostr #define PL_reginput PL_reg_state.re_state_reginput #define PL_regeol PL_reg_state.re_state_regeol #define PL_regoffs PL_reg_state.re_state_regoffs #define PL_reglastparen PL_reg_state.re_state_reglastparen #define PL_reglastcloseparen PL_reg_state.re_state_reglastcloseparen #define PL_reg_start_tmp PL_reg_state.re_state_reg_start_tmp #define PL_reg_start_tmpl PL_reg_state.re_state_reg_start_tmpl #define PL_reg_eval_set PL_reg_state.re_state_reg_eval_set #define PL_reg_match_utf8 PL_reg_state.re_state_reg_match_utf8 #define PL_reg_magic PL_reg_state.re_state_reg_magic #define PL_reg_oldpos PL_reg_state.re_state_reg_oldpos #define PL_reg_oldcurpm PL_reg_state.re_state_reg_oldcurpm #define PL_reg_curpm PL_reg_state.re_state_reg_curpm #define PL_reg_oldsaved PL_reg_state.re_state_reg_oldsaved #define PL_reg_oldsavedlen PL_reg_state.re_state_reg_oldsavedlen #define PL_reg_maxiter PL_reg_state.re_state_reg_maxiter #define PL_reg_leftiter PL_reg_state.re_state_reg_leftiter #define PL_reg_poscache PL_reg_state.re_state_reg_poscache #define PL_reg_poscache_size PL_reg_state.re_state_reg_poscache_size #define PL_regsize PL_reg_state.re_state_regsize #define PL_reg_starttry PL_reg_state.re_state_reg_starttry #define PL_nrs PL_reg_state.re_state_nrs struct re_save_state { U32 re_state_reg_flags; /* from regexec.c */ U32 re_state_reg_start_tmpl; /* from regexec.c */ I32 re_state_reg_eval_set; /* from regexec.c */ bool re_state_reg_match_utf8; /* from regexec.c */ char *re_state_bostr; char *re_state_reginput; /* String-input pointer. */ char *re_state_regeol; /* End of input, for $ check. */ regexp_paren_pair *re_state_regoffs; /* Pointer to start/end pairs */ U32 *re_state_reglastparen; /* Similarly for lastparen. */ U32 *re_state_reglastcloseparen; /* Similarly for lastcloseparen. */ char **re_state_reg_start_tmp; /* from regexec.c */ MAGIC *re_state_reg_magic; /* from regexec.c */ PMOP *re_state_reg_oldcurpm; /* from regexec.c */ PMOP *re_state_reg_curpm; /* from regexec.c */ char *re_state_reg_oldsaved; /* old saved substr during match */ STRLEN re_state_reg_oldsavedlen; /* old length of saved substr during match */ STRLEN re_state_reg_poscache_size; /* size of pos cache of WHILEM */ I32 re_state_reg_oldpos; /* from regexec.c */ I32 re_state_reg_maxiter; /* max wait until caching pos */ I32 re_state_reg_leftiter; /* wait until caching pos */ U32 re_state_regsize; /* from regexec.c */ char *re_state_reg_poscache; /* cache of pos of WHILEM */ char *re_state_reg_starttry; /* from regexec.c */ #ifdef PERL_OLD_COPY_ON_WRITE SV *re_state_nrs; /* was placeholder: unused since 5.8.0 (5.7.2 patch #12027 for bug ID 20010815.012). Used to save rx->saved_copy */ #endif }; #define SAVESTACK_ALLOC_FOR_RE_SAVE_STATE \ (1 + ((sizeof(struct re_save_state) - 1) / sizeof(*PL_savestack))) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZtime64.hnuW+A#include #include "time64_config.h" #ifndef TIME64_H # define TIME64_H /* Set our custom types */ typedef INT_64_T Int64; typedef Int64 Time64_T; typedef I32 Year; /* A copy of the tm struct but with a 64 bit year */ struct TM64 { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; Year tm_year; int tm_wday; int tm_yday; int tm_isdst; #ifdef HAS_TM_TM_GMTOFF long tm_gmtoff; #endif #ifdef HAS_TM_TM_ZONE # ifdef __GLIBC__ const char *tm_zone; # else char *tm_zone; # endif #endif }; /* Decide which tm struct to use */ #ifdef USE_TM64 #define TM TM64 #else #define TM tm #endif /* Declare functions */ static struct TM *S_gmtime64_r (const Time64_T *, struct TM *); static struct TM *S_localtime64_r (const Time64_T *, struct TM *); static Time64_T S_timegm64 (struct TM *); /* Not everyone has gm/localtime_r(), provide a replacement */ #ifdef HAS_LOCALTIME_R # define LOCALTIME_R(clock, result) (L_R_TZSET localtime_r(clock, result)) #else # define LOCALTIME_R(clock, result) (L_R_TZSET S_localtime_r(clock, result)) #endif #ifdef HAS_GMTIME_R # define GMTIME_R(clock, result) gmtime_r(clock, result) #else # define GMTIME_R(clock, result) S_gmtime_r(clock, result) #endif #endif PKZY`!!sv.hnuW+A/* sv.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #ifdef sv_flags #undef sv_flags /* Convex has this in for sigvec() */ #endif /* =head1 SV Flags =for apidoc AmU||svtype An enum of flags for Perl types. These are found in the file B in the C enum. Test these flags with the C macro. =for apidoc AmU||SVt_PV Pointer type flag for scalars. See C. =for apidoc AmU||SVt_IV Integer type flag for scalars. See C. =for apidoc AmU||SVt_NV Double type flag for scalars. See C. =for apidoc AmU||SVt_PVMG Type flag for blessed scalars. See C. =for apidoc AmU||SVt_PVAV Type flag for arrays. See C. =for apidoc AmU||SVt_PVHV Type flag for hashes. See C. =for apidoc AmU||SVt_PVCV Type flag for code refs. See C. =cut */ typedef enum { SVt_NULL, /* 0 */ SVt_BIND, /* 1 */ SVt_IV, /* 2 */ SVt_NV, /* 3 */ /* RV was here, before it was merged with IV. */ SVt_PV, /* 4 */ SVt_PVIV, /* 5 */ SVt_PVNV, /* 6 */ SVt_PVMG, /* 7 */ SVt_REGEXP, /* 8 */ /* PVBM was here, before BIND replaced it. */ SVt_PVGV, /* 9 */ SVt_PVLV, /* 10 */ SVt_PVAV, /* 11 */ SVt_PVHV, /* 12 */ SVt_PVCV, /* 13 */ SVt_PVFM, /* 14 */ SVt_PVIO, /* 15 */ SVt_LAST /* keep last in enum. used to size arrays */ } svtype; /* *** any alterations to the SV types above need to be reflected in * SVt_MASK and the various PL_valid_types_* tables */ #define SVt_MASK 0xf /* smallest bitmask that covers all types */ #ifndef PERL_CORE /* Although Fast Boyer Moore tables are now being stored in PVGVs, for most purposes eternal code wanting to consider PVBM probably needs to think of PVMG instead. */ # define SVt_PVBM SVt_PVMG /* Anything wanting to create a reference from clean should ensure that it has a scalar of type SVt_IV now: */ # define SVt_RV SVt_IV #endif /* There is collusion here with sv_clear - sv_clear exits early for SVt_NULL so never reaches the clause at the end that uses sv_type_details->body_size to determine whether to call safefree(). Hence body_size can be set non-zero to record the size of HEs, without fear of bogus frees. */ #if defined(PERL_IN_HV_C) || defined(PERL_IN_XS_APITEST) #define HE_SVSLOT SVt_NULL #endif #define PERL_ARENA_ROOTS_SIZE (SVt_LAST) /* typedefs to eliminate some typing */ typedef struct he HE; typedef struct hek HEK; /* Using C's structural equivalence to help emulate C++ inheritance here... */ /* start with 2 sv-head building blocks */ #define _SV_HEAD(ptrtype) \ ptrtype sv_any; /* pointer to body */ \ U32 sv_refcnt; /* how many references to us */ \ U32 sv_flags /* what we are */ #define _SV_HEAD_UNION \ union { \ char* svu_pv; /* pointer to malloced string */ \ IV svu_iv; \ UV svu_uv; \ SV* svu_rv; /* pointer to another SV */ \ SV** svu_array; \ HE** svu_hash; \ GP* svu_gp; \ PerlIO *svu_fp; \ } sv_u struct STRUCT_SV { /* struct sv { */ _SV_HEAD(void*); _SV_HEAD_UNION; #ifdef DEBUG_LEAKING_SCALARS PERL_BITFIELD32 sv_debug_optype:9; /* the type of OP that allocated us */ PERL_BITFIELD32 sv_debug_inpad:1; /* was allocated in a pad for an OP */ PERL_BITFIELD32 sv_debug_line:16; /* the line where we were allocated */ UV sv_debug_serial; /* serial number of sv allocation */ char * sv_debug_file; /* the file where we were allocated */ SV * sv_debug_parent; /* what we were cloned from (ithreads)*/ #endif }; struct gv { _SV_HEAD(XPVGV*); /* pointer to xpvgv body */ _SV_HEAD_UNION; }; struct cv { _SV_HEAD(XPVCV*); /* pointer to xpvcv body */ _SV_HEAD_UNION; }; struct av { _SV_HEAD(XPVAV*); /* pointer to xpvav body */ _SV_HEAD_UNION; }; struct hv { _SV_HEAD(XPVHV*); /* pointer to xpvhv body */ _SV_HEAD_UNION; }; struct io { _SV_HEAD(XPVIO*); /* pointer to xpvio body */ _SV_HEAD_UNION; }; struct p5rx { _SV_HEAD(struct regexp*); /* pointer to regexp body */ _SV_HEAD_UNION; }; #undef _SV_HEAD #undef _SV_HEAD_UNION /* ensure no pollution */ /* =head1 SV Manipulation Functions =for apidoc Am|U32|SvREFCNT|SV* sv Returns the value of the object's reference count. =for apidoc Am|SV*|SvREFCNT_inc|SV* sv Increments the reference count of the given SV. All of the following SvREFCNT_inc* macros are optimized versions of SvREFCNT_inc, and can be replaced with SvREFCNT_inc. =for apidoc Am|SV*|SvREFCNT_inc_NN|SV* sv Same as SvREFCNT_inc, but can only be used if you know I is not NULL. Since we don't have to check the NULLness, it's faster and smaller. =for apidoc Am|void|SvREFCNT_inc_void|SV* sv Same as SvREFCNT_inc, but can only be used if you don't need the return value. The macro doesn't need to return a meaningful value. =for apidoc Am|void|SvREFCNT_inc_void_NN|SV* sv Same as SvREFCNT_inc, but can only be used if you don't need the return value, and you know that I is not NULL. The macro doesn't need to return a meaningful value, or check for NULLness, so it's smaller and faster. =for apidoc Am|SV*|SvREFCNT_inc_simple|SV* sv Same as SvREFCNT_inc, but can only be used with expressions without side effects. Since we don't have to store a temporary value, it's faster. =for apidoc Am|SV*|SvREFCNT_inc_simple_NN|SV* sv Same as SvREFCNT_inc_simple, but can only be used if you know I is not NULL. Since we don't have to check the NULLness, it's faster and smaller. =for apidoc Am|void|SvREFCNT_inc_simple_void|SV* sv Same as SvREFCNT_inc_simple, but can only be used if you don't need the return value. The macro doesn't need to return a meaningful value. =for apidoc Am|void|SvREFCNT_inc_simple_void_NN|SV* sv Same as SvREFCNT_inc, but can only be used if you don't need the return value, and you know that I is not NULL. The macro doesn't need to return a meaningful value, or check for NULLness, so it's smaller and faster. =for apidoc Am|void|SvREFCNT_dec|SV* sv Decrements the reference count of the given SV. =for apidoc Am|svtype|SvTYPE|SV* sv Returns the type of the SV. See C. =for apidoc Am|void|SvUPGRADE|SV* sv|svtype type Used to upgrade an SV to a more complex form. Uses C to perform the upgrade if necessary. See C. =cut */ #define SvANY(sv) (sv)->sv_any #define SvFLAGS(sv) (sv)->sv_flags #define SvREFCNT(sv) (sv)->sv_refcnt #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvREFCNT_inc(sv) \ ({ \ SV * const _sv = MUTABLE_SV(sv); \ if (_sv) \ (SvREFCNT(_sv))++; \ _sv; \ }) # define SvREFCNT_inc_simple(sv) \ ({ \ if (sv) \ (SvREFCNT(sv))++; \ MUTABLE_SV(sv); \ }) # define SvREFCNT_inc_NN(sv) \ ({ \ SV * const _sv = MUTABLE_SV(sv); \ SvREFCNT(_sv)++; \ _sv; \ }) # define SvREFCNT_inc_void(sv) \ ({ \ SV * const _sv = MUTABLE_SV(sv); \ if (_sv) \ (void)(SvREFCNT(_sv)++); \ }) #else # define SvREFCNT_inc(sv) \ ((PL_Sv=MUTABLE_SV(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) # define SvREFCNT_inc_simple(sv) \ ((sv) ? (SvREFCNT(sv)++,MUTABLE_SV(sv)) : NULL) # define SvREFCNT_inc_NN(sv) \ (PL_Sv=MUTABLE_SV(sv),++(SvREFCNT(PL_Sv)),PL_Sv) # define SvREFCNT_inc_void(sv) \ (void)((PL_Sv=MUTABLE_SV(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) #endif /* These guys don't need the curly blocks */ #define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END #define SvREFCNT_inc_simple_NN(sv) (++(SvREFCNT(sv)),MUTABLE_SV(sv)) #define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) #define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT(MUTABLE_SV(sv))) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvREFCNT_dec(sv) \ ({ \ SV * const _sv = MUTABLE_SV(sv); \ if (_sv) { \ if (SvREFCNT(_sv)) { \ if (--(SvREFCNT(_sv)) == 0) \ Perl_sv_free2(aTHX_ _sv); \ } else { \ sv_free(_sv); \ } \ } \ }) #else #define SvREFCNT_dec(sv) sv_free(MUTABLE_SV(sv)) #endif #define SVTYPEMASK 0xff #define SvTYPE(sv) ((svtype)((sv)->sv_flags & SVTYPEMASK)) /* Sadly there are some parts of the core that have pointers to already-freed SV heads, and rely on being able to tell that they are now free. So mark them all by using a consistent macro. */ #define SvIS_FREED(sv) ((sv)->sv_flags == SVTYPEMASK) #define SvUPGRADE(sv, mt) (SvTYPE(sv) >= (mt) || (sv_upgrade(sv, mt), 1)) #define SVf_IOK 0x00000100 /* has valid public integer value */ #define SVf_NOK 0x00000200 /* has valid public numeric value */ #define SVf_POK 0x00000400 /* has valid public pointer value */ #define SVf_ROK 0x00000800 /* has a valid reference pointer */ #define SVp_IOK 0x00001000 /* has valid non-public integer value */ #define SVp_NOK 0x00002000 /* has valid non-public numeric value */ #define SVp_POK 0x00004000 /* has valid non-public pointer value */ #define SVp_SCREAM 0x00008000 /* has been studied? */ #define SVphv_CLONEABLE SVp_SCREAM /* PVHV (stashes) clone its objects */ #define SVpgv_GP SVp_SCREAM /* GV has a valid GP */ #define SVprv_PCS_IMPORTED SVp_SCREAM /* RV is a proxy for a constant subroutine in another package. Set the CvIMPORTED_CV_ON() if it needs to be expanded to a real GV */ /* 0x00010000 *** FREE SLOT */ #define SVs_PADTMP 0x00020000 /* in use as tmp; only if ! SVs_PADMY */ #define SVs_PADSTALE 0x00020000 /* lexical has gone out of scope; only valid for SVs_PADMY */ #define SVpad_TYPED 0x00020000 /* pad name is a Typed Lexical */ #define SVs_PADMY 0x00040000 /* in use a "my" variable */ #define SVpad_OUR 0x00040000 /* pad name is "our" instead of "my" */ #define SVs_TEMP 0x00080000 /* string is stealable? */ #define SVs_OBJECT 0x00100000 /* is "blessed" */ #define SVs_GMG 0x00200000 /* has magical get method */ #define SVs_SMG 0x00400000 /* has magical set method */ #define SVs_RMG 0x00800000 /* has random magical methods */ #define SVf_FAKE 0x01000000 /* 0: glob is just a copy 1: SV head arena wasn't malloc()ed 2: in conjunction with SVf_READONLY marks a shared hash key scalar (SvLEN == 0) or a copy on write string (SvLEN != 0) [SvIsCOW(sv)] 3: For PVCV, whether CvUNIQUE(cv) refers to an eval or once only [CvEVAL(cv), CvSPECIAL(cv)] 4: On a pad name SV, that slot in the frame AV is a REFCNT'ed reference to a lexical from "outside". */ #define SVphv_REHASH SVf_FAKE /* 5: On a PVHV, hash values are being recalculated */ #define SVf_OOK 0x02000000 /* has valid offset value. For a PVHV this means that a hv_aux struct is present after the main array */ #define SVf_BREAK 0x04000000 /* refcnt is artificially low - used by SVs in final arena cleanup. Set in S_regtry on PL_reg_curpm, so that perl_destruct will skip it. */ #define SVf_READONLY 0x08000000 /* may not be modified */ #define SVf_THINKFIRST (SVf_READONLY|SVf_ROK|SVf_FAKE) #define SVf_OK (SVf_IOK|SVf_NOK|SVf_POK|SVf_ROK| \ SVp_IOK|SVp_NOK|SVp_POK|SVpgv_GP) #define PRIVSHIFT 4 /* (SVp_?OK >> PRIVSHIFT) == SVf_?OK */ #define SVf_AMAGIC 0x10000000 /* has magical overloaded methods */ /* Ensure this value does not clash with the GV_ADD* flags in gv.h: */ #define SVf_UTF8 0x20000000 /* SvPV is UTF-8 encoded This is also set on RVs whose overloaded stringification is UTF-8. This might only happen as a side effect of SvPV() */ /* Some private flags. */ /* PVAV could probably use 0x2000000 without conflict. I assume that PVFM can be UTF-8 encoded, and PVCVs could well have UTF-8 prototypes. PVIOs haven't been restructured, so sometimes get used as string buffers. */ /* PVHV */ #define SVphv_SHAREKEYS 0x20000000 /* PVHV keys live on shared string table */ /* PVNV, PVMG only, and only used in pads. Should be safe to test on any scalar SV, as the core is careful to avoid setting both. SVf_POK, SVp_POK also set: 0x00004400 Normal 0x0000C400 Studied (SvSCREAM) 0x40004400 FBM compiled (SvVALID) 0x4000C400 pad name. 0x00008000 GV with GP 0x00008800 RV with PCS imported */ #define SVpad_NAME (SVp_SCREAM|SVpbm_VALID) /* This SV is a name in the PAD, so SVpad_TYPED, SVpad_OUR and SVpad_STATE apply */ /* PVAV */ #define SVpav_REAL 0x40000000 /* free old entries */ /* PVHV */ #define SVphv_LAZYDEL 0x40000000 /* entry in xhv_eiter must be deleted */ /* This is only set true on a PVGV when it's playing "PVBM", but is tested for on any regular scalar (anything <= PVLV) */ #define SVpbm_VALID 0x40000000 /* Only used in toke.c on an SV stored in PL_lex_repl */ #define SVrepl_EVAL 0x40000000 /* Replacement part of s///e */ /* IV, PVIV, PVNV, PVMG, PVGV and (I assume) PVLV */ #define SVf_IVisUV 0x80000000 /* use XPVUV instead of XPVIV */ /* PVAV */ #define SVpav_REIFY 0x80000000 /* can become real */ /* PVHV */ #define SVphv_HASKFLAGS 0x80000000 /* keys have flag byte after hash */ /* PVGV when SVpbm_VALID is true */ #define SVpbm_TAIL 0x80000000 /* RV upwards. However, SVf_ROK and SVp_IOK are exclusive */ #define SVprv_WEAKREF 0x80000000 /* Weak reference */ /* pad name vars only */ #define SVpad_STATE 0x80000000 /* pad name is a "state" var */ #define _XPV_HEAD \ HV* xmg_stash; /* class package */ \ union _xmgu xmg_u; \ STRLEN xpv_cur; /* length of svu_pv as a C string */ \ STRLEN xpv_len /* allocated size */ union _xnvu { NV xnv_nv; /* numeric value, if any */ HV * xgv_stash; struct { U32 xlow; U32 xhigh; } xpad_cop_seq; /* used by pad.c for cop_sequence */ struct { I32 xbm_useful; U8 xbm_rare; /* rarest character in string */ } xbm_s; /* fields from PVBM */ }; union _xivu { IV xivu_iv; /* integer value */ UV xivu_uv; HEK * xivu_namehek; /* xpvlv, xpvgv: GvNAME */ }; union _xmgu { MAGIC* xmg_magic; /* linked list of magicalness */ HV* xmg_ourstash; /* Stash for our (when SvPAD_OUR is true) */ STRLEN xmg_hash_index; /* used while freeing hash entries */ }; struct xpv { _XPV_HEAD; }; struct xpviv { _XPV_HEAD; union _xivu xiv_u; }; #define xiv_iv xiv_u.xivu_iv struct xpvuv { _XPV_HEAD; union _xivu xuv_u; }; #define xuv_uv xuv_u.xivu_uv struct xpvnv { _XPV_HEAD; union _xivu xiv_u; union _xnvu xnv_u; }; /* This structure must match the beginning of struct xpvhv in hv.h. */ struct xpvmg { _XPV_HEAD; union _xivu xiv_u; union _xnvu xnv_u; }; struct xpvlv { _XPV_HEAD; union _xivu xiv_u; union _xnvu xnv_u; STRLEN xlv_targoff; STRLEN xlv_targlen; SV* xlv_targ; char xlv_type; /* k=keys .=pos x=substr v=vec /=join/re * y=alem/helem/iter t=tie T=tied HE */ char xlv_flags; /* 1 = negative offset 2 = negative len */ }; /* This structure works in 3 ways - regular scalar, GV with GP, or fast Boyer-Moore. */ struct xpvgv { _XPV_HEAD; union _xivu xiv_u; union _xnvu xnv_u; }; /* This structure must match XPVCV in cv.h */ typedef U16 cv_flags_t; #define _XPVCV_COMMON \ HV * xcv_stash; \ union { \ OP * xcv_start; \ ANY xcv_xsubany; \ } xcv_start_u; \ union { \ OP * xcv_root; \ void (*xcv_xsub) (pTHX_ CV*); \ } xcv_root_u; \ GV * xcv_gv; \ char * xcv_file; \ AV * xcv_padlist; \ CV * xcv_outside; \ U32 xcv_outside_seq; /* the COP sequence (at the point of our \ * compilation) in the lexically enclosing \ * sub */ \ cv_flags_t xcv_flags struct xpvfm { _XPV_HEAD; _XPVCV_COMMON; IV xfm_lines; }; struct xpvio { _XPV_HEAD; union _xivu xiv_u; /* ifp and ofp are normally the same, but sockets need separate streams */ PerlIO * xio_ofp; /* Cray addresses everything by word boundaries (64 bits) and * code and data pointers cannot be mixed (which is exactly what * Perl_filter_add() tries to do with the dirp), hence the * following union trick (as suggested by Gurusamy Sarathy). * For further information see Geir Johansen's problem report * titled [ID 20000612.002] Perl problem on Cray system * The any pointer (known as IoANY()) will also be a good place * to hang any IO disciplines to. */ union { DIR * xiou_dirp; /* for opendir, readdir, etc */ void * xiou_any; /* for alignment */ } xio_dirpu; /* IV xio_lines is now in IVX $. */ IV xio_page; /* $% */ IV xio_page_len; /* $= */ IV xio_lines_left; /* $- */ char * xio_top_name; /* $^ */ GV * xio_top_gv; /* $^ */ char * xio_fmt_name; /* $~ */ GV * xio_fmt_gv; /* $~ */ char * xio_bottom_name;/* $^B */ GV * xio_bottom_gv; /* $^B */ char xio_type; U8 xio_flags; }; #define xio_dirp xio_dirpu.xiou_dirp #define xio_any xio_dirpu.xiou_any #define IOf_ARGV 1 /* this fp iterates over ARGV */ #define IOf_START 2 /* check for null ARGV and substitute '-' */ #define IOf_FLUSH 4 /* this fp wants a flush after write op */ #define IOf_DIDTOP 8 /* just did top of form */ #define IOf_UNTAINT 16 /* consider this fp (and its data) "safe" */ #define IOf_NOLINE 32 /* slurped a pseudo-line from empty file */ #define IOf_FAKE_DIRP 64 /* xio_dirp is fake (source filters kludge) Also, when this is set, SvPVX() is valid */ /* The following macros define implementation-independent predicates on SVs. */ /* =for apidoc Am|U32|SvNIOK|SV* sv Returns a U32 value indicating whether the SV contains a number, integer or double. =for apidoc Am|U32|SvNIOKp|SV* sv Returns a U32 value indicating whether the SV contains a number, integer or double. Checks the B setting. Use C instead. =for apidoc Am|void|SvNIOK_off|SV* sv Unsets the NV/IV status of an SV. =for apidoc Am|U32|SvOK|SV* sv Returns a U32 value indicating whether the value is defined. This is only meaningful for scalars. =for apidoc Am|U32|SvIOKp|SV* sv Returns a U32 value indicating whether the SV contains an integer. Checks the B setting. Use C instead. =for apidoc Am|U32|SvNOKp|SV* sv Returns a U32 value indicating whether the SV contains a double. Checks the B setting. Use C instead. =for apidoc Am|U32|SvPOKp|SV* sv Returns a U32 value indicating whether the SV contains a character string. Checks the B setting. Use C instead. =for apidoc Am|U32|SvIOK|SV* sv Returns a U32 value indicating whether the SV contains an integer. =for apidoc Am|void|SvIOK_on|SV* sv Tells an SV that it is an integer. =for apidoc Am|void|SvIOK_off|SV* sv Unsets the IV status of an SV. =for apidoc Am|void|SvIOK_only|SV* sv Tells an SV that it is an integer and disables all other OK bits. =for apidoc Am|void|SvIOK_only_UV|SV* sv Tells and SV that it is an unsigned integer and disables all other OK bits. =for apidoc Am|bool|SvIOK_UV|SV* sv Returns a boolean indicating whether the SV contains an unsigned integer. =for apidoc Am|bool|SvUOK|SV* sv Returns a boolean indicating whether the SV contains an unsigned integer. =for apidoc Am|bool|SvIOK_notUV|SV* sv Returns a boolean indicating whether the SV contains a signed integer. =for apidoc Am|U32|SvNOK|SV* sv Returns a U32 value indicating whether the SV contains a double. =for apidoc Am|void|SvNOK_on|SV* sv Tells an SV that it is a double. =for apidoc Am|void|SvNOK_off|SV* sv Unsets the NV status of an SV. =for apidoc Am|void|SvNOK_only|SV* sv Tells an SV that it is a double and disables all other OK bits. =for apidoc Am|U32|SvPOK|SV* sv Returns a U32 value indicating whether the SV contains a character string. =for apidoc Am|void|SvPOK_on|SV* sv Tells an SV that it is a string. =for apidoc Am|void|SvPOK_off|SV* sv Unsets the PV status of an SV. =for apidoc Am|void|SvPOK_only|SV* sv Tells an SV that it is a string and disables all other OK bits. Will also turn off the UTF-8 status. =for apidoc Am|bool|SvVOK|SV* sv Returns a boolean indicating whether the SV contains a v-string. =for apidoc Am|U32|SvOOK|SV* sv Returns a U32 indicating whether the pointer to the string buffer is offset. This hack is used internally to speed up removal of characters from the beginning of a SvPV. When SvOOK is true, then the start of the allocated string buffer is actually C bytes before SvPVX. This offset used to be stored in SvIVX, but is now stored within the spare part of the buffer. =for apidoc Am|U32|SvROK|SV* sv Tests if the SV is an RV. =for apidoc Am|void|SvROK_on|SV* sv Tells an SV that it is an RV. =for apidoc Am|void|SvROK_off|SV* sv Unsets the RV status of an SV. =for apidoc Am|SV*|SvRV|SV* sv Dereferences an RV to return the SV. =for apidoc Am|IV|SvIVX|SV* sv Returns the raw value in the SV's IV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. =for apidoc Am|UV|SvUVX|SV* sv Returns the raw value in the SV's UV slot, without checks or conversions. Only use when you are sure SvIOK is true. See also C. =for apidoc Am|NV|SvNVX|SV* sv Returns the raw value in the SV's NV slot, without checks or conversions. Only use when you are sure SvNOK is true. See also C. =for apidoc Am|char*|SvPVX|SV* sv Returns a pointer to the physical string in the SV. The SV must contain a string. This is also used to store the name of an autoloaded subroutine in an XS AUTOLOAD routine. See L. =for apidoc Am|STRLEN|SvCUR|SV* sv Returns the length of the string which is in the SV. See C. =for apidoc Am|STRLEN|SvLEN|SV* sv Returns the size of the string buffer in the SV, not including any part attributable to C. See C. =for apidoc Am|char*|SvEND|SV* sv Returns a pointer to the spot just after the last character in the string which is in the SV, where there is usually a trailing null (even though Perl scalars do not strictly require it). See C. Access the character as *(SvEND(sv)). Warning: If C is equal to C, then C points to unallocated memory. =for apidoc Am|HV*|SvSTASH|SV* sv Returns the stash of the SV. =for apidoc Am|void|SvIV_set|SV* sv|IV val Set the value of the IV pointer in sv to val. It is possible to perform the same function of this macro with an lvalue assignment to C. With future Perls, however, it will be more efficient to use C instead of the lvalue assignment to C. =for apidoc Am|void|SvNV_set|SV* sv|NV val Set the value of the NV pointer in sv to val. See C. =for apidoc Am|void|SvPV_set|SV* sv|char* val Set the value of the PV pointer in sv to val. See C. =for apidoc Am|void|SvUV_set|SV* sv|UV val Set the value of the UV pointer in sv to val. See C. =for apidoc Am|void|SvRV_set|SV* sv|SV* val Set the value of the RV pointer in sv to val. See C. =for apidoc Am|void|SvMAGIC_set|SV* sv|MAGIC* val Set the value of the MAGIC pointer in sv to val. See C. =for apidoc Am|void|SvSTASH_set|SV* sv|HV* val Set the value of the STASH pointer in sv to val. See C. =for apidoc Am|void|SvCUR_set|SV* sv|STRLEN len Set the current length of the string which is in the SV. See C and C. =for apidoc Am|void|SvLEN_set|SV* sv|STRLEN len Set the actual length of the string which is in the SV. See C. =cut */ #define SvNIOK(sv) (SvFLAGS(sv) & (SVf_IOK|SVf_NOK)) #define SvNIOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK)) #define SvNIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK| \ SVp_IOK|SVp_NOK|SVf_IVisUV)) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) #define assert_not_ROK(sv) ({assert(!SvROK(sv) || !SvRV(sv));}), #define assert_not_glob(sv) ({assert(!isGV_with_GP(sv));}), #else #define assert_not_ROK(sv) #define assert_not_glob(sv) #endif #define SvOK(sv) ((SvTYPE(sv) == SVt_BIND) \ ? (SvFLAGS(SvRV(sv)) & SVf_OK) \ : (SvFLAGS(sv) & SVf_OK)) #define SvOK_off(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV|SVf_UTF8), \ SvOOK_off(sv)) #define SvOK_off_exc_UV(sv) (assert_not_ROK(sv) \ SvFLAGS(sv) &= ~(SVf_OK| \ SVf_UTF8), \ SvOOK_off(sv)) #define SvOKp(sv) (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) #define SvIOKp(sv) (SvFLAGS(sv) & SVp_IOK) #define SvIOKp_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ SvFLAGS(sv) |= SVp_IOK) #define SvNOKp(sv) (SvFLAGS(sv) & SVp_NOK) #define SvNOKp_on(sv) (assert_not_glob(sv) SvFLAGS(sv) |= SVp_NOK) #define SvPOKp(sv) (SvFLAGS(sv) & SVp_POK) #define SvPOKp_on(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) |= SVp_POK) #define SvIOK(sv) (SvFLAGS(sv) & SVf_IOK) #define SvIOK_on(sv) (assert_not_glob(sv) SvRELEASE_IVX_(sv) \ SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) #define SvIOK_off(sv) (SvFLAGS(sv) &= ~(SVf_IOK|SVp_IOK|SVf_IVisUV)) #define SvIOK_only(sv) (SvOK_off(sv), \ SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) #define SvIOK_only_UV(sv) (assert_not_glob(sv) SvOK_off_exc_UV(sv), \ SvFLAGS(sv) |= (SVf_IOK|SVp_IOK)) #define SvIOK_UV(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) \ == (SVf_IOK|SVf_IVisUV)) #define SvUOK(sv) SvIOK_UV(sv) #define SvIOK_notUV(sv) ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV)) \ == SVf_IOK) #define SvIsUV(sv) (SvFLAGS(sv) & SVf_IVisUV) #define SvIsUV_on(sv) (SvFLAGS(sv) |= SVf_IVisUV) #define SvIsUV_off(sv) (SvFLAGS(sv) &= ~SVf_IVisUV) #define SvNOK(sv) (SvFLAGS(sv) & SVf_NOK) #define SvNOK_on(sv) (assert_not_glob(sv) \ SvFLAGS(sv) |= (SVf_NOK|SVp_NOK)) #define SvNOK_off(sv) (SvFLAGS(sv) &= ~(SVf_NOK|SVp_NOK)) #define SvNOK_only(sv) (SvOK_off(sv), \ SvFLAGS(sv) |= (SVf_NOK|SVp_NOK)) /* =for apidoc Am|U32|SvUTF8|SV* sv Returns a U32 value indicating the UTF-8 status of an SV. If things are set-up properly, this indicates whether or not the SV contains UTF-8 encoded data. Call this after SvPV() in case any call to string overloading updates the internal flag. =for apidoc Am|void|SvUTF8_on|SV *sv Turn on the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. =for apidoc Am|void|SvUTF8_off|SV *sv Unsets the UTF-8 status of an SV (the data is not changed, just the flag). Do not use frivolously. =for apidoc Am|void|SvPOK_only_UTF8|SV* sv Tells an SV that it is a string and disables all other OK bits, and leaves the UTF-8 status as it was. =cut */ /* Ensure the return value of this macro does not clash with the GV_ADD* flags in gv.h: */ #define SvUTF8(sv) (SvFLAGS(sv) & SVf_UTF8) #define SvUTF8_on(sv) (SvFLAGS(sv) |= (SVf_UTF8)) #define SvUTF8_off(sv) (SvFLAGS(sv) &= ~(SVf_UTF8)) #define SvPOK(sv) (SvFLAGS(sv) & SVf_POK) #define SvPOK_on(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvPOK_off(sv) (SvFLAGS(sv) &= ~(SVf_POK|SVp_POK)) #define SvPOK_only(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV|SVf_UTF8), \ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvPOK_only_UTF8(sv) (assert_not_ROK(sv) assert_not_glob(sv) \ SvFLAGS(sv) &= ~(SVf_OK| \ SVf_IVisUV), \ SvFLAGS(sv) |= (SVf_POK|SVp_POK)) #define SvVOK(sv) (SvMAGICAL(sv) \ && mg_find(sv,PERL_MAGIC_vstring)) /* returns the vstring magic, if any */ #define SvVSTRING_mg(sv) (SvMAGICAL(sv) \ ? mg_find(sv,PERL_MAGIC_vstring) : NULL) #define SvOOK(sv) (SvFLAGS(sv) & SVf_OOK) #define SvOOK_on(sv) (SvFLAGS(sv) |= SVf_OOK) #define SvOOK_off(sv) ((void)(SvOOK(sv) && sv_backoff(sv))) #define SvFAKE(sv) (SvFLAGS(sv) & SVf_FAKE) #define SvFAKE_on(sv) (SvFLAGS(sv) |= SVf_FAKE) #define SvFAKE_off(sv) (SvFLAGS(sv) &= ~SVf_FAKE) #define SvROK(sv) (SvFLAGS(sv) & SVf_ROK) #define SvROK_on(sv) (SvFLAGS(sv) |= SVf_ROK) #define SvROK_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK)) #define SvMAGICAL(sv) (SvFLAGS(sv) & (SVs_GMG|SVs_SMG|SVs_RMG)) #define SvMAGICAL_on(sv) (SvFLAGS(sv) |= (SVs_GMG|SVs_SMG|SVs_RMG)) #define SvMAGICAL_off(sv) (SvFLAGS(sv) &= ~(SVs_GMG|SVs_SMG|SVs_RMG)) #define SvGMAGICAL(sv) (SvFLAGS(sv) & SVs_GMG) #define SvGMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_GMG) #define SvGMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_GMG) #define SvSMAGICAL(sv) (SvFLAGS(sv) & SVs_SMG) #define SvSMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_SMG) #define SvSMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_SMG) #define SvRMAGICAL(sv) (SvFLAGS(sv) & SVs_RMG) #define SvRMAGICAL_on(sv) (SvFLAGS(sv) |= SVs_RMG) #define SvRMAGICAL_off(sv) (SvFLAGS(sv) &= ~SVs_RMG) #define SvAMAGIC(sv) (SvROK(sv) && (SvFLAGS(SvRV(sv)) & SVf_AMAGIC)) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvAMAGIC_on(sv) ({ SV * const kloink = sv; \ assert(SvROK(kloink)); \ SvFLAGS(SvRV(kloink)) |= SVf_AMAGIC; \ }) # define SvAMAGIC_off(sv) ({ SV * const kloink = sv; \ if(SvROK(kloink)) \ SvFLAGS(SvRV(kloink)) &= ~SVf_AMAGIC;\ }) #else # define SvAMAGIC_on(sv) (SvFLAGS(SvRV(sv)) |= SVf_AMAGIC) # define SvAMAGIC_off(sv) \ (SvROK(sv) && (SvFLAGS(SvRV(sv)) &= ~SVf_AMAGIC)) #endif /* =for apidoc Am|U32|SvGAMAGIC|SV* sv Returns true if the SV has get magic or overloading. If either is true then the scalar is active data, and has the potential to return a new value every time it is accessed. Hence you must be careful to only read it once per user logical operation and work with that returned value. If neither is true then the scalar's value cannot change unless written to. =cut */ #define SvGAMAGIC(sv) (SvGMAGICAL(sv) || SvAMAGIC(sv)) #define Gv_AMG(stash) (PL_amagic_generation && Gv_AMupdate(stash, FALSE)) #define SvWEAKREF(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_WEAKREF)) \ == (SVf_ROK|SVprv_WEAKREF)) #define SvWEAKREF_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_WEAKREF)) #define SvWEAKREF_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_WEAKREF)) #define SvPCS_IMPORTED(sv) ((SvFLAGS(sv) & (SVf_ROK|SVprv_PCS_IMPORTED)) \ == (SVf_ROK|SVprv_PCS_IMPORTED)) #define SvPCS_IMPORTED_on(sv) (SvFLAGS(sv) |= (SVf_ROK|SVprv_PCS_IMPORTED)) #define SvPCS_IMPORTED_off(sv) (SvFLAGS(sv) &= ~(SVf_ROK|SVprv_PCS_IMPORTED)) #define SvTHINKFIRST(sv) (SvFLAGS(sv) & SVf_THINKFIRST) #define SvPADMY(sv) (SvFLAGS(sv) & SVs_PADMY) #define SvPADMY_on(sv) (SvFLAGS(sv) |= SVs_PADMY) /* SVs_PADTMP and SVs_PADSTALE share the same bit, mediated by SVs_PADMY */ #define SvPADTMP(sv) ((SvFLAGS(sv) & (SVs_PADMY|SVs_PADTMP)) == SVs_PADTMP) #define SvPADSTALE(sv) ((SvFLAGS(sv) & (SVs_PADMY|SVs_PADSTALE)) \ == (SVs_PADMY|SVs_PADSTALE)) #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvPADTMP_on(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(!(SvFLAGS(_svpad) & SVs_PADMY)); \ SvFLAGS(_svpad) |= SVs_PADTMP; \ }) # define SvPADTMP_off(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(!(SvFLAGS(_svpad) & SVs_PADMY)); \ SvFLAGS(_svpad) &= ~SVs_PADTMP; \ }) # define SvPADSTALE_on(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(SvFLAGS(_svpad) & SVs_PADMY); \ SvFLAGS(_svpad) |= SVs_PADSTALE; \ }) # define SvPADSTALE_off(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(SvFLAGS(_svpad) & SVs_PADMY); \ SvFLAGS(_svpad) &= ~SVs_PADSTALE; \ }) #else # define SvPADTMP_on(sv) (SvFLAGS(sv) |= SVs_PADTMP) # define SvPADTMP_off(sv) (SvFLAGS(sv) &= ~SVs_PADTMP) # define SvPADSTALE_on(sv) (SvFLAGS(sv) |= SVs_PADSTALE) # define SvPADSTALE_off(sv) (SvFLAGS(sv) &= ~SVs_PADSTALE) #endif #define SvTEMP(sv) (SvFLAGS(sv) & SVs_TEMP) #define SvTEMP_on(sv) (SvFLAGS(sv) |= SVs_TEMP) #define SvTEMP_off(sv) (SvFLAGS(sv) &= ~SVs_TEMP) #define SvOBJECT(sv) (SvFLAGS(sv) & SVs_OBJECT) #define SvOBJECT_on(sv) (SvFLAGS(sv) |= SVs_OBJECT) #define SvOBJECT_off(sv) (SvFLAGS(sv) &= ~SVs_OBJECT) #define SvREADONLY(sv) (SvFLAGS(sv) & SVf_READONLY) #define SvREADONLY_on(sv) (SvFLAGS(sv) |= SVf_READONLY) #define SvREADONLY_off(sv) (SvFLAGS(sv) &= ~SVf_READONLY) #define SvSCREAM(sv) ((SvFLAGS(sv) & (SVp_SCREAM|SVp_POK)) == (SVp_SCREAM|SVp_POK)) #define SvSCREAM_on(sv) (SvFLAGS(sv) |= SVp_SCREAM) #define SvSCREAM_off(sv) (SvFLAGS(sv) &= ~SVp_SCREAM) #ifndef PERL_CORE # define SvCOMPILED(sv) 0 # define SvCOMPILED_on(sv) # define SvCOMPILED_off(sv) #endif #define SvEVALED(sv) (SvFLAGS(sv) & SVrepl_EVAL) #define SvEVALED_on(sv) (SvFLAGS(sv) |= SVrepl_EVAL) #define SvEVALED_off(sv) (SvFLAGS(sv) &= ~SVrepl_EVAL) #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvVALID(sv) ({ const SV *const _svvalid = (const SV*)(sv); \ if (SvFLAGS(_svvalid) & SVpbm_VALID) \ assert(!isGV_with_GP(_svvalid)); \ (SvFLAGS(_svvalid) & SVpbm_VALID); \ }) # define SvVALID_on(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ assert(!isGV_with_GP(_svvalid)); \ (SvFLAGS(_svvalid) |= SVpbm_VALID); \ }) # define SvVALID_off(sv) ({ SV *const _svvalid = MUTABLE_SV(sv); \ assert(!isGV_with_GP(_svvalid)); \ (SvFLAGS(_svvalid) &= ~SVpbm_VALID); \ }) # define SvTAIL(sv) ({ const SV *const _svtail = (const SV *)(sv); \ assert(SvTYPE(_svtail) != SVt_PVAV); \ assert(SvTYPE(_svtail) != SVt_PVHV); \ (SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ == (SVpbm_TAIL|SVpbm_VALID); \ }) #else # define SvVALID(sv) (SvFLAGS(sv) & SVpbm_VALID) # define SvVALID_on(sv) (SvFLAGS(sv) |= SVpbm_VALID) # define SvVALID_off(sv) (SvFLAGS(sv) &= ~SVpbm_VALID) # define SvTAIL(sv) ((SvFLAGS(sv) & (SVpbm_TAIL|SVpbm_VALID)) \ == (SVpbm_TAIL|SVpbm_VALID)) #endif #define SvTAIL_on(sv) (SvFLAGS(sv) |= SVpbm_TAIL) #define SvTAIL_off(sv) (SvFLAGS(sv) &= ~SVpbm_TAIL) #define SvPAD_TYPED(sv) \ ((SvFLAGS(sv) & (SVpad_NAME|SVpad_TYPED)) == (SVpad_NAME|SVpad_TYPED)) #define SvPAD_OUR(sv) \ ((SvFLAGS(sv) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR)) #define SvPAD_STATE(sv) \ ((SvFLAGS(sv) & (SVpad_NAME|SVpad_STATE)) == (SVpad_NAME|SVpad_STATE)) #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvPAD_TYPED_on(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(SvTYPE(_svpad) == SVt_PVMG); \ (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_TYPED); \ }) #define SvPAD_OUR_on(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(SvTYPE(_svpad) == SVt_PVMG); \ (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_OUR); \ }) #define SvPAD_STATE_on(sv) ({ \ SV *const _svpad = MUTABLE_SV(sv); \ assert(SvTYPE(_svpad) == SVt_PVNV || SvTYPE(_svpad) == SVt_PVMG); \ (SvFLAGS(_svpad) |= SVpad_NAME|SVpad_STATE); \ }) #else # define SvPAD_TYPED_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_TYPED) # define SvPAD_OUR_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_OUR) # define SvPAD_STATE_on(sv) (SvFLAGS(sv) |= SVpad_NAME|SVpad_STATE) #endif #define SvOURSTASH(sv) \ (SvPAD_OUR(sv) ? ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash : NULL) #define SvOURSTASH_set(sv, st) \ STMT_START { \ assert(SvTYPE(sv) == SVt_PVMG); \ ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash = st; \ } STMT_END #define SvRVx(sv) SvRV(sv) #ifdef PERL_DEBUG_COW /* Need -0.0 for SvNVX to preserve IEEE FP "negative zero" because +0.0 + -0.0 => +0.0 but -0.0 + -0.0 => -0.0 */ # define SvIVX(sv) (0 + ((XPVIV*) SvANY(sv))->xiv_iv) # define SvUVX(sv) (0 + ((XPVUV*) SvANY(sv))->xuv_uv) # define SvNVX(sv) (-0.0 + ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv) # define SvRV(sv) (0 + (sv)->sv_u.svu_rv) # define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) /* Don't test the core XS code yet. */ # if defined (PERL_CORE) && PERL_DEBUG_COW > 1 # define SvPVX(sv) (0 + (assert(!SvREADONLY(sv)), (sv)->sv_u.svu_pv)) # else # define SvPVX(sv) SvPVX_mutable(sv) # endif # define SvCUR(sv) (0 + ((XPV*) SvANY(sv))->xpv_cur) # define SvLEN(sv) (0 + ((XPV*) SvANY(sv))->xpv_len) # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) # ifdef DEBUGGING # define SvMAGIC(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*) SvANY(sv))->xmg_u.xmg_magic)) # define SvSTASH(sv) (0 + *(assert(SvTYPE(sv) >= SVt_PVMG), &((XPVMG*) SvANY(sv))->xmg_stash)) # else # define SvMAGIC(sv) (0 + ((XPVMG*) SvANY(sv))->xmg_u.xmg_magic) # define SvSTASH(sv) (0 + ((XPVMG*) SvANY(sv))->xmg_stash) # endif #else # define SvLEN(sv) ((XPV*) SvANY(sv))->xpv_len # define SvEND(sv) ((sv)->sv_u.svu_pv + ((XPV*)SvANY(sv))->xpv_cur) # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) /* These get expanded inside other macros that already use a variable _sv */ # define SvPVX(sv) \ (*({ SV *const _svpvx = MUTABLE_SV(sv); \ assert(PL_valid_types_PVX[SvTYPE(_svpvx) & SVt_MASK]); \ assert(!isGV_with_GP(_svpvx)); \ assert(!(SvTYPE(_svpvx) == SVt_PVIO \ && !(IoFLAGS(_svpvx) & IOf_FAKE_DIRP))); \ &((_svpvx)->sv_u.svu_pv); \ })) # define SvCUR(sv) \ (*({ const SV *const _svcur = (const SV *)(sv); \ assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]); \ assert(!isGV_with_GP(_svcur)); \ assert(!(SvTYPE(_svcur) == SVt_PVIO \ && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP))); \ &(((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur); \ })) # define SvIVX(sv) \ (*({ const SV *const _svivx = (const SV *)(sv); \ assert(PL_valid_types_IVX[SvTYPE(_svivx) & SVt_MASK]); \ assert(!isGV_with_GP(_svivx)); \ &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv); \ })) # define SvUVX(sv) \ (*({ const SV *const _svuvx = (const SV *)(sv); \ assert(PL_valid_types_IVX[SvTYPE(_svuvx) & SVt_MASK]); \ assert(!isGV_with_GP(_svuvx)); \ &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv); \ })) # define SvNVX(sv) \ (*({ const SV *const _svnvx = (const SV *)(sv); \ assert(PL_valid_types_NVX[SvTYPE(_svnvx) & SVt_MASK]); \ assert(!isGV_with_GP(_svnvx)); \ &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv); \ })) # define SvRV(sv) \ (*({ SV *const _svrv = MUTABLE_SV(sv); \ assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ assert(!isGV_with_GP(_svrv)); \ assert(!(SvTYPE(_svrv) == SVt_PVIO \ && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ &((_svrv)->sv_u.svu_rv); \ })) # define SvRV_const(sv) \ ({ const SV *const _svrv = (const SV *)(sv); \ assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ assert(!isGV_with_GP(_svrv)); \ assert(!(SvTYPE(_svrv) == SVt_PVIO \ && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ (_svrv)->sv_u.svu_rv; \ }) # define SvMAGIC(sv) \ (*({ const SV *const _svmagic = (const SV *)(sv); \ assert(SvTYPE(_svmagic) >= SVt_PVMG); \ if(SvTYPE(_svmagic) == SVt_PVMG) \ assert(!SvPAD_OUR(_svmagic)); \ &(((XPVMG*) MUTABLE_PTR(SvANY(_svmagic)))->xmg_u.xmg_magic); \ })) # define SvSTASH(sv) \ (*({ const SV *const _svstash = (const SV *)(sv); \ assert(SvTYPE(_svstash) >= SVt_PVMG); \ &(((XPVMG*) MUTABLE_PTR(SvANY(_svstash)))->xmg_stash); \ })) # else # define SvPVX(sv) ((sv)->sv_u.svu_pv) # define SvCUR(sv) ((XPV*) SvANY(sv))->xpv_cur # define SvIVX(sv) ((XPVIV*) SvANY(sv))->xiv_iv # define SvUVX(sv) ((XPVUV*) SvANY(sv))->xuv_uv # define SvNVX(sv) ((XPVNV*) SvANY(sv))->xnv_u.xnv_nv # define SvRV(sv) ((sv)->sv_u.svu_rv) # define SvRV_const(sv) (0 + (sv)->sv_u.svu_rv) # define SvMAGIC(sv) ((XPVMG*) SvANY(sv))->xmg_u.xmg_magic # define SvSTASH(sv) ((XPVMG*) SvANY(sv))->xmg_stash # endif #endif #ifndef PERL_POISON /* Given that these two are new, there can't be any existing code using them * as LVALUEs */ # define SvPVX_mutable(sv) (0 + (sv)->sv_u.svu_pv) # define SvPVX_const(sv) ((const char*)(0 + (sv)->sv_u.svu_pv)) #else /* Except for the poison code, which uses & to scribble over the pointer after free() is called. */ # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) #endif #define SvIVXx(sv) SvIVX(sv) #define SvUVXx(sv) SvUVX(sv) #define SvNVXx(sv) SvNVX(sv) #define SvPVXx(sv) SvPVX(sv) #define SvLENx(sv) SvLEN(sv) #define SvENDx(sv) ((PL_Sv = (sv)), SvEND(PL_Sv)) /* Ask a scalar nicely to try to become an IV, if possible. Not guaranteed to stay returning void */ /* Macro won't actually call sv_2iv if already IOK */ #define SvIV_please(sv) \ STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \ (void) SvIV(sv); } STMT_END #define SvIV_please_nomg(sv) \ STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \ (void) SvIV_nomg(sv); } STMT_END #define SvIV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ (((XPVIV*) SvANY(sv))->xiv_iv = (val)); } STMT_END #define SvNV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_NV_set[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ (((XPVNV*)SvANY(sv))->xnv_u.xnv_nv = (val)); } STMT_END #define SvPV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ assert(!(SvTYPE(sv) == SVt_PVIO \ && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ ((sv)->sv_u.svu_pv = (val)); } STMT_END #define SvUV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ (((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END #define SvRV_set(sv, val) \ STMT_START { \ assert(PL_valid_types_RV[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ assert(!(SvTYPE(sv) == SVt_PVIO \ && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ ((sv)->sv_u.svu_rv = (val)); } STMT_END #define SvMAGIC_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*)SvANY(sv))->xmg_u.xmg_magic = (val)); } STMT_END #define SvSTASH_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END #define SvCUR_set(sv, val) \ STMT_START { \ assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ assert(!(SvTYPE(sv) == SVt_PVIO \ && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ (((XPV*) SvANY(sv))->xpv_cur = (val)); } STMT_END #define SvLEN_set(sv, val) \ STMT_START { \ assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]); \ assert(!isGV_with_GP(sv)); \ assert(!(SvTYPE(sv) == SVt_PVIO \ && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \ (((XPV*) SvANY(sv))->xpv_len = (val)); } STMT_END #define SvEND_set(sv, val) \ STMT_START { assert(SvTYPE(sv) >= SVt_PV); \ SvCUR_set(sv, (val) - SvPVX(sv)); } STMT_END #define SvPV_renew(sv,n) \ STMT_START { SvLEN_set(sv, n); \ SvPV_set((sv), (MEM_WRAP_CHECK_(n,char) \ (char*)saferealloc((Malloc_t)SvPVX(sv), \ (MEM_SIZE)((n))))); \ } STMT_END #define SvPV_shrink_to_cur(sv) STMT_START { \ const STRLEN _lEnGtH = SvCUR(sv) + 1; \ SvPV_renew(sv, _lEnGtH); \ } STMT_END #define SvPV_free(sv) \ STMT_START { \ assert(SvTYPE(sv) >= SVt_PV); \ if (SvLEN(sv)) { \ assert(!SvROK(sv)); \ if(SvOOK(sv)) { \ STRLEN zok; \ SvOOK_offset(sv, zok); \ SvPV_set(sv, SvPVX_mutable(sv) - zok); \ SvFLAGS(sv) &= ~SVf_OOK; \ } \ Safefree(SvPVX(sv)); \ } \ } STMT_END #ifdef PERL_CORE /* Code that crops up in three places to take a scalar and ready it to hold a reference */ # define prepare_SV_for_RV(sv) \ STMT_START { \ if (SvTYPE(sv) < SVt_PV && SvTYPE(sv) != SVt_IV) \ sv_upgrade(sv, SVt_IV); \ else if (SvTYPE(sv) >= SVt_PV) { \ SvPV_free(sv); \ SvLEN_set(sv, 0); \ SvCUR_set(sv, 0); \ } \ } STMT_END #endif #ifndef PERL_CORE # define BmFLAGS(sv) (SvTAIL(sv) ? FBMcf_TAIL : 0) #endif #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define BmRARE(sv) \ (*({ SV *const _bmrare = MUTABLE_SV(sv); \ assert(SvTYPE(_bmrare) == SVt_PVMG); \ assert(SvVALID(_bmrare)); \ &(((XPVMG*) SvANY(_bmrare))->xnv_u.xbm_s.xbm_rare); \ })) # define BmUSEFUL(sv) \ (*({ SV *const _bmuseful = MUTABLE_SV(sv); \ assert(SvTYPE(_bmuseful) == SVt_PVMG); \ assert(SvVALID(_bmuseful)); \ assert(!SvIOK(_bmuseful)); \ &(((XPVMG*) SvANY(_bmuseful))->xnv_u.xbm_s.xbm_useful); \ })) # define BmPREVIOUS(sv) \ (*({ SV *const _bmprevious = MUTABLE_SV(sv); \ assert(SvTYPE(_bmprevious) == SVt_PVMG); \ assert(SvVALID(_bmprevious)); \ &(((XPVMG*) SvANY(_bmprevious))->xiv_u.xivu_uv); \ })) #else # define BmRARE(sv) ((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_rare # define BmUSEFUL(sv) ((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_useful # define BmPREVIOUS(sv) ((XPVMG*) SvANY(sv))->xiv_u.xivu_uv #endif #define FmLINES(sv) ((XPVFM*) SvANY(sv))->xfm_lines #define LvTYPE(sv) ((XPVLV*) SvANY(sv))->xlv_type #define LvTARG(sv) ((XPVLV*) SvANY(sv))->xlv_targ #define LvTARGOFF(sv) ((XPVLV*) SvANY(sv))->xlv_targoff #define LvTARGLEN(sv) ((XPVLV*) SvANY(sv))->xlv_targlen #define LvFLAGS(sv) ((XPVLV*) SvANY(sv))->xlv_flags #define IoIFP(sv) (sv)->sv_u.svu_fp #define IoOFP(sv) ((XPVIO*) SvANY(sv))->xio_ofp #define IoDIRP(sv) ((XPVIO*) SvANY(sv))->xio_dirp #define IoANY(sv) ((XPVIO*) SvANY(sv))->xio_any #define IoLINES(sv) ((XPVIO*) SvANY(sv))->xiv_u.xivu_iv #define IoPAGE(sv) ((XPVIO*) SvANY(sv))->xio_page #define IoPAGE_LEN(sv) ((XPVIO*) SvANY(sv))->xio_page_len #define IoLINES_LEFT(sv)((XPVIO*) SvANY(sv))->xio_lines_left #define IoTOP_NAME(sv) ((XPVIO*) SvANY(sv))->xio_top_name #define IoTOP_GV(sv) ((XPVIO*) SvANY(sv))->xio_top_gv #define IoFMT_NAME(sv) ((XPVIO*) SvANY(sv))->xio_fmt_name #define IoFMT_GV(sv) ((XPVIO*) SvANY(sv))->xio_fmt_gv #define IoBOTTOM_NAME(sv)((XPVIO*) SvANY(sv))->xio_bottom_name #define IoBOTTOM_GV(sv) ((XPVIO*) SvANY(sv))->xio_bottom_gv #define IoTYPE(sv) ((XPVIO*) SvANY(sv))->xio_type #define IoFLAGS(sv) ((XPVIO*) SvANY(sv))->xio_flags /* IoTYPE(sv) is a single character telling the type of I/O connection. */ #define IoTYPE_RDONLY '<' #define IoTYPE_WRONLY '>' #define IoTYPE_RDWR '+' #define IoTYPE_APPEND 'a' #define IoTYPE_PIPE '|' #define IoTYPE_STD '-' /* stdin or stdout */ #define IoTYPE_SOCKET 's' #define IoTYPE_CLOSED ' ' #define IoTYPE_IMPLICIT 'I' /* stdin or stdout or stderr */ #define IoTYPE_NUMERIC '#' /* fdopen */ /* =for apidoc Am|bool|SvTAINTED|SV* sv Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if not. =for apidoc Am|void|SvTAINTED_on|SV* sv Marks an SV as tainted if tainting is enabled. =for apidoc Am|void|SvTAINTED_off|SV* sv Untaints an SV. Be I careful with this routine, as it short-circuits some of Perl's fundamental security features. XS module authors should not use this function unless they fully understand all the implications of unconditionally untainting the value. Untainting should be done in the standard perl fashion, via a carefully crafted regexp, rather than directly untainting variables. =for apidoc Am|void|SvTAINT|SV* sv Taints an SV if tainting is enabled, and if some input to the current expression is tainted--usually a variable, but possibly also implicit inputs such as locale settings. C propagates that taintedness to the outputs of an expression in a pessimistic fashion; i.e., without paying attention to precisely which outputs are influenced by which inputs. =cut */ #define sv_taint(sv) sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0) #define SvTAINTED(sv) (SvMAGICAL(sv) && sv_tainted(sv)) #define SvTAINTED_on(sv) STMT_START{ if(PL_tainting){sv_taint(sv);} }STMT_END #define SvTAINTED_off(sv) STMT_START{ if(PL_tainting){sv_untaint(sv);} }STMT_END #define SvTAINT(sv) \ STMT_START { \ if (PL_tainting) { \ if (PL_tainted) \ SvTAINTED_on(sv); \ } \ } STMT_END /* =for apidoc Am|char*|SvPV_force|SV* sv|STRLEN len Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len Like C but will force the SV into containing just a string (C). You want force if you are going to update the C directly. Doesn't process magic. =for apidoc Am|char*|SvPV|SV* sv|STRLEN len Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified version becoming C. Handles 'get' magic. See also C for a version which guarantees to evaluate sv only once. =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len A version of C which guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len Like C but doesn't process magic. =for apidoc Am|char*|SvPV_nolen|SV* sv Returns a pointer to the string in the SV, or a stringified form of the SV if the SV does not contain a string. The SV may cache the stringified form becoming C. Handles 'get' magic. =for apidoc Am|char*|SvPV_nomg_nolen|SV* sv Like C but doesn't process magic. =for apidoc Am|IV|SvIV|SV* sv Coerces the given SV to an integer and returns it. See C for a version which guarantees to evaluate sv only once. =for apidoc Am|IV|SvIV_nomg|SV* sv Like C but doesn't process magic. =for apidoc Am|IV|SvIVx|SV* sv Coerces the given SV to an integer and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. =for apidoc Am|NV|SvNV|SV* sv Coerce the given SV to a double and return it. See C for a version which guarantees to evaluate sv only once. =for apidoc Am|NV|SvNV_nomg|SV* sv Like C but doesn't process magic. =for apidoc Am|NV|SvNVx|SV* sv Coerces the given SV to a double and returns it. Guarantees to evaluate C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. =for apidoc Am|UV|SvUV|SV* sv Coerces the given SV to an unsigned integer and returns it. See C for a version which guarantees to evaluate sv only once. =for apidoc Am|UV|SvUV_nomg|SV* sv Like C but doesn't process magic. =for apidoc Am|UV|SvUVx|SV* sv Coerces the given SV to an unsigned integer and returns it. Guarantees to C only once. Only use this if C is an expression with side effects, otherwise use the more efficient C. =for apidoc Am|bool|SvTRUE|SV* sv Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Handles 'get' magic unless the scalar is already SvPOK, SvIOK or SvNOK (the public, not the private flags). =for apidoc Am|bool|SvTRUE_nomg|SV* sv Returns a boolean indicating whether Perl would evaluate the SV as true or false. See SvOK() for a defined/undefined test. Does not handle 'get' magic. =for apidoc Am|char*|SvPVutf8_force|SV* sv|STRLEN len Like C, but converts sv to utf8 first if necessary. =for apidoc Am|char*|SvPVutf8|SV* sv|STRLEN len Like C, but converts sv to utf8 first if necessary. =for apidoc Am|char*|SvPVutf8_nolen|SV* sv Like C, but converts sv to utf8 first if necessary. =for apidoc Am|char*|SvPVbyte_force|SV* sv|STRLEN len Like C, but converts sv to byte representation first if necessary. =for apidoc Am|char*|SvPVbyte|SV* sv|STRLEN len Like C, but converts sv to byte representation first if necessary. =for apidoc Am|char*|SvPVbyte_nolen|SV* sv Like C, but converts sv to byte representation first if necessary. =for apidoc Am|char*|SvPVutf8x_force|SV* sv|STRLEN len Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. =for apidoc Am|char*|SvPVutf8x|SV* sv|STRLEN len Like C, but converts sv to utf8 first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. =for apidoc Am|char*|SvPVbytex_force|SV* sv|STRLEN len Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. =for apidoc Am|char*|SvPVbytex|SV* sv|STRLEN len Like C, but converts sv to byte representation first if necessary. Guarantees to evaluate sv only once; use the more efficient C otherwise. =for apidoc Am|bool|SvIsCOW|SV* sv Returns a boolean indicating whether the SV is Copy-On-Write (either shared hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for COW). =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv Returns a boolean indicating whether the SV is Copy-On-Write shared hash key scalar. =for apidoc Am|void|sv_catpvn_nomg|SV* sv|const char* ptr|STRLEN len Like C but doesn't process magic. =for apidoc Am|void|sv_catpv_nomg|SV* sv|const char* ptr Like C but doesn't process magic. =for apidoc Am|void|sv_setsv_nomg|SV* dsv|SV* ssv Like C but doesn't process magic. =for apidoc Am|void|sv_catsv_nomg|SV* dsv|SV* ssv Like C but doesn't process magic. =for apidoc Amdb|STRLEN|sv_utf8_upgrade_nomg|NN SV *sv Like sv_utf8_upgrade, but doesn't do magic on C. =cut */ /* Let us hope that bitmaps for UV and IV are the same */ #define SvIV(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) #define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) #define SvNV(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv)) #define SvIV_nomg(sv) (SvIOK(sv) ? SvIVX(sv) : sv_2iv_flags(sv, 0)) #define SvUV_nomg(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv_flags(sv, 0)) #define SvNV_nomg(sv) (SvNOK(sv) ? SvNVX(sv) : sv_2nv_flags(sv, 0)) /* ----*/ #define SvPV(sv, lp) SvPV_flags(sv, lp, SV_GMAGIC) #define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) #define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) #define SvPV_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) #define SvPV_flags_const(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) #define SvPV_flags_const_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : \ (const char*) sv_2pv_flags(sv, 0, flags|SV_CONST_RETURN)) #define SvPV_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) #define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) #define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) #define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) #define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) #define SvPV_force_flags(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) #define SvPV_force_flags_nolen(sv, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? SvPVX(sv) : sv_pvn_force_flags(sv, 0, flags)) #define SvPV_force_flags_mutable(sv, lp, flags) \ ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) #define SvPV_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC)) #define SvPV_nomg_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX(sv) : sv_2pv_flags(sv, 0, 0)) #define SvPV_nolen_const(sv) \ ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ ? SvPVX_const(sv) : sv_2pv_flags(sv, 0, SV_GMAGIC|SV_CONST_RETURN)) #define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) #define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) #define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) /* ----*/ #define SvPVutf8(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvutf8(sv, &lp)) #define SvPVutf8_force(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK|SVf_UTF8) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvutf8n_force(sv, &lp)) #define SvPVutf8_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK|SVf_UTF8)\ ? SvPVX(sv) : sv_2pvutf8(sv, 0)) /* ----*/ #define SvPVbyte(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) #define SvPVbyte_force(sv, lp) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8|SVf_THINKFIRST)) == (SVf_POK) \ ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvbyten_force(sv, &lp)) #define SvPVbyte_nolen(sv) \ ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK)\ ? SvPVX(sv) : sv_2pvbyte(sv, 0)) /* define FOOx(): idempotent versions of FOO(). If possible, use a local * var to evaluate the arg once; failing that, use a global if possible; * failing that, call a function to do the work */ #define SvPVx_force(sv, lp) sv_pvn_force(sv, &lp) #define SvPVutf8x_force(sv, lp) sv_pvutf8n_force(sv, &lp) #define SvPVbytex_force(sv, lp) sv_pvbyten_force(sv, &lp) #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define SvIVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvIV(_sv); }) # define SvUVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvUV(_sv); }) # define SvNVx(sv) ({SV *_sv = MUTABLE_SV(sv); SvNV(_sv); }) # define SvPVx(sv, lp) ({SV *_sv = (sv); SvPV(_sv, lp); }) # define SvPVx_const(sv, lp) ({SV *_sv = (sv); SvPV_const(_sv, lp); }) # define SvPVx_nolen(sv) ({SV *_sv = (sv); SvPV_nolen(_sv); }) # define SvPVx_nolen_const(sv) ({SV *_sv = (sv); SvPV_nolen_const(_sv); }) # define SvPVutf8x(sv, lp) ({SV *_sv = (sv); SvPVutf8(_sv, lp); }) # define SvPVbytex(sv, lp) ({SV *_sv = (sv); SvPVbyte(_sv, lp); }) # define SvPVbytex_nolen(sv) ({SV *_sv = (sv); SvPVbyte_nolen(_sv); }) # define SvTRUE(sv) ( \ !sv \ ? 0 \ : SvPOK(sv) \ ? (({XPV *nxpv = (XPV*)SvANY(sv); \ nxpv && \ (nxpv->xpv_cur > 1 || \ (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \ ? 1 \ : 0) \ : \ SvIOK(sv) \ ? SvIVX(sv) != 0 \ : SvNOK(sv) \ ? SvNVX(sv) != 0.0 \ : sv_2bool(sv) ) # define SvTRUE_nomg(sv) ( \ !sv \ ? 0 \ : SvPOK(sv) \ ? (({XPV *nxpv = (XPV*)SvANY(sv); \ nxpv && \ (nxpv->xpv_cur > 1 || \ (nxpv->xpv_cur && *(sv)->sv_u.svu_pv != '0')); }) \ ? 1 \ : 0) \ : \ SvIOK(sv) \ ? SvIVX(sv) != 0 \ : SvNOK(sv) \ ? SvNVX(sv) != 0.0 \ : sv_2bool_flags(sv,0) ) # define SvTRUEx(sv) ({SV *_sv = (sv); SvTRUE(_sv); }) #else /* __GNUC__ */ /* These inlined macros use globals, which will require a thread * declaration in user code, so we avoid them under threads */ # define SvIVx(sv) ((PL_Sv = (sv)), SvIV(PL_Sv)) # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) # define SvNVx(sv) ((PL_Sv = (sv)), SvNV(PL_Sv)) # define SvPVx(sv, lp) ((PL_Sv = (sv)), SvPV(PL_Sv, lp)) # define SvPVx_const(sv, lp) ((PL_Sv = (sv)), SvPV_const(PL_Sv, lp)) # define SvPVx_nolen(sv) ((PL_Sv = (sv)), SvPV_nolen(PL_Sv)) # define SvPVx_nolen_const(sv) ((PL_Sv = (sv)), SvPV_nolen_const(PL_Sv)) # define SvPVutf8x(sv, lp) ((PL_Sv = (sv)), SvPVutf8(PL_Sv, lp)) # define SvPVbytex(sv, lp) ((PL_Sv = (sv)), SvPVbyte(PL_Sv, lp)) # define SvPVbytex_nolen(sv) ((PL_Sv = (sv)), SvPVbyte_nolen(PL_Sv)) # define SvTRUE(sv) ( \ !sv \ ? 0 \ : SvPOK(sv) \ ? ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) && \ (PL_Xpv->xpv_cur > 1 || \ (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0')) \ ? 1 \ : 0) \ : \ SvIOK(sv) \ ? SvIVX(sv) != 0 \ : SvNOK(sv) \ ? SvNVX(sv) != 0.0 \ : sv_2bool(sv) ) # define SvTRUE_nomg(sv) ( \ !sv \ ? 0 \ : SvPOK(sv) \ ? ((PL_Xpv = (XPV*)SvANY(PL_Sv = (sv))) && \ (PL_Xpv->xpv_cur > 1 || \ (PL_Xpv->xpv_cur && *PL_Sv->sv_u.svu_pv != '0')) \ ? 1 \ : 0) \ : \ SvIOK(sv) \ ? SvIVX(sv) != 0 \ : SvNOK(sv) \ ? SvNVX(sv) != 0.0 \ : sv_2bool_flags(sv,0) ) # define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv)) #endif /* __GNU__ */ #define SvIsCOW(sv) ((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \ (SVf_FAKE | SVf_READONLY) && !isGV_with_GP(sv) \ && SvTYPE(sv) != SVt_REGEXP) #define SvIsCOW_shared_hash(sv) (SvIsCOW(sv) && SvLEN(sv) == 0) #define SvSHARED_HEK_FROM_PV(pvx) \ ((struct hek*)(pvx - STRUCT_OFFSET(struct hek, hek_key))) #define SvSHARED_HASH(sv) (0 + SvSHARED_HEK_FROM_PV(SvPVX_const(sv))->hek_hash) /* flag values for sv_*_flags functions */ #define SV_IMMEDIATE_UNREF 1 #define SV_GMAGIC 2 #define SV_COW_DROP_PV 4 #define SV_UTF8_NO_ENCODING 8 #define SV_NOSTEAL 16 #define SV_CONST_RETURN 32 #define SV_MUTABLE_RETURN 64 #define SV_SMAGIC 128 #define SV_HAS_TRAILING_NUL 256 #define SV_COW_SHARED_HASH_KEYS 512 /* This one is only enabled for PERL_OLD_COPY_ON_WRITE */ #define SV_COW_OTHER_PVS 1024 /* Make sv_2pv_flags return NULL if something is undefined. */ #define SV_UNDEF_RETURNS_NULL 2048 /* Tell sv_utf8_upgrade() to not check to see if an upgrade is really needed. * This is used when the caller has already determined it is, and avoids * redundant work */ #define SV_FORCE_UTF8_UPGRADE 4096 /* if (after resolving magic etc), the SV is found to be overloaded, * don't call the overload magic, just return as-is */ #define SV_SKIP_OVERLOAD 8192 /* It is not yet clear whether we want this as an API, or what the * constants should be named. */ #ifdef PERL_CORE # define SV_CATBYTES 16384 # define SV_CATUTF8 32768 #endif /* The core is safe for this COW optimisation. XS code on CPAN may not be. So only default to doing the COW setup if we're in the core. */ #ifdef PERL_CORE # ifndef SV_DO_COW_SVSETSV # define SV_DO_COW_SVSETSV SV_COW_SHARED_HASH_KEYS|SV_COW_OTHER_PVS # endif #endif #ifndef SV_DO_COW_SVSETSV # define SV_DO_COW_SVSETSV 0 #endif #define sv_unref(sv) sv_unref_flags(sv, 0) #define sv_force_normal(sv) sv_force_normal_flags(sv, 0) #define sv_usepvn(sv, p, l) sv_usepvn_flags(sv, p, l, 0) #define sv_usepvn_mg(sv, p, l) sv_usepvn_flags(sv, p, l, SV_SMAGIC) /* We are about to replace the SV's current value. So if it's copy on write we need to normalise it. Use the SV_COW_DROP_PV flag hint to say that the value is about to get thrown away, so drop the PV rather than go to the effort of making a read-write copy only for it to get immediately discarded. */ #define SV_CHECK_THINKFIRST_COW_DROP(sv) if (SvTHINKFIRST(sv)) \ sv_force_normal_flags(sv, SV_COW_DROP_PV) #ifdef PERL_OLD_COPY_ON_WRITE #define SvRELEASE_IVX(sv) \ ((SvIsCOW(sv) ? sv_force_normal_flags(sv, 0) : (void) 0), 0) # define SvIsCOW_normal(sv) (SvIsCOW(sv) && SvLEN(sv)) # define SvRELEASE_IVX_(sv) SvRELEASE_IVX(sv), #else # define SvRELEASE_IVX(sv) 0 /* This little game brought to you by the need to shut this warning up: mg.c: In function 'Perl_magic_get': mg.c:1024: warning: left-hand operand of comma expression has no effect */ # define SvRELEASE_IVX_(sv) /**/ #endif /* PERL_OLD_COPY_ON_WRITE */ #define CAN_COW_MASK (SVs_OBJECT|SVs_GMG|SVs_SMG|SVs_RMG|SVf_IOK|SVf_NOK| \ SVf_POK|SVf_ROK|SVp_IOK|SVp_NOK|SVp_POK|SVf_FAKE| \ SVf_OOK|SVf_BREAK|SVf_READONLY) #define CAN_COW_FLAGS (SVp_POK|SVf_POK) #define SV_CHECK_THINKFIRST(sv) if (SvTHINKFIRST(sv)) \ sv_force_normal_flags(sv, 0) /* all these 'functions' are now just macros */ #define sv_pv(sv) SvPV_nolen(sv) #define sv_pvutf8(sv) SvPVutf8_nolen(sv) #define sv_pvbyte(sv) SvPVbyte_nolen(sv) #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0) #define sv_utf8_upgrade_flags(sv, flags) sv_utf8_upgrade_flags_grow(sv, flags, 0) #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0) #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0) #define sv_catpv_nomg(dsv, sstr) sv_catpv_flags(dsv, sstr, 0) #define sv_setsv(dsv, ssv) \ sv_setsv_flags(dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV) #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_DO_COW_SVSETSV) #define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC) #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0) #define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC) #define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC) #define sv_catpvn_mg(sv, sstr, slen) \ sv_catpvn_flags(sv, sstr, slen, SV_GMAGIC|SV_SMAGIC); #define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC) #define sv_2pv_nolen(sv) sv_2pv(sv, 0) #define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0) #define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0) #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0) #define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC) #define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC) #define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC) #define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC) #define sv_2nv(sv) sv_2nv_flags(sv, SV_GMAGIC) #define sv_eq(sv1, sv2) sv_eq_flags(sv1, sv2, SV_GMAGIC) #define sv_cmp(sv1, sv2) sv_cmp_flags(sv1, sv2, SV_GMAGIC) #define sv_cmp_locale(sv1, sv2) sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC) #define sv_collxfrm(sv, nxp) sv_cmp_flags(sv, nxp, SV_GMAGIC) #define sv_2bool(sv) sv_2bool_flags(sv, SV_GMAGIC) #define sv_insert(bigstr, offset, len, little, littlelen) \ Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little), \ (littlelen), SV_GMAGIC) /* Should be named SvCatPVN_utf8_upgrade? */ #define sv_catpvn_utf8_upgrade(dsv, sstr, slen, nsv) \ STMT_START { \ if (!(nsv)) \ nsv = newSVpvn_flags(sstr, slen, SVs_TEMP); \ else \ sv_setpvn(nsv, sstr, slen); \ SvUTF8_off(nsv); \ sv_utf8_upgrade(nsv); \ sv_catsv(dsv, nsv); \ } STMT_END /* =for apidoc Am|SV*|newRV_inc|SV* sv Creates an RV wrapper for an SV. The reference count for the original SV is incremented. =cut */ #define newRV_inc(sv) newRV(sv) /* the following macros update any magic values this sv is associated with */ /* =head1 Magical Functions =for apidoc Am|void|SvGETMAGIC|SV* sv Invokes C on an SV if it has 'get' magic. This macro evaluates its argument more than once. =for apidoc Am|void|SvSETMAGIC|SV* sv Invokes C on an SV if it has 'set' magic. This macro evaluates its argument more than once. =for apidoc Am|void|SvSetSV|SV* dsb|SV* ssv Calls C if dsv is not the same as ssv. May evaluate arguments more than once. =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv Calls a non-destructive version of C if dsv is not the same as ssv. May evaluate arguments more than once. =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv Like C, but does any set magic required afterwards. =for apidoc Am|void|SvSetMagicSV_nosteal|SV* dsv|SV* ssv Like C, but does any set magic required afterwards. =for apidoc Am|void|SvSHARE|SV* sv Arranges for sv to be shared between threads if a suitable module has been loaded. =for apidoc Am|void|SvLOCK|SV* sv Arranges for a mutual exclusion lock to be obtained on sv if a suitable module has been loaded. =for apidoc Am|void|SvUNLOCK|SV* sv Releases a mutual exclusion lock on sv if a suitable module has been loaded. =head1 SV Manipulation Functions =for apidoc Am|char *|SvGROW|SV* sv|STRLEN len Expands the character buffer in the SV so that it has room for the indicated number of bytes (remember to reserve space for an extra trailing NUL character). Calls C to perform the expansion if necessary. Returns a pointer to the character buffer. =cut */ #define SvSHARE(sv) PL_sharehook(aTHX_ sv) #define SvLOCK(sv) PL_lockhook(aTHX_ sv) #define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv) #define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv) #define SvGETMAGIC(x) ((void)(SvGMAGICAL(x) && mg_get(x))) #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END #define SvSetSV_and(dst,src,finally) \ STMT_START { \ if ((dst) != (src)) { \ sv_setsv(dst, src); \ finally; \ } \ } STMT_END #define SvSetSV_nosteal_and(dst,src,finally) \ STMT_START { \ if ((dst) != (src)) { \ sv_setsv_flags(dst, src, SV_GMAGIC | SV_NOSTEAL | SV_DO_COW_SVSETSV); \ finally; \ } \ } STMT_END #define SvSetSV(dst,src) \ SvSetSV_and(dst,src,/*nothing*/;) #define SvSetSV_nosteal(dst,src) \ SvSetSV_nosteal_and(dst,src,/*nothing*/;) #define SvSetMagicSV(dst,src) \ SvSetSV_and(dst,src,SvSETMAGIC(dst)) #define SvSetMagicSV_nosteal(dst,src) \ SvSetSV_nosteal_and(dst,src,SvSETMAGIC(dst)) #if !defined(SKIP_DEBUGGING) #define SvPEEK(sv) sv_peek(sv) #else #define SvPEEK(sv) "" #endif #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder) /* =for apidoc Am|SV *|boolSV|bool b Returns a true SV if C is a true value, or a false SV if C is 0. See also C and C. =cut */ #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) #define isGV(sv) (SvTYPE(sv) == SVt_PVGV) /* If I give every macro argument a different name, then there won't be bugs where nested macros get confused. Been there, done that. */ #define isGV_with_GP(pwadak) \ (((SvFLAGS(pwadak) & (SVp_POK|SVpgv_GP)) == SVpgv_GP) \ && (SvTYPE(pwadak) == SVt_PVGV || SvTYPE(pwadak) == SVt_PVLV)) #define isGV_with_GP_on(sv) STMT_START { \ assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ assert (!SvPOKp(sv)); \ assert (!SvIOKp(sv)); \ (SvFLAGS(sv) |= SVpgv_GP); \ } STMT_END #define isGV_with_GP_off(sv) STMT_START { \ assert (SvTYPE(sv) == SVt_PVGV || SvTYPE(sv) == SVt_PVLV); \ assert (!SvPOKp(sv)); \ assert (!SvIOKp(sv)); \ (SvFLAGS(sv) &= ~SVpgv_GP); \ } STMT_END #define SvGROW(sv,len) (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX(sv)) #define SvGROW_mutable(sv,len) \ (SvLEN(sv) < (len) ? sv_grow(sv,len) : SvPVX_mutable(sv)) #define Sv_Grow sv_grow #define CLONEf_COPY_STACKS 1 #define CLONEf_KEEP_PTR_TABLE 2 #define CLONEf_CLONE_HOST 4 #define CLONEf_JOIN_IN 8 struct clone_params { AV* stashes; UV flags; PerlInterpreter *proto_perl; PerlInterpreter *new_perl; AV *unreferenced; }; /* =for apidoc Am|SV*|newSVpvn_utf8|NULLOK const char* s|STRLEN len|U32 utf8 Creates a new SV and copies a string into it. If utf8 is true, calls C on the new SV. Implemented as a wrapper around C. =cut */ #define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) /* =for apidoc Am|void|SvOOK_offset|NN SV*sv|STRLEN len Reads into I the offset from SvPVX back to the true start of the allocated buffer, which will be non-zero if C has been used to efficiently remove characters from start of the buffer. Implemented as a macro, which takes the address of I, which must be of type C. Evaluates I more than once. Sets I to 0 if C is false. =cut */ #ifdef DEBUGGING /* Does the bot know something I don't? 10:28 <@Nicholas> metabatman 10:28 <+meta> Nicholas: crash */ # define SvOOK_offset(sv, offset) STMT_START { \ assert(sizeof(offset) == sizeof(STRLEN)); \ if (SvOOK(sv)) { \ const U8 *crash = (U8*)SvPVX_const(sv); \ offset = *--crash; \ if (!offset) { \ crash -= sizeof(STRLEN); \ Copy(crash, (U8 *)&offset, sizeof(STRLEN), U8); \ } \ { \ /* Validate the preceding buffer's sentinels to \ verify that no-one is using it. */ \ const U8 *const bonk = (U8 *) SvPVX_const(sv) - offset; \ while (crash > bonk) { \ --crash; \ assert (*crash == (U8)PTR2UV(crash)); \ } \ } \ } else { \ offset = 0; \ } \ } STMT_END #else /* This is the same code, but avoids using any temporary variables: */ # define SvOOK_offset(sv, offset) STMT_START { \ assert(sizeof(offset) == sizeof(STRLEN)); \ if (SvOOK(sv)) { \ offset = ((U8*)SvPVX_const(sv))[-1]; \ if (!offset) { \ Copy(SvPVX_const(sv) - 1 - sizeof(STRLEN), \ (U8 *)&offset, sizeof(STRLEN), U8); \ } \ } else { \ offset = 0; \ } \ } STMT_END #endif #define newIO() MUTABLE_IO(newSV_type(SVt_PVIO)) /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ$tcop.hnuW+A/* cop.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * Control ops (cops) are one of the two ops OP_NEXTSTATE and OP_DBSTATE, * that (loosely speaking) are separate statements. * They hold information important for lexical state and error reporting. * At run time, PL_curcop is set to point to the most recently executed cop, * and thus can be used to determine our current state. */ /* A jmpenv packages the state required to perform a proper non-local jump. * Note that there is a PL_start_env initialized when perl starts, and * PL_top_env points to this initially, so PL_top_env should always be * non-null. * * Existence of a non-null PL_top_env->je_prev implies it is valid to call * longjmp() at that runlevel (we make sure PL_start_env.je_prev is always * null to ensure this). * * je_mustcatch, when set at any runlevel to TRUE, means eval ops must * establish a local jmpenv to handle exception traps. Care must be taken * to restore the previous value of je_mustcatch before exiting the * stack frame iff JMPENV_PUSH was not called in that stack frame. * GSAR 97-03-27 */ struct jmpenv { struct jmpenv * je_prev; Sigjmp_buf je_buf; /* only for use if !je_throw */ int je_ret; /* last exception thrown */ bool je_mustcatch; /* need to call longjmp()? */ }; typedef struct jmpenv JMPENV; #ifdef OP_IN_REGISTER #define OP_REG_TO_MEM PL_opsave = op #define OP_MEM_TO_REG op = PL_opsave #else #define OP_REG_TO_MEM NOOP #define OP_MEM_TO_REG NOOP #endif /* * How to build the first jmpenv. * * top_env needs to be non-zero. It points to an area * in which longjmp() stuff is stored, as C callstack * info there at least is thread specific this has to * be per-thread. Otherwise a 'die' in a thread gives * that thread the C stack of last thread to do an eval {}! */ #define JMPENV_BOOTSTRAP \ STMT_START { \ Zero(&PL_start_env, 1, JMPENV); \ PL_start_env.je_ret = -1; \ PL_start_env.je_mustcatch = TRUE; \ PL_top_env = &PL_start_env; \ } STMT_END /* * PERL_FLEXIBLE_EXCEPTIONS * * All the flexible exceptions code has been removed. * See the following threads for details: * * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2004-07/msg00378.html * * Joshua's original patches (which weren't applied) and discussion: * * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg01396.html * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg01489.html * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg01491.html * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg01608.html * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg02144.html * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1998-02/msg02998.html * * Chip's reworked patch and discussion: * * http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/1999-03/msg00520.html * * The flaw in these patches (which went unnoticed at the time) was * that they moved some code that could potentially die() out of the * region protected by the setjmp()s. This caused exceptions within * END blocks and such to not be handled by the correct setjmp(). * * The original patches that introduces flexible exceptions were: * * http://perl5.git.perl.org/perl.git/commit/312caa8e97f1c7ee342a9895c2f0e749625b4929 * http://perl5.git.perl.org/perl.git/commit/14dd3ad8c9bf82cf09798a22cc89a9862dfd6d1a * */ #define dJMPENV JMPENV cur_env #define JMPENV_PUSH(v) \ STMT_START { \ DEBUG_l({ \ int i = 0; JMPENV *p = PL_top_env; \ while (p) { i++; p = p->je_prev; } \ Perl_deb(aTHX_ "JUMPENV_PUSH level=%d at %s:%d\n", \ i, __FILE__, __LINE__);}) \ cur_env.je_prev = PL_top_env; \ OP_REG_TO_MEM; \ cur_env.je_ret = PerlProc_setjmp(cur_env.je_buf, SCOPE_SAVES_SIGNAL_MASK); \ OP_MEM_TO_REG; \ PL_top_env = &cur_env; \ cur_env.je_mustcatch = FALSE; \ (v) = cur_env.je_ret; \ } STMT_END #define JMPENV_POP \ STMT_START { \ DEBUG_l({ \ int i = -1; JMPENV *p = PL_top_env; \ while (p) { i++; p = p->je_prev; } \ Perl_deb(aTHX_ "JUMPENV_POP level=%d at %s:%d\n", \ i, __FILE__, __LINE__);}) \ assert(PL_top_env == &cur_env); \ PL_top_env = cur_env.je_prev; \ } STMT_END #define JMPENV_JUMP(v) \ STMT_START { \ DEBUG_l({ \ int i = -1; JMPENV *p = PL_top_env; \ while (p) { i++; p = p->je_prev; } \ Perl_deb(aTHX_ "JUMPENV_JUMP(%d) level=%d at %s:%d\n", \ (int)v, i, __FILE__, __LINE__);}) \ OP_REG_TO_MEM; \ if (PL_top_env->je_prev) \ PerlProc_longjmp(PL_top_env->je_buf, (v)); \ if ((v) == 2) \ PerlProc_exit(STATUS_EXIT); \ PerlIO_printf(PerlIO_stderr(), "panic: top_env, v=%d\n", (int)v); \ PerlProc_exit(1); \ } STMT_END #define CATCH_GET (PL_top_env->je_mustcatch) #define CATCH_SET(v) \ STMT_START { \ DEBUG_l( \ Perl_deb(aTHX_ \ "JUMPLEVEL set catch %d => %d (for %p) at %s:%d\n", \ PL_top_env->je_mustcatch, v, (void*)PL_top_env, \ __FILE__, __LINE__);) \ PL_top_env->je_mustcatch = (v); \ } STMT_END /* =head1 COP Hint Hashes */ typedef struct refcounted_he COPHH; #define COPHH_KEY_UTF8 REFCOUNTED_HE_KEY_UTF8 /* =for apidoc Amx|SV *|cophh_fetch_pvn|const COPHH *cophh|const char *keypv|STRLEN keylen|U32 hash|U32 flags Look up the entry in the cop hints hash I with the key specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar copy of the value associated with the key, or C<&PL_sv_placeholder> if there is no value associated with the key. =cut */ #define cophh_fetch_pvn(cophh, keypv, keylen, hash, flags) \ Perl_refcounted_he_fetch_pvn(aTHX_ cophh, keypv, keylen, hash, flags) /* =for apidoc Amx|SV *|cophh_fetch_pvs|const COPHH *cophh|const char *key|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define cophh_fetch_pvs(cophh, key, flags) \ Perl_refcounted_he_fetch_pvn(aTHX_ cophh, STR_WITH_LEN(key), 0, flags) /* =for apidoc Amx|SV *|cophh_fetch_pv|const COPHH *cophh|const char *key|U32 hash|U32 flags Like L, but takes a nul-terminated string instead of a string/length pair. =cut */ #define cophh_fetch_pv(cophh, key, hash, flags) \ Perl_refcounted_he_fetch_pv(aTHX_ cophh, key, hash, flags) /* =for apidoc Amx|SV *|cophh_fetch_sv|const COPHH *cophh|SV *key|U32 hash|U32 flags Like L, but takes a Perl scalar instead of a string/length pair. =cut */ #define cophh_fetch_sv(cophh, key, hash, flags) \ Perl_refcounted_he_fetch_sv(aTHX_ cophh, key, hash, flags) /* =for apidoc Amx|HV *|cophh_2hv|const COPHH *cophh|U32 flags Generates and returns a standard Perl hash representing the full set of key/value pairs in the cop hints hash I. I is currently unused and must be zero. =cut */ #define cophh_2hv(cophh, flags) \ Perl_refcounted_he_chain_2hv(aTHX_ cophh, flags) /* =for apidoc Amx|COPHH *|cophh_copy|COPHH *cophh Make and return a complete copy of the cop hints hash I. =cut */ #define cophh_copy(cophh) Perl_refcounted_he_inc(aTHX_ cophh) /* =for apidoc Amx|void|cophh_free|COPHH *cophh Discard the cop hints hash I, freeing all resources associated with it. =cut */ #define cophh_free(cophh) Perl_refcounted_he_free(aTHX_ cophh) /* =for apidoc Amx|COPHH *|cophh_new_empty Generate and return a fresh cop hints hash containing no entries. =cut */ #define cophh_new_empty() ((COPHH *)NULL) /* =for apidoc Amx|COPHH *|cophh_store_pvn|COPHH *cophh|const char *keypv|STRLEN keylen|U32 hash|SV *value|U32 flags Stores a value, associated with a key, in the cop hints hash I, and returns the modified hash. The returned hash pointer is in general not the same as the hash pointer that was passed in. The input hash is consumed by the function, and the pointer to it must not be subsequently used. Use L if you need both hashes. The key is specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. I is the scalar value to store for this key. I is copied by this function, which thus does not take ownership of any reference to it, and later changes to the scalar will not be reflected in the value visible in the cop hints hash. Complex types of scalar will not be stored with referential integrity, but will be coerced to strings. =cut */ #define cophh_store_pvn(cophh, keypv, keylen, hash, value, flags) \ Perl_refcounted_he_new_pvn(aTHX_ cophh, keypv, keylen, hash, value, flags) /* =for apidoc Amx|COPHH *|cophh_store_pvs|const COPHH *cophh|const char *key|SV *value|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define cophh_store_pvs(cophh, key, value, flags) \ Perl_refcounted_he_new_pvn(aTHX_ cophh, STR_WITH_LEN(key), 0, value, flags) /* =for apidoc Amx|COPHH *|cophh_store_pv|const COPHH *cophh|const char *key|U32 hash|SV *value|U32 flags Like L, but takes a nul-terminated string instead of a string/length pair. =cut */ #define cophh_store_pv(cophh, key, hash, value, flags) \ Perl_refcounted_he_new_pv(aTHX_ cophh, key, hash, value, flags) /* =for apidoc Amx|COPHH *|cophh_store_sv|const COPHH *cophh|SV *key|U32 hash|SV *value|U32 flags Like L, but takes a Perl scalar instead of a string/length pair. =cut */ #define cophh_store_sv(cophh, key, hash, value, flags) \ Perl_refcounted_he_new_sv(aTHX_ cophh, key, hash, value, flags) /* =for apidoc Amx|COPHH *|cophh_delete_pvn|COPHH *cophh|const char *keypv|STRLEN keylen|U32 hash|U32 flags Delete a key and its associated value from the cop hints hash I, and returns the modified hash. The returned hash pointer is in general not the same as the hash pointer that was passed in. The input hash is consumed by the function, and the pointer to it must not be subsequently used. Use L if you need both hashes. The key is specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. =cut */ #define cophh_delete_pvn(cophh, keypv, keylen, hash, flags) \ Perl_refcounted_he_new_pvn(aTHX_ cophh, keypv, keylen, hash, \ (SV *)NULL, flags) /* =for apidoc Amx|COPHH *|cophh_delete_pvs|const COPHH *cophh|const char *key|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define cophh_delete_pvs(cophh, key, flags) \ Perl_refcounted_he_new_pvn(aTHX_ cophh, STR_WITH_LEN(key), 0, \ (SV *)NULL, flags) /* =for apidoc Amx|COPHH *|cophh_delete_pv|const COPHH *cophh|const char *key|U32 hash|U32 flags Like L, but takes a nul-terminated string instead of a string/length pair. =cut */ #define cophh_delete_pv(cophh, key, hash, flags) \ Perl_refcounted_he_new_pv(aTHX_ cophh, key, hash, (SV *)NULL, flags) /* =for apidoc Amx|COPHH *|cophh_delete_sv|const COPHH *cophh|SV *key|U32 hash|U32 flags Like L, but takes a Perl scalar instead of a string/length pair. =cut */ #define cophh_delete_sv(cophh, key, hash, flags) \ Perl_refcounted_he_new_sv(aTHX_ cophh, key, hash, (SV *)NULL, flags) #include "mydtrace.h" struct cop { BASEOP /* On LP64 putting this here takes advantage of the fact that BASEOP isn't an exact multiple of 8 bytes to save structure padding. */ line_t cop_line; /* line # of this command */ /* label for this construct is now stored in cop_hints_hash */ #ifdef USE_ITHREADS char * cop_stashpv; /* package line was compiled in */ char * cop_file; /* file name the following line # is from */ I32 cop_stashlen; /* negative for UTF8 */ #else HV * cop_stash; /* package line was compiled in */ GV * cop_filegv; /* file the following line # is from */ #endif U32 cop_hints; /* hints bits from pragmata */ U32 cop_seq; /* parse sequence number */ /* Beware. mg.c and warnings.pl assume the type of this is STRLEN *: */ STRLEN * cop_warnings; /* lexical warnings bitmask */ /* compile time state of %^H. See the comment in op.c for how this is used to recreate a hash to return from caller. */ COPHH * cop_hints_hash; }; #ifdef USE_ITHREADS # define CopFILE(c) ((c)->cop_file) # define CopFILEGV(c) (CopFILE(c) \ ? gv_fetchfile(CopFILE(c)) : NULL) # ifdef NETWARE # define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) # define CopFILE_setn(c,pv,l) ((c)->cop_file = savepv((pv),(l))) # else # define CopFILE_set(c,pv) ((c)->cop_file = savesharedpv(pv)) # define CopFILE_setn(c,pv,l) ((c)->cop_file = savesharedpvn((pv),(l))) # endif # define CopFILESV(c) (CopFILE(c) \ ? GvSV(gv_fetchfile(CopFILE(c))) : NULL) # define CopFILEAV(c) (CopFILE(c) \ ? GvAV(gv_fetchfile(CopFILE(c))) : NULL) # ifdef DEBUGGING # define CopFILEAVx(c) (assert(CopFILE(c)), \ GvAV(gv_fetchfile(CopFILE(c)))) # else # define CopFILEAVx(c) (GvAV(gv_fetchfile(CopFILE(c)))) # endif # define CopSTASHPV(c) ((c)->cop_stashpv) # ifdef NETWARE # define CopSTASHPV_set(c,pv,n) ((c)->cop_stashpv = \ ((pv) ? savepvn(pv,n) : NULL)) # else # define CopSTASHPV_set(c,pv,n) ((c)->cop_stashpv = (pv) \ ? savesharedpvn(pv,n) : NULL) # endif # define CopSTASH_len_set(c,n) ((c)->cop_stashlen = (n)) # define CopSTASH_len(c) ((c)->cop_stashlen) # define CopSTASH(c) (CopSTASHPV(c) \ ? gv_stashpvn(CopSTASHPV(c), \ CopSTASH_len(c) < 0 \ ? -CopSTASH_len(c) \ : CopSTASH_len(c), \ GV_ADD|SVf_UTF8*(CopSTASH_len(c) < 0) \ ) \ : NULL) # define CopSTASH_set(c,hv) (CopSTASHPV_set(c, \ (hv) ? HvNAME_get(hv) : NULL, \ (hv) ? HvNAMELEN(hv) : 0), \ CopSTASH_len_set(c, \ (hv) ? HvNAMEUTF8(hv) \ ? -HvNAMELEN(hv) \ : HvNAMELEN(hv) \ : 0)) # define CopSTASH_eq(c,hv) ((hv) && stashpv_hvname_match(c,hv)) # ifdef NETWARE # define CopSTASH_free(c) SAVECOPSTASH_FREE(c) # define CopFILE_free(c) SAVECOPFILE_FREE(c) # else # define CopSTASH_free(c) PerlMemShared_free(CopSTASHPV(c)) # define CopFILE_free(c) (PerlMemShared_free(CopFILE(c)),(CopFILE(c) = NULL)) # endif #else # define CopFILEGV(c) ((c)->cop_filegv) # define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) # define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) # define CopFILE_setn(c,pv,l) CopFILEGV_set((c), gv_fetchfile_flags((pv),(l),0)) # define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : NULL) # define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : NULL) # ifdef DEBUGGING # define CopFILEAVx(c) (assert(CopFILEGV(c)), GvAV(CopFILEGV(c))) # else # define CopFILEAVx(c) (GvAV(CopFILEGV(c))) # endif # define CopFILE(c) (CopFILEGV(c) && GvSV(CopFILEGV(c)) \ ? SvPVX(GvSV(CopFILEGV(c))) : NULL) # define CopSTASH(c) ((c)->cop_stash) # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) # define CopSTASHPV(c) (CopSTASH(c) ? HvNAME_get(CopSTASH(c)) : NULL) /* cop_stash is not refcounted */ # define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) # define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) # define CopSTASH_free(c) # define CopFILE_free(c) (SvREFCNT_dec(CopFILEGV(c)),(CopFILEGV(c) = NULL)) #endif /* USE_ITHREADS */ #define CopHINTHASH_get(c) ((COPHH*)((c)->cop_hints_hash)) #define CopHINTHASH_set(c,h) ((c)->cop_hints_hash = (h)) /* =head1 COP Hint Reading */ /* =for apidoc Am|SV *|cop_hints_fetch_pvn|const COP *cop|const char *keypv|STRLEN keylen|U32 hash|U32 flags Look up the hint entry in the cop I with the key specified by I and I. If I has the C bit set, the key octets are interpreted as UTF-8, otherwise they are interpreted as Latin-1. I is a precomputed hash of the key string, or zero if it has not been precomputed. Returns a mortal scalar copy of the value associated with the key, or C<&PL_sv_placeholder> if there is no value associated with the key. =cut */ #define cop_hints_fetch_pvn(cop, keypv, keylen, hash, flags) \ cophh_fetch_pvn(CopHINTHASH_get(cop), keypv, keylen, hash, flags) /* =for apidoc Am|SV *|cop_hints_fetch_pvs|const COP *cop|const char *key|U32 flags Like L, but takes a literal string instead of a string/length pair, and no precomputed hash. =cut */ #define cop_hints_fetch_pvs(cop, key, flags) \ cophh_fetch_pvs(CopHINTHASH_get(cop), key, flags) /* =for apidoc Am|SV *|cop_hints_fetch_pv|const COP *cop|const char *key|U32 hash|U32 flags Like L, but takes a nul-terminated string instead of a string/length pair. =cut */ #define cop_hints_fetch_pv(cop, key, hash, flags) \ cophh_fetch_pv(CopHINTHASH_get(cop), key, hash, flags) /* =for apidoc Am|SV *|cop_hints_fetch_sv|const COP *cop|SV *key|U32 hash|U32 flags Like L, but takes a Perl scalar instead of a string/length pair. =cut */ #define cop_hints_fetch_sv(cop, key, hash, flags) \ cophh_fetch_sv(CopHINTHASH_get(cop), key, hash, flags) /* =for apidoc Am|HV *|cop_hints_2hv|const COP *cop|U32 flags Generates and returns a standard Perl hash representing the full set of hint entries in the cop I. I is currently unused and must be zero. =cut */ #define cop_hints_2hv(cop, flags) \ cophh_2hv(CopHINTHASH_get(cop), flags) #define CopLABEL(c) Perl_cop_fetch_label(aTHX_ (c), NULL, NULL) #define CopLABEL_len(c,len) Perl_cop_fetch_label(aTHX_ (c), len, NULL) #define CopLABEL_len_flags(c,len,flags) Perl_cop_fetch_label(aTHX_ (c), len, flags) #define CopLABEL_alloc(pv) ((pv)?savepv(pv):NULL) #define CopSTASH_ne(c,hv) (!CopSTASH_eq(c,hv)) #define CopLINE(c) ((c)->cop_line) #define CopLINE_inc(c) (++CopLINE(c)) #define CopLINE_dec(c) (--CopLINE(c)) #define CopLINE_set(c,l) (CopLINE(c) = (l)) /* OutCopFILE() is CopFILE for output (caller, die, warn, etc.) */ #define OutCopFILE(c) CopFILE(c) /* FIXME NATIVE_HINTS if this is changed from op_private (see perl.h) */ #define CopHINTS_get(c) ((c)->cop_hints + 0) #define CopHINTS_set(c, h) STMT_START { \ (c)->cop_hints = (h); \ } STMT_END /* * Here we have some enormously heavy (or at least ponderous) wizardry. */ /* subroutine context */ struct block_sub { OP * retop; /* op to execute on exit from sub */ /* Above here is the same for sub, format and eval. */ CV * cv; /* Above here is the same for sub and format. */ AV * savearray; AV * argarray; I32 olddepth; PAD *oldcomppad; }; /* format context */ struct block_format { OP * retop; /* op to execute on exit from sub */ /* Above here is the same for sub, format and eval. */ CV * cv; /* Above here is the same for sub and format. */ GV * gv; GV * dfoutgv; }; /* base for the next two macros. Don't use directly. * Note that the refcnt of the cv is incremented twice; The CX one is * decremented by LEAVESUB, the other by LEAVE. */ #define PUSHSUB_BASE(cx) \ ENTRY_PROBE(GvENAME(CvGV(cv)), \ CopFILE((const COP *)CvSTART(cv)), \ CopLINE((const COP *)CvSTART(cv)), \ CopSTASHPV((const COP *)CvSTART(cv))); \ \ cx->blk_sub.cv = cv; \ cx->blk_sub.olddepth = CvDEPTH(cv); \ cx->cx_type |= (hasargs) ? CXp_HASARGS : 0; \ cx->blk_sub.retop = NULL; \ if (!CvDEPTH(cv)) { \ SvREFCNT_inc_simple_void_NN(cv); \ SvREFCNT_inc_simple_void_NN(cv); \ SAVEFREESV(cv); \ } #define PUSHSUB(cx) \ { \ /* If the context is indeterminate, then only the lvalue */ \ /* flags that the caller also has are applicable. */ \ U8 phlags = \ (PL_op->op_flags & OPf_WANT) \ ? OPpENTERSUB_LVAL_MASK \ : !(PL_op->op_private & OPpENTERSUB_LVAL_MASK) \ ? 0 : Perl_was_lvalue_sub(aTHX); \ PUSHSUB_BASE(cx) \ cx->blk_u16 = PL_op->op_private & \ (phlags|OPpDEREF); \ } /* variant for use by OP_DBSTATE, where op_private holds hint bits */ #define PUSHSUB_DB(cx) \ PUSHSUB_BASE(cx) \ cx->blk_u16 = 0; #define PUSHFORMAT(cx, retop) \ cx->blk_format.cv = cv; \ cx->blk_format.gv = gv; \ cx->blk_format.retop = (retop); \ cx->blk_format.dfoutgv = PL_defoutgv; \ SvREFCNT_inc_void(cx->blk_format.dfoutgv) #define POP_SAVEARRAY() \ STMT_START { \ SvREFCNT_dec(GvAV(PL_defgv)); \ GvAV(PL_defgv) = cx->blk_sub.savearray; \ } STMT_END /* junk in @_ spells trouble when cloning CVs and in pp_caller(), so don't * leave any (a fast av_clear(ary), basically) */ #define CLEAR_ARGARRAY(ary) \ STMT_START { \ AvMAX(ary) += AvARRAY(ary) - AvALLOC(ary); \ AvARRAY(ary) = AvALLOC(ary); \ AvFILLp(ary) = -1; \ } STMT_END #define POPSUB(cx,sv) \ STMT_START { \ RETURN_PROBE(GvENAME(CvGV((const CV*)cx->blk_sub.cv)), \ CopFILE((COP*)CvSTART((const CV*)cx->blk_sub.cv)), \ CopLINE((COP*)CvSTART((const CV*)cx->blk_sub.cv)), \ CopSTASHPV((COP*)CvSTART((const CV*)cx->blk_sub.cv))); \ \ if (CxHASARGS(cx)) { \ POP_SAVEARRAY(); \ /* abandon @_ if it got reified */ \ if (AvREAL(cx->blk_sub.argarray)) { \ const SSize_t fill = AvFILLp(cx->blk_sub.argarray); \ SvREFCNT_dec(cx->blk_sub.argarray); \ cx->blk_sub.argarray = newAV(); \ av_extend(cx->blk_sub.argarray, fill); \ AvREIFY_only(cx->blk_sub.argarray); \ CX_CURPAD_SV(cx->blk_sub, 0) = MUTABLE_SV(cx->blk_sub.argarray); \ } \ else { \ CLEAR_ARGARRAY(cx->blk_sub.argarray); \ } \ } \ sv = MUTABLE_SV(cx->blk_sub.cv); \ if (sv && (CvDEPTH((const CV*)sv) = cx->blk_sub.olddepth)) \ sv = NULL; \ } STMT_END #define LEAVESUB(sv) \ STMT_START { \ if (sv) \ SvREFCNT_dec(sv); \ } STMT_END #define POPFORMAT(cx) \ setdefout(cx->blk_format.dfoutgv); \ SvREFCNT_dec(cx->blk_format.dfoutgv); /* eval context */ struct block_eval { OP * retop; /* op to execute on exit from eval */ /* Above here is the same for sub, format and eval. */ SV * old_namesv; OP * old_eval_root; SV * cur_text; CV * cv; JMPENV * cur_top_env; /* value of PL_top_env when eval CX created */ }; /* If we ever need more than 512 op types, change the shift from 7. blku_gimme is actually also only 2 bits, so could be merged with something. */ #define CxOLD_IN_EVAL(cx) (((cx)->blk_u16) & 0x7F) #define CxOLD_OP_TYPE(cx) (((cx)->blk_u16) >> 7) #define PUSHEVAL(cx,n) \ STMT_START { \ assert(!(PL_in_eval & ~0x7F)); \ assert(!(PL_op->op_type & ~0x1FF)); \ cx->blk_u16 = (PL_in_eval & 0x7F) | ((U16)PL_op->op_type << 7); \ cx->blk_eval.old_namesv = (n ? newSVpv(n,0) : NULL); \ cx->blk_eval.old_eval_root = PL_eval_root; \ cx->blk_eval.cur_text = PL_parser ? PL_parser->linestr : NULL; \ cx->blk_eval.cv = NULL; /* set by doeval(), as applicable */ \ cx->blk_eval.retop = NULL; \ cx->blk_eval.cur_top_env = PL_top_env; \ } STMT_END #define POPEVAL(cx) \ STMT_START { \ PL_in_eval = CxOLD_IN_EVAL(cx); \ optype = CxOLD_OP_TYPE(cx); \ PL_eval_root = cx->blk_eval.old_eval_root; \ if (cx->blk_eval.old_namesv) \ sv_2mortal(cx->blk_eval.old_namesv); \ } STMT_END /* loop context */ struct block_loop { I32 resetsp; LOOP * my_op; /* My op, that contains redo, next and last ops. */ union { /* different ways of locating the iteration variable */ SV **svp; GV *gv; PAD *oldcomppad; /* only used in ITHREADS */ } itervar_u; union { struct { /* valid if type is LOOP_FOR or LOOP_PLAIN (but {NULL,0})*/ AV * ary; /* use the stack if this is NULL */ IV ix; } ary; struct { /* valid if type is LOOP_LAZYIV */ IV cur; IV end; } lazyiv; struct { /* valid if type if LOOP_LAZYSV */ SV * cur; SV * end; /* maxiumum value (or minimum in reverse) */ } lazysv; } state_u; }; #ifdef USE_ITHREADS # define CxITERVAR_PADSV(c) \ &CX_CURPAD_SV( (c)->blk_loop.itervar_u, (c)->blk_loop.my_op->op_targ) #else # define CxITERVAR_PADSV(c) ((c)->blk_loop.itervar_u.svp) #endif #define CxITERVAR(c) \ ((c)->blk_loop.itervar_u.oldcomppad \ ? (CxPADLOOP(c) \ ? CxITERVAR_PADSV(c) \ : &GvSV((c)->blk_loop.itervar_u.gv)) \ : (SV**)NULL) #define CxLABEL(c) (0 + CopLABEL((c)->blk_oldcop)) #define CxLABEL_len(c,len) (0 + CopLABEL_len((c)->blk_oldcop, len)) #define CxLABEL_len_flags(c,len,flags) (0 + CopLABEL_len_flags((c)->blk_oldcop, len, flags)) #define CxHASARGS(c) (((c)->cx_type & CXp_HASARGS) == CXp_HASARGS) #define CxLVAL(c) (0 + (c)->blk_u16) #define PUSHLOOP_PLAIN(cx, s) \ cx->blk_loop.resetsp = s - PL_stack_base; \ cx->blk_loop.my_op = cLOOP; \ cx->blk_loop.state_u.ary.ary = NULL; \ cx->blk_loop.state_u.ary.ix = 0; \ cx->blk_loop.itervar_u.svp = NULL; #define PUSHLOOP_FOR(cx, ivar, s) \ cx->blk_loop.resetsp = s - PL_stack_base; \ cx->blk_loop.my_op = cLOOP; \ cx->blk_loop.state_u.ary.ary = NULL; \ cx->blk_loop.state_u.ary.ix = 0; \ cx->blk_loop.itervar_u.svp = (SV**)(ivar); #define POPLOOP(cx) \ if (CxTYPE(cx) == CXt_LOOP_LAZYSV) { \ SvREFCNT_dec(cx->blk_loop.state_u.lazysv.cur); \ SvREFCNT_dec(cx->blk_loop.state_u.lazysv.end); \ } \ if (CxTYPE(cx) == CXt_LOOP_FOR) \ SvREFCNT_dec(cx->blk_loop.state_u.ary.ary); /* given/when context */ struct block_givwhen { OP *leave_op; }; #define PUSHGIVEN(cx) \ cx->blk_givwhen.leave_op = cLOGOP->op_other; #define PUSHWHEN PUSHGIVEN /* context common to subroutines, evals and loops */ struct block { U8 blku_type; /* what kind of context this is */ U8 blku_gimme; /* is this block running in list context? */ U16 blku_u16; /* used by block_sub and block_eval (so far) */ I32 blku_oldsp; /* stack pointer to copy stuff down to */ COP * blku_oldcop; /* old curcop pointer */ I32 blku_oldmarksp; /* mark stack index */ I32 blku_oldscopesp; /* scope stack index */ PMOP * blku_oldpm; /* values of pattern match vars */ union { struct block_sub blku_sub; struct block_format blku_format; struct block_eval blku_eval; struct block_loop blku_loop; struct block_givwhen blku_givwhen; } blk_u; }; #define blk_oldsp cx_u.cx_blk.blku_oldsp #define blk_oldcop cx_u.cx_blk.blku_oldcop #define blk_oldmarksp cx_u.cx_blk.blku_oldmarksp #define blk_oldscopesp cx_u.cx_blk.blku_oldscopesp #define blk_oldpm cx_u.cx_blk.blku_oldpm #define blk_gimme cx_u.cx_blk.blku_gimme #define blk_u16 cx_u.cx_blk.blku_u16 #define blk_sub cx_u.cx_blk.blk_u.blku_sub #define blk_format cx_u.cx_blk.blk_u.blku_format #define blk_eval cx_u.cx_blk.blk_u.blku_eval #define blk_loop cx_u.cx_blk.blk_u.blku_loop #define blk_givwhen cx_u.cx_blk.blk_u.blku_givwhen #define DEBUG_CX(action) \ DEBUG_l( \ Perl_deb(aTHX_ "CX %ld %s %s (scope %ld,%ld) at %s:%d\n", \ (long)cxstack_ix, \ action, \ PL_block_type[CxTYPE(&cxstack[cxstack_ix])], \ (long)PL_scopestack_ix, \ (long)(cxstack[cxstack_ix].blk_oldscopesp), \ __FILE__, __LINE__)); /* Enter a block. */ #define PUSHBLOCK(cx,t,sp) CXINC, cx = &cxstack[cxstack_ix], \ cx->cx_type = t, \ cx->blk_oldsp = sp - PL_stack_base, \ cx->blk_oldcop = PL_curcop, \ cx->blk_oldmarksp = PL_markstack_ptr - PL_markstack, \ cx->blk_oldscopesp = PL_scopestack_ix, \ cx->blk_oldpm = PL_curpm, \ cx->blk_gimme = (U8)gimme; \ DEBUG_CX("PUSH"); /* Exit a block (RETURN and LAST). */ #define POPBLOCK(cx,pm) \ DEBUG_CX("POP"); \ cx = &cxstack[cxstack_ix--], \ newsp = PL_stack_base + cx->blk_oldsp, \ PL_curcop = cx->blk_oldcop, \ PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp, \ PL_scopestack_ix = cx->blk_oldscopesp, \ pm = cx->blk_oldpm, \ gimme = cx->blk_gimme; /* Continue a block elsewhere (NEXT and REDO). */ #define TOPBLOCK(cx) \ DEBUG_CX("TOP"); \ cx = &cxstack[cxstack_ix], \ PL_stack_sp = PL_stack_base + cx->blk_oldsp, \ PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp, \ PL_scopestack_ix = cx->blk_oldscopesp, \ PL_curpm = cx->blk_oldpm; /* substitution context */ struct subst { U8 sbu_type; /* what kind of context this is */ U8 sbu_rflags; U16 sbu_rxtainted; /* matches struct block */ I32 sbu_iters; I32 sbu_maxiters; I32 sbu_oldsave; char * sbu_orig; SV * sbu_dstr; SV * sbu_targ; char * sbu_s; char * sbu_m; char * sbu_strend; void * sbu_rxres; REGEXP * sbu_rx; }; #define sb_iters cx_u.cx_subst.sbu_iters #define sb_maxiters cx_u.cx_subst.sbu_maxiters #define sb_rflags cx_u.cx_subst.sbu_rflags #define sb_oldsave cx_u.cx_subst.sbu_oldsave #define sb_rxtainted cx_u.cx_subst.sbu_rxtainted #define sb_orig cx_u.cx_subst.sbu_orig #define sb_dstr cx_u.cx_subst.sbu_dstr #define sb_targ cx_u.cx_subst.sbu_targ #define sb_s cx_u.cx_subst.sbu_s #define sb_m cx_u.cx_subst.sbu_m #define sb_strend cx_u.cx_subst.sbu_strend #define sb_rxres cx_u.cx_subst.sbu_rxres #define sb_rx cx_u.cx_subst.sbu_rx #ifdef PERL_CORE # define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix], \ cx->sb_iters = iters, \ cx->sb_maxiters = maxiters, \ cx->sb_rflags = r_flags, \ cx->sb_oldsave = oldsave, \ cx->sb_rxtainted = rxtainted, \ cx->sb_orig = orig, \ cx->sb_dstr = dstr, \ cx->sb_targ = targ, \ cx->sb_s = s, \ cx->sb_m = m, \ cx->sb_strend = strend, \ cx->sb_rxres = NULL, \ cx->sb_rx = rx, \ cx->cx_type = CXt_SUBST | (once ? CXp_ONCE : 0); \ rxres_save(&cx->sb_rxres, rx); \ (void)ReREFCNT_inc(rx) # define POPSUBST(cx) cx = &cxstack[cxstack_ix--]; \ rxres_free(&cx->sb_rxres); \ ReREFCNT_dec(cx->sb_rx) #endif #define CxONCE(cx) ((cx)->cx_type & CXp_ONCE) struct context { union { struct block cx_blk; struct subst cx_subst; } cx_u; }; #define cx_type cx_u.cx_subst.sbu_type /* If you re-order these, there is also an array of uppercase names in perl.h and a static array of context names in pp_ctl.c */ #define CXTYPEMASK 0xf #define CXt_NULL 0 #define CXt_WHEN 1 #define CXt_BLOCK 2 /* When micro-optimising :-) keep GIVEN next to the LOOPs, as these 5 share a jump table in pp_ctl.c The first 4 don't have a 'case' in at least one switch statement in pp_ctl.c */ #define CXt_GIVEN 3 /* This is first so that CXt_LOOP_FOR|CXt_LOOP_LAZYIV is CXt_LOOP_LAZYIV */ #define CXt_LOOP_FOR 4 #define CXt_LOOP_PLAIN 5 #define CXt_LOOP_LAZYSV 6 #define CXt_LOOP_LAZYIV 7 #define CXt_SUB 8 #define CXt_FORMAT 9 #define CXt_EVAL 10 #define CXt_SUBST 11 /* SUBST doesn't feature in all switch statements. */ /* private flags for CXt_SUB and CXt_NULL However, this is checked in many places which do not check the type, so this bit needs to be kept clear for most everything else. For reasons I haven't investigated, it can coexist with CXp_FOR_DEF */ #define CXp_MULTICALL 0x10 /* part of a multicall (so don't tear down context on exit). */ /* private flags for CXt_SUB and CXt_FORMAT */ #define CXp_HASARGS 0x20 /* private flags for CXt_EVAL */ #define CXp_REAL 0x20 /* truly eval'', not a lookalike */ #define CXp_TRYBLOCK 0x40 /* eval{}, not eval'' or similar */ /* private flags for CXt_LOOP */ #define CXp_FOR_DEF 0x10 /* foreach using $_ */ #define CxPADLOOP(c) ((c)->blk_loop.my_op->op_targ) /* private flags for CXt_SUBST */ #define CXp_ONCE 0x10 /* What was sbu_once in struct subst */ #define CxTYPE(c) ((c)->cx_type & CXTYPEMASK) #define CxTYPE_is_LOOP(c) (((c)->cx_type & 0xC) == 0x4) #define CxMULTICALL(c) (((c)->cx_type & CXp_MULTICALL) \ == CXp_MULTICALL) #define CxREALEVAL(c) (((c)->cx_type & (CXTYPEMASK|CXp_REAL)) \ == (CXt_EVAL|CXp_REAL)) #define CxTRYBLOCK(c) (((c)->cx_type & (CXTYPEMASK|CXp_TRYBLOCK)) \ == (CXt_EVAL|CXp_TRYBLOCK)) #define CxFOREACH(c) (CxTYPE_is_LOOP(c) && CxTYPE(c) != CXt_LOOP_PLAIN) #define CxFOREACHDEF(c) ((CxTYPE_is_LOOP(c) && CxTYPE(c) != CXt_LOOP_PLAIN) \ && ((c)->cx_type & CXp_FOR_DEF)) #define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc())) /* =head1 "Gimme" Values */ /* =for apidoc AmU||G_SCALAR Used to indicate scalar context. See C, C, and L. =for apidoc AmU||G_ARRAY Used to indicate list context. See C, C and L. =for apidoc AmU||G_VOID Used to indicate void context. See C and L. =for apidoc AmU||G_DISCARD Indicates that arguments returned from a callback should be discarded. See L. =for apidoc AmU||G_EVAL Used to force a Perl C wrapper around a callback. See L. =for apidoc AmU||G_NOARGS Indicates that no arguments are being sent to a callback. See L. =cut */ #define G_SCALAR 2 #define G_ARRAY 3 #define G_VOID 1 #define G_WANT 3 /* extra flags for Perl_call_* routines */ #define G_DISCARD 4 /* Call FREETMPS. Don't change this without consulting the hash actions codes defined in hv.h */ #define G_EVAL 8 /* Assume eval {} around subroutine call. */ #define G_NOARGS 16 /* Don't construct a @_ array. */ #define G_KEEPERR 32 /* Warn for errors, don't overwrite $@ */ #define G_NODEBUG 64 /* Disable debugging at toplevel. */ #define G_METHOD 128 /* Calling method. */ #define G_FAKINGEVAL 256 /* Faking an eval context for call_sv or fold_constants. */ #define G_UNDEF_FILL 512 /* Fill the stack with &PL_sv_undef A special case for UNSHIFT in Perl_magic_methcall(). */ #define G_WRITING_TO_STDERR 1024 /* Perl_write_to_stderr() is calling Perl_magic_methcall(). */ /* flag bits for PL_in_eval */ #define EVAL_NULL 0 /* not in an eval */ #define EVAL_INEVAL 1 /* some enclosing scope is an eval */ #define EVAL_WARNONLY 2 /* used by yywarn() when calling yyerror() */ #define EVAL_KEEPERR 4 /* set by Perl_call_sv if G_KEEPERR */ #define EVAL_INREQUIRE 8 /* The code is being required. */ /* Support for switching (stack and block) contexts. * This ensures magic doesn't invalidate local stack and cx pointers. */ #define PERLSI_UNKNOWN -1 #define PERLSI_UNDEF 0 #define PERLSI_MAIN 1 #define PERLSI_MAGIC 2 #define PERLSI_SORT 3 #define PERLSI_SIGNAL 4 #define PERLSI_OVERLOAD 5 #define PERLSI_DESTROY 6 #define PERLSI_WARNHOOK 7 #define PERLSI_DIEHOOK 8 #define PERLSI_REQUIRE 9 struct stackinfo { AV * si_stack; /* stack for current runlevel */ PERL_CONTEXT * si_cxstack; /* context stack for runlevel */ struct stackinfo * si_prev; struct stackinfo * si_next; I32 si_cxix; /* current context index */ I32 si_cxmax; /* maximum allocated index */ I32 si_type; /* type of runlevel */ I32 si_markoff; /* offset where markstack begins for us. * currently used only with DEBUGGING, * but not #ifdef-ed for bincompat */ }; typedef struct stackinfo PERL_SI; #define cxstack (PL_curstackinfo->si_cxstack) #define cxstack_ix (PL_curstackinfo->si_cxix) #define cxstack_max (PL_curstackinfo->si_cxmax) #ifdef DEBUGGING # define SET_MARK_OFFSET \ PL_curstackinfo->si_markoff = PL_markstack_ptr - PL_markstack #else # define SET_MARK_OFFSET NOOP #endif #define PUSHSTACKi(type) \ STMT_START { \ PERL_SI *next = PL_curstackinfo->si_next; \ DEBUG_l({ \ int i = 0; PERL_SI *p = PL_curstackinfo; \ while (p) { i++; p = p->si_prev; } \ Perl_deb(aTHX_ "push STACKINFO %d at %s:%d\n", \ i, __FILE__, __LINE__);}) \ if (!next) { \ next = new_stackinfo(32, 2048/sizeof(PERL_CONTEXT) - 1); \ next->si_prev = PL_curstackinfo; \ PL_curstackinfo->si_next = next; \ } \ next->si_type = type; \ next->si_cxix = -1; \ AvFILLp(next->si_stack) = 0; \ SWITCHSTACK(PL_curstack,next->si_stack); \ PL_curstackinfo = next; \ SET_MARK_OFFSET; \ } STMT_END #define PUSHSTACK PUSHSTACKi(PERLSI_UNKNOWN) /* POPSTACK works with PL_stack_sp, so it may need to be bracketed by * PUTBACK/SPAGAIN to flush/refresh any local SP that may be active */ #define POPSTACK \ STMT_START { \ dSP; \ PERL_SI * const prev = PL_curstackinfo->si_prev; \ DEBUG_l({ \ int i = -1; PERL_SI *p = PL_curstackinfo; \ while (p) { i++; p = p->si_prev; } \ Perl_deb(aTHX_ "pop STACKINFO %d at %s:%d\n", \ i, __FILE__, __LINE__);}) \ if (!prev) { \ PerlIO_printf(Perl_error_log, "panic: POPSTACK\n"); \ my_exit(1); \ } \ SWITCHSTACK(PL_curstack,prev->si_stack); \ /* don't free prev here, free them all at the END{} */ \ PL_curstackinfo = prev; \ } STMT_END #define POPSTACK_TO(s) \ STMT_START { \ while (PL_curstack != s) { \ dounwind(-1); \ POPSTACK; \ } \ } STMT_END #define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) #define IN_PERL_RUNTIME (PL_curcop != &PL_compiling) /* =head1 Multicall Functions =for apidoc Ams||dMULTICALL Declare local variables for a multicall. See L. =for apidoc Ams||PUSH_MULTICALL Opening bracket for a lightweight callback. See L. =for apidoc Ams||MULTICALL Make a lightweight callback. See L. =for apidoc Ams||POP_MULTICALL Closing bracket for a lightweight callback. See L. =cut */ #define dMULTICALL \ SV **newsp; /* set by POPBLOCK */ \ PERL_CONTEXT *cx; \ CV *multicall_cv; \ OP *multicall_cop; \ bool multicall_oldcatch; \ U8 hasargs = 0 /* used by PUSHSUB */ #define PUSH_MULTICALL(the_cv) \ STMT_START { \ CV * const _nOnclAshIngNamE_ = the_cv; \ CV * const cv = _nOnclAshIngNamE_; \ AV * const padlist = CvPADLIST(cv); \ ENTER; \ multicall_oldcatch = CATCH_GET; \ SAVETMPS; SAVEVPTR(PL_op); \ CATCH_SET(TRUE); \ PUSHSTACKi(PERLSI_SORT); \ PUSHBLOCK(cx, CXt_SUB|CXp_MULTICALL, PL_stack_sp); \ PUSHSUB(cx); \ if (++CvDEPTH(cv) >= 2) { \ PERL_STACK_OVERFLOW_CHECK(); \ Perl_pad_push(aTHX_ padlist, CvDEPTH(cv)); \ } \ SAVECOMPPAD(); \ PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv)); \ multicall_cv = cv; \ multicall_cop = CvSTART(cv); \ } STMT_END #define MULTICALL \ STMT_START { \ PL_op = multicall_cop; \ CALLRUNOPS(aTHX); \ } STMT_END #define POP_MULTICALL \ STMT_START { \ if (! --CvDEPTH(multicall_cv)) \ LEAVESUB(multicall_cv); \ POPBLOCK(cx,PL_curpm); \ POPSTACK; \ CATCH_SET(multicall_oldcatch); \ LEAVE; \ SPAGAIN; \ } STMT_END /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ& regnodes.hnuW+A/* -*- buffer-read-only: t -*- !!!!!!! DO NOT EDIT THIS FILE !!!!!!! This file is built by regen/regcomp.pl from regcomp.sym. Any changes made here will be lost! */ /* Regops and State definitions */ #define REGNODE_MAX 112 #define REGMATCH_STATE_MAX 152 #define END 0 /* 0000 End of program. */ #define SUCCEED 1 /* 0x01 Return from a subroutine, basically. */ #define BOL 2 /* 0x02 Match "" at beginning of line. */ #define MBOL 3 /* 0x03 Same, assuming multiline. */ #define SBOL 4 /* 0x04 Same, assuming singleline. */ #define EOS 5 /* 0x05 Match "" at end of string. */ #define EOL 6 /* 0x06 Match "" at end of line. */ #define MEOL 7 /* 0x07 Same, assuming multiline. */ #define SEOL 8 /* 0x08 Same, assuming singleline. */ #define BOUND 9 /* 0x09 Match "" at any word boundary using native charset semantics for non-utf8 */ #define BOUNDL 10 /* 0x0a Match "" at any locale word boundary */ #define BOUNDU 11 /* 0x0b Match "" at any word boundary using Unicode semantics */ #define BOUNDA 12 /* 0x0c Match "" at any word boundary using ASCII semantics */ #define NBOUND 13 /* 0x0d Match "" at any word non-boundary using native charset semantics for non-utf8 */ #define NBOUNDL 14 /* 0x0e Match "" at any locale word non-boundary */ #define NBOUNDU 15 /* 0x0f Match "" at any word non-boundary using Unicode semantics */ #define NBOUNDA 16 /* 0x10 Match "" at any word non-boundary using ASCII semantics */ #define GPOS 17 /* 0x11 Matches where last m//g left off. */ #define REG_ANY 18 /* 0x12 Match any one character (except newline). */ #define SANY 19 /* 0x13 Match any one character. */ #define CANY 20 /* 0x14 Match any one byte. */ #define ANYOF 21 /* 0x15 Match character in (or not in) this class, single char match only */ #define ANYOFV 22 /* 0x16 Match character in (or not in) this class, can match-multiple chars */ #define ALNUM 23 /* 0x17 Match any alphanumeric character using native charset semantics for non-utf8 */ #define ALNUML 24 /* 0x18 Match any alphanumeric char in locale */ #define ALNUMU 25 /* 0x19 Match any alphanumeric char using Unicode semantics */ #define ALNUMA 26 /* 0x1a Match [A-Za-z_0-9] */ #define NALNUM 27 /* 0x1b Match any non-alphanumeric character using native charset semantics for non-utf8 */ #define NALNUML 28 /* 0x1c Match any non-alphanumeric char in locale */ #define NALNUMU 29 /* 0x1d Match any non-alphanumeric char using Unicode semantics */ #define NALNUMA 30 /* 0x1e Match [^A-Za-z_0-9] */ #define SPACE 31 /* 0x1f Match any whitespace character using native charset semantics for non-utf8 */ #define SPACEL 32 /* 0x20 Match any whitespace char in locale */ #define SPACEU 33 /* 0x21 Match any whitespace char using Unicode semantics */ #define SPACEA 34 /* 0x22 Match [ \t\n\f\r] */ #define NSPACE 35 /* 0x23 Match any non-whitespace character using native charset semantics for non-utf8 */ #define NSPACEL 36 /* 0x24 Match any non-whitespace char in locale */ #define NSPACEU 37 /* 0x25 Match any non-whitespace char using Unicode semantics */ #define NSPACEA 38 /* 0x26 Match [^ \t\n\f\r] */ #define DIGIT 39 /* 0x27 Match any numeric character using native charset semantics for non-utf8 */ #define DIGITL 40 /* 0x28 Match any numeric character in locale */ #define DIGITA 41 /* 0x29 Match [0-9] */ #define NDIGIT 42 /* 0x2a Match any non-numeric character using native charset semantics for non-utf8 */ #define NDIGITL 43 /* 0x2b Match any non-numeric character in locale */ #define NDIGITA 44 /* 0x2c Match [^0-9] */ #define CLUMP 45 /* 0x2d Match any extended grapheme cluster sequence */ #define BRANCH 46 /* 0x2e Match this alternative, or the next... */ #define BACK 47 /* 0x2f Match "", "next" ptr points backward. */ #define EXACT 48 /* 0x30 Match this string (preceded by length). */ #define EXACTF 49 /* 0x31 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */ #define EXACTFL 50 /* 0x32 Match this string (not guaranteed to be folded) using /il rules (w/len). */ #define EXACTFU 51 /* 0x33 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */ #define EXACTFU_SS 52 /* 0x34 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */ #define EXACTFU_TRICKYFOLD 53 /* 0x35 Match this folded UTF-8 string using /iu rules */ #define EXACTFA 54 /* 0x36 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */ #define NOTHING 55 /* 0x37 Match empty string. */ #define TAIL 56 /* 0x38 Match empty string. Can jump here from outside. */ #define STAR 57 /* 0x39 Match this (simple) thing 0 or more times. */ #define PLUS 58 /* 0x3a Match this (simple) thing 1 or more times. */ #define CURLY 59 /* 0x3b Match this simple thing {n,m} times. */ #define CURLYN 60 /* 0x3c Capture next-after-this simple thing */ #define CURLYM 61 /* 0x3d Capture this medium-complex thing {n,m} times. */ #define CURLYX 62 /* 0x3e Match this complex thing {n,m} times. */ #define WHILEM 63 /* 0x3f Do curly processing and see if rest matches. */ #define OPEN 64 /* 0x40 Mark this point in input as start of */ #define CLOSE 65 /* 0x41 Analogous to OPEN. */ #define REF 66 /* 0x42 Match some already matched string */ #define REFF 67 /* 0x43 Match already matched string, folded using native charset semantics for non-utf8 */ #define REFFL 68 /* 0x44 Match already matched string, folded in loc. */ #define REFFU 69 /* 0x45 Match already matched string, folded using unicode semantics for non-utf8 */ #define REFFA 70 /* 0x46 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ #define NREF 71 /* 0x47 Match some already matched string */ #define NREFF 72 /* 0x48 Match already matched string, folded using native charset semantics for non-utf8 */ #define NREFFL 73 /* 0x49 Match already matched string, folded in loc. */ #define NREFFU 74 /* 0x4a Match already matched string, folded using unicode semantics for non-utf8 */ #define NREFFA 75 /* 0x4b Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */ #define IFMATCH 76 /* 0x4c Succeeds if the following matches. */ #define UNLESSM 77 /* 0x4d Fails if the following matches. */ #define SUSPEND 78 /* 0x4e "Independent" sub-RE. */ #define IFTHEN 79 /* 0x4f Switch, should be preceded by switcher . */ #define GROUPP 80 /* 0x50 Whether the group matched. */ #define LONGJMP 81 /* 0x51 Jump far away. */ #define BRANCHJ 82 /* 0x52 BRANCH with long offset. */ #define EVAL 83 /* 0x53 Execute some Perl code. */ #define MINMOD 84 /* 0x54 Next operator is not greedy. */ #define LOGICAL 85 /* 0x55 Next opcode should set the flag only. */ #define RENUM 86 /* 0x56 Group with independently numbered parens. */ #define TRIE 87 /* 0x57 Match many EXACT(F[ALU]?)? at once. flags==type */ #define TRIEC 88 /* 0x58 Same as TRIE, but with embedded charclass data */ #define AHOCORASICK 89 /* 0x59 Aho Corasick stclass. flags==type */ #define AHOCORASICKC 90 /* 0x5a Same as AHOCORASICK, but with embedded charclass data */ #define GOSUB 91 /* 0x5b recurse to paren arg1 at (signed) ofs arg2 */ #define GOSTART 92 /* 0x5c recurse to start of pattern */ #define NGROUPP 93 /* 0x5d Whether the group matched. */ #define INSUBP 94 /* 0x5e Whether we are in a specific recurse. */ #define DEFINEP 95 /* 0x5f Never execute directly. */ #define ENDLIKE 96 /* 0x60 Used only for the type field of verbs */ #define OPFAIL 97 /* 0x61 Same as (?!) */ #define ACCEPT 98 /* 0x62 Accepts the current matched string. */ #define VERB 99 /* 0x63 Used only for the type field of verbs */ #define PRUNE 100 /* 0x64 Pattern fails at this startpoint if no-backtracking through this */ #define MARKPOINT 101 /* 0x65 Push the current location for rollback by cut. */ #define SKIP 102 /* 0x66 On failure skip forward (to the mark) before retrying */ #define COMMIT 103 /* 0x67 Pattern fails outright if backtracking through this */ #define CUTGROUP 104 /* 0x68 On failure go to the next alternation in the group */ #define KEEPS 105 /* 0x69 $& begins here. */ #define LNBREAK 106 /* 0x6a generic newline pattern */ #define VERTWS 107 /* 0x6b vertical whitespace (Perl 6) */ #define NVERTWS 108 /* 0x6c not vertical whitespace (Perl 6) */ #define HORIZWS 109 /* 0x6d horizontal whitespace (Perl 6) */ #define NHORIZWS 110 /* 0x6e not horizontal whitespace (Perl 6) */ #define OPTIMIZED 111 /* 0x6f Placeholder for dump. */ #define PSEUDO 112 /* 0x70 Pseudo opcode for internal use. */ /* ------------ States ------------- */ #define TRIE_next (REGNODE_MAX + 1) /* state for TRIE */ #define TRIE_next_fail (REGNODE_MAX + 2) /* state for TRIE */ #define EVAL_AB (REGNODE_MAX + 3) /* state for EVAL */ #define EVAL_AB_fail (REGNODE_MAX + 4) /* state for EVAL */ #define CURLYX_end (REGNODE_MAX + 5) /* state for CURLYX */ #define CURLYX_end_fail (REGNODE_MAX + 6) /* state for CURLYX */ #define WHILEM_A_pre (REGNODE_MAX + 7) /* state for WHILEM */ #define WHILEM_A_pre_fail (REGNODE_MAX + 8) /* state for WHILEM */ #define WHILEM_A_min (REGNODE_MAX + 9) /* state for WHILEM */ #define WHILEM_A_min_fail (REGNODE_MAX + 10) /* state for WHILEM */ #define WHILEM_A_max (REGNODE_MAX + 11) /* state for WHILEM */ #define WHILEM_A_max_fail (REGNODE_MAX + 12) /* state for WHILEM */ #define WHILEM_B_min (REGNODE_MAX + 13) /* state for WHILEM */ #define WHILEM_B_min_fail (REGNODE_MAX + 14) /* state for WHILEM */ #define WHILEM_B_max (REGNODE_MAX + 15) /* state for WHILEM */ #define WHILEM_B_max_fail (REGNODE_MAX + 16) /* state for WHILEM */ #define BRANCH_next (REGNODE_MAX + 17) /* state for BRANCH */ #define BRANCH_next_fail (REGNODE_MAX + 18) /* state for BRANCH */ #define CURLYM_A (REGNODE_MAX + 19) /* state for CURLYM */ #define CURLYM_A_fail (REGNODE_MAX + 20) /* state for CURLYM */ #define CURLYM_B (REGNODE_MAX + 21) /* state for CURLYM */ #define CURLYM_B_fail (REGNODE_MAX + 22) /* state for CURLYM */ #define IFMATCH_A (REGNODE_MAX + 23) /* state for IFMATCH */ #define IFMATCH_A_fail (REGNODE_MAX + 24) /* state for IFMATCH */ #define CURLY_B_min_known (REGNODE_MAX + 25) /* state for CURLY */ #define CURLY_B_min_known_fail (REGNODE_MAX + 26) /* state for CURLY */ #define CURLY_B_min (REGNODE_MAX + 27) /* state for CURLY */ #define CURLY_B_min_fail (REGNODE_MAX + 28) /* state for CURLY */ #define CURLY_B_max (REGNODE_MAX + 29) /* state for CURLY */ #define CURLY_B_max_fail (REGNODE_MAX + 30) /* state for CURLY */ #define COMMIT_next (REGNODE_MAX + 31) /* state for COMMIT */ #define COMMIT_next_fail (REGNODE_MAX + 32) /* state for COMMIT */ #define MARKPOINT_next (REGNODE_MAX + 33) /* state for MARKPOINT */ #define MARKPOINT_next_fail (REGNODE_MAX + 34) /* state for MARKPOINT */ #define SKIP_next (REGNODE_MAX + 35) /* state for SKIP */ #define SKIP_next_fail (REGNODE_MAX + 36) /* state for SKIP */ #define CUTGROUP_next (REGNODE_MAX + 37) /* state for CUTGROUP */ #define CUTGROUP_next_fail (REGNODE_MAX + 38) /* state for CUTGROUP */ #define KEEPS_next (REGNODE_MAX + 39) /* state for KEEPS */ #define KEEPS_next_fail (REGNODE_MAX + 40) /* state for KEEPS */ /* PL_regkind[] What type of regop or state is this. */ #ifndef DOINIT EXTCONST U8 PL_regkind[]; #else EXTCONST U8 PL_regkind[] = { END, /* END */ END, /* SUCCEED */ BOL, /* BOL */ BOL, /* MBOL */ BOL, /* SBOL */ EOL, /* EOS */ EOL, /* EOL */ EOL, /* MEOL */ EOL, /* SEOL */ BOUND, /* BOUND */ BOUND, /* BOUNDL */ BOUND, /* BOUNDU */ BOUND, /* BOUNDA */ NBOUND, /* NBOUND */ NBOUND, /* NBOUNDL */ NBOUND, /* NBOUNDU */ NBOUND, /* NBOUNDA */ GPOS, /* GPOS */ REG_ANY, /* REG_ANY */ REG_ANY, /* SANY */ REG_ANY, /* CANY */ ANYOF, /* ANYOF */ ANYOF, /* ANYOFV */ ALNUM, /* ALNUM */ ALNUM, /* ALNUML */ ALNUM, /* ALNUMU */ ALNUM, /* ALNUMA */ NALNUM, /* NALNUM */ NALNUM, /* NALNUML */ NALNUM, /* NALNUMU */ NALNUM, /* NALNUMA */ SPACE, /* SPACE */ SPACE, /* SPACEL */ SPACE, /* SPACEU */ SPACE, /* SPACEA */ NSPACE, /* NSPACE */ NSPACE, /* NSPACEL */ NSPACE, /* NSPACEU */ NSPACE, /* NSPACEA */ DIGIT, /* DIGIT */ DIGIT, /* DIGITL */ DIGIT, /* DIGITA */ NDIGIT, /* NDIGIT */ NDIGIT, /* NDIGITL */ NDIGIT, /* NDIGITA */ CLUMP, /* CLUMP */ BRANCH, /* BRANCH */ BACK, /* BACK */ EXACT, /* EXACT */ EXACT, /* EXACTF */ EXACT, /* EXACTFL */ EXACT, /* EXACTFU */ EXACT, /* EXACTFU_SS */ EXACT, /* EXACTFU_TRICKYFOLD */ EXACT, /* EXACTFA */ NOTHING, /* NOTHING */ NOTHING, /* TAIL */ STAR, /* STAR */ PLUS, /* PLUS */ CURLY, /* CURLY */ CURLY, /* CURLYN */ CURLY, /* CURLYM */ CURLY, /* CURLYX */ WHILEM, /* WHILEM */ OPEN, /* OPEN */ CLOSE, /* CLOSE */ REF, /* REF */ REF, /* REFF */ REF, /* REFFL */ REF, /* REFFU */ REF, /* REFFA */ REF, /* NREF */ REF, /* NREFF */ REF, /* NREFFL */ REF, /* NREFFU */ REF, /* NREFFA */ BRANCHJ, /* IFMATCH */ BRANCHJ, /* UNLESSM */ BRANCHJ, /* SUSPEND */ BRANCHJ, /* IFTHEN */ GROUPP, /* GROUPP */ LONGJMP, /* LONGJMP */ BRANCHJ, /* BRANCHJ */ EVAL, /* EVAL */ MINMOD, /* MINMOD */ LOGICAL, /* LOGICAL */ BRANCHJ, /* RENUM */ TRIE, /* TRIE */ TRIE, /* TRIEC */ TRIE, /* AHOCORASICK */ TRIE, /* AHOCORASICKC */ GOSUB, /* GOSUB */ GOSTART, /* GOSTART */ NGROUPP, /* NGROUPP */ INSUBP, /* INSUBP */ DEFINEP, /* DEFINEP */ ENDLIKE, /* ENDLIKE */ ENDLIKE, /* OPFAIL */ ENDLIKE, /* ACCEPT */ VERB, /* VERB */ VERB, /* PRUNE */ VERB, /* MARKPOINT */ VERB, /* SKIP */ VERB, /* COMMIT */ VERB, /* CUTGROUP */ KEEPS, /* KEEPS */ LNBREAK, /* LNBREAK */ VERTWS, /* VERTWS */ NVERTWS, /* NVERTWS */ HORIZWS, /* HORIZWS */ NHORIZWS, /* NHORIZWS */ NOTHING, /* OPTIMIZED */ PSEUDO, /* PSEUDO */ /* ------------ States ------------- */ TRIE, /* TRIE_next */ TRIE, /* TRIE_next_fail */ EVAL, /* EVAL_AB */ EVAL, /* EVAL_AB_fail */ CURLYX, /* CURLYX_end */ CURLYX, /* CURLYX_end_fail */ WHILEM, /* WHILEM_A_pre */ WHILEM, /* WHILEM_A_pre_fail */ WHILEM, /* WHILEM_A_min */ WHILEM, /* WHILEM_A_min_fail */ WHILEM, /* WHILEM_A_max */ WHILEM, /* WHILEM_A_max_fail */ WHILEM, /* WHILEM_B_min */ WHILEM, /* WHILEM_B_min_fail */ WHILEM, /* WHILEM_B_max */ WHILEM, /* WHILEM_B_max_fail */ BRANCH, /* BRANCH_next */ BRANCH, /* BRANCH_next_fail */ CURLYM, /* CURLYM_A */ CURLYM, /* CURLYM_A_fail */ CURLYM, /* CURLYM_B */ CURLYM, /* CURLYM_B_fail */ IFMATCH, /* IFMATCH_A */ IFMATCH, /* IFMATCH_A_fail */ CURLY, /* CURLY_B_min_known */ CURLY, /* CURLY_B_min_known_fail */ CURLY, /* CURLY_B_min */ CURLY, /* CURLY_B_min_fail */ CURLY, /* CURLY_B_max */ CURLY, /* CURLY_B_max_fail */ COMMIT, /* COMMIT_next */ COMMIT, /* COMMIT_next_fail */ MARKPOINT, /* MARKPOINT_next */ MARKPOINT, /* MARKPOINT_next_fail */ SKIP, /* SKIP_next */ SKIP, /* SKIP_next_fail */ CUTGROUP, /* CUTGROUP_next */ CUTGROUP, /* CUTGROUP_next_fail */ KEEPS, /* KEEPS_next */ KEEPS, /* KEEPS_next_fail */ }; #endif /* regarglen[] - How large is the argument part of the node (in regnodes) */ #ifdef REG_COMP_C static const U8 regarglen[] = { 0, /* END */ 0, /* SUCCEED */ 0, /* BOL */ 0, /* MBOL */ 0, /* SBOL */ 0, /* EOS */ 0, /* EOL */ 0, /* MEOL */ 0, /* SEOL */ 0, /* BOUND */ 0, /* BOUNDL */ 0, /* BOUNDU */ 0, /* BOUNDA */ 0, /* NBOUND */ 0, /* NBOUNDL */ 0, /* NBOUNDU */ 0, /* NBOUNDA */ 0, /* GPOS */ 0, /* REG_ANY */ 0, /* SANY */ 0, /* CANY */ 0, /* ANYOF */ 0, /* ANYOFV */ 0, /* ALNUM */ 0, /* ALNUML */ 0, /* ALNUMU */ 0, /* ALNUMA */ 0, /* NALNUM */ 0, /* NALNUML */ 0, /* NALNUMU */ 0, /* NALNUMA */ 0, /* SPACE */ 0, /* SPACEL */ 0, /* SPACEU */ 0, /* SPACEA */ 0, /* NSPACE */ 0, /* NSPACEL */ 0, /* NSPACEU */ 0, /* NSPACEA */ 0, /* DIGIT */ 0, /* DIGITL */ 0, /* DIGITA */ 0, /* NDIGIT */ 0, /* NDIGITL */ 0, /* NDIGITA */ 0, /* CLUMP */ 0, /* BRANCH */ 0, /* BACK */ 0, /* EXACT */ 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ 0, /* EXACTFU_SS */ 0, /* EXACTFU_TRICKYFOLD */ 0, /* EXACTFA */ 0, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ 0, /* PLUS */ EXTRA_SIZE(struct regnode_2), /* CURLY */ EXTRA_SIZE(struct regnode_2), /* CURLYN */ EXTRA_SIZE(struct regnode_2), /* CURLYM */ EXTRA_SIZE(struct regnode_2), /* CURLYX */ 0, /* WHILEM */ EXTRA_SIZE(struct regnode_1), /* OPEN */ EXTRA_SIZE(struct regnode_1), /* CLOSE */ EXTRA_SIZE(struct regnode_1), /* REF */ EXTRA_SIZE(struct regnode_1), /* REFF */ EXTRA_SIZE(struct regnode_1), /* REFFL */ EXTRA_SIZE(struct regnode_1), /* REFFU */ EXTRA_SIZE(struct regnode_1), /* REFFA */ EXTRA_SIZE(struct regnode_1), /* NREF */ EXTRA_SIZE(struct regnode_1), /* NREFF */ EXTRA_SIZE(struct regnode_1), /* NREFFL */ EXTRA_SIZE(struct regnode_1), /* NREFFU */ EXTRA_SIZE(struct regnode_1), /* NREFFA */ EXTRA_SIZE(struct regnode_1), /* IFMATCH */ EXTRA_SIZE(struct regnode_1), /* UNLESSM */ EXTRA_SIZE(struct regnode_1), /* SUSPEND */ EXTRA_SIZE(struct regnode_1), /* IFTHEN */ EXTRA_SIZE(struct regnode_1), /* GROUPP */ EXTRA_SIZE(struct regnode_1), /* LONGJMP */ EXTRA_SIZE(struct regnode_1), /* BRANCHJ */ EXTRA_SIZE(struct regnode_1), /* EVAL */ 0, /* MINMOD */ 0, /* LOGICAL */ EXTRA_SIZE(struct regnode_1), /* RENUM */ EXTRA_SIZE(struct regnode_1), /* TRIE */ EXTRA_SIZE(struct regnode_charclass), /* TRIEC */ EXTRA_SIZE(struct regnode_1), /* AHOCORASICK */ EXTRA_SIZE(struct regnode_charclass), /* AHOCORASICKC */ EXTRA_SIZE(struct regnode_2L), /* GOSUB */ 0, /* GOSTART */ EXTRA_SIZE(struct regnode_1), /* NGROUPP */ EXTRA_SIZE(struct regnode_1), /* INSUBP */ EXTRA_SIZE(struct regnode_1), /* DEFINEP */ 0, /* ENDLIKE */ 0, /* OPFAIL */ EXTRA_SIZE(struct regnode_1), /* ACCEPT */ EXTRA_SIZE(struct regnode_1), /* VERB */ EXTRA_SIZE(struct regnode_1), /* PRUNE */ EXTRA_SIZE(struct regnode_1), /* MARKPOINT */ EXTRA_SIZE(struct regnode_1), /* SKIP */ EXTRA_SIZE(struct regnode_1), /* COMMIT */ EXTRA_SIZE(struct regnode_1), /* CUTGROUP */ 0, /* KEEPS */ 0, /* LNBREAK */ 0, /* VERTWS */ 0, /* NVERTWS */ 0, /* HORIZWS */ 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ }; /* reg_off_by_arg[] - Which argument holds the offset to the next node */ static const char reg_off_by_arg[] = { 0, /* END */ 0, /* SUCCEED */ 0, /* BOL */ 0, /* MBOL */ 0, /* SBOL */ 0, /* EOS */ 0, /* EOL */ 0, /* MEOL */ 0, /* SEOL */ 0, /* BOUND */ 0, /* BOUNDL */ 0, /* BOUNDU */ 0, /* BOUNDA */ 0, /* NBOUND */ 0, /* NBOUNDL */ 0, /* NBOUNDU */ 0, /* NBOUNDA */ 0, /* GPOS */ 0, /* REG_ANY */ 0, /* SANY */ 0, /* CANY */ 0, /* ANYOF */ 0, /* ANYOFV */ 0, /* ALNUM */ 0, /* ALNUML */ 0, /* ALNUMU */ 0, /* ALNUMA */ 0, /* NALNUM */ 0, /* NALNUML */ 0, /* NALNUMU */ 0, /* NALNUMA */ 0, /* SPACE */ 0, /* SPACEL */ 0, /* SPACEU */ 0, /* SPACEA */ 0, /* NSPACE */ 0, /* NSPACEL */ 0, /* NSPACEU */ 0, /* NSPACEA */ 0, /* DIGIT */ 0, /* DIGITL */ 0, /* DIGITA */ 0, /* NDIGIT */ 0, /* NDIGITL */ 0, /* NDIGITA */ 0, /* CLUMP */ 0, /* BRANCH */ 0, /* BACK */ 0, /* EXACT */ 0, /* EXACTF */ 0, /* EXACTFL */ 0, /* EXACTFU */ 0, /* EXACTFU_SS */ 0, /* EXACTFU_TRICKYFOLD */ 0, /* EXACTFA */ 0, /* NOTHING */ 0, /* TAIL */ 0, /* STAR */ 0, /* PLUS */ 0, /* CURLY */ 0, /* CURLYN */ 0, /* CURLYM */ 0, /* CURLYX */ 0, /* WHILEM */ 0, /* OPEN */ 0, /* CLOSE */ 0, /* REF */ 0, /* REFF */ 0, /* REFFL */ 0, /* REFFU */ 0, /* REFFA */ 0, /* NREF */ 0, /* NREFF */ 0, /* NREFFL */ 0, /* NREFFU */ 0, /* NREFFA */ 2, /* IFMATCH */ 2, /* UNLESSM */ 1, /* SUSPEND */ 1, /* IFTHEN */ 0, /* GROUPP */ 1, /* LONGJMP */ 1, /* BRANCHJ */ 0, /* EVAL */ 0, /* MINMOD */ 0, /* LOGICAL */ 1, /* RENUM */ 0, /* TRIE */ 0, /* TRIEC */ 0, /* AHOCORASICK */ 0, /* AHOCORASICKC */ 0, /* GOSUB */ 0, /* GOSTART */ 0, /* NGROUPP */ 0, /* INSUBP */ 0, /* DEFINEP */ 0, /* ENDLIKE */ 0, /* OPFAIL */ 0, /* ACCEPT */ 0, /* VERB */ 0, /* PRUNE */ 0, /* MARKPOINT */ 0, /* SKIP */ 0, /* COMMIT */ 0, /* CUTGROUP */ 0, /* KEEPS */ 0, /* LNBREAK */ 0, /* VERTWS */ 0, /* NVERTWS */ 0, /* HORIZWS */ 0, /* NHORIZWS */ 0, /* OPTIMIZED */ 0, /* PSEUDO */ }; #endif /* REG_COMP_C */ /* reg_name[] - Opcode/state names in string form, for debugging */ #ifndef DOINIT EXTCONST char * PL_reg_name[]; #else EXTCONST char * const PL_reg_name[] = { "END", /* 0000 */ "SUCCEED", /* 0x01 */ "BOL", /* 0x02 */ "MBOL", /* 0x03 */ "SBOL", /* 0x04 */ "EOS", /* 0x05 */ "EOL", /* 0x06 */ "MEOL", /* 0x07 */ "SEOL", /* 0x08 */ "BOUND", /* 0x09 */ "BOUNDL", /* 0x0a */ "BOUNDU", /* 0x0b */ "BOUNDA", /* 0x0c */ "NBOUND", /* 0x0d */ "NBOUNDL", /* 0x0e */ "NBOUNDU", /* 0x0f */ "NBOUNDA", /* 0x10 */ "GPOS", /* 0x11 */ "REG_ANY", /* 0x12 */ "SANY", /* 0x13 */ "CANY", /* 0x14 */ "ANYOF", /* 0x15 */ "ANYOFV", /* 0x16 */ "ALNUM", /* 0x17 */ "ALNUML", /* 0x18 */ "ALNUMU", /* 0x19 */ "ALNUMA", /* 0x1a */ "NALNUM", /* 0x1b */ "NALNUML", /* 0x1c */ "NALNUMU", /* 0x1d */ "NALNUMA", /* 0x1e */ "SPACE", /* 0x1f */ "SPACEL", /* 0x20 */ "SPACEU", /* 0x21 */ "SPACEA", /* 0x22 */ "NSPACE", /* 0x23 */ "NSPACEL", /* 0x24 */ "NSPACEU", /* 0x25 */ "NSPACEA", /* 0x26 */ "DIGIT", /* 0x27 */ "DIGITL", /* 0x28 */ "DIGITA", /* 0x29 */ "NDIGIT", /* 0x2a */ "NDIGITL", /* 0x2b */ "NDIGITA", /* 0x2c */ "CLUMP", /* 0x2d */ "BRANCH", /* 0x2e */ "BACK", /* 0x2f */ "EXACT", /* 0x30 */ "EXACTF", /* 0x31 */ "EXACTFL", /* 0x32 */ "EXACTFU", /* 0x33 */ "EXACTFU_SS", /* 0x34 */ "EXACTFU_TRICKYFOLD", /* 0x35 */ "EXACTFA", /* 0x36 */ "NOTHING", /* 0x37 */ "TAIL", /* 0x38 */ "STAR", /* 0x39 */ "PLUS", /* 0x3a */ "CURLY", /* 0x3b */ "CURLYN", /* 0x3c */ "CURLYM", /* 0x3d */ "CURLYX", /* 0x3e */ "WHILEM", /* 0x3f */ "OPEN", /* 0x40 */ "CLOSE", /* 0x41 */ "REF", /* 0x42 */ "REFF", /* 0x43 */ "REFFL", /* 0x44 */ "REFFU", /* 0x45 */ "REFFA", /* 0x46 */ "NREF", /* 0x47 */ "NREFF", /* 0x48 */ "NREFFL", /* 0x49 */ "NREFFU", /* 0x4a */ "NREFFA", /* 0x4b */ "IFMATCH", /* 0x4c */ "UNLESSM", /* 0x4d */ "SUSPEND", /* 0x4e */ "IFTHEN", /* 0x4f */ "GROUPP", /* 0x50 */ "LONGJMP", /* 0x51 */ "BRANCHJ", /* 0x52 */ "EVAL", /* 0x53 */ "MINMOD", /* 0x54 */ "LOGICAL", /* 0x55 */ "RENUM", /* 0x56 */ "TRIE", /* 0x57 */ "TRIEC", /* 0x58 */ "AHOCORASICK", /* 0x59 */ "AHOCORASICKC", /* 0x5a */ "GOSUB", /* 0x5b */ "GOSTART", /* 0x5c */ "NGROUPP", /* 0x5d */ "INSUBP", /* 0x5e */ "DEFINEP", /* 0x5f */ "ENDLIKE", /* 0x60 */ "OPFAIL", /* 0x61 */ "ACCEPT", /* 0x62 */ "VERB", /* 0x63 */ "PRUNE", /* 0x64 */ "MARKPOINT", /* 0x65 */ "SKIP", /* 0x66 */ "COMMIT", /* 0x67 */ "CUTGROUP", /* 0x68 */ "KEEPS", /* 0x69 */ "LNBREAK", /* 0x6a */ "VERTWS", /* 0x6b */ "NVERTWS", /* 0x6c */ "HORIZWS", /* 0x6d */ "NHORIZWS", /* 0x6e */ "OPTIMIZED", /* 0x6f */ "PSEUDO", /* 0x70 */ /* ------------ States ------------- */ "TRIE_next", /* REGNODE_MAX +0x01 */ "TRIE_next_fail", /* REGNODE_MAX +0x02 */ "EVAL_AB", /* REGNODE_MAX +0x03 */ "EVAL_AB_fail", /* REGNODE_MAX +0x04 */ "CURLYX_end", /* REGNODE_MAX +0x05 */ "CURLYX_end_fail", /* REGNODE_MAX +0x06 */ "WHILEM_A_pre", /* REGNODE_MAX +0x07 */ "WHILEM_A_pre_fail", /* REGNODE_MAX +0x08 */ "WHILEM_A_min", /* REGNODE_MAX +0x09 */ "WHILEM_A_min_fail", /* REGNODE_MAX +0x0a */ "WHILEM_A_max", /* REGNODE_MAX +0x0b */ "WHILEM_A_max_fail", /* REGNODE_MAX +0x0c */ "WHILEM_B_min", /* REGNODE_MAX +0x0d */ "WHILEM_B_min_fail", /* REGNODE_MAX +0x0e */ "WHILEM_B_max", /* REGNODE_MAX +0x0f */ "WHILEM_B_max_fail", /* REGNODE_MAX +0x10 */ "BRANCH_next", /* REGNODE_MAX +0x11 */ "BRANCH_next_fail", /* REGNODE_MAX +0x12 */ "CURLYM_A", /* REGNODE_MAX +0x13 */ "CURLYM_A_fail", /* REGNODE_MAX +0x14 */ "CURLYM_B", /* REGNODE_MAX +0x15 */ "CURLYM_B_fail", /* REGNODE_MAX +0x16 */ "IFMATCH_A", /* REGNODE_MAX +0x17 */ "IFMATCH_A_fail", /* REGNODE_MAX +0x18 */ "CURLY_B_min_known", /* REGNODE_MAX +0x19 */ "CURLY_B_min_known_fail", /* REGNODE_MAX +0x1a */ "CURLY_B_min", /* REGNODE_MAX +0x1b */ "CURLY_B_min_fail", /* REGNODE_MAX +0x1c */ "CURLY_B_max", /* REGNODE_MAX +0x1d */ "CURLY_B_max_fail", /* REGNODE_MAX +0x1e */ "COMMIT_next", /* REGNODE_MAX +0x1f */ "COMMIT_next_fail", /* REGNODE_MAX +0x20 */ "MARKPOINT_next", /* REGNODE_MAX +0x21 */ "MARKPOINT_next_fail", /* REGNODE_MAX +0x22 */ "SKIP_next", /* REGNODE_MAX +0x23 */ "SKIP_next_fail", /* REGNODE_MAX +0x24 */ "CUTGROUP_next", /* REGNODE_MAX +0x25 */ "CUTGROUP_next_fail", /* REGNODE_MAX +0x26 */ "KEEPS_next", /* REGNODE_MAX +0x27 */ "KEEPS_next_fail", /* REGNODE_MAX +0x28 */ }; #endif /* DOINIT */ /* PL_reg_extflags_name[] - Opcode/state names in string form, for debugging */ #ifndef DOINIT EXTCONST char * PL_reg_extflags_name[]; #else EXTCONST char * const PL_reg_extflags_name[] = { /* Bits in extflags defined: 11111111111111111111111011111111 */ "MULTILINE", /* 0x00000001 */ "SINGLELINE", /* 0x00000002 */ "FOLD", /* 0x00000004 */ "EXTENDED", /* 0x00000008 */ "KEEPCOPY", /* 0x00000010 */ "CHARSET", /* 0x000000e0 */ "CHARSET", /* 0x000000e0 */ "CHARSET", /* 0x000000e0 */ "UNUSED_BIT_8", /* 0x00000100 */ "ANCH_BOL", /* 0x00000200 */ "ANCH_MBOL", /* 0x00000400 */ "ANCH_SBOL", /* 0x00000800 */ "ANCH_GPOS", /* 0x00001000 */ "GPOS_SEEN", /* 0x00002000 */ "GPOS_FLOAT", /* 0x00004000 */ "LOOKBEHIND_SEEN", /* 0x00008000 */ "EVAL_SEEN", /* 0x00010000 */ "CANY_SEEN", /* 0x00020000 */ "NOSCAN", /* 0x00040000 */ "CHECK_ALL", /* 0x00080000 */ "MATCH_UTF8", /* 0x00100000 */ "USE_INTUIT_NOML", /* 0x00200000 */ "USE_INTUIT_ML", /* 0x00400000 */ "INTUIT_TAIL", /* 0x00800000 */ "SPLIT", /* 0x01000000 */ "COPY_DONE", /* 0x02000000 */ "TAINTED_SEEN", /* 0x04000000 */ "TAINTED", /* 0x08000000 */ "START_ONLY", /* 0x10000000 */ "SKIPWHITE", /* 0x20000000 */ "WHITE", /* 0x40000000 */ "NULL", /* 0x80000000 */ }; #endif /* DOINIT */ /* The following have no fixed length. U8 so we can do strchr() on it. */ #define REGNODE_VARIES(node) (PL_varies_bitmask[(node) >> 3] & (1 << ((node) & 7))) #ifndef DOINIT EXTCONST U8 PL_varies[] __attribute__deprecated__; #else EXTCONST U8 PL_varies[] __attribute__deprecated__ = { ANYOFV, CLUMP, BRANCH, BACK, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, WHILEM, REF, REFF, REFFL, REFFU, REFFA, NREF, NREFF, NREFFL, NREFFU, NREFFA, SUSPEND, IFTHEN, BRANCHJ, 0 }; #endif /* DOINIT */ #ifndef DOINIT EXTCONST U8 PL_varies_bitmask[]; #else EXTCONST U8 PL_varies_bitmask[] = { 0x00, 0x00, 0x40, 0x00, 0x00, 0xE0, 0x00, 0xFE, 0xFC, 0xCF, 0x04, 0x00, 0x00, 0x00, 0x00 }; #endif /* DOINIT */ /* The following always have a length of 1. U8 we can do strchr() on it. */ /* (Note that length 1 means "one character" under UTF8, not "one octet".) */ #define REGNODE_SIMPLE(node) (PL_simple_bitmask[(node) >> 3] & (1 << ((node) & 7))) #ifndef DOINIT EXTCONST U8 PL_simple[] __attribute__deprecated__; #else EXTCONST U8 PL_simple[] __attribute__deprecated__ = { REG_ANY, SANY, CANY, ANYOF, ALNUM, ALNUML, ALNUMU, ALNUMA, NALNUM, NALNUML, NALNUMU, NALNUMA, SPACE, SPACEL, SPACEU, SPACEA, NSPACE, NSPACEL, NSPACEU, NSPACEA, DIGIT, DIGITL, DIGITA, NDIGIT, NDIGITL, NDIGITA, VERTWS, NVERTWS, HORIZWS, NHORIZWS, 0 }; #endif /* DOINIT */ #ifndef DOINIT EXTCONST U8 PL_simple_bitmask[]; #else EXTCONST U8 PL_simple_bitmask[] = { 0x00, 0x00, 0xBC, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x00 }; #endif /* DOINIT */ /* ex: set ro: */ PKZ*Yw metaconfig.hnuW+A/* This is a placeholder file for symbols that should be exported * into config_h.SH and Porting/Glossary. See also metaconfig.SH * * First version was created from the part in handy.h * H.Merijn Brand 21 Dec 2010 (Tux) * * Mentioned variables are forced to be included into config_h.SH * as they are only included if meta finds them referenced. That * implies that noone can use them unless they are available and * they won't be available unless used. When new symbols are probed * in Configure, this is the way to force them into availability. * * CHARBITS * HAS_ASCTIME64 * HAS_CTIME64 * HAS_DIFFTIME64 * HAS_GMTIME64 * HAS_ISBLANK * HAS_LOCALTIME64 * HAS_IPV6_MREQ * HAS_MKTIME64 * HAS_PRCTL * HAS_PSEUDOFORK * HAS_TIMEGM * HAS_SOCKADDR_IN6 * I16SIZE * I64SIZE * I8SIZE * LOCALTIME_R_NEEDS_TZSET * U8SIZE * USE_KERN_PROC_PATHNAME * USE_NSGETEXECUTABLEPATH * */ PKZ $ feature.hnuW+A/* -*- buffer-read-only: t -*- !!!!!!! DO NOT EDIT THIS FILE !!!!!!! This file is built by regen/feature.pl. Any changes made here will be lost! */ #if defined(PERL_CORE) || defined (PERL_EXT) #define HINT_FEATURE_SHIFT 26 #define FEATURE_BUNDLE_DEFAULT 0 #define FEATURE_BUNDLE_510 1 #define FEATURE_BUNDLE_511 2 #define FEATURE_BUNDLE_515 3 #define FEATURE_BUNDLE_CUSTOM (HINT_FEATURE_MASK >> HINT_FEATURE_SHIFT) #define CURRENT_HINTS \ (PL_curcop == &PL_compiling ? PL_hints : PL_curcop->cop_hints) #define CURRENT_FEATURE_BUNDLE \ ((CURRENT_HINTS & HINT_FEATURE_MASK) >> HINT_FEATURE_SHIFT) /* Avoid using ... && Perl_feature_is_enabled(...) as that triggers a bug in the HP-UX cc on PA-RISC */ #define FEATURE_IS_ENABLED(name) \ ((CURRENT_HINTS \ & HINT_LOCALIZE_HH) \ ? Perl_feature_is_enabled(aTHX_ STR_WITH_LEN(name)) : FALSE) /* The longest string we pass in. */ #define MAX_FEATURE_LEN (sizeof("evalbytes")-1) #define FEATURE_FC_IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_515 \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("fc")) \ ) #define FEATURE_SAY_IS_ENABLED \ ( \ (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \ CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_515) \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("say")) \ ) #define FEATURE_STATE_IS_ENABLED \ ( \ (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \ CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_515) \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("state")) \ ) #define FEATURE_SWITCH_IS_ENABLED \ ( \ (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \ CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_515) \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("switch")) \ ) #define FEATURE_EVALBYTES_IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_515 \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("evalbytes")) \ ) #define FEATURE_ARYBASE_IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_511 \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("arybase")) \ ) #define FEATURE___SUB___IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_515 \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("__SUB__")) \ ) #define FEATURE_UNIEVAL_IS_ENABLED \ ( \ CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_515 \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("unieval")) \ ) #define FEATURE_UNICODE_IS_ENABLED \ ( \ (CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_511 && \ CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_515) \ || (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \ FEATURE_IS_ENABLED("unicode")) \ ) #endif /* PERL_CORE or PERL_EXT */ #ifdef PERL_IN_OP_C PERL_STATIC_INLINE void S_enable_feature_bundle(pTHX_ SV *ver) { SV *comp_ver = sv_newmortal(); PL_hints = (PL_hints &~ HINT_FEATURE_MASK) | ( (sv_setnv(comp_ver, 5.015), vcmp(ver, upg_version(comp_ver, FALSE)) >= 0) ? FEATURE_BUNDLE_515 : (sv_setnv(comp_ver, 5.011), vcmp(ver, upg_version(comp_ver, FALSE)) >= 0) ? FEATURE_BUNDLE_511 : (sv_setnv(comp_ver, 5.009005), vcmp(ver, upg_version(comp_ver, FALSE)) >= 0) ? FEATURE_BUNDLE_510 : FEATURE_BUNDLE_DEFAULT ) << HINT_FEATURE_SHIFT; /* special case */ assert(PL_curcop == &PL_compiling); if (FEATURE_UNICODE_IS_ENABLED) PL_hints |= HINT_UNI_8_BIT; else PL_hints &= ~HINT_UNI_8_BIT; } #endif /* PERL_IN_OP_C */ /* ex: set ro: */ PKZ(NNop_reg_common.hnuW+A/* op_reg_common.h * * Definitions common to by op.h and regexp.h * * Copyright (C) 2010, 2011 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* These defines are used in both op.h and regexp.h The definitions use the * shift form so that ext/B/defsubs_h.PL will pick them up. * * Data structures used in the two headers have common fields, and in fact one * is copied onto the other. This makes it easy to keep them in sync */ /* This tells where the first of these bits is. Setting it to 0 saved cycles * and memory. I (khw) think the code will work if changed back, but haven't * tested it */ /* Make sure to update ext/re/re.pm when changing this! */ #ifndef RXf_PMf_STD_PMMOD_SHIFT /* Only expand #include of this file once */ #define RXf_PMf_STD_PMMOD_SHIFT 0 /* The bits need to be ordered so that the msix are contiguous starting at bit * RXf_PMf_STD_PMMOD_SHIFT, followed by the p. See STD_PAT_MODS and * INT_PAT_MODS in regexp.h for the reason contiguity is needed */ /* Make sure to update lib/re.pm when changing these! */ #define RXf_PMf_MULTILINE (1 << (RXf_PMf_STD_PMMOD_SHIFT+0)) /* /m */ #define RXf_PMf_SINGLELINE (1 << (RXf_PMf_STD_PMMOD_SHIFT+1)) /* /s */ #define RXf_PMf_FOLD (1 << (RXf_PMf_STD_PMMOD_SHIFT+2)) /* /i */ #define RXf_PMf_EXTENDED (1 << (RXf_PMf_STD_PMMOD_SHIFT+3)) /* /x */ #define RXf_PMf_KEEPCOPY (1 << (RXf_PMf_STD_PMMOD_SHIFT+4)) /* /p */ /* The character set for the regex is stored in a field of more than one bit * using an enum, for reasons of compactness and to ensure that the options are * mutually exclusive */ /* Make sure to update ext/re/re.pm when changing this! */ typedef enum { REGEX_DEPENDS_CHARSET = 0, REGEX_LOCALE_CHARSET, REGEX_UNICODE_CHARSET, REGEX_ASCII_RESTRICTED_CHARSET, REGEX_ASCII_MORE_RESTRICTED_CHARSET } regex_charset; #define _RXf_PMf_CHARSET_SHIFT ((RXf_PMf_STD_PMMOD_SHIFT)+5) #define RXf_PMf_CHARSET (7 << (_RXf_PMf_CHARSET_SHIFT)) /* 3 bits */ /* Manually decorate these functions here with gcc-style attributes just to * avoid making the regex_charset typedef global, which it would need to be for * proto.h to understand it */ PERL_STATIC_INLINE void set_regex_charset(U32 * const flags, const regex_charset cs) __attribute__nonnull__(1); PERL_STATIC_INLINE void set_regex_charset(U32 * const flags, const regex_charset cs) { /* Sets the character set portion of 'flags' to 'cs', which is a member of * the above enum */ *flags &= ~RXf_PMf_CHARSET; *flags |= (cs << _RXf_PMf_CHARSET_SHIFT); } PERL_STATIC_INLINE regex_charset get_regex_charset(const U32 flags) __attribute__warn_unused_result__; PERL_STATIC_INLINE regex_charset get_regex_charset(const U32 flags) { /* Returns the enum corresponding to the character set in 'flags' */ return (regex_charset) ((flags & RXf_PMf_CHARSET) >> _RXf_PMf_CHARSET_SHIFT); } /* Next available bit after the above. Name begins with '_' so won't be * exported by B */ #define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+8) /* Mask of the above bits. These need to be transferred from op_pmflags to * re->extflags during compilation */ #define RXf_PMf_COMPILETIME (RXf_PMf_MULTILINE|RXf_PMf_SINGLELINE|RXf_PMf_CHARSET|RXf_PMf_FOLD|RXf_PMf_EXTENDED|RXf_PMf_KEEPCOPY) /* These copies need to be numerical or defsubs_h.PL won't know about them. */ #define PMf_MULTILINE 1<<0 #define PMf_SINGLELINE 1<<1 #define PMf_FOLD 1<<2 #define PMf_EXTENDED 1<<3 #define PMf_KEEPCOPY 1<<4 #if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY # error RXf_PMf defines are wrong #endif #define PMf_COMPILETIME RXf_PMf_COMPILETIME /* Error check that haven't left something out of this. This isn't done * directly in the #define because doing so confuses regcomp.pl. * (2**n - 1) is n 1 bits, so the below gets the contiguous bits between the * beginning and ending shifts */ #if RXf_PMf_COMPILETIME != (((1 << (_RXf_PMf_SHIFT_NEXT))-1) \ & (~((1 << RXf_PMf_STD_PMMOD_SHIFT)-1))) # error RXf_PMf_COMPILETIME is invalid #endif #endif /* Include only once */ PKZz@ee git_version.hnuW+A/************************************************************************** * WARNING: 'git_version.h' is automatically generated by make_patchnum.pl * DO NOT EDIT DIRECTLY - edit make_patchnum.pl instead ***************************************************************************/ #define PERL_GIT_UNPUSHED_COMMITS \ /*leave-this-comment*/ PKZLӲJJop.hnuW+A/* op.h * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * The fields of BASEOP are: * op_next Pointer to next ppcode to execute after this one. * (Top level pre-grafted op points to first op, * but this is replaced when op is grafted in, when * this op will point to the real next op, and the new * parent takes over role of remembering starting op.) * op_ppaddr Pointer to current ppcode's function. * op_type The type of the operation. * op_opt Whether or not the op has been optimised by the * peephole optimiser. * * See the comments in S_clear_yystack() for more * details on the following three flags: * * op_latefree tell op_free() to clear this op (and free any kids) * but not yet deallocate the struct. This means that * the op may be safely op_free()d multiple times * op_latefreed an op_latefree op has been op_free()d * op_attached this op (sub)tree has been attached to a CV * * op_spare three spare bits! * op_flags Flags common to all operations. See OPf_* below. * op_private Flags peculiar to a particular operation (BUT, * by default, set to the number of children until * the operation is privatized by a check routine, * which may or may not check number of children). */ #include "op_reg_common.h" #define OPCODE U16 #ifdef PERL_MAD # define MADPROP_IN_BASEOP MADPROP* op_madprop; #else # define MADPROP_IN_BASEOP #endif typedef PERL_BITFIELD16 Optype; #ifdef BASEOP_DEFINITION #define BASEOP BASEOP_DEFINITION #else #define BASEOP \ OP* op_next; \ OP* op_sibling; \ OP* (*op_ppaddr)(pTHX); \ MADPROP_IN_BASEOP \ PADOFFSET op_targ; \ PERL_BITFIELD16 op_type:9; \ PERL_BITFIELD16 op_opt:1; \ PERL_BITFIELD16 op_latefree:1; \ PERL_BITFIELD16 op_latefreed:1; \ PERL_BITFIELD16 op_attached:1; \ PERL_BITFIELD16 op_spare:3; \ U8 op_flags; \ U8 op_private; #endif /* If op_type:9 is changed to :10, also change PUSHEVAL in cop.h. Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32) then all the other bit-fields before/after it should change their types too to let VC pack them into the same 4 byte integer.*/ #define OP_GIMME(op,dfl) \ (((op)->op_flags & OPf_WANT) == OPf_WANT_VOID ? G_VOID : \ ((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \ ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \ dfl) #define OP_GIMME_REVERSE(flags) ((flags) & G_WANT) /* =head1 "Gimme" Values =for apidoc Amn|U32|GIMME_V The XSUB-writer's equivalent to Perl's C. Returns C, C or C for void, scalar or list context, respectively. See L for a usage example. =for apidoc Amn|U32|GIMME A backward-compatible version of C which can only return C or C; in a void context, it returns C. Deprecated. Use C instead. =cut */ #define GIMME_V OP_GIMME(PL_op, block_gimme()) /* Public flags */ #define OPf_WANT 3 /* Mask for "want" bits: */ #define OPf_WANT_VOID 1 /* Want nothing */ #define OPf_WANT_SCALAR 2 /* Want single value */ #define OPf_WANT_LIST 3 /* Want list of any length */ #define OPf_KIDS 4 /* There is a firstborn child. */ #define OPf_PARENS 8 /* This operator was parenthesized. */ /* (Or block needs explicit scope entry.) */ #define OPf_REF 16 /* Certified reference. */ /* (Return container, not containee). */ #define OPf_MOD 32 /* Will modify (lvalue). */ #define OPf_STACKED 64 /* Some arg is arriving on the stack. */ #define OPf_SPECIAL 128 /* Do something weird for this op: */ /* On local LVAL, don't init local value. */ /* On OP_SORT, subroutine is inlined. */ /* On OP_NOT, inversion was implicit. */ /* On OP_LEAVE, don't restore curpm. */ /* On truncate, we truncate filehandle */ /* On control verbs, we saw no label */ /* On flipflop, we saw ... instead of .. */ /* On UNOPs, saw bare parens, e.g. eof(). */ /* On OP_ENTERSUB || OP_NULL, saw a "do". */ /* On OP_EXISTS, treat av as av, not avhv. */ /* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */ /* On pushre, rx is used as part of split, e.g. split " " */ /* On regcomp, "use re 'eval'" was in scope */ /* On OP_READLINE, was <$filehandle> */ /* On RV2[ACGHS]V, don't create GV--in defined()*/ /* On OP_DBSTATE, indicates breakpoint * (runtime property) */ /* On OP_REQUIRE, was seen as CORE::require */ /* On OP_(ENTER|LEAVE)WHEN, there's no condition */ /* On OP_SMARTMATCH, an implicit smartmatch */ /* On OP_ANONHASH and OP_ANONLIST, create a reference to the new anon hash or array */ /* On OP_HELEM and OP_HSLICE, localization will be followed by assignment, so do not wipe the target if it is special (e.g. a glob or a magic SV) */ /* On OP_MATCH, OP_SUBST & OP_TRANS, the operand of a logical or conditional that was optimised away, so it should not be bound via =~ */ /* On OP_CONST, from a constant CV */ /* On OP_GLOB, two meanings: - Before ck_glob, called as CORE::glob - After ck_glob, use Perl glob function */ /* old names; don't use in new code, but don't break them, either */ #define OPf_LIST OPf_WANT_LIST #define OPf_KNOW OPf_WANT #define GIMME \ (PL_op->op_flags & OPf_WANT \ ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \ ? G_ARRAY \ : G_SCALAR) \ : dowantarray()) /* Lower bits of op_private often carry the number of arguments, as * set by newBINOP, newUNOP and ck_fun */ /* NOTE: OP_NEXTSTATE and OP_DBSTATE (i.e. COPs) carry NATIVE_HINTS * in op_private */ /* Private for lvalues */ #define OPpLVAL_INTRO 128 /* Lvalue must be localized or lvalue sub */ /* Private for OPs with TARGLEX */ /* (lower bits may carry MAXARG) */ #define OPpTARGET_MY 16 /* Target is PADMY. */ /* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */ #define OPpREFCOUNTED 64 /* op_targ carries a refcount */ /* Private for OP_AASSIGN */ #define OPpASSIGN_COMMON 64 /* Left & right have syms in common. */ /* Private for OP_SASSIGN */ #define OPpASSIGN_BACKWARDS 64 /* Left & right switched. */ #define OPpASSIGN_CV_TO_GV 128 /* Possible optimisation for constants. */ /* Private for OP_MATCH and OP_SUBST{,CONST} */ #define OPpRUNTIME 64 /* Pattern coming in on the stack */ /* Private for OP_TRANS */ #define OPpTRANS_FROM_UTF 1 #define OPpTRANS_TO_UTF 2 #define OPpTRANS_IDENTICAL 4 /* right side is same as left */ #define OPpTRANS_SQUASH 8 /* 16 is used for OPpTARGET_MY */ #define OPpTRANS_COMPLEMENT 32 #define OPpTRANS_GROWS 64 #define OPpTRANS_DELETE 128 #define OPpTRANS_ALL (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE) /* Private for OP_REPEAT */ #define OPpREPEAT_DOLIST 64 /* List replication. */ /* Private for OP_RV2GV, OP_RV2SV, OP_AELEM, OP_HELEM, OP_PADSV */ #define OPpDEREF (32|64) /* autovivify: Want ref to something: */ #define OPpDEREF_AV 32 /* Want ref to AV. */ #define OPpDEREF_HV 64 /* Want ref to HV. */ #define OPpDEREF_SV (32|64) /* Want ref to SV. */ /* OP_ENTERSUB only */ #define OPpENTERSUB_DB 16 /* Debug subroutine. */ #define OPpENTERSUB_HASTARG 4 /* Called from OP tree. */ #define OPpENTERSUB_INARGS 1 /* Lval used as arg to a sub. */ /* used by OPpDEREF (32|64) */ /* used by HINT_STRICT_SUBS 2 */ /* Mask for OP_ENTERSUB flags, the absence of which must be propagated in dynamic context */ #define OPpENTERSUB_LVAL_MASK (OPpLVAL_INTRO|OPpENTERSUB_INARGS) /* OP_RV2CV only */ #define OPpENTERSUB_AMPER 8 /* Used & form to call. */ #define OPpENTERSUB_NOPAREN 128 /* bare sub call (without parens) */ #define OPpMAY_RETURN_CONSTANT 1 /* If a constant sub, return the constant */ /* OP_GV only */ #define OPpEARLY_CV 32 /* foo() called before sub foo was parsed */ /* OP_?ELEM only */ #define OPpLVAL_DEFER 16 /* Defer creation of array/hash elem */ /* OP_RV2[SAH]V, OP_GVSV, OP_ENTERITER only */ #define OPpOUR_INTRO 16 /* Variable was in an our() */ /* OP_RV2[AGH]V, OP_PAD[AH]V, OP_[AH]ELEM, OP_[AH]SLICE OP_AV2ARYLEN, OP_R?KEYS, OP_SUBSTR, OP_POS, OP_VEC */ #define OPpMAYBE_LVSUB 8 /* We might be an lvalue to return */ /* OP_SUBSTR only */ #define OPpSUBSTR_REPL_FIRST 16 /* 1st arg is replacement string */ /* OP_PADSV only */ #define OPpPAD_STATE 16 /* is a "state" pad */ /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */ /* OP_RV2GV only */ #define OPpDONT_INIT_GV 4 /* Call gv_fetchpv with GV_NOINIT */ /* (Therefore will return whatever is currently in the symbol table, not guaranteed to be a PVGV) */ #define OPpALLOW_FAKE 16 /* OK to return fake glob */ /* Private for OP_ENTERITER and OP_ITER */ #define OPpITER_REVERSED 4 /* for (reverse ...) */ #define OPpITER_DEF 8 /* for $_ or for my $_ */ /* Private for OP_CONST */ #define OPpCONST_NOVER 2 /* no 6; */ #define OPpCONST_SHORTCIRCUIT 4 /* eg the constant 5 in (5 || foo) */ #define OPpCONST_STRICT 8 /* bareword subject to strict 'subs' */ #define OPpCONST_ENTERED 16 /* Has been entered as symbol. */ #define OPpCONST_BARE 64 /* Was a bare word (filehandle?). */ #define OPpCONST_WARNING 128 /* Was a $^W translated to constant. */ /* Private for OP_FLIP/FLOP */ #define OPpFLIP_LINENUM 64 /* Range arg potentially a line num. */ /* Private for OP_LIST */ #define OPpLIST_GUESSED 64 /* Guessed that pushmark was needed. */ /* Private for OP_DELETE */ #define OPpSLICE 64 /* Operating on a list of keys */ /* Also OPpLVAL_INTRO (128) */ /* Private for OP_EXISTS */ #define OPpEXISTS_SUB 64 /* Checking for &sub, not {} or []. */ /* Private for OP_SORT */ #define OPpSORT_NUMERIC 1 /* Optimized away { $a <=> $b } */ #define OPpSORT_INTEGER 2 /* Ditto while under "use integer" */ #define OPpSORT_REVERSE 4 /* Reversed sort */ #define OPpSORT_INPLACE 8 /* sort in-place; eg @a = sort @a */ #define OPpSORT_DESCEND 16 /* Descending sort */ #define OPpSORT_QSORT 32 /* Use quicksort (not mergesort) */ #define OPpSORT_STABLE 64 /* Use a stable algorithm */ /* Private for OP_REVERSE */ #define OPpREVERSE_INPLACE 8 /* reverse in-place (@a = reverse @a) */ /* Private for OP_OPEN and OP_BACKTICK */ #define OPpOPEN_IN_RAW 16 /* binmode(F,":raw") on input fh */ #define OPpOPEN_IN_CRLF 32 /* binmode(F,":crlf") on input fh */ #define OPpOPEN_OUT_RAW 64 /* binmode(F,":raw") on output fh */ #define OPpOPEN_OUT_CRLF 128 /* binmode(F,":crlf") on output fh */ /* Private for OP_EXIT, HUSH also for OP_DIE */ #define OPpHUSH_VMSISH 64 /* hush DCL exit msg vmsish mode*/ #define OPpEXIT_VMSISH 128 /* exit(0) vs. exit(1) vmsish mode*/ /* Private for OP_FTXXX */ #define OPpFT_ACCESS 2 /* use filetest 'access' */ #define OPpFT_STACKED 4 /* stacked filetest, as "-f" in "-f -x $f" */ #define OPpFT_STACKING 8 /* stacking filetest, as "-x" in "-f -x $f" */ #define OPpFT_AFTER_t 16 /* previous op was -t */ /* Private for OP_(MAP|GREP)(WHILE|START) */ #define OPpGREP_LEX 2 /* iterate over lexical $_ */ /* Private for OP_ENTEREVAL */ #define OPpEVAL_HAS_HH 2 /* Does it have a copy of %^H */ #define OPpEVAL_UNICODE 4 #define OPpEVAL_BYTES 8 #define OPpEVAL_COPHH 16 /* Construct %^H from cop hints */ /* Private for OP_CALLER, OP_WANTARRAY and OP_RUNCV */ #define OPpOFFBYONE 128 /* Treat caller(1) as caller(2) */ /* Private for OP_COREARGS */ /* These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. See pp.c:S_rv2gv. */ #define OPpCOREARGS_DEREF1 1 /* Arg 1 is a handle constructor */ #define OPpCOREARGS_DEREF2 2 /* Arg 2 is a handle constructor */ #define OPpCOREARGS_SCALARMOD 64 /* \$ rather than \[$@%*] */ #define OPpCOREARGS_PUSHMARK 128 /* Call pp_pushmark */ /* Private for OP_(LAST|REDO|NEXT|GOTO|DUMP) */ #define OPpPV_IS_UTF8 128 /* label is in UTF8 */ struct op { BASEOP }; struct unop { BASEOP OP * op_first; }; struct binop { BASEOP OP * op_first; OP * op_last; }; struct logop { BASEOP OP * op_first; OP * op_other; }; struct listop { BASEOP OP * op_first; OP * op_last; }; struct pmop { BASEOP OP * op_first; OP * op_last; #ifdef USE_ITHREADS IV op_pmoffset; #else REGEXP * op_pmregexp; /* compiled expression */ #endif U32 op_pmflags; union { OP * op_pmreplroot; /* For OP_SUBST */ #ifdef USE_ITHREADS PADOFFSET op_pmtargetoff; /* For OP_PUSHRE */ #else GV * op_pmtargetgv; #endif } op_pmreplrootu; union { OP * op_pmreplstart; /* Only used in OP_SUBST */ #ifdef USE_ITHREADS struct { char * op_pmstashpv; /* Only used in OP_MATCH, with PMf_ONCE set */ U32 op_pmstashflags; /* currently only SVf_UTF8 or 0 */ } op_pmstashthr; #else HV * op_pmstash; #endif } op_pmstashstartu; }; #ifdef USE_ITHREADS #define PM_GETRE(o) (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \ ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL) /* The assignment is just to enforce type safety (or at least get a warning). */ /* With first class regexps not via a reference one needs to assign &PL_sv_undef under ithreads. (This would probably work unthreaded, but NULL is cheaper. I guess we could allow NULL, but the check above would get more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */ /* BEWARE - something that calls this macro passes (r) which has a side effect. */ #define PM_SETRE(o,r) STMT_START { \ REGEXP *const _pm_setre = (r); \ assert(_pm_setre); \ PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \ } STMT_END #else #define PM_GETRE(o) ((o)->op_pmregexp) #define PM_SETRE(o,r) ((o)->op_pmregexp = (r)) #endif /* Leave some space, so future bit allocations can go either in the shared or * unshared area without affecting binary compatibility */ #define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+6) /* 'use re "taint"' in scope: taint $1 etc. if target tainted */ #define PMf_RETAINT (1<<(PMf_BASE_SHIFT+0)) /* match successfully only once per reset, with related flag RXf_USED in * re->extflags holding state. This is used only for ?? matches, and only on * OP_MATCH and OP_QR */ #define PMf_ONCE (1<<(PMf_BASE_SHIFT+1)) /* replacement contains variables */ #define PMf_MAYBE_CONST (1<<(PMf_BASE_SHIFT+2)) /* PMf_ONCE has matched successfully. Not used under threading. */ #define PMf_USED (1<<(PMf_BASE_SHIFT+3)) /* subst replacement is constant */ #define PMf_CONST (1<<(PMf_BASE_SHIFT+4)) /* keep 1st runtime pattern forever */ #define PMf_KEEP (1<<(PMf_BASE_SHIFT+5)) #define PMf_GLOBAL (1<<(PMf_BASE_SHIFT+6)) /* pattern had a g modifier */ /* don't reset pos() if //g fails */ #define PMf_CONTINUE (1<<(PMf_BASE_SHIFT+7)) /* evaluating replacement as expr */ #define PMf_EVAL (1<<(PMf_BASE_SHIFT+8)) /* Return substituted string instead of modifying it. */ #define PMf_NONDESTRUCT (1<<(PMf_BASE_SHIFT+9)) #if PMf_BASE_SHIFT+9 > 31 # error Too many PMf_ bits used. See above and regnodes.h for any spare in middle #endif #ifdef USE_ITHREADS # define PmopSTASHPV(o) \ (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv : NULL) # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define PmopSTASHPV_set(o,pv) ({ \ assert((o)->op_pmflags & PMf_ONCE); \ ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv = savesharedpv(pv)); \ }) # else # define PmopSTASHPV_set(o,pv) \ ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv = savesharedpv(pv)) # endif # define PmopSTASH_flags(o) ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashflags) # define PmopSTASH_flags_set(o,flags) ((o)->op_pmstashstartu.op_pmstashthr.op_pmstashflags = flags) # define PmopSTASH(o) (PmopSTASHPV(o) \ ? gv_stashpv((o)->op_pmstashstartu.op_pmstashthr.op_pmstashpv, \ GV_ADD | PmopSTASH_flags(o)) : NULL) # define PmopSTASH_set(o,hv) (PmopSTASHPV_set(o, (hv) ? HvNAME_get(hv) : NULL), \ PmopSTASH_flags_set(o, \ ((hv) && HvNAME_HEK(hv) && \ HvNAMEUTF8(hv)) \ ? SVf_UTF8 \ : 0)) # define PmopSTASH_free(o) PerlMemShared_free(PmopSTASHPV(o)) #else # define PmopSTASH(o) \ (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL) # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) # define PmopSTASH_set(o,hv) ({ \ assert((o)->op_pmflags & PMf_ONCE); \ ((o)->op_pmstashstartu.op_pmstash = (hv)); \ }) # else # define PmopSTASH_set(o,hv) ((o)->op_pmstashstartu.op_pmstash = (hv)) # endif # define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL) /* op_pmstashstartu.op_pmstash is not refcounted */ # define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) /* Note that if this becomes non-empty, then S_forget_pmop in op.c will need changing */ # define PmopSTASH_free(o) #endif struct svop { BASEOP SV * op_sv; }; struct padop { BASEOP PADOFFSET op_padix; }; struct pvop { BASEOP char * op_pv; }; struct loop { BASEOP OP * op_first; OP * op_last; OP * op_redoop; OP * op_nextop; OP * op_lastop; }; #define cUNOPx(o) ((UNOP*)o) #define cBINOPx(o) ((BINOP*)o) #define cLISTOPx(o) ((LISTOP*)o) #define cLOGOPx(o) ((LOGOP*)o) #define cPMOPx(o) ((PMOP*)o) #define cSVOPx(o) ((SVOP*)o) #define cPADOPx(o) ((PADOP*)o) #define cPVOPx(o) ((PVOP*)o) #define cCOPx(o) ((COP*)o) #define cLOOPx(o) ((LOOP*)o) #define cUNOP cUNOPx(PL_op) #define cBINOP cBINOPx(PL_op) #define cLISTOP cLISTOPx(PL_op) #define cLOGOP cLOGOPx(PL_op) #define cPMOP cPMOPx(PL_op) #define cSVOP cSVOPx(PL_op) #define cPADOP cPADOPx(PL_op) #define cPVOP cPVOPx(PL_op) #define cCOP cCOPx(PL_op) #define cLOOP cLOOPx(PL_op) #define cUNOPo cUNOPx(o) #define cBINOPo cBINOPx(o) #define cLISTOPo cLISTOPx(o) #define cLOGOPo cLOGOPx(o) #define cPMOPo cPMOPx(o) #define cSVOPo cSVOPx(o) #define cPADOPo cPADOPx(o) #define cPVOPo cPVOPx(o) #define cCOPo cCOPx(o) #define cLOOPo cLOOPx(o) #define kUNOP cUNOPx(kid) #define kBINOP cBINOPx(kid) #define kLISTOP cLISTOPx(kid) #define kLOGOP cLOGOPx(kid) #define kPMOP cPMOPx(kid) #define kSVOP cSVOPx(kid) #define kPADOP cPADOPx(kid) #define kPVOP cPVOPx(kid) #define kCOP cCOPx(kid) #define kLOOP cLOOPx(kid) #ifdef USE_ITHREADS # define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix)) # define IS_PADGV(v) (v && SvTYPE(v) == SVt_PVGV && isGV_with_GP(v) \ && GvIN_PAD(v)) # define IS_PADCONST(v) (v && SvREADONLY(v)) # define cSVOPx_sv(v) (cSVOPx(v)->op_sv \ ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ)) # define cSVOPx_svp(v) (cSVOPx(v)->op_sv \ ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ)) #else # define cGVOPx_gv(o) ((GV*)cSVOPx(o)->op_sv) # define IS_PADGV(v) FALSE # define IS_PADCONST(v) FALSE # define cSVOPx_sv(v) (cSVOPx(v)->op_sv) # define cSVOPx_svp(v) (&cSVOPx(v)->op_sv) #endif #define cGVOP_gv cGVOPx_gv(PL_op) #define cGVOPo_gv cGVOPx_gv(o) #define kGVOP_gv cGVOPx_gv(kid) #define cSVOP_sv cSVOPx_sv(PL_op) #define cSVOPo_sv cSVOPx_sv(o) #define kSVOP_sv cSVOPx_sv(kid) #ifndef PERL_CORE # define Nullop ((OP*)NULL) #endif /* Lowest byte of PL_opargs */ #define OA_MARK 1 #define OA_FOLDCONST 2 #define OA_RETSCALAR 4 #define OA_TARGET 8 #define OA_TARGLEX 16 #define OA_OTHERINT 32 #define OA_DANGEROUS 64 #define OA_DEFGV 128 /* The next 4 bits encode op class information */ #define OCSHIFT 8 #define OA_CLASS_MASK (15 << OCSHIFT) #define OA_BASEOP (0 << OCSHIFT) #define OA_UNOP (1 << OCSHIFT) #define OA_BINOP (2 << OCSHIFT) #define OA_LOGOP (3 << OCSHIFT) #define OA_LISTOP (4 << OCSHIFT) #define OA_PMOP (5 << OCSHIFT) #define OA_SVOP (6 << OCSHIFT) #define OA_PADOP (7 << OCSHIFT) #define OA_PVOP_OR_SVOP (8 << OCSHIFT) #define OA_LOOP (9 << OCSHIFT) #define OA_COP (10 << OCSHIFT) #define OA_BASEOP_OR_UNOP (11 << OCSHIFT) #define OA_FILESTATOP (12 << OCSHIFT) #define OA_LOOPEXOP (13 << OCSHIFT) #define OASHIFT 12 /* Remaining nybbles of PL_opargs */ #define OA_SCALAR 1 #define OA_LIST 2 #define OA_AVREF 3 #define OA_HVREF 4 #define OA_CVREF 5 #define OA_FILEREF 6 #define OA_SCALARREF 7 #define OA_OPTIONAL 8 /* Op_REFCNT is a reference count at the head of each op tree: needed * since the tree is shared between threads, and between cloned closure * copies in the same thread. OP_REFCNT_LOCK/UNLOCK is used when modifying * this count. * The same mutex is used to protect the refcounts of the reg_trie_data * and reg_ac_data structures, which are shared between duplicated * regexes. */ #ifdef USE_ITHREADS # define OP_REFCNT_INIT MUTEX_INIT(&PL_op_mutex) # ifdef PERL_CORE # define OP_REFCNT_LOCK MUTEX_LOCK(&PL_op_mutex) # define OP_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_op_mutex) # else # define OP_REFCNT_LOCK op_refcnt_lock() # define OP_REFCNT_UNLOCK op_refcnt_unlock() # endif # define OP_REFCNT_TERM MUTEX_DESTROY(&PL_op_mutex) #else # define OP_REFCNT_INIT NOOP # define OP_REFCNT_LOCK NOOP # define OP_REFCNT_UNLOCK NOOP # define OP_REFCNT_TERM NOOP #endif #define OpREFCNT_set(o,n) ((o)->op_targ = (n)) #ifdef PERL_DEBUG_READONLY_OPS # define OpREFCNT_inc(o) Perl_op_refcnt_inc(aTHX_ o) # define OpREFCNT_dec(o) Perl_op_refcnt_dec(aTHX_ o) #else # define OpREFCNT_inc(o) ((o) ? (++(o)->op_targ, (o)) : NULL) # define OpREFCNT_dec(o) (--(o)->op_targ) #endif /* flags used by Perl_load_module() */ #define PERL_LOADMOD_DENY 0x1 /* no Module */ #define PERL_LOADMOD_NOIMPORT 0x2 /* use Module () */ #define PERL_LOADMOD_IMPORT_OPS 0x4 /* use Module (...) */ #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) #define ref(o, type) doref(o, type, TRUE) #endif /* =head1 Optree Manipulation Functions =for apidoc Am|OP*|LINKLIST|OP *o Given the root of an optree, link the tree in execution order using the C pointers and return the first op executed. If this has already been done, it will not be redone, and C<< o->op_next >> will be returned. If C<< o->op_next >> is not already set, I should be at least an C. =cut */ #define LINKLIST(o) ((o)->op_next ? (o)->op_next : op_linklist((OP*)o)) /* no longer used anywhere in core */ #ifndef PERL_CORE #define cv_ckproto(cv, gv, p) \ cv_ckproto_len_flags((cv), (gv), (p), (p) ? strlen(p) : 0, 0) #endif #ifdef PERL_CORE # define my(o) my_attrs((o), NULL) #endif #ifdef USE_REENTRANT_API #include "reentr.h" #endif #if defined(PL_OP_SLAB_ALLOC) #define NewOp(m,var,c,type) \ (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type))) #define NewOpSz(m,var,size) \ (var = (OP *) Perl_Slab_Alloc(aTHX_ size)) #define FreeOp(p) Perl_Slab_Free(aTHX_ p) #else #define NewOp(m, var, c, type) \ (var = (MEM_WRAP_CHECK_(c,type) \ (type*)PerlMemShared_calloc(c, sizeof(type)))) #define NewOpSz(m, var, size) \ (var = (OP*)PerlMemShared_calloc(1, size)) #define FreeOp(p) PerlMemShared_free(p) #endif struct block_hooks { U32 bhk_flags; void (*bhk_start) (pTHX_ int full); void (*bhk_pre_end) (pTHX_ OP **seq); void (*bhk_post_end) (pTHX_ OP **seq); void (*bhk_eval) (pTHX_ OP *const saveop); }; /* =head1 Compile-time scope hooks =for apidoc mx|U32|BhkFLAGS|BHK *hk Return the BHK's flags. =for apidoc mx|void *|BhkENTRY|BHK *hk|which Return an entry from the BHK structure. I is a preprocessor token indicating which entry to return. If the appropriate flag is not set this will return NULL. The type of the return value depends on which entry you ask for. =for apidoc Amx|void|BhkENTRY_set|BHK *hk|which|void *ptr Set an entry in the BHK structure, and set the flags to indicate it is valid. I is a preprocessing token indicating which entry to set. The type of I depends on the entry. =for apidoc Amx|void|BhkDISABLE|BHK *hk|which Temporarily disable an entry in this BHK structure, by clearing the appropriate flag. I is a preprocessor token indicating which entry to disable. =for apidoc Amx|void|BhkENABLE|BHK *hk|which Re-enable an entry in this BHK structure, by setting the appropriate flag. I is a preprocessor token indicating which entry to enable. This will assert (under -DDEBUGGING) if the entry doesn't contain a valid pointer. =for apidoc mx|void|CALL_BLOCK_HOOKS|which|arg Call all the registered block hooks for type I. I is a preprocessing token; the type of I depends on I. =cut */ #define BhkFLAGS(hk) ((hk)->bhk_flags) #define BHKf_bhk_start 0x01 #define BHKf_bhk_pre_end 0x02 #define BHKf_bhk_post_end 0x04 #define BHKf_bhk_eval 0x08 #define BhkENTRY(hk, which) \ ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->which) : NULL) #define BhkENABLE(hk, which) \ STMT_START { \ BhkFLAGS(hk) |= BHKf_ ## which; \ assert(BhkENTRY(hk, which)); \ } STMT_END #define BhkDISABLE(hk, which) \ STMT_START { \ BhkFLAGS(hk) &= ~(BHKf_ ## which); \ } STMT_END #define BhkENTRY_set(hk, which, ptr) \ STMT_START { \ (hk)->which = ptr; \ BhkENABLE(hk, which); \ } STMT_END #define CALL_BLOCK_HOOKS(which, arg) \ STMT_START { \ if (PL_blockhooks) { \ I32 i; \ for (i = av_len(PL_blockhooks); i >= 0; i--) { \ SV *sv = AvARRAY(PL_blockhooks)[i]; \ BHK *hk; \ \ assert(SvIOK(sv)); \ if (SvUOK(sv)) \ hk = INT2PTR(BHK *, SvUVX(sv)); \ else \ hk = INT2PTR(BHK *, SvIVX(sv)); \ \ if (BhkENTRY(hk, which)) \ BhkENTRY(hk, which)(aTHX_ arg); \ } \ } \ } STMT_END /* flags for rv2cv_op_cv */ #define RV2CVOPCV_MARK_EARLY 0x00000001 #define RV2CVOPCV_RETURN_NAME_GV 0x00000002 #define op_lvalue(op,t) Perl_op_lvalue_flags(aTHX_ op,t,0) /* flags for op_lvalue_flags */ #define OP_LVALUE_NO_CROAK 1 /* =head1 Custom Operators =for apidoc Am|U32|XopFLAGS|XOP *xop Return the XOP's flags. =for apidoc Am||XopENTRY|XOP *xop|which Return a member of the XOP structure. I is a cpp token indicating which entry to return. If the member is not set this will return a default value. The return type depends on I. =for apidoc Am|void|XopENTRY_set|XOP *xop|which|value Set a member of the XOP structure. I is a cpp token indicating which entry to set. See L for details about the available members and how they are used. =for apidoc Am|void|XopDISABLE|XOP *xop|which Temporarily disable a member of the XOP, by clearing the appropriate flag. =for apidoc Am|void|XopENABLE|XOP *xop|which Reenable a member of the XOP which has been disabled. =cut */ struct custom_op { U32 xop_flags; const char *xop_name; const char *xop_desc; U32 xop_class; void (*xop_peep)(pTHX_ OP *o, OP *oldop); }; #define XopFLAGS(xop) ((xop)->xop_flags) #define XOPf_xop_name 0x01 #define XOPf_xop_desc 0x02 #define XOPf_xop_class 0x04 #define XOPf_xop_peep 0x08 #define XOPd_xop_name PL_op_name[OP_CUSTOM] #define XOPd_xop_desc PL_op_desc[OP_CUSTOM] #define XOPd_xop_class OA_BASEOP #define XOPd_xop_peep ((Perl_cpeep_t)0) #define XopENTRY_set(xop, which, to) \ STMT_START { \ (xop)->which = (to); \ (xop)->xop_flags |= XOPf_ ## which; \ } STMT_END #define XopENTRY(xop, which) \ ((XopFLAGS(xop) & XOPf_ ## which) ? (xop)->which : XOPd_ ## which) #define XopDISABLE(xop, which) ((xop)->xop_flags &= ~XOPf_ ## which) #define XopENABLE(xop, which) \ STMT_START { \ (xop)->xop_flags |= XOPf_ ## which; \ assert(XopENTRY(xop, which)); \ } STMT_END /* =head1 Optree Manipulation Functions =for apidoc Am|const char *|OP_NAME|OP *o Return the name of the provided OP. For core ops this looks up the name from the op_type; for custom ops from the op_ppaddr. =for apidoc Am|const char *|OP_DESC|OP *o Return a short description of the provided OP. =for apidoc Am|U32|OP_CLASS|OP *o Return the class of the provided OP: that is, which of the *OP structures it uses. For core ops this currently gets the information out of PL_opargs, which does not always accurately reflect the type used. For custom ops the type is returned from the registration, and it is up to the registree to ensure it is accurate. The value returned will be one of the OA_* constants from op.h. =cut */ #define OP_NAME(o) ((o)->op_type == OP_CUSTOM \ ? XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_name) \ : PL_op_name[(o)->op_type]) #define OP_DESC(o) ((o)->op_type == OP_CUSTOM \ ? XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_desc) \ : PL_op_desc[(o)->op_type]) #define OP_CLASS(o) ((o)->op_type == OP_CUSTOM \ ? XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_class) \ : (PL_opargs[(o)->op_type] & OA_CLASS_MASK)) #define newSUB(f, o, p, b) Perl_newATTRSUB(aTHX_ (f), (o), (p), NULL, (b)) #ifdef PERL_MAD # define MAD_NULL 1 # define MAD_PV 2 # define MAD_OP 3 # define MAD_SV 4 struct madprop { MADPROP* mad_next; void *mad_val; U32 mad_vlen; /* short mad_count; */ char mad_key; char mad_type; }; struct token { I32 tk_type; YYSTYPE tk_lval; MADPROP* tk_mad; }; #endif /* * Values that can be held by mad_key : * ^ unfilled head spot * , literal , * ; literal ; (blank if implicit ; at end of block) * : literal : from ?: or attr list * + unary + * ? literal ? from ?: * ( literal ( * ) literal ) * [ literal [ * ] literal ] * { literal { * } literal } * @ literal @ sigil * $ literal $ sigil * * literal * sigil * ! use is source filtered * & & or sub * # whitespace/comment following ; or } * # $# sigil * 1 1st ; from for(;;) * 1 retired protasis * 2 2nd ; from for(;;) * 2 retired apodosis * 3 C-style for list * a sub or var attributes * a non-method arrow operator * A method arrow operator * A use import args * b format block * B retired stub block * C constant conditional op * d declarator * D do block * e unreached "else" (see C) * e expression producing E * E tr/E/R/, /E/ * f folded constant op * F peg op for format * g op was forced to be a word * i if/unless modifier * I if/elsif/unless statement * k local declarator * K retired kid op * l last index of array ($#foo) * L label * m modifier on regex * n sub or format name * o current operator/declarator name * o else/continue * O generic optimized op * p peg to hold extra whitespace at statement level * P peg op for package declaration * q opening quote * = quoted material * Q closing quote * Q optimized qw// * r expression producing R * R tr/E/R/ s/E/R/ * s sub signature * S use import stub (no import) * S retired sort block * t unreached "then" (see C) * U use import op * v private sv of for loop * V use version * w while/until modifier * W while/for statement * x optimized qw * X random thing * _ whitespace/comments preceding anything else * ~ =~ operator */ /* =head1 Hook manipulation */ #ifdef USE_ITHREADS # define OP_CHECK_MUTEX_INIT MUTEX_INIT(&PL_check_mutex) # define OP_CHECK_MUTEX_LOCK MUTEX_LOCK(&PL_check_mutex) # define OP_CHECK_MUTEX_UNLOCK MUTEX_UNLOCK(&PL_check_mutex) # define OP_CHECK_MUTEX_TERM MUTEX_DESTROY(&PL_check_mutex) #else # define OP_CHECK_MUTEX_INIT NOOP # define OP_CHECK_MUTEX_LOCK NOOP # define OP_CHECK_MUTEX_UNLOCK NOOP # define OP_CHECK_MUTEX_TERM NOOP #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZT+T+perlio.hnuW+A/* perlio.h * * Copyright (C) 1996, 1997, 1999, 2000, 2001, 2002, 2003, * 2004, 2005, 2006, 2007, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ #ifndef _PERLIO_H #define _PERLIO_H /* Interface for perl to IO functions. There is a hierarchy of Configure determined #define controls: USE_STDIO - forces PerlIO_xxx() to be #define-d onto stdio functions. This is used for x2p subdirectory and for conservative builds - "just like perl5.00X used to be". This dominates over the others. USE_PERLIO - The primary Configure variable that enables PerlIO. If USE_PERLIO is _NOT_ set then USE_STDIO above will be set to be conservative. If USE_PERLIO is set then there are two modes determined by USE_SFIO: USE_SFIO - If set causes PerlIO_xxx() to be #define-d onto sfio functions. A backward compatibility mode for some specialist applications. If USE_SFIO is not set then PerlIO_xxx() are real functions defined in perlio.c which implement extra functionality required for utf8 support. One further note - the table-of-functions scheme controlled by PERL_IMPLICIT_SYS turns on USE_PERLIO so that iperlsys.h can #define PerlIO_xxx() to go via the function table, without having to #undef them from (say) stdio forms. */ #if defined(PERL_IMPLICIT_SYS) #ifndef USE_PERLIO #ifndef NETWARE /* # define USE_PERLIO */ #endif #endif #endif #ifndef USE_PERLIO # define USE_STDIO #endif #ifdef USE_STDIO # ifndef PERLIO_IS_STDIO # define PERLIO_IS_STDIO # endif #endif /* -------------------- End of Configure controls ---------------------------- */ /* * Although we may not want stdio to be used including here * avoids issues where stdio.h has strange side effects */ #include #ifdef __BEOS__ int fseeko(FILE *stream, off_t offset, int whence); off_t ftello(FILE *stream); #endif #if defined(USE_64_BIT_STDIO) && defined(HAS_FTELLO) && !defined(USE_FTELL64) #define ftell ftello #endif #if defined(USE_64_BIT_STDIO) && defined(HAS_FSEEKO) && !defined(USE_FSEEK64) #define fseek fseeko #endif /* BS2000 includes are sometimes a bit non standard :-( */ #if defined(POSIX_BC) && defined(O_BINARY) && !defined(O_TEXT) #undef O_BINARY #endif #ifdef PERLIO_IS_STDIO /* #define PerlIO_xxxx() as equivalent stdio function */ #include "perlsdio.h" #else /* PERLIO_IS_STDIO */ #ifdef USE_SFIO /* #define PerlIO_xxxx() as equivalent sfio function */ #include "perlsfio.h" #endif /* USE_SFIO */ #endif /* PERLIO_IS_STDIO */ #ifndef PerlIO /* ----------- PerlIO implementation ---------- */ /* PerlIO not #define-d to something else - define the implementation */ typedef struct _PerlIO PerlIOl; typedef struct _PerlIO_funcs PerlIO_funcs; typedef PerlIOl *PerlIO; #define PerlIO PerlIO #define PERLIO_LAYERS 1 /* Making the big PerlIO_funcs vtables const is good (enables placing * them in the const section which is good for speed, security, and * embeddability) but this cannot be done by default because of * backward compatibility. */ #ifdef PERLIO_FUNCS_CONST #define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs #define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) #else #define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs #define PERLIO_FUNCS_CAST(funcs) (funcs) #endif PERL_EXPORT_C void PerlIO_define_layer(pTHX_ PerlIO_funcs *tab); PERL_EXPORT_C PerlIO_funcs *PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load); PERL_EXPORT_C PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg); PERL_EXPORT_C void PerlIO_pop(pTHX_ PerlIO *f); PERL_EXPORT_C AV* PerlIO_get_layers(pTHX_ PerlIO *f); PERL_EXPORT_C void PerlIO_clone(pTHX_ PerlInterpreter *proto, CLONE_PARAMS *param); #endif /* PerlIO */ /* ----------- End of implementation choices ---------- */ #ifndef PERLIO_IS_STDIO /* Not using stdio _directly_ as PerlIO */ /* We now need to determine what happens if source trys to use stdio. * There are three cases based on PERLIO_NOT_STDIO which XS code * can set how it wants. */ #ifdef PERL_CORE /* Make a choice for perl core code - currently this is set to try and catch lingering raw stdio calls. This is a known issue with some non UNIX ports which still use "native" stdio features. */ #ifndef PERLIO_NOT_STDIO #define PERLIO_NOT_STDIO 1 #endif #else #ifndef PERLIO_NOT_STDIO #define PERLIO_NOT_STDIO 0 #endif #endif #ifdef PERLIO_NOT_STDIO #if PERLIO_NOT_STDIO /* * PERLIO_NOT_STDIO #define'd as 1 * Case 1: Strong denial of stdio - make all stdio calls (we can think of) errors */ #include "nostdio.h" #else /* if PERLIO_NOT_STDIO */ /* * PERLIO_NOT_STDIO #define'd as 0 * Case 2: Declares that both PerlIO and stdio can be used */ #endif /* if PERLIO_NOT_STDIO */ #else /* ifdef PERLIO_NOT_STDIO */ /* * PERLIO_NOT_STDIO not defined * Case 3: Try and fake stdio calls as PerlIO calls */ #include "fakesdio.h" #endif /* ifndef PERLIO_NOT_STDIO */ #endif /* PERLIO_IS_STDIO */ /* ----------- fill in things that have not got #define'd ---------- */ #ifndef Fpos_t #define Fpos_t Off_t #endif #ifndef EOF #define EOF (-1) #endif /* This is to catch case with no stdio */ #ifndef BUFSIZ #define BUFSIZ 1024 #endif /* The default buffer size for the perlio buffering layer */ #ifndef PERLIOBUF_DEFAULT_BUFSIZ #define PERLIOBUF_DEFAULT_BUFSIZ (BUFSIZ > 8192 ? BUFSIZ : 8192) #endif #ifndef SEEK_SET #define SEEK_SET 0 #endif #ifndef SEEK_CUR #define SEEK_CUR 1 #endif #ifndef SEEK_END #define SEEK_END 2 #endif #define PERLIO_DUP_CLONE 1 #define PERLIO_DUP_FD 2 /* --------------------- Now prototypes for functions --------------- */ START_EXTERN_C #ifndef __attribute__format__ # ifdef HASATTRIBUTE_FORMAT # define __attribute__format__(x,y,z) __attribute__((format(x,y,z))) # else # define __attribute__format__(x,y,z) # endif #endif #ifndef PerlIO_init PERL_EXPORT_C void PerlIO_init(pTHX); #endif #ifndef PerlIO_stdoutf PERL_EXPORT_C int PerlIO_stdoutf(const char *, ...) __attribute__format__(__printf__, 1, 2); #endif #ifndef PerlIO_puts PERL_EXPORT_C int PerlIO_puts(PerlIO *, const char *); #endif #ifndef PerlIO_open PERL_EXPORT_C PerlIO *PerlIO_open(const char *, const char *); #endif #ifndef PerlIO_openn PERL_EXPORT_C PerlIO *PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **arg); #endif #ifndef PerlIO_eof PERL_EXPORT_C int PerlIO_eof(PerlIO *); #endif #ifndef PerlIO_error PERL_EXPORT_C int PerlIO_error(PerlIO *); #endif #ifndef PerlIO_clearerr PERL_EXPORT_C void PerlIO_clearerr(PerlIO *); #endif #ifndef PerlIO_getc PERL_EXPORT_C int PerlIO_getc(PerlIO *); #endif #ifndef PerlIO_putc PERL_EXPORT_C int PerlIO_putc(PerlIO *, int); #endif #ifndef PerlIO_ungetc PERL_EXPORT_C int PerlIO_ungetc(PerlIO *, int); #endif #ifndef PerlIO_fdopen PERL_EXPORT_C PerlIO *PerlIO_fdopen(int, const char *); #endif #ifndef PerlIO_importFILE PERL_EXPORT_C PerlIO *PerlIO_importFILE(FILE *, const char *); #endif #ifndef PerlIO_exportFILE PERL_EXPORT_C FILE *PerlIO_exportFILE(PerlIO *, const char *); #endif #ifndef PerlIO_findFILE PERL_EXPORT_C FILE *PerlIO_findFILE(PerlIO *); #endif #ifndef PerlIO_releaseFILE PERL_EXPORT_C void PerlIO_releaseFILE(PerlIO *, FILE *); #endif #ifndef PerlIO_read PERL_EXPORT_C SSize_t PerlIO_read(PerlIO *, void *, Size_t); #endif #ifndef PerlIO_unread PERL_EXPORT_C SSize_t PerlIO_unread(PerlIO *, const void *, Size_t); #endif #ifndef PerlIO_write PERL_EXPORT_C SSize_t PerlIO_write(PerlIO *, const void *, Size_t); #endif #ifndef PerlIO_setlinebuf PERL_EXPORT_C void PerlIO_setlinebuf(PerlIO *); #endif #ifndef PerlIO_printf PERL_EXPORT_C int PerlIO_printf(PerlIO *, const char *, ...) __attribute__format__(__printf__, 2, 3); #endif #ifndef PerlIO_sprintf PERL_EXPORT_C int PerlIO_sprintf(char *, int, const char *, ...) __attribute__format__(__printf__, 3, 4); #endif #ifndef PerlIO_vprintf PERL_EXPORT_C int PerlIO_vprintf(PerlIO *, const char *, va_list); #endif #ifndef PerlIO_tell PERL_EXPORT_C Off_t PerlIO_tell(PerlIO *); #endif #ifndef PerlIO_seek PERL_EXPORT_C int PerlIO_seek(PerlIO *, Off_t, int); #endif #ifndef PerlIO_rewind PERL_EXPORT_C void PerlIO_rewind(PerlIO *); #endif #ifndef PerlIO_has_base PERL_EXPORT_C int PerlIO_has_base(PerlIO *); #endif #ifndef PerlIO_has_cntptr PERL_EXPORT_C int PerlIO_has_cntptr(PerlIO *); #endif #ifndef PerlIO_fast_gets PERL_EXPORT_C int PerlIO_fast_gets(PerlIO *); #endif #ifndef PerlIO_canset_cnt PERL_EXPORT_C int PerlIO_canset_cnt(PerlIO *); #endif #ifndef PerlIO_get_ptr PERL_EXPORT_C STDCHAR *PerlIO_get_ptr(PerlIO *); #endif #ifndef PerlIO_get_cnt PERL_EXPORT_C int PerlIO_get_cnt(PerlIO *); #endif #ifndef PerlIO_set_cnt PERL_EXPORT_C void PerlIO_set_cnt(PerlIO *, int); #endif #ifndef PerlIO_set_ptrcnt PERL_EXPORT_C void PerlIO_set_ptrcnt(PerlIO *, STDCHAR *, int); #endif #ifndef PerlIO_get_base PERL_EXPORT_C STDCHAR *PerlIO_get_base(PerlIO *); #endif #ifndef PerlIO_get_bufsiz PERL_EXPORT_C int PerlIO_get_bufsiz(PerlIO *); #endif #ifndef PerlIO_tmpfile PERL_EXPORT_C PerlIO *PerlIO_tmpfile(void); #endif #ifndef PerlIO_stdin PERL_EXPORT_C PerlIO *PerlIO_stdin(void); #endif #ifndef PerlIO_stdout PERL_EXPORT_C PerlIO *PerlIO_stdout(void); #endif #ifndef PerlIO_stderr PERL_EXPORT_C PerlIO *PerlIO_stderr(void); #endif #ifndef PerlIO_getpos PERL_EXPORT_C int PerlIO_getpos(PerlIO *, SV *); #endif #ifndef PerlIO_setpos PERL_EXPORT_C int PerlIO_setpos(PerlIO *, SV *); #endif #ifndef PerlIO_fdupopen PERL_EXPORT_C PerlIO *PerlIO_fdupopen(pTHX_ PerlIO *, CLONE_PARAMS *, int); #endif #if !defined(PerlIO_modestr) && !defined(PERLIO_IS_STDIO) PERL_EXPORT_C char *PerlIO_modestr(PerlIO *, char *buf); #endif #ifndef PerlIO_isutf8 PERL_EXPORT_C int PerlIO_isutf8(PerlIO *); #endif #ifndef PerlIO_apply_layers PERL_EXPORT_C int PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names); #endif #ifndef PerlIO_binmode PERL_EXPORT_C int PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int omode, const char *names); #endif #ifndef PerlIO_getname PERL_EXPORT_C char *PerlIO_getname(PerlIO *, char *); #endif PERL_EXPORT_C void PerlIO_destruct(pTHX); PERL_EXPORT_C int PerlIO_intmode2str(int rawmode, char *mode, int *writing); #ifdef PERLIO_LAYERS PERL_EXPORT_C void PerlIO_cleanup(pTHX); PERL_EXPORT_C void PerlIO_debug(const char *fmt, ...) __attribute__format__(__printf__, 1, 2); typedef struct PerlIO_list_s PerlIO_list_t; #endif END_EXTERN_C #endif /* _PERLIO_H */ /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZL0DD utfebcdic.hnuW+A/* utfebcdic.h * * Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2009, * 2010, 2011 by Larry Wall, Nick Ing-Simmons, and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * Macros to implement UTF-EBCDIC as perl's internal encoding * Taken from version 7.1 of Unicode Technical Report #16: * http://www.unicode.org/unicode/reports/tr16 * * To summarize, the way it works is: * To convert an EBCDIC character to UTF-EBCDIC: * 1) convert to Unicode. The table in this file that does this for * EBCDIC bytes is PL_e2a (with inverse PLa2e). The 'a' stands for * ASCIIish, meaning latin1. * 2) convert that to a utf8-like string called I8 (I stands for * intermediate) with variant characters occupying multiple bytes. This * step is similar to the utf8-creating step from Unicode, but the details * are different. This transformation is called UTF8-Mod. There is a * chart about the bit patterns in a comment later in this file. But * essentially here are the differences: * UTF8 I8 * invariant byte starts with 0 starts with 0 or 100 * continuation byte starts with 10 starts with 101 * start byte same in both: if the code point requires N bytes, * then the leading N bits are 1, followed by a 0. (No * trailing 0 for the very largest possible allocation * in I8, far beyond the current Unicode standard's * max, as shown in the comment later in this file.) * 3) Use the table published in tr16 to convert each byte from step 2 into * final UTF-EBCDIC. That table is reproduced in this file as PL_utf2e, * and its inverse is PL_e2utf. They are constructed so that all EBCDIC * invariants remain invariant, but no others do. For example, the * ordinal value of 'A' is 193 in EBCDIC, and also is 193 in UTF-EBCDIC. * Step 1) converts it to 65, Step 2 leaves it at 65, and Step 3 converts * it back to 193. As an example of how a variant character works, take * LATIN SMALL LETTER Y WITH DIAERESIS, which is typically 0xDF in * EBCDIC. Step 1 converts it to the Unicode value, 0xFF. Step 2 * converts that to two bytes = 11000111 10111111 = C7 BF, and Step 3 * converts those to 0x8B 0x73. The table is constructed so that the * first byte of the final form of a variant will always have its upper * bit set (at least in the encodings that Perl recognizes, and probably * all). But note that the upper bit of some invariants is also 1. * * If you're starting from Unicode, skip step 1. For UTF-EBCDIC to straight * EBCDIC, reverse the steps. * * The EBCDIC invariants have been chosen to be those characters whose Unicode * equivalents have ordinal numbers less than 160, that is the same characters * that are expressible in ASCII, plus the C1 controls. So there are 160 * invariants instead of the 128 in UTF-8. (My guess is that this is because * the C1 control NEL (and maybe others) is important in IBM.) * * The purpose of Step 3 is to make the encoding be invariant for the chosen * characters. This messes up the convenient patterns found in step 2, so * generally, one has to undo step 3 into a temporary to use them. However, * a "shadow", or parallel table, PL_utf8skip, has been constructed so that for * each byte, it says how long the sequence is if that byte were to begin it * * There are actually 3 slightly different UTF-EBCDIC encodings in this file, * one for each of the code pages recognized by Perl. That means that there * are actually three different sets of tables, one for each code page. (If * Perl is compiled on platforms using another EBCDIC code page, it may not * compile, or Perl may silently mistake it for one of the three.) * * EBCDIC characters above 0xFF are the same as Unicode in Perl's * implementation of all 3 encodings, so for those Step 1 is trivial. * * (Note that the entries for invariant characters are necessarily the same in * PL_e2a and PLe2f, and the same for their inverses.) * * UTF-EBCDIC strings are the same length or longer than UTF-8 representations * of the same string. The maximum code point representable as 2 bytes in * UTF-EBCDIC is 0x3FFF, instead of 0x7FFF in UTF-8. */ START_EXTERN_C #ifdef DOINIT /* Indexed by encoded byte this table gives the length of the sequence. Adapted from the shadow flags table in tr16. The entries marked 9 in tr16 are continuation bytes and are marked as length 1 here so that we can recover. */ #if '^' == 95 /* if defined(__MVS__) || defined(??) (VM/ESA?) 1047 */ EXTCONST unsigned char PL_utf8skip[] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,2,2,2,2,2,1,1,1,1,1,1,1, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,1,1,1,1,1,1,1,1,1,2,2,2,1,2,2, 2,2,2,2,2,2,2,3,3,3,3,3,3,1,3,3, 1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3, 1,1,1,1,1,1,1,1,1,1,3,3,4,4,4,4, 1,4,1,1,1,1,1,1,1,1,4,4,4,5,5,5, 1,1,1,1,1,1,1,1,1,1,5,6,6,7,7,1 }; #endif #if '^' == 106 /* if defined(_OSD_POSIX) POSIX-BC */ unsigned char PL_utf8skip[] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,2,2,2,2,2,3,1,1,1,1,1,1, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,3,1,1,1,1,1,1,1,1,2,2,2,3,2,2, 1,2,2,2,2,2,2,3,3,3,2,1,1,1,3,3, 4,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3, 1,1,1,1,1,1,1,1,1,1,3,3,4,6,4,4, 7,4,1,1,1,1,1,1,1,1,4,4,4,5,5,5, 1,1,1,1,1,1,1,1,1,1,5,1,6,1,7,1 }; #endif #if '^' == 176 /* if defined(??) (OS/400?) 037 */ unsigned char PL_utf8skip[] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,2,2,2,2,2,1,1,1,1,1,1,1, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2, 2,1,1,1,1,1,1,1,1,1,2,2,2,3,2,2, 1,2,2,2,2,2,2,3,3,3,1,1,3,3,3,3, 1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3, 1,1,1,1,1,1,1,1,1,1,3,3,4,4,4,4, 1,4,1,1,1,1,1,1,1,1,4,4,4,5,5,5, 1,1,1,1,1,1,1,1,1,1,5,6,6,7,7,1 }; #endif /* Transform tables from tr16 applied after encoding to render encoding EBCDIC * like, meaning that all the invariants are actually invariant, eg, that 'A' * remains 'A' */ #if '^' == 95 /* if defined(__MVS__) || defined(??) (VM/ESA?) 1047 */ EXTCONST unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-1047) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D, 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x80, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBE, 0xBF, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }; EXTCONST unsigned char PL_e2utf[] = { /* EBCDIC (IBM-1047) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E, 0x2D, 0x2F, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xC5, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xD4, 0xD5, 0xD6, 0x5B, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0x5D, 0xE6, 0xE7, 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0x5C, 0xF4, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x9F }; #endif /* 1047 */ #if '^' == 106 /* if defined(_OSD_POSIX) POSIX-BC */ unsigned char PL_utf2e[] = { /* I8 to EBCDIC (POSIX-BC) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xBB, 0xBC, 0xBD, 0x6A, 0x6D, 0x4A, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xFB, 0x4F, 0xFD, 0xFF, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0x5F, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xB0, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xD0, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x80, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0xBA, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xAD, 0x79, 0xA1, 0xBE, 0xBF, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xDA, 0xDB, 0xDC, 0xC0, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xDD, 0xFC, 0xE0, 0xFE }; unsigned char PL_e2utf[] = { /* EBCDIC (POSIX-BC) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0x60, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x9F, 0x2D, 0x2F, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0x5E, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xE4, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xC5, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xE5, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xD4, 0xD5, 0xD6, 0xE3, 0xD7, 0xD8, 0xA9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xD9, 0x5B, 0x5C, 0x5D, 0xE6, 0xE7, 0xF1, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xBB, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xEE, 0xEF, 0xF0, 0xFC, 0xF2, 0xF3, 0xFE, 0xF4, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xFB, 0x7B, 0xFD, 0x7D, 0xFF, 0x7E }; #endif /* POSIX-BC */ #if '^' == 176 /* if defined(??) (OS/400?) 037 */ unsigned char PL_utf2e[] = { /* I8 to EBCDIC (IBM-037) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xBA, 0xE0, 0xBB, 0xB0, 0x6D, 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x80, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xAA, 0xAB, 0xAC, 0xAE, 0xAF, 0x5F, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xAD, 0xBD, 0xBC, 0xBE, 0xBF, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE1, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }; unsigned char PL_e2utf[] = { /* EBCDIC (IBM-037) to I8 */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x85, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x0A, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0xD9, 0x2D, 0x2F, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xC5, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xD4, 0xD5, 0xD6, 0xE3, 0xD7, 0xD8, 0x5E, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0x5B, 0x5D, 0xE5, 0xE4, 0xE6, 0xE7, 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0x5C, 0xF4, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x9F }; #endif /* 037 */ /* These tables moved from perl.h and converted to hex. They map platform code page from/to bottom 256 codes of Unicode (i.e. iso-8859-1). */ #if '^' == 95 /* if defined(__MVS__) || defined(??) (VM/ESA?) 1047 */ EXTCONST unsigned char PL_a2e[] = { /* ASCII (iso-8859-1) to EBCDIC (IBM-1047) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D, 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF, 0x41, 0xAA, 0x4A, 0xB1, 0x9F, 0xB2, 0x6A, 0xB5, 0xBB, 0xB4, 0x9A, 0x8A, 0xB0, 0xCA, 0xAF, 0xBC, 0x90, 0x8F, 0xEA, 0xFA, 0xBE, 0xA0, 0xB6, 0xB3, 0x9D, 0xDA, 0x9B, 0x8B, 0xB7, 0xB8, 0xB9, 0xAB, 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9E, 0x68, 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, 0xAC, 0x69, 0xED, 0xEE, 0xEB, 0xEF, 0xEC, 0xBF, 0x80, 0xFD, 0xFE, 0xFB, 0xFC, 0xBA, 0xAE, 0x59, 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9C, 0x48, 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; #define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF #define LATIN_SMALL_LETTER_SHARP_S 0x59 #define MICRO_SIGN 0xA0 #define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 #define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (IBM-1047) to ASCII (iso-8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xE2, 0xE4, 0xE0, 0xE1, 0xE3, 0xE5, 0xE7, 0xF1, 0xA2, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xE9, 0xEA, 0xEB, 0xE8, 0xED, 0xEE, 0xEF, 0xEC, 0xDF, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E, 0x2D, 0x2F, 0xC2, 0xC4, 0xC0, 0xC1, 0xC3, 0xC5, 0xC7, 0xD1, 0xA6, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xF8, 0xC9, 0xCA, 0xCB, 0xC8, 0xCD, 0xCE, 0xCF, 0xCC, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xD8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xAB, 0xBB, 0xF0, 0xFD, 0xFE, 0xB1, 0xB0, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xAA, 0xBA, 0xE6, 0xB8, 0xC6, 0xA4, 0xB5, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0xBF, 0xD0, 0x5B, 0xDE, 0xAE, 0xAC, 0xA3, 0xA5, 0xB7, 0xA9, 0xA7, 0xB6, 0xBC, 0xBD, 0xBE, 0xDD, 0xA8, 0xAF, 0x5D, 0xB4, 0xD7, 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xAD, 0xF4, 0xF6, 0xF2, 0xF3, 0xF5, 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xB9, 0xFB, 0xFC, 0xF9, 0xFA, 0xFF, 0x5C, 0xF7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xB2, 0xD4, 0xD6, 0xD2, 0xD3, 0xD5, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xB3, 0xDB, 0xDC, 0xD9, 0xDA, 0x9F }; EXTCONST unsigned char PL_fold[] = { /* fast EBCDIC case folding table, 'A' => 'a'; 'a' => 'A' */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 98, 99, 100, 101, 102, 103, 104, 105, 74, 75, 76, 77, 78, 79, 80, 113, 114, 115, 116, 117, 118, 119, 120, 89, 90, 91, 92, 93, 94, 95, 96, 97, 66, 67, 68, 69, 70, 71, 72, 73, 106, 107, 108, 109, 110, 111, 128, 81, 82, 83, 84, 85, 86, 87, 88, 121, 122, 123, 124, 125, 126, 127, 112, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 138, 139, 172, 186, 174, 143, 144, 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 154, 155, 158, 157, 156, 159, 160, 161, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 170, 171, 140, 173, 142, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 141, 187, 188, 189, 190, 191, 192, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 202, 235, 236, 237, 238, 239, 208, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 218, 251, 252, 253, 254, 223, 224, 225, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 234, 203, 204, 205, 206, 207, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 219, 220, 221, 222, 255 }; #endif /* 1047 */ #if '^' == 106 /* if defined(_OSD_POSIX) POSIX-BC */ EXTCONST unsigned char PL_a2e[] = { /* ASCII (ISO8859-1) to EBCDIC (POSIX-BC) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xBB, 0xBC, 0xBD, 0x6A, 0x6D, 0x4A, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xFB, 0x4F, 0xFD, 0xFF, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0x5F, 0x41, 0xAA, 0xB0, 0xB1, 0x9F, 0xB2, 0xD0, 0xB5, 0x79, 0xB4, 0x9A, 0x8A, 0xBA, 0xCA, 0xAF, 0xA1, 0x90, 0x8F, 0xEA, 0xFA, 0xBE, 0xA0, 0xB6, 0xB3, 0x9D, 0xDA, 0x9B, 0x8B, 0xB7, 0xB8, 0xB9, 0xAB, 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9E, 0x68, 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, 0xAC, 0x69, 0xED, 0xEE, 0xEB, 0xEF, 0xEC, 0xBF, 0x80, 0xE0, 0xFE, 0xDD, 0xFC, 0xAD, 0xAE, 0x59, 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9C, 0x48, 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xC0, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; #define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF #define LATIN_SMALL_LETTER_SHARP_S 0x59 #define MICRO_SIGN 0xA0 #define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 #define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (POSIX-BC) to ASCII (ISO8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x0A, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xE2, 0xE4, 0xE0, 0xE1, 0xE3, 0xE5, 0xE7, 0xF1, 0x60, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xE9, 0xEA, 0xEB, 0xE8, 0xED, 0xEE, 0xEF, 0xEC, 0xDF, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x9F, 0x2D, 0x2F, 0xC2, 0xC4, 0xC0, 0xC1, 0xC3, 0xC5, 0xC7, 0xD1, 0x5E, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xF8, 0xC9, 0xCA, 0xCB, 0xC8, 0xCD, 0xCE, 0xCF, 0xCC, 0xA8, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xD8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xAB, 0xBB, 0xF0, 0xFD, 0xFE, 0xB1, 0xB0, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xAA, 0xBA, 0xE6, 0xB8, 0xC6, 0xA4, 0xB5, 0xAF, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0xBF, 0xD0, 0xDD, 0xDE, 0xAE, 0xA2, 0xA3, 0xA5, 0xB7, 0xA9, 0xA7, 0xB6, 0xBC, 0xBD, 0xBE, 0xAC, 0x5B, 0x5C, 0x5D, 0xB4, 0xD7, 0xF9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xAD, 0xF4, 0xF6, 0xF2, 0xF3, 0xF5, 0xA6, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xB9, 0xFB, 0xFC, 0xDB, 0xFA, 0xFF, 0xD9, 0xF7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xB2, 0xD4, 0xD6, 0xD2, 0xD3, 0xD5, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xB3, 0x7B, 0xDC, 0x7D, 0xDA, 0x7E }; EXTCONST unsigned char PL_fold[] = { /* fast EBCDIC case folding table, 'A' => 'a'; 'a' => 'A' */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 98, 99, 100, 101, 102, 103, 104, 105, 74, 75, 76, 77, 78, 79, 80, 113, 114, 115, 116, 117, 118, 119, 120, 89, 90, 91, 92, 93, 94, 95, 96, 97, 66, 67, 68, 69, 70, 71, 72, 73, 106, 107, 108, 109, 110, 111, 128, 81, 82, 83, 84, 85, 86, 87, 88, 121, 122, 123, 124, 125, 126, 127, 112, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 138, 139, 172, 173, 174, 143, 144, 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 154, 155, 158, 157, 156, 159, 160, 161, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 170, 171, 140, 141, 142, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 224, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 202, 235, 236, 237, 238, 239, 208, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 218, 221, 252, 219, 254, 223, 192, 225, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 234, 203, 204, 205, 206, 207, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 220, 253, 222, 255 }; #endif /* POSIX-BC */ #if '^' == 176 /* if defined(??) (OS/400?) 037 */ EXTCONST unsigned char PL_a2e[] = { /* ASCII (ISO8859-1) to EBCDIC (IBM-037) */ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xBA, 0xE0, 0xBB, 0xB0, 0x6D, 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF, 0x41, 0xAA, 0x4A, 0xB1, 0x9F, 0xB2, 0x6A, 0xB5, 0xBD, 0xB4, 0x9A, 0x8A, 0x5F, 0xCA, 0xAF, 0xBC, 0x90, 0x8F, 0xEA, 0xFA, 0xBE, 0xA0, 0xB6, 0xB3, 0x9D, 0xDA, 0x9B, 0x8B, 0xB7, 0xB8, 0xB9, 0xAB, 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9E, 0x68, 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, 0xAC, 0x69, 0xED, 0xEE, 0xEB, 0xEF, 0xEC, 0xBF, 0x80, 0xFD, 0xFE, 0xFB, 0xFC, 0xAD, 0xAE, 0x59, 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9C, 0x48, 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF }; #define LATIN_SMALL_LETTER_Y_WITH_DIAERESIS 0xDF #define LATIN_SMALL_LETTER_SHARP_S 0x59 #define MICRO_SIGN 0xA0 #define LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE 0x0067 #define LATIN_SMALL_LETTER_A_WITH_RING_ABOVE 0x0047 EXTCONST unsigned char PL_e2a[] = { /* EBCDIC (IBM-037) to ASCII (ISO8859-1) */ 0x00, 0x01, 0x02, 0x03, 0x9C, 0x09, 0x86, 0x7F, 0x97, 0x8D, 0x8E, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x9D, 0x85, 0x08, 0x87, 0x18, 0x19, 0x92, 0x8F, 0x1C, 0x1D, 0x1E, 0x1F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x0A, 0x17, 0x1B, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x05, 0x06, 0x07, 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04, 0x98, 0x99, 0x9A, 0x9B, 0x14, 0x15, 0x9E, 0x1A, 0x20, 0xA0, 0xE2, 0xE4, 0xE0, 0xE1, 0xE3, 0xE5, 0xE7, 0xF1, 0xA2, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 0x26, 0xE9, 0xEA, 0xEB, 0xE8, 0xED, 0xEE, 0xEF, 0xEC, 0xDF, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0xAC, 0x2D, 0x2F, 0xC2, 0xC4, 0xC0, 0xC1, 0xC3, 0xC5, 0xC7, 0xD1, 0xA6, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 0xF8, 0xC9, 0xCA, 0xCB, 0xC8, 0xCD, 0xCE, 0xCF, 0xCC, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 0xD8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0xAB, 0xBB, 0xF0, 0xFD, 0xFE, 0xB1, 0xB0, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0xAA, 0xBA, 0xE6, 0xB8, 0xC6, 0xA4, 0xB5, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0xA1, 0xBF, 0xD0, 0xDD, 0xDE, 0xAE, 0x5E, 0xA3, 0xA5, 0xB7, 0xA9, 0xA7, 0xB6, 0xBC, 0xBD, 0xBE, 0x5B, 0x5D, 0xAF, 0xA8, 0xB4, 0xD7, 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0xAD, 0xF4, 0xF6, 0xF2, 0xF3, 0xF5, 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0xB9, 0xFB, 0xFC, 0xF9, 0xFA, 0xFF, 0x5C, 0xF7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0xB2, 0xD4, 0xD6, 0xD2, 0xD3, 0xD5, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0xB3, 0xDB, 0xDC, 0xD9, 0xDA, 0x9F }; EXTCONST unsigned char PL_fold[] = { /* fast EBCDIC case folding table, 'A' => 'a'; 'a' => 'A' */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 98, 99, 100, 101, 102, 103, 104, 105, 74, 75, 76, 77, 78, 79, 80, 113, 114, 115, 116, 117, 118, 119, 120, 89, 90, 91, 92, 93, 94, 95, 96, 97, 66, 67, 68, 69, 70, 71, 72, 73, 106, 107, 108, 109, 110, 111, 128, 81, 82, 83, 84, 85, 86, 87, 88, 121, 122, 123, 124, 125, 126, 127, 112, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 138, 139, 172, 173, 174, 143, 144, 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 154, 155, 158, 157, 156, 159, 160, 161, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 170, 171, 140, 141, 142, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 202, 235, 236, 237, 238, 239, 208, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 218, 251, 252, 253, 254, 223, 224, 225, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 234, 203, 204, 205, 206, 207, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 219, 220, 221, 222, 255 }; #endif /* 037 */ #else EXTCONST unsigned char PL_utf8skip[]; EXTCONST unsigned char PL_e2utf[]; EXTCONST unsigned char PL_utf2e[]; EXTCONST unsigned char PL_e2a[]; EXTCONST unsigned char PL_a2e[]; EXTCONST unsigned char PL_fold[]; #endif /* Since the EBCDIC code pages are isomorphic to Latin1, that table is merely a * duplicate */ EXTCONST unsigned char * PL_fold_latin1 = PL_fold; END_EXTERN_C /* EBCDIC-happy ways of converting native code to UTF-8 */ /* Native to iso-8859-1 */ #define NATIVE_TO_ASCII(ch) PL_e2a[(U8)(ch)] #define ASCII_TO_NATIVE(ch) PL_a2e[(U8)(ch)] /* Transform after encoding, essentially converts to/from I8 */ #define NATIVE_TO_UTF(ch) PL_e2utf[(U8)(ch)] /* to I8 */ #define NATIVE_TO_I8(ch) NATIVE_TO_UTF(ch) /* synonym */ #define UTF_TO_NATIVE(ch) PL_utf2e[(U8)(ch)] /* from I8 */ #define I8_TO_NATIVE(ch) UTF_TO_NATIVE(ch) /* synonym */ /* Transform in wide UV char space */ #define NATIVE_TO_UNI(ch) (((ch) > 255) ? (ch) : NATIVE_TO_ASCII(ch)) #define UNI_TO_NATIVE(ch) (((ch) > 255) ? (ch) : ASCII_TO_NATIVE(ch)) /* Transform in invariant..byte space */ #define NATIVE_TO_NEED(enc,ch) ((enc) ? UTF_TO_NATIVE(NATIVE_TO_ASCII(ch)) : (ch)) #define ASCII_TO_NEED(enc,ch) ((enc) ? UTF_TO_NATIVE(ch) : ASCII_TO_NATIVE(ch)) /* The following table is adapted from tr16, it shows I8 encoding of Unicode code points. Unicode Bit pattern 1st Byte 2nd Byte 3rd Byte 4th Byte 5th Byte 6th Byte 7th byte U+0000..U+007F 000000000xxxxxxx 0xxxxxxx U+0080..U+009F 00000000100xxxxx 100xxxxx U+00A0..U+00FF 00000000yyyxxxxx 11000yyy 101xxxxx U+00A0..U+03FF 000000yyyyyxxxxx 110yyyyy 101xxxxx U+0400..U+3FFF 00zzzzyyyyyxxxxx 1110zzzz 101yyyyy 101xxxxx U+4000..U+3FFFF 0wwwzzzzzyyyyyxxxxx 11110www 101zzzzz 101yyyyy 101xxxxx U+40000..U+3FFFFF 0vvwwwwwzzzzzyyyyyxxxxx 111110vv 101wwwww 101zzzzz 101yyyyy 101xxxxx U+400000..U+3FFFFFF 0uvvvvvwwwwwzzzzzyyyyyxxxxx 1111110u 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx U+4000000..U+7FFFFFFF 0tuuuuuvvvvvwwwwwzzzzzyyyyyxxxxx 1111111t 101uuuuu 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx Note: The I8 transformation is valid for UCS-4 values X'0' to X'7FFFFFFF' (the full extent of ISO/IEC 10646 coding space). */ #define UNISKIP(uv) ( (uv) < 0xA0 ? 1 : \ (uv) < 0x400 ? 2 : \ (uv) < 0x4000 ? 3 : \ (uv) < 0x40000 ? 4 : \ (uv) < 0x400000 ? 5 : \ (uv) < 0x4000000 ? 6 : 7 ) #define UNI_IS_INVARIANT(c) ((c) < 0xA0) /* UTF-EBCDIC semantic macros - transform back into I8 and then compare */ #define UTF8_IS_START(c) (NATIVE_TO_UTF(c) >= 0xC5 && NATIVE_TO_UTF(c) != 0xE0) #define UTF8_IS_CONTINUATION(c) ((NATIVE_TO_UTF(c) & 0xE0) == 0xA0) #define UTF8_IS_CONTINUED(c) (NATIVE_TO_UTF(c) >= 0xA0) #define UTF8_IS_DOWNGRADEABLE_START(c) (NATIVE_TO_UTF(c) >= 0xC5 && NATIVE_TO_UTF(c) <= 0xC7) #define UTF_START_MARK(len) (((len) > 7) ? 0xFF : ((U8)(0xFE << (7-(len))))) #define UTF_START_MASK(len) (((len) >= 6) ? 0x01 : (0x1F >> ((len)-2))) #define UTF_CONTINUATION_MARK 0xA0 #define UTF_CONTINUATION_MASK ((U8)0x1f) #define UTF_ACCUMULATION_SHIFT 5 /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZlz z nostdio.hnuW+A/* nostdio.h * * Copyright (C) 1996, 2000, 2001, 2005, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * Strong denial of stdio - make all stdio calls (we can think of) errors */ /* This is a 1st attempt to stop other include files pulling in real . A more ambitious set of possible symbols can be found in sfio.h (inside an _cplusplus gard). It is completely pointless as we have already included it ourselves. */ #if !defined(_STDIO_H) && !defined(FILE) && !defined(_STDIO_INCLUDED) && !defined(__STDIO_LOADED) #define _STDIO_H #define _STDIO_INCLUDED #define __STDIO_LOADED struct _FILE; #define FILE struct _FILE #endif #define _CANNOT "CANNOT" #undef clearerr #undef fclose #undef fdopen #undef feof #undef ferror #undef fflush #undef fgetc #undef fgetpos #undef fgets #undef fileno #undef flockfile #undef fopen #undef fprintf #undef fputc #undef fputs #undef fread #undef freopen #undef fscanf #undef fseek #undef fsetpos #undef ftell #undef ftrylockfile #undef funlockfile #undef fwrite #undef getc #undef getc_unlocked #undef getw #undef pclose #undef popen #undef putc #undef putc_unlocked #undef putw #undef rewind #undef setbuf #undef setvbuf #undef stderr #undef stdin #undef stdout #undef tmpfile #undef ungetc #undef vfprintf #undef printf #define fprintf _CANNOT _fprintf_ #define printf _CANNOT _printf_ #define stdin _CANNOT _stdin_ #define stdout _CANNOT _stdout_ #define stderr _CANNOT _stderr_ #ifndef OS2 #define tmpfile() _CANNOT _tmpfile_ #endif #define fclose(f) _CANNOT _fclose_ #define fflush(f) _CANNOT _fflush_ #define fopen(p,m) _CANNOT _fopen_ #define freopen(p,m,f) _CANNOT _freopen_ #define setbuf(f,b) _CANNOT _setbuf_ #define setvbuf(f,b,x,s) _CANNOT _setvbuf_ #define fscanf _CANNOT _fscanf_ #define vfprintf(f,fmt,a) _CANNOT _vfprintf_ #define fgetc(f) _CANNOT _fgetc_ #define fgets(s,n,f) _CANNOT _fgets_ #define fputc(c,f) _CANNOT _fputc_ #define fputs(s,f) _CANNOT _fputs_ #define getc(f) _CANNOT _getc_ #define putc(c,f) _CANNOT _putc_ #ifndef OS2 #define ungetc(c,f) _CANNOT _ungetc_ #endif #define fread(b,s,c,f) _CANNOT _fread_ #define fwrite(b,s,c,f) _CANNOT _fwrite_ #define fgetpos(f,p) _CANNOT _fgetpos_ #define fseek(f,o,w) _CANNOT _fseek_ #define fsetpos(f,p) _CANNOT _fsetpos_ #define ftell(f) _CANNOT _ftell_ #define rewind(f) _CANNOT _rewind_ #define clearerr(f) _CANNOT _clearerr_ #define feof(f) _CANNOT _feof_ #define ferror(f) _CANNOT _ferror_ #define __filbuf(f) _CANNOT __filbuf_ #define __flsbuf(c,f) _CANNOT __flsbuf_ #define _filbuf(f) _CANNOT _filbuf_ #define _flsbuf(c,f) _CANNOT _flsbuf_ #define fdopen(fd,p) _CANNOT _fdopen_ #define fileno(f) _CANNOT _fileno_ #if defined(SFIO_VERSION) && SFIO_VERSION < 20000101L #define flockfile(f) _CANNOT _flockfile_ #define ftrylockfile(f) _CANNOT _ftrylockfile_ #define funlockfile(f) _CANNOT _funlockfile_ #endif #define getc_unlocked(f) _CANNOT _getc_unlocked_ #define putc_unlocked(c,f) _CANNOT _putc_unlocked_ #define popen(c,m) _CANNOT _popen_ #define getw(f) _CANNOT _getw_ #define putw(v,f) _CANNOT _putw_ #ifndef OS2 #define pclose(f) _CANNOT _pclose_ #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ. See C and C. =for apidoc AmU||MARK Stack marker variable for the XSUB. See C. =for apidoc Am|void|PUSHMARK|SP Opening bracket for arguments on a callback. See C and L. =for apidoc Ams||dSP Declares a local copy of perl's stack pointer for the XSUB, available via the C macro. See C. =for apidoc ms||djSP Declare Just C. This is actually identical to C, and declares a local copy of perl's stack pointer, available via the C macro. See C. (Available for backward source code compatibility with the old (Perl 5.005) thread model.) =for apidoc Ams||dMARK Declare a stack marker variable, C, for the XSUB. See C and C. =for apidoc Ams||dORIGMARK Saves the original stack mark for the XSUB. See C. =for apidoc AmU||ORIGMARK The original stack mark for the XSUB. See C. =for apidoc Ams||SPAGAIN Refetch the stack pointer. Used after a callback. See L. =cut */ #undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */ #define SP sp #define MARK mark #define TARG targ #define PUSHMARK(p) \ STMT_START { \ if (++PL_markstack_ptr == PL_markstack_max) \ markstack_grow(); \ *PL_markstack_ptr = (I32)((p) - PL_stack_base);\ } STMT_END #define TOPMARK (*PL_markstack_ptr) #define POPMARK (*PL_markstack_ptr--) #define dSP SV **sp = PL_stack_sp #define djSP dSP #define dMARK register SV **mark = PL_stack_base + POPMARK #define dORIGMARK const I32 origmark = (I32)(mark - PL_stack_base) #define ORIGMARK (PL_stack_base + origmark) #define SPAGAIN sp = PL_stack_sp #define MSPAGAIN STMT_START { sp = PL_stack_sp; mark = ORIGMARK; } STMT_END #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ)) #define dTARGETSTACKED SV * GETTARGETSTACKED #define GETTARGET targ = PAD_SV(PL_op->op_targ) #define dTARGET SV * GETTARGET #define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ)) #define dATARGET SV * GETATARGET #define dTARG SV *targ #define NORMAL PL_op->op_next #define DIE return Perl_die /* =for apidoc Ams||PUTBACK Closing bracket for XSUB arguments. This is usually handled by C. See C and L for other uses. =for apidoc Amn|SV*|POPs Pops an SV off the stack. =for apidoc Amn|char*|POPp Pops a string off the stack. Deprecated. New code should use POPpx. =for apidoc Amn|char*|POPpx Pops a string off the stack. =for apidoc Amn|char*|POPpbytex Pops a string off the stack which must consist of bytes i.e. characters < 256. =for apidoc Amn|NV|POPn Pops a double off the stack. =for apidoc Amn|IV|POPi Pops an integer off the stack. =for apidoc Amn|long|POPl Pops a long off the stack. =cut */ #define PUTBACK PL_stack_sp = sp #define RETURN return (PUTBACK, NORMAL) #define RETURNOP(o) return (PUTBACK, o) #define RETURNX(x) return (x, PUTBACK, NORMAL) #define POPs (*sp--) #define POPp (SvPVx(POPs, PL_na)) /* deprecated */ #define POPpx (SvPVx_nolen(POPs)) #define POPpconstx (SvPVx_nolen_const(POPs)) #define POPpbytex (SvPVbytex_nolen(POPs)) #define POPn (SvNVx(POPs)) #define POPi ((IV)SvIVx(POPs)) #define POPu ((UV)SvUVx(POPs)) #define POPl ((long)SvIVx(POPs)) #define POPul ((unsigned long)SvIVx(POPs)) #ifdef HAS_QUAD #define POPq ((Quad_t)SvIVx(POPs)) #define POPuq ((Uquad_t)SvUVx(POPs)) #endif #define TOPs (*sp) #define TOPm1s (*(sp-1)) #define TOPp1s (*(sp+1)) #define TOPp (SvPV(TOPs, PL_na)) /* deprecated */ #define TOPpx (SvPV_nolen(TOPs)) #define TOPn (SvNV(TOPs)) #define TOPi ((IV)SvIV(TOPs)) #define TOPu ((UV)SvUV(TOPs)) #define TOPl ((long)SvIV(TOPs)) #define TOPul ((unsigned long)SvUV(TOPs)) #ifdef HAS_QUAD #define TOPq ((Quad_t)SvIV(TOPs)) #define TOPuq ((Uquad_t)SvUV(TOPs)) #endif /* Go to some pains in the rare event that we must extend the stack. */ /* =for apidoc Am|void|EXTEND|SP|int nitems Used to extend the argument stack for an XSUB's return values. Once used, guarantees that there is room for at least C to be pushed onto the stack. =for apidoc Am|void|PUSHs|SV* sv Push an SV onto the stack. The stack must have room for this element. Does not handle 'set' magic. Does not use C. See also C, C and C. =for apidoc Am|void|PUSHp|char* str|STRLEN len Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|PUSHn|NV nv Push a double onto the stack. The stack must have room for this element. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|PUSHi|IV iv Push an integer onto the stack. The stack must have room for this element. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|PUSHu|UV uv Push an unsigned integer onto the stack. The stack must have room for this element. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|XPUSHs|SV* sv Push an SV onto the stack, extending the stack if necessary. Does not handle 'set' magic. Does not use C. See also C, C and C. =for apidoc Am|void|XPUSHp|char* str|STRLEN len Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|XPUSHn|NV nv Push a double onto the stack, extending the stack if necessary. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|XPUSHi|IV iv Push an integer onto the stack, extending the stack if necessary. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|XPUSHu|UV uv Push an unsigned integer onto the stack, extending the stack if necessary. Handles 'set' magic. Uses C, so C or C should be called to declare it. Do not call multiple C-oriented macros to return lists from XSUB's - see C instead. See also C and C. =for apidoc Am|void|mPUSHs|SV* sv Push an SV onto the stack and mortalizes the SV. The stack must have room for this element. Does not use C. See also C and C. =for apidoc Am|void|PUSHmortal Push a new mortal SV onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. =for apidoc Am|void|mPUSHp|char* str|STRLEN len Push a string onto the stack. The stack must have room for this element. The C indicates the length of the string. Does not use C. See also C, C and C. =for apidoc Am|void|mPUSHn|NV nv Push a double onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. =for apidoc Am|void|mPUSHi|IV iv Push an integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. =for apidoc Am|void|mPUSHu|UV uv Push an unsigned integer onto the stack. The stack must have room for this element. Does not use C. See also C, C and C. =for apidoc Am|void|mXPUSHs|SV* sv Push an SV onto the stack, extending the stack if necessary and mortalizes the SV. Does not use C. See also C and C. =for apidoc Am|void|XPUSHmortal Push a new mortal SV onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. =for apidoc Am|void|mXPUSHp|char* str|STRLEN len Push a string onto the stack, extending the stack if necessary. The C indicates the length of the string. Does not use C. See also C, C and C. =for apidoc Am|void|mXPUSHn|NV nv Push a double onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. =for apidoc Am|void|mXPUSHi|IV iv Push an integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. =for apidoc Am|void|mXPUSHu|UV uv Push an unsigned integer onto the stack, extending the stack if necessary. Does not use C. See also C, C and C. =cut */ #define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (int)(n)) { \ sp = stack_grow(sp,p, (int) (n)); \ } } STMT_END /* Same thing, but update mark register too. */ #define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (int)(n)) { \ const int markoff = mark - PL_stack_base; \ sp = stack_grow(sp,p,(int) (n)); \ mark = PL_stack_base + markoff; \ } } STMT_END #define PUSHs(s) (*++sp = (s)) #define PUSHTARG STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END #define PUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END #define PUSHn(n) STMT_START { sv_setnv(TARG, (NV)(n)); PUSHTARG; } STMT_END #define PUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END #define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END #define XPUSHs(s) STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END #define XPUSHTARG STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END #define XPUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END #define XPUSHn(n) STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END #define XPUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END #define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END #define XPUSHundef STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END #define mPUSHs(s) PUSHs(sv_2mortal(s)) #define PUSHmortal PUSHs(sv_newmortal()) #define mPUSHp(p,l) PUSHs(newSVpvn_flags((p), (l), SVs_TEMP)) #define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) #define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) #define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) #define mXPUSHs(s) XPUSHs(sv_2mortal(s)) #define XPUSHmortal XPUSHs(sv_newmortal()) #define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); mPUSHp((p), (l)); } STMT_END #define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END #define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END #define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END #define SETs(s) (*sp = s) #define SETTARG STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END #define SETp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END #define SETn(n) STMT_START { sv_setnv(TARG, (NV)(n)); SETTARG; } STMT_END #define SETi(i) STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END #define SETu(u) STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END #define dTOPss SV *sv = TOPs #define dPOPss SV *sv = POPs #define dTOPnv NV value = TOPn #define dPOPnv NV value = POPn #define dPOPnv_nomg NV value = (sp--, SvNV_nomg(TOPp1s)) #define dTOPiv IV value = TOPi #define dPOPiv IV value = POPi #define dTOPuv UV value = TOPu #define dPOPuv UV value = POPu #ifdef HAS_QUAD #define dTOPqv Quad_t value = TOPu #define dPOPqv Quad_t value = POPu #define dTOPuqv Uquad_t value = TOPuq #define dPOPuqv Uquad_t value = POPuq #endif #define dPOPXssrl(X) SV *right = POPs; SV *left = CAT2(X,s) #define dPOPXnnrl(X) NV right = POPn; NV left = CAT2(X,n) #define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i) #define USE_LEFT(sv) \ (SvOK(sv) || !(PL_op->op_flags & OPf_STACKED)) #define dPOPXiirl_ul_nomg(X) \ IV right = (sp--, SvIV_nomg(TOPp1s)); \ SV *leftsv = CAT2(X,s); \ IV left = USE_LEFT(leftsv) ? SvIV_nomg(leftsv) : 0 #define dPOPPOPssrl dPOPXssrl(POP) #define dPOPPOPnnrl dPOPXnnrl(POP) #define dPOPPOPiirl dPOPXiirl(POP) #define dPOPTOPssrl dPOPXssrl(TOP) #define dPOPTOPnnrl dPOPXnnrl(TOP) #define dPOPTOPnnrl_nomg \ NV right = SvNV_nomg(TOPs); NV left = (sp--, SvNV_nomg(TOPs)) #define dPOPTOPiirl dPOPXiirl(TOP) #define dPOPTOPiirl_ul_nomg dPOPXiirl_ul_nomg(TOP) #define dPOPTOPiirl_nomg \ IV right = SvIV_nomg(TOPs); IV left = (sp--, SvIV_nomg(TOPs)) #define RETPUSHYES RETURNX(PUSHs(&PL_sv_yes)) #define RETPUSHNO RETURNX(PUSHs(&PL_sv_no)) #define RETPUSHUNDEF RETURNX(PUSHs(&PL_sv_undef)) #define RETSETYES RETURNX(SETs(&PL_sv_yes)) #define RETSETNO RETURNX(SETs(&PL_sv_no)) #define RETSETUNDEF RETURNX(SETs(&PL_sv_undef)) #define ARGTARG PL_op->op_targ /* See OPpTARGET_MY: */ #define MAXARG (PL_op->op_private & 15) #define SWITCHSTACK(f,t) \ STMT_START { \ AvFILLp(f) = sp - PL_stack_base; \ PL_stack_base = AvARRAY(t); \ PL_stack_max = PL_stack_base + AvMAX(t); \ sp = PL_stack_sp = PL_stack_base + AvFILLp(t); \ PL_curstack = t; \ } STMT_END #define EXTEND_MORTAL(n) \ STMT_START { \ if (PL_tmps_ix + (n) >= PL_tmps_max) \ tmps_grow(n); \ } STMT_END #define AMGf_noright 1 #define AMGf_noleft 2 #define AMGf_assign 4 #define AMGf_unary 8 #define AMGf_numeric 0x10 /* for Perl_try_amagic_bin */ #define AMGf_set 0x20 /* for Perl_try_amagic_bin */ /* do SvGETMAGIC on the stack args before checking for overload */ #define tryAMAGICun_MG(method, flags) STMT_START { \ if ( (SvFLAGS(TOPs) & (SVf_ROK|SVs_GMG)) \ && Perl_try_amagic_un(aTHX_ method, flags)) \ return NORMAL; \ } STMT_END #define tryAMAGICbin_MG(method, flags) STMT_START { \ if ( ((SvFLAGS(TOPm1s)|SvFLAGS(TOPs)) & (SVf_ROK|SVs_GMG)) \ && Perl_try_amagic_bin(aTHX_ method, flags)) \ return NORMAL; \ } STMT_END #define AMG_CALLunary(sv,meth) \ amagic_call(sv,&PL_sv_undef, meth, AMGf_noright | AMGf_unary) /* No longer used in core. Use AMG_CALLunary instead */ #define AMG_CALLun(sv,meth) AMG_CALLunary(sv, CAT2(meth,_amg)) #define tryAMAGICunTARGET(meth, shift, jump) \ STMT_START { \ dATARGET; \ dSP; \ SV *tmpsv; \ SV *arg= sp[shift]; \ if (SvAMAGIC(arg) && \ (tmpsv = amagic_call(arg, &PL_sv_undef, meth, \ AMGf_noright | AMGf_unary))) { \ SPAGAIN; \ sp += shift; \ sv_setsv(TARG, tmpsv); \ if (opASSIGN) \ sp--; \ SETTARG; \ PUTBACK; \ if (jump) { \ OP *jump_o = NORMAL->op_next; \ while (jump_o->op_type == OP_NULL) \ jump_o = jump_o->op_next; \ assert(jump_o->op_type == OP_ENTERSUB); \ PL_markstack_ptr--; \ return jump_o->op_next; \ } \ return NORMAL; \ } \ } STMT_END /* This is no longer used anywhere in the core. You might wish to consider calling amagic_deref_call() directly, as it has a cleaner interface. */ #define tryAMAGICunDEREF(meth) \ STMT_START { \ sv = amagic_deref_call(*sp, CAT2(meth,_amg)); \ SPAGAIN; \ } STMT_END #define opASSIGN (PL_op->op_flags & OPf_STACKED) #define SETsv(sv) STMT_START { \ if (opASSIGN || (SvFLAGS(TARG) & SVs_PADMY)) \ { sv_setsv(TARG, (sv)); SETTARG; } \ else SETs(sv); } STMT_END #define SETsvUN(sv) STMT_START { \ if (SvFLAGS(TARG) & SVs_PADMY) \ { sv_setsv(TARG, (sv)); SETTARG; } \ else SETs(sv); } STMT_END /* =for apidoc mU||LVRET True if this op will be the return value of an lvalue subroutine =cut */ #define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub()) #define SvCANEXISTDELETE(sv) \ (!SvRMAGICAL(sv) \ || ((mg = mg_find((const SV *) sv, PERL_MAGIC_tied)) \ && (stash = SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(sv), mg)))) \ && gv_fetchmethod_autoload(stash, "EXISTS", TRUE) \ && gv_fetchmethod_autoload(stash, "DELETE", TRUE) \ ) \ ) #ifdef PERL_CORE /* These are just for Perl_tied_method(), which is not part of the public API. Use 0x04 rather than the next available bit, to help the compiler if the architecture can generate more efficient instructions. */ # define TIED_METHOD_MORTALIZE_NOT_NEEDED 0x04 # define TIED_METHOD_ARGUMENTS_ON_STACK 0x08 # define TIED_METHOD_SAY 0x10 /* Used in various places that need to dereference a glob or globref */ # define MAYBE_DEREF_GV_flags(sv,phlags) \ ( \ (void)(phlags & SV_GMAGIC && (SvGETMAGIC(sv),0)), \ isGV_with_GP(sv) \ ? (GV *)sv \ : SvROK(sv) && SvTYPE(SvRV(sv)) <= SVt_PVLV && \ (SvGETMAGIC(SvRV(sv)), isGV_with_GP(SvRV(sv))) \ ? (GV *)SvRV(sv) \ : NULL \ ) # define MAYBE_DEREF_GV(sv) MAYBE_DEREF_GV_flags(sv,SV_GMAGIC) # define MAYBE_DEREF_GV_nomg(sv) MAYBE_DEREF_GV_flags(sv,0) #endif /* * Local variables: * c-indentation-style: bsd * c-basic-offset: 4 * indent-tabs-mode: t * End: * * ex: set ts=8 sts=4 sw=4 noet: */ PKZ~Quudmap.hnuW+A{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } PKZʬRR bitcount.hnuW+A{ 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 } PKZE*IPSSembed.hnuW+A/* -*- buffer-read-only: t -*- * * embed.h * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/embed.pl from data in embed.fnc, * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h. * Any changes made here will be lost! * * Edit those files and run 'make regen_headers' to effect changes. */ /* (Doing namespace management portably in C is really gross.) */ /* By defining PERL_NO_SHORT_NAMES (not done by default) the short forms * (like warn instead of Perl_warn) for the API are not defined. * Not defining the short forms is a good thing for cleaner embedding. */ #ifndef PERL_NO_SHORT_NAMES /* Hide global symbols */ #define Gv_AMupdate(a,b) Perl_Gv_AMupdate(aTHX_ a,b) #define _to_uni_fold_flags(a,b,c,d) Perl__to_uni_fold_flags(aTHX_ a,b,c,d) #define _to_utf8_fold_flags(a,b,c,d,e) Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e) #define _to_utf8_lower_flags(a,b,c,d,e) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e) #define _to_utf8_title_flags(a,b,c,d,e) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e) #define _to_utf8_upper_flags(a,b,c,d,e) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e) #define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) #define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) #define apply_attrs_string(a,b,c,d) Perl_apply_attrs_string(aTHX_ a,b,c,d) #define atfork_lock Perl_atfork_lock #define atfork_unlock Perl_atfork_unlock #define av_clear(a) Perl_av_clear(aTHX_ a) #define av_delete(a,b,c) Perl_av_delete(aTHX_ a,b,c) #define av_exists(a,b) Perl_av_exists(aTHX_ a,b) #define av_extend(a,b) Perl_av_extend(aTHX_ a,b) #define av_fetch(a,b,c) Perl_av_fetch(aTHX_ a,b,c) #define av_fill(a,b) Perl_av_fill(aTHX_ a,b) #define av_len(a) Perl_av_len(aTHX_ a) #define av_make(a,b) Perl_av_make(aTHX_ a,b) #define av_pop(a) Perl_av_pop(aTHX_ a) #define av_push(a,b) Perl_av_push(aTHX_ a,b) #define av_shift(a) Perl_av_shift(aTHX_ a) #define av_store(a,b,c) Perl_av_store(aTHX_ a,b,c) #define av_undef(a) Perl_av_undef(aTHX_ a) #define av_unshift(a,b) Perl_av_unshift(aTHX_ a,b) #define block_gimme() Perl_block_gimme(aTHX) #define bytes_cmp_utf8(a,b,c,d) Perl_bytes_cmp_utf8(aTHX_ a,b,c,d) #define bytes_from_utf8(a,b,c) Perl_bytes_from_utf8(aTHX_ a,b,c) #define bytes_to_utf8(a,b) Perl_bytes_to_utf8(aTHX_ a,b) #define call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) #define call_atexit(a,b) Perl_call_atexit(aTHX_ a,b) #define call_list(a,b) Perl_call_list(aTHX_ a,b) #define call_method(a,b) Perl_call_method(aTHX_ a,b) #define call_pv(a,b) Perl_call_pv(aTHX_ a,b) #define call_sv(a,b) Perl_call_sv(aTHX_ a,b) #define caller_cx(a,b) Perl_caller_cx(aTHX_ a,b) #define cast_i32(a) Perl_cast_i32(aTHX_ a) #define cast_iv(a) Perl_cast_iv(aTHX_ a) #define cast_ulong(a) Perl_cast_ulong(aTHX_ a) #define cast_uv(a) Perl_cast_uv(aTHX_ a) #define ck_entersub_args_list(a) Perl_ck_entersub_args_list(aTHX_ a) #define ck_entersub_args_proto(a,b,c) Perl_ck_entersub_args_proto(aTHX_ a,b,c) #define ck_entersub_args_proto_or_list(a,b,c) Perl_ck_entersub_args_proto_or_list(aTHX_ a,b,c) #ifndef PERL_IMPLICIT_CONTEXT #define ck_warner Perl_ck_warner #define ck_warner_d Perl_ck_warner_d #endif #ifndef PERL_IMPLICIT_CONTEXT #define croak Perl_croak #endif #define croak_no_modify() Perl_croak_no_modify(aTHX) #define croak_sv(a) Perl_croak_sv(aTHX_ a) #define croak_xs_usage(a,b) Perl_croak_xs_usage(aTHX_ a,b) #define custom_op_desc(a) Perl_custom_op_desc(aTHX_ a) #define custom_op_name(a) Perl_custom_op_name(aTHX_ a) #define cv_clone(a) Perl_cv_clone(aTHX_ a) #define cv_const_sv(a) Perl_cv_const_sv(aTHX_ a) #define cv_get_call_checker(a,b,c) Perl_cv_get_call_checker(aTHX_ a,b,c) #define cv_set_call_checker(a,b,c) Perl_cv_set_call_checker(aTHX_ a,b,c) #define cv_undef(a) Perl_cv_undef(aTHX_ a) #define cx_dump(a) Perl_cx_dump(aTHX_ a) #define cxinc() Perl_cxinc(aTHX) #ifndef PERL_IMPLICIT_CONTEXT #define deb Perl_deb #endif #define debop(a) Perl_debop(aTHX_ a) #define debprofdump() Perl_debprofdump(aTHX) #define debstack() Perl_debstack(aTHX) #define debstackptrs() Perl_debstackptrs(aTHX) #define delimcpy Perl_delimcpy #define despatch_signals() Perl_despatch_signals(aTHX) #ifndef PERL_IMPLICIT_CONTEXT #define die Perl_die #endif #define die_sv(a) Perl_die_sv(aTHX_ a) #define do_binmode(a,b,c) Perl_do_binmode(aTHX_ a,b,c) #define do_close(a,b) Perl_do_close(aTHX_ a,b) #define do_gv_dump(a,b,c,d) Perl_do_gv_dump(aTHX_ a,b,c,d) #define do_gvgv_dump(a,b,c,d) Perl_do_gvgv_dump(aTHX_ a,b,c,d) #define do_hv_dump(a,b,c,d) Perl_do_hv_dump(aTHX_ a,b,c,d) #define do_join(a,b,c,d) Perl_do_join(aTHX_ a,b,c,d) #define do_magic_dump(a,b,c,d,e,f,g) Perl_do_magic_dump(aTHX_ a,b,c,d,e,f,g) #define do_op_dump(a,b,c) Perl_do_op_dump(aTHX_ a,b,c) #define do_open9(a,b,c,d,e,f,g,h,i) Perl_do_open9(aTHX_ a,b,c,d,e,f,g,h,i) #define do_openn(a,b,c,d,e,f,g,h,i) Perl_do_openn(aTHX_ a,b,c,d,e,f,g,h,i) #define do_pmop_dump(a,b,c) Perl_do_pmop_dump(aTHX_ a,b,c) #define do_sprintf(a,b,c) Perl_do_sprintf(aTHX_ a,b,c) #define do_sv_dump(a,b,c,d,e,f,g) Perl_do_sv_dump(aTHX_ a,b,c,d,e,f,g) #define doing_taint Perl_doing_taint #define doref(a,b,c) Perl_doref(aTHX_ a,b,c) #define dounwind(a) Perl_dounwind(aTHX_ a) #define dowantarray() Perl_dowantarray(aTHX) #define dump_all() Perl_dump_all(aTHX) #define dump_eval() Perl_dump_eval(aTHX) #define dump_form(a) Perl_dump_form(aTHX_ a) #ifndef PERL_IMPLICIT_CONTEXT #define dump_indent Perl_dump_indent #endif #define dump_packsubs(a) Perl_dump_packsubs(aTHX_ a) #define dump_sub(a) Perl_dump_sub(aTHX_ a) #define dump_vindent(a,b,c,d) Perl_dump_vindent(aTHX_ a,b,c,d) #define eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) #define eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) #define fbm_compile(a,b) Perl_fbm_compile(aTHX_ a,b) #define fbm_instr(a,b,c,d) Perl_fbm_instr(aTHX_ a,b,c,d) #define filter_add(a,b) Perl_filter_add(aTHX_ a,b) #define filter_del(a) Perl_filter_del(aTHX_ a) #define filter_read(a,b,c) Perl_filter_read(aTHX_ a,b,c) #define find_runcv(a) Perl_find_runcv(aTHX_ a) #define find_rundefsv() Perl_find_rundefsv(aTHX) #define find_rundefsvoffset() Perl_find_rundefsvoffset(aTHX) #define foldEQ Perl_foldEQ #define foldEQ_latin1 Perl_foldEQ_latin1 #define foldEQ_locale Perl_foldEQ_locale #define foldEQ_utf8_flags(a,b,c,d,e,f,g,h,i) Perl_foldEQ_utf8_flags(aTHX_ a,b,c,d,e,f,g,h,i) #ifndef PERL_IMPLICIT_CONTEXT #define form Perl_form #endif #define free_tmps() Perl_free_tmps(aTHX) #define get_av(a,b) Perl_get_av(aTHX_ a,b) #define get_context Perl_get_context #define get_cv(a,b) Perl_get_cv(aTHX_ a,b) #define get_cvn_flags(a,b,c) Perl_get_cvn_flags(aTHX_ a,b,c) #define get_hv(a,b) Perl_get_hv(aTHX_ a,b) #define get_op_descs() Perl_get_op_descs(aTHX) #define get_op_names() Perl_get_op_names(aTHX) #define get_ppaddr() Perl_get_ppaddr(aTHX) #define get_sv(a,b) Perl_get_sv(aTHX_ a,b) #define get_vtbl(a) Perl_get_vtbl(aTHX_ a) #define getcwd_sv(a) Perl_getcwd_sv(aTHX_ a) #define gp_free(a) Perl_gp_free(aTHX_ a) #define gp_ref(a) Perl_gp_ref(aTHX_ a) #define grok_bin(a,b,c,d) Perl_grok_bin(aTHX_ a,b,c,d) #define grok_hex(a,b,c,d) Perl_grok_hex(aTHX_ a,b,c,d) #define grok_number(a,b,c) Perl_grok_number(aTHX_ a,b,c) #define grok_numeric_radix(a,b) Perl_grok_numeric_radix(aTHX_ a,b) #define grok_oct(a,b,c,d) Perl_grok_oct(aTHX_ a,b,c,d) #define gv_add_by_type(a,b) Perl_gv_add_by_type(aTHX_ a,b) #define gv_autoload_pv(a,b,c) Perl_gv_autoload_pv(aTHX_ a,b,c) #define gv_autoload_pvn(a,b,c,d) Perl_gv_autoload_pvn(aTHX_ a,b,c,d) #define gv_autoload_sv(a,b,c) Perl_gv_autoload_sv(aTHX_ a,b,c) #define gv_check(a) Perl_gv_check(aTHX_ a) #define gv_const_sv(a) Perl_gv_const_sv(aTHX_ a) #define gv_dump(a) Perl_gv_dump(aTHX_ a) #define gv_efullname(a,b) Perl_gv_efullname(aTHX_ a,b) #define gv_efullname4(a,b,c,d) Perl_gv_efullname4(aTHX_ a,b,c,d) #define gv_fetchfile(a) Perl_gv_fetchfile(aTHX_ a) #define gv_fetchfile_flags(a,b,c) Perl_gv_fetchfile_flags(aTHX_ a,b,c) #define gv_fetchmeth_pv(a,b,c,d) Perl_gv_fetchmeth_pv(aTHX_ a,b,c,d) #define gv_fetchmeth_pv_autoload(a,b,c,d) Perl_gv_fetchmeth_pv_autoload(aTHX_ a,b,c,d) #define gv_fetchmeth_pvn(a,b,c,d,e) Perl_gv_fetchmeth_pvn(aTHX_ a,b,c,d,e) #define gv_fetchmeth_pvn_autoload(a,b,c,d,e) Perl_gv_fetchmeth_pvn_autoload(aTHX_ a,b,c,d,e) #define gv_fetchmeth_sv(a,b,c,d) Perl_gv_fetchmeth_sv(aTHX_ a,b,c,d) #define gv_fetchmeth_sv_autoload(a,b,c,d) Perl_gv_fetchmeth_sv_autoload(aTHX_ a,b,c,d) #define gv_fetchmethod_autoload(a,b,c) Perl_gv_fetchmethod_autoload(aTHX_ a,b,c) #define gv_fetchmethod_pv_flags(a,b,c) Perl_gv_fetchmethod_pv_flags(aTHX_ a,b,c) #define gv_fetchmethod_pvn_flags(a,b,c,d) Perl_gv_fetchmethod_pvn_flags(aTHX_ a,b,c,d) #define gv_fetchmethod_sv_flags(a,b,c) Perl_gv_fetchmethod_sv_flags(aTHX_ a,b,c) #define gv_fetchpv(a,b,c) Perl_gv_fetchpv(aTHX_ a,b,c) #define gv_fetchpvn_flags(a,b,c,d) Perl_gv_fetchpvn_flags(aTHX_ a,b,c,d) #define gv_fetchsv(a,b,c) Perl_gv_fetchsv(aTHX_ a,b,c) #define gv_fullname(a,b) Perl_gv_fullname(aTHX_ a,b) #define gv_fullname4(a,b,c,d) Perl_gv_fullname4(aTHX_ a,b,c,d) #define gv_handler(a,b) Perl_gv_handler(aTHX_ a,b) #define gv_init_pv(a,b,c,d) Perl_gv_init_pv(aTHX_ a,b,c,d) #define gv_init_pvn(a,b,c,d,e) Perl_gv_init_pvn(aTHX_ a,b,c,d,e) #define gv_init_sv(a,b,c,d) Perl_gv_init_sv(aTHX_ a,b,c,d) #define gv_name_set(a,b,c,d) Perl_gv_name_set(aTHX_ a,b,c,d) #define gv_stashpv(a,b) Perl_gv_stashpv(aTHX_ a,b) #define gv_stashpvn(a,b,c) Perl_gv_stashpvn(aTHX_ a,b,c) #define gv_stashsv(a,b) Perl_gv_stashsv(aTHX_ a,b) #define hv_clear(a) Perl_hv_clear(aTHX_ a) #define hv_clear_placeholders(a) Perl_hv_clear_placeholders(aTHX_ a) #define hv_common(a,b,c,d,e,f,g,h) Perl_hv_common(aTHX_ a,b,c,d,e,f,g,h) #define hv_common_key_len(a,b,c,d,e,f) Perl_hv_common_key_len(aTHX_ a,b,c,d,e,f) #define hv_copy_hints_hv(a) Perl_hv_copy_hints_hv(aTHX_ a) #define hv_delayfree_ent(a,b) Perl_hv_delayfree_ent(aTHX_ a,b) #define hv_free_ent(a,b) Perl_hv_free_ent(aTHX_ a,b) #define hv_iterinit(a) Perl_hv_iterinit(aTHX_ a) #define hv_iterkey(a,b) Perl_hv_iterkey(aTHX_ a,b) #define hv_iterkeysv(a) Perl_hv_iterkeysv(aTHX_ a) #define hv_iternext_flags(a,b) Perl_hv_iternext_flags(aTHX_ a,b) #define hv_iternextsv(a,b,c) Perl_hv_iternextsv(aTHX_ a,b,c) #define hv_iterval(a,b) Perl_hv_iterval(aTHX_ a,b) #define hv_ksplit(a,b) Perl_hv_ksplit(aTHX_ a,b) #define hv_name_set(a,b,c,d) Perl_hv_name_set(aTHX_ a,b,c,d) #define hv_scalar(a) Perl_hv_scalar(aTHX_ a) #define init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) #define init_i18nl14n(a) Perl_init_i18nl14n(aTHX_ a) #define init_stacks() Perl_init_stacks(aTHX) #define init_tm(a) Perl_init_tm(aTHX_ a) #define instr Perl_instr #define is_ascii_string Perl_is_ascii_string #define is_lvalue_sub() Perl_is_lvalue_sub(aTHX) #define is_uni_alnum(a) Perl_is_uni_alnum(aTHX_ a) #define is_uni_alnum_lc(a) Perl_is_uni_alnum_lc(aTHX_ a) #define is_uni_alpha(a) Perl_is_uni_alpha(aTHX_ a) #define is_uni_alpha_lc(a) Perl_is_uni_alpha_lc(aTHX_ a) #define is_uni_ascii(a) Perl_is_uni_ascii(aTHX_ a) #define is_uni_ascii_lc(a) Perl_is_uni_ascii_lc(aTHX_ a) #define is_uni_cntrl(a) Perl_is_uni_cntrl(aTHX_ a) #define is_uni_cntrl_lc(a) Perl_is_uni_cntrl_lc(aTHX_ a) #define is_uni_digit(a) Perl_is_uni_digit(aTHX_ a) #define is_uni_digit_lc(a) Perl_is_uni_digit_lc(aTHX_ a) #define is_uni_graph(a) Perl_is_uni_graph(aTHX_ a) #define is_uni_graph_lc(a) Perl_is_uni_graph_lc(aTHX_ a) #define is_uni_idfirst(a) Perl_is_uni_idfirst(aTHX_ a) #define is_uni_idfirst_lc(a) Perl_is_uni_idfirst_lc(aTHX_ a) #define is_uni_lower(a) Perl_is_uni_lower(aTHX_ a) #define is_uni_lower_lc(a) Perl_is_uni_lower_lc(aTHX_ a) #define is_uni_print(a) Perl_is_uni_print(aTHX_ a) #define is_uni_print_lc(a) Perl_is_uni_print_lc(aTHX_ a) #define is_uni_punct(a) Perl_is_uni_punct(aTHX_ a) #define is_uni_punct_lc(a) Perl_is_uni_punct_lc(aTHX_ a) #define is_uni_space(a) Perl_is_uni_space(aTHX_ a) #define is_uni_space_lc(a) Perl_is_uni_space_lc(aTHX_ a) #define is_uni_upper(a) Perl_is_uni_upper(aTHX_ a) #define is_uni_upper_lc(a) Perl_is_uni_upper_lc(aTHX_ a) #define is_uni_xdigit(a) Perl_is_uni_xdigit(aTHX_ a) #define is_uni_xdigit_lc(a) Perl_is_uni_xdigit_lc(aTHX_ a) #define is_utf8_alnum(a) Perl_is_utf8_alnum(aTHX_ a) #define is_utf8_alpha(a) Perl_is_utf8_alpha(aTHX_ a) #define is_utf8_ascii(a) Perl_is_utf8_ascii(aTHX_ a) #define is_utf8_char Perl_is_utf8_char #define is_utf8_char_buf Perl_is_utf8_char_buf #define is_utf8_cntrl(a) Perl_is_utf8_cntrl(aTHX_ a) #define is_utf8_digit(a) Perl_is_utf8_digit(aTHX_ a) #define is_utf8_graph(a) Perl_is_utf8_graph(aTHX_ a) #define is_utf8_idcont(a) Perl_is_utf8_idcont(aTHX_ a) #define is_utf8_idfirst(a) Perl_is_utf8_idfirst(aTHX_ a) #define is_utf8_lower(a) Perl_is_utf8_lower(aTHX_ a) #define is_utf8_mark(a) Perl_is_utf8_mark(aTHX_ a) #define is_utf8_perl_space(a) Perl_is_utf8_perl_space(aTHX_ a) #define is_utf8_perl_word(a) Perl_is_utf8_perl_word(aTHX_ a) #define is_utf8_posix_digit(a) Perl_is_utf8_posix_digit(aTHX_ a) #define is_utf8_print(a) Perl_is_utf8_print(aTHX_ a) #define is_utf8_punct(a) Perl_is_utf8_punct(aTHX_ a) #define is_utf8_space(a) Perl_is_utf8_space(aTHX_ a) #define is_utf8_string Perl_is_utf8_string #define is_utf8_string_loclen Perl_is_utf8_string_loclen #define is_utf8_upper(a) Perl_is_utf8_upper(aTHX_ a) #define is_utf8_xdigit(a) Perl_is_utf8_xdigit(aTHX_ a) #define is_utf8_xidcont(a) Perl_is_utf8_xidcont(aTHX_ a) #define is_utf8_xidfirst(a) Perl_is_utf8_xidfirst(aTHX_ a) #define leave_scope(a) Perl_leave_scope(aTHX_ a) #define lex_bufutf8() Perl_lex_bufutf8(aTHX) #define lex_discard_to(a) Perl_lex_discard_to(aTHX_ a) #define lex_grow_linestr(a) Perl_lex_grow_linestr(aTHX_ a) #define lex_next_chunk(a) Perl_lex_next_chunk(aTHX_ a) #define lex_peek_unichar(a) Perl_lex_peek_unichar(aTHX_ a) #define lex_read_space(a) Perl_lex_read_space(aTHX_ a) #define lex_read_to(a) Perl_lex_read_to(aTHX_ a) #define lex_read_unichar(a) Perl_lex_read_unichar(aTHX_ a) #define lex_start(a,b,c) Perl_lex_start(aTHX_ a,b,c) #define lex_stuff_pv(a,b) Perl_lex_stuff_pv(aTHX_ a,b) #define lex_stuff_pvn(a,b,c) Perl_lex_stuff_pvn(aTHX_ a,b,c) #define lex_stuff_sv(a,b) Perl_lex_stuff_sv(aTHX_ a,b) #define lex_unstuff(a) Perl_lex_unstuff(aTHX_ a) #ifndef PERL_IMPLICIT_CONTEXT #define load_module Perl_load_module #endif #define looks_like_number(a) Perl_looks_like_number(aTHX_ a) #define magic_dump(a) Perl_magic_dump(aTHX_ a) #define markstack_grow() Perl_markstack_grow(aTHX) #ifndef PERL_IMPLICIT_CONTEXT #define mess Perl_mess #endif #define mess_sv(a,b) Perl_mess_sv(aTHX_ a,b) #define mg_clear(a) Perl_mg_clear(aTHX_ a) #define mg_copy(a,b,c,d) Perl_mg_copy(aTHX_ a,b,c,d) #define mg_find(a,b) Perl_mg_find(aTHX_ a,b) #define mg_findext(a,b,c) Perl_mg_findext(aTHX_ a,b,c) #define mg_free(a) Perl_mg_free(aTHX_ a) #define mg_free_type(a,b) Perl_mg_free_type(aTHX_ a,b) #define mg_get(a) Perl_mg_get(aTHX_ a) #define mg_length(a) Perl_mg_length(aTHX_ a) #define mg_magical(a) Perl_mg_magical(aTHX_ a) #define mg_set(a) Perl_mg_set(aTHX_ a) #define mg_size(a) Perl_mg_size(aTHX_ a) #define mini_mktime(a) Perl_mini_mktime(aTHX_ a) #define moreswitches(a) Perl_moreswitches(aTHX_ a) #define mro_get_linear_isa(a) Perl_mro_get_linear_isa(aTHX_ a) #define mro_method_changed_in(a) Perl_mro_method_changed_in(aTHX_ a) #define my_atof(a) Perl_my_atof(aTHX_ a) #define my_atof2(a,b) Perl_my_atof2(aTHX_ a,b) #define my_dirfd(a) Perl_my_dirfd(aTHX_ a) #define my_exit(a) Perl_my_exit(aTHX_ a) #define my_failure_exit() Perl_my_failure_exit(aTHX) #define my_fflush_all() Perl_my_fflush_all(aTHX) #define my_fork Perl_my_fork #define my_popen_list(a,b,c) Perl_my_popen_list(aTHX_ a,b,c) #define my_setenv(a,b) Perl_my_setenv(aTHX_ a,b) #define my_socketpair Perl_my_socketpair #define my_strftime(a,b,c,d,e,f,g,h,i,j) Perl_my_strftime(aTHX_ a,b,c,d,e,f,g,h,i,j) #define newANONATTRSUB(a,b,c,d) Perl_newANONATTRSUB(aTHX_ a,b,c,d) #define newANONHASH(a) Perl_newANONHASH(aTHX_ a) #define newANONLIST(a) Perl_newANONLIST(aTHX_ a) #define newANONSUB(a,b,c) Perl_newANONSUB(aTHX_ a,b,c) #define newASSIGNOP(a,b,c,d) Perl_newASSIGNOP(aTHX_ a,b,c,d) #define newATTRSUB(a,b,c,d,e) Perl_newATTRSUB(aTHX_ a,b,c,d,e) #define newAVREF(a) Perl_newAVREF(aTHX_ a) #define newBINOP(a,b,c,d) Perl_newBINOP(aTHX_ a,b,c,d) #define newCONDOP(a,b,c,d) Perl_newCONDOP(aTHX_ a,b,c,d) #define newCONSTSUB(a,b,c) Perl_newCONSTSUB(aTHX_ a,b,c) #define newCONSTSUB_flags(a,b,c,d,e) Perl_newCONSTSUB_flags(aTHX_ a,b,c,d,e) #define newCVREF(a,b) Perl_newCVREF(aTHX_ a,b) #define newFOROP(a,b,c,d,e) Perl_newFOROP(aTHX_ a,b,c,d,e) #define newGIVENOP(a,b,c) Perl_newGIVENOP(aTHX_ a,b,c) #define newGVOP(a,b,c) Perl_newGVOP(aTHX_ a,b,c) #define newGVREF(a,b) Perl_newGVREF(aTHX_ a,b) #define newGVgen_flags(a,b) Perl_newGVgen_flags(aTHX_ a,b) #define newHVREF(a) Perl_newHVREF(aTHX_ a) #define newHVhv(a) Perl_newHVhv(aTHX_ a) #define newLISTOP(a,b,c,d) Perl_newLISTOP(aTHX_ a,b,c,d) #define newLOGOP(a,b,c,d) Perl_newLOGOP(aTHX_ a,b,c,d) #define newLOOPEX(a,b) Perl_newLOOPEX(aTHX_ a,b) #define newLOOPOP(a,b,c,d) Perl_newLOOPOP(aTHX_ a,b,c,d) #define newNULLLIST() Perl_newNULLLIST(aTHX) #define newOP(a,b) Perl_newOP(aTHX_ a,b) #define newPMOP(a,b) Perl_newPMOP(aTHX_ a,b) #define newPROG(a) Perl_newPROG(aTHX_ a) #define newPVOP(a,b,c) Perl_newPVOP(aTHX_ a,b,c) #define newRANGE(a,b,c) Perl_newRANGE(aTHX_ a,b,c) #define newRV(a) Perl_newRV(aTHX_ a) #define newRV_noinc(a) Perl_newRV_noinc(aTHX_ a) #define newSLICEOP(a,b,c) Perl_newSLICEOP(aTHX_ a,b,c) #define newSTATEOP(a,b,c) Perl_newSTATEOP(aTHX_ a,b,c) #define newSV(a) Perl_newSV(aTHX_ a) #define newSVOP(a,b,c) Perl_newSVOP(aTHX_ a,b,c) #define newSVREF(a) Perl_newSVREF(aTHX_ a) #define newSV_type(a) Perl_newSV_type(aTHX_ a) #define newSVhek(a) Perl_newSVhek(aTHX_ a) #define newSViv(a) Perl_newSViv(aTHX_ a) #define newSVnv(a) Perl_newSVnv(aTHX_ a) #define newSVpv(a,b) Perl_newSVpv(aTHX_ a,b) #define newSVpv_share(a,b) Perl_newSVpv_share(aTHX_ a,b) #ifndef PERL_IMPLICIT_CONTEXT #define newSVpvf Perl_newSVpvf #endif #define newSVpvn(a,b) Perl_newSVpvn(aTHX_ a,b) #define newSVpvn_flags(a,b,c) Perl_newSVpvn_flags(aTHX_ a,b,c) #define newSVpvn_share(a,b,c) Perl_newSVpvn_share(aTHX_ a,b,c) #define newSVrv(a,b) Perl_newSVrv(aTHX_ a,b) #define newSVsv(a) Perl_newSVsv(aTHX_ a) #define newSVuv(a) Perl_newSVuv(aTHX_ a) #define newUNOP(a,b,c) Perl_newUNOP(aTHX_ a,b,c) #define newWHENOP(a,b) Perl_newWHENOP(aTHX_ a,b) #define newWHILEOP(a,b,c,d,e,f,g) Perl_newWHILEOP(aTHX_ a,b,c,d,e,f,g) #define newXS(a,b,c) Perl_newXS(aTHX_ a,b,c) #define newXS_flags(a,b,c,d,e) Perl_newXS_flags(aTHX_ a,b,c,d,e) #define new_collate(a) Perl_new_collate(aTHX_ a) #define new_ctype(a) Perl_new_ctype(aTHX_ a) #define new_numeric(a) Perl_new_numeric(aTHX_ a) #define new_stackinfo(a,b) Perl_new_stackinfo(aTHX_ a,b) #define new_version(a) Perl_new_version(aTHX_ a) #define ninstr Perl_ninstr #define nothreadhook() Perl_nothreadhook(aTHX) #define op_append_elem(a,b,c) Perl_op_append_elem(aTHX_ a,b,c) #define op_append_list(a,b,c) Perl_op_append_list(aTHX_ a,b,c) #define op_contextualize(a,b) Perl_op_contextualize(aTHX_ a,b) #define op_dump(a) Perl_op_dump(aTHX_ a) #define op_free(a) Perl_op_free(aTHX_ a) #define op_linklist(a) Perl_op_linklist(aTHX_ a) #define op_null(a) Perl_op_null(aTHX_ a) #define op_prepend_elem(a,b,c) Perl_op_prepend_elem(aTHX_ a,b,c) #define op_refcnt_lock() Perl_op_refcnt_lock(aTHX) #define op_refcnt_unlock() Perl_op_refcnt_unlock(aTHX) #define op_scope(a) Perl_op_scope(aTHX_ a) #define pack_cat(a,b,c,d,e,f,g) Perl_pack_cat(aTHX_ a,b,c,d,e,f,g) #define packlist(a,b,c,d,e) Perl_packlist(aTHX_ a,b,c,d,e) #define pad_add_anon(a,b) Perl_pad_add_anon(aTHX_ a,b) #define pad_add_name_pv(a,b,c,d) Perl_pad_add_name_pv(aTHX_ a,b,c,d) #define pad_add_name_pvn(a,b,c,d,e) Perl_pad_add_name_pvn(aTHX_ a,b,c,d,e) #define pad_add_name_sv(a,b,c,d) Perl_pad_add_name_sv(aTHX_ a,b,c,d) #define pad_alloc(a,b) Perl_pad_alloc(aTHX_ a,b) #define pad_compname_type(a) Perl_pad_compname_type(aTHX_ a) #define pad_findmy_pv(a,b) Perl_pad_findmy_pv(aTHX_ a,b) #define pad_findmy_pvn(a,b,c) Perl_pad_findmy_pvn(aTHX_ a,b,c) #define pad_findmy_sv(a,b) Perl_pad_findmy_sv(aTHX_ a,b) #define pad_new(a) Perl_pad_new(aTHX_ a) #define pad_tidy(a) Perl_pad_tidy(aTHX_ a) #define parse_arithexpr(a) Perl_parse_arithexpr(aTHX_ a) #define parse_barestmt(a) Perl_parse_barestmt(aTHX_ a) #define parse_block(a) Perl_parse_block(aTHX_ a) #define parse_fullexpr(a) Perl_parse_fullexpr(aTHX_ a) #define parse_fullstmt(a) Perl_parse_fullstmt(aTHX_ a) #define parse_label(a) Perl_parse_label(aTHX_ a) #define parse_listexpr(a) Perl_parse_listexpr(aTHX_ a) #define parse_stmtseq(a) Perl_parse_stmtseq(aTHX_ a) #define parse_termexpr(a) Perl_parse_termexpr(aTHX_ a) #define pmop_dump(a) Perl_pmop_dump(aTHX_ a) #define pop_scope() Perl_pop_scope(aTHX) #define pregcomp(a,b) Perl_pregcomp(aTHX_ a,b) #define pregexec(a,b,c,d,e,f,g) Perl_pregexec(aTHX_ a,b,c,d,e,f,g) #define pregfree(a) Perl_pregfree(aTHX_ a) #define pregfree2(a) Perl_pregfree2(aTHX_ a) #define prescan_version(a,b,c,d,e,f,g) Perl_prescan_version(aTHX_ a,b,c,d,e,f,g) #define ptr_table_clear(a) Perl_ptr_table_clear(aTHX_ a) #define ptr_table_fetch(a,b) Perl_ptr_table_fetch(aTHX_ a,b) #define ptr_table_free(a) Perl_ptr_table_free(aTHX_ a) #define ptr_table_new() Perl_ptr_table_new(aTHX) #define ptr_table_split(a) Perl_ptr_table_split(aTHX_ a) #define ptr_table_store(a,b,c) Perl_ptr_table_store(aTHX_ a,b,c) #define push_scope() Perl_push_scope(aTHX) #define pv_display(a,b,c,d,e) Perl_pv_display(aTHX_ a,b,c,d,e) #define pv_escape(a,b,c,d,e,f) Perl_pv_escape(aTHX_ a,b,c,d,e,f) #define pv_pretty(a,b,c,d,e,f,g) Perl_pv_pretty(aTHX_ a,b,c,d,e,f,g) #define pv_uni_display(a,b,c,d,e) Perl_pv_uni_display(aTHX_ a,b,c,d,e) #define re_compile(a,b) Perl_re_compile(aTHX_ a,b) #define re_intuit_start(a,b,c,d,e,f) Perl_re_intuit_start(aTHX_ a,b,c,d,e,f) #define re_intuit_string(a) Perl_re_intuit_string(aTHX_ a) #define reg_named_buff_all(a,b) Perl_reg_named_buff_all(aTHX_ a,b) #define reg_named_buff_exists(a,b,c) Perl_reg_named_buff_exists(aTHX_ a,b,c) #define reg_named_buff_fetch(a,b,c) Perl_reg_named_buff_fetch(aTHX_ a,b,c) #define reg_named_buff_firstkey(a,b) Perl_reg_named_buff_firstkey(aTHX_ a,b) #define reg_named_buff_nextkey(a,b) Perl_reg_named_buff_nextkey(aTHX_ a,b) #define reg_named_buff_scalar(a,b) Perl_reg_named_buff_scalar(aTHX_ a,b) #define regclass_swash(a,b,c,d,e) Perl_regclass_swash(aTHX_ a,b,c,d,e) #define regdump(a) Perl_regdump(aTHX_ a) #define regdump(a) Perl_regdump(aTHX_ a) #define regexec_flags(a,b,c,d,e,f,g,h) Perl_regexec_flags(aTHX_ a,b,c,d,e,f,g,h) #define regfree_internal(a) Perl_regfree_internal(aTHX_ a) #define reginitcolors() Perl_reginitcolors(aTHX) #define regnext(a) Perl_regnext(aTHX_ a) #define repeatcpy Perl_repeatcpy #define require_pv(a) Perl_require_pv(aTHX_ a) #define rninstr Perl_rninstr #define rsignal(a,b) Perl_rsignal(aTHX_ a,b) #define rsignal_state(a) Perl_rsignal_state(aTHX_ a) #define runops_debug() Perl_runops_debug(aTHX) #define runops_standard() Perl_runops_standard(aTHX) #define rv2cv_op_cv(a,b) Perl_rv2cv_op_cv(aTHX_ a,b) #define safesyscalloc Perl_safesyscalloc #define safesysfree Perl_safesysfree #define safesysmalloc Perl_safesysmalloc #define safesysrealloc Perl_safesysrealloc #define save_I16(a) Perl_save_I16(aTHX_ a) #define save_I32(a) Perl_save_I32(aTHX_ a) #define save_I8(a) Perl_save_I8(aTHX_ a) #define save_adelete(a,b) Perl_save_adelete(aTHX_ a,b) #define save_aelem_flags(a,b,c,d) Perl_save_aelem_flags(aTHX_ a,b,c,d) #define save_alloc(a,b) Perl_save_alloc(aTHX_ a,b) #define save_aptr(a) Perl_save_aptr(aTHX_ a) #define save_ary(a) Perl_save_ary(aTHX_ a) #define save_bool(a) Perl_save_bool(aTHX_ a) #define save_clearsv(a) Perl_save_clearsv(aTHX_ a) #define save_delete(a,b,c) Perl_save_delete(aTHX_ a,b,c) #define save_destructor(a,b) Perl_save_destructor(aTHX_ a,b) #define save_destructor_x(a,b) Perl_save_destructor_x(aTHX_ a,b) #define save_generic_pvref(a) Perl_save_generic_pvref(aTHX_ a) #define save_generic_svref(a) Perl_save_generic_svref(aTHX_ a) #define save_gp(a,b) Perl_save_gp(aTHX_ a,b) #define save_hash(a) Perl_save_hash(aTHX_ a) #define save_hdelete(a,b) Perl_save_hdelete(aTHX_ a,b) #define save_helem_flags(a,b,c,d) Perl_save_helem_flags(aTHX_ a,b,c,d) #define save_hints() Perl_save_hints(aTHX) #define save_hptr(a) Perl_save_hptr(aTHX_ a) #define save_int(a) Perl_save_int(aTHX_ a) #define save_item(a) Perl_save_item(aTHX_ a) #define save_iv(a) Perl_save_iv(aTHX_ a) #define save_list(a,b) Perl_save_list(aTHX_ a,b) #define save_long(a) Perl_save_long(aTHX_ a) #define save_nogv(a) Perl_save_nogv(aTHX_ a) #define save_padsv_and_mortalize(a) Perl_save_padsv_and_mortalize(aTHX_ a) #define save_pptr(a) Perl_save_pptr(aTHX_ a) #define save_pushi32ptr(a,b,c) Perl_save_pushi32ptr(aTHX_ a,b,c) #define save_pushptr(a,b) Perl_save_pushptr(aTHX_ a,b) #define save_pushptrptr(a,b,c) Perl_save_pushptrptr(aTHX_ a,b,c) #define save_re_context() Perl_save_re_context(aTHX) #define save_scalar(a) Perl_save_scalar(aTHX_ a) #define save_set_svflags(a,b,c) Perl_save_set_svflags(aTHX_ a,b,c) #define save_shared_pvref(a) Perl_save_shared_pvref(aTHX_ a) #define save_sptr(a) Perl_save_sptr(aTHX_ a) #define save_svref(a) Perl_save_svref(aTHX_ a) #define save_vptr(a) Perl_save_vptr(aTHX_ a) #define savepv(a) Perl_savepv(aTHX_ a) #define savepvn(a,b) Perl_savepvn(aTHX_ a,b) #define savesharedpv(a) Perl_savesharedpv(aTHX_ a) #define savesharedpvn(a,b) Perl_savesharedpvn(aTHX_ a,b) #define savesharedsvpv(a) Perl_savesharedsvpv(aTHX_ a) #define savestack_grow() Perl_savestack_grow(aTHX) #define savestack_grow_cnt(a) Perl_savestack_grow_cnt(aTHX_ a) #define savesvpv(a) Perl_savesvpv(aTHX_ a) #define scan_bin(a,b,c) Perl_scan_bin(aTHX_ a,b,c) #define scan_hex(a,b,c) Perl_scan_hex(aTHX_ a,b,c) #define scan_num(a,b) Perl_scan_num(aTHX_ a,b) #define scan_oct(a,b,c) Perl_scan_oct(aTHX_ a,b,c) #define scan_version(a,b,c) Perl_scan_version(aTHX_ a,b,c) #define scan_vstring(a,b,c) Perl_scan_vstring(aTHX_ a,b,c) #define screaminstr(a,b,c,d,e,f) Perl_screaminstr(aTHX_ a,b,c,d,e,f) #define seed() Perl_seed(aTHX) #define set_context Perl_set_context #define set_numeric_local() Perl_set_numeric_local(aTHX) #define set_numeric_radix() Perl_set_numeric_radix(aTHX) #define set_numeric_standard() Perl_set_numeric_standard(aTHX) #define setdefout(a) Perl_setdefout(aTHX_ a) #define share_hek(a,b,c) Perl_share_hek(aTHX_ a,b,c) #define sortsv(a,b,c) Perl_sortsv(aTHX_ a,b,c) #define sortsv_flags(a,b,c,d) Perl_sortsv_flags(aTHX_ a,b,c,d) #define stack_grow(a,b,c) Perl_stack_grow(aTHX_ a,b,c) #define start_subparse(a,b) Perl_start_subparse(aTHX_ a,b) #define stashpv_hvname_match(a,b) Perl_stashpv_hvname_match(aTHX_ a,b) #define str_to_version(a) Perl_str_to_version(aTHX_ a) #define sv_2bool_flags(a,b) Perl_sv_2bool_flags(aTHX_ a,b) #define sv_2cv(a,b,c,d) Perl_sv_2cv(aTHX_ a,b,c,d) #define sv_2io(a) Perl_sv_2io(aTHX_ a) #define sv_2iv_flags(a,b) Perl_sv_2iv_flags(aTHX_ a,b) #define sv_2mortal(a) Perl_sv_2mortal(aTHX_ a) #define sv_2nv_flags(a,b) Perl_sv_2nv_flags(aTHX_ a,b) #define sv_2pv_flags(a,b,c) Perl_sv_2pv_flags(aTHX_ a,b,c) #define sv_2pvbyte(a,b) Perl_sv_2pvbyte(aTHX_ a,b) #define sv_2pvutf8(a,b) Perl_sv_2pvutf8(aTHX_ a,b) #define sv_2uv_flags(a,b) Perl_sv_2uv_flags(aTHX_ a,b) #define sv_backoff(a) Perl_sv_backoff(aTHX_ a) #define sv_bless(a,b) Perl_sv_bless(aTHX_ a,b) #define sv_cat_decode(a,b,c,d,e,f) Perl_sv_cat_decode(aTHX_ a,b,c,d,e,f) #define sv_catpv(a,b) Perl_sv_catpv(aTHX_ a,b) #define sv_catpv_flags(a,b,c) Perl_sv_catpv_flags(aTHX_ a,b,c) #define sv_catpv_mg(a,b) Perl_sv_catpv_mg(aTHX_ a,b) #ifndef PERL_IMPLICIT_CONTEXT #define sv_catpvf Perl_sv_catpvf #define sv_catpvf_mg Perl_sv_catpvf_mg #endif #define sv_catpvn_flags(a,b,c,d) Perl_sv_catpvn_flags(aTHX_ a,b,c,d) #define sv_catsv_flags(a,b,c) Perl_sv_catsv_flags(aTHX_ a,b,c) #define sv_chop(a,b) Perl_sv_chop(aTHX_ a,b) #define sv_clear(a) Perl_sv_clear(aTHX_ a) #define sv_cmp_flags(a,b,c) Perl_sv_cmp_flags(aTHX_ a,b,c) #define sv_cmp_locale_flags(a,b,c) Perl_sv_cmp_locale_flags(aTHX_ a,b,c) #define sv_compile_2op(a,b,c,d) Perl_sv_compile_2op(aTHX_ a,b,c,d) #define sv_copypv(a,b) Perl_sv_copypv(aTHX_ a,b) #define sv_dec(a) Perl_sv_dec(aTHX_ a) #define sv_dec_nomg(a) Perl_sv_dec_nomg(aTHX_ a) #define sv_derived_from(a,b) Perl_sv_derived_from(aTHX_ a,b) #define sv_derived_from_pv(a,b,c) Perl_sv_derived_from_pv(aTHX_ a,b,c) #define sv_derived_from_pvn(a,b,c,d) Perl_sv_derived_from_pvn(aTHX_ a,b,c,d) #define sv_derived_from_sv(a,b,c) Perl_sv_derived_from_sv(aTHX_ a,b,c) #define sv_destroyable(a) Perl_sv_destroyable(aTHX_ a) #define sv_does(a,b) Perl_sv_does(aTHX_ a,b) #define sv_does_pv(a,b,c) Perl_sv_does_pv(aTHX_ a,b,c) #define sv_does_pvn(a,b,c,d) Perl_sv_does_pvn(aTHX_ a,b,c,d) #define sv_does_sv(a,b,c) Perl_sv_does_sv(aTHX_ a,b,c) #define sv_dump(a) Perl_sv_dump(aTHX_ a) #define sv_eq_flags(a,b,c) Perl_sv_eq_flags(aTHX_ a,b,c) #define sv_force_normal_flags(a,b) Perl_sv_force_normal_flags(aTHX_ a,b) #define sv_free(a) Perl_sv_free(aTHX_ a) #define sv_gets(a,b,c) Perl_sv_gets(aTHX_ a,b,c) #define sv_grow(a,b) Perl_sv_grow(aTHX_ a,b) #define sv_inc(a) Perl_sv_inc(aTHX_ a) #define sv_inc_nomg(a) Perl_sv_inc_nomg(aTHX_ a) #define sv_insert_flags(a,b,c,d,e,f) Perl_sv_insert_flags(aTHX_ a,b,c,d,e,f) #define sv_isa(a,b) Perl_sv_isa(aTHX_ a,b) #define sv_isobject(a) Perl_sv_isobject(aTHX_ a) #define sv_iv(a) Perl_sv_iv(aTHX_ a) #define sv_len(a) Perl_sv_len(aTHX_ a) #define sv_len_utf8(a) Perl_sv_len_utf8(aTHX_ a) #define sv_magic(a,b,c,d,e) Perl_sv_magic(aTHX_ a,b,c,d,e) #define sv_magicext(a,b,c,d,e,f) Perl_sv_magicext(aTHX_ a,b,c,d,e,f) #define sv_mortalcopy(a) Perl_sv_mortalcopy(aTHX_ a) #define sv_newmortal() Perl_sv_newmortal(aTHX) #define sv_newref(a) Perl_sv_newref(aTHX_ a) #define sv_nosharing(a) Perl_sv_nosharing(aTHX_ a) #define sv_nv(a) Perl_sv_nv(aTHX_ a) #define sv_peek(a) Perl_sv_peek(aTHX_ a) #define sv_pos_b2u(a,b) Perl_sv_pos_b2u(aTHX_ a,b) #define sv_pos_u2b(a,b,c) Perl_sv_pos_u2b(aTHX_ a,b,c) #define sv_pos_u2b_flags(a,b,c,d) Perl_sv_pos_u2b_flags(aTHX_ a,b,c,d) #define sv_pvbyten(a,b) Perl_sv_pvbyten(aTHX_ a,b) #define sv_pvbyten_force(a,b) Perl_sv_pvbyten_force(aTHX_ a,b) #define sv_pvn(a,b) Perl_sv_pvn(aTHX_ a,b) #define sv_pvn_force_flags(a,b,c) Perl_sv_pvn_force_flags(aTHX_ a,b,c) #define sv_pvn_nomg(a,b) Perl_sv_pvn_nomg(aTHX_ a,b) #define sv_pvutf8n(a,b) Perl_sv_pvutf8n(aTHX_ a,b) #define sv_pvutf8n_force(a,b) Perl_sv_pvutf8n_force(aTHX_ a,b) #define sv_recode_to_utf8(a,b) Perl_sv_recode_to_utf8(aTHX_ a,b) #define sv_reftype(a,b) Perl_sv_reftype(aTHX_ a,b) #define sv_replace(a,b) Perl_sv_replace(aTHX_ a,b) #define sv_report_used() Perl_sv_report_used(aTHX) #define sv_reset(a,b) Perl_sv_reset(aTHX_ a,b) #define sv_rvweaken(a) Perl_sv_rvweaken(aTHX_ a) #define sv_setiv(a,b) Perl_sv_setiv(aTHX_ a,b) #define sv_setiv_mg(a,b) Perl_sv_setiv_mg(aTHX_ a,b) #define sv_setnv(a,b) Perl_sv_setnv(aTHX_ a,b) #define sv_setnv_mg(a,b) Perl_sv_setnv_mg(aTHX_ a,b) #define sv_setpv(a,b) Perl_sv_setpv(aTHX_ a,b) #define sv_setpv_mg(a,b) Perl_sv_setpv_mg(aTHX_ a,b) #ifndef PERL_IMPLICIT_CONTEXT #define sv_setpvf Perl_sv_setpvf #define sv_setpvf_mg Perl_sv_setpvf_mg #endif #define sv_setpviv(a,b) Perl_sv_setpviv(aTHX_ a,b) #define sv_setpviv_mg(a,b) Perl_sv_setpviv_mg(aTHX_ a,b) #define sv_setpvn(a,b,c) Perl_sv_setpvn(aTHX_ a,b,c) #define sv_setpvn_mg(a,b,c) Perl_sv_setpvn_mg(aTHX_ a,b,c) #define sv_setref_iv(a,b,c) Perl_sv_setref_iv(aTHX_ a,b,c) #define sv_setref_nv(a,b,c) Perl_sv_setref_nv(aTHX_ a,b,c) #define sv_setref_pv(a,b,c) Perl_sv_setref_pv(aTHX_ a,b,c) #define sv_setref_pvn(a,b,c,d) Perl_sv_setref_pvn(aTHX_ a,b,c,d) #define sv_setref_uv(a,b,c) Perl_sv_setref_uv(aTHX_ a,b,c) #define sv_setsv_flags(a,b,c) Perl_sv_setsv_flags(aTHX_ a,b,c) #define sv_setsv_mg(a,b) Perl_sv_setsv_mg(aTHX_ a,b) #define sv_setuv(a,b) Perl_sv_setuv(aTHX_ a,b) #define sv_setuv_mg(a,b) Perl_sv_setuv_mg(aTHX_ a,b) #define sv_tainted(a) Perl_sv_tainted(aTHX_ a) #define sv_true(a) Perl_sv_true(aTHX_ a) #define sv_uni_display(a,b,c,d) Perl_sv_uni_display(aTHX_ a,b,c,d) #define sv_unmagic(a,b) Perl_sv_unmagic(aTHX_ a,b) #define sv_unmagicext(a,b,c) Perl_sv_unmagicext(aTHX_ a,b,c) #define sv_unref_flags(a,b) Perl_sv_unref_flags(aTHX_ a,b) #define sv_untaint(a) Perl_sv_untaint(aTHX_ a) #define sv_upgrade(a,b) Perl_sv_upgrade(aTHX_ a,b) #define sv_usepvn_flags(a,b,c,d) Perl_sv_usepvn_flags(aTHX_ a,b,c,d) #define sv_utf8_decode(a) Perl_sv_utf8_decode(aTHX_ a) #define sv_utf8_downgrade(a,b) Perl_sv_utf8_downgrade(aTHX_ a,b) #define sv_utf8_encode(a) Perl_sv_utf8_encode(aTHX_ a) #define sv_utf8_upgrade_flags_grow(a,b,c) Perl_sv_utf8_upgrade_flags_grow(aTHX_ a,b,c) #define sv_uv(a) Perl_sv_uv(aTHX_ a) #define sv_vcatpvf(a,b,c) Perl_sv_vcatpvf(aTHX_ a,b,c) #define sv_vcatpvf_mg(a,b,c) Perl_sv_vcatpvf_mg(aTHX_ a,b,c) #define sv_vcatpvfn(a,b,c,d,e,f,g) Perl_sv_vcatpvfn(aTHX_ a,b,c,d,e,f,g) #define sv_vsetpvf(a,b,c) Perl_sv_vsetpvf(aTHX_ a,b,c) #define sv_vsetpvf_mg(a,b,c) Perl_sv_vsetpvf_mg(aTHX_ a,b,c) #define sv_vsetpvfn(a,b,c,d,e,f,g) Perl_sv_vsetpvfn(aTHX_ a,b,c,d,e,f,g) #define swash_fetch(a,b,c) Perl_swash_fetch(aTHX_ a,b,c) #define swash_init(a,b,c,d,e) Perl_swash_init(aTHX_ a,b,c,d,e) #define taint_env() Perl_taint_env(aTHX) #define taint_proper(a,b) Perl_taint_proper(aTHX_ a,b) #define tmps_grow(a) Perl_tmps_grow(aTHX_ a) #define to_uni_lower(a,b,c) Perl_to_uni_lower(aTHX_ a,b,c) #define to_uni_lower_lc(a) Perl_to_uni_lower_lc(aTHX_ a) #define to_uni_title(a,b,c) Perl_to_uni_title(aTHX_ a,b,c) #define to_uni_title_lc(a) Perl_to_uni_title_lc(aTHX_ a) #define to_uni_upper(a,b,c) Perl_to_uni_upper(aTHX_ a,b,c) #define to_uni_upper_lc(a) Perl_to_uni_upper_lc(aTHX_ a) #define to_utf8_case(a,b,c,d,e,f) Perl_to_utf8_case(aTHX_ a,b,c,d,e,f) #define unpack_str(a,b,c,d,e,f,g,h) Perl_unpack_str(aTHX_ a,b,c,d,e,f,g,h) #define unpackstring(a,b,c,d,e) Perl_unpackstring(aTHX_ a,b,c,d,e) #define unsharepvn(a,b,c) Perl_unsharepvn(aTHX_ a,b,c) #define upg_version(a,b) Perl_upg_version(aTHX_ a,b) #define utf16_to_utf8(a,b,c,d) Perl_utf16_to_utf8(aTHX_ a,b,c,d) #define utf16_to_utf8_reversed(a,b,c,d) Perl_utf16_to_utf8_reversed(aTHX_ a,b,c,d) #define utf8_distance(a,b) Perl_utf8_distance(aTHX_ a,b) #define utf8_hop(a,b) Perl_utf8_hop(aTHX_ a,b) #define utf8_length(a,b) Perl_utf8_length(aTHX_ a,b) #define utf8_to_bytes(a,b) Perl_utf8_to_bytes(aTHX_ a,b) #define utf8_to_uvchr(a,b) Perl_utf8_to_uvchr(aTHX_ a,b) #define utf8_to_uvchr_buf(a,b,c) Perl_utf8_to_uvchr_buf(aTHX_ a,b,c) #define utf8_to_uvuni(a,b) Perl_utf8_to_uvuni(aTHX_ a,b) #define utf8_to_uvuni_buf(a,b,c) Perl_utf8_to_uvuni_buf(aTHX_ a,b,c) #define utf8n_to_uvuni(a,b,c,d) Perl_utf8n_to_uvuni(aTHX_ a,b,c,d) #define uvchr_to_utf8_flags(a,b,c) Perl_uvchr_to_utf8_flags(aTHX_ a,b,c) #define uvuni_to_utf8_flags(a,b,c) Perl_uvuni_to_utf8_flags(aTHX_ a,b,c) #define valid_utf8_to_uvchr(a,b) Perl_valid_utf8_to_uvchr(aTHX_ a,b) #define valid_utf8_to_uvuni(a,b) Perl_valid_utf8_to_uvuni(aTHX_ a,b) #define vcmp(a,b) Perl_vcmp(aTHX_ a,b) #define vcroak(a,b) Perl_vcroak(aTHX_ a,b) #define vdeb(a,b) Perl_vdeb(aTHX_ a,b) #define vform(a,b) Perl_vform(aTHX_ a,b) #define vload_module(a,b,c,d) Perl_vload_module(aTHX_ a,b,c,d) #define vmess(a,b) Perl_vmess(aTHX_ a,b) #define vnewSVpvf(a,b) Perl_vnewSVpvf(aTHX_ a,b) #define vnormal(a) Perl_vnormal(aTHX_ a) #define vnumify(a) Perl_vnumify(aTHX_ a) #define vstringify(a) Perl_vstringify(aTHX_ a) #define vverify(a) Perl_vverify(aTHX_ a) #define vwarn(a,b) Perl_vwarn(aTHX_ a,b) #define vwarner(a,b,c) Perl_vwarner(aTHX_ a,b,c) #ifndef PERL_IMPLICIT_CONTEXT #define warn Perl_warn #endif #define warn_sv(a) Perl_warn_sv(aTHX_ a) #ifndef PERL_IMPLICIT_CONTEXT #define warner Perl_warner #endif #define whichsig_pv(a) Perl_whichsig_pv(aTHX_ a) #define whichsig_pvn(a,b) Perl_whichsig_pvn(aTHX_ a,b) #define whichsig_sv(a) Perl_whichsig_sv(aTHX_ a) #define wrap_op_checker(a,b,c) Perl_wrap_op_checker(aTHX_ a,b,c) #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) #define csighandler Perl_csighandler #endif #if !(defined(NO_MATHOMS)) #define sv_nounlocking(a) Perl_sv_nounlocking(aTHX_ a) #endif #if !(defined(PERL_MAD)) #define newFORM(a,b,c) Perl_newFORM(aTHX_ a,b,c) #define newMYSUB(a,b,c,d,e) Perl_newMYSUB(aTHX_ a,b,c,d,e) #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) #define my_bzero Perl_my_bzero #endif #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) #define my_memcmp Perl_my_memcmp #endif #if !defined(HAS_MEMSET) #define my_memset Perl_my_memset #endif #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) #define my_chsize(a,b) Perl_my_chsize(aTHX_ a,b) #endif #if !defined(PERL_IMPLICIT_SYS) #define my_pclose(a) Perl_my_pclose(aTHX_ a) #define my_popen(a,b) Perl_my_popen(aTHX_ a,b) #endif #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY)) #define my_bcopy Perl_my_bcopy #endif #if defined(DEBUGGING) #define pad_setsv(a,b) Perl_pad_setsv(aTHX_ a,b) #define pad_sv(a) Perl_pad_sv(aTHX_ a) #endif #if defined(DUMP_FDS) #define dump_fds(a) Perl_dump_fds(aTHX_ a) #endif #if defined(EBCDIC) #define utf8n_to_uvchr(a,b,c,d) Perl_utf8n_to_uvchr(aTHX_ a,b,c,d) #define uvchr_to_utf8(a,b) Perl_uvchr_to_utf8(aTHX_ a,b) #endif #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) #define csighandler Perl_csighandler #endif #if defined(HAVE_INTERP_INTERN) #define sys_intern_clear() Perl_sys_intern_clear(aTHX) #define sys_intern_init() Perl_sys_intern_init(aTHX) # if defined(USE_ITHREADS) #define sys_intern_dup(a,b) Perl_sys_intern_dup(aTHX_ a,b) # endif #endif #if defined(MYMALLOC) #define dump_mstats(a) Perl_dump_mstats(aTHX_ a) #define get_mstats(a,b,c) Perl_get_mstats(aTHX_ a,b,c) #endif #if defined(MYSWAP) #define my_htonl(a) Perl_my_htonl(aTHX_ a) #define my_ntohl(a) Perl_my_ntohl(aTHX_ a) #define my_swap(a) Perl_my_swap(aTHX_ a) #endif #if defined(PERL_GLOBAL_STRUCT) #define GetVars() Perl_GetVars(aTHX) #define free_global_struct(a) Perl_free_global_struct(aTHX_ a) #define init_global_struct() Perl_init_global_struct(aTHX) #endif #if defined(PERL_IMPLICIT_CONTEXT) #define croak_nocontext Perl_croak_nocontext #define deb_nocontext Perl_deb_nocontext #define die_nocontext Perl_die_nocontext #define form_nocontext Perl_form_nocontext #define fprintf_nocontext Perl_fprintf_nocontext #define load_module_nocontext Perl_load_module_nocontext #define mess_nocontext Perl_mess_nocontext #define newSVpvf_nocontext Perl_newSVpvf_nocontext #define printf_nocontext Perl_printf_nocontext #define sv_catpvf_mg_nocontext Perl_sv_catpvf_mg_nocontext #define sv_catpvf_nocontext Perl_sv_catpvf_nocontext #define sv_setpvf_mg_nocontext Perl_sv_setpvf_mg_nocontext #define sv_setpvf_nocontext Perl_sv_setpvf_nocontext #define warn_nocontext Perl_warn_nocontext #define warner_nocontext Perl_warner_nocontext #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) #define _is_utf8_quotemeta(a) Perl__is_utf8_quotemeta(aTHX_ a) #endif #if defined(PERL_MAD) #define newFORM(a,b,c) Perl_newFORM(aTHX_ a,b,c) #define newMYSUB(a,b,c,d,e) Perl_newMYSUB(aTHX_ a,b,c,d,e) #endif #if defined(PL_OP_SLAB_ALLOC) #define Slab_Alloc(a) Perl_Slab_Alloc(aTHX_ a) #define Slab_Free(a) Perl_Slab_Free(aTHX_ a) #endif #if defined(UNLINK_ALL_VERSIONS) #define unlnk(a) Perl_unlnk(aTHX_ a) #endif #if defined(USE_ITHREADS) #define any_dup(a,b) Perl_any_dup(aTHX_ a,b) #define cx_dup(a,b,c,d) Perl_cx_dup(aTHX_ a,b,c,d) #define dirp_dup(a,b) Perl_dirp_dup(aTHX_ a,b) #define fp_dup(a,b,c) Perl_fp_dup(aTHX_ a,b,c) #define gp_dup(a,b) Perl_gp_dup(aTHX_ a,b) #define he_dup(a,b,c) Perl_he_dup(aTHX_ a,b,c) #define hek_dup(a,b) Perl_hek_dup(aTHX_ a,b) #define mg_dup(a,b) Perl_mg_dup(aTHX_ a,b) #define newPADOP(a,b,c) Perl_newPADOP(aTHX_ a,b,c) #define parser_dup(a,b) Perl_parser_dup(aTHX_ a,b) #define re_dup_guts(a,b,c) Perl_re_dup_guts(aTHX_ a,b,c) #define regdupe_internal(a,b) Perl_regdupe_internal(aTHX_ a,b) #define rvpv_dup(a,b,c) Perl_rvpv_dup(aTHX_ a,b,c) #define si_dup(a,b) Perl_si_dup(aTHX_ a,b) #define ss_dup(a,b) Perl_ss_dup(aTHX_ a,b) #define sv_dup(a,b) Perl_sv_dup(aTHX_ a,b) #define sv_dup_inc(a,b) Perl_sv_dup_inc(aTHX_ a,b) #endif #if defined(USE_LOCALE_COLLATE) #define sv_collxfrm_flags(a,b,c) Perl_sv_collxfrm_flags(aTHX_ a,b,c) #endif #if defined(USE_PERLIO) && !defined(USE_SFIO) #define PerlIO_clearerr(a) Perl_PerlIO_clearerr(aTHX_ a) #define PerlIO_close(a) Perl_PerlIO_close(aTHX_ a) #define PerlIO_eof(a) Perl_PerlIO_eof(aTHX_ a) #define PerlIO_error(a) Perl_PerlIO_error(aTHX_ a) #define PerlIO_fileno(a) Perl_PerlIO_fileno(aTHX_ a) #define PerlIO_fill(a) Perl_PerlIO_fill(aTHX_ a) #define PerlIO_flush(a) Perl_PerlIO_flush(aTHX_ a) #define PerlIO_get_base(a) Perl_PerlIO_get_base(aTHX_ a) #define PerlIO_get_bufsiz(a) Perl_PerlIO_get_bufsiz(aTHX_ a) #define PerlIO_get_cnt(a) Perl_PerlIO_get_cnt(aTHX_ a) #define PerlIO_get_ptr(a) Perl_PerlIO_get_ptr(aTHX_ a) #define PerlIO_read(a,b,c) Perl_PerlIO_read(aTHX_ a,b,c) #define PerlIO_seek(a,b,c) Perl_PerlIO_seek(aTHX_ a,b,c) #define PerlIO_set_cnt(a,b) Perl_PerlIO_set_cnt(aTHX_ a,b) #define PerlIO_set_ptrcnt(a,b,c) Perl_PerlIO_set_ptrcnt(aTHX_ a,b,c) #define PerlIO_setlinebuf(a) Perl_PerlIO_setlinebuf(aTHX_ a) #define PerlIO_stderr() Perl_PerlIO_stderr(aTHX) #define PerlIO_stdin() Perl_PerlIO_stdin(aTHX) #define PerlIO_stdout() Perl_PerlIO_stdout(aTHX) #define PerlIO_tell(a) Perl_PerlIO_tell(aTHX_ a) #define PerlIO_unread(a,b,c) Perl_PerlIO_unread(aTHX_ a,b,c) #define PerlIO_write(a,b,c) Perl_PerlIO_write(aTHX_ a,b,c) #endif #if defined(USE_REENTRANT_API) #define reentrant_free() Perl_reentrant_free(aTHX) #define reentrant_init() Perl_reentrant_init(aTHX) #define reentrant_retry Perl_reentrant_retry #define reentrant_size() Perl_reentrant_size(aTHX) #endif #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) #define do_aspawn(a,b,c) Perl_do_aspawn(aTHX_ a,b,c) #define do_spawn(a) Perl_do_spawn(aTHX_ a) #define do_spawn_nowait(a) Perl_do_spawn_nowait(aTHX_ a) #endif #if defined(PERL_CORE) || defined(PERL_EXT) #define _is_utf8__perl_idstart(a) Perl__is_utf8__perl_idstart(aTHX_ a) #define av_reify(a) Perl_av_reify(aTHX_ a) #define is_utf8_X_L(a) Perl_is_utf8_X_L(aTHX_ a) #define is_utf8_X_LV(a) Perl_is_utf8_X_LV(aTHX_ a) #define is_utf8_X_LVT(a) Perl_is_utf8_X_LVT(aTHX_ a) #define is_utf8_X_LV_LVT_V(a) Perl_is_utf8_X_LV_LVT_V(aTHX_ a) #define is_utf8_X_T(a) Perl_is_utf8_X_T(aTHX_ a) #define is_utf8_X_V(a) Perl_is_utf8_X_V(aTHX_ a) #define is_utf8_X_begin(a) Perl_is_utf8_X_begin(aTHX_ a) #define is_utf8_X_extend(a) Perl_is_utf8_X_extend(aTHX_ a) #define is_utf8_X_non_hangul(a) Perl_is_utf8_X_non_hangul(aTHX_ a) #define is_utf8_X_prepend(a) Perl_is_utf8_X_prepend(aTHX_ a) #define op_clear(a) Perl_op_clear(aTHX_ a) #define qerror(a) Perl_qerror(aTHX_ a) #define reg_named_buff(a,b,c,d) Perl_reg_named_buff(aTHX_ a,b,c,d) #define reg_named_buff_iter(a,b,c) Perl_reg_named_buff_iter(aTHX_ a,b,c) #define reg_numbered_buff_fetch(a,b,c) Perl_reg_numbered_buff_fetch(aTHX_ a,b,c) #define reg_numbered_buff_length(a,b,c) Perl_reg_numbered_buff_length(aTHX_ a,b,c) #define reg_numbered_buff_store(a,b,c) Perl_reg_numbered_buff_store(aTHX_ a,b,c) #define reg_qr_package(a) Perl_reg_qr_package(aTHX_ a) #define reg_temp_copy(a,b) Perl_reg_temp_copy(aTHX_ a,b) #define regprop(a,b,c) Perl_regprop(aTHX_ a,b,c) #define report_uninit(a) Perl_report_uninit(aTHX_ a) #define vivify_defelem(a) Perl_vivify_defelem(aTHX_ a) #define yylex() Perl_yylex(aTHX) # if defined(DEBUGGING) # if defined(PERL_IN_REGCOMP_C) #define dump_trie(a,b,c,d) S_dump_trie(aTHX_ a,b,c,d) #define dump_trie_interim_list(a,b,c,d,e) S_dump_trie_interim_list(aTHX_ a,b,c,d,e) #define dump_trie_interim_table(a,b,c,d,e) S_dump_trie_interim_table(aTHX_ a,b,c,d,e) #define dumpuntil(a,b,c,d,e,f,g,h) S_dumpuntil(aTHX_ a,b,c,d,e,f,g,h) #define put_byte(a,b) S_put_byte(aTHX_ a,b) #define regdump_extflags(a,b) S_regdump_extflags(aTHX_ a,b) #define regtail_study(a,b,c,d) S_regtail_study(aTHX_ a,b,c,d) # endif # if defined(PERL_IN_REGEXEC_C) #define debug_start_match(a,b,c,d,e) S_debug_start_match(aTHX_ a,b,c,d,e) #define dump_exec_pos(a,b,c,d,e,f) S_dump_exec_pos(aTHX_ a,b,c,d,e,f) # endif # endif # if defined(PERL_IN_DQUOTE_STATIC_C) #define grok_bslash_c(a,b,c) S_grok_bslash_c(aTHX_ a,b,c) #define grok_bslash_o(a,b,c,d,e) S_grok_bslash_o(aTHX_ a,b,c,d,e) #define regcurly(a) S_regcurly(aTHX_ a) # endif # if defined(PERL_IN_REGCOMP_C) #define _append_range_to_invlist(a,b,c) S__append_range_to_invlist(aTHX_ a,b,c) #define _invlist_array_init(a,b) S__invlist_array_init(aTHX_ a,b) #define _new_invlist_C_array(a) S__new_invlist_C_array(aTHX_ a) #define add_alternate(a,b,c) S_add_alternate(aTHX_ a,b,c) #define add_cp_to_invlist(a,b) S_add_cp_to_invlist(aTHX_ a,b) #define add_data S_add_data #define checkposixcc(a) S_checkposixcc(aTHX_ a) #define cl_and S_cl_and #define cl_anything S_cl_anything #define cl_init S_cl_init #define cl_is_anything S_cl_is_anything #define cl_or S_cl_or #define get_invlist_iter_addr(a) S_get_invlist_iter_addr(aTHX_ a) #define get_invlist_len_addr(a) S_get_invlist_len_addr(aTHX_ a) #define get_invlist_version_id_addr(a) S_get_invlist_version_id_addr(aTHX_ a) #define get_invlist_zero_addr(a) S_get_invlist_zero_addr(aTHX_ a) #define invlist_array(a) S_invlist_array(aTHX_ a) #define invlist_clone(a) S_invlist_clone(aTHX_ a) #define invlist_extend(a,b) S_invlist_extend(aTHX_ a,b) #define invlist_iterinit(a) S_invlist_iterinit(aTHX_ a) #define invlist_iternext(a,b,c) S_invlist_iternext(aTHX_ a,b,c) #define invlist_len(a) S_invlist_len(aTHX_ a) #define invlist_max(a) S_invlist_max(aTHX_ a) #define invlist_search(a,b) S_invlist_search(aTHX_ a,b) #define invlist_set_len(a,b) S_invlist_set_len(aTHX_ a,b) #define invlist_trim(a) S_invlist_trim(aTHX_ a) #define join_exact(a,b,c,d,e,f,g) S_join_exact(aTHX_ a,b,c,d,e,f,g) #define make_trie(a,b,c,d,e,f,g,h) S_make_trie(aTHX_ a,b,c,d,e,f,g,h) #define make_trie_failtable(a,b,c,d) S_make_trie_failtable(aTHX_ a,b,c,d) #define nextchar(a) S_nextchar(aTHX_ a) #define rck_elide_nothing(a) S_rck_elide_nothing(aTHX_ a) #define reg(a,b,c,d) S_reg(aTHX_ a,b,c,d) #define reg_namedseq(a,b,c,d) S_reg_namedseq(aTHX_ a,b,c,d) #define reg_node(a,b) S_reg_node(aTHX_ a,b) #define reg_recode(a,b) S_reg_recode(aTHX_ a,b) #define reg_scan_name(a,b) S_reg_scan_name(aTHX_ a,b) #define reg_skipcomment(a) S_reg_skipcomment(aTHX_ a) #define reganode(a,b,c) S_reganode(aTHX_ a,b,c) #define regatom(a,b,c) S_regatom(aTHX_ a,b,c) #define regbranch(a,b,c,d) S_regbranch(aTHX_ a,b,c,d) #define regclass(a,b) S_regclass(aTHX_ a,b) #define reginsert(a,b,c,d) S_reginsert(aTHX_ a,b,c,d) #define regpiece(a,b,c) S_regpiece(aTHX_ a,b,c) #define regpposixcc(a,b) S_regpposixcc(aTHX_ a,b) #define regtail(a,b,c,d) S_regtail(aTHX_ a,b,c,d) #define reguni(a,b,c) S_reguni(aTHX_ a,b,c) #define regwhite S_regwhite #define scan_commit(a,b,c,d) S_scan_commit(aTHX_ a,b,c,d) #define set_regclass_bit(a,b,c,d,e) S_set_regclass_bit(aTHX_ a,b,c,d,e) #define set_regclass_bit_fold(a,b,c,d,e) S_set_regclass_bit_fold(aTHX_ a,b,c,d,e) #define study_chunk(a,b,c,d,e,f,g,h,i,j,k,l) S_study_chunk(aTHX_ a,b,c,d,e,f,g,h,i,j,k,l) # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) #define _core_swash_init(a,b,c,d,e,f,g,h) Perl__core_swash_init(aTHX_ a,b,c,d,e,f,g,h) #define _invlist_contents(a) Perl__invlist_contents(aTHX_ a) # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) #define _add_range_to_invlist(a,b,c) Perl__add_range_to_invlist(aTHX_ a,b,c) #define _invlist_intersection_maybe_complement_2nd(a,b,c,d) Perl__invlist_intersection_maybe_complement_2nd(aTHX_ a,b,c,d) #define _invlist_invert(a) Perl__invlist_invert(aTHX_ a) #define _invlist_invert_prop(a) Perl__invlist_invert_prop(aTHX_ a) #define _invlist_populate_swatch(a,b,c,d) Perl__invlist_populate_swatch(aTHX_ a,b,c,d) #define _invlist_union_maybe_complement_2nd(a,b,c,d) Perl__invlist_union_maybe_complement_2nd(aTHX_ a,b,c,d) #define _new_invlist(a) Perl__new_invlist(aTHX_ a) #define _swash_inversion_hash(a) Perl__swash_inversion_hash(aTHX_ a) #define _swash_to_invlist(a) Perl__swash_to_invlist(aTHX_ a) # endif # if defined(PERL_IN_REGEXEC_C) #define core_regclass_swash(a,b,c,d,e) S_core_regclass_swash(aTHX_ a,b,c,d,e) #define find_byclass(a,b,c,d,e) S_find_byclass(aTHX_ a,b,c,d,e) #define reg_check_named_buff_matched(a,b) S_reg_check_named_buff_matched(aTHX_ a,b) #define regcppop(a) S_regcppop(aTHX_ a) #define regcppush(a) S_regcppush(aTHX_ a) #define reghop3 S_reghop3 #define reghopmaybe3 S_reghopmaybe3 #define reginclass(a,b,c,d,e) S_reginclass(aTHX_ a,b,c,d,e) #define regmatch(a,b) S_regmatch(aTHX_ a,b) #define regrepeat(a,b,c,d) S_regrepeat(aTHX_ a,b,c,d) #define regtry(a,b) S_regtry(aTHX_ a,b) #define to_byte_substr(a) S_to_byte_substr(aTHX_ a) #define to_utf8_substr(a) S_to_utf8_substr(aTHX_ a) # if defined(XXX_dmq) #define reghop4 S_reghop4 # endif # endif # if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) #define _to_fold_latin1(a,b,c,d) Perl__to_fold_latin1(aTHX_ a,b,c,d) # endif # if defined(PERL_OLD_COPY_ON_WRITE) #define sv_setsv_cow(a,b) Perl_sv_setsv_cow(aTHX_ a,b) # endif #endif #ifdef PERL_CORE #define allocmy(a,b,c) Perl_allocmy(aTHX_ a,b,c) #define amagic_is_enabled(a) Perl_amagic_is_enabled(aTHX_ a) #define apply(a,b,c) Perl_apply(aTHX_ a,b,c) #define bind_match(a,b,c) Perl_bind_match(aTHX_ a,b,c) #define block_end(a,b) Perl_block_end(aTHX_ a,b) #define block_start(a) Perl_block_start(aTHX_ a) #define boot_core_PerlIO() Perl_boot_core_PerlIO(aTHX) #define boot_core_UNIVERSAL() Perl_boot_core_UNIVERSAL(aTHX) #define boot_core_mro() Perl_boot_core_mro(aTHX) #define cando(a,b,c) Perl_cando(aTHX_ a,b,c) #define check_utf8_print(a,b) Perl_check_utf8_print(aTHX_ a,b) #define ck_anoncode(a) Perl_ck_anoncode(aTHX_ a) #define ck_bitop(a) Perl_ck_bitop(aTHX_ a) #define ck_chdir(a) Perl_ck_chdir(aTHX_ a) #define ck_cmp(a) Perl_ck_cmp(aTHX_ a) #define ck_concat(a) Perl_ck_concat(aTHX_ a) #define ck_defined(a) Perl_ck_defined(aTHX_ a) #define ck_delete(a) Perl_ck_delete(aTHX_ a) #define ck_die(a) Perl_ck_die(aTHX_ a) #define ck_each(a) Perl_ck_each(aTHX_ a) #define ck_eof(a) Perl_ck_eof(aTHX_ a) #define ck_eval(a) Perl_ck_eval(aTHX_ a) #define ck_exec(a) Perl_ck_exec(aTHX_ a) #define ck_exists(a) Perl_ck_exists(aTHX_ a) #define ck_exit(a) Perl_ck_exit(aTHX_ a) #define ck_ftst(a) Perl_ck_ftst(aTHX_ a) #define ck_fun(a) Perl_ck_fun(aTHX_ a) #define ck_glob(a) Perl_ck_glob(aTHX_ a) #define ck_grep(a) Perl_ck_grep(aTHX_ a) #define ck_index(a) Perl_ck_index(aTHX_ a) #define ck_join(a) Perl_ck_join(aTHX_ a) #define ck_length(a) Perl_ck_length(aTHX_ a) #define ck_lfun(a) Perl_ck_lfun(aTHX_ a) #define ck_listiob(a) Perl_ck_listiob(aTHX_ a) #define ck_match(a) Perl_ck_match(aTHX_ a) #define ck_method(a) Perl_ck_method(aTHX_ a) #define ck_null(a) Perl_ck_null(aTHX_ a) #define ck_open(a) Perl_ck_open(aTHX_ a) #define ck_readline(a) Perl_ck_readline(aTHX_ a) #define ck_repeat(a) Perl_ck_repeat(aTHX_ a) #define ck_require(a) Perl_ck_require(aTHX_ a) #define ck_return(a) Perl_ck_return(aTHX_ a) #define ck_rfun(a) Perl_ck_rfun(aTHX_ a) #define ck_rvconst(a) Perl_ck_rvconst(aTHX_ a) #define ck_sassign(a) Perl_ck_sassign(aTHX_ a) #define ck_select(a) Perl_ck_select(aTHX_ a) #define ck_shift(a) Perl_ck_shift(aTHX_ a) #define ck_smartmatch(a) Perl_ck_smartmatch(aTHX_ a) #define ck_sort(a) Perl_ck_sort(aTHX_ a) #define ck_spair(a) Perl_ck_spair(aTHX_ a) #define ck_split(a) Perl_ck_split(aTHX_ a) #define ck_subr(a) Perl_ck_subr(aTHX_ a) #define ck_substr(a) Perl_ck_substr(aTHX_ a) #define ck_svconst(a) Perl_ck_svconst(aTHX_ a) #define ck_tell(a) Perl_ck_tell(aTHX_ a) #define ck_trunc(a) Perl_ck_trunc(aTHX_ a) #define convert(a,b,c) Perl_convert(aTHX_ a,b,c) #define core_prototype(a,b,c,d) Perl_core_prototype(aTHX_ a,b,c,d) #define coresub_op(a,b,c) Perl_coresub_op(aTHX_ a,b,c) #define create_eval_scope(a) Perl_create_eval_scope(aTHX_ a) #define cv_ckproto_len_flags(a,b,c,d,e) Perl_cv_ckproto_len_flags(aTHX_ a,b,c,d,e) #define cvgv_set(a,b) Perl_cvgv_set(aTHX_ a,b) #define cvstash_set(a,b) Perl_cvstash_set(aTHX_ a,b) #define deb_stack_all() Perl_deb_stack_all(aTHX) #define delete_eval_scope() Perl_delete_eval_scope(aTHX) #define die_unwind(a) Perl_die_unwind(aTHX_ a) #define do_aexec5(a,b,c,d,e) Perl_do_aexec5(aTHX_ a,b,c,d,e) #define do_dump_pad(a,b,c,d) Perl_do_dump_pad(aTHX_ a,b,c,d) #define do_eof(a) Perl_do_eof(aTHX_ a) #define do_execfree() Perl_do_execfree(aTHX) #define do_ncmp(a,b) Perl_do_ncmp(aTHX_ a,b) #define do_print(a,b) Perl_do_print(aTHX_ a,b) #define do_readline() Perl_do_readline(aTHX) #define do_seek(a,b,c) Perl_do_seek(aTHX_ a,b,c) #define do_sysseek(a,b,c) Perl_do_sysseek(aTHX_ a,b,c) #define do_tell(a) Perl_do_tell(aTHX_ a) #define do_trans(a) Perl_do_trans(aTHX_ a) #define do_vecget(a,b,c) Perl_do_vecget(aTHX_ a,b,c) #define do_vecset(a) Perl_do_vecset(aTHX_ a) #define do_vop(a,b,c,d) Perl_do_vop(aTHX_ a,b,c,d) #define dofile(a,b) Perl_dofile(aTHX_ a,b) #define dump_all_perl(a) Perl_dump_all_perl(aTHX_ a) #define dump_packsubs_perl(a,b) Perl_dump_packsubs_perl(aTHX_ a,b) #define dump_sub_perl(a,b) Perl_dump_sub_perl(aTHX_ a,b) #define finalize_optree(a) Perl_finalize_optree(aTHX_ a) #define find_rundefsv2(a,b) Perl_find_rundefsv2(aTHX_ a,b) #define find_script(a,b,c,d) Perl_find_script(aTHX_ a,b,c,d) #define free_tied_hv_pool() Perl_free_tied_hv_pool(aTHX) #define get_hash_seed() Perl_get_hash_seed(aTHX) #define get_no_modify() Perl_get_no_modify(aTHX) #define get_opargs() Perl_get_opargs(aTHX) #define gv_try_downgrade(a) Perl_gv_try_downgrade(aTHX_ a) #define hv_ename_add(a,b,c,d) Perl_hv_ename_add(aTHX_ a,b,c,d) #define hv_ename_delete(a,b,c,d) Perl_hv_ename_delete(aTHX_ a,b,c,d) #define init_argv_symbols(a,b) Perl_init_argv_symbols(aTHX_ a,b) #define init_debugger() Perl_init_debugger(aTHX) #define intro_my() Perl_intro_my(aTHX) #define invert(a) Perl_invert(aTHX_ a) #define io_close(a,b) Perl_io_close(aTHX_ a,b) #define jmaybe(a) Perl_jmaybe(aTHX_ a) #define keyword(a,b,c) Perl_keyword(aTHX_ a,b,c) #define list(a) Perl_list(aTHX_ a) #define localize(a,b) Perl_localize(aTHX_ a,b) #define magic_clear_all_env(a,b) Perl_magic_clear_all_env(aTHX_ a,b) #define magic_clearenv(a,b) Perl_magic_clearenv(aTHX_ a,b) #define magic_clearhint(a,b) Perl_magic_clearhint(aTHX_ a,b) #define magic_clearhints(a,b) Perl_magic_clearhints(aTHX_ a,b) #define magic_clearisa(a,b) Perl_magic_clearisa(aTHX_ a,b) #define magic_clearpack(a,b) Perl_magic_clearpack(aTHX_ a,b) #define magic_clearsig(a,b) Perl_magic_clearsig(aTHX_ a,b) #define magic_existspack(a,b) Perl_magic_existspack(aTHX_ a,b) #define magic_freearylen_p(a,b) Perl_magic_freearylen_p(aTHX_ a,b) #define magic_freeovrld(a,b) Perl_magic_freeovrld(aTHX_ a,b) #define magic_get(a,b) Perl_magic_get(aTHX_ a,b) #define magic_getarylen(a,b) Perl_magic_getarylen(aTHX_ a,b) #define magic_getdefelem(a,b) Perl_magic_getdefelem(aTHX_ a,b) #define magic_getnkeys(a,b) Perl_magic_getnkeys(aTHX_ a,b) #define magic_getpack(a,b) Perl_magic_getpack(aTHX_ a,b) #define magic_getpos(a,b) Perl_magic_getpos(aTHX_ a,b) #define magic_getsig(a,b) Perl_magic_getsig(aTHX_ a,b) #define magic_getsubstr(a,b) Perl_magic_getsubstr(aTHX_ a,b) #define magic_gettaint(a,b) Perl_magic_gettaint(aTHX_ a,b) #define magic_getuvar(a,b) Perl_magic_getuvar(aTHX_ a,b) #define magic_getvec(a,b) Perl_magic_getvec(aTHX_ a,b) #define magic_killbackrefs(a,b) Perl_magic_killbackrefs(aTHX_ a,b) #define magic_len(a,b) Perl_magic_len(aTHX_ a,b) #define magic_nextpack(a,b,c) Perl_magic_nextpack(aTHX_ a,b,c) #define magic_regdata_cnt(a,b) Perl_magic_regdata_cnt(aTHX_ a,b) #define magic_regdatum_get(a,b) Perl_magic_regdatum_get(aTHX_ a,b) #define magic_regdatum_set(a,b) Perl_magic_regdatum_set(aTHX_ a,b) #define magic_scalarpack(a,b) Perl_magic_scalarpack(aTHX_ a,b) #define magic_set(a,b) Perl_magic_set(aTHX_ a,b) #define magic_set_all_env(a,b) Perl_magic_set_all_env(aTHX_ a,b) #define magic_setamagic(a,b) Perl_magic_setamagic(aTHX_ a,b) #define magic_setarylen(a,b) Perl_magic_setarylen(aTHX_ a,b) #define magic_setdbline(a,b) Perl_magic_setdbline(aTHX_ a,b) #define magic_setdefelem(a,b) Perl_magic_setdefelem(aTHX_ a,b) #define magic_setenv(a,b) Perl_magic_setenv(aTHX_ a,b) #define magic_sethint(a,b) Perl_magic_sethint(aTHX_ a,b) #define magic_setisa(a,b) Perl_magic_setisa(aTHX_ a,b) #define magic_setmglob(a,b) Perl_magic_setmglob(aTHX_ a,b) #define magic_setnkeys(a,b) Perl_magic_setnkeys(aTHX_ a,b) #define magic_setpack(a,b) Perl_magic_setpack(aTHX_ a,b) #define magic_setpos(a,b) Perl_magic_setpos(aTHX_ a,b) #define magic_setregexp(a,b) Perl_magic_setregexp(aTHX_ a,b) #define magic_setsig(a,b) Perl_magic_setsig(aTHX_ a,b) #define magic_setsubstr(a,b) Perl_magic_setsubstr(aTHX_ a,b) #define magic_settaint(a,b) Perl_magic_settaint(aTHX_ a,b) #define magic_setutf8(a,b) Perl_magic_setutf8(aTHX_ a,b) #define magic_setuvar(a,b) Perl_magic_setuvar(aTHX_ a,b) #define magic_setvec(a,b) Perl_magic_setvec(aTHX_ a,b) #define magic_setvstring(a,b) Perl_magic_setvstring(aTHX_ a,b) #define magic_sizepack(a,b) Perl_magic_sizepack(aTHX_ a,b) #define magic_wipepack(a,b) Perl_magic_wipepack(aTHX_ a,b) #define mg_localize(a,b,c) Perl_mg_localize(aTHX_ a,b,c) #define mode_from_discipline(a,b) Perl_mode_from_discipline(aTHX_ a,b) #define mro_isa_changed_in(a) Perl_mro_isa_changed_in(aTHX_ a) #define mro_package_moved(a,b,c,d) Perl_mro_package_moved(aTHX_ a,b,c,d) #define munge_qwlist_to_paren_list(a) Perl_munge_qwlist_to_paren_list(aTHX_ a) #define my_attrs(a,b) Perl_my_attrs(aTHX_ a,b) #define my_clearenv() Perl_my_clearenv(aTHX) #define my_lstat_flags(a) Perl_my_lstat_flags(aTHX_ a) #define my_stat_flags(a) Perl_my_stat_flags(aTHX_ a) #define my_swabn Perl_my_swabn #define my_unexec() Perl_my_unexec(aTHX) #define newATTRSUB_flags(a,b,c,d,e,f) Perl_newATTRSUB_flags(aTHX_ a,b,c,d,e,f) #define newXS_len_flags(a,b,c,d,e,f,g) Perl_newXS_len_flags(aTHX_ a,b,c,d,e,f,g) #define nextargv(a) Perl_nextargv(aTHX_ a) #define oopsAV(a) Perl_oopsAV(aTHX_ a) #define oopsHV(a) Perl_oopsHV(aTHX_ a) #define op_const_sv(a,b) Perl_op_const_sv(aTHX_ a,b) #define package_version(a) Perl_package_version(aTHX_ a) #define pad_block_start(a) Perl_pad_block_start(aTHX_ a) #define pad_fixup_inner_anons(a,b,c) Perl_pad_fixup_inner_anons(aTHX_ a,b,c) #define pad_free(a) Perl_pad_free(aTHX_ a) #define pad_leavemy() Perl_pad_leavemy(aTHX) #define pad_push(a,b) Perl_pad_push(aTHX_ a,b) #define pad_swipe(a,b) Perl_pad_swipe(aTHX_ a,b) #define parse_unicode_opts(a) Perl_parse_unicode_opts(aTHX_ a) #define parser_free(a) Perl_parser_free(aTHX_ a) #define peep(a) Perl_peep(aTHX_ a) #define pmruntime(a,b,c) Perl_pmruntime(aTHX_ a,b,c) #define refcounted_he_chain_2hv(a,b) Perl_refcounted_he_chain_2hv(aTHX_ a,b) #define refcounted_he_fetch_pv(a,b,c,d) Perl_refcounted_he_fetch_pv(aTHX_ a,b,c,d) #define refcounted_he_fetch_pvn(a,b,c,d,e) Perl_refcounted_he_fetch_pvn(aTHX_ a,b,c,d,e) #define refcounted_he_fetch_sv(a,b,c,d) Perl_refcounted_he_fetch_sv(aTHX_ a,b,c,d) #define refcounted_he_free(a) Perl_refcounted_he_free(aTHX_ a) #define refcounted_he_inc(a) Perl_refcounted_he_inc(aTHX_ a) #define refcounted_he_new_pv(a,b,c,d,e) Perl_refcounted_he_new_pv(aTHX_ a,b,c,d,e) #define refcounted_he_new_pvn(a,b,c,d,e,f) Perl_refcounted_he_new_pvn(aTHX_ a,b,c,d,e,f) #define refcounted_he_new_sv(a,b,c,d,e) Perl_refcounted_he_new_sv(aTHX_ a,b,c,d,e) #define report_evil_fh(a) Perl_report_evil_fh(aTHX_ a) #define report_wrongway_fh(a,b) Perl_report_wrongway_fh(aTHX_ a,b) #define rpeep(a) Perl_rpeep(aTHX_ a) #define rsignal_restore(a,b) Perl_rsignal_restore(aTHX_ a,b) #define rsignal_save(a,b,c) Perl_rsignal_save(aTHX_ a,b,c) #define rxres_save(a,b) Perl_rxres_save(aTHX_ a,b) #define sawparens(a) Perl_sawparens(aTHX_ a) #define scalar(a) Perl_scalar(aTHX_ a) #define scalarvoid(a) Perl_scalarvoid(aTHX_ a) #define sub_crush_depth(a) Perl_sub_crush_depth(aTHX_ a) #define sv_2num(a) Perl_sv_2num(aTHX_ a) #define sv_clean_all() Perl_sv_clean_all(aTHX) #define sv_clean_objs() Perl_sv_clean_objs(aTHX) #define sv_del_backref(a,b) Perl_sv_del_backref(aTHX_ a,b) #define sv_free_arenas() Perl_sv_free_arenas(aTHX) #define sv_ref(a,b,c) Perl_sv_ref(aTHX_ a,b,c) #define sv_sethek(a,b) Perl_sv_sethek(aTHX_ a,b) #ifndef PERL_IMPLICIT_CONTEXT #define tied_method Perl_tied_method #endif #define unshare_hek(a) Perl_unshare_hek(aTHX_ a) #define vivify_ref(a,b) Perl_vivify_ref(aTHX_ a,b) #define wait4pid(a,b,c) Perl_wait4pid(aTHX_ a,b,c) #define watch(a) Perl_watch(aTHX_ a) #define write_to_stderr(a) Perl_write_to_stderr(aTHX_ a) #define yyerror(a) Perl_yyerror(aTHX_ a) #define yyerror_pv(a,b) Perl_yyerror_pv(aTHX_ a,b) #define yyerror_pvn(a,b,c) Perl_yyerror_pvn(aTHX_ a,b,c) #define yyparse(a) Perl_yyparse(aTHX_ a) #define yyunlex() Perl_yyunlex(aTHX) # if !(defined(DEBUGGING)) # if !defined(NV_PRESERVES_UV) # if defined(PERL_IN_SV_C) #define sv_2iuv_non_preserve(a) S_sv_2iuv_non_preserve(aTHX_ a) # endif # endif # endif # if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) #define sighandler Perl_sighandler # endif # if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) #define do_exec(a) Perl_do_exec(aTHX_ a) # endif # if !(defined(PERL_MAD)) #define package(a) Perl_package(aTHX_ a) #define utilize(a,b,c,d,e) Perl_utilize(aTHX_ a,b,c,d,e) # endif # if !defined(HAS_GETENV_LEN) #define getenv_len(a,b) Perl_getenv_len(aTHX_ a,b) # endif # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) # if defined(PERL_IN_PP_SYS_C) #define dooneliner(a,b) S_dooneliner(aTHX_ a,b) # endif # endif # if !defined(HAS_RENAME) #define same_dirent(a,b) Perl_same_dirent(aTHX_ a,b) # endif # if !defined(NV_PRESERVES_UV) # if defined(DEBUGGING) # if defined(PERL_IN_SV_C) #define sv_2iuv_non_preserve(a,b) S_sv_2iuv_non_preserve(aTHX_ a,b) # endif # endif # endif # if !defined(PERL_DISABLE_PMC) # if defined(PERL_IN_PP_CTL_C) #define doopen_pm(a) S_doopen_pm(aTHX_ a) # endif # endif # if !defined(PERL_IS_MINIPERL) # if defined(PERL_IN_PERL_C) #define incpush_if_exists(a,b,c) S_incpush_if_exists(aTHX_ a,b,c) # endif # endif # if !defined(PERL_NO_UTF16_FILTER) # if defined(PERL_IN_TOKE_C) #define add_utf16_textfilter(a,b) S_add_utf16_textfilter(aTHX_ a,b) #define utf16_textfilter(a,b,c) S_utf16_textfilter(aTHX_ a,b,c) # endif # endif # if !defined(WIN32) #define do_exec3(a,b,c) Perl_do_exec3(aTHX_ a,b,c) # endif # if defined(DEBUGGING) #define get_debug_opts(a,b) Perl_get_debug_opts(aTHX_ a,b) # if defined(PERL_IN_PAD_C) #define cv_dump(a,b) S_cv_dump(aTHX_ a,b) # endif # if defined(PERL_IN_SV_C) #define del_sv(a) S_del_sv(aTHX_ a) # endif # if defined(PERL_IN_TOKE_C) #define printbuf(a,b) S_printbuf(aTHX_ a,b) #define tokereport(a,b) S_tokereport(aTHX_ a,b) # endif # endif # if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) #define dump_sv_child(a) Perl_dump_sv_child(aTHX_ a) # endif # if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) #define do_ipcctl(a,b,c) Perl_do_ipcctl(aTHX_ a,b,c) #define do_ipcget(a,b,c) Perl_do_ipcget(aTHX_ a,b,c) #define do_msgrcv(a,b) Perl_do_msgrcv(aTHX_ a,b) #define do_msgsnd(a,b) Perl_do_msgsnd(aTHX_ a,b) #define do_semop(a,b) Perl_do_semop(aTHX_ a,b) #define do_shmio(a,b,c) Perl_do_shmio(aTHX_ a,b,c) # endif # if defined(HAS_SIGACTION) && defined(SA_SIGINFO) #define sighandler Perl_sighandler # endif # if defined(MYMALLOC) #define malloc_good_size Perl_malloc_good_size #define malloced_size Perl_malloced_size # endif # if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) #define cr_textfilter(a,b,c) S_cr_textfilter(aTHX_ a,b,c) #define strip_return(a) S_strip_return(aTHX_ a) # endif # endif # if defined(PERL_DEBUG_READONLY_OPS) # if defined(PERL_IN_OP_C) # if defined(PL_OP_SLAB_ALLOC) #define Slab_to_rw(a) S_Slab_to_rw(aTHX_ a) # endif # endif # endif # if defined(PERL_IN_AV_C) #define get_aux_mg(a) S_get_aux_mg(aTHX_ a) # endif # if defined(PERL_IN_DEB_C) #define deb_stack_n(a,b,c,d,e) S_deb_stack_n(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_DOIO_C) #define exec_failed(a,b,c) S_exec_failed(aTHX_ a,b,c) #define ingroup(a,b) S_ingroup(aTHX_ a,b) # endif # if defined(PERL_IN_DOOP_C) #define do_trans_complex(a) S_do_trans_complex(aTHX_ a) #define do_trans_complex_utf8(a) S_do_trans_complex_utf8(aTHX_ a) #define do_trans_count(a) S_do_trans_count(aTHX_ a) #define do_trans_count_utf8(a) S_do_trans_count_utf8(aTHX_ a) #define do_trans_simple(a) S_do_trans_simple(aTHX_ a) #define do_trans_simple_utf8(a) S_do_trans_simple_utf8(aTHX_ a) # endif # if defined(PERL_IN_DUMP_C) #define deb_curcv(a) S_deb_curcv(aTHX_ a) #define debprof(a) S_debprof(aTHX_ a) #define pm_description(a) S_pm_description(aTHX_ a) #define sequence_num(a) S_sequence_num(aTHX_ a) # endif # if defined(PERL_IN_GV_C) #define gv_get_super_pkg(a,b,c) S_gv_get_super_pkg(aTHX_ a,b,c) #define gv_init_svtype(a,b) S_gv_init_svtype(aTHX_ a,b) #define gv_magicalize_isa(a) S_gv_magicalize_isa(aTHX_ a) #define gv_magicalize_overload(a) S_gv_magicalize_overload(aTHX_ a) #define require_tie_mod(a,b,c,d,e) S_require_tie_mod(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_HV_C) #define clear_placeholders(a,b) S_clear_placeholders(aTHX_ a,b) #define hfreeentries(a) S_hfreeentries(aTHX_ a) #define hsplit(a) S_hsplit(aTHX_ a) #define hv_auxinit S_hv_auxinit #define hv_delete_common(a,b,c,d,e,f,g) S_hv_delete_common(aTHX_ a,b,c,d,e,f,g) #define hv_free_ent_ret(a,b) S_hv_free_ent_ret(aTHX_ a,b) #define hv_magic_check S_hv_magic_check #define hv_notallowed(a,b,c,d) S_hv_notallowed(aTHX_ a,b,c,d) #define new_he() S_new_he(aTHX) #define refcounted_he_value(a) S_refcounted_he_value(aTHX_ a) #define save_hek_flags S_save_hek_flags #define share_hek_flags(a,b,c,d) S_share_hek_flags(aTHX_ a,b,c,d) #define unshare_hek_or_pvn(a,b,c,d) S_unshare_hek_or_pvn(aTHX_ a,b,c,d) # endif # if defined(PERL_IN_LOCALE_C) # if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE) #define stdize_locale(a) S_stdize_locale(aTHX_ a) # endif # endif # if defined(PERL_IN_MG_C) #define magic_methcall1(a,b,c,d,e,f) S_magic_methcall1(aTHX_ a,b,c,d,e,f) #define magic_methpack(a,b,c) S_magic_methpack(aTHX_ a,b,c) #define restore_magic(a) S_restore_magic(aTHX_ a) #define save_magic(a,b) S_save_magic(aTHX_ a,b) #define unwind_handler_stack(a) S_unwind_handler_stack(aTHX_ a) # endif # if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) #define translate_substr_offsets(a,b,c,d,e,f,g) Perl_translate_substr_offsets(aTHX_ a,b,c,d,e,f,g) # endif # if defined(PERL_IN_MRO_C) #define mro_clean_isarev(a,b,c,d,e) S_mro_clean_isarev(aTHX_ a,b,c,d,e) #define mro_gather_and_rename(a,b,c,d,e) S_mro_gather_and_rename(aTHX_ a,b,c,d,e) #define mro_get_linear_isa_dfs(a,b) S_mro_get_linear_isa_dfs(aTHX_ a,b) # endif # if defined(PERL_IN_NUMERIC_C) #define mulexp10 S_mulexp10 # endif # if defined(PERL_IN_OP_C) #define aassign_common_vars(a) S_aassign_common_vars(aTHX_ a) #define apply_attrs(a,b,c,d) S_apply_attrs(aTHX_ a,b,c,d) #define apply_attrs_my(a,b,c,d) S_apply_attrs_my(aTHX_ a,b,c,d) #define bad_type_pv(a,b,c,d,e) S_bad_type_pv(aTHX_ a,b,c,d,e) #define bad_type_sv(a,b,c,d,e) S_bad_type_sv(aTHX_ a,b,c,d,e) #define cop_free(a) S_cop_free(aTHX_ a) #define dup_attrlist(a) S_dup_attrlist(aTHX_ a) #define finalize_op(a) S_finalize_op(aTHX_ a) #define find_and_forget_pmops(a) S_find_and_forget_pmops(aTHX_ a) #define fold_constants(a) S_fold_constants(aTHX_ a) #define force_list(a) S_force_list(aTHX_ a) #define gen_constant_list(a) S_gen_constant_list(aTHX_ a) #define gv_ename(a) S_gv_ename(aTHX_ a) #define inplace_aassign(a) S_inplace_aassign(aTHX_ a) #define is_handle_constructor S_is_handle_constructor #define is_list_assignment(a) S_is_list_assignment(aTHX_ a) #define listkids(a) S_listkids(aTHX_ a) #define looks_like_bool(a) S_looks_like_bool(aTHX_ a) #define modkids(a,b) S_modkids(aTHX_ a,b) #define my_kid(a,b,c) S_my_kid(aTHX_ a,b,c) #define newDEFSVOP() S_newDEFSVOP(aTHX) #define newGIVWHENOP(a,b,c,d,e) S_newGIVWHENOP(aTHX_ a,b,c,d,e) #define new_logop(a,b,c,d) S_new_logop(aTHX_ a,b,c,d) #define no_bareword_allowed(a) S_no_bareword_allowed(aTHX_ a) #define no_fh_allowed(a) S_no_fh_allowed(aTHX_ a) #define op_integerize(a) S_op_integerize(aTHX_ a) #define op_std_init(a) S_op_std_init(aTHX_ a) #define opt_scalarhv(a) S_opt_scalarhv(aTHX_ a) #define pmtrans(a,b,c) S_pmtrans(aTHX_ a,b,c) #define process_special_blocks(a,b,c) S_process_special_blocks(aTHX_ a,b,c) #define ref_array_or_hash(a) S_ref_array_or_hash(aTHX_ a) #define refkids(a,b) S_refkids(aTHX_ a,b) #define scalar_mod_type S_scalar_mod_type #define scalarboolean(a) S_scalarboolean(aTHX_ a) #define scalarkids(a) S_scalarkids(aTHX_ a) #define scalarseq(a) S_scalarseq(aTHX_ a) #define search_const(a) S_search_const(aTHX_ a) #define simplify_sort(a) S_simplify_sort(aTHX_ a) #define too_few_arguments_pv(a,b,c) S_too_few_arguments_pv(aTHX_ a,b,c) #define too_few_arguments_sv(a,b,c) S_too_few_arguments_sv(aTHX_ a,b,c) #define too_many_arguments_pv(a,b,c) S_too_many_arguments_pv(aTHX_ a,b,c) #define too_many_arguments_sv(a,b,c) S_too_many_arguments_sv(aTHX_ a,b,c) # endif # if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) #define report_redefined_cv(a,b,c) Perl_report_redefined_cv(aTHX_ a,b,c) # endif # if defined(PERL_IN_PAD_C) #define pad_alloc_name(a,b,c,d) S_pad_alloc_name(aTHX_ a,b,c,d) #define pad_check_dup(a,b,c) S_pad_check_dup(aTHX_ a,b,c) #define pad_findlex(a,b,c,d,e,f,g,h,i) S_pad_findlex(aTHX_ a,b,c,d,e,f,g,h,i) #define pad_reset() S_pad_reset(aTHX) # endif # if defined(PERL_IN_PERL_C) #define find_beginning(a,b) S_find_beginning(aTHX_ a,b) #define forbid_setid(a,b) S_forbid_setid(aTHX_ a,b) #define incpush(a,b,c) S_incpush(aTHX_ a,b,c) #define incpush_use_sep(a,b,c) S_incpush_use_sep(aTHX_ a,b,c) #define init_ids() S_init_ids(aTHX) #define init_interp() S_init_interp(aTHX) #define init_main_stash() S_init_main_stash(aTHX) #define init_perllib() S_init_perllib(aTHX) #define init_postdump_symbols(a,b,c) S_init_postdump_symbols(aTHX_ a,b,c) #define init_predump_symbols() S_init_predump_symbols(aTHX) #define mayberelocate(a,b,c) S_mayberelocate(aTHX_ a,b,c) #define minus_v() S_minus_v(aTHX) #define my_exit_jump() S_my_exit_jump(aTHX) #define nuke_stacks() S_nuke_stacks(aTHX) #define open_script(a,b,c) S_open_script(aTHX_ a,b,c) #define parse_body(a,b) S_parse_body(aTHX_ a,b) #define run_body(a) S_run_body(aTHX_ a) #define usage() S_usage(aTHX) # endif # if defined(PERL_IN_PP_C) #define do_chomp(a,b,c) S_do_chomp(aTHX_ a,b,c) #define do_delete_local() S_do_delete_local(aTHX) #define refto(a) S_refto(aTHX_ a) # endif # if defined(PERL_IN_PP_CTL_C) #define adjust_stack_on_leave(a,b,c,d,e) S_adjust_stack_on_leave(aTHX_ a,b,c,d,e) #define check_type_and_open(a) S_check_type_and_open(aTHX_ a) #define destroy_matcher(a) S_destroy_matcher(aTHX_ a) #define do_smartmatch(a,b,c) S_do_smartmatch(aTHX_ a,b,c) #define docatch(a) S_docatch(aTHX_ a) #define doeval(a,b,c,d,e) S_doeval(aTHX_ a,b,c,d,e) #define dofindlabel(a,b,c,d,e,f) S_dofindlabel(aTHX_ a,b,c,d,e,f) #define doparseform(a) S_doparseform(aTHX_ a) #define dopoptoeval(a) S_dopoptoeval(aTHX_ a) #define dopoptogiven(a) S_dopoptogiven(aTHX_ a) #define dopoptolabel(a,b,c) S_dopoptolabel(aTHX_ a,b,c) #define dopoptoloop(a) S_dopoptoloop(aTHX_ a) #define dopoptosub_at(a,b) S_dopoptosub_at(aTHX_ a,b) #define dopoptowhen(a) S_dopoptowhen(aTHX_ a) #define make_matcher(a) S_make_matcher(aTHX_ a) #define matcher_matches_sv(a,b) S_matcher_matches_sv(aTHX_ a,b) #define num_overflow S_num_overflow #define path_is_absolute S_path_is_absolute #define run_user_filter(a,b,c) S_run_user_filter(aTHX_ a,b,c) #define rxres_free(a) S_rxres_free(aTHX_ a) #define rxres_restore(a,b) S_rxres_restore(aTHX_ a,b) #define save_lines(a,b) S_save_lines(aTHX_ a,b) # endif # if defined(PERL_IN_PP_HOT_C) #define do_oddball(a,b,c) S_do_oddball(aTHX_ a,b,c) #define method_common(a,b) S_method_common(aTHX_ a,b) # endif # if defined(PERL_IN_PP_PACK_C) #define bytes_to_uni S_bytes_to_uni #define div128(a,b) S_div128(aTHX_ a,b) #define first_symbol S_first_symbol #define get_num(a,b) S_get_num(aTHX_ a,b) #define group_end(a,b,c) S_group_end(aTHX_ a,b,c) #define is_an_int(a,b) S_is_an_int(aTHX_ a,b) #define measure_struct(a) S_measure_struct(aTHX_ a) #define mul128(a,b) S_mul128(aTHX_ a,b) #define need_utf8 S_need_utf8 #define next_symbol(a) S_next_symbol(aTHX_ a) #define pack_rec(a,b,c,d) S_pack_rec(aTHX_ a,b,c,d) #define sv_exp_grow(a,b) S_sv_exp_grow(aTHX_ a,b) #define unpack_rec(a,b,c,d,e) S_unpack_rec(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_PP_SORT_C) #define amagic_cmp(a,b) S_amagic_cmp(aTHX_ a,b) #define amagic_cmp_locale(a,b) S_amagic_cmp_locale(aTHX_ a,b) #define amagic_i_ncmp(a,b) S_amagic_i_ncmp(aTHX_ a,b) #define amagic_ncmp(a,b) S_amagic_ncmp(aTHX_ a,b) #define qsortsvu(a,b,c) S_qsortsvu(aTHX_ a,b,c) #define sortcv(a,b) S_sortcv(aTHX_ a,b) #define sortcv_stacked(a,b) S_sortcv_stacked(aTHX_ a,b) #define sortcv_xsub(a,b) S_sortcv_xsub(aTHX_ a,b) #define sv_i_ncmp(a,b) S_sv_i_ncmp(aTHX_ a,b) #define sv_ncmp(a,b) S_sv_ncmp(aTHX_ a,b) # endif # if defined(PERL_IN_PP_SYS_C) #define doform(a,b,c) S_doform(aTHX_ a,b,c) #define space_join_names_mortal(a) S_space_join_names_mortal(aTHX_ a) # endif # if defined(PERL_IN_SCOPE_C) #define save_pushptri32ptr(a,b,c,d) S_save_pushptri32ptr(aTHX_ a,b,c,d) #define save_scalar_at(a,b) S_save_scalar_at(aTHX_ a,b) # endif # if defined(PERL_IN_SV_C) #define F0convert S_F0convert #define anonymise_cv_maybe(a,b) S_anonymise_cv_maybe(aTHX_ a,b) #define assert_uft8_cache_coherent(a,b,c,d) S_assert_uft8_cache_coherent(aTHX_ a,b,c,d) #define curse(a,b) S_curse(aTHX_ a,b) #define expect_number(a) S_expect_number(aTHX_ a) #define find_array_subscript(a,b) S_find_array_subscript(aTHX_ a,b) #define find_hash_subscript(a,b) S_find_hash_subscript(aTHX_ a,b) #define find_uninit_var(a,b,c) S_find_uninit_var(aTHX_ a,b,c) #define glob_2number(a) S_glob_2number(aTHX_ a) #define glob_assign_glob(a,b,c) S_glob_assign_glob(aTHX_ a,b,c) #define glob_assign_ref(a,b) S_glob_assign_ref(aTHX_ a,b) #define more_sv() S_more_sv(aTHX) #define not_a_number(a) S_not_a_number(aTHX_ a) #define ptr_table_find S_ptr_table_find #define sv_2iuv_common(a) S_sv_2iuv_common(aTHX_ a) #define sv_add_arena(a,b,c) S_sv_add_arena(aTHX_ a,b,c) #define sv_pos_b2u_midway(a,b,c,d) S_sv_pos_b2u_midway(aTHX_ a,b,c,d) #define sv_pos_u2b_cached(a,b,c,d,e,f,g) S_sv_pos_u2b_cached(aTHX_ a,b,c,d,e,f,g) #define sv_pos_u2b_forwards S_sv_pos_u2b_forwards #define sv_pos_u2b_midway S_sv_pos_u2b_midway #define sv_unglob(a,b) S_sv_unglob(aTHX_ a,b) #define uiv_2buf S_uiv_2buf #define utf8_mg_len_cache_update(a,b,c) S_utf8_mg_len_cache_update(aTHX_ a,b,c) #define utf8_mg_pos_cache_update(a,b,c,d,e) S_utf8_mg_pos_cache_update(aTHX_ a,b,c,d,e) #define visit(a,b,c) S_visit(aTHX_ a,b,c) # if defined(PERL_OLD_COPY_ON_WRITE) #define sv_release_COW(a,b,c) S_sv_release_COW(aTHX_ a,b,c) # endif # if defined(USE_ITHREADS) #define sv_dup_common(a,b) S_sv_dup_common(aTHX_ a,b) #define sv_dup_inc_multiple(a,b,c,d) S_sv_dup_inc_multiple(aTHX_ a,b,c,d) #define unreferenced_to_tmp_stack(a) S_unreferenced_to_tmp_stack(aTHX_ a) # endif # endif # if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) #define varname(a,b,c,d,e,f) Perl_varname(aTHX_ a,b,c,d,e,f) # endif # if defined(PERL_IN_TOKE_C) #define ao(a) S_ao(aTHX_ a) #define check_uni() S_check_uni(aTHX) #define checkcomma(a,b,c) S_checkcomma(aTHX_ a,b,c) #define deprecate_commaless_var_list() S_deprecate_commaless_var_list(aTHX) #define filter_gets(a,b) S_filter_gets(aTHX_ a,b) #define find_in_my_stash(a,b) S_find_in_my_stash(aTHX_ a,b) #define force_ident(a,b) S_force_ident(aTHX_ a,b) #define force_next(a) S_force_next(aTHX_ a) #define force_strict_version(a) S_force_strict_version(aTHX_ a) #define force_version(a,b) S_force_version(aTHX_ a,b) #define force_word(a,b,c,d,e) S_force_word(aTHX_ a,b,c,d,e) #define incline(a) S_incline(aTHX_ a) #define intuit_method(a,b,c) S_intuit_method(aTHX_ a,b,c) #define intuit_more(a) S_intuit_more(aTHX_ a) #define lop(a,b,c) S_lop(aTHX_ a,b,c) #define missingterm(a) S_missingterm(aTHX_ a) #define no_op(a,b) S_no_op(aTHX_ a,b) #define readpipe_override() S_readpipe_override(aTHX) #define scan_const(a) S_scan_const(aTHX_ a) #define scan_formline(a) S_scan_formline(aTHX_ a) #define scan_heredoc(a) S_scan_heredoc(aTHX_ a) #define scan_ident(a,b,c,d,e) S_scan_ident(aTHX_ a,b,c,d,e) #define scan_inputsymbol(a) S_scan_inputsymbol(aTHX_ a) #define scan_pat(a,b) S_scan_pat(aTHX_ a,b) #define scan_str(a,b,c) S_scan_str(aTHX_ a,b,c) #define scan_subst(a) S_scan_subst(aTHX_ a) #define scan_trans(a) S_scan_trans(aTHX_ a) #define scan_word(a,b,c,d,e) S_scan_word(aTHX_ a,b,c,d,e) #define skipspace(a) S_skipspace(aTHX_ a) #define sublex_done() S_sublex_done(aTHX) #define sublex_push() S_sublex_push(aTHX) #define sublex_start() S_sublex_start(aTHX) #define swallow_bom(a) S_swallow_bom(aTHX_ a) #define tokenize_use(a,b) S_tokenize_use(aTHX_ a,b) #define tokeq(a) S_tokeq(aTHX_ a) #define update_debugger_info(a,b,c) S_update_debugger_info(aTHX_ a,b,c) #define yywarn(a,b) S_yywarn(aTHX_ a,b) # if defined(PERL_MAD) #define curmad(a,b) S_curmad(aTHX_ a,b) #define skipspace0(a) S_skipspace0(aTHX_ a) #define skipspace1(a) S_skipspace1(aTHX_ a) #define skipspace2(a,b) S_skipspace2(aTHX_ a,b) #define start_force(a) S_start_force(aTHX_ a) # endif # endif # if defined(PERL_IN_UNIVERSAL_C) #define isa_lookup(a,b,c,d) S_isa_lookup(aTHX_ a,b,c,d) # endif # if defined(PERL_IN_UTF8_C) #define check_locale_boundary_crossing(a,b,c,d) S_check_locale_boundary_crossing(aTHX_ a,b,c,d) #define is_utf8_char_slow S_is_utf8_char_slow #define is_utf8_common(a,b,c) S_is_utf8_common(aTHX_ a,b,c) #define swatch_get(a,b,c) S_swatch_get(aTHX_ a,b,c) #define to_lower_latin1(a,b,c) S_to_lower_latin1(aTHX_ a,b,c) # endif # if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) #define _to_upper_title_latin1(a,b,c,d) Perl__to_upper_title_latin1(aTHX_ a,b,c,d) # endif # if defined(PERL_IN_UTIL_C) #define ckwarn_common(a) S_ckwarn_common(aTHX_ a) #define closest_cop(a,b) S_closest_cop(aTHX_ a,b) #define invoke_exception_hook(a,b) S_invoke_exception_hook(aTHX_ a,b) #define mess_alloc() S_mess_alloc(aTHX) #define with_queued_errors(a) S_with_queued_errors(aTHX_ a) #define write_no_mem() S_write_no_mem(aTHX) # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) #define mem_log_common S_mem_log_common # endif # endif # if defined(PERL_MAD) #define addmad(a,b,c) Perl_addmad(aTHX_ a,b,c) #define append_madprops(a,b,c) Perl_append_madprops(aTHX_ a,b,c) #define do_op_xmldump(a,b,c) Perl_do_op_xmldump(aTHX_ a,b,c) #define do_pmop_xmldump(a,b,c) Perl_do_pmop_xmldump(aTHX_ a,b,c) #define mad_free(a) Perl_mad_free(aTHX_ a) #define madlex() Perl_madlex(aTHX) #define madparse(a) Perl_madparse(aTHX_ a) #define newMADPROP(a,b,c,d) Perl_newMADPROP(aTHX_ a,b,c,d) #define newMADsv(a,b) Perl_newMADsv(aTHX_ a,b) #define newTOKEN(a,b,c) Perl_newTOKEN(aTHX_ a,b,c) #define op_getmad(a,b,c) Perl_op_getmad(aTHX_ a,b,c) #define op_getmad_weak(a,b,c) Perl_op_getmad_weak(aTHX_ a,b,c) #define op_xmldump(a) Perl_op_xmldump(aTHX_ a) #define package(a) Perl_package(aTHX_ a) #define pad_peg Perl_pad_peg #define pmop_xmldump(a) Perl_pmop_xmldump(aTHX_ a) #define prepend_madprops(a,b,c) Perl_prepend_madprops(aTHX_ a,b,c) #define sv_catxmlpv(a,b,c) Perl_sv_catxmlpv(aTHX_ a,b,c) #define sv_catxmlpvn(a,b,c,d) Perl_sv_catxmlpvn(aTHX_ a,b,c,d) #define sv_catxmlsv(a,b) Perl_sv_catxmlsv(aTHX_ a,b) #define sv_xmlpeek(a) Perl_sv_xmlpeek(aTHX_ a) #define token_free(a) Perl_token_free(aTHX_ a) #define token_getmad(a,b,c) Perl_token_getmad(aTHX_ a,b,c) #define utilize(a,b,c,d,e) Perl_utilize(aTHX_ a,b,c,d,e) #define xmldump_all() Perl_xmldump_all(aTHX) #define xmldump_all_perl(a) Perl_xmldump_all_perl(aTHX_ a) #define xmldump_eval() Perl_xmldump_eval(aTHX) #define xmldump_form(a) Perl_xmldump_form(aTHX_ a) #ifndef PERL_IMPLICIT_CONTEXT #define xmldump_indent Perl_xmldump_indent #endif #define xmldump_packsubs(a) Perl_xmldump_packsubs(aTHX_ a) #define xmldump_packsubs_perl(a,b) Perl_xmldump_packsubs_perl(aTHX_ a,b) #define xmldump_sub(a) Perl_xmldump_sub(aTHX_ a) #define xmldump_sub_perl(a,b) Perl_xmldump_sub_perl(aTHX_ a,b) #define xmldump_vindent(a,b,c,d) Perl_xmldump_vindent(aTHX_ a,b,c,d) # endif # if defined(PERL_NEED_MY_BETOH16) #define my_betoh16 Perl_my_betoh16 # endif # if defined(PERL_NEED_MY_BETOH32) #define my_betoh32 Perl_my_betoh32 # endif # if defined(PERL_NEED_MY_BETOH64) #define my_betoh64 Perl_my_betoh64 # endif # if defined(PERL_NEED_MY_BETOHI) #define my_betohi Perl_my_betohi # endif # if defined(PERL_NEED_MY_BETOHL) #define my_betohl Perl_my_betohl # endif # if defined(PERL_NEED_MY_BETOHS) #define my_betohs Perl_my_betohs # endif # if defined(PERL_NEED_MY_HTOBE16) #define my_htobe16 Perl_my_htobe16 # endif # if defined(PERL_NEED_MY_HTOBE32) #define my_htobe32 Perl_my_htobe32 # endif # if defined(PERL_NEED_MY_HTOBE64) #define my_htobe64 Perl_my_htobe64 # endif # if defined(PERL_NEED_MY_HTOBEI) #define my_htobei Perl_my_htobei # endif # if defined(PERL_NEED_MY_HTOBEL) #define my_htobel Perl_my_htobel # endif # if defined(PERL_NEED_MY_HTOBES) #define my_htobes Perl_my_htobes # endif # if defined(PERL_NEED_MY_HTOLE16) #define my_htole16 Perl_my_htole16 # endif # if defined(PERL_NEED_MY_HTOLE32) #define my_htole32 Perl_my_htole32 # endif # if defined(PERL_NEED_MY_HTOLE64) #define my_htole64 Perl_my_htole64 # endif # if defined(PERL_NEED_MY_HTOLEI) #define my_htolei Perl_my_htolei # endif # if defined(PERL_NEED_MY_HTOLEL) #define my_htolel Perl_my_htolel # endif # if defined(PERL_NEED_MY_HTOLES) #define my_htoles Perl_my_htoles # endif # if defined(PERL_NEED_MY_LETOH16) #define my_letoh16 Perl_my_letoh16 # endif # if defined(PERL_NEED_MY_LETOH32) #define my_letoh32 Perl_my_letoh32 # endif # if defined(PERL_NEED_MY_LETOH64) #define my_letoh64 Perl_my_letoh64 # endif # if defined(PERL_NEED_MY_LETOHI) #define my_letohi Perl_my_letohi # endif # if defined(PERL_NEED_MY_LETOHL) #define my_letohl Perl_my_letohl # endif # if defined(PERL_NEED_MY_LETOHS) #define my_letohs Perl_my_letohs # endif # if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) #define pidgone(a,b) S_pidgone(aTHX_ a,b) # endif # if defined(USE_ITHREADS) #define mro_meta_dup(a,b) Perl_mro_meta_dup(aTHX_ a,b) #define padlist_dup(a,b) Perl_padlist_dup(aTHX_ a,b) # endif # if defined(USE_LOCALE_COLLATE) #define magic_setcollxfrm(a,b) Perl_magic_setcollxfrm(aTHX_ a,b) #define mem_collxfrm(a,b,c) Perl_mem_collxfrm(aTHX_ a,b,c) # endif #endif #endif /* #ifndef PERL_NO_SHORT_NAMES */ /* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to disable them. */ #if !defined(PERL_CORE) # define sv_setptrobj(rv,ptr,name) sv_setref_iv(rv,name,PTR2IV(ptr)) # define sv_setptrref(rv,ptr) sv_setref_iv(rv,NULL,PTR2IV(ptr)) #endif #if !defined(PERL_CORE) && !defined(PERL_NOCOMPAT) /* Compatibility for various misnamed functions. All functions in the API that begin with "perl_" (not "Perl_") take an explicit interpreter context pointer. The following are not like that, but since they had a "perl_" prefix in previous versions, we provide compatibility macros. */ # define perl_atexit(a,b) call_atexit(a,b) # define perl_call_argv(a,b,c) call_argv(a,b,c) # define perl_call_method(a,b) call_method(a,b) # define perl_call_pv(a,b) call_pv(a,b) # define perl_call_sv(a,b) call_sv(a,b) # define perl_eval_pv(a,b) eval_pv(a,b) # define perl_eval_sv(a,b) eval_sv(a,b) # define perl_get_av(a,b) get_av(a,b) # define perl_get_cv(a,b) get_cv(a,b) # define perl_get_hv(a,b) get_hv(a,b) # define perl_get_sv(a,b) get_sv(a,b) # define perl_init_i18nl10n(a) init_i18nl10n(a) # define perl_init_i18nl14n(a) init_i18nl14n(a) # define perl_new_collate(a) new_collate(a) # define perl_new_ctype(a) new_ctype(a) # define perl_new_numeric(a) new_numeric(a) # define perl_require_pv(a) require_pv(a) /* varargs functions can't be handled with CPP macros. :-( This provides a set of compatibility functions that don't take an extra argument but grab the context pointer using the macro dTHX. */ #if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_NO_SHORT_NAMES) # define croak Perl_croak_nocontext # define deb Perl_deb_nocontext # define die Perl_die_nocontext # define form Perl_form_nocontext # define load_module Perl_load_module_nocontext # define mess Perl_mess_nocontext # define newSVpvf Perl_newSVpvf_nocontext # define sv_catpvf Perl_sv_catpvf_nocontext # define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext # define sv_setpvf Perl_sv_setpvf_nocontext # define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext # define warn Perl_warn_nocontext # define warner Perl_warner_nocontext #endif #endif /* !defined(PERL_CORE) && !defined(PERL_NOCOMPAT) */ #if !defined(PERL_IMPLICIT_CONTEXT) /* undefined symbols, point them back at the usual ones */ # define Perl_croak_nocontext Perl_croak # define Perl_deb_nocontext Perl_deb # define Perl_die_nocontext Perl_die # define Perl_form_nocontext Perl_form # define Perl_load_module_nocontext Perl_load_module # define Perl_mess_nocontext Perl_mess # define Perl_newSVpvf_nocontext Perl_newSVpvf # define Perl_sv_catpvf_nocontext Perl_sv_catpvf # define Perl_sv_catpvf_mg_nocontext Perl_sv_catpvf_mg # define Perl_sv_setpvf_nocontext Perl_sv_setpvf # define Perl_sv_setpvf_mg_nocontext Perl_sv_setpvf_mg # define Perl_warn_nocontext Perl_warn # define Perl_warner_nocontext Perl_warner #endif /* ex: set ro: */ PKZ{yossl1_char_class_tab.hnuW+A/* -*- buffer-read-only: t -*- * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! * This file is built by regen/mk_PL_charclass.pl from property definitions * and lib/unicore/CaseFolding.txt. * Any changes made here will be lost! */ /* U+00 NUL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+01 SOH */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+02 STX */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+03 ETX */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+04 EOT */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+05 ENQ */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+06 ACK */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+07 BEL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+08 BS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+09 HT */ _CC_BLANK_A|_CC_BLANK_L1|_CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+0A LF */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+0B VT */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_QUOTEMETA, /* U+0C FF */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+0D CR */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+0E SO */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+0F SI */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+10 DLE */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+11 DC1 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+12 DC2 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+13 DC3 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+14 DC4 */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+15 NAK */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+16 SYN */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+17 ETB */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+18 CAN */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+19 EOM */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1A SUB */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1B ESC */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1C FS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1D GS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1E RS */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+1F US */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+20 SPACE */ _CC_BLANK_A|_CC_BLANK_L1|_CC_CHARNAME_CONT|_CC_PRINT_A|_CC_PRINT_L1|_CC_PSXSPC_A|_CC_PSXSPC_L1|_CC_SPACE_A|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+21 '!' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+22 '"' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+23 '#' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+24 '$' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+25 '%' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+26 '&' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+27 ''' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+28 '(' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+29 ')' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2A '*' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2B '+' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2C ',' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2D '-' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2E '.' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+2F '/' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+30 '0' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+31 '1' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+32 '2' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+33 '3' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+34 '4' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+35 '5' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+36 '6' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+37 '7' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_OCTAL_A|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+38 '8' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+39 '9' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_CHARNAME_CONT|_CC_DIGIT_A|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+3A ':' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+3B ';' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+3C '<' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+3D '=' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+3E '>' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+3F '?' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+40 '@' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+41 'A' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+42 'B' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+43 'C' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+44 'D' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+45 'E' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+46 'F' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+47 'G' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+48 'H' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+49 'I' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4A 'J' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4B 'K' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4C 'L' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4D 'M' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4E 'N' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+4F 'O' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+50 'P' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+51 'Q' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+52 'R' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+53 'S' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+54 'T' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+55 'U' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+56 'V' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+57 'W' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+58 'X' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+59 'Y' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+5A 'Z' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_UPPER_A|_CC_UPPER_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+5B '[' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+5C '\' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+5D ']' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+5E '^' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+5F '_' */ _CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+60 '`' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+61 'a' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+62 'b' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+63 'c' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+64 'd' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+65 'e' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+66 'f' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1|_CC_XDIGIT_A, /* U+67 'g' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+68 'h' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+69 'i' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6A 'j' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6B 'k' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6C 'l' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6D 'm' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6E 'n' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+6F 'o' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+70 'p' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+71 'q' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+72 'r' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+73 's' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+74 't' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+75 'u' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+76 'v' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+77 'w' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+78 'x' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+79 'y' */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+7A 'z' */ _CC_ALNUMC_A|_CC_ALNUMC_L1|_CC_ALPHA_A|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_A|_CC_GRAPH_L1|_CC_IDFIRST_A|_CC_IDFIRST_L1|_CC_LOWER_A|_CC_LOWER_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_WORDCHAR_A|_CC_WORDCHAR_L1, /* U+7B '{' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+7C '|' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+7D '}' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+7E '~' */ _CC_GRAPH_A|_CC_GRAPH_L1|_CC_PRINT_A|_CC_PRINT_L1|_CC_PUNCT_A|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+7F DEL */ _CC_CNTRL_A|_CC_CNTRL_L1|_CC_QUOTEMETA, /* U+80 PAD */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+81 HOP */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+82 BPH */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+83 NBH */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+84 IND */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+85 NEL */ _CC_CNTRL_L1|_CC_PSXSPC_L1|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+86 SSA */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+87 ESA */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+88 HTS */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+89 HTJ */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8A VTS */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8B PLD */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8C PLU */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8D RI */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8E SS2 */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+8F SS3 */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+90 DCS */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+91 PU1 */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+92 PU2 */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+93 STS */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+94 CCH */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+95 MW */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+96 SPA */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+97 EPA */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+98 SOS */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+99 SGC */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9A SCI */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9B CSI */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9C ST */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9D OSC */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9E PM */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+9F APC */ _CC_CNTRL_L1|_CC_QUOTEMETA, /* U+A0 NO-BREAK SPACE */ _CC_BLANK_L1|_CC_CHARNAME_CONT|_CC_PRINT_L1|_CC_PSXSPC_L1|_CC_SPACE_L1|_CC_QUOTEMETA, /* U+A1 INVERTED EXCLAMATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+A2 CENT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+A3 POUND SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+A4 CURRENCY SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+A5 YEN SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+A6 BROKEN BAR */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+A7 SECTION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+A8 DIAERESIS */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+A9 COPYRIGHT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+AA FEMININE ORDINAL INDICATOR */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+AC NOT SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+AD SOFT HYPHEN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+AE REGISTERED SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+AF MACRON */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+B0 DEGREE SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+B1 PLUS-MINUS SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+B2 SUPERSCRIPT TWO */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+B3 SUPERSCRIPT THREE */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+B4 ACUTE ACCENT */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+B5 MICRO SIGN */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+B6 PILCROW SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+B7 MIDDLE DOT */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1, /* U+B8 CEDILLA */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+B9 SUPERSCRIPT ONE */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+BA MASCULINE ORDINAL INDICATOR */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+BC VULGAR FRACTION ONE QUARTER */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+BD VULGAR FRACTION ONE HALF */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+BE VULGAR FRACTION THREE QUARTERS */ _CC_GRAPH_L1|_CC_PRINT_L1, /* U+BF INVERTED QUESTION MARK */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_PUNCT_L1|_CC_QUOTEMETA, /* U+C0 A WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C1 A WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C2 A WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C3 A WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C4 A WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C5 A WITH RING ABOVE */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C6 AE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C7 C WITH CEDILLA */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C8 E WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+C9 E WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CA E WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CB E WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CC I WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CD I WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CE I WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+CF I WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D0 ETH */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D1 N WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D2 O WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D3 O WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D4 O WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D5 O WITH TILDE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D6 O WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D7 MULTIPLICATION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+D8 O WITH STROKE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+D9 U WITH GRAVE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DA U WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DB U WITH CIRCUMFLEX */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DC U WITH DIAERESIS */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DD Y WITH ACUTE */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DE THORN */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_PRINT_L1|_CC_UPPER_L1|_CC_WORDCHAR_L1, /* U+DF sharp s */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E0 a with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E1 a with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E2 a with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E3 a with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E4 a with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E5 a with ring above */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E6 ae */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E7 c with cedilla */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E8 e with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+E9 e with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+EA e with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+EB e with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+EC i with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+ED i with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+EE i with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+EF i with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F0 eth */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F1 n with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F2 o with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F3 o with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F4 o with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F5 o with tilde */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F6 o with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F7 DIVISION SIGN */ _CC_GRAPH_L1|_CC_PRINT_L1|_CC_QUOTEMETA, /* U+F8 o with stroke */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+F9 u with grave */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FA u with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FB u with circumflex */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FC u with diaeresis */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FD y with acute */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FE thorn */ _CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* U+FF y with diaeresis */ _CC_NONLATIN1_FOLD|_CC_ALNUMC_L1|_CC_ALPHA_L1|_CC_CHARNAME_CONT|_CC_GRAPH_L1|_CC_IDFIRST_L1|_CC_LOWER_L1|_CC_PRINT_L1|_CC_WORDCHAR_L1, /* ex: set ro: */ PKZuUUXSUB.hnuW+APKZ"r IUhandy.hnuW+APKZMa )iperlsys.hnuW+APKZ~Lperl.hnuW+APKZ$ll cintrpvar.hnuW+APKZbform.hnuW+APKZl&&Oscope.hnuW+APKZ6&6&$charclass_invlists.hnuW+APKZVp#c#cJutf8.hnuW+APKZ{% unixish.hnuW+APKZ' overload.hnuW+APKZs}t.{.{8regcharclass.hnuW+APKZ5BGperly.hnuW+APKZЊ3^parser.hnuW+APKZd֔$$ Itmg_vtable.hnuW+APKZ[8util.hnuW+APKZk7 7 #opnames.hnuW+APKZG perlsfio.hnuW+APKZlSLSL \embedvar.hnuW+APKZBB uconfig.hnuW+APKZ? Z fakethr.hnuW+APKZ+44 b perliol.hnuW+APKZ\\ — perlapi.hnuW+APKZy~ ~ W proto.hnuW+APKZÁ:͸͸ opcode.hnuW+APKZsEXTERN.hnuW+APKZ \zwarnings.hnuW+APKZI=33pad.hnuW+APKZU^;?!! ξperlvars.hnuW+APKZl-perldtrace.hnuW+APKZ2<< -mydtrace.hnuW+APKZrr-regexp.hnuW+APKZQ.time64.hnuW+APKZY`!!V.sv.hnuW+APKZ$tx/cop.hnuW+APKZ& 0regnodes.hnuW+APKZ*Yw 0metaconfig.hnuW+APKZ $ g0feature.hnuW+APKZ(NNe0op_reg_common.hnuW+APKZz@ee 0git_version.hnuW+APKZLӲJJ0op.hnuW+APKZT+T+V1perlio.hnuW+APKZL0DD 1utfebcdic.hnuW+APKZlz z  2nostdio.hnuW+APKZ