/* first, some documentation for xsubpp-generated items */
/*
-=head1 C<xsubpp> variables and internal functions
+=for apidoc_section XS
=for apidoc Amn|char*|CLASS
Variable which is setup by C<xsubpp> to indicate the
=for apidoc Amns||XSRETURN_EMPTY
Return an empty list from an XSUB immediately.
-=head1 Variables created by C<xsubpp> and C<xsubpp> internal functions
-
=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.
*/
/*
-=head1 Array Manipulation Functions
+=for apidoc_section AV Handling
*/
#include "EXTERN.h"
(deprecated - use C<(AV *)NULL> instead)
-=head1 Array Manipulation Functions
-
=for apidoc Am|int|AvFILL|AV* av
Same as C<av_top_index()> or C<av_tindex()>.
#define CopHINTHASH_set(c,h) ((c)->cop_hints_hash = (h))
/*
-=head1 COP Hint Reading
-*/
-
-/*
=for apidoc Am|SV *|cop_hints_fetch_pvn|const COP *cop|const char *keypv|STRLEN keylen|U32 hash|U32 flags
Look up the hint entry in the cop C<cop> with the key specified by
#define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc()))
/*
-=head1 "Gimme" Values
-*/
-
-/*
=for apidoc AmnU||G_SCALAR
Used to indicate scalar context. See C<L</GIMME_V>>, C<L</GIMME>>, and
L<perlcall>.
};
/*
-=head1 Handy Values
+=head1 CV Handling
+
+This section documents functions to manipulate CVs which are code-values,
+meaning subroutines. For more information, see L<perlguts>.
=for apidoc ADmnU||Nullcv
Null CV pointer.
(deprecated - use C<(CV *)NULL> instead)
-=head1 CV Manipulation Functions
-
-This section documents functions to manipulate CVs which are code-values,
-or subroutines. For more information, see L<perlguts>.
-
=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.
)
/*
-=head1 CV reference counts and CvOUTSIDE
=for apidoc m|bool|CvWEAKOUTSIDE|CV *cv
#endif /* SYSV IPC */
/*
-=head1 IO Functions
+=for apidoc_section Input/Output
=for apidoc start_glob
return SvPV_nolen(t);
}
-/*
-=head1 Debugging Utilities
-*/
-
void
Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
{
*/
/*
-=head1 GV Functions
+=head1 GV Handling
A GV is a structure which corresponds to to a Perl typeglob, ie *foo.
It is a structure that holds a pointer to a scalar, an array, a hash etc,
corresponding to $foo, @foo, %foo.
#define GvNAMELEN(gv) GvNAMELEN_get(gv)
/*
-=head1 GV Functions
+=for apidoc_section GV Handling
=for apidoc Am|SV*|GvSV|GV* gv
# define Null(type) ((type)NULL)
/*
-=head1 Handy Values
-
+=for apidoc_section String Handling
=for apidoc AmnU||Nullch
Null character pointer. (No longer available when C<PERL_CORE> is
defined.)
+=for apidoc_section SV Handling
=for apidoc AmnU||Nullsv
Null SV pointer. (No longer available when C<PERL_CORE> is defined.)
=cut
+
+Below are signatures of functions from config.h which can't easily be gleaned
+from it, and are very unlikely to change
+
+=for apidoc_section Signals
+=for apidoc Am|int|Sigsetjmp|jmp_buf env|int savesigs
+=for apidoc Am|void|Siglongjmp|jmp_buf env|int val
+
+=for apidoc_section Filesystem configuration values
+=for apidoc Am|void *|FILE_ptr|FILE * f
+=for apidoc Am|Size_t|FILE_cnt|FILE * f
+=for apidoc Am|void *|FILE_base|FILE * f
+=for apidoc Am|Size_t|FILE_bufsiz
+
+=for apidoc_section String Handling
+=for apidoc Am|token|CAT2|token x|token y
+=for apidoc Am|string|STRINGIFY|token x
+
+=for apidoc_section Numeric Functions
+=for apidoc Am|double|Drand01|double x
+=for apidoc Am|void|seedDrand01|Rand_seed_t x
+=for apidoc Am|char *|Gconvert|double x|Size_t n|bool t|char * b
+
+=cut
*/
# define Nullch Null(char*)
#endif
/*
+=for apidoc_section Casting
=for apidoc Am|bool|cBOOL|bool expr
Cast-to-bool. A simple S<C<(bool) I<expr>>> cast may not do the right thing:
#define nBIT_UMAX(n) nBIT_MASK(n)
/*
+=for apidoc_section Compiler directives
=for apidoc Am|void|__ASSERT_|bool expr
This is a helper macro to avoid preprocessor issues, replaced by nothing
#endif
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc Ama|SV*|newSVpvs|"literal string"
Like C<newSVpvn>, but takes a literal string instead of a
Like C<sv_setref_pvn>, but takes a literal string instead of
a string/length pair.
-=head1 Memory Management
+=for apidoc_section String Handling
=for apidoc Ama|char*|savepvs|"literal string"
Like C<savepvn>, but takes a literal string instead of a
A version of C<savepvs()> which allocates the duplicate string in memory
which is shared between threads.
-=head1 GV Functions
+=for apidoc_section GV Handling
=for apidoc Am|HV*|gv_stashpvs|"name"|I32 create
Like C<gv_stashpvn>, but takes a literal string instead of a
string/length pair.
-=head1 Hash Manipulation Functions
+=for apidoc_section HV Handling
=for apidoc Am|SV**|hv_fetchs|HV* tb|"key"|I32 lval
Like C<hv_fetch>, but takes a literal string instead of a
*/
/*
-=head1 Handy Values
+=for apidoc_section String Handling
=for apidoc Amu|pair|STR_WITH_LEN|"literal string"
PERL_VERSION_PATCH)
/*
+=for apidoc_section Versioning
=for apidoc AmR|bool|PERL_VERSION_EQ|const U8 major|const U8 minor|const U8 patch
Returns whether or not the perl currently being compiled has the specified
# define PERL_VERSION_GT(j,n,p) (! PERL_VERSION_LE(j,n,p))
/*
-=head1 Miscellaneous Functions
+=for apidoc_section String Handling
=for apidoc Am|bool|strNE|char* s1|char* s2
Test two C<NUL>-terminated strings to see if they are different. Returns true
=for apidoc Amh|bool|isIDCONT_LC_uvchr|int ch
=for apidoc Amh|bool|isIDCONT_LC_utf8_safe|U8 * s| U8 *end
-=head1 Miscellaneous Functions
+=for apidoc_section Numeric Functions
=for apidoc Am|U8|READ_XDIGIT|char str*
Returns the value of an ASCII-range hex digit and advances the string pointer.
/*
void below because that's the best fit, and works for Devel::PPPort
+=for apidoc_section Integer configuration values
=for apidoc AmnU|void|WIDEST_UTYPE
Yields the widest unsigned integer type on the platform, currently either
This should B<ONLY> be used on memory obtained using L</"Newx"> and friends.
+=for apidoc_section String Handling
=for apidoc Am|void|Move|void* src|void* dest|int nitems|type
The XSUB-writer's interface to the C C<memmove> function. The C<src> is the
source, C<dest> is the destination, C<nitems> is the number of items, and
for encouraging compilers to tail-call
optimise.
+=for apidoc_section Utility Functions
=for apidoc Am|void|StructCopy|type *src|type *dest|type
This is an architecture-independent macro to copy one structure to another.
#define StructCopy(s,d,t) (*((t*)(d)) = *((t*)(s)))
/*
-=head1 Handy Values
+=for apidoc_section Utility Functions
=for apidoc Am|STRLEN|C_ARRAY_LENGTH|void *a
*/
/*
-=head1 Hash Manipulation Functions
+=head1 HV Handling
A HV structure represents a Perl hash. It consists mainly of an array
of pointers, each of which points to a linked list of HE structures. The
array is indexed by the hash function of the key, so each linked list
}
/*
+=for apidoc_section COP Hint Hashes
=for apidoc cop_fetch_label
Returns the label attached to a cop, and stores its length in bytes into
}
/*
+=for apidoc_section HV Handling
=for apidoc hv_assert
Check that a hash is in an internally consistent state.
};
/*
-=head1 Hash Manipulation Functions
+=for apidoc_section HV Handling
=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).
-=head1 Handy Values
-
=for apidoc ADmnU||Nullhv
Null HV pointer.
(deprecated - use C<(HV *)NULL> instead)
-=head1 Hash Manipulation Functions
-
=for apidoc Am|char*|HvNAME|HV* stash
Returns the package name of a stash, or C<NULL> if C<stash> isn't a stash.
See C<L</SvSTASH>>, C<L</CvSTASH>>.
/* ------------------------------- av.h ------------------------------- */
/*
+=for apidoc_section AV Handling
=for apidoc av_count
Returns the number of elements in the array C<av>. This is the true length of
the array, including any undefined elements. It is always the same as
/* ------------------------------- perl.h ----------------------------- */
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Utility Functions
=for apidoc is_safe_syscall
/* ------------------ util.h ------------------------------------------- */
/*
-=head1 Miscellaneous Functions
+=for apidoc_section String Handling
=for apidoc foldEQ
}
/*
+=for apidoc_section Locales
=for apidoc foldEQ_locale
Returns true if the leading C<len> bytes of the strings C<s1> and C<s2> are the
}
/*
+=for apidoc_section String Handling
=for apidoc my_strnlen
The C library C<strnlen> if available, or a Perl implementation of it.
/*
-=head1 Locale-related functions and macros
+=for apidoc_section Locales
=for apidoc Perl_setlocale
/*
These have the same interfaces as the C lib ones, so are considered documented
+=for apidoc_section Memory Management
=for apidoc malloc
=for apidoc calloc
=for apidoc realloc
*
* Some blurb for perlapi.pod:
-=head1 Obsolete backwards compatibility functions
+ head1 Obsolete backwards compatibility functions
Some of these are also deprecated. You can exclude these from
your compiled Perl by adding this option to Configure:
}
/*
+=for apidoc_section SV Handling
=for apidoc sv_unref
Unsets the RV status of the SV, and decrements the reference count of
}
/*
+=for apidoc_section GV Handling
=for apidoc gv_fetchmethod
See L</gv_fetchmethod_autoload>.
}
/*
+=for apidoc_section SV Handling
=for apidoc sv_nolocking
Dummy routine which "locks" an SV when there is no locking module present.
}
/*
+=for apidoc_section Pack and Unpack
=for apidoc unpack_str
The engine implementing C<unpack()> Perl function. Note: parameters C<strbeg>,
/*
+=for apidoc_section Custom Operators
=for apidoc custom_op_name
Return the name for a given custom op. This was once used by the C<OP_NAME>
macro, but is no longer: it has only been kept for compatibility, and
}
/*
+=for apidoc_section Unicode Support
=for apidoc is_utf8_char
Tests if some arbitrary number of bytes begins in a valid UTF-8
*/
/*
-=head1 Magical Functions
+=head1 Magic
"Magic" is special data attached to SV structures in order to give them
"magical" properties. When any Perl code tries to read from, or assign to,
an SV marked as magical, it calls the 'get' or 'set' function associated
}
/*
+=for apidoc_section Errno
=for apidoc sv_string_from_errnum
Generates the message string describing an OS error and returns it as
}
/*
+=for apidoc_section Magic
=for apidoc magic_methcall
Invoke a magic method (like FETCH).
}
/*
+=for apidoc_section Magic
=for apidoc magic_sethint
Triggered by a store to C<%^H>, records the key/value pair to
*/
/*
-=head1 MRO Functions
+=head1 MRO
These functions are related to the method resolution order of perl classes
Also see L<perlmroapi>.
*/
/*
-=head1 Numeric functions
+=for apidoc_section Numeric Functions
=cut
}
/*
-=head1 Embedding Functions
+=for apidoc_section Embedding and Interpreter Cloning
=for apidoc load_module
#define OP_GIMME_REVERSE(flags) ((flags) & G_WANT)
/*
-=head1 "Gimme" Values
+=for apidoc_section Callback Functions
=for apidoc Amn|U32|GIMME_V
The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>,
/*
-=head1 Embedding Functions
+=for apidoc_section Embedding and Interpreter Cloning
=for apidoc cv_undef
*/
/*
-=head1 Handy Values
+=for apidoc_section Versioning
=for apidoc AmDnU|U8|PERL_REVISION
The major number component of the perl interpreter currently being compiled or
#else
/*
-=head1 Embedding Functions
+=for apidoc_section Embedding and Interpreter Cloning
=for apidoc perl_alloc
}
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc get_sv
}
/*
-=head1 Array Manipulation Functions
+=for apidoc_section AV Handling
=for apidoc get_av
}
/*
-=head1 Hash Manipulation Functions
+=for apidoc_section HV Handling
=for apidoc get_hv
}
/*
-=head1 CV Manipulation Functions
+=for apidoc_section CV Handling
=for apidoc get_cvn_flags
/* Require a module. */
/*
-=head1 Embedding Functions
+=for apidoc_section Embedding and Interpreter Cloning
=for apidoc require_pv
/* <--- 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
* 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
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
#endif
/*
-=head1 Miscellaneous Functions
-
+=for apidoc_section Compiler directives
=for apidoc AmnUu|void|STMT_START
STMT_START { statements; } STMT_END;
# 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
#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_section Integer configuration values
=for apidoc AmnUh||PERL_INT_MIN
=for apidoc AmnUh||PERL_LONG_MAX
=for apidoc AmnUh||PERL_USHORT_MAX
=for apidoc AmnUh||PERL_USHORT_MIN
=for apidoc AmnUh||PERL_QUAD_MIN
+=for apidoc_section Floating point configuration values
+
=for apidoc AmnU||PERL_INT_MAX
This and
C<PERL_INT_MIN>,
#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
#endif
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Compiler directives
=for apidoc AmU|bool|LIKELY|const bool expr
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
#define PerlIO PerlIO
#define PERLIO_LAYERS 1
+/*
+=for apidoc_section Input/Output
+=cut
+*/
/* PERLIO_FUNCS_CONST is now on by default for efficiency, PERLIO_FUNCS_CONST
can be removed 1 day once stable & then PerlIO vtables are permanently RO */
#ifdef PERLIO_FUNCS_CONST
const char *layers);
void PerlIO_debug(const char *fmt,...);
+=for apidoc_section Input/Output
+
=for apidoc Amh|int |PerlIO_apply_layers|PerlIO *f|const char *mode|const char *layers
=for apidoc Amh|int |PerlIO_binmode|PerlIO *f|int ptype|int imode|const char *layers
=for apidoc ATmh|int |PerlIO_canset_cnt|PerlIO *f
=head1 FLAG VALUES
+=for apidoc_section Callback Functions
+
The C<flags> parameter in all the I<call_*> functions is one of G_VOID,
G_SCALAR, or G_ARRAY, which indicate the call context, OR'ed together
with a bit mask of any combination of the other G_* symbols defined below.
C<ERRSV> is a macro that calls a function, and C<SvTRUE(ERRSV)> would
end up calling that function multiple times.
+=for apidoc_section Callback Functions
=for apidoc Amnh|GV *|PL_errgv
=item 3.
1;
+=for apidoc_section Source Filters
=for apidoc filter_add
=for apidoc filter_read
See L</Understanding the Magic of Tied Hashes and Arrays> for more
information on how to use the hash access functions on tied hashes.
+=for apidoc_section HV Handling
=for apidoc Amh|void|PERL_HASH|U32 hash|char *key|STRLEN klen
=head2 Hash API Extensions
or 'd' for B<d>eclaration, so we have C<pTHX>, C<aTHX> and C<dTHX>, and
their variants.
+=for apidoc_section Concurrency
=for apidoc Amnh||aTHX
=for apidoc Amnh||aTHX_
=for apidoc Amnh||dTHX
NVff NV %f-like
NVgf NV %g-like
+=for apidoc_section Formats
=for apidoc Amnh||IVdf
=for apidoc Amnh||UVuf
=for apidoc Amnh||UVof
One way to do this for typical filehandles is to invoke perl with the
C<-C>> parameter. (See L<perlrun/-C [numberE<sol>list]>.
+=for apidoc_section Formats
+=cut
+
=head2 Formatted Printing of C<Size_t> and C<SSize_t>
The most general way to do this is to cast them to a UV or IV, and
PTR2NV(pointer)
INT2PTR(pointertotype, integer)
+=for apidoc_section Casting
=for apidoc Amh|void *|INT2PTR|type|int value
=for apidoc Amh|UV|PTR2UV|void *
=for apidoc Amh|IV|PTR2IV|void *
C<c> is in C<"list"> and works even if C<c> is C<NUL>. These functions
need an additional parameter to give the string length.
In the case of literal string parameters, perl has defined macros that
-calculate the length for you. See L<perlapi/Miscellaneous Functions>.
+calculate the length for you. See L<perlapi/String Handling>.
=item *
meta = HvMROMETA(stash);
private_sv = MRO_GET_PRIVATE_DATA(meta, &my_mro_alg);
+=for apidoc_section MRO
=for apidoc mro_get_private_data
To set your private value, call C<Perl_mro_set_private_data()>:
/*
-=head1 CV Manipulation Functions
+=for apidoc_section CV Handling
=for apidoc caller_cx
}
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc sortsv_flags
#endif
/*
-=head1 Array Manipulation Functions
=for apidoc sortsv
/*
-=head1 GV Functions
+=for apidoc_section GV Handling
=for apidoc setdefout
#define SAVEPVN(p, n) ((p) ? savepvn(p, n) : NULL)
/*
+=for apidoc_section REGEXP Functions
=for apidoc re_dup_guts
Duplicate a regexp.
/*
-=head1 GV Functions
+=for apidoc_section GV Handling
=for apidoc save_gp
/* ============================================================================
-=head1 Allocation and deallocation of SVs.
-
+=for apidoc_section SV Handling
An SV (or AV, HV, etc.) is allocated in two parts: the head (struct
sv, av, hv...) contains type and reference count information, and for
many types, a pointer to the body (struct xrv, xpv, xpviv...), which
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc sv_add_arena
/* =========================================================================
-=head1 Cloning an interpreter
+=for apidoc_section Embedding and Interpreter Cloning
=cut
/*
+=apidoc_section Warning and Dieing
=for apidoc find_uninit_var
Find the name of the undefined variable (if any) that caused the operator
#undef _SV_HEAD_UNION /* ensure no pollution */
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc Am|U32|SvREFCNT|SV* sv
Returns the value of the object's reference count. Exposed
/* the following macros update any magic values this C<sv> is associated with */
/*
-=head1 Magical Functions
+=head1 Magic
=for apidoc Am|void|SvGETMAGIC|SV* sv
Invokes C<mg_get> on an SV if it has 'get' magic. For example, this
Releases a mutual exclusion lock on C<sv> if a suitable module
has been loaded.
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc Am|char *|SvGROW|SV* sv|STRLEN len
Expands the character buffer in the SV so that it has room for the
Digest::MD5 cpan/Digest-MD5/MD5.xs 249bed648232192ce018f7f894ad127c3a639831
Digest::MD5 cpan/Digest-MD5/t/files.t e987329d2411ff60ad9a2bdf93fdf5f6943467e8
ExtUtils::Constant cpan/ExtUtils-Constant/t/Constant.t d5c75c41d6736a0c5897130f534af0896a7d6f4d
-Filter::Util::Call pod/perlfilter.pod e9833bf4ebc51087dfee5c553e0f8a5eef67212d
+Filter::Util::Call pod/perlfilter.pod 67d1ea264f5fe88e9422976e2a903bf3d1671f6d
Locale::Maketext::Simple cpan/Locale-Maketext-Simple/lib/Locale/Maketext/Simple.pm 57ed38905791a17c150210cd6f42ead22a7707b6
Math::Complex cpan/Math-Complex/lib/Math/Complex.pm 66f28a17647e2de166909ca66e4ced26f8a0a62e
Math::Complex cpan/Math-Complex/t/Complex.t 17039e03ee798539e770ea9a0d19a99364278306
Win32API::File cpan/Win32API-File/File.xs beb870fed4490d2faa547b4a8576b8d64d1d27c5
experimental cpan/experimental/t/basic.t cb9da8dd05b854375809872a05dd32637508d5da
version cpan/version/lib/version.pm 7ef9219d1d5f1d71f08a79f3b0577df138b21b12
-version vutil.c 601cc57bbc0070ae33eab7fd2d667f20efbe15f8
+version vutil.c 7a416b6630a498e737aae03891d0873aaeb066f0
}
/*
-=head1 SV Manipulation Functions
+=for apidoc_section SV Handling
=for apidoc sv_derived_from_pvn
/*
+=for apidoc_section String Handling
=for apidoc delimcpy_no_escape
Copy a source buffer to a destination buffer, stopping at (but not including)
}
/*
-=head1 Miscellaneous Functions
-
=for apidoc ninstr
Find the first (leftmost) occurrence of a sequence of bytes within another
}
/*
-=head1 Miscellaneous Functions
-
=for apidoc rninstr
Like C<L</ninstr>>, but instead finds the final (rightmost) occurrence of a
If FBMcf_TAIL, the table is created as if the string has a trailing \n. */
/*
-=head1 Miscellaneous Functions
=for apidoc fbm_compile
/* copy a string to a safe spot */
/*
-=head1 Memory Management
-
+=for apidoc_section String Handling
=for apidoc savepv
Perl's version of C<strdup()>. Returns a pointer to a newly allocated
#endif /* PERL_IMPLICIT_CONTEXT */
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Display and Dump functions
=for apidoc form
Takes a sprintf-style format pattern and conventional
}
/*
-=head1 Warning and Dieing
+=for apidoc_section Warning and Dieing
*/
/* Common code used in dieing and warning */
# if !defined(WIN32) && !defined(NETWARE)
/*
+=for apidoc_section Utility Functions
=for apidoc my_setenv
A wrapper for the C library L<setenv(3)>. Don't use the latter, as the perl
#ifdef HAS_SIGACTION
/*
+=for apidoc_section Signals
=for apidoc rsignal
A wrapper for the C library L<signal(2)>. Don't use the latter, as the Perl
#ifdef HAS_STRFTIME
/*
+=for apidoc_section Time
=for apidoc my_strftime
strftime(), but with a different API so that the return value is a pointer
to the formatted result (which MUST be arranged to be FREED BY THE
(dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
/*
-=head1 Miscellaneous Functions
+=for apidoc_section Utility Functions
=for apidoc getcwd_sv
#endif /* PERL_MEM_LOG */
/*
+=for apidoc_section String Handling
=for apidoc quadmath_format_valid
C<quadmath_snprintf()> is very strict about its C<format> string and will
#endif /* #ifdef PERL_DARWIN */
/*
+=for apidoc_section Display and Dump functions
=for apidoc get_c_backtrace
Collects the backtrace (aka "stacktrace") into a single linear
*/
/*
+=for apidoc_section Display and Dump functions
=for apidoc get_c_backtrace_dump
Returns a SV containing a dump of C<depth> frames of the call stack, skipping
#endif
/*
-=head1 Miscellaneous Functions
+=for apidoc_section String Handling
=for apidoc ibcmp
#define VERSION_MAX 0x7FFFFFFF
/*
+=for apidoc_section Versioning
+
=for apidoc prescan_version
Validate that a given string can be parsed as a version object, but doesn't
https://perl5.git.perl.org / perl5.git / commitdiff