1 #if 0
2 <<'SKIP';
3 #endif
4 /*
5 ----------------------------------------------------------------------
6
7 ppport.h -- Perl/Pollution/Portability Version 3.20_01
8
9 Automatically created by Devel::PPPort running under perl 5.016001.
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.20_01
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.11.5.
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. Note that this does not
82 automagially add a dot between the original filename and the
83 suffix. If you want the dot, you have to include it in the option
84 argument.
85
86 If neither C<--patch> or C<--copy> are given, the default is to
87 simply print the diffs for each file. This requires either
88 C<Text::Diff> or a C<diff> program to be installed.
89
90 =head2 --diff=I<program>
91
92 Manually set the diff program and options to use. The default
93 is to use C<Text::Diff>, when installed, and output unified
94 context diffs.
95
96 =head2 --compat-version=I<version>
97
98 Tell F<ppport.h> to check for compatibility with the given
99 Perl version. The default is to check for compatibility with Perl
100 version 5.003. You can use this option to reduce the output
101 of F<ppport.h> if you intend to be backward compatible only
102 down to a certain Perl version.
103
104 =head2 --cplusplus
105
106 Usually, F<ppport.h> will detect C++ style comments and
107 replace them with C style comments for portability reasons.
108 Using this option instructs F<ppport.h> to leave C++
109 comments untouched.
110
111 =head2 --quiet
112
113 Be quiet. Don't print anything except fatal errors.
114
115 =head2 --nodiag
116
117 Don't output any diagnostic messages. Only portability
118 alerts will be printed.
119
120 =head2 --nohints
121
122 Don't output any hints. Hints often contain useful portability
123 notes. Warnings will still be displayed.
124
125 =head2 --nochanges
126
127 Don't suggest any changes. Only give diagnostic output and hints
128 unless these are also deactivated.
129
130 =head2 --nofilter
131
132 Don't filter the list of input files. By default, files not looking
133 like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped.
134
135 =head2 --strip
136
137 Strip all script and documentation functionality from F<ppport.h>.
138 This reduces the size of F<ppport.h> dramatically and may be useful
139 if you want to include F<ppport.h> in smaller modules without
140 increasing their distribution size too much.
141
142 The stripped F<ppport.h> will have a C<--unstrip> option that allows
143 you to undo the stripping, but only if an appropriate C<Devel::PPPort>
144 module is installed.
145
146 =head2 --list-provided
147
148 Lists the API elements for which compatibility is provided by
149 F<ppport.h>. Also lists if it must be explicitly requested,
150 if it has dependencies, and if there are hints or warnings for it.
151
152 =head2 --list-unsupported
153
154 Lists the API elements that are known not to be supported by
155 F<ppport.h> and below which version of Perl they probably
156 won't be available or work.
157
158 =head2 --api-info=I<name>
159
160 Show portability information for API elements matching I<name>.
161 If I<name> is surrounded by slashes, it is interpreted as a regular
162 expression.
163
164 =head1 DESCRIPTION
165
166 In order for a Perl extension (XS) module to be as portable as possible
167 across differing versions of Perl itself, certain steps need to be taken.
168
169 =over 4
170
171 =item *
172
173 Including this header is the first major one. This alone will give you
174 access to a large part of the Perl API that hasn't been available in
175 earlier Perl releases. Use
176
177 perl ppport.h --list-provided
178
179 to see which API elements are provided by ppport.h.
180
181 =item *
182
183 You should avoid using deprecated parts of the API. For example, using
184 global Perl variables without the C<PL_> prefix is deprecated. Also,
185 some API functions used to have a C<perl_> prefix. Using this form is
186 also deprecated. You can safely use the supported API, as F<ppport.h>
187 will provide wrappers for older Perl versions.
188
189 =item *
190
191 If you use one of a few functions or variables that were not present in
192 earlier versions of Perl, and that can't be provided using a macro, you
193 have to explicitly request support for these functions by adding one or
194 more C<#define>s in your source code before the inclusion of F<ppport.h>.
195
196 These functions or variables will be marked C<explicit> in the list shown
197 by C<--list-provided>.
198
199 Depending on whether you module has a single or multiple files that
200 use such functions or variables, you want either C<static> or global
201 variants.
202
203 For a C<static> function or variable (used only in a single source
204 file), use:
205
206 #define NEED_function
207 #define NEED_variable
208
209 For a global function or variable (used in multiple source files),
210 use:
211
212 #define NEED_function_GLOBAL
213 #define NEED_variable_GLOBAL
214
215 Note that you mustn't have more than one global request for the
216 same function or variable in your project.
217
218 Function / Variable Static Request Global Request
219 -----------------------------------------------------------------------------------------
220 PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL
221 PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL
222 eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL
223 grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL
224 grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL
225 grok_number() NEED_grok_number NEED_grok_number_GLOBAL
226 grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL
227 grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL
228 load_module() NEED_load_module NEED_load_module_GLOBAL
229 my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL
230 my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL
231 my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL
232 my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL
233 newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL
234 newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL
235 newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL
236 newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL
237 newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL
238 pv_display() NEED_pv_display NEED_pv_display_GLOBAL
239 pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL
240 pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL
241 sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL
242 sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL
243 sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL
244 sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL
245 sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL
246 sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL
247 sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL
248 vload_module() NEED_vload_module NEED_vload_module_GLOBAL
249 vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL
250 warner() NEED_warner NEED_warner_GLOBAL
251
252 To avoid namespace conflicts, you can change the namespace of the
253 explicitly exported functions / variables using the C<DPPP_NAMESPACE>
254 macro. Just C<#define> the macro before including C<ppport.h>:
255
256 #define DPPP_NAMESPACE MyOwnNamespace_
257 #include "ppport.h"
258
259 The default namespace is C<DPPP_>.
260
261 =back
262
263 The good thing is that most of the above can be checked by running
264 F<ppport.h> on your source code. See the next section for
265 details.
266
267 =head1 EXAMPLES
268
269 To verify whether F<ppport.h> is needed for your module, whether you
270 should make any changes to your code, and whether any special defines
271 should be used, F<ppport.h> can be run as a Perl script to check your
272 source code. Simply say:
273
274 perl ppport.h
275
276 The result will usually be a list of patches suggesting changes
277 that should at least be acceptable, if not necessarily the most
278 efficient solution, or a fix for all possible problems.
279
280 If you know that your XS module uses features only available in
281 newer Perl releases, if you're aware that it uses C++ comments,
282 and if you want all suggestions as a single patch file, you could
283 use something like this:
284
285 perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff
286
287 If you only want your code to be scanned without any suggestions
288 for changes, use:
289
290 perl ppport.h --nochanges
291
292 You can specify a different C<diff> program or options, using
293 the C<--diff> option:
294
295 perl ppport.h --diff='diff -C 10'
296
297 This would output context diffs with 10 lines of context.
298
299 If you want to create patched copies of your files instead, use:
300
301 perl ppport.h --copy=.new
302
303 To display portability information for the C<newSVpvn> function,
304 use:
305
306 perl ppport.h --api-info=newSVpvn
307
308 Since the argument to C<--api-info> can be a regular expression,
309 you can use
310
311 perl ppport.h --api-info=/_nomg$/
312
313 to display portability information for all C<_nomg> functions or
314
315 perl ppport.h --api-info=/./
316
317 to display information for all known API elements.
318
319 =head1 BUGS
320
321 If this version of F<ppport.h> is causing failure during
322 the compilation of this module, please check if newer versions
323 of either this module or C<Devel::PPPort> are available on CPAN
324 before sending a bug report.
325
326 If F<ppport.h> was generated using the latest version of
327 C<Devel::PPPort> and is causing failure of this module, please
328 file a bug report using the CPAN Request Tracker at L<http://rt.cpan.org/>.
329
330 Please include the following information:
331
332 =over 4
333
334 =item 1.
335
336 The complete output from running "perl -V"
337
338 =item 2.
339
340 This file.
341
342 =item 3.
343
344 The name and version of the module you were trying to build.
345
346 =item 4.
347
348 A full log of the build that failed.
349
350 =item 5.
351
352 Any other information that you think could be relevant.
353
354 =back
355
356 For the latest version of this code, please get the C<Devel::PPPort>
357 module from CPAN.
358
359 =head1 COPYRIGHT
360
361 Version 3.x, Copyright (c) 2004-2012, Marcus Holland-Moritz.
362
363 Version 2.x, Copyright (C) 2001, Paul Marquess.
364
365 Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
366
367 This program is free software; you can redistribute it and/or
368 modify it under the same terms as Perl itself.
369
370 =head1 SEE ALSO
371
372 See L<Devel::PPPort>.
373
374 =cut
375
376 use strict;
377
378 # Disable broken TRIE-optimization
379 BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
380
381 my $VERSION = 3.20_01;
382
383 my %opt = (
384 quiet => 0,
385 diag => 1,
386 hints => 1,
387 changes => 1,
388 cplusplus => 0,
389 filter => 1,
390 strip => 0,
391 version => 0,
392 );
393
394 my($ppport) = $0 =~ /([\w.]+)$/;
395 my $LF = '(?:\r\n|[\r\n])'; # line feed
396 my $HS = "[ \t]"; # horizontal whitespace
397
398 # Never use C comments in this file!
399 my $ccs = '/'.'*';
400 my $cce = '*'.'/';
401 my $rccs = quotemeta $ccs;
402 my $rcce = quotemeta $cce;
403
404 eval {
405 require Getopt::Long;
406 Getopt::Long::GetOptions(\%opt, qw(
407 help quiet diag! filter! hints! changes! cplusplus strip version
408 patch=s copy=s diff=s compat-version=s
409 list-provided list-unsupported api-info=s
410 )) or usage();
411 };
412
413 if ($@ and grep /^-/, @ARGV) {
414 usage() if "@ARGV" =~ /^--?h(?:elp)?$/;
415 die "Getopt::Long not found. Please don't use any options.\n";
416 }
417
418 if ($opt{version}) {
419 print "This is $0 $VERSION.\n";
420 exit 0;
421 }
422
423 usage() if $opt{help};
424 strip() if $opt{strip};
425
426 if (exists $opt{'compat-version'}) {
427 my($r,$v,$s) = eval { parse_version($opt{'compat-version'}) };
428 if ($@) {
429 die "Invalid version number format: '$opt{'compat-version'}'\n";
430 }
431 die "Only Perl 5 is supported\n" if $r != 5;
432 die "Invalid version number: $opt{'compat-version'}\n" if $v >= 1000 || $s >= 1000;
433 $opt{'compat-version'} = sprintf "%d.%03d%03d", $r, $v, $s;
434 }
435 else {
436 $opt{'compat-version'} = 5;
437 }
438
439 my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/
440 ? ( $1 => {
441 ($2 ? ( base => $2 ) : ()),
442 ($3 ? ( todo => $3 ) : ()),
443 (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()),
444 (index($4, 'p') >= 0 ? ( provided => 1 ) : ()),
445 (index($4, 'n') >= 0 ? ( nothxarg => 1 ) : ()),
446 } )
447 : die "invalid spec: $_" } qw(
448 AvFILLp|5.004050||p
449 AvFILL|||
450 BhkDISABLE||5.017004|
451 BhkENABLE||5.017004|
452 BhkENTRY_set||5.017004|
453 BhkENTRY|||
454 BhkFLAGS|||
455 CALL_BLOCK_HOOKS|||
456 CLASS|||n
457 CPERLscope|5.005000||p
458 CX_CURPAD_SAVE|||
459 CX_CURPAD_SV|||
460 CopFILEAV|5.006000||p
461 CopFILEGV_set|5.006000||p
462 CopFILEGV|5.006000||p
463 CopFILESV|5.006000||p
464 CopFILE_set|5.006000||p
465 CopFILE|5.006000||p
466 CopSTASHPV_set|5.006000||p
467 CopSTASHPV|5.006000||p
468 CopSTASH_eq|5.006000||p
469 CopSTASH_set|5.006000||p
470 CopSTASH|5.006000||p
471 CopyD|5.009002|5.004050|p
472 Copy|||
473 CvPADLIST||5.008001|
474 CvSTASH|||
475 CvWEAKOUTSIDE|||
476 DEFSV_set|5.010001||p
477 DEFSV|5.004050||p
478 END_EXTERN_C|5.005000||p
479 ENTER|||
480 ERRSV|5.004050||p
481 EXTEND|||
482 EXTERN_C|5.005000||p
483 F0convert|||n
484 FREETMPS|||
485 GIMME_V||5.004000|n
486 GIMME|||n
487 GROK_NUMERIC_RADIX|5.007002||p
488 G_ARRAY|||
489 G_DISCARD|||
490 G_EVAL|||
491 G_METHOD|5.006001||p
492 G_NOARGS|||
493 G_SCALAR|||
494 G_VOID||5.004000|
495 GetVars|||
496 GvAV|||
497 GvCV|||
498 GvHV|||
499 GvSVn|5.009003||p
500 GvSV|||
501 Gv_AMupdate||5.011000|
502 HEf_SVKEY||5.004000|
503 HeHASH||5.004000|
504 HeKEY||5.004000|
505 HeKLEN||5.004000|
506 HePV||5.004000|
507 HeSVKEY_force||5.004000|
508 HeSVKEY_set||5.004000|
509 HeSVKEY||5.004000|
510 HeUTF8||5.010001|
511 HeVAL||5.004000|
512 HvENAMELEN||5.015004|
513 HvENAMEUTF8||5.015004|
514 HvENAME||5.013007|
515 HvNAMELEN_get|5.009003||p
516 HvNAMELEN||5.015004|
517 HvNAMEUTF8||5.015004|
518 HvNAME_get|5.009003||p
519 HvNAME|||
520 INT2PTR|5.006000||p
521 IN_LOCALE_COMPILETIME|5.007002||p
522 IN_LOCALE_RUNTIME|5.007002||p
523 IN_LOCALE|5.007002||p
524 IN_PERL_COMPILETIME|5.008001||p
525 IS_NUMBER_GREATER_THAN_UV_MAX|5.007002||p
526 IS_NUMBER_INFINITY|5.007002||p
527 IS_NUMBER_IN_UV|5.007002||p
528 IS_NUMBER_NAN|5.007003||p
529 IS_NUMBER_NEG|5.007002||p
530 IS_NUMBER_NOT_INT|5.007002||p
531 IVSIZE|5.006000||p
532 IVTYPE|5.006000||p
533 IVdf|5.006000||p
534 LEAVE|||
535 LINKLIST||5.013006|
536 LVRET|||
537 MARK|||
538 MULTICALL||5.017004|
539 MY_CXT_CLONE|5.009002||p
540 MY_CXT_INIT|5.007003||p
541 MY_CXT|5.007003||p
542 MoveD|5.009002|5.004050|p
543 Move|||
544 NOOP|5.005000||p
545 NUM2PTR|5.006000||p
546 NVTYPE|5.006000||p
547 NVef|5.006001||p
548 NVff|5.006001||p
549 NVgf|5.006001||p
550 Newxc|5.009003||p
551 Newxz|5.009003||p
552 Newx|5.009003||p
553 Nullav|||
554 Nullch|||
555 Nullcv|||
556 Nullhv|||
557 Nullsv|||
558 OP_CLASS||5.013007|
559 OP_DESC||5.007003|
560 OP_NAME||5.007003|
561 ORIGMARK|||
562 PAD_BASE_SV|||
563 PAD_CLONE_VARS|||
564 PAD_COMPNAME_FLAGS|||
565 PAD_COMPNAME_GEN_set|||
566 PAD_COMPNAME_GEN|||
567 PAD_COMPNAME_OURSTASH|||
568 PAD_COMPNAME_PV|||
569 PAD_COMPNAME_TYPE|||
570 PAD_RESTORE_LOCAL|||
571 PAD_SAVE_LOCAL|||
572 PAD_SAVE_SETNULLPAD|||
573 PAD_SETSV|||
574 PAD_SET_CUR_NOSAVE|||
575 PAD_SET_CUR|||
576 PAD_SVl|||
577 PAD_SV|||
578 PERLIO_FUNCS_CAST|5.009003||p
579 PERLIO_FUNCS_DECL|5.009003||p
580 PERL_ABS|5.008001||p
581 PERL_BCDVERSION|5.017004||p
582 PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||p
583 PERL_HASH|5.004000||p
584 PERL_INT_MAX|5.004000||p
585 PERL_INT_MIN|5.004000||p
586 PERL_LONG_MAX|5.004000||p
587 PERL_LONG_MIN|5.004000||p
588 PERL_MAGIC_arylen|5.007002||p
589 PERL_MAGIC_backref|5.007002||p
590 PERL_MAGIC_bm|5.007002||p
591 PERL_MAGIC_collxfrm|5.007002||p
592 PERL_MAGIC_dbfile|5.007002||p
593 PERL_MAGIC_dbline|5.007002||p
594 PERL_MAGIC_defelem|5.007002||p
595 PERL_MAGIC_envelem|5.007002||p
596 PERL_MAGIC_env|5.007002||p
597 PERL_MAGIC_ext|5.007002||p
598 PERL_MAGIC_fm|5.007002||p
599 PERL_MAGIC_glob|5.017004||p
600 PERL_MAGIC_isaelem|5.007002||p
601 PERL_MAGIC_isa|5.007002||p
602 PERL_MAGIC_mutex|5.017004||p
603 PERL_MAGIC_nkeys|5.007002||p
604 PERL_MAGIC_overload_elem|5.017004||p
605 PERL_MAGIC_overload_table|5.007002||p
606 PERL_MAGIC_overload|5.017004||p
607 PERL_MAGIC_pos|5.007002||p
608 PERL_MAGIC_qr|5.007002||p
609 PERL_MAGIC_regdata|5.007002||p
610 PERL_MAGIC_regdatum|5.007002||p
611 PERL_MAGIC_regex_global|5.007002||p
612 PERL_MAGIC_shared_scalar|5.007003||p
613 PERL_MAGIC_shared|5.007003||p
614 PERL_MAGIC_sigelem|5.007002||p
615 PERL_MAGIC_sig|5.007002||p
616 PERL_MAGIC_substr|5.007002||p
617 PERL_MAGIC_sv|5.007002||p
618 PERL_MAGIC_taint|5.007002||p
619 PERL_MAGIC_tiedelem|5.007002||p
620 PERL_MAGIC_tiedscalar|5.007002||p
621 PERL_MAGIC_tied|5.007002||p
622 PERL_MAGIC_utf8|5.008001||p
623 PERL_MAGIC_uvar_elem|5.007003||p
624 PERL_MAGIC_uvar|5.007002||p
625 PERL_MAGIC_vec|5.007002||p
626 PERL_MAGIC_vstring|5.008001||p
627 PERL_PV_ESCAPE_ALL|5.009004||p
628 PERL_PV_ESCAPE_FIRSTCHAR|5.009004||p
629 PERL_PV_ESCAPE_NOBACKSLASH|5.009004||p
630 PERL_PV_ESCAPE_NOCLEAR|5.009004||p
631 PERL_PV_ESCAPE_QUOTE|5.009004||p
632 PERL_PV_ESCAPE_RE|5.009005||p
633 PERL_PV_ESCAPE_UNI_DETECT|5.009004||p
634 PERL_PV_ESCAPE_UNI|5.009004||p
635 PERL_PV_PRETTY_DUMP|5.009004||p
636 PERL_PV_PRETTY_ELLIPSES|5.010000||p
637 PERL_PV_PRETTY_LTGT|5.009004||p
638 PERL_PV_PRETTY_NOCLEAR|5.010000||p
639 PERL_PV_PRETTY_QUOTE|5.009004||p
640 PERL_PV_PRETTY_REGPROP|5.009004||p
641 PERL_QUAD_MAX|5.004000||p
642 PERL_QUAD_MIN|5.004000||p
643 PERL_REVISION|5.006000||p
644 PERL_SCAN_ALLOW_UNDERSCORES|5.007003||p
645 PERL_SCAN_DISALLOW_PREFIX|5.007003||p
646 PERL_SCAN_GREATER_THAN_UV_MAX|5.007003||p
647 PERL_SCAN_SILENT_ILLDIGIT|5.008001||p
648 PERL_SHORT_MAX|5.004000||p
649 PERL_SHORT_MIN|5.004000||p
650 PERL_SIGNALS_UNSAFE_FLAG|5.008001||p
651 PERL_SUBVERSION|5.006000||p
652 PERL_SYS_INIT3||5.006000|
653 PERL_SYS_INIT|||
654 PERL_SYS_TERM||5.017004|
655 PERL_UCHAR_MAX|5.004000||p
656 PERL_UCHAR_MIN|5.004000||p
657 PERL_UINT_MAX|5.004000||p
658 PERL_UINT_MIN|5.004000||p
659 PERL_ULONG_MAX|5.004000||p
660 PERL_ULONG_MIN|5.004000||p
661 PERL_UNUSED_ARG|5.009003||p
662 PERL_UNUSED_CONTEXT|5.009004||p
663 PERL_UNUSED_DECL|5.007002||p
664 PERL_UNUSED_VAR|5.007002||p
665 PERL_UQUAD_MAX|5.004000||p
666 PERL_UQUAD_MIN|5.004000||p
667 PERL_USE_GCC_BRACE_GROUPS|5.009004||p
668 PERL_USHORT_MAX|5.004000||p
669 PERL_USHORT_MIN|5.004000||p
670 PERL_VERSION|5.006000||p
671 PL_DBsignal|5.005000||p
672 PL_DBsingle|||pn
673 PL_DBsub|||pn
674 PL_DBtrace|||pn
675 PL_Sv|5.005000||p
676 PL_bufend|5.017004||p
677 PL_bufptr|5.017004||p
678 PL_check||5.006000|
679 PL_compiling|5.004050||p
680 PL_comppad_name||5.017004|
681 PL_comppad||5.008001|
682 PL_copline|5.017004||p
683 PL_curcop|5.004050||p
684 PL_curpad||5.005000|
685 PL_curstash|5.004050||p
686 PL_debstash|5.004050||p
687 PL_defgv|5.004050||p
688 PL_diehook|5.004050||p
689 PL_dirty|5.004050||p
690 PL_dowarn|||pn
691 PL_errgv|5.004050||p
692 PL_error_count|5.017004||p
693 PL_expect|5.017004||p
694 PL_hexdigit|5.005000||p
695 PL_hints|5.005000||p
696 PL_in_my_stash|5.017004||p
697 PL_in_my|5.017004||p
698 PL_keyword_plugin||5.011002|
699 PL_last_in_gv|||n
700 PL_laststatval|5.005000||p
701 PL_lex_state|5.017004||p
702 PL_lex_stuff|5.017004||p
703 PL_linestr|5.017004||p
704 PL_modglobal||5.005000|n
705 PL_na|5.004050||pn
706 PL_no_modify|5.006000||p
707 PL_ofsgv|||n
708 PL_opfreehook||5.011000|n
709 PL_parser|5.009005|5.009005|p
710 PL_peepp||5.007003|n
711 PL_perl_destruct_level|5.004050||p
712 PL_perldb|5.004050||p
713 PL_ppaddr|5.006000||p
714 PL_rpeepp||5.013005|n
715 PL_rsfp_filters|5.017004||p
716 PL_rsfp|5.017004||p
717 PL_rs|||n
718 PL_signals|5.008001||p
719 PL_stack_base|5.004050||p
720 PL_stack_sp|5.004050||p
721 PL_statcache|5.005000||p
722 PL_stdingv|5.004050||p
723 PL_sv_arenaroot|5.004050||p
724 PL_sv_no|5.004050||pn
725 PL_sv_undef|5.004050||pn
726 PL_sv_yes|5.004050||pn
727 PL_tainted|5.004050||p
728 PL_tainting|5.004050||p
729 PL_tokenbuf|5.017004||p
730 POP_MULTICALL||5.017004|
731 POPi|||n
732 POPl|||n
733 POPn|||n
734 POPpbytex||5.007001|n
735 POPpx||5.005030|n
736 POPp|||n
737 POPs|||n
738 PTR2IV|5.006000||p
739 PTR2NV|5.006000||p
740 PTR2UV|5.006000||p
741 PTR2nat|5.009003||p
742 PTR2ul|5.007001||p
743 PTRV|5.006000||p
744 PUSHMARK|||
745 PUSH_MULTICALL||5.017004|
746 PUSHi|||
747 PUSHmortal|5.009002||p
748 PUSHn|||
749 PUSHp|||
750 PUSHs|||
751 PUSHu|5.004000||p
752 PUTBACK|||
753 PadARRAY||5.017004|
754 PadMAX||5.017004|
755 PadlistARRAY||5.017004|
756 PadlistMAX||5.017004|
757 PadlistNAMESARRAY||5.017004|
758 PadlistNAMESMAX||5.017004|
759 PadlistNAMES||5.017004|
760 PadlistREFCNT||5.017004|
761 PadnameIsOUR|||
762 PadnameIsSTATE|||
763 PadnameLEN||5.017004|
764 PadnameOURSTASH|||
765 PadnameOUTER|||
766 PadnamePV||5.017004|
767 PadnameSV||5.017004|
768 PadnameTYPE|||
769 PadnameUTF8||5.017004|
770 PadnamelistARRAY||5.017004|
771 PadnamelistMAX||5.017004|
772 PerlIO_clearerr||5.007003|
773 PerlIO_close||5.007003|
774 PerlIO_context_layers||5.009004|
775 PerlIO_eof||5.007003|
776 PerlIO_error||5.007003|
777 PerlIO_fileno||5.007003|
778 PerlIO_fill||5.007003|
779 PerlIO_flush||5.007003|
780 PerlIO_get_base||5.007003|
781 PerlIO_get_bufsiz||5.007003|
782 PerlIO_get_cnt||5.007003|
783 PerlIO_get_ptr||5.007003|
784 PerlIO_read||5.007003|
785 PerlIO_seek||5.007003|
786 PerlIO_set_cnt||5.007003|
787 PerlIO_set_ptrcnt||5.007003|
788 PerlIO_setlinebuf||5.007003|
789 PerlIO_stderr||5.007003|
790 PerlIO_stdin||5.007003|
791 PerlIO_stdout||5.007003|
792 PerlIO_tell||5.007003|
793 PerlIO_unread||5.007003|
794 PerlIO_write||5.007003|
795 Perl_signbit||5.009005|n
796 PoisonFree|5.009004||p
797 PoisonNew|5.009004||p
798 PoisonWith|5.009004||p
799 Poison|5.008000||p
800 RETVAL|||n
801 Renewc|||
802 Renew|||
803 SAVECLEARSV|||
804 SAVECOMPPAD|||
805 SAVEPADSV|||
806 SAVETMPS|||
807 SAVE_DEFSV|5.004050||p
808 SPAGAIN|||
809 SP|||
810 START_EXTERN_C|5.005000||p
811 START_MY_CXT|5.007003||p
812 STMT_END|||p
813 STMT_START|||p
814 STR_WITH_LEN|5.009003||p
815 ST|||
816 SV_CONST_RETURN|5.009003||p
817 SV_COW_DROP_PV|5.008001||p
818 SV_COW_SHARED_HASH_KEYS|5.009005||p
819 SV_GMAGIC|5.007002||p
820 SV_HAS_TRAILING_NUL|5.009004||p
821 SV_IMMEDIATE_UNREF|5.007001||p
822 SV_MUTABLE_RETURN|5.009003||p
823 SV_NOSTEAL|5.009002||p
824 SV_SMAGIC|5.009003||p
825 SV_UTF8_NO_ENCODING|5.008001||p
826 SVfARG|5.009005||p
827 SVf_UTF8|5.006000||p
828 SVf|5.006000||p
829 SVt_IV|||
830 SVt_NV|||
831 SVt_PVAV|||
832 SVt_PVCV|||
833 SVt_PVHV|||
834 SVt_PVMG|||
835 SVt_PV|||
836 Safefree|||
837 Slab_Alloc|||
838 Slab_Free|||
839 Slab_to_ro|||
840 Slab_to_rw|||
841 StructCopy|||
842 SvCUR_set|||
843 SvCUR|||
844 SvEND|||
845 SvGAMAGIC||5.006001|
846 SvGETMAGIC|5.004050||p
847 SvGROW|||
848 SvIOK_UV||5.006000|
849 SvIOK_notUV||5.006000|
850 SvIOK_off|||
851 SvIOK_only_UV||5.006000|
852 SvIOK_only|||
853 SvIOK_on|||
854 SvIOKp|||
855 SvIOK|||
856 SvIVX|||
857 SvIV_nomg|5.009001||p
858 SvIV_set|||
859 SvIVx|||
860 SvIV|||
861 SvIsCOW_shared_hash||5.008003|
862 SvIsCOW||5.008003|
863 SvLEN_set|||
864 SvLEN|||
865 SvLOCK||5.007003|
866 SvMAGIC_set|5.009003||p
867 SvNIOK_off|||
868 SvNIOKp|||
869 SvNIOK|||
870 SvNOK_off|||
871 SvNOK_only|||
872 SvNOK_on|||
873 SvNOKp|||
874 SvNOK|||
875 SvNVX|||
876 SvNV_nomg||5.013002|
877 SvNV_set|||
878 SvNVx|||
879 SvNV|||
880 SvOK|||
881 SvOOK_offset||5.011000|
882 SvOOK|||
883 SvPOK_off|||
884 SvPOK_only_UTF8||5.006000|
885 SvPOK_only|||
886 SvPOK_on|||
887 SvPOKp|||
888 SvPOK|||
889 SvPVX_const|5.009003||p
890 SvPVX_mutable|5.009003||p
891 SvPVX|||
892 SvPV_const|5.009003||p
893 SvPV_flags_const_nolen|5.009003||p
894 SvPV_flags_const|5.009003||p
895 SvPV_flags_mutable|5.009003||p
896 SvPV_flags|5.007002||p
897 SvPV_force_flags_mutable|5.009003||p
898 SvPV_force_flags_nolen|5.009003||p
899 SvPV_force_flags|5.007002||p
900 SvPV_force_mutable|5.009003||p
901 SvPV_force_nolen|5.009003||p
902 SvPV_force_nomg_nolen|5.009003||p
903 SvPV_force_nomg|5.007002||p
904 SvPV_force|||p
905 SvPV_mutable|5.009003||p
906 SvPV_nolen_const|5.009003||p
907 SvPV_nolen|5.006000||p
908 SvPV_nomg_const_nolen|5.009003||p
909 SvPV_nomg_const|5.009003||p
910 SvPV_nomg_nolen|5.013007|5.013007|p
911 SvPV_nomg|5.007002||p
912 SvPV_renew|5.009003||p
913 SvPV_set|||
914 SvPVbyte_force||5.009002|
915 SvPVbyte_nolen||5.006000|
916 SvPVbytex_force||5.006000|
917 SvPVbytex||5.006000|
918 SvPVbyte|5.006000||p
919 SvPVutf8_force||5.006000|
920 SvPVutf8_nolen||5.006000|
921 SvPVutf8x_force||5.006000|
922 SvPVutf8x||5.006000|
923 SvPVutf8||5.006000|
924 SvPVx|||
925 SvPV|||
926 SvREFCNT_dec|||
927 SvREFCNT_inc_NN|5.009004||p
928 SvREFCNT_inc_simple_NN|5.009004||p
929 SvREFCNT_inc_simple_void_NN|5.009004||p
930 SvREFCNT_inc_simple_void|5.009004||p
931 SvREFCNT_inc_simple|5.009004||p
932 SvREFCNT_inc_void_NN|5.009004||p
933 SvREFCNT_inc_void|5.009004||p
934 SvREFCNT_inc|||p
935 SvREFCNT|||
936 SvROK_off|||
937 SvROK_on|||
938 SvROK|||
939 SvRV_set|5.009003||p
940 SvRV|||
941 SvRXOK||5.009005|
942 SvRX||5.009005|
943 SvSETMAGIC|||
944 SvSHARED_HASH|5.009003||p
945 SvSHARE||5.007003|
946 SvSTASH_set|5.009003||p
947 SvSTASH|||
948 SvSetMagicSV_nosteal||5.004000|
949 SvSetMagicSV||5.004000|
950 SvSetSV_nosteal||5.004000|
951 SvSetSV|||
952 SvTAINTED_off||5.004000|
953 SvTAINTED_on||5.004000|
954 SvTAINTED||5.004000|
955 SvTAINT|||
956 SvTHINKFIRST|||
957 SvTRUE_nomg||5.013006|
958 SvTRUE|||
959 SvTYPE|||
960 SvUNLOCK||5.007003|
961 SvUOK|5.007001|5.006000|p
962 SvUPGRADE|||
963 SvUTF8_off||5.006000|
964 SvUTF8_on||5.006000|
965 SvUTF8||5.006000|
966 SvUVXx|5.004000||p
967 SvUVX|5.004000||p
968 SvUV_nomg|5.009001||p
969 SvUV_set|5.009003||p
970 SvUVx|5.004000||p
971 SvUV|5.004000||p
972 SvVOK||5.008001|
973 SvVSTRING_mg|5.009004||p
974 THIS|||n
975 UNDERBAR|5.009002||p
976 UTF8_MAXBYTES|5.009002||p
977 UVSIZE|5.006000||p
978 UVTYPE|5.006000||p
979 UVXf|5.007001||p
980 UVof|5.006000||p
981 UVuf|5.006000||p
982 UVxf|5.006000||p
983 WARN_ALL|5.006000||p
984 WARN_AMBIGUOUS|5.006000||p
985 WARN_ASSERTIONS|5.017004||p
986 WARN_BAREWORD|5.006000||p
987 WARN_CLOSED|5.006000||p
988 WARN_CLOSURE|5.006000||p
989 WARN_DEBUGGING|5.006000||p
990 WARN_DEPRECATED|5.006000||p
991 WARN_DIGIT|5.006000||p
992 WARN_EXEC|5.006000||p
993 WARN_EXITING|5.006000||p
994 WARN_GLOB|5.006000||p
995 WARN_INPLACE|5.006000||p
996 WARN_INTERNAL|5.006000||p
997 WARN_IO|5.006000||p
998 WARN_LAYER|5.008000||p
999 WARN_MALLOC|5.006000||p
1000 WARN_MISC|5.006000||p
1001 WARN_NEWLINE|5.006000||p
1002 WARN_NUMERIC|5.006000||p
1003 WARN_ONCE|5.006000||p
1004 WARN_OVERFLOW|5.006000||p
1005 WARN_PACK|5.006000||p
1006 WARN_PARENTHESIS|5.006000||p
1007 WARN_PIPE|5.006000||p
1008 WARN_PORTABLE|5.006000||p
1009 WARN_PRECEDENCE|5.006000||p
1010 WARN_PRINTF|5.006000||p
1011 WARN_PROTOTYPE|5.006000||p
1012 WARN_QW|5.006000||p
1013 WARN_RECURSION|5.006000||p
1014 WARN_REDEFINE|5.006000||p
1015 WARN_REGEXP|5.006000||p
1016 WARN_RESERVED|5.006000||p
1017 WARN_SEMICOLON|5.006000||p
1018 WARN_SEVERE|5.006000||p
1019 WARN_SIGNAL|5.006000||p
1020 WARN_SUBSTR|5.006000||p
1021 WARN_SYNTAX|5.006000||p
1022 WARN_TAINT|5.006000||p
1023 WARN_THREADS|5.008000||p
1024 WARN_UNINITIALIZED|5.006000||p
1025 WARN_UNOPENED|5.006000||p
1026 WARN_UNPACK|5.006000||p
1027 WARN_UNTIE|5.006000||p
1028 WARN_UTF8|5.006000||p
1029 WARN_VOID|5.006000||p
1030 XCPT_CATCH|5.009002||p
1031 XCPT_RETHROW|5.009002||p
1032 XCPT_TRY_END|5.009002||p
1033 XCPT_TRY_START|5.009002||p
1034 XPUSHi|||
1035 XPUSHmortal|5.009002||p
1036 XPUSHn|||
1037 XPUSHp|||
1038 XPUSHs|||
1039 XPUSHu|5.004000||p
1040 XSPROTO|5.010000||p
1041 XSRETURN_EMPTY|||
1042 XSRETURN_IV|||
1043 XSRETURN_NO|||
1044 XSRETURN_NV|||
1045 XSRETURN_PV|||
1046 XSRETURN_UNDEF|||
1047 XSRETURN_UV|5.008001||p
1048 XSRETURN_YES|||
1049 XSRETURN|||p
1050 XST_mIV|||
1051 XST_mNO|||
1052 XST_mNV|||
1053 XST_mPV|||
1054 XST_mUNDEF|||
1055 XST_mUV|5.008001||p
1056 XST_mYES|||
1057 XS_APIVERSION_BOOTCHECK||5.013004|
1058 XS_EXTERNAL||5.017004|
1059 XS_INTERNAL||5.017004|
1060 XS_VERSION_BOOTCHECK|||
1061 XS_VERSION|||
1062 XSprePUSH|5.006000||p
1063 XS|||
1064 XopDISABLE||5.017004|
1065 XopENABLE||5.017004|
1066 XopENTRY_set||5.017004|
1067 XopENTRY||5.017004|
1068 XopFLAGS||5.013007|
1069 ZeroD|5.009002||p
1070 Zero|||
1071 _aMY_CXT|5.007003||p
1072 _add_range_to_invlist|||
1073 _append_range_to_invlist|||
1074 _core_swash_init|||
1075 _get_swash_invlist|||
1076 _invlist_array_init|||
1077 _invlist_contains_cp|||
1078 _invlist_contents|||
1079 _invlist_intersection_maybe_complement_2nd|||
1080 _invlist_intersection|||
1081 _invlist_invert_prop|||
1082 _invlist_invert|||
1083 _invlist_populate_swatch|||
1084 _invlist_search|||
1085 _invlist_subtract|||
1086 _invlist_union_maybe_complement_2nd|||
1087 _invlist_union|||
1088 _is_swash_user_defined|||
1089 _is_utf8__perl_idstart|||
1090 _is_utf8_quotemeta|||
1091 _new_invlist_C_array|||
1092 _new_invlist|||
1093 _pMY_CXT|5.007003||p
1094 _swash_inversion_hash|||
1095 _swash_to_invlist|||
1096 _to_fold_latin1|||
1097 _to_uni_fold_flags||5.013011|
1098 _to_upper_title_latin1|||
1099 _to_utf8_fold_flags||5.015006|
1100 _to_utf8_lower_flags||5.015006|
1101 _to_utf8_title_flags||5.015006|
1102 _to_utf8_upper_flags||5.015006|
1103 aMY_CXT_|5.007003||p
1104 aMY_CXT|5.007003||p
1105 aTHXR_|5.017004||p
1106 aTHXR|5.017004||p
1107 aTHX_|5.006000||p
1108 aTHX|5.006000||p
1109 aassign_common_vars|||
1110 add_alternate|||
1111 add_cp_to_invlist|||
1112 add_data|||n
1113 add_utf16_textfilter|||
1114 addmad|||
1115 adjust_stack_on_leave|||
1116 alloc_maybe_populate_EXACT|||
1117 alloccopstash|||
1118 allocmy|||
1119 amagic_call|||
1120 amagic_cmp_locale|||
1121 amagic_cmp|||
1122 amagic_deref_call||5.013007|
1123 amagic_i_ncmp|||
1124 amagic_is_enabled|||
1125 amagic_ncmp|||
1126 anonymise_cv_maybe|||
1127 any_dup|||
1128 ao|||
1129 append_madprops|||
1130 apply_attrs_my|||
1131 apply_attrs_string||5.006001|
1132 apply_attrs|||
1133 apply|||
1134 assert_uft8_cache_coherent|||
1135 atfork_lock||5.007003|n
1136 atfork_unlock||5.007003|n
1137 av_arylen_p||5.009003|
1138 av_clear|||
1139 av_create_and_push||5.009005|
1140 av_create_and_unshift_one||5.009005|
1141 av_delete||5.006000|
1142 av_exists||5.006000|
1143 av_extend_guts|||
1144 av_extend|||
1145 av_fetch|||
1146 av_fill|||
1147 av_iter_p||5.011000|
1148 av_len|||
1149 av_make|||
1150 av_pop|||
1151 av_push|||
1152 av_reify|||
1153 av_shift|||
1154 av_store|||
1155 av_undef|||
1156 av_unshift|||
1157 ax|||n
1158 bad_type_pv|||
1159 bad_type_sv|||
1160 bind_match|||
1161 block_end|||
1162 block_gimme||5.004000|
1163 block_start|||
1164 blockhook_register||5.013003|
1165 boolSV|5.004000||p
1166 boot_core_PerlIO|||
1167 boot_core_UNIVERSAL|||
1168 boot_core_mro|||
1169 bytes_cmp_utf8||5.013007|
1170 bytes_from_utf8||5.007001|
1171 bytes_to_uni|||n
1172 bytes_to_utf8||5.006001|
1173 call_argv|5.006000||p
1174 call_atexit||5.006000|
1175 call_list||5.004000|
1176 call_method|5.006000||p
1177 call_pv|5.006000||p
1178 call_sv|5.006000||p
1179 caller_cx||5.013005|
1180 calloc||5.007002|n
1181 cando|||
1182 cast_i32||5.006000|
1183 cast_iv||5.006000|
1184 cast_ulong||5.006000|
1185 cast_uv||5.006000|
1186 check_locale_boundary_crossing|||
1187 check_type_and_open|||
1188 check_uni|||
1189 check_utf8_print|||
1190 checkcomma|||
1191 checkposixcc|||
1192 ckWARN|5.006000||p
1193 ck_entersub_args_core|||
1194 ck_entersub_args_list||5.013006|
1195 ck_entersub_args_proto_or_list||5.013006|
1196 ck_entersub_args_proto||5.013006|
1197 ck_warner_d||5.011001|v
1198 ck_warner||5.011001|v
1199 ckwarn_common|||
1200 ckwarn_d||5.009003|
1201 ckwarn||5.009003|
1202 cl_and|||n
1203 cl_anything|||n
1204 cl_init|||n
1205 cl_is_anything|||n
1206 cl_or|||n
1207 clear_placeholders|||
1208 clone_params_del|||n
1209 clone_params_new|||n
1210 closest_cop|||
1211 compute_EXACTish|||
1212 convert|||
1213 cop_fetch_label||5.015001|
1214 cop_free|||
1215 cop_hints_2hv||5.013007|
1216 cop_hints_fetch_pvn||5.013007|
1217 cop_hints_fetch_pvs||5.013007|
1218 cop_hints_fetch_pv||5.013007|
1219 cop_hints_fetch_sv||5.013007|
1220 cop_store_label||5.015001|
1221 cophh_2hv||5.013007|
1222 cophh_copy||5.013007|
1223 cophh_delete_pvn||5.013007|
1224 cophh_delete_pvs||5.013007|
1225 cophh_delete_pv||5.013007|
1226 cophh_delete_sv||5.013007|
1227 cophh_fetch_pvn||5.013007|
1228 cophh_fetch_pvs||5.013007|
1229 cophh_fetch_pv||5.013007|
1230 cophh_fetch_sv||5.013007|
1231 cophh_free||5.013007|
1232 cophh_new_empty||5.017004|
1233 cophh_store_pvn||5.013007|
1234 cophh_store_pvs||5.013007|
1235 cophh_store_pv||5.013007|
1236 cophh_store_sv||5.013007|
1237 core_prototype|||
1238 core_regclass_swash|||
1239 coresub_op|||
1240 cr_textfilter|||
1241 create_eval_scope|||
1242 croak_no_modify||5.013003|
1243 croak_nocontext|||vn
1244 croak_sv||5.013001|
1245 croak_xs_usage||5.010001|
1246 croak|||v
1247 csighandler||5.009003|n
1248 curmad|||
1249 current_re_engine|||
1250 curse|||
1251 custom_op_desc||5.007003|
1252 custom_op_name||5.007003|
1253 custom_op_register||5.013007|
1254 custom_op_xop||5.013007|
1255 cv_ckproto_len_flags|||
1256 cv_clone|||
1257 cv_const_sv||5.004000|
1258 cv_dump|||
1259 cv_forget_slab|||
1260 cv_get_call_checker||5.013006|
1261 cv_set_call_checker||5.013006|
1262 cv_undef|||
1263 cvgv_set|||
1264 cvstash_set|||
1265 cx_dump||5.005000|
1266 cx_dup|||
1267 cxinc|||
1268 dAXMARK|5.009003||p
1269 dAX|5.007002||p
1270 dITEMS|5.007002||p
1271 dMARK|||
1272 dMULTICALL||5.009003|
1273 dMY_CXT_SV|5.007003||p
1274 dMY_CXT|5.007003||p
1275 dNOOP|5.006000||p
1276 dORIGMARK|||
1277 dSP|||
1278 dTHR|5.004050||p
1279 dTHXR|5.017004||p
1280 dTHXa|5.006000||p
1281 dTHXoa|5.006000||p
1282 dTHX|5.006000||p
1283 dUNDERBAR|5.009002||p
1284 dVAR|5.009003||p
1285 dXCPT|5.009002||p
1286 dXSARGS|||
1287 dXSI32|||
1288 dXSTARG|5.006000||p
1289 deb_curcv|||
1290 deb_nocontext|||vn
1291 deb_stack_all|||
1292 deb_stack_n|||
1293 debop||5.005000|
1294 debprofdump||5.005000|
1295 debprof|||
1296 debstackptrs||5.007003|
1297 debstack||5.007003|
1298 debug_start_match|||
1299 deb||5.007003|v
1300 del_sv|||
1301 delete_eval_scope|||
1302 delimcpy||5.004000|n
1303 deprecate_commaless_var_list|||
1304 despatch_signals||5.007001|
1305 destroy_matcher|||
1306 die_nocontext|||vn
1307 die_sv||5.013001|
1308 die_unwind|||
1309 die|||v
1310 dirp_dup|||
1311 div128|||
1312 djSP|||
1313 do_aexec5|||
1314 do_aexec|||
1315 do_aspawn|||
1316 do_binmode||5.004050|
1317 do_chomp|||
1318 do_close|||
1319 do_delete_local|||
1320 do_dump_pad|||
1321 do_eof|||
1322 do_exec3|||
1323 do_execfree|||
1324 do_exec|||
1325 do_gv_dump||5.006000|
1326 do_gvgv_dump||5.006000|
1327 do_hv_dump||5.006000|
1328 do_ipcctl|||
1329 do_ipcget|||
1330 do_join|||
1331 do_magic_dump||5.006000|
1332 do_msgrcv|||
1333 do_msgsnd|||
1334 do_ncmp|||
1335 do_oddball|||
1336 do_op_dump||5.006000|
1337 do_op_xmldump|||
1338 do_open9||5.006000|
1339 do_openn||5.007001|
1340 do_open||5.004000|
1341 do_pmop_dump||5.006000|
1342 do_pmop_xmldump|||
1343 do_print|||
1344 do_readline|||
1345 do_seek|||
1346 do_semop|||
1347 do_shmio|||
1348 do_smartmatch|||
1349 do_spawn_nowait|||
1350 do_spawn|||
1351 do_sprintf|||
1352 do_sv_dump||5.006000|
1353 do_sysseek|||
1354 do_tell|||
1355 do_trans_complex_utf8|||
1356 do_trans_complex|||
1357 do_trans_count_utf8|||
1358 do_trans_count|||
1359 do_trans_simple_utf8|||
1360 do_trans_simple|||
1361 do_trans|||
1362 do_vecget|||
1363 do_vecset|||
1364 do_vop|||
1365 docatch|||
1366 doeval|||
1367 dofile|||
1368 dofindlabel|||
1369 doform|||
1370 doing_taint||5.008001|n
1371 dooneliner|||
1372 doopen_pm|||
1373 doparseform|||
1374 dopoptoeval|||
1375 dopoptogiven|||
1376 dopoptolabel|||
1377 dopoptoloop|||
1378 dopoptosub_at|||
1379 dopoptowhen|||
1380 doref||5.009003|
1381 dounwind|||
1382 dowantarray|||
1383 dump_all_perl|||
1384 dump_all||5.006000|
1385 dump_eval||5.006000|
1386 dump_exec_pos|||
1387 dump_fds|||
1388 dump_form||5.006000|
1389 dump_indent||5.006000|v
1390 dump_mstats|||
1391 dump_packsubs_perl|||
1392 dump_packsubs||5.006000|
1393 dump_sub_perl|||
1394 dump_sub||5.006000|
1395 dump_sv_child|||
1396 dump_trie_interim_list|||
1397 dump_trie_interim_table|||
1398 dump_trie|||
1399 dump_vindent||5.006000|
1400 dumpuntil|||
1401 dup_attrlist|||
1402 emulate_cop_io|||
1403 eval_pv|5.006000||p
1404 eval_sv|5.006000||p
1405 exec_failed|||
1406 expect_number|||
1407 fbm_compile||5.005000|
1408 fbm_instr||5.005000|
1409 feature_is_enabled|||
1410 filter_add|||
1411 filter_del|||
1412 filter_gets|||
1413 filter_read|||
1414 finalize_optree|||
1415 finalize_op|||
1416 find_and_forget_pmops|||
1417 find_array_subscript|||
1418 find_beginning|||
1419 find_byclass|||
1420 find_hash_subscript|||
1421 find_in_my_stash|||
1422 find_runcv_where|||
1423 find_runcv||5.008001|
1424 find_rundefsv2|||
1425 find_rundefsvoffset||5.009002|
1426 find_rundefsv||5.013002|
1427 find_script|||
1428 find_uninit_var|||
1429 first_symbol|||n
1430 foldEQ_latin1||5.013008|n
1431 foldEQ_locale||5.013002|n
1432 foldEQ_utf8_flags||5.013010|
1433 foldEQ_utf8||5.013002|
1434 foldEQ||5.013002|n
1435 fold_constants|||
1436 forbid_setid|||
1437 force_ident|||
1438 force_list|||
1439 force_next|||
1440 force_strict_version|||
1441 force_version|||
1442 force_word|||
1443 forget_pmop|||
1444 form_nocontext|||vn
1445 form||5.004000|v
1446 fp_dup|||
1447 fprintf_nocontext|||vn
1448 free_global_struct|||
1449 free_tied_hv_pool|||
1450 free_tmps|||
1451 gen_constant_list|||
1452 get_aux_mg|||
1453 get_av|5.006000||p
1454 get_context||5.006000|n
1455 get_cvn_flags|5.009005||p
1456 get_cvs|5.011000||p
1457 get_cv|5.006000||p
1458 get_db_sub|||
1459 get_debug_opts|||
1460 get_hash_seed|||
1461 get_hv|5.006000||p
1462 get_invlist_iter_addr|||
1463 get_invlist_len_addr|||
1464 get_invlist_version_id_addr|||
1465 get_invlist_zero_addr|||
1466 get_mstats|||
1467 get_no_modify|||
1468 get_num|||
1469 get_op_descs||5.005000|
1470 get_op_names||5.005000|
1471 get_opargs|||
1472 get_ppaddr||5.006000|
1473 get_re_arg|||
1474 get_sv|5.006000||p
1475 get_vtbl||5.005030|
1476 getcwd_sv||5.007002|
1477 getenv_len|||
1478 glob_2number|||
1479 glob_assign_glob|||
1480 glob_assign_ref|||
1481 gp_dup|||
1482 gp_free|||
1483 gp_ref|||
1484 grok_bin|5.007003||p
1485 grok_bslash_N|||
1486 grok_bslash_c|||
1487 grok_bslash_o|||
1488 grok_bslash_x|||
1489 grok_hex|5.007003||p
1490 grok_number|5.007002||p
1491 grok_numeric_radix|5.007002||p
1492 grok_oct|5.007003||p
1493 group_end|||
1494 gv_AVadd|||
1495 gv_HVadd|||
1496 gv_IOadd|||
1497 gv_SVadd|||
1498 gv_add_by_type||5.011000|
1499 gv_autoload4||5.004000|
1500 gv_autoload_pvn||5.015004|
1501 gv_autoload_pv||5.015004|
1502 gv_autoload_sv||5.015004|
1503 gv_check|||
1504 gv_const_sv||5.009003|
1505 gv_dump||5.006000|
1506 gv_efullname3||5.004000|
1507 gv_efullname4||5.006001|
1508 gv_efullname|||
1509 gv_ename|||
1510 gv_fetchfile_flags||5.009005|
1511 gv_fetchfile|||
1512 gv_fetchmeth_autoload||5.007003|
1513 gv_fetchmeth_pv_autoload||5.015004|
1514 gv_fetchmeth_pvn_autoload||5.015004|
1515 gv_fetchmeth_pvn||5.015004|
1516 gv_fetchmeth_pv||5.015004|
1517 gv_fetchmeth_sv_autoload||5.015004|
1518 gv_fetchmeth_sv||5.015004|
1519 gv_fetchmethod_autoload||5.004000|
1520 gv_fetchmethod_pv_flags||5.015004|
1521 gv_fetchmethod_pvn_flags||5.015004|
1522 gv_fetchmethod_sv_flags||5.015004|
1523 gv_fetchmethod|||
1524 gv_fetchmeth|||
1525 gv_fetchpvn_flags|5.009002||p
1526 gv_fetchpvs|5.009004||p
1527 gv_fetchpv|||
1528 gv_fetchsv|5.009002||p
1529 gv_fullname3||5.004000|
1530 gv_fullname4||5.006001|
1531 gv_fullname|||
1532 gv_get_super_pkg|||
1533 gv_handler||5.007001|
1534 gv_init_pvn||5.015004|
1535 gv_init_pv||5.015004|
1536 gv_init_svtype|||
1537 gv_init_sv||5.015004|
1538 gv_init|||
1539 gv_magicalize_isa|||
1540 gv_name_set||5.009004|
1541 gv_stashpvn|5.004000||p
1542 gv_stashpvs|5.009003||p
1543 gv_stashpv|||
1544 gv_stashsv|||
1545 gv_try_downgrade|||
1546 he_dup|||
1547 hek_dup|||
1548 hfree_next_entry|||
1549 hfreeentries|||
1550 hsplit|||
1551 hv_assert|||
1552 hv_auxinit|||n
1553 hv_backreferences_p|||
1554 hv_clear_placeholders||5.009001|
1555 hv_clear|||
1556 hv_common_key_len||5.010000|
1557 hv_common||5.010000|
1558 hv_copy_hints_hv||5.009004|
1559 hv_delayfree_ent||5.004000|
1560 hv_delete_common|||
1561 hv_delete_ent||5.004000|
1562 hv_delete|||
1563 hv_eiter_p||5.009003|
1564 hv_eiter_set||5.009003|
1565 hv_ename_add|||
1566 hv_ename_delete|||
1567 hv_exists_ent||5.004000|
1568 hv_exists|||
1569 hv_fetch_ent||5.004000|
1570 hv_fetchs|5.009003||p
1571 hv_fetch|||
1572 hv_fill||5.013002|
1573 hv_free_ent_ret|||
1574 hv_free_ent||5.004000|
1575 hv_iterinit|||
1576 hv_iterkeysv||5.004000|
1577 hv_iterkey|||
1578 hv_iternext_flags||5.008000|
1579 hv_iternextsv|||
1580 hv_iternext|||
1581 hv_iterval|||
1582 hv_kill_backrefs|||
1583 hv_ksplit||5.004000|
1584 hv_magic_check|||n
1585 hv_magic|||
1586 hv_name_set||5.009003|
1587 hv_notallowed|||
1588 hv_placeholders_get||5.009003|
1589 hv_placeholders_p||5.009003|
1590 hv_placeholders_set||5.009003|
1591 hv_riter_p||5.009003|
1592 hv_riter_set||5.009003|
1593 hv_scalar||5.009001|
1594 hv_store_ent||5.004000|
1595 hv_store_flags||5.008000|
1596 hv_stores|5.009004||p
1597 hv_store|||
1598 hv_undef_flags|||
1599 hv_undef|||
1600 ibcmp_locale||5.004000|
1601 ibcmp_utf8||5.007003|
1602 ibcmp|||
1603 incline|||
1604 incpush_if_exists|||
1605 incpush_use_sep|||
1606 incpush|||
1607 ingroup|||
1608 init_argv_symbols|||
1609 init_constants|||
1610 init_dbargs|||
1611 init_debugger|||
1612 init_global_struct|||
1613 init_i18nl10n||5.006000|
1614 init_i18nl14n||5.006000|
1615 init_ids|||
1616 init_interp|||
1617 init_main_stash|||
1618 init_perllib|||
1619 init_postdump_symbols|||
1620 init_predump_symbols|||
1621 init_stacks||5.005000|
1622 init_tm||5.007002|
1623 inplace_aassign|||
1624 instr|||n
1625 intro_my|||
1626 intuit_method|||
1627 intuit_more|||
1628 invert|||
1629 invlist_array|||
1630 invlist_clone|||
1631 invlist_extend|||
1632 invlist_highest|||
1633 invlist_iterinit|||
1634 invlist_iternext|||
1635 invlist_len|||
1636 invlist_max|||
1637 invlist_set_len|||
1638 invlist_trim|||
1639 invoke_exception_hook|||
1640 io_close|||
1641 isALNUMC|5.006000||p
1642 isALPHA|||
1643 isASCII|5.006000||p
1644 isBLANK|5.006001||p
1645 isCNTRL|5.006000||p
1646 isDIGIT|||
1647 isGRAPH|5.006000||p
1648 isGV_with_GP|5.009004||p
1649 isLOWER|||
1650 isOCTAL||5.013005|
1651 isPRINT|5.004000||p
1652 isPSXSPC|5.006001||p
1653 isPUNCT|5.006000||p
1654 isSPACE|||
1655 isUPPER|||
1656 isWORDCHAR||5.013006|
1657 isXDIGIT|5.006000||p
1658 is_an_int|||
1659 is_ascii_string||5.011000|n
1660 is_handle_constructor|||n
1661 is_list_assignment|||
1662 is_lvalue_sub||5.007001|
1663 is_uni_alnum_lc||5.006000|
1664 is_uni_alnum||5.006000|
1665 is_uni_alpha_lc||5.006000|
1666 is_uni_alpha||5.006000|
1667 is_uni_ascii_lc||5.006000|
1668 is_uni_ascii||5.006000|
1669 is_uni_blank||5.017002|
1670 is_uni_cntrl_lc||5.006000|
1671 is_uni_cntrl||5.006000|
1672 is_uni_digit_lc||5.006000|
1673 is_uni_digit||5.006000|
1674 is_uni_graph_lc||5.006000|
1675 is_uni_graph||5.006000|
1676 is_uni_idfirst_lc||5.006000|
1677 is_uni_idfirst||5.006000|
1678 is_uni_lower_lc||5.006000|
1679 is_uni_lower||5.006000|
1680 is_uni_print_lc||5.006000|
1681 is_uni_print||5.006000|
1682 is_uni_punct_lc||5.006000|
1683 is_uni_punct||5.006000|
1684 is_uni_space_lc||5.006000|
1685 is_uni_space||5.006000|
1686 is_uni_upper_lc||5.006000|
1687 is_uni_upper||5.006000|
1688 is_uni_xdigit_lc||5.006000|
1689 is_uni_xdigit||5.006000|
1690 is_utf8_X_LVT|||
1691 is_utf8_X_LV_LVT_V|||
1692 is_utf8_X_LV|||
1693 is_utf8_X_L|||
1694 is_utf8_X_T|||
1695 is_utf8_X_V|||
1696 is_utf8_X_begin|||
1697 is_utf8_X_extend|||
1698 is_utf8_X_non_hangul|||
1699 is_utf8_X_prepend|||
1700 is_utf8_alnum||5.006000|
1701 is_utf8_alpha||5.006000|
1702 is_utf8_ascii||5.006000|
1703 is_utf8_blank||5.017002|
1704 is_utf8_char_buf||5.015008|n
1705 is_utf8_char_slow|||n
1706 is_utf8_char||5.006000|n
1707 is_utf8_cntrl||5.006000|
1708 is_utf8_common|||
1709 is_utf8_digit||5.006000|
1710 is_utf8_graph||5.006000|
1711 is_utf8_idcont||5.008000|
1712 is_utf8_idfirst||5.006000|
1713 is_utf8_lower||5.006000|
1714 is_utf8_mark||5.006000|
1715 is_utf8_perl_space||5.011001|
1716 is_utf8_perl_word||5.011001|
1717 is_utf8_posix_digit||5.011001|
1718 is_utf8_print||5.006000|
1719 is_utf8_punct||5.006000|
1720 is_utf8_space||5.006000|
1721 is_utf8_string_loclen||5.009003|n
1722 is_utf8_string_loc||5.008001|n
1723 is_utf8_string||5.006001|n
1724 is_utf8_upper||5.006000|
1725 is_utf8_xdigit||5.006000|
1726 is_utf8_xidcont||5.013010|
1727 is_utf8_xidfirst||5.013010|
1728 isa_lookup|||
1729 items|||n
1730 ix|||n
1731 jmaybe|||
1732 join_exact|||
1733 keyword_plugin_standard|||
1734 keyword|||
1735 leave_scope|||
1736 lex_bufutf8||5.011002|
1737 lex_discard_to||5.011002|
1738 lex_grow_linestr||5.011002|
1739 lex_next_chunk||5.011002|
1740 lex_peek_unichar||5.011002|
1741 lex_read_space||5.011002|
1742 lex_read_to||5.011002|
1743 lex_read_unichar||5.011002|
1744 lex_start||5.009005|
1745 lex_stuff_pvn||5.011002|
1746 lex_stuff_pvs||5.013005|
1747 lex_stuff_pv||5.013006|
1748 lex_stuff_sv||5.011002|
1749 lex_unstuff||5.011002|
1750 listkids|||
1751 list|||
1752 load_module_nocontext|||vn
1753 load_module|5.006000||pv
1754 localize|||
1755 looks_like_bool|||
1756 looks_like_number|||
1757 lop|||
1758 mPUSHi|5.009002||p
1759 mPUSHn|5.009002||p
1760 mPUSHp|5.009002||p
1761 mPUSHs|5.010001||p
1762 mPUSHu|5.009002||p
1763 mXPUSHi|5.009002||p
1764 mXPUSHn|5.009002||p
1765 mXPUSHp|5.009002||p
1766 mXPUSHs|5.010001||p
1767 mXPUSHu|5.009002||p
1768 mad_free|||
1769 madlex|||
1770 madparse|||
1771 magic_clear_all_env|||
1772 magic_cleararylen_p|||
1773 magic_clearenv|||
1774 magic_clearhints|||
1775 magic_clearhint|||
1776 magic_clearisa|||
1777 magic_clearpack|||
1778 magic_clearsig|||
1779 magic_copycallchecker|||
1780 magic_dump||5.006000|
1781 magic_existspack|||
1782 magic_freearylen_p|||
1783 magic_freeovrld|||
1784 magic_getarylen|||
1785 magic_getdefelem|||
1786 magic_getnkeys|||
1787 magic_getpack|||
1788 magic_getpos|||
1789 magic_getsig|||
1790 magic_getsubstr|||
1791 magic_gettaint|||
1792 magic_getuvar|||
1793 magic_getvec|||
1794 magic_get|||
1795 magic_killbackrefs|||
1796 magic_len|||
1797 magic_methcall1|||
1798 magic_methcall|||v
1799 magic_methpack|||
1800 magic_nextpack|||
1801 magic_regdata_cnt|||
1802 magic_regdatum_get|||
1803 magic_regdatum_set|||
1804 magic_scalarpack|||
1805 magic_set_all_env|||
1806 magic_setarylen|||
1807 magic_setcollxfrm|||
1808 magic_setdbline|||
1809 magic_setdefelem|||
1810 magic_setenv|||
1811 magic_sethint|||
1812 magic_setisa|||
1813 magic_setmglob|||
1814 magic_setnkeys|||
1815 magic_setpack|||
1816 magic_setpos|||
1817 magic_setregexp|||
1818 magic_setsig|||
1819 magic_setsubstr|||
1820 magic_settaint|||
1821 magic_setutf8|||
1822 magic_setuvar|||
1823 magic_setvec|||
1824 magic_set|||
1825 magic_sizepack|||
1826 magic_wipepack|||
1827 make_matcher|||
1828 make_trie_failtable|||
1829 make_trie|||
1830 malloc_good_size|||n
1831 malloced_size|||n
1832 malloc||5.007002|n
1833 markstack_grow|||
1834 matcher_matches_sv|||
1835 mayberelocate|||
1836 measure_struct|||
1837 memEQs|5.009005||p
1838 memEQ|5.004000||p
1839 memNEs|5.009005||p
1840 memNE|5.004000||p
1841 mem_collxfrm|||
1842 mem_log_common|||n
1843 mess_alloc|||
1844 mess_nocontext|||vn
1845 mess_sv||5.013001|
1846 mess||5.006000|v
1847 method_common|||
1848 mfree||5.007002|n
1849 mg_clear|||
1850 mg_copy|||
1851 mg_dup|||
1852 mg_findext||5.013008|
1853 mg_find|||
1854 mg_free_type||5.013006|
1855 mg_free|||
1856 mg_get|||
1857 mg_length||5.005000|
1858 mg_localize|||
1859 mg_magical|||
1860 mg_set|||
1861 mg_size||5.005000|
1862 mini_mktime||5.007002|
1863 minus_v|||
1864 missingterm|||
1865 mode_from_discipline|||
1866 modkids|||
1867 more_bodies|||
1868 more_sv|||
1869 moreswitches|||
1870 mro_clean_isarev|||
1871 mro_gather_and_rename|||
1872 mro_get_from_name||5.010001|
1873 mro_get_linear_isa_dfs|||
1874 mro_get_linear_isa||5.009005|
1875 mro_get_private_data||5.010001|
1876 mro_isa_changed_in|||
1877 mro_meta_dup|||
1878 mro_meta_init|||
1879 mro_method_changed_in||5.009005|
1880 mro_package_moved|||
1881 mro_register||5.010001|
1882 mro_set_mro||5.010001|
1883 mro_set_private_data||5.010001|
1884 mul128|||
1885 mulexp10|||n
1886 my_atof2||5.007002|
1887 my_atof||5.006000|
1888 my_attrs|||
1889 my_bcopy|||n
1890 my_betoh16|||n
1891 my_betoh32|||n
1892 my_betoh64|||n
1893 my_betohi|||n
1894 my_betohl|||n
1895 my_betohs|||n
1896 my_bzero|||n
1897 my_chsize|||
1898 my_clearenv|||
1899 my_cxt_index|||
1900 my_cxt_init|||
1901 my_dirfd||5.009005|
1902 my_exit_jump|||
1903 my_exit|||
1904 my_failure_exit||5.004000|
1905 my_fflush_all||5.006000|
1906 my_fork||5.007003|n
1907 my_htobe16|||n
1908 my_htobe32|||n
1909 my_htobe64|||n
1910 my_htobei|||n
1911 my_htobel|||n
1912 my_htobes|||n
1913 my_htole16|||n
1914 my_htole32|||n
1915 my_htole64|||n
1916 my_htolei|||n
1917 my_htolel|||n
1918 my_htoles|||n
1919 my_htonl|||
1920 my_kid|||
1921 my_letoh16|||n
1922 my_letoh32|||n
1923 my_letoh64|||n
1924 my_letohi|||n
1925 my_letohl|||n
1926 my_letohs|||n
1927 my_lstat_flags|||
1928 my_lstat||5.017004|
1929 my_memcmp|||n
1930 my_memset||5.004000|n
1931 my_ntohl|||
1932 my_pclose||5.004000|
1933 my_popen_list||5.007001|
1934 my_popen||5.004000|
1935 my_setenv|||
1936 my_snprintf|5.009004||pvn
1937 my_socketpair||5.007003|n
1938 my_sprintf|5.009003||pvn
1939 my_stat_flags|||
1940 my_stat||5.017004|
1941 my_strftime||5.007002|
1942 my_strlcat|5.009004||pn
1943 my_strlcpy|5.009004||pn
1944 my_swabn|||n
1945 my_swap|||
1946 my_unexec|||
1947 my_vsnprintf||5.009004|n
1948 need_utf8|||n
1949 newANONATTRSUB||5.006000|
1950 newANONHASH|||
1951 newANONLIST|||
1952 newANONSUB|||
1953 newASSIGNOP|||
1954 newATTRSUB_flags|||
1955 newATTRSUB||5.006000|
1956 newAVREF|||
1957 newAV|||
1958 newBINOP|||
1959 newCONDOP|||
1960 newCONSTSUB_flags||5.015006|
1961 newCONSTSUB|5.004050||p
1962 newCVREF|||
1963 newDEFSVOP|||
1964 newFORM|||
1965 newFOROP||5.013007|
1966 newGIVENOP||5.009003|
1967 newGIVWHENOP|||
1968 newGP|||
1969 newGVOP|||
1970 newGVREF|||
1971 newGVgen_flags||5.015004|
1972 newGVgen|||
1973 newHVREF|||
1974 newHVhv||5.005000|
1975 newHV|||
1976 newIO|||
1977 newLISTOP|||
1978 newLOGOP|||
1979 newLOOPEX|||
1980 newLOOPOP|||
1981 newMADPROP|||
1982 newMADsv|||
1983 newMYSUB|||
1984 newNULLLIST|||
1985 newOP|||
1986 newPADOP|||
1987 newPMOP|||
1988 newPROG|||
1989 newPVOP|||
1990 newRANGE|||
1991 newRV_inc|5.004000||p
1992 newRV_noinc|5.004000||p
1993 newRV|||
1994 newSLICEOP|||
1995 newSTATEOP|||
1996 newSTUB|||
1997 newSUB|||
1998 newSVOP|||
1999 newSVREF|||
2000 newSV_type|5.009005||p
2001 newSVhek||5.009003|
2002 newSViv|||
2003 newSVnv|||
2004 newSVpadname||5.017004|
2005 newSVpv_share||5.013006|
2006 newSVpvf_nocontext|||vn
2007 newSVpvf||5.004000|v
2008 newSVpvn_flags|5.010001||p
2009 newSVpvn_share|5.007001||p
2010 newSVpvn_utf8|5.010001||p
2011 newSVpvn|5.004050||p
2012 newSVpvs_flags|5.010001||p
2013 newSVpvs_share|5.009003||p
2014 newSVpvs|5.009003||p
2015 newSVpv|||
2016 newSVrv|||
2017 newSVsv|||
2018 newSVuv|5.006000||p
2019 newSV|||
2020 newTOKEN|||
2021 newUNOP|||
2022 newWHENOP||5.009003|
2023 newWHILEOP||5.013007|
2024 newXS_flags||5.009004|
2025 newXS_len_flags|||
2026 newXSproto||5.006000|
2027 newXS||5.006000|
2028 new_collate||5.006000|
2029 new_constant|||
2030 new_ctype||5.006000|
2031 new_he|||
2032 new_logop|||
2033 new_numeric||5.006000|
2034 new_stackinfo||5.005000|
2035 new_version||5.009000|
2036 new_warnings_bitfield|||
2037 next_symbol|||
2038 nextargv|||
2039 nextchar|||
2040 ninstr|||n
2041 no_bareword_allowed|||
2042 no_fh_allowed|||
2043 no_op|||
2044 not_a_number|||
2045 nothreadhook||5.008000|
2046 nuke_stacks|||
2047 num_overflow|||n
2048 oopsAV|||
2049 oopsHV|||
2050 op_append_elem||5.013006|
2051 op_append_list||5.013006|
2052 op_clear|||
2053 op_const_sv|||
2054 op_contextualize||5.013006|
2055 op_dump||5.006000|
2056 op_free|||
2057 op_getmad_weak|||
2058 op_getmad|||
2059 op_integerize|||
2060 op_linklist||5.013006|
2061 op_lvalue_flags|||
2062 op_lvalue||5.013007|
2063 op_null||5.007002|
2064 op_prepend_elem||5.013006|
2065 op_refcnt_dec|||
2066 op_refcnt_inc|||
2067 op_refcnt_lock||5.009002|
2068 op_refcnt_unlock||5.009002|
2069 op_scope||5.013007|
2070 op_std_init|||
2071 op_unscope|||
2072 op_xmldump|||
2073 open_script|||
2074 opslab_force_free|||
2075 opslab_free_nopad|||
2076 opslab_free|||
2077 opt_scalarhv|||
2078 pMY_CXT_|5.007003||p
2079 pMY_CXT|5.007003||p
2080 pTHX_|5.006000||p
2081 pTHX|5.006000||p
2082 packWARN|5.007003||p
2083 pack_cat||5.007003|
2084 pack_rec|||
2085 package_version|||
2086 package|||
2087 packlist||5.008001|
2088 pad_add_anon||5.008001|
2089 pad_add_name_pvn||5.015001|
2090 pad_add_name_pvs||5.015001|
2091 pad_add_name_pv||5.015001|
2092 pad_add_name_sv||5.015001|
2093 pad_alloc_name|||
2094 pad_alloc|||
2095 pad_block_start|||
2096 pad_check_dup|||
2097 pad_compname_type||5.009003|
2098 pad_findlex|||
2099 pad_findmy_pvn||5.015001|
2100 pad_findmy_pvs||5.015001|
2101 pad_findmy_pv||5.015001|
2102 pad_findmy_sv||5.015001|
2103 pad_fixup_inner_anons|||
2104 pad_free|||
2105 pad_leavemy|||
2106 pad_new||5.008001|
2107 pad_peg|||n
2108 pad_push|||
2109 pad_reset|||
2110 pad_setsv|||
2111 pad_sv|||
2112 pad_swipe|||
2113 pad_tidy||5.008001|
2114 padlist_dup|||
2115 padlist_store|||
2116 parse_arithexpr||5.013008|
2117 parse_barestmt||5.013007|
2118 parse_block||5.013007|
2119 parse_body|||
2120 parse_fullexpr||5.013008|
2121 parse_fullstmt||5.013005|
2122 parse_label||5.013007|
2123 parse_listexpr||5.013008|
2124 parse_stmtseq||5.013006|
2125 parse_termexpr||5.013008|
2126 parse_unicode_opts|||
2127 parser_dup|||
2128 parser_free|||
2129 path_is_absolute|||n
2130 peep|||
2131 perl_alloc_using|||n
2132 perl_alloc|||n
2133 perl_clone_using|||n
2134 perl_clone|||n
2135 perl_construct|||n
2136 perl_destruct||5.007003|n
2137 perl_free|||n
2138 perl_parse||5.006000|n
2139 perl_run|||n
2140 pidgone|||
2141 pm_description|||
2142 pmop_dump||5.006000|
2143 pmop_xmldump|||
2144 pmruntime|||
2145 pmtrans|||
2146 pop_scope|||
2147 populate_isa|||v
2148 pregcomp||5.009005|
2149 pregexec|||
2150 pregfree2||5.011000|
2151 pregfree|||
2152 prepend_madprops|||
2153 prescan_version||5.011004|
2154 printbuf|||
2155 printf_nocontext|||vn
2156 process_special_blocks|||
2157 ptr_table_clear||5.009005|
2158 ptr_table_fetch||5.009005|
2159 ptr_table_find|||n
2160 ptr_table_free||5.009005|
2161 ptr_table_new||5.009005|
2162 ptr_table_split||5.009005|
2163 ptr_table_store||5.009005|
2164 push_scope|||
2165 put_byte|||
2166 pv_display|5.006000||p
2167 pv_escape|5.009004||p
2168 pv_pretty|5.009004||p
2169 pv_uni_display||5.007003|
2170 qerror|||
2171 qsortsvu|||
2172 re_compile||5.009005|
2173 re_croak2|||
2174 re_dup_guts|||
2175 re_intuit_start||5.009005|
2176 re_intuit_string||5.006000|
2177 re_op_compile|||
2178 readpipe_override|||
2179 realloc||5.007002|n
2180 reentrant_free||5.017004|
2181 reentrant_init||5.017004|
2182 reentrant_retry||5.017004|vn
2183 reentrant_size||5.017004|
2184 ref_array_or_hash|||
2185 refcounted_he_chain_2hv|||
2186 refcounted_he_fetch_pvn|||
2187 refcounted_he_fetch_pvs|||
2188 refcounted_he_fetch_pv|||
2189 refcounted_he_fetch_sv|||
2190 refcounted_he_free|||
2191 refcounted_he_inc|||
2192 refcounted_he_new_pvn|||
2193 refcounted_he_new_pvs|||
2194 refcounted_he_new_pv|||
2195 refcounted_he_new_sv|||
2196 refcounted_he_value|||
2197 refkids|||
2198 refto|||
2199 ref||5.017004|
2200 reg_check_named_buff_matched|||
2201 reg_named_buff_all||5.009005|
2202 reg_named_buff_exists||5.009005|
2203 reg_named_buff_fetch||5.009005|
2204 reg_named_buff_firstkey||5.009005|
2205 reg_named_buff_iter|||
2206 reg_named_buff_nextkey||5.009005|
2207 reg_named_buff_scalar||5.009005|
2208 reg_named_buff|||
2209 reg_node|||
2210 reg_numbered_buff_fetch|||
2211 reg_numbered_buff_length|||
2212 reg_numbered_buff_store|||
2213 reg_qr_package|||
2214 reg_recode|||
2215 reg_scan_name|||
2216 reg_skipcomment|||
2217 reg_temp_copy|||
2218 reganode|||
2219 regatom|||
2220 regbranch|||
2221 regclass_swash||5.009004|
2222 regclass|||
2223 regcppop|||
2224 regcppush|||
2225 regcurly|||
2226 regdump_extflags|||
2227 regdump||5.005000|
2228 regdupe_internal|||
2229 regexec_flags||5.005000|
2230 regfree_internal||5.009005|
2231 reghop3|||n
2232 reghop4|||n
2233 reghopmaybe3|||n
2234 reginclass|||
2235 reginitcolors||5.006000|
2236 reginsert|||
2237 regmatch|||
2238 regnext||5.005000|
2239 regpiece|||
2240 regpposixcc|||
2241 regprop|||
2242 regrepeat|||
2243 regtail_study|||
2244 regtail|||
2245 regtry|||
2246 reguni|||
2247 regwhite|||n
2248 reg|||
2249 repeatcpy|||n
2250 report_evil_fh|||
2251 report_redefined_cv|||
2252 report_uninit|||
2253 report_wrongway_fh|||
2254 require_pv||5.006000|
2255 require_tie_mod|||
2256 restore_magic|||
2257 rninstr|||n
2258 rpeep|||
2259 rsignal_restore|||
2260 rsignal_save|||
2261 rsignal_state||5.004000|
2262 rsignal||5.004000|
2263 run_body|||
2264 run_user_filter|||
2265 runops_debug||5.005000|
2266 runops_standard||5.005000|
2267 rv2cv_op_cv||5.013006|
2268 rvpv_dup|||
2269 rxres_free|||
2270 rxres_restore|||
2271 rxres_save|||
2272 safesyscalloc||5.006000|n
2273 safesysfree||5.006000|n
2274 safesysmalloc||5.006000|n
2275 safesysrealloc||5.006000|n
2276 same_dirent|||
2277 save_I16||5.004000|
2278 save_I32|||
2279 save_I8||5.006000|
2280 save_adelete||5.011000|
2281 save_aelem_flags||5.011000|
2282 save_aelem||5.004050|
2283 save_alloc||5.006000|
2284 save_aptr|||
2285 save_ary|||
2286 save_bool||5.008001|
2287 save_clearsv|||
2288 save_delete|||
2289 save_destructor_x||5.006000|
2290 save_destructor||5.006000|
2291 save_freeop|||
2292 save_freepv|||
2293 save_freesv|||
2294 save_generic_pvref||5.006001|
2295 save_generic_svref||5.005030|
2296 save_gp||5.004000|
2297 save_hash|||
2298 save_hdelete||5.011000|
2299 save_hek_flags|||n
2300 save_helem_flags||5.011000|
2301 save_helem||5.004050|
2302 save_hints||5.010001|
2303 save_hptr|||
2304 save_int|||
2305 save_item|||
2306 save_iv||5.005000|
2307 save_lines|||
2308 save_list|||
2309 save_long|||
2310 save_magic|||
2311 save_mortalizesv||5.007001|
2312 save_nogv|||
2313 save_op||5.005000|
2314 save_padsv_and_mortalize||5.010001|
2315 save_pptr|||
2316 save_pushi32ptr||5.010001|
2317 save_pushptri32ptr|||
2318 save_pushptrptr||5.010001|
2319 save_pushptr||5.010001|
2320 save_re_context||5.006000|
2321 save_scalar_at|||
2322 save_scalar|||
2323 save_set_svflags||5.009000|
2324 save_shared_pvref||5.007003|
2325 save_sptr|||
2326 save_svref|||
2327 save_vptr||5.006000|
2328 savepvn|||
2329 savepvs||5.009003|
2330 savepv|||
2331 savesharedpvn||5.009005|
2332 savesharedpvs||5.013006|
2333 savesharedpv||5.007003|
2334 savesharedsvpv||5.013006|
2335 savestack_grow_cnt||5.008001|
2336 savestack_grow|||
2337 savesvpv||5.009002|
2338 sawparens|||
2339 scalar_mod_type|||n
2340 scalarboolean|||
2341 scalarkids|||
2342 scalarseq|||
2343 scalarvoid|||
2344 scalar|||
2345 scan_bin||5.006000|
2346 scan_commit|||
2347 scan_const|||
2348 scan_formline|||
2349 scan_heredoc|||
2350 scan_hex|||
2351 scan_ident|||
2352 scan_inputsymbol|||
2353 scan_num||5.007001|
2354 scan_oct|||
2355 scan_pat|||
2356 scan_str|||
2357 scan_subst|||
2358 scan_trans|||
2359 scan_version||5.009001|
2360 scan_vstring||5.009005|
2361 scan_word|||
2362 screaminstr||5.005000|
2363 search_const|||
2364 seed||5.008001|
2365 sequence_num|||
2366 set_context||5.006000|n
2367 set_numeric_local||5.006000|
2368 set_numeric_radix||5.006000|
2369 set_numeric_standard||5.006000|
2370 setdefout|||
2371 share_hek_flags|||
2372 share_hek||5.004000|
2373 si_dup|||
2374 sighandler|||n
2375 simplify_sort|||
2376 skipspace0|||
2377 skipspace1|||
2378 skipspace2|||
2379 skipspace|||
2380 softref2xv|||
2381 sortcv_stacked|||
2382 sortcv_xsub|||
2383 sortcv|||
2384 sortsv_flags||5.009003|
2385 sortsv||5.007003|
2386 space_join_names_mortal|||
2387 ss_dup|||
2388 stack_grow|||
2389 start_force|||
2390 start_glob|||
2391 start_subparse||5.004000|
2392 stdize_locale|||
2393 strEQ|||
2394 strGE|||
2395 strGT|||
2396 strLE|||
2397 strLT|||
2398 strNE|||
2399 str_to_version||5.006000|
2400 strip_return|||
2401 strnEQ|||
2402 strnNE|||
2403 study_chunk|||
2404 sub_crush_depth|||
2405 sublex_done|||
2406 sublex_push|||
2407 sublex_start|||
2408 sv_2bool_flags||5.013006|
2409 sv_2bool|||
2410 sv_2cv|||
2411 sv_2io|||
2412 sv_2iuv_common|||
2413 sv_2iuv_non_preserve|||
2414 sv_2iv_flags||5.009001|
2415 sv_2iv|||
2416 sv_2mortal|||
2417 sv_2num|||
2418 sv_2nv_flags||5.013001|
2419 sv_2pv_flags|5.007002||p
2420 sv_2pv_nolen|5.006000||p
2421 sv_2pvbyte_nolen|5.006000||p
2422 sv_2pvbyte|5.006000||p
2423 sv_2pvutf8_nolen||5.006000|
2424 sv_2pvutf8||5.006000|
2425 sv_2pv|||
2426 sv_2uv_flags||5.009001|
2427 sv_2uv|5.004000||p
2428 sv_add_arena|||
2429 sv_add_backref|||
2430 sv_backoff|||
2431 sv_bless|||
2432 sv_cat_decode||5.008001|
2433 sv_catpv_flags||5.013006|
2434 sv_catpv_mg|5.004050||p
2435 sv_catpv_nomg||5.013006|
2436 sv_catpvf_mg_nocontext|||pvn
2437 sv_catpvf_mg|5.006000|5.004000|pv
2438 sv_catpvf_nocontext|||vn
2439 sv_catpvf||5.004000|v
2440 sv_catpvn_flags||5.007002|
2441 sv_catpvn_mg|5.004050||p
2442 sv_catpvn_nomg|5.007002||p
2443 sv_catpvn|||
2444 sv_catpvs_flags||5.013006|
2445 sv_catpvs_mg||5.013006|
2446 sv_catpvs_nomg||5.013006|
2447 sv_catpvs|5.009003||p
2448 sv_catpv|||
2449 sv_catsv_flags||5.007002|
2450 sv_catsv_mg|5.004050||p
2451 sv_catsv_nomg|5.007002||p
2452 sv_catsv|||
2453 sv_catxmlpvn|||
2454 sv_catxmlpv|||
2455 sv_catxmlsv|||
2456 sv_chop|||
2457 sv_clean_all|||
2458 sv_clean_objs|||
2459 sv_clear|||
2460 sv_cmp_flags||5.013006|
2461 sv_cmp_locale_flags||5.013006|
2462 sv_cmp_locale||5.004000|
2463 sv_cmp|||
2464 sv_collxfrm_flags||5.013006|
2465 sv_collxfrm|||
2466 sv_copypv_flags||5.017002|
2467 sv_copypv_nomg||5.017002|
2468 sv_copypv|||
2469 sv_dec_nomg||5.013002|
2470 sv_dec|||
2471 sv_del_backref|||
2472 sv_derived_from_pvn||5.015004|
2473 sv_derived_from_pv||5.015004|
2474 sv_derived_from_sv||5.015004|
2475 sv_derived_from||5.004000|
2476 sv_destroyable||5.010000|
2477 sv_does_pvn||5.015004|
2478 sv_does_pv||5.015004|
2479 sv_does_sv||5.015004|
2480 sv_does||5.009004|
2481 sv_dump|||
2482 sv_dup_common|||
2483 sv_dup_inc_multiple|||
2484 sv_dup_inc|||
2485 sv_dup|||
2486 sv_eq_flags||5.013006|
2487 sv_eq|||
2488 sv_exp_grow|||
2489 sv_force_normal_flags||5.007001|
2490 sv_force_normal||5.006000|
2491 sv_free2|||
2492 sv_free_arenas|||
2493 sv_free|||
2494 sv_gets||5.004000|
2495 sv_grow|||
2496 sv_i_ncmp|||
2497 sv_inc_nomg||5.013002|
2498 sv_inc|||
2499 sv_insert_flags||5.010001|
2500 sv_insert|||
2501 sv_isa|||
2502 sv_isobject|||
2503 sv_iv||5.005000|
2504 sv_kill_backrefs|||
2505 sv_len_utf8||5.006000|
2506 sv_len|||
2507 sv_magic_portable|5.017004|5.004000|p
2508 sv_magicext||5.007003|
2509 sv_magic|||
2510 sv_mortalcopy|||
2511 sv_ncmp|||
2512 sv_newmortal|||
2513 sv_newref|||
2514 sv_nolocking||5.007003|
2515 sv_nosharing||5.007003|
2516 sv_nounlocking|||
2517 sv_nv||5.005000|
2518 sv_peek||5.005000|
2519 sv_pos_b2u_midway|||
2520 sv_pos_b2u||5.006000|
2521 sv_pos_u2b_cached|||
2522 sv_pos_u2b_flags||5.011005|
2523 sv_pos_u2b_forwards|||n
2524 sv_pos_u2b_midway|||n
2525 sv_pos_u2b||5.006000|
2526 sv_pvbyten_force||5.006000|
2527 sv_pvbyten||5.006000|
2528 sv_pvbyte||5.006000|
2529 sv_pvn_force_flags|5.007002||p
2530 sv_pvn_force|||
2531 sv_pvn_nomg|5.007003|5.005000|p
2532 sv_pvn||5.005000|
2533 sv_pvutf8n_force||5.006000|
2534 sv_pvutf8n||5.006000|
2535 sv_pvutf8||5.006000|
2536 sv_pv||5.006000|
2537 sv_recode_to_utf8||5.007003|
2538 sv_reftype|||
2539 sv_ref|||
2540 sv_release_COW|||
2541 sv_replace|||
2542 sv_report_used|||
2543 sv_reset|||
2544 sv_rvweaken||5.006000|
2545 sv_sethek|||
2546 sv_setiv_mg|5.004050||p
2547 sv_setiv|||
2548 sv_setnv_mg|5.006000||p
2549 sv_setnv|||
2550 sv_setpv_mg|5.004050||p
2551 sv_setpvf_mg_nocontext|||pvn
2552 sv_setpvf_mg|5.006000|5.004000|pv
2553 sv_setpvf_nocontext|||vn
2554 sv_setpvf||5.004000|v
2555 sv_setpviv_mg||5.008001|
2556 sv_setpviv||5.008001|
2557 sv_setpvn_mg|5.004050||p
2558 sv_setpvn|||
2559 sv_setpvs_mg||5.013006|
2560 sv_setpvs|5.009004||p
2561 sv_setpv|||
2562 sv_setref_iv|||
2563 sv_setref_nv|||
2564 sv_setref_pvn|||
2565 sv_setref_pvs||5.017004|
2566 sv_setref_pv|||
2567 sv_setref_uv||5.007001|
2568 sv_setsv_cow|||
2569 sv_setsv_flags||5.007002|
2570 sv_setsv_mg|5.004050||p
2571 sv_setsv_nomg|5.007002||p
2572 sv_setsv|||
2573 sv_setuv_mg|5.004050||p
2574 sv_setuv|5.004000||p
2575 sv_tainted||5.004000|
2576 sv_taint||5.004000|
2577 sv_true||5.005000|
2578 sv_unglob|||
2579 sv_uni_display||5.007003|
2580 sv_unmagicext||5.013008|
2581 sv_unmagic|||
2582 sv_unref_flags||5.007001|
2583 sv_unref|||
2584 sv_untaint||5.004000|
2585 sv_upgrade|||
2586 sv_usepvn_flags||5.009004|
2587 sv_usepvn_mg|5.004050||p
2588 sv_usepvn|||
2589 sv_utf8_decode||5.006000|
2590 sv_utf8_downgrade||5.006000|
2591 sv_utf8_encode||5.006000|
2592 sv_utf8_upgrade_flags_grow||5.011000|
2593 sv_utf8_upgrade_flags||5.007002|
2594 sv_utf8_upgrade_nomg||5.007002|
2595 sv_utf8_upgrade||5.007001|
2596 sv_uv|5.005000||p
2597 sv_vcatpvf_mg|5.006000|5.004000|p
2598 sv_vcatpvfn_flags||5.017002|
2599 sv_vcatpvfn||5.004000|
2600 sv_vcatpvf|5.006000|5.004000|p
2601 sv_vsetpvf_mg|5.006000|5.004000|p
2602 sv_vsetpvfn||5.004000|
2603 sv_vsetpvf|5.006000|5.004000|p
2604 sv_xmlpeek|||
2605 svtype|||
2606 swallow_bom|||
2607 swash_fetch||5.007002|
2608 swash_init||5.006000|
2609 swatch_get|||
2610 sys_init3||5.010000|n
2611 sys_init||5.010000|n
2612 sys_intern_clear|||
2613 sys_intern_dup|||
2614 sys_intern_init|||
2615 sys_term||5.010000|n
2616 taint_env|||
2617 taint_proper|||
2618 tied_method|||v
2619 tmps_grow||5.006000|
2620 toLOWER|||
2621 toUPPER|||
2622 to_byte_substr|||
2623 to_lower_latin1|||
2624 to_uni_fold||5.007003|
2625 to_uni_lower_lc||5.006000|
2626 to_uni_lower||5.007003|
2627 to_uni_title_lc||5.006000|
2628 to_uni_title||5.007003|
2629 to_uni_upper_lc||5.006000|
2630 to_uni_upper||5.007003|
2631 to_utf8_case||5.007003|
2632 to_utf8_fold||5.015007|
2633 to_utf8_lower||5.015007|
2634 to_utf8_substr|||
2635 to_utf8_title||5.015007|
2636 to_utf8_upper||5.015007|
2637 token_free|||
2638 token_getmad|||
2639 tokenize_use|||
2640 tokeq|||
2641 tokereport|||
2642 too_few_arguments_pv|||
2643 too_few_arguments_sv|||
2644 too_many_arguments_pv|||
2645 too_many_arguments_sv|||
2646 translate_substr_offsets|||
2647 try_amagic_bin|||
2648 try_amagic_un|||
2649 uiv_2buf|||n
2650 unlnk|||
2651 unpack_rec|||
2652 unpack_str||5.007003|
2653 unpackstring||5.008001|
2654 unreferenced_to_tmp_stack|||
2655 unshare_hek_or_pvn|||
2656 unshare_hek|||
2657 unsharepvn||5.004000|
2658 unwind_handler_stack|||
2659 update_debugger_info|||
2660 upg_version||5.009005|
2661 usage|||
2662 utf16_textfilter|||
2663 utf16_to_utf8_reversed||5.006001|
2664 utf16_to_utf8||5.006001|
2665 utf8_distance||5.006000|
2666 utf8_hop||5.006000|
2667 utf8_length||5.007001|
2668 utf8_mg_len_cache_update|||
2669 utf8_mg_pos_cache_update|||
2670 utf8_to_bytes||5.006001|
2671 utf8_to_uvchr_buf||5.015009|
2672 utf8_to_uvchr||5.007001|
2673 utf8_to_uvuni_buf||5.015009|
2674 utf8_to_uvuni||5.007001|
2675 utf8n_to_uvchr|||
2676 utf8n_to_uvuni||5.007001|
2677 utilize|||
2678 uvchr_to_utf8_flags||5.007003|
2679 uvchr_to_utf8|||
2680 uvuni_to_utf8_flags||5.007003|
2681 uvuni_to_utf8||5.007001|
2682 valid_utf8_to_uvchr||5.015009|
2683 valid_utf8_to_uvuni||5.015009|
2684 validate_suid|||
2685 varname|||
2686 vcmp||5.009000|
2687 vcroak||5.006000|
2688 vdeb||5.007003|
2689 vform||5.006000|
2690 visit|||
2691 vivify_defelem|||
2692 vivify_ref|||
2693 vload_module|5.006000||p
2694 vmess||5.006000|
2695 vnewSVpvf|5.006000|5.004000|p
2696 vnormal||5.009002|
2697 vnumify||5.009000|
2698 vstringify||5.009000|
2699 vverify||5.009003|
2700 vwarner||5.006000|
2701 vwarn||5.006000|
2702 wait4pid|||
2703 warn_nocontext|||vn
2704 warn_sv||5.013001|
2705 warner_nocontext|||vn
2706 warner|5.006000|5.004000|pv
2707 warn|||v
2708 was_lvalue_sub|||
2709 watch|||
2710 whichsig_pvn||5.015004|
2711 whichsig_pv||5.015004|
2712 whichsig_sv||5.015004|
2713 whichsig|||
2714 with_queued_errors|||
2715 wrap_op_checker||5.015008|
2716 write_no_mem|||
2717 write_to_stderr|||
2718 xmldump_all_perl|||
2719 xmldump_all|||
2720 xmldump_attr|||
2721 xmldump_eval|||
2722 xmldump_form|||
2723 xmldump_indent|||v
2724 xmldump_packsubs_perl|||
2725 xmldump_packsubs|||
2726 xmldump_sub_perl|||
2727 xmldump_sub|||
2728 xmldump_vindent|||
2729 xs_apiversion_bootcheck|||
2730 xs_version_bootcheck|||
2731 yyerror_pvn|||
2732 yyerror_pv|||
2733 yyerror|||
2734 yylex|||
2735 yyparse|||
2736 yyunlex|||
2737 yywarn|||
2738 );
2739
2740 if (exists $opt{'list-unsupported'}) {
2741 my $f;
2742 for $f (sort { lc $a cmp lc $b } keys %API) {
2743 next unless $API{$f}{todo};
2744 print "$f ", '.'x(40-length($f)), " ", format_version($API{$f}{todo}), "\n";
2745 }
2746 exit 0;
2747 }
2748
2749 # Scan for possible replacement candidates
2750
2751 my(%replace, %need, %hints, %warnings, %depends);
2752 my $replace = 0;
2753 my($hint, $define, $function);
2754
2755 sub find_api
2756 {
2757 my $code = shift;
2758 $code =~ s{
2759 / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
2760 | "[^"\\]*(?:\\.[^"\\]*)*"
2761 | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx;
2762 grep { exists $API{$_} } $code =~ /(\w+)/mg;
2763 }
2764
2765 while (<DATA>) {
2766 if ($hint) {
2767 my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
2768 if (m{^\s*\*\s(.*?)\s*$}) {
2769 for (@{$hint->[1]}) {
2770 $h->{$_} ||= ''; # suppress warning with older perls
2771 $h->{$_} .= "$1\n";
2772 }
2773 }
2774 else { undef $hint }
2775 }
2776
2777 $hint = [$1, [split /,?\s+/, $2]]
2778 if m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$};
2779
2780 if ($define) {
2781 if ($define->[1] =~ /\\$/) {
2782 $define->[1] .= $_;
2783 }
2784 else {
2785 if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
2786 my @n = find_api($define->[1]);
2787 push @{$depends{$define->[0]}}, @n if @n
2788 }
2789 undef $define;
2790 }
2791 }
2792
2793 $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)};
2794
2795 if ($function) {
2796 if (/^}/) {
2797 if (exists $API{$function->[0]}) {
2798 my @n = find_api($function->[1]);
2799 push @{$depends{$function->[0]}}, @n if @n
2800 }
2801 undef $function;
2802 }
2803 else {
2804 $function->[1] .= $_;
2805 }
2806 }
2807
2808 $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)};
2809
2810 $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$};
2811 $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)};
2812 $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce};
2813 $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s*$};
2814
2815 if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) {
2816 my @deps = map { s/\s+//g; $_ } split /,/, $3;
2817 my $d;
2818 for $d (map { s/\s+//g; $_ } split /,/, $1) {
2819 push @{$depends{$d}}, @deps;
2820 }
2821 }
2822
2823 $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)};
2824 }
2825
2826 for (values %depends) {
2827 my %s;
2828 $_ = [sort grep !$s{$_}++, @$_];
2829 }
2830
2831 if (exists $opt{'api-info'}) {
2832 my $f;
2833 my $count = 0;
2834 my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$";
2835 for $f (sort { lc $a cmp lc $b } keys %API) {
2836 next unless $f =~ /$match/;
2837 print "\n=== $f ===\n\n";
2838 my $info = 0;
2839 if ($API{$f}{base} || $API{$f}{todo}) {
2840 my $base = format_version($API{$f}{base} || $API{$f}{todo});
2841 print "Supported at least starting from perl-$base.\n";
2842 $info++;
2843 }
2844 if ($API{$f}{provided}) {
2845 my $todo = $API{$f}{todo} ? format_version($API{$f}{todo}) : "5.003";
2846 print "Support by $ppport provided back to perl-$todo.\n";
2847 print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
2848 print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
2849 print "\n$hints{$f}" if exists $hints{$f};
2850 print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
2851 $info++;
2852 }
2853 print "No portability information available.\n" unless $info;
2854 $count++;
2855 }
2856 $count or print "Found no API matching '$opt{'api-info'}'.";
2857 print "\n";
2858 exit 0;
2859 }
2860
2861 if (exists $opt{'list-provided'}) {
2862 my $f;
2863 for $f (sort { lc $a cmp lc $b } keys %API) {
2864 next unless $API{$f}{provided};
2865 my @flags;
2866 push @flags, 'explicit' if exists $need{$f};
2867 push @flags, 'depend' if exists $depends{$f};
2868 push @flags, 'hint' if exists $hints{$f};
2869 push @flags, 'warning' if exists $warnings{$f};
2870 my $flags = @flags ? ' ['.join(', ', @flags).']' : '';
2871 print "$f$flags\n";
2872 }
2873 exit 0;
2874 }
2875
2876 my @files;
2877 my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
2878 my $srcext = join '|', map { quotemeta $_ } @srcext;
2879
2880 if (@ARGV) {
2881 my %seen;
2882 for (@ARGV) {
2883 if (-e) {
2884 if (-f) {
2885 push @files, $_ unless $seen{$_}++;
2886 }
2887 else { warn "'$_' is not a file.\n" }
2888 }
2889 else {
2890 my @new = grep { -f } glob $_
2891 or warn "'$_' does not exist.\n";
2892 push @files, grep { !$seen{$_}++ } @new;
2893 }
2894 }
2895 }
2896 else {
2897 eval {
2898 require File::Find;
2899 File::Find::find(sub {
2900 $File::Find::name =~ /($srcext)$/i
2901 and push @files, $File::Find::name;
2902 }, '.');
2903 };
2904 if ($@) {
2905 @files = map { glob "*$_" } @srcext;
2906 }
2907 }
2908
2909 if (!@ARGV || $opt{filter}) {
2910 my(@in, @out);
2911 my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
2912 for (@files) {
2913 my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i;
2914 push @{ $out ? \@out : \@in }, $_;
2915 }
2916 if (@ARGV && @out) {
2917 warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out);
2918 }
2919 @files = @in;
2920 }
2921
2922 die "No input files given!\n" unless @files;
2923
2924 my(%files, %global, %revreplace);
2925 %revreplace = reverse %replace;
2926 my $filename;
2927 my $patch_opened = 0;
2928
2929 for $filename (@files) {
2930 unless (open IN, "<$filename") {
2931 warn "Unable to read from $filename: $!\n";
2932 next;
2933 }
2934
2935 info("Scanning $filename ...");
2936
2937 my $c = do { local $/; <IN> };
2938 close IN;
2939
2940 my %file = (orig => $c, changes => 0);
2941
2942 # Temporarily remove C/XS comments and strings from the code
2943 my @ccom;
2944
2945 $c =~ s{
2946 ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]*
2947 | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* )
2948 | ( ^$HS*\#[^\r\n]*
2949 | "[^"\\]*(?:\\.[^"\\]*)*"
2950 | '[^'\\]*(?:\\.[^'\\]*)*'
2951 | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) )
2952 }{ defined $2 and push @ccom, $2;
2953 defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
2954
2955 $file{ccom} = \@ccom;
2956 $file{code} = $c;
2957 $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m;
2958
2959 my $func;
2960
2961 for $func (keys %API) {
2962 my $match = $func;
2963 $match .= "|$revreplace{$func}" if exists $revreplace{$func};
2964 if ($c =~ /\b(?:Perl_)?($match)\b/) {
2965 $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
2966 $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
2967 if (exists $API{$func}{provided}) {
2968 $file{uses_provided}{$func}++;
2969 if (!exists $API{$func}{base} || $API{$func}{base} > $opt{'compat-version'}) {
2970 $file{uses}{$func}++;
2971 my @deps = rec_depend($func);
2972 if (@deps) {
2973 $file{uses_deps}{$func} = \@deps;
2974 for (@deps) {
2975 $file{uses}{$_} = 0 unless exists $file{uses}{$_};
2976 }
2977 }
2978 for ($func, @deps) {
2979 $file{needs}{$_} = 'static' if exists $need{$_};
2980 }
2981 }
2982 }
2983 if (exists $API{$func}{todo} && $API{$func}{todo} > $opt{'compat-version'}) {
2984 if ($c =~ /\b$func\b/) {
2985 $file{uses_todo}{$func}++;
2986 }
2987 }
2988 }
2989 }
2990
2991 while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) {
2992 if (exists $need{$2}) {
2993 $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
2994 }
2995 else { warning("Possibly wrong #define $1 in $filename") }
2996 }
2997
2998 for (qw(uses needs uses_todo needed_global needed_static)) {
2999 for $func (keys %{$file{$_}}) {
3000 push @{$global{$_}{$func}}, $filename;
3001 }
3002 }
3003
3004 $files{$filename} = \%file;
3005 }
3006
3007 # Globally resolve NEED_'s
3008 my $need;
3009 for $need (keys %{$global{needs}}) {
3010 if (@{$global{needs}{$need}} > 1) {
3011 my @targets = @{$global{needs}{$need}};
3012 my @t = grep $files{$_}{needed_global}{$need}, @targets;
3013 @targets = @t if @t;
3014 @t = grep /\.xs$/i, @targets;
3015 @targets = @t if @t;
3016 my $target = shift @targets;
3017 $files{$target}{needs}{$need} = 'global';
3018 for (@{$global{needs}{$need}}) {
3019 $files{$_}{needs}{$need} = 'extern' if $_ ne $target;
3020 }
3021 }
3022 }
3023
3024 for $filename (@files) {
3025 exists $files{$filename} or next;
3026
3027 info("=== Analyzing $filename ===");
3028
3029 my %file = %{$files{$filename}};
3030 my $func;
3031 my $c = $file{code};
3032 my $warnings = 0;
3033
3034 for $func (sort keys %{$file{uses_Perl}}) {
3035 if ($API{$func}{varargs}) {
3036 unless ($API{$func}{nothxarg}) {
3037 my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))}
3038 { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
3039 if ($changes) {
3040 warning("Doesn't pass interpreter argument aTHX to Perl_$func");
3041 $file{changes} += $changes;
3042 }
3043 }
3044 }
3045 else {
3046 warning("Uses Perl_$func instead of $func");
3047 $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*}
3048 {$func$1(}g);
3049 }
3050 }
3051
3052 for $func (sort keys %{$file{uses_replace}}) {
3053 warning("Uses $func instead of $replace{$func}");
3054 $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
3055 }
3056
3057 for $func (sort keys %{$file{uses_provided}}) {
3058 if ($file{uses}{$func}) {
3059 if (exists $file{uses_deps}{$func}) {
3060 diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
3061 }
3062 else {
3063 diag("Uses $func");
3064 }
3065 }
3066 $warnings += hint($func);
3067 }
3068
3069 unless ($opt{quiet}) {
3070 for $func (sort keys %{$file{uses_todo}}) {
3071 print "*** WARNING: Uses $func, which may not be portable below perl ",
3072 format_version($API{$func}{todo}), ", even with '$ppport'\n";
3073 $warnings++;
3074 }
3075 }
3076
3077 for $func (sort keys %{$file{needed_static}}) {
3078 my $message = '';
3079 if (not exists $file{uses}{$func}) {
3080 $message = "No need to define NEED_$func if $func is never used";
3081 }
3082 elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') {
3083 $message = "No need to define NEED_$func when already needed globally";
3084 }
3085 if ($message) {
3086 diag($message);
3087 $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg);
3088 }
3089 }
3090
3091 for $func (sort keys %{$file{needed_global}}) {
3092 my $message = '';
3093 if (not exists $global{uses}{$func}) {
3094 $message = "No need to define NEED_${func}_GLOBAL if $func is never used";
3095 }
3096 elsif (exists $file{needs}{$func}) {
3097 if ($file{needs}{$func} eq 'extern') {
3098 $message = "No need to define NEED_${func}_GLOBAL when already needed globally";
3099 }
3100 elsif ($file{needs}{$func} eq 'static') {
3101 $message = "No need to define NEED_${func}_GLOBAL when only used in this file";
3102 }
3103 }
3104 if ($message) {
3105 diag($message);
3106 $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg);
3107 }
3108 }
3109
3110 $file{needs_inc_ppport} = keys %{$file{uses}};
3111
3112 if ($file{needs_inc_ppport}) {
3113 my $pp = '';
3114
3115 for $func (sort keys %{$file{needs}}) {
3116 my $type = $file{needs}{$func};
3117 next if $type eq 'extern';
3118 my $suffix = $type eq 'global' ? '_GLOBAL' : '';
3119 unless (exists $file{"needed_$type"}{$func}) {
3120 if ($type eq 'global') {
3121 diag("Files [@{$global{needs}{$func}}] need $func, adding global request");
3122 }
3123 else {
3124 diag("File needs $func, adding static request");
3125 }
3126 $pp .= "#define NEED_$func$suffix\n";
3127 }
3128 }
3129
3130 if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) {
3131 $pp = '';
3132 $file{changes}++;
3133 }
3134
3135 unless ($file{has_inc_ppport}) {
3136 diag("Needs to include '$ppport'");
3137 $pp .= qq(#include "$ppport"\n)
3138 }
3139
3140 if ($pp) {
3141 $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms)
3142 || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m)
3143 || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m)
3144 || ($c =~ s/^/$pp/);
3145 }
3146 }
3147 else {
3148 if ($file{has_inc_ppport}) {
3149 diag("No need to include '$ppport'");
3150 $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m);
3151 }
3152 }
3153
3154 # put back in our C comments
3155 my $ix;
3156 my $cppc = 0;
3157 my @ccom = @{$file{ccom}};
3158 for $ix (0 .. $#ccom) {
3159 if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) {
3160 $cppc++;
3161 $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/;
3162 }
3163 else {
3164 $c =~ s/$rccs$ix$rcce/$ccom[$ix]/;
3165 }
3166 }
3167
3168 if ($cppc) {
3169 my $s = $cppc != 1 ? 's' : '';
3170 warning("Uses $cppc C++ style comment$s, which is not portable");
3171 }
3172
3173 my $s = $warnings != 1 ? 's' : '';
3174 my $warn = $warnings ? " ($warnings warning$s)" : '';
3175 info("Analysis completed$warn");
3176
3177 if ($file{changes}) {
3178 if (exists $opt{copy}) {
3179 my $newfile = "$filename$opt{copy}";
3180 if (-e $newfile) {
3181 error("'$newfile' already exists, refusing to write copy of '$filename'");
3182 }
3183 else {
3184 local *F;
3185 if (open F, ">$newfile") {
3186 info("Writing copy of '$filename' with changes to '$newfile'");
3187 print F $c;
3188 close F;
3189 }
3190 else {
3191 error("Cannot open '$newfile' for writing: $!");
3192 }
3193 }
3194 }
3195 elsif (exists $opt{patch} || $opt{changes}) {
3196 if (exists $opt{patch}) {
3197 unless ($patch_opened) {
3198 if (open PATCH, ">$opt{patch}") {
3199 $patch_opened = 1;
3200 }
3201 else {
3202 error("Cannot open '$opt{patch}' for writing: $!");
3203 delete $opt{patch};
3204 $opt{changes} = 1;
3205 goto fallback;
3206 }
3207 }
3208 mydiff(\*PATCH, $filename, $c);
3209 }
3210 else {
3211 fallback:
3212 info("Suggested changes:");
3213 mydiff(\*STDOUT, $filename, $c);
3214 }
3215 }
3216 else {
3217 my $s = $file{changes} == 1 ? '' : 's';
3218 info("$file{changes} potentially required change$s detected");
3219 }
3220 }
3221 else {
3222 info("Looks good");
3223 }
3224 }
3225
3226 close PATCH if $patch_opened;
3227
3228 exit 0;
3229
3230
3231 sub try_use { eval "use @_;"; return $@ eq '' }
3232
3233 sub mydiff
3234 {
3235 local *F = shift;
3236 my($file, $str) = @_;
3237 my $diff;
3238
3239 if (exists $opt{diff}) {
3240 $diff = run_diff($opt{diff}, $file, $str);
3241 }
3242
3243 if (!defined $diff and try_use('Text::Diff')) {
3244 $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
3245 $diff = <<HEADER . $diff;
3246 --- $file
3247 +++ $file.patched
3248 HEADER
3249 }
3250
3251 if (!defined $diff) {
3252 $diff = run_diff('diff -u', $file, $str);
3253 }
3254
3255 if (!defined $diff) {
3256 $diff = run_diff('diff', $file, $str);
3257 }
3258
3259 if (!defined $diff) {
3260 error("Cannot generate a diff. Please install Text::Diff or use --copy.");
3261 return;
3262 }
3263
3264 print F $diff;
3265 }
3266
3267 sub run_diff
3268 {
3269 my($prog, $file, $str) = @_;
3270 my $tmp = 'dppptemp';
3271 my $suf = 'aaa';
3272 my $diff = '';
3273 local *F;
3274
3275 while (-e "$tmp.$suf") { $suf++ }
3276 $tmp = "$tmp.$suf";
3277
3278 if (open F, ">$tmp") {
3279 print F $str;
3280 close F;
3281
3282 if (open F, "$prog $file $tmp |") {
3283 while (<F>) {
3284 s/\Q$tmp\E/$file.patched/;
3285 $diff .= $_;
3286 }
3287 close F;
3288 unlink $tmp;
3289 return $diff;
3290 }
3291
3292 unlink $tmp;
3293 }
3294 else {
3295 error("Cannot open '$tmp' for writing: $!");
3296 }
3297
3298 return undef;
3299 }
3300
3301 sub rec_depend
3302 {
3303 my($func, $seen) = @_;
3304 return () unless exists $depends{$func};
3305 $seen = {%{$seen||{}}};
3306 return () if $seen->{$func}++;
3307 my %s;
3308 grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
3309 }
3310
3311 sub parse_version
3312 {
3313 my $ver = shift;
3314
3315 if ($ver =~ /^(\d+)\.(\d+)\.(\d+)$/) {
3316 return ($1, $2, $3);
3317 }
3318 elsif ($ver !~ /^\d+\.[\d_]+$/) {
3319 die "cannot parse version '$ver'\n";
3320 }
3321
3322 $ver =~ s/_//g;
3323 $ver =~ s/$/000000/;
3324
3325 my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
3326
3327 $v = int $v;
3328 $s = int $s;
3329
3330 if ($r < 5 || ($r == 5 && $v < 6)) {
3331 if ($s % 10) {
3332 die "cannot parse version '$ver'\n";
3333 }
3334 }
3335
3336 return ($r, $v, $s);
3337 }
3338
3339 sub format_version
3340 {
3341 my $ver = shift;
3342
3343 $ver =~ s/$/000000/;
3344 my($r,$v,$s) = $ver =~ /(\d+)\.(\d{3})(\d{3})/;
3345
3346 $v = int $v;
3347 $s = int $s;
3348
3349 if ($r < 5 || ($r == 5 && $v < 6)) {
3350 if ($s % 10) {
3351 die "invalid version '$ver'\n";
3352 }
3353 $s /= 10;
3354
3355 $ver = sprintf "%d.%03d", $r, $v;
3356 $s > 0 and $ver .= sprintf "_%02d", $s;
3357
3358 return $ver;
3359 }
3360
3361 return sprintf "%d.%d.%d", $r, $v, $s;
3362 }
3363
3364 sub info
3365 {
3366 $opt{quiet} and return;
3367 print @_, "\n";
3368 }
3369
3370 sub diag
3371 {
3372 $opt{quiet} and return;
3373 $opt{diag} and print @_, "\n";
3374 }
3375
3376 sub warning
3377 {
3378 $opt{quiet} and return;
3379 print "*** ", @_, "\n";
3380 }
3381
3382 sub error
3383 {
3384 print "*** ERROR: ", @_, "\n";
3385 }
3386
3387 my %given_hints;
3388 my %given_warnings;
3389 sub hint
3390 {
3391 $opt{quiet} and return;
3392 my $func = shift;
3393 my $rv = 0;
3394 if (exists $warnings{$func} && !$given_warnings{$func}++) {
3395 my $warn = $warnings{$func};
3396 $warn =~ s!^!*** !mg;
3397 print "*** WARNING: $func\n", $warn;
3398 $rv++;
3399 }
3400 if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
3401 my $hint = $hints{$func};
3402 $hint =~ s/^/ /mg;
3403 print " --- hint for $func ---\n", $hint;
3404 }
3405 $rv;
3406 }
3407
3408 sub usage
3409 {
3410 my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
3411 my %M = ( 'I' => '*' );
3412 $usage =~ s/^\s*perl\s+\S+/$^X $0/;
3413 $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;
3414
3415 print <<ENDUSAGE;
3416
3417 Usage: $usage
3418
3419 See perldoc $0 for details.
3420
3421 ENDUSAGE
3422
3423 exit 2;
3424 }
3425
3426 sub strip
3427 {
3428 my $self = do { local(@ARGV,$/)=($0); <> };
3429 my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms;
3430 $copy =~ s/^(?=\S+)/ /gms;
3431 $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms;
3432 $self =~ s/^SKIP.*(?=^__DATA__)/SKIP
3433 if (\@ARGV && \$ARGV[0] eq '--unstrip') {
3434 eval { require Devel::PPPort };
3435 \$@ and die "Cannot require Devel::PPPort, please install.\\n";
3436 if (eval \$Devel::PPPort::VERSION < $VERSION) {
3437 die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
3438 . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
3439 . "Please install a newer version, or --unstrip will not work.\\n";
3440 }
3441 Devel::PPPort::WriteFile(\$0);
3442 exit 0;
3443 }
3444 print <<END;
3445
3446 Sorry, but this is a stripped version of \$0.
3447
3448 To be able to use its original script and doc functionality,
3449 please try to regenerate this file using:
3450
3451 \$^X \$0 --unstrip
3452
3453 END
3454 /ms;
3455 my($pl, $c) = $self =~ /(.*^__DATA__)(.*)/ms;
3456 $c =~ s{
3457 / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*)
3458 | ( "[^"\\]*(?:\\.[^"\\]*)*"
3459 | '[^'\\]*(?:\\.[^'\\]*)*' )
3460 | ($HS+) }{ defined $2 ? ' ' : ($1 || '') }gsex;
3461 $c =~ s!\s+$!!mg;
3462 $c =~ s!^$LF!!mg;
3463 $c =~ s!^\s*#\s*!#!mg;
3464 $c =~ s!^\s+!!mg;
3465
3466 open OUT, ">$0" or die "cannot strip $0: $!\n";
3467 print OUT "$pl$c\n";
3468
3469 exit 0;
3470 }
3471
3472 __DATA__
3473 */
3474
3475 #ifndef _P_P_PORTABILITY_H_
3476 #define _P_P_PORTABILITY_H_
3477
3478 #ifndef DPPP_NAMESPACE
3479 # define DPPP_NAMESPACE DPPP_
3480 #endif
3481
3482 #define DPPP_CAT2(x,y) CAT2(x,y)
3483 #define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name)
3484
3485 #ifndef PERL_REVISION
3486 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
3487 # define PERL_PATCHLEVEL_H_IMPLICIT
3488 # include <patchlevel.h>
3489 # endif
3490 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
3491 # include <could_not_find_Perl_patchlevel.h>
3492 # endif
3493 # ifndef PERL_REVISION
3494 # define PERL_REVISION (5)
3495 /* Replace: 1 */
3496 # define PERL_VERSION PATCHLEVEL
3497 # define PERL_SUBVERSION SUBVERSION
3498 /* Replace PERL_PATCHLEVEL with PERL_VERSION */
3499 /* Replace: 0 */
3500 # endif
3501 #endif
3502
3503 #define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
3504 #define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
3505
3506 /* It is very unlikely that anyone will try to use this with Perl 6
3507 (or greater), but who knows.
3508 */
3509 #if PERL_REVISION != 5
3510 # error ppport.h only works with Perl version 5
3511 #endif /* PERL_REVISION != 5 */
3512 #ifndef dTHR
3513 # define dTHR dNOOP
3514 #endif
3515 #ifndef dTHX
3516 # define dTHX dNOOP
3517 #endif
3518
3519 #ifndef dTHXa
3520 # define dTHXa(x) dNOOP
3521 #endif
3522 #ifndef pTHX
3523 # define pTHX void
3524 #endif
3525
3526 #ifndef pTHX_
3527 # define pTHX_
3528 #endif
3529
3530 #ifndef aTHX
3531 # define aTHX
3532 #endif
3533
3534 #ifndef aTHX_
3535 # define aTHX_
3536 #endif
3537
3538 #if (PERL_BCDVERSION < 0x5006000)
3539 # ifdef USE_THREADS
3540 # define aTHXR thr
3541 # define aTHXR_ thr,
3542 # else
3543 # define aTHXR
3544 # define aTHXR_
3545 # endif
3546 # define dTHXR dTHR
3547 #else
3548 # define aTHXR aTHX
3549 # define aTHXR_ aTHX_
3550 # define dTHXR dTHX
3551 #endif
3552 #ifndef dTHXoa
3553 # define dTHXoa(x) dTHXa(x)
3554 #endif
3555
3556 #ifdef I_LIMITS
3557 # include <limits.h>
3558 #endif
3559
3560 #ifndef PERL_UCHAR_MIN
3561 # define PERL_UCHAR_MIN ((unsigned char)0)
3562 #endif
3563
3564 #ifndef PERL_UCHAR_MAX
3565 # ifdef UCHAR_MAX
3566 # define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX)
3567 # else
3568 # ifdef MAXUCHAR
3569 # define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR)
3570 # else
3571 # define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0)
3572 # endif
3573 # endif
3574 #endif
3575
3576 #ifndef PERL_USHORT_MIN
3577 # define PERL_USHORT_MIN ((unsigned short)0)
3578 #endif
3579
3580 #ifndef PERL_USHORT_MAX
3581 # ifdef USHORT_MAX
3582 # define PERL_USHORT_MAX ((unsigned short)USHORT_MAX)
3583 # else
3584 # ifdef MAXUSHORT
3585 # define PERL_USHORT_MAX ((unsigned short)MAXUSHORT)
3586 # else
3587 # ifdef USHRT_MAX
3588 # define PERL_USHORT_MAX ((unsigned short)USHRT_MAX)
3589 # else
3590 # define PERL_USHORT_MAX ((unsigned short)~(unsigned)0)
3591 # endif
3592 # endif
3593 # endif
3594 #endif
3595
3596 #ifndef PERL_SHORT_MAX
3597 # ifdef SHORT_MAX
3598 # define PERL_SHORT_MAX ((short)SHORT_MAX)
3599 # else
3600 # ifdef MAXSHORT /* Often used in <values.h> */
3601 # define PERL_SHORT_MAX ((short)MAXSHORT)
3602 # else
3603 # ifdef SHRT_MAX
3604 # define PERL_SHORT_MAX ((short)SHRT_MAX)
3605 # else
3606 # define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1))
3607 # endif
3608 # endif
3609 # endif
3610 #endif
3611
3612 #ifndef PERL_SHORT_MIN
3613 # ifdef SHORT_MIN
3614 # define PERL_SHORT_MIN ((short)SHORT_MIN)
3615 # else
3616 # ifdef MINSHORT
3617 # define PERL_SHORT_MIN ((short)MINSHORT)
3618 # else
3619 # ifdef SHRT_MIN
3620 # define PERL_SHORT_MIN ((short)SHRT_MIN)
3621 # else
3622 # define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3))
3623 # endif
3624 # endif
3625 # endif
3626 #endif
3627
3628 #ifndef PERL_UINT_MAX
3629 # ifdef UINT_MAX
3630 # define PERL_UINT_MAX ((unsigned int)UINT_MAX)
3631 # else
3632 # ifdef MAXUINT
3633 # define PERL_UINT_MAX ((unsigned int)MAXUINT)
3634 # else
3635 # define PERL_UINT_MAX (~(unsigned int)0)
3636 # endif
3637 # endif
3638 #endif
3639
3640 #ifndef PERL_UINT_MIN
3641 # define PERL_UINT_MIN ((unsigned int)0)
3642 #endif
3643
3644 #ifndef PERL_INT_MAX
3645 # ifdef INT_MAX
3646 # define PERL_INT_MAX ((int)INT_MAX)
3647 # else
3648 # ifdef MAXINT /* Often used in <values.h> */
3649 # define PERL_INT_MAX ((int)MAXINT)
3650 # else
3651 # define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1))
3652 # endif
3653 # endif
3654 #endif
3655
3656 #ifndef PERL_INT_MIN
3657 # ifdef INT_MIN
3658 # define PERL_INT_MIN ((int)INT_MIN)
3659 # else
3660 # ifdef MININT
3661 # define PERL_INT_MIN ((int)MININT)
3662 # else
3663 # define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3))
3664 # endif
3665 # endif
3666 #endif
3667
3668 #ifndef PERL_ULONG_MAX
3669 # ifdef ULONG_MAX
3670 # define PERL_ULONG_MAX ((unsigned long)ULONG_MAX)
3671 # else
3672 # ifdef MAXULONG
3673 # define PERL_ULONG_MAX ((unsigned long)MAXULONG)
3674 # else
3675 # define PERL_ULONG_MAX (~(unsigned long)0)
3676 # endif
3677 # endif
3678 #endif
3679
3680 #ifndef PERL_ULONG_MIN
3681 # define PERL_ULONG_MIN ((unsigned long)0L)
3682 #endif
3683
3684 #ifndef PERL_LONG_MAX
3685 # ifdef LONG_MAX
3686 # define PERL_LONG_MAX ((long)LONG_MAX)
3687 # else
3688 # ifdef MAXLONG
3689 # define PERL_LONG_MAX ((long)MAXLONG)
3690 # else
3691 # define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1))
3692 # endif
3693 # endif
3694 #endif
3695
3696 #ifndef PERL_LONG_MIN
3697 # ifdef LONG_MIN
3698 # define PERL_LONG_MIN ((long)LONG_MIN)
3699 # else
3700 # ifdef MINLONG
3701 # define PERL_LONG_MIN ((long)MINLONG)
3702 # else
3703 # define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3))
3704 # endif
3705 # endif
3706 #endif
3707
3708 #if defined(HAS_QUAD) && (defined(convex) || defined(uts))
3709 # ifndef PERL_UQUAD_MAX
3710 # ifdef ULONGLONG_MAX
3711 # define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX)
3712 # else
3713 # ifdef MAXULONGLONG
3714 # define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG)
3715 # else
3716 # define PERL_UQUAD_MAX (~(unsigned long long)0)
3717 # endif
3718 # endif
3719 # endif
3720
3721 # ifndef PERL_UQUAD_MIN
3722 # define PERL_UQUAD_MIN ((unsigned long long)0L)
3723 # endif
3724
3725 # ifndef PERL_QUAD_MAX
3726 # ifdef LONGLONG_MAX
3727 # define PERL_QUAD_MAX ((long long)LONGLONG_MAX)
3728 # else
3729 # ifdef MAXLONGLONG
3730 # define PERL_QUAD_MAX ((long long)MAXLONGLONG)
3731 # else
3732 # define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1))
3733 # endif
3734 # endif
3735 # endif
3736
3737 # ifndef PERL_QUAD_MIN
3738 # ifdef LONGLONG_MIN
3739 # define PERL_QUAD_MIN ((long long)LONGLONG_MIN)
3740 # else
3741 # ifdef MINLONGLONG
3742 # define PERL_QUAD_MIN ((long long)MINLONGLONG)
3743 # else
3744 # define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3))
3745 # endif
3746 # endif
3747 # endif
3748 #endif
3749
3750 /* This is based on code from 5.003 perl.h */
3751 #ifdef HAS_QUAD
3752 # ifdef cray
3753 #ifndef IVTYPE
3754 # define IVTYPE int
3755 #endif
3756
3757 #ifndef IV_MIN
3758 # define IV_MIN PERL_INT_MIN
3759 #endif
3760
3761 #ifndef IV_MAX
3762 # define IV_MAX PERL_INT_MAX
3763 #endif
3764
3765 #ifndef UV_MIN
3766 # define UV_MIN PERL_UINT_MIN
3767 #endif
3768
3769 #ifndef UV_MAX
3770 # define UV_MAX PERL_UINT_MAX
3771 #endif
3772
3773 # ifdef INTSIZE
3774 #ifndef IVSIZE
3775 # define IVSIZE INTSIZE
3776 #endif
3777
3778 # endif
3779 # else
3780 # if defined(convex) || defined(uts)
3781 #ifndef IVTYPE
3782 # define IVTYPE long long
3783 #endif
3784
3785 #ifndef IV_MIN
3786 # define IV_MIN PERL_QUAD_MIN
3787 #endif
3788
3789 #ifndef IV_MAX
3790 # define IV_MAX PERL_QUAD_MAX
3791 #endif
3792
3793 #ifndef UV_MIN
3794 # define UV_MIN PERL_UQUAD_MIN
3795 #endif
3796
3797 #ifndef UV_MAX
3798 # define UV_MAX PERL_UQUAD_MAX
3799 #endif
3800
3801 # ifdef LONGLONGSIZE
3802 #ifndef IVSIZE
3803 # define IVSIZE LONGLONGSIZE
3804 #endif
3805
3806 # endif
3807 # else
3808 #ifndef IVTYPE
3809 # define IVTYPE long
3810 #endif
3811
3812 #ifndef IV_MIN
3813 # define IV_MIN PERL_LONG_MIN
3814 #endif
3815
3816 #ifndef IV_MAX
3817 # define IV_MAX PERL_LONG_MAX
3818 #endif
3819
3820 #ifndef UV_MIN
3821 # define UV_MIN PERL_ULONG_MIN
3822 #endif
3823
3824 #ifndef UV_MAX
3825 # define UV_MAX PERL_ULONG_MAX
3826 #endif
3827
3828 # ifdef LONGSIZE
3829 #ifndef IVSIZE
3830 # define IVSIZE LONGSIZE
3831 #endif
3832
3833 # endif
3834 # endif
3835 # endif
3836 #ifndef IVSIZE
3837 # define IVSIZE 8
3838 #endif
3839
3840 #ifndef LONGSIZE
3841 # define LONGSIZE 8
3842 #endif
3843
3844 #ifndef PERL_QUAD_MIN
3845 # define PERL_QUAD_MIN IV_MIN
3846 #endif
3847
3848 #ifndef PERL_QUAD_MAX
3849 # define PERL_QUAD_MAX IV_MAX
3850 #endif
3851
3852 #ifndef PERL_UQUAD_MIN
3853 # define PERL_UQUAD_MIN UV_MIN
3854 #endif
3855
3856 #ifndef PERL_UQUAD_MAX
3857 # define PERL_UQUAD_MAX UV_MAX
3858 #endif
3859
3860 #else
3861 #ifndef IVTYPE
3862 # define IVTYPE long
3863 #endif
3864
3865 #ifndef LONGSIZE
3866 # define LONGSIZE 4
3867 #endif
3868
3869 #ifndef IV_MIN
3870 # define IV_MIN PERL_LONG_MIN
3871 #endif
3872
3873 #ifndef IV_MAX
3874 # define IV_MAX PERL_LONG_MAX
3875 #endif
3876
3877 #ifndef UV_MIN
3878 # define UV_MIN PERL_ULONG_MIN
3879 #endif
3880
3881 #ifndef UV_MAX
3882 # define UV_MAX PERL_ULONG_MAX
3883 #endif
3884
3885 #endif
3886
3887 #ifndef IVSIZE
3888 # ifdef LONGSIZE
3889 # define IVSIZE LONGSIZE
3890 # else
3891 # define IVSIZE 4 /* A bold guess, but the best we can make. */
3892 # endif
3893 #endif
3894 #ifndef UVTYPE
3895 # define UVTYPE unsigned IVTYPE
3896 #endif
3897
3898 #ifndef UVSIZE
3899 # define UVSIZE IVSIZE
3900 #endif
3901 #ifndef sv_setuv
3902 # define sv_setuv(sv, uv) \
3903 STMT_START { \
3904 UV TeMpUv = uv; \
3905 if (TeMpUv <= IV_MAX) \
3906 sv_setiv(sv, TeMpUv); \
3907 else \
3908 sv_setnv(sv, (double)TeMpUv); \
3909 } STMT_END
3910 #endif
3911 #ifndef newSVuv
3912 # define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv))
3913 #endif
3914 #ifndef sv_2uv
3915 # define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv)))
3916 #endif
3917
3918 #ifndef SvUVX
3919 # define SvUVX(sv) ((UV)SvIVX(sv))
3920 #endif
3921
3922 #ifndef SvUVXx
3923 # define SvUVXx(sv) SvUVX(sv)
3924 #endif
3925
3926 #ifndef SvUV
3927 # define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv))
3928 #endif
3929
3930 #ifndef SvUVx
3931 # define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv))
3932 #endif
3933
3934 /* Hint: sv_uv
3935 * Always use the SvUVx() macro instead of sv_uv().
3936 */
3937 #ifndef sv_uv
3938 # define sv_uv(sv) SvUVx(sv)
3939 #endif
3940
3941 #if !defined(SvUOK) && defined(SvIOK_UV)
3942 # define SvUOK(sv) SvIOK_UV(sv)
3943 #endif
3944 #ifndef XST_mUV
3945 # define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
3946 #endif
3947
3948 #ifndef XSRETURN_UV
3949 # define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
3950 #endif
3951 #ifndef PUSHu
3952 # define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
3953 #endif
3954
3955 #ifndef XPUSHu
3956 # define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
3957 #endif
3958
3959 #ifdef HAS_MEMCMP
3960 #ifndef memNE
3961 # define memNE(s1,s2,l) (memcmp(s1,s2,l))
3962 #endif
3963
3964 #ifndef memEQ
3965 # define memEQ(s1,s2,l) (!memcmp(s1,s2,l))
3966 #endif
3967
3968 #else
3969 #ifndef memNE
3970 # define memNE(s1,s2,l) (bcmp(s1,s2,l))
3971 #endif
3972
3973 #ifndef memEQ
3974 # define memEQ(s1,s2,l) (!bcmp(s1,s2,l))
3975 #endif
3976
3977 #endif
3978 #ifndef memEQs
3979 # define memEQs(s1, l, s2) \
3980 (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
3981 #endif
3982
3983 #ifndef memNEs
3984 # define memNEs(s1, l, s2) !memEQs(s1, l, s2)
3985 #endif
3986 #ifndef MoveD
3987 # define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t))
3988 #endif
3989
3990 #ifndef CopyD
3991 # define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t))
3992 #endif
3993
3994 #ifdef HAS_MEMSET
3995 #ifndef ZeroD
3996 # define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t))
3997 #endif
3998
3999 #else
4000 #ifndef ZeroD
4001 # define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d)
4002 #endif
4003
4004 #endif
4005 #ifndef PoisonWith
4006 # define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t))
4007 #endif
4008
4009 #ifndef PoisonNew
4010 # define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB)
4011 #endif
4012
4013 #ifndef PoisonFree
4014 # define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF)
4015 #endif
4016
4017 #ifndef Poison
4018 # define Poison(d,n,t) PoisonFree(d,n,t)
4019 #endif
4020 #ifndef Newx
4021 # define Newx(v,n,t) New(0,v,n,t)
4022 #endif
4023
4024 #ifndef Newxc
4025 # define Newxc(v,n,t,c) Newc(0,v,n,t,c)
4026 #endif
4027
4028 #ifndef Newxz
4029 # define Newxz(v,n,t) Newz(0,v,n,t)
4030 #endif
4031
4032 #ifndef PERL_UNUSED_DECL
4033 # ifdef HASATTRIBUTE
4034 # if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER)
4035 # define PERL_UNUSED_DECL
4036 # else
4037 # define PERL_UNUSED_DECL __attribute__((unused))
4038 # endif
4039 # else
4040 # define PERL_UNUSED_DECL
4041 # endif
4042 #endif
4043
4044 #ifndef PERL_UNUSED_ARG
4045 # if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */
4046 # include <note.h>
4047 # define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x))
4048 # else
4049 # define PERL_UNUSED_ARG(x) ((void)x)
4050 # endif
4051 #endif
4052
4053 #ifndef PERL_UNUSED_VAR
4054 # define PERL_UNUSED_VAR(x) ((void)x)
4055 #endif
4056
4057 #ifndef PERL_UNUSED_CONTEXT
4058 # ifdef USE_ITHREADS
4059 # define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl)
4060 # else
4061 # define PERL_UNUSED_CONTEXT
4062 # endif
4063 #endif
4064 #ifndef NOOP
4065 # define NOOP /*EMPTY*/(void)0
4066 #endif
4067
4068 #ifndef dNOOP
4069 # define dNOOP extern int /*@unused@*/ Perl___notused PERL_UNUSED_DECL
4070 #endif
4071
4072 #ifndef NVTYPE
4073 # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE)
4074 # define NVTYPE long double
4075 # else
4076 # define NVTYPE double
4077 # endif
4078 typedef NVTYPE NV;
4079 #endif
4080
4081 #ifndef INT2PTR
4082 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
4083 # define PTRV UV
4084 # define INT2PTR(any,d) (any)(d)
4085 # else
4086 # if PTRSIZE == LONGSIZE
4087 # define PTRV unsigned long
4088 # else
4089 # define PTRV unsigned
4090 # endif
4091 # define INT2PTR(any,d) (any)(PTRV)(d)
4092 # endif
4093 #endif
4094
4095 #ifndef PTR2ul
4096 # if PTRSIZE == LONGSIZE
4097 # define PTR2ul(p) (unsigned long)(p)
4098 # else
4099 # define PTR2ul(p) INT2PTR(unsigned long,p)
4100 # endif
4101 #endif
4102 #ifndef PTR2nat
4103 # define PTR2nat(p) (PTRV)(p)
4104 #endif
4105
4106 #ifndef NUM2PTR
4107 # define NUM2PTR(any,d) (any)PTR2nat(d)
4108 #endif
4109
4110 #ifndef PTR2IV
4111 # define PTR2IV(p) INT2PTR(IV,p)
4112 #endif
4113
4114 #ifndef PTR2UV
4115 # define PTR2UV(p) INT2PTR(UV,p)
4116 #endif
4117
4118 #ifndef PTR2NV
4119 # define PTR2NV(p) NUM2PTR(NV,p)
4120 #endif
4121
4122 #undef START_EXTERN_C
4123 #undef END_EXTERN_C
4124 #undef EXTERN_C
4125 #ifdef __cplusplus
4126 # define START_EXTERN_C extern "C" {
4127 # define END_EXTERN_C }
4128 # define EXTERN_C extern "C"
4129 #else
4130 # define START_EXTERN_C
4131 # define END_EXTERN_C
4132 # define EXTERN_C extern
4133 #endif
4134
4135 #if defined(PERL_GCC_PEDANTIC)
4136 # ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN
4137 # define PERL_GCC_BRACE_GROUPS_FORBIDDEN
4138 # endif
4139 #endif
4140
4141 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) && !defined(__cplusplus)
4142 # ifndef PERL_USE_GCC_BRACE_GROUPS
4143 # define PERL_USE_GCC_BRACE_GROUPS
4144 # endif
4145 #endif
4146
4147 #undef STMT_START
4148 #undef STMT_END
4149 #ifdef PERL_USE_GCC_BRACE_GROUPS
4150 # define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */
4151 # define STMT_END )
4152 #else
4153 # if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__)
4154 # define STMT_START if (1)
4155 # define STMT_END else (void)0
4156 # else
4157 # define STMT_START do
4158 # define STMT_END while (0)
4159 # endif
4160 #endif
4161 #ifndef boolSV
4162 # define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
4163 #endif
4164
4165 /* DEFSV appears first in 5.004_56 */
4166 #ifndef DEFSV
4167 # define DEFSV GvSV(PL_defgv)
4168 #endif
4169
4170 #ifndef SAVE_DEFSV
4171 # define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
4172 #endif
4173
4174 #ifndef DEFSV_set
4175 # define DEFSV_set(sv) (DEFSV = (sv))
4176 #endif
4177
4178 /* Older perls (<=5.003) lack AvFILLp */
4179 #ifndef AvFILLp
4180 # define AvFILLp AvFILL
4181 #endif
4182 #ifndef ERRSV
4183 # define ERRSV get_sv("@",FALSE)
4184 #endif
4185
4186 /* Hint: gv_stashpvn
4187 * This function's backport doesn't support the length parameter, but
4188 * rather ignores it. Portability can only be ensured if the length
4189 * parameter is used for speed reasons, but the length can always be
4190 * correctly computed from the string argument.
4191 */
4192 #ifndef gv_stashpvn
4193 # define gv_stashpvn(str,len,create) gv_stashpv(str,create)
4194 #endif
4195
4196 /* Replace: 1 */
4197 #ifndef get_cv
4198 # define get_cv perl_get_cv
4199 #endif
4200
4201 #ifndef get_sv
4202 # define get_sv perl_get_sv
4203 #endif
4204
4205 #ifndef get_av
4206 # define get_av perl_get_av
4207 #endif
4208
4209 #ifndef get_hv
4210 # define get_hv perl_get_hv
4211 #endif
4212
4213 /* Replace: 0 */
4214 #ifndef dUNDERBAR
4215 # define dUNDERBAR dNOOP
4216 #endif
4217
4218 #ifndef UNDERBAR
4219 # define UNDERBAR DEFSV
4220 #endif
4221 #ifndef dAX
4222 # define dAX I32 ax = MARK - PL_stack_base + 1
4223 #endif
4224
4225 #ifndef dITEMS
4226 # define dITEMS I32 items = SP - MARK
4227 #endif
4228 #ifndef dXSTARG
4229 # define dXSTARG SV * targ = sv_newmortal()
4230 #endif
4231 #ifndef dAXMARK
4232 # define dAXMARK I32 ax = POPMARK; \
4233 register SV ** const mark = PL_stack_base + ax++
4234 #endif
4235 #ifndef XSprePUSH
4236 # define XSprePUSH (sp = PL_stack_base + ax - 1)
4237 #endif
4238
4239 #if (PERL_BCDVERSION < 0x5005000)
4240 # undef XSRETURN
4241 # define XSRETURN(off) \
4242 STMT_START { \
4243 PL_stack_sp = PL_stack_base + ax + ((off) - 1); \
4244 return; \
4245 } STMT_END
4246 #endif
4247 #ifndef XSPROTO
4248 # define XSPROTO(name) void name(pTHX_ CV* cv)
4249 #endif
4250
4251 #ifndef SVfARG
4252 # define SVfARG(p) ((void*)(p))
4253 #endif
4254 #ifndef PERL_ABS
4255 # define PERL_ABS(x) ((x) < 0 ? -(x) : (x))
4256 #endif
4257 #ifndef dVAR
4258 # define dVAR dNOOP
4259 #endif
4260 #ifndef SVf
4261 # define SVf "_"
4262 #endif
4263 #ifndef UTF8_MAXBYTES
4264 # define UTF8_MAXBYTES UTF8_MAXLEN
4265 #endif
4266 #ifndef CPERLscope
4267 # define CPERLscope(x) x
4268 #endif
4269 #ifndef PERL_HASH
4270 # define PERL_HASH(hash,str,len) \
4271 STMT_START { \
4272 const char *s_PeRlHaSh = str; \
4273 I32 i_PeRlHaSh = len; \
4274 U32 hash_PeRlHaSh = 0; \
4275 while (i_PeRlHaSh--) \
4276 hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
4277 (hash) = hash_PeRlHaSh; \
4278 } STMT_END
4279 #endif
4280
4281 #ifndef PERLIO_FUNCS_DECL
4282 # ifdef PERLIO_FUNCS_CONST
4283 # define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
4284 # define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
4285 # else
4286 # define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs
4287 # define PERLIO_FUNCS_CAST(funcs) (funcs)
4288 # endif
4289 #endif
4290
4291 /* provide these typedefs for older perls */
4292 #if (PERL_BCDVERSION < 0x5009003)
4293
4294 # ifdef ARGSproto
4295 typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);
4296 # else
4297 typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
4298 # endif
4299
4300 typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*);
4301
4302 #endif
4303 #ifndef isPSXSPC
4304 # define isPSXSPC(c) (isSPACE(c) || (c) == '\v')
4305 #endif
4306
4307 #ifndef isBLANK
4308 # define isBLANK(c) ((c) == ' ' || (c) == '\t')
4309 #endif
4310
4311 #ifdef EBCDIC
4312 #ifndef isALNUMC
4313 # define isALNUMC(c) isalnum(c)
4314 #endif
4315
4316 #ifndef isASCII
4317 # define isASCII(c) isascii(c)
4318 #endif
4319
4320 #ifndef isCNTRL
4321 # define isCNTRL(c) iscntrl(c)
4322 #endif
4323
4324 #ifndef isGRAPH
4325 # define isGRAPH(c) isgraph(c)
4326 #endif
4327
4328 #ifndef isPRINT
4329 # define isPRINT(c) isprint(c)
4330 #endif
4331
4332 #ifndef isPUNCT
4333 # define isPUNCT(c) ispunct(c)
4334 #endif
4335
4336 #ifndef isXDIGIT
4337 # define isXDIGIT(c) isxdigit(c)
4338 #endif
4339
4340 #else
4341 # if (PERL_BCDVERSION < 0x5010000)
4342 /* Hint: isPRINT
4343 * The implementation in older perl versions includes all of the
4344 * isSPACE() characters, which is wrong. The version provided by
4345 * Devel::PPPort always overrides a present buggy version.
4346 */
4347 # undef isPRINT
4348 # endif
4349 #ifndef isALNUMC
4350 # define isALNUMC(c) (isALPHA(c) || isDIGIT(c))
4351 #endif
4352
4353 #ifndef isASCII
4354 # define isASCII(c) ((U8) (c) <= 127)
4355 #endif
4356
4357 #ifndef isCNTRL
4358 # define isCNTRL(c) ((U8) (c) < ' ' || (c) == 127)
4359 #endif
4360
4361 #ifndef isGRAPH
4362 # define isGRAPH(c) (isALNUM(c) || isPUNCT(c))
4363 #endif
4364
4365 #ifndef isPRINT
4366 # define isPRINT(c) (((c) >= 32 && (c) < 127))
4367 #endif
4368
4369 #ifndef isPUNCT
4370 # define isPUNCT(c) (((c) >= 33 && (c) <= 47) || ((c) >= 58 && (c) <= 64) || ((c) >= 91 && (c) <= 96) || ((c) >= 123 && (c) <= 126))
4371 #endif
4372
4373 #ifndef isXDIGIT
4374 # define isXDIGIT(c) (isDIGIT(c) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
4375 #endif
4376
4377 #endif
4378
4379 #ifndef PERL_SIGNALS_UNSAFE_FLAG
4380
4381 #define PERL_SIGNALS_UNSAFE_FLAG 0x0001
4382
4383 #if (PERL_BCDVERSION < 0x5008000)
4384 # define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG
4385 #else
4386 # define D_PPP_PERL_SIGNALS_INIT 0
4387 #endif
4388
4389 #if defined(NEED_PL_signals)
4390 static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4391 #elif defined(NEED_PL_signals_GLOBAL)
4392 U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
4393 #else
4394 extern U32 DPPP_(my_PL_signals);
4395 #endif
4396 #define PL_signals DPPP_(my_PL_signals)
4397
4398 #endif
4399
4400 /* Hint: PL_ppaddr
4401 * Calling an op via PL_ppaddr requires passing a context argument
4402 * for threaded builds. Since the context argument is different for
4403 * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
4404 * automatically be defined as the correct argument.
4405 */
4406
4407 #if (PERL_BCDVERSION <= 0x5005005)
4408 /* Replace: 1 */
4409 # define PL_ppaddr ppaddr
4410 # define PL_no_modify no_modify
4411 /* Replace: 0 */
4412 #endif
4413
4414 #if (PERL_BCDVERSION <= 0x5004005)
4415 /* Replace: 1 */
4416 # define PL_DBsignal DBsignal
4417 # define PL_DBsingle DBsingle
4418 # define PL_DBsub DBsub
4419 # define PL_DBtrace DBtrace
4420 # define PL_Sv Sv
4421 # define PL_bufend bufend
4422 # define PL_bufptr bufptr
4423 # define PL_compiling compiling
4424 # define PL_copline copline
4425 # define PL_curcop curcop
4426 # define PL_curstash curstash
4427 # define PL_debstash debstash
4428 # define PL_defgv defgv
4429 # define PL_diehook diehook
4430 # define PL_dirty dirty
4431 # define PL_dowarn dowarn
4432 # define PL_errgv errgv
4433 # define PL_error_count error_count
4434 # define PL_expect expect
4435 # define PL_hexdigit hexdigit
4436 # define PL_hints hints
4437 # define PL_in_my in_my
4438 # define PL_laststatval laststatval
4439 # define PL_lex_state lex_state
4440 # define PL_lex_stuff lex_stuff
4441 # define PL_linestr linestr
4442 # define PL_na na
4443 # define PL_perl_destruct_level perl_destruct_level
4444 # define PL_perldb perldb
4445 # define PL_rsfp_filters rsfp_filters
4446 # define PL_rsfp rsfp
4447 # define PL_stack_base stack_base
4448 # define PL_stack_sp stack_sp
4449 # define PL_statcache statcache
4450 # define PL_stdingv stdingv
4451 # define PL_sv_arenaroot sv_arenaroot
4452 # define PL_sv_no sv_no
4453 # define PL_sv_undef sv_undef
4454 # define PL_sv_yes sv_yes
4455 # define PL_tainted tainted
4456 # define PL_tainting tainting
4457 # define PL_tokenbuf tokenbuf
4458 /* Replace: 0 */
4459 #endif
4460
4461 /* Warning: PL_parser
4462 * For perl versions earlier than 5.9.5, this is an always
4463 * non-NULL dummy. Also, it cannot be dereferenced. Don't
4464 * use it if you can avoid is and unless you absolutely know
4465 * what you're doing.
4466 * If you always check that PL_parser is non-NULL, you can
4467 * define DPPP_PL_parser_NO_DUMMY to avoid the creation of
4468 * a dummy parser structure.
4469 */
4470
4471 #if (PERL_BCDVERSION >= 0x5009005)
4472 # ifdef DPPP_PL_parser_NO_DUMMY
4473 # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4474 (croak("panic: PL_parser == NULL in %s:%d", \
4475 __FILE__, __LINE__), (yy_parser *) NULL))->var)
4476 # else
4477 # ifdef DPPP_PL_parser_NO_DUMMY_WARNING
4478 # define D_PPP_parser_dummy_warning(var)
4479 # else
4480 # define D_PPP_parser_dummy_warning(var) \
4481 warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
4482 # endif
4483 # define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
4484 (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
4485 #if defined(NEED_PL_parser)
4486 static yy_parser DPPP_(dummy_PL_parser);
4487 #elif defined(NEED_PL_parser_GLOBAL)
4488 yy_parser DPPP_(dummy_PL_parser);
4489 #else
4490 extern yy_parser DPPP_(dummy_PL_parser);
4491 #endif
4492
4493 # endif
4494
4495 /* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */
4496 /* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
4497 * Do not use this variable unless you know exactly what you're
4498 * doint. It is internal to the perl parser and may change or even
4499 * be removed in the future. As of perl 5.9.5, you have to check
4500 * for (PL_parser != NULL) for this variable to have any effect.
4501 * An always non-NULL PL_parser dummy is provided for earlier
4502 * perl versions.
4503 * If PL_parser is NULL when you try to access this variable, a
4504 * dummy is being accessed instead and a warning is issued unless
4505 * you define DPPP_PL_parser_NO_DUMMY_WARNING.
4506 * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
4507 * this variable will croak with a panic message.
4508 */
4509
4510 # define PL_expect D_PPP_my_PL_parser_var(expect)
4511 # define PL_copline D_PPP_my_PL_parser_var(copline)
4512 # define PL_rsfp D_PPP_my_PL_parser_var(rsfp)
4513 # define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters)
4514 # define PL_linestr D_PPP_my_PL_parser_var(linestr)
4515 # define PL_bufptr D_PPP_my_PL_parser_var(bufptr)
4516 # define PL_bufend D_PPP_my_PL_parser_var(bufend)
4517 # define PL_lex_state D_PPP_my_PL_parser_var(lex_state)
4518 # define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff)
4519 # define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf)
4520 # define PL_in_my D_PPP_my_PL_parser_var(in_my)
4521 # define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash)
4522 # define PL_error_count D_PPP_my_PL_parser_var(error_count)
4523
4524
4525 #else
4526
4527 /* ensure that PL_parser != NULL and cannot be dereferenced */
4528 # define PL_parser ((void *) 1)
4529
4530 #endif
4531 #ifndef mPUSHs
4532 # define mPUSHs(s) PUSHs(sv_2mortal(s))
4533 #endif
4534
4535 #ifndef PUSHmortal
4536 # define PUSHmortal PUSHs(sv_newmortal())
4537 #endif
4538
4539 #ifndef mPUSHp
4540 # define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l))
4541 #endif
4542
4543 #ifndef mPUSHn
4544 # define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n))
4545 #endif
4546
4547 #ifndef mPUSHi
4548 # define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i))
4549 #endif
4550
4551 #ifndef mPUSHu
4552 # define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u))
4553 #endif
4554 #ifndef mXPUSHs
4555 # define mXPUSHs(s) XPUSHs(sv_2mortal(s))
4556 #endif
4557
4558 #ifndef XPUSHmortal
4559 # define XPUSHmortal XPUSHs(sv_newmortal())
4560 #endif
4561
4562 #ifndef mXPUSHp
4563 # define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
4564 #endif
4565
4566 #ifndef mXPUSHn
4567 # define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
4568 #endif
4569
4570 #ifndef mXPUSHi
4571 # define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
4572 #endif
4573
4574 #ifndef mXPUSHu
4575 # define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
4576 #endif
4577
4578 /* Replace: 1 */
4579 #ifndef call_sv
4580 # define call_sv perl_call_sv
4581 #endif
4582
4583 #ifndef call_pv
4584 # define call_pv perl_call_pv
4585 #endif
4586
4587 #ifndef call_argv
4588 # define call_argv perl_call_argv
4589 #endif
4590
4591 #ifndef call_method
4592 # define call_method perl_call_method
4593 #endif
4594 #ifndef eval_sv
4595 # define eval_sv perl_eval_sv
4596 #endif
4597
4598 /* Replace: 0 */
4599 #ifndef PERL_LOADMOD_DENY
4600 # define PERL_LOADMOD_DENY 0x1
4601 #endif
4602
4603 #ifndef PERL_LOADMOD_NOIMPORT
4604 # define PERL_LOADMOD_NOIMPORT 0x2
4605 #endif
4606
4607 #ifndef PERL_LOADMOD_IMPORT_OPS
4608 # define PERL_LOADMOD_IMPORT_OPS 0x4
4609 #endif
4610
4611 #ifndef G_METHOD
4612 # define G_METHOD 64
4613 # ifdef call_sv
4614 # undef call_sv
4615 # endif
4616 # if (PERL_BCDVERSION < 0x5006000)
4617 # define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
4618 (flags) & ~G_METHOD) : perl_call_sv(sv, flags))
4619 # else
4620 # define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
4621 (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
4622 # endif
4623 #endif
4624
4625 /* Replace perl_eval_pv with eval_pv */
4626
4627 #ifndef eval_pv
4628 #if defined(NEED_eval_pv)
4629 static SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
4630 static
4631 #else
4632 extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
4633 #endif
4634
4635 #ifdef eval_pv
4636 # undef eval_pv
4637 #endif
4638 #define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
4639 #define Perl_eval_pv DPPP_(my_eval_pv)
4640
4641 #if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
4642
4643 SV*
DPPP_(my_eval_pv)4644 DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
4645 {
4646 dSP;
4647 SV* sv = newSVpv(p, 0);
4648
4649 PUSHMARK(sp);
4650 eval_sv(sv, G_SCALAR);
4651 SvREFCNT_dec(sv);
4652
4653 SPAGAIN;
4654 sv = POPs;
4655 PUTBACK;
4656
4657 if (croak_on_error && SvTRUE(GvSV(errgv)))
4658 croak(SvPVx(GvSV(errgv), na));
4659
4660 return sv;
4661 }
4662
4663 #endif
4664 #endif
4665
4666 #ifndef vload_module
4667 #if defined(NEED_vload_module)
4668 static void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4669 static
4670 #else
4671 extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
4672 #endif
4673
4674 #ifdef vload_module
4675 # undef vload_module
4676 #endif
4677 #define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
4678 #define Perl_vload_module DPPP_(my_vload_module)
4679
4680 #if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
4681
4682 void
DPPP_(my_vload_module)4683 DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
4684 {
4685 dTHR;
4686 dVAR;
4687 OP *veop, *imop;
4688
4689 OP * const modname = newSVOP(OP_CONST, 0, name);
4690 /* 5.005 has a somewhat hacky force_normal that doesn't croak on
4691 SvREADONLY() if PL_compling is true. Current perls take care in
4692 ck_require() to correctly turn off SvREADONLY before calling
4693 force_normal_flags(). This seems a better fix than fudging PL_compling
4694 */
4695 SvREADONLY_off(((SVOP*)modname)->op_sv);
4696 modname->op_private |= OPpCONST_BARE;
4697 if (ver) {
4698 veop = newSVOP(OP_CONST, 0, ver);
4699 }
4700 else
4701 veop = NULL;
4702 if (flags & PERL_LOADMOD_NOIMPORT) {
4703 imop = sawparens(newNULLLIST());
4704 }
4705 else if (flags & PERL_LOADMOD_IMPORT_OPS) {
4706 imop = va_arg(*args, OP*);
4707 }
4708 else {
4709 SV *sv;
4710 imop = NULL;
4711 sv = va_arg(*args, SV*);
4712 while (sv) {
4713 imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
4714 sv = va_arg(*args, SV*);
4715 }
4716 }
4717 {
4718 const line_t ocopline = PL_copline;
4719 COP * const ocurcop = PL_curcop;
4720 const int oexpect = PL_expect;
4721
4722 #if (PERL_BCDVERSION >= 0x5004000)
4723 utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
4724 veop, modname, imop);
4725 #else
4726 utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
4727 modname, imop);
4728 #endif
4729 PL_expect = oexpect;
4730 PL_copline = ocopline;
4731 PL_curcop = ocurcop;
4732 }
4733 }
4734
4735 #endif
4736 #endif
4737
4738 #ifndef load_module
4739 #if defined(NEED_load_module)
4740 static void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4741 static
4742 #else
4743 extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
4744 #endif
4745
4746 #ifdef load_module
4747 # undef load_module
4748 #endif
4749 #define load_module DPPP_(my_load_module)
4750 #define Perl_load_module DPPP_(my_load_module)
4751
4752 #if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
4753
4754 void
DPPP_(my_load_module)4755 DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
4756 {
4757 va_list args;
4758 va_start(args, ver);
4759 vload_module(flags, name, ver, &args);
4760 va_end(args);
4761 }
4762
4763 #endif
4764 #endif
4765 #ifndef newRV_inc
4766 # define newRV_inc(sv) newRV(sv) /* Replace */
4767 #endif
4768
4769 #ifndef newRV_noinc
4770 #if defined(NEED_newRV_noinc)
4771 static SV * DPPP_(my_newRV_noinc)(SV *sv);
4772 static
4773 #else
4774 extern SV * DPPP_(my_newRV_noinc)(SV *sv);
4775 #endif
4776
4777 #ifdef newRV_noinc
4778 # undef newRV_noinc
4779 #endif
4780 #define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
4781 #define Perl_newRV_noinc DPPP_(my_newRV_noinc)
4782
4783 #if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
4784 SV *
DPPP_(my_newRV_noinc)4785 DPPP_(my_newRV_noinc)(SV *sv)
4786 {
4787 SV *rv = (SV *)newRV(sv);
4788 SvREFCNT_dec(sv);
4789 return rv;
4790 }
4791 #endif
4792 #endif
4793
4794 /* Hint: newCONSTSUB
4795 * Returns a CV* as of perl-5.7.1. This return value is not supported
4796 * by Devel::PPPort.
4797 */
4798
4799 /* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
4800 #if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
4801 #if defined(NEED_newCONSTSUB)
4802 static void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4803 static
4804 #else
4805 extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
4806 #endif
4807
4808 #ifdef newCONSTSUB
4809 # undef newCONSTSUB
4810 #endif
4811 #define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
4812 #define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
4813
4814 #if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
4815
4816 /* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
4817 /* (There's no PL_parser in perl < 5.005, so this is completely safe) */
4818 #define D_PPP_PL_copline PL_copline
4819
4820 void
DPPP_(my_newCONSTSUB)4821 DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
4822 {
4823 U32 oldhints = PL_hints;
4824 HV *old_cop_stash = PL_curcop->cop_stash;
4825 HV *old_curstash = PL_curstash;
4826 line_t oldline = PL_curcop->cop_line;
4827 PL_curcop->cop_line = D_PPP_PL_copline;
4828
4829 PL_hints &= ~HINT_BLOCK_SCOPE;
4830 if (stash)
4831 PL_curstash = PL_curcop->cop_stash = stash;
4832
4833 newSUB(
4834
4835 #if (PERL_BCDVERSION < 0x5003022)
4836 start_subparse(),
4837 #elif (PERL_BCDVERSION == 0x5003022)
4838 start_subparse(0),
4839 #else /* 5.003_23 onwards */
4840 start_subparse(FALSE, 0),
4841 #endif
4842
4843 newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
4844 newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
4845 newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4846 );
4847
4848 PL_hints = oldhints;
4849 PL_curcop->cop_stash = old_cop_stash;
4850 PL_curstash = old_curstash;
4851 PL_curcop->cop_line = oldline;
4852 }
4853 #endif
4854 #endif
4855
4856 /*
4857 * Boilerplate macros for initializing and accessing interpreter-local
4858 * data from C. All statics in extensions should be reworked to use
4859 * this, if you want to make the extension thread-safe. See ext/re/re.xs
4860 * for an example of the use of these macros.
4861 *
4862 * Code that uses these macros is responsible for the following:
4863 * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts"
4864 * 2. Declare a typedef named my_cxt_t that is a structure that contains
4865 * all the data that needs to be interpreter-local.
4866 * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t.
4867 * 4. Use the MY_CXT_INIT macro such that it is called exactly once
4868 * (typically put in the BOOT: section).
4869 * 5. Use the members of the my_cxt_t structure everywhere as
4870 * MY_CXT.member.
4871 * 6. Use the dMY_CXT macro (a declaration) in all the functions that
4872 * access MY_CXT.
4873 */
4874
4875 #if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \
4876 defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT)
4877
4878 #ifndef START_MY_CXT
4879
4880 /* This must appear in all extensions that define a my_cxt_t structure,
4881 * right after the definition (i.e. at file scope). The non-threads
4882 * case below uses it to declare the data as static. */
4883 #define START_MY_CXT
4884
4885 #if (PERL_BCDVERSION < 0x5004068)
4886 /* Fetches the SV that keeps the per-interpreter data. */
4887 #define dMY_CXT_SV \
4888 SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
4889 #else /* >= perl5.004_68 */
4890 #define dMY_CXT_SV \
4891 SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \
4892 sizeof(MY_CXT_KEY)-1, TRUE)
4893 #endif /* < perl5.004_68 */
4894
4895 /* This declaration should be used within all functions that use the
4896 * interpreter-local data. */
4897 #define dMY_CXT \
4898 dMY_CXT_SV; \
4899 my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv))
4900
4901 /* Creates and zeroes the per-interpreter data.
4902 * (We allocate my_cxtp in a Perl SV so that it will be released when
4903 * the interpreter goes away.) */
4904 #define MY_CXT_INIT \
4905 dMY_CXT_SV; \
4906 /* newSV() allocates one more than needed */ \
4907 my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
4908 Zero(my_cxtp, 1, my_cxt_t); \
4909 sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
4910
4911 /* This macro must be used to access members of the my_cxt_t structure.
4912 * e.g. MYCXT.some_data */
4913 #define MY_CXT (*my_cxtp)
4914
4915 /* Judicious use of these macros can reduce the number of times dMY_CXT
4916 * is used. Use is similar to pTHX, aTHX etc. */
4917 #define pMY_CXT my_cxt_t *my_cxtp
4918 #define pMY_CXT_ pMY_CXT,
4919 #define _pMY_CXT ,pMY_CXT
4920 #define aMY_CXT my_cxtp
4921 #define aMY_CXT_ aMY_CXT,
4922 #define _aMY_CXT ,aMY_CXT
4923
4924 #endif /* START_MY_CXT */
4925
4926 #ifndef MY_CXT_CLONE
4927 /* Clones the per-interpreter data. */
4928 #define MY_CXT_CLONE \
4929 dMY_CXT_SV; \
4930 my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\
4931 Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
4932 sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
4933 #endif
4934
4935 #else /* single interpreter */
4936
4937 #ifndef START_MY_CXT
4938
4939 #define START_MY_CXT static my_cxt_t my_cxt;
4940 #define dMY_CXT_SV dNOOP
4941 #define dMY_CXT dNOOP
4942 #define MY_CXT_INIT NOOP
4943 #define MY_CXT my_cxt
4944
4945 #define pMY_CXT void
4946 #define pMY_CXT_
4947 #define _pMY_CXT
4948 #define aMY_CXT
4949 #define aMY_CXT_
4950 #define _aMY_CXT
4951
4952 #endif /* START_MY_CXT */
4953
4954 #ifndef MY_CXT_CLONE
4955 #define MY_CXT_CLONE NOOP
4956 #endif
4957
4958 #endif
4959
4960 #ifndef IVdf
4961 # if IVSIZE == LONGSIZE
4962 # define IVdf "ld"
4963 # define UVuf "lu"
4964 # define UVof "lo"
4965 # define UVxf "lx"
4966 # define UVXf "lX"
4967 # elif IVSIZE == INTSIZE
4968 # define IVdf "d"
4969 # define UVuf "u"
4970 # define UVof "o"
4971 # define UVxf "x"
4972 # define UVXf "X"
4973 # else
4974 # error "cannot define IV/UV formats"
4975 # endif
4976 #endif
4977
4978 #ifndef NVef
4979 # if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
4980 defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
4981 /* Not very likely, but let's try anyway. */
4982 # define NVef PERL_PRIeldbl
4983 # define NVff PERL_PRIfldbl
4984 # define NVgf PERL_PRIgldbl
4985 # else
4986 # define NVef "e"
4987 # define NVff "f"
4988 # define NVgf "g"
4989 # endif
4990 #endif
4991
4992 #ifndef SvREFCNT_inc
4993 # ifdef PERL_USE_GCC_BRACE_GROUPS
4994 # define SvREFCNT_inc(sv) \
4995 ({ \
4996 SV * const _sv = (SV*)(sv); \
4997 if (_sv) \
4998 (SvREFCNT(_sv))++; \
4999 _sv; \
5000 })
5001 # else
5002 # define SvREFCNT_inc(sv) \
5003 ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
5004 # endif
5005 #endif
5006
5007 #ifndef SvREFCNT_inc_simple
5008 # ifdef PERL_USE_GCC_BRACE_GROUPS
5009 # define SvREFCNT_inc_simple(sv) \
5010 ({ \
5011 if (sv) \
5012 (SvREFCNT(sv))++; \
5013 (SV *)(sv); \
5014 })
5015 # else
5016 # define SvREFCNT_inc_simple(sv) \
5017 ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL)
5018 # endif
5019 #endif
5020
5021 #ifndef SvREFCNT_inc_NN
5022 # ifdef PERL_USE_GCC_BRACE_GROUPS
5023 # define SvREFCNT_inc_NN(sv) \
5024 ({ \
5025 SV * const _sv = (SV*)(sv); \
5026 SvREFCNT(_sv)++; \
5027 _sv; \
5028 })
5029 # else
5030 # define SvREFCNT_inc_NN(sv) \
5031 (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv)
5032 # endif
5033 #endif
5034
5035 #ifndef SvREFCNT_inc_void
5036 # ifdef PERL_USE_GCC_BRACE_GROUPS
5037 # define SvREFCNT_inc_void(sv) \
5038 ({ \
5039 SV * const _sv = (SV*)(sv); \
5040 if (_sv) \
5041 (void)(SvREFCNT(_sv)++); \
5042 })
5043 # else
5044 # define SvREFCNT_inc_void(sv) \
5045 (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0)
5046 # endif
5047 #endif
5048 #ifndef SvREFCNT_inc_simple_void
5049 # define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END
5050 #endif
5051
5052 #ifndef SvREFCNT_inc_simple_NN
5053 # define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv))
5054 #endif
5055
5056 #ifndef SvREFCNT_inc_void_NN
5057 # define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
5058 #endif
5059
5060 #ifndef SvREFCNT_inc_simple_void_NN
5061 # define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
5062 #endif
5063
5064 #ifndef newSV_type
5065
5066 #if defined(NEED_newSV_type)
5067 static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
5068 static
5069 #else
5070 extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
5071 #endif
5072
5073 #ifdef newSV_type
5074 # undef newSV_type
5075 #endif
5076 #define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)
5077 #define Perl_newSV_type DPPP_(my_newSV_type)
5078
5079 #if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
5080
5081 SV*
DPPP_(my_newSV_type)5082 DPPP_(my_newSV_type)(pTHX_ svtype const t)
5083 {
5084 SV* const sv = newSV(0);
5085 sv_upgrade(sv, t);
5086 return sv;
5087 }
5088
5089 #endif
5090
5091 #endif
5092
5093 #if (PERL_BCDVERSION < 0x5006000)
5094 # define D_PPP_CONSTPV_ARG(x) ((char *) (x))
5095 #else
5096 # define D_PPP_CONSTPV_ARG(x) (x)
5097 #endif
5098 #ifndef newSVpvn
5099 # define newSVpvn(data,len) ((data) \
5100 ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
5101 : newSV(0))
5102 #endif
5103 #ifndef newSVpvn_utf8
5104 # define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
5105 #endif
5106 #ifndef SVf_UTF8
5107 # define SVf_UTF8 0
5108 #endif
5109
5110 #ifndef newSVpvn_flags
5111
5112 #if defined(NEED_newSVpvn_flags)
5113 static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
5114 static
5115 #else
5116 extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
5117 #endif
5118
5119 #ifdef newSVpvn_flags
5120 # undef newSVpvn_flags
5121 #endif
5122 #define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
5123 #define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
5124
5125 #if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
5126
5127 SV *
DPPP_(my_newSVpvn_flags)5128 DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
5129 {
5130 SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
5131 SvFLAGS(sv) |= (flags & SVf_UTF8);
5132 return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
5133 }
5134
5135 #endif
5136
5137 #endif
5138
5139 /* Backwards compatibility stuff... :-( */
5140 #if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
5141 # define NEED_sv_2pv_flags
5142 #endif
5143 #if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
5144 # define NEED_sv_2pv_flags_GLOBAL
5145 #endif
5146
5147 /* Hint: sv_2pv_nolen
5148 * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
5149 */
5150 #ifndef sv_2pv_nolen
5151 # define sv_2pv_nolen(sv) SvPV_nolen(sv)
5152 #endif
5153
5154 #ifdef SvPVbyte
5155
5156 /* Hint: SvPVbyte
5157 * Does not work in perl-5.6.1, ppport.h implements a version
5158 * borrowed from perl-5.7.3.
5159 */
5160
5161 #if (PERL_BCDVERSION < 0x5007000)
5162
5163 #if defined(NEED_sv_2pvbyte)
5164 static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
5165 static
5166 #else
5167 extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
5168 #endif
5169
5170 #ifdef sv_2pvbyte
5171 # undef sv_2pvbyte
5172 #endif
5173 #define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
5174 #define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
5175
5176 #if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
5177
5178 char *
DPPP_(my_sv_2pvbyte)5179 DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
5180 {
5181 sv_utf8_downgrade(sv,0);
5182 return SvPV(sv,*lp);
5183 }
5184
5185 #endif
5186
5187 /* Hint: sv_2pvbyte
5188 * Use the SvPVbyte() macro instead of sv_2pvbyte().
5189 */
5190
5191 #undef SvPVbyte
5192
5193 #define SvPVbyte(sv, lp) \
5194 ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \
5195 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))
5196
5197 #endif
5198
5199 #else
5200
5201 # define SvPVbyte SvPV
5202 # define sv_2pvbyte sv_2pv
5203
5204 #endif
5205 #ifndef sv_2pvbyte_nolen
5206 # define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv)
5207 #endif
5208
5209 /* Hint: sv_pvn
5210 * Always use the SvPV() macro instead of sv_pvn().
5211 */
5212
5213 /* Hint: sv_pvn_force
5214 * Always use the SvPV_force() macro instead of sv_pvn_force().
5215 */
5216
5217 /* If these are undefined, they're not handled by the core anyway */
5218 #ifndef SV_IMMEDIATE_UNREF
5219 # define SV_IMMEDIATE_UNREF 0
5220 #endif
5221
5222 #ifndef SV_GMAGIC
5223 # define SV_GMAGIC 0
5224 #endif
5225
5226 #ifndef SV_COW_DROP_PV
5227 # define SV_COW_DROP_PV 0
5228 #endif
5229
5230 #ifndef SV_UTF8_NO_ENCODING
5231 # define SV_UTF8_NO_ENCODING 0
5232 #endif
5233
5234 #ifndef SV_NOSTEAL
5235 # define SV_NOSTEAL 0
5236 #endif
5237
5238 #ifndef SV_CONST_RETURN
5239 # define SV_CONST_RETURN 0
5240 #endif
5241
5242 #ifndef SV_MUTABLE_RETURN
5243 # define SV_MUTABLE_RETURN 0
5244 #endif
5245
5246 #ifndef SV_SMAGIC
5247 # define SV_SMAGIC 0
5248 #endif
5249
5250 #ifndef SV_HAS_TRAILING_NUL
5251 # define SV_HAS_TRAILING_NUL 0
5252 #endif
5253
5254 #ifndef SV_COW_SHARED_HASH_KEYS
5255 # define SV_COW_SHARED_HASH_KEYS 0
5256 #endif
5257
5258 #if (PERL_BCDVERSION < 0x5007002)
5259
5260 #if defined(NEED_sv_2pv_flags)
5261 static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
5262 static
5263 #else
5264 extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
5265 #endif
5266
5267 #ifdef sv_2pv_flags
5268 # undef sv_2pv_flags
5269 #endif
5270 #define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
5271 #define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
5272
5273 #if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
5274
5275 char *
DPPP_(my_sv_2pv_flags)5276 DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
5277 {
5278 STRLEN n_a = (STRLEN) flags;
5279 return sv_2pv(sv, lp ? lp : &n_a);
5280 }
5281
5282 #endif
5283
5284 #if defined(NEED_sv_pvn_force_flags)
5285 static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
5286 static
5287 #else
5288 extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
5289 #endif
5290
5291 #ifdef sv_pvn_force_flags
5292 # undef sv_pvn_force_flags
5293 #endif
5294 #define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
5295 #define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
5296
5297 #if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
5298
5299 char *
DPPP_(my_sv_pvn_force_flags)5300 DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
5301 {
5302 STRLEN n_a = (STRLEN) flags;
5303 return sv_pvn_force(sv, lp ? lp : &n_a);
5304 }
5305
5306 #endif
5307
5308 #endif
5309
5310 #if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
5311 # define DPPP_SVPV_NOLEN_LP_ARG &PL_na
5312 #else
5313 # define DPPP_SVPV_NOLEN_LP_ARG 0
5314 #endif
5315 #ifndef SvPV_const
5316 # define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
5317 #endif
5318
5319 #ifndef SvPV_mutable
5320 # define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
5321 #endif
5322 #ifndef SvPV_flags
5323 # define SvPV_flags(sv, lp, flags) \
5324 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5325 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
5326 #endif
5327 #ifndef SvPV_flags_const
5328 # define SvPV_flags_const(sv, lp, flags) \
5329 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5330 ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
5331 (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN))
5332 #endif
5333 #ifndef SvPV_flags_const_nolen
5334 # define SvPV_flags_const_nolen(sv, flags) \
5335 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5336 ? SvPVX_const(sv) : \
5337 (const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
5338 #endif
5339 #ifndef SvPV_flags_mutable
5340 # define SvPV_flags_mutable(sv, lp, flags) \
5341 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5342 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
5343 sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
5344 #endif
5345 #ifndef SvPV_force
5346 # define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
5347 #endif
5348
5349 #ifndef SvPV_force_nolen
5350 # define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
5351 #endif
5352
5353 #ifndef SvPV_force_mutable
5354 # define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
5355 #endif
5356
5357 #ifndef SvPV_force_nomg
5358 # define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
5359 #endif
5360
5361 #ifndef SvPV_force_nomg_nolen
5362 # define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
5363 #endif
5364 #ifndef SvPV_force_flags
5365 # define SvPV_force_flags(sv, lp, flags) \
5366 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5367 ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
5368 #endif
5369 #ifndef SvPV_force_flags_nolen
5370 # define SvPV_force_flags_nolen(sv, flags) \
5371 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5372 ? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
5373 #endif
5374 #ifndef SvPV_force_flags_mutable
5375 # define SvPV_force_flags_mutable(sv, lp, flags) \
5376 ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
5377 ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
5378 : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN))
5379 #endif
5380 #ifndef SvPV_nolen
5381 # define SvPV_nolen(sv) \
5382 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5383 ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
5384 #endif
5385 #ifndef SvPV_nolen_const
5386 # define SvPV_nolen_const(sv) \
5387 ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5388 ? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
5389 #endif
5390 #ifndef SvPV_nomg
5391 # define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
5392 #endif
5393
5394 #ifndef SvPV_nomg_const
5395 # define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
5396 #endif
5397
5398 #ifndef SvPV_nomg_const_nolen
5399 # define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
5400 #endif
5401
5402 #ifndef SvPV_nomg_nolen
5403 # define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
5404 ? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0))
5405 #endif
5406 #ifndef SvPV_renew
5407 # define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \
5408 SvPV_set((sv), (char *) saferealloc( \
5409 (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
5410 } STMT_END
5411 #endif
5412 #ifndef SvMAGIC_set
5413 # define SvMAGIC_set(sv, val) \
5414 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
5415 (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
5416 #endif
5417
5418 #if (PERL_BCDVERSION < 0x5009003)
5419 #ifndef SvPVX_const
5420 # define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
5421 #endif
5422
5423 #ifndef SvPVX_mutable
5424 # define SvPVX_mutable(sv) (0 + SvPVX(sv))
5425 #endif
5426 #ifndef SvRV_set
5427 # define SvRV_set(sv, val) \
5428 STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
5429 (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END
5430 #endif
5431
5432 #else
5433 #ifndef SvPVX_const
5434 # define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv))
5435 #endif
5436
5437 #ifndef SvPVX_mutable
5438 # define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv)
5439 #endif
5440 #ifndef SvRV_set
5441 # define SvRV_set(sv, val) \
5442 STMT_START { assert(SvTYPE(sv) >= SVt_RV); \
5443 ((sv)->sv_u.svu_rv = (val)); } STMT_END
5444 #endif
5445
5446 #endif
5447 #ifndef SvSTASH_set
5448 # define SvSTASH_set(sv, val) \
5449 STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
5450 (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
5451 #endif
5452
5453 #if (PERL_BCDVERSION < 0x5004000)
5454 #ifndef SvUV_set
5455 # define SvUV_set(sv, val) \
5456 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
5457 (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END
5458 #endif
5459
5460 #else
5461 #ifndef SvUV_set
5462 # define SvUV_set(sv, val) \
5463 STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
5464 (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END
5465 #endif
5466
5467 #endif
5468
5469 #if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
5470 #if defined(NEED_vnewSVpvf)
5471 static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
5472 static
5473 #else
5474 extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
5475 #endif
5476
5477 #ifdef vnewSVpvf
5478 # undef vnewSVpvf
5479 #endif
5480 #define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
5481 #define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
5482
5483 #if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
5484
5485 SV *
DPPP_(my_vnewSVpvf)5486 DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
5487 {
5488 register SV *sv = newSV(0);
5489 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
5490 return sv;
5491 }
5492
5493 #endif
5494 #endif
5495
5496 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
5497 # define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
5498 #endif
5499
5500 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
5501 # define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*))
5502 #endif
5503
5504 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
5505 #if defined(NEED_sv_catpvf_mg)
5506 static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5507 static
5508 #else
5509 extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5510 #endif
5511
5512 #define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
5513
5514 #if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
5515
5516 void
DPPP_(my_sv_catpvf_mg)5517 DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
5518 {
5519 va_list args;
5520 va_start(args, pat);
5521 sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5522 SvSETMAGIC(sv);
5523 va_end(args);
5524 }
5525
5526 #endif
5527 #endif
5528
5529 #ifdef PERL_IMPLICIT_CONTEXT
5530 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
5531 #if defined(NEED_sv_catpvf_mg_nocontext)
5532 static void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5533 static
5534 #else
5535 extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5536 #endif
5537
5538 #define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
5539 #define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
5540
5541 #if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
5542
5543 void
DPPP_(my_sv_catpvf_mg_nocontext)5544 DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
5545 {
5546 dTHX;
5547 va_list args;
5548 va_start(args, pat);
5549 sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5550 SvSETMAGIC(sv);
5551 va_end(args);
5552 }
5553
5554 #endif
5555 #endif
5556 #endif
5557
5558 /* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
5559 #ifndef sv_catpvf_mg
5560 # ifdef PERL_IMPLICIT_CONTEXT
5561 # define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext
5562 # else
5563 # define sv_catpvf_mg Perl_sv_catpvf_mg
5564 # endif
5565 #endif
5566
5567 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
5568 # define sv_vcatpvf_mg(sv, pat, args) \
5569 STMT_START { \
5570 sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
5571 SvSETMAGIC(sv); \
5572 } STMT_END
5573 #endif
5574
5575 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
5576 #if defined(NEED_sv_setpvf_mg)
5577 static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5578 static
5579 #else
5580 extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
5581 #endif
5582
5583 #define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
5584
5585 #if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
5586
5587 void
DPPP_(my_sv_setpvf_mg)5588 DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
5589 {
5590 va_list args;
5591 va_start(args, pat);
5592 sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5593 SvSETMAGIC(sv);
5594 va_end(args);
5595 }
5596
5597 #endif
5598 #endif
5599
5600 #ifdef PERL_IMPLICIT_CONTEXT
5601 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
5602 #if defined(NEED_sv_setpvf_mg_nocontext)
5603 static void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5604 static
5605 #else
5606 extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
5607 #endif
5608
5609 #define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
5610 #define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
5611
5612 #if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
5613
5614 void
DPPP_(my_sv_setpvf_mg_nocontext)5615 DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
5616 {
5617 dTHX;
5618 va_list args;
5619 va_start(args, pat);
5620 sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
5621 SvSETMAGIC(sv);
5622 va_end(args);
5623 }
5624
5625 #endif
5626 #endif
5627 #endif
5628
5629 /* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
5630 #ifndef sv_setpvf_mg
5631 # ifdef PERL_IMPLICIT_CONTEXT
5632 # define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext
5633 # else
5634 # define sv_setpvf_mg Perl_sv_setpvf_mg
5635 # endif
5636 #endif
5637
5638 #if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
5639 # define sv_vsetpvf_mg(sv, pat, args) \
5640 STMT_START { \
5641 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \
5642 SvSETMAGIC(sv); \
5643 } STMT_END
5644 #endif
5645
5646 /* Hint: newSVpvn_share
5647 * The SVs created by this function only mimic the behaviour of
5648 * shared PVs without really being shared. Only use if you know
5649 * what you're doing.
5650 */
5651
5652 #ifndef newSVpvn_share
5653
5654 #if defined(NEED_newSVpvn_share)
5655 static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
5656 static
5657 #else
5658 extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
5659 #endif
5660
5661 #ifdef newSVpvn_share
5662 # undef newSVpvn_share
5663 #endif
5664 #define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
5665 #define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
5666
5667 #if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
5668
5669 SV *
DPPP_(my_newSVpvn_share)5670 DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
5671 {
5672 SV *sv;
5673 if (len < 0)
5674 len = -len;
5675 if (!hash)
5676 PERL_HASH(hash, (char*) src, len);
5677 sv = newSVpvn((char *) src, len);
5678 sv_upgrade(sv, SVt_PVIV);
5679 SvIVX(sv) = hash;
5680 SvREADONLY_on(sv);
5681 SvPOK_on(sv);
5682 return sv;
5683 }
5684
5685 #endif
5686
5687 #endif
5688 #ifndef SvSHARED_HASH
5689 # define SvSHARED_HASH(sv) (0 + SvUVX(sv))
5690 #endif
5691 #ifndef HvNAME_get
5692 # define HvNAME_get(hv) HvNAME(hv)
5693 #endif
5694 #ifndef HvNAMELEN_get
5695 # define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
5696 #endif
5697 #ifndef GvSVn
5698 # define GvSVn(gv) GvSV(gv)
5699 #endif
5700
5701 #ifndef isGV_with_GP
5702 # define isGV_with_GP(gv) isGV(gv)
5703 #endif
5704
5705 #ifndef gv_fetchpvn_flags
5706 # define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt)
5707 #endif
5708
5709 #ifndef gv_fetchsv
5710 # define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt)
5711 #endif
5712 #ifndef get_cvn_flags
5713 # define get_cvn_flags(name, namelen, flags) get_cv(name, flags)
5714 #endif
5715 #ifndef WARN_ALL
5716 # define WARN_ALL 0
5717 #endif
5718
5719 #ifndef WARN_CLOSURE
5720 # define WARN_CLOSURE 1
5721 #endif
5722
5723 #ifndef WARN_DEPRECATED
5724 # define WARN_DEPRECATED 2
5725 #endif
5726
5727 #ifndef WARN_EXITING
5728 # define WARN_EXITING 3
5729 #endif
5730
5731 #ifndef WARN_GLOB
5732 # define WARN_GLOB 4
5733 #endif
5734
5735 #ifndef WARN_IO
5736 # define WARN_IO 5
5737 #endif
5738
5739 #ifndef WARN_CLOSED
5740 # define WARN_CLOSED 6
5741 #endif
5742
5743 #ifndef WARN_EXEC
5744 # define WARN_EXEC 7
5745 #endif
5746
5747 #ifndef WARN_LAYER
5748 # define WARN_LAYER 8
5749 #endif
5750
5751 #ifndef WARN_NEWLINE
5752 # define WARN_NEWLINE 9
5753 #endif
5754
5755 #ifndef WARN_PIPE
5756 # define WARN_PIPE 10
5757 #endif
5758
5759 #ifndef WARN_UNOPENED
5760 # define WARN_UNOPENED 11
5761 #endif
5762
5763 #ifndef WARN_MISC
5764 # define WARN_MISC 12
5765 #endif
5766
5767 #ifndef WARN_NUMERIC
5768 # define WARN_NUMERIC 13
5769 #endif
5770
5771 #ifndef WARN_ONCE
5772 # define WARN_ONCE 14
5773 #endif
5774
5775 #ifndef WARN_OVERFLOW
5776 # define WARN_OVERFLOW 15
5777 #endif
5778
5779 #ifndef WARN_PACK
5780 # define WARN_PACK 16
5781 #endif
5782
5783 #ifndef WARN_PORTABLE
5784 # define WARN_PORTABLE 17
5785 #endif
5786
5787 #ifndef WARN_RECURSION
5788 # define WARN_RECURSION 18
5789 #endif
5790
5791 #ifndef WARN_REDEFINE
5792 # define WARN_REDEFINE 19
5793 #endif
5794
5795 #ifndef WARN_REGEXP
5796 # define WARN_REGEXP 20
5797 #endif
5798
5799 #ifndef WARN_SEVERE
5800 # define WARN_SEVERE 21
5801 #endif
5802
5803 #ifndef WARN_DEBUGGING
5804 # define WARN_DEBUGGING 22
5805 #endif
5806
5807 #ifndef WARN_INPLACE
5808 # define WARN_INPLACE 23
5809 #endif
5810
5811 #ifndef WARN_INTERNAL
5812 # define WARN_INTERNAL 24
5813 #endif
5814
5815 #ifndef WARN_MALLOC
5816 # define WARN_MALLOC 25
5817 #endif
5818
5819 #ifndef WARN_SIGNAL
5820 # define WARN_SIGNAL 26
5821 #endif
5822
5823 #ifndef WARN_SUBSTR
5824 # define WARN_SUBSTR 27
5825 #endif
5826
5827 #ifndef WARN_SYNTAX
5828 # define WARN_SYNTAX 28
5829 #endif
5830
5831 #ifndef WARN_AMBIGUOUS
5832 # define WARN_AMBIGUOUS 29
5833 #endif
5834
5835 #ifndef WARN_BAREWORD
5836 # define WARN_BAREWORD 30
5837 #endif
5838
5839 #ifndef WARN_DIGIT
5840 # define WARN_DIGIT 31
5841 #endif
5842
5843 #ifndef WARN_PARENTHESIS
5844 # define WARN_PARENTHESIS 32
5845 #endif
5846
5847 #ifndef WARN_PRECEDENCE
5848 # define WARN_PRECEDENCE 33
5849 #endif
5850
5851 #ifndef WARN_PRINTF
5852 # define WARN_PRINTF 34
5853 #endif
5854
5855 #ifndef WARN_PROTOTYPE
5856 # define WARN_PROTOTYPE 35
5857 #endif
5858
5859 #ifndef WARN_QW
5860 # define WARN_QW 36
5861 #endif
5862
5863 #ifndef WARN_RESERVED
5864 # define WARN_RESERVED 37
5865 #endif
5866
5867 #ifndef WARN_SEMICOLON
5868 # define WARN_SEMICOLON 38
5869 #endif
5870
5871 #ifndef WARN_TAINT
5872 # define WARN_TAINT 39
5873 #endif
5874
5875 #ifndef WARN_THREADS
5876 # define WARN_THREADS 40
5877 #endif
5878
5879 #ifndef WARN_UNINITIALIZED
5880 # define WARN_UNINITIALIZED 41
5881 #endif
5882
5883 #ifndef WARN_UNPACK
5884 # define WARN_UNPACK 42
5885 #endif
5886
5887 #ifndef WARN_UNTIE
5888 # define WARN_UNTIE 43
5889 #endif
5890
5891 #ifndef WARN_UTF8
5892 # define WARN_UTF8 44
5893 #endif
5894
5895 #ifndef WARN_VOID
5896 # define WARN_VOID 45
5897 #endif
5898
5899 #ifndef WARN_ASSERTIONS
5900 # define WARN_ASSERTIONS 46
5901 #endif
5902 #ifndef packWARN
5903 # define packWARN(a) (a)
5904 #endif
5905
5906 #ifndef ckWARN
5907 # ifdef G_WARN_ON
5908 # define ckWARN(a) (PL_dowarn & G_WARN_ON)
5909 # else
5910 # define ckWARN(a) PL_dowarn
5911 # endif
5912 #endif
5913
5914 #if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
5915 #if defined(NEED_warner)
5916 static void DPPP_(my_warner)(U32 err, const char *pat, ...);
5917 static
5918 #else
5919 extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
5920 #endif
5921
5922 #define Perl_warner DPPP_(my_warner)
5923
5924 #if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
5925
5926 void
DPPP_(my_warner)5927 DPPP_(my_warner)(U32 err, const char *pat, ...)
5928 {
5929 SV *sv;
5930 va_list args;
5931
5932 PERL_UNUSED_ARG(err);
5933
5934 va_start(args, pat);
5935 sv = vnewSVpvf(pat, &args);
5936 va_end(args);
5937 sv_2mortal(sv);
5938 warn("%s", SvPV_nolen(sv));
5939 }
5940
5941 #define warner Perl_warner
5942
5943 #define Perl_warner_nocontext Perl_warner
5944
5945 #endif
5946 #endif
5947
5948 /* concatenating with "" ensures that only literal strings are accepted as argument
5949 * note that STR_WITH_LEN() can't be used as argument to macros or functions that
5950 * under some configurations might be macros
5951 */
5952 #ifndef STR_WITH_LEN
5953 # define STR_WITH_LEN(s) (s ""), (sizeof(s)-1)
5954 #endif
5955 #ifndef newSVpvs
5956 # define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1)
5957 #endif
5958
5959 #ifndef newSVpvs_flags
5960 # define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags)
5961 #endif
5962
5963 #ifndef newSVpvs_share
5964 # define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0)
5965 #endif
5966
5967 #ifndef sv_catpvs
5968 # define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1)
5969 #endif
5970
5971 #ifndef sv_setpvs
5972 # define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1)
5973 #endif
5974
5975 #ifndef hv_fetchs
5976 # define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval)
5977 #endif
5978
5979 #ifndef hv_stores
5980 # define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0)
5981 #endif
5982 #ifndef gv_fetchpvs
5983 # define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
5984 #endif
5985
5986 #ifndef gv_stashpvs
5987 # define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags)
5988 #endif
5989 #ifndef get_cvs
5990 # define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags)
5991 #endif
5992 #ifndef SvGETMAGIC
5993 # define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
5994 #endif
5995 #ifndef PERL_MAGIC_sv
5996 # define PERL_MAGIC_sv '\0'
5997 #endif
5998
5999 #ifndef PERL_MAGIC_overload
6000 # define PERL_MAGIC_overload 'A'
6001 #endif
6002
6003 #ifndef PERL_MAGIC_overload_elem
6004 # define PERL_MAGIC_overload_elem 'a'
6005 #endif
6006
6007 #ifndef PERL_MAGIC_overload_table
6008 # define PERL_MAGIC_overload_table 'c'
6009 #endif
6010
6011 #ifndef PERL_MAGIC_bm
6012 # define PERL_MAGIC_bm 'B'
6013 #endif
6014
6015 #ifndef PERL_MAGIC_regdata
6016 # define PERL_MAGIC_regdata 'D'
6017 #endif
6018
6019 #ifndef PERL_MAGIC_regdatum
6020 # define PERL_MAGIC_regdatum 'd'
6021 #endif
6022
6023 #ifndef PERL_MAGIC_env
6024 # define PERL_MAGIC_env 'E'
6025 #endif
6026
6027 #ifndef PERL_MAGIC_envelem
6028 # define PERL_MAGIC_envelem 'e'
6029 #endif
6030
6031 #ifndef PERL_MAGIC_fm
6032 # define PERL_MAGIC_fm 'f'
6033 #endif
6034
6035 #ifndef PERL_MAGIC_regex_global
6036 # define PERL_MAGIC_regex_global 'g'
6037 #endif
6038
6039 #ifndef PERL_MAGIC_isa
6040 # define PERL_MAGIC_isa 'I'
6041 #endif
6042
6043 #ifndef PERL_MAGIC_isaelem
6044 # define PERL_MAGIC_isaelem 'i'
6045 #endif
6046
6047 #ifndef PERL_MAGIC_nkeys
6048 # define PERL_MAGIC_nkeys 'k'
6049 #endif
6050
6051 #ifndef PERL_MAGIC_dbfile
6052 # define PERL_MAGIC_dbfile 'L'
6053 #endif
6054
6055 #ifndef PERL_MAGIC_dbline
6056 # define PERL_MAGIC_dbline 'l'
6057 #endif
6058
6059 #ifndef PERL_MAGIC_mutex
6060 # define PERL_MAGIC_mutex 'm'
6061 #endif
6062
6063 #ifndef PERL_MAGIC_shared
6064 # define PERL_MAGIC_shared 'N'
6065 #endif
6066
6067 #ifndef PERL_MAGIC_shared_scalar
6068 # define PERL_MAGIC_shared_scalar 'n'
6069 #endif
6070
6071 #ifndef PERL_MAGIC_collxfrm
6072 # define PERL_MAGIC_collxfrm 'o'
6073 #endif
6074
6075 #ifndef PERL_MAGIC_tied
6076 # define PERL_MAGIC_tied 'P'
6077 #endif
6078
6079 #ifndef PERL_MAGIC_tiedelem
6080 # define PERL_MAGIC_tiedelem 'p'
6081 #endif
6082
6083 #ifndef PERL_MAGIC_tiedscalar
6084 # define PERL_MAGIC_tiedscalar 'q'
6085 #endif
6086
6087 #ifndef PERL_MAGIC_qr
6088 # define PERL_MAGIC_qr 'r'
6089 #endif
6090
6091 #ifndef PERL_MAGIC_sig
6092 # define PERL_MAGIC_sig 'S'
6093 #endif
6094
6095 #ifndef PERL_MAGIC_sigelem
6096 # define PERL_MAGIC_sigelem 's'
6097 #endif
6098
6099 #ifndef PERL_MAGIC_taint
6100 # define PERL_MAGIC_taint 't'
6101 #endif
6102
6103 #ifndef PERL_MAGIC_uvar
6104 # define PERL_MAGIC_uvar 'U'
6105 #endif
6106
6107 #ifndef PERL_MAGIC_uvar_elem
6108 # define PERL_MAGIC_uvar_elem 'u'
6109 #endif
6110
6111 #ifndef PERL_MAGIC_vstring
6112 # define PERL_MAGIC_vstring 'V'
6113 #endif
6114
6115 #ifndef PERL_MAGIC_vec
6116 # define PERL_MAGIC_vec 'v'
6117 #endif
6118
6119 #ifndef PERL_MAGIC_utf8
6120 # define PERL_MAGIC_utf8 'w'
6121 #endif
6122
6123 #ifndef PERL_MAGIC_substr
6124 # define PERL_MAGIC_substr 'x'
6125 #endif
6126
6127 #ifndef PERL_MAGIC_defelem
6128 # define PERL_MAGIC_defelem 'y'
6129 #endif
6130
6131 #ifndef PERL_MAGIC_glob
6132 # define PERL_MAGIC_glob '*'
6133 #endif
6134
6135 #ifndef PERL_MAGIC_arylen
6136 # define PERL_MAGIC_arylen '#'
6137 #endif
6138
6139 #ifndef PERL_MAGIC_pos
6140 # define PERL_MAGIC_pos '.'
6141 #endif
6142
6143 #ifndef PERL_MAGIC_backref
6144 # define PERL_MAGIC_backref '<'
6145 #endif
6146
6147 #ifndef PERL_MAGIC_ext
6148 # define PERL_MAGIC_ext '~'
6149 #endif
6150
6151 /* That's the best we can do... */
6152 #ifndef sv_catpvn_nomg
6153 # define sv_catpvn_nomg sv_catpvn
6154 #endif
6155
6156 #ifndef sv_catsv_nomg
6157 # define sv_catsv_nomg sv_catsv
6158 #endif
6159
6160 #ifndef sv_setsv_nomg
6161 # define sv_setsv_nomg sv_setsv
6162 #endif
6163
6164 #ifndef sv_pvn_nomg
6165 # define sv_pvn_nomg sv_pvn
6166 #endif
6167
6168 #ifndef SvIV_nomg
6169 # define SvIV_nomg SvIV
6170 #endif
6171
6172 #ifndef SvUV_nomg
6173 # define SvUV_nomg SvUV
6174 #endif
6175
6176 #ifndef sv_catpv_mg
6177 # define sv_catpv_mg(sv, ptr) \
6178 STMT_START { \
6179 SV *TeMpSv = sv; \
6180 sv_catpv(TeMpSv,ptr); \
6181 SvSETMAGIC(TeMpSv); \
6182 } STMT_END
6183 #endif
6184
6185 #ifndef sv_catpvn_mg
6186 # define sv_catpvn_mg(sv, ptr, len) \
6187 STMT_START { \
6188 SV *TeMpSv = sv; \
6189 sv_catpvn(TeMpSv,ptr,len); \
6190 SvSETMAGIC(TeMpSv); \
6191 } STMT_END
6192 #endif
6193
6194 #ifndef sv_catsv_mg
6195 # define sv_catsv_mg(dsv, ssv) \
6196 STMT_START { \
6197 SV *TeMpSv = dsv; \
6198 sv_catsv(TeMpSv,ssv); \
6199 SvSETMAGIC(TeMpSv); \
6200 } STMT_END
6201 #endif
6202
6203 #ifndef sv_setiv_mg
6204 # define sv_setiv_mg(sv, i) \
6205 STMT_START { \
6206 SV *TeMpSv = sv; \
6207 sv_setiv(TeMpSv,i); \
6208 SvSETMAGIC(TeMpSv); \
6209 } STMT_END
6210 #endif
6211
6212 #ifndef sv_setnv_mg
6213 # define sv_setnv_mg(sv, num) \
6214 STMT_START { \
6215 SV *TeMpSv = sv; \
6216 sv_setnv(TeMpSv,num); \
6217 SvSETMAGIC(TeMpSv); \
6218 } STMT_END
6219 #endif
6220
6221 #ifndef sv_setpv_mg
6222 # define sv_setpv_mg(sv, ptr) \
6223 STMT_START { \
6224 SV *TeMpSv = sv; \
6225 sv_setpv(TeMpSv,ptr); \
6226 SvSETMAGIC(TeMpSv); \
6227 } STMT_END
6228 #endif
6229
6230 #ifndef sv_setpvn_mg
6231 # define sv_setpvn_mg(sv, ptr, len) \
6232 STMT_START { \
6233 SV *TeMpSv = sv; \
6234 sv_setpvn(TeMpSv,ptr,len); \
6235 SvSETMAGIC(TeMpSv); \
6236 } STMT_END
6237 #endif
6238
6239 #ifndef sv_setsv_mg
6240 # define sv_setsv_mg(dsv, ssv) \
6241 STMT_START { \
6242 SV *TeMpSv = dsv; \
6243 sv_setsv(TeMpSv,ssv); \
6244 SvSETMAGIC(TeMpSv); \
6245 } STMT_END
6246 #endif
6247
6248 #ifndef sv_setuv_mg
6249 # define sv_setuv_mg(sv, i) \
6250 STMT_START { \
6251 SV *TeMpSv = sv; \
6252 sv_setuv(TeMpSv,i); \
6253 SvSETMAGIC(TeMpSv); \
6254 } STMT_END
6255 #endif
6256
6257 #ifndef sv_usepvn_mg
6258 # define sv_usepvn_mg(sv, ptr, len) \
6259 STMT_START { \
6260 SV *TeMpSv = sv; \
6261 sv_usepvn(TeMpSv,ptr,len); \
6262 SvSETMAGIC(TeMpSv); \
6263 } STMT_END
6264 #endif
6265 #ifndef SvVSTRING_mg
6266 # define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
6267 #endif
6268
6269 /* Hint: sv_magic_portable
6270 * This is a compatibility function that is only available with
6271 * Devel::PPPort. It is NOT in the perl core.
6272 * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
6273 * it is being passed a name pointer with namlen == 0. In that
6274 * case, perl 5.8.0 and later store the pointer, not a copy of it.
6275 * The compatibility can be provided back to perl 5.004. With
6276 * earlier versions, the code will not compile.
6277 */
6278
6279 #if (PERL_BCDVERSION < 0x5004000)
6280
6281 /* code that uses sv_magic_portable will not compile */
6282
6283 #elif (PERL_BCDVERSION < 0x5008000)
6284
6285 # define sv_magic_portable(sv, obj, how, name, namlen) \
6286 STMT_START { \
6287 SV *SvMp_sv = (sv); \
6288 char *SvMp_name = (char *) (name); \
6289 I32 SvMp_namlen = (namlen); \
6290 if (SvMp_name && SvMp_namlen == 0) \
6291 { \
6292 MAGIC *mg; \
6293 sv_magic(SvMp_sv, obj, how, 0, 0); \
6294 mg = SvMAGIC(SvMp_sv); \
6295 mg->mg_len = -42; /* XXX: this is the tricky part */ \
6296 mg->mg_ptr = SvMp_name; \
6297 } \
6298 else \
6299 { \
6300 sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
6301 } \
6302 } STMT_END
6303
6304 #else
6305
6306 # define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e)
6307
6308 #endif
6309
6310 #ifdef USE_ITHREADS
6311 #ifndef CopFILE
6312 # define CopFILE(c) ((c)->cop_file)
6313 #endif
6314
6315 #ifndef CopFILEGV
6316 # define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv)
6317 #endif
6318
6319 #ifndef CopFILE_set
6320 # define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv))
6321 #endif
6322
6323 #ifndef CopFILESV
6324 # define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
6325 #endif
6326
6327 #ifndef CopFILEAV
6328 # define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
6329 #endif
6330
6331 #ifndef CopSTASHPV
6332 # define CopSTASHPV(c) ((c)->cop_stashpv)
6333 #endif
6334
6335 #ifndef CopSTASHPV_set
6336 # define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch))
6337 #endif
6338
6339 #ifndef CopSTASH
6340 # define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
6341 #endif
6342
6343 #ifndef CopSTASH_set
6344 # define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)
6345 #endif
6346
6347 #ifndef CopSTASH_eq
6348 # define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
6349 || (CopSTASHPV(c) && HvNAME(hv) \
6350 && strEQ(CopSTASHPV(c), HvNAME(hv)))))
6351 #endif
6352
6353 #else
6354 #ifndef CopFILEGV
6355 # define CopFILEGV(c) ((c)->cop_filegv)
6356 #endif
6357
6358 #ifndef CopFILEGV_set
6359 # define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
6360 #endif
6361
6362 #ifndef CopFILE_set
6363 # define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv))
6364 #endif
6365
6366 #ifndef CopFILESV
6367 # define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
6368 #endif
6369
6370 #ifndef CopFILEAV
6371 # define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
6372 #endif
6373
6374 #ifndef CopFILE
6375 # define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
6376 #endif
6377
6378 #ifndef CopSTASH
6379 # define CopSTASH(c) ((c)->cop_stash)
6380 #endif
6381
6382 #ifndef CopSTASH_set
6383 # define CopSTASH_set(c,hv) ((c)->cop_stash = (hv))
6384 #endif
6385
6386 #ifndef CopSTASHPV
6387 # define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
6388 #endif
6389
6390 #ifndef CopSTASHPV_set
6391 # define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
6392 #endif
6393
6394 #ifndef CopSTASH_eq
6395 # define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv))
6396 #endif
6397
6398 #endif /* USE_ITHREADS */
6399 #ifndef IN_PERL_COMPILETIME
6400 # define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling)
6401 #endif
6402
6403 #ifndef IN_LOCALE_RUNTIME
6404 # define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE)
6405 #endif
6406
6407 #ifndef IN_LOCALE_COMPILETIME
6408 # define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE)
6409 #endif
6410
6411 #ifndef IN_LOCALE
6412 # define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME)
6413 #endif
6414 #ifndef IS_NUMBER_IN_UV
6415 # define IS_NUMBER_IN_UV 0x01
6416 #endif
6417
6418 #ifndef IS_NUMBER_GREATER_THAN_UV_MAX
6419 # define IS_NUMBER_GREATER_THAN_UV_MAX 0x02
6420 #endif
6421
6422 #ifndef IS_NUMBER_NOT_INT
6423 # define IS_NUMBER_NOT_INT 0x04
6424 #endif
6425
6426 #ifndef IS_NUMBER_NEG
6427 # define IS_NUMBER_NEG 0x08
6428 #endif
6429
6430 #ifndef IS_NUMBER_INFINITY
6431 # define IS_NUMBER_INFINITY 0x10
6432 #endif
6433
6434 #ifndef IS_NUMBER_NAN
6435 # define IS_NUMBER_NAN 0x20
6436 #endif
6437 #ifndef GROK_NUMERIC_RADIX
6438 # define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send)
6439 #endif
6440 #ifndef PERL_SCAN_GREATER_THAN_UV_MAX
6441 # define PERL_SCAN_GREATER_THAN_UV_MAX 0x02
6442 #endif
6443
6444 #ifndef PERL_SCAN_SILENT_ILLDIGIT
6445 # define PERL_SCAN_SILENT_ILLDIGIT 0x04
6446 #endif
6447
6448 #ifndef PERL_SCAN_ALLOW_UNDERSCORES
6449 # define PERL_SCAN_ALLOW_UNDERSCORES 0x01
6450 #endif
6451
6452 #ifndef PERL_SCAN_DISALLOW_PREFIX
6453 # define PERL_SCAN_DISALLOW_PREFIX 0x02
6454 #endif
6455
6456 #ifndef grok_numeric_radix
6457 #if defined(NEED_grok_numeric_radix)
6458 static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
6459 static
6460 #else
6461 extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
6462 #endif
6463
6464 #ifdef grok_numeric_radix
6465 # undef grok_numeric_radix
6466 #endif
6467 #define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
6468 #define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
6469
6470 #if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
6471 bool
DPPP_(my_grok_numeric_radix)6472 DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
6473 {
6474 #ifdef USE_LOCALE_NUMERIC
6475 #ifdef PL_numeric_radix_sv
6476 if (PL_numeric_radix_sv && IN_LOCALE) {
6477 STRLEN len;
6478 char* radix = SvPV(PL_numeric_radix_sv, len);
6479 if (*sp + len <= send && memEQ(*sp, radix, len)) {
6480 *sp += len;
6481 return TRUE;
6482 }
6483 }
6484 #else
6485 /* older perls don't have PL_numeric_radix_sv so the radix
6486 * must manually be requested from locale.h
6487 */
6488 #include <locale.h>
6489 dTHR; /* needed for older threaded perls */
6490 struct lconv *lc = localeconv();
6491 char *radix = lc->decimal_point;
6492 if (radix && IN_LOCALE) {
6493 STRLEN len = strlen(radix);
6494 if (*sp + len <= send && memEQ(*sp, radix, len)) {
6495 *sp += len;
6496 return TRUE;
6497 }
6498 }
6499 #endif
6500 #endif /* USE_LOCALE_NUMERIC */
6501 /* always try "." if numeric radix didn't match because
6502 * we may have data from different locales mixed */
6503 if (*sp < send && **sp == '.') {
6504 ++*sp;
6505 return TRUE;
6506 }
6507 return FALSE;
6508 }
6509 #endif
6510 #endif
6511
6512 #ifndef grok_number
6513 #if defined(NEED_grok_number)
6514 static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
6515 static
6516 #else
6517 extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
6518 #endif
6519
6520 #ifdef grok_number
6521 # undef grok_number
6522 #endif
6523 #define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
6524 #define Perl_grok_number DPPP_(my_grok_number)
6525
6526 #if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
6527 int
DPPP_(my_grok_number)6528 DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
6529 {
6530 const char *s = pv;
6531 const char *send = pv + len;
6532 const UV max_div_10 = UV_MAX / 10;
6533 const char max_mod_10 = UV_MAX % 10;
6534 int numtype = 0;
6535 int sawinf = 0;
6536 int sawnan = 0;
6537
6538 while (s < send && isSPACE(*s))
6539 s++;
6540 if (s == send) {
6541 return 0;
6542 } else if (*s == '-') {
6543 s++;
6544 numtype = IS_NUMBER_NEG;
6545 }
6546 else if (*s == '+')
6547 s++;
6548
6549 if (s == send)
6550 return 0;
6551
6552 /* next must be digit or the radix separator or beginning of infinity */
6553 if (isDIGIT(*s)) {
6554 /* UVs are at least 32 bits, so the first 9 decimal digits cannot
6555 overflow. */
6556 UV value = *s - '0';
6557 /* This construction seems to be more optimiser friendly.
6558 (without it gcc does the isDIGIT test and the *s - '0' separately)
6559 With it gcc on arm is managing 6 instructions (6 cycles) per digit.
6560 In theory the optimiser could deduce how far to unroll the loop
6561 before checking for overflow. */
6562 if (++s < send) {
6563 int digit = *s - '0';
6564 if (digit >= 0 && digit <= 9) {
6565 value = value * 10 + digit;
6566 if (++s < send) {
6567 digit = *s - '0';
6568 if (digit >= 0 && digit <= 9) {
6569 value = value * 10 + digit;
6570 if (++s < send) {
6571 digit = *s - '0';
6572 if (digit >= 0 && digit <= 9) {
6573 value = value * 10 + digit;
6574 if (++s < send) {
6575 digit = *s - '0';
6576 if (digit >= 0 && digit <= 9) {
6577 value = value * 10 + digit;
6578 if (++s < send) {
6579 digit = *s - '0';
6580 if (digit >= 0 && digit <= 9) {
6581 value = value * 10 + digit;
6582 if (++s < send) {
6583 digit = *s - '0';
6584 if (digit >= 0 && digit <= 9) {
6585 value = value * 10 + digit;
6586 if (++s < send) {
6587 digit = *s - '0';
6588 if (digit >= 0 && digit <= 9) {
6589 value = value * 10 + digit;
6590 if (++s < send) {
6591 digit = *s - '0';
6592 if (digit >= 0 && digit <= 9) {
6593 value = value * 10 + digit;
6594 if (++s < send) {
6595 /* Now got 9 digits, so need to check
6596 each time for overflow. */
6597 digit = *s - '0';
6598 while (digit >= 0 && digit <= 9
6599 && (value < max_div_10
6600 || (value == max_div_10
6601 && digit <= max_mod_10))) {
6602 value = value * 10 + digit;
6603 if (++s < send)
6604 digit = *s - '0';
6605 else
6606 break;
6607 }
6608 if (digit >= 0 && digit <= 9
6609 && (s < send)) {
6610 /* value overflowed.
6611 skip the remaining digits, don't
6612 worry about setting *valuep. */
6613 do {
6614 s++;
6615 } while (s < send && isDIGIT(*s));
6616 numtype |=
6617 IS_NUMBER_GREATER_THAN_UV_MAX;
6618 goto skip_value;
6619 }
6620 }
6621 }
6622 }
6623 }
6624 }
6625 }
6626 }
6627 }
6628 }
6629 }
6630 }
6631 }
6632 }
6633 }
6634 }
6635 }
6636 }
6637 numtype |= IS_NUMBER_IN_UV;
6638 if (valuep)
6639 *valuep = value;
6640
6641 skip_value:
6642 if (GROK_NUMERIC_RADIX(&s, send)) {
6643 numtype |= IS_NUMBER_NOT_INT;
6644 while (s < send && isDIGIT(*s)) /* optional digits after the radix */
6645 s++;
6646 }
6647 }
6648 else if (GROK_NUMERIC_RADIX(&s, send)) {
6649 numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */
6650 /* no digits before the radix means we need digits after it */
6651 if (s < send && isDIGIT(*s)) {
6652 do {
6653 s++;
6654 } while (s < send && isDIGIT(*s));
6655 if (valuep) {
6656 /* integer approximation is valid - it's 0. */
6657 *valuep = 0;
6658 }
6659 }
6660 else
6661 return 0;
6662 } else if (*s == 'I' || *s == 'i') {
6663 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6664 s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
6665 s++; if (s < send && (*s == 'I' || *s == 'i')) {
6666 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6667 s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
6668 s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
6669 s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
6670 s++;
6671 }
6672 sawinf = 1;
6673 } else if (*s == 'N' || *s == 'n') {
6674 /* XXX TODO: There are signaling NaNs and quiet NaNs. */
6675 s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
6676 s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
6677 s++;
6678 sawnan = 1;
6679 } else
6680 return 0;
6681
6682 if (sawinf) {
6683 numtype &= IS_NUMBER_NEG; /* Keep track of sign */
6684 numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;
6685 } else if (sawnan) {
6686 numtype &= IS_NUMBER_NEG; /* Keep track of sign */
6687 numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT;
6688 } else if (s < send) {
6689 /* we can have an optional exponent part */
6690 if (*s == 'e' || *s == 'E') {
6691 /* The only flag we keep is sign. Blow away any "it's UV" */
6692 numtype &= IS_NUMBER_NEG;
6693 numtype |= IS_NUMBER_NOT_INT;
6694 s++;
6695 if (s < send && (*s == '-' || *s == '+'))
6696 s++;
6697 if (s < send && isDIGIT(*s)) {
6698 do {
6699 s++;
6700 } while (s < send && isDIGIT(*s));
6701 }
6702 else
6703 return 0;
6704 }
6705 }
6706 while (s < send && isSPACE(*s))
6707 s++;
6708 if (s >= send)
6709 return numtype;
6710 if (len == 10 && memEQ(pv, "0 but true", 10)) {
6711 if (valuep)
6712 *valuep = 0;
6713 return IS_NUMBER_IN_UV;
6714 }
6715 return 0;
6716 }
6717 #endif
6718 #endif
6719
6720 /*
6721 * The grok_* routines have been modified to use warn() instead of
6722 * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit,
6723 * which is why the stack variable has been renamed to 'xdigit'.
6724 */
6725
6726 #ifndef grok_bin
6727 #if defined(NEED_grok_bin)
6728 static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6729 static
6730 #else
6731 extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6732 #endif
6733
6734 #ifdef grok_bin
6735 # undef grok_bin
6736 #endif
6737 #define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
6738 #define Perl_grok_bin DPPP_(my_grok_bin)
6739
6740 #if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
6741 UV
DPPP_(my_grok_bin)6742 DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6743 {
6744 const char *s = start;
6745 STRLEN len = *len_p;
6746 UV value = 0;
6747 NV value_nv = 0;
6748
6749 const UV max_div_2 = UV_MAX / 2;
6750 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6751 bool overflowed = FALSE;
6752
6753 if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
6754 /* strip off leading b or 0b.
6755 for compatibility silently suffer "b" and "0b" as valid binary
6756 numbers. */
6757 if (len >= 1) {
6758 if (s[0] == 'b') {
6759 s++;
6760 len--;
6761 }
6762 else if (len >= 2 && s[0] == '0' && s[1] == 'b') {
6763 s+=2;
6764 len-=2;
6765 }
6766 }
6767 }
6768
6769 for (; len-- && *s; s++) {
6770 char bit = *s;
6771 if (bit == '0' || bit == '1') {
6772 /* Write it in this wonky order with a goto to attempt to get the
6773 compiler to make the common case integer-only loop pretty tight.
6774 With gcc seems to be much straighter code than old scan_bin. */
6775 redo:
6776 if (!overflowed) {
6777 if (value <= max_div_2) {
6778 value = (value << 1) | (bit - '0');
6779 continue;
6780 }
6781 /* Bah. We're just overflowed. */
6782 warn("Integer overflow in binary number");
6783 overflowed = TRUE;
6784 value_nv = (NV) value;
6785 }
6786 value_nv *= 2.0;
6787 /* If an NV has not enough bits in its mantissa to
6788 * represent a UV this summing of small low-order numbers
6789 * is a waste of time (because the NV cannot preserve
6790 * the low-order bits anyway): we could just remember when
6791 * did we overflow and in the end just multiply value_nv by the
6792 * right amount. */
6793 value_nv += (NV)(bit - '0');
6794 continue;
6795 }
6796 if (bit == '_' && len && allow_underscores && (bit = s[1])
6797 && (bit == '0' || bit == '1'))
6798 {
6799 --len;
6800 ++s;
6801 goto redo;
6802 }
6803 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6804 warn("Illegal binary digit '%c' ignored", *s);
6805 break;
6806 }
6807
6808 if ( ( overflowed && value_nv > 4294967295.0)
6809 #if UVSIZE > 4
6810 || (!overflowed && value > 0xffffffff )
6811 #endif
6812 ) {
6813 warn("Binary number > 0b11111111111111111111111111111111 non-portable");
6814 }
6815 *len_p = s - start;
6816 if (!overflowed) {
6817 *flags = 0;
6818 return value;
6819 }
6820 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
6821 if (result)
6822 *result = value_nv;
6823 return UV_MAX;
6824 }
6825 #endif
6826 #endif
6827
6828 #ifndef grok_hex
6829 #if defined(NEED_grok_hex)
6830 static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6831 static
6832 #else
6833 extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6834 #endif
6835
6836 #ifdef grok_hex
6837 # undef grok_hex
6838 #endif
6839 #define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
6840 #define Perl_grok_hex DPPP_(my_grok_hex)
6841
6842 #if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
6843 UV
DPPP_(my_grok_hex)6844 DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6845 {
6846 const char *s = start;
6847 STRLEN len = *len_p;
6848 UV value = 0;
6849 NV value_nv = 0;
6850
6851 const UV max_div_16 = UV_MAX / 16;
6852 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6853 bool overflowed = FALSE;
6854 const char *xdigit;
6855
6856 if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) {
6857 /* strip off leading x or 0x.
6858 for compatibility silently suffer "x" and "0x" as valid hex numbers.
6859 */
6860 if (len >= 1) {
6861 if (s[0] == 'x') {
6862 s++;
6863 len--;
6864 }
6865 else if (len >= 2 && s[0] == '0' && s[1] == 'x') {
6866 s+=2;
6867 len-=2;
6868 }
6869 }
6870 }
6871
6872 for (; len-- && *s; s++) {
6873 xdigit = strchr((char *) PL_hexdigit, *s);
6874 if (xdigit) {
6875 /* Write it in this wonky order with a goto to attempt to get the
6876 compiler to make the common case integer-only loop pretty tight.
6877 With gcc seems to be much straighter code than old scan_hex. */
6878 redo:
6879 if (!overflowed) {
6880 if (value <= max_div_16) {
6881 value = (value << 4) | ((xdigit - PL_hexdigit) & 15);
6882 continue;
6883 }
6884 warn("Integer overflow in hexadecimal number");
6885 overflowed = TRUE;
6886 value_nv = (NV) value;
6887 }
6888 value_nv *= 16.0;
6889 /* If an NV has not enough bits in its mantissa to
6890 * represent a UV this summing of small low-order numbers
6891 * is a waste of time (because the NV cannot preserve
6892 * the low-order bits anyway): we could just remember when
6893 * did we overflow and in the end just multiply value_nv by the
6894 * right amount of 16-tuples. */
6895 value_nv += (NV)((xdigit - PL_hexdigit) & 15);
6896 continue;
6897 }
6898 if (*s == '_' && len && allow_underscores && s[1]
6899 && (xdigit = strchr((char *) PL_hexdigit, s[1])))
6900 {
6901 --len;
6902 ++s;
6903 goto redo;
6904 }
6905 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6906 warn("Illegal hexadecimal digit '%c' ignored", *s);
6907 break;
6908 }
6909
6910 if ( ( overflowed && value_nv > 4294967295.0)
6911 #if UVSIZE > 4
6912 || (!overflowed && value > 0xffffffff )
6913 #endif
6914 ) {
6915 warn("Hexadecimal number > 0xffffffff non-portable");
6916 }
6917 *len_p = s - start;
6918 if (!overflowed) {
6919 *flags = 0;
6920 return value;
6921 }
6922 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
6923 if (result)
6924 *result = value_nv;
6925 return UV_MAX;
6926 }
6927 #endif
6928 #endif
6929
6930 #ifndef grok_oct
6931 #if defined(NEED_grok_oct)
6932 static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6933 static
6934 #else
6935 extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
6936 #endif
6937
6938 #ifdef grok_oct
6939 # undef grok_oct
6940 #endif
6941 #define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
6942 #define Perl_grok_oct DPPP_(my_grok_oct)
6943
6944 #if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
6945 UV
DPPP_(my_grok_oct)6946 DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
6947 {
6948 const char *s = start;
6949 STRLEN len = *len_p;
6950 UV value = 0;
6951 NV value_nv = 0;
6952
6953 const UV max_div_8 = UV_MAX / 8;
6954 bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES;
6955 bool overflowed = FALSE;
6956
6957 for (; len-- && *s; s++) {
6958 /* gcc 2.95 optimiser not smart enough to figure that this subtraction
6959 out front allows slicker code. */
6960 int digit = *s - '0';
6961 if (digit >= 0 && digit <= 7) {
6962 /* Write it in this wonky order with a goto to attempt to get the
6963 compiler to make the common case integer-only loop pretty tight.
6964 */
6965 redo:
6966 if (!overflowed) {
6967 if (value <= max_div_8) {
6968 value = (value << 3) | digit;
6969 continue;
6970 }
6971 /* Bah. We're just overflowed. */
6972 warn("Integer overflow in octal number");
6973 overflowed = TRUE;
6974 value_nv = (NV) value;
6975 }
6976 value_nv *= 8.0;
6977 /* If an NV has not enough bits in its mantissa to
6978 * represent a UV this summing of small low-order numbers
6979 * is a waste of time (because the NV cannot preserve
6980 * the low-order bits anyway): we could just remember when
6981 * did we overflow and in the end just multiply value_nv by the
6982 * right amount of 8-tuples. */
6983 value_nv += (NV)digit;
6984 continue;
6985 }
6986 if (digit == ('_' - '0') && len && allow_underscores
6987 && (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
6988 {
6989 --len;
6990 ++s;
6991 goto redo;
6992 }
6993 /* Allow \octal to work the DWIM way (that is, stop scanning
6994 * as soon as non-octal characters are seen, complain only iff
6995 * someone seems to want to use the digits eight and nine). */
6996 if (digit == 8 || digit == 9) {
6997 if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
6998 warn("Illegal octal digit '%c' ignored", *s);
6999 }
7000 break;
7001 }
7002
7003 if ( ( overflowed && value_nv > 4294967295.0)
7004 #if UVSIZE > 4
7005 || (!overflowed && value > 0xffffffff )
7006 #endif
7007 ) {
7008 warn("Octal number > 037777777777 non-portable");
7009 }
7010 *len_p = s - start;
7011 if (!overflowed) {
7012 *flags = 0;
7013 return value;
7014 }
7015 *flags = PERL_SCAN_GREATER_THAN_UV_MAX;
7016 if (result)
7017 *result = value_nv;
7018 return UV_MAX;
7019 }
7020 #endif
7021 #endif
7022
7023 #if !defined(my_snprintf)
7024 #if defined(NEED_my_snprintf)
7025 static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
7026 static
7027 #else
7028 extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
7029 #endif
7030
7031 #define my_snprintf DPPP_(my_my_snprintf)
7032 #define Perl_my_snprintf DPPP_(my_my_snprintf)
7033
7034 #if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
7035
7036 int
DPPP_(my_my_snprintf)7037 DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
7038 {
7039 dTHX;
7040 int retval;
7041 va_list ap;
7042 va_start(ap, format);
7043 #ifdef HAS_VSNPRINTF
7044 retval = vsnprintf(buffer, len, format, ap);
7045 #else
7046 retval = vsprintf(buffer, format, ap);
7047 #endif
7048 va_end(ap);
7049 if (retval < 0 || (len > 0 && (Size_t)retval >= len))
7050 Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
7051 return retval;
7052 }
7053
7054 #endif
7055 #endif
7056
7057 #if !defined(my_sprintf)
7058 #if defined(NEED_my_sprintf)
7059 static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
7060 static
7061 #else
7062 extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
7063 #endif
7064
7065 #define my_sprintf DPPP_(my_my_sprintf)
7066 #define Perl_my_sprintf DPPP_(my_my_sprintf)
7067
7068 #if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
7069
7070 int
DPPP_(my_my_sprintf)7071 DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
7072 {
7073 va_list args;
7074 va_start(args, pat);
7075 vsprintf(buffer, pat, args);
7076 va_end(args);
7077 return strlen(buffer);
7078 }
7079
7080 #endif
7081 #endif
7082
7083 #ifdef NO_XSLOCKS
7084 # ifdef dJMPENV
7085 # define dXCPT dJMPENV; int rEtV = 0
7086 # define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0)
7087 # define XCPT_TRY_END JMPENV_POP;
7088 # define XCPT_CATCH if (rEtV != 0)
7089 # define XCPT_RETHROW JMPENV_JUMP(rEtV)
7090 # else
7091 # define dXCPT Sigjmp_buf oldTOP; int rEtV = 0
7092 # define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0)
7093 # define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf);
7094 # define XCPT_CATCH if (rEtV != 0)
7095 # define XCPT_RETHROW Siglongjmp(top_env, rEtV)
7096 # endif
7097 #endif
7098
7099 #if !defined(my_strlcat)
7100 #if defined(NEED_my_strlcat)
7101 static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
7102 static
7103 #else
7104 extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
7105 #endif
7106
7107 #define my_strlcat DPPP_(my_my_strlcat)
7108 #define Perl_my_strlcat DPPP_(my_my_strlcat)
7109
7110 #if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
7111
7112 Size_t
DPPP_(my_my_strlcat)7113 DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
7114 {
7115 Size_t used, length, copy;
7116
7117 used = strlen(dst);
7118 length = strlen(src);
7119 if (size > 0 && used < size - 1) {
7120 copy = (length >= size - used) ? size - used - 1 : length;
7121 memcpy(dst + used, src, copy);
7122 dst[used + copy] = '\0';
7123 }
7124 return used + length;
7125 }
7126 #endif
7127 #endif
7128
7129 #if !defined(my_strlcpy)
7130 #if defined(NEED_my_strlcpy)
7131 static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
7132 static
7133 #else
7134 extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
7135 #endif
7136
7137 #define my_strlcpy DPPP_(my_my_strlcpy)
7138 #define Perl_my_strlcpy DPPP_(my_my_strlcpy)
7139
7140 #if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
7141
7142 Size_t
DPPP_(my_my_strlcpy)7143 DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
7144 {
7145 Size_t length, copy;
7146
7147 length = strlen(src);
7148 if (size > 0) {
7149 copy = (length >= size) ? size - 1 : length;
7150 memcpy(dst, src, copy);
7151 dst[copy] = '\0';
7152 }
7153 return length;
7154 }
7155
7156 #endif
7157 #endif
7158 #ifndef PERL_PV_ESCAPE_QUOTE
7159 # define PERL_PV_ESCAPE_QUOTE 0x0001
7160 #endif
7161
7162 #ifndef PERL_PV_PRETTY_QUOTE
7163 # define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE
7164 #endif
7165
7166 #ifndef PERL_PV_PRETTY_ELLIPSES
7167 # define PERL_PV_PRETTY_ELLIPSES 0x0002
7168 #endif
7169
7170 #ifndef PERL_PV_PRETTY_LTGT
7171 # define PERL_PV_PRETTY_LTGT 0x0004
7172 #endif
7173
7174 #ifndef PERL_PV_ESCAPE_FIRSTCHAR
7175 # define PERL_PV_ESCAPE_FIRSTCHAR 0x0008
7176 #endif
7177
7178 #ifndef PERL_PV_ESCAPE_UNI
7179 # define PERL_PV_ESCAPE_UNI 0x0100
7180 #endif
7181
7182 #ifndef PERL_PV_ESCAPE_UNI_DETECT
7183 # define PERL_PV_ESCAPE_UNI_DETECT 0x0200
7184 #endif
7185
7186 #ifndef PERL_PV_ESCAPE_ALL
7187 # define PERL_PV_ESCAPE_ALL 0x1000
7188 #endif
7189
7190 #ifndef PERL_PV_ESCAPE_NOBACKSLASH
7191 # define PERL_PV_ESCAPE_NOBACKSLASH 0x2000
7192 #endif
7193
7194 #ifndef PERL_PV_ESCAPE_NOCLEAR
7195 # define PERL_PV_ESCAPE_NOCLEAR 0x4000
7196 #endif
7197
7198 #ifndef PERL_PV_ESCAPE_RE
7199 # define PERL_PV_ESCAPE_RE 0x8000
7200 #endif
7201
7202 #ifndef PERL_PV_PRETTY_NOCLEAR
7203 # define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR
7204 #endif
7205 #ifndef PERL_PV_PRETTY_DUMP
7206 # define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE
7207 #endif
7208
7209 #ifndef PERL_PV_PRETTY_REGPROP
7210 # define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
7211 #endif
7212
7213 /* Hint: pv_escape
7214 * Note that unicode functionality is only backported to
7215 * those perl versions that support it. For older perl
7216 * versions, the implementation will fall back to bytes.
7217 */
7218
7219 #ifndef pv_escape
7220 #if defined(NEED_pv_escape)
7221 static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
7222 static
7223 #else
7224 extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
7225 #endif
7226
7227 #ifdef pv_escape
7228 # undef pv_escape
7229 #endif
7230 #define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
7231 #define Perl_pv_escape DPPP_(my_pv_escape)
7232
7233 #if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
7234
7235 char *
DPPP_(my_pv_escape)7236 DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
7237 const STRLEN count, const STRLEN max,
7238 STRLEN * const escaped, const U32 flags)
7239 {
7240 const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';
7241 const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;
7242 char octbuf[32] = "%123456789ABCDF";
7243 STRLEN wrote = 0;
7244 STRLEN chsize = 0;
7245 STRLEN readsize = 1;
7246 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
7247 bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;
7248 #endif
7249 const char *pv = str;
7250 const char * const end = pv + count;
7251 octbuf[0] = esc;
7252
7253 if (!(flags & PERL_PV_ESCAPE_NOCLEAR))
7254 sv_setpvs(dsv, "");
7255
7256 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
7257 if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
7258 isuni = 1;
7259 #endif
7260
7261 for (; pv < end && (!max || wrote < max) ; pv += readsize) {
7262 const UV u =
7263 #if defined(is_utf8_string) && defined(utf8_to_uvchr)
7264 isuni ? utf8_to_uvchr((U8*)pv, &readsize) :
7265 #endif
7266 (U8)*pv;
7267 const U8 c = (U8)u & 0xFF;
7268
7269 if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) {
7270 if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
7271 chsize = my_snprintf(octbuf, sizeof octbuf,
7272 "%"UVxf, u);
7273 else
7274 chsize = my_snprintf(octbuf, sizeof octbuf,
7275 "%cx{%"UVxf"}", esc, u);
7276 } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
7277 chsize = 1;
7278 } else {
7279 if (c == dq || c == esc || !isPRINT(c)) {
7280 chsize = 2;
7281 switch (c) {
7282 case '\\' : /* fallthrough */
7283 case '%' : if (c == esc)
7284 octbuf[1] = esc;
7285 else
7286 chsize = 1;
7287 break;
7288 case '\v' : octbuf[1] = 'v'; break;
7289 case '\t' : octbuf[1] = 't'; break;
7290 case '\r' : octbuf[1] = 'r'; break;
7291 case '\n' : octbuf[1] = 'n'; break;
7292 case '\f' : octbuf[1] = 'f'; break;
7293 case '"' : if (dq == '"')
7294 octbuf[1] = '"';
7295 else
7296 chsize = 1;
7297 break;
7298 default: chsize = my_snprintf(octbuf, sizeof octbuf,
7299 pv < end && isDIGIT((U8)*(pv+readsize))
7300 ? "%c%03o" : "%c%o", esc, c);
7301 }
7302 } else {
7303 chsize = 1;
7304 }
7305 }
7306 if (max && wrote + chsize > max) {
7307 break;
7308 } else if (chsize > 1) {
7309 sv_catpvn(dsv, octbuf, chsize);
7310 wrote += chsize;
7311 } else {
7312 char tmp[2];
7313 my_snprintf(tmp, sizeof tmp, "%c", c);
7314 sv_catpvn(dsv, tmp, 1);
7315 wrote++;
7316 }
7317 if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
7318 break;
7319 }
7320 if (escaped != NULL)
7321 *escaped= pv - str;
7322 return SvPVX(dsv);
7323 }
7324
7325 #endif
7326 #endif
7327
7328 #ifndef pv_pretty
7329 #if defined(NEED_pv_pretty)
7330 static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
7331 static
7332 #else
7333 extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
7334 #endif
7335
7336 #ifdef pv_pretty
7337 # undef pv_pretty
7338 #endif
7339 #define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
7340 #define Perl_pv_pretty DPPP_(my_pv_pretty)
7341
7342 #if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
7343
7344 char *
DPPP_(my_pv_pretty)7345 DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
7346 const STRLEN max, char const * const start_color, char const * const end_color,
7347 const U32 flags)
7348 {
7349 const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
7350 STRLEN escaped;
7351
7352 if (!(flags & PERL_PV_PRETTY_NOCLEAR))
7353 sv_setpvs(dsv, "");
7354
7355 if (dq == '"')
7356 sv_catpvs(dsv, "\"");
7357 else if (flags & PERL_PV_PRETTY_LTGT)
7358 sv_catpvs(dsv, "<");
7359
7360 if (start_color != NULL)
7361 sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));
7362
7363 pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR);
7364
7365 if (end_color != NULL)
7366 sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));
7367
7368 if (dq == '"')
7369 sv_catpvs(dsv, "\"");
7370 else if (flags & PERL_PV_PRETTY_LTGT)
7371 sv_catpvs(dsv, ">");
7372
7373 if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)
7374 sv_catpvs(dsv, "...");
7375
7376 return SvPVX(dsv);
7377 }
7378
7379 #endif
7380 #endif
7381
7382 #ifndef pv_display
7383 #if defined(NEED_pv_display)
7384 static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
7385 static
7386 #else
7387 extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
7388 #endif
7389
7390 #ifdef pv_display
7391 # undef pv_display
7392 #endif
7393 #define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
7394 #define Perl_pv_display DPPP_(my_pv_display)
7395
7396 #if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
7397
7398 char *
DPPP_(my_pv_display)7399 DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
7400 {
7401 pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
7402 if (len > cur && pv[cur] == '\0')
7403 sv_catpvs(dsv, "\\0");
7404 return SvPVX(dsv);
7405 }
7406
7407 #endif
7408 #endif
7409
7410 #endif /* _P_P_PORTABILITY_H_ */
7411
7412 /* End of File ppport.h */
7413