/* <--- here ends the logic shared by perl.h and makedef.pl */
/*
+=for apidoc_section Compiler directives
=for apidoc AmnUu|void|EXTERN_C
When not compiling using C++, expands to nothing.
Otherwise is used in a declaration of a function to indicate the function
* implementation of multiplicity using C++ objects. They have been left
* here solely for the sake of XS code which has incorrectly
* cargo-culted them.
+ *
+ * The only one Devel::PPPort handles is this; list it as deprecated
+
+=for apidoc_section Concurrency
+=for apidoc AmD|void|CPERLscope|void x
+Now a no-op.
+
+=cut
*/
#define CPERLscope(x) x
#define CPERLarg void
* marking unused variables (they need e.g. a #pragma) and therefore
* cpp macros like PERL_UNUSED_DECL cannot work for this purpose, even
* if it were PERL_UNUSED_DECL(x), which it cannot be (see above).
- *
+
+=for apidoc_section Compiler directives
+=for apidoc AmnU||PERL_UNUSED_DECL
+Tells the compiler that the parameter in the function prototype just before it
+is not necessarily expected to be used in the function. Not that many
+compilers understand this, so this should only be used in cases where
+C<L</PERL_UNUSED_ARG>> can't conveniently be used.
+
+Example usage:
+
+=over
+
+ Signal_t
+ Perl_perly_sighandler(int sig, Siginfo_t *sip PERL_UNUSED_DECL,
+ void *uap PERL_UNUSED_DECL, bool safe)
+
+=back
+
+=cut
*/
#ifndef PERL_UNUSED_DECL
* but we cannot quite get rid of, such as "ax" in PPCODE+noargs xsubs,
* or variables/arguments that are used only in certain configurations.
-=head1 Miscellaneous Functions
-
-=for apidoc Am||PERL_UNUSED_ARG|void x
+=for apidoc Ams||PERL_UNUSED_ARG|void x
This is used to suppress compiler warnings that a parameter to a function is
not used. This situation can arise, for example, when a parameter is needed
under some configuration conditions, but not others, so that C preprocessor
conditional compilation causes it be used just some times.
-=for apidoc Amn||PERL_UNUSED_CONTEXT
+=for apidoc Amns||PERL_UNUSED_CONTEXT
This is used to suppress compiler warnings that the thread context parameter to
a function is not used. This situation can arise, for example, when a
C preprocessor conditional compilation causes it be used just some times.
-=for apidoc Am||PERL_UNUSED_VAR|void x
+=for apidoc Ams||PERL_UNUSED_VAR|void x
This is used to suppress compiler warnings that the variable I<x> is not used.
This situation can arise, for example, when a C preprocessor conditional
compilation causes it be used just some times.
#define MSVC_DIAG_IGNORE_STMT(x) MSVC_DIAG_IGNORE(x) NOOP
#define MSVC_DIAG_RESTORE_STMT MSVC_DIAG_RESTORE NOOP
+/*
+=for apidoc Amns||NOOP
+Do nothing; typically used as a placeholder to replace something that used to
+do something.
+
+=for apidoc Amns||dNOOP
+Declare nothing; typically used as a placeholder to replace something that used
+to declare something. Works on compilers that require declarations before any
+code.
+
+=cut
+*/
#define NOOP /*EMPTY*/(void)0
#define dNOOP struct Perl___notused_struct
# define pTHX_12 12
#endif
+/*
+=for apidoc_section Concurrency
+=for apidoc AmnU||dVAR
+This is now a synonym for dNOOP: declare nothing
+
+=cut
+*/
+
#ifndef PERL_CORE
-/* Backwards compatibility macro for XS code. It used to be part of
- * the PERL_GLOBAL_STRUCT(_PRIVATE) feature, which no longer exists */
+ /* Backwards compatibility macro for XS code. It used to be part of the
+ * PERL_GLOBAL_STRUCT(_PRIVATE) feature, which no longer exists */
# define dVAR dNOOP
-#endif
-/* these are only defined for compatibility; should not be used internally */
-#if !defined(pTHXo) && !defined(PERL_CORE)
-# define pTHXo pTHX
-# define pTHXo_ pTHX_
-# define aTHXo aTHX
-# define aTHXo_ aTHX_
-# define dTHXo dTHX
-# define dTHXoa(x) dTHXa(x)
+ /* these are only defined for compatibility; should not be used internally.
+ * */
+# ifndef pTHXo
+# define pTHXo pTHX
+# define pTHXo_ pTHX_
+# define aTHXo aTHX
+# define aTHXo_ aTHX_
+# define dTHXo dTHX
+# define dTHXoa(x) dTHXa(x)
+# endif
#endif
#ifndef pTHXx
#endif
/*
-=head1 Miscellaneous Functions
-
+=for apidoc_section Compiler directives
=for apidoc AmnUu|void|STMT_START
+=for apidoc_item ||STMT_END
- STMT_START { statements; } STMT_END;
-
-can be used as a single statement, as in
-
- if (x) STMT_START { ... } STMT_END; else ...
+This allows a series of statements in a macro to be used as a single statement,
+as in
-These are often used in macro definitions. Note that you can't return a value
-out of them.
+ if (x) STMT_START { ... } STMT_END else ...
-=for apidoc AmnUhu|void|STMT_END
+Note that you can't return a value out of them, which limits their utility.
+But see C<L</PERL_USE_GCC_BRACE_GROUPS>>.
=for apidoc AmnuU|bool|PERL_USE_GCC_BRACE_GROUPS
This C pre-processor value, if defined, indicates that it is permissible to use
-the GCC brace groups extension. This extension is of the form C<({
-I<STATEMENTS> })>, and turns the block consisting of I<STATEMENTS> into an
-expression with a value, unlike plain C language blocks. This can present
-optimization possibilities, but there always needs to be an alternative in case
-this ability doesn't exist or has otherwise been forbidden.
+the GCC brace groups extension. This extension, of the form
+
+ ({ statement ... })
+
+turns the block consisting of I<statements ...> into an expression with a
+value, unlike plain C language blocks. This can present optimization
+possibilities, B<BUT> you generally need to specify an alternative in case this
+ability doesn't exist or has otherwise been forbidden.
+
+Example usage:
+
+=over
+
+ #ifdef PERL_USE_GCC_BRACE_GROUPS
+ ...
+ #else
+ ...
+ #endif
+
+=back
=cut
EXTERN_C int usleep(unsigned int);
#endif
-/* macros for correct constant construction. These are in C99 <stdint.h>
+/* Macros for correct constant construction. These are in C99 <stdint.h>
* (so they will not be available in strict C89 mode), but they are nice, so
- * let's define them if necessary. */
+ * let's define them if necessary.
+=for apidoc_section Integer configuration values
+=for apidoc Am|I16|INT16_C|number
+=for apidoc_item |I32|INT32_C|number
+=for apidoc_item |I64|INT64_C|number
+
+Returns a token the C compiler recognizes for the constant C<number> of the
+corresponding integer type on the machine.
+
+If the machine does not have a 64-bit type, C<INT64_C> is undefined.
+Use C<L</INTMAX_C>> to get the largest type available on the platform.
+
+=for apidoc Am|U16|UINT16_C|number
+=for apidoc_item |U32|UINT32_C|number
+=for apidoc_item |U64|UINT64_C|number
+
+Returns a token the C compiler recognizes for the constant C<number> of the
+corresponding unsigned integer type on the machine.
+
+If the machine does not have a 64-bit type, C<UINT64_C> is undefined.
+Use C<L</UINTMAX_C>> to get the largest type available on the platform.
+
+
+=cut
+*/
#ifndef UINT16_C
# if INTSIZE >= 2
# define UINT16_C(x) ((U16_TYPE)x##U)
# endif
/*
+=for apidoc_section Integer configuration values
=for apidoc Am||INTMAX_C|number
Returns a token the C compiler recognizes for the constant C<number> of the
widest integer type on the machine. For example, if the machine has C<long
-1LL
+See also, for example, C<L</INT32_C>>.
+
+Use L</IV> to declare variables of the maximum usable size on this platform.
+
=for apidoc Am||UINTMAX_C|number
Returns a token the C compiler recognizes for the constant C<number> of the
widest unsigned integer type on the machine. For example, if the machine has
1UL
+See also, for example, C<L</UINT32_C>>.
+
+Use L</UV> to declare variables of the maximum usable size on this platform.
+
=cut
*/
#endif
/*
-=head1 Errno
+=for apidoc_section Errno
=for apidoc m|void|SETERRNO|int errcode|int vmserrcode
#endif
/*
-=head1 Warning and Dieing
+=for apidoc_section Warning and Dieing
=for apidoc Amn|SV *|ERRSV
#endif
/*
+=for apidoc_section SV Handling
=for apidoc Amn|SV *|DEFSV
Returns the SV associated with C<$_>
* longer need that. XS modules can (and do) use this name, so it must remain
* a part of the API that's visible to modules.
-=head1 Miscellaneous Functions
-
+=for apidoc_section String Handling
=for apidoc ATmD|int|my_sprintf|NN char *buffer|NN const char *pat|...
Do NOT use this due to the possibility of overflowing C<buffer>. Instead use
#endif
/*
-=head1 Numeric functions
-
-=for apidoc AmnUh||PERL_INT_MIN
-=for apidoc AmnUh||PERL_LONG_MAX
-=for apidoc AmnUh||PERL_LONG_MIN
-=for apidoc AmnUh||PERL_QUAD_MAX
-=for apidoc AmnUh||PERL_SHORT_MAX
-=for apidoc AmnUh||PERL_SHORT_MIN
-=for apidoc AmnUh||PERL_UCHAR_MAX
-=for apidoc AmnUh||PERL_UCHAR_MIN
-=for apidoc AmnUh||PERL_UINT_MAX
-=for apidoc AmnUh||PERL_UINT_MIN
-=for apidoc AmnUh||PERL_ULONG_MAX
-=for apidoc AmnUh||PERL_ULONG_MIN
-=for apidoc AmnUh||PERL_UQUAD_MAX
-=for apidoc AmnUh||PERL_UQUAD_MIN
-=for apidoc AmnUh||PERL_USHORT_MAX
-=for apidoc AmnUh||PERL_USHORT_MIN
-=for apidoc AmnUh||PERL_QUAD_MIN
+=for apidoc_section Integer configuration values
+
=for apidoc AmnU||PERL_INT_MAX
-This and
-C<PERL_INT_MIN>,
-C<PERL_LONG_MAX>,
-C<PERL_LONG_MIN>,
-C<PERL_QUAD_MAX>,
-C<PERL_SHORT_MAX>,
-C<PERL_SHORT_MIN>,
-C<PERL_UCHAR_MAX>,
-C<PERL_UCHAR_MIN>,
-C<PERL_UINT_MAX>,
-C<PERL_UINT_MIN>,
-C<PERL_ULONG_MAX>,
-C<PERL_ULONG_MIN>,
-C<PERL_UQUAD_MAX>,
-C<PERL_UQUAD_MIN>,
-C<PERL_USHORT_MAX>,
-C<PERL_USHORT_MIN>,
-C<PERL_QUAD_MIN>
-give the largest and smallest number representable in the current
+=for apidoc_item ||PERL_INT_MIN
+=for apidoc_item ||PERL_LONG_MAX
+=for apidoc_item ||PERL_LONG_MIN
+=for apidoc_item ||PERL_SHORT_MAX
+=for apidoc_item ||PERL_SHORT_MIN
+=for apidoc_item ||PERL_UCHAR_MAX
+=for apidoc_item ||PERL_UCHAR_MIN
+=for apidoc_item ||PERL_UINT_MAX
+=for apidoc_item ||PERL_UINT_MIN
+=for apidoc_item ||PERL_ULONG_MAX
+=for apidoc_item ||PERL_ULONG_MIN
+=for apidoc_item ||PERL_USHORT_MAX
+=for apidoc_item ||PERL_USHORT_MIN
+=for apidoc_item ||PERL_QUAD_MAX
+=for apidoc_item ||PERL_QUAD_MIN
+=for apidoc_item ||PERL_UQUAD_MAX
+=for apidoc_item ||PERL_UQUAD_MIN
+
+These give the largest and smallest number representable in the current
platform in variables of the corresponding types.
For signed types, the smallest representable number is the most negative
#endif
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Embedding and Interpreter Cloning
=for apidoc Am|void|PERL_SYS_INIT|int *argc|char*** argv
Provides system-specific tune up of the C runtime environment necessary to
#define HEKfARG(p) ((void*)(p))
-/*
-=for apidoc Amnh||UTF8f
-=for apidoc Amh||UTF8fARG|bool is_utf8|Size_t byte_len|char *str
-
-=cut
+/* Documented in perlguts
+ *
* %4p is a custom format
*/
#ifndef UTF8f
#endif
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Compiler directives
-=for apidoc AmU|bool|LIKELY|const bool expr
+=for apidoc Am||LIKELY|bool expr
Returns the input unchanged, but at the same time it gives a branch prediction
hint to the compiler that this condition is likely to be true.
-=for apidoc AmU|bool|UNLIKELY|const bool expr
+=for apidoc Am||UNLIKELY|bool expr
Returns the input unchanged, but at the same time it gives a branch prediction
hint to the compiler that this condition is likely to be false.
# define __has_builtin(x) 0 /* not a clang style compiler */
#endif
-/* ASSUME is like assert(), but it has a benefit in a release build. It is a
- hint to a compiler about a statement of fact in a function call free
- expression, which allows the compiler to generate better machine code.
- In a debug build, ASSUME(x) is a synonym for assert(x). ASSUME(0) means
- the control path is unreachable. In a for loop, ASSUME can be used to hint
- that a loop will run at least X times. ASSUME is based off MSVC's __assume
- intrinsic function, see its documents for more details.
+/*
+=for apidoc Am||ASSUME|bool expr
+C<ASSUME> is like C<assert()>, but it has a benefit in a release build. It is a
+hint to a compiler about a statement of fact in a function call free
+expression, which allows the compiler to generate better machine code. In a
+debug build, C<ASSUME(x)> is a synonym for C<assert(x)>. C<ASSUME(0)> means the
+control path is unreachable. In a for loop, C<ASSUME> can be used to hint that
+a loop will run at least X times. C<ASSUME> is based off MSVC's C<__assume>
+intrinsic function, see its documents for more details.
+
+=cut
*/
-#ifndef DEBUGGING
-# if __has_builtin(__builtin_unreachable) \
- || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5 || __GNUC__ > 4) /* 4.5 -> */
+#ifdef DEBUGGING
+# define ASSUME(x) assert(x)
+# if __has_builtin(__builtin_unreachable)
+# define HAS_BUILTIN_UNREACHABLE
+# elif (defined(__GNUC__) && ( __GNUC__ > 4 \
+ || __GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+# define HAS_BUILTIN_UNREACHABLE
+# endif
+#endif
+
+#if defined(__sun) || (defined(__hpux) && !defined(__GNUC__))
+# ifndef ASSUME
+# define ASSUME(x) /* ASSUME() generates warnings on Solaris */
+# endif
+# define NOT_REACHED
+#elif defined(HAS_BUILTIN_UNREACHABLE)
+# ifndef ASSUME
# define ASSUME(x) ((x) ? (void) 0 : __builtin_unreachable())
-# elif defined(_MSC_VER)
+# endif
+# define NOT_REACHED \
+ STMT_START { \
+ ASSUME(!"UNREACHABLE"); __builtin_unreachable(); \
+ } STMT_END
+#else
+# if defined(_MSC_VER)
# define ASSUME(x) __assume(x)
# elif defined(__ARMCC_VERSION) /* untested */
# define ASSUME(x) __promise(x)
# else
-/* a random compiler might define assert to its own special optimization token
- so pass it through to C lib as a last resort */
+ /* a random compiler might define assert to its own special optimization
+ * token so pass it through to C lib as a last resort */
# define ASSUME(x) assert(x)
# endif
-#else
-# define ASSUME(x) assert(x)
-#endif
-
-#if defined(__sun) /* ASSUME() generates warnings on Solaris */
-# define NOT_REACHED
-#elif defined(DEBUGGING) && (__has_builtin(__builtin_unreachable) \
- || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5 || __GNUC__ > 4)) /* 4.5 -> */
-# define NOT_REACHED STMT_START { ASSUME(!"UNREACHABLE"); __builtin_unreachable(); } STMT_END
-#else
# define NOT_REACHED ASSUME(!"UNREACHABLE")
#endif
+#undef HAS_BUILTIN_UNREACHABLE
/* Some unistd.h's give a prototype for pause() even though
HAS_PAUSE ends up undefined. This causes the #define
&& idx >= AvFILLp(PL_parser->rsfp_filters))
#define PERL_FILTER_EXISTS(i) \
(PL_parser && PL_parser->rsfp_filters \
- && (i) < av_count(PL_parser->rsfp_filters))
+ && (Size_t) (i) < av_count(PL_parser->rsfp_filters))
#if defined(_AIX) && !defined(_AIX43)
#if defined(USE_REENTRANT) || defined(_REENTRANT) || defined(_THREAD_SAFE)
typedef struct magic_state MGS; /* struct magic_state defined in mg.c */
-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) \
+ || defined(PERL_EXT_RE_BUILD)
/* These have to be predeclared, as they are used in proto.h which is #included
* before their definitions in regcomp.h. */
/* This may look like unnecessary jumping through hoops, but converting
out of range floating point values to integers *is* undefined behaviour,
and it is starting to bite.
+
+=for apidoc_section Casting
+=for apidoc Am|I32|I_32|NV what
+Cast an NV to I32 while avoiding undefined C behavior
+
+=for apidoc Am|U32|U_32|NV what
+Cast an NV to U32 while avoiding undefined C behavior
+
+=for apidoc Am|IV|I_V|NV what
+Cast an NV to IV while avoiding undefined C behavior
+
+=for apidoc Am|UV|U_V|NV what
+Cast an NV to UV while avoiding undefined C behavior
+
+=cut
*/
#ifndef CAST_INLINE
#define I_32(what) (cast_i32((NV)(what)))
INIT("");
EXTCONST char PL_Zero[]
INIT("0");
+
+/*
+=for apidoc_section Numeric Functions
+=for apidoc AmTuU|const char *|PL_hexdigit|U8 value
+
+This array, indexed by an integer, converts that value into the character that
+represents it. For example, if the input is 8, the return will be a string
+whose first character is '8'. What is actually returned is a pointer into a
+string. All you are interested in is the first character of that string. To
+get uppercase letters (for the values 10..15), add 16 to the index. Hence,
+C<PL_hexdigit[11]> is C<'b'>, and C<PL_hexdigit[11+16]> is C<'B'>. Adding 16
+to an index whose representation is '0'..'9' yields the same as not adding 16.
+Indices outside the range 0..31 result in (bad) undedefined behavior.
+
+=cut
+*/
EXTCONST char PL_hexdigit[]
INIT("0123456789abcdef0123456789ABCDEF");
#define HINT_SORT_STABLE 0x00000100 /* sort styles */
#define HINT_SORT_UNSTABLE 0x00000200
+#define HINT_ALL_STRICT HINT_STRICT_REFS \
+ | HINT_STRICT_SUBS \
+ | HINT_STRICT_VARS
+
+#ifdef USE_STRICT_BY_DEFAULT
+#define HINTS_DEFAULT HINT_ALL_STRICT
+#else
+#define HINTS_DEFAULT 0
+#endif
+
/* flags for PL_sawampersand */
#define SAWAMPERSAND_LEFT 1 /* saw $` */
#define PERL_MAGIC_READONLY_ACCEPTABLE 0x40
#define PERL_MAGIC_VALUE_MAGIC 0x80
#define PERL_MAGIC_VTABLE_MASK 0x3F
+
+/* can this type of magic be attached to a readonly SV? */
#define PERL_MAGIC_TYPE_READONLY_ACCEPTABLE(t) \
(PL_magic_data[(U8)(t)] & PERL_MAGIC_READONLY_ACCEPTABLE)
+
+/* Is this type of magic container magic (%ENV, $1 etc),
+ * or value magic (pos, taint etc)?
+ */
#define PERL_MAGIC_TYPE_IS_VALUE_MAGIC(t) \
(PL_magic_data[(U8)(t)] & PERL_MAGIC_VALUE_MAGIC)
* byte ones (as they are always legal) are to this state.
*/
-# define NUM_CLASSES 18
-# define N0 0
-# define N1 ((N0) + NUM_CLASSES)
-# define N2 ((N1) + NUM_CLASSES)
-# define N3 ((N2) + NUM_CLASSES)
-# define N4 ((N3) + NUM_CLASSES)
-# define N5 ((N4) + NUM_CLASSES)
-# define N6 ((N5) + NUM_CLASSES)
-# define N7 ((N6) + NUM_CLASSES)
-# define N8 ((N7) + NUM_CLASSES)
-# define N9 ((N8) + NUM_CLASSES)
-# define N10 ((N9) + NUM_CLASSES)
+# if defined(PERL_CORE)
+# define NUM_CLASSES 18
+# define N0 0
+# define N1 ((N0) + NUM_CLASSES)
+# define N2 ((N1) + NUM_CLASSES)
+# define N3 ((N2) + NUM_CLASSES)
+# define N4 ((N3) + NUM_CLASSES)
+# define N5 ((N4) + NUM_CLASSES)
+# define N6 ((N5) + NUM_CLASSES)
+# define N7 ((N6) + NUM_CLASSES)
+# define N8 ((N7) + NUM_CLASSES)
+# define N9 ((N8) + NUM_CLASSES)
+# define N10 ((N9) + NUM_CLASSES)
/*Class: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 */
/*N0*/ 0, 1,N1,N2,N3,N4,N5, 1, 1, 1, 1, 1, 1,N6,N7,N8,N9,N10,
* byte ones (as they are always legal) are to this state.
*/
-# undef N0
-# undef N1
-# undef N2
-# undef N3
-# undef N4
-# undef N5
-# undef N6
-# undef N7
-# undef N8
-# undef N9
-# undef NUM_CLASSES
-# define NUM_CLASSES 19
-# define N0 0
-# define N1 ((N0) + NUM_CLASSES)
-# define N2 ((N1) + NUM_CLASSES)
-# define N3 ((N2) + NUM_CLASSES)
-# define N4 ((N3) + NUM_CLASSES)
-# define N5 ((N4) + NUM_CLASSES)
-# define N6 ((N5) + NUM_CLASSES)
-# define N7 ((N6) + NUM_CLASSES)
-# define N8 ((N7) + NUM_CLASSES)
-# define N9 ((N8) + NUM_CLASSES)
-# define N10 ((N9) + NUM_CLASSES)
-# define N11 ((N10) + NUM_CLASSES)
+# undef N0
+# undef N1
+# undef N2
+# undef N3
+# undef N4
+# undef N5
+# undef N6
+# undef N7
+# undef N8
+# undef N9
+# undef NUM_CLASSES
+# define NUM_CLASSES 19
+# define N0 0
+# define N1 ((N0) + NUM_CLASSES)
+# define N2 ((N1) + NUM_CLASSES)
+# define N3 ((N2) + NUM_CLASSES)
+# define N4 ((N3) + NUM_CLASSES)
+# define N5 ((N4) + NUM_CLASSES)
+# define N6 ((N5) + NUM_CLASSES)
+# define N7 ((N6) + NUM_CLASSES)
+# define N8 ((N7) + NUM_CLASSES)
+# define N9 ((N8) + NUM_CLASSES)
+# define N10 ((N9) + NUM_CLASSES)
+# define N11 ((N10) + NUM_CLASSES)
/*Class: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 */
/*N0*/ 0, 1, N1, N2, N4, N7, N6, N3, N5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
* byte ones (as they are always legal) are to this state.
*/
-# undef N0
-# undef N1
-# undef N2
-# undef N3
-# undef N4
-# undef N5
-# undef N6
-# undef N7
-# undef NUM_CLASSES
-# define NUM_CLASSES 12
-# define N0 0
-# define N1 ((N0) + NUM_CLASSES)
-# define N2 ((N1) + NUM_CLASSES)
-# define N3 ((N2) + NUM_CLASSES)
-# define N4 ((N3) + NUM_CLASSES)
-# define N5 ((N4) + NUM_CLASSES)
-# define N6 ((N5) + NUM_CLASSES)
-# define N7 ((N6) + NUM_CLASSES)
+# undef N0
+# undef N1
+# undef N2
+# undef N3
+# undef N4
+# undef N5
+# undef N6
+# undef N7
+# undef NUM_CLASSES
+# define NUM_CLASSES 12
+# define N0 0
+# define N1 ((N0) + NUM_CLASSES)
+# define N2 ((N1) + NUM_CLASSES)
+# define N3 ((N2) + NUM_CLASSES)
+# define N4 ((N3) + NUM_CLASSES)
+# define N5 ((N4) + NUM_CLASSES)
+# define N6 ((N5) + NUM_CLASSES)
+# define N7 ((N6) + NUM_CLASSES)
/*Class: 0 1 2 3 4 5 6 7 8 9 10 11 */
/*N0*/ 0, 1, N1, N2, N5, N7, N3, N4, N6, 1, 1, 1,
/*N7*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, N2, 1, 1,
};
+# endif /* defined(PERL_CORE) */
# else /* End of is DOINIT */
EXTCONST U8 PL_extended_utf8_dfa_tab[];
cBOOL(PL_hints & (HINT_LOCALE|HINT_LOCALE_PARTIAL))
/*
-=head1 Locale-related functions and macros
+=for apidoc_section Locales
=for apidoc Amn|bool|IN_LOCALE
* operations used by Perl, namely the decimal point, and even the thousands
* separator.)
-=head1 Locale-related functions and macros
+=for apidoc_section Locales
=for apidoc Amn|void|DECLARATION_FOR_LC_NUMERIC_MANIPULATION
/*
-=head1 Numeric functions
+=for apidoc_section Numeric Functions
=for apidoc AmTR|NV|Strtod|NN const char * const s|NULLOK char ** e
#define IS_NUMBER_TRAILING 0x40 /* number has trailing trash */
/*
-=head1 Numeric functions
+=for apidoc_section Numeric Functions
=for apidoc AmdR|bool|GROK_NUMERIC_RADIX|NN const char **sp|NN const char *send
#define PERL_UNICODE_UTF8CACHEASSERT 'a'
/*
+=for apidoc_section Signals
=for apidoc Amn|U32|PERL_SIGNALS_UNSAFE_FLAG
If this bit in C<PL_signals> is set, the system is uing the pre-Perl 5.8
unsafe signals. See L<perlrun/PERL_SIGNALS> and L<perlipc/Deferred Signals
#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
/*
-=head1 Numeric functions
+=for apidoc_section Numeric Functions
=for apidoc Am|int|PERL_ABS|int
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Utility Functions
=for apidoc Am|bool|IS_SAFE_SYSCALL|NN const char *pv|STRLEN len|NN const char *what|NN const char *op_name