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