This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
run regen.pl after change #25274
[perl5.git] / pod / perlintern.pod
CommitLineData
954c1994
GS
1=head1 NAME
2
1c846c1f 3perlintern - autogenerated documentation of purely B<internal>
954c1994
GS
4 Perl functions
5
6=head1 DESCRIPTION
7
1c846c1f 8This file is the autogenerated documentation of functions in the
4375e838 9Perl interpreter that are documented using Perl's internal documentation
1c846c1f 10format but are not marked as part of the Perl API. In other words,
954c1994
GS
11B<they are not for use in extensions>!
12
a8586c98 13
7dafbf52
DM
14=head1 CV reference counts and CvOUTSIDE
15
16=over 8
17
18=item CvWEAKOUTSIDE
19
20Each CV has a pointer, C<CvOUTSIDE()>, to its lexically enclosing
21CV (if any). Because pointers to anonymous sub prototypes are
22stored in C<&> pad slots, it is a possible to get a circular reference,
23with the parent pointing to the child and vice-versa. To avoid the
24ensuing memory leak, we do not increment the reference count of the CV
25pointed to by C<CvOUTSIDE> in the I<one specific instance> that the parent
26has a C<&> pad slot pointing back to us. In this case, we set the
27C<CvWEAKOUTSIDE> flag in the child. This allows us to determine under what
28circumstances we should decrement the refcount of the parent when freeing
29the child.
30
28a5cf3b 31There is a further complication with non-closure anonymous subs (i.e. those
7dafbf52
DM
32that do not refer to any lexicals outside that sub). In this case, the
33anonymous prototype is shared rather than being cloned. This has the
34consequence that the parent may be freed while there are still active
35children, eg
36
37 BEGIN { $a = sub { eval '$x' } }
38
39In this case, the BEGIN is freed immediately after execution since there
40are no active references to it: the anon sub prototype has
41C<CvWEAKOUTSIDE> set since it's not a closure, and $a points to the same
42CV, so it doesn't contribute to BEGIN's refcount either. When $a is
43executed, the C<eval '$x'> causes the chain of C<CvOUTSIDE>s to be followed,
44and the freed BEGIN is accessed.
45
46To avoid this, whenever a CV and its associated pad is freed, any
47C<&> entries in the pad are explicitly removed from the pad, and if the
48refcount of the pointed-to anon sub is still positive, then that
49child's C<CvOUTSIDE> is set to point to its grandparent. This will only
50occur in the single specific case of a non-closure anon prototype
51having one or more active references (such as C<$a> above).
52
53One other thing to consider is that a CV may be merely undefined
54rather than freed, eg C<undef &foo>. In this case, its refcount may
55not have reached zero, but we still delete its pad and its C<CvROOT> etc.
56Since various children may still have their C<CvOUTSIDE> pointing at this
57undefined CV, we keep its own C<CvOUTSIDE> for the time being, so that
58the chain of lexical scopes is unbroken. For example, the following
59should print 123:
60
61 my $x = 123;
62 sub tmp { sub { eval '$x' } }
63 my $a = tmp();
64 undef &tmp;
65 print $a->();
66
67 bool CvWEAKOUTSIDE(CV *cv)
68
69=for hackers
70Found in file cv.h
71
72
73=back
74
dd2155a4
DM
75=head1 Functions in file pad.h
76
77
78=over 8
79
80=item CX_CURPAD_SAVE
81
82Save the current pad in the given context block structure.
83
84 void CX_CURPAD_SAVE(struct context)
85
86=for hackers
87Found in file pad.h
88
89=item CX_CURPAD_SV
90
91Access the SV at offset po in the saved current pad in the given
92context block structure (can be used as an lvalue).
93
f3548bdc 94 SV * CX_CURPAD_SV(struct context, PADOFFSET po)
dd2155a4
DM
95
96=for hackers
97Found in file pad.h
98
99=item PAD_BASE_SV
100
101Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
102
103 SV * PAD_BASE_SV (PADLIST padlist, PADOFFSET po)
104
105=for hackers
106Found in file pad.h
107
108=item PAD_CLONE_VARS
109
110|CLONE_PARAMS* param
111Clone the state variables associated with running and compiling pads.
112
113 void PAD_CLONE_VARS(PerlInterpreter *proto_perl \)
114
115=for hackers
116Found in file pad.h
117
118=item PAD_COMPNAME_FLAGS
119
120Return the flags for the current compiling pad name
121at offset C<po>. Assumes a valid slot entry.
122
123 U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
124
125=for hackers
126Found in file pad.h
127
128=item PAD_COMPNAME_GEN
129
130The generation number of the name at offset C<po> in the current
131compiling pad (lvalue). Note that C<SvCUR> is hijacked for this purpose.
132
133 STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
134
135=for hackers
136Found in file pad.h
137
27da23d5
JH
138=item PAD_COMPNAME_GEN_set
139
140Sets the generation number of the name at offset C<po> in the current
141ling pad (lvalue) to C<gen>. Note that C<SvCUR_set> is hijacked for this purpose.
142
143 STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
144
145=for hackers
146Found in file pad.h
147
dd2155a4
DM
148=item PAD_COMPNAME_OURSTASH
149
150Return the stash associated with an C<our> variable.
151Assumes the slot entry is a valid C<our> lexical.
152
153 HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
154
155=for hackers
156Found in file pad.h
157
158=item PAD_COMPNAME_PV
159
160Return the name of the current compiling pad name
161at offset C<po>. Assumes a valid slot entry.
162
163 char * PAD_COMPNAME_PV(PADOFFSET po)
164
165=for hackers
166Found in file pad.h
167
168=item PAD_COMPNAME_TYPE
169
170Return the type (stash) of the current compiling pad name at offset
171C<po>. Must be a valid name. Returns null if not typed.
172
173 HV * PAD_COMPNAME_TYPE(PADOFFSET po)
174
175=for hackers
176Found in file pad.h
177
178=item PAD_DUP
179
180Clone a padlist.
181
182 void PAD_DUP(PADLIST dstpad, PADLIST srcpad, CLONE_PARAMS* param)
183
184=for hackers
185Found in file pad.h
186
f3548bdc
DM
187=item PAD_RESTORE_LOCAL
188
189Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
190
191 void PAD_RESTORE_LOCAL(PAD *opad)
192
193=for hackers
194Found in file pad.h
195
196=item PAD_SAVE_LOCAL
197
198Save the current pad to the local variable opad, then make the
199current pad equal to npad
200
201 void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
202
203=for hackers
204Found in file pad.h
205
dd2155a4
DM
206=item PAD_SAVE_SETNULLPAD
207
208Save the current pad then set it to null.
209
210 void PAD_SAVE_SETNULLPAD()
211
212=for hackers
213Found in file pad.h
214
215=item PAD_SETSV
216
217Set the slot at offset C<po> in the current pad to C<sv>
218
219 SV * PAD_SETSV (PADOFFSET po, SV* sv)
220
221=for hackers
222Found in file pad.h
223
224=item PAD_SET_CUR
225
226Set the current pad to be pad C<n> in the padlist, saving
f54ba1c2
DM
227the previous current pad. NB currently this macro expands to a string too
228long for some compilers, so it's best to replace it with
229
230 SAVECOMPPAD();
231 PAD_SET_CUR_NOSAVE(padlist,n);
232
dd2155a4
DM
233
234 void PAD_SET_CUR (PADLIST padlist, I32 n)
235
236=for hackers
237Found in file pad.h
238
bf9cdc68
RG
239=item PAD_SET_CUR_NOSAVE
240
241like PAD_SET_CUR, but without the save
242
243 void PAD_SET_CUR_NOSAVE (PADLIST padlist, I32 n)
244
245=for hackers
246Found in file pad.h
247
dd2155a4
DM
248=item PAD_SV
249
250Get the value at offset C<po> in the current pad
251
252 void PAD_SV (PADOFFSET po)
253
254=for hackers
255Found in file pad.h
256
257=item PAD_SVl
258
259Lightweight and lvalue version of C<PAD_SV>.
260Get or set the value at offset C<po> in the current pad.
261Unlike C<PAD_SV>, does not print diagnostics with -DX.
262For internal use only.
263
264 SV * PAD_SVl (PADOFFSET po)
265
266=for hackers
267Found in file pad.h
268
dd2155a4
DM
269=item SAVECLEARSV
270
28a5cf3b 271Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my')
dd2155a4
DM
272
273 void SAVECLEARSV (SV **svp)
274
275=for hackers
276Found in file pad.h
277
278=item SAVECOMPPAD
279
280save PL_comppad and PL_curpad
281
dd2155a4 282
dd2155a4
DM
283
284
285
f3548bdc 286 void SAVECOMPPAD()
dd2155a4
DM
287
288=for hackers
289Found in file pad.h
290
291=item SAVEPADSV
292
293Save a pad slot (used to restore after an iteration)
294
f3548bdc 295XXX DAPM it would make more sense to make the arg a PADOFFSET
dd2155a4
DM
296 void SAVEPADSV (PADOFFSET po)
297
298=for hackers
299Found in file pad.h
300
301
302=back
303
a3985cdc
DM
304=head1 Functions in file pp_ctl.c
305
306
307=over 8
308
309=item find_runcv
310
311Locate the CV corresponding to the currently executing sub or eval.
d819b83a
DM
312If db_seqp is non_null, skip CVs that are in the DB package and populate
313*db_seqp with the cop sequence number at the point that the DB:: code was
314entered. (allows debuggers to eval in the scope of the breakpoint rather
324092c6 315than in the scope of the debugger itself).
a3985cdc 316
d819b83a 317 CV* find_runcv(U32 *db_seqp)
a3985cdc
DM
318
319=for hackers
320Found in file pp_ctl.c
321
322
323=back
324
a4f1a029 325=head1 Global Variables
78f9721b 326
a4f1a029 327=over 8
78f9721b 328
2eb25c99
JH
329=item PL_DBsingle
330
331When Perl is run in debugging mode, with the B<-d> switch, this SV is a
332boolean which indicates whether subs are being single-stepped.
333Single-stepping is automatically turned on after every step. This is the C
334variable which corresponds to Perl's $DB::single variable. See
335C<PL_DBsub>.
336
337 SV * PL_DBsingle
338
339=for hackers
340Found in file intrpvar.h
341
342=item PL_DBsub
343
344When Perl is run in debugging mode, with the B<-d> switch, this GV contains
345the SV which holds the name of the sub being debugged. This is the C
346variable which corresponds to Perl's $DB::sub variable. See
347C<PL_DBsingle>.
348
349 GV * PL_DBsub
350
351=for hackers
352Found in file intrpvar.h
353
354=item PL_DBtrace
355
356Trace variable used when Perl is run in debugging mode, with the B<-d>
357switch. This is the C variable which corresponds to Perl's $DB::trace
358variable. See C<PL_DBsingle>.
359
360 SV * PL_DBtrace
361
362=for hackers
363Found in file intrpvar.h
364
365=item PL_dowarn
366
367The C variable which corresponds to Perl's $^W warning variable.
368
369 bool PL_dowarn
370
371=for hackers
372Found in file intrpvar.h
373
374=item PL_last_in_gv
375
376The GV which was last used for a filehandle input operation. (C<< <FH> >>)
377
378 GV* PL_last_in_gv
379
380=for hackers
381Found in file thrdvar.h
382
383=item PL_ofs_sv
384
385The output field separator - C<$,> in Perl space.
386
387 SV* PL_ofs_sv
388
389=for hackers
390Found in file thrdvar.h
391
392=item PL_rs
393
394The input record separator - C<$/> in Perl space.
395
396 SV* PL_rs
397
398=for hackers
399Found in file thrdvar.h
400
645c22ef 401
a4f1a029 402=back
645c22ef 403
a4f1a029
NIS
404=head1 GV Functions
405
406=over 8
407
408=item is_gv_magical
409
410Returns C<TRUE> if given the name of a magical GV.
411
412Currently only useful internally when determining if a GV should be
413created even in rvalue contexts.
414
415C<flags> is not used at present but available for future extension to
416allow selecting particular classes of magical variable.
417
766f8916
MHM
418Currently assumes that C<name> is NUL terminated (as well as len being valid).
419This assumption is met by all callers within the perl core, which all pass
420pointers returned by SvPV.
421
7fc63493
AL
422 bool is_gv_magical(const char *name, STRLEN len, U32 flags)
423
424=for hackers
425Found in file gv.c
426
427=item is_gv_magical_sv
428
429Returns C<TRUE> if given the name of a magical GV. Calls is_gv_magical.
430
431 bool is_gv_magical_sv(SV *name, U32 flags)
645c22ef
DM
432
433=for hackers
a4f1a029
NIS
434Found in file gv.c
435
436
437=back
438
439=head1 IO Functions
440
441=over 8
645c22ef 442
a8586c98
JH
443=item start_glob
444
445Function called by C<do_readline> to spawn a glob (or do the glob inside
446perl on VMS). This code used to be inline, but now perl uses C<File::Glob>
bd16a5f0 447this glob starter is only used by miniperl during the build process.
a8586c98
JH
448Moving it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
449
450 PerlIO* start_glob(SV* pattern, IO *io)
451
452=for hackers
453Found in file doio.c
454
a4f1a029
NIS
455
456=back
457
0cbee0a4
DM
458=head1 Magical Functions
459
460=over 8
461
462=item mg_localize
463
464Copy some of the magic from an existing SV to new localized version of
465that SV. Container magic (eg %ENV, $1, tie) gets copied, value magic
466doesn't (eg taint, pos).
467
468 void mg_localize(SV* sv, SV* nsv)
469
470=for hackers
471Found in file mg.c
472
473
474=back
475
a4f1a029
NIS
476=head1 Pad Data Structures
477
478=over 8
479
480=item CvPADLIST
481
482CV's can have CvPADLIST(cv) set to point to an AV.
483
484For these purposes "forms" are a kind-of CV, eval""s are too (except they're
485not callable at will and are always thrown away after the eval"" is done
b5c19bd7
DM
486executing). Require'd files are simply evals without any outer lexical
487scope.
a4f1a029
NIS
488
489XSUBs don't have CvPADLIST set - dXSTARG fetches values from PL_curpad,
490but that is really the callers pad (a slot of which is allocated by
491every entersub).
492
493The CvPADLIST AV has does not have AvREAL set, so REFCNT of component items
f3548bdc 494is managed "manual" (mostly in pad.c) rather than normal av.c rules.
a4f1a029
NIS
495The items in the AV are not SVs as for a normal AV, but other AVs:
496
4970'th Entry of the CvPADLIST is an AV which represents the "names" or rather
498the "static type information" for lexicals.
499
500The CvDEPTH'th entry of CvPADLIST AV is an AV which is the stack frame at that
501depth of recursion into the CV.
502The 0'th slot of a frame AV is an AV which is @_.
503other entries are storage for variables and op targets.
504
505During compilation:
a6d05634
TM
506C<PL_comppad_name> is set to the names AV.
507C<PL_comppad> is set to the frame AV for the frame CvDEPTH == 1.
508C<PL_curpad> is set to the body of the frame AV (i.e. AvARRAY(PL_comppad)).
a4f1a029 509
f3548bdc
DM
510During execution, C<PL_comppad> and C<PL_curpad> refer to the live
511frame of the currently executing sub.
512
513Iterating over the names AV iterates over all possible pad
a4f1a029
NIS
514items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having
515&PL_sv_undef "names" (see pad_alloc()).
516
517Only my/our variable (SVs_PADMY/SVs_PADOUR) slots get valid names.
518The rest are op targets/GVs/constants which are statically allocated
519or resolved at compile time. These don't have names by which they
520can be looked up from Perl code at run time through eval"" like
521my/our variables can be. Since they can't be looked up by "name"
522but only by their index allocated at compile time (which is usually
523in PL_op->op_targ), wasting a name SV for them doesn't make sense.
524
525The SVs in the names AV have their PV being the name of the variable.
dd2155a4
DM
526NV+1..IV inclusive is a range of cop_seq numbers for which the name is
527valid. For typed lexicals name SV is SVt_PVMG and SvSTASH points at the
528type. For C<our> lexicals, the type is SVt_PVGV, and GvSTASH points at the
d7f8936a 529stash of the associated global (so that duplicate C<our> declarations in the
dd2155a4
DM
530same package can be detected). SvCUR is sometimes hijacked to
531store the generation number during compilation.
a4f1a029 532
b5c19bd7
DM
533If SvFAKE is set on the name SV, then that slot in the frame AV is
534a REFCNT'ed reference to a lexical from "outside". In this case,
535the name SV does not use NVX and IVX to store a cop_seq range, since it is
536in scope throughout. Instead IVX stores some flags containing info about
537the real lexical (is it declared in an anon, and is it capable of being
538instantiated multiple times?), and for fake ANONs, NVX contains the index
539within the parent's pad where the lexical's value is stored, to make
540cloning quicker.
a4f1a029 541
a6d05634 542If the 'name' is '&' the corresponding entry in frame AV
a4f1a029
NIS
543is a CV representing a possible closure.
544(SvFAKE and name of '&' is not a meaningful combination currently but could
545become so if C<my sub foo {}> is implemented.)
546
5c3943b6
RGS
547Note that formats are treated as anon subs, and are cloned each time
548write is called (if necessary).
549
2814eb74
PJ
550The flag SVf_PADSTALE is cleared on lexicals each time the my() is executed,
551and set on scope exit. This allows the 'Variable $x is not available' warning
552to be generated in evals, such as
553
554 { my $x = 1; sub f { eval '$x'} } f();
555
a4f1a029
NIS
556 AV * CvPADLIST(CV *cv)
557
558=for hackers
dd2155a4
DM
559Found in file pad.c
560
561=item cv_clone
562
563Clone a CV: make a new CV which points to the same code etc, but which
ad63d80f 564has a newly-created pad built by copying the prototype pad and capturing
dd2155a4
DM
565any outer lexicals.
566
567 CV* cv_clone(CV* proto)
568
569=for hackers
570Found in file pad.c
571
572=item cv_dump
573
574dump the contents of a CV
575
e1ec3a88 576 void cv_dump(const CV *cv, const char *title)
dd2155a4
DM
577
578=for hackers
579Found in file pad.c
580
581=item do_dump_pad
582
583Dump the contents of a padlist
584
585 void do_dump_pad(I32 level, PerlIO *file, PADLIST *padlist, int full)
586
587=for hackers
588Found in file pad.c
589
590=item intro_my
591
592"Introduce" my variables to visible status.
593
594 U32 intro_my()
595
596=for hackers
597Found in file pad.c
598
599=item pad_add_anon
600
601Add an anon code entry to the current compiling pad
602
603 PADOFFSET pad_add_anon(SV* sv, OPCODE op_type)
604
605=for hackers
606Found in file pad.c
607
608=item pad_add_name
609
b5c19bd7
DM
610Create a new name and associated PADMY SV in the current pad; return the
611offset.
dd2155a4
DM
612If C<typestash> is valid, the name is for a typed lexical; set the
613name's stash to that value.
614If C<ourstash> is valid, it's an our lexical, set the name's
615GvSTASH to that value
616
dd2155a4
DM
617If fake, it means we're cloning an existing entry
618
e1ec3a88 619 PADOFFSET pad_add_name(const char *name, HV* typestash, HV* ourstash, bool clone)
dd2155a4
DM
620
621=for hackers
622Found in file pad.c
623
624=item pad_alloc
625
626Allocate a new my or tmp pad entry. For a my, simply push a null SV onto
627the end of PL_comppad, but for a tmp, scan the pad from PL_padix upwards
324092c6 628for a slot which has no name and no active value.
dd2155a4
DM
629
630 PADOFFSET pad_alloc(I32 optype, U32 tmptype)
631
632=for hackers
633Found in file pad.c
634
635=item pad_block_start
636
637Update the pad compilation state variables on entry to a new block
638
639 void pad_block_start(int full)
640
641=for hackers
642Found in file pad.c
643
644=item pad_check_dup
645
646Check for duplicate declarations: report any of:
647 * a my in the current scope with the same name;
648 * an our (anywhere in the pad) with the same name and the same stash
649 as C<ourstash>
650C<is_our> indicates that the name to check is an 'our' declaration
651
e1ec3a88 652 void pad_check_dup(const char* name, bool is_our, const HV* ourstash)
dd2155a4
DM
653
654=for hackers
655Found in file pad.c
656
657=item pad_findlex
658
659Find a named lexical anywhere in a chain of nested pads. Add fake entries
b5c19bd7
DM
660in the inner pads if it's found in an outer one.
661
662Returns the offset in the bottom pad of the lex or the fake lex.
663cv is the CV in which to start the search, and seq is the current cop_seq
664to match against. If warn is true, print appropriate warnings. The out_*
665vars return values, and so are pointers to where the returned values
666should be stored. out_capture, if non-null, requests that the innermost
667instance of the lexical is captured; out_name_sv is set to the innermost
668matched namesv or fake namesv; out_flags returns the flags normally
669associated with the IVX field of a fake namesv.
670
671Note that pad_findlex() is recursive; it recurses up the chain of CVs,
672then comes back down, adding fake entries as it goes. It has to be this way
673because fake namesvs in anon protoypes have to store in NVX the index into
674the parent pad.
675
e1ec3a88 676 PADOFFSET pad_findlex(const char *name, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
dd2155a4
DM
677
678=for hackers
679Found in file pad.c
680
681=item pad_findmy
682
ad63d80f 683Given a lexical name, try to find its offset, first in the current pad,
dd2155a4 684or failing that, in the pads of any lexically enclosing subs (including
ad63d80f
JP
685the complications introduced by eval). If the name is found in an outer pad,
686then a fake entry is added to the current pad.
dd2155a4
DM
687Returns the offset in the current pad, or NOT_IN_PAD on failure.
688
e1ec3a88 689 PADOFFSET pad_findmy(const char* name)
dd2155a4
DM
690
691=for hackers
692Found in file pad.c
693
694=item pad_fixup_inner_anons
695
696For any anon CVs in the pad, change CvOUTSIDE of that CV from
7dafbf52
DM
697old_cv to new_cv if necessary. Needed when a newly-compiled CV has to be
698moved to a pre-existing CV struct.
dd2155a4
DM
699
700 void pad_fixup_inner_anons(PADLIST *padlist, CV *old_cv, CV *new_cv)
701
702=for hackers
703Found in file pad.c
704
705=item pad_free
706
d7f8936a 707Free the SV at offset po in the current pad.
dd2155a4
DM
708
709 void pad_free(PADOFFSET po)
710
711=for hackers
712Found in file pad.c
713
714=item pad_leavemy
715
716Cleanup at end of scope during compilation: set the max seq number for
717lexicals in this scope and warn of any lexicals that never got introduced.
718
719 void pad_leavemy()
720
721=for hackers
722Found in file pad.c
723
724=item pad_new
725
ad63d80f 726Create a new compiling padlist, saving and updating the various global
dd2155a4
DM
727vars at the same time as creating the pad itself. The following flags
728can be OR'ed together:
729
730 padnew_CLONE this pad is for a cloned CV
731 padnew_SAVE save old globals
732 padnew_SAVESUB also save extra stuff for start of sub
733
c7c737cb 734 PADLIST* pad_new(int flags)
dd2155a4
DM
735
736=for hackers
737Found in file pad.c
738
739=item pad_push
740
741Push a new pad frame onto the padlist, unless there's already a pad at
26019298
AL
742this depth, in which case don't bother creating a new one. Then give
743the new pad an @_ in slot zero.
dd2155a4 744
26019298 745 void pad_push(PADLIST *padlist, int depth)
dd2155a4
DM
746
747=for hackers
748Found in file pad.c
749
750=item pad_reset
751
752Mark all the current temporaries for reuse
753
754 void pad_reset()
755
756=for hackers
757Found in file pad.c
758
759=item pad_setsv
760
761Set the entry at offset po in the current pad to sv.
762Use the macro PAD_SETSV() rather than calling this function directly.
763
764 void pad_setsv(PADOFFSET po, SV* sv)
765
766=for hackers
767Found in file pad.c
768
769=item pad_swipe
770
771Abandon the tmp in the current pad at offset po and replace with a
772new one.
773
774 void pad_swipe(PADOFFSET po, bool refadjust)
775
776=for hackers
777Found in file pad.c
778
779=item pad_tidy
780
781Tidy up a pad after we've finished compiling it:
782 * remove most stuff from the pads of anonsub prototypes;
783 * give it a @_;
784 * mark tmps as such.
785
786 void pad_tidy(padtidy_type type)
787
788=for hackers
789Found in file pad.c
790
791=item pad_undef
792
793Free the padlist associated with a CV.
794If parts of it happen to be current, we null the relevant
795PL_*pad* global vars so that we don't have any dangling references left.
796We also repoint the CvOUTSIDE of any about-to-be-orphaned
a3985cdc 797inner subs to the outer of this cv.
dd2155a4 798
7dafbf52
DM
799(This function should really be called pad_free, but the name was already
800taken)
801
a3985cdc 802 void pad_undef(CV* cv)
dd2155a4
DM
803
804=for hackers
805Found in file pad.c
a4f1a029
NIS
806
807
808=back
809
810=head1 Stack Manipulation Macros
811
812=over 8
813
814=item djSP
815
816Declare Just C<SP>. This is actually identical to C<dSP>, and declares
817a local copy of perl's stack pointer, available via the C<SP> macro.
818See C<SP>. (Available for backward source code compatibility with the
819old (Perl 5.005) thread model.)
820
821 djSP;
822
823=for hackers
824Found in file pp.h
825
826=item LVRET
827
828True if this op will be the return value of an lvalue subroutine
829
830=for hackers
831Found in file pp.h
832
833
834=back
835
836=head1 SV Manipulation Functions
837
838=over 8
839
29489e7c
DM
840=item find_uninit_var
841
842Find the name of the undefined variable (if any) that caused the operator o
843to issue a "Use of uninitialized value" warning.
844If match is true, only return a name if it's value matches uninit_sv.
845So roughly speaking, if a unary operator (such as OP_COS) generates a
846warning, then following the direct child of the op may yield an
847OP_PADSV or OP_GV that gives the name of the undefined variable. On the
848other hand, with OP_ADD there are two branches to follow, so we only print
849the variable name if we get an exact match.
850
851The name is returned as a mortal SV.
852
853Assumes that PL_op is the op that originally triggered the error, and that
854PL_comppad/PL_curpad points to the currently executing pad.
855
856 SV* find_uninit_var(OP* obase, SV* uninit_sv, bool top)
857
858=for hackers
859Found in file sv.c
860
a4f1a029
NIS
861=item report_uninit
862
863Print appropriate "Use of uninitialized variable" warning
864
29489e7c 865 void report_uninit(SV* uninit_sv)
a4f1a029
NIS
866
867=for hackers
868Found in file sv.c
869
645c22ef
DM
870=item sv_add_arena
871
872Given a chunk of memory, link it to the head of the list of arenas,
873and split it into a list of free SVs.
874
875 void sv_add_arena(char* ptr, U32 size, U32 flags)
876
877=for hackers
878Found in file sv.c
879
880=item sv_clean_all
881
882Decrement the refcnt of each remaining SV, possibly triggering a
883cleanup. This function may have to be called multiple times to free
8fb26106 884SVs which are in complex self-referential hierarchies.
645c22ef
DM
885
886 I32 sv_clean_all()
887
888=for hackers
889Found in file sv.c
890
891=item sv_clean_objs
892
893Attempt to destroy all objects not yet freed
894
895 void sv_clean_objs()
896
897=for hackers
898Found in file sv.c
899
900=item sv_free_arenas
901
902Deallocate the memory used by all arenas. Note that all the individual SV
903heads and bodies within the arenas must already have been freed.
904
905 void sv_free_arenas()
906
907=for hackers
908Found in file sv.c
909
a4f1a029 910
954c1994
GS
911=back
912
913=head1 AUTHORS
914
1c846c1f
NIS
915The autodocumentation system was originally added to the Perl core by
916Benjamin Stuhl. Documentation is by whoever was kind enough to
954c1994
GS
917document their functions.
918
919=head1 SEE ALSO
920
921perlguts(1), perlapi(1)
922