X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlguts.pod;h=83ed06860444bcd1e3b4bddd7476e32630c7017d;hb=cccede5366275457276b68bb148b7872098aaf29;hp=8b116532cb08621dd6c253b2652a6789ce379dad;hpb=acfe0abcedaf592fb4b9cb69ce3468308ae99d91;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlguts.pod b/pod/perlguts.pod index 8b11653..83ed068 100644 --- a/pod/perlguts.pod +++ b/pod/perlguts.pod @@ -29,24 +29,34 @@ Additionally, there is the UV, which is simply an unsigned IV. Perl also uses two special typedefs, I32 and I16, which will always be at least 32-bits and 16-bits long, respectively. (Again, there are U32 and U16, -as well.) +as well.) They will usually be exactly 32 and 16 bits long, but on Crays +they will both be 64 bits. =head2 Working with SVs -An SV can be created and loaded with one command. There are four types of -values that can be loaded: an integer value (IV), a double (NV), -a string (PV), and another scalar (SV). +An SV can be created and loaded with one command. There are five types of +values that can be loaded: an integer value (IV), an unsigned integer +value (UV), a double (NV), a string (PV), and another scalar (SV). -The six routines are: +The seven routines are: SV* newSViv(IV); + SV* newSVuv(UV); SV* newSVnv(double); SV* newSVpv(const char*, int); SV* newSVpvn(const char*, int); SV* newSVpvf(const char*, ...); SV* newSVsv(SV*); -To change the value of an *already-existing* SV, there are seven routines: +If you require more complex initialisation you can create an empty SV with +newSV(len). If C is 0 an empty SV of type NULL is returned, else an +SV of type PV is returned with len + 1 (for the NUL) bytes of storage +allocated, accessible via SvPVX. In both cases the SV has value undef. + + SV* newSV(0); /* no storage allocated */ + SV* newSV(10); /* 10 (+1) bytes of uninitialised storage allocated */ + +To change the value of an *already-existing* SV, there are eight routines: void sv_setiv(SV*, IV); void sv_setuv(SV*, UV); @@ -54,7 +64,7 @@ To change the value of an *already-existing* SV, there are seven routines: void sv_setpv(SV*, const char*); void sv_setpvn(SV*, const char*, int) void sv_setpvf(SV*, const char*, ...); - void sv_setpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool); + void sv_vsetpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool *); void sv_setsv(SV*, SV*); Notice that you can choose to specify the length of the string to be @@ -67,7 +77,7 @@ string terminating with a NUL character. The arguments of C are processed like C, and the formatted output becomes the value. -C is an analogue of C, but it allows you to specify +C is an analogue of C, but it allows you to specify either a pointer to a variable argument list or the address and length of an array of SVs. The last argument points to a boolean; on return, if that boolean is true, then locale-specific information has been used to format @@ -162,7 +172,7 @@ you can use the following functions: void sv_catpv(SV*, const char*); void sv_catpvn(SV*, const char*, STRLEN); void sv_catpvf(SV*, const char*, ...); - void sv_catpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool); + void sv_vcatpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool); void sv_catsv(SV*, SV*); The first function calculates the length of the string to be appended by @@ -218,7 +228,7 @@ call is not necessary (see L). Perl provides the function C to efficiently remove characters from the beginning of a string; you give it an SV and a pointer to -somewhere inside the the PV, and it discards everything before the +somewhere inside the PV, and it discards everything before the pointer. The efficiency comes by means of a little hack: instead of actually removing the characters, C sets the flag C (offset OK) to signal to other functions that the offset hack is in @@ -247,7 +257,7 @@ portion of the string between the "real" and the "fake" beginnings is shown in parentheses, and the values of C and C reflect the fake beginning, not the real one. -Something similar to the offset hack is perfomed on AVs to enable +Something similar to the offset hack is performed on AVs to enable efficient shifting and splicing off the beginning of the array; while C points to the first element in the array that is visible from Perl, C points to the real start of the C array. These are @@ -405,7 +415,7 @@ specified below. /* Get the key from an HE structure and also return the length of the key string */ SV* hv_iterval(HV*, HE* entry); - /* Return a SV pointer to the value of the HE + /* Return an SV pointer to the value of the HE structure */ SV* hv_iternextsv(HV*, char** key, I32* retlen); /* This convenience routine combines hv_iternext, @@ -599,17 +609,32 @@ be set, using the routines appropriate to the data type. There are additional macros whose values may be bitwise OR'ed with the C argument to enable certain extra features. Those bits are: - GV_ADDMULTI Marks the variable as multiply defined, thus preventing the - "Name used only once: possible typo" warning. - GV_ADDWARN Issues the warning "Had to create unexpectedly" if - the variable did not exist before the function was called. +=over + +=item GV_ADDMULTI + +Marks the variable as multiply defined, thus preventing the: + + Name used only once: possible typo + +warning. + +=item GV_ADDWARN + +Issues the warning: + + Had to create unexpectedly + +if the variable did not exist before the function was called. + +=back If you do not specify a package name, the variable is created in the current package. =head2 Reference Counts and Mortality -Perl uses an reference count-driven garbage collection mechanism. SVs, +Perl uses a reference count-driven garbage collection mechanism. SVs, AVs, or HVs (xV for short in the following) start their life with a reference count of 1. If the reference count of an xV ever drops to 0, then it will be destroyed and its memory made available for reuse. @@ -674,7 +699,7 @@ The first call creates a mortal SV (with no value), the second converts an exist SV to a mortal SV (and thus defers a call to C), and the third creates a mortal copy of an existing SV. Because C gives the new SV no value,it must normally be given one -via C, C etc. : +via C, C, etc. : SV *tmp = sv_newmortal(); sv_setiv(tmp, an_integer); @@ -833,7 +858,7 @@ SV. The C and C arguments are used to associate a string with the magic, typically the name of a variable. C is stored in the -C field and if C is non-null and C >= 0 a malloc'd +C field and if C is non-null and C E= 0 a malloc'd copy of the name is stored in C field. The sv_magic function uses C to determine which, if any, predefined @@ -843,7 +868,7 @@ stored in the C field. The value of C should be chosen from the set of macros C found perl.h. Note that before these macros were added, Perl internals used to directly use character literals, so you may occasionally come across old code or documentation -referrring to 'U' magic rather than C for example. +referring to 'U' magic rather than C for example. The C argument is stored in the C field of the C structure. If it is not the same as the C argument, the reference @@ -866,7 +891,7 @@ was initially made magical. =head2 Magic Virtual Tables -The C field in the C structure is a pointer to a +The C field in the C structure is a pointer to an C, which is a structure of function pointers and stands for "Magic Virtual Table" to handle the various operations that might be applied to that variable. @@ -886,7 +911,7 @@ actions depending on which function is being called. Function pointer Action taken ---------------- ------------ - svt_get Do something after the value of the SV is retrieved. + svt_get Do something before the value of the SV is retrieved. svt_set Do something after the SV is assigned a value. svt_len Report on the SV's length. svt_clear Clear something the SV represents. @@ -938,6 +963,8 @@ The current kinds of Magic Virtual Tables are: t PERL_MAGIC_taint vtbl_taint Taintedness U PERL_MAGIC_uvar vtbl_uvar Available for use by extensions v PERL_MAGIC_vec vtbl_vec vec() lvalue + V PERL_MAGIC_vstring (none) v-string scalars + w PERL_MAGIC_utf8 vtbl_utf8 UTF-8 length+offset cache x PERL_MAGIC_substr vtbl_substr substr() lvalue y PERL_MAGIC_defelem vtbl_defelem Shadow "foreach" iterator variable / smart parameter @@ -949,10 +976,10 @@ The current kinds of Magic Virtual Tables are: ~ PERL_MAGIC_ext (none) Available for use by extensions When an uppercase and lowercase letter both exist in the table, then the -uppercase letter is used to represent some kind of composite type (a list -or a hash), and the lowercase letter is used to represent an element of -that composite type. Some internals code makes use of this case -relationship. +uppercase letter is typically used to represent some kind of composite type +(a list or a hash), and the lowercase letter is used to represent an element +of that composite type. Some internals code makes use of this case +relationship. However, 'v' and 'V' (vec and v-string) are in no way related. The C and C magic types are defined specifically for use by extensions and will not be used by perl itself. @@ -1034,7 +1061,7 @@ you find yourself actually applying such information in this section, be aware that the behavior may change in the future, umm, without warning. The perl tie function associates a variable with an object that implements -the various GET, SET etc methods. To perform the equivalent of the perl +the various GET, SET, etc methods. To perform the equivalent of the perl tie function from an XSUB, you must mimic this behaviour. The code below carries out the necessary steps - firstly it creates a new hash, and then creates a second hash which it blesses into the class which will implement @@ -1128,7 +1155,7 @@ This construction is I equivalent to The biggest difference is that the first construction would reinstate the initial value of $var, irrespective of how control exits -the block: C, C, C/C etc. It is a little bit +the block: C, C, C/C, etc. It is a little bit more efficient as well. There is a way to achieve a similar task from C via Perl API: create a @@ -1255,7 +1282,7 @@ C of C of length C. =item C -Similar to C, but will reinstate a C. +Similar to C, but will reinstate an C. =item C @@ -1342,7 +1369,7 @@ trapped, and how to treat return values. All four routines return the number of arguments that the subroutine returned on the Perl stack. -These routines used to be called C etc., before Perl v5.6.0, +These routines used to be called C, etc., before Perl v5.6.0, but those names are now deprecated; macros of the same name are provided for compatibility. @@ -1490,7 +1517,7 @@ the scratchpad AV. In fact it contains a pointer to an AV of (initially) one element, and this element is the scratchpad AV. Why do we need an extra level of indirection? -The answer is B, and maybe (sometime soon) B. Both +The answer is B, and maybe B. Both these can create several execution pointers going into the same subroutine. For the subroutine-child not write over the temporaries for the subroutine-parent (lifespan of which covers the call to the @@ -1695,7 +1722,7 @@ C to produce debugging output from Perl-space, so users of that module should already be familiar with its format. C can be used to dump an C structure or any of its -derivatives, and produces output similiar to C; in fact, +derivatives, and produces output similar to C; in fact, C will dump the main root of the code being evaluated, exactly like C<-Dx>. @@ -1731,7 +1758,7 @@ interpreters, with one interpreter represented either as a C structure, or inside a thread-specific structure. These structures contain all the context, the state of that interpreter. -Three macros control the major Perl build flavors: MULTIPLICITY, and +Two macros control the major Perl build flavors: MULTIPLICITY and USE_5005THREADS. The MULTIPLICITY build has a C structure that packages all the interpreter state, and there is a similar thread-specific data structure under USE_5005THREADS. In both cases, @@ -1772,7 +1799,7 @@ A public function (i.e. part of the internal API, but not necessarily sanctioned for use in extensions) begins like this: void - Perl_sv_setsv(pTHX_ SV* dsv, SV* ssv) + Perl_sv_setiv(pTHX_ SV* dsv, IV num) C is one of a number of macros (in perl.h) that hide the details of the interpreter's context. THX stands for "thread", "this", @@ -1791,19 +1818,19 @@ macro without the trailing underscore is used when there are no additional explicit arguments. When a core function calls another, it must pass the context. This -is normally hidden via macros. Consider C. It expands into +is normally hidden via macros. Consider C. It expands into something like this: - ifdef PERL_IMPLICIT_CONTEXT - define sv_setsv(a,b) Perl_sv_setsv(aTHX_ a, b) + #ifdef PERL_IMPLICIT_CONTEXT + #define sv_setiv(a,b) Perl_sv_setiv(aTHX_ a, b) /* can't do this for vararg functions, see below */ - else - define sv_setsv Perl_sv_setsv - endif + #else + #define sv_setiv Perl_sv_setiv + #endif This works well, and means that XS authors can gleefully write: - sv_setsv(foo, bar); + sv_setiv(foo, bar); and still have it work under all the modes Perl could have been compiled with. @@ -1847,16 +1874,16 @@ with extensions: whenever XSUB.h is #included, it redefines the aTHX and aTHX_ macros to call a function that will return the context. Thus, something like: - sv_setsv(asv, bsv); + sv_setiv(sv, num); in your extension will translate to this when PERL_IMPLICIT_CONTEXT is in effect: - Perl_sv_setsv(Perl_get_context(), asv, bsv); + Perl_sv_setiv(Perl_get_context(), sv, num); or to this otherwise: - Perl_sv_setsv(asv, bsv); + Perl_sv_setiv(sv, num); You have to do nothing new in your extension to get this; since the Perl library provides Perl_get_context(), it will all just @@ -2205,13 +2232,15 @@ C, which takes a string and a number of characters to skip over. You're on your own about bounds checking, though, so don't use it lightly. -All bytes in a multi-byte UTF8 character will have the high bit set, so -you can test if you need to do something special with this character -like this: +All bytes in a multi-byte UTF8 character will have the high bit set, +so you can test if you need to do something special with this +character like this (the UTF8_IS_INVARIANT() is a macro that tests +whether the byte can be encoded as a single byte even in UTF-8): - UV uv; + U8 *utf; + UV uv; /* Note: a UV, not a U8, not a char */ - if (utf & 0x80) + if (!UTF8_IS_INVARIANT(*utf)) /* Must treat this as UTF8 */ uv = utf8_to_uv(utf); else @@ -2222,7 +2251,7 @@ You can also see in that example that we use C to get the value of the character; the inverse function C is available for putting a UV into UTF8: - if (uv > 0x80) + if (!UTF8_IS_INVARIANT(uv)) /* Must treat this as UTF8 */ utf8 = uv_to_utf8(utf8, uv); else @@ -2284,6 +2313,10 @@ In fact, your C function should be made aware of whether or not it's dealing with UTF8 data, so that it can handle the string appropriately. +Since just passing an SV to an XS function and copying the data of +the SV is not enough to copy the UTF8 flags, even less right is just +passing a C to an XS function. + =head2 How do I convert a string to UTF8? If you're mixing UTF8 and non-UTF8 strings, you might find it necessary @@ -2324,12 +2357,13 @@ it's not - if you pass on the PV to somewhere, pass on the flag too. =item * If a string is UTF8, B use C to get at the value, -unless C in which case you can use C<*s>. +unless C in which case you can use C<*s>. =item * -When writing to a UTF8 string, B use C, unless -C in which case you can use C<*s = uv>. +When writing a character C to a UTF8 string, B use +C, unless C in which case +you can use C<*s = uv>. =item * @@ -2342,15 +2376,14 @@ high character - C is one of those. =head1 Custom Operators -Custom operator support is a new experimental feature that allows you do +Custom operator support is a new experimental feature that allows you to define your own ops. This is primarily to allow the building of interpreters for other languages in the Perl core, but it also allows optimizations through the creation of "macro-ops" (ops which perform the functions of multiple ops which are usually executed together, such as -C.) Currently, this feature must be enabled with the C -flag C<-DPERL_CUSTOM_OPS>. +C.) -Enabling the feature will create a new op type, C. The Perl +This feature is implemented as a new op type, C. The Perl core does not "know" anything special about this op type, and so it will not be involved in any optimizations. This also means that you can define your custom ops to be any op structure - unary, binary, list and @@ -2387,15 +2420,15 @@ the Perl interpreter. =head1 AUTHORS Until May 1997, this document was maintained by Jeff Okamoto -. It is now maintained as part of Perl itself -by the Perl 5 Porters . +Eokamoto@corp.hp.comE. It is now maintained as part of Perl +itself by the Perl 5 Porters Eperl5-porters@perl.orgE. With lots of help and suggestions from Dean Roehrich, Malcolm Beattie, Andreas Koenig, Paul Hudson, Ilya Zakharevich, Paul Marquess, Neil Bowers, Matthew Green, Tim Bunce, Spider Boardman, Ulrich Pfeifer, Stephen McCamant, and Gurusamy Sarathy. -API Listing originally by Dean Roehrich . +API Listing originally by Dean Roehrich Eroehrich@cray.comE. Modifications to autogenerate the API listing (L) by Benjamin Stuhl.