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