1 #if 0
2 <<'SKIP';
3 #endif
4 /*
5 ----------------------------------------------------------------------
6
7 ppport.h -- Perl/Pollution/Portability Version 3.11
8
9 Automatically created by Devel::PPPort running under perl 5.008008.
10
11 Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
12 includes in parts/inc/ instead.
13
14 Use 'perldoc ppport.h' to view the documentation below.
15
16 ----------------------------------------------------------------------
17
18 SKIP
19
20 =pod
21
22 =head1 NAME
23
24 ppport.h - Perl/Pollution/Portability version 3.11
25
26 =head1 SYNOPSIS
27
28 perl ppport.h [options] [source files]
29
30 Searches current directory for files if no [source files] are given
31
32 --help show short help
33
34 --version show version
35
36 --patch=file write one patch file with changes
37 --copy=suffix write changed copies with suffix
38 --diff=program use diff program and options
39
40 --compat-version=version provide compatibility with Perl version
41 --cplusplus accept C++ comments
42
43 --quiet don't output anything except fatal errors
44 --nodiag don't show diagnostics
45 --nohints don't show hints
46 --nochanges don't suggest changes
47 --nofilter don't filter input files
48
49 --strip strip all script and doc functionality from
50 ppport.h
51
52 --list-provided list provided API
53 --list-unsupported list unsupported API
54 --api-info=name show Perl API portability information
55
56 =head1 COMPATIBILITY
57
58 This version of F<ppport.h> is designed to support operation with Perl
59 installations back to 5.003, and has been tested up to 5.9.4.
60
61 =head1 OPTIONS
62
63 =head2 --help
64
65 Display a brief usage summary.
66
67 =head2 --version
68
69 Display the version of F<ppport.h>.
70
71 =head2 --patch=I<file>
72
73 If this option is given, a single patch file will be created if
74 any changes are suggested. This requires a working diff program
75 to be installed on your system.
76
77 =head2 --copy=I<suffix>
78
79 If this option is given, a copy of each file will be saved with
80 the given suffix that contains the suggested changes. This does
81 not require any external programs.
82
83 If neither C<--patch> or C<--copy> are given, the default is to
84 simply print the diffs for each file. This requires either
85 C<Text::Diff> or a C<diff> program to be installed.
86
87 =head2 --diff=I<program>
88
89 Manually set the diff program and options to use. The default
90 is to use C<Text::Diff>, when installed, and output unified
91 context diffs.
92
93 =head2 --compat-version=I<version>
94
95 Tell F<ppport.h> to check for compatibility with the given
96 Perl version. The default is to check for compatibility with Perl
97 version 5.003. You can use this option to reduce the output
98 of F<ppport.h> if you intend to be backward compatible only
99 down to a certain Perl version.
100
101 =head2 --cplusplus
102
103 Usually, F<ppport.h> will detect C++ style comments and
104 replace them with C style comments for portability reasons.
105 Using this option instructs F<ppport.h> to leave C++
106 comments untouched.
107
108 =head2 --quiet
109
110 Be quiet. Don't print anything except fatal errors.
111
112 =head2 --nodiag
113
114 Don't output any diagnostic messages. Only portability
115 alerts will be printed.
116
117 =head2 --nohints
118
119 Don't output any hints. Hints often contain useful portability
120 notes.
121
122 =head2 --nochanges
123
124 Don't suggest any changes. Only give diagnostic output and hints
125 unless these are also deactivated.
126
127 =head2 --nofilter
128
129 Don't filter the list of input files. By default, files not looking
130 like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.
131
132 =head2 --strip
133
134 Strip all script and documentation functionality from F<ppport.h>.
135 This reduces the size of F<ppport.h> dramatically and may be useful
136 if you want to include F<ppport.h> in smaller modules without
137 increasing their distribution size too much.
138
139 The stripped F<ppport.h> will have a C<--unstrip> option that allows
140 you to undo the stripping, but only if an appropriate C<Devel::PPPort>
141 module is installed.
142
143 =head2 --list-provided
144
145 Lists the API elements for which compatibility is provided by
146 F<ppport.h>. Also lists if it must be explicitly requested,
147 if it has dependencies, and if there are hints for it.
148
149 =head2 --list-unsupported
150
151 Lists the API elements that are known not to be supported by
152 F<ppport.h> and below which version of Perl they probably
153 won't be available or work.
154
155 =head2 --api-info=I<name>
156
157 Show portability information for API elements matching I<name>.
158 If I<name> is surrounded by slashes, it is interpreted as a regular
159 expression.
160
161 =head1 DESCRIPTION
162
163 In order for a Perl extension (XS) module to be as portable as possible
164 across differing versions of Perl itself, certain steps need to be taken.
165
166 =over 4
167
168 =item *
169
170 Including this header is the first major one. This alone will give you
171 access to a large part of the Perl API that hasn't been available in
172 earlier Perl releases. Use
173
174 perl ppport.h --list-provided
175
176 to see which API elements are provided by ppport.h.
177
178 =item *
179
180 You should avoid using deprecated parts of the API. For example, using
181 global Perl variables without the C<PL_> prefix is deprecated. Also,
182 some API functions used to have a C<perl_> prefix. Using this form is
183 also deprecated. You can safely use the supported API, as F<ppport.h>
184 will provide wrappers for older Perl versions.
185
186 =item *
187
188 If you use one of a few functions or variables that were not present in
189 earlier versions of Perl, and that can't be provided using a macro, you
190 have to explicitly request support for these functions by adding one or
191 more C<#define>s in your source code before the inclusion of F<ppport.h>.
192
193 These functions or variables will be marked C<explicit> in the list shown
194 by C<--list-provided>.
195
196 Depending on whether you module has a single or multiple files that
197 use such functions or variables, you want either C<static> or global
198 variants.
199
200 For a C<static> function or variable (used only in a single source
201 file), use:
202
203 #define NEED_function
204 #define NEED_variable
205
206 For a global function or variable (used in multiple source files),
207 use:
208
209 #define NEED_function_GLOBAL
210 #define NEED_variable_GLOBAL
211
212 Note that you mustn't have more than one global request for the
213 same function or variable in your project.
214
215 Function / Variable Static Request Global Request
216 -----------------------------------------------------------------------------------------
217 PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL
218 eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL
219 grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL
220 grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL
221 grok_number() NEED_grok_number NEED_grok_number_GLOBAL
222 grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL
223 grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL
224 my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL
225 my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL
226 my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL
227 newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL
228 newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL
229 sv_2pv_nolen() NEED_sv_2pv_nolen NEED_sv_2pv_nolen_GLOBAL
230 sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL
231 sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL
232 sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL
233 sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL
234 sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL
235 vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL
236 warner() NEED_warner NEED_warner_GLOBAL
237
238 To avoid namespace conflicts, you can change the namespace of the
239 explicitly exported functions / variables using the C<DPPP_NAMESPACE>
240 macro. Just C<#define> the macro before including C<ppport.h>:
241
242 #define DPPP_NAMESPACE MyOwnNamespace_
243 #include "ppport.h"
244
245 The default namespace is C<DPPP_>.
246
247 =back
248
249 The good thing is that most of the above can be checked by running
250 F<ppport.h> on your source code. See the next section for
251 details.
252
253 =head1 EXAMPLES
254
255 To verify whether F<ppport.h> is needed for your module, whether you
256 should make any changes to your code, and whether any special defines
257 should be used, F<ppport.h> can be run as a Perl script to check your
258 source code. Simply say:
259
260 perl ppport.h
261
262 The result will usually be a list of patches suggesting changes
263 that should at least be acceptable, if not necessarily the most
264 efficient solution, or a fix for all possible problems.
265
266 If you know that your XS module uses features only available in
267 newer Perl releases, if you're aware that it uses C++ comments,
268 and if you want all suggestions as a single patch file, you could
269 use something like this:
270
271 perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
272
273 If you only want your code to be scanned without any suggestions
274 for changes, use:
275
276 perl ppport.h --nochanges
277
278 You can specify a different C<diff> program or options, using
279 the C<--diff> option:
280
281 perl ppport.h --diff='diff -C 10'
282
283 This would output context diffs with 10 lines of context.
284
285 To display portability information for the C<newSVpvn> function,
286 use:
287
288 perl ppport.h --api-info=newSVpvn
289
290 Since the argument to C<--api-info> can be a regular expression,
291 you can use
292
293 perl ppport.h --api-info=/_nomg$/
294
295 to display portability information for all C<_nomg> functions or
296
297 perl ppport.h --api-info=/./
298
299 to display information for all known API elements.
300
301 =head1 BUGS
302
303 If this version of F<ppport.h> is causing failure during
304 the compilation of this module, please check if newer versions
305 of either this module or C<Devel::PPPort> are available on CPAN
306 before sending a bug report.
307
308 If F<ppport.h> was generated using the latest version of
309 C<Devel::PPPort> and is causing failure of this module, please
310 file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
311
312 Please include the following information:
313
314 =over 4
315
316 =item 1.
317
318 The complete output from running "perl -V"
319
320 =item 2.
321
322 This file.
323
324 =item 3.
325
326 The name and version of the module you were trying to build.
327
328 =item 4.
329
330 A full log of the build that failed.
331
332 =item 5.
333
334 Any other information that you think could be relevant.
335
336 =back
337
338 For the latest version of this code, please get the C<Devel::PPPort>
339 module from CPAN.
340
341 =head1 COPYRIGHT
342
343 Version 3.x, Copyright (c) 2004-2007, Marcus Holland-Moritz.
344
345 Version 2.x, Copyright (C) 2001, Paul Marquess.
346
347 Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
348
349 This program is free software; you can redistribute it and/or
350 modify it under the same terms as Perl itself.
351
352 =head1 SEE ALSO
353
354 See L<Devel::PPPort>.
355
356 =cut
357
358 use strict;
359
360 my $VERSION = 3.11;
361
362 my %opt = (
363 quiet => 0,
364 diag => 1,
365 hints => 1,
366 changes => 1,
367 cplusplus => 0,
368 filter => 1,
369 strip => 0,
370 version => 0,
371 );
372
373 my($ppport) = $0 =~ /([\w.]+)$/;
374 my $LF = '(?:\r\n|[\r\n])'; # line feed
375 my $HS = "[ \t]"; # horizontal whitespace
376
377 eval {
378 require Getopt::Long;
379 Getopt::Long::GetOptions(\%opt, qw(
380 help quiet diag! filter! hints! changes! cplusplus strip version
381 patch=s copy=s diff=s compat-version=s
382 list-provided list-unsupported api-info=s
383 )) or usage();
384 };
385
386 if ($@ and grep /^-/, @ARGV) {
387 usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
388 die "Getopt::Long not found. Please don't use any options.\n";
389 }
390
391 if ($opt{version}) {
392 print "This is $0 $VERSION.\n";
393 exit 0;
394 }
395
396 usage() if $opt{help};
397 strip() if $opt{strip};
398
399 if (exists $opt{'compat-version'}) {
400 my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
401 if ($@) {
402 die "Invalid version number format: '$opt{'compat-version'}'\n";
403 }
404 die "Only Perl 5 is supported\n" if $r != 5;
405 die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
406 $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
407 }
408 else {
409 $opt{'compat-version'} = 5;
410 }
411
412 # Never use C comments in this file!!!!!
413 my $ccs = '/'.'*';
414 my $cce = '*'.'/';
415 my $rccs = quotemeta $ccs;
416 my $rcce = quotemeta $cce;
417
418 my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
419 ? ( $1 => {
420 ($2 ? ( base => $2 ) : ()),
421 ($3 ? ( todo => $3 ) : ()),
422 (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()),
423 (index($4, 'p') >= 0 ? ( provided => 1 ) : ()),
424 (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()),
425 } )
426 : die "invalid spec: $_" } qw(
427 AvFILLp|5.004050||p
428 AvFILL|||
429 CLASS|||n
430 CX_CURPAD_SAVE|||
431 CX_CURPAD_SV|||
432 CopFILEAV|5.006000||p
433 CopFILEGV_set|5.006000||p
434 CopFILEGV|5.006000||p
435 CopFILESV|5.006000||p
436 CopFILE_set|5.006000||p
437 CopFILE|5.006000||p
438 CopSTASHPV_set|5.006000||p
439 CopSTASHPV|5.006000||p
440 CopSTASH_eq|5.006000||p
441 CopSTASH_set|5.006000||p
442 CopSTASH|5.006000||p
443 CopyD|5.009002||p
444 Copy|||
445 CvPADLIST|||
446 CvSTASH|||
447 CvWEAKOUTSIDE|||
448 DEFSV|5.004050||p
449 END_EXTERN_C|5.005000||p
450 ENTER|||
451 ERRSV|5.004050||p
452 EXTEND|||
453 EXTERN_C|5.005000||p
454 F0convert|||n
455 FREETMPS|||
456 GIMME_V||5.004000|n
457 GIMME|||n
458 GROK_NUMERIC_RADIX|5.007002||p
459 G_ARRAY|||
460 G_DISCARD|||
461 G_EVAL|||
462 G_NOARGS|||
463 G_SCALAR|||
464 G_VOID||5.004000|
465 GetVars|||
466 GvSV|||
467 Gv_AMupdate|||
468 HEf_SVKEY||5.004000|
469 HeHASH||5.004000|
470 HeKEY||5.004000|
471 HeKLEN||5.004000|
472 HePV||5.004000|
473 HeSVKEY_force||5.004000|
474 HeSVKEY_set||5.004000|
475 HeSVKEY||5.004000|
476 HeVAL||5.004000|
477 HvNAME|||
478 INT2PTR|5.006000||p
479 IN_LOCALE_COMPILETIME|5.007002||p
480 IN_LOCALE_RUNTIME|5.007002||p
481 IN_LOCALE|5.007002||p
482 IN_PERL_COMPILETIME|5.008001||p
483 IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p
484 IS_NUMBER_INFINITY|5.007002||p
485 IS_NUMBER_IN_UV|5.007002||p
486 IS_NUMBER_NAN|5.007003||p
487 IS_NUMBER_NEG|5.007002||p
488 IS_NUMBER_NOT_INT|5.007002||p
489 IVSIZE|5.006000||p
490 IVTYPE|5.006000||p
491 IVdf|5.006000||p
492 LEAVE|||
493 LVRET|||
494 MARK|||
495 MULTICALL||5.009005|
496 MY_CXT_CLONE|5.009002||p
497 MY_CXT_INIT|5.007003||p
498 MY_CXT|5.007003||p
499 MoveD|5.009002||p
500 Move|||
501 NOOP|5.005000||p
502 NUM2PTR|5.006000||p
503 NVTYPE|5.006000||p
504 NVef|5.006001||p
505 NVff|5.006001||p
506 NVgf|5.006001||p
507 Newxc|5.009003||p
508 Newxz|5.009003||p
509 Newx|5.009003||p
510 Nullav|||
511 Nullch|||
512 Nullcv|||
513 Nullhv|||
514 Nullsv|||
515 ORIGMARK|||
516 PAD_BASE_SV|||
517 PAD_CLONE_VARS|||
518 PAD_COMPNAME_FLAGS|||
519 PAD_COMPNAME_GEN_set|||
520 PAD_COMPNAME_GEN|||
521 PAD_COMPNAME_OURSTASH|||
522 PAD_COMPNAME_PV|||
523 PAD_COMPNAME_TYPE|||
524 PAD_RESTORE_LOCAL|||
525 PAD_SAVE_LOCAL|||
526 PAD_SAVE_SETNULLPAD|||
527 PAD_SETSV|||
528 PAD_SET_CUR_NOSAVE|||
529 PAD_SET_CUR|||
530 PAD_SVl|||
531 PAD_SV|||
532 PERL_ABS|5.008001||p
533 PERL_BCDVERSION|5.009005||p
534 PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
535 PERL_INT_MAX|5.004000||p
536 PERL_INT_MIN|5.004000||p
537 PERL_LONG_MAX|5.004000||p
538 PERL_LONG_MIN|5.004000||p
539 PERL_MAGIC_arylen|5.007002||p
540 PERL_MAGIC_backref|5.007002||p
541 PERL_MAGIC_bm|5.007002||p
542 PERL_MAGIC_collxfrm|5.007002||p
543 PERL_MAGIC_dbfile|5.007002||p
544 PERL_MAGIC_dbline|5.007002||p
545 PERL_MAGIC_defelem|5.007002||p
546 PERL_MAGIC_envelem|5.007002||p
547 PERL_MAGIC_env|5.007002||p
548 PERL_MAGIC_ext|5.007002||p
549 PERL_MAGIC_fm|5.007002||p
550 PERL_MAGIC_glob|5.009005||p
551 PERL_MAGIC_isaelem|5.007002||p
552 PERL_MAGIC_isa|5.007002||p
553 PERL_MAGIC_mutex|5.007002||p
554 PERL_MAGIC_nkeys|5.007002||p
555 PERL_MAGIC_overload_elem|5.007002||p
556 PERL_MAGIC_overload_table|5.007002||p
557 PERL_MAGIC_overload|5.007002||p
558 PERL_MAGIC_pos|5.007002||p
559 PERL_MAGIC_qr|5.007002||p
560 PERL_MAGIC_regdata|5.007002||p
561 PERL_MAGIC_regdatum|5.007002||p
562 PERL_MAGIC_regex_global|5.007002||p
563 PERL_MAGIC_shared_scalar|5.007003||p
564 PERL_MAGIC_shared|5.007003||p
565 PERL_MAGIC_sigelem|5.007002||p
566 PERL_MAGIC_sig|5.007002||p
567 PERL_MAGIC_substr|5.007002||p
568 PERL_MAGIC_sv|5.007002||p
569 PERL_MAGIC_taint|5.007002||p
570 PERL_MAGIC_tiedelem|5.007002||p
571 PERL_MAGIC_tiedscalar|5.007002||p
572 PERL_MAGIC_tied|5.007002||p
573 PERL_MAGIC_utf8|5.008001||p
574 PERL_MAGIC_uvar_elem|5.007003||p
575 PERL_MAGIC_uvar|5.007002||p
576 PERL_MAGIC_vec|5.007002||p
577 PERL_MAGIC_vstring|5.008001||p
578 PERL_QUAD_MAX|5.004000||p
579 PERL_QUAD_MIN|5.004000||p
580 PERL_REVISION|5.006000||p
581 PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p
582 PERL_SCAN_DISALLOW_PREFIX|5.007003||p
583 PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p
584 PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
585 PERL_SHORT_MAX|5.004000||p
586 PERL_SHORT_MIN|5.004000||p
587 PERL_SIGNALS_UNSAFE_FLAG|5.008001||p
588 PERL_SUBVERSION|5.006000||p
589 PERL_UCHAR_MAX|5.004000||p
590 PERL_UCHAR_MIN|5.004000||p
591 PERL_UINT_MAX|5.004000||p
592 PERL_UINT_MIN|5.004000||p
593 PERL_ULONG_MAX|5.004000||p
594 PERL_ULONG_MIN|5.004000||p
595 PERL_UNUSED_ARG|5.009003||p
596 PERL_UNUSED_CONTEXT|5.009004||p
597 PERL_UNUSED_DECL|5.007002||p
598 PERL_UNUSED_VAR|5.007002||p
599 PERL_UQUAD_MAX|5.004000||p
600 PERL_UQUAD_MIN|5.004000||p
601 PERL_USE_GCC_BRACE_GROUPS|5.009004||p
602 PERL_USHORT_MAX|5.004000||p
603 PERL_USHORT_MIN|5.004000||p
604 PERL_VERSION|5.006000||p
605 PL_DBsignal|5.005000||p
606 PL_DBsingle|||pn
607 PL_DBsub|||pn
608 PL_DBtrace|||pn
609 PL_Sv|5.005000||p
610 PL_compiling|5.004050||p
611 PL_copline|5.005000||p
612 PL_curcop|5.004050||p
613 PL_curstash|5.004050||p
614 PL_debstash|5.004050||p
615 PL_defgv|5.004050||p
616 PL_diehook|5.004050||p
617 PL_dirty|5.004050||p
618 PL_dowarn|||pn
619 PL_errgv|5.004050||p
620 PL_hexdigit|5.005000||p
621 PL_hints|5.005000||p
622 PL_last_in_gv|||n
623 PL_laststatval|5.005000||p
624 PL_modglobal||5.005000|n
625 PL_na|5.004050||pn
626 PL_no_modify|5.006000||p
627 PL_ofs_sv|||n
628 PL_perl_destruct_level|5.004050||p
629 PL_perldb|5.004050||p
630 PL_ppaddr|5.006000||p
631 PL_rsfp_filters|5.004050||p
632 PL_rsfp|5.004050||p
633 PL_rs|||n
634 PL_signals|5.008001||p
635 PL_stack_base|5.004050||p
636 PL_stack_sp|5.004050||p
637 PL_statcache|5.005000||p
638 PL_stdingv|5.004050||p
639 PL_sv_arenaroot|5.004050||p
640 PL_sv_no|5.004050||pn
641 PL_sv_undef|5.004050||pn
642 PL_sv_yes|5.004050||pn
643 PL_tainted|5.004050||p
644 PL_tainting|5.004050||p
645 POP_MULTICALL||5.009005|
646 POPi|||n
647 POPl|||n
648 POPn|||n
649 POPpbytex||5.007001|n
650 POPpx||5.005030|n
651 POPp|||n
652 POPs|||n
653 PTR2IV|5.006000||p
654 PTR2NV|5.006000||p
655 PTR2UV|5.006000||p
656 PTR2ul|5.007001||p
657 PTRV|5.006000||p
658 PUSHMARK|||
659 PUSH_MULTICALL||5.009005|
660 PUSHi|||
661 PUSHmortal|5.009002||p
662 PUSHn|||
663 PUSHp|||
664 PUSHs|||
665 PUSHu|5.004000||p
666 PUTBACK|||
667 PerlIO_clearerr||5.007003|
668 PerlIO_close||5.007003|
669 PerlIO_context_layers||5.009004|
670 PerlIO_eof||5.007003|
671 PerlIO_error||5.007003|
672 PerlIO_fileno||5.007003|
673 PerlIO_fill||5.007003|
674 PerlIO_flush||5.007003|
675 PerlIO_get_base||5.007003|
676 PerlIO_get_bufsiz||5.007003|
677 PerlIO_get_cnt||5.007003|
678 PerlIO_get_ptr||5.007003|
679 PerlIO_read||5.007003|
680 PerlIO_seek||5.007003|
681 PerlIO_set_cnt||5.007003|
682 PerlIO_set_ptrcnt||5.007003|
683 PerlIO_setlinebuf||5.007003|
684 PerlIO_stderr||5.007003|
685 PerlIO_stdin||5.007003|
686 PerlIO_stdout||5.007003|
687 PerlIO_tell||5.007003|
688 PerlIO_unread||5.007003|
689 PerlIO_write||5.007003|
690 Perl_warner_nocontext|5.006000||p
691 Perl_warner|5.006000||p
692 PoisonFree|5.009004||p
693 PoisonNew|5.009004||p
694 PoisonWith|5.009004||p
695 Poison|5.008000||p
696 RETVAL|||n
697 Renewc|||
698 Renew|||
699 SAVECLEARSV|||
700 SAVECOMPPAD|||
701 SAVEPADSV|||
702 SAVETMPS|||
703 SAVE_DEFSV|5.004050||p
704 SPAGAIN|||
705 SP|||
706 START_EXTERN_C|5.005000||p
707 START_MY_CXT|5.007003||p
708 STMT_END|||p
709 STMT_START|||p
710 STR_WITH_LEN|5.009003||p
711 ST|||
712 SVf|5.006000||p
713 SVt_IV|||
714 SVt_NV|||
715 SVt_PVAV|||
716 SVt_PVCV|||
717 SVt_PVHV|||
718 SVt_PVMG|||
719 SVt_PV|||
720 Safefree|||
721 Slab_Alloc|||
722 Slab_Free|||
723 StructCopy|||
724 SvCUR_set|||
725 SvCUR|||
726 SvEND|||
727 SvGAMAGIC||5.006001|
728 SvGETMAGIC|5.004050||p
729 SvGROW|||
730 SvIOK_UV||5.006000|
731 SvIOK_notUV||5.006000|
732 SvIOK_off|||
733 SvIOK_only_UV||5.006000|
734 SvIOK_only|||
735 SvIOK_on|||
736 SvIOKp|||
737 SvIOK|||
738 SvIVX|||
739 SvIV_nomg|5.009001||p
740 SvIV_set|||
741 SvIVx|||
742 SvIV|||
743 SvIsCOW_shared_hash||5.008003|
744 SvIsCOW||5.008003|
745 SvLEN_set|||
746 SvLEN|||
747 SvLOCK||5.007003|
748 SvMAGIC_set|5.009003||p
749 SvNIOK_off|||
750 SvNIOKp|||
751 SvNIOK|||
752 SvNOK_off|||
753 SvNOK_only|||
754 SvNOK_on|||
755 SvNOKp|||
756 SvNOK|||
757 SvNVX|||
758 SvNV_set|||
759 SvNVx|||
760 SvNV|||
761 SvOK|||
762 SvOOK|||
763 SvPOK_off|||
764 SvPOK_only_UTF8||5.006000|
765 SvPOK_only|||
766 SvPOK_on|||
767 SvPOKp|||
768 SvPOK|||
769 SvPVX_const|5.009003||p
770 SvPVX_mutable|5.009003||p
771 SvPVX|||
772 SvPV_force_nomg|5.007002||p
773 SvPV_force|||
774 SvPV_nolen|5.006000||p
775 SvPV_nomg|5.007002||p
776 SvPV_set|||
777 SvPVbyte_force||5.009002|
778 SvPVbyte_nolen||5.006000|
779 SvPVbytex_force||5.006000|
780 SvPVbytex||5.006000|
781 SvPVbyte|5.006000||p
782 SvPVutf8_force||5.006000|
783 SvPVutf8_nolen||5.006000|
784 SvPVutf8x_force||5.006000|
785 SvPVutf8x||5.006000|
786 SvPVutf8||5.006000|
787 SvPVx|||
788 SvPV|||
789 SvREFCNT_dec|||
790 SvREFCNT_inc_NN|5.009004||p
791 SvREFCNT_inc_simple_NN|5.009004||p
792 SvREFCNT_inc_simple_void_NN|5.009004||p
793 SvREFCNT_inc_simple_void|5.009004||p
794 SvREFCNT_inc_simple|5.009004||p
795 SvREFCNT_inc_void_NN|5.009004||p
796 SvREFCNT_inc_void|5.009004||p
797 SvREFCNT_inc|||p
798 SvREFCNT|||
799 SvROK_off|||
800 SvROK_on|||
801 SvROK|||
802 SvRV_set|5.009003||p
803 SvRV|||
804 SvSETMAGIC|||
805 SvSHARE||5.007003|
806 SvSTASH_set|5.009003||p
807 SvSTASH|||
808 SvSetMagicSV_nosteal||5.004000|
809 SvSetMagicSV||5.004000|
810 SvSetSV_nosteal||5.004000|
811 SvSetSV|||
812 SvTAINTED_off||5.004000|
813 SvTAINTED_on||5.004000|
814 SvTAINTED||5.004000|
815 SvTAINT|||
816 SvTRUE|||
817 SvTYPE|||
818 SvUNLOCK||5.007003|
819 SvUOK||5.007001|
820 SvUPGRADE|||
821 SvUTF8_off||5.006000|
822 SvUTF8_on||5.006000|
823 SvUTF8||5.006000|
824 SvUVXx|5.004000||p
825 SvUVX|5.004000||p
826 SvUV_nomg|5.009001||p
827 SvUV_set|5.009003||p
828 SvUVx|5.004000||p
829 SvUV|5.004000||p
830 SvVOK||5.008001|
831 SvVSTRING_mg|5.009004||p
832 THIS|||n
833 UNDERBAR|5.009002||p
834 UVSIZE|5.006000||p
835 UVTYPE|5.006000||p
836 UVXf|5.007001||p
837 UVof|5.006000||p
838 UVuf|5.006000||p
839 UVxf|5.006000||p
840 WARN_ALL|5.006000||p
841 WARN_AMBIGUOUS|5.006000||p
842 WARN_ASSERTIONS|5.009000||p
843 WARN_BAREWORD|5.006000||p
844 WARN_CLOSED|5.006000||p
845 WARN_CLOSURE|5.006000||p
846 WARN_DEBUGGING|5.006000||p
847 WARN_DEPRECATED|5.006000||p
848 WARN_DIGIT|5.006000||p
849 WARN_EXEC|5.006000||p
850 WARN_EXITING|5.006000||p
851 WARN_GLOB|5.006000||p
852 WARN_INPLACE|5.006000||p
853 WARN_INTERNAL|5.006000||p
854 WARN_IO|5.006000||p
855 WARN_LAYER|5.008000||p
856 WARN_MALLOC|5.006000||p
857 WARN_MISC|5.006000||p
858 WARN_NEWLINE|5.006000||p
859 WARN_NUMERIC|5.006000||p
860 WARN_ONCE|5.006000||p
861 WARN_OVERFLOW|5.006000||p
862 WARN_PACK|5.006000||p
863 WARN_PARENTHESIS|5.006000||p
864 WARN_PIPE|5.006000||p
865 WARN_PORTABLE|5.006000||p
866 WARN_PRECEDENCE|5.006000||p
867 WARN_PRINTF|5.006000||p
868 WARN_PROTOTYPE|5.006000||p
869 WARN_QW|5.006000||p
870 WARN_RECURSION|5.006000||p
871 WARN_REDEFINE|5.006000||p
872 WARN_REGEXP|5.006000||p
873 WARN_RESERVED|5.006000||p
874 WARN_SEMICOLON|5.006000||p
875 WARN_SEVERE|5.006000||p
876 WARN_SIGNAL|5.006000||p
877 WARN_SUBSTR|5.006000||p
878 WARN_SYNTAX|5.006000||p
879 WARN_TAINT|5.006000||p
880 WARN_THREADS|5.008000||p
881 WARN_UNINITIALIZED|5.006000||p
882 WARN_UNOPENED|5.006000||p
883 WARN_UNPACK|5.006000||p
884 WARN_UNTIE|5.006000||p
885 WARN_UTF8|5.006000||p
886 WARN_VOID|5.006000||p
887 XCPT_CATCH|5.009002||p
888 XCPT_RETHROW|5.009002||p
889 XCPT_TRY_END|5.009002||p
890 XCPT_TRY_START|5.009002||p
891 XPUSHi|||
892 XPUSHmortal|5.009002||p
893 XPUSHn|||
894 XPUSHp|||
895 XPUSHs|||
896 XPUSHu|5.004000||p
897 XSRETURN_EMPTY|||
898 XSRETURN_IV|||
899 XSRETURN_NO|||
900 XSRETURN_NV|||
901 XSRETURN_PV|||
902 XSRETURN_UNDEF|||
903 XSRETURN_UV|5.008001||p
904 XSRETURN_YES|||
905 XSRETURN|||p
906 XST_mIV|||
907 XST_mNO|||
908 XST_mNV|||
909 XST_mPV|||
910 XST_mUNDEF|||
911 XST_mUV|5.008001||p
912 XST_mYES|||
913 XS_VERSION_BOOTCHECK|||
914 XS_VERSION|||
915 XSprePUSH|5.006000||p
916 XS|||
917 ZeroD|5.009002||p
918 Zero|||
919 _aMY_CXT|5.007003||p
920 _pMY_CXT|5.007003||p
921 aMY_CXT_|5.007003||p
922 aMY_CXT|5.007003||p
923 aTHXR_|||p
924 aTHXR|||p
925 aTHX_|5.006000||p
926 aTHX|5.006000||p
927 add_data|||n
928 addmad|||
929 allocmy|||
930 amagic_call|||
931 amagic_cmp_locale|||
932 amagic_cmp|||
933 amagic_i_ncmp|||
934 amagic_ncmp|||
935 any_dup|||
936 ao|||
937 append_elem|||
938 append_list|||
939 append_madprops|||
940 apply_attrs_my|||
941 apply_attrs_string||5.006001|
942 apply_attrs|||
943 apply|||
944 atfork_lock||5.007003|n
945 atfork_unlock||5.007003|n
946 av_arylen_p||5.009003|
947 av_clear|||
948 av_delete||5.006000|
949 av_exists||5.006000|
950 av_extend|||
951 av_fake|||
952 av_fetch|||
953 av_fill|||
954 av_len|||
955 av_make|||
956 av_pop|||
957 av_push|||
958 av_reify|||
959 av_shift|||
960 av_store|||
961 av_undef|||
962 av_unshift|||
963 ax|||n
964 bad_type|||
965 bind_match|||
966 block_end|||
967 block_gimme||5.004000|
968 block_start|||
969 boolSV|5.004000||p
970 boot_core_PerlIO|||
971 boot_core_UNIVERSAL|||
972 boot_core_xsutils|||
973 bytes_from_utf8||5.007001|
974 bytes_to_uni|||n
975 bytes_to_utf8||5.006001|
976 call_argv|5.006000||p
977 call_atexit||5.006000|
978 call_list||5.004000|
979 call_method|5.006000||p
980 call_pv|5.006000||p
981 call_sv|5.006000||p
982 calloc||5.007002|n
983 cando|||
984 cast_i32||5.006000|
985 cast_iv||5.006000|
986 cast_ulong||5.006000|
987 cast_uv||5.006000|
988 check_type_and_open|||
989 check_uni|||
990 checkcomma|||
991 checkposixcc|||
992 ckWARN|5.006000||p
993 ck_anoncode|||
994 ck_bitop|||
995 ck_concat|||
996 ck_defined|||
997 ck_delete|||
998 ck_die|||
999 ck_eof|||
1000 ck_eval|||
1001 ck_exec|||
1002 ck_exists|||
1003 ck_exit|||
1004 ck_ftst|||
1005 ck_fun|||
1006 ck_glob|||
1007 ck_grep|||
1008 ck_index|||
1009 ck_join|||
1010 ck_lengthconst|||
1011 ck_lfun|||
1012 ck_listiob|||
1013 ck_match|||
1014 ck_method|||
1015 ck_null|||
1016 ck_open|||
1017 ck_repeat|||
1018 ck_require|||
1019 ck_retarget|||
1020 ck_return|||
1021 ck_rfun|||
1022 ck_rvconst|||
1023 ck_sassign|||
1024 ck_select|||
1025 ck_shift|||
1026 ck_sort|||
1027 ck_spair|||
1028 ck_split|||
1029 ck_subr|||
1030 ck_substr|||
1031 ck_svconst|||
1032 ck_trunc|||
1033 ck_unpack|||
1034 ckwarn_d||5.009003|
1035 ckwarn||5.009003|
1036 cl_and|||n
1037 cl_anything|||n
1038 cl_init_zero|||n
1039 cl_init|||n
1040 cl_is_anything|||n
1041 cl_or|||n
1042 clear_placeholders|||
1043 closest_cop|||
1044 convert|||
1045 cop_free|||
1046 cr_textfilter|||
1047 create_eval_scope|||
1048 croak_nocontext|||vn
1049 croak|||v
1050 csighandler||5.009003|n
1051 curmad|||
1052 custom_op_desc||5.007003|
1053 custom_op_name||5.007003|
1054 cv_ckproto_len|||
1055 cv_ckproto|||
1056 cv_clone|||
1057 cv_const_sv||5.004000|
1058 cv_dump|||
1059 cv_undef|||
1060 cx_dump||5.005000|
1061 cx_dup|||
1062 cxinc|||
1063 dAXMARK|5.009003||p
1064 dAX|5.007002||p
1065 dITEMS|5.007002||p
1066 dMARK|||
1067 dMULTICALL||5.009003|
1068 dMY_CXT_SV|5.007003||p
1069 dMY_CXT|5.007003||p
1070 dNOOP|5.006000||p
1071 dORIGMARK|||
1072 dSP|||
1073 dTHR|5.004050||p
1074 dTHXR|||p
1075 dTHXa|5.006000||p
1076 dTHXoa|5.006000||p
1077 dTHX|5.006000||p
1078 dUNDERBAR|5.009002||p
1079 dVAR|5.009003||p
1080 dXCPT|5.009002||p
1081 dXSARGS|||
1082 dXSI32|||
1083 dXSTARG|5.006000||p
1084 deb_curcv|||
1085 deb_nocontext|||vn
1086 deb_stack_all|||
1087 deb_stack_n|||
1088 debop||5.005000|
1089 debprofdump||5.005000|
1090 debprof|||
1091 debstackptrs||5.007003|
1092 debstack||5.007003|
1093 debug_start_match|||
1094 deb||5.007003|v
1095 del_sv|||
1096 delete_eval_scope|||
1097 delimcpy||5.004000|
1098 deprecate_old|||
1099 deprecate|||
1100 despatch_signals||5.007001|
1101 destroy_matcher|||
1102 die_nocontext|||vn
1103 die_where|||
1104 die|||v
1105 dirp_dup|||
1106 div128|||
1107 djSP|||
1108 do_aexec5|||
1109 do_aexec|||
1110 do_aspawn|||
1111 do_binmode||5.004050|
1112 do_chomp|||
1113 do_chop|||
1114 do_close|||
1115 do_dump_pad|||
1116 do_eof|||
1117 do_exec3|||
1118 do_execfree|||
1119 do_exec|||
1120 do_gv_dump||5.006000|
1121 do_gvgv_dump||5.006000|
1122 do_hv_dump||5.006000|
1123 do_ipcctl|||
1124 do_ipcget|||
1125 do_join|||
1126 do_kv|||
1127 do_magic_dump||5.006000|
1128 do_msgrcv|||
1129 do_msgsnd|||
1130 do_oddball|||
1131 do_op_dump||5.006000|
1132 do_op_xmldump|||
1133 do_open9||5.006000|
1134 do_openn||5.007001|
1135 do_open||5.004000|
1136 do_pipe|||
1137 do_pmop_dump||5.006000|
1138 do_pmop_xmldump|||
1139 do_print|||
1140 do_readline|||
1141 do_seek|||
1142 do_semop|||
1143 do_shmio|||
1144 do_smartmatch|||
1145 do_spawn_nowait|||
1146 do_spawn|||
1147 do_sprintf|||
1148 do_sv_dump||5.006000|
1149 do_sysseek|||
1150 do_tell|||
1151 do_trans_complex_utf8|||
1152 do_trans_complex|||
1153 do_trans_count_utf8|||
1154 do_trans_count|||
1155 do_trans_simple_utf8|||
1156 do_trans_simple|||
1157 do_trans|||
1158 do_vecget|||
1159 do_vecset|||
1160 do_vop|||
1161 docatch_body|||
1162 docatch|||
1163 doeval|||
1164 dofile|||
1165 dofindlabel|||
1166 doform|||
1167 doing_taint||5.008001|n
1168 dooneliner|||
1169 doopen_pm|||
1170 doparseform|||
1171 dopoptoeval|||
1172 dopoptogiven|||
1173 dopoptolabel|||
1174 dopoptoloop|||
1175 dopoptosub_at|||
1176 dopoptosub|||
1177 dopoptowhen|||
1178 doref||5.009003|
1179 dounwind|||
1180 dowantarray|||
1181 dump_all||5.006000|
1182 dump_eval||5.006000|
1183 dump_exec_pos|||
1184 dump_fds|||
1185 dump_form||5.006000|
1186 dump_indent||5.006000|v
1187 dump_mstats|||
1188 dump_packsubs||5.006000|
1189 dump_sub||5.006000|
1190 dump_sv_child|||
1191 dump_trie_interim_list|||
1192 dump_trie_interim_table|||
1193 dump_trie|||
1194 dump_vindent||5.006000|
1195 dumpuntil|||
1196 dup_attrlist|||
1197 emulate_eaccess|||
1198 eval_pv|5.006000||p
1199 eval_sv|5.006000||p
1200 exec_failed|||
1201 expect_number|||
1202 fbm_compile||5.005000|
1203 fbm_instr||5.005000|
1204 fd_on_nosuid_fs|||
1205 feature_is_enabled|||
1206 filter_add|||
1207 filter_del|||
1208 filter_gets|||
1209 filter_read|||
1210 find_array_subscript|||
1211 find_beginning|||
1212 find_byclass|||
1213 find_hash_subscript|||
1214 find_in_my_stash|||
1215 find_runcv|||
1216 find_rundefsvoffset||5.009002|
1217 find_script|||
1218 find_uninit_var|||
1219 first_symbol|||n
1220 fold_constants|||
1221 forbid_setid|||
1222 force_ident|||
1223 force_list|||
1224 force_next|||
1225 force_version|||
1226 force_word|||
1227 form_nocontext|||vn
1228 form||5.004000|v
1229 fp_dup|||
1230 fprintf_nocontext|||vn
1231 free_global_struct|||
1232 free_tied_hv_pool|||
1233 free_tmps|||
1234 gen_constant_list|||
1235 get_arena|||
1236 get_av|5.006000||p
1237 get_context||5.006000|n
1238 get_cv|5.006000||p
1239 get_db_sub|||
1240 get_debug_opts|||
1241 get_hash_seed|||
1242 get_hv|5.006000||p
1243 get_mstats|||
1244 get_no_modify|||
1245 get_num|||
1246 get_op_descs||5.005000|
1247 get_op_names||5.005000|
1248 get_opargs|||
1249 get_ppaddr||5.006000|
1250 get_sv|5.006000||p
1251 get_vtbl||5.005030|
1252 getcwd_sv||5.007002|
1253 getenv_len|||
1254 glob_2number|||
1255 glob_2pv|||
1256 glob_assign_glob|||
1257 glob_assign_ref|||
1258 gp_dup|||
1259 gp_free|||
1260 gp_ref|||
1261 grok_bin|5.007003||p
1262 grok_hex|5.007003||p
1263 grok_number|5.007002||p
1264 grok_numeric_radix|5.007002||p
1265 grok_oct|5.007003||p
1266 group_end|||
1267 gv_AVadd|||
1268 gv_HVadd|||
1269 gv_IOadd|||
1270 gv_SVadd|||
1271 gv_autoload4||5.004000|
1272 gv_check|||
1273 gv_const_sv||5.009003|
1274 gv_dump||5.006000|
1275 gv_efullname3||5.004000|
1276 gv_efullname4||5.006001|
1277 gv_efullname|||
1278 gv_ename|||
1279 gv_fetchfile|||
1280 gv_fetchmeth_autoload||5.007003|
1281 gv_fetchmethod_autoload||5.004000|
1282 gv_fetchmethod|||
1283 gv_fetchmeth|||
1284 gv_fetchpvn_flags||5.009002|
1285 gv_fetchpv|||
1286 gv_fetchsv||5.009002|
1287 gv_fullname3||5.004000|
1288 gv_fullname4||5.006001|
1289 gv_fullname|||
1290 gv_handler||5.007001|
1291 gv_init_sv|||
1292 gv_init|||
1293 gv_name_set||5.009004|
1294 gv_stashpvn|5.004000||p
1295 gv_stashpvs||5.009003|
1296 gv_stashpv|||
1297 gv_stashsv|||
1298 he_dup|||
1299 hek_dup|||
1300 hfreeentries|||
1301 hsplit|||
1302 hv_assert||5.009005|
1303 hv_auxinit|||n
1304 hv_backreferences_p|||
1305 hv_clear_placeholders||5.009001|
1306 hv_clear|||
1307 hv_copy_hints_hv|||
1308 hv_delayfree_ent||5.004000|
1309 hv_delete_common|||
1310 hv_delete_ent||5.004000|
1311 hv_delete|||
1312 hv_eiter_p||5.009003|
1313 hv_eiter_set||5.009003|
1314 hv_exists_ent||5.004000|
1315 hv_exists|||
1316 hv_fetch_common|||
1317 hv_fetch_ent||5.004000|
1318 hv_fetchs|5.009003||p
1319 hv_fetch|||
1320 hv_free_ent||5.004000|
1321 hv_iterinit|||
1322 hv_iterkeysv||5.004000|
1323 hv_iterkey|||
1324 hv_iternext_flags||5.008000|
1325 hv_iternextsv|||
1326 hv_iternext|||
1327 hv_iterval|||
1328 hv_kill_backrefs|||
1329 hv_ksplit||5.004000|
1330 hv_magic_check|||n
1331 hv_magic_uvar_xkey|||
1332 hv_magic|||
1333 hv_name_set||5.009003|
1334 hv_notallowed|||
1335 hv_placeholders_get||5.009003|
1336 hv_placeholders_p||5.009003|
1337 hv_placeholders_set||5.009003|
1338 hv_riter_p||5.009003|
1339 hv_riter_set||5.009003|
1340 hv_scalar||5.009001|
1341 hv_store_ent||5.004000|
1342 hv_store_flags||5.008000|
1343 hv_stores|5.009004||p
1344 hv_store|||
1345 hv_undef|||
1346 ibcmp_locale||5.004000|
1347 ibcmp_utf8||5.007003|
1348 ibcmp|||
1349 incl_perldb|||
1350 incline|||
1351 incpush_if_exists|||
1352 incpush|||
1353 ingroup|||
1354 init_argv_symbols|||
1355 init_debugger|||
1356 init_global_struct|||
1357 init_i18nl10n||5.006000|
1358 init_i18nl14n||5.006000|
1359 init_ids|||
1360 init_interp|||
1361 init_lexer|||
1362 init_main_stash|||
1363 init_perllib|||
1364 init_postdump_symbols|||
1365 init_predump_symbols|||
1366 init_stacks||5.005000|
1367 init_tm||5.007002|
1368 instr|||
1369 intro_my|||
1370 intuit_method|||
1371 intuit_more|||
1372 invert|||
1373 io_close|||
1374 isALNUM|||
1375 isALPHA|||
1376 isDIGIT|||
1377 isLOWER|||
1378 isSPACE|||
1379 isUPPER|||
1380 is_an_int|||
1381 is_gv_magical_sv|||
1382 is_gv_magical|||
1383 is_handle_constructor|||n
1384 is_list_assignment|||
1385 is_lvalue_sub||5.007001|
1386 is_uni_alnum_lc||5.006000|
1387 is_uni_alnumc_lc||5.006000|
1388 is_uni_alnumc||5.006000|
1389 is_uni_alnum||5.006000|
1390 is_uni_alpha_lc||5.006000|
1391 is_uni_alpha||5.006000|
1392 is_uni_ascii_lc||5.006000|
1393 is_uni_ascii||5.006000|
1394 is_uni_cntrl_lc||5.006000|
1395 is_uni_cntrl||5.006000|
1396 is_uni_digit_lc||5.006000|
1397 is_uni_digit||5.006000|
1398 is_uni_graph_lc||5.006000|
1399 is_uni_graph||5.006000|
1400 is_uni_idfirst_lc||5.006000|
1401 is_uni_idfirst||5.006000|
1402 is_uni_lower_lc||5.006000|
1403 is_uni_lower||5.006000|
1404 is_uni_print_lc||5.006000|
1405 is_uni_print||5.006000|
1406 is_uni_punct_lc||5.006000|
1407 is_uni_punct||5.006000|
1408 is_uni_space_lc||5.006000|
1409 is_uni_space||5.006000|
1410 is_uni_upper_lc||5.006000|
1411 is_uni_upper||5.006000|
1412 is_uni_xdigit_lc||5.006000|
1413 is_uni_xdigit||5.006000|
1414 is_utf8_alnumc||5.006000|
1415 is_utf8_alnum||5.006000|
1416 is_utf8_alpha||5.006000|
1417 is_utf8_ascii||5.006000|
1418 is_utf8_char_slow|||n
1419 is_utf8_char||5.006000|
1420 is_utf8_cntrl||5.006000|
1421 is_utf8_common|||
1422 is_utf8_digit||5.006000|
1423 is_utf8_graph||5.006000|
1424 is_utf8_idcont||5.008000|
1425 is_utf8_idfirst||5.006000|
1426 is_utf8_lower||5.006000|
1427 is_utf8_mark||5.006000|
1428 is_utf8_print||5.006000|
1429 is_utf8_punct||5.006000|
1430 is_utf8_space||5.006000|
1431 is_utf8_string_loclen||5.009003|
1432 is_utf8_string_loc||5.008001|
1433 is_utf8_string||5.006001|
1434 is_utf8_upper||5.006000|
1435 is_utf8_xdigit||5.006000|
1436 isa_lookup|||
1437 items|||n
1438 ix|||n
1439 jmaybe|||
1440 join_exact|||
1441 keyword|||
1442 leave_scope|||
1443 lex_end|||
1444 lex_start|||
1445 linklist|||
1446 listkids|||
1447 list|||
1448 load_module_nocontext|||vn
1449 load_module||5.006000|v
1450 localize|||
1451 looks_like_bool|||
1452 looks_like_number|||
1453 lop|||
1454 mPUSHi|5.009002||p
1455 mPUSHn|5.009002||p
1456 mPUSHp|5.009002||p
1457 mPUSHu|5.009002||p
1458 mXPUSHi|5.009002||p
1459 mXPUSHn|5.009002||p
1460 mXPUSHp|5.009002||p
1461 mXPUSHu|5.009002||p
1462 mad_free|||
1463 madlex|||
1464 madparse|||
1465 magic_clear_all_env|||
1466 magic_clearenv|||
1467 magic_clearhint|||
1468 magic_clearpack|||
1469 magic_clearsig|||
1470 magic_dump||5.006000|
1471 magic_existspack|||
1472 magic_freearylen_p|||
1473 magic_freeovrld|||
1474 magic_freeregexp|||
1475 magic_getarylen|||
1476 magic_getdefelem|||
1477 magic_getnkeys|||
1478 magic_getpack|||
1479 magic_getpos|||
1480 magic_getsig|||
1481 magic_getsubstr|||
1482 magic_gettaint|||
1483 magic_getuvar|||
1484 magic_getvec|||
1485 magic_get|||
1486 magic_killbackrefs|||
1487 magic_len|||
1488 magic_methcall|||
1489 magic_methpack|||
1490 magic_nextpack|||
1491 magic_regdata_cnt|||
1492 magic_regdatum_get|||
1493 magic_regdatum_set|||
1494 magic_scalarpack|||
1495 magic_set_all_env|||
1496 magic_setamagic|||
1497 magic_setarylen|||
1498 magic_setbm|||
1499 magic_setcollxfrm|||
1500 magic_setdbline|||
1501 magic_setdefelem|||
1502 magic_setenv|||
1503 magic_setfm|||
1504 magic_setglob|||
1505 magic_sethint|||
1506 magic_setisa|||
1507 magic_setmglob|||
1508 magic_setnkeys|||
1509 magic_setpack|||
1510 magic_setpos|||
1511 magic_setregexp|||
1512 magic_setsig|||
1513 magic_setsubstr|||
1514 magic_settaint|||
1515 magic_setutf8|||
1516 magic_setuvar|||
1517 magic_setvec|||
1518 magic_set|||
1519 magic_sizepack|||
1520 magic_wipepack|||
1521 magicname|||
1522 make_matcher|||
1523 make_trie_failtable|||
1524 make_trie|||
1525 malloced_size|||n
1526 malloc||5.007002|n
1527 markstack_grow|||
1528 matcher_matches_sv|||
1529 measure_struct|||
1530 memEQ|5.004000||p
1531 memNE|5.004000||p
1532 mem_collxfrm|||
1533 mess_alloc|||
1534 mess_nocontext|||vn
1535 mess||5.006000|v
1536 method_common|||
1537 mfree||5.007002|n
1538 mg_clear|||
1539 mg_copy|||
1540 mg_dup|||
1541 mg_find|||
1542 mg_free|||
1543 mg_get|||
1544 mg_length||5.005000|
1545 mg_localize|||
1546 mg_magical|||
1547 mg_set|||
1548 mg_size||5.005000|
1549 mini_mktime||5.007002|
1550 missingterm|||
1551 mode_from_discipline|||
1552 modkids|||
1553 mod|||
1554 more_bodies|||
1555 more_sv|||
1556 moreswitches|||
1557 mul128|||
1558 mulexp10|||n
1559 my_atof2||5.007002|
1560 my_atof||5.006000|
1561 my_attrs|||
1562 my_bcopy|||n
1563 my_betoh16|||n
1564 my_betoh32|||n
1565 my_betoh64|||n
1566 my_betohi|||n
1567 my_betohl|||n
1568 my_betohs|||n
1569 my_bzero|||n
1570 my_chsize|||
1571 my_clearenv|||
1572 my_cxt_init|||
1573 my_exit_jump|||
1574 my_exit|||
1575 my_failure_exit||5.004000|
1576 my_fflush_all||5.006000|
1577 my_fork||5.007003|n
1578 my_htobe16|||n
1579 my_htobe32|||n
1580 my_htobe64|||n
1581 my_htobei|||n
1582 my_htobel|||n
1583 my_htobes|||n
1584 my_htole16|||n
1585 my_htole32|||n
1586 my_htole64|||n
1587 my_htolei|||n
1588 my_htolel|||n
1589 my_htoles|||n
1590 my_htonl|||
1591 my_kid|||
1592 my_letoh16|||n
1593 my_letoh32|||n
1594 my_letoh64|||n
1595 my_letohi|||n
1596 my_letohl|||n
1597 my_letohs|||n
1598 my_lstat|||
1599 my_memcmp||5.004000|n
1600 my_memset|||n
1601 my_ntohl|||
1602 my_pclose||5.004000|
1603 my_popen_list||5.007001|
1604 my_popen||5.004000|
1605 my_setenv|||
1606 my_snprintf|5.009004||pvn
1607 my_socketpair||5.007003|n
1608 my_sprintf||5.009003|vn
1609 my_stat|||
1610 my_strftime||5.007002|
1611 my_strlcat|5.009004||pn
1612 my_strlcpy|5.009004||pn
1613 my_swabn|||n
1614 my_swap|||
1615 my_unexec|||
1616 my_vsnprintf||5.009004|n
1617 my|||
1618 need_utf8|||n
1619 newANONATTRSUB||5.006000|
1620 newANONHASH|||
1621 newANONLIST|||
1622 newANONSUB|||
1623 newASSIGNOP|||
1624 newATTRSUB||5.006000|
1625 newAVREF|||
1626 newAV|||
1627 newBINOP|||
1628 newCONDOP|||
1629 newCONSTSUB|5.004050||p
1630 newCVREF|||
1631 newDEFSVOP|||
1632 newFORM|||
1633 newFOROP|||
1634 newGIVENOP||5.009003|
1635 newGIVWHENOP|||
1636 newGP|||
1637 newGVOP|||
1638 newGVREF|||
1639 newGVgen|||
1640 newHVREF|||
1641 newHVhv||5.005000|
1642 newHV|||
1643 newIO|||
1644 newLISTOP|||
1645 newLOGOP|||
1646 newLOOPEX|||
1647 newLOOPOP|||
1648 newMADPROP|||
1649 newMADsv|||
1650 newMYSUB|||
1651 newNULLLIST|||
1652 newOP|||
1653 newPADOP||5.006000|
1654 newPMOP|||
1655 newPROG|||
1656 newPVOP|||
1657 newRANGE|||
1658 newRV_inc|5.004000||p
1659 newRV_noinc|5.004000||p
1660 newRV|||
1661 newSLICEOP|||
1662 newSTATEOP|||
1663 newSUB|||
1664 newSVOP|||
1665 newSVREF|||
1666 newSVhek||5.009003|
1667 newSViv|||
1668 newSVnv|||
1669 newSVpvf_nocontext|||vn
1670 newSVpvf||5.004000|v
1671 newSVpvn_share||5.007001|
1672 newSVpvn|5.004050||p
1673 newSVpvs_share||5.009003|
1674 newSVpvs|5.009003||p
1675 newSVpv|||
1676 newSVrv|||
1677 newSVsv|||
1678 newSVuv|5.006000||p
1679 newSV|||
1680 newTOKEN|||
1681 newUNOP|||
1682 newWHENOP||5.009003|
1683 newWHILEOP||5.009003|
1684 newXS_flags||5.009004|
1685 newXSproto||5.006000|
1686 newXS||5.006000|
1687 new_collate||5.006000|
1688 new_constant|||
1689 new_ctype||5.006000|
1690 new_he|||
1691 new_logop|||
1692 new_numeric||5.006000|
1693 new_stackinfo||5.005000|
1694 new_version||5.009000|
1695 new_warnings_bitfield|||
1696 next_symbol|||
1697 nextargv|||
1698 nextchar|||
1699 ninstr|||
1700 no_bareword_allowed|||
1701 no_fh_allowed|||
1702 no_op|||
1703 not_a_number|||
1704 nothreadhook||5.008000|
1705 nuke_stacks|||
1706 num_overflow|||n
1707 offer_nice_chunk|||
1708 oopsAV|||
1709 oopsCV|||
1710 oopsHV|||
1711 op_clear|||
1712 op_const_sv|||
1713 op_dump||5.006000|
1714 op_free|||
1715 op_getmad_weak|||
1716 op_getmad|||
1717 op_null||5.007002|
1718 op_refcnt_lock||5.009002|
1719 op_refcnt_unlock||5.009002|
1720 op_xmldump|||
1721 open_script|||
1722 pMY_CXT_|5.007003||p
1723 pMY_CXT|5.007003||p
1724 pTHX_|5.006000||p
1725 pTHX|5.006000||p
1726 packWARN|5.007003||p
1727 pack_cat||5.007003|
1728 pack_rec|||
1729 package|||
1730 packlist||5.008001|
1731 pad_add_anon|||
1732 pad_add_name|||
1733 pad_alloc|||
1734 pad_block_start|||
1735 pad_check_dup|||
1736 pad_compname_type|||
1737 pad_findlex|||
1738 pad_findmy|||
1739 pad_fixup_inner_anons|||
1740 pad_free|||
1741 pad_leavemy|||
1742 pad_new|||
1743 pad_peg|||n
1744 pad_push|||
1745 pad_reset|||
1746 pad_setsv|||
1747 pad_sv||5.009005|
1748 pad_swipe|||
1749 pad_tidy|||
1750 pad_undef|||
1751 parse_body|||
1752 parse_unicode_opts|||
1753 path_is_absolute|||n
1754 peep|||
1755 pending_ident|||
1756 perl_alloc_using|||n
1757 perl_alloc|||n
1758 perl_clone_using|||n
1759 perl_clone|||n
1760 perl_construct|||n
1761 perl_destruct||5.007003|n
1762 perl_free|||n
1763 perl_parse||5.006000|n
1764 perl_run|||n
1765 pidgone|||
1766 pm_description|||
1767 pmflag|||
1768 pmop_dump||5.006000|
1769 pmop_xmldump|||
1770 pmruntime|||
1771 pmtrans|||
1772 pop_scope|||
1773 pregcomp|||
1774 pregexec|||
1775 pregfree|||
1776 prepend_elem|||
1777 prepend_madprops|||
1778 printbuf|||
1779 printf_nocontext|||vn
1780 ptr_table_clear|||
1781 ptr_table_fetch|||
1782 ptr_table_find|||n
1783 ptr_table_free|||
1784 ptr_table_new|||
1785 ptr_table_split|||
1786 ptr_table_store|||
1787 push_scope|||
1788 put_byte|||
1789 pv_display||5.006000|
1790 pv_escape||5.009004|
1791 pv_pretty||5.009004|
1792 pv_uni_display||5.007003|
1793 qerror|||
1794 qsortsvu|||
1795 re_croak2|||
1796 re_dup|||
1797 re_intuit_start||5.006000|
1798 re_intuit_string||5.006000|
1799 readpipe_override|||
1800 realloc||5.007002|n
1801 reentrant_free|||
1802 reentrant_init|||
1803 reentrant_retry|||vn
1804 reentrant_size|||
1805 ref_array_or_hash|||
1806 refcounted_he_chain_2hv|||
1807 refcounted_he_fetch|||
1808 refcounted_he_free|||
1809 refcounted_he_new|||
1810 refcounted_he_value|||
1811 refkids|||
1812 refto|||
1813 ref||5.009003|
1814 reg_check_named_buff_matched|||
1815 reg_named_buff_sv|||
1816 reg_namedseq|||
1817 reg_node|||
1818 reg_recode|||
1819 reg_scan_name|||
1820 reg_stringify|||
1821 reganode|||
1822 regatom|||
1823 regbranch|||
1824 regclass_swash||5.009004|
1825 regclass|||
1826 regcppop|||
1827 regcppush|||
1828 regcurly|||n
1829 regdump||5.005000|
1830 regdupe|||
1831 regexec_flags||5.005000|
1832 reghop3|||n
1833 reghop4|||n
1834 reghopmaybe3|||n
1835 reginclass|||
1836 reginitcolors||5.006000|
1837 reginsert|||
1838 regmatch|||
1839 regnext||5.005000|
1840 regpiece|||
1841 regpposixcc|||
1842 regprop|||
1843 regrepeat|||
1844 regtail_study|||
1845 regtail|||
1846 regtry|||
1847 reguni|||
1848 regwhite|||n
1849 reg|||
1850 repeatcpy|||
1851 report_evil_fh|||
1852 report_uninit|||
1853 require_errno|||
1854 require_pv||5.006000|
1855 restore_magic|||
1856 rninstr|||
1857 rsignal_restore|||
1858 rsignal_save|||
1859 rsignal_state||5.004000|
1860 rsignal||5.004000|
1861 run_body|||
1862 run_user_filter|||
1863 runops_debug||5.005000|
1864 runops_standard||5.005000|
1865 rvpv_dup|||
1866 rxres_free|||
1867 rxres_restore|||
1868 rxres_save|||
1869 safesyscalloc||5.006000|n
1870 safesysfree||5.006000|n
1871 safesysmalloc||5.006000|n
1872 safesysrealloc||5.006000|n
1873 same_dirent|||
1874 save_I16||5.004000|
1875 save_I32|||
1876 save_I8||5.006000|
1877 save_aelem||5.004050|
1878 save_alloc||5.006000|
1879 save_aptr|||
1880 save_ary|||
1881 save_bool||5.008001|
1882 save_clearsv|||
1883 save_delete|||
1884 save_destructor_x||5.006000|
1885 save_destructor||5.006000|
1886 save_freeop|||
1887 save_freepv|||
1888 save_freesv|||
1889 save_generic_pvref||5.006001|
1890 save_generic_svref||5.005030|
1891 save_gp||5.004000|
1892 save_hash|||
1893 save_hek_flags|||n
1894 save_helem||5.004050|
1895 save_hints||5.005000|
1896 save_hptr|||
1897 save_int|||
1898 save_item|||
1899 save_iv||5.005000|
1900 save_lines|||
1901 save_list|||
1902 save_long|||
1903 save_magic|||
1904 save_mortalizesv||5.007001|
1905 save_nogv|||
1906 save_op|||
1907 save_padsv||5.007001|
1908 save_pptr|||
1909 save_re_context||5.006000|
1910 save_scalar_at|||
1911 save_scalar|||
1912 save_set_svflags||5.009000|
1913 save_shared_pvref||5.007003|
1914 save_sptr|||
1915 save_svref|||
1916 save_vptr||5.006000|
1917 savepvn|||
1918 savepvs||5.009003|
1919 savepv|||
1920 savesharedpv||5.007003|
1921 savestack_grow_cnt||5.008001|
1922 savestack_grow|||
1923 savesvpv||5.009002|
1924 sawparens|||
1925 scalar_mod_type|||n
1926 scalarboolean|||
1927 scalarkids|||
1928 scalarseq|||
1929 scalarvoid|||
1930 scalar|||
1931 scan_bin||5.006000|
1932 scan_commit|||
1933 scan_const|||
1934 scan_formline|||
1935 scan_heredoc|||
1936 scan_hex|||
1937 scan_ident|||
1938 scan_inputsymbol|||
1939 scan_num||5.007001|
1940 scan_oct|||
1941 scan_pat|||
1942 scan_str|||
1943 scan_subst|||
1944 scan_trans|||
1945 scan_version||5.009001|
1946 scan_vstring||5.008001|
1947 scan_word|||
1948 scope|||
1949 screaminstr||5.005000|
1950 seed||5.008001|
1951 sequence_num|||
1952 sequence_tail|||
1953 sequence|||
1954 set_context||5.006000|n
1955 set_csh|||
1956 set_numeric_local||5.006000|
1957 set_numeric_radix||5.006000|
1958 set_numeric_standard||5.006000|
1959 setdefout|||
1960 setenv_getix|||
1961 share_hek_flags|||
1962 share_hek||5.004000|
1963 si_dup|||
1964 sighandler|||n
1965 simplify_sort|||
1966 skipspace0|||
1967 skipspace1|||
1968 skipspace2|||
1969 skipspace|||
1970 sortcv_stacked|||
1971 sortcv_xsub|||
1972 sortcv|||
1973 sortsv_flags||5.009003|
1974 sortsv||5.007003|
1975 space_join_names_mortal|||
1976 ss_dup|||
1977 stack_grow|||
1978 start_force|||
1979 start_glob|||
1980 start_subparse||5.004000|
1981 stashpv_hvname_match||5.009005|
1982 stdize_locale|||
1983 strEQ|||
1984 strGE|||
1985 strGT|||
1986 strLE|||
1987 strLT|||
1988 strNE|||
1989 str_to_version||5.006000|
1990 strip_return|||
1991 strnEQ|||
1992 strnNE|||
1993 study_chunk|||
1994 sub_crush_depth|||
1995 sublex_done|||
1996 sublex_push|||
1997 sublex_start|||
1998 sv_2bool|||
1999 sv_2cv|||
2000 sv_2io|||
2001 sv_2iuv_common|||
2002 sv_2iuv_non_preserve|||
2003 sv_2iv_flags||5.009001|
2004 sv_2iv|||
2005 sv_2mortal|||
2006 sv_2nv|||
2007 sv_2pv_flags||5.007002|
2008 sv_2pv_nolen|5.006000||p
2009 sv_2pvbyte_nolen|||
2010 sv_2pvbyte|5.006000||p
2011 sv_2pvutf8_nolen||5.006000|
2012 sv_2pvutf8||5.006000|
2013 sv_2pv|||
2014 sv_2uv_flags||5.009001|
2015 sv_2uv|5.004000||p
2016 sv_add_arena|||
2017 sv_add_backref|||
2018 sv_backoff|||
2019 sv_bless|||
2020 sv_cat_decode||5.008001|
2021 sv_catpv_mg|5.004050||p
2022 sv_catpvf_mg_nocontext|||pvn
2023 sv_catpvf_mg|5.006000|5.004000|pv
2024 sv_catpvf_nocontext|||vn
2025 sv_catpvf||5.004000|v
2026 sv_catpvn_flags||5.007002|
2027 sv_catpvn_mg|5.004050||p
2028 sv_catpvn_nomg|5.007002||p
2029 sv_catpvn|||
2030 sv_catpvs|5.009003||p
2031 sv_catpv|||
2032 sv_catsv_flags||5.007002|
2033 sv_catsv_mg|5.004050||p
2034 sv_catsv_nomg|5.007002||p
2035 sv_catsv|||
2036 sv_catxmlpvn|||
2037 sv_catxmlsv|||
2038 sv_chop|||
2039 sv_clean_all|||
2040 sv_clean_objs|||
2041 sv_clear|||
2042 sv_cmp_locale||5.004000|
2043 sv_cmp|||
2044 sv_collxfrm|||
2045 sv_compile_2op||5.008001|
2046 sv_copypv||5.007003|
2047 sv_dec|||
2048 sv_del_backref|||
2049 sv_derived_from||5.004000|
2050 sv_does||5.009004|
2051 sv_dump|||
2052 sv_dup|||
2053 sv_eq|||
2054 sv_exp_grow|||
2055 sv_force_normal_flags||5.007001|
2056 sv_force_normal||5.006000|
2057 sv_free2|||
2058 sv_free_arenas|||
2059 sv_free|||
2060 sv_gets||5.004000|
2061 sv_grow|||
2062 sv_i_ncmp|||
2063 sv_inc|||
2064 sv_insert|||
2065 sv_isa|||
2066 sv_isobject|||
2067 sv_iv||5.005000|
2068 sv_kill_backrefs|||
2069 sv_len_utf8||5.006000|
2070 sv_len|||
2071 sv_magicext||5.007003|
2072 sv_magic|||
2073 sv_mortalcopy|||
2074 sv_ncmp|||
2075 sv_newmortal|||
2076 sv_newref|||
2077 sv_nolocking||5.007003|
2078 sv_nosharing||5.007003|
2079 sv_nounlocking|||
2080 sv_nv||5.005000|
2081 sv_peek||5.005000|
2082 sv_pos_b2u_midway|||
2083 sv_pos_b2u||5.006000|
2084 sv_pos_u2b_cached|||
2085 sv_pos_u2b_forwards|||n
2086 sv_pos_u2b_midway|||n
2087 sv_pos_u2b||5.006000|
2088 sv_pvbyten_force||5.006000|
2089 sv_pvbyten||5.006000|
2090 sv_pvbyte||5.006000|
2091 sv_pvn_force_flags||5.007002|
2092 sv_pvn_force|||p
2093 sv_pvn_nomg|5.007003||p
2094 sv_pvn|5.005000||p
2095 sv_pvutf8n_force||5.006000|
2096 sv_pvutf8n||5.006000|
2097 sv_pvutf8||5.006000|
2098 sv_pv||5.006000|
2099 sv_recode_to_utf8||5.007003|
2100 sv_reftype|||
2101 sv_release_COW|||
2102 sv_release_IVX|||
2103 sv_replace|||
2104 sv_report_used|||
2105 sv_reset|||
2106 sv_rvweaken||5.006000|
2107 sv_setiv_mg|5.004050||p
2108 sv_setiv|||
2109 sv_setnv_mg|5.006000||p
2110 sv_setnv|||
2111 sv_setpv_mg|5.004050||p
2112 sv_setpvf_mg_nocontext|||pvn
2113 sv_setpvf_mg|5.006000|5.004000|pv
2114 sv_setpvf_nocontext|||vn
2115 sv_setpvf||5.004000|v
2116 sv_setpviv_mg||5.008001|
2117 sv_setpviv||5.008001|
2118 sv_setpvn_mg|5.004050||p
2119 sv_setpvn|||
2120 sv_setpvs|5.009004||p
2121 sv_setpv|||
2122 sv_setref_iv|||
2123 sv_setref_nv|||
2124 sv_setref_pvn|||
2125 sv_setref_pv|||
2126 sv_setref_uv||5.007001|
2127 sv_setsv_cow|||
2128 sv_setsv_flags||5.007002|
2129 sv_setsv_mg|5.004050||p
2130 sv_setsv_nomg|5.007002||p
2131 sv_setsv|||
2132 sv_setuv_mg|5.004050||p
2133 sv_setuv|5.004000||p
2134 sv_tainted||5.004000|
2135 sv_taint||5.004000|
2136 sv_true||5.005000|
2137 sv_unglob|||
2138 sv_uni_display||5.007003|
2139 sv_unmagic|||
2140 sv_unref_flags||5.007001|
2141 sv_unref|||
2142 sv_untaint||5.004000|
2143 sv_upgrade|||
2144 sv_usepvn_flags||5.009004|
2145 sv_usepvn_mg|5.004050||p
2146 sv_usepvn|||
2147 sv_utf8_decode||5.006000|
2148 sv_utf8_downgrade||5.006000|
2149 sv_utf8_encode||5.006000|
2150 sv_utf8_upgrade_flags||5.007002|
2151 sv_utf8_upgrade||5.007001|
2152 sv_uv|5.005000||p
2153 sv_vcatpvf_mg|5.006000|5.004000|p
2154 sv_vcatpvfn||5.004000|
2155 sv_vcatpvf|5.006000|5.004000|p
2156 sv_vsetpvf_mg|5.006000|5.004000|p
2157 sv_vsetpvfn||5.004000|
2158 sv_vsetpvf|5.006000|5.004000|p
2159 sv_xmlpeek|||
2160 svtype|||
2161 swallow_bom|||
2162 swash_fetch||5.007002|
2163 swash_get|||
2164 swash_init||5.006000|
2165 sys_intern_clear|||
2166 sys_intern_dup|||
2167 sys_intern_init|||
2168 taint_env|||
2169 taint_proper|||
2170 tmps_grow||5.006000|
2171 toLOWER|||
2172 toUPPER|||
2173 to_byte_substr|||
2174 to_uni_fold||5.007003|
2175 to_uni_lower_lc||5.006000|
2176 to_uni_lower||5.007003|
2177 to_uni_title_lc||5.006000|
2178 to_uni_title||5.007003|
2179 to_uni_upper_lc||5.006000|
2180 to_uni_upper||5.007003|
2181 to_utf8_case||5.007003|
2182 to_utf8_fold||5.007003|
2183 to_utf8_lower||5.007003|
2184 to_utf8_substr|||
2185 to_utf8_title||5.007003|
2186 to_utf8_upper||5.007003|
2187 token_free|||
2188 token_getmad|||
2189 tokenize_use|||
2190 tokeq|||
2191 tokereport|||
2192 too_few_arguments|||
2193 too_many_arguments|||
2194 uiv_2buf|||n
2195 unlnk|||
2196 unpack_rec|||
2197 unpack_str||5.007003|
2198 unpackstring||5.008001|
2199 unshare_hek_or_pvn|||
2200 unshare_hek|||
2201 unsharepvn||5.004000|
2202 unwind_handler_stack|||
2203 upg_version||5.009000|
2204 usage|||
2205 utf16_to_utf8_reversed||5.006001|
2206 utf16_to_utf8||5.006001|
2207 utf8_distance||5.006000|
2208 utf8_hop||5.006000|
2209 utf8_length||5.007001|
2210 utf8_mg_pos_cache_update|||
2211 utf8_to_bytes||5.006001|
2212 utf8_to_uvchr||5.007001|
2213 utf8_to_uvuni||5.007001|
2214 utf8n_to_uvchr|||
2215 utf8n_to_uvuni||5.007001|
2216 utilize|||
2217 uvchr_to_utf8_flags||5.007003|
2218 uvchr_to_utf8|||
2219 uvuni_to_utf8_flags||5.007003|
2220 uvuni_to_utf8||5.007001|
2221 validate_suid|||
2222 varname|||
2223 vcmp||5.009000|
2224 vcroak||5.006000|
2225 vdeb||5.007003|
2226 vdie_common|||
2227 vdie_croak_common|||
2228 vdie|||
2229 vform||5.006000|
2230 visit|||
2231 vivify_defelem|||
2232 vivify_ref|||
2233 vload_module||5.006000|
2234 vmess||5.006000|
2235 vnewSVpvf|5.006000|5.004000|p
2236 vnormal||5.009002|
2237 vnumify||5.009000|
2238 vstringify||5.009000|
2239 vverify||5.009003|
2240 vwarner||5.006000|
2241 vwarn||5.006000|
2242 wait4pid|||
2243 warn_nocontext|||vn
2244 warner_nocontext|||vn
2245 warner|5.006000|5.004000|pv
2246 warn|||v
2247 watch|||
2248 whichsig|||
2249 write_no_mem|||
2250 write_to_stderr|||
2251 xmldump_all|||
2252 xmldump_attr|||
2253 xmldump_eval|||
2254 xmldump_form|||
2255 xmldump_indent|||v
2256 xmldump_packsubs|||
2257 xmldump_sub|||
2258 xmldump_vindent|||
2259 yyerror|||
2260 yylex|||
2261 yyparse|||
2262 yywarn|||
2263 );
2264
2265 if (exists $opt{'list-unsupported'}) {
2266 my $f;
2267 for $f (sort { lc $a cmp lc $b } keys %API) {
2268 next unless $API{$f}{todo};
2269 print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
2270 }
2271 exit 0;
2272 }
2273
2274 # Scan for possible replacement candidates
2275
2276 my(%replace, %need, %hints, %depends);
2277 my $replace = 0;
2278 my $hint = '';
2279
2280 while (<DATA>) {
2281 if ($hint) {
2282 if (m{^\s*\*\s(.*?)\s*$}) {
2283 $hints{$hint} ||= ''; # suppress warning with older perls
2284 $hints{$hint} .= "$1\n";
2285 }
2286 else {
2287 $hint = '';
2288 }
2289 }
2290 $hint = $1 if m{^\s*$rccs\sHint:\s+(\w+)\s*$};
2291
2292 $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
2293 $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
2294 $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
2295 $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
2296
2297 if (m{^\s*$rccs\s+(\w+)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
2298 push @{$depends{$1}}, map { s/\s+//g; $_ } split /,/, $2;
2299 }
2300
2301 $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
2302 }
2303
2304 if (exists $opt{'api-info'}) {
2305 my $f;
2306 my $count = 0;
2307 my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
2308 for $f (sort { lc $a cmp lc $b } keys %API) {
2309 next unless $f =~ /$match/;
2310 print "\n=== $f ===\n\n";
2311 my $info = 0;
2312 if ($API{$f}{base} || $API{$f}{todo}) {
2313 my $base = format_version($API{$f}{base} || $API{$f}{todo});
2314 print "Supported at least starting from perl-$base.\n";
2315 $info++;
2316 }
2317 if ($API{$f}{provided}) {
2318 my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";
2319 print "Support by $ppport provided back to perl-$todo.\n";
2320 print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
2321 print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
2322 print "$hints{$f}" if exists $hints{$f};
2323 $info++;
2324 }
2325 unless ($info) {
2326 print "No portability information available.\n";
2327 }
2328 $count++;
2329 }
2330 if ($count > 0) {
2331 print "\n";
2332 }
2333 else {
2334 print "Found no API matching '$opt{'api-info'}'.\n";
2335 }
2336 exit 0;
2337 }
2338
2339 if (exists $opt{'list-provided'}) {
2340 my $f;
2341 for $f (sort { lc $a cmp lc $b } keys %API) {
2342 next unless $API{$f}{provided};
2343 my @flags;
2344 push @flags, 'explicit' if exists $need{$f};
2345 push @flags, 'depend' if exists $depends{$f};
2346 push @flags, 'hint' if exists $hints{$f};
2347 my $flags = @flags ? ' ['.join(', ', @flags).']' : '';
2348 print "$f$flags\n";
2349 }
2350 exit 0;
2351 }
2352
2353 my @files;
2354 my @srcext = qw( xs c h cc cpp );
2355 my $srcext = join '|', @srcext;
2356
2357 if (@ARGV) {
2358 my %seen;
2359 @files = grep { -f && !exists $seen{$_} } map { glob $_ } @ARGV;
2360 }
2361 else {
2362 eval {
2363 require File::Find;
2364 File::Find::find(sub {
2365 $File::Find::name =~ /\.($srcext)$/i
2366 and push @files, $File::Find::name;
2367 }, '.');
2368 };
2369 if ($@) {
2370 @files = map { glob "*.$_" } @srcext;
2371 }
2372 }
2373
2374 if (!@ARGV || $opt{filter}) {
2375 my(@in, @out);
2376 my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
2377 for (@files) {
2378 my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/\.($srcext)$/i;
2379 push @{ $out ? \@out : \@in }, $_;
2380 }
2381 if (@ARGV && @out) {
2382 warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
2383 }
2384 @files = @in;
2385 }
2386
2387 unless (@files) {
2388 die "No input files given!\n";
2389 }
2390
2391 my(%files, %global, %revreplace);
2392 %revreplace = reverse %replace;
2393 my $filename;
2394 my $patch_opened = 0;
2395
2396 for $filename (@files) {
2397 unless (open IN, "<$filename") {
2398 warn "Unable to read from $filename: $!\n";
2399 next;
2400 }
2401
2402 info("Scanning $filename ...");
2403
2404 my $c = do { local $/; <IN> };
2405 close IN;
2406
2407 my %file = (orig => $c, changes => 0);
2408
2409 # temporarily remove C comments from the code
2410 my @ccom;
2411 $c =~ s{
2412 (
2413 [^"'/]+
2414 |
2415 (?:"[^"\\]*(?:\\.[^"\\]*)*" [^"'/]*)+
2416 |
2417 (?:'[^'\\]*(?:\\.[^'\\]*)*' [^"'/]*)+
2418 )
2419 |
2420 (/ (?:
2421 \*[^*]*\*+(?:[^$ccs][^*]*\*+)* /
2422 |
2423 /[^\r\n]*
2424 ))
2425 }{
2426 defined $2 and push @ccom, $2;
2427 defined $1 ? $1 : "$ccs$#ccom$cce";
2428 }egsx;
2429
2430 $file{ccom} = \@ccom;
2431 $file{code} = $c;
2432 $file{has_inc_ppport} = ($c =~ /#.*include.*\Q$ppport\E/);
2433
2434 my $func;
2435
2436 for $func (keys %API) {
2437 my $match = $func;
2438 $match .= "|$revreplace{$func}" if exists $revreplace{$func};
2439 if ($c =~ /\b(?:Perl_)?($match)\b/) {
2440 $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
2441 $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
2442 if (exists $API{$func}{provided}) {
2443 if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
2444 $file{uses}{$func}++;
2445 my @deps = rec_depend($func);
2446 if (@deps) {
2447 $file{uses_deps}{$func} = \@deps;
2448 for (@deps) {
2449 $file{uses}{$_} = 0 unless exists $file{uses}{$_};
2450 }
2451 }
2452 for ($func, @deps) {
2453 if (exists $need{$_}) {
2454 $file{needs}{$_} = 'static';
2455 }
2456 }
2457 }
2458 }
2459 if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {
2460 if ($c =~ /\b$func\b/) {
2461 $file{uses_todo}{$func}++;
2462 }
2463 }
2464 }
2465 }
2466
2467 while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
2468 if (exists $need{$2}) {
2469 $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
2470 }
2471 else {
2472 warning("Possibly wrong #define $1 in $filename");
2473 }
2474 }
2475
2476 for (qw(uses needs uses_todo needed_global needed_static)) {
2477 for $func (keys %{$file{$_}}) {
2478 push @{$global{$_}{$func}}, $filename;
2479 }
2480 }
2481
2482 $files{$filename} = \%file;
2483 }
2484
2485 # Globally resolve NEED_'s
2486 my $need;
2487 for $need (keys %{$global{needs}}) {
2488 if (@{$global{needs}{$need}} > 1) {
2489 my @targets = @{$global{needs}{$need}};
2490 my @t = grep $files{$_}{needed_global}{$need}, @targets;
2491 @targets = @t if @t;
2492 @t = grep /\.xs$/i, @targets;
2493 @targets = @t if @t;
2494 my $target = shift @targets;
2495 $files{$target}{needs}{$need} = 'global';
2496 for (@{$global{needs}{$need}}) {
2497 $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
2498 }
2499 }
2500 }
2501
2502 for $filename (@files) {
2503 exists $files{$filename} or next;
2504
2505 info("=== Analyzing $filename ===");
2506
2507 my %file = %{$files{$filename}};
2508 my $func;
2509 my $c = $file{code};
2510
2511 for $func (sort keys %{$file{uses_Perl}}) {
2512 if ($API{$func}{varargs}) {
2513 my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
2514 { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
2515 if ($changes) {
2516 warning("Doesn't pass interpreter argument aTHX to Perl_$func");
2517 $file{changes} += $changes;
2518 }
2519 }
2520 else {
2521 warning("Uses Perl_$func instead of $func");
2522 $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
2523 {$func$1(}g);
2524 }
2525 }
2526
2527 for $func (sort keys %{$file{uses_replace}}) {
2528 warning("Uses $func instead of $replace{$func}");
2529 $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
2530 }
2531
2532 for $func (sort keys %{$file{uses}}) {
2533 next unless $file{uses}{$func}; # if it's only a dependency
2534 if (exists $file{uses_deps}{$func}) {
2535 diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
2536 }
2537 elsif (exists $replace{$func}) {
2538 warning("Uses $func instead of $replace{$func}");
2539 $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
2540 }
2541 else {
2542 diag("Uses $func");
2543 }
2544 hint($func);
2545 }
2546
2547 for $func (sort keys %{$file{uses_todo}}) {
2548 warning("Uses $func, which may not be portable below perl ",
2549 format_version($API{$func}{todo}));
2550 }
2551
2552 for $func (sort keys %{$file{needed_static}}) {
2553 my $message = '';
2554 if (not exists $file{uses}{$func}) {
2555 $message = "No need to define NEED_$func if $func is never used";
2556 }
2557 elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
2558 $message = "No need to define NEED_$func when already needed globally";
2559 }
2560 if ($message) {
2561 diag($message);
2562 $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
2563 }
2564 }
2565
2566 for $func (sort keys %{$file{needed_global}}) {
2567 my $message = '';
2568 if (not exists $global{uses}{$func}) {
2569 $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
2570 }
2571 elsif (exists $file{needs}{$func}) {
2572 if ($file{needs}{$func} eq 'extern') {
2573 $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
2574 }
2575 elsif ($file{needs}{$func} eq 'static') {
2576 $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
2577 }
2578 }
2579 if ($message) {
2580 diag($message);
2581 $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
2582 }
2583 }
2584
2585 $file{needs_inc_ppport} = keys %{$file{uses}};
2586
2587 if ($file{needs_inc_ppport}) {
2588 my $pp = '';
2589
2590 for $func (sort keys %{$file{needs}}) {
2591 my $type = $file{needs}{$func};
2592 next if $type eq 'extern';
2593 my $suffix = $type eq 'global' ? '_GLOBAL' : '';
2594 unless (exists $file{"needed_$type"}{$func}) {
2595 if ($type eq 'global') {
2596 diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
2597 }
2598 else {
2599 diag("File needs $func, adding static request");
2600 }
2601 $pp .= "#define NEED_$func$suffix\n";
2602 }
2603 }
2604
2605 if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
2606 $pp = '';
2607 $file{changes}++;
2608 }
2609
2610 unless ($file{has_inc_ppport}) {
2611 diag("Needs to include '$ppport'");
2612 $pp .= qq(#include "$ppport"\n)
2613 }
2614
2615 if ($pp) {
2616 $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
2617 || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
2618 || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
2619 || ($c =~ s/^/$pp/);
2620 }
2621 }
2622 else {
2623 if ($file{has_inc_ppport}) {
2624 diag("No need to include '$ppport'");
2625 $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
2626 }
2627 }
2628
2629 # put back in our C comments
2630 my $ix;
2631 my $cppc = 0;
2632 my @ccom = @{$file{ccom}};
2633 for $ix (0 .. $#ccom) {
2634 if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
2635 $cppc++;
2636 $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
2637 }
2638 else {
2639 $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
2640 }
2641 }
2642
2643 if ($cppc) {
2644 my $s = $cppc != 1 ? 's' : '';
2645 warning("Uses $cppc C++ style comment$s, which is not portable");
2646 }
2647
2648 if ($file{changes}) {
2649 if (exists $opt{copy}) {
2650 my $newfile = "$filename$opt{copy}";
2651 if (-e $newfile) {
2652 error("'$newfile' already exists, refusing to write copy of '$filename'");
2653 }
2654 else {
2655 local *F;
2656 if (open F, ">$newfile") {
2657 info("Writing copy of '$filename' with changes to '$newfile'");
2658 print F $c;
2659 close F;
2660 }
2661 else {
2662 error("Cannot open '$newfile' for writing: $!");
2663 }
2664 }
2665 }
2666 elsif (exists $opt{patch} || $opt{changes}) {
2667 if (exists $opt{patch}) {
2668 unless ($patch_opened) {
2669 if (open PATCH, ">$opt{patch}") {
2670 $patch_opened = 1;
2671 }
2672 else {
2673 error("Cannot open '$opt{patch}' for writing: $!");
2674 delete $opt{patch};
2675 $opt{changes} = 1;
2676 goto fallback;
2677 }
2678 }
2679 mydiff(\*PATCH, $filename, $c);
2680 }
2681 else {
2682 fallback:
2683 info("Suggested changes:");
2684 mydiff(\*STDOUT, $filename, $c);
2685 }
2686 }
2687 else {
2688 my $s = $file{changes} == 1 ? '' : 's';
2689 info("$file{changes} potentially required change$s detected");
2690 }
2691 }
2692 else {
2693 info("Looks good");
2694 }
2695 }
2696
2697 close PATCH if $patch_opened;
2698
2699 exit 0;
2700
2701
2702 sub mydiff
2703 {
2704 local *F = shift;
2705 my($file, $str) = @_;
2706 my $diff;
2707
2708 if (exists $opt{diff}) {
2709 $diff = run_diff($opt{diff}, $file, $str);
2710 }
2711
2712 if (!defined $diff and can_use('Text::Diff')) {
2713 $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
2714 $diff = <<HEADER . $diff;
2715 --- $file
2716 +++ $file.patched
2717 HEADER
2718 }
2719
2720 if (!defined $diff) {
2721 $diff = run_diff('diff -u', $file, $str);
2722 }
2723
2724 if (!defined $diff) {
2725 $diff = run_diff('diff', $file, $str);
2726 }
2727
2728 if (!defined $diff) {
2729 error("Cannot generate a diff. Please install Text::Diff or use --copy.");
2730 return;
2731 }
2732
2733 print F $diff;
2734
2735 }
2736
2737 sub run_diff
2738 {
2739 my($prog, $file, $str) = @_;
2740 my $tmp = 'dppptemp';
2741 my $suf = 'aaa';
2742 my $diff = '';
2743 local *F;
2744
2745 while (-e "$tmp.$suf") { $suf++ }
2746 $tmp = "$tmp.$suf";
2747
2748 if (open F, ">$tmp") {
2749 print F $str;
2750 close F;
2751
2752 if (open F, "$prog $file $tmp |") {
2753 while (<F>) {
2754 s/\Q$tmp\E/$file.patched/;
2755 $diff .= $_;
2756 }
2757 close F;
2758 unlink $tmp;
2759 return $diff;
2760 }
2761
2762 unlink $tmp;
2763 }
2764 else {
2765 error("Cannot open '$tmp' for writing: $!");
2766 }
2767
2768 return undef;
2769 }
2770
2771 sub can_use
2772 {
2773 eval "use @_;";
2774 return $@ eq '';
2775 }
2776
2777 sub rec_depend
2778 {
2779 my $func = shift;
2780 my %seen;
2781 return () unless exists $depends{$func};
2782 grep !$seen{$_}++, map { ($_, rec_depend($_)) } @{$depends{$func}};
2783 }
2784
2785 sub parse_version
2786 {
2787 my $ver = shift;
2788
2789 if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
2790 return ($1, $2, $3);
2791 }
2792 elsif ($ver !~ /^\d+\.[\d_]+$/) {
2793 die "cannot parse version '$ver'\n";
2794 }
2795
2796 $ver =~ s/_//g;
2797 $ver =~ s/$/000000/;
2798
2799 my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
2800
2801 $v = int $v;
2802 $s = int $s;
2803
2804 if ($r < 5 || ($r == 5 && $v < 6)) {
2805 if ($s % 10) {
2806 die "cannot parse version '$ver'\n";
2807 }
2808 }
2809
2810 return ($r, $v, $s);
2811 }
2812
2813 sub format_version
2814 {
2815 my $ver = shift;
2816
2817 $ver =~ s/$/000000/;
2818 my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
2819
2820 $v = int $v;
2821 $s = int $s;
2822
2823 if ($r < 5 || ($r == 5 && $v < 6)) {
2824 if ($s % 10) {
2825 die "invalid version '$ver'\n";
2826 }
2827 $s /= 10;
2828
2829 $ver = sprintf "%d.%03d", $r, $v;
2830 $s > 0 and $ver .= sprintf "_%02d", $s;
2831
2832 return $ver;
2833 }
2834
2835 return sprintf "%d.%d.%d", $r, $v, $s;
2836 }
2837
2838 sub info
2839 {
2840 $opt{quiet} and return;
2841 print @_, "\n";
2842 }
2843
2844 sub diag
2845 {
2846 $opt{quiet} and return;
2847 $opt{diag} and print @_, "\n";
2848 }
2849
2850 sub warning
2851 {
2852 $opt{quiet} and return;
2853 print "*** ", @_, "\n";
2854 }
2855
2856 sub error
2857 {
2858 print "*** ERROR: ", @_, "\n";
2859 }
2860
2861 my %given_hints;
2862 sub hint
2863 {
2864 $opt{quiet} and return;
2865 $opt{hints} or return;
2866 my $func = shift;
2867 exists $hints{$func} or return;
2868 $given_hints{$func}++ and return;
2869 my $hint = $hints{$func};
2870 $hint =~ s/^/ /mg;
2871 print " --- hint for $func ---\n", $hint;
2872 }
2873
2874 sub usage
2875 {
2876 my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
2877 my %M = ( 'I' => '*' );
2878 $usage =~ s/^\s*perl\s+\S+/$^X $0/;
2879 $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;
2880
2881 print <<ENDUSAGE;
2882
2883 Usage: $usage
2884
2885 See perldoc $0 for details.
2886
2887 ENDUSAGE
2888
2889 exit 2;
2890 }
2891
2892 sub strip
2893 {
2894 my $self = do { local(@ARGV,$/)=($0); <> };
2895 my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
2896 $copy =~ s/^(?=\S+)/ /gms;
2897 $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
2898 $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
2899 if (\@ARGV && \$ARGV[0] eq '--unstrip') {
2900 eval { require Devel::PPPort };
2901 \$@ and die "Cannot require Devel::PPPort, please install.\\n";
2902 if (\$Devel::PPPort::VERSION < $VERSION) {
2903 die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
2904 . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
2905 . "Please install a newer version, or --unstrip will not work.\\n";
2906 }
2907 Devel::PPPort::WriteFile(\$0);
2908 exit 0;
2909 }
2910 print <<END;
2911
2912 Sorry, but this is a stripped version of \$0.
2913
2914 To be able to use its original script and doc functionality,
2915 please try to regenerate this file using:
2916
2917 \$^X \$0 --unstrip
2918
2919 END
2920 /ms;
2921
2922 open OUT, ">$0" or die "cannot strip $0: $!\n";
2923 print OUT $self;
2924
2925 exit 0;
2926 }
2927
2928 __DATA__
2929 */
2930
2931 #ifndef _P_P_PORTABILITY_H_
2932 #define _P_P_PORTABILITY_H_
2933
2934 #ifndef DPPP_NAMESPACE
2935 # define DPPP_NAMESPACE DPPP_
2936 #endif
2937
2938 #define DPPP_CAT2(x,y) CAT2(x,y)
2939 #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)
2940
2941 #ifndef PERL_REVISION
2942 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
2943 # define PERL_PATCHLEVEL_H_IMPLICIT
2944 # include <patchlevel.h>
2945 # endif
2946 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
2947 # include <could_not_find_Perl_patchlevel.h>
2948 # endif
2949 # ifndef PERL_REVISION
2950 # define PERL_REVISION (5)
2951 /* Replace: 1 */
2952 # define PERL_VERSION PATCHLEVEL
2953 # define PERL_SUBVERSION SUBVERSION
2954 /* Replace PERL_PATCHLEVEL with PERL_VERSION */
2955 /* Replace: 0 */
2956 # endif
2957 #endif
2958
2959 #define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)
2960
2961 /* It is very unlikely that anyone will try to use this with Perl 6
2962 (or greater), but who knows.
2963 */
2964 #if PERL_REVISION != 5
2965 # error ppport.h only works with Perl version 5
2966 #endif /* PERL_REVISION != 5 */
2967
2968 #ifdef I_LIMITS
2969 # include <limits.h>
2970 #endif
2971
2972 #ifndef PERL_UCHAR_MIN
2973 # define PERL_UCHAR_MIN ((unsigned char)0)
2974 #endif
2975
2976 #ifndef PERL_UCHAR_MAX
2977 # ifdef UCHAR_MAX
2978 # define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
2979 # else
2980 # ifdef MAXUCHAR
2981 # define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
2982 # else
2983 # define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
2984 # endif
2985 # endif
2986 #endif
2987
2988 #ifndef PERL_USHORT_MIN
2989 # define PERL_USHORT_MIN ((unsigned short)0)
2990 #endif
2991
2992 #ifndef PERL_USHORT_MAX
2993 # ifdef USHORT_MAX
2994 # define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
2995 # else
2996 # ifdef MAXUSHORT
2997 # define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
2998 # else
2999 # ifdef USHRT_MAX
3000 # define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
3001 # else
3002 # define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
3003 # endif
3004 # endif
3005 # endif
3006 #endif
3007
3008 #ifndef PERL_SHORT_MAX
3009 # ifdef SHORT_MAX
3010 # define PERL_SHORT_MAX ((short)SHORT_MAX)
3011 # else
3012 # ifdef MAXSHORT /* Often used in <values.h> */
3013 # define PERL_SHORT_MAX ((short)MAXSHORT)
3014 # else
3015 # ifdef SHRT_MAX
3016 # define PERL_SHORT_MAX ((short)SHRT_MAX)
3017 # else
3018 # define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
3019 # endif
3020 # endif
3021 # endif
3022 #endif
3023
3024 #ifndef PERL_SHORT_MIN
3025 # ifdef SHORT_MIN
3026 # define PERL_SHORT_MIN ((short)SHORT_MIN)
3027 # else
3028 # ifdef MINSHORT
3029 # define PERL_SHORT_MIN ((short)MINSHORT)
3030 # else
3031 # ifdef SHRT_MIN
3032 # define PERL_SHORT_MIN ((short)SHRT_MIN)
3033 # else
3034 # define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
3035 # endif
3036 # endif
3037 # endif
3038 #endif
3039
3040 #ifndef PERL_UINT_MAX
3041 # ifdef UINT_MAX
3042 # define PERL_UINT_MAX ((unsigned int)UINT_MAX)
3043 # else
3044 # ifdef MAXUINT
3045 # define PERL_UINT_MAX ((unsigned int)MAXUINT)
3046 # else
3047 # define PERL_UINT_MAX (~(unsigned int)0)
3048 # endif
3049 # endif
3050 #endif
3051
3052 #ifndef PERL_UINT_MIN
3053 # define PERL_UINT_MIN ((unsigned int)0)
3054 #endif
3055
3056 #ifndef PERL_INT_MAX
3057 # ifdef INT_MAX
3058 # define PERL_INT_MAX ((int)INT_MAX)
3059 # else
3060 # ifdef MAXINT /* Often used in <values.h> */
3061 # define PERL_INT_MAX ((int)MAXINT)
3062 # else
3063 # define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
3064 # endif
3065 # endif
3066 #endif
3067
3068 #ifndef PERL_INT_MIN
3069 # ifdef INT_MIN
3070 # define PERL_INT_MIN ((int)INT_MIN)
3071 # else
3072 # ifdef MININT
3073 # define PERL_INT_MIN ((int)MININT)
3074 # else
3075 # define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
3076 # endif
3077 # endif
3078 #endif
3079
3080 #ifndef PERL_ULONG_MAX
3081 # ifdef ULONG_MAX
3082 # define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
3083 # else
3084 # ifdef MAXULONG
3085 # define PERL_ULONG_MAX ((unsigned long)MAXULONG)
3086 # else
3087 # define PERL_ULONG_MAX (~(unsigned long)0)
3088 # endif
3089 # endif
3090 #endif
3091
3092 #ifndef PERL_ULONG_MIN
3093 # define PERL_ULONG_MIN ((unsigned long)0L)
3094 #endif
3095
3096 #ifndef PERL_LONG_MAX
3097 # ifdef LONG_MAX
3098 # define PERL_LONG_MAX ((long)LONG_MAX)
3099 # else
3100 # ifdef MAXLONG
3101 # define PERL_LONG_MAX ((long)MAXLONG)
3102 # else
3103 # define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
3104 # endif
3105 # endif
3106 #endif
3107
3108 #ifndef PERL_LONG_MIN
3109 # ifdef LONG_MIN
3110 # define PERL_LONG_MIN ((long)LONG_MIN)
3111 # else
3112 # ifdef MINLONG
3113 # define PERL_LONG_MIN ((long)MINLONG)
3114 # else
3115 # define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
3116 # endif
3117 # endif
3118 #endif
3119
3120 #if defined(HAS_QUAD) && (defined(convex) || defined(uts))
3121 # ifndef PERL_UQUAD_MAX
3122 # ifdef ULONGLONG_MAX
3123 # define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
3124 # else
3125 # ifdef MAXULONGLONG
3126 # define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
3127 # else
3128 # define PERL_UQUAD_MAX (~(unsigned long long)0)
3129 # endif
3130 # endif
3131 # endif
3132
3133 # ifndef PERL_UQUAD_MIN
3134 # define PERL_UQUAD_MIN ((unsigned long long)0L)
3135 # endif
3136
3137 # ifndef PERL_QUAD_MAX
3138 # ifdef LONGLONG_MAX
3139 # define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
3140 # else
3141 # ifdef MAXLONGLONG
3142 # define PERL_QUAD_MAX ((long long)MAXLONGLONG)
3143 # else
3144 # define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
3145 # endif
3146 # endif
3147 # endif
3148
3149 # ifndef PERL_QUAD_MIN
3150 # ifdef LONGLONG_MIN
3151 # define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
3152 # else
3153 # ifdef MINLONGLONG
3154 # define PERL_QUAD_MIN ((long long)MINLONGLONG)
3155 # else
3156 # define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
3157 # endif
3158 # endif
3159 # endif
3160 #endif
3161
3162 /* This is based on code from 5.003 perl.h */
3163 #ifdef HAS_QUAD
3164 # ifdef cray
3165 #ifndef IVTYPE
3166 # define IVTYPE int
3167 #endif
3168
3169 #ifndef IV_MIN
3170 # define IV_MIN PERL_INT_MIN
3171 #endif
3172
3173 #ifndef IV_MAX
3174 # define IV_MAX PERL_INT_MAX
3175 #endif
3176
3177 #ifndef UV_MIN
3178 # define UV_MIN PERL_UINT_MIN
3179 #endif
3180
3181 #ifndef UV_MAX
3182 # define UV_MAX PERL_UINT_MAX
3183 #endif
3184
3185 # ifdef INTSIZE
3186 #ifndef IVSIZE
3187 # define IVSIZE INTSIZE
3188 #endif
3189
3190 # endif
3191 # else
3192 # if defined(convex) || defined(uts)
3193 #ifndef IVTYPE
3194 # define IVTYPE long long
3195 #endif
3196
3197 #ifndef IV_MIN
3198 # define IV_MIN PERL_QUAD_MIN
3199 #endif
3200
3201 #ifndef IV_MAX
3202 # define IV_MAX PERL_QUAD_MAX
3203 #endif
3204
3205 #ifndef UV_MIN
3206 # define UV_MIN PERL_UQUAD_MIN
3207 #endif
3208
3209 #ifndef UV_MAX
3210 # define UV_MAX PERL_UQUAD_MAX
3211 #endif
3212
3213 # ifdef LONGLONGSIZE
3214 #ifndef IVSIZE
3215 # define IVSIZE LONGLONGSIZE
3216 #endif
3217
3218 # endif
3219 # else
3220 #ifndef IVTYPE
3221 # define IVTYPE long
3222 #endif
3223
3224 #ifndef IV_MIN
3225 # define IV_MIN PERL_LONG_MIN
3226 #endif
3227
3228 #ifndef IV_MAX
3229 # define IV_MAX PERL_LONG_MAX
3230 #endif
3231
3232 #ifndef UV_MIN
3233 # define UV_MIN PERL_ULONG_MIN
3234 #endif
3235
3236 #ifndef UV_MAX
3237 # define UV_MAX PERL_ULONG_MAX
3238 #endif
3239
3240 # ifdef LONGSIZE
3241 #ifndef IVSIZE
3242 # define IVSIZE LONGSIZE
3243 #endif
3244
3245 # endif
3246 # endif
3247 # endif
3248 #ifndef IVSIZE
3249 # define IVSIZE 8
3250 #endif
3251
3252 #ifndef PERL_QUAD_MIN
3253 # define PERL_QUAD_MIN IV_MIN
3254 #endif
3255
3256 #ifndef PERL_QUAD_MAX
3257 # define PERL_QUAD_MAX IV_MAX
3258 #endif
3259
3260 #ifndef PERL_UQUAD_MIN
3261 # define PERL_UQUAD_MIN UV_MIN
3262 #endif
3263
3264 #ifndef PERL_UQUAD_MAX
3265 # define PERL_UQUAD_MAX UV_MAX
3266 #endif
3267
3268 #else
3269 #ifndef IVTYPE
3270 # define IVTYPE long
3271 #endif
3272
3273 #ifndef IV_MIN
3274 # define IV_MIN PERL_LONG_MIN
3275 #endif
3276
3277 #ifndef IV_MAX
3278 # define IV_MAX PERL_LONG_MAX
3279 #endif
3280
3281 #ifndef UV_MIN
3282 # define UV_MIN PERL_ULONG_MIN
3283 #endif
3284
3285 #ifndef UV_MAX
3286 # define UV_MAX PERL_ULONG_MAX
3287 #endif
3288
3289 #endif
3290
3291 #ifndef IVSIZE
3292 # ifdef LONGSIZE
3293 # define IVSIZE LONGSIZE
3294 # else
3295 # define IVSIZE 4 /* A bold guess, but the best we can make. */
3296 # endif
3297 #endif
3298 #ifndef UVTYPE
3299 # define UVTYPE unsigned IVTYPE
3300 #endif
3301
3302 #ifndef UVSIZE
3303 # define UVSIZE IVSIZE
3304 #endif
3305 #ifndef sv_setuv
3306 # define sv_setuv(sv, uv) \
3307 STMT_START { \
3308 UV TeMpUv = uv; \
3309 if (TeMpUv <= IV_MAX) \
3310 sv_setiv(sv, TeMpUv); \
3311 else \
3312 sv_setnv(sv, (double)TeMpUv); \
3313 } STMT_END
3314 #endif
3315 #ifndef newSVuv
3316 # define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
3317 #endif
3318 #ifndef sv_2uv
3319 # define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
3320 #endif
3321
3322 #ifndef SvUVX
3323 # define SvUVX(sv) ((UV)SvIVX(sv))
3324 #endif
3325
3326 #ifndef SvUVXx
3327 # define SvUVXx(sv) SvUVX(sv)
3328 #endif
3329
3330 #ifndef SvUV
3331 # define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
3332 #endif
3333
3334 #ifndef SvUVx
3335 # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
3336 #endif
3337
3338 /* Hint: sv_uv
3339 * Always use the SvUVx() macro instead of sv_uv().
3340 */
3341 #ifndef sv_uv
3342 # define sv_uv(sv) SvUVx(sv)
3343 #endif
3344 #ifndef XST_mUV
3345 # define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
3346 #endif
3347
3348 #ifndef XSRETURN_UV
3349 # define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
3350 #endif
3351 #ifndef PUSHu
3352 # define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
3353 #endif
3354
3355 #ifndef XPUSHu
3356 # define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
3357 #endif
3358
3359 #ifdef HAS_MEMCMP
3360 #ifndef memNE
3361 # define memNE(s1,s2,l) (memcmp(s1,s2,l))
3362 #endif
3363
3364 #ifndef memEQ
3365 # define memEQ(s1,s2,l) (!memcmp(s1,s2,l))
3366 #endif
3367
3368 #else
3369 #ifndef memNE
3370 # define memNE(s1,s2,l) (bcmp(s1,s2,l))
3371 #endif
3372
3373 #ifndef memEQ
3374 # define memEQ(s1,s2,l) (!bcmp(s1,s2,l))
3375 #endif
3376
3377 #endif
3378 #ifndef MoveD
3379 # define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t))
3380 #endif
3381
3382 #ifndef CopyD
3383 # define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
3384 #endif
3385
3386 #ifdef HAS_MEMSET
3387 #ifndef ZeroD
3388 # define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t))
3389 #endif
3390
3391 #else
3392 #ifndef ZeroD
3393 # define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d)
3394 #endif
3395
3396 #endif
3397 #ifndef PoisonWith
3398 # define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
3399 #endif
3400
3401 #ifndef PoisonNew
3402 # define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB)
3403 #endif
3404
3405 #ifndef PoisonFree
3406 # define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF)
3407 #endif
3408
3409 #ifndef Poison
3410 # define Poison(d,n,t) PoisonFree(d,n,t)
3411 #endif
3412 #ifndef Newx
3413 # define Newx(v,n,t) New(0,v,n,t)
3414 #endif
3415
3416 #ifndef Newxc
3417 # define Newxc(v,n,t,c) Newc(0,v,n,t,c)
3418 #endif
3419
3420 #ifndef Newxz
3421 # define Newxz(v,n,t) Newz(0,v,n,t)
3422 #endif
3423
3424 #ifndef PERL_UNUSED_DECL
3425 # ifdef HASATTRIBUTE
3426 # if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
3427 # define PERL_UNUSED_DECL
3428 # else
3429 # define PERL_UNUSED_DECL __attribute__((unused))
3430 # endif
3431 # else
3432 # define PERL_UNUSED_DECL
3433 # endif
3434 #endif
3435
3436 #ifndef PERL_UNUSED_ARG
3437 # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
3438 # include <note.h>
3439 # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
3440 # else
3441 # define PERL_UNUSED_ARG(x) ((void)x)
3442 # endif
3443 #endif
3444
3445 #ifndef PERL_UNUSED_VAR
3446 # define PERL_UNUSED_VAR(x) ((void)x)
3447 #endif
3448
3449 #ifndef PERL_UNUSED_CONTEXT
3450 # ifdef USE_ITHREADS
3451 # define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
3452 # else
3453 # define PERL_UNUSED_CONTEXT
3454 # endif
3455 #endif
3456 #ifndef NOOP
3457 # define NOOP /*EMPTY*/(void)0
3458 #endif
3459
3460 #ifndef dNOOP
3461 # define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
3462 #endif
3463
3464 #ifndef NVTYPE
3465 # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
3466 # define NVTYPE long double
3467 # else
3468 # define NVTYPE double
3469 # endif
3470 typedef NVTYPE NV;
3471 #endif
3472
3473 #ifndef INT2PTR
3474
3475 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
3476 # define PTRV UV
3477 # define INT2PTR(any,d) (any)(d)
3478 # else
3479 # if PTRSIZE == LONGSIZE
3480 # define PTRV unsigned long
3481 # else
3482 # define PTRV unsigned
3483 # endif
3484 # define INT2PTR(any,d) (any)(PTRV)(d)
3485 # endif
3486
3487 # define NUM2PTR(any,d) (any)(PTRV)(d)
3488 # define PTR2IV(p) INT2PTR(IV,p)
3489 # define PTR2UV(p) INT2PTR(UV,p)
3490 # define PTR2NV(p) NUM2PTR(NV,p)
3491
3492 # if PTRSIZE == LONGSIZE
3493 # define PTR2ul(p) (unsigned long)(p)
3494 # else
3495 # define PTR2ul(p) INT2PTR(unsigned long,p)
3496 # endif
3497
3498 #endif /* !INT2PTR */
3499
3500 #undef START_EXTERN_C
3501 #undef END_EXTERN_C
3502 #undef EXTERN_C
3503 #ifdef __cplusplus
3504 # define START_EXTERN_C extern "C" {
3505 # define END_EXTERN_C }
3506 # define EXTERN_C extern "C"
3507 #else
3508 # define START_EXTERN_C
3509 # define END_EXTERN_C
3510 # define EXTERN_C extern
3511 #endif
3512
3513 #if defined(PERL_GCC_PEDANTIC)
3514 # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
3515 # define PERL_GCC_BRACE_GROUPS_FORBIDDEN
3516 # endif
3517 #endif
3518
3519 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
3520 # ifndef PERL_USE_GCC_BRACE_GROUPS
3521 # define PERL_USE_GCC_BRACE_GROUPS
3522 # endif
3523 #endif
3524
3525 #undef STMT_START
3526 #undef STMT_END
3527 #ifdef PERL_USE_GCC_BRACE_GROUPS
3528 # define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */
3529 # define STMT_END )
3530 #else
3531 # if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
3532 # define STMT_START if (1)
3533 # define STMT_END else (void)0
3534 # else
3535 # define STMT_START do
3536 # define STMT_END while (0)
3537 # endif
3538 #endif
3539 #ifndef boolSV
3540 # define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
3541 #endif
3542
3543 /* DEFSV appears first in 5.004_56 */
3544 #ifndef DEFSV
3545 # define DEFSV GvSV(PL_defgv)
3546 #endif
3547
3548 #ifndef SAVE_DEFSV
3549 # define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
3550 #endif
3551
3552 /* Older perls (<=5.003) lack AvFILLp */
3553 #ifndef AvFILLp
3554 # define AvFILLp AvFILL
3555 #endif
3556 #ifndef ERRSV
3557 # define ERRSV get_sv("@",FALSE)
3558 #endif
3559 #ifndef newSVpvn
3560 # define newSVpvn(data,len) ((data) \
3561 ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
3562 : newSV(0))
3563 #endif
3564
3565 /* Hint: gv_stashpvn
3566 * This function's backport doesn't support the length parameter, but
3567 * rather ignores it. Portability can only be ensured if the length
3568 * parameter is used for speed reasons, but the length can always be
3569 * correctly computed from the string argument.
3570 */
3571 #ifndef gv_stashpvn
3572 # define gv_stashpvn(str,len,create) gv_stashpv(str,create)
3573 #endif
3574
3575 /* Replace: 1 */
3576 #ifndef get_cv
3577 # define get_cv perl_get_cv
3578 #endif
3579
3580 #ifndef get_sv
3581 # define get_sv perl_get_sv
3582 #endif
3583
3584 #ifndef get_av
3585 # define get_av perl_get_av
3586 #endif
3587
3588 #ifndef get_hv
3589 # define get_hv perl_get_hv
3590 #endif
3591
3592 /* Replace: 0 */
3593 #ifndef dUNDERBAR
3594 # define dUNDERBAR dNOOP
3595 #endif
3596
3597 #ifndef UNDERBAR
3598 # define UNDERBAR DEFSV
3599 #endif
3600 #ifndef dAX
3601 # define dAX I32 ax = MARK - PL_stack_base + 1
3602 #endif
3603
3604 #ifndef dITEMS
3605 # define dITEMS I32 items = SP - MARK
3606 #endif
3607 #ifndef dXSTARG
3608 # define dXSTARG SV * targ = sv_newmortal()
3609 #endif
3610 #ifndef dAXMARK
3611 # define dAXMARK I32 ax = POPMARK; \
3612 register SV ** const mark = PL_stack_base + ax++
3613 #endif
3614 #ifndef XSprePUSH
3615 # define XSprePUSH (sp = PL_stack_base + ax - 1)
3616 #endif
3617
3618 #if ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 0)))
3619 # undef XSRETURN
3620 # define XSRETURN(off) \
3621 STMT_START { \
3622 PL_stack_sp = PL_stack_base + ax + ((off) - 1); \
3623 return; \
3624 } STMT_END
3625 #endif
3626 #ifndef PERL_ABS
3627 # define PERL_ABS(x) ((x) < 0 ? -(x) : (x))
3628 #endif
3629 #ifndef dVAR
3630 # define dVAR dNOOP
3631 #endif
3632 #ifndef SVf
3633 # define SVf "_"
3634 #endif
3635
3636 #ifndef PERL_SIGNALS_UNSAFE_FLAG
3637
3638 #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
3639
3640 #if ((PERL_VERSION < 8) || ((PERL_VERSION == 8) && (PERL_SUBVERSION < 0)))
3641 # define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG
3642 #else
3643 # define D_PPP_PERL_SIGNALS_INIT 0
3644 #endif
3645
3646 #if defined(NEED_PL_signals)
3647 static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3648 #elif defined(NEED_PL_signals_GLOBAL)
3649 U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3650 #else
3651 extern U32 DPPP_(my_PL_signals);
3652 #endif
3653 #define PL_signals DPPP_(my_PL_signals)
3654
3655 #endif
3656
3657 /* Hint: PL_ppaddr
3658 * Calling an op via PL_ppaddr requires passing a context argument
3659 * for threaded builds. Since the context argument is different for
3660 * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
3661 * automatically be defined as the correct argument.
3662 */
3663
3664 #if ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION <= 4)))
3665 /* Replace: 1 */
3666 # define PL_ppaddr ppaddr
3667 # define PL_no_modify no_modify
3668 /* Replace: 0 */
3669 #endif
3670
3671 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
3672 /* Replace: 1 */
3673 # define PL_DBsignal DBsignal
3674 # define PL_DBsingle DBsingle
3675 # define PL_DBsub DBsub
3676 # define PL_DBtrace DBtrace
3677 # define PL_Sv Sv
3678 # define PL_compiling compiling
3679 # define PL_copline copline
3680 # define PL_curcop curcop
3681 # define PL_curstash curstash
3682 # define PL_debstash debstash
3683 # define PL_defgv defgv
3684 # define PL_diehook diehook
3685 # define PL_dirty dirty
3686 # define PL_dowarn dowarn
3687 # define PL_errgv errgv
3688 # define PL_hexdigit hexdigit
3689 # define PL_hints hints
3690 # define PL_laststatval laststatval
3691 # define PL_na na
3692 # define PL_perl_destruct_level perl_destruct_level
3693 # define PL_perldb perldb
3694 # define PL_rsfp_filters rsfp_filters
3695 # define PL_rsfp rsfp
3696 # define PL_stack_base stack_base
3697 # define PL_stack_sp stack_sp
3698 # define PL_statcache statcache
3699 # define PL_stdingv stdingv
3700 # define PL_sv_arenaroot sv_arenaroot
3701 # define PL_sv_no sv_no
3702 # define PL_sv_undef sv_undef
3703 # define PL_sv_yes sv_yes
3704 # define PL_tainted tainted
3705 # define PL_tainting tainting
3706 /* Replace: 0 */
3707 #endif
3708 #ifndef dTHR
3709 # define dTHR dNOOP
3710 #endif
3711 #ifndef dTHX
3712 # define dTHX dNOOP
3713 #endif
3714
3715 #ifndef dTHXa
3716 # define dTHXa(x) dNOOP
3717 #endif
3718 #ifndef pTHX
3719 # define pTHX void
3720 #endif
3721
3722 #ifndef pTHX_
3723 # define pTHX_
3724 #endif
3725
3726 #ifndef aTHX
3727 # define aTHX
3728 #endif
3729
3730 #ifndef aTHX_
3731 # define aTHX_
3732 #endif
3733
3734 #if ((PERL_VERSION < 6) || ((PERL_VERSION == 6) && (PERL_SUBVERSION < 0)))
3735 # ifdef USE_THREADS
3736 # define aTHXR thr
3737 # define aTHXR_ thr,
3738 # else
3739 # define aTHXR
3740 # define aTHXR_
3741 # endif
3742 # define dTHXR dTHR
3743 #else
3744 # define aTHXR aTHX
3745 # define aTHXR_ aTHX_
3746 # define dTHXR dTHX
3747 #endif
3748 #ifndef dTHXoa
3749 # define dTHXoa(x) dTHXa(x)
3750 #endif
3751 #ifndef PUSHmortal
3752 # define PUSHmortal PUSHs(sv_newmortal())
3753 #endif
3754
3755 #ifndef mPUSHp
3756 # define mPUSHp(p,l) sv_setpvn_mg(PUSHmortal, (p), (l))
3757 #endif
3758
3759 #ifndef mPUSHn
3760 # define mPUSHn(n) sv_setnv_mg(PUSHmortal, (NV)(n))
3761 #endif
3762
3763 #ifndef mPUSHi
3764 # define mPUSHi(i) sv_setiv_mg(PUSHmortal, (IV)(i))
3765 #endif
3766
3767 #ifndef mPUSHu
3768 # define mPUSHu(u) sv_setuv_mg(PUSHmortal, (UV)(u))
3769 #endif
3770 #ifndef XPUSHmortal
3771 # define XPUSHmortal XPUSHs(sv_newmortal())
3772 #endif
3773
3774 #ifndef mXPUSHp
3775 # define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END
3776 #endif
3777
3778 #ifndef mXPUSHn
3779 # define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END
3780 #endif
3781
3782 #ifndef mXPUSHi
3783 # define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END
3784 #endif
3785
3786 #ifndef mXPUSHu
3787 # define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END
3788 #endif
3789
3790 /* Replace: 1 */
3791 #ifndef call_sv
3792 # define call_sv perl_call_sv
3793 #endif
3794
3795 #ifndef call_pv
3796 # define call_pv perl_call_pv
3797 #endif
3798
3799 #ifndef call_argv
3800 # define call_argv perl_call_argv
3801 #endif
3802
3803 #ifndef call_method
3804 # define call_method perl_call_method
3805 #endif
3806 #ifndef eval_sv
3807 # define eval_sv perl_eval_sv
3808 #endif
3809
3810 /* Replace: 0 */
3811
3812 /* Replace perl_eval_pv with eval_pv */
3813 /* eval_pv depends on eval_sv */
3814
3815 #ifndef eval_pv
3816 #if defined(NEED_eval_pv)
3817 static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
3818 static
3819 #else
3820 extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
3821 #endif
3822
3823 #ifdef eval_pv
3824 # undef eval_pv
3825 #endif
3826 #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
3827 #define Perl_eval_pv DPPP_(my_eval_pv)
3828
3829 #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
3830
3831 SV*
DPPP_(my_eval_pv)3832 DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
3833 {
3834 dSP;
3835 SV* sv = newSVpv(p, 0);
3836
3837 PUSHMARK(sp);
3838 eval_sv(sv, G_SCALAR);
3839 SvREFCNT_dec(sv);
3840
3841 SPAGAIN;
3842 sv = POPs;
3843 PUTBACK;
3844
3845 if (croak_on_error && SvTRUE(GvSV(errgv)))
3846 croak(SvPVx(GvSV(errgv), na));
3847
3848 return sv;
3849 }
3850
3851 #endif
3852 #endif
3853 #ifndef newRV_inc
3854 # define newRV_inc(sv) newRV(sv) /* Replace */
3855 #endif
3856
3857 #ifndef newRV_noinc
3858 #if defined(NEED_newRV_noinc)
3859 static SV * DPPP_(my_newRV_noinc)(SV *sv);
3860 static
3861 #else
3862 extern SV * DPPP_(my_newRV_noinc)(SV *sv);
3863 #endif
3864
3865 #ifdef newRV_noinc
3866 # undef newRV_noinc
3867 #endif
3868 #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
3869 #define Perl_newRV_noinc DPPP_(my_newRV_noinc)
3870
3871 #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
3872 SV *
DPPP_(my_newRV_noinc)3873 DPPP_(my_newRV_noinc)(SV *sv)
3874 {
3875 SV *rv = (SV *)newRV(sv);
3876 SvREFCNT_dec(sv);
3877 return rv;
3878 }
3879 #endif
3880 #endif
3881
3882 /* Hint: newCONSTSUB
3883 * Returns a CV* as of perl-5.7.1. This return value is not supported
3884 * by Devel::PPPort.
3885 */
3886
3887 /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
3888 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))) && ((PERL_VERSION != 4) || (PERL_SUBVERSION != 5))
3889 #if defined(NEED_newCONSTSUB)
3890 static void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);
3891 static
3892 #else
3893 extern void DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv);
3894 #endif
3895
3896 #ifdef newCONSTSUB
3897 # undef newCONSTSUB
3898 #endif
3899 #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
3900 #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
3901
3902 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
3903
3904 void
DPPP_(my_newCONSTSUB)3905 DPPP_(my_newCONSTSUB)(HV *stash, char *name, SV *sv)
3906 {
3907 U32 oldhints = PL_hints;
3908 HV *old_cop_stash = PL_curcop->cop_stash;
3909 HV *old_curstash = PL_curstash;
3910 line_t oldline = PL_curcop->cop_line;
3911 PL_curcop->cop_line = PL_copline;
3912
3913 PL_hints &= ~HINT_BLOCK_SCOPE;
3914 if (stash)
3915 PL_curstash = PL_curcop->cop_stash = stash;
3916
3917 newSUB(
3918
3919 #if ((PERL_VERSION < 3) || ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22)))
3920 start_subparse(),
3921 #elif ((PERL_VERSION == 3) && (PERL_SUBVERSION == 22))
3922 start_subparse(0),
3923 #else /* 5.003_23 onwards */
3924 start_subparse(FALSE, 0),
3925 #endif
3926
3927 newSVOP(OP_CONST, 0, newSVpv(name,0)),
3928 newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
3929 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
3930 );
3931
3932 PL_hints = oldhints;
3933 PL_curcop->cop_stash = old_cop_stash;
3934 PL_curstash = old_curstash;
3935 PL_curcop->cop_line = oldline;
3936 }
3937 #endif
3938 #endif
3939
3940 /*
3941 * Boilerplate macros for initializing and accessing interpreter-local
3942 * data from C. All statics in extensions should be reworked to use
3943 * this, if you want to make the extension thread-safe. See ext/re/re.xs
3944 * for an example of the use of these macros.
3945 *
3946 * Code that uses these macros is responsible for the following:
3947 * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
3948 * 2. Declare a typedef named my_cxt_t that is a structure that contains
3949 * all the data that needs to be interpreter-local.
3950 * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
3951 * 4. Use the MY_CXT_INIT macro such that it is called exactly once
3952 * (typically put in the BOOT: section).
3953 * 5. Use the members of the my_cxt_t structure everywhere as
3954 * MY_CXT.member.
3955 * 6. Use the dMY_CXT macro (a declaration) in all the functions that
3956 * access MY_CXT.
3957 */
3958
3959 #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
3960 defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)
3961
3962 #ifndef START_MY_CXT
3963
3964 /* This must appear in all extensions that define a my_cxt_t structure,
3965 * right after the definition (i.e. at file scope). The non-threads
3966 * case below uses it to declare the data as static. */
3967 #define START_MY_CXT
3968
3969 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 68)))
3970 /* Fetches the SV that keeps the per-interpreter data. */
3971 #define dMY_CXT_SV \
3972 SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
3973 #else /* >= perl5.004_68 */
3974 #define dMY_CXT_SV \
3975 SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \
3976 sizeof(MY_CXT_KEY)-1, TRUE)
3977 #endif /* < perl5.004_68 */
3978
3979 /* This declaration should be used within all functions that use the
3980 * interpreter-local data. */
3981 #define dMY_CXT \
3982 dMY_CXT_SV; \
3983 my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
3984
3985 /* Creates and zeroes the per-interpreter data.
3986 * (We allocate my_cxtp in a Perl SV so that it will be released when
3987 * the interpreter goes away.) */
3988 #define MY_CXT_INIT \
3989 dMY_CXT_SV; \
3990 /* newSV() allocates one more than needed */ \
3991 my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
3992 Zero(my_cxtp, 1, my_cxt_t); \
3993 sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
3994
3995 /* This macro must be used to access members of the my_cxt_t structure.
3996 * e.g. MYCXT.some_data */
3997 #define MY_CXT (*my_cxtp)
3998
3999 /* Judicious use of these macros can reduce the number of times dMY_CXT
4000 * is used. Use is similar to pTHX, aTHX etc. */
4001 #define pMY_CXT my_cxt_t *my_cxtp
4002 #define pMY_CXT_ pMY_CXT,
4003 #define _pMY_CXT ,pMY_CXT
4004 #define aMY_CXT my_cxtp
4005 #define aMY_CXT_ aMY_CXT,
4006 #define _aMY_CXT ,aMY_CXT
4007
4008 #endif /* START_MY_CXT */
4009
4010 #ifndef MY_CXT_CLONE
4011 /* Clones the per-interpreter data. */
4012 #define MY_CXT_CLONE \
4013 dMY_CXT_SV; \
4014 my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
4015 Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
4016 sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
4017 #endif
4018
4019 #else /* single interpreter */
4020
4021 #ifndef START_MY_CXT
4022
4023 #define START_MY_CXT static my_cxt_t my_cxt;
4024 #define dMY_CXT_SV dNOOP
4025 #define dMY_CXT dNOOP
4026 #define MY_CXT_INIT NOOP
4027 #define MY_CXT my_cxt
4028
4029 #define pMY_CXT void
4030 #define pMY_CXT_
4031 #define _pMY_CXT
4032 #define aMY_CXT
4033 #define aMY_CXT_
4034 #define _aMY_CXT
4035
4036 #endif /* START_MY_CXT */
4037
4038 #ifndef MY_CXT_CLONE
4039 #define MY_CXT_CLONE NOOP
4040 #endif
4041
4042 #endif
4043
4044 #ifndef IVdf
4045 # if IVSIZE == LONGSIZE
4046 # define IVdf "ld"
4047 # define UVuf "lu"
4048 # define UVof "lo"
4049 # define UVxf "lx"
4050 # define UVXf "lX"
4051 # else
4052 # if IVSIZE == INTSIZE
4053 # define IVdf "d"
4054 # define UVuf "u"
4055 # define UVof "o"
4056 # define UVxf "x"
4057 # define UVXf "X"
4058 # endif
4059 # endif
4060 #endif
4061
4062 #ifndef NVef
4063 # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
4064 defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */
4065 # define NVef PERL_PRIeldbl
4066 # define NVff PERL_PRIfldbl
4067 # define NVgf PERL_PRIgldbl
4068 # else
4069 # define NVef "e"
4070 # define NVff "f"
4071 # define NVgf "g"
4072 # endif
4073 #endif
4074
4075 #ifndef SvREFCNT_inc
4076 # ifdef PERL_USE_GCC_BRACE_GROUPS
4077 # define SvREFCNT_inc(sv) \
4078 ({ \
4079 SV * const _sv = (SV*)(sv); \
4080 if (_sv) \
4081 (SvREFCNT(_sv))++; \
4082 _sv; \
4083 })
4084 # else
4085 # define SvREFCNT_inc(sv) \
4086 ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
4087 # endif
4088 #endif
4089
4090 #ifndef SvREFCNT_inc_simple
4091 # ifdef PERL_USE_GCC_BRACE_GROUPS
4092 # define SvREFCNT_inc_simple(sv) \
4093 ({ \
4094 if (sv) \
4095 (SvREFCNT(sv))++; \
4096 (SV *)(sv); \
4097 })
4098 # else
4099 # define SvREFCNT_inc_simple(sv) \
4100 ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
4101 # endif
4102 #endif
4103
4104 #ifndef SvREFCNT_inc_NN
4105 # ifdef PERL_USE_GCC_BRACE_GROUPS
4106 # define SvREFCNT_inc_NN(sv) \
4107 ({ \
4108 SV * const _sv = (SV*)(sv); \
4109 SvREFCNT(_sv)++; \
4110 _sv; \
4111 })
4112 # else
4113 # define SvREFCNT_inc_NN(sv) \
4114 (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
4115 # endif
4116 #endif
4117
4118 #ifndef SvREFCNT_inc_void
4119 # ifdef PERL_USE_GCC_BRACE_GROUPS
4120 # define SvREFCNT_inc_void(sv) \
4121 ({ \
4122 SV * const _sv = (SV*)(sv); \
4123 if (_sv) \
4124 (void)(SvREFCNT(_sv)++); \
4125 })
4126 # else
4127 # define SvREFCNT_inc_void(sv) \
4128 (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
4129 # endif
4130 #endif
4131 #ifndef SvREFCNT_inc_simple_void
4132 # define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
4133 #endif
4134
4135 #ifndef SvREFCNT_inc_simple_NN
4136 # define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv))
4137 #endif
4138
4139 #ifndef SvREFCNT_inc_void_NN
4140 # define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
4141 #endif
4142
4143 #ifndef SvREFCNT_inc_simple_void_NN
4144 # define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
4145 #endif
4146
4147 #ifndef SvPV_nolen
4148
4149 #if defined(NEED_sv_2pv_nolen)
4150 static char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
4151 static
4152 #else
4153 extern char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
4154 #endif
4155
4156 #ifdef sv_2pv_nolen
4157 # undef sv_2pv_nolen
4158 #endif
4159 #define sv_2pv_nolen(a) DPPP_(my_sv_2pv_nolen)(aTHX_ a)
4160 #define Perl_sv_2pv_nolen DPPP_(my_sv_2pv_nolen)
4161
4162 #if defined(NEED_sv_2pv_nolen) || defined(NEED_sv_2pv_nolen_GLOBAL)
4163
4164 char *
DPPP_(my_sv_2pv_nolen)4165 DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv)
4166 {
4167 STRLEN n_a;
4168 return sv_2pv(sv, &n_a);
4169 }
4170
4171 #endif
4172
4173 /* Hint: sv_2pv_nolen
4174 * Use the SvPV_nolen() macro instead of sv_2pv_nolen().
4175 */
4176
4177 /* SvPV_nolen depends on sv_2pv_nolen */
4178 #define SvPV_nolen(sv) \
4179 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4180 ? SvPVX(sv) : sv_2pv_nolen(sv))
4181
4182 #endif
4183
4184 #ifdef SvPVbyte
4185
4186 /* Hint: SvPVbyte
4187 * Does not work in perl-5.6.1, ppport.h implements a version
4188 * borrowed from perl-5.7.3.
4189 */
4190
4191 #if ((PERL_VERSION < 7) || ((PERL_VERSION == 7) && (PERL_SUBVERSION < 0)))
4192
4193 #if defined(NEED_sv_2pvbyte)
4194 static char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);
4195 static
4196 #else
4197 extern char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp);
4198 #endif
4199
4200 #ifdef sv_2pvbyte
4201 # undef sv_2pvbyte
4202 #endif
4203 #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
4204 #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
4205
4206 #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
4207
4208 char *
DPPP_(my_sv_2pvbyte)4209 DPPP_(my_sv_2pvbyte)(pTHX_ register SV *sv, STRLEN *lp)
4210 {
4211 sv_utf8_downgrade(sv,0);
4212 return SvPV(sv,*lp);
4213 }
4214
4215 #endif
4216
4217 /* Hint: sv_2pvbyte
4218 * Use the SvPVbyte() macro instead of sv_2pvbyte().
4219 */
4220
4221 #undef SvPVbyte
4222
4223 /* SvPVbyte depends on sv_2pvbyte */
4224 #define SvPVbyte(sv, lp) \
4225 ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
4226 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
4227
4228 #endif
4229
4230 #else
4231
4232 # define SvPVbyte SvPV
4233 # define sv_2pvbyte sv_2pv
4234
4235 #endif
4236
4237 /* sv_2pvbyte_nolen depends on sv_2pv_nolen */
4238 #ifndef sv_2pvbyte_nolen
4239 # define sv_2pvbyte_nolen sv_2pv_nolen
4240 #endif
4241
4242 /* Hint: sv_pvn
4243 * Always use the SvPV() macro instead of sv_pvn().
4244 */
4245 #ifndef sv_pvn
4246 # define sv_pvn(sv, len) SvPV(sv, len)
4247 #endif
4248
4249 /* Hint: sv_pvn_force
4250 * Always use the SvPV_force() macro instead of sv_pvn_force().
4251 */
4252 #ifndef sv_pvn_force
4253 # define sv_pvn_force(sv, len) SvPV_force(sv, len)
4254 #endif
4255 #ifndef SvMAGIC_set
4256 # define SvMAGIC_set(sv, val) \
4257 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
4258 (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
4259 #endif
4260
4261 #if ((PERL_VERSION < 9) || ((PERL_VERSION == 9) && (PERL_SUBVERSION < 3)))
4262 #ifndef SvPVX_const
4263 # define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
4264 #endif
4265
4266 #ifndef SvPVX_mutable
4267 # define SvPVX_mutable(sv) (0 + SvPVX(sv))
4268 #endif
4269 #ifndef SvRV_set
4270 # define SvRV_set(sv, val) \
4271 STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
4272 (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
4273 #endif
4274
4275 #else
4276 #ifndef SvPVX_const
4277 # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv))
4278 #endif
4279
4280 #ifndef SvPVX_mutable
4281 # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv)
4282 #endif
4283 #ifndef SvRV_set
4284 # define SvRV_set(sv, val) \
4285 STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
4286 ((sv)->sv_u.svu_rv = (val)); } STMT_END
4287 #endif
4288
4289 #endif
4290 #ifndef SvSTASH_set
4291 # define SvSTASH_set(sv, val) \
4292 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
4293 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
4294 #endif
4295
4296 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION < 0)))
4297 #ifndef SvUV_set
4298 # define SvUV_set(sv, val) \
4299 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
4300 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
4301 #endif
4302
4303 #else
4304 #ifndef SvUV_set
4305 # define SvUV_set(sv, val) \
4306 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
4307 (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
4308 #endif
4309
4310 #endif
4311
4312 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(vnewSVpvf)
4313 #if defined(NEED_vnewSVpvf)
4314 static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
4315 static
4316 #else
4317 extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
4318 #endif
4319
4320 #ifdef vnewSVpvf
4321 # undef vnewSVpvf
4322 #endif
4323 #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
4324 #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
4325
4326 #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
4327
4328 SV *
DPPP_(my_vnewSVpvf)4329 DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
4330 {
4331 register SV *sv = newSV(0);
4332 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
4333 return sv;
4334 }
4335
4336 #endif
4337 #endif
4338
4339 /* sv_vcatpvf depends on sv_vcatpvfn */
4340 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf)
4341 # define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
4342 #endif
4343
4344 /* sv_vsetpvf depends on sv_vsetpvfn */
4345 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf)
4346 # define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
4347 #endif
4348
4349 /* sv_catpvf_mg depends on sv_vcatpvfn, sv_catpvf_mg_nocontext */
4350 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg)
4351 #if defined(NEED_sv_catpvf_mg)
4352 static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4353 static
4354 #else
4355 extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4356 #endif
4357
4358 #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
4359
4360 #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
4361
4362 void
DPPP_(my_sv_catpvf_mg)4363 DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
4364 {
4365 va_list args;
4366 va_start(args, pat);
4367 sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
4368 SvSETMAGIC(sv);
4369 va_end(args);
4370 }
4371
4372 #endif
4373 #endif
4374
4375 /* sv_catpvf_mg_nocontext depends on sv_vcatpvfn */
4376 #ifdef PERL_IMPLICIT_CONTEXT
4377 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg_nocontext)
4378 #if defined(NEED_sv_catpvf_mg_nocontext)
4379 static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4380 static
4381 #else
4382 extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4383 #endif
4384
4385 #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
4386 #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
4387
4388 #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
4389
4390 void
DPPP_(my_sv_catpvf_mg_nocontext)4391 DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
4392 {
4393 dTHX;
4394 va_list args;
4395 va_start(args, pat);
4396 sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
4397 SvSETMAGIC(sv);
4398 va_end(args);
4399 }
4400
4401 #endif
4402 #endif
4403 #endif
4404
4405 #ifndef sv_catpvf_mg
4406 # ifdef PERL_IMPLICIT_CONTEXT
4407 # define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext
4408 # else
4409 # define sv_catpvf_mg Perl_sv_catpvf_mg
4410 # endif
4411 #endif
4412
4413 /* sv_vcatpvf_mg depends on sv_vcatpvfn */
4414 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf_mg)
4415 # define sv_vcatpvf_mg(sv, pat, args) \
4416 STMT_START { \
4417 sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
4418 SvSETMAGIC(sv); \
4419 } STMT_END
4420 #endif
4421
4422 /* sv_setpvf_mg depends on sv_vsetpvfn, sv_setpvf_mg_nocontext */
4423 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg)
4424 #if defined(NEED_sv_setpvf_mg)
4425 static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4426 static
4427 #else
4428 extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
4429 #endif
4430
4431 #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
4432
4433 #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
4434
4435 void
DPPP_(my_sv_setpvf_mg)4436 DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
4437 {
4438 va_list args;
4439 va_start(args, pat);
4440 sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
4441 SvSETMAGIC(sv);
4442 va_end(args);
4443 }
4444
4445 #endif
4446 #endif
4447
4448 /* sv_setpvf_mg_nocontext depends on sv_vsetpvfn */
4449 #ifdef PERL_IMPLICIT_CONTEXT
4450 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg_nocontext)
4451 #if defined(NEED_sv_setpvf_mg_nocontext)
4452 static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4453 static
4454 #else
4455 extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
4456 #endif
4457
4458 #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
4459 #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
4460
4461 #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
4462
4463 void
DPPP_(my_sv_setpvf_mg_nocontext)4464 DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
4465 {
4466 dTHX;
4467 va_list args;
4468 va_start(args, pat);
4469 sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
4470 SvSETMAGIC(sv);
4471 va_end(args);
4472 }
4473
4474 #endif
4475 #endif
4476 #endif
4477
4478 #ifndef sv_setpvf_mg
4479 # ifdef PERL_IMPLICIT_CONTEXT
4480 # define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext
4481 # else
4482 # define sv_setpvf_mg Perl_sv_setpvf_mg
4483 # endif
4484 #endif
4485
4486 /* sv_vsetpvf_mg depends on sv_vsetpvfn */
4487 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf_mg)
4488 # define sv_vsetpvf_mg(sv, pat, args) \
4489 STMT_START { \
4490 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
4491 SvSETMAGIC(sv); \
4492 } STMT_END
4493 #endif
4494 #ifndef WARN_ALL
4495 # define WARN_ALL 0
4496 #endif
4497
4498 #ifndef WARN_CLOSURE
4499 # define WARN_CLOSURE 1
4500 #endif
4501
4502 #ifndef WARN_DEPRECATED
4503 # define WARN_DEPRECATED 2
4504 #endif
4505
4506 #ifndef WARN_EXITING
4507 # define WARN_EXITING 3
4508 #endif
4509
4510 #ifndef WARN_GLOB
4511 # define WARN_GLOB 4
4512 #endif
4513
4514 #ifndef WARN_IO
4515 # define WARN_IO 5
4516 #endif
4517
4518 #ifndef WARN_CLOSED
4519 # define WARN_CLOSED 6
4520 #endif
4521
4522 #ifndef WARN_EXEC
4523 # define WARN_EXEC 7
4524 #endif
4525
4526 #ifndef WARN_LAYER
4527 # define WARN_LAYER 8
4528 #endif
4529
4530 #ifndef WARN_NEWLINE
4531 # define WARN_NEWLINE 9
4532 #endif
4533
4534 #ifndef WARN_PIPE
4535 # define WARN_PIPE 10
4536 #endif
4537
4538 #ifndef WARN_UNOPENED
4539 # define WARN_UNOPENED 11
4540 #endif
4541
4542 #ifndef WARN_MISC
4543 # define WARN_MISC 12
4544 #endif
4545
4546 #ifndef WARN_NUMERIC
4547 # define WARN_NUMERIC 13
4548 #endif
4549
4550 #ifndef WARN_ONCE
4551 # define WARN_ONCE 14
4552 #endif
4553
4554 #ifndef WARN_OVERFLOW
4555 # define WARN_OVERFLOW 15
4556 #endif
4557
4558 #ifndef WARN_PACK
4559 # define WARN_PACK 16
4560 #endif
4561
4562 #ifndef WARN_PORTABLE
4563 # define WARN_PORTABLE 17
4564 #endif
4565
4566 #ifndef WARN_RECURSION
4567 # define WARN_RECURSION 18
4568 #endif
4569
4570 #ifndef WARN_REDEFINE
4571 # define WARN_REDEFINE 19
4572 #endif
4573
4574 #ifndef WARN_REGEXP
4575 # define WARN_REGEXP 20
4576 #endif
4577
4578 #ifndef WARN_SEVERE
4579 # define WARN_SEVERE 21
4580 #endif
4581
4582 #ifndef WARN_DEBUGGING
4583 # define WARN_DEBUGGING 22
4584 #endif
4585
4586 #ifndef WARN_INPLACE
4587 # define WARN_INPLACE 23
4588 #endif
4589
4590 #ifndef WARN_INTERNAL
4591 # define WARN_INTERNAL 24
4592 #endif
4593
4594 #ifndef WARN_MALLOC
4595 # define WARN_MALLOC 25
4596 #endif
4597
4598 #ifndef WARN_SIGNAL
4599 # define WARN_SIGNAL 26
4600 #endif
4601
4602 #ifndef WARN_SUBSTR
4603 # define WARN_SUBSTR 27
4604 #endif
4605
4606 #ifndef WARN_SYNTAX
4607 # define WARN_SYNTAX 28
4608 #endif
4609
4610 #ifndef WARN_AMBIGUOUS
4611 # define WARN_AMBIGUOUS 29
4612 #endif
4613
4614 #ifndef WARN_BAREWORD
4615 # define WARN_BAREWORD 30
4616 #endif
4617
4618 #ifndef WARN_DIGIT
4619 # define WARN_DIGIT 31
4620 #endif
4621
4622 #ifndef WARN_PARENTHESIS
4623 # define WARN_PARENTHESIS 32
4624 #endif
4625
4626 #ifndef WARN_PRECEDENCE
4627 # define WARN_PRECEDENCE 33
4628 #endif
4629
4630 #ifndef WARN_PRINTF
4631 # define WARN_PRINTF 34
4632 #endif
4633
4634 #ifndef WARN_PROTOTYPE
4635 # define WARN_PROTOTYPE 35
4636 #endif
4637
4638 #ifndef WARN_QW
4639 # define WARN_QW 36
4640 #endif
4641
4642 #ifndef WARN_RESERVED
4643 # define WARN_RESERVED 37
4644 #endif
4645
4646 #ifndef WARN_SEMICOLON
4647 # define WARN_SEMICOLON 38
4648 #endif
4649
4650 #ifndef WARN_TAINT
4651 # define WARN_TAINT 39
4652 #endif
4653
4654 #ifndef WARN_THREADS
4655 # define WARN_THREADS 40
4656 #endif
4657
4658 #ifndef WARN_UNINITIALIZED
4659 # define WARN_UNINITIALIZED 41
4660 #endif
4661
4662 #ifndef WARN_UNPACK
4663 # define WARN_UNPACK 42
4664 #endif
4665
4666 #ifndef WARN_UNTIE
4667 # define WARN_UNTIE 43
4668 #endif
4669
4670 #ifndef WARN_UTF8
4671 # define WARN_UTF8 44
4672 #endif
4673
4674 #ifndef WARN_VOID
4675 # define WARN_VOID 45
4676 #endif
4677
4678 #ifndef WARN_ASSERTIONS
4679 # define WARN_ASSERTIONS 46
4680 #endif
4681 #ifndef packWARN
4682 # define packWARN(a) (a)
4683 #endif
4684
4685 #ifndef ckWARN
4686 # ifdef G_WARN_ON
4687 # define ckWARN(a) (PL_dowarn & G_WARN_ON)
4688 # else
4689 # define ckWARN(a) PL_dowarn
4690 # endif
4691 #endif
4692
4693 /* warner depends on vnewSVpvf */
4694 #if ((PERL_VERSION > 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(warner)
4695 #if defined(NEED_warner)
4696 static void DPPP_(my_warner)(U32 err, const char *pat, ...);
4697 static
4698 #else
4699 extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
4700 #endif
4701
4702 #define Perl_warner DPPP_(my_warner)
4703
4704 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
4705
4706 void
DPPP_(my_warner)4707 DPPP_(my_warner)(U32 err, const char *pat, ...)
4708 {
4709 SV *sv;
4710 va_list args;
4711
4712 PERL_UNUSED_ARG(err);
4713
4714 va_start(args, pat);
4715 sv = vnewSVpvf(pat, &args);
4716 va_end(args);
4717 sv_2mortal(sv);
4718 warn("%s", SvPV_nolen(sv));
4719 }
4720
4721 #define warner Perl_warner
4722
4723 /* Perl_warner_nocontext depends on warner */
4724 #define Perl_warner_nocontext Perl_warner
4725
4726 #endif
4727 #endif
4728
4729 /* concatenating with "" ensures that only literal strings are accepted as argument
4730 * note that STR_WITH_LEN() can't be used as argument to macros or functions that
4731 * under some configurations might be macros
4732 */
4733 #ifndef STR_WITH_LEN
4734 # define STR_WITH_LEN(s) (s ""), (sizeof(s)-1)
4735 #endif
4736 #ifndef newSVpvs
4737 # define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1)
4738 #endif
4739
4740 #ifndef sv_catpvs
4741 # define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1)
4742 #endif
4743
4744 #ifndef sv_setpvs
4745 # define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1)
4746 #endif
4747
4748 #ifndef hv_fetchs
4749 # define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval)
4750 #endif
4751
4752 #ifndef hv_stores
4753 # define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0)
4754 #endif
4755 #ifndef SvGETMAGIC
4756 # define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
4757 #endif
4758 #ifndef PERL_MAGIC_sv
4759 # define PERL_MAGIC_sv '\0'
4760 #endif
4761
4762 #ifndef PERL_MAGIC_overload
4763 # define PERL_MAGIC_overload 'A'
4764 #endif
4765
4766 #ifndef PERL_MAGIC_overload_elem
4767 # define PERL_MAGIC_overload_elem 'a'
4768 #endif
4769
4770 #ifndef PERL_MAGIC_overload_table
4771 # define PERL_MAGIC_overload_table 'c'
4772 #endif
4773
4774 #ifndef PERL_MAGIC_bm
4775 # define PERL_MAGIC_bm 'B'
4776 #endif
4777
4778 #ifndef PERL_MAGIC_regdata
4779 # define PERL_MAGIC_regdata 'D'
4780 #endif
4781
4782 #ifndef PERL_MAGIC_regdatum
4783 # define PERL_MAGIC_regdatum 'd'
4784 #endif
4785
4786 #ifndef PERL_MAGIC_env
4787 # define PERL_MAGIC_env 'E'
4788 #endif
4789
4790 #ifndef PERL_MAGIC_envelem
4791 # define PERL_MAGIC_envelem 'e'
4792 #endif
4793
4794 #ifndef PERL_MAGIC_fm
4795 # define PERL_MAGIC_fm 'f'
4796 #endif
4797
4798 #ifndef PERL_MAGIC_regex_global
4799 # define PERL_MAGIC_regex_global 'g'
4800 #endif
4801
4802 #ifndef PERL_MAGIC_isa
4803 # define PERL_MAGIC_isa 'I'
4804 #endif
4805
4806 #ifndef PERL_MAGIC_isaelem
4807 # define PERL_MAGIC_isaelem 'i'
4808 #endif
4809
4810 #ifndef PERL_MAGIC_nkeys
4811 # define PERL_MAGIC_nkeys 'k'
4812 #endif
4813
4814 #ifndef PERL_MAGIC_dbfile
4815 # define PERL_MAGIC_dbfile 'L'
4816 #endif
4817
4818 #ifndef PERL_MAGIC_dbline
4819 # define PERL_MAGIC_dbline 'l'
4820 #endif
4821
4822 #ifndef PERL_MAGIC_mutex
4823 # define PERL_MAGIC_mutex 'm'
4824 #endif
4825
4826 #ifndef PERL_MAGIC_shared
4827 # define PERL_MAGIC_shared 'N'
4828 #endif
4829
4830 #ifndef PERL_MAGIC_shared_scalar
4831 # define PERL_MAGIC_shared_scalar 'n'
4832 #endif
4833
4834 #ifndef PERL_MAGIC_collxfrm
4835 # define PERL_MAGIC_collxfrm 'o'
4836 #endif
4837
4838 #ifndef PERL_MAGIC_tied
4839 # define PERL_MAGIC_tied 'P'
4840 #endif
4841
4842 #ifndef PERL_MAGIC_tiedelem
4843 # define PERL_MAGIC_tiedelem 'p'
4844 #endif
4845
4846 #ifndef PERL_MAGIC_tiedscalar
4847 # define PERL_MAGIC_tiedscalar 'q'
4848 #endif
4849
4850 #ifndef PERL_MAGIC_qr
4851 # define PERL_MAGIC_qr 'r'
4852 #endif
4853
4854 #ifndef PERL_MAGIC_sig
4855 # define PERL_MAGIC_sig 'S'
4856 #endif
4857
4858 #ifndef PERL_MAGIC_sigelem
4859 # define PERL_MAGIC_sigelem 's'
4860 #endif
4861
4862 #ifndef PERL_MAGIC_taint
4863 # define PERL_MAGIC_taint 't'
4864 #endif
4865
4866 #ifndef PERL_MAGIC_uvar
4867 # define PERL_MAGIC_uvar 'U'
4868 #endif
4869
4870 #ifndef PERL_MAGIC_uvar_elem
4871 # define PERL_MAGIC_uvar_elem 'u'
4872 #endif
4873
4874 #ifndef PERL_MAGIC_vstring
4875 # define PERL_MAGIC_vstring 'V'
4876 #endif
4877
4878 #ifndef PERL_MAGIC_vec
4879 # define PERL_MAGIC_vec 'v'
4880 #endif
4881
4882 #ifndef PERL_MAGIC_utf8
4883 # define PERL_MAGIC_utf8 'w'
4884 #endif
4885
4886 #ifndef PERL_MAGIC_substr
4887 # define PERL_MAGIC_substr 'x'
4888 #endif
4889
4890 #ifndef PERL_MAGIC_defelem
4891 # define PERL_MAGIC_defelem 'y'
4892 #endif
4893
4894 #ifndef PERL_MAGIC_glob
4895 # define PERL_MAGIC_glob '*'
4896 #endif
4897
4898 #ifndef PERL_MAGIC_arylen
4899 # define PERL_MAGIC_arylen '#'
4900 #endif
4901
4902 #ifndef PERL_MAGIC_pos
4903 # define PERL_MAGIC_pos '.'
4904 #endif
4905
4906 #ifndef PERL_MAGIC_backref
4907 # define PERL_MAGIC_backref '<'
4908 #endif
4909
4910 #ifndef PERL_MAGIC_ext
4911 # define PERL_MAGIC_ext '~'
4912 #endif
4913
4914 /* That's the best we can do... */
4915 #ifndef SvPV_force_nomg
4916 # define SvPV_force_nomg SvPV_force
4917 #endif
4918
4919 #ifndef SvPV_nomg
4920 # define SvPV_nomg SvPV
4921 #endif
4922
4923 #ifndef sv_catpvn_nomg
4924 # define sv_catpvn_nomg sv_catpvn
4925 #endif
4926
4927 #ifndef sv_catsv_nomg
4928 # define sv_catsv_nomg sv_catsv
4929 #endif
4930
4931 #ifndef sv_setsv_nomg
4932 # define sv_setsv_nomg sv_setsv
4933 #endif
4934
4935 #ifndef sv_pvn_nomg
4936 # define sv_pvn_nomg sv_pvn
4937 #endif
4938
4939 #ifndef SvIV_nomg
4940 # define SvIV_nomg SvIV
4941 #endif
4942
4943 #ifndef SvUV_nomg
4944 # define SvUV_nomg SvUV
4945 #endif
4946
4947 #ifndef sv_catpv_mg
4948 # define sv_catpv_mg(sv, ptr) \
4949 STMT_START { \
4950 SV *TeMpSv = sv; \
4951 sv_catpv(TeMpSv,ptr); \
4952 SvSETMAGIC(TeMpSv); \
4953 } STMT_END
4954 #endif
4955
4956 #ifndef sv_catpvn_mg
4957 # define sv_catpvn_mg(sv, ptr, len) \
4958 STMT_START { \
4959 SV *TeMpSv = sv; \
4960 sv_catpvn(TeMpSv,ptr,len); \
4961 SvSETMAGIC(TeMpSv); \
4962 } STMT_END
4963 #endif
4964
4965 #ifndef sv_catsv_mg
4966 # define sv_catsv_mg(dsv, ssv) \
4967 STMT_START { \
4968 SV *TeMpSv = dsv; \
4969 sv_catsv(TeMpSv,ssv); \
4970 SvSETMAGIC(TeMpSv); \
4971 } STMT_END
4972 #endif
4973
4974 #ifndef sv_setiv_mg
4975 # define sv_setiv_mg(sv, i) \
4976 STMT_START { \
4977 SV *TeMpSv = sv; \
4978 sv_setiv(TeMpSv,i); \
4979 SvSETMAGIC(TeMpSv); \
4980 } STMT_END
4981 #endif
4982
4983 #ifndef sv_setnv_mg
4984 # define sv_setnv_mg(sv, num) \
4985 STMT_START { \
4986 SV *TeMpSv = sv; \
4987 sv_setnv(TeMpSv,num); \
4988 SvSETMAGIC(TeMpSv); \
4989 } STMT_END
4990 #endif
4991
4992 #ifndef sv_setpv_mg
4993 # define sv_setpv_mg(sv, ptr) \
4994 STMT_START { \
4995 SV *TeMpSv = sv; \
4996 sv_setpv(TeMpSv,ptr); \
4997 SvSETMAGIC(TeMpSv); \
4998 } STMT_END
4999 #endif
5000
5001 #ifndef sv_setpvn_mg
5002 # define sv_setpvn_mg(sv, ptr, len) \
5003 STMT_START { \
5004 SV *TeMpSv = sv; \
5005 sv_setpvn(TeMpSv,ptr,len); \
5006 SvSETMAGIC(TeMpSv); \
5007 } STMT_END
5008 #endif
5009
5010 #ifndef sv_setsv_mg
5011 # define sv_setsv_mg(dsv, ssv) \
5012 STMT_START { \
5013 SV *TeMpSv = dsv; \
5014 sv_setsv(TeMpSv,ssv); \
5015 SvSETMAGIC(TeMpSv); \
5016 } STMT_END
5017 #endif
5018
5019 #ifndef sv_setuv_mg
5020 # define sv_setuv_mg(sv, i) \
5021 STMT_START { \
5022 SV *TeMpSv = sv; \
5023 sv_setuv(TeMpSv,i); \
5024 SvSETMAGIC(TeMpSv); \
5025 } STMT_END
5026 #endif
5027
5028 #ifndef sv_usepvn_mg
5029 # define sv_usepvn_mg(sv, ptr, len) \
5030 STMT_START { \
5031 SV *TeMpSv = sv; \
5032 sv_usepvn(TeMpSv,ptr,len); \
5033 SvSETMAGIC(TeMpSv); \
5034 } STMT_END
5035 #endif
5036 #ifndef SvVSTRING_mg
5037 # define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
5038 #endif
5039
5040 #ifdef USE_ITHREADS
5041 #ifndef CopFILE
5042 # define CopFILE(c) ((c)->cop_file)
5043 #endif
5044
5045 #ifndef CopFILEGV
5046 # define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
5047 #endif
5048
5049 #ifndef CopFILE_set
5050 # define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv))
5051 #endif
5052
5053 #ifndef CopFILESV
5054 # define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
5055 #endif
5056
5057 #ifndef CopFILEAV
5058 # define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
5059 #endif
5060
5061 #ifndef CopSTASHPV
5062 # define CopSTASHPV(c) ((c)->cop_stashpv)
5063 #endif
5064
5065 #ifndef CopSTASHPV_set
5066 # define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
5067 #endif
5068
5069 #ifndef CopSTASH
5070 # define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
5071 #endif
5072
5073 #ifndef CopSTASH_set
5074 # define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
5075 #endif
5076
5077 #ifndef CopSTASH_eq
5078 # define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
5079 || (CopSTASHPV(c) && HvNAME(hv) \
5080 && strEQ(CopSTASHPV(c), HvNAME(hv)))))
5081 #endif
5082
5083 #else
5084 #ifndef CopFILEGV
5085 # define CopFILEGV(c) ((c)->cop_filegv)
5086 #endif
5087
5088 #ifndef CopFILEGV_set
5089 # define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
5090 #endif
5091
5092 #ifndef CopFILE_set
5093 # define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv))
5094 #endif
5095
5096 #ifndef CopFILESV
5097 # define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
5098 #endif
5099
5100 #ifndef CopFILEAV
5101 # define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
5102 #endif
5103
5104 #ifndef CopFILE
5105 # define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
5106 #endif
5107
5108 #ifndef CopSTASH
5109 # define CopSTASH(c) ((c)->cop_stash)
5110 #endif
5111
5112 #ifndef CopSTASH_set
5113 # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv))
5114 #endif
5115
5116 #ifndef CopSTASHPV
5117 # define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
5118 #endif
5119
5120 #ifndef CopSTASHPV_set
5121 # define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
5122 #endif
5123
5124 #ifndef CopSTASH_eq
5125 # define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv))
5126 #endif
5127
5128 #endif /* USE_ITHREADS */
5129 #ifndef IN_PERL_COMPILETIME
5130 # define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling)
5131 #endif
5132
5133 #ifndef IN_LOCALE_RUNTIME
5134 # define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE)
5135 #endif
5136
5137 #ifndef IN_LOCALE_COMPILETIME
5138 # define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE)
5139 #endif
5140
5141 #ifndef IN_LOCALE
5142 # define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)
5143 #endif
5144 #ifndef IS_NUMBER_IN_UV
5145 # define IS_NUMBER_IN_UV 0x01
5146 #endif
5147
5148 #ifndef IS_NUMBER_GREATER_THAN_UV_MAX
5149 # define IS_NUMBER_GREATER_THAN_UV_MAX 0x02
5150 #endif
5151
5152 #ifndef IS_NUMBER_NOT_INT
5153 # define IS_NUMBER_NOT_INT 0x04
5154 #endif
5155
5156 #ifndef IS_NUMBER_NEG
5157 # define IS_NUMBER_NEG 0x08
5158 #endif
5159
5160 #ifndef IS_NUMBER_INFINITY
5161 # define IS_NUMBER_INFINITY 0x10
5162 #endif
5163
5164 #ifndef IS_NUMBER_NAN
5165 # define IS_NUMBER_NAN 0x20
5166 #endif
5167
5168 /* GROK_NUMERIC_RADIX depends on grok_numeric_radix */
5169 #ifndef GROK_NUMERIC_RADIX
5170 # define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send)
5171 #endif
5172 #ifndef PERL_SCAN_GREATER_THAN_UV_MAX
5173 # define PERL_SCAN_GREATER_THAN_UV_MAX 0x02
5174 #endif
5175
5176 #ifndef PERL_SCAN_SILENT_ILLDIGIT
5177 # define PERL_SCAN_SILENT_ILLDIGIT 0x04
5178 #endif
5179
5180 #ifndef PERL_SCAN_ALLOW_UNDERSCORES
5181 # define PERL_SCAN_ALLOW_UNDERSCORES 0x01
5182 #endif
5183
5184 #ifndef PERL_SCAN_DISALLOW_PREFIX
5185 # define PERL_SCAN_DISALLOW_PREFIX 0x02
5186 #endif
5187
5188 #ifndef grok_numeric_radix
5189 #if defined(NEED_grok_numeric_radix)
5190 static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
5191 static
5192 #else
5193 extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
5194 #endif
5195
5196 #ifdef grok_numeric_radix
5197 # undef grok_numeric_radix
5198 #endif
5199 #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
5200 #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
5201
5202 #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
5203 bool
DPPP_(my_grok_numeric_radix)5204 DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
5205 {
5206 #ifdef USE_LOCALE_NUMERIC
5207 #ifdef PL_numeric_radix_sv
5208 if (PL_numeric_radix_sv && IN_LOCALE) {
5209 STRLEN len;
5210 char* radix = SvPV(PL_numeric_radix_sv, len);
5211 if (*sp + len <= send && memEQ(*sp, radix, len)) {
5212 *sp += len;
5213 return TRUE;
5214 }
5215 }
5216 #else
5217 /* older perls don't have PL_numeric_radix_sv so the radix
5218 * must manually be requested from locale.h
5219 */
5220 #include <locale.h>
5221 dTHR; /* needed for older threaded perls */
5222 struct lconv *lc = localeconv();
5223 char *radix = lc->decimal_point;
5224 if (radix && IN_LOCALE) {
5225 STRLEN len = strlen(radix);
5226 if (*sp + len <= send && memEQ(*sp, radix, len)) {
5227 *sp += len;
5228 return TRUE;
5229 }
5230 }
5231 #endif
5232 #endif /* USE_LOCALE_NUMERIC */
5233 /* always try "." if numeric radix didn't match because
5234 * we may have data from different locales mixed */
5235 if (*sp < send && **sp == '.') {
5236 ++*sp;
5237 return TRUE;
5238 }
5239 return FALSE;
5240 }
5241 #endif
5242 #endif
5243
5244 /* grok_number depends on grok_numeric_radix */
5245
5246 #ifndef grok_number
5247 #if defined(NEED_grok_number)
5248 static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
5249 static
5250 #else
5251 extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
5252 #endif
5253
5254 #ifdef grok_number
5255 # undef grok_number
5256 #endif
5257 #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
5258 #define Perl_grok_number DPPP_(my_grok_number)
5259
5260 #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
5261 int
DPPP_(my_grok_number)5262 DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
5263 {
5264 const char *s = pv;
5265 const char *send = pv + len;
5266 const UV max_div_10 = UV_MAX / 10;
5267 const char max_mod_10 = UV_MAX % 10;
5268 int numtype = 0;
5269 int sawinf = 0;
5270 int sawnan = 0;
5271
5272 while (s < send && isSPACE(*s))
5273 s++;
5274 if (s == send) {
5275 return 0;
5276 } else if (*s == '-') {
5277 s++;
5278 numtype = IS_NUMBER_NEG;
5279 }
5280 else if (*s == '+')
5281 s++;
5282
5283 if (s == send)
5284 return 0;
5285
5286 /* next must be digit or the radix separator or beginning of infinity */
5287 if (isDIGIT(*s)) {
5288 /* UVs are at least 32 bits, so the first 9 decimal digits cannot
5289 overflow. */
5290 UV value = *s - '0';
5291 /* This construction seems to be more optimiser friendly.
5292 (without it gcc does the isDIGIT test and the *s - '0' separately)
5293 With it gcc on arm is managing 6 instructions (6 cycles) per digit.
5294 In theory the optimiser could deduce how far to unroll the loop
5295 before checking for overflow. */
5296 if (++s < send) {
5297 int digit = *s - '0';
5298 if (digit >= 0 && digit <= 9) {
5299 value = value * 10 + digit;
5300 if (++s < send) {
5301 digit = *s - '0';
5302 if (digit >= 0 && digit <= 9) {
5303 value = value * 10 + digit;
5304 if (++s < send) {
5305 digit = *s - '0';
5306 if (digit >= 0 && digit <= 9) {
5307 value = value * 10 + digit;
5308 if (++s < send) {
5309 digit = *s - '0';
5310 if (digit >= 0 && digit <= 9) {
5311 value = value * 10 + digit;
5312 if (++s < send) {
5313 digit = *s - '0';
5314 if (digit >= 0 && digit <= 9) {
5315 value = value * 10 + digit;
5316 if (++s < send) {
5317 digit = *s - '0';
5318 if (digit >= 0 && digit <= 9) {
5319 value = value * 10 + digit;
5320 if (++s < send) {
5321 digit = *s - '0';
5322 if (digit >= 0 && digit <= 9) {
5323 value = value * 10 + digit;
5324 if (++s < send) {
5325 digit = *s - '0';
5326 if (digit >= 0 && digit <= 9) {
5327 value = value * 10 + digit;
5328 if (++s < send) {
5329 /* Now got 9 digits, so need to check
5330 each time for overflow. */
5331 digit = *s - '0';
5332 while (digit >= 0 && digit <= 9
5333 && (value < max_div_10
5334 || (value == max_div_10
5335 && digit <= max_mod_10))) {
5336 value = value * 10 + digit;
5337 if (++s < send)
5338 digit = *s - '0';
5339 else
5340 break;
5341 }
5342 if (digit >= 0 && digit <= 9
5343 && (s < send)) {
5344 /* value overflowed.
5345 skip the remaining digits, don't
5346 worry about setting *valuep. */
5347 do {
5348 s++;
5349 } while (s < send && isDIGIT(*s));
5350 numtype |=
5351 IS_NUMBER_GREATER_THAN_UV_MAX;
5352 goto skip_value;
5353 }
5354 }
5355 }
5356 }
5357 }
5358 }
5359 }
5360 }
5361 }
5362 }
5363 }
5364 }
5365 }
5366 }
5367 }
5368 }
5369 }
5370 }
5371 numtype |= IS_NUMBER_IN_UV;
5372 if (valuep)
5373 *valuep = value;
5374
5375 skip_value:
5376 if (GROK_NUMERIC_RADIX(&s, send)) {
5377 numtype |= IS_NUMBER_NOT_INT;
5378 while (s < send && isDIGIT(*s)) /* optional digits after the radix */
5379 s++;
5380 }
5381 }
5382 else if (GROK_NUMERIC_RADIX(&s, send)) {
5383 numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */
5384 /* no digits before the radix means we need digits after it */
5385 if (s < send && isDIGIT(*s)) {
5386 do {
5387 s++;
5388 } while (s < send && isDIGIT(*s));
5389 if (valuep) {
5390 /* integer approximation is valid - it's 0. */
5391 *valuep = 0;
5392 }
5393 }
5394 else
5395 return 0;
5396 } else if (*s == 'I' || *s == 'i') {
5397 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
5398 s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
5399 s++; if (s < send && (*s == 'I' || *s == 'i')) {
5400 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
5401 s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
5402 s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
5403 s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
5404 s++;
5405 }
5406 sawinf = 1;
5407 } else if (*s == 'N' || *s == 'n') {
5408 /* XXX TODO: There are signaling NaNs and quiet NaNs. */
5409 s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
5410 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
5411 s++;
5412 sawnan = 1;
5413 } else
5414 return 0;
5415
5416 if (sawinf) {
5417 numtype &= IS_NUMBER_NEG; /* Keep track of sign */
5418 numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
5419 } else if (sawnan) {
5420 numtype &= IS_NUMBER_NEG; /* Keep track of sign */
5421 numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;
5422 } else if (s < send) {
5423 /* we can have an optional exponent part */
5424 if (*s == 'e' || *s == 'E') {
5425 /* The only flag we keep is sign. Blow away any "it's UV" */
5426 numtype &= IS_NUMBER_NEG;
5427 numtype |= IS_NUMBER_NOT_INT;
5428 s++;
5429 if (s < send && (*s == '-' || *s == '+'))
5430 s++;
5431 if (s < send && isDIGIT(*s)) {
5432 do {
5433 s++;
5434 } while (s < send && isDIGIT(*s));
5435 }
5436 else
5437 return 0;
5438 }
5439 }
5440 while (s < send && isSPACE(*s))
5441 s++;
5442 if (s >= send)
5443 return numtype;
5444 if (len == 10 && memEQ(pv, "0 but true", 10)) {
5445 if (valuep)
5446 *valuep = 0;
5447 return IS_NUMBER_IN_UV;
5448 }
5449 return 0;
5450 }
5451 #endif
5452 #endif
5453
5454 /*
5455 * The grok_* routines have been modified to use warn() instead of
5456 * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,
5457 * which is why the stack variable has been renamed to 'xdigit'.
5458 */
5459
5460 #ifndef grok_bin
5461 #if defined(NEED_grok_bin)
5462 static UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5463 static
5464 #else
5465 extern UV DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5466 #endif
5467
5468 #ifdef grok_bin
5469 # undef grok_bin
5470 #endif
5471 #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
5472 #define Perl_grok_bin DPPP_(my_grok_bin)
5473
5474 #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
5475 UV
DPPP_(my_grok_bin)5476 DPPP_(my_grok_bin)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
5477 {
5478 const char *s = start;
5479 STRLEN len = *len_p;
5480 UV value = 0;
5481 NV value_nv = 0;
5482
5483 const UV max_div_2 = UV_MAX / 2;
5484 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
5485 bool overflowed = FALSE;
5486
5487 if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
5488 /* strip off leading b or 0b.
5489 for compatibility silently suffer "b" and "0b" as valid binary
5490 numbers. */
5491 if (len >= 1) {
5492 if (s[0] == 'b') {
5493 s++;
5494 len--;
5495 }
5496 else if (len >= 2 && s[0] == '0' && s[1] == 'b') {
5497 s+=2;
5498 len-=2;
5499 }
5500 }
5501 }
5502
5503 for (; len-- && *s; s++) {
5504 char bit = *s;
5505 if (bit == '0' || bit == '1') {
5506 /* Write it in this wonky order with a goto to attempt to get the
5507 compiler to make the common case integer-only loop pretty tight.
5508 With gcc seems to be much straighter code than old scan_bin. */
5509 redo:
5510 if (!overflowed) {
5511 if (value <= max_div_2) {
5512 value = (value << 1) | (bit - '0');
5513 continue;
5514 }
5515 /* Bah. We're just overflowed. */
5516 warn("Integer overflow in binary number");
5517 overflowed = TRUE;
5518 value_nv = (NV) value;
5519 }
5520 value_nv *= 2.0;
5521 /* If an NV has not enough bits in its mantissa to
5522 * represent a UV this summing of small low-order numbers
5523 * is a waste of time (because the NV cannot preserve
5524 * the low-order bits anyway): we could just remember when
5525 * did we overflow and in the end just multiply value_nv by the
5526 * right amount. */
5527 value_nv += (NV)(bit - '0');
5528 continue;
5529 }
5530 if (bit == '_' && len && allow_underscores && (bit = s[1])
5531 && (bit == '0' || bit == '1'))
5532 {
5533 --len;
5534 ++s;
5535 goto redo;
5536 }
5537 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
5538 warn("Illegal binary digit '%c' ignored", *s);
5539 break;
5540 }
5541
5542 if ( ( overflowed && value_nv > 4294967295.0)
5543 #if UVSIZE > 4
5544 || (!overflowed && value > 0xffffffff )
5545 #endif
5546 ) {
5547 warn("Binary number > 0b11111111111111111111111111111111 non-portable");
5548 }
5549 *len_p = s - start;
5550 if (!overflowed) {
5551 *flags = 0;
5552 return value;
5553 }
5554 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
5555 if (result)
5556 *result = value_nv;
5557 return UV_MAX;
5558 }
5559 #endif
5560 #endif
5561
5562 #ifndef grok_hex
5563 #if defined(NEED_grok_hex)
5564 static UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5565 static
5566 #else
5567 extern UV DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5568 #endif
5569
5570 #ifdef grok_hex
5571 # undef grok_hex
5572 #endif
5573 #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
5574 #define Perl_grok_hex DPPP_(my_grok_hex)
5575
5576 #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
5577 UV
DPPP_(my_grok_hex)5578 DPPP_(my_grok_hex)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
5579 {
5580 const char *s = start;
5581 STRLEN len = *len_p;
5582 UV value = 0;
5583 NV value_nv = 0;
5584
5585 const UV max_div_16 = UV_MAX / 16;
5586 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
5587 bool overflowed = FALSE;
5588 const char *xdigit;
5589
5590 if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
5591 /* strip off leading x or 0x.
5592 for compatibility silently suffer "x" and "0x" as valid hex numbers.
5593 */
5594 if (len >= 1) {
5595 if (s[0] == 'x') {
5596 s++;
5597 len--;
5598 }
5599 else if (len >= 2 && s[0] == '0' && s[1] == 'x') {
5600 s+=2;
5601 len-=2;
5602 }
5603 }
5604 }
5605
5606 for (; len-- && *s; s++) {
5607 xdigit = strchr((char *) PL_hexdigit, *s);
5608 if (xdigit) {
5609 /* Write it in this wonky order with a goto to attempt to get the
5610 compiler to make the common case integer-only loop pretty tight.
5611 With gcc seems to be much straighter code than old scan_hex. */
5612 redo:
5613 if (!overflowed) {
5614 if (value <= max_div_16) {
5615 value = (value << 4) | ((xdigit - PL_hexdigit) & 15);
5616 continue;
5617 }
5618 warn("Integer overflow in hexadecimal number");
5619 overflowed = TRUE;
5620 value_nv = (NV) value;
5621 }
5622 value_nv *= 16.0;
5623 /* If an NV has not enough bits in its mantissa to
5624 * represent a UV this summing of small low-order numbers
5625 * is a waste of time (because the NV cannot preserve
5626 * the low-order bits anyway): we could just remember when
5627 * did we overflow and in the end just multiply value_nv by the
5628 * right amount of 16-tuples. */
5629 value_nv += (NV)((xdigit - PL_hexdigit) & 15);
5630 continue;
5631 }
5632 if (*s == '_' && len && allow_underscores && s[1]
5633 && (xdigit = strchr((char *) PL_hexdigit, s[1])))
5634 {
5635 --len;
5636 ++s;
5637 goto redo;
5638 }
5639 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
5640 warn("Illegal hexadecimal digit '%c' ignored", *s);
5641 break;
5642 }
5643
5644 if ( ( overflowed && value_nv > 4294967295.0)
5645 #if UVSIZE > 4
5646 || (!overflowed && value > 0xffffffff )
5647 #endif
5648 ) {
5649 warn("Hexadecimal number > 0xffffffff non-portable");
5650 }
5651 *len_p = s - start;
5652 if (!overflowed) {
5653 *flags = 0;
5654 return value;
5655 }
5656 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
5657 if (result)
5658 *result = value_nv;
5659 return UV_MAX;
5660 }
5661 #endif
5662 #endif
5663
5664 #ifndef grok_oct
5665 #if defined(NEED_grok_oct)
5666 static UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5667 static
5668 #else
5669 extern UV DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result);
5670 #endif
5671
5672 #ifdef grok_oct
5673 # undef grok_oct
5674 #endif
5675 #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
5676 #define Perl_grok_oct DPPP_(my_grok_oct)
5677
5678 #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
5679 UV
DPPP_(my_grok_oct)5680 DPPP_(my_grok_oct)(pTHX_ char *start, STRLEN *len_p, I32 *flags, NV *result)
5681 {
5682 const char *s = start;
5683 STRLEN len = *len_p;
5684 UV value = 0;
5685 NV value_nv = 0;
5686
5687 const UV max_div_8 = UV_MAX / 8;
5688 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
5689 bool overflowed = FALSE;
5690
5691 for (; len-- && *s; s++) {
5692 /* gcc 2.95 optimiser not smart enough to figure that this subtraction
5693 out front allows slicker code. */
5694 int digit = *s - '0';
5695 if (digit >= 0 && digit <= 7) {
5696 /* Write it in this wonky order with a goto to attempt to get the
5697 compiler to make the common case integer-only loop pretty tight.
5698 */
5699 redo:
5700 if (!overflowed) {
5701 if (value <= max_div_8) {
5702 value = (value << 3) | digit;
5703 continue;
5704 }
5705 /* Bah. We're just overflowed. */
5706 warn("Integer overflow in octal number");
5707 overflowed = TRUE;
5708 value_nv = (NV) value;
5709 }
5710 value_nv *= 8.0;
5711 /* If an NV has not enough bits in its mantissa to
5712 * represent a UV this summing of small low-order numbers
5713 * is a waste of time (because the NV cannot preserve
5714 * the low-order bits anyway): we could just remember when
5715 * did we overflow and in the end just multiply value_nv by the
5716 * right amount of 8-tuples. */
5717 value_nv += (NV)digit;
5718 continue;
5719 }
5720 if (digit == ('_' - '0') && len && allow_underscores
5721 && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
5722 {
5723 --len;
5724 ++s;
5725 goto redo;
5726 }
5727 /* Allow \octal to work the DWIM way (that is, stop scanning
5728 * as soon as non-octal characters are seen, complain only iff
5729 * someone seems to want to use the digits eight and nine). */
5730 if (digit == 8 || digit == 9) {
5731 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
5732 warn("Illegal octal digit '%c' ignored", *s);
5733 }
5734 break;
5735 }
5736
5737 if ( ( overflowed && value_nv > 4294967295.0)
5738 #if UVSIZE > 4
5739 || (!overflowed && value > 0xffffffff )
5740 #endif
5741 ) {
5742 warn("Octal number > 037777777777 non-portable");
5743 }
5744 *len_p = s - start;
5745 if (!overflowed) {
5746 *flags = 0;
5747 return value;
5748 }
5749 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
5750 if (result)
5751 *result = value_nv;
5752 return UV_MAX;
5753 }
5754 #endif
5755 #endif
5756
5757 #if !defined(my_snprintf)
5758 #if defined(NEED_my_snprintf)
5759 static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
5760 static
5761 #else
5762 extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
5763 #endif
5764
5765 #define my_snprintf DPPP_(my_my_snprintf)
5766 #define Perl_my_snprintf DPPP_(my_my_snprintf)
5767
5768 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
5769
5770 int
DPPP_(my_my_snprintf)5771 DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
5772 {
5773 dTHX;
5774 int retval;
5775 va_list ap;
5776 va_start(ap, format);
5777 #ifdef HAS_VSNPRINTF
5778 retval = vsnprintf(buffer, len, format, ap);
5779 #else
5780 retval = vsprintf(buffer, format, ap);
5781 #endif
5782 va_end(ap);
5783 if (retval >= (int)len)
5784 Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
5785 return retval;
5786 }
5787
5788 #endif
5789 #endif
5790
5791 #ifdef NO_XSLOCKS
5792 # ifdef dJMPENV
5793 # define dXCPT dJMPENV; int rEtV = 0
5794 # define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0)
5795 # define XCPT_TRY_END JMPENV_POP;
5796 # define XCPT_CATCH if (rEtV != 0)
5797 # define XCPT_RETHROW JMPENV_JUMP(rEtV)
5798 # else
5799 # define dXCPT Sigjmp_buf oldTOP; int rEtV = 0
5800 # define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)
5801 # define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf);
5802 # define XCPT_CATCH if (rEtV != 0)
5803 # define XCPT_RETHROW Siglongjmp(top_env, rEtV)
5804 # endif
5805 #endif
5806
5807 #if !defined(my_strlcat)
5808 #if defined(NEED_my_strlcat)
5809 static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
5810 static
5811 #else
5812 extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
5813 #endif
5814
5815 #define my_strlcat DPPP_(my_my_strlcat)
5816 #define Perl_my_strlcat DPPP_(my_my_strlcat)
5817
5818 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
5819
5820 Size_t
DPPP_(my_my_strlcat)5821 DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
5822 {
5823 Size_t used, length, copy;
5824
5825 used = strlen(dst);
5826 length = strlen(src);
5827 if (size > 0 && used < size - 1) {
5828 copy = (length >= size - used) ? size - used - 1 : length;
5829 memcpy(dst + used, src, copy);
5830 dst[used + copy] = '\0';
5831 }
5832 return used + length;
5833 }
5834 #endif
5835 #endif
5836
5837 #if !defined(my_strlcpy)
5838 #if defined(NEED_my_strlcpy)
5839 static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
5840 static
5841 #else
5842 extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
5843 #endif
5844
5845 #define my_strlcpy DPPP_(my_my_strlcpy)
5846 #define Perl_my_strlcpy DPPP_(my_my_strlcpy)
5847
5848 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
5849
5850 Size_t
DPPP_(my_my_strlcpy)5851 DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
5852 {
5853 Size_t length, copy;
5854
5855 length = strlen(src);
5856 if (size > 0) {
5857 copy = (length >= size) ? size - 1 : length;
5858 memcpy(dst, src, copy);
5859 dst[copy] = '\0';
5860 }
5861 return length;
5862 }
5863
5864 #endif
5865 #endif
5866
5867 #endif /* _P_P_PORTABILITY_H_ */
5868
5869 /* End of File ppport.h */
5870