3 perlapi - autogenerated documentation for the perl public API
7 This file contains the documentation of the perl public API generated by
8 embed.pl, specifically a listing of functions, macros, flags, and variables
9 that may be used by extension writers. The interfaces of any functions that
10 are not listed here are subject to change without notice. For this reason,
11 blindly using functions listed in proto.h is to be avoided when writing
14 Note that all Perl API global variables must be referenced with the C<PL_>
15 prefix. Some macros are provided for compatibility with the older,
16 unadorned names, but this support may be disabled in a future release.
18 The listing is alphabetical, case insensitive.
24 Same as C<av_len()>. Deprecated, use C<av_len()> instead.
30 Clears an array, making it empty. Does not free the memory used by the
37 Pre-extend an array. The C<key> is the index to which the array should be
40 void av_extend(AV* ar, I32 key)
44 Returns the SV at the specified index in the array. The C<key> is the
45 index. If C<lval> is set then the fetch will be part of a store. Check
46 that the return value is non-null before dereferencing it to a C<SV*>.
48 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
49 more information on how to use this function on tied arrays.
51 SV** av_fetch(AV* ar, I32 key, I32 lval)
55 Returns the highest index in the array. Returns -1 if the array is
62 Creates a new AV and populates it with a list of SVs. The SVs are copied
63 into the array, so they may be freed after the call to av_make. The new AV
64 will have a reference count of 1.
66 AV* av_make(I32 size, SV** svp)
70 Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array
77 Pushes an SV onto the end of the array. The array will grow automatically
78 to accommodate the addition.
80 void av_push(AV* ar, SV* val)
84 Shifts an SV off the beginning of the array.
90 Stores an SV in an array. The array index is specified as C<key>. The
91 return value will be NULL if the operation failed or if the value did not
92 need to be actually stored within the array (as in the case of tied
93 arrays). Otherwise it can be dereferenced to get the original C<SV*>. Note
94 that the caller is responsible for suitably incrementing the reference
95 count of C<val> before the call, and decrementing it if the function
98 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
99 more information on how to use this function on tied arrays.
101 SV** av_store(AV* ar, I32 key, SV* val)
105 Undefines the array. Frees the memory used by the array itself.
107 void av_undef(AV* ar)
111 Unshift the given number of C<undef> values onto the beginning of the
112 array. The array will grow automatically to accommodate the addition. You
113 must then use C<av_store> to assign values to these new elements.
115 void av_unshift(AV* ar, I32 num)
119 Performs a callback to the specified Perl sub. See L<perlcall>.
121 NOTE: the perl_ form of this function is deprecated.
123 I32 call_argv(const char* sub_name, I32 flags, char** argv)
127 Performs a callback to the specified Perl method. The blessed object must
128 be on the stack. See L<perlcall>.
130 NOTE: the perl_ form of this function is deprecated.
132 I32 call_method(const char* methname, I32 flags)
136 Performs a callback to the specified Perl sub. See L<perlcall>.
138 NOTE: the perl_ form of this function is deprecated.
140 I32 call_pv(const char* sub_name, I32 flags)
144 Performs a callback to the Perl sub whose name is in the SV. See
147 NOTE: the perl_ form of this function is deprecated.
149 I32 call_sv(SV* sv, I32 flags)
153 Variable which is setup by C<xsubpp> to indicate the
154 class name for a C++ XS constructor. This is always a C<char*>. See C<THIS>.
160 The XSUB-writer's interface to the C C<memcpy> function. The C<src> is the
161 source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
162 the type. May fail on overlapping copies. See also C<Move>.
164 void Copy(void* src, void* dest, int nitems, type)
168 This is the XSUB-writer's interface to Perl's C<die> function. Use this
169 function the same way you use the C C<printf> function. See
172 void croak(const char* pat, ...)
176 Returns the stash of the CV.
182 Declare a stack marker variable, C<mark>, for the XSUB. See C<MARK> and
189 Saves the original stack mark for the XSUB. See C<ORIGMARK>.
195 Declares a local copy of perl's stack pointer for the XSUB, available via
196 the C<SP> macro. See C<SP>.
202 Sets up stack and mark pointers for an XSUB, calling dSP and dMARK. This
203 is usually handled automatically by C<xsubpp>. Declares the C<items>
204 variable to indicate the number of items on the stack.
210 Sets up the C<ix> variable for an XSUB which has aliases. This is usually
211 handled automatically by C<xsubpp>.
217 Opening bracket on a callback. See C<LEAVE> and L<perlcall>.
223 Tells Perl to C<eval> the given string and return an SV* result.
225 NOTE: the perl_ form of this function is deprecated.
227 SV* eval_pv(const char* p, I32 croak_on_error)
231 Tells Perl to C<eval> the string in the SV.
233 NOTE: the perl_ form of this function is deprecated.
235 I32 eval_sv(SV* sv, I32 flags)
239 Used to extend the argument stack for an XSUB's return values. Once
240 used, guarrantees that there is room for at least C<nitems> to be pushed
243 void EXTEND(SP, int nitems)
247 Analyses the string in order to make fast searches on it using fbm_instr()
248 -- the Boyer-Moore algorithm.
250 void fbm_compile(SV* sv, U32 flags)
254 Returns the location of the SV in the string delimited by C<str> and
255 C<strend>. It returns C<Nullch> if the string can't be found. The C<sv>
256 does not have to be fbm_compiled, but the search will not be as fast
259 char* fbm_instr(unsigned char* big, unsigned char* bigend, SV* littlesv, U32 flags)
263 Closing bracket for temporaries on a callback. See C<SAVETMPS> and
270 Returns the AV of the specified Perl array. If C<create> is set and the
271 Perl variable does not exist then it will be created. If C<create> is not
272 set and the variable does not exist then NULL is returned.
274 NOTE: the perl_ form of this function is deprecated.
276 AV* get_av(const char* name, I32 create)
280 Returns the CV of the specified Perl subroutine. If C<create> is set and
281 the Perl subroutine does not exist then it will be declared (which has the
282 same effect as saying C<sub name;>). If C<create> is not set and the
283 subroutine does not exist then NULL is returned.
285 NOTE: the perl_ form of this function is deprecated.
287 CV* get_cv(const char* name, I32 create)
291 Returns the HV of the specified Perl hash. If C<create> is set and the
292 Perl variable does not exist then it will be created. If C<create> is not
293 set and the variable does not exist then NULL is returned.
295 NOTE: the perl_ form of this function is deprecated.
297 HV* get_hv(const char* name, I32 create)
301 Returns the SV of the specified Perl scalar. If C<create> is set and the
302 Perl variable does not exist then it will be created. If C<create> is not
303 set and the variable does not exist then NULL is returned.
305 NOTE: the perl_ form of this function is deprecated.
307 SV* get_sv(const char* name, I32 create)
311 A backward-compatible version of C<GIMME_V> which can only return
312 C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>.
313 Deprecated. Use C<GIMME_V> instead.
319 The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>,
320 C<G_SCALAR> or C<G_ARRAY> for void, scalar or array context,
327 Return the SV from the GV.
333 Returns the glob with the given C<name> and a defined subroutine or
334 C<NULL>. The glob lives in the given C<stash>, or in the stashes
335 accessible via @ISA and @UNIVERSAL.
337 The argument C<level> should be either 0 or -1. If C<level==0>, as a
338 side-effect creates a glob with the given C<name> in the given C<stash>
339 which in the case of success contains an alias for the subroutine, and sets
340 up caching info for this glob. Similarly for all the searched stashes.
342 This function grants C<"SUPER"> token as a postfix of the stash name. The
343 GV returned from C<gv_fetchmeth> may be a method cache entry, which is not
344 visible to Perl code. So when calling C<call_sv>, you should not use
345 the GV directly; instead, you should use the method's CV, which can be
346 obtained from the GV with the C<GvCV> macro.
348 GV* gv_fetchmeth(HV* stash, const char* name, STRLEN len, I32 level)
352 See L<gv_fetchmethod_autoload>.
354 GV* gv_fetchmethod(HV* stash, const char* name)
356 =item gv_fetchmethod_autoload
358 Returns the glob which contains the subroutine to call to invoke the method
359 on the C<stash>. In fact in the presence of autoloading this may be the
360 glob for "AUTOLOAD". In this case the corresponding variable $AUTOLOAD is
363 The third parameter of C<gv_fetchmethod_autoload> determines whether
364 AUTOLOAD lookup is performed if the given method is not present: non-zero
365 means yes, look for AUTOLOAD; zero means no, don't look for AUTOLOAD.
366 Calling C<gv_fetchmethod> is equivalent to calling C<gv_fetchmethod_autoload>
367 with a non-zero C<autoload> parameter.
369 These functions grant C<"SUPER"> token as a prefix of the method name. Note
370 that if you want to keep the returned glob for a long time, you need to
371 check for it being "AUTOLOAD", since at the later time the call may load a
372 different subroutine due to $AUTOLOAD changing its value. Use the glob
373 created via a side effect to do this.
375 These functions have the same side-effects and as C<gv_fetchmeth> with
376 C<level==0>. C<name> should be writable if contains C<':'> or C<'
377 ''>. The warning against passing the GV returned by C<gv_fetchmeth> to
378 C<call_sv> apply equally to these functions.
380 GV* gv_fetchmethod_autoload(HV* stash, const char* name, I32 autoload)
384 Returns a pointer to the stash for a specified package. C<name> should
385 be a valid UTF-8 string. If C<create> is set then the package will be
386 created if it does not already exist. If C<create> is not set and the
387 package does not exist then NULL is returned.
389 HV* gv_stashpv(const char* name, I32 create)
393 Returns a pointer to the stash for a specified package, which must be a
394 valid UTF-8 string. See C<gv_stashpv>.
396 HV* gv_stashsv(SV* sv, I32 create)
400 Used to indicate array context. See C<GIMME_V>, C<GIMME> and
405 Indicates that arguments returned from a callback should be discarded. See
410 Used to force a Perl C<eval> wrapper around a callback. See
415 Indicates that no arguments are being sent to a callback. See
420 Used to indicate scalar context. See C<GIMME_V>, C<GIMME>, and
425 Used to indicate void context. See C<GIMME_V> and L<perlcall>.
429 This flag, used in the length slot of hash entries and magic structures,
430 specifies the structure contains a C<SV*> pointer where a C<char*> pointer
431 is to be expected. (For information only--not to be used).
435 Returns the computed hash stored in the hash entry.
441 Returns the actual pointer stored in the key slot of the hash entry. The
442 pointer may be either C<char*> or C<SV*>, depending on the value of
443 C<HeKLEN()>. Can be assigned to. The C<HePV()> or C<HeSVKEY()> macros are
444 usually preferable for finding the value of a key.
450 If this is negative, and amounts to C<HEf_SVKEY>, it indicates the entry
451 holds an C<SV*> key. Otherwise, holds the actual length of the key. Can
452 be assigned to. The C<HePV()> macro is usually preferable for finding key
455 STRLEN HeKLEN(HE* he)
459 Returns the key slot of the hash entry as a C<char*> value, doing any
460 necessary dereferencing of possibly C<SV*> keys. The length of the string
461 is placed in C<len> (this is a macro, so do I<not> use C<&len>). If you do
462 not care about what the length of the key is, you may use the global
463 variable C<PL_na>, though this is rather less efficient than using a local
464 variable. Remember though, that hash keys in perl are free to contain
465 embedded nulls, so using C<strlen()> or similar is not a good way to find
466 the length of hash keys. This is very similar to the C<SvPV()> macro
467 described elsewhere in this document.
469 char* HePV(HE* he, STRLEN len)
473 Returns the key as an C<SV*>, or C<Nullsv> if the hash entry does not
474 contain an C<SV*> key.
480 Returns the key as an C<SV*>. Will create and return a temporary mortal
481 C<SV*> if the hash entry contains only a C<char*> key.
483 SV* HeSVKEY_force(HE* he)
487 Sets the key to a given C<SV*>, taking care to set the appropriate flags to
488 indicate the presence of an C<SV*> key, and returns the same
491 SV* HeSVKEY_set(HE* he, SV* sv)
495 Returns the value slot (type C<SV*>) stored in the hash entry.
501 Returns the package name of a stash. See C<SvSTASH>, C<CvSTASH>.
503 char* HvNAME(HV* stash)
507 Clears a hash, making it empty.
509 void hv_clear(HV* tb)
513 Deletes a key/value pair in the hash. The value SV is removed from the
514 hash and returned to the caller. The C<klen> is the length of the key.
515 The C<flags> value will normally be zero; if set to G_DISCARD then NULL
518 SV* hv_delete(HV* tb, const char* key, U32 klen, I32 flags)
522 Deletes a key/value pair in the hash. The value SV is removed from the
523 hash and returned to the caller. The C<flags> value will normally be zero;
524 if set to G_DISCARD then NULL will be returned. C<hash> can be a valid
525 precomputed hash value, or 0 to ask for it to be computed.
527 SV* hv_delete_ent(HV* tb, SV* key, I32 flags, U32 hash)
531 Returns a boolean indicating whether the specified hash key exists. The
532 C<klen> is the length of the key.
534 bool hv_exists(HV* tb, const char* key, U32 klen)
538 Returns a boolean indicating whether the specified hash key exists. C<hash>
539 can be a valid precomputed hash value, or 0 to ask for it to be
542 bool hv_exists_ent(HV* tb, SV* key, U32 hash)
546 Returns the SV which corresponds to the specified key in the hash. The
547 C<klen> is the length of the key. If C<lval> is set then the fetch will be
548 part of a store. Check that the return value is non-null before
549 dereferencing it to a C<SV*>.
551 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
552 information on how to use this function on tied hashes.
554 SV** hv_fetch(HV* tb, const char* key, U32 klen, I32 lval)
558 Returns the hash entry which corresponds to the specified key in the hash.
559 C<hash> must be a valid precomputed hash number for the given C<key>, or 0
560 if you want the function to compute it. IF C<lval> is set then the fetch
561 will be part of a store. Make sure the return value is non-null before
562 accessing it. The return value when C<tb> is a tied hash is a pointer to a
563 static location, so be sure to make a copy of the structure if you need to
566 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
567 information on how to use this function on tied hashes.
569 HE* hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)
573 Prepares a starting point to traverse a hash table. Returns the number of
574 keys in the hash (i.e. the same as C<HvKEYS(tb)>). The return value is
575 currently only meaningful for hashes without tie magic.
577 NOTE: Before version 5.004_65, C<hv_iterinit> used to return the number of
578 hash buckets that happen to be in use. If you still need that esoteric
579 value, you can get it through the macro C<HvFILL(tb)>.
581 I32 hv_iterinit(HV* tb)
585 Returns the key from the current position of the hash iterator. See
588 char* hv_iterkey(HE* entry, I32* retlen)
592 Returns the key as an C<SV*> from the current position of the hash
593 iterator. The return value will always be a mortal copy of the key. Also
596 SV* hv_iterkeysv(HE* entry)
600 Returns entries from a hash iterator. See C<hv_iterinit>.
602 HE* hv_iternext(HV* tb)
606 Performs an C<hv_iternext>, C<hv_iterkey>, and C<hv_iterval> in one
609 SV* hv_iternextsv(HV* hv, char** key, I32* retlen)
613 Returns the value from the current position of the hash iterator. See
616 SV* hv_iterval(HV* tb, HE* entry)
620 Adds magic to a hash. See C<sv_magic>.
622 void hv_magic(HV* hv, GV* gv, int how)
626 Stores an SV in a hash. The hash key is specified as C<key> and C<klen> is
627 the length of the key. The C<hash> parameter is the precomputed hash
628 value; if it is zero then Perl will compute it. The return value will be
629 NULL if the operation failed or if the value did not need to be actually
630 stored within the hash (as in the case of tied hashes). Otherwise it can
631 be dereferenced to get the original C<SV*>. Note that the caller is
632 responsible for suitably incrementing the reference count of C<val> before
633 the call, and decrementing it if the function returned NULL.
635 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
636 information on how to use this function on tied hashes.
638 SV** hv_store(HV* tb, const char* key, U32 klen, SV* val, U32 hash)
642 Stores C<val> in a hash. The hash key is specified as C<key>. The C<hash>
643 parameter is the precomputed hash value; if it is zero then Perl will
644 compute it. The return value is the new hash entry so created. It will be
645 NULL if the operation failed or if the value did not need to be actually
646 stored within the hash (as in the case of tied hashes). Otherwise the
647 contents of the return value can be accessed using the C<He???> macros
648 described here. Note that the caller is responsible for suitably
649 incrementing the reference count of C<val> before the call, and
650 decrementing it if the function returned NULL.
652 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
653 information on how to use this function on tied hashes.
655 HE* hv_store_ent(HV* tb, SV* key, SV* val, U32 hash)
661 void hv_undef(HV* tb)
665 Returns a boolean indicating whether the C C<char> is an ascii alphanumeric
668 bool isALNUM(char ch)
672 Returns a boolean indicating whether the C C<char> is an ascii alphabetic
675 bool isALPHA(char ch)
679 Returns a boolean indicating whether the C C<char> is an ascii
682 bool isDIGIT(char ch)
686 Returns a boolean indicating whether the C C<char> is a lowercase
689 bool isLOWER(char ch)
693 Returns a boolean indicating whether the C C<char> is whitespace.
695 bool isSPACE(char ch)
699 Returns a boolean indicating whether the C C<char> is an uppercase
702 bool isUPPER(char ch)
706 Variable which is setup by C<xsubpp> to indicate the number of
707 items on the stack. See L<perlxs/"Variable-length Parameter Lists">.
713 Variable which is setup by C<xsubpp> to indicate which of an
714 XSUB's aliases was used to invoke it. See L<perlxs/"The ALIAS: Keyword">.
720 Closing bracket on a callback. See C<ENTER> and L<perlcall>.
724 =item looks_like_number
726 Test if an the content of an SV looks like a number (or is a
729 I32 looks_like_number(SV* sv)
733 Stack marker variable for the XSUB. See C<dMARK>.
737 Clear something magical that the SV represents. See C<sv_magic>.
743 Copies the magic from one SV to another. See C<sv_magic>.
745 int mg_copy(SV* sv, SV* nsv, const char* key, I32 klen)
749 Finds the magic pointer for type matching the SV. See C<sv_magic>.
751 MAGIC* mg_find(SV* sv, int type)
755 Free any magic storage used by the SV. See C<sv_magic>.
761 Do magic after a value is retrieved from the SV. See C<sv_magic>.
767 Report on the SV's length. See C<sv_magic>.
769 U32 mg_length(SV* sv)
773 Turns on the magical status of an SV. See C<sv_magic>.
775 void mg_magical(SV* sv)
779 Do magic after a value is assigned to the SV. See C<sv_magic>.
785 The XSUB-writer's interface to the C C<memmove> function. The C<src> is the
786 source, C<dest> is the destination, C<nitems> is the number of items, and C<type> is
787 the type. Can do overlapping moves. See also C<Copy>.
789 void Move(void* src, void* dest, int nitems, type)
793 The XSUB-writer's interface to the C C<malloc> function.
795 void New(int id, void* ptr, int nitems, type)
799 Creates a new AV. The reference count is set to 1.
805 The XSUB-writer's interface to the C C<malloc> function, with
808 void Newc(int id, void* ptr, int nitems, type, cast)
812 Creates a constant sub equivalent to Perl C<sub FOO () { 123 }> which is
813 eligible for inlining at compile-time.
815 void newCONSTSUB(HV* stash, char* name, SV* sv)
819 Creates a new HV. The reference count is set to 1.
825 Creates an RV wrapper for an SV. The reference count for the original SV is
828 SV* newRV_inc(SV* sv)
832 Creates an RV wrapper for an SV. The reference count for the original
833 SV is B<not> incremented.
835 SV* newRV_noinc(SV *sv)
839 Creates a new SV. A non-zero C<len> parameter indicates the number of
840 bytes of preallocated string space the SV should have. An extra byte for a
841 tailing NUL is also reserved. (SvPOK is not set for the SV even if string
842 space is allocated.) The reference count for the new SV is set to 1.
843 C<id> is an integer id between 0 and 1299 (used to identify leaks).
845 SV* NEWSV(int id, STRLEN len)
849 Creates a new SV and copies an integer into it. The reference count for the
856 Creates a new SV and copies a floating point value into it.
857 The reference count for the SV is set to 1.
863 Creates a new SV and copies a string into it. The reference count for the
864 SV is set to 1. If C<len> is zero, Perl will compute the length using
865 strlen(). For efficiency, consider using C<newSVpvn> instead.
867 SV* newSVpv(const char* s, STRLEN len)
871 Creates a new SV an initialize it with the string formatted like
874 SV* newSVpvf(const char* pat, ...)
878 Creates a new SV and copies a string into it. The reference count for the
879 SV is set to 1. Note that if C<len> is zero, Perl will create a zero length
880 string. You are responsible for ensuring that the source string is at least
883 SV* newSVpvn(const char* s, STRLEN len)
887 Creates a new SV for the RV, C<rv>, to point to. If C<rv> is not an RV then
888 it will be upgraded to one. If C<classname> is non-null then the new SV will
889 be blessed in the specified package. The new SV is returned and its
890 reference count is 1.
892 SV* newSVrv(SV* rv, const char* classname)
896 Creates a new SV which is an exact duplicate of the original SV.
902 Creates a new SV and copies an unsigned integer into it.
903 The reference count for the SV is set to 1.
909 Used by C<xsubpp> to hook up XSUBs as Perl subs.
913 Used by C<xsubpp> to hook up XSUBs as Perl subs. Adds Perl prototypes to
918 The XSUB-writer's interface to the C C<malloc> function. The allocated
919 memory is zeroed with C<memzero>.
921 void Newz(int id, void* ptr, int nitems, type)
929 Null character pointer.
945 The original stack mark for the XSUB. See C<dORIGMARK>.
949 Allocates a new Perl interpreter. See L<perlembed>.
951 PerlInterpreter* perl_alloc()
955 Initializes a new Perl interpreter. See L<perlembed>.
957 void perl_construct(PerlInterpreter* interp)
961 Shuts down a Perl interpreter. See L<perlembed>.
963 void perl_destruct(PerlInterpreter* interp)
967 Releases a Perl interpreter. See L<perlembed>.
969 void perl_free(PerlInterpreter* interp)
973 Tells a Perl interpreter to parse a Perl script. See L<perlembed>.
975 int perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env)
979 Tells a Perl interpreter to run. See L<perlembed>.
981 int perl_run(PerlInterpreter* interp)
985 When Perl is run in debugging mode, with the B<-d> switch, this SV is a
986 boolean which indicates whether subs are being single-stepped.
987 Single-stepping is automatically turned on after every step. This is the C
988 variable which corresponds to Perl's $DB::single variable. See
995 When Perl is run in debugging mode, with the B<-d> switch, this GV contains
996 the SV which holds the name of the sub being debugged. This is the C
997 variable which corresponds to Perl's $DB::sub variable. See
1004 Trace variable used when Perl is run in debugging mode, with the B<-d>
1005 switch. This is the C variable which corresponds to Perl's $DB::trace
1006 variable. See C<PL_DBsingle>.
1012 The C variable which corresponds to Perl's $^W warning variable.
1018 C<PL_modglobal> is a general purpose, interpreter global HV for use by
1019 extensions that need to keep information on a per-interpreter basis.
1020 In a pinch, it can also be used as a symbol table for extensions
1021 to share data among each other. It is a good idea to use keys
1022 prefixed by the package name of the extension that owns the data.
1028 A convenience variable which is typically used with C<SvPV> when one
1029 doesn't care about the length of the string. It is usually more efficient
1030 to either declare a local variable and use that instead or to use the
1031 C<SvPV_nolen> macro.
1037 This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as
1044 This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>.
1050 This is the C<true> SV. See C<PL_sv_no>. Always refer to this as
1057 Pops an integer off the stack.
1063 Pops a long off the stack.
1069 Pops a double off the stack.
1075 Pops a string off the stack.
1081 Pops an SV off the stack.
1087 Push an integer onto the stack. The stack must have room for this element.
1088 Handles 'set' magic. See C<XPUSHi>.
1094 Opening bracket for arguments on a callback. See C<PUTBACK> and
1101 Push a double onto the stack. The stack must have room for this element.
1102 Handles 'set' magic. See C<XPUSHn>.
1108 Push a string onto the stack. The stack must have room for this element.
1109 The C<len> indicates the length of the string. Handles 'set' magic. See
1112 void PUSHp(char* str, STRLEN len)
1116 Push an SV onto the stack. The stack must have room for this element.
1117 Does not handle 'set' magic. See C<XPUSHs>.
1123 Push an unsigned integer onto the stack. The stack must have room for this
1124 element. See C<XPUSHu>.
1130 Closing bracket for XSUB arguments. This is usually handled by C<xsubpp>.
1131 See C<PUSHMARK> and L<perlcall> for other uses.
1137 The XSUB-writer's interface to the C C<realloc> function.
1139 void Renew(void* ptr, int nitems, type)
1143 The XSUB-writer's interface to the C C<realloc> function, with
1146 void Renewc(void* ptr, int nitems, type, cast)
1150 Tells Perl to C<require> a module.
1152 NOTE: the perl_ form of this function is deprecated.
1154 void require_pv(const char* pv)
1158 Variable which is setup by C<xsubpp> to hold the return value for an
1159 XSUB. This is always the proper type for the XSUB. See
1160 L<perlxs/"The RETVAL Variable">.
1166 The XSUB-writer's interface to the C C<free> function.
1168 void Safefree(void* src, void* dest, int nitems, type)
1172 Copy a string to a safe spot. This does not use an SV.
1174 char* savepv(const char* sv)
1178 Copy a string to a safe spot. The C<len> indicates number of bytes to
1179 copy. This does not use an SV.
1181 char* savepvn(const char* sv, I32 len)
1185 Opening bracket for temporaries on a callback. See C<FREETMPS> and
1192 Stack pointer. This is usually handled by C<xsubpp>. See C<dSP> and
1197 Refetch the stack pointer. Used after a callback. See L<perlcall>.
1203 Used to access elements on the XSUB's stack.
1209 Test two strings to see if they are equal. Returns true or false.
1211 bool strEQ(char* s1, char* s2)
1215 Test two strings to see if the first, C<s1>, is greater than or equal to
1216 the second, C<s2>. Returns true or false.
1218 bool strGE(char* s1, char* s2)
1222 Test two strings to see if the first, C<s1>, is greater than the second,
1223 C<s2>. Returns true or false.
1225 bool strGT(char* s1, char* s2)
1229 Test two strings to see if the first, C<s1>, is less than or equal to the
1230 second, C<s2>. Returns true or false.
1232 bool strLE(char* s1, char* s2)
1236 Test two strings to see if the first, C<s1>, is less than the second,
1237 C<s2>. Returns true or false.
1239 bool strLT(char* s1, char* s2)
1243 Test two strings to see if they are different. Returns true or
1246 bool strNE(char* s1, char* s2)
1250 Test two strings to see if they are equal. The C<len> parameter indicates
1251 the number of bytes to compare. Returns true or false. (A wrapper for
1254 bool strnEQ(char* s1, char* s2, STRLEN len)
1258 Test two strings to see if they are different. The C<len> parameter
1259 indicates the number of bytes to compare. Returns true or false. (A
1260 wrapper for C<strncmp>).
1262 bool strnNE(char* s1, char* s2, STRLEN len)
1266 This is an architecture-independant macro to copy one structure to another.
1268 void StructCopy(type src, type dest, type)
1272 Returns the length of the string which is in the SV. See C<SvLEN>.
1274 STRLEN SvCUR(SV* sv)
1278 Set the length of the string which is in the SV. See C<SvCUR>.
1280 void SvCUR_set(SV* sv, STRLEN len)
1284 Returns a pointer to the last character in the string which is in the SV.
1285 See C<SvCUR>. Access the character as *(SvEND(sv)).
1291 Invokes C<mg_get> on an SV if it has 'get' magic. This macro evaluates its
1292 argument more than once.
1294 void SvGETMAGIC(SV* sv)
1298 Expands the character buffer in the SV so that it has room for the
1299 indicated number of bytes (remember to reserve space for an extra trailing
1300 NUL character). Calls C<sv_grow> to perform the expansion if necessary.
1301 Returns a pointer to the character buffer.
1303 void SvGROW(SV* sv, STRLEN len)
1307 Returns a boolean indicating whether the SV contains an integer.
1313 Returns a boolean indicating whether the SV contains an integer. Checks
1314 the B<private> setting. Use C<SvIOK>.
1320 Unsets the IV status of an SV.
1322 void SvIOK_off(SV* sv)
1326 Tells an SV that it is an integer.
1328 void SvIOK_on(SV* sv)
1332 Tells an SV that it is an integer and disables all other OK bits.
1334 void SvIOK_only(SV* sv)
1338 Coerces the given SV to an integer and returns it.
1344 Returns the integer which is stored in the SV, assuming SvIOK is
1351 Returns the size of the string buffer in the SV. See C<SvCUR>.
1353 STRLEN SvLEN(SV* sv)
1357 Returns a boolean indicating whether the SV contains a number, integer or
1364 Returns a boolean indicating whether the SV contains a number, integer or
1365 double. Checks the B<private> setting. Use C<SvNIOK>.
1367 bool SvNIOKp(SV* sv)
1371 Unsets the NV/IV status of an SV.
1373 void SvNIOK_off(SV* sv)
1377 Returns a boolean indicating whether the SV contains a double.
1383 Returns a boolean indicating whether the SV contains a double. Checks the
1384 B<private> setting. Use C<SvNOK>.
1390 Unsets the NV status of an SV.
1392 void SvNOK_off(SV* sv)
1396 Tells an SV that it is a double.
1398 void SvNOK_on(SV* sv)
1402 Tells an SV that it is a double and disables all other OK bits.
1404 void SvNOK_only(SV* sv)
1408 Coerce the given SV to a double and return it.
1414 Returns the double which is stored in the SV, assuming SvNOK is
1421 Returns a boolean indicating whether the value is an SV.
1427 Returns a boolean indicating whether the SvIVX is a valid offset value for
1428 the SvPVX. This hack is used internally to speed up removal of characters
1429 from the beginning of a SvPV. When SvOOK is true, then the start of the
1430 allocated string buffer is really (SvPVX - SvIVX).
1436 Returns a boolean indicating whether the SV contains a character
1443 Returns a boolean indicating whether the SV contains a character string.
1444 Checks the B<private> setting. Use C<SvPOK>.
1450 Unsets the PV status of an SV.
1452 void SvPOK_off(SV* sv)
1456 Tells an SV that it is a string.
1458 void SvPOK_on(SV* sv)
1462 Tells an SV that it is a string and disables all other OK bits.
1464 void SvPOK_only(SV* sv)
1468 Returns a pointer to the string in the SV, or a stringified form of the SV
1469 if the SV does not contain a string. Handles 'get' magic.
1471 char* SvPV(SV* sv, STRLEN len)
1475 Returns a pointer to the string in the SV. The SV must contain a
1482 Like <SvPV> but will force the SV into becoming a string (SvPOK). You want
1483 force if you are going to update the SvPVX directly.
1485 char* SvPV_force(SV* sv, STRLEN len)
1489 Returns a pointer to the string in the SV, or a stringified form of the SV
1490 if the SV does not contain a string. Handles 'get' magic.
1492 char* SvPV_nolen(SV* sv)
1496 Returns the value of the object's reference count.
1498 U32 SvREFCNT(SV* sv)
1502 Decrements the reference count of the given SV.
1504 void SvREFCNT_dec(SV* sv)
1508 Increments the reference count of the given SV.
1510 SV* SvREFCNT_inc(SV* sv)
1514 Tests if the SV is an RV.
1520 Unsets the RV status of an SV.
1522 void SvROK_off(SV* sv)
1526 Tells an SV that it is an RV.
1528 void SvROK_on(SV* sv)
1532 Dereferences an RV to return the SV.
1538 Invokes C<mg_set> on an SV if it has 'set' magic. This macro evaluates its
1539 argument more than once.
1541 void SvSETMAGIC(SV* sv)
1545 Calls C<sv_setsv> if dsv is not the same as ssv. May evaluate arguments
1548 void SvSetSV(SV* dsb, SV* ssv)
1550 =item SvSetSV_nosteal
1552 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
1553 ssv. May evaluate arguments more than once.
1555 void SvSetSV_nosteal(SV* dsv, SV* ssv)
1559 Returns the stash of the SV.
1565 Taints an SV if tainting is enabled
1567 void SvTAINT(SV* sv)
1571 Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
1574 bool SvTAINTED(SV* sv)
1578 Untaints an SV. Be I<very> careful with this routine, as it short-circuits
1579 some of Perl's fundamental security features. XS module authors should not
1580 use this function unless they fully understand all the implications of
1581 unconditionally untainting the value. Untainting should be done in the
1582 standard perl fashion, via a carefully crafted regexp, rather than directly
1583 untainting variables.
1585 void SvTAINTED_off(SV* sv)
1589 Marks an SV as tainted.
1591 void SvTAINTED_on(SV* sv)
1595 Returns a boolean indicating whether Perl would evaluate the SV as true or
1596 false, defined or undefined. Does not handle 'get' magic.
1602 An enum of flags for Perl types. These are found in the file B<sv.h>
1603 in the C<svtype> enum. Test these flags with the C<SvTYPE> macro.
1607 Returns the type of the SV. See C<svtype>.
1609 svtype SvTYPE(SV* sv)
1613 Integer type flag for scalars. See C<svtype>.
1617 Double type flag for scalars. See C<svtype>.
1621 Pointer type flag for scalars. See C<svtype>.
1625 Type flag for arrays. See C<svtype>.
1629 Type flag for code refs. See C<svtype>.
1633 Type flag for hashes. See C<svtype>.
1637 Type flag for blessed scalars. See C<svtype>.
1641 Used to upgrade an SV to a more complex form. Uses C<sv_upgrade> to
1642 perform the upgrade if necessary. See C<svtype>.
1644 void SvUPGRADE(SV* sv, svtype type)
1648 Coerces the given SV to an unsigned integer and returns it.
1654 Returns the unsigned integer which is stored in the SV, assuming SvIOK is
1661 Marks an SV as mortal. The SV will be destroyed when the current context
1664 SV* sv_2mortal(SV* sv)
1668 Blesses an SV into a specified package. The SV must be an RV. The package
1669 must be designated by its stash (see C<gv_stashpv()>). The reference count
1670 of the SV is unaffected.
1672 SV* sv_bless(SV* sv, HV* stash)
1676 Concatenates the string onto the end of the string which is in the SV.
1677 Handles 'get' magic, but not 'set' magic. See C<sv_catpv_mg>.
1679 void sv_catpv(SV* sv, const char* ptr)
1683 Processes its arguments like C<sprintf> and appends the formatted output
1684 to an SV. Handles 'get' magic, but not 'set' magic. C<SvSETMAGIC()> must
1685 typically be called after calling this function to handle 'set' magic.
1687 void sv_catpvf(SV* sv, const char* pat, ...)
1691 Like C<sv_catpvf>, but also handles 'set' magic.
1693 void sv_catpvf_mg(SV *sv, const char* pat, ...)
1697 Concatenates the string onto the end of the string which is in the SV. The
1698 C<len> indicates number of bytes to copy. Handles 'get' magic, but not
1699 'set' magic. See C<sv_catpvn_mg>.
1701 void sv_catpvn(SV* sv, const char* ptr, STRLEN len)
1705 Like C<sv_catpvn>, but also handles 'set' magic.
1707 void sv_catpvn_mg(SV *sv, const char *ptr, STRLEN len)
1711 Like C<sv_catpv>, but also handles 'set' magic.
1713 void sv_catpv_mg(SV *sv, const char *ptr)
1717 Concatenates the string from SV C<ssv> onto the end of the string in SV
1718 C<dsv>. Handles 'get' magic, but not 'set' magic. See C<sv_catsv_mg>.
1720 void sv_catsv(SV* dsv, SV* ssv)
1724 Like C<sv_catsv>, but also handles 'set' magic.
1726 void sv_catsv_mg(SV *dstr, SV *sstr)
1730 Efficient removal of characters from the beginning of the string buffer.
1731 SvPOK(sv) must be true and the C<ptr> must be a pointer to somewhere inside
1732 the string buffer. The C<ptr> becomes the first character of the adjusted
1735 void sv_chop(SV* sv, char* ptr)
1739 Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the
1740 string in C<sv1> is less than, equal to, or greater than the string in
1743 I32 sv_cmp(SV* sv1, SV* sv2)
1747 Auto-decrement of the value in the SV.
1751 =item sv_derived_from
1753 Returns a boolean indicating whether the SV is derived from the specified
1754 class. This is the function that implements C<UNIVERSAL::isa>. It works
1755 for class names as well as for objects.
1757 bool sv_derived_from(SV* sv, const char* name)
1761 Returns a boolean indicating whether the strings in the two SVs are
1764 I32 sv_eq(SV* sv1, SV* sv2)
1768 Expands the character buffer in the SV. This will use C<sv_unref> and will
1769 upgrade the SV to C<SVt_PV>. Returns a pointer to the character buffer.
1772 char* sv_grow(SV* sv, STRLEN newlen)
1776 Auto-increment of the value in the SV.
1782 Inserts a string at the specified offset/length within the SV. Similar to
1783 the Perl substr() function.
1785 void sv_insert(SV* bigsv, STRLEN offset, STRLEN len, char* little, STRLEN littlelen)
1789 Returns a boolean indicating whether the SV is blessed into the specified
1790 class. This does not check for subtypes; use C<sv_derived_from> to verify
1791 an inheritance relationship.
1793 int sv_isa(SV* sv, const char* name)
1797 Returns a boolean indicating whether the SV is an RV pointing to a blessed
1798 object. If the SV is not an RV, or if the object is not blessed, then this
1801 int sv_isobject(SV* sv)
1805 Returns the length of the string in the SV. See also C<SvCUR>.
1807 STRLEN sv_len(SV* sv)
1811 Adds magic to an SV.
1813 void sv_magic(SV* sv, SV* obj, int how, const char* name, I32 namlen)
1817 Creates a new SV which is a copy of the original SV. The new SV is marked
1820 SV* sv_mortalcopy(SV* oldsv)
1824 Creates a new SV which is mortal. The reference count of the SV is set to 1.
1830 Copies an integer into the given SV. Does not handle 'set' magic. See
1833 void sv_setiv(SV* sv, IV num)
1837 Like C<sv_setiv>, but also handles 'set' magic.
1839 void sv_setiv_mg(SV *sv, IV i)
1843 Copies a double into the given SV. Does not handle 'set' magic. See
1846 void sv_setnv(SV* sv, NV num)
1850 Like C<sv_setnv>, but also handles 'set' magic.
1852 void sv_setnv_mg(SV *sv, NV num)
1856 Copies a string into an SV. The string must be null-terminated. Does not
1857 handle 'set' magic. See C<sv_setpv_mg>.
1859 void sv_setpv(SV* sv, const char* ptr)
1863 Processes its arguments like C<sprintf> and sets an SV to the formatted
1864 output. Does not handle 'set' magic. See C<sv_setpvf_mg>.
1866 void sv_setpvf(SV* sv, const char* pat, ...)
1870 Like C<sv_setpvf>, but also handles 'set' magic.
1872 void sv_setpvf_mg(SV *sv, const char* pat, ...)
1876 Copies an integer into the given SV, also updating its string value.
1877 Does not handle 'set' magic. See C<sv_setpviv_mg>.
1879 void sv_setpviv(SV* sv, IV num)
1883 Like C<sv_setpviv>, but also handles 'set' magic.
1885 void sv_setpviv_mg(SV *sv, IV iv)
1889 Copies a string into an SV. The C<len> parameter indicates the number of
1890 bytes to be copied. Does not handle 'set' magic. See C<sv_setpvn_mg>.
1892 void sv_setpvn(SV* sv, const char* ptr, STRLEN len)
1896 Like C<sv_setpvn>, but also handles 'set' magic.
1898 void sv_setpvn_mg(SV *sv, const char *ptr, STRLEN len)
1902 Like C<sv_setpv>, but also handles 'set' magic.
1904 void sv_setpv_mg(SV *sv, const char *ptr)
1908 Copies an integer into a new SV, optionally blessing the SV. The C<rv>
1909 argument will be upgraded to an RV. That RV will be modified to point to
1910 the new SV. The C<classname> argument indicates the package for the
1911 blessing. Set C<classname> to C<Nullch> to avoid the blessing. The new SV
1912 will be returned and will have a reference count of 1.
1914 SV* sv_setref_iv(SV* rv, const char* classname, IV iv)
1918 Copies a double into a new SV, optionally blessing the SV. The C<rv>
1919 argument will be upgraded to an RV. That RV will be modified to point to
1920 the new SV. The C<classname> argument indicates the package for the
1921 blessing. Set C<classname> to C<Nullch> to avoid the blessing. The new SV
1922 will be returned and will have a reference count of 1.
1924 SV* sv_setref_nv(SV* rv, const char* classname, NV nv)
1928 Copies a pointer into a new SV, optionally blessing the SV. The C<rv>
1929 argument will be upgraded to an RV. That RV will be modified to point to
1930 the new SV. If the C<pv> argument is NULL then C<PL_sv_undef> will be placed
1931 into the SV. The C<classname> argument indicates the package for the
1932 blessing. Set C<classname> to C<Nullch> to avoid the blessing. The new SV
1933 will be returned and will have a reference count of 1.
1935 Do not use with other Perl types such as HV, AV, SV, CV, because those
1936 objects will become corrupted by the pointer copy process.
1938 Note that C<sv_setref_pvn> copies the string while this copies the pointer.
1940 SV* sv_setref_pv(SV* rv, const char* classname, void* pv)
1944 Copies a string into a new SV, optionally blessing the SV. The length of the
1945 string must be specified with C<n>. The C<rv> argument will be upgraded to
1946 an RV. That RV will be modified to point to the new SV. The C<classname>
1947 argument indicates the package for the blessing. Set C<classname> to
1948 C<Nullch> to avoid the blessing. The new SV will be returned and will have
1949 a reference count of 1.
1951 Note that C<sv_setref_pv> copies the pointer while this copies the string.
1953 SV* sv_setref_pvn(SV* rv, const char* classname, char* pv, STRLEN n)
1957 Copies the contents of the source SV C<ssv> into the destination SV C<dsv>.
1958 The source SV may be destroyed if it is mortal. Does not handle 'set'
1959 magic. See the macro forms C<SvSetSV>, C<SvSetSV_nosteal> and
1962 void sv_setsv(SV* dsv, SV* ssv)
1966 Like C<sv_setsv>, but also handles 'set' magic.
1968 void sv_setsv_mg(SV *dstr, SV *sstr)
1972 Copies an unsigned integer into the given SV. Does not handle 'set' magic.
1975 void sv_setuv(SV* sv, UV num)
1979 Like C<sv_setuv>, but also handles 'set' magic.
1981 void sv_setuv_mg(SV *sv, UV u)
1985 Unsets the RV status of the SV, and decrements the reference count of
1986 whatever was being referenced by the RV. This can almost be thought of
1987 as a reversal of C<newSVrv>. See C<SvROK_off>.
1989 void sv_unref(SV* sv)
1993 Upgrade an SV to a more complex form. Use C<SvUPGRADE>. See
1996 bool sv_upgrade(SV* sv, U32 mt)
2000 Tells an SV to use C<ptr> to find its string value. Normally the string is
2001 stored inside the SV but sv_usepvn allows the SV to use an outside string.
2002 The C<ptr> should point to memory that was allocated by C<malloc>. The
2003 string length, C<len>, must be supplied. This function will realloc the
2004 memory pointed to by C<ptr>, so that pointer should not be freed or used by
2005 the programmer after giving it to sv_usepvn. Does not handle 'set' magic.
2006 See C<sv_usepvn_mg>.
2008 void sv_usepvn(SV* sv, char* ptr, STRLEN len)
2012 Like C<sv_usepvn>, but also handles 'set' magic.
2014 void sv_usepvn_mg(SV *sv, char *ptr, STRLEN len)
2018 Processes its arguments like C<vsprintf> and appends the formatted output
2019 to an SV. Uses an array of SVs if the C style variable argument list is
2020 missing (NULL). When running with taint checks enabled, indicates via
2021 C<maybe_tainted> if results are untrustworthy (often due to the use of
2024 void sv_vcatpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
2028 Works like C<vcatpvfn> but copies the text into the SV instead of
2031 void sv_vsetpvfn(SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
2035 Variable which is setup by C<xsubpp> to designate the object in a C++
2036 XSUB. This is always the proper type for the C++ object. See C<CLASS> and
2037 L<perlxs/"Using XS With C++">.
2043 Converts the specified character to lowercase.
2045 char toLOWER(char ch)
2049 Converts the specified character to uppercase.
2051 char toUPPER(char ch)
2055 This is the XSUB-writer's interface to Perl's C<warn> function. Use this
2056 function the same way you use the C C<printf> function. See
2059 void warn(const char* pat, ...)
2063 Push an integer onto the stack, extending the stack if necessary. Handles
2064 'set' magic. See C<PUSHi>.
2070 Push a double onto the stack, extending the stack if necessary. Handles
2071 'set' magic. See C<PUSHn>.
2077 Push a string onto the stack, extending the stack if necessary. The C<len>
2078 indicates the length of the string. Handles 'set' magic. See
2081 void XPUSHp(char* str, STRLEN len)
2085 Push an SV onto the stack, extending the stack if necessary. Does not
2086 handle 'set' magic. See C<PUSHs>.
2092 Push an unsigned integer onto the stack, extending the stack if necessary.
2099 Macro to declare an XSUB and its C parameter list. This is handled by
2104 Return from XSUB, indicating number of items on the stack. This is usually
2105 handled by C<xsubpp>.
2107 void XSRETURN(int nitems)
2109 =item XSRETURN_EMPTY
2111 Return an empty list from an XSUB immediately.
2117 Return an integer from an XSUB immediately. Uses C<XST_mIV>.
2119 void XSRETURN_IV(IV iv)
2123 Return C<&PL_sv_no> from an XSUB immediately. Uses C<XST_mNO>.
2129 Return an double from an XSUB immediately. Uses C<XST_mNV>.
2131 void XSRETURN_NV(NV nv)
2135 Return a copy of a string from an XSUB immediately. Uses C<XST_mPV>.
2137 void XSRETURN_PV(char* str)
2139 =item XSRETURN_UNDEF
2141 Return C<&PL_sv_undef> from an XSUB immediately. Uses C<XST_mUNDEF>.
2147 Return C<&PL_sv_yes> from an XSUB immediately. Uses C<XST_mYES>.
2153 Place an integer into the specified position C<pos> on the stack. The
2154 value is stored in a new mortal SV.
2156 void XST_mIV(int pos, IV iv)
2160 Place C<&PL_sv_no> into the specified position C<pos> on the
2163 void XST_mNO(int pos)
2167 Place a double into the specified position C<pos> on the stack. The value
2168 is stored in a new mortal SV.
2170 void XST_mNV(int pos, NV nv)
2174 Place a copy of a string into the specified position C<pos> on the stack.
2175 The value is stored in a new mortal SV.
2177 void XST_mPV(int pos, char* str)
2181 Place C<&PL_sv_undef> into the specified position C<pos> on the
2184 void XST_mUNDEF(int pos)
2188 Place C<&PL_sv_yes> into the specified position C<pos> on the
2191 void XST_mYES(int pos)
2195 The version identifier for an XS module. This is usually
2196 handled automatically by C<ExtUtils::MakeMaker>. See C<XS_VERSION_BOOTCHECK>.
2198 =item XS_VERSION_BOOTCHECK
2200 Macro to verify that a PM module's $VERSION variable matches the XS
2201 module's C<XS_VERSION> variable. This is usually handled automatically by
2202 C<xsubpp>. See L<perlxs/"The VERSIONCHECK: Keyword">.
2204 XS_VERSION_BOOTCHECK;
2208 The XSUB-writer's interface to the C C<memzero> function. The C<dest> is the
2209 destination, C<nitems> is the number of items, and C<type> is the type.
2211 void Zero(void* dest, int nitems, type)
2217 Until May 1997, this document was maintained by Jeff Okamoto
2218 <okamoto@corp.hp.com>. It is now maintained as part of Perl itself.
2220 With lots of help and suggestions from Dean Roehrich, Malcolm Beattie,
2221 Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil
2222 Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer,
2223 Stephen McCamant, and Gurusamy Sarathy.
2225 API Listing originally by Dean Roehrich <roehrich@cray.com>.
2227 Updated to be autogenerated from comments in the source by Benjamin Stuhl.
2231 perlguts(1), perlxs(1), perlxstut(1), perlintern(1)