Commit c1f3d56dd8450d8ded2b0964cadbb885ed41b644 - libcompress-raw-lzma-perl

import Compress-Raw-Lzma 2.057 2.057 10 November 2012 * update to ppport.h that includes SvPV_nomg_nolen * added PERL_NO_GET_CONTEXT git-cpan-module: Compress-Raw-Lzma git-cpan-version: 2.057 git-cpan-authorid: pmqs pmqs 11 years ago

8 changed file(s) with 2265 addition(s) and 663 deletion(s). Raw diff Collapse all Expand all

-0

Changes less more

0	0	CHANGES
1	1	-------
	2
	3	2.057 10 November 2012
	4
	5	* update to ppport.h that includes SvPV_nomg_nolen
	6	* added PERL_NO_GET_CONTEXT
2	7
3	8	2.055 5 August 2012
4	9

+11

-6

Lzma.xs less more

9	9	*/
10	10
11	11
	12	#define PERL_NO_GET_CONTEXT
12	13	#include "EXTERN.h"
13	14	#include "perl.h"
14	15	#include "XSUB.h"

230	231	char * message;
231	232	#endif
232	233	{
	234	dTHX;
233	235
234	236	#if 0
235	237	if (! trace)

288	290	InitStream()
289	291	#endif
290	292	{
	293	dTHX;
291	294	di_stream *s ;
292	295
293	296	ZMALLOC(s, di_stream) ;

316	319	bool
317	320	setupFilters(di_stream* s, AV* filters, const char* properties)
318	321	{
	322	dTHX;
319	323	int i = 0;
320	324
321	325	if (properties) {

352	356	void
353	357	destroyStream(di_stream * s)
354	358	{
	359	dTHX;
355	360	if (s)
356	361	{
357	362	int i;

546	551	SV* output ;
547	552	#endif
548	553	{
	554	dTHX;
549	555	uint32_t size;
550	556	int cur_length = SvCUR(output) ;
551	557	lzma_ret status = lzma_properties_size(&size, &s->filters[0]);

861	867	if (DO_UTF8(buf) && !sv_utf8_downgrade(buf, 1))
862	868	croak("Wide character in " COMPRESS_CLASS "::code input parameter");
863	869	#endif
864		s->stream.next_in = (uint8_t*)SvPVbyte_nolen(buf) ;
	870	s->stream.next_in = (uint8_t*)SvPV_nomg_nolen(buf) ;
865	871	s->stream.avail_in = SvCUR(buf) ;
866	872
867	873	//if (is_tainted)

889	895
890	896	if (s->stream.avail_out == 0) {
891	897	/* out of space in the output buffer so make it bigger */
892		s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
	898	s->stream.next_out = (uint8_t*)Sv_Grow(output, SvLEN(output) + bufinc) ;
893	899	cur_length += increment ;
894	900	s->stream.next_out += cur_length ;
895	901	increment = bufinc ;

970	976	for (;;) {
971	977	if (s->stream.avail_out == 0) {
972	978	/* consumed all the available output, so extend it */
973		s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc) ;
	979	s->stream.next_out = (uint8_t*)Sv_Grow(output, SvLEN(output) + bufinc) ;
974	980	cur_length += increment ;
975	981	s->stream.next_out += cur_length ;
976	982	increment = bufinc ;

1139	1145	uInt cur_length = 0;
1140	1146	uInt prefix_length = 0;
1141	1147	uInt increment = 0;
1142		STRLEN stmp = NO_INIT
1143	1148	uInt bufinc = NO_INIT
1144	1149	PREINIT:
1145	1150	#ifdef UTF8_AVAILABLE

1161	1166	#endif
1162	1167
1163	1168	/* initialise the input buffer */
1164		s->stream.next_in = (uint8_t*)SvPVbyte_force(buf, stmp) ;
	1169	s->stream.next_in = (uint8_t*)SvPV_nomg_nolen(buf) ;
1165	1170	s->stream.avail_in = SvCUR(buf);
1166	1171
1167	1172	/* and retrieve the output buffer */

1207	1212
1208	1213	if (s->stream.avail_out == 0) {
1209	1214	/* out of space in the output buffer so make it bigger */
1210		s->stream.next_out = Sv_Grow(output, SvLEN(output) + bufinc + 1) ;
	1215	s->stream.next_out = (uint8_t*)Sv_Grow(output, SvLEN(output) + bufinc + 1) ;
1211	1216	cur_length += increment ;
1212	1217	s->stream.next_out += cur_length ;
1213	1218	increment = bufinc ;

-1

META.json less more

36	36	}
37	37	},
38	38	"release_status" : "stable",
39		"version" : "2.055"
	39	"version" : "2.057"
40	40	}

-1

META.yml less more

19	19	- t
20	20	- private
21	21	requires: {}
22		version: 2.055
	22	version: 2.057

-3

README less more

0	0
1	1	Compress-Raw-Lzma
2	2
3		Version 2.055
	3	Version 2.057
4	4
5		5th August 2012
	5	10th November 2012
6	6
7	7	Copyright (c) 2009-2012 Paul Marquess. All rights reserved.
8	8	This program is free software; you can redistribute it

160	160	If you haven't installed Compress-Raw-Lzma then search Compress::Raw::Lzma.pm
161	161	for a line like this:
162	162
163		$VERSION = "2.055" ;
	163	$VERSION = "2.057" ;
164	164
165	165	c. The version of lzma you have used.
166	166	If you have successfully installed Compress-Raw-Lzma, this one-liner

-1

lib/Compress/Raw/Lzma.pm less more

11	11	use bytes ;
12	12	our ($VERSION, $XS_VERSION, @ISA, @EXPORT, $AUTOLOAD);
13	13
14		$VERSION = '2.055';
	14	$VERSION = '2.057';
15	15	$XS_VERSION = $VERSION;
16	16	$VERSION = eval $VERSION;
17	17

+2242

-650

ppport.h less more

3	3	/*
4	4	----------------------------------------------------------------------
5	5
6		ppport.h -- Perl/Pollution/Portability Version 3.10
7
8		Automatically created by Devel::PPPort running under perl 5.009004.
	6	ppport.h -- Perl/Pollution/Portability Version 3.20_01
	7
	8	Automatically created by Devel::PPPort running under perl 5.016001.
9	9
10	10	Do NOT edit this file directly! -- Edit PPPort_pm.PL and the
11	11	includes in parts/inc/ instead.

20	20
21	21	=head1 NAME
22	22
23		ppport.h - Perl/Pollution/Portability version 3.10
	23	ppport.h - Perl/Pollution/Portability version 3.20_01
24	24
25	25	=head1 SYNOPSIS
26	26

55	55	=head1 COMPATIBILITY
56	56
57	57	This version of F<ppport.h> is designed to support operation with Perl
58		installations back to 5.003, and has been tested up to 5.9.4.
	58	installations back to 5.003, and has been tested up to 5.11.5.
59	59
60	60	=head1 OPTIONS
61	61

77	77
78	78	If this option is given, a copy of each file will be saved with
79	79	the given suffix that contains the suggested changes. This does
80		not require any external programs.
	80	not require any external programs. Note that this does not
	81	automagially add a dot between the original filename and the
	82	suffix. If you want the dot, you have to include it in the option
	83	argument.
81	84
82	85	If neither C<--patch> or C<--copy> are given, the default is to
83	86	simply print the diffs for each file. This requires either

116	119	=head2 --nohints
117	120
118	121	Don't output any hints. Hints often contain useful portability
119		notes.
	122	notes. Warnings will still be displayed.
120	123
121	124	=head2 --nochanges
122	125

143	146
144	147	Lists the API elements for which compatibility is provided by
145	148	F<ppport.h>. Also lists if it must be explicitly requested,
146		if it has dependencies, and if there are hints for it.
	149	if it has dependencies, and if there are hints or warnings for it.
147	150
148	151	=head2 --list-unsupported
149	152

213	216
214	217	Function / Variable Static Request Global Request
215	218	-----------------------------------------------------------------------------------------
	219	PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL
216	220	PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL
217	221	eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL
218	222	grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL

220	224	grok_number() NEED_grok_number NEED_grok_number_GLOBAL
221	225	grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL
222	226	grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL
	227	load_module() NEED_load_module NEED_load_module_GLOBAL
223	228	my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL
	229	my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL
224	230	my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL
225	231	my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL
226	232	newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL
227	233	newRV_noinc() NEED_newRV_noinc NEED_newRV_noinc_GLOBAL
228		sv_2pv_nolen() NEED_sv_2pv_nolen NEED_sv_2pv_nolen_GLOBAL
	234	newSV_type() NEED_newSV_type NEED_newSV_type_GLOBAL
	235	newSVpvn_flags() NEED_newSVpvn_flags NEED_newSVpvn_flags_GLOBAL
	236	newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL
	237	pv_display() NEED_pv_display NEED_pv_display_GLOBAL
	238	pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL
	239	pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL
	240	sv_2pv_flags() NEED_sv_2pv_flags NEED_sv_2pv_flags_GLOBAL
229	241	sv_2pvbyte() NEED_sv_2pvbyte NEED_sv_2pvbyte_GLOBAL
230	242	sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL
231	243	sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL
	244	sv_pvn_force_flags() NEED_sv_pvn_force_flags NEED_sv_pvn_force_flags_GLOBAL
232	245	sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL
233	246	sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL
	247	vload_module() NEED_vload_module NEED_vload_module_GLOBAL
234	248	vnewSVpvf() NEED_vnewSVpvf NEED_vnewSVpvf_GLOBAL
235	249	warner() NEED_warner NEED_warner_GLOBAL
236	250

281	295
282	296	This would output context diffs with 10 lines of context.
283	297
	298	If you want to create patched copies of your files instead, use:
	299
	300	perl ppport.h --copy=.new
	301
284	302	To display portability information for the C<newSVpvn> function,
285	303	use:
286	304

339	357
340	358	=head1 COPYRIGHT
341	359
342		Version 3.x, Copyright (c) 2004-2006, Marcus Holland-Moritz.
	360	Version 3.x, Copyright (c) 2004-2012, Marcus Holland-Moritz.
343	361
344	362	Version 2.x, Copyright (C) 2001, Paul Marquess.
345	363

356	374
357	375	use strict;
358	376
359		my $VERSION = 3.10;
	377	# Disable broken TRIE-optimization
	378	BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if $] >= 5.009004 && $] <= 5.009005 }
	379
	380	my $VERSION = 3.20_01;
360	381
361	382	my %opt = (
362	383	quiet => 0,

372	393	my($ppport) = $0 =~ /([\w.]+)$/;
373	394	my $LF = '(?:\r\n\|[\r\n])'; # line feed
374	395	my $HS = "[ \t]"; # horizontal whitespace
	396
	397	# Never use C comments in this file!
	398	my $ccs = '/'.'*';
	399	my $cce = '*'.'/';
	400	my $rccs = quotemeta $ccs;
	401	my $rcce = quotemeta $cce;
375	402
376	403	eval {
377	404	require Getopt::Long;

408	435	$opt{'compat-version'} = 5;
409	436	}
410	437
411		# Never use C comments in this file!!!!!
412		my $ccs = '/'.'*';
413		my $cce = '*'.'/';
414		my $rccs = quotemeta $ccs;
415		my $rcce = quotemeta $cce;
416
417	438	my %API = map { /^(\w+)\\|([^\|])\\|([^\|])\\|(\w*)$/
418	439	? ( $1 => {
419	440	($2 ? ( base => $2 ) : ()),

425	446	: die "invalid spec: $_" } qw(
426	447	AvFILLp\|5.004050\|\|p
427	448	AvFILL\|\|\|
	449	BhkDISABLE\|\|5.017004\|
	450	BhkENABLE\|\|5.017004\|
	451	BhkENTRY_set\|\|5.017004\|
	452	BhkENTRY\|\|\|
	453	BhkFLAGS\|\|\|
	454	CALL_BLOCK_HOOKS\|\|\|
428	455	CLASS\|\|\|n
	456	CPERLscope\|5.005000\|\|p
429	457	CX_CURPAD_SAVE\|\|\|
430	458	CX_CURPAD_SV\|\|\|
431	459	CopFILEAV\|5.006000\|\|p

439	467	CopSTASH_eq\|5.006000\|\|p
440	468	CopSTASH_set\|5.006000\|\|p
441	469	CopSTASH\|5.006000\|\|p
442		CopyD\|5.009002\|\|p
	470	CopyD\|5.009002\|5.004050\|p
443	471	Copy\|\|\|
444		CvPADLIST\|\|\|
	472	CvPADLIST\|\|5.008001\|
445	473	CvSTASH\|\|\|
446	474	CvWEAKOUTSIDE\|\|\|
	475	DEFSV_set\|5.010001\|\|p
447	476	DEFSV\|5.004050\|\|p
448	477	END_EXTERN_C\|5.005000\|\|p
449	478	ENTER\|\|\|

458	487	G_ARRAY\|\|\|
459	488	G_DISCARD\|\|\|
460	489	G_EVAL\|\|\|
	490	G_METHOD\|5.006001\|\|p
461	491	G_NOARGS\|\|\|
462	492	G_SCALAR\|\|\|
463	493	G_VOID\|\|5.004000\|
464	494	GetVars\|\|\|
	495	GvAV\|\|\|
	496	GvCV\|\|\|
	497	GvHV\|\|\|
	498	GvSVn\|5.009003\|\|p
465	499	GvSV\|\|\|
466		Gv_AMupdate\|\|\|
	500	Gv_AMupdate\|\|5.011000\|
467	501	HEf_SVKEY\|\|5.004000\|
468	502	HeHASH\|\|5.004000\|
469	503	HeKEY\|\|5.004000\|

472	506	HeSVKEY_force\|\|5.004000\|
473	507	HeSVKEY_set\|\|5.004000\|
474	508	HeSVKEY\|\|5.004000\|
	509	HeUTF8\|\|5.010001\|
475	510	HeVAL\|\|5.004000\|
	511	HvENAMELEN\|\|5.015004\|
	512	HvENAMEUTF8\|\|5.015004\|
	513	HvENAME\|\|5.013007\|
	514	HvNAMELEN_get\|5.009003\|\|p
	515	HvNAMELEN\|\|5.015004\|
	516	HvNAMEUTF8\|\|5.015004\|
	517	HvNAME_get\|5.009003\|\|p
476	518	HvNAME\|\|\|
477	519	INT2PTR\|5.006000\|\|p
478	520	IN_LOCALE_COMPILETIME\|5.007002\|\|p

489	531	IVTYPE\|5.006000\|\|p
490	532	IVdf\|5.006000\|\|p
491	533	LEAVE\|\|\|
	534	LINKLIST\|\|5.013006\|
492	535	LVRET\|\|\|
493	536	MARK\|\|\|
494		MULTICALL\|\|5.009004\|
	537	MULTICALL\|\|5.017004\|
495	538	MY_CXT_CLONE\|5.009002\|\|p
496	539	MY_CXT_INIT\|5.007003\|\|p
497	540	MY_CXT\|5.007003\|\|p
498		MoveD\|5.009002\|\|p
	541	MoveD\|5.009002\|5.004050\|p
499	542	Move\|\|\|
500	543	NOOP\|5.005000\|\|p
501	544	NUM2PTR\|5.006000\|\|p

511	554	Nullcv\|\|\|
512	555	Nullhv\|\|\|
513	556	Nullsv\|\|\|
	557	OP_CLASS\|\|5.013007\|
	558	OP_DESC\|\|5.007003\|
	559	OP_NAME\|\|5.007003\|
514	560	ORIGMARK\|\|\|
515	561	PAD_BASE_SV\|\|\|
516	562	PAD_CLONE_VARS\|\|\|

528	574	PAD_SET_CUR\|\|\|
529	575	PAD_SVl\|\|\|
530	576	PAD_SV\|\|\|
	577	PERLIO_FUNCS_CAST\|5.009003\|\|p
	578	PERLIO_FUNCS_DECL\|5.009003\|\|p
531	579	PERL_ABS\|5.008001\|\|p
532		PERL_BCDVERSION\|5.009004\|\|p
	580	PERL_BCDVERSION\|5.017004\|\|p
533	581	PERL_GCC_BRACE_GROUPS_FORBIDDEN\|5.008001\|\|p
	582	PERL_HASH\|5.004000\|\|p
534	583	PERL_INT_MAX\|5.004000\|\|p
535	584	PERL_INT_MIN\|5.004000\|\|p
536	585	PERL_LONG_MAX\|5.004000\|\|p

546	595	PERL_MAGIC_env\|5.007002\|\|p
547	596	PERL_MAGIC_ext\|5.007002\|\|p
548	597	PERL_MAGIC_fm\|5.007002\|\|p
549		PERL_MAGIC_glob\|5.007002\|\|p
	598	PERL_MAGIC_glob\|5.017004\|\|p
550	599	PERL_MAGIC_isaelem\|5.007002\|\|p
551	600	PERL_MAGIC_isa\|5.007002\|\|p
552		PERL_MAGIC_mutex\|5.007002\|\|p
	601	PERL_MAGIC_mutex\|5.017004\|\|p
553	602	PERL_MAGIC_nkeys\|5.007002\|\|p
554		PERL_MAGIC_overload_elem\|5.007002\|\|p
	603	PERL_MAGIC_overload_elem\|5.017004\|\|p
555	604	PERL_MAGIC_overload_table\|5.007002\|\|p
556		PERL_MAGIC_overload\|5.007002\|\|p
	605	PERL_MAGIC_overload\|5.017004\|\|p
557	606	PERL_MAGIC_pos\|5.007002\|\|p
558	607	PERL_MAGIC_qr\|5.007002\|\|p
559	608	PERL_MAGIC_regdata\|5.007002\|\|p

574	623	PERL_MAGIC_uvar\|5.007002\|\|p
575	624	PERL_MAGIC_vec\|5.007002\|\|p
576	625	PERL_MAGIC_vstring\|5.008001\|\|p
	626	PERL_PV_ESCAPE_ALL\|5.009004\|\|p
	627	PERL_PV_ESCAPE_FIRSTCHAR\|5.009004\|\|p
	628	PERL_PV_ESCAPE_NOBACKSLASH\|5.009004\|\|p
	629	PERL_PV_ESCAPE_NOCLEAR\|5.009004\|\|p
	630	PERL_PV_ESCAPE_QUOTE\|5.009004\|\|p
	631	PERL_PV_ESCAPE_RE\|5.009005\|\|p
	632	PERL_PV_ESCAPE_UNI_DETECT\|5.009004\|\|p
	633	PERL_PV_ESCAPE_UNI\|5.009004\|\|p
	634	PERL_PV_PRETTY_DUMP\|5.009004\|\|p
	635	PERL_PV_PRETTY_ELLIPSES\|5.010000\|\|p
	636	PERL_PV_PRETTY_LTGT\|5.009004\|\|p
	637	PERL_PV_PRETTY_NOCLEAR\|5.010000\|\|p
	638	PERL_PV_PRETTY_QUOTE\|5.009004\|\|p
	639	PERL_PV_PRETTY_REGPROP\|5.009004\|\|p
577	640	PERL_QUAD_MAX\|5.004000\|\|p
578	641	PERL_QUAD_MIN\|5.004000\|\|p
579	642	PERL_REVISION\|5.006000\|\|p

585	648	PERL_SHORT_MIN\|5.004000\|\|p
586	649	PERL_SIGNALS_UNSAFE_FLAG\|5.008001\|\|p
587	650	PERL_SUBVERSION\|5.006000\|\|p
	651	PERL_SYS_INIT3\|\|5.006000\|
	652	PERL_SYS_INIT\|\|\|
	653	PERL_SYS_TERM\|\|5.017004\|
588	654	PERL_UCHAR_MAX\|5.004000\|\|p
589	655	PERL_UCHAR_MIN\|5.004000\|\|p
590	656	PERL_UINT_MAX\|5.004000\|\|p

601	667	PERL_USHORT_MAX\|5.004000\|\|p
602	668	PERL_USHORT_MIN\|5.004000\|\|p
603	669	PERL_VERSION\|5.006000\|\|p
	670	PL_DBsignal\|5.005000\|\|p
604	671	PL_DBsingle\|\|\|pn
605	672	PL_DBsub\|\|\|pn
606		PL_DBtrace\|\|\|n
	673	PL_DBtrace\|\|\|pn
607	674	PL_Sv\|5.005000\|\|p
	675	PL_bufend\|5.017004\|\|p
	676	PL_bufptr\|5.017004\|\|p
	677	PL_check\|\|5.006000\|
608	678	PL_compiling\|5.004050\|\|p
609		PL_copline\|5.005000\|\|p
	679	PL_comppad_name\|\|5.017004\|
	680	PL_comppad\|\|5.008001\|
	681	PL_copline\|5.017004\|\|p
610	682	PL_curcop\|5.004050\|\|p
	683	PL_curpad\|\|5.005000\|
611	684	PL_curstash\|5.004050\|\|p
612	685	PL_debstash\|5.004050\|\|p
613	686	PL_defgv\|5.004050\|\|p

615	688	PL_dirty\|5.004050\|\|p
616	689	PL_dowarn\|\|\|pn
617	690	PL_errgv\|5.004050\|\|p
	691	PL_error_count\|5.017004\|\|p
	692	PL_expect\|5.017004\|\|p
618	693	PL_hexdigit\|5.005000\|\|p
619	694	PL_hints\|5.005000\|\|p
	695	PL_in_my_stash\|5.017004\|\|p
	696	PL_in_my\|5.017004\|\|p
	697	PL_keyword_plugin\|\|5.011002\|
620	698	PL_last_in_gv\|\|\|n
	699	PL_laststatval\|5.005000\|\|p
	700	PL_lex_state\|5.017004\|\|p
	701	PL_lex_stuff\|5.017004\|\|p
	702	PL_linestr\|5.017004\|\|p
621	703	PL_modglobal\|\|5.005000\|n
622	704	PL_na\|5.004050\|\|pn
623	705	PL_no_modify\|5.006000\|\|p
624		PL_ofs_sv\|\|\|n
	706	PL_ofsgv\|\|\|n
	707	PL_opfreehook\|\|5.011000\|n
	708	PL_parser\|5.009005\|5.009005\|p
	709	PL_peepp\|\|5.007003\|n
625	710	PL_perl_destruct_level\|5.004050\|\|p
626	711	PL_perldb\|5.004050\|\|p
627	712	PL_ppaddr\|5.006000\|\|p
628		PL_rsfp_filters\|5.004050\|\|p
629		PL_rsfp\|5.004050\|\|p
	713	PL_rpeepp\|\|5.013005\|n
	714	PL_rsfp_filters\|5.017004\|\|p
	715	PL_rsfp\|5.017004\|\|p
630	716	PL_rs\|\|\|n
631	717	PL_signals\|5.008001\|\|p
632	718	PL_stack_base\|5.004050\|\|p
633	719	PL_stack_sp\|5.004050\|\|p
	720	PL_statcache\|5.005000\|\|p
634	721	PL_stdingv\|5.004050\|\|p
635	722	PL_sv_arenaroot\|5.004050\|\|p
636	723	PL_sv_no\|5.004050\|\|pn

638	725	PL_sv_yes\|5.004050\|\|pn
639	726	PL_tainted\|5.004050\|\|p
640	727	PL_tainting\|5.004050\|\|p
641		POP_MULTICALL\|\|5.009004\|
	728	PL_tokenbuf\|5.017004\|\|p
	729	POP_MULTICALL\|\|5.017004\|
642	730	POPi\|\|\|n
643	731	POPl\|\|\|n
644	732	POPn\|\|\|n

649	737	PTR2IV\|5.006000\|\|p
650	738	PTR2NV\|5.006000\|\|p
651	739	PTR2UV\|5.006000\|\|p
	740	PTR2nat\|5.009003\|\|p
652	741	PTR2ul\|5.007001\|\|p
653	742	PTRV\|5.006000\|\|p
654	743	PUSHMARK\|\|\|
655		PUSH_MULTICALL\|\|5.009004\|
	744	PUSH_MULTICALL\|\|5.017004\|
656	745	PUSHi\|\|\|
657	746	PUSHmortal\|5.009002\|\|p
658	747	PUSHn\|\|\|

660	749	PUSHs\|\|\|
661	750	PUSHu\|5.004000\|\|p
662	751	PUTBACK\|\|\|
	752	PadARRAY\|\|5.017004\|
	753	PadMAX\|\|5.017004\|
	754	PadlistARRAY\|\|5.017004\|
	755	PadlistMAX\|\|5.017004\|
	756	PadlistNAMESARRAY\|\|5.017004\|
	757	PadlistNAMESMAX\|\|5.017004\|
	758	PadlistNAMES\|\|5.017004\|
	759	PadlistREFCNT\|\|5.017004\|
	760	PadnameIsOUR\|\|\|
	761	PadnameIsSTATE\|\|\|
	762	PadnameLEN\|\|5.017004\|
	763	PadnameOURSTASH\|\|\|
	764	PadnameOUTER\|\|\|
	765	PadnamePV\|\|5.017004\|
	766	PadnameSV\|\|5.017004\|
	767	PadnameTYPE\|\|\|
	768	PadnameUTF8\|\|5.017004\|
	769	PadnamelistARRAY\|\|5.017004\|
	770	PadnamelistMAX\|\|5.017004\|
663	771	PerlIO_clearerr\|\|5.007003\|
664	772	PerlIO_close\|\|5.007003\|
665	773	PerlIO_context_layers\|\|5.009004\|

683	791	PerlIO_tell\|\|5.007003\|
684	792	PerlIO_unread\|\|5.007003\|
685	793	PerlIO_write\|\|5.007003\|
686		Perl_warner_nocontext\|5.006000\|\|p
687		Perl_warner\|5.006000\|\|p
	794	Perl_signbit\|\|5.009005\|n
688	795	PoisonFree\|5.009004\|\|p
689	796	PoisonNew\|5.009004\|\|p
690	797	PoisonWith\|5.009004\|\|p

705	812	STMT_START\|\|\|p
706	813	STR_WITH_LEN\|5.009003\|\|p
707	814	ST\|\|\|
	815	SV_CONST_RETURN\|5.009003\|\|p
	816	SV_COW_DROP_PV\|5.008001\|\|p
	817	SV_COW_SHARED_HASH_KEYS\|5.009005\|\|p
	818	SV_GMAGIC\|5.007002\|\|p
	819	SV_HAS_TRAILING_NUL\|5.009004\|\|p
	820	SV_IMMEDIATE_UNREF\|5.007001\|\|p
	821	SV_MUTABLE_RETURN\|5.009003\|\|p
	822	SV_NOSTEAL\|5.009002\|\|p
	823	SV_SMAGIC\|5.009003\|\|p
	824	SV_UTF8_NO_ENCODING\|5.008001\|\|p
	825	SVfARG\|5.009005\|\|p
	826	SVf_UTF8\|5.006000\|\|p
708	827	SVf\|5.006000\|\|p
709	828	SVt_IV\|\|\|
710	829	SVt_NV\|\|\|

716	835	Safefree\|\|\|
717	836	Slab_Alloc\|\|\|
718	837	Slab_Free\|\|\|
	838	Slab_to_ro\|\|\|
	839	Slab_to_rw\|\|\|
719	840	StructCopy\|\|\|
720	841	SvCUR_set\|\|\|
721	842	SvCUR\|\|\|

751	872	SvNOKp\|\|\|
752	873	SvNOK\|\|\|
753	874	SvNVX\|\|\|
	875	SvNV_nomg\|\|5.013002\|
754	876	SvNV_set\|\|\|
755	877	SvNVx\|\|\|
756	878	SvNV\|\|\|
757	879	SvOK\|\|\|
	880	SvOOK_offset\|\|5.011000\|
758	881	SvOOK\|\|\|
759	882	SvPOK_off\|\|\|
760	883	SvPOK_only_UTF8\|\|5.006000\|

765	888	SvPVX_const\|5.009003\|\|p
766	889	SvPVX_mutable\|5.009003\|\|p
767	890	SvPVX\|\|\|
	891	SvPV_const\|5.009003\|\|p
	892	SvPV_flags_const_nolen\|5.009003\|\|p
	893	SvPV_flags_const\|5.009003\|\|p
	894	SvPV_flags_mutable\|5.009003\|\|p
	895	SvPV_flags\|5.007002\|\|p
	896	SvPV_force_flags_mutable\|5.009003\|\|p
	897	SvPV_force_flags_nolen\|5.009003\|\|p
	898	SvPV_force_flags\|5.007002\|\|p
	899	SvPV_force_mutable\|5.009003\|\|p
	900	SvPV_force_nolen\|5.009003\|\|p
	901	SvPV_force_nomg_nolen\|5.009003\|\|p
768	902	SvPV_force_nomg\|5.007002\|\|p
769		SvPV_force\|\|\|
	903	SvPV_force\|\|\|p
	904	SvPV_mutable\|5.009003\|\|p
	905	SvPV_nolen_const\|5.009003\|\|p
770	906	SvPV_nolen\|5.006000\|\|p
	907	SvPV_nomg_const_nolen\|5.009003\|\|p
	908	SvPV_nomg_const\|5.009003\|\|p
	909	SvPV_nomg_nolen\|5.013007\|5.013007\|p
771	910	SvPV_nomg\|5.007002\|\|p
	911	SvPV_renew\|5.009003\|\|p
772	912	SvPV_set\|\|\|
773	913	SvPVbyte_force\|\|5.009002\|
774	914	SvPVbyte_nolen\|\|5.006000\|

797	937	SvROK\|\|\|
798	938	SvRV_set\|5.009003\|\|p
799	939	SvRV\|\|\|
	940	SvRXOK\|\|5.009005\|
	941	SvRX\|\|5.009005\|
800	942	SvSETMAGIC\|\|\|
	943	SvSHARED_HASH\|5.009003\|\|p
801	944	SvSHARE\|\|5.007003\|
802	945	SvSTASH_set\|5.009003\|\|p
803	946	SvSTASH\|\|\|

809	952	SvTAINTED_on\|\|5.004000\|
810	953	SvTAINTED\|\|5.004000\|
811	954	SvTAINT\|\|\|
	955	SvTHINKFIRST\|\|\|
	956	SvTRUE_nomg\|\|5.013006\|
812	957	SvTRUE\|\|\|
813	958	SvTYPE\|\|\|
814	959	SvUNLOCK\|\|5.007003\|
815		SvUOK\|\|5.007001\|
	960	SvUOK\|5.007001\|5.006000\|p
816	961	SvUPGRADE\|\|\|
817	962	SvUTF8_off\|\|5.006000\|
818	963	SvUTF8_on\|\|5.006000\|

827	972	SvVSTRING_mg\|5.009004\|\|p
828	973	THIS\|\|\|n
829	974	UNDERBAR\|5.009002\|\|p
	975	UTF8_MAXBYTES\|5.009002\|\|p
830	976	UVSIZE\|5.006000\|\|p
831	977	UVTYPE\|5.006000\|\|p
832	978	UVXf\|5.007001\|\|p

835	981	UVxf\|5.006000\|\|p
836	982	WARN_ALL\|5.006000\|\|p
837	983	WARN_AMBIGUOUS\|5.006000\|\|p
838		WARN_ASSERTIONS\|5.009000\|\|p
	984	WARN_ASSERTIONS\|5.017004\|\|p
839	985	WARN_BAREWORD\|5.006000\|\|p
840	986	WARN_CLOSED\|5.006000\|\|p
841	987	WARN_CLOSURE\|5.006000\|\|p

890	1036	XPUSHp\|\|\|
891	1037	XPUSHs\|\|\|
892	1038	XPUSHu\|5.004000\|\|p
	1039	XSPROTO\|5.010000\|\|p
893	1040	XSRETURN_EMPTY\|\|\|
894	1041	XSRETURN_IV\|\|\|
895	1042	XSRETURN_NO\|\|\|

906	1053	XST_mUNDEF\|\|\|
907	1054	XST_mUV\|5.008001\|\|p
908	1055	XST_mYES\|\|\|
	1056	XS_APIVERSION_BOOTCHECK\|\|5.013004\|
	1057	XS_EXTERNAL\|\|5.017004\|
	1058	XS_INTERNAL\|\|5.017004\|
909	1059	XS_VERSION_BOOTCHECK\|\|\|
910	1060	XS_VERSION\|\|\|
911	1061	XSprePUSH\|5.006000\|\|p
912	1062	XS\|\|\|
	1063	XopDISABLE\|\|5.017004\|
	1064	XopENABLE\|\|5.017004\|
	1065	XopENTRY_set\|\|5.017004\|
	1066	XopENTRY\|\|5.017004\|
	1067	XopFLAGS\|\|5.013007\|
913	1068	ZeroD\|5.009002\|\|p
914	1069	Zero\|\|\|
915	1070	_aMY_CXT\|5.007003\|\|p
	1071	_add_range_to_invlist\|\|\|
	1072	_append_range_to_invlist\|\|\|
	1073	_core_swash_init\|\|\|
	1074	_get_swash_invlist\|\|\|
	1075	_invlist_array_init\|\|\|
	1076	_invlist_contains_cp\|\|\|
	1077	_invlist_contents\|\|\|
	1078	_invlist_intersection_maybe_complement_2nd\|\|\|
	1079	_invlist_intersection\|\|\|
	1080	_invlist_invert_prop\|\|\|
	1081	_invlist_invert\|\|\|
	1082	_invlist_populate_swatch\|\|\|
	1083	_invlist_search\|\|\|
	1084	_invlist_subtract\|\|\|
	1085	_invlist_union_maybe_complement_2nd\|\|\|
	1086	_invlist_union\|\|\|
	1087	_is_swash_user_defined\|\|\|
	1088	_is_utf8__perl_idstart\|\|\|
	1089	_is_utf8_quotemeta\|\|\|
	1090	_new_invlist_C_array\|\|\|
	1091	_new_invlist\|\|\|
916	1092	_pMY_CXT\|5.007003\|\|p
	1093	_swash_inversion_hash\|\|\|
	1094	_swash_to_invlist\|\|\|
	1095	_to_fold_latin1\|\|\|
	1096	_to_uni_fold_flags\|\|5.013011\|
	1097	_to_upper_title_latin1\|\|\|
	1098	_to_utf8_fold_flags\|\|5.015006\|
	1099	_to_utf8_lower_flags\|\|5.015006\|
	1100	_to_utf8_title_flags\|\|5.015006\|
	1101	_to_utf8_upper_flags\|\|5.015006\|
917	1102	aMY_CXT_\|5.007003\|\|p
918	1103	aMY_CXT\|5.007003\|\|p
	1104	aTHXR_\|5.017004\|\|p
	1105	aTHXR\|5.017004\|\|p
919	1106	aTHX_\|5.006000\|\|p
920	1107	aTHX\|5.006000\|\|p
	1108	aassign_common_vars\|\|\|
	1109	add_alternate\|\|\|
	1110	add_cp_to_invlist\|\|\|
921	1111	add_data\|\|\|n
	1112	add_utf16_textfilter\|\|\|
922	1113	addmad\|\|\|
	1114	adjust_stack_on_leave\|\|\|
	1115	alloc_maybe_populate_EXACT\|\|\|
	1116	alloccopstash\|\|\|
923	1117	allocmy\|\|\|
924	1118	amagic_call\|\|\|
925	1119	amagic_cmp_locale\|\|\|
926	1120	amagic_cmp\|\|\|
	1121	amagic_deref_call\|\|5.013007\|
927	1122	amagic_i_ncmp\|\|\|
	1123	amagic_is_enabled\|\|\|
928	1124	amagic_ncmp\|\|\|
	1125	anonymise_cv_maybe\|\|\|
929	1126	any_dup\|\|\|
930	1127	ao\|\|\|
931		append_elem\|\|\|
932		append_list\|\|\|
933	1128	append_madprops\|\|\|
934	1129	apply_attrs_my\|\|\|
935	1130	apply_attrs_string\|\|5.006001\|
936	1131	apply_attrs\|\|\|
937	1132	apply\|\|\|
	1133	assert_uft8_cache_coherent\|\|\|
938	1134	atfork_lock\|\|5.007003\|n
939	1135	atfork_unlock\|\|5.007003\|n
940	1136	av_arylen_p\|\|5.009003\|
941	1137	av_clear\|\|\|
	1138	av_create_and_push\|\|5.009005\|
	1139	av_create_and_unshift_one\|\|5.009005\|
942	1140	av_delete\|\|5.006000\|
943	1141	av_exists\|\|5.006000\|
	1142	av_extend_guts\|\|\|
944	1143	av_extend\|\|\|
945		av_fake\|\|\|
946	1144	av_fetch\|\|\|
947	1145	av_fill\|\|\|
	1146	av_iter_p\|\|5.011000\|
948	1147	av_len\|\|\|
949	1148	av_make\|\|\|
950	1149	av_pop\|\|\|

955	1154	av_undef\|\|\|
956	1155	av_unshift\|\|\|
957	1156	ax\|\|\|n
958		bad_type\|\|\|
	1157	bad_type_pv\|\|\|
	1158	bad_type_sv\|\|\|
959	1159	bind_match\|\|\|
960	1160	block_end\|\|\|
961	1161	block_gimme\|\|5.004000\|
962	1162	block_start\|\|\|
	1163	blockhook_register\|\|5.013003\|
963	1164	boolSV\|5.004000\|\|p
964	1165	boot_core_PerlIO\|\|\|
965	1166	boot_core_UNIVERSAL\|\|\|
966		boot_core_xsutils\|\|\|
	1167	boot_core_mro\|\|\|
	1168	bytes_cmp_utf8\|\|5.013007\|
967	1169	bytes_from_utf8\|\|5.007001\|
968	1170	bytes_to_uni\|\|\|n
969	1171	bytes_to_utf8\|\|5.006001\|

973	1175	call_method\|5.006000\|\|p
974	1176	call_pv\|5.006000\|\|p
975	1177	call_sv\|5.006000\|\|p
	1178	caller_cx\|\|5.013005\|
976	1179	calloc\|\|5.007002\|n
977	1180	cando\|\|\|
978	1181	cast_i32\|\|5.006000\|
979	1182	cast_iv\|\|5.006000\|
980	1183	cast_ulong\|\|5.006000\|
981	1184	cast_uv\|\|5.006000\|
	1185	check_locale_boundary_crossing\|\|\|
982	1186	check_type_and_open\|\|\|
983	1187	check_uni\|\|\|
	1188	check_utf8_print\|\|\|
984	1189	checkcomma\|\|\|
985	1190	checkposixcc\|\|\|
986	1191	ckWARN\|5.006000\|\|p
987		ck_anoncode\|\|\|
988		ck_bitop\|\|\|
989		ck_concat\|\|\|
990		ck_defined\|\|\|
991		ck_delete\|\|\|
992		ck_die\|\|\|
993		ck_eof\|\|\|
994		ck_eval\|\|\|
995		ck_exec\|\|\|
996		ck_exists\|\|\|
997		ck_exit\|\|\|
998		ck_ftst\|\|\|
999		ck_fun\|\|\|
1000		ck_glob\|\|\|
1001		ck_grep\|\|\|
1002		ck_index\|\|\|
1003		ck_join\|\|\|
1004		ck_lengthconst\|\|\|
1005		ck_lfun\|\|\|
1006		ck_listiob\|\|\|
1007		ck_match\|\|\|
1008		ck_method\|\|\|
1009		ck_null\|\|\|
1010		ck_open\|\|\|
1011		ck_repeat\|\|\|
1012		ck_require\|\|\|
1013		ck_retarget\|\|\|
1014		ck_return\|\|\|
1015		ck_rfun\|\|\|
1016		ck_rvconst\|\|\|
1017		ck_sassign\|\|\|
1018		ck_say\|\|\|
1019		ck_select\|\|\|
1020		ck_shift\|\|\|
1021		ck_sort\|\|\|
1022		ck_spair\|\|\|
1023		ck_split\|\|\|
1024		ck_subr\|\|\|
1025		ck_substr\|\|\|
1026		ck_svconst\|\|\|
1027		ck_trunc\|\|\|
1028		ck_unpack\|\|\|
	1192	ck_entersub_args_core\|\|\|
	1193	ck_entersub_args_list\|\|5.013006\|
	1194	ck_entersub_args_proto_or_list\|\|5.013006\|
	1195	ck_entersub_args_proto\|\|5.013006\|
	1196	ck_warner_d\|\|5.011001\|v
	1197	ck_warner\|\|5.011001\|v
	1198	ckwarn_common\|\|\|
1029	1199	ckwarn_d\|\|5.009003\|
1030	1200	ckwarn\|\|5.009003\|
1031	1201	cl_and\|\|\|n
1032	1202	cl_anything\|\|\|n
1033		cl_init_zero\|\|\|n
1034	1203	cl_init\|\|\|n
1035	1204	cl_is_anything\|\|\|n
1036	1205	cl_or\|\|\|n
1037	1206	clear_placeholders\|\|\|
	1207	clone_params_del\|\|\|n
	1208	clone_params_new\|\|\|n
1038	1209	closest_cop\|\|\|
	1210	compute_EXACTish\|\|\|
1039	1211	convert\|\|\|
	1212	cop_fetch_label\|\|5.015001\|
1040	1213	cop_free\|\|\|
	1214	cop_hints_2hv\|\|5.013007\|
	1215	cop_hints_fetch_pvn\|\|5.013007\|
	1216	cop_hints_fetch_pvs\|\|5.013007\|
	1217	cop_hints_fetch_pv\|\|5.013007\|
	1218	cop_hints_fetch_sv\|\|5.013007\|
	1219	cop_store_label\|\|5.015001\|
	1220	cophh_2hv\|\|5.013007\|
	1221	cophh_copy\|\|5.013007\|
	1222	cophh_delete_pvn\|\|5.013007\|
	1223	cophh_delete_pvs\|\|5.013007\|
	1224	cophh_delete_pv\|\|5.013007\|
	1225	cophh_delete_sv\|\|5.013007\|
	1226	cophh_fetch_pvn\|\|5.013007\|
	1227	cophh_fetch_pvs\|\|5.013007\|
	1228	cophh_fetch_pv\|\|5.013007\|
	1229	cophh_fetch_sv\|\|5.013007\|
	1230	cophh_free\|\|5.013007\|
	1231	cophh_new_empty\|\|5.017004\|
	1232	cophh_store_pvn\|\|5.013007\|
	1233	cophh_store_pvs\|\|5.013007\|
	1234	cophh_store_pv\|\|5.013007\|
	1235	cophh_store_sv\|\|5.013007\|
	1236	core_prototype\|\|\|
	1237	core_regclass_swash\|\|\|
	1238	coresub_op\|\|\|
1041	1239	cr_textfilter\|\|\|
1042	1240	create_eval_scope\|\|\|
	1241	croak_no_modify\|\|5.013003\|
1043	1242	croak_nocontext\|\|\|vn
	1243	croak_sv\|\|5.013001\|
	1244	croak_xs_usage\|\|5.010001\|
1044	1245	croak\|\|\|v
1045	1246	csighandler\|\|5.009003\|n
1046	1247	curmad\|\|\|
	1248	current_re_engine\|\|\|
	1249	curse\|\|\|
1047	1250	custom_op_desc\|\|5.007003\|
1048	1251	custom_op_name\|\|5.007003\|
1049		cv_ckproto_len\|\|\|
1050		cv_ckproto\|\|\|
	1252	custom_op_register\|\|5.013007\|
	1253	custom_op_xop\|\|5.013007\|
	1254	cv_ckproto_len_flags\|\|\|
1051	1255	cv_clone\|\|\|
1052	1256	cv_const_sv\|\|5.004000\|
1053	1257	cv_dump\|\|\|
	1258	cv_forget_slab\|\|\|
	1259	cv_get_call_checker\|\|5.013006\|
	1260	cv_set_call_checker\|\|5.013006\|
1054	1261	cv_undef\|\|\|
	1262	cvgv_set\|\|\|
	1263	cvstash_set\|\|\|
1055	1264	cx_dump\|\|5.005000\|
1056	1265	cx_dup\|\|\|
1057	1266	cxinc\|\|\|

1066	1275	dORIGMARK\|\|\|
1067	1276	dSP\|\|\|
1068	1277	dTHR\|5.004050\|\|p
	1278	dTHXR\|5.017004\|\|p
1069	1279	dTHXa\|5.006000\|\|p
1070	1280	dTHXoa\|5.006000\|\|p
1071	1281	dTHX\|5.006000\|\|p

1088	1298	deb\|\|5.007003\|v
1089	1299	del_sv\|\|\|
1090	1300	delete_eval_scope\|\|\|
1091		delimcpy\|\|5.004000\|
1092		deprecate_old\|\|\|
1093		deprecate\|\|\|
	1301	delimcpy\|\|5.004000\|n
	1302	deprecate_commaless_var_list\|\|\|
1094	1303	despatch_signals\|\|5.007001\|
1095	1304	destroy_matcher\|\|\|
1096	1305	die_nocontext\|\|\|vn
1097		die_where\|\|\|
	1306	die_sv\|\|5.013001\|
	1307	die_unwind\|\|\|
1098	1308	die\|\|\|v
1099	1309	dirp_dup\|\|\|
1100	1310	div128\|\|\|

1104	1314	do_aspawn\|\|\|
1105	1315	do_binmode\|\|5.004050\|
1106	1316	do_chomp\|\|\|
1107		do_chop\|\|\|
1108	1317	do_close\|\|\|
	1318	do_delete_local\|\|\|
1109	1319	do_dump_pad\|\|\|
1110	1320	do_eof\|\|\|
1111	1321	do_exec3\|\|\|

1117	1327	do_ipcctl\|\|\|
1118	1328	do_ipcget\|\|\|
1119	1329	do_join\|\|\|
1120		do_kv\|\|\|
1121	1330	do_magic_dump\|\|5.006000\|
1122	1331	do_msgrcv\|\|\|
1123	1332	do_msgsnd\|\|\|
	1333	do_ncmp\|\|\|
1124	1334	do_oddball\|\|\|
1125	1335	do_op_dump\|\|5.006000\|
1126	1336	do_op_xmldump\|\|\|
1127	1337	do_open9\|\|5.006000\|
1128	1338	do_openn\|\|5.007001\|
1129	1339	do_open\|\|5.004000\|
1130		do_pipe\|\|\|
1131	1340	do_pmop_dump\|\|5.006000\|
1132	1341	do_pmop_xmldump\|\|\|
1133	1342	do_print\|\|\|

1152	1361	do_vecget\|\|\|
1153	1362	do_vecset\|\|\|
1154	1363	do_vop\|\|\|
1155		docatch_body\|\|\|
1156	1364	docatch\|\|\|
1157	1365	doeval\|\|\|
1158	1366	dofile\|\|\|

1167	1375	dopoptolabel\|\|\|
1168	1376	dopoptoloop\|\|\|
1169	1377	dopoptosub_at\|\|\|
1170		dopoptosub\|\|\|
1171	1378	dopoptowhen\|\|\|
1172	1379	doref\|\|5.009003\|
1173	1380	dounwind\|\|\|
1174	1381	dowantarray\|\|\|
	1382	dump_all_perl\|\|\|
1175	1383	dump_all\|\|5.006000\|
1176	1384	dump_eval\|\|5.006000\|
1177	1385	dump_exec_pos\|\|\|

1179	1387	dump_form\|\|5.006000\|
1180	1388	dump_indent\|\|5.006000\|v
1181	1389	dump_mstats\|\|\|
	1390	dump_packsubs_perl\|\|\|
1182	1391	dump_packsubs\|\|5.006000\|
	1392	dump_sub_perl\|\|\|
1183	1393	dump_sub\|\|5.006000\|
1184	1394	dump_sv_child\|\|\|
1185	1395	dump_trie_interim_list\|\|\|

1188	1398	dump_vindent\|\|5.006000\|
1189	1399	dumpuntil\|\|\|
1190	1400	dup_attrlist\|\|\|
1191		emulate_eaccess\|\|\|
	1401	emulate_cop_io\|\|\|
1192	1402	eval_pv\|5.006000\|\|p
1193	1403	eval_sv\|5.006000\|\|p
1194	1404	exec_failed\|\|\|
1195	1405	expect_number\|\|\|
1196	1406	fbm_compile\|\|5.005000\|
1197	1407	fbm_instr\|\|5.005000\|
1198		fd_on_nosuid_fs\|\|\|
1199	1408	feature_is_enabled\|\|\|
1200	1409	filter_add\|\|\|
1201	1410	filter_del\|\|\|
1202	1411	filter_gets\|\|\|
1203	1412	filter_read\|\|\|
	1413	finalize_optree\|\|\|
	1414	finalize_op\|\|\|
	1415	find_and_forget_pmops\|\|\|
1204	1416	find_array_subscript\|\|\|
1205	1417	find_beginning\|\|\|
1206	1418	find_byclass\|\|\|
1207	1419	find_hash_subscript\|\|\|
1208	1420	find_in_my_stash\|\|\|
1209		find_runcv\|\|\|
	1421	find_runcv_where\|\|\|
	1422	find_runcv\|\|5.008001\|
	1423	find_rundefsv2\|\|\|
1210	1424	find_rundefsvoffset\|\|5.009002\|
	1425	find_rundefsv\|\|5.013002\|
1211	1426	find_script\|\|\|
1212	1427	find_uninit_var\|\|\|
1213	1428	first_symbol\|\|\|n
	1429	foldEQ_latin1\|\|5.013008\|n
	1430	foldEQ_locale\|\|5.013002\|n
	1431	foldEQ_utf8_flags\|\|5.013010\|
	1432	foldEQ_utf8\|\|5.013002\|
	1433	foldEQ\|\|5.013002\|n
1214	1434	fold_constants\|\|\|
1215	1435	forbid_setid\|\|\|
1216	1436	force_ident\|\|\|
1217	1437	force_list\|\|\|
1218	1438	force_next\|\|\|
	1439	force_strict_version\|\|\|
1219	1440	force_version\|\|\|
1220	1441	force_word\|\|\|
	1442	forget_pmop\|\|\|
1221	1443	form_nocontext\|\|\|vn
1222	1444	form\|\|5.004000\|v
1223	1445	fp_dup\|\|\|

1226	1448	free_tied_hv_pool\|\|\|
1227	1449	free_tmps\|\|\|
1228	1450	gen_constant_list\|\|\|
1229		get_arena\|\|\|
	1451	get_aux_mg\|\|\|
1230	1452	get_av\|5.006000\|\|p
1231	1453	get_context\|\|5.006000\|n
	1454	get_cvn_flags\|5.009005\|\|p
	1455	get_cvs\|5.011000\|\|p
1232	1456	get_cv\|5.006000\|\|p
1233	1457	get_db_sub\|\|\|
1234	1458	get_debug_opts\|\|\|
1235	1459	get_hash_seed\|\|\|
1236	1460	get_hv\|5.006000\|\|p
	1461	get_invlist_iter_addr\|\|\|
	1462	get_invlist_len_addr\|\|\|
	1463	get_invlist_version_id_addr\|\|\|
	1464	get_invlist_zero_addr\|\|\|
1237	1465	get_mstats\|\|\|
1238	1466	get_no_modify\|\|\|
1239	1467	get_num\|\|\|

1241	1469	get_op_names\|\|5.005000\|
1242	1470	get_opargs\|\|\|
1243	1471	get_ppaddr\|\|5.006000\|
	1472	get_re_arg\|\|\|
1244	1473	get_sv\|5.006000\|\|p
1245	1474	get_vtbl\|\|5.005030\|
1246	1475	getcwd_sv\|\|5.007002\|
1247	1476	getenv_len\|\|\|
1248	1477	glob_2number\|\|\|
1249		glob_2pv\|\|\|
1250	1478	glob_assign_glob\|\|\|
1251	1479	glob_assign_ref\|\|\|
1252	1480	gp_dup\|\|\|
1253	1481	gp_free\|\|\|
1254	1482	gp_ref\|\|\|
1255	1483	grok_bin\|5.007003\|\|p
	1484	grok_bslash_N\|\|\|
	1485	grok_bslash_c\|\|\|
	1486	grok_bslash_o\|\|\|
	1487	grok_bslash_x\|\|\|
1256	1488	grok_hex\|5.007003\|\|p
1257	1489	grok_number\|5.007002\|\|p
1258	1490	grok_numeric_radix\|5.007002\|\|p

1262	1494	gv_HVadd\|\|\|
1263	1495	gv_IOadd\|\|\|
1264	1496	gv_SVadd\|\|\|
	1497	gv_add_by_type\|\|5.011000\|
1265	1498	gv_autoload4\|\|5.004000\|
	1499	gv_autoload_pvn\|\|5.015004\|
	1500	gv_autoload_pv\|\|5.015004\|
	1501	gv_autoload_sv\|\|5.015004\|
1266	1502	gv_check\|\|\|
1267	1503	gv_const_sv\|\|5.009003\|
1268	1504	gv_dump\|\|5.006000\|

1270	1506	gv_efullname4\|\|5.006001\|
1271	1507	gv_efullname\|\|\|
1272	1508	gv_ename\|\|\|
	1509	gv_fetchfile_flags\|\|5.009005\|
1273	1510	gv_fetchfile\|\|\|
1274	1511	gv_fetchmeth_autoload\|\|5.007003\|
	1512	gv_fetchmeth_pv_autoload\|\|5.015004\|
	1513	gv_fetchmeth_pvn_autoload\|\|5.015004\|
	1514	gv_fetchmeth_pvn\|\|5.015004\|
	1515	gv_fetchmeth_pv\|\|5.015004\|
	1516	gv_fetchmeth_sv_autoload\|\|5.015004\|
	1517	gv_fetchmeth_sv\|\|5.015004\|
1275	1518	gv_fetchmethod_autoload\|\|5.004000\|
	1519	gv_fetchmethod_pv_flags\|\|5.015004\|
	1520	gv_fetchmethod_pvn_flags\|\|5.015004\|
	1521	gv_fetchmethod_sv_flags\|\|5.015004\|
1276	1522	gv_fetchmethod\|\|\|
1277	1523	gv_fetchmeth\|\|\|
1278		gv_fetchpvn_flags\|\|5.009002\|
	1524	gv_fetchpvn_flags\|5.009002\|\|p
	1525	gv_fetchpvs\|5.009004\|\|p
1279	1526	gv_fetchpv\|\|\|
1280		gv_fetchsv\|\|5.009002\|
	1527	gv_fetchsv\|5.009002\|\|p
1281	1528	gv_fullname3\|\|5.004000\|
1282	1529	gv_fullname4\|\|5.006001\|
1283	1530	gv_fullname\|\|\|
	1531	gv_get_super_pkg\|\|\|
1284	1532	gv_handler\|\|5.007001\|
1285		gv_init_sv\|\|\|
	1533	gv_init_pvn\|\|5.015004\|
	1534	gv_init_pv\|\|5.015004\|
	1535	gv_init_svtype\|\|\|
	1536	gv_init_sv\|\|5.015004\|
1286	1537	gv_init\|\|\|
	1538	gv_magicalize_isa\|\|\|
1287	1539	gv_name_set\|\|5.009004\|
1288	1540	gv_stashpvn\|5.004000\|\|p
1289		gv_stashpvs\|\|5.009003\|
	1541	gv_stashpvs\|5.009003\|\|p
1290	1542	gv_stashpv\|\|\|
1291	1543	gv_stashsv\|\|\|
	1544	gv_try_downgrade\|\|\|
1292	1545	he_dup\|\|\|
1293	1546	hek_dup\|\|\|
	1547	hfree_next_entry\|\|\|
1294	1548	hfreeentries\|\|\|
1295	1549	hsplit\|\|\|
1296		hv_assert\|\|5.009001\|
	1550	hv_assert\|\|\|
1297	1551	hv_auxinit\|\|\|n
1298	1552	hv_backreferences_p\|\|\|
1299	1553	hv_clear_placeholders\|\|5.009001\|
1300	1554	hv_clear\|\|\|
1301		hv_copy_hints_hv\|\|\|
	1555	hv_common_key_len\|\|5.010000\|
	1556	hv_common\|\|5.010000\|
	1557	hv_copy_hints_hv\|\|5.009004\|
1302	1558	hv_delayfree_ent\|\|5.004000\|
1303	1559	hv_delete_common\|\|\|
1304	1560	hv_delete_ent\|\|5.004000\|
1305	1561	hv_delete\|\|\|
1306	1562	hv_eiter_p\|\|5.009003\|
1307	1563	hv_eiter_set\|\|5.009003\|
	1564	hv_ename_add\|\|\|
	1565	hv_ename_delete\|\|\|
1308	1566	hv_exists_ent\|\|5.004000\|
1309	1567	hv_exists\|\|\|
1310		hv_fetch_common\|\|\|
1311	1568	hv_fetch_ent\|\|5.004000\|
1312	1569	hv_fetchs\|5.009003\|\|p
1313	1570	hv_fetch\|\|\|
	1571	hv_fill\|\|5.013002\|
	1572	hv_free_ent_ret\|\|\|
1314	1573	hv_free_ent\|\|5.004000\|
1315	1574	hv_iterinit\|\|\|
1316	1575	hv_iterkeysv\|\|5.004000\|

1322	1581	hv_kill_backrefs\|\|\|
1323	1582	hv_ksplit\|\|5.004000\|
1324	1583	hv_magic_check\|\|\|n
1325		hv_magic_uvar_xkey\|\|\|
1326	1584	hv_magic\|\|\|
1327	1585	hv_name_set\|\|5.009003\|
1328	1586	hv_notallowed\|\|\|

1336	1594	hv_store_flags\|\|5.008000\|
1337	1595	hv_stores\|5.009004\|\|p
1338	1596	hv_store\|\|\|
	1597	hv_undef_flags\|\|\|
1339	1598	hv_undef\|\|\|
1340	1599	ibcmp_locale\|\|5.004000\|
1341	1600	ibcmp_utf8\|\|5.007003\|
1342	1601	ibcmp\|\|\|
1343		incl_perldb\|\|\|
1344	1602	incline\|\|\|
1345	1603	incpush_if_exists\|\|\|
	1604	incpush_use_sep\|\|\|
1346	1605	incpush\|\|\|
1347	1606	ingroup\|\|\|
1348	1607	init_argv_symbols\|\|\|
	1608	init_constants\|\|\|
	1609	init_dbargs\|\|\|
1349	1610	init_debugger\|\|\|
1350	1611	init_global_struct\|\|\|
1351	1612	init_i18nl10n\|\|5.006000\|
1352	1613	init_i18nl14n\|\|5.006000\|
1353	1614	init_ids\|\|\|
1354	1615	init_interp\|\|\|
1355		init_lexer\|\|\|
1356	1616	init_main_stash\|\|\|
1357	1617	init_perllib\|\|\|
1358	1618	init_postdump_symbols\|\|\|
1359	1619	init_predump_symbols\|\|\|
1360	1620	init_stacks\|\|5.005000\|
1361	1621	init_tm\|\|5.007002\|
1362		instr\|\|\|
	1622	inplace_aassign\|\|\|
	1623	instr\|\|\|n
1363	1624	intro_my\|\|\|
1364	1625	intuit_method\|\|\|
1365	1626	intuit_more\|\|\|
1366	1627	invert\|\|\|
	1628	invlist_array\|\|\|
	1629	invlist_clone\|\|\|
	1630	invlist_extend\|\|\|
	1631	invlist_highest\|\|\|
	1632	invlist_iterinit\|\|\|
	1633	invlist_iternext\|\|\|
	1634	invlist_len\|\|\|
	1635	invlist_max\|\|\|
	1636	invlist_set_len\|\|\|
	1637	invlist_trim\|\|\|
	1638	invoke_exception_hook\|\|\|
1367	1639	io_close\|\|\|
1368		isALNUM\|\|\|
	1640	isALNUMC\|5.006000\|\|p
1369	1641	isALPHA\|\|\|
	1642	isASCII\|5.006000\|\|p
	1643	isBLANK\|5.006001\|\|p
	1644	isCNTRL\|5.006000\|\|p
1370	1645	isDIGIT\|\|\|
	1646	isGRAPH\|5.006000\|\|p
	1647	isGV_with_GP\|5.009004\|\|p
1371	1648	isLOWER\|\|\|
	1649	isOCTAL\|\|5.013005\|
	1650	isPRINT\|5.004000\|\|p
	1651	isPSXSPC\|5.006001\|\|p
	1652	isPUNCT\|5.006000\|\|p
1372	1653	isSPACE\|\|\|
1373	1654	isUPPER\|\|\|
	1655	isWORDCHAR\|\|5.013006\|
	1656	isXDIGIT\|5.006000\|\|p
1374	1657	is_an_int\|\|\|
1375		is_gv_magical_sv\|\|\|
1376		is_gv_magical\|\|\|
	1658	is_ascii_string\|\|5.011000\|n
1377	1659	is_handle_constructor\|\|\|n
1378	1660	is_list_assignment\|\|\|
1379	1661	is_lvalue_sub\|\|5.007001\|
1380	1662	is_uni_alnum_lc\|\|5.006000\|
1381		is_uni_alnumc_lc\|\|5.006000\|
1382		is_uni_alnumc\|\|5.006000\|
1383	1663	is_uni_alnum\|\|5.006000\|
1384	1664	is_uni_alpha_lc\|\|5.006000\|
1385	1665	is_uni_alpha\|\|5.006000\|
1386	1666	is_uni_ascii_lc\|\|5.006000\|
1387	1667	is_uni_ascii\|\|5.006000\|
	1668	is_uni_blank\|\|5.017002\|
1388	1669	is_uni_cntrl_lc\|\|5.006000\|
1389	1670	is_uni_cntrl\|\|5.006000\|
1390	1671	is_uni_digit_lc\|\|5.006000\|

1405	1686	is_uni_upper\|\|5.006000\|
1406	1687	is_uni_xdigit_lc\|\|5.006000\|
1407	1688	is_uni_xdigit\|\|5.006000\|
1408		is_utf8_alnumc\|\|5.006000\|
	1689	is_utf8_X_LVT\|\|\|
	1690	is_utf8_X_LV_LVT_V\|\|\|
	1691	is_utf8_X_LV\|\|\|
	1692	is_utf8_X_L\|\|\|
	1693	is_utf8_X_T\|\|\|
	1694	is_utf8_X_V\|\|\|
	1695	is_utf8_X_begin\|\|\|
	1696	is_utf8_X_extend\|\|\|
	1697	is_utf8_X_non_hangul\|\|\|
	1698	is_utf8_X_prepend\|\|\|
1409	1699	is_utf8_alnum\|\|5.006000\|
1410	1700	is_utf8_alpha\|\|5.006000\|
1411	1701	is_utf8_ascii\|\|5.006000\|
	1702	is_utf8_blank\|\|5.017002\|
	1703	is_utf8_char_buf\|\|5.015008\|n
1412	1704	is_utf8_char_slow\|\|\|n
1413		is_utf8_char\|\|5.006000\|
	1705	is_utf8_char\|\|5.006000\|n
1414	1706	is_utf8_cntrl\|\|5.006000\|
1415	1707	is_utf8_common\|\|\|
1416	1708	is_utf8_digit\|\|5.006000\|

1419	1711	is_utf8_idfirst\|\|5.006000\|
1420	1712	is_utf8_lower\|\|5.006000\|
1421	1713	is_utf8_mark\|\|5.006000\|
	1714	is_utf8_perl_space\|\|5.011001\|
	1715	is_utf8_perl_word\|\|5.011001\|
	1716	is_utf8_posix_digit\|\|5.011001\|
1422	1717	is_utf8_print\|\|5.006000\|
1423	1718	is_utf8_punct\|\|5.006000\|
1424	1719	is_utf8_space\|\|5.006000\|
1425		is_utf8_string_loclen\|\|5.009003\|
1426		is_utf8_string_loc\|\|5.008001\|
1427		is_utf8_string\|\|5.006001\|
	1720	is_utf8_string_loclen\|\|5.009003\|n
	1721	is_utf8_string_loc\|\|5.008001\|n
	1722	is_utf8_string\|\|5.006001\|n
1428	1723	is_utf8_upper\|\|5.006000\|
1429	1724	is_utf8_xdigit\|\|5.006000\|
	1725	is_utf8_xidcont\|\|5.013010\|
	1726	is_utf8_xidfirst\|\|5.013010\|
1430	1727	isa_lookup\|\|\|
1431	1728	items\|\|\|n
1432	1729	ix\|\|\|n
1433	1730	jmaybe\|\|\|
1434	1731	join_exact\|\|\|
	1732	keyword_plugin_standard\|\|\|
1435	1733	keyword\|\|\|
1436	1734	leave_scope\|\|\|
1437		lex_end\|\|\|
1438		lex_start\|\|\|
1439		linklist\|\|\|
	1735	lex_bufutf8\|\|5.011002\|
	1736	lex_discard_to\|\|5.011002\|
	1737	lex_grow_linestr\|\|5.011002\|
	1738	lex_next_chunk\|\|5.011002\|
	1739	lex_peek_unichar\|\|5.011002\|
	1740	lex_read_space\|\|5.011002\|
	1741	lex_read_to\|\|5.011002\|
	1742	lex_read_unichar\|\|5.011002\|
	1743	lex_start\|\|5.009005\|
	1744	lex_stuff_pvn\|\|5.011002\|
	1745	lex_stuff_pvs\|\|5.013005\|
	1746	lex_stuff_pv\|\|5.013006\|
	1747	lex_stuff_sv\|\|5.011002\|
	1748	lex_unstuff\|\|5.011002\|
1440	1749	listkids\|\|\|
1441	1750	list\|\|\|
1442	1751	load_module_nocontext\|\|\|vn
1443		load_module\|\|5.006000\|v
	1752	load_module\|5.006000\|\|pv
1444	1753	localize\|\|\|
1445	1754	looks_like_bool\|\|\|
1446	1755	looks_like_number\|\|\|

1448	1757	mPUSHi\|5.009002\|\|p
1449	1758	mPUSHn\|5.009002\|\|p
1450	1759	mPUSHp\|5.009002\|\|p
	1760	mPUSHs\|5.010001\|\|p
1451	1761	mPUSHu\|5.009002\|\|p
1452	1762	mXPUSHi\|5.009002\|\|p
1453	1763	mXPUSHn\|5.009002\|\|p
1454	1764	mXPUSHp\|5.009002\|\|p
	1765	mXPUSHs\|5.010001\|\|p
1455	1766	mXPUSHu\|5.009002\|\|p
1456	1767	mad_free\|\|\|
1457	1768	madlex\|\|\|
1458	1769	madparse\|\|\|
1459	1770	magic_clear_all_env\|\|\|
	1771	magic_cleararylen_p\|\|\|
1460	1772	magic_clearenv\|\|\|
	1773	magic_clearhints\|\|\|
1461	1774	magic_clearhint\|\|\|
	1775	magic_clearisa\|\|\|
1462	1776	magic_clearpack\|\|\|
1463	1777	magic_clearsig\|\|\|
	1778	magic_copycallchecker\|\|\|
1464	1779	magic_dump\|\|5.006000\|
1465	1780	magic_existspack\|\|\|
1466	1781	magic_freearylen_p\|\|\|
1467	1782	magic_freeovrld\|\|\|
1468		magic_freeregexp\|\|\|
1469	1783	magic_getarylen\|\|\|
1470	1784	magic_getdefelem\|\|\|
1471	1785	magic_getnkeys\|\|\|

1479	1793	magic_get\|\|\|
1480	1794	magic_killbackrefs\|\|\|
1481	1795	magic_len\|\|\|
1482		magic_methcall\|\|\|
	1796	magic_methcall1\|\|\|
	1797	magic_methcall\|\|\|v
1483	1798	magic_methpack\|\|\|
1484	1799	magic_nextpack\|\|\|
1485	1800	magic_regdata_cnt\|\|\|

1487	1802	magic_regdatum_set\|\|\|
1488	1803	magic_scalarpack\|\|\|
1489	1804	magic_set_all_env\|\|\|
1490		magic_setamagic\|\|\|
1491	1805	magic_setarylen\|\|\|
1492		magic_setbm\|\|\|
1493	1806	magic_setcollxfrm\|\|\|
1494	1807	magic_setdbline\|\|\|
1495	1808	magic_setdefelem\|\|\|
1496	1809	magic_setenv\|\|\|
1497		magic_setfm\|\|\|
1498		magic_setglob\|\|\|
1499	1810	magic_sethint\|\|\|
1500	1811	magic_setisa\|\|\|
1501	1812	magic_setmglob\|\|\|

1512	1823	magic_set\|\|\|
1513	1824	magic_sizepack\|\|\|
1514	1825	magic_wipepack\|\|\|
1515		magicname\|\|\|
1516	1826	make_matcher\|\|\|
1517	1827	make_trie_failtable\|\|\|
1518	1828	make_trie\|\|\|
	1829	malloc_good_size\|\|\|n
1519	1830	malloced_size\|\|\|n
1520	1831	malloc\|\|5.007002\|n
1521	1832	markstack_grow\|\|\|
1522	1833	matcher_matches_sv\|\|\|
	1834	mayberelocate\|\|\|
1523	1835	measure_struct\|\|\|
	1836	memEQs\|5.009005\|\|p
1524	1837	memEQ\|5.004000\|\|p
	1838	memNEs\|5.009005\|\|p
1525	1839	memNE\|5.004000\|\|p
1526	1840	mem_collxfrm\|\|\|
	1841	mem_log_common\|\|\|n
1527	1842	mess_alloc\|\|\|
1528	1843	mess_nocontext\|\|\|vn
	1844	mess_sv\|\|5.013001\|
1529	1845	mess\|\|5.006000\|v
1530	1846	method_common\|\|\|
1531	1847	mfree\|\|5.007002\|n
1532	1848	mg_clear\|\|\|
1533	1849	mg_copy\|\|\|
1534	1850	mg_dup\|\|\|
	1851	mg_findext\|\|5.013008\|
1535	1852	mg_find\|\|\|
	1853	mg_free_type\|\|5.013006\|
1536	1854	mg_free\|\|\|
1537	1855	mg_get\|\|\|
1538	1856	mg_length\|\|5.005000\|

1541	1859	mg_set\|\|\|
1542	1860	mg_size\|\|5.005000\|
1543	1861	mini_mktime\|\|5.007002\|
	1862	minus_v\|\|\|
1544	1863	missingterm\|\|\|
1545	1864	mode_from_discipline\|\|\|
1546	1865	modkids\|\|\|
1547		mod\|\|\|
1548	1866	more_bodies\|\|\|
1549	1867	more_sv\|\|\|
1550	1868	moreswitches\|\|\|
	1869	mro_clean_isarev\|\|\|
	1870	mro_gather_and_rename\|\|\|
	1871	mro_get_from_name\|\|5.010001\|
	1872	mro_get_linear_isa_dfs\|\|\|
	1873	mro_get_linear_isa\|\|5.009005\|
	1874	mro_get_private_data\|\|5.010001\|
	1875	mro_isa_changed_in\|\|\|
	1876	mro_meta_dup\|\|\|
	1877	mro_meta_init\|\|\|
	1878	mro_method_changed_in\|\|5.009005\|
	1879	mro_package_moved\|\|\|
	1880	mro_register\|\|5.010001\|
	1881	mro_set_mro\|\|5.010001\|
	1882	mro_set_private_data\|\|5.010001\|
1551	1883	mul128\|\|\|
1552	1884	mulexp10\|\|\|n
1553	1885	my_atof2\|\|5.007002\|

1563	1895	my_bzero\|\|\|n
1564	1896	my_chsize\|\|\|
1565	1897	my_clearenv\|\|\|
	1898	my_cxt_index\|\|\|
1566	1899	my_cxt_init\|\|\|
	1900	my_dirfd\|\|5.009005\|
1567	1901	my_exit_jump\|\|\|
1568	1902	my_exit\|\|\|
1569	1903	my_failure_exit\|\|5.004000\|

1589	1923	my_letohi\|\|\|n
1590	1924	my_letohl\|\|\|n
1591	1925	my_letohs\|\|\|n
1592		my_lstat\|\|\|
1593		my_memcmp\|\|5.004000\|n
1594		my_memset\|\|\|n
	1926	my_lstat_flags\|\|\|
	1927	my_lstat\|\|5.017004\|
	1928	my_memcmp\|\|\|n
	1929	my_memset\|\|5.004000\|n
1595	1930	my_ntohl\|\|\|
1596	1931	my_pclose\|\|5.004000\|
1597	1932	my_popen_list\|\|5.007001\|

1599	1934	my_setenv\|\|\|
1600	1935	my_snprintf\|5.009004\|\|pvn
1601	1936	my_socketpair\|\|5.007003\|n
1602		my_sprintf\|\|5.009003\|vn
1603		my_stat\|\|\|
	1937	my_sprintf\|5.009003\|\|pvn
	1938	my_stat_flags\|\|\|
	1939	my_stat\|\|5.017004\|
1604	1940	my_strftime\|\|5.007002\|
1605	1941	my_strlcat\|5.009004\|\|pn
1606	1942	my_strlcpy\|5.009004\|\|pn

1608	1944	my_swap\|\|\|
1609	1945	my_unexec\|\|\|
1610	1946	my_vsnprintf\|\|5.009004\|n
1611		my\|\|\|
1612	1947	need_utf8\|\|\|n
1613	1948	newANONATTRSUB\|\|5.006000\|
1614	1949	newANONHASH\|\|\|
1615	1950	newANONLIST\|\|\|
1616	1951	newANONSUB\|\|\|
1617	1952	newASSIGNOP\|\|\|
	1953	newATTRSUB_flags\|\|\|
1618	1954	newATTRSUB\|\|5.006000\|
1619	1955	newAVREF\|\|\|
1620	1956	newAV\|\|\|
1621	1957	newBINOP\|\|\|
1622	1958	newCONDOP\|\|\|
	1959	newCONSTSUB_flags\|\|5.015006\|
1623	1960	newCONSTSUB\|5.004050\|\|p
1624	1961	newCVREF\|\|\|
1625	1962	newDEFSVOP\|\|\|
1626	1963	newFORM\|\|\|
1627		newFOROP\|\|\|
	1964	newFOROP\|\|5.013007\|
1628	1965	newGIVENOP\|\|5.009003\|
1629	1966	newGIVWHENOP\|\|\|
1630	1967	newGP\|\|\|
1631	1968	newGVOP\|\|\|
1632	1969	newGVREF\|\|\|
	1970	newGVgen_flags\|\|5.015004\|
1633	1971	newGVgen\|\|\|
1634	1972	newHVREF\|\|\|
1635	1973	newHVhv\|\|5.005000\|

1644	1982	newMYSUB\|\|\|
1645	1983	newNULLLIST\|\|\|
1646	1984	newOP\|\|\|
1647		newPADOP\|\|5.006000\|
	1985	newPADOP\|\|\|
1648	1986	newPMOP\|\|\|
1649	1987	newPROG\|\|\|
1650	1988	newPVOP\|\|\|

1654	1992	newRV\|\|\|
1655	1993	newSLICEOP\|\|\|
1656	1994	newSTATEOP\|\|\|
	1995	newSTUB\|\|\|
1657	1996	newSUB\|\|\|
1658	1997	newSVOP\|\|\|
1659	1998	newSVREF\|\|\|
	1999	newSV_type\|5.009005\|\|p
1660	2000	newSVhek\|\|5.009003\|
1661	2001	newSViv\|\|\|
1662	2002	newSVnv\|\|\|
	2003	newSVpadname\|\|5.017004\|
	2004	newSVpv_share\|\|5.013006\|
1663	2005	newSVpvf_nocontext\|\|\|vn
1664	2006	newSVpvf\|\|5.004000\|v
1665		newSVpvn_share\|\|5.007001\|
	2007	newSVpvn_flags\|5.010001\|\|p
	2008	newSVpvn_share\|5.007001\|\|p
	2009	newSVpvn_utf8\|5.010001\|\|p
1666	2010	newSVpvn\|5.004050\|\|p
1667		newSVpvs_share\|\|5.009003\|
	2011	newSVpvs_flags\|5.010001\|\|p
	2012	newSVpvs_share\|5.009003\|\|p
1668	2013	newSVpvs\|5.009003\|\|p
1669	2014	newSVpv\|\|\|
1670	2015	newSVrv\|\|\|

1674	2019	newTOKEN\|\|\|
1675	2020	newUNOP\|\|\|
1676	2021	newWHENOP\|\|5.009003\|
1677		newWHILEOP\|\|5.009003\|
	2022	newWHILEOP\|\|5.013007\|
1678	2023	newXS_flags\|\|5.009004\|
	2024	newXS_len_flags\|\|\|
1679	2025	newXSproto\|\|5.006000\|
1680	2026	newXS\|\|5.006000\|
1681	2027	new_collate\|\|5.006000\|

1690	2036	next_symbol\|\|\|
1691	2037	nextargv\|\|\|
1692	2038	nextchar\|\|\|
1693		ninstr\|\|\|
	2039	ninstr\|\|\|n
1694	2040	no_bareword_allowed\|\|\|
1695	2041	no_fh_allowed\|\|\|
1696	2042	no_op\|\|\|

1698	2044	nothreadhook\|\|5.008000\|
1699	2045	nuke_stacks\|\|\|
1700	2046	num_overflow\|\|\|n
1701		offer_nice_chunk\|\|\|
1702	2047	oopsAV\|\|\|
1703		oopsCV\|\|\|
1704	2048	oopsHV\|\|\|
	2049	op_append_elem\|\|5.013006\|
	2050	op_append_list\|\|5.013006\|
1705	2051	op_clear\|\|\|
1706	2052	op_const_sv\|\|\|
	2053	op_contextualize\|\|5.013006\|
1707	2054	op_dump\|\|5.006000\|
1708	2055	op_free\|\|\|
1709	2056	op_getmad_weak\|\|\|
1710	2057	op_getmad\|\|\|
	2058	op_integerize\|\|\|
	2059	op_linklist\|\|5.013006\|
	2060	op_lvalue_flags\|\|\|
	2061	op_lvalue\|\|5.013007\|
1711	2062	op_null\|\|5.007002\|
	2063	op_prepend_elem\|\|5.013006\|
	2064	op_refcnt_dec\|\|\|
	2065	op_refcnt_inc\|\|\|
1712	2066	op_refcnt_lock\|\|5.009002\|
1713	2067	op_refcnt_unlock\|\|5.009002\|
	2068	op_scope\|\|5.013007\|
	2069	op_std_init\|\|\|
	2070	op_unscope\|\|\|
1714	2071	op_xmldump\|\|\|
1715	2072	open_script\|\|\|
	2073	opslab_force_free\|\|\|
	2074	opslab_free_nopad\|\|\|
	2075	opslab_free\|\|\|
	2076	opt_scalarhv\|\|\|
1716	2077	pMY_CXT_\|5.007003\|\|p
1717	2078	pMY_CXT\|5.007003\|\|p
1718	2079	pTHX_\|5.006000\|\|p

1720	2081	packWARN\|5.007003\|\|p
1721	2082	pack_cat\|\|5.007003\|
1722	2083	pack_rec\|\|\|
	2084	package_version\|\|\|
1723	2085	package\|\|\|
1724	2086	packlist\|\|5.008001\|
1725		pad_add_anon\|\|\|
1726		pad_add_name\|\|\|
	2087	pad_add_anon\|\|5.008001\|
	2088	pad_add_name_pvn\|\|5.015001\|
	2089	pad_add_name_pvs\|\|5.015001\|
	2090	pad_add_name_pv\|\|5.015001\|
	2091	pad_add_name_sv\|\|5.015001\|
	2092	pad_alloc_name\|\|\|
1727	2093	pad_alloc\|\|\|
1728	2094	pad_block_start\|\|\|
1729	2095	pad_check_dup\|\|\|
1730		pad_compname_type\|\|\|
	2096	pad_compname_type\|\|5.009003\|
1731	2097	pad_findlex\|\|\|
1732		pad_findmy\|\|\|
	2098	pad_findmy_pvn\|\|5.015001\|
	2099	pad_findmy_pvs\|\|5.015001\|
	2100	pad_findmy_pv\|\|5.015001\|
	2101	pad_findmy_sv\|\|5.015001\|
1733	2102	pad_fixup_inner_anons\|\|\|
1734	2103	pad_free\|\|\|
1735	2104	pad_leavemy\|\|\|
1736		pad_new\|\|\|
	2105	pad_new\|\|5.008001\|
1737	2106	pad_peg\|\|\|n
1738	2107	pad_push\|\|\|
1739	2108	pad_reset\|\|\|
1740	2109	pad_setsv\|\|\|
1741		pad_sv\|\|5.009004\|
	2110	pad_sv\|\|\|
1742	2111	pad_swipe\|\|\|
1743		pad_tidy\|\|\|
1744		pad_undef\|\|\|
	2112	pad_tidy\|\|5.008001\|
	2113	padlist_dup\|\|\|
	2114	padlist_store\|\|\|
	2115	parse_arithexpr\|\|5.013008\|
	2116	parse_barestmt\|\|5.013007\|
	2117	parse_block\|\|5.013007\|
1745	2118	parse_body\|\|\|
	2119	parse_fullexpr\|\|5.013008\|
	2120	parse_fullstmt\|\|5.013005\|
	2121	parse_label\|\|5.013007\|
	2122	parse_listexpr\|\|5.013008\|
	2123	parse_stmtseq\|\|5.013006\|
	2124	parse_termexpr\|\|5.013008\|
1746	2125	parse_unicode_opts\|\|\|
	2126	parser_dup\|\|\|
	2127	parser_free\|\|\|
1747	2128	path_is_absolute\|\|\|n
1748	2129	peep\|\|\|
1749		pending_ident\|\|\|
1750	2130	perl_alloc_using\|\|\|n
1751	2131	perl_alloc\|\|\|n
1752	2132	perl_clone_using\|\|\|n

1758	2138	perl_run\|\|\|n
1759	2139	pidgone\|\|\|
1760	2140	pm_description\|\|\|
1761		pmflag\|\|\|
1762	2141	pmop_dump\|\|5.006000\|
1763	2142	pmop_xmldump\|\|\|
1764	2143	pmruntime\|\|\|
1765	2144	pmtrans\|\|\|
1766	2145	pop_scope\|\|\|
1767		pregcomp\|\|\|
	2146	populate_isa\|\|\|v
	2147	pregcomp\|\|5.009005\|
1768	2148	pregexec\|\|\|
	2149	pregfree2\|\|5.011000\|
1769	2150	pregfree\|\|\|
1770		prepend_elem\|\|\|
1771	2151	prepend_madprops\|\|\|
	2152	prescan_version\|\|5.011004\|
1772	2153	printbuf\|\|\|
1773	2154	printf_nocontext\|\|\|vn
1774		ptr_table_clear\|\|\|
1775		ptr_table_fetch\|\|\|
	2155	process_special_blocks\|\|\|
	2156	ptr_table_clear\|\|5.009005\|
	2157	ptr_table_fetch\|\|5.009005\|
1776	2158	ptr_table_find\|\|\|n
1777		ptr_table_free\|\|\|
1778		ptr_table_new\|\|\|
1779		ptr_table_split\|\|\|
1780		ptr_table_store\|\|\|
	2159	ptr_table_free\|\|5.009005\|
	2160	ptr_table_new\|\|5.009005\|
	2161	ptr_table_split\|\|5.009005\|
	2162	ptr_table_store\|\|5.009005\|
1781	2163	push_scope\|\|\|
1782	2164	put_byte\|\|\|
1783		pv_display\|\|5.006000\|
1784		pv_escape\|\|5.009004\|
1785		pv_pretty\|\|5.009004\|
	2165	pv_display\|5.006000\|\|p
	2166	pv_escape\|5.009004\|\|p
	2167	pv_pretty\|5.009004\|\|p
1786	2168	pv_uni_display\|\|5.007003\|
1787	2169	qerror\|\|\|
1788	2170	qsortsvu\|\|\|
	2171	re_compile\|\|5.009005\|
1789	2172	re_croak2\|\|\|
1790		re_dup\|\|\|
1791		re_intuit_start\|\|5.006000\|
	2173	re_dup_guts\|\|\|
	2174	re_intuit_start\|\|5.009005\|
1792	2175	re_intuit_string\|\|5.006000\|
	2176	re_op_compile\|\|\|
	2177	readpipe_override\|\|\|
1793	2178	realloc\|\|5.007002\|n
1794		reentrant_free\|\|\|
1795		reentrant_init\|\|\|
1796		reentrant_retry\|\|\|vn
1797		reentrant_size\|\|\|
	2179	reentrant_free\|\|5.017004\|
	2180	reentrant_init\|\|5.017004\|
	2181	reentrant_retry\|\|5.017004\|vn
	2182	reentrant_size\|\|5.017004\|
1798	2183	ref_array_or_hash\|\|\|
1799	2184	refcounted_he_chain_2hv\|\|\|
1800		refcounted_he_fetch\|\|\|
	2185	refcounted_he_fetch_pvn\|\|\|
	2186	refcounted_he_fetch_pvs\|\|\|
	2187	refcounted_he_fetch_pv\|\|\|
	2188	refcounted_he_fetch_sv\|\|\|
1801	2189	refcounted_he_free\|\|\|
1802		refcounted_he_new\|\|\|
	2190	refcounted_he_inc\|\|\|
	2191	refcounted_he_new_pvn\|\|\|
	2192	refcounted_he_new_pvs\|\|\|
	2193	refcounted_he_new_pv\|\|\|
	2194	refcounted_he_new_sv\|\|\|
1803	2195	refcounted_he_value\|\|\|
1804	2196	refkids\|\|\|
1805	2197	refto\|\|\|
1806		ref\|\|5.009003\|
	2198	ref\|\|5.017004\|
	2199	reg_check_named_buff_matched\|\|\|
	2200	reg_named_buff_all\|\|5.009005\|
	2201	reg_named_buff_exists\|\|5.009005\|
	2202	reg_named_buff_fetch\|\|5.009005\|
	2203	reg_named_buff_firstkey\|\|5.009005\|
	2204	reg_named_buff_iter\|\|\|
	2205	reg_named_buff_nextkey\|\|5.009005\|
	2206	reg_named_buff_scalar\|\|5.009005\|
	2207	reg_named_buff\|\|\|
1807	2208	reg_node\|\|\|
	2209	reg_numbered_buff_fetch\|\|\|
	2210	reg_numbered_buff_length\|\|\|
	2211	reg_numbered_buff_store\|\|\|
	2212	reg_qr_package\|\|\|
	2213	reg_recode\|\|\|
	2214	reg_scan_name\|\|\|
	2215	reg_skipcomment\|\|\|
	2216	reg_temp_copy\|\|\|
1808	2217	reganode\|\|\|
1809	2218	regatom\|\|\|
1810	2219	regbranch\|\|\|

1812	2221	regclass\|\|\|
1813	2222	regcppop\|\|\|
1814	2223	regcppush\|\|\|
1815		regcurly\|\|\|n
	2224	regcurly\|\|\|
	2225	regdump_extflags\|\|\|
1816	2226	regdump\|\|5.005000\|
	2227	regdupe_internal\|\|\|
1817	2228	regexec_flags\|\|5.005000\|
	2229	regfree_internal\|\|5.009005\|
1818	2230	reghop3\|\|\|n
	2231	reghop4\|\|\|n
1819	2232	reghopmaybe3\|\|\|n
1820	2233	reginclass\|\|\|
1821	2234	reginitcolors\|\|5.006000\|

1832	2245	reguni\|\|\|
1833	2246	regwhite\|\|\|n
1834	2247	reg\|\|\|
1835		repeatcpy\|\|\|
	2248	repeatcpy\|\|\|n
1836	2249	report_evil_fh\|\|\|
	2250	report_redefined_cv\|\|\|
1837	2251	report_uninit\|\|\|
1838		require_errno\|\|\|
	2252	report_wrongway_fh\|\|\|
1839	2253	require_pv\|\|5.006000\|
	2254	require_tie_mod\|\|\|
1840	2255	restore_magic\|\|\|
1841		rninstr\|\|\|
	2256	rninstr\|\|\|n
	2257	rpeep\|\|\|
1842	2258	rsignal_restore\|\|\|
1843	2259	rsignal_save\|\|\|
1844	2260	rsignal_state\|\|5.004000\|

1847	2263	run_user_filter\|\|\|
1848	2264	runops_debug\|\|5.005000\|
1849	2265	runops_standard\|\|5.005000\|
	2266	rv2cv_op_cv\|\|5.013006\|
1850	2267	rvpv_dup\|\|\|
1851	2268	rxres_free\|\|\|
1852	2269	rxres_restore\|\|\|

1859	2276	save_I16\|\|5.004000\|
1860	2277	save_I32\|\|\|
1861	2278	save_I8\|\|5.006000\|
	2279	save_adelete\|\|5.011000\|
	2280	save_aelem_flags\|\|5.011000\|
1862	2281	save_aelem\|\|5.004050\|
1863	2282	save_alloc\|\|5.006000\|
1864	2283	save_aptr\|\|\|

1875	2294	save_generic_svref\|\|5.005030\|
1876	2295	save_gp\|\|5.004000\|
1877	2296	save_hash\|\|\|
	2297	save_hdelete\|\|5.011000\|
1878	2298	save_hek_flags\|\|\|n
	2299	save_helem_flags\|\|5.011000\|
1879	2300	save_helem\|\|5.004050\|
1880		save_hints\|\|5.005000\|
	2301	save_hints\|\|5.010001\|
1881	2302	save_hptr\|\|\|
1882	2303	save_int\|\|\|
1883	2304	save_item\|\|\|

1888	2309	save_magic\|\|\|
1889	2310	save_mortalizesv\|\|5.007001\|
1890	2311	save_nogv\|\|\|
1891		save_op\|\|\|
1892		save_padsv\|\|5.007001\|
	2312	save_op\|\|5.005000\|
	2313	save_padsv_and_mortalize\|\|5.010001\|
1893	2314	save_pptr\|\|\|
	2315	save_pushi32ptr\|\|5.010001\|
	2316	save_pushptri32ptr\|\|\|
	2317	save_pushptrptr\|\|5.010001\|
	2318	save_pushptr\|\|5.010001\|
1894	2319	save_re_context\|\|5.006000\|
1895	2320	save_scalar_at\|\|\|
1896	2321	save_scalar\|\|\|

1902	2327	savepvn\|\|\|
1903	2328	savepvs\|\|5.009003\|
1904	2329	savepv\|\|\|
	2330	savesharedpvn\|\|5.009005\|
	2331	savesharedpvs\|\|5.013006\|
1905	2332	savesharedpv\|\|5.007003\|
	2333	savesharedsvpv\|\|5.013006\|
1906	2334	savestack_grow_cnt\|\|5.008001\|
1907	2335	savestack_grow\|\|\|
1908	2336	savesvpv\|\|5.009002\|

1928	2356	scan_subst\|\|\|
1929	2357	scan_trans\|\|\|
1930	2358	scan_version\|\|5.009001\|
1931		scan_vstring\|\|5.008001\|
	2359	scan_vstring\|\|5.009005\|
1932	2360	scan_word\|\|\|
1933		scope\|\|\|
1934	2361	screaminstr\|\|5.005000\|
	2362	search_const\|\|\|
1935	2363	seed\|\|5.008001\|
1936	2364	sequence_num\|\|\|
1937		sequence_tail\|\|\|
1938		sequence\|\|\|
1939	2365	set_context\|\|5.006000\|n
1940		set_csh\|\|\|
1941	2366	set_numeric_local\|\|5.006000\|
1942	2367	set_numeric_radix\|\|5.006000\|
1943	2368	set_numeric_standard\|\|5.006000\|
1944	2369	setdefout\|\|\|
1945		setenv_getix\|\|\|
1946	2370	share_hek_flags\|\|\|
1947	2371	share_hek\|\|5.004000\|
1948	2372	si_dup\|\|\|

1952	2376	skipspace1\|\|\|
1953	2377	skipspace2\|\|\|
1954	2378	skipspace\|\|\|
	2379	softref2xv\|\|\|
1955	2380	sortcv_stacked\|\|\|
1956	2381	sortcv_xsub\|\|\|
1957	2382	sortcv\|\|\|

1963	2388	start_force\|\|\|
1964	2389	start_glob\|\|\|
1965	2390	start_subparse\|\|5.004000\|
1966		stashpv_hvname_match\|\|5.009004\|
1967	2391	stdize_locale\|\|\|
1968	2392	strEQ\|\|\|
1969	2393	strGE\|\|\|

1972	2396	strLT\|\|\|
1973	2397	strNE\|\|\|
1974	2398	str_to_version\|\|5.006000\|
1975		stringify_regexp\|\|\|
1976	2399	strip_return\|\|\|
1977	2400	strnEQ\|\|\|
1978	2401	strnNE\|\|\|

1981	2404	sublex_done\|\|\|
1982	2405	sublex_push\|\|\|
1983	2406	sublex_start\|\|\|
	2407	sv_2bool_flags\|\|5.013006\|
1984	2408	sv_2bool\|\|\|
1985	2409	sv_2cv\|\|\|
1986	2410	sv_2io\|\|\|

1989	2413	sv_2iv_flags\|\|5.009001\|
1990	2414	sv_2iv\|\|\|
1991	2415	sv_2mortal\|\|\|
1992		sv_2nv\|\|\|
1993		sv_2pv_flags\|\|5.007002\|
	2416	sv_2num\|\|\|
	2417	sv_2nv_flags\|\|5.013001\|
	2418	sv_2pv_flags\|5.007002\|\|p
1994	2419	sv_2pv_nolen\|5.006000\|\|p
1995		sv_2pvbyte_nolen\|\|\|
	2420	sv_2pvbyte_nolen\|5.006000\|\|p
1996	2421	sv_2pvbyte\|5.006000\|\|p
1997	2422	sv_2pvutf8_nolen\|\|5.006000\|
1998	2423	sv_2pvutf8\|\|5.006000\|

2004	2429	sv_backoff\|\|\|
2005	2430	sv_bless\|\|\|
2006	2431	sv_cat_decode\|\|5.008001\|
	2432	sv_catpv_flags\|\|5.013006\|
2007	2433	sv_catpv_mg\|5.004050\|\|p
	2434	sv_catpv_nomg\|\|5.013006\|
2008	2435	sv_catpvf_mg_nocontext\|\|\|pvn
2009	2436	sv_catpvf_mg\|5.006000\|5.004000\|pv
2010	2437	sv_catpvf_nocontext\|\|\|vn

2013	2440	sv_catpvn_mg\|5.004050\|\|p
2014	2441	sv_catpvn_nomg\|5.007002\|\|p
2015	2442	sv_catpvn\|\|\|
	2443	sv_catpvs_flags\|\|5.013006\|
	2444	sv_catpvs_mg\|\|5.013006\|
	2445	sv_catpvs_nomg\|\|5.013006\|
2016	2446	sv_catpvs\|5.009003\|\|p
2017	2447	sv_catpv\|\|\|
2018	2448	sv_catsv_flags\|\|5.007002\|

2020	2450	sv_catsv_nomg\|5.007002\|\|p
2021	2451	sv_catsv\|\|\|
2022	2452	sv_catxmlpvn\|\|\|
	2453	sv_catxmlpv\|\|\|
2023	2454	sv_catxmlsv\|\|\|
2024	2455	sv_chop\|\|\|
2025	2456	sv_clean_all\|\|\|
2026	2457	sv_clean_objs\|\|\|
2027	2458	sv_clear\|\|\|
	2459	sv_cmp_flags\|\|5.013006\|
	2460	sv_cmp_locale_flags\|\|5.013006\|
2028	2461	sv_cmp_locale\|\|5.004000\|
2029	2462	sv_cmp\|\|\|
	2463	sv_collxfrm_flags\|\|5.013006\|
2030	2464	sv_collxfrm\|\|\|
2031		sv_compile_2op\|\|5.008001\|
2032		sv_copypv\|\|5.007003\|
	2465	sv_copypv_flags\|\|5.017002\|
	2466	sv_copypv_nomg\|\|5.017002\|
	2467	sv_copypv\|\|\|
	2468	sv_dec_nomg\|\|5.013002\|
2033	2469	sv_dec\|\|\|
2034	2470	sv_del_backref\|\|\|
	2471	sv_derived_from_pvn\|\|5.015004\|
	2472	sv_derived_from_pv\|\|5.015004\|
	2473	sv_derived_from_sv\|\|5.015004\|
2035	2474	sv_derived_from\|\|5.004000\|
	2475	sv_destroyable\|\|5.010000\|
	2476	sv_does_pvn\|\|5.015004\|
	2477	sv_does_pv\|\|5.015004\|
	2478	sv_does_sv\|\|5.015004\|
2036	2479	sv_does\|\|5.009004\|
2037	2480	sv_dump\|\|\|
	2481	sv_dup_common\|\|\|
	2482	sv_dup_inc_multiple\|\|\|
	2483	sv_dup_inc\|\|\|
2038	2484	sv_dup\|\|\|
	2485	sv_eq_flags\|\|5.013006\|
2039	2486	sv_eq\|\|\|
2040	2487	sv_exp_grow\|\|\|
2041	2488	sv_force_normal_flags\|\|5.007001\|

2046	2493	sv_gets\|\|5.004000\|
2047	2494	sv_grow\|\|\|
2048	2495	sv_i_ncmp\|\|\|
	2496	sv_inc_nomg\|\|5.013002\|
2049	2497	sv_inc\|\|\|
	2498	sv_insert_flags\|\|5.010001\|
2050	2499	sv_insert\|\|\|
2051	2500	sv_isa\|\|\|
2052	2501	sv_isobject\|\|\|

2054	2503	sv_kill_backrefs\|\|\|
2055	2504	sv_len_utf8\|\|5.006000\|
2056	2505	sv_len\|\|\|
	2506	sv_magic_portable\|5.017004\|5.004000\|p
2057	2507	sv_magicext\|\|5.007003\|
2058	2508	sv_magic\|\|\|
2059	2509	sv_mortalcopy\|\|\|

2065	2515	sv_nounlocking\|\|\|
2066	2516	sv_nv\|\|5.005000\|
2067	2517	sv_peek\|\|5.005000\|
2068		sv_pos_b2u_forwards\|\|\|
2069	2518	sv_pos_b2u_midway\|\|\|
2070	2519	sv_pos_b2u\|\|5.006000\|
2071	2520	sv_pos_u2b_cached\|\|\|
	2521	sv_pos_u2b_flags\|\|5.011005\|
2072	2522	sv_pos_u2b_forwards\|\|\|n
2073	2523	sv_pos_u2b_midway\|\|\|n
2074	2524	sv_pos_u2b\|\|5.006000\|
2075	2525	sv_pvbyten_force\|\|5.006000\|
2076	2526	sv_pvbyten\|\|5.006000\|
2077	2527	sv_pvbyte\|\|5.006000\|
2078		sv_pvn_force_flags\|\|5.007002\|
2079		sv_pvn_force\|\|\|p
2080		sv_pvn_nomg\|5.007003\|\|p
2081		sv_pvn\|5.005000\|\|p
	2528	sv_pvn_force_flags\|5.007002\|\|p
	2529	sv_pvn_force\|\|\|
	2530	sv_pvn_nomg\|5.007003\|5.005000\|p
	2531	sv_pvn\|\|5.005000\|
2082	2532	sv_pvutf8n_force\|\|5.006000\|
2083	2533	sv_pvutf8n\|\|5.006000\|
2084	2534	sv_pvutf8\|\|5.006000\|
2085	2535	sv_pv\|\|5.006000\|
2086	2536	sv_recode_to_utf8\|\|5.007003\|
2087	2537	sv_reftype\|\|\|
	2538	sv_ref\|\|\|
2088	2539	sv_release_COW\|\|\|
2089		sv_release_IVX\|\|\|
2090	2540	sv_replace\|\|\|
2091	2541	sv_report_used\|\|\|
2092	2542	sv_reset\|\|\|
2093	2543	sv_rvweaken\|\|5.006000\|
	2544	sv_sethek\|\|\|
2094	2545	sv_setiv_mg\|5.004050\|\|p
2095	2546	sv_setiv\|\|\|
2096	2547	sv_setnv_mg\|5.006000\|\|p

2104	2555	sv_setpviv\|\|5.008001\|
2105	2556	sv_setpvn_mg\|5.004050\|\|p
2106	2557	sv_setpvn\|\|\|
	2558	sv_setpvs_mg\|\|5.013006\|
2107	2559	sv_setpvs\|5.009004\|\|p
2108	2560	sv_setpv\|\|\|
2109	2561	sv_setref_iv\|\|\|
2110	2562	sv_setref_nv\|\|\|
2111	2563	sv_setref_pvn\|\|\|
	2564	sv_setref_pvs\|\|5.017004\|
2112	2565	sv_setref_pv\|\|\|
2113	2566	sv_setref_uv\|\|5.007001\|
2114	2567	sv_setsv_cow\|\|\|

2123	2576	sv_true\|\|5.005000\|
2124	2577	sv_unglob\|\|\|
2125	2578	sv_uni_display\|\|5.007003\|
	2579	sv_unmagicext\|\|5.013008\|
2126	2580	sv_unmagic\|\|\|
2127	2581	sv_unref_flags\|\|5.007001\|
2128	2582	sv_unref\|\|\|

2134	2588	sv_utf8_decode\|\|5.006000\|
2135	2589	sv_utf8_downgrade\|\|5.006000\|
2136	2590	sv_utf8_encode\|\|5.006000\|
	2591	sv_utf8_upgrade_flags_grow\|\|5.011000\|
2137	2592	sv_utf8_upgrade_flags\|\|5.007002\|
	2593	sv_utf8_upgrade_nomg\|\|5.007002\|
2138	2594	sv_utf8_upgrade\|\|5.007001\|
2139	2595	sv_uv\|5.005000\|\|p
2140	2596	sv_vcatpvf_mg\|5.006000\|5.004000\|p
	2597	sv_vcatpvfn_flags\|\|5.017002\|
2141	2598	sv_vcatpvfn\|\|5.004000\|
2142	2599	sv_vcatpvf\|5.006000\|5.004000\|p
2143	2600	sv_vsetpvf_mg\|5.006000\|5.004000\|p

2147	2604	svtype\|\|\|
2148	2605	swallow_bom\|\|\|
2149	2606	swash_fetch\|\|5.007002\|
2150		swash_get\|\|\|
2151	2607	swash_init\|\|5.006000\|
	2608	swatch_get\|\|\|
	2609	sys_init3\|\|5.010000\|n
	2610	sys_init\|\|5.010000\|n
2152	2611	sys_intern_clear\|\|\|
2153	2612	sys_intern_dup\|\|\|
2154	2613	sys_intern_init\|\|\|
	2614	sys_term\|\|5.010000\|n
2155	2615	taint_env\|\|\|
2156	2616	taint_proper\|\|\|
	2617	tied_method\|\|\|v
2157	2618	tmps_grow\|\|5.006000\|
2158	2619	toLOWER\|\|\|
2159	2620	toUPPER\|\|\|
2160	2621	to_byte_substr\|\|\|
	2622	to_lower_latin1\|\|\|
2161	2623	to_uni_fold\|\|5.007003\|
2162	2624	to_uni_lower_lc\|\|5.006000\|
2163	2625	to_uni_lower\|\|5.007003\|

2166	2628	to_uni_upper_lc\|\|5.006000\|
2167	2629	to_uni_upper\|\|5.007003\|
2168	2630	to_utf8_case\|\|5.007003\|
2169		to_utf8_fold\|\|5.007003\|
2170		to_utf8_lower\|\|5.007003\|
	2631	to_utf8_fold\|\|5.015007\|
	2632	to_utf8_lower\|\|5.015007\|
2171	2633	to_utf8_substr\|\|\|
2172		to_utf8_title\|\|5.007003\|
2173		to_utf8_upper\|\|5.007003\|
	2634	to_utf8_title\|\|5.015007\|
	2635	to_utf8_upper\|\|5.015007\|
2174	2636	token_free\|\|\|
2175	2637	token_getmad\|\|\|
2176	2638	tokenize_use\|\|\|
2177	2639	tokeq\|\|\|
2178	2640	tokereport\|\|\|
2179		too_few_arguments\|\|\|
2180		too_many_arguments\|\|\|
	2641	too_few_arguments_pv\|\|\|
	2642	too_few_arguments_sv\|\|\|
	2643	too_many_arguments_pv\|\|\|
	2644	too_many_arguments_sv\|\|\|
	2645	translate_substr_offsets\|\|\|
	2646	try_amagic_bin\|\|\|
	2647	try_amagic_un\|\|\|
2181	2648	uiv_2buf\|\|\|n
2182	2649	unlnk\|\|\|
2183	2650	unpack_rec\|\|\|
2184	2651	unpack_str\|\|5.007003\|
2185	2652	unpackstring\|\|5.008001\|
	2653	unreferenced_to_tmp_stack\|\|\|
2186	2654	unshare_hek_or_pvn\|\|\|
2187	2655	unshare_hek\|\|\|
2188	2656	unsharepvn\|\|5.004000\|
2189	2657	unwind_handler_stack\|\|\|
2190		upg_version\|\|5.009000\|
	2658	update_debugger_info\|\|\|
	2659	upg_version\|\|5.009005\|
2191	2660	usage\|\|\|
	2661	utf16_textfilter\|\|\|
2192	2662	utf16_to_utf8_reversed\|\|5.006001\|
2193	2663	utf16_to_utf8\|\|5.006001\|
2194	2664	utf8_distance\|\|5.006000\|
2195	2665	utf8_hop\|\|5.006000\|
2196	2666	utf8_length\|\|5.007001\|
	2667	utf8_mg_len_cache_update\|\|\|
2197	2668	utf8_mg_pos_cache_update\|\|\|
2198	2669	utf8_to_bytes\|\|5.006001\|
	2670	utf8_to_uvchr_buf\|\|5.015009\|
2199	2671	utf8_to_uvchr\|\|5.007001\|
	2672	utf8_to_uvuni_buf\|\|5.015009\|
2200	2673	utf8_to_uvuni\|\|5.007001\|
2201	2674	utf8n_to_uvchr\|\|\|
2202	2675	utf8n_to_uvuni\|\|5.007001\|

2205	2678	uvchr_to_utf8\|\|\|
2206	2679	uvuni_to_utf8_flags\|\|5.007003\|
2207	2680	uvuni_to_utf8\|\|5.007001\|
	2681	valid_utf8_to_uvchr\|\|5.015009\|
	2682	valid_utf8_to_uvuni\|\|5.015009\|
2208	2683	validate_suid\|\|\|
2209	2684	varname\|\|\|
2210	2685	vcmp\|\|5.009000\|
2211	2686	vcroak\|\|5.006000\|
2212	2687	vdeb\|\|5.007003\|
2213		vdie_common\|\|\|
2214		vdie_croak_common\|\|\|
2215		vdie\|\|\|
2216	2688	vform\|\|5.006000\|
2217	2689	visit\|\|\|
2218	2690	vivify_defelem\|\|\|
2219	2691	vivify_ref\|\|\|
2220		vload_module\|\|5.006000\|
	2692	vload_module\|5.006000\|\|p
2221	2693	vmess\|\|5.006000\|
2222	2694	vnewSVpvf\|5.006000\|5.004000\|p
2223	2695	vnormal\|\|5.009002\|

2228	2700	vwarn\|\|5.006000\|
2229	2701	wait4pid\|\|\|
2230	2702	warn_nocontext\|\|\|vn
	2703	warn_sv\|\|5.013001\|
2231	2704	warner_nocontext\|\|\|vn
2232	2705	warner\|5.006000\|5.004000\|pv
2233	2706	warn\|\|\|v
	2707	was_lvalue_sub\|\|\|
2234	2708	watch\|\|\|
	2709	whichsig_pvn\|\|5.015004\|
	2710	whichsig_pv\|\|5.015004\|
	2711	whichsig_sv\|\|5.015004\|
2235	2712	whichsig\|\|\|
	2713	with_queued_errors\|\|\|
	2714	wrap_op_checker\|\|5.015008\|
2236	2715	write_no_mem\|\|\|
2237	2716	write_to_stderr\|\|\|
	2717	xmldump_all_perl\|\|\|
2238	2718	xmldump_all\|\|\|
2239	2719	xmldump_attr\|\|\|
2240	2720	xmldump_eval\|\|\|
2241	2721	xmldump_form\|\|\|
2242	2722	xmldump_indent\|\|\|v
	2723	xmldump_packsubs_perl\|\|\|
2243	2724	xmldump_packsubs\|\|\|
	2725	xmldump_sub_perl\|\|\|
2244	2726	xmldump_sub\|\|\|
2245	2727	xmldump_vindent\|\|\|
	2728	xs_apiversion_bootcheck\|\|\|
	2729	xs_version_bootcheck\|\|\|
	2730	yyerror_pvn\|\|\|
	2731	yyerror_pv\|\|\|
2246	2732	yyerror\|\|\|
2247	2733	yylex\|\|\|
2248	2734	yyparse\|\|\|
	2735	yyunlex\|\|\|
2249	2736	yywarn\|\|\|
2250	2737	);
2251	2738

2260	2747
2261	2748	# Scan for possible replacement candidates
2262	2749
2263		my(%replace, %need, %hints, %depends);
	2750	my(%replace, %need, %hints, %warnings, %depends);
2264	2751	my $replace = 0;
2265		my $hint = '';
	2752	my($hint, $define, $function);
	2753
	2754	sub find_api
	2755	{
	2756	my $code = shift;
	2757	$code =~ s{
	2758	/ (?: \[^]\+(?:[^$ccs][^]\+) / \| /[^\r\n]*)
	2759	\| "[^"\\](?:\\.[^"\\])*"
	2760	\| '[^'\\](?:\\.[^'\\])*' }{}egsx;
	2761	grep { exists $API{$_} } $code =~ /(\w+)/mg;
	2762	}
2266	2763
2267	2764	while (<DATA>) {
2268	2765	if ($hint) {
	2766	my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings;
2269	2767	if (m{^\s\\s(.?)\s$}) {
2270		$hints{$hint} \|\|= ''; # suppress warning with older perls
2271		$hints{$hint} .= "$1\n";
	2768	for (@{$hint->[1]}) {
	2769	$h->{$_} \|\|= ''; # suppress warning with older perls
	2770	$h->{$_} .= "$1\n";
	2771	}
	2772	}
	2773	else { undef $hint }
	2774	}
	2775
	2776	$hint = [$1, [split /,?\s+/, $2]]
	2777	if m{^\s$rccs\s+(Hint\|Warning):\s+(\w+(?:,?\s+\w+))\s*$};
	2778
	2779	if ($define) {
	2780	if ($define->[1] =~ /\\$/) {
	2781	$define->[1] .= $_;
2272	2782	}
2273	2783	else {
2274		$hint = '';
	2784	if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) {
	2785	my @n = find_api($define->[1]);
	2786	push @{$depends{$define->[0]}}, @n if @n
	2787	}
	2788	undef $define;
2275	2789	}
2276	2790	}
2277		$hint = $1 if m{^\s$rccs\sHint:\s+(\w+)\s$};
	2791
	2792	$define = [$1, $2] if m{^\s#\sdefine\s+(\w+)(?:$[^)]$)?\s+(.)};
	2793
	2794	if ($function) {
	2795	if (/^}/) {
	2796	if (exists $API{$function->[0]}) {
	2797	my @n = find_api($function->[1]);
	2798	push @{$depends{$function->[0]}}, @n if @n
	2799	}
	2800	undef $function;
	2801	}
	2802	else {
	2803	$function->[1] .= $_;
	2804	}
	2805	}
	2806
	2807	$function = [$1, ''] if m{^DPPP_$my_(\w+)$};
2278	2808
2279	2809	$replace = $1 if m{^\s$rccs\s+Replace:\s+(\d+)\s+$rcce\s$};
2280	2810	$replace{$2} = $1 if $replace and m{^\s#\sdefine\s+(\w+)(?:$[^)]*$)?\s+(\w+)};
2281	2811	$replace{$2} = $1 if m{^\s#\sdefine\s+(\w+)(?:$[^)]$)?\s+(\w+).$rccs\s+Replace\s+$rcce};
2282	2812	$replace{$1} = $2 if m{^\s$rccs\s+Replace (\w+) with (\w+)\s+$rcce\s$};
2283	2813
2284		if (m{^\s$rccs\s+(\w+)\s+depends\s+on\s+(\w+(\s,\s\w+))\s+$rcce\s*$}) {
2285		push @{$depends{$1}}, map { s/\s+//g; $_ } split /,/, $2;
	2814	if (m{^\s$rccs\s+(\w+(\s,\s\w+))\s+depends\s+on\s+(\w+(\s,\s\w+))\s+$rcce\s$}) {
	2815	my @deps = map { s/\s+//g; $_ } split /,/, $3;
	2816	my $d;
	2817	for $d (map { s/\s+//g; $_ } split /,/, $1) {
	2818	push @{$depends{$d}}, @deps;
	2819	}
2286	2820	}
2287	2821
2288	2822	$need{$1} = 1 if m{^#if\s+defined$NEED_(\w+)(?:_GLOBAL)?$};
	2823	}
	2824
	2825	for (values %depends) {
	2826	my %s;
	2827	$_ = [sort grep !$s{$_}++, @$_];
2289	2828	}
2290	2829
2291	2830	if (exists $opt{'api-info'}) {

2306	2845	print "Support by $ppport provided back to perl-$todo.\n";
2307	2846	print "Support needs to be explicitly requested by NEED_$f.\n" if exists $need{$f};
2308	2847	print "Depends on: ", join(', ', @{$depends{$f}}), ".\n" if exists $depends{$f};
2309		print "$hints{$f}" if exists $hints{$f};
	2848	print "\n$hints{$f}" if exists $hints{$f};
	2849	print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f};
2310	2850	$info++;
2311	2851	}
2312		unless ($info) {
2313		print "No portability information available.\n";
2314		}
	2852	print "No portability information available.\n" unless $info;
2315	2853	$count++;
2316	2854	}
2317		if ($count > 0) {
2318		print "\n";
2319		}
2320		else {
2321		print "Found no API matching '$opt{'api-info'}'.\n";
2322		}
	2855	$count or print "Found no API matching '$opt{'api-info'}'.";
	2856	print "\n";
2323	2857	exit 0;
2324	2858	}
2325	2859

2331	2865	push @flags, 'explicit' if exists $need{$f};
2332	2866	push @flags, 'depend' if exists $depends{$f};
2333	2867	push @flags, 'hint' if exists $hints{$f};
	2868	push @flags, 'warning' if exists $warnings{$f};
2334	2869	my $flags = @flags ? ' ['.join(', ', @flags).']' : '';
2335	2870	print "$f$flags\n";
2336	2871	}

2338	2873	}
2339	2874
2340	2875	my @files;
2341		my @srcext = qw( xs c h cc cpp );
2342		my $srcext = join '\|', @srcext;
	2876	my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc );
	2877	my $srcext = join '\|', map { quotemeta $_ } @srcext;
2343	2878
2344	2879	if (@ARGV) {
2345	2880	my %seen;
2346		@files = grep { -f && !exists $seen{$_} } map { glob $_ } @ARGV;
	2881	for (@ARGV) {
	2882	if (-e) {
	2883	if (-f) {
	2884	push @files, $_ unless $seen{$_}++;
	2885	}
	2886	else { warn "'$_' is not a file.\n" }
	2887	}
	2888	else {
	2889	my @new = grep { -f } glob $_
	2890	or warn "'$_' does not exist.\n";
	2891	push @files, grep { !$seen{$_}++ } @new;
	2892	}
	2893	}
2347	2894	}
2348	2895	else {
2349	2896	eval {
2350	2897	require File::Find;
2351	2898	File::Find::find(sub {
2352		$File::Find::name =~ /\.($srcext)$/i
	2899	$File::Find::name =~ /($srcext)$/i
2353	2900	and push @files, $File::Find::name;
2354	2901	}, '.');
2355	2902	};
2356	2903	if ($@) {
2357		@files = map { glob "*.$_" } @srcext;
	2904	@files = map { glob "*$_" } @srcext;
2358	2905	}
2359	2906	}
2360	2907

2362	2909	my(@in, @out);
2363	2910	my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files;
2364	2911	for (@files) {
2365		my $out = exists $xsc{$_} \|\| /\b\Q$ppport\E$/i \|\| !/\.($srcext)$/i;
	2912	my $out = exists $xsc{$_} \|\| /\b\Q$ppport\E$/i \|\| !/($srcext)$/i;
2366	2913	push @{ $out ? \@out : \@in }, $_;
2367	2914	}
2368	2915	if (@ARGV && @out) {

2371	2918	@files = @in;
2372	2919	}
2373	2920
2374		unless (@files) {
2375		die "No input files given!\n";
2376		}
	2921	die "No input files given!\n" unless @files;
2377	2922
2378	2923	my(%files, %global, %revreplace);
2379	2924	%revreplace = reverse %replace;

2393	2938
2394	2939	my %file = (orig => $c, changes => 0);
2395	2940
2396		# temporarily remove C comments from the code
	2941	# Temporarily remove C/XS comments and strings from the code
2397	2942	my @ccom;
	2943
2398	2944	$c =~ s{
2399		(
2400		[^"'/]+
2401		\|
2402		(?:"[^"\\](?:\\.[^"\\])" [^"'/])+
2403		\|
2404		(?:'[^'\\](?:\\.[^'\\])' [^"'/])+
2405		)
2406		\|
2407		(/ (?:
2408		\[^]\+(?:[^$ccs][^]\+) /
2409		\|
2410		/[^\r\n]*
2411		))
2412		}{
2413		defined $2 and push @ccom, $2;
2414		defined $1 ? $1 : "$ccs$#ccom$cce";
2415		}egsx;
	2945	( ^$HS\#$HSinclude\b[^\r\n]+\b(?:\Q$ppport\E\|XSUB\.h)\b[^\r\n]*
	2946	\| ^$HS\#$HS(?:define\|elif\|if(?:def)?)\b[^\r\n]* )
	2947	\| ( ^$HS\#[^\r\n]
	2948	\| "[^"\\](?:\\.[^"\\])*"
	2949	\| '[^'\\](?:\\.[^'\\])*'
	2950	\| / (?: \[^]\+(?:[^$ccs][^]\+) / \| /[^\r\n]* ) )
	2951	}{ defined $2 and push @ccom, $2;
	2952	defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex;
2416	2953
2417	2954	$file{ccom} = \@ccom;
2418	2955	$file{code} = $c;
2419		$file{has_inc_ppport} = ($c =~ /#.include.\Q$ppport\E/);
	2956	$file{has_inc_ppport} = $c =~ /^$HS#$HSinclude[^\r\n]+\b\Q$ppport\E\b/m;
2420	2957
2421	2958	my $func;
2422	2959

2427	2964	$file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func};
2428	2965	$file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/;
2429	2966	if (exists $API{$func}{provided}) {
	2967	$file{uses_provided}{$func}++;
2430	2968	if (!exists $API{$func}{base} \|\| $API{$func}{base} > $opt{'compat-version'}) {
2431	2969	$file{uses}{$func}++;
2432	2970	my @deps = rec_depend($func);

2437	2975	}
2438	2976	}
2439	2977	for ($func, @deps) {
2440		if (exists $need{$_}) {
2441		$file{needs}{$_} = 'static';
2442		}
	2978	$file{needs}{$_} = 'static' if exists $need{$_};
2443	2979	}
2444	2980	}
2445	2981	}

2455	2991	if (exists $need{$2}) {
2456	2992	$file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++;
2457	2993	}
2458		else {
2459		warning("Possibly wrong #define $1 in $filename");
2460		}
	2994	else { warning("Possibly wrong #define $1 in $filename") }
2461	2995	}
2462	2996
2463	2997	for (qw(uses needs uses_todo needed_global needed_static)) {

2494	3028	my %file = %{$files{$filename}};
2495	3029	my $func;
2496	3030	my $c = $file{code};
	3031	my $warnings = 0;
2497	3032
2498	3033	for $func (sort keys %{$file{uses_Perl}}) {
2499	3034	if ($API{$func}{varargs}) {
2500		my $changes = ($c =~ s{\b(Perl_$func\s$\s)(?!aTHX_?)($\|[^\s)]*\))}
2501		{ $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
2502		if ($changes) {
2503		warning("Doesn't pass interpreter argument aTHX to Perl_$func");
2504		$file{changes} += $changes;
	3035	unless ($API{$func}{nothxarg}) {
	3036	my $changes = ($c =~ s{\b(Perl_$func\s$\s)(?!aTHX_?)($\|[^\s)]*\))}
	3037	{ $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge);
	3038	if ($changes) {
	3039	warning("Doesn't pass interpreter argument aTHX to Perl_$func");
	3040	$file{changes} += $changes;
	3041	}
2505	3042	}
2506	3043	}
2507	3044	else {

2516	3053	$file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
2517	3054	}
2518	3055
2519		for $func (sort keys %{$file{uses}}) {
2520		next unless $file{uses}{$func}; # if it's only a dependency
2521		if (exists $file{uses_deps}{$func}) {
2522		diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
	3056	for $func (sort keys %{$file{uses_provided}}) {
	3057	if ($file{uses}{$func}) {
	3058	if (exists $file{uses_deps}{$func}) {
	3059	diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}}));
	3060	}
	3061	else {
	3062	diag("Uses $func");
	3063	}
2523	3064	}
2524		elsif (exists $replace{$func}) {
2525		warning("Uses $func instead of $replace{$func}");
2526		$file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g);
	3065	$warnings += hint($func);
	3066	}
	3067
	3068	unless ($opt{quiet}) {
	3069	for $func (sort keys %{$file{uses_todo}}) {
	3070	print "*** WARNING: Uses $func, which may not be portable below perl ",
	3071	format_version($API{$func}{todo}), ", even with '$ppport'\n";
	3072	$warnings++;
2527	3073	}
2528		else {
2529		diag("Uses $func");
2530		}
2531		hint($func);
2532		}
2533
2534		for $func (sort keys %{$file{uses_todo}}) {
2535		warning("Uses $func, which may not be portable below perl ",
2536		format_version($API{$func}{todo}));
2537	3074	}
2538	3075
2539	3076	for $func (sort keys %{$file{needed_static}}) {

2631	3168	my $s = $cppc != 1 ? 's' : '';
2632	3169	warning("Uses $cppc C++ style comment$s, which is not portable");
2633	3170	}
	3171
	3172	my $s = $warnings != 1 ? 's' : '';
	3173	my $warn = $warnings ? " ($warnings warning$s)" : '';
	3174	info("Analysis completed$warn");
2634	3175
2635	3176	if ($file{changes}) {
2636	3177	if (exists $opt{copy}) {

2686	3227	exit 0;
2687	3228
2688	3229
	3230	sub try_use { eval "use @_;"; return $@ eq '' }
	3231
2689	3232	sub mydiff
2690	3233	{
2691	3234	local *F = shift;

2696	3239	$diff = run_diff($opt{diff}, $file, $str);
2697	3240	}
2698	3241
2699		if (!defined $diff and can_use('Text::Diff')) {
	3242	if (!defined $diff and try_use('Text::Diff')) {
2700	3243	$diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' });
2701	3244	$diff = <<HEADER . $diff;
2702	3245	--- $file

2718	3261	}
2719	3262
2720	3263	print F $diff;
2721
2722	3264	}
2723	3265
2724	3266	sub run_diff

2755	3297	return undef;
2756	3298	}
2757	3299
2758		sub can_use
2759		{
2760		eval "use @_;";
2761		return $@ eq '';
2762		}
2763
2764	3300	sub rec_depend
2765	3301	{
2766		my $func = shift;
2767		my %seen;
	3302	my($func, $seen) = @_;
2768	3303	return () unless exists $depends{$func};
2769		grep !$seen{$_}++, map { ($_, rec_depend($_)) } @{$depends{$func}};
	3304	$seen = {%{$seen\|\|{}}};
	3305	return () if $seen->{$func}++;
	3306	my %s;
	3307	grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}};
2770	3308	}
2771	3309
2772	3310	sub parse_version

2846	3384	}
2847	3385
2848	3386	my %given_hints;
	3387	my %given_warnings;
2849	3388	sub hint
2850	3389	{
2851	3390	$opt{quiet} and return;
2852		$opt{hints} or return;
2853	3391	my $func = shift;
2854		exists $hints{$func} or return;
2855		$given_hints{$func}++ and return;
2856		my $hint = $hints{$func};
2857		$hint =~ s/^/ /mg;
2858		print " --- hint for $func ---\n", $hint;
	3392	my $rv = 0;
	3393	if (exists $warnings{$func} && !$given_warnings{$func}++) {
	3394	my $warn = $warnings{$func};
	3395	$warn =~ s!^!*** !mg;
	3396	print "*** WARNING: $func\n", $warn;
	3397	$rv++;
	3398	}
	3399	if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) {
	3400	my $hint = $hints{$func};
	3401	$hint =~ s/^/ /mg;
	3402	print " --- hint for $func ---\n", $hint;
	3403	}
	3404	$rv;
2859	3405	}
2860	3406
2861	3407	sub usage

2886	3432	if (\@ARGV && \$ARGV[0] eq '--unstrip') {
2887	3433	eval { require Devel::PPPort };
2888	3434	\$@ and die "Cannot require Devel::PPPort, please install.\\n";
2889		if (\$Devel::PPPort::VERSION < $VERSION) {
	3435	if (eval \$Devel::PPPort::VERSION < $VERSION) {
2890	3436	die "$0 was originally generated with Devel::PPPort $VERSION.\\n"
2891	3437	. "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n"
2892	3438	. "Please install a newer version, or --unstrip will not work.\\n";

2905	3451
2906	3452	END
2907	3453	/ms;
	3454	my($pl, $c) = $self =~ /(.^__DATA__)(.)/ms;
	3455	$c =~ s{
	3456	/ (?: \[^]\+(?:[^$ccs][^]\+) / \| /[^\r\n]*)
	3457	\| ( "[^"\\](?:\\.[^"\\])*"
	3458	\| '[^'\\](?:\\.[^'\\])*' )
	3459	\| ($HS+) }{ defined $2 ? ' ' : ($1 \|\| '') }gsex;
	3460	$c =~ s!\s+$!!mg;
	3461	$c =~ s!^$LF!!mg;
	3462	$c =~ s!^\s#\s!#!mg;
	3463	$c =~ s!^\s+!!mg;
2908	3464
2909	3465	open OUT, ">$0" or die "cannot strip $0: $!\n";
2910		print OUT $self;
	3466	print OUT "$pl$c\n";
2911	3467
2912	3468	exit 0;
2913	3469	}

2943	3499	# endif
2944	3500	#endif
2945	3501
2946		#define PERL_BCDVERSION ((PERL_REVISION * 0x1000000L) + (PERL_VERSION * 0x1000L) + PERL_SUBVERSION)
	3502	#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)\|((((dec)%100)/10)<<4)\|((dec)%10))
	3503	#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)\|(_dpppDEC2BCD(PERL_VERSION)<<12)\|_dpppDEC2BCD(PERL_SUBVERSION))
2947	3504
2948	3505	/* It is very unlikely that anyone will try to use this with Perl 6
2949	3506	(or greater), but who knows.

2951	3508	#if PERL_REVISION != 5
2952	3509	# error ppport.h only works with Perl version 5
2953	3510	#endif /* PERL_REVISION != 5 */
	3511	#ifndef dTHR
	3512	# define dTHR dNOOP
	3513	#endif
	3514	#ifndef dTHX
	3515	# define dTHX dNOOP
	3516	#endif
	3517
	3518	#ifndef dTHXa
	3519	# define dTHXa(x) dNOOP
	3520	#endif
	3521	#ifndef pTHX
	3522	# define pTHX void
	3523	#endif
	3524
	3525	#ifndef pTHX_
	3526	# define pTHX_
	3527	#endif
	3528
	3529	#ifndef aTHX
	3530	# define aTHX
	3531	#endif
	3532
	3533	#ifndef aTHX_
	3534	# define aTHX_
	3535	#endif
	3536
	3537	#if (PERL_BCDVERSION < 0x5006000)
	3538	# ifdef USE_THREADS
	3539	# define aTHXR thr
	3540	# define aTHXR_ thr,
	3541	# else
	3542	# define aTHXR
	3543	# define aTHXR_
	3544	# endif
	3545	# define dTHXR dTHR
	3546	#else
	3547	# define aTHXR aTHX
	3548	# define aTHXR_ aTHX_
	3549	# define dTHXR dTHX
	3550	#endif
	3551	#ifndef dTHXoa
	3552	# define dTHXoa(x) dTHXa(x)
	3553	#endif
2954	3554
2955	3555	#ifdef I_LIMITS
2956	3556	# include <limits.h>

3236	3836	# define IVSIZE 8
3237	3837	#endif
3238	3838
	3839	#ifndef LONGSIZE
	3840	# define LONGSIZE 8
	3841	#endif
	3842
3239	3843	#ifndef PERL_QUAD_MIN
3240	3844	# define PERL_QUAD_MIN IV_MIN
3241	3845	#endif

3255	3859	#else
3256	3860	#ifndef IVTYPE
3257	3861	# define IVTYPE long
	3862	#endif
	3863
	3864	#ifndef LONGSIZE
	3865	# define LONGSIZE 4
3258	3866	#endif
3259	3867
3260	3868	#ifndef IV_MIN

3328	3936	#ifndef sv_uv
3329	3937	# define sv_uv(sv) SvUVx(sv)
3330	3938	#endif
	3939
	3940	#if !defined(SvUOK) && defined(SvIOK_UV)
	3941	# define SvUOK(sv) SvIOK_UV(sv)
	3942	#endif
3331	3943	#ifndef XST_mUV
3332	3944	# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
3333	3945	#endif

3362	3974	#endif
3363	3975
3364	3976	#endif
	3977	#ifndef memEQs
	3978	# define memEQs(s1, l, s2) \
	3979	(sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1)))
	3980	#endif
	3981
	3982	#ifndef memNEs
	3983	# define memNEs(s1, l, s2) !memEQs(s1, l, s2)
	3984	#endif
3365	3985	#ifndef MoveD
3366	3986	# define MoveD(s,d,n,t) memmove((char)(d),(char)(s), (n) * sizeof(t))
3367	3987	#endif

3406	4026
3407	4027	#ifndef Newxz
3408	4028	# define Newxz(v,n,t) Newz(0,v,n,t)
3409		#endif
3410
3411		#if ((PERL_VERSION < 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
3412		/* Replace: 1 */
3413		# define PL_DBsingle DBsingle
3414		# define PL_DBsub DBsub
3415		# define PL_Sv Sv
3416		# define PL_compiling compiling
3417		# define PL_copline copline
3418		# define PL_curcop curcop
3419		# define PL_curstash curstash
3420		# define PL_debstash debstash
3421		# define PL_defgv defgv
3422		# define PL_diehook diehook
3423		# define PL_dirty dirty
3424		# define PL_dowarn dowarn
3425		# define PL_errgv errgv
3426		# define PL_hexdigit hexdigit
3427		# define PL_hints hints
3428		# define PL_na na
3429		# define PL_no_modify no_modify
3430		# define PL_perl_destruct_level perl_destruct_level
3431		# define PL_perldb perldb
3432		# define PL_ppaddr ppaddr
3433		# define PL_rsfp_filters rsfp_filters
3434		# define PL_rsfp rsfp
3435		# define PL_stack_base stack_base
3436		# define PL_stack_sp stack_sp
3437		# define PL_stdingv stdingv
3438		# define PL_sv_arenaroot sv_arenaroot
3439		# define PL_sv_no sv_no
3440		# define PL_sv_undef sv_undef
3441		# define PL_sv_yes sv_yes
3442		# define PL_tainted tainted
3443		# define PL_tainting tainting
3444		/* Replace: 0 */
3445	4029	#endif
3446	4030
3447	4031	#ifndef PERL_UNUSED_DECL

3494	4078	#endif
3495	4079
3496	4080	#ifndef INT2PTR
3497
3498	4081	# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
3499	4082	# define PTRV UV
3500	4083	# define INT2PTR(any,d) (any)(d)

3506	4089	# endif
3507	4090	# define INT2PTR(any,d) (any)(PTRV)(d)
3508	4091	# endif
3509
3510		# define NUM2PTR(any,d) (any)(PTRV)(d)
3511		# define PTR2IV(p) INT2PTR(IV,p)
3512		# define PTR2UV(p) INT2PTR(UV,p)
3513		# define PTR2NV(p) NUM2PTR(NV,p)
3514
	4092	#endif
	4093
	4094	#ifndef PTR2ul
3515	4095	# if PTRSIZE == LONGSIZE
3516	4096	# define PTR2ul(p) (unsigned long)(p)
3517	4097	# else
3518	4098	# define PTR2ul(p) INT2PTR(unsigned long,p)
3519	4099	# endif
3520
3521		#endif /* !INT2PTR */
	4100	#endif
	4101	#ifndef PTR2nat
	4102	# define PTR2nat(p) (PTRV)(p)
	4103	#endif
	4104
	4105	#ifndef NUM2PTR
	4106	# define NUM2PTR(any,d) (any)PTR2nat(d)
	4107	#endif
	4108
	4109	#ifndef PTR2IV
	4110	# define PTR2IV(p) INT2PTR(IV,p)
	4111	#endif
	4112
	4113	#ifndef PTR2UV
	4114	# define PTR2UV(p) INT2PTR(UV,p)
	4115	#endif
	4116
	4117	#ifndef PTR2NV
	4118	# define PTR2NV(p) NUM2PTR(NV,p)
	4119	#endif
3522	4120
3523	4121	#undef START_EXTERN_C
3524	4122	#undef END_EXTERN_C

3548	4146	#undef STMT_START
3549	4147	#undef STMT_END
3550	4148	#ifdef PERL_USE_GCC_BRACE_GROUPS
3551		# define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */
3552		# define STMT_END )
	4149	# define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */
	4150	# define STMT_END )
3553	4151	#else
3554	4152	# if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) \|\| defined(__sun__)) && !defined(__GNUC__)
3555		# define STMT_START if (1)
3556		# define STMT_END else (void)0
	4153	# define STMT_START if (1)
	4154	# define STMT_END else (void)0
3557	4155	# else
3558		# define STMT_START do
3559		# define STMT_END while (0)
	4156	# define STMT_START do
	4157	# define STMT_END while (0)
3560	4158	# endif
3561	4159	#endif
3562	4160	#ifndef boolSV

3572	4170	# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv))
3573	4171	#endif
3574	4172
	4173	#ifndef DEFSV_set
	4174	# define DEFSV_set(sv) (DEFSV = (sv))
	4175	#endif
	4176
3575	4177	/* Older perls (<=5.003) lack AvFILLp */
3576	4178	#ifndef AvFILLp
3577	4179	# define AvFILLp AvFILL
3578	4180	#endif
3579	4181	#ifndef ERRSV
3580	4182	# define ERRSV get_sv("@",FALSE)
3581		#endif
3582		#ifndef newSVpvn
3583		# define newSVpvn(data,len) ((data) \
3584		? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
3585		: newSV(0))
3586	4183	#endif
3587	4184
3588	4185	/* Hint: gv_stashpvn

3638	4235	# define XSprePUSH (sp = PL_stack_base + ax - 1)
3639	4236	#endif
3640	4237
3641		#if ((PERL_VERSION < 5) \|\| ((PERL_VERSION == 5) && (PERL_SUBVERSION < 0)))
	4238	#if (PERL_BCDVERSION < 0x5005000)
3642	4239	# undef XSRETURN
3643	4240	# define XSRETURN(off) \
3644	4241	STMT_START { \

3646	4243	return; \
3647	4244	} STMT_END
3648	4245	#endif
	4246	#ifndef XSPROTO
	4247	# define XSPROTO(name) void name(pTHX_ CV* cv)
	4248	#endif
	4249
	4250	#ifndef SVfARG
	4251	# define SVfARG(p) ((void*)(p))
	4252	#endif
3649	4253	#ifndef PERL_ABS
3650	4254	# define PERL_ABS(x) ((x) < 0 ? -(x) : (x))
3651	4255	#endif

3655	4259	#ifndef SVf
3656	4260	# define SVf "_"
3657	4261	#endif
	4262	#ifndef UTF8_MAXBYTES
	4263	# define UTF8_MAXBYTES UTF8_MAXLEN
	4264	#endif
	4265	#ifndef CPERLscope
	4266	# define CPERLscope(x) x
	4267	#endif
	4268	#ifndef PERL_HASH
	4269	# define PERL_HASH(hash,str,len) \
	4270	STMT_START { \
	4271	const char *s_PeRlHaSh = str; \
	4272	I32 i_PeRlHaSh = len; \
	4273	U32 hash_PeRlHaSh = 0; \
	4274	while (i_PeRlHaSh--) \
	4275	hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \
	4276	(hash) = hash_PeRlHaSh; \
	4277	} STMT_END
	4278	#endif
	4279
	4280	#ifndef PERLIO_FUNCS_DECL
	4281	# ifdef PERLIO_FUNCS_CONST
	4282	# define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
	4283	# define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
	4284	# else
	4285	# define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs
	4286	# define PERLIO_FUNCS_CAST(funcs) (funcs)
	4287	# endif
	4288	#endif
	4289
	4290	/* provide these typedefs for older perls */
	4291	#if (PERL_BCDVERSION < 0x5009003)
	4292
	4293	# ifdef ARGSproto
	4294	typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto);
	4295	# else
	4296	typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX);
	4297	# endif
	4298
	4299	typedef OP* (CPERLscope(Perl_check_t)) (pTHX_ OP);
	4300
	4301	#endif
	4302	#ifndef isPSXSPC
	4303	# define isPSXSPC(c) (isSPACE(c) \|\| (c) == '\v')
	4304	#endif
	4305
	4306	#ifndef isBLANK
	4307	# define isBLANK(c) ((c) == ' ' \|\| (c) == '\t')
	4308	#endif
	4309
	4310	#ifdef EBCDIC
	4311	#ifndef isALNUMC
	4312	# define isALNUMC(c) isalnum(c)
	4313	#endif
	4314
	4315	#ifndef isASCII
	4316	# define isASCII(c) isascii(c)
	4317	#endif
	4318
	4319	#ifndef isCNTRL
	4320	# define isCNTRL(c) iscntrl(c)
	4321	#endif
	4322
	4323	#ifndef isGRAPH
	4324	# define isGRAPH(c) isgraph(c)
	4325	#endif
	4326
	4327	#ifndef isPRINT
	4328	# define isPRINT(c) isprint(c)
	4329	#endif
	4330
	4331	#ifndef isPUNCT
	4332	# define isPUNCT(c) ispunct(c)
	4333	#endif
	4334
	4335	#ifndef isXDIGIT
	4336	# define isXDIGIT(c) isxdigit(c)
	4337	#endif
	4338
	4339	#else
	4340	# if (PERL_BCDVERSION < 0x5010000)
	4341	/* Hint: isPRINT
	4342	* The implementation in older perl versions includes all of the
	4343	* isSPACE() characters, which is wrong. The version provided by
	4344	* Devel::PPPort always overrides a present buggy version.
	4345	*/
	4346	# undef isPRINT
	4347	# endif
	4348	#ifndef isALNUMC
	4349	# define isALNUMC(c) (isALPHA(c) \|\| isDIGIT(c))
	4350	#endif
	4351
	4352	#ifndef isASCII
	4353	# define isASCII(c) ((U8) (c) <= 127)
	4354	#endif
	4355
	4356	#ifndef isCNTRL
	4357	# define isCNTRL(c) ((U8) (c) < ' ' \|\| (c) == 127)
	4358	#endif
	4359
	4360	#ifndef isGRAPH
	4361	# define isGRAPH(c) (isALNUM(c) \|\| isPUNCT(c))
	4362	#endif
	4363
	4364	#ifndef isPRINT
	4365	# define isPRINT(c) (((c) >= 32 && (c) < 127))
	4366	#endif
	4367
	4368	#ifndef isPUNCT
	4369	# define isPUNCT(c) (((c) >= 33 && (c) <= 47) \|\| ((c) >= 58 && (c) <= 64) \|\| ((c) >= 91 && (c) <= 96) \|\| ((c) >= 123 && (c) <= 126))
	4370	#endif
	4371
	4372	#ifndef isXDIGIT
	4373	# define isXDIGIT(c) (isDIGIT(c) \|\| ((c) >= 'a' && (c) <= 'f') \|\| ((c) >= 'A' && (c) <= 'F'))
	4374	#endif
	4375
	4376	#endif
3658	4377
3659	4378	#ifndef PERL_SIGNALS_UNSAFE_FLAG
3660	4379
3661	4380	#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
3662	4381
	4382	#if (PERL_BCDVERSION < 0x5008000)
	4383	# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG
	4384	#else
	4385	# define D_PPP_PERL_SIGNALS_INIT 0
	4386	#endif
	4387
3663	4388	#if defined(NEED_PL_signals)
3664		static U32 DPPP_(my_PL_signals) = PERL_SIGNALS_UNSAFE_FLAG;
	4389	static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3665	4390	#elif defined(NEED_PL_signals_GLOBAL)
3666		U32 DPPP_(my_PL_signals) = PERL_SIGNALS_UNSAFE_FLAG;
	4391	U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT;
3667	4392	#else
3668	4393	extern U32 DPPP_(my_PL_signals);
3669	4394	#endif
3670	4395	#define PL_signals DPPP_(my_PL_signals)
3671	4396
3672	4397	#endif
3673		#ifndef dTHR
3674		# define dTHR dNOOP
3675		#endif
3676		#ifndef dTHX
3677		# define dTHX dNOOP
3678		#endif
3679
3680		#ifndef dTHXa
3681		# define dTHXa(x) dNOOP
3682		#endif
3683		#ifndef pTHX
3684		# define pTHX void
3685		#endif
3686
3687		#ifndef pTHX_
3688		# define pTHX_
3689		#endif
3690
3691		#ifndef aTHX
3692		# define aTHX
3693		#endif
3694
3695		#ifndef aTHX_
3696		# define aTHX_
3697		#endif
3698		#ifndef dTHXoa
3699		# define dTHXoa(x) dTHXa(x)
3700		#endif
	4398
	4399	/* Hint: PL_ppaddr
	4400	* Calling an op via PL_ppaddr requires passing a context argument
	4401	* for threaded builds. Since the context argument is different for
	4402	* 5.005 perls, you can use aTHXR (supplied by ppport.h), which will
	4403	* automatically be defined as the correct argument.
	4404	*/
	4405
	4406	#if (PERL_BCDVERSION <= 0x5005005)
	4407	/* Replace: 1 */
	4408	# define PL_ppaddr ppaddr
	4409	# define PL_no_modify no_modify
	4410	/* Replace: 0 */
	4411	#endif
	4412
	4413	#if (PERL_BCDVERSION <= 0x5004005)
	4414	/* Replace: 1 */
	4415	# define PL_DBsignal DBsignal
	4416	# define PL_DBsingle DBsingle
	4417	# define PL_DBsub DBsub
	4418	# define PL_DBtrace DBtrace
	4419	# define PL_Sv Sv
	4420	# define PL_bufend bufend
	4421	# define PL_bufptr bufptr
	4422	# define PL_compiling compiling
	4423	# define PL_copline copline
	4424	# define PL_curcop curcop
	4425	# define PL_curstash curstash
	4426	# define PL_debstash debstash
	4427	# define PL_defgv defgv
	4428	# define PL_diehook diehook
	4429	# define PL_dirty dirty
	4430	# define PL_dowarn dowarn
	4431	# define PL_errgv errgv
	4432	# define PL_error_count error_count
	4433	# define PL_expect expect
	4434	# define PL_hexdigit hexdigit
	4435	# define PL_hints hints
	4436	# define PL_in_my in_my
	4437	# define PL_laststatval laststatval
	4438	# define PL_lex_state lex_state
	4439	# define PL_lex_stuff lex_stuff
	4440	# define PL_linestr linestr
	4441	# define PL_na na
	4442	# define PL_perl_destruct_level perl_destruct_level
	4443	# define PL_perldb perldb
	4444	# define PL_rsfp_filters rsfp_filters
	4445	# define PL_rsfp rsfp
	4446	# define PL_stack_base stack_base
	4447	# define PL_stack_sp stack_sp
	4448	# define PL_statcache statcache
	4449	# define PL_stdingv stdingv
	4450	# define PL_sv_arenaroot sv_arenaroot
	4451	# define PL_sv_no sv_no
	4452	# define PL_sv_undef sv_undef
	4453	# define PL_sv_yes sv_yes
	4454	# define PL_tainted tainted
	4455	# define PL_tainting tainting
	4456	# define PL_tokenbuf tokenbuf
	4457	/* Replace: 0 */
	4458	#endif
	4459
	4460	/* Warning: PL_parser
	4461	* For perl versions earlier than 5.9.5, this is an always
	4462	* non-NULL dummy. Also, it cannot be dereferenced. Don't
	4463	* use it if you can avoid is and unless you absolutely know
	4464	* what you're doing.
	4465	* If you always check that PL_parser is non-NULL, you can
	4466	* define DPPP_PL_parser_NO_DUMMY to avoid the creation of
	4467	* a dummy parser structure.
	4468	*/
	4469
	4470	#if (PERL_BCDVERSION >= 0x5009005)
	4471	# ifdef DPPP_PL_parser_NO_DUMMY
	4472	# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
	4473	(croak("panic: PL_parser == NULL in %s:%d", \
	4474	__FILE__, __LINE__), (yy_parser *) NULL))->var)
	4475	# else
	4476	# ifdef DPPP_PL_parser_NO_DUMMY_WARNING
	4477	# define D_PPP_parser_dummy_warning(var)
	4478	# else
	4479	# define D_PPP_parser_dummy_warning(var) \
	4480	warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__),
	4481	# endif
	4482	# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \
	4483	(D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var)
	4484	#if defined(NEED_PL_parser)
	4485	static yy_parser DPPP_(dummy_PL_parser);
	4486	#elif defined(NEED_PL_parser_GLOBAL)
	4487	yy_parser DPPP_(dummy_PL_parser);
	4488	#else
	4489	extern yy_parser DPPP_(dummy_PL_parser);
	4490	#endif
	4491
	4492	# endif
	4493
	4494	/* PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf depends on PL_parser */
	4495	/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf
	4496	* Do not use this variable unless you know exactly what you're
	4497	* doint. It is internal to the perl parser and may change or even
	4498	* be removed in the future. As of perl 5.9.5, you have to check
	4499	* for (PL_parser != NULL) for this variable to have any effect.
	4500	* An always non-NULL PL_parser dummy is provided for earlier
	4501	* perl versions.
	4502	* If PL_parser is NULL when you try to access this variable, a
	4503	* dummy is being accessed instead and a warning is issued unless
	4504	* you define DPPP_PL_parser_NO_DUMMY_WARNING.
	4505	* If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access
	4506	* this variable will croak with a panic message.
	4507	*/
	4508
	4509	# define PL_expect D_PPP_my_PL_parser_var(expect)
	4510	# define PL_copline D_PPP_my_PL_parser_var(copline)
	4511	# define PL_rsfp D_PPP_my_PL_parser_var(rsfp)
	4512	# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters)
	4513	# define PL_linestr D_PPP_my_PL_parser_var(linestr)
	4514	# define PL_bufptr D_PPP_my_PL_parser_var(bufptr)
	4515	# define PL_bufend D_PPP_my_PL_parser_var(bufend)
	4516	# define PL_lex_state D_PPP_my_PL_parser_var(lex_state)
	4517	# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff)
	4518	# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf)
	4519	# define PL_in_my D_PPP_my_PL_parser_var(in_my)
	4520	# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash)
	4521	# define PL_error_count D_PPP_my_PL_parser_var(error_count)
	4522
	4523
	4524	#else
	4525
	4526	/* ensure that PL_parser != NULL and cannot be dereferenced */
	4527	# define PL_parser ((void *) 1)
	4528
	4529	#endif
	4530	#ifndef mPUSHs
	4531	# define mPUSHs(s) PUSHs(sv_2mortal(s))
	4532	#endif
	4533
3701	4534	#ifndef PUSHmortal
3702	4535	# define PUSHmortal PUSHs(sv_newmortal())
3703	4536	#endif
3704	4537
3705	4538	#ifndef mPUSHp
3706		# define mPUSHp(p,l) sv_setpvn_mg(PUSHmortal, (p), (l))
	4539	# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l))
3707	4540	#endif
3708	4541
3709	4542	#ifndef mPUSHn
3710		# define mPUSHn(n) sv_setnv_mg(PUSHmortal, (NV)(n))
	4543	# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n))
3711	4544	#endif
3712	4545
3713	4546	#ifndef mPUSHi
3714		# define mPUSHi(i) sv_setiv_mg(PUSHmortal, (IV)(i))
	4547	# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i))
3715	4548	#endif
3716	4549
3717	4550	#ifndef mPUSHu
3718		# define mPUSHu(u) sv_setuv_mg(PUSHmortal, (UV)(u))
3719		#endif
	4551	# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u))
	4552	#endif
	4553	#ifndef mXPUSHs
	4554	# define mXPUSHs(s) XPUSHs(sv_2mortal(s))
	4555	#endif
	4556
3720	4557	#ifndef XPUSHmortal
3721	4558	# define XPUSHmortal XPUSHs(sv_newmortal())
3722	4559	#endif
3723	4560
3724	4561	#ifndef mXPUSHp
3725		# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END
	4562	# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END
3726	4563	#endif
3727	4564
3728	4565	#ifndef mXPUSHn
3729		# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END
	4566	# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END
3730	4567	#endif
3731	4568
3732	4569	#ifndef mXPUSHi
3733		# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END
	4570	# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END
3734	4571	#endif
3735	4572
3736	4573	#ifndef mXPUSHu
3737		# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END
	4574	# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END
3738	4575	#endif
3739	4576
3740	4577	/* Replace: 1 */

3758	4595	#endif
3759	4596
3760	4597	/* Replace: 0 */
	4598	#ifndef PERL_LOADMOD_DENY
	4599	# define PERL_LOADMOD_DENY 0x1
	4600	#endif
	4601
	4602	#ifndef PERL_LOADMOD_NOIMPORT
	4603	# define PERL_LOADMOD_NOIMPORT 0x2
	4604	#endif
	4605
	4606	#ifndef PERL_LOADMOD_IMPORT_OPS
	4607	# define PERL_LOADMOD_IMPORT_OPS 0x4
	4608	#endif
	4609
	4610	#ifndef G_METHOD
	4611	# define G_METHOD 64
	4612	# ifdef call_sv
	4613	# undef call_sv
	4614	# endif
	4615	# if (PERL_BCDVERSION < 0x5006000)
	4616	# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \
	4617	(flags) & ~G_METHOD) : perl_call_sv(sv, flags))
	4618	# else
	4619	# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \
	4620	(flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags))
	4621	# endif
	4622	#endif
3761	4623
3762	4624	/* Replace perl_eval_pv with eval_pv */
3763		/* eval_pv depends on eval_sv */
3764	4625
3765	4626	#ifndef eval_pv
3766	4627	#if defined(NEED_eval_pv)

3793	4654	PUTBACK;
3794	4655
3795	4656	if (croak_on_error && SvTRUE(GvSV(errgv)))
3796		croak(SvPVx(GvSV(errgv), na));
	4657	croak(SvPVx(GvSV(errgv), na));
3797	4658
3798	4659	return sv;
	4660	}
	4661
	4662	#endif
	4663	#endif
	4664
	4665	#ifndef vload_module
	4666	#if defined(NEED_vload_module)
	4667	static void DPPP_(my_vload_module)(U32 flags, SV name, SV ver, va_list *args);
	4668	static
	4669	#else
	4670	extern void DPPP_(my_vload_module)(U32 flags, SV name, SV ver, va_list *args);
	4671	#endif
	4672
	4673	#ifdef vload_module
	4674	# undef vload_module
	4675	#endif
	4676	#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
	4677	#define Perl_vload_module DPPP_(my_vload_module)
	4678
	4679	#if defined(NEED_vload_module) \|\| defined(NEED_vload_module_GLOBAL)
	4680
	4681	void
	4682	DPPP_(my_vload_module)(U32 flags, SV name, SV ver, va_list *args)
	4683	{
	4684	dTHR;
	4685	dVAR;
	4686	OP veop, imop;
	4687
	4688	OP * const modname = newSVOP(OP_CONST, 0, name);
	4689	/* 5.005 has a somewhat hacky force_normal that doesn't croak on
	4690	SvREADONLY() if PL_compling is true. Current perls take care in
	4691	ck_require() to correctly turn off SvREADONLY before calling
	4692	force_normal_flags(). This seems a better fix than fudging PL_compling
	4693	*/
	4694	SvREADONLY_off(((SVOP*)modname)->op_sv);
	4695	modname->op_private \|= OPpCONST_BARE;
	4696	if (ver) {
	4697	veop = newSVOP(OP_CONST, 0, ver);
	4698	}
	4699	else
	4700	veop = NULL;
	4701	if (flags & PERL_LOADMOD_NOIMPORT) {
	4702	imop = sawparens(newNULLLIST());
	4703	}
	4704	else if (flags & PERL_LOADMOD_IMPORT_OPS) {
	4705	imop = va_arg(args, OP);
	4706	}
	4707	else {
	4708	SV *sv;
	4709	imop = NULL;
	4710	sv = va_arg(args, SV);
	4711	while (sv) {
	4712	imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
	4713	sv = va_arg(args, SV);
	4714	}
	4715	}
	4716	{
	4717	const line_t ocopline = PL_copline;
	4718	COP * const ocurcop = PL_curcop;
	4719	const int oexpect = PL_expect;
	4720
	4721	#if (PERL_BCDVERSION >= 0x5004000)
	4722	utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
	4723	veop, modname, imop);
	4724	#else
	4725	utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(),
	4726	modname, imop);
	4727	#endif
	4728	PL_expect = oexpect;
	4729	PL_copline = ocopline;
	4730	PL_curcop = ocurcop;
	4731	}
	4732	}
	4733
	4734	#endif
	4735	#endif
	4736
	4737	#ifndef load_module
	4738	#if defined(NEED_load_module)
	4739	static void DPPP_(my_load_module)(U32 flags, SV name, SV ver, ...);
	4740	static
	4741	#else
	4742	extern void DPPP_(my_load_module)(U32 flags, SV name, SV ver, ...);
	4743	#endif
	4744
	4745	#ifdef load_module
	4746	# undef load_module
	4747	#endif
	4748	#define load_module DPPP_(my_load_module)
	4749	#define Perl_load_module DPPP_(my_load_module)
	4750
	4751	#if defined(NEED_load_module) \|\| defined(NEED_load_module_GLOBAL)
	4752
	4753	void
	4754	DPPP_(my_load_module)(U32 flags, SV name, SV ver, ...)
	4755	{
	4756	va_list args;
	4757	va_start(args, ver);
	4758	vload_module(flags, name, ver, &args);
	4759	va_end(args);
3799	4760	}
3800	4761
3801	4762	#endif

3835	4796	*/
3836	4797
3837	4798	/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */
3838		#if ((PERL_VERSION < 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION < 63))) && ((PERL_VERSION != 4) \|\| (PERL_SUBVERSION != 5))
	4799	#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005)
3839	4800	#if defined(NEED_newCONSTSUB)
3840		static void DPPP_(my_newCONSTSUB)(HV stash, char name, SV *sv);
	4801	static void DPPP_(my_newCONSTSUB)(HV stash, const char name, SV *sv);
3841	4802	static
3842	4803	#else
3843		extern void DPPP_(my_newCONSTSUB)(HV stash, char name, SV *sv);
	4804	extern void DPPP_(my_newCONSTSUB)(HV stash, const char name, SV *sv);
3844	4805	#endif
3845	4806
3846	4807	#ifdef newCONSTSUB

3851	4812
3852	4813	#if defined(NEED_newCONSTSUB) \|\| defined(NEED_newCONSTSUB_GLOBAL)
3853	4814
	4815	/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */
	4816	/* (There's no PL_parser in perl < 5.005, so this is completely safe) */
	4817	#define D_PPP_PL_copline PL_copline
	4818
3854	4819	void
3855		DPPP_(my_newCONSTSUB)(HV stash, char name, SV *sv)
	4820	DPPP_(my_newCONSTSUB)(HV stash, const char name, SV *sv)
3856	4821	{
3857		U32 oldhints = PL_hints;
3858		HV *old_cop_stash = PL_curcop->cop_stash;
3859		HV *old_curstash = PL_curstash;
3860		line_t oldline = PL_curcop->cop_line;
3861		PL_curcop->cop_line = PL_copline;
3862
3863		PL_hints &= ~HINT_BLOCK_SCOPE;
3864		if (stash)
3865		PL_curstash = PL_curcop->cop_stash = stash;
3866
3867		newSUB(
3868
3869		#if ((PERL_VERSION < 3) \|\| ((PERL_VERSION == 3) && (PERL_SUBVERSION < 22)))
3870		start_subparse(),
3871		#elif ((PERL_VERSION == 3) && (PERL_SUBVERSION == 22))
3872		start_subparse(0),
	4822	U32 oldhints = PL_hints;
	4823	HV *old_cop_stash = PL_curcop->cop_stash;
	4824	HV *old_curstash = PL_curstash;
	4825	line_t oldline = PL_curcop->cop_line;
	4826	PL_curcop->cop_line = D_PPP_PL_copline;
	4827
	4828	PL_hints &= ~HINT_BLOCK_SCOPE;
	4829	if (stash)
	4830	PL_curstash = PL_curcop->cop_stash = stash;
	4831
	4832	newSUB(
	4833
	4834	#if (PERL_BCDVERSION < 0x5003022)
	4835	start_subparse(),
	4836	#elif (PERL_BCDVERSION == 0x5003022)
	4837	start_subparse(0),
3873	4838	#else /* 5.003_23 onwards */
3874		start_subparse(FALSE, 0),
3875		#endif
3876
3877		newSVOP(OP_CONST, 0, newSVpv(name,0)),
3878		newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
3879		newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
3880		);
3881
3882		PL_hints = oldhints;
3883		PL_curcop->cop_stash = old_cop_stash;
3884		PL_curstash = old_curstash;
3885		PL_curcop->cop_line = oldline;
	4839	start_subparse(FALSE, 0),
	4840	#endif
	4841
	4842	newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)),
	4843	newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */
	4844	newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
	4845	);
	4846
	4847	PL_hints = oldhints;
	4848	PL_curcop->cop_stash = old_cop_stash;
	4849	PL_curstash = old_curstash;
	4850	PL_curcop->cop_line = oldline;
3886	4851	}
3887	4852	#endif
3888	4853	#endif

3916	4881	* case below uses it to declare the data as static. */
3917	4882	#define START_MY_CXT
3918	4883
3919		#if ((PERL_VERSION < 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION < 68)))
	4884	#if (PERL_BCDVERSION < 0x5004068)
3920	4885	/* Fetches the SV that keeps the per-interpreter data. */
3921	4886	#define dMY_CXT_SV \
3922		SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
	4887	SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE)
3923	4888	#else /* >= perl5.004_68 */
3924	4889	#define dMY_CXT_SV \
3925		SV my_cxt_sv = hv_fetch(PL_modglobal, MY_CXT_KEY, \
3926		sizeof(MY_CXT_KEY)-1, TRUE)
	4890	SV my_cxt_sv = hv_fetch(PL_modglobal, MY_CXT_KEY, \
	4891	sizeof(MY_CXT_KEY)-1, TRUE)
3927	4892	#endif /* < perl5.004_68 */
3928	4893
3929	4894	/* This declaration should be used within all functions that use the
3930	4895	* interpreter-local data. */
3931		#define dMY_CXT \
3932		dMY_CXT_SV; \
3933		my_cxt_t my_cxtp = INT2PTR(my_cxt_t,SvUV(my_cxt_sv))
	4896	#define dMY_CXT \
	4897	dMY_CXT_SV; \
	4898	my_cxt_t my_cxtp = INT2PTR(my_cxt_t,SvUV(my_cxt_sv))
3934	4899
3935	4900	/* Creates and zeroes the per-interpreter data.
3936	4901	* (We allocate my_cxtp in a Perl SV so that it will be released when
3937	4902	* the interpreter goes away.) */
3938	4903	#define MY_CXT_INIT \
3939		dMY_CXT_SV; \
3940		/* newSV() allocates one more than needed */ \
3941		my_cxt_t my_cxtp = (my_cxt_t)SvPVX(newSV(sizeof(my_cxt_t)-1));\
3942		Zero(my_cxtp, 1, my_cxt_t); \
3943		sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
	4904	dMY_CXT_SV; \
	4905	/* newSV() allocates one more than needed */ \
	4906	my_cxt_t my_cxtp = (my_cxt_t)SvPVX(newSV(sizeof(my_cxt_t)-1));\
	4907	Zero(my_cxtp, 1, my_cxt_t); \
	4908	sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
3944	4909
3945	4910	/* This macro must be used to access members of the my_cxt_t structure.
3946	4911	* e.g. MYCXT.some_data */
3947		#define MY_CXT (*my_cxtp)
	4912	#define MY_CXT (*my_cxtp)
3948	4913
3949	4914	/* Judicious use of these macros can reduce the number of times dMY_CXT
3950	4915	* is used. Use is similar to pTHX, aTHX etc. */
3951		#define pMY_CXT my_cxt_t *my_cxtp
3952		#define pMY_CXT_ pMY_CXT,
3953		#define _pMY_CXT ,pMY_CXT
3954		#define aMY_CXT my_cxtp
3955		#define aMY_CXT_ aMY_CXT,
3956		#define _aMY_CXT ,aMY_CXT
	4916	#define pMY_CXT my_cxt_t *my_cxtp
	4917	#define pMY_CXT_ pMY_CXT,
	4918	#define _pMY_CXT ,pMY_CXT
	4919	#define aMY_CXT my_cxtp
	4920	#define aMY_CXT_ aMY_CXT,
	4921	#define _aMY_CXT ,aMY_CXT
3957	4922
3958	4923	#endif /* START_MY_CXT */
3959	4924
3960	4925	#ifndef MY_CXT_CLONE
3961	4926	/* Clones the per-interpreter data. */
3962	4927	#define MY_CXT_CLONE \
3963		dMY_CXT_SV; \
3964		my_cxt_t my_cxtp = (my_cxt_t)SvPVX(newSV(sizeof(my_cxt_t)-1));\
3965		Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
3966		sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
	4928	dMY_CXT_SV; \
	4929	my_cxt_t my_cxtp = (my_cxt_t)SvPVX(newSV(sizeof(my_cxt_t)-1));\
	4930	Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\
	4931	sv_setuv(my_cxt_sv, PTR2UV(my_cxtp))
3967	4932	#endif
3968	4933
3969	4934	#else /* single interpreter */
3970	4935
3971	4936	#ifndef START_MY_CXT
3972	4937
3973		#define START_MY_CXT static my_cxt_t my_cxt;
3974		#define dMY_CXT_SV dNOOP
3975		#define dMY_CXT dNOOP
3976		#define MY_CXT_INIT NOOP
3977		#define MY_CXT my_cxt
3978
3979		#define pMY_CXT void
	4938	#define START_MY_CXT static my_cxt_t my_cxt;
	4939	#define dMY_CXT_SV dNOOP
	4940	#define dMY_CXT dNOOP
	4941	#define MY_CXT_INIT NOOP
	4942	#define MY_CXT my_cxt
	4943
	4944	#define pMY_CXT void
3980	4945	#define pMY_CXT_
3981	4946	#define _pMY_CXT
3982	4947	#define aMY_CXT

3986	4951	#endif /* START_MY_CXT */
3987	4952
3988	4953	#ifndef MY_CXT_CLONE
3989		#define MY_CXT_CLONE NOOP
	4954	#define MY_CXT_CLONE NOOP
3990	4955	#endif
3991	4956
3992	4957	#endif
3993	4958
3994	4959	#ifndef IVdf
3995	4960	# if IVSIZE == LONGSIZE
3996		# define IVdf "ld"
3997		# define UVuf "lu"
3998		# define UVof "lo"
3999		# define UVxf "lx"
4000		# define UVXf "lX"
	4961	# define IVdf "ld"
	4962	# define UVuf "lu"
	4963	# define UVof "lo"
	4964	# define UVxf "lx"
	4965	# define UVXf "lX"
	4966	# elif IVSIZE == INTSIZE
	4967	# define IVdf "d"
	4968	# define UVuf "u"
	4969	# define UVof "o"
	4970	# define UVxf "x"
	4971	# define UVXf "X"
4001	4972	# else
4002		# if IVSIZE == INTSIZE
4003		# define IVdf "d"
4004		# define UVuf "u"
4005		# define UVof "o"
4006		# define UVxf "x"
4007		# define UVXf "X"
4008		# endif
	4973	# error "cannot define IV/UV formats"
4009	4974	# endif
4010	4975	#endif
4011	4976
4012	4977	#ifndef NVef
4013	4978	# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \
4014		defined(PERL_PRIfldbl) /* Not very likely, but let's try anyway. */
	4979	defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000)
	4980	/* Not very likely, but let's try anyway. */
4015	4981	# define NVef PERL_PRIeldbl
4016	4982	# define NVff PERL_PRIfldbl
4017	4983	# define NVgf PERL_PRIgldbl

4024	4990
4025	4991	#ifndef SvREFCNT_inc
4026	4992	# ifdef PERL_USE_GCC_BRACE_GROUPS
4027		# define SvREFCNT_inc(sv) \
4028		({ \
4029		SV * const _sv = (SV*)(sv); \
4030		if (_sv) \
4031		(SvREFCNT(_sv))++; \
4032		_sv; \
	4993	# define SvREFCNT_inc(sv) \
	4994	({ \
	4995	SV * const _sv = (SV*)(sv); \
	4996	if (_sv) \
	4997	(SvREFCNT(_sv))++; \
	4998	_sv; \
4033	4999	})
4034	5000	# else
4035		# define SvREFCNT_inc(sv) \
	5001	# define SvREFCNT_inc(sv) \
4036	5002	((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL)
4037	5003	# endif
4038	5004	#endif
4039	5005
4040	5006	#ifndef SvREFCNT_inc_simple
4041	5007	# ifdef PERL_USE_GCC_BRACE_GROUPS
4042		# define SvREFCNT_inc_simple(sv) \
4043		({ \
4044		if (sv) \
4045		(SvREFCNT(sv))++; \
4046		(SV *)(sv); \
	5008	# define SvREFCNT_inc_simple(sv) \
	5009	({ \
	5010	if (sv) \
	5011	(SvREFCNT(sv))++; \
	5012	(SV *)(sv); \
4047	5013	})
4048	5014	# else
4049	5015	# define SvREFCNT_inc_simple(sv) \

4053	5019
4054	5020	#ifndef SvREFCNT_inc_NN
4055	5021	# ifdef PERL_USE_GCC_BRACE_GROUPS
4056		# define SvREFCNT_inc_NN(sv) \
4057		({ \
4058		SV * const _sv = (SV*)(sv); \
4059		SvREFCNT(_sv)++; \
4060		_sv; \
	5022	# define SvREFCNT_inc_NN(sv) \
	5023	({ \
	5024	SV * const _sv = (SV*)(sv); \
	5025	SvREFCNT(_sv)++; \
	5026	_sv; \
4061	5027	})
4062	5028	# else
4063	5029	# define SvREFCNT_inc_NN(sv) \

4067	5033
4068	5034	#ifndef SvREFCNT_inc_void
4069	5035	# ifdef PERL_USE_GCC_BRACE_GROUPS
4070		# define SvREFCNT_inc_void(sv) \
4071		({ \
4072		SV * const _sv = (SV*)(sv); \
4073		if (_sv) \
4074		(void)(SvREFCNT(_sv)++); \
	5036	# define SvREFCNT_inc_void(sv) \
	5037	({ \
	5038	SV * const _sv = (SV*)(sv); \
	5039	if (_sv) \
	5040	(void)(SvREFCNT(_sv)++); \
4075	5041	})
4076	5042	# else
4077	5043	# define SvREFCNT_inc_void(sv) \

4094	5060	# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv)))
4095	5061	#endif
4096	5062
4097		#ifndef SvPV_nolen
4098
4099		#if defined(NEED_sv_2pv_nolen)
4100		static char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
	5063	#ifndef newSV_type
	5064
	5065	#if defined(NEED_newSV_type)
	5066	static SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
4101	5067	static
4102	5068	#else
4103		extern char * DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv);
4104		#endif
4105
4106		#ifdef sv_2pv_nolen
4107		# undef sv_2pv_nolen
4108		#endif
4109		#define sv_2pv_nolen(a) DPPP_(my_sv_2pv_nolen)(aTHX_ a)
4110		#define Perl_sv_2pv_nolen DPPP_(my_sv_2pv_nolen)
4111
4112		#if defined(NEED_sv_2pv_nolen) \|\| defined(NEED_sv_2pv_nolen_GLOBAL)
4113
4114		char *
4115		DPPP_(my_sv_2pv_nolen)(pTHX_ register SV *sv)
	5069	extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
	5070	#endif
	5071
	5072	#ifdef newSV_type
	5073	# undef newSV_type
	5074	#endif
	5075	#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)
	5076	#define Perl_newSV_type DPPP_(my_newSV_type)
	5077
	5078	#if defined(NEED_newSV_type) \|\| defined(NEED_newSV_type_GLOBAL)
	5079
	5080	SV*
	5081	DPPP_(my_newSV_type)(pTHX_ svtype const t)
4116	5082	{
4117		STRLEN n_a;
4118		return sv_2pv(sv, &n_a);
	5083	SV* const sv = newSV(0);
	5084	sv_upgrade(sv, t);
	5085	return sv;
4119	5086	}
4120	5087
4121	5088	#endif
4122	5089
	5090	#endif
	5091
	5092	#if (PERL_BCDVERSION < 0x5006000)
	5093	# define D_PPP_CONSTPV_ARG(x) ((char *) (x))
	5094	#else
	5095	# define D_PPP_CONSTPV_ARG(x) (x)
	5096	#endif
	5097	#ifndef newSVpvn
	5098	# define newSVpvn(data,len) ((data) \
	5099	? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \
	5100	: newSV(0))
	5101	#endif
	5102	#ifndef newSVpvn_utf8
	5103	# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
	5104	#endif
	5105	#ifndef SVf_UTF8
	5106	# define SVf_UTF8 0
	5107	#endif
	5108
	5109	#ifndef newSVpvn_flags
	5110
	5111	#if defined(NEED_newSVpvn_flags)
	5112	static SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
	5113	static
	5114	#else
	5115	extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
	5116	#endif
	5117
	5118	#ifdef newSVpvn_flags
	5119	# undef newSVpvn_flags
	5120	#endif
	5121	#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
	5122	#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
	5123
	5124	#if defined(NEED_newSVpvn_flags) \|\| defined(NEED_newSVpvn_flags_GLOBAL)
	5125
	5126	SV *
	5127	DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
	5128	{
	5129	SV *sv = newSVpvn(D_PPP_CONSTPV_ARG(s), len);
	5130	SvFLAGS(sv) \|= (flags & SVf_UTF8);
	5131	return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
	5132	}
	5133
	5134	#endif
	5135
	5136	#endif
	5137
	5138	/* Backwards compatibility stuff... :-( */
	5139	#if !defined(NEED_sv_2pv_flags) && defined(NEED_sv_2pv_nolen)
	5140	# define NEED_sv_2pv_flags
	5141	#endif
	5142	#if !defined(NEED_sv_2pv_flags_GLOBAL) && defined(NEED_sv_2pv_nolen_GLOBAL)
	5143	# define NEED_sv_2pv_flags_GLOBAL
	5144	#endif
	5145
4123	5146	/* Hint: sv_2pv_nolen
4124		* Use the SvPV_nolen() macro instead of sv_2pv_nolen().
	5147	* Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen().
4125	5148	*/
4126
4127		/* SvPV_nolen depends on sv_2pv_nolen */
4128		#define SvPV_nolen(sv) \
4129		((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
4130		? SvPVX(sv) : sv_2pv_nolen(sv))
4131
	5149	#ifndef sv_2pv_nolen
	5150	# define sv_2pv_nolen(sv) SvPV_nolen(sv)
4132	5151	#endif
4133	5152
4134	5153	#ifdef SvPVbyte

4138	5157	* borrowed from perl-5.7.3.
4139	5158	*/
4140	5159
4141		#if ((PERL_VERSION < 7) \|\| ((PERL_VERSION == 7) && (PERL_SUBVERSION < 0)))
	5160	#if (PERL_BCDVERSION < 0x5007000)
4142	5161
4143	5162	#if defined(NEED_sv_2pvbyte)
4144		static char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV sv, STRLEN lp);
	5163	static char * DPPP_(my_sv_2pvbyte)(pTHX_ SV sv, STRLEN lp);
4145	5164	static
4146	5165	#else
4147		extern char * DPPP_(my_sv_2pvbyte)(pTHX_ register SV sv, STRLEN lp);
	5166	extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV sv, STRLEN lp);
4148	5167	#endif
4149	5168
4150	5169	#ifdef sv_2pvbyte

4156	5175	#if defined(NEED_sv_2pvbyte) \|\| defined(NEED_sv_2pvbyte_GLOBAL)
4157	5176
4158	5177	char *
4159		DPPP_(my_sv_2pvbyte)(pTHX_ register SV sv, STRLEN lp)
	5178	DPPP_(my_sv_2pvbyte)(pTHX_ SV sv, STRLEN lp)
4160	5179	{
4161	5180	sv_utf8_downgrade(sv,0);
4162	5181	return SvPV(sv,*lp);

4170	5189
4171	5190	#undef SvPVbyte
4172	5191
4173		/* SvPVbyte depends on sv_2pvbyte */
4174	5192	#define SvPVbyte(sv, lp) \
4175	5193	((SvFLAGS(sv) & (SVf_POK\|SVf_UTF8)) == (SVf_POK) \
4176	5194	? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp))

4183	5201	# define sv_2pvbyte sv_2pv
4184	5202
4185	5203	#endif
4186
4187		/* sv_2pvbyte_nolen depends on sv_2pv_nolen */
4188	5204	#ifndef sv_2pvbyte_nolen
4189		# define sv_2pvbyte_nolen sv_2pv_nolen
	5205	# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv)
4190	5206	#endif
4191	5207
4192	5208	/* Hint: sv_pvn
4193	5209	* Always use the SvPV() macro instead of sv_pvn().
4194	5210	*/
4195		#ifndef sv_pvn
4196		# define sv_pvn(sv, len) SvPV(sv, len)
4197		#endif
4198	5211
4199	5212	/* Hint: sv_pvn_force
4200	5213	* Always use the SvPV_force() macro instead of sv_pvn_force().
4201	5214	*/
4202		#ifndef sv_pvn_force
4203		# define sv_pvn_force(sv, len) SvPV_force(sv, len)
	5215
	5216	/* If these are undefined, they're not handled by the core anyway */
	5217	#ifndef SV_IMMEDIATE_UNREF
	5218	# define SV_IMMEDIATE_UNREF 0
	5219	#endif
	5220
	5221	#ifndef SV_GMAGIC
	5222	# define SV_GMAGIC 0
	5223	#endif
	5224
	5225	#ifndef SV_COW_DROP_PV
	5226	# define SV_COW_DROP_PV 0
	5227	#endif
	5228
	5229	#ifndef SV_UTF8_NO_ENCODING
	5230	# define SV_UTF8_NO_ENCODING 0
	5231	#endif
	5232
	5233	#ifndef SV_NOSTEAL
	5234	# define SV_NOSTEAL 0
	5235	#endif
	5236
	5237	#ifndef SV_CONST_RETURN
	5238	# define SV_CONST_RETURN 0
	5239	#endif
	5240
	5241	#ifndef SV_MUTABLE_RETURN
	5242	# define SV_MUTABLE_RETURN 0
	5243	#endif
	5244
	5245	#ifndef SV_SMAGIC
	5246	# define SV_SMAGIC 0
	5247	#endif
	5248
	5249	#ifndef SV_HAS_TRAILING_NUL
	5250	# define SV_HAS_TRAILING_NUL 0
	5251	#endif
	5252
	5253	#ifndef SV_COW_SHARED_HASH_KEYS
	5254	# define SV_COW_SHARED_HASH_KEYS 0
	5255	#endif
	5256
	5257	#if (PERL_BCDVERSION < 0x5007002)
	5258
	5259	#if defined(NEED_sv_2pv_flags)
	5260	static char * DPPP_(my_sv_2pv_flags)(pTHX_ SV sv, STRLEN lp, I32 flags);
	5261	static
	5262	#else
	5263	extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV sv, STRLEN lp, I32 flags);
	5264	#endif
	5265
	5266	#ifdef sv_2pv_flags
	5267	# undef sv_2pv_flags
	5268	#endif
	5269	#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
	5270	#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
	5271
	5272	#if defined(NEED_sv_2pv_flags) \|\| defined(NEED_sv_2pv_flags_GLOBAL)
	5273
	5274	char *
	5275	DPPP_(my_sv_2pv_flags)(pTHX_ SV sv, STRLEN lp, I32 flags)
	5276	{
	5277	STRLEN n_a = (STRLEN) flags;
	5278	return sv_2pv(sv, lp ? lp : &n_a);
	5279	}
	5280
	5281	#endif
	5282
	5283	#if defined(NEED_sv_pvn_force_flags)
	5284	static char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV sv, STRLEN lp, I32 flags);
	5285	static
	5286	#else
	5287	extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV sv, STRLEN lp, I32 flags);
	5288	#endif
	5289
	5290	#ifdef sv_pvn_force_flags
	5291	# undef sv_pvn_force_flags
	5292	#endif
	5293	#define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
	5294	#define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
	5295
	5296	#if defined(NEED_sv_pvn_force_flags) \|\| defined(NEED_sv_pvn_force_flags_GLOBAL)
	5297
	5298	char *
	5299	DPPP_(my_sv_pvn_force_flags)(pTHX_ SV sv, STRLEN lp, I32 flags)
	5300	{
	5301	STRLEN n_a = (STRLEN) flags;
	5302	return sv_pvn_force(sv, lp ? lp : &n_a);
	5303	}
	5304
	5305	#endif
	5306
	5307	#endif
	5308
	5309	#if (PERL_BCDVERSION < 0x5008008) \|\| ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
	5310	# define DPPP_SVPV_NOLEN_LP_ARG &PL_na
	5311	#else
	5312	# define DPPP_SVPV_NOLEN_LP_ARG 0
	5313	#endif
	5314	#ifndef SvPV_const
	5315	# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
	5316	#endif
	5317
	5318	#ifndef SvPV_mutable
	5319	# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC)
	5320	#endif
	5321	#ifndef SvPV_flags
	5322	# define SvPV_flags(sv, lp, flags) \
	5323	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5324	? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags))
	5325	#endif
	5326	#ifndef SvPV_flags_const
	5327	# define SvPV_flags_const(sv, lp, flags) \
	5328	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5329	? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \
	5330	(const char*) sv_2pv_flags(sv, &lp, flags\|SV_CONST_RETURN))
	5331	#endif
	5332	#ifndef SvPV_flags_const_nolen
	5333	# define SvPV_flags_const_nolen(sv, flags) \
	5334	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5335	? SvPVX_const(sv) : \
	5336	(const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags\|SV_CONST_RETURN))
	5337	#endif
	5338	#ifndef SvPV_flags_mutable
	5339	# define SvPV_flags_mutable(sv, lp, flags) \
	5340	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5341	? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \
	5342	sv_2pv_flags(sv, &lp, flags\|SV_MUTABLE_RETURN))
	5343	#endif
	5344	#ifndef SvPV_force
	5345	# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC)
	5346	#endif
	5347
	5348	#ifndef SvPV_force_nolen
	5349	# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC)
	5350	#endif
	5351
	5352	#ifndef SvPV_force_mutable
	5353	# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC)
	5354	#endif
	5355
	5356	#ifndef SvPV_force_nomg
	5357	# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0)
	5358	#endif
	5359
	5360	#ifndef SvPV_force_nomg_nolen
	5361	# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0)
	5362	#endif
	5363	#ifndef SvPV_force_flags
	5364	# define SvPV_force_flags(sv, lp, flags) \
	5365	((SvFLAGS(sv) & (SVf_POK\|SVf_THINKFIRST)) == SVf_POK \
	5366	? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags))
	5367	#endif
	5368	#ifndef SvPV_force_flags_nolen
	5369	# define SvPV_force_flags_nolen(sv, flags) \
	5370	((SvFLAGS(sv) & (SVf_POK\|SVf_THINKFIRST)) == SVf_POK \
	5371	? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
	5372	#endif
	5373	#ifndef SvPV_force_flags_mutable
	5374	# define SvPV_force_flags_mutable(sv, lp, flags) \
	5375	((SvFLAGS(sv) & (SVf_POK\|SVf_THINKFIRST)) == SVf_POK \
	5376	? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \
	5377	: sv_pvn_force_flags(sv, &lp, flags\|SV_MUTABLE_RETURN))
	5378	#endif
	5379	#ifndef SvPV_nolen
	5380	# define SvPV_nolen(sv) \
	5381	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5382	? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
	5383	#endif
	5384	#ifndef SvPV_nolen_const
	5385	# define SvPV_nolen_const(sv) \
	5386	((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5387	? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC\|SV_CONST_RETURN))
	5388	#endif
	5389	#ifndef SvPV_nomg
	5390	# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
	5391	#endif
	5392
	5393	#ifndef SvPV_nomg_const
	5394	# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0)
	5395	#endif
	5396
	5397	#ifndef SvPV_nomg_const_nolen
	5398	# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0)
	5399	#endif
	5400
	5401	#ifndef SvPV_nomg_nolen
	5402	# define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
	5403	? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0))
	5404	#endif
	5405	#ifndef SvPV_renew
	5406	# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \
	5407	SvPV_set((sv), (char *) saferealloc( \
	5408	(Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \
	5409	} STMT_END
4204	5410	#endif
4205	5411	#ifndef SvMAGIC_set
4206	5412	# define SvMAGIC_set(sv, val) \

4208	5414	(((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END
4209	5415	#endif
4210	5416
4211		#if ((PERL_VERSION < 9) \|\| ((PERL_VERSION == 9) && (PERL_SUBVERSION < 3)))
	5417	#if (PERL_BCDVERSION < 0x5009003)
4212	5418	#ifndef SvPVX_const
4213	5419	# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
4214	5420	#endif

4243	5449	(((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END
4244	5450	#endif
4245	5451
4246		#if ((PERL_VERSION < 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION < 0)))
	5452	#if (PERL_BCDVERSION < 0x5004000)
4247	5453	#ifndef SvUV_set
4248	5454	# define SvUV_set(sv, val) \
4249	5455	STMT_START { assert(SvTYPE(sv) == SVt_IV \|\| SvTYPE(sv) >= SVt_PVIV); \

4259	5465
4260	5466	#endif
4261	5467
4262		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(vnewSVpvf)
	5468	#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf)
4263	5469	#if defined(NEED_vnewSVpvf)
4264		static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
	5470	static SV * DPPP_(my_vnewSVpvf)(pTHX_ const char pat, va_list args);
4265	5471	static
4266	5472	#else
4267		extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char * pat, va_list * args);
	5473	extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char pat, va_list args);
4268	5474	#endif
4269	5475
4270	5476	#ifdef vnewSVpvf

4286	5492	#endif
4287	5493	#endif
4288	5494
4289		/* sv_vcatpvf depends on sv_vcatpvfn */
4290		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf)
	5495	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf)
4291	5496	# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV*), 0, Null(bool))
4292	5497	#endif
4293	5498
4294		/* sv_vsetpvf depends on sv_vsetpvfn */
4295		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf)
	5499	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf)
4296	5500	# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV*), 0, Null(bool))
4297	5501	#endif
4298	5502
4299		/* sv_catpvf_mg depends on sv_vcatpvfn, sv_catpvf_mg_nocontext */
4300		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg)
	5503	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg)
4301	5504	#if defined(NEED_sv_catpvf_mg)
4302		static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
	5505	static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV sv, const char pat, ...);
4303	5506	static
4304	5507	#else
4305		extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
	5508	extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV sv, const char pat, ...);
4306	5509	#endif
4307	5510
4308	5511	#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)

4322	5525	#endif
4323	5526	#endif
4324	5527
4325		/* sv_catpvf_mg_nocontext depends on sv_vcatpvfn */
4326	5528	#ifdef PERL_IMPLICIT_CONTEXT
4327		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_catpvf_mg_nocontext)
	5529	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext)
4328	5530	#if defined(NEED_sv_catpvf_mg_nocontext)
4329		static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
	5531	static void DPPP_(my_sv_catpvf_mg_nocontext)(SV sv, const char pat, ...);
4330	5532	static
4331	5533	#else
4332		extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * sv, const char * pat, ...);
	5534	extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV sv, const char pat, ...);
4333	5535	#endif
4334	5536
4335	5537	#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)

4352	5554	#endif
4353	5555	#endif
4354	5556
	5557	/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */
4355	5558	#ifndef sv_catpvf_mg
4356	5559	# ifdef PERL_IMPLICIT_CONTEXT
4357	5560	# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext

4360	5563	# endif
4361	5564	#endif
4362	5565
4363		/* sv_vcatpvf_mg depends on sv_vcatpvfn */
4364		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vcatpvf_mg)
	5566	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg)
4365	5567	# define sv_vcatpvf_mg(sv, pat, args) \
4366	5568	STMT_START { \
4367	5569	sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV*), 0, Null(bool)); \

4369	5571	} STMT_END
4370	5572	#endif
4371	5573
4372		/* sv_setpvf_mg depends on sv_vsetpvfn, sv_setpvf_mg_nocontext */
4373		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg)
	5574	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg)
4374	5575	#if defined(NEED_sv_setpvf_mg)
4375		static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
	5576	static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV sv, const char pat, ...);
4376	5577	static
4377	5578	#else
4378		extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * sv, const char * pat, ...);
	5579	extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV sv, const char pat, ...);
4379	5580	#endif
4380	5581
4381	5582	#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)

4395	5596	#endif
4396	5597	#endif
4397	5598
4398		/* sv_setpvf_mg_nocontext depends on sv_vsetpvfn */
4399	5599	#ifdef PERL_IMPLICIT_CONTEXT
4400		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_setpvf_mg_nocontext)
	5600	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext)
4401	5601	#if defined(NEED_sv_setpvf_mg_nocontext)
4402		static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
	5602	static void DPPP_(my_sv_setpvf_mg_nocontext)(SV sv, const char pat, ...);
4403	5603	static
4404	5604	#else
4405		extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * sv, const char * pat, ...);
	5605	extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV sv, const char pat, ...);
4406	5606	#endif
4407	5607
4408	5608	#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)

4425	5625	#endif
4426	5626	#endif
4427	5627
	5628	/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */
4428	5629	#ifndef sv_setpvf_mg
4429	5630	# ifdef PERL_IMPLICIT_CONTEXT
4430	5631	# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext

4433	5634	# endif
4434	5635	#endif
4435	5636
4436		/* sv_vsetpvf_mg depends on sv_vsetpvfn */
4437		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(sv_vsetpvf_mg)
	5637	#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg)
4438	5638	# define sv_vsetpvf_mg(sv, pat, args) \
4439	5639	STMT_START { \
4440	5640	sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV*), 0, Null(bool)); \
4441	5641	SvSETMAGIC(sv); \
4442	5642	} STMT_END
	5643	#endif
	5644
	5645	/* Hint: newSVpvn_share
	5646	* The SVs created by this function only mimic the behaviour of
	5647	* shared PVs without really being shared. Only use if you know
	5648	* what you're doing.
	5649	*/
	5650
	5651	#ifndef newSVpvn_share
	5652
	5653	#if defined(NEED_newSVpvn_share)
	5654	static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
	5655	static
	5656	#else
	5657	extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
	5658	#endif
	5659
	5660	#ifdef newSVpvn_share
	5661	# undef newSVpvn_share
	5662	#endif
	5663	#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
	5664	#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
	5665
	5666	#if defined(NEED_newSVpvn_share) \|\| defined(NEED_newSVpvn_share_GLOBAL)
	5667
	5668	SV *
	5669	DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
	5670	{
	5671	SV *sv;
	5672	if (len < 0)
	5673	len = -len;
	5674	if (!hash)
	5675	PERL_HASH(hash, (char*) src, len);
	5676	sv = newSVpvn((char *) src, len);
	5677	sv_upgrade(sv, SVt_PVIV);
	5678	SvIVX(sv) = hash;
	5679	SvREADONLY_on(sv);
	5680	SvPOK_on(sv);
	5681	return sv;
	5682	}
	5683
	5684	#endif
	5685
	5686	#endif
	5687	#ifndef SvSHARED_HASH
	5688	# define SvSHARED_HASH(sv) (0 + SvUVX(sv))
	5689	#endif
	5690	#ifndef HvNAME_get
	5691	# define HvNAME_get(hv) HvNAME(hv)
	5692	#endif
	5693	#ifndef HvNAMELEN_get
	5694	# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0)
	5695	#endif
	5696	#ifndef GvSVn
	5697	# define GvSVn(gv) GvSV(gv)
	5698	#endif
	5699
	5700	#ifndef isGV_with_GP
	5701	# define isGV_with_GP(gv) isGV(gv)
	5702	#endif
	5703
	5704	#ifndef gv_fetchpvn_flags
	5705	# define gv_fetchpvn_flags(name, len, flags, svt) gv_fetchpv(name, flags, svt)
	5706	#endif
	5707
	5708	#ifndef gv_fetchsv
	5709	# define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt)
	5710	#endif
	5711	#ifndef get_cvn_flags
	5712	# define get_cvn_flags(name, namelen, flags) get_cv(name, flags)
4443	5713	#endif
4444	5714	#ifndef WARN_ALL
4445	5715	# define WARN_ALL 0

4640	5910	# endif
4641	5911	#endif
4642	5912
4643		/* warner depends on vnewSVpvf */
4644		#if ((PERL_VERSION > 4) \|\| ((PERL_VERSION == 4) && (PERL_SUBVERSION >= 0))) && !defined(warner)
	5913	#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner)
4645	5914	#if defined(NEED_warner)
4646	5915	static void DPPP_(my_warner)(U32 err, const char *pat, ...);
4647	5916	static

4670	5939
4671	5940	#define warner Perl_warner
4672	5941
4673		/* Perl_warner_nocontext depends on warner */
4674	5942	#define Perl_warner_nocontext Perl_warner
4675	5943
4676	5944	#endif

4687	5955	# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1)
4688	5956	#endif
4689	5957
	5958	#ifndef newSVpvs_flags
	5959	# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags)
	5960	#endif
	5961
	5962	#ifndef newSVpvs_share
	5963	# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0)
	5964	#endif
	5965
4690	5966	#ifndef sv_catpvs
4691	5967	# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1)
4692	5968	#endif

4702	5978	#ifndef hv_stores
4703	5979	# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0)
4704	5980	#endif
	5981	#ifndef gv_fetchpvs
	5982	# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt)
	5983	#endif
	5984
	5985	#ifndef gv_stashpvs
	5986	# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags)
	5987	#endif
	5988	#ifndef get_cvs
	5989	# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags)
	5990	#endif
4705	5991	#ifndef SvGETMAGIC
4706	5992	# define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
4707	5993	#endif

4862	6148	#endif
4863	6149
4864	6150	/* That's the best we can do... */
4865		#ifndef SvPV_force_nomg
4866		# define SvPV_force_nomg SvPV_force
4867		#endif
4868
4869		#ifndef SvPV_nomg
4870		# define SvPV_nomg SvPV
4871		#endif
4872
4873	6151	#ifndef sv_catpvn_nomg
4874	6152	# define sv_catpvn_nomg sv_catpvn
4875	6153	#endif

4987	6265	# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL)
4988	6266	#endif
4989	6267
	6268	/* Hint: sv_magic_portable
	6269	* This is a compatibility function that is only available with
	6270	* Devel::PPPort. It is NOT in the perl core.
	6271	* Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when
	6272	* it is being passed a name pointer with namlen == 0. In that
	6273	* case, perl 5.8.0 and later store the pointer, not a copy of it.
	6274	* The compatibility can be provided back to perl 5.004. With
	6275	* earlier versions, the code will not compile.
	6276	*/
	6277
	6278	#if (PERL_BCDVERSION < 0x5004000)
	6279
	6280	/* code that uses sv_magic_portable will not compile */
	6281
	6282	#elif (PERL_BCDVERSION < 0x5008000)
	6283
	6284	# define sv_magic_portable(sv, obj, how, name, namlen) \
	6285	STMT_START { \
	6286	SV *SvMp_sv = (sv); \
	6287	char SvMp_name = (char ) (name); \
	6288	I32 SvMp_namlen = (namlen); \
	6289	if (SvMp_name && SvMp_namlen == 0) \
	6290	{ \
	6291	MAGIC *mg; \
	6292	sv_magic(SvMp_sv, obj, how, 0, 0); \
	6293	mg = SvMAGIC(SvMp_sv); \
	6294	mg->mg_len = -42; /* XXX: this is the tricky part */ \
	6295	mg->mg_ptr = SvMp_name; \
	6296	} \
	6297	else \
	6298	{ \
	6299	sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \
	6300	} \
	6301	} STMT_END
	6302
	6303	#else
	6304
	6305	# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e)
	6306
	6307	#endif
	6308
4990	6309	#ifdef USE_ITHREADS
4991	6310	#ifndef CopFILE
4992	6311	# define CopFILE(c) ((c)->cop_file)

5026	6345
5027	6346	#ifndef CopSTASH_eq
5028	6347	# define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \
5029		\|\| (CopSTASHPV(c) && HvNAME(hv) \
5030		&& strEQ(CopSTASHPV(c), HvNAME(hv)))))
	6348	\|\| (CopSTASHPV(c) && HvNAME(hv) \
	6349	&& strEQ(CopSTASHPV(c), HvNAME(hv)))))
5031	6350	#endif
5032	6351
5033	6352	#else

5114	6433	#ifndef IS_NUMBER_NAN
5115	6434	# define IS_NUMBER_NAN 0x20
5116	6435	#endif
5117
5118		/* GROK_NUMERIC_RADIX depends on grok_numeric_radix */
5119	6436	#ifndef GROK_NUMERIC_RADIX
5120	6437	# define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send)
5121	6438	#endif

5191	6508	#endif
5192	6509	#endif
5193	6510
5194		/* grok_number depends on grok_numeric_radix */
5195
5196	6511	#ifndef grok_number
5197	6512	#if defined(NEED_grok_number)
5198	6513	static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);

5255	6570	digit = *s - '0';
5256	6571	if (digit >= 0 && digit <= 9) {
5257	6572	value = value * 10 + digit;
5258		if (++s < send) {
	6573	if (++s < send) {
5259	6574	digit = *s - '0';
5260	6575	if (digit >= 0 && digit <= 9) {
5261	6576	value = value * 10 + digit;

5303	6618	}
5304	6619	}
5305	6620	}
5306		}
	6621	}
5307	6622	}
5308	6623	}
5309	6624	}

5315	6630	}
5316	6631	}
5317	6632	}
5318		}
	6633	}
5319	6634	}
5320	6635	}
5321	6636	numtype \|= IS_NUMBER_IN_UV;

5409	6724
5410	6725	#ifndef grok_bin
5411	6726	#if defined(NEED_grok_bin)
5412		static UV DPPP_(my_grok_bin)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6727	static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5413	6728	static
5414	6729	#else
5415		extern UV DPPP_(my_grok_bin)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6730	extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5416	6731	#endif
5417	6732
5418	6733	#ifdef grok_bin

5423	6738
5424	6739	#if defined(NEED_grok_bin) \|\| defined(NEED_grok_bin_GLOBAL)
5425	6740	UV
5426		DPPP_(my_grok_bin)(pTHX_ char start, STRLEN len_p, I32 flags, NV result)
	6741	DPPP_(my_grok_bin)(pTHX_ const char start, STRLEN len_p, I32 flags, NV result)
5427	6742	{
5428	6743	const char *s = start;
5429	6744	STRLEN len = *len_p;

5468	6783	value_nv = (NV) value;
5469	6784	}
5470	6785	value_nv *= 2.0;
5471		/* If an NV has not enough bits in its mantissa to
5472		* represent a UV this summing of small low-order numbers
5473		* is a waste of time (because the NV cannot preserve
5474		* the low-order bits anyway): we could just remember when
5475		* did we overflow and in the end just multiply value_nv by the
5476		* right amount. */
	6786	/* If an NV has not enough bits in its mantissa to
	6787	* represent a UV this summing of small low-order numbers
	6788	* is a waste of time (because the NV cannot preserve
	6789	* the low-order bits anyway): we could just remember when
	6790	* did we overflow and in the end just multiply value_nv by the
	6791	* right amount. */
5477	6792	value_nv += (NV)(bit - '0');
5478	6793	continue;
5479	6794	}
5480	6795	if (bit == '_' && len && allow_underscores && (bit = s[1])
5481	6796	&& (bit == '0' \|\| bit == '1'))
5482		{
5483		--len;
5484		++s;
	6797	{
	6798	--len;
	6799	++s;
5485	6800	goto redo;
5486		}
	6801	}
5487	6802	if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
5488	6803	warn("Illegal binary digit '%c' ignored", *s);
5489	6804	break;

5491	6806
5492	6807	if ( ( overflowed && value_nv > 4294967295.0)
5493	6808	#if UVSIZE > 4
5494		\|\| (!overflowed && value > 0xffffffff )
5495		#endif
5496		) {
5497		warn("Binary number > 0b11111111111111111111111111111111 non-portable");
	6809	\|\| (!overflowed && value > 0xffffffff )
	6810	#endif
	6811	) {
	6812	warn("Binary number > 0b11111111111111111111111111111111 non-portable");
5498	6813	}
5499	6814	*len_p = s - start;
5500	6815	if (!overflowed) {

5511	6826
5512	6827	#ifndef grok_hex
5513	6828	#if defined(NEED_grok_hex)
5514		static UV DPPP_(my_grok_hex)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6829	static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5515	6830	static
5516	6831	#else
5517		extern UV DPPP_(my_grok_hex)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6832	extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5518	6833	#endif
5519	6834
5520	6835	#ifdef grok_hex

5525	6840
5526	6841	#if defined(NEED_grok_hex) \|\| defined(NEED_grok_hex_GLOBAL)
5527	6842	UV
5528		DPPP_(my_grok_hex)(pTHX_ char start, STRLEN len_p, I32 flags, NV result)
	6843	DPPP_(my_grok_hex)(pTHX_ const char start, STRLEN len_p, I32 flags, NV result)
5529	6844	{
5530	6845	const char *s = start;
5531	6846	STRLEN len = *len_p;

5554	6869	}
5555	6870
5556	6871	for (; len-- && *s; s++) {
5557		xdigit = strchr((char ) PL_hexdigit, s);
	6872	xdigit = strchr((char ) PL_hexdigit, s);
5558	6873	if (xdigit) {
5559	6874	/* Write it in this wonky order with a goto to attempt to get the
5560	6875	compiler to make the common case integer-only loop pretty tight.

5570	6885	value_nv = (NV) value;
5571	6886	}
5572	6887	value_nv *= 16.0;
5573		/* If an NV has not enough bits in its mantissa to
5574		* represent a UV this summing of small low-order numbers
5575		* is a waste of time (because the NV cannot preserve
5576		* the low-order bits anyway): we could just remember when
5577		* did we overflow and in the end just multiply value_nv by the
5578		* right amount of 16-tuples. */
	6888	/* If an NV has not enough bits in its mantissa to
	6889	* represent a UV this summing of small low-order numbers
	6890	* is a waste of time (because the NV cannot preserve
	6891	* the low-order bits anyway): we could just remember when
	6892	* did we overflow and in the end just multiply value_nv by the
	6893	* right amount of 16-tuples. */
5579	6894	value_nv += (NV)((xdigit - PL_hexdigit) & 15);
5580	6895	continue;
5581	6896	}
5582	6897	if (*s == '_' && len && allow_underscores && s[1]
5583		&& (xdigit = strchr((char *) PL_hexdigit, s[1])))
5584		{
5585		--len;
5586		++s;
	6898	&& (xdigit = strchr((char *) PL_hexdigit, s[1])))
	6899	{
	6900	--len;
	6901	++s;
5587	6902	goto redo;
5588		}
	6903	}
5589	6904	if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT))
5590	6905	warn("Illegal hexadecimal digit '%c' ignored", *s);
5591	6906	break;

5593	6908
5594	6909	if ( ( overflowed && value_nv > 4294967295.0)
5595	6910	#if UVSIZE > 4
5596		\|\| (!overflowed && value > 0xffffffff )
5597		#endif
5598		) {
5599		warn("Hexadecimal number > 0xffffffff non-portable");
	6911	\|\| (!overflowed && value > 0xffffffff )
	6912	#endif
	6913	) {
	6914	warn("Hexadecimal number > 0xffffffff non-portable");
5600	6915	}
5601	6916	*len_p = s - start;
5602	6917	if (!overflowed) {

5613	6928
5614	6929	#ifndef grok_oct
5615	6930	#if defined(NEED_grok_oct)
5616		static UV DPPP_(my_grok_oct)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6931	static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5617	6932	static
5618	6933	#else
5619		extern UV DPPP_(my_grok_oct)(pTHX_ char start, STRLEN len_p, I32 flags, NV result);
	6934	extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
5620	6935	#endif
5621	6936
5622	6937	#ifdef grok_oct

5627	6942
5628	6943	#if defined(NEED_grok_oct) \|\| defined(NEED_grok_oct_GLOBAL)
5629	6944	UV
5630		DPPP_(my_grok_oct)(pTHX_ char start, STRLEN len_p, I32 flags, NV result)
	6945	DPPP_(my_grok_oct)(pTHX_ const char start, STRLEN len_p, I32 flags, NV result)
5631	6946	{
5632	6947	const char *s = start;
5633	6948	STRLEN len = *len_p;

5658	6973	value_nv = (NV) value;
5659	6974	}
5660	6975	value_nv *= 8.0;
5661		/* If an NV has not enough bits in its mantissa to
5662		* represent a UV this summing of small low-order numbers
5663		* is a waste of time (because the NV cannot preserve
5664		* the low-order bits anyway): we could just remember when
5665		* did we overflow and in the end just multiply value_nv by the
5666		* right amount of 8-tuples. */
	6976	/* If an NV has not enough bits in its mantissa to
	6977	* represent a UV this summing of small low-order numbers
	6978	* is a waste of time (because the NV cannot preserve
	6979	* the low-order bits anyway): we could just remember when
	6980	* did we overflow and in the end just multiply value_nv by the
	6981	* right amount of 8-tuples. */
5667	6982	value_nv += (NV)digit;
5668	6983	continue;
5669	6984	}
5670	6985	if (digit == ('_' - '0') && len && allow_underscores
5671	6986	&& (digit = s[1] - '0') && (digit >= 0 && digit <= 7))
5672		{
5673		--len;
5674		++s;
	6987	{
	6988	--len;
	6989	++s;
5675	6990	goto redo;
5676		}
	6991	}
5677	6992	/* Allow \octal to work the DWIM way (that is, stop scanning
5678	6993	* as soon as non-octal characters are seen, complain only iff
5679	6994	* someone seems to want to use the digits eight and nine). */

5686	7001
5687	7002	if ( ( overflowed && value_nv > 4294967295.0)
5688	7003	#if UVSIZE > 4
5689		\|\| (!overflowed && value > 0xffffffff )
5690		#endif
5691		) {
5692		warn("Octal number > 037777777777 non-portable");
	7004	\|\| (!overflowed && value > 0xffffffff )
	7005	#endif
	7006	) {
	7007	warn("Octal number > 037777777777 non-portable");
5693	7008	}
5694	7009	*len_p = s - start;
5695	7010	if (!overflowed) {

5730	7045	retval = vsprintf(buffer, format, ap);
5731	7046	#endif
5732	7047	va_end(ap);
5733		if (retval >= (int)len)
5734		Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
	7048	if (retval < 0 \|\| (len > 0 && (Size_t)retval >= len))
	7049	Perl_croak(aTHX_ "panic: my_snprintf buffer overflow");
5735	7050	return retval;
	7051	}
	7052
	7053	#endif
	7054	#endif
	7055
	7056	#if !defined(my_sprintf)
	7057	#if defined(NEED_my_sprintf)
	7058	static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
	7059	static
	7060	#else
	7061	extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
	7062	#endif
	7063
	7064	#define my_sprintf DPPP_(my_my_sprintf)
	7065	#define Perl_my_sprintf DPPP_(my_my_sprintf)
	7066
	7067	#if defined(NEED_my_sprintf) \|\| defined(NEED_my_sprintf_GLOBAL)
	7068
	7069	int
	7070	DPPP_(my_my_sprintf)(char buffer, const char pat, ...)
	7071	{
	7072	va_list args;
	7073	va_start(args, pat);
	7074	vsprintf(buffer, pat, args);
	7075	va_end(args);
	7076	return strlen(buffer);
5736	7077	}
5737	7078
5738	7079	#endif

5813	7154
5814	7155	#endif
5815	7156	#endif
	7157	#ifndef PERL_PV_ESCAPE_QUOTE
	7158	# define PERL_PV_ESCAPE_QUOTE 0x0001
	7159	#endif
	7160
	7161	#ifndef PERL_PV_PRETTY_QUOTE
	7162	# define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE
	7163	#endif
	7164
	7165	#ifndef PERL_PV_PRETTY_ELLIPSES
	7166	# define PERL_PV_PRETTY_ELLIPSES 0x0002
	7167	#endif
	7168
	7169	#ifndef PERL_PV_PRETTY_LTGT
	7170	# define PERL_PV_PRETTY_LTGT 0x0004
	7171	#endif
	7172
	7173	#ifndef PERL_PV_ESCAPE_FIRSTCHAR
	7174	# define PERL_PV_ESCAPE_FIRSTCHAR 0x0008
	7175	#endif
	7176
	7177	#ifndef PERL_PV_ESCAPE_UNI
	7178	# define PERL_PV_ESCAPE_UNI 0x0100
	7179	#endif
	7180
	7181	#ifndef PERL_PV_ESCAPE_UNI_DETECT
	7182	# define PERL_PV_ESCAPE_UNI_DETECT 0x0200
	7183	#endif
	7184
	7185	#ifndef PERL_PV_ESCAPE_ALL
	7186	# define PERL_PV_ESCAPE_ALL 0x1000
	7187	#endif
	7188
	7189	#ifndef PERL_PV_ESCAPE_NOBACKSLASH
	7190	# define PERL_PV_ESCAPE_NOBACKSLASH 0x2000
	7191	#endif
	7192
	7193	#ifndef PERL_PV_ESCAPE_NOCLEAR
	7194	# define PERL_PV_ESCAPE_NOCLEAR 0x4000
	7195	#endif
	7196
	7197	#ifndef PERL_PV_ESCAPE_RE
	7198	# define PERL_PV_ESCAPE_RE 0x8000
	7199	#endif
	7200
	7201	#ifndef PERL_PV_PRETTY_NOCLEAR
	7202	# define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR
	7203	#endif
	7204	#ifndef PERL_PV_PRETTY_DUMP
	7205	# define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES\|PERL_PV_PRETTY_QUOTE
	7206	#endif
	7207
	7208	#ifndef PERL_PV_PRETTY_REGPROP
	7209	# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES\|PERL_PV_PRETTY_LTGT\|PERL_PV_ESCAPE_RE
	7210	#endif
	7211
	7212	/* Hint: pv_escape
	7213	* Note that unicode functionality is only backported to
	7214	* those perl versions that support it. For older perl
	7215	* versions, the implementation will fall back to bytes.
	7216	*/
	7217
	7218	#ifndef pv_escape
	7219	#if defined(NEED_pv_escape)
	7220	static char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
	7221	static
	7222	#else
	7223	extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
	7224	#endif
	7225
	7226	#ifdef pv_escape
	7227	# undef pv_escape
	7228	#endif
	7229	#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
	7230	#define Perl_pv_escape DPPP_(my_pv_escape)
	7231
	7232	#if defined(NEED_pv_escape) \|\| defined(NEED_pv_escape_GLOBAL)
	7233
	7234	char *
	7235	DPPP_(my_pv_escape)(pTHX_ SV dsv, char const const str,
	7236	const STRLEN count, const STRLEN max,
	7237	STRLEN * const escaped, const U32 flags)
	7238	{
	7239	const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\';
	7240	const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc;
	7241	char octbuf[32] = "%123456789ABCDF";
	7242	STRLEN wrote = 0;
	7243	STRLEN chsize = 0;
	7244	STRLEN readsize = 1;
	7245	#if defined(is_utf8_string) && defined(utf8_to_uvchr)
	7246	bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0;
	7247	#endif
	7248	const char *pv = str;
	7249	const char * const end = pv + count;
	7250	octbuf[0] = esc;
	7251
	7252	if (!(flags & PERL_PV_ESCAPE_NOCLEAR))
	7253	sv_setpvs(dsv, "");
	7254
	7255	#if defined(is_utf8_string) && defined(utf8_to_uvchr)
	7256	if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
	7257	isuni = 1;
	7258	#endif
	7259
	7260	for (; pv < end && (!max \|\| wrote < max) ; pv += readsize) {
	7261	const UV u =
	7262	#if defined(is_utf8_string) && defined(utf8_to_uvchr)
	7263	isuni ? utf8_to_uvchr((U8*)pv, &readsize) :
	7264	#endif
	7265	(U8)*pv;
	7266	const U8 c = (U8)u & 0xFF;
	7267
	7268	if (u > 255 \|\| (flags & PERL_PV_ESCAPE_ALL)) {
	7269	if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
	7270	chsize = my_snprintf(octbuf, sizeof octbuf,
	7271	"%"UVxf, u);
	7272	else
	7273	chsize = my_snprintf(octbuf, sizeof octbuf,
	7274	"%cx{%"UVxf"}", esc, u);
	7275	} else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
	7276	chsize = 1;
	7277	} else {
	7278	if (c == dq \|\| c == esc \|\| !isPRINT(c)) {
	7279	chsize = 2;
	7280	switch (c) {
	7281	case '\\' : /* fallthrough */
	7282	case '%' : if (c == esc)
	7283	octbuf[1] = esc;
	7284	else
	7285	chsize = 1;
	7286	break;
	7287	case '\v' : octbuf[1] = 'v'; break;
	7288	case '\t' : octbuf[1] = 't'; break;
	7289	case '\r' : octbuf[1] = 'r'; break;
	7290	case '\n' : octbuf[1] = 'n'; break;
	7291	case '\f' : octbuf[1] = 'f'; break;
	7292	case '"' : if (dq == '"')
	7293	octbuf[1] = '"';
	7294	else
	7295	chsize = 1;
	7296	break;
	7297	default: chsize = my_snprintf(octbuf, sizeof octbuf,
	7298	pv < end && isDIGIT((U8)*(pv+readsize))
	7299	? "%c%03o" : "%c%o", esc, c);
	7300	}
	7301	} else {
	7302	chsize = 1;
	7303	}
	7304	}
	7305	if (max && wrote + chsize > max) {
	7306	break;
	7307	} else if (chsize > 1) {
	7308	sv_catpvn(dsv, octbuf, chsize);
	7309	wrote += chsize;
	7310	} else {
	7311	char tmp[2];
	7312	my_snprintf(tmp, sizeof tmp, "%c", c);
	7313	sv_catpvn(dsv, tmp, 1);
	7314	wrote++;
	7315	}
	7316	if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
	7317	break;
	7318	}
	7319	if (escaped != NULL)
	7320	*escaped= pv - str;
	7321	return SvPVX(dsv);
	7322	}
	7323
	7324	#endif
	7325	#endif
	7326
	7327	#ifndef pv_pretty
	7328	#if defined(NEED_pv_pretty)
	7329	static char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
	7330	static
	7331	#else
	7332	extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
	7333	#endif
	7334
	7335	#ifdef pv_pretty
	7336	# undef pv_pretty
	7337	#endif
	7338	#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
	7339	#define Perl_pv_pretty DPPP_(my_pv_pretty)
	7340
	7341	#if defined(NEED_pv_pretty) \|\| defined(NEED_pv_pretty_GLOBAL)
	7342
	7343	char *
	7344	DPPP_(my_pv_pretty)(pTHX_ SV dsv, char const const str, const STRLEN count,
	7345	const STRLEN max, char const * const start_color, char const * const end_color,
	7346	const U32 flags)
	7347	{
	7348	const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
	7349	STRLEN escaped;
	7350
	7351	if (!(flags & PERL_PV_PRETTY_NOCLEAR))
	7352	sv_setpvs(dsv, "");
	7353
	7354	if (dq == '"')
	7355	sv_catpvs(dsv, "\"");
	7356	else if (flags & PERL_PV_PRETTY_LTGT)
	7357	sv_catpvs(dsv, "<");
	7358
	7359	if (start_color != NULL)
	7360	sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color));
	7361
	7362	pv_escape(dsv, str, count, max, &escaped, flags \| PERL_PV_ESCAPE_NOCLEAR);
	7363
	7364	if (end_color != NULL)
	7365	sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color));
	7366
	7367	if (dq == '"')
	7368	sv_catpvs(dsv, "\"");
	7369	else if (flags & PERL_PV_PRETTY_LTGT)
	7370	sv_catpvs(dsv, ">");
	7371
	7372	if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count)
	7373	sv_catpvs(dsv, "...");
	7374
	7375	return SvPVX(dsv);
	7376	}
	7377
	7378	#endif
	7379	#endif
	7380
	7381	#ifndef pv_display
	7382	#if defined(NEED_pv_display)
	7383	static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
	7384	static
	7385	#else
	7386	extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
	7387	#endif
	7388
	7389	#ifdef pv_display
	7390	# undef pv_display
	7391	#endif
	7392	#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
	7393	#define Perl_pv_display DPPP_(my_pv_display)
	7394
	7395	#if defined(NEED_pv_display) \|\| defined(NEED_pv_display_GLOBAL)
	7396
	7397	char *
	7398	DPPP_(my_pv_display)(pTHX_ SV dsv, const char pv, STRLEN cur, STRLEN len, STRLEN pvlim)
	7399	{
	7400	pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
	7401	if (len > cur && pv[cur] == '\0')
	7402	sv_catpvs(dsv, "\\0");
	7403	return SvPVX(dsv);
	7404	}
	7405
	7406	#endif
	7407	#endif
5816	7408
5817	7409	#endif /* _P_P_PORTABILITY_H_ */
5818	7410

-1

t/000prereq.t less more

18	18	if eval { require Test::NoWarnings ; import Test::NoWarnings; 1 };
19	19
20	20
21		my $VERSION = '2.055';
	21	my $VERSION = '2.057';
22	22	my @NAMES = qw(
23	23
24	24	);