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