Initial Windows agent repository
This commit is contained in:
commit
a0db0c2e5b
10589 changed files with 3844063 additions and 0 deletions
58
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/EXTERN.h
Normal file
58
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/EXTERN.h
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
/* 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(WIN32) && !defined(PERL_STATIC_SYMS)
|
||||
/* miniperl should not export anything */
|
||||
# if defined(PERL_IS_MINIPERL)
|
||||
# define EXT extern
|
||||
# define dEXT
|
||||
# define EXTCONST extern const
|
||||
# define dEXTCONST const
|
||||
# elif defined(PERLDLL)
|
||||
# define EXT EXTERN_C __declspec(dllexport)
|
||||
# define dEXT
|
||||
# define EXTCONST EXTERN_C __declspec(dllexport) const
|
||||
# define dEXTCONST const
|
||||
# else
|
||||
# define EXT EXTERN_C __declspec(dllimport)
|
||||
# define dEXT
|
||||
# define EXTCONST EXTERN_C __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
|
||||
|
||||
#undef INIT
|
||||
#define INIT(...)
|
||||
|
||||
#undef DOINIT
|
||||
51
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/INTERN.h
Normal file
51
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/INTERN.h
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/* 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(WIN32) && defined(__MINGW32__) && ! defined(PERL_IS_MINIPERL))
|
||||
# ifdef __cplusplus
|
||||
# define EXT __declspec(dllexport)
|
||||
# define dEXT
|
||||
# define EXTCONST __declspec(dllexport) extern const
|
||||
# define dEXTCONST const
|
||||
# else
|
||||
# define EXT __declspec(dllexport)
|
||||
# define dEXT
|
||||
# define EXTCONST __declspec(dllexport) const
|
||||
# define dEXTCONST const
|
||||
# endif
|
||||
# else
|
||||
# ifdef __cplusplus
|
||||
# define EXT
|
||||
# define dEXT
|
||||
# define EXTCONST EXTERN_C const
|
||||
# define dEXTCONST const
|
||||
# else
|
||||
# define EXT
|
||||
# define dEXT
|
||||
# define EXTCONST const
|
||||
# define dEXTCONST const
|
||||
# endif
|
||||
# endif
|
||||
|
||||
#undef INIT
|
||||
#define INIT(...) = __VA_ARGS__
|
||||
|
||||
#define DOINIT
|
||||
676
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/XSUB.h
Normal file
676
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/XSUB.h
Normal file
|
|
@ -0,0 +1,676 @@
|
|||
/* 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 PERL_XSUB_H_
|
||||
#define PERL_XSUB_H_ 1
|
||||
|
||||
/* first, some documentation for xsubpp-generated items */
|
||||
|
||||
/*
|
||||
=for apidoc_section $XS
|
||||
|
||||
F<xsubpp> compiles XS code into C. See L<perlutil/xsubpp>.
|
||||
|
||||
=for comment
|
||||
Some variables below are flagged with 'u' because Devel::PPPort can't currently
|
||||
readily test them as they spring into existence by compiling with xsubpp.
|
||||
|
||||
=for apidoc Amnu|char*|CLASS
|
||||
Variable which is setup by C<xsubpp> to indicate the
|
||||
class name for a C++ XS constructor. This is always a C<char*>. See
|
||||
C<L</THIS>>.
|
||||
|
||||
=for apidoc Amnu|type|RETVAL
|
||||
Variable which is setup by C<xsubpp> to hold the return value for an
|
||||
XSUB. This is always the proper type for the XSUB. See
|
||||
L<perlxs/"The RETVAL Variable">.
|
||||
|
||||
=for apidoc Amnu|type|THIS
|
||||
Variable which is setup by C<xsubpp> to designate the object in a C++
|
||||
XSUB. This is always the proper type for the C++ object. See C<L</CLASS>> and
|
||||
L<perlxs/"Using XS With C++">.
|
||||
|
||||
=for apidoc Amn|Stack_off_t|ax
|
||||
Variable which is setup by C<xsubpp> to indicate the stack base offset,
|
||||
used by the C<ST>, C<XSprePUSH> and C<XSRETURN> macros. The C<dMARK> macro
|
||||
must be called prior to setup the C<MARK> variable.
|
||||
|
||||
=for apidoc Amn|Stack_off_t|items
|
||||
Variable which is setup by C<xsubpp> to indicate the number of
|
||||
items on the stack. See L<perlxs/"Variable-length Parameter Lists">.
|
||||
|
||||
=for apidoc Amn|I32|ix
|
||||
Variable which is setup by C<xsubpp> to indicate which of an
|
||||
XSUB's aliases was used to invoke it. See L<perlxs/"The ALIAS: Keyword">.
|
||||
|
||||
=for apidoc Am|SV*|ST|int ix
|
||||
Used to access elements on the XSUB's stack.
|
||||
|
||||
=for apidoc Ay||XS|name
|
||||
Macro to declare an XSUB and its C parameter list. This is handled by
|
||||
C<xsubpp>. It is the same as using the more explicit C<XS_EXTERNAL> macro; the
|
||||
latter is preferred.
|
||||
|
||||
=for apidoc Ayu||XS_INTERNAL|name
|
||||
Macro to declare an XSUB and its C parameter list without exporting the symbols.
|
||||
This is handled by C<xsubpp> and generally preferable over exporting the XSUB
|
||||
symbols unnecessarily.
|
||||
|
||||
=for comment
|
||||
XS_INTERNAL marked 'u' because declaring a function static within our test
|
||||
function doesn't work
|
||||
|
||||
=for apidoc Ay||XS_EXTERNAL|name
|
||||
Macro to declare an XSUB and its C parameter list explicitly exporting the symbols.
|
||||
|
||||
=for apidoc Ay||XSPROTO|name
|
||||
Macro used by C<L</XS_INTERNAL>> and C<L</XS_EXTERNAL>> to declare a function
|
||||
prototype. You probably shouldn't be using this directly yourself.
|
||||
|
||||
=for apidoc Amn;||dAX
|
||||
Sets up the C<ax> variable.
|
||||
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
|
||||
|
||||
=for apidoc Amn;||dAXMARK
|
||||
Sets up the C<ax> variable and stack marker variable C<mark>.
|
||||
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
|
||||
|
||||
=for apidoc Amn;||dITEMS
|
||||
Sets up the C<items> variable.
|
||||
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
|
||||
|
||||
=for apidoc Amn;||dXSARGS
|
||||
Sets up stack and mark pointers for an XSUB, calling C<dSP> and C<dMARK>.
|
||||
Sets up the C<ax> and C<items> variables by calling C<dAX> and C<dITEMS>.
|
||||
This is usually handled automatically by C<xsubpp>.
|
||||
|
||||
=for apidoc Amn;||dXSI32
|
||||
Sets up the C<ix> variable for an XSUB which has aliases. This is usually
|
||||
handled automatically by C<xsubpp>.
|
||||
|
||||
=for apidoc Amn;||dUNDERBAR
|
||||
Sets up any variable needed by the C<UNDERBAR> macro. It used to define
|
||||
C<padoff_du>, but it is currently a noop. However, it is strongly advised
|
||||
to still use it for ensuring past and future compatibility.
|
||||
|
||||
=for apidoc AmnU||UNDERBAR
|
||||
The SV* corresponding to the C<$_> variable. Works even if there
|
||||
is a lexical C<$_> in scope.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#ifndef PERL_UNUSED_ARG
|
||||
# define PERL_UNUSED_ARG(x) ((void)sizeof(x))
|
||||
#endif
|
||||
#ifndef PERL_UNUSED_VAR
|
||||
# define PERL_UNUSED_VAR(x) ((void)sizeof(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 __attribute__unused__)
|
||||
|
||||
#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)
|
||||
#elif defined(__cplusplus)
|
||||
# define XS_EXTERNAL(name) extern "C" XSPROTO(name)
|
||||
# define XS_INTERNAL(name) static XSPROTO(name)
|
||||
#elif defined(HASATTRIBUTE_UNUSED)
|
||||
# define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
|
||||
# define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
|
||||
#else
|
||||
# define XS_EXTERNAL(name) XSPROTO(name)
|
||||
# define XS_INTERNAL(name) STATIC XSPROTO(name)
|
||||
#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 Stack_off_t ax = (Stack_off_t)(MARK - PL_stack_base + 1)
|
||||
|
||||
#define dAXMARK \
|
||||
Stack_off_t ax = POPMARK; \
|
||||
SV **mark = PL_stack_base + ax++
|
||||
|
||||
#define dITEMS Stack_off_t items = (Stack_off_t)(SP - MARK)
|
||||
|
||||
#define dXSARGS \
|
||||
dSP; dAXMARK; dITEMS
|
||||
/* These 3 macros are replacements for dXSARGS macro only in bootstrap.
|
||||
They factor out common code in every BOOT XSUB. Computation of vars mark
|
||||
and items will optimize away in most BOOT functions. Var ax can never be
|
||||
optimized away since BOOT must return &PL_sv_yes by default from xsubpp.
|
||||
Note these macros are not drop in replacements for dXSARGS since they set
|
||||
PL_xsubfilename. */
|
||||
#define dXSBOOTARGSXSAPIVERCHK \
|
||||
Stack_off_t ax = XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK; \
|
||||
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
|
||||
#define dXSBOOTARGSAPIVERCHK \
|
||||
Stack_off_t ax = XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK; \
|
||||
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
|
||||
/* dXSBOOTARGSNOVERCHK has no API in xsubpp to choose it so do
|
||||
#undef dXSBOOTARGSXSAPIVERCHK
|
||||
#define dXSBOOTARGSXSAPIVERCHK dXSBOOTARGSNOVERCHK */
|
||||
#define dXSBOOTARGSNOVERCHK \
|
||||
Stack_off_t ax = XS_SETXSUBFN_POPMARK; \
|
||||
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
|
||||
|
||||
#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. */
|
||||
|
||||
/*
|
||||
=for apidoc_section $stack
|
||||
|
||||
=for apidoc Am|void|XST_mIV|int pos|IV iv
|
||||
Place an integer into the specified position C<pos> 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<pos> 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<pos> on the stack.
|
||||
The value is stored in a new mortal SV.
|
||||
|
||||
=for apidoc Am|void|XST_mUV|int pos|UV uv
|
||||
Place an unsigned integer into the specified position C<pos> 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<pos> on the
|
||||
stack.
|
||||
|
||||
=for apidoc Am|void|XST_mYES|int pos
|
||||
Place C<&PL_sv_yes> into the specified position C<pos> on the
|
||||
stack.
|
||||
|
||||
=for apidoc Am|void|XST_mUNDEF|int pos
|
||||
Place C<&PL_sv_undef> into the specified position C<pos> 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<xsubpp>.
|
||||
|
||||
=for apidoc Am|void|XSRETURN_IV|IV iv
|
||||
Return an integer from an XSUB immediately. Uses C<XST_mIV>.
|
||||
|
||||
=for apidoc Am|void|XSRETURN_UV|IV uv
|
||||
Return an integer from an XSUB immediately. Uses C<XST_mUV>.
|
||||
|
||||
=for apidoc Am|void|XSRETURN_NV|NV nv
|
||||
Return a double from an XSUB immediately. Uses C<XST_mNV>.
|
||||
|
||||
=for apidoc Am|void|XSRETURN_PV|char* str
|
||||
Return a copy of a string from an XSUB immediately. Uses C<XST_mPV>.
|
||||
|
||||
=for apidoc Amn;||XSRETURN_NO
|
||||
Return C<&PL_sv_no> from an XSUB immediately. Uses C<XST_mNO>.
|
||||
|
||||
=for apidoc Amn;||XSRETURN_YES
|
||||
Return C<&PL_sv_yes> from an XSUB immediately. Uses C<XST_mYES>.
|
||||
|
||||
=for apidoc Amn;||XSRETURN_UNDEF
|
||||
Return C<&PL_sv_undef> from an XSUB immediately. Uses C<XST_mUNDEF>.
|
||||
|
||||
=for apidoc Amn;||XSRETURN_EMPTY
|
||||
Return an empty list from an XSUB immediately.
|
||||
|
||||
=for apidoc AmU||newXSproto|char* name|XSUBADDR_t f|char* filename|const char *proto
|
||||
Used by C<xsubpp> to hook up XSUBs as Perl subs. Adds Perl prototypes to
|
||||
the subs.
|
||||
|
||||
=for apidoc AmnU||XS_VERSION
|
||||
The version identifier for an XS module. This is usually
|
||||
handled automatically by C<ExtUtils::MakeMaker>. See
|
||||
C<L</XS_VERSION_BOOTCHECK>>.
|
||||
|
||||
=for apidoc Amn;||XS_VERSION_BOOTCHECK
|
||||
Macro to verify that a PM module's C<$VERSION> variable matches the XS
|
||||
module's C<XS_VERSION> variable. This is usually handled automatically by
|
||||
C<xsubpp>. See L<perlxs/"The VERSIONCHECK: Keyword">.
|
||||
|
||||
=for apidoc Amn;||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.
|
||||
|
||||
=for apidoc_section $exceptions
|
||||
|
||||
=for apidoc Amn;||dXCPT
|
||||
Set up necessary local variables for exception handling.
|
||||
See L<perlguts/"Exception Handling">.
|
||||
|
||||
=for apidoc AmnU||XCPT_TRY_START
|
||||
Starts a try block. See L<perlguts/"Exception Handling">.
|
||||
|
||||
=for apidoc AmnU||XCPT_TRY_END
|
||||
Ends a try block. See L<perlguts/"Exception Handling">.
|
||||
|
||||
=for apidoc AmnU||XCPT_CATCH
|
||||
Introduces a catch block. See L<perlguts/"Exception Handling">.
|
||||
|
||||
=for apidoc Amn;||XCPT_RETHROW
|
||||
Rethrows a previously caught exception. See L<perlguts/"Exception Handling">.
|
||||
|
||||
=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); \
|
||||
assert(tmpXSoff >= 0);\
|
||||
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_handshake(HS_KEY(FALSE, FALSE, "", XS_VERSION), HS_CXT, __FILE__, \
|
||||
items, ax, XS_VERSION)
|
||||
#else
|
||||
# define XS_VERSION_BOOTCHECK
|
||||
#endif
|
||||
|
||||
#define XS_APIVERSION_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(FALSE, FALSE, "v" PERL_API_VERSION_STRING, ""), \
|
||||
HS_CXT, __FILE__, items, ax, "v" PERL_API_VERSION_STRING)
|
||||
/* public API, this is a combination of XS_VERSION_BOOTCHECK and
|
||||
XS_APIVERSION_BOOTCHECK in 1, and is backportable */
|
||||
#ifdef XS_VERSION
|
||||
# define XS_BOTHVERSION_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(FALSE, FALSE, "v" PERL_API_VERSION_STRING, XS_VERSION), \
|
||||
HS_CXT, __FILE__, items, ax, "v" PERL_API_VERSION_STRING, XS_VERSION)
|
||||
#else
|
||||
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
|
||||
# define XS_BOTHVERSION_BOOTCHECK XS_APIVERSION_BOOTCHECK
|
||||
#endif
|
||||
|
||||
/* private API */
|
||||
#define XS_APIVERSION_POPMARK_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(FALSE, TRUE, "v" PERL_API_VERSION_STRING, ""), \
|
||||
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING)
|
||||
#ifdef XS_VERSION
|
||||
# define XS_BOTHVERSION_POPMARK_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(FALSE, TRUE, "v" PERL_API_VERSION_STRING, XS_VERSION), \
|
||||
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING, XS_VERSION)
|
||||
#else
|
||||
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
|
||||
# define XS_BOTHVERSION_POPMARK_BOOTCHECK XS_APIVERSION_POPMARK_BOOTCHECK
|
||||
#endif
|
||||
|
||||
#define XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "v" PERL_API_VERSION_STRING, ""), \
|
||||
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING)
|
||||
#ifdef XS_VERSION
|
||||
# define XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK \
|
||||
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "v" PERL_API_VERSION_STRING, XS_VERSION),\
|
||||
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING, XS_VERSION)
|
||||
#else
|
||||
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
|
||||
# define XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK
|
||||
#endif
|
||||
|
||||
/* For a normal bootstrap without API or XS version checking.
|
||||
Useful for static XS modules or debugging/testing scenarios.
|
||||
If this macro gets heavily used in the future, it should separated into
|
||||
a separate function independent of Perl_xs_handshake for efficiency */
|
||||
#define XS_SETXSUBFN_POPMARK \
|
||||
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "", "") | HSf_NOCHK, HS_CXT, __FILE__)
|
||||
|
||||
#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_NN(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
|
||||
|
||||
#if defined(MULTIPLICITY) && !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
|
||||
# undef closedir
|
||||
# undef opendir
|
||||
# undef stdin
|
||||
# undef stdout
|
||||
# undef stderr
|
||||
# undef feof
|
||||
# undef ferror
|
||||
# undef fgetpos
|
||||
# undef ioctl
|
||||
# undef getlogin
|
||||
# undef getc
|
||||
# undef ungetc
|
||||
# undef fileno
|
||||
|
||||
/* 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 calloc PerlMem_calloc
|
||||
# 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 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
|
||||
|
||||
# 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 /* NO_XSLOCKS */
|
||||
#endif /* PERL_IMPLICIT_SYS && !PERL_CORE */
|
||||
|
||||
#endif /* PERL_XSUB_H_ */ /* include guard */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
225
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/av.h
Normal file
225
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/av.h
Normal file
|
|
@ -0,0 +1,225 @@
|
|||
/* av.h
|
||||
*
|
||||
* Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000,
|
||||
* 2001, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
struct xpvav {
|
||||
HV* xmg_stash; /* class package */
|
||||
union _xmgu xmg_u;
|
||||
SSize_t xav_fill; /* Index of last element present */
|
||||
SSize_t xav_max; /* max index for which array has space */
|
||||
SV** xav_alloc; /* pointer to beginning of C array of SVs */
|
||||
};
|
||||
|
||||
/* SV* xav_arylen; */
|
||||
|
||||
/* SVpav_REAL is set for all AVs whose xav_array contents are refcounted
|
||||
* and initialized such that any element can be retrieved as a SV*.
|
||||
* Such AVs may be referred to as "real" AVs. Examples include regular
|
||||
* perl arrays, tiedarrays (since v5.16), and padlist AVs.
|
||||
*
|
||||
* Some things do not set SVpav_REAL, to indicate that they are cheating
|
||||
* (for efficiency) by not refcounting the AV's contents or ensuring that
|
||||
* all elements are safe for arbitrary access. This type of AV may be
|
||||
* referred to as "fake" AVs. Examples include "@_" (unless tied), the
|
||||
* scratchpad list, and the backrefs list on an object or stash.
|
||||
*
|
||||
* SVpav_REIFY is only meaningful on such "fake" AVs (i.e. where SVpav_REAL
|
||||
* is not set). It indicates that the fake AV is capable of becoming
|
||||
* real if the array needs to be modified in some way. Functions that
|
||||
* modify fake AVs check both flags to call av_reify() as appropriate.
|
||||
*
|
||||
* av_reify() transforms a fake AV into a real one through two actions.
|
||||
* Allocated but unpopulated elements are initialized to make them safe for
|
||||
* arbitrary retrieval and the reference counts of populated elements are
|
||||
* incremented.
|
||||
*
|
||||
* Note that the Perl stack has neither flag set. (Thus,
|
||||
* items that go on the stack are never refcounted.)
|
||||
*
|
||||
* These internal details are subject to change any time. AV
|
||||
* manipulations external to perl should not care about any of this.
|
||||
* GSAR 1999-09-10
|
||||
*/
|
||||
|
||||
/*
|
||||
=for apidoc ADmnU||Nullav
|
||||
Null AV pointer.
|
||||
|
||||
(deprecated - use C<(AV *)NULL> instead)
|
||||
|
||||
=for apidoc Am|SSize_t|AvFILL|AV* av
|
||||
Same as C<L</av_top_index>> or C<L</av_tindex>>.
|
||||
|
||||
=for apidoc Cm|SSize_t|AvFILLp|AV* av
|
||||
|
||||
If the array C<av> is empty, this returns -1; otherwise it returns the maximum
|
||||
value of the indices of all the array elements which are currently defined in
|
||||
C<av>. It does not handle magic, hence the C<p> private indication in its name.
|
||||
|
||||
=for apidoc Am|SV**|AvARRAY|AV* av
|
||||
Returns a pointer to the AV's internal SV* array.
|
||||
|
||||
This is useful for doing pointer arithmetic on the array.
|
||||
If all you need is to look up an array element, then prefer C<av_fetch>.
|
||||
|
||||
=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 av_top_index(av) AvFILL(av)
|
||||
#define av_tindex(av) av_top_index(av)
|
||||
|
||||
/* Note that it doesn't make sense to do this:
|
||||
* SvGETMAGIC(av); IV x = av_tindex_nomg(av);
|
||||
*/
|
||||
# define av_top_index_skip_len_mg(av) \
|
||||
(__ASSERT_(SvTYPE(av) == SVt_PVAV) AvFILLp(av))
|
||||
# define av_tindex_skip_len_mg(av) av_top_index_skip_len_mg(av)
|
||||
|
||||
#define NEGATIVE_INDICES_VAR "NEGATIVE_INDICES"
|
||||
|
||||
/*
|
||||
|
||||
Note that there are both real and fake AVs; see the beginning of this file and
|
||||
'av.c'
|
||||
|
||||
=for apidoc newAV
|
||||
=for apidoc_item newAV_mortal
|
||||
=for apidoc_item newAV_alloc_x
|
||||
=for apidoc_item newAV_alloc_xz
|
||||
|
||||
These all create a new AV, setting the reference count to 1. If you also know
|
||||
the initial elements of the array with, see L</C<av_make>>.
|
||||
|
||||
As background, an array consists of three things:
|
||||
|
||||
=over
|
||||
|
||||
=item 1.
|
||||
|
||||
A data structure containing information about the array as a whole, such as its
|
||||
size and reference count.
|
||||
|
||||
=item 2.
|
||||
|
||||
A C language array of pointers to the individual elements. These are treated
|
||||
as pointers to SVs, so all must be castable to SV*.
|
||||
|
||||
=item 3.
|
||||
|
||||
The individual elements themselves. These could be, for instance, SVs and/or
|
||||
AVs and/or HVs, etc.
|
||||
|
||||
=back
|
||||
|
||||
An empty array need only have the first data structure, and all these functions
|
||||
create that. They differ in what else they do, as follows:
|
||||
|
||||
=over
|
||||
|
||||
=item C<newAV> form
|
||||
|
||||
=for comment
|
||||
'form' above and below is because otherwise have two =items with the same name,
|
||||
can't link to them.
|
||||
|
||||
This does nothing beyond creating the whole-array data structure.
|
||||
The Perl equivalent is approximately S<C<my @array;>>
|
||||
|
||||
This is useful when the minimum size of the array could be zero (perhaps there
|
||||
are likely code paths that will entirely skip using it).
|
||||
|
||||
If the array does get used, the pointers data structure will need to be
|
||||
allocated at that time. This will end up being done by L</av_extend>>,
|
||||
either explicitly:
|
||||
|
||||
av_extend(av, len);
|
||||
|
||||
or implicitly when the first element is stored:
|
||||
|
||||
(void)av_store(av, 0, sv);
|
||||
|
||||
Unused array elements are typically initialized by C<av_extend>.
|
||||
|
||||
=item C<newAV_mortal> form
|
||||
|
||||
This also creates the whole-array data structure, but also mortalises it.
|
||||
(That is to say, a reference to the AV is added to the C<temps> stack.)
|
||||
|
||||
=item C<newAV_alloc_x> form
|
||||
|
||||
This effectively does a C<newAV> followed by also allocating (uninitialized)
|
||||
space for the pointers array. This is used when you know ahead of time the
|
||||
likely minimum size of the array. It is more efficient to do this than doing a
|
||||
plain C<newAV> followed by an C<av_extend>.
|
||||
|
||||
Of course the array can be extended later should it become necessary.
|
||||
|
||||
C<size> must be at least 1.
|
||||
|
||||
=item C<newAV_alloc_xz> form
|
||||
|
||||
This is C<newAV_alloc_x>, but initializes each pointer in it to NULL. This
|
||||
gives added safety to guard against them being read before being set.
|
||||
|
||||
C<size> must be at least 1.
|
||||
|
||||
=back
|
||||
|
||||
The following examples all result in an array that can fit four elements
|
||||
(indexes 0 .. 3):
|
||||
|
||||
AV *av = newAV();
|
||||
av_extend(av, 3);
|
||||
|
||||
AV *av = newAV_alloc_x(4);
|
||||
|
||||
AV *av = newAV_alloc_xz(4);
|
||||
|
||||
In contrast, the following examples allocate an array that is only guaranteed
|
||||
to fit one element without extending:
|
||||
|
||||
AV *av = newAV_alloc_x(1);
|
||||
AV *av = newAV_alloc_xz(1);
|
||||
|
||||
=cut
|
||||
|
||||
*/
|
||||
|
||||
#define newAV() MUTABLE_AV(newSV_type(SVt_PVAV))
|
||||
#define newAV_mortal() MUTABLE_AV(newSV_type_mortal(SVt_PVAV))
|
||||
#define newAV_alloc_x(size) av_new_alloc(size,0)
|
||||
#define newAV_alloc_xz(size) av_new_alloc(size,1)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
24
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/bitcount.h
Normal file
24
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/bitcount.h
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
/* bitcount.h:
|
||||
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
|
||||
*
|
||||
* These values will populate PL_bitcount[]:
|
||||
* this is a count of bits for each U8 value 0..255
|
||||
*/
|
||||
{
|
||||
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
|
||||
}
|
||||
436086
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/charclass_invlists.h
Normal file
436086
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/charclass_invlists.h
Normal file
File diff suppressed because it is too large
Load diff
5408
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/config.h
Normal file
5408
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/config.h
Normal file
File diff suppressed because it is too large
Load diff
1445
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cop.h
Normal file
1445
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cop.h
Normal file
File diff suppressed because it is too large
Load diff
373
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cv.h
Normal file
373
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cv.h
Normal file
|
|
@ -0,0 +1,373 @@
|
|||
/* 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;
|
||||
};
|
||||
|
||||
/*
|
||||
=for apidoc Ayh||CV
|
||||
|
||||
=for apidoc ADmnU||Nullcv
|
||||
Null CV pointer.
|
||||
|
||||
(deprecated - use C<(CV *)NULL> instead)
|
||||
|
||||
=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<perlguts>.
|
||||
|
||||
This also has a special use with XS AUTOLOAD subs.
|
||||
See L<perlguts/Autoloading with XSUBs>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#ifndef PERL_CORE
|
||||
# define Nullcv Null(CV*)
|
||||
#endif
|
||||
|
||||
#define CvSTASH(sv) (MUTABLE_HV(((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) Perl_CvGV(aTHX_ (CV *)(sv))
|
||||
#define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv)
|
||||
#define CvHASGV(cv) cBOOL(SvANY(cv)->xcv_gv_u.xcv_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)))
|
||||
#define CvDEPTH(sv) (*Perl_CvDEPTH((const CV *)sv))
|
||||
/* For use when you only have a XPVCV*, not a real CV*.
|
||||
Must be assert protected as in Perl_CvDEPTH before use. */
|
||||
#define CvDEPTHunsafe(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth
|
||||
|
||||
/* these CvPADLIST/CvRESERVED asserts can be reverted one day, once stabilized */
|
||||
#define CvPADLIST(sv) (*(assert_(!CvISXSUB((CV*)(sv))) \
|
||||
&(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist)))
|
||||
/* CvPADLIST_set is not public API, it can be removed one day, once stabilized */
|
||||
#ifdef DEBUGGING
|
||||
# define CvPADLIST_set(sv, padlist) Perl_set_padlist((CV*)sv, padlist)
|
||||
#else
|
||||
# define CvPADLIST_set(sv, padlist) (CvPADLIST(sv) = (padlist))
|
||||
#endif
|
||||
#define CvHSCXT(sv) *(assert_(CvISXSUB((CV*)(sv))) \
|
||||
&(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_hscxt))
|
||||
#ifdef DEBUGGING
|
||||
# if PTRSIZE == 8
|
||||
# define PoisonPADLIST(sv) \
|
||||
(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)UINT64_C(0xEFEFEFEFEFEFEFEF))
|
||||
# elif PTRSIZE == 4
|
||||
# define PoisonPADLIST(sv) \
|
||||
(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)0xEFEFEFEF)
|
||||
# else
|
||||
# error unknown pointer size
|
||||
# endif
|
||||
#else
|
||||
# define PoisonPADLIST(sv) NOOP
|
||||
#endif
|
||||
|
||||
#define CvOUTSIDE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside
|
||||
#define CvOUTSIDE_SEQ(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside_seq
|
||||
#define CvFLAGS(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_flags
|
||||
|
||||
/* 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 \
|
||||
)
|
||||
|
||||
/* CV has the `:method` attribute. This used to be called CVf_METHOD but is
|
||||
* renamed to avoid collision with CVf_IsMETHOD */
|
||||
#define CVf_NOWARN_AMBIGUOUS 0x0001
|
||||
|
||||
#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 */
|
||||
#if defined(PERL_CORE) || defined(PERL_EXT)
|
||||
# define CVf_SLABBED 0x0800 /* Holds refcount on op slab */
|
||||
#endif
|
||||
#define CVf_DYNFILE 0x1000 /* The filename is malloced */
|
||||
#define CVf_AUTOLOAD 0x2000 /* SvPVX contains AUTOLOADed sub name */
|
||||
/* 0x4000 previously CVf_HASEVAL */
|
||||
#define CVf_NAMED 0x8000 /* Has a name HEK */
|
||||
#define CVf_LEXICAL 0x10000 /* Omit package from name */
|
||||
#define CVf_ANONCONST 0x20000 /* :const - create anonconst op */
|
||||
#define CVf_SIGNATURE 0x40000 /* CV uses a signature */
|
||||
#define CVf_REFCOUNTED_ANYSV 0x80000 /* CvXSUBANY().any_sv is refcounted */
|
||||
#define CVf_IsMETHOD 0x100000 /* CV is a (real) method of a real class. Not
|
||||
to be confused with what used to be called
|
||||
CVf_METHOD; now CVf_NOWARN_AMBIGUOUS */
|
||||
#define CVf_XS_RCSTACK 0x200000 /* the XS function understands a
|
||||
reference-counted stack */
|
||||
|
||||
/* This symbol for optimised communication between toke.c and op.c: */
|
||||
#define CVf_BUILTIN_ATTRS (CVf_NOWARN_AMBIGUOUS|CVf_LVALUE|CVf_ANONCONST)
|
||||
|
||||
#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)
|
||||
|
||||
/* CvEVAL or CvSPECIAL */
|
||||
#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 CvNOWARN_AMBIGUOUS(cv) (CvFLAGS(cv) & CVf_NOWARN_AMBIGUOUS)
|
||||
#define CvNOWARN_AMBIGUOUS_on(cv) (CvFLAGS(cv) |= CVf_NOWARN_AMBIGUOUS)
|
||||
#define CvNOWARN_AMBIGUOUS_off(cv) (CvFLAGS(cv) &= ~CVf_NOWARN_AMBIGUOUS)
|
||||
|
||||
#define CvLVALUE(cv) (CvFLAGS(cv) & CVf_LVALUE)
|
||||
#define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE)
|
||||
#define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE)
|
||||
|
||||
/* eval or PL_main_cv */
|
||||
#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)
|
||||
|
||||
#ifdef PERL_CORE
|
||||
# define CvSLABBED(cv) (CvFLAGS(cv) & CVf_SLABBED)
|
||||
# define CvSLABBED_on(cv) (CvFLAGS(cv) |= CVf_SLABBED)
|
||||
# define CvSLABBED_off(cv) (CvFLAGS(cv) &= ~CVf_SLABBED)
|
||||
#endif
|
||||
|
||||
#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)
|
||||
|
||||
#define CvNAMED(cv) (CvFLAGS(cv) & CVf_NAMED)
|
||||
#define CvNAMED_on(cv) (CvFLAGS(cv) |= CVf_NAMED)
|
||||
#define CvNAMED_off(cv) (CvFLAGS(cv) &= ~CVf_NAMED)
|
||||
|
||||
#define CvLEXICAL(cv) (CvFLAGS(cv) & CVf_LEXICAL)
|
||||
#define CvLEXICAL_on(cv) (CvFLAGS(cv) |= CVf_LEXICAL)
|
||||
#define CvLEXICAL_off(cv) (CvFLAGS(cv) &= ~CVf_LEXICAL)
|
||||
|
||||
#define CvANONCONST(cv) (CvFLAGS(cv) & CVf_ANONCONST)
|
||||
#define CvANONCONST_on(cv) (CvFLAGS(cv) |= CVf_ANONCONST)
|
||||
#define CvANONCONST_off(cv) (CvFLAGS(cv) &= ~CVf_ANONCONST)
|
||||
|
||||
#define CvSIGNATURE(cv) (CvFLAGS(cv) & CVf_SIGNATURE)
|
||||
#define CvSIGNATURE_on(cv) (CvFLAGS(cv) |= CVf_SIGNATURE)
|
||||
#define CvSIGNATURE_off(cv) (CvFLAGS(cv) &= ~CVf_SIGNATURE)
|
||||
|
||||
/*
|
||||
|
||||
=for apidoc m|bool|CvREFCOUNTED_ANYSV|CV *cv
|
||||
|
||||
If true, indicates that the C<CvXSUBANY(cv).any_sv> member contains an SV
|
||||
pointer whose reference count should be decremented when the CV itself is
|
||||
freed. In addition, C<cv_clone()> will increment the reference count, and
|
||||
C<sv_dup()> will duplicate the entire pointed-to SV if this flag is set.
|
||||
|
||||
Any CV that wraps an XSUB has an C<ANY> union that the XSUB function is free
|
||||
to use for its own purposes. It may be the case that the code wishes to store
|
||||
an SV in the C<any_sv> member of this union. By setting this flag, this SV
|
||||
reference will be properly reclaimed or duplicated when the CV itself is.
|
||||
|
||||
=for apidoc m|void|CvREFCOUNTED_ANYSV_on|CV *cv
|
||||
|
||||
Helper macro to turn on the C<CvREFCOUNTED_ANYSV> flag.
|
||||
|
||||
=for apidoc m|void|CvREFCOUNTED_ANYSV_off|CV *cv
|
||||
|
||||
Helper macro to turn off the C<CvREFCOUNTED_ANYSV> flag.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#define CvREFCOUNTED_ANYSV(cv) (CvFLAGS(cv) & CVf_REFCOUNTED_ANYSV)
|
||||
#define CvREFCOUNTED_ANYSV_on(cv) (CvFLAGS(cv) |= CVf_REFCOUNTED_ANYSV)
|
||||
#define CvREFCOUNTED_ANYSV_off(cv) (CvFLAGS(cv) &= ~CVf_REFCOUNTED_ANYSV)
|
||||
|
||||
#define CvIsMETHOD(cv) (CvFLAGS(cv) & CVf_IsMETHOD)
|
||||
#define CvIsMETHOD_on(cv) (CvFLAGS(cv) |= CVf_IsMETHOD)
|
||||
#define CvIsMETHOD_off(cv) (CvFLAGS(cv) &= ~CVf_IsMETHOD)
|
||||
|
||||
#define CvXS_RCSTACK(cv) (CvFLAGS(cv) & CVf_XS_RCSTACK)
|
||||
#define CvXS_RCSTACK_on(cv) (CvFLAGS(cv) |= CVf_XS_RCSTACK)
|
||||
#define CvXS_RCSTACK_off(cv) (CvFLAGS(cv) &= ~CVf_XS_RCSTACK)
|
||||
|
||||
/* Back-compat */
|
||||
#ifndef PERL_CORE
|
||||
# define CVf_METHOD CVf_NOWARN_AMBIGUOUS
|
||||
# define CvMETHOD(cv) CvNOWARN_AMBIGUOUS(cv)
|
||||
# define CvMETHOD_on(cv) CvNOWARN_AMBIGUOUS_on(cv)
|
||||
# define CvMETHOD_off(cv) CvNOWARN_AMBIGUOUS_off(cv)
|
||||
#endif
|
||||
|
||||
/* Flags for newXS_flags */
|
||||
#define XS_DYNAMIC_FILENAME 0x01 /* The filename isn't static */
|
||||
|
||||
PERL_STATIC_INLINE HEK *
|
||||
CvNAME_HEK(CV *sv)
|
||||
{
|
||||
return CvNAMED(sv)
|
||||
? ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_hek
|
||||
: 0;
|
||||
}
|
||||
|
||||
/* helper for the common pattern:
|
||||
CvNAMED(sv) ? CvNAME_HEK((CV *)sv) : GvNAME_HEK(CvGV(sv))
|
||||
*/
|
||||
#define CvGvNAME_HEK(sv) ( \
|
||||
CvNAMED((CV*)sv) ? \
|
||||
((XPVCV*)MUTABLE_PTR(SvANY((SV*)sv)))->xcv_gv_u.xcv_hek\
|
||||
: GvNAME_HEK(CvGV( (SV*) sv)) \
|
||||
)
|
||||
|
||||
/* This lowers the reference count of the previous value, but does *not*
|
||||
increment the reference count of the new value. */
|
||||
#define CvNAME_HEK_set(cv, hek) ( \
|
||||
CvNAME_HEK((CV *)(cv)) \
|
||||
? unshare_hek(SvANY((CV *)(cv))->xcv_gv_u.xcv_hek) \
|
||||
: (void)0, \
|
||||
((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_gv_u.xcv_hek = (hek), \
|
||||
CvNAMED_on(cv) \
|
||||
)
|
||||
|
||||
/*
|
||||
|
||||
=for apidoc m|bool|CvWEAKOUTSIDE|CV *cv
|
||||
|
||||
Each CV has a pointer, C<CvOUTSIDE()>, 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<CvOUTSIDE> in the I<one specific instance> that the parent
|
||||
has a C<&> pad slot pointing back to us. In this case, we set the
|
||||
C<CvWEAKOUTSIDE> 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, I<e.g.>,
|
||||
|
||||
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<CvWEAKOUTSIDE> 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<eval '$x'> causes the chain of C<CvOUTSIDE>s 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<CvOUTSIDE> 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<undef &foo>. In this case, its refcount may
|
||||
not have reached zero, but we still delete its pad and its C<CvROOT> etc.
|
||||
Since various children may still have their C<CvOUTSIDE> pointing at this
|
||||
undefined CV, we keep its own C<CvOUTSIDE> 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 *);
|
||||
|
||||
#define CALL_CHECKER_REQUIRE_GV MGf_REQUIRE_GV
|
||||
|
||||
#define CV_NAME_NOTQUAL 1
|
||||
|
||||
#ifdef PERL_CORE
|
||||
# define CV_UNDEF_KEEP_NAME 1
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cygperl5_40.dll
Normal file
BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cygperl5_40.dll
Normal file
Binary file not shown.
119
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/dosish.h
Normal file
119
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/dosish.h
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
/* 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 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
|
||||
# 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
|
||||
|
||||
/* Generally add things last-in first-terminated. IO and memory terminations
|
||||
* need to be generally last
|
||||
*
|
||||
* BEWARE that using PerlIO in these will be using freed memory, so may appear
|
||||
* to work, but must NOT be retained in production code. */
|
||||
#ifndef PERL_SYS_TERM_BODY
|
||||
# define PERL_SYS_TERM_BODY() \
|
||||
ENV_TERM; USER_PROP_MUTEX_TERM; LOCALE_TERM; \
|
||||
HINTS_REFCNT_TERM; KEYWORD_PLUGIN_MUTEX_TERM; \
|
||||
OP_CHECK_MUTEX_TERM; OP_REFCNT_TERM; \
|
||||
PERLIO_TERM; MALLOC_TERM;
|
||||
#endif
|
||||
#define dXSUB_SYS dNOOP
|
||||
|
||||
/* 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 <sys/stat.h> and <sys/types.h> to get any typedef'ed
|
||||
* information.
|
||||
*/
|
||||
#if defined(WIN32)
|
||||
# define Stat_t struct w32_stat
|
||||
#else
|
||||
# define Stat_t struct _stati64
|
||||
#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 <signal.h>
|
||||
|
||||
/*
|
||||
* 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))
|
||||
#define Fflush(fp) fflush(fp)
|
||||
#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 */
|
||||
|
||||
/* Don't go reading from /dev/urandom */
|
||||
#define PERL_NO_DEV_RANDOM
|
||||
|
||||
#ifdef WIN32
|
||||
# define NO_ENVIRON_ARRAY
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
798
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/ebcdic_tables.h
Normal file
798
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/ebcdic_tables.h
Normal file
|
|
@ -0,0 +1,798 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
|
||||
* This file is built by regen/ebcdic.pl.
|
||||
* Any changes made here will be lost!
|
||||
*/
|
||||
|
||||
|
||||
#ifndef PERL_EBCDIC_TABLES_H_ /* Guard against nested #includes */
|
||||
#define PERL_EBCDIC_TABLES_H_ 1
|
||||
|
||||
/* This file contains definitions for various tables used in EBCDIC handling.
|
||||
* More info is in utfebcdic.h
|
||||
*
|
||||
* Some of the tables are adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* which requires this copyright notice:
|
||||
|
||||
Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
||||
*/
|
||||
|
||||
#if 'A' == 193 /* EBCDIC 1047 */ \
|
||||
&& '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
|
||||
&& '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
|
||||
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21
|
||||
|
||||
/* Index is ASCII platform code point; value is EBCDIC 1047 equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_a2e[256];
|
||||
# else
|
||||
EXTCONST U8 PL_a2e[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x15,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
|
||||
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
|
||||
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
|
||||
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAD,0xE0,0xBD,0x5F,0x6D,
|
||||
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
|
||||
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
|
||||
/*8_*/0x20,0x21,0x22,0x23,0x24,0x25,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
|
||||
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
|
||||
/*A_*/0x41,0xAA,0x4A,0xB1,0x9F,0xB2,0x6A,0xB5,0xBB,0xB4,0x9A,0x8A,0xB0,0xCA,0xAF,0xBC,
|
||||
/*B_*/0x90,0x8F,0xEA,0xFA,0xBE,0xA0,0xB6,0xB3,0x9D,0xDA,0x9B,0x8B,0xB7,0xB8,0xB9,0xAB,
|
||||
/*C_*/0x64,0x65,0x62,0x66,0x63,0x67,0x9E,0x68,0x74,0x71,0x72,0x73,0x78,0x75,0x76,0x77,
|
||||
/*D_*/0xAC,0x69,0xED,0xEE,0xEB,0xEF,0xEC,0xBF,0x80,0xFD,0xFE,0xFB,0xFC,0xBA,0xAE,0x59,
|
||||
/*E_*/0x44,0x45,0x42,0x46,0x43,0x47,0x9C,0x48,0x54,0x51,0x52,0x53,0x58,0x55,0x56,0x57,
|
||||
/*F_*/0x8C,0x49,0xCD,0xCE,0xCB,0xCF,0xCC,0xE1,0x70,0xDD,0xDE,0xDB,0xDC,0x8D,0x8E,0xDF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 code point; value is ASCII platform equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_e2a[256];
|
||||
# else
|
||||
EXTCONST U8 PL_e2a[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
|
||||
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
|
||||
/*4_*/0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
|
||||
/*5_*/0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0x5E,
|
||||
/*6_*/0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
|
||||
/*7_*/0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
|
||||
/*8_*/0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
|
||||
/*9_*/0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
|
||||
/*A_*/0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0x5B,0xDE,0xAE,
|
||||
/*B_*/0xAC,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0xDD,0xA8,0xAF,0x5D,0xB4,0xD7,
|
||||
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
|
||||
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
|
||||
/*E_*/0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
|
||||
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* (Confusingly named) Index is EBCDIC 1047 I8 byte; value is
|
||||
* EBCDIC 1047 UTF-EBCDIC equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_utf2e[256];
|
||||
# else
|
||||
EXTCONST U8 PL_utf2e[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x15,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
|
||||
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
|
||||
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
|
||||
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAD,0xE0,0xBD,0x5F,0x6D,
|
||||
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
|
||||
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
|
||||
/*8_*/0x20,0x21,0x22,0x23,0x24,0x25,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
|
||||
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
|
||||
/*A_*/0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x51,0x52,0x53,0x54,0x55,0x56,
|
||||
/*B_*/0x57,0x58,0x59,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x70,0x71,0x72,0x73,
|
||||
/*C_*/0x74,0x75,0x76,0x77,0x78,0x80,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x9A,0x9B,0x9C,
|
||||
/*D_*/0x9D,0x9E,0x9F,0xA0,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,
|
||||
/*E_*/0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBF,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xDA,0xDB,
|
||||
/*F_*/0xDC,0xDD,0xDE,0xDF,0xE1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xFA,0xFB,0xFC,0xFD,0xFE
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* (Confusingly named) Index is EBCDIC 1047 UTF-EBCDIC byte; value is
|
||||
* EBCDIC 1047 I8 equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_e2utf[256];
|
||||
# else
|
||||
EXTCONST U8 PL_e2utf[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
|
||||
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
|
||||
/*4_*/0x20,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0x2E,0x3C,0x28,0x2B,0x7C,
|
||||
/*5_*/0x26,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0x21,0x24,0x2A,0x29,0x3B,0x5E,
|
||||
/*6_*/0x2D,0x2F,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0x2C,0x25,0x5F,0x3E,0x3F,
|
||||
/*7_*/0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
|
||||
/*8_*/0xC5,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
|
||||
/*9_*/0xCC,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,
|
||||
/*A_*/0xD3,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xD4,0xD5,0xD6,0x5B,0xD7,0xD8,
|
||||
/*B_*/0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0x5D,0xE6,0xE7,
|
||||
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
|
||||
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
|
||||
/*E_*/0x5C,0xF4,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,
|
||||
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xFB,0xFC,0xFD,0xFE,0xFF,0x9F
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 UTF-EBCDIC byte; value is UTF8SKIP for start bytes
|
||||
* (including for overlongs); 1 for continuation. 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. */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_utf8skip[256];
|
||||
# else
|
||||
EXTCONST U8 PL_utf8skip[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 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,
|
||||
/*3_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*4_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*5_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*6_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*7_*/ 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*8_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
|
||||
/*9_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
|
||||
/*A_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 2, 2,
|
||||
/*B_*/ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 1, 3, 3,
|
||||
/*C_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
|
||||
/*D_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4,
|
||||
/*E_*/ 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 5, 5, 5,
|
||||
/*F_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 6, 6, 7, 14, 1
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 code point; value is its lowercase equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_latin1_lc[256];
|
||||
# else
|
||||
EXTCONST U8 PL_latin1_lc[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x70,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x70,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
|
||||
/*9_*/0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9C,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0x8C,0xAD,0x8E,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0x8D,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 code point; value is its uppercase equivalent.
|
||||
* The 'mod' in the name means that codepoints whose uppercase is above 255 or
|
||||
* longer than 1 character map to LATIN SMALL LETTER Y WITH DIARESIS */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_mod_latin1_uc[256];
|
||||
# else
|
||||
EXTCONST U8 PL_mod_latin1_uc[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0xDF,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x80,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xBA,0xAE,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9E,0x9F,
|
||||
/*A_*/0xDF,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*D_*/0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 code point; For A-Z, value is a-z; for a-z, value
|
||||
* is A-Z; all other code points map to themselves */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_fold[256];
|
||||
# else
|
||||
EXTCONST U8 PL_fold[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 1047 code point; value is its other fold-pair equivalent
|
||||
* (A => a; a => A, etc) in the 0-255 range. If no such equivalent, value is
|
||||
* the code point itself */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_fold_latin1[256];
|
||||
# else
|
||||
EXTCONST U8 PL_fold_latin1[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x80,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x70,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xBA,0xAE,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9C,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0x8C,0xAD,0x8E,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0x8D,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_extended_utf8_dfa_tab[416];
|
||||
# else
|
||||
EXTCONST U8 PL_extended_utf8_dfa_tab[416] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 10, 10, 10, 10, 10, 10, 11, 11, 11, 0, 0, 0, 0, 0, 0,
|
||||
/*6_ */ 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 11, 11, 11, 11, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
|
||||
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 12, 4, 4, 4,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 13, 5, 5,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 14, 6, 15, 1, 0,
|
||||
/*N0= 0*/ 0, 1, 16, 32, 48, 64, 80, 1, 1, 1, 1, 1, 96,112,128,144,
|
||||
/*N1= 16*/ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
|
||||
/*N2= 32*/ 1, 1, 1, 1, 1, 1, 1, 16, 16, 16, 16, 16, 1, 1, 1, 1,
|
||||
/*N3= 48*/ 1, 1, 1, 1, 1, 1, 1, 32, 32, 32, 32, 32, 1, 1, 1, 1,
|
||||
/*N4= 64*/ 1, 1, 1, 1, 1, 1, 1, 48, 48, 48, 48, 48, 1, 1, 1, 1,
|
||||
/*N5= 80*/ 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 64, 64, 1, 1, 1, 1,
|
||||
/*N6= 96*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 32, 1, 1, 1, 1,
|
||||
/*N7=112*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 48, 48, 1, 1, 1, 1,
|
||||
/*N8=128*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 1, 1, 1, 1,
|
||||
/*N9=144*/ 1, 1, 1, 1, 1, 1, 1, 1, 80, 80, 80, 80, 1, 1, 1, 1
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U16 PL_strict_utf8_dfa_tab[624];
|
||||
# else
|
||||
EXTCONST U16 PL_strict_utf8_dfa_tab[624] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 10, 11, 12, 12, 12, 12, 12, 12, 13, 14, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 13, 14, 13, 14, 15, 16, 17, 18, 17, 0, 0, 0, 0, 0, 0,
|
||||
/*6_ */ 0, 0, 18, 17, 18, 19, 20, 17, 18, 17, 18, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 17, 18, 21, 22, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
|
||||
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 8, 6, 4, 5,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 9, 7, 1,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
|
||||
/*N0 = 0*/ 0, 1, 23, 46, 69,138,115,184, 92,161, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*N1 = 23*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*N2 = 46*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
|
||||
/*N3 = 69*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
|
||||
/*N4 = 92*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46,
|
||||
/*N5 =115*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 1, 1, 46,207,
|
||||
/*N6 =138*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,276,
|
||||
/*N7 =161*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 69,322, 69,322, 69,322, 69,322,
|
||||
/*N8 =184*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*N9 =207*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23,230,253, 23, 23, 23, 23, 23,299,
|
||||
/*N10=230*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
|
||||
/*N11=253*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
|
||||
/*N12=276*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299,
|
||||
/*N13=299*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
|
||||
/*N14=322*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,345,
|
||||
/*N15=345*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_c9_utf8_dfa_tab[368];
|
||||
# else
|
||||
EXTCONST U8 PL_c9_utf8_dfa_tab[368] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 11, 11, 11, 11, 11, 11, 12, 12, 12, 0, 0, 0, 0, 0, 0,
|
||||
/*6_ */ 0, 0, 12, 12, 12, 13, 13, 12, 12, 12, 12, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 12, 12, 12, 12, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
|
||||
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 6, 5, 4, 4,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 8, 7, 1,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
|
||||
/*N0= 0*/ 0, 1, 14, 28, 42, 70, 56, 98, 84, 1, 1, 1, 1, 1,
|
||||
/*N1=14*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
|
||||
/*N2=28*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, 14, 14, 14, 14,
|
||||
/*N3=42*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28,
|
||||
/*N4=56*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28,
|
||||
/*N5=70*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 1,
|
||||
/*N6=84*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 42, 42,
|
||||
/*N7=98*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 1, 1, 1, 1
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13*/
|
||||
};
|
||||
# endif
|
||||
|
||||
#endif /* EBCDIC 1047 */
|
||||
|
||||
#if 'A' == 193 /* EBCDIC 037 */ \
|
||||
&& '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
|
||||
&& '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
|
||||
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37
|
||||
|
||||
/* Index is ASCII platform code point; value is EBCDIC 037 equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_a2e[256];
|
||||
# else
|
||||
EXTCONST U8 PL_a2e[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x25,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
|
||||
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
|
||||
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
|
||||
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xBA,0xE0,0xBB,0xB0,0x6D,
|
||||
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
|
||||
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
|
||||
/*8_*/0x20,0x21,0x22,0x23,0x24,0x15,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
|
||||
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
|
||||
/*A_*/0x41,0xAA,0x4A,0xB1,0x9F,0xB2,0x6A,0xB5,0xBD,0xB4,0x9A,0x8A,0x5F,0xCA,0xAF,0xBC,
|
||||
/*B_*/0x90,0x8F,0xEA,0xFA,0xBE,0xA0,0xB6,0xB3,0x9D,0xDA,0x9B,0x8B,0xB7,0xB8,0xB9,0xAB,
|
||||
/*C_*/0x64,0x65,0x62,0x66,0x63,0x67,0x9E,0x68,0x74,0x71,0x72,0x73,0x78,0x75,0x76,0x77,
|
||||
/*D_*/0xAC,0x69,0xED,0xEE,0xEB,0xEF,0xEC,0xBF,0x80,0xFD,0xFE,0xFB,0xFC,0xAD,0xAE,0x59,
|
||||
/*E_*/0x44,0x45,0x42,0x46,0x43,0x47,0x9C,0x48,0x54,0x51,0x52,0x53,0x58,0x55,0x56,0x57,
|
||||
/*F_*/0x8C,0x49,0xCD,0xCE,0xCB,0xCF,0xCC,0xE1,0x70,0xDD,0xDE,0xDB,0xDC,0x8D,0x8E,0xDF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 code point; value is ASCII platform equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_e2a[256];
|
||||
# else
|
||||
EXTCONST U8 PL_e2a[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x85,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x80,0x81,0x82,0x83,0x84,0x0A,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
|
||||
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
|
||||
/*4_*/0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
|
||||
/*5_*/0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0xAC,
|
||||
/*6_*/0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
|
||||
/*7_*/0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
|
||||
/*8_*/0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
|
||||
/*9_*/0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
|
||||
/*A_*/0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0xDD,0xDE,0xAE,
|
||||
/*B_*/0x5E,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0x5B,0x5D,0xAF,0xA8,0xB4,0xD7,
|
||||
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
|
||||
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
|
||||
/*E_*/0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
|
||||
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* (Confusingly named) Index is EBCDIC 037 I8 byte; value is
|
||||
* EBCDIC 037 UTF-EBCDIC equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_utf2e[256];
|
||||
# else
|
||||
EXTCONST U8 PL_utf2e[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x25,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
|
||||
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
|
||||
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
|
||||
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xBA,0xE0,0xBB,0xB0,0x6D,
|
||||
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
|
||||
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
|
||||
/*8_*/0x20,0x21,0x22,0x23,0x24,0x15,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
|
||||
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
|
||||
/*A_*/0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x51,0x52,0x53,0x54,0x55,0x56,
|
||||
/*B_*/0x57,0x58,0x59,0x5F,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x70,0x71,0x72,
|
||||
/*C_*/0x73,0x74,0x75,0x76,0x77,0x78,0x80,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x9A,0x9B,
|
||||
/*D_*/0x9C,0x9D,0x9E,0x9F,0xA0,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB4,0xB5,
|
||||
/*E_*/0xB6,0xB7,0xB8,0xB9,0xBC,0xBD,0xBE,0xBF,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xDA,0xDB,
|
||||
/*F_*/0xDC,0xDD,0xDE,0xDF,0xE1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xFA,0xFB,0xFC,0xFD,0xFE
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* (Confusingly named) Index is EBCDIC 037 UTF-EBCDIC byte; value is
|
||||
* EBCDIC 037 I8 equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_e2utf[256];
|
||||
# else
|
||||
EXTCONST U8 PL_e2utf[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x85,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x80,0x81,0x82,0x83,0x84,0x0A,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
|
||||
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
|
||||
/*4_*/0x20,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0x2E,0x3C,0x28,0x2B,0x7C,
|
||||
/*5_*/0x26,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0x21,0x24,0x2A,0x29,0x3B,0xB3,
|
||||
/*6_*/0x2D,0x2F,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0x2C,0x25,0x5F,0x3E,0x3F,
|
||||
/*7_*/0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
|
||||
/*8_*/0xC6,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,
|
||||
/*9_*/0xCD,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,
|
||||
/*A_*/0xD4,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,
|
||||
/*B_*/0x5E,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0x5B,0x5D,0xE4,0xE5,0xE6,0xE7,
|
||||
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
|
||||
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
|
||||
/*E_*/0x5C,0xF4,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,
|
||||
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xFB,0xFC,0xFD,0xFE,0xFF,0x9F
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 UTF-EBCDIC byte; value is UTF8SKIP for start bytes
|
||||
* (including for overlongs); 1 for continuation. 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. */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_utf8skip[256];
|
||||
# else
|
||||
EXTCONST U8 PL_utf8skip[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 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,
|
||||
/*3_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*4_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*5_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*6_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*7_*/ 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*8_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
|
||||
/*9_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
|
||||
/*A_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
|
||||
/*B_*/ 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 3, 3, 3, 3,
|
||||
/*C_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
|
||||
/*D_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4,
|
||||
/*E_*/ 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 5, 5, 5,
|
||||
/*F_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 6, 6, 7, 14, 1
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 code point; value is its lowercase equivalent */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_latin1_lc[256];
|
||||
# else
|
||||
EXTCONST U8 PL_latin1_lc[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x70,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x70,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
|
||||
/*9_*/0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9C,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0x8C,0x8D,0x8E,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 code point; value is its uppercase equivalent.
|
||||
* The 'mod' in the name means that codepoints whose uppercase is above 255 or
|
||||
* longer than 1 character map to LATIN SMALL LETTER Y WITH DIARESIS */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_mod_latin1_uc[256];
|
||||
# else
|
||||
EXTCONST U8 PL_mod_latin1_uc[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0xDF,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x80,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xAD,0xAE,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9E,0x9F,
|
||||
/*A_*/0xDF,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*D_*/0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 code point; For A-Z, value is a-z; for a-z, value
|
||||
* is A-Z; all other code points map to themselves */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_fold[256];
|
||||
# else
|
||||
EXTCONST U8 PL_fold[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
/* Index is EBCDIC 037 code point; value is its other fold-pair equivalent
|
||||
* (A => a; a => A, etc) in the 0-255 range. If no such equivalent, value is
|
||||
* the code point itself */
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_fold_latin1[256];
|
||||
# else
|
||||
EXTCONST U8 PL_fold_latin1[256] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
|
||||
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
||||
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
||||
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
||||
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
||||
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
||||
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
|
||||
/*7_*/0x80,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
||||
/*8_*/0x70,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xAD,0xAE,0x8F,
|
||||
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9C,0x9F,
|
||||
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0x8C,0x8D,0x8E,0xAF,
|
||||
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
||||
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
|
||||
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
|
||||
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
||||
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_extended_utf8_dfa_tab[416];
|
||||
# else
|
||||
EXTCONST U8 PL_extended_utf8_dfa_tab[416] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 10, 10, 10, 10, 10, 10, 11, 11, 11, 0, 0, 0, 0, 0, 11,
|
||||
/*6_ */ 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 11, 11, 11, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 12, 4, 4, 4,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 13, 5, 5,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 14, 6, 15, 1, 0,
|
||||
/*N0= 0*/ 0, 1, 16, 32, 48, 64, 80, 1, 1, 1, 1, 1, 96,112,128,144,
|
||||
/*N1= 16*/ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
|
||||
/*N2= 32*/ 1, 1, 1, 1, 1, 1, 1, 16, 16, 16, 16, 16, 1, 1, 1, 1,
|
||||
/*N3= 48*/ 1, 1, 1, 1, 1, 1, 1, 32, 32, 32, 32, 32, 1, 1, 1, 1,
|
||||
/*N4= 64*/ 1, 1, 1, 1, 1, 1, 1, 48, 48, 48, 48, 48, 1, 1, 1, 1,
|
||||
/*N5= 80*/ 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 64, 64, 1, 1, 1, 1,
|
||||
/*N6= 96*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 32, 1, 1, 1, 1,
|
||||
/*N7=112*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 48, 48, 1, 1, 1, 1,
|
||||
/*N8=128*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 1, 1, 1, 1,
|
||||
/*N9=144*/ 1, 1, 1, 1, 1, 1, 1, 1, 80, 80, 80, 80, 1, 1, 1, 1
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U16 PL_strict_utf8_dfa_tab[624];
|
||||
# else
|
||||
EXTCONST U16 PL_strict_utf8_dfa_tab[624] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 10, 11, 12, 12, 12, 12, 12, 12, 13, 14, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 13, 14, 13, 14, 15, 16, 17, 18, 17, 0, 0, 0, 0, 0, 18,
|
||||
/*6_ */ 0, 0, 17, 18, 19, 20, 17, 18, 17, 18, 17, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 18, 21, 22, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 8, 6, 4, 5,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 9, 7, 1,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
|
||||
/*N0 = 0*/ 0, 1, 23, 46, 69,138,115,184, 92,161, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*N1 = 23*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*N2 = 46*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
|
||||
/*N3 = 69*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
|
||||
/*N4 = 92*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46,
|
||||
/*N5 =115*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 1, 1, 46,207,
|
||||
/*N6 =138*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,276,
|
||||
/*N7 =161*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 69,322, 69,322, 69,322, 69,322,
|
||||
/*N8 =184*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
/*N9 =207*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23,230,253, 23, 23, 23, 23, 23,299,
|
||||
/*N10=230*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
|
||||
/*N11=253*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
|
||||
/*N12=276*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299,
|
||||
/*N13=299*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
|
||||
/*N14=322*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,345,
|
||||
/*N15=345*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22*/
|
||||
};
|
||||
# endif
|
||||
|
||||
|
||||
/* The table below is adapted from
|
||||
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
|
||||
* See copyright notice at the beginning of this file.
|
||||
*/
|
||||
|
||||
# ifndef DOINIT
|
||||
EXTCONST U8 PL_c9_utf8_dfa_tab[368];
|
||||
# else
|
||||
EXTCONST U8 PL_c9_utf8_dfa_tab[368] = {
|
||||
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
|
||||
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*4_ */ 0, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 0, 0, 0, 0, 0,
|
||||
/*5_ */ 0, 11, 11, 11, 11, 11, 11, 12, 12, 12, 0, 0, 0, 0, 0, 12,
|
||||
/*6_ */ 0, 0, 12, 12, 13, 13, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0,
|
||||
/*7_ */ 12, 12, 12, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
|
||||
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
|
||||
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
|
||||
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
|
||||
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 6, 5, 4, 4,
|
||||
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 8, 7, 1,
|
||||
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
|
||||
/*N0= 0*/ 0, 1, 14, 28, 42, 70, 56, 98, 84, 1, 1, 1, 1, 1,
|
||||
/*N1=14*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
|
||||
/*N2=28*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, 14, 14, 14, 14,
|
||||
/*N3=42*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28,
|
||||
/*N4=56*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28,
|
||||
/*N5=70*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 1,
|
||||
/*N6=84*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 42, 42,
|
||||
/*N7=98*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 1, 1, 1, 1
|
||||
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13*/
|
||||
};
|
||||
# endif
|
||||
|
||||
#endif /* EBCDIC 037 */
|
||||
|
||||
#endif /* PERL_EBCDIC_TABLES_H_ */
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
2233
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embed.h
Normal file
2233
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embed.h
Normal file
File diff suppressed because it is too large
Load diff
370
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embedvar.h
Normal file
370
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embedvar.h
Normal file
|
|
@ -0,0 +1,370 @@
|
|||
/* -*- mode: C; 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, 2010, 2011, 2012, 2013,
|
||||
* 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022
|
||||
* 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 embed.fnc, intrpvar.h,
|
||||
* perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and
|
||||
* regen/HeaderParser.pm.
|
||||
* Any changes made here will be lost!
|
||||
*
|
||||
* Edit those files and run 'make regen_headers' to effect changes.
|
||||
*/
|
||||
|
||||
#if defined(MULTIPLICITY)
|
||||
# define vTHX aTHX
|
||||
# define PL_AboveLatin1 (vTHX->IAboveLatin1)
|
||||
# define PL_an (vTHX->Ian)
|
||||
# define PL_argvgv (vTHX->Iargvgv)
|
||||
# define PL_argvout_stack (vTHX->Iargvout_stack)
|
||||
# define PL_argvoutgv (vTHX->Iargvoutgv)
|
||||
# define PL_Assigned_invlist (vTHX->IAssigned_invlist)
|
||||
# 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_CCC_non0_non230 (vTHX->ICCC_non0_non230)
|
||||
# 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_constpadix (vTHX->Iconstpadix)
|
||||
# define PL_cop_seqmax (vTHX->Icop_seqmax)
|
||||
# define PL_ctype_name (vTHX->Ictype_name)
|
||||
# define PL_cur_LC_ALL (vTHX->Icur_LC_ALL)
|
||||
# define PL_cur_locale_obj (vTHX->Icur_locale_obj)
|
||||
# define PL_curcop (vTHX->Icurcop)
|
||||
# define PL_curcopdb (vTHX->Icurcopdb)
|
||||
# define PL_curlocales (vTHX->Icurlocales)
|
||||
# define PL_curpad (vTHX->Icurpad)
|
||||
# define PL_curpm (vTHX->Icurpm)
|
||||
# define PL_curpm_under (vTHX->Icurpm_under)
|
||||
# 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_DBcontrol (vTHX->IDBcontrol)
|
||||
# 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_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_Dir (vTHX->IDir)
|
||||
# define PL_doswitches (vTHX->Idoswitches)
|
||||
# define PL_dowarn (vTHX->Idowarn)
|
||||
# define PL_dump_re_max_len (vTHX->Idump_re_max_len)
|
||||
# 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_endav (vTHX->Iendav)
|
||||
# define PL_Env (vTHX->IEnv)
|
||||
# define PL_envgv (vTHX->Ienvgv)
|
||||
# define PL_errgv (vTHX->Ierrgv)
|
||||
# define PL_errors (vTHX->Ierrors)
|
||||
# define PL_eval_begin_nest_depth (vTHX->Ieval_begin_nest_depth)
|
||||
# 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_fold_locale (vTHX->Ifold_locale)
|
||||
# define PL_forkprocess (vTHX->Iforkprocess)
|
||||
# define PL_formtarget (vTHX->Iformtarget)
|
||||
# define PL_GCB_invlist (vTHX->IGCB_invlist)
|
||||
# define PL_generation (vTHX->Igeneration)
|
||||
# define PL_gensym (vTHX->Igensym)
|
||||
# define PL_globalstash (vTHX->Iglobalstash)
|
||||
# define PL_globhook (vTHX->Iglobhook)
|
||||
# define PL_hash_rand_bits (vTHX->Ihash_rand_bits)
|
||||
# define PL_hash_rand_bits_enabled (vTHX->Ihash_rand_bits_enabled)
|
||||
# define PL_HasMultiCharFold (vTHX->IHasMultiCharFold)
|
||||
# define PL_hintgv (vTHX->Ihintgv)
|
||||
# define PL_hook__require__after (vTHX->Ihook__require__after)
|
||||
# define PL_hook__require__before (vTHX->Ihook__require__before)
|
||||
# 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_in_some_fold (vTHX->Iin_some_fold)
|
||||
# define PL_in_utf8_COLLATE_locale (vTHX->Iin_utf8_COLLATE_locale)
|
||||
# define PL_in_utf8_CTYPE_locale (vTHX->Iin_utf8_CTYPE_locale)
|
||||
# define PL_in_utf8_turkic_locale (vTHX->Iin_utf8_turkic_locale)
|
||||
# define PL_InBitmap (vTHX->IInBitmap)
|
||||
# define PL_incgv (vTHX->Iincgv)
|
||||
# define PL_initav (vTHX->Iinitav)
|
||||
# define PL_InMultiCharFold (vTHX->IInMultiCharFold)
|
||||
# define PL_inplace (vTHX->Iinplace)
|
||||
# define PL_internal_random_state (vTHX->Iinternal_random_state)
|
||||
# define PL_isarev (vTHX->Iisarev)
|
||||
# define PL_known_layers (vTHX->Iknown_layers)
|
||||
# define PL_langinfo_sv (vTHX->Ilanginfo_sv)
|
||||
# define PL_last_in_gv (vTHX->Ilast_in_gv)
|
||||
# define PL_lastfd (vTHX->Ilastfd)
|
||||
# define PL_lastgotoprobe (vTHX->Ilastgotoprobe)
|
||||
# define PL_laststatval (vTHX->Ilaststatval)
|
||||
# define PL_laststype (vTHX->Ilaststype)
|
||||
# define PL_Latin1 (vTHX->ILatin1)
|
||||
# define PL_LB_invlist (vTHX->ILB_invlist)
|
||||
# define PL_less_dicey_locale_buf (vTHX->Iless_dicey_locale_buf)
|
||||
# define PL_less_dicey_locale_bufsize (vTHX->Iless_dicey_locale_bufsize)
|
||||
# define PL_LIO (vTHX->ILIO)
|
||||
# define PL_locale_mutex_depth (vTHX->Ilocale_mutex_depth)
|
||||
# define PL_localizing (vTHX->Ilocalizing)
|
||||
# define PL_localpatches (vTHX->Ilocalpatches)
|
||||
# define PL_lockhook (vTHX->Ilockhook)
|
||||
# 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_maxsysfd (vTHX->Imaxsysfd)
|
||||
# define PL_mbrlen_ps (vTHX->Imbrlen_ps)
|
||||
# define PL_mbrtowc_ps (vTHX->Imbrtowc_ps)
|
||||
# define PL_Mem (vTHX->IMem)
|
||||
# define PL_mem_log (vTHX->Imem_log)
|
||||
# define PL_memory_debug_header (vTHX->Imemory_debug_header)
|
||||
# define PL_MemParse (vTHX->IMemParse)
|
||||
# define PL_MemShared (vTHX->IMemShared)
|
||||
# define PL_mess_sv (vTHX->Imess_sv)
|
||||
# define PL_min_intro_pending (vTHX->Imin_intro_pending)
|
||||
# define PL_minus_a (vTHX->Iminus_a)
|
||||
# define PL_minus_c (vTHX->Iminus_c)
|
||||
# define PL_minus_E (vTHX->Iminus_E)
|
||||
# define PL_minus_F (vTHX->Iminus_F)
|
||||
# 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_multideref_pc (vTHX->Imultideref_pc)
|
||||
# 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_name (vTHX->Inumeric_name)
|
||||
# define PL_numeric_radix_sv (vTHX->Inumeric_radix_sv)
|
||||
# define PL_numeric_standard (vTHX->Inumeric_standard)
|
||||
# define PL_numeric_underlying (vTHX->Inumeric_underlying)
|
||||
# define PL_numeric_underlying_is_standard (vTHX->Inumeric_underlying_is_standard)
|
||||
# define PL_ofsgv (vTHX->Iofsgv)
|
||||
# define PL_oldname (vTHX->Ioldname)
|
||||
# define PL_op (vTHX->Iop)
|
||||
# define PL_op_exec_cnt (vTHX->Iop_exec_cnt)
|
||||
# define PL_op_mask (vTHX->Iop_mask)
|
||||
# define PL_opfreehook (vTHX->Iopfreehook)
|
||||
# define PL_origalen (vTHX->Iorigalen)
|
||||
# define PL_origargc (vTHX->Iorigargc)
|
||||
# define PL_origargv (vTHX->Iorigargv)
|
||||
# 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_padlist_generation (vTHX->Ipadlist_generation)
|
||||
# define PL_padname_const (vTHX->Ipadname_const)
|
||||
# define PL_padname_undef (vTHX->Ipadname_undef)
|
||||
# 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_Posix_ptrs (vTHX->IPosix_ptrs)
|
||||
# define PL_preambleav (vTHX->Ipreambleav)
|
||||
# define PL_prevailing_version (vTHX->Iprevailing_version)
|
||||
# define PL_Private_Use (vTHX->IPrivate_Use)
|
||||
# define PL_Proc (vTHX->IProc)
|
||||
# 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_random_state (vTHX->Irandom_state)
|
||||
# define PL_reentrant_buffer (vTHX->Ireentrant_buffer)
|
||||
# define PL_reentrant_retint (vTHX->Ireentrant_retint)
|
||||
# define PL_reg_curpm (vTHX->Ireg_curpm)
|
||||
# define PL_regex_pad (vTHX->Iregex_pad)
|
||||
# define PL_regex_padav (vTHX->Iregex_padav)
|
||||
# define PL_registered_mros (vTHX->Iregistered_mros)
|
||||
# define PL_regmatch_slab (vTHX->Iregmatch_slab)
|
||||
# define PL_regmatch_state (vTHX->Iregmatch_state)
|
||||
# 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_SB_invlist (vTHX->ISB_invlist)
|
||||
# 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_scratch_langinfo (vTHX->Iscratch_langinfo)
|
||||
# define PL_scratch_locale_obj (vTHX->Iscratch_locale_obj)
|
||||
# define PL_SCX_invlist (vTHX->ISCX_invlist)
|
||||
# define PL_secondgv (vTHX->Isecondgv)
|
||||
# define PL_setlocale_buf (vTHX->Isetlocale_buf)
|
||||
# define PL_setlocale_bufsize (vTHX->Isetlocale_bufsize)
|
||||
# define PL_sharehook (vTHX->Isharehook)
|
||||
# define PL_sig_pending (vTHX->Isig_pending)
|
||||
# define PL_sighandler1p (vTHX->Isighandler1p)
|
||||
# define PL_sighandler3p (vTHX->Isighandler3p)
|
||||
# define PL_sighandlerp (vTHX->Isighandlerp)
|
||||
# define PL_signalhook (vTHX->Isignalhook)
|
||||
# define PL_signals (vTHX->Isignals)
|
||||
# define PL_Sock (vTHX->ISock)
|
||||
# define PL_sortcop (vTHX->Isortcop)
|
||||
# define PL_sortstash (vTHX->Isortstash)
|
||||
# define PL_splitstr (vTHX->Isplitstr)
|
||||
# define PL_srand_called (vTHX->Isrand_called)
|
||||
# define PL_srand_override (vTHX->Isrand_override)
|
||||
# define PL_srand_override_next (vTHX->Isrand_override_next)
|
||||
# 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_stashpad (vTHX->Istashpad)
|
||||
# define PL_stashpadix (vTHX->Istashpadix)
|
||||
# define PL_stashpadmax (vTHX->Istashpadmax)
|
||||
# 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_StdIO (vTHX->IStdIO)
|
||||
# define PL_strtab (vTHX->Istrtab)
|
||||
# define PL_strxfrm_is_behaved (vTHX->Istrxfrm_is_behaved)
|
||||
# define PL_strxfrm_max_cp (vTHX->Istrxfrm_max_cp)
|
||||
# define PL_strxfrm_NUL_replacement (vTHX->Istrxfrm_NUL_replacement)
|
||||
# define PL_sub_generation (vTHX->Isub_generation)
|
||||
# define PL_subline (vTHX->Isubline)
|
||||
# define PL_subname (vTHX->Isubname)
|
||||
# define PL_Sv (vTHX->ISv)
|
||||
# define PL_sv_arenaroot (vTHX->Isv_arenaroot)
|
||||
# define PL_sv_consts (vTHX->Isv_consts)
|
||||
# define PL_sv_count (vTHX->Isv_count)
|
||||
# define PL_sv_immortals (vTHX->Isv_immortals)
|
||||
# define PL_sv_no (vTHX->Isv_no)
|
||||
# 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_sv_zero (vTHX->Isv_zero)
|
||||
# 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_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_TR_SPECIAL_HANDLING_UTF8 (vTHX->ITR_SPECIAL_HANDLING_UTF8)
|
||||
# define PL_underlying_radix_sv (vTHX->Iunderlying_radix_sv)
|
||||
# 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_UpperLatin1 (vTHX->IUpperLatin1)
|
||||
# define PL_utf8_charname_begin (vTHX->Iutf8_charname_begin)
|
||||
# define PL_utf8_charname_continue (vTHX->Iutf8_charname_continue)
|
||||
# define PL_utf8_foldclosures (vTHX->Iutf8_foldclosures)
|
||||
# define PL_utf8_idcont (vTHX->Iutf8_idcont)
|
||||
# define PL_utf8_idstart (vTHX->Iutf8_idstart)
|
||||
# define PL_utf8_mark (vTHX->Iutf8_mark)
|
||||
# define PL_utf8_perl_idcont (vTHX->Iutf8_perl_idcont)
|
||||
# define PL_utf8_perl_idstart (vTHX->Iutf8_perl_idstart)
|
||||
# define PL_utf8_tofold (vTHX->Iutf8_tofold)
|
||||
# define PL_utf8_tolower (vTHX->Iutf8_tolower)
|
||||
# define PL_utf8_tosimplefold (vTHX->Iutf8_tosimplefold)
|
||||
# define PL_utf8_totitle (vTHX->Iutf8_totitle)
|
||||
# define PL_utf8_toupper (vTHX->Iutf8_toupper)
|
||||
# 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_warn_locale (vTHX->Iwarn_locale)
|
||||
# define PL_warnhook (vTHX->Iwarnhook)
|
||||
# define PL_watchaddr (vTHX->Iwatchaddr)
|
||||
# define PL_watchok (vTHX->Iwatchok)
|
||||
# define PL_WB_invlist (vTHX->IWB_invlist)
|
||||
# define PL_wcrtomb_ps (vTHX->Iwcrtomb_ps)
|
||||
# define PL_XPosix_ptrs (vTHX->IXPosix_ptrs)
|
||||
# define PL_Xpv (vTHX->IXpv)
|
||||
# define PL_xsubfilename (vTHX->Ixsubfilename)
|
||||
# if !defined(PL_sawampersand)
|
||||
# define PL_sawampersand (vTHX->Isawampersand)
|
||||
# endif
|
||||
#endif /* defined(MULTIPLICITY) */
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/fakesdio.h
Normal file
127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/fakesdio.h
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
/* fakesdio.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_
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
614
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/feature.h
Normal file
614
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/feature.h
Normal file
|
|
@ -0,0 +1,614 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
|
||||
This file is built by regen/feature.pl.
|
||||
Any changes made here will be lost!
|
||||
*/
|
||||
|
||||
|
||||
#ifndef PERL_FEATURE_H_
|
||||
#define PERL_FEATURE_H_
|
||||
|
||||
#if defined(PERL_CORE) || defined (PERL_EXT)
|
||||
|
||||
#define HINT_FEATURE_SHIFT 26
|
||||
|
||||
#define FEATURE_BAREWORD_FILEHANDLES_BIT 0x0001
|
||||
#define FEATURE_BITWISE_BIT 0x0002
|
||||
#define FEATURE_CLASS_BIT 0x0004
|
||||
#define FEATURE___SUB___BIT 0x0008
|
||||
#define FEATURE_MYREF_BIT 0x0010
|
||||
#define FEATURE_DEFER_BIT 0x0020
|
||||
#define FEATURE_EVALBYTES_BIT 0x0040
|
||||
#define FEATURE_MORE_DELIMS_BIT 0x0080
|
||||
#define FEATURE_FC_BIT 0x0100
|
||||
#define FEATURE_INDIRECT_BIT 0x0200
|
||||
#define FEATURE_ISA_BIT 0x0400
|
||||
#define FEATURE_MODULE_TRUE_BIT 0x0800
|
||||
#define FEATURE_MULTIDIMENSIONAL_BIT 0x1000
|
||||
#define FEATURE_POSTDEREF_QQ_BIT 0x2000
|
||||
#define FEATURE_REFALIASING_BIT 0x4000
|
||||
#define FEATURE_SAY_BIT 0x8000
|
||||
#define FEATURE_SIGNATURES_BIT 0x10000
|
||||
#define FEATURE_STATE_BIT 0x20000
|
||||
#define FEATURE_SWITCH_BIT 0x40000
|
||||
#define FEATURE_TRY_BIT 0x80000
|
||||
#define FEATURE_UNIEVAL_BIT 0x100000
|
||||
#define FEATURE_UNICODE_BIT 0x200000
|
||||
|
||||
#define FEATURE_BUNDLE_DEFAULT 0
|
||||
#define FEATURE_BUNDLE_510 1
|
||||
#define FEATURE_BUNDLE_511 2
|
||||
#define FEATURE_BUNDLE_515 3
|
||||
#define FEATURE_BUNDLE_523 4
|
||||
#define FEATURE_BUNDLE_527 5
|
||||
#define FEATURE_BUNDLE_535 6
|
||||
#define FEATURE_BUNDLE_537 7
|
||||
#define FEATURE_BUNDLE_539 8
|
||||
#define FEATURE_BUNDLE_CUSTOM (HINT_FEATURE_MASK >> HINT_FEATURE_SHIFT)
|
||||
|
||||
/* this is preserved for testing and asserts */
|
||||
#define OLD_CURRENT_HINTS \
|
||||
(PL_curcop == &PL_compiling ? PL_hints : PL_curcop->cop_hints)
|
||||
/* this is the same thing, but simpler (no if) as PL_hints expands
|
||||
to PL_compiling.cop_hints */
|
||||
#define CURRENT_HINTS \
|
||||
PL_curcop->cop_hints
|
||||
#define CURRENT_FEATURE_BUNDLE \
|
||||
((CURRENT_HINTS & HINT_FEATURE_MASK) >> HINT_FEATURE_SHIFT)
|
||||
|
||||
#define FEATURE_IS_ENABLED_MASK(mask) \
|
||||
((CURRENT_HINTS & HINT_LOCALIZE_HH) \
|
||||
? (PL_curcop->cop_features & (mask)) : FALSE)
|
||||
|
||||
/* The longest string we pass in. */
|
||||
#define MAX_FEATURE_LEN (sizeof("bareword_filehandles")-1)
|
||||
|
||||
#define FEATURE_FC_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_FC_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_ISA_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_535 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_ISA_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_SAY_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_SAY_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_TRY_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_539 \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_TRY_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_CLASS_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_CLASS_BIT) \
|
||||
)
|
||||
|
||||
#define FEATURE_DEFER_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_DEFER_BIT) \
|
||||
)
|
||||
|
||||
#define FEATURE_STATE_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_STATE_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_SWITCH_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_SWITCH_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_BITWISE_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_527 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_BITWISE_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_INDIRECT_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_INDIRECT_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_EVALBYTES_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_EVALBYTES_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_SIGNATURES_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_535 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_SIGNATURES_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE___SUB___IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE___SUB___BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_MODULE_TRUE_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_537 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_MODULE_TRUE_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_REFALIASING_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_REFALIASING_BIT) \
|
||||
)
|
||||
|
||||
#define FEATURE_POSTDEREF_QQ_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_523 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_POSTDEREF_QQ_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_UNIEVAL_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_UNIEVAL_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_MYREF_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_MYREF_BIT) \
|
||||
)
|
||||
|
||||
#define FEATURE_UNICODE_IS_ENABLED \
|
||||
( \
|
||||
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_511 && \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_UNICODE_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_MULTIDIMENSIONAL_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_MULTIDIMENSIONAL_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_BAREWORD_FILEHANDLES_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535 \
|
||||
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_BAREWORD_FILEHANDLES_BIT)) \
|
||||
)
|
||||
|
||||
#define FEATURE_MORE_DELIMS_IS_ENABLED \
|
||||
( \
|
||||
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
|
||||
FEATURE_IS_ENABLED_MASK(FEATURE_MORE_DELIMS_BIT) \
|
||||
)
|
||||
|
||||
|
||||
#define SAVEFEATUREBITS() SAVEI32(PL_compiling.cop_features)
|
||||
|
||||
#define CLEARFEATUREBITS() (PL_compiling.cop_features = 0)
|
||||
|
||||
#define FETCHFEATUREBITSHH(hh) S_fetch_feature_bits_hh(aTHX_ (hh))
|
||||
|
||||
#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.039),
|
||||
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
|
||||
? FEATURE_BUNDLE_539 :
|
||||
(sv_setnv(comp_ver, 5.037),
|
||||
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
|
||||
? FEATURE_BUNDLE_537 :
|
||||
(sv_setnv(comp_ver, 5.035),
|
||||
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
|
||||
? FEATURE_BUNDLE_535 :
|
||||
(sv_setnv(comp_ver, 5.027),
|
||||
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
|
||||
? FEATURE_BUNDLE_527 :
|
||||
(sv_setnv(comp_ver, 5.023),
|
||||
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
|
||||
? FEATURE_BUNDLE_523 :
|
||||
(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 */
|
||||
|
||||
#if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_CTL_C)
|
||||
|
||||
#define magic_sethint_feature(keysv, keypv, keylen, valsv, valbool) \
|
||||
S_magic_sethint_feature(aTHX_ (keysv), (keypv), (keylen), (valsv), (valbool))
|
||||
PERL_STATIC_INLINE void
|
||||
S_magic_sethint_feature(pTHX_ SV *keysv, const char *keypv, STRLEN keylen,
|
||||
SV *valsv, bool valbool) {
|
||||
if (keysv)
|
||||
keypv = SvPV_const(keysv, keylen);
|
||||
|
||||
if (memBEGINs(keypv, keylen, "feature_")) {
|
||||
const char *subf = keypv + (sizeof("feature_")-1);
|
||||
U32 mask = 0;
|
||||
switch (*subf) {
|
||||
case '_':
|
||||
if (keylen == sizeof("feature___SUB__")-1
|
||||
&& memcmp(subf+1, "_SUB__", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE___SUB___BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'b':
|
||||
if (keylen == sizeof("feature_bareword_filehandles")-1
|
||||
&& memcmp(subf+1, "areword_filehandles", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_BAREWORD_FILEHANDLES_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_bitwise")-1
|
||||
&& memcmp(subf+1, "itwise", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_BITWISE_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'c':
|
||||
if (keylen == sizeof("feature_class")-1
|
||||
&& memcmp(subf+1, "lass", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_CLASS_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'd':
|
||||
if (keylen == sizeof("feature_defer")-1
|
||||
&& memcmp(subf+1, "efer", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_DEFER_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'e':
|
||||
if (keylen == sizeof("feature_evalbytes")-1
|
||||
&& memcmp(subf+1, "valbytes", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_EVALBYTES_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'f':
|
||||
if (keylen == sizeof("feature_fc")-1
|
||||
&& memcmp(subf+1, "c", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_FC_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'i':
|
||||
if (keylen == sizeof("feature_indirect")-1
|
||||
&& memcmp(subf+1, "ndirect", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_INDIRECT_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_isa")-1
|
||||
&& memcmp(subf+1, "sa", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_ISA_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'm':
|
||||
if (keylen == sizeof("feature_module_true")-1
|
||||
&& memcmp(subf+1, "odule_true", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_MODULE_TRUE_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_more_delims")-1
|
||||
&& memcmp(subf+1, "ore_delims", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_MORE_DELIMS_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_multidimensional")-1
|
||||
&& memcmp(subf+1, "ultidimensional", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_MULTIDIMENSIONAL_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_myref")-1
|
||||
&& memcmp(subf+1, "yref", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_MYREF_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'p':
|
||||
if (keylen == sizeof("feature_postderef_qq")-1
|
||||
&& memcmp(subf+1, "ostderef_qq", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_POSTDEREF_QQ_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'r':
|
||||
if (keylen == sizeof("feature_refaliasing")-1
|
||||
&& memcmp(subf+1, "efaliasing", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_REFALIASING_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 's':
|
||||
if (keylen == sizeof("feature_say")-1
|
||||
&& memcmp(subf+1, "ay", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_SAY_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_signatures")-1
|
||||
&& memcmp(subf+1, "ignatures", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_SIGNATURES_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_state")-1
|
||||
&& memcmp(subf+1, "tate", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_STATE_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_switch")-1
|
||||
&& memcmp(subf+1, "witch", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_SWITCH_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 't':
|
||||
if (keylen == sizeof("feature_try")-1
|
||||
&& memcmp(subf+1, "ry", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_TRY_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
case 'u':
|
||||
if (keylen == sizeof("feature_unicode")-1
|
||||
&& memcmp(subf+1, "nicode", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_UNICODE_BIT;
|
||||
break;
|
||||
}
|
||||
else if (keylen == sizeof("feature_unieval")-1
|
||||
&& memcmp(subf+1, "nieval", keylen - sizeof("feature_")) == 0) {
|
||||
mask = FEATURE_UNIEVAL_BIT;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
if (valsv ? SvTRUE(valsv) : valbool)
|
||||
PL_compiling.cop_features |= mask;
|
||||
else
|
||||
PL_compiling.cop_features &= ~mask;
|
||||
}
|
||||
}
|
||||
#endif /* PERL_IN_MG_C */
|
||||
|
||||
/* subject to change */
|
||||
struct perl_feature_bit {
|
||||
const char *name;
|
||||
STRLEN namelen;
|
||||
U32 mask;
|
||||
};
|
||||
|
||||
#ifdef PERL_IN_PP_CTL_C
|
||||
|
||||
static const struct perl_feature_bit
|
||||
PL_feature_bits[] = {
|
||||
{
|
||||
/* feature bareword_filehandles */
|
||||
"feature_bareword_filehandles",
|
||||
STRLENs("feature_bareword_filehandles"),
|
||||
FEATURE_BAREWORD_FILEHANDLES_BIT
|
||||
},
|
||||
{
|
||||
/* feature bitwise */
|
||||
"feature_bitwise",
|
||||
STRLENs("feature_bitwise"),
|
||||
FEATURE_BITWISE_BIT
|
||||
},
|
||||
{
|
||||
/* feature class */
|
||||
"feature_class",
|
||||
STRLENs("feature_class"),
|
||||
FEATURE_CLASS_BIT
|
||||
},
|
||||
{
|
||||
/* feature current_sub */
|
||||
"feature___SUB__",
|
||||
STRLENs("feature___SUB__"),
|
||||
FEATURE___SUB___BIT
|
||||
},
|
||||
{
|
||||
/* feature declared_refs */
|
||||
"feature_myref",
|
||||
STRLENs("feature_myref"),
|
||||
FEATURE_MYREF_BIT
|
||||
},
|
||||
{
|
||||
/* feature defer */
|
||||
"feature_defer",
|
||||
STRLENs("feature_defer"),
|
||||
FEATURE_DEFER_BIT
|
||||
},
|
||||
{
|
||||
/* feature evalbytes */
|
||||
"feature_evalbytes",
|
||||
STRLENs("feature_evalbytes"),
|
||||
FEATURE_EVALBYTES_BIT
|
||||
},
|
||||
{
|
||||
/* feature extra_paired_delimiters */
|
||||
"feature_more_delims",
|
||||
STRLENs("feature_more_delims"),
|
||||
FEATURE_MORE_DELIMS_BIT
|
||||
},
|
||||
{
|
||||
/* feature fc */
|
||||
"feature_fc",
|
||||
STRLENs("feature_fc"),
|
||||
FEATURE_FC_BIT
|
||||
},
|
||||
{
|
||||
/* feature indirect */
|
||||
"feature_indirect",
|
||||
STRLENs("feature_indirect"),
|
||||
FEATURE_INDIRECT_BIT
|
||||
},
|
||||
{
|
||||
/* feature isa */
|
||||
"feature_isa",
|
||||
STRLENs("feature_isa"),
|
||||
FEATURE_ISA_BIT
|
||||
},
|
||||
{
|
||||
/* feature module_true */
|
||||
"feature_module_true",
|
||||
STRLENs("feature_module_true"),
|
||||
FEATURE_MODULE_TRUE_BIT
|
||||
},
|
||||
{
|
||||
/* feature multidimensional */
|
||||
"feature_multidimensional",
|
||||
STRLENs("feature_multidimensional"),
|
||||
FEATURE_MULTIDIMENSIONAL_BIT
|
||||
},
|
||||
{
|
||||
/* feature postderef_qq */
|
||||
"feature_postderef_qq",
|
||||
STRLENs("feature_postderef_qq"),
|
||||
FEATURE_POSTDEREF_QQ_BIT
|
||||
},
|
||||
{
|
||||
/* feature refaliasing */
|
||||
"feature_refaliasing",
|
||||
STRLENs("feature_refaliasing"),
|
||||
FEATURE_REFALIASING_BIT
|
||||
},
|
||||
{
|
||||
/* feature say */
|
||||
"feature_say",
|
||||
STRLENs("feature_say"),
|
||||
FEATURE_SAY_BIT
|
||||
},
|
||||
{
|
||||
/* feature signatures */
|
||||
"feature_signatures",
|
||||
STRLENs("feature_signatures"),
|
||||
FEATURE_SIGNATURES_BIT
|
||||
},
|
||||
{
|
||||
/* feature state */
|
||||
"feature_state",
|
||||
STRLENs("feature_state"),
|
||||
FEATURE_STATE_BIT
|
||||
},
|
||||
{
|
||||
/* feature switch */
|
||||
"feature_switch",
|
||||
STRLENs("feature_switch"),
|
||||
FEATURE_SWITCH_BIT
|
||||
},
|
||||
{
|
||||
/* feature try */
|
||||
"feature_try",
|
||||
STRLENs("feature_try"),
|
||||
FEATURE_TRY_BIT
|
||||
},
|
||||
{
|
||||
/* feature unicode_eval */
|
||||
"feature_unieval",
|
||||
STRLENs("feature_unieval"),
|
||||
FEATURE_UNIEVAL_BIT
|
||||
},
|
||||
{
|
||||
/* feature unicode_strings */
|
||||
"feature_unicode",
|
||||
STRLENs("feature_unicode"),
|
||||
FEATURE_UNICODE_BIT
|
||||
},
|
||||
{ NULL, 0, 0U }
|
||||
};
|
||||
|
||||
PERL_STATIC_INLINE void
|
||||
S_fetch_feature_bits_hh(pTHX_ HV *hh) {
|
||||
PL_compiling.cop_features = 0;
|
||||
|
||||
const struct perl_feature_bit *fb = PL_feature_bits;
|
||||
while (fb->name) {
|
||||
SV **svp = hv_fetch(hh, fb->name, (I32)fb->namelen, 0);
|
||||
if (svp && SvTRUE(*svp))
|
||||
PL_compiling.cop_features |= fb->mask;
|
||||
++fb;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* PERL_FEATURE_H_ */
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
27
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/form.h
Normal file
27
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/form.h
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
/* 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 <arg> literal chars */
|
||||
#define FF_SKIP 3 /* skip <arg> chars in format */
|
||||
#define FF_FETCH 4 /* get next item and set field size to <arg> */
|
||||
#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 <arg>=(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 ^* */
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
/**************************************************************************
|
||||
* 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*/
|
||||
|
||||
326
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/gv.h
Normal file
326
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/gv.h
Normal file
|
|
@ -0,0 +1,326 @@
|
|||
/* 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 gp_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 */
|
||||
PERL_BITFIELD32 gp_line:31; /* line first declared at (for -w) */
|
||||
PERL_BITFIELD32 gp_flags:1;
|
||||
HEK * gp_file_hek; /* file first declared in (for -w) */
|
||||
};
|
||||
|
||||
#define GvXPVGV(gv) ((XPVGV*)SvANY(gv))
|
||||
|
||||
|
||||
#if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) && !defined(__INTEL_COMPILER)
|
||||
# define GvGP(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);})))
|
||||
# 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); \
|
||||
&(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)
|
||||
|
||||
/*
|
||||
=for apidoc Am|SV*|GvSV|GV* gv
|
||||
|
||||
Return the SV from the GV.
|
||||
|
||||
Prior to Perl v5.9.3, this would add a scalar if none existed. Nowadays, use
|
||||
C<L</GvSVn>> for that, or compile perl with S<C<-DPERL_CREATE_GVSV>>. See
|
||||
L<perl5100delta>.
|
||||
|
||||
=for apidoc Am|SV*|GvSVn|GV* gv
|
||||
Like C<L</GvSV>>, but creates an empty scalar if none already exists.
|
||||
|
||||
=for apidoc Am|AV*|GvAV|GV* gv
|
||||
|
||||
Return the AV from the GV.
|
||||
|
||||
=for apidoc Am|HV*|GvHV|GV* gv
|
||||
|
||||
Return the HV from the GV.
|
||||
|
||||
=for apidoc Am|CV*|GvCV|GV* gv
|
||||
|
||||
Return the CV 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) ((CV*)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 GvGPFLAGS(gv) (GvGP(gv)->gp_flags)
|
||||
|
||||
#define GvLINE(gv) (GvGP(gv)->gp_line)
|
||||
#define GvFILE_HEK(gv) (GvGP(gv)->gp_file_hek)
|
||||
#define GvFILEx(gv) HEK_KEY(GvFILE_HEK(gv))
|
||||
#define GvFILE(gv) (GvFILE_HEK(gv) ? GvFILEx(gv) : NULL)
|
||||
#define GvFILEGV(gv) (GvFILE_HEK(gv) ? gv_fetchfile(GvFILEx(gv)) : NULL)
|
||||
|
||||
#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)
|
||||
|
||||
/* GVf_INTRO is one-shot flag which indicates that the next assignment
|
||||
of a reference to the glob is to be localised; it distinguishes
|
||||
'local *g = $ref' from '*g = $ref'.
|
||||
|
||||
GVf_MULTI is used to implement the "used only once" warning. It is
|
||||
always set on a glob when an existing name is referenced, and when
|
||||
a name is created when the warning is disabled. A post parse scan
|
||||
in gv_check() then reports any names where this isn't set.
|
||||
|
||||
GVf_ONCE_FATAL is set on a glob when it is created and fatal "used
|
||||
only once" warnings are enabled, since PL_curcop no longer has the
|
||||
fatal flag set at the point where the warnings are reported.
|
||||
*/
|
||||
#define GVf_INTRO 0x01
|
||||
#define GVf_MULTI 0x02
|
||||
#define GVf_ASSUMECV 0x04
|
||||
#define GVf_RESERVED 0x08 /* unused */
|
||||
#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 GVf_ONCE_FATAL 0x100
|
||||
|
||||
#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 GvONCE_FATAL(gv) (GvFLAGS(gv) & GVf_ONCE_FATAL)
|
||||
#define GvONCE_FATAL_on(gv) (GvFLAGS(gv) |= GVf_ONCE_FATAL)
|
||||
#define GvONCE_FATAL_off(gv) (GvFLAGS(gv) &= ~GVf_ONCE_FATAL)
|
||||
|
||||
#ifndef PERL_CORE
|
||||
# define GvIN_PAD(gv) 0
|
||||
# define GvIN_PAD_on(gv) NOOP
|
||||
# define GvIN_PAD_off(gv) NOOP
|
||||
# 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 */
|
||||
/* 0x08 UNUSED */
|
||||
#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) */
|
||||
#define GV_CACHE_ONLY 0x1000 /* return stash only if found in cache;
|
||||
used only in flags parameter to gv_stash* family */
|
||||
|
||||
/* Flags for gv_fetchmeth_pvn and gv_autoload_pvn*/
|
||||
#define GV_SUPER 0x1000 /* SUPER::method */
|
||||
#define GV_NOUNIVERSAL 0x2000 /* Skip UNIVERSAL lookup */
|
||||
|
||||
/* 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) */
|
||||
|
||||
/* gv_fetchfile_flags() */
|
||||
#define GVF_NOADD 0x01 /* don't add the glob if it doesn't exist */
|
||||
|
||||
#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*cBOOL(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)
|
||||
|
||||
/*
|
||||
=for apidoc gv_autoload4
|
||||
Equivalent to C<L</gv_autoload_pvn>>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
#define gv_autoload4(stash, name, len, autoload) \
|
||||
gv_autoload_pvn(stash, name, len, cBOOL(autoload))
|
||||
#define newGVgen(pack) newGVgen_flags(pack, 0)
|
||||
#define gv_method_changed(gv) \
|
||||
( \
|
||||
assert_(isGV_with_GP(gv)) \
|
||||
GvREFCNT(gv) > 1 \
|
||||
? (void)++PL_sub_generation \
|
||||
: mro_method_changed_in(GvSTASH(gv)) \
|
||||
)
|
||||
|
||||
/*
|
||||
=for apidoc gv_AVadd
|
||||
=for apidoc_item gv_HVadd
|
||||
=for apidoc_item gv_IOadd
|
||||
=for apidoc_item gv_SVadd
|
||||
|
||||
Make sure there is a slot of the given type (AV, HV, IO, SV) in the GV C<gv>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#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)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
3148
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/handy.h
Normal file
3148
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/handy.h
Normal file
File diff suppressed because it is too large
Load diff
711
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv.h
Normal file
711
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv.h
Normal file
|
|
@ -0,0 +1,711 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/* These control hash traversal randomization and the environment variable PERL_PERTURB_KEYS.
|
||||
* Currently disabling this functionality will break a few tests, but should otherwise work fine.
|
||||
* See perlrun for more details. */
|
||||
|
||||
#if defined(PERL_PERTURB_KEYS_DISABLED)
|
||||
# define PL_HASH_RAND_BITS_ENABLED 0
|
||||
# define PERL_HASH_ITER_BUCKET(iter) ((iter)->xhv_riter)
|
||||
#else
|
||||
# define PERL_HASH_RANDOMIZE_KEYS 1
|
||||
# if defined(PERL_PERTURB_KEYS_RANDOM)
|
||||
# define PL_HASH_RAND_BITS_ENABLED 1
|
||||
# elif defined(PERL_PERTURB_KEYS_DETERMINISTIC)
|
||||
# define PL_HASH_RAND_BITS_ENABLED 2
|
||||
# else
|
||||
# define USE_PERL_PERTURB_KEYS 1
|
||||
# define PL_HASH_RAND_BITS_ENABLED PL_hash_rand_bits_enabled
|
||||
# endif
|
||||
# define PERL_HASH_ITER_BUCKET(iter) (((iter)->xhv_riter) ^ ((iter)->xhv_rand))
|
||||
#endif
|
||||
|
||||
#ifdef PERL_USE_UNSHARED_KEYS_IN_LARGE_HASHES
|
||||
#define LARGE_HASH_HEURISTIC(hv,new_max) S_large_hash_heuristic(aTHX_ (hv), (new_max))
|
||||
#else
|
||||
#define LARGE_HASH_HEURISTIC(hv,new_max) 0
|
||||
#endif
|
||||
|
||||
|
||||
/* 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; /* computed hash of key */
|
||||
I32 hek_len; /* length of the hash key */
|
||||
/* Be careful! Sometimes we store a pointer in the hek_key
|
||||
* buffer, which means it must be 8 byte aligned or things
|
||||
* dont work on aligned platforms like HPUX
|
||||
* Also beware, the last byte of the hek_key buffer is a
|
||||
* hidden flags byte about the 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 or WAS-UTF-8, or an SV */
|
||||
};
|
||||
|
||||
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_core.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 */
|
||||
HV *super; /* SUPER method cache */
|
||||
CV *destroy; /* DESTROY method if destroy_gen non-zero */
|
||||
U32 destroy_gen; /* Generation number of DESTROY cache */
|
||||
};
|
||||
|
||||
#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 */
|
||||
};
|
||||
|
||||
/* A struct defined by pad.h and used within class.c */
|
||||
struct suspended_compcv;
|
||||
|
||||
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;
|
||||
#ifdef PERL_HASH_RANDOMIZE_KEYS
|
||||
U32 xhv_rand; /* random value for hash traversal */
|
||||
U32 xhv_last_rand; /* last random value for hash traversal,
|
||||
used to detect each() after insert for warnings */
|
||||
#endif
|
||||
U32 xhv_aux_flags; /* assorted extra flags */
|
||||
|
||||
/* The following fields are only valid if we have the flag HvAUXf_IS_CLASS */
|
||||
HV *xhv_class_superclass; /* STASH of the :isa() base class */
|
||||
CV *xhv_class_initfields_cv; /* CV for running initfields */
|
||||
AV *xhv_class_adjust_blocks; /* CVs containing the ADJUST blocks */
|
||||
PADNAMELIST *xhv_class_fields; /* PADNAMEs with PadnameIsFIELD() */
|
||||
PADOFFSET xhv_class_next_fieldix;
|
||||
HV *xhv_class_param_map; /* Maps param names to field index stored in UV */
|
||||
|
||||
struct suspended_compcv
|
||||
*xhv_class_suspended_initfields_compcv;
|
||||
};
|
||||
|
||||
#define HvAUXf_SCAN_STASH 0x1 /* stash is being scanned by gv_check */
|
||||
#define HvAUXf_NO_DEREF 0x2 /* @{}, %{} etc (and nomethod) not present */
|
||||
#define HvAUXf_IS_CLASS 0x4 /* the package is a 'class' */
|
||||
|
||||
#define HvSTASH_IS_CLASS(hv) \
|
||||
(HvHasAUX(hv) && HvAUX(hv)->xhv_aux_flags & HvAUXf_IS_CLASS)
|
||||
|
||||
/* 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 */
|
||||
};
|
||||
|
||||
struct xpvhv_with_aux {
|
||||
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 */
|
||||
struct xpvhv_aux xhv_aux;
|
||||
};
|
||||
|
||||
/*
|
||||
=for apidoc AmnU||HEf_SVKEY
|
||||
This flag, used in the length slot of hash entries and magic structures,
|
||||
specifies the structure contains an C<SV*> pointer where a C<char*> pointer
|
||||
is to be expected. (For information only--not to be used).
|
||||
|
||||
=for apidoc ADmnU||Nullhv
|
||||
Null HV pointer.
|
||||
|
||||
(deprecated - use C<(HV *)NULL> instead)
|
||||
|
||||
=for apidoc Am|char*|HvNAME|HV* stash
|
||||
Returns the package name of a stash, or C<NULL> if C<stash> isn't a stash.
|
||||
See C<L</SvSTASH>>, C<L</CvSTASH>>.
|
||||
|
||||
=for apidoc Am|STRLEN|HvNAMELEN|HV *stash
|
||||
Returns the length of the stash's name.
|
||||
|
||||
Disfavored forms of HvNAME and HvNAMELEN; suppress mention of them
|
||||
=for apidoc Cmh|char*|HvNAME_get|HV* stash
|
||||
=for apidoc Amh|I32|HvNAMELEN_get|HV* stash
|
||||
|
||||
=for apidoc Am|unsigned char|HvNAMEUTF8|HV *stash
|
||||
Returns true if the name is in UTF-8 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<HvNAME> 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 UTF-8 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<char*> or C<SV*>, depending on the value of
|
||||
C<HeKLEN()>. Can be assigned to. The C<HePV()> or C<HeSVKEY()> 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<HEf_SVKEY>, it indicates the entry
|
||||
holds an C<SV*> key. Otherwise, holds the actual length of the key. Can
|
||||
be assigned to. The C<HePV()> macro is usually preferable for finding key
|
||||
lengths.
|
||||
|
||||
=for apidoc Am|SV*|HeVAL|HE* he
|
||||
Returns the value slot (type C<SV*>)
|
||||
stored in the hash entry. Can be assigned
|
||||
to.
|
||||
|
||||
SV *foo= HeVAL(hv);
|
||||
HeVAL(hv)= sv;
|
||||
|
||||
|
||||
=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<char*> value, doing any
|
||||
necessary dereferencing of possibly C<SV*> keys. The length of the string
|
||||
is placed in C<len> (this is a macro, so do I<not> use C<&len>). If you do
|
||||
not care about what the length of the key is, you may use the global
|
||||
variable C<PL_na>, 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<strlen()> or similar is not a good way to find
|
||||
the length of hash keys. This is very similar to the C<SvPV()> macro
|
||||
described elsewhere in this document. See also C<L</HeUTF8>>.
|
||||
|
||||
If you are using C<HePV> to get values to pass to C<newSVpvn()> to create a
|
||||
new SV, you should consider using C<newSVhek(HeKEY_hek(he))> as it is more
|
||||
efficient.
|
||||
|
||||
=for apidoc Am|U32|HeUTF8|HE* he
|
||||
Returns whether the C<char *> value returned by C<HePV> is encoded in UTF-8,
|
||||
doing any necessary dereferencing of possibly C<SV*> keys. The value returned
|
||||
will be 0 or non-0, not necessarily 1 (or even a value with any low bits set),
|
||||
so B<do not> blindly assign this to a C<bool> variable, as C<bool> may be a
|
||||
typedef for C<char>.
|
||||
|
||||
=for apidoc Am|SV*|HeSVKEY|HE* he
|
||||
Returns the key as an C<SV*>, or C<NULL> if the hash entry does not
|
||||
contain an C<SV*> key.
|
||||
|
||||
=for apidoc Am|SV*|HeSVKEY_force|HE* he
|
||||
Returns the key as an C<SV*>. Will create and return a temporary mortal
|
||||
C<SV*> if the hash entry contains only a C<char*> key.
|
||||
|
||||
=for apidoc Am|SV*|HeSVKEY_set|HE* he|SV* sv
|
||||
Sets the key to a given C<SV*>, taking care to set the appropriate flags to
|
||||
indicate the presence of an C<SV*> key, and returns the same
|
||||
C<SV*>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#define PERL_HASH_DEFAULT_HvMAX 7
|
||||
|
||||
/* 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)
|
||||
|
||||
/*
|
||||
|
||||
=for apidoc Am|STRLEN|HvFILL|HV *const hv
|
||||
|
||||
Returns the number of hash buckets that happen to be in use.
|
||||
|
||||
As of perl 5.25 this function is used only for debugging
|
||||
purposes, and the number of used hash buckets is not
|
||||
in any way cached, thus this function can be costly
|
||||
to execute as it must iterate over all the buckets in the
|
||||
hash.
|
||||
|
||||
=cut
|
||||
|
||||
*/
|
||||
|
||||
#define HvFILL(hv) Perl_hv_fill(aTHX_ MUTABLE_HV(hv))
|
||||
#define HvMAX(hv) ((XPVHV*) SvANY(hv))->xhv_max
|
||||
|
||||
/*
|
||||
|
||||
=for apidoc Am|bool|HvHasAUX|HV *const hv
|
||||
|
||||
Returns true if the HV has a C<struct xpvhv_aux> extension. Use this to check
|
||||
whether it is valid to call C<HvAUX()>.
|
||||
|
||||
=cut
|
||||
|
||||
*/
|
||||
#define HvHasAUX(hv) (SvFLAGS(hv) & SVphv_HasAUX)
|
||||
|
||||
/* This quite intentionally does no flag checking first. That's your
|
||||
responsibility. Use HvHasAUX() first */
|
||||
#define HvAUX(hv) (&(((struct xpvhv_with_aux*) SvANY(hv))->xhv_aux))
|
||||
#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) (HvHasAUX(hv) ? HvAUX(hv)->xhv_riter : -1)
|
||||
#define HvEITER_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_eiter : NULL)
|
||||
#define HvRAND_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_rand : 0)
|
||||
#define HvLASTRAND_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_last_rand : 0)
|
||||
|
||||
#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) \
|
||||
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvNAME_HEK_NN(hv) : NULL)
|
||||
#define HvHasNAME(hv) \
|
||||
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv))
|
||||
#define HvNAME_get(hv) \
|
||||
(HvHasNAME(hv) ? HEK_KEY(HvNAME_HEK_NN(hv)) : NULL)
|
||||
#define HvNAMELEN_get(hv) \
|
||||
((HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
|
||||
? HEK_LEN(HvNAME_HEK_NN(hv)) : 0)
|
||||
#define HvNAMEUTF8(hv) \
|
||||
((HvHasAUX(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 HvHasENAME_HEK(hv) \
|
||||
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name)
|
||||
#define HvENAME_HEK(hv) \
|
||||
(HvHasENAME_HEK(hv) ? HvENAME_HEK_NN(hv) : NULL)
|
||||
#define HvHasENAME(hv) \
|
||||
(HvHasENAME_HEK(hv) && HvAUX(hv)->xhv_name_count != -1)
|
||||
#define HvENAME_get(hv) \
|
||||
(HvHasENAME(hv) ? HEK_KEY(HvENAME_HEK_NN(hv)) : NULL)
|
||||
#define HvENAMELEN_get(hv) \
|
||||
(HvHasENAME(hv) ? HEK_LEN(HvENAME_HEK_NN(hv)) : 0)
|
||||
#define HvENAMEUTF8(hv) \
|
||||
(HvHasENAME(hv) ? HEK_UTF8(HvENAME_HEK_NN(hv)) : 0)
|
||||
|
||||
/*
|
||||
* 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) (((XPVHV*) SvANY(hv))->xhv_keys)
|
||||
#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)
|
||||
|
||||
/* This (now) flags whether *new* keys in the hash will be allocated from the
|
||||
* shared string table. We have a heuristic to call HvSHAREKEYS_off() if a hash
|
||||
* is "getting large". After which, the first keys in that hash will be from
|
||||
* the shared string table, but subsequent keys will not be.
|
||||
*
|
||||
* If we didn't do this, we'd have to reallocate all keys when we switched this
|
||||
* flag, which would be work for no real gain. */
|
||||
#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)
|
||||
|
||||
#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 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 | \
|
||||
( HeKUTF8(he) ? SVf_UTF8 : 0 ))) : \
|
||||
&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_NOTSHARED 0x04 /* This key isn't a shared hash key. */
|
||||
/* the following flags are options for functions, they are not stored in heks */
|
||||
#define HVhek_FREEKEY 0x100 /* Internal flag to say key is Newx()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_ENABLEHVKFLAGS (HVhek_UTF8|HVhek_WASUTF8)
|
||||
|
||||
#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)
|
||||
|
||||
/* 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) \
|
||||
cBOOL(hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash)))
|
||||
#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) \
|
||||
cBOOL(hv_common_key_len((hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0))
|
||||
|
||||
#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)))
|
||||
|
||||
/* Provide 's' suffix subs for constant strings (and avoid needing to count
|
||||
* chars). See STR_WITH_LEN in handy.h - because these are macros we cant use
|
||||
* STR_WITH_LEN to do the work, we have to unroll it. */
|
||||
#define hv_existss(hv, key) \
|
||||
hv_exists((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1))
|
||||
|
||||
#define hv_fetchs(hv, key, lval) \
|
||||
hv_fetch((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (lval))
|
||||
|
||||
#define hv_deletes(hv, key, flags) \
|
||||
hv_delete((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (flags))
|
||||
|
||||
#define hv_name_sets(hv, name, flags) \
|
||||
hv_name_set((hv),ASSERT_IS_LITERAL(name),(sizeof(name)-1), flags)
|
||||
|
||||
#define hv_stores(hv, key, val) \
|
||||
hv_store((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (val), 0)
|
||||
|
||||
#ifdef PERL_CORE
|
||||
# define hv_storehek(hv, hek, val) \
|
||||
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
|
||||
HV_FETCH_ISSTORE|HV_FETCH_JUST_SV, (val), HEK_HASH(hek))
|
||||
# define hv_fetchhek(hv, hek, lval) \
|
||||
((SV **) \
|
||||
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
|
||||
(lval) \
|
||||
? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \
|
||||
: HV_FETCH_JUST_SV, \
|
||||
NULL, HEK_HASH(hek)))
|
||||
# define hv_deletehek(hv, hek, flags) \
|
||||
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
|
||||
(flags)|HV_DELETE, NULL, HEK_HASH(hek))
|
||||
#define hv_existshek(hv, hek) \
|
||||
cBOOL(hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
|
||||
HV_FETCH_ISEXISTS, NULL, HEK_HASH(hek)))
|
||||
#endif
|
||||
|
||||
/* 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
|
||||
#define REFCOUNTED_HE_EXISTS 0x00000002
|
||||
|
||||
#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|"key"|U32 flags
|
||||
|
||||
Like L</refcounted_he_fetch_pvn>, 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|"key"|SV *value|U32 flags
|
||||
|
||||
Like L</refcounted_he_new_pvn>, 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))
|
||||
|
||||
#include "hv_func.h"
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
189
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_func.h
Normal file
189
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_func.h
Normal file
|
|
@ -0,0 +1,189 @@
|
|||
/* hash a key
|
||||
*--------------------------------------------------------------------------------------
|
||||
* 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
|
||||
* (see also perl.c:perl_parse() and S_init_tls_and_interp() and util.c:get_hash_seed())
|
||||
*/
|
||||
#ifndef PERL_SEEN_HV_FUNC_H_ /* compile once */
|
||||
#define PERL_SEEN_HV_FUNC_H_
|
||||
#include "hv_macro.h"
|
||||
|
||||
#if !( 0 \
|
||||
|| defined(PERL_HASH_FUNC_SIPHASH) \
|
||||
|| defined(PERL_HASH_FUNC_SIPHASH13) \
|
||||
|| defined(PERL_HASH_FUNC_ZAPHOD32) \
|
||||
)
|
||||
# ifdef CAN64BITHASH
|
||||
# define PERL_HASH_FUNC_SIPHASH13
|
||||
# else
|
||||
# define PERL_HASH_FUNC_ZAPHOD32
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef PERL_HASH_USE_SBOX32_ALSO
|
||||
# if defined(PERL_HASH_USE_SBOX32) || !defined(PERL_HASH_NO_SBOX32)
|
||||
# define PERL_HASH_USE_SBOX32_ALSO 1
|
||||
# else
|
||||
# define PERL_HASH_USE_SBOX32_ALSO 0
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#undef PERL_HASH_USE_SBOX32
|
||||
#undef PERL_HASH_NO_SBOX32
|
||||
#if PERL_HASH_USE_SBOX32_ALSO != 0
|
||||
# define PERL_HASH_USE_SBOX32
|
||||
#else
|
||||
# define PERL_HASH_NO_SBOX32
|
||||
#endif
|
||||
|
||||
#ifndef SBOX32_MAX_LEN
|
||||
#define SBOX32_MAX_LEN 24
|
||||
#endif
|
||||
|
||||
/* this must be after the SBOX32_MAX_LEN define */
|
||||
#include "sbox32_hash.h"
|
||||
|
||||
#if defined(PERL_HASH_FUNC_SIPHASH)
|
||||
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_SIPHASH"
|
||||
# define PVT__PERL_HASH_FUNC "SIPHASH_2_4"
|
||||
# define PVT__PERL_HASH_WORD_TYPE U64
|
||||
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
|
||||
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 2)
|
||||
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 4)
|
||||
# define PVT__PERL_HASH_SEED_STATE(seed,state) S_perl_siphash_seed_state(seed,state)
|
||||
# define PVT__PERL_HASH_WITH_STATE(state,str,len) S_perl_hash_siphash_2_4_with_state((state),(U8*)(str),(len))
|
||||
#elif defined(PERL_HASH_FUNC_SIPHASH13)
|
||||
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_SIPHASH13"
|
||||
# define PVT__PERL_HASH_FUNC "SIPHASH_1_3"
|
||||
# define PVT__PERL_HASH_WORD_TYPE U64
|
||||
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
|
||||
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 2)
|
||||
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 4)
|
||||
# define PVT__PERL_HASH_SEED_STATE(seed,state) S_perl_siphash_seed_state(seed,state)
|
||||
# define PVT__PERL_HASH_WITH_STATE(state,str,len) S_perl_hash_siphash_1_3_with_state((state),(const U8*)(str),(len))
|
||||
#elif defined(PERL_HASH_FUNC_ZAPHOD32)
|
||||
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_ZAPHOD32"
|
||||
# define PVT__PERL_HASH_FUNC "ZAPHOD32"
|
||||
# define PVT__PERL_HASH_WORD_TYPE U32
|
||||
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
|
||||
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 3)
|
||||
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 3)
|
||||
# define PVT__PERL_HASH_SEED_STATE(seed,state) zaphod32_seed_state(seed,state)
|
||||
# define PVT__PERL_HASH_WITH_STATE(state,str,len) (U32)zaphod32_hash_with_state((state),(U8*)(str),(len))
|
||||
# include "zaphod32_hash.h"
|
||||
#endif
|
||||
|
||||
#ifndef PVT__PERL_HASH_WITH_STATE
|
||||
#error "No hash function defined!"
|
||||
#endif
|
||||
#ifndef PVT__PERL_HASH_SEED_BYTES
|
||||
#error "PVT__PERL_HASH_SEED_BYTES not defined"
|
||||
#endif
|
||||
#ifndef PVT__PERL_HASH_FUNC
|
||||
#error "PVT__PERL_HASH_FUNC not defined"
|
||||
#endif
|
||||
|
||||
/* Some siphash static functions are needed by XS::APItest even when
|
||||
siphash isn't the current hash. For SipHash builds this needs to
|
||||
be before the S_perl_hash_with_seed() definition.
|
||||
*/
|
||||
#include "perl_siphash.h"
|
||||
|
||||
#define PVT__PERL_HASH_SEED_roundup(x, y) ( ( ( (x) + ( (y) - 1 ) ) / (y) ) * (y) )
|
||||
#define PVT_PERL_HASH_SEED_roundup(x) PVT__PERL_HASH_SEED_roundup(x,PVT__PERL_HASH_WORD_SIZE)
|
||||
|
||||
#define PL_hash_seed ((U8 *)PL_hash_seed_w)
|
||||
#define PL_hash_state ((U8 *)PL_hash_state_w)
|
||||
|
||||
#if PERL_HASH_USE_SBOX32_ALSO == 0
|
||||
# define PVT_PERL_HASH_FUNC PVT__PERL_HASH_FUNC
|
||||
# define PVT_PERL_HASH_SEED_BYTES PVT__PERL_HASH_SEED_BYTES
|
||||
# define PVT_PERL_HASH_STATE_BYTES PVT__PERL_HASH_STATE_BYTES
|
||||
# define PVT_PERL_HASH_SEED_STATE(seed,state) PVT__PERL_HASH_SEED_STATE(seed,state)
|
||||
# define PVT_PERL_HASH_WITH_STATE(state,str,len) PVT__PERL_HASH_WITH_STATE(state,str,len)
|
||||
#else
|
||||
|
||||
#define PVT_PERL_HASH_FUNC "SBOX32_WITH_" PVT__PERL_HASH_FUNC
|
||||
/* note the 4 in the below code comes from the fact the seed to initialize the SBOX is 128 bits */
|
||||
#define PVT_PERL_HASH_SEED_BYTES ( PVT__PERL_HASH_SEED_BYTES + (int)( 4 * sizeof(U32)) )
|
||||
|
||||
#define PVT_PERL_HASH_STATE_BYTES \
|
||||
( PVT__PERL_HASH_STATE_BYTES + ( ( 1 + ( 256 * SBOX32_MAX_LEN ) ) * sizeof(U32) ) )
|
||||
|
||||
#define PVT_PERL_HASH_SEED_STATE(seed,state) STMT_START { \
|
||||
PVT__PERL_HASH_SEED_STATE(seed,state); \
|
||||
sbox32_seed_state128(seed + PVT__PERL_HASH_SEED_BYTES, state + PVT__PERL_HASH_STATE_BYTES); \
|
||||
} STMT_END
|
||||
|
||||
#define PVT_PERL_HASH_WITH_STATE(state,str,len) \
|
||||
(LIKELY(len <= SBOX32_MAX_LEN) \
|
||||
? sbox32_hash_with_state((state + PVT__PERL_HASH_STATE_BYTES),(const U8*)(str),(len)) \
|
||||
: PVT__PERL_HASH_WITH_STATE((state),(str),(len)))
|
||||
|
||||
#endif
|
||||
|
||||
#define PERL_HASH_WITH_SEED(seed,hash,str,len) \
|
||||
(hash) = S_perl_hash_with_seed((const U8 *) seed, (const U8 *) str,len)
|
||||
#define PERL_HASH_WITH_STATE(state,hash,str,len) \
|
||||
(hash) = PVT_PERL_HASH_WITH_STATE((state),(const U8*)(str),(len))
|
||||
|
||||
#define PERL_HASH_SEED_STATE(seed,state) PVT_PERL_HASH_SEED_STATE(seed,state)
|
||||
#define PERL_HASH_SEED_BYTES PVT_PERL_HASH_SEED_roundup(PVT_PERL_HASH_SEED_BYTES)
|
||||
#define PERL_HASH_STATE_BYTES PVT_PERL_HASH_SEED_roundup(PVT_PERL_HASH_STATE_BYTES)
|
||||
#define PERL_HASH_FUNC PVT_PERL_HASH_FUNC
|
||||
|
||||
#define PERL_HASH_SEED_WORDS (PERL_HASH_SEED_BYTES/PVT__PERL_HASH_WORD_SIZE)
|
||||
#define PERL_HASH_STATE_WORDS (PERL_HASH_STATE_BYTES/PVT__PERL_HASH_WORD_SIZE)
|
||||
|
||||
#ifdef PERL_USE_SINGLE_CHAR_HASH_CACHE
|
||||
#define PERL_HASH(state,str,len) \
|
||||
(hash) = ((len) < 2 ? ( (len) == 0 ? PL_hash_chars[256] : PL_hash_chars[(U8)(str)[0]] ) \
|
||||
: PVT_PERL_HASH_WITH_STATE(PL_hash_state,(U8*)(str),(len)))
|
||||
#else
|
||||
#define PERL_HASH(hash,str,len) \
|
||||
PERL_HASH_WITH_STATE(PL_hash_state,hash,(U8*)(str),(len))
|
||||
#endif
|
||||
|
||||
/* Setup the hash seed, either we do things dynamically at start up,
|
||||
* including reading from the environment, or we randomly setup the
|
||||
* seed. The seed will be passed into the PERL_HASH_SEED_STATE() function
|
||||
* defined for the configuration defined for this perl, which will then
|
||||
* initialize whatever state it might need later in hashing. */
|
||||
|
||||
#ifndef PERL_HASH_SEED
|
||||
# if defined(USE_HASH_SEED)
|
||||
# define PERL_HASH_SEED PL_hash_seed
|
||||
# else
|
||||
/* this is a 512 bit seed, which should be more than enough for the
|
||||
* configuration of any of our hash functions (with or without sbox).
|
||||
* If you actually use a hard coded seed, you are strongly encouraged
|
||||
* to replace this with something else of the correct length
|
||||
* for the hash function you are using (24-32 bytes depending on build
|
||||
* options). Repeat, you are *STRONGLY* encouraged not to use the value
|
||||
* provided here.
|
||||
*/
|
||||
# define PERL_HASH_SEED \
|
||||
((const U8 *)"A long string of pseudorandomly " \
|
||||
"chosen bytes for hashing in Perl")
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* legacy - only mod_perl should be doing this. */
|
||||
#ifdef PERL_HASH_INTERNAL_ACCESS
|
||||
#define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH(hash,str,len)
|
||||
#endif
|
||||
|
||||
PERL_STATIC_INLINE U32
|
||||
S_perl_hash_with_seed(const U8 * seed, const U8 *str, STRLEN len) {
|
||||
PVT__PERL_HASH_WORD_TYPE state[PERL_HASH_STATE_WORDS];
|
||||
PVT_PERL_HASH_SEED_STATE(seed,(U8*)state);
|
||||
return PVT_PERL_HASH_WITH_STATE((U8*)state,str,len);
|
||||
}
|
||||
|
||||
#endif /*compile once*/
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
85
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_macro.h
Normal file
85
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_macro.h
Normal file
|
|
@ -0,0 +1,85 @@
|
|||
#ifndef PERL_SEEN_HV_MACRO_H_ /* compile once */
|
||||
#define PERL_SEEN_HV_MACRO_H_
|
||||
|
||||
#if IVSIZE == 8
|
||||
#define CAN64BITHASH
|
||||
#endif
|
||||
|
||||
#ifdef CAN64BITHASH
|
||||
#ifndef U64TYPE
|
||||
/* This probably isn't going to work, but failing with a compiler error due to
|
||||
lack of uint64_t is no worse than failing right now with an #error. */
|
||||
#define U64 uint64_t
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Endianess and util macros
|
||||
*
|
||||
* The following 3 macros are defined in this section. The other macros defined
|
||||
* are only needed to help derive these 3.
|
||||
*
|
||||
* U8TO16_LE(x) Read a little endian unsigned 16-bit int
|
||||
* U8TO32_LE(x) Read a little endian unsigned 32-bit int
|
||||
* U8TO64_LE(x) Read a little endian unsigned 64-bit int
|
||||
* ROTL32(x,r) Rotate x left by r bits
|
||||
* ROTL64(x,r) Rotate x left by r bits
|
||||
* ROTR32(x,r) Rotate x right by r bits
|
||||
* ROTR64(x,r) Rotate x right by r bits
|
||||
*/
|
||||
|
||||
#ifndef U8TO16_LE
|
||||
#define _shifted_octet(type,ptr,idx,shift) (((type)(((const U8*)(ptr))[(idx)]))<<(shift))
|
||||
#if defined(USE_UNALIGNED_PTR_DEREF) && (BYTEORDER == 0x1234 || BYTEORDER == 0x12345678)
|
||||
#define U8TO16_LE(ptr) (*((const U16*)(ptr)))
|
||||
#define U8TO32_LE(ptr) (*((const U32*)(ptr)))
|
||||
#define U8TO64_LE(ptr) (*((const U64*)(ptr)))
|
||||
#else
|
||||
#define U8TO16_LE(ptr) (_shifted_octet(U16,(ptr),0, 0)|\
|
||||
_shifted_octet(U16,(ptr),1, 8))
|
||||
|
||||
#define U8TO32_LE(ptr) (_shifted_octet(U32,(ptr),0, 0)|\
|
||||
_shifted_octet(U32,(ptr),1, 8)|\
|
||||
_shifted_octet(U32,(ptr),2,16)|\
|
||||
_shifted_octet(U32,(ptr),3,24))
|
||||
|
||||
#define U8TO64_LE(ptr) (_shifted_octet(U64,(ptr),0, 0)|\
|
||||
_shifted_octet(U64,(ptr),1, 8)|\
|
||||
_shifted_octet(U64,(ptr),2,16)|\
|
||||
_shifted_octet(U64,(ptr),3,24)|\
|
||||
_shifted_octet(U64,(ptr),4,32)|\
|
||||
_shifted_octet(U64,(ptr),5,40)|\
|
||||
_shifted_octet(U64,(ptr),6,48)|\
|
||||
_shifted_octet(U64,(ptr),7,56))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Find best way to ROTL32/ROTL64 */
|
||||
#if defined(_MSC_VER)
|
||||
#include <stdlib.h> /* Microsoft put _rotl declaration in here */
|
||||
#define ROTL32(x,r) _rotl(x,r)
|
||||
#define ROTR32(x,r) _rotr(x,r)
|
||||
#define ROTL64(x,r) _rotl64(x,r)
|
||||
#define ROTR64(x,r) _rotr64(x,r)
|
||||
#else
|
||||
/* gcc recognises this code and generates a rotate instruction for CPUs with one */
|
||||
#define ROTL32(x,r) (((U32)(x) << (r)) | ((U32)(x) >> (32 - (r))))
|
||||
#define ROTR32(x,r) (((U32)(x) << (32 - (r))) | ((U32)(x) >> (r)))
|
||||
#define ROTL64(x,r) ( ( (U64)(x) << (r) ) | ( (U64)(x) >> ( 64 - (r) ) ) )
|
||||
#define ROTR64(x,r) ( ( (U64)(x) << ( 64 - (r) ) ) | ( (U64)(x) >> (r) ) )
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef UV_IS_QUAD
|
||||
#define ROTL_UV(x,r) ROTL64(x,r)
|
||||
#define ROTR_UV(x,r) ROTL64(x,r)
|
||||
#else
|
||||
#define ROTL_UV(x,r) ROTL32(x,r)
|
||||
#define ROTR_UV(x,r) ROTR32(x,r)
|
||||
#endif
|
||||
#if IVSIZE == 8
|
||||
#define CAN64BITHASH
|
||||
#endif
|
||||
|
||||
#endif
|
||||
4729
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/inline.h
Normal file
4729
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/inline.h
Normal file
File diff suppressed because it is too large
Load diff
1107
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/intrpvar.h
Normal file
1107
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/intrpvar.h
Normal file
File diff suppressed because it is too large
Load diff
375
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/invlist_inline.h
Normal file
375
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/invlist_inline.h
Normal file
|
|
@ -0,0 +1,375 @@
|
|||
/* invlist_inline.h
|
||||
*
|
||||
* Copyright (C) 2012 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 PERL_INVLIST_INLINE_H_
|
||||
#define PERL_INVLIST_INLINE_H_
|
||||
|
||||
#if defined(PERL_IN_UTF8_C) \
|
||||
|| defined(PERL_IN_REGCOMP_ANY) \
|
||||
|| defined(PERL_IN_REGEXEC_C) \
|
||||
|| defined(PERL_IN_TOKE_C) \
|
||||
|| defined(PERL_IN_PP_C) \
|
||||
|| defined(PERL_IN_OP_C) \
|
||||
|| defined(PERL_IN_DOOP_C)
|
||||
|
||||
/* An element is in an inversion list iff its index is even numbered: 0, 2, 4,
|
||||
* etc */
|
||||
#define ELEMENT_RANGE_MATCHES_INVLIST(i) (! ((i) & 1))
|
||||
#define PREV_RANGE_MATCHES_INVLIST(i) (! ELEMENT_RANGE_MATCHES_INVLIST(i))
|
||||
|
||||
/* This converts to/from our UVs to what the SV code is expecting: bytes. */
|
||||
#define TO_INTERNAL_SIZE(x) ((x) * sizeof(UV))
|
||||
#define FROM_INTERNAL_SIZE(x) ((x)/ sizeof(UV))
|
||||
|
||||
PERL_STATIC_INLINE bool
|
||||
S_is_invlist(const SV* const invlist)
|
||||
{
|
||||
return invlist != NULL && SvTYPE(invlist) == SVt_INVLIST;
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE bool*
|
||||
S_get_invlist_offset_addr(SV* invlist)
|
||||
{
|
||||
/* Return the address of the field that says whether the inversion list is
|
||||
* offset (it contains 1) or not (contains 0) */
|
||||
PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR;
|
||||
|
||||
assert(is_invlist(invlist));
|
||||
|
||||
return &(((XINVLIST*) SvANY(invlist))->is_offset);
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE UV
|
||||
S__invlist_len(SV* const invlist)
|
||||
{
|
||||
/* Returns the current number of elements stored in the inversion list's
|
||||
* array */
|
||||
|
||||
PERL_ARGS_ASSERT__INVLIST_LEN;
|
||||
|
||||
assert(is_invlist(invlist));
|
||||
|
||||
return (SvCUR(invlist) == 0)
|
||||
? 0
|
||||
: FROM_INTERNAL_SIZE(SvCUR(invlist)) - *get_invlist_offset_addr(invlist);
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE bool
|
||||
S__invlist_contains_cp(SV* const invlist, const UV cp)
|
||||
{
|
||||
/* Does <invlist> contain code point <cp> as part of the set? */
|
||||
|
||||
IV index = _invlist_search(invlist, cp);
|
||||
|
||||
PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP;
|
||||
|
||||
return index >= 0 && ELEMENT_RANGE_MATCHES_INVLIST(index);
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE UV*
|
||||
S_invlist_array(SV* const invlist)
|
||||
{
|
||||
/* Returns the pointer to the inversion list's array. Every time the
|
||||
* length changes, this needs to be called in case malloc or realloc moved
|
||||
* it */
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_ARRAY;
|
||||
|
||||
/* Must not be empty. If these fail, you probably didn't check for <len>
|
||||
* being non-zero before trying to get the array */
|
||||
assert(_invlist_len(invlist));
|
||||
|
||||
/* The very first element always contains zero, The array begins either
|
||||
* there, or if the inversion list is offset, at the element after it.
|
||||
* The offset header field determines which; it contains 0 or 1 to indicate
|
||||
* how much additionally to add */
|
||||
assert(0 == *(SvPVX(invlist)));
|
||||
return ((UV *) SvPVX(invlist) + *get_invlist_offset_addr(invlist));
|
||||
}
|
||||
|
||||
#endif
|
||||
#if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C)
|
||||
|
||||
PERL_STATIC_INLINE void
|
||||
S_invlist_extend(pTHX_ SV* const invlist, const UV new_max)
|
||||
{
|
||||
/* Grow the maximum size of an inversion list */
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_EXTEND;
|
||||
|
||||
assert(SvTYPE(invlist) == SVt_INVLIST);
|
||||
|
||||
/* Add one to account for the zero element at the beginning which may not
|
||||
* be counted by the calling parameters */
|
||||
SvGROW((SV *)invlist, TO_INTERNAL_SIZE(new_max + 1));
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE void
|
||||
S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
|
||||
{
|
||||
/* Sets the current number of elements stored in the inversion list.
|
||||
* Updates SvCUR correspondingly */
|
||||
PERL_UNUSED_CONTEXT;
|
||||
PERL_ARGS_ASSERT_INVLIST_SET_LEN;
|
||||
|
||||
assert(SvTYPE(invlist) == SVt_INVLIST);
|
||||
|
||||
SvCUR_set(invlist,
|
||||
(len == 0)
|
||||
? 0
|
||||
: TO_INTERNAL_SIZE(len + offset));
|
||||
assert(SvLEN(invlist) == 0 || SvCUR(invlist) <= SvLEN(invlist));
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE SV*
|
||||
S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) {
|
||||
return _add_range_to_invlist(invlist, cp, cp);
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE UV
|
||||
S_invlist_highest(SV* const invlist)
|
||||
{
|
||||
/* Returns the highest code point that matches an inversion list. This API
|
||||
* has an ambiguity, as it returns 0 under either the highest is actually
|
||||
* 0, or if the list is empty. If this distinction matters to you, check
|
||||
* for emptiness before calling this function */
|
||||
|
||||
UV len = _invlist_len(invlist);
|
||||
UV *array;
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_HIGHEST;
|
||||
|
||||
if (len == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
array = invlist_array(invlist);
|
||||
|
||||
/* The last element in the array in the inversion list always starts a
|
||||
* range that goes to infinity. That range may be for code points that are
|
||||
* matched in the inversion list, or it may be for ones that aren't
|
||||
* matched. In the latter case, the highest code point in the set is one
|
||||
* less than the beginning of this range; otherwise it is the final element
|
||||
* of this range: infinity */
|
||||
return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
|
||||
? UV_MAX
|
||||
: array[len - 1] - 1;
|
||||
}
|
||||
|
||||
# if defined(PERL_IN_REGCOMP_ANY)
|
||||
|
||||
PERL_STATIC_INLINE UV
|
||||
S_invlist_highest_range_start(SV* const invlist)
|
||||
{
|
||||
/* Returns the lowest code point of the highest range in the inversion
|
||||
* list parameter. This API has an ambiguity: it returns 0 either when
|
||||
* the lowest such point is actually 0 or when the list is empty. If this
|
||||
* distinction matters to you, check for emptiness before calling this
|
||||
* function. */
|
||||
|
||||
UV len = _invlist_len(invlist);
|
||||
UV *array;
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_HIGHEST_RANGE_START;
|
||||
|
||||
if (len == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
array = invlist_array(invlist);
|
||||
|
||||
/* The last element in the array in the inversion list always starts a
|
||||
* range that goes to infinity. That range may be for code points that are
|
||||
* matched in the inversion list, or it may be for ones that aren't
|
||||
* matched. In the first case, the lowest code point in the matching range
|
||||
* is that the one that started the range. If the other case, the final
|
||||
* matching range begins at the next element down (which may be 0 in the
|
||||
* edge case). */
|
||||
return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
|
||||
? array[len - 1]
|
||||
: len == 1
|
||||
? 0
|
||||
: array[len - 2];
|
||||
}
|
||||
|
||||
# endif
|
||||
#endif
|
||||
#if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_OP_C)
|
||||
|
||||
PERL_STATIC_INLINE STRLEN*
|
||||
S_get_invlist_iter_addr(SV* invlist)
|
||||
{
|
||||
/* Return the address of the UV that contains the current iteration
|
||||
* position */
|
||||
|
||||
PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR;
|
||||
|
||||
assert(is_invlist(invlist));
|
||||
|
||||
return &(((XINVLIST*) SvANY(invlist))->iterator);
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE void
|
||||
S_invlist_iterinit(SV* invlist) /* Initialize iterator for invlist */
|
||||
{
|
||||
PERL_ARGS_ASSERT_INVLIST_ITERINIT;
|
||||
|
||||
*get_invlist_iter_addr(invlist) = 0;
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE void
|
||||
S_invlist_iterfinish(SV* invlist)
|
||||
{
|
||||
/* Terminate iterator for invlist. This is to catch development errors.
|
||||
* Any iteration that is interrupted before completed should call this
|
||||
* function. Functions that add code points anywhere else but to the end
|
||||
* of an inversion list assert that they are not in the middle of an
|
||||
* iteration. If they were, the addition would make the iteration
|
||||
* problematical: if the iteration hadn't reached the place where things
|
||||
* were being added, it would be ok */
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_ITERFINISH;
|
||||
|
||||
*get_invlist_iter_addr(invlist) = (STRLEN) UV_MAX;
|
||||
}
|
||||
|
||||
STATIC bool
|
||||
S_invlist_iternext(SV* invlist, UV* start, UV* end)
|
||||
{
|
||||
/* An C<invlist_iterinit> call on <invlist> must be used to set this up.
|
||||
* This call sets in <*start> and <*end>, the next range in <invlist>.
|
||||
* Returns <TRUE> if successful and the next call will return the next
|
||||
* range; <FALSE> if was already at the end of the list. If the latter,
|
||||
* <*start> and <*end> are unchanged, and the next call to this function
|
||||
* will start over at the beginning of the list */
|
||||
|
||||
STRLEN* pos = get_invlist_iter_addr(invlist);
|
||||
UV len = _invlist_len(invlist);
|
||||
UV *array;
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_ITERNEXT;
|
||||
|
||||
if (*pos >= len) {
|
||||
*pos = (STRLEN) UV_MAX; /* Force iterinit() to be required next time */
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
array = invlist_array(invlist);
|
||||
|
||||
*start = array[(*pos)++];
|
||||
|
||||
if (*pos >= len) {
|
||||
*end = UV_MAX;
|
||||
}
|
||||
else {
|
||||
*end = array[(*pos)++] - 1;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef PERL_IN_REGCOMP_ANY
|
||||
|
||||
/* These symbols are only needed later in regcomp.c */
|
||||
# undef TO_INTERNAL_SIZE
|
||||
# undef FROM_INTERNAL_SIZE
|
||||
#endif
|
||||
|
||||
#ifdef PERL_IN_REGCOMP_ANY
|
||||
PERL_STATIC_INLINE
|
||||
bool
|
||||
S_invlist_is_iterating(const SV* const invlist)
|
||||
{
|
||||
PERL_ARGS_ASSERT_INVLIST_IS_ITERATING;
|
||||
|
||||
/* get_invlist_iter_addr()'s sv is non-const only because it returns a
|
||||
* value that can be used to modify the invlist, it doesn't modify the
|
||||
* invlist itself */
|
||||
return *(get_invlist_iter_addr((SV*)invlist)) < (STRLEN) UV_MAX;
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE
|
||||
SV *
|
||||
S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style)
|
||||
{
|
||||
/* Get the contents of an inversion list into a string SV so that they can
|
||||
* be printed out. If 'traditional_style' is TRUE, it uses the format
|
||||
* traditionally done for debug tracing; otherwise it uses a format
|
||||
* suitable for just copying to the output, with blanks between ranges and
|
||||
* a dash between range components */
|
||||
|
||||
UV start, end;
|
||||
SV* output;
|
||||
const char intra_range_delimiter = (traditional_style ? '\t' : '-');
|
||||
const char inter_range_delimiter = (traditional_style ? '\n' : ' ');
|
||||
|
||||
if (traditional_style) {
|
||||
output = newSVpvs("\n");
|
||||
}
|
||||
else {
|
||||
output = newSVpvs("");
|
||||
}
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_CONTENTS;
|
||||
|
||||
assert(! invlist_is_iterating(invlist));
|
||||
|
||||
invlist_iterinit(invlist);
|
||||
while (invlist_iternext(invlist, &start, &end)) {
|
||||
if (end == UV_MAX) {
|
||||
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%cINFTY%c",
|
||||
start, intra_range_delimiter,
|
||||
inter_range_delimiter);
|
||||
}
|
||||
else if (end != start) {
|
||||
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c%04" UVXf "%c",
|
||||
start,
|
||||
intra_range_delimiter,
|
||||
end, inter_range_delimiter);
|
||||
}
|
||||
else {
|
||||
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c",
|
||||
start, inter_range_delimiter);
|
||||
}
|
||||
}
|
||||
|
||||
if (SvCUR(output) && ! traditional_style) {/* Get rid of trailing blank */
|
||||
SvCUR_set(output, SvCUR(output) - 1);
|
||||
}
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
PERL_STATIC_INLINE
|
||||
UV
|
||||
S_invlist_lowest(SV* const invlist)
|
||||
{
|
||||
/* Returns the lowest code point that matches an inversion list. This API
|
||||
* has an ambiguity, as it returns 0 under either the lowest is actually
|
||||
* 0, or if the list is empty. If this distinction matters to you, check
|
||||
* for emptiness before calling this function */
|
||||
|
||||
UV len = _invlist_len(invlist);
|
||||
UV *array;
|
||||
|
||||
PERL_ARGS_ASSERT_INVLIST_LOWEST;
|
||||
|
||||
if (len == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
array = invlist_array(invlist);
|
||||
|
||||
return array[0];
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* PERL_INVLIST_INLINE_H_ */
|
||||
1422
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/iperlsys.h
Normal file
1422
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/iperlsys.h
Normal file
File diff suppressed because it is too large
Load diff
284
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/keywords.h
Normal file
284
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/keywords.h
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
/* -*- mode: C; 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___CLASS__ 4
|
||||
#define KEY___DATA__ 5
|
||||
#define KEY___END__ 6
|
||||
#define KEY___SUB__ 7
|
||||
#define KEY_ADJUST 8
|
||||
#define KEY_AUTOLOAD 9
|
||||
#define KEY_BEGIN 10
|
||||
#define KEY_UNITCHECK 11
|
||||
#define KEY_DESTROY 12
|
||||
#define KEY_END 13
|
||||
#define KEY_INIT 14
|
||||
#define KEY_CHECK 15
|
||||
#define KEY_abs 16
|
||||
#define KEY_accept 17
|
||||
#define KEY_alarm 18
|
||||
#define KEY_and 19
|
||||
#define KEY_atan2 20
|
||||
#define KEY_bind 21
|
||||
#define KEY_binmode 22
|
||||
#define KEY_bless 23
|
||||
#define KEY_break 24
|
||||
#define KEY_caller 25
|
||||
#define KEY_catch 26
|
||||
#define KEY_chdir 27
|
||||
#define KEY_chmod 28
|
||||
#define KEY_chomp 29
|
||||
#define KEY_chop 30
|
||||
#define KEY_chown 31
|
||||
#define KEY_chr 32
|
||||
#define KEY_chroot 33
|
||||
#define KEY_class 34
|
||||
#define KEY_close 35
|
||||
#define KEY_closedir 36
|
||||
#define KEY_cmp 37
|
||||
#define KEY_connect 38
|
||||
#define KEY_continue 39
|
||||
#define KEY_cos 40
|
||||
#define KEY_crypt 41
|
||||
#define KEY_dbmclose 42
|
||||
#define KEY_dbmopen 43
|
||||
#define KEY_default 44
|
||||
#define KEY_defer 45
|
||||
#define KEY_defined 46
|
||||
#define KEY_delete 47
|
||||
#define KEY_die 48
|
||||
#define KEY_do 49
|
||||
#define KEY_dump 50
|
||||
#define KEY_each 51
|
||||
#define KEY_else 52
|
||||
#define KEY_elsif 53
|
||||
#define KEY_endgrent 54
|
||||
#define KEY_endhostent 55
|
||||
#define KEY_endnetent 56
|
||||
#define KEY_endprotoent 57
|
||||
#define KEY_endpwent 58
|
||||
#define KEY_endservent 59
|
||||
#define KEY_eof 60
|
||||
#define KEY_eq 61
|
||||
#define KEY_eval 62
|
||||
#define KEY_evalbytes 63
|
||||
#define KEY_exec 64
|
||||
#define KEY_exists 65
|
||||
#define KEY_exit 66
|
||||
#define KEY_exp 67
|
||||
#define KEY_fc 68
|
||||
#define KEY_fcntl 69
|
||||
#define KEY_field 70
|
||||
#define KEY_fileno 71
|
||||
#define KEY_finally 72
|
||||
#define KEY_flock 73
|
||||
#define KEY_for 74
|
||||
#define KEY_foreach 75
|
||||
#define KEY_fork 76
|
||||
#define KEY_format 77
|
||||
#define KEY_formline 78
|
||||
#define KEY_ge 79
|
||||
#define KEY_getc 80
|
||||
#define KEY_getgrent 81
|
||||
#define KEY_getgrgid 82
|
||||
#define KEY_getgrnam 83
|
||||
#define KEY_gethostbyaddr 84
|
||||
#define KEY_gethostbyname 85
|
||||
#define KEY_gethostent 86
|
||||
#define KEY_getlogin 87
|
||||
#define KEY_getnetbyaddr 88
|
||||
#define KEY_getnetbyname 89
|
||||
#define KEY_getnetent 90
|
||||
#define KEY_getpeername 91
|
||||
#define KEY_getpgrp 92
|
||||
#define KEY_getppid 93
|
||||
#define KEY_getpriority 94
|
||||
#define KEY_getprotobyname 95
|
||||
#define KEY_getprotobynumber 96
|
||||
#define KEY_getprotoent 97
|
||||
#define KEY_getpwent 98
|
||||
#define KEY_getpwnam 99
|
||||
#define KEY_getpwuid 100
|
||||
#define KEY_getservbyname 101
|
||||
#define KEY_getservbyport 102
|
||||
#define KEY_getservent 103
|
||||
#define KEY_getsockname 104
|
||||
#define KEY_getsockopt 105
|
||||
#define KEY_given 106
|
||||
#define KEY_glob 107
|
||||
#define KEY_gmtime 108
|
||||
#define KEY_goto 109
|
||||
#define KEY_grep 110
|
||||
#define KEY_gt 111
|
||||
#define KEY_hex 112
|
||||
#define KEY_if 113
|
||||
#define KEY_index 114
|
||||
#define KEY_int 115
|
||||
#define KEY_ioctl 116
|
||||
#define KEY_isa 117
|
||||
#define KEY_join 118
|
||||
#define KEY_keys 119
|
||||
#define KEY_kill 120
|
||||
#define KEY_last 121
|
||||
#define KEY_lc 122
|
||||
#define KEY_lcfirst 123
|
||||
#define KEY_le 124
|
||||
#define KEY_length 125
|
||||
#define KEY_link 126
|
||||
#define KEY_listen 127
|
||||
#define KEY_local 128
|
||||
#define KEY_localtime 129
|
||||
#define KEY_lock 130
|
||||
#define KEY_log 131
|
||||
#define KEY_lstat 132
|
||||
#define KEY_lt 133
|
||||
#define KEY_m 134
|
||||
#define KEY_map 135
|
||||
#define KEY_method 136
|
||||
#define KEY_mkdir 137
|
||||
#define KEY_msgctl 138
|
||||
#define KEY_msgget 139
|
||||
#define KEY_msgrcv 140
|
||||
#define KEY_msgsnd 141
|
||||
#define KEY_my 142
|
||||
#define KEY_ne 143
|
||||
#define KEY_next 144
|
||||
#define KEY_no 145
|
||||
#define KEY_not 146
|
||||
#define KEY_oct 147
|
||||
#define KEY_open 148
|
||||
#define KEY_opendir 149
|
||||
#define KEY_or 150
|
||||
#define KEY_ord 151
|
||||
#define KEY_our 152
|
||||
#define KEY_pack 153
|
||||
#define KEY_package 154
|
||||
#define KEY_pipe 155
|
||||
#define KEY_pop 156
|
||||
#define KEY_pos 157
|
||||
#define KEY_print 158
|
||||
#define KEY_printf 159
|
||||
#define KEY_prototype 160
|
||||
#define KEY_push 161
|
||||
#define KEY_q 162
|
||||
#define KEY_qq 163
|
||||
#define KEY_qr 164
|
||||
#define KEY_quotemeta 165
|
||||
#define KEY_qw 166
|
||||
#define KEY_qx 167
|
||||
#define KEY_rand 168
|
||||
#define KEY_read 169
|
||||
#define KEY_readdir 170
|
||||
#define KEY_readline 171
|
||||
#define KEY_readlink 172
|
||||
#define KEY_readpipe 173
|
||||
#define KEY_recv 174
|
||||
#define KEY_redo 175
|
||||
#define KEY_ref 176
|
||||
#define KEY_rename 177
|
||||
#define KEY_require 178
|
||||
#define KEY_reset 179
|
||||
#define KEY_return 180
|
||||
#define KEY_reverse 181
|
||||
#define KEY_rewinddir 182
|
||||
#define KEY_rindex 183
|
||||
#define KEY_rmdir 184
|
||||
#define KEY_s 185
|
||||
#define KEY_say 186
|
||||
#define KEY_scalar 187
|
||||
#define KEY_seek 188
|
||||
#define KEY_seekdir 189
|
||||
#define KEY_select 190
|
||||
#define KEY_semctl 191
|
||||
#define KEY_semget 192
|
||||
#define KEY_semop 193
|
||||
#define KEY_send 194
|
||||
#define KEY_setgrent 195
|
||||
#define KEY_sethostent 196
|
||||
#define KEY_setnetent 197
|
||||
#define KEY_setpgrp 198
|
||||
#define KEY_setpriority 199
|
||||
#define KEY_setprotoent 200
|
||||
#define KEY_setpwent 201
|
||||
#define KEY_setservent 202
|
||||
#define KEY_setsockopt 203
|
||||
#define KEY_shift 204
|
||||
#define KEY_shmctl 205
|
||||
#define KEY_shmget 206
|
||||
#define KEY_shmread 207
|
||||
#define KEY_shmwrite 208
|
||||
#define KEY_shutdown 209
|
||||
#define KEY_sin 210
|
||||
#define KEY_sleep 211
|
||||
#define KEY_socket 212
|
||||
#define KEY_socketpair 213
|
||||
#define KEY_sort 214
|
||||
#define KEY_splice 215
|
||||
#define KEY_split 216
|
||||
#define KEY_sprintf 217
|
||||
#define KEY_sqrt 218
|
||||
#define KEY_srand 219
|
||||
#define KEY_stat 220
|
||||
#define KEY_state 221
|
||||
#define KEY_study 222
|
||||
#define KEY_sub 223
|
||||
#define KEY_substr 224
|
||||
#define KEY_symlink 225
|
||||
#define KEY_syscall 226
|
||||
#define KEY_sysopen 227
|
||||
#define KEY_sysread 228
|
||||
#define KEY_sysseek 229
|
||||
#define KEY_system 230
|
||||
#define KEY_syswrite 231
|
||||
#define KEY_tell 232
|
||||
#define KEY_telldir 233
|
||||
#define KEY_tie 234
|
||||
#define KEY_tied 235
|
||||
#define KEY_time 236
|
||||
#define KEY_times 237
|
||||
#define KEY_tr 238
|
||||
#define KEY_try 239
|
||||
#define KEY_truncate 240
|
||||
#define KEY_uc 241
|
||||
#define KEY_ucfirst 242
|
||||
#define KEY_umask 243
|
||||
#define KEY_undef 244
|
||||
#define KEY_unless 245
|
||||
#define KEY_unlink 246
|
||||
#define KEY_unpack 247
|
||||
#define KEY_unshift 248
|
||||
#define KEY_untie 249
|
||||
#define KEY_until 250
|
||||
#define KEY_use 251
|
||||
#define KEY_utime 252
|
||||
#define KEY_values 253
|
||||
#define KEY_vec 254
|
||||
#define KEY_wait 255
|
||||
#define KEY_waitpid 256
|
||||
#define KEY_wantarray 257
|
||||
#define KEY_warn 258
|
||||
#define KEY_when 259
|
||||
#define KEY_while 260
|
||||
#define KEY_write 261
|
||||
#define KEY_x 262
|
||||
#define KEY_xor 263
|
||||
#define KEY_y 264
|
||||
|
||||
/* Generated from:
|
||||
* c8b75109fa56ce3ea3f30503a3b398f02e49036dc60d5fb36ea5ba9ffd6c596e regen/keywords.pl
|
||||
* ex: set ro ft=c: */
|
||||
|
|
@ -0,0 +1,796 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
|
||||
* This file is built by regen/mk_PL_charclass.pl from Unicode::UCD.
|
||||
* Any changes made here will be lost!
|
||||
*/
|
||||
|
||||
/* For code points whose position is not the same as Unicode, both are shown
|
||||
* in the comment*/
|
||||
|
||||
#if 'A' == 65 /* ASCII/Latin1 */
|
||||
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* U+A1 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A2 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A3 POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A4 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A5 YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A6 BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A7 SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+A8 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+A9 COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+AA FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+AB LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+AC NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+AD SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+AE REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+AF MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+B0 DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+B1 PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+B2 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+B3 SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+B4 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+B5 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+B6 PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+B7 MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
|
||||
/* U+B8 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+B9 SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+BA MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+BB RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+BC 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+BD 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+BE 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* U+BF INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+C0 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C1 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C2 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C3 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C4 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C5 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C6 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C7 C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C8 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+C9 E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CA E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CB E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CC I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CD I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CE I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+CF I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D0 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D1 N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D2 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D3 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D4 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D5 O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D6 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+D8 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+D9 U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DA U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DB U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DC U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DD Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DE THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+DF sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E0 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E1 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E2 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E3 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E4 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E5 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E6 ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E8 e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+E9 e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+EA e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+EB e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+EC i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+ED i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+EE i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+EF i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F0 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F1 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F2 o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F3 o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F4 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F5 o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F6 o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F7 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+F8 o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+F9 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FA u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FB u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FC u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FD y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FE thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* U+FF y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)
|
||||
|
||||
#endif /* ASCII/Latin1 */
|
||||
|
||||
#if 'A' == 193 /* EBCDIC 1047 */ \
|
||||
&& '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
|
||||
&& '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
|
||||
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21
|
||||
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x04 U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x05 U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x06 U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x07 U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x08 U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x09 U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x0A U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x14 U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x15 U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* 0x16 U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x17 U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x1A U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x1B U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x20 U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x21 U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x22 U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x23 U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x24 U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x25 U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* 0x26 U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x27 U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x28 U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x29 U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2A U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2B U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2C U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2D U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2E U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2F U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x30 U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x31 U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x32 U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x33 U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x34 U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x35 U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x36 U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x37 U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x38 U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x39 U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3A U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3B U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3C U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3D U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3E U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3F U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x40 U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x41 U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x42 U+E2 I8=A1 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x43 U+E4 I8=A2 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x44 U+E0 I8=A3 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x45 U+E1 I8=A4 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x46 U+E3 I8=A5 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x47 U+E5 I8=A6 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x48 U+E7 I8=A7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x49 U+F1 I8=A8 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x4A U+A2 I8=A9 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4B U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4C U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4D U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4E U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4F U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x50 U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x51 U+E9 I8=AA e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x52 U+EA I8=AB e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x53 U+EB I8=AC e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x54 U+E8 I8=AD e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x55 U+ED I8=AE i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x56 U+EE I8=AF i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x57 U+EF I8=B0 i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x58 U+EC I8=B1 i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x59 U+DF I8=B2 sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x5A U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5B U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5C U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5D U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5E U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5F U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x60 U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x61 U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x62 U+C2 I8=B3 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x63 U+C4 I8=B4 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x64 U+C0 I8=B5 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x65 U+C1 I8=B6 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x66 U+C3 I8=B7 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x67 U+C5 I8=B8 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x68 U+C7 I8=B9 C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x69 U+D1 I8=BA N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x6A U+A6 I8=BB BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6B U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6C U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6D U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x6E U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6F U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x70 U+F8 I8=BC o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x71 U+C9 I8=BD E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x72 U+CA I8=BE E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x73 U+CB I8=BF E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x74 U+C8 I8=C0 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x75 U+CD I8=C1 I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x76 U+CE I8=C2 I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x77 U+CF I8=C3 I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x78 U+CC I8=C4 I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x79 U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7A U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7B U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7C U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7D U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7E U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7F U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x80 U+D8 I8=C5 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x81 U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x82 U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x83 U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x84 U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x85 U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x86 U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x87 U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x88 U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x89 U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8A U+AB I8=C6 LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x8B U+BB I8=C7 RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x8C U+F0 I8=C8 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8D U+FD I8=C9 y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8E U+FE I8=CA thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8F U+B1 I8=CB PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x90 U+B0 I8=CC DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x91 U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x92 U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x93 U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x94 U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x95 U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x96 U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x97 U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x98 U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x99 U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9A U+AA I8=CD FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9B U+BA I8=CE MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9C U+E6 I8=CF ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9D U+B8 I8=D0 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0x9E U+C6 I8=D1 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9F U+A4 I8=D2 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xA0 U+B5 I8=D3 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA1 U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xA2 U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA3 U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA4 U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA5 U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA6 U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA7 U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA8 U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA9 U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAA U+A1 I8=D4 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xAB U+BF I8=D5 INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xAC U+D0 I8=D6 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAD U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xAE U+DE I8=D7 THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAF U+AE I8=D8 REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB0 U+AC I8=D9 NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB1 U+A3 I8=DA POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB2 U+A5 I8=DB YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB3 U+B7 I8=DC MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
|
||||
/* 0xB4 U+A9 I8=DD COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB5 U+A7 I8=DE SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+B6 I8=DF PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB7 U+BC I8=E0 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xB8 U+BD I8=E1 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xB9 U+BE I8=E2 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBA U+DD I8=E3 Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xBB U+A8 I8=E4 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBC U+AF I8=E5 MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBD U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xBE U+B4 I8=E6 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBF U+D7 I8=E7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xC0 U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xC1 U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC2 U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC3 U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC4 U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC5 U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC6 U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC7 U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xC8 U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xC9 U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCA U+AD I8=E8 SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xCB U+F4 I8=E9 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCC U+F6 I8=EA o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCD U+F2 I8=EB o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCE U+F3 I8=EC o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCF U+F5 I8=ED o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD0 U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xD1 U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD2 U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD3 U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD4 U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD5 U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD6 U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD7 U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD8 U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD9 U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDA U+B9 I8=EE SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xDB U+FB I8=EF u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDC U+FC I8=F0 u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDD U+F9 I8=F1 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDE U+FA I8=F2 u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDF U+FF I8=F3 y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE0 U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xE1 U+F7 I8=F4 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xE2 U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE3 U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE4 U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE5 U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE6 U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE7 U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE8 U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE9 U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEA U+B2 I8=F5 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xEB U+D4 I8=F6 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEC U+D6 I8=F7 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xED U+D2 I8=F8 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEE U+D3 I8=F9 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEF U+D5 I8=FA O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xF0 U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF1 U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF2 U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF3 U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF4 U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF5 U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF6 U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF7 U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF8 U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF9 U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xFA U+B3 I8=FB SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xFB U+DB I8=FC U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFC U+DC I8=FD U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFD U+D9 I8=FE U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFE U+DA I8=FF U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFF U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)
|
||||
|
||||
#endif /* EBCDIC 1047 */
|
||||
|
||||
#if 'A' == 193 /* EBCDIC 037 */ \
|
||||
&& '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
|
||||
&& '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
|
||||
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37
|
||||
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x04 U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x05 U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x06 U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x07 U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x08 U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x09 U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x0A U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x14 U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x15 U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* 0x16 U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x17 U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x1A U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x1B U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x20 U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x21 U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x22 U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x23 U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x24 U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x25 U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
|
||||
/* 0x26 U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x27 U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x28 U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x29 U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2A U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2B U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2C U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2D U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2E U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x2F U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x30 U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x31 U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x32 U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x33 U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x34 U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x35 U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x36 U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x37 U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x38 U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x39 U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3A U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3B U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3C U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3D U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3E U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x3F U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x40 U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x41 U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
|
||||
/* 0x42 U+E2 I8=A1 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x43 U+E4 I8=A2 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x44 U+E0 I8=A3 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x45 U+E1 I8=A4 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x46 U+E3 I8=A5 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x47 U+E5 I8=A6 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x48 U+E7 I8=A7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x49 U+F1 I8=A8 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x4A U+A2 I8=A9 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4B U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4C U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4D U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4E U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x4F U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x50 U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x51 U+E9 I8=AA e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x52 U+EA I8=AB e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x53 U+EB I8=AC e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x54 U+E8 I8=AD e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x55 U+ED I8=AE i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x56 U+EE I8=AF i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x57 U+EF I8=B0 i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x58 U+EC I8=B1 i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x59 U+DF I8=B2 sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x5A U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5B U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5C U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5D U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5E U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x5F U+AC I8=B3 NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x60 U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x61 U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x62 U+C2 I8=B4 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x63 U+C4 I8=B5 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x64 U+C0 I8=B6 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x65 U+C1 I8=B7 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x66 U+C3 I8=B8 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x67 U+C5 I8=B9 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x68 U+C7 I8=BA C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x69 U+D1 I8=BB N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x6A U+A6 I8=BC BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6B U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6C U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6D U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x6E U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x6F U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x70 U+F8 I8=BD o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x71 U+C9 I8=BE E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x72 U+CA I8=BF E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x73 U+CB I8=C0 E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x74 U+C8 I8=C1 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x75 U+CD I8=C2 I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x76 U+CE I8=C3 I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x77 U+CF I8=C4 I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x78 U+CC I8=C5 I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x79 U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7A U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7B U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7C U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7D U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7E U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x7F U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x80 U+D8 I8=C6 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x81 U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x82 U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x83 U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x84 U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x85 U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x86 U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0x87 U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x88 U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x89 U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8A U+AB I8=C7 LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x8B U+BB I8=C8 RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x8C U+F0 I8=C9 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8D U+FD I8=CA y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8E U+FE I8=CB thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x8F U+B1 I8=CC PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x90 U+B0 I8=CD DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0x91 U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x92 U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x93 U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x94 U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x95 U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x96 U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x97 U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x98 U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x99 U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9A U+AA I8=CE FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9B U+BA I8=CF MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9C U+E6 I8=D0 ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9D U+B8 I8=D1 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0x9E U+C6 I8=D2 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0x9F U+A4 I8=D3 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xA0 U+B5 I8=D4 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA1 U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xA2 U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA3 U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA4 U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA5 U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA6 U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA7 U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA8 U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xA9 U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAA U+A1 I8=D5 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xAB U+BF I8=D6 INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xAC U+D0 I8=D7 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAD U+DD I8=D8 Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAE U+DE I8=D9 THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xAF U+AE I8=DA REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB0 U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB1 U+A3 I8=DB POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB2 U+A5 I8=DC YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB3 U+B7 I8=DD MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
|
||||
/* 0xB4 U+A9 I8=DE COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB5 U+A7 I8=DF SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* U+B6 I8=E0 PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xB7 U+BC I8=E1 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xB8 U+BD I8=E2 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xB9 U+BE I8=E3 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBA U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xBB U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xBC U+AF I8=E4 MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBD U+A8 I8=E5 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBE U+B4 I8=E6 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xBF U+D7 I8=E7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xC0 U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xC1 U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC2 U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC3 U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC4 U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC5 U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC6 U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xC7 U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xC8 U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xC9 U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCA U+AD I8=E8 SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xCB U+F4 I8=E9 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCC U+F6 I8=EA o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCD U+F2 I8=EB o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCE U+F3 I8=EC o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xCF U+F5 I8=ED o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD0 U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xD1 U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD2 U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD3 U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD4 U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD5 U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD6 U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD7 U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD8 U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xD9 U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDA U+B9 I8=EE SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xDB U+FB I8=EF u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDC U+FC I8=F0 u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDD U+F9 I8=F1 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDE U+FA I8=F2 u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xDF U+FF I8=F3 y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE0 U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xE1 U+F7 I8=F4 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
|
||||
/* 0xE2 U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE3 U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE4 U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE5 U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE6 U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE7 U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE8 U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xE9 U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEA U+B2 I8=F5 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xEB U+D4 I8=F6 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEC U+D6 I8=F7 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xED U+D2 I8=F8 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEE U+D3 I8=F9 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xEF U+D5 I8=FA O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xF0 U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF1 U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF2 U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF3 U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF4 U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF5 U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF6 U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF7 U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF8 U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xF9 U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
|
||||
/* 0xFA U+B3 I8=FB SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
|
||||
/* 0xFB U+DB I8=FC U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFC U+DC I8=FD U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFD U+D9 I8=FE U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFE U+DA I8=FF U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
|
||||
/* 0xFF U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)
|
||||
|
||||
#endif /* EBCDIC 037 */
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/libperl.dll.a
Normal file
BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/libperl.dll.a
Normal file
Binary file not shown.
242
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/locale_table.h
Normal file
242
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/locale_table.h
Normal file
|
|
@ -0,0 +1,242 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
*
|
||||
* locale_table.h
|
||||
*
|
||||
* Copyright (C) 2023, 2024 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/locale.pl from data in regen/locale.pl.
|
||||
* Any changes made here will be lost!
|
||||
*/
|
||||
|
||||
/* This defines a macro for each individual locale category used on the this
|
||||
* system. (The congomerate category LC_ALL is not included.) This
|
||||
* file will be #included as the interior of various parallel arrays and in
|
||||
* other constructs; each usage will re-#define the macro to generate its
|
||||
* appropriate data.
|
||||
*
|
||||
* This guarantees the arrays will be parallel, and populated in the order
|
||||
* given here. That order is mostly arbitrary. LC_CTYPE is first because when
|
||||
* we are setting multiple categories, CTYPE often needs to match the other(s),
|
||||
* and the way the code is constructed, if we set the other category first, we
|
||||
* might otherwise have to set CTYPE twice.
|
||||
*
|
||||
* Each entry takes the token giving the category name, and either the name of
|
||||
* a function to call that does specialized set up for this category when it is
|
||||
* changed into, or NULL if no such set up is needed
|
||||
*/
|
||||
|
||||
#ifdef LC_CTYPE
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_CTYPE)
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(CTYPE, NULL)
|
||||
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_CTYPE_AVAIL_ 0
|
||||
# else
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(CTYPE, S_new_ctype)
|
||||
|
||||
# define LC_CTYPE_AVAIL_ 1
|
||||
# define USE_LOCALE_CTYPE
|
||||
# endif
|
||||
#else
|
||||
# define LC_CTYPE_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_NUMERIC
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_NUMERIC)
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(NUMERIC, NULL)
|
||||
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_NUMERIC_AVAIL_ 0
|
||||
# else
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(NUMERIC, S_new_numeric)
|
||||
|
||||
# define LC_NUMERIC_AVAIL_ 1
|
||||
# define USE_LOCALE_NUMERIC
|
||||
# endif
|
||||
#else
|
||||
# define LC_NUMERIC_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_COLLATE
|
||||
|
||||
/* Perl outsources all its collation efforts to the libc strxfrm(), so
|
||||
* if it isn't available on the system, default "C" locale collation
|
||||
* gets used */
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_COLLATE) || ! defined(HAS_STRXFRM)
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(COLLATE, NULL)
|
||||
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_COLLATE_AVAIL_ 0
|
||||
# else
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(COLLATE, S_new_collate)
|
||||
|
||||
# define LC_COLLATE_AVAIL_ 1
|
||||
# define USE_LOCALE_COLLATE
|
||||
# endif
|
||||
#else
|
||||
# define LC_COLLATE_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_TIME
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(TIME, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_TIME)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_TIME_AVAIL_ 0
|
||||
# else
|
||||
# define LC_TIME_AVAIL_ 1
|
||||
# define USE_LOCALE_TIME
|
||||
# endif
|
||||
#else
|
||||
# define LC_TIME_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_MESSAGES
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(MESSAGES, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_MESSAGES)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_MESSAGES_AVAIL_ 0
|
||||
# else
|
||||
# define LC_MESSAGES_AVAIL_ 1
|
||||
# define USE_LOCALE_MESSAGES
|
||||
# endif
|
||||
#else
|
||||
# define LC_MESSAGES_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_MONETARY
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(MONETARY, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_MONETARY)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_MONETARY_AVAIL_ 0
|
||||
# else
|
||||
# define LC_MONETARY_AVAIL_ 1
|
||||
# define USE_LOCALE_MONETARY
|
||||
# endif
|
||||
#else
|
||||
# define LC_MONETARY_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_ADDRESS
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(ADDRESS, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_ADDRESS)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_ADDRESS_AVAIL_ 0
|
||||
# else
|
||||
# define LC_ADDRESS_AVAIL_ 1
|
||||
# define USE_LOCALE_ADDRESS
|
||||
# endif
|
||||
#else
|
||||
# define LC_ADDRESS_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_IDENTIFICATION
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(IDENTIFICATION, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_IDENTIFICATION)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_IDENTIFICATION_AVAIL_ 0
|
||||
# else
|
||||
# define LC_IDENTIFICATION_AVAIL_ 1
|
||||
# define USE_LOCALE_IDENTIFICATION
|
||||
# endif
|
||||
#else
|
||||
# define LC_IDENTIFICATION_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_MEASUREMENT
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(MEASUREMENT, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_MEASUREMENT)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_MEASUREMENT_AVAIL_ 0
|
||||
# else
|
||||
# define LC_MEASUREMENT_AVAIL_ 1
|
||||
# define USE_LOCALE_MEASUREMENT
|
||||
# endif
|
||||
#else
|
||||
# define LC_MEASUREMENT_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_PAPER
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(PAPER, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_PAPER)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_PAPER_AVAIL_ 0
|
||||
# else
|
||||
# define LC_PAPER_AVAIL_ 1
|
||||
# define USE_LOCALE_PAPER
|
||||
# endif
|
||||
#else
|
||||
# define LC_PAPER_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_TELEPHONE
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(TELEPHONE, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_TELEPHONE)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_TELEPHONE_AVAIL_ 0
|
||||
# else
|
||||
# define LC_TELEPHONE_AVAIL_ 1
|
||||
# define USE_LOCALE_TELEPHONE
|
||||
# endif
|
||||
#else
|
||||
# define LC_TELEPHONE_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_NAME
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(NAME, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_NAME)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_NAME_AVAIL_ 0
|
||||
# else
|
||||
# define LC_NAME_AVAIL_ 1
|
||||
# define USE_LOCALE_NAME
|
||||
# endif
|
||||
#else
|
||||
# define LC_NAME_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_SYNTAX
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(SYNTAX, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_SYNTAX)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_SYNTAX_AVAIL_ 0
|
||||
# else
|
||||
# define LC_SYNTAX_AVAIL_ 1
|
||||
# define USE_LOCALE_SYNTAX
|
||||
# endif
|
||||
#else
|
||||
# define LC_SYNTAX_AVAIL_ 0
|
||||
#endif
|
||||
#ifdef LC_TOD
|
||||
|
||||
PERL_LOCALE_TABLE_ENTRY(TOD, NULL)
|
||||
|
||||
# if defined(NO_LOCALE) || defined(NO_LOCALE_TOD)
|
||||
# define HAS_IGNORED_LOCALE_CATEGORIES_
|
||||
# define LC_TOD_AVAIL_ 0
|
||||
# else
|
||||
# define LC_TOD_AVAIL_ 1
|
||||
# define USE_LOCALE_TOD
|
||||
# endif
|
||||
#else
|
||||
# define LC_TOD_AVAIL_ 0
|
||||
#endif
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
62
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/malloc_ctl.h
Normal file
62
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/malloc_ctl.h
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
#ifndef PERL_MALLOC_CTL_H_
|
||||
# define PERL_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
|
||||
124
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/metaconfig.h
Normal file
124
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/metaconfig.h
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
/* 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.
|
||||
*
|
||||
* Symbols should only be here temporarily. Once they are actually used,
|
||||
* they should be removed from here.
|
||||
*
|
||||
* BIN
|
||||
* CASTI32
|
||||
* CASTNEGFLOAT
|
||||
* CPPLAST
|
||||
* CPPMINUS
|
||||
* CPPRUN
|
||||
* CPPSTDIN
|
||||
* DOSUID
|
||||
* DOUBLE_HAS_NEGATIVE_ZERO
|
||||
* DOUBLE_HAS_SUBNORMALS
|
||||
* DOUBLEMANTBITS
|
||||
* DOUBLE_STYLE_CRAY
|
||||
* DOUBLE_STYLE_IBM
|
||||
* DOUBLE_STYLE_IEEE
|
||||
* DOUBLE_STYLE_VAX
|
||||
* DRAND48_R_PROTO
|
||||
* Gid_t_f
|
||||
* HAS_ASCTIME64
|
||||
* HAS_ATOLF
|
||||
* HAS_BUILTIN_ADD_OVERFLOW
|
||||
* HAS_BUILTIN_MUL_OVERFLOW
|
||||
* HAS_BUILTIN_SUB_OVERFLOW
|
||||
* HAS_CSH
|
||||
* HAS_CTERMID
|
||||
* HAS_CTIME64
|
||||
* HAS_DIFFTIME64
|
||||
* HAS_DRAND48_PROTO
|
||||
* HAS_DRAND48_R
|
||||
* HAS_FD_SET
|
||||
* HAS_FFS
|
||||
* HAS_FFSL
|
||||
* HAS_GETMNT
|
||||
* HAS_GMTIME64
|
||||
* HAS_GNULIBC
|
||||
* HAS_INT64_T
|
||||
* HAS_IPV6_MREQ_SOURCE
|
||||
* HAS_ISLESS
|
||||
* HAS_ISNORMAL
|
||||
* HAS_LGAMMA_R
|
||||
* HAS_LOCALECONV_L
|
||||
* HAS_LOCALTIME64
|
||||
* HAS_LSEEK_PROTO
|
||||
* HAS_MKTIME64
|
||||
* HAS_NANOSLEEP
|
||||
* HAS_OPEN3
|
||||
* HAS_OPENAT
|
||||
* HAS_PRCTL
|
||||
* HAS_PSEUDOFORK
|
||||
* HAS_RANDOM_R
|
||||
* HAS_SIGINFO_SI_VALUE
|
||||
* HAS_SIGSETJMP
|
||||
* HAS_SRAND48_R
|
||||
* HAS_SRANDOM_R
|
||||
* HAS_STRTOD_L
|
||||
* HAS_STRTOLD_L
|
||||
* HAS_STRUCT_FS_DATA
|
||||
* HAS_STRUCT_STATFS
|
||||
* HAS_STRUCT_STATFS_F_FLAGS
|
||||
* HAS_TIME
|
||||
* HAS_USTAT
|
||||
* HAS_VFORK
|
||||
* HAS_WCSCMP
|
||||
* HAS_WCSXFRM
|
||||
* I16SIZE
|
||||
* I32SIZE
|
||||
* I64SIZE
|
||||
* I8SIZE
|
||||
* I_GDBM
|
||||
* INSTALL_USR_BIN_PERL
|
||||
* I_STDBOOL
|
||||
* I_SYS_MOUNT
|
||||
* I_SYS_STATFS
|
||||
* I_SYS_STATVFS
|
||||
* I_SYS_VFS
|
||||
* I_TIME
|
||||
* I_USTAT
|
||||
* I_VFORK
|
||||
* I_XLOCALE
|
||||
* LOCALTIME_R_NEEDS_TZSET
|
||||
* LOC_SED
|
||||
* LONGDBLMANTBITS
|
||||
* LONG_DOUBLE_STYLE_IEEE
|
||||
* LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE
|
||||
* LONG_DOUBLE_STYLE_IEEE_EXTENDED
|
||||
* LONG_DOUBLE_STYLE_IEEE_STD
|
||||
* LONG_DOUBLE_STYLE_VAX
|
||||
* OSVERS
|
||||
* PERL_LC_ALL_CATEGORY_POSITIONS_INIT
|
||||
* PERL_LC_ALL_SEPARATOR
|
||||
* PERL_LC_ALL_USES_NAME_VALUE_PAIRS
|
||||
* PERL_PRIeldbl
|
||||
* PERL_SCNfldbl
|
||||
* PERL_TARGETARCH
|
||||
* PERL_VENDORARCH
|
||||
* RANDOM_R_PROTO
|
||||
* SRAND48_R_PROTO
|
||||
* SRANDOM_R_PROTO
|
||||
* STARTPERL
|
||||
* ST_INO_SIGN
|
||||
* ST_INO_SIZE
|
||||
* U32_ALIGNMENT_REQUIRED
|
||||
* U32of
|
||||
* U32xf
|
||||
* U32Xf
|
||||
* U8SIZE
|
||||
* Uid_t_f
|
||||
* USE_CROSS_COMPILE
|
||||
* USE_MORE_BITS
|
||||
*/
|
||||
89
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg.h
Normal file
89
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg.h
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
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);
|
||||
};
|
||||
|
||||
struct magic {
|
||||
MAGIC* mg_moremagic;
|
||||
MGVTBL* mg_virtual; /* pointer to magic functions */
|
||||
U16 mg_private;
|
||||
char mg_type;
|
||||
U8 mg_flags;
|
||||
SSize_t 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_REQUIRE_GV 1 /* PERL_MAGIC_checkcall 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 MGf_BYTES 0x40 /* PERL_MAGIC_regex_global only */
|
||||
#define MGf_PERSIST 0x80 /* PERL_MAGIC_lvref only */
|
||||
|
||||
#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)
|
||||
|
||||
/* Extracts the SV stored in mg, or NULL. */
|
||||
#define MgSV(mg) (((int)((mg)->mg_len) == HEf_SVKEY) ? \
|
||||
MUTABLE_SV((mg)->mg_ptr) : \
|
||||
NULL)
|
||||
|
||||
/* If mg contains an SV, these extract the PV stored in that SV;
|
||||
otherwise, these extract the mg's mg_ptr/mg_len.
|
||||
These do NOT account for the SV's UTF8 flag, so handle with care.
|
||||
*/
|
||||
#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)))
|
||||
|
||||
#if defined(PERL_CORE) || defined(PERL_EXT)
|
||||
# define MgBYTEPOS(mg,sv,pv,len) S_MgBYTEPOS(aTHX_ mg,sv,pv,len)
|
||||
/* assumes get-magic and stringification have already occurred */
|
||||
# define MgBYTEPOS_set(mg,sv,pv,off) ( \
|
||||
assert_((mg)->mg_type == PERL_MAGIC_regex_global) \
|
||||
SvPOK(sv) && (!SvGMAGICAL(sv) || sv_only_taint_gmagic(sv)) \
|
||||
? (mg)->mg_len = (off), (mg)->mg_flags |= MGf_BYTES \
|
||||
: ((mg)->mg_len = DO_UTF8(sv) \
|
||||
? (SSize_t)utf8_length((U8 *)(pv), (U8 *)(pv)+(off)) \
|
||||
: (SSize_t)(off), \
|
||||
(mg)->mg_flags &= ~MGf_BYTES))
|
||||
#endif
|
||||
|
||||
#define whichsig(pv) whichsig_pv(pv)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
312
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_data.h
Normal file
312
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_data.h
Normal file
|
|
@ -0,0 +1,312 @@
|
|||
/* mg_data.h:
|
||||
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
|
||||
*
|
||||
* These values will populate PL_magic_data[]: this is an array of
|
||||
* per-magic U8 values containing an index into PL_magic_vtables[]
|
||||
* plus two flags:
|
||||
* PERL_MAGIC_READONLY_ACCEPTABLE
|
||||
* PERL_MAGIC_VALUE_MAGIC
|
||||
*/
|
||||
{
|
||||
/* 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,
|
||||
/* debugvar '*' $DB::single, signal, trace vars */
|
||||
want_vtbl_debugvar,
|
||||
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,
|
||||
0,
|
||||
/* 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,
|
||||
0,
|
||||
/* hints 'H' %^H hash */
|
||||
want_vtbl_hints,
|
||||
/* isa 'I' @ISA array */
|
||||
want_vtbl_isa,
|
||||
0,
|
||||
0,
|
||||
/* dbfile 'L' Debugger %_<filename */
|
||||
magic_vtable_max,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
/* tied 'P' Tied array or hash */
|
||||
want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC,
|
||||
0,
|
||||
0,
|
||||
/* sig 'S' %SIG hash */
|
||||
want_vtbl_sig,
|
||||
0,
|
||||
/* uvar 'U' Available for use by extensions */
|
||||
want_vtbl_uvar,
|
||||
/* vstring 'V' SV was vstring literal */
|
||||
magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
|
||||
0,
|
||||
/* destruct 'X' destruct callback */
|
||||
want_vtbl_destruct | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* nonelem 'Y' Array element that does not exist */
|
||||
want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* hook 'Z' %{^HOOK} hash */
|
||||
want_vtbl_hook,
|
||||
0,
|
||||
/* lvref '\' Lvalue reference constructor */
|
||||
want_vtbl_lvref,
|
||||
/* checkcall ']' Inlining/mutation of call to this CV */
|
||||
want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* extvalue '^' Value magic available for use by extensions */
|
||||
magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
/* overload_table 'c' Holds overload table (AMT) on stash */
|
||||
want_vtbl_ovrld,
|
||||
/* regdatum 'd' Regex match position data element */
|
||||
want_vtbl_regdatum,
|
||||
/* envelem 'e' %ENV hash element */
|
||||
want_vtbl_envelem,
|
||||
/* fm 'f' Formline ('compiled' format) */
|
||||
want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* regex_global 'g' m//g target */
|
||||
want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* hintselem 'h' %^H hash element */
|
||||
want_vtbl_hintselem,
|
||||
/* isaelem 'i' @ISA array element */
|
||||
want_vtbl_isaelem,
|
||||
0,
|
||||
/* nkeys 'k' scalar(keys()) lvalue */
|
||||
want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* dbline 'l' Debugger %_<filename element */
|
||||
want_vtbl_dbline,
|
||||
0,
|
||||
0,
|
||||
/* collxfrm 'o' Locale transformation */
|
||||
want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* tiedelem 'p' Tied array or hash element */
|
||||
want_vtbl_packelem,
|
||||
/* tiedscalar 'q' Tied scalar or handle */
|
||||
want_vtbl_packelem,
|
||||
/* qr 'r' Precompiled qr// regex */
|
||||
want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* sigelem 's' %SIG hash element */
|
||||
want_vtbl_sigelem,
|
||||
/* taint 't' Taintedness */
|
||||
want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC,
|
||||
0,
|
||||
/* vec 'v' vec() lvalue */
|
||||
want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* utf8 'w' Cached UTF-8 information */
|
||||
want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* substr 'x' substr() lvalue */
|
||||
want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* defelem 'y' Shadow "foreach" iterator variable / smart parameter vivification */
|
||||
want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC,
|
||||
/* hookelem 'z' %{^HOOK} hash element */
|
||||
want_vtbl_hookelem,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
/* ext '~' Variable magic available for use by extensions */
|
||||
magic_vtable_max | 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,
|
||||
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
|
||||
}
|
||||
100
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_raw.h
Normal file
100
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_raw.h
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
/* -*- mode: C; 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_debugvar",
|
||||
"/* debugvar '*' $DB::single, signal, trace vars */" },
|
||||
{ '.', "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 */" },
|
||||
{ '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_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* fm 'f' Formline ('compiled' format) */" },
|
||||
{ '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 %_<filename */" },
|
||||
{ 'l', "want_vtbl_dbline",
|
||||
"/* dbline 'l' Debugger %_<filename element */" },
|
||||
{ 'o', "want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* collxfrm 'o' Locale transformation */" },
|
||||
{ 'P', "want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* tied 'P' Tied array or hash */" },
|
||||
{ 'p', "want_vtbl_packelem",
|
||||
"/* tiedelem 'p' Tied array or hash element */" },
|
||||
{ 'q', "want_vtbl_packelem",
|
||||
"/* tiedscalar 'q' Tied scalar or handle */" },
|
||||
{ 'r', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* qr 'r' Precompiled qr// regex */" },
|
||||
{ 'S', "want_vtbl_sig",
|
||||
"/* sig 'S' %SIG hash */" },
|
||||
{ 's', "want_vtbl_sigelem",
|
||||
"/* sigelem 's' %SIG hash element */" },
|
||||
{ 't', "want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* taint 't' Taintedness */" },
|
||||
{ 'U', "want_vtbl_uvar",
|
||||
"/* uvar 'U' Available for use by extensions */" },
|
||||
{ 'V', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* vstring 'V' SV was vstring literal */" },
|
||||
{ 'v', "want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* vec 'v' vec() lvalue */" },
|
||||
{ 'w', "want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* utf8 'w' Cached UTF-8 information */" },
|
||||
{ 'X', "want_vtbl_destruct | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* destruct 'X' destruct callback */" },
|
||||
{ 'x', "want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* substr 'x' substr() lvalue */" },
|
||||
{ 'Y', "want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* nonelem 'Y' Array element that does not exist */" },
|
||||
{ 'y', "want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* defelem 'y' Shadow \"foreach\" iterator variable / smart parameter vivification */" },
|
||||
{ 'Z', "want_vtbl_hook",
|
||||
"/* hook 'Z' %{^HOOK} hash */" },
|
||||
{ 'z', "want_vtbl_hookelem",
|
||||
"/* hookelem 'z' %{^HOOK} hash element */" },
|
||||
{ '\\', "want_vtbl_lvref",
|
||||
"/* lvref '\\' Lvalue reference constructor */" },
|
||||
{ ']', "want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* checkcall ']' Inlining/mutation of call to this CV */" },
|
||||
{ '^', "magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
|
||||
"/* extvalue '^' Value magic available for use by extensions */" },
|
||||
{ '~', "magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE",
|
||||
"/* ext '~' Variable magic available for use by extensions */" },
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
255
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_vtable.h
Normal file
255
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_vtable.h
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
/* -*- mode: C; 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_debugvar '*' /* $DB::single, signal, trace vars */
|
||||
#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_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_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 %_<filename */
|
||||
#define PERL_MAGIC_dbline 'l' /* Debugger %_<filename element */
|
||||
#define PERL_MAGIC_shared 'N' /* Shared between threads */
|
||||
#define PERL_MAGIC_shared_scalar 'n' /* Shared between threads */
|
||||
#define PERL_MAGIC_collxfrm 'o' /* Locale transformation */
|
||||
#define PERL_MAGIC_tied 'P' /* Tied array or hash */
|
||||
#define PERL_MAGIC_tiedelem 'p' /* Tied array or hash element */
|
||||
#define PERL_MAGIC_tiedscalar 'q' /* Tied scalar or handle */
|
||||
#define PERL_MAGIC_qr 'r' /* Precompiled qr// regex */
|
||||
#define PERL_MAGIC_sig 'S' /* %SIG hash */
|
||||
#define PERL_MAGIC_sigelem 's' /* %SIG hash element */
|
||||
#define PERL_MAGIC_taint 't' /* Taintedness */
|
||||
#define PERL_MAGIC_uvar 'U' /* Available for use by extensions */
|
||||
#define PERL_MAGIC_uvar_elem 'u' /* Reserved for use by extensions */
|
||||
#define PERL_MAGIC_vstring 'V' /* SV was vstring literal */
|
||||
#define PERL_MAGIC_vec 'v' /* vec() lvalue */
|
||||
#define PERL_MAGIC_utf8 'w' /* Cached UTF-8 information */
|
||||
#define PERL_MAGIC_destruct 'X' /* destruct callback */
|
||||
#define PERL_MAGIC_substr 'x' /* substr() lvalue */
|
||||
#define PERL_MAGIC_nonelem 'Y' /* Array element that does not exist */
|
||||
#define PERL_MAGIC_defelem 'y' /* Shadow "foreach" iterator variable /
|
||||
smart parameter vivification */
|
||||
#define PERL_MAGIC_hook 'Z' /* %{^HOOK} hash */
|
||||
#define PERL_MAGIC_hookelem 'z' /* %{^HOOK} hash element */
|
||||
#define PERL_MAGIC_lvref '\\' /* Lvalue reference constructor */
|
||||
#define PERL_MAGIC_checkcall ']' /* Inlining/mutation of call to this CV */
|
||||
#define PERL_MAGIC_extvalue '^' /* Value magic available for use by extensions */
|
||||
#define PERL_MAGIC_ext '~' /* Variable magic available for use by extensions */
|
||||
|
||||
enum { /* pass one of these to get_vtbl */
|
||||
want_vtbl_arylen,
|
||||
want_vtbl_arylen_p,
|
||||
want_vtbl_backref,
|
||||
want_vtbl_checkcall,
|
||||
want_vtbl_collxfrm,
|
||||
want_vtbl_dbline,
|
||||
want_vtbl_debugvar,
|
||||
want_vtbl_defelem,
|
||||
want_vtbl_destruct,
|
||||
want_vtbl_env,
|
||||
want_vtbl_envelem,
|
||||
want_vtbl_hints,
|
||||
want_vtbl_hintselem,
|
||||
want_vtbl_hook,
|
||||
want_vtbl_hookelem,
|
||||
want_vtbl_isa,
|
||||
want_vtbl_isaelem,
|
||||
want_vtbl_lvref,
|
||||
want_vtbl_mglob,
|
||||
want_vtbl_nkeys,
|
||||
want_vtbl_nonelem,
|
||||
want_vtbl_ovrld,
|
||||
want_vtbl_pack,
|
||||
want_vtbl_packelem,
|
||||
want_vtbl_pos,
|
||||
want_vtbl_regdata,
|
||||
want_vtbl_regdatum,
|
||||
want_vtbl_regexp,
|
||||
want_vtbl_sig,
|
||||
want_vtbl_sigelem,
|
||||
want_vtbl_substr,
|
||||
want_vtbl_sv,
|
||||
want_vtbl_taint,
|
||||
want_vtbl_utf8,
|
||||
want_vtbl_uvar,
|
||||
want_vtbl_vec,
|
||||
magic_vtable_max
|
||||
};
|
||||
|
||||
#ifdef DOINIT
|
||||
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max] = {
|
||||
"arylen",
|
||||
"arylen_p",
|
||||
"backref",
|
||||
"checkcall",
|
||||
"collxfrm",
|
||||
"dbline",
|
||||
"debugvar",
|
||||
"defelem",
|
||||
"destruct",
|
||||
"env",
|
||||
"envelem",
|
||||
"hints",
|
||||
"hintselem",
|
||||
"hook",
|
||||
"hookelem",
|
||||
"isa",
|
||||
"isaelem",
|
||||
"lvref",
|
||||
"mglob",
|
||||
"nkeys",
|
||||
"nonelem",
|
||||
"ovrld",
|
||||
"pack",
|
||||
"packelem",
|
||||
"pos",
|
||||
"regdata",
|
||||
"regdatum",
|
||||
"regexp",
|
||||
"sig",
|
||||
"sigelem",
|
||||
"substr",
|
||||
"sv",
|
||||
"taint",
|
||||
"utf8",
|
||||
"uvar",
|
||||
"vec"
|
||||
};
|
||||
#else
|
||||
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max];
|
||||
#endif
|
||||
|
||||
/* These all need to be 0, not NULL, as NULL can be (void*)0, which is a
|
||||
* pointer to data, whereas we're assigning pointers to functions, which are
|
||||
* not the same beast. ANSI doesn't allow the assignment from one to the other.
|
||||
* (although most, but not all, compilers are prepared to do it)
|
||||
*/
|
||||
|
||||
/* order is:
|
||||
get
|
||||
set
|
||||
len
|
||||
clear
|
||||
free
|
||||
copy
|
||||
dup
|
||||
local
|
||||
*/
|
||||
|
||||
#ifdef DOINIT
|
||||
EXT_MGVTBL PL_magic_vtables[magic_vtable_max] = {
|
||||
{ (int (*)(pTHX_ SV *, MAGIC *))Perl_magic_getarylen, Perl_magic_setarylen, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, Perl_magic_cleararylen_p, Perl_magic_freearylen_p, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0, Perl_magic_killbackrefs, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0, 0, Perl_magic_copycallchecker, 0, 0 },
|
||||
#ifdef USE_LOCALE_COLLATE
|
||||
{ 0, Perl_magic_setcollxfrm, 0, 0, Perl_magic_freecollxfrm, 0, 0, 0 },
|
||||
#else
|
||||
{ 0, 0, 0, 0, 0, 0, 0, 0 },
|
||||
#endif
|
||||
{ 0, Perl_magic_setdbline, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getdebugvar, Perl_magic_setdebugvar, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getdefelem, Perl_magic_setdefelem, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0, Perl_magic_freedestruct, 0, 0, 0 },
|
||||
{ 0, Perl_magic_set_all_env, 0, Perl_magic_clear_all_env, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setenv, 0, Perl_magic_clearenv, 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, Perl_magic_clearhints, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_sethint, 0, Perl_magic_clearhint, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_sethookall, 0, Perl_magic_clearhookall, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_sethook, 0, Perl_magic_clearhook, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setisa, 0, Perl_magic_clearisa, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setisa, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setlvref, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setmglob, 0, 0, Perl_magic_freemglob, 0, 0, 0 },
|
||||
{ Perl_magic_getnkeys, Perl_magic_setnkeys, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setnonelem, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, 0, 0, 0, Perl_magic_freeovrld, 0, 0, 0 },
|
||||
{ 0, 0, Perl_magic_sizepack, Perl_magic_wipepack, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getpack, Perl_magic_setpack, 0, Perl_magic_clearpack, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getpos, Perl_magic_setpos, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, 0, Perl_magic_regdata_cnt, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_regdatum_get, Perl_magic_regdatum_set, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setregexp, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setsigall, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getsig, Perl_magic_setsig, 0, Perl_magic_clearsig, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getsubstr, Perl_magic_setsubstr, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_get, Perl_magic_set, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_gettaint, Perl_magic_settaint, 0, 0, 0, 0, 0, 0 },
|
||||
{ 0, Perl_magic_setutf8, 0, 0, Perl_magic_freeutf8, 0, 0, 0 },
|
||||
{ Perl_magic_getuvar, Perl_magic_setuvar, 0, 0, 0, 0, 0, 0 },
|
||||
{ Perl_magic_getvec, Perl_magic_setvec, 0, 0, 0, 0, 0, 0 }
|
||||
};
|
||||
#else
|
||||
EXT_MGVTBL PL_magic_vtables[magic_vtable_max];
|
||||
#endif
|
||||
|
||||
#define want_vtbl_bm want_vtbl_regexp
|
||||
#define want_vtbl_fm want_vtbl_regexp
|
||||
|
||||
#define PL_vtbl_arylen PL_magic_vtables[want_vtbl_arylen]
|
||||
#define PL_vtbl_arylen_p PL_magic_vtables[want_vtbl_arylen_p]
|
||||
#define PL_vtbl_backref PL_magic_vtables[want_vtbl_backref]
|
||||
#define PL_vtbl_bm PL_magic_vtables[want_vtbl_bm]
|
||||
#define PL_vtbl_checkcall PL_magic_vtables[want_vtbl_checkcall]
|
||||
#define PL_vtbl_collxfrm PL_magic_vtables[want_vtbl_collxfrm]
|
||||
#define PL_vtbl_dbline PL_magic_vtables[want_vtbl_dbline]
|
||||
#define PL_vtbl_debugvar PL_magic_vtables[want_vtbl_debugvar]
|
||||
#define PL_vtbl_defelem PL_magic_vtables[want_vtbl_defelem]
|
||||
#define PL_vtbl_destruct PL_magic_vtables[want_vtbl_destruct]
|
||||
#define PL_vtbl_env PL_magic_vtables[want_vtbl_env]
|
||||
#define PL_vtbl_envelem PL_magic_vtables[want_vtbl_envelem]
|
||||
#define PL_vtbl_fm PL_magic_vtables[want_vtbl_fm]
|
||||
#define PL_vtbl_hints PL_magic_vtables[want_vtbl_hints]
|
||||
#define PL_vtbl_hintselem PL_magic_vtables[want_vtbl_hintselem]
|
||||
#define PL_vtbl_hook PL_magic_vtables[want_vtbl_hook]
|
||||
#define PL_vtbl_hookelem PL_magic_vtables[want_vtbl_hookelem]
|
||||
#define PL_vtbl_isa PL_magic_vtables[want_vtbl_isa]
|
||||
#define PL_vtbl_isaelem PL_magic_vtables[want_vtbl_isaelem]
|
||||
#define PL_vtbl_lvref PL_magic_vtables[want_vtbl_lvref]
|
||||
#define PL_vtbl_mglob PL_magic_vtables[want_vtbl_mglob]
|
||||
#define PL_vtbl_nkeys PL_magic_vtables[want_vtbl_nkeys]
|
||||
#define PL_vtbl_nonelem PL_magic_vtables[want_vtbl_nonelem]
|
||||
#define PL_vtbl_ovrld PL_magic_vtables[want_vtbl_ovrld]
|
||||
#define PL_vtbl_pack PL_magic_vtables[want_vtbl_pack]
|
||||
#define PL_vtbl_packelem PL_magic_vtables[want_vtbl_packelem]
|
||||
#define PL_vtbl_pos PL_magic_vtables[want_vtbl_pos]
|
||||
#define PL_vtbl_regdata PL_magic_vtables[want_vtbl_regdata]
|
||||
#define PL_vtbl_regdatum PL_magic_vtables[want_vtbl_regdatum]
|
||||
#define PL_vtbl_regexp PL_magic_vtables[want_vtbl_regexp]
|
||||
#define PL_vtbl_sig PL_magic_vtables[want_vtbl_sig]
|
||||
#define PL_vtbl_sigelem PL_magic_vtables[want_vtbl_sigelem]
|
||||
#define PL_vtbl_substr PL_magic_vtables[want_vtbl_substr]
|
||||
#define PL_vtbl_sv PL_magic_vtables[want_vtbl_sv]
|
||||
#define PL_vtbl_taint PL_magic_vtables[want_vtbl_taint]
|
||||
#define PL_vtbl_utf8 PL_magic_vtables[want_vtbl_utf8]
|
||||
#define PL_vtbl_uvar PL_magic_vtables[want_vtbl_uvar]
|
||||
#define PL_vtbl_vec PL_magic_vtables[want_vtbl_vec]
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
54
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mydtrace.h
Normal file
54
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mydtrace.h
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
/* 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"
|
||||
|
||||
# define PERL_DTRACE_PROBE_ENTRY(cv) \
|
||||
if (PERL_SUB_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_call(aTHX_ cv, TRUE);
|
||||
|
||||
# define PERL_DTRACE_PROBE_RETURN(cv) \
|
||||
if (PERL_SUB_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_call(aTHX_ cv, FALSE);
|
||||
|
||||
# define PERL_DTRACE_PROBE_FILE_LOADING(name) \
|
||||
if (PERL_SUB_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_load(aTHX_ name, TRUE);
|
||||
|
||||
# define PERL_DTRACE_PROBE_FILE_LOADED(name) \
|
||||
if (PERL_SUB_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_load(aTHX_ name, FALSE);
|
||||
|
||||
# define PERL_DTRACE_PROBE_OP(op) \
|
||||
if (PERL_OP_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_op(aTHX_ op);
|
||||
|
||||
# define PERL_DTRACE_PROBE_PHASE(phase) \
|
||||
if (PERL_OP_ENTRY_ENABLED()) \
|
||||
Perl_dtrace_probe_phase(aTHX_ phase);
|
||||
|
||||
#else
|
||||
|
||||
/* NOPs */
|
||||
# define PERL_DTRACE_PROBE_ENTRY(cv)
|
||||
# define PERL_DTRACE_PROBE_RETURN(cv)
|
||||
# define PERL_DTRACE_PROBE_FILE_LOADING(cv)
|
||||
# define PERL_DTRACE_PROBE_FILE_LOADED(cv)
|
||||
# define PERL_DTRACE_PROBE_OP(op)
|
||||
# define PERL_DTRACE_PROBE_PHASE(phase)
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
134
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/nostdio.h
Normal file
134
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/nostdio.h
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
/* 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 <stdio.h>.
|
||||
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
|
||||
|
||||
#if !defined(OEMVS)
|
||||
|
||||
# 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
|
||||
|
||||
#endif /*not define OEMVS */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
1178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op.h
Normal file
1178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op.h
Normal file
File diff suppressed because it is too large
Load diff
157
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op_reg_common.h
Normal file
157
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op_reg_common.h
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
/* 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/Makefile.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 msixn 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! */
|
||||
/* Make sure you keep the pure PMf_ versions below in sync */
|
||||
#define RXf_PMf_MULTILINE (1U << (RXf_PMf_STD_PMMOD_SHIFT+0)) /* /m */
|
||||
#define RXf_PMf_SINGLELINE (1U << (RXf_PMf_STD_PMMOD_SHIFT+1)) /* /s */
|
||||
#define RXf_PMf_FOLD (1U << (RXf_PMf_STD_PMMOD_SHIFT+2)) /* /i */
|
||||
#define RXf_PMf_EXTENDED (1U << (RXf_PMf_STD_PMMOD_SHIFT+3)) /* /x */
|
||||
#define RXf_PMf_EXTENDED_MORE (1U << (RXf_PMf_STD_PMMOD_SHIFT+4)) /* /xx */
|
||||
#define RXf_PMf_NOCAPTURE (1U << (RXf_PMf_STD_PMMOD_SHIFT+5)) /* /n */
|
||||
|
||||
#define RXf_PMf_KEEPCOPY (1U << (RXf_PMf_STD_PMMOD_SHIFT+6)) /* /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 and regcomp.sym (as these are used as
|
||||
* offsets for various node types, like POSIXD vs POSIXL, etc) 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)+7)
|
||||
#define RXf_PMf_CHARSET (7U << (_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);
|
||||
}
|
||||
|
||||
#define RXf_PMf_STRICT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+10))
|
||||
|
||||
#define _RXf_PMf_SHIFT_COMPILETIME (RXf_PMf_STD_PMMOD_SHIFT+11)
|
||||
|
||||
|
||||
/*
|
||||
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_PMf_SPLIT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+11))
|
||||
|
||||
/* 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+12)
|
||||
|
||||
/* 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_FOLD \
|
||||
| RXf_PMf_EXTENDED \
|
||||
| RXf_PMf_EXTENDED_MORE \
|
||||
| RXf_PMf_KEEPCOPY \
|
||||
| RXf_PMf_NOCAPTURE \
|
||||
| RXf_PMf_CHARSET \
|
||||
| RXf_PMf_STRICT )
|
||||
|
||||
#define RXf_PMf_FLAGCOPYMASK \
|
||||
( RXf_PMf_COMPILETIME \
|
||||
| RXf_PMf_SPLIT )
|
||||
|
||||
/* Temporary to get Jenkins happy again
|
||||
* See thread starting at http://nntp.perl.org/group/perl.perl5.porters/220710
|
||||
*/
|
||||
#if 0
|
||||
/* Exclude win32 because it can't cope with I32_MAX definition */
|
||||
#ifndef WIN32
|
||||
# if RXf_PMf_COMPILETIME > I32_MAX
|
||||
# error RXf_PMf_COMPILETIME wont fit in arg2 field of eval node
|
||||
# endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* These copies need to be numerical or ext/B/Makefile.PL won't think they are
|
||||
* constants */
|
||||
#define PMf_MULTILINE (1U<<0)
|
||||
#define PMf_SINGLELINE (1U<<1)
|
||||
#define PMf_FOLD (1U<<2)
|
||||
#define PMf_EXTENDED (1U<<3)
|
||||
#define PMf_EXTENDED_MORE (1U<<4)
|
||||
#define PMf_NOCAPTURE (1U<<5)
|
||||
#define PMf_KEEPCOPY (1U<<6)
|
||||
#define PMf_CHARSET (7U<<7)
|
||||
#define PMf_STRICT (1U<<10)
|
||||
#define PMf_SPLIT (1U<<11)
|
||||
|
||||
#if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_EXTENDED_MORE != RXf_PMf_EXTENDED_MORE || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY || PMf_SPLIT != RXf_PMf_SPLIT || PMf_CHARSET != RXf_PMf_CHARSET || PMf_NOCAPTURE != RXf_PMf_NOCAPTURE || PMf_STRICT != RXf_PMf_STRICT
|
||||
# error RXf_PMf defines are wrong
|
||||
#endif
|
||||
|
||||
/* 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 != ((nBIT_MASK(_RXf_PMf_SHIFT_COMPILETIME)) \
|
||||
& (~(nBIT_MASK( RXf_PMf_STD_PMMOD_SHIFT))))
|
||||
# error RXf_PMf_COMPILETIME is invalid
|
||||
#endif
|
||||
|
||||
#endif /* Include only once */
|
||||
3536
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opcode.h
Normal file
3536
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opcode.h
Normal file
File diff suppressed because it is too large
Load diff
468
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opnames.h
Normal file
468
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opnames.h
Normal file
|
|
@ -0,0 +1,468 @@
|
|||
/* -*- mode: C; 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_PADSV_STORE = 10,
|
||||
OP_PADAV = 11,
|
||||
OP_PADHV = 12,
|
||||
OP_PADANY = 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_MULTICONCAT = 68,
|
||||
OP_STRINGIFY = 69,
|
||||
OP_LEFT_SHIFT = 70,
|
||||
OP_RIGHT_SHIFT = 71,
|
||||
OP_LT = 72,
|
||||
OP_I_LT = 73,
|
||||
OP_GT = 74,
|
||||
OP_I_GT = 75,
|
||||
OP_LE = 76,
|
||||
OP_I_LE = 77,
|
||||
OP_GE = 78,
|
||||
OP_I_GE = 79,
|
||||
OP_EQ = 80,
|
||||
OP_I_EQ = 81,
|
||||
OP_NE = 82,
|
||||
OP_I_NE = 83,
|
||||
OP_NCMP = 84,
|
||||
OP_I_NCMP = 85,
|
||||
OP_SLT = 86,
|
||||
OP_SGT = 87,
|
||||
OP_SLE = 88,
|
||||
OP_SGE = 89,
|
||||
OP_SEQ = 90,
|
||||
OP_SNE = 91,
|
||||
OP_SCMP = 92,
|
||||
OP_BIT_AND = 93,
|
||||
OP_BIT_XOR = 94,
|
||||
OP_BIT_OR = 95,
|
||||
OP_NBIT_AND = 96,
|
||||
OP_NBIT_XOR = 97,
|
||||
OP_NBIT_OR = 98,
|
||||
OP_SBIT_AND = 99,
|
||||
OP_SBIT_XOR = 100,
|
||||
OP_SBIT_OR = 101,
|
||||
OP_NEGATE = 102,
|
||||
OP_I_NEGATE = 103,
|
||||
OP_NOT = 104,
|
||||
OP_COMPLEMENT = 105,
|
||||
OP_NCOMPLEMENT = 106,
|
||||
OP_SCOMPLEMENT = 107,
|
||||
OP_SMARTMATCH = 108,
|
||||
OP_ATAN2 = 109,
|
||||
OP_SIN = 110,
|
||||
OP_COS = 111,
|
||||
OP_RAND = 112,
|
||||
OP_SRAND = 113,
|
||||
OP_EXP = 114,
|
||||
OP_LOG = 115,
|
||||
OP_SQRT = 116,
|
||||
OP_INT = 117,
|
||||
OP_HEX = 118,
|
||||
OP_OCT = 119,
|
||||
OP_ABS = 120,
|
||||
OP_LENGTH = 121,
|
||||
OP_SUBSTR = 122,
|
||||
OP_VEC = 123,
|
||||
OP_INDEX = 124,
|
||||
OP_RINDEX = 125,
|
||||
OP_SPRINTF = 126,
|
||||
OP_FORMLINE = 127,
|
||||
OP_ORD = 128,
|
||||
OP_CHR = 129,
|
||||
OP_CRYPT = 130,
|
||||
OP_UCFIRST = 131,
|
||||
OP_LCFIRST = 132,
|
||||
OP_UC = 133,
|
||||
OP_LC = 134,
|
||||
OP_QUOTEMETA = 135,
|
||||
OP_RV2AV = 136,
|
||||
OP_AELEMFAST = 137,
|
||||
OP_AELEMFAST_LEX = 138,
|
||||
OP_AELEMFASTLEX_STORE = 139,
|
||||
OP_AELEM = 140,
|
||||
OP_ASLICE = 141,
|
||||
OP_KVASLICE = 142,
|
||||
OP_AEACH = 143,
|
||||
OP_AVALUES = 144,
|
||||
OP_AKEYS = 145,
|
||||
OP_EACH = 146,
|
||||
OP_VALUES = 147,
|
||||
OP_KEYS = 148,
|
||||
OP_DELETE = 149,
|
||||
OP_EXISTS = 150,
|
||||
OP_RV2HV = 151,
|
||||
OP_HELEM = 152,
|
||||
OP_HSLICE = 153,
|
||||
OP_KVHSLICE = 154,
|
||||
OP_MULTIDEREF = 155,
|
||||
OP_UNPACK = 156,
|
||||
OP_PACK = 157,
|
||||
OP_SPLIT = 158,
|
||||
OP_JOIN = 159,
|
||||
OP_LIST = 160,
|
||||
OP_LSLICE = 161,
|
||||
OP_ANONLIST = 162,
|
||||
OP_ANONHASH = 163,
|
||||
OP_EMPTYAVHV = 164,
|
||||
OP_SPLICE = 165,
|
||||
OP_PUSH = 166,
|
||||
OP_POP = 167,
|
||||
OP_SHIFT = 168,
|
||||
OP_UNSHIFT = 169,
|
||||
OP_SORT = 170,
|
||||
OP_REVERSE = 171,
|
||||
OP_GREPSTART = 172,
|
||||
OP_GREPWHILE = 173,
|
||||
OP_MAPSTART = 174,
|
||||
OP_MAPWHILE = 175,
|
||||
OP_RANGE = 176,
|
||||
OP_FLIP = 177,
|
||||
OP_FLOP = 178,
|
||||
OP_AND = 179,
|
||||
OP_OR = 180,
|
||||
OP_XOR = 181,
|
||||
OP_DOR = 182,
|
||||
OP_COND_EXPR = 183,
|
||||
OP_ANDASSIGN = 184,
|
||||
OP_ORASSIGN = 185,
|
||||
OP_DORASSIGN = 186,
|
||||
OP_ENTERSUB = 187,
|
||||
OP_LEAVESUB = 188,
|
||||
OP_LEAVESUBLV = 189,
|
||||
OP_ARGCHECK = 190,
|
||||
OP_ARGELEM = 191,
|
||||
OP_ARGDEFELEM = 192,
|
||||
OP_CALLER = 193,
|
||||
OP_WARN = 194,
|
||||
OP_DIE = 195,
|
||||
OP_RESET = 196,
|
||||
OP_LINESEQ = 197,
|
||||
OP_NEXTSTATE = 198,
|
||||
OP_DBSTATE = 199,
|
||||
OP_UNSTACK = 200,
|
||||
OP_ENTER = 201,
|
||||
OP_LEAVE = 202,
|
||||
OP_SCOPE = 203,
|
||||
OP_ENTERITER = 204,
|
||||
OP_ITER = 205,
|
||||
OP_ENTERLOOP = 206,
|
||||
OP_LEAVELOOP = 207,
|
||||
OP_RETURN = 208,
|
||||
OP_LAST = 209,
|
||||
OP_NEXT = 210,
|
||||
OP_REDO = 211,
|
||||
OP_DUMP = 212,
|
||||
OP_GOTO = 213,
|
||||
OP_EXIT = 214,
|
||||
OP_METHOD = 215,
|
||||
OP_METHOD_NAMED = 216,
|
||||
OP_METHOD_SUPER = 217,
|
||||
OP_METHOD_REDIR = 218,
|
||||
OP_METHOD_REDIR_SUPER = 219,
|
||||
OP_ENTERGIVEN = 220,
|
||||
OP_LEAVEGIVEN = 221,
|
||||
OP_ENTERWHEN = 222,
|
||||
OP_LEAVEWHEN = 223,
|
||||
OP_BREAK = 224,
|
||||
OP_CONTINUE = 225,
|
||||
OP_OPEN = 226,
|
||||
OP_CLOSE = 227,
|
||||
OP_PIPE_OP = 228,
|
||||
OP_FILENO = 229,
|
||||
OP_UMASK = 230,
|
||||
OP_BINMODE = 231,
|
||||
OP_TIE = 232,
|
||||
OP_UNTIE = 233,
|
||||
OP_TIED = 234,
|
||||
OP_DBMOPEN = 235,
|
||||
OP_DBMCLOSE = 236,
|
||||
OP_SSELECT = 237,
|
||||
OP_SELECT = 238,
|
||||
OP_GETC = 239,
|
||||
OP_READ = 240,
|
||||
OP_ENTERWRITE = 241,
|
||||
OP_LEAVEWRITE = 242,
|
||||
OP_PRTF = 243,
|
||||
OP_PRINT = 244,
|
||||
OP_SAY = 245,
|
||||
OP_SYSOPEN = 246,
|
||||
OP_SYSSEEK = 247,
|
||||
OP_SYSREAD = 248,
|
||||
OP_SYSWRITE = 249,
|
||||
OP_EOF = 250,
|
||||
OP_TELL = 251,
|
||||
OP_SEEK = 252,
|
||||
OP_TRUNCATE = 253,
|
||||
OP_FCNTL = 254,
|
||||
OP_IOCTL = 255,
|
||||
OP_FLOCK = 256,
|
||||
OP_SEND = 257,
|
||||
OP_RECV = 258,
|
||||
OP_SOCKET = 259,
|
||||
OP_SOCKPAIR = 260,
|
||||
OP_BIND = 261,
|
||||
OP_CONNECT = 262,
|
||||
OP_LISTEN = 263,
|
||||
OP_ACCEPT = 264,
|
||||
OP_SHUTDOWN = 265,
|
||||
OP_GSOCKOPT = 266,
|
||||
OP_SSOCKOPT = 267,
|
||||
OP_GETSOCKNAME = 268,
|
||||
OP_GETPEERNAME = 269,
|
||||
OP_LSTAT = 270,
|
||||
OP_STAT = 271,
|
||||
OP_FTRREAD = 272,
|
||||
OP_FTRWRITE = 273,
|
||||
OP_FTREXEC = 274,
|
||||
OP_FTEREAD = 275,
|
||||
OP_FTEWRITE = 276,
|
||||
OP_FTEEXEC = 277,
|
||||
OP_FTIS = 278,
|
||||
OP_FTSIZE = 279,
|
||||
OP_FTMTIME = 280,
|
||||
OP_FTATIME = 281,
|
||||
OP_FTCTIME = 282,
|
||||
OP_FTROWNED = 283,
|
||||
OP_FTEOWNED = 284,
|
||||
OP_FTZERO = 285,
|
||||
OP_FTSOCK = 286,
|
||||
OP_FTCHR = 287,
|
||||
OP_FTBLK = 288,
|
||||
OP_FTFILE = 289,
|
||||
OP_FTDIR = 290,
|
||||
OP_FTPIPE = 291,
|
||||
OP_FTSUID = 292,
|
||||
OP_FTSGID = 293,
|
||||
OP_FTSVTX = 294,
|
||||
OP_FTLINK = 295,
|
||||
OP_FTTTY = 296,
|
||||
OP_FTTEXT = 297,
|
||||
OP_FTBINARY = 298,
|
||||
OP_CHDIR = 299,
|
||||
OP_CHOWN = 300,
|
||||
OP_CHROOT = 301,
|
||||
OP_UNLINK = 302,
|
||||
OP_CHMOD = 303,
|
||||
OP_UTIME = 304,
|
||||
OP_RENAME = 305,
|
||||
OP_LINK = 306,
|
||||
OP_SYMLINK = 307,
|
||||
OP_READLINK = 308,
|
||||
OP_MKDIR = 309,
|
||||
OP_RMDIR = 310,
|
||||
OP_OPEN_DIR = 311,
|
||||
OP_READDIR = 312,
|
||||
OP_TELLDIR = 313,
|
||||
OP_SEEKDIR = 314,
|
||||
OP_REWINDDIR = 315,
|
||||
OP_CLOSEDIR = 316,
|
||||
OP_FORK = 317,
|
||||
OP_WAIT = 318,
|
||||
OP_WAITPID = 319,
|
||||
OP_SYSTEM = 320,
|
||||
OP_EXEC = 321,
|
||||
OP_KILL = 322,
|
||||
OP_GETPPID = 323,
|
||||
OP_GETPGRP = 324,
|
||||
OP_SETPGRP = 325,
|
||||
OP_GETPRIORITY = 326,
|
||||
OP_SETPRIORITY = 327,
|
||||
OP_TIME = 328,
|
||||
OP_TMS = 329,
|
||||
OP_LOCALTIME = 330,
|
||||
OP_GMTIME = 331,
|
||||
OP_ALARM = 332,
|
||||
OP_SLEEP = 333,
|
||||
OP_SHMGET = 334,
|
||||
OP_SHMCTL = 335,
|
||||
OP_SHMREAD = 336,
|
||||
OP_SHMWRITE = 337,
|
||||
OP_MSGGET = 338,
|
||||
OP_MSGCTL = 339,
|
||||
OP_MSGSND = 340,
|
||||
OP_MSGRCV = 341,
|
||||
OP_SEMOP = 342,
|
||||
OP_SEMGET = 343,
|
||||
OP_SEMCTL = 344,
|
||||
OP_REQUIRE = 345,
|
||||
OP_DOFILE = 346,
|
||||
OP_HINTSEVAL = 347,
|
||||
OP_ENTEREVAL = 348,
|
||||
OP_LEAVEEVAL = 349,
|
||||
OP_ENTERTRY = 350,
|
||||
OP_LEAVETRY = 351,
|
||||
OP_GHBYNAME = 352,
|
||||
OP_GHBYADDR = 353,
|
||||
OP_GHOSTENT = 354,
|
||||
OP_GNBYNAME = 355,
|
||||
OP_GNBYADDR = 356,
|
||||
OP_GNETENT = 357,
|
||||
OP_GPBYNAME = 358,
|
||||
OP_GPBYNUMBER = 359,
|
||||
OP_GPROTOENT = 360,
|
||||
OP_GSBYNAME = 361,
|
||||
OP_GSBYPORT = 362,
|
||||
OP_GSERVENT = 363,
|
||||
OP_SHOSTENT = 364,
|
||||
OP_SNETENT = 365,
|
||||
OP_SPROTOENT = 366,
|
||||
OP_SSERVENT = 367,
|
||||
OP_EHOSTENT = 368,
|
||||
OP_ENETENT = 369,
|
||||
OP_EPROTOENT = 370,
|
||||
OP_ESERVENT = 371,
|
||||
OP_GPWNAM = 372,
|
||||
OP_GPWUID = 373,
|
||||
OP_GPWENT = 374,
|
||||
OP_SPWENT = 375,
|
||||
OP_EPWENT = 376,
|
||||
OP_GGRNAM = 377,
|
||||
OP_GGRGID = 378,
|
||||
OP_GGRENT = 379,
|
||||
OP_SGRENT = 380,
|
||||
OP_EGRENT = 381,
|
||||
OP_GETLOGIN = 382,
|
||||
OP_SYSCALL = 383,
|
||||
OP_LOCK = 384,
|
||||
OP_ONCE = 385,
|
||||
OP_CUSTOM = 386,
|
||||
OP_COREARGS = 387,
|
||||
OP_AVHVSWITCH = 388,
|
||||
OP_RUNCV = 389,
|
||||
OP_FC = 390,
|
||||
OP_PADCV = 391,
|
||||
OP_INTROCV = 392,
|
||||
OP_CLONECV = 393,
|
||||
OP_PADRANGE = 394,
|
||||
OP_REFASSIGN = 395,
|
||||
OP_LVREF = 396,
|
||||
OP_LVREFSLICE = 397,
|
||||
OP_LVAVREF = 398,
|
||||
OP_ANONCONST = 399,
|
||||
OP_ISA = 400,
|
||||
OP_CMPCHAIN_AND = 401,
|
||||
OP_CMPCHAIN_DUP = 402,
|
||||
OP_ENTERTRYCATCH = 403,
|
||||
OP_LEAVETRYCATCH = 404,
|
||||
OP_POPTRY = 405,
|
||||
OP_CATCH = 406,
|
||||
OP_PUSHDEFER = 407,
|
||||
OP_IS_BOOL = 408,
|
||||
OP_IS_WEAK = 409,
|
||||
OP_WEAKEN = 410,
|
||||
OP_UNWEAKEN = 411,
|
||||
OP_BLESSED = 412,
|
||||
OP_REFADDR = 413,
|
||||
OP_REFTYPE = 414,
|
||||
OP_CEIL = 415,
|
||||
OP_FLOOR = 416,
|
||||
OP_IS_TAINTED = 417,
|
||||
OP_HELEMEXISTSOR = 418,
|
||||
OP_METHSTART = 419,
|
||||
OP_INITFIELD = 420,
|
||||
OP_CLASSNAME = 421,
|
||||
OP_max
|
||||
} opcode;
|
||||
|
||||
#define MAXO 422
|
||||
#define OP_FREED MAXO
|
||||
|
||||
/* 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)
|
||||
|
||||
#define OP_IS_INFIX_BIT(op) \
|
||||
((op) >= OP_BIT_AND && (op) <= OP_SBIT_OR)
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
98
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/overload.h
Normal file
98
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/overload.h
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
/* -*- mode: C; 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 &= */
|
||||
sband_amg, /* 0x30 &. */
|
||||
sband_ass_amg, /* 0x31 &.= */
|
||||
bor_amg, /* 0x32 | */
|
||||
bor_ass_amg, /* 0x33 |= */
|
||||
sbor_amg, /* 0x34 |. */
|
||||
sbor_ass_amg, /* 0x35 |.= */
|
||||
bxor_amg, /* 0x36 ^ */
|
||||
bxor_ass_amg, /* 0x37 ^= */
|
||||
sbxor_amg, /* 0x38 ^. */
|
||||
sbxor_ass_amg, /* 0x39 ^.= */
|
||||
ncmp_amg, /* 0x3a <=> */
|
||||
scmp_amg, /* 0x3b cmp */
|
||||
compl_amg, /* 0x3c ~ */
|
||||
scompl_amg, /* 0x3d ~. */
|
||||
atan2_amg, /* 0x3e atan2 */
|
||||
cos_amg, /* 0x3f cos */
|
||||
sin_amg, /* 0x40 sin */
|
||||
exp_amg, /* 0x41 exp */
|
||||
log_amg, /* 0x42 log */
|
||||
sqrt_amg, /* 0x43 sqrt */
|
||||
repeat_amg, /* 0x44 x */
|
||||
repeat_ass_amg, /* 0x45 x= */
|
||||
concat_amg, /* 0x46 . */
|
||||
concat_ass_amg, /* 0x47 .= */
|
||||
smart_amg, /* 0x48 ~~ */
|
||||
ftest_amg, /* 0x49 -X */
|
||||
regexp_amg, /* 0x4a qr */
|
||||
max_amg_code
|
||||
/* Do not leave a trailing comma here. C9X allows it, C89 doesn't. */
|
||||
};
|
||||
|
||||
#define NofAMmeth max_amg_code
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
570
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pad.h
Normal file
570
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pad.h
Normal file
|
|
@ -0,0 +1,570 @@
|
|||
/* 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.
|
||||
*/
|
||||
|
||||
/* offsets within a pad */
|
||||
|
||||
typedef SSize_t PADOFFSET; /* signed so that -1 is a valid value */
|
||||
#define NOT_IN_PAD ((PADOFFSET) -1)
|
||||
|
||||
/* B.xs expects the first members of these two structs to line up
|
||||
(xpadl_max with xpadnl_fill).
|
||||
*/
|
||||
|
||||
struct padlist {
|
||||
SSize_t xpadl_max; /* max index for which array has space */
|
||||
union {
|
||||
PAD ** xpadlarr_alloc; /* Pointer to beginning of array of AVs.
|
||||
Note that a 'padnamelist *' is stored
|
||||
in the 0 index of the AV. */
|
||||
struct {
|
||||
PADNAMELIST * padnl;
|
||||
PAD * pad_1; /* this slice of PAD * array always alloced */
|
||||
PAD * pad_2; /* maybe unalloced */
|
||||
} * xpadlarr_dbg; /* for use with a C debugger only */
|
||||
} xpadl_arr;
|
||||
U32 xpadl_id; /* Semi-unique ID, shared between clones */
|
||||
U32 xpadl_outid; /* ID of outer pad */
|
||||
};
|
||||
|
||||
struct padnamelist {
|
||||
SSize_t xpadnl_fill; /* max index in use */
|
||||
PADNAME ** xpadnl_alloc; /* pointer to beginning of array */
|
||||
SSize_t xpadnl_max; /* max index for which array has space */
|
||||
PADOFFSET xpadnl_max_named; /* highest index with len > 0 */
|
||||
U32 xpadnl_refcnt;
|
||||
};
|
||||
|
||||
/* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
|
||||
PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
|
||||
define one or the other. */
|
||||
#if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
|
||||
# error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
|
||||
#endif
|
||||
|
||||
#if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
|
||||
# define PERL_PADNAME_MINIMAL
|
||||
#endif
|
||||
|
||||
struct padname_fieldinfo;
|
||||
|
||||
#define _PADNAME_BASE \
|
||||
char * xpadn_pv; \
|
||||
HV * xpadn_ourstash; \
|
||||
union { \
|
||||
HV * xpadn_typestash; \
|
||||
CV * xpadn_protocv; \
|
||||
} xpadn_type_u; \
|
||||
struct padname_fieldinfo *xpadn_fieldinfo; \
|
||||
U32 xpadn_low; \
|
||||
U32 xpadn_high; \
|
||||
U32 xpadn_refcnt; \
|
||||
int xpadn_gen; \
|
||||
U8 xpadn_len; \
|
||||
U8 xpadn_flags
|
||||
|
||||
struct padname {
|
||||
_PADNAME_BASE;
|
||||
};
|
||||
|
||||
struct padname_with_str {
|
||||
#ifdef PERL_PADNAME_MINIMAL
|
||||
_PADNAME_BASE;
|
||||
#else
|
||||
struct padname xpadn_padname;
|
||||
#endif
|
||||
char xpadn_str[1];
|
||||
};
|
||||
|
||||
#undef _PADNAME_BASE
|
||||
|
||||
#define PADNAME_FROM_PV(s) \
|
||||
((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
|
||||
|
||||
/* Most padnames are not field names. Keep all the field-related info in its
|
||||
* own substructure, stored in ->xpadn_fieldinfo.
|
||||
*/
|
||||
struct padname_fieldinfo {
|
||||
U32 refcount;
|
||||
PADOFFSET fieldix; /* index of this field within ObjectFIELDS() array */
|
||||
HV *fieldstash; /* original class package which added this field */
|
||||
OP *defop; /* optree fragment for defaulting expression */
|
||||
SV *paramname; /* name of the :param to look for in constructor */
|
||||
int def_if_undef : 1; /* default op uses //= */
|
||||
int def_if_false : 1; /* default op uses ||= */
|
||||
};
|
||||
|
||||
|
||||
/* 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
|
||||
#define COP_SEQMAX_INC \
|
||||
(PL_cop_seqmax++, \
|
||||
(void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
|
||||
|
||||
|
||||
/* 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) */
|
||||
|
||||
#define COP_SEQ_RANGE_LOW(pn) (pn)->xpadn_low
|
||||
#define COP_SEQ_RANGE_HIGH(pn) (pn)->xpadn_high
|
||||
#define PARENT_PAD_INDEX(pn) (pn)->xpadn_low
|
||||
#define PARENT_FAKELEX_FLAGS(pn) (pn)->xpadn_high
|
||||
|
||||
/* 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_STALEOK 0x08 /* allow stale lexical in active
|
||||
* sub, but only one level up */
|
||||
#define padadd_FIELD 0x10 /* set PADNAMEt_FIELD */
|
||||
#define padfind_FIELD_OK 0x20 /* pad_findlex is permitted to see fields */
|
||||
|
||||
/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
|
||||
* whether PL_comppad and PL_curpad are consistent and whether they have
|
||||
* active values */
|
||||
|
||||
#ifdef DEBUGGING
|
||||
# define ASSERT_CURPAD_LEGAL(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) \
|
||||
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)
|
||||
|
||||
=cut
|
||||
|
||||
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
|
||||
C<my>)
|
||||
|
||||
=for apidoc m|void|SAVECOMPPAD
|
||||
save C<PL_comppad> and C<PL_curpad>
|
||||
|
||||
|
||||
=for apidoc Amx|PAD **|PadlistARRAY|PADLIST * padlist
|
||||
The C array of a padlist, containing the pads. Only subscript it with
|
||||
numbers >= 1, as the 0th entry is not guaranteed to remain usable.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadlistMAX|PADLIST * padlist
|
||||
The index of the last allocated space in the padlist. Note that the last
|
||||
pad may be in an earlier slot. Any entries following it will be C<NULL> in
|
||||
that case.
|
||||
|
||||
=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST * padlist
|
||||
The names associated with pad entries.
|
||||
|
||||
=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST * padlist
|
||||
The C array of pad names.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST * padlist
|
||||
The index of the last pad name.
|
||||
|
||||
=for apidoc Amx|U32|PadlistREFCNT|PADLIST * padlist
|
||||
The reference count of the padlist. Currently this is always 1.
|
||||
|
||||
=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST * pnl
|
||||
The C array of pad names.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST * pnl
|
||||
The index of the last pad name.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST * pnl
|
||||
The reference count of the pad name list.
|
||||
|
||||
=for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST * pnl
|
||||
Lowers the reference count of the pad name list.
|
||||
|
||||
=for apidoc Amx|SV **|PadARRAY|PAD * pad
|
||||
The C array of pad entries.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadMAX|PAD * pad
|
||||
The index of the last pad entry.
|
||||
|
||||
=for apidoc Amx|char *|PadnamePV|PADNAME * pn
|
||||
The name stored in the pad name struct. This returns C<NULL> for a target
|
||||
slot.
|
||||
|
||||
=for apidoc Amx|STRLEN|PadnameLEN|PADNAME * pn
|
||||
The length of the name.
|
||||
|
||||
=for apidoc Amx|bool|PadnameUTF8|PADNAME * pn
|
||||
Whether PadnamePV is in UTF-8. Currently, this is always true.
|
||||
|
||||
=for apidoc Amx|SV *|PadnameSV|PADNAME * pn
|
||||
Returns the pad name as a mortal SV.
|
||||
|
||||
=for apidoc m|bool|PadnameIsOUR|PADNAME * pn
|
||||
Whether this is an "our" variable.
|
||||
|
||||
=for apidoc m|HV *|PadnameOURSTASH|PADNAME * pn
|
||||
The stash in which this "our" variable was declared.
|
||||
|
||||
=for apidoc m|bool|PadnameOUTER|PADNAME * pn
|
||||
Whether this entry belongs to an outer pad. Entries for which this is true
|
||||
are often referred to as 'fake'.
|
||||
|
||||
=for apidoc m|bool|PadnameIsSTATE|PADNAME * pn
|
||||
Whether this is a "state" variable.
|
||||
|
||||
=for apidoc m|bool|PadnameIsFIELD|PADNAME * pn
|
||||
Whether this is a "field" variable. PADNAMEs where this is true will
|
||||
have additional information available via C<PadnameFIELDINFO>.
|
||||
|
||||
=for apidoc m|HV *|PadnameTYPE|PADNAME * pn
|
||||
The stash associated with a typed lexical. This returns the C<%Foo::> hash
|
||||
for C<my Foo $bar>.
|
||||
|
||||
=for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME * pn
|
||||
The reference count of the pad name.
|
||||
|
||||
=for apidoc Amx|PADNAME *|PadnameREFCNT_inc|PADNAME * pn
|
||||
Increases the reference count of the pad name. Returns the pad name itself.
|
||||
|
||||
=for apidoc Amx|void|PadnameREFCNT_dec|PADNAME * pn
|
||||
Lowers the reference count of the pad name.
|
||||
|
||||
|
||||
=for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
|
||||
Set the slot at offset C<po> in the current pad to C<sv>
|
||||
|
||||
=for apidoc m|SV *|PAD_SV |PADOFFSET po
|
||||
Get the value at offset C<po> in the current pad
|
||||
|
||||
=for apidoc m|SV *|PAD_SVl |PADOFFSET po
|
||||
Lightweight and lvalue version of C<PAD_SV>.
|
||||
Get or set the value at offset C<po> in the current pad.
|
||||
Unlike C<PAD_SV>, 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<po> 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<n> 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 C<opad>, then make the
|
||||
current pad equal to C<npad>
|
||||
|
||||
=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
|
||||
Restore the old pad saved into the local variable C<opad> by C<PAD_SAVE_LOCAL()>
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#define PadlistARRAY(pl) (pl)->xpadl_arr.xpadlarr_alloc
|
||||
#define PadlistMAX(pl) (pl)->xpadl_max
|
||||
#define PadlistNAMES(pl) *((PADNAMELIST **)PadlistARRAY(pl))
|
||||
#define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl))
|
||||
#define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl))
|
||||
#define PadlistREFCNT(pl) 1 /* reserved for future use */
|
||||
|
||||
#define PadnamelistARRAY(pnl) (pnl)->xpadnl_alloc
|
||||
#define PadnamelistMAX(pnl) (pnl)->xpadnl_fill
|
||||
#define PadnamelistMAXNAMED(pnl) (pnl)->xpadnl_max_named
|
||||
#define PadnamelistREFCNT(pnl) (pnl)->xpadnl_refcnt
|
||||
#define PadnamelistREFCNT_inc(pnl) Perl_padnamelist_refcnt_inc(pnl)
|
||||
#define PadnamelistREFCNT_dec(pnl) Perl_padnamelist_free(aTHX_ pnl)
|
||||
|
||||
#define PadARRAY(pad) AvARRAY(pad)
|
||||
#define PadMAX(pad) AvFILLp(pad)
|
||||
|
||||
#define PadnamePV(pn) (pn)->xpadn_pv
|
||||
#define PadnameLEN(pn) (pn)->xpadn_len
|
||||
#define PadnameUTF8(pn) 1
|
||||
#define PadnameSV(pn) \
|
||||
newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
|
||||
#define PadnameFLAGS(pn) (pn)->xpadn_flags
|
||||
#define PadnameIsOUR(pn) cBOOL((pn)->xpadn_ourstash)
|
||||
#define PadnameOURSTASH(pn) (pn)->xpadn_ourstash
|
||||
#define PadnameTYPE(pn) (pn)->xpadn_type_u.xpadn_typestash
|
||||
#define PadnameHasTYPE(pn) cBOOL(PadnameTYPE(pn))
|
||||
#define PadnamePROTOCV(pn) (pn)->xpadn_type_u.xpadn_protocv
|
||||
#define PadnameREFCNT(pn) (pn)->xpadn_refcnt
|
||||
#define PadnameREFCNT_inc(pn) Perl_padname_refcnt_inc(pn)
|
||||
#define PadnameREFCNT_dec(pn) Perl_padname_free(aTHX_ pn)
|
||||
#define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
|
||||
#define PadnameTYPE_set(pn,s) (PadnameTYPE(pn) = (s))
|
||||
#define PadnameFIELDINFO(pn) (pn)->xpadn_fieldinfo
|
||||
#define PadnameOUTER(pn) (PadnameFLAGS(pn) & PADNAMEf_OUTER)
|
||||
#define PadnameIsSTATE(pn) (PadnameFLAGS(pn) & PADNAMEf_STATE)
|
||||
#define PadnameLVALUE(pn) (PadnameFLAGS(pn) & PADNAMEf_LVALUE)
|
||||
#define PadnameIsFIELD(pn) (PadnameFLAGS(pn) & PADNAMEf_FIELD)
|
||||
|
||||
#define PadnameLVALUE_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_LVALUE)
|
||||
#define PadnameIsSTATE_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_STATE)
|
||||
|
||||
#define PADNAMEf_OUTER 0x01 /* outer lexical var */
|
||||
#define PADNAMEf_STATE 0x02 /* state var */
|
||||
#define PADNAMEf_LVALUE 0x04 /* used as lvalue */
|
||||
#define PADNAMEf_TYPED 0x08 /* for B; unused by core */
|
||||
#define PADNAMEf_OUR 0x10 /* for B; unused by core */
|
||||
#define PADNAMEf_FIELD 0x20 /* field var */
|
||||
|
||||
/* backward compatibility */
|
||||
#ifndef PERL_CORE
|
||||
# define SvPAD_STATE PadnameIsSTATE
|
||||
# define SvPAD_TYPED PadnameHasTYPE
|
||||
# define SvPAD_OUR(pn) cBOOL(PadnameOURSTASH(pn))
|
||||
# define SvPAD_STATE_on PadnameIsSTATE_on
|
||||
# define SvPAD_TYPED_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_TYPED)
|
||||
# define SvPAD_OUR_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_OUR)
|
||||
# define SvOURSTASH PadnameOURSTASH
|
||||
# define SvOURSTASH_set PadnameOURSTASH_set
|
||||
# define SVpad_STATE PADNAMEf_STATE
|
||||
# define SVpad_TYPED PADNAMEf_TYPED
|
||||
# define SVpad_OUR PADNAMEf_OUR
|
||||
# define PADNAMEt_OUTER PADNAMEf_OUTER
|
||||
# define PADNAMEt_STATE PADNAMEf_STATE
|
||||
# define PADNAMEt_LVALUE PADNAMEf_LVALUE
|
||||
# define PADNAMEt_TYPED PADNAMEf_TYPED
|
||||
# define PADNAMEt_OUR PADNAMEf_OUR
|
||||
#endif
|
||||
|
||||
#ifdef USE_ITHREADS
|
||||
# define padnamelist_dup_inc(pnl,param) PadnamelistREFCNT_inc(padnamelist_dup(pnl,param))
|
||||
# define padname_dup_inc(pn,param) PadnameREFCNT_inc(padname_dup(pn,param))
|
||||
#endif
|
||||
|
||||
#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) \
|
||||
(PadlistARRAY(padlist)[1]) \
|
||||
? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
|
||||
: NULL;
|
||||
|
||||
|
||||
#define PAD_SET_CUR_NOSAVE(padlist,nth) \
|
||||
PL_comppad = (PAD*) (PadlistARRAY(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 C<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<po>. 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<po>. 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<po>. 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<our> variable.
|
||||
Assumes the slot entry is a valid C<our> lexical.
|
||||
|
||||
=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
|
||||
The generation number of the name at offset C<po> in the current
|
||||
compiling pad (lvalue).
|
||||
|
||||
=for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
|
||||
Sets the generation number of the name at offset C<po> in the current
|
||||
ling pad (lvalue) to C<gen>.
|
||||
=cut
|
||||
|
||||
*/
|
||||
|
||||
#define PAD_COMPNAME(po) PAD_COMPNAME_SV(po)
|
||||
#define PAD_COMPNAME_SV(po) (PadnamelistARRAY(PL_comppad_name)[(po)])
|
||||
#define PAD_COMPNAME_FLAGS(po) PadnameFLAGS(PAD_COMPNAME(po))
|
||||
#define PAD_COMPNAME_FLAGS_isOUR(po) PadnameIsOUR(PAD_COMPNAME_SV(po))
|
||||
#define PAD_COMPNAME_PV(po) PadnamePV(PAD_COMPNAME(po))
|
||||
|
||||
#define PAD_COMPNAME_TYPE(po) PadnameTYPE(PAD_COMPNAME(po))
|
||||
|
||||
#define PAD_COMPNAME_OURSTASH(po) (PadnameOURSTASH(PAD_COMPNAME_SV(po)))
|
||||
|
||||
#define PAD_COMPNAME_GEN(po) \
|
||||
((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
|
||||
|
||||
#define PAD_COMPNAME_GEN_set(po, gen) \
|
||||
(PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (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 = \
|
||||
padnamelist_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|"name"|U32 flags|HV *typestash|HV *ourstash
|
||||
|
||||
Exactly like L</pad_add_name_pvn>, 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|"name"|U32 flags
|
||||
|
||||
Exactly like L</pad_findmy_pvn>, 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)
|
||||
|
||||
struct suspended_compcv
|
||||
{
|
||||
CV *compcv;
|
||||
STRLEN padix, constpadix;
|
||||
STRLEN comppad_name_fill;
|
||||
STRLEN min_intro_pending, max_intro_pending;
|
||||
bool cv_has_eval, pad_reset_pending;
|
||||
};
|
||||
|
||||
#define resume_compcv_final(buffer) Perl_resume_compcv(aTHX_ buffer, false)
|
||||
#define resume_compcv_and_save(buffer) Perl_resume_compcv(aTHX_ buffer, true)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
165
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/parser.h
Normal file
165
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/parser.h
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
/* 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;
|
||||
|
||||
/* Fields that need to be shared with (i.e., visible to) inner lex-
|
||||
ing scopes. */
|
||||
typedef struct yy_lexshared {
|
||||
struct yy_lexshared *ls_prev;
|
||||
SV *ls_linestr; /* mirrors PL_parser->linestr */
|
||||
char *ls_bufptr; /* mirrors PL_parser->bufptr */
|
||||
char *re_eval_start; /* start of "(?{..." text */
|
||||
SV *re_eval_str; /* "(?{...})" text */
|
||||
} LEXSHARED;
|
||||
|
||||
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;
|
||||
|
||||
yy_stack_frame *stack; /* base of stack */
|
||||
yy_stack_frame *stack_max1;/* (top-1)th element of allocated stack */
|
||||
yy_stack_frame *ps; /* current stack frame */
|
||||
int yylen; /* length of active reduction */
|
||||
|
||||
/* lexer state */
|
||||
|
||||
I32 lex_formbrack; /* bracket count at outer format level */
|
||||
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 */
|
||||
U8 lex_dojoin; /* doing an array interpolation
|
||||
1 = @{...} 2 = ->@ */
|
||||
U8 expect; /* how to interpret ambiguous tokens */
|
||||
bool preambled;
|
||||
bool sub_no_recover; /* can't recover from a sublex error */
|
||||
U8 sub_error_count; /* the number of errors before sublexing */
|
||||
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 named list or unary 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 */
|
||||
UV multi_open; /* delimiter code point of said string */
|
||||
UV multi_close; /* delimiter code point of said string */
|
||||
bool lex_re_reparsing; /* we're doing G_RE_REPARSING */
|
||||
U8 lex_super_state;/* lexer state to save */
|
||||
U16 lex_sub_inwhat; /* "lex_inwhat" to use in sublex_push */
|
||||
I32 lex_allbrackets;/* (), [], {}, ?: bracket count */
|
||||
OP *lex_sub_op; /* current op in y/// or pattern */
|
||||
SV *lex_sub_repl; /* repl of s/// used in sublex_push */
|
||||
LEXSHARED *lex_shared;
|
||||
SV *linestr; /* current chunk of src text */
|
||||
char *bufptr; /* carries the cursor (current parsing
|
||||
position) from one invocation of yylex
|
||||
to the next */
|
||||
char *oldbufptr; /* in yylex, beginning of current token */
|
||||
char *oldoldbufptr; /* in yylex, beginning of previous token */
|
||||
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 */
|
||||
/* copline is used to pass a specific line number to newSTATEOP. It
|
||||
is a one-time line number, as newSTATEOP invalidates it (sets it to
|
||||
NOLINE) after using it. The purpose of this is to report line num-
|
||||
bers in multiline constructs using the number of the first line. */
|
||||
line_t copline;
|
||||
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 */
|
||||
|
||||
YYSTYPE nextval[5]; /* value of next token, if any */
|
||||
I32 nexttype[5]; /* type of next token */
|
||||
U8 nexttoke;
|
||||
U8 form_lex_state; /* remember lex_state when parsing fmt */
|
||||
U8 lex_fakeeof; /* precedence at which to fake EOF */
|
||||
U8 lex_flags;
|
||||
COP *saved_curcop; /* the previous PL_curcop */
|
||||
char tokenbuf[256];
|
||||
line_t herelines; /* number of lines in here-doc */
|
||||
line_t preambling; /* line # when processing $ENV{PERL5DB} */
|
||||
|
||||
/* these are valid while parsing a subroutine signature */
|
||||
UV sig_elems; /* number of signature elements seen so far */
|
||||
UV sig_optelems; /* number of optional signature elems seen */
|
||||
char sig_slurpy; /* the sigil of the slurpy var (or null) */
|
||||
bool sig_seen; /* the currently parsing sub has a signature */
|
||||
|
||||
bool recheck_utf8_validity;
|
||||
|
||||
PERL_BITFIELD16 in_pod:1; /* lexer is within a =pod section */
|
||||
PERL_BITFIELD16 filtered:1; /* source filters in evalbytes */
|
||||
PERL_BITFIELD16 saw_infix_sigil:1; /* saw & or * or % operator */
|
||||
PERL_BITFIELD16 parsed_sub:1; /* last thing parsed was a sub */
|
||||
} 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
|
||||
};
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/patchlevel.h
Normal file
178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/patchlevel.h
Normal file
|
|
@ -0,0 +1,178 @@
|
|||
/* patchlevel.h
|
||||
*
|
||||
* Copyright (C) 1993, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
=for apidoc AmDnU|U8|PERL_REVISION
|
||||
The major number component of the perl interpreter currently being compiled or
|
||||
executing. This has been C<5> from 1993 into 2020.
|
||||
|
||||
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
|
||||
|
||||
=for apidoc AmDnU|U8|PERL_VERSION
|
||||
The minor number component of the perl interpreter currently being compiled or
|
||||
executing. Between 1993 into 2020, this has ranged from 0 to 33.
|
||||
|
||||
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
|
||||
|
||||
=for apidoc AmDnU|U8|PERL_SUBVERSION
|
||||
The micro number component of the perl interpreter currently being compiled or
|
||||
executing. In stable releases this gives the dot release number for
|
||||
maintenance updates. In development releases this gives a tag for a snapshot
|
||||
of the status at various points in the development cycle.
|
||||
|
||||
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#ifndef __PATCHLEVEL_H_INCLUDED__
|
||||
|
||||
/* do not adjust the whitespace! Configure expects the numbers to be
|
||||
* exactly on the third column */
|
||||
|
||||
#define PERL_REVISION 5 /* age */
|
||||
#define PERL_VERSION 40 /* epoch */
|
||||
#define PERL_SUBVERSION 3 /* generation */
|
||||
|
||||
/* The following numbers describe the earliest compatible version of
|
||||
Perl ("compatibility" here being defined as sufficient binary/API
|
||||
compatibility to run XS code built with the older version).
|
||||
Normally this should not change across maintenance releases.
|
||||
|
||||
Note that this only refers to an out-of-the-box build. Many non-default
|
||||
options such as usemultiplicity tend to break binary compatibility
|
||||
more often.
|
||||
|
||||
This is used by Configure et al to figure out
|
||||
PERL_INC_VERSION_LIST, which lists version libraries
|
||||
to include in @INC. See INSTALL for how this works.
|
||||
|
||||
Porting/bump-perl-version will automatically set these to the version of perl
|
||||
to be released for blead releases, and to 5.X.0 for maint releases. Manually
|
||||
changing them should not be necessary.
|
||||
*/
|
||||
#define PERL_API_REVISION 5
|
||||
#define PERL_API_VERSION 40
|
||||
#define PERL_API_SUBVERSION 0
|
||||
/*
|
||||
XXX Note: The selection of non-default Configure options, such
|
||||
as -Duselonglong may invalidate these settings. Currently, Configure
|
||||
does not adequately test for this. A.D. Jan 13, 2000
|
||||
*/
|
||||
|
||||
#define __PATCHLEVEL_H_INCLUDED__
|
||||
#endif
|
||||
|
||||
/*
|
||||
local_patches -- list of locally applied less-than-subversion patches.
|
||||
If you're distributing such a patch, please give it a name and a
|
||||
one-line description, placed just before the last NULL in the array
|
||||
below. If your patch fixes a bug in the perlbug database, please
|
||||
mention the bugid. If your patch *IS* dependent on a prior patch,
|
||||
please place your applied patch line after its dependencies. This
|
||||
will help tracking of patch dependencies.
|
||||
|
||||
Please either use 'diff --unified=0' if your diff supports
|
||||
that or edit the hunk of the diff output which adds your patch
|
||||
to this list, to remove context lines which would give patch
|
||||
problems. For instance, if the original context diff is
|
||||
|
||||
*** patchlevel.h.orig <date here>
|
||||
--- patchlevel.h <date here>
|
||||
*** 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 <date here>
|
||||
--- patchlevel.h <date here>
|
||||
*** 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 (<PLIN>) {
|
||||
if (/^(\s+),NULL/ and $seen) {
|
||||
my $pre = $1;
|
||||
while (my $c = shift @ARGV){
|
||||
$c =~ s|\\|\\\\|g;
|
||||
$c =~ s|"|\\"|g;
|
||||
print PLOUT qq{$pre,"$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*/
|
||||
# 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 */
|
||||
,"Cygwin: README"
|
||||
,"Cygwin: modify hints"
|
||||
,"Cygwin: Win32 correct UTF8 handling for tests"
|
||||
,NULL
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* Initial space prevents this variable from being inserted in config.sh */
|
||||
# define LOCAL_PATCH_COUNT \
|
||||
((int)(C_ARRAY_LENGTH(local_patches)-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
|
||||
9264
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl.h
Normal file
9264
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl.h
Normal file
File diff suppressed because it is too large
Load diff
182
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_inc_macro.h
Normal file
182
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_inc_macro.h
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
/* just define a list of macros to push elements in INC
|
||||
* so we can easily use them and change order on demand
|
||||
*
|
||||
* list of available INCPUSH macros
|
||||
* - INCPUSH_APPLLIB_EXP
|
||||
* - INCPUSH_SITEARCH_EXP
|
||||
* - INCPUSH_SITELIB_EXP
|
||||
* - INCPUSH_PERL_VENDORARCH_EXP
|
||||
* - INCPUSH_PERL_VENDORLIB_EXP
|
||||
* - INCPUSH_ARCHLIB_EXP
|
||||
* - INCPUSH_PRIVLIB_EXP
|
||||
* - INCPUSH_PERL_OTHERLIBDIRS
|
||||
* - INCPUSH_PERL5LIB
|
||||
* - INCPUSH_APPLLIB_OLD_EXP
|
||||
* - INCPUSH_SITELIB_STEM
|
||||
* - INCPUSH_PERL_VENDORLIB_STEM
|
||||
* - INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
|
||||
*/
|
||||
|
||||
#ifndef DEFINE_INC_MACROS
|
||||
|
||||
/* protect against multiple inclusions */
|
||||
#define DEFINE_INC_MACROS 1
|
||||
|
||||
#ifdef APPLLIB_EXP
|
||||
# define INCPUSH_APPLLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
|
||||
INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
#ifdef SITEARCH_EXP
|
||||
/* sitearch is always relative to sitelib on Windows for
|
||||
* DLL-based path intuition to work correctly */
|
||||
# if !defined(WIN32)
|
||||
# define INCPUSH_SITEARCH_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITEARCH_EXP), \
|
||||
INCPUSH_CAN_RELOCATE);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef SITELIB_EXP
|
||||
# if defined(WIN32)
|
||||
/* this picks up sitearch as well */
|
||||
# define INCPUSH_SITELIB_EXP s = PerlEnv_sitelib_path(PERL_FS_VERSION, &len); \
|
||||
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
|
||||
# else
|
||||
# define INCPUSH_SITELIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_EXP), \
|
||||
INCPUSH_CAN_RELOCATE);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef PERL_VENDORARCH_EXP
|
||||
/* vendorarch is always relative to vendorlib on Windows for
|
||||
* DLL-based path intuition to work correctly */
|
||||
# if !defined(WIN32)
|
||||
# define INCPUSH_PERL_VENDORARCH_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORARCH_EXP), INCPUSH_CAN_RELOCATE);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef PERL_VENDORLIB_EXP
|
||||
# if defined(WIN32)
|
||||
/* this picks up vendorarch as well */
|
||||
# define INCPUSH_PERL_VENDORLIB_EXP s = PerlEnv_vendorlib_path(PERL_FS_VERSION, &len); \
|
||||
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
|
||||
# else
|
||||
# define INCPUSH_PERL_VENDORLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_EXP), INCPUSH_CAN_RELOCATE);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef ARCHLIB_EXP
|
||||
# define INCPUSH_ARCHLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(ARCHLIB_EXP), INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
/* used by INCPUSH_PRIVLIB_EXP */
|
||||
#ifndef PRIVLIB_EXP
|
||||
# define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
|
||||
#endif
|
||||
|
||||
#if defined(WIN32)
|
||||
# define INCPUSH_PRIVLIB_EXP s = PerlEnv_lib_path(PERL_FS_VERSION, &len); \
|
||||
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
|
||||
#else
|
||||
# define INCPUSH_PRIVLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PRIVLIB_EXP), INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
#ifdef PERL_OTHERLIBDIRS
|
||||
# define INCPUSH_PERL_OTHERLIBDIRS S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
|
||||
INCPUSH_ADD_VERSIONED_SUB_DIRS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
|
||||
/* submacros for INCPUSH_PERL5LIB */
|
||||
|
||||
#define _INCPUSH_PERL5LIB_IF if (perl5lib && *perl5lib != '\0')
|
||||
|
||||
#ifndef VMS
|
||||
# define _INCPUSH_PERL5LIB_ADD _INCPUSH_PERL5LIB_IF incpush_use_sep(perl5lib, 0, INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR);
|
||||
#else
|
||||
/* VMS */
|
||||
/* Treat PERL5?LIB as a possible search list logical name -- the
|
||||
* "natural" VMS idiom for a Unix path string. We allow each
|
||||
* element to be a set of |-separated directories for compatibility.
|
||||
*/
|
||||
# define _INCPUSH_PERL5LIB_ADD char buf[256]; \
|
||||
int idx = 0; \
|
||||
if (vmstrnenv("PERL5LIB",buf,0,NULL,0)) \
|
||||
do { \
|
||||
incpush_use_sep(buf, 0, \
|
||||
INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR); \
|
||||
} while (vmstrnenv("PERL5LIB",buf,++idx,NULL,0));
|
||||
#endif
|
||||
|
||||
/* this macro is special and use submacros from above */
|
||||
#define INCPUSH_PERL5LIB if (!TAINTING_get) { _INCPUSH_PERL5LIB_ADD }
|
||||
|
||||
/* Use the ~-expanded versions of APPLLIB (undocumented),
|
||||
SITELIB and VENDORLIB for older versions
|
||||
*/
|
||||
#ifdef APPLLIB_EXP
|
||||
# define INCPUSH_APPLLIB_OLD_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
|
||||
INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
#if defined(SITELIB_STEM) && defined(PERL_INC_VERSION_LIST)
|
||||
/* Search for version-specific dirs below here */
|
||||
# define INCPUSH_SITELIB_STEM S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_STEM), \
|
||||
INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(PERL_VENDORLIB_STEM) && defined(PERL_INC_VERSION_LIST)
|
||||
/* Search for version-specific dirs below here */
|
||||
# define INCPUSH_PERL_VENDORLIB_STEM S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_STEM), \
|
||||
INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
#ifdef PERL_OTHERLIBDIRS
|
||||
# define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
|
||||
INCPUSH_ADD_OLD_VERS|INCPUSH_ADD_ARCHONLY_SUB_DIRS|INCPUSH_CAN_RELOCATE);
|
||||
#endif
|
||||
|
||||
|
||||
/* define all undefined macros... */
|
||||
#ifndef INCPUSH_APPLLIB_EXP
|
||||
#define INCPUSH_APPLLIB_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_SITEARCH_EXP
|
||||
#define INCPUSH_SITEARCH_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_SITELIB_EXP
|
||||
#define INCPUSH_SITELIB_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL_VENDORARCH_EXP
|
||||
#define INCPUSH_PERL_VENDORARCH_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL_VENDORLIB_EXP
|
||||
#define INCPUSH_PERL_VENDORLIB_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_ARCHLIB_EXP
|
||||
#define INCPUSH_ARCHLIB_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_PRIVLIB_EXP
|
||||
#define INCPUSH_PRIVLIB_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL_OTHERLIBDIRS
|
||||
#define INCPUSH_PERL_OTHERLIBDIRS
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL5LIB
|
||||
#define INCPUSH_PERL5LIB
|
||||
#endif
|
||||
#ifndef INCPUSH_APPLLIB_OLD_EXP
|
||||
#define INCPUSH_APPLLIB_OLD_EXP
|
||||
#endif
|
||||
#ifndef INCPUSH_SITELIB_STEM
|
||||
#define INCPUSH_SITELIB_STEM
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL_VENDORLIB_STEM
|
||||
#define INCPUSH_PERL_VENDORLIB_STEM
|
||||
#endif
|
||||
#ifndef INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
|
||||
#define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
|
||||
#endif
|
||||
|
||||
#endif /* DEFINE_INC_MACROS */
|
||||
337
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_langinfo.h
Normal file
337
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_langinfo.h
Normal file
|
|
@ -0,0 +1,337 @@
|
|||
/* Replaces <langinfo.h>, and allows our code to work on systems that don't
|
||||
* have that. */
|
||||
|
||||
#ifndef PERL_LANGINFO_H
|
||||
#define PERL_LANGINFO_H 1
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#if defined(I_LANGINFO)
|
||||
# include <langinfo.h>
|
||||
#else
|
||||
|
||||
typedef int nl_item; /* Substitute 'int' for emulated nl_langinfo() */
|
||||
|
||||
#endif
|
||||
|
||||
/* NOTE that this file is parsed by ext/XS-APItest/t/locale.t, so be careful
|
||||
* with changes */
|
||||
|
||||
/* If foo doesn't exist define it to a negative number. */
|
||||
|
||||
#ifndef CODESET
|
||||
# define CODESET -1
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef D_T_FMT
|
||||
# define D_T_FMT -2
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef D_FMT
|
||||
# define D_FMT -3
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef T_FMT
|
||||
# define T_FMT -4
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef T_FMT_AMPM
|
||||
# define T_FMT_AMPM -5
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef AM_STR
|
||||
# define AM_STR -6
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef PM_STR
|
||||
# define PM_STR -7
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_1
|
||||
# define DAY_1 -8
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_2
|
||||
# define DAY_2 -9
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_3
|
||||
# define DAY_3 -10
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_4
|
||||
# define DAY_4 -11
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_5
|
||||
# define DAY_5 -12
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_6
|
||||
# define DAY_6 -13
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef DAY_7
|
||||
# define DAY_7 -14
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_1
|
||||
# define ABDAY_1 -15
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_2
|
||||
# define ABDAY_2 -16
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_3
|
||||
# define ABDAY_3 -17
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_4
|
||||
# define ABDAY_4 -18
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_5
|
||||
# define ABDAY_5 -19
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_6
|
||||
# define ABDAY_6 -20
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABDAY_7
|
||||
# define ABDAY_7 -21
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_1
|
||||
# define MON_1 -22
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_2
|
||||
# define MON_2 -23
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_3
|
||||
# define MON_3 -24
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_4
|
||||
# define MON_4 -25
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_5
|
||||
# define MON_5 -26
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_6
|
||||
# define MON_6 -27
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_7
|
||||
# define MON_7 -28
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_8
|
||||
# define MON_8 -29
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_9
|
||||
# define MON_9 -30
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_10
|
||||
# define MON_10 -31
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_11
|
||||
# define MON_11 -32
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef MON_12
|
||||
# define MON_12 -33
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_1
|
||||
# define ABMON_1 -34
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_2
|
||||
# define ABMON_2 -35
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_3
|
||||
# define ABMON_3 -36
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_4
|
||||
# define ABMON_4 -37
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_5
|
||||
# define ABMON_5 -38
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_6
|
||||
# define ABMON_6 -39
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_7
|
||||
# define ABMON_7 -40
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_8
|
||||
# define ABMON_8 -41
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_9
|
||||
# define ABMON_9 -42
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_10
|
||||
# define ABMON_10 -43
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_11
|
||||
# define ABMON_11 -44
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ABMON_12
|
||||
# define ABMON_12 -45
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ERA
|
||||
# define ERA -46
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ERA_D_FMT
|
||||
# define ERA_D_FMT -47
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ERA_D_T_FMT
|
||||
# define ERA_D_T_FMT -48
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ERA_T_FMT
|
||||
# define ERA_T_FMT -49
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef ALT_DIGITS
|
||||
# define ALT_DIGITS -50
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef RADIXCHAR
|
||||
# define RADIXCHAR -51
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef THOUSEP
|
||||
# define THOUSEP -52
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef YESEXPR
|
||||
# define YESEXPR -53
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef YESSTR
|
||||
# define YESSTR -54
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef NOEXPR
|
||||
# define NOEXPR -55
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef NOSTR
|
||||
# define NOSTR -56
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#ifndef CRNCYSTR
|
||||
# define CRNCYSTR -57
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
|
||||
/* The rest of the items are gnu extensions, and are not #defined by its
|
||||
* langinfo.h. There is a slight possibility that one of these numbers could
|
||||
* conflict with some other value, in which case after much gnashing of teeth
|
||||
* you will find this comment, and end up having to adjust the numbers. But
|
||||
* glibc values are not (so far) negative */
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_ADDRESS)
|
||||
# define _NL_ADDRESS_POSTAL_FMT -58
|
||||
# define _NL_ADDRESS_COUNTRY_NAME -59
|
||||
# define _NL_ADDRESS_COUNTRY_POST -60
|
||||
# define _NL_ADDRESS_COUNTRY_AB2 -61
|
||||
# define _NL_ADDRESS_COUNTRY_AB3 -62
|
||||
# define _NL_ADDRESS_COUNTRY_CAR -63
|
||||
# define _NL_ADDRESS_COUNTRY_NUM -64
|
||||
# define _NL_ADDRESS_COUNTRY_ISBN -65
|
||||
# define _NL_ADDRESS_LANG_NAME -66
|
||||
# define _NL_ADDRESS_LANG_AB -67
|
||||
# define _NL_ADDRESS_LANG_TERM -68
|
||||
# define _NL_ADDRESS_LANG_LIB -69
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_IDENTIFICATION)
|
||||
# define _NL_IDENTIFICATION_TITLE -70
|
||||
# define _NL_IDENTIFICATION_SOURCE -71
|
||||
# define _NL_IDENTIFICATION_ADDRESS -72
|
||||
# define _NL_IDENTIFICATION_CONTACT -73
|
||||
# define _NL_IDENTIFICATION_EMAIL -74
|
||||
# define _NL_IDENTIFICATION_TEL -75
|
||||
# define _NL_IDENTIFICATION_FAX -76
|
||||
# define _NL_IDENTIFICATION_LANGUAGE -77
|
||||
# define _NL_IDENTIFICATION_TERRITORY -78
|
||||
# define _NL_IDENTIFICATION_AUDIENCE -79
|
||||
# define _NL_IDENTIFICATION_APPLICATION -80
|
||||
# define _NL_IDENTIFICATION_ABBREVIATION -81
|
||||
# define _NL_IDENTIFICATION_REVISION -82
|
||||
# define _NL_IDENTIFICATION_DATE -83
|
||||
# define _NL_IDENTIFICATION_CATEGORY -84
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_MEASUREMENT)
|
||||
# define _NL_MEASUREMENT_MEASUREMENT -85
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_NAME)
|
||||
# define _NL_NAME_NAME_FMT -86
|
||||
# define _NL_NAME_NAME_GEN -87
|
||||
# define _NL_NAME_NAME_MR -88
|
||||
# define _NL_NAME_NAME_MRS -89
|
||||
# define _NL_NAME_NAME_MISS -90
|
||||
# define _NL_NAME_NAME_MS -91
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_PAPER)
|
||||
# define _NL_PAPER_HEIGHT -92
|
||||
# define _NL_PAPER_WIDTH -93
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_TELEPHONE)
|
||||
# define _NL_TELEPHONE_TEL_INT_FMT -94
|
||||
# define _NL_TELEPHONE_TEL_DOM_FMT -95
|
||||
# define _NL_TELEPHONE_INT_SELECT -96
|
||||
# define _NL_TELEPHONE_INT_PREFIX -97
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
|
||||
/* All these categories have to be emulated if not available on the platform */
|
||||
#if ! LC_CTYPE_AVAIL_ \
|
||||
|| ! LC_MESSAGES_AVAIL_ \
|
||||
|| ! LC_MONETARY_AVAIL_ \
|
||||
|| ! LC_NUMERIC_AVAIL_ \
|
||||
|| ! LC_TIME_AVAIL_ \
|
||||
|| ! LC_ADDRESS_AVAIL_ \
|
||||
|| ! LC_IDENTIFICATION_AVAIL_ \
|
||||
|| ! LC_MEASUREMENT_AVAIL_ \
|
||||
|| ! LC_NAME_AVAIL_ \
|
||||
|| ! LC_PAPER_AVAIL_ \
|
||||
|| ! LC_TELEPHONE_AVAIL_
|
||||
|
||||
# define HAS_MISSING_LANGINFO_ITEM_
|
||||
#endif
|
||||
|
||||
#endif /* PERL_LANGINFO_H */
|
||||
127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_siphash.h
Normal file
127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_siphash.h
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
/* This is SipHash by Jean-Philippe Aumasson and Daniel J. Bernstein.
|
||||
* The authors claim it is relatively secure compared to the alternatives
|
||||
* and that performance wise it is a suitable hash for languages like Perl.
|
||||
* See:
|
||||
*
|
||||
* https://www.131002.net/siphash/
|
||||
*
|
||||
* This implementation seems to perform slightly slower than one-at-a-time for
|
||||
* short keys, but degrades slower for longer keys. Murmur Hash outperforms it
|
||||
* regardless of keys size.
|
||||
*
|
||||
* It is 64 bit only.
|
||||
*/
|
||||
|
||||
#ifdef CAN64BITHASH
|
||||
|
||||
#define SIPROUND \
|
||||
STMT_START { \
|
||||
v0 += v1; v1=ROTL64(v1,13); v1 ^= v0; v0=ROTL64(v0,32); \
|
||||
v2 += v3; v3=ROTL64(v3,16); v3 ^= v2; \
|
||||
v0 += v3; v3=ROTL64(v3,21); v3 ^= v0; \
|
||||
v2 += v1; v1=ROTL64(v1,17); v1 ^= v2; v2=ROTL64(v2,32); \
|
||||
} STMT_END
|
||||
|
||||
#define SIPHASH_SEED_STATE(key,v0,v1,v2,v3) \
|
||||
do { \
|
||||
v0 = v2 = U8TO64_LE(key + 0); \
|
||||
v1 = v3 = U8TO64_LE(key + 8); \
|
||||
/* "somepseudorandomlygeneratedbytes" */ \
|
||||
v0 ^= UINT64_C(0x736f6d6570736575); \
|
||||
v1 ^= UINT64_C(0x646f72616e646f6d); \
|
||||
v2 ^= UINT64_C(0x6c7967656e657261); \
|
||||
v3 ^= UINT64_C(0x7465646279746573); \
|
||||
} while (0)
|
||||
|
||||
PERL_STATIC_INLINE
|
||||
void S_perl_siphash_seed_state(const unsigned char * const seed_buf, unsigned char * state_buf) {
|
||||
U64 *v= (U64*) state_buf;
|
||||
SIPHASH_SEED_STATE(seed_buf, v[0],v[1],v[2],v[3]);
|
||||
}
|
||||
|
||||
#define PERL_SIPHASH_FNC(FNC,SIP_ROUNDS,SIP_FINAL_ROUNDS) \
|
||||
PERL_STATIC_INLINE U64 \
|
||||
FNC ## _with_state_64 \
|
||||
(const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
|
||||
{ \
|
||||
const int left = inlen & 7; \
|
||||
const U8 *end = in + inlen - left; \
|
||||
\
|
||||
U64 b = ( ( U64 )(inlen) ) << 56; \
|
||||
U64 m; \
|
||||
U64 v0 = U8TO64_LE(state); \
|
||||
U64 v1 = U8TO64_LE(state+8); \
|
||||
U64 v2 = U8TO64_LE(state+16); \
|
||||
U64 v3 = U8TO64_LE(state+24); \
|
||||
\
|
||||
for ( ; in != end; in += 8 ) \
|
||||
{ \
|
||||
m = U8TO64_LE( in ); \
|
||||
v3 ^= m; \
|
||||
\
|
||||
SIP_ROUNDS; \
|
||||
\
|
||||
v0 ^= m; \
|
||||
} \
|
||||
\
|
||||
switch( left ) \
|
||||
{ \
|
||||
case 7: b |= ( ( U64 )in[ 6] ) << 48; /*FALLTHROUGH*/ \
|
||||
case 6: b |= ( ( U64 )in[ 5] ) << 40; /*FALLTHROUGH*/ \
|
||||
case 5: b |= ( ( U64 )in[ 4] ) << 32; /*FALLTHROUGH*/ \
|
||||
case 4: b |= ( ( U64 )in[ 3] ) << 24; /*FALLTHROUGH*/ \
|
||||
case 3: b |= ( ( U64 )in[ 2] ) << 16; /*FALLTHROUGH*/ \
|
||||
case 2: b |= ( ( U64 )in[ 1] ) << 8; /*FALLTHROUGH*/ \
|
||||
case 1: b |= ( ( U64 )in[ 0] ); break; \
|
||||
case 0: break; \
|
||||
} \
|
||||
\
|
||||
v3 ^= b; \
|
||||
\
|
||||
SIP_ROUNDS; \
|
||||
\
|
||||
v0 ^= b; \
|
||||
\
|
||||
v2 ^= 0xff; \
|
||||
\
|
||||
SIP_FINAL_ROUNDS \
|
||||
\
|
||||
b = v0 ^ v1 ^ v2 ^ v3; \
|
||||
return b; \
|
||||
} \
|
||||
\
|
||||
PERL_STATIC_INLINE U32 \
|
||||
FNC ## _with_state \
|
||||
(const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
|
||||
{ \
|
||||
union { \
|
||||
U64 h64; \
|
||||
U32 h32[2]; \
|
||||
} h; \
|
||||
h.h64= FNC ## _with_state_64(state,in,inlen); \
|
||||
return h.h32[0] ^ h.h32[1]; \
|
||||
} \
|
||||
\
|
||||
\
|
||||
PERL_STATIC_INLINE U32 \
|
||||
FNC (const unsigned char * const seed, const unsigned char *in, const STRLEN inlen) \
|
||||
{ \
|
||||
U64 state[4]; \
|
||||
SIPHASH_SEED_STATE(seed,state[0],state[1],state[2],state[3]); \
|
||||
return FNC ## _with_state((U8*)state,in,inlen); \
|
||||
}
|
||||
|
||||
|
||||
PERL_SIPHASH_FNC(
|
||||
S_perl_hash_siphash_1_3
|
||||
,SIPROUND;
|
||||
,SIPROUND;SIPROUND;SIPROUND;
|
||||
)
|
||||
|
||||
PERL_SIPHASH_FNC(
|
||||
S_perl_hash_siphash_2_4
|
||||
,SIPROUND;SIPROUND;
|
||||
,SIPROUND;SIPROUND;SIPROUND;SIPROUND;
|
||||
)
|
||||
|
||||
#endif /* defined(CAN64BITHASH) */
|
||||
22
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlapi.h
Normal file
22
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlapi.h
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
/*
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file used to declare accessor functions for Perl variables
|
||||
* when PERL_GLOBAL_STRUCT was enabled, but that no longer exists.
|
||||
* This file is kept for backwards compatibility with XS code that
|
||||
* might include it.
|
||||
*/
|
||||
#ifndef __perlapi_h__
|
||||
#define __perlapi_h__
|
||||
|
||||
#endif /* __perlapi_h__ */
|
||||
350
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlio.h
Normal file
350
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlio.h
Normal file
|
|
@ -0,0 +1,350 @@
|
|||
/* 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 - No longer available via Configure. Formerly forced
|
||||
PerlIO_xxx() to be #define-d onto stdio functions.
|
||||
Now generates compile-time error.
|
||||
|
||||
USE_PERLIO - The primary Configure variable that enables PerlIO.
|
||||
PerlIO_xxx() are real functions
|
||||
defined in perlio.c which implement extra functionality
|
||||
required for utf8 support.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef USE_PERLIO
|
||||
# define USE_STDIO
|
||||
#endif
|
||||
|
||||
#ifdef USE_STDIO
|
||||
# error "stdio is no longer supported as the default base layer -- use perlio."
|
||||
#endif
|
||||
|
||||
/*-------------------- End of Configure controls ---------------------------*/
|
||||
|
||||
/*
|
||||
* Although we may not want stdio to be used including <stdio.h> here
|
||||
* avoids issues where stdio.h has strange side effects
|
||||
*/
|
||||
#include <stdio.h>
|
||||
|
||||
#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
|
||||
|
||||
#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
|
||||
|
||||
/*
|
||||
=for apidoc_section $io
|
||||
=for apidoc Amu||PERLIO_FUNCS_DECL|PerlIO * ftab
|
||||
Declare C<ftab> to be a PerlIO function table, that is, of type
|
||||
C<PerlIO_funcs>.
|
||||
|
||||
=for apidoc Ay|PerlIO_funcs *|PERLIO_FUNCS_CAST|PerlIO * func
|
||||
Cast the pointer C<func> to be of type S<C<PerlIO_funcs *>>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
#define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
|
||||
#define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
|
||||
|
||||
PERL_CALLCONV void PerlIO_define_layer(pTHX_ PerlIO_funcs *tab);
|
||||
PERL_CALLCONV PerlIO_funcs *PerlIO_find_layer(pTHX_ const char *name,
|
||||
STRLEN len,
|
||||
int load);
|
||||
PERL_CALLCONV PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab),
|
||||
const char *mode, SV *arg);
|
||||
PERL_CALLCONV void PerlIO_pop(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV AV* PerlIO_get_layers(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV void PerlIO_clone(pTHX_ PerlInterpreter *proto,
|
||||
CLONE_PARAMS *param);
|
||||
|
||||
#endif /* PerlIO */
|
||||
|
||||
/* ----------- End of implementation choices ---------- */
|
||||
|
||||
/* 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 */
|
||||
|
||||
/* ----------- 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_CALLCONV void PerlIO_init(pTHX);
|
||||
#endif
|
||||
#ifndef PerlIO_stdoutf
|
||||
PERL_CALLCONV int PerlIO_stdoutf(const char *, ...)
|
||||
__attribute__format__(__printf__, 1, 2);
|
||||
#endif
|
||||
#ifndef PerlIO_puts
|
||||
PERL_CALLCONV int PerlIO_puts(PerlIO *, const char *);
|
||||
#endif
|
||||
#ifndef PerlIO_open
|
||||
PERL_CALLCONV PerlIO *PerlIO_open(const char *, const char *);
|
||||
#endif
|
||||
#ifndef PerlIO_openn
|
||||
PERL_CALLCONV 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_CALLCONV int PerlIO_eof(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_error
|
||||
PERL_CALLCONV int PerlIO_error(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_clearerr
|
||||
PERL_CALLCONV void PerlIO_clearerr(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_getc
|
||||
PERL_CALLCONV int PerlIO_getc(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_putc
|
||||
PERL_CALLCONV int PerlIO_putc(PerlIO *, int);
|
||||
#endif
|
||||
#ifndef PerlIO_ungetc
|
||||
PERL_CALLCONV int PerlIO_ungetc(PerlIO *, int);
|
||||
#endif
|
||||
#ifndef PerlIO_fdopen
|
||||
PERL_CALLCONV PerlIO *PerlIO_fdopen(int, const char *);
|
||||
#endif
|
||||
#ifndef PerlIO_importFILE
|
||||
PERL_CALLCONV PerlIO *PerlIO_importFILE(FILE *, const char *);
|
||||
#endif
|
||||
#ifndef PerlIO_exportFILE
|
||||
PERL_CALLCONV FILE *PerlIO_exportFILE(PerlIO *, const char *);
|
||||
#endif
|
||||
#ifndef PerlIO_findFILE
|
||||
PERL_CALLCONV FILE *PerlIO_findFILE(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_releaseFILE
|
||||
PERL_CALLCONV void PerlIO_releaseFILE(PerlIO *, FILE *);
|
||||
#endif
|
||||
#ifndef PerlIO_read
|
||||
PERL_CALLCONV SSize_t PerlIO_read(PerlIO *, void *, Size_t);
|
||||
#endif
|
||||
#ifndef PerlIO_unread
|
||||
PERL_CALLCONV SSize_t PerlIO_unread(PerlIO *, const void *, Size_t);
|
||||
#endif
|
||||
#ifndef PerlIO_write
|
||||
PERL_CALLCONV SSize_t PerlIO_write(PerlIO *, const void *, Size_t);
|
||||
#endif
|
||||
#ifndef PerlIO_setlinebuf
|
||||
PERL_CALLCONV void PerlIO_setlinebuf(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_printf
|
||||
PERL_CALLCONV int PerlIO_printf(PerlIO *, const char *, ...)
|
||||
__attribute__format__(__printf__, 2, 3);
|
||||
#endif
|
||||
#ifndef PerlIO_vprintf
|
||||
PERL_CALLCONV int PerlIO_vprintf(PerlIO *, const char *, va_list);
|
||||
#endif
|
||||
#ifndef PerlIO_tell
|
||||
PERL_CALLCONV Off_t PerlIO_tell(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_seek
|
||||
PERL_CALLCONV int PerlIO_seek(PerlIO *, Off_t, int);
|
||||
#endif
|
||||
#ifndef PerlIO_rewind
|
||||
PERL_CALLCONV void PerlIO_rewind(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_has_base
|
||||
PERL_CALLCONV int PerlIO_has_base(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_has_cntptr
|
||||
PERL_CALLCONV int PerlIO_has_cntptr(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_fast_gets
|
||||
PERL_CALLCONV int PerlIO_fast_gets(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_canset_cnt
|
||||
PERL_CALLCONV int PerlIO_canset_cnt(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_get_ptr
|
||||
PERL_CALLCONV STDCHAR *PerlIO_get_ptr(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_get_cnt
|
||||
PERL_CALLCONV SSize_t PerlIO_get_cnt(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_set_cnt
|
||||
PERL_CALLCONV void PerlIO_set_cnt(PerlIO *, SSize_t);
|
||||
#endif
|
||||
#ifndef PerlIO_set_ptrcnt
|
||||
PERL_CALLCONV void PerlIO_set_ptrcnt(PerlIO *, STDCHAR *, SSize_t);
|
||||
#endif
|
||||
#ifndef PerlIO_get_base
|
||||
PERL_CALLCONV STDCHAR *PerlIO_get_base(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_get_bufsiz
|
||||
PERL_CALLCONV SSize_t PerlIO_get_bufsiz(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_tmpfile
|
||||
PERL_CALLCONV PerlIO *PerlIO_tmpfile(void);
|
||||
#endif
|
||||
#ifndef PerlIO_tmpfile_flags
|
||||
PERL_CALLCONV PerlIO *PerlIO_tmpfile_flags(int flags);
|
||||
#endif
|
||||
#ifndef PerlIO_stdin
|
||||
PERL_CALLCONV PerlIO *PerlIO_stdin(void);
|
||||
#endif
|
||||
#ifndef PerlIO_stdout
|
||||
PERL_CALLCONV PerlIO *PerlIO_stdout(void);
|
||||
#endif
|
||||
#ifndef PerlIO_stderr
|
||||
PERL_CALLCONV PerlIO *PerlIO_stderr(void);
|
||||
#endif
|
||||
#ifndef PerlIO_getpos
|
||||
PERL_CALLCONV int PerlIO_getpos(PerlIO *, SV *);
|
||||
#endif
|
||||
#ifndef PerlIO_setpos
|
||||
PERL_CALLCONV int PerlIO_setpos(PerlIO *, SV *);
|
||||
#endif
|
||||
#ifndef PerlIO_fdupopen
|
||||
PERL_CALLCONV PerlIO *PerlIO_fdupopen(pTHX_ PerlIO *, CLONE_PARAMS *, int);
|
||||
#endif
|
||||
#if !defined(PerlIO_modestr)
|
||||
PERL_CALLCONV char *PerlIO_modestr(PerlIO *, char *buf);
|
||||
#endif
|
||||
#ifndef PerlIO_isutf8
|
||||
PERL_CALLCONV int PerlIO_isutf8(PerlIO *);
|
||||
#endif
|
||||
#ifndef PerlIO_apply_layers
|
||||
PERL_CALLCONV int PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode,
|
||||
const char *names);
|
||||
#endif
|
||||
#ifndef PerlIO_binmode
|
||||
PERL_CALLCONV int PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int omode,
|
||||
const char *names);
|
||||
#endif
|
||||
#ifndef PerlIO_getname
|
||||
PERL_CALLCONV char *PerlIO_getname(PerlIO *, char *);
|
||||
#endif
|
||||
|
||||
PERL_CALLCONV void PerlIO_destruct(pTHX);
|
||||
|
||||
PERL_CALLCONV int PerlIO_intmode2str(int rawmode, char *mode, int *writing);
|
||||
|
||||
#ifdef PERLIO_LAYERS
|
||||
PERL_CALLCONV void PerlIO_cleanup(pTHX);
|
||||
|
||||
PERL_CALLCONV 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_ */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
283
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perliol.h
Normal file
283
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perliol.h
Normal file
|
|
@ -0,0 +1,283 @@
|
|||
#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 */
|
||||
int err; /* Saved errno value */
|
||||
#ifdef VMS
|
||||
unsigned os_err; /* Saved vaxc$errno value */
|
||||
#elif defined (OS2)
|
||||
unsigned long os_err;
|
||||
#elif defined (WIN32)
|
||||
DWORD os_err; /* Saved GetLastError() value */
|
||||
#endif
|
||||
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))
|
||||
|
||||
/*--------------------------------------------------------------------------------------*/
|
||||
EXTCONST PerlIO_funcs PerlIO_unix;
|
||||
EXTCONST PerlIO_funcs PerlIO_perlio;
|
||||
EXTCONST PerlIO_funcs PerlIO_stdio;
|
||||
EXTCONST PerlIO_funcs PerlIO_crlf;
|
||||
EXTCONST PerlIO_funcs PerlIO_utf8;
|
||||
EXTCONST PerlIO_funcs PerlIO_byte;
|
||||
EXTCONST PerlIO_funcs PerlIO_raw;
|
||||
EXTCONST PerlIO_funcs PerlIO_pending;
|
||||
PERL_CALLCONV PerlIO *PerlIO_allocate(pTHX);
|
||||
PERL_CALLCONV 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_CALLCONV int PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
|
||||
PerlIO_list_t *layers, IV n, IV max);
|
||||
PERL_CALLCONV int PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names);
|
||||
PERL_CALLCONV PerlIO_funcs *PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def);
|
||||
|
||||
|
||||
PERL_CALLCONV SV *PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param);
|
||||
PERL_CALLCONV void PerlIO_cleantable(pTHX_ PerlIOl **tablep);
|
||||
PERL_CALLCONV SV * PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab);
|
||||
PERL_CALLCONV void PerlIO_default_buffer(pTHX_ PerlIO_list_t *av);
|
||||
PERL_CALLCONV void PerlIO_stdstreams(pTHX);
|
||||
PERL_CALLCONV int PerlIO__close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV PerlIO_list_t * PerlIO_resolve_layers(pTHX_ const char *layers, const char *mode, int narg, SV **args);
|
||||
PERL_CALLCONV PerlIO_funcs * PerlIO_default_layer(pTHX_ I32 n);
|
||||
PERL_CALLCONV PerlIO_list_t * PerlIO_default_layers(pTHX);
|
||||
PERL_CALLCONV PerlIO * PerlIO_reopen(const char *path, const char *mode, PerlIO *f);
|
||||
|
||||
PERL_CALLCONV PerlIO_list_t *PerlIO_list_alloc(pTHX);
|
||||
PERL_CALLCONV PerlIO_list_t *PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param);
|
||||
PERL_CALLCONV void PerlIO_list_free(pTHX_ PerlIO_list_t *list);
|
||||
PERL_CALLCONV void PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg);
|
||||
PERL_CALLCONV 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_CALLCONV IV PerlIOBase_binmode(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV void PerlIOBase_clearerr(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV PerlIO * PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
|
||||
PERL_CALLCONV IV PerlIOBase_eof(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_error(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_fileno(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV void PerlIOBase_flush_linebuf(pTHX);
|
||||
PERL_CALLCONV IV PerlIOBase_noop_fail(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_noop_ok(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_popped(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV 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_CALLCONV SSize_t PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
|
||||
PERL_CALLCONV void PerlIOBase_setlinebuf(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
|
||||
/* Buf */
|
||||
PERL_CALLCONV Size_t PerlIOBuf_bufsiz(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBuf_close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV PerlIO * PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
|
||||
PERL_CALLCONV IV PerlIOBuf_fill(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBuf_flush(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV STDCHAR * PerlIOBuf_get_base(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOBuf_get_cnt(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV STDCHAR * PerlIOBuf_get_ptr(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV 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_CALLCONV IV PerlIOBuf_popped(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV SSize_t PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
|
||||
PERL_CALLCONV IV PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
|
||||
PERL_CALLCONV void PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
|
||||
PERL_CALLCONV Off_t PerlIOBuf_tell(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
PERL_CALLCONV SSize_t PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
|
||||
/* Crlf */
|
||||
PERL_CALLCONV IV PerlIOCrlf_binmode(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOCrlf_flush(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOCrlf_get_cnt(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV void PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
|
||||
PERL_CALLCONV SSize_t PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
PERL_CALLCONV SSize_t PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
|
||||
/* Pending */
|
||||
PERL_CALLCONV IV PerlIOPending_close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOPending_fill(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOPending_flush(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV SSize_t PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
|
||||
PERL_CALLCONV IV PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
|
||||
PERL_CALLCONV void PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
|
||||
|
||||
/* Pop */
|
||||
PERL_CALLCONV IV PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
|
||||
/* Raw */
|
||||
PERL_CALLCONV IV PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
|
||||
/* Stdio */
|
||||
PERL_CALLCONV void PerlIOStdio_clearerr(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOStdio_close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV PerlIO * PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
|
||||
PERL_CALLCONV IV PerlIOStdio_eof(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOStdio_error(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOStdio_fileno(pTHX_ PerlIO *f);
|
||||
#ifdef USE_STDIO_PTR
|
||||
PERL_CALLCONV STDCHAR * PerlIOStdio_get_ptr(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOStdio_get_cnt(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV void PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
|
||||
#endif
|
||||
PERL_CALLCONV IV PerlIOStdio_fill(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV IV PerlIOStdio_flush(pTHX_ PerlIO *f);
|
||||
#ifdef FILE_base
|
||||
PERL_CALLCONV STDCHAR * PerlIOStdio_get_base(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV Size_t PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f);
|
||||
#endif
|
||||
PERL_CALLCONV char * PerlIOStdio_mode(const char *mode, char *tmode);
|
||||
PERL_CALLCONV 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_CALLCONV IV PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV SSize_t PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
|
||||
PERL_CALLCONV IV PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
|
||||
PERL_CALLCONV void PerlIOStdio_setlinebuf(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV Off_t PerlIOStdio_tell(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
PERL_CALLCONV SSize_t PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
|
||||
/* Unix */
|
||||
PERL_CALLCONV IV PerlIOUnix_close(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV PerlIO * PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
|
||||
PERL_CALLCONV IV PerlIOUnix_fileno(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV int PerlIOUnix_oflags(const char *mode);
|
||||
PERL_CALLCONV 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_CALLCONV IV PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
PERL_CALLCONV SSize_t PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
|
||||
PERL_CALLCONV int PerlIOUnix_refcnt_dec(int fd);
|
||||
PERL_CALLCONV void PerlIOUnix_refcnt_inc(int fd);
|
||||
PERL_CALLCONV int PerlIOUnix_refcnt(int fd);
|
||||
PERL_CALLCONV IV PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
|
||||
PERL_CALLCONV Off_t PerlIOUnix_tell(pTHX_ PerlIO *f);
|
||||
PERL_CALLCONV SSize_t PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
|
||||
|
||||
/* Utf8 */
|
||||
PERL_CALLCONV IV PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
|
||||
|
||||
#endif /* PERLIOL_H_ */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
21
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlsdio.h
Normal file
21
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlsdio.h
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
/* perlsdio.h
|
||||
*
|
||||
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001,
|
||||
* 2002, 2003, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Shouldn't be possible to get here, but if we did ... */
|
||||
|
||||
#ifdef PERLIO_IS_STDIO
|
||||
|
||||
# error "stdio is no longer supported as the default base layer -- use perlio."
|
||||
|
||||
#endif /* PERLIO_IS_STDIO */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
33
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlstatic.h
Normal file
33
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlstatic.h
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
/* perlstatic.h
|
||||
*
|
||||
* 'I don't know half of you half as well as I should like; and I like less
|
||||
* than half of you half as well as you deserve.'
|
||||
*
|
||||
* Copyright (C) 2020 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 is a home for static functions that we don't consider suitable for
|
||||
* inlining, but for which giving the compiler full knowledge of may be
|
||||
* advantageous. Functions that have potential tail call optimizations are a
|
||||
* likely component.
|
||||
|
||||
*/
|
||||
|
||||
/* saves machine code for a common noreturn idiom typically used in Newx*() */
|
||||
GCC_DIAG_IGNORE_DECL(-Wunused-function);
|
||||
|
||||
STATIC void
|
||||
Perl_croak_memory_wrap(void)
|
||||
{
|
||||
Perl_croak_nocontext("%s",PL_memory_wrap);
|
||||
}
|
||||
|
||||
GCC_DIAG_RESTORE_DECL;
|
||||
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
|
||||
400
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlvars.h
Normal file
400
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlvars.h
Normal file
|
|
@ -0,0 +1,400 @@
|
|||
/* 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. Any variables not documented
|
||||
here may be changed or removed without notice, so don't use them!
|
||||
If you feel you really do need to use an unlisted variable, first send email to
|
||||
L<perl5-porters@perl.org|mailto:perl5-porters@perl.org>. It may be that
|
||||
someone there will point out a way to accomplish what you need without using an
|
||||
internal variable. But if not, you should get a go-ahead to document and then
|
||||
use the variable.
|
||||
|
||||
=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
|
||||
PERLVARI(G, curinterp, PerlInterpreter *, NULL)
|
||||
/* 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? */
|
||||
|
||||
#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
|
||||
|
||||
/* 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)
|
||||
|
||||
/* these ptrs to functions are to avoid linkage problems; see
|
||||
* perl-5.8.0-2193-g5c1546dc48
|
||||
*/
|
||||
PERLVARI(G, csighandlerp, Sighandler_t, Perl_csighandler)
|
||||
PERLVARI(G, csighandler1p, Sighandler1_t, Perl_csighandler1)
|
||||
PERLVARI(G, csighandler3p, Sighandler3_t, Perl_csighandler3)
|
||||
|
||||
/* 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 */
|
||||
PERLVAR(G, env_mutex, perl_RnW1_mutex_t) /* Mutex for accessing ENV */
|
||||
PERLVAR(G, locale_mutex, perl_mutex) /* Mutex related to locale handling */
|
||||
#endif
|
||||
|
||||
#ifdef USE_POSIX_2008_LOCALE
|
||||
PERLVARI(G, C_locale_obj, locale_t, NULL)
|
||||
#endif
|
||||
|
||||
PERLVARI(G, watch_pvx, char *, NULL)
|
||||
|
||||
/*
|
||||
=for apidoc AmnU|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<wrap> 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</wrap_op_checker>.
|
||||
|
||||
=for apidoc Amn|enum perl_phase|PL_phase
|
||||
|
||||
A value that indicates the current Perl interpreter's phase. Possible values
|
||||
include C<PERL_PHASE_CONSTRUCT>, C<PERL_PHASE_START>, C<PERL_PHASE_CHECK>,
|
||||
C<PERL_PHASE_INIT>, C<PERL_PHASE_RUN>, C<PERL_PHASE_END>, and
|
||||
C<PERL_PHASE_DESTRUCT>.
|
||||
|
||||
For example, the following determines whether the interpreter is in
|
||||
global destruction:
|
||||
|
||||
if (PL_phase == PERL_PHASE_DESTRUCT) {
|
||||
// we are in global destruction
|
||||
}
|
||||
|
||||
C<PL_phase> was introduced in Perl 5.14; in prior perls you can use
|
||||
C<PL_dirty> (boolean) to determine whether the interpreter is in global
|
||||
destruction. (Use of C<PL_dirty> is discouraged since 5.14.)
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#if defined(USE_ITHREADS)
|
||||
PERLVAR(G, check_mutex, perl_mutex) /* Mutex for PL_check */
|
||||
#endif
|
||||
|
||||
/* allocate a unique index to every module that calls MY_CXT_INIT */
|
||||
|
||||
#ifdef MULTIPLICITY
|
||||
# ifdef USE_ITHREADS
|
||||
PERLVAR(G, my_ctx_mutex, perl_mutex)
|
||||
PERLVARI(G, veto_switch_non_tTHX_context, int, FALSE)
|
||||
# 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 AmnUx|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<keyword_ptr> points at the word in the parser's input
|
||||
buffer, and C<keyword_len> 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<KEYWORD_PLUGIN_DECLINE>, 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</Lexer interface> for details.
|
||||
|
||||
When a keyword is being handled, the plugin function must build
|
||||
a tree of C<OP> 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<KEYWORD_PLUGIN_STMT> if it is a complete statement, or
|
||||
C<KEYWORD_PLUGIN_EXPR> if it is an expression. Note that a statement
|
||||
construct cannot be used inside an expression (except via C<do BLOCK>
|
||||
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<PL_keyword_plugin> 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<PL_keyword_plugin> 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<KEYWORD_PLUGIN_DECLINE>.
|
||||
|
||||
For thread safety, modules should not set this variable directly.
|
||||
Instead, use the function L</wrap_keyword_plugin>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#if defined(USE_ITHREADS)
|
||||
PERLVAR(G, keyword_plugin_mutex, perl_mutex) /* Mutex for PL_keyword_plugin and PL_infix_plugin */
|
||||
#endif
|
||||
PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard)
|
||||
|
||||
/*
|
||||
=for apidoc AmnUx|Perl_infix_plugin_t|PL_infix_plugin
|
||||
|
||||
B<NOTE:> This API exists entirely for the purpose of making the CPAN module
|
||||
C<XS::Parse::Infix> work. It is not expected that additional modules will make
|
||||
use of it; rather, that they should use C<XS::Parse::Infix> to provide parsing
|
||||
of new infix operators.
|
||||
|
||||
Function pointer, pointing at a function used to handle extended infix
|
||||
operators. The function should be declared as
|
||||
|
||||
int infix_plugin_function(pTHX_
|
||||
char *opname, STRLEN oplen,
|
||||
struct Perl_custom_infix **infix_ptr)
|
||||
|
||||
The function is called from the tokenizer whenever a possible infix operator
|
||||
is seen. C<opname> points to the operator name in the parser's input buffer,
|
||||
and C<oplen> gives the I<maximum> number of bytes of it that should be
|
||||
consumed; it is not null-terminated. The function is expected to examine the
|
||||
operator name and possibly other state such as L<%^H|perlvar/%^H>, to
|
||||
determine whether it wants to handle the operator name.
|
||||
|
||||
As compared to the single stage of C<PL_keyword_plugin>, parsing of additional
|
||||
infix operators occurs in three separate stages. This is because of the more
|
||||
complex interactions it has with the parser, to ensure that operator
|
||||
precedence rules work correctly. These stages are co-ordinated by the use of
|
||||
an additional information structure.
|
||||
|
||||
If the function wants to handle the infix operator, it must set the variable
|
||||
pointed to by C<infix_ptr> to the address of a structure that provides this
|
||||
additional information about the subsequent parsing stages. If it does not,
|
||||
it should make a call to the next function in the chain.
|
||||
|
||||
This structure has the following definition:
|
||||
|
||||
struct Perl_custom_infix {
|
||||
enum Perl_custom_infix_precedence prec;
|
||||
void (*parse)(pTHX_ SV **opdata,
|
||||
struct Perl_custom_infix *);
|
||||
OP *(*build_op)(pTHX_ SV **opdata, OP *lhs, OP *rhs,
|
||||
struct Perl_custom_infix *);
|
||||
};
|
||||
|
||||
The function must then return an integer giving the number of bytes consumed
|
||||
by the name of this operator. In the case of an operator whose name is
|
||||
composed of identifier characters, this must be equal to C<oplen>. In the case
|
||||
of an operator named by non-identifier characters, this is permitted to be
|
||||
shorter than C<oplen>, and any additional characters after it will not be
|
||||
claimed by the infix operator but instead will be consumed by the tokenizer
|
||||
and parser as normal.
|
||||
|
||||
If the optional C<parse> function is provided, it is called immediately by the
|
||||
parser to let the operator's definition consume any additional syntax from the
|
||||
source code. This should I<not> be used for normal operand parsing, but it may
|
||||
be useful when implementing things like parametric operators or meta-operators
|
||||
that consume more syntax themselves. This function may use the variable
|
||||
pointed to by C<opdata> to provide an SV containing additional data to be
|
||||
passed into the C<build_op> function later on.
|
||||
|
||||
The information structure gives the operator precedence level in the C<prec>
|
||||
field. This is used to tell the parser how much of the surrounding syntax
|
||||
before and after should be considered as operands to the operator.
|
||||
|
||||
The tokenizer and parser will then continue to operate as normal until enough
|
||||
additional input has been parsed to form both the left- and right-hand side
|
||||
operands to the operator, according to the precedence level. At this point the
|
||||
C<build_op> function is called, being passed the left- and right-hand operands
|
||||
as optree fragments. It is expected to combine them into the resulting optree
|
||||
fragment, which it should return.
|
||||
|
||||
After the C<build_op> function has returned, if the variable pointed to by
|
||||
C<opdata> was set to a non-C<NULL> value, it will then be destroyed by calling
|
||||
C<SvREFCNT_dec()>.
|
||||
|
||||
For thread safety, modules should not set this variable directly.
|
||||
Instead, use the function L</wrap_infix_plugin>.
|
||||
|
||||
However, that all said, the introductory note above still applies. This
|
||||
variable is provided in core perl only for the benefit of the
|
||||
C<XS::Parse::Infix> module. That module acts as a central registry for infix
|
||||
operators, automatically handling things like deparse support and
|
||||
discovery/reflection, and these abilities only work because it knows all the
|
||||
registered operators. Other modules should not use this interpreter variable
|
||||
directly to implement them because then those central features would no longer
|
||||
work properly.
|
||||
|
||||
Furthermore, it is likely that this (experimental) API will be replaced in a
|
||||
future Perl version by a more complete API that fully implements the central
|
||||
registry and other semantics currently provided by C<XS::Parse::Infix>, once
|
||||
the module has had sufficient experimental testing time. This current
|
||||
mechanism exists only as an interim measure to get to that stage.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
PERLVARI(G, infix_plugin, Perl_infix_plugin_t, Perl_infix_plugin_standard)
|
||||
|
||||
PERLVARI(G, op_sequence, HV *, NULL) /* 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.
|
||||
In theory, the contents are never used, only the address.
|
||||
In practice, &PL_sv_placeholder is returned by some APIs, and the calling
|
||||
code is checking SvOK(). */
|
||||
|
||||
PERLVAR(G, sv_placeholder, SV)
|
||||
|
||||
#if defined(MYMALLOC) && defined(USE_ITHREADS)
|
||||
PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */
|
||||
#endif
|
||||
|
||||
PERLVARI(G, hash_seed_set, bool, FALSE) /* perl.c */
|
||||
PERLVARA(G, hash_seed_w, PERL_HASH_SEED_WORDS, PVT__PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
|
||||
#if defined(PERL_HASH_STATE_BYTES)
|
||||
PERLVARA(G, hash_state_w, PERL_HASH_STATE_WORDS, PVT__PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
|
||||
#endif
|
||||
#if defined(PERL_USE_SINGLE_CHAR_HASH_CACHE)
|
||||
#define PERL_SINGLE_CHAR_HASH_CACHE_ELEMS ((1+256) * sizeof(U32))
|
||||
PERLVARA(G, hash_chars, PERL_SINGLE_CHAR_HASH_CACHE_ELEMS, unsigned char) /* perl.c and hv.h */
|
||||
#endif
|
||||
|
||||
/* The path separator can vary depending on whether we're running under DCL or
|
||||
* a Unix shell.
|
||||
*/
|
||||
#ifdef __VMS
|
||||
PERLVAR(G, perllib_sep, char)
|
||||
#endif
|
||||
|
||||
/* Definitions of user-defined \p{} properties, as the subs that define them
|
||||
* are only called once */
|
||||
PERLVARI(G, user_def_props, HV *, NULL)
|
||||
|
||||
#if defined(USE_ITHREADS)
|
||||
PERLVAR(G, user_def_props_aTHX, PerlInterpreter *) /* aTHX that user_def_props
|
||||
was defined in */
|
||||
PERLVAR(G, user_prop_mutex, perl_mutex) /* Mutex for manipulating
|
||||
PL_user_defined_properties */
|
||||
#endif
|
||||
|
||||
/* these record the best way to perform certain IO operations while
|
||||
* atomically setting FD_CLOEXEC. On the first call, a probe is done
|
||||
* and the result recorded for use by subsequent calls.
|
||||
* In theory these variables aren't thread-safe, but the worst that can
|
||||
* happen is that two treads will both do an initial probe
|
||||
*/
|
||||
PERLVARI(G, strategy_dup, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_dup2, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_open, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_open3, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_mkstemp, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_socket, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_accept, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_pipe, int, 0) /* doio.c */
|
||||
PERLVARI(G, strategy_socketpair, int, 0) /* doio.c */
|
||||
|
||||
PERLVARI(G, my_environ, char **, NULL)
|
||||
PERLVARI(G, origenviron, char **, NULL)
|
||||
246
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perly.h
Normal file
246
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perly.h
Normal file
|
|
@ -0,0 +1,246 @@
|
|||
/* -*- mode: C; 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!
|
||||
*/
|
||||
|
||||
#define PERL_BISON_VERSION 30007
|
||||
|
||||
#ifdef PERL_CORE
|
||||
/* A Bison parser, made by GNU Bison 3.7. */
|
||||
|
||||
/* Bison interface for Yacc-like parsers in C
|
||||
|
||||
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 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 3 of the License, 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, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
/* 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. */
|
||||
|
||||
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
|
||||
especially those whose name start with YY_ or yy_. They are
|
||||
private implementation details that can be changed or removed. */
|
||||
|
||||
/* Debug traces. */
|
||||
#ifndef YYDEBUG
|
||||
# define YYDEBUG 0
|
||||
#endif
|
||||
#if YYDEBUG
|
||||
extern int yydebug;
|
||||
#endif
|
||||
|
||||
/* Token kinds. */
|
||||
#ifndef YYTOKENTYPE
|
||||
# define YYTOKENTYPE
|
||||
enum yytokentype
|
||||
{
|
||||
YYEMPTY = -2,
|
||||
YYEOF = 0, /* "end of file" */
|
||||
YYerror = 256, /* error */
|
||||
YYUNDEF = 257, /* "invalid token" */
|
||||
GRAMPROG = 258, /* GRAMPROG */
|
||||
GRAMEXPR = 259, /* GRAMEXPR */
|
||||
GRAMBLOCK = 260, /* GRAMBLOCK */
|
||||
GRAMBARESTMT = 261, /* GRAMBARESTMT */
|
||||
GRAMFULLSTMT = 262, /* GRAMFULLSTMT */
|
||||
GRAMSTMTSEQ = 263, /* GRAMSTMTSEQ */
|
||||
GRAMSUBSIGNATURE = 264, /* GRAMSUBSIGNATURE */
|
||||
PERLY_AMPERSAND = 265, /* PERLY_AMPERSAND */
|
||||
PERLY_BRACE_OPEN = 266, /* PERLY_BRACE_OPEN */
|
||||
PERLY_BRACE_CLOSE = 267, /* PERLY_BRACE_CLOSE */
|
||||
PERLY_BRACKET_OPEN = 268, /* PERLY_BRACKET_OPEN */
|
||||
PERLY_BRACKET_CLOSE = 269, /* PERLY_BRACKET_CLOSE */
|
||||
PERLY_COMMA = 270, /* PERLY_COMMA */
|
||||
PERLY_DOLLAR = 271, /* PERLY_DOLLAR */
|
||||
PERLY_DOT = 272, /* PERLY_DOT */
|
||||
PERLY_EQUAL_SIGN = 273, /* PERLY_EQUAL_SIGN */
|
||||
PERLY_MINUS = 274, /* PERLY_MINUS */
|
||||
PERLY_PERCENT_SIGN = 275, /* PERLY_PERCENT_SIGN */
|
||||
PERLY_PLUS = 276, /* PERLY_PLUS */
|
||||
PERLY_SEMICOLON = 277, /* PERLY_SEMICOLON */
|
||||
PERLY_SLASH = 278, /* PERLY_SLASH */
|
||||
PERLY_SNAIL = 279, /* PERLY_SNAIL */
|
||||
PERLY_STAR = 280, /* PERLY_STAR */
|
||||
KW_FORMAT = 281, /* KW_FORMAT */
|
||||
KW_PACKAGE = 282, /* KW_PACKAGE */
|
||||
KW_CLASS = 283, /* KW_CLASS */
|
||||
KW_LOCAL = 284, /* KW_LOCAL */
|
||||
KW_MY = 285, /* KW_MY */
|
||||
KW_FIELD = 286, /* KW_FIELD */
|
||||
KW_IF = 287, /* KW_IF */
|
||||
KW_ELSE = 288, /* KW_ELSE */
|
||||
KW_ELSIF = 289, /* KW_ELSIF */
|
||||
KW_UNLESS = 290, /* KW_UNLESS */
|
||||
KW_FOR = 291, /* KW_FOR */
|
||||
KW_UNTIL = 292, /* KW_UNTIL */
|
||||
KW_WHILE = 293, /* KW_WHILE */
|
||||
KW_CONTINUE = 294, /* KW_CONTINUE */
|
||||
KW_GIVEN = 295, /* KW_GIVEN */
|
||||
KW_WHEN = 296, /* KW_WHEN */
|
||||
KW_DEFAULT = 297, /* KW_DEFAULT */
|
||||
KW_TRY = 298, /* KW_TRY */
|
||||
KW_CATCH = 299, /* KW_CATCH */
|
||||
KW_FINALLY = 300, /* KW_FINALLY */
|
||||
KW_DEFER = 301, /* KW_DEFER */
|
||||
KW_REQUIRE = 302, /* KW_REQUIRE */
|
||||
KW_DO = 303, /* KW_DO */
|
||||
KW_USE_or_NO = 304, /* KW_USE_or_NO */
|
||||
KW_SUB_named = 305, /* KW_SUB_named */
|
||||
KW_SUB_named_sig = 306, /* KW_SUB_named_sig */
|
||||
KW_SUB_anon = 307, /* KW_SUB_anon */
|
||||
KW_SUB_anon_sig = 308, /* KW_SUB_anon_sig */
|
||||
KW_METHOD_named = 309, /* KW_METHOD_named */
|
||||
KW_METHOD_anon = 310, /* KW_METHOD_anon */
|
||||
BAREWORD = 311, /* BAREWORD */
|
||||
METHCALL0 = 312, /* METHCALL0 */
|
||||
METHCALL = 313, /* METHCALL */
|
||||
THING = 314, /* THING */
|
||||
PMFUNC = 315, /* PMFUNC */
|
||||
PRIVATEREF = 316, /* PRIVATEREF */
|
||||
QWLIST = 317, /* QWLIST */
|
||||
FUNC0OP = 318, /* FUNC0OP */
|
||||
FUNC0SUB = 319, /* FUNC0SUB */
|
||||
UNIOPSUB = 320, /* UNIOPSUB */
|
||||
LSTOPSUB = 321, /* LSTOPSUB */
|
||||
PLUGEXPR = 322, /* PLUGEXPR */
|
||||
PLUGSTMT = 323, /* PLUGSTMT */
|
||||
LABEL = 324, /* LABEL */
|
||||
LOOPEX = 325, /* LOOPEX */
|
||||
DOTDOT = 326, /* DOTDOT */
|
||||
YADAYADA = 327, /* YADAYADA */
|
||||
FUNC0 = 328, /* FUNC0 */
|
||||
FUNC1 = 329, /* FUNC1 */
|
||||
FUNC = 330, /* FUNC */
|
||||
UNIOP = 331, /* UNIOP */
|
||||
LSTOP = 332, /* LSTOP */
|
||||
POWOP = 333, /* POWOP */
|
||||
MULOP = 334, /* MULOP */
|
||||
ADDOP = 335, /* ADDOP */
|
||||
DOLSHARP = 336, /* DOLSHARP */
|
||||
HASHBRACK = 337, /* HASHBRACK */
|
||||
NOAMP = 338, /* NOAMP */
|
||||
COLONATTR = 339, /* COLONATTR */
|
||||
FORMLBRACK = 340, /* FORMLBRACK */
|
||||
FORMRBRACK = 341, /* FORMRBRACK */
|
||||
SUBLEXSTART = 342, /* SUBLEXSTART */
|
||||
SUBLEXEND = 343, /* SUBLEXEND */
|
||||
PHASER = 344, /* PHASER */
|
||||
PREC_LOW = 345, /* PREC_LOW */
|
||||
PLUGIN_LOW_OP = 346, /* PLUGIN_LOW_OP */
|
||||
OROP = 347, /* OROP */
|
||||
PLUGIN_LOGICAL_OR_LOW_OP = 348, /* PLUGIN_LOGICAL_OR_LOW_OP */
|
||||
ANDOP = 349, /* ANDOP */
|
||||
PLUGIN_LOGICAL_AND_LOW_OP = 350, /* PLUGIN_LOGICAL_AND_LOW_OP */
|
||||
NOTOP = 351, /* NOTOP */
|
||||
ASSIGNOP = 352, /* ASSIGNOP */
|
||||
PLUGIN_ASSIGN_OP = 353, /* PLUGIN_ASSIGN_OP */
|
||||
PERLY_QUESTION_MARK = 354, /* PERLY_QUESTION_MARK */
|
||||
PERLY_COLON = 355, /* PERLY_COLON */
|
||||
OROR = 356, /* OROR */
|
||||
DORDOR = 357, /* DORDOR */
|
||||
PLUGIN_LOGICAL_OR_OP = 358, /* PLUGIN_LOGICAL_OR_OP */
|
||||
ANDAND = 359, /* ANDAND */
|
||||
PLUGIN_LOGICAL_AND_OP = 360, /* PLUGIN_LOGICAL_AND_OP */
|
||||
BITOROP = 361, /* BITOROP */
|
||||
BITANDOP = 362, /* BITANDOP */
|
||||
CHEQOP = 363, /* CHEQOP */
|
||||
NCEQOP = 364, /* NCEQOP */
|
||||
CHRELOP = 365, /* CHRELOP */
|
||||
NCRELOP = 366, /* NCRELOP */
|
||||
PLUGIN_REL_OP = 367, /* PLUGIN_REL_OP */
|
||||
SHIFTOP = 368, /* SHIFTOP */
|
||||
PLUGIN_ADD_OP = 369, /* PLUGIN_ADD_OP */
|
||||
PLUGIN_MUL_OP = 370, /* PLUGIN_MUL_OP */
|
||||
MATCHOP = 371, /* MATCHOP */
|
||||
PERLY_EXCLAMATION_MARK = 372, /* PERLY_EXCLAMATION_MARK */
|
||||
PERLY_TILDE = 373, /* PERLY_TILDE */
|
||||
UMINUS = 374, /* UMINUS */
|
||||
REFGEN = 375, /* REFGEN */
|
||||
PLUGIN_POW_OP = 376, /* PLUGIN_POW_OP */
|
||||
PREINC = 377, /* PREINC */
|
||||
PREDEC = 378, /* PREDEC */
|
||||
POSTINC = 379, /* POSTINC */
|
||||
POSTDEC = 380, /* POSTDEC */
|
||||
POSTJOIN = 381, /* POSTJOIN */
|
||||
PLUGIN_HIGH_OP = 382, /* PLUGIN_HIGH_OP */
|
||||
ARROW = 383, /* ARROW */
|
||||
PERLY_PAREN_CLOSE = 384, /* PERLY_PAREN_CLOSE */
|
||||
PERLY_PAREN_OPEN = 385 /* PERLY_PAREN_OPEN */
|
||||
};
|
||||
typedef enum yytokentype yytoken_kind_t;
|
||||
#endif
|
||||
|
||||
/* Value type. */
|
||||
#ifdef PERL_IN_TOKE_C
|
||||
static bool
|
||||
S_is_opval_token(int type) {
|
||||
switch (type) {
|
||||
case BAREWORD:
|
||||
case FUNC0OP:
|
||||
case FUNC0SUB:
|
||||
case LABEL:
|
||||
case LSTOPSUB:
|
||||
case METHCALL:
|
||||
case METHCALL0:
|
||||
case PLUGEXPR:
|
||||
case PLUGSTMT:
|
||||
case PMFUNC:
|
||||
case PRIVATEREF:
|
||||
case QWLIST:
|
||||
case THING:
|
||||
case UNIOPSUB:
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* PERL_IN_TOKE_C */
|
||||
#endif /* PERL_CORE */
|
||||
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
||||
union YYSTYPE
|
||||
{
|
||||
|
||||
I32 ival; /* __DEFAULT__ (marker for regen_perly.pl;
|
||||
must always be 1st union member) */
|
||||
void *pval;
|
||||
OP *opval;
|
||||
GV *gvval;
|
||||
|
||||
|
||||
};
|
||||
typedef union YYSTYPE YYSTYPE;
|
||||
# define YYSTYPE_IS_TRIVIAL 1
|
||||
# define YYSTYPE_IS_DECLARED 1
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
int yyparse (void);
|
||||
|
||||
|
||||
/* Generated from:
|
||||
* 823630846fc59cc2a19502726ec723b568eabded55fdc5e9722c600e1098779e perly.y
|
||||
* acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
|
||||
* ex: set ro ft=c: */
|
||||
742
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp.h
Normal file
742
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp.h
Normal file
|
|
@ -0,0 +1,742 @@
|
|||
/* pp.h
|
||||
*
|
||||
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
=for apidoc_section $rpp
|
||||
|
||||
=for apidoc Amux||XSPP_wrapped|xsppw_name|I32 xsppw_nargs|I32 xsppw_nlists
|
||||
Declare and wrap a non-reference-counted PP-style function.
|
||||
On traditional perl builds where the stack isn't reference-counted, this
|
||||
just produces a function declaration like
|
||||
|
||||
OP * xsppw_name(pTHX)
|
||||
|
||||
Conversely, in ref-counted builds it creates xsppw_name() as a small
|
||||
wrapper function which calls the real function via a wrapper which
|
||||
processes the args and return values to ensure that reference counts are
|
||||
properly handled for code which uses old-style dSP, PUSHs(), POPs() etc,
|
||||
which don't adjust the reference counts of the items they manipulate.
|
||||
|
||||
xsppw_nargs indicates how many arguments the function consumes off the
|
||||
stack. It can be a constant value or an expression, such as
|
||||
|
||||
((PL_op->op_flags & OPf_STACKED) ? 2 : 1)
|
||||
|
||||
Alternatively if xsppw_nlists is 1, it indicates that the PP function
|
||||
consumes a list (or - rarely - if 2, consumes two lists, like
|
||||
pp_aassign()), as indicated by the top markstack position.
|
||||
|
||||
This is intended as a temporary fix when converting XS code to run under
|
||||
PERL_RC_STACK builds. In the longer term, the PP function should be
|
||||
rewritten to replace PUSHs() etc with rpp_push_1() etc.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#ifdef PERL_RC_STACK
|
||||
# define XSPP_wrapped(xsppw_name, xsppw_nargs, xsppw_nlists) \
|
||||
\
|
||||
STATIC OP* S_##xsppw_name##_norc(pTHX); \
|
||||
OP* xsppw_name(pTHX) \
|
||||
{ \
|
||||
return Perl_pp_wrap(aTHX_ S_##xsppw_name##_norc, \
|
||||
(xsppw_nargs), (xsppw_nlists)); \
|
||||
} \
|
||||
STATIC OP* S_##xsppw_name##_norc(pTHX)
|
||||
|
||||
#else
|
||||
# define XSPP_wrapped(xsppw_name, xsppw_nargs, xsppw_nlists) \
|
||||
OP * xsppw_name(pTHX)
|
||||
#endif
|
||||
|
||||
#define PP_wrapped(ppw_name, ppw_nargs, ppw_nlists) \
|
||||
XSPP_wrapped(Perl_##ppw_name, ppw_nargs, ppw_nlists)
|
||||
|
||||
#define PP(s) OP * Perl_##s(pTHX)
|
||||
|
||||
/*
|
||||
=for apidoc_section $stack
|
||||
|
||||
=for apidoc AmnU||SP
|
||||
Stack pointer. This is usually handled by C<xsubpp>. See C<L</dSP>> and
|
||||
C<SPAGAIN>.
|
||||
|
||||
=for apidoc AmnU||MARK
|
||||
Stack marker variable for the XSUB. See C<L</dMARK>>.
|
||||
|
||||
=for apidoc Am|void|PUSHMARK|SP
|
||||
Opening bracket for arguments on a callback. See C<L</PUTBACK>> and
|
||||
L<perlcall>.
|
||||
|
||||
=for apidoc Amn;||dSP
|
||||
Declares a local copy of perl's stack pointer for the XSUB, available via
|
||||
the C<SP> macro. See C<L</SP>>.
|
||||
|
||||
=for apidoc m;||djSP
|
||||
|
||||
Declare Just C<SP>. This is actually identical to C<dSP>, and declares
|
||||
a local copy of perl's stack pointer, available via the C<SP> macro.
|
||||
See C<L<perlapi/SP>>. (Available for backward source code compatibility with
|
||||
the old (Perl 5.005) thread model.)
|
||||
|
||||
=for apidoc Amn;||dMARK
|
||||
Declare a stack marker variable, C<mark>, for the XSUB. See C<L</MARK>> and
|
||||
C<L</dORIGMARK>>.
|
||||
|
||||
=for apidoc Amn;||dORIGMARK
|
||||
Saves the original stack mark for the XSUB. See C<L</ORIGMARK>>.
|
||||
|
||||
=for apidoc AmnU||ORIGMARK
|
||||
The original stack mark for the XSUB. See C<L</dORIGMARK>>.
|
||||
|
||||
=for apidoc Amn;||SPAGAIN
|
||||
Refetch the stack pointer. Used after a callback. See L<perlcall>.
|
||||
|
||||
=cut */
|
||||
|
||||
#undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
|
||||
#define SP sp
|
||||
#define MARK mark
|
||||
|
||||
/*
|
||||
=for apidoc Amn;||TARG
|
||||
|
||||
C<TARG> is short for "target". It is an entry in the pad that an OPs
|
||||
C<op_targ> refers to. It is scratchpad space, often used as a return
|
||||
value for the OP, but some use it for other purposes.
|
||||
|
||||
=cut
|
||||
*/
|
||||
#define TARG targ
|
||||
|
||||
#define PUSHMARK(p) \
|
||||
STMT_START { \
|
||||
Stack_off_t * mark_stack_entry; \
|
||||
if (UNLIKELY((mark_stack_entry = ++PL_markstack_ptr) \
|
||||
== PL_markstack_max)) \
|
||||
mark_stack_entry = markstack_grow(); \
|
||||
*mark_stack_entry = (Stack_off_t)((p) - PL_stack_base); \
|
||||
DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, \
|
||||
"MARK push %p %" IVdf "\n", \
|
||||
PL_markstack_ptr, (IV)*mark_stack_entry))); \
|
||||
} STMT_END
|
||||
|
||||
#define TOPMARK Perl_TOPMARK(aTHX)
|
||||
#define POPMARK Perl_POPMARK(aTHX)
|
||||
|
||||
#define INCMARK \
|
||||
STMT_START { \
|
||||
DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, \
|
||||
"MARK inc %p %" IVdf "\n", \
|
||||
(PL_markstack_ptr+1), (IV)*(PL_markstack_ptr+1)))); \
|
||||
PL_markstack_ptr++; \
|
||||
} STMT_END
|
||||
|
||||
#define dSP SV **sp = PL_stack_sp
|
||||
#define djSP dSP
|
||||
#define dMARK SV **mark = PL_stack_base + POPMARK
|
||||
#define dORIGMARK const SSize_t origmark = (SSize_t)(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)
|
||||
|
||||
/*
|
||||
=for apidoc Amn;||dTARGET
|
||||
Declare that this function uses C<TARG>, and initializes it
|
||||
|
||||
=cut
|
||||
*/
|
||||
#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 Amn;||PUTBACK
|
||||
Closing bracket for XSUB arguments. This is usually handled by C<xsubpp>.
|
||||
See C<L</PUSHMARK>> and L<perlcall> 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.
|
||||
|
||||
=for apidoc Amn|char*|POPpx
|
||||
Pops a string off the stack. Identical to POPp. There are two names for
|
||||
historical reasons.
|
||||
|
||||
=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|UV|POPu
|
||||
Pops an unsigned integer off the stack.
|
||||
|
||||
=for apidoc Amn|long|POPl
|
||||
Pops a long off the stack.
|
||||
|
||||
=for apidoc Amn|long|POPul
|
||||
Pops an unsigned 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)
|
||||
|
||||
#ifdef PERL_RC_STACK
|
||||
# define POPs (assert(!rpp_stack_is_rc()), *sp--)
|
||||
#else
|
||||
# define POPs (*sp--)
|
||||
#endif
|
||||
|
||||
#define POPp POPpx
|
||||
#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))
|
||||
|
||||
#define TOPs (*sp)
|
||||
#define TOPm1s (*(sp-1))
|
||||
#define TOPp1s (*(sp+1))
|
||||
#define TOPp TOPpx
|
||||
#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))
|
||||
|
||||
/* Go to some pains in the rare event that we must extend the stack. */
|
||||
|
||||
/*
|
||||
=for apidoc Am|void|EXTEND|SP|SSize_t nitems
|
||||
Used to extend the argument stack for an XSUB's return values. Once
|
||||
used, guarantees that there is room for at least C<nitems> 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<TARG>. See also
|
||||
C<L</PUSHmortal>>, C<L</XPUSHs>>, and C<L</XPUSHmortal>>.
|
||||
|
||||
=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<len> indicates the length of the string. Handles 'set' magic. Uses
|
||||
C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it. Do not
|
||||
call multiple C<TARG>-oriented macros to return lists from XSUB's - see
|
||||
C<L</mPUSHp>> instead. See also C<L</XPUSHp>> and C<L</mXPUSHp>>.
|
||||
|
||||
=for apidoc Am|void|PUSHpvs|"literal string"
|
||||
A variation on C<PUSHp> that takes a literal string and calculates its size
|
||||
directly.
|
||||
|
||||
=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<TARG>, so C<dTARGET> or C<dXSTARG> should be
|
||||
called to declare it. Do not call multiple C<TARG>-oriented macros to
|
||||
return lists from XSUB's - see C<L</mPUSHn>> instead. See also C<L</XPUSHn>>
|
||||
and C<L</mXPUSHn>>.
|
||||
|
||||
=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<TARG>, so C<dTARGET> or C<dXSTARG> should be
|
||||
called to declare it. Do not call multiple C<TARG>-oriented macros to
|
||||
return lists from XSUB's - see C<L</mPUSHi>> instead. See also C<L</XPUSHi>>
|
||||
and C<L</mXPUSHi>>.
|
||||
|
||||
=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<TARG>, so C<dTARGET> or C<dXSTARG>
|
||||
should be called to declare it. Do not call multiple C<TARG>-oriented
|
||||
macros to return lists from XSUB's - see C<L</mPUSHu>> instead. See also
|
||||
C<L</XPUSHu>> and C<L</mXPUSHu>>.
|
||||
|
||||
=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<TARG>. See also C<L</XPUSHmortal>>,
|
||||
C<PUSHs> and C<PUSHmortal>.
|
||||
|
||||
=for apidoc Am|void|XPUSHp|char* str|STRLEN len
|
||||
Push a string onto the stack, extending the stack if necessary. The C<len>
|
||||
indicates the length of the string. Handles 'set' magic. Uses C<TARG>, so
|
||||
C<dTARGET> or C<dXSTARG> should be called to declare it. Do not call
|
||||
multiple C<TARG>-oriented macros to return lists from XSUB's - see
|
||||
C<L</mXPUSHp>> instead. See also C<L</PUSHp>> and C<L</mPUSHp>>.
|
||||
|
||||
=for apidoc Am|void|XPUSHpvs|"literal string"
|
||||
A variation on C<XPUSHp> that takes a literal string and calculates its size
|
||||
directly.
|
||||
|
||||
=for apidoc Am|void|XPUSHn|NV nv
|
||||
Push a double onto the stack, extending the stack if necessary. Handles
|
||||
'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
|
||||
declare it. Do not call multiple C<TARG>-oriented macros to return lists
|
||||
from XSUB's - see C<L</mXPUSHn>> instead. See also C<L</PUSHn>> and
|
||||
C<L</mPUSHn>>.
|
||||
|
||||
=for apidoc Am|void|XPUSHi|IV iv
|
||||
Push an integer onto the stack, extending the stack if necessary. Handles
|
||||
'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
|
||||
declare it. Do not call multiple C<TARG>-oriented macros to return lists
|
||||
from XSUB's - see C<L</mXPUSHi>> instead. See also C<L</PUSHi>> and
|
||||
C<L</mPUSHi>>.
|
||||
|
||||
=for apidoc Am|void|XPUSHu|UV uv
|
||||
Push an unsigned integer onto the stack, extending the stack if necessary.
|
||||
Handles 'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
|
||||
called to declare it. Do not call multiple C<TARG>-oriented macros to
|
||||
return lists from XSUB's - see C<L</mXPUSHu>> instead. See also C<L</PUSHu>> and
|
||||
C<L</mPUSHu>>.
|
||||
|
||||
=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<TARG>. See also C<L</PUSHs>> and
|
||||
C<L</mXPUSHs>>.
|
||||
|
||||
=for apidoc Amn|void|PUSHmortal
|
||||
Push a new mortal SV onto the stack. The stack must have room for this
|
||||
element. Does not use C<TARG>. See also C<L</PUSHs>>, C<L</XPUSHmortal>> and
|
||||
C<L</XPUSHs>>.
|
||||
|
||||
=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<len> indicates the length of the string. Does not use C<TARG>.
|
||||
See also C<L</PUSHp>>, C<L</mXPUSHp>> and C<L</XPUSHp>>.
|
||||
|
||||
=for apidoc Am|void|mPUSHpvs|"literal string"
|
||||
A variation on C<mPUSHp> that takes a literal string and calculates its size
|
||||
directly.
|
||||
|
||||
=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<TARG>. See also C<L</PUSHn>>, C<L</mXPUSHn>> and C<L</XPUSHn>>.
|
||||
|
||||
=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<TARG>. See also C<L</PUSHi>>, C<L</mXPUSHi>> and C<L</XPUSHi>>.
|
||||
|
||||
=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<TARG>. See also C<L</PUSHu>>, C<L</mXPUSHu>> and
|
||||
C<L</XPUSHu>>.
|
||||
|
||||
=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<TARG>. See also C<L</XPUSHs>> and C<L</mPUSHs>>.
|
||||
|
||||
=for apidoc Amn|void|XPUSHmortal
|
||||
Push a new mortal SV onto the stack, extending the stack if necessary.
|
||||
Does not use C<TARG>. See also C<L</XPUSHs>>, C<L</PUSHmortal>> and
|
||||
C<L</PUSHs>>.
|
||||
|
||||
=for apidoc Am|void|mXPUSHp|char* str|STRLEN len
|
||||
Push a string onto the stack, extending the stack if necessary. The C<len>
|
||||
indicates the length of the string. Does not use C<TARG>. See also
|
||||
C<L</XPUSHp>>, C<mPUSHp> and C<PUSHp>.
|
||||
|
||||
=for apidoc Am|void|mXPUSHpvs|"literal string"
|
||||
A variation on C<mXPUSHp> that takes a literal string and calculates its size
|
||||
directly.
|
||||
|
||||
=for apidoc Am|void|mXPUSHn|NV nv
|
||||
Push a double onto the stack, extending the stack if necessary.
|
||||
Does not use C<TARG>. See also C<L</XPUSHn>>, C<L</mPUSHn>> and C<L</PUSHn>>.
|
||||
|
||||
=for apidoc Am|void|mXPUSHi|IV iv
|
||||
Push an integer onto the stack, extending the stack if necessary.
|
||||
Does not use C<TARG>. See also C<L</XPUSHi>>, C<L</mPUSHi>> and C<L</PUSHi>>.
|
||||
|
||||
=for apidoc Am|void|mXPUSHu|UV uv
|
||||
Push an unsigned integer onto the stack, extending the stack if necessary.
|
||||
Does not use C<TARG>. See also C<L</XPUSHu>>, C<L</mPUSHu>> and C<L</PUSHu>>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
/* EXTEND_HWM_SET: note the high-water-mark to which the stack has been
|
||||
* requested to be extended (which is likely to be less than PL_stack_max)
|
||||
*/
|
||||
#ifdef PERL_USE_HWM
|
||||
# define EXTEND_HWM_SET(p, n) \
|
||||
STMT_START { \
|
||||
SSize_t extend_hwm_set_ix = (p) - PL_stack_base + (n); \
|
||||
if (extend_hwm_set_ix > PL_curstackinfo->si_stack_hwm) \
|
||||
PL_curstackinfo->si_stack_hwm = extend_hwm_set_ix; \
|
||||
} STMT_END
|
||||
#else
|
||||
# define EXTEND_HWM_SET(p, n) NOOP
|
||||
#endif
|
||||
|
||||
/* _EXTEND_SAFE_N(n): private helper macro for EXTEND().
|
||||
* Tests whether the value of n would be truncated when implicitly cast to
|
||||
* SSize_t as an arg to stack_grow(). If so, sets it to -1 instead to
|
||||
* trigger a panic. It will be constant folded on platforms where this
|
||||
* can't happen.
|
||||
*/
|
||||
|
||||
#define _EXTEND_SAFE_N(n) \
|
||||
(sizeof(n) > sizeof(SSize_t) && ((SSize_t)(n) != (n)) ? -1 : (n))
|
||||
|
||||
#ifdef STRESS_REALLOC
|
||||
# define EXTEND_SKIP(p, n) EXTEND_HWM_SET(p, n)
|
||||
|
||||
# define EXTEND(p,n) STMT_START { \
|
||||
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
|
||||
PERL_UNUSED_VAR(sp); \
|
||||
} STMT_END
|
||||
/* Same thing, but update mark register too. */
|
||||
# define MEXTEND(p,n) STMT_START { \
|
||||
const SSize_t markoff = mark - PL_stack_base; \
|
||||
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
|
||||
mark = PL_stack_base + markoff; \
|
||||
PERL_UNUSED_VAR(sp); \
|
||||
} STMT_END
|
||||
#else
|
||||
|
||||
/* _EXTEND_NEEDS_GROW(p,n): private helper macro for EXTEND().
|
||||
* Tests to see whether n is too big and we need to grow the stack. Be
|
||||
* very careful if modifying this. There are many ways to get things wrong
|
||||
* (wrapping, truncating etc) that could cause a false negative and cause
|
||||
* the call to stack_grow() to be skipped. On the other hand, false
|
||||
* positives are safe.
|
||||
* Bear in mind that sizeof(p) may be less than, equal to, or greater
|
||||
* than sizeof(n), and while n is documented to be signed, someone might
|
||||
* pass an unsigned value or expression. In general don't use casts to
|
||||
* avoid warnings; instead expect the caller to fix their code.
|
||||
* It is legal for p to be greater than PL_stack_max.
|
||||
* If the allocated stack is already very large but current usage is
|
||||
* small, then PL_stack_max - p might wrap round to a negative value, but
|
||||
* this just gives a safe false positive
|
||||
*/
|
||||
|
||||
# define _EXTEND_NEEDS_GROW(p,n) ((n) < 0 || PL_stack_max - (p) < (n))
|
||||
|
||||
|
||||
/* EXTEND_SKIP(): used for where you would normally call EXTEND(), but
|
||||
* you know for sure that a previous op will have already extended the
|
||||
* stack sufficiently. For example pp_enteriter ensures that there
|
||||
* is always at least 1 free slot, so pp_iter can return &PL_sv_yes/no
|
||||
* without checking each time. Calling EXTEND_SKIP() defeats the HWM
|
||||
* debugging mechanism which would otherwise whine
|
||||
*/
|
||||
|
||||
# define EXTEND_SKIP(p, n) STMT_START { \
|
||||
EXTEND_HWM_SET(p, n); \
|
||||
assert(!_EXTEND_NEEDS_GROW(p,n)); \
|
||||
} STMT_END
|
||||
|
||||
|
||||
# define EXTEND(p,n) STMT_START { \
|
||||
EXTEND_HWM_SET(p, n); \
|
||||
if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \
|
||||
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
|
||||
PERL_UNUSED_VAR(sp); \
|
||||
} \
|
||||
} STMT_END
|
||||
/* Same thing, but update mark register too. */
|
||||
# define MEXTEND(p,n) STMT_START { \
|
||||
EXTEND_HWM_SET(p, n); \
|
||||
if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \
|
||||
const SSize_t markoff = mark - PL_stack_base;\
|
||||
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
|
||||
mark = PL_stack_base + markoff; \
|
||||
PERL_UNUSED_VAR(sp); \
|
||||
} \
|
||||
} STMT_END
|
||||
#endif
|
||||
|
||||
|
||||
/* set TARG to the IV value i. If do_taint is false,
|
||||
* assume that PL_tainted can never be true */
|
||||
#define TARGi(i, do_taint) \
|
||||
STMT_START { \
|
||||
IV TARGi_iv = i; \
|
||||
if (LIKELY( \
|
||||
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
|
||||
& (do_taint ? !TAINT_get : 1))) \
|
||||
{ \
|
||||
/* Cheap SvIOK_only(). \
|
||||
* Assert that flags which SvIOK_only() would test or \
|
||||
* clear can't be set, because we're SVt_IV */ \
|
||||
assert(!(SvFLAGS(TARG) & \
|
||||
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK))))); \
|
||||
SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK); \
|
||||
/* SvIV_set() where sv_any points to head */ \
|
||||
TARG->sv_u.svu_iv = TARGi_iv; \
|
||||
} \
|
||||
else \
|
||||
sv_setiv_mg(targ, TARGi_iv); \
|
||||
} STMT_END
|
||||
|
||||
/* set TARG to the UV value u. If do_taint is false,
|
||||
* assume that PL_tainted can never be true */
|
||||
#define TARGu(u, do_taint) \
|
||||
STMT_START { \
|
||||
UV TARGu_uv = u; \
|
||||
if (LIKELY( \
|
||||
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
|
||||
& (do_taint ? !TAINT_get : 1) \
|
||||
& (TARGu_uv <= (UV)IV_MAX))) \
|
||||
{ \
|
||||
/* Cheap SvIOK_only(). \
|
||||
* Assert that flags which SvIOK_only() would test or \
|
||||
* clear can't be set, because we're SVt_IV */ \
|
||||
assert(!(SvFLAGS(TARG) & \
|
||||
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK))))); \
|
||||
SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK); \
|
||||
/* SvIV_set() where sv_any points to head */ \
|
||||
TARG->sv_u.svu_iv = TARGu_uv; \
|
||||
} \
|
||||
else \
|
||||
sv_setuv_mg(targ, TARGu_uv); \
|
||||
} STMT_END
|
||||
|
||||
/* set TARG to the NV value n. If do_taint is false,
|
||||
* assume that PL_tainted can never be true */
|
||||
#define TARGn(n, do_taint) \
|
||||
STMT_START { \
|
||||
NV TARGn_nv = n; \
|
||||
if (LIKELY( \
|
||||
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST)) == SVt_NV) \
|
||||
& (do_taint ? !TAINT_get : 1))) \
|
||||
{ \
|
||||
/* Cheap SvNOK_only(). \
|
||||
* Assert that flags which SvNOK_only() would test or \
|
||||
* clear can't be set, because we're SVt_NV */ \
|
||||
assert(!(SvFLAGS(TARG) & \
|
||||
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_NOK|SVp_NOK))))); \
|
||||
SvFLAGS(TARG) |= (SVf_NOK|SVp_NOK); \
|
||||
SvNV_set(TARG, TARGn_nv); \
|
||||
} \
|
||||
else \
|
||||
sv_setnv_mg(targ, TARGn_nv); \
|
||||
} STMT_END
|
||||
|
||||
#ifdef PERL_RC_STACK
|
||||
# define PUSHs(s) (assert(!rpp_stack_is_rc()), *++sp = (s))
|
||||
#else
|
||||
# define PUSHs(s) (*++sp = (s))
|
||||
#endif
|
||||
|
||||
#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 PUSHpvs(s) PUSHp("" s "", sizeof(s)-1)
|
||||
#define PUSHn(n) STMT_START { TARGn(n,1); PUSHs(TARG); } STMT_END
|
||||
#define PUSHi(i) STMT_START { TARGi(i,1); PUSHs(TARG); } STMT_END
|
||||
#define PUSHu(u) STMT_START { TARGu(u,1); PUSHs(TARG); } STMT_END
|
||||
|
||||
#define XPUSHs(s) STMT_START { EXTEND(sp,1); PUSHs(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 XPUSHpvs(s) XPUSHp("" s "", sizeof(s)-1)
|
||||
#define XPUSHn(n) STMT_START { TARGn(n,1); XPUSHs(TARG); } STMT_END
|
||||
#define XPUSHi(i) STMT_START { TARGi(i,1); XPUSHs(TARG); } STMT_END
|
||||
#define XPUSHu(u) STMT_START { TARGu(u,1); XPUSHs(TARG); } 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 mPUSHpvs(s) mPUSHp("" s "", sizeof(s)-1)
|
||||
#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 mXPUSHpvs(s) mXPUSHp("" s "", sizeof(s)-1)
|
||||
#define mXPUSHn(n) STMT_START { EXTEND(sp,1); mPUSHn(n); } STMT_END
|
||||
#define mXPUSHi(i) STMT_START { EXTEND(sp,1); mPUSHi(i); } STMT_END
|
||||
#define mXPUSHu(u) STMT_START { EXTEND(sp,1); mPUSHu(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 { TARGn(n,1); SETs(TARG); } STMT_END
|
||||
#define SETi(i) STMT_START { TARGi(i,1); SETs(TARG); } STMT_END
|
||||
#define SETu(u) STMT_START { TARGu(u,1); SETs(TARG); } 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
|
||||
|
||||
#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 RETSETTARG STMT_START { SETTARG; RETURN; } STMT_END
|
||||
|
||||
#define ARGTARG PL_op->op_targ
|
||||
|
||||
#define MAXARG (PL_op->op_private & OPpARG4_MASK)
|
||||
|
||||
/* for backcompat - use switch_argstack() instead */
|
||||
|
||||
#define SWITCHSTACK(f,t) \
|
||||
STMT_START { \
|
||||
PL_curstack = f; \
|
||||
PL_stack_sp = sp; \
|
||||
switch_argstack(t); \
|
||||
sp = PL_stack_sp; \
|
||||
} STMT_END
|
||||
|
||||
#define EXTEND_MORTAL(n) \
|
||||
STMT_START { \
|
||||
SSize_t eMiX = PL_tmps_ix + (n); \
|
||||
if (UNLIKELY(eMiX >= PL_tmps_max)) \
|
||||
(void)Perl_tmps_grow_p(aTHX_ eMiX); \
|
||||
} STMT_END
|
||||
|
||||
#define AMGf_noright 1
|
||||
#define AMGf_noleft 2
|
||||
#define AMGf_assign 4 /* op supports mutator variant, e.g. $x += 1 */
|
||||
#define AMGf_unary 8
|
||||
#define AMGf_numeric 0x10 /* for Perl_try_amagic_bin */
|
||||
|
||||
#define AMGf_want_list 0x40
|
||||
#define AMGf_numarg 0x80
|
||||
|
||||
|
||||
/* do SvGETMAGIC on the stack args before checking for overload */
|
||||
|
||||
#define tryAMAGICun_MG(method, flags) STMT_START { \
|
||||
if ( UNLIKELY((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 ( UNLIKELY(((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))
|
||||
|
||||
/* 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
|
||||
|
||||
|
||||
/* 2019: no longer used in core */
|
||||
#define opASSIGN (PL_op->op_flags & OPf_STACKED)
|
||||
|
||||
/*
|
||||
=for apidoc mnU||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)
|
||||
|
||||
# define FIND_RUNCV_padid_eq 1
|
||||
# define FIND_RUNCV_level_eq 2
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
325
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp_proto.h
Normal file
325
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp_proto.h
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
|
||||
This file is built by opcode.pl from its data.
|
||||
Any changes made here will be lost!
|
||||
*/
|
||||
|
||||
PERL_CALLCONV PP(do_kv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aassign) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_abs) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_accept) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_add) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aeach) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aelem) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aelemfast) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aelemfastlex_store) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_akeys) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_alarm) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_and) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_anoncode) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_anonconst) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_anonhash) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_anonlist) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_argcheck) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_argdefelem) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_argelem) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_aslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_atan2) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_av2arylen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_avhvswitch) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_backtick) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_bind) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_binmode) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_bit_and) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_bit_or) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_bless) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_blessed) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_break) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_caller) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_catch) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ceil) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_chdir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_chop) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_chown) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_chr) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_chroot) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_classname) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_clonecv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_close) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_closedir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_cmpchain_and) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_cmpchain_dup) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_complement) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_concat) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_cond_expr) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_const) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_continue) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_coreargs) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_crypt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_dbmopen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_dbstate) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_defined) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_delete) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_die) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_divide) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_each) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ehostent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_emptyavhv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_enter) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_entereval) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_entergiven) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_enteriter) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_enterloop) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_entersub) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_entertry) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_entertrycatch) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_enterwhen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_enterwrite) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_eof) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_eq) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_exec) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_exists) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_exit) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_fc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_fileno) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_flip) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_flock) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_floor) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_flop) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_fork) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_formline) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ftis) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ftlink) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ftrowned) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ftrread) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_fttext) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_fttty) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ge) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gelem) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getlogin) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getpeername) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getpgrp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getppid) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_getpriority) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ggrent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ghostent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_glob) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gmtime) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gnetent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_goto) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gprotoent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gpwent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_grepstart) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_grepwhile) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gservent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_gvsv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_helem) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_helemexistsor) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_hintseval) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_hslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_add) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_divide) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_eq) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_ge) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_gt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_le) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_lt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_modulo) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_multiply) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_ncmp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_ne) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_negate) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_i_subtract) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_index) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_initfield) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_int) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_introcv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ioctl) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_is_bool) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_is_tainted) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_is_weak) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_isa) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_iter) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_join) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_kvaslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_kvhslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_last) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_le) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leave) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leaveeval) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavegiven) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leaveloop) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavesub) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavesublv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavetry) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavetrycatch) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavewhen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_leavewrite) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_left_shift) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_length) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_link) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_list) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_listen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lock) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lvavref) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lvref) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_lvrefslice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_mapwhile) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_match) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_method) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_method_named) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_method_redir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_method_redir_super) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_method_super) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_methstart) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_mkdir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_modulo) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_multiconcat) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_multideref) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_multiply) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_nbit_and) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_nbit_or) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ncmp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ncomplement) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ne) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_negate) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_next) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_nextstate) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_not) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_null) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_oct) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_once) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_open) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_open_dir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_or) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ord) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pack) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padav) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padcv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padhv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padrange) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padsv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_padsv_store) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pipe_op) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_poptry) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pos) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_postdec) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_postinc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pow) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_predec) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_preinc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_print) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_prototype) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_prtf) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_push) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pushdefer) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_pushmark) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_qr) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_quotemeta) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rand) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_range) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rcatline) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_readdir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_readline) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_readlink) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_redo) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ref) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_refaddr) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_refassign) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_refgen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_reftype) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_regcomp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_regcreset) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rename) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_repeat) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_require) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_reset) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_return) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_reverse) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rewinddir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_right_shift) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rmdir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_runcv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rv2av) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rv2cv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rv2gv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_rv2sv) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sassign) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sbit_and) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sbit_or) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_schop) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_scmp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_scomplement) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_seekdir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_select) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_semctl) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_semget) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_seq) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_setpgrp) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_setpriority) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_shift) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_shmwrite) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_shostent) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_shutdown) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sin) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sle) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sleep) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_smartmatch) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sne) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_socket) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sockpair) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sort) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_splice) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_split) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sprintf) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_srand) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_srefgen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sselect) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ssockopt) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_stat) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_stringify) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_stub) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_study) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_subst) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_substcont) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_substr) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_subtract) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_syscall) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sysopen) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sysread) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_sysseek) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_system) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_syswrite) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_tell) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_telldir) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_tie) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_tied) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_time) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_tms) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_trans) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_truncate) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_uc) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_ucfirst) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_umask) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_undef) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_unpack) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_unshift) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_unstack) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_untie) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_unweaken) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_vec) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_wait) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_waitpid) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_wantarray) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_warn) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_weaken) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(pp_xor) __attribute__visibility__("hidden");
|
||||
PERL_CALLCONV PP(unimplemented_op) __attribute__visibility__("hidden");
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
10870
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/proto.h
Normal file
10870
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/proto.h
Normal file
File diff suppressed because it is too large
Load diff
1702
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reentr.h
Normal file
1702
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reentr.h
Normal file
File diff suppressed because it is too large
Load diff
3858
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcharclass.h
Normal file
3858
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcharclass.h
Normal file
File diff suppressed because it is too large
Load diff
1575
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp.h
Normal file
1575
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp.h
Normal file
File diff suppressed because it is too large
Load diff
1260
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp_internal.h
Normal file
1260
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp_internal.h
Normal file
File diff suppressed because it is too large
Load diff
1098
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regexp.h
Normal file
1098
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regexp.h
Normal file
File diff suppressed because it is too large
Load diff
64
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reginline.h
Normal file
64
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reginline.h
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
|
||||
#ifndef PERL_REGINLINE_H
|
||||
|
||||
/*
|
||||
- regnext - dig the "next" pointer out of a node
|
||||
*/
|
||||
PERL_STATIC_INLINE
|
||||
regnode *
|
||||
Perl_regnext(pTHX_ const regnode *p)
|
||||
{
|
||||
I32 offset;
|
||||
|
||||
if (!p)
|
||||
return(NULL);
|
||||
|
||||
if (OP(p) > REGNODE_MAX) { /* regnode.type is unsigned */
|
||||
Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d",
|
||||
(int)OP(p), (int)REGNODE_MAX);
|
||||
}
|
||||
|
||||
offset = (REGNODE_OFF_BY_ARG(OP(p)) ? ARG1u(p) : NEXT_OFF(p));
|
||||
if (offset == 0)
|
||||
return(NULL);
|
||||
|
||||
return(regnode *)(p+offset);
|
||||
}
|
||||
|
||||
/*
|
||||
- regnode_after - find the node physically following p in memory,
|
||||
taking into account the size of p as determined by OP(p), our
|
||||
sizing data, and possibly the STR_SZ() macro.
|
||||
*/
|
||||
PERL_STATIC_INLINE
|
||||
regnode *
|
||||
Perl_regnode_after(pTHX_ const regnode *p, const bool varies)
|
||||
{
|
||||
assert(p);
|
||||
const U8 op = OP(p);
|
||||
assert(op < REGNODE_MAX);
|
||||
const regnode *ret = p + NODE_STEP_REGNODE + REGNODE_ARG_LEN(op);
|
||||
if (varies || REGNODE_ARG_LEN_VARIES(op))
|
||||
ret += STR_SZ(STR_LEN(p));
|
||||
return (regnode *)ret;
|
||||
}
|
||||
|
||||
/* validate that the passed in node and extra length would match that
|
||||
* returned by regnode_after() */
|
||||
PERL_STATIC_INLINE
|
||||
bool
|
||||
Perl_check_regnode_after(pTHX_ const regnode *p, const STRLEN extra)
|
||||
{
|
||||
const regnode *nextoper = regnode_after((regnode *)p,FALSE);
|
||||
const regnode *other = REGNODE_AFTER_PLUS(p, extra);
|
||||
if (nextoper != other) {
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#define PERL_REGINLINE_H
|
||||
#endif
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
2980
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regnodes.h
Normal file
2980
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regnodes.h
Normal file
File diff suppressed because it is too large
Load diff
1736
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sbox32_hash.h
Normal file
1736
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sbox32_hash.h
Normal file
File diff suppressed because it is too large
Load diff
322
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope.h
Normal file
322
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope.h
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
/* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "scope_types.h"
|
||||
|
||||
#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
|
||||
|
||||
/* the maximum number of entries that might be pushed using the SS_ADD*
|
||||
* macros */
|
||||
#define SS_MAXPUSH 4
|
||||
|
||||
#define SSGROW(need) if (UNLIKELY(PL_savestack_ix + (I32)(need) > PL_savestack_max)) savestack_grow_cnt(need)
|
||||
#define SSCHECK(need) SSGROW(need) /* legacy */
|
||||
#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))
|
||||
|
||||
/* SS_ADD*: newer, faster versions of the above. Don't mix the two sets of
|
||||
* macros. These are fast because they save reduce accesses to the PL_
|
||||
* vars and move the size check to the end. Doing the check last means
|
||||
* that values in registers will have been pushed and no longer needed, so
|
||||
* don't need saving around the call to grow. Also, tail-call elimination
|
||||
* of the grow() can be done. These changes reduce the code of something
|
||||
* like save_pushptrptr() to half its former size.
|
||||
* Of course, doing the size check *after* pushing means we must always
|
||||
* ensure there are SS_MAXPUSH free slots on the savestack. This is ensured by
|
||||
* savestack_grow_cnt always allocating SS_MAXPUSH slots
|
||||
* more than asked for, or that it sets PL_savestack_max to
|
||||
*
|
||||
* These are for internal core use only and are subject to change */
|
||||
|
||||
#define dSS_ADD \
|
||||
I32 ix = PL_savestack_ix; \
|
||||
ANY *ssp = &PL_savestack[ix]
|
||||
|
||||
#define SS_ADD_END(need) \
|
||||
assert((need) <= SS_MAXPUSH); \
|
||||
ix += (need); \
|
||||
PL_savestack_ix = ix; \
|
||||
assert(ix <= PL_savestack_max + SS_MAXPUSH); \
|
||||
if (UNLIKELY(ix > PL_savestack_max)) savestack_grow_cnt(ix - PL_savestack_max); \
|
||||
assert(PL_savestack_ix <= PL_savestack_max);
|
||||
|
||||
#define SS_ADD_INT(i) ((ssp++)->any_i32 = (I32)(i))
|
||||
#define SS_ADD_LONG(i) ((ssp++)->any_long = (long)(i))
|
||||
#define SS_ADD_BOOL(p) ((ssp++)->any_bool = (p))
|
||||
#define SS_ADD_IV(i) ((ssp++)->any_iv = (IV)(i))
|
||||
#define SS_ADD_UV(u) ((ssp++)->any_uv = (UV)(u))
|
||||
#define SS_ADD_PTR(p) ((ssp++)->any_ptr = (void*)(p))
|
||||
#define SS_ADD_DPTR(p) ((ssp++)->any_dptr = (p))
|
||||
#define SS_ADD_DXPTR(p) ((ssp++)->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)
|
||||
|
||||
|
||||
/*
|
||||
=for apidoc_section $callback
|
||||
|
||||
=for apidoc Amn;||SAVETMPS
|
||||
Opening bracket for temporaries on a callback. See C<L</FREETMPS>> and
|
||||
L<perlcall>.
|
||||
|
||||
=for apidoc Amn;||FREETMPS
|
||||
Closing bracket for temporaries on a callback. See C<L</SAVETMPS>> and
|
||||
L<perlcall>.
|
||||
|
||||
=for apidoc Amn;||ENTER
|
||||
Opening bracket on a callback. See C<L</LEAVE>> and L<perlcall>.
|
||||
|
||||
=for apidoc Amn;||LEAVE
|
||||
Closing bracket on a callback. See C<L</ENTER>> and L<perlcall>.
|
||||
|
||||
=for apidoc Am;||ENTER_with_name|"name"
|
||||
|
||||
Same as C<L</ENTER>>, but when debugging is enabled it also associates the
|
||||
given literal string with the new scope.
|
||||
|
||||
=for apidoc Am;||LEAVE_with_name|"name"
|
||||
|
||||
Same as C<L</LEAVE>>, but when debugging is enabled it first checks that the
|
||||
scope has the given name. C<name> must be a literal string.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#define SAVETMPS Perl_savetmps(aTHX)
|
||||
|
||||
#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] = ASSERT_IS_LITERAL(name);\
|
||||
DEBUG_SCOPE("ENTER \"" name "\"") \
|
||||
} STMT_END
|
||||
#define LEAVE_with_name(name) \
|
||||
STMT_START { \
|
||||
DEBUG_SCOPE("LEAVE \"" name "\"") \
|
||||
if (PL_scopestack_name) { \
|
||||
CLANG_DIAG_IGNORE_STMT(-Wstring-compare); \
|
||||
assert(((char*)PL_scopestack_name[PL_scopestack_ix-1] \
|
||||
== (char*)ASSERT_IS_LITERAL(name)) \
|
||||
|| strEQ(PL_scopestack_name[PL_scopestack_ix-1], name)); \
|
||||
CLANG_DIAG_RESTORE_STMT; \
|
||||
} \
|
||||
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) STMT_START { \
|
||||
if (PL_savestack_ix > old) leave_scope(old); \
|
||||
} STMT_END
|
||||
|
||||
#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 SAVESTRLEN(l) Perl_save_strlen(aTHX_ (STRLEN*)&(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 SAVEFREEPADNAME(s) save_pushptr((void *)(s), SAVEt_FREEPADNAME)
|
||||
#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 SAVERCPV(s) save_rcpv((char**)&(s))
|
||||
#define SAVEFREERCPV(s) save_freercpv(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), (SSize_t)(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 MORTALSVFUNC_X(f,sv) \
|
||||
mortal_svfunc_x((SVFUNC_t)(f), sv)
|
||||
|
||||
#define MORTALDESTRUCTOR_SV(coderef,args) \
|
||||
mortal_destructor_sv(coderef,args)
|
||||
|
||||
#define SAVESTACK_POS() \
|
||||
STMT_START { \
|
||||
dSS_ADD; \
|
||||
SS_ADD_INT(PL_stack_sp - PL_stack_base); \
|
||||
SS_ADD_UV(SAVEt_STACK_POS); \
|
||||
SS_ADD_END(2); \
|
||||
} 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
|
||||
|
||||
/* Note these are special, we can't just use a save_pushptrptr() on them
|
||||
* as the target might change after a fork or thread start. */
|
||||
#define SAVECOMPILEWARNINGS() save_pushptr(PL_compiling.cop_warnings, SAVEt_COMPILE_WARNINGS)
|
||||
#define SAVECURCOPWARNINGS() save_pushptr(PL_curcop->cop_warnings, SAVEt_CURCOP_WARNINGS)
|
||||
|
||||
|
||||
#define SAVEPARSER(p) save_pushptr((p), SAVEt_PARSER)
|
||||
|
||||
#ifdef USE_ITHREADS
|
||||
# define SAVECOPSTASH_FREE(c) SAVEIV((c)->cop_stashoff)
|
||||
# define SAVECOPFILE_x(c) SAVEPPTR((c)->cop_file)
|
||||
# define SAVECOPFILE(c) \
|
||||
STMT_START { \
|
||||
SAVECOPFILE_x(c); \
|
||||
CopFILE_debug((c),"SAVECOPFILE",0); \
|
||||
} STMT_END
|
||||
# define SAVECOPFILE_FREE_x(c) SAVERCPV((c)->cop_file)
|
||||
# define SAVECOPFILE_FREE(c) \
|
||||
STMT_START { \
|
||||
SAVECOPFILE_FREE_x(c); \
|
||||
CopFILE_debug((c),"SAVECOPFILE_FREE",0); \
|
||||
} STMT_END
|
||||
#else
|
||||
# /* XXX not refcounted */
|
||||
# define SAVECOPSTASH_FREE(c) SAVESPTR(CopSTASH(c))
|
||||
# define SAVECOPFILE(c) SAVESPTR(CopFILEGV(c))
|
||||
# define SAVECOPFILE_FREE(c) SAVEGENERICSV(CopFILEGV(c))
|
||||
#endif
|
||||
|
||||
#define SAVECOPLINE(c) SAVEI32(CopLINE(c))
|
||||
|
||||
/*
|
||||
=for apidoc_section $stack
|
||||
=for apidoc Am|SSize_t|SSNEW |Size_t size
|
||||
=for apidoc_item | |SSNEWa |Size_t size|Size_t align
|
||||
=for apidoc_item | |SSNEWat|Size_t size|type|Size_t align
|
||||
=for apidoc_item | |SSNEWt |Size_t size|type
|
||||
|
||||
These each temporarily allocate data on the savestack, returning an SSize_t
|
||||
index into the savestack, because a pointer would get broken if the savestack
|
||||
is moved on reallocation. Use L</C<SSPTR>> to convert the returned index into
|
||||
a pointer.
|
||||
|
||||
The forms differ in that plain C<SSNEW> allocates C<size> bytes;
|
||||
C<SSNEWt> and C<SSNEWat> allocate C<size> objects, each of which is type
|
||||
C<type>;
|
||||
and <SSNEWa> and C<SSNEWat> make sure to align the new data to an C<align>
|
||||
boundary. The most useful value for the alignment is likely to be
|
||||
L</C<MEM_ALIGNBYTES>>. The alignment will be preserved through savestack
|
||||
reallocation B<only> if realloc returns data aligned to a size divisible by
|
||||
"align"!
|
||||
|
||||
=for apidoc Am|type |SSPTR |SSize_t index|type
|
||||
=for apidoc_item|type *|SSPTRt|SSize_t index|type
|
||||
|
||||
These convert the C<index> returned by L/<C<SSNEW>> and kin into actual pointers.
|
||||
|
||||
The difference is that C<SSPTR> casts the result to C<type>, and C<SSPTRt>
|
||||
casts it to a pointer of that C<type>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#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) (assert(sizeof(off) >= sizeof(SSize_t)), (type) ((char*)PL_savestack + off))
|
||||
#define SSPTRt(off,type) (assert(sizeof(off) >= sizeof(SSize_t)), (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) \
|
||||
STMT_START { \
|
||||
OP * const _o = (OP *)(op); \
|
||||
assert(!_o->op_savefree); \
|
||||
_o->op_savefree = 1; \
|
||||
save_pushptr((void *)(_o), SAVEt_FREEOP); \
|
||||
} STMT_END
|
||||
#define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV)
|
||||
|
||||
/*
|
||||
=for apidoc_section $callback
|
||||
=for apidoc save_op
|
||||
|
||||
Implements C<SAVEOP>.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
#define save_op() save_pushptr((void *)(PL_op), SAVEt_OP)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
151
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope_types.h
Normal file
151
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope_types.h
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
/* -*- mode: C; buffer-read-only: t -*-
|
||||
|
||||
Copyright (C) 2022 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/scope_types.pl.
|
||||
Any changes made here will be lost!
|
||||
The defines and contents of the leave_scope_arg_counts[] array
|
||||
must match. To add a new type modify the __DATA__ section in
|
||||
regen/scope_types.pl and run `make regen` to rebuild the file.
|
||||
*/
|
||||
|
||||
/* zero args */
|
||||
|
||||
#define SAVEt_ALLOC 0
|
||||
#define SAVEt_CLEARPADRANGE 1
|
||||
#define SAVEt_CLEARSV 2
|
||||
#define SAVEt_REGCONTEXT 3
|
||||
|
||||
/* one arg */
|
||||
|
||||
#define SAVEt_TMPSFLOOR 4
|
||||
#define SAVEt_BOOL 5
|
||||
#define SAVEt_COMPILE_WARNINGS 6
|
||||
#define SAVEt_CURCOP_WARNINGS 7
|
||||
#define SAVEt_COMPPAD 8
|
||||
#define SAVEt_FREECOPHH 9
|
||||
#define SAVEt_FREEOP 10
|
||||
#define SAVEt_FREEPV 11
|
||||
#define SAVEt_FREESV 12
|
||||
#define SAVEt_I16 13
|
||||
#define SAVEt_I32_SMALL 14
|
||||
#define SAVEt_I8 15
|
||||
#define SAVEt_INT_SMALL 16
|
||||
#define SAVEt_MORTALIZESV 17
|
||||
#define SAVEt_NSTAB 18
|
||||
#define SAVEt_OP 19
|
||||
#define SAVEt_PARSER 20
|
||||
#define SAVEt_STACK_POS 21
|
||||
#define SAVEt_READONLY_OFF 22
|
||||
#define SAVEt_FREEPADNAME 23
|
||||
#define SAVEt_STRLEN_SMALL 24
|
||||
#define SAVEt_FREERCPV 25
|
||||
|
||||
/* two args */
|
||||
|
||||
#define SAVEt_AV 26
|
||||
#define SAVEt_DESTRUCTOR 27
|
||||
#define SAVEt_DESTRUCTOR_X 28
|
||||
#define SAVEt_GENERIC_PVREF 29
|
||||
#define SAVEt_GENERIC_SVREF 30
|
||||
#define SAVEt_GP 31
|
||||
#define SAVEt_GVSV 32
|
||||
#define SAVEt_HINTS 33
|
||||
#define SAVEt_HPTR 34
|
||||
#define SAVEt_HV 35
|
||||
#define SAVEt_I32 36
|
||||
#define SAVEt_INT 37
|
||||
#define SAVEt_ITEM 38
|
||||
#define SAVEt_IV 39
|
||||
#define SAVEt_LONG 40
|
||||
#define SAVEt_PPTR 41
|
||||
#define SAVEt_SAVESWITCHSTACK 42
|
||||
#define SAVEt_SHARED_PVREF 43
|
||||
#define SAVEt_SPTR 44
|
||||
#define SAVEt_STRLEN 45
|
||||
#define SAVEt_SV 46
|
||||
#define SAVEt_SVREF 47
|
||||
#define SAVEt_VPTR 48
|
||||
#define SAVEt_ADELETE 49
|
||||
#define SAVEt_APTR 50
|
||||
#define SAVEt_RCPV 51
|
||||
|
||||
/* three args */
|
||||
|
||||
#define SAVEt_HELEM 52
|
||||
#define SAVEt_PADSV_AND_MORTALIZE 53
|
||||
#define SAVEt_SET_SVFLAGS 54
|
||||
#define SAVEt_GVSLOT 55
|
||||
#define SAVEt_AELEM 56
|
||||
#define SAVEt_DELETE 57
|
||||
#define SAVEt_HINTS_HH 58
|
||||
|
||||
static const U8 leave_scope_arg_counts[] = {
|
||||
0, /* SAVEt_ALLOC */
|
||||
0, /* SAVEt_CLEARPADRANGE */
|
||||
0, /* SAVEt_CLEARSV */
|
||||
0, /* SAVEt_REGCONTEXT */
|
||||
1, /* SAVEt_TMPSFLOOR */
|
||||
1, /* SAVEt_BOOL */
|
||||
1, /* SAVEt_COMPILE_WARNINGS */
|
||||
1, /* SAVEt_CURCOP_WARNINGS */
|
||||
1, /* SAVEt_COMPPAD */
|
||||
1, /* SAVEt_FREECOPHH */
|
||||
1, /* SAVEt_FREEOP */
|
||||
1, /* SAVEt_FREEPV */
|
||||
1, /* SAVEt_FREESV */
|
||||
1, /* SAVEt_I16 */
|
||||
1, /* SAVEt_I32_SMALL */
|
||||
1, /* SAVEt_I8 */
|
||||
1, /* SAVEt_INT_SMALL */
|
||||
1, /* SAVEt_MORTALIZESV */
|
||||
1, /* SAVEt_NSTAB */
|
||||
1, /* SAVEt_OP */
|
||||
1, /* SAVEt_PARSER */
|
||||
1, /* SAVEt_STACK_POS */
|
||||
1, /* SAVEt_READONLY_OFF */
|
||||
1, /* SAVEt_FREEPADNAME */
|
||||
1, /* SAVEt_STRLEN_SMALL */
|
||||
1, /* SAVEt_FREERCPV */
|
||||
2, /* SAVEt_AV */
|
||||
2, /* SAVEt_DESTRUCTOR */
|
||||
2, /* SAVEt_DESTRUCTOR_X */
|
||||
2, /* SAVEt_GENERIC_PVREF */
|
||||
2, /* SAVEt_GENERIC_SVREF */
|
||||
2, /* SAVEt_GP */
|
||||
2, /* SAVEt_GVSV */
|
||||
2, /* SAVEt_HINTS */
|
||||
2, /* SAVEt_HPTR */
|
||||
2, /* SAVEt_HV */
|
||||
2, /* SAVEt_I32 */
|
||||
2, /* SAVEt_INT */
|
||||
2, /* SAVEt_ITEM */
|
||||
2, /* SAVEt_IV */
|
||||
2, /* SAVEt_LONG */
|
||||
2, /* SAVEt_PPTR */
|
||||
2, /* SAVEt_SAVESWITCHSTACK */
|
||||
2, /* SAVEt_SHARED_PVREF */
|
||||
2, /* SAVEt_SPTR */
|
||||
2, /* SAVEt_STRLEN */
|
||||
2, /* SAVEt_SV */
|
||||
2, /* SAVEt_SVREF */
|
||||
2, /* SAVEt_VPTR */
|
||||
2, /* SAVEt_ADELETE */
|
||||
2, /* SAVEt_APTR */
|
||||
2, /* SAVEt_RCPV */
|
||||
3, /* SAVEt_HELEM */
|
||||
3, /* SAVEt_PADSV_AND_MORTALIZE */
|
||||
3, /* SAVEt_SET_SVFLAGS */
|
||||
3, /* SAVEt_GVSLOT */
|
||||
3, /* SAVEt_AELEM */
|
||||
3, /* SAVEt_DELETE */
|
||||
3 /* SAVEt_HINTS_HH */
|
||||
};
|
||||
|
||||
#define MAX_SAVEt 58
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
2726
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv.h
Normal file
2726
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv.h
Normal file
File diff suppressed because it is too large
Load diff
1019
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv_inline.h
Normal file
1019
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv_inline.h
Normal file
File diff suppressed because it is too large
Load diff
549
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/thread.h
Normal file
549
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/thread.h
Normal file
|
|
@ -0,0 +1,549 @@
|
|||
/* 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 <builtins.h>
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
# include <win32thread.h>
|
||||
#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 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(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
|
||||
|
||||
#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 __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 <mach/cthreads.h> 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_RET_TYPE any_t
|
||||
|
||||
#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
|
||||
# elif defined(HAS_SCHED_YIELD)
|
||||
# define YIELD sched_yield()
|
||||
# elif defined(HAS_PTHREAD_YIELD)
|
||||
/* pthread_yield(NULL) platforms are expected
|
||||
* to have #defined YIELD for themselves. */
|
||||
# define YIELD pthread_yield()
|
||||
# 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
|
||||
|
||||
# ifdef PERL_TSA_ACTIVE
|
||||
# define perl_pthread_mutex_lock(m) perl_tsa_mutex_lock(m)
|
||||
# define perl_pthread_mutex_unlock(m) perl_tsa_mutex_unlock(m)
|
||||
# else
|
||||
# define perl_pthread_mutex_lock(m) pthread_mutex_lock(m)
|
||||
# define perl_pthread_mutex_unlock(m) pthread_mutex_unlock(m)
|
||||
# endif
|
||||
|
||||
# define MUTEX_LOCK(m) \
|
||||
STMT_START { \
|
||||
dSAVE_ERRNO; \
|
||||
int _eC_; \
|
||||
if ((_eC_ = perl_pthread_mutex_lock((m)))) \
|
||||
Perl_croak_nocontext("panic: MUTEX_LOCK (%d) [%s:%d]",\
|
||||
_eC_, __FILE__, __LINE__); \
|
||||
RESTORE_ERRNO; \
|
||||
} STMT_END
|
||||
|
||||
# define MUTEX_UNLOCK(m) \
|
||||
STMT_START { \
|
||||
dSAVE_ERRNO; /* Shouldn't be necessary as panics if fails */\
|
||||
int _eC_; \
|
||||
if ((_eC_ = perl_pthread_mutex_unlock((m)))) { \
|
||||
Perl_croak_nocontext( \
|
||||
"panic: MUTEX_UNLOCK (%d) [%s:%d]", \
|
||||
_eC_, __FILE__, __LINE__); \
|
||||
} \
|
||||
RESTORE_ERRNO; \
|
||||
} STMT_END
|
||||
|
||||
# define MUTEX_DESTROY(m) \
|
||||
STMT_START { \
|
||||
int _eC_; \
|
||||
if ((_eC_ = pthread_mutex_destroy((m)))) { \
|
||||
dTHX; \
|
||||
if (PL_phase != PERL_PHASE_DESTRUCT) { \
|
||||
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)))) { \
|
||||
dTHX; \
|
||||
if (PL_phase != PERL_PHASE_DESTRUCT) { \
|
||||
Perl_croak_nocontext("panic: COND_DESTROY (%d) [%s:%d]", \
|
||||
_eC_, __FILE__, __LINE__); \
|
||||
} \
|
||||
} \
|
||||
} STMT_END
|
||||
#endif /* COND_INIT */
|
||||
|
||||
#if defined(MUTEX_LOCK) && defined(MUTEX_UNLOCK) \
|
||||
&& defined(COND_SIGNAL) && defined(COND_WAIT)
|
||||
|
||||
/* These emulate native many-reader/1-writer locks.
|
||||
* Basically a locking reader just locks the semaphore long enough to increment
|
||||
* a counter; and similarly decrements it when when through. Any writer will
|
||||
* run only when the count of readers is 0. That is because it blocks on that
|
||||
* semaphore (doing a COND_WAIT) until it gets control of it, which won't
|
||||
* happen unless the count becomes 0. ALL readers and other writers are then
|
||||
* blocked until it releases the semaphore. The reader whose unlocking causes
|
||||
* the count to become 0 signals any waiting writers, and the system guarantees
|
||||
* that only one gets control at a time */
|
||||
|
||||
# define PERL_READ_LOCK(mutex) \
|
||||
STMT_START { \
|
||||
MUTEX_LOCK(&(mutex)->lock); \
|
||||
(mutex)->readers_count++; \
|
||||
MUTEX_UNLOCK(&(mutex)->lock); \
|
||||
} STMT_END
|
||||
|
||||
# define PERL_READ_UNLOCK(mutex) \
|
||||
STMT_START { \
|
||||
MUTEX_LOCK(&(mutex)->lock); \
|
||||
(mutex)->readers_count--; \
|
||||
if ((mutex)->readers_count <= 0) { \
|
||||
assert((mutex)->readers_count == 0); \
|
||||
COND_SIGNAL(&(mutex)->wakeup); \
|
||||
(mutex)->readers_count = 0; \
|
||||
} \
|
||||
MUTEX_UNLOCK(&(mutex)->lock); \
|
||||
} STMT_END
|
||||
|
||||
# define PERL_WRITE_LOCK(mutex) \
|
||||
STMT_START { \
|
||||
MUTEX_LOCK(&(mutex)->lock); \
|
||||
do { \
|
||||
if ((mutex)->readers_count <= 0) { \
|
||||
assert((mutex)->readers_count == 0); \
|
||||
(mutex)->readers_count = 0; \
|
||||
break; \
|
||||
} \
|
||||
COND_WAIT(&(mutex)->wakeup, &(mutex)->lock); \
|
||||
} \
|
||||
while (1); \
|
||||
\
|
||||
/* Here, the mutex is locked, with no readers */ \
|
||||
} STMT_END
|
||||
|
||||
# define PERL_WRITE_UNLOCK(mutex) \
|
||||
STMT_START { \
|
||||
COND_SIGNAL(&(mutex)->wakeup); \
|
||||
MUTEX_UNLOCK(&(mutex)->lock); \
|
||||
} STMT_END
|
||||
|
||||
# define PERL_RW_MUTEX_INIT(mutex) \
|
||||
STMT_START { \
|
||||
MUTEX_INIT(&(mutex)->lock); \
|
||||
COND_INIT(&(mutex)->wakeup); \
|
||||
(mutex)->readers_count = 0; \
|
||||
} STMT_END
|
||||
|
||||
# define PERL_RW_MUTEX_DESTROY(mutex) \
|
||||
STMT_START { \
|
||||
COND_DESTROY(&(mutex)->wakeup); \
|
||||
MUTEX_DESTROY(&(mutex)->lock); \
|
||||
} STMT_END
|
||||
|
||||
#endif
|
||||
|
||||
/* 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
|
||||
|
||||
#if defined(PERL_THREAD_LOCAL) && !defined(PERL_GET_CONTEXT) && !defined(PERL_SET_CONTEXT) && !defined(__cplusplus)
|
||||
/* Use C11 thread-local storage, where possible.
|
||||
* Frustratingly we can't use it for C++ extensions, C++ and C disagree on the
|
||||
* syntax used for thread local storage, meaning that the working token that
|
||||
* Configure probed for C turns out to be a compiler error on C++. Great.
|
||||
* (Well, unless one or both is supporting non-standard syntax as an extension)
|
||||
* As Configure doesn't have a way to probe for C++ dialects, we just take the
|
||||
* safe option and do the same as 5.34.0 and earlier - use pthreads on C++.
|
||||
* Of course, if C++ XS extensions really want to avoid *all* this overhead,
|
||||
* they should #define PERL_NO_GET_CONTEXT and pass aTHX/aTHX_ explicitly) */
|
||||
# define PERL_USE_THREAD_LOCAL
|
||||
extern PERL_THREAD_LOCAL void *PL_current_context;
|
||||
|
||||
# define PERL_GET_CONTEXT PL_current_context
|
||||
|
||||
/* We must also call pthread_setspecific() always, as C++ code has to read it
|
||||
* with pthreads (the #else side just below) */
|
||||
|
||||
# define PERL_SET_CONTEXT(t) \
|
||||
STMT_START { \
|
||||
int _eC_; \
|
||||
if ((_eC_ = pthread_setspecific(PL_thr_key, \
|
||||
PL_current_context = (void *)(t)))) \
|
||||
Perl_croak_nocontext("panic: pthread_setspecific (%d) [%s:%d]", \
|
||||
_eC_, __FILE__, __LINE__); \
|
||||
PERL_SET_NON_tTHX_CONTEXT(t); \
|
||||
} STMT_END
|
||||
|
||||
#else
|
||||
/* else fall back to pthreads */
|
||||
|
||||
# ifndef PERL_GET_CONTEXT
|
||||
# define PERL_GET_CONTEXT PTHREAD_GETSPECIFIC(PL_thr_key)
|
||||
# endif
|
||||
|
||||
/* For C++ extensions built on a system where the C compiler provides thread
|
||||
* local storage that call PERL_SET_CONTEXT() also need to set
|
||||
* PL_current_context, so need to call into C code to do this.
|
||||
* To avoid exploding code complexity, do this also on C platforms that don't
|
||||
* support thread local storage. PERL_SET_CONTEXT is not called that often. */
|
||||
|
||||
# ifndef PERL_SET_CONTEXT
|
||||
# define PERL_SET_CONTEXT(t) Perl_set_context((void*)t)
|
||||
# endif /* PERL_SET_CONTEXT */
|
||||
#endif /* PERL_THREAD_LOCAL */
|
||||
|
||||
#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)) { \
|
||||
PERL_UNUSED_RESULT(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 *
|
||||
#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) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef MUTEX_UNLOCK
|
||||
# define MUTEX_UNLOCK(m) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef MUTEX_INIT
|
||||
# define MUTEX_INIT(m) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef MUTEX_DESTROY
|
||||
# define MUTEX_DESTROY(m) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef COND_INIT
|
||||
# define COND_INIT(c) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef COND_SIGNAL
|
||||
# define COND_SIGNAL(c) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef COND_BROADCAST
|
||||
# define COND_BROADCAST(c) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef COND_WAIT
|
||||
# define COND_WAIT(c, m) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef COND_DESTROY
|
||||
# define COND_DESTROY(c) NOOP
|
||||
#endif
|
||||
|
||||
#ifndef PERL_READ_LOCK
|
||||
# define PERL_READ_LOCK NOOP
|
||||
# define PERL_READ_UNLOCK NOOP
|
||||
# define PERL_WRITE_LOCK NOOP
|
||||
# define PERL_WRITE_UNLOCK NOOP
|
||||
# define PERL_RW_MUTEX_INIT NOOP
|
||||
# define PERL_RW_MUTEX_DESTROY NOOP
|
||||
#endif
|
||||
|
||||
#ifndef LOCK_DOLLARZERO_MUTEX
|
||||
# define LOCK_DOLLARZERO_MUTEX NOOP
|
||||
#endif
|
||||
|
||||
#ifndef UNLOCK_DOLLARZERO_MUTEX
|
||||
# define UNLOCK_DOLLARZERO_MUTEX NOOP
|
||||
#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
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
48
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/time64.h
Normal file
48
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/time64.h
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
#include <time.h>
|
||||
#include "time64_config.h"
|
||||
|
||||
#ifndef PERL_TIME64_H_
|
||||
# define PERL_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
|
||||
const char *tm_zone;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
/* Decide which tm struct to use */
|
||||
#ifdef USE_TM64
|
||||
#define TM TM64
|
||||
#else
|
||||
#define TM tm
|
||||
#endif
|
||||
|
||||
|
||||
/* Declare functions */
|
||||
struct TM *Perl_gmtime64_r (const Time64_T *, struct TM *);
|
||||
struct TM *Perl_localtime64_r (const Time64_T *, struct TM *);
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,87 @@
|
|||
#ifndef PERL_TIME64_CONFIG_H_
|
||||
# define PERL_TIME64_CONFIG_H_
|
||||
|
||||
#include "reentr.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 /* PERL_TIME64_CONFIG_H_ */
|
||||
7765
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uni_keywords.h
Normal file
7765
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uni_keywords.h
Normal file
File diff suppressed because it is too large
Load diff
File diff suppressed because one or more lines are too long
175
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/unixish.h
Normal file
175
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/unixish.h
Normal file
|
|
@ -0,0 +1,175 @@
|
|||
/* 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.
|
||||
*/
|
||||
|
||||
/* 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
|
||||
|
||||
/* 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 <sys/stat.h> and <sys/types.h> 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 <signal.h>
|
||||
|
||||
#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))
|
||||
|
||||
#ifdef __amigaos4__
|
||||
int afstat(int fd, struct stat *statb);
|
||||
# define Fstat(fd,bufptr) afstat((fd),(bufptr))
|
||||
#endif
|
||||
|
||||
#ifndef Fstat
|
||||
# define Fstat(fd,bufptr) fstat((fd),(bufptr))
|
||||
#endif
|
||||
|
||||
#define Fflush(fp) fflush(fp)
|
||||
#define Mkdir(path,mode) mkdir((path),(mode))
|
||||
|
||||
#if defined(__amigaos4__)
|
||||
# define PLATFORM_SYS_TERM_ amigaos4_dispose_fork_array()
|
||||
# define PLATFORM_SYS_INIT_ STMT_START { \
|
||||
amigaos4_init_fork_array(); \
|
||||
amigaos4_init_environ_sema(); \
|
||||
} STMT_END
|
||||
#else
|
||||
# define PLATFORM_SYS_TERM_ NOOP
|
||||
# define PLATFORM_SYS_INIT_ NOOP
|
||||
#endif
|
||||
|
||||
#ifndef PERL_SYS_INIT_BODY
|
||||
#define PERL_SYS_INIT_BODY(c,v) \
|
||||
MALLOC_CHECK_TAINT2(*c,*v) PERL_FPU_INIT; PERLIO_INIT; \
|
||||
MALLOC_INIT; PLATFORM_SYS_INIT_;
|
||||
#endif
|
||||
|
||||
/* Generally add things last-in first-terminated. IO and memory terminations
|
||||
* need to be generally last
|
||||
*
|
||||
* BEWARE that using PerlIO in these will be using freed memory, so may appear
|
||||
* to work, but must NOT be retained in production code. */
|
||||
#ifndef PERL_SYS_TERM_BODY
|
||||
# define PERL_SYS_TERM_BODY() \
|
||||
ENV_TERM; USER_PROP_MUTEX_TERM; LOCALE_TERM; \
|
||||
HINTS_REFCNT_TERM; KEYWORD_PLUGIN_MUTEX_TERM; \
|
||||
OP_CHECK_MUTEX_TERM; OP_REFCNT_TERM; \
|
||||
PERLIO_TERM; MALLOC_TERM; \
|
||||
PLATFORM_SYS_TERM_;
|
||||
#endif
|
||||
|
||||
#define BIT_BUCKET "/dev/null"
|
||||
|
||||
#define dXSUB_SYS dNOOP
|
||||
|
||||
#ifndef NO_ENVIRON_ARRAY
|
||||
#define USE_ENVIRON_ARRAY
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
1319
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utf8.h
Normal file
1319
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utf8.h
Normal file
File diff suppressed because it is too large
Load diff
208
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utfebcdic.h
Normal file
208
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utfebcdic.h
Normal file
|
|
@ -0,0 +1,208 @@
|
|||
/* 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
|
||||
* Adapted from version 7.1 of Unicode Technical Report #16:
|
||||
* http://www.unicode.org/reports/tr16
|
||||
*
|
||||
* To summarize, the way it works is:
|
||||
* To convert an EBCDIC code point to UTF-EBCDIC:
|
||||
* 1) convert to Unicode. No conversion is necessary for code points above
|
||||
* 255, as Unicode and EBCDIC are identical in this range. For smaller
|
||||
* code points, the conversion is done by lookup in the PL_e2a table (with
|
||||
* inverse PL_a2e) in the generated file 'ebcdic_tables.h'. The 'a'
|
||||
* stands for ASCII platform, meaning 0-255 Unicode. Use
|
||||
* NATIVE_TO_LATIN1() and LATIN1_TO_NATIVE(), respectively to perform this
|
||||
* lookup. NATIVE_TO_UNI() and UNI_TO_NATIVE() are similarly used for any
|
||||
* input, and know to avoid the lookup for inputs above 255.
|
||||
* 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. If
|
||||
* all 8 bits in the first byte are 1, the code point
|
||||
* will occupy 14 bytes (compared to 13 in Perl's
|
||||
* extended UTF-8). This is incompatible with what
|
||||
* tr16 implies should be the representation of code
|
||||
* points 2**30 and above, but allows Perl to be able
|
||||
* to represent all code points that fit in a 64-bit
|
||||
* word in either our extended UTF-EBCDIC or UTF-8.
|
||||
* 3) Use the algorithm in tr16 to convert each byte from step 2 into
|
||||
* final UTF-EBCDIC. This is done by table lookup from a table
|
||||
* constructed from the algorithm, reproduced in ebcdic_tables.h as
|
||||
* PL_utf2e, with its inverse being PL_e2utf. They are constructed so that
|
||||
* all EBCDIC invariants remain invariant, but no others do, and the first
|
||||
* byte of a variant will always have its upper bit set. But note that
|
||||
* the upper bit of some invariants is also 1. The table also is designed
|
||||
* so that lexically comparing two UTF-EBCDIC-variant characters yields
|
||||
* the Unicode code point order. (To get native code point order, one has
|
||||
* to convert the latin1-range characters to their native code point
|
||||
* value.) The macros NATIVE_UTF8_TO_I8() and I8_TO_NATIVE_UTF8() do the
|
||||
* table lookups.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* 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, using the
|
||||
* macro NATIVE_TO_I8(). However, one "shadow", or parallel table,
|
||||
* PL_utf8skip, has been constructed that doesn't require undoing things. It
|
||||
* is such that for each byte, it says how long the sequence is if that
|
||||
* (UTF-EBCDIC) byte were to begin it.
|
||||
*
|
||||
* There are actually 3 slightly different UTF-EBCDIC encodings in
|
||||
* ebcdic_tables.h, 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.)
|
||||
*
|
||||
* Note that tr16 actually only specifies one version of UTF-EBCDIC, based on
|
||||
* the 1047 encoding, and which is supposed to be used for all code pages.
|
||||
* But this doesn't work. To illustrate the problem, consider the '^' character.
|
||||
* On a 037 code page it is the single byte 176, whereas under 1047 UTF-EBCDIC
|
||||
* it is the single byte 95. If Perl implemented tr16 exactly, it would mean
|
||||
* that changing a string containing '^' to UTF-EBCDIC would change that '^'
|
||||
* from 176 to 95 (and vice-versa), violating the rule that ASCII-range
|
||||
* characters are the same in UTF-8 or not. Much code in Perl assumes this
|
||||
* rule. See for example
|
||||
* http://grokbase.com/t/perl/mvs/025xf0yhmn/utf-ebcdic-for-posix-bc-malformed-utf-8-character
|
||||
* What Perl does is create a version of UTF-EBCDIC suited to each code page;
|
||||
* the one for the 1047 code page is identical to what's specified in tr16.
|
||||
* This complicates interchanging files between computers using different code
|
||||
* pages. Best is to convert to I8 before sending them, as the I8
|
||||
* representation is the same no matter what the underlying code page is.
|
||||
*
|
||||
* Because of the way UTF-EBCDIC is constructed, the lowest 32 code points that
|
||||
* aren't equivalent to ASCII characters nor C1 controls form the set of
|
||||
* continuation bytes; the remaining 64 non-ASCII, non-control code points form
|
||||
* the potential start bytes, in order. (However, the first 5 of these lead to
|
||||
* malformed overlongs, so there really are only 59 start bytes, and the first
|
||||
* three of the 59 are the start bytes for the Latin1 range.) Hence the
|
||||
* UTF-EBCDIC for the smallest variant code point, 0x160, will have likely 0x41
|
||||
* as its continuation byte, provided 0x41 isn't an ASCII or C1 equivalent.
|
||||
* And its start byte will be the code point that is 37 (32+5) non-ASCII,
|
||||
* non-control code points past it. (0 - 3F are controls, and 40 is SPACE,
|
||||
* leaving 41 as the first potentially available one.) In contrast, on ASCII
|
||||
* platforms, the first 64 (not 32) non-ASCII code points are the continuation
|
||||
* bytes. And the first 2 (not 5) potential start bytes form overlong
|
||||
* malformed sequences.
|
||||
*
|
||||
* 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 PL_e2utf; likewise 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
|
||||
|
||||
#include "ebcdic_tables.h"
|
||||
|
||||
END_EXTERN_C
|
||||
|
||||
/* EBCDIC-happy ways of converting native code to UTF-8 */
|
||||
|
||||
/* Use these when ch is known to be < 256 */
|
||||
#define NATIVE_TO_LATIN1(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) PL_e2a[(U8)(ch)])
|
||||
#define LATIN1_TO_NATIVE(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) PL_a2e[(U8)(ch)])
|
||||
|
||||
/* Use these on bytes */
|
||||
#define NATIVE_UTF8_TO_I8(b) (__ASSERT_(FITS_IN_8_BITS(b)) PL_e2utf[(U8)(b)])
|
||||
#define I8_TO_NATIVE_UTF8(b) (__ASSERT_(FITS_IN_8_BITS(b)) PL_utf2e[(U8)(b)])
|
||||
|
||||
/* Transforms in wide UV chars */
|
||||
#define NATIVE_TO_UNI(ch) \
|
||||
(FITS_IN_8_BITS(ch) ? NATIVE_TO_LATIN1(ch) : (UV) (ch))
|
||||
#define UNI_TO_NATIVE(ch) \
|
||||
(FITS_IN_8_BITS(ch) ? LATIN1_TO_NATIVE(ch) : (UV) (ch))
|
||||
/*
|
||||
The following table is adapted from tr16, it shows the I8 encoding of Unicode code points.
|
||||
|
||||
Unicode U32 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+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+3FFFFFFF 00uuuuuvvvvvwwwwwzzzzzyyyyyxxxxx 11111110 101uuuuu 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx
|
||||
|
||||
Beyond this, Perl uses an incompatible extension, similar to the one used in
|
||||
regular UTF-8. There are now 14 bytes. A full 32 bits of information thus looks like this:
|
||||
1st Byte 2nd-7th 8th Byte 9th Byte 10th B 11th B 12th B 13th B 14th B
|
||||
U+40000000..U+FFFFFFFF ttuuuuuvvvvvwwwwwzzzzzyyyyyxxxxx 11111111 10100000 101000tt 101uuuuu 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx
|
||||
|
||||
For 32-bit words, the 2nd through 7th bytes effectively function as leading
|
||||
zeros. Above 32 bits, these fill up, with each byte yielding 5 bits of
|
||||
information, so that with 13 continuation bytes, we can handle 65 bits, just
|
||||
above what a 64 bit word can hold
|
||||
|
||||
The following table gives the I8:
|
||||
|
||||
I8 Code Points 1st Byte 2nd Byte 3rd 4th 5th 6th 7th 8th 9th-14th
|
||||
|
||||
0x0000..0x009F 00..9F
|
||||
0x00A0..0x00FF * C5..C7 A0..BF
|
||||
U+0100..U+03FF C8..DF A0..BF
|
||||
U+0400..U+3FFF * E1..EF A0..BF A0..BF
|
||||
U+4000..U+7FFF F0 * B0..BF A0..BF A0..BF
|
||||
U+8000..U+D7FF F1 A0..B5 A0..BF A0..BF
|
||||
U+D800..U+DFFF F1 B6..B7 A0..BF A0..BF (surrogates)
|
||||
U+E000..U+FFFF F1 B8..BF A0..BF A0..BF
|
||||
U+10000..U+3FFFF F2..F7 A0..BF A0..BF A0..BF
|
||||
U+40000..U+FFFFF F8 * A8..BF A0..BF A0..BF A0..BF
|
||||
U+100000..U+10FFFF F9 A0..A1 A0..BF A0..BF A0..BF
|
||||
Below are above-Unicode code points
|
||||
U+110000..U+1FFFFF F9 A2..BF A0..BF A0..BF A0..BF
|
||||
U+200000..U+3FFFFF FA..FB A0..BF A0..BF A0..BF A0..BF
|
||||
U+400000..U+1FFFFFF FC * A4..BF A0..BF A0..BF A0..BF A0..BF
|
||||
U+2000000..U+3FFFFFF FD A0..BF A0..BF A0..BF A0..BF A0..BF
|
||||
U+4000000..U+3FFFFFFF FE * A2..BF A0..BF A0..BF A0..BF A0..BF A0..BF
|
||||
U+40000000.. FF A0..BF A0..BF A0..BF A0..BF A0..BF A0..BF * A1..BF A0..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). */
|
||||
|
||||
#define UTF_CONTINUATION_BYTE_INFO_BITS UTF_EBCDIC_CONTINUATION_BYTE_INFO_BITS
|
||||
|
||||
/* ^? is defined to be APC on EBCDIC systems, as specified in Unicode Technical
|
||||
* Report #16. See the definition of toCTRL() for more */
|
||||
#define QUESTION_MARK_CTRL LATIN1_TO_NATIVE(0x9F)
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
285
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/util.h
Normal file
285
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/util.h
Normal file
|
|
@ -0,0 +1,285 @@
|
|||
/* util.h
|
||||
*
|
||||
* Copyright (C) 1991, 1992, 1993, 1999, 2001, 2002, 2003, 2004, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef PERL_UTIL_H_
|
||||
#define PERL_UTIL_H_
|
||||
|
||||
|
||||
#ifdef VMS
|
||||
# define PERL_FILE_IS_ABSOLUTE(f) \
|
||||
(*(f) == '/' \
|
||||
|| (strchr(f,':') \
|
||||
|| ((*(f) == '[' || *(f) == '<') \
|
||||
&& (isWORDCHAR((f)[1]) || memCHRs("$-_]>",(f)[1])))))
|
||||
|
||||
#elif defined(WIN32) || defined(__CYGWIN__)
|
||||
# define PERL_FILE_IS_ABSOLUTE(f) \
|
||||
(*(f) == '/' || *(f) == '\\' /* UNC/rooted path */ \
|
||||
|| ((f)[0] && (f)[1] == ':')) /* drive name */
|
||||
#elif defined(DOSISH)
|
||||
# define PERL_FILE_IS_ABSOLUTE(f) \
|
||||
(*(f) == '/' \
|
||||
|| ((f)[0] && (f)[1] == ':')) /* drive name */
|
||||
#else /* NOT DOSISH */
|
||||
# define PERL_FILE_IS_ABSOLUTE(f) (*(f) == '/')
|
||||
#endif
|
||||
|
||||
/*
|
||||
=for apidoc_section $string
|
||||
|
||||
=for apidoc ibcmp
|
||||
|
||||
This is a synonym for S<C<(! foldEQ())>>
|
||||
|
||||
=for apidoc ibcmp_locale
|
||||
|
||||
This is a synonym for S<C<(! foldEQ_locale())>>
|
||||
|
||||
=for apidoc ibcmp_utf8
|
||||
|
||||
This is a synonym for S<C<(! foldEQ_utf8())>>
|
||||
|
||||
=cut
|
||||
*/
|
||||
#define ibcmp(s1, s2, len) cBOOL(! foldEQ(s1, s2, len))
|
||||
#define ibcmp_locale(s1, s2, len) cBOOL(! foldEQ_locale(s1, s2, len))
|
||||
#define ibcmp_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2) \
|
||||
cBOOL(! foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2))
|
||||
|
||||
/* outside the core, perl.h undefs HAS_QUAD if IV isn't 64-bit
|
||||
We can't swap this to HAS_QUAD, because the logic here affects the type of
|
||||
perl_drand48_t below, and that is visible outside of the core. */
|
||||
#if defined(U64TYPE)
|
||||
/* use a faster implementation when quads are available */
|
||||
# define PERL_DRAND48_QUAD
|
||||
#endif
|
||||
|
||||
#ifdef PERL_DRAND48_QUAD
|
||||
|
||||
/* U64 is only defined under PERL_CORE, but this needs to be visible
|
||||
* elsewhere so the definition of PerlInterpreter is complete.
|
||||
*/
|
||||
typedef U64TYPE perl_drand48_t;
|
||||
|
||||
#else
|
||||
|
||||
struct PERL_DRAND48_T {
|
||||
U16 seed[3];
|
||||
};
|
||||
|
||||
typedef struct PERL_DRAND48_T perl_drand48_t;
|
||||
|
||||
#endif
|
||||
|
||||
#define PL_RANDOM_STATE_TYPE perl_drand48_t
|
||||
|
||||
#define Perl_drand48_init(seed) (Perl_drand48_init_r(&PL_random_state, (seed)))
|
||||
#define Perl_drand48() (Perl_drand48_r(&PL_random_state))
|
||||
|
||||
#ifdef PERL_CORE
|
||||
/* uses a different source of randomness to avoid interfering with the results
|
||||
* of rand() */
|
||||
#define Perl_internal_drand48() (Perl_drand48_r(&PL_internal_random_state))
|
||||
#endif
|
||||
|
||||
#ifdef USE_C_BACKTRACE
|
||||
|
||||
typedef struct {
|
||||
/* The number of frames returned. */
|
||||
UV frame_count;
|
||||
/* The total size of the Perl_c_backtrace, including this header,
|
||||
* the frames, and the name strings. */
|
||||
UV total_bytes;
|
||||
} Perl_c_backtrace_header;
|
||||
|
||||
typedef struct {
|
||||
void* addr; /* the program counter at this frame */
|
||||
|
||||
/* We could use Dl_info (as used by dladdr()) for many of these but
|
||||
* that would be naughty towards non-dlfcn systems (hi there, Win32). */
|
||||
|
||||
void* symbol_addr; /* symbol address (hint: try symbol_addr - addr) */
|
||||
void* object_base_addr; /* base address of the shared object */
|
||||
|
||||
/* The offsets are from the beginning of the whole backtrace,
|
||||
* which makes the backtrace relocatable. */
|
||||
STRLEN object_name_offset; /* pathname of the shared object */
|
||||
STRLEN object_name_size; /* length of the pathname */
|
||||
STRLEN symbol_name_offset; /* symbol name */
|
||||
STRLEN symbol_name_size; /* length of the symbol name */
|
||||
STRLEN source_name_offset; /* source code file name */
|
||||
STRLEN source_name_size; /* length of the source code file name */
|
||||
STRLEN source_line_number; /* source code line number */
|
||||
|
||||
/* OS X notes: atos(1) (more recently, "xcrun atos"), but the C
|
||||
* API atos() uses is unknown (private "Symbolicator" framework,
|
||||
* might require Objective-C even if the API would be known).
|
||||
* Currently we open read pipe to "xcrun atos" and parse the
|
||||
* output - quite disgusting. And that won't work if the
|
||||
* Developer Tools isn't installed. */
|
||||
|
||||
/* FreeBSD notes: execinfo.h exists, but probably would need also
|
||||
* the library -lexecinfo. BFD exists if the pkg devel/binutils
|
||||
* has been installed, but there seems to be a known problem that
|
||||
* the "bfd.h" getting installed refers to "ansidecl.h", which
|
||||
* doesn't get installed. */
|
||||
|
||||
/* Win32 notes: as moral equivalents of backtrace() + dladdr(),
|
||||
* one could possibly first use GetCurrentProcess() +
|
||||
* SymInitialize(), and then CaptureStackBackTrace() +
|
||||
* SymFromAddr(). */
|
||||
|
||||
/* Note that using the compiler optimizer easily leads into much
|
||||
* of this information, like the symbol names (think inlining),
|
||||
* and source code locations getting lost or confused. In many
|
||||
* cases keeping the debug information (-g) is necessary.
|
||||
*
|
||||
* Note that for example with gcc you can do both -O and -g.
|
||||
*
|
||||
* Note, however, that on some platforms (e.g. OSX + clang (cc))
|
||||
* backtrace() + dladdr() works fine without -g. */
|
||||
|
||||
/* For example: the mere presence of <bfd.h> is no guarantee: e.g.
|
||||
* OS X has that, but BFD does not seem to work on the OSX executables.
|
||||
*
|
||||
* Another niceness would be to able to see something about
|
||||
* the function arguments, however gdb/lldb manage to do that. */
|
||||
} Perl_c_backtrace_frame;
|
||||
|
||||
typedef struct {
|
||||
Perl_c_backtrace_header header;
|
||||
Perl_c_backtrace_frame frame_info[1];
|
||||
/* After the header come:
|
||||
* (1) header.frame_count frames
|
||||
* (2) frame_count times the \0-terminated strings (object_name
|
||||
* and so forth). The frames contain the pointers to the starts
|
||||
* of these strings, and the lengths of these strings. */
|
||||
} Perl_c_backtrace;
|
||||
|
||||
#define Perl_free_c_backtrace(bt) Safefree(bt)
|
||||
|
||||
#endif /* USE_C_BACKTRACE */
|
||||
|
||||
/* Use a packed 32 bit constant "key" to start the handshake. The key defines
|
||||
ABI compatibility, and how to process the vararg list.
|
||||
|
||||
Note, some bits may be taken from INTRPSIZE (but then a simple x86 AX register
|
||||
can't be used to read it) and 4 bits from API version len can also be taken,
|
||||
since v00.00.00 is 9 bytes long. XS version length should not have any bits
|
||||
taken since XS_VERSION lengths can get quite long since they are user
|
||||
selectable. These spare bits allow for additional features for the varargs
|
||||
stuff or ABI compat test flags in the future.
|
||||
*/
|
||||
#define HSm_APIVERLEN 0x0000001F /* perl version string won't be more than 31 chars */
|
||||
#define HS_APIVERLEN_MAX HSm_APIVERLEN
|
||||
#define HSm_XSVERLEN 0x0000FF00 /* if 0, not present, dont check, die if over 255*/
|
||||
#define HS_XSVERLEN_MAX 0xFF
|
||||
/* uses var file to set default filename for newXS_deffile to use for CvFILE */
|
||||
#define HSf_SETXSUBFN 0x00000020
|
||||
#define HSf_POPMARK 0x00000040 /* popmark mode or you must supply ax and items */
|
||||
#define HSf_IMP_CXT 0x00000080 /* ABI, threaded, MULTIPLICITY, pTHX_ present */
|
||||
#define HSm_INTRPSIZE 0xFFFF0000 /* ABI, interp struct size */
|
||||
/* A mask of bits in the key which must always match between a XS mod and interp.
|
||||
Also if all ABI bits in a key are true, skip all ABI checks, it is very
|
||||
the unlikely interp size will all 1 bits */
|
||||
/* Maybe HSm_APIVERLEN one day if Perl_xs_apiversion_bootcheck is changed to a memcmp */
|
||||
#define HSm_KEY_MATCH (HSm_INTRPSIZE|HSf_IMP_CXT)
|
||||
#define HSf_NOCHK HSm_KEY_MATCH /* if all ABI bits are 1 in the key, dont chk */
|
||||
|
||||
|
||||
#define HS_GETINTERPSIZE(key) ((key) >> 16)
|
||||
/* if in the future "" and NULL must be separated, XSVERLEN would be 0
|
||||
means arg not present, 1 is empty string/null byte */
|
||||
/* (((key) & 0x0000FF00) >> 8) is less efficient on Visual C */
|
||||
#define HS_GETXSVERLEN(key) ((U8) ((key) >> 8))
|
||||
#define HS_GETAPIVERLEN(key) ((key) & HSm_APIVERLEN)
|
||||
|
||||
/* internal to util.h macro to create a packed handshake key, all args must be constants */
|
||||
/* U32 return = (U16 interpsize, bool cxt, bool setxsubfn, bool popmark,
|
||||
U5 (FIVE!) apiverlen, U8 xsverlen) */
|
||||
#define HS_KEYp(interpsize, cxt, setxsubfn, popmark, apiverlen, xsverlen) \
|
||||
(((interpsize) << 16) \
|
||||
| ((xsverlen) > HS_XSVERLEN_MAX \
|
||||
? (Perl_croak_nocontext("panic: handshake overflow"), HS_XSVERLEN_MAX) \
|
||||
: (xsverlen) << 8) \
|
||||
| (cBOOL(setxsubfn) ? HSf_SETXSUBFN : 0) \
|
||||
| (cBOOL(cxt) ? HSf_IMP_CXT : 0) \
|
||||
| (cBOOL(popmark) ? HSf_POPMARK : 0) \
|
||||
| ((apiverlen) > HS_APIVERLEN_MAX \
|
||||
? (Perl_croak_nocontext("panic: handshake overflow"), HS_APIVERLEN_MAX) \
|
||||
: (apiverlen)))
|
||||
/* overflows above will optimize away unless they will execute */
|
||||
|
||||
/* public macro for core usage to create a packed handshake key but this is
|
||||
not public API. This more friendly version already collected all ABI info */
|
||||
/* U32 return = (bool setxsubfn, bool popmark, "litteral_string_api_ver",
|
||||
"litteral_string_xs_ver") */
|
||||
#ifdef MULTIPLICITY
|
||||
# define HS_KEY(setxsubfn, popmark, apiver, xsver) \
|
||||
HS_KEYp(sizeof(PerlInterpreter), TRUE, setxsubfn, popmark, \
|
||||
sizeof("" apiver "")-1, sizeof("" xsver "")-1)
|
||||
# define HS_CXT aTHX
|
||||
#else
|
||||
# define HS_KEY(setxsubfn, popmark, apiver, xsver) \
|
||||
HS_KEYp(sizeof(struct PerlHandShakeInterpreter), FALSE, setxsubfn, popmark, \
|
||||
sizeof("" apiver "")-1, sizeof("" xsver "")-1)
|
||||
# define HS_CXT cv
|
||||
#endif
|
||||
|
||||
/*
|
||||
=for apidoc instr
|
||||
Same as L<strstr(3)>, which finds and returns a pointer to the first occurrence
|
||||
of the NUL-terminated substring C<little> in the NUL-terminated string C<big>,
|
||||
returning NULL if not found. The terminating NUL bytes are not compared.
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
|
||||
#define instr(haystack, needle) strstr((char *) haystack, (char *) needle)
|
||||
|
||||
#ifdef HAS_MEMMEM
|
||||
# define ninstr(big, bigend, little, lend) \
|
||||
(__ASSERT_(bigend >= big) \
|
||||
__ASSERT_(lend >= little) \
|
||||
(char *) memmem((big), (bigend) - (big), \
|
||||
(little), (lend) - (little)))
|
||||
#else
|
||||
# define ninstr(a,b,c,d) Perl_ninstr(a,b,c,d)
|
||||
#endif
|
||||
|
||||
#ifdef __Lynx__
|
||||
/* Missing proto on LynxOS */
|
||||
int mkstemp(char*);
|
||||
#endif
|
||||
|
||||
#ifdef PERL_CORE
|
||||
# if defined(VMS)
|
||||
/* only useful for calls to our mkostemp() emulation */
|
||||
# define O_VMS_DELETEONCLOSE 0x40000000
|
||||
# ifdef HAS_MKOSTEMP
|
||||
# error 134221 will need a new solution for VMS
|
||||
# endif
|
||||
# else
|
||||
# define O_VMS_DELETEONCLOSE 0
|
||||
# endif
|
||||
#endif
|
||||
#if defined(HAS_MKOSTEMP) && defined(PERL_CORE)
|
||||
# define Perl_my_mkostemp(templte, flags) mkostemp(templte, flags)
|
||||
#endif
|
||||
#if defined(HAS_MKSTEMP) && defined(PERL_CORE)
|
||||
# define Perl_my_mkstemp(templte) mkstemp(templte)
|
||||
#endif
|
||||
|
||||
#endif /* PERL_UTIL_H_ */
|
||||
|
||||
/*
|
||||
* ex: set ts=8 sts=4 sw=4 et:
|
||||
*/
|
||||
23
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uudmap.h
Normal file
23
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uudmap.h
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
/* uudmap.h:
|
||||
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
|
||||
*
|
||||
* These values will populate PL_uumap[], as used by unpack('u')
|
||||
*/
|
||||
{
|
||||
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
|
||||
}
|
||||
114
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/vutil.h
Normal file
114
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/vutil.h
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
/* This file is part of the "version" CPAN distribution. Please avoid
|
||||
editing it in the perl core. */
|
||||
|
||||
/* 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 PERL_VERSION_LT(5,15,4)
|
||||
# define ISA_VERSION_OBJ(v) (sv_isobject(v) && sv_derived_from(v,"version"))
|
||||
#else
|
||||
# define ISA_VERSION_OBJ(v) (sv_isobject(v) && sv_derived_from_pvn(v,"version",7,0))
|
||||
#endif
|
||||
|
||||
#if PERL_VERSION_GE(5,9,0) && !defined(PERL_CORE)
|
||||
|
||||
# define VUTIL_REPLACE_CORE 1
|
||||
|
||||
static const char * Perl_scan_version2(pTHX_ const char *s, SV *rv, bool qv);
|
||||
static SV * Perl_new_version2(pTHX_ SV *ver);
|
||||
static SV * Perl_upg_version2(pTHX_ SV *sv, bool qv);
|
||||
static SV * Perl_vstringify2(pTHX_ SV *vs);
|
||||
static SV * Perl_vverify2(pTHX_ SV *vs);
|
||||
static SV * Perl_vnumify2(pTHX_ SV *vs);
|
||||
static SV * Perl_vnormal2(pTHX_ SV *vs);
|
||||
static SV * Perl_vstringify2(pTHX_ SV *vs);
|
||||
static int Perl_vcmp2(pTHX_ SV *lsv, SV *rsv);
|
||||
static const char * Perl_prescan_version2(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha);
|
||||
|
||||
# define SCAN_VERSION(a,b,c) Perl_scan_version2(aTHX_ a,b,c)
|
||||
# define NEW_VERSION(a) Perl_new_version2(aTHX_ a)
|
||||
# define UPG_VERSION(a,b) Perl_upg_version2(aTHX_ a, b)
|
||||
# define VSTRINGIFY(a) Perl_vstringify2(aTHX_ a)
|
||||
# define VVERIFY(a) Perl_vverify2(aTHX_ a)
|
||||
# define VNUMIFY(a) Perl_vnumify2(aTHX_ a)
|
||||
# define VNORMAL(a) Perl_vnormal2(aTHX_ a)
|
||||
# define VCMP(a,b) Perl_vcmp2(aTHX_ a,b)
|
||||
# define PRESCAN_VERSION(a,b,c,d,e,f,g) Perl_prescan_version2(aTHX_ a,b,c,d,e,f,g)
|
||||
# undef is_LAX_VERSION
|
||||
# define is_LAX_VERSION(a,b) \
|
||||
(a != Perl_prescan_version2(aTHX_ a, FALSE, b, NULL, NULL, NULL, NULL))
|
||||
# undef is_STRICT_VERSION
|
||||
# define is_STRICT_VERSION(a,b) \
|
||||
(a != Perl_prescan_version2(aTHX_ a, TRUE, b, NULL, NULL, NULL, NULL))
|
||||
|
||||
#else
|
||||
|
||||
const char * Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv);
|
||||
SV * Perl_new_version(pTHX_ SV *ver);
|
||||
SV * Perl_upg_version(pTHX_ SV *sv, bool qv);
|
||||
SV * Perl_vverify(pTHX_ SV *vs);
|
||||
SV * Perl_vnumify(pTHX_ SV *vs);
|
||||
SV * Perl_vnormal(pTHX_ SV *vs);
|
||||
SV * Perl_vstringify(pTHX_ SV *vs);
|
||||
int Perl_vcmp(pTHX_ SV *lsv, SV *rsv);
|
||||
const char * Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha);
|
||||
|
||||
# define SCAN_VERSION(a,b,c) Perl_scan_version(aTHX_ a,b,c)
|
||||
# define NEW_VERSION(a) Perl_new_version(aTHX_ a)
|
||||
# define UPG_VERSION(a,b) Perl_upg_version(aTHX_ a, b)
|
||||
# define VSTRINGIFY(a) Perl_vstringify(aTHX_ a)
|
||||
# define VVERIFY(a) Perl_vverify(aTHX_ a)
|
||||
# define VNUMIFY(a) Perl_vnumify(aTHX_ a)
|
||||
# define VNORMAL(a) Perl_vnormal(aTHX_ a)
|
||||
# define VCMP(a,b) Perl_vcmp(aTHX_ a,b)
|
||||
|
||||
# define PRESCAN_VERSION(a,b,c,d,e,f,g) Perl_prescan_version(aTHX_ a,b,c,d,e,f,g)
|
||||
# ifndef is_LAX_VERSION
|
||||
# define is_LAX_VERSION(a,b) \
|
||||
(a != Perl_prescan_version(aTHX_ a, FALSE, b, NULL, NULL, NULL, NULL))
|
||||
# endif
|
||||
# ifndef is_STRICT_VERSION
|
||||
# define is_STRICT_VERSION(a,b) \
|
||||
(a != Perl_prescan_version(aTHX_ a, TRUE, b, NULL, NULL, NULL, NULL))
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
#if PERL_VERSION_LT(5,11,4)
|
||||
# define BADVERSION(a,b,c) \
|
||||
if (b) { \
|
||||
*b = c; \
|
||||
} \
|
||||
return a;
|
||||
|
||||
# define PERL_ARGS_ASSERT_PRESCAN_VERSION \
|
||||
assert(s); assert(sqv); assert(ssaw_decimal);\
|
||||
assert(swidth); assert(salpha);
|
||||
|
||||
# define PERL_ARGS_ASSERT_SCAN_VERSION \
|
||||
assert(s); assert(rv)
|
||||
# define PERL_ARGS_ASSERT_NEW_VERSION \
|
||||
assert(ver)
|
||||
# define PERL_ARGS_ASSERT_UPG_VERSION \
|
||||
assert(ver)
|
||||
# define PERL_ARGS_ASSERT_VVERIFY \
|
||||
assert(vs)
|
||||
# define PERL_ARGS_ASSERT_VNUMIFY \
|
||||
assert(vs)
|
||||
# define PERL_ARGS_ASSERT_VNORMAL \
|
||||
assert(vs)
|
||||
# define PERL_ARGS_ASSERT_VSTRINGIFY \
|
||||
assert(vs)
|
||||
# define PERL_ARGS_ASSERT_VCMP \
|
||||
assert(lhv); assert(rhv)
|
||||
# define PERL_ARGS_ASSERT_CK_WARNER \
|
||||
assert(pat)
|
||||
#endif
|
||||
|
||||
/* ex: set ro: */
|
||||
368
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/warnings.h
Normal file
368
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/warnings.h
Normal file
|
|
@ -0,0 +1,368 @@
|
|||
/* -*- mode: C; 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 Perl_Warn_Off_(x) ((x) / 8)
|
||||
#define Perl_Warn_Bit_(x) (1 << ((x) % 8))
|
||||
#define PerlWarnIsSet_(a, x) ((a)[Perl_Warn_Off_(x)] & Perl_Warn_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 &PL_WARN_ALL /* use warnings 'all' */
|
||||
#define pWARN_NONE &PL_WARN_NONE /* 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.011003 */
|
||||
|
||||
#define WARN_DEPRECATED__GOTO_CONSTRUCT 48
|
||||
#define WARN_DEPRECATED__UNICODE_PROPERTY_NAME 49
|
||||
|
||||
/* Warnings Categories added in Perl 5.013 */
|
||||
|
||||
#define WARN_NON_UNICODE 50
|
||||
#define WARN_NONCHAR 51
|
||||
#define WARN_SURROGATE 52
|
||||
|
||||
/* Warnings Categories added in Perl 5.017 */
|
||||
|
||||
#define WARN_EXPERIMENTAL 53
|
||||
#define WARN_EXPERIMENTAL__REGEX_SETS 54
|
||||
|
||||
/* Warnings Categories added in Perl 5.019 */
|
||||
|
||||
#define WARN_SYSCALLS 55
|
||||
|
||||
/* Warnings Categories added in Perl 5.021 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__RE_STRICT 56
|
||||
#define WARN_EXPERIMENTAL__REFALIASING 57
|
||||
#define WARN_LOCALE 58
|
||||
#define WARN_MISSING 59
|
||||
#define WARN_REDUNDANT 60
|
||||
|
||||
/* Warnings Categories added in Perl 5.025 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__DECLARED_REFS 61
|
||||
|
||||
/* Warnings Categories added in Perl 5.025011 */
|
||||
|
||||
#define WARN_DEPRECATED__DOT_IN_INC 62
|
||||
|
||||
/* Warnings Categories added in Perl 5.027 */
|
||||
|
||||
#define WARN_SHADOW 63
|
||||
|
||||
/* Warnings Categories added in Perl 5.029 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__PRIVATE_USE 64
|
||||
#define WARN_EXPERIMENTAL__UNIPROP_WILDCARDS 65
|
||||
#define WARN_EXPERIMENTAL__VLB 66
|
||||
|
||||
/* Warnings Categories added in Perl 5.033 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__TRY 67
|
||||
|
||||
/* Warnings Categories added in Perl 5.035 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__ARGS_ARRAY_WITH_SIGNATURES 68
|
||||
#define WARN_EXPERIMENTAL__BUILTIN 69
|
||||
#define WARN_EXPERIMENTAL__DEFER 70
|
||||
#define WARN_EXPERIMENTAL__EXTRA_PAIRED_DELIMITERS 71
|
||||
#define WARN_SCALAR 72
|
||||
|
||||
/* Warnings Categories added in Perl 5.035009 */
|
||||
|
||||
#define WARN_DEPRECATED__VERSION_DOWNGRADE 73
|
||||
|
||||
/* Warnings Categories added in Perl 5.03501 */
|
||||
|
||||
#define WARN_DEPRECATED__DELIMITER_WILL_BE_PAIRED 74
|
||||
|
||||
/* Warnings Categories added in Perl 5.037 */
|
||||
|
||||
#define WARN_EXPERIMENTAL__CLASS 75
|
||||
|
||||
/* Warnings Categories added in Perl 5.037009 */
|
||||
|
||||
#define WARN_DEPRECATED__APOSTROPHE_AS_PACKAGE_SEPARATOR 76
|
||||
|
||||
/* Warnings Categories added in Perl 5.03701 */
|
||||
|
||||
#define WARN_DEPRECATED__SMARTMATCH 77
|
||||
|
||||
/* Warnings Categories added in Perl 5.039002 */
|
||||
|
||||
#define WARN_DEPRECATED__MISSING_IMPORT_CALLED_WITH_ARGS 78
|
||||
|
||||
/* Warnings Categories added in Perl 5.039008 */
|
||||
|
||||
#define WARN_DEPRECATED__SUBSEQUENT_USE_VERSION 79
|
||||
#define WARNsize 20
|
||||
#define WARN_ALLstring "\125\125\125\125\125\125\125\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\0\0\0\0\0\0\0"
|
||||
|
||||
#define isLEXWARN_on \
|
||||
cBOOL(PL_curcop && PL_curcop->cop_warnings != pWARN_STD)
|
||||
#define isLEXWARN_off \
|
||||
cBOOL(!PL_curcop || PL_curcop->cop_warnings == pWARN_STD)
|
||||
#define isWARN_ONCE (PL_dowarn & (G_WARN_ON|G_WARN_ONCE))
|
||||
#define hasWARNBIT(c,x) (RCPV_LEN(c) > (2*(x)/8))
|
||||
#define isWARN_on(c,x) (hasWARNBIT(c,x) \
|
||||
? PerlWarnIsSet_((U8 *)(c), 2*(x)) \
|
||||
: 0)
|
||||
#define isWARNf_on(c,x) (hasWARNBIT(c,x) \
|
||||
? PerlWarnIsSet_((U8 *)(c), 2*(x)+1) \
|
||||
: 0)
|
||||
|
||||
#define DUP_WARNINGS(p) Perl_dup_warnings(aTHX_ p)
|
||||
|
||||
#define free_and_set_cop_warnings(cmp,w) STMT_START { \
|
||||
if (!specialWARN((cmp)->cop_warnings)) rcpv_free((cmp)->cop_warnings); \
|
||||
(cmp)->cop_warnings = w; \
|
||||
} STMT_END
|
||||
|
||||
/*
|
||||
|
||||
=head1 Warning and Dieing
|
||||
|
||||
In all these calls, the C<U32 wI<n>> parameters are warning category
|
||||
constants. You can see the ones currently available in
|
||||
L<warnings/Category Hierarchy>, just capitalize all letters in the names
|
||||
and prefix them by C<WARN_>. So, for example, the category C<void> used in a
|
||||
perl program becomes C<WARN_VOID> when used in XS code and passed to one of
|
||||
the calls below.
|
||||
|
||||
=for apidoc Am|bool|ckWARN|U32 w
|
||||
=for apidoc_item ||ckWARN2|U32 w1|U32 w2
|
||||
=for apidoc_item ||ckWARN3|U32 w1|U32 w2|U32 w3
|
||||
=for apidoc_item ||ckWARN4|U32 w1|U32 w2|U32 w3|U32 w4
|
||||
These return a boolean as to whether or not warnings are enabled for any of
|
||||
the warning category(ies) parameters: C<w>, C<w1>, ....
|
||||
|
||||
Should any of the categories by default be enabled even if not within the
|
||||
scope of S<C<use warnings>>, instead use the C<L</ckWARN_d>> macros.
|
||||
|
||||
The categories must be completely independent, one may not be subclassed from
|
||||
the other.
|
||||
|
||||
=for apidoc Am|bool|ckWARN_d|U32 w
|
||||
=for apidoc_item ||ckWARN2_d|U32 w1|U32 w2
|
||||
=for apidoc_item ||ckWARN3_d|U32 w1|U32 w2|U32 w3
|
||||
=for apidoc_item ||ckWARN4_d|U32 w1|U32 w2|U32 w3|U32 w4
|
||||
|
||||
Like C<L</ckWARN>>, but for use if and only if the warning category(ies) is by
|
||||
default enabled even if not within the scope of S<C<use warnings>>.
|
||||
|
||||
=for apidoc Am|U32|packWARN|U32 w1
|
||||
=for apidoc_item ||packWARN2|U32 w1|U32 w2
|
||||
=for apidoc_item ||packWARN3|U32 w1|U32 w2|U32 w3
|
||||
=for apidoc_item ||packWARN4|U32 w1|U32 w2|U32 w3|U32 w4
|
||||
|
||||
These macros are used to pack warning categories into a single U32 to pass to
|
||||
macros and functions that take a warning category parameter. The number of
|
||||
categories to pack is given by the name, with a corresponding number of
|
||||
category parameters passed.
|
||||
|
||||
=cut
|
||||
|
||||
*/
|
||||
|
||||
#define ckWARN(w) Perl_ckwarn(aTHX_ packWARN(w))
|
||||
|
||||
/* The w1, w2 ... should be independent warnings categories; one shouldn't be
|
||||
* a subcategory of any other */
|
||||
|
||||
#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 )
|
||||
|
||||
/* The a, b, ... should be independent warnings categories; one shouldn't be
|
||||
* a subcategory of any other */
|
||||
|
||||
#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) ((U8) (x) )
|
||||
#define unpackWARN2(x) ((U8) ((x) >> 8))
|
||||
#define unpackWARN3(x) ((U8) ((x) >> 16))
|
||||
#define unpackWARN4(x) ((U8) ((x) >> 24))
|
||||
|
||||
#define ckDEAD(x) \
|
||||
(PL_curcop && \
|
||||
!specialWARN(PL_curcop->cop_warnings) && \
|
||||
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN1(x)) || \
|
||||
(unpackWARN2(x) && \
|
||||
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN2(x)) || \
|
||||
(unpackWARN3(x) && \
|
||||
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN3(x)) || \
|
||||
(unpackWARN4(x) && \
|
||||
isWARNf_on(PL_curcop->cop_warnings, unpackWARN4(x)))))))))
|
||||
|
||||
|
||||
|
||||
/*
|
||||
=for apidoc Amnh||WARN_ALL
|
||||
=for apidoc Amnh||WARN_CLOSURE
|
||||
=for apidoc Amnh||WARN_DEPRECATED
|
||||
=for apidoc Amnh||WARN_EXITING
|
||||
=for apidoc Amnh||WARN_GLOB
|
||||
=for apidoc Amnh||WARN_IO
|
||||
=for apidoc Amnh||WARN_CLOSED
|
||||
=for apidoc Amnh||WARN_EXEC
|
||||
=for apidoc Amnh||WARN_LAYER
|
||||
=for apidoc Amnh||WARN_NEWLINE
|
||||
=for apidoc Amnh||WARN_PIPE
|
||||
=for apidoc Amnh||WARN_UNOPENED
|
||||
=for apidoc Amnh||WARN_MISC
|
||||
=for apidoc Amnh||WARN_NUMERIC
|
||||
=for apidoc Amnh||WARN_ONCE
|
||||
=for apidoc Amnh||WARN_OVERFLOW
|
||||
=for apidoc Amnh||WARN_PACK
|
||||
=for apidoc Amnh||WARN_PORTABLE
|
||||
=for apidoc Amnh||WARN_RECURSION
|
||||
=for apidoc Amnh||WARN_REDEFINE
|
||||
=for apidoc Amnh||WARN_REGEXP
|
||||
=for apidoc Amnh||WARN_SEVERE
|
||||
=for apidoc Amnh||WARN_DEBUGGING
|
||||
=for apidoc Amnh||WARN_INPLACE
|
||||
=for apidoc Amnh||WARN_INTERNAL
|
||||
=for apidoc Amnh||WARN_MALLOC
|
||||
=for apidoc Amnh||WARN_SIGNAL
|
||||
=for apidoc Amnh||WARN_SUBSTR
|
||||
=for apidoc Amnh||WARN_SYNTAX
|
||||
=for apidoc Amnh||WARN_AMBIGUOUS
|
||||
=for apidoc Amnh||WARN_BAREWORD
|
||||
=for apidoc Amnh||WARN_DIGIT
|
||||
=for apidoc Amnh||WARN_PARENTHESIS
|
||||
=for apidoc Amnh||WARN_PRECEDENCE
|
||||
=for apidoc Amnh||WARN_PRINTF
|
||||
=for apidoc Amnh||WARN_PROTOTYPE
|
||||
=for apidoc Amnh||WARN_QW
|
||||
=for apidoc Amnh||WARN_RESERVED
|
||||
=for apidoc Amnh||WARN_SEMICOLON
|
||||
=for apidoc Amnh||WARN_TAINT
|
||||
=for apidoc Amnh||WARN_THREADS
|
||||
=for apidoc Amnh||WARN_UNINITIALIZED
|
||||
=for apidoc Amnh||WARN_UNPACK
|
||||
=for apidoc Amnh||WARN_UNTIE
|
||||
=for apidoc Amnh||WARN_UTF8
|
||||
=for apidoc Amnh||WARN_VOID
|
||||
=for apidoc Amnh||WARN_IMPRECISION
|
||||
=for apidoc Amnh||WARN_ILLEGALPROTO
|
||||
=for apidoc Amnh||WARN_DEPRECATED__GOTO_CONSTRUCT
|
||||
=for apidoc Amnh||WARN_DEPRECATED__UNICODE_PROPERTY_NAME
|
||||
=for apidoc Amnh||WARN_NON_UNICODE
|
||||
=for apidoc Amnh||WARN_NONCHAR
|
||||
=for apidoc Amnh||WARN_SURROGATE
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__REGEX_SETS
|
||||
=for apidoc Amnh||WARN_SYSCALLS
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__RE_STRICT
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__REFALIASING
|
||||
=for apidoc Amnh||WARN_LOCALE
|
||||
=for apidoc Amnh||WARN_MISSING
|
||||
=for apidoc Amnh||WARN_REDUNDANT
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__DECLARED_REFS
|
||||
=for apidoc Amnh||WARN_DEPRECATED__DOT_IN_INC
|
||||
=for apidoc Amnh||WARN_SHADOW
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__PRIVATE_USE
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__UNIPROP_WILDCARDS
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__VLB
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__TRY
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__ARGS_ARRAY_WITH_SIGNATURES
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__BUILTIN
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__DEFER
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__EXTRA_PAIRED_DELIMITERS
|
||||
=for apidoc Amnh||WARN_SCALAR
|
||||
=for apidoc Amnh||WARN_DEPRECATED__VERSION_DOWNGRADE
|
||||
=for apidoc Amnh||WARN_DEPRECATED__DELIMITER_WILL_BE_PAIRED
|
||||
=for apidoc Amnh||WARN_EXPERIMENTAL__CLASS
|
||||
=for apidoc Amnh||WARN_DEPRECATED__APOSTROPHE_AS_PACKAGE_SEPARATOR
|
||||
=for apidoc Amnh||WARN_DEPRECATED__SMARTMATCH
|
||||
=for apidoc Amnh||WARN_DEPRECATED__MISSING_IMPORT_CALLED_WITH_ARGS
|
||||
=for apidoc Amnh||WARN_DEPRECATED__SUBSEQUENT_USE_VERSION
|
||||
|
||||
=cut
|
||||
*/
|
||||
|
||||
/* end of file warnings.h */
|
||||
|
||||
/* ex: set ro ft=c: */
|
||||
292
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/zaphod32_hash.h
Normal file
292
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/zaphod32_hash.h
Normal file
|
|
@ -0,0 +1,292 @@
|
|||
#ifndef DEBUG_ZAPHOD32_HASH
|
||||
#define DEBUG_ZAPHOD32_HASH 0
|
||||
|
||||
#if DEBUG_ZAPHOD32_HASH == 1
|
||||
#include <stdio.h>
|
||||
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5) printf(pat, v0, v1, v2, v3, v4, v5)
|
||||
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4) printf(pat, v0, v1, v2, v3, v4)
|
||||
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3) printf(pat, v0, v1, v2, v3)
|
||||
#define ZAPHOD32_WARN3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
|
||||
#define ZAPHOD32_WARN2(pat,v0,v1) printf(pat, v0, v1)
|
||||
#define NOTE3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
|
||||
#elif DEBUG_ZAPHOD32_HASH == 2
|
||||
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5)
|
||||
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4)
|
||||
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3)
|
||||
#define ZAPHOD32_WARN3(pat,v0,v1,v2)
|
||||
#define ZAPHOD32_WARN2(pat,v0,v1)
|
||||
#define NOTE3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
|
||||
#else
|
||||
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5)
|
||||
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4)
|
||||
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3)
|
||||
#define ZAPHOD32_WARN3(pat,v0,v1,v2)
|
||||
#define NOTE3(pat,v0,v1,v2)
|
||||
#define ZAPHOD32_WARN2(pat,v0,v1)
|
||||
#endif
|
||||
|
||||
/* Find best way to ROTL32/ROTL64 */
|
||||
#ifndef ROTL32
|
||||
#if defined(_MSC_VER)
|
||||
#include <stdlib.h> /* Microsoft put _rotl declaration in here */
|
||||
#define ROTL32(x,r) _rotl(x,r)
|
||||
#define ROTR32(x,r) _rotr(x,r)
|
||||
#else
|
||||
/* gcc recognises this code and generates a rotate instruction for CPUs with one */
|
||||
#define ROTL32(x,r) (((U32)(x) << (r)) | ((U32)(x) >> (32 - (r))))
|
||||
#define ROTR32(x,r) (((U32)(x) << (32 - (r))) | ((U32)(x) >> (r)))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef PERL_SEEN_HV_FUNC_H_
|
||||
#if !defined(U64)
|
||||
#include <stdint.h>
|
||||
#define U64 uint64_t
|
||||
#endif
|
||||
|
||||
#if !defined(U32)
|
||||
#define U32 uint32_t
|
||||
#endif
|
||||
|
||||
#if !defined(U8)
|
||||
#define U8 unsigned char
|
||||
#endif
|
||||
|
||||
#if !defined(U16)
|
||||
#define U16 uint16_t
|
||||
#endif
|
||||
|
||||
#ifndef STRLEN
|
||||
#define STRLEN int
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ZAPHOD32_STATIC_INLINE
|
||||
#ifdef PERL_STATIC_INLINE
|
||||
#define ZAPHOD32_STATIC_INLINE PERL_STATIC_INLINE
|
||||
#else
|
||||
#define ZAPHOD32_STATIC_INLINE static inline
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef STMT_START
|
||||
#define STMT_START do
|
||||
#define STMT_END while(0)
|
||||
#endif
|
||||
|
||||
/* This is two marsaglia xor-shift permutes, with a prime-multiple
|
||||
* sandwiched inside. The end result of doing this twice with different
|
||||
* primes is a completely avalanched v. */
|
||||
#define ZAPHOD32_SCRAMBLE32(v,prime) STMT_START { \
|
||||
v ^= (v>>9); \
|
||||
v ^= (v<<21); \
|
||||
v ^= (v>>16); \
|
||||
v *= prime; \
|
||||
v ^= (v>>17); \
|
||||
v ^= (v<<15); \
|
||||
v ^= (v>>23); \
|
||||
} STMT_END
|
||||
|
||||
#define ZAPHOD32_FINALIZE(v0,v1,v2) STMT_START { \
|
||||
ZAPHOD32_WARN3("v0=%08x v1=%08x v2=%08x - ZAPHOD32 FINALIZE\n", \
|
||||
(unsigned int)v0, (unsigned int)v1, (unsigned int)v2); \
|
||||
v2 += v0; \
|
||||
v1 -= v2; \
|
||||
v1 = ROTL32(v1, 6); \
|
||||
v2 ^= v1; \
|
||||
v2 = ROTL32(v2, 28); \
|
||||
v1 ^= v2; \
|
||||
v0 += v1; \
|
||||
v1 = ROTL32(v1, 24); \
|
||||
v2 += v1; \
|
||||
v2 = ROTL32(v2, 18) + v1; \
|
||||
v0 ^= v2; \
|
||||
v0 = ROTL32(v0, 20); \
|
||||
v2 += v0; \
|
||||
v1 ^= v2; \
|
||||
v0 += v1; \
|
||||
v0 = ROTL32(v0, 5); \
|
||||
v2 += v0; \
|
||||
v2 = ROTL32(v2, 22); \
|
||||
v0 -= v1; \
|
||||
v1 -= v2; \
|
||||
v1 = ROTL32(v1, 17); \
|
||||
} STMT_END
|
||||
|
||||
#define ZAPHOD32_MIX(v0,v1,v2,text) STMT_START { \
|
||||
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x - ZAPHOD32 %s MIX\n", \
|
||||
(unsigned int)v0,(unsigned int)v1,(unsigned int)v2, text ); \
|
||||
v0 = ROTL32(v0,16) - v2; \
|
||||
v1 = ROTR32(v1,13) ^ v2; \
|
||||
v2 = ROTL32(v2,17) + v1; \
|
||||
v0 = ROTR32(v0, 2) + v1; \
|
||||
v1 = ROTR32(v1,17) - v0; \
|
||||
v2 = ROTR32(v2, 7) ^ v0; \
|
||||
} STMT_END
|
||||
|
||||
|
||||
ZAPHOD32_STATIC_INLINE
|
||||
void zaphod32_seed_state (
|
||||
const U8 *seed_ch,
|
||||
U8 *state_ch
|
||||
) {
|
||||
const U32 *seed= (const U32 *)seed_ch;
|
||||
U32 *state= (U32 *)state_ch;
|
||||
|
||||
/* hex expansion of PI, skipping first two digits. PI= 3.2[43f6...]
|
||||
*
|
||||
* PI value in hex from here:
|
||||
*
|
||||
* http://turner.faculty.swau.edu/mathematics/materialslibrary/pi/pibases.html
|
||||
*
|
||||
* Ensure that the three state vectors are nonzero regardless of
|
||||
* the seed. The idea of these two steps is to ensure that the 0
|
||||
* state comes from a seed utterly unlike that of the value we
|
||||
* replace it with.
|
||||
*/
|
||||
state[0]= seed[0] ^ 0x43f6a888;
|
||||
state[1]= seed[1] ^ 0x5a308d31;
|
||||
state[2]= seed[2] ^ 0x3198a2e0;
|
||||
if (!state[0]) state[0] = 1;
|
||||
if (!state[1]) state[1] = 2;
|
||||
if (!state[2]) state[2] = 4;
|
||||
/* these are pseudo-randomly selected primes between 2**31 and 2**32
|
||||
* (I generated a big list and then randomly chose some from the list) */
|
||||
ZAPHOD32_SCRAMBLE32(state[0],0x9fade23b);
|
||||
ZAPHOD32_SCRAMBLE32(state[1],0xaa6f908d);
|
||||
ZAPHOD32_SCRAMBLE32(state[2],0xcdf6b72d);
|
||||
|
||||
/* now that we have scrambled we do some mixing to avalanche the
|
||||
* state bits to gether */
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 1/4");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 2/4");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 3/4");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 4/4");
|
||||
|
||||
/* and then scramble them again with different primes */
|
||||
ZAPHOD32_SCRAMBLE32(state[0],0xc95d22a9);
|
||||
ZAPHOD32_SCRAMBLE32(state[1],0x8497242b);
|
||||
ZAPHOD32_SCRAMBLE32(state[2],0x9c5cc4e9);
|
||||
|
||||
/* and a thorough final mix */
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 1/5");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 2/5");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 3/5");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 4/5");
|
||||
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 5/5");
|
||||
|
||||
}
|
||||
|
||||
ZAPHOD32_STATIC_INLINE
|
||||
U32 zaphod32_hash_with_state(
|
||||
const U8 *state_ch,
|
||||
const U8 *key,
|
||||
const STRLEN key_len
|
||||
) {
|
||||
const U32 *state= (const U32 *)state_ch;
|
||||
const U8 *end;
|
||||
STRLEN len = key_len;
|
||||
U32 v0= state[0];
|
||||
U32 v1= state[1];
|
||||
U32 v2= state[2] ^ (0xC41A7AB1 * ((U32)key_len + 1));
|
||||
|
||||
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x ln=%08x HASH START\n",
|
||||
(unsigned int)state[0], (unsigned int)state[1],
|
||||
(unsigned int)state[2], (unsigned int)key_len);
|
||||
{
|
||||
switch (len) {
|
||||
default: goto zaphod32_read8;
|
||||
case 12: v2 += (U32)key[11] << 24; /* FALLTHROUGH */
|
||||
case 11: v2 += (U32)key[10] << 16; /* FALLTHROUGH */
|
||||
case 10: v2 += (U32)U8TO16_LE(key+8);
|
||||
v1 -= U8TO32_LE(key+4);
|
||||
v0 += U8TO32_LE(key+0);
|
||||
goto zaphod32_finalize;
|
||||
case 9: v2 += (U32)key[8]; /* FALLTHROUGH */
|
||||
case 8: v1 -= U8TO32_LE(key+4);
|
||||
v0 += U8TO32_LE(key+0);
|
||||
goto zaphod32_finalize;
|
||||
case 7: v2 += (U32)key[6]; /* FALLTHROUGH */
|
||||
case 6: v0 += (U32)U8TO16_LE(key+4);
|
||||
v1 -= U8TO32_LE(key+0);
|
||||
goto zaphod32_finalize;
|
||||
case 5: v0 += (U32)key[4]; /* FALLTHROUGH */
|
||||
case 4: v1 -= U8TO32_LE(key+0);
|
||||
goto zaphod32_finalize;
|
||||
case 3: v2 += (U32)key[2]; /* FALLTHROUGH */
|
||||
case 2: v0 += (U32)U8TO16_LE(key);
|
||||
break;
|
||||
case 1: v0 += (U32)key[0];
|
||||
break;
|
||||
case 0: v2 ^= 0xFF;
|
||||
break;
|
||||
|
||||
}
|
||||
v0 -= v2;
|
||||
v2 = ROTL32(v2, 8) ^ v0;
|
||||
v0 = ROTR32(v0,16) + v2;
|
||||
v2 += v0;
|
||||
v0 += v0 >> 9;
|
||||
v0 += v2;
|
||||
v2 ^= v0;
|
||||
v2 += v2 << 4;
|
||||
v0 -= v2;
|
||||
v2 = ROTR32(v2, 8) ^ v0;
|
||||
v0 = ROTL32(v0,16) ^ v2;
|
||||
v2 = ROTL32(v2,10) + v0;
|
||||
v0 = ROTR32(v0,30) + v2;
|
||||
v2 = ROTR32(v2,12);
|
||||
return v0 ^ v2;
|
||||
}
|
||||
|
||||
/* if (len >= 8) */ /* this block is only reached by a goto above, so this condition
|
||||
is commented out, but if the above block is removed it would
|
||||
be necessary to use this. */
|
||||
{
|
||||
zaphod32_read8:
|
||||
len = key_len & 0x7;
|
||||
end = key + key_len - len;
|
||||
do {
|
||||
v1 -= U8TO32_LE(key+0);
|
||||
v0 += U8TO32_LE(key+4);
|
||||
ZAPHOD32_MIX(v0,v1,v2,"MIX 2-WORDS A");
|
||||
key += 8;
|
||||
} while ( key < end );
|
||||
}
|
||||
|
||||
if ( len >= 4 ) {
|
||||
v1 -= U8TO32_LE(key);
|
||||
key += 4;
|
||||
}
|
||||
|
||||
v0 += (U32)(key_len) << 24;
|
||||
switch (len & 0x3) {
|
||||
case 3: v2 += (U32)key[2]; /* FALLTHROUGH */
|
||||
case 2: v0 += (U32)U8TO16_LE(key);
|
||||
break;
|
||||
case 1: v0 += (U32)key[0];
|
||||
break;
|
||||
case 0: v2 ^= 0xFF;
|
||||
break;
|
||||
}
|
||||
zaphod32_finalize:
|
||||
ZAPHOD32_FINALIZE(v0,v1,v2);
|
||||
|
||||
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x hh=%08x - FINAL\n\n",
|
||||
(unsigned int)v0, (unsigned int)v1, (unsigned int)v2,
|
||||
(unsigned int)v0 ^ v1 ^ v2);
|
||||
|
||||
return v0 ^ v1 ^ v2;
|
||||
}
|
||||
|
||||
ZAPHOD32_STATIC_INLINE U32 zaphod32_hash(
|
||||
const U8 *seed_ch,
|
||||
const U8 *key,
|
||||
const STRLEN key_len
|
||||
) {
|
||||
U32 state[3];
|
||||
zaphod32_seed_state(seed_ch,(U8*)state);
|
||||
return zaphod32_hash_with_state((U8*)state,key,key_len);
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue