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
The arguments of C<sv_setpvf> are processed like C<sprintf>, and the
formatted output becomes the value.
-C<sv_setpvfn> is an analogue of C<vsprintf>, but it allows you to specify
+C<sv_vsetpvfn> is an analogue of C<vsprintf>, 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
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
Perl provides the function C<sv_chop> 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<sv_chop> sets the flag C<OOK>
(offset OK) to signal to other functions that the offset hack is in
/* 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,
=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.
=head2 Magic Virtual Tables
-The C<mg_virtual> field in the C<MAGIC> structure is a pointer to a
+The C<mg_virtual> field in the C<MAGIC> structure is a pointer to an
C<MGVTBL>, 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.
=item C<SV* save_svref(SV **sptr)>
-Similar to C<save_scalar>, but will reinstate a C<SV *>.
+Similar to C<save_scalar>, but will reinstate an C<SV *>.
=item C<void save_aptr(AV **aptr)>
module should already be familiar with its format.
C<Perl_op_dump> can be used to dump an C<OP> structure or any of its
-derivatives, and produces output simil
iar to C<perl -Dx>; in fact,
+derivatives, and produces output similar to C<perl -Dx>; in fact,
C<Perl_dump_eval> will dump the main root of the code being evaluated,
exactly like C<-Dx>.
for feeding it code or otherwise making it do things, but it also has
functions for its own use. This smells a lot like an object, and
there are ways for you to build Perl so that you can have multiple
-interpreters, with one interpreter represented either as a C++ object,
-a C structure, or inside a thread. The thread, the C structure, or
-the C++ object will contain all the context, the state of that
-interpreter.
-
-Three macros control the major Perl build flavors: MULTIPLICITY,
-USE_THREADS and PERL_OBJECT. The MULTIPLICITY build has a C structure
-that packages all the interpreter state, there is a similar thread-specific
-data structure under USE_THREADS, and the (now deprecated) PERL_OBJECT
-build has a C++ class to maintain interpreter state. In all three cases,
+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
+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,
PERL_IMPLICIT_CONTEXT is also normally defined, and enables the
support for passing in a "hidden" first argument that represents all three
data structures.
All this obviously requires a way for the Perl internal functions to be
-C++ methods, subroutines taking some kind of structure as the first
+either subroutines taking some kind of structure as the first
argument, or subroutines taking nothing as the first argument. To
-enable these three very different ways of building the interpreter,
+enable these two very different ways of building the interpreter,
the Perl source (as it does in so many other situations) makes heavy
use of macros and subroutine naming conventions.
STATIC void
S_incline(pTHX_ char *s)
-STATIC becomes "static" in C, and is #define'd to nothing in C++.
+STATIC becomes "static" in C, and may be #define'd to nothing in some
+configurations in future.
A public function (i.e. part of the internal API, but not necessarily
sanctioned for use in extensions) begins like this:
and still have it work under all the modes Perl could have been
compiled with.
-Under PERL_OBJECT in the core, that will translate to either:
-
- CPerlObj::Perl_sv_setsv(foo,bar); # in CPerlObj functions,
- # C++ takes care of 'this'
- or
-
- pPerl->Perl_sv_setsv(foo,bar); # in truly static functions,
- # see objXSUB.h
-
-Under PERL_OBJECT in extensions (aka PERL_CAPI), or under
-MULTIPLICITY/USE_THREADS with PERL_IMPLICIT_CONTEXT in both core
-and extensions, it will become:
-
- Perl_sv_setsv(aTHX_ foo, bar); # the canonical Perl "API"
- # for all build flavors
-
This doesn't work so cleanly for varargs functions, though, as macros
imply that the number of arguments is known in advance. Instead we
either need to spell them out fully, passing C<aTHX_> as the first
compatibility at the expense of performance. (Passing an arg is
cheaper than grabbing it from thread-local storage.)
-You can ignore [pad]THX[xo] when browsing the Perl headers/sources.
+You can ignore [pad]THXx when browsing the Perl headers/sources.
Those are strictly for use within the core. Extensions and embedders
need only be aware of [pad]THX.
that the interpreter knows about itself and pass it around, so too are
there plans to allow the interpreter to bundle up everything it knows
about the environment it's running on. This is enabled with the
-PERL_IMPLICIT_SYS macro. Currently it only works with PERL_OBJECT
-and USE_THREADS on Windows (see inside iperlsys.h).
+PERL_IMPLICIT_SYS macro. Currently it only works with USE_ITHREADS
+and USE_5005THREADS on Windows (see inside iperlsys.h).
This allows the ability to provide an extra pointer (called the "host"
environment) for all the system calls. This makes it possible for
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<gvsv, gvsv, add>.) Currently, this feature must be enabled with the C
-flag C<-DPERL_CUSTOM_OPS>.
+C<gvsv, gvsv, add>.)
-Enabling the feature will create a new op type, C<OP_CUSTOM>. The Perl
+This feature is implemented as a new op type, C<OP_CUSTOM>. 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
https://perl5.git.perl.org / perl5.git / blobdiff