This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Recode all the old variable-like substitutions with the generic line
[perl5.git] / ext / Devel / Peek / t / Peek.t
1 #!./perl -T
2
3 BEGIN {
4     chdir 't' if -d 't';
5     @INC = '../lib';
6     require Config; import Config;
7     if ($Config{'extensions'} !~ /\bDevel\/Peek\b/) {
8         print "1..0 # Skip: Devel::Peek was not built\n";
9         exit 0;
10     }
11 }
12
13 BEGIN { require "./test.pl"; }
14
15 use Devel::Peek;
16
17 plan(50);
18
19 our $DEBUG = 0;
20 open(SAVERR, ">&STDERR") or die "Can't dup STDERR: $!";
21
22 sub do_test {
23     my $todo = $_[3];
24     my $repeat_todo = $_[4];
25     my $pattern = $_[2];
26     if (open(OUT,">peek$$")) {
27         open(STDERR, ">&OUT") or die "Can't dup OUT: $!";
28         Dump($_[1]);
29         print STDERR "*****\n";
30         Dump($_[1]); # second dump to compare with the first to make sure nothing changed.
31         open(STDERR, ">&SAVERR") or die "Can't restore STDERR: $!";
32         close(OUT);
33         if (open(IN, "peek$$")) {
34             local $/;
35             $pattern =~ s/\$ADDR/0x[[:xdigit:]]+/g;
36             $pattern =~ s/\$FLOAT/(?:\\d*\\.\\d+(?:e[-+]\\d+)?|\\d+)/g;
37             # handle DEBUG_LEAKING_SCALARS prefix
38             $pattern =~ s/^(\s*)(SV =.* at )/(?:$1ALLOCATED at .*?\n)?$1$2/mg;
39
40             # Need some clear generic mechanism to eliminate (or add) lines
41             # of dump output dependant on perl version. The (previous) use of
42             # things like $IVNV gave the illusion that the string passed in was
43             # a regexp into which variables were interpolated, but this wasn't
44             # actually true as those 'variables' actually also ate the
45             # whitspace on the line. So it seems better to mark lines that
46             # need to be eliminated. I considered (?# ... ) and (?{ ... }),
47             # but whilst embedded code or comment syntax would keep it as a
48             # legitimate regexp, it still isn't true. Seems easier and clearer
49             # things that look like comments.
50
51             # Could do this is in a s///mge but seems clearer like this:
52             $pattern = join '', map {
53                 # If we identify the version condition, take *it* out whatever
54                 s/\s*# (\$] [<>]=? 5\.\d\d\d)$//
55                     ? (eval $1 ? $_ : '')
56                     : $_ # Didn't match, so this line is in
57             } split /^/, $pattern;
58             
59             $pattern =~ s/\$PADMY/
60                 ($] < 5.009) ? 'PADBUSY,PADMY' : 'PADMY';
61             /mge;
62             $pattern =~ s/\$PADTMP/
63                 ($] < 5.009) ? 'PADBUSY,PADTMP' : 'PADTMP';
64             /mge;
65             $pattern =~ s/\$RV/
66                 ($] < 5.011) ? 'RV' : 'IV';
67             /mge;
68
69             print $pattern, "\n" if $DEBUG;
70             my ($dump, $dump2) = split m/\*\*\*\*\*\n/, scalar <IN>;
71             print $dump, "\n"    if $DEBUG;
72             like( $dump, qr/\A$pattern\Z/ms );
73
74             local $TODO = $repeat_todo;
75             is($dump2, $dump);
76
77             close(IN);
78
79             return $1;
80         } else {
81             die "$0: failed to open peek$$: !\n";
82         }
83     } else {
84         die "$0: failed to create peek$$: $!\n";
85     }
86 }
87
88 our   $a;
89 our   $b;
90 my    $c;
91 local $d = 0;
92
93 END {
94     1 while unlink("peek$$");
95 }
96
97 do_test( 1,
98         $a = "foo",
99 'SV = PV\\($ADDR\\) at $ADDR
100   REFCNT = 1
101   FLAGS = \\(POK,pPOK\\)
102   PV = $ADDR "foo"\\\0
103   CUR = 3
104   LEN = \\d+'
105        );
106
107 do_test( 2,
108         "bar",
109 'SV = PV\\($ADDR\\) at $ADDR
110   REFCNT = 1
111   FLAGS = \\(.*POK,READONLY,pPOK\\)
112   PV = $ADDR "bar"\\\0
113   CUR = 3
114   LEN = \\d+');
115
116 do_test( 3,
117         $b = 123,
118 'SV = IV\\($ADDR\\) at $ADDR
119   REFCNT = 1
120   FLAGS = \\(IOK,pIOK\\)
121   IV = 123');
122
123 do_test( 4,
124         456,
125 'SV = IV\\($ADDR\\) at $ADDR
126   REFCNT = 1
127   FLAGS = \\(.*IOK,READONLY,pIOK\\)
128   IV = 456');
129
130 do_test( 5,
131         $c = 456,
132 'SV = IV\\($ADDR\\) at $ADDR
133   REFCNT = 1
134   FLAGS = \\($PADMY,IOK,pIOK\\)
135   IV = 456');
136
137 # If perl is built with PERL_PRESERVE_IVUV then maths is done as integers
138 # where possible and this scalar will be an IV. If NO_PERL_PRESERVE_IVUV then
139 # maths is done in floating point always, and this scalar will be an NV.
140 # ([NI]) captures the type, referred to by \1 in this regexp and $type for
141 # building subsequent regexps.
142 my $type = do_test( 6,
143         $c + $d,
144 'SV = ([NI])V\\($ADDR\\) at $ADDR
145   REFCNT = 1
146   FLAGS = \\(PADTMP,\1OK,p\1OK\\)
147   \1V = 456');
148
149 ($d = "789") += 0.1;
150
151 do_test( 7,
152        $d,
153 'SV = PVNV\\($ADDR\\) at $ADDR
154   REFCNT = 1
155   FLAGS = \\(NOK,pNOK\\)
156   IV = \d+
157   NV = 789\\.(?:1(?:000+\d+)?|0999+\d+)
158   PV = $ADDR "789"\\\0
159   CUR = 3
160   LEN = \\d+');
161
162 do_test( 8,
163         0xabcd,
164 'SV = IV\\($ADDR\\) at $ADDR
165   REFCNT = 1
166   FLAGS = \\(.*IOK,READONLY,pIOK\\)
167   IV = 43981');
168
169 do_test( 9,
170         undef,
171 'SV = NULL\\(0x0\\) at $ADDR
172   REFCNT = 1
173   FLAGS = \\(\\)');
174
175 do_test(10,
176         \$a,
177 'SV = $RV\\($ADDR\\) at $ADDR
178   REFCNT = 1
179   FLAGS = \\(ROK\\)
180   RV = $ADDR
181   SV = PV\\($ADDR\\) at $ADDR
182     REFCNT = 2
183     FLAGS = \\(POK,pPOK\\)
184     PV = $ADDR "foo"\\\0
185     CUR = 3
186     LEN = \\d+');
187
188 my $c_pattern;
189 if ($type eq 'N') {
190   $c_pattern = '
191     SV = PVNV\\($ADDR\\) at $ADDR
192       REFCNT = 1
193       FLAGS = \\(IOK,NOK,pIOK,pNOK\\)
194       IV = 456
195       NV = 456
196       PV = 0';
197 } else {
198   $c_pattern = '
199     SV = IV\\($ADDR\\) at $ADDR
200       REFCNT = 1
201       FLAGS = \\(IOK,pIOK\\)
202       IV = 456';
203 }
204 do_test(11,
205        [$b,$c],
206 'SV = $RV\\($ADDR\\) at $ADDR
207   REFCNT = 1
208   FLAGS = \\(ROK\\)
209   RV = $ADDR
210   SV = PVAV\\($ADDR\\) at $ADDR
211     REFCNT = 1
212     FLAGS = \\(\\)
213     IV = 0                                      # $] < 5.009
214     NV = 0                                      # $] < 5.009
215     ARRAY = $ADDR
216     FILL = 1
217     MAX = 1
218     ARYLEN = 0x0
219     FLAGS = \\(REAL\\)
220     Elt No. 0
221     SV = IV\\($ADDR\\) at $ADDR
222       REFCNT = 1
223       FLAGS = \\(IOK,pIOK\\)
224       IV = 123
225     Elt No. 1' . $c_pattern);
226
227 do_test(12,
228        {$b=>$c},
229 'SV = $RV\\($ADDR\\) at $ADDR
230   REFCNT = 1
231   FLAGS = \\(ROK\\)
232   RV = $ADDR
233   SV = PVHV\\($ADDR\\) at $ADDR
234     REFCNT = 1
235     FLAGS = \\(SHAREKEYS\\)
236     IV = 1                                      # $] < 5.009
237     NV = $FLOAT                                 # $] < 5.009
238     ARRAY = $ADDR  \\(0:7, 1:1\\)
239     hash quality = 100.0%
240     KEYS = 1
241     FILL = 1
242     MAX = 7
243     RITER = -1
244     EITER = 0x0
245     Elt "123" HASH = $ADDR' . $c_pattern,
246         '',
247         $] > 5.009 && 'The hash iterator used in dump.c sets the OOK flag');
248
249 do_test(13,
250         sub(){@_},
251 'SV = $RV\\($ADDR\\) at $ADDR
252   REFCNT = 1
253   FLAGS = \\(ROK\\)
254   RV = $ADDR
255   SV = PVCV\\($ADDR\\) at $ADDR
256     REFCNT = 2
257     FLAGS = \\($PADMY,POK,pPOK,ANON,WEAKOUTSIDE\\)
258     IV = 0                                      # $] < 5.009
259     NV = 0                                      # $] < 5.009
260     PROTOTYPE = ""
261     COMP_STASH = $ADDR\\t"main"
262     START = $ADDR ===> \\d+
263     ROOT = $ADDR
264     XSUB = 0x0                                  # $] < 5.009
265     XSUBANY = 0                                 # $] < 5.009
266     GVGV::GV = $ADDR\\t"main" :: "__ANON__[^"]*"
267     FILE = ".*\\b(?i:peek\\.t)"
268     DEPTH = 0(?:
269     MUTEXP = $ADDR
270     OWNER = $ADDR)?
271     FLAGS = 0x404                               # $] < 5.009
272     FLAGS = 0x90                                # $] >= 5.009
273     OUTSIDE_SEQ = \\d+
274     PADLIST = $ADDR
275     PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
276     OUTSIDE = $ADDR \\(MAIN\\)');
277
278 do_test(14,
279         \&do_test,
280 'SV = $RV\\($ADDR\\) at $ADDR
281   REFCNT = 1
282   FLAGS = \\(ROK\\)
283   RV = $ADDR
284   SV = PVCV\\($ADDR\\) at $ADDR
285     REFCNT = (3|4)
286     FLAGS = \\(\\)
287     IV = 0                                      # $] < 5.009
288     NV = 0                                      # $] < 5.009
289     COMP_STASH = $ADDR\\t"main"
290     START = $ADDR ===> \\d+
291     ROOT = $ADDR
292     XSUB = 0x0                                  # $] < 5.009
293     XSUBANY = 0                                 # $] < 5.009
294     GVGV::GV = $ADDR\\t"main" :: "do_test"
295     FILE = ".*\\b(?i:peek\\.t)"
296     DEPTH = 1
297 (?:    MUTEXP = $ADDR
298     OWNER = $ADDR
299 )?    FLAGS = 0x0
300     OUTSIDE_SEQ = \\d+
301     PADLIST = $ADDR
302     PADNAME = $ADDR\\($ADDR\\) PAD = $ADDR\\($ADDR\\)
303        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$todo"
304        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$repeat_todo"
305        \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$pattern"
306       \\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG"                       # $] < 5.009
307       \\d+\\. $ADDR<\\d+> FAKE "\\$DEBUG" flags=0x0 index=0     # $] >= 5.009
308       \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump"
309       \\d+\\. $ADDR<\\d+> \\(\\d+,\\d+\\) "\\$dump2"
310     OUTSIDE = $ADDR \\(MAIN\\)');
311
312 if ($] >= 5.011) {
313 do_test(15,
314         qr(tic),
315 'SV = $RV\\($ADDR\\) at $ADDR
316   REFCNT = 1
317   FLAGS = \\(ROK\\)
318   RV = $ADDR
319   SV = REGEXP\\($ADDR\\) at $ADDR
320     REFCNT = 2
321     FLAGS = \\(OBJECT,POK,pPOK\\)
322     IV = 0
323     PV = $ADDR "\\(\\?-xism:tic\\)"\\\0
324     CUR = 12
325     LEN = \\d+
326     STASH = $ADDR\\t"Regexp"');
327 } else {
328 do_test(15,
329         qr(tic),
330 'SV = $RV\\($ADDR\\) at $ADDR
331   REFCNT = 1
332   FLAGS = \\(ROK\\)
333   RV = $ADDR
334   SV = PVMG\\($ADDR\\) at $ADDR
335     REFCNT = 1
336     FLAGS = \\(OBJECT,SMG\\)
337     IV = 0
338     NV = 0
339     PV = 0
340     MAGIC = $ADDR
341       MG_VIRTUAL = $ADDR
342       MG_TYPE = PERL_MAGIC_qr\(r\)
343       MG_OBJ = $ADDR
344         PAT = "\(\?-xism:tic\)"                 # $] >= 5.009
345         REFCNT = 2                              # $] >= 5.009
346     STASH = $ADDR\\t"Regexp"');
347 }
348
349 do_test(16,
350         (bless {}, "Tac"),
351 'SV = $RV\\($ADDR\\) at $ADDR
352   REFCNT = 1
353   FLAGS = \\(ROK\\)
354   RV = $ADDR
355   SV = PVHV\\($ADDR\\) at $ADDR
356     REFCNT = 1
357     FLAGS = \\(OBJECT,SHAREKEYS\\)
358     IV = 0                                      # $] < 5.009
359     NV = 0                                      # $] < 5.009
360     STASH = $ADDR\\t"Tac"
361     ARRAY = 0x0
362     KEYS = 0
363     FILL = 0
364     MAX = 7
365     RITER = -1
366     EITER = 0x0', '',
367         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
368         : "Something causes the HV's array to become allocated");
369
370 do_test(17,
371         *a,
372 'SV = PVGV\\($ADDR\\) at $ADDR
373   REFCNT = 5
374   FLAGS = \\(MULTI(?:,IN_PAD)?\\)               # $] >= 5.009
375   FLAGS = \\(GMG,SMG,MULTI(?:,IN_PAD)?\\)       # $] < 5.009
376   IV = 0                                        # $] < 5.009
377   NV = 0                                        # $] < 5.009
378   PV = 0                                        # $] < 5.009
379   MAGIC = $ADDR                                 # $] < 5.009
380     MG_VIRTUAL = &PL_vtbl_glob                  # $] < 5.009
381     MG_TYPE = PERL_MAGIC_glob\(\*\)             # $] < 5.009
382     MG_OBJ = $ADDR                              # $] < 5.009
383   NAME = "a"
384   NAMELEN = 1
385   GvSTASH = $ADDR\\t"main"
386   GP = $ADDR
387     SV = $ADDR
388     REFCNT = 1
389     IO = 0x0
390     FORM = 0x0  
391     AV = 0x0
392     HV = 0x0
393     CV = 0x0
394     CVGEN = 0x0
395     GPFLAGS = 0x0                               # $] < 5.009
396     LINE = \\d+
397     FILE = ".*\\b(?i:peek\\.t)"
398     FLAGS = $ADDR
399     EGV = $ADDR\\t"a"');
400
401 if (ord('A') == 193) {
402 do_test(18,
403         chr(256).chr(0).chr(512),
404 'SV = PV\\($ADDR\\) at $ADDR
405   REFCNT = 1
406   FLAGS = \\((?:$PADTMP,)?POK,READONLY,pPOK,UTF8\\)
407   PV = $ADDR "\\\214\\\101\\\0\\\235\\\101"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
408   CUR = 5
409   LEN = \\d+');
410 } else {
411 do_test(18,
412         chr(256).chr(0).chr(512),
413 'SV = PV\\($ADDR\\) at $ADDR
414   REFCNT = 1
415   FLAGS = \\((?:$PADTMP,)?POK,READONLY,pPOK,UTF8\\)
416   PV = $ADDR "\\\304\\\200\\\0\\\310\\\200"\\\0 \[UTF8 "\\\x\{100\}\\\x\{0\}\\\x\{200\}"\]
417   CUR = 5
418   LEN = \\d+');
419 }
420
421 if (ord('A') == 193) {
422 do_test(19,
423         {chr(256)=>chr(512)},
424 'SV = $RV\\($ADDR\\) at $ADDR
425   REFCNT = 1
426   FLAGS = \\(ROK\\)
427   RV = $ADDR
428   SV = PVHV\\($ADDR\\) at $ADDR
429     REFCNT = 1
430     FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
431     UV = 1                                      # $] < 5.009
432     NV = $FLOAT                                 # $] < 5.009
433     ARRAY = $ADDR  \\(0:7, 1:1\\)
434     hash quality = 100.0%
435     KEYS = 1
436     FILL = 1
437     MAX = 7
438     RITER = -1
439     EITER = $ADDR
440     Elt "\\\214\\\101" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
441     SV = PV\\($ADDR\\) at $ADDR
442       REFCNT = 1
443       FLAGS = \\(POK,pPOK,UTF8\\)
444       PV = $ADDR "\\\235\\\101"\\\0 \[UTF8 "\\\x\{200\}"\]
445       CUR = 2
446       LEN = \\d+',
447         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
448         : 'sv_length has been called on the element, and cached the result in MAGIC');
449 } else {
450 do_test(19,
451         {chr(256)=>chr(512)},
452 'SV = $RV\\($ADDR\\) at $ADDR
453   REFCNT = 1
454   FLAGS = \\(ROK\\)
455   RV = $ADDR
456   SV = PVHV\\($ADDR\\) at $ADDR
457     REFCNT = 1
458     FLAGS = \\(SHAREKEYS,HASKFLAGS\\)
459     UV = 1                                      # $] < 5.009
460     NV = 0                                      # $] < 5.009
461     ARRAY = $ADDR  \\(0:7, 1:1\\)
462     hash quality = 100.0%
463     KEYS = 1
464     FILL = 1
465     MAX = 7
466     RITER = -1
467     EITER = $ADDR
468     Elt "\\\304\\\200" \[UTF8 "\\\x\{100\}"\] HASH = $ADDR
469     SV = PV\\($ADDR\\) at $ADDR
470       REFCNT = 1
471       FLAGS = \\(POK,pPOK,UTF8\\)
472       PV = $ADDR "\\\310\\\200"\\\0 \[UTF8 "\\\x\{200\}"\]
473       CUR = 2
474       LEN = \\d+', '',
475         $] > 5.009 ? 'The hash iterator used in dump.c sets the OOK flag'
476         : 'sv_length has been called on the element, and cached the result in MAGIC');
477 }
478
479 my $x="";
480 $x=~/.??/g;
481 do_test(20,
482         $x,
483 'SV = PVMG\\($ADDR\\) at $ADDR
484   REFCNT = 1
485   FLAGS = \\($PADMY,SMG,POK,pPOK\\)
486   IV = 0
487   NV = 0
488   PV = $ADDR ""\\\0
489   CUR = 0
490   LEN = \d+
491   MAGIC = $ADDR
492     MG_VIRTUAL = &PL_vtbl_mglob
493     MG_TYPE = PERL_MAGIC_regex_global\\(g\\)
494     MG_FLAGS = 0x01
495       MINMATCH');
496
497 #
498 # TAINTEDDIR is not set on: OS2, AMIGAOS, WIN32, MSDOS
499 # environment variables may be invisibly case-forced, hence the (?i:PATH)
500 # C<scalar(@ARGV)> is turned into an IV on VMS hence the (?:IV)?
501 # VMS is setting FAKE and READONLY flags.  What VMS uses for storing
502 # ENV hashes is also not always null terminated.
503 #
504 do_test(21,
505         $ENV{PATH}=@ARGV,  # scalar(@ARGV) is a handy known tainted value
506 'SV = PVMG\\($ADDR\\) at $ADDR
507   REFCNT = 1
508   FLAGS = \\(GMG,SMG,RMG,pIOK,pPOK\\)
509   IV = 0
510   NV = 0
511   PV = $ADDR "0"\\\0
512   CUR = 1
513   LEN = \d+
514   MAGIC = $ADDR
515     MG_VIRTUAL = &PL_vtbl_envelem
516     MG_TYPE = PERL_MAGIC_envelem\\(e\\)
517 (?:    MG_FLAGS = 0x01
518       TAINTEDDIR
519 )?    MG_LEN = -?\d+
520     MG_PTR = $ADDR (?:"(?i:PATH)"|=> HEf_SVKEY
521     SV = PV(?:IV)?\\($ADDR\\) at $ADDR
522       REFCNT = \d+
523       FLAGS = \\(TEMP,POK,(?:FAKE,READONLY,)?pPOK\\)
524 (?:      IV = 0
525 )?      PV = $ADDR "(?i:PATH)"(?:\\\0)?
526       CUR = \d+
527       LEN = \d+)
528   MAGIC = $ADDR
529     MG_VIRTUAL = &PL_vtbl_taint
530     MG_TYPE = PERL_MAGIC_taint\\(t\\)');
531
532 # blessed refs
533 do_test(22,
534         bless(\\undef, 'Foobar'),
535 'SV = $RV\\($ADDR\\) at $ADDR
536   REFCNT = 1
537   FLAGS = \\(ROK\\)
538   RV = $ADDR
539   SV = PVMG\\($ADDR\\) at $ADDR
540     REFCNT = 2
541     FLAGS = \\(OBJECT,ROK\\)
542     IV = -?\d+
543     NV = $FLOAT
544     RV = $ADDR
545     SV = NULL\\(0x0\\) at $ADDR
546       REFCNT = \d+
547       FLAGS = \\(READONLY\\)
548     PV = $ADDR ""
549     CUR = 0
550     LEN = 0
551     STASH = $ADDR\s+"Foobar"');
552
553 # Constant subroutines
554
555 sub const () {
556     "Perl rules";
557 }
558
559 do_test(23,
560         \&const,
561 'SV = $RV\\($ADDR\\) at $ADDR
562   REFCNT = 1
563   FLAGS = \\(ROK\\)
564   RV = $ADDR
565   SV = PVCV\\($ADDR\\) at $ADDR
566     REFCNT = (2)
567     FLAGS = \\(POK,pPOK,CONST\\)
568     IV = 0                                      # $] < 5.009
569     NV = 0                                      # $] < 5.009
570     PROTOTYPE = ""
571     COMP_STASH = 0x0
572     ROOT = 0x0                                  # $] < 5.009
573     XSUB = $ADDR
574     XSUBANY = $ADDR \\(CONST SV\\)
575     SV = PV\\($ADDR\\) at $ADDR
576       REFCNT = 1
577       FLAGS = \\(.*POK,READONLY,pPOK\\)
578       PV = $ADDR "Perl rules"\\\0
579       CUR = 10
580       LEN = \\d+
581     GVGV::GV = $ADDR\\t"main" :: "const"
582     FILE = ".*\\b(?i:peek\\.t)"
583     DEPTH = 0(?:
584     MUTEXP = $ADDR
585     OWNER = $ADDR)?
586     FLAGS = 0x200                               # $] < 5.009
587     FLAGS = 0xc00                               # $] >= 5.009
588     OUTSIDE_SEQ = 0
589     PADLIST = 0x0
590     OUTSIDE = 0x0 \\(null\\)'); 
591
592 # isUV should show on PVMG
593 do_test(24,
594         do { my $v = $1; $v = ~0; $v },
595 'SV = PVMG\\($ADDR\\) at $ADDR
596   REFCNT = 1
597   FLAGS = \\(IOK,pIOK,IsUV\\)
598   UV = \d+
599   NV = 0
600   PV = 0');
601
602 do_test(25,
603         *STDOUT{IO},
604 'SV = $RV\\($ADDR\\) at $ADDR
605   REFCNT = 1
606   FLAGS = \\(ROK\\)
607   RV = $ADDR
608   SV = PVIO\\($ADDR\\) at $ADDR
609     REFCNT = 3
610     FLAGS = \\(OBJECT\\)
611     IV = 0
612     NV = 0                                      # $] < 5.011
613     STASH = $ADDR\s+"IO::Handle"
614     IFP = $ADDR
615     OFP = $ADDR
616     DIRP = 0x0
617     LINES = 0
618     PAGE = 0
619     PAGE_LEN = 60
620     LINES_LEFT = 0
621     TOP_GV = 0x0
622     FMT_GV = 0x0
623     BOTTOM_GV = 0x0
624     SUBPROCESS = 0                              # $] < 5.009
625     TYPE = \'>\'
626     FLAGS = 0x0');