From: Charles McGarvey Date: Sun, 1 May 2022 01:41:53 +0000 (-0600) Subject: Version 0.900 X-Git-Url: https://git.brokenzipper.com/gitweb?a=commitdiff_plain;h=bd555cf59bfd563366bd9e30c72f8101a4897940;p=chaz%2Fp5-File-KDBX-XS Version 0.900 --- bd555cf59bfd563366bd9e30c72f8101a4897940 diff --git a/Changes b/Changes new file mode 100644 index 0000000..7f31fdf --- /dev/null +++ b/Changes @@ -0,0 +1,6 @@ +Revision history for File-KDBX-XS. + +0.900 2022-04-30 19:41:34-0600 + + * Initial release + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..c66d7e9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,379 @@ +This software is copyright (c) 2022 by Charles McGarvey. + +This is free software; you can redistribute it and/or modify it under +the same terms as the Perl 5 programming language system itself. + +Terms of the Perl programming language system itself + +a) the GNU General Public License as published by the Free + Software Foundation; either version 1, or (at your option) any + later version, or +b) the "Artistic License" + +--- The GNU General Public License, Version 1, February 1989 --- + +This software is Copyright (c) 2022 by Charles McGarvey. + +This is free software, licensed under: + + The GNU General Public License, Version 1, February 1989 + + GNU GENERAL PUBLIC LICENSE + Version 1, February 1989 + + Copyright (C) 1989 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The license agreements of most software companies try to keep users +at the mercy of those companies. By contrast, our General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. The +General Public License applies to the Free Software Foundation's +software and to any other program whose authors commit to using it. +You can use it for your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Specifically, the General Public License is designed to make +sure that you have the freedom to give away or sell copies of free +software, that you receive source code or can get it if you want it, +that you can change the software or use pieces of it in new free +programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of a such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must tell them their rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any program or other work which +contains a notice placed by the copyright holder saying it may be +distributed under the terms of this General Public License. The +"Program", below, refers to any such program or work, and a "work based +on the Program" means either the Program or any work containing the +Program or a portion of it, either verbatim or with modifications. Each +licensee is addressed as "you". + + 1. You may copy and distribute verbatim copies of the Program's source +code as you receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice and +disclaimer of warranty; keep intact all the notices that refer to this +General Public License and to the absence of any warranty; and give any +other recipients of the Program a copy of this General Public License +along with the Program. You may charge a fee for the physical act of +transferring a copy. + + 2. You may modify your copy or copies of the Program or any portion of +it, and copy and distribute such modifications under the terms of Paragraph +1 above, provided that you also do the following: + + a) cause the modified files to carry prominent notices stating that + you changed the files and the date of any change; and + + b) cause the whole of any work that you distribute or publish, that + in whole or in part contains the Program or any part thereof, either + with or without modifications, to be licensed at no charge to all + third parties under the terms of this General Public License (except + that you may choose to grant warranty protection to some or all + third parties, at your option). + + c) If the modified program normally reads commands interactively when + run, you must cause it, when started running for such interactive use + in the simplest and most usual way, to print or display an + announcement including an appropriate copyright notice and a notice + that there is no warranty (or else, saying that you provide a + warranty) and that users may redistribute the program under these + conditions, and telling the user how to view a copy of this General + Public License. + + d) You may charge a fee for the physical act of transferring a + copy, and you may at your option offer warranty protection in + exchange for a fee. + +Mere aggregation of another independent work with the Program (or its +derivative) on a volume of a storage or distribution medium does not bring +the other work under the scope of these terms. + + 3. You may copy and distribute the Program (or a portion or derivative of +it, under Paragraph 2) in object code or executable form under the terms of +Paragraphs 1 and 2 above provided that you also do one of the following: + + a) accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of + Paragraphs 1 and 2 above; or, + + b) accompany it with a written offer, valid for at least three + years, to give any third party free (except for a nominal charge + for the cost of distribution) a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of + Paragraphs 1 and 2 above; or, + + c) accompany it with the information you received as to where the + corresponding source code may be obtained. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form alone.) + +Source code for a work means the preferred form of the work for making +modifications to it. For an executable file, complete source code means +all the source code for all modules it contains; but, as a special +exception, it need not include source code for modules which are standard +libraries that accompany the operating system on which the executable +file runs, or for standard header files or definitions files that +accompany that operating system. + + 4. You may not copy, modify, sublicense, distribute or transfer the +Program except as expressly provided under this General Public License. +Any attempt otherwise to copy, modify, sublicense, distribute or transfer +the Program is void, and will automatically terminate your rights to use +the Program under this License. However, parties who have received +copies, or rights to use copies, from you under this General Public +License will not have their licenses terminated so long as such parties +remain in full compliance. + + 5. By copying, distributing or modifying the Program (or any work based +on the Program) you indicate your acceptance of this license to do so, +and all its terms and conditions. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the original +licensor to copy, distribute or modify the Program subject to these +terms and conditions. You may not impose any further restrictions on the +recipients' exercise of the rights granted herein. + + 7. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of the license which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +the license, you may choose any version ever published by the Free Software +Foundation. + + 8. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to humanity, the best way to achieve this is to make it +free software which everyone can redistribute and change under these +terms. + + To do so, attach the following notices to the program. It is safest to +attach them to the start of each source file to most effectively convey +the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19xx name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the +appropriate parts of the General Public License. Of course, the +commands you use may be called something other than `show w' and `show +c'; they could even be mouse-clicks or menu items--whatever suits your +program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + program `Gnomovision' (a program to direct compilers to make passes + at assemblers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +That's all there is to it! + + +--- The Artistic License 1.0 --- + +This software is Copyright (c) 2022 by Charles McGarvey. + +This is free software, licensed under: + + The Artistic License 1.0 + +The Artistic License + +Preamble + +The intent of this document is to state the conditions under which a Package +may be copied, such that the Copyright Holder maintains some semblance of +artistic control over the development of the package, while giving the users of +the package the right to use and distribute the Package in a more-or-less +customary fashion, plus the right to make reasonable modifications. + +Definitions: + + - "Package" refers to the collection of files distributed by the Copyright + Holder, and derivatives of that collection of files created through + textual modification. + - "Standard Version" refers to such a Package if it has not been modified, + or has been modified in accordance with the wishes of the Copyright + Holder. + - "Copyright Holder" is whoever is named in the copyright or copyrights for + the package. + - "You" is you, if you're thinking about copying or distributing this Package. + - "Reasonable copying fee" is whatever you can justify on the basis of media + cost, duplication charges, time of people involved, and so on. (You will + not be required to justify it to the Copyright Holder, but only to the + computing community at large as a market that must bear the fee.) + - "Freely Available" means that no fee is charged for the item itself, though + there may be fees involved in handling the item. It also means that + recipients of the item may redistribute it under the same conditions they + received it. + +1. You may make and give away verbatim copies of the source form of the +Standard Version of this Package without restriction, provided that you +duplicate all of the original copyright notices and associated disclaimers. + +2. You may apply bug fixes, portability fixes and other modifications derived +from the Public Domain or from the Copyright Holder. A Package modified in such +a way shall still be considered the Standard Version. + +3. You may otherwise modify your copy of this Package in any way, provided that +you insert a prominent notice in each changed file stating how and when you +changed that file, and provided that you do at least ONE of the following: + + a) place your modifications in the Public Domain or otherwise make them + Freely Available, such as by posting said modifications to Usenet or an + equivalent medium, or placing the modifications on a major archive site + such as ftp.uu.net, or by allowing the Copyright Holder to include your + modifications in the Standard Version of the Package. + + b) use the modified Package only within your corporation or organization. + + c) rename any non-standard executables so the names do not conflict with + standard executables, which must also be provided, and provide a separate + manual page for each non-standard executable that clearly documents how it + differs from the Standard Version. + + d) make other distribution arrangements with the Copyright Holder. + +4. You may distribute the programs of this Package in object code or executable +form, provided that you do at least ONE of the following: + + a) distribute a Standard Version of the executables and library files, + together with instructions (in the manual page or equivalent) on where to + get the Standard Version. + + b) accompany the distribution with the machine-readable source of the Package + with your modifications. + + c) accompany any non-standard executables with their corresponding Standard + Version executables, giving the non-standard executables non-standard + names, and clearly documenting the differences in manual pages (or + equivalent), together with instructions on where to get the Standard + Version. + + d) make other distribution arrangements with the Copyright Holder. + +5. You may charge a reasonable copying fee for any distribution of this +Package. You may charge any fee you choose for support of this Package. You +may not charge a fee for this Package itself. However, you may distribute this +Package in aggregate with other (possibly commercial) programs as part of a +larger (possibly commercial) software distribution provided that you do not +advertise this Package as a product of your own. + +6. The scripts and library files supplied as input to or produced as output +from the programs of this Package do not automatically fall under the copyright +of this Package, but belong to whomever generated them, and may be sold +commercially, and may be aggregated with this Package. + +7. C or perl subroutines supplied by you and linked into this Package shall not +be considered part of this Package. + +8. The name of the Copyright Holder may not be used to endorse or promote +products derived from this software without specific prior written permission. + +9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + +The End + diff --git a/MANIFEST b/MANIFEST new file mode 100644 index 0000000..3eb0443 --- /dev/null +++ b/MANIFEST @@ -0,0 +1,50 @@ +# This file was automatically generated by Dist::Zilla::Plugin::Manifest v6.024. +Changes +LICENSE +MANIFEST +META.json +META.yml +Makefile.PL +README +XS.xs +eg/benchmark.pl +lib/File/KDBX/XS.pm +libtomcrypt/LICENSE +libtomcrypt/Makefile +libtomcrypt/Makefile.nmake +libtomcrypt/README +libtomcrypt/src/ciphers/aes/aes.c +libtomcrypt/src/ciphers/aes/aes_tab.c +libtomcrypt/src/headers/tomcrypt.h +libtomcrypt/src/headers/tomcrypt_argchk.h +libtomcrypt/src/headers/tomcrypt_cfg.h +libtomcrypt/src/headers/tomcrypt_cipher.h +libtomcrypt/src/headers/tomcrypt_custom.h +libtomcrypt/src/headers/tomcrypt_hash.h +libtomcrypt/src/headers/tomcrypt_mac.h +libtomcrypt/src/headers/tomcrypt_macros.h +libtomcrypt/src/headers/tomcrypt_math.h +libtomcrypt/src/headers/tomcrypt_misc.h +libtomcrypt/src/headers/tomcrypt_pk.h +libtomcrypt/src/headers/tomcrypt_pkcs.h +libtomcrypt/src/headers/tomcrypt_private.h +libtomcrypt/src/headers/tomcrypt_prng.h +libtomcrypt/src/misc/compare_testvector.c +libtomcrypt/src/misc/crypt/crypt_argchk.c +libtomcrypt/src/misc/zeromem.c +ppport.h +t/00-compile.t +t/00-report-prereqs.dd +t/00-report-prereqs.t +t/kdf-aes.t +xt/author/clean-namespaces.t +xt/author/critic.t +xt/author/distmeta.t +xt/author/eol.t +xt/author/minimum-version.t +xt/author/no-tabs.t +xt/author/pod-coverage.t +xt/author/pod-no404s.t +xt/author/pod-syntax.t +xt/author/portability.t +xt/release/cpan-changes.t diff --git a/META.json b/META.json new file mode 100644 index 0000000..abd2353 --- /dev/null +++ b/META.json @@ -0,0 +1,100 @@ +{ + "abstract" : "Speed up File::KDBX", + "author" : [ + "Charles McGarvey " + ], + "dynamic_config" : 0, + "generated_by" : "Dist::Zilla version 6.024, CPAN::Meta::Converter version 2.150010", + "license" : [ + "perl_5" + ], + "meta-spec" : { + "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", + "version" : 2 + }, + "name" : "File-KDBX-XS", + "no_index" : { + "directory" : [ + "eg", + "libtomcrypt", + "t", + "xt" + ] + }, + "prereqs" : { + "configure" : { + "requires" : { + "ExtUtils::MakeMaker" : "0" + } + }, + "develop" : { + "requires" : { + "Dist::Zilla" : "5", + "Dist::Zilla::Plugin::MakeMaker::Custom" : "0", + "Dist::Zilla::Plugin::Meta::Contributors" : "0", + "Dist::Zilla::PluginBundle::Author::CCM" : "0.012", + "Pod::Coverage::TrustPod" : "0", + "Software::License::Perl_5" : "0", + "Test::CPAN::Changes" : "0.19", + "Test::CPAN::Meta" : "0", + "Test::CleanNamespaces" : "0.15", + "Test::EOL" : "0", + "Test::MinimumVersion" : "0", + "Test::More" : "0.96", + "Test::NoTabs" : "0", + "Test::Perl::Critic" : "0", + "Test::Pod" : "1.41", + "Test::Pod::Coverage" : "1.08", + "Test::Pod::No404s" : "0", + "Test::Portability::Files" : "0" + } + }, + "runtime" : { + "requires" : { + "XSLoader" : "0", + "strict" : "0", + "warnings" : "0" + } + }, + "test" : { + "recommends" : { + "CPAN::Meta" : "2.120900" + }, + "requires" : { + "ExtUtils::MakeMaker" : "0", + "File::Spec" : "0", + "IO::Handle" : "0", + "IPC::Open3" : "0", + "Test::More" : "0", + "perl" : "5.006" + } + } + }, + "provides" : { + "File::KDBX::XS" : { + "file" : "lib/File/KDBX/XS.pm", + "version" : "0.900" + } + }, + "release_status" : "stable", + "resources" : { + "bugtracker" : { + "web" : "https://github.com/chazmcgarvey/File-KDBX-XS/issues" + }, + "homepage" : "https://github.com/chazmcgarvey/File-KDBX-XS", + "repository" : { + "type" : "git", + "url" : "https://github.com/chazmcgarvey/File-KDBX-XS.git", + "web" : "https://github.com/chazmcgarvey/File-KDBX-XS" + } + }, + "version" : "0.900", + "x_authority" : "cpan:CCM", + "x_contributors" : [ + "Karel Miko " + ], + "x_generated_by_perl" : "v5.34.1", + "x_serialization_backend" : "Cpanel::JSON::XS version 4.27", + "x_spdx_expression" : "Artistic-1.0-Perl OR GPL-1.0-or-later" +} + diff --git a/META.yml b/META.yml new file mode 100644 index 0000000..66bfc45 --- /dev/null +++ b/META.yml @@ -0,0 +1,45 @@ +--- +abstract: 'Speed up File::KDBX' +author: + - 'Charles McGarvey ' +build_requires: + ExtUtils::MakeMaker: '0' + File::Spec: '0' + IO::Handle: '0' + IPC::Open3: '0' + Test::More: '0' + perl: '5.006' +configure_requires: + ExtUtils::MakeMaker: '0' +dynamic_config: 0 +generated_by: 'Dist::Zilla version 6.024, CPAN::Meta::Converter version 2.150010' +license: perl +meta-spec: + url: http://module-build.sourceforge.net/META-spec-v1.4.html + version: '1.4' +name: File-KDBX-XS +no_index: + directory: + - eg + - libtomcrypt + - t + - xt +provides: + File::KDBX::XS: + file: lib/File/KDBX/XS.pm + version: '0.900' +requires: + XSLoader: '0' + strict: '0' + warnings: '0' +resources: + bugtracker: https://github.com/chazmcgarvey/File-KDBX-XS/issues + homepage: https://github.com/chazmcgarvey/File-KDBX-XS + repository: https://github.com/chazmcgarvey/File-KDBX-XS.git +version: '0.900' +x_authority: cpan:CCM +x_contributors: + - 'Karel Miko ' +x_generated_by_perl: v5.34.1 +x_serialization_backend: 'YAML::Tiny version 1.73' +x_spdx_expression: 'Artistic-1.0-Perl OR GPL-1.0-or-later' diff --git a/Makefile.PL b/Makefile.PL new file mode 100644 index 0000000..2ff4890 --- /dev/null +++ b/Makefile.PL @@ -0,0 +1,132 @@ +#!/usr/bin/env perl + +# A lot of this is cargo-culted from CryptX which has already gone through a lot of working around platform +# incompatibilities which we're grateful to take advantage of here -- thanks cpan:MIK! + +use warnings; +use strict; + +use Config; +use ExtUtils::MakeMaker; + + + +my (@EUMM_INC_LIB, $myarflags, $mycflags); + +# use bundled libtomcrypt +my @myobjs = map { /^(.*)\.c$/ ? "$1$Config{obj_ext}" : () } qw( + libtomcrypt/src/ciphers/aes/aes.c + libtomcrypt/src/misc/compare_testvector.c + libtomcrypt/src/misc/crypt/crypt_argchk.c + libtomcrypt/src/misc/zeromem.c +); +$mycflags = " $Config{ccflags} $Config{cccdlflags} $Config{optimize} "; # keep leading + trailing spaces + +#FIX: this is particularly useful for Debian https://github.com/DCIT/perl-CryptX/pull/39 +$mycflags .= " $ENV{CFLAGS} " if $ENV{CFLAGS}; +$mycflags .= " $ENV{CPPFLAGS} " if $ENV{CPPFLAGS}; + +#### remove all lto hacks - https://github.com/DCIT/perl-CryptX/issues/70 +## #FIX: gcc with -flto is a trouble maker see https://github.com/DCIT/perl-CryptX/issues/32 +## #FIX: another issue with "-flto=auto" see https://github.com/DCIT/perl-CryptX/pull/66 +## $mycflags =~ s/\s-flto\S+\s/ /g; # -flto -flto=auto -flto=jobserver -flto=N ... + +#FIX: avoid -Wwrite-strings -Wcast-qual -pedantic -pedantic-errors -ansi -std=c89 +$mycflags =~ s/\s-pedantic-errors\s/ /g; +$mycflags =~ s/\s-pedantic\s/ /g; +$mycflags =~ s/\s-std=c89\s/ /g; +$mycflags =~ s/\s-ansi\s/ /g; +$mycflags =~ s/\s-Wwrite-strings\s/ /g; +$mycflags =~ s/\s-Wcast-qual\s/ /g; + +#FIX: avoid "ar: fatal: Numeric group ID too large" see https://github.com/DCIT/perl-CryptX/issues/33 +$myarflags = '$(AR_STATIC_ARGS)'; +if ($^O ne 'MSWin32' && $Config{ar}) { + # for ar's "deterministic mode" we need GNU binutils 2.20+ (2009-10-16) + my $arver = `$Config{ar} --version 2>/dev/null`; + my ($maj, $min) = $arver =~ /^GNU ar [^\d]*(\d)\.(\d+)\.\d+/s; + $myarflags = 'rcD' if ($maj && $min && $maj >= 2 && $min >= 20) || $arver=~ /^BSD ar /; +} + +# turn on extra warnings in AUTHOR_MODE (it is gcc only!!) +$mycflags = "$mycflags -Wall -Werror -Wextra" if $ENV{AUTHOR_MODE}; + +@EUMM_INC_LIB = ( + INC => $ENV{AUTHOR_MODE} ? '-DLTM_DESC -Ilibtomcrypt/src/headers -Wall -Werror -Wextra' # gcc only + : '-DLTM_DESC -Ilibtomcrypt/src/headers', + MYEXTLIB => "libtomcrypt/libonlyaes$Config{lib_ext}", + clean => { FILES => join(' ', @myobjs, "libtomcrypt/libonlyaes$Config{lib_ext}") }, + realclean => { FILES => join(' ', qw{cover_db *.gcda *.gcno *.gcov})}, +); + +#FIX: https://github.com/DCIT/perl-CryptX/pull/79 +# not needed on MS Windows +# does not work on macos - Apple LLVM 12.0.5 (clang-1205.0.22.9) ld: unknown option: --exclude-libs +# does not work on solaris - gcc 9.3.0 - ld: fatal: unrecognized option '--exclude-libs' +if ($^O !~ /^(MSWin32|darwin|solaris)$/ && ($Config{ld} =~ /gcc|g\+\+/ || $Config{gccversion})) { + push @EUMM_INC_LIB, (LDDLFLAGS => "$Config{lddlflags} -Wl,--exclude-libs,ALL"); +} + +my %eumm_args = ( + 'NAME' => 'File::KDBX::XS', + 'VERSION' => '999.999', + 'ABSTRACT' => 'Speed up File::KDBX', + 'AUTHOR' => 'Charles McGarvey ', + 'DISTNAME' => 'File-KDBX-XS', + 'LICENSE' => 'perl', + 'MIN_PERL_VERSION' => '5.006', + 'VERSION' => '0.900', + 'test' => { + 'TESTS' => 't/*.t' + }, + 'CONFIGURE_REQUIRES' => { + 'ExtUtils::MakeMaker' => '0' + }, + 'PREREQ_PM' => { + 'XSLoader' => '0', + 'strict' => '0', + 'warnings' => '0' + }, + 'TEST_REQUIRES' => { + 'ExtUtils::MakeMaker' => '0', + 'File::Spec' => '0', + 'IO::Handle' => '0', + 'IPC::Open3' => '0', + 'Test::More' => '0' + }, + @EUMM_INC_LIB, +); + +my $eumm_ver = eval $ExtUtils::MakeMaker::VERSION; +delete $eumm_args{MIN_PERL_VERSION} if $eumm_ver < 6.48; +delete $eumm_args{META_ADD} if $eumm_ver < 6.46; +delete $eumm_args{META_MERGE} if $eumm_ver < 6.46; +delete $eumm_args{LICENSE} if $eumm_ver < 6.31; +delete $eumm_args{CONFIGURE_REQUIRES} if $eumm_ver < 6.52; +delete $eumm_args{BUILD_REQUIRES} if $eumm_ver < 6.56; +delete $eumm_args{TEST_REQUIRES} if $eumm_ver < 6.64; + +WriteMakefile(%eumm_args); + +sub MY::postamble { + return "" unless $mycflags && $myarflags; + + my $extra_targets = qq{ +\$(MYEXTLIB): libtomcrypt/Makefile +\tcd libtomcrypt && \$(MAKE) ARFLAGS="$myarflags" RANLIB="\$(RANLIB)" AR="\$(AR)" CC="\$(CC)" LIB_EXT=\$(LIB_EXT) OBJ_EXT=\$(OBJ_EXT) CFLAGS="$mycflags" +}; + + $extra_targets = qq{ +\$(MYEXTLIB): libtomcrypt/Makefile.nmake +\tcd libtomcrypt && \$(MAKE) -f Makefile.nmake CFLAGS="$mycflags" +} if $^O eq 'MSWin32' && $Config{make} =~ /nmake/ && $Config{cc} =~ /cl/; + + $extra_targets = qq{ +\$(MYEXTLIB): libtomcrypt/Makefile +\tcd libtomcrypt && \$(MAKE) CC="$Config{cc}" CFLAGS="$mycflags" +} if $^O eq 'MSWin32' && $Config{cc} =~ /gcc/; + + return $extra_targets; +} + + diff --git a/README b/README new file mode 100644 index 0000000..eb9d87b --- /dev/null +++ b/README @@ -0,0 +1,50 @@ +NAME + + File::KDBX::XS - Speed up File::KDBX + +VERSION + + version 0.900 + +DESCRIPTION + + This module provides some speed improvement for File::KDBX. + + There is no public interface. + + This distribution contains code from CryptX and LibTomCrypt + , bundled according to their own + licensing terms (which are also permissive). + +FUNCTIONS + + CowREFCNT + + Get the copy-on-write (COW) reference count of a scalar, or undef if + the perl does not support scalar COW or if the scalar is not COW. + + See also "cowrefcnt( PV )" in B::COW. + +BUGS + + Please report any bugs or feature requests on the bugtracker website + https://github.com/chazmcgarvey/File-KDBX-XS/issues + + When submitting a bug or request, please include a test-file or a patch + to an existing test-file that illustrates the bug or desired feature. + +AUTHOR + + Charles McGarvey + +CONTRIBUTOR + + Karel Miko + +COPYRIGHT AND LICENSE + + This software is copyright (c) 2022 by Charles McGarvey. + + This is free software; you can redistribute it and/or modify it under + the same terms as the Perl 5 programming language system itself. + diff --git a/XS.xs b/XS.xs new file mode 100644 index 0000000..48f3077 --- /dev/null +++ b/XS.xs @@ -0,0 +1,43 @@ +#define PERL_NO_GET_CONTEXT +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" +#include "ppport.h" + +#include "tomcrypt.h" + +MODULE = File::KDBX::XS PACKAGE = File::KDBX::XS + +PROTOTYPES: DISABLE + +SV* +CowREFCNT(SV* sv) + CODE: +#ifdef SV_COW_REFCNT_MAX + if (SvIsCOW(sv)) XSRETURN_IV(0 < SvLEN(sv) ? CowREFCNT(sv) : 0); +#endif + XSRETURN_UNDEF; + OUTPUT: + RETVAL + +SV* +kdf_aes_transform_half(const char* key, const char* seed, unsigned int rounds) + CODE: + symmetric_key skey; + + unsigned char work[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + Copy(seed, work, 1, work); + + aes_setup(key, 32, 14, &skey); + for (unsigned int i = 0; i < rounds; ++i) { + aes_ecb_encrypt(work, work, &skey); + } + + SV* result = newSVpvn(work, sizeof(work)); + + Zero(&skey, 1, skey); + Zero(work, 1, work); + + RETVAL = result; + OUTPUT: + RETVAL diff --git a/eg/benchmark.pl b/eg/benchmark.pl new file mode 100755 index 0000000..57bd313 --- /dev/null +++ b/eg/benchmark.pl @@ -0,0 +1,55 @@ +#!/usr/bin/env perl + +use warnings; +use strict; + +use Crypt::Rijndael; +use Crypt::Cipher; +use File::KDBX::XS; + +use Benchmark qw(:all :hireswallclock); +use Test::More; + +my $iterations = shift // 50; + +my $rounds = 500_000; +my $key = "\1" x 32; +my $seed = "\1" x 16; +my $expected = pack('H*', '3f7dfb512060cc8be094cd259c7ff03c'); + +sub xs { + my $result = File::KDBX::KDF::AES::_transform_half_xs($key, $seed, $rounds); + return $result; +} + +sub cryptx { + my $cipher = Crypt::Cipher->new('AES', $key); + my $result = $seed; + for (my $i = 0; $i < $rounds; ++$i) { + $result = $cipher->encrypt($result); + } + return $result; +} + +sub crypt_rijndael { + my $cipher = Crypt::Rijndael->new($key, Crypt::Rijndael::MODE_ECB()); + my $result = $seed; + for (my $i = 0; $i < $rounds; ++$i) { + $result = $cipher->encrypt($result); + } + return $result; +} + +my $r = xs(); +is $r, $expected, 'AES KDF transform works' or diag explain unpack('H*', $r); +is $r, cryptx(), 'XS transform agrees with CryptX'; +is $r, crypt_rijndael(), 'XS transform agrees with Crypt::Rijndael'; + +done_testing; + +my $timings = timethese($iterations, { + crypt_rijndael => \&crypt_rijndael, + cryptx => \&cryptx, + xs => \&xs, +}); +cmpthese($timings); diff --git a/lib/File/KDBX/XS.pm b/lib/File/KDBX/XS.pm new file mode 100644 index 0000000..7904ad5 --- /dev/null +++ b/lib/File/KDBX/XS.pm @@ -0,0 +1,83 @@ +package File::KDBX::XS; +# ABSTRACT: Speed up File::KDBX + +use warnings; +use strict; + +use XSLoader; + +our $VERSION = '0.900'; # VERSION + +XSLoader::load(__PACKAGE__, $VERSION); + +1; + +__END__ + +=pod + +=encoding UTF-8 + +=head1 NAME + +File::KDBX::XS - Speed up File::KDBX + +=head1 VERSION + +version 0.900 + +=head1 DESCRIPTION + +This module provides some speed improvement for L. + +There is no public interface. + +This distribution contains code from L and L, +bundled according to their own licensing terms (which are also permissive). + +=head1 FUNCTIONS + +=head2 CowREFCNT + +Get the copy-on-write (COW) reference count of a scalar, or C if the perl does not support scalar COW +or if the scalar is not COW. + +See also L. + +=for markdown [![Linux](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/linux.yml/badge.svg)](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/linux.yml) +[![macOS](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/macos.yml/badge.svg)](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/macos.yml) +[![Windows](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/windows.yml/badge.svg)](https://github.com/chazmcgarvey/File-KDBX-XS/actions/workflows/windows.yml) + +=for HTML + + + +=for Pod::Coverage kdf_aes_transform_half + +=head1 BUGS + +Please report any bugs or feature requests on the bugtracker website +L + +When submitting a bug or request, please include a test-file or a +patch to an existing test-file that illustrates the bug or desired +feature. + +=head1 AUTHOR + +Charles McGarvey + +=head1 CONTRIBUTOR + +=for stopwords Karel Miko + +Karel Miko + +=head1 COPYRIGHT AND LICENSE + +This software is copyright (c) 2022 by Charles McGarvey. + +This is free software; you can redistribute it and/or modify it under +the same terms as the Perl 5 programming language system itself. + +=cut diff --git a/libtomcrypt/LICENSE b/libtomcrypt/LICENSE new file mode 100644 index 0000000..b23b3c8 --- /dev/null +++ b/libtomcrypt/LICENSE @@ -0,0 +1,26 @@ + The LibTom license + +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to diff --git a/libtomcrypt/Makefile b/libtomcrypt/Makefile new file mode 100644 index 0000000..6a3a36f --- /dev/null +++ b/libtomcrypt/Makefile @@ -0,0 +1,22 @@ +OBJS = src/ciphers/aes/aes.o src/misc/crypt/crypt_argchk.o src/misc/compare_testvector.o src/misc/zeromem.o + +LIB_EXT =.a +OBJ_EXT =.o +PERL =perl +RANLIB =ranlib +AR =ar +ARFLAGS =cr +RM_F =$(PERL) -MExtUtils::Command -e rm_f -- + +libonlyaes$(LIB_EXT): $(OBJS) + $(AR) $(ARFLAGS) $@ $(OBJS) + $(RANLIB) $@ + +clean: + $(RM_F) $(OBJS) libonlyaes$(LIB_EXT) + +#this is necessary for compatibility with BSD make (namely on OpenBSD) +.SUFFIXES: .o .c + +.c$(OBJ_EXT): + $(CC) -Isrc/headers -DLTC_SOURCE -DLTC_NO_TEST -DLTC_NO_PROTOTYPES -DLTM_DESC $(CFLAGS) -DARGTYPE=4 -c $< -o $@ diff --git a/libtomcrypt/Makefile.nmake b/libtomcrypt/Makefile.nmake new file mode 100644 index 0000000..a5e7cce --- /dev/null +++ b/libtomcrypt/Makefile.nmake @@ -0,0 +1,13 @@ +OBJS = src/ciphers/aes/aes.obj src/misc/crypt/crypt_argchk.obj src/misc/compare_testvector.obj src/misc/zeromem.obj + +PERL =perl +RM_F =$(PERL) -MExtUtils::Command -e rm_f -- + +libonlyaes.lib: $(OBJS) + lib /OUT:$@ $(OBJS) + +clean: + $(RM_F) $(OBJS) libonlyaes.lib + +.c.obj: + cl /Isrc/headers /DLTC_SOURCE /DLTC_NO_TEST /DLTC_NO_PROTOTYPES /DLTM_DESC /DARGTYPE=4 $(CFLAGS) /c $< /Fo$@ diff --git a/libtomcrypt/README b/libtomcrypt/README new file mode 100644 index 0000000..5ac3d4f --- /dev/null +++ b/libtomcrypt/README @@ -0,0 +1,5 @@ +# libtomcrypt - but only AES + +The complete code can be found online: https://github.com/libtom/libtomcrypt + +The software in this directory is under the LibTom license (see LICENSE). diff --git a/libtomcrypt/src/ciphers/aes/aes.c b/libtomcrypt/src/ciphers/aes/aes.c new file mode 100644 index 0000000..dd6f14e --- /dev/null +++ b/libtomcrypt/src/ciphers/aes/aes.c @@ -0,0 +1,744 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* AES implementation by Tom St Denis + * + * Derived from the Public Domain source code by + +--- + * rijndael-alg-fst.c + * + * @version 3.0 (December 2000) + * + * Optimised ANSI C code for the Rijndael cipher (now AES) + * + * @author Vincent Rijmen + * @author Antoon Bosselaers + * @author Paulo Barreto +--- + */ +/** + @file aes.c + Implementation of AES +*/ + +#include "tomcrypt_private.h" + +#ifdef LTC_RIJNDAEL + +#ifndef ENCRYPT_ONLY + +#define SETUP rijndael_setup +#define ECB_ENC rijndael_ecb_encrypt +#define ECB_DEC rijndael_ecb_decrypt +#define ECB_DONE rijndael_done +#define ECB_TEST rijndael_test +#define ECB_KS rijndael_keysize + +const struct ltc_cipher_descriptor rijndael_desc = +{ + "rijndael", + 6, + 16, 32, 16, 10, + SETUP, ECB_ENC, ECB_DEC, ECB_TEST, ECB_DONE, ECB_KS, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +const struct ltc_cipher_descriptor aes_desc = +{ + "aes", + 6, + 16, 32, 16, 10, + SETUP, ECB_ENC, ECB_DEC, ECB_TEST, ECB_DONE, ECB_KS, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +#else + +#define SETUP rijndael_enc_setup +#define ECB_ENC rijndael_enc_ecb_encrypt +#define ECB_KS rijndael_enc_keysize +#define ECB_DONE rijndael_enc_done + +const struct ltc_cipher_descriptor rijndael_enc_desc = +{ + "rijndael", + 6, + 16, 32, 16, 10, + SETUP, ECB_ENC, NULL, NULL, ECB_DONE, ECB_KS, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +const struct ltc_cipher_descriptor aes_enc_desc = +{ + "aes", + 6, + 16, 32, 16, 10, + SETUP, ECB_ENC, NULL, NULL, ECB_DONE, ECB_KS, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL +}; + +#endif + +#define LTC_AES_TAB_C +#include "aes_tab.c" + +static ulong32 setup_mix(ulong32 temp) +{ + return (Te4_3[LTC_BYTE(temp, 2)]) ^ + (Te4_2[LTC_BYTE(temp, 1)]) ^ + (Te4_1[LTC_BYTE(temp, 0)]) ^ + (Te4_0[LTC_BYTE(temp, 3)]); +} + +#ifndef ENCRYPT_ONLY +#ifdef LTC_SMALL_CODE +static ulong32 setup_mix2(ulong32 temp) +{ + return Td0(255 & Te4[LTC_BYTE(temp, 3)]) ^ + Td1(255 & Te4[LTC_BYTE(temp, 2)]) ^ + Td2(255 & Te4[LTC_BYTE(temp, 1)]) ^ + Td3(255 & Te4[LTC_BYTE(temp, 0)]); +} +#endif +#endif + + /** + Initialize the AES (Rijndael) block cipher + @param key The symmetric key you wish to pass + @param keylen The key length in bytes + @param num_rounds The number of rounds desired (0 for default) + @param skey The key in as scheduled by this function. + @return CRYPT_OK if successful + */ +int SETUP(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey) +{ + int i; + ulong32 temp, *rk; +#ifndef ENCRYPT_ONLY + ulong32 *rrk; +#endif + LTC_ARGCHK(key != NULL); + LTC_ARGCHK(skey != NULL); + + if (keylen != 16 && keylen != 24 && keylen != 32) { + return CRYPT_INVALID_KEYSIZE; + } + + if (num_rounds != 0 && num_rounds != (10 + ((keylen/8)-2)*2)) { + return CRYPT_INVALID_ROUNDS; + } + + skey->rijndael.Nr = 10 + ((keylen/8)-2)*2; + + /* setup the forward key */ + i = 0; + rk = skey->rijndael.eK; + LOAD32H(rk[0], key ); + LOAD32H(rk[1], key + 4); + LOAD32H(rk[2], key + 8); + LOAD32H(rk[3], key + 12); + if (keylen == 16) { + for (;;) { + temp = rk[3]; + rk[4] = rk[0] ^ setup_mix(temp) ^ rcon[i]; + rk[5] = rk[1] ^ rk[4]; + rk[6] = rk[2] ^ rk[5]; + rk[7] = rk[3] ^ rk[6]; + if (++i == 10) { + break; + } + rk += 4; + } + } else if (keylen == 24) { + LOAD32H(rk[4], key + 16); + LOAD32H(rk[5], key + 20); + for (;;) { + #ifdef _MSC_VER + temp = skey->rijndael.eK[rk - skey->rijndael.eK + 5]; + #else + temp = rk[5]; + #endif + rk[ 6] = rk[ 0] ^ setup_mix(temp) ^ rcon[i]; + rk[ 7] = rk[ 1] ^ rk[ 6]; + rk[ 8] = rk[ 2] ^ rk[ 7]; + rk[ 9] = rk[ 3] ^ rk[ 8]; + if (++i == 8) { + break; + } + rk[10] = rk[ 4] ^ rk[ 9]; + rk[11] = rk[ 5] ^ rk[10]; + rk += 6; + } + } else if (keylen == 32) { + LOAD32H(rk[4], key + 16); + LOAD32H(rk[5], key + 20); + LOAD32H(rk[6], key + 24); + LOAD32H(rk[7], key + 28); + for (;;) { + #ifdef _MSC_VER + temp = skey->rijndael.eK[rk - skey->rijndael.eK + 7]; + #else + temp = rk[7]; + #endif + rk[ 8] = rk[ 0] ^ setup_mix(temp) ^ rcon[i]; + rk[ 9] = rk[ 1] ^ rk[ 8]; + rk[10] = rk[ 2] ^ rk[ 9]; + rk[11] = rk[ 3] ^ rk[10]; + if (++i == 7) { + break; + } + temp = rk[11]; + rk[12] = rk[ 4] ^ setup_mix(RORc(temp, 8)); + rk[13] = rk[ 5] ^ rk[12]; + rk[14] = rk[ 6] ^ rk[13]; + rk[15] = rk[ 7] ^ rk[14]; + rk += 8; + } + } else { + /* this can't happen */ + /* coverity[dead_error_line] */ + return CRYPT_ERROR; + } + +#ifndef ENCRYPT_ONLY + /* setup the inverse key now */ + rk = skey->rijndael.dK; + rrk = skey->rijndael.eK + (28 + keylen) - 4; + + /* apply the inverse MixColumn transform to all round keys but the first and the last: */ + /* copy first */ + *rk++ = *rrk++; + *rk++ = *rrk++; + *rk++ = *rrk++; + *rk = *rrk; + rk -= 3; rrk -= 3; + + for (i = 1; i < skey->rijndael.Nr; i++) { + rrk -= 4; + rk += 4; + #ifdef LTC_SMALL_CODE + temp = rrk[0]; + rk[0] = setup_mix2(temp); + temp = rrk[1]; + rk[1] = setup_mix2(temp); + temp = rrk[2]; + rk[2] = setup_mix2(temp); + temp = rrk[3]; + rk[3] = setup_mix2(temp); + #else + temp = rrk[0]; + rk[0] = + Tks0[LTC_BYTE(temp, 3)] ^ + Tks1[LTC_BYTE(temp, 2)] ^ + Tks2[LTC_BYTE(temp, 1)] ^ + Tks3[LTC_BYTE(temp, 0)]; + temp = rrk[1]; + rk[1] = + Tks0[LTC_BYTE(temp, 3)] ^ + Tks1[LTC_BYTE(temp, 2)] ^ + Tks2[LTC_BYTE(temp, 1)] ^ + Tks3[LTC_BYTE(temp, 0)]; + temp = rrk[2]; + rk[2] = + Tks0[LTC_BYTE(temp, 3)] ^ + Tks1[LTC_BYTE(temp, 2)] ^ + Tks2[LTC_BYTE(temp, 1)] ^ + Tks3[LTC_BYTE(temp, 0)]; + temp = rrk[3]; + rk[3] = + Tks0[LTC_BYTE(temp, 3)] ^ + Tks1[LTC_BYTE(temp, 2)] ^ + Tks2[LTC_BYTE(temp, 1)] ^ + Tks3[LTC_BYTE(temp, 0)]; + #endif + + } + + /* copy last */ + rrk -= 4; + rk += 4; + *rk++ = *rrk++; + *rk++ = *rrk++; + *rk++ = *rrk++; + *rk = *rrk; +#endif /* ENCRYPT_ONLY */ + + return CRYPT_OK; +} + +/** + Encrypts a block of text with AES + @param pt The input plaintext (16 bytes) + @param ct The output ciphertext (16 bytes) + @param skey The key as scheduled + @return CRYPT_OK if successful +*/ +#ifdef LTC_CLEAN_STACK +static int s_rijndael_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey) +#else +int ECB_ENC(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey) +#endif +{ + ulong32 s0, s1, s2, s3, t0, t1, t2, t3; + const ulong32 *rk; + int Nr, r; + + LTC_ARGCHK(pt != NULL); + LTC_ARGCHK(ct != NULL); + LTC_ARGCHK(skey != NULL); + + Nr = skey->rijndael.Nr; + + if (Nr < 2 || Nr > 16) + return CRYPT_INVALID_ROUNDS; + + rk = skey->rijndael.eK; + + /* + * map byte array block to cipher state + * and add initial round key: + */ + LOAD32H(s0, pt ); s0 ^= rk[0]; + LOAD32H(s1, pt + 4); s1 ^= rk[1]; + LOAD32H(s2, pt + 8); s2 ^= rk[2]; + LOAD32H(s3, pt + 12); s3 ^= rk[3]; + +#ifdef LTC_SMALL_CODE + + for (r = 0; ; r++) { + rk += 4; + t0 = + Te0(LTC_BYTE(s0, 3)) ^ + Te1(LTC_BYTE(s1, 2)) ^ + Te2(LTC_BYTE(s2, 1)) ^ + Te3(LTC_BYTE(s3, 0)) ^ + rk[0]; + t1 = + Te0(LTC_BYTE(s1, 3)) ^ + Te1(LTC_BYTE(s2, 2)) ^ + Te2(LTC_BYTE(s3, 1)) ^ + Te3(LTC_BYTE(s0, 0)) ^ + rk[1]; + t2 = + Te0(LTC_BYTE(s2, 3)) ^ + Te1(LTC_BYTE(s3, 2)) ^ + Te2(LTC_BYTE(s0, 1)) ^ + Te3(LTC_BYTE(s1, 0)) ^ + rk[2]; + t3 = + Te0(LTC_BYTE(s3, 3)) ^ + Te1(LTC_BYTE(s0, 2)) ^ + Te2(LTC_BYTE(s1, 1)) ^ + Te3(LTC_BYTE(s2, 0)) ^ + rk[3]; + if (r == Nr-2) { + break; + } + s0 = t0; s1 = t1; s2 = t2; s3 = t3; + } + rk += 4; + +#else + + /* + * Nr - 1 full rounds: + */ + r = Nr >> 1; + for (;;) { + t0 = + Te0(LTC_BYTE(s0, 3)) ^ + Te1(LTC_BYTE(s1, 2)) ^ + Te2(LTC_BYTE(s2, 1)) ^ + Te3(LTC_BYTE(s3, 0)) ^ + rk[4]; + t1 = + Te0(LTC_BYTE(s1, 3)) ^ + Te1(LTC_BYTE(s2, 2)) ^ + Te2(LTC_BYTE(s3, 1)) ^ + Te3(LTC_BYTE(s0, 0)) ^ + rk[5]; + t2 = + Te0(LTC_BYTE(s2, 3)) ^ + Te1(LTC_BYTE(s3, 2)) ^ + Te2(LTC_BYTE(s0, 1)) ^ + Te3(LTC_BYTE(s1, 0)) ^ + rk[6]; + t3 = + Te0(LTC_BYTE(s3, 3)) ^ + Te1(LTC_BYTE(s0, 2)) ^ + Te2(LTC_BYTE(s1, 1)) ^ + Te3(LTC_BYTE(s2, 0)) ^ + rk[7]; + + rk += 8; + if (--r == 0) { + break; + } + + s0 = + Te0(LTC_BYTE(t0, 3)) ^ + Te1(LTC_BYTE(t1, 2)) ^ + Te2(LTC_BYTE(t2, 1)) ^ + Te3(LTC_BYTE(t3, 0)) ^ + rk[0]; + s1 = + Te0(LTC_BYTE(t1, 3)) ^ + Te1(LTC_BYTE(t2, 2)) ^ + Te2(LTC_BYTE(t3, 1)) ^ + Te3(LTC_BYTE(t0, 0)) ^ + rk[1]; + s2 = + Te0(LTC_BYTE(t2, 3)) ^ + Te1(LTC_BYTE(t3, 2)) ^ + Te2(LTC_BYTE(t0, 1)) ^ + Te3(LTC_BYTE(t1, 0)) ^ + rk[2]; + s3 = + Te0(LTC_BYTE(t3, 3)) ^ + Te1(LTC_BYTE(t0, 2)) ^ + Te2(LTC_BYTE(t1, 1)) ^ + Te3(LTC_BYTE(t2, 0)) ^ + rk[3]; + } + +#endif + + /* + * apply last round and + * map cipher state to byte array block: + */ + s0 = + (Te4_3[LTC_BYTE(t0, 3)]) ^ + (Te4_2[LTC_BYTE(t1, 2)]) ^ + (Te4_1[LTC_BYTE(t2, 1)]) ^ + (Te4_0[LTC_BYTE(t3, 0)]) ^ + rk[0]; + STORE32H(s0, ct); + s1 = + (Te4_3[LTC_BYTE(t1, 3)]) ^ + (Te4_2[LTC_BYTE(t2, 2)]) ^ + (Te4_1[LTC_BYTE(t3, 1)]) ^ + (Te4_0[LTC_BYTE(t0, 0)]) ^ + rk[1]; + STORE32H(s1, ct+4); + s2 = + (Te4_3[LTC_BYTE(t2, 3)]) ^ + (Te4_2[LTC_BYTE(t3, 2)]) ^ + (Te4_1[LTC_BYTE(t0, 1)]) ^ + (Te4_0[LTC_BYTE(t1, 0)]) ^ + rk[2]; + STORE32H(s2, ct+8); + s3 = + (Te4_3[LTC_BYTE(t3, 3)]) ^ + (Te4_2[LTC_BYTE(t0, 2)]) ^ + (Te4_1[LTC_BYTE(t1, 1)]) ^ + (Te4_0[LTC_BYTE(t2, 0)]) ^ + rk[3]; + STORE32H(s3, ct+12); + + return CRYPT_OK; +} + +#ifdef LTC_CLEAN_STACK +int ECB_ENC(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey) +{ + int err = s_rijndael_ecb_encrypt(pt, ct, skey); + burn_stack(sizeof(unsigned long)*8 + sizeof(unsigned long*) + sizeof(int)*2); + return err; +} +#endif + +#ifndef ENCRYPT_ONLY + +/** + Decrypts a block of text with AES + @param ct The input ciphertext (16 bytes) + @param pt The output plaintext (16 bytes) + @param skey The key as scheduled + @return CRYPT_OK if successful +*/ +#ifdef LTC_CLEAN_STACK +static int s_rijndael_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey) +#else +int ECB_DEC(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey) +#endif +{ + ulong32 s0, s1, s2, s3, t0, t1, t2, t3; + const ulong32 *rk; + int Nr, r; + + LTC_ARGCHK(pt != NULL); + LTC_ARGCHK(ct != NULL); + LTC_ARGCHK(skey != NULL); + + Nr = skey->rijndael.Nr; + + if (Nr < 2 || Nr > 16) + return CRYPT_INVALID_ROUNDS; + + rk = skey->rijndael.dK; + + /* + * map byte array block to cipher state + * and add initial round key: + */ + LOAD32H(s0, ct ); s0 ^= rk[0]; + LOAD32H(s1, ct + 4); s1 ^= rk[1]; + LOAD32H(s2, ct + 8); s2 ^= rk[2]; + LOAD32H(s3, ct + 12); s3 ^= rk[3]; + +#ifdef LTC_SMALL_CODE + for (r = 0; ; r++) { + rk += 4; + t0 = + Td0(LTC_BYTE(s0, 3)) ^ + Td1(LTC_BYTE(s3, 2)) ^ + Td2(LTC_BYTE(s2, 1)) ^ + Td3(LTC_BYTE(s1, 0)) ^ + rk[0]; + t1 = + Td0(LTC_BYTE(s1, 3)) ^ + Td1(LTC_BYTE(s0, 2)) ^ + Td2(LTC_BYTE(s3, 1)) ^ + Td3(LTC_BYTE(s2, 0)) ^ + rk[1]; + t2 = + Td0(LTC_BYTE(s2, 3)) ^ + Td1(LTC_BYTE(s1, 2)) ^ + Td2(LTC_BYTE(s0, 1)) ^ + Td3(LTC_BYTE(s3, 0)) ^ + rk[2]; + t3 = + Td0(LTC_BYTE(s3, 3)) ^ + Td1(LTC_BYTE(s2, 2)) ^ + Td2(LTC_BYTE(s1, 1)) ^ + Td3(LTC_BYTE(s0, 0)) ^ + rk[3]; + if (r == Nr-2) { + break; + } + s0 = t0; s1 = t1; s2 = t2; s3 = t3; + } + rk += 4; + +#else + + /* + * Nr - 1 full rounds: + */ + r = Nr >> 1; + for (;;) { + + t0 = + Td0(LTC_BYTE(s0, 3)) ^ + Td1(LTC_BYTE(s3, 2)) ^ + Td2(LTC_BYTE(s2, 1)) ^ + Td3(LTC_BYTE(s1, 0)) ^ + rk[4]; + t1 = + Td0(LTC_BYTE(s1, 3)) ^ + Td1(LTC_BYTE(s0, 2)) ^ + Td2(LTC_BYTE(s3, 1)) ^ + Td3(LTC_BYTE(s2, 0)) ^ + rk[5]; + t2 = + Td0(LTC_BYTE(s2, 3)) ^ + Td1(LTC_BYTE(s1, 2)) ^ + Td2(LTC_BYTE(s0, 1)) ^ + Td3(LTC_BYTE(s3, 0)) ^ + rk[6]; + t3 = + Td0(LTC_BYTE(s3, 3)) ^ + Td1(LTC_BYTE(s2, 2)) ^ + Td2(LTC_BYTE(s1, 1)) ^ + Td3(LTC_BYTE(s0, 0)) ^ + rk[7]; + + rk += 8; + if (--r == 0) { + break; + } + + + s0 = + Td0(LTC_BYTE(t0, 3)) ^ + Td1(LTC_BYTE(t3, 2)) ^ + Td2(LTC_BYTE(t2, 1)) ^ + Td3(LTC_BYTE(t1, 0)) ^ + rk[0]; + s1 = + Td0(LTC_BYTE(t1, 3)) ^ + Td1(LTC_BYTE(t0, 2)) ^ + Td2(LTC_BYTE(t3, 1)) ^ + Td3(LTC_BYTE(t2, 0)) ^ + rk[1]; + s2 = + Td0(LTC_BYTE(t2, 3)) ^ + Td1(LTC_BYTE(t1, 2)) ^ + Td2(LTC_BYTE(t0, 1)) ^ + Td3(LTC_BYTE(t3, 0)) ^ + rk[2]; + s3 = + Td0(LTC_BYTE(t3, 3)) ^ + Td1(LTC_BYTE(t2, 2)) ^ + Td2(LTC_BYTE(t1, 1)) ^ + Td3(LTC_BYTE(t0, 0)) ^ + rk[3]; + } +#endif + + /* + * apply last round and + * map cipher state to byte array block: + */ + s0 = + (Td4[LTC_BYTE(t0, 3)] & 0xff000000) ^ + (Td4[LTC_BYTE(t3, 2)] & 0x00ff0000) ^ + (Td4[LTC_BYTE(t2, 1)] & 0x0000ff00) ^ + (Td4[LTC_BYTE(t1, 0)] & 0x000000ff) ^ + rk[0]; + STORE32H(s0, pt); + s1 = + (Td4[LTC_BYTE(t1, 3)] & 0xff000000) ^ + (Td4[LTC_BYTE(t0, 2)] & 0x00ff0000) ^ + (Td4[LTC_BYTE(t3, 1)] & 0x0000ff00) ^ + (Td4[LTC_BYTE(t2, 0)] & 0x000000ff) ^ + rk[1]; + STORE32H(s1, pt+4); + s2 = + (Td4[LTC_BYTE(t2, 3)] & 0xff000000) ^ + (Td4[LTC_BYTE(t1, 2)] & 0x00ff0000) ^ + (Td4[LTC_BYTE(t0, 1)] & 0x0000ff00) ^ + (Td4[LTC_BYTE(t3, 0)] & 0x000000ff) ^ + rk[2]; + STORE32H(s2, pt+8); + s3 = + (Td4[LTC_BYTE(t3, 3)] & 0xff000000) ^ + (Td4[LTC_BYTE(t2, 2)] & 0x00ff0000) ^ + (Td4[LTC_BYTE(t1, 1)] & 0x0000ff00) ^ + (Td4[LTC_BYTE(t0, 0)] & 0x000000ff) ^ + rk[3]; + STORE32H(s3, pt+12); + + return CRYPT_OK; +} + + +#ifdef LTC_CLEAN_STACK +int ECB_DEC(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey) +{ + int err = s_rijndael_ecb_decrypt(ct, pt, skey); + burn_stack(sizeof(unsigned long)*8 + sizeof(unsigned long*) + sizeof(int)*2); + return err; +} +#endif + +/** + Performs a self-test of the AES block cipher + @return CRYPT_OK if functional, CRYPT_NOP if self-test has been disabled +*/ +int ECB_TEST(void) +{ + #ifndef LTC_TEST + return CRYPT_NOP; + #else + int err; + static const struct { + int keylen; + unsigned char key[32], pt[16], ct[16]; + } tests[] = { + { 16, + { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f }, + { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, + { 0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30, + 0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a } + }, { + 24, + { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 }, + { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, + { 0xdd, 0xa9, 0x7c, 0xa4, 0x86, 0x4c, 0xdf, 0xe0, + 0x6e, 0xaf, 0x70, 0xa0, 0xec, 0x0d, 0x71, 0x91 } + }, { + 32, + { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f }, + { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, + 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff }, + { 0x8e, 0xa2, 0xb7, 0xca, 0x51, 0x67, 0x45, 0xbf, + 0xea, 0xfc, 0x49, 0x90, 0x4b, 0x49, 0x60, 0x89 } + } + }; + + symmetric_key key; + unsigned char tmp[2][16]; + int i, y; + + for (i = 0; i < (int)(sizeof(tests)/sizeof(tests[0])); i++) { + zeromem(&key, sizeof(key)); + if ((err = rijndael_setup(tests[i].key, tests[i].keylen, 0, &key)) != CRYPT_OK) { + return err; + } + + rijndael_ecb_encrypt(tests[i].pt, tmp[0], &key); + rijndael_ecb_decrypt(tmp[0], tmp[1], &key); + if (compare_testvector(tmp[0], 16, tests[i].ct, 16, "AES Encrypt", i) || + compare_testvector(tmp[1], 16, tests[i].pt, 16, "AES Decrypt", i)) { + return CRYPT_FAIL_TESTVECTOR; + } + + /* now see if we can encrypt all zero bytes 1000 times, decrypt and come back where we started */ + for (y = 0; y < 16; y++) tmp[0][y] = 0; + for (y = 0; y < 1000; y++) rijndael_ecb_encrypt(tmp[0], tmp[0], &key); + for (y = 0; y < 1000; y++) rijndael_ecb_decrypt(tmp[0], tmp[0], &key); + for (y = 0; y < 16; y++) if (tmp[0][y] != 0) return CRYPT_FAIL_TESTVECTOR; + } + return CRYPT_OK; + #endif +} + +#endif /* ENCRYPT_ONLY */ + + +/** Terminate the context + @param skey The scheduled key +*/ +void ECB_DONE(symmetric_key *skey) +{ + LTC_UNUSED_PARAM(skey); +} + + +/** + Gets suitable key size + @param keysize [in/out] The length of the recommended key (in bytes). This function will store the suitable size back in this variable. + @return CRYPT_OK if the input key size is acceptable. +*/ +int ECB_KS(int *keysize) +{ + LTC_ARGCHK(keysize != NULL); + + if (*keysize < 16) { + return CRYPT_INVALID_KEYSIZE; + } + if (*keysize < 24) { + *keysize = 16; + return CRYPT_OK; + } + if (*keysize < 32) { + *keysize = 24; + return CRYPT_OK; + } + *keysize = 32; + return CRYPT_OK; +} + +#endif + diff --git a/libtomcrypt/src/ciphers/aes/aes_tab.c b/libtomcrypt/src/ciphers/aes/aes_tab.c new file mode 100644 index 0000000..5e59004 --- /dev/null +++ b/libtomcrypt/src/ciphers/aes/aes_tab.c @@ -0,0 +1,1022 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ +/* The precomputed tables for AES */ +/* +Te0[x] = S [x].[02, 01, 01, 03]; +Te1[x] = S [x].[03, 02, 01, 01]; +Te2[x] = S [x].[01, 03, 02, 01]; +Te3[x] = S [x].[01, 01, 03, 02]; +Te4[x] = S [x].[01, 01, 01, 01]; + +Td0[x] = Si[x].[0e, 09, 0d, 0b]; +Td1[x] = Si[x].[0b, 0e, 09, 0d]; +Td2[x] = Si[x].[0d, 0b, 0e, 09]; +Td3[x] = Si[x].[09, 0d, 0b, 0e]; +Td4[x] = Si[x].[01, 01, 01, 01]; +*/ + +#ifdef LTC_AES_TAB_C + +/** + @file aes_tab.c + AES tables +*/ +static const ulong32 TE0[256] = { + 0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL, + 0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL, + 0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL, + 0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL, + 0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL, + 0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL, + 0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL, + 0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL, + 0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL, + 0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL, + 0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL, + 0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL, + 0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL, + 0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL, + 0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL, + 0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL, + 0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL, + 0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL, + 0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL, + 0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL, + 0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL, + 0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL, + 0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL, + 0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL, + 0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL, + 0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL, + 0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL, + 0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL, + 0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL, + 0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL, + 0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL, + 0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL, + 0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL, + 0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL, + 0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL, + 0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL, + 0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL, + 0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL, + 0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL, + 0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL, + 0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL, + 0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL, + 0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL, + 0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL, + 0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL, + 0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL, + 0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL, + 0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL, + 0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL, + 0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL, + 0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL, + 0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL, + 0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL, + 0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL, + 0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL, + 0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL, + 0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL, + 0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL, + 0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL, + 0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL, + 0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL, + 0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL, + 0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL, + 0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL, +}; + +#if !defined(PELI_TAB) && defined(LTC_SMALL_CODE) +static const ulong32 Te4[256] = { + 0x63636363UL, 0x7c7c7c7cUL, 0x77777777UL, 0x7b7b7b7bUL, + 0xf2f2f2f2UL, 0x6b6b6b6bUL, 0x6f6f6f6fUL, 0xc5c5c5c5UL, + 0x30303030UL, 0x01010101UL, 0x67676767UL, 0x2b2b2b2bUL, + 0xfefefefeUL, 0xd7d7d7d7UL, 0xababababUL, 0x76767676UL, + 0xcacacacaUL, 0x82828282UL, 0xc9c9c9c9UL, 0x7d7d7d7dUL, + 0xfafafafaUL, 0x59595959UL, 0x47474747UL, 0xf0f0f0f0UL, + 0xadadadadUL, 0xd4d4d4d4UL, 0xa2a2a2a2UL, 0xafafafafUL, + 0x9c9c9c9cUL, 0xa4a4a4a4UL, 0x72727272UL, 0xc0c0c0c0UL, + 0xb7b7b7b7UL, 0xfdfdfdfdUL, 0x93939393UL, 0x26262626UL, + 0x36363636UL, 0x3f3f3f3fUL, 0xf7f7f7f7UL, 0xccccccccUL, + 0x34343434UL, 0xa5a5a5a5UL, 0xe5e5e5e5UL, 0xf1f1f1f1UL, + 0x71717171UL, 0xd8d8d8d8UL, 0x31313131UL, 0x15151515UL, + 0x04040404UL, 0xc7c7c7c7UL, 0x23232323UL, 0xc3c3c3c3UL, + 0x18181818UL, 0x96969696UL, 0x05050505UL, 0x9a9a9a9aUL, + 0x07070707UL, 0x12121212UL, 0x80808080UL, 0xe2e2e2e2UL, + 0xebebebebUL, 0x27272727UL, 0xb2b2b2b2UL, 0x75757575UL, + 0x09090909UL, 0x83838383UL, 0x2c2c2c2cUL, 0x1a1a1a1aUL, + 0x1b1b1b1bUL, 0x6e6e6e6eUL, 0x5a5a5a5aUL, 0xa0a0a0a0UL, + 0x52525252UL, 0x3b3b3b3bUL, 0xd6d6d6d6UL, 0xb3b3b3b3UL, + 0x29292929UL, 0xe3e3e3e3UL, 0x2f2f2f2fUL, 0x84848484UL, + 0x53535353UL, 0xd1d1d1d1UL, 0x00000000UL, 0xededededUL, + 0x20202020UL, 0xfcfcfcfcUL, 0xb1b1b1b1UL, 0x5b5b5b5bUL, + 0x6a6a6a6aUL, 0xcbcbcbcbUL, 0xbebebebeUL, 0x39393939UL, + 0x4a4a4a4aUL, 0x4c4c4c4cUL, 0x58585858UL, 0xcfcfcfcfUL, + 0xd0d0d0d0UL, 0xefefefefUL, 0xaaaaaaaaUL, 0xfbfbfbfbUL, + 0x43434343UL, 0x4d4d4d4dUL, 0x33333333UL, 0x85858585UL, + 0x45454545UL, 0xf9f9f9f9UL, 0x02020202UL, 0x7f7f7f7fUL, + 0x50505050UL, 0x3c3c3c3cUL, 0x9f9f9f9fUL, 0xa8a8a8a8UL, + 0x51515151UL, 0xa3a3a3a3UL, 0x40404040UL, 0x8f8f8f8fUL, + 0x92929292UL, 0x9d9d9d9dUL, 0x38383838UL, 0xf5f5f5f5UL, + 0xbcbcbcbcUL, 0xb6b6b6b6UL, 0xdadadadaUL, 0x21212121UL, + 0x10101010UL, 0xffffffffUL, 0xf3f3f3f3UL, 0xd2d2d2d2UL, + 0xcdcdcdcdUL, 0x0c0c0c0cUL, 0x13131313UL, 0xececececUL, + 0x5f5f5f5fUL, 0x97979797UL, 0x44444444UL, 0x17171717UL, + 0xc4c4c4c4UL, 0xa7a7a7a7UL, 0x7e7e7e7eUL, 0x3d3d3d3dUL, + 0x64646464UL, 0x5d5d5d5dUL, 0x19191919UL, 0x73737373UL, + 0x60606060UL, 0x81818181UL, 0x4f4f4f4fUL, 0xdcdcdcdcUL, + 0x22222222UL, 0x2a2a2a2aUL, 0x90909090UL, 0x88888888UL, + 0x46464646UL, 0xeeeeeeeeUL, 0xb8b8b8b8UL, 0x14141414UL, + 0xdedededeUL, 0x5e5e5e5eUL, 0x0b0b0b0bUL, 0xdbdbdbdbUL, + 0xe0e0e0e0UL, 0x32323232UL, 0x3a3a3a3aUL, 0x0a0a0a0aUL, + 0x49494949UL, 0x06060606UL, 0x24242424UL, 0x5c5c5c5cUL, + 0xc2c2c2c2UL, 0xd3d3d3d3UL, 0xacacacacUL, 0x62626262UL, + 0x91919191UL, 0x95959595UL, 0xe4e4e4e4UL, 0x79797979UL, + 0xe7e7e7e7UL, 0xc8c8c8c8UL, 0x37373737UL, 0x6d6d6d6dUL, + 0x8d8d8d8dUL, 0xd5d5d5d5UL, 0x4e4e4e4eUL, 0xa9a9a9a9UL, + 0x6c6c6c6cUL, 0x56565656UL, 0xf4f4f4f4UL, 0xeaeaeaeaUL, + 0x65656565UL, 0x7a7a7a7aUL, 0xaeaeaeaeUL, 0x08080808UL, + 0xbabababaUL, 0x78787878UL, 0x25252525UL, 0x2e2e2e2eUL, + 0x1c1c1c1cUL, 0xa6a6a6a6UL, 0xb4b4b4b4UL, 0xc6c6c6c6UL, + 0xe8e8e8e8UL, 0xddddddddUL, 0x74747474UL, 0x1f1f1f1fUL, + 0x4b4b4b4bUL, 0xbdbdbdbdUL, 0x8b8b8b8bUL, 0x8a8a8a8aUL, + 0x70707070UL, 0x3e3e3e3eUL, 0xb5b5b5b5UL, 0x66666666UL, + 0x48484848UL, 0x03030303UL, 0xf6f6f6f6UL, 0x0e0e0e0eUL, + 0x61616161UL, 0x35353535UL, 0x57575757UL, 0xb9b9b9b9UL, + 0x86868686UL, 0xc1c1c1c1UL, 0x1d1d1d1dUL, 0x9e9e9e9eUL, + 0xe1e1e1e1UL, 0xf8f8f8f8UL, 0x98989898UL, 0x11111111UL, + 0x69696969UL, 0xd9d9d9d9UL, 0x8e8e8e8eUL, 0x94949494UL, + 0x9b9b9b9bUL, 0x1e1e1e1eUL, 0x87878787UL, 0xe9e9e9e9UL, + 0xcecececeUL, 0x55555555UL, 0x28282828UL, 0xdfdfdfdfUL, + 0x8c8c8c8cUL, 0xa1a1a1a1UL, 0x89898989UL, 0x0d0d0d0dUL, + 0xbfbfbfbfUL, 0xe6e6e6e6UL, 0x42424242UL, 0x68686868UL, + 0x41414141UL, 0x99999999UL, 0x2d2d2d2dUL, 0x0f0f0f0fUL, + 0xb0b0b0b0UL, 0x54545454UL, 0xbbbbbbbbUL, 0x16161616UL, +}; +#endif + +#ifndef ENCRYPT_ONLY + +static const ulong32 TD0[256] = { + 0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL, + 0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL, + 0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL, + 0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL, + 0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL, + 0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL, + 0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL, + 0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL, + 0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL, + 0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL, + 0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL, + 0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL, + 0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL, + 0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL, + 0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL, + 0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL, + 0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL, + 0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL, + 0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL, + 0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL, + 0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL, + 0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL, + 0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL, + 0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL, + 0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL, + 0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL, + 0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL, + 0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL, + 0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL, + 0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL, + 0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL, + 0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL, + 0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL, + 0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL, + 0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL, + 0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL, + 0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL, + 0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL, + 0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL, + 0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL, + 0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL, + 0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL, + 0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL, + 0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL, + 0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL, + 0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL, + 0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL, + 0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL, + 0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL, + 0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL, + 0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL, + 0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL, + 0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL, + 0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL, + 0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL, + 0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL, + 0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL, + 0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL, + 0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL, + 0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL, + 0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL, + 0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL, + 0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL, + 0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL, +}; + +static const ulong32 Td4[256] = { + 0x52525252UL, 0x09090909UL, 0x6a6a6a6aUL, 0xd5d5d5d5UL, + 0x30303030UL, 0x36363636UL, 0xa5a5a5a5UL, 0x38383838UL, + 0xbfbfbfbfUL, 0x40404040UL, 0xa3a3a3a3UL, 0x9e9e9e9eUL, + 0x81818181UL, 0xf3f3f3f3UL, 0xd7d7d7d7UL, 0xfbfbfbfbUL, + 0x7c7c7c7cUL, 0xe3e3e3e3UL, 0x39393939UL, 0x82828282UL, + 0x9b9b9b9bUL, 0x2f2f2f2fUL, 0xffffffffUL, 0x87878787UL, + 0x34343434UL, 0x8e8e8e8eUL, 0x43434343UL, 0x44444444UL, + 0xc4c4c4c4UL, 0xdedededeUL, 0xe9e9e9e9UL, 0xcbcbcbcbUL, + 0x54545454UL, 0x7b7b7b7bUL, 0x94949494UL, 0x32323232UL, + 0xa6a6a6a6UL, 0xc2c2c2c2UL, 0x23232323UL, 0x3d3d3d3dUL, + 0xeeeeeeeeUL, 0x4c4c4c4cUL, 0x95959595UL, 0x0b0b0b0bUL, + 0x42424242UL, 0xfafafafaUL, 0xc3c3c3c3UL, 0x4e4e4e4eUL, + 0x08080808UL, 0x2e2e2e2eUL, 0xa1a1a1a1UL, 0x66666666UL, + 0x28282828UL, 0xd9d9d9d9UL, 0x24242424UL, 0xb2b2b2b2UL, + 0x76767676UL, 0x5b5b5b5bUL, 0xa2a2a2a2UL, 0x49494949UL, + 0x6d6d6d6dUL, 0x8b8b8b8bUL, 0xd1d1d1d1UL, 0x25252525UL, + 0x72727272UL, 0xf8f8f8f8UL, 0xf6f6f6f6UL, 0x64646464UL, + 0x86868686UL, 0x68686868UL, 0x98989898UL, 0x16161616UL, + 0xd4d4d4d4UL, 0xa4a4a4a4UL, 0x5c5c5c5cUL, 0xccccccccUL, + 0x5d5d5d5dUL, 0x65656565UL, 0xb6b6b6b6UL, 0x92929292UL, + 0x6c6c6c6cUL, 0x70707070UL, 0x48484848UL, 0x50505050UL, + 0xfdfdfdfdUL, 0xededededUL, 0xb9b9b9b9UL, 0xdadadadaUL, + 0x5e5e5e5eUL, 0x15151515UL, 0x46464646UL, 0x57575757UL, + 0xa7a7a7a7UL, 0x8d8d8d8dUL, 0x9d9d9d9dUL, 0x84848484UL, + 0x90909090UL, 0xd8d8d8d8UL, 0xababababUL, 0x00000000UL, + 0x8c8c8c8cUL, 0xbcbcbcbcUL, 0xd3d3d3d3UL, 0x0a0a0a0aUL, + 0xf7f7f7f7UL, 0xe4e4e4e4UL, 0x58585858UL, 0x05050505UL, + 0xb8b8b8b8UL, 0xb3b3b3b3UL, 0x45454545UL, 0x06060606UL, + 0xd0d0d0d0UL, 0x2c2c2c2cUL, 0x1e1e1e1eUL, 0x8f8f8f8fUL, + 0xcacacacaUL, 0x3f3f3f3fUL, 0x0f0f0f0fUL, 0x02020202UL, + 0xc1c1c1c1UL, 0xafafafafUL, 0xbdbdbdbdUL, 0x03030303UL, + 0x01010101UL, 0x13131313UL, 0x8a8a8a8aUL, 0x6b6b6b6bUL, + 0x3a3a3a3aUL, 0x91919191UL, 0x11111111UL, 0x41414141UL, + 0x4f4f4f4fUL, 0x67676767UL, 0xdcdcdcdcUL, 0xeaeaeaeaUL, + 0x97979797UL, 0xf2f2f2f2UL, 0xcfcfcfcfUL, 0xcecececeUL, + 0xf0f0f0f0UL, 0xb4b4b4b4UL, 0xe6e6e6e6UL, 0x73737373UL, + 0x96969696UL, 0xacacacacUL, 0x74747474UL, 0x22222222UL, + 0xe7e7e7e7UL, 0xadadadadUL, 0x35353535UL, 0x85858585UL, + 0xe2e2e2e2UL, 0xf9f9f9f9UL, 0x37373737UL, 0xe8e8e8e8UL, + 0x1c1c1c1cUL, 0x75757575UL, 0xdfdfdfdfUL, 0x6e6e6e6eUL, + 0x47474747UL, 0xf1f1f1f1UL, 0x1a1a1a1aUL, 0x71717171UL, + 0x1d1d1d1dUL, 0x29292929UL, 0xc5c5c5c5UL, 0x89898989UL, + 0x6f6f6f6fUL, 0xb7b7b7b7UL, 0x62626262UL, 0x0e0e0e0eUL, + 0xaaaaaaaaUL, 0x18181818UL, 0xbebebebeUL, 0x1b1b1b1bUL, + 0xfcfcfcfcUL, 0x56565656UL, 0x3e3e3e3eUL, 0x4b4b4b4bUL, + 0xc6c6c6c6UL, 0xd2d2d2d2UL, 0x79797979UL, 0x20202020UL, + 0x9a9a9a9aUL, 0xdbdbdbdbUL, 0xc0c0c0c0UL, 0xfefefefeUL, + 0x78787878UL, 0xcdcdcdcdUL, 0x5a5a5a5aUL, 0xf4f4f4f4UL, + 0x1f1f1f1fUL, 0xddddddddUL, 0xa8a8a8a8UL, 0x33333333UL, + 0x88888888UL, 0x07070707UL, 0xc7c7c7c7UL, 0x31313131UL, + 0xb1b1b1b1UL, 0x12121212UL, 0x10101010UL, 0x59595959UL, + 0x27272727UL, 0x80808080UL, 0xececececUL, 0x5f5f5f5fUL, + 0x60606060UL, 0x51515151UL, 0x7f7f7f7fUL, 0xa9a9a9a9UL, + 0x19191919UL, 0xb5b5b5b5UL, 0x4a4a4a4aUL, 0x0d0d0d0dUL, + 0x2d2d2d2dUL, 0xe5e5e5e5UL, 0x7a7a7a7aUL, 0x9f9f9f9fUL, + 0x93939393UL, 0xc9c9c9c9UL, 0x9c9c9c9cUL, 0xefefefefUL, + 0xa0a0a0a0UL, 0xe0e0e0e0UL, 0x3b3b3b3bUL, 0x4d4d4d4dUL, + 0xaeaeaeaeUL, 0x2a2a2a2aUL, 0xf5f5f5f5UL, 0xb0b0b0b0UL, + 0xc8c8c8c8UL, 0xebebebebUL, 0xbbbbbbbbUL, 0x3c3c3c3cUL, + 0x83838383UL, 0x53535353UL, 0x99999999UL, 0x61616161UL, + 0x17171717UL, 0x2b2b2b2bUL, 0x04040404UL, 0x7e7e7e7eUL, + 0xbabababaUL, 0x77777777UL, 0xd6d6d6d6UL, 0x26262626UL, + 0xe1e1e1e1UL, 0x69696969UL, 0x14141414UL, 0x63636363UL, + 0x55555555UL, 0x21212121UL, 0x0c0c0c0cUL, 0x7d7d7d7dUL, +}; + +#endif /* ENCRYPT_ONLY */ + +#ifdef LTC_SMALL_CODE + +#define Te0(x) TE0[x] +#define Te1(x) RORc(TE0[x], 8) +#define Te2(x) RORc(TE0[x], 16) +#define Te3(x) RORc(TE0[x], 24) + +#define Td0(x) TD0[x] +#define Td1(x) RORc(TD0[x], 8) +#define Td2(x) RORc(TD0[x], 16) +#define Td3(x) RORc(TD0[x], 24) + +#define Te4_0 0x000000FF & Te4 +#define Te4_1 0x0000FF00 & Te4 +#define Te4_2 0x00FF0000 & Te4 +#define Te4_3 0xFF000000 & Te4 + +#else + +#define Te0(x) TE0[x] +#define Te1(x) TE1[x] +#define Te2(x) TE2[x] +#define Te3(x) TE3[x] + +#define Td0(x) TD0[x] +#define Td1(x) TD1[x] +#define Td2(x) TD2[x] +#define Td3(x) TD3[x] + +static const ulong32 TE1[256] = { + 0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL, + 0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL, + 0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL, + 0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL, + 0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL, + 0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL, + 0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL, + 0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL, + 0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL, + 0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL, + 0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL, + 0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL, + 0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL, + 0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL, + 0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL, + 0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL, + 0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL, + 0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL, + 0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL, + 0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL, + 0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL, + 0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL, + 0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL, + 0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL, + 0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL, + 0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL, + 0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL, + 0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL, + 0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL, + 0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL, + 0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL, + 0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL, + 0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL, + 0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL, + 0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL, + 0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL, + 0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL, + 0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL, + 0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL, + 0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL, + 0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL, + 0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL, + 0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL, + 0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL, + 0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL, + 0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL, + 0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL, + 0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL, + 0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL, + 0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL, + 0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL, + 0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL, + 0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL, + 0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL, + 0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL, + 0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL, + 0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL, + 0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL, + 0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL, + 0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL, + 0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL, + 0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL, + 0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL, + 0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL, +}; +static const ulong32 TE2[256] = { + 0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL, + 0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL, + 0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL, + 0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL, + 0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL, + 0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL, + 0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL, + 0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL, + 0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL, + 0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL, + 0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL, + 0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL, + 0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL, + 0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL, + 0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL, + 0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL, + 0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL, + 0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL, + 0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL, + 0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL, + 0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL, + 0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL, + 0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL, + 0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL, + 0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL, + 0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL, + 0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL, + 0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL, + 0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL, + 0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL, + 0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL, + 0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL, + 0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL, + 0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL, + 0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL, + 0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL, + 0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL, + 0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL, + 0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL, + 0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL, + 0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL, + 0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL, + 0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL, + 0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL, + 0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL, + 0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL, + 0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL, + 0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL, + 0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL, + 0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL, + 0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL, + 0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL, + 0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL, + 0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL, + 0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL, + 0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL, + 0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL, + 0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL, + 0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL, + 0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL, + 0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL, + 0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL, + 0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL, + 0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL, +}; +static const ulong32 TE3[256] = { + + 0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL, + 0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL, + 0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL, + 0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL, + 0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL, + 0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL, + 0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL, + 0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL, + 0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL, + 0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL, + 0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL, + 0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL, + 0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL, + 0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL, + 0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL, + 0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL, + 0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL, + 0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL, + 0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL, + 0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL, + 0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL, + 0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL, + 0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL, + 0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL, + 0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL, + 0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL, + 0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL, + 0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL, + 0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL, + 0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL, + 0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL, + 0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL, + 0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL, + 0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL, + 0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL, + 0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL, + 0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL, + 0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL, + 0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL, + 0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL, + 0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL, + 0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL, + 0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL, + 0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL, + 0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL, + 0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL, + 0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL, + 0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL, + 0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL, + 0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL, + 0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL, + 0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL, + 0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL, + 0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL, + 0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL, + 0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL, + 0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL, + 0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL, + 0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL, + 0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL, + 0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL, + 0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL, + 0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL, + 0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL, +}; + +#ifndef PELI_TAB +static const ulong32 Te4_0[] = { +0x00000063UL, 0x0000007cUL, 0x00000077UL, 0x0000007bUL, 0x000000f2UL, 0x0000006bUL, 0x0000006fUL, 0x000000c5UL, +0x00000030UL, 0x00000001UL, 0x00000067UL, 0x0000002bUL, 0x000000feUL, 0x000000d7UL, 0x000000abUL, 0x00000076UL, +0x000000caUL, 0x00000082UL, 0x000000c9UL, 0x0000007dUL, 0x000000faUL, 0x00000059UL, 0x00000047UL, 0x000000f0UL, +0x000000adUL, 0x000000d4UL, 0x000000a2UL, 0x000000afUL, 0x0000009cUL, 0x000000a4UL, 0x00000072UL, 0x000000c0UL, +0x000000b7UL, 0x000000fdUL, 0x00000093UL, 0x00000026UL, 0x00000036UL, 0x0000003fUL, 0x000000f7UL, 0x000000ccUL, +0x00000034UL, 0x000000a5UL, 0x000000e5UL, 0x000000f1UL, 0x00000071UL, 0x000000d8UL, 0x00000031UL, 0x00000015UL, +0x00000004UL, 0x000000c7UL, 0x00000023UL, 0x000000c3UL, 0x00000018UL, 0x00000096UL, 0x00000005UL, 0x0000009aUL, +0x00000007UL, 0x00000012UL, 0x00000080UL, 0x000000e2UL, 0x000000ebUL, 0x00000027UL, 0x000000b2UL, 0x00000075UL, +0x00000009UL, 0x00000083UL, 0x0000002cUL, 0x0000001aUL, 0x0000001bUL, 0x0000006eUL, 0x0000005aUL, 0x000000a0UL, +0x00000052UL, 0x0000003bUL, 0x000000d6UL, 0x000000b3UL, 0x00000029UL, 0x000000e3UL, 0x0000002fUL, 0x00000084UL, +0x00000053UL, 0x000000d1UL, 0x00000000UL, 0x000000edUL, 0x00000020UL, 0x000000fcUL, 0x000000b1UL, 0x0000005bUL, +0x0000006aUL, 0x000000cbUL, 0x000000beUL, 0x00000039UL, 0x0000004aUL, 0x0000004cUL, 0x00000058UL, 0x000000cfUL, +0x000000d0UL, 0x000000efUL, 0x000000aaUL, 0x000000fbUL, 0x00000043UL, 0x0000004dUL, 0x00000033UL, 0x00000085UL, +0x00000045UL, 0x000000f9UL, 0x00000002UL, 0x0000007fUL, 0x00000050UL, 0x0000003cUL, 0x0000009fUL, 0x000000a8UL, +0x00000051UL, 0x000000a3UL, 0x00000040UL, 0x0000008fUL, 0x00000092UL, 0x0000009dUL, 0x00000038UL, 0x000000f5UL, +0x000000bcUL, 0x000000b6UL, 0x000000daUL, 0x00000021UL, 0x00000010UL, 0x000000ffUL, 0x000000f3UL, 0x000000d2UL, +0x000000cdUL, 0x0000000cUL, 0x00000013UL, 0x000000ecUL, 0x0000005fUL, 0x00000097UL, 0x00000044UL, 0x00000017UL, +0x000000c4UL, 0x000000a7UL, 0x0000007eUL, 0x0000003dUL, 0x00000064UL, 0x0000005dUL, 0x00000019UL, 0x00000073UL, +0x00000060UL, 0x00000081UL, 0x0000004fUL, 0x000000dcUL, 0x00000022UL, 0x0000002aUL, 0x00000090UL, 0x00000088UL, +0x00000046UL, 0x000000eeUL, 0x000000b8UL, 0x00000014UL, 0x000000deUL, 0x0000005eUL, 0x0000000bUL, 0x000000dbUL, +0x000000e0UL, 0x00000032UL, 0x0000003aUL, 0x0000000aUL, 0x00000049UL, 0x00000006UL, 0x00000024UL, 0x0000005cUL, +0x000000c2UL, 0x000000d3UL, 0x000000acUL, 0x00000062UL, 0x00000091UL, 0x00000095UL, 0x000000e4UL, 0x00000079UL, +0x000000e7UL, 0x000000c8UL, 0x00000037UL, 0x0000006dUL, 0x0000008dUL, 0x000000d5UL, 0x0000004eUL, 0x000000a9UL, +0x0000006cUL, 0x00000056UL, 0x000000f4UL, 0x000000eaUL, 0x00000065UL, 0x0000007aUL, 0x000000aeUL, 0x00000008UL, +0x000000baUL, 0x00000078UL, 0x00000025UL, 0x0000002eUL, 0x0000001cUL, 0x000000a6UL, 0x000000b4UL, 0x000000c6UL, +0x000000e8UL, 0x000000ddUL, 0x00000074UL, 0x0000001fUL, 0x0000004bUL, 0x000000bdUL, 0x0000008bUL, 0x0000008aUL, +0x00000070UL, 0x0000003eUL, 0x000000b5UL, 0x00000066UL, 0x00000048UL, 0x00000003UL, 0x000000f6UL, 0x0000000eUL, +0x00000061UL, 0x00000035UL, 0x00000057UL, 0x000000b9UL, 0x00000086UL, 0x000000c1UL, 0x0000001dUL, 0x0000009eUL, +0x000000e1UL, 0x000000f8UL, 0x00000098UL, 0x00000011UL, 0x00000069UL, 0x000000d9UL, 0x0000008eUL, 0x00000094UL, +0x0000009bUL, 0x0000001eUL, 0x00000087UL, 0x000000e9UL, 0x000000ceUL, 0x00000055UL, 0x00000028UL, 0x000000dfUL, +0x0000008cUL, 0x000000a1UL, 0x00000089UL, 0x0000000dUL, 0x000000bfUL, 0x000000e6UL, 0x00000042UL, 0x00000068UL, +0x00000041UL, 0x00000099UL, 0x0000002dUL, 0x0000000fUL, 0x000000b0UL, 0x00000054UL, 0x000000bbUL, 0x00000016UL +}; + +static const ulong32 Te4_1[] = { +0x00006300UL, 0x00007c00UL, 0x00007700UL, 0x00007b00UL, 0x0000f200UL, 0x00006b00UL, 0x00006f00UL, 0x0000c500UL, +0x00003000UL, 0x00000100UL, 0x00006700UL, 0x00002b00UL, 0x0000fe00UL, 0x0000d700UL, 0x0000ab00UL, 0x00007600UL, +0x0000ca00UL, 0x00008200UL, 0x0000c900UL, 0x00007d00UL, 0x0000fa00UL, 0x00005900UL, 0x00004700UL, 0x0000f000UL, +0x0000ad00UL, 0x0000d400UL, 0x0000a200UL, 0x0000af00UL, 0x00009c00UL, 0x0000a400UL, 0x00007200UL, 0x0000c000UL, +0x0000b700UL, 0x0000fd00UL, 0x00009300UL, 0x00002600UL, 0x00003600UL, 0x00003f00UL, 0x0000f700UL, 0x0000cc00UL, +0x00003400UL, 0x0000a500UL, 0x0000e500UL, 0x0000f100UL, 0x00007100UL, 0x0000d800UL, 0x00003100UL, 0x00001500UL, +0x00000400UL, 0x0000c700UL, 0x00002300UL, 0x0000c300UL, 0x00001800UL, 0x00009600UL, 0x00000500UL, 0x00009a00UL, +0x00000700UL, 0x00001200UL, 0x00008000UL, 0x0000e200UL, 0x0000eb00UL, 0x00002700UL, 0x0000b200UL, 0x00007500UL, +0x00000900UL, 0x00008300UL, 0x00002c00UL, 0x00001a00UL, 0x00001b00UL, 0x00006e00UL, 0x00005a00UL, 0x0000a000UL, +0x00005200UL, 0x00003b00UL, 0x0000d600UL, 0x0000b300UL, 0x00002900UL, 0x0000e300UL, 0x00002f00UL, 0x00008400UL, +0x00005300UL, 0x0000d100UL, 0x00000000UL, 0x0000ed00UL, 0x00002000UL, 0x0000fc00UL, 0x0000b100UL, 0x00005b00UL, +0x00006a00UL, 0x0000cb00UL, 0x0000be00UL, 0x00003900UL, 0x00004a00UL, 0x00004c00UL, 0x00005800UL, 0x0000cf00UL, +0x0000d000UL, 0x0000ef00UL, 0x0000aa00UL, 0x0000fb00UL, 0x00004300UL, 0x00004d00UL, 0x00003300UL, 0x00008500UL, +0x00004500UL, 0x0000f900UL, 0x00000200UL, 0x00007f00UL, 0x00005000UL, 0x00003c00UL, 0x00009f00UL, 0x0000a800UL, +0x00005100UL, 0x0000a300UL, 0x00004000UL, 0x00008f00UL, 0x00009200UL, 0x00009d00UL, 0x00003800UL, 0x0000f500UL, +0x0000bc00UL, 0x0000b600UL, 0x0000da00UL, 0x00002100UL, 0x00001000UL, 0x0000ff00UL, 0x0000f300UL, 0x0000d200UL, +0x0000cd00UL, 0x00000c00UL, 0x00001300UL, 0x0000ec00UL, 0x00005f00UL, 0x00009700UL, 0x00004400UL, 0x00001700UL, +0x0000c400UL, 0x0000a700UL, 0x00007e00UL, 0x00003d00UL, 0x00006400UL, 0x00005d00UL, 0x00001900UL, 0x00007300UL, +0x00006000UL, 0x00008100UL, 0x00004f00UL, 0x0000dc00UL, 0x00002200UL, 0x00002a00UL, 0x00009000UL, 0x00008800UL, +0x00004600UL, 0x0000ee00UL, 0x0000b800UL, 0x00001400UL, 0x0000de00UL, 0x00005e00UL, 0x00000b00UL, 0x0000db00UL, +0x0000e000UL, 0x00003200UL, 0x00003a00UL, 0x00000a00UL, 0x00004900UL, 0x00000600UL, 0x00002400UL, 0x00005c00UL, +0x0000c200UL, 0x0000d300UL, 0x0000ac00UL, 0x00006200UL, 0x00009100UL, 0x00009500UL, 0x0000e400UL, 0x00007900UL, +0x0000e700UL, 0x0000c800UL, 0x00003700UL, 0x00006d00UL, 0x00008d00UL, 0x0000d500UL, 0x00004e00UL, 0x0000a900UL, +0x00006c00UL, 0x00005600UL, 0x0000f400UL, 0x0000ea00UL, 0x00006500UL, 0x00007a00UL, 0x0000ae00UL, 0x00000800UL, +0x0000ba00UL, 0x00007800UL, 0x00002500UL, 0x00002e00UL, 0x00001c00UL, 0x0000a600UL, 0x0000b400UL, 0x0000c600UL, +0x0000e800UL, 0x0000dd00UL, 0x00007400UL, 0x00001f00UL, 0x00004b00UL, 0x0000bd00UL, 0x00008b00UL, 0x00008a00UL, +0x00007000UL, 0x00003e00UL, 0x0000b500UL, 0x00006600UL, 0x00004800UL, 0x00000300UL, 0x0000f600UL, 0x00000e00UL, +0x00006100UL, 0x00003500UL, 0x00005700UL, 0x0000b900UL, 0x00008600UL, 0x0000c100UL, 0x00001d00UL, 0x00009e00UL, +0x0000e100UL, 0x0000f800UL, 0x00009800UL, 0x00001100UL, 0x00006900UL, 0x0000d900UL, 0x00008e00UL, 0x00009400UL, +0x00009b00UL, 0x00001e00UL, 0x00008700UL, 0x0000e900UL, 0x0000ce00UL, 0x00005500UL, 0x00002800UL, 0x0000df00UL, +0x00008c00UL, 0x0000a100UL, 0x00008900UL, 0x00000d00UL, 0x0000bf00UL, 0x0000e600UL, 0x00004200UL, 0x00006800UL, +0x00004100UL, 0x00009900UL, 0x00002d00UL, 0x00000f00UL, 0x0000b000UL, 0x00005400UL, 0x0000bb00UL, 0x00001600UL +}; + +static const ulong32 Te4_2[] = { +0x00630000UL, 0x007c0000UL, 0x00770000UL, 0x007b0000UL, 0x00f20000UL, 0x006b0000UL, 0x006f0000UL, 0x00c50000UL, +0x00300000UL, 0x00010000UL, 0x00670000UL, 0x002b0000UL, 0x00fe0000UL, 0x00d70000UL, 0x00ab0000UL, 0x00760000UL, +0x00ca0000UL, 0x00820000UL, 0x00c90000UL, 0x007d0000UL, 0x00fa0000UL, 0x00590000UL, 0x00470000UL, 0x00f00000UL, +0x00ad0000UL, 0x00d40000UL, 0x00a20000UL, 0x00af0000UL, 0x009c0000UL, 0x00a40000UL, 0x00720000UL, 0x00c00000UL, +0x00b70000UL, 0x00fd0000UL, 0x00930000UL, 0x00260000UL, 0x00360000UL, 0x003f0000UL, 0x00f70000UL, 0x00cc0000UL, +0x00340000UL, 0x00a50000UL, 0x00e50000UL, 0x00f10000UL, 0x00710000UL, 0x00d80000UL, 0x00310000UL, 0x00150000UL, +0x00040000UL, 0x00c70000UL, 0x00230000UL, 0x00c30000UL, 0x00180000UL, 0x00960000UL, 0x00050000UL, 0x009a0000UL, +0x00070000UL, 0x00120000UL, 0x00800000UL, 0x00e20000UL, 0x00eb0000UL, 0x00270000UL, 0x00b20000UL, 0x00750000UL, +0x00090000UL, 0x00830000UL, 0x002c0000UL, 0x001a0000UL, 0x001b0000UL, 0x006e0000UL, 0x005a0000UL, 0x00a00000UL, +0x00520000UL, 0x003b0000UL, 0x00d60000UL, 0x00b30000UL, 0x00290000UL, 0x00e30000UL, 0x002f0000UL, 0x00840000UL, +0x00530000UL, 0x00d10000UL, 0x00000000UL, 0x00ed0000UL, 0x00200000UL, 0x00fc0000UL, 0x00b10000UL, 0x005b0000UL, +0x006a0000UL, 0x00cb0000UL, 0x00be0000UL, 0x00390000UL, 0x004a0000UL, 0x004c0000UL, 0x00580000UL, 0x00cf0000UL, +0x00d00000UL, 0x00ef0000UL, 0x00aa0000UL, 0x00fb0000UL, 0x00430000UL, 0x004d0000UL, 0x00330000UL, 0x00850000UL, +0x00450000UL, 0x00f90000UL, 0x00020000UL, 0x007f0000UL, 0x00500000UL, 0x003c0000UL, 0x009f0000UL, 0x00a80000UL, +0x00510000UL, 0x00a30000UL, 0x00400000UL, 0x008f0000UL, 0x00920000UL, 0x009d0000UL, 0x00380000UL, 0x00f50000UL, +0x00bc0000UL, 0x00b60000UL, 0x00da0000UL, 0x00210000UL, 0x00100000UL, 0x00ff0000UL, 0x00f30000UL, 0x00d20000UL, +0x00cd0000UL, 0x000c0000UL, 0x00130000UL, 0x00ec0000UL, 0x005f0000UL, 0x00970000UL, 0x00440000UL, 0x00170000UL, +0x00c40000UL, 0x00a70000UL, 0x007e0000UL, 0x003d0000UL, 0x00640000UL, 0x005d0000UL, 0x00190000UL, 0x00730000UL, +0x00600000UL, 0x00810000UL, 0x004f0000UL, 0x00dc0000UL, 0x00220000UL, 0x002a0000UL, 0x00900000UL, 0x00880000UL, +0x00460000UL, 0x00ee0000UL, 0x00b80000UL, 0x00140000UL, 0x00de0000UL, 0x005e0000UL, 0x000b0000UL, 0x00db0000UL, +0x00e00000UL, 0x00320000UL, 0x003a0000UL, 0x000a0000UL, 0x00490000UL, 0x00060000UL, 0x00240000UL, 0x005c0000UL, +0x00c20000UL, 0x00d30000UL, 0x00ac0000UL, 0x00620000UL, 0x00910000UL, 0x00950000UL, 0x00e40000UL, 0x00790000UL, +0x00e70000UL, 0x00c80000UL, 0x00370000UL, 0x006d0000UL, 0x008d0000UL, 0x00d50000UL, 0x004e0000UL, 0x00a90000UL, +0x006c0000UL, 0x00560000UL, 0x00f40000UL, 0x00ea0000UL, 0x00650000UL, 0x007a0000UL, 0x00ae0000UL, 0x00080000UL, +0x00ba0000UL, 0x00780000UL, 0x00250000UL, 0x002e0000UL, 0x001c0000UL, 0x00a60000UL, 0x00b40000UL, 0x00c60000UL, +0x00e80000UL, 0x00dd0000UL, 0x00740000UL, 0x001f0000UL, 0x004b0000UL, 0x00bd0000UL, 0x008b0000UL, 0x008a0000UL, +0x00700000UL, 0x003e0000UL, 0x00b50000UL, 0x00660000UL, 0x00480000UL, 0x00030000UL, 0x00f60000UL, 0x000e0000UL, +0x00610000UL, 0x00350000UL, 0x00570000UL, 0x00b90000UL, 0x00860000UL, 0x00c10000UL, 0x001d0000UL, 0x009e0000UL, +0x00e10000UL, 0x00f80000UL, 0x00980000UL, 0x00110000UL, 0x00690000UL, 0x00d90000UL, 0x008e0000UL, 0x00940000UL, +0x009b0000UL, 0x001e0000UL, 0x00870000UL, 0x00e90000UL, 0x00ce0000UL, 0x00550000UL, 0x00280000UL, 0x00df0000UL, +0x008c0000UL, 0x00a10000UL, 0x00890000UL, 0x000d0000UL, 0x00bf0000UL, 0x00e60000UL, 0x00420000UL, 0x00680000UL, +0x00410000UL, 0x00990000UL, 0x002d0000UL, 0x000f0000UL, 0x00b00000UL, 0x00540000UL, 0x00bb0000UL, 0x00160000UL +}; + +static const ulong32 Te4_3[] = { +0x63000000UL, 0x7c000000UL, 0x77000000UL, 0x7b000000UL, 0xf2000000UL, 0x6b000000UL, 0x6f000000UL, 0xc5000000UL, +0x30000000UL, 0x01000000UL, 0x67000000UL, 0x2b000000UL, 0xfe000000UL, 0xd7000000UL, 0xab000000UL, 0x76000000UL, +0xca000000UL, 0x82000000UL, 0xc9000000UL, 0x7d000000UL, 0xfa000000UL, 0x59000000UL, 0x47000000UL, 0xf0000000UL, +0xad000000UL, 0xd4000000UL, 0xa2000000UL, 0xaf000000UL, 0x9c000000UL, 0xa4000000UL, 0x72000000UL, 0xc0000000UL, +0xb7000000UL, 0xfd000000UL, 0x93000000UL, 0x26000000UL, 0x36000000UL, 0x3f000000UL, 0xf7000000UL, 0xcc000000UL, +0x34000000UL, 0xa5000000UL, 0xe5000000UL, 0xf1000000UL, 0x71000000UL, 0xd8000000UL, 0x31000000UL, 0x15000000UL, +0x04000000UL, 0xc7000000UL, 0x23000000UL, 0xc3000000UL, 0x18000000UL, 0x96000000UL, 0x05000000UL, 0x9a000000UL, +0x07000000UL, 0x12000000UL, 0x80000000UL, 0xe2000000UL, 0xeb000000UL, 0x27000000UL, 0xb2000000UL, 0x75000000UL, +0x09000000UL, 0x83000000UL, 0x2c000000UL, 0x1a000000UL, 0x1b000000UL, 0x6e000000UL, 0x5a000000UL, 0xa0000000UL, +0x52000000UL, 0x3b000000UL, 0xd6000000UL, 0xb3000000UL, 0x29000000UL, 0xe3000000UL, 0x2f000000UL, 0x84000000UL, +0x53000000UL, 0xd1000000UL, 0x00000000UL, 0xed000000UL, 0x20000000UL, 0xfc000000UL, 0xb1000000UL, 0x5b000000UL, +0x6a000000UL, 0xcb000000UL, 0xbe000000UL, 0x39000000UL, 0x4a000000UL, 0x4c000000UL, 0x58000000UL, 0xcf000000UL, +0xd0000000UL, 0xef000000UL, 0xaa000000UL, 0xfb000000UL, 0x43000000UL, 0x4d000000UL, 0x33000000UL, 0x85000000UL, +0x45000000UL, 0xf9000000UL, 0x02000000UL, 0x7f000000UL, 0x50000000UL, 0x3c000000UL, 0x9f000000UL, 0xa8000000UL, +0x51000000UL, 0xa3000000UL, 0x40000000UL, 0x8f000000UL, 0x92000000UL, 0x9d000000UL, 0x38000000UL, 0xf5000000UL, +0xbc000000UL, 0xb6000000UL, 0xda000000UL, 0x21000000UL, 0x10000000UL, 0xff000000UL, 0xf3000000UL, 0xd2000000UL, +0xcd000000UL, 0x0c000000UL, 0x13000000UL, 0xec000000UL, 0x5f000000UL, 0x97000000UL, 0x44000000UL, 0x17000000UL, +0xc4000000UL, 0xa7000000UL, 0x7e000000UL, 0x3d000000UL, 0x64000000UL, 0x5d000000UL, 0x19000000UL, 0x73000000UL, +0x60000000UL, 0x81000000UL, 0x4f000000UL, 0xdc000000UL, 0x22000000UL, 0x2a000000UL, 0x90000000UL, 0x88000000UL, +0x46000000UL, 0xee000000UL, 0xb8000000UL, 0x14000000UL, 0xde000000UL, 0x5e000000UL, 0x0b000000UL, 0xdb000000UL, +0xe0000000UL, 0x32000000UL, 0x3a000000UL, 0x0a000000UL, 0x49000000UL, 0x06000000UL, 0x24000000UL, 0x5c000000UL, +0xc2000000UL, 0xd3000000UL, 0xac000000UL, 0x62000000UL, 0x91000000UL, 0x95000000UL, 0xe4000000UL, 0x79000000UL, +0xe7000000UL, 0xc8000000UL, 0x37000000UL, 0x6d000000UL, 0x8d000000UL, 0xd5000000UL, 0x4e000000UL, 0xa9000000UL, +0x6c000000UL, 0x56000000UL, 0xf4000000UL, 0xea000000UL, 0x65000000UL, 0x7a000000UL, 0xae000000UL, 0x08000000UL, +0xba000000UL, 0x78000000UL, 0x25000000UL, 0x2e000000UL, 0x1c000000UL, 0xa6000000UL, 0xb4000000UL, 0xc6000000UL, +0xe8000000UL, 0xdd000000UL, 0x74000000UL, 0x1f000000UL, 0x4b000000UL, 0xbd000000UL, 0x8b000000UL, 0x8a000000UL, +0x70000000UL, 0x3e000000UL, 0xb5000000UL, 0x66000000UL, 0x48000000UL, 0x03000000UL, 0xf6000000UL, 0x0e000000UL, +0x61000000UL, 0x35000000UL, 0x57000000UL, 0xb9000000UL, 0x86000000UL, 0xc1000000UL, 0x1d000000UL, 0x9e000000UL, +0xe1000000UL, 0xf8000000UL, 0x98000000UL, 0x11000000UL, 0x69000000UL, 0xd9000000UL, 0x8e000000UL, 0x94000000UL, +0x9b000000UL, 0x1e000000UL, 0x87000000UL, 0xe9000000UL, 0xce000000UL, 0x55000000UL, 0x28000000UL, 0xdf000000UL, +0x8c000000UL, 0xa1000000UL, 0x89000000UL, 0x0d000000UL, 0xbf000000UL, 0xe6000000UL, 0x42000000UL, 0x68000000UL, +0x41000000UL, 0x99000000UL, 0x2d000000UL, 0x0f000000UL, 0xb0000000UL, 0x54000000UL, 0xbb000000UL, 0x16000000UL +}; +#endif /* pelimac */ + +#ifndef ENCRYPT_ONLY + +static const ulong32 TD1[256] = { + 0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL, + 0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL, + 0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL, + 0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL, + 0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL, + 0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL, + 0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL, + 0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL, + 0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL, + 0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL, + 0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL, + 0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL, + 0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL, + 0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL, + 0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL, + 0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL, + 0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL, + 0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL, + 0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL, + 0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL, + 0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL, + 0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL, + 0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL, + 0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL, + 0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL, + 0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL, + 0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL, + 0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL, + 0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL, + 0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL, + 0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL, + 0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL, + 0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL, + 0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL, + 0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL, + 0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL, + 0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL, + 0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL, + 0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL, + 0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL, + 0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL, + 0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL, + 0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL, + 0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL, + 0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL, + 0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL, + 0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL, + 0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL, + 0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL, + 0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL, + 0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL, + 0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL, + 0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL, + 0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL, + 0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL, + 0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL, + 0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL, + 0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL, + 0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL, + 0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL, + 0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL, + 0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL, + 0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL, + 0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL, +}; +static const ulong32 TD2[256] = { + 0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL, + 0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL, + 0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL, + 0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL, + 0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL, + 0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL, + 0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL, + 0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL, + 0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL, + 0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL, + 0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL, + 0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL, + 0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL, + 0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL, + 0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL, + 0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL, + 0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL, + 0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL, + 0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL, + 0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL, + 0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL, + 0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL, + 0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL, + 0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL, + 0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL, + 0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL, + 0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL, + 0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL, + 0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL, + 0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL, + 0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL, + 0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL, + 0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL, + 0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL, + 0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL, + 0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL, + 0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL, + 0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL, + 0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL, + 0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL, + 0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL, + 0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL, + 0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL, + 0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL, + 0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL, + 0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL, + 0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL, + 0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL, + 0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL, + 0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL, + 0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL, + 0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL, + 0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL, + 0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL, + 0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL, + 0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL, + 0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL, + 0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL, + 0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL, + 0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL, + 0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL, + 0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL, + 0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL, + 0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL, +}; +static const ulong32 TD3[256] = { + 0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL, + 0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL, + 0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL, + 0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL, + 0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL, + 0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL, + 0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL, + 0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL, + 0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL, + 0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL, + 0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL, + 0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL, + 0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL, + 0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL, + 0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL, + 0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL, + 0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL, + 0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL, + 0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL, + 0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL, + 0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL, + 0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL, + 0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL, + 0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL, + 0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL, + 0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL, + 0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL, + 0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL, + 0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL, + 0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL, + 0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL, + 0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL, + 0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL, + 0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL, + 0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL, + 0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL, + 0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL, + 0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL, + 0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL, + 0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL, + 0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL, + 0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL, + 0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL, + 0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL, + 0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL, + 0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL, + 0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL, + 0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL, + 0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL, + 0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL, + 0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL, + 0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL, + 0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL, + 0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL, + 0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL, + 0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL, + 0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL, + 0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL, + 0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL, + 0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL, + 0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL, + 0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL, + 0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL, + 0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL, +}; + +static const ulong32 Tks0[] = { +0x00000000UL, 0x0e090d0bUL, 0x1c121a16UL, 0x121b171dUL, 0x3824342cUL, 0x362d3927UL, 0x24362e3aUL, 0x2a3f2331UL, +0x70486858UL, 0x7e416553UL, 0x6c5a724eUL, 0x62537f45UL, 0x486c5c74UL, 0x4665517fUL, 0x547e4662UL, 0x5a774b69UL, +0xe090d0b0UL, 0xee99ddbbUL, 0xfc82caa6UL, 0xf28bc7adUL, 0xd8b4e49cUL, 0xd6bde997UL, 0xc4a6fe8aUL, 0xcaaff381UL, +0x90d8b8e8UL, 0x9ed1b5e3UL, 0x8ccaa2feUL, 0x82c3aff5UL, 0xa8fc8cc4UL, 0xa6f581cfUL, 0xb4ee96d2UL, 0xbae79bd9UL, +0xdb3bbb7bUL, 0xd532b670UL, 0xc729a16dUL, 0xc920ac66UL, 0xe31f8f57UL, 0xed16825cUL, 0xff0d9541UL, 0xf104984aUL, +0xab73d323UL, 0xa57ade28UL, 0xb761c935UL, 0xb968c43eUL, 0x9357e70fUL, 0x9d5eea04UL, 0x8f45fd19UL, 0x814cf012UL, +0x3bab6bcbUL, 0x35a266c0UL, 0x27b971ddUL, 0x29b07cd6UL, 0x038f5fe7UL, 0x0d8652ecUL, 0x1f9d45f1UL, 0x119448faUL, +0x4be30393UL, 0x45ea0e98UL, 0x57f11985UL, 0x59f8148eUL, 0x73c737bfUL, 0x7dce3ab4UL, 0x6fd52da9UL, 0x61dc20a2UL, +0xad766df6UL, 0xa37f60fdUL, 0xb16477e0UL, 0xbf6d7aebUL, 0x955259daUL, 0x9b5b54d1UL, 0x894043ccUL, 0x87494ec7UL, +0xdd3e05aeUL, 0xd33708a5UL, 0xc12c1fb8UL, 0xcf2512b3UL, 0xe51a3182UL, 0xeb133c89UL, 0xf9082b94UL, 0xf701269fUL, +0x4de6bd46UL, 0x43efb04dUL, 0x51f4a750UL, 0x5ffdaa5bUL, 0x75c2896aUL, 0x7bcb8461UL, 0x69d0937cUL, 0x67d99e77UL, +0x3daed51eUL, 0x33a7d815UL, 0x21bccf08UL, 0x2fb5c203UL, 0x058ae132UL, 0x0b83ec39UL, 0x1998fb24UL, 0x1791f62fUL, +0x764dd68dUL, 0x7844db86UL, 0x6a5fcc9bUL, 0x6456c190UL, 0x4e69e2a1UL, 0x4060efaaUL, 0x527bf8b7UL, 0x5c72f5bcUL, +0x0605bed5UL, 0x080cb3deUL, 0x1a17a4c3UL, 0x141ea9c8UL, 0x3e218af9UL, 0x302887f2UL, 0x223390efUL, 0x2c3a9de4UL, +0x96dd063dUL, 0x98d40b36UL, 0x8acf1c2bUL, 0x84c61120UL, 0xaef93211UL, 0xa0f03f1aUL, 0xb2eb2807UL, 0xbce2250cUL, +0xe6956e65UL, 0xe89c636eUL, 0xfa877473UL, 0xf48e7978UL, 0xdeb15a49UL, 0xd0b85742UL, 0xc2a3405fUL, 0xccaa4d54UL, +0x41ecdaf7UL, 0x4fe5d7fcUL, 0x5dfec0e1UL, 0x53f7cdeaUL, 0x79c8eedbUL, 0x77c1e3d0UL, 0x65daf4cdUL, 0x6bd3f9c6UL, +0x31a4b2afUL, 0x3fadbfa4UL, 0x2db6a8b9UL, 0x23bfa5b2UL, 0x09808683UL, 0x07898b88UL, 0x15929c95UL, 0x1b9b919eUL, +0xa17c0a47UL, 0xaf75074cUL, 0xbd6e1051UL, 0xb3671d5aUL, 0x99583e6bUL, 0x97513360UL, 0x854a247dUL, 0x8b432976UL, +0xd134621fUL, 0xdf3d6f14UL, 0xcd267809UL, 0xc32f7502UL, 0xe9105633UL, 0xe7195b38UL, 0xf5024c25UL, 0xfb0b412eUL, +0x9ad7618cUL, 0x94de6c87UL, 0x86c57b9aUL, 0x88cc7691UL, 0xa2f355a0UL, 0xacfa58abUL, 0xbee14fb6UL, 0xb0e842bdUL, +0xea9f09d4UL, 0xe49604dfUL, 0xf68d13c2UL, 0xf8841ec9UL, 0xd2bb3df8UL, 0xdcb230f3UL, 0xcea927eeUL, 0xc0a02ae5UL, +0x7a47b13cUL, 0x744ebc37UL, 0x6655ab2aUL, 0x685ca621UL, 0x42638510UL, 0x4c6a881bUL, 0x5e719f06UL, 0x5078920dUL, +0x0a0fd964UL, 0x0406d46fUL, 0x161dc372UL, 0x1814ce79UL, 0x322bed48UL, 0x3c22e043UL, 0x2e39f75eUL, 0x2030fa55UL, +0xec9ab701UL, 0xe293ba0aUL, 0xf088ad17UL, 0xfe81a01cUL, 0xd4be832dUL, 0xdab78e26UL, 0xc8ac993bUL, 0xc6a59430UL, +0x9cd2df59UL, 0x92dbd252UL, 0x80c0c54fUL, 0x8ec9c844UL, 0xa4f6eb75UL, 0xaaffe67eUL, 0xb8e4f163UL, 0xb6edfc68UL, +0x0c0a67b1UL, 0x02036abaUL, 0x10187da7UL, 0x1e1170acUL, 0x342e539dUL, 0x3a275e96UL, 0x283c498bUL, 0x26354480UL, +0x7c420fe9UL, 0x724b02e2UL, 0x605015ffUL, 0x6e5918f4UL, 0x44663bc5UL, 0x4a6f36ceUL, 0x587421d3UL, 0x567d2cd8UL, +0x37a10c7aUL, 0x39a80171UL, 0x2bb3166cUL, 0x25ba1b67UL, 0x0f853856UL, 0x018c355dUL, 0x13972240UL, 0x1d9e2f4bUL, +0x47e96422UL, 0x49e06929UL, 0x5bfb7e34UL, 0x55f2733fUL, 0x7fcd500eUL, 0x71c45d05UL, 0x63df4a18UL, 0x6dd64713UL, +0xd731dccaUL, 0xd938d1c1UL, 0xcb23c6dcUL, 0xc52acbd7UL, 0xef15e8e6UL, 0xe11ce5edUL, 0xf307f2f0UL, 0xfd0efffbUL, +0xa779b492UL, 0xa970b999UL, 0xbb6bae84UL, 0xb562a38fUL, 0x9f5d80beUL, 0x91548db5UL, 0x834f9aa8UL, 0x8d4697a3UL +}; + +static const ulong32 Tks1[] = { +0x00000000UL, 0x0b0e090dUL, 0x161c121aUL, 0x1d121b17UL, 0x2c382434UL, 0x27362d39UL, 0x3a24362eUL, 0x312a3f23UL, +0x58704868UL, 0x537e4165UL, 0x4e6c5a72UL, 0x4562537fUL, 0x74486c5cUL, 0x7f466551UL, 0x62547e46UL, 0x695a774bUL, +0xb0e090d0UL, 0xbbee99ddUL, 0xa6fc82caUL, 0xadf28bc7UL, 0x9cd8b4e4UL, 0x97d6bde9UL, 0x8ac4a6feUL, 0x81caaff3UL, +0xe890d8b8UL, 0xe39ed1b5UL, 0xfe8ccaa2UL, 0xf582c3afUL, 0xc4a8fc8cUL, 0xcfa6f581UL, 0xd2b4ee96UL, 0xd9bae79bUL, +0x7bdb3bbbUL, 0x70d532b6UL, 0x6dc729a1UL, 0x66c920acUL, 0x57e31f8fUL, 0x5ced1682UL, 0x41ff0d95UL, 0x4af10498UL, +0x23ab73d3UL, 0x28a57adeUL, 0x35b761c9UL, 0x3eb968c4UL, 0x0f9357e7UL, 0x049d5eeaUL, 0x198f45fdUL, 0x12814cf0UL, +0xcb3bab6bUL, 0xc035a266UL, 0xdd27b971UL, 0xd629b07cUL, 0xe7038f5fUL, 0xec0d8652UL, 0xf11f9d45UL, 0xfa119448UL, +0x934be303UL, 0x9845ea0eUL, 0x8557f119UL, 0x8e59f814UL, 0xbf73c737UL, 0xb47dce3aUL, 0xa96fd52dUL, 0xa261dc20UL, +0xf6ad766dUL, 0xfda37f60UL, 0xe0b16477UL, 0xebbf6d7aUL, 0xda955259UL, 0xd19b5b54UL, 0xcc894043UL, 0xc787494eUL, +0xaedd3e05UL, 0xa5d33708UL, 0xb8c12c1fUL, 0xb3cf2512UL, 0x82e51a31UL, 0x89eb133cUL, 0x94f9082bUL, 0x9ff70126UL, +0x464de6bdUL, 0x4d43efb0UL, 0x5051f4a7UL, 0x5b5ffdaaUL, 0x6a75c289UL, 0x617bcb84UL, 0x7c69d093UL, 0x7767d99eUL, +0x1e3daed5UL, 0x1533a7d8UL, 0x0821bccfUL, 0x032fb5c2UL, 0x32058ae1UL, 0x390b83ecUL, 0x241998fbUL, 0x2f1791f6UL, +0x8d764dd6UL, 0x867844dbUL, 0x9b6a5fccUL, 0x906456c1UL, 0xa14e69e2UL, 0xaa4060efUL, 0xb7527bf8UL, 0xbc5c72f5UL, +0xd50605beUL, 0xde080cb3UL, 0xc31a17a4UL, 0xc8141ea9UL, 0xf93e218aUL, 0xf2302887UL, 0xef223390UL, 0xe42c3a9dUL, +0x3d96dd06UL, 0x3698d40bUL, 0x2b8acf1cUL, 0x2084c611UL, 0x11aef932UL, 0x1aa0f03fUL, 0x07b2eb28UL, 0x0cbce225UL, +0x65e6956eUL, 0x6ee89c63UL, 0x73fa8774UL, 0x78f48e79UL, 0x49deb15aUL, 0x42d0b857UL, 0x5fc2a340UL, 0x54ccaa4dUL, +0xf741ecdaUL, 0xfc4fe5d7UL, 0xe15dfec0UL, 0xea53f7cdUL, 0xdb79c8eeUL, 0xd077c1e3UL, 0xcd65daf4UL, 0xc66bd3f9UL, +0xaf31a4b2UL, 0xa43fadbfUL, 0xb92db6a8UL, 0xb223bfa5UL, 0x83098086UL, 0x8807898bUL, 0x9515929cUL, 0x9e1b9b91UL, +0x47a17c0aUL, 0x4caf7507UL, 0x51bd6e10UL, 0x5ab3671dUL, 0x6b99583eUL, 0x60975133UL, 0x7d854a24UL, 0x768b4329UL, +0x1fd13462UL, 0x14df3d6fUL, 0x09cd2678UL, 0x02c32f75UL, 0x33e91056UL, 0x38e7195bUL, 0x25f5024cUL, 0x2efb0b41UL, +0x8c9ad761UL, 0x8794de6cUL, 0x9a86c57bUL, 0x9188cc76UL, 0xa0a2f355UL, 0xabacfa58UL, 0xb6bee14fUL, 0xbdb0e842UL, +0xd4ea9f09UL, 0xdfe49604UL, 0xc2f68d13UL, 0xc9f8841eUL, 0xf8d2bb3dUL, 0xf3dcb230UL, 0xeecea927UL, 0xe5c0a02aUL, +0x3c7a47b1UL, 0x37744ebcUL, 0x2a6655abUL, 0x21685ca6UL, 0x10426385UL, 0x1b4c6a88UL, 0x065e719fUL, 0x0d507892UL, +0x640a0fd9UL, 0x6f0406d4UL, 0x72161dc3UL, 0x791814ceUL, 0x48322bedUL, 0x433c22e0UL, 0x5e2e39f7UL, 0x552030faUL, +0x01ec9ab7UL, 0x0ae293baUL, 0x17f088adUL, 0x1cfe81a0UL, 0x2dd4be83UL, 0x26dab78eUL, 0x3bc8ac99UL, 0x30c6a594UL, +0x599cd2dfUL, 0x5292dbd2UL, 0x4f80c0c5UL, 0x448ec9c8UL, 0x75a4f6ebUL, 0x7eaaffe6UL, 0x63b8e4f1UL, 0x68b6edfcUL, +0xb10c0a67UL, 0xba02036aUL, 0xa710187dUL, 0xac1e1170UL, 0x9d342e53UL, 0x963a275eUL, 0x8b283c49UL, 0x80263544UL, +0xe97c420fUL, 0xe2724b02UL, 0xff605015UL, 0xf46e5918UL, 0xc544663bUL, 0xce4a6f36UL, 0xd3587421UL, 0xd8567d2cUL, +0x7a37a10cUL, 0x7139a801UL, 0x6c2bb316UL, 0x6725ba1bUL, 0x560f8538UL, 0x5d018c35UL, 0x40139722UL, 0x4b1d9e2fUL, +0x2247e964UL, 0x2949e069UL, 0x345bfb7eUL, 0x3f55f273UL, 0x0e7fcd50UL, 0x0571c45dUL, 0x1863df4aUL, 0x136dd647UL, +0xcad731dcUL, 0xc1d938d1UL, 0xdccb23c6UL, 0xd7c52acbUL, 0xe6ef15e8UL, 0xede11ce5UL, 0xf0f307f2UL, 0xfbfd0effUL, +0x92a779b4UL, 0x99a970b9UL, 0x84bb6baeUL, 0x8fb562a3UL, 0xbe9f5d80UL, 0xb591548dUL, 0xa8834f9aUL, 0xa38d4697UL +}; + +static const ulong32 Tks2[] = { +0x00000000UL, 0x0d0b0e09UL, 0x1a161c12UL, 0x171d121bUL, 0x342c3824UL, 0x3927362dUL, 0x2e3a2436UL, 0x23312a3fUL, +0x68587048UL, 0x65537e41UL, 0x724e6c5aUL, 0x7f456253UL, 0x5c74486cUL, 0x517f4665UL, 0x4662547eUL, 0x4b695a77UL, +0xd0b0e090UL, 0xddbbee99UL, 0xcaa6fc82UL, 0xc7adf28bUL, 0xe49cd8b4UL, 0xe997d6bdUL, 0xfe8ac4a6UL, 0xf381caafUL, +0xb8e890d8UL, 0xb5e39ed1UL, 0xa2fe8ccaUL, 0xaff582c3UL, 0x8cc4a8fcUL, 0x81cfa6f5UL, 0x96d2b4eeUL, 0x9bd9bae7UL, +0xbb7bdb3bUL, 0xb670d532UL, 0xa16dc729UL, 0xac66c920UL, 0x8f57e31fUL, 0x825ced16UL, 0x9541ff0dUL, 0x984af104UL, +0xd323ab73UL, 0xde28a57aUL, 0xc935b761UL, 0xc43eb968UL, 0xe70f9357UL, 0xea049d5eUL, 0xfd198f45UL, 0xf012814cUL, +0x6bcb3babUL, 0x66c035a2UL, 0x71dd27b9UL, 0x7cd629b0UL, 0x5fe7038fUL, 0x52ec0d86UL, 0x45f11f9dUL, 0x48fa1194UL, +0x03934be3UL, 0x0e9845eaUL, 0x198557f1UL, 0x148e59f8UL, 0x37bf73c7UL, 0x3ab47dceUL, 0x2da96fd5UL, 0x20a261dcUL, +0x6df6ad76UL, 0x60fda37fUL, 0x77e0b164UL, 0x7aebbf6dUL, 0x59da9552UL, 0x54d19b5bUL, 0x43cc8940UL, 0x4ec78749UL, +0x05aedd3eUL, 0x08a5d337UL, 0x1fb8c12cUL, 0x12b3cf25UL, 0x3182e51aUL, 0x3c89eb13UL, 0x2b94f908UL, 0x269ff701UL, +0xbd464de6UL, 0xb04d43efUL, 0xa75051f4UL, 0xaa5b5ffdUL, 0x896a75c2UL, 0x84617bcbUL, 0x937c69d0UL, 0x9e7767d9UL, +0xd51e3daeUL, 0xd81533a7UL, 0xcf0821bcUL, 0xc2032fb5UL, 0xe132058aUL, 0xec390b83UL, 0xfb241998UL, 0xf62f1791UL, +0xd68d764dUL, 0xdb867844UL, 0xcc9b6a5fUL, 0xc1906456UL, 0xe2a14e69UL, 0xefaa4060UL, 0xf8b7527bUL, 0xf5bc5c72UL, +0xbed50605UL, 0xb3de080cUL, 0xa4c31a17UL, 0xa9c8141eUL, 0x8af93e21UL, 0x87f23028UL, 0x90ef2233UL, 0x9de42c3aUL, +0x063d96ddUL, 0x0b3698d4UL, 0x1c2b8acfUL, 0x112084c6UL, 0x3211aef9UL, 0x3f1aa0f0UL, 0x2807b2ebUL, 0x250cbce2UL, +0x6e65e695UL, 0x636ee89cUL, 0x7473fa87UL, 0x7978f48eUL, 0x5a49deb1UL, 0x5742d0b8UL, 0x405fc2a3UL, 0x4d54ccaaUL, +0xdaf741ecUL, 0xd7fc4fe5UL, 0xc0e15dfeUL, 0xcdea53f7UL, 0xeedb79c8UL, 0xe3d077c1UL, 0xf4cd65daUL, 0xf9c66bd3UL, +0xb2af31a4UL, 0xbfa43fadUL, 0xa8b92db6UL, 0xa5b223bfUL, 0x86830980UL, 0x8b880789UL, 0x9c951592UL, 0x919e1b9bUL, +0x0a47a17cUL, 0x074caf75UL, 0x1051bd6eUL, 0x1d5ab367UL, 0x3e6b9958UL, 0x33609751UL, 0x247d854aUL, 0x29768b43UL, +0x621fd134UL, 0x6f14df3dUL, 0x7809cd26UL, 0x7502c32fUL, 0x5633e910UL, 0x5b38e719UL, 0x4c25f502UL, 0x412efb0bUL, +0x618c9ad7UL, 0x6c8794deUL, 0x7b9a86c5UL, 0x769188ccUL, 0x55a0a2f3UL, 0x58abacfaUL, 0x4fb6bee1UL, 0x42bdb0e8UL, +0x09d4ea9fUL, 0x04dfe496UL, 0x13c2f68dUL, 0x1ec9f884UL, 0x3df8d2bbUL, 0x30f3dcb2UL, 0x27eecea9UL, 0x2ae5c0a0UL, +0xb13c7a47UL, 0xbc37744eUL, 0xab2a6655UL, 0xa621685cUL, 0x85104263UL, 0x881b4c6aUL, 0x9f065e71UL, 0x920d5078UL, +0xd9640a0fUL, 0xd46f0406UL, 0xc372161dUL, 0xce791814UL, 0xed48322bUL, 0xe0433c22UL, 0xf75e2e39UL, 0xfa552030UL, +0xb701ec9aUL, 0xba0ae293UL, 0xad17f088UL, 0xa01cfe81UL, 0x832dd4beUL, 0x8e26dab7UL, 0x993bc8acUL, 0x9430c6a5UL, +0xdf599cd2UL, 0xd25292dbUL, 0xc54f80c0UL, 0xc8448ec9UL, 0xeb75a4f6UL, 0xe67eaaffUL, 0xf163b8e4UL, 0xfc68b6edUL, +0x67b10c0aUL, 0x6aba0203UL, 0x7da71018UL, 0x70ac1e11UL, 0x539d342eUL, 0x5e963a27UL, 0x498b283cUL, 0x44802635UL, +0x0fe97c42UL, 0x02e2724bUL, 0x15ff6050UL, 0x18f46e59UL, 0x3bc54466UL, 0x36ce4a6fUL, 0x21d35874UL, 0x2cd8567dUL, +0x0c7a37a1UL, 0x017139a8UL, 0x166c2bb3UL, 0x1b6725baUL, 0x38560f85UL, 0x355d018cUL, 0x22401397UL, 0x2f4b1d9eUL, +0x642247e9UL, 0x692949e0UL, 0x7e345bfbUL, 0x733f55f2UL, 0x500e7fcdUL, 0x5d0571c4UL, 0x4a1863dfUL, 0x47136dd6UL, +0xdccad731UL, 0xd1c1d938UL, 0xc6dccb23UL, 0xcbd7c52aUL, 0xe8e6ef15UL, 0xe5ede11cUL, 0xf2f0f307UL, 0xfffbfd0eUL, +0xb492a779UL, 0xb999a970UL, 0xae84bb6bUL, 0xa38fb562UL, 0x80be9f5dUL, 0x8db59154UL, 0x9aa8834fUL, 0x97a38d46UL +}; + +static const ulong32 Tks3[] = { +0x00000000UL, 0x090d0b0eUL, 0x121a161cUL, 0x1b171d12UL, 0x24342c38UL, 0x2d392736UL, 0x362e3a24UL, 0x3f23312aUL, +0x48685870UL, 0x4165537eUL, 0x5a724e6cUL, 0x537f4562UL, 0x6c5c7448UL, 0x65517f46UL, 0x7e466254UL, 0x774b695aUL, +0x90d0b0e0UL, 0x99ddbbeeUL, 0x82caa6fcUL, 0x8bc7adf2UL, 0xb4e49cd8UL, 0xbde997d6UL, 0xa6fe8ac4UL, 0xaff381caUL, +0xd8b8e890UL, 0xd1b5e39eUL, 0xcaa2fe8cUL, 0xc3aff582UL, 0xfc8cc4a8UL, 0xf581cfa6UL, 0xee96d2b4UL, 0xe79bd9baUL, +0x3bbb7bdbUL, 0x32b670d5UL, 0x29a16dc7UL, 0x20ac66c9UL, 0x1f8f57e3UL, 0x16825cedUL, 0x0d9541ffUL, 0x04984af1UL, +0x73d323abUL, 0x7ade28a5UL, 0x61c935b7UL, 0x68c43eb9UL, 0x57e70f93UL, 0x5eea049dUL, 0x45fd198fUL, 0x4cf01281UL, +0xab6bcb3bUL, 0xa266c035UL, 0xb971dd27UL, 0xb07cd629UL, 0x8f5fe703UL, 0x8652ec0dUL, 0x9d45f11fUL, 0x9448fa11UL, +0xe303934bUL, 0xea0e9845UL, 0xf1198557UL, 0xf8148e59UL, 0xc737bf73UL, 0xce3ab47dUL, 0xd52da96fUL, 0xdc20a261UL, +0x766df6adUL, 0x7f60fda3UL, 0x6477e0b1UL, 0x6d7aebbfUL, 0x5259da95UL, 0x5b54d19bUL, 0x4043cc89UL, 0x494ec787UL, +0x3e05aeddUL, 0x3708a5d3UL, 0x2c1fb8c1UL, 0x2512b3cfUL, 0x1a3182e5UL, 0x133c89ebUL, 0x082b94f9UL, 0x01269ff7UL, +0xe6bd464dUL, 0xefb04d43UL, 0xf4a75051UL, 0xfdaa5b5fUL, 0xc2896a75UL, 0xcb84617bUL, 0xd0937c69UL, 0xd99e7767UL, +0xaed51e3dUL, 0xa7d81533UL, 0xbccf0821UL, 0xb5c2032fUL, 0x8ae13205UL, 0x83ec390bUL, 0x98fb2419UL, 0x91f62f17UL, +0x4dd68d76UL, 0x44db8678UL, 0x5fcc9b6aUL, 0x56c19064UL, 0x69e2a14eUL, 0x60efaa40UL, 0x7bf8b752UL, 0x72f5bc5cUL, +0x05bed506UL, 0x0cb3de08UL, 0x17a4c31aUL, 0x1ea9c814UL, 0x218af93eUL, 0x2887f230UL, 0x3390ef22UL, 0x3a9de42cUL, +0xdd063d96UL, 0xd40b3698UL, 0xcf1c2b8aUL, 0xc6112084UL, 0xf93211aeUL, 0xf03f1aa0UL, 0xeb2807b2UL, 0xe2250cbcUL, +0x956e65e6UL, 0x9c636ee8UL, 0x877473faUL, 0x8e7978f4UL, 0xb15a49deUL, 0xb85742d0UL, 0xa3405fc2UL, 0xaa4d54ccUL, +0xecdaf741UL, 0xe5d7fc4fUL, 0xfec0e15dUL, 0xf7cdea53UL, 0xc8eedb79UL, 0xc1e3d077UL, 0xdaf4cd65UL, 0xd3f9c66bUL, +0xa4b2af31UL, 0xadbfa43fUL, 0xb6a8b92dUL, 0xbfa5b223UL, 0x80868309UL, 0x898b8807UL, 0x929c9515UL, 0x9b919e1bUL, +0x7c0a47a1UL, 0x75074cafUL, 0x6e1051bdUL, 0x671d5ab3UL, 0x583e6b99UL, 0x51336097UL, 0x4a247d85UL, 0x4329768bUL, +0x34621fd1UL, 0x3d6f14dfUL, 0x267809cdUL, 0x2f7502c3UL, 0x105633e9UL, 0x195b38e7UL, 0x024c25f5UL, 0x0b412efbUL, +0xd7618c9aUL, 0xde6c8794UL, 0xc57b9a86UL, 0xcc769188UL, 0xf355a0a2UL, 0xfa58abacUL, 0xe14fb6beUL, 0xe842bdb0UL, +0x9f09d4eaUL, 0x9604dfe4UL, 0x8d13c2f6UL, 0x841ec9f8UL, 0xbb3df8d2UL, 0xb230f3dcUL, 0xa927eeceUL, 0xa02ae5c0UL, +0x47b13c7aUL, 0x4ebc3774UL, 0x55ab2a66UL, 0x5ca62168UL, 0x63851042UL, 0x6a881b4cUL, 0x719f065eUL, 0x78920d50UL, +0x0fd9640aUL, 0x06d46f04UL, 0x1dc37216UL, 0x14ce7918UL, 0x2bed4832UL, 0x22e0433cUL, 0x39f75e2eUL, 0x30fa5520UL, +0x9ab701ecUL, 0x93ba0ae2UL, 0x88ad17f0UL, 0x81a01cfeUL, 0xbe832dd4UL, 0xb78e26daUL, 0xac993bc8UL, 0xa59430c6UL, +0xd2df599cUL, 0xdbd25292UL, 0xc0c54f80UL, 0xc9c8448eUL, 0xf6eb75a4UL, 0xffe67eaaUL, 0xe4f163b8UL, 0xedfc68b6UL, +0x0a67b10cUL, 0x036aba02UL, 0x187da710UL, 0x1170ac1eUL, 0x2e539d34UL, 0x275e963aUL, 0x3c498b28UL, 0x35448026UL, +0x420fe97cUL, 0x4b02e272UL, 0x5015ff60UL, 0x5918f46eUL, 0x663bc544UL, 0x6f36ce4aUL, 0x7421d358UL, 0x7d2cd856UL, +0xa10c7a37UL, 0xa8017139UL, 0xb3166c2bUL, 0xba1b6725UL, 0x8538560fUL, 0x8c355d01UL, 0x97224013UL, 0x9e2f4b1dUL, +0xe9642247UL, 0xe0692949UL, 0xfb7e345bUL, 0xf2733f55UL, 0xcd500e7fUL, 0xc45d0571UL, 0xdf4a1863UL, 0xd647136dUL, +0x31dccad7UL, 0x38d1c1d9UL, 0x23c6dccbUL, 0x2acbd7c5UL, 0x15e8e6efUL, 0x1ce5ede1UL, 0x07f2f0f3UL, 0x0efffbfdUL, +0x79b492a7UL, 0x70b999a9UL, 0x6bae84bbUL, 0x62a38fb5UL, 0x5d80be9fUL, 0x548db591UL, 0x4f9aa883UL, 0x4697a38dUL +}; + +#endif /* ENCRYPT_ONLY */ + +#endif /* SMALL CODE */ + +#ifndef PELI_TAB +static const ulong32 rcon[] = { + 0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, + 0x10000000UL, 0x20000000UL, 0x40000000UL, 0x80000000UL, + 0x1B000000UL, 0x36000000UL, /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */ +}; +#endif + +#endif /* LTC_AES_TAB_C */ diff --git a/libtomcrypt/src/headers/tomcrypt.h b/libtomcrypt/src/headers/tomcrypt.h new file mode 100644 index 0000000..c310a8c --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt.h @@ -0,0 +1,95 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#ifndef TOMCRYPT_H_ +#define TOMCRYPT_H_ +#include +#include +#include +#include +#include +#include +#include +#include + +/* use configuration data */ +#include "tomcrypt_custom.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* version */ +#define CRYPT 0x0118 +#define SCRYPT "1.18.2-develop" + +/* max size of either a cipher/hash block or symmetric key [largest of the two] */ +#define MAXBLOCKSIZE 144 + +#ifndef TAB_SIZE +/* descriptor table size */ +#define TAB_SIZE 34 +#endif + +/* error codes [will be expanded in future releases] */ +enum { + CRYPT_OK=0, /* Result OK */ + CRYPT_ERROR, /* Generic Error */ + CRYPT_NOP, /* Not a failure but no operation was performed */ + + CRYPT_INVALID_KEYSIZE, /* Invalid key size given */ + CRYPT_INVALID_ROUNDS, /* Invalid number of rounds */ + CRYPT_FAIL_TESTVECTOR, /* Algorithm failed test vectors */ + + CRYPT_BUFFER_OVERFLOW, /* Not enough space for output */ + CRYPT_INVALID_PACKET, /* Invalid input packet given */ + + CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */ + CRYPT_ERROR_READPRNG, /* Could not read enough from PRNG */ + + CRYPT_INVALID_CIPHER, /* Invalid cipher specified */ + CRYPT_INVALID_HASH, /* Invalid hash specified */ + CRYPT_INVALID_PRNG, /* Invalid PRNG specified */ + + CRYPT_MEM, /* Out of memory */ + + CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */ + CRYPT_PK_NOT_PRIVATE, /* Requires a private PK key */ + + CRYPT_INVALID_ARG, /* Generic invalid argument */ + CRYPT_FILE_NOTFOUND, /* File Not Found */ + + CRYPT_PK_INVALID_TYPE, /* Invalid type of PK key */ + + CRYPT_OVERFLOW, /* An overflow of a value was detected/prevented */ + + CRYPT_PK_ASN1_ERROR, /* An error occurred while en- or decoding ASN.1 data */ + + CRYPT_INPUT_TOO_LONG, /* The input was longer than expected. */ + + CRYPT_PK_INVALID_SIZE, /* Invalid size input for PK parameters */ + + CRYPT_INVALID_PRIME_SIZE,/* Invalid size of prime requested */ + CRYPT_PK_INVALID_PADDING, /* Invalid padding on input */ + + CRYPT_HASH_OVERFLOW /* Hash applied to too many bits */ +}; + +#include "tomcrypt_cfg.h" +#include "tomcrypt_macros.h" +#include "tomcrypt_cipher.h" +#include "tomcrypt_hash.h" +#include "tomcrypt_mac.h" +#include "tomcrypt_prng.h" +#include "tomcrypt_pk.h" +#include "tomcrypt_math.h" +#include "tomcrypt_misc.h" +#include "tomcrypt_argchk.h" +#include "tomcrypt_pkcs.h" + +#ifdef __cplusplus + } +#endif + +#endif /* TOMCRYPT_H_ */ + diff --git a/libtomcrypt/src/headers/tomcrypt_argchk.h b/libtomcrypt/src/headers/tomcrypt_argchk.h new file mode 100644 index 0000000..f3884e9 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_argchk.h @@ -0,0 +1,38 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* Defines the LTC_ARGCHK macro used within the library */ +/* ARGTYPE is defined in tomcrypt_cfg.h */ + +/* ARGTYPE is per default defined to 0 */ +#if ARGTYPE == 0 + +#include + +LTC_NORETURN void crypt_argchk(const char *v, const char *s, int d); +#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) +#define LTC_ARGCHKVD(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0) + +#elif ARGTYPE == 1 + +/* fatal type of error */ +#define LTC_ARGCHK(x) assert((x)) +#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) + +#elif ARGTYPE == 2 + +#define LTC_ARGCHK(x) if (!(x)) { fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); } +#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) + +#elif ARGTYPE == 3 + +#define LTC_ARGCHK(x) LTC_UNUSED_PARAM(x) +#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) + +#elif ARGTYPE == 4 + +#define LTC_ARGCHK(x) if (!(x)) return CRYPT_INVALID_ARG; +#define LTC_ARGCHKVD(x) if (!(x)) return; + +#endif + diff --git a/libtomcrypt/src/headers/tomcrypt_cfg.h b/libtomcrypt/src/headers/tomcrypt_cfg.h new file mode 100644 index 0000000..994a084 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_cfg.h @@ -0,0 +1,314 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* This is the build config file. + * + * With this you can setup what to inlcude/exclude automatically during any build. Just comment + * out the line that #define's the word for the thing you want to remove. phew! + */ + +#ifndef TOMCRYPT_CFG_H +#define TOMCRYPT_CFG_H + +#if defined(_WIN32) || defined(_MSC_VER) + #define LTC_CALL __cdecl +#elif !defined(LTC_CALL) + #define LTC_CALL +#endif + +#ifndef LTC_EXPORT + #define LTC_EXPORT +#endif + +/* certain platforms use macros for these, making the prototypes broken */ +#ifndef LTC_NO_PROTOTYPES + +/* you can change how memory allocation works ... */ +LTC_EXPORT void * LTC_CALL XMALLOC(size_t n); +LTC_EXPORT void * LTC_CALL XREALLOC(void *p, size_t n); +LTC_EXPORT void * LTC_CALL XCALLOC(size_t n, size_t s); +LTC_EXPORT void LTC_CALL XFREE(void *p); + +LTC_EXPORT void LTC_CALL XQSORT(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)); + + +/* change the clock function too */ +LTC_EXPORT clock_t LTC_CALL XCLOCK(void); + +/* various other functions */ +LTC_EXPORT void * LTC_CALL XMEMCPY(void *dest, const void *src, size_t n); +LTC_EXPORT int LTC_CALL XMEMCMP(const void *s1, const void *s2, size_t n); +LTC_EXPORT void * LTC_CALL XMEMSET(void *s, int c, size_t n); + +LTC_EXPORT int LTC_CALL XSTRCMP(const char *s1, const char *s2); + +#endif + +/* some compilers do not like "inline" (or maybe "static inline"), namely: HP cc, IBM xlc */ +#if defined(__GNUC__) || defined(__xlc__) + #define LTC_INLINE __inline__ +#elif defined(_MSC_VER) || defined(__HP_cc) + #define LTC_INLINE __inline +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define LTC_INLINE inline +#else + #define LTC_INLINE +#endif + +#if defined(__clang__) || defined(__GNUC_MINOR__) +#define LTC_NORETURN __attribute__ ((noreturn)) +#elif defined(_MSC_VER) +#define LTC_NORETURN __declspec(noreturn) +#else +#define LTC_NORETURN +#endif + +/* type of argument checking, 0=default, 1=fatal and 2=error+continue, 3=nothing */ +#ifndef ARGTYPE + #define ARGTYPE 0 +#endif + +#undef LTC_ENCRYPT +#define LTC_ENCRYPT 0 +#undef LTC_DECRYPT +#define LTC_DECRYPT 1 + +/* Controls endianess and size of registers. Leave uncommented to get platform neutral [slower] code + * + * Note: in order to use the optimized macros your platform must support unaligned 32 and 64 bit read/writes. + * The x86 platforms allow this but some others [ARM for instance] do not. On those platforms you **MUST** + * use the portable [slower] macros. + */ +/* detect x86/i386 32bit */ +#if defined(__i386__) || defined(__i386) || defined(_M_IX86) + #define ENDIAN_LITTLE + #define ENDIAN_32BITWORD + #define LTC_FAST +#endif + +/* detect amd64/x64 */ +#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) + #define ENDIAN_LITTLE + #define ENDIAN_64BITWORD + #define LTC_FAST +#endif + +/* detect PPC32 */ +#if defined(LTC_PPC32) + #define ENDIAN_BIG + #define ENDIAN_32BITWORD + #define LTC_FAST +#endif + +/* detects MIPS R5900 processors (PS2) */ +#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && (defined(_mips) || defined(__mips__) || defined(mips)) + #define ENDIAN_64BITWORD + #if defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) + #define ENDIAN_BIG + #else + #define ENDIAN_LITTLE + #endif +#endif + +/* detect AIX */ +#if defined(_AIX) && defined(_BIG_ENDIAN) + #define ENDIAN_BIG + #if defined(__LP64__) || defined(_ARCH_PPC64) + #define ENDIAN_64BITWORD + #else + #define ENDIAN_32BITWORD + #endif +#endif + +/* detect HP-UX */ +#if defined(__hpux) || defined(__hpux__) + #define ENDIAN_BIG + #if defined(__ia64) || defined(__ia64__) || defined(__LP64__) + #define ENDIAN_64BITWORD + #else + #define ENDIAN_32BITWORD + #endif +#endif + +/* detect Apple OS X */ +#if defined(__APPLE__) && defined(__MACH__) + #if defined(__LITTLE_ENDIAN__) || defined(__x86_64__) + #define ENDIAN_LITTLE + #else + #define ENDIAN_BIG + #endif + #if defined(__LP64__) || defined(__x86_64__) + #define ENDIAN_64BITWORD + #else + #define ENDIAN_32BITWORD + #endif +#endif + +/* detect SPARC and SPARC64 */ +#if defined(__sparc__) || defined(__sparc) + #define ENDIAN_BIG + #if defined(__arch64__) || defined(__sparcv9) || defined(__sparc_v9__) + #define ENDIAN_64BITWORD + #else + #define ENDIAN_32BITWORD + #endif +#endif + +/* detect IBM S390(x) */ +#if defined(__s390x__) || defined(__s390__) + #define ENDIAN_BIG + #if defined(__s390x__) + #define ENDIAN_64BITWORD + #else + #define ENDIAN_32BITWORD + #endif +#endif + +/* detect PPC64 */ +#if defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) + #define ENDIAN_64BITWORD + #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + #define ENDIAN_BIG + #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + #define ENDIAN_LITTLE + #endif + #define LTC_FAST +#endif + +/* endianness fallback */ +#if !defined(ENDIAN_BIG) && !defined(ENDIAN_LITTLE) + #if defined(_BYTE_ORDER) && _BYTE_ORDER == _BIG_ENDIAN || \ + defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \ + defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ || \ + defined(__BIG_ENDIAN__) || \ + defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \ + defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || \ + defined(__m68k__) + #define ENDIAN_BIG + #elif defined(_BYTE_ORDER) && _BYTE_ORDER == _LITTLE_ENDIAN || \ + defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \ + defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ || \ + defined(__LITTLE_ENDIAN__) || \ + defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \ + defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) + #define ENDIAN_LITTLE + #else + #error Cannot detect endianness + #endif +#endif + +/* ulong64: 64-bit data type */ +#ifdef _MSC_VER + #define CONST64(n) n ## ui64 + typedef unsigned __int64 ulong64; + typedef __int64 long64; +#else + #define CONST64(n) n ## ULL + typedef unsigned long long ulong64; + typedef long long long64; +#endif + +/* ulong32: "32-bit at least" data type */ +#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) || \ + defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \ + defined(__s390x__) || defined(__arch64__) || defined(__aarch64__) || \ + defined(__sparcv9) || defined(__sparc_v9__) || defined(__sparc64__) || \ + defined(__ia64) || defined(__ia64__) || defined(__itanium__) || defined(_M_IA64) || \ + defined(__LP64__) || defined(_LP64) || defined(__64BIT__) + typedef unsigned ulong32; + #if !defined(ENDIAN_64BITWORD) && !defined(ENDIAN_32BITWORD) + #define ENDIAN_64BITWORD + #endif +#else + typedef unsigned long ulong32; + #if !defined(ENDIAN_64BITWORD) && !defined(ENDIAN_32BITWORD) + #define ENDIAN_32BITWORD + #endif +#endif + +#if defined(ENDIAN_64BITWORD) && !defined(_MSC_VER) +typedef unsigned long long ltc_mp_digit; +#else +typedef unsigned long ltc_mp_digit; +#endif + +/* No asm is a quick way to disable anything "not portable" */ +#ifdef LTC_NO_ASM + #define ENDIAN_NEUTRAL + #undef ENDIAN_32BITWORD + #undef ENDIAN_64BITWORD + #undef LTC_FAST + #define LTC_NO_BSWAP + #define LTC_NO_ROLC + #define LTC_NO_ROTATE +#endif + +/* No LTC_FAST if: explicitly disabled OR non-gcc/non-clang compiler OR old gcc OR using -ansi -std=c99 */ +#if defined(LTC_NO_FAST) || (__GNUC__ < 4) || defined(__STRICT_ANSI__) + #undef LTC_FAST +#endif + +#ifdef LTC_FAST + #define LTC_FAST_TYPE_PTR_CAST(x) ((LTC_FAST_TYPE*)(void*)(x)) + #ifdef ENDIAN_64BITWORD + typedef ulong64 __attribute__((__may_alias__)) LTC_FAST_TYPE; + #else + typedef ulong32 __attribute__((__may_alias__)) LTC_FAST_TYPE; + #endif +#endif + +#if !defined(ENDIAN_NEUTRAL) && (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD)) + #error You must specify a word size as well as endianess in tomcrypt_cfg.h +#endif + +#if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) + #define ENDIAN_NEUTRAL +#endif + +#if (defined(ENDIAN_32BITWORD) && defined(ENDIAN_64BITWORD)) + #error Cannot be 32 and 64 bit words... +#endif + +/* gcc 4.3 and up has a bswap builtin; detect it by gcc version. + * clang also supports the bswap builtin, and although clang pretends + * to be gcc (macro-wise, anyway), clang pretends to be a version + * prior to gcc 4.3, so we can't detect bswap that way. Instead, + * clang has a __has_builtin mechanism that can be used to check + * for builtins: + * http://clang.llvm.org/docs/LanguageExtensions.html#feature_check */ +#ifndef __has_builtin + #define __has_builtin(x) 0 +#endif +#if !defined(LTC_NO_BSWAP) && defined(__GNUC__) && \ + ((__GNUC__ * 100 + __GNUC_MINOR__ >= 403) || \ + (__has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64))) + #define LTC_HAVE_BSWAP_BUILTIN +#endif + +#if !defined(LTC_NO_ROTATE) && (__has_builtin(__builtin_rotateleft32) && __has_builtin(__builtin_rotateright32)) + #define LTC_HAVE_ROTATE_BUILTIN +#endif + +#if defined(__GNUC__) + #define LTC_ALIGN(n) __attribute__((aligned(n))) +#else + #define LTC_ALIGN(n) +#endif + +#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 405) +# define LTC_DEPRECATED(s) __attribute__((deprecated("replaced by " #s))) +# define PRIVATE_LTC_DEPRECATED_PRAGMA(s) _Pragma(#s) +# define LTC_DEPRECATED_PRAGMA(s) PRIVATE_LTC_DEPRECATED_PRAGMA(GCC warning s) +#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 301) +# define LTC_DEPRECATED(s) __attribute__((deprecated)) +# define LTC_DEPRECATED_PRAGMA(s) +#elif defined(_MSC_VER) && _MSC_VER >= 1500 + /* supported since Visual Studio 2008 */ +# define LTC_DEPRECATED(s) __declspec(deprecated("replaced by " #s)) +# define LTC_DEPRECATED_PRAGMA(s) __pragma(message(s)) +#else +# define LTC_DEPRECATED(s) +# define LTC_DEPRECATED_PRAGMA(s) +#endif + +#endif /* TOMCRYPT_CFG_H */ diff --git a/libtomcrypt/src/headers/tomcrypt_cipher.h b/libtomcrypt/src/headers/tomcrypt_cipher.h new file mode 100644 index 0000000..a3ba8f3 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_cipher.h @@ -0,0 +1,1160 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- SYMMETRIC KEY STUFF ----- + * + * We put each of the ciphers scheduled keys in their own structs then we put all of + * the key formats in one union. This makes the function prototypes easier to use. + */ +#ifdef LTC_BLOWFISH +struct blowfish_key { + ulong32 S[4][256]; + ulong32 K[18]; +}; +#endif + +#ifdef LTC_RC5 +struct rc5_key { + int rounds; + ulong32 K[50]; +}; +#endif + +#ifdef LTC_RC6 +struct rc6_key { + ulong32 K[44]; +}; +#endif + +#ifdef LTC_SAFERP +struct saferp_key { + unsigned char K[33][16]; + long rounds; +}; +#endif + +#ifdef LTC_RIJNDAEL +struct rijndael_key { + ulong32 eK[60], dK[60]; + int Nr; +}; +#endif + +#ifdef LTC_KSEED +struct kseed_key { + ulong32 K[32], dK[32]; +}; +#endif + +#ifdef LTC_KASUMI +struct kasumi_key { + ulong32 KLi1[8], KLi2[8], + KOi1[8], KOi2[8], KOi3[8], + KIi1[8], KIi2[8], KIi3[8]; +}; +#endif + +#ifdef LTC_XTEA +struct xtea_key { + unsigned long A[32], B[32]; +}; +#endif + +#ifdef LTC_TWOFISH +#ifndef LTC_TWOFISH_SMALL + struct twofish_key { + ulong32 S[4][256], K[40]; + }; +#else + struct twofish_key { + ulong32 K[40]; + unsigned char S[32], start; + }; +#endif +#endif + +#ifdef LTC_SAFER +#define LTC_SAFER_K64_DEFAULT_NOF_ROUNDS 6 +#define LTC_SAFER_K128_DEFAULT_NOF_ROUNDS 10 +#define LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS 8 +#define LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS 10 +#define LTC_SAFER_MAX_NOF_ROUNDS 13 +#define LTC_SAFER_BLOCK_LEN 8 +#define LTC_SAFER_KEY_LEN (1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS)) +typedef unsigned char safer_block_t[LTC_SAFER_BLOCK_LEN]; +typedef unsigned char safer_key_t[LTC_SAFER_KEY_LEN]; +struct safer_key { safer_key_t key; }; +#endif + +#ifdef LTC_RC2 +struct rc2_key { unsigned xkey[64]; }; +#endif + +#ifdef LTC_DES +struct des_key { + ulong32 ek[32], dk[32]; +}; + +struct des3_key { + ulong32 ek[3][32], dk[3][32]; +}; +#endif + +#ifdef LTC_CAST5 +struct cast5_key { + ulong32 K[32], keylen; +}; +#endif + +#ifdef LTC_NOEKEON +struct noekeon_key { + ulong32 K[4], dK[4]; +}; +#endif + +#ifdef LTC_SKIPJACK +struct skipjack_key { + unsigned char key[10]; +}; +#endif + +#ifdef LTC_KHAZAD +struct khazad_key { + ulong64 roundKeyEnc[8 + 1]; + ulong64 roundKeyDec[8 + 1]; +}; +#endif + +#ifdef LTC_ANUBIS +struct anubis_key { + int keyBits; + int R; + ulong32 roundKeyEnc[18 + 1][4]; + ulong32 roundKeyDec[18 + 1][4]; +}; +#endif + +#ifdef LTC_MULTI2 +struct multi2_key { + int N; + ulong32 uk[8]; +}; +#endif + +#ifdef LTC_CAMELLIA +struct camellia_key { + int R; + ulong64 kw[4], k[24], kl[6]; +}; +#endif + +#ifdef LTC_IDEA +/* rounds */ +#define LTC_IDEA_ROUNDS 8 +/* key schedule length in # of unsigned shorts */ +#define LTC_IDEA_KEYLEN 6*LTC_IDEA_ROUNDS+4 +struct idea_key { + unsigned short int ek[LTC_IDEA_KEYLEN]; /* enc key */ + unsigned short int dk[LTC_IDEA_KEYLEN]; /* dec key */ +}; +#endif + +#ifdef LTC_SERPENT +struct serpent_key { + ulong32 k[33*4]; +}; +#endif + +#ifdef LTC_TEA +struct tea_key { + ulong32 k[4]; +}; +#endif + +typedef union Symmetric_key { +#ifdef LTC_DES + struct des_key des; + struct des3_key des3; +#endif +#ifdef LTC_RC2 + struct rc2_key rc2; +#endif +#ifdef LTC_SAFER + struct safer_key safer; +#endif +#ifdef LTC_TWOFISH + struct twofish_key twofish; +#endif +#ifdef LTC_BLOWFISH + struct blowfish_key blowfish; +#endif +#ifdef LTC_RC5 + struct rc5_key rc5; +#endif +#ifdef LTC_RC6 + struct rc6_key rc6; +#endif +#ifdef LTC_SAFERP + struct saferp_key saferp; +#endif +#ifdef LTC_RIJNDAEL + struct rijndael_key rijndael; +#endif +#ifdef LTC_XTEA + struct xtea_key xtea; +#endif +#ifdef LTC_CAST5 + struct cast5_key cast5; +#endif +#ifdef LTC_NOEKEON + struct noekeon_key noekeon; +#endif +#ifdef LTC_SKIPJACK + struct skipjack_key skipjack; +#endif +#ifdef LTC_KHAZAD + struct khazad_key khazad; +#endif +#ifdef LTC_ANUBIS + struct anubis_key anubis; +#endif +#ifdef LTC_KSEED + struct kseed_key kseed; +#endif +#ifdef LTC_KASUMI + struct kasumi_key kasumi; +#endif +#ifdef LTC_MULTI2 + struct multi2_key multi2; +#endif +#ifdef LTC_CAMELLIA + struct camellia_key camellia; +#endif +#ifdef LTC_IDEA + struct idea_key idea; +#endif +#ifdef LTC_SERPENT + struct serpent_key serpent; +#endif +#ifdef LTC_TEA + struct tea_key tea; +#endif + void *data; +} symmetric_key; + +#ifdef LTC_ECB_MODE +/** A block cipher ECB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen; + /** The scheduled key */ + symmetric_key key; +} symmetric_ECB; +#endif + +#ifdef LTC_CFB_MODE +/** A block cipher CFB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE], + /** The pad used to encrypt/decrypt */ + pad[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_CFB; +#endif + +#ifdef LTC_OFB_MODE +/** A block cipher OFB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_OFB; +#endif + +#ifdef LTC_CBC_MODE +/** A block cipher CBC structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_CBC; +#endif + + +#ifdef LTC_CTR_MODE +/** A block cipher CTR structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen, + /** The mode (endianess) of the CTR, 0==little, 1==big */ + mode, + /** counter width */ + ctrlen; + + /** The counter */ + unsigned char ctr[MAXBLOCKSIZE]; + /** The pad used to encrypt/decrypt */ + unsigned char pad[MAXBLOCKSIZE] LTC_ALIGN(16); + /** The scheduled key */ + symmetric_key key; +} symmetric_CTR; +#endif + + +#ifdef LTC_LRW_MODE +/** A LRW structure */ +typedef struct { + /** The index of the cipher chosen (must be a 128-bit block cipher) */ + int cipher; + + /** The current IV */ + unsigned char IV[16], + + /** the tweak key */ + tweak[16], + + /** The current pad, it's the product of the first 15 bytes against the tweak key */ + pad[16]; + + /** The scheduled symmetric key */ + symmetric_key key; + +#ifdef LTC_LRW_TABLES + /** The pre-computed multiplication table */ + unsigned char PC[16][256][16]; +#endif +} symmetric_LRW; +#endif + +#ifdef LTC_F8_MODE +/** A block cipher F8 structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE], + MIV[MAXBLOCKSIZE]; + /** Current block count */ + ulong32 blockcnt; + /** The scheduled key */ + symmetric_key key; +} symmetric_F8; +#endif + + +/** cipher descriptor table, last entry has "name == NULL" to mark the end of table */ +extern struct ltc_cipher_descriptor { + /** name of cipher */ + const char *name; + /** internal ID */ + unsigned char ID; + /** min keysize (octets) */ + int min_key_length, + /** max keysize (octets) */ + max_key_length, + /** block size (octets) */ + block_length, + /** default number of rounds */ + default_rounds; + /** Setup the cipher + @param key The input symmetric key + @param keylen The length of the input key (octets) + @param num_rounds The requested number of rounds (0==default) + @param skey [out] The destination of the scheduled key + @return CRYPT_OK if successful + */ + int (*setup)(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); + /** Encrypt a block + @param pt The plaintext + @param ct [out] The ciphertext + @param skey The scheduled key + @return CRYPT_OK if successful + */ + int (*ecb_encrypt)(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); + /** Decrypt a block + @param ct The ciphertext + @param pt [out] The plaintext + @param skey The scheduled key + @return CRYPT_OK if successful + */ + int (*ecb_decrypt)(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); + /** Test the block cipher + @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled + */ + int (*test)(void); + + /** Terminate the context + @param skey The scheduled key + */ + void (*done)(symmetric_key *skey); + + /** Determine a key size + @param keysize [in/out] The size of the key desired and the suggested size + @return CRYPT_OK if successful + */ + int (*keysize)(int *keysize); + +/** Accelerators **/ + /** Accelerated ECB encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ecb_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, symmetric_key *skey); + + /** Accelerated ECB decryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ecb_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, symmetric_key *skey); + + /** Accelerated CBC encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_cbc_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, symmetric_key *skey); + + /** Accelerated CBC decryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_cbc_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, symmetric_key *skey); + + /** Accelerated CTR encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param mode little or big endian counter (mode=0 or mode=1) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ctr_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, int mode, symmetric_key *skey); + + /** Accelerated LRW + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param tweak The LRW tweak + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_lrw_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); + + /** Accelerated LRW + @param ct Ciphertext + @param pt Plaintext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param tweak The LRW tweak + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_lrw_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); + + /** Accelerated CCM packet (one-shot) + @param key The secret key to use + @param keylen The length of the secret key (octets) + @param uskey A previously scheduled key [optional can be NULL] + @param nonce The session nonce [use once] + @param noncelen The length of the nonce + @param header The header for the session + @param headerlen The length of the header (octets) + @param pt [out] The plaintext + @param ptlen The length of the plaintext (octets) + @param ct [out] The ciphertext + @param tag [out] The destination tag + @param taglen [in/out] The max size and resulting size of the authentication tag + @param direction Encrypt or Decrypt direction (0 or 1) + @return CRYPT_OK if successful + */ + int (*accel_ccm_memory)( + const unsigned char *key, unsigned long keylen, + symmetric_key *uskey, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *header, unsigned long headerlen, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen, + int direction); + + /** Accelerated GCM packet (one shot) + @param key The secret key + @param keylen The length of the secret key + @param IV The initialization vector + @param IVlen The length of the initialization vector + @param adata The additional authentication data (header) + @param adatalen The length of the adata + @param pt The plaintext + @param ptlen The length of the plaintext (ciphertext length is the same) + @param ct The ciphertext + @param tag [out] The MAC tag + @param taglen [in/out] The MAC tag length + @param direction Encrypt or Decrypt mode (GCM_ENCRYPT or GCM_DECRYPT) + @return CRYPT_OK on success + */ + int (*accel_gcm_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *IV, unsigned long IVlen, + const unsigned char *adata, unsigned long adatalen, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen, + int direction); + + /** Accelerated one shot LTC_OMAC + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + */ + int (*omac_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated one shot XCBC + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + */ + int (*xcbc_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated one shot F9 + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + @remark Requires manual padding + */ + int (*f9_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated XTS encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param tweak The 128-bit encryption tweak (input/output). + The tweak should not be encrypted on input, but + next tweak will be copied encrypted on output. + @param skey1 The first scheduled key context + @param skey2 The second scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_xts_encrypt)(const unsigned char *pt, unsigned char *ct, + unsigned long blocks, unsigned char *tweak, + const symmetric_key *skey1, const symmetric_key *skey2); + + /** Accelerated XTS decryption + @param ct Ciphertext + @param pt Plaintext + @param blocks The number of complete blocks to process + @param tweak The 128-bit encryption tweak (input/output). + The tweak should not be encrypted on input, but + next tweak will be copied encrypted on output. + @param skey1 The first scheduled key context + @param skey2 The second scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_xts_decrypt)(const unsigned char *ct, unsigned char *pt, + unsigned long blocks, unsigned char *tweak, + const symmetric_key *skey1, const symmetric_key *skey2); +} cipher_descriptor[]; + +#ifdef LTC_BLOWFISH +int blowfish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int blowfish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int blowfish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int blowfish_test(void); +void blowfish_done(symmetric_key *skey); +int blowfish_keysize(int *keysize); +extern const struct ltc_cipher_descriptor blowfish_desc; +#endif + +#ifdef LTC_RC5 +int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int rc5_test(void); +void rc5_done(symmetric_key *skey); +int rc5_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc5_desc; +#endif + +#ifdef LTC_RC6 +int rc6_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc6_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int rc6_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int rc6_test(void); +void rc6_done(symmetric_key *skey); +int rc6_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc6_desc; +#endif + +#ifdef LTC_RC2 +int rc2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc2_setup_ex(const unsigned char *key, int keylen, int bits, int num_rounds, symmetric_key *skey); +int rc2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int rc2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int rc2_test(void); +void rc2_done(symmetric_key *skey); +int rc2_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc2_desc; +#endif + +#ifdef LTC_SAFERP +int saferp_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int saferp_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int saferp_test(void); +void saferp_done(symmetric_key *skey); +int saferp_keysize(int *keysize); +extern const struct ltc_cipher_descriptor saferp_desc; +#endif + +#ifdef LTC_SAFER +int safer_k64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_sk64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_k128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_sk128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int safer_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int safer_k64_test(void); +int safer_sk64_test(void); +int safer_sk128_test(void); +void safer_done(symmetric_key *skey); +int safer_64_keysize(int *keysize); +int safer_128_keysize(int *keysize); +extern const struct ltc_cipher_descriptor safer_k64_desc, safer_k128_desc, safer_sk64_desc, safer_sk128_desc; +#endif + +#ifdef LTC_RIJNDAEL + +/* make aes an alias */ +#define aes_setup rijndael_setup +#define aes_ecb_encrypt rijndael_ecb_encrypt +#define aes_ecb_decrypt rijndael_ecb_decrypt +#define aes_test rijndael_test +#define aes_done rijndael_done +#define aes_keysize rijndael_keysize + +#define aes_enc_setup rijndael_enc_setup +#define aes_enc_ecb_encrypt rijndael_enc_ecb_encrypt +#define aes_enc_keysize rijndael_enc_keysize + +int rijndael_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rijndael_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int rijndael_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int rijndael_test(void); +void rijndael_done(symmetric_key *skey); +int rijndael_keysize(int *keysize); +int rijndael_enc_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rijndael_enc_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +void rijndael_enc_done(symmetric_key *skey); +int rijndael_enc_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rijndael_desc, aes_desc; +extern const struct ltc_cipher_descriptor rijndael_enc_desc, aes_enc_desc; +#endif + +#ifdef LTC_XTEA +int xtea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int xtea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int xtea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int xtea_test(void); +void xtea_done(symmetric_key *skey); +int xtea_keysize(int *keysize); +extern const struct ltc_cipher_descriptor xtea_desc; +#endif + +#ifdef LTC_TWOFISH +int twofish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int twofish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int twofish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int twofish_test(void); +void twofish_done(symmetric_key *skey); +int twofish_keysize(int *keysize); +extern const struct ltc_cipher_descriptor twofish_desc; +#endif + +#ifdef LTC_DES +int des_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int des_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int des_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int des_test(void); +void des_done(symmetric_key *skey); +int des_keysize(int *keysize); +int des3_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int des3_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int des3_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int des3_test(void); +void des3_done(symmetric_key *skey); +int des3_keysize(int *keysize); +extern const struct ltc_cipher_descriptor des_desc, des3_desc; +#endif + +#ifdef LTC_CAST5 +int cast5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int cast5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int cast5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int cast5_test(void); +void cast5_done(symmetric_key *skey); +int cast5_keysize(int *keysize); +extern const struct ltc_cipher_descriptor cast5_desc; +#endif + +#ifdef LTC_NOEKEON +int noekeon_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int noekeon_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int noekeon_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int noekeon_test(void); +void noekeon_done(symmetric_key *skey); +int noekeon_keysize(int *keysize); +extern const struct ltc_cipher_descriptor noekeon_desc; +#endif + +#ifdef LTC_SKIPJACK +int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int skipjack_test(void); +void skipjack_done(symmetric_key *skey); +int skipjack_keysize(int *keysize); +extern const struct ltc_cipher_descriptor skipjack_desc; +#endif + +#ifdef LTC_KHAZAD +int khazad_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int khazad_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int khazad_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int khazad_test(void); +void khazad_done(symmetric_key *skey); +int khazad_keysize(int *keysize); +extern const struct ltc_cipher_descriptor khazad_desc; +#endif + +#ifdef LTC_ANUBIS +int anubis_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int anubis_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int anubis_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int anubis_test(void); +void anubis_done(symmetric_key *skey); +int anubis_keysize(int *keysize); +extern const struct ltc_cipher_descriptor anubis_desc; +#endif + +#ifdef LTC_KSEED +int kseed_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int kseed_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int kseed_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int kseed_test(void); +void kseed_done(symmetric_key *skey); +int kseed_keysize(int *keysize); +extern const struct ltc_cipher_descriptor kseed_desc; +#endif + +#ifdef LTC_KASUMI +int kasumi_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int kasumi_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int kasumi_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int kasumi_test(void); +void kasumi_done(symmetric_key *skey); +int kasumi_keysize(int *keysize); +extern const struct ltc_cipher_descriptor kasumi_desc; +#endif + + +#ifdef LTC_MULTI2 +int multi2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int multi2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int multi2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int multi2_test(void); +void multi2_done(symmetric_key *skey); +int multi2_keysize(int *keysize); +extern const struct ltc_cipher_descriptor multi2_desc; +#endif + +#ifdef LTC_CAMELLIA +int camellia_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int camellia_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int camellia_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int camellia_test(void); +void camellia_done(symmetric_key *skey); +int camellia_keysize(int *keysize); +extern const struct ltc_cipher_descriptor camellia_desc; +#endif + +#ifdef LTC_IDEA +int idea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int idea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int idea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int idea_test(void); +void idea_done(symmetric_key *skey); +int idea_keysize(int *keysize); +extern const struct ltc_cipher_descriptor idea_desc; +#endif + +#ifdef LTC_SERPENT +int serpent_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int serpent_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int serpent_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int serpent_test(void); +void serpent_done(symmetric_key *skey); +int serpent_keysize(int *keysize); +extern const struct ltc_cipher_descriptor serpent_desc; +#endif + +#ifdef LTC_TEA +int tea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int tea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, const symmetric_key *skey); +int tea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, const symmetric_key *skey); +int tea_test(void); +void tea_done(symmetric_key *skey); +int tea_keysize(int *keysize); +extern const struct ltc_cipher_descriptor tea_desc; +#endif + +#ifdef LTC_ECB_MODE +int ecb_start(int cipher, const unsigned char *key, + int keylen, int num_rounds, symmetric_ECB *ecb); +int ecb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_ECB *ecb); +int ecb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_ECB *ecb); +int ecb_done(symmetric_ECB *ecb); +#endif + +#ifdef LTC_CFB_MODE +int cfb_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_CFB *cfb); +int cfb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CFB *cfb); +int cfb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CFB *cfb); +int cfb_getiv(unsigned char *IV, unsigned long *len, const symmetric_CFB *cfb); +int cfb_setiv(const unsigned char *IV, unsigned long len, symmetric_CFB *cfb); +int cfb_done(symmetric_CFB *cfb); +#endif + +#ifdef LTC_OFB_MODE +int ofb_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_OFB *ofb); +int ofb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_OFB *ofb); +int ofb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_OFB *ofb); +int ofb_getiv(unsigned char *IV, unsigned long *len, const symmetric_OFB *ofb); +int ofb_setiv(const unsigned char *IV, unsigned long len, symmetric_OFB *ofb); +int ofb_done(symmetric_OFB *ofb); +#endif + +#ifdef LTC_CBC_MODE +int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_CBC *cbc); +int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CBC *cbc); +int cbc_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CBC *cbc); +int cbc_getiv(unsigned char *IV, unsigned long *len, const symmetric_CBC *cbc); +int cbc_setiv(const unsigned char *IV, unsigned long len, symmetric_CBC *cbc); +int cbc_done(symmetric_CBC *cbc); +#endif + +#ifdef LTC_CTR_MODE + +#define CTR_COUNTER_LITTLE_ENDIAN 0x0000 +#define CTR_COUNTER_BIG_ENDIAN 0x1000 +#define LTC_CTR_RFC3686 0x2000 + +int ctr_start( int cipher, + const unsigned char *IV, + const unsigned char *key, int keylen, + int num_rounds, int ctr_mode, + symmetric_CTR *ctr); +int ctr_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CTR *ctr); +int ctr_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CTR *ctr); +int ctr_getiv(unsigned char *IV, unsigned long *len, const symmetric_CTR *ctr); +int ctr_setiv(const unsigned char *IV, unsigned long len, symmetric_CTR *ctr); +int ctr_done(symmetric_CTR *ctr); +int ctr_test(void); +#endif + +#ifdef LTC_LRW_MODE + +#define LRW_ENCRYPT LTC_ENCRYPT +#define LRW_DECRYPT LTC_DECRYPT + +int lrw_start( int cipher, + const unsigned char *IV, + const unsigned char *key, int keylen, + const unsigned char *tweak, + int num_rounds, + symmetric_LRW *lrw); +int lrw_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_LRW *lrw); +int lrw_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_LRW *lrw); +int lrw_getiv(unsigned char *IV, unsigned long *len, const symmetric_LRW *lrw); +int lrw_setiv(const unsigned char *IV, unsigned long len, symmetric_LRW *lrw); +int lrw_done(symmetric_LRW *lrw); +int lrw_test(void); + +/* don't call */ +int lrw_process(const unsigned char *pt, unsigned char *ct, unsigned long len, int mode, symmetric_LRW *lrw); +#endif + +#ifdef LTC_F8_MODE +int f8_start( int cipher, const unsigned char *IV, + const unsigned char *key, int keylen, + const unsigned char *salt_key, int skeylen, + int num_rounds, symmetric_F8 *f8); +int f8_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_F8 *f8); +int f8_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_F8 *f8); +int f8_getiv(unsigned char *IV, unsigned long *len, const symmetric_F8 *f8); +int f8_setiv(const unsigned char *IV, unsigned long len, symmetric_F8 *f8); +int f8_done(symmetric_F8 *f8); +int f8_test_mode(void); +#endif + +#ifdef LTC_XTS_MODE +typedef struct { + symmetric_key key1, key2; + int cipher; +} symmetric_xts; + +int xts_start( int cipher, + const unsigned char *key1, + const unsigned char *key2, + unsigned long keylen, + int num_rounds, + symmetric_xts *xts); + +int xts_encrypt( + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tweak, + const symmetric_xts *xts); +int xts_decrypt( + const unsigned char *ct, unsigned long ptlen, + unsigned char *pt, + unsigned char *tweak, + const symmetric_xts *xts); + +void xts_done(symmetric_xts *xts); +int xts_test(void); +void xts_mult_x(unsigned char *I); +#endif + +int find_cipher(const char *name); +int find_cipher_any(const char *name, int blocklen, int keylen); +int find_cipher_id(unsigned char ID); +int register_cipher(const struct ltc_cipher_descriptor *cipher); +int unregister_cipher(const struct ltc_cipher_descriptor *cipher); +int register_all_ciphers(void); +int cipher_is_valid(int idx); + +LTC_MUTEX_PROTO(ltc_cipher_mutex) + +/* ---- stream ciphers ---- */ + +#ifdef LTC_CHACHA + +typedef struct { + ulong32 input[16]; + unsigned char kstream[64]; + unsigned long ksleft; + unsigned long ivlen; + int rounds; +} chacha_state; + +int chacha_setup(chacha_state *st, const unsigned char *key, unsigned long keylen, int rounds); +int chacha_ivctr32(chacha_state *st, const unsigned char *iv, unsigned long ivlen, ulong32 counter); +int chacha_ivctr64(chacha_state *st, const unsigned char *iv, unsigned long ivlen, ulong64 counter); +int chacha_crypt(chacha_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int chacha_keystream(chacha_state *st, unsigned char *out, unsigned long outlen); +int chacha_done(chacha_state *st); +int chacha_test(void); +int chacha_memory(const unsigned char *key, unsigned long keylen, unsigned long rounds, + const unsigned char *iv, unsigned long ivlen, ulong64 counter, + const unsigned char *datain, unsigned long datalen, unsigned char *dataout); + +#endif /* LTC_CHACHA */ + +#ifdef LTC_SALSA20 + +typedef struct { + ulong32 input[16]; + unsigned char kstream[64]; + unsigned long ksleft; + unsigned long ivlen; + int rounds; +} salsa20_state; + +int salsa20_setup(salsa20_state *st, const unsigned char *key, unsigned long keylen, int rounds); +int salsa20_ivctr64(salsa20_state *st, const unsigned char *iv, unsigned long ivlen, ulong64 counter); +int salsa20_crypt(salsa20_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int salsa20_keystream(salsa20_state *st, unsigned char *out, unsigned long outlen); +int salsa20_done(salsa20_state *st); +int salsa20_test(void); +int salsa20_memory(const unsigned char *key, unsigned long keylen, unsigned long rounds, + const unsigned char *iv, unsigned long ivlen, ulong64 counter, + const unsigned char *datain, unsigned long datalen, unsigned char *dataout); + +#endif /* LTC_SALSA20 */ + +#ifdef LTC_XSALSA20 + +int xsalsa20_setup(salsa20_state *st, const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + int rounds); +int xsalsa20_test(void); +int xsalsa20_memory(const unsigned char *key, unsigned long keylen, unsigned long rounds, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *datain, unsigned long datalen, unsigned char *dataout); + +#endif /* LTC_XSALSA20 */ + +#ifdef LTC_SOSEMANUK + +typedef struct { + ulong32 kc[100]; /* key_context */ + ulong32 s00, s01, s02, s03, s04, s05, s06, s07, s08, s09; + ulong32 r1, r2; + /* + * Buffering: the stream cipher produces output data by + * blocks of 640 bits. buf[] contains such a block, and + * "ptr" is the index of the next output byte. + */ + unsigned char buf[80]; + unsigned ptr; +} sosemanuk_state; + +int sosemanuk_setup(sosemanuk_state *st, const unsigned char *key, unsigned long keylen); +int sosemanuk_setiv(sosemanuk_state *st, const unsigned char *iv, unsigned long ivlen); +int sosemanuk_crypt(sosemanuk_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int sosemanuk_keystream(sosemanuk_state *st, unsigned char *out, unsigned long outlen); +int sosemanuk_done(sosemanuk_state *st); +int sosemanuk_test(void); +int sosemanuk_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *iv, unsigned long ivlen, + const unsigned char *datain, unsigned long datalen, + unsigned char *dataout); + +#endif /* LTC_SOSEMANUK */ + +#ifdef LTC_RABBIT + +typedef struct { + ulong32 x[8]; + ulong32 c[8]; + ulong32 carry; +} rabbit_ctx; + +typedef struct { + rabbit_ctx master_ctx; + rabbit_ctx work_ctx; + unsigned char block[16]; /* last keystream block containing unused bytes */ + ulong32 unused; /* count fm right */ +} rabbit_state; + +int rabbit_setup(rabbit_state* st, const unsigned char *key, unsigned long keylen); +int rabbit_setiv(rabbit_state* st, const unsigned char *iv, unsigned long ivlen); +int rabbit_crypt(rabbit_state* st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int rabbit_keystream(rabbit_state* st, unsigned char *out, unsigned long outlen); +int rabbit_done(rabbit_state *st); +int rabbit_test(void); +int rabbit_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *iv, unsigned long ivlen, + const unsigned char *datain, unsigned long datalen, + unsigned char *dataout); + +#endif /* LTC_RABBIT */ + +#ifdef LTC_RC4_STREAM + +typedef struct { + unsigned int x, y; + unsigned char buf[256]; +} rc4_state; + +int rc4_stream_setup(rc4_state *st, const unsigned char *key, unsigned long keylen); +int rc4_stream_crypt(rc4_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int rc4_stream_keystream(rc4_state *st, unsigned char *out, unsigned long outlen); +int rc4_stream_done(rc4_state *st); +int rc4_stream_test(void); +int rc4_stream_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *datain, unsigned long datalen, + unsigned char *dataout); + +#endif /* LTC_RC4_STREAM */ + +#ifdef LTC_SOBER128_STREAM + +typedef struct { + ulong32 R[17], /* Working storage for the shift register */ + initR[17], /* saved register contents */ + konst, /* key dependent constant */ + sbuf; /* partial word encryption buffer */ + int nbuf; /* number of part-word stream bits buffered */ +} sober128_state; + +int sober128_stream_setup(sober128_state *st, const unsigned char *key, unsigned long keylen); +int sober128_stream_setiv(sober128_state *st, const unsigned char *iv, unsigned long ivlen); +int sober128_stream_crypt(sober128_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int sober128_stream_keystream(sober128_state *st, unsigned char *out, unsigned long outlen); +int sober128_stream_done(sober128_state *st); +int sober128_stream_test(void); +int sober128_stream_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *iv, unsigned long ivlen, + const unsigned char *datain, unsigned long datalen, + unsigned char *dataout); + +#endif /* LTC_SOBER128_STREAM */ diff --git a/libtomcrypt/src/headers/tomcrypt_custom.h b/libtomcrypt/src/headers/tomcrypt_custom.h new file mode 100644 index 0000000..b13c2e0 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_custom.h @@ -0,0 +1,741 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#ifndef TOMCRYPT_CUSTOM_H_ +#define TOMCRYPT_CUSTOM_H_ + +/* macros for various libc functions you can change for embedded targets */ +#ifndef XMALLOC +#define XMALLOC malloc +#endif +#ifndef XREALLOC +#define XREALLOC realloc +#endif +#ifndef XCALLOC +#define XCALLOC calloc +#endif +#ifndef XFREE +#define XFREE free +#endif + +#ifndef XMEMSET +#define XMEMSET memset +#endif +#ifndef XMEMCPY +#define XMEMCPY memcpy +#endif +#ifndef XMEMMOVE +#define XMEMMOVE memmove +#endif +#ifndef XMEMCMP +#define XMEMCMP memcmp +#endif +/* A memory compare function that has to run in constant time, + * c.f. mem_neq() API summary. + */ +#ifndef XMEM_NEQ +#define XMEM_NEQ mem_neq +#endif +#ifndef XSTRCMP +#define XSTRCMP strcmp +#endif +#ifndef XSTRLEN +#define XSTRLEN strlen +#endif +#ifndef XSTRNCPY +#define XSTRNCPY strncpy +#endif + +#ifndef XCLOCK +#define XCLOCK clock +#endif + +#ifndef XQSORT +#define XQSORT qsort +#endif + +#if ( defined(malloc) || defined(realloc) || defined(calloc) || defined(free) || \ + defined(memset) || defined(memcpy) || defined(memcmp) || defined(strcmp) || \ + defined(strlen) || defined(strncpy) || defined(clock) || defined(qsort) ) \ + && !defined(LTC_NO_PROTOTYPES) +#define LTC_NO_PROTOTYPES +#endif + +/* shortcut to disable automatic inclusion */ +#if defined LTC_NOTHING && !defined LTC_EASY + #define LTC_NO_CIPHERS + #define LTC_NO_MODES + #define LTC_NO_HASHES + #define LTC_NO_MACS + #define LTC_NO_PRNGS + #define LTC_NO_PK + #define LTC_NO_PKCS + #define LTC_NO_MISC +#endif /* LTC_NOTHING */ + +/* Easy button? */ +#ifdef LTC_EASY + #define LTC_NO_CIPHERS + #define LTC_RIJNDAEL + #define LTC_BLOWFISH + #define LTC_DES + #define LTC_CAST5 + + #define LTC_NO_MODES + #define LTC_ECB_MODE + #define LTC_CBC_MODE + #define LTC_CTR_MODE + + #define LTC_NO_HASHES + #define LTC_SHA1 + #define LTC_SHA3 + #define LTC_SHA512 + #define LTC_SHA384 + #define LTC_SHA256 + #define LTC_SHA224 + #define LTC_HASH_HELPERS + + #define LTC_NO_MACS + #define LTC_HMAC + #define LTC_OMAC + #define LTC_CCM_MODE + + #define LTC_NO_PRNGS + #define LTC_SPRNG + #define LTC_YARROW + #define LTC_DEVRANDOM + #define LTC_TRY_URANDOM_FIRST + #define LTC_RNG_GET_BYTES + #define LTC_RNG_MAKE_PRNG + + #define LTC_NO_PK + #define LTC_MRSA + #define LTC_MECC + + #define LTC_NO_MISC + #define LTC_BASE64 +#endif + +/* The minimal set of functionality to run the tests */ +#ifdef LTC_MINIMAL + #define LTC_RIJNDAEL + #define LTC_SHA256 + #define LTC_YARROW + #define LTC_CTR_MODE + + #define LTC_RNG_MAKE_PRNG + #define LTC_RNG_GET_BYTES + #define LTC_DEVRANDOM + #define LTC_TRY_URANDOM_FIRST + + #undef LTC_NO_FILE +#endif + +/* Enable self-test test vector checking */ +#ifndef LTC_NO_TEST + #define LTC_TEST +#endif +/* Enable extended self-tests */ +/* #define LTC_TEST_EXT */ + +/* Use small code where possible */ +/* #define LTC_SMALL_CODE */ + +/* clean the stack of functions which put private information on stack */ +/* #define LTC_CLEAN_STACK */ + +/* disable all file related functions */ +/* #define LTC_NO_FILE */ + +/* disable all forms of ASM */ +/* #define LTC_NO_ASM */ + +/* disable FAST mode */ +/* #define LTC_NO_FAST */ + +/* disable BSWAP on x86 */ +/* #define LTC_NO_BSWAP */ + +/* ---> math provider? <--- */ +#ifndef LTC_NO_MATH + +/* LibTomMath */ +/* #define LTM_DESC */ + +/* TomsFastMath */ +/* #define TFM_DESC */ + +/* GNU Multiple Precision Arithmetic Library */ +/* #define GMP_DESC */ + +#endif /* LTC_NO_MATH */ + +/* ---> Symmetric Block Ciphers <--- */ +#ifndef LTC_NO_CIPHERS + +#define LTC_BLOWFISH +#define LTC_RC2 +#define LTC_RC5 +#define LTC_RC6 +#define LTC_SAFERP +#define LTC_RIJNDAEL +#define LTC_XTEA +/* _TABLES tells it to use tables during setup, _SMALL means to use the smaller scheduled key format + * (saves 4KB of ram), _ALL_TABLES enables all tables during setup */ +#define LTC_TWOFISH +#ifndef LTC_NO_TABLES + #define LTC_TWOFISH_TABLES + /* #define LTC_TWOFISH_ALL_TABLES */ +#else + #define LTC_TWOFISH_SMALL +#endif +/* #define LTC_TWOFISH_SMALL */ +/* LTC_DES includes EDE triple-DES */ +#define LTC_DES +#define LTC_CAST5 +#define LTC_NOEKEON +#define LTC_SKIPJACK +#define LTC_SAFER +#define LTC_KHAZAD +#define LTC_ANUBIS +#define LTC_ANUBIS_TWEAK +#define LTC_KSEED +#define LTC_KASUMI +#define LTC_MULTI2 +#define LTC_CAMELLIA +#define LTC_IDEA +#define LTC_SERPENT +#define LTC_TEA + +/* stream ciphers */ +#define LTC_CHACHA +#define LTC_SALSA20 +#define LTC_XSALSA20 +#define LTC_SOSEMANUK +#define LTC_RABBIT +#define LTC_RC4_STREAM +#define LTC_SOBER128_STREAM + +#endif /* LTC_NO_CIPHERS */ + + +/* ---> Block Cipher Modes of Operation <--- */ +#ifndef LTC_NO_MODES + +#define LTC_CFB_MODE +#define LTC_OFB_MODE +#define LTC_ECB_MODE +#define LTC_CBC_MODE +#define LTC_CTR_MODE + +/* F8 chaining mode */ +#define LTC_F8_MODE + +/* LRW mode */ +#define LTC_LRW_MODE +#ifndef LTC_NO_TABLES + /* like GCM mode this will enable 16 8x128 tables [64KB] that make + * seeking very fast. + */ + #define LTC_LRW_TABLES +#endif + +/* XTS mode */ +#define LTC_XTS_MODE + +#endif /* LTC_NO_MODES */ + +/* ---> One-Way Hash Functions <--- */ +#ifndef LTC_NO_HASHES + +#define LTC_CHC_HASH +#define LTC_WHIRLPOOL +#define LTC_SHA3 +#define LTC_KECCAK +#define LTC_SHA512 +#define LTC_SHA512_256 +#define LTC_SHA512_224 +#define LTC_SHA384 +#define LTC_SHA256 +#define LTC_SHA224 +#define LTC_TIGER +#define LTC_SHA1 +#define LTC_MD5 +#define LTC_MD4 +#define LTC_MD2 +#define LTC_RIPEMD128 +#define LTC_RIPEMD160 +#define LTC_RIPEMD256 +#define LTC_RIPEMD320 +#define LTC_BLAKE2S +#define LTC_BLAKE2B + +#define LTC_HASH_HELPERS + +#endif /* LTC_NO_HASHES */ + + +/* ---> MAC functions <--- */ +#ifndef LTC_NO_MACS + +#define LTC_HMAC +#define LTC_OMAC +#define LTC_PMAC +#define LTC_XCBC +#define LTC_F9_MODE +#define LTC_PELICAN +#define LTC_POLY1305 +#define LTC_BLAKE2SMAC +#define LTC_BLAKE2BMAC + +/* ---> Encrypt + Authenticate Modes <--- */ + +#define LTC_EAX_MODE + +#define LTC_OCB_MODE +#define LTC_OCB3_MODE +#define LTC_CCM_MODE +#define LTC_GCM_MODE +#define LTC_CHACHA20POLY1305_MODE + +/* Use 64KiB tables */ +#ifndef LTC_NO_TABLES + #define LTC_GCM_TABLES +#endif + +/* USE SSE2? requires GCC works on x86_32 and x86_64*/ +#ifdef LTC_GCM_TABLES +/* #define LTC_GCM_TABLES_SSE2 */ +#endif + +#endif /* LTC_NO_MACS */ + + +/* --> Pseudo Random Number Generators <--- */ +#ifndef LTC_NO_PRNGS + +/* Yarrow */ +#define LTC_YARROW + +/* a PRNG that simply reads from an available system source */ +#define LTC_SPRNG + +/* The RC4 stream cipher based PRNG */ +#define LTC_RC4 + +/* The ChaCha20 stream cipher based PRNG */ +#define LTC_CHACHA20_PRNG + +/* Fortuna PRNG */ +#define LTC_FORTUNA + +/* Greg's SOBER128 stream cipher based PRNG */ +#define LTC_SOBER128 + +/* the *nix style /dev/random device */ +#define LTC_DEVRANDOM +/* try /dev/urandom before trying /dev/random + * are you sure you want to disable this? http://www.2uo.de/myths-about-urandom/ */ +#define LTC_TRY_URANDOM_FIRST +/* rng_get_bytes() */ +#define LTC_RNG_GET_BYTES +/* rng_make_prng() */ +#define LTC_RNG_MAKE_PRNG + +/* enable the ltc_rng hook to integrate e.g. embedded hardware RNG's easily */ +/* #define LTC_PRNG_ENABLE_LTC_RNG */ + +#endif /* LTC_NO_PRNGS */ + +#ifdef LTC_YARROW + +/* which descriptor of AES to use? */ +/* 0 = rijndael_enc 1 = aes_enc, 2 = rijndael [full], 3 = aes [full] */ +#ifdef ENCRYPT_ONLY + #define LTC_YARROW_AES 0 +#else + #define LTC_YARROW_AES 2 +#endif + +#endif + +#ifdef LTC_FORTUNA + +#if !defined(LTC_FORTUNA_RESEED_RATELIMIT_STATIC) && \ + ((defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || defined(_WIN32)) + +/* time-based rate limit of the reseeding */ +#define LTC_FORTUNA_RESEED_RATELIMIT_TIMED + +/* with non-glibc or glibc 2.17+ prefer clock_gettime over gettimeofday */ +#if defined(__GLIBC__) && defined(__GLIBC_PREREQ) +#if __GLIBC_PREREQ(2, 17) + #define LTC_CLOCK_GETTIME +#endif +#elif defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L + #define LTC_CLOCK_GETTIME +#endif + +#else + +#ifndef LTC_FORTUNA_WD +/* reseed every N calls to the read function */ +#define LTC_FORTUNA_WD 10 +#endif + +#ifdef LTC_FORTUNA_RESEED_RATELIMIT_TIMED +/* make sure only one of + * LTC_FORTUNA_RESEED_RATELIMIT_STATIC + * and + * LTC_FORTUNA_RESEED_RATELIMIT_TIMED + * is defined. + */ +#undef LTC_FORTUNA_RESEED_RATELIMIT_TIMED +#warning "undef'ed LTC_FORTUNA_RESEED_RATELIMIT_TIMED, looks like your architecture doesn't support it" +#endif + +#endif + +#ifndef LTC_FORTUNA_POOLS +/* number of pools (4..32) can save a bit of ram by lowering the count */ +#define LTC_FORTUNA_POOLS 32 +#endif + +#endif /* LTC_FORTUNA */ + + +/* ---> Public Key Crypto <--- */ +#ifndef LTC_NO_PK + +/* Include RSA support */ +#define LTC_MRSA + +/* Include Diffie-Hellman support */ +/* is_prime fails for GMP */ +#define LTC_MDH +/* Supported Key Sizes */ +#define LTC_DH768 +#define LTC_DH1024 +#define LTC_DH1536 +#define LTC_DH2048 + +#if defined(LTM_DESC) || defined(GMP_DESC) +/* tfm has a problem in fp_isprime for larger key sizes */ +#define LTC_DH3072 +#define LTC_DH4096 +#define LTC_DH6144 +#define LTC_DH8192 +#endif + +/* Digital Signature Algorithm */ +#define LTC_MDSA + +/* Ed25519 & X25519 */ +#define LTC_CURVE25519 + +/* ECC */ +#define LTC_MECC + +/* use Shamir's trick for point mul (speeds up signature verification) */ +#define LTC_ECC_SHAMIR + +#if defined(TFM_DESC) && defined(LTC_MECC) + #define LTC_MECC_ACCEL +#endif + +/* do we want fixed point ECC */ +/* #define LTC_MECC_FP */ + +#endif /* LTC_NO_PK */ + +#if defined(LTC_MRSA) && !defined(LTC_NO_RSA_BLINDING) +/* Enable RSA blinding when doing private key operations by default */ +#define LTC_RSA_BLINDING +#endif /* LTC_NO_RSA_BLINDING */ + +#if defined(LTC_MRSA) && !defined(LTC_NO_RSA_CRT_HARDENING) +/* Enable RSA CRT hardening when doing private key operations by default */ +#define LTC_RSA_CRT_HARDENING +#endif /* LTC_NO_RSA_CRT_HARDENING */ + +#if defined(LTC_MECC) && !defined(LTC_NO_ECC_TIMING_RESISTANT) +/* Enable ECC timing resistant version by default */ +#define LTC_ECC_TIMING_RESISTANT +#endif + +/* PKCS #1 (RSA) and #5 (Password Handling) stuff */ +#ifndef LTC_NO_PKCS + +#define LTC_PKCS_1 +#define LTC_PKCS_5 +#define LTC_PKCS_8 +#define LTC_PKCS_12 + +/* Include ASN.1 DER (required by DSA/RSA) */ +#define LTC_DER + +#endif /* LTC_NO_PKCS */ + +/* misc stuff */ +#ifndef LTC_NO_MISC + +/* Various tidbits of modern neatoness */ +#define LTC_BASE64 +/* ... and it's URL safe version */ +#define LTC_BASE64_URL +/* Base32 encoding/decoding */ +#define LTC_BASE32 +/* Base16/hex encoding/decoding */ +#define LTC_BASE16 + +#define LTC_BCRYPT + +#ifndef LTC_BCRYPT_DEFAULT_ROUNDS +#define LTC_BCRYPT_DEFAULT_ROUNDS 10 +#endif + +/* Keep LTC_NO_HKDF for compatibility reasons + * superseeded by LTC_NO_MISC*/ +#ifndef LTC_NO_HKDF +/* HKDF Key Derivation/Expansion stuff */ +#define LTC_HKDF +#endif /* LTC_NO_HKDF */ + +#define LTC_ADLER32 + +#define LTC_CRC32 + +#define LTC_SSH + +#define LTC_PADDING + +#define LTC_PBES + +#endif /* LTC_NO_MISC */ + +/* cleanup */ + +#ifdef LTC_MECC +/* Supported ECC Key Sizes */ +#ifndef LTC_NO_CURVES + #define LTC_ECC_BRAINPOOLP160R1 + #define LTC_ECC_BRAINPOOLP160T1 + #define LTC_ECC_BRAINPOOLP192R1 + #define LTC_ECC_BRAINPOOLP192T1 + #define LTC_ECC_BRAINPOOLP224R1 + #define LTC_ECC_BRAINPOOLP224T1 + #define LTC_ECC_BRAINPOOLP256R1 + #define LTC_ECC_BRAINPOOLP256T1 + #define LTC_ECC_BRAINPOOLP320R1 + #define LTC_ECC_BRAINPOOLP320T1 + #define LTC_ECC_BRAINPOOLP384R1 + #define LTC_ECC_BRAINPOOLP384T1 + #define LTC_ECC_BRAINPOOLP512R1 + #define LTC_ECC_BRAINPOOLP512T1 + #define LTC_ECC_PRIME192V2 + #define LTC_ECC_PRIME192V3 + #define LTC_ECC_PRIME239V1 + #define LTC_ECC_PRIME239V2 + #define LTC_ECC_PRIME239V3 + #define LTC_ECC_SECP112R1 + #define LTC_ECC_SECP112R2 + #define LTC_ECC_SECP128R1 + #define LTC_ECC_SECP128R2 + #define LTC_ECC_SECP160K1 + #define LTC_ECC_SECP160R1 + #define LTC_ECC_SECP160R2 + #define LTC_ECC_SECP192K1 + #define LTC_ECC_SECP192R1 + #define LTC_ECC_SECP224K1 + #define LTC_ECC_SECP224R1 + #define LTC_ECC_SECP256K1 + #define LTC_ECC_SECP256R1 + #define LTC_ECC_SECP384R1 + #define LTC_ECC_SECP521R1 +#endif +#endif + +#if defined(LTC_DER) + #ifndef LTC_DER_MAX_RECURSION + /* Maximum recursion limit when processing nested ASN.1 types. */ + #define LTC_DER_MAX_RECURSION 30 + #endif +#endif + +#if defined(LTC_MECC) || defined(LTC_MRSA) || defined(LTC_MDSA) || defined(LTC_SSH) + /* Include the MPI functionality? (required by the PK algorithms) */ + #define LTC_MPI + + #ifndef LTC_PK_MAX_RETRIES + /* iterations limit for retry-loops */ + #define LTC_PK_MAX_RETRIES 20 + #endif +#endif + +#ifdef LTC_MRSA + #define LTC_PKCS_1 +#endif + +#if defined(LTC_MRSA) || defined(LTC_MECC) + #define LTC_PKCS_8 +#endif + +#ifdef LTC_PKCS_8 + #define LTC_PADDING + #define LTC_PBES +#endif + +#if defined(LTC_CLEAN_STACK) +/* if you're sure that you want to use it, remove the line below */ + #error LTC_CLEAN_STACK is considered as broken +#endif + +#if defined(LTC_PBES) && !defined(LTC_PKCS_5) + #error LTC_PBES requires LTC_PKCS_5 +#endif + +#if defined(LTC_PBES) && !defined(LTC_PKCS_12) + #error LTC_PBES requires LTC_PKCS_12 +#endif + +#if defined(LTC_PKCS_5) && !defined(LTC_HMAC) + #error LTC_PKCS_5 requires LTC_HMAC +#endif + +#if defined(LTC_PKCS_5) && !defined(LTC_HASH_HELPERS) + #error LTC_PKCS_5 requires LTC_HASH_HELPERS +#endif + +#if defined(LTC_PELICAN) && !defined(LTC_RIJNDAEL) + #error Pelican-MAC requires LTC_RIJNDAEL +#endif + +#if defined(LTC_EAX_MODE) && !(defined(LTC_CTR_MODE) && defined(LTC_OMAC)) + #error LTC_EAX_MODE requires CTR and LTC_OMAC mode +#endif + +#if defined(LTC_YARROW) && !defined(LTC_CTR_MODE) + #error LTC_YARROW requires LTC_CTR_MODE chaining mode to be defined! +#endif + +#if defined(LTC_DER) && !defined(LTC_MPI) + #error ASN.1 DER requires MPI functionality +#endif + +#if (defined(LTC_MDSA) || defined(LTC_MRSA) || defined(LTC_MECC)) && !defined(LTC_DER) + #error PK requires ASN.1 DER functionality, make sure LTC_DER is enabled +#endif + +#if defined(LTC_BCRYPT) && !defined(LTC_BLOWFISH) + #error LTC_BCRYPT requires LTC_BLOWFISH +#endif + +#if defined(LTC_CHACHA20POLY1305_MODE) && (!defined(LTC_CHACHA) || !defined(LTC_POLY1305)) + #error LTC_CHACHA20POLY1305_MODE requires LTC_CHACHA + LTC_POLY1305 +#endif + +#if defined(LTC_CHACHA20_PRNG) && !defined(LTC_CHACHA) + #error LTC_CHACHA20_PRNG requires LTC_CHACHA +#endif + +#if defined(LTC_XSALSA20) && !defined(LTC_SALSA20) + #error LTC_XSALSA20 requires LTC_SALSA20 +#endif + +#if defined(LTC_RC4) && !defined(LTC_RC4_STREAM) + #error LTC_RC4 requires LTC_RC4_STREAM +#endif + +#if defined(LTC_SOBER128) && !defined(LTC_SOBER128_STREAM) + #error LTC_SOBER128 requires LTC_SOBER128_STREAM +#endif + +#if defined(LTC_BLAKE2SMAC) && !defined(LTC_BLAKE2S) + #error LTC_BLAKE2SMAC requires LTC_BLAKE2S +#endif + +#if defined(LTC_BLAKE2BMAC) && !defined(LTC_BLAKE2B) + #error LTC_BLAKE2BMAC requires LTC_BLAKE2B +#endif + +#if defined(LTC_SPRNG) && !defined(LTC_RNG_GET_BYTES) + #error LTC_SPRNG requires LTC_RNG_GET_BYTES +#endif + +#if defined(LTC_NO_MATH) && (defined(LTM_DESC) || defined(TFM_DESC) || defined(GMP_DESC)) + #error LTC_NO_MATH defined, but also a math descriptor +#endif + +/* THREAD management */ +#ifdef LTC_PTHREAD + +#include + +#define LTC_MUTEX_GLOBAL(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER; +#define LTC_MUTEX_PROTO(x) extern pthread_mutex_t x; +#define LTC_MUTEX_TYPE(x) pthread_mutex_t x; +#define LTC_MUTEX_INIT(x) LTC_ARGCHK(pthread_mutex_init(x, NULL) == 0); +#define LTC_MUTEX_LOCK(x) LTC_ARGCHK(pthread_mutex_lock(x) == 0); +#define LTC_MUTEX_UNLOCK(x) LTC_ARGCHK(pthread_mutex_unlock(x) == 0); +#define LTC_MUTEX_DESTROY(x) LTC_ARGCHK(pthread_mutex_destroy(x) == 0); + +#else + +/* default no functions */ +#define LTC_MUTEX_GLOBAL(x) +#define LTC_MUTEX_PROTO(x) +#define LTC_MUTEX_TYPE(x) +#define LTC_MUTEX_INIT(x) +#define LTC_MUTEX_LOCK(x) +#define LTC_MUTEX_UNLOCK(x) +#define LTC_MUTEX_DESTROY(x) + +#endif + +/* Debuggers */ + +/* define this if you use Valgrind, note: it CHANGES the way SOBER-128 and RC4 work (see the code) */ +/* #define LTC_VALGRIND */ + +#endif + +#ifndef LTC_NO_FILE + /* buffer size for reading from a file via fread(..) */ + #ifndef LTC_FILE_READ_BUFSIZE + #define LTC_FILE_READ_BUFSIZE 8192 + #endif +#endif + +/* ECC backwards compatibility */ +#if !defined(LTC_ECC_SECP112R1) && defined(LTC_ECC112) +#define LTC_ECC_SECP112R1 +#undef LTC_ECC112 +#endif +#if !defined(LTC_ECC_SECP128R1) && defined(LTC_ECC128) +#define LTC_ECC_SECP128R1 +#undef LTC_ECC128 +#endif +#if !defined(LTC_ECC_SECP160R1) && defined(LTC_ECC160) +#define LTC_ECC_SECP160R1 +#undef LTC_ECC160 +#endif +#if !defined(LTC_ECC_SECP192R1) && defined(LTC_ECC192) +#define LTC_ECC_SECP192R1 +#undef LTC_ECC192 +#endif +#if !defined(LTC_ECC_SECP224R1) && defined(LTC_ECC224) +#define LTC_ECC_SECP224R1 +#undef LTC_ECC224 +#endif +#if !defined(LTC_ECC_SECP256R1) && defined(LTC_ECC256) +#define LTC_ECC_SECP256R1 +#undef LTC_ECC256 +#endif +#if !defined(LTC_ECC_SECP384R1) && defined(LTC_ECC384) +#define LTC_ECC_SECP384R1 +#undef LTC_ECC384 +#endif +#if !defined(LTC_ECC_SECP512R1) && defined(LTC_ECC521) +#define LTC_ECC_SECP521R1 +#undef LTC_ECC521 +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_hash.h b/libtomcrypt/src/headers/tomcrypt_hash.h new file mode 100644 index 0000000..4eb0712 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_hash.h @@ -0,0 +1,502 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- HASH FUNCTIONS ---- */ +#if defined(LTC_SHA3) || defined(LTC_KECCAK) +struct sha3_state { + ulong64 saved; /* the portion of the input message that we didn't consume yet */ + ulong64 s[25]; + unsigned char sb[25 * 8]; /* used for storing `ulong64 s[25]` as little-endian bytes */ + unsigned short byte_index; /* 0..7--the next byte after the set one (starts from 0; 0--none are buffered) */ + unsigned short word_index; /* 0..24--the next word to integrate input (starts from 0) */ + unsigned short capacity_words; /* the double size of the hash output in words (e.g. 16 for Keccak 512) */ + unsigned short xof_flag; +}; +#endif + +#ifdef LTC_SHA512 +struct sha512_state { + ulong64 length, state[8]; + unsigned long curlen; + unsigned char buf[128]; +}; +#endif + +#ifdef LTC_SHA256 +struct sha256_state { + ulong64 length; + ulong32 state[8], curlen; + unsigned char buf[64]; +}; +#endif + +#ifdef LTC_SHA1 +struct sha1_state { + ulong64 length; + ulong32 state[5], curlen; + unsigned char buf[64]; +}; +#endif + +#ifdef LTC_MD5 +struct md5_state { + ulong64 length; + ulong32 state[4], curlen; + unsigned char buf[64]; +}; +#endif + +#ifdef LTC_MD4 +struct md4_state { + ulong64 length; + ulong32 state[4], curlen; + unsigned char buf[64]; +}; +#endif + +#ifdef LTC_TIGER +struct tiger_state { + ulong64 state[3], length; + unsigned long curlen; + unsigned char buf[64]; +}; +#endif + +#ifdef LTC_MD2 +struct md2_state { + unsigned char chksum[16], X[48], buf[16]; + unsigned long curlen; +}; +#endif + +#ifdef LTC_RIPEMD128 +struct rmd128_state { + ulong64 length; + unsigned char buf[64]; + ulong32 curlen, state[4]; +}; +#endif + +#ifdef LTC_RIPEMD160 +struct rmd160_state { + ulong64 length; + unsigned char buf[64]; + ulong32 curlen, state[5]; +}; +#endif + +#ifdef LTC_RIPEMD256 +struct rmd256_state { + ulong64 length; + unsigned char buf[64]; + ulong32 curlen, state[8]; +}; +#endif + +#ifdef LTC_RIPEMD320 +struct rmd320_state { + ulong64 length; + unsigned char buf[64]; + ulong32 curlen, state[10]; +}; +#endif + +#ifdef LTC_WHIRLPOOL +struct whirlpool_state { + ulong64 length, state[8]; + unsigned char buf[64]; + ulong32 curlen; +}; +#endif + +#ifdef LTC_CHC_HASH +struct chc_state { + ulong64 length; + unsigned char state[MAXBLOCKSIZE], buf[MAXBLOCKSIZE]; + ulong32 curlen; +}; +#endif + +#ifdef LTC_BLAKE2S +struct blake2s_state { + ulong32 h[8]; + ulong32 t[2]; + ulong32 f[2]; + unsigned char buf[64]; + unsigned long curlen; + unsigned long outlen; + unsigned char last_node; +}; +#endif + +#ifdef LTC_BLAKE2B +struct blake2b_state { + ulong64 h[8]; + ulong64 t[2]; + ulong64 f[2]; + unsigned char buf[128]; + unsigned long curlen; + unsigned long outlen; + unsigned char last_node; +}; +#endif + +typedef union Hash_state { + char dummy[1]; +#ifdef LTC_CHC_HASH + struct chc_state chc; +#endif +#ifdef LTC_WHIRLPOOL + struct whirlpool_state whirlpool; +#endif +#if defined(LTC_SHA3) || defined(LTC_KECCAK) + struct sha3_state sha3; +#endif +#ifdef LTC_SHA512 + struct sha512_state sha512; +#endif +#ifdef LTC_SHA256 + struct sha256_state sha256; +#endif +#ifdef LTC_SHA1 + struct sha1_state sha1; +#endif +#ifdef LTC_MD5 + struct md5_state md5; +#endif +#ifdef LTC_MD4 + struct md4_state md4; +#endif +#ifdef LTC_MD2 + struct md2_state md2; +#endif +#ifdef LTC_TIGER + struct tiger_state tiger; +#endif +#ifdef LTC_RIPEMD128 + struct rmd128_state rmd128; +#endif +#ifdef LTC_RIPEMD160 + struct rmd160_state rmd160; +#endif +#ifdef LTC_RIPEMD256 + struct rmd256_state rmd256; +#endif +#ifdef LTC_RIPEMD320 + struct rmd320_state rmd320; +#endif +#ifdef LTC_BLAKE2S + struct blake2s_state blake2s; +#endif +#ifdef LTC_BLAKE2B + struct blake2b_state blake2b; +#endif + + void *data; +} hash_state; + +/** hash descriptor */ +extern struct ltc_hash_descriptor { + /** name of hash */ + const char *name; + /** internal ID */ + unsigned char ID; + /** Size of digest in octets */ + unsigned long hashsize; + /** Input block size in octets */ + unsigned long blocksize; + /** ASN.1 OID */ + unsigned long OID[16]; + /** Length of DER encoding */ + unsigned long OIDlen; + + /** Init a hash state + @param hash The hash to initialize + @return CRYPT_OK if successful + */ + int (*init)(hash_state *hash); + /** Process a block of data + @param hash The hash state + @param in The data to hash + @param inlen The length of the data (octets) + @return CRYPT_OK if successful + */ + int (*process)(hash_state *hash, const unsigned char *in, unsigned long inlen); + /** Produce the digest and store it + @param hash The hash state + @param out [out] The destination of the digest + @return CRYPT_OK if successful + */ + int (*done)(hash_state *hash, unsigned char *out); + /** Self-test + @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled + */ + int (*test)(void); + + /* accelerated hmac callback: if you need to-do multiple packets just use the generic hmac_memory and provide a hash callback */ + int (*hmac_block)(const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +} hash_descriptor[]; + +#ifdef LTC_CHC_HASH +int chc_register(int cipher); +int chc_init(hash_state * md); +int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int chc_done(hash_state * md, unsigned char *out); +int chc_test(void); +extern const struct ltc_hash_descriptor chc_desc; +#endif + +#ifdef LTC_WHIRLPOOL +int whirlpool_init(hash_state * md); +int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int whirlpool_done(hash_state * md, unsigned char *out); +int whirlpool_test(void); +extern const struct ltc_hash_descriptor whirlpool_desc; +#endif + +#if defined(LTC_SHA3) || defined(LTC_KECCAK) +/* sha3_NNN_init are shared by SHA3 and KECCAK */ +int sha3_512_init(hash_state * md); +int sha3_384_init(hash_state * md); +int sha3_256_init(hash_state * md); +int sha3_224_init(hash_state * md); +/* sha3_process is the same for all variants of SHA3 + KECCAK */ +int sha3_process(hash_state * md, const unsigned char *in, unsigned long inlen); +#endif + +#ifdef LTC_SHA3 +int sha3_512_test(void); +extern const struct ltc_hash_descriptor sha3_512_desc; +int sha3_384_test(void); +extern const struct ltc_hash_descriptor sha3_384_desc; +int sha3_256_test(void); +extern const struct ltc_hash_descriptor sha3_256_desc; +int sha3_224_test(void); +extern const struct ltc_hash_descriptor sha3_224_desc; +int sha3_done(hash_state *md, unsigned char *out); +/* SHAKE128 + SHAKE256 */ +int sha3_shake_init(hash_state *md, int num); +#define sha3_shake_process(a,b,c) sha3_process(a,b,c) +int sha3_shake_done(hash_state *md, unsigned char *out, unsigned long outlen); +int sha3_shake_test(void); +int sha3_shake_memory(int num, const unsigned char *in, unsigned long inlen, unsigned char *out, const unsigned long *outlen); +#endif + +#ifdef LTC_KECCAK +#define keccak_512_init(a) sha3_512_init(a) +#define keccak_384_init(a) sha3_384_init(a) +#define keccak_256_init(a) sha3_256_init(a) +#define keccak_224_init(a) sha3_224_init(a) +#define keccak_process(a,b,c) sha3_process(a,b,c) +extern const struct ltc_hash_descriptor keccak_512_desc; +int keccak_512_test(void); +extern const struct ltc_hash_descriptor keccak_384_desc; +int keccak_384_test(void); +extern const struct ltc_hash_descriptor keccak_256_desc; +int keccak_256_test(void); +extern const struct ltc_hash_descriptor keccak_224_desc; +int keccak_224_test(void); +int keccak_done(hash_state *md, unsigned char *out); +#endif + +#ifdef LTC_SHA512 +int sha512_init(hash_state * md); +int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int sha512_done(hash_state * md, unsigned char *out); +int sha512_test(void); +extern const struct ltc_hash_descriptor sha512_desc; +#endif + +#ifdef LTC_SHA384 +#ifndef LTC_SHA512 + #error LTC_SHA512 is required for LTC_SHA384 +#endif +int sha384_init(hash_state * md); +#define sha384_process sha512_process +int sha384_done(hash_state * md, unsigned char *out); +int sha384_test(void); +extern const struct ltc_hash_descriptor sha384_desc; +#endif + +#ifdef LTC_SHA512_256 +#ifndef LTC_SHA512 + #error LTC_SHA512 is required for LTC_SHA512_256 +#endif +int sha512_256_init(hash_state * md); +#define sha512_256_process sha512_process +int sha512_256_done(hash_state * md, unsigned char *out); +int sha512_256_test(void); +extern const struct ltc_hash_descriptor sha512_256_desc; +#endif + +#ifdef LTC_SHA512_224 +#ifndef LTC_SHA512 + #error LTC_SHA512 is required for LTC_SHA512_224 +#endif +int sha512_224_init(hash_state * md); +#define sha512_224_process sha512_process +int sha512_224_done(hash_state * md, unsigned char *out); +int sha512_224_test(void); +extern const struct ltc_hash_descriptor sha512_224_desc; +#endif + +#ifdef LTC_SHA256 +int sha256_init(hash_state * md); +int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int sha256_done(hash_state * md, unsigned char *out); +int sha256_test(void); +extern const struct ltc_hash_descriptor sha256_desc; + +#ifdef LTC_SHA224 +#ifndef LTC_SHA256 + #error LTC_SHA256 is required for LTC_SHA224 +#endif +int sha224_init(hash_state * md); +#define sha224_process sha256_process +int sha224_done(hash_state * md, unsigned char *out); +int sha224_test(void); +extern const struct ltc_hash_descriptor sha224_desc; +#endif +#endif + +#ifdef LTC_SHA1 +int sha1_init(hash_state * md); +int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int sha1_done(hash_state * md, unsigned char *out); +int sha1_test(void); +extern const struct ltc_hash_descriptor sha1_desc; +#endif + +#ifdef LTC_BLAKE2S +extern const struct ltc_hash_descriptor blake2s_256_desc; +int blake2s_256_init(hash_state * md); +int blake2s_256_test(void); + +extern const struct ltc_hash_descriptor blake2s_224_desc; +int blake2s_224_init(hash_state * md); +int blake2s_224_test(void); + +extern const struct ltc_hash_descriptor blake2s_160_desc; +int blake2s_160_init(hash_state * md); +int blake2s_160_test(void); + +extern const struct ltc_hash_descriptor blake2s_128_desc; +int blake2s_128_init(hash_state * md); +int blake2s_128_test(void); + +int blake2s_init(hash_state * md, unsigned long outlen, const unsigned char *key, unsigned long keylen); +int blake2s_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int blake2s_done(hash_state * md, unsigned char *out); +#endif + +#ifdef LTC_BLAKE2B +extern const struct ltc_hash_descriptor blake2b_512_desc; +int blake2b_512_init(hash_state * md); +int blake2b_512_test(void); + +extern const struct ltc_hash_descriptor blake2b_384_desc; +int blake2b_384_init(hash_state * md); +int blake2b_384_test(void); + +extern const struct ltc_hash_descriptor blake2b_256_desc; +int blake2b_256_init(hash_state * md); +int blake2b_256_test(void); + +extern const struct ltc_hash_descriptor blake2b_160_desc; +int blake2b_160_init(hash_state * md); +int blake2b_160_test(void); + +int blake2b_init(hash_state * md, unsigned long outlen, const unsigned char *key, unsigned long keylen); +int blake2b_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int blake2b_done(hash_state * md, unsigned char *out); +#endif + +#ifdef LTC_MD5 +int md5_init(hash_state * md); +int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int md5_done(hash_state * md, unsigned char *out); +int md5_test(void); +extern const struct ltc_hash_descriptor md5_desc; +#endif + +#ifdef LTC_MD4 +int md4_init(hash_state * md); +int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int md4_done(hash_state * md, unsigned char *out); +int md4_test(void); +extern const struct ltc_hash_descriptor md4_desc; +#endif + +#ifdef LTC_MD2 +int md2_init(hash_state * md); +int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int md2_done(hash_state * md, unsigned char *out); +int md2_test(void); +extern const struct ltc_hash_descriptor md2_desc; +#endif + +#ifdef LTC_TIGER +int tiger_init(hash_state * md); +int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int tiger_done(hash_state * md, unsigned char *out); +int tiger_test(void); +extern const struct ltc_hash_descriptor tiger_desc; +#endif + +#ifdef LTC_RIPEMD128 +int rmd128_init(hash_state * md); +int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int rmd128_done(hash_state * md, unsigned char *out); +int rmd128_test(void); +extern const struct ltc_hash_descriptor rmd128_desc; +#endif + +#ifdef LTC_RIPEMD160 +int rmd160_init(hash_state * md); +int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int rmd160_done(hash_state * md, unsigned char *out); +int rmd160_test(void); +extern const struct ltc_hash_descriptor rmd160_desc; +#endif + +#ifdef LTC_RIPEMD256 +int rmd256_init(hash_state * md); +int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int rmd256_done(hash_state * md, unsigned char *out); +int rmd256_test(void); +extern const struct ltc_hash_descriptor rmd256_desc; +#endif + +#ifdef LTC_RIPEMD320 +int rmd320_init(hash_state * md); +int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen); +int rmd320_done(hash_state * md, unsigned char *out); +int rmd320_test(void); +extern const struct ltc_hash_descriptor rmd320_desc; +#endif + + +int find_hash(const char *name); +int find_hash_id(unsigned char ID); +int find_hash_oid(const unsigned long *ID, unsigned long IDlen); +int find_hash_any(const char *name, int digestlen); +int register_hash(const struct ltc_hash_descriptor *hash); +int unregister_hash(const struct ltc_hash_descriptor *hash); +int register_all_hashes(void); +int hash_is_valid(int idx); + +LTC_MUTEX_PROTO(ltc_hash_mutex) + +int hash_memory(int hash, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); + +#ifndef LTC_NO_FILE +int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen); +int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *outlen); +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_mac.h b/libtomcrypt/src/headers/tomcrypt_mac.h new file mode 100644 index 0000000..549903c --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_mac.h @@ -0,0 +1,553 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#ifdef LTC_HMAC +typedef struct Hmac_state { + hash_state md; + int hash; + unsigned char key[MAXBLOCKSIZE]; +} hmac_state; + +int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen); +int hmac_process(hmac_state *hmac, const unsigned char *in, unsigned long inlen); +int hmac_done(hmac_state *hmac, unsigned char *out, unsigned long *outlen); +int hmac_test(void); +int hmac_memory(int hash, + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int hmac_memory_multi(int hash, + const unsigned char *key, unsigned long keylen, + unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); +int hmac_file(int hash, const char *fname, const unsigned char *key, + unsigned long keylen, + unsigned char *out, unsigned long *outlen); +#endif + +#ifdef LTC_OMAC + +typedef struct { + int cipher_idx, + buflen, + blklen; + unsigned char block[MAXBLOCKSIZE], + prev[MAXBLOCKSIZE], + Lu[2][MAXBLOCKSIZE]; + symmetric_key key; +} omac_state; + +int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen); +int omac_process(omac_state *omac, const unsigned char *in, unsigned long inlen); +int omac_done(omac_state *omac, unsigned char *out, unsigned long *outlen); +int omac_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int omac_memory_multi(int cipher, + const unsigned char *key, unsigned long keylen, + unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); +int omac_file(int cipher, + const unsigned char *key, unsigned long keylen, + const char *filename, + unsigned char *out, unsigned long *outlen); +int omac_test(void); +#endif /* LTC_OMAC */ + +#ifdef LTC_PMAC + +typedef struct { + unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ + Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ + Lr[MAXBLOCKSIZE], /* L * x^-1 */ + block[MAXBLOCKSIZE], /* currently accumulated block */ + checksum[MAXBLOCKSIZE]; /* current checksum */ + + symmetric_key key; /* scheduled key for cipher */ + unsigned long block_index; /* index # for current block */ + int cipher_idx, /* cipher idx */ + block_len, /* length of block */ + buflen; /* number of bytes in the buffer */ +} pmac_state; + +int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen); +int pmac_process(pmac_state *pmac, const unsigned char *in, unsigned long inlen); +int pmac_done(pmac_state *pmac, unsigned char *out, unsigned long *outlen); + +int pmac_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +int pmac_memory_multi(int cipher, + const unsigned char *key, unsigned long keylen, + unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); + +int pmac_file(int cipher, + const unsigned char *key, unsigned long keylen, + const char *filename, + unsigned char *out, unsigned long *outlen); + +int pmac_test(void); + +/* internal functions */ +int pmac_ntz(unsigned long x); +void pmac_shift_xor(pmac_state *pmac); + +#endif /* PMAC */ + +#ifdef LTC_POLY1305 +typedef struct { + ulong32 r[5]; + ulong32 h[5]; + ulong32 pad[4]; + unsigned long leftover; + unsigned char buffer[16]; + int final; +} poly1305_state; + +int poly1305_init(poly1305_state *st, const unsigned char *key, unsigned long keylen); +int poly1305_process(poly1305_state *st, const unsigned char *in, unsigned long inlen); +int poly1305_done(poly1305_state *st, unsigned char *mac, unsigned long *maclen); +int poly1305_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen); +int poly1305_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...); +int poly1305_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen); +int poly1305_test(void); +#endif /* LTC_POLY1305 */ + +#ifdef LTC_BLAKE2SMAC +typedef hash_state blake2smac_state; +int blake2smac_init(blake2smac_state *st, unsigned long outlen, const unsigned char *key, unsigned long keylen); +int blake2smac_process(blake2smac_state *st, const unsigned char *in, unsigned long inlen); +int blake2smac_done(blake2smac_state *st, unsigned char *mac, unsigned long *maclen); +int blake2smac_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen); +int blake2smac_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...); +int blake2smac_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen); +int blake2smac_test(void); +#endif /* LTC_BLAKE2SMAC */ + +#ifdef LTC_BLAKE2BMAC +typedef hash_state blake2bmac_state; +int blake2bmac_init(blake2bmac_state *st, unsigned long outlen, const unsigned char *key, unsigned long keylen); +int blake2bmac_process(blake2bmac_state *st, const unsigned char *in, unsigned long inlen); +int blake2bmac_done(blake2bmac_state *st, unsigned char *mac, unsigned long *maclen); +int blake2bmac_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen); +int blake2bmac_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...); +int blake2bmac_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen); +int blake2bmac_test(void); +#endif /* LTC_BLAKE2BMAC */ + + +#ifdef LTC_PELICAN + +typedef struct pelican_state +{ + symmetric_key K; + unsigned char state[16]; + int buflen; +} pelican_state; + +int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long keylen); +int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned long inlen); +int pelican_done(pelican_state *pelmac, unsigned char *out); +int pelican_test(void); + +int pelican_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out); + +#endif + +#ifdef LTC_XCBC + +/* add this to "keylen" to xcbc_init to use a pure three-key XCBC MAC */ +#define LTC_XCBC_PURE 0x8000UL + +typedef struct { + unsigned char K[3][MAXBLOCKSIZE], + IV[MAXBLOCKSIZE]; + + symmetric_key key; + + int cipher, + buflen, + blocksize; +} xcbc_state; + +int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned long keylen); +int xcbc_process(xcbc_state *xcbc, const unsigned char *in, unsigned long inlen); +int xcbc_done(xcbc_state *xcbc, unsigned char *out, unsigned long *outlen); +int xcbc_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int xcbc_memory_multi(int cipher, + const unsigned char *key, unsigned long keylen, + unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); +int xcbc_file(int cipher, + const unsigned char *key, unsigned long keylen, + const char *filename, + unsigned char *out, unsigned long *outlen); +int xcbc_test(void); + +#endif + +#ifdef LTC_F9_MODE + +typedef struct { + unsigned char akey[MAXBLOCKSIZE], + ACC[MAXBLOCKSIZE], + IV[MAXBLOCKSIZE]; + + symmetric_key key; + + int cipher, + buflen, + keylen, + blocksize; +} f9_state; + +int f9_init(f9_state *f9, int cipher, const unsigned char *key, unsigned long keylen); +int f9_process(f9_state *f9, const unsigned char *in, unsigned long inlen); +int f9_done(f9_state *f9, unsigned char *out, unsigned long *outlen); +int f9_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int f9_memory_multi(int cipher, + const unsigned char *key, unsigned long keylen, + unsigned char *out, unsigned long *outlen, + const unsigned char *in, unsigned long inlen, ...); +int f9_file(int cipher, + const unsigned char *key, unsigned long keylen, + const char *fname, + unsigned char *out, unsigned long *outlen); +int f9_test(void); + +#endif + +/* + * ENC+AUTH modes + */ + +#ifdef LTC_EAX_MODE + +#if !(defined(LTC_OMAC) && defined(LTC_CTR_MODE)) + #error LTC_EAX_MODE requires LTC_OMAC and CTR +#endif + +typedef struct { + unsigned char N[MAXBLOCKSIZE]; + symmetric_CTR ctr; + omac_state headeromac, ctomac; +} eax_state; + +int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *header, unsigned long headerlen); + +int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length); +int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length); +int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length); +int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen); + +int eax_encrypt_authenticate_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *header, unsigned long headerlen, + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen); + +int eax_decrypt_verify_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *header, unsigned long headerlen, + const unsigned char *ct, unsigned long ctlen, + unsigned char *pt, + const unsigned char *tag, unsigned long taglen, + int *stat); + + int eax_test(void); +#endif /* EAX MODE */ + +#ifdef LTC_OCB_MODE +typedef struct { + unsigned char L[MAXBLOCKSIZE], /* L value */ + Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ + Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ + Lr[MAXBLOCKSIZE], /* L * x^-1 */ + R[MAXBLOCKSIZE], /* R value */ + checksum[MAXBLOCKSIZE]; /* current checksum */ + + symmetric_key key; /* scheduled key for cipher */ + unsigned long block_index; /* index # for current block */ + int cipher, /* cipher idx */ + block_len; /* length of block */ +} ocb_state; + +int ocb_init(ocb_state *ocb, int cipher, + const unsigned char *key, unsigned long keylen, const unsigned char *nonce); + +int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct); +int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt); + +int ocb_done_encrypt(ocb_state *ocb, + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen); + +int ocb_done_decrypt(ocb_state *ocb, + const unsigned char *ct, unsigned long ctlen, + unsigned char *pt, + const unsigned char *tag, unsigned long taglen, int *stat); + +int ocb_encrypt_authenticate_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen); + +int ocb_decrypt_verify_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, + const unsigned char *ct, unsigned long ctlen, + unsigned char *pt, + const unsigned char *tag, unsigned long taglen, + int *stat); + +int ocb_test(void); + +/* internal functions */ +void ocb_shift_xor(ocb_state *ocb, unsigned char *Z); +int ocb_ntz(unsigned long x); +int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode); + +#endif /* LTC_OCB_MODE */ + +#ifdef LTC_OCB3_MODE +typedef struct { + unsigned char Offset_0[MAXBLOCKSIZE], /* Offset_0 value */ + Offset_current[MAXBLOCKSIZE], /* Offset_{current_block_index} value */ + L_dollar[MAXBLOCKSIZE], /* L_$ value */ + L_star[MAXBLOCKSIZE], /* L_* value */ + L_[32][MAXBLOCKSIZE], /* L_{i} values */ + tag_part[MAXBLOCKSIZE], /* intermediate result of tag calculation */ + checksum[MAXBLOCKSIZE]; /* current checksum */ + + /* AAD related members */ + unsigned char aSum_current[MAXBLOCKSIZE], /* AAD related helper variable */ + aOffset_current[MAXBLOCKSIZE], /* AAD related helper variable */ + adata_buffer[MAXBLOCKSIZE]; /* AAD buffer */ + int adata_buffer_bytes; /* bytes in AAD buffer */ + unsigned long ablock_index; /* index # for current adata (AAD) block */ + + symmetric_key key; /* scheduled key for cipher */ + unsigned long block_index; /* index # for current data block */ + int cipher, /* cipher idx */ + tag_len, /* length of tag */ + block_len; /* length of block */ +} ocb3_state; + +int ocb3_init(ocb3_state *ocb, int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + unsigned long taglen); + +int ocb3_encrypt(ocb3_state *ocb, const unsigned char *pt, unsigned long ptlen, unsigned char *ct); +int ocb3_decrypt(ocb3_state *ocb, const unsigned char *ct, unsigned long ctlen, unsigned char *pt); +int ocb3_encrypt_last(ocb3_state *ocb, const unsigned char *pt, unsigned long ptlen, unsigned char *ct); +int ocb3_decrypt_last(ocb3_state *ocb, const unsigned char *ct, unsigned long ctlen, unsigned char *pt); +int ocb3_add_aad(ocb3_state *ocb, const unsigned char *aad, unsigned long aadlen); +int ocb3_done(ocb3_state *ocb, unsigned char *tag, unsigned long *taglen); + +int ocb3_encrypt_authenticate_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *adata, unsigned long adatalen, + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen); + +int ocb3_decrypt_verify_memory(int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *adata, unsigned long adatalen, + const unsigned char *ct, unsigned long ctlen, + unsigned char *pt, + const unsigned char *tag, unsigned long taglen, + int *stat); + +int ocb3_test(void); + +#endif /* LTC_OCB3_MODE */ + +#ifdef LTC_CCM_MODE + +#define CCM_ENCRYPT LTC_ENCRYPT +#define CCM_DECRYPT LTC_DECRYPT + +typedef struct { + symmetric_key K; + int cipher, /* which cipher */ + taglen, /* length of the tag (encoded in M value) */ + x; /* index in PAD */ + + unsigned long L, /* L value */ + ptlen, /* length that will be enc / dec */ + current_ptlen, /* current processed length */ + aadlen, /* length of the aad */ + current_aadlen, /* length of the currently provided add */ + noncelen; /* length of the nonce */ + + unsigned char PAD[16], /* flags | Nonce N | l(m) */ + ctr[16], + CTRPAD[16], + CTRlen; +} ccm_state; + +int ccm_init(ccm_state *ccm, int cipher, + const unsigned char *key, int keylen, int ptlen, int taglen, int aadlen); + +int ccm_reset(ccm_state *ccm); + +int ccm_add_nonce(ccm_state *ccm, + const unsigned char *nonce, unsigned long noncelen); + +int ccm_add_aad(ccm_state *ccm, + const unsigned char *adata, unsigned long adatalen); + +int ccm_process(ccm_state *ccm, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + int direction); + +int ccm_done(ccm_state *ccm, + unsigned char *tag, unsigned long *taglen); + +int ccm_memory(int cipher, + const unsigned char *key, unsigned long keylen, + symmetric_key *uskey, + const unsigned char *nonce, unsigned long noncelen, + const unsigned char *header, unsigned long headerlen, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen, + int direction); + +int ccm_test(void); + +#endif /* LTC_CCM_MODE */ + +#if defined(LRW_MODE) || defined(LTC_GCM_MODE) +void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c); +#endif + + +/* table shared between GCM and LRW */ +#if defined(LTC_GCM_TABLES) || defined(LTC_LRW_TABLES) || ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST)) +extern const unsigned char gcm_shift_table[]; +#endif + +#ifdef LTC_GCM_MODE + +#define GCM_ENCRYPT LTC_ENCRYPT +#define GCM_DECRYPT LTC_DECRYPT + +#define LTC_GCM_MODE_IV 0 +#define LTC_GCM_MODE_AAD 1 +#define LTC_GCM_MODE_TEXT 2 + +typedef struct { + symmetric_key K; + unsigned char H[16], /* multiplier */ + X[16], /* accumulator */ + Y[16], /* counter */ + Y_0[16], /* initial counter */ + buf[16]; /* buffer for stuff */ + + int cipher, /* which cipher */ + ivmode, /* Which mode is the IV in? */ + mode, /* mode the GCM code is in */ + buflen; /* length of data in buf */ + + ulong64 totlen, /* 64-bit counter used for IV and AAD */ + pttotlen; /* 64-bit counter for the PT */ + +#ifdef LTC_GCM_TABLES + unsigned char PC[16][256][16] /* 16 tables of 8x128 */ +#ifdef LTC_GCM_TABLES_SSE2 +LTC_ALIGN(16) +#endif +; +#endif +} gcm_state; + +void gcm_mult_h(const gcm_state *gcm, unsigned char *I); + +int gcm_init(gcm_state *gcm, int cipher, + const unsigned char *key, int keylen); + +int gcm_reset(gcm_state *gcm); + +int gcm_add_iv(gcm_state *gcm, + const unsigned char *IV, unsigned long IVlen); + +int gcm_add_aad(gcm_state *gcm, + const unsigned char *adata, unsigned long adatalen); + +int gcm_process(gcm_state *gcm, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + int direction); + +int gcm_done(gcm_state *gcm, + unsigned char *tag, unsigned long *taglen); + +int gcm_memory( int cipher, + const unsigned char *key, unsigned long keylen, + const unsigned char *IV, unsigned long IVlen, + const unsigned char *adata, unsigned long adatalen, + unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tag, unsigned long *taglen, + int direction); +int gcm_test(void); + +#endif /* LTC_GCM_MODE */ + +#ifdef LTC_CHACHA20POLY1305_MODE + +typedef struct { + poly1305_state poly; + chacha_state chacha; + ulong64 aadlen; + ulong64 ctlen; + int aadflg; +} chacha20poly1305_state; + +#define CHACHA20POLY1305_ENCRYPT LTC_ENCRYPT +#define CHACHA20POLY1305_DECRYPT LTC_DECRYPT + +int chacha20poly1305_init(chacha20poly1305_state *st, const unsigned char *key, unsigned long keylen); +int chacha20poly1305_setiv(chacha20poly1305_state *st, const unsigned char *iv, unsigned long ivlen); +int chacha20poly1305_setiv_rfc7905(chacha20poly1305_state *st, const unsigned char *iv, unsigned long ivlen, ulong64 sequence_number); +int chacha20poly1305_add_aad(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen); +int chacha20poly1305_encrypt(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int chacha20poly1305_decrypt(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int chacha20poly1305_done(chacha20poly1305_state *st, unsigned char *tag, unsigned long *taglen); +int chacha20poly1305_memory(const unsigned char *key, unsigned long keylen, + const unsigned char *iv, unsigned long ivlen, + const unsigned char *aad, unsigned long aadlen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, + unsigned char *tag, unsigned long *taglen, + int direction); +int chacha20poly1305_test(void); + +#endif /* LTC_CHACHA20POLY1305_MODE */ diff --git a/libtomcrypt/src/headers/tomcrypt_macros.h b/libtomcrypt/src/headers/tomcrypt_macros.h new file mode 100644 index 0000000..94aa7c3 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_macros.h @@ -0,0 +1,454 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- HELPER MACROS ---- */ +#ifdef ENDIAN_NEUTRAL + +#define STORE32L(x, y) \ + do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ + (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0) + +#define LOAD32L(x, y) \ + do { x = ((ulong32)((y)[3] & 255)<<24) | \ + ((ulong32)((y)[2] & 255)<<16) | \ + ((ulong32)((y)[1] & 255)<<8) | \ + ((ulong32)((y)[0] & 255)); } while(0) + +#define STORE64L(x, y) \ + do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ + (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ + (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ + (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0) + +#define LOAD64L(x, y) \ + do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \ + (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \ + (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \ + (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0) + +#define STORE32H(x, y) \ + do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \ + (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0) + +#define LOAD32H(x, y) \ + do { x = ((ulong32)((y)[0] & 255)<<24) | \ + ((ulong32)((y)[1] & 255)<<16) | \ + ((ulong32)((y)[2] & 255)<<8) | \ + ((ulong32)((y)[3] & 255)); } while(0) + +#define STORE64H(x, y) \ +do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ + (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ + (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ + (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0) + +#define LOAD64H(x, y) \ +do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \ + (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \ + (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \ + (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0) + + +#elif defined(ENDIAN_LITTLE) + +#ifdef LTC_HAVE_BSWAP_BUILTIN + +#define STORE32H(x, y) \ +do { ulong32 ttt = __builtin_bswap32 ((x)); \ + XMEMCPY ((y), &ttt, 4); } while(0) + +#define LOAD32H(x, y) \ +do { XMEMCPY (&(x), (y), 4); \ + (x) = __builtin_bswap32 ((x)); } while(0) + +#elif !defined(LTC_NO_BSWAP) && (defined(INTEL_CC) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__) || defined(__x86_64__)))) + +#define STORE32H(x, y) \ +asm __volatile__ ( \ + "bswapl %0 \n\t" \ + "movl %0,(%1)\n\t" \ + "bswapl %0 \n\t" \ + ::"r"(x), "r"(y): "memory"); + +#define LOAD32H(x, y) \ +asm __volatile__ ( \ + "movl (%1),%0\n\t" \ + "bswapl %0\n\t" \ + :"=r"(x): "r"(y): "memory"); + +#else + +#define STORE32H(x, y) \ + do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \ + (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0) + +#define LOAD32H(x, y) \ + do { x = ((ulong32)((y)[0] & 255)<<24) | \ + ((ulong32)((y)[1] & 255)<<16) | \ + ((ulong32)((y)[2] & 255)<<8) | \ + ((ulong32)((y)[3] & 255)); } while(0) + +#endif + +#ifdef LTC_HAVE_BSWAP_BUILTIN + +#define STORE64H(x, y) \ +do { ulong64 ttt = __builtin_bswap64 ((x)); \ + XMEMCPY ((y), &ttt, 8); } while(0) + +#define LOAD64H(x, y) \ +do { XMEMCPY (&(x), (y), 8); \ + (x) = __builtin_bswap64 ((x)); } while(0) + +/* x86_64 processor */ +#elif !defined(LTC_NO_BSWAP) && (defined(__GNUC__) && defined(__x86_64__)) + +#define STORE64H(x, y) \ +asm __volatile__ ( \ + "bswapq %0 \n\t" \ + "movq %0,(%1)\n\t" \ + "bswapq %0 \n\t" \ + ::"r"(x), "r"(y): "memory"); + +#define LOAD64H(x, y) \ +asm __volatile__ ( \ + "movq (%1),%0\n\t" \ + "bswapq %0\n\t" \ + :"=r"(x): "r"(y): "memory"); + +#else + +#define STORE64H(x, y) \ +do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ + (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ + (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ + (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0) + +#define LOAD64H(x, y) \ +do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \ + (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \ + (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \ + (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0) + +#endif + +#ifdef ENDIAN_32BITWORD + +#define STORE32L(x, y) \ + do { ulong32 ttt = (x); XMEMCPY(y, &ttt, 4); } while(0) + +#define LOAD32L(x, y) \ + do { XMEMCPY(&(x), y, 4); } while(0) + +#define STORE64L(x, y) \ + do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ + (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ + (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ + (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0) + +#define LOAD64L(x, y) \ + do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \ + (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \ + (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \ + (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0) + +#else /* 64-bit words then */ + +#define STORE32L(x, y) \ + do { ulong32 ttt = (x); XMEMCPY(y, &ttt, 4); } while(0) + +#define LOAD32L(x, y) \ + do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0) + +#define STORE64L(x, y) \ + do { ulong64 ttt = (x); XMEMCPY(y, &ttt, 8); } while(0) + +#define LOAD64L(x, y) \ + do { XMEMCPY(&(x), y, 8); } while(0) + +#endif /* ENDIAN_64BITWORD */ + +#elif defined(ENDIAN_BIG) + +#define STORE32L(x, y) \ + do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ + (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0) + +#define LOAD32L(x, y) \ + do { x = ((ulong32)((y)[3] & 255)<<24) | \ + ((ulong32)((y)[2] & 255)<<16) | \ + ((ulong32)((y)[1] & 255)<<8) | \ + ((ulong32)((y)[0] & 255)); } while(0) + +#define STORE64L(x, y) \ +do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ + (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ + (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ + (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0) + +#define LOAD64L(x, y) \ +do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \ + (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \ + (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \ + (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0) + +#ifdef ENDIAN_32BITWORD + +#define STORE32H(x, y) \ + do { ulong32 ttt = (x); XMEMCPY(y, &ttt, 4); } while(0) + +#define LOAD32H(x, y) \ + do { XMEMCPY(&(x), y, 4); } while(0) + +#define STORE64H(x, y) \ + do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ + (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ + (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ + (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0) + +#define LOAD64H(x, y) \ + do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \ + (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \ + (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \ + (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); } while(0) + +#else /* 64-bit words then */ + +#define STORE32H(x, y) \ + do { ulong32 ttt = (x); XMEMCPY(y, &ttt, 4); } while(0) + +#define LOAD32H(x, y) \ + do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0) + +#define STORE64H(x, y) \ + do { ulong64 ttt = (x); XMEMCPY(y, &ttt, 8); } while(0) + +#define LOAD64H(x, y) \ + do { XMEMCPY(&(x), y, 8); } while(0) + +#endif /* ENDIAN_64BITWORD */ +#endif /* ENDIAN_BIG */ + +#define BSWAP(x) ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL) | \ + ((x>>8)&0x0000FF00UL) | ((x<<8)&0x00FF0000UL) ) + + +/* 32-bit Rotates */ +#if defined(_MSC_VER) +#define LTC_ROx_BUILTIN + +/* instrinsic rotate */ +#include +#pragma intrinsic(_rotr,_rotl) +#define ROR(x,n) _rotr(x,n) +#define ROL(x,n) _rotl(x,n) +#define RORc(x,n) ROR(x,n) +#define ROLc(x,n) ROL(x,n) + +#elif defined(LTC_HAVE_ROTATE_BUILTIN) +#define LTC_ROx_BUILTIN + +#define ROR(x,n) __builtin_rotateright32(x,n) +#define ROL(x,n) __builtin_rotateleft32(x,n) +#define ROLc(x,n) ROL(x,n) +#define RORc(x,n) ROR(x,n) + +#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM) +#define LTC_ROx_ASM + +static inline ulong32 ROL(ulong32 word, int i) +{ + asm ("roll %%cl,%0" + :"=r" (word) + :"0" (word),"c" (i)); + return word; +} + +static inline ulong32 ROR(ulong32 word, int i) +{ + asm ("rorl %%cl,%0" + :"=r" (word) + :"0" (word),"c" (i)); + return word; +} + +#ifndef LTC_NO_ROLC + +#define ROLc(word,i) ({ \ + ulong32 ROLc_tmp = (word); \ + __asm__ ("roll %2, %0" : \ + "=r" (ROLc_tmp) : \ + "0" (ROLc_tmp), \ + "I" (i)); \ + ROLc_tmp; \ + }) +#define RORc(word,i) ({ \ + ulong32 RORc_tmp = (word); \ + __asm__ ("rorl %2, %0" : \ + "=r" (RORc_tmp) : \ + "0" (RORc_tmp), \ + "I" (i)); \ + RORc_tmp; \ + }) + +#else + +#define ROLc ROL +#define RORc ROR + +#endif + +#elif !defined(__STRICT_ANSI__) && defined(LTC_PPC32) +#define LTC_ROx_ASM + +static inline ulong32 ROL(ulong32 word, int i) +{ + asm ("rotlw %0,%0,%2" + :"=r" (word) + :"0" (word),"r" (i)); + return word; +} + +static inline ulong32 ROR(ulong32 word, int i) +{ + asm ("rotlw %0,%0,%2" + :"=r" (word) + :"0" (word),"r" (32-i)); + return word; +} + +#ifndef LTC_NO_ROLC + +static inline ulong32 ROLc(ulong32 word, const int i) +{ + asm ("rotlwi %0,%0,%2" + :"=r" (word) + :"0" (word),"I" (i)); + return word; +} + +static inline ulong32 RORc(ulong32 word, const int i) +{ + asm ("rotrwi %0,%0,%2" + :"=r" (word) + :"0" (word),"I" (i)); + return word; +} + +#else + +#define ROLc ROL +#define RORc ROR + +#endif + + +#else + +/* rotates the hard way */ +#define ROL(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL) +#define ROR(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL) +#define ROLc(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL) +#define RORc(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL) + +#endif + + +/* 64-bit Rotates */ +#if defined(_MSC_VER) + +/* instrinsic rotate */ +#include +#pragma intrinsic(_rotr64,_rotr64) +#define ROR64(x,n) _rotr64(x,n) +#define ROL64(x,n) _rotl64(x,n) +#define ROR64c(x,n) ROR64(x,n) +#define ROL64c(x,n) ROL64(x,n) + +#elif defined(LTC_HAVE_ROTATE_BUILTIN) + +#define ROR64(x,n) __builtin_rotateright64(x,n) +#define ROL64(x,n) __builtin_rotateleft64(x,n) +#define ROR64c(x,n) ROR64(x,n) +#define ROL64c(x,n) ROL64(x,n) + +#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && defined(__x86_64__) && !defined(INTEL_CC) && !defined(LTC_NO_ASM) + +static inline ulong64 ROL64(ulong64 word, int i) +{ + asm("rolq %%cl,%0" + :"=r" (word) + :"0" (word),"c" (i)); + return word; +} + +static inline ulong64 ROR64(ulong64 word, int i) +{ + asm("rorq %%cl,%0" + :"=r" (word) + :"0" (word),"c" (i)); + return word; +} + +#ifndef LTC_NO_ROLC + +#define ROL64c(word,i) ({ \ + ulong64 ROL64c_tmp = word; \ + __asm__ ("rolq %2, %0" : \ + "=r" (ROL64c_tmp) : \ + "0" (ROL64c_tmp), \ + "J" (i)); \ + ROL64c_tmp; \ + }) +#define ROR64c(word,i) ({ \ + ulong64 ROR64c_tmp = word; \ + __asm__ ("rorq %2, %0" : \ + "=r" (ROR64c_tmp) : \ + "0" (ROR64c_tmp), \ + "J" (i)); \ + ROR64c_tmp; \ + }) + +#else /* LTC_NO_ROLC */ + +#define ROL64c ROL64 +#define ROR64c ROR64 + +#endif + +#else /* Not x86_64 */ + +#define ROL64(x, y) \ + ( (((x)<<((ulong64)(y)&63)) | \ + (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF)) + +#define ROR64(x, y) \ + ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \ + ((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF)) + +#define ROL64c(x, y) \ + ( (((x)<<((ulong64)(y)&63)) | \ + (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF)) + +#define ROR64c(x, y) \ + ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \ + ((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF)) + +#endif + +#ifndef MAX + #define MAX(x, y) ( ((x)>(y))?(x):(y) ) +#endif + +#ifndef MIN + #define MIN(x, y) ( ((x)<(y))?(x):(y) ) +#endif + +#ifndef LTC_UNUSED_PARAM + #define LTC_UNUSED_PARAM(x) (void)(x) +#endif + +/* there is no snprintf before Visual C++ 2015 */ +#if defined(_MSC_VER) && _MSC_VER < 1900 +#define snprintf _snprintf +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_math.h b/libtomcrypt/src/headers/tomcrypt_math.h new file mode 100644 index 0000000..bb49915 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_math.h @@ -0,0 +1,519 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/** math functions **/ + +#define LTC_MP_LT -1 +#define LTC_MP_EQ 0 +#define LTC_MP_GT 1 + +#define LTC_MP_NO 0 +#define LTC_MP_YES 1 + +#ifndef LTC_MECC + typedef void ecc_point; +#endif + +#ifndef LTC_MRSA + typedef void rsa_key; +#endif + +#ifndef LTC_MILLER_RABIN_REPS + /* Number of rounds of the Miller-Rabin test + * "Reasonable values of reps are between 15 and 50." c.f. gmp doc of mpz_probab_prime_p() + * As of https://security.stackexchange.com/a/4546 we should use 40 rounds */ + #define LTC_MILLER_RABIN_REPS 40 +#endif + +int radix_to_bin(const void *in, int radix, void *out, unsigned long *len); + +/** math descriptor */ +typedef struct { + /** Name of the math provider */ + const char *name; + + /** Bits per digit, amount of bits must fit in an unsigned long */ + int bits_per_digit; + +/* ---- init/deinit functions ---- */ + + /** initialize a bignum + @param a The number to initialize + @return CRYPT_OK on success + */ + int (*init)(void **a); + + /** init copy + @param dst The number to initialize and write to + @param src The number to copy from + @return CRYPT_OK on success + */ + int (*init_copy)(void **dst, void *src); + + /** deinit + @param a The number to free + @return CRYPT_OK on success + */ + void (*deinit)(void *a); + +/* ---- data movement ---- */ + + /** negate + @param src The number to negate + @param dst The destination + @return CRYPT_OK on success + */ + int (*neg)(void *src, void *dst); + + /** copy + @param src The number to copy from + @param dst The number to write to + @return CRYPT_OK on success + */ + int (*copy)(void *src, void *dst); + +/* ---- trivial low level functions ---- */ + + /** set small constant + @param a Number to write to + @param n Source upto bits_per_digit (actually meant for very small constants) + @return CRYPT_OK on success + */ + int (*set_int)(void *a, ltc_mp_digit n); + + /** get small constant + @param a Small number to read, + only fetches up to bits_per_digit from the number + @return The lower bits_per_digit of the integer (unsigned) + */ + unsigned long (*get_int)(void *a); + + /** get digit n + @param a The number to read from + @param n The number of the digit to fetch + @return The bits_per_digit sized n'th digit of a + */ + ltc_mp_digit (*get_digit)(void *a, int n); + + /** Get the number of digits that represent the number + @param a The number to count + @return The number of digits used to represent the number + */ + int (*get_digit_count)(void *a); + + /** compare two integers + @param a The left side integer + @param b The right side integer + @return LTC_MP_LT if a < b, + LTC_MP_GT if a > b and + LTC_MP_EQ otherwise. (signed comparison) + */ + int (*compare)(void *a, void *b); + + /** compare against int + @param a The left side integer + @param b The right side integer (upto bits_per_digit) + @return LTC_MP_LT if a < b, + LTC_MP_GT if a > b and + LTC_MP_EQ otherwise. (signed comparison) + */ + int (*compare_d)(void *a, ltc_mp_digit n); + + /** Count the number of bits used to represent the integer + @param a The integer to count + @return The number of bits required to represent the integer + */ + int (*count_bits)(void * a); + + /** Count the number of LSB bits which are zero + @param a The integer to count + @return The number of contiguous zero LSB bits + */ + int (*count_lsb_bits)(void *a); + + /** Compute a power of two + @param a The integer to store the power in + @param n The power of two you want to store (a = 2^n) + @return CRYPT_OK on success + */ + int (*twoexpt)(void *a , int n); + +/* ---- radix conversions ---- */ + + /** read ascii string + @param a The integer to store into + @param str The string to read + @param radix The radix the integer has been represented in (2-64) + @return CRYPT_OK on success + */ + int (*read_radix)(void *a, const char *str, int radix); + + /** write number to string + @param a The integer to store + @param str The destination for the string + @param radix The radix the integer is to be represented in (2-64) + @return CRYPT_OK on success + */ + int (*write_radix)(void *a, char *str, int radix); + + /** get size as unsigned char string + @param a The integer to get the size (when stored in array of octets) + @return The length of the integer in octets + */ + unsigned long (*unsigned_size)(void *a); + + /** store an integer as an array of octets + @param src The integer to store + @param dst The buffer to store the integer in + @return CRYPT_OK on success + */ + int (*unsigned_write)(void *src, unsigned char *dst); + + /** read an array of octets and store as integer + @param dst The integer to load + @param src The array of octets + @param len The number of octets + @return CRYPT_OK on success + */ + int (*unsigned_read)( void *dst, + unsigned char *src, + unsigned long len); + +/* ---- basic math ---- */ + + /** add two integers + @param a The first source integer + @param b The second source integer + @param c The destination of "a + b" + @return CRYPT_OK on success + */ + int (*add)(void *a, void *b, void *c); + + /** add two integers + @param a The first source integer + @param b The second source integer + (single digit of upto bits_per_digit in length) + @param c The destination of "a + b" + @return CRYPT_OK on success + */ + int (*addi)(void *a, ltc_mp_digit b, void *c); + + /** subtract two integers + @param a The first source integer + @param b The second source integer + @param c The destination of "a - b" + @return CRYPT_OK on success + */ + int (*sub)(void *a, void *b, void *c); + + /** subtract two integers + @param a The first source integer + @param b The second source integer + (single digit of upto bits_per_digit in length) + @param c The destination of "a - b" + @return CRYPT_OK on success + */ + int (*subi)(void *a, ltc_mp_digit b, void *c); + + /** multiply two integers + @param a The first source integer + @param b The second source integer + (single digit of upto bits_per_digit in length) + @param c The destination of "a * b" + @return CRYPT_OK on success + */ + int (*mul)(void *a, void *b, void *c); + + /** multiply two integers + @param a The first source integer + @param b The second source integer + (single digit of upto bits_per_digit in length) + @param c The destination of "a * b" + @return CRYPT_OK on success + */ + int (*muli)(void *a, ltc_mp_digit b, void *c); + + /** Square an integer + @param a The integer to square + @param b The destination + @return CRYPT_OK on success + */ + int (*sqr)(void *a, void *b); + + /** Square root (mod prime) + @param a The integer to compute square root mod prime from + @param b The prime + @param c The destination + @return CRYPT_OK on success + */ + int (*sqrtmod_prime)(void *a, void *b, void *c); + + /** Divide an integer + @param a The dividend + @param b The divisor + @param c The quotient (can be NULL to signify don't care) + @param d The remainder (can be NULL to signify don't care) + @return CRYPT_OK on success + */ + int (*mpdiv)(void *a, void *b, void *c, void *d); + + /** divide by two + @param a The integer to divide (shift right) + @param b The destination + @return CRYPT_OK on success + */ + int (*div_2)(void *a, void *b); + + /** Get remainder (small value) + @param a The integer to reduce + @param b The modulus (upto bits_per_digit in length) + @param c The destination for the residue + @return CRYPT_OK on success + */ + int (*modi)(void *a, ltc_mp_digit b, ltc_mp_digit *c); + + /** gcd + @param a The first integer + @param b The second integer + @param c The destination for (a, b) + @return CRYPT_OK on success + */ + int (*gcd)(void *a, void *b, void *c); + + /** lcm + @param a The first integer + @param b The second integer + @param c The destination for [a, b] + @return CRYPT_OK on success + */ + int (*lcm)(void *a, void *b, void *c); + + /** Modular multiplication + @param a The first source + @param b The second source + @param c The modulus + @param d The destination (a*b mod c) + @return CRYPT_OK on success + */ + int (*mulmod)(void *a, void *b, void *c, void *d); + + /** Modular squaring + @param a The first source + @param b The modulus + @param c The destination (a*a mod b) + @return CRYPT_OK on success + */ + int (*sqrmod)(void *a, void *b, void *c); + + /** Modular inversion + @param a The value to invert + @param b The modulus + @param c The destination (1/a mod b) + @return CRYPT_OK on success + */ + int (*invmod)(void *, void *, void *); + +/* ---- reduction ---- */ + + /** setup Montgomery + @param a The modulus + @param b The destination for the reduction digit + @return CRYPT_OK on success + */ + int (*montgomery_setup)(void *a, void **b); + + /** get normalization value + @param a The destination for the normalization value + @param b The modulus + @return CRYPT_OK on success + */ + int (*montgomery_normalization)(void *a, void *b); + + /** reduce a number + @param a The number [and dest] to reduce + @param b The modulus + @param c The value "b" from montgomery_setup() + @return CRYPT_OK on success + */ + int (*montgomery_reduce)(void *a, void *b, void *c); + + /** clean up (frees memory) + @param a The value "b" from montgomery_setup() + @return CRYPT_OK on success + */ + void (*montgomery_deinit)(void *a); + +/* ---- exponentiation ---- */ + + /** Modular exponentiation + @param a The base integer + @param b The power (can be negative) integer + @param c The modulus integer + @param d The destination + @return CRYPT_OK on success + */ + int (*exptmod)(void *a, void *b, void *c, void *d); + + /** Primality testing + @param a The integer to test + @param b The number of Miller-Rabin tests that shall be executed + @param c The destination of the result (FP_YES if prime) + @return CRYPT_OK on success + */ + int (*isprime)(void *a, int b, int *c); + +/* ---- (optional) ecc point math ---- */ + + /** ECC GF(p) point multiplication (from the NIST curves) + @param k The integer to multiply the point by + @param G The point to multiply + @param R The destination for kG + @param a ECC curve parameter a + @param modulus The modulus for the field + @param map Boolean indicated whether to map back to affine or not + (can be ignored if you work in affine only) + @return CRYPT_OK on success + */ + int (*ecc_ptmul)( void *k, + const ecc_point *G, + ecc_point *R, + void *a, + void *modulus, + int map); + + /** ECC GF(p) point addition + @param P The first point + @param Q The second point + @param R The destination of P + Q + @param ma The curve parameter "a" in montgomery form + @param modulus The modulus + @param mp The "b" value from montgomery_setup() + @return CRYPT_OK on success + */ + int (*ecc_ptadd)(const ecc_point *P, + const ecc_point *Q, + ecc_point *R, + void *ma, + void *modulus, + void *mp); + + /** ECC GF(p) point double + @param P The first point + @param R The destination of 2P + @param ma The curve parameter "a" in montgomery form + @param modulus The modulus + @param mp The "b" value from montgomery_setup() + @return CRYPT_OK on success + */ + int (*ecc_ptdbl)(const ecc_point *P, + ecc_point *R, + void *ma, + void *modulus, + void *mp); + + /** ECC mapping from projective to affine, + currently uses (x,y,z) => (x/z^2, y/z^3, 1) + @param P The point to map + @param modulus The modulus + @param mp The "b" value from montgomery_setup() + @return CRYPT_OK on success + @remark The mapping can be different but keep in mind a + ecc_point only has three integers (x,y,z) so if + you use a different mapping you have to make it fit. + */ + int (*ecc_map)(ecc_point *P, void *modulus, void *mp); + + /** Computes kA*A + kB*B = C using Shamir's Trick + @param A First point to multiply + @param kA What to multiple A by + @param B Second point to multiply + @param kB What to multiple B by + @param C [out] Destination point (can overlap with A or B) + @param ma The curve parameter "a" in montgomery form + @param modulus Modulus for curve + @return CRYPT_OK on success + */ + int (*ecc_mul2add)(const ecc_point *A, void *kA, + const ecc_point *B, void *kB, + ecc_point *C, + void *ma, + void *modulus); + +/* ---- (optional) rsa optimized math (for internal CRT) ---- */ + + /** RSA Key Generation + @param prng An active PRNG state + @param wprng The index of the PRNG desired + @param size The size of the key in octets + @param e The "e" value (public key). + e==65537 is a good choice + @param key [out] Destination of a newly created private key pair + @return CRYPT_OK if successful, upon error all allocated ram is freed + */ + int (*rsa_keygen)(prng_state *prng, + int wprng, + int size, + long e, + rsa_key *key); + + /** RSA exponentiation + @param in The octet array representing the base + @param inlen The length of the input + @param out The destination (to be stored in an octet array format) + @param outlen The length of the output buffer and the resulting size + (zero padded to the size of the modulus) + @param which PK_PUBLIC for public RSA and PK_PRIVATE for private RSA + @param key The RSA key to use + @return CRYPT_OK on success + */ + int (*rsa_me)(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, int which, + const rsa_key *key); + +/* ---- basic math continued ---- */ + + /** Modular addition + @param a The first source + @param b The second source + @param c The modulus + @param d The destination (a + b mod c) + @return CRYPT_OK on success + */ + int (*addmod)(void *a, void *b, void *c, void *d); + + /** Modular substraction + @param a The first source + @param b The second source + @param c The modulus + @param d The destination (a - b mod c) + @return CRYPT_OK on success + */ + int (*submod)(void *a, void *b, void *c, void *d); + +/* ---- misc stuff ---- */ + + /** Make a pseudo-random mpi + @param a The mpi to make random + @param size The desired length + @return CRYPT_OK on success + */ + int (*rand)(void *a, int size); +} ltc_math_descriptor; + +extern ltc_math_descriptor ltc_mp; + +int ltc_init_multi(void **a, ...); +void ltc_deinit_multi(void *a, ...); +void ltc_cleanup_multi(void **a, ...); + +#ifdef LTM_DESC +extern const ltc_math_descriptor ltm_desc; +#endif + +#ifdef TFM_DESC +extern const ltc_math_descriptor tfm_desc; +#endif + +#ifdef GMP_DESC +extern const ltc_math_descriptor gmp_desc; +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_misc.h b/libtomcrypt/src/headers/tomcrypt_misc.h new file mode 100644 index 0000000..ae861fe --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_misc.h @@ -0,0 +1,178 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- LTC_BASE64 Routines ---- */ +#ifdef LTC_BASE64 +int base64_encode(const unsigned char *in, unsigned long inlen, + char *out, unsigned long *outlen); + +int base64_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int base64_strict_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int base64_sane_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +#endif + +#ifdef LTC_BASE64_URL +int base64url_encode(const unsigned char *in, unsigned long inlen, + char *out, unsigned long *outlen); +int base64url_strict_encode(const unsigned char *in, unsigned long inlen, + char *out, unsigned long *outlen); + +int base64url_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int base64url_strict_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int base64url_sane_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +#endif + +/* ---- BASE32 Routines ---- */ +#ifdef LTC_BASE32 +typedef enum { + BASE32_RFC4648 = 0, + BASE32_BASE32HEX = 1, + BASE32_ZBASE32 = 2, + BASE32_CROCKFORD = 3 +} base32_alphabet; +int base32_encode(const unsigned char *in, unsigned long inlen, + char *out, unsigned long *outlen, + base32_alphabet id); +int base32_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + base32_alphabet id); +#endif + +/* ---- BASE16 Routines ---- */ +#ifdef LTC_BASE16 +int base16_encode(const unsigned char *in, unsigned long inlen, + char *out, unsigned long *outlen, + unsigned int options); +int base16_decode(const char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +#endif + +#ifdef LTC_BCRYPT +int bcrypt_pbkdf_openbsd(const void *secret, unsigned long secret_len, + const unsigned char *salt, unsigned long salt_len, + unsigned int rounds, int hash_idx, + unsigned char *out, unsigned long *outlen); +#endif + +/* ===> LTC_HKDF -- RFC5869 HMAC-based Key Derivation Function <=== */ +#ifdef LTC_HKDF + +int hkdf_test(void); + +int hkdf_extract(int hash_idx, + const unsigned char *salt, unsigned long saltlen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +int hkdf_expand(int hash_idx, + const unsigned char *info, unsigned long infolen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long outlen); + +int hkdf(int hash_idx, + const unsigned char *salt, unsigned long saltlen, + const unsigned char *info, unsigned long infolen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long outlen); + +#endif /* LTC_HKDF */ + +/* ---- MEM routines ---- */ +int mem_neq(const void *a, const void *b, size_t len); +void zeromem(volatile void *out, size_t outlen); +void burn_stack(unsigned long len); + +const char *error_to_string(int err); + +extern const char *crypt_build_settings; + +/* ---- HMM ---- */ +int crypt_fsa(void *mp, ...); + +/* ---- Dynamic language support ---- */ +int crypt_get_constant(const char* namein, int *valueout); +int crypt_list_all_constants(char *names_list, unsigned int *names_list_size); + +int crypt_get_size(const char* namein, unsigned int *sizeout); +int crypt_list_all_sizes(char *names_list, unsigned int *names_list_size); + +#ifdef LTM_DESC +LTC_DEPRECATED(crypt_mp_init) void init_LTM(void); +#endif +#ifdef TFM_DESC +LTC_DEPRECATED(crypt_mp_init) void init_TFM(void); +#endif +#ifdef GMP_DESC +LTC_DEPRECATED(crypt_mp_init) void init_GMP(void); +#endif +int crypt_mp_init(const char* mpi); + +#ifdef LTC_ADLER32 +typedef struct adler32_state_s +{ + unsigned short s[2]; +} adler32_state; + +void adler32_init(adler32_state *ctx); +void adler32_update(adler32_state *ctx, const unsigned char *input, unsigned long length); +void adler32_finish(const adler32_state *ctx, void *hash, unsigned long size); +int adler32_test(void); +#endif + +#ifdef LTC_CRC32 +typedef struct crc32_state_s +{ + ulong32 crc; +} crc32_state; + +void crc32_init(crc32_state *ctx); +void crc32_update(crc32_state *ctx, const unsigned char *input, unsigned long length); +void crc32_finish(const crc32_state *ctx, void *hash, unsigned long size); +int crc32_test(void); +#endif + + +#ifdef LTC_PADDING + +enum padding_type { + LTC_PAD_PKCS7 = 0x0000U, +#ifdef LTC_RNG_GET_BYTES + LTC_PAD_ISO_10126 = 0x1000U, +#endif + LTC_PAD_ANSI_X923 = 0x2000U, + /* The following padding modes don't contain the padding + * length as last byte of the padding. + */ + LTC_PAD_ONE_AND_ZERO = 0x8000U, + LTC_PAD_ZERO = 0x9000U, + LTC_PAD_ZERO_ALWAYS = 0xA000U, +}; + +int padding_pad(unsigned char *data, unsigned long length, unsigned long* padded_length, unsigned long mode); +int padding_depad(const unsigned char *data, unsigned long *length, unsigned long mode); +#endif /* LTC_PADDING */ + +#ifdef LTC_SSH +typedef enum ssh_data_type_ { + LTC_SSHDATA_EOL, + LTC_SSHDATA_BYTE, + LTC_SSHDATA_BOOLEAN, + LTC_SSHDATA_UINT32, + LTC_SSHDATA_UINT64, + LTC_SSHDATA_STRING, + LTC_SSHDATA_MPINT, + LTC_SSHDATA_NAMELIST, +} ssh_data_type; + +/* VA list handy helpers with tuples of */ +int ssh_encode_sequence_multi(unsigned char *out, unsigned long *outlen, ...); +int ssh_decode_sequence_multi(const unsigned char *in, unsigned long *inlen, ...); +#endif /* LTC_SSH */ + +int compare_testvector(const void* is, const unsigned long is_len, const void* should, const unsigned long should_len, const char* what, int which); diff --git a/libtomcrypt/src/headers/tomcrypt_pk.h b/libtomcrypt/src/headers/tomcrypt_pk.h new file mode 100644 index 0000000..167789e --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_pk.h @@ -0,0 +1,785 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- NUMBER THEORY ---- */ + +enum public_key_type { + /* Refers to the public key */ + PK_PUBLIC = 0x0000, + /* Refers to the private key */ + PK_PRIVATE = 0x0001, + + /* Indicates standard output formats that can be read e.g. by OpenSSL or GnuTLS */ + PK_STD = 0x1000, + /* Indicates compressed public ECC key */ + PK_COMPRESSED = 0x2000, + /* Indicates ECC key with the curve specified by OID */ + PK_CURVEOID = 0x4000 +}; + +int rand_prime(void *N, long len, prng_state *prng, int wprng); + +/* ---- RSA ---- */ +#ifdef LTC_MRSA + +/** RSA PKCS style key */ +typedef struct Rsa_key { + /** Type of key, PK_PRIVATE or PK_PUBLIC */ + int type; + /** The public exponent */ + void *e; + /** The private exponent */ + void *d; + /** The modulus */ + void *N; + /** The p factor of N */ + void *p; + /** The q factor of N */ + void *q; + /** The 1/q mod p CRT param */ + void *qP; + /** The d mod (p - 1) CRT param */ + void *dP; + /** The d mod (q - 1) CRT param */ + void *dQ; +} rsa_key; + +int rsa_make_key(prng_state *prng, int wprng, int size, long e, rsa_key *key); +int rsa_make_key_ubin_e(prng_state *prng, int wprng, int size, + const unsigned char *e, unsigned long elen, rsa_key *key); +int rsa_get_size(const rsa_key *key); + +int rsa_exptmod(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, int which, + const rsa_key *key); + +void rsa_free(rsa_key *key); + +/* These use PKCS #1 v2.0 padding */ +#define rsa_encrypt_key(in, inlen, out, outlen, lparam, lparamlen, prng, prng_idx, hash_idx, key) \ + rsa_encrypt_key_ex(in, inlen, out, outlen, lparam, lparamlen, prng, prng_idx, hash_idx, LTC_PKCS_1_OAEP, key) + +#define rsa_decrypt_key(in, inlen, out, outlen, lparam, lparamlen, hash_idx, stat, key) \ + rsa_decrypt_key_ex(in, inlen, out, outlen, lparam, lparamlen, hash_idx, LTC_PKCS_1_OAEP, stat, key) + +#define rsa_sign_hash(in, inlen, out, outlen, prng, prng_idx, hash_idx, saltlen, key) \ + rsa_sign_hash_ex(in, inlen, out, outlen, LTC_PKCS_1_PSS, prng, prng_idx, hash_idx, saltlen, key) + +#define rsa_verify_hash(sig, siglen, hash, hashlen, hash_idx, saltlen, stat, key) \ + rsa_verify_hash_ex(sig, siglen, hash, hashlen, LTC_PKCS_1_PSS, hash_idx, saltlen, stat, key) + +#define rsa_sign_saltlen_get_max(hash_idx, key) \ + rsa_sign_saltlen_get_max_ex(LTC_PKCS_1_PSS, hash_idx, key) + +/* These can be switched between PKCS #1 v2.x and PKCS #1 v1.5 paddings */ +int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + const unsigned char *lparam, unsigned long lparamlen, + prng_state *prng, int prng_idx, + int hash_idx, int padding, + const rsa_key *key); + +int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + const unsigned char *lparam, unsigned long lparamlen, + int hash_idx, int padding, + int *stat, const rsa_key *key); + +int rsa_sign_hash_ex(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + int padding, + prng_state *prng, int prng_idx, + int hash_idx, unsigned long saltlen, + const rsa_key *key); + +int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen, + const unsigned char *hash, unsigned long hashlen, + int padding, + int hash_idx, unsigned long saltlen, + int *stat, const rsa_key *key); + +int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, const rsa_key *key); + +/* PKCS #1 import/export */ +int rsa_export(unsigned char *out, unsigned long *outlen, int type, const rsa_key *key); +int rsa_import(const unsigned char *in, unsigned long inlen, rsa_key *key); + +int rsa_import_x509(const unsigned char *in, unsigned long inlen, rsa_key *key); +int rsa_import_pkcs8(const unsigned char *in, unsigned long inlen, + const void *passwd, unsigned long passwdlen, rsa_key *key); + +int rsa_set_key(const unsigned char *N, unsigned long Nlen, + const unsigned char *e, unsigned long elen, + const unsigned char *d, unsigned long dlen, + rsa_key *key); +int rsa_set_factors(const unsigned char *p, unsigned long plen, + const unsigned char *q, unsigned long qlen, + rsa_key *key); +int rsa_set_crt_params(const unsigned char *dP, unsigned long dPlen, + const unsigned char *dQ, unsigned long dQlen, + const unsigned char *qP, unsigned long qPlen, + rsa_key *key); +#endif + +/* ---- DH Routines ---- */ +#ifdef LTC_MDH + +typedef struct { + int type; + void *x; + void *y; + void *base; + void *prime; +} dh_key; + +int dh_get_groupsize(const dh_key *key); + +int dh_export(unsigned char *out, unsigned long *outlen, int type, const dh_key *key); +int dh_import(const unsigned char *in, unsigned long inlen, dh_key *key); + +int dh_set_pg(const unsigned char *p, unsigned long plen, + const unsigned char *g, unsigned long glen, + dh_key *key); +int dh_set_pg_dhparam(const unsigned char *dhparam, unsigned long dhparamlen, dh_key *key); +int dh_set_pg_groupsize(int groupsize, dh_key *key); + +int dh_set_key(const unsigned char *in, unsigned long inlen, int type, dh_key *key); +int dh_generate_key(prng_state *prng, int wprng, dh_key *key); + +int dh_shared_secret(const dh_key *private_key, const dh_key *public_key, + unsigned char *out, unsigned long *outlen); + +void dh_free(dh_key *key); + +int dh_export_key(void *out, unsigned long *outlen, int type, const dh_key *key); +#endif /* LTC_MDH */ + + +/* ---- ECC Routines ---- */ +#ifdef LTC_MECC + +/* size of our temp buffers for exported keys */ +#define ECC_BUF_SIZE 256 + +/* max private key size */ +#define ECC_MAXSIZE 66 + +/** Structure defines a GF(p) curve */ +typedef struct { + /** The prime that defines the field the curve is in (encoded in hex) */ + const char *prime; + + /** The fields A param (hex) */ + const char *A; + + /** The fields B param (hex) */ + const char *B; + + /** The order of the curve (hex) */ + const char *order; + + /** The x co-ordinate of the base point on the curve (hex) */ + const char *Gx; + + /** The y co-ordinate of the base point on the curve (hex) */ + const char *Gy; + + /** The co-factor */ + unsigned long cofactor; + + /** The OID */ + const char *OID; +} ltc_ecc_curve; + +/** A point on a ECC curve, stored in Jacbobian format such that (x,y,z) => (x/z^2, y/z^3, 1) when interpretted as affine */ +typedef struct { + /** The x co-ordinate */ + void *x; + + /** The y co-ordinate */ + void *y; + + /** The z co-ordinate */ + void *z; +} ecc_point; + +/** ECC key's domain parameters */ +typedef struct { + /** The size of the curve in octets */ + int size; + /** The prime that defines the field the curve is in */ + void *prime; + /** The fields A param */ + void *A; + /** The fields B param */ + void *B; + /** The order of the curve */ + void *order; + /** The base point G on the curve */ + ecc_point base; + /** The co-factor */ + unsigned long cofactor; + /** The OID */ + unsigned long oid[16]; + unsigned long oidlen; +} ltc_ecc_dp; + +/** An ECC key */ +typedef struct { + /** Type of key, PK_PRIVATE or PK_PUBLIC */ + int type; + + /** Structure with domain parameters */ + ltc_ecc_dp dp; + + /** Structure with the public key */ + ecc_point pubkey; + + /** The private key */ + void *k; +} ecc_key; + +/** Formats of ECC signatures */ +typedef enum ecc_signature_type_ { + /* ASN.1 encoded, ANSI X9.62 */ + LTC_ECCSIG_ANSIX962 = 0x0, + /* raw R, S values */ + LTC_ECCSIG_RFC7518 = 0x1, + /* raw R, S, V (+27) values */ + LTC_ECCSIG_ETH27 = 0x2, + /* SSH + ECDSA signature format defined by RFC5656 */ + LTC_ECCSIG_RFC5656 = 0x3, +} ecc_signature_type; + +/** the ECC params provided */ +extern const ltc_ecc_curve ltc_ecc_curves[]; + +void ecc_sizes(int *low, int *high); +int ecc_get_size(const ecc_key *key); + +int ecc_find_curve(const char* name_or_oid, const ltc_ecc_curve** cu); +int ecc_set_curve(const ltc_ecc_curve *cu, ecc_key *key); +int ecc_generate_key(prng_state *prng, int wprng, ecc_key *key); +int ecc_set_key(const unsigned char *in, unsigned long inlen, int type, ecc_key *key); +int ecc_get_key(unsigned char *out, unsigned long *outlen, int type, const ecc_key *key); +int ecc_get_oid_str(char *out, unsigned long *outlen, const ecc_key *key); + +int ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key); +int ecc_make_key_ex(prng_state *prng, int wprng, ecc_key *key, const ltc_ecc_curve *cu); +void ecc_free(ecc_key *key); + +int ecc_export(unsigned char *out, unsigned long *outlen, int type, const ecc_key *key); +int ecc_import(const unsigned char *in, unsigned long inlen, ecc_key *key); +int ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_curve *cu); + +int ecc_ansi_x963_export(const ecc_key *key, unsigned char *out, unsigned long *outlen); +int ecc_ansi_x963_import(const unsigned char *in, unsigned long inlen, ecc_key *key); +int ecc_ansi_x963_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_curve *cu); + +int ecc_export_openssl(unsigned char *out, unsigned long *outlen, int type, const ecc_key *key); +int ecc_import_openssl(const unsigned char *in, unsigned long inlen, ecc_key *key); +int ecc_import_pkcs8(const unsigned char *in, unsigned long inlen, const void *pwd, unsigned long pwdlen, ecc_key *key); +int ecc_import_x509(const unsigned char *in, unsigned long inlen, ecc_key *key); + +int ecc_shared_secret(const ecc_key *private_key, const ecc_key *public_key, + unsigned char *out, unsigned long *outlen); + +int ecc_encrypt_key(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + prng_state *prng, int wprng, int hash, + const ecc_key *key); + +int ecc_decrypt_key(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + const ecc_key *key); + +#define ecc_sign_hash_rfc7518(in_, inlen_, out_, outlen_, prng_, wprng_, key_) \ + ecc_sign_hash_ex(in_, inlen_, out_, outlen_, prng_, wprng_, LTC_ECCSIG_RFC7518, NULL, key_) + +#define ecc_sign_hash(in_, inlen_, out_, outlen_, prng_, wprng_, key_) \ + ecc_sign_hash_ex(in_, inlen_, out_, outlen_, prng_, wprng_, LTC_ECCSIG_ANSIX962, NULL, key_) + +#define ecc_verify_hash_rfc7518(sig_, siglen_, hash_, hashlen_, stat_, key_) \ + ecc_verify_hash_ex(sig_, siglen_, hash_, hashlen_, LTC_ECCSIG_RFC7518, stat_, key_) + +#define ecc_verify_hash(sig_, siglen_, hash_, hashlen_, stat_, key_) \ + ecc_verify_hash_ex(sig_, siglen_, hash_, hashlen_, LTC_ECCSIG_ANSIX962, stat_, key_) + +int ecc_sign_hash_ex(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + prng_state *prng, int wprng, ecc_signature_type sigformat, + int *recid, const ecc_key *key); + +int ecc_verify_hash_ex(const unsigned char *sig, unsigned long siglen, + const unsigned char *hash, unsigned long hashlen, + ecc_signature_type sigformat, int *stat, const ecc_key *key); + +int ecc_recover_key(const unsigned char *sig, unsigned long siglen, + const unsigned char *hash, unsigned long hashlen, + int recid, ecc_signature_type sigformat, ecc_key *key); + +#endif + +#ifdef LTC_CURVE25519 + +typedef struct { + /** The key type, PK_PRIVATE or PK_PUBLIC */ + enum public_key_type type; + + /** The PK-algorithm, PKA_ED25519 or PKA_X25519 */ + /** This was supposed to be: + * enum public_key_algorithms algo; + * but that enum is now in tomcrypt_private.h + */ + int algo; + + /** The private key */ + unsigned char priv[32]; + + /** The public key */ + unsigned char pub[32]; +} curve25519_key; + + +/** Ed25519 Signature API */ +int ed25519_make_key(prng_state *prng, int wprng, curve25519_key *key); + +int ed25519_export( unsigned char *out, unsigned long *outlen, + int which, + const curve25519_key *key); + +int ed25519_import(const unsigned char *in, unsigned long inlen, curve25519_key *key); +int ed25519_import_raw(const unsigned char *in, unsigned long inlen, int which, curve25519_key *key); +int ed25519_import_x509(const unsigned char *in, unsigned long inlen, curve25519_key *key); +int ed25519_import_pkcs8(const unsigned char *in, unsigned long inlen, + const void *pwd, unsigned long pwdlen, + curve25519_key *key); + +int ed25519_sign(const unsigned char *msg, unsigned long msglen, + unsigned char *sig, unsigned long *siglen, + const curve25519_key *private_key); + +int ed25519_verify(const unsigned char *msg, unsigned long msglen, + const unsigned char *sig, unsigned long siglen, + int *stat, const curve25519_key *public_key); + +/** X25519 Key-Exchange API */ +int x25519_make_key(prng_state *prng, int wprng, curve25519_key *key); + +int x25519_export( unsigned char *out, unsigned long *outlen, + int which, + const curve25519_key *key); + +int x25519_import(const unsigned char *in, unsigned long inlen, curve25519_key *key); +int x25519_import_raw(const unsigned char *in, unsigned long inlen, int which, curve25519_key *key); +int x25519_import_x509(const unsigned char *in, unsigned long inlen, curve25519_key *key); +int x25519_import_pkcs8(const unsigned char *in, unsigned long inlen, + const void *pwd, unsigned long pwdlen, + curve25519_key *key); + +int x25519_shared_secret(const curve25519_key *private_key, + const curve25519_key *public_key, + unsigned char *out, unsigned long *outlen); + +#endif /* LTC_CURVE25519 */ + +#ifdef LTC_MDSA + +/* Max diff between group and modulus size in bytes (max case: L=8192bits, N=256bits) */ +#define LTC_MDSA_DELTA 992 + +/* Max DSA group size in bytes */ +#define LTC_MDSA_MAX_GROUP 64 + +/* Max DSA modulus size in bytes (the actual DSA size, max 8192 bits) */ +#define LTC_MDSA_MAX_MODULUS 1024 + +/** DSA key structure */ +typedef struct { + /** The key type, PK_PRIVATE or PK_PUBLIC */ + int type; + + /** The order of the sub-group used in octets */ + int qord; + + /** The generator */ + void *g; + + /** The prime used to generate the sub-group */ + void *q; + + /** The large prime that generats the field the contains the sub-group */ + void *p; + + /** The private key */ + void *x; + + /** The public key */ + void *y; +} dsa_key; + +int dsa_make_key(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key); + +int dsa_set_pqg(const unsigned char *p, unsigned long plen, + const unsigned char *q, unsigned long qlen, + const unsigned char *g, unsigned long glen, + dsa_key *key); +int dsa_set_pqg_dsaparam(const unsigned char *dsaparam, unsigned long dsaparamlen, dsa_key *key); +int dsa_generate_pqg(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key); + +int dsa_set_key(const unsigned char *in, unsigned long inlen, int type, dsa_key *key); +int dsa_generate_key(prng_state *prng, int wprng, dsa_key *key); + +void dsa_free(dsa_key *key); + +int dsa_sign_hash_raw(const unsigned char *in, unsigned long inlen, + void *r, void *s, + prng_state *prng, int wprng, const dsa_key *key); + +int dsa_sign_hash(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + prng_state *prng, int wprng, const dsa_key *key); + +int dsa_verify_hash_raw( void *r, void *s, + const unsigned char *hash, unsigned long hashlen, + int *stat, const dsa_key *key); + +int dsa_verify_hash(const unsigned char *sig, unsigned long siglen, + const unsigned char *hash, unsigned long hashlen, + int *stat, const dsa_key *key); + +int dsa_encrypt_key(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + prng_state *prng, int wprng, int hash, + const dsa_key *key); + +int dsa_decrypt_key(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen, + const dsa_key *key); + +int dsa_import(const unsigned char *in, unsigned long inlen, dsa_key *key); +int dsa_export(unsigned char *out, unsigned long *outlen, int type, const dsa_key *key); +int dsa_verify_key(const dsa_key *key, int *stat); +int dsa_shared_secret(void *private_key, void *base, + const dsa_key *public_key, + unsigned char *out, unsigned long *outlen); +#endif /* LTC_MDSA */ + +#ifdef LTC_DER +/* DER handling */ + +typedef enum ltc_asn1_type_ { + /* 0 */ + LTC_ASN1_EOL, + LTC_ASN1_BOOLEAN, + LTC_ASN1_INTEGER, + LTC_ASN1_SHORT_INTEGER, + LTC_ASN1_BIT_STRING, + /* 5 */ + LTC_ASN1_OCTET_STRING, + LTC_ASN1_NULL, + LTC_ASN1_OBJECT_IDENTIFIER, + LTC_ASN1_IA5_STRING, + LTC_ASN1_PRINTABLE_STRING, + /* 10 */ + LTC_ASN1_UTF8_STRING, + LTC_ASN1_UTCTIME, + LTC_ASN1_CHOICE, + LTC_ASN1_SEQUENCE, + LTC_ASN1_SET, + /* 15 */ + LTC_ASN1_SETOF, + LTC_ASN1_RAW_BIT_STRING, + LTC_ASN1_TELETEX_STRING, + LTC_ASN1_GENERALIZEDTIME, + LTC_ASN1_CUSTOM_TYPE, +} ltc_asn1_type; + +typedef enum { + LTC_ASN1_CL_UNIVERSAL = 0x0, + LTC_ASN1_CL_APPLICATION = 0x1, + LTC_ASN1_CL_CONTEXT_SPECIFIC = 0x2, + LTC_ASN1_CL_PRIVATE = 0x3, +} ltc_asn1_class; + +typedef enum { + LTC_ASN1_PC_PRIMITIVE = 0x0, + LTC_ASN1_PC_CONSTRUCTED = 0x1, +} ltc_asn1_pc; + +/** A LTC ASN.1 list type */ +typedef struct ltc_asn1_list_ { + /** The LTC ASN.1 enumerated type identifier */ + ltc_asn1_type type; + /** The data to encode or place for decoding */ + void *data; + /** The size of the input or resulting output */ + unsigned long size; + /** The used flag + * 1. This is used by the CHOICE ASN.1 type to indicate which choice was made + * 2. This is used by the ASN.1 decoder to indicate if an element is used + * 3. This is used by the flexi-decoder to indicate the first byte of the identifier */ + int used; + /** Flag used to indicate optional items in ASN.1 sequences */ + int optional; + /** ASN.1 identifier */ + ltc_asn1_class klass; + ltc_asn1_pc pc; + ulong64 tag; + /** prev/next entry in the list */ + struct ltc_asn1_list_ *prev, *next, *child, *parent; +} ltc_asn1_list; + +#define LTC_SET_ASN1(list, index, Type, Data, Size) \ + do { \ + int LTC_MACRO_temp = (index); \ + ltc_asn1_list *LTC_MACRO_list = (list); \ + LTC_MACRO_list[LTC_MACRO_temp].type = (Type); \ + LTC_MACRO_list[LTC_MACRO_temp].data = (void*)(Data); \ + LTC_MACRO_list[LTC_MACRO_temp].size = (Size); \ + LTC_MACRO_list[LTC_MACRO_temp].used = 0; \ + LTC_MACRO_list[LTC_MACRO_temp].optional = 0; \ + LTC_MACRO_list[LTC_MACRO_temp].klass = 0; \ + LTC_MACRO_list[LTC_MACRO_temp].pc = 0; \ + LTC_MACRO_list[LTC_MACRO_temp].tag = 0; \ + } while (0) + +#define LTC_SET_ASN1_IDENTIFIER(list, index, Class, Pc, Tag) \ + do { \ + int LTC_MACRO_temp = (index); \ + ltc_asn1_list *LTC_MACRO_list = (list); \ + LTC_MACRO_list[LTC_MACRO_temp].type = LTC_ASN1_CUSTOM_TYPE; \ + LTC_MACRO_list[LTC_MACRO_temp].klass = (Class); \ + LTC_MACRO_list[LTC_MACRO_temp].pc = (Pc); \ + LTC_MACRO_list[LTC_MACRO_temp].tag = (Tag); \ + } while (0) + +#define LTC_SET_ASN1_CUSTOM_CONSTRUCTED(list, index, Class, Tag, Data) \ + do { \ + int LTC_MACRO_temp##__LINE__ = (index); \ + LTC_SET_ASN1(list, LTC_MACRO_temp##__LINE__, LTC_ASN1_CUSTOM_TYPE, Data, 1); \ + LTC_SET_ASN1_IDENTIFIER(list, LTC_MACRO_temp##__LINE__, Class, LTC_ASN1_PC_CONSTRUCTED, Tag); \ + } while (0) + +#define LTC_SET_ASN1_CUSTOM_PRIMITIVE(list, index, Class, Tag, Type, Data, Size) \ + do { \ + int LTC_MACRO_temp##__LINE__ = (index); \ + LTC_SET_ASN1(list, LTC_MACRO_temp##__LINE__, LTC_ASN1_CUSTOM_TYPE, Data, Size); \ + LTC_SET_ASN1_IDENTIFIER(list, LTC_MACRO_temp##__LINE__, Class, LTC_ASN1_PC_PRIMITIVE, Tag); \ + list[LTC_MACRO_temp##__LINE__].used = (int)(Type); \ + } while (0) + +extern const char* der_asn1_class_to_string_map[]; +extern const unsigned long der_asn1_class_to_string_map_sz; + +extern const char* der_asn1_pc_to_string_map[]; +extern const unsigned long der_asn1_pc_to_string_map_sz; + +extern const char* der_asn1_tag_to_string_map[]; +extern const unsigned long der_asn1_tag_to_string_map_sz; + +/* SEQUENCE */ +int der_encode_sequence_ex(const ltc_asn1_list *list, unsigned long inlen, + unsigned char *out, unsigned long *outlen, int type_of); + +#define der_encode_sequence(list, inlen, out, outlen) der_encode_sequence_ex(list, inlen, out, outlen, LTC_ASN1_SEQUENCE) + +/** The supported bitmap for all the + * decoders with a `flags` argument. + */ +enum ltc_der_seq { + LTC_DER_SEQ_ZERO = 0x0u, + + /** Bit0 - [0]=Unordered (SET or SETOF) + * [1]=Ordered (SEQUENCE) */ + LTC_DER_SEQ_UNORDERED = LTC_DER_SEQ_ZERO, + LTC_DER_SEQ_ORDERED = 0x1u, + + /** Bit1 - [0]=Relaxed + * [1]=Strict */ + LTC_DER_SEQ_RELAXED = LTC_DER_SEQ_ZERO, + LTC_DER_SEQ_STRICT = 0x2u, + + /** Alternative naming */ + LTC_DER_SEQ_SET = LTC_DER_SEQ_UNORDERED, + LTC_DER_SEQ_SEQUENCE = LTC_DER_SEQ_ORDERED, +}; + +int der_decode_sequence_ex(const unsigned char *in, unsigned long inlen, + ltc_asn1_list *list, unsigned long outlen, unsigned int flags); + +#define der_decode_sequence(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SEQUENCE | LTC_DER_SEQ_RELAXED) +#define der_decode_sequence_strict(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SEQUENCE | LTC_DER_SEQ_STRICT) + +int der_length_sequence(const ltc_asn1_list *list, unsigned long inlen, + unsigned long *outlen); + + +/* Custom-types */ +int der_encode_custom_type(const ltc_asn1_list *root, + unsigned char *out, unsigned long *outlen); + +int der_decode_custom_type(const unsigned char *in, unsigned long inlen, + ltc_asn1_list *root); + +int der_length_custom_type(const ltc_asn1_list *root, + unsigned long *outlen, + unsigned long *payloadlen); + +/* SET */ +#define der_decode_set(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, LTC_DER_SEQ_SET) +#define der_length_set der_length_sequence +int der_encode_set(const ltc_asn1_list *list, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +int der_encode_setof(const ltc_asn1_list *list, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +/* VA list handy helpers with triplets of */ +int der_encode_sequence_multi(unsigned char *out, unsigned long *outlen, ...); +int der_decode_sequence_multi(const unsigned char *in, unsigned long inlen, ...); + +/* FLEXI DECODER handle unknown list decoder */ +int der_decode_sequence_flexi(const unsigned char *in, unsigned long *inlen, ltc_asn1_list **out); +#define der_free_sequence_flexi der_sequence_free +void der_sequence_free(ltc_asn1_list *in); +void der_sequence_shrink(ltc_asn1_list *in); + +/* BOOLEAN */ +int der_length_boolean(unsigned long *outlen); +int der_encode_boolean(int in, + unsigned char *out, unsigned long *outlen); +int der_decode_boolean(const unsigned char *in, unsigned long inlen, + int *out); +/* INTEGER */ +int der_encode_integer(void *num, unsigned char *out, unsigned long *outlen); +int der_decode_integer(const unsigned char *in, unsigned long inlen, void *num); +int der_length_integer(void *num, unsigned long *outlen); + +/* INTEGER -- handy for 0..2^32-1 values */ +int der_decode_short_integer(const unsigned char *in, unsigned long inlen, unsigned long *num); +int der_encode_short_integer(unsigned long num, unsigned char *out, unsigned long *outlen); +int der_length_short_integer(unsigned long num, unsigned long *outlen); + +/* BIT STRING */ +int der_encode_bit_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_decode_bit_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_encode_raw_bit_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_decode_raw_bit_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_length_bit_string(unsigned long nbits, unsigned long *outlen); + +/* OCTET STRING */ +int der_encode_octet_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_decode_octet_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_length_octet_string(unsigned long noctets, unsigned long *outlen); + +/* OBJECT IDENTIFIER */ +int der_encode_object_identifier(const unsigned long *words, unsigned long nwords, + unsigned char *out, unsigned long *outlen); +int der_decode_object_identifier(const unsigned char *in, unsigned long inlen, + unsigned long *words, unsigned long *outlen); +int der_length_object_identifier(const unsigned long *words, unsigned long nwords, unsigned long *outlen); +unsigned long der_object_identifier_bits(unsigned long x); + +/* IA5 STRING */ +int der_encode_ia5_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_decode_ia5_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_length_ia5_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen); + +int der_ia5_char_encode(int c); +int der_ia5_value_decode(int v); + +/* TELETEX STRING */ +int der_decode_teletex_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_length_teletex_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen); + +/* PRINTABLE STRING */ +int der_encode_printable_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_decode_printable_string(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); +int der_length_printable_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen); + +int der_printable_char_encode(int c); +int der_printable_value_decode(int v); + +/* UTF-8 */ +#if (defined(SIZE_MAX) || __STDC_VERSION__ >= 199901L || defined(WCHAR_MAX) || defined(__WCHAR_MAX__) || defined(_WCHAR_T) || defined(_WCHAR_T_DEFINED) || defined (__WCHAR_TYPE__)) && !defined(LTC_NO_WCHAR) + #if defined(__WCHAR_MAX__) + #define LTC_WCHAR_MAX __WCHAR_MAX__ + #else + #include + #define LTC_WCHAR_MAX WCHAR_MAX + #endif +/* please note that it might happen that LTC_WCHAR_MAX is undefined */ +#else + typedef ulong32 wchar_t; + #define LTC_WCHAR_MAX 0xFFFFFFFF +#endif + +int der_encode_utf8_string(const wchar_t *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +int der_decode_utf8_string(const unsigned char *in, unsigned long inlen, + wchar_t *out, unsigned long *outlen); +unsigned long der_utf8_charsize(const wchar_t c); +int der_length_utf8_string(const wchar_t *in, unsigned long noctets, unsigned long *outlen); + + +/* CHOICE */ +int der_decode_choice(const unsigned char *in, unsigned long *inlen, + ltc_asn1_list *list, unsigned long outlen); + +/* UTCTime */ +typedef struct { + unsigned YY, /* year */ + MM, /* month */ + DD, /* day */ + hh, /* hour */ + mm, /* minute */ + ss, /* second */ + off_dir, /* timezone offset direction 0 == +, 1 == - */ + off_hh, /* timezone offset hours */ + off_mm; /* timezone offset minutes */ +} ltc_utctime; + +int der_encode_utctime(const ltc_utctime *utctime, + unsigned char *out, unsigned long *outlen); + +int der_decode_utctime(const unsigned char *in, unsigned long *inlen, + ltc_utctime *out); + +int der_length_utctime(const ltc_utctime *utctime, unsigned long *outlen); + +/* GeneralizedTime */ +typedef struct { + unsigned YYYY, /* year */ + MM, /* month */ + DD, /* day */ + hh, /* hour */ + mm, /* minute */ + ss, /* second */ + fs, /* fractional seconds */ + off_dir, /* timezone offset direction 0 == +, 1 == - */ + off_hh, /* timezone offset hours */ + off_mm; /* timezone offset minutes */ +} ltc_generalizedtime; + +int der_encode_generalizedtime(const ltc_generalizedtime *gtime, + unsigned char *out, unsigned long *outlen); + +int der_decode_generalizedtime(const unsigned char *in, unsigned long *inlen, + ltc_generalizedtime *out); + +int der_length_generalizedtime(const ltc_generalizedtime *gtime, unsigned long *outlen); + +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_pkcs.h b/libtomcrypt/src/headers/tomcrypt_pkcs.h new file mode 100644 index 0000000..a0aa892 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_pkcs.h @@ -0,0 +1,99 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* PKCS Header Info */ + +/* ===> PKCS #1 -- RSA Cryptography <=== */ +#ifdef LTC_PKCS_1 + +enum ltc_pkcs_1_v1_5_blocks +{ + LTC_PKCS_1_EMSA = 1, /* Block type 1 (PKCS #1 v1.5 signature padding) */ + LTC_PKCS_1_EME = 2 /* Block type 2 (PKCS #1 v1.5 encryption padding) */ +}; + +enum ltc_pkcs_1_paddings +{ + LTC_PKCS_1_V1_5 = 1, /* PKCS #1 v1.5 padding (\sa ltc_pkcs_1_v1_5_blocks) */ + LTC_PKCS_1_OAEP = 2, /* PKCS #1 v2.0 encryption padding */ + LTC_PKCS_1_PSS = 3, /* PKCS #1 v2.1 signature padding */ + LTC_PKCS_1_V1_5_NA1 = 4 /* PKCS #1 v1.5 padding - No ASN.1 (\sa ltc_pkcs_1_v1_5_blocks) */ +}; + +int pkcs_1_mgf1( int hash_idx, + const unsigned char *seed, unsigned long seedlen, + unsigned char *mask, unsigned long masklen); + +int pkcs_1_i2osp(void *n, unsigned long modulus_len, unsigned char *out); +int pkcs_1_os2ip(void *n, unsigned char *in, unsigned long inlen); + +/* *** v1.5 padding */ +int pkcs_1_v1_5_encode(const unsigned char *msg, + unsigned long msglen, + int block_type, + unsigned long modulus_bitlen, + prng_state *prng, + int prng_idx, + unsigned char *out, + unsigned long *outlen); + +int pkcs_1_v1_5_decode(const unsigned char *msg, + unsigned long msglen, + int block_type, + unsigned long modulus_bitlen, + unsigned char *out, + unsigned long *outlen, + int *is_valid); + +/* *** v2.1 padding */ +int pkcs_1_oaep_encode(const unsigned char *msg, unsigned long msglen, + const unsigned char *lparam, unsigned long lparamlen, + unsigned long modulus_bitlen, prng_state *prng, + int prng_idx, int hash_idx, + unsigned char *out, unsigned long *outlen); + +int pkcs_1_oaep_decode(const unsigned char *msg, unsigned long msglen, + const unsigned char *lparam, unsigned long lparamlen, + unsigned long modulus_bitlen, int hash_idx, + unsigned char *out, unsigned long *outlen, + int *res); + +int pkcs_1_pss_encode(const unsigned char *msghash, unsigned long msghashlen, + unsigned long saltlen, prng_state *prng, + int prng_idx, int hash_idx, + unsigned long modulus_bitlen, + unsigned char *out, unsigned long *outlen); + +int pkcs_1_pss_decode(const unsigned char *msghash, unsigned long msghashlen, + const unsigned char *sig, unsigned long siglen, + unsigned long saltlen, int hash_idx, + unsigned long modulus_bitlen, int *res); + +#endif /* LTC_PKCS_1 */ + +/* ===> PKCS #5 -- Password Based Cryptography <=== */ +#ifdef LTC_PKCS_5 + +/* Algorithm #1 (PBKDF1) */ +int pkcs_5_alg1(const unsigned char *password, unsigned long password_len, + const unsigned char *salt, + int iteration_count, int hash_idx, + unsigned char *out, unsigned long *outlen); + +/* Algorithm #1 (PBKDF1) - OpenSSL-compatible variant for arbitrarily-long keys. + Compatible with EVP_BytesToKey() */ +int pkcs_5_alg1_openssl(const unsigned char *password, + unsigned long password_len, + const unsigned char *salt, + int iteration_count, int hash_idx, + unsigned char *out, unsigned long *outlen); + +/* Algorithm #2 (PBKDF2) */ +int pkcs_5_alg2(const unsigned char *password, unsigned long password_len, + const unsigned char *salt, unsigned long salt_len, + int iteration_count, int hash_idx, + unsigned char *out, unsigned long *outlen); + +int pkcs_5_test (void); +#endif /* LTC_PKCS_5 */ + diff --git a/libtomcrypt/src/headers/tomcrypt_private.h b/libtomcrypt/src/headers/tomcrypt_private.h new file mode 100644 index 0000000..7c1e172 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_private.h @@ -0,0 +1,449 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#include "tomcrypt.h" + +/* + * Internal Macros + */ + +#define LTC_PAD_MASK (0xF000U) + +/* + * Internal Enums + */ + +enum ltc_oid_id { + PKA_RSA, + PKA_DSA, + PKA_EC, + PKA_EC_PRIMEF, + PKA_X25519, + PKA_ED25519, +}; + +/* + * Internal Types + */ + +typedef struct { + int size; + const char *name, *base, *prime; +} ltc_dh_set_type; + + +typedef int (*fn_kdf_t)(const unsigned char *password, unsigned long password_len, + const unsigned char *salt, unsigned long salt_len, + int iteration_count, int hash_idx, + unsigned char *out, unsigned long *outlen); + +typedef struct { + /* KDF */ + fn_kdf_t kdf; + /* Hash or HMAC */ + const char* h; + /* cipher */ + const char* c; + unsigned long keylen; + /* not used for pbkdf2 */ + unsigned long blocklen; +} pbes_properties; + +typedef struct +{ + pbes_properties type; + const void *pwd; + unsigned long pwdlen; + ltc_asn1_list *enc_data; + ltc_asn1_list *salt; + ltc_asn1_list *iv; + unsigned long iterations; + /* only used for RC2 */ + unsigned long key_bits; +} pbes_arg; + +/* + * Internal functions + */ + + +/* tomcrypt_cipher.h */ + +void blowfish_enc(ulong32 *data, unsigned long blocks, const symmetric_key *skey); +int blowfish_expand(const unsigned char *key, int keylen, + const unsigned char *data, int datalen, + symmetric_key *skey); +int blowfish_setup_with_data(const unsigned char *key, int keylen, + const unsigned char *data, int datalen, + symmetric_key *skey); + +/* tomcrypt_hash.h */ + +/* a simple macro for making hash "process" functions */ +#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \ +int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \ +{ \ + unsigned long n; \ + int err; \ + LTC_ARGCHK(md != NULL); \ + LTC_ARGCHK(in != NULL); \ + if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ + return CRYPT_INVALID_ARG; \ + } \ + if ((md-> state_var .length + inlen * 8) < md-> state_var .length) { \ + return CRYPT_HASH_OVERFLOW; \ + } \ + while (inlen > 0) { \ + if (md-> state_var .curlen == 0 && inlen >= block_size) { \ + if ((err = compress_name (md, in)) != CRYPT_OK) { \ + return err; \ + } \ + md-> state_var .length += block_size * 8; \ + in += block_size; \ + inlen -= block_size; \ + } else { \ + n = MIN(inlen, (block_size - md-> state_var .curlen)); \ + XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \ + md-> state_var .curlen += n; \ + in += n; \ + inlen -= n; \ + if (md-> state_var .curlen == block_size) { \ + if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \ + return err; \ + } \ + md-> state_var .length += 8*block_size; \ + md-> state_var .curlen = 0; \ + } \ + } \ + } \ + return CRYPT_OK; \ +} + + +/* tomcrypt_mac.h */ + +int ocb3_int_ntz(unsigned long x); +void ocb3_int_xor_blocks(unsigned char *out, const unsigned char *block_a, const unsigned char *block_b, unsigned long block_len); + + +/* tomcrypt_math.h */ + +#if !defined(DESC_DEF_ONLY) + +#define MP_DIGIT_BIT ltc_mp.bits_per_digit + +/* some handy macros */ +#define mp_init(a) ltc_mp.init(a) +#define mp_init_multi ltc_init_multi +#define mp_clear(a) ltc_mp.deinit(a) +#define mp_clear_multi ltc_deinit_multi +#define mp_cleanup_multi ltc_cleanup_multi +#define mp_init_copy(a, b) ltc_mp.init_copy(a, b) + +#define mp_neg(a, b) ltc_mp.neg(a, b) +#define mp_copy(a, b) ltc_mp.copy(a, b) + +#define mp_set(a, b) ltc_mp.set_int(a, b) +#define mp_set_int(a, b) ltc_mp.set_int(a, b) +#define mp_get_int(a) ltc_mp.get_int(a) +#define mp_get_digit(a, n) ltc_mp.get_digit(a, n) +#define mp_get_digit_count(a) ltc_mp.get_digit_count(a) +#define mp_cmp(a, b) ltc_mp.compare(a, b) +#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) +#define mp_count_bits(a) ltc_mp.count_bits(a) +#define mp_cnt_lsb(a) ltc_mp.count_lsb_bits(a) +#define mp_2expt(a, b) ltc_mp.twoexpt(a, b) + +#define mp_read_radix(a, b, c) ltc_mp.read_radix(a, b, c) +#define mp_toradix(a, b, c) ltc_mp.write_radix(a, b, c) +#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a) +#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b) +#define mp_read_unsigned_bin(a, b, c) ltc_mp.unsigned_read(a, b, c) + +#define mp_add(a, b, c) ltc_mp.add(a, b, c) +#define mp_add_d(a, b, c) ltc_mp.addi(a, b, c) +#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) +#define mp_sub_d(a, b, c) ltc_mp.subi(a, b, c) +#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) +#define mp_mul_d(a, b, c) ltc_mp.muli(a, b, c) +#define mp_sqr(a, b) ltc_mp.sqr(a, b) +#define mp_sqrtmod_prime(a, b, c) ltc_mp.sqrtmod_prime(a, b, c) +#define mp_div(a, b, c, d) ltc_mp.mpdiv(a, b, c, d) +#define mp_div_2(a, b) ltc_mp.div_2(a, b) +#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c) +#define mp_mod_d(a, b, c) ltc_mp.modi(a, b, c) +#define mp_gcd(a, b, c) ltc_mp.gcd(a, b, c) +#define mp_lcm(a, b, c) ltc_mp.lcm(a, b, c) + +#define mp_addmod(a, b, c, d) ltc_mp.addmod(a, b, c, d) +#define mp_submod(a, b, c, d) ltc_mp.submod(a, b, c, d) +#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) +#define mp_sqrmod(a, b, c) ltc_mp.sqrmod(a, b, c) +#define mp_invmod(a, b, c) ltc_mp.invmod(a, b, c) + +#define mp_montgomery_setup(a, b) ltc_mp.montgomery_setup(a, b) +#define mp_montgomery_normalization(a, b) ltc_mp.montgomery_normalization(a, b) +#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) +#define mp_montgomery_free(a) ltc_mp.montgomery_deinit(a) + +#define mp_exptmod(a,b,c,d) ltc_mp.exptmod(a,b,c,d) +#define mp_prime_is_prime(a, b, c) ltc_mp.isprime(a, b, c) + +#define mp_iszero(a) (mp_cmp_d(a, 0) == LTC_MP_EQ ? LTC_MP_YES : LTC_MP_NO) +#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) +#define mp_exch(a, b) do { void *ABC__tmp = a; a = b; b = ABC__tmp; } while(0) + +#define mp_tohex(a, b) mp_toradix(a, b, 16) + +#define mp_rand(a, b) ltc_mp.rand(a, b) + +#endif + + +/* tomcrypt_misc.h */ + +void copy_or_zeromem(const unsigned char* src, unsigned char* dest, unsigned long len, int coz); + +int pbes_decrypt(const pbes_arg *arg, unsigned char *dec_data, unsigned long *dec_size); + +int pbes1_extract(const ltc_asn1_list *s, pbes_arg *res); +int pbes2_extract(const ltc_asn1_list *s, pbes_arg *res); + + +/* tomcrypt_pk.h */ + +int rand_bn_bits(void *N, int bits, prng_state *prng, int wprng); +int rand_bn_upto(void *N, void *limit, prng_state *prng, int wprng); + +int pk_get_oid(enum ltc_oid_id id, const char **st); +int pk_oid_str_to_num(const char *OID, unsigned long *oid, unsigned long *oidlen); +int pk_oid_num_to_str(const unsigned long *oid, unsigned long oidlen, char *OID, unsigned long *outlen); + +/* ---- DH Routines ---- */ +#ifdef LTC_MRSA +int rsa_init(rsa_key *key); +void rsa_shrink_key(rsa_key *key); +int rsa_make_key_bn_e(prng_state *prng, int wprng, int size, void *e, + rsa_key *key); /* used by op-tee */ +#endif /* LTC_MRSA */ + +/* ---- DH Routines ---- */ +#ifdef LTC_MDH +extern const ltc_dh_set_type ltc_dh_sets[]; + +int dh_check_pubkey(const dh_key *key); +#endif /* LTC_MDH */ + +/* ---- ECC Routines ---- */ +#ifdef LTC_MECC +int ecc_set_curve_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key); +int ecc_copy_curve(const ecc_key *srckey, ecc_key *key); +int ecc_set_curve_by_size(int size, ecc_key *key); +int ecc_import_subject_public_key_info(const unsigned char *in, unsigned long inlen, ecc_key *key); + +#ifdef LTC_SSH +int ecc_ssh_ecdsa_encode_name(char *buffer, unsigned long *buflen, const ecc_key *key); +#endif + +/* low level functions */ +ecc_point *ltc_ecc_new_point(void); +void ltc_ecc_del_point(ecc_point *p); +int ltc_ecc_set_point_xyz(ltc_mp_digit x, ltc_mp_digit y, ltc_mp_digit z, ecc_point *p); +int ltc_ecc_copy_point(const ecc_point *src, ecc_point *dst); +int ltc_ecc_is_point(const ltc_ecc_dp *dp, void *x, void *y); +int ltc_ecc_is_point_at_infinity(const ecc_point *P, void *modulus, int *retval); +int ltc_ecc_import_point(const unsigned char *in, unsigned long inlen, void *prime, void *a, void *b, void *x, void *y); +int ltc_ecc_export_point(unsigned char *out, unsigned long *outlen, void *x, void *y, unsigned long size, int compressed); +int ltc_ecc_verify_key(const ecc_key *key); + +/* point ops (mp == montgomery digit) */ +#if !defined(LTC_MECC_ACCEL) || defined(LTM_DESC) || defined(GMP_DESC) +/* R = 2P */ +int ltc_ecc_projective_dbl_point(const ecc_point *P, ecc_point *R, void *ma, void *modulus, void *mp); + +/* R = P + Q */ +int ltc_ecc_projective_add_point(const ecc_point *P, const ecc_point *Q, ecc_point *R, void *ma, void *modulus, void *mp); +#endif + +#if defined(LTC_MECC_FP) +/* optimized point multiplication using fixed point cache (HAC algorithm 14.117) */ +int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulus, int map); + +/* functions for saving/loading/freeing/adding to fixed point cache */ +int ltc_ecc_fp_save_state(unsigned char **out, unsigned long *outlen); +int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen); +void ltc_ecc_fp_free(void); +int ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock); + +/* lock/unlock all points currently in fixed point cache */ +void ltc_ecc_fp_tablelock(int lock); +#endif + +/* R = kG */ +int ltc_ecc_mulmod(void *k, const ecc_point *G, ecc_point *R, void *a, void *modulus, int map); + +#ifdef LTC_ECC_SHAMIR +/* kA*A + kB*B = C */ +int ltc_ecc_mul2add(const ecc_point *A, void *kA, + const ecc_point *B, void *kB, + ecc_point *C, + void *ma, + void *modulus); + +#ifdef LTC_MECC_FP +/* Shamir's trick with optimized point multiplication using fixed point cache */ +int ltc_ecc_fp_mul2add(const ecc_point *A, void *kA, + const ecc_point *B, void *kB, + ecc_point *C, + void *ma, + void *modulus); +#endif + +#endif + + +/* map P to affine from projective */ +int ltc_ecc_map(ecc_point *P, void *modulus, void *mp); +#endif /* LTC_MECC */ + +#ifdef LTC_MDSA +int dsa_int_validate_xy(const dsa_key *key, int *stat); +int dsa_int_validate_pqg(const dsa_key *key, int *stat); +int dsa_int_validate_primes(const dsa_key *key, int *stat); +#endif /* LTC_MDSA */ + + +#ifdef LTC_CURVE25519 + +int tweetnacl_crypto_sign( + unsigned char *sm,unsigned long long *smlen, + const unsigned char *m,unsigned long long mlen, + const unsigned char *sk, const unsigned char *pk); +int tweetnacl_crypto_sign_open( + int *stat, + unsigned char *m,unsigned long long *mlen, + const unsigned char *sm,unsigned long long smlen, + const unsigned char *pk); +int tweetnacl_crypto_sign_keypair(prng_state *prng, int wprng, unsigned char *pk,unsigned char *sk); +int tweetnacl_crypto_sk_to_pk(unsigned char *pk, const unsigned char *sk); +int tweetnacl_crypto_scalarmult(unsigned char *q, const unsigned char *n, const unsigned char *p); +int tweetnacl_crypto_scalarmult_base(unsigned char *q,const unsigned char *n); + +typedef int (*sk_to_pk)(unsigned char *pk ,const unsigned char *sk); +int ec25519_import_pkcs8(const unsigned char *in, unsigned long inlen, + const void *pwd, unsigned long pwdlen, + enum ltc_oid_id id, sk_to_pk fp, + curve25519_key *key); +int ec25519_export( unsigned char *out, unsigned long *outlen, + int which, + const curve25519_key *key); +#endif /* LTC_CURVE25519 */ + +#ifdef LTC_DER + +#define LTC_ASN1_IS_TYPE(e, t) (((e) != NULL) && ((e)->type == (t))) + +/* DER handling */ +int der_decode_custom_type_ex(const unsigned char *in, unsigned long inlen, + ltc_asn1_list *root, + ltc_asn1_list *list, unsigned long outlen, unsigned int flags); + +int der_encode_asn1_identifier(const ltc_asn1_list *id, unsigned char *out, unsigned long *outlen); +int der_decode_asn1_identifier(const unsigned char *in, unsigned long *inlen, ltc_asn1_list *id); +int der_length_asn1_identifier(const ltc_asn1_list *id, unsigned long *idlen); + +int der_encode_asn1_length(unsigned long len, unsigned char* out, unsigned long* outlen); +int der_decode_asn1_length(const unsigned char *in, unsigned long *inlen, unsigned long *outlen); +int der_length_asn1_length(unsigned long len, unsigned long *outlen); + +int der_length_sequence_ex(const ltc_asn1_list *list, unsigned long inlen, + unsigned long *outlen, unsigned long *payloadlen); + +extern const ltc_asn1_type der_asn1_tag_to_type_map[]; +extern const unsigned long der_asn1_tag_to_type_map_sz; + +extern const int der_asn1_type_to_identifier_map[]; +extern const unsigned long der_asn1_type_to_identifier_map_sz; + +int der_decode_sequence_multi_ex(const unsigned char *in, unsigned long inlen, unsigned int flags, ...); + +int der_teletex_char_encode(int c); +int der_teletex_value_decode(int v); + +int der_utf8_valid_char(const wchar_t c); + +typedef int (*public_key_decode_cb)(const unsigned char *in, unsigned long inlen, void *ctx); + +int x509_decode_public_key_from_certificate(const unsigned char *in, unsigned long inlen, + enum ltc_oid_id algorithm, ltc_asn1_type param_type, + ltc_asn1_list* parameters, unsigned long *parameters_len, + public_key_decode_cb callback, void *ctx); + +/* SUBJECT PUBLIC KEY INFO */ +int x509_encode_subject_public_key_info(unsigned char *out, unsigned long *outlen, + unsigned int algorithm, const void* public_key, unsigned long public_key_len, + ltc_asn1_type parameters_type, ltc_asn1_list* parameters, unsigned long parameters_len); + +int x509_decode_subject_public_key_info(const unsigned char *in, unsigned long inlen, + unsigned int algorithm, void* public_key, unsigned long* public_key_len, + ltc_asn1_type parameters_type, ltc_asn1_list* parameters, unsigned long *parameters_len); + +int pk_oid_cmp_with_ulong(const char *o1, const unsigned long *o2, unsigned long o2size); +int pk_oid_cmp_with_asn1(const char *o1, const ltc_asn1_list *o2); + +#endif /* LTC_DER */ + +/* tomcrypt_pkcs.h */ + +#ifdef LTC_PKCS_8 + +int pkcs8_decode_flexi(const unsigned char *in, unsigned long inlen, + const void *pwd, unsigned long pwdlen, + ltc_asn1_list **decoded_list); + +#endif /* LTC_PKCS_8 */ + + +#ifdef LTC_PKCS_12 + +int pkcs12_utf8_to_utf16(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + +int pkcs12_kdf( int hash_id, + const unsigned char *pw, unsigned long pwlen, + const unsigned char *salt, unsigned long saltlen, + unsigned int iterations, unsigned char purpose, + unsigned char *out, unsigned long outlen); + +#endif /* LTC_PKCS_12 */ + +/* tomcrypt_prng.h */ + +#define LTC_PRNG_EXPORT(which) \ +int which ## _export(unsigned char *out, unsigned long *outlen, prng_state *prng) \ +{ \ + unsigned long len = which ## _desc.export_size; \ + \ + LTC_ARGCHK(prng != NULL); \ + LTC_ARGCHK(out != NULL); \ + LTC_ARGCHK(outlen != NULL); \ + \ + if (*outlen < len) { \ + *outlen = len; \ + return CRYPT_BUFFER_OVERFLOW; \ + } \ + \ + if (which ## _read(out, len, prng) != len) { \ + return CRYPT_ERROR_READPRNG; \ + } \ + \ + *outlen = len; \ + return CRYPT_OK; \ +} + +/* extract a byte portably */ +#ifdef _MSC_VER + #define LTC_BYTE(x, n) ((unsigned char)((x) >> (8 * (n)))) +#else + #define LTC_BYTE(x, n) (((x) >> (8 * (n))) & 255) +#endif diff --git a/libtomcrypt/src/headers/tomcrypt_prng.h b/libtomcrypt/src/headers/tomcrypt_prng.h new file mode 100644 index 0000000..b8fa585 --- /dev/null +++ b/libtomcrypt/src/headers/tomcrypt_prng.h @@ -0,0 +1,223 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +/* ---- PRNG Stuff ---- */ +#ifdef LTC_YARROW +struct yarrow_prng { + int cipher, hash; + unsigned char pool[MAXBLOCKSIZE]; + symmetric_CTR ctr; +}; +#endif + +#ifdef LTC_RC4 +struct rc4_prng { + rc4_state s; +}; +#endif + +#ifdef LTC_CHACHA20_PRNG +struct chacha20_prng { + chacha_state s; /* chacha state */ + unsigned char ent[40]; /* entropy buffer */ + unsigned long idx; /* entropy counter */ +}; +#endif + +#ifdef LTC_FORTUNA +struct fortuna_prng { + hash_state pool[LTC_FORTUNA_POOLS]; /* the pools */ + + symmetric_key skey; + + unsigned char K[32], /* the current key */ + IV[16]; /* IV for CTR mode */ + + unsigned long pool_idx, /* current pool we will add to */ + pool0_len; /* length of 0'th pool */ + ulong64 wd; + ulong64 reset_cnt; /* number of times we have reseeded */ +}; +#endif + +#ifdef LTC_SOBER128 +struct sober128_prng { + sober128_state s; /* sober128 state */ + unsigned char ent[40]; /* entropy buffer */ + unsigned long idx; /* entropy counter */ +}; +#endif + +typedef struct { + union { + char dummy[1]; +#ifdef LTC_YARROW + struct yarrow_prng yarrow; +#endif +#ifdef LTC_RC4 + struct rc4_prng rc4; +#endif +#ifdef LTC_CHACHA20_PRNG + struct chacha20_prng chacha; +#endif +#ifdef LTC_FORTUNA + struct fortuna_prng fortuna; +#endif +#ifdef LTC_SOBER128 + struct sober128_prng sober128; +#endif + } u; + short ready; /* ready flag 0-1 */ + LTC_MUTEX_TYPE(lock) /* lock */ +} prng_state; + +/** PRNG descriptor */ +extern struct ltc_prng_descriptor { + /** Name of the PRNG */ + const char *name; + /** size in bytes of exported state */ + int export_size; + /** Start a PRNG state + @param prng [out] The state to initialize + @return CRYPT_OK if successful + */ + int (*start)(prng_state *prng); + /** Add entropy to the PRNG + @param in The entropy + @param inlen Length of the entropy (octets)\ + @param prng The PRNG state + @return CRYPT_OK if successful + */ + int (*add_entropy)(const unsigned char *in, unsigned long inlen, prng_state *prng); + /** Ready a PRNG state to read from + @param prng The PRNG state to ready + @return CRYPT_OK if successful + */ + int (*ready)(prng_state *prng); + /** Read from the PRNG + @param out [out] Where to store the data + @param outlen Length of data desired (octets) + @param prng The PRNG state to read from + @return Number of octets read + */ + unsigned long (*read)(unsigned char *out, unsigned long outlen, prng_state *prng); + /** Terminate a PRNG state + @param prng The PRNG state to terminate + @return CRYPT_OK if successful + */ + int (*done)(prng_state *prng); + /** Export a PRNG state + @param out [out] The destination for the state + @param outlen [in/out] The max size and resulting size of the PRNG state + @param prng The PRNG to export + @return CRYPT_OK if successful + */ + int (*pexport)(unsigned char *out, unsigned long *outlen, prng_state *prng); + /** Import a PRNG state + @param in The data to import + @param inlen The length of the data to import (octets) + @param prng The PRNG to initialize/import + @return CRYPT_OK if successful + */ + int (*pimport)(const unsigned char *in, unsigned long inlen, prng_state *prng); + /** Self-test the PRNG + @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled + */ + int (*test)(void); +} prng_descriptor[]; + +#ifdef LTC_YARROW +int yarrow_start(prng_state *prng); +int yarrow_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int yarrow_ready(prng_state *prng); +unsigned long yarrow_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int yarrow_done(prng_state *prng); +int yarrow_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int yarrow_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int yarrow_test(void); +extern const struct ltc_prng_descriptor yarrow_desc; +#endif + +#ifdef LTC_FORTUNA +int fortuna_start(prng_state *prng); +int fortuna_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int fortuna_add_random_event(unsigned long source, unsigned long pool, const unsigned char *in, unsigned long inlen, prng_state *prng); +int fortuna_ready(prng_state *prng); +unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int fortuna_done(prng_state *prng); +int fortuna_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int fortuna_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int fortuna_update_seed(const unsigned char *in, unsigned long inlen, prng_state *prng); +int fortuna_test(void); +extern const struct ltc_prng_descriptor fortuna_desc; +#endif + +#ifdef LTC_RC4 +int rc4_start(prng_state *prng); +int rc4_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int rc4_ready(prng_state *prng); +unsigned long rc4_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int rc4_done(prng_state *prng); +int rc4_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int rc4_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int rc4_test(void); +extern const struct ltc_prng_descriptor rc4_desc; +#endif + +#ifdef LTC_CHACHA20_PRNG +int chacha20_prng_start(prng_state *prng); +int chacha20_prng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int chacha20_prng_ready(prng_state *prng); +unsigned long chacha20_prng_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int chacha20_prng_done(prng_state *prng); +int chacha20_prng_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int chacha20_prng_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int chacha20_prng_test(void); +extern const struct ltc_prng_descriptor chacha20_prng_desc; +#endif + +#ifdef LTC_SPRNG +int sprng_start(prng_state *prng); +int sprng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int sprng_ready(prng_state *prng); +unsigned long sprng_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int sprng_done(prng_state *prng); +int sprng_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int sprng_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int sprng_test(void); +extern const struct ltc_prng_descriptor sprng_desc; +#endif + +#ifdef LTC_SOBER128 +int sober128_start(prng_state *prng); +int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); +int sober128_ready(prng_state *prng); +unsigned long sober128_read(unsigned char *out, unsigned long outlen, prng_state *prng); +int sober128_done(prng_state *prng); +int sober128_export(unsigned char *out, unsigned long *outlen, prng_state *prng); +int sober128_import(const unsigned char *in, unsigned long inlen, prng_state *prng); +int sober128_test(void); +extern const struct ltc_prng_descriptor sober128_desc; +#endif + +int find_prng(const char *name); +int register_prng(const struct ltc_prng_descriptor *prng); +int unregister_prng(const struct ltc_prng_descriptor *prng); +int register_all_prngs(void); +int prng_is_valid(int idx); +LTC_MUTEX_PROTO(ltc_prng_mutex) + +/* Slow RNG you **might** be able to use to seed a PRNG with. Be careful as this + * might not work on all platforms as planned + */ +unsigned long rng_get_bytes(unsigned char *out, + unsigned long outlen, + void (*callback)(void)); + +int rng_make_prng(int bits, int wprng, prng_state *prng, void (*callback)(void)); + +#ifdef LTC_PRNG_ENABLE_LTC_RNG +extern unsigned long (*ltc_rng)(unsigned char *out, unsigned long outlen, + void (*callback)(void)); +#endif + diff --git a/libtomcrypt/src/misc/compare_testvector.c b/libtomcrypt/src/misc/compare_testvector.c new file mode 100644 index 0000000..bb3c8cb --- /dev/null +++ b/libtomcrypt/src/misc/compare_testvector.c @@ -0,0 +1,81 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#include "tomcrypt_private.h" + +/** + @file compare_testvector.c + Function to compare two testvectors and print a (detailed) error-message if required, Steffen Jaeckel +*/ + +#if defined(LTC_TEST) && defined(LTC_TEST_DBG) +static void s_print_hex(const char* what, const void* v, const unsigned long l) +{ + const unsigned char* p = v; + unsigned long x, y = 0, z; + fprintf(stderr, "%s contents: \n", what); + for (x = 0; x < l; ) { + fprintf(stderr, "%02X ", p[x]); + if (!(++x % 16) || x == l) { + if((x % 16) != 0) { + z = 16 - (x % 16); + if(z >= 8) + fprintf(stderr, " "); + for (; z != 0; --z) { + fprintf(stderr, " "); + } + } + fprintf(stderr, " | "); + for(; y < x; y++) { + if((y % 8) == 0) + fprintf(stderr, " "); + if(isgraph(p[y])) + fprintf(stderr, "%c", p[y]); + else + fprintf(stderr, "."); + } + fprintf(stderr, "\n"); + } + else if((x % 8) == 0) { + fprintf(stderr, " "); + } + } +} +#endif + +/** + Compare two test-vectors + + @param is The data as it is + @param is_len The length of is + @param should The data as it should + @param should_len The length of should + @param what The type of the data + @param which The iteration count + @return 0 on equality, -1 or 1 on difference +*/ +int compare_testvector(const void* is, const unsigned long is_len, const void* should, const unsigned long should_len, const char* what, int which) +{ + int res = 0; + if(is_len != should_len) { + res = is_len > should_len ? -1 : 1; + } else { + res = XMEMCMP(is, should, is_len); + } +#if defined(LTC_TEST) && defined(LTC_TEST_DBG) + if (res != 0) { + fprintf(stderr, "Testvector #%i(0x%x) of %s failed:\n", which, which, what); + s_print_hex("SHOULD", should, should_len); + s_print_hex("IS ", is, is_len); +#if LTC_TEST_DBG > 1 + } else { + fprintf(stderr, "Testvector #%i(0x%x) of %s passed!\n", which, which, what); +#endif + } +#else + LTC_UNUSED_PARAM(which); + LTC_UNUSED_PARAM(what); +#endif + + return res; +} diff --git a/libtomcrypt/src/misc/crypt/crypt_argchk.c b/libtomcrypt/src/misc/crypt/crypt_argchk.c new file mode 100644 index 0000000..85b562a --- /dev/null +++ b/libtomcrypt/src/misc/crypt/crypt_argchk.c @@ -0,0 +1,17 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ +#include "tomcrypt_private.h" + +/** + @file crypt_argchk.c + Perform argument checking, Tom St Denis +*/ + +#if (ARGTYPE == 0) +void crypt_argchk(const char *v, const char *s, int d) +{ + fprintf(stderr, "LTC_ARGCHK '%s' failure on line %d of file %s\n", + v, d, s); + abort(); +} +#endif diff --git a/libtomcrypt/src/misc/zeromem.c b/libtomcrypt/src/misc/zeromem.c new file mode 100644 index 0000000..7d14994 --- /dev/null +++ b/libtomcrypt/src/misc/zeromem.c @@ -0,0 +1,22 @@ +/* LibTomCrypt, modular cryptographic library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ +#include "tomcrypt_private.h" + +/** + @file zeromem.c + Zero a block of memory, Tom St Denis +*/ + +/** + Zero a block of memory + @param out The destination of the area to zero + @param outlen The length of the area to zero (octets) +*/ +void zeromem(volatile void *out, size_t outlen) +{ + volatile char *mem = out; + LTC_ARGCHKVD(out != NULL); + while (outlen-- > 0) { + *mem++ = '\0'; + } +} diff --git a/ppport.h b/ppport.h new file mode 100644 index 0000000..01493c8 --- /dev/null +++ b/ppport.h @@ -0,0 +1,18463 @@ +#if 0 +my $void = <<'SKIP'; +#endif +/* +---------------------------------------------------------------------- + + ppport.h -- Perl/Pollution/Portability Version 3.68 + + Automatically created by Devel::PPPort running under perl 5.028000. + + Do NOT edit this file directly! -- Edit PPPort_pm.PL and the + includes in parts/inc/ instead. + + Use 'perldoc ppport.h' to view the documentation below. + +---------------------------------------------------------------------- + +SKIP + +=pod + +=head1 NAME + +ppport.h - Perl/Pollution/Portability version 3.68 + +=head1 SYNOPSIS + + perl ppport.h [options] [source files] + + Searches current directory for files if no [source files] are given + + --help show short help + + --version show version + + --patch=file write one patch file with changes + --copy=suffix write changed copies with suffix + --diff=program use diff program and options + + --compat-version=version provide compatibility with Perl version + --cplusplus accept C++ comments + + --quiet don't output anything except fatal errors + --nodiag don't show diagnostics + --nohints don't show hints + --nochanges don't suggest changes + --nofilter don't filter input files + + --strip strip all script and doc functionality + from ppport.h + + --list-provided list provided API + --list-unsupported list API that isn't supported all the way + back + --api-info=name show Perl API portability information + +=head1 COMPATIBILITY + +This version of F is designed to support operation with Perl +installations back to 5.003_07, and has been tested up to 5.35.9. + +=head1 OPTIONS + +=head2 --help + +Display a brief usage summary. + +=head2 --version + +Display the version of F. + +=head2 --patch=I + +If this option is given, a single patch file will be created if +any changes are suggested. This requires a working diff program +to be installed on your system. + +=head2 --copy=I + +If this option is given, a copy of each file will be saved with +the given suffix that contains the suggested changes. This does +not require any external programs. Note that this does not +automagically add a dot between the original filename and the +suffix. If you want the dot, you have to include it in the option +argument. + +If neither C<--patch> or C<--copy> are given, the default is to +simply print the diffs for each file. This requires either +C or a C program to be installed. + +=head2 --diff=I + +Manually set the diff program and options to use. The default +is to use C, when installed, and output unified +context diffs. + +=head2 --compat-version=I + +Tell F to check for compatibility with the given +Perl version. The default is to check for compatibility with Perl +version 5.003_07. You can use this option to reduce the output +of F if you intend to be backward compatible only +down to a certain Perl version. + +=head2 --cplusplus + +Usually, F will detect C++ style comments and +replace them with C style comments for portability reasons. +Using this option instructs F to leave C++ +comments untouched. + +=head2 --quiet + +Be quiet. Don't print anything except fatal errors. + +=head2 --nodiag + +Don't output any diagnostic messages. Only portability +alerts will be printed. + +=head2 --nohints + +Don't output any hints. Hints often contain useful portability +notes. Warnings will still be displayed. + +=head2 --nochanges + +Don't suggest any changes. Only give diagnostic output and hints +unless these are also deactivated. + +=head2 --nofilter + +Don't filter the list of input files. By default, files not looking +like source code (i.e. not *.xs, *.c, *.cc, *.cpp or *.h) are skipped. + +=head2 --strip + +Strip all script and documentation functionality from F. +This reduces the size of F dramatically and may be useful +if you want to include F in smaller modules without +increasing their distribution size too much. + +The stripped F will have a C<--unstrip> option that allows +you to undo the stripping, but only if an appropriate C +module is installed. + +=head2 --list-provided + +Lists the API elements for which compatibility is provided by +F. Also lists if it must be explicitly requested, +if it has dependencies, and if there are hints or warnings for it. + +=head2 --list-unsupported + +Lists the API elements that are known not to be FULLY supported by F, +and below which version of Perl they probably won't be available or work. +By FULLY, we mean that support isn't provided all the way back to the first +version of Perl that F supports at all. + +=head2 --api-info=I + +Show portability information for elements matching I. +If I is surrounded by slashes, it is interpreted as a regular +expression. + +Normally, only API elements are shown, but if there are no matching API +elements but there are some other matching elements, those are shown. This +allows you to conveniently find when functions internal to the core +implementation were added; only people working on the core are likely to find +this last part useful. + +=head1 DESCRIPTION + +In order for a Perl extension (XS) module to be as portable as possible +across differing versions of Perl itself, certain steps need to be taken. + +=over 4 + +=item * + +Including this header is the first major one. This alone will give you +access to a large part of the Perl API that hasn't been available in +earlier Perl releases. Use + + perl ppport.h --list-provided + +to see which API elements are provided by ppport.h. + +=item * + +You should avoid using deprecated parts of the API. For example, using +global Perl variables without the C prefix is deprecated. Also, +some API functions used to have a C prefix. Using this form is +also deprecated. You can safely use the supported API, as F +will provide wrappers for older Perl versions. + +=item * + +Although the purpose of F is to keep you from having to concern +yourself with what version you are running under, there may arise instances +where you have to do so. These macros, the same ones as in base Perl, are +available to you in all versions, and are what you should use: + +=over 4 + +=item C(major, minor, patch)> + +Returns whether or not the perl currently being compiled has the specified +relationship I to the perl given by the parameters. I is one of +C, C, C, C, C, C. + +For example, + + #if PERL_VERSION_GT(5,24,2) + code that will only be compiled on perls after v5.24.2 + #else + fallback code + #endif + +Note that this is usable in making compile-time decisions + +You may use the special value '*' for the final number to mean ALL possible +values for it. Thus, + + #if PERL_VERSION_EQ(5,31,'*') + +means all perls in the 5.31 series. And + + #if PERL_VERSION_NE(5,24,'*') + +means all perls EXCEPT 5.24 ones. And + + #if PERL_VERSION_LE(5,9,'*') + +is effectively + + #if PERL_VERSION_LT(5,10,0) + +=back + +=item * + +If you use one of a few functions or variables that were not present in +earlier versions of Perl, and that can't be provided using a macro, you +have to explicitly request support for these functions by adding one or +more C<#define>s in your source code before the inclusion of F. + +These functions or variables will be marked C in the list shown +by C<--list-provided>. + +Depending on whether you module has a single or multiple files that +use such functions or variables, you want either C or global +variants. + +For a C function or variable (used only in a single source +file), use: + + #define NEED_function + #define NEED_variable + +For a global function or variable (used in multiple source files), +use: + + #define NEED_function_GLOBAL + #define NEED_variable_GLOBAL + +Note that you mustn't have more than one global request for the +same function or variable in your project. + + Function / Variable Static Request Global Request + ----------------------------------------------------------------------------------------- + caller_cx() NEED_caller_cx NEED_caller_cx_GLOBAL + ck_warner() NEED_ck_warner NEED_ck_warner_GLOBAL + ck_warner_d() NEED_ck_warner_d NEED_ck_warner_d_GLOBAL + croak_xs_usage() NEED_croak_xs_usage NEED_croak_xs_usage_GLOBAL + die_sv() NEED_die_sv NEED_die_sv_GLOBAL + eval_pv() NEED_eval_pv NEED_eval_pv_GLOBAL + grok_bin() NEED_grok_bin NEED_grok_bin_GLOBAL + grok_hex() NEED_grok_hex NEED_grok_hex_GLOBAL + grok_number() NEED_grok_number NEED_grok_number_GLOBAL + grok_numeric_radix() NEED_grok_numeric_radix NEED_grok_numeric_radix_GLOBAL + grok_oct() NEED_grok_oct NEED_grok_oct_GLOBAL + load_module() NEED_load_module NEED_load_module_GLOBAL + mess() NEED_mess NEED_mess_GLOBAL + mess_nocontext() NEED_mess_nocontext NEED_mess_nocontext_GLOBAL + mess_sv() NEED_mess_sv NEED_mess_sv_GLOBAL + mg_findext() NEED_mg_findext NEED_mg_findext_GLOBAL + my_snprintf() NEED_my_snprintf NEED_my_snprintf_GLOBAL + my_sprintf() NEED_my_sprintf NEED_my_sprintf_GLOBAL + my_strlcat() NEED_my_strlcat NEED_my_strlcat_GLOBAL + my_strlcpy() NEED_my_strlcpy NEED_my_strlcpy_GLOBAL + my_strnlen() NEED_my_strnlen NEED_my_strnlen_GLOBAL + newCONSTSUB() NEED_newCONSTSUB NEED_newCONSTSUB_GLOBAL + newSVpvn_share() NEED_newSVpvn_share NEED_newSVpvn_share_GLOBAL + PL_parser NEED_PL_parser NEED_PL_parser_GLOBAL + PL_signals NEED_PL_signals NEED_PL_signals_GLOBAL + pv_display() NEED_pv_display NEED_pv_display_GLOBAL + pv_escape() NEED_pv_escape NEED_pv_escape_GLOBAL + pv_pretty() NEED_pv_pretty NEED_pv_pretty_GLOBAL + sv_catpvf_mg() NEED_sv_catpvf_mg NEED_sv_catpvf_mg_GLOBAL + sv_catpvf_mg_nocontext() NEED_sv_catpvf_mg_nocontext NEED_sv_catpvf_mg_nocontext_GLOBAL + sv_setpvf_mg() NEED_sv_setpvf_mg NEED_sv_setpvf_mg_GLOBAL + sv_setpvf_mg_nocontext() NEED_sv_setpvf_mg_nocontext NEED_sv_setpvf_mg_nocontext_GLOBAL + sv_unmagicext() NEED_sv_unmagicext NEED_sv_unmagicext_GLOBAL + utf8_to_uvchr_buf() NEED_utf8_to_uvchr_buf NEED_utf8_to_uvchr_buf_GLOBAL + vload_module() NEED_vload_module NEED_vload_module_GLOBAL + vmess() NEED_vmess NEED_vmess_GLOBAL + warner() NEED_warner NEED_warner_GLOBAL + +To avoid namespace conflicts, you can change the namespace of the +explicitly exported functions / variables using the C +macro. Just C<#define> the macro before including C: + + #define DPPP_NAMESPACE MyOwnNamespace_ + #include "ppport.h" + +The default namespace is C. + +=back + +The good thing is that most of the above can be checked by running +F on your source code. See the next section for +details. + +=head1 EXAMPLES + +To verify whether F is needed for your module, whether you +should make any changes to your code, and whether any special defines +should be used, F can be run as a Perl script to check your +source code. Simply say: + + perl ppport.h + +The result will usually be a list of patches suggesting changes +that should at least be acceptable, if not necessarily the most +efficient solution, or a fix for all possible problems. + +If you know that your XS module uses features only available in +newer Perl releases, if you're aware that it uses C++ comments, +and if you want all suggestions as a single patch file, you could +use something like this: + + perl ppport.h --compat-version=5.6.0 --cplusplus --patch=test.diff + +If you only want your code to be scanned without any suggestions +for changes, use: + + perl ppport.h --nochanges + +You can specify a different C program or options, using +the C<--diff> option: + + perl ppport.h --diff='diff -C 10' + +This would output context diffs with 10 lines of context. + +If you want to create patched copies of your files instead, use: + + perl ppport.h --copy=.new + +To display portability information for the C function, +use: + + perl ppport.h --api-info=newSVpvn + +Since the argument to C<--api-info> can be a regular expression, +you can use + + perl ppport.h --api-info=/_nomg$/ + +to display portability information for all C<_nomg> functions or + + perl ppport.h --api-info=/./ + +to display information for all known API elements. + +=head1 BUGS + +Some of the suggested edits and/or generated patches may not compile as-is +without tweaking manually. This is generally due to the need for an extra +parameter to be added to the call to prevent buffer overflow. + +If this version of F is causing failure during +the compilation of this module, please check if newer versions +of either this module or C are available on CPAN +before sending a bug report. + +If F was generated using the latest version of +C and is causing failure of this module, please +file a bug report at L + +Please include the following information: + +=over 4 + +=item 1. + +The complete output from running "perl -V" + +=item 2. + +This file. + +=item 3. + +The name and version of the module you were trying to build. + +=item 4. + +A full log of the build that failed. + +=item 5. + +Any other information that you think could be relevant. + +=back + +For the latest version of this code, please get the C +module from CPAN. + +=head1 COPYRIGHT + +Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz. + +Version 2.x, Copyright (C) 2001, Paul Marquess. + +Version 1.x, Copyright (C) 1999, Kenneth Albanowski. + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=head1 SEE ALSO + +See L. + +=cut + +# These are tools that must be included in ppport.h. It doesn't work if given +# a .pl suffix. +# +# WARNING: Use only constructs that are legal as far back as D:P handles, as +# this is run in the perl version being tested. + +# What revisions are legal, to be output as-is and converted into a pattern +# that matches them precisely +my $r_pat = "[57]"; + +sub format_version +{ + # Given an input version that is acceptable to parse_version(), return a + # string of the standard representation of it. + + my($r,$v,$s) = parse_version(shift); + + if ($r < 5 || ($r == 5 && $v < 6)) { + my $ver = sprintf "%d.%03d", $r, $v; + $s > 0 and $ver .= sprintf "_%02d", $s; + + return $ver; + } + + return sprintf "%d.%d.%d", $r, $v, $s; +} + +sub parse_version +{ + # Returns a triplet, (revision, major, minor) from the input, treated as a + # string, which can be in any of several typical formats. + + my $ver = shift; + $ver = "" unless defined $ver; + + my($r,$v,$s); + + if ( ($r, $v, $s) = $ver =~ /^([0-9]+)([0-9]{3})([0-9]{3})$/ # 5029010, from the file + # names in our + # parts/base/ and + # parts/todo directories + or ($r, $v, $s) = $ver =~ /^([0-9]+)\.([0-9]+)\.([0-9]+)$/ # 5.25.7 + or ($r, $v, $s) = $ver =~ /^([0-9]+)\.([0-9]{3})([0-9]{3})$/ # 5.025008, from the + # output of $] + or ($r, $v, $s) = $ver =~ /^([0-9]+)\.([0-9]{1,3})()$/ # 5.24, 5.004 + or ($r, $v, $s) = $ver =~ /^([0-9]+)\.(00[1-5])_?([0-9]{2})$/ # 5.003_07 + ) { + + $s = 0 unless $s; + + die "Only Perl $r_pat are supported '$ver'\n" unless $r =~ / ^ $r_pat $ /x; + die "Invalid version number: $ver\n" if $v >= 1000 || $s >= 1000; + return (0 +$r, 0 + $v, 0 + $s); + } + + # For some safety, don't assume something is a version number if it has a + # literal dot as one of the three characters. This will have to be fixed + # when we reach x.46 (since 46 is ord('.')) + if ($ver !~ /\./ && (($r, $v, $s) = $ver =~ /^(.)(.)(.)$/)) # vstring 5.25.7 + { + $r = ord $r; + $v = ord $v; + $s = ord $s; + + die "Only Perl $r_pat are supported '$ver'\n" unless $r =~ / ^ $r_pat $ /x; + return ($r, $v, $s); + } + + my $mesg = ""; + $mesg = ". (In 5.00x_yz, x must be 1-5.)" if $ver =~ /_/; + die "Invalid version number format: '$ver'$mesg\n"; +} + +sub int_parse_version +{ + # Returns integer 7 digit human-readable version, suitable for use in file + # names in parts/todo parts/base. + + return 0 + join "", map { sprintf("%03d", $_) } parse_version(shift); +} + +sub ivers # Shorter name for int_parse_version +{ + return int_parse_version(shift); +} + +sub format_version_line +{ + # Returns a floating point representation of the input version + + my $version = int_parse_version(shift); + $version =~ s/ ^ ( $r_pat ) \B /$1./x; + return $version; +} + +BEGIN { + if ("$]" < "5.006" ) { + # On early perls, the implicit pass by reference doesn't work, so we have + # to use the globals to initialize. + eval q[sub dictionary_order($$) { _dictionary_order($a, $b) } ]; + } elsif ("$]" < "5.022" ) { + eval q[sub dictionary_order($$) { _dictionary_order(@_) } ]; + } else { + eval q[sub dictionary_order :prototype($$) { _dictionary_order(@_) } ]; + } +} + +sub _dictionary_order { # Sort caselessly, ignoring punct + my ($valid_a, $valid_b) = @_; + + my ($lc_a, $lc_b); + my ($squeezed_a, $squeezed_b); + + $valid_a = '' unless defined $valid_a; + $valid_b = '' unless defined $valid_b; + + $lc_a = lc $valid_a; + $lc_b = lc $valid_b; + + $squeezed_a = $lc_a; + $squeezed_a =~ s/^_+//g; # No leading underscores + $squeezed_a =~ s/\B_+\B//g; # No connecting underscores + $squeezed_a =~ s/[\W]//g; # No punct + + $squeezed_b = $lc_b; + $squeezed_b =~ s/^_+//g; + $squeezed_b =~ s/\B_+\B//g; + $squeezed_b =~ s/[\W]//g; + + return( $squeezed_a cmp $squeezed_b + or $lc_a cmp $lc_b + or $valid_a cmp $valid_b); +} + +sub sort_api_lines # Sort lines of the form flags|return|name|args... + # by 'name' +{ + $a =~ / ^ [^|]* \| [^|]* \| ( [^|]* ) /x; # 3rd field '|' is sep + my $a_name = $1; + $b =~ / ^ [^|]* \| [^|]* \| ( [^|]* ) /x; + my $b_name = $1; + return dictionary_order($a_name, $b_name); +} + +1; + +use strict; + +BEGIN { require warnings if "$]" > '5.006' } + +# Disable broken TRIE-optimization +BEGIN { eval '${^RE_TRIE_MAXBUF} = -1' if "$]" >= "5.009004" && "$]" <= "5.009005"} + +my $VERSION = 3.68; + +my %opt = ( + quiet => 0, + diag => 1, + hints => 1, + changes => 1, + cplusplus => 0, + filter => 1, + strip => 0, + version => 0, +); + +my($ppport) = $0 =~ /([\w.]+)$/; +my $LF = '(?:\r\n|[\r\n])'; # line feed +my $HS = "[ \t]"; # horizontal whitespace + +# Never use C comments in this file! +my $ccs = '/'.'*'; +my $cce = '*'.'/'; +my $rccs = quotemeta $ccs; +my $rcce = quotemeta $cce; + +eval { + require Getopt::Long; + Getopt::Long::GetOptions(\%opt, qw( + help quiet diag! filter! hints! changes! cplusplus strip version + patch=s copy=s diff=s compat-version=s + list-provided list-unsupported api-info=s + )) or usage(); +}; + +if ($@ and grep /^-/, @ARGV) { + usage() if "@ARGV" =~ /^--?h(?:elp)?$/; + die "Getopt::Long not found. Please don't use any options.\n"; +} + +if ($opt{version}) { + print "This is $0 $VERSION.\n"; + exit 0; +} + +usage() if $opt{help}; +strip() if $opt{strip}; + +$opt{'compat-version'} = 5.003_07 unless exists $opt{'compat-version'}; +$opt{'compat-version'} = int_parse_version($opt{'compat-version'}); + +my $int_min_perl = int_parse_version(5.003_07); + +# Each element of this hash looks something like: +# 'Poison' => { +# 'base' => '5.008000', +# 'provided' => 1, +# 'todo' => '5.003007' +# }, +my %API = map { /^(\w+)\|([^|]*)\|([^|]*)\|(\w*)$/ + ? ( $1 => { + ($2 ? ( base => $2 ) : ()), + ($3 ? ( todo => $3 ) : ()), + (index($4, 'v') >= 0 ? ( varargs => 1 ) : ()), + (index($4, 'p') >= 0 ? ( provided => 1 ) : ()), + (index($4, 'n') >= 0 ? ( noTHXarg => 1 ) : ()), + (index($4, 'c') >= 0 ? ( core_only => 1 ) : ()), + (index($4, 'd') >= 0 ? ( deprecated => 1 ) : ()), + (index($4, 'i') >= 0 ? ( inaccessible => 1 ) : ()), + (index($4, 'x') >= 0 ? ( experimental => 1 ) : ()), + (index($4, 'u') >= 0 ? ( undocumented => 1 ) : ()), + (index($4, 'o') >= 0 ? ( ppport_fnc => 1 ) : ()), + (index($4, 'V') >= 0 ? ( unverified => 1 ) : ()), + } ) + : die "invalid spec: $_" } qw( +ABDAY_1|5.027010||Viu +ABDAY_2|5.027010||Viu +ABDAY_3|5.027010||Viu +ABDAY_4|5.027010||Viu +ABDAY_5|5.027010||Viu +ABDAY_6|5.027010||Viu +ABDAY_7|5.027010||Viu +ABMON_10|5.027010||Viu +ABMON_11|5.027010||Viu +ABMON_12|5.027010||Viu +ABMON_1|5.027010||Viu +ABMON_2|5.027010||Viu +ABMON_3|5.027010||Viu +ABMON_4|5.027010||Viu +ABMON_5|5.027010||Viu +ABMON_6|5.027010||Viu +ABMON_7|5.027010||Viu +ABMON_8|5.027010||Viu +ABMON_9|5.027010||Viu +ABORT|5.003007||Viu +abort|5.005000||Viu +abort_execution|5.025010||Viu +accept|5.005000||Viu +ACCEPT|5.009005||Viu +ACCEPT_t8|5.035004||Viu +ACCEPT_t8_p8|5.033003||Viu +ACCEPT_t8_pb|5.033003||Viu +ACCEPT_tb|5.035004||Viu +ACCEPT_tb_p8|5.033003||Viu +ACCEPT_tb_pb|5.033003||Viu +access|5.005000||Viu +add_above_Latin1_folds|5.021001||Viu +add_cp_to_invlist|5.013011||Viu +add_data|5.005000||Vniu +add_multi_match|5.021004||Viu +_add_range_to_invlist|5.016000||cViu +add_utf16_textfilter|5.011001||Viu +adjust_size_and_find_bucket|5.019003||Vniu +advance_one_LB|5.023007||Viu +advance_one_SB|5.021009||Viu +advance_one_WB|5.021009||Viu +AHOCORASICK|5.009005||Viu +AHOCORASICKC|5.009005||Viu +AHOCORASICKC_t8|5.035004||Viu +AHOCORASICKC_t8_p8|5.033003||Viu +AHOCORASICKC_t8_pb|5.033003||Viu +AHOCORASICKC_tb|5.035004||Viu +AHOCORASICKC_tb_p8|5.033003||Viu +AHOCORASICKC_tb_pb|5.033003||Viu +AHOCORASICK_t8|5.035004||Viu +AHOCORASICK_t8_p8|5.033003||Viu +AHOCORASICK_t8_pb|5.033003||Viu +AHOCORASICK_tb|5.035004||Viu +AHOCORASICK_tb_p8|5.033003||Viu +AHOCORASICK_tb_pb|5.033003||Viu +ALIGNED_TYPE_NAME|||Viu +ALIGNED_TYPE|||Viu +alloccopstash|5.017001|5.017001|x +alloc_LOGOP|5.025004||xViu +allocmy|5.008001||Viu +ALLOC_THREAD_KEY|5.005003||Viu +ALT_DIGITS|5.027010||Viu +amagic_call|5.003007|5.003007|u +amagic_cmp|5.009003||Viu +amagic_cmp_desc|5.031011||Viu +amagic_cmp_locale|5.009003||Viu +amagic_cmp_locale_desc|5.031011||Viu +amagic_deref_call|5.013007|5.013007|u +amagic_i_ncmp|5.009003||Viu +amagic_i_ncmp_desc|5.031011||Viu +amagic_is_enabled|5.015008||Viu +amagic_ncmp|5.009003||Viu +amagic_ncmp_desc|5.031011||Viu +AMG_CALLun|5.003007||Viu +AMG_CALLunary|5.013009||Viu +AMGfallNEVER|5.003007||Viu +AMGfallNO|5.003007||Viu +AMGfallYES|5.003007||Viu +AMGf_assign|5.003007||Viu +AMGf_noleft|5.003007||Viu +AMGf_noright|5.003007||Viu +AMGf_numarg|5.021009||Viu +AMGf_numeric|5.013002||Viu +AMGf_unary|5.003007||Viu +AMGf_want_list|5.017002||Viu +AM_STR|5.027010||Viu +AMT_AMAGIC|5.004000||Viu +AMT_AMAGIC_off|5.004000||Viu +AMT_AMAGIC_on|5.004000||Viu +AMTf_AMAGIC|5.004000||Viu +_aMY_CXT|5.009000|5.009000|p +aMY_CXT|5.009000|5.009000|p +aMY_CXT_|5.009000|5.009000|p +anchored_end_shift|5.009005||Viu +anchored_offset|5.005000||Viu +anchored_substr|5.005000||Viu +anchored_utf8|5.008000||Viu +ANGSTROM_SIGN|5.017003||Viu +anonymise_cv_maybe|5.013003||Viu +any_dup|5.006000||Vu +ANYOF|5.003007||Viu +ANYOF_ALNUM|5.006000||Viu +ANYOF_ALNUML|5.004000||Viu +ANYOF_ALPHA|5.006000||Viu +ANYOF_ALPHANUMERIC|5.017008||Viu +ANYOF_ASCII|5.006000||Viu +ANYOF_BIT|5.004005||Viu +ANYOF_BITMAP|5.006000||Viu +ANYOF_BITMAP_BYTE|5.006000||Viu +ANYOF_BITMAP_CLEAR|5.006000||Viu +ANYOF_BITMAP_CLEARALL|5.007003||Viu +ANYOF_BITMAP_SET|5.006000||Viu +ANYOF_BITMAP_SETALL|5.007003||Viu +ANYOF_BITMAP_SIZE|5.006000||Viu +ANYOF_BITMAP_TEST|5.006000||Viu +ANYOF_BITMAP_ZERO|5.006000||Viu +ANYOF_BLANK|5.006001||Viu +ANYOF_CASED|5.017008||Viu +ANYOF_CLASS_OR|5.017007||Viu +ANYOF_CLASS_SETALL|5.013011||Viu +ANYOF_CLASS_TEST_ANY_SET|5.013008||Viu +ANYOF_CNTRL|5.006000||Viu +ANYOF_COMMON_FLAGS|5.019008||Viu +ANYOFD|5.023003||Viu +ANYOF_DIGIT|5.006000||Viu +ANYOFD_t8|5.035004||Viu +ANYOFD_t8_p8|5.033003||Viu +ANYOFD_t8_pb|5.033003||Viu +ANYOFD_tb|5.035004||Viu +ANYOFD_tb_p8|5.033003||Viu +ANYOFD_tb_pb|5.033003||Viu +ANYOF_FLAGS|5.006000||Viu +ANYOF_FLAGS_ALL|5.006000||Viu +ANYOF_GRAPH|5.006000||Viu +ANYOFH|5.029007||Viu +ANYOFHb|5.031001||Viu +ANYOFHb_t8|5.035004||Viu +ANYOFHb_t8_p8|5.033003||Viu +ANYOFHb_t8_pb|5.033003||Viu +ANYOFHb_tb|5.035004||Viu +ANYOFHb_tb_p8|5.033003||Viu +ANYOFHb_tb_pb|5.033003||Viu +ANYOF_HORIZWS|5.009005||Viu +ANYOFHr|5.031002||Viu +ANYOFHr_t8|5.035004||Viu +ANYOFHr_t8_p8|5.033003||Viu +ANYOFHr_t8_pb|5.033003||Viu +ANYOFHr_tb|5.035004||Viu +ANYOFHr_tb_p8|5.033003||Viu +ANYOFHr_tb_pb|5.033003||Viu +ANYOFHs|5.031007||Viu +ANYOFHs_t8|5.035004||Viu +ANYOFHs_t8_p8|5.033003||Viu +ANYOFHs_t8_pb|5.033003||Viu +ANYOFHs_tb|5.035004||Viu +ANYOFHs_tb_p8|5.033003||Viu +ANYOFHs_tb_pb|5.033003||Viu +ANYOFH_t8|5.035004||Viu +ANYOFH_t8_p8|5.033003||Viu +ANYOFH_t8_pb|5.033003||Viu +ANYOFH_tb|5.035004||Viu +ANYOFH_tb_p8|5.033003||Viu +ANYOFH_tb_pb|5.033003||Viu +ANYOF_INVERT|5.004000||Viu +ANYOFL|5.021008||Viu +ANYOFL_FOLD|5.023007||Viu +ANYOF_LOCALE_FLAGS|5.019005||Viu +ANYOF_LOWER|5.006000||Viu +ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD|5.023007||Viu +ANYOFL_SOME_FOLDS_ONLY_IN_UTF8_LOCALE|5.023007||Viu +ANYOFL_t8|5.035004||Viu +ANYOFL_t8_p8|5.033003||Viu +ANYOFL_t8_pb|5.033003||Viu +ANYOFL_tb|5.035004||Viu +ANYOFL_tb_p8|5.033003||Viu +ANYOFL_tb_pb|5.033003||Viu +ANYOFL_UTF8_LOCALE_REQD|5.023007||Viu +ANYOFM|5.027009||Viu +ANYOF_MATCHES_ALL_ABOVE_BITMAP|5.021004||Viu +ANYOF_MATCHES_POSIXL|5.021004||Viu +ANYOF_MAX|5.006000||Viu +ANYOFM_t8|5.035004||Viu +ANYOFM_t8_p8|5.033003||Viu +ANYOFM_t8_pb|5.033003||Viu +ANYOFM_tb|5.035004||Viu +ANYOFM_tb_p8|5.033003||Viu +ANYOFM_tb_pb|5.033003||Viu +ANYOF_NALNUM|5.006000||Viu +ANYOF_NALNUML|5.004000||Viu +ANYOF_NALPHA|5.006000||Viu +ANYOF_NALPHANUMERIC|5.017008||Viu +ANYOF_NASCII|5.006000||Viu +ANYOF_NBLANK|5.006001||Viu +ANYOF_NCASED|5.017008||Viu +ANYOF_NCNTRL|5.006000||Viu +ANYOF_NDIGIT|5.006000||Viu +ANYOF_NGRAPH|5.006000||Viu +ANYOF_NHORIZWS|5.009005||Viu +ANYOF_NLOWER|5.006000||Viu +ANYOF_NPRINT|5.006000||Viu +ANYOF_NPUNCT|5.006000||Viu +ANYOF_NSPACE|5.006000||Viu +ANYOF_NSPACEL|5.004000||Viu +ANYOF_NUPPER|5.006000||Viu +ANYOF_NVERTWS|5.009005||Viu +ANYOF_NWORDCHAR|5.017005||Viu +ANYOF_NXDIGIT|5.006000||Viu +ANYOF_ONLY_HAS_BITMAP|5.021004||Viu +ANYOFPOSIXL|5.029004||Viu +ANYOF_POSIXL_AND|5.019005||Viu +ANYOF_POSIXL_BITMAP|5.035003||Viu +ANYOF_POSIXL_CLEAR|5.019005||Viu +ANYOF_POSIXL_MAX|5.019005||Viu +ANYOF_POSIXL_OR|5.019005||Viu +ANYOF_POSIXL_SET|5.019005||Viu +ANYOF_POSIXL_SETALL|5.019005||Viu +ANYOF_POSIXL_SET_TO_BITMAP|5.029004||Viu +ANYOF_POSIXL_SSC_TEST_ALL_SET|5.019009||Viu +ANYOF_POSIXL_SSC_TEST_ANY_SET|5.019009||Viu +ANYOFPOSIXL_t8|5.035004||Viu +ANYOFPOSIXL_t8_p8|5.033003||Viu +ANYOFPOSIXL_t8_pb|5.033003||Viu +ANYOFPOSIXL_tb|5.035004||Viu +ANYOFPOSIXL_tb_p8|5.033003||Viu +ANYOFPOSIXL_tb_pb|5.033003||Viu +ANYOF_POSIXL_TEST|5.019005||Viu +ANYOF_POSIXL_TEST_ALL_SET|5.019005||Viu +ANYOF_POSIXL_TEST_ANY_SET|5.019005||Viu +ANYOF_POSIXL_ZERO|5.019005||Viu +ANYOF_PRINT|5.006000||Viu +ANYOF_PUNCT|5.006000||Viu +ANYOFR|5.031007||Viu +ANYOFRb|5.031007||Viu +ANYOFRbase|5.031007||Viu +ANYOFR_BASE_BITS|5.031007||Viu +ANYOFRb_t8|5.035004||Viu +ANYOFRb_t8_p8|5.033003||Viu +ANYOFRb_t8_pb|5.033003||Viu +ANYOFRb_tb|5.035004||Viu +ANYOFRb_tb_p8|5.033003||Viu +ANYOFRb_tb_pb|5.033003||Viu +ANYOFRdelta|5.031007||Viu +ANYOFR_t8|5.035004||Viu +ANYOFR_t8_p8|5.033003||Viu +ANYOFR_t8_pb|5.033003||Viu +ANYOFR_tb|5.035004||Viu +ANYOFR_tb_p8|5.033003||Viu +ANYOFR_tb_pb|5.033003||Viu +ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER|5.023003||Viu +ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP|5.023006||Viu +ANYOF_SPACE|5.006000||Viu +ANYOF_SPACEL|5.004000||Viu +ANYOF_t8|5.035004||Viu +ANYOF_t8_p8|5.033003||Viu +ANYOF_t8_pb|5.033003||Viu +ANYOF_tb|5.035004||Viu +ANYOF_tb_p8|5.033003||Viu +ANYOF_tb_pb|5.033003||Viu +ANYOF_UNIPROP|5.017006||Viu +ANYOF_UPPER|5.006000||Viu +ANYOF_VERTWS|5.009005||Viu +ANYOF_WORDCHAR|5.017005||Viu +ANYOF_XDIGIT|5.006000||Viu +ao|5.005000||Viu +_append_range_to_invlist|5.013010||Viu +append_utf8_from_native_byte|5.019004||cVniu +apply|5.003007||Viu +apply_attrs|5.006000||Viu +apply_attrs_my|5.007003||Viu +apply_attrs_string|5.006001|5.006001|xu +ARCHLIB|5.003007|5.003007|Vn +ARCHLIB_EXP|5.003007|5.003007|Vn +ARCHNAME|5.004000|5.004000|Vn +ARG1|5.003007||Viu +ARG1_LOC|5.005000||Viu +ARG1_SET|5.005000||Viu +ARG2|5.003007||Viu +ARG2L|5.009005||Viu +ARG2L_LOC|5.009005||Viu +ARG2_LOC|5.005000||Viu +ARG2L_SET|5.009005||Viu +ARG2_SET|5.005000||Viu +ARG|5.005000||Viu +ARG_LOC|5.005000||Viu +ARGp|5.031010||Viu +ARGp_LOC|5.031010||Viu +ARGp_SET|5.031010||Viu +ARG__SET|5.005000||Viu +ARG_SET|5.005000||Viu +ARGTARG|5.003007||Viu +ARG_VALUE|5.005000||Viu +argvout_final|5.029006||Viu +ASCIIish|5.005003||Viu +ASCII_MORE_RESTRICT_PAT_MODS|5.013010||Viu +ASCII_PLATFORM_UTF8_MAXBYTES|5.035004||Viu +ASCII_RESTRICT_PAT_MOD|5.013009||Viu +ASCII_RESTRICT_PAT_MODS|5.013009||Viu +ASCII_TO_NATIVE|5.007001||Viu +ASCII_TO_NEED|5.019004||dcVnu +asctime|5.009000||Viu +ASCTIME_R_PROTO|5.008000|5.008000|Vn +assert|5.003007||Viu +__ASSERT_|5.019007|5.008008|p +ASSERT_CURPAD_ACTIVE|5.008001||Viu +ASSERT_CURPAD_LEGAL|5.008001||Viu +ASSERT_IS_LITERAL|||Viu +ASSERT_IS_PTR|||Viu +assert_not_glob|5.009004||Viu +ASSERT_NOT_PTR|5.035004||Viu +assert_not_ROK|5.008001||Viu +assert_uft8_cache_coherent|5.013003||Viu +assignment_type|5.021005||Viu +ASSUME|5.019006|5.003007|p +atfork_lock|5.007003|5.007003|nu +atfork_unlock|5.007003|5.007003|nu +aTHX|5.006000|5.003007|p +aTHX_|5.006000|5.003007|p +aTHXa|5.017006||Viu +aTHXo|5.006000||Viu +aTHXR||5.003007|ponu +aTHXR_||5.003007|ponu +aTHXx|5.006000||Viu +Atof|5.006000||Viu +Atol|5.006000||Viu +atoll|5.008000||Viu +Atoul|5.006000||Viu +AvALLOC|5.003007||Viu +AvARRAY|5.003007|5.003007| +AvARYLEN|5.003007||Viu +av_arylen_p|||cu +av_clear|5.003007|5.003007| +av_count|5.033001|5.003007|p +av_create_and_push||| +av_create_and_unshift_one||| +av_delete|5.006000|5.006000| +av_exists|5.006000|5.006000| +av_extend|5.003007|5.003007| +av_extend_guts|5.017004||Viu +av_fetch|5.003007|5.003007| +av_fetch_simple|5.035002||cV +av_fill|5.003007|5.003007| +AvFILL|5.003007|5.003007| +AvFILLp|5.004005||pcV +av_iter_p|||cu +av_len|5.003007|5.003007| +av_make|5.003007|5.003007| +AvMAX|5.003007||Viu +av_new_alloc|5.035001|5.035001| +av_nonelem|5.027009||Viu +av_pop|5.003007|5.003007| +av_push|5.003007|5.003007| +AvREAL|5.003007||Viu +AvREALISH|5.003007||Viu +AvREAL_off|5.003007||Viu +AvREAL_on|5.003007||Viu +AvREAL_only|5.009003||Viu +AvREIFY|5.003007||Viu +av_reify|5.004004||cViu +AvREIFY_off|5.003007||Viu +AvREIFY_on|5.003007||Viu +AvREIFY_only|5.009003||Viu +av_shift|5.003007|5.003007| +av_store|5.003007|5.003007| +av_store_simple|5.035002||cV +av_tindex|5.017009|5.003007|p +av_tindex_skip_len_mg|5.025010||Viu +av_top_index|5.017009|5.003007|p +av_top_index_skip_len_mg|5.025010||Viu +av_undef|5.003007|5.003007| +av_unshift|5.003007|5.003007| +ax|5.003007|5.003007| +backup_one_GCB|5.025003||Viu +backup_one_LB|5.023007||Viu +backup_one_SB|5.021009||Viu +backup_one_WB|5.021009||Viu +bad_type_gv|5.019002||Viu +bad_type_pv|5.016000||Viu +BADVERSION|5.011004||Viu +BASEOP|5.003007||Viu +BhkDISABLE|5.013003||xV +BhkENABLE|5.013003||xV +BhkENTRY|5.013003||xVi +BhkENTRY_set|5.013003||xV +BHKf_bhk_eval|5.013006||Viu +BHKf_bhk_post_end|5.013006||Viu +BHKf_bhk_pre_end|5.013006||Viu +BHKf_bhk_start|5.013006||Viu +BhkFLAGS|5.013003||xVi +BIN|5.003007|5.003007|Vn +bind|5.005000||Viu +bind_match|5.003007||Viu +BIN_EXP|5.004000|5.004000|Vn +BIT_BUCKET|5.003007||Viu +BIT_DIGITS|5.004000||Viu +BITMAP_BYTE|5.009005||Viu +BITMAP_TEST|5.009005||Viu +blk_eval|5.003007||Viu +blk_format|5.011000||Viu +blk_gimme|5.003007||Viu +blk_givwhen|5.027008||Viu +blk_loop|5.003007||Viu +blk_oldcop|5.003007||Viu +blk_oldmarksp|5.003007||Viu +blk_oldpm|5.003007||Viu +blk_oldsaveix|5.023008||Viu +blk_oldscopesp|5.003007||Viu +blk_oldsp|5.003007||Viu +blk_old_tmpsfloor|5.023008||Viu +blk_sub|5.003007||Viu +blk_u16|5.011000||Viu +block_end|5.021006|5.021006| +block_gimme|5.004000|5.004000|u +blockhook_register|||x +block_start|5.021006|5.021006| +BmFLAGS|5.009005||Viu +BmPREVIOUS|5.003007||Viu +BmRARE|5.003007||Viu +BmUSEFUL|5.003007||Viu +BOL|5.003007||Viu +BOL_t8|5.035004||Viu +BOL_t8_p8|5.033003||Viu +BOL_t8_pb|5.033003||Viu +BOL_tb|5.035004||Viu +BOL_tb_p8|5.033003||Viu +BOL_tb_pb|5.033003||Viu +BOM_UTF8|5.025005|5.003007|p +BOM_UTF8_FIRST_BYTE|5.019004||Viu +BOM_UTF8_TAIL|5.019004||Viu +boolSV|5.004000|5.003007|p +boot_core_builtin|5.035007||Viu +boot_core_mro|5.009005||Viu +boot_core_PerlIO|5.007002||Viu +boot_core_UNIVERSAL|5.003007||Viu +BOUND|5.003007||Viu +BOUNDA|5.013009||Viu +BOUNDA_t8|5.035004||Viu +BOUNDA_t8_p8|5.033003||Viu +BOUNDA_t8_pb|5.033003||Viu +BOUNDA_tb|5.035004||Viu +BOUNDA_tb_p8|5.033003||Viu +BOUNDA_tb_pb|5.033003||Viu +BOUNDL|5.004000||Viu +BOUNDL_t8|5.035004||Viu +BOUNDL_t8_p8|5.033003||Viu +BOUNDL_t8_pb|5.033003||Viu +BOUNDL_tb|5.035004||Viu +BOUNDL_tb_p8|5.033003||Viu +BOUNDL_tb_pb|5.033003||Viu +BOUND_t8|5.035004||Viu +BOUND_t8_p8|5.033003||Viu +BOUND_t8_pb|5.033003||Viu +BOUND_tb|5.035004||Viu +BOUND_tb_p8|5.033003||Viu +BOUND_tb_pb|5.033003||Viu +BOUNDU|5.013009||Viu +BOUNDU_t8|5.035004||Viu +BOUNDU_t8_p8|5.033003||Viu +BOUNDU_t8_pb|5.033003||Viu +BOUNDU_tb|5.035004||Viu +BOUNDU_tb_p8|5.033003||Viu +BOUNDU_tb_pb|5.033003||Viu +BRANCH|5.003007||Viu +BRANCHJ|5.005000||Viu +BRANCHJ_t8|5.035004||Viu +BRANCHJ_t8_p8|5.033003||Viu +BRANCHJ_t8_pb|5.033003||Viu +BRANCHJ_tb|5.035004||Viu +BRANCHJ_tb_p8|5.033003||Viu +BRANCHJ_tb_pb|5.033003||Viu +BRANCH_next|5.009005||Viu +BRANCH_next_fail|5.009005||Viu +BRANCH_next_fail_t8|5.035004||Viu +BRANCH_next_fail_t8_p8|5.033003||Viu +BRANCH_next_fail_t8_pb|5.033003||Viu +BRANCH_next_fail_tb|5.035004||Viu +BRANCH_next_fail_tb_p8|5.033003||Viu +BRANCH_next_fail_tb_pb|5.033003||Viu +BRANCH_next_t8|5.035004||Viu +BRANCH_next_t8_p8|5.033003||Viu +BRANCH_next_t8_pb|5.033003||Viu +BRANCH_next_tb|5.035004||Viu +BRANCH_next_tb_p8|5.033003||Viu +BRANCH_next_tb_pb|5.033003||Viu +BRANCH_t8|5.035004||Viu +BRANCH_t8_p8|5.033003||Viu +BRANCH_t8_pb|5.033003||Viu +BRANCH_tb|5.035004||Viu +BRANCH_tb_p8|5.033003||Viu +BRANCH_tb_pb|5.033003||Viu +BSD_GETPGRP|5.003007||Viu +BSDish|5.008001||Viu +BSD_SETPGRP|5.003007||Viu +BUFSIZ|5.003007||Viu +_byte_dump_string|5.025006||cViu +BYTEORDER|5.003007|5.003007|Vn +bytes_cmp_utf8|5.013007|5.013007| +bytes_from_utf8|5.007001|5.007001|x +bytes_from_utf8_loc|5.027001||xcVn +bytes_to_utf8|5.006001|5.006001|x +call_argv|5.006000|5.003007|p +call_atexit|5.006000|5.006000|u +CALL_BLOCK_HOOKS|5.013003||xVi +CALL_CHECKER_REQUIRE_GV|5.021004|5.021004| +caller_cx|5.013005|5.006000|p +CALL_FPTR|5.006000||Viu +call_list|5.004000|5.004000|u +call_method|5.006000|5.003007|p +calloc|5.029005||Vn +call_pv|5.006000|5.003007|p +CALLREGCOMP|5.005000||Viu +CALLREGCOMP_ENG|5.009005||Viu +CALLREGDUPE|5.009005||Viu +CALLREGDUPE_PVT|5.009005||Viu +CALLREGEXEC|5.005000||Viu +CALLREGFREE|5.006000||Viu +CALLREGFREE_PVT|5.009005||Viu +CALLREG_INTUIT_START|5.006000||Viu +CALLREG_INTUIT_STRING|5.006000||Viu +CALLREG_NAMED_BUFF_ALL|5.009005||Viu +CALLREG_NAMED_BUFF_CLEAR|5.009005||Viu +CALLREG_NAMED_BUFF_COUNT|5.009005||Viu +CALLREG_NAMED_BUFF_DELETE|5.009005||Viu +CALLREG_NAMED_BUFF_EXISTS|5.009005||Viu +CALLREG_NAMED_BUFF_FETCH|5.009005||Viu +CALLREG_NAMED_BUFF_FIRSTKEY|5.009005||Viu +CALLREG_NAMED_BUFF_NEXTKEY|5.009005||Viu +CALLREG_NAMED_BUFF_SCALAR|5.009005||Viu +CALLREG_NAMED_BUFF_STORE|5.009005||Viu +CALLREG_NUMBUF_FETCH|5.009005||Viu +CALLREG_NUMBUF_LENGTH|5.009005||Viu +CALLREG_NUMBUF_STORE|5.009005||Viu +CALLREG_PACKAGE|5.009005||Viu +CALLRUNOPS|5.005000||Viu +call_sv|5.006000|5.003007|p +CAN64BITHASH|5.027001||Viu +CAN_COW_FLAGS|5.009000||Viu +CAN_COW_MASK|5.009000||Viu +cando|5.003007||Viu +CAN_PROTOTYPE|5.003007||Viu +C_ARRAY_END|5.013002|5.003007|p +C_ARRAY_LENGTH|5.008001|5.003007|p +case_100_SBOX32|5.027001||Viu +case_101_SBOX32|5.027001||Viu +case_102_SBOX32|5.027001||Viu +case_103_SBOX32|5.027001||Viu +case_104_SBOX32|5.027001||Viu +case_105_SBOX32|5.027001||Viu +case_106_SBOX32|5.027001||Viu +case_107_SBOX32|5.027001||Viu +case_108_SBOX32|5.027001||Viu +case_109_SBOX32|5.027001||Viu +case_10_SBOX32|5.027001||Viu +case_110_SBOX32|5.027001||Viu +case_111_SBOX32|5.027001||Viu +case_112_SBOX32|5.027001||Viu +case_113_SBOX32|5.027001||Viu +case_114_SBOX32|5.027001||Viu +case_115_SBOX32|5.027001||Viu +case_116_SBOX32|5.027001||Viu +case_117_SBOX32|5.027001||Viu +case_118_SBOX32|5.027001||Viu +case_119_SBOX32|5.027001||Viu +case_11_SBOX32|5.027001||Viu +case_120_SBOX32|5.027001||Viu +case_121_SBOX32|5.027001||Viu +case_122_SBOX32|5.027001||Viu +case_123_SBOX32|5.027001||Viu +case_124_SBOX32|5.027001||Viu +case_125_SBOX32|5.027001||Viu +case_126_SBOX32|5.027001||Viu +case_127_SBOX32|5.027001||Viu +case_128_SBOX32|5.027001||Viu +case_129_SBOX32|5.027001||Viu +case_12_SBOX32|5.027001||Viu +case_130_SBOX32|5.027001||Viu +case_131_SBOX32|5.027001||Viu +case_132_SBOX32|5.027001||Viu +case_133_SBOX32|5.027001||Viu +case_134_SBOX32|5.027001||Viu +case_135_SBOX32|5.027001||Viu +case_136_SBOX32|5.027001||Viu +case_137_SBOX32|5.027001||Viu +case_138_SBOX32|5.027001||Viu +case_139_SBOX32|5.027001||Viu +case_13_SBOX32|5.027001||Viu +case_140_SBOX32|5.027001||Viu +case_141_SBOX32|5.027001||Viu +case_142_SBOX32|5.027001||Viu +case_143_SBOX32|5.027001||Viu +case_144_SBOX32|5.027001||Viu +case_145_SBOX32|5.027001||Viu +case_146_SBOX32|5.027001||Viu +case_147_SBOX32|5.027001||Viu +case_148_SBOX32|5.027001||Viu +case_149_SBOX32|5.027001||Viu +case_14_SBOX32|5.027001||Viu +case_150_SBOX32|5.027001||Viu +case_151_SBOX32|5.027001||Viu +case_152_SBOX32|5.027001||Viu +case_153_SBOX32|5.027001||Viu +case_154_SBOX32|5.027001||Viu +case_155_SBOX32|5.027001||Viu +case_156_SBOX32|5.027001||Viu +case_157_SBOX32|5.027001||Viu +case_158_SBOX32|5.027001||Viu +case_159_SBOX32|5.027001||Viu +case_15_SBOX32|5.027001||Viu +case_160_SBOX32|5.027001||Viu +case_161_SBOX32|5.027001||Viu +case_162_SBOX32|5.027001||Viu +case_163_SBOX32|5.027001||Viu +case_164_SBOX32|5.027001||Viu +case_165_SBOX32|5.027001||Viu +case_166_SBOX32|5.027001||Viu +case_167_SBOX32|5.027001||Viu +case_168_SBOX32|5.027001||Viu +case_169_SBOX32|5.027001||Viu +case_16_SBOX32|5.027001||Viu +case_170_SBOX32|5.027001||Viu +case_171_SBOX32|5.027001||Viu +case_172_SBOX32|5.027001||Viu +case_173_SBOX32|5.027001||Viu +case_174_SBOX32|5.027001||Viu +case_175_SBOX32|5.027001||Viu +case_176_SBOX32|5.027001||Viu +case_177_SBOX32|5.027001||Viu +case_178_SBOX32|5.027001||Viu +case_179_SBOX32|5.027001||Viu +case_17_SBOX32|5.027001||Viu +case_180_SBOX32|5.027001||Viu +case_181_SBOX32|5.027001||Viu +case_182_SBOX32|5.027001||Viu +case_183_SBOX32|5.027001||Viu +case_184_SBOX32|5.027001||Viu +case_185_SBOX32|5.027001||Viu +case_186_SBOX32|5.027001||Viu +case_187_SBOX32|5.027001||Viu +case_188_SBOX32|5.027001||Viu +case_189_SBOX32|5.027001||Viu +case_18_SBOX32|5.027001||Viu +case_190_SBOX32|5.027001||Viu +case_191_SBOX32|5.027001||Viu +case_192_SBOX32|5.027001||Viu +case_193_SBOX32|5.027001||Viu +case_194_SBOX32|5.027001||Viu +case_195_SBOX32|5.027001||Viu +case_196_SBOX32|5.027001||Viu +case_197_SBOX32|5.027001||Viu +case_198_SBOX32|5.027001||Viu +case_199_SBOX32|5.027001||Viu +case_19_SBOX32|5.027001||Viu +case_1_SBOX32|5.027001||Viu +case_200_SBOX32|5.027001||Viu +case_201_SBOX32|5.027001||Viu +case_202_SBOX32|5.027001||Viu +case_203_SBOX32|5.027001||Viu +case_204_SBOX32|5.027001||Viu +case_205_SBOX32|5.027001||Viu +case_206_SBOX32|5.027001||Viu +case_207_SBOX32|5.027001||Viu +case_208_SBOX32|5.027001||Viu +case_209_SBOX32|5.027001||Viu +case_20_SBOX32|5.027001||Viu +case_210_SBOX32|5.027001||Viu +case_211_SBOX32|5.027001||Viu +case_212_SBOX32|5.027001||Viu +case_213_SBOX32|5.027001||Viu +case_214_SBOX32|5.027001||Viu +case_215_SBOX32|5.027001||Viu +case_216_SBOX32|5.027001||Viu +case_217_SBOX32|5.027001||Viu +case_218_SBOX32|5.027001||Viu +case_219_SBOX32|5.027001||Viu +case_21_SBOX32|5.027001||Viu +case_220_SBOX32|5.027001||Viu +case_221_SBOX32|5.027001||Viu +case_222_SBOX32|5.027001||Viu +case_223_SBOX32|5.027001||Viu +case_224_SBOX32|5.027001||Viu +case_225_SBOX32|5.027001||Viu +case_226_SBOX32|5.027001||Viu +case_227_SBOX32|5.027001||Viu +case_228_SBOX32|5.027001||Viu +case_229_SBOX32|5.027001||Viu +case_22_SBOX32|5.027001||Viu +case_230_SBOX32|5.027001||Viu +case_231_SBOX32|5.027001||Viu +case_232_SBOX32|5.027001||Viu +case_233_SBOX32|5.027001||Viu +case_234_SBOX32|5.027001||Viu +case_235_SBOX32|5.027001||Viu +case_236_SBOX32|5.027001||Viu +case_237_SBOX32|5.027001||Viu +case_238_SBOX32|5.027001||Viu +case_239_SBOX32|5.027001||Viu +case_23_SBOX32|5.027001||Viu +case_240_SBOX32|5.027001||Viu +case_241_SBOX32|5.027001||Viu +case_242_SBOX32|5.027001||Viu +case_243_SBOX32|5.027001||Viu +case_244_SBOX32|5.027001||Viu +case_245_SBOX32|5.027001||Viu +case_246_SBOX32|5.027001||Viu +case_247_SBOX32|5.027001||Viu +case_248_SBOX32|5.027001||Viu +case_249_SBOX32|5.027001||Viu +case_24_SBOX32|5.027001||Viu +case_250_SBOX32|5.027001||Viu +case_251_SBOX32|5.027001||Viu +case_252_SBOX32|5.027001||Viu +case_253_SBOX32|5.027001||Viu +case_254_SBOX32|5.027001||Viu +case_255_SBOX32|5.027001||Viu +case_256_SBOX32|5.027001||Viu +case_25_SBOX32|5.027001||Viu +case_26_SBOX32|5.027001||Viu +case_27_SBOX32|5.027001||Viu +case_28_SBOX32|5.027001||Viu +case_29_SBOX32|5.027001||Viu +case_2_SBOX32|5.027001||Viu +case_30_SBOX32|5.027001||Viu +case_31_SBOX32|5.027001||Viu +case_32_SBOX32|5.027001||Viu +case_33_SBOX32|5.027001||Viu +case_34_SBOX32|5.027001||Viu +case_35_SBOX32|5.027001||Viu +case_36_SBOX32|5.027001||Viu +case_37_SBOX32|5.027001||Viu +case_38_SBOX32|5.027001||Viu +case_39_SBOX32|5.027001||Viu +case_3_SBOX32|5.027001||Viu +case_40_SBOX32|5.027001||Viu +case_41_SBOX32|5.027001||Viu +case_42_SBOX32|5.027001||Viu +case_43_SBOX32|5.027001||Viu +case_44_SBOX32|5.027001||Viu +case_45_SBOX32|5.027001||Viu +case_46_SBOX32|5.027001||Viu +case_47_SBOX32|5.027001||Viu +case_48_SBOX32|5.027001||Viu +case_49_SBOX32|5.027001||Viu +case_4_SBOX32|5.027001||Viu +case_50_SBOX32|5.027001||Viu +case_51_SBOX32|5.027001||Viu +case_52_SBOX32|5.027001||Viu +case_53_SBOX32|5.027001||Viu +case_54_SBOX32|5.027001||Viu +case_55_SBOX32|5.027001||Viu +case_56_SBOX32|5.027001||Viu +case_57_SBOX32|5.027001||Viu +case_58_SBOX32|5.027001||Viu +case_59_SBOX32|5.027001||Viu +case_5_SBOX32|5.027001||Viu +case_60_SBOX32|5.027001||Viu +case_61_SBOX32|5.027001||Viu +case_62_SBOX32|5.027001||Viu +case_63_SBOX32|5.027001||Viu +case_64_SBOX32|5.027001||Viu +case_65_SBOX32|5.027001||Viu +case_66_SBOX32|5.027001||Viu +case_67_SBOX32|5.027001||Viu +case_68_SBOX32|5.027001||Viu +case_69_SBOX32|5.027001||Viu +case_6_SBOX32|5.027001||Viu +case_70_SBOX32|5.027001||Viu +case_71_SBOX32|5.027001||Viu +case_72_SBOX32|5.027001||Viu +case_73_SBOX32|5.027001||Viu +case_74_SBOX32|5.027001||Viu +case_75_SBOX32|5.027001||Viu +case_76_SBOX32|5.027001||Viu +case_77_SBOX32|5.027001||Viu +case_78_SBOX32|5.027001||Viu +case_79_SBOX32|5.027001||Viu +case_7_SBOX32|5.027001||Viu +case_80_SBOX32|5.027001||Viu +case_81_SBOX32|5.027001||Viu +case_82_SBOX32|5.027001||Viu +case_83_SBOX32|5.027001||Viu +case_84_SBOX32|5.027001||Viu +case_85_SBOX32|5.027001||Viu +case_86_SBOX32|5.027001||Viu +case_87_SBOX32|5.027001||Viu +case_88_SBOX32|5.027001||Viu +case_89_SBOX32|5.027001||Viu +case_8_SBOX32|5.027001||Viu +case_90_SBOX32|5.027001||Viu +case_91_SBOX32|5.027001||Viu +case_92_SBOX32|5.027001||Viu +case_93_SBOX32|5.027001||Viu +case_94_SBOX32|5.027001||Viu +case_95_SBOX32|5.027001||Viu +case_96_SBOX32|5.027001||Viu +case_97_SBOX32|5.027001||Viu +case_98_SBOX32|5.027001||Viu +case_99_SBOX32|5.027001||Viu +case_9_SBOX32|5.027001||Viu +CASE_STD_PMMOD_FLAGS_PARSE_SET|5.009005||Viu +CASTFLAGS|5.003007|5.003007|Vn +cast_i32|5.006000||cVnu +cast_iv|5.006000||cVnu +CASTNEGFLOAT|5.003007|5.003007|Vn +cast_ulong|5.003007||cVnu +cast_uv|5.006000||cVnu +CAT2|5.003007|5.003007|Vn +CATCH_GET|5.004000||Viu +CATCH_SET|5.004000||Viu +category_name|5.027008||Vniu +cBINOP|5.003007||Viu +cBINOPo|5.004005||Viu +cBINOPx|5.006000||Viu +cBOOL|5.013000|5.003007|p +cCOP|5.003007||Viu +cCOPo|5.004005||Viu +cCOPx|5.006000||Viu +C_FAC_POSIX|5.009003||Viu +cGVOP_gv|5.006000||Viu +cGVOPo_gv|5.006000||Viu +cGVOPx_gv|5.006000||Viu +change_engine_size|5.029004||Viu +CHANGE_MULTICALL_FLAGS|5.018000||Viu +CHARBITS|5.011002|5.011002|Vn +CHARSET_PAT_MODS|5.013010||Viu +chdir|5.005000||Viu +checkcomma|5.003007||Viu +check_end_shift|5.009005||Viu +check_locale_boundary_crossing|5.015006||Viu +CHECK_MALLOC_TAINT|5.008001||Viu +CHECK_MALLOC_TOO_LATE_FOR|5.008001||Viu +check_offset_max|5.005000||Viu +check_offset_min|5.005000||Viu +check_substr|5.005000||Viu +check_type_and_open|5.009003||Viu +check_uni|5.003007||Viu +check_utf8|5.008000||Viu +check_utf8_print|5.013009||Viu +child_offset_bits|5.009003||Viu +chmod|5.005000||Viu +chsize|5.005000||Viu +ckDEAD|5.006000||Viu +ck_entersub_args_core|||iu +ck_entersub_args_list|5.013006|5.013006| +ck_entersub_args_proto|5.013006|5.013006| +ck_entersub_args_proto_or_list|5.013006|5.013006| +ckWARN2|5.006000|5.003007|p +ckWARN2_d|5.006000|5.003007|p +ckWARN3|5.007003|5.003007|p +ckWARN3_d|5.007003|5.003007|p +ckWARN4|5.007003|5.003007|p +ckWARN4_d|5.007003|5.003007|p +ckWARN|5.006000|5.003007|p +ckwarn_common|5.011001||Viu +ckwarn|||cu +ckWARN_d|5.006000|5.003007|p +ckwarn_d|||cu +ck_warner|5.011001||pvV +ck_warner_d|5.011001||pvV +CLANG_DIAG_IGNORE|5.023006||Viu +CLANG_DIAG_IGNORE_DECL|5.027007||Viu +CLANG_DIAG_IGNORE_STMT|5.027007||Viu +CLANG_DIAG_PRAGMA|5.023006||Viu +CLANG_DIAG_RESTORE|5.023006||Viu +CLANG_DIAG_RESTORE_DECL|5.027007||Viu +CLANG_DIAG_RESTORE_STMT|5.027007||Viu +CLASS||5.003007| +CLEAR_ARGARRAY|5.006000||Viu +clear_defarray|5.023008|5.023008|u +clearerr|5.003007||Viu +CLEAR_ERRSV|5.025007|5.025007| +CLEARFEATUREBITS|5.031006||Viu +clear_placeholders|5.009004||xViu +clear_special_blocks|5.021003||Viu +cLISTOP|5.003007||Viu +cLISTOPo|5.004005||Viu +cLISTOPx|5.006000||Viu +cLOGOP|5.003007||Viu +cLOGOPo|5.004005||Viu +cLOGOPx|5.006000||Viu +CLONEf_CLONE_HOST|5.007002||Viu +CLONEf_COPY_STACKS|5.007001||Viu +CLONEf_JOIN_IN|5.008001||Viu +CLONEf_KEEP_PTR_TABLE|5.007001||Viu +clone_params_del|||nu +clone_params_new|||nu +cLOOP|5.003007||Viu +cLOOPo|5.004005||Viu +cLOOPx|5.006000||Viu +CLOSE|5.003007||Viu +close|5.005000||Viu +closedir|5.005000||Viu +closest_cop|5.007002||Viu +CLOSE_t8|5.035004||Viu +CLOSE_t8_p8|5.033003||Viu +CLOSE_t8_pb|5.033003||Viu +CLOSE_tb|5.035004||Viu +CLOSE_tb_p8|5.033003||Viu +CLOSE_tb_pb|5.033003||Viu +CLUMP_2IV|5.006000||Viu +CLUMP_2UV|5.006000||Viu +CLUMP|5.006000||Viu +CLUMP_t8|5.035004||Viu +CLUMP_t8_p8|5.033003||Viu +CLUMP_t8_pb|5.033003||Viu +CLUMP_tb|5.035004||Viu +CLUMP_tb_p8|5.033003||Viu +CLUMP_tb_pb|5.033003||Viu +cMETHOPx|5.021005||Viu +cMETHOPx_meth|5.021005||Viu +cMETHOPx_rclass|5.021007||Viu +cmpchain_extend|5.031011||Viu +cmpchain_finish|5.031011||Viu +cmpchain_start|5.031011||Viu +cmp_desc|5.031011||Viu +cmp_locale_desc|5.031011||Viu +cntrl_to_mnemonic|5.021004||cVniu +CODESET|5.027010||Viu +COMBINING_DOT_ABOVE_UTF8|5.029008||Viu +COMBINING_GRAVE_ACCENT_UTF8|5.017004||Viu +COMMIT|5.009005||Viu +COMMIT_next|5.009005||Viu +COMMIT_next_fail|5.009005||Viu +COMMIT_next_fail_t8|5.035004||Viu +COMMIT_next_fail_t8_p8|5.033003||Viu +COMMIT_next_fail_t8_pb|5.033003||Viu +COMMIT_next_fail_tb|5.035004||Viu +COMMIT_next_fail_tb_p8|5.033003||Viu +COMMIT_next_fail_tb_pb|5.033003||Viu +COMMIT_next_t8|5.035004||Viu +COMMIT_next_t8_p8|5.033003||Viu +COMMIT_next_t8_pb|5.033003||Viu +COMMIT_next_tb|5.035004||Viu +COMMIT_next_tb_p8|5.033003||Viu +COMMIT_next_tb_pb|5.033003||Viu +COMMIT_t8|5.035004||Viu +COMMIT_t8_p8|5.033003||Viu +COMMIT_t8_pb|5.033003||Viu +COMMIT_tb|5.035004||Viu +COMMIT_tb_p8|5.033003||Viu +COMMIT_tb_pb|5.033003||Viu +compile_wildcard|5.031010||Viu +compute_EXACTish|5.017003||Vniu +COND_BROADCAST|5.005000||Viu +COND_DESTROY|5.005000||Viu +COND_INIT|5.005000||Viu +COND_SIGNAL|5.005000||Viu +COND_WAIT|5.005000||Viu +connect|5.005000||Viu +construct_ahocorasick_from_trie|5.021001||Viu +CONTINUE_PAT_MOD|5.009005||Viu +cop_fetch_label|5.031004|5.031004|x +CopFILE|5.006000|5.003007|p +CopFILEAV|5.006000|5.003007|p +CopFILEAVn|5.035006|5.035006| +cop_file_avn|5.035006||cVu +CopFILEAVx|5.009003||Viu +CopFILE_free|5.007003||Viu +CopFILEGV|5.006000|5.003007|p +CopFILEGV_set|5.006000|5.003007|p +CopFILE_set|5.006000|5.003007|p +CopFILE_setn|5.009005||Viu +CopFILESV|5.006000|5.003007|p +cop_free|5.006000||Viu +cophh_2hv|5.013007|5.013007|x +cophh_copy|5.013007|5.013007|x +cophh_delete_pv|5.013007|5.013007|x +cophh_delete_pvn|5.013007|5.013007|x +cophh_delete_pvs|5.013007|5.013007|x +cophh_delete_sv|5.013007|5.013007|x +COPHH_EXISTS|5.033008||Viu +cophh_exists_pv|5.033008|5.033008|x +cophh_exists_pvn|5.033008|5.033008|x +cophh_exists_pvs|5.033008|5.033008|x +cophh_exists_sv|5.033008|5.033008|x +cophh_fetch_pv|5.013007|5.013007|x +cophh_fetch_pvn|5.013007|5.013007|x +cophh_fetch_pvs|5.013007|5.013007|x +cophh_fetch_sv|5.013007|5.013007|x +cophh_free|5.013007|5.013007|x +COPHH_KEY_UTF8|5.013007|5.013007| +cophh_new_empty|5.013007|5.013007|x +cophh_store_pv|5.013007|5.013007|x +cophh_store_pvn|5.013007|5.013007|x +cophh_store_pvs|5.013007|5.013007|x +cophh_store_sv|5.013007|5.013007|x +CopHINTHASH_get|5.013007||Viu +CopHINTHASH_set|5.013007||Viu +cop_hints_2hv|5.013007|5.013007| +cop_hints_exists_pv|5.033008|5.033008| +cop_hints_exists_pvn|5.033008|5.033008| +cop_hints_exists_pvs|5.033008|5.033008| +cop_hints_exists_sv|5.033008|5.033008| +cop_hints_fetch_pv|5.013007|5.013007| +cop_hints_fetch_pvn|5.013007|5.013007| +cop_hints_fetch_pvs|5.013007|5.013007| +cop_hints_fetch_sv|5.013007|5.013007| +CopHINTS_get|5.009004||Viu +CopHINTS_set|5.009004||Viu +CopLABEL|5.009005|5.009005| +CopLABEL_alloc|5.009005||Viu +CopLABEL_len|5.016000|5.016000| +CopLABEL_len_flags|5.016000|5.016000| +CopLINE|5.006000|5.006000| +CopLINE_dec|5.006000||Viu +CopLINE_inc|5.006000||Viu +CopLINE_set|5.006000||Viu +COP_SEQMAX_INC|5.021006||Viu +COP_SEQ_RANGE_HIGH|5.009005||Viu +COP_SEQ_RANGE_LOW|5.009005||Viu +CopSTASH|5.006000|5.003007|p +CopSTASH_eq|5.006000|5.003007|p +CopSTASH_ne|5.006000||Viu +CopSTASHPV|5.006000|5.003007|p +CopSTASHPV_set|5.017001|5.017001|p +CopSTASH_set|5.006000|5.003007|p +cop_store_label|5.031004|5.031004|x +Copy|5.003007|5.003007| +CopyD|5.009002|5.003007|p +copy_length|||Viu +core_prototype|5.015002||Vi +coresub_op|5.015003||Viu +CowREFCNT|5.017007||Viu +cPADOP|5.006000||Viu +cPADOPo|5.006000||Viu +cPADOPx|5.006000||Viu +CPERLarg|5.005000||Viu +CPERLscope|5.005000|5.003007|pdV +cPMOP|5.003007||Viu +cPMOPo|5.004005||Viu +cPMOPx|5.006000||Viu +CPPLAST|5.006000|5.006000|Vn +CPPMINUS|5.003007|5.003007|Vn +CPPRUN|5.006000|5.006000|Vn +CPPSTDIN|5.003007|5.003007|Vn +cPVOP|5.003007||Viu +cPVOPo|5.004005||Viu +cPVOPx|5.006000||Viu +create_eval_scope|5.009004||xViu +CR_NATIVE|5.019004||Viu +CRNCYSTR|5.027010||Viu +croak|5.003007||vV +croak_caller|5.025004||vVniu +croak_memory_wrap|5.019003||pcVnu +croak_nocontext|5.006000||pvVn +croak_no_mem|5.017006||Vniu +croak_no_modify|5.013003|5.003007|pn +croak_popstack|5.017008||cVniu +croak_sv|5.013001|5.003007|p +croak_xs_usage|5.010001|5.003007|pn +cr_textfilter|5.006000||Viu +crypt|5.009000||Viu +CRYPT_R_PROTO|5.008000|5.008000|Vn +CSH|5.003007|5.003007|Vn +csighandler1|5.031007||cVnu +csighandler3|5.031007||cVnu +csighandler|5.008001||cVnu +cSVOP|5.003007||Viu +cSVOPo|5.004005||Viu +cSVOPo_sv|5.006000||Viu +cSVOP_sv|5.006000||Viu +cSVOPx|5.006000||Viu +cSVOPx_sv|5.006000||Viu +cSVOPx_svp|5.006000||Viu +ctermid|5.009000||Viu +CTERMID_R_PROTO|5.008000|5.008000|Vn +ctime|5.009000||Viu +CTIME_R_PROTO|5.008000|5.008000|Vn +Ctl|5.003007||Viu +CTYPE256|5.003007||Viu +cUNOP|5.003007||Viu +cUNOP_AUX|5.021007||Viu +cUNOP_AUXo|5.021007||Viu +cUNOP_AUXx|5.021007||Viu +cUNOPo|5.004005||Viu +cUNOPx|5.006000||Viu +CURLY|5.003007||Viu +CURLY_B_max|5.009005||Viu +CURLY_B_max_fail|5.009005||Viu +CURLY_B_max_fail_t8|5.035004||Viu +CURLY_B_max_fail_t8_p8|5.033003||Viu +CURLY_B_max_fail_t8_pb|5.033003||Viu +CURLY_B_max_fail_tb|5.035004||Viu +CURLY_B_max_fail_tb_p8|5.033003||Viu +CURLY_B_max_fail_tb_pb|5.033003||Viu +CURLY_B_max_t8|5.035004||Viu +CURLY_B_max_t8_p8|5.033003||Viu +CURLY_B_max_t8_pb|5.033003||Viu +CURLY_B_max_tb|5.035004||Viu +CURLY_B_max_tb_p8|5.033003||Viu +CURLY_B_max_tb_pb|5.033003||Viu +CURLY_B_min|5.009005||Viu +CURLY_B_min_fail|5.009005||Viu +CURLY_B_min_fail_t8|5.035004||Viu +CURLY_B_min_fail_t8_p8|5.033003||Viu +CURLY_B_min_fail_t8_pb|5.033003||Viu +CURLY_B_min_fail_tb|5.035004||Viu +CURLY_B_min_fail_tb_p8|5.033003||Viu +CURLY_B_min_fail_tb_pb|5.033003||Viu +CURLY_B_min_t8|5.035004||Viu +CURLY_B_min_t8_p8|5.033003||Viu +CURLY_B_min_t8_pb|5.033003||Viu +CURLY_B_min_tb|5.035004||Viu +CURLY_B_min_tb_p8|5.033003||Viu +CURLY_B_min_tb_pb|5.033003||Viu +CURLYM|5.005000||Viu +CURLYM_A|5.009005||Viu +CURLYM_A_fail|5.009005||Viu +CURLYM_A_fail_t8|5.035004||Viu +CURLYM_A_fail_t8_p8|5.033003||Viu +CURLYM_A_fail_t8_pb|5.033003||Viu +CURLYM_A_fail_tb|5.035004||Viu +CURLYM_A_fail_tb_p8|5.033003||Viu +CURLYM_A_fail_tb_pb|5.033003||Viu +CURLYM_A_t8|5.035004||Viu +CURLYM_A_t8_p8|5.033003||Viu +CURLYM_A_t8_pb|5.033003||Viu +CURLYM_A_tb|5.035004||Viu +CURLYM_A_tb_p8|5.033003||Viu +CURLYM_A_tb_pb|5.033003||Viu +CURLYM_B|5.009005||Viu +CURLYM_B_fail|5.009005||Viu +CURLYM_B_fail_t8|5.035004||Viu +CURLYM_B_fail_t8_p8|5.033003||Viu +CURLYM_B_fail_t8_pb|5.033003||Viu +CURLYM_B_fail_tb|5.035004||Viu +CURLYM_B_fail_tb_p8|5.033003||Viu +CURLYM_B_fail_tb_pb|5.033003||Viu +CURLYM_B_t8|5.035004||Viu +CURLYM_B_t8_p8|5.033003||Viu +CURLYM_B_t8_pb|5.033003||Viu +CURLYM_B_tb|5.035004||Viu +CURLYM_B_tb_p8|5.033003||Viu +CURLYM_B_tb_pb|5.033003||Viu +CURLYM_t8|5.035004||Viu +CURLYM_t8_p8|5.033003||Viu +CURLYM_t8_pb|5.033003||Viu +CURLYM_tb|5.035004||Viu +CURLYM_tb_p8|5.033003||Viu +CURLYM_tb_pb|5.033003||Viu +CURLYN|5.005000||Viu +CURLYN_t8|5.035004||Viu +CURLYN_t8_p8|5.033003||Viu +CURLYN_t8_pb|5.033003||Viu +CURLYN_tb|5.035004||Viu +CURLYN_tb_p8|5.033003||Viu +CURLYN_tb_pb|5.033003||Viu +CURLY_t8|5.035004||Viu +CURLY_t8_p8|5.033003||Viu +CURLY_t8_pb|5.033003||Viu +CURLY_tb|5.035004||Viu +CURLY_tb_p8|5.033003||Viu +CURLY_tb_pb|5.033003||Viu +CURLYX|5.003007||Viu +CURLYX_end|5.009005||Viu +CURLYX_end_fail|5.009005||Viu +CURLYX_end_fail_t8|5.035004||Viu +CURLYX_end_fail_t8_p8|5.033003||Viu +CURLYX_end_fail_t8_pb|5.033003||Viu +CURLYX_end_fail_tb|5.035004||Viu +CURLYX_end_fail_tb_p8|5.033003||Viu +CURLYX_end_fail_tb_pb|5.033003||Viu +CURLYX_end_t8|5.035004||Viu +CURLYX_end_t8_p8|5.033003||Viu +CURLYX_end_t8_pb|5.033003||Viu +CURLYX_end_tb|5.035004||Viu +CURLYX_end_tb_p8|5.033003||Viu +CURLYX_end_tb_pb|5.033003||Viu +CURLYX_t8|5.035004||Viu +CURLYX_t8_p8|5.033003||Viu +CURLYX_t8_pb|5.033003||Viu +CURLYX_tb|5.035004||Viu +CURLYX_tb_p8|5.033003||Viu +CURLYX_tb_pb|5.033003||Viu +CURRENT_FEATURE_BUNDLE|5.015007||Viu +CURRENT_HINTS|5.015007||Viu +current_re_engine|5.017001||cViu +curse|5.013009||Viu +custom_op_desc|5.007003|5.007003|d +custom_op_get_field|5.019006||cViu +custom_op_name|5.007003|5.007003|d +custom_op_register||| +CUTGROUP|5.009005||Viu +CUTGROUP_next|5.009005||Viu +CUTGROUP_next_fail|5.009005||Viu +CUTGROUP_next_fail_t8|5.035004||Viu +CUTGROUP_next_fail_t8_p8|5.033003||Viu +CUTGROUP_next_fail_t8_pb|5.033003||Viu +CUTGROUP_next_fail_tb|5.035004||Viu +CUTGROUP_next_fail_tb_p8|5.033003||Viu +CUTGROUP_next_fail_tb_pb|5.033003||Viu +CUTGROUP_next_t8|5.035004||Viu +CUTGROUP_next_t8_p8|5.033003||Viu +CUTGROUP_next_t8_pb|5.033003||Viu +CUTGROUP_next_tb|5.035004||Viu +CUTGROUP_next_tb_p8|5.033003||Viu +CUTGROUP_next_tb_pb|5.033003||Viu +CUTGROUP_t8|5.035004||Viu +CUTGROUP_t8_p8|5.033003||Viu +CUTGROUP_t8_pb|5.033003||Viu +CUTGROUP_tb|5.035004||Viu +CUTGROUP_tb_p8|5.033003||Viu +CUTGROUP_tb_pb|5.033003||Viu +CvANON|5.003007||Viu +CvANONCONST|5.021008||Viu +CvANONCONST_off|5.021008||Viu +CvANONCONST_on|5.021008||Viu +CvANON_off|5.003007||Viu +CvANON_on|5.003007||Viu +CvAUTOLOAD|5.015004||Viu +CvAUTOLOAD_off|5.015004||Viu +CvAUTOLOAD_on|5.015004||Viu +cv_ckproto|5.009004||Viu +cv_ckproto_len_flags|5.015004||xcViu +CvCLONE|5.003007||Viu +cv_clone|5.015001|5.015001| +CvCLONED|5.003007||Viu +CvCLONED_off|5.003007||Viu +CvCLONED_on|5.003007||Viu +cv_clone_into|5.017004||Viu +CvCLONE_off|5.003007||Viu +CvCLONE_on|5.003007||Viu +CvCONST|5.007001||Viu +CvCONST_off|5.007001||Viu +CvCONST_on|5.007001||Viu +cv_const_sv|5.003007|5.003007|n +cv_const_sv_or_av|5.019003||Vniu +CvCVGV_RC|5.013003||Viu +CvCVGV_RC_off|5.013003||Viu +CvCVGV_RC_on|5.013003||Viu +CvDEPTH|5.003007|5.003007|nu +CvDEPTHunsafe|5.021006||Viu +cv_dump|5.006000||Vi +CvDYNFILE|5.015002||Viu +CvDYNFILE_off|5.015002||Viu +CvDYNFILE_on|5.015002||Viu +CvEVAL|5.005003||Viu +CvEVAL_off|5.005003||Viu +CvEVAL_on|5.005003||Viu +CVf_ANON|5.003007||Viu +CVf_ANONCONST|5.021008||Viu +CVf_AUTOLOAD|5.015004||Viu +CVf_BUILTIN_ATTRS|5.008000||Viu +CVf_CLONE|5.003007||Viu +CVf_CLONED|5.003007||Viu +CVf_CONST|5.007001||Viu +CVf_CVGV_RC|5.013003||Viu +CVf_DYNFILE|5.015002||Viu +CVf_HASEVAL|5.017002||Viu +CvFILE|5.006000||Viu +CvFILEGV|5.003007||Viu +CvFILE_set_from_cop|5.007002||Viu +CVf_ISXSUB|5.009004||Viu +CvFLAGS|5.003007||Viu +CVf_LEXICAL|5.021004||Viu +CVf_LVALUE|5.006000||Viu +CVf_METHOD|5.005000||Viu +CVf_NAMED|5.017004||Viu +CVf_NODEBUG|5.004000||Viu +cv_forget_slab|5.017002||Vi +CVf_SIGNATURE|5.035009||Viu +CVf_SLABBED|5.017002||Viu +CVf_UNIQUE|5.004000||Viu +CVf_WEAKOUTSIDE|5.008001||Viu +cv_get_call_checker|5.013006|5.013006| +cv_get_call_checker_flags|5.027003|5.027003| +CvGV|5.003007|5.003007| +cvgv_from_hek|||ciu +cvgv_set|5.013003||cViu +CvGV_set|5.013003||Viu +CvHASEVAL|5.017002||Viu +CvHASEVAL_off|5.017002||Viu +CvHASEVAL_on|5.017002||Viu +CvHASGV|5.021004||Viu +CvHSCXT|5.021006||Viu +CvISXSUB|5.009004||Viu +CvISXSUB_off|5.009004||Viu +CvISXSUB_on|5.009004||Viu +CvLEXICAL|5.021004||Viu +CvLEXICAL_off|5.021004||Viu +CvLEXICAL_on|5.021004||Viu +CvLVALUE|5.006000||Viu +CvLVALUE_off|5.006000||Viu +CvLVALUE_on|5.006000||Viu +CvMETHOD|5.005000||Viu +CvMETHOD_off|5.005000||Viu +CvMETHOD_on|5.005000||Viu +cv_name|5.021005|5.021005| +CvNAMED|5.017004||Viu +CvNAMED_off|5.017004||Viu +CvNAMED_on|5.017004||Viu +CvNAME_HEK_set|5.017004||Viu +CV_NAME_NOTQUAL|5.021005|5.021005| +CvNODEBUG|5.004000||Viu +CvNODEBUG_off|5.004000||Viu +CvNODEBUG_on|5.004000||Viu +CvOUTSIDE|5.003007||Viu +CvOUTSIDE_SEQ|5.008001||Viu +CvPADLIST|5.008001|5.008001|x +CvPADLIST_set|5.021006||Viu +CvPROTO|5.015004||Viu +CvPROTOLEN|5.015004||Viu +CvROOT|5.003007||Viu +cv_set_call_checker|5.013006|5.013006| +cv_set_call_checker_flags|5.021004|5.021004| +CvSIGNATURE|5.035009||Viu +CvSIGNATURE_off|5.035009||Viu +CvSIGNATURE_on|5.035009||Viu +CvSLABBED|5.017002||Viu +CvSLABBED_off|5.017002||Viu +CvSLABBED_on|5.017002||Viu +CvSPECIAL|5.005003||Viu +CvSPECIAL_off|5.005003||Viu +CvSPECIAL_on|5.005003||Viu +CvSTART|5.003007||Viu +CvSTASH|5.003007|5.003007| +cvstash_set|5.013007||cViu +CvSTASH_set|5.013007||Viu +cv_undef|5.003007|5.003007| +cv_undef_flags|5.021004||Viu +CV_UNDEF_KEEP_NAME|5.021004||Viu +CvUNIQUE|5.004000||Viu +CvUNIQUE_off|5.004000||Viu +CvUNIQUE_on|5.004000||Viu +CvWEAKOUTSIDE|5.008001||Vi +CvWEAKOUTSIDE_off|5.008001||Viu +CvWEAKOUTSIDE_on|5.008001||Viu +CvXSUB|5.003007||Viu +CvXSUBANY|5.003007||Viu +CX_CUR|5.023008||Viu +CX_CURPAD_SAVE|5.008001||Vi +CX_CURPAD_SV|5.008001||Vi +CX_DEBUG|5.023008||Viu +cx_dump|5.003007||cVu +cx_dup|5.006000||cVu +CxEVALBLOCK|5.033007||Viu +CxEVAL_TXT_REFCNTED|5.025007||Viu +CxFOREACH|5.009003||Viu +CxHASARGS|5.010001||Viu +cxinc|5.003007||cVu +CXINC|5.003007||Viu +CxITERVAR|5.006000||Viu +CxLABEL|5.010001||Viu +CxLABEL_len|5.016000||Viu +CxLABEL_len_flags|5.016000||Viu +CX_LEAVE_SCOPE|5.023008||Viu +CxLVAL|5.010001||Viu +CxMULTICALL|5.009003||Viu +CxOLD_IN_EVAL|5.010001||Viu +CxOLD_OP_TYPE|5.010001||Viu +CxONCE|5.010001||Viu +CxPADLOOP|5.006000||Viu +CXp_EVALBLOCK|5.033007||Viu +CXp_FINALLY|5.035008||Viu +CXp_FOR_DEF|5.027008||Viu +CXp_FOR_GV|5.023008||Viu +CXp_FOR_LVREF|5.021005||Viu +CXp_FOR_PAD|5.023008||Viu +CXp_HASARGS|5.011000||Viu +CXp_MULTICALL|5.009003||Viu +CXp_ONCE|5.011000||Viu +CX_POP|5.023008||Viu +cx_popblock|5.023008||xcVu +cx_popeval|5.023008||xcVu +cx_popformat|5.023008||xcVu +cx_popgiven|5.027008||xcVu +cx_poploop|5.023008||xcVu +CX_POP_SAVEARRAY|5.023008||Viu +cx_popsub|5.023008||xcVu +cx_popsub_args|5.023008||xcVu +cx_popsub_common|5.023008||xcVu +CX_POPSUBST|5.023008||Viu +cx_popwhen|5.027008||xcVu +CXp_REAL|5.005003||Viu +CXp_SUB_RE|5.018000||Viu +CXp_SUB_RE_FAKE|5.018000||Viu +CXp_TRY|5.033007||Viu +CXp_TRYBLOCK|5.006000||Viu +cx_pushblock|5.023008||xcVu +cx_pusheval|5.023008||xcVu +cx_pushformat|5.023008||xcVu +cx_pushgiven|5.027008||xcVu +cx_pushloop_for|5.023008||xcVu +cx_pushloop_plain|5.023008||xcVu +cx_pushsub|5.023008||xcVu +CX_PUSHSUB_GET_LVALUE_MASK|5.023008||Viu +CX_PUSHSUBST|5.023008||Viu +cx_pushtry|5.033007||xcVu +cx_pushwhen|5.027008||xcVu +CxREALEVAL|5.005003||Viu +cxstack|5.005000||Viu +cxstack_ix|5.005000||Viu +cxstack_max|5.005000||Viu +CXt_BLOCK|5.003007||Viu +CXt_DEFER|5.035004||Viu +CXt_EVAL|5.003007||Viu +CXt_FORMAT|5.006000||Viu +CXt_GIVEN|5.027008||Viu +CXt_LOOP_ARY|5.023008||Viu +CXt_LOOP_LAZYIV|5.011000||Viu +CXt_LOOP_LAZYSV|5.011000||Viu +CXt_LOOP_LIST|5.023008||Viu +CXt_LOOP_PLAIN|5.011000||Viu +CXt_NULL|5.003007||Viu +cx_topblock|5.023008||xcVu +CxTRY|5.033007||Viu +CxTRYBLOCK|5.006000||Viu +CXt_SUB|5.003007||Viu +CXt_SUBST|5.003007||Viu +CXt_WHEN|5.027008||Viu +CxTYPE|5.005003||Viu +cx_type|5.009005||Viu +CxTYPE_is_LOOP|5.011000||Viu +CXTYPEMASK|5.005003||Viu +dATARGET|5.003007||Viu +dAX|5.007002|5.003007|p +dAXMARK|5.009003|5.003007|p +DAY_1|5.027010||Viu +DAY_2|5.027010||Viu +DAY_3|5.027010||Viu +DAY_4|5.027010||Viu +DAY_5|5.027010||Viu +DAY_6|5.027010||Viu +DAY_7|5.027010||Viu +DB_Hash_t|5.003007|5.003007|Vn +DBM_ckFilter|5.008001||Viu +DBM_setFilter|5.008001||Viu +DB_Prefix_t|5.003007|5.003007|Vn +DBVARMG_COUNT|5.021005||Viu +DBVARMG_SIGNAL|5.021005||Viu +DBVARMG_SINGLE|5.021005||Viu +DBVARMG_TRACE|5.021005||Viu +DB_VERSION_MAJOR_CFG|5.007002|5.007002|Vn +DB_VERSION_MINOR_CFG|5.007002|5.007002|Vn +DB_VERSION_PATCH_CFG|5.007002|5.007002|Vn +deb|5.003007||vVu +deb_curcv|5.007002||Viu +deb_nocontext|5.006000||vVnu +debop|5.005000|5.005000|u +debprof|5.005000||Viu +debprofdump|5.005000|5.005000|u +debstack|5.007003|5.007003|u +deb_stack_all|5.008001||Viu +deb_stack_n|5.008001||Viu +debstackptrs|5.007003|5.007003|u +DEBUG|5.003007||Viu +DEBUG_A|5.009001||Viu +DEBUG_A_FLAG|5.009001||Viu +DEBUG_A_TEST|5.009001||Viu +DEBUG_B|5.011000||Viu +DEBUG_B_FLAG|5.011000||Viu +DEBUG_BOTH_FLAGS_TEST|5.033007||Viu +DEBUG_B_TEST|5.011000||Viu +DEBUG_BUFFERS_r|5.009005||Viu +DEBUG_c|5.003007||Viu +DEBUG_C|5.009000||Viu +DEBUG_c_FLAG|5.007001||Viu +DEBUG_C_FLAG|5.009000||Viu +DEBUG_COMPILE_r|5.009002||Viu +DEBUG_c_TEST|5.007001||Viu +DEBUG_C_TEST|5.009000||Viu +DEBUG_D|5.003007||Viu +DEBUG_DB_RECURSE_FLAG|5.007001||Viu +DEBUG_D_FLAG|5.007001||Viu +DEBUG_D_TEST|5.007001||Viu +DEBUG_DUMP_PRE_OPTIMIZE_r|5.031004||Viu +DEBUG_DUMP_r|5.009004||Viu +DEBUG_EXECUTE_r|5.009002||Viu +DEBUG_EXTRA_r|5.009004||Viu +DEBUG_f|5.003007||Viu +DEBUG_f_FLAG|5.007001||Viu +DEBUG_FLAGS_r|5.009005||Viu +DEBUG_f_TEST|5.007001||Viu +DEBUG_GPOS_r|5.011000||Viu +DEBUG_i|5.025002||Viu +DEBUG_i_FLAG|5.025002||Viu +DEBUG_INTUIT_r|5.009004||Viu +DEBUG_i_TEST|5.025002||Viu +DEBUG_J_FLAG|5.007003||Viu +DEBUG_J_TEST|5.007003||Viu +DEBUG_l|5.003007||Viu +DEBUG_L|5.019009||Viu +DEBUG_l_FLAG|5.007001||Viu +DEBUG_L_FLAG|5.019009||Viu +DEBUG_l_TEST|5.007001||Viu +DEBUG_L_TEST|5.019009||Viu +DEBUG_Lv|5.023003||Viu +DEBUG_Lv_TEST|5.023003||Viu +DEBUG_m|5.003007||Viu +DEBUG_M|5.027008||Viu +DEBUG_MASK|5.007001||Viu +DEBUG_MATCH_r|5.009004||Viu +DEBUG_m_FLAG|5.007001||Viu +DEBUG_M_FLAG|5.027008||Viu +DEBUG_m_TEST|5.007001||Viu +DEBUG_M_TEST|5.027008||Viu +DEBUG_o|5.003007||Viu +DEBUG_o_FLAG|5.007001||Viu +DEBUG_OPTIMISE_MORE_r|5.009005||Viu +DEBUG_OPTIMISE_r|5.009002||Viu +DEBUG_o_TEST|5.007001||Viu +DEBUG_P|5.003007||Viu +DEBUG_p|5.003007||Viu +DEBUG_PARSE_r|5.009004||Viu +DEBUG_P_FLAG|5.007001||Viu +DEBUG_p_FLAG|5.007001||Viu +DEBUG_POST_STMTS|5.033008||Viu +DEBUG_PRE_STMTS|5.033008||Viu +DEBUG_P_TEST|5.007001||Viu +DEBUG_p_TEST|5.007001||Viu +DEBUG_Pv|5.013008||Viu +DEBUG_Pv_TEST|5.013008||Viu +DEBUG_q|5.009001||Viu +DEBUG_q_FLAG|5.009001||Viu +DEBUG_q_TEST|5.009001||Viu +DEBUG_r|5.003007||Viu +DEBUG_R|5.007001||Viu +DEBUG_R_FLAG|5.007001||Viu +DEBUG_r_FLAG|5.007001||Viu +DEBUG_R_TEST|5.007001||Viu +DEBUG_r_TEST|5.007001||Viu +DEBUG_s|5.003007||Viu +DEBUG_S|5.017002||Viu +DEBUG_SBOX32_HASH|5.027001||Viu +DEBUG_SCOPE|5.008001||Viu +DEBUG_s_FLAG|5.007001||Viu +DEBUG_S_FLAG|5.017002||Viu +DEBUG_STACK_r|5.009005||Viu +debug_start_match|5.009004||Viu +DEBUG_STATE_r|5.009004||Viu +DEBUG_s_TEST|5.007001||Viu +DEBUG_S_TEST|5.017002||Viu +DEBUG_t|5.003007||Viu +DEBUG_T|5.007001||Viu +DEBUG_TEST_r|5.021005||Viu +DEBUG_T_FLAG|5.007001||Viu +DEBUG_t_FLAG|5.007001||Viu +DEBUG_TOP_FLAG|5.007001||Viu +DEBUG_TRIE_COMPILE_MORE_r|5.009002||Viu +DEBUG_TRIE_COMPILE_r|5.009002||Viu +DEBUG_TRIE_EXECUTE_MORE_r|5.009002||Viu +DEBUG_TRIE_EXECUTE_r|5.009002||Viu +DEBUG_TRIE_r|5.009002||Viu +DEBUG_T_TEST|5.007001||Viu +DEBUG_t_TEST|5.007001||Viu +DEBUG_u|5.003007||Viu +DEBUG_U|5.009005||Viu +DEBUG_u_FLAG|5.007001||Viu +DEBUG_U_FLAG|5.009005||Viu +DEBUG_u_TEST|5.007001||Viu +DEBUG_U_TEST|5.009005||Viu +DEBUG_Uv|5.009005||Viu +DEBUG_Uv_TEST|5.009005||Viu +DEBUG_v|5.008001||Viu +DEBUG_v_FLAG|5.008001||Viu +DEBUG_v_TEST|5.008001||Viu +DEBUG_X|5.003007||Viu +DEBUG_x|5.003007||Viu +DEBUG_X_FLAG|5.007001||Viu +DEBUG_x_FLAG|5.007001||Viu +DEBUG_X_TEST|5.007001||Viu +DEBUG_x_TEST|5.007001||Viu +DEBUG_Xv|5.008001||Viu +DEBUG_Xv_TEST|5.008001||Viu +DEBUG_y|5.031007||Viu +DEBUG_y_FLAG|5.031007||Viu +DEBUG_y_TEST|5.031007||Viu +DEBUG_yv|5.031007||Viu +DEBUG_yv_TEST|5.031007||Viu +DEBUG_ZAPHOD32_HASH|5.027001||Viu +DECLARATION_FOR_LC_NUMERIC_MANIPULATION|5.021010|5.021010|p +DECLARE_AND_GET_RE_DEBUG_FLAGS|5.031011||Viu +DECLARE_AND_GET_RE_DEBUG_FLAGS_NON_REGEX|5.031011||Viu +DEFAULT_INC_EXCLUDES_DOT|5.025011|5.025011|Vn +DEFAULT_PAT_MOD|5.013006||Viu +defelem_target|5.019002||Viu +DEFINE_INC_MACROS|5.027006||Viu +DEFINEP|5.009005||Viu +DEFINEP_t8|5.035004||Viu +DEFINEP_t8_p8|5.033003||Viu +DEFINEP_t8_pb|5.033003||Viu +DEFINEP_tb|5.035004||Viu +DEFINEP_tb_p8|5.033003||Viu +DEFINEP_tb_pb|5.033003||Viu +DEFSV|5.004005|5.003007|p +DEFSV_set|5.010001|5.003007|p +del_body_by_type|||Viu +delete_eval_scope|5.009004||xViu +delimcpy|5.004000|5.004000|n +delimcpy_no_escape|5.025005||cVni +DEL_NATIVE|5.017010||Viu +del_sv|5.005000||Viu +DEPENDS_PAT_MOD|5.013009||Viu +DEPENDS_PAT_MODS|5.013009||Viu +deprecate|5.011001||Viu +deprecate_disappears_in|5.025009||Viu +deprecate_fatal_in|5.025009||Viu +despatch_signals|5.007001||cVu +destroy_matcher|5.027008||Viu +DETACH|5.005000||Viu +dEXT|5.003007||Viu +dEXTCONST|5.004000||Viu +DFA_RETURN_FAILURE|5.035004||Viu +DFA_RETURN_SUCCESS|5.035004||Viu +DFA_TEASE_APART_FF|5.035004||Viu +D_FMT|5.027010||Viu +DIE|5.003007||Viu +die|5.003007||vV +die_nocontext|5.006000||vVn +die_sv|5.013001|5.003007|p +die_unwind|5.013001||Viu +Direntry_t|5.003007|5.003007|Vn +dirp_dup|5.013007|5.013007|u +dITEMS|5.007002|5.003007|p +div128|5.005000||Viu +dJMPENV|5.004000||Viu +djSP|5.004005||Vi +dMARK|5.003007|5.003007| +DM_ARRAY_ISA|5.013002||Viu +DM_DELAY|5.003007||Viu +DM_EGID|5.003007||Viu +DM_EUID|5.003007||Viu +DM_GID|5.003007||Viu +DM_RGID|5.003007||Viu +DM_RUID|5.003007||Viu +DM_UID|5.003007||Viu +dMULTICALL|5.009003|5.009003| +dMY_CXT|5.009000|5.009000|p +dMY_CXT_INTERP|5.009003||Viu +dMY_CXT_SV|5.007003|5.003007|pV +dNOOP|5.006000|5.003007|p +do_aexec|5.009003||Viu +do_aexec5|5.006000||Viu +do_aspawn|5.008000||Vu +do_binmode|5.004005|5.004005|du +docatch|5.005000||Vi +do_chomp|5.003007||Viu +do_close|5.003007|5.003007|u +do_delete_local|5.011000||Viu +do_dump_pad|5.008001||Vi +do_eof|5.003007||Viu +does_utf8_overflow|5.025006||Vniu +doeval_compile|5.023008||Viu +do_exec3|5.006000||Viu +do_exec|5.009003||Viu +dofile|5.005003||Viu +dofindlabel|5.003007||Viu +doform|5.005000||Viu +do_gv_dump|5.006000||cVu +do_gvgv_dump|5.006000||cVu +do_hv_dump|5.006000||cVu +doing_taint|5.008001||cVnu +DOINIT|5.003007||Viu +do_ipcctl|5.003007||Viu +do_ipcget|5.003007||Viu +do_join|5.003007|5.003007|u +do_magic_dump|5.006000||cVu +do_msgrcv|5.003007||Viu +do_msgsnd|5.003007||Viu +do_ncmp|5.015001||Viu +do_oddball|5.006000||Viu +dooneliner|5.006000||Viu +do_op_dump|5.006000||cVu +do_open|5.003007|5.003007|u +do_open6|5.019010||xViu +do_open9|5.006000|5.006000|du +do_openn|5.007001|5.007001|u +doopen_pm|5.008001||Viu +do_open_raw|5.019010||xViu +doparseform|5.005000||Viu +do_pmop_dump|5.006000||cVu +dopoptoeval|5.003007||Viu +dopoptogivenfor|5.027008||Viu +dopoptolabel|5.005000||Viu +dopoptoloop|5.005000||Viu +dopoptosub_at|5.005000||Viu +dopoptowhen|5.027008||Viu +do_print|5.003007||Viu +do_readline|5.003007||Viu +doref|5.009003|5.009003|u +dORIGMARK|5.003007|5.003007| +do_seek|5.003007||Viu +do_semop|5.003007||Viu +do_shmio|5.003007||Viu +DOSISH|5.003007||Viu +do_smartmatch|5.027008||Viu +do_spawn|5.008000||Vu +do_spawn_nowait|5.008000||Vu +do_sprintf|5.003007|5.003007|u +do_sv_dump|5.006000||cVu +do_sysseek|5.004000||Viu +do_tell|5.003007||Viu +do_trans|5.003007||Viu +do_trans_complex|5.006001||Viu +do_trans_count|5.006001||Viu +do_trans_count_invmap|5.031006||Viu +do_trans_invmap|5.031006||Viu +do_trans_simple|5.006001||Viu +DOUBLE_BIG_ENDIAN|5.021009||Viu +DOUBLE_HAS_INF|5.025003|5.025003|Vn +DOUBLE_HAS_NAN|5.025003|5.025003|Vn +DOUBLE_HAS_NEGATIVE_ZERO|5.025007|5.025007|Vn +DOUBLE_HAS_SUBNORMALS|5.025007|5.025007|Vn +DOUBLEINFBYTES|5.023000|5.023000|Vn +DOUBLE_IS_CRAY_SINGLE_64_BIT|5.025006|5.025006|Vn +DOUBLE_IS_IBM_DOUBLE_64_BIT|5.025006|5.025006|Vn +DOUBLE_IS_IBM_SINGLE_32_BIT|5.025006|5.025006|Vn +DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_32_BIT_BIG_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_32_BIT_LITTLE_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_64_BIT_BIG_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_64_BIT_LITTLE_ENDIAN|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_BE_LE|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_LE_BE|5.021006|5.021006|Vn +DOUBLE_IS_IEEE_FORMAT|5.025003||Viu +DOUBLE_IS_UNKNOWN_FORMAT|5.021006|5.021006|Vn +DOUBLE_IS_VAX_D_FLOAT|5.025003|5.025003|Vn +DOUBLE_IS_VAX_F_FLOAT|5.025003|5.025003|Vn +DOUBLE_IS_VAX_FLOAT|5.025003||Viu +DOUBLE_IS_VAX_G_FLOAT|5.025003|5.025003|Vn +DOUBLEKIND|5.021006|5.021006|Vn +DOUBLE_LITTLE_ENDIAN|5.021009||Viu +DOUBLEMANTBITS|5.023000|5.023000|Vn +DOUBLE_MIX_ENDIAN|5.021009||Viu +DOUBLENANBYTES|5.023000|5.023000|Vn +DOUBLESIZE|5.005000|5.005000|Vn +DOUBLE_STYLE_IEEE|5.025007|5.025007|Vn +DOUBLE_VAX_ENDIAN|5.025003||Viu +do_uniprop_match|5.031011||cVniu +dounwind|5.003007|5.003007|u +DO_UTF8|5.006000|5.006000| +do_vecget|5.006000||Viu +do_vecset|5.003007||Viu +do_vop|5.003007||Viu +dowantarray|5.003007|5.003007|u +dPOPiv|5.003007||Viu +dPOPnv|5.003007||Viu +dPOPnv_nomg|5.013002||Viu +dPOPPOPiirl|5.003007||Viu +dPOPPOPnnrl|5.003007||Viu +dPOPPOPssrl|5.003007||Viu +dPOPss|5.003007||Viu +dPOPTOPiirl|5.003007||Viu +dPOPTOPiirl_nomg|5.013002||Viu +dPOPTOPiirl_ul_nomg|5.013002||Viu +dPOPTOPnnrl|5.003007||Viu +dPOPTOPnnrl_nomg|5.013002||Viu +dPOPTOPssrl|5.003007||Viu +dPOPuv|5.004000||Viu +dPOPXiirl|5.004000||Viu +dPOPXiirl_ul_nomg|5.013002||Viu +dPOPXnnrl|5.004000||Viu +dPOPXssrl|5.004000||Viu +DPTR2FPTR|5.009003||Viu +Drand01|5.006000|5.006000| +drand48_init_r|||cniu +drand48_r|||cniu +DRAND48_R_PROTO|5.008000|5.008000|Vn +dSAVEDERRNO|5.010001||Vi +dSAVE_ERRNO|5.010001||Vi +dSP|5.003007|5.003007| +dSS_ADD|5.017007||Viu +dTARG|5.003007||Viu +dTARGET|5.003007|5.003007| +dTARGETSTACKED|5.003007||Viu +D_T_FMT|5.027010||Viu +dTHR|5.004005|5.003007|p +dTHX|5.003007|5.003007|p +dTHXa|5.006000|5.003007|p +dTHX_DEBUGGING|5.027009||Viu +dTHXo|5.006000||Viu +dTHXoa|5.006001|5.003007|p +dTHXR||5.003007|ponu +dTHXs|5.007002||Viu +dTHXx|5.006000||Viu +dTOPiv|5.003007||Viu +dTOPnv|5.003007||Viu +dTOPss|5.003007||Viu +dTOPuv|5.004000||Viu +dtrace_probe_call|||ciu +dtrace_probe_load|||ciu +dtrace_probe_op|||ciu +dtrace_probe_phase|||ciu +dump_all|5.006000|5.006000| +dump_all_perl|5.011000||Viu +dump_c_backtrace|5.021001||V +dump_eval|5.006000|5.006000|u +dump_exec_pos|5.009004||Viu +dump_form|5.006000|5.006000|u +dump_indent|5.006000||vcVu +dump_mstats|5.003007||Vu +dump_packsubs|5.006000|5.006000| +dump_packsubs_perl|5.011000||Viu +dump_regex_sets_structures|5.025006||Viu +dump_sub|5.006000|5.006000|u +dump_sub_perl|5.011000||Viu +dump_sv_child|5.009003||Viu +dump_trie|5.009004||Viu +dump_trie_interim_list|5.009004||Viu +dump_trie_interim_table|5.009004||Viu +dumpuntil|5.005000||Viu +dump_vindent|5.006000||cVu +dUNDERBAR|5.009002|5.003007|p +dup2|5.005000||Viu +dup|5.005000||Viu +dup_attrlist|5.006000||Viu +DUP_WARNINGS|5.009004||Viu +dup_warnings|||ciu +dVAR|5.009003|5.003007|p +dXCPT|5.009002|5.003007|p +dXSARGS|5.003007|5.003007| +dXSBOOTARGSAPIVERCHK|5.021006||Viu +dXSBOOTARGSNOVERCHK|5.021006||Viu +dXSBOOTARGSXSAPIVERCHK|5.021006||Viu +dXSFUNCTION|5.005000||Viu +dXSI32|5.003007|5.003007|V +dXSTARG|5.006000|5.003007|poVnu +dXSUB_SYS|5.003007||Viu +edit_distance|5.023008||Vniu +EIGHT_BIT_UTF8_TO_NATIVE|5.023003||Viu +ELEMENT_RANGE_MATCHES_INVLIST|5.023002||Viu +EMBEDMYMALLOC|5.006000||Viu +emulate_cop_io|||xciu +emulate_setlocale|5.027009||Vniu +END|5.003007||Viu +END_EXTERN_C|5.005000|5.003007|pV +endgrent|5.009000||Viu +ENDGRENT_R_HAS_FPTR|5.008000||Viu +ENDGRENT_R_PROTO|5.008000|5.008000|Vn +endhostent|5.005000||Viu +ENDHOSTENT_R_PROTO|5.008000|5.008000|Vn +ENDLIKE|5.009005||Viu +ENDLIKE_t8|5.035004||Viu +ENDLIKE_t8_p8|5.033003||Viu +ENDLIKE_t8_pb|5.033003||Viu +ENDLIKE_tb|5.035004||Viu +ENDLIKE_tb_p8|5.033003||Viu +ENDLIKE_tb_pb|5.033003||Viu +endnetent|5.005000||Viu +ENDNETENT_R_PROTO|5.008000|5.008000|Vn +endprotoent|5.005000||Viu +ENDPROTOENT_R_PROTO|5.008000|5.008000|Vn +endpwent|5.009000||Viu +ENDPWENT_R_HAS_FPTR|5.008000||Viu +ENDPWENT_R_PROTO|5.008000|5.008000|Vn +endservent|5.005000||Viu +ENDSERVENT_R_PROTO|5.008000|5.008000|Vn +END_t8|5.035004||Viu +END_t8_p8|5.033003||Viu +END_t8_pb|5.033003||Viu +END_tb|5.035004||Viu +END_tb_p8|5.033003||Viu +END_tb_pb|5.033003||Viu +ENTER|5.003007|5.003007| +ENTER_with_name|5.011002|5.011002| +ENV_INIT|5.031011||Viu +environ|5.003007||Viu +ENV_LOCALE_LOCK|5.031011||Viu +ENV_LOCALE_READ_LOCK|5.031011||Viu +ENV_LOCALE_READ_UNLOCK|5.031011||Viu +ENV_LOCALE_UNLOCK|5.031011||Viu +ENV_LOCK|5.031011||Viu +ENV_READ_LOCK|5.033005||Viu +ENV_READ_UNLOCK|5.033005||Viu +ENV_TERM|5.031011||Viu +ENV_UNLOCK|5.031011||Viu +EOF|5.003007||Viu +EOF_NONBLOCK|5.003007|5.003007|Vn +EOL|5.003007||Viu +EOL_t8|5.035004||Viu +EOL_t8_p8|5.033003||Viu +EOL_t8_pb|5.033003||Viu +EOL_tb|5.035004||Viu +EOL_tb_p8|5.033003||Viu +EOL_tb_pb|5.033003||Viu +EOS|5.005000||Viu +EOS_t8|5.035004||Viu +EOS_t8_p8|5.033003||Viu +EOS_t8_pb|5.033003||Viu +EOS_tb|5.035004||Viu +EOS_tb_p8|5.033003||Viu +EOS_tb_pb|5.033003||Viu +ERA|5.027010||Viu +ERA_D_FMT|5.027010||Viu +ERA_D_T_FMT|5.027010||Viu +ERA_T_FMT|5.027010||Viu +ERRSV|5.004005|5.003007|p +ESC_NATIVE|5.021004||Viu +EVAL|5.005000||Viu +EVAL_B|5.025010||Viu +EVAL_B_fail|5.025010||Viu +EVAL_B_fail_t8|5.035004||Viu +EVAL_B_fail_t8_p8|5.033003||Viu +EVAL_B_fail_t8_pb|5.033003||Viu +EVAL_B_fail_tb|5.035004||Viu +EVAL_B_fail_tb_p8|5.033003||Viu +EVAL_B_fail_tb_pb|5.033003||Viu +EVAL_B_t8|5.035004||Viu +EVAL_B_t8_p8|5.033003||Viu +EVAL_B_t8_pb|5.033003||Viu +EVAL_B_tb|5.035004||Viu +EVAL_B_tb_p8|5.033003||Viu +EVAL_B_tb_pb|5.033003||Viu +EVAL_INEVAL|5.006000||Viu +EVAL_INREQUIRE|5.007001||Viu +EVAL_KEEPERR|5.006000||Viu +EVAL_NULL|5.006000||Viu +EVAL_postponed_AB|5.025010||Viu +EVAL_postponed_AB_fail|5.025010||Viu +EVAL_postponed_AB_fail_t8|5.035004||Viu +EVAL_postponed_AB_fail_t8_p8|5.033003||Viu +EVAL_postponed_AB_fail_t8_pb|5.033003||Viu +EVAL_postponed_AB_fail_tb|5.035004||Viu +EVAL_postponed_AB_fail_tb_p8|5.033003||Viu +EVAL_postponed_AB_fail_tb_pb|5.033003||Viu +EVAL_postponed_AB_t8|5.035004||Viu +EVAL_postponed_AB_t8_p8|5.033003||Viu +EVAL_postponed_AB_t8_pb|5.033003||Viu +EVAL_postponed_AB_tb|5.035004||Viu +EVAL_postponed_AB_tb_p8|5.033003||Viu +EVAL_postponed_AB_tb_pb|5.033003||Viu +eval_pv|5.006000|5.003007|p +EVAL_RE_REPARSING|5.017011||Viu +eval_sv|5.006000|5.003007|p +EVAL_t8|5.035004||Viu +EVAL_t8_p8|5.033003||Viu +EVAL_t8_pb|5.033003||Viu +EVAL_tb|5.035004||Viu +EVAL_tb_p8|5.033003||Viu +EVAL_tb_pb|5.033003||Viu +EVAL_WARNONLY|5.006000||Viu +EXACT|5.004000||Viu +EXACTF|5.004000||Viu +EXACTFAA|5.027009||Viu +EXACTFAA_NO_TRIE|5.027009||Viu +EXACTFAA_NO_TRIE_t8|5.035004||Viu +EXACTFAA_NO_TRIE_t8_p8|5.033003||Viu +EXACTFAA_NO_TRIE_t8_pb|5.033003||Viu +EXACTFAA_NO_TRIE_tb|5.035004||Viu +EXACTFAA_NO_TRIE_tb_p8|5.033003||Viu +EXACTFAA_NO_TRIE_tb_pb|5.033003||Viu +EXACTFAA_t8|5.035004||Viu +EXACTFAA_t8_p8|5.033003||Viu +EXACTFAA_t8_pb|5.033003||Viu +EXACTFAA_tb|5.035004||Viu +EXACTFAA_tb_p8|5.033003||Viu +EXACTFAA_tb_pb|5.033003||Viu +EXACTFL|5.004000||Viu +EXACTFL_t8|5.035004||Viu +EXACTFL_t8_p8|5.033003||Viu +EXACTFL_t8_pb|5.033003||Viu +EXACTFL_tb|5.035004||Viu +EXACTFL_tb_p8|5.033003||Viu +EXACTFL_tb_pb|5.033003||Viu +EXACTFLU8|5.021008||Viu +EXACTFLU8_t8|5.035004||Viu +EXACTFLU8_t8_p8|5.033003||Viu +EXACTFLU8_t8_pb|5.033003||Viu +EXACTFLU8_tb|5.035004||Viu +EXACTFLU8_tb_p8|5.033003||Viu +EXACTFLU8_tb_pb|5.033003||Viu +EXACTF_t8|5.035004||Viu +EXACTF_t8_p8|5.033003||Viu +EXACTF_t8_pb|5.033003||Viu +EXACTF_tb|5.035004||Viu +EXACTF_tb_p8|5.033003||Viu +EXACTF_tb_pb|5.033003||Viu +EXACTFU|5.013008||Viu +EXACTFUP|5.029007||Viu +EXACTFUP_t8|5.035004||Viu +EXACTFUP_t8_p8|5.033003||Viu +EXACTFUP_t8_pb|5.033003||Viu +EXACTFUP_tb|5.035004||Viu +EXACTFUP_tb_p8|5.033003||Viu +EXACTFUP_tb_pb|5.033003||Viu +EXACTFU_REQ8|5.031006||Viu +EXACTFU_REQ8_t8|5.035004||Viu +EXACTFU_REQ8_t8_p8|5.033003||Viu +EXACTFU_REQ8_t8_pb|5.033003||Viu +EXACTFU_REQ8_tb|5.035004||Viu +EXACTFU_REQ8_tb_p8|5.033003||Viu +EXACTFU_REQ8_tb_pb|5.033003||Viu +EXACTFU_S_EDGE|5.029007||Viu +EXACTFU_S_EDGE_t8|5.035004||Viu +EXACTFU_S_EDGE_t8_p8|5.033003||Viu +EXACTFU_S_EDGE_t8_pb|5.033003||Viu +EXACTFU_S_EDGE_tb|5.035004||Viu +EXACTFU_S_EDGE_tb_p8|5.033003||Viu +EXACTFU_S_EDGE_tb_pb|5.033003||Viu +EXACTFU_t8|5.035004||Viu +EXACTFU_t8_p8|5.033003||Viu +EXACTFU_t8_pb|5.033003||Viu +EXACTFU_tb|5.035004||Viu +EXACTFU_tb_p8|5.033003||Viu +EXACTFU_tb_pb|5.033003||Viu +EXACTL|5.021008||Viu +EXACTL_t8|5.035004||Viu +EXACTL_t8_p8|5.033003||Viu +EXACTL_t8_pb|5.033003||Viu +EXACTL_tb|5.035004||Viu +EXACTL_tb_p8|5.033003||Viu +EXACTL_tb_pb|5.033003||Viu +EXACT_REQ8|5.031006||Viu +EXACT_REQ8_t8|5.035004||Viu +EXACT_REQ8_t8_p8|5.033003||Viu +EXACT_REQ8_t8_pb|5.033003||Viu +EXACT_REQ8_tb|5.035004||Viu +EXACT_REQ8_tb_p8|5.033003||Viu +EXACT_REQ8_tb_pb|5.033003||Viu +EXACT_t8|5.035004||Viu +EXACT_t8_p8|5.033003||Viu +EXACT_t8_pb|5.033003||Viu +EXACT_tb|5.035004||Viu +EXACT_tb_p8|5.033003||Viu +EXACT_tb_pb|5.033003||Viu +EXEC_ARGV_CAST|5.007001||Viu +exec_failed|5.009004||Viu +execl|5.005000||Viu +EXEC_PAT_MOD|5.009005||Viu +EXEC_PAT_MODS|5.009005||Viu +execute_wildcard|5.031010||Viu +execv|5.005000||Viu +execvp|5.005000||Viu +exit|5.005000||Viu +EXPECT|5.009004||Viu +expect_number|5.007001||Viu +EXT|5.003007||Viu +EXTCONST|5.004000||Viu +EXTEND|5.003007|5.003007| +EXTEND_HWM_SET|5.027002||Viu +EXTEND_MORTAL|5.004000||Viu +EXTEND_SKIP|5.027002||Viu +EXTERN_C|5.005000|5.003007|pV +EXT_MGVTBL|5.009004||Viu +EXT_PAT_MODS|5.009005||Viu +EXTRA_SIZE|5.005000||Viu +EXTRA_STEP_2ARGS|5.005000||Viu +F0convert|5.009003||Vniu +FAKE_BIT_BUCKET|5.009005||Viu +FAKE_DEFAULT_SIGNAL_HANDLERS|5.009003||Viu +FAKE_PERSISTENT_SIGNAL_HANDLERS|5.009003||Viu +FALSE|5.003007||Viu +FATAL_ABOVE_FF_MSG|5.027010||Viu +F_atan2_amg|5.004000||Viu +FBMcf_TAIL|5.006000||Viu +FBMcf_TAIL_DOLLAR|5.006000||Viu +FBMcf_TAIL_DOLLARM|5.006000||Viu +FBMcf_TAIL_Z|5.006000||Viu +FBMcf_TAIL_z|5.006000||Viu +fbm_compile|5.005000|5.005000| +fbm_instr|5.005000|5.005000| +FBMrf_MULTILINE|5.006000||Viu +fclose|5.003007||Viu +fcntl|5.006000||Viu +FCNTL_CAN_LOCK|5.007001|5.007001|Vn +F_cos_amg|5.004000||Viu +FD_CLR|5.008000||Viu +FD_ISSET|5.008000||Viu +fdopen|5.003007||Viu +FD_SET|5.008000||Viu +fd_set|5.008000||Viu +FD_ZERO|5.008000||Viu +FEATURE_BAREWORD_FILEHANDLES_BIT|5.033006||Viu +FEATURE_BAREWORD_FILEHANDLES_IS_ENABLED|5.033006||Viu +FEATURE_BITWISE_BIT|5.031006||Viu +FEATURE_BITWISE_IS_ENABLED|5.021009||Viu +FEATURE_BUNDLE_510|5.015007||Viu +FEATURE_BUNDLE_511|5.015007||Viu +FEATURE_BUNDLE_515|5.015007||Viu +FEATURE_BUNDLE_523|5.023001||Viu +FEATURE_BUNDLE_527|5.027008||Viu +FEATURE_BUNDLE_535|5.035003||Viu +FEATURE_BUNDLE_CUSTOM|5.015007||Viu +FEATURE_BUNDLE_DEFAULT|5.015007||Viu +FEATURE_DEFER_BIT|5.035004||Viu +FEATURE_DEFER_IS_ENABLED|5.035004||Viu +FEATURE_EVALBYTES_BIT|5.031006||Viu +FEATURE_EVALBYTES_IS_ENABLED|5.015007||Viu +FEATURE_FC_BIT|5.031006||Viu +FEATURE_FC_IS_ENABLED|5.015008||Viu +FEATURE_INDIRECT_BIT|5.031010||Viu +FEATURE_INDIRECT_IS_ENABLED|5.031010||Viu +FEATURE_ISA_BIT|5.031007||Viu +FEATURE_ISA_IS_ENABLED|5.031007||Viu +FEATURE_IS_ENABLED_MASK|5.031006||Viu +FEATURE_MULTIDIMENSIONAL_BIT|5.033001||Viu +FEATURE_MULTIDIMENSIONAL_IS_ENABLED|5.033001||Viu +FEATURE_MYREF_BIT|5.031006||Viu +FEATURE_MYREF_IS_ENABLED|5.025003||Viu +FEATURE_POSTDEREF_QQ_BIT|5.031006||Viu +FEATURE_POSTDEREF_QQ_IS_ENABLED|5.019005||Viu +FEATURE_REFALIASING_BIT|5.031006||Viu +FEATURE_REFALIASING_IS_ENABLED|5.021005||Viu +FEATURE_SAY_BIT|5.031006||Viu +FEATURE_SAY_IS_ENABLED|5.015007||Viu +FEATURE_SIGNATURES_BIT|5.031006||Viu +FEATURE_SIGNATURES_IS_ENABLED|5.019009||Viu +FEATURE_STATE_BIT|5.031006||Viu +FEATURE_STATE_IS_ENABLED|5.015007||Viu +FEATURE___SUB___BIT|5.031006||Viu +FEATURE___SUB___IS_ENABLED|5.015007||Viu +FEATURE_SWITCH_BIT|5.031006||Viu +FEATURE_SWITCH_IS_ENABLED|5.015007||Viu +FEATURE_TRY_BIT|5.033007||Viu +FEATURE_TRY_IS_ENABLED|5.033007||Viu +FEATURE_UNICODE_BIT|5.031006||Viu +FEATURE_UNICODE_IS_ENABLED|5.015007||Viu +FEATURE_UNIEVAL_BIT|5.031006||Viu +FEATURE_UNIEVAL_IS_ENABLED|5.015007||Viu +feof|5.003007||Viu +ferror|5.003007||Viu +FETCHFEATUREBITSHH|5.031006||Viu +F_exp_amg|5.004000||Viu +FF_0DECIMAL|5.007001||Viu +FF_BLANK|5.003007||Viu +FF_CHECKCHOP|5.003007||Viu +FF_CHECKNL|5.003007||Viu +FF_CHOP|5.003007||Viu +FF_DECIMAL|5.003007||Viu +FF_END|5.003007||Viu +FF_FETCH|5.003007||Viu +FF_HALFSPACE|5.003007||Viu +FF_ITEM|5.003007||Viu +FF_LINEGLOB|5.003007||Viu +FF_LINEMARK|5.003007||Viu +FF_LINESNGL|5.009001||Viu +FF_LITERAL|5.003007||Viu +Fflush|5.003007||Viu +fflush|5.003007||Viu +FFLUSH_NULL|5.006000|5.006000|Vn +FF_MORE|5.003007||Viu +FF_NEWLINE|5.003007||Viu +FF_SKIP|5.003007||Viu +FF_SPACE|5.003007||Viu +fgetc|5.003007||Viu +fgetpos|5.003007||Viu +fgets|5.003007||Viu +FILE|5.003007||Viu +FILE_base|5.007000|5.007000| +FILE_bufsiz|5.007000|5.007000| +FILE_cnt|5.007000|5.007000| +fileno|5.003007||Viu +FILE_ptr|5.007000|5.007000| +FILL_ADVANCE_NODE_2L_ARG|5.021005||Viu +FILL_ADVANCE_NODE|5.005000||Viu +FILL_ADVANCE_NODE_ARG|5.005000||Viu +FILL_ADVANCE_NODE_ARGp|5.031010||Viu +FILL_NODE|5.029004||Viu +filter_add|5.003007|5.003007| +FILTER_DATA|5.003007||Viu +filter_del|5.003007|5.003007|u +filter_gets|5.005000||Viu +FILTER_ISREADER|5.003007||Viu +filter_read|5.003007|5.003007| +FILTER_READ|5.003007||Viu +finalize_op|5.015002||Viu +finalize_optree|5.015002||Vi +find_and_forget_pmops|5.009005||Viu +find_array_subscript|5.009004||Viu +find_beginning|5.005000||Viu +find_byclass|5.006000||Viu +find_default_stash|5.019004||Viu +find_first_differing_byte_pos|5.031007||Vniu +find_hash_subscript|5.009004||Viu +find_in_my_stash|5.006001||Viu +find_lexical_cv|5.019001||Viu +find_next_masked|5.027009||Vniu +find_runcv|5.009005|5.009005| +FIND_RUNCV_level_eq|5.017002||Viu +FIND_RUNCV_padid_eq|5.017004||Viu +find_runcv_where|5.017002||Viu +find_rundefsv|5.013002|5.013002| +find_rundefsvoffset|5.009002|5.009002|d +find_script|5.004005||Viu +find_span_end|5.027009||Vniu +find_span_end_mask|5.027009||Vniu +find_uninit_var|5.009002||xVi +FIRST_NON_ASCII_DECIMAL_DIGIT|5.027007||Viu +first_symbol|5.009003||Vniu +FIT_ARENA0|||Viu +FIT_ARENAn|||Viu +FIT_ARENA|||Viu +FITS_IN_8_BITS|5.013005||Viu +fixup_errno_string|5.019007||Viu +FLAGS|5.013006||Viu +FLEXFILENAMES|5.003007|5.003007|Vn +float_end_shift|5.009005||Viu +float_max_offset|5.005000||Viu +float_min_offset|5.005000||Viu +float_substr|5.005000||Viu +float_utf8|5.008000||Viu +flock|5.005000||Viu +flockfile|5.003007||Viu +F_log_amg|5.004000||Viu +FmLINES|5.003007||Viu +fold_constants|5.003007||Viu +foldEQ|5.013002|5.013002|n +foldEQ_latin1|5.013008||cVnu +foldEQ_latin1_s2_folded|5.029007||Vniu +foldEQ_locale|5.013002|5.013002|n +FOLDEQ_LOCALE|5.019009||cV +FOLDEQ_S1_ALREADY_FOLDED|5.015004||cV +FOLDEQ_S1_FOLDS_SANE|5.021008||cV +FOLDEQ_S2_ALREADY_FOLDED|5.015004||cV +FOLDEQ_S2_FOLDS_SANE|5.021008||cV +foldEQ_utf8|5.013002|5.007003|p +foldEQ_utf8_flags|5.013010||cVu +FOLDEQ_UTF8_NOMIX_ASCII|5.013010||cV +FOLD_FLAGS_FULL|5.015006||Viu +FOLD_FLAGS_LOCALE|5.015006||Viu +FOLD_FLAGS_NOMIX_ASCII|5.017000||Viu +fopen|5.003007||Viu +forbid_setid|5.005000||Viu +force_ident|5.003007||Viu +force_ident_maybe_lex|5.017004||Viu +force_list|5.003007||Viu +force_next|5.003007||Viu +_force_out_malformed_utf8_message|5.025009||cVu +force_strict_version|5.011004||Viu +force_version|5.005000||Viu +force_word|5.003007||Viu +forget_pmop|5.017007||Viu +form|5.004000||vV +form_alien_digit_msg|5.031009||cViu +form_cp_too_large_msg|5.031009||cViu +form_nocontext|5.006000||vVn +fp_dup|5.007003|5.007003|u +Fpos_t|5.003007|5.003007|Vn +F_pow_amg|5.004000||Viu +FP_PINF|5.021004||Viu +FP_QNAN|5.021004||Viu +fprintf|5.003007||Viu +fprintf_nocontext|5.006000||vdVnu +FPTR2DPTR|5.009003||Viu +fputc|5.003007||Viu +fputs|5.003007||Viu +fread|5.003007||Viu +free|5.003007||Viu +free_and_set_cop_warnings|5.031011||Viu +free_c_backtrace|5.021001||Vi +FreeOp|5.008001||Viu +Free_t|5.003007|5.003007|Vn +FREE_THREAD_KEY|5.006001||Viu +free_tied_hv_pool|5.008001||Viu +FREETMPS|5.003007|5.003007| +free_tmps|5.003007||cVu +freopen|5.003007||Viu +frewind|5.005000||Viu +FROM_INTERNAL_SIZE|5.023002||Viu +fscanf|5.003007||Viu +fseek|5.003007||Viu +FSEEKSIZE|5.006000||Viu +fsetpos|5.003007||Viu +F_sin_amg|5.004000||Viu +F_sqrt_amg|5.004000||Viu +Fstat|5.003007||Viu +fstat|5.005000||Viu +ftell|5.003007||Viu +ftruncate|5.006000||Viu +ftrylockfile|5.003007||Viu +FUNCTION|5.009003||Viu +funlockfile|5.003007||Viu +fwrite1|5.003007||Viu +fwrite|5.003007||Viu +G_ARRAY|5.003007||Viu +GCB_BREAKABLE|5.025003||Viu +GCB_EX_then_EM|5.025003||Viu +GCB_Maybe_Emoji_NonBreak|5.029002||Viu +GCB_NOBREAK|5.025003||Viu +GCB_RI_then_RI|5.025003||Viu +GCC_DIAG_IGNORE|5.019007||Viu +GCC_DIAG_IGNORE_DECL|5.027007||Viu +GCC_DIAG_IGNORE_STMT|5.027007||Viu +GCC_DIAG_PRAGMA|5.021001||Viu +GCC_DIAG_RESTORE|5.019007||Viu +GCC_DIAG_RESTORE_DECL|5.027007||Viu +GCC_DIAG_RESTORE_STMT|5.027007||Viu +Gconvert|5.003007|5.003007| +GDBMNDBM_H_USES_PROTOTYPES|5.032001|5.032001|Vn +G_DISCARD|5.003007|5.003007| +gen_constant_list|5.003007||Viu +get_and_check_backslash_N_name|5.017006||cViu +get_and_check_backslash_N_name_wrapper|5.029009||Viu +get_ANYOF_cp_list_for_ssc|5.019005||Viu +get_ANYOFM_contents|5.027009||Viu +GETATARGET|5.003007||Viu +get_aux_mg|5.011000||Viu +get_av|5.006000|5.003007|p +getc|5.003007||Viu +get_c_backtrace|5.021001||Vi +get_c_backtrace_dump|5.021001||V +get_context|5.006000|5.006000|nu +getc_unlocked|5.003007||Viu +get_cv|5.006000|5.003007|p +get_cvn_flags|5.009005|5.003007|p +get_cvs|5.011000|5.003007|p +getcwd_sv|5.007002|5.007002| +get_db_sub|||iu +get_debug_opts|5.008001||Viu +get_deprecated_property_msg|5.031011||cVniu +getegid|5.005000||Viu +getenv|5.005000||Viu +getenv_len|5.006000||Viu +GETENV_LOCK|5.033005||Viu +GETENV_PRESERVES_OTHER_THREAD|5.033005|5.033005|Vn +GETENV_UNLOCK|5.033005||Viu +geteuid|5.005000||Viu +getgid|5.005000||Viu +getgrent|5.009000||Viu +GETGRENT_R_HAS_BUFFER|5.008000||Viu +GETGRENT_R_HAS_FPTR|5.008000||Viu +GETGRENT_R_HAS_PTR|5.008000||Viu +GETGRENT_R_PROTO|5.008000|5.008000|Vn +getgrgid|5.009000||Viu +GETGRGID_R_HAS_BUFFER|5.008000||Viu +GETGRGID_R_HAS_PTR|5.008000||Viu +GETGRGID_R_PROTO|5.008000|5.008000|Vn +getgrnam|5.009000||Viu +GETGRNAM_R_HAS_BUFFER|5.008000||Viu +GETGRNAM_R_HAS_PTR|5.008000||Viu +GETGRNAM_R_PROTO|5.008000|5.008000|Vn +get_hash_seed|5.008001||Viu +gethostbyaddr|5.005000||Viu +GETHOSTBYADDR_R_HAS_BUFFER|5.008000||Viu +GETHOSTBYADDR_R_HAS_ERRNO|5.008000||Viu +GETHOSTBYADDR_R_HAS_PTR|5.008000||Viu +GETHOSTBYADDR_R_PROTO|5.008000|5.008000|Vn +gethostbyname|5.005000||Viu +GETHOSTBYNAME_R_HAS_BUFFER|5.008000||Viu +GETHOSTBYNAME_R_HAS_ERRNO|5.008000||Viu +GETHOSTBYNAME_R_HAS_PTR|5.008000||Viu +GETHOSTBYNAME_R_PROTO|5.008000|5.008000|Vn +gethostent|5.005000||Viu +GETHOSTENT_R_HAS_BUFFER|5.008000||Viu +GETHOSTENT_R_HAS_ERRNO|5.008000||Viu +GETHOSTENT_R_HAS_PTR|5.008000||Viu +GETHOSTENT_R_PROTO|5.008000|5.008000|Vn +gethostname|5.005000||Viu +get_hv|5.006000|5.003007|p +get_invlist_iter_addr|5.015001||Vniu +get_invlist_offset_addr|5.019002||Vniu +get_invlist_previous_index_addr|5.017004||Vniu +getlogin|5.005000||Viu +GETLOGIN_R_PROTO|5.008000|5.008000|Vn +get_mstats|5.006000||Vu +getnetbyaddr|5.005000||Viu +GETNETBYADDR_R_HAS_BUFFER|5.008000||Viu +GETNETBYADDR_R_HAS_ERRNO|5.008000||Viu +GETNETBYADDR_R_HAS_PTR|5.008000||Viu +GETNETBYADDR_R_PROTO|5.008000|5.008000|Vn +getnetbyname|5.005000||Viu +GETNETBYNAME_R_HAS_BUFFER|5.008000||Viu +GETNETBYNAME_R_HAS_ERRNO|5.008000||Viu +GETNETBYNAME_R_HAS_PTR|5.008000||Viu +GETNETBYNAME_R_PROTO|5.008000|5.008000|Vn +getnetent|5.005000||Viu +GETNETENT_R_HAS_BUFFER|5.008000||Viu +GETNETENT_R_HAS_ERRNO|5.008000||Viu +GETNETENT_R_HAS_PTR|5.008000||Viu +GETNETENT_R_PROTO|5.008000|5.008000|Vn +get_no_modify|5.005000||Viu +get_num|5.008001||Viu +get_opargs|5.005000||Viu +get_op_descs|5.005000|5.005000|u +get_op_names|5.005000|5.005000|u +getpeername|5.005000||Viu +getpid|5.006000||Viu +get_ppaddr|5.006000|5.006000|u +get_prop_definition|5.031011||cViu +get_prop_values|5.031011||cVniu +getprotobyname|5.005000||Viu +GETPROTOBYNAME_R_HAS_BUFFER|5.008000||Viu +GETPROTOBYNAME_R_HAS_PTR|5.008000||Viu +GETPROTOBYNAME_R_PROTO|5.008000|5.008000|Vn +getprotobynumber|5.005000||Viu +GETPROTOBYNUMBER_R_HAS_BUFFER|5.008000||Viu +GETPROTOBYNUMBER_R_HAS_PTR|5.008000||Viu +GETPROTOBYNUMBER_R_PROTO|5.008000|5.008000|Vn +getprotoent|5.005000||Viu +GETPROTOENT_R_HAS_BUFFER|5.008000||Viu +GETPROTOENT_R_HAS_PTR|5.008000||Viu +GETPROTOENT_R_PROTO|5.008000|5.008000|Vn +getpwent|5.009000||Viu +GETPWENT_R_HAS_BUFFER|5.008000||Viu +GETPWENT_R_HAS_FPTR|5.008000||Viu +GETPWENT_R_HAS_PTR|5.008000||Viu +GETPWENT_R_PROTO|5.008000|5.008000|Vn +getpwnam|5.009000||Viu +GETPWNAM_R_HAS_BUFFER|5.008000||Viu +GETPWNAM_R_HAS_PTR|5.008000||Viu +GETPWNAM_R_PROTO|5.008000|5.008000|Vn +getpwuid|5.009000||Viu +GETPWUID_R_HAS_PTR|5.008000||Viu +GETPWUID_R_PROTO|5.008000|5.008000|Vn +get_quantifier_value|5.033006||Viu +get_re_arg|||xciu +get_re_gclass_nonbitmap_data|5.031011||Viu +get_regclass_nonbitmap_data|5.031011||Viu +get_regex_charset_name|5.031004||Vniu +getservbyname|5.005000||Viu +GETSERVBYNAME_R_HAS_BUFFER|5.008000||Viu +GETSERVBYNAME_R_HAS_PTR|5.008000||Viu +GETSERVBYNAME_R_PROTO|5.008000|5.008000|Vn +getservbyport|5.005000||Viu +GETSERVBYPORT_R_HAS_BUFFER|5.008000||Viu +GETSERVBYPORT_R_HAS_PTR|5.008000||Viu +GETSERVBYPORT_R_PROTO|5.008000|5.008000|Vn +getservent|5.005000||Viu +GETSERVENT_R_HAS_BUFFER|5.008000||Viu +GETSERVENT_R_HAS_PTR|5.008000||Viu +GETSERVENT_R_PROTO|5.008000|5.008000|Vn +getsockname|5.005000||Viu +getsockopt|5.005000||Viu +getspnam|5.009000||Viu +GETSPNAM_R_HAS_BUFFER|5.031011||Viu +GETSPNAM_R_HAS_PTR|5.008000||Viu +GETSPNAM_R_PROTO|5.008000|5.008000|Vn +get_sv|5.006000|5.003007|p +GETTARGET|5.003007||Viu +GETTARGETSTACKED|5.003007||Viu +gettimeofday|5.008000||Viu +getuid|5.005000||Viu +get_vtbl|5.005003|5.005003|u +getw|5.003007||Viu +G_EVAL|5.003007|5.003007| +G_FAKINGEVAL|5.009004||Viu +Gid_t|5.003007|5.003007|Vn +Gid_t_f|5.006000|5.006000|Vn +Gid_t_sign|5.006000|5.006000|Vn +Gid_t_size|5.006000|5.006000|Vn +GIMME|5.003007|5.003007|d +GIMME_V|5.004000|5.004000| +gimme_V|5.031005||xcVu +G_KEEPERR|5.003007|5.003007| +G_LIST|5.035001|5.003007| +glob_2number|5.009004||Viu +GLOBAL_PAT_MOD|5.009005||Viu +glob_assign_glob|5.009004||Viu +G_METHOD|5.006001|5.003007|p +G_METHOD_NAMED|5.019002|5.019002| +gmtime|5.031011||Viu +GMTIME_MAX|5.010001|5.010001|Vn +GMTIME_MIN|5.010001|5.010001|Vn +GMTIME_R_PROTO|5.008000|5.008000|Vn +G_NOARGS|5.003007|5.003007| +G_NODEBUG|5.004005||Viu +GOSUB|5.009005||Viu +GOSUB_t8|5.035004||Viu +GOSUB_t8_p8|5.033003||Viu +GOSUB_t8_pb|5.033003||Viu +GOSUB_tb|5.035004||Viu +GOSUB_tb_p8|5.033003||Viu +GOSUB_tb_pb|5.033003||Viu +gp_dup|5.007003|5.007003|u +gp_free|5.003007|5.003007|u +GPOS|5.004000||Viu +GPOS_t8|5.035004||Viu +GPOS_t8_p8|5.033003||Viu +GPOS_t8_pb|5.033003||Viu +GPOS_tb|5.035004||Viu +GPOS_tb_p8|5.033003||Viu +GPOS_tb_pb|5.033003||Viu +gp_ref|5.003007|5.003007|u +GREEK_CAPITAL_LETTER_MU|5.013011||Viu +GREEK_SMALL_LETTER_MU|5.013008||Viu +G_RE_REPARSING|5.017011||Viu +G_RETHROW|5.031002|5.003007|p +grok_atoUV|5.021010||cVni +grok_bin|5.007003|5.003007|p +grok_bin_oct_hex|5.031008||cVu +grok_bslash_c|5.013001||cViu +grok_bslash_N|5.017003||Viu +grok_bslash_o|5.013003||cViu +grok_bslash_x|5.017002||cViu +grok_hex|5.007003|5.003007|p +grok_infnan|5.021004|5.021004| +grok_number|5.007002|5.003007|p +grok_number_flags|5.021002|5.021002| +GROK_NUMERIC_RADIX|5.007002|5.003007|p +grok_numeric_radix|5.007002|5.003007|p +grok_oct|5.007003|5.003007|p +group_end|5.007003||Viu +GROUPP|5.005000||Viu +GROUPPN|5.031001||Viu +GROUPPN_t8|5.035004||Viu +GROUPPN_t8_p8|5.033003||Viu +GROUPPN_t8_pb|5.033003||Viu +GROUPPN_tb|5.035004||Viu +GROUPPN_tb_p8|5.033003||Viu +GROUPPN_tb_pb|5.033003||Viu +GROUPP_t8|5.035004||Viu +GROUPP_t8_p8|5.033003||Viu +GROUPP_t8_pb|5.033003||Viu +GROUPP_tb|5.035004||Viu +GROUPP_tb_p8|5.033003||Viu +GROUPP_tb_pb|5.033003||Viu +Groups_t|5.003007|5.003007|Vn +GRPASSWD|5.005000|5.005000|Vn +G_SCALAR|5.003007|5.003007| +G_UNDEF_FILL|5.013001||Viu +GV_ADD|5.003007|5.003007| +gv_add_by_type|5.011000|5.011000|u +GV_ADDMG|5.015003|5.015003| +GV_ADDMULTI|5.003007|5.003007| +GV_ADDWARN|5.003007|5.003007| +Gv_AMG|5.003007||Viu +Gv_AMupdate|5.011000|5.011000|u +GvASSUMECV|5.003007||Viu +GvASSUMECV_off|5.003007||Viu +GvASSUMECV_on|5.003007||Viu +gv_autoload4|5.004000|5.004000| +GV_AUTOLOAD|5.011000||Viu +GV_AUTOLOAD_ISMETHOD|5.015004||Viu +gv_autoload_pv|5.015004|5.015004|u +gv_autoload_pvn|5.015004|5.015004|u +gv_autoload_sv|5.015004|5.015004|u +GvAV|5.003007|5.003007| +gv_AVadd|5.003007|5.003007|u +GvAVn|5.003007||Viu +GV_CACHE_ONLY|5.021004||Vi +gv_check|5.003007||cVu +gv_const_sv|5.009003|5.009003| +GV_CROAK|5.011000||Viu +GvCV|5.003007|5.003007| +GvCVGEN|5.003007||Viu +GvCV_set|5.013010||Viu +GvCVu|5.004000||Viu +gv_dump|5.006000|5.006000|u +gv_efullname3|5.003007|5.003007|u +gv_efullname4|5.006001|5.006001|u +gv_efullname|5.003007|5.003007|du +GvEGV|5.003007||Viu +GvEGVx|5.013000||Viu +GvENAME|5.003007||Viu +GvENAME_HEK|5.015004||Viu +GvENAMELEN|5.015004||Viu +GvENAMEUTF8|5.015004||Viu +GvESTASH|5.003007||Viu +GVf_ASSUMECV|5.003007||Viu +gv_fetchfile|5.003007|5.003007| +gv_fetchfile_flags|5.009005|5.009005| +gv_fetchmeth|5.003007|5.003007| +gv_fetchmeth_autoload|5.007003|5.007003| +gv_fetchmeth_internal|5.021007||Viu +gv_fetchmethod|5.003007|5.003007| +gv_fetchmethod_autoload|5.004000|5.004000| +gv_fetchmethod_flags|5.015004||Viu +gv_fetchmethod_pv_flags|5.015004|5.015004|xu +gv_fetchmethod_pvn_flags|5.015004|5.015004|xu +gv_fetchmethod_sv_flags|5.015004|5.015004|xu +gv_fetchmeth_pv|5.015004|5.015004| +gv_fetchmeth_pv_autoload|5.015004|5.015004| +gv_fetchmeth_pvn|5.015004|5.015004| +gv_fetchmeth_pvn_autoload|5.015004|5.015004| +gv_fetchmeth_sv|5.015004|5.015004| +gv_fetchmeth_sv_autoload|5.015004|5.015004| +gv_fetchpv|5.003007|5.003007| +gv_fetchpvn|5.013006|5.013006| +gv_fetchpvn_flags|5.009002|5.003007|p +gv_fetchpvs|5.009004|5.003007|p +gv_fetchsv|5.009002|5.003007|p +gv_fetchsv_nomg|5.015003|5.015003| +GvFILE|5.006000||Viu +GvFILEGV|5.003007||Viu +GvFILE_HEK|5.009004||Viu +GvFILEx|5.019006||Viu +GVf_IMPORTED|5.003007||Viu +GVf_IMPORTED_AV|5.003007||Viu +GVf_IMPORTED_CV|5.003007||Viu +GVf_IMPORTED_HV|5.003007||Viu +GVf_IMPORTED_SV|5.003007||Viu +GVf_INTRO|5.003007||Viu +GvFLAGS|5.003007||Viu +GVf_MULTI|5.003007||Viu +GVF_NOADD|5.035006||Viu +GvFORM|5.003007||Viu +gv_fullname3|5.003007|5.003007|u +gv_fullname4|5.006001|5.006001|u +gv_fullname|5.003007|5.003007|du +GvGP|5.003007||Viu +GvGPFLAGS|5.021004||Viu +GvGP_set|5.013010||Viu +gv_handler|5.007001|5.007001|u +GvHV|5.003007|5.003007| +gv_HVadd|5.003007|5.003007|u +GvHVn|5.003007||Viu +GvIMPORTED|5.003007||Viu +GvIMPORTED_AV|5.003007||Viu +GvIMPORTED_AV_off|5.003007||Viu +GvIMPORTED_AV_on|5.003007||Viu +GvIMPORTED_CV|5.003007||Viu +GvIMPORTED_CV_off|5.003007||Viu +GvIMPORTED_CV_on|5.003007||Viu +GvIMPORTED_HV|5.003007||Viu +GvIMPORTED_HV_off|5.003007||Viu +GvIMPORTED_HV_on|5.003007||Viu +GvIMPORTED_off|5.003007||Viu +GvIMPORTED_on|5.003007||Viu +GvIMPORTED_SV|5.003007||Viu +GvIMPORTED_SV_off|5.003007||Viu +GvIMPORTED_SV_on|5.003007||Viu +gv_init|5.003007|5.003007| +gv_init_pv|5.015004|5.015004| +gv_init_pvn|5.015004|5.003007|p +gv_init_sv|5.015004|5.015004| +gv_init_svtype|5.015004||Viu +GvIN_PAD|5.006000||Viu +GvIN_PAD_off|5.006000||Viu +GvIN_PAD_on|5.006000||Viu +GvINTRO|5.003007||Viu +GvINTRO_off|5.003007||Viu +GvINTRO_on|5.003007||Viu +GvIO|5.003007||Viu +gv_IOadd|5.003007|5.003007|u +GvIOn|5.003007||Viu +GvIOp|5.003007||Viu +gv_is_in_main|5.019004||Viu +GvLINE|5.003007||Viu +gv_magicalize|5.019004||Viu +gv_magicalize_isa|5.013005||Viu +gv_method_changed|5.017007||Viu +GvMULTI|5.003007||Viu +GvMULTI_off|5.003007||Viu +GvMULTI_on|5.003007||Viu +GvNAME|5.003007||Viu +GvNAME_get|5.009004||Viu +GvNAME_HEK|5.009004||Viu +GvNAMELEN|5.003007||Viu +GvNAMELEN_get|5.009004||Viu +gv_name_set|5.009004|5.009004|u +GvNAMEUTF8|5.015004||Viu +GV_NOADD_MASK|5.009005||Viu +GV_NOADD_NOINIT|5.009003|5.009003| +GV_NOEXPAND|5.009003|5.009003| +GV_NOINIT|5.004005|5.004005| +GV_NO_SVGMAGIC|5.015003|5.015003| +GV_NOTQUAL|5.009004|5.009004| +GV_NOUNIVERSAL|5.033009||Viu +G_VOID|5.004000|5.004000| +gv_override|5.019006||Viu +GvREFCNT|5.003007||Viu +gv_setref|5.021005||Viu +GvSTASH|5.003007||Viu +gv_stashpv|5.003007|5.003007| +gv_stashpvn|5.003007|5.003007|p +gv_stashpvn_internal|5.021004||Viu +gv_stashpvs|5.009003|5.003007|p +gv_stashsv|5.003007|5.003007| +gv_stashsvpvn_cached|5.021004||Vi +GV_SUPER|5.017004|5.017004| +GvSV|5.003007|5.003007| +gv_SVadd|5.011000||Vu +GvSVn|5.009003|5.003007|p +gv_try_downgrade|5.011002||xcVi +GvXPVGV|5.003007||Viu +G_WANT|5.010001||Viu +G_WARN_ALL_MASK|5.006000||Viu +G_WARN_ALL_OFF|5.006000||Viu +G_WARN_ALL_ON|5.006000||Viu +G_WARN_OFF|5.006000||Viu +G_WARN_ON|5.006000||Viu +G_WARN_ONCE|5.006000||Viu +G_WRITING_TO_STDERR|5.013009||Viu +HADNV|||Viu +handle_named_backref|5.023008||Viu +handle_names_wildcard|5.031011||Viu +handle_possible_posix|5.023008||Viu +handle_regex_sets|5.017009||Viu +handle_user_defined_property|5.029008||Viu +HAS_ACCEPT4|5.027008|5.027008|Vn +HAS_ACCESS|5.006000|5.006000|Vn +HAS_ACOSH|5.021004|5.021004|Vn +HAS_ALARM|5.003007|5.003007|Vn +HASARENA|||Viu +HAS_ASCTIME_R|5.010000|5.010000|Vn +HAS_ASINH|5.021006|5.021006|Vn +HAS_ATANH|5.021006|5.021006|Vn +HAS_ATOLL|5.006000|5.006000|Vn +HASATTRIBUTE_ALWAYS_INLINE|5.031007|5.031007|Vn +HASATTRIBUTE_DEPRECATED|5.010001|5.010001|Vn +HASATTRIBUTE_FORMAT|5.009003|5.009003|Vn +HASATTRIBUTE_MALLOC|5.009003|5.009003|Vn +HASATTRIBUTE_NONNULL|5.009003|5.009003|Vn +HASATTRIBUTE_NORETURN|5.009003|5.009003|Vn +HASATTRIBUTE_PURE|5.009003|5.009003|Vn +HASATTRIBUTE_UNUSED|5.009003|5.009003|Vn +HASATTRIBUTE_WARN_UNUSED_RESULT|5.009003|5.009003|Vn +HAS_BACKTRACE|5.021001|5.021001|Vn +HAS_BUILTIN_CHOOSE_EXPR|5.009004|5.009004|Vn +HAS_BUILTIN_EXPECT|5.010001|5.010001|Vn +HAS_BUILTIN_UNREACHABLE|5.033003||Viu +HAS_C99|5.021004||Viu +HAS_C99_VARIADIC_MACROS|5.009004|5.009004|Vn +HAS_CBRT|5.021006|5.021006|Vn +HAS_CF_AUX_TABLES|5.027011||Viu +HAS_CHOWN|5.003007|5.003007|Vn +HAS_CHROOT|5.003007|5.003007|Vn +HAS_CHSIZE|5.004005|5.004005|Vn +HAS_CLEARENV|5.009003|5.009003|Vn +HAS_COPYSIGN|5.021006|5.021006|Vn +HAS_COPYSIGNL|5.008001|5.008001|Vn +HAS_CRYPT|5.003007|5.003007|Vn +HAS_CRYPT_R|5.010000|5.010000|Vn +HAS_CSH|5.005000|5.005000|Vn +HAS_CTERMID|5.009005|5.009005|Vn +HAS_CTIME_R|5.010000|5.010000|Vn +HAS_CUSERID|5.003007|5.003007|Vn +HAS_DBMINIT_PROTO|5.032001|5.032001|Vn +HAS_DIFFTIME|5.003007|5.003007|Vn +HAS_DIRFD|5.007003|5.007003|Vn +HAS_DLADDR|5.021001|5.021001|Vn +HAS_DLERROR|5.003007|5.003007|Vn +HAS_DRAND48_PROTO|5.006000|5.006000|Vn +HAS_DRAND48_R|5.010000|5.010000|Vn +HAS_DUP2|5.003007|5.003007|Vn +HAS_DUP3|5.027008|5.027008|Vn +HAS_DUPLOCALE|5.027011|5.027011|Vn +HAS_EACCESS|5.006000|5.006000|Vn +HAS_ENDGRENT|5.005000|5.005000|Vn +HAS_ENDHOSTENT|5.005000|5.005000|Vn +HAS_ENDNETENT|5.005000|5.005000|Vn +HAS_ENDPROTOENT|5.005000|5.005000|Vn +HAS_ENDPWENT|5.005000|5.005000|Vn +HAS_ENDSERVENT|5.005000|5.005000|Vn +HAS_ERF|5.021006|5.021006|Vn +HAS_ERFC|5.021006|5.021006|Vn +HAS_EXP2|5.021006|5.021006|Vn +HAS_EXPM1|5.021006|5.021006|Vn +HAS_EXTRA_LONG_UTF8|5.035004||Viu +HAS_FAST_STDIO|5.008001|5.008001|Vn +HAS_FCHDIR|5.007002|5.007002|Vn +HAS_FCHMOD|5.003007|5.003007|Vn +HAS_FCHMODAT|5.027004|5.027004|Vn +HAS_FCHOWN|5.003007|5.003007|Vn +HAS_FCNTL|5.003007|5.003007|Vn +HAS_FDIM|5.021006|5.021006|Vn +HAS_FD_SET|5.006000|5.006000|Vn +HAS_FEGETROUND|5.021004|5.021004|Vn +HAS_FFS|5.035001|5.035001|Vn +HAS_FFSL|5.035001|5.035001|Vn +HAS_FGETPOS|5.003007|5.003007|Vn +HAS_FINITE|5.007003|5.007003|Vn +HAS_FINITEL|5.007003|5.007003|Vn +HAS_FLOCK|5.003007|5.003007|Vn +HAS_FLOCK_PROTO|5.007002|5.007002|Vn +HAS_FMA|5.021006|5.021006|Vn +HAS_FMAX|5.021006|5.021006|Vn +HAS_FMIN|5.021006|5.021006|Vn +HAS_FORK|5.003007|5.003007|Vn +HAS_FPATHCONF|5.003007|5.003007|Vn +HAS_FPCLASSIFY|5.021004|5.021004|Vn +HAS_FREELOCALE|5.023009|5.023009|Vn +HAS_FREXPL|5.006001|5.006001|Vn +HAS_FSEEKO|5.006000|5.006000|Vn +HAS_FSETPOS|5.003007|5.003007|Vn +HAS_FSTATFS|5.023005|5.023005|Vn +HAS_FSTATVFS|5.023005|5.023005|Vn +HAS_FSYNC|5.007001|5.007001|Vn +HAS_FTELLO|5.006000|5.006000|Vn +HAS_FUTIMES|5.009003|5.009003|Vn +HAS_GAI_STRERROR|5.025004|5.025004|Vn +HAS_GETADDRINFO|5.010001|5.010001|Vn +HAS_GETCWD|5.006000|5.006000|Vn +HAS_GETGRENT|5.005000|5.005000|Vn +HAS_GETGRENT_R|5.010000|5.010000|Vn +HAS_GETGRGID_R|5.010000|5.010000|Vn +HAS_GETGRNAM_R|5.010000|5.010000|Vn +HAS_GETGROUPS|5.003007|5.003007|Vn +HAS_GETHOSTBYADDR|5.005000|5.005000|Vn +HAS_GETHOSTBYADDR_R|5.010000|5.010000|Vn +HAS_GETHOSTBYNAME|5.005000|5.005000|Vn +HAS_GETHOSTBYNAME_R|5.010000|5.010000|Vn +HAS_GETHOSTENT|5.003007|5.003007|Vn +HAS_GETHOSTENT_R|5.010000|5.010000|Vn +HAS_GETHOSTNAME|5.006000|5.006000|Vn +HAS_GETHOST_PROTOS|5.005000|5.005000|Vn +HAS_GETITIMER|5.007001|5.007001|Vn +HAS_GETLOGIN|5.003007|5.003007|Vn +HAS_GETLOGIN_R|5.010000|5.010000|Vn +HAS_GETMNTENT|5.023005|5.023005|Vn +HAS_GETNAMEINFO|5.010001|5.010001|Vn +HAS_GETNETBYADDR|5.005000|5.005000|Vn +HAS_GETNETBYADDR_R|5.010000|5.010000|Vn +HAS_GETNETBYNAME|5.005000|5.005000|Vn +HAS_GETNETBYNAME_R|5.010000|5.010000|Vn +HAS_GETNETENT|5.005000|5.005000|Vn +HAS_GETNETENT_R|5.010000|5.010000|Vn +HAS_GETNET_PROTOS|5.005000|5.005000|Vn +HAS_GETPAGESIZE|5.007001|5.007001|Vn +HAS_GETPGID|5.003007|5.003007|Vn +HAS_GETPGRP|5.003007|5.003007|Vn +HAS_GETPPID|5.003007|5.003007|Vn +HAS_GETPRIORITY|5.003007|5.003007|Vn +HAS_GETPROTOBYNAME|5.005000|5.005000|Vn +HAS_GETPROTOBYNAME_R|5.010000|5.010000|Vn +HAS_GETPROTOBYNUMBER|5.005000|5.005000|Vn +HAS_GETPROTOBYNUMBER_R|5.010000|5.010000|Vn +HAS_GETPROTOENT|5.005000|5.005000|Vn +HAS_GETPROTOENT_R|5.010000|5.010000|Vn +HAS_GETPROTO_PROTOS|5.005000|5.005000|Vn +HAS_GETPWENT|5.005000|5.005000|Vn +HAS_GETPWENT_R|5.010000|5.010000|Vn +HAS_GETPWNAM_R|5.010000|5.010000|Vn +HAS_GETPWUID_R|5.010000|5.010000|Vn +HAS_GETSERVBYNAME|5.005000|5.005000|Vn +HAS_GETSERVBYNAME_R|5.010000|5.010000|Vn +HAS_GETSERVBYPORT|5.005000|5.005000|Vn +HAS_GETSERVBYPORT_R|5.010000|5.010000|Vn +HAS_GETSERVENT|5.005000|5.005000|Vn +HAS_GETSERVENT_R|5.010000|5.010000|Vn +HAS_GETSERV_PROTOS|5.005000|5.005000|Vn +HAS_GETSPNAM|5.006000|5.006000|Vn +HAS_GETSPNAM_R|5.010000|5.010000|Vn +HAS_GETTIMEOFDAY|5.004000|5.004000|Vn +HAS_GMTIME_R|5.010000|5.010000|Vn +HAS_GNULIBC|5.004005|5.004005|Vn +HAS_GROUP|5.003007||Viu +HAS_HASMNTOPT|5.023005|5.023005|Vn +HAS_HTONL|5.003007|5.003007|Vn +HAS_HTONS|5.003007|5.003007|Vn +HAS_HYPOT|5.021006|5.021006|Vn +HAS_ILOGB|5.021006|5.021006|Vn +HAS_ILOGBL|5.008001|5.008001|Vn +HAS_INET_ATON|5.004000|5.004000|Vn +HAS_INETNTOP|5.010001|5.010001|Vn +HAS_INETPTON|5.010001|5.010001|Vn +HAS_INT64_T|5.006000|5.006000|Vn +HAS_IOCTL|5.003007||Viu +HAS_IP_MREQ|5.017002|5.017002|Vn +HAS_IP_MREQ_SOURCE|5.017004|5.017004|Vn +HAS_IPV6_MREQ|5.015008|5.015008|Vn +HAS_ISASCII|5.003007|5.003007|Vn +HAS_ISBLANK|5.015007|5.015007|Vn +HAS_ISFINITE|5.021004|5.021004|Vn +HAS_ISINF|5.007003|5.007003|Vn +HAS_ISINFL|5.021004|5.021004|Vn +HAS_ISLESS|5.031007|5.031007|Vn +HAS_ISNAN|5.006001|5.006001|Vn +HAS_ISNANL|5.006001|5.006001|Vn +HAS_ISNORMAL|5.021006|5.021006|Vn +HAS_IVCF_AUX_TABLES|5.027011||Viu +HAS_J0|5.021004|5.021004|Vn +HAS_J0L|5.021004|5.021004|Vn +HAS_KILL|5.003007||Viu +HAS_KILLPG|5.003007|5.003007|Vn +HAS_LC_AUX_TABLES|5.027011||Viu +HAS_LCHOWN|5.005000|5.005000|Vn +HAS_LC_MONETARY_2008|5.021005|5.021005|Vn +HAS_LDBL_DIG|5.006000|5.006000|Vn +HAS_LDEXPL|5.021003|5.021003|Vn +HAS_LGAMMA|5.021006|5.021006|Vn +HAS_LGAMMA_R|5.021006|5.021006|Vn +HAS_LINK|5.003007|5.003007|Vn +HAS_LINKAT|5.027004|5.027004|Vn +HAS_LLRINT|5.021006|5.021006|Vn +HAS_LLRINTL|5.021009|5.021009|Vn +HAS_LLROUND|5.021006|5.021006|Vn +HAS_LLROUNDL|5.021009|5.021009|Vn +HAS_LOCALECONV|5.003007|5.003007|Vn +HAS_LOCALTIME_R|5.010000|5.010000|Vn +HAS_LOCKF|5.003007|5.003007|Vn +HAS_LOG1P|5.021006|5.021006|Vn +HAS_LOG2|5.021006|5.021006|Vn +HAS_LOGB|5.021006|5.021006|Vn +HAS_LONG_DOUBLE|5.005000|5.005000|Vn +HAS_LONG_LONG|5.005000|5.005000|Vn +HAS_LRINT|5.021006|5.021006|Vn +HAS_LRINTL|5.021009|5.021009|Vn +HAS_LROUND|5.021006|5.021006|Vn +HAS_LROUNDL|5.021009|5.021009|Vn +HAS_LSEEK_PROTO|5.006000|5.006000|Vn +HAS_LSTAT|5.003007|5.003007|Vn +HAS_MADVISE|5.006000|5.006000|Vn +HAS_MBLEN|5.003007|5.003007|Vn +HAS_MBRLEN|5.027006|5.027006|Vn +HAS_MBRTOWC|5.027006|5.027006|Vn +HAS_MBSTOWCS|5.003007|5.003007|Vn +HAS_MBTOWC|5.003007|5.003007|Vn +HAS_MEMMEM|5.024000|5.024000|Vn +HAS_MEMRCHR|5.027005|5.027005|Vn +HAS_MKDIR|5.003007|5.003007|Vn +HAS_MKDTEMP|5.006000|5.006000|Vn +HAS_MKFIFO|5.003007|5.003007|Vn +HAS_MKOSTEMP|5.027008|5.027008|Vn +HAS_MKSTEMP|5.006000|5.006000|Vn +HAS_MKSTEMPS|5.006000|5.006000|Vn +HAS_MKTIME|5.003007|5.003007|Vn +HAS_MMAP|5.006000|5.006000|Vn +HAS_MODFL|5.006001|5.006001|Vn +HAS_MODFL_PROTO|5.009003|5.009003|Vn +HAS_MPROTECT|5.006000|5.006000|Vn +HAS_MSG|5.003007|5.003007|Vn +HAS_MSYNC|5.006000|5.006000|Vn +HAS_MUNMAP|5.006000|5.006000|Vn +HAS_NAN|5.021006|5.021006|Vn +HAS_NANOSLEEP|5.027006|5.027006|Vn +HAS_NEARBYINT|5.021006|5.021006|Vn +HAS_NEWLOCALE|5.023009|5.023009|Vn +HAS_NEXTAFTER|5.021006|5.021006|Vn +HAS_NEXTTOWARD|5.021006|5.021006|Vn +HAS_NICE|5.003007|5.003007|Vn +HAS_NL_LANGINFO|5.007002|5.007002|Vn +HAS_NL_LANGINFO_L|5.035001|5.035001|Vn +HAS_NON_INT_BITFIELDS|5.035001|5.035001|Vn +HAS_NONLATIN1_FOLD_CLOSURE|5.033005||Viu +HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE|5.033005||Viu +HAS_NTOHL|5.003007|5.003007|Vn +HAS_NTOHS|5.003007|5.003007|Vn +HAS_OFF64_T|5.010000|5.010000|Vn +HAS_OPEN3|5.003007|5.003007|Vn +HAS_OPENAT|5.027004|5.027004|Vn +HAS_PASSWD|5.003007||Viu +HAS_PATHCONF|5.003007|5.003007|Vn +HAS_PAUSE|5.003007|5.003007|Vn +HAS_PIPE2|5.027008|5.027008|Vn +HAS_PIPE|5.003007|5.003007|Vn +HAS_POLL|5.003007|5.003007|Vn +HAS_POSIX_2008_LOCALE|5.027003||Viu +HAS_PRCTL|5.013000|5.013000|Vn +HAS_PRCTL_SET_NAME|5.013000|5.013000|Vn +HAS_PROCSELFEXE|5.007003|5.007003|Vn +HAS_PTHREAD_ATFORK|5.010000|5.010000|Vn +HAS_PTHREAD_ATTR_SETSCOPE|5.008001|5.008001|Vn +HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP|5.007002||Viu +HAS_PTHREAD_YIELD|5.009005|5.009005|Vn +HAS_PTRDIFF_T|5.021001|5.021001|Vn +HAS_QUAD|5.003007|5.003007|Vn +HAS_RANDOM_R|5.010000|5.010000|Vn +HAS_READDIR|5.003007|5.003007|Vn +HAS_READDIR64_R|5.010000|5.010000|Vn +HAS_READDIR_R|5.010000|5.010000|Vn +HAS_READLINK|5.003007|5.003007|Vn +HAS_READV|5.007001|5.007001|Vn +HAS_RECVMSG|5.007001|5.007001|Vn +HAS_REGCOMP|5.021007|5.021007|Vn +HAS_REMAINDER|5.021006|5.021006|Vn +HAS_REMQUO|5.021006|5.021006|Vn +HAS_RENAME|5.003007|5.003007|Vn +HAS_RENAMEAT|5.027004|5.027004|Vn +HAS_REWINDDIR|5.003007|5.003007|Vn +HAS_RINT|5.021006|5.021006|Vn +HAS_RMDIR|5.003007|5.003007|Vn +HAS_ROUND|5.021006|5.021006|Vn +HAS_SBRK_PROTO|5.007001|5.007001|Vn +HAS_SCALBN|5.021006|5.021006|Vn +HAS_SCALBNL|5.008001|5.008001|Vn +HAS_SCHED_YIELD|5.005000|5.005000|Vn +HAS_SCX_AUX_TABLES|5.027008||Viu +HAS_SEEKDIR|5.003007|5.003007|Vn +HAS_SELECT|5.003007|5.003007|Vn +HAS_SEM|5.003007|5.003007|Vn +HAS_SENDMSG|5.007001|5.007001|Vn +HAS_SETEGID|5.003007|5.003007|Vn +HAS_SETEUID|5.003007|5.003007|Vn +HAS_SETGRENT|5.005000|5.005000|Vn +HAS_SETGROUPS|5.004000|5.004000|Vn +HAS_SETHOSTENT|5.005000|5.005000|Vn +HAS_SETITIMER|5.007001|5.007001|Vn +HAS_SETLINEBUF|5.003007|5.003007|Vn +HAS_SETLOCALE|5.003007|5.003007|Vn +HAS_SETNETENT|5.005000|5.005000|Vn +HAS_SETPGID|5.003007|5.003007|Vn +HAS_SETPGRP|5.003007|5.003007|Vn +HAS_SETPRIORITY|5.003007|5.003007|Vn +HAS_SETPROTOENT|5.005000|5.005000|Vn +HAS_SETPWENT|5.005000|5.005000|Vn +HAS_SETREGID|5.003007|5.003007|Vn +HAS_SETRESGID|5.003007|5.003007|Vn +HAS_SETRESGID_PROTO|5.010000|5.010000|Vn +HAS_SETRESUID|5.003007|5.003007|Vn +HAS_SETRESUID_PROTO|5.010000|5.010000|Vn +HAS_SETREUID|5.003007|5.003007|Vn +HAS_SETSERVENT|5.005000|5.005000|Vn +HAS_SETSID|5.003007|5.003007|Vn +HAS_SETVBUF|5.005000|5.005000|Vn +HAS_SHM|5.003007|5.003007|Vn +HAS_SHMAT_PROTOTYPE|5.003007|5.003007|Vn +HAS_SIGACTION|5.003007|5.003007|Vn +HAS_SIGINFO_SI_ADDR|5.023008|5.023008|Vn +HAS_SIGINFO_SI_BAND|5.023008|5.023008|Vn +HAS_SIGINFO_SI_ERRNO|5.023008|5.023008|Vn +HAS_SIGINFO_SI_PID|5.023008|5.023008|Vn +HAS_SIGINFO_SI_STATUS|5.023008|5.023008|Vn +HAS_SIGINFO_SI_UID|5.023008|5.023008|Vn +HAS_SIGINFO_SI_VALUE|5.023008|5.023008|Vn +HAS_SIGNBIT|5.009005|5.009005|Vn +HAS_SIGPROCMASK|5.007001|5.007001|Vn +HAS_SIGSETJMP|5.003007|5.003007|Vn +HAS_SIN6_SCOPE_ID|5.013009|5.013009|Vn +HAS_SKIP_LOCALE_INIT|5.019002||Viu +HAS_SNPRINTF|5.009003|5.009003|Vn +HAS_SOCKADDR_IN6|5.015008|5.015008|Vn +HAS_SOCKADDR_STORAGE|5.032001|5.032001|Vn +HAS_SOCKATMARK|5.007001|5.007001|Vn +HAS_SOCKATMARK_PROTO|5.007002|5.007002|Vn +HAS_SOCKET|5.003007|5.003007|Vn +HAS_SOCKETPAIR|5.003007|5.003007|Vn +HAS_SQRTL|5.006000|5.006000|Vn +HAS_SRAND48_R|5.010000|5.010000|Vn +HAS_SRANDOM_R|5.010000|5.010000|Vn +HAS_STAT|5.021007|5.021007|Vn +HAS_STATIC_INLINE|5.013004|5.013004|Vn +HAS_STRCOLL|5.003007|5.003007|Vn +HAS_STRERROR_L|5.025002|5.025002|Vn +HAS_STRERROR_R|5.010000|5.010000|Vn +HAS_STRFTIME|5.007002|5.007002|Vn +HAS_STRNLEN|5.027006|5.027006|Vn +HAS_STRTOD|5.004000|5.004000|Vn +HAS_STRTOD_L|5.027011|5.027011|Vn +HAS_STRTOL|5.004000|5.004000|Vn +HAS_STRTOLD|5.006000|5.006000|Vn +HAS_STRTOLD_L|5.027006|5.027006|Vn +HAS_STRTOLL|5.006000|5.006000|Vn +HAS_STRTOQ|5.007001|5.007001|Vn +HAS_STRTOUL|5.004000|5.004000|Vn +HAS_STRTOULL|5.006000|5.006000|Vn +HAS_STRTOUQ|5.006000|5.006000|Vn +HAS_STRUCT_CMSGHDR|5.007001|5.007001|Vn +HAS_STRUCT_MSGHDR|5.007001|5.007001|Vn +HAS_STRUCT_STATFS|5.023005|5.023005|Vn +HAS_STRUCT_STATFS_F_FLAGS|5.023005|5.023005|Vn +HAS_STRXFRM|5.003007|5.003007|Vn +HAS_STRXFRM_L|5.035001|5.035001|Vn +HAS_SYMLINK|5.003007|5.003007|Vn +HAS_SYSCALL|5.003007|5.003007|Vn +HAS_SYSCALL_PROTO|5.007002|5.007002|Vn +HAS_SYSCONF|5.003007|5.003007|Vn +HAS_SYS_ERRLIST|5.003007|5.003007|Vn +HAS_SYSTEM|5.003007|5.003007|Vn +HAS_TC_AUX_TABLES|5.027011||Viu +HAS_TCGETPGRP|5.003007|5.003007|Vn +HAS_TCSETPGRP|5.003007|5.003007|Vn +HAS_TELLDIR|5.003007|5.003007|Vn +HAS_TELLDIR_PROTO|5.006000|5.006000|Vn +HAS_TGAMMA|5.021006|5.021006|Vn +HAS_THREAD_SAFE_NL_LANGINFO_L|5.027006|5.027006|Vn +HAS_TIME|5.008000|5.008000|Vn +HAS_TIMEGM|5.010001|5.010001|Vn +HAS_TIMES|5.003007|5.003007|Vn +HAS_TMPNAM_R|5.010000|5.010000|Vn +HAS_TM_TM_GMTOFF|5.008001|5.008001|Vn +HAS_TM_TM_ZONE|5.008000|5.008000|Vn +HAS_TOWLOWER|5.029009|5.029009|Vn +HAS_TOWUPPER|5.029009|5.029009|Vn +HAS_TRUNC|5.021006|5.021006|Vn +HAS_TRUNCATE|5.003007|5.003007|Vn +HAS_TRUNCL|5.021004|5.021004|Vn +HAS_TTYNAME_R|5.010000|5.010000|Vn +HAS_TZNAME|5.003007|5.003007|Vn +HAS_UALARM|5.007001|5.007001|Vn +HAS_UC_AUX_TABLES|5.027011||Viu +HAS_UMASK|5.003007|5.003007|Vn +HAS_UNAME|5.003007|5.003007|Vn +HAS_UNLINKAT|5.027004|5.027004|Vn +HAS_UNSETENV|5.009003|5.009003|Vn +HAS_USELOCALE|5.023009|5.023009|Vn +HAS_USLEEP|5.007001|5.007001|Vn +HAS_USLEEP_PROTO|5.007002|5.007002|Vn +HAS_USTAT|5.023005|5.023005|Vn +HAS_UTIME|5.003007||Viu +HAS_VSNPRINTF|5.009003|5.009003|Vn +HAS_WAIT4|5.003007|5.003007|Vn +HAS_WAIT|5.003007||Viu +HAS_WAITPID|5.003007|5.003007|Vn +HAS_WCRTOMB|5.031007|5.031007|Vn +HAS_WCSCMP|5.021001|5.021001|Vn +HAS_WCSTOMBS|5.003007|5.003007|Vn +HAS_WCSXFRM|5.021001|5.021001|Vn +HAS_WCTOMB|5.003007|5.003007|Vn +HAS_WRITEV|5.007001|5.007001|Vn +HE_ARENA_ROOT_IX|5.035005||Viu +he_dup|5.007003|5.007003|u +HEf_SVKEY|5.003007|5.003007|p +HeHASH|5.003007|5.003007| +HEK_BASESIZE|5.004000||Viu +hek_dup|5.009000|5.009000|u +HeKEY|5.003007|5.003007| +HeKEY_hek|5.004000||Viu +HeKEY_sv|5.004000||Viu +HEKf256|5.015004||Viu +HEKf|5.015004||Viu +HEKfARG|5.015004||Viu +HEK_FLAGS|5.008000||Viu +HeKFLAGS|5.008000||Viu +HEK_HASH|5.004000||Viu +HEK_KEY|5.004000||Viu +HeKLEN|5.003007|5.003007| +HEK_LEN|5.004000||Viu +HeKLEN_UTF8|5.007001||Viu +HEK_UTF8|5.007001||Viu +HeKUTF8|5.007001||Viu +HEK_UTF8_off|5.008000||Viu +HEK_UTF8_on|5.008000||Viu +HEK_WASUTF8|5.008000||Viu +HeKWASUTF8|5.008000||Viu +HEK_WASUTF8_off|5.008000||Viu +HEK_WASUTF8_on|5.008000||Viu +HeNEXT|5.003007||Viu +HePV|5.004000|5.004000| +HeSVKEY|5.003007|5.003007| +HeSVKEY_force|5.003007|5.003007| +HeSVKEY_set|5.004000|5.004000| +HeUTF8|5.010001|5.008000|p +HeVAL|5.003007|5.003007| +hfree_next_entry|||iu +HIGHEST_ANYOF_HRx_BYTE|5.031002||Viu +HIGHEST_CASE_CHANGING_CP|5.033005||Viu +HINT_ALL_STRICT|5.033002||Viu +HINT_BLOCK_SCOPE|5.003007||Viu +HINT_BYTES|5.007002||Viu +HINT_EXPLICIT_STRICT_REFS|5.016000||Viu +HINT_EXPLICIT_STRICT_SUBS|5.016000||Viu +HINT_EXPLICIT_STRICT_VARS|5.016000||Viu +HINT_FEATURE_MASK|5.015007||Viu +HINT_FEATURE_SHIFT|5.015007||Viu +HINT_FILETEST_ACCESS|5.006000||Viu +HINT_INTEGER|5.003007||Viu +HINT_LEXICAL_IO_IN|5.009005||Viu +HINT_LEXICAL_IO_OUT|5.009005||Viu +HINT_LOCALE|5.004000||Viu +HINT_LOCALE_PARTIAL|5.021001||Viu +HINT_LOCALIZE_HH|5.005000||Viu +HINT_NEW_BINARY|5.005000||Viu +HINT_NEW_FLOAT|5.005000||Viu +HINT_NEW_INTEGER|5.005000||Viu +HINT_NEW_RE|5.005000||Viu +HINT_NEW_STRING|5.005000||Viu +HINT_NO_AMAGIC|5.010001||Viu +HINT_RE_EVAL|5.005000||Viu +HINT_RE_FLAGS|5.013007||Viu +HINT_RE_TAINT|5.004005||Viu +HINTS_DEFAULT|5.033002||Viu +HINTS_REFCNT_INIT|5.009004||Viu +HINTS_REFCNT_LOCK|5.009004||Viu +HINTS_REFCNT_TERM|5.009004||Viu +HINTS_REFCNT_UNLOCK|5.009004||Viu +HINT_STRICT_REFS|5.003007||Viu +HINT_STRICT_SUBS|5.003007||Viu +HINT_STRICT_VARS|5.003007||Viu +HINT_UNI_8_BIT|5.011002||Viu +HINT_UTF8|5.006000||Viu +H_PERL|5.003007||Viu +HS_APIVERLEN_MAX|5.021006||Viu +HS_CXT|5.021006||Viu +HSf_IMP_CXT|5.021006||Viu +HSf_NOCHK|5.021006||Viu +HSf_POPMARK|5.021006||Viu +HSf_SETXSUBFN|5.021006||Viu +HS_GETAPIVERLEN|5.021006||Viu +HS_GETINTERPSIZE|5.021006||Viu +HS_GETXSVERLEN|5.021006||Viu +HS_KEY|5.021006||Viu +HS_KEYp|5.021006||Viu +HSm_APIVERLEN|5.021006||Viu +HSm_INTRPSIZE|5.021006||Viu +HSm_KEY_MATCH|5.021006||Viu +HSm_XSVERLEN|5.021006||Viu +hsplit|5.005000||Viu +HS_XSVERLEN_MAX|5.021006||Viu +htoni|5.003007||Viu +htonl|5.003007||Viu +htons|5.003007||Viu +htovl|5.003007||Viu +htovs|5.003007||Viu +HvAMAGIC|5.017000||Viu +HvAMAGIC_off|5.017000||Viu +HvAMAGIC_on|5.017000||Viu +HvARRAY|5.003007||Viu +hv_assert||| +HvAUX|5.009003||Viu +hv_auxalloc|||iu +HVAUX_ARENA_ROOT_IX|5.035005||Viu +HvAUXf_NO_DEREF|5.019010||Viu +HvAUXf_SCAN_STASH|5.019010||Viu +hv_auxinit|5.009003||Viu +hv_backreferences_p|||xiu +hv_bucket_ratio|5.025003|5.025003|x +hv_clear|5.003007|5.003007| +hv_clear_placeholders|5.009001|5.009001| +hv_common|5.010000||cVu +hv_common_key_len|5.010000||cVu +hv_copy_hints_hv|5.013005|5.013005| +hv_delayfree_ent|5.004000|5.004000|u +hv_delete|5.003007|5.003007| +HV_DELETE|5.009005||Viu +hv_delete_common|5.009001||xViu +hv_delete_ent|5.003007|5.003007| +hv_deletehek|5.019006||Viu +hv_deletes|5.025006||Viu +HV_DISABLE_UVAR_XKEY|5.010000||Viu +HvEITER|5.003007||Viu +HvEITER_get|5.009003||Viu +hv_eiter_p|||u +HvEITER_set|5.009003||Viu +hv_eiter_set|||u +HvENAME|5.013007|5.013007| +hv_ename_add|5.013007||Vi +hv_ename_delete|5.013007||Vi +HvENAME_get|5.013007||Viu +HvENAME_HEK|5.013007||Viu +HvENAME_HEK_NN|5.013007||Viu +HvENAMELEN|5.015004|5.015004| +HvENAMELEN_get|5.013007||Viu +HvENAMEUTF8|5.015004|5.015004| +hv_exists|5.003007|5.003007| +hv_exists_ent|5.003007|5.003007| +hv_existshek|5.035003||Viu +hv_existss|5.025006||Viu +hv_fetch|5.003007|5.003007| +HV_FETCH_EMPTY_HE|5.013007||Viu +hv_fetch_ent|5.003007|5.003007| +hv_fetchhek|5.019006||Viu +HV_FETCH_ISEXISTS|5.009005||Viu +HV_FETCH_ISSTORE|5.009005||Viu +HV_FETCH_JUST_SV|5.009005||Viu +HV_FETCH_LVALUE|5.009005||Viu +hv_fetchs|5.009003|5.003007|p +hv_fill||| +HvFILL|5.003007|5.003007| +hv_free_ent|5.004000|5.004000|u +hv_free_ent_ret|5.015000||Viu +hv_free_entries|5.027002||Viu +HvHASKFLAGS|5.008000||Viu +HvHASKFLAGS_off|5.008000||Viu +HvHASKFLAGS_on|5.008000||Viu +HVhek_ENABLEHVKFLAGS|5.008002||Viu +HVhek_FREEKEY|5.008000||Viu +HVhek_KEYCANONICAL|5.010001||Viu +HVhek_MASK|5.008000||Viu +HVhek_PLACEHOLD|5.008000||Viu +HVhek_UNSHARED|5.009004||Viu +HVhek_UTF8|5.008000||Viu +HVhek_WASUTF8|5.008000||Viu +hv_iterinit|5.003007|5.003007| +hv_iterkey|5.003007|5.003007| +hv_iterkeysv|5.003007|5.003007| +hv_iternext|5.003007|5.003007| +hv_iternext_flags|5.008000|5.008000|x +hv_iternextsv|5.003007|5.003007| +HV_ITERNEXT_WANTPLACEHOLDERS|5.008000|5.008000| +hv_iterval|5.003007|5.003007| +HvKEYS|5.003007||Viu +hv_kill_backrefs|||xiu +hv_ksplit|5.003007|5.003007|u +HvLASTRAND_get|5.017011||Viu +HvLAZYDEL|5.003007||Viu +HvLAZYDEL_off|5.003007||Viu +HvLAZYDEL_on|5.003007||Viu +hv_magic|5.003007|5.003007| +hv_magic_check|5.006000||Vniu +HvMAX|5.003007||Viu +HvMROMETA|5.010001|5.010001| +HvNAME|5.003007|5.003007| +HvNAME_get|5.009003||pcV +HvNAME_HEK|5.009003||Viu +HvNAME_HEK_NN|5.013007||Viu +HvNAMELEN|5.015004|5.015004| +HvNAMELEN_get|5.009003|5.003007|p +hv_name_set|5.009003|5.009003|u +HV_NAME_SETALL|5.013008||Viu +hv_name_sets|5.025006||Viu +HvNAMEUTF8|5.015004|5.015004| +hv_notallowed|5.008000||Viu +HvPLACEHOLDERS|5.007003||Viu +HvPLACEHOLDERS_get|5.009003||Viu +hv_placeholders_get|||u +hv_placeholders_p|||ciu +HvPLACEHOLDERS_set|5.009003||Viu +hv_placeholders_set|||u +hv_pushkv|5.027003||Viu +HvRAND_get|5.017011||Viu +hv_rand_set|5.018000|5.018000|u +HVrhek_delete|5.009004||Viu +HVrhek_IV|5.009004||Viu +HVrhek_PV|5.009004||Viu +HVrhek_PV_UTF8|5.009005||Viu +HVrhek_typemask|5.009004||Viu +HVrhek_undef|5.009004||Viu +HVrhek_UV|5.009004||Viu +HvRITER|5.003007||Viu +HvRITER_get|5.009003||Viu +hv_riter_p|||u +HvRITER_set|5.009003||Viu +hv_riter_set|||u +hv_scalar|5.009001|5.009001| +HvSHAREKEYS|5.003007||Viu +HvSHAREKEYS_off|5.003007||Viu +HvSHAREKEYS_on|5.003007||Viu +hv_store|5.003007|5.003007| +hv_store_ent|5.003007|5.003007| +hv_store_flags|5.008000|5.008000|xu +hv_storehek|5.019006||Viu +hv_stores|5.009004|5.003007|p +HvTOTALKEYS|5.007003||Viu +hv_undef|5.003007|5.003007| +hv_undef_flags|||ciu +HvUSEDKEYS|5.007003||Viu +HYPHEN_UTF8|5.017004||Viu +I16_MAX|5.003007||Viu +I16_MIN|5.003007||Viu +I16SIZE|5.006000|5.006000|Vn +I16TYPE|5.006000|5.006000|Vn +I_32|5.006000|5.003007| +I32_MAX|5.003007||Viu +I32_MAX_P1|5.007002||Viu +I32_MIN|5.003007||Viu +I32SIZE|5.006000|5.006000|Vn +I32TYPE|5.006000|5.006000|Vn +I64SIZE|5.006000|5.006000|Vn +I64TYPE|5.006000|5.006000|Vn +I8SIZE|5.006000|5.006000|Vn +I8_TO_NATIVE|5.015006||Viu +I8_TO_NATIVE_UTF8|5.019004||Viu +I8TYPE|5.006000|5.006000|Vn +I_ARPA_INET|5.005000|5.005000|Vn +ibcmp|5.003007|5.003007| +ibcmp_locale|5.004000|5.004000| +ibcmp_utf8|5.007003|5.007003| +I_CRYPT|5.008000|5.008000|Vn +I_DBM|5.032001|5.032001|Vn +I_DIRENT|5.003007|5.003007|Vn +I_DLFCN|5.003007|5.003007|Vn +I_EXECINFO|5.021001|5.021001|Vn +I_FENV|5.021004|5.021004|Vn +IFMATCH|5.003007||Viu +IFMATCH_A|5.009005||Viu +IFMATCH_A_fail|5.009005||Viu +IFMATCH_A_fail_t8|5.035004||Viu +IFMATCH_A_fail_t8_p8|5.033003||Viu +IFMATCH_A_fail_t8_pb|5.033003||Viu +IFMATCH_A_fail_tb|5.035004||Viu +IFMATCH_A_fail_tb_p8|5.033003||Viu +IFMATCH_A_fail_tb_pb|5.033003||Viu +IFMATCH_A_t8|5.035004||Viu +IFMATCH_A_t8_p8|5.033003||Viu +IFMATCH_A_t8_pb|5.033003||Viu +IFMATCH_A_tb|5.035004||Viu +IFMATCH_A_tb_p8|5.033003||Viu +IFMATCH_A_tb_pb|5.033003||Viu +IFMATCH_t8|5.035004||Viu +IFMATCH_t8_p8|5.033003||Viu +IFMATCH_t8_pb|5.033003||Viu +IFMATCH_tb|5.035004||Viu +IFMATCH_tb_p8|5.033003||Viu +IFMATCH_tb_pb|5.033003||Viu +IFTHEN|5.005000||Viu +IFTHEN_t8|5.035004||Viu +IFTHEN_t8_p8|5.033003||Viu +IFTHEN_t8_pb|5.033003||Viu +IFTHEN_tb|5.035004||Viu +IFTHEN_tb_p8|5.033003||Viu +IFTHEN_tb_pb|5.033003||Viu +I_GDBM|5.021007|5.021007|Vn +I_GDBMNDBM|5.021007|5.021007|Vn +IGNORE_PAT_MOD|5.009005||Viu +I_GRP|5.003007|5.003007|Vn +I_INTTYPES|5.006000|5.006000|Vn +I_LANGINFO|5.007002|5.007002|Vn +I_LIMITS|5.003007||Viu +ILLEGAL_UTF8_BYTE|5.019004||Viu +I_LOCALE|5.003007|5.003007|Vn +I_MNTENT|5.023005|5.023005|Vn +IN_BYTES|5.007002||Viu +incline|5.005000||Viu +INCLUDE_PROTOTYPES|5.007001||Viu +INCMARK|5.023005||Viu +incpush|5.005000||Viu +INCPUSH_APPLLIB_EXP|5.027006||Viu +INCPUSH_APPLLIB_OLD_EXP|5.027006||Viu +INCPUSH_ARCHLIB_EXP|5.027006||Viu +incpush_if_exists|5.009003||Viu +INCPUSH_PERL5LIB|5.027006||Viu +INCPUSH_PERL_OTHERLIBDIRS|5.027006||Viu +INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY|5.027006||Viu +INCPUSH_PERL_VENDORARCH_EXP|5.027006||Viu +INCPUSH_PERL_VENDORLIB_EXP|5.027006||Viu +INCPUSH_PERL_VENDORLIB_STEM|5.027006||Viu +INCPUSH_PRIVLIB_EXP|5.027006||Viu +INCPUSH_SITEARCH_EXP|5.027006||Viu +INCPUSH_SITELIB_EXP|5.027006||Viu +INCPUSH_SITELIB_STEM|5.027006||Viu +incpush_use_sep|5.011000||Viu +I_NDBM|5.032001|5.032001|Vn +inet_addr|5.005000||Viu +I_NETDB|5.005000|5.005000|Vn +I_NETINET_IN|5.003007|5.003007|Vn +I_NETINET_TCP|5.006000|5.006000|Vn +inet_ntoa|5.005000||Viu +INFNAN_NV_U8_DECL|5.023000||Viu +INFNAN_U8_NV_DECL|5.023000||Viu +ingroup|5.003007||Viu +INIT|5.003007||Viu +init_argv_symbols|5.007003||Viu +init_constants|5.017003||Viu +init_dbargs|||iu +init_debugger|5.005000||Viu +init_i18nl10n|5.006000||cVu +init_i18nl14n|5.006000||dcVu +initialize_invlist_guts|5.029002||Viu +init_ids|5.005000||Viu +init_interp|5.005000||Viu +init_main_stash|5.005000||Viu +init_named_cv|5.027010||cViu +init_os_extras|5.005000||Viu +init_perllib|5.005000||Viu +init_postdump_symbols|5.005000||Viu +init_predump_symbols|5.005000||Viu +init_stacks|5.005000|5.005000|u +INIT_THREADS|5.005000||Viu +init_tm|5.007002|5.007002|u +INIT_TRACK_MEMPOOL|5.009004||Viu +init_uniprops|5.027011||Viu +IN_LC|5.021001||Viu +IN_LC_ALL_COMPILETIME|5.021001||Viu +IN_LC_ALL_RUNTIME|5.021001||Viu +IN_LC_COMPILETIME|5.021001||Viu +IN_LC_PARTIAL_COMPILETIME|5.021001||Viu +IN_LC_PARTIAL_RUNTIME|5.021001||Viu +IN_LC_RUNTIME|5.021001||Viu +IN_LOCALE|5.007002|5.004000|p +IN_LOCALE_COMPILETIME|5.007002|5.004000|p +IN_LOCALE_RUNTIME|5.007002|5.004000|p +IN_PERL_COMPILETIME|5.008001|5.003007|p +IN_PERL_RUNTIME|5.008001|5.008001| +inplace_aassign|5.015003||Viu +inRANGE|5.029010||Viu +inRANGE_helper|5.033005||Viu +IN_SOME_LOCALE_FORM|5.015008||Viu +IN_SOME_LOCALE_FORM_COMPILETIME|5.015008||Viu +IN_SOME_LOCALE_FORM_RUNTIME|5.015008||Viu +instr|5.003007|5.003007|n +INSUBP|5.009005||Viu +INSUBP_t8|5.035004||Viu +INSUBP_t8_p8|5.033003||Viu +INSUBP_t8_pb|5.033003||Viu +INSUBP_tb|5.035004||Viu +INSUBP_tb_p8|5.033003||Viu +INSUBP_tb_pb|5.033003||Viu +INT16_C|5.003007|5.003007| +INT2PTR|5.006000|5.003007|p +INT32_C|5.003007|5.003007| +INT32_MIN|5.007002||Viu +INT64_C|5.023002|5.023002| +INT64_MIN|5.007002||Viu +INT_64_T|5.011000||Viu +INTMAX_C|5.003007|5.003007| +INT_PAT_MODS|5.009005||Viu +intro_my|5.021006|5.021006| +INTSIZE|5.003007|5.003007|Vn +intuit_method|5.005000||Viu +intuit_more|5.003007||Viu +IN_UNI_8_BIT|5.011002||Viu +IN_UTF8_CTYPE_LOCALE|5.019009||Viu +_inverse_folds|5.027011||cViu +invert|5.003007||Viu +invlist_array|5.013010||Vniu +_invlist_array_init|5.015001||Vniu +invlist_clear|5.023009||Viu +invlist_clone|5.015001||cViu +_invlist_contains_cp|5.017003||Vniu +invlist_contents|5.023008||Viu +_invlist_dump|5.019003||cViu +_invlistEQ|5.023006||cViu +invlist_extend|5.013010||Viu +invlist_highest|5.017002||Vniu +_invlist_intersection|5.015001||Viu +_invlist_intersection_maybe_complement_2nd|5.015008||cViu +_invlist_invert|5.015001||cViu +invlist_is_iterating|5.017008||Vniu +invlist_iterfinish|5.017008||Vniu +invlist_iterinit|5.015001||Vniu +invlist_iternext|5.015001||Vniu +_invlist_len|5.017004||Vniu +invlist_lowest|5.031007||xVniu +invlist_max|5.013010||Vniu +invlist_previous_index|5.017004||Vniu +invlist_replace_list_destroys_src|5.023009||Viu +_invlist_search|5.017003||cVniu +invlist_set_len|5.013010||Viu +invlist_set_previous_index|5.017004||Vniu +_invlist_subtract|5.015001||Viu +invlist_trim|5.013010||Vniu +_invlist_union|5.015001||cVu +_invlist_union_maybe_complement_2nd|5.015008||cViu +invmap_dump|5.031006||Viu +invoke_exception_hook|5.013001||Viu +IoANY|5.006001||Viu +IoBOTTOM_GV|5.003007||Viu +IoBOTTOM_NAME|5.003007||Viu +io_close|5.003007||Viu +IOCPARM_LEN|5.003007||Viu +ioctl|5.005000||Viu +IoDIRP|5.003007||Viu +IOf_ARGV|5.003007||Viu +IOf_DIDTOP|5.003007||Viu +IOf_FAKE_DIRP|5.006000||Viu +IOf_FLUSH|5.003007||Viu +IoFLAGS|5.003007||Viu +IoFMT_GV|5.003007||Viu +IoFMT_NAME|5.003007||Viu +IOf_NOLINE|5.005003||Viu +IOf_START|5.003007||Viu +IOf_UNTAINT|5.003007||Viu +IoIFP|5.003007||Viu +IoLINES|5.003007||Viu +IoLINES_LEFT|5.003007||Viu +IoOFP|5.003007||Viu +IoPAGE|5.003007||Viu +IoPAGE_LEN|5.003007||Viu +IoTOP_GV|5.003007||Viu +IoTOP_NAME|5.003007||Viu +IoTYPE|5.003007||Viu +IoTYPE_APPEND|5.006001||Viu +IoTYPE_CLOSED|5.006001||Viu +IoTYPE_IMPLICIT|5.008001||Viu +IoTYPE_NUMERIC|5.008001||Viu +IoTYPE_PIPE|5.006001||Viu +IoTYPE_RDONLY|5.006001||Viu +IoTYPE_RDWR|5.006001||Viu +IoTYPE_SOCKET|5.006001||Viu +IoTYPE_STD|5.006001||Viu +IoTYPE_WRONLY|5.006001||Viu +I_POLL|5.006000|5.006000|Vn +I_PTHREAD|5.005003|5.005003|Vn +I_PWD|5.003007|5.003007|Vn +isALNUM|5.003007|5.003007|p +isALNUM_A|5.031003|5.003007|p +isALNUMC|5.006000|5.003007|p +isALNUMC_A|5.013006|5.003007|p +isALNUMC_L1|5.013006|5.003007|p +isALNUMC_LC|5.006000|5.006000| +isALNUMC_LC_utf8_safe|5.031007||Viu +isALNUMC_LC_uvchr|5.017007|5.017007| +isALNUMC_uni|5.017007||Viu +isALNUMC_utf8|5.017007||Viu +isALNUMC_utf8_safe|5.031007||Viu +isALNUM_lazy_if_safe|5.031007||Viu +isALNUM_LC|5.004000|5.004000| +isALNUM_LC_utf8|5.006000||Viu +isALNUM_LC_utf8_safe|5.031007||Viu +isALNUM_LC_uvchr|5.007001|5.007001| +isALNUMU|5.011005||Viu +isALNUM_uni|5.006000||Viu +isALNUM_utf8|5.006000||Viu +isALNUM_utf8_safe|5.031007||Viu +isa_lookup|5.005000||Viu +isALPHA|5.003007|5.003007|p +isALPHA_A|5.013006|5.003007|p +isALPHA_FOLD_EQ|5.021004||Viu +isALPHA_FOLD_NE|5.021004||Viu +isALPHA_L1|5.013006|5.003007|p +isALPHA_LC|5.004000|5.004000| +isALPHA_LC_utf8|5.006000||Viu +isALPHA_LC_utf8_safe|5.025009|5.006000|p +isALPHA_LC_uvchr|5.007001|5.007001| +isALPHANUMERIC|5.017008|5.003007|p +isALPHANUMERIC_A|5.017008|5.003007|p +isALPHANUMERIC_L1|5.017008|5.003007|p +isALPHANUMERIC_LC|5.017008|5.004000|p +isALPHANUMERIC_LC_utf8|5.017008||Viu +isALPHANUMERIC_LC_utf8_safe|5.025009|5.006000|p +isALPHANUMERIC_LC_uvchr|5.017008|5.017008| +isALPHANUMERIC_uni|5.017008||Viu +isALPHANUMERIC_utf8|5.031005|5.031005| +isALPHANUMERIC_utf8_safe|5.025009|5.006000|p +isALPHANUMERIC_uvchr|5.023009|5.006000|p +isALPHAU|5.011005||Viu +isALPHA_uni|5.006000||Viu +isALPHA_utf8|5.031005|5.031005| +isALPHA_utf8_safe|5.025009|5.006000|p +isALPHA_uvchr|5.023009|5.006000|p +is_an_int|5.005000||Viu +is_ANYOF_SYNTHETIC|5.019009||Viu +IS_ANYOF_TRIE|5.009005||Viu +isASCII|5.006000|5.003007|p +isASCII_A|5.013006|5.003007|p +isASCII_L1|5.015004|5.003007|p +isASCII_LC|5.015008|5.003007|p +isASCII_LC_utf8|5.017007||Viu +isASCII_LC_utf8_safe|5.025009|5.025009| +isASCII_LC_uvchr|5.017007|5.017007| +is_ascii_string|5.011000|5.011000|n +isASCII_uni|5.006000||Viu +isASCII_utf8|5.031005|5.031005| +isASCII_utf8_safe|5.025009|5.003007|p +isASCII_uvchr|5.023009|5.003007|p +isatty|5.005000||Viu +ISA_VERSION_OBJ|5.019008||Viu +isBLANK|5.006001|5.003007|p +isBLANK_A|5.013006|5.003007|p +isBLANK_L1|5.013006|5.003007|p +isBLANK_LC|5.006001|5.003007|p +isBLANK_LC_uni|5.006001||Viu +isBLANK_LC_utf8|5.006001||Viu +isBLANK_LC_utf8_safe|5.025009|5.006000|p +isBLANK_LC_uvchr|5.017007|5.017007| +isBLANK_uni|5.006001||Viu +isBLANK_utf8|5.031005|5.031005| +isBLANK_utf8_safe|5.025009|5.006000|p +isBLANK_uvchr|5.023009|5.006000|p +isC9_STRICT_UTF8_CHAR|5.025005|5.025005|n +is_c9strict_utf8_string|5.025006|5.025006|n +is_c9strict_utf8_string_loc|5.025006|5.025006|n +is_c9strict_utf8_string_loclen|5.025006|5.025006|n +isCHARNAME_CONT|5.011005||Viu +isCNTRL|5.006000|5.003007|p +isCNTRL_A|5.013006|5.003007|p +isCNTRL_L1|5.013006|5.003007|p +isCNTRL_LC|5.006000|5.006000| +isCNTRL_LC_utf8|5.006000||Viu +isCNTRL_LC_utf8_safe|5.025009|5.006000|p +isCNTRL_LC_uvchr|5.007001|5.007001| +isCNTRL_uni|5.006000||Viu +isCNTRL_utf8|5.031005|5.031005| +isCNTRL_utf8_safe|5.025009|5.006000|p +isCNTRL_uvchr|5.023009|5.006000|p +_is_cur_LC_category_utf8|5.021001||cVu +isDEBUG_WILDCARD|5.031011||Viu +isDIGIT|5.003007|5.003007|p +isDIGIT_A|5.013006|5.003007|p +isDIGIT_L1|5.013006|5.003007|p +isDIGIT_LC|5.004000|5.004000| +isDIGIT_LC_utf8|5.006000||Viu +isDIGIT_LC_utf8_safe|5.025009|5.006000|p +isDIGIT_LC_uvchr|5.007001|5.007001| +isDIGIT_uni|5.006000||Viu +isDIGIT_utf8|5.031005|5.031005| +isDIGIT_utf8_safe|5.025009|5.006000|p +isDIGIT_uvchr|5.023009|5.006000|p +isEXACTFish|5.033003||Viu +isEXACT_REQ8|5.033003||Viu +isFF_overlong|5.035004||Vniu +is_FOLDS_TO_MULTI_utf8|5.019009||Viu +isFOO_lc|5.017007||Viu +isFOO_utf8_lc|5.017008||Viu +isGCB|5.021009||Viu +isGRAPH|5.006000|5.003007|p +isGRAPH_A|5.013006|5.003007|p +is_grapheme|5.031007||Viu +isGRAPH_L1|5.013006|5.003007|p +isGRAPH_LC|5.006000|5.006000| +isGRAPH_LC_utf8|5.006000||Viu +isGRAPH_LC_utf8_safe|5.025009|5.006000|p +isGRAPH_LC_uvchr|5.007001|5.007001| +isGRAPH_uni|5.006000||Viu +isGRAPH_utf8|5.031005|5.031005| +isGRAPH_utf8_safe|5.025009|5.006000|p +isGRAPH_uvchr|5.023009|5.006000|p +isGV|5.003007||Viu +isGV_or_RVCV|5.027005||Viu +isGV_with_GP|5.009004|5.003007|p +isGV_with_GP_off|5.009005||Viu +isGV_with_GP_on|5.009005||Viu +I_SHADOW|5.006000|5.006000|Vn +is_handle_constructor|5.006000||Vniu +is_HANGUL_ED_utf8_safe|5.029001||Viu +is_HORIZWS_cp_high|5.017006||Viu +is_HORIZWS_high|5.017006||Viu +isIDCONT|5.017008|5.003007|p +isIDCONT_A|5.017008|5.003007|p +isIDCONT_L1|5.017008|5.003007|p +isIDCONT_LC|5.017008|5.004000|p +isIDCONT_LC_utf8|5.017008||Viu +isIDCONT_LC_utf8_safe|5.025009|5.006000|p +isIDCONT_LC_uvchr|5.017008|5.017008| +isIDCONT_uni|5.017008||Viu +isIDCONT_utf8|5.031005|5.031005| +isIDCONT_utf8_safe|5.025009|5.006000|p +isIDCONT_uvchr|5.023009|5.006000|p +isIDFIRST|5.003007|5.003007|p +isIDFIRST_A|5.013006|5.003007|p +isIDFIRST_L1|5.013006|5.003007|p +isIDFIRST_lazy_if_safe|5.025009||Viu +isIDFIRST_LC|5.004000|5.004000|p +isIDFIRST_LC_utf8|5.006000||Viu +isIDFIRST_LC_utf8_safe|5.025009|5.006000|p +isIDFIRST_LC_uvchr|5.007001|5.007001| +isIDFIRST_uni|5.006000||Viu +isIDFIRST_utf8|5.031005|5.031005| +isIDFIRST_utf8_safe|5.025009|5.006000|p +isIDFIRST_uvchr|5.023009|5.006000|p +isinfnan|5.021004|5.021004|n +isinfnansv|5.021005||Vi +_is_in_locale_category|5.021001||cViu +IS_IN_SOME_FOLD_L1|5.033005||Viu +is_invariant_string|5.021007|5.011000|pn +is_invlist|5.029002||Vniu +is_LARGER_NON_CHARS_utf8|5.035003||Viu +is_LAX_VERSION|5.011004||Viu +isLB|5.023007||Viu +isLEXWARN_off|5.006000||Viu +isLEXWARN_on|5.006000||Viu +is_LNBREAK_latin1_safe|5.009005||Viu +is_LNBREAK_safe|5.009005||Viu +is_LNBREAK_utf8_safe|5.009005||Viu +isLOWER|5.003007|5.003007|p +isLOWER_A|5.013006|5.003007|p +isLOWER_L1|5.013006|5.003007|p +isLOWER_LC|5.004000|5.004000| +isLOWER_LC_utf8|5.006000||Viu +isLOWER_LC_utf8_safe|5.025009|5.006000|p +isLOWER_LC_uvchr|5.007001|5.007001| +isLOWER_uni|5.006000||Viu +isLOWER_utf8|5.031005|5.031005| +isLOWER_utf8_safe|5.025009|5.006000|p +isLOWER_uvchr|5.023009|5.006000|p +is_lvalue_sub|5.007001|5.007001|u +isMNEMONIC_CNTRL|5.031009||Viu +is_MULTI_CHAR_FOLD_latin1_safe|5.019010||Viu +is_MULTI_CHAR_FOLD_utf8_safe|5.019010||Viu +is_MULTI_CHAR_FOLD_utf8_safe_part0|5.019010||Viu +is_MULTI_CHAR_FOLD_utf8_safe_part1|5.019010||Viu +is_MULTI_CHAR_FOLD_utf8_safe_part2|5.025008||Viu +is_MULTI_CHAR_FOLD_utf8_safe_part3|5.025008||Viu +is_NONCHAR_utf8_safe|5.025005||Viu +IS_NON_FINAL_FOLD|5.033005||Viu +isnormal|5.021004||Viu +IS_NUMBER_GREATER_THAN_UV_MAX|5.007002|5.003007|p +IS_NUMBER_INFINITY|5.007002|5.003007|p +IS_NUMBER_IN_UV|5.007002|5.003007|p +IS_NUMBER_NAN|5.007003|5.003007|p +IS_NUMBER_NEG|5.007002|5.003007|p +IS_NUMBER_NOT_INT|5.007002|5.003007|p +IS_NUMBER_TRAILING|5.021002||Viu +IS_NUMERIC_RADIX|5.006000||Viu +isOCTAL|5.013005|5.003007|p +isOCTAL_A|5.013006|5.003007|p +isOCTAL_L1|5.013006|5.003007|p +IS_PADCONST|5.006000||Viu +IS_PADGV|5.006000||Viu +is_PATWS_safe|5.017008||Viu +isPOWER_OF_2|5.029006||Viu +isPRINT|5.004000|5.003007|p +isPRINT_A|5.013006|5.003007|p +isPRINT_L1|5.013006|5.003007|p +isPRINT_LC|5.004000|5.004000| +isPRINT_LC_utf8|5.006000||Viu +isPRINT_LC_utf8_safe|5.025009|5.006000|p +isPRINT_LC_uvchr|5.007001|5.007001| +isPRINT_uni|5.006000||Viu +isPRINT_utf8|5.031005|5.031005| +isPRINT_utf8_safe|5.025009|5.006000|p +isPRINT_uvchr|5.023009|5.006000|p +is_PROBLEMATIC_LOCALE_FOLD_cp|5.019009||Viu +is_PROBLEMATIC_LOCALE_FOLDEDS_START_cp|5.019009||Viu +is_PROBLEMATIC_LOCALE_FOLDEDS_START_utf8|5.019009||Viu +is_PROBLEMATIC_LOCALE_FOLD_utf8|5.019009||Viu +isPSXSPC|5.006001|5.003007|p +isPSXSPC_A|5.013006|5.003007|p +isPSXSPC_L1|5.013006|5.003007|p +isPSXSPC_LC|5.006001|5.006001| +isPSXSPC_LC_utf8|5.006001||Viu +isPSXSPC_LC_utf8_safe|5.025009|5.006000|p +isPSXSPC_LC_uvchr|5.017007|5.017007| +isPSXSPC_uni|5.006001||Viu +isPSXSPC_utf8|5.031005|5.031005| +isPSXSPC_utf8_safe|5.025009|5.006000|p +isPSXSPC_uvchr|5.023009|5.006000|p +isPUNCT|5.006000|5.003007|p +isPUNCT_A|5.013006|5.003007|p +isPUNCT_L1|5.013006|5.003007|p +isPUNCT_LC|5.006000|5.006000| +isPUNCT_LC_utf8|5.006000||Viu +isPUNCT_LC_utf8_safe|5.025009|5.006000|p +isPUNCT_LC_uvchr|5.007001|5.007001| +isPUNCT_uni|5.006000||Viu +isPUNCT_utf8|5.031005|5.031005| +isPUNCT_utf8_safe|5.025009|5.006000|p +isPUNCT_uvchr|5.023009|5.006000|p +is_QUOTEMETA_high|5.017004||Viu +isREGEXP|5.017006||Viu +IS_SAFE_PATHNAME|5.019004||Viu +IS_SAFE_SYSCALL|5.019004|5.019004| +is_safe_syscall|5.019004|5.019004| +isSB|5.021009||Viu +isSCRIPT_RUN|5.027008||cVi +is_SHORTER_NON_CHARS_utf8|5.035003||Viu +isSPACE|5.003007|5.003007|p +isSPACE_A|5.013006|5.003007|p +isSPACE_L1|5.013006|5.003007|p +isSPACE_LC|5.004000|5.004000| +isSPACE_LC_utf8|5.006000||Viu +isSPACE_LC_utf8_safe|5.025009|5.006000|p +isSPACE_LC_uvchr|5.007001|5.007001| +isSPACE_uni|5.006000||Viu +isSPACE_utf8|5.031005|5.031005| +isSPACE_utf8_safe|5.025009|5.006000|p +isSPACE_uvchr|5.023009|5.006000|p +is_ssc_worth_it|5.021005||Vniu +isSTRICT_UTF8_CHAR|5.025005|5.025005|n +is_strict_utf8_string|5.025006|5.025006|n +is_strict_utf8_string_loc|5.025006|5.025006|n +is_strict_utf8_string_loclen|5.025006|5.025006|n +is_STRICT_VERSION|5.011004||Viu +is_SURROGATE_utf8|5.035004||Viu +is_SURROGATE_utf8_safe|5.025005||Viu +I_STDARG|5.003007||Viu +I_STDBOOL|5.015003|5.015003|Vn +I_STDINT|5.021004|5.021004|Vn +is_THREE_CHAR_FOLD_HEAD_latin1_safe|5.031007||Viu +is_THREE_CHAR_FOLD_HEAD_utf8_safe|5.031007||Viu +is_THREE_CHAR_FOLD_latin1_safe|5.031007||Viu +is_THREE_CHAR_FOLD_utf8_safe|5.031007||Viu +IS_TRIE_AC|5.009005||Viu +isUNICODE_POSSIBLY_PROBLEMATIC|5.035004||Viu +_is_uni_FOO|5.017008||cVu +_is_uni_perl_idcont|5.017008||cVu +_is_uni_perl_idstart|5.017007||cVu +isUPPER|5.003007|5.003007|p +isUPPER_A|5.013006|5.003007|p +isUPPER_L1|5.013006|5.003007|p +isUPPER_LC|5.004000|5.004000| +isUPPER_LC_utf8|5.006000||Viu +isUPPER_LC_utf8_safe|5.025009|5.006000|p +isUPPER_LC_uvchr|5.007001|5.007001| +isUPPER_uni|5.006000||Viu +isUPPER_utf8|5.031005|5.031005| +isUPPER_utf8_safe|5.025009|5.006000|p +isUPPER_uvchr|5.023009|5.006000|p +is_utf8_char|5.006000|5.006000|dn +IS_UTF8_CHAR|5.009003||Viu +isUTF8_CHAR|5.021001|5.006001|pn +is_utf8_char_buf|5.015008|5.015008|n +isUTF8_CHAR_flags|5.025005|5.025005|n +is_utf8_char_helper_|5.035004||cVnu +is_utf8_common|5.009003||Viu +is_utf8_FF_helper_|5.035004||cVnu +is_utf8_fixed_width_buf_flags|5.025006|5.025006|n +is_utf8_fixed_width_buf_loc_flags|5.025006|5.025006|n +is_utf8_fixed_width_buf_loclen_flags|5.025006|5.025006|n +_is_utf8_FOO|5.031006||cVu +is_utf8_invariant_string|5.025005|5.011000|pn +is_utf8_invariant_string_loc|5.027001|5.027001|n +is_utf8_non_invariant_string|5.027007||cVni +is_utf8_overlong|5.035004||Vniu +_is_utf8_perl_idcont|5.031006||cVu +_is_utf8_perl_idstart|5.031006||cVu +isUTF8_POSSIBLY_PROBLEMATIC|5.023003||Viu +is_utf8_string|5.006001|5.006001|n +is_utf8_string_flags|5.025006|5.025006|n +is_utf8_string_loc|5.008001|5.008001|n +is_utf8_string_loc_flags|5.025006|5.025006|n +is_utf8_string_loclen|5.009003|5.009003|n +is_utf8_string_loclen_flags|5.025006|5.025006|n +is_utf8_valid_partial_char|5.025005|5.025005|n +is_utf8_valid_partial_char_flags|5.025005|5.025005|n +is_VERTWS_cp_high|5.017006||Viu +is_VERTWS_high|5.017006||Viu +isVERTWS_uni|5.017006||Viu +isVERTWS_utf8|5.017006||Viu +isVERTWS_utf8_safe|5.025009||Viu +isVERTWS_uvchr|5.023009||Viu +isWARNf_on|5.006001||Viu +isWARN_on|5.006000||Viu +isWARN_ONCE|5.006000||Viu +isWB|5.021009||Viu +isWORDCHAR|5.013006|5.003007|p +isWORDCHAR_A|5.013006|5.003007|p +isWORDCHAR_L1|5.013006|5.003007|p +isWORDCHAR_lazy_if_safe|5.025009||Viu +isWORDCHAR_LC|5.017007|5.004000|p +isWORDCHAR_LC_utf8|5.017007||Viu +isWORDCHAR_LC_utf8_safe|5.025009|5.006000|p +isWORDCHAR_LC_uvchr|5.017007|5.017007| +isWORDCHAR_uni|5.017006||Viu +isWORDCHAR_utf8|5.031005|5.031005| +isWORDCHAR_utf8_safe|5.025009|5.006000|p +isWORDCHAR_uvchr|5.023009|5.006000|p +isXDIGIT|5.006000|5.003007|p +isXDIGIT_A|5.013006|5.003007|p +is_XDIGIT_cp_high|5.017006||Viu +is_XDIGIT_high|5.017006||Viu +isXDIGIT_L1|5.013006|5.003007|p +isXDIGIT_LC|5.017007|5.003007|p +isXDIGIT_LC_utf8|5.017007||Viu +isXDIGIT_LC_utf8_safe|5.025009|5.006000|p +isXDIGIT_LC_uvchr|5.017007|5.017007| +isXDIGIT_uni|5.006000||Viu +isXDIGIT_utf8|5.031005|5.031005| +isXDIGIT_utf8_safe|5.025009|5.006000|p +isXDIGIT_uvchr|5.023009|5.006000|p +is_XPERLSPACE_cp_high|5.017006||Viu +is_XPERLSPACE_high|5.017006||Viu +I_SYS_DIR|5.003007|5.003007|Vn +I_SYS_FILE|5.003007|5.003007|Vn +I_SYS_IOCTL|5.003007|5.003007|Vn +I_SYSLOG|5.006000|5.006000|Vn +I_SYS_MOUNT|5.023005|5.023005|Vn +I_SYS_PARAM|5.003007|5.003007|Vn +I_SYS_POLL|5.010001|5.010001|Vn +I_SYS_RESOURCE|5.003007|5.003007|Vn +I_SYS_SELECT|5.003007|5.003007|Vn +I_SYS_STAT|5.003007|5.003007|Vn +I_SYS_STATFS|5.023005|5.023005|Vn +I_SYS_STATVFS|5.023005|5.023005|Vn +I_SYS_TIME|5.003007|5.003007|Vn +I_SYS_TIMES|5.003007|5.003007|Vn +I_SYS_TYPES|5.003007|5.003007|Vn +I_SYSUIO|5.006000|5.006000|Vn +I_SYS_UN|5.003007|5.003007|Vn +I_SYSUTSNAME|5.006000|5.006000|Vn +I_SYS_VFS|5.023005|5.023005|Vn +I_SYS_WAIT|5.003007|5.003007|Vn +items||5.003007| +I_TERMIOS|5.003007|5.003007|Vn +I_TIME|5.003007|5.003007|Vn +I_UNISTD|5.003007|5.003007|Vn +I_USTAT|5.023005|5.023005|Vn +I_UTIME|5.003007|5.003007|Vn +I_V|5.006000|5.003007| +IVdf|5.006000|5.003007|poVn +IV_DIG|5.006000||Viu +IV_IS_QUAD|5.006000||Viu +IV_MAX|5.003007|5.003007| +IV_MAX_P1|5.007002||Viu +IV_MIN|5.003007|5.003007| +IVSIZE|5.006000|5.003007|poVn +IVTYPE|5.006000|5.003007|poVn +I_WCHAR|5.027006|5.027006|Vn +I_WCTYPE|5.029009|5.029009|Vn +ix||5.003007| +I_XLOCALE|5.025004|5.025004|Vn +JE_OLD_STACK_HWM_restore|5.027002||Viu +JE_OLD_STACK_HWM_save|5.027002||Viu +JE_OLD_STACK_HWM_zero|5.027002||Viu +jmaybe|5.003007||Viu +JMPENV_BOOTSTRAP|5.006000||Viu +JMPENV_JUMP|5.004000|5.004000| +JMPENV_POP|5.004000||Viu +JMPENV_PUSH|5.004000||Viu +JOIN|5.005000||Viu +join_exact|5.009004||Viu +kBINOP|5.003007||Viu +kCOP|5.003007||Viu +KEEPCOPY_PAT_MOD|5.009005||Viu +KEEPCOPY_PAT_MODS|5.009005||Viu +KEEPS|5.009005||Viu +KEEPS_next|5.009005||Viu +KEEPS_next_fail|5.009005||Viu +KEEPS_next_fail_t8|5.035004||Viu +KEEPS_next_fail_t8_p8|5.033003||Viu +KEEPS_next_fail_t8_pb|5.033003||Viu +KEEPS_next_fail_tb|5.035004||Viu +KEEPS_next_fail_tb_p8|5.033003||Viu +KEEPS_next_fail_tb_pb|5.033003||Viu +KEEPS_next_t8|5.035004||Viu +KEEPS_next_t8_p8|5.033003||Viu +KEEPS_next_t8_pb|5.033003||Viu +KEEPS_next_tb|5.035004||Viu +KEEPS_next_tb_p8|5.033003||Viu +KEEPS_next_tb_pb|5.033003||Viu +KEEPS_t8|5.035004||Viu +KEEPS_t8_p8|5.033003||Viu +KEEPS_t8_pb|5.033003||Viu +KEEPS_tb|5.035004||Viu +KEEPS_tb_p8|5.033003||Viu +KEEPS_tb_pb|5.033003||Viu +KELVIN_SIGN|5.017003||Viu +KERNEL|5.003007||Viu +KEY_abs|5.003007||Viu +KEY_accept|5.003007||Viu +KEY_alarm|5.003007||Viu +KEY_and|5.003007||Viu +KEY_atan2|5.003007||Viu +KEY_AUTOLOAD|5.003007||Viu +KEY_BEGIN|5.003007||Viu +KEY_bind|5.003007||Viu +KEY_binmode|5.003007||Viu +KEY_bless|5.003007||Viu +KEY_break|5.027008||Viu +KEY_caller|5.003007||Viu +KEY_catch|5.033007||Viu +KEY_chdir|5.003007||Viu +KEY_CHECK|5.006000||Viu +KEY_chmod|5.003007||Viu +KEY_chomp|5.003007||Viu +KEY_chop|5.003007||Viu +KEY_chown|5.003007||Viu +KEY_chr|5.003007||Viu +KEY_chroot|5.003007||Viu +KEY_close|5.003007||Viu +KEY_closedir|5.003007||Viu +KEY_cmp|5.003007||Viu +KEY_connect|5.003007||Viu +KEY_continue|5.003007||Viu +KEY_cos|5.003007||Viu +KEY_crypt|5.003007||Viu +KEY___DATA|5.003007||Viu +KEY_dbmclose|5.003007||Viu +KEY_dbmopen|5.003007||Viu +KEY_default|5.027008||Viu +KEY_defer|5.035004||Viu +KEY_defined|5.003007||Viu +KEY_delete|5.003007||Viu +KEY_DESTROY|5.003007||Viu +KEY_die|5.003007||Viu +KEY_do|5.003007||Viu +KEY_dump|5.003007||Viu +KEY_each|5.003007||Viu +KEY_else|5.003007||Viu +KEY_elsif|5.003007||Viu +KEY___END|5.003007||Viu +KEY_END|5.003007||Viu +KEY_endgrent|5.003007||Viu +KEY_endhostent|5.003007||Viu +KEY_endnetent|5.003007||Viu +KEY_endprotoent|5.003007||Viu +KEY_endpwent|5.003007||Viu +KEY_endservent|5.003007||Viu +KEY_eof|5.003007||Viu +KEY_eq|5.003007||Viu +KEY_eval|5.003007||Viu +KEY_evalbytes|5.015005||Viu +KEY_exec|5.003007||Viu +KEY_exists|5.003007||Viu +KEY_exit|5.003007||Viu +KEY_exp|5.003007||Viu +KEY_fc|5.015008||Viu +KEY_fcntl|5.003007||Viu +KEY___FILE|5.003007||Viu +KEY_fileno|5.003007||Viu +KEY_finally|5.035008||Viu +KEY_flock|5.003007||Viu +KEY_for|5.003007||Viu +KEY_foreach|5.003007||Viu +KEY_fork|5.003007||Viu +KEY_format|5.003007||Viu +KEY_formline|5.003007||Viu +KEY_ge|5.003007||Viu +KEY_getc|5.003007||Viu +KEY_getgrent|5.003007||Viu +KEY_getgrgid|5.003007||Viu +KEY_getgrnam|5.003007||Viu +KEY_gethostbyaddr|5.003007||Viu +KEY_gethostbyname|5.003007||Viu +KEY_gethostent|5.003007||Viu +KEY_getlogin|5.003007||Viu +KEY_getnetbyaddr|5.003007||Viu +KEY_getnetbyname|5.003007||Viu +KEY_getnetent|5.003007||Viu +KEY_getpeername|5.003007||Viu +KEY_getpgrp|5.003007||Viu +KEY_getppid|5.003007||Viu +KEY_getpriority|5.003007||Viu +KEY_getprotobyname|5.003007||Viu +KEY_getprotobynumber|5.003007||Viu +KEY_getprotoent|5.003007||Viu +KEY_getpwent|5.003007||Viu +KEY_getpwnam|5.003007||Viu +KEY_getpwuid|5.003007||Viu +KEY_getservbyname|5.003007||Viu +KEY_getservbyport|5.003007||Viu +KEY_getservent|5.003007||Viu +KEY_getsockname|5.003007||Viu +KEY_getsockopt|5.003007||Viu +KEY_getspnam|5.031011||Viu +KEY_given|5.009003||Viu +KEY_glob|5.003007||Viu +KEY_gmtime|5.003007||Viu +KEY_goto|5.003007||Viu +KEY_grep|5.003007||Viu +KEY_gt|5.003007||Viu +KEY_hex|5.003007||Viu +KEY_if|5.003007||Viu +KEY_index|5.003007||Viu +KEY_INIT|5.005000||Viu +KEY_int|5.003007||Viu +KEY_ioctl|5.003007||Viu +KEY_isa|5.031007||Viu +KEY_join|5.003007||Viu +KEY_keys|5.003007||Viu +KEY_kill|5.003007||Viu +KEY_last|5.003007||Viu +KEY_lc|5.003007||Viu +KEY_lcfirst|5.003007||Viu +KEY_le|5.003007||Viu +KEY_length|5.003007||Viu +KEY___LINE|5.003007||Viu +KEY_link|5.003007||Viu +KEY_listen|5.003007||Viu +KEY_local|5.003007||Viu +KEY_localtime|5.003007||Viu +KEY_lock|5.005000||Viu +KEY_log|5.003007||Viu +KEY_lstat|5.003007||Viu +KEY_lt|5.003007||Viu +KEY_m|5.003007||Viu +KEY_map|5.003007||Viu +KEY_mkdir|5.003007||Viu +KEY_msgctl|5.003007||Viu +KEY_msgget|5.003007||Viu +KEY_msgrcv|5.003007||Viu +KEY_msgsnd|5.003007||Viu +KEY_my|5.003007||Viu +KEY_ne|5.003007||Viu +KEY_next|5.003007||Viu +KEY_no|5.003007||Viu +KEY_not|5.003007||Viu +KEY_NULL|5.003007||Viu +KEY_oct|5.003007||Viu +KEY_open|5.003007||Viu +KEY_opendir|5.003007||Viu +KEY_or|5.003007||Viu +KEY_ord|5.003007||Viu +KEY_our|5.006000||Viu +KEY_pack|5.003007||Viu +KEY_package|5.003007||Viu +KEY___PACKAGE|5.004000||Viu +KEY_pipe|5.003007||Viu +KEY_pop|5.003007||Viu +KEY_pos|5.003007||Viu +KEY_print|5.003007||Viu +KEY_printf|5.003007||Viu +KEY_prototype|5.003007||Viu +KEY_push|5.003007||Viu +KEY_q|5.003007||Viu +KEY_qq|5.003007||Viu +KEY_qr|5.005000||Viu +KEY_quotemeta|5.003007||Viu +KEY_qw|5.003007||Viu +KEY_qx|5.003007||Viu +KEY_rand|5.003007||Viu +KEY_read|5.003007||Viu +KEY_readdir|5.003007||Viu +KEY_readline|5.003007||Viu +KEY_readlink|5.003007||Viu +KEY_readpipe|5.003007||Viu +KEY_recv|5.003007||Viu +KEY_redo|5.003007||Viu +KEY_ref|5.003007||Viu +KEY_rename|5.003007||Viu +KEY_require|5.003007||Viu +KEY_reset|5.003007||Viu +KEY_return|5.003007||Viu +KEY_reverse|5.003007||Viu +KEY_rewinddir|5.003007||Viu +KEY_rindex|5.003007||Viu +KEY_rmdir|5.003007||Viu +KEY_s|5.003007||Viu +KEY_say|5.009003||Viu +KEY_scalar|5.003007||Viu +KEY_seek|5.003007||Viu +KEY_seekdir|5.003007||Viu +KEY_select|5.003007||Viu +KEY_semctl|5.003007||Viu +KEY_semget|5.003007||Viu +KEY_semop|5.003007||Viu +KEY_send|5.003007||Viu +KEY_setgrent|5.003007||Viu +KEY_sethostent|5.003007||Viu +KEY_setnetent|5.003007||Viu +KEY_setpgrp|5.003007||Viu +KEY_setpriority|5.003007||Viu +KEY_setprotoent|5.003007||Viu +KEY_setpwent|5.003007||Viu +KEY_setservent|5.003007||Viu +KEY_setsockopt|5.003007||Viu +KEY_shift|5.003007||Viu +KEY_shmctl|5.003007||Viu +KEY_shmget|5.003007||Viu +KEY_shmread|5.003007||Viu +KEY_shmwrite|5.003007||Viu +KEY_shutdown|5.003007||Viu +KEY_sigvar|5.025004||Viu +KEY_sin|5.003007||Viu +KEY_sleep|5.003007||Viu +KEY_socket|5.003007||Viu +KEY_socketpair|5.003007||Viu +KEY_sort|5.003007||Viu +KEY_splice|5.003007||Viu +KEY_split|5.003007||Viu +KEY_sprintf|5.003007||Viu +KEY_sqrt|5.003007||Viu +KEY_srand|5.003007||Viu +KEY_stat|5.003007||Viu +KEY_state|5.009004||Viu +KEY_study|5.003007||Viu +KEY_sub|5.003007||Viu +KEY___SUB|5.015006||Viu +KEY_substr|5.003007||Viu +KEY_symlink|5.003007||Viu +KEY_syscall|5.003007||Viu +KEY_sysopen|5.003007||Viu +KEY_sysread|5.003007||Viu +KEY_sysseek|5.004000||Viu +KEY_system|5.003007||Viu +KEY_syswrite|5.003007||Viu +KEY_tell|5.003007||Viu +KEY_telldir|5.003007||Viu +KEY_tie|5.003007||Viu +KEY_tied|5.003007||Viu +KEY_time|5.003007||Viu +KEY_times|5.003007||Viu +KEY_tr|5.003007||Viu +KEY_truncate|5.003007||Viu +KEY_try|5.033007||Viu +KEY_uc|5.003007||Viu +KEY_ucfirst|5.003007||Viu +KEY_umask|5.003007||Viu +KEY_undef|5.003007||Viu +KEY_UNITCHECK|5.009005||Viu +KEY_unless|5.003007||Viu +KEY_unlink|5.003007||Viu +KEY_unpack|5.003007||Viu +KEY_unshift|5.003007||Viu +KEY_untie|5.003007||Viu +KEY_until|5.003007||Viu +KEY_use|5.003007||Viu +KEY_utime|5.003007||Viu +KEY_values|5.003007||Viu +KEY_vec|5.003007||Viu +KEY_wait|5.003007||Viu +KEY_waitpid|5.003007||Viu +KEY_wantarray|5.003007||Viu +KEY_warn|5.003007||Viu +KEY_when|5.027008||Viu +KEY_while|5.003007||Viu +keyword|5.003007||Viu +KEYWORD_PLUGIN_DECLINE|5.011002||Viu +KEYWORD_PLUGIN_EXPR|5.011002||Viu +KEYWORD_PLUGIN_MUTEX_INIT|5.027006||Viu +KEYWORD_PLUGIN_MUTEX_LOCK|5.027006||Viu +KEYWORD_PLUGIN_MUTEX_TERM|5.027006||Viu +KEYWORD_PLUGIN_MUTEX_UNLOCK|5.027006||Viu +keyword_plugin_standard|||iu +KEYWORD_PLUGIN_STMT|5.011002||Viu +KEY_write|5.003007||Viu +KEY_x|5.003007||Viu +KEY_xor|5.003007||Viu +KEY_y|5.003007||Viu +kGVOP_gv|5.006000||Viu +kill|5.005000||Viu +killpg|5.005000||Viu +kLISTOP|5.003007||Viu +kLOGOP|5.003007||Viu +kLOOP|5.003007||Viu +kPADOP|5.006000||Viu +kPMOP|5.003007||Viu +kPVOP|5.003007||Viu +kSVOP|5.003007||Viu +kSVOP_sv|5.006000||Viu +kUNOP|5.003007||Viu +kUNOP_AUX|5.021007||Viu +LATIN1_TO_NATIVE|5.019004|5.003007|p +LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE|5.013011||Viu +LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE_NATIVE|5.017004||Viu +LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE|5.023002||Viu +LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_UTF8|5.023002||Viu +LATIN_CAPITAL_LETTER_SHARP_S|5.014000||Viu +LATIN_CAPITAL_LETTER_SHARP_S_UTF8|5.019001||Viu +LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS|5.013011||Viu +LATIN_SMALL_LETTER_A_WITH_RING_ABOVE|5.013011||Viu +LATIN_SMALL_LETTER_A_WITH_RING_ABOVE_NATIVE|5.017004||Viu +LATIN_SMALL_LETTER_DOTLESS_I|5.023002||Viu +LATIN_SMALL_LETTER_DOTLESS_I_UTF8|5.023002||Viu +LATIN_SMALL_LETTER_LONG_S|5.017003||Viu +LATIN_SMALL_LETTER_LONG_S_UTF8|5.019001||Viu +LATIN_SMALL_LETTER_SHARP_S|5.011002||Viu +LATIN_SMALL_LETTER_SHARP_S_NATIVE|5.017004||Viu +LATIN_SMALL_LETTER_SHARP_S_UTF8|5.033003||Viu +LATIN_SMALL_LETTER_Y_WITH_DIAERESIS|5.011002||Viu +LATIN_SMALL_LETTER_Y_WITH_DIAERESIS_NATIVE|5.017004||Viu +LATIN_SMALL_LIGATURE_LONG_S_T|5.019004||Viu +LATIN_SMALL_LIGATURE_LONG_S_T_UTF8|5.019004||Viu +LATIN_SMALL_LIGATURE_ST|5.019004||Viu +LATIN_SMALL_LIGATURE_ST_UTF8|5.019004||Viu +LB_BREAKABLE|5.023007||Viu +LB_CM_ZWJ_foo|5.025003||Viu +LB_HY_or_BA_then_foo|5.023007||Viu +LB_NOBREAK|5.023007||Viu +LB_NOBREAK_EVEN_WITH_SP_BETWEEN|5.023007||Viu +LB_PR_or_PO_then_OP_or_HY|5.023007||Viu +LB_RI_then_RI|5.025003||Viu +LB_SP_foo|5.023007||Viu +LB_SY_or_IS_then_various|5.023007||Viu +LB_various_then_PO_or_PR|5.023007||Viu +LC_NUMERIC_LOCK|5.027009||pVu +LC_NUMERIC_UNLOCK|5.027009||pVu +LDBL_DIG|5.006000||Viu +LEAVE|5.003007|5.003007| +leave_adjust_stacks|5.023008|5.023008|xu +leave_scope|5.003007|5.003007|u +LEAVE_SCOPE|5.003007||Viu +LEAVE_with_name|5.011002|5.011002| +LEXACT|5.031005||Viu +LEXACT_REQ8|5.031006||Viu +LEXACT_REQ8_t8|5.035004||Viu +LEXACT_REQ8_t8_p8|5.033003||Viu +LEXACT_REQ8_t8_pb|5.033003||Viu +LEXACT_REQ8_tb|5.035004||Viu +LEXACT_REQ8_tb_p8|5.033003||Viu +LEXACT_REQ8_tb_pb|5.033003||Viu +LEXACT_t8|5.035004||Viu +LEXACT_t8_p8|5.033003||Viu +LEXACT_t8_pb|5.033003||Viu +LEXACT_tb|5.035004||Viu +LEXACT_tb_p8|5.033003||Viu +LEXACT_tb_pb|5.033003||Viu +lex_bufutf8|5.011002|5.011002|x +lex_discard_to|5.011002|5.011002|x +LEX_DONT_CLOSE_RSFP|5.015009||Viu +LEX_EVALBYTES|5.015005||Viu +lex_grow_linestr|5.011002|5.011002|x +LEX_IGNORE_UTF8_HINTS|5.015005||Viu +LEX_KEEP_PREVIOUS|5.011002|5.011002| +lex_next_chunk|5.011002|5.011002|x +LEX_NOTPARSING|5.004004||Viu +lex_peek_unichar|5.011002|5.011002|x +lex_read_space|5.011002|5.011002|x +lex_read_to|5.011002|5.011002|x +lex_read_unichar|5.011002|5.011002|x +lex_start|5.013007|5.013007|x +LEX_START_COPIED|5.015005||Viu +LEX_START_FLAGS|5.015005||Viu +LEX_START_SAME_FILTER|5.014000||Viu +lex_stuff_pv|5.013006|5.013006|x +lex_stuff_pvn|5.011002|5.011002|x +lex_stuff_pvs|5.013005|5.013005|x +lex_stuff_sv|5.011002|5.011002|x +LEX_STUFF_UTF8|5.011002|5.011002| +lex_unstuff|5.011002|5.011002|x +LF_NATIVE|5.019004||Viu +LIB_INVARG|5.008001||Viu +LIBM_LIB_VERSION|5.009003|5.009003|Vn +LIKELY|5.009004|5.003007|p +link|5.006000||Viu +LINKLIST|5.013006|5.013006| +list|5.003007||Viu +listen|5.005000||Viu +listkids|5.003007||Viu +LNBREAK|5.009005||Viu +LNBREAK_t8|5.035004||Viu +LNBREAK_t8_p8|5.033003||Viu +LNBREAK_t8_pb|5.033003||Viu +LNBREAK_tb|5.035004||Viu +LNBREAK_tb_p8|5.033003||Viu +LNBREAK_tb_pb|5.033003||Viu +load_charnames|5.031010||cViu +load_module|5.006000|5.003007|pv +load_module_nocontext|5.013006|5.013006|vn +LOCALECONV_LOCK|5.033005||Viu +LOCALECONV_UNLOCK|5.033005||Viu +LOCALE_INIT|5.024000||Viu +LOCALE_INIT_LC_NUMERIC|5.033005||Viu +LOCALE_LOCK|5.024000||Viu +LOCALE_PAT_MOD|5.013006||Viu +LOCALE_PAT_MODS|5.013006||Viu +LOCALE_READ_LOCK|5.033005||Viu +LOCALE_READ_UNLOCK|5.033005||Viu +LOCALE_TERM|5.024000||Viu +LOCALE_TERM_LC_NUMERIC|5.033005||Viu +LOCALE_TERM_POSIX_2008|5.033005||Viu +LOCALE_UNLOCK|5.024000||Viu +localize|5.003007||Viu +LOCAL_PATCH_COUNT|5.003007||Viu +localtime|5.031011||Viu +LOCALTIME_MAX|5.010001|5.010001|Vn +LOCALTIME_MIN|5.010001|5.010001|Vn +LOCALTIME_R_NEEDS_TZSET|5.010000|5.010000|Vn +LOCALTIME_R_PROTO|5.008000|5.008000|Vn +LOCK_DOLLARZERO_MUTEX|5.008001||Viu +lockf|5.006000||Viu +LOCK_LC_NUMERIC_STANDARD|5.021010||poVnu +LOCK_NUMERIC_STANDARD|||piu +LOC_SED|5.003007|5.003007|Vn +LOGICAL|5.005000||Viu +LOGICAL_t8|5.035004||Viu +LOGICAL_t8_p8|5.033003||Viu +LOGICAL_t8_pb|5.033003||Viu +LOGICAL_tb|5.035004||Viu +LOGICAL_tb_p8|5.033003||Viu +LOGICAL_tb_pb|5.033003||Viu +LONGDBLINFBYTES|5.023000|5.023000|Vn +LONGDBLMANTBITS|5.023000|5.023000|Vn +LONGDBLNANBYTES|5.023000|5.023000|Vn +LONGDOUBLE_BIG_ENDIAN|5.021009||Viu +LONGDOUBLE_DOUBLEDOUBLE|5.021009||Viu +LONG_DOUBLE_EQUALS_DOUBLE|5.007001||Viu +LONG_DOUBLE_IS_DOUBLE|5.021003|5.021003|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_BE|5.023006|5.023006|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_LE|5.023006|5.023006|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BIG_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_BE|5.023006|5.023006|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_LE|5.023006|5.023006|Vn +LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LITTLE_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLE_IS_UNKNOWN_FORMAT|5.021003|5.021003|Vn +LONG_DOUBLE_IS_VAX_H_FLOAT|5.025004|5.025004|Vn +LONG_DOUBLE_IS_X86_80_BIT_BIG_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLE_IS_X86_80_BIT_LITTLE_ENDIAN|5.021003|5.021003|Vn +LONG_DOUBLEKIND|5.021003|5.021003|Vn +LONGDOUBLE_LITTLE_ENDIAN|5.021009||Viu +LONGDOUBLE_MIX_ENDIAN|5.023006||Viu +LONG_DOUBLESIZE|5.005000|5.005000|Vn +LONG_DOUBLE_STYLE_IEEE|5.025007|5.025007|Vn +LONG_DOUBLE_STYLE_IEEE_EXTENDED|5.025007|5.025007|Vn +LONGDOUBLE_VAX_ENDIAN|5.025004||Viu +LONGDOUBLE_X86_80_BIT|5.021009||Viu +LONGJMP|5.005000||Viu +longjmp|5.005000||Viu +LONGJMP_t8|5.035004||Viu +LONGJMP_t8_p8|5.033003||Viu +LONGJMP_t8_pb|5.033003||Viu +LONGJMP_tb|5.035004||Viu +LONGJMP_tb_p8|5.033003||Viu +LONGJMP_tb_pb|5.033003||Viu +LONGLONGSIZE|5.005000|5.005000|Vn +LONGSIZE|5.004000|5.003007|oVn +LOOKBEHIND_END_t8_p8|||Viu +LOOKBEHIND_END_t8_pb|||Viu +LOOKBEHIND_END_t8|||Viu +LOOKBEHIND_END_tb_p8|||Viu +LOOKBEHIND_END_tb_pb|||Viu +LOOKBEHIND_END_tb|||Viu +LOOKBEHIND_END|||Viu +looks_like_bool|5.027008||Viu +looks_like_number|5.003007|5.003007| +LOOP_PAT_MODS|5.009005||Viu +lop|5.005000||Viu +lossless_NV_to_IV|5.031001||Vniu +LOWEST_ANYOF_HRx_BYTE|5.031002||Viu +L_R_TZSET|5.009005|5.009005|Vn +lsbit_pos32|5.035003||cVnu +lsbit_pos|5.035004||Viu +lsbit_pos64|5.035003||cVnu +lsbit_pos_uintmax|5.035003||Viu +lseek|5.005000||Viu +LSEEKSIZE|5.006000|5.006000|Vn +lstat|5.005000||Viu +LvFLAGS|5.015006||Viu +LVf_NEG_LEN|5.027001||Viu +LVf_NEG_OFF|5.027001||Viu +LVf_OUT_OF_RANGE|5.027001||Viu +LVRET|5.007001||Vi +LvSTARGOFF|5.019004||Viu +LvTARG|5.003007||Viu +LvTARGLEN|5.003007||Viu +LvTARGOFF|5.003007||Viu +LvTYPE|5.003007||Viu +LZC_TO_MSBIT_POS|5.035003||Viu +magic_clear_all_env|5.004001||Viu +magic_cleararylen_p|5.017002||Viu +magic_clearenv|5.003007||Viu +magic_clearhint|5.009004||Vi +magic_clearhints|5.011000||Vi +magic_clearisa|5.010001||Viu +magic_clearpack|5.003007||Viu +magic_clearsig|5.003007||Viu +magic_copycallchecker|5.017000||Viu +magic_dump|5.006000|5.006000|u +magic_existspack|5.003007||Viu +magic_freearylen_p|5.009003||Viu +magic_freecollxfrm|5.033004||Viu +magic_freemglob|5.033004||Viu +magic_freeovrld|5.007001||Viu +magic_freeutf8|5.033004||Viu +magic_get|5.003007||Viu +magic_getarylen|5.003007||Viu +magic_getdebugvar|5.021005||Viu +magic_getdefelem|5.004000||Viu +magic_getnkeys|5.004005||Viu +magic_getpack|5.003007||Viu +magic_getpos|5.003007||Viu +magic_getsig|5.003007||Viu +magic_getsubstr|5.004005||Viu +magic_gettaint|5.003007||Viu +magic_getuvar|5.003007||Viu +magic_getvec|5.004005||Viu +magic_killbackrefs|5.006000||Viu +magic_methcall1|5.013001||Viu +magic_methcall|||vi +magic_methpack|5.005000||Viu +magic_nextpack|5.003007||Viu +magic_regdata_cnt|5.006000||Viu +magic_regdatum_get|5.006000||Viu +magic_regdatum_set|5.006001||Viu +magic_scalarpack|5.009001||Viu +magic_set|5.003007||Viu +magic_set_all_env|5.004004||Viu +magic_setarylen|5.003007||Viu +magic_setcollxfrm|5.004000||Viu +magic_setdbline|5.003007||Viu +magic_setdebugvar|5.021005||Viu +magic_setdefelem|5.004000||Viu +magic_setenv|5.003007||Viu +magic_sethint|5.009004||Vi +magic_sethint_feature|5.031007||Viu +magic_setisa|5.003007||Viu +magic_setlvref|5.021005||Viu +magic_setmglob|5.003007||Viu +magic_setnkeys|5.003007||Viu +magic_setnonelem|5.027009||Viu +magic_setpack|5.003007||Viu +magic_setpos|5.003007||Viu +magic_setregexp|5.008001||Viu +magic_setsig|5.003007||Viu +magic_setsigall|5.035001||Viu +magic_setsubstr|5.003007||Viu +magic_settaint|5.003007||Viu +magic_setutf8|5.008001||Viu +magic_setuvar|5.003007||Viu +magic_setvec|5.003007||Viu +magic_sizepack|5.005000||Viu +magic_wipepack|5.003007||Viu +make_exactf_invlist|5.031006||Viu +make_matcher|5.027008||Viu +make_trie|5.009002||Viu +malloc|5.003007||Vn +MALLOC_CHECK_TAINT2|5.008001||Viu +MALLOC_CHECK_TAINT|5.008001||Viu +malloced_size|5.005000||Vniu +malloc_good_size|5.010001||Vniu +MALLOC_INIT|5.005000||Viu +MALLOC_OVERHEAD|5.006000||Viu +Malloc_t|5.003007|5.003007|Vn +MALLOC_TERM|5.005000||Viu +MALLOC_TOO_LATE_FOR|5.008001||Viu +MARK|5.003007|5.003007| +MARKPOINT|5.009005||Viu +MARKPOINT_next|5.009005||Viu +MARKPOINT_next_fail|5.009005||Viu +MARKPOINT_next_fail_t8|5.035004||Viu +MARKPOINT_next_fail_t8_p8|5.033003||Viu +MARKPOINT_next_fail_t8_pb|5.033003||Viu +MARKPOINT_next_fail_tb|5.035004||Viu +MARKPOINT_next_fail_tb_p8|5.033003||Viu +MARKPOINT_next_fail_tb_pb|5.033003||Viu +MARKPOINT_next_t8|5.035004||Viu +MARKPOINT_next_t8_p8|5.033003||Viu +MARKPOINT_next_t8_pb|5.033003||Viu +MARKPOINT_next_tb|5.035004||Viu +MARKPOINT_next_tb_p8|5.033003||Viu +MARKPOINT_next_tb_pb|5.033003||Viu +MARKPOINT_t8|5.035004||Viu +MARKPOINT_t8_p8|5.033003||Viu +MARKPOINT_t8_pb|5.033003||Viu +MARKPOINT_tb|5.035004||Viu +MARKPOINT_tb_p8|5.033003||Viu +MARKPOINT_tb_pb|5.033003||Viu +markstack_grow|5.021001|5.021001|u +matcher_matches_sv|5.027008||Viu +MAX|5.025006||Viu +MAX_ANYOF_HRx_BYTE|5.031002||Viu +MAXARG|5.003007||Viu +MAX_CHARSET_NAME_LENGTH|5.013009||Viu +MAX_FEATURE_LEN|5.013010||Viu +MAX_FOLD_FROMS|5.029006||Viu +MAX_LEGAL_CP|5.029002||Viu +MAX_MATCHES|5.033005||Viu +MAXO|5.003007||Viu +MAXPATHLEN|5.006000||Viu +MAX_PORTABLE_UTF8_TWO_BYTE|5.011002||Viu +MAX_PRINT_A|5.033005||Viu +MAX_RECURSE_EVAL_NOCHANGE_DEPTH|5.009005||Viu +MAXSYSFD|5.003007||Viu +MAX_UNICODE_UTF8|5.027006||Viu +MAX_UNI_KEYWORD_INDEX|5.027011||Viu +MAX_UTF8_TWO_BYTE|5.019004||Viu +MAYBE_DEREF_GV|5.015003||Viu +MAYBE_DEREF_GV_flags|5.015003||Viu +MAYBE_DEREF_GV_nomg|5.015003||Viu +maybe_multimagic_gv|5.019004||Viu +mayberelocate|5.015006||Viu +MBLEN_LOCK|5.033005||Viu +MBLEN_UNLOCK|5.033005||Viu +MBOL|5.003007||Viu +MBOL_t8|5.035004||Viu +MBOL_t8_p8|5.033003||Viu +MBOL_t8_pb|5.033003||Viu +MBOL_tb|5.035004||Viu +MBOL_tb_p8|5.033003||Viu +MBOL_tb_pb|5.033003||Viu +MBTOWC_LOCK|5.033005||Viu +MBTOWC_UNLOCK|5.033005||Viu +MDEREF_ACTION_MASK|5.021007||Viu +MDEREF_AV_gvav_aelem|5.021007||Viu +MDEREF_AV_gvsv_vivify_rv2av_aelem|5.021007||Viu +MDEREF_AV_padav_aelem|5.021007||Viu +MDEREF_AV_padsv_vivify_rv2av_aelem|5.021007||Viu +MDEREF_AV_pop_rv2av_aelem|5.021007||Viu +MDEREF_AV_vivify_rv2av_aelem|5.021007||Viu +MDEREF_FLAG_last|5.021007||Viu +MDEREF_HV_gvhv_helem|5.021007||Viu +MDEREF_HV_gvsv_vivify_rv2hv_helem|5.021007||Viu +MDEREF_HV_padhv_helem|5.021007||Viu +MDEREF_HV_padsv_vivify_rv2hv_helem|5.021007||Viu +MDEREF_HV_pop_rv2hv_helem|5.021007||Viu +MDEREF_HV_vivify_rv2hv_helem|5.021007||Viu +MDEREF_INDEX_const|5.021007||Viu +MDEREF_INDEX_gvsv|5.021007||Viu +MDEREF_INDEX_MASK|5.021007||Viu +MDEREF_INDEX_none|5.021007||Viu +MDEREF_INDEX_padsv|5.021007||Viu +MDEREF_MASK|5.021007||Viu +MDEREF_reload|5.021007||Viu +MDEREF_SHIFT|5.021007||Viu +measure_struct|5.007003||Viu +MEM_ALIGNBYTES|5.003007|5.003007|Vn +memBEGINPs|5.027006||Viu +memBEGINs|5.027006||Viu +MEMBER_TO_FPTR|5.006000||Viu +memCHRs|5.031008|5.003007|p +mem_collxfrm|5.003007||dViu +_mem_collxfrm|5.025002||Viu +memENDPs|5.027006||Viu +memENDs|5.027006||Viu +memEQ|5.004000|5.003007|p +memEQs|5.009005|5.003007|p +memGE|5.025005||Viu +memGT|5.025005||Viu +memLE|5.025005||Viu +MEM_LOG_ALLOC|5.009003||Viu +mem_log_alloc|5.024000||Vniu +mem_log_common|5.010001||Vniu +MEM_LOG_DEL_SV|||Viu +MEM_LOG_FREE|5.009003||Viu +mem_log_free|5.024000||Vniu +MEM_LOG_NEW_SV|||Viu +MEM_LOG_REALLOC|5.009003||Viu +mem_log_realloc|5.024000||Vniu +memLT|5.025005||Viu +memNE|5.004000|5.003007|p +memNEs|5.009005|5.003007|p +MEM_SIZE|5.003007||Viu +MEM_SIZE_MAX|5.009005||Viu +MEM_WRAP_CHECK_1|5.009002||Viu +MEM_WRAP_CHECK|5.009002||Viu +MEM_WRAP_CHECK_s|5.027010||Viu +memzero|5.003007|5.003007| +MEOL|5.003007||Viu +MEOL_t8|5.035004||Viu +MEOL_t8_p8|5.033003||Viu +MEOL_t8_pb|5.033003||Viu +MEOL_tb|5.035004||Viu +MEOL_tb_p8|5.033003||Viu +MEOL_tb_pb|5.033003||Viu +mess|5.003007||pvV +mess_alloc|5.005000||Viu +mess_nocontext|5.006000||pvVn +mess_sv|5.013001|5.004000|p +MEXTEND|5.003007||Viu +mfree|||nu +MgBYTEPOS|5.019004||Viu +MgBYTEPOS_set|5.019004||Viu +mg_clear|5.003007|5.003007| +mg_copy|5.003007|5.003007| +mg_dup|5.007003|5.007003|u +MGf_BYTES|5.019004||Viu +MGf_COPY|5.007003||Viu +MGf_DUP|5.007003||Viu +MGf_GSKIP|5.003007||Viu +mg_find|5.003007|5.003007|n +mg_findext|5.013008|5.003007|pn +mg_find_mglob|5.019002||cViu +MGf_LOCAL|5.009003||Viu +MGf_MINMATCH|5.003007||Viu +MGf_PERSIST|5.021005||Viu +mg_free|5.003007|5.003007| +mg_freeext|5.027004|5.027004| +mg_free_type|5.013006|5.013006| +MGf_REFCOUNTED|5.003007||Viu +MGf_REQUIRE_GV|5.021004||Viu +MGf_TAINTEDDIR|5.003007||Viu +mg_get|5.003007|5.003007| +mg_length|5.005000|5.005000|d +mg_localize|5.009003||Vi +mg_magical|5.003007|5.003007|n +MgPV|5.003007||Viu +MgPV_const|5.009003||Viu +MgPV_nolen_const|5.009003||Viu +mg_set|5.003007|5.003007| +mg_size|5.005000|5.005000|u +MgSV|5.033009||Viu +MgTAINTEDDIR|5.003007||Viu +MgTAINTEDDIR_off|5.004000||Viu +MgTAINTEDDIR_on|5.003007||Viu +MICRO_SIGN|5.011002||Viu +MICRO_SIGN_NATIVE|5.017004||Viu +MICRO_SIGN_UTF8|5.033003||Viu +MIN|5.025006||Viu +mini_mktime|5.007002|5.007002|n +MINMOD|5.003007||Viu +MINMOD_t8|5.035004||Viu +MINMOD_t8_p8|5.033003||Viu +MINMOD_t8_pb|5.033003||Viu +MINMOD_tb|5.035004||Viu +MINMOD_tb_p8|5.033003||Viu +MINMOD_tb_pb|5.033003||Viu +minus_v|5.015006||Viu +missingterm|5.005000||Viu +Mkdir|5.004000||Viu +mkdir|5.005000||Viu +mktemp|5.005000||Viu +Mmap_t|5.006000|5.006000|Vn +mode_from_discipline|5.006000||Viu +Mode_t|5.003007|5.003007|Vn +modkids|5.003007||Viu +MON_10|5.027010||Viu +MON_11|5.027010||Viu +MON_12|5.027010||Viu +MON_1|5.027010||Viu +MON_2|5.027010||Viu +MON_3|5.027010||Viu +MON_4|5.027010||Viu +MON_5|5.027010||Viu +MON_6|5.027010||Viu +MON_7|5.027010||Viu +MON_8|5.027010||Viu +MON_9|5.027010||Viu +more_bodies|||cu +more_sv|5.009004||cVu +moreswitches|5.003007||cVu +mortal_getenv|5.031011||cVnu +Move|5.003007|5.003007| +MoveD|5.009002|5.003007|p +move_proto_attr|5.019005||Viu +M_PAT_MODS|5.009005||Viu +MPH_BUCKETS|5.027011||Viu +MPH_RSHIFT|5.027011||Viu +MPH_VALt|5.027011||Viu +mPUSHi|5.009002|5.003007|p +mPUSHn|5.009002|5.003007|p +mPUSHp|5.009002|5.003007|p +mPUSHs|5.010001|5.003007|p +mPUSHu|5.009002|5.003007|p +mro_clean_isarev|5.013007||Viu +mro_gather_and_rename|5.013007||Viu +mro_get_from_name|||u +mro_get_linear_isa|5.009005|5.009005| +mro_get_linear_isa_c3|||i +mro_get_linear_isa_dfs|5.009005||Vi +MRO_GET_PRIVATE_DATA|5.010001|5.010001| +mro_get_private_data|||cu +mro_isa_changed_in|5.009005||Vi +mro_meta_dup|5.009005||Viu +mro_meta_init|||ciu +mro_method_changed_in|5.009005|5.009005| +mro_package_moved|5.013006||Vi +mro_register||| +mro_set_mro|||u +mro_set_private_data||| +msbit_pos32|5.035003||cVnu +msbit_pos|5.035004||Viu +msbit_pos64|5.035003||cVnu +msbit_pos_uintmax|5.035003||Viu +MSPAGAIN|5.003007||Viu +MSVC_DIAG_IGNORE|5.029010||Viu +MSVC_DIAG_IGNORE_DECL|5.029010||Viu +MSVC_DIAG_IGNORE_STMT|5.029010||Viu +MSVC_DIAG_RESTORE|5.029010||Viu +MSVC_DIAG_RESTORE_DECL|5.029010||Viu +MSVC_DIAG_RESTORE_STMT|5.029010||Viu +mul128|5.005000||Viu +MULTICALL|5.009003|5.009003| +multiconcat_stringify|5.027006||cViu +multideref_stringify|5.021009||cViu +MULTILINE_PAT_MOD|5.009005||Viu +MULTIPLICITY|5.006000|5.006000|Vn +MUTABLE_AV|5.010001|5.003007|p +MUTABLE_CV|5.010001|5.003007|p +MUTABLE_GV|5.010001|5.003007|p +MUTABLE_HV|5.010001|5.003007|p +MUTABLE_IO|5.010001|5.003007|p +MUTABLE_PTR|5.010001|5.003007|p +MUTABLE_SV|5.010001|5.003007|p +MUTEX_DESTROY|5.005000||Viu +MUTEX_INIT|5.005000||Viu +MUTEX_INIT_NEEDS_MUTEX_ZEROED|5.005003||Viu +MUTEX_LOCK|5.005000||Viu +MUTEX_UNLOCK|5.005000||Viu +mXPUSHi|5.009002|5.003007|p +mXPUSHn|5.009002|5.003007|p +mXPUSHp|5.009002|5.003007|p +mXPUSHs|5.010001|5.003007|p +mXPUSHu|5.009002|5.003007|p +my|5.011000||Viu +my_atof2|5.029000||cVu +my_atof3|5.029000||cVu +my_atof|5.006000|5.006000| +my_attrs|5.006000||Viu +my_binmode|5.006000||Viu +my_bytes_to_utf8|5.021009||Vniu +my_chsize|5.003007||Vu +my_clearenv|5.009003||Viu +MY_CXT|5.009000|5.009000|p +MY_CXT_CLONE|5.009002|5.009000|p +MY_CXT_INDEX|5.009005||Viu +MY_CXT_INIT|5.009000|5.009000|p +MY_CXT_INIT_ARG|5.013005||Viu +MY_CXT_INIT_INTERP|5.009003||Viu +my_cxt_init|||u +my_dirfd|5.009005|5.009005|nu +my_exit|5.003007|5.003007| +my_exit_jump|5.005000||Viu +my_failure_exit|5.004000|5.004000|u +my_fflush_all|5.006000|5.006000|u +my_fork|5.007003|5.007003|nu +my_kid|5.006000||Viu +my_lstat|5.013003||Viu +my_lstat_flags|5.013003||cViu +my_memrchr|5.027006||Vniu +my_mkostemp_cloexec|||niu +my_mkostemp|||niu +my_mkstemp_cloexec|||niu +my_mkstemp|||niu +my_nl_langinfo|5.027006||Vniu +my_pclose|5.003007|5.003007|u +my_popen|5.003007|5.003007|u +my_popen_list|5.007001|5.007001|u +my_setenv|5.003007|5.003007| +my_snprintf|5.009004||pvVn +my_socketpair|5.007003|5.007003|nu +my_sprintf|5.009003|5.003007|pdn +my_stat|5.013003||Viu +my_stat_flags|5.013003||cViu +my_strerror|5.021001||Viu +my_strftime|5.007002||V +my_strlcat|5.009004|5.003007|pn +my_strlcpy|5.009004|5.003007|pn +my_strnlen|5.027006|5.003007|pn +my_strtod|5.029010|5.029010|n +my_unexec|5.003007||Viu +my_vsnprintf|5.009004|5.009004|n +N0|5.029001||Viu +N10|5.029001||Viu +N11|5.029001||Viu +N1|5.029001||Viu +N2|5.029001||Viu +N3|5.029001||Viu +N4|5.029001||Viu +N5|5.029001||Viu +N6|5.029001||Viu +N7|5.029001||Viu +N8|5.029001||Viu +N9|5.029001||Viu +NAN_COMPARE_BROKEN|5.021005||Viu +NANYOFM|5.029005||Viu +NANYOFM_t8|5.035004||Viu +NANYOFM_t8_p8|5.033003||Viu +NANYOFM_t8_pb|5.033003||Viu +NANYOFM_tb|5.035004||Viu +NANYOFM_tb_p8|5.033003||Viu +NANYOFM_tb_pb|5.033003||Viu +NATIVE8_TO_UNI|5.011000||Viu +NATIVE_BYTE_IS_INVARIANT|5.019004||Viu +NATIVE_SKIP|5.019004||Viu +NATIVE_TO_ASCII|5.007001||Viu +NATIVE_TO_I8|5.015006||Viu +NATIVE_TO_LATIN1|5.019004|5.003007|p +NATIVE_TO_NEED|5.019004||dcVnu +NATIVE_TO_UNI|5.007001|5.003007|p +NATIVE_TO_UTF|5.007001||Viu +NATIVE_UTF8_TO_I8|5.019004||Viu +nBIT_MASK|5.033001||Viu +nBIT_UMAX|5.033001||Viu +NBOUND|5.003007||Viu +NBOUNDA|5.013009||Viu +NBOUNDA_t8|5.035004||Viu +NBOUNDA_t8_p8|5.033003||Viu +NBOUNDA_t8_pb|5.033003||Viu +NBOUNDA_tb|5.035004||Viu +NBOUNDA_tb_p8|5.033003||Viu +NBOUNDA_tb_pb|5.033003||Viu +NBOUNDL|5.004000||Viu +NBOUNDL_t8|5.035004||Viu +NBOUNDL_t8_p8|5.033003||Viu +NBOUNDL_t8_pb|5.033003||Viu +NBOUNDL_tb|5.035004||Viu +NBOUNDL_tb_p8|5.033003||Viu +NBOUNDL_tb_pb|5.033003||Viu +NBOUND_t8|5.035004||Viu +NBOUND_t8_p8|5.033003||Viu +NBOUND_t8_pb|5.033003||Viu +NBOUND_tb|5.035004||Viu +NBOUND_tb_p8|5.033003||Viu +NBOUND_tb_pb|5.033003||Viu +NBOUNDU|5.013009||Viu +NBOUNDU_t8|5.035004||Viu +NBOUNDU_t8_p8|5.033003||Viu +NBOUNDU_t8_pb|5.033003||Viu +NBOUNDU_tb|5.035004||Viu +NBOUNDU_tb_p8|5.033003||Viu +NBOUNDU_tb_pb|5.033003||Viu +NBSP_NATIVE|5.021001||Viu +NBSP_UTF8|5.021001||Viu +NDBM_H_USES_PROTOTYPES|5.032001|5.032001|Vn +NDEBUG|5.021007||Viu +need_utf8|5.009003||Vniu +NEED_VA_COPY|5.007001|5.007001|Vn +NEGATIVE_INDICES_VAR|5.008001||Viu +Netdb_hlen_t|5.005000|5.005000|Vn +Netdb_host_t|5.005000|5.005000|Vn +Netdb_name_t|5.005000|5.005000|Vn +Netdb_net_t|5.005000|5.005000|Vn +NETDB_R_OBSOLETE|5.008000||Viu +New|5.003007||Viu +newANONATTRSUB|5.006000|5.006000|u +newANONHASH|5.003007|5.003007|u +newANONLIST|5.003007|5.003007|u +newANONSUB|5.003007|5.003007|u +newASSIGNOP|5.003007|5.003007| +newATTRSUB|5.006000|5.006000| +newATTRSUB_x|5.019008||cVi +newAV|5.003007|5.003007| +newAV_alloc_x|5.035001|5.035001| +newAV_alloc_xz|5.035001|5.035001| +newAVREF|5.003007|5.003007|u +newBINOP|5.003007|5.003007| +new_body_allocated|||Viu +new_body_from_arena|||Viu +Newc|5.003007||Viu +new_collate|5.006000||Viu +newCONDOP|5.003007|5.003007| +new_constant|||iu +newCONSTSUB|5.004005|5.003007|p +newCONSTSUB_flags|5.015006|5.015006| +new_ctype|5.006000||Viu +newCVREF|5.003007|5.003007|u +newDEFEROP|5.035004|5.035004|x +newDEFSVOP|5.021006|5.021006| +newFORM|5.003007|5.003007|u +newFOROP|5.013007|5.013007| +newGIVENOP|5.009003|5.009003| +newGIVWHENOP|5.027008||Viu +newGP|||xiu +newGVgen|5.003007|5.003007|u +newGVgen_flags|5.015004|5.015004|u +newGVOP|5.003007|5.003007| +newGVREF|5.003007|5.003007|u +new_he|5.005000||Viu +newHV|5.003007|5.003007| +newHVhv|5.005000|5.005000|u +newHVREF|5.003007|5.003007|u +_new_invlist|5.013010||cViu +_new_invlist_C_array|5.015008||cViu +newIO|5.003007|5.003007|u +newLISTOP|5.003007|5.003007| +newLOGOP|5.003007|5.003007| +new_logop|5.005000||Viu +newLOOPEX|5.003007|5.003007| +newLOOPOP|5.003007|5.003007| +newMETHOP|5.021005|5.021005| +newMETHOP_internal|5.021005||Viu +newMETHOP_named|5.021005|5.021005| +new_msg_hv|5.027009||Viu +newMYSUB|5.017004|5.017004|u +new_NOARENA|||Viu +new_NOARENAZ|||Viu +newNULLLIST|5.003007|5.003007| +new_numeric|5.006000||Viu +newOP|5.003007|5.003007| +NewOp|5.008001||Viu +newPADNAMELIST|5.021007|5.021007|xn +newPADNAMEouter|5.021007|5.021007|xn +newPADNAMEpvn|5.021007|5.021007|xn +newPADOP|5.006000||V +newPMOP|5.003007|5.003007| +newPROG|5.003007|5.003007|u +newPVOP|5.003007|5.003007| +newRANGE|5.003007|5.003007| +newRV|5.003007|5.003007| +newRV_inc|5.004000|5.003007|p +newRV_noinc|5.004000|5.003007|p +newSLICEOP|5.003007|5.003007| +new_stackinfo|5.005000|5.005000|u +newSTATEOP|5.003007|5.003007| +newSTUB|5.017001||Viu +newSUB|5.003007|5.003007| +newSV|5.003007|5.003007| +NEWSV|5.003007||Viu +newSVavdefelem|5.019004||Viu +newSVhek|5.009003|5.009003| +newSViv|5.003007|5.003007| +newSVnv|5.006000|5.003007| +newSVOP|5.003007|5.003007| +newSVpadname|5.017004|5.017004|x +newSVpv|5.003007|5.003007| +newSVpvf|5.004000||vV +newSVpvf_nocontext|5.006000||vVn +newSVpvn|5.004005|5.003007|p +newSVpvn_flags|5.010001|5.003007|p +newSVpvn_share|5.007001|5.003007|p +newSVpvn_utf8|5.010001|5.003007|p +newSVpvs|5.009003|5.003007|p +newSVpvs_flags|5.010001|5.003007|p +newSVpv_share|5.013006|5.013006| +newSVpvs_share|5.009003|5.003007|p +newSVREF|5.003007|5.003007|u +newSVrv|5.003007|5.003007| +newSVsv|5.003007|5.003007| +newSVsv_flags|5.029009|5.003007|p +newSVsv_nomg|5.029009|5.003007|p +newSV_type|5.009005|5.003007|p +newSV_type_mortal||| +newSVuv|5.006000|5.003007|p +new_SV|||Viu +newTRYCATCHOP|5.033007|5.033007|x +newUNOP|5.003007|5.003007| +newUNOP_AUX|5.021007|5.021007| +new_version|5.009000|5.009000| +NEW_VERSION|5.019008||Viu +new_warnings_bitfield|||xciu +newWHENOP|5.027008|5.027008| +newWHILEOP|5.013007|5.013007| +Newx|5.009003|5.003007|p +Newxc|5.009003|5.003007|p +new_XNV|||Viu +new_XPVMG|||Viu +new_XPVNV|||Viu +newXS|5.006000|5.006000| +newXS_deffile|5.021006||cViu +newXS_flags|5.009004|5.009004|xu +newXS_len_flags|5.015006||Vi +newXSproto|5.006000|5.006000| +Newxz|5.009003|5.003007|p +Newz|5.003007||Viu +nextargv|5.003007||Viu +nextchar|5.005000||Viu +NEXT_LINE_CHAR|5.007003||Viu +NEXT_OFF|5.005000||Viu +NEXTOPER|5.003007||Viu +next_symbol|5.007003||Viu +ninstr|5.003007|5.003007|n +NL_LANGINFO_LOCK|5.033005||Viu +NL_LANGINFO_UNLOCK|5.033005||Viu +NOARENA|||Viu +no_bareword_allowed|5.005004||Viu +no_bareword_filehandle|5.033006||Viu +NOCAPTURE_PAT_MOD|5.021008||Viu +NOCAPTURE_PAT_MODS|5.021008||Viu +NODE_ALIGN|5.005000||Viu +NODE_ALIGN_FILL|5.005000||Viu +NODE_STEP_REGNODE|5.005000||Viu +NODE_SZ_STR|5.006000||Viu +NO_ENV_ARRAY_IN_MAIN|5.009004||Viu +NOEXPR|5.027010||Viu +NofAMmeth|5.003007||Viu +no_fh_allowed|5.003007||Viu +NOLINE|5.003007||Viu +NO_LOCALE|5.007000||Viu +NONDESTRUCT_PAT_MOD|5.013002||Viu +NONDESTRUCT_PAT_MODS|5.013002||Viu +NON_OTHER_COUNT|5.033005||Viu +NONV|||Viu +no_op|5.003007||Viu +NOOP|5.005000|5.003007|p +noperl_die|5.021006||vVniu +NORETURN_FUNCTION_END|5.009003||Viu +NORMAL|5.003007||Viu +NOSTR|5.027010||Viu +NO_TAINT_SUPPORT|5.017006||Viu +not_a_number|5.005000||Viu +NOTE3|5.027001||Viu +NOTHING|5.003007||Viu +NOTHING_t8|5.035004||Viu +NOTHING_t8_p8|5.033003||Viu +NOTHING_t8_pb|5.033003||Viu +NOTHING_tb|5.035004||Viu +NOTHING_tb_p8|5.033003||Viu +NOTHING_tb_pb|5.033003||Viu +nothreadhook|5.008000|5.008000| +notify_parser_that_changed_to_utf8|5.025010||Viu +not_incrementable|5.021002||Viu +NOT_IN_PAD|5.005000||Viu +NOT_REACHED|5.019006|5.003007|poVnu +NPOSIXA|5.017003||Viu +NPOSIXA_t8|5.035004||Viu +NPOSIXA_t8_p8|5.033003||Viu +NPOSIXA_t8_pb|5.033003||Viu +NPOSIXA_tb|5.035004||Viu +NPOSIXA_tb_p8|5.033003||Viu +NPOSIXA_tb_pb|5.033003||Viu +NPOSIXD|5.017003||Viu +NPOSIXD_t8|5.035004||Viu +NPOSIXD_t8_p8|5.033003||Viu +NPOSIXD_t8_pb|5.033003||Viu +NPOSIXD_tb|5.035004||Viu +NPOSIXD_tb_p8|5.033003||Viu +NPOSIXD_tb_pb|5.033003||Viu +NPOSIXL|5.017003||Viu +NPOSIXL_t8|5.035004||Viu +NPOSIXL_t8_p8|5.033003||Viu +NPOSIXL_t8_pb|5.033003||Viu +NPOSIXL_tb|5.035004||Viu +NPOSIXL_tb_p8|5.033003||Viu +NPOSIXL_tb_pb|5.033003||Viu +NPOSIXU|5.017003||Viu +NPOSIXU_t8|5.035004||Viu +NPOSIXU_t8_p8|5.033003||Viu +NPOSIXU_t8_pb|5.033003||Viu +NPOSIXU_tb|5.035004||Viu +NPOSIXU_tb_p8|5.033003||Viu +NPOSIXU_tb_pb|5.033003||Viu +NSIG|5.009003||Viu +ntohi|5.003007||Viu +ntohl|5.003007||Viu +ntohs|5.003007||Viu +nuke_stacks|5.005000||Viu +Null|5.003007||Viu +Nullav|5.003007|5.003007|d +Nullch|5.003007|5.003007| +Nullcv|5.003007|5.003007|d +Nullfp|5.003007||Viu +Nullgv|5.003007||Viu +Nullhe|5.003007||Viu +Nullhek|5.004000||Viu +Nullhv|5.003007|5.003007|d +Nullop|5.003007||Viu +Nullsv|5.003007|5.003007| +NUM2PTR|5.006000||pVu +NUM_ANYOF_CODE_POINTS|5.021004||Viu +NUM_CLASSES|5.029001||Viu +num_overflow|5.009001||Vniu +NV_BIG_ENDIAN|5.021009||Viu +NV_DIG|5.006000||Viu +NVef|5.006001|5.003007|poVn +NV_EPSILON|5.007003||Viu +NVff|5.006001|5.003007|poVn +NVgf|5.006001|5.003007|poVn +NV_IMPLICIT_BIT|5.021009||Viu +NV_INF|5.007003||Viu +NV_LITTLE_ENDIAN|5.021009||Viu +NVMANTBITS|5.023000|5.023000|Vn +NV_MANT_DIG|5.006001||Viu +NV_MAX_10_EXP|5.007003||Viu +NV_MAX|5.006001||Viu +NV_MAX_EXP|5.021003||Viu +NV_MIN_10_EXP|5.007003||Viu +NV_MIN|5.006001||Viu +NV_MIN_EXP|5.021003||Viu +NV_MIX_ENDIAN|5.021009||Viu +NV_NAN|5.007003||Viu +NV_NAN_BITS|5.023000||Viu +NV_NAN_IS_QUIET|5.023000||Viu +NV_NAN_IS_SIGNALING|5.023000||Viu +NV_NAN_PAYLOAD_MASK|5.023000||Viu +NV_NAN_PAYLOAD_MASK_IEEE_754_128_BE|5.023000||Viu +NV_NAN_PAYLOAD_MASK_IEEE_754_128_LE|5.023000||Viu +NV_NAN_PAYLOAD_MASK_IEEE_754_64_BE|5.023000||Viu +NV_NAN_PAYLOAD_MASK_IEEE_754_64_LE|5.023000||Viu +NV_NAN_PAYLOAD_MASK_SKIP_EIGHT|5.023006||Viu +NV_NAN_PAYLOAD_PERM_0_TO_7|5.023000||Viu +NV_NAN_PAYLOAD_PERM|5.023000||Viu +NV_NAN_PAYLOAD_PERM_7_TO_0|5.023000||Viu +NV_NAN_PAYLOAD_PERM_IEEE_754_128_BE|5.023000||Viu +NV_NAN_PAYLOAD_PERM_IEEE_754_128_LE|5.023000||Viu +NV_NAN_PAYLOAD_PERM_IEEE_754_64_BE|5.023000||Viu +NV_NAN_PAYLOAD_PERM_IEEE_754_64_LE|5.023000||Viu +NV_NAN_PAYLOAD_PERM_SKIP_EIGHT|5.023006||Viu +NV_NAN_QS_BIT|5.023000||Viu +NV_NAN_QS_BIT_OFFSET|5.023000||Viu +NV_NAN_QS_BIT_SHIFT|5.023000||Viu +NV_NAN_QS_BYTE|5.023000||Viu +NV_NAN_QS_BYTE_OFFSET|5.023000||Viu +NV_NAN_QS_QUIET|5.023000||Viu +NV_NAN_QS_SIGNALING|5.023000||Viu +NV_NAN_QS_TEST|5.023000||Viu +NV_NAN_QS_XOR|5.023000||Viu +NV_NAN_SET_QUIET|5.023000||Viu +NV_NAN_SET_SIGNALING|5.023000||Viu +NV_OVERFLOWS_INTEGERS_AT|5.010001|5.010001|Vn +NV_PRESERVES_UV_BITS|5.006001|5.006001|Vn +NVSIZE|5.006001|5.006001|Vn +NVTYPE|5.006000|5.003007|poVn +NV_VAX_ENDIAN|5.025003||Viu +NV_WITHIN_IV|5.006000||Viu +NV_WITHIN_UV|5.006000||Viu +NV_X86_80_BIT|5.025004||Viu +NV_ZERO_IS_ALLBITS_ZERO|5.035009|5.035009|Vn +OA_AVREF|5.003007||Viu +OA_BASEOP|5.005000||Viu +OA_BASEOP_OR_UNOP|5.005000||Viu +OA_BINOP|5.005000||Viu +OA_CLASS_MASK|5.005000||Viu +OA_COP|5.005000||Viu +OA_CVREF|5.003007||Viu +OA_DANGEROUS|5.003007||Viu +OA_DEFGV|5.003007||Viu +OA_FILEREF|5.003007||Viu +OA_FILESTATOP|5.005000||Viu +OA_FOLDCONST|5.003007||Viu +OA_HVREF|5.003007||Viu +OA_LIST|5.003007||Viu +OA_LISTOP|5.005000||Viu +OA_LOGOP|5.005000||Viu +OA_LOOP|5.005000||Viu +OA_LOOPEXOP|5.005000||Viu +OA_MARK|5.003007||Viu +OA_METHOP|5.021005||Viu +OA_OPTIONAL|5.003007||Viu +OA_OTHERINT|5.003007||Viu +OA_PADOP|5.006000||Viu +OA_PMOP|5.005000||Viu +OA_PVOP_OR_SVOP|5.006000||Viu +OA_RETSCALAR|5.003007||Viu +OA_SCALAR|5.003007||Viu +OA_SCALARREF|5.003007||Viu +OASHIFT|5.003007||Viu +OA_SVOP|5.005000||Viu +OA_TARGET|5.003007||Viu +OA_TARGLEX|5.006000||Viu +OA_UNOP|5.005000||Viu +OA_UNOP_AUX|5.021007||Viu +O_BINARY|5.006000||Viu +O_CREAT|5.006000||Viu +OCSHIFT|5.006000||Viu +OCTAL_VALUE|5.019008||Viu +Off_t|5.003007|5.003007|Vn +Off_t_size|5.006000|5.006000|Vn +OFFUNI_IS_INVARIANT|5.023003||Viu +OFFUNISKIP|5.019004||Viu +OFFUNISKIP_helper|5.035004||Viu +ONCE_PAT_MOD|5.009005||Viu +ONCE_PAT_MODS|5.009005||Viu +ONE_IF_EBCDIC_ZERO_IF_NOT|5.035004||Viu +oopsAV|5.003007||Viu +oopsHV|5.003007||Viu +OP|5.003007||Viu +op_append_elem|5.013006|5.013006| +op_append_list|5.013006|5.013006| +opASSIGN|5.003007||Viu +OP_CHECK_MUTEX_INIT|5.015008||Viu +OP_CHECK_MUTEX_LOCK|5.015008||Viu +OP_CHECK_MUTEX_TERM|5.015008||Viu +OP_CHECK_MUTEX_UNLOCK|5.015008||Viu +OP_CLASS|5.013007|5.013007| +op_class|5.025010|5.025010| +op_clear|5.006000||cViu +OPCODE|5.003007||Viu +op_contextualize|5.013006|5.013006| +op_convert_list|5.021006|5.021006| +OP_DESC|5.007003|5.007003| +op_dump|5.006000|5.006000| +OPEN|5.003007||Viu +open|5.005000||Viu +opendir|5.005000||Viu +openn_cleanup|5.019010||Viu +openn_setup|5.019010||Viu +open_script|5.005000||Viu +OPEN_t8|5.035004||Viu +OPEN_t8_p8|5.033003||Viu +OPEN_t8_pb|5.033003||Viu +OPEN_tb|5.035004||Viu +OPEN_tb_p8|5.033003||Viu +OPEN_tb_pb|5.033003||Viu +OPERAND|5.003007||Viu +OPERANDl|5.031005||Viu +OPERANDs|5.031005||Viu +OPFAIL|5.009005||Viu +OPFAIL_t8|5.035004||Viu +OPFAIL_t8_p8|5.033003||Viu +OPFAIL_t8_pb|5.033003||Viu +OPFAIL_tb|5.035004||Viu +OPFAIL_tb_p8|5.033003||Viu +OPFAIL_tb_pb|5.033003||Viu +OPf_FOLDED|5.021007||Viu +OPf_KIDS|5.003007|5.003007| +OPf_KNOW|5.003007||Viu +OPf_LIST|5.003007||Viu +OPf_MOD|5.003007||Viu +OPf_PARENS|5.003007||Viu +op_free|5.003007|5.003007| +OP_FREED|5.017002||Viu +OPf_REF|5.003007||Viu +OPf_SPECIAL|5.003007||Viu +OPf_STACKED|5.003007||Viu +OPf_WANT|5.004000||Viu +OPf_WANT_LIST|5.004000||Viu +OPf_WANT_SCALAR|5.004000||Viu +OPf_WANT_VOID|5.004000||Viu +OP_GIMME|5.004000||Viu +OP_GIMME_REVERSE|5.010001||Viu +OpHAS_SIBLING|5.021007|5.003007|p +op_integerize|5.015003||Viu +OP_IS_DIRHOP|5.015003||Viu +OP_IS_FILETEST|5.006001||Viu +OP_IS_FILETEST_ACCESS|5.008001||Viu +OP_IS_INFIX_BIT|5.021009||Viu +OP_IS_NUMCOMPARE|5.015003||Viu +OP_IS_SOCKET|5.006001||Viu +OP_IS_STAT|5.031001||Viu +OpLASTSIB_set|5.021011|5.003007|p +op_linklist|5.013006|5.013006| +op_lvalue|5.013007|5.013007|x +op_lvalue_flags|||ciu +OP_LVALUE_NO_CROAK|5.015001||Viu +OpMAYBESIB_set|5.021011|5.003007|p +opmethod_stash|5.021007||Viu +OpMORESIB_set|5.021011|5.003007|p +OP_NAME|5.007003|5.007003| +op_null|5.007002|5.007002| +OPpALLOW_FAKE|5.015006||Viu +op_parent|5.025001|5.025001|n +OPpARG1_MASK|5.021004||Viu +OPpARG2_MASK|5.021004||Viu +OPpARG3_MASK|5.021004||Viu +OPpARG4_MASK|5.021004||Viu +OPpARGELEM_AV|5.025004||Viu +OPpARGELEM_HV|5.025004||Viu +OPpARGELEM_MASK|5.025004||Viu +OPpARGELEM_SV|5.025004||Viu +OPpASSIGN_BACKWARDS|5.003007||Viu +OPpASSIGN_COMMON_AGG|5.023002||Viu +OPpASSIGN_COMMON_RC1|5.023002||Viu +OPpASSIGN_COMMON_SCALAR|5.023002||Viu +OPpASSIGN_CV_TO_GV|5.009003||Viu +OPpASSIGN_TRUEBOOL|5.027003||Viu +OPpAVHVSWITCH_MASK|5.025006||Viu +OPpCONCAT_NESTED|5.027007||Viu +OPpCONST_BARE|5.003007||Viu +OPpCONST_ENTERED|5.003007||Viu +OPpCONST_NOVER|5.009003||Viu +OPpCONST_SHORTCIRCUIT|5.009001||Viu +OPpCONST_STRICT|5.005004||Viu +OPpCOREARGS_DEREF1|5.015003||Viu +OPpCOREARGS_DEREF2|5.015003||Viu +OPpCOREARGS_PUSHMARK|5.015003||Viu +OPpCOREARGS_SCALARMOD|5.015003||Viu +OPpDEFER_FINALLY|5.035008||Viu +OPpDEREF|5.004000||Viu +OPpDEREF_AV|5.003007||Viu +OPpDEREF_HV|5.003007||Viu +OPpDEREF_SV|5.004000||Viu +OPpDONT_INIT_GV|5.009003||Viu +OPpEARLY_CV|5.006000|5.006000| +OPpENTERSUB_AMPER|5.003007|5.003007| +OPpENTERSUB_DB|5.003007||Viu +OPpENTERSUB_HASTARG|5.006000||Viu +OPpENTERSUB_INARGS|5.006000||Viu +OPpENTERSUB_LVAL_MASK|5.015001||Viu +OPpENTERSUB_NOPAREN|5.005004||Viu +OPpEVAL_BYTES|5.015005||Viu +OPpEVAL_COPHH|5.015005||Viu +OPpEVAL_HAS_HH|5.009003||Viu +OPpEVAL_RE_REPARSING|5.017011||Viu +OPpEVAL_UNICODE|5.015005||Viu +OPpEXISTS_SUB|5.006000||Viu +OPpFLIP_LINENUM|5.003007||Viu +OPpFT_ACCESS|5.008001||Viu +OPpFT_AFTER_t|5.015008||Viu +OPpFT_STACKED|5.009001||Viu +OPpFT_STACKING|5.015001||Viu +OPpHINT_STRICT_REFS|5.021004||Viu +OPpHUSH_VMSISH|5.007003||Viu +OPpINDEX_BOOLNEG|5.027003||Viu +OPpITER_DEF|5.027008||Viu +OPpITER_REVERSED|5.009002||Viu +OPpKVSLICE|5.027001||Viu +OPpLIST_GUESSED|5.003007||Viu +OPpLVAL_DEFER|5.004000||Viu +OPpLVAL_INTRO|5.003007||Viu +OPpLVALUE|5.019006||Viu +OPpLVREF_AV|5.021005||Viu +OPpLVREF_CV|5.021005||Viu +OPpLVREF_ELEM|5.021005||Viu +OPpLVREF_HV|5.021005||Viu +OPpLVREF_ITER|5.021005||Viu +OPpLVREF_SV|5.021005||Viu +OPpLVREF_TYPE|5.021005||Viu +OPpMAYBE_LVSUB|5.007001||Viu +OPpMAYBE_TRUEBOOL|5.017004||Viu +OPpMAY_RETURN_CONSTANT|5.009003||Viu +OPpMULTICONCAT_APPEND|5.027006||Viu +OPpMULTICONCAT_FAKE|5.027006||Viu +OPpMULTICONCAT_STRINGIFY|5.027006||Viu +OPpMULTIDEREF_DELETE|5.021007||Viu +OPpMULTIDEREF_EXISTS|5.021007||Viu +OPpOFFBYONE|5.015002||Viu +OPpOPEN_IN_CRLF|5.006000||Viu +OPpOPEN_IN_RAW|5.006000||Viu +OPpOPEN_OUT_CRLF|5.006000||Viu +OPpOPEN_OUT_RAW|5.006000||Viu +OPpOUR_INTRO|5.006000||Viu +OPpPADHV_ISKEYS|5.027003||Viu +OPpPADRANGE_COUNTMASK|5.017006||Viu +OPpPADRANGE_COUNTSHIFT|5.017006||Viu +OPpPAD_STATE|5.009004||Viu +OPpPV_IS_UTF8|5.016000||Viu +OPpREFCOUNTED|5.006000||Viu +OPpREPEAT_DOLIST|5.003007||Viu +op_prepend_elem|5.013006|5.013006| +OPpREVERSE_INPLACE|5.011002||Viu +OPpRV2HV_ISKEYS|5.027003||Viu +OPpSLICE|5.004000||Viu +OPpSLICEWARNING|5.019004||Viu +OPpSORT_DESCEND|5.009002||Viu +OPpSORT_INPLACE|5.009001||Viu +OPpSORT_INTEGER|5.006000||Viu +OPpSORT_NUMERIC|5.006000||Viu +OPpSORT_REVERSE|5.006000||Viu +OPpSPLIT_ASSIGN|5.025006||Viu +OPpSPLIT_IMPLIM|5.019002||Viu +OPpSPLIT_LEX|5.025006||Viu +OPpSUBSTR_REPL_FIRST|5.015006||Viu +OPpTARGET_MY|5.006000||Viu +OPpTRANS_ALL|5.009001||Viu +OPpTRANS_CAN_FORCE_UTF8|5.031006||Viu +OPpTRANS_COMPLEMENT|5.003007||Viu +OPpTRANS_DELETE|5.003007||Viu +OPpTRANS_FROM_UTF|5.006000||Viu +OPpTRANS_GROWS|5.006000||Viu +OPpTRANS_IDENTICAL|5.006000||Viu +OPpTRANS_SQUASH|5.003007||Viu +OPpTRANS_TO_UTF|5.006000||Viu +OPpTRANS_USE_SVOP|5.031006||Viu +OPpTRUEBOOL|5.017004||Viu +OPpUSEINT|5.035005||Viu +OpREFCNT_dec|5.006000||Viu +op_refcnt_dec|||xiu +OpREFCNT_inc|5.006000||Viu +op_refcnt_inc|||xiu +OP_REFCNT_INIT|5.006000||Viu +OP_REFCNT_LOCK|5.006000||Viu +op_refcnt_lock|5.009002|5.009002|u +OpREFCNT_set|5.006000||Viu +OP_REFCNT_TERM|5.006000||Viu +OP_REFCNT_UNLOCK|5.006000||Viu +op_refcnt_unlock|5.009002|5.009002|u +op_relocate_sv|5.021005||Viu +op_scope|5.013007|5.013007|x +OP_SIBLING|5.021002||Viu +OpSIBLING|5.021007|5.003007|p +op_sibling_splice|5.021002|5.021002|n +OpSLAB|5.017002||Viu +opslab_force_free|5.017002||Viu +opslab_free|5.017002||Viu +opslab_free_nopad|5.017002||Viu +OpslabREFCNT_dec|5.017002||Viu +OpslabREFCNT_dec_padok|5.017002||Viu +OpSLOT|5.017002||Viu +OPSLOT_HEADER|5.017002||Viu +OpSLOToff|5.033001||Viu +op_std_init|5.015003||Viu +OPTIMIZED|5.005000||Viu +OPTIMIZED_t8|5.035004||Viu +OPTIMIZED_t8_p8|5.033003||Viu +OPTIMIZED_t8_pb|5.033003||Viu +OPTIMIZED_tb|5.035004||Viu +OPTIMIZED_tb_p8|5.033003||Viu +OPTIMIZED_tb_pb|5.033003||Viu +optimize_op|5.027006||Viu +optimize_optree|5.027006||Vi +optimize_regclass|5.035001||Viu +OP_TYPE_IS|5.019007|5.019007| +OP_TYPE_IS_NN|5.019010||Viu +OP_TYPE_ISNT|5.019010||Viu +OP_TYPE_ISNT_AND_WASNT|5.019010||Viu +OP_TYPE_ISNT_AND_WASNT_NN|5.019010||Viu +OP_TYPE_ISNT_NN|5.019010||Viu +OP_TYPE_IS_OR_WAS|5.019010|5.019010| +OP_TYPE_IS_OR_WAS_NN|5.019010||Viu +op_unscope|5.017003||xViu +op_wrap_finally|5.035008|5.035008|x +O_RDONLY|5.006000||Viu +O_RDWR|5.006000||Viu +ORIGMARK|5.003007|5.003007| +OSNAME|5.003007|5.003007|Vn +OSVERS|5.007002|5.007002|Vn +O_TEXT|5.006000||Viu +OutCopFILE|5.007003||Viu +output_non_portable|5.031008||Viu +output_posix_warnings|5.029005||Viu +O_VMS_DELETEONCLOSE|5.031002||Viu +O_WRONLY|5.006000||Viu +package|5.003007||Viu +package_version|5.011001||Viu +pack_cat|5.033002|5.033002|d +packlist|5.008001|5.008001| +pack_rec|5.008001||Viu +packWARN2|5.007003|5.003007|p +packWARN3|5.007003|5.003007|p +packWARN4|5.007003|5.003007|p +packWARN|5.007003|5.003007|p +pad_add_anon|5.015001|5.015001| +pad_add_name_pv|5.015001|5.015001| +pad_add_name_pvn|5.015001|5.015001| +pad_add_name_pvs|5.015001|5.015001| +pad_add_name_sv|5.015001|5.015001| +padadd_NO_DUP_CHECK|5.011002||Viu +padadd_OUR|5.011002||Viu +padadd_STALEOK|5.017003||Viu +padadd_STATE|5.011002||Viu +pad_add_weakref|5.021007||Viu +pad_alloc|5.015001|5.015001|x +pad_alloc_name|5.015001||Vi +PadARRAY|5.017004|5.017004|x +PAD_BASE_SV|5.008001||Vi +pad_block_start|5.008001||Vi +pad_check_dup|5.008001||Vi +PAD_CLONE_VARS|5.008001||Vi +PAD_COMPNAME|5.017004||Viu +PAD_COMPNAME_FLAGS|5.008001||Vi +PAD_COMPNAME_FLAGS_isOUR|5.009004||Viu +PAD_COMPNAME_GEN|5.008001||Vi +PAD_COMPNAME_GEN_set|5.009003||Vi +PAD_COMPNAME_OURSTASH|5.008001||Vi +PAD_COMPNAME_PV|5.008001||Vi +PAD_COMPNAME_SV|5.009005||Viu +PAD_COMPNAME_TYPE|5.008001||Vi +pad_compname_type|5.033005|5.033005|d +PAD_FAKELEX_ANON|5.009005||Viu +PAD_FAKELEX_MULTI|5.009005||Viu +pad_findlex|5.005000||Vi +pad_findmy_pv|5.015001|5.015001| +pad_findmy_pvn|5.015001|5.015001| +pad_findmy_pvs|5.015001|5.015001| +pad_findmy_sv|5.015001|5.015001| +pad_fixup_inner_anons|5.008001||Vi +pad_free|5.003007||Vi +pad_leavemy|5.003007||Vi +PadlistARRAY|5.017004|5.017004|x +padlist_dup|5.013002||Vi +PadlistMAX|5.017004|5.017004|x +PadlistNAMES|5.017004|5.017004|x +PadlistNAMESARRAY|5.017004|5.017004|x +PadlistNAMESMAX|5.017004|5.017004|x +PadlistREFCNT|5.017004|5.017004|x +padlist_store|5.017004||Viu +PadMAX|5.017004|5.017004|x +padname_dup|5.021007||Vi +PadnameFLAGS|5.021007||Viu +padname_free|||ciu +PADNAME_FROM_PV|5.021007||Viu +PadnameIN_SCOPE|5.031004||Vniu +PadnameIsOUR|5.017004||Vi +PadnameIsSTATE|5.017004||Vi +PadnameIsSTATE_on|5.021007||Viu +PadnameLEN|5.017004|5.017004|x +PadnamelistARRAY|5.017004|5.017004|x +padnamelist_dup|5.021007||Vi +padnamelist_fetch|5.021007|5.021007|xn +padnamelist_free|||ciu +PadnamelistMAX|5.017004|5.017004|x +PadnamelistMAXNAMED|5.019003||Viu +PadnamelistREFCNT|5.021007|5.021007|x +PadnamelistREFCNT_dec|5.021007|5.021007|x +padnamelist_store|5.021007|5.021007|x +PadnameLVALUE|5.021006||Viu +PadnameLVALUE_on|5.021006||Viu +PadnameOURSTASH|5.017004||Vi +PadnameOURSTASH_set|5.021007||Viu +PadnameOUTER|5.017004||Vi +PadnamePROTOCV|5.021007||Viu +PadnamePV|5.017004|5.017004|x +PadnameREFCNT|5.021007|5.021007|x +PadnameREFCNT_dec|5.021007|5.021007|x +PadnameSV|5.017004|5.017004|x +PADNAMEt_LVALUE|5.021007||Viu +PADNAMEt_OUR|5.021007||Viu +PADNAMEt_OUTER|5.021007|5.021007| +PADNAMEt_STATE|5.021007||Viu +PADNAMEt_TYPED|5.021007||Viu +PadnameTYPE|5.017004||Vi +PadnameTYPE_set|5.021007||Viu +PadnameUTF8|5.017004|5.017004|x +pad_new|5.015001|5.015001| +padnew_CLONE|5.008001||Viu +padnew_SAVE|5.008001||Viu +padnew_SAVESUB|5.008001||Viu +pad_peg|5.009004||Viu +pad_push|5.008001||cVi +pad_reset|5.003007||Vi +PAD_RESTORE_LOCAL|5.008001||Vi +PAD_SAVE_LOCAL|5.008001||Vi +PAD_SAVE_SETNULLPAD|5.008001||Vi +PAD_SET_CUR|5.008001||Vi +PAD_SET_CUR_NOSAVE|5.008002||Vi +pad_setsv|5.008001||cV +PAD_SETSV|5.008001||Vi +pad_sv|5.003007||cV +PAD_SV|5.003007||Vi +PAD_SVl|5.008001||Vi +pad_swipe|5.003007||Vi +pad_tidy|5.015001|5.015001|x +panic_write2|5.008001||Viu +PARENT_FAKELEX_FLAGS|5.009005||Viu +PARENT_PAD_INDEX|5.009005||Viu +parse_arithexpr|5.013008|5.013008|x +parse_barestmt|5.013007|5.013007|x +parse_block|5.013007|5.013007|x +parse_body|5.006000||Viu +parse_fullexpr|5.013008|5.013008|x +parse_fullstmt|5.013005|5.013005|x +parse_gv_stash_name|5.019004||Viu +parse_ident|5.017010||Viu +parse_label|5.013007|5.013007|x +parse_listexpr|5.013008|5.013008|x +parse_lparen_question_flags|5.017009||Viu +PARSE_OPTIONAL|5.013007|5.013007| +parser_dup|5.009000|5.009000|u +parser_free|5.009005||Viu +parser_free_nexttoke_ops|5.017006||Viu +parse_stmtseq|5.013006|5.013006|x +parse_subsignature|5.031003|5.031003|x +parse_termexpr|5.013008|5.013008|x +parse_unicode_opts|5.008001||Viu +parse_uniprop_string|5.027011||Viu +PATCHLEVEL|5.003007||Viu +path_is_searchable|5.019001||Vniu +Pause|5.003007||Viu +pause|5.005000||Viu +pclose|5.003007||Viu +peep|5.003007||Viu +pending_ident|5.017004||Viu +PERL_ABS|5.008001|5.003007|p +Perl_acos|5.021004|5.021004|n +perl_alloc|5.003007|5.003007|n +PERL_ALLOC_CHECK|5.006000||Viu +perl_alloc_using|5.006000||Vnu +PERL_ANY_COW|5.017007||Viu +PERL_API_REVISION|5.006000||Viu +PERL_API_SUBVERSION|5.006000||Viu +PERL_API_VERSION|5.006000||Viu +PERL_API_VERSION_STRING|5.013004||Viu +PERL_ARENA_ROOTS_SIZE|5.009004||Viu +PERL_ARENA_SIZE|5.009003||Viu +PERL_ARGS_ASSERT_CROAK_XS_USAGE|||ponu +Perl_asin|5.021004|5.021004|n +Perl_assert|5.011000||Viu +perl_assert_ptr|5.027004||Viu +PERL_ASYNC_CHECK|5.006000|5.006000| +Perl_atan2|5.006000|5.006000|n +Perl_atan|5.021004|5.021004|n +Perl_atof2|5.006001||Viu +Perl_atof|5.006000||Viu +PERL_BCDVERSION||5.003007|onu +PERL_BISON_VERSION|5.023008||Viu +PERL_BITFIELD16|5.010001||Viu +PERL_BITFIELD32|5.010001||Viu +PERL_BITFIELD8|5.010001||Viu +PERL_CALLCONV|5.005002||Viu +PERL_CALLCONV_NO_RET|5.017002||Viu +Perl_ceil|5.009001|5.009001|n +PERL_CKDEF|5.006000||Viu +perl_clone|5.006000||Vn +perl_clone_using|5.006000||Vnu +PERL_CLZ_32|5.035003||Viu +PERL_CLZ_64|5.035003||Viu +perl_construct|5.003007|5.003007|n +PERL_COP_SEQMAX|5.013010||Viu +PERL_COPY_ON_WRITE|5.023001||Viu +Perl_cos|5.006000|5.006000|n +Perl_cosh|5.021004|5.021004|n +PERL_COUNT_MULTIPLIER|5.027007||Viu +PERL_CTZ_32|5.035003||Viu +PERL_CTZ_64|5.035003||Viu +Perl_custom_op_xop|5.019006||V +PERLDB_ALL|5.004002||Viu +PERLDBf_GOTO|5.004005||Viu +PERLDBf_INTER|5.004002||Viu +PERLDBf_LINE|5.004002||Viu +PERLDBf_NAMEANON|5.006000||Viu +PERLDBf_NAMEEVAL|5.006000||Viu +PERLDBf_NONAME|5.004005||Viu +PERLDBf_NOOPT|5.004002||Viu +PERLDBf_SAVESRC|5.010001||Viu +PERLDBf_SAVESRC_INVALID|5.010001||Viu +PERLDBf_SAVESRC_NOSUBS|5.010001||Viu +PERLDBf_SINGLE|5.004002||Viu +PERLDBf_SUB|5.004002||Viu +PERLDBf_SUBLINE|5.004002||Viu +PERLDB_GOTO|5.004005||Viu +PERLDB_INTER|5.004002||Viu +PERLDB_LINE|5.004002||Viu +PERLDB_LINE_OR_SAVESRC|5.023002||Viu +PERLDB_NAMEANON|5.006000||Viu +PERLDB_NAMEEVAL|5.006000||Viu +PERLDB_NOOPT|5.004002||Viu +PERLDB_SAVESRC|5.010001||Viu +PERLDB_SAVESRC_INVALID|5.010001||Viu +PERLDB_SAVESRC_NOSUBS|5.010001||Viu +PERLDB_SINGLE|5.004002||Viu +PERLDB_SUB|5.004002||Viu +PERLDB_SUBLINE|5.004002||Viu +PERLDB_SUB_NN|5.004005||Viu +PERL_DEB2|5.021007||Viu +PERL_DEB|5.008001||Viu +PERL_deBruijnMagic32|5.035003||Viu +PERL_deBruijnMagic64|5.035003||Viu +PERL_deBruijnShift32|5.035003||Viu +PERL_deBruijnShift64|5.035003||Viu +PERL_DEBUG|5.008001||Viu +Perl_debug_log|5.003007||Viu +PERL_DEBUG_PAD|5.007003||Viu +PERL_DEBUG_PAD_ZERO|5.007003||Viu +PERL_DECIMAL_VERSION|5.019008||Viu +PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION|5.009003||Viu +perl_destruct|5.007003|5.007003|n +PerlDir_chdir|5.005000||Viu +PerlDir_close|5.005000||Viu +PerlDir_mapA|5.006000||Viu +PerlDir_mapW|5.006000||Viu +PerlDir_mkdir|5.005000||Viu +PerlDir_open|5.005000||Viu +PerlDir_read|5.005000||Viu +PerlDir_rewind|5.005000||Viu +PerlDir_rmdir|5.005000||Viu +PerlDir_seek|5.005000||Viu +PerlDir_tell|5.005000||Viu +PERL_DONT_CREATE_GVSV|5.009003||Viu +Perl_drand48|5.019004||Viu +Perl_drand48_init|5.019004||Viu +PERL_DRAND48_QUAD|5.019004||Viu +PERL_DTRACE_PROBE_ENTRY|5.023009||Viu +PERL_DTRACE_PROBE_FILE_LOADED|5.023009||Viu +PERL_DTRACE_PROBE_FILE_LOADING|5.023009||Viu +PERL_DTRACE_PROBE_OP|5.023009||Viu +PERL_DTRACE_PROBE_PHASE|5.023009||Viu +PERL_DTRACE_PROBE_RETURN|5.023009||Viu +PERL_EBCDIC_TABLES_H|5.027001||Viu +PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS|5.009004||Viu +PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION|5.009004||Viu +PERL_ENABLE_POSITIVE_ASSERTION_STUDY|5.009005||Viu +PERL_ENABLE_TRIE_OPTIMISATION|5.009004||Viu +PerlEnv_clearenv|5.006000||Viu +PerlEnv_ENVgetenv|5.006000||Viu +PerlEnv_ENVgetenv_len|5.006000||Viu +PerlEnv_free_childdir|5.006000||Viu +PerlEnv_free_childenv|5.006000||Viu +PerlEnv_get_childdir|5.006000||Viu +PerlEnv_get_childenv|5.006000||Viu +PerlEnv_get_child_IO|5.006000||Viu +PerlEnv_getenv|5.005000||Viu +PerlEnv_getenv_len|5.006000||Viu +PerlEnv_lib_path|5.005000||Viu +PerlEnv_os_id|5.006000||Viu +PerlEnv_putenv|5.005000||Viu +PerlEnv_sitelib_path|5.005000||Viu +PerlEnv_uname|5.005004||Viu +PerlEnv_vendorlib_path|5.006000||Viu +Perl_error_log|5.006000||Viu +Perl_eval_pv||5.003007|onu +Perl_eval_sv||5.003007|onu +PERL_EXIT_ABORT|5.019003|5.019003| +PERL_EXIT_DESTRUCT_END|5.007003|5.007003| +PERL_EXIT_EXPECTED|5.006000|5.006000| +PERL_EXIT_WARN|5.019003|5.019003| +Perl_exp|5.006000|5.006000|n +Perl_fabs|5.035005||Viu +PERL_FEATURE_H|5.029006||Viu +PERL_FILE_IS_ABSOLUTE|5.006000||Viu +PERL_FILTER_EXISTS|5.009005||Viu +Perl_floor|5.006000|5.006000|n +PERL_FLUSHALL_FOR_CHILD|5.006000||Viu +Perl_fmod|5.006000|5.006000|n +Perl_fp_class|5.007003||Viu +Perl_fp_class_denorm|5.007003||Viu +Perl_fp_class_inf|5.007003||Viu +Perl_fp_class_nan|5.007003||Viu +Perl_fp_class_ndenorm|5.007003||Viu +Perl_fp_class_ninf|5.007003||Viu +Perl_fp_class_nnorm|5.007003||Viu +Perl_fp_class_norm|5.007003||Viu +Perl_fp_class_nzero|5.007003||Viu +Perl_fp_class_pdenorm|5.007003||Viu +Perl_fp_class_pinf|5.007003||Viu +Perl_fp_class_pnorm|5.007003||Viu +Perl_fp_class_pzero|5.007003||Viu +Perl_fp_class_qnan|5.007003||Viu +Perl_fp_class_snan|5.007003||Viu +Perl_fp_class_zero|5.007003||Viu +PERL_FPU_INIT|5.007002||Viu +PERL_FPU_POST_EXEC|5.008001||Viu +PERL_FPU_PRE_EXEC|5.008001||Viu +perl_free|5.003007|5.003007|n +Perl_free_c_backtrace|5.021001||Viu +Perl_frexp|5.006000|5.006000|n +PERL_FS_VER_FMT|5.006000||Viu +PERL_FS_VERSION|5.010001||Viu +PERL_GCC_BRACE_GROUPS_FORBIDDEN|5.008001||Viu +PERL_GCC_VERSION_GE|5.035003||Viu +PERL_GCC_VERSION_GT|5.035003||Viu +PERL_GCC_VERSION_LE|5.035003||Viu +PERL_GCC_VERSION_LT|5.035003||Viu +PERL_GET_CONTEXT|5.006000||Viu +PERL_GET_INTERP|5.006000||Viu +PERL_GET_THX|5.006000||Viu +PERL_GIT_UNPUSHED_COMMITS|5.010001||Viu +PERL_GPROF_MONCONTROL|5.007002||Viu +PERL_HANDY_H|5.027001||Viu +PERL_HAS_FAST_GET_LSB_POS32|5.035003||Viu +PERL_HAS_FAST_GET_LSB_POS64|5.035003||Viu +PERL_HAS_FAST_GET_MSB_POS32|5.035003||Viu +PERL_HAS_FAST_GET_MSB_POS64|5.035003||Viu +PERL_HASH|5.003007|5.003007|p +PERL_HASH_DEFAULT_HvMAX|5.017011||Viu +PERL_HASH_FUNC|5.017006||Viu +PERL_HASH_FUNC_SIPHASH13|5.033007||Viu +PERL_HASH_FUNC_ZAPHOD32|5.027001||Viu +PERL_HASH_INTERNAL|5.008002||Viu +PERL_HASH_ITER_BUCKET|5.018000||Viu +PERL_HASH_RANDOMIZE_KEYS|5.018000||Viu +PERL_HASH_SEED|5.008001||Viu +PERL_HASH_SEED_BYTES|5.017006||Viu +PERL_HASH_SEED_STATE|5.027001||Viu +PERL_HASH_SEED_WORDS|5.033007||Viu +PERL_HASH_STATE_BYTES|5.027001||Viu +PERL_HASH_STATE_WORDS|5.033007||Viu +PERL_HASH_USE_SBOX32_ALSO|5.027001||Viu +PERL_HASH_WITH_SEED|5.021001||Viu +PERL_HASH_WITH_STATE|5.027001||Viu +PERL_HV_ARRAY_ALLOC_BYTES|5.006000||Viu +PERL___I|5.009005||Viu +PERL_IMPLICIT_CONTEXT|5.006000||Viu +PERL_INC_VERSION_LIST|5.035009|5.035009|Vn +Perl_internal_drand48|5.027004||Viu +PERL_INTERPRETER_SIZE_UPTO_MEMBER|5.010000||Viu +PERL_INT_MAX|5.003007|5.003007|p +PERL_INT_MIN|5.003007|5.003007|p +PERL_INVLIST_INLINE_H|5.029006||Viu +PerlIO|5.003007||Viu +PerlIO_apply_layers|5.007001|5.007001| +PerlIOArg|5.007001||Viu +PerlIOBase|5.007001||Viu +PerlIO_binmode|5.007001|5.007001| +PERLIOBUF_DEFAULT_BUFSIZ|5.013007||Viu +PerlIO_canset_cnt|5.003007|5.003007|n +PerlIO_clearerr|5.007003|5.007003| +PerlIO_close|5.007003|5.007003| +PerlIO_context_layers|||u +PerlIO_debug|5.007001|5.007001| +PERLIO_DUP_CLONE|5.007003||Viu +PERLIO_DUP_FD|5.007003||Viu +PerlIO_eof|5.007003|5.007003| +PerlIO_error|5.007003|5.007003| +PerlIO_exportFILE|5.003007|5.003007|n +PERLIO_F_APPEND|5.007001|5.007001| +PerlIO_fast_gets|5.003007|5.003007|n +PERLIO_F_CANREAD|5.007001|5.007001| +PERLIO_F_CANWRITE|5.007001|5.007001| +PERLIO_F_CLEARED|5.013008||Viu +PERLIO_F_CRLF|5.007001|5.007001| +PerlIO_fdopen|5.003007|5.003007|n +PERLIO_F_EOF|5.007001|5.007001| +PERLIO_F_ERROR|5.007001|5.007001| +PERLIO_F_FASTGETS|5.007001|5.007001| +PerlIO_fileno|5.007003|5.007003| +PerlIO_fill|5.007000|5.007000|u +PerlIO_findFILE|5.003007|5.003007|n +PERLIO_F_LINEBUF|5.007001|5.007001| +PerlIO_flush|5.007003|5.007003| +PERLIO_F_NOTREG|5.008001||Viu +PERLIO_F_OPEN|5.007001|5.007001| +PERLIO_F_RDBUF|5.007001|5.007001| +PERLIO_F_TEMP|5.007001|5.007001| +PERLIO_F_TRUNCATE|5.007001|5.007001| +PERLIO_F_TTY|5.007001||Viu +PERLIO_F_UNBUF|5.007001|5.007001| +PERLIO_FUNCS_CAST|5.009003||pVu +PERLIO_FUNCS_DECL|5.009003|5.009003|pVu +PERLIO_F_UTF8|5.007001|5.007001| +PERLIO_F_WRBUF|5.007001|5.007001| +PerlIO_get_base|5.007003|5.007003| +PerlIO_get_bufsiz|5.007003|5.007003| +PerlIO_getc|5.003007|5.003007|n +PerlIO_get_cnt|5.007003|5.007003| +PerlIO_getpos|5.003007|5.003007|n +PerlIO_get_ptr|5.007003|5.007003| +PERLIO_H|5.027001||Viu +PerlIO_has_base|5.003007|5.003007|n +PerlIO_has_cntptr|5.003007|5.003007|n +PerlIO_importFILE|5.003007|5.003007|n +PERLIO_INIT|5.009005||Viu +PERLIO_K_BUFFERED|5.007001|5.007001| +PERLIO_K_CANCRLF|5.007001|5.007001| +PERLIO_K_DESTRUCT|5.007001||Viu +PERLIO_K_DUMMY|5.007001||Viu +PERLIO_K_FASTGETS|5.007001|5.007001| +PERLIO_K_MULTIARG|5.007003|5.007003| +PERLIO_K_RAW|5.007001|5.007001| +PERLIO_K_UTF8|5.007001||Viu +PERLIO_LAYERS|5.007001||Viu +PERLIOL_H|5.027001||Viu +PerlIONext|5.007001||Viu +PERLIO_NOT_STDIO|5.003007||Viu +PerlIO_open|5.003007|5.003007|n +PerlIO_printf|5.006000|5.003007| +PerlIO_putc|5.003007|5.003007|n +PerlIO_puts|5.003007|5.003007|n +PerlIO_read|5.007003|5.007003| +PerlIO_releaseFILE|5.003007|5.003007|n +PerlIO_reopen|5.003007|5.003007|n +PerlIO_restore_errno|5.021006||cViu +PerlIO_rewind|5.003007|5.003007|n +PerlIO_save_errno|5.021006||cViu +PerlIO_seek|5.007003|5.007003| +PerlIOSelf|5.007001||Viu +PerlIO_set_cnt|5.007003|5.007003| +PerlIO_setlinebuf|5.007003|5.007003| +PerlIO_setpos|5.003007|5.003007|n +PerlIO_set_ptrcnt|5.007003|5.007003| +PerlIO_stderr|5.007003|5.007003| +PerlIO_stdin|5.007003|5.007003| +PerlIO_stdout|5.007003|5.007003| +PerlIO_stdoutf|5.006000|5.003007| +PERLIO_STDTEXT|5.007001||Viu +PerlIO_tell|5.007003|5.007003| +PERLIO_TERM|5.009005||Viu +PerlIO_ungetc|5.003007|5.003007|n +PerlIO_unread|5.007003|5.007003|u +PERLIO_USING_CRLF|5.007003||Viu +PerlIOValid|5.007003||Viu +PerlIO_vprintf|5.003007|5.003007|n +PerlIO_write|5.007003|5.007003| +Perl_isfinite|5.007003|5.007003|n +Perl_isfinitel|5.021004||Viu +PERL_IS_GCC|5.032001||Viu +Perl_isinf|5.007003|5.007003|n +Perl_isnan|5.006001|5.006001|n +PERL_IS_SUBWORD_ADDR|5.027007||Viu +PERL_IS_UTF8_CHAR_DFA|5.035004||Viu +PERL_JNP_TO_DECIMAL|5.033001||Viu +Perl_langinfo|5.027004|5.027004|n +PERL_LANGINFO_H|5.027004||Viu +PERL_LAST_5_18_0_INTERP_MEMBER|5.017009||Viu +Perl_ldexp|5.021003|5.021003|n +PerlLIO_access|5.005000||Viu +PerlLIO_chmod|5.005000||Viu +PerlLIO_chown|5.005000||Viu +PerlLIO_chsize|5.005000||Viu +PerlLIO_close|5.005000||Viu +PerlLIO_dup2|5.005000||Viu +PerlLIO_dup2_cloexec|5.027008||Viu +PerlLIO_dup|5.005000||Viu +PerlLIO_dup_cloexec|5.027008||Viu +PerlLIO_flock|5.005000||Viu +PerlLIO_fstat|5.005000||Viu +PerlLIO_ioctl|5.005000||Viu +PerlLIO_isatty|5.005000||Viu +PerlLIO_link|5.006000||Viu +PerlLIO_lseek|5.005000||Viu +PerlLIO_lstat|5.005000||Viu +PerlLIO_mktemp|5.005000||Viu +PerlLIO_open3|5.005000||Viu +PerlLIO_open3_cloexec|5.027008||Viu +PerlLIO_open|5.005000||Viu +PerlLIO_open_cloexec|5.027008||Viu +PerlLIO_read|5.005000||Viu +PerlLIO_readlink|5.033005||Viu +PerlLIO_rename|5.005000||Viu +PerlLIO_setmode|5.005000||Viu +PerlLIO_stat|5.005000||Viu +PerlLIO_symlink|5.033005||Viu +PerlLIO_tmpnam|5.005000||Viu +PerlLIO_umask|5.005000||Viu +PerlLIO_unlink|5.005000||Viu +PerlLIO_utime|5.005000||Viu +PerlLIO_write|5.005000||Viu +PERL_LOADMOD_DENY|5.006000|5.003007| +PERL_LOADMOD_IMPORT_OPS|5.006000|5.003007| +PERL_LOADMOD_NOIMPORT|5.006000|5.003007| +Perl_log10|5.021004|5.021004|n +Perl_log|5.006000|5.006000|n +PERL_LONG_MAX|5.003007|5.003007|p +PERL_LONG_MIN|5.003007|5.003007|p +PERL_MAGIC_arylen|5.007002|5.003007|p +PERL_MAGIC_arylen_p|5.009003|5.009003| +PERL_MAGIC_backref|5.007002|5.003007|p +PERL_MAGIC_bm|5.007002|5.003007|p +PERL_MAGIC_checkcall|5.013006|5.013006| +PERL_MAGIC_collxfrm|5.007002|5.003007|p +PERL_MAGIC_dbfile|5.007002|5.003007|p +PERL_MAGIC_dbline|5.007002|5.003007|p +PERL_MAGIC_debugvar|5.021005|5.021005| +PERL_MAGIC_defelem|5.007002|5.003007|p +PERL_MAGIC_env|5.007002|5.003007|p +PERL_MAGIC_envelem|5.007002|5.003007|p +PERL_MAGIC_ext|5.007002|5.003007|p +PERL_MAGIC_fm|5.007002|5.003007|p +PERL_MAGIC_glob||5.003007|ponu +PERL_MAGIC_hints|5.009004|5.009004| +PERL_MAGIC_hintselem|5.009004|5.009004| +PERL_MAGIC_isa|5.007002|5.003007|p +PERL_MAGIC_isaelem|5.007002|5.003007|p +PERL_MAGIC_lvref|5.021005|5.021005| +PERL_MAGIC_mutex||5.003007|ponu +PERL_MAGIC_nkeys|5.007002|5.003007|p +PERL_MAGIC_nonelem|5.027009|5.027009| +PERL_MAGIC_overload||5.003007|ponu +PERL_MAGIC_overload_elem||5.003007|ponu +PERL_MAGIC_overload_table|5.007002|5.003007|p +PERL_MAGIC_pos|5.007002|5.003007|p +PERL_MAGIC_qr|5.007002|5.003007|p +PERL_MAGIC_READONLY_ACCEPTABLE|5.015000||Viu +PERL_MAGIC_regdata|5.007002|5.003007|p +PERL_MAGIC_regdatum|5.007002|5.003007|p +PERL_MAGIC_regex_global|5.007002|5.003007|p +PERL_MAGIC_rhash|5.009003|5.009003| +PERL_MAGIC_shared|5.007003|5.003007|p +PERL_MAGIC_shared_scalar|5.007003|5.003007|p +PERL_MAGIC_sig|5.007002|5.003007|p +PERL_MAGIC_sigelem|5.007002|5.003007|p +PERL_MAGIC_substr|5.007002|5.003007|p +PERL_MAGIC_sv|5.007002|5.003007|p +PERL_MAGIC_symtab|5.009003|5.009003| +PERL_MAGIC_taint|5.007002|5.003007|p +PERL_MAGIC_tied|5.007002|5.003007|p +PERL_MAGIC_tiedelem|5.007002|5.003007|p +PERL_MAGIC_tiedscalar|5.007002|5.003007|p +PERL_MAGIC_TYPE_IS_VALUE_MAGIC|5.015000||Viu +PERL_MAGIC_TYPE_READONLY_ACCEPTABLE|5.015000||Viu +PERL_MAGIC_utf8|5.008001|5.003007|p +PERL_MAGIC_UTF8_CACHESIZE|5.008001||Viu +PERL_MAGIC_uvar|5.007002|5.003007|p +PERL_MAGIC_uvar_elem|5.007003|5.003007|p +PERL_MAGIC_VALUE_MAGIC|5.015000||Viu +PERL_MAGIC_vec|5.007002|5.003007|p +PERL_MAGIC_vstring|5.008001|5.003007|p +PERL_MAGIC_VTABLE_MASK|5.015000||Viu +PERL_MALLOC_CTL_H|5.027001||Viu +Perl_malloc_good_size|5.010001||Viu +PERL_MALLOC_WRAP|5.009002|5.009002|Vn +PerlMem_calloc|5.006000||Viu +PerlMem_free|5.005000||Viu +PerlMem_free_lock|5.006000||Viu +PerlMem_get_lock|5.006000||Viu +PerlMem_is_locked|5.006000||Viu +PerlMem_malloc|5.005000||Viu +PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu +PerlMemParse_calloc|5.006000||Viu +PerlMemParse_free|5.006000||Viu +PerlMemParse_free_lock|5.006000||Viu +PerlMemParse_get_lock|5.006000||Viu +PerlMemParse_is_locked|5.006000||Viu +PerlMemParse_malloc|5.006000||Viu +PerlMemParse_realloc|5.006000||Viu +PerlMem_realloc|5.005000||Viu +PerlMemShared_calloc|5.006000||Viu +PerlMemShared_free|5.006000||Viu +PerlMemShared_free_lock|5.006000||Viu +PerlMemShared_get_lock|5.006000||Viu +PerlMemShared_is_locked|5.006000||Viu +PerlMemShared_malloc|5.006000||Viu +PerlMemShared_realloc|5.006000||Viu +PERL_MG_UFUNC|5.007001||Viu +Perl_modf|5.006000|5.006000|n +PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu +PERL_MULTICONCAT_IX_LENGTHS|5.027006||Viu +PERL_MULTICONCAT_IX_NARGS|5.027006||Viu +PERL_MULTICONCAT_IX_PLAIN_LEN|5.027006||Viu +PERL_MULTICONCAT_IX_PLAIN_PV|5.027006||Viu +PERL_MULTICONCAT_IX_UTF8_LEN|5.027006||Viu +PERL_MULTICONCAT_IX_UTF8_PV|5.027006||Viu +PERL_MULTICONCAT_MAXARG|5.027006||Viu +Perl_my_mkostemp|5.027008||Viu +Perl_my_mkstemp|5.027004||Viu +PERL_MY_SNPRINTF_GUARDED|5.009004||Viu +PERL_MY_SNPRINTF_POST_GUARD|5.021002||Viu +PERL_MY_VSNPRINTF_GUARDED|5.009004||Viu +PERL_MY_VSNPRINTF_POST_GUARD|5.021002||Viu +PERL_NO_DEV_RANDOM|5.009004||Viu +PERL_NON_CORE_CHECK_EMPTY|5.035004||Viu +PERL_OBJECT_THIS|5.005000||Viu +PERL_OP_PARENT|5.025001||Viu +PERL_PADNAME_MINIMAL|5.021007||Viu +PERL_PADSEQ_INTRO|5.013010||Viu +perl_parse|5.006000|5.006000|n +PERL_PATCHLEVEL_H_IMPLICIT|5.006000||Viu +PERL_PATCHNUM|5.010001||Viu +PERL_POISON_EXPR|5.019006||Viu +Perl_pow|5.006000|5.006000|n +Perl_pp_accept|5.013009||Viu +Perl_pp_aelemfast_lex|5.015000||Viu +Perl_pp_andassign|5.013009||Viu +Perl_pp_avalues|5.013009||Viu +Perl_pp_bind|5.013009||Viu +Perl_pp_bit_xor|5.013009||Viu +Perl_pp_chmod|5.013009||Viu +Perl_pp_chomp|5.013009||Viu +Perl_pp_connect|5.013009||Viu +Perl_pp_cos|5.013009||Viu +Perl_pp_custom|5.013009||Viu +Perl_pp_dbmclose|5.013009||Viu +PERL_PPDEF|5.006000||Viu +Perl_pp_dofile|5.013009||Viu +Perl_pp_dor|5.013009||Viu +Perl_pp_dorassign|5.013009||Viu +Perl_pp_dump|5.013009||Viu +Perl_pp_egrent|5.013009||Viu +Perl_pp_enetent|5.013009||Viu +Perl_pp_eprotoent|5.013009||Viu +Perl_pp_epwent|5.013009||Viu +Perl_pp_eservent|5.013009||Viu +Perl_pp_exp|5.013009||Viu +Perl_pp_fcntl|5.013009||Viu +Perl_pp_ftatime|5.013009||Viu +Perl_pp_ftbinary|5.013009||Viu +Perl_pp_ftblk|5.013009||Viu +Perl_pp_ftchr|5.013009||Viu +Perl_pp_ftctime|5.013009||Viu +Perl_pp_ftdir|5.013009||Viu +Perl_pp_fteexec|5.013009||Viu +Perl_pp_fteowned|5.013009||Viu +Perl_pp_fteread|5.013009||Viu +Perl_pp_ftewrite|5.013009||Viu +Perl_pp_ftfile|5.013009||Viu +Perl_pp_ftmtime|5.013009||Viu +Perl_pp_ftpipe|5.013009||Viu +Perl_pp_ftrexec|5.013009||Viu +Perl_pp_ftrwrite|5.013009||Viu +Perl_pp_ftsgid|5.013009||Viu +Perl_pp_ftsize|5.013009||Viu +Perl_pp_ftsock|5.013009||Viu +Perl_pp_ftsuid|5.013009||Viu +Perl_pp_ftsvtx|5.013009||Viu +Perl_pp_ftzero|5.013009||Viu +Perl_pp_getpeername|5.013009||Viu +Perl_pp_getsockname|5.013009||Viu +Perl_pp_ggrgid|5.013009||Viu +Perl_pp_ggrnam|5.013009||Viu +Perl_pp_ghbyaddr|5.013009||Viu +Perl_pp_ghbyname|5.013009||Viu +Perl_pp_gnbyaddr|5.013009||Viu +Perl_pp_gnbyname|5.013009||Viu +Perl_pp_gpbyname|5.013009||Viu +Perl_pp_gpbynumber|5.013009||Viu +Perl_pp_gpwnam|5.013009||Viu +Perl_pp_gpwuid|5.013009||Viu +Perl_pp_gsbyname|5.013009||Viu +Perl_pp_gsbyport|5.013009||Viu +Perl_pp_gsockopt|5.013009||Viu +Perl_pp_hex|5.013009||Viu +Perl_pp_i_postdec|5.006000||Viu +Perl_pp_i_postinc|5.006000||Viu +Perl_pp_i_predec|5.006000||Viu +Perl_pp_i_preinc|5.006000||Viu +Perl_pp_keys|5.013009||Viu +Perl_pp_kill|5.013009||Viu +Perl_pp_lcfirst|5.013009||Viu +Perl_pp_lineseq|5.013009||Viu +Perl_pp_listen|5.013009||Viu +Perl_pp_localtime|5.013009||Viu +Perl_pp_log|5.013009||Viu +Perl_pp_lstat|5.013009||Viu +Perl_pp_mapstart|5.013009||Viu +Perl_pp_msgctl|5.013009||Viu +Perl_pp_msgget|5.013009||Viu +Perl_pp_msgrcv|5.013009||Viu +Perl_pp_msgsnd|5.013009||Viu +Perl_pp_nbit_xor|5.021009||Viu +Perl_pp_orassign|5.013009||Viu +Perl_pp_padany|5.013009||Viu +Perl_pp_pop|5.013009||Viu +Perl_pp_read|5.013009||Viu +Perl_pp_recv|5.013009||Viu +Perl_pp_regcmaybe|5.013009||Viu +Perl_pp_rindex|5.013009||Viu +Perl_pp_rv2hv|5.013009||Viu +Perl_pp_say|5.013009||Viu +Perl_pp_sbit_xor|5.021009||Viu +Perl_pp_scalar|5.013009||Viu +Perl_pp_schomp|5.013009||Viu +Perl_pp_scope|5.013009||Viu +Perl_pp_seek|5.013009||Viu +Perl_pp_semop|5.013009||Viu +Perl_pp_send|5.013009||Viu +Perl_pp_sge|5.013009||Viu +Perl_pp_sgrent|5.013009||Viu +Perl_pp_sgt|5.013009||Viu +Perl_pp_shmctl|5.013009||Viu +Perl_pp_shmget|5.013009||Viu +Perl_pp_shmread|5.013009||Viu +Perl_pp_shutdown|5.013009||Viu +Perl_pp_slt|5.013009||Viu +Perl_pp_snetent|5.013009||Viu +Perl_pp_socket|5.013009||Viu +Perl_pp_sprotoent|5.013009||Viu +Perl_pp_spwent|5.013009||Viu +Perl_pp_sqrt|5.013009||Viu +Perl_pp_sservent|5.013009||Viu +Perl_pp_ssockopt|5.013009||Viu +Perl_pp_symlink|5.013009||Viu +Perl_pp_transr|5.013009||Viu +Perl_pp_unlink|5.013009||Viu +Perl_pp_utime|5.013009||Viu +Perl_pp_values|5.013009||Viu +PERL_PRESERVE_IVUV|5.007001||Viu +PERL_PRIeldbl|5.006001|5.006001|Vn +PERL_PRIfldbl|5.006000|5.006000|Vn +PERL_PRIgldbl|5.006000|5.006000|Vn +PerlProc_abort|5.005000||Viu +PerlProc_crypt|5.005000||Viu +PerlProc_DynaLoad|5.006000||Viu +PerlProc_execl|5.005000||Viu +PerlProc_execv|5.005000||Viu +PerlProc_execvp|5.005000||Viu +PerlProc__exit|5.005000||Viu +PerlProc_exit|5.005000||Viu +PerlProc_fork|5.006000||Viu +PerlProc_getegid|5.005000||Viu +PerlProc_geteuid|5.005000||Viu +PerlProc_getgid|5.005000||Viu +PerlProc_getlogin|5.005000||Viu +PerlProc_GetOSError|5.006000||Viu +PerlProc_getpid|5.006000||Viu +PerlProc_gettimeofday|5.008000||Viu +PerlProc_getuid|5.005000||Viu +PerlProc_kill|5.005000||Viu +PerlProc_killpg|5.005000||Viu +PerlProc_lasthost|5.007001||Viu +PerlProc_longjmp|5.005000||Viu +PerlProc_pause|5.005000||Viu +PerlProc_pclose|5.005000||Viu +PerlProc_pipe|5.005000||Viu +PerlProc_pipe_cloexec|5.027008||Viu +PerlProc_popen|5.005000||Viu +PerlProc_popen_list|5.007001||Viu +PerlProc_setgid|5.005000||Viu +PerlProc_setjmp|5.005000||Viu +PerlProc_setuid|5.005000||Viu +PerlProc_signal|5.005000||Viu +PerlProc_sleep|5.005000||Viu +PerlProc_spawnvp|5.008000||Viu +PerlProc_times|5.005000||Viu +PerlProc_wait|5.005000||Viu +PerlProc_waitpid|5.005000||Viu +perl_pthread_mutex_lock|5.023006||Viu +perl_pthread_mutex_unlock|5.023006||Viu +PERL_PV_ESCAPE_ALL|5.009004|5.003007|p +PERL_PV_ESCAPE_DWIM|5.019008||Viu +PERL_PV_ESCAPE_DWIM_ALL_HEX|||Viu +PERL_PV_ESCAPE_FIRSTCHAR|5.009004|5.003007|p +PERL_PV_ESCAPE_NOBACKSLASH|5.009004|5.003007|p +PERL_PV_ESCAPE_NOCLEAR|5.009004|5.003007|p +PERL_PV_ESCAPE_NONASCII|5.013009|5.013009| +PERL_PV_ESCAPE_QUOTE|5.009004|5.003007|p +PERL_PV_ESCAPE_RE|5.009005|5.003007|p +PERL_PV_ESCAPE_UNI|5.009004|5.003007|p +PERL_PV_ESCAPE_UNI_DETECT|5.009004|5.003007|p +PERL_PV_PRETTY_DUMP|5.009004||pcV +PERL_PV_PRETTY_ELLIPSES|5.010000|5.003007|p +PERL_PV_PRETTY_EXACTSIZE|5.021005||Viu +PERL_PV_PRETTY_LTGT|5.009004|5.003007|p +PERL_PV_PRETTY_NOCLEAR|5.010000||pcV +PERL_PV_PRETTY_QUOTE|5.009004|5.003007|p +PERL_PV_PRETTY_REGPROP|5.009004||pcV +PERL_QUAD_MAX|5.003007|5.003007|p +PERL_QUAD_MIN|5.003007|5.003007|p +PERL_READ_LOCK|5.033005||Viu +PERL_READ_UNLOCK|5.033005||Viu +PERL_REENTR_API|5.009005||Viu +PERL_REENTR_H|5.027001||Viu +PERL_REENTR_USING_ASCTIME_R|5.031011||Viu +PERL_REENTR_USING_CRYPT_R|5.031011||Viu +PERL_REENTR_USING_CTERMID_R|5.031011||Viu +PERL_REENTR_USING_CTIME_R|5.031011||Viu +PERL_REENTR_USING_ENDGRENT_R|5.031011||Viu +PERL_REENTR_USING_ENDHOSTENT_R|5.031011||Viu +PERL_REENTR_USING_ENDNETENT_R|5.031011||Viu +PERL_REENTR_USING_ENDPROTOENT_R|5.031011||Viu +PERL_REENTR_USING_ENDPWENT_R|5.031011||Viu +PERL_REENTR_USING_ENDSERVENT_R|5.031011||Viu +PERL_REENTR_USING_GETGRENT_R|5.031011||Viu +PERL_REENTR_USING_GETGRGID_R|5.031011||Viu +PERL_REENTR_USING_GETGRNAM_R|5.031011||Viu +PERL_REENTR_USING_GETHOSTBYADDR_R|5.031011||Viu +PERL_REENTR_USING_GETHOSTBYNAME_R|5.031011||Viu +PERL_REENTR_USING_GETHOSTENT_R|5.031011||Viu +PERL_REENTR_USING_GETLOGIN_R|5.031011||Viu +PERL_REENTR_USING_GETNETBYADDR_R|5.031011||Viu +PERL_REENTR_USING_GETNETBYNAME_R|5.031011||Viu +PERL_REENTR_USING_GETNETENT_R|5.031011||Viu +PERL_REENTR_USING_GETPROTOBYNAME_R|5.031011||Viu +PERL_REENTR_USING_GETPROTOBYNUMBER_R|5.031011||Viu +PERL_REENTR_USING_GETPROTOENT_R|5.031011||Viu +PERL_REENTR_USING_GETPWENT_R|5.031011||Viu +PERL_REENTR_USING_GETPWNAM_R|5.031011||Viu +PERL_REENTR_USING_GETPWUID_R|5.031011||Viu +PERL_REENTR_USING_GETSERVBYNAME_R|5.031011||Viu +PERL_REENTR_USING_GETSERVBYPORT_R|5.031011||Viu +PERL_REENTR_USING_GETSERVENT_R|5.031011||Viu +PERL_REENTR_USING_GETSPNAM_R|5.031011||Viu +PERL_REENTR_USING_GMTIME_R|5.031011||Viu +PERL_REENTR_USING_LOCALTIME_R|5.031011||Viu +PERL_REENTR_USING_READDIR64_R|5.031011||Viu +PERL_REENTR_USING_READDIR_R|5.031011||Viu +PERL_REENTR_USING_SETGRENT_R|5.031011||Viu +PERL_REENTR_USING_SETHOSTENT_R|5.031011||Viu +PERL_REENTR_USING_SETLOCALE_R|5.031011||Viu +PERL_REENTR_USING_SETNETENT_R|5.031011||Viu +PERL_REENTR_USING_SETPROTOENT_R|5.031011||Viu +PERL_REENTR_USING_SETPWENT_R|5.031011||Viu +PERL_REENTR_USING_SETSERVENT_R|5.031011||Viu +PERL_REENTR_USING_STRERROR_R|5.031011||Viu +PERL_REENTR_USING_TMPNAM_R|5.031011||Viu +PERL_REENTR_USING_TTYNAME_R|5.031011||Viu +PERL_REGCHARCLASS_H|5.027001||Viu +PERL_REGCOMP_H|5.029006||Viu +PERL_REGMATCH_SLAB_SLOTS|5.009004||Viu +PERL_RELOCATABLE_INC|5.017002|5.017002|Vn +PERL_REVISION|5.006000|5.006000|d +perl_run|5.003007|5.003007|n +PERL_RW_MUTEX_DESTROY|5.033005||Viu +PERL_RW_MUTEX_INIT|5.033005||Viu +Perl_safesysmalloc_size|5.010001||Viu +PERL_SAWAMPERSAND|5.017010||Viu +PERL_SCAN_ALLOW_MEDIAL_UNDERSCORES|5.031009||Viu +PERL_SCAN_ALLOW_UNDERSCORES|5.007003|5.003007|p +PERL_SCAN_DISALLOW_PREFIX|5.007003|5.003007|p +PERL_SCAN_GREATER_THAN_UV_MAX|5.007003|5.003007|p +PERL_SCAN_NOTIFY_ILLDIGIT|5.031008||Viu +PERL_SCAN_SILENT_ILLDIGIT|5.008001|5.003007|p +PERL_SCAN_SILENT_NON_PORTABLE|5.015001||Viu +PERL_SCAN_SILENT_OVERFLOW|5.031009||Viu +PERL_SCAN_TRAILING|5.021002|5.021002| +PERL_SCNfldbl|5.006001|5.006001|Vn +PERL_SCRIPT_MODE|5.004005||Viu +PERL_SEEN_HV_FUNC_H|5.017010||Viu +PERL_SEEN_HV_MACRO_H|5.027001||Viu +PERL_SET_CONTEXT|5.006000||Viu +PERL_SET_INTERP|5.006000||Viu +Perl_setlocale|5.027002|5.027002|n +PERL_SET_PHASE|5.015001||Viu +PERL_SET_THX|5.006000||Viu +Perl_sharepvn|5.006000||Viu +PERL_SHORT_MAX|5.003007|5.003007|p +PERL_SHORT_MIN|5.003007|5.003007|p +PERLSI_DESTROY|5.005000||Viu +PERLSI_DIEHOOK|5.005000||Viu +PERL_SIGNALS_UNSAFE_FLAG|5.008001|5.003007|p +Perl_signbit|5.009005|5.009005|xn +PERLSI_MAGIC|5.005000||Viu +PERLSI_MAIN|5.005000||Viu +PERLSI_MULTICALL|5.023000||Viu +Perl_sin|5.006000|5.006000|n +Perl_sinh|5.021004|5.021004|n +PerlSIO_canset_cnt|5.007001||Viu +PerlSIO_clearerr|5.007001||Viu +PerlSIO_fast_gets|5.007001||Viu +PerlSIO_fclose|5.007001||Viu +PerlSIO_fdopen|5.007001||Viu +PerlSIO_fdupopen|5.007001||Viu +PerlSIO_feof|5.007001||Viu +PerlSIO_ferror|5.007001||Viu +PerlSIO_fflush|5.007001||Viu +PerlSIO_fgetc|5.007001||Viu +PerlSIO_fgetpos|5.007001||Viu +PerlSIO_fgets|5.007001||Viu +PerlSIO_fileno|5.007001||Viu +PerlSIO_fopen|5.007001||Viu +PerlSIO_fputc|5.007001||Viu +PerlSIO_fputs|5.007001||Viu +PerlSIO_fread|5.007001||Viu +PerlSIO_freopen|5.007001||Viu +PerlSIO_fseek|5.007001||Viu +PerlSIO_fsetpos|5.007001||Viu +PerlSIO_ftell|5.007001||Viu +PerlSIO_fwrite|5.007001||Viu +PerlSIO_get_base|5.007001||Viu +PerlSIO_get_bufsiz|5.007001||Viu +PerlSIO_get_cnt|5.007001||Viu +PerlSIO_get_ptr|5.007001||Viu +PerlSIO_has_base|5.007001||Viu +PerlSIO_has_cntptr|5.007001||Viu +PerlSIO_init|5.007001||Viu +PerlSIO_printf|5.007001||Viu +PerlSIO_rewind|5.007001||Viu +PerlSIO_setbuf|5.007001||Viu +PerlSIO_set_cnt|5.007001||Viu +PerlSIO_setlinebuf|5.007001||Viu +PerlSIO_set_ptr|5.007001||Viu +PerlSIO_setvbuf|5.007001||Viu +PerlSIO_stderr|5.007001||Viu +PerlSIO_stdin|5.007001||Viu +PerlSIO_stdout|5.007001||Viu +PerlSIO_stdoutf|5.007001||Viu +PerlSIO_tmpfile|5.007001||Viu +PerlSIO_ungetc|5.007001||Viu +PERLSI_OVERLOAD|5.005000||Viu +PerlSIO_vprintf|5.007001||Viu +PERL_SIPHASH_FNC|5.025008||Viu +PERLSI_REGCOMP|5.031011||Viu +PERLSI_REQUIRE|5.005000||Viu +PERLSI_SIGNAL|5.005000||Viu +PERLSI_SORT|5.005000||Viu +PERLSI_UNDEF|5.005000||Viu +PERLSI_UNKNOWN|5.005000||Viu +PERLSI_WARNHOOK|5.005000||Viu +PERL_SNPRINTF_CHECK|5.021002||Viu +PerlSock_accept|5.005000||Viu +PerlSock_accept_cloexec|5.027008||Viu +PerlSock_bind|5.005000||Viu +PerlSock_closesocket|5.006000||Viu +PerlSock_connect|5.005000||Viu +PerlSock_endhostent|5.005000||Viu +PerlSock_endnetent|5.005000||Viu +PerlSock_endprotoent|5.005000||Viu +PerlSock_endservent|5.005000||Viu +PerlSock_gethostbyaddr|5.005000||Viu +PerlSock_gethostbyname|5.005000||Viu +PerlSock_gethostent|5.005000||Viu +PerlSock_gethostname|5.005000||Viu +PerlSock_getnetbyaddr|5.005000||Viu +PerlSock_getnetbyname|5.005000||Viu +PerlSock_getnetent|5.005000||Viu +PerlSock_getpeername|5.005000||Viu +PerlSock_getprotobyname|5.005000||Viu +PerlSock_getprotobynumber|5.005000||Viu +PerlSock_getprotoent|5.005000||Viu +PerlSock_getservbyname|5.005000||Viu +PerlSock_getservbyport|5.005000||Viu +PerlSock_getservent|5.005000||Viu +PerlSock_getsockname|5.005000||Viu +PerlSock_getsockopt|5.005000||Viu +PerlSock_htonl|5.005000||Viu +PerlSock_htons|5.005000||Viu +PerlSock_inet_addr|5.005000||Viu +PerlSock_inet_ntoa|5.005000||Viu +PerlSock_listen|5.005000||Viu +PerlSock_ntohl|5.005000||Viu +PerlSock_ntohs|5.005000||Viu +PerlSock_recv|5.005000||Viu +PerlSock_recvfrom|5.005000||Viu +PerlSock_select|5.005000||Viu +PerlSock_send|5.005000||Viu +PerlSock_sendto|5.005000||Viu +PerlSock_sethostent|5.005000||Viu +PerlSock_setnetent|5.005000||Viu +PerlSock_setprotoent|5.005000||Viu +PerlSock_setservent|5.005000||Viu +PerlSock_setsockopt|5.005000||Viu +PerlSock_shutdown|5.005000||Viu +PERL_SOCKS_NEED_PROTOTYPES|5.007001||Viu +PerlSock_socket|5.005000||Viu +PerlSock_socket_cloexec|5.027008||Viu +PerlSock_socketpair|5.005000||Viu +PerlSock_socketpair_cloexec|5.027008||Viu +Perl_sqrt|5.006000|5.006000|n +PERL_STACK_OVERFLOW_CHECK|5.006000||Viu +PERL_STATIC_FORCE_INLINE|5.031011||Viu +PERL_STATIC_FORCE_INLINE_NO_RET|5.031011||Viu +PERL_STATIC_INLINE|5.013004|5.013004|poVn +PERL_STATIC_INLINE_NO_RET|5.017005||Viu +PERL_STATIC_NO_RET|5.017005||Viu +PERL_STRLEN_EXPAND_SHIFT|5.013004||Viu +PERL_STRLEN_ROUNDUP|5.009003||Viu +PERL_STRLEN_ROUNDUP_QUANTUM|5.009003||Viu +Perl_strtod|5.021004||Viu +PERL_SUB_DEPTH_WARN|5.010001||Viu +PERL_SUBVERSION|5.006000|5.003007|d +PERL_SYS_FPU_INIT|5.021005||Viu +PERL_SYS_INIT3|5.006000|5.006000| +PERL_SYS_INIT3_BODY|5.010000||Viu +PERL_SYS_INIT|5.003007|5.003007| +PERL_SYS_INIT_BODY|5.010000||Viu +PERL_SYS_TERM|5.003007|5.003007| +PERL_SYS_TERM_BODY|5.010000||Viu +Perl_tan|5.021004|5.021004|n +Perl_tanh|5.021004|5.021004|n +PERL_TARGETARCH|5.007002|5.007002|Vn +PERL_THREAD_LOCAL|5.035004|5.035004|Vn +PERL_TIME64_CONFIG_H|5.027001||Viu +PERL_TIME64_H|5.027001||Viu +PERL_TRACK_MEMPOOL|5.009003||Viu +PERL_TSA|5.023006||Viu +PERL_TSA_ACQUIRE|5.023006||Viu +PERL_TSA_ACTIVE|5.023006||Viu +PERL_TSA_CAPABILITY|5.023006||Viu +PERL_TSA_EXCLUDES|5.023006||Viu +PERL_TSA_GUARDED_BY|5.023006||Viu +PERL_TSA_NO_TSA|5.023006||Viu +PERL_TSA_PT_GUARDED_BY|5.023006||Viu +PERL_TSA_RELEASE|5.023006||Viu +PERL_TSA_REQUIRES|5.023006||Viu +PERL_UCHAR_MAX|5.003007|5.003007|p +PERL_UCHAR_MIN|5.003007|5.003007|p +PERL_UINT_MAX|5.003007|5.003007|p +PERL_UINT_MIN|5.003007|5.003007|p +PERL_ULONG_MAX|5.003007|5.003007|p +PERL_ULONG_MIN|5.003007|5.003007|p +PERL_UNICODE_ALL_FLAGS|5.008001||Viu +PERL_UNICODE_ARGV|5.008001||Viu +PERL_UNICODE_ARGV_FLAG|5.008001||Viu +PERL_UNICODE_CONSTANTS_H|5.027001||Viu +PERL_UNICODE_DEFAULT_FLAGS|5.008001||Viu +PERL_UNICODE_IN|5.008001||Viu +PERL_UNICODE_IN_FLAG|5.008001||Viu +PERL_UNICODE_INOUT|5.008001||Viu +PERL_UNICODE_INOUT_FLAG|5.008001||Viu +PERL_UNICODE_LOCALE|5.008001||Viu +PERL_UNICODE_LOCALE_FLAG|5.008001||Viu +PERL_UNICODE_MAX|5.007003||Viu +PERL_UNICODE_OUT|5.008001||Viu +PERL_UNICODE_OUT_FLAG|5.008001||Viu +PERL_UNICODE_STD|5.008001||Viu +PERL_UNICODE_STDERR|5.008001||Viu +PERL_UNICODE_STDERR_FLAG|5.008001||Viu +PERL_UNICODE_STD_FLAG|5.008001||Viu +PERL_UNICODE_STDIN|5.008001||Viu +PERL_UNICODE_STDIN_FLAG|5.008001||Viu +PERL_UNICODE_STDOUT|5.008001||Viu +PERL_UNICODE_STDOUT_FLAG|5.008001||Viu +PERL_UNICODE_UTF8CACHEASSERT|5.009004||Viu +PERL_UNICODE_UTF8CACHEASSERT_FLAG|5.009004||Viu +PERL_UNICODE_WIDESYSCALLS|5.008001||Viu +PERL_UNICODE_WIDESYSCALLS_FLAG|5.008001||Viu +PERL_UNLOCK_HOOK|5.009004||Viu +PERL_UNUSED_ARG|5.009003|5.003007|p +PERL_UNUSED_CONTEXT|5.009004|5.003007|p +PERL_UNUSED_DECL|5.007002|5.003007|p +PERL_UNUSED_RESULT|5.021001|5.003007|p +PERL_UNUSED_VAR|5.007002|5.003007|p +PERL_UQUAD_MAX|5.003007|5.003007|p +PERL_UQUAD_MIN|5.003007|5.003007|p +PERL_USE_DEVEL|5.010001|5.010001|Vn +PERL_USE_GCC_BRACE_GROUPS|5.009004|5.003007|pV +PERL_USES_PL_PIDSTATUS|5.009003||Viu +PERL_USE_THREAD_LOCAL|5.035004||Viu +PERL_USHORT_MAX|5.003007|5.003007|p +PERL_USHORT_MIN|5.003007|5.003007|p +PERL_UTF8_H|5.027001||Viu +PERL_UTIL_H|5.025012||Viu +Perl_va_copy|5.007001||Viu +PERLVAR|5.005000||Viu +PERLVARA|5.006000||Viu +PERLVARI|5.005000||Viu +PERL_VARIANTS_WORD_MASK|5.027007||Viu +PERLVARIC|5.005000||Viu +PERL_VERSION|5.006000|5.003007|d +PERL_VERSION_EQ|5.033001||p +PERL_VERSION_GE|5.033001|5.003007|p +PERL_VERSION_GT|5.033001|5.003007|p +PERL_VERSION_LE|5.033001|5.003007|p +PERL_VERSION_LT|5.033001|5.003007|p +PERL_VERSION_MAJOR|5.033001||Viu +PERL_VERSION_MINOR|5.033001||Viu +PERL_VERSION_NE|5.033001||p +PERL_VERSION_PATCH|5.033001||Viu +PERL_VERSION_STRING|5.010001||Viu +PERL_WAIT_FOR_CHILDREN|5.006000||Viu +Perl_Warn_Bit|5.033003||Viu +Perl_warner_nocontext||5.004000|ponu +PERL_WARNHOOK_FATAL|5.009004||Viu +Perl_Warn_Off|5.033003||Viu +PERL_WORD_BOUNDARY_MASK|5.027007||Viu +PERL_WORDSIZE|5.027007||Viu +PERL_WRITE_LOCK|5.033005||Viu +PERL_WRITE_MSG_TO_CONSOLE|5.007003||Viu +PERL_WRITE_UNLOCK|5.033005||Viu +PERL_XSUB_H|5.027001||Viu +perly_sighandler|5.031007||cVnu +phase_name|5.035007|5.035007| +PHOSTNAME|5.006000|5.006000|Vn +pidgone|5.003007||Viu +Pid_t|5.005000|5.005000|Vn +pipe|5.005000||Viu +PIPE_OPEN_MODE|5.008002||Viu +PIPESOCK_MODE|5.008001||Viu +PL_AboveLatin1|5.015008||Viu +PL_amagic_generation|5.005000||Viu +PL_an|5.005000||Viu +PL_argvgv|5.005000||Viu +PL_argvoutgv|5.005000||Viu +PL_argvout_stack|5.006000||Viu +PL_Assigned_invlist|5.025009||Viu +PL_basetime|5.005000||Viu +PL_beginav|5.005000||Viu +PL_beginav_save|5.006001||Viu +PL_blockhooks|5.013003||Viu +PL_body_arenas|5.009004||Viu +PL_body_roots|5.009003||Viu +PL_bodytarget|5.005000||Viu +PL_breakable_sub_gen|5.010001||Viu +PL_bufend||5.003007|ponu +PL_bufptr||5.003007|ponu +PL_CCC_non0_non230|5.029008||Viu +PL_check|5.009003|5.006000| +PL_checkav|5.006000||Viu +PL_checkav_save|5.008001||Viu +PL_chopset|5.005000||Viu +PL_clocktick|5.008001||Viu +PL_collation_ix|5.005000||Viu +PL_collation_name|5.005000||Viu +PL_collation_standard|5.005000||Viu +PL_collxfrm_base|5.005000||Viu +PL_collxfrm_mult|5.005000||Viu +PL_colors|5.005000||Viu +PL_colorset|5.005000||Viu +PL_compcv|5.005000||Viu +PL_compiling|5.005000|5.003007|poVnu +PL_comppad|5.008001|5.008001|x +PL_comppad_name|5.017004|5.017004|x +PL_comppad_name_fill|5.005000||Viu +PL_comppad_name_floor|5.005000||Viu +PL_constpadix|5.021004||Viu +PL_copline||5.003007|ponu +PL_cop_seqmax|5.005000||Viu +PL_cshlen|5.005000||Viu +PL_curcop|5.004005|5.003007|p +PL_curcopdb|5.005000||Viu +PL_curlocales|5.027009||Viu +PL_curpad|5.005000|5.005000|x +PL_curpm|5.005000||Viu +PL_curpm_under|5.025007||Viu +PL_curstack|5.005000||Viu +PL_curstackinfo|5.005000||Viu +PL_curstash|5.004005|5.003007|p +PL_curstname|5.005000||Viu +PL_custom_op_descs|5.007003||Viu +PL_custom_op_names|5.007003||Viu +PL_custom_ops|5.013007||Viu +PL_cv_has_eval|5.009000||Viu +PL_dbargs|5.005000||Viu +PL_DBcontrol|5.021005||Viu +PL_DBcv|5.005000||Viu +PL_DBgv|5.005000||Viu +PL_DBline|5.005000||Viu +PL_DBsignal|5.005000|5.003007|poVnu +PL_DBsignal_iv|5.021005||Viu +PL_DBsingle|5.005000||pV +PL_DBsingle_iv|5.021005||Viu +PL_DBsub|5.005000||pV +PL_DBtrace|5.005000||pV +PL_DBtrace_iv|5.021005||Viu +PL_debstash|5.005000|5.003007|poVnu +PL_debug|5.005000||Viu +PL_debug_pad|5.007003||Viu +PL_defgv|5.004005|5.003007|p +PL_def_layerlist|5.007003||Viu +PL_defoutgv|5.005000||Viu +PL_defstash|5.005000||Viu +PL_delaymagic|5.005000||Viu +PL_delaymagic_egid|5.015008||Viu +PL_delaymagic_euid|5.015008||Viu +PL_delaymagic_gid|5.015008||Viu +PL_delaymagic_uid|5.015008||Viu +PL_destroyhook|5.010000||Viu +PL_diehook|5.005000|5.003007|poVnu +PL_Dir|5.006000||Viu +PL_dirty|5.005000|5.003007|poVnu +PL_doswitches|5.005000||Viu +PL_dowarn|5.005000||pV +PL_dumper_fd|5.009003||Viu +PL_dumpindent|5.006000||Viu +PL_dump_re_max_len|5.023008||Viu +PL_efloatbuf|5.006000||Viu +PL_efloatsize|5.006000||Viu +PL_E_FORMAT_PRECISION|5.029000||Viu +PL_encoding|5.007003||Viu +PL_endav|5.005000||Viu +PL_Env|5.006000||Viu +PL_envgv|5.005000||Viu +PL_errgv|5.004005|5.003007|p +PL_error_count||5.003007|ponu +PL_errors|5.006000||Viu +PL_e_script|5.005000||Viu +PL_eval_root|5.005000||Viu +PL_evalseq|5.005000||Viu +PL_eval_start|5.005000||Viu +PL_exit_flags|5.006000|5.006000| +PL_exitlist|5.005000||Viu +PL_exitlistlen|5.005000||Viu +PL_expect||5.003007|ponu +PL_fdpid|5.005000||Viu +PL_filemode|5.005000||Viu +PL_firstgv|5.005000||Viu +PL_forkprocess|5.005000||Viu +PL_formtarget|5.005000||Viu +PL_GCB_invlist|5.021009||Viu +PL_generation|5.005000||Viu +PL_gensym|5.005000||Viu +PL_globalstash|5.005000||Viu +PL_globhook|5.015005||Viu +PL_hash_rand_bits|5.017010||Viu +PL_HASH_RAND_BITS_ENABLED|5.018000||Viu +PL_hash_rand_bits_enabled|5.018000||Viu +PL_hash_seed|5.033007||Viu +PL_hash_state|5.033007||Viu +PL_HasMultiCharFold|5.017005||Viu +PL_hexdigit||5.003007|pn +PL_hintgv|5.005000||Viu +PL_hints|5.005000|5.003007|poVnu +PL_hv_fetch_ent_mh|5.005000||Viu +PL_incgv|5.005000||Viu +PL_in_clean_all|5.005000||Viu +PL_in_clean_objs|5.005000||Viu +PL_in_eval|5.005000||Viu +PL_initav|5.005000||Viu +PL_in_load_module|5.008001||Viu +PL_in_my||5.003007|ponu +PL_in_my_stash||5.005000|ponu +PL_inplace|5.005000||Viu +PL_in_some_fold|5.029007||Viu +PL_internal_random_state|5.027004||Viu +PL_in_utf8_COLLATE_locale|5.025002||Viu +PL_in_utf8_CTYPE_locale|5.019009||Viu +PL_in_utf8_turkic_locale|5.029008||Viu +PL_isarev|5.009005||Viu +PL_keyword_plugin|5.011002|5.011002|x +PL_known_layers|5.007003||Viu +PL_langinfo_buf|5.027004||Viu +PL_langinfo_bufsize|5.027004||Viu +PL_lastfd|5.005000||Viu +PL_lastgotoprobe|5.005000||Viu +PL_last_in_gv|5.005000||Vi +PL_laststatval|5.005000|5.003007|poVnu +PL_laststype|5.005000||Viu +PL_Latin1|5.015008||Viu +PL_LB_invlist|5.023007||Viu +PL_lc_numeric_mutex_depth|5.027009||Viu +PL_lex_state||5.003007|ponu +PL_lex_stuff||5.003007|ponu +PL_linestr||5.003007|ponu +PL_LIO|5.006000||Viu +PL_locale_utf8ness|5.027009||Viu +PL_localizing|5.005000||Viu +PL_localpatches|5.005000||Viu +PL_lockhook|5.007003||Viu +PL_main_cv|5.005000||Viu +PL_main_root|5.005000||Viu +PL_mainstack|5.005000||Viu +PL_main_start|5.005000||Viu +PL_markstack|5.005000||Viu +PL_markstack_max|5.005000||Viu +PL_markstack_ptr|5.005000||Viu +PL_max_intro_pending|5.005000||Viu +PL_maxo|5.005000||Viu +PL_maxsysfd|5.005000|5.005000| +PL_mbrlen_ps|5.031010||Viu +PL_mbrtowc_ps|5.031010||Viu +PL_Mem|5.006000||Viu +PL_mem_log|5.033005||Viu +PL_memory_debug_header|5.009004||Viu +PL_MemParse|5.006000||Viu +PL_MemShared|5.006000||Viu +PL_mess_sv|5.005000|5.004000|poVnu +PL_min_intro_pending|5.005000||Viu +PL_minus_a|5.005000||Viu +PL_minus_c|5.005000||Viu +PL_minus_E|5.009003||Viu +PL_minus_F|5.005000||Viu +PL_minus_l|5.005000||Viu +PL_minus_n|5.005000||Viu +PL_minus_p|5.005000||Viu +PL_modcount|5.005000||Viu +PL_modglobal|5.005000|5.005000| +PL_multideref_pc|5.021007||Viu +PL_my_cxt_list|5.009003||Viu +PL_my_cxt_size|5.009003||Viu +PL_na|5.004005|5.003007|p +PL_nomemok|5.005000||Viu +PL_no_modify||5.003007|ponu +PL_numeric_name|5.005000||Viu +PL_numeric_radix_sv|5.007002||Viu +PL_numeric_standard|5.005000||Viu +PL_numeric_underlying|5.027006||Viu +PL_numeric_underlying_is_standard|5.027009||Viu +PL_ofsgv|5.011000||Vi +PL_oldname|5.005000||Viu +PL_op|5.005000||Viu +PL_op_exec_cnt|5.019002||Viu +PL_opfreehook|5.011000|5.011000| +PL_op_mask|5.005000||Viu +PL_origalen|5.005000||Viu +PL_origargc|5.005000||Viu +PL_origargv|5.005000||Viu +PL_origenviron|5.005000||Viu +PL_origfilename|5.005000||Viu +PL_ors_sv|5.007001||Viu +PL_osname|5.005000||Viu +PL_padix|5.005000||Viu +PL_padix_floor|5.005000||Viu +PL_padlist_generation|5.021007||Viu +PL_padname_const|5.021007||Viu +PL_padname_undef|5.021007||Viu +PL_pad_reset_pending|5.005000||Viu +PL_parser|5.009005|5.003007|p +PL_patchlevel|5.005000||Viu +PL_peepp|5.007003|5.007003| +PL_perldb|5.005000|5.003007|poVnu +PL_perl_destruct_level|5.004005|5.003007|p +PL_perlio|5.007003||Viu +PL_phase|5.013007|5.013007| +PL_pidstatus|5.005000||Viu +PL_Posix_ptrs|5.029000||Viu +PL_ppaddr||5.003007|ponu +PL_preambleav|5.005000||Viu +PL_prevailing_version|5.035009||Viu +PL_Private_Use|5.029009||Viu +PL_Proc|5.006000||Viu +PL_profiledata|5.005000||Viu +PL_psig_name|5.006000||Viu +PL_psig_pend|5.007001||Viu +PL_psig_ptr|5.006000||Viu +PL_ptr_table|5.006000||Viu +PL_random_state|5.019004||Viu +PL_RANDOM_STATE_TYPE|5.019004||Viu +PL_reentrant_buffer|5.007002||Viu +PL_reentrant_retint|5.008001||Viu +PL_reg_curpm|5.006000||Viu +PL_regex_pad|5.007002||Viu +PL_regex_padav|5.007002||Viu +PL_registered_mros|5.010001||Viu +PL_regmatch_slab|5.009004||Viu +PL_regmatch_state|5.009004||Viu +PL_replgv|5.005000||Viu +PL_restartjmpenv|5.013001||Viu +PL_restartop|5.005000|5.005000| +PL_rpeepp|5.013005|5.013005| +PL_rs|5.005000||Vi +PL_rsfp||5.003007|ponu +PL_rsfp_filters||5.003007|ponu +PL_runops|5.006000|5.006000| +PL_savebegin|5.007003||Viu +PL_savestack|5.005000||Viu +PL_savestack_ix|5.005000||Viu +PL_savestack_max|5.005000||Viu +PL_sawampersand|5.005000||Viu +PL_SB_invlist|5.021009||Viu +PL_scopestack|5.005000||Viu +PL_scopestack_ix|5.005000||Viu +PL_scopestack_max|5.005000||Viu +PL_scopestack_name|5.011002||Viu +PL_SCX_invlist|5.027008||Viu +PL_secondgv|5.005000||Viu +PL_setlocale_buf|5.027009||Viu +PL_setlocale_bufsize|5.027009||Viu +PL_sharehook|5.007003||Viu +PL_sighandler1p|5.031007||Viu +PL_sighandler3p|5.031007||Viu +PL_sighandlerp|5.005000||Viu +PL_signalhook|5.013002||Viu +PL_signals|5.008001|5.003007|poVnu +PL_sig_pending|5.007001||Viu +PL_Sock|5.006000||Viu +PL_sortcop|5.005000||Viu +PL_sortstash|5.005000||Viu +PL_splitstr|5.005000||Viu +PL_srand_called|5.006000||Viu +PL_stack_base|5.005000|5.003007|poVnu +PL_stack_max|5.005000||Viu +PL_stack_sp|5.005000|5.003007|poVnu +PL_start_env|5.005000||Viu +PL_stashcache|5.008001||Viu +PL_stashpad|5.017001||Viu +PL_stashpadix|5.017001||Viu +PL_stashpadmax|5.017001||Viu +PL_statcache|5.005000|5.003007|poVnu +PL_statgv|5.005000||Viu +PL_statname|5.005000||Viu +PL_statusvalue|5.005000||Viu +PL_statusvalue_posix|5.009003||Viu +PL_statusvalue_vms|5.005000||Viu +PL_stderrgv|5.006000||Viu +PL_stdingv|5.005000|5.003007|poVnu +PL_StdIO|5.006000||Viu +PL_strtab|5.005000||Viu +PL_strxfrm_is_behaved|5.025002||Viu +PL_strxfrm_max_cp|5.025002||Viu +PL_strxfrm_NUL_replacement|5.025008||Viu +PL_sub_generation|5.005000||Viu +PL_subline|5.005000||Viu +PL_subname|5.005000||Viu +PL_Sv|5.005000||pcV +PL_sv_arenaroot|5.005000|5.003007|poVnu +PL_sv_consts|5.019002||Viu +PL_sv_count|5.005000||Viu +PL_sv_immortals|5.027003||Viu +PL_sv_no|5.004005|5.003007|p +PL_sv_root|5.005000||Viu +PL_sv_serial|5.010001||Viu +PL_sv_undef|5.004005|5.003007|p +PL_sv_yes|5.004005|5.003007|p +PL_sv_zero|5.027003|5.027003| +PL_sys_intern|5.005000||Viu +PL_tainted|5.005000|5.003007|poVnu +PL_tainting|5.005000|5.003007|poVnu +PL_taint_warn|5.007003||Viu +PL_threadhook|5.008000||Viu +PL_tmps_floor|5.005000||Viu +PL_tmps_ix|5.005000||Viu +PL_tmps_max|5.005000||Viu +PL_tmps_stack|5.005000||Viu +PL_tokenbuf||5.003007|ponu +PL_top_env|5.005000||Viu +PL_toptarget|5.005000||Viu +PL_TR_SPECIAL_HANDLING_UTF8|5.031006||Viu +PL_underlying_numeric_obj|5.027009||Viu +PL_unicode|5.008001||Viu +PL_unitcheckav|5.009005||Viu +PL_unitcheckav_save|5.009005||Viu +PL_unlockhook|5.007003||Viu +PL_unsafe|5.005000||Viu +PL_UpperLatin1|5.019005||Viu +PLUS|5.003007||Viu +PLUS_t8|5.035004||Viu +PLUS_t8_p8|5.033003||Viu +PLUS_t8_pb|5.033003||Viu +PLUS_tb|5.035004||Viu +PLUS_tb_p8|5.033003||Viu +PLUS_tb_pb|5.033003||Viu +PL_utf8cache|5.009004||Viu +PL_utf8_charname_begin|5.017006||Viu +PL_utf8_charname_continue|5.017006||Viu +PL_utf8_foldclosures|5.013007||Viu +PL_utf8_idcont|5.008000||Viu +PL_utf8_idstart|5.008000||Viu +PL_utf8locale|5.008001||Viu +PL_utf8_mark|5.006000||Viu +PL_utf8_perl_idcont|5.017008||Viu +PL_utf8_perl_idstart|5.015004||Viu +PL_utf8_tofold|5.007003||Viu +PL_utf8_tolower|5.006000||Viu +PL_utf8_tosimplefold|5.027011||Viu +PL_utf8_totitle|5.006000||Viu +PL_utf8_toupper|5.006000||Viu +PL_utf8_xidcont|5.013010||Viu +PL_utf8_xidstart|5.013010||Viu +PL_vtbl_arylen|5.015000||Viu +PL_vtbl_arylen_p|5.015000||Viu +PL_vtbl_backref|5.015000||Viu +PL_vtbl_bm|5.015000||Viu +PL_vtbl_checkcall|5.017000||Viu +PL_vtbl_collxfrm|5.015000||Viu +PL_vtbl_dbline|5.015000||Viu +PL_vtbl_debugvar|5.021005||Viu +PL_vtbl_defelem|5.015000||Viu +PL_vtbl_env|5.015000||Viu +PL_vtbl_envelem|5.015000||Viu +PL_vtbl_fm|5.015000||Viu +PL_vtbl_hints|5.015000||Viu +PL_vtbl_hintselem|5.015000||Viu +PL_vtbl_isa|5.015000||Viu +PL_vtbl_isaelem|5.015000||Viu +PL_vtbl_lvref|5.021005||Viu +PL_vtbl_mglob|5.015000||Viu +PL_vtbl_nkeys|5.015000||Viu +PL_vtbl_nonelem|5.027009||Viu +PL_vtbl_ovrld|5.015000||Viu +PL_vtbl_pack|5.015000||Viu +PL_vtbl_packelem|5.015000||Viu +PL_vtbl_pos|5.015000||Viu +PL_vtbl_regdata|5.015000||Viu +PL_vtbl_regdatum|5.015000||Viu +PL_vtbl_regexp|5.015000||Viu +PL_vtbl_sig|5.035001||Viu +PL_vtbl_sigelem|5.015000||Viu +PL_vtbl_substr|5.015000||Viu +PL_vtbl_sv|5.015000||Viu +PL_vtbl_taint|5.015000||Viu +PL_vtbl_utf8|5.015000||Viu +PL_vtbl_uvar|5.015000||Viu +PL_vtbl_vec|5.015000||Viu +PL_warnhook|5.005000||Viu +PL_warn_locale|5.021008||Viu +PL_watchaddr|5.006000||Viu +PL_watchok|5.006000||Viu +PL_WB_invlist|5.021009||Viu +PL_wcrtomb_ps|5.031010||Viu +PL_XPosix_ptrs|5.017008||Viu +PL_Xpv|5.005000|5.003007|poVnu +PL_xsubfilename|5.021006||Viu +pm_description|5.009004||Viu +PMf_BASE_SHIFT|5.013004||Viu +PMf_CHARSET|5.017011||Viu +PMf_CODELIST_PRIVATE|5.017001||Viu +PMf_CONST|5.003007||Viu +PMf_CONTINUE|5.004000||Viu +PMf_EVAL|5.003007||Viu +PMf_EXTENDED|5.003007||Viu +PMf_EXTENDED_MORE|5.021005||Viu +PMf_FOLD|5.003007||Viu +PMf_GLOBAL|5.003007||Viu +PMf_HAS_CV|5.017001||Viu +PMf_HAS_ERROR|5.025010||Viu +PMf_IS_QR|5.017001||Viu +PMf_KEEP|5.003007||Viu +PMf_KEEPCOPY|5.009005||Viu +PMf_MULTILINE|5.003007||Viu +PMf_NOCAPTURE|5.021008||Viu +PMf_NONDESTRUCT|5.013002||Viu +PMf_ONCE|5.003007||Viu +PMf_RETAINT|5.004005||Viu +PMf_SINGLELINE|5.003007||Viu +PMf_SPLIT|5.017011||Viu +PMf_STRICT|5.021008||Viu +PMf_USED|5.009005||Viu +PMf_USE_RE_EVAL|5.017001||Viu +PMf_WILDCARD|5.031010||Viu +PM_GETRE|5.007002||Viu +pmop_dump|5.006000|5.006000|u +PmopSTASH|5.007001||Viu +PmopSTASHPV|5.007001||Viu +PmopSTASHPV_set|5.007001||Viu +PmopSTASH_set|5.007001||Viu +pmruntime|5.003007||Viu +PM_SETRE|5.007002||Viu +PM_STR|5.027010||Viu +pmtrans|5.003007||Viu +pMY_CXT|5.009000|5.009000|p +_pMY_CXT||5.009000|p +pMY_CXT_||5.009000|p +PNf|5.021007||Viu +PNfARG|5.021007||Viu +Poison|5.008000|5.003007|p +PoisonFree|5.009004|5.003007|p +PoisonNew|5.009004|5.003007|p +PoisonPADLIST|5.021006||Viu +POISON_SV_HEAD|||Viu +PoisonWith|5.009004|5.003007|p +popen|5.003007||Viu +POPi|5.003007|5.003007| +POPl|5.003007|5.003007| +POPMARK|5.003007||cViu +POP_MULTICALL|5.009003|5.009003| +POPn|5.006000|5.003007| +POPp|5.003007|5.003007| +POPpbytex|5.007001|5.007001| +POPpconstx|5.009003||Viu +POPpx|5.005003|5.005003| +POPs|5.003007|5.003007| +pop_scope|5.003007|5.003007|u +POPSTACK|5.005000||Viu +POPSTACK_TO|5.005000||Viu +POPu|5.004000|5.004000| +POPul|5.006000|5.006000| +populate_ANYOF_from_invlist|5.019005||Viu +populate_isa|||viu +POSIXA|5.017003||Viu +POSIXA_t8|5.035004||Viu +POSIXA_t8_p8|5.033003||Viu +POSIXA_t8_pb|5.033003||Viu +POSIXA_tb|5.035004||Viu +POSIXA_tb_p8|5.033003||Viu +POSIXA_tb_pb|5.033003||Viu +POSIX_CC_COUNT|5.017008||Viu +POSIXD|5.017003||Viu +POSIXD_t8|5.035004||Viu +POSIXD_t8_p8|5.033003||Viu +POSIXD_t8_pb|5.033003||Viu +POSIXD_tb|5.035004||Viu +POSIXD_tb_p8|5.033003||Viu +POSIXD_tb_pb|5.033003||Viu +POSIXL|5.017003||Viu +POSIXL_CLEAR|5.029004||Viu +POSIXL_SET|5.029004||Viu +POSIXL_t8|5.035004||Viu +POSIXL_t8_p8|5.033003||Viu +POSIXL_t8_pb|5.033003||Viu +POSIXL_tb|5.035004||Viu +POSIXL_tb_p8|5.033003||Viu +POSIXL_tb_pb|5.033003||Viu +POSIXL_TEST|5.029004||Viu +POSIXL_ZERO|5.029004||Viu +POSIXU|5.017003||Viu +POSIXU_t8|5.035004||Viu +POSIXU_t8_p8|5.033003||Viu +POSIXU_t8_pb|5.033003||Viu +POSIXU_tb|5.035004||Viu +POSIXU_tb_p8|5.033003||Viu +POSIXU_tb_pb|5.033003||Viu +PP|5.003007||Viu +pregcomp|5.009005|5.009005| +pregexec|5.003007|5.003007| +PREGf_ANCH|5.019009||Viu +PREGf_ANCH_GPOS|5.019009||Viu +PREGf_ANCH_MBOL|5.019009||Viu +PREGf_ANCH_SBOL|5.019009||Viu +PREGf_CUTGROUP_SEEN|5.009005||Viu +PREGf_GPOS_FLOAT|5.019009||Viu +PREGf_GPOS_SEEN|5.019009||Viu +PREGf_IMPLICIT|5.009005||Viu +PREGf_NAUGHTY|5.009005||Viu +PREGf_NOSCAN|5.019009||Viu +PREGf_RECURSE_SEEN|5.023009||Viu +pregfree2|5.011000||cVu +pregfree|5.003007|5.003007|u +PREGf_SKIP|5.009005||Viu +PREGf_USE_RE_EVAL|5.017001||Viu +PREGf_VERBARG_SEEN|5.009005||Viu +prepare_SV_for_RV|5.010001||Viu +prescan_version|5.011004|5.011004| +PRESCAN_VERSION|5.019008||Viu +PREVOPER|5.003007||Viu +PREV_RANGE_MATCHES_INVLIST|5.023002||Viu +printbuf|5.009004||Viu +print_bytes_for_locale|5.027002||Viu +print_collxfrm_input_and_return|5.025004||Viu +printf|5.003007||Viu +PRINTF_FORMAT_NULL_OK|5.009005|5.009005|Vn +printf_nocontext|5.007001||vdVnu +PRIVLIB|5.003007|5.003007|Vn +PRIVLIB_EXP|5.003007|5.003007|Vn +PRIVSHIFT|5.003007||Viu +process_special_blocks|5.009005||Viu +PROCSELFEXE_PATH|5.007003|5.007003|Vn +PRUNE|5.009005||Viu +PRUNE_t8|5.035004||Viu +PRUNE_t8_p8|5.033003||Viu +PRUNE_t8_pb|5.033003||Viu +PRUNE_tb|5.035004||Viu +PRUNE_tb_p8|5.033003||Viu +PRUNE_tb_pb|5.033003||Viu +PSEUDO|5.009004||Viu +PSEUDO_t8|5.035004||Viu +PSEUDO_t8_p8|5.033003||Viu +PSEUDO_t8_pb|5.033003||Viu +PSEUDO_tb|5.035004||Viu +PSEUDO_tb_p8|5.033003||Viu +PSEUDO_tb_pb|5.033003||Viu +pthread_addr_t|5.005000||Viu +PTHREAD_ATFORK|5.007002||Viu +pthread_attr_init|5.006000||Viu +PTHREAD_ATTR_SETDETACHSTATE|5.006000||Viu +pthread_condattr_default|5.005000||Viu +PTHREAD_CREATE|5.006000||Viu +pthread_create|5.008001||Viu +PTHREAD_CREATE_JOINABLE|5.005000||Viu +PTHREAD_GETSPECIFIC|5.007002||Viu +PTHREAD_GETSPECIFIC_INT|5.006000||Viu +pthread_key_create|5.005000||Viu +pthread_keycreate|5.008001||Viu +pthread_mutexattr_default|5.005000||Viu +pthread_mutexattr_init|5.005000||Viu +pthread_mutexattr_settype|5.005000||Viu +pTHX_12|5.019010||Viu +pTHX_1|5.006000||Viu +pTHX_2|5.006000||Viu +pTHX_3|5.006000||Viu +pTHX_4|5.006000||Viu +pTHX|5.006000|5.003007|p +pTHX_5|5.009003||Viu +pTHX_6|5.009003||Viu +pTHX_7|5.009003||Viu +pTHX_8|5.009003||Viu +pTHX_9|5.009003||Viu +pTHX_||5.003007|p +pTHX__FORMAT|5.009002||Viu +pTHX_FORMAT|5.009002||Viu +pTHXo|5.006000||Viu +pTHX__VALUE|5.009002||Viu +pTHX_VALUE|5.009002||Viu +pTHXx|5.006000||Viu +PTR2IV|5.006000|5.003007|p +PTR2nat|5.009003|5.003007|p +PTR2NV|5.006000|5.003007|p +PTR2ul|5.007001|5.003007|p +PTR2UV|5.006000|5.003007|p +Ptrdiff_t|5.029003||Viu +ptr_hash|5.017010||Vniu +PTRSIZE|5.005000|5.005000|Vn +ptr_table_fetch|5.009005|5.009005|u +ptr_table_find|5.009004||Vniu +ptr_table_free|5.009005|5.009005|u +ptr_table_new|5.009005|5.009005|u +ptr_table_split|5.009005|5.009005|u +ptr_table_store|5.009005|5.009005|u +PTRV|5.006000|5.003007|poVnu +PUSHi|5.003007|5.003007| +PUSHMARK|5.003007|5.003007| +PUSHmortal|5.009002|5.003007|p +PUSH_MULTICALL|5.011000|5.011000| +PUSH_MULTICALL_FLAGS|5.018000||Viu +PUSHn|5.006000|5.003007| +PUSHp|5.003007|5.003007| +PUSHs|5.003007|5.003007| +push_scope|5.003007|5.003007|u +PUSHSTACK|5.005000||Viu +PUSHSTACKi|5.005000||Viu +PUSHSTACK_INIT_HWM|5.027002||Viu +PUSHTARG|5.003007||Viu +PUSHu|5.004000|5.003007|p +PUTBACK|5.003007|5.003007| +putc|5.003007||Viu +put_charclass_bitmap_innards|5.021004||Viu +put_charclass_bitmap_innards_common|5.023008||Viu +put_charclass_bitmap_innards_invlist|5.023008||Viu +put_code_point|5.021004||Viu +putc_unlocked|5.003007||Viu +putenv|5.005000||Viu +put_range|5.019009||Viu +putw|5.003007||Viu +pv_display|5.006000|5.003007|p +pv_escape|5.009004|5.003007|p +pv_pretty|5.009004|5.003007|p +pv_uni_display|5.007003|5.007003| +pWARN_ALL|5.006000||Viu +pWARN_NONE|5.006000||Viu +pWARN_STD|5.006000||Viu +PWGECOS|5.004005|5.004005|Vn +PWPASSWD|5.005000|5.005000|Vn +qerror|5.006000||cViu +QR_PAT_MODS|5.009005||Viu +QUAD_IS_INT|5.006000|5.006000|Vn +QUAD_IS___INT64|5.015003|5.015003|Vn +QUAD_IS_INT64_T|5.006000|5.006000|Vn +QUAD_IS_LONG|5.006000|5.006000|Vn +QUAD_IS_LONG_LONG|5.006000|5.006000|Vn +QUADKIND|5.006000|5.006000|Vn +quadmath_format_needed|5.021004||Vni +quadmath_format_valid|5.031007||Vni +Quad_t|5.003007|5.003007|Vn +QUESTION_MARK_CTRL|5.021001||Viu +RADIXCHAR|5.027010||Viu +RANDBITS|5.003007|5.003007|Vn +RANDOM_R_PROTO|5.008000|5.008000|Vn +Rand_seed_t|5.006000|5.006000|Vn +RANGE_INDICATOR|5.031006||Viu +rck_elide_nothing|5.032001||Viu +RD_NODATA|5.003007|5.003007|Vn +read|5.005000||Viu +readdir|5.005000||Viu +readdir64|5.009000||Viu +READDIR64_R_PROTO|5.008000|5.008000|Vn +READDIR_R_PROTO|5.008000|5.008000|Vn +READ_XDIGIT|5.017006|5.017006| +realloc|5.003007||Vn +ReANY|5.017006||cVnu +re_compile|5.009005|5.009005|u +RE_COMPILE_RECURSION_INIT|5.029009||Viu +RE_COMPILE_RECURSION_LIMIT|5.029009||Viu +re_croak|||iu +recv|5.006000||Viu +recvfrom|5.005000||Viu +RE_DEBUG_COMPILE_DUMP|5.009004||Viu +RE_DEBUG_COMPILE_FLAGS|5.009005||Viu +RE_DEBUG_COMPILE_MASK|5.009004||Viu +RE_DEBUG_COMPILE_OPTIMISE|5.009004||Viu +RE_DEBUG_COMPILE_PARSE|5.009004||Viu +RE_DEBUG_COMPILE_TEST|5.021005||Viu +RE_DEBUG_COMPILE_TRIE|5.009004||Viu +RE_DEBUG_EXECUTE_INTUIT|5.009004||Viu +RE_DEBUG_EXECUTE_MASK|5.009004||Viu +RE_DEBUG_EXECUTE_MATCH|5.009004||Viu +RE_DEBUG_EXECUTE_TRIE|5.009004||Viu +RE_DEBUG_EXTRA_BUFFERS|5.009005||Viu +RE_DEBUG_EXTRA_DUMP_PRE_OPTIMIZE|5.031004||Viu +RE_DEBUG_EXTRA_GPOS|5.011000||Viu +RE_DEBUG_EXTRA_MASK|5.009004||Viu +RE_DEBUG_EXTRA_OPTIMISE|5.009005||Viu +RE_DEBUG_EXTRA_STACK|5.009005||Viu +RE_DEBUG_EXTRA_STATE|5.009004||Viu +RE_DEBUG_EXTRA_TRIE|5.009004||Viu +RE_DEBUG_EXTRA_WILDCARD|5.031011||Viu +RE_DEBUG_FLAG|5.009004||Viu +RE_DEBUG_FLAGS|5.009002||Viu +re_dup_guts|5.011000|5.011000| +reentrant_free|5.008000||cVu +reentrant_init|5.008000||cVu +REENTRANT_PROTO_B_B|5.008000||Viu +REENTRANT_PROTO_B_BI|5.008000||Viu +REENTRANT_PROTO_B_BW|5.008000||Viu +REENTRANT_PROTO_B_CCD|5.008000||Viu +REENTRANT_PROTO_B_CCS|5.008000||Viu +REENTRANT_PROTO_B_IBI|5.008000||Viu +REENTRANT_PROTO_B_IBW|5.008000||Viu +REENTRANT_PROTO_B_SB|5.008000||Viu +REENTRANT_PROTO_B_SBI|5.008000||Viu +REENTRANT_PROTO_I_BI|5.008000||Viu +REENTRANT_PROTO_I_BW|5.008000||Viu +REENTRANT_PROTO_I_CCSBWR|5.008000||Viu +REENTRANT_PROTO_I_CCSD|5.008000||Viu +REENTRANT_PROTO_I_CII|5.008000||Viu +REENTRANT_PROTO_I_CIISD|5.008000||Viu +REENTRANT_PROTO_I_CSBI|5.008000||Viu +REENTRANT_PROTO_I_CSBIR|5.008000||Viu +REENTRANT_PROTO_I_CSBWR|5.008000||Viu +REENTRANT_PROTO_I_CSBWRE|5.008000||Viu +REENTRANT_PROTO_I_CSD|5.008000||Viu +REENTRANT_PROTO_I_CWISBWRE|5.008000||Viu +REENTRANT_PROTO_I_CWISD|5.008000||Viu +REENTRANT_PROTO_I_D|5.008000||Viu +REENTRANT_PROTO_I_H|5.008000||Viu +REENTRANT_PROTO_I_IBI|5.008000||Viu +REENTRANT_PROTO_I_IBW|5.008000||Viu +REENTRANT_PROTO_I_ICBI|5.008000||Viu +REENTRANT_PROTO_I_ICSBWR|5.008000||Viu +REENTRANT_PROTO_I_ICSD|5.008000||Viu +REENTRANT_PROTO_I_ID|5.008000||Viu +REENTRANT_PROTO_I_IISD|5.008000||Viu +REENTRANT_PROTO_I_ISBWR|5.008000||Viu +REENTRANT_PROTO_I_ISD|5.008000||Viu +REENTRANT_PROTO_I_LISBI|5.008000||Viu +REENTRANT_PROTO_I_LISD|5.008000||Viu +REENTRANT_PROTO_I_SB|5.008000||Viu +REENTRANT_PROTO_I_SBI|5.008000||Viu +REENTRANT_PROTO_I_SBIE|5.008000||Viu +REENTRANT_PROTO_I_SBIH|5.008000||Viu +REENTRANT_PROTO_I_SBIR|5.008000||Viu +REENTRANT_PROTO_I_SBWR|5.008000||Viu +REENTRANT_PROTO_I_SBWRE|5.008000||Viu +REENTRANT_PROTO_I_SD|5.008000||Viu +REENTRANT_PROTO_I_TISD|5.008000||Viu +REENTRANT_PROTO_I_TS|5.008000||Viu +REENTRANT_PROTO_I_TSBI|5.008000||Viu +REENTRANT_PROTO_I_TSBIR|5.008000||Viu +REENTRANT_PROTO_I_TSBWR|5.008000||Viu +REENTRANT_PROTO_I_TsISBWRE|5.008001||Viu +REENTRANT_PROTO_I_TSR|5.008000||Viu +REENTRANT_PROTO_I_UISBWRE|5.008000||Viu +REENTRANT_PROTO_I_uISBWRE|5.008001||Viu +REENTRANT_PROTO_S_CBI|5.008000||Viu +REENTRANT_PROTO_S_CCSBI|5.008000||Viu +REENTRANT_PROTO_S_CIISBIE|5.008000||Viu +REENTRANT_PROTO_S_CSBI|5.008000||Viu +REENTRANT_PROTO_S_CSBIE|5.008000||Viu +REENTRANT_PROTO_S_CWISBIE|5.008000||Viu +REENTRANT_PROTO_S_CWISBWIE|5.008000||Viu +REENTRANT_PROTO_S_ICSBI|5.008000||Viu +REENTRANT_PROTO_S_ISBI|5.008000||Viu +REENTRANT_PROTO_S_LISBI|5.008000||Viu +REENTRANT_PROTO_S_SBI|5.008000||Viu +REENTRANT_PROTO_S_SBIE|5.008000||Viu +REENTRANT_PROTO_S_SBW|5.008000||Viu +REENTRANT_PROTO_S_TISBI|5.008000||Viu +REENTRANT_PROTO_S_TS|5.031011||Viu +REENTRANT_PROTO_S_TSBI|5.008000||Viu +REENTRANT_PROTO_S_TSBIE|5.008000||Viu +REENTRANT_PROTO_S_TWISBIE|5.008000||Viu +REENTRANT_PROTO_V_D|5.008000||Viu +REENTRANT_PROTO_V_H|5.008000||Viu +REENTRANT_PROTO_V_ID|5.008000||Viu +reentrant_retry|5.008000||vcVnu +reentrant_size|5.008000||cVu +REENTR_MEMZERO|5.009003||Viu +re_exec_indentf|5.023009||vViu +REF|5.003007||Viu +ref|5.009003||Viu +ref_array_or_hash|5.027008||Viu +refcounted_he_chain_2hv|5.013007||cVi +REFCOUNTED_HE_EXISTS|5.015007||Viu +refcounted_he_fetch_pv|5.013007||cVi +refcounted_he_fetch_pvn|5.013007||cVi +refcounted_he_fetch_pvs|5.013007||Vi +refcounted_he_fetch_sv|5.013007||cVi +refcounted_he_free|5.013007||cVi +refcounted_he_inc|5.013007||cVi +REFCOUNTED_HE_KEY_UTF8|5.013007||Viu +refcounted_he_new_pv|5.013007||cVi +refcounted_he_new_pvn|5.013007||cVi +refcounted_he_new_pvs|5.013007||Vi +refcounted_he_new_sv|5.013007||cVi +refcounted_he_value|5.009004||Viu +REFF|5.004001||Viu +REFFA|5.013010||Viu +REFFAN|5.031001||Viu +REFFAN_t8|5.035004||Viu +REFFAN_t8_p8|5.033003||Viu +REFFAN_t8_pb|5.033003||Viu +REFFAN_tb|5.035004||Viu +REFFAN_tb_p8|5.033003||Viu +REFFAN_tb_pb|5.033003||Viu +REFFA_t8|5.035004||Viu +REFFA_t8_p8|5.033003||Viu +REFFA_t8_pb|5.033003||Viu +REFFA_tb|5.035004||Viu +REFFA_tb_p8|5.033003||Viu +REFFA_tb_pb|5.033003||Viu +REFFL|5.004001||Viu +REFFLN|5.031001||Viu +REFFLN_t8|5.035004||Viu +REFFLN_t8_p8|5.033003||Viu +REFFLN_t8_pb|5.033003||Viu +REFFLN_tb|5.035004||Viu +REFFLN_tb_p8|5.033003||Viu +REFFLN_tb_pb|5.033003||Viu +REFFL_t8|5.035004||Viu +REFFL_t8_p8|5.033003||Viu +REFFL_t8_pb|5.033003||Viu +REFFL_tb|5.035004||Viu +REFFL_tb_p8|5.033003||Viu +REFFL_tb_pb|5.033003||Viu +REFFN|5.031001||Viu +REFFN_t8|5.035004||Viu +REFFN_t8_p8|5.033003||Viu +REFFN_t8_pb|5.033003||Viu +REFFN_tb|5.035004||Viu +REFFN_tb_p8|5.033003||Viu +REFFN_tb_pb|5.033003||Viu +REFF_t8|5.035004||Viu +REFF_t8_p8|5.033003||Viu +REFF_t8_pb|5.033003||Viu +REFF_tb|5.035004||Viu +REFF_tb_p8|5.033003||Viu +REFF_tb_pb|5.033003||Viu +REFFU|5.013008||Viu +REFFUN|5.031001||Viu +REFFUN_t8|5.035004||Viu +REFFUN_t8_p8|5.033003||Viu +REFFUN_t8_pb|5.033003||Viu +REFFUN_tb|5.035004||Viu +REFFUN_tb_p8|5.033003||Viu +REFFUN_tb_pb|5.033003||Viu +REFFU_t8|5.035004||Viu +REFFU_t8_p8|5.033003||Viu +REFFU_t8_pb|5.033003||Viu +REFFU_tb|5.035004||Viu +REFFU_tb_p8|5.033003||Viu +REFFU_tb_pb|5.033003||Viu +REF_HE_KEY|5.009005||Viu +refkids|5.003007||Viu +REFN|5.031001||Viu +REFN_t8|5.035004||Viu +REFN_t8_p8|5.033003||Viu +REFN_t8_pb|5.033003||Viu +REFN_tb|5.035004||Viu +REFN_tb_p8|5.033003||Viu +REFN_tb_pb|5.033003||Viu +REF_t8|5.035004||Viu +REF_t8_p8|5.033003||Viu +REF_t8_pb|5.033003||Viu +REF_tb|5.035004||Viu +REF_tb_p8|5.033003||Viu +REF_tb_pb|5.033003||Viu +refto|5.005000||Viu +reg2Lanode|5.021005||Viu +reg|5.005000||Viu +reganode|5.005000||Viu +REG_ANY|5.006000||Viu +REG_ANY_t8|5.035004||Viu +REG_ANY_t8_p8|5.033003||Viu +REG_ANY_t8_pb|5.033003||Viu +REG_ANY_tb|5.035004||Viu +REG_ANY_tb_p8|5.033003||Viu +REG_ANY_tb_pb|5.033003||Viu +regatom|5.005000||Viu +regbranch|5.005000||Viu +reg_check_named_buff_matched|5.009005||Vniu +regclass|5.005000||Viu +regcppop|5.005000||Viu +regcppush|5.005000||Viu +regcp_restore|5.025006||Viu +regcurly|5.013010||cVniu +REG_CUTGROUP_SEEN|5.019009||Viu +regdump|5.005000|5.005000|u +regdump_extflags|5.009005||Viu +regdump_intflags|5.019002||Viu +regdupe_internal|5.009005||cVu +regexec_flags|5.005000||cVu +REGEX_SET|5.031010||Viu +regex_set_precedence|5.021010||Vniu +REGEX_SET_t8|5.035004||Viu +REGEX_SET_t8_p8|5.033003||Viu +REGEX_SET_t8_pb|5.033003||Viu +REGEX_SET_tb|5.035004||Viu +REGEX_SET_tb_p8|5.033003||Viu +REGEX_SET_tb_pb|5.033003||Viu +REG_EXTFLAGS_NAME_SIZE|5.020000||Viu +regfree_internal|5.009005||cVu +REG_GPOS_SEEN|5.019009||Viu +reghop3|5.007001||Vniu +reghop4|5.009005||Vniu +reghopmaybe3|5.007001||Vniu +reginclass|5.005000||Viu +REG_INFTY|5.004005||Viu +reginitcolors|5.006000||cVu +reginsert|5.005000||Viu +REG_INTFLAGS_NAME_SIZE|5.020000||Viu +register|5.003007||Viu +reg_la_NOTHING|||Viu +reg_la_OPFAIL|||Viu +REG_LB_SEEN|||Viu +REG_LOOKBEHIND_SEEN|5.019009||Viu +REG_MAGIC|5.006000||Viu +regmatch|5.005000||Viu +REGMATCH_STATE_MAX|5.009005||Viu +reg_named_buff|5.009005||cViu +reg_named_buff_all|5.009005||cVu +reg_named_buff_exists|5.009005||cVu +reg_named_buff_fetch|5.009005||cVu +reg_named_buff_firstkey|5.009005||cVu +reg_named_buff_iter|5.009005||cViu +reg_named_buff_nextkey|5.009005||cVu +reg_named_buff_scalar|5.009005||cVu +regnext|5.003007||cVu +reg_node|5.005000||Viu +regnode_guts|5.021005||Viu +regnode_guts_debug|||Viu +REGNODE_MAX|5.009004||Viu +REGNODE_SIMPLE|5.013002||Viu +REGNODE_VARIES|5.013002||Viu +reg_numbered_buff_fetch|5.009005||cViu +reg_numbered_buff_length|5.009005||cViu +reg_numbered_buff_store|5.009005||cViu +regpiece|5.005000||Viu +regpnode|5.031010||Viu +regprop|5.003007||Viu +reg_qr_package|5.009005||cViu +REG_RECURSE_SEEN|5.019009||Viu +regrepeat|5.005000||Viu +REG_RUN_ON_COMMENT_SEEN|5.019009||Viu +reg_scan_name|5.009005||Viu +reg_skipcomment|5.009005||Vniu +regtail|5.005000||Viu +regtail_study|5.009004||Viu +reg_temp_copy|5.009005||cViu +REG_TOP_LEVEL_BRANCHES_SEEN|5.019009||Viu +regtry|5.005000||Viu +REG_UNBOUNDED_QUANTIFIER_SEEN|5.019009||Viu +REG_UNFOLDED_MULTI_SEEN|5.019009||Viu +REG_VERBARG_SEEN|5.019009||Viu +REG_ZERO_LEN_SEEN|5.019009||Viu +re_indentf|5.023009||vViu +re_intuit_start|5.006000||cVu +re_intuit_string|5.006000||cVu +rename|5.005000||Viu +Renew|5.003007|5.003007| +Renewc|5.003007|5.003007| +RENUM|5.005000||Viu +RENUM_t8|5.035004||Viu +RENUM_t8_p8|5.033003||Viu +RENUM_t8_pb|5.033003||Viu +RENUM_tb|5.035004||Viu +RENUM_tb_p8|5.033003||Viu +RENUM_tb_pb|5.033003||Viu +re_op_compile|5.017001||Viu +repeatcpy|5.003007|5.003007|nu +REPLACEMENT_CHARACTER_UTF8|5.025005|5.003007|p +report_evil_fh|5.006001||Viu +report_redefined_cv|5.015006||Viu +report_uninit|5.006000||cVi +report_wrongway_fh|5.013009||Viu +re_printf|5.023009||vViu +RE_PV_COLOR_DECL|5.009004||Viu +RE_PV_QUOTED_DECL|5.009004||Viu +require_pv|5.006000|5.006000| +require_tie_mod|5.009005||Viu +ReREFCNT_dec|5.005000||Viu +ReREFCNT_inc|5.005000||Viu +RESTORE_ERRNO|5.010001||Vi +RESTORE_LC_NUMERIC|5.021010|5.021010|p +restore_magic|5.009003||Viu +restore_switched_locale|5.027009||Viu +RE_SV_DUMPLEN|5.009004||Viu +RE_SV_ESCAPE|5.009004||Viu +RE_SV_TAIL|5.009004||Viu +RETPUSHNO|5.003007||Viu +RETPUSHUNDEF|5.003007||Viu +RETPUSHYES|5.003007||Viu +RE_TRIE_MAXBUF_INIT|5.009002||Viu +RE_TRIE_MAXBUF_NAME|5.009002||Viu +RETSETNO|5.003007||Viu +RETSETTARG|5.021009||Viu +RETSETUNDEF|5.003007||Viu +RETSETYES|5.003007||Viu +RETURN|5.003007||Viu +RETURNOP|5.003007||Viu +RETURNX|5.003007||Viu +RETVAL|5.003007|5.003007|V +rewind|5.003007||Viu +rewinddir|5.005000||Viu +REXEC_CHECKED|5.005000||Viu +REXEC_COPY_SKIP_POST|5.017004||Viu +REXEC_COPY_SKIP_PRE|5.017004||Viu +REXEC_COPY_STR|5.005000||Viu +REXEC_FAIL_ON_UNDERFLOW|5.019003||Viu +REXEC_IGNOREPOS|5.006000||Viu +REXEC_NOT_FIRST|5.006000||Viu +REXEC_SCREAM|5.006000||Viu +rmdir|5.005000||Viu +RMS_DIR|5.008001||Viu +RMS_FAC|5.008001||Viu +RMS_FEX|5.008001||Viu +RMS_FNF|5.008001||Viu +RMS_IFI|5.008001||Viu +RMS_ISI|5.008001||Viu +RMS_PRV|5.008001||Viu +rninstr|5.003007|5.003007|n +ROTL32|5.017010||Viu +ROTL64|5.017010||Viu +ROTL_UV|5.017010||Viu +ROTR32|5.027001||Viu +ROTR64|5.027001||Viu +ROTR_UV|5.027001||Viu +rpeep|5.013005||Viu +rsignal|5.004000|5.004000| +rsignal_restore|5.004000||Viu +rsignal_save|5.004000||Viu +rsignal_state|5.004000|5.004000|u +RsPARA|5.003007||Viu +RsRECORD|5.005000||Viu +RsSIMPLE|5.003007||Viu +RsSNARF|5.003007||Viu +run_body|5.006000||Viu +runops_debug|5.005000||cVu +RUNOPS_DEFAULT|5.005000||Viu +runops_standard|5.005000||cVu +run_user_filter|5.009003||Viu +rv2cv_op_cv|5.013006|5.013006| +RV2CVOPCV_FLAG_MASK|5.021004||Viu +RV2CVOPCV_MARK_EARLY|5.013006|5.013006| +RV2CVOPCV_MAYBE_NAME_GV|5.021004||Viu +RV2CVOPCV_RETURN_NAME_GV|5.013006|5.013006| +RV2CVOPCV_RETURN_STUB|5.021004||Viu +rvpv_dup|5.008008|5.008008|u +RX_ANCHORED_SUBSTR|5.010001||Viu +RX_ANCHORED_UTF8|5.010001||Viu +RXapif_ALL|5.009005||Viu +RXapif_CLEAR|5.009005||Viu +RXapif_DELETE|5.009005||Viu +RXapif_EXISTS|5.009005||Viu +RXapif_FETCH|5.009005||Viu +RXapif_FIRSTKEY|5.009005||Viu +RXapif_NEXTKEY|5.009005||Viu +RXapif_ONE|5.009005||Viu +RXapif_REGNAME|5.009005||Viu +RXapif_REGNAMES|5.009005||Viu +RXapif_REGNAMES_COUNT|5.009005||Viu +RXapif_SCALAR|5.009005||Viu +RXapif_STORE|5.009005||Viu +RX_BUFF_IDX_CARET_FULLMATCH|5.017004||Viu +RX_BUFF_IDX_CARET_POSTMATCH|5.017004||Viu +RX_BUFF_IDX_CARET_PREMATCH|5.017004||Viu +RX_BUFF_IDX_FULLMATCH|5.009005||Viu +RX_BUFF_IDX_POSTMATCH|5.009005||Viu +RX_BUFF_IDX_PREMATCH|5.009005||Viu +RX_CHECK_SUBSTR|5.010001||Viu +RX_COMPFLAGS|5.017011||Viu +RX_ENGINE|5.010001||Viu +RX_EXTFLAGS|5.010001||Viu +RXf_BASE_SHIFT|5.013004||Viu +RXf_CHECK_ALL|5.009005||Viu +RXf_COPY_DONE|5.009005||Viu +RXf_EVAL_SEEN|5.009005||Viu +RXf_INTUIT_TAIL|5.009005||Viu +RXf_IS_ANCHORED|5.019009||Viu +RX_FLOAT_SUBSTR|5.010001||Viu +RX_FLOAT_UTF8|5.010001||Viu +RXf_MATCH_UTF8|5.009005||Viu +RXf_NO_INPLACE_SUBST|5.017011||Viu +RXf_NULL|5.010000||Viu +RXf_PMf_CHARSET|5.013009||Viu +RXf_PMf_COMPILETIME|5.009005||Viu +RXf_PMf_EXTENDED|5.009005||Viu +RXf_PMf_EXTENDED_MORE|5.021005||Viu +RXf_PMf_FLAGCOPYMASK|5.017011||Viu +RXf_PMf_FOLD|5.009005||Viu +RXf_PMf_KEEPCOPY|5.009005||Viu +RXf_PMf_MULTILINE|5.009005||Viu +RXf_PMf_NOCAPTURE|5.021008||Viu +RXf_PMf_SINGLELINE|5.009005||Viu +RXf_PMf_SPLIT|5.017011||Viu +RXf_PMf_STD_PMMOD|5.009005||Viu +RXf_PMf_STD_PMMOD_SHIFT|5.010001||Viu +RXf_PMf_STRICT|5.021008||Viu +RXf_SKIPWHITE|5.009005||Viu +RXf_SPLIT|5.009005||Viu +RXf_START_ONLY|5.009005||Viu +RXf_TAINTED|5.009005||Viu +RXf_TAINTED_SEEN|5.009005||Viu +RXf_UNBOUNDED_QUANTIFIER_SEEN|5.019009||Viu +RXf_USE_INTUIT|5.009005||Viu +RXf_USE_INTUIT_ML|5.009005||Viu +RXf_USE_INTUIT_NOML|5.009005||Viu +RXf_WHITE|5.009005||Viu +RX_GOFS|5.010001||Viu +RXi_GET|5.009005||Viu +RXi_GET_DECL|5.009005||Viu +RX_INTFLAGS|5.019009||Viu +RXi_SET|5.009005||Viu +RX_ISTAINTED|5.017006||Viu +RX_LASTCLOSEPAREN|5.010001||Viu +RX_LASTPAREN|5.010001||Viu +RX_MATCH_COPIED|5.006000||Viu +RX_MATCH_COPIED_off|5.006000||Viu +RX_MATCH_COPIED_on|5.006000||Viu +RX_MATCH_COPIED_set|5.006000||Viu +RX_MATCH_COPY_FREE|5.009000||Viu +RX_MATCH_TAINTED|5.005000||Viu +RX_MATCH_TAINTED_off|5.005000||Viu +RX_MATCH_TAINTED_on|5.005000||Viu +RX_MATCH_TAINTED_set|5.005000||Viu +RX_MATCH_UTF8|5.008001||Viu +RX_MATCH_UTF8_off|5.008001||Viu +RX_MATCH_UTF8_on|5.008001||Viu +RX_MATCH_UTF8_set|5.008001||Viu +RX_MINLEN|5.010001||Viu +RX_MINLENRET|5.010001||Viu +RX_NPARENS|5.010001||Viu +RX_OFFS|5.010001||Viu +RXp_COMPFLAGS|5.017011||Viu +RXp_ENGINE|5.027003||Viu +RXp_EXTFLAGS|5.010001||Viu +RXp_GOFS|5.027003||Viu +RXp_HAS_CUTGROUP|5.027003||Viu +RXp_INTFLAGS|5.019009||Viu +RXp_ISTAINTED|5.027003||Viu +RXp_MATCH_COPIED|5.010001||Viu +RXp_MATCH_COPIED_off|5.010001||Viu +RXp_MATCH_COPIED_on|5.010001||Viu +RXp_MATCH_COPY_FREE|5.027003||Viu +RXp_MATCH_TAINTED|5.010001||Viu +RXp_MATCH_TAINTED_off|5.027003||Viu +RXp_MATCH_TAINTED_on|5.017008||Viu +RXp_MATCH_UTF8|5.010001||Viu +RXp_MATCH_UTF8_off|5.027003||Viu +RXp_MATCH_UTF8_on|5.027003||Viu +RXp_MATCH_UTF8_set|5.027003||Viu +RXp_MINLEN|5.027003||Viu +RXp_MINLENRET|5.027003||Viu +RXp_NPARENS|5.027003||Viu +RXp_OFFS|5.027003||Viu +RXp_PAREN_NAMES|5.010001||Viu +RX_PRECOMP|5.010001||Viu +RX_PRECOMP_const|5.010001||Viu +RX_PRELEN|5.010001||Viu +RXp_SAVED_COPY|5.027003||Viu +RXp_SUBBEG|5.027003||Viu +RXp_SUBOFFSET|5.027003||Viu +RXp_ZERO_LEN|5.027003||Viu +RX_REFCNT|5.010001||Viu +rxres_free|5.004000||Viu +rxres_restore|5.004000||Viu +rxres_save|5.004000||Viu +RX_SAVED_COPY|5.011000||Viu +RX_SUBBEG|5.010001||Viu +RX_SUBCOFFSET|5.017004||Viu +RX_SUBLEN|5.010001||Viu +RX_SUBOFFSET|5.017004||Viu +RX_TAINT_on|5.017006||Viu +RX_UTF8|5.010001||Viu +RX_WRAPLEN|5.010001||Viu +RX_WRAPPED|5.010001||Viu +RX_WRAPPED_const|5.011000||Viu +RX_ZERO_LEN|5.019003||Viu +safecalloc|5.003007||Viu +Safefree|5.003007|5.003007| +safefree|5.003007||Viu +safemalloc|5.003007||Viu +saferealloc|5.003007||Viu +safesyscalloc|5.006000|5.006000|n +safesysfree|5.006000|5.006000|n +safesysmalloc|5.006000|5.006000|n +safesysrealloc|5.006000|5.006000|n +SAFE_TRIE_NODENUM|5.009002||Viu +same_dirent|5.003007||Viu +SANE_ERRSV|5.031003|5.031003| +SANY|5.003007||Viu +SANY_t8|5.035004||Viu +SANY_t8_p8|5.033003||Viu +SANY_t8_pb|5.033003||Viu +SANY_tb|5.035004||Viu +SANY_tb_p8|5.033003||Viu +SANY_tb_pb|5.033003||Viu +save_adelete|5.011000|5.011000|u +SAVEADELETE|5.011000||Viu +save_aelem|5.004005|5.004005|u +save_aelem_flags|5.011000|5.011000|u +save_alloc|5.006000|5.006000|u +save_aptr|5.003007|5.003007| +save_ary|5.003007|5.003007| +SAVEBOOL|5.008001|5.008001| +save_bool|5.008001||cVu +save_clearsv|5.003007||cVu +SAVECLEARSV|5.003007||Vi +SAVECOMPILEWARNINGS|5.009004||Viu +SAVECOMPPAD|5.006000||Vi +SAVECOPFILE|5.006000||Viu +SAVECOPFILE_FREE|5.006001||Viu +SAVECOPLINE|5.006000||Viu +SAVECOPSTASH_FREE|5.006001||Viu +SAVE_DEFSV|5.004005|5.003007|p +SAVEDELETE|5.003007|5.003007| +save_delete|5.003007||cVu +save_destructor|5.003007||cVu +SAVEDESTRUCTOR|5.006000|5.006000| +SAVEDESTRUCTOR_X|5.006000|5.006000| +save_destructor_x|5.006000||cVu +SAVE_ERRNO|5.010001||Vi +SAVEFEATUREBITS|5.031006||Viu +SAVEf_KEEPOLDELEM|5.011000||Viu +SAVEFREECOPHH|5.013007||Viu +SAVEFREEOP|5.010001|5.010001| +save_freeop|5.010001||cVu +SAVEFREEPADNAME|5.021007||Viu +SAVEFREEPV|5.003007|5.003007| +save_freepv|5.010001||cVu +SAVEFREESV|5.003007|5.003007| +save_freesv|5.010001||cVu +SAVEf_SETMAGIC|5.011000||Viu +SAVEGENERICPV|5.006001||Viu +save_generic_pvref|5.006001|5.006001|u +SAVEGENERICSV|5.005003||Viu +save_generic_svref|5.005003|5.005003|u +save_gp|5.004000|5.004000| +save_hash|5.003007|5.003007| +save_hdelete|5.011000|5.011000|u +SAVEHDELETE|5.011000||Viu +save_hek_flags|5.008000||Vniu +save_helem|5.004005|5.004005|u +save_helem_flags|5.011000|5.011000|u +SAVEHINTS|5.005000||Viu +save_hints|5.013005|5.013005|u +save_hptr|5.003007|5.003007| +SAVEI16|5.004000|5.004000| +save_I16|5.004000||cVu +SAVEI32|5.003007|5.003007| +save_I32|5.003007||cVu +SAVEI8|5.006000|5.006000| +save_I8|5.006000||cVu +SAVEINT|5.003007|5.003007| +save_int|5.003007||cVu +save_item|5.003007|5.003007| +SAVEIV|5.003007|5.003007| +save_iv|5.004000||cVu +save_lines|5.005000||Viu +save_list|5.003007|5.003007|d +SAVELONG|5.003007|5.003007| +save_long|5.003007||dcVu +save_magic_flags|5.019002||Viu +SAVE_MASK|5.013001||Viu +SAVEMORTALIZESV|5.007001|5.007001| +save_mortalizesv|5.010001||cVu +save_nogv|5.003007|5.003007|du +SAVEOP|5.005000||Viu +save_op|5.010001|5.010001|u +save_padsv_and_mortalize|5.010001|5.010001|u +SAVEPADSVANDMORTALIZE|5.010001||Viu +SAVEPADSV|||i +SAVEPARSER|5.009005||Viu +SAVEPPTR|5.003007|5.003007| +save_pptr|5.003007||cVu +save_pushi32ptr|5.013006|5.013006|u +save_pushptr|5.010001|5.010001|u +save_pushptri32ptr|5.010001||Viu +save_pushptrptr|5.013006|5.013006|u +savepv|5.003007|5.003007| +savepvn|5.003007|5.003007| +savepvs|5.009003|5.009003| +save_re_context|5.006000||cVu +save_scalar|5.003007|5.003007| +save_scalar_at|5.005000||Viu +save_set_svflags|5.009000|5.009000|u +SAVESETSVFLAGS|5.009000||Viu +savesharedpv|5.007003|5.007003| +SAVESHAREDPV|5.007003||Viu +savesharedpvn|5.009005|5.009005| +save_shared_pvref|5.007003|5.007003|u +savesharedpvs|5.013006|5.013006| +savesharedsvpv|5.013006|5.013006| +SAVESPTR|5.003007|5.003007| +save_sptr|5.003007||cVu +savestack_grow|5.003007|5.003007|u +savestack_grow_cnt|5.008001|5.008001|u +SAVESTACK_POS|5.004000|5.004000| +save_strlen|5.019004||cViu +SAVESTRLEN|5.035005|5.035005| +savesvpv|5.009002|5.009002| +save_svref|5.003007|5.003007| +SAVESWITCHSTACK|5.009002||Viu +SAVEt_ADELETE|5.011000||Viu +SAVEt_AELEM|5.004005||Viu +SAVEt_ALLOC|5.006000||Viu +SAVEt_APTR|5.003007||Viu +SAVEt_AV|5.003007||Viu +SAVEt_BOOL|5.008001||Viu +SAVEt_CLEARPADRANGE|5.017006||Viu +SAVEt_CLEARSV|5.003007||Viu +SAVEt_COMPILE_WARNINGS|5.009004||Viu +SAVEt_COMPPAD|5.006000||Viu +SAVEt_DELETE|5.003007||Viu +SAVEt_DESTRUCTOR|5.003007||Viu +SAVEt_DESTRUCTOR_X|5.006000||Viu +SAVEt_FREECOPHH|5.013007||Viu +SAVEt_FREEOP|5.003007||Viu +SAVEt_FREEPADNAME|5.021007||Viu +SAVEt_FREEPV|5.003007||Viu +SAVEt_FREESV|5.003007||Viu +SAVEt_GENERIC_PVREF|5.006001||Viu +SAVEt_GENERIC_SVREF|5.005003||Viu +SAVEt_GP|5.003007||Viu +SAVEt_GVSLOT|5.017007||Viu +SAVEt_GVSV|5.013005||Viu +SAVEt_HELEM|5.004005||Viu +SAVEt_HINTS|5.005000||Viu +SAVEt_HINTS_HH|5.033001||Viu +SAVEt_HPTR|5.003007||Viu +SAVEt_HV|5.003007||Viu +SAVEt_I16|5.004000||Viu +SAVEt_I32|5.003007||Viu +SAVEt_I32_SMALL|5.013001||Viu +SAVEt_I8|5.006000||Viu +SAVE_TIGHT_SHIFT|5.013001||Viu +SAVEt_INT|5.003007||Viu +SAVEt_INT_SMALL|5.013001||Viu +SAVEt_ITEM|5.003007||Viu +SAVEt_IV|5.003007||Viu +SAVEt_LONG|5.003007||Viu +SAVEt_MORTALIZESV|5.007001||Viu +SAVETMPS|5.003007|5.003007| +savetmps|||xu +SAVEt_NSTAB|5.003007||Viu +save_to_buffer|5.027004||Vniu +SAVEt_OP|5.005000||Viu +SAVEt_PADSV_AND_MORTALIZE|5.010001||Viu +SAVEt_PARSER|5.009005||Viu +SAVEt_PPTR|5.003007||Viu +SAVEt_READONLY_OFF|5.019002||Viu +SAVEt_REGCONTEXT|5.003007||Viu +SAVEt_SAVESWITCHSTACK|5.009002||Viu +SAVEt_SET_SVFLAGS|5.009000||Viu +SAVEt_SHARED_PVREF|5.007003||Viu +SAVEt_SPTR|5.003007||Viu +SAVEt_STACK_POS|5.004000||Viu +SAVEt_STRLEN|5.019004||Viu +SAVEt_STRLEN_SMALL|5.033005||Viu +SAVEt_SV|5.003007||Viu +SAVEt_SVREF|5.003007||Viu +SAVEt_TMPSFLOOR|5.023008||Viu +SAVEt_VPTR|5.006000||Viu +save_vptr|5.006000|5.006000|u +SAVEVPTR|5.006000||Viu +SAWAMPERSAND_LEFT|5.017004||Viu +SAWAMPERSAND_MIDDLE|5.017004||Viu +SAWAMPERSAND_RIGHT|5.017004||Viu +sawparens|5.003007||Viu +sb_dstr|5.003007||Viu +sb_iters|5.003007||Viu +sb_m|5.003007||Viu +sb_maxiters|5.003007||Viu +SBOL|5.003007||Viu +SBOL_t8|5.035004||Viu +SBOL_t8_p8|5.033003||Viu +SBOL_t8_pb|5.033003||Viu +SBOL_tb|5.035004||Viu +SBOL_tb_p8|5.033003||Viu +SBOL_tb_pb|5.033003||Viu +sb_orig|5.003007||Viu +SBOX32_CHURN_ROUNDS|5.027001||Viu +SBOX32_MAX_LEN|5.027001||Viu +SBOX32_MIX3|5.027001||Viu +SBOX32_MIX4|5.027001||Viu +SBOX32_SCRAMBLE32|5.027001||Viu +SBOX32_SKIP_MASK|5.027001||Viu +SBOX32_STATE_BITS|5.027001||Viu +SBOX32_STATE_BYTES|5.027001||Viu +SBOX32_STATE_WORDS|5.027001||Viu +SBOX32_STATIC_INLINE|5.027001||Viu +SBOX32_WARN2|5.027001||Viu +SBOX32_WARN3|5.027001||Viu +SBOX32_WARN4|5.027001||Viu +SBOX32_WARN5|5.027001||Viu +SBOX32_WARN6|5.027001||Viu +sb_rflags|5.006000||Viu +sb_rx|5.003007||Viu +sb_rxres|5.004000||Viu +sb_rxtainted|5.004000||Viu +sb_s|5.003007||Viu +sb_strend|5.003007||Viu +sb_targ|5.003007||Viu +scalar|5.003007||Viu +scalarboolean|5.005000||Viu +scalarkids|5.003007||Viu +scalar_mod_type|5.006000||Vniu +scalarvoid|5.003007||Viu +scan_bin|5.006000|5.006000| +scan_commit|5.005000||Viu +scan_const|5.003007||Viu +SCAN_DEF|5.003007||Viu +scan_formline|5.003007||Viu +scan_heredoc|5.003007||Viu +scan_hex|5.006000|5.003007| +scan_ident|5.003007||Viu +scan_inputsymbol|5.003007||Viu +scan_num|5.003007||cVu +scan_oct|5.006000|5.003007| +scan_pat|5.003007||Viu +SCAN_REPL|5.003007||Viu +scan_str|5.003007||xcViu +scan_subst|5.003007||Viu +SCAN_TR|5.003007||Viu +scan_trans|5.003007||Viu +scan_version|5.009001|5.009001| +SCAN_VERSION|5.019008||Viu +scan_vstring|5.009005|5.009005|u +scan_word|5.003007||xcViu +SCHED_YIELD|5.006000|5.006000|Vn +SCOPE_SAVES_SIGNAL_MASK|5.007001||Viu +search_const|5.010001||Viu +seed|5.009003|5.009003|u +seedDrand01|5.006000|5.006000| +SEEK_CUR|5.003007||Viu +seekdir|5.005000||Viu +SEEK_END|5.003007||Viu +SEEK_SET|5.003007||Viu +select|5.005000||Viu +Select_fd_set_t|5.003007|5.003007|Vn +SELECT_MIN_BITS|5.005003|5.005003|Vn +Semctl|5.004005||Viu +semun|5.006000||Viu +send|5.005000||Viu +sendto|5.005000||Viu +SEOL|5.003007||Viu +SEOL_t8|5.035004||Viu +SEOL_t8_p8|5.033003||Viu +SEOL_t8_pb|5.033003||Viu +SEOL_tb|5.035004||Viu +SEOL_tb_p8|5.033003||Viu +SEOL_tb_pb|5.033003||Viu +sequence_num|5.009003||Viu +set_ANYOF_arg|5.019005||Viu +set_ANYOF_SYNTHETIC|5.019009||Viu +setbuf|5.003007||Viu +set_caret_X|5.019006||Viu +set_context|5.006000|5.006000|nu +setdefout|5.011000|5.011000| +SETERRNO|5.003007||Vi +setfd_cloexec|5.027008||Vniu +setfd_cloexec_for_nonsysfd|5.027008||Viu +setfd_cloexec_or_inhexec_by_sysfdness|5.027008||Viu +setfd_inhexec|5.027008||Vniu +setfd_inhexec_for_sysfd|5.027008||Viu +setgid|5.005000||Viu +setgrent|5.009000||Viu +SETGRENT_R_HAS_FPTR|5.008000||Viu +SETGRENT_R_PROTO|5.008000|5.008000|Vn +sethostent|5.005000||Viu +SETHOSTENT_R_PROTO|5.008000|5.008000|Vn +SETi|5.003007||Viu +setjmp|5.005000||Viu +setlinebuf|5.005000||Viu +setlocale|5.009000||Viu +setlocale_debug_string|5.027002||Vniu +SETLOCALE_LOCK|5.033005||Viu +SETLOCALE_R_PROTO|5.008000|5.008000|Vn +SETLOCALE_UNLOCK|5.033005||Viu +SET_MARK_OFFSET|5.006000||Viu +setmode|5.005000||Viu +SETn|5.003007||Viu +setnetent|5.005000||Viu +SETNETENT_R_PROTO|5.008000|5.008000|Vn +set_numeric_radix|5.006000||Viu +SET_NUMERIC_STANDARD|5.004000||Viu +set_numeric_standard|5.006000||cViu +SET_NUMERIC_UNDERLYING|5.021010||Viu +set_numeric_underlying|5.027006||cViu +SETp|5.003007||Viu +set_padlist|5.021006||cVniu +setprotoent|5.005000||Viu +SETPROTOENT_R_PROTO|5.008000|5.008000|Vn +setpwent|5.009000||Viu +SETPWENT_R_HAS_FPTR|5.008000||Viu +SETPWENT_R_PROTO|5.008000|5.008000|Vn +set_regex_pv|5.029004||Viu +setregid|5.003007||Viu +setreuid|5.003007||Viu +SETs|5.003007||Viu +setservent|5.005000||Viu +SETSERVENT_R_PROTO|5.008000|5.008000|Vn +setsockopt|5.005000||Viu +setSTR_LEN|5.031005||Viu +SET_SVANY_FOR_BODYLESS_IV|5.023008||Viu +SET_SVANY_FOR_BODYLESS_NV|5.023008||Viu +SETTARG|5.003007||Viu +SET_THR|5.005000||Viu +SET_THREAD_SELF|5.005003||Viu +SETu|5.004000||Viu +setuid|5.005000||Viu +_setup_canned_invlist|5.019008||cViu +setvbuf|5.003007||Viu +share_hek|5.009003|5.009003|u +share_hek_flags|5.008000||Viu +share_hek_hek|5.009003||Viu +sharepvn|5.005000||Viu +SHARP_S_SKIP|5.007003||Viu +Shmat_t|5.003007|5.003007|Vn +SHORTSIZE|5.004000|5.004000|Vn +should_warn_nl|5.021001||Vniu +should_we_output_Debug_r|5.031011||Viu +SH_PATH|5.003007|5.003007|Vn +shutdown|5.005000||Viu +si_dup|5.007003|5.007003|u +S_IEXEC|5.006000||Viu +S_IFIFO|5.011000||Viu +S_IFMT|5.003007||Viu +SIGABRT|5.003007||Viu +sighandler1|5.031007||Vniu +sighandler3|5.031007||Vniu +sighandler|5.003007||Vniu +SIGILL|5.003007||Viu +Sigjmp_buf|5.003007|5.003007|Vn +Siglongjmp|5.003007|5.003007| +signal|5.005000||Viu +Signal_t|5.003007|5.003007|Vn +SIG_NAME|5.003007|5.003007|Vn +SIG_NUM|5.003007|5.003007|Vn +Sigsetjmp|5.003007|5.003007| +SIG_SIZE|5.007001|5.007001|Vn +simplify_sort|5.006000||Viu +single_1bit_pos32|5.035003||cVnu +single_1bit_pos64|5.035003||cVnu +SINGLE_PAT_MOD|5.009005||Viu +SIPHASH_SEED_STATE|5.027001||Viu +SIPROUND|5.017006||Viu +S_IREAD|5.006000||Viu +S_IRGRP|5.003007||Viu +S_IROTH|5.003007||Viu +S_IRUSR|5.003007||Viu +S_IRWXG|5.006000||Viu +S_IRWXO|5.006000||Viu +S_IRWXU|5.006000||Viu +S_ISBLK|5.003007||Viu +S_ISCHR|5.003007||Viu +S_ISDIR|5.003007||Viu +S_ISFIFO|5.003007||Viu +S_ISGID|5.003007||Viu +S_ISLNK|5.003007||Viu +S_ISREG|5.003007||Viu +S_ISSOCK|5.003007||Viu +S_ISUID|5.003007||Viu +SITEARCH|5.003007|5.003007|Vn +SITEARCH_EXP|5.003007|5.003007|Vn +SITELIB|5.003007|5.003007|Vn +SITELIB_EXP|5.003007|5.003007|Vn +SITELIB_STEM|5.006000|5.006000|Vn +S_IWGRP|5.003007||Viu +S_IWOTH|5.003007||Viu +S_IWRITE|5.006000||Viu +S_IWUSR|5.003007||Viu +S_IXGRP|5.003007||Viu +S_IXOTH|5.003007||Viu +S_IXUSR|5.003007||Viu +SIZE_ALIGN|5.005000||Viu +Size_t|5.003007|5.003007|Vn +Size_t_MAX|5.021003||Viu +Size_t_size|5.006000|5.006000|Vn +SKIP|5.009005||Viu +SKIP_next|5.009005||Viu +SKIP_next_fail|5.009005||Viu +SKIP_next_fail_t8|5.035004||Viu +SKIP_next_fail_t8_p8|5.033003||Viu +SKIP_next_fail_t8_pb|5.033003||Viu +SKIP_next_fail_tb|5.035004||Viu +SKIP_next_fail_tb_p8|5.033003||Viu +SKIP_next_fail_tb_pb|5.033003||Viu +SKIP_next_t8|5.035004||Viu +SKIP_next_t8_p8|5.033003||Viu +SKIP_next_t8_pb|5.033003||Viu +SKIP_next_tb|5.035004||Viu +SKIP_next_tb_p8|5.033003||Viu +SKIP_next_tb_pb|5.033003||Viu +skipspace_flags|5.019002||xcViu +SKIP_t8|5.035004||Viu +SKIP_t8_p8|5.033003||Viu +SKIP_t8_pb|5.033003||Viu +SKIP_tb|5.035004||Viu +SKIP_tb_p8|5.033003||Viu +SKIP_tb_pb|5.033003||Viu +skip_to_be_ignored_text|5.023004||Viu +Slab_Alloc|5.006000||cViu +Slab_Free|5.007003||cViu +Slab_to_ro|5.017002||Viu +Slab_to_rw|5.009005||Viu +sleep|5.005000||Viu +SLOPPYDIVIDE|5.003007||Viu +socket|5.005000||Viu +SOCKET_OPEN_MODE|5.008002||Viu +socketpair|5.005000||Viu +Sock_size_t|5.006000|5.006000|Vn +softref2xv|||iu +sortcv|5.009003||Viu +sortcv_stacked|5.009003||Viu +sortcv_xsub|5.009003||Viu +sortsv|5.007003|5.007003| +sortsv_flags|5.009003|5.009003| +sortsv_flags_impl|5.031011||Viu +SP|5.003007|5.003007| +space_join_names_mortal|5.009004||Viu +SPAGAIN|5.003007|5.003007| +S_PAT_MODS|5.009005||Viu +specialWARN|5.006000||Viu +SRAND48_R_PROTO|5.008000|5.008000|Vn +SRANDOM_R_PROTO|5.008000|5.008000|Vn +SRCLOSE|5.027008||Viu +SRCLOSE_t8|5.035004||Viu +SRCLOSE_t8_p8|5.033003||Viu +SRCLOSE_t8_pb|5.033003||Viu +SRCLOSE_tb|5.035004||Viu +SRCLOSE_tb_p8|5.033003||Viu +SRCLOSE_tb_pb|5.033003||Viu +SROPEN|5.027008||Viu +SROPEN_t8|5.035004||Viu +SROPEN_t8_p8|5.033003||Viu +SROPEN_t8_pb|5.033003||Viu +SROPEN_tb|5.035004||Viu +SROPEN_tb_p8|5.033003||Viu +SROPEN_tb_pb|5.033003||Viu +SS_ACCVIO|5.008001||Viu +SS_ADD_BOOL|5.017007||Viu +SS_ADD_DPTR|5.017007||Viu +SS_ADD_DXPTR|5.017007||Viu +SS_ADD_END|5.017007||Viu +SS_ADD_INT|5.017007||Viu +SS_ADD_IV|5.017007||Viu +SS_ADD_LONG|5.017007||Viu +SS_ADD_PTR|5.017007||Viu +SS_ADD_UV|5.017007||Viu +SS_BUFFEROVF|5.021009||Viu +ssc_add_range|5.019005||Viu +ssc_and|5.019005||Viu +ssc_anything|5.019005||Viu +ssc_clear_locale|5.019005||Vniu +ssc_cp_and|5.019005||Viu +ssc_finalize|5.019005||Viu +SSCHECK|5.003007||Viu +ssc_init|5.019005||Viu +ssc_intersection|5.019005||Viu +ssc_is_anything|5.019005||Vniu +ssc_is_cp_posixl_init|5.019005||Vniu +SSC_MATCHES_EMPTY_STRING|5.021004||Viu +ssc_or|5.019005||Viu +ssc_union|5.019005||Viu +SS_DEVOFFLINE|5.008001||Viu +ss_dup|5.007003|5.007003|u +SSGROW|5.008001||Viu +SS_IVCHAN|5.008001||Viu +SSize_t|5.003007|5.003007|Vn +SSize_t_MAX|5.019004||Viu +SS_MAXPUSH|5.017007||Viu +SSNEW|5.006000||Viu +SSNEWa|5.006000||Viu +SSNEWat|5.007001||Viu +SSNEWt|5.007001||Viu +SS_NOPRIV|5.021001||Viu +SS_NORMAL|5.008001||Viu +SSPOPBOOL|5.008001||Viu +SSPOPDPTR|5.003007||Viu +SSPOPDXPTR|5.006000||Viu +SSPOPINT|5.003007||Viu +SSPOPIV|5.003007||Viu +SSPOPLONG|5.003007||Viu +SSPOPPTR|5.003007||Viu +SSPOPUV|5.013001||Viu +SSPTR|5.006000||Viu +SSPTRt|5.007001||Viu +SSPUSHBOOL|5.008001||Viu +SSPUSHDPTR|5.003007||Viu +SSPUSHDXPTR|5.006000||Viu +SSPUSHINT|5.003007||Viu +SSPUSHIV|5.003007||Viu +SSPUSHLONG|5.003007||Viu +SSPUSHPTR|5.003007||Viu +SSPUSHUV|5.013001||Viu +ST|5.003007|5.003007| +stack_grow|5.003007||cVu +STANDARD_C|5.003007||Viu +STAR|5.003007||Viu +STAR_t8|5.035004||Viu +STAR_t8_p8|5.033003||Viu +STAR_t8_pb|5.033003||Viu +STAR_tb|5.035004||Viu +STAR_tb_p8|5.033003||Viu +STAR_tb_pb|5.033003||Viu +START_EXTERN_C|5.005000|5.003007|pV +start_glob|||xi +START_MY_CXT|5.010000|5.010000|p +STARTPERL|5.003007|5.003007|Vn +start_subparse|5.004000|5.003007|pu +StashHANDLER|5.007001||Viu +Stat|5.003007||Viu +stat|5.005000||Viu +STATIC|5.005000||Viu +STATIC_ASSERT_1|5.021007||Viu +STATIC_ASSERT_2|5.021007||Viu +STATIC_ASSERT_DECL|5.027001||Viu +STATIC_ASSERT_STMT|5.021007||Viu +Stat_t|5.004005||Viu +STATUS_ALL_FAILURE|5.004000||Viu +STATUS_ALL_SUCCESS|5.004000||Viu +STATUS_CURRENT|5.004000||Viu +STATUS_EXIT|5.009003||Viu +STATUS_EXIT_SET|5.009003||Viu +STATUS_NATIVE|5.004000||Viu +STATUS_NATIVE_CHILD_SET|5.009003||Viu +STATUS_UNIX|5.009003||Viu +STATUS_UNIX_EXIT_SET|5.009003||Viu +STATUS_UNIX_SET|5.009003||Viu +STDCHAR|5.003007|5.003007|Vn +stderr|5.003007||Viu +ST_DEV_SIGN|5.035004|5.035004|Vn +ST_DEV_SIZE|5.035004|5.035004|Vn +stdin|5.003007||Viu +STDIO_PTR_LVAL_SETS_CNT|5.007001|5.007001|Vn +STDIO_PTR_LVALUE|5.006000|5.006000|Vn +STDIO_STREAM_ARRAY|5.006000|5.006000|Vn +stdize_locale|5.007001||Viu +stdout|5.003007||Viu +stdoutf|5.005000||Viu +STD_PAT_MODS|5.009005||Viu +STD_PMMOD_FLAGS_CLEAR|5.013006||Viu +ST_INO_SIGN|5.015002|5.015002|Vn +ST_INO_SIZE|5.015002|5.015002|Vn +STMT_END|5.003007|5.003007|pV +STMT_START|5.003007|5.003007|pV +STOREFEATUREBITSHH|5.031006||Viu +STORE_LC_NUMERIC_FORCE_TO_UNDERLYING|5.021010|5.021010| +STORE_LC_NUMERIC_SET_STANDARD|5.027009||pVu +STORE_LC_NUMERIC_SET_TO_NEEDED|5.021010|5.021010| +STORE_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003| +STORE_NUMERIC_SET_STANDARD|||piu +strBEGINs|5.027006||Viu +strEQ|5.003007|5.003007| +Strerror|5.003007||Viu +strerror|5.009000||Viu +STRERROR_R_PROTO|5.008000|5.008000|Vn +strGE|5.003007|5.003007| +strGT|5.003007|5.003007| +STRING|5.006000||Viu +STRINGIFY|5.003007|5.003007|Vn +STRINGl|5.031005||Viu +STRINGs|5.031005||Viu +strip_return|5.009003||Viu +strLE|5.003007|5.003007| +STR_LEN|5.006000||Viu +STRLEN|5.027001||Viu +STR_LENl|5.031005||Viu +STR_LENs|5.031005||Viu +strLT|5.003007|5.003007| +strNE|5.003007|5.003007| +strnEQ|5.003007|5.003007| +strnNE|5.003007|5.003007| +STR_SZ|5.006000||Viu +Strtod|5.029010|5.029010|n +Strtol|5.006000|5.006000|n +strtoll|5.006000||Viu +Strtoul|5.006000|5.006000|n +strtoull|5.006000||Viu +str_to_version|5.006000||cVu +StructCopy|5.003007|5.003007|V +STRUCT_OFFSET|5.004000||Viu +STRUCT_SV|5.007001||Viu +STR_WITH_LEN|5.009003|5.003007|pV +study_chunk|5.005000||Viu +sub_crush_depth|5.004000||Viu +sublex_done|5.005000||Viu +sublex_push|5.005000||Viu +sublex_start|5.005000||Viu +SUBST_TAINT_BOOLRET|5.013010||Viu +SUBST_TAINT_PAT|5.013010||Viu +SUBST_TAINT_REPL|5.013010||Viu +SUBST_TAINT_RETAINT|5.013010||Viu +SUBST_TAINT_STR|5.013010||Viu +SUBVERSION|5.003007||Viu +SUCCEED|5.003007||Viu +SUCCEED_t8|5.035004||Viu +SUCCEED_t8_p8|5.033003||Viu +SUCCEED_t8_pb|5.033003||Viu +SUCCEED_tb|5.035004||Viu +SUCCEED_tb_p8|5.033003||Viu +SUCCEED_tb_pb|5.033003||Viu +SUSPEND|5.005000||Viu +SUSPEND_t8|5.035004||Viu +SUSPEND_t8_p8|5.033003||Viu +SUSPEND_t8_pb|5.033003||Viu +SUSPEND_tb|5.035004||Viu +SUSPEND_tb_p8|5.033003||Viu +SUSPEND_tb_pb|5.033003||Viu +sv_2bool|5.013006||cV +sv_2bool_flags|5.013006||cV +sv_2bool_nomg|5.017002||Viu +sv_2cv|5.003007|5.003007| +sv_2io|5.003007|5.003007| +sv_2iuv_common|5.009004||Viu +sv_2iuv_non_preserve|5.007001||Viu +sv_2iv|5.009001||cVu +sv_2iv_flags|5.009001|5.009001| +sv_2mortal|5.003007|5.003007| +sv_2num|5.010000||xVi +sv_2nv|5.013001||Viu +sv_2nv_flags|5.013001|5.013001| +sv_2pv|5.005000||cVu +sv_2pvbyte|5.006000|5.003007|p +sv_2pvbyte_flags|5.031004|5.031004|u +sv_2pvbyte_nolen|5.009003||pcV +sv_2pv_flags|5.007002||pcV +sv_2pv_nolen|5.009003||pcV +sv_2pv_nomg|5.007002||Viu +sv_2pvutf8|5.006000|5.006000| +sv_2pvutf8_flags|5.031004|5.031004|u +sv_2pvutf8_nolen|5.009003||cV +sv_2uv|5.009001||pcVu +sv_2uv_flags|5.009001|5.009001| +sv_add_arena|5.003007||Vi +sv_add_backref|||iu +SvAMAGIC|5.003007||Viu +SvAMAGIC_off|5.003007|5.003007|nu +SvAMAGIC_on|5.003007|5.003007|nu +SvANY|5.003007||Viu +SvARENA_CHAIN_SET|||Viu +SvARENA_CHAIN|||Viu +sv_backoff|5.003007|5.003007|n +sv_bless|5.003007|5.003007| +sv_buf_to_ro|5.019008||Viu +sv_buf_to_rw|5.019008||Viu +SvCANCOW|5.017007||Viu +SvCANEXISTDELETE|5.011000||Viu +SV_CATBYTES|5.021005|5.021005| +sv_cat_decode|5.008001|5.008001| +sv_cathek|5.021004||Viu +sv_catpv|5.003007|5.003007| +sv_catpvf|5.004000||vV +sv_catpv_flags|5.013006|5.013006| +sv_catpvf_mg|5.004005||pvV +sv_catpvf_mg_nocontext|5.006000||pvVn +sv_catpvf_nocontext|5.006000||vVn +sv_catpv_mg|5.004005|5.003007|p +sv_catpvn|5.003007|5.003007| +sv_catpvn_flags|5.007002|5.007002| +sv_catpvn_mg|5.004005|5.003007|p +sv_catpvn_nomg|5.007002|5.003007|p +sv_catpvn_nomg_maybeutf8|5.017005||Viu +sv_catpvn_nomg_utf8_upgrade|5.017002||Viu +sv_catpv_nomg|5.013006|5.013006| +sv_catpvs|5.009003|5.003007|p +sv_catpvs_flags|5.013006|5.013006| +sv_catpvs_mg|5.013006|5.013006| +sv_catpvs_nomg|5.013006|5.013006| +sv_catsv|5.003007|5.003007| +sv_catsv_flags|5.007002|5.007002| +sv_catsv_mg|5.004005|5.003007|p +sv_catsv_nomg|5.007002|5.003007|p +SV_CATUTF8|5.021005|5.021005| +sv_catxmlpvs|5.013006||Viu +SV_CHECK_THINKFIRST|5.008001||Viu +SV_CHECK_THINKFIRST_COW_DROP|5.009000||Viu +sv_chop|5.003007|5.003007| +sv_clean_all|5.003007||Vi +sv_clean_objs|5.003007||Vi +sv_clear|5.003007|5.003007| +sv_cmp|5.003007|5.003007| +sv_cmp_flags|5.013006|5.013006| +sv_cmp_locale|5.004000|5.004000| +sv_cmp_locale_flags|5.013006|5.013006| +sv_collxfrm|5.013006||V +sv_collxfrm_flags|5.013006|5.013006| +SvCOMPILED|5.003007||Viu +SvCOMPILED_off|5.003007||Viu +SvCOMPILED_on|5.003007||Viu +SV_CONST|5.019002||Viu +SV_CONST_BINMODE|5.019002||Viu +SV_CONST_CLEAR|5.019002||Viu +SV_CONST_CLOSE|5.019002||Viu +SV_CONST_DELETE|5.019002||Viu +SV_CONST_DESTROY|5.019002||Viu +SV_CONST_EOF|5.019002||Viu +SV_CONST_EXISTS|5.019002||Viu +SV_CONST_EXTEND|5.019002||Viu +SV_CONST_FETCH|5.019002||Viu +SV_CONST_FETCHSIZE|5.019002||Viu +SV_CONST_FILENO|5.019002||Viu +SV_CONST_FIRSTKEY|5.019002||Viu +SV_CONST_GETC|5.019002||Viu +SV_CONST_NEXTKEY|5.019002||Viu +SV_CONST_OPEN|5.019002||Viu +SV_CONST_POP|5.019002||Viu +SV_CONST_PRINT|5.019002||Viu +SV_CONST_PRINTF|5.019002||Viu +SV_CONST_PUSH|5.019002||Viu +SV_CONST_READ|5.019002||Viu +SV_CONST_READLINE|5.019002||Viu +SV_CONST_RETURN|5.009003|5.003007|poVnu +SV_CONST_SCALAR|5.019002||Viu +SV_CONSTS_COUNT|5.019002||Viu +SV_CONST_SEEK|5.019002||Viu +SV_CONST_SHIFT|5.019002||Viu +SV_CONST_SPLICE|5.019002||Viu +SV_CONST_STORE|5.019002||Viu +SV_CONST_STORESIZE|5.019002||Viu +SV_CONST_TELL|5.019002||Viu +SV_CONST_TIEARRAY|5.019002||Viu +SV_CONST_TIEHANDLE|5.019002||Viu +SV_CONST_TIEHASH|5.019002||Viu +SV_CONST_TIESCALAR|5.019002||Viu +SV_CONST_UNSHIFT|5.019002||Viu +SV_CONST_UNTIE|5.019002||Viu +SV_CONST_WRITE|5.019002||Viu +sv_copypv|5.007003|5.007003| +sv_copypv_flags|5.017002|5.017002| +sv_copypv_nomg|5.017002|5.017002| +SV_COW_DROP_PV|5.008001|5.003007|p +SV_COW_OTHER_PVS|5.009005||Viu +SV_COW_REFCNT_MAX|5.017007||Viu +SV_COW_SHARED_HASH_KEYS|5.009005|5.003007|poVnu +SvCUR|5.003007|5.003007| +SvCUR_set|5.003007|5.003007| +sv_dec|5.003007|5.003007| +sv_dec_nomg|5.013002|5.013002| +sv_del_backref|5.006000||cViu +sv_derived_from|5.004000|5.004000| +sv_derived_from_pv|5.015004|5.015004| +sv_derived_from_pvn|5.015004|5.015004| +sv_derived_from_sv|5.015004|5.015004| +sv_derived_from_svpvn|5.031006||Viu +sv_destroyable|5.010000|5.010000| +SvDESTROYABLE|5.010000||Viu +sv_display|5.021002||Viu +SV_DO_COW_SVSETSV|5.009005||Viu +sv_does|5.009004|5.009004| +sv_does_pv|5.015004|5.015004| +sv_does_pvn|5.015004|5.015004| +sv_does_sv|5.015004|5.015004| +sv_dump|5.003007|5.003007| +sv_dup|5.007003|5.007003|u +sv_dup_common|5.013002||Viu +sv_dup_inc|5.013002|5.013002|u +sv_dup_inc_multiple|5.011000||Viu +SvEND|5.003007|5.003007| +SvEND_set|5.003007||Viu +SvENDx|5.003007||Viu +sv_eq|5.003007|5.003007| +sv_eq_flags|5.013006|5.013006| +sv_exp_grow|5.009003||Viu +SVf256|5.008001||Viu +SVf32|5.009002||Viu +SVf|5.006000|5.003007|p +SvFAKE|5.003007||Viu +SvFAKE_off|5.003007||Viu +SvFAKE_on|5.003007||Viu +SVf_AMAGIC|5.003007||Viu +SVfARG|5.009005|5.003007|p +SVf_BREAK|5.003007||Viu +SVf_FAKE|5.003007||Viu +SVf_IOK|5.003007||Viu +SVf_IsCOW|5.017006||Viu +SVf_IVisUV|5.006000||Viu +SvFLAGS|5.003007||Viu +SVf_NOK|5.003007||Viu +SVf_OK|5.003007||Viu +SVf_OOK|5.003007||Viu +sv_force_normal|5.006000|5.006000| +sv_force_normal_flags|5.007001|5.007001| +SV_FORCE_UTF8_UPGRADE|5.011000|5.011000| +SVf_POK|5.003007||Viu +SVf_PROTECT|5.021005||Viu +SVf_READONLY|5.003007||Viu +sv_free2|||xciu +sv_free|5.003007|5.003007| +sv_free_arenas|5.003007||Vi +SVf_ROK|5.003007||Viu +SVf_THINKFIRST|5.003007||Viu +SVf_UTF8|5.006000|5.003007|p +SvGAMAGIC|5.006001|5.006001| +sv_get_backrefs|5.021008|5.021008|xn +SvGETMAGIC|5.004005|5.003007|p +sv_gets|5.003007|5.003007| +SvGID|5.019001||Viu +SV_GMAGIC|5.007002|5.003007|p +SvGMAGICAL|5.003007||Viu +SvGMAGICAL_off|5.003007||Viu +SvGMAGICAL_on|5.003007||Viu +SvGROW|5.003007|5.003007| +sv_grow|5.003007||cV +Sv_Grow|5.003007||Viu +sv_grow_fresh|5.035006||cV +SvGROW_mutable|5.009003||Viu +SV_HAS_TRAILING_NUL|5.009004|5.003007|p +SV_IMMEDIATE_UNREF|5.007001|5.003007|p +SvIMMORTAL|5.004000||Viu +SvIMMORTAL_INTERP|5.027003||Viu +SvIMMORTAL_TRUE|5.027003||Viu +sv_inc|5.003007|5.003007| +sv_i_ncmp|5.009003||Viu +sv_i_ncmp_desc|5.031011||Viu +sv_inc_nomg|5.013002|5.013002| +sv_insert|5.003007|5.003007| +sv_insert_flags|5.010001|5.010001| +SvIOK|5.003007|5.003007| +SvIOK_nog|5.017002||Viu +SvIOK_nogthink|5.017002||Viu +SvIOK_notUV|5.006000|5.006000| +SvIOK_off|5.003007|5.003007| +SvIOK_on|5.003007|5.003007| +SvIOK_only|5.003007|5.003007| +SvIOK_only_UV|5.006000|5.006000| +SvIOKp|5.003007|5.003007| +SvIOKp_on|5.003007||Viu +SvIOK_UV|5.006000|5.006000| +sv_isa|5.003007|5.003007| +sv_isa_sv|5.031007|5.031007|x +SvIsBOOL|5.035004|5.035004| +SvIsCOW|5.008003|5.008003| +SvIsCOW_shared_hash|5.008003|5.008003| +SvIS_FREED|5.009003||Viu +sv_isobject|5.003007|5.003007| +SvIV|5.003007|5.003007| +sv_iv|5.005000||dcV +SvIV_nomg|5.009001|5.003007|p +SvIV_please|5.007001||Viu +SvIV_please_nomg|5.013002||Viu +SvIV_set|5.003007|5.003007| +SvIVX|5.003007|5.003007| +SvIVx|5.003007|5.003007| +SvIVXx|5.003007||Viu +sv_kill_backrefs|||xiu +sv_len|5.003007|5.003007| +SvLEN|5.003007|5.003007| +SvLEN_set|5.003007|5.003007| +sv_len_utf8|5.006000|5.006000|p +sv_len_utf8_nomg||5.006000|p +SvLENx|5.003007||Viu +SvLOCK|5.007003|5.007003| +sv_magic|5.003007|5.003007| +SvMAGIC|5.003007||Viu +SvMAGICAL|5.003007||Viu +SvMAGICAL_off|5.003007||Viu +SvMAGICAL_on|5.003007||Viu +sv_magicext|5.007003|5.007003| +sv_magicext_mglob|5.019002||cViu +sv_magic_portable||5.004000|pou +SvMAGIC_set|5.009003|5.003007|p +sv_mortalcopy|5.003007|5.003007| +sv_mortalcopy_flags|5.031001|5.003007|p +SV_MUTABLE_RETURN|5.009003|5.003007|poVnu +sv_ncmp|5.009003||Viu +sv_ncmp_desc|5.031011||Viu +sv_newmortal|5.003007|5.003007| +sv_newref|5.003007||cV +SvNIOK|5.003007|5.003007| +SvNIOK_nog|5.017002||Viu +SvNIOK_nogthink|5.017002||Viu +SvNIOK_off|5.003007|5.003007| +SvNIOKp|5.003007|5.003007| +SvNOK|5.003007|5.003007| +SvNOK_nog|5.017002||Viu +SvNOK_nogthink|5.017002||Viu +SvNOK_off|5.003007|5.003007| +SvNOK_on|5.003007|5.003007| +SvNOK_only|5.003007|5.003007| +SvNOKp|5.003007|5.003007| +SvNOKp_on|5.003007||Viu +sv_nolocking|5.031004|5.031004|d +sv_nosharing|5.007003|5.007003| +SV_NOSTEAL|5.009002|5.003007|p +sv_nounlocking|5.009004|5.009004|d +sv_numeq|5.035009|5.035009| +sv_numeq_flags|5.035009|5.035009| +sv_nv|5.005000||dcV +SvNV|5.006000|5.003007| +SvNV_nomg|5.013002|5.003007|p +SvNV_set|5.006000|5.003007| +SvNVX|5.006000|5.003007| +SvNVx|5.006000|5.003007| +SvNVXx|5.003007||Viu +SvOBJECT|5.003007||Viu +SvOBJECT_off|5.003007||Viu +SvOBJECT_on|5.003007||Viu +SvOK|5.003007|5.003007| +SvOK_off|5.003007||Viu +SvOK_off_exc_UV|5.006000||Viu +SvOKp|5.003007||Viu +sv_only_taint_gmagic|5.021010||Vniu +SvOOK|5.003007|5.003007| +SvOOK_off|5.003007|5.003007| +SvOOK_offset|5.011000|5.011000| +SvOOK_on|5.003007||Viu +sv_or_pv_len_utf8|5.017005||Viu +sv_or_pv_pos_u2b|5.019004||Viu +SvOURSTASH|5.009005||Viu +SvOURSTASH_set|5.009005||Viu +SvPADMY|5.003007||Viu +SvPADMY_on|5.003007||Viu +SVpad_OUR|5.006000||Viu +SvPAD_OUR|5.009004||Viu +SvPAD_OUR_on|5.009004||Viu +SvPADSTALE|5.009000||Viu +SvPADSTALE_off|5.009000||Viu +SvPADSTALE_on|5.009000||Viu +SVpad_STATE|5.009004||Viu +SvPAD_STATE|5.009004||Viu +SvPAD_STATE_on|5.009004||Viu +SvPADTMP|5.003007||Viu +SvPADTMP_off|5.003007||Viu +SvPADTMP_on|5.003007||Viu +SVpad_TYPED|5.007002||Viu +SvPAD_TYPED|5.009004||Viu +SvPAD_TYPED_on|5.009004||Viu +SVpav_REAL|5.009003||Viu +SVpav_REIFY|5.009003||Viu +SvPCS_IMPORTED|5.009005||Viu +SvPCS_IMPORTED_off|5.009005||Viu +SvPCS_IMPORTED_on|5.009005||Viu +SvPEEK|5.003007||Viu +sv_peek|5.005000|5.005000|u +SVpgv_GP|5.009005||Viu +SVphv_CLONEABLE|5.009003||Viu +SVphv_HASKFLAGS|5.008000||Viu +SVphv_LAZYDEL|5.003007||Viu +SVphv_SHAREKEYS|5.003007||Viu +SVp_IOK|5.003007||Viu +SVp_NOK|5.003007||Viu +SvPOK|5.003007|5.003007| +SvPOK_byte_nog|5.017002||Viu +SvPOK_byte_nogthink|5.017002||Viu +SvPOK_byte_pure_nogthink|5.017003||Viu +SvPOK_nog|5.017002||Viu +SvPOK_nogthink|5.017002||Viu +SvPOK_off|5.003007|5.003007| +SvPOK_on|5.003007|5.003007| +SvPOK_only|5.003007|5.003007| +SvPOK_only_UTF8|5.006000|5.006000| +SvPOK_or_cached_IV|||Viu +SvPOKp|5.003007|5.003007| +SvPOKp_on|5.003007||Viu +SvPOK_pure_nogthink|5.017003||Viu +SvPOK_utf8_nog|5.017002||Viu +SvPOK_utf8_nogthink|5.017002||Viu +SvPOK_utf8_pure_nogthink|5.017003||Viu +sv_pos_b2u|5.006000|5.006000| +sv_pos_b2u_flags|5.019003|5.019003| +sv_pos_b2u_midway|5.009004||Viu +sv_pos_u2b|5.006000|5.006000| +sv_pos_u2b_cached|5.009004||Viu +sv_pos_u2b_flags|5.011005|5.011005| +sv_pos_u2b_forwards|5.009004||Vniu +sv_pos_u2b_midway|5.009004||Vniu +SVp_POK|5.003007||Viu +SVppv_STATIC|5.035004||Viu +SVprv_PCS_IMPORTED|5.009005||Viu +SVprv_WEAKREF|5.006000||Viu +SVp_SCREAM|5.003007||Viu +SvPV|5.003007|5.003007| +sv_pv|5.008000||cV +SvPVbyte|5.006000|5.003007|p +sv_pvbyte|5.008000||cV +SvPVbyte_force|5.009002|5.009002| +sv_pvbyten|5.006000||dcV +sv_pvbyten_force|5.006000||cV +SvPVbyte_nolen|5.006000|5.006000| +SvPVbyte_nomg|5.031004|5.031004| +SvPVbyte_or_null|5.031004|5.031004| +SvPVbyte_or_null_nomg|5.031004|5.031004| +SvPVbytex|5.006000|5.006000| +SvPVbytex_force|5.006000|5.006000| +SvPVbytex_nolen|5.009003|5.009003| +SvPVCLEAR|5.025006|5.025006|p +SvPV_const|5.009003|5.003007|p +SvPV_flags|5.007002|5.003007|p +SvPV_flags_const|5.009003|5.003007|p +SvPV_flags_const_nolen|5.009003||pVu +SvPV_flags_mutable|5.009003|5.003007|p +SvPV_force|5.003007|5.003007|p +SvPV_force_flags|5.007002|5.003007|p +SvPV_force_flags_mutable|5.009003|5.003007|p +SvPV_force_flags_nolen|5.009003|5.003007|p +SvPV_force_mutable|5.009003|5.003007|p +SvPV_force_nolen|5.009003|5.003007|p +SvPV_force_nomg|5.007002|5.003007|p +SvPV_force_nomg_nolen|5.009003|5.003007|p +SvPV_free|5.009003|5.009003| +SvPV_mutable|5.009003|5.003007|p +sv_pvn|5.004000||dcV +sv_pvn_force|5.005000||cV +sv_pvn_force_flags|5.007002|5.003007|p +sv_pvn_force_nomg|5.007002||Viu +sv_pvn_nomg|5.007003|5.005000|pdu +SvPV_nolen|5.006000|5.003007|p +SvPV_nolen_const|5.009003|5.003007|p +SvPV_nomg|5.007002|5.003007|p +SvPV_nomg_const|5.009003|5.003007|p +SvPV_nomg_const_nolen|5.009003|5.003007|p +SvPV_nomg_nolen|5.013007|5.003007|p +SvPV_renew|5.009003|5.003007|p +SvPV_set|5.003007|5.003007| +SvPV_shrink_to_cur|5.009003||Viu +SvPVutf8|5.006000|5.006000| +sv_pvutf8|5.008000||cV +SvPVutf8_force|5.006000|5.006000| +sv_pvutf8n|5.006000||dcV +sv_pvutf8n_force|5.006000||cV +SvPVutf8_nolen|5.006000|5.006000| +SvPVutf8_nomg|5.031004|5.031004| +SvPVutf8_or_null|5.031004|5.031004| +SvPVutf8_or_null_nomg|5.031004|5.031004| +SvPVutf8x|5.006000|5.006000| +SvPVutf8x_force|5.006000|5.006000| +SvPVX|5.003007|5.003007| +SvPVx|5.003007|5.003007| +SvPVX_const|5.009003|5.003007|p +SvPVx_const|5.009003|5.009003| +SvPVx_force|5.005000|5.005000| +SvPVX_mutable|5.009003|5.003007|p +SvPVx_nolen|5.009003|5.009003| +SvPVx_nolen_const|5.009003|5.003007|p +SvPVXtrue|5.017002||Viu +SvPVXx|5.003007|5.003007| +SvREADONLY|5.003007|5.003007| +SvREADONLY_off|5.003007|5.003007| +SvREADONLY_on|5.003007|5.003007| +sv_recode_to_utf8|5.007003|5.007003| +sv_ref|5.023005|5.023005| +SvREFCNT|5.003007|5.003007| +SvREFCNT_dec|5.003007|5.003007| +SvREFCNT_dec_NN|5.017007|5.017007| +SvREFCNT_IMMORTAL|5.017008||Viu +SvREFCNT_inc|5.003007|5.003007|pn +SvREFCNT_inc_NN|5.009004|5.003007|pn +SvREFCNT_inc_simple|5.009004|5.003007|pn +SvREFCNT_inc_simple_NN|5.009004|5.003007|pn +SvREFCNT_inc_simple_void|5.009004|5.003007|pn +SvREFCNT_inc_simple_void_NN|5.009004|5.003007|pn +SvREFCNT_inc_void|5.009004|5.003007|pn +SvREFCNT_inc_void_NN|5.009004|5.003007|pn +sv_reftype|5.003007|5.003007| +sv_replace|5.003007|5.003007| +sv_report_used|5.003007|5.003007| +sv_reset|5.003007|5.003007| +sv_resetpvn|5.017005||Viu +SvRMAGICAL|5.003007||Viu +SvRMAGICAL_off|5.003007||Viu +SvRMAGICAL_on|5.003007||Viu +SvROK|5.003007|5.003007| +SvROK_off|5.003007|5.003007| +SvROK_on|5.003007|5.003007| +SvRV|5.003007|5.003007| +SvRV_const|5.010001||Viu +SvRV_set|5.009003|5.003007|p +sv_rvunweaken|5.027004|5.027004| +sv_rvweaken|5.006000|5.006000| +SvRVx|5.003007||Viu +SvRX|5.009005|5.003007|p +SvRXOK|5.009005|5.003007|p +SV_SAVED_COPY|5.009005||Viu +SvSCREAM|5.003007||Viu +SvSCREAM_off|5.003007||Viu +SvSCREAM_on|5.003007||Viu +sv_setbool|5.035004|5.035004| +sv_setbool_mg|5.035004|5.035004| +sv_setgid|5.019001||Viu +sv_sethek|5.015004||cViu +sv_setiv|5.003007|5.003007| +sv_setiv_mg|5.004005|5.003007|p +SvSETMAGIC|5.003007|5.003007| +SvSetMagicSV|5.004000|5.004000| +SvSetMagicSV_nosteal|5.004000|5.004000| +sv_setnv|5.006000|5.003007| +sv_setnv_mg|5.006000|5.003007|p +sv_setpv|5.003007|5.003007| +sv_setpv_bufsize|5.025006|5.025006| +sv_setpvf|5.004000||vV +sv_setpvf_mg|5.004005||pvV +sv_setpvf_mg_nocontext|5.006000||pvVn +sv_setpvf_nocontext|5.006000||vVn +sv_setpviv|5.008001|5.008001|d +sv_setpviv_mg|5.008001|5.008001|d +sv_setpv_mg|5.004005|5.003007|p +sv_setpvn|5.003007|5.003007| +sv_setpvn_fresh|5.035006|5.035006| +sv_setpvn_mg|5.004005|5.003007|p +sv_setpvs|5.009004|5.003007|p +sv_setpvs_mg|5.013006|5.013006| +sv_setref_iv|5.003007|5.003007| +sv_setref_nv|5.006000|5.003007| +sv_setref_pv|5.003007|5.003007| +sv_setref_pvn|5.003007|5.003007| +sv_setref_pvs|5.013006|5.013006| +sv_setref_uv|5.007001|5.007001| +sv_setrv_inc|5.035004|5.035004| +sv_setrv_inc_mg|5.035004|5.035004| +sv_setrv_noinc|5.035004|5.035004| +sv_setrv_noinc_mg|5.035004|5.035004| +sv_setsv|5.003007|5.003007| +SvSetSV|5.003007|5.003007| +sv_setsv_cow|5.009000||xcViu +sv_setsv_flags|5.007002|5.003007|p +sv_setsv_mg|5.004005|5.003007|p +sv_setsv_nomg|5.007002|5.003007|p +SvSetSV_nosteal|5.004000|5.004000| +sv_setuid|5.019001||Viu +sv_set_undef|5.025008|5.025008| +sv_setuv|5.004000|5.003007|p +sv_setuv_mg|5.004005|5.003007|p +SVs_GMG|5.003007||Viu +SvSHARE|5.007003|5.007003| +SvSHARED_HASH|5.009003|5.003007|p +SvSHARED_HEK_FROM_PV|5.009003||Viu +SV_SKIP_OVERLOAD|5.013001||Viu +SV_SMAGIC|5.009003|5.003007|p +SvSMAGICAL|5.003007||Viu +SvSMAGICAL_off|5.003007||Viu +SvSMAGICAL_on|5.003007||Viu +SVs_OBJECT|5.003007||Viu +SVs_PADMY|5.003007||Viu +SVs_PADSTALE|5.009000|5.009000| +SVs_PADTMP|5.003007||Viu +SVs_RMG|5.003007||Viu +SVs_SMG|5.003007||Viu +SvSTASH|5.003007|5.003007| +SvSTASH_set|5.009003|5.003007|p +SVs_TEMP|5.003007|5.003007| +sv_streq|5.035009|5.035009| +sv_streq_flags|5.035009|5.035009| +sv_string_from_errnum|5.027003|5.027003| +SvTAIL|5.003007||Viu +SvTAINT|5.003007|5.003007| +sv_taint|5.009003||cV +SvTAINTED|5.004000|5.004000| +sv_tainted|5.004000||cV +SvTAINTED_off|5.004000|5.004000| +SvTAINTED_on|5.004000|5.004000| +SvTEMP|5.003007||Viu +SvTEMP_off|5.003007||Viu +SvTEMP_on|5.003007||Viu +SVt_FIRST|5.021005||Viu +SvTHINKFIRST|5.003007||Vi +SvTIED_mg|5.005003||Viu +SvTIED_obj|5.005003|5.005003| +SVt_INVLIST|||c +SVt_IV|5.003007|5.003007| +SVt_MASK|5.015001||Viu +SVt_NULL|5.003007|5.003007| +SVt_NV|5.003007|5.003007| +SVt_PV|5.003007|5.003007| +SVt_PVAV|5.003007|5.003007| +SVt_PVBM|5.009005||Viu +SVt_PVCV|5.003007|5.003007| +SVt_PVFM|5.003007|5.003007| +SVt_PVGV|5.003007|5.003007| +SVt_PVHV|5.003007|5.003007| +SVt_PVIO|5.003007|5.003007| +SVt_PVIV|5.003007|5.003007| +SVt_PVLV|5.003007|5.003007| +SVt_PVMG|5.003007|5.003007| +SVt_PVNV|5.003007|5.003007| +SVt_REGEXP|5.011000|5.011000| +SvTRUE|5.003007|5.003007| +sv_true|5.005000||cV +SvTRUE_common|5.033005||cVu +SvTRUE_NN|5.017007|5.017007| +SvTRUE_nomg|5.013006|5.003007|p +SvTRUE_nomg_NN|5.017007|5.017007| +SvTRUEx|5.003007|5.003007| +SvTRUEx_nomg|5.017002||Viu +SVt_RV|5.011000||Viu +SvTYPE|5.003007|5.003007| +SVTYPEMASK|5.003007||Viu +SvUID|5.019001||Viu +SV_UNDEF_RETURNS_NULL|5.011000||Viu +sv_unglob|5.005000||Viu +sv_uni_display|5.007003|5.007003| +SvUNLOCK|5.007003|5.007003| +sv_unmagic|5.003007|5.003007| +sv_unmagicext|5.013008|5.003007|p +sv_unref|5.003007|5.003007| +sv_unref_flags|5.007001|5.007001| +sv_untaint|5.004000||cV +SvUOK|5.007001|5.006000|p +SvUOK_nog|5.017002||Viu +SvUOK_nogthink|5.017002||Viu +sv_upgrade|5.003007|5.003007| +SvUPGRADE|5.003007|5.003007| +sv_usepvn|5.003007|5.003007| +sv_usepvn_flags|5.009004|5.009004| +sv_usepvn_mg|5.004005|5.003007|p +SvUTF8|5.006000|5.003007|p +sv_utf8_decode|5.006000|5.006000| +sv_utf8_downgrade|5.006000|5.006000| +sv_utf8_downgrade_flags|5.031004|5.031004| +sv_utf8_downgrade_nomg|5.031004|5.031004| +sv_utf8_encode|5.006000|5.006000| +SV_UTF8_NO_ENCODING|5.008001|5.003007|pd +SvUTF8_off|5.006000|5.006000| +SvUTF8_on|5.006000|5.006000| +sv_utf8_upgrade|5.007001|5.007001| +sv_utf8_upgrade_flags|5.007002|5.007002| +sv_utf8_upgrade_flags_grow|5.011000|5.011000| +sv_utf8_upgrade_nomg|5.007002|5.007002| +SvUV|5.004000|5.003007|p +sv_uv|5.005000||pdcV +SvUV_nomg|5.009001|5.003007|p +SvUV_set|5.009003|5.003007|p +SvUVX|5.004000|5.003007|p +SvUVx|5.004000|5.003007|p +SvUVXx|5.004000|5.003007|pd +SvVALID|5.003007||Viu +sv_vcatpvf|5.006000|5.004000|p +sv_vcatpvf_mg|5.006000|5.004000|p +sv_vcatpvfn|5.004000|5.004000| +sv_vcatpvfn_flags|5.017002|5.017002| +SvVOK|5.008001|5.008001| +sv_vsetpvf|5.006000|5.004000|p +sv_vsetpvf_mg|5.006000|5.004000|p +sv_vsetpvfn|5.004000|5.004000| +SvVSTRING_mg|5.009004|5.003007|p +SvWEAKREF|5.006000||Viu +SvWEAKREF_off|5.006000||Viu +SvWEAKREF_on|5.006000||Viu +swallow_bom|5.006001||Viu +switch_category_locale_to_template|5.027009||Viu +SWITCHSTACK|5.003007||Viu +switch_to_global_locale|5.027009|5.003007|pn +sync_locale|5.027009|5.003007|pn +sys_init3|||cnu +sys_init|||cnu +sys_intern_clear|5.006001||Vu +sys_intern_dup|5.006000||Vu +sys_intern_init|5.006001||Vu +SYSTEM_GMTIME_MAX|5.011000||Viu +SYSTEM_GMTIME_MIN|5.011000||Viu +SYSTEM_LOCALTIME_MAX|5.011000||Viu +SYSTEM_LOCALTIME_MIN|5.011000||Viu +sys_term|||cnu +TAIL|5.005000||Viu +TAIL_t8|5.035004||Viu +TAIL_t8_p8|5.033003||Viu +TAIL_t8_pb|5.033003||Viu +TAIL_tb|5.035004||Viu +TAIL_tb_p8|5.033003||Viu +TAIL_tb_pb|5.033003||Viu +TAINT|5.004000||Viu +taint_env|5.003007|5.003007|u +TAINT_ENV|5.003007||Viu +TAINT_get|5.017006||Viu +TAINT_IF|5.003007||Viu +TAINTING_get|5.017006||Viu +TAINTING_set|5.017006||Viu +TAINT_NOT|5.003007||Viu +taint_proper|5.003007|5.003007|u +TAINT_PROPER|5.003007||Viu +TAINT_set|5.017006||Viu +TAINT_WARN_get|5.017006||Viu +TAINT_WARN_set|5.017006||Viu +TARG|5.003007|5.003007| +TARGi|5.023005||Viu +TARGn|5.023005||Viu +TARGu|5.023005||Viu +telldir|5.005000||Viu +T_FMT|5.027010||Viu +T_FMT_AMPM|5.027010||Viu +THIS|5.003007|5.003007|V +THOUSEP|5.027010||Viu +THR|5.005000||Viu +THREAD_CREATE_NEEDS_STACK|5.007002||Viu +thread_locale_init|5.027009|5.027009|xnu +thread_locale_term|5.027009|5.027009|xnu +THREAD_RET_TYPE|5.005000||Viu +tied_method|5.013009||vViu +TIED_METHOD_ARGUMENTS_ON_STACK|5.013009||Viu +TIED_METHOD_MORTALIZE_NOT_NEEDED|5.013009||Viu +TIED_METHOD_SAY|5.013009||Viu +times|5.005000||Viu +Time_t|5.003007|5.003007|Vn +Timeval|5.004000|5.004000|Vn +TM|5.011000||Viu +tmpfile|5.003007||Viu +tmpnam|5.005000||Viu +TMPNAM_R_PROTO|5.008000|5.008000|Vn +tmps_grow_p|5.021005||cViu +to_byte_substr|5.008000||Viu +to_case_cp_list|5.035004||Viu +toCTRL|5.004000||Viu +toFOLD|5.019001|5.019001| +toFOLD_A|5.019001|5.019001| +_to_fold_latin1|5.015005||cVniu +toFOLD_LC|5.019001||Viu +toFOLD_uni|5.007003||Viu +toFOLD_utf8|5.031005|5.031005| +toFOLD_utf8_safe|5.025009|5.006000|p +toFOLD_uvchr|5.023009|5.006000|p +TO_INTERNAL_SIZE|5.023002||Viu +tokenize_use|5.009003||Viu +tokeq|5.005000||Viu +tokereport|5.007001||Viu +toLOWER|5.003007|5.003007| +toLOWER_A|5.019001|5.019001| +toLOWER_L1|5.019001|5.019001| +toLOWER_LATIN1|5.013006|5.011002| +to_lower_latin1|5.015005||Vniu +toLOWER_LC|5.004000|5.004000| +toLOWER_uni|5.006000||Viu +toLOWER_utf8|5.031005|5.031005| +toLOWER_utf8_safe|5.025009|5.006000|p +toLOWER_uvchr|5.023009|5.006000|p +too_few_arguments_pv|5.016000||Viu +TOO_LATE_FOR|5.008001||Viu +too_many_arguments_pv|5.016000||Viu +TOPi|5.003007||Viu +TOPl|5.003007||Viu +TOPm1s|5.007001||Viu +TOPMARK|5.003007||cViu +TOPn|5.003007||Viu +TOPp1s|5.007001||Viu +TOPp|5.003007||Viu +TOPpx|5.005003||Viu +TOPs|5.003007||Viu +TOPu|5.004000||Viu +TOPul|5.006000||Viu +toTITLE|5.019001|5.019001| +toTITLE_A|5.019001|5.019001| +toTITLE_uni|5.006000||Viu +toTITLE_utf8|5.031005|5.031005| +toTITLE_utf8_safe|5.025009|5.006000|p +toTITLE_uvchr|5.023009|5.006000|p +to_uni_fold|5.014000||cVu +_to_uni_fold_flags|5.014000||cVu +to_uni_lower|5.006000||cVu +to_uni_title|5.006000||cVu +to_uni_upper|5.006000||cVu +toUPPER|5.003007|5.003007| +toUPPER_A|5.019001|5.019001| +toUPPER_LATIN1_MOD|5.011002||Viu +toUPPER_LC|5.004000||Viu +_to_upper_title_latin1|5.015005||Viu +toUPPER_uni|5.006000||Viu +toUPPER_utf8|5.031005|5.031005| +toUPPER_utf8_safe|5.025009|5.006000|p +toUPPER_uvchr|5.023009|5.006000|p +_to_utf8_case|5.023006||Viu +_to_utf8_fold_flags|5.014000||cVu +_to_utf8_lower_flags|5.015006||cVu +to_utf8_substr|5.008000||Viu +_to_utf8_title_flags|5.015006||cVu +_to_utf8_upper_flags|5.015006||cVu +translate_substr_offsets|5.015006||Vniu +traverse_op_tree|5.029008||Vi +TR_DELETE|5.031006||Viu +TRIE|5.009002||Viu +TRIE_BITMAP|5.009004||Viu +TRIE_BITMAP_BYTE|5.009004||Viu +TRIE_BITMAP_CLEAR|5.009004||Viu +TRIE_BITMAP_SET|5.009004||Viu +TRIE_BITMAP_TEST|5.009004||Viu +TRIEC|5.009004||Viu +TRIE_CHARCOUNT|5.009004||Viu +TRIEC_t8|5.035004||Viu +TRIEC_t8_p8|5.033003||Viu +TRIEC_t8_pb|5.033003||Viu +TRIEC_tb|5.035004||Viu +TRIEC_tb_p8|5.033003||Viu +TRIEC_tb_pb|5.033003||Viu +TRIE_next|5.009005||Viu +TRIE_next_fail|5.009005||Viu +TRIE_next_fail_t8|5.035004||Viu +TRIE_next_fail_t8_p8|5.033003||Viu +TRIE_next_fail_t8_pb|5.033003||Viu +TRIE_next_fail_tb|5.035004||Viu +TRIE_next_fail_tb_p8|5.033003||Viu +TRIE_next_fail_tb_pb|5.033003||Viu +TRIE_next_t8|5.035004||Viu +TRIE_next_t8_p8|5.033003||Viu +TRIE_next_t8_pb|5.033003||Viu +TRIE_next_tb|5.035004||Viu +TRIE_next_tb_p8|5.033003||Viu +TRIE_next_tb_pb|5.033003||Viu +TRIE_NODEIDX|5.009002||Viu +TRIE_NODENUM|5.009002||Viu +TRIE_t8|5.035004||Viu +TRIE_t8_p8|5.033003||Viu +TRIE_t8_pb|5.033003||Viu +TRIE_tb|5.035004||Viu +TRIE_tb_p8|5.033003||Viu +TRIE_tb_pb|5.033003||Viu +TRIE_WORDS_OFFSET|5.009005||Viu +TR_OOB|5.031006||Viu +TR_R_EMPTY|5.031006||Viu +TR_SPECIAL_HANDLING|5.031006||Viu +TRUE|5.003007||Viu +truncate|5.006000||Viu +TR_UNLISTED|5.031006||Viu +TR_UNMAPPED|5.031006||Viu +try_amagic_bin|||ciu +tryAMAGICbin_MG|5.013002||Viu +try_amagic_un|||ciu +tryAMAGICunDEREF|5.006000||Viu +tryAMAGICun_MG|5.013002||Viu +tryAMAGICunTARGETlist|5.017002||Viu +TS_W32_BROKEN_LOCALECONV|5.027010||Viu +tTHX|5.009003||Viu +ttyname|5.009000||Viu +TTYNAME_R_PROTO|5.008000|5.008000|Vn +turkic_fc|5.029008||Viu +turkic_lc|5.029008||Viu +turkic_uc|5.029008||Viu +TWO_BYTE_UTF8_TO_NATIVE|5.019004||Viu +TWO_BYTE_UTF8_TO_UNI|5.013008||Viu +TYPE_CHARS|5.004000||Viu +TYPE_DIGITS|5.004000||Viu +U16|5.027001||Viu +U16_MAX|5.003007||Viu +U16_MIN|5.003007||Viu +U16SIZE|5.006000|5.006000|Vn +U16TYPE|5.006000|5.006000|Vn +U_32|5.007002|5.007002| +U32|5.027001||Viu +U32_ALIGNMENT_REQUIRED|5.007001|5.007001|Vn +U32_MAX|5.003007||Viu +U32_MAX_P1|5.007002||Viu +U32_MAX_P1_HALF|5.007002||Viu +U32_MIN|5.003007||Viu +U32SIZE|5.006000|5.006000|Vn +U32TYPE|5.006000|5.006000|Vn +U64|5.023002||Viu +U64SIZE|5.006000|5.006000|Vn +U64TYPE|5.006000|5.006000|Vn +U8|5.027001||Viu +U8_MAX|5.003007||Viu +U8_MIN|5.003007||Viu +U8SIZE|5.006000|5.006000|Vn +U8TO16_LE|5.017010||Viu +U8TO32_LE|5.017010||Viu +U8TO64_LE|5.017006||Viu +U8TYPE|5.006000|5.006000|Vn +UCHARAT|5.003007||Viu +U_I|5.003007||Viu +Uid_t|5.003007|5.003007|Vn +Uid_t_f|5.006000|5.006000|Vn +Uid_t_sign|5.006000|5.006000|Vn +Uid_t_size|5.006000|5.006000|Vn +UINT16_C|5.003007|5.003007| +UINT32_C|5.003007|5.003007| +UINT32_MIN|5.006000||Viu +UINT64_C|5.023002|5.023002| +UINT64_MIN|5.006000||Viu +UINTMAX_C|5.003007|5.003007| +uiv_2buf|5.009003||Vniu +U_L|5.003007||Viu +umask|5.005000||Viu +uname|5.005004||Viu +UNDERBAR|5.009002|5.003007|p +unexpected_non_continuation_text|5.025006||Viu +ungetc|5.003007||Viu +UNI_age_values_index|5.029009||Viu +UNI_AHEX|5.029002||Viu +UNI_ahex_values_index|5.029009||Viu +UNI_ALNUM|5.029002||Viu +UNI_ALPHA|5.029002||Viu +UNI_ALPHABETIC|5.029002||Viu +UNI_alpha_values_index|5.029009||Viu +UNI_ASCIIHEXDIGIT|5.029002||Viu +UNI_BASICLATIN|5.029002||Viu +UNI_bc_values_index|5.029009||Viu +UNI_bidic_values_index|5.029009||Viu +UNI_bidim_values_index|5.029009||Viu +UNI_BLANK|5.029002||Viu +UNI_blk_values_index|5.029009||Viu +UNI_bpt_values_index|5.029009||Viu +UNI_cased_values_index|5.029009||Viu +UNI_CC|5.029002||Viu +UNI_ccc_values_index|5.029009||Viu +UNI_ce_values_index|5.029009||Viu +UNI_ci_values_index|5.029009||Viu +UNI_CNTRL|5.029002||Viu +UNICODE_ALLOW_ABOVE_IV_MAX|5.031006||Viu +UNICODE_ALLOW_ANY|5.007003||Viu +UNICODE_ALLOW_SUPER|5.007003||Viu +UNICODE_ALLOW_SURROGATE|5.007003||Viu +UNICODE_BYTE_ORDER_MARK|5.008000||Viu +UNICODE_DISALLOW_ABOVE_31_BIT|5.023006|5.023006| +UNICODE_DISALLOW_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| +UNICODE_DISALLOW_ILLEGAL_INTERCHANGE|5.013009|5.013009| +UNICODE_DISALLOW_NONCHAR|5.013009|5.013009| +UNICODE_DISALLOW_PERL_EXTENDED|5.027002|5.027002| +UNICODE_DISALLOW_SUPER|5.013009|5.013009| +UNICODE_DISALLOW_SURROGATE|5.013009|5.013009| +UNICODE_DOT_DOT_VERSION|5.023002||Viu +UNICODE_DOT_VERSION|5.023002||Viu +UNICODE_GOT_NONCHAR|5.027009||Viu +UNICODE_GOT_PERL_EXTENDED|5.027009||Viu +UNICODE_GOT_SUPER|5.027009||Viu +UNICODE_GOT_SURROGATE|5.027009||Viu +UNICODE_GREEK_CAPITAL_LETTER_SIGMA|5.007003||Viu +UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA|5.007003||Viu +UNICODE_GREEK_SMALL_LETTER_SIGMA|5.007003||Viu +UNICODE_IS_32_CONTIGUOUS_NONCHARS|5.023006||Viu +UNICODE_IS_BYTE_ORDER_MARK|5.007001||Viu +UNICODE_IS_END_PLANE_NONCHAR_GIVEN_NOT_SUPER|5.023006||Viu +UNICODE_IS_NONCHAR|5.013009|5.013009| +UNICODE_IS_PERL_EXTENDED|5.027002||Viu +UNICODE_IS_REPLACEMENT|5.007002|5.007002| +UNICODE_IS_SUPER|5.013009|5.013009| +UNICODE_IS_SURROGATE|5.007001|5.007001| +UNICODE_MAJOR_VERSION|5.023002||Viu +UNICODE_PAT_MOD|5.013006||Viu +UNICODE_PAT_MODS|5.013006||Viu +UNICODE_REPLACEMENT|5.007001|5.003007|p +UNICODE_SURROGATE_FIRST|5.007001||Viu +UNICODE_SURROGATE_LAST|5.007001||Viu +UNICODE_WARN_ABOVE_31_BIT|5.023006|5.023006| +UNICODE_WARN_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| +UNICODE_WARN_ILLEGAL_INTERCHANGE|5.013009|5.013009| +UNICODE_WARN_NONCHAR|5.013009|5.013009| +UNICODE_WARN_PERL_EXTENDED|5.027002|5.027002| +UNICODE_WARN_SUPER|5.013009|5.013009| +UNICODE_WARN_SURROGATE|5.013009|5.013009| +UNI_compex_values_index|5.029009||Viu +UNI_CONTROL|5.029002||Viu +UNI_cwcf_values_index|5.029009||Viu +UNI_cwcm_values_index|5.029009||Viu +UNI_cwkcf_values_index|5.029009||Viu +UNI_cwl_values_index|5.029009||Viu +UNI_cwt_values_index|5.029009||Viu +UNI_cwu_values_index|5.029009||Viu +UNI_dash_values_index|5.029009||Viu +UNI_DECIMALNUMBER|5.029002||Viu +UNI_dep_values_index|5.029009||Viu +UNI_dia_values_index|5.029009||Viu +UNI_DIGIT|5.029002||Viu +UNI_DISPLAY_BACKSLASH|5.007003|5.007003| +UNI_DISPLAY_BACKSPACE|5.031009|5.031009| +UNI_DISPLAY_ISPRINT|5.007003|5.007003| +UNI_DISPLAY_QQ|5.007003|5.007003| +UNI_DISPLAY_REGEX|5.007003|5.007003| +UNI_di_values_index|5.029009||Viu +UNI_dt_values_index|5.029009||Viu +UNI_ea_values_index|5.029009||Viu +UNI_ebase_values_index|5.031010||Viu +UNI_ecomp_values_index|5.031010||Viu +UNI_emod_values_index|5.031010||Viu +UNI_emoji_values_index|5.031010||Viu +UNI_epres_values_index|5.031010||Viu +UNI_extpict_values_index|5.031010||Viu +UNI_ext_values_index|5.029009||Viu +UNI_gcb_values_index|5.029009||Viu +UNI_gc_values_index|5.029009||Viu +UNI_GRAPH|5.029002||Viu +UNI_grbase_values_index|5.029009||Viu +UNI_grext_values_index|5.029009||Viu +UNI_HEX|5.029002||Viu +UNI_HEXDIGIT|5.029002||Viu +UNI_hex_values_index|5.029009||Viu +UNI_HORIZSPACE|5.029002||Viu +UNI_hst_values_index|5.029009||Viu +UNI_HYPHEN|5.029002||Viu +UNI_hyphen_values_index|5.029009||Viu +UNI_idc_values_index|5.029009||Viu +UNI_identifierstatus_values_index|5.031010||Viu +UNI_identifiertype_values_index|5.031010||Viu +UNI_ideo_values_index|5.029009||Viu +UNI_idsb_values_index|5.029009||Viu +UNI_idst_values_index|5.029009||Viu +UNI_ids_values_index|5.029009||Viu +UNI_inpc_values_index|5.029009||Viu +UNI_insc_values_index|5.029009||Viu +UNI_in_values_index|5.029009||Viu +UNI_IS_INVARIANT|5.007001||Viu +UNI_jg_values_index|5.029009||Viu +UNI_joinc_values_index|5.029009||Viu +UNI_jt_values_index|5.029009||Viu +UNI_L|5.029002||Viu +UNI_L_AMP|5.029002||Viu +UNI_LB__SG|5.029002||Viu +UNI_lb_values_index|5.029009||Viu +UNI_LC|5.029002||Viu +UNI_LL|5.029002||Viu +UNI_loe_values_index|5.029009||Viu +UNI_LOWER|5.029002||Viu +UNI_LOWERCASE|5.029002||Viu +UNI_lower_values_index|5.029009||Viu +UNI_LT|5.029002||Viu +UNI_LU|5.029002||Viu +UNI_math_values_index|5.029009||Viu +UNI_nchar_values_index|5.029009||Viu +UNI_ND|5.029002||Viu +UNI_nfcqc_values_index|5.029009||Viu +UNI_nfdqc_values_index|5.029009||Viu +UNI_nfkcqc_values_index|5.029009||Viu +UNI_nfkdqc_values_index|5.029009||Viu +UNI_nt_values_index|5.029009||Viu +UNI_nv_values_index|5.029009||Viu +UNI_patsyn_values_index|5.029009||Viu +UNI_patws_values_index|5.029009||Viu +UNI_pcm_values_index|5.029009||Viu +UNI_PERLSPACE|5.029002||Viu +UNI_PERLWORD|5.029002||Viu +UNI_PRINT|5.029002||Viu +UNI_qmark_values_index|5.029009||Viu +UNI_radical_values_index|5.029009||Viu +UNI_ri_values_index|5.029009||Viu +UNI_sb_values_index|5.029009||Viu +UNI_sc_values_index|5.029009||Viu +UNI_scx_values_index|5.029009||Viu +UNI_sd_values_index|5.029009||Viu +UNISKIP|5.007001||Viu +UNISKIP_BY_MSB|5.035004||Viu +UNI_SPACE|5.029002||Viu +UNI_SPACEPERL|5.029002||Viu +UNI_sterm_values_index|5.029009||Viu +UNI_term_values_index|5.029009||Viu +UNI_TITLECASE|5.029002||Viu +UNI_TITLECASELETTER|5.029002||Viu +UNI_TO_NATIVE|5.007001|5.003007|p +UNI_uideo_values_index|5.029009||Viu +UNI_UPPER|5.029002||Viu +UNI_UPPERCASE|5.029002||Viu +UNI_upper_values_index|5.029009||Viu +UNI_vo_values_index|5.029009||Viu +UNI_vs_values_index|5.029009||Viu +UNI_wb_values_index|5.029009||Viu +UNI_WHITESPACE|5.029002||Viu +UNI_WORD|5.029002||Viu +UNI_WSPACE|5.029002||Viu +UNI_wspace_values_index|5.029009||Viu +UNI_XDIGIT|5.029002||Viu +UNI_xidc_values_index|5.029009||Viu +UNI_xids_values_index|5.029009||Viu +UNI_XPERLSPACE|5.029002||Viu +UNKNOWN_ERRNO_MSG|5.019007||Viu +UNLESSM|5.003007||Viu +UNLESSM_t8|5.035004||Viu +UNLESSM_t8_p8|5.033003||Viu +UNLESSM_t8_pb|5.033003||Viu +UNLESSM_tb|5.035004||Viu +UNLESSM_tb_p8|5.033003||Viu +UNLESSM_tb_pb|5.033003||Viu +UNLIKELY|5.009004|5.003007|p +UNLINK|5.003007||Viu +unlink|5.005000||Viu +unlnk|5.003007||cVu +UNLOCK_DOLLARZERO_MUTEX|5.008001||Viu +UNLOCK_LC_NUMERIC_STANDARD|5.021010||poVnu +UNLOCK_NUMERIC_STANDARD|||piu +UNOP_AUX_item_sv|5.021007||Viu +unpack_rec|5.008001||Viu +unpack_str|5.007003|5.007003|d +unpackstring|5.008001|5.008001| +unpackWARN1|5.007003||Viu +unpackWARN2|5.007003||Viu +unpackWARN3|5.007003||Viu +unpackWARN4|5.007003||Viu +unreferenced_to_tmp_stack|5.013002||Viu +unshare_hek|5.004000||Viu +unshare_hek_or_pvn|5.008000||Viu +unsharepvn|5.003007|5.003007|u +unwind_handler_stack|5.009003||Viu +update_debugger_info|5.009005||Viu +upg_version|5.009005|5.009005| +UPG_VERSION|5.019008||Viu +uproot_SV|||Viu +Uquad_t|5.006000|5.006000|Vn +U_S|5.003007||Viu +usage|5.005000||Viu +USE_64_BIT_ALL|5.006000|5.006000|Vn +USE_64_BIT_INT|5.006000|5.006000|Vn +USE_64_BIT_RAWIO|5.006000||Viu +USE_64_BIT_STDIO|5.006000||Viu +USE_BSDPGRP|5.003007||Viu +USE_C_BACKTRACE|5.035009|5.035009|Vn +USE_DYNAMIC_LOADING|5.003007|5.003007|Vn +USE_ENVIRON_ARRAY|5.007001||Viu +USE_GRENT_BUFFER|5.008000||Viu +USE_GRENT_FPTR|5.008000||Viu +USE_GRENT_PTR|5.008000||Viu +USE_HASH_SEED|5.008001||Viu +USE_HOSTENT_BUFFER|5.008000||Viu +USE_HOSTENT_ERRNO|5.008000||Viu +USE_HOSTENT_PTR|5.008000||Viu +USE_ITHREADS|5.010000|5.010000|Vn +USE_LARGE_FILES|5.006000|5.006000|Vn +USE_LEFT|5.004000||Viu +USE_LOCALE|5.004000||Viu +USE_LOCALE_ADDRESS|5.027009||Viu +USE_LOCALE_COLLATE|5.004000||Viu +USE_LOCALE_CTYPE|5.004000||Viu +USE_LOCALE_IDENTIFICATION|5.027009||Viu +USE_LOCALE_MEASUREMENT|5.027009||Viu +USE_LOCALE_MESSAGES|5.019002||Viu +USE_LOCALE_MONETARY|5.019002||Viu +USE_LOCALE_NUMERIC|5.004000||Viu +USE_LOCALE_PAPER|5.027009||Viu +USE_LOCALE_SYNTAX|5.033001||Viu +USE_LOCALE_TELEPHONE|5.027009||Viu +USE_LOCALE_TIME|5.021002||Viu +USE_LOCALE_TOD|5.033001||Viu +USEMYBINMODE|5.006000||Viu +USE_NETENT_BUFFER|5.008000||Viu +USE_NETENT_ERRNO|5.008000||Viu +USE_NETENT_PTR|5.008000||Viu +USE_PERL_ATOF|5.008000||Viu +USE_PERLIO|5.007001|5.007001|Vn +USE_PERL_PERTURB_KEYS|5.018000||Viu +USE_POSIX_2008_LOCALE|5.027003||Viu +USE_PROTOENT_BUFFER|5.008000||Viu +USE_PROTOENT_PTR|5.008000||Viu +USE_PWENT_BUFFER|5.008000||Viu +USE_PWENT_FPTR|5.008000||Viu +USE_PWENT_PTR|5.008000||Viu +USE_REENTRANT_API|5.007003||Viu +USER_PROP_MUTEX_INIT|5.029008||Viu +USER_PROP_MUTEX_LOCK|5.029008||Viu +USER_PROP_MUTEX_TERM|5.029008||Viu +USER_PROP_MUTEX_UNLOCK|5.029008||Viu +USE_SEMCTL_SEMID_DS|5.004005|5.004005|Vn +USE_SEMCTL_SEMUN|5.004005|5.004005|Vn +USE_SERVENT_BUFFER|5.008000||Viu +USE_SERVENT_PTR|5.008000||Viu +USE_SPENT_BUFFER|5.031011||Viu +USE_SPENT_PTR|5.008000||Viu +USE_STAT_BLOCKS|5.005003|5.005003|Vn +USE_STAT_RDEV|5.003007||Viu +USE_STDIO|5.003007||Viu +USE_STDIO_BASE|5.006000|5.006000|Vn +USE_STDIO_PTR|5.006000|5.006000|Vn +USE_SYSTEM_GMTIME|5.011000||Viu +USE_SYSTEM_LOCALTIME|5.011000||Viu +USE_THREADS|5.006000|5.006000|Vn +USE_THREAD_SAFE_LOCALE|5.025004||Viu +USE_TM64|5.011000||Viu +USE_UTF8_IN_NAMES|5.007003||Viu +utf16_textfilter|5.011001||Viu +utf16_to_utf8|5.035004||cViu +utf16_to_utf8_base|5.035004||cViu +utf16_to_utf8_reversed|5.035004||cViu +UTF8_ACCUMULATE|5.007001||Viu +UTF8_ALLOW_ANY|5.007001||Viu +UTF8_ALLOW_ANYUV|5.007001||Viu +UTF8_ALLOW_CONTINUATION|5.007001||Viu +UTF8_ALLOW_DEFAULT|5.009004||Viu +UTF8_ALLOW_EMPTY|5.007001||Viu +UTF8_ALLOW_FE_FF|5.027009||Viu +UTF8_ALLOW_FFFF|5.007001||Viu +UTF8_ALLOW_LONG|5.007001||Viu +UTF8_ALLOW_LONG_AND_ITS_VALUE|5.025009||Viu +UTF8_ALLOW_NON_CONTINUATION|5.007001||Viu +UTF8_ALLOW_OVERFLOW|5.025009||Viu +UTF8_ALLOW_SHORT|5.007001||Viu +UTF8_ALLOW_SURROGATE|5.007001||Viu +UTF8_CHECK_ONLY|5.007001|5.007001| +UTF8_CHK_SKIP|5.031006|5.006000|p +UTF8_DISALLOW_ABOVE_31_BIT|5.023006||Viu +UTF8_DISALLOW_FE_FF|5.013009||Viu +UTF8_DISALLOW_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| +UTF8_DISALLOW_ILLEGAL_INTERCHANGE|5.013009|5.013009| +UTF8_DISALLOW_NONCHAR|5.013009|5.013009| +UTF8_DISALLOW_PERL_EXTENDED|5.027002|5.027002| +UTF8_DISALLOW_SUPER|5.013009|5.013009| +UTF8_DISALLOW_SURROGATE|5.013009|5.013009| +utf8_distance|5.006000|5.006000| +UTF8_EIGHT_BIT_HI|5.007001||Viu +UTF8_EIGHT_BIT_LO|5.007001||Viu +UTF8f|5.019001|5.003007|p +UTF8fARG|5.019002|5.003007|p +UTF8_GOT_ABOVE_31_BIT|5.025006||Viu +UTF8_GOT_CONTINUATION|5.025006|5.025006| +UTF8_GOT_EMPTY|5.025006|5.025006| +UTF8_GOT_LONG|5.025006|5.025006| +UTF8_GOT_NONCHAR|5.025006|5.025006| +UTF8_GOT_NON_CONTINUATION|5.025006|5.025006| +UTF8_GOT_OVERFLOW|5.025006|5.025006| +UTF8_GOT_PERL_EXTENDED|5.027002|5.027002| +UTF8_GOT_SHORT|5.025006|5.025006| +UTF8_GOT_SUPER|5.025006|5.025006| +UTF8_GOT_SURROGATE|5.025006|5.025006| +utf8_hop|5.006000|5.006000|n +utf8_hop_back|5.025007|5.025007|n +utf8_hop_forward|5.025007|5.025007|n +utf8_hop_safe|5.025007|5.025007|n +UTF8_IS_ABOVE_LATIN1|5.017004||Viu +UTF8_IS_ABOVE_LATIN1_START|5.023003||Viu +UTF8_IS_CONTINUATION|5.007001||Viu +UTF8_IS_CONTINUED|5.007001||Viu +UTF8_IS_DOWNGRADEABLE_START|5.007001||Viu +UTF8_IS_INVARIANT|5.007001|5.003007|p +UTF8_IS_NEXT_CHAR_DOWNGRADEABLE|5.017006||Viu +UTF8_IS_NONCHAR|5.023002|5.023002| +UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC|5.013009||Viu +UTF8_IS_PERL_EXTENDED|5.035004||Viu +UTF8_IS_REPLACEMENT||| +UTF8_IS_START|5.007001||Viu +UTF8_IS_START_base|5.031007||Viu +UTF8_IS_SUPER|5.023002|5.023002| +UTF8_IS_SURROGATE|5.023002|5.023002| +utf8_length|5.007001|5.007001| +UTF8_MAXBYTES|5.009002|5.006000|p +UTF8_MAXBYTES_CASE|5.009002|5.003007|p +UTF8_MAX_FOLD_CHAR_EXPAND|5.013009||Viu +UTF8_MAXLEN|5.006000||Viu +utf8_mg_len_cache_update|5.013003||Viu +utf8_mg_pos_cache_update|5.009004||Viu +utf8n_to_uvchr|5.007001|5.007001|n +utf8n_to_uvchr_error|5.025006|5.025006|n +utf8n_to_uvchr_msgs|5.027009|5.027009|n +_utf8n_to_uvchr_msgs_helper|5.029001||cVnu +utf8n_to_uvuni|5.007001||dcV +UTF8_SAFE_SKIP|5.029009|5.006000|p +UTF8SKIP|5.006000|5.006000| +UTF8_SKIP|5.023002|5.006000|p +utf8_to_bytes|5.006001|5.006001|x +utf8_to_utf16|5.035004||Viu +utf8_to_utf16_base|5.035004||xcViu +utf8_to_utf16_reversed|5.035004||Viu +utf8_to_uvchr|5.007001|5.006001|pd +utf8_to_uvchr_buf|5.015009|5.006001|p +utf8_to_uvchr_buf_helper|5.031004||cVu +utf8_to_uvuni|5.007001||dcV +utf8_to_uvuni_buf|5.015009||dcV +UTF8_TWO_BYTE_HI|5.011002||Viu +UTF8_TWO_BYTE_HI_nocast|5.011002||Viu +UTF8_TWO_BYTE_LO|5.011002||Viu +UTF8_TWO_BYTE_LO_nocast|5.011002||Viu +UTF8_WARN_ABOVE_31_BIT|5.023006||Viu +UTF8_WARN_FE_FF|5.013009||Viu +UTF8_WARN_ILLEGAL_C9_INTERCHANGE|5.025005|5.025005| +UTF8_WARN_ILLEGAL_INTERCHANGE|5.013009|5.013009| +UTF8_WARN_NONCHAR|5.013009|5.013009| +UTF8_WARN_PERL_EXTENDED|5.027002|5.027002| +UTF8_WARN_SUPER|5.013009|5.013009| +UTF8_WARN_SURROGATE|5.013009|5.013009| +UTF_ACCUMULATION_SHIFT|5.007001||Viu +UTF_CONTINUATION_BYTE_INFO_BITS|5.035004||Viu +UTF_CONTINUATION_MARK|5.007001||Viu +UTF_CONTINUATION_MASK|5.007001||Viu +UTF_EBCDIC_CONTINUATION_BYTE_INFO_BITS|5.035004||Viu +UTF_FIRST_CONT_BYTE_110000|5.035004||Viu +UTF_FIRST_CONT_BYTE|5.035004||Viu +UTF_IS_CONTINUATION_MASK|5.023006||Viu +UTF_MIN_ABOVE_LATIN1_BYTE|5.031006||Viu +UTF_MIN_CONTINUATION_BYTE|5.035004||Viu +UTF_MIN_START_BYTE|5.031006||Viu +UTF_START_BYTE_110000|5.035004||Viu +UTF_START_BYTE|5.035004||Viu +UTF_START_MARK|5.007001||Viu +UTF_START_MASK|5.007001||Viu +UTF_TO_NATIVE|5.007001||Viu +utilize|5.003007||Viu +utime|5.005000||Viu +U_V|5.006000|5.003007| +UVCHR_IS_INVARIANT|5.019004|5.003007|p +UVCHR_SKIP|5.022000|5.003007|p +uvchr_to_utf8|5.007001|5.007001| +uvchr_to_utf8_flags|5.007003|5.007003| +uvchr_to_utf8_flags_msgs|5.027009|5.027009| +UV_DIG|5.006000||Viu +UVf|5.010000|5.010000|d +UV_IS_QUAD|5.006000||Viu +UV_MAX|5.003007|5.003007| +UV_MAX_P1|5.007002||Viu +UV_MAX_P1_HALF|5.007002||Viu +UV_MIN|5.003007|5.003007| +UVof|5.006000|5.003007|poVn +uvoffuni_to_utf8_flags|5.027009||cV +uvoffuni_to_utf8_flags_msgs|5.027009||cVu +UVSIZE|5.006000|5.003007|poVn +UVTYPE|5.006000|5.003007|poVn +UVuf|5.006000|5.003007|poVn +uvuni_to_utf8|5.019004||cVu +uvuni_to_utf8_flags|5.007003||dcV +UVxf|5.006000|5.003007|poVn +UVXf|5.007001|5.007001|poVn +VAL_EAGAIN|5.003007|5.003007|Vn +validate_proto|5.019002||xcVi +validate_suid|||iu +valid_utf8_to_uvchr|5.015009||cVn +valid_utf8_to_uvuni|5.015009||dcVu +VAL_O_NONBLOCK|5.003007|5.003007|Vn +variant_byte_number|5.031004||cVnu +variant_under_utf8_count|5.027007||Vni +varname|5.009003||Viu +vcmp|5.009000|5.009000| +VCMP|5.019008||Viu +vcroak|5.006000|5.006000| +vdeb|5.007003|5.007003|u +VERB|5.009005||Viu +VERB_t8|5.035004||Viu +VERB_t8_p8|5.033003||Viu +VERB_t8_pb|5.033003||Viu +VERB_tb|5.035004||Viu +VERB_tb_p8|5.033003||Viu +VERB_tb_pb|5.033003||Viu +vform|5.006000|5.006000| +vfprintf|5.003007||Viu +visit|5.005000||Viu +vivify_defelem|5.004000||cViu +vivify_ref|5.004000||Viu +vload_module|5.006000|5.003007|p +vmess|5.006000|5.004000|p +vnewSVpvf|5.006000|5.004000|p +vnormal|5.009002|5.009002| +VNORMAL|5.019008||Viu +vnumify|5.009000|5.009000| +VNUMIFY|5.019008||Viu +voidnonfinal|5.035002||Viu +VOL|5.003007||Viu +vstringify|5.009000|5.009000| +VSTRINGIFY|5.019008||Viu +VTBL_amagic|5.005003||Viu +VTBL_amagicelem|5.005003||Viu +VTBL_arylen|5.005003||Viu +VTBL_bm|5.005003||Viu +VTBL_collxfrm|5.005003||Viu +VTBL_dbline|5.005003||Viu +VTBL_defelem|5.005003||Viu +VTBL_env|5.005003||Viu +VTBL_envelem|5.005003||Viu +VTBL_fm|5.005003||Viu +VTBL_glob|5.005003||Viu +VTBL_isa|5.005003||Viu +VTBL_isaelem|5.005003||Viu +VTBL_mglob|5.005003||Viu +VTBL_nkeys|5.005003||Viu +VTBL_pack|5.005003||Viu +VTBL_packelem|5.005003||Viu +VTBL_pos|5.005003||Viu +VTBL_regdata|5.006000||Viu +VTBL_regdatum|5.006000||Viu +VTBL_regexp|5.005003||Viu +VTBL_sigelem|5.005003||Viu +VTBL_substr|5.005003||Viu +VTBL_sv|5.005003||Viu +VTBL_taint|5.005003||Viu +VTBL_uvar|5.005003||Viu +VTBL_vec|5.005003||Viu +vTHX|5.006000||Viu +VT_NATIVE|5.021004||Viu +vtohl|5.003007||Viu +vtohs|5.003007||Viu +VUTIL_REPLACE_CORE|5.019008||Viu +vverify|5.009003|5.009003| +VVERIFY|5.019008||Viu +vwarn|5.006000|5.003007| +vwarner|5.006000|5.004000|p +wait4pid|5.003007||Viu +wait|5.005000||Viu +want_vtbl_bm|5.015000||Viu +want_vtbl_fm|5.015000||Viu +warn|5.003007||vV +WARN_ALL|5.006000|5.003007|p +WARN_ALLstring|5.006000||Viu +WARN_AMBIGUOUS|5.006000|5.003007|p +WARN_ASSERTIONS||5.003007|ponu +WARN_BAREWORD|5.006000|5.003007|p +WARN_CLOSED|5.006000|5.003007|p +WARN_CLOSURE|5.006000|5.003007|p +WARN_DEBUGGING|5.006000|5.003007|p +WARN_DEPRECATED|5.006000|5.003007|p +WARN_DIGIT|5.006000|5.003007|p +warner|5.006000||pvV +warner_nocontext|5.006000||vVn +WARN_EXEC|5.006000|5.003007|p +WARN_EXITING|5.006000|5.003007|p +WARN_EXPERIMENTAL|5.017004|5.017004| +WARN_EXPERIMENTAL__ALPHA_ASSERTIONS|5.027009|5.027009| +WARN_EXPERIMENTAL__ARGS_ARRAY_WITH_SIGNATURES|5.035009|5.035009| +WARN_EXPERIMENTAL__BITWISE|5.021009|5.021009| +WARN_EXPERIMENTAL__BUILTIN|5.035009|5.035009| +WARN_EXPERIMENTAL__CONST_ATTR|5.021008|5.021008| +WARN_EXPERIMENTAL__DECLARED_REFS|5.025003|5.025003| +WARN_EXPERIMENTAL__DEFER|5.035004|5.035004| +WARN_EXPERIMENTAL__FOR_LIST|5.035005|5.035005| +WARN_EXPERIMENTAL__ISA|5.031007|5.031007| +WARN_EXPERIMENTAL__LEXICAL_SUBS|5.017005|5.017005| +WARN_EXPERIMENTAL__POSTDEREF|5.019005|5.019005| +WARN_EXPERIMENTAL__PRIVATE_USE|5.029009|5.029009| +WARN_EXPERIMENTAL__REFALIASING|5.021005|5.021005| +WARN_EXPERIMENTAL__REGEX_SETS|5.017008|5.017008| +WARN_EXPERIMENTAL__RE_STRICT|5.021008|5.021008| +WARN_EXPERIMENTAL__SCRIPT_RUN|5.027008|5.027008| +WARN_EXPERIMENTAL__SIGNATURES|5.019009|5.019009| +WARN_EXPERIMENTAL__SMARTMATCH|5.017011|5.017011| +WARN_EXPERIMENTAL__TRY|5.033007|5.033007| +WARN_EXPERIMENTAL__UNIPROP_WILDCARDS|5.029009|5.029009| +WARN_EXPERIMENTAL__VLB|5.029009|5.029009| +WARN_GLOB|5.006000|5.003007|p +WARN_ILLEGALPROTO|5.011004|5.011004| +WARN_IMPRECISION|5.011000|5.011000| +WARN_INPLACE|5.006000|5.003007|p +WARN_INTERNAL|5.006000|5.003007|p +WARN_IO|5.006000|5.003007|p +WARN_LAYER|5.008000|5.003007|p +WARN_LOCALE|5.021006|5.021006| +WARN_MALLOC|5.006000|5.003007|p +WARN_MISC|5.006000|5.003007|p +WARN_MISSING|5.021002|5.021002| +WARN_NEWLINE|5.006000|5.003007|p +warn_nocontext|5.006000||pvVn +WARN_NONCHAR|5.013010|5.013010| +WARN_NONEstring|5.006000||Viu +WARN_NON_UNICODE|5.013010|5.013010| +WARN_NUMERIC|5.006000|5.003007|p +WARN_ONCE|5.006000|5.003007|p +warn_on_first_deprecated_use|5.025009||Viu +WARN_OVERFLOW|5.006000|5.003007|p +WARN_PACK|5.006000|5.003007|p +WARN_PARENTHESIS|5.006000|5.003007|p +WARN_PIPE|5.006000|5.003007|p +WARN_PORTABLE|5.006000|5.003007|p +WARN_PRECEDENCE|5.006000|5.003007|p +WARN_PRINTF|5.006000|5.003007|p +_warn_problematic_locale|5.021008||cVniu +WARN_PROTOTYPE|5.006000|5.003007|p +WARN_QW|5.006000|5.003007|p +WARN_RECURSION|5.006000|5.003007|p +WARN_REDEFINE|5.006000|5.003007|p +WARN_REDUNDANT|5.021002|5.021002| +WARN_REGEXP|5.006000|5.003007|p +WARN_RESERVED|5.006000|5.003007|p +WARN_SEMICOLON|5.006000|5.003007|p +WARN_SEVERE|5.006000|5.003007|p +WARN_SHADOW|5.027007|5.027007| +WARNshift|5.011001||Viu +WARN_SIGNAL|5.006000|5.003007|p +WARNsize|5.006000||Viu +WARN_SUBSTR|5.006000|5.003007|p +WARN_SURROGATE|5.013010|5.013010| +warn_sv|5.013001|5.003007|p +WARN_SYNTAX|5.006000|5.003007|p +WARN_SYSCALLS|5.019004|5.019004| +WARN_TAINT|5.006000|5.003007|p +WARN_THREADS|5.008000|5.003007|p +WARN_UNINITIALIZED|5.006000|5.003007|p +WARN_UNOPENED|5.006000|5.003007|p +WARN_UNPACK|5.006000|5.003007|p +WARN_UNTIE|5.006000|5.003007|p +WARN_UTF8|5.006000|5.003007|p +WARN_VOID|5.006000|5.003007|p +was_lvalue_sub|||ciu +watch|5.003007||Viu +WB_BREAKABLE|5.023008||Viu +WB_DQ_then_HL|5.023008||Viu +WB_Ex_or_FO_or_ZWJ_then_foo|5.025003||Viu +WB_HL_then_DQ|5.023008||Viu +WB_hs_then_hs|5.023008||Viu +WB_LE_or_HL_then_MB_or_ML_or_SQ|5.023008||Viu +WB_MB_or_ML_or_SQ_then_LE_or_HL|5.023008||Viu +WB_MB_or_MN_or_SQ_then_NU|5.023008||Viu +WB_NOBREAK|5.023008||Viu +WB_NU_then_MB_or_MN_or_SQ|5.023008||Viu +WB_RI_then_RI|5.025003||Viu +WCTOMB_LOCK|5.033005||Viu +WCTOMB_UNLOCK|5.033005||Viu +what_MULTI_CHAR_FOLD_latin1_safe|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part0|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part1|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part2|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part3|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part4|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part5|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part6|5.033005||Viu +what_MULTI_CHAR_FOLD_utf8_safe_part7|5.033005||Viu +whichsig|5.003007|5.003007| +whichsig_pv|5.015004|5.015004| +whichsig_pvn|5.015004|5.015004| +whichsig_sv|5.015004|5.015004| +WHILEM|5.003007||Viu +WHILEM_A_max|5.009005||Viu +WHILEM_A_max_fail|5.009005||Viu +WHILEM_A_max_fail_t8|5.035004||Viu +WHILEM_A_max_fail_t8_p8|5.033003||Viu +WHILEM_A_max_fail_t8_pb|5.033003||Viu +WHILEM_A_max_fail_tb|5.035004||Viu +WHILEM_A_max_fail_tb_p8|5.033003||Viu +WHILEM_A_max_fail_tb_pb|5.033003||Viu +WHILEM_A_max_t8|5.035004||Viu +WHILEM_A_max_t8_p8|5.033003||Viu +WHILEM_A_max_t8_pb|5.033003||Viu +WHILEM_A_max_tb|5.035004||Viu +WHILEM_A_max_tb_p8|5.033003||Viu +WHILEM_A_max_tb_pb|5.033003||Viu +WHILEM_A_min|5.009005||Viu +WHILEM_A_min_fail|5.009005||Viu +WHILEM_A_min_fail_t8|5.035004||Viu +WHILEM_A_min_fail_t8_p8|5.033003||Viu +WHILEM_A_min_fail_t8_pb|5.033003||Viu +WHILEM_A_min_fail_tb|5.035004||Viu +WHILEM_A_min_fail_tb_p8|5.033003||Viu +WHILEM_A_min_fail_tb_pb|5.033003||Viu +WHILEM_A_min_t8|5.035004||Viu +WHILEM_A_min_t8_p8|5.033003||Viu +WHILEM_A_min_t8_pb|5.033003||Viu +WHILEM_A_min_tb|5.035004||Viu +WHILEM_A_min_tb_p8|5.033003||Viu +WHILEM_A_min_tb_pb|5.033003||Viu +WHILEM_A_pre|5.009005||Viu +WHILEM_A_pre_fail|5.009005||Viu +WHILEM_A_pre_fail_t8|5.035004||Viu +WHILEM_A_pre_fail_t8_p8|5.033003||Viu +WHILEM_A_pre_fail_t8_pb|5.033003||Viu +WHILEM_A_pre_fail_tb|5.035004||Viu +WHILEM_A_pre_fail_tb_p8|5.033003||Viu +WHILEM_A_pre_fail_tb_pb|5.033003||Viu +WHILEM_A_pre_t8|5.035004||Viu +WHILEM_A_pre_t8_p8|5.033003||Viu +WHILEM_A_pre_t8_pb|5.033003||Viu +WHILEM_A_pre_tb|5.035004||Viu +WHILEM_A_pre_tb_p8|5.033003||Viu +WHILEM_A_pre_tb_pb|5.033003||Viu +WHILEM_B_max|5.009005||Viu +WHILEM_B_max_fail|5.009005||Viu +WHILEM_B_max_fail_t8|5.035004||Viu +WHILEM_B_max_fail_t8_p8|5.033003||Viu +WHILEM_B_max_fail_t8_pb|5.033003||Viu +WHILEM_B_max_fail_tb|5.035004||Viu +WHILEM_B_max_fail_tb_p8|5.033003||Viu +WHILEM_B_max_fail_tb_pb|5.033003||Viu +WHILEM_B_max_t8|5.035004||Viu +WHILEM_B_max_t8_p8|5.033003||Viu +WHILEM_B_max_t8_pb|5.033003||Viu +WHILEM_B_max_tb|5.035004||Viu +WHILEM_B_max_tb_p8|5.033003||Viu +WHILEM_B_max_tb_pb|5.033003||Viu +WHILEM_B_min|5.009005||Viu +WHILEM_B_min_fail|5.009005||Viu +WHILEM_B_min_fail_t8|5.035004||Viu +WHILEM_B_min_fail_t8_p8|5.033003||Viu +WHILEM_B_min_fail_t8_pb|5.033003||Viu +WHILEM_B_min_fail_tb|5.035004||Viu +WHILEM_B_min_fail_tb_p8|5.033003||Viu +WHILEM_B_min_fail_tb_pb|5.033003||Viu +WHILEM_B_min_t8|5.035004||Viu +WHILEM_B_min_t8_p8|5.033003||Viu +WHILEM_B_min_t8_pb|5.033003||Viu +WHILEM_B_min_tb|5.035004||Viu +WHILEM_B_min_tb_p8|5.033003||Viu +WHILEM_B_min_tb_pb|5.033003||Viu +WHILEM_t8|5.035004||Viu +WHILEM_t8_p8|5.033003||Viu +WHILEM_t8_pb|5.033003||Viu +WHILEM_tb|5.035004||Viu +WHILEM_tb_p8|5.033003||Viu +WHILEM_tb_pb|5.033003||Viu +WIDEST_UTYPE|5.015004|5.003007|poVnu +win32_croak_not_implemented|5.017006||Vniu +WIN32SCK_IS_STDSCK|5.007001||Viu +win32_setlocale|5.027006||Viu +withinCOUNT|5.031004||Viu +withinCOUNT_KNOWN_VALID|5.033005||Viu +WITH_LC_NUMERIC_SET_TO_NEEDED|5.031003|5.031003| +WITH_LC_NUMERIC_SET_TO_NEEDED_IN|5.031003|5.031003| +with_queued_errors|5.013001||Viu +with_tp_UTF8ness|5.033003||Viu +with_t_UTF8ness|5.035004||Viu +wrap_keyword_plugin|5.027006|5.027006|x +wrap_op_checker|5.015008|5.015008| +write|5.005000||Viu +write_to_stderr|5.008001||Viu +XCPT_CATCH|5.009002|5.003007|p +XCPT_RETHROW|5.009002|5.003007|p +XCPT_TRY_END|5.009002|5.003007|p +XCPT_TRY_START|5.009002|5.003007|p +XDIGIT_VALUE|5.019008||Viu +xio_any|5.006001||Viu +xio_dirp|5.006001||Viu +xiv_iv|5.009003||Viu +xlv_targoff|5.019004||Viu +XopDISABLE|5.013007|5.013007|V +XOPd_xop_class|5.013007||Viu +XOPd_xop_desc|5.013007||Viu +XOPd_xop_name|5.013007||Viu +XOPd_xop_peep|5.013007||Viu +XopENABLE|5.013007|5.013007|V +XopENTRY|5.013007|5.013007|V +XopENTRYCUSTOM|5.019006|5.013007|V +XopENTRY_set|5.013007|5.013007|V +XopFLAGS|5.013007|5.013007| +XOPf_xop_class|5.013007||Viu +XOPf_xop_desc|5.013007||Viu +XOPf_xop_name|5.013007||Viu +XOPf_xop_peep|5.013007||Viu +XORSHIFT128_set|5.027001||Viu +XORSHIFT96_set|5.027001||Viu +XPUSHi|5.003007|5.003007| +XPUSHmortal|5.009002|5.003007|p +XPUSHn|5.006000|5.003007| +XPUSHp|5.003007|5.003007| +XPUSHs|5.003007|5.003007| +XPUSHTARG|5.003007||Viu +XPUSHu|5.004000|5.003007|p +XPUSHundef|5.006000||Viu +xpv_len|5.017006||Viu +XS|5.003007|5.003007|Vu +XSANY|5.003007||Viu +XS_APIVERSION_BOOTCHECK|5.013004|5.013004| +XS_APIVERSION_POPMARK_BOOTCHECK|5.021006||Viu +XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK|5.021006||Viu +xs_boot_epilog|5.021006||cViu +XS_BOTHVERSION_BOOTCHECK|5.021006||Viu +XS_BOTHVERSION_POPMARK_BOOTCHECK|5.021006||Viu +XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK|5.021006||Viu +XS_DYNAMIC_FILENAME|5.009004||Viu +XS_EXTERNAL|5.015002|5.015002|Vu +xs_handshake|||vcniu +XSINTERFACE_CVT|5.005000||Viu +XSINTERFACE_CVT_ANON|5.010000||Viu +XSINTERFACE_FUNC|5.005000||Viu +XSINTERFACE_FUNC_SET|5.005000||Viu +XS_INTERNAL|5.015002|5.015002|Vu +XSprePUSH|5.006000|5.003007|poVnu +XSPROTO|5.010000|5.003007|pVu +XSRETURN|5.003007|5.003007|p +XSRETURN_EMPTY|5.003007|5.003007| +XSRETURN_IV|5.003007|5.003007| +XSRETURN_NO|5.003007|5.003007| +XSRETURN_NV|5.006000|5.003007| +XSRETURN_PV|5.003007|5.003007| +XSRETURN_PVN|5.006000||Viu +XSRETURN_UNDEF|5.003007|5.003007| +XSRETURN_UV|5.008001|5.003007|p +XSRETURN_YES|5.003007|5.003007| +XS_SETXSUBFN_POPMARK|5.021006||Viu +XST_mIV|5.003007|5.003007| +XST_mNO|5.003007|5.003007| +XST_mNV|5.006000|5.003007| +XST_mPV|5.003007|5.003007| +XST_mPVN|5.006000||Viu +XST_mUNDEF|5.003007|5.003007| +XST_mUV|5.008001|5.003007|p +XST_mYES|5.003007|5.003007| +XS_VERSION|5.003007|5.003007| +XS_VERSION_BOOTCHECK|5.003007|5.003007| +xs_version_bootcheck|||iu +XTENDED_PAT_MOD|5.009005||Viu +xuv_uv|5.009003||Viu +YESEXPR|5.027010||Viu +YESSTR|5.027010||Viu +YIELD|5.005000||Viu +YYDEBUG|5.025006||Viu +YYEMPTY|5.009005||Viu +yyerror|5.003007||Viu +yyerror_pv|5.016000||Viu +yyerror_pvn|5.016000||Viu +yylex|5.003007||cViu +yyparse|5.003007||Viu +yyquit|5.025010||Viu +YYSTYPE_IS_DECLARED|5.009001||Viu +YYSTYPE_IS_TRIVIAL|5.009001||Viu +YYTOKENTYPE|5.009001||Viu +yyunlex|5.013005||Viu +yywarn|5.003007||Viu +ZAPHOD32_FINALIZE|5.027001||Viu +ZAPHOD32_MIX|5.027001||Viu +ZAPHOD32_SCRAMBLE32|5.027001||Viu +ZAPHOD32_STATIC_INLINE|5.027001||Viu +ZAPHOD32_WARN2|5.027001||Viu +ZAPHOD32_WARN3|5.027001||Viu +ZAPHOD32_WARN4|5.027001||Viu +ZAPHOD32_WARN5|5.027001||Viu +ZAPHOD32_WARN6|5.027001||Viu +Zero|5.003007|5.003007| +ZeroD|5.009002|5.003007|p +); + +if (exists $opt{'list-unsupported'}) { + my $f; + for $f (sort dictionary_order keys %API) { + next if $API{$f}{core_only}; + next if $API{$f}{beyond_depr}; + next if $API{$f}{inaccessible}; + next if $API{$f}{experimental}; + next unless $API{$f}{todo}; + next if int_parse_version($API{$f}{todo}) <= $int_min_perl; + my $repeat = 40 - length($f); + $repeat = 0 if $repeat < 0; + print "$f ", '.'x $repeat, " ", format_version($API{$f}{todo}), "\n"; + } + exit 0; +} + +# Scan for hints, possible replacement candidates, etc. + +my(%replace, %need, %hints, %warnings, %depends); +my $replace = 0; +my($hint, $define, $function); + +sub find_api +{ + BEGIN { 'warnings'->unimport('uninitialized') if "$]" > '5.006' } + my $code = shift; + $code =~ s{ + / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]*) + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' }{}egsx; + grep { exists $API{$_} } $code =~ /(\w+)/mg; +} + +while () { + if ($hint) { + + # Here, we are in the middle of accumulating a hint or warning. + my $end_of_hint = 0; + + # A line containing a comment end marker closes the hint. Remove that + # marker for processing below. + if (s/\s*$rcce(.*?)\s*$//) { + die "Nothing can follow the end of comment in '$_'\n" if length $1 > 0; + $end_of_hint = 1; + } + + # Set $h to the hash of which type. + my $h = $hint->[0] eq 'Hint' ? \%hints : \%warnings; + + # Ignore any leading and trailing white space, and an optional star comment + # continuation marker, then place the meat of the line into $1 + m/^\s*(?:\*\s*)?(.*?)\s*$/; + + # Add the meat of this line to the hash value of each API element it + # applies to + for (@{$hint->[1]}) { + $h->{$_} ||= ''; # avoid the warning older perls generate + $h->{$_} .= "$1\n"; + } + + # If the line had a comment close, we are through with this hint + undef $hint if $end_of_hint; + + next; + } + + # Set up $hint if this is the beginning of a Hint: or Warning: + # These are from a multi-line C comment in the file, with the first line + # looking like (a space has been inserted because this file can't have C + # comment markers in it): + # / * Warning: PL_expect, PL_copline, PL_rsfp + # + # $hint becomes + # [ + # 'Warning', + # [ + # 'PL_expect', + # 'PL_copline', + # 'PL_rsfp', + # ], + # ] + if (m{^\s*$rccs\s+(Hint|Warning):\s+(\w+(?:,?\s+\w+)*)\s*$}) { + $hint = [$1, [split /,?\s+/, $2]]; + next; + } + + if ($define) { # If in the middle of a definition... + + # append a continuation line ending with backslash. + if ($define->[1] =~ /\\$/) { + $define->[1] .= $_; + } + else { # Otherwise this line ends the definition, make foo depend on bar + # (and what bar depends on) if its not one of ppp's own constructs + if (exists $API{$define->[0]} && $define->[1] !~ /^DPPP_\(/) { + my @n = find_api($define->[1]); + push @{$depends{$define->[0]}}, @n if @n + } + undef $define; + } + } + + # For '#define foo bar' or '#define foo(a,b,c) bar', $define becomes a + # reference to [ foo, bar ] + $define = [$1, $2] if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(.*)}; + + if ($function) { + if (/^}/) { + if (exists $API{$function->[0]}) { + my @n = find_api($function->[1]); + push @{$depends{$function->[0]}}, @n if @n + } + undef $function; + } + else { + $function->[1] .= $_; + } + } + + $function = [$1, ''] if m{^DPPP_\(my_(\w+)\)}; + + # Set $replace to the number given for lines that look like + # / * Replace: \d+ * / + # Thus setting it to 1 starts a region where replacements are automatically + # done, and setting it to 0 ends that region. + $replace = $1 if m{^\s*$rccs\s+Replace:\s+(\d+)\s+$rcce\s*$}; + + # Add bar => foo to %replace for lines like '#define foo bar in a region + # where $replace is non-zero + $replace{$2} = $1 if $replace and m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+)}; + + # Add bar => foo to %replace for lines like '#define foo bar / * Replace * / + $replace{$2} = $1 if m{^\s*#\s*define\s+(\w+)(?:\([^)]*\))?\s+(\w+).*$rccs\s+Replace\s+$rcce}; + + # Add foo => bar to %replace for lines like / * Replace foo with bar * / + $replace{$1} = $2 if m{^\s*$rccs\s+Replace (\w+) with (\w+.*?)\s+$rcce\s*$}; + + # For lines like / * foo, bar depends on baz, bat * / + # create a list of the elements on the rhs, and make that list apply to each + # element in the lhs, which becomes a key in \%depends. + if (m{^\s*$rccs\s+(\w+(\s*,\s*\w+)*)\s+depends\s+on\s+(\w+(\s*,\s*\w+)*)\s+$rcce\s*$}) { + my @deps = map { s/\s+//g; $_ } split /,/, $3; + my $d; + for $d (map { s/\s+//g; $_ } split /,/, $1) { + push @{$depends{$d}}, @deps; + } + } + + $need{$1} = 1 if m{^#if\s+defined\(NEED_(\w+)(?:_GLOBAL)?\)}; +} + +for (values %depends) { + my %seen; + $_ = [sort dictionary_order grep !$seen{$_}++, @$_]; +} + +if (exists $opt{'api-info'}) { + my $f; + my $count = 0; + my $match = $opt{'api-info'} =~ m!^/(.*)/$! ? $1 : "^\Q$opt{'api-info'}\E\$"; + + # Sort the names, and split into two classes; one for things that are part of + # the API; a second for things that aren't. + my @ok_to_use; + my @shouldnt_use; + for $f (sort dictionary_order keys %API) { + next unless $f =~ /$match/; + my $base = int_parse_version($API{$f}{base}) if $API{$f}{base}; + if ($base && ! $API{$f}{inaccessible} && ! $API{$f}{core_only}) { + push @ok_to_use, $f; + } + else { + push @shouldnt_use, $f; + } + } + + # We normally suppress non-API items. But if the search matched no API + # items, output the non-ones. This allows someone to get the info for an + # item if they ask for it specifically enough, but doesn't normally clutter + # the output with irrelevant results. + @ok_to_use = @shouldnt_use unless @ok_to_use; + + for $f (@ok_to_use) { + print "\n=== $f ===\n"; + my $info = 0; + my $base; + $base = int_parse_version($API{$f}{base}) if $API{$f}{base}; + my $todo; + $todo = int_parse_version($API{$f}{todo}) if $API{$f}{todo}; + + # Output information + if ($base) { + my $with_or= ""; + if ( $base <= $int_min_perl + || ( (! $API{$f}{provided} && ! $todo) + || ($todo && $todo >= $base))) + { + $with_or= " with or"; + } + + my $Supported = ($API{$f}{undocumented}) ? 'Available' : 'Supported'; + print "\n$Supported at least since perl-", + format_version($base), ",$with_or without $ppport."; + if ($API{$f}{unverified}) { + print "\nThis information is based on inspection of the source code", + " and has not been\n", + "verified by successful compilation."; + } + print "\n"; + $info++; + } + if ($API{$f}{provided} || $todo) { + print "\nThis is only supported by $ppport, and NOT by perl versions going forward.\n" unless $base; + if ($todo) { + if (! $base || $todo < $base) { + my $additionally = ""; + $additionally .= " additionally" if $base; + print "$ppport$additionally provides support at least back to perl-", + format_version($todo), + ".\n"; + } + } + elsif (! $base || $base > $int_min_perl) { + if (exists $depends{$f}) { + my $max = 0; + for (@{$depends{$f}}) { + $max = int_parse_version($API{$_}{todo}) if $API{$_}{todo} && $API{$_}{todo} > $max; + # XXX What to assume unspecified values are? This effectively makes them MIN_PERL + } + $todo = $max if $max; + } + print "\n$ppport provides support for this, but ironically, does not", + " currently know,\n", + "for this report, the minimum version it supports for this"; + if ($API{$f}{undocumented}) { + print " and many things\n", + "it provides that are implemented as macros and aren't", + " documented. You can\n", + "help by submitting a documentation patch"; + } + print ".\n"; + if ($todo) { + if ($todo <= $int_min_perl) { + print "It may very well be supported all the way back to ", + format_version(5.003_07), ".\n"; + } + else { + print "But given the things $f depends on, it's a good", + " guess that it isn't\n", + "supported prior to ", format_version($todo), ".\n"; + } + } + } + } + if ($API{$f}{provided}) { + print "Support needs to be explicitly requested by #define NEED_$f\n", + "(or #define NEED_${f}_GLOBAL).\n" if exists $need{$f}; + $info++; + } + + if ($base || ! $API{$f}{ppport_fnc}) { + my $email = "Send email to perl5-porters\@perl.org if you need to have this functionality.\n"; + if ($API{$f}{inaccessible}) { + print "\nThis is not part of the public API, and may not even be accessible to XS code.\n"; + $info++; + } + elsif ($API{$f}{core_only}) { + print "\nThis is not part of the public API, and should not be used by XS code.\n"; + $info++; + } + elsif ($API{$f}{deprecated}) { + print "\nThis is deprecated and should not be used. Convert existing uses.\n"; + $info++; + } + elsif ($API{$f}{experimental}) { + print "\nThe API for this is unstable and should not be used by XS code.\n", $email; + $info++; + } + elsif ($API{$f}{undocumented}) { + print "\nSince this is undocumented, the API should be considered unstable.\n"; + if ($API{$f}{provided}) { + print "Consider bringing this up on the list: perl5-porters\@perl.org.\n"; + } + else { + print "It may be that this is not intended for XS use, or it may just be\n", + "that no one has gotten around to documenting it.\n", $email; + } + $info++; + } + unless ($info) { + print "No portability information available. Check your spelling; or", + " this could be\na bug in Devel::PPPort. To report an issue:\n", + "https://github.com/Dual-Life/Devel-PPPort/issues/new\n"; + } + } + + print "\nDepends on: ", join(', ', @{$depends{$f}}), ".\n" + if exists $depends{$f}; + if (exists $hints{$f} || exists $warnings{$f}) { + print "\n$hints{$f}" if exists $hints{$f}; + print "\nWARNING:\n$warnings{$f}" if exists $warnings{$f}; + $info++; + } + $count++; + } + + $count or print "\nFound no API matching '$opt{'api-info'}'."; + print "\n"; + exit 0; +} + +if (exists $opt{'list-provided'}) { + my $f; + for $f (sort dictionary_order keys %API) { + next unless $API{$f}{provided}; + my @flags; + push @flags, 'explicit' if exists $need{$f}; + push @flags, 'depend' if exists $depends{$f}; + push @flags, 'hint' if exists $hints{$f}; + push @flags, 'warning' if exists $warnings{$f}; + my $flags = @flags ? ' ['.join(', ', @flags).']' : ''; + print "$f$flags\n"; + } + exit 0; +} + +my @files; +my @srcext = qw( .xs .c .h .cc .cpp -c.inc -xs.inc ); +my $srcext = join '|', map { quotemeta $_ } @srcext; + +if (@ARGV) { + my %seen; + for (@ARGV) { + if (-e) { + if (-f) { + push @files, $_ unless $seen{$_}++; + } + else { warn "'$_' is not a file.\n" } + } + else { + my @new = grep { -f } glob $_ + or warn "'$_' does not exist.\n"; + push @files, grep { !$seen{$_}++ } @new; + } + } +} +else { + eval { + require File::Find; + File::Find::find(sub { + $File::Find::name =~ /($srcext)$/i + and push @files, $File::Find::name; + }, '.'); + }; + if ($@) { + @files = map { glob "*$_" } @srcext; + } +} + +if (!@ARGV || $opt{filter}) { + my(@in, @out); + my %xsc = map { /(.*)\.xs$/ ? ("$1.c" => 1, "$1.cc" => 1) : () } @files; + for (@files) { + my $out = exists $xsc{$_} || /\b\Q$ppport\E$/i || !/($srcext)$/i; + push @{ $out ? \@out : \@in }, $_; + } + if (@ARGV && @out) { + warning("Skipping the following files (use --nofilter to avoid this):\n| ", join "\n| ", @out); + } + @files = @in; +} + +die "No input files given!\n" unless @files; + +my(%files, %global, %revreplace); +%revreplace = reverse %replace; +my $filename; +my $patch_opened = 0; + +for $filename (@files) { + unless (open IN, "<$filename") { + warn "Unable to read from $filename: $!\n"; + next; + } + + info("Scanning $filename ..."); + + my $c = do { local $/; }; + close IN; + + my %file = (orig => $c, changes => 0); + + # Temporarily remove C/XS comments and strings from the code + my @ccom; + + $c =~ s{ + ( ^$HS*\#$HS*include\b[^\r\n]+\b(?:\Q$ppport\E|XSUB\.h)\b[^\r\n]* + | ^$HS*\#$HS*(?:define|elif|if(?:def)?)\b[^\r\n]* ) + | ( ^$HS*\#[^\r\n]* + | "[^"\\]*(?:\\.[^"\\]*)*" + | '[^'\\]*(?:\\.[^'\\]*)*' + | / (?: \*[^*]*\*+(?:[^$ccs][^*]*\*+)* / | /[^\r\n]* ) ) + }{ defined $2 and push @ccom, $2; + defined $1 ? $1 : "$ccs$#ccom$cce" }mgsex; + + $file{ccom} = \@ccom; + $file{code} = $c; + $file{has_inc_ppport} = $c =~ /^$HS*#$HS*include[^\r\n]+\b\Q$ppport\E\b/m; + + my $func; + + for $func (keys %API) { + my $match = $func; + $match .= "|$revreplace{$func}" if exists $revreplace{$func}; + if ($c =~ /\b(?:Perl_)?($match)\b/) { + $file{uses_replace}{$1}++ if exists $revreplace{$func} && $1 eq $revreplace{$func}; + $file{uses_Perl}{$func}++ if $c =~ /\bPerl_$func\b/; + if (exists $API{$func}{provided}) { + $file{uses_provided}{$func}++; + if ( ! exists $API{$func}{base} + || int_parse_version($API{$func}{base}) > $opt{'compat-version'}) + { + $file{uses}{$func}++; + my @deps = rec_depend($func); + if (@deps) { + $file{uses_deps}{$func} = \@deps; + for (@deps) { + $file{uses}{$_} = 0 unless exists $file{uses}{$_}; + } + } + for ($func, @deps) { + $file{needs}{$_} = 'static' if exists $need{$_}; + } + } + } + if ( exists $API{$func}{todo} + && int_parse_version($API{$func}{todo}) > $opt{'compat-version'}) + { + if ($c =~ /\b$func\b/) { + $file{uses_todo}{$func}++; + } + } + } + } + + while ($c =~ /^$HS*#$HS*define$HS+(NEED_(\w+?)(_GLOBAL)?)\b/mg) { + if (exists $need{$2}) { + $file{defined $3 ? 'needed_global' : 'needed_static'}{$2}++; + } + else { warning("Possibly wrong #define $1 in $filename") } + } + + for (qw(uses needs uses_todo needed_global needed_static)) { + for $func (keys %{$file{$_}}) { + push @{$global{$_}{$func}}, $filename; + } + } + + $files{$filename} = \%file; +} + +# Globally resolve NEED_'s +my $need; +for $need (keys %{$global{needs}}) { + if (@{$global{needs}{$need}} > 1) { + my @targets = @{$global{needs}{$need}}; + my @t = grep $files{$_}{needed_global}{$need}, @targets; + @targets = @t if @t; + @t = grep /\.xs$/i, @targets; + @targets = @t if @t; + my $target = shift @targets; + $files{$target}{needs}{$need} = 'global'; + for (@{$global{needs}{$need}}) { + $files{$_}{needs}{$need} = 'extern' if $_ ne $target; + } + } +} + +for $filename (@files) { + exists $files{$filename} or next; + + info("=== Analyzing $filename ==="); + + my %file = %{$files{$filename}}; + my $func; + my $c = $file{code}; + my $warnings = 0; + + for $func (sort dictionary_order keys %{$file{uses_Perl}}) { + if ($API{$func}{varargs}) { + unless ($API{$func}{noTHXarg}) { + my $changes = ($c =~ s{\b(Perl_$func\s*\(\s*)(?!aTHX_?)(\)|[^\s)]*\))} + { $1 . ($2 eq ')' ? 'aTHX' : 'aTHX_ ') . $2 }ge); + if ($changes) { + warning("Doesn't pass interpreter argument aTHX to Perl_$func"); + $file{changes} += $changes; + } + } + } + else { + warning("Uses Perl_$func instead of $func"); + $file{changes} += ($c =~ s{\bPerl_$func(\s*)\((\s*aTHX_?)?\s*} + {$func$1(}g); + } + } + + for $func (sort dictionary_order keys %{$file{uses_replace}}) { + warning("Uses $func instead of $replace{$func}"); + $file{changes} += ($c =~ s/\b$func\b/$replace{$func}/g); + } + + for $func (sort dictionary_order keys %{$file{uses_provided}}) { + if ($file{uses}{$func}) { + if (exists $file{uses_deps}{$func}) { + diag("Uses $func, which depends on ", join(', ', @{$file{uses_deps}{$func}})); + } + else { + diag("Uses $func"); + } + } + $warnings += (hint($func) || 0); + } + + unless ($opt{quiet}) { + for $func (sort dictionary_order keys %{$file{uses_todo}}) { + next if int_parse_version($API{$func}{todo}) <= $int_min_perl; + print "*** WARNING: Uses $func, which may not be portable below perl ", + format_version($API{$func}{todo}), ", even with '$ppport'\n"; + $warnings++; + } + } + + for $func (sort dictionary_order keys %{$file{needed_static}}) { + my $message = ''; + if (not exists $file{uses}{$func}) { + $message = "No need to define NEED_$func if $func is never used"; + } + elsif (exists $file{needs}{$func} && $file{needs}{$func} ne 'static') { + $message = "No need to define NEED_$func when already needed globally"; + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_$func\b.*$LF//mg); + } + } + + for $func (sort dictionary_order keys %{$file{needed_global}}) { + my $message = ''; + if (not exists $global{uses}{$func}) { + $message = "No need to define NEED_${func}_GLOBAL if $func is never used"; + } + elsif (exists $file{needs}{$func}) { + if ($file{needs}{$func} eq 'extern') { + $message = "No need to define NEED_${func}_GLOBAL when already needed globally"; + } + elsif ($file{needs}{$func} eq 'static') { + $message = "No need to define NEED_${func}_GLOBAL when only used in this file"; + } + } + if ($message) { + diag($message); + $file{changes} += ($c =~ s/^$HS*#$HS*define$HS+NEED_${func}_GLOBAL\b.*$LF//mg); + } + } + + $file{needs_inc_ppport} = keys %{$file{uses}}; + + if ($file{needs_inc_ppport}) { + my $pp = ''; + + for $func (sort dictionary_order keys %{$file{needs}}) { + my $type = $file{needs}{$func}; + next if $type eq 'extern'; + my $suffix = $type eq 'global' ? '_GLOBAL' : ''; + unless (exists $file{"needed_$type"}{$func}) { + if ($type eq 'global') { + diag("Files [@{$global{needs}{$func}}] need $func, adding global request"); + } + else { + diag("File needs $func, adding static request"); + } + $pp .= "#define NEED_$func$suffix\n"; + } + } + + if ($pp && ($c =~ s/^(?=$HS*#$HS*define$HS+NEED_\w+)/$pp/m)) { + $pp = ''; + $file{changes}++; + } + + unless ($file{has_inc_ppport}) { + diag("Needs to include '$ppport'"); + $pp .= qq(#include "$ppport"\n) + } + + if ($pp) { + $file{changes} += ($c =~ s/^($HS*#$HS*define$HS+NEED_\w+.*?)^/$1$pp/ms) + || ($c =~ s/^(?=$HS*#$HS*include.*\Q$ppport\E)/$pp/m) + || ($c =~ s/^($HS*#$HS*include.*XSUB.*\s*?)^/$1$pp/m) + || ($c =~ s/^/$pp/); + } + } + else { + if ($file{has_inc_ppport}) { + diag("No need to include '$ppport'"); + $file{changes} += ($c =~ s/^$HS*?#$HS*include.*\Q$ppport\E.*?$LF//m); + } + } + + # put back in our C comments + my $ix; + my $cppc = 0; + my @ccom = @{$file{ccom}}; + for $ix (0 .. $#ccom) { + if (!$opt{cplusplus} && $ccom[$ix] =~ s!^//!!) { + $cppc++; + $file{changes} += $c =~ s/$rccs$ix$rcce/$ccs$ccom[$ix] $cce/; + } + else { + $c =~ s/$rccs$ix$rcce/$ccom[$ix]/; + } + } + + if ($cppc) { + my $s = $cppc != 1 ? 's' : ''; + warning("Uses $cppc C++ style comment$s, which is not portable"); + } + + my $s = $warnings != 1 ? 's' : ''; + my $warn = $warnings ? " ($warnings warning$s)" : ''; + info("Analysis completed$warn"); + + if ($file{changes}) { + if (exists $opt{copy}) { + my $newfile = "$filename$opt{copy}"; + if (-e $newfile) { + error("'$newfile' already exists, refusing to write copy of '$filename'"); + } + else { + local *F; + if (open F, ">$newfile") { + info("Writing copy of '$filename' with changes to '$newfile'"); + print F $c; + close F; + } + else { + error("Cannot open '$newfile' for writing: $!"); + } + } + } + elsif (exists $opt{patch} || $opt{changes}) { + if (exists $opt{patch}) { + unless ($patch_opened) { + if (open PATCH, ">$opt{patch}") { + $patch_opened = 1; + } + else { + error("Cannot open '$opt{patch}' for writing: $!"); + delete $opt{patch}; + $opt{changes} = 1; + goto fallback; + } + } + mydiff(\*PATCH, $filename, $c); + } + else { +fallback: + info("Suggested changes:"); + mydiff(\*STDOUT, $filename, $c); + } + } + else { + my $s = $file{changes} == 1 ? '' : 's'; + info("$file{changes} potentially required change$s detected"); + } + } + else { + info("Looks good"); + } +} + +close PATCH if $patch_opened; + +exit 0; + + +sub try_use { eval "use @_;"; return $@ eq '' } + +sub mydiff +{ + local *F = shift; + my($file, $str) = @_; + my $diff; + + if (exists $opt{diff}) { + $diff = run_diff($opt{diff}, $file, $str); + } + + if (!defined $diff and try_use('Text::Diff')) { + $diff = Text::Diff::diff($file, \$str, { STYLE => 'Unified' }); + $diff = <
$tmp") { + print F $str; + close F; + + if (open F, "$prog $file $tmp |") { + while () { + s/\Q$tmp\E/$file.patched/; + $diff .= $_; + } + close F; + unlink $tmp; + return $diff; + } + + unlink $tmp; + } + else { + error("Cannot open '$tmp' for writing: $!"); + } + + return undef; +} + +sub rec_depend +{ + my($func, $seen) = @_; + return () unless exists $depends{$func}; + $seen = {%{$seen||{}}}; + return () if $seen->{$func}++; + my %s; + grep !$s{$_}++, map { ($_, rec_depend($_, $seen)) } @{$depends{$func}}; +} + +sub info +{ + $opt{quiet} and return; + print @_, "\n"; +} + +sub diag +{ + $opt{quiet} and return; + $opt{diag} and print @_, "\n"; +} + +sub warning +{ + $opt{quiet} and return; + print "*** ", @_, "\n"; +} + +sub error +{ + print "*** ERROR: ", @_, "\n"; +} + +my %given_hints; +my %given_warnings; +sub hint +{ + $opt{quiet} and return; + my $func = shift; + my $rv = 0; + if (exists $warnings{$func} && !$given_warnings{$func}++) { + my $warn = $warnings{$func}; + $warn =~ s!^!*** !mg; + print "*** WARNING: $func\n", $warn; + $rv++; + } + if ($opt{hints} && exists $hints{$func} && !$given_hints{$func}++) { + my $hint = $hints{$func}; + $hint =~ s/^/ /mg; + print " --- hint for $func ---\n", $hint; + } + $rv || 0; +} + +sub usage +{ + my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms; + my %M = ( 'I' => '*' ); + $usage =~ s/^\s*perl\s+\S+/$^X $0/; + $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g; + + print < }; + my($copy) = $self =~ /^=head\d\s+COPYRIGHT\s*^(.*?)^=\w+/ms; + $copy =~ s/^(?=\S+)/ /gms; + $self =~ s/^$HS+Do NOT edit.*?(?=^-)/$copy/ms; + $self =~ s/^SKIP.*(?=^__DATA__)/SKIP +if (\@ARGV && \$ARGV[0] eq '--unstrip') { + eval { require Devel::PPPort }; + \$@ and die "Cannot require Devel::PPPort, please install.\\n"; + if (eval \$Devel::PPPort::VERSION < $VERSION) { + die "$0 was originally generated with Devel::PPPort $VERSION.\\n" + . "Your Devel::PPPort is only version \$Devel::PPPort::VERSION.\\n" + . "Please install a newer version, or --unstrip will not work.\\n"; + } + Devel::PPPort::WriteFile(\$0); + exit 0; +} +print <$0" or die "cannot strip $0: $!\n"; + print OUT "$pl$c\n"; + + exit 0; +} + +__DATA__ +*/ + +#ifndef _P_P_PORTABILITY_H_ +#define _P_P_PORTABILITY_H_ + +#ifndef DPPP_NAMESPACE +# define DPPP_NAMESPACE DPPP_ +#endif + +#define DPPP_CAT2(x,y) CAT2(x,y) +#define DPPP_(name) DPPP_CAT2(DPPP_NAMESPACE, name) + +#define D_PPP_RELEASE_DATE 1647561600 /* 2022-03-18 */ + +#if ! defined(PERL_REVISION) && ! defined(PERL_VERSION_MAJOR) +# if ! defined(__PATCHLEVEL_H_INCLUDED__) \ + && ! ( defined(PATCHLEVEL) && defined(SUBVERSION)) +# define PERL_PATCHLEVEL_H_IMPLICIT +# include +# endif +# if ! defined(PERL_VERSION) \ + && ! defined(PERL_VERSION_MAJOR) \ + && ( ! defined(SUBVERSION) || ! defined(PATCHLEVEL) ) +# include +# endif +#endif + +#ifdef PERL_VERSION_MAJOR +# define D_PPP_MAJOR PERL_VERSION_MAJOR +#elif defined(PERL_REVISION) +# define D_PPP_MAJOR PERL_REVISION +#else +# define D_PPP_MAJOR 5 +#endif + +#ifdef PERL_VERSION_MINOR +# define D_PPP_MINOR PERL_VERSION_MINOR +#elif defined(PERL_VERSION) +# define D_PPP_MINOR PERL_VERSION +#elif defined(PATCHLEVEL) +# define D_PPP_MINOR PATCHLEVEL +# define PERL_VERSION PATCHLEVEL /* back-compat */ +#else +# error Could not find a source for PERL_VERSION_MINOR +#endif + +#ifdef PERL_VERSION_PATCH +# define D_PPP_PATCH PERL_VERSION_PATCH +#elif defined(PERL_SUBVERSION) +# define D_PPP_PATCH PERL_SUBVERSION +#elif defined(SUBVERSION) +# define D_PPP_PATCH SUBVERSION +# define PERL_SUBVERSION SUBVERSION /* back-compat */ +#else +# error Could not find a source for PERL_VERSION_PATCH +#endif + +#if D_PPP_MAJOR < 5 || D_PPP_MAJOR == 6 +# error Devel::PPPort works only on Perl 5, Perl 7, ... +#elif D_PPP_MAJOR != 5 + /* Perl 7 and above: the old forms are deprecated, set up so that they + * assume Perl 5, and will make this look like 5.201.201. + * + * 201 is used so will be well above anything that would come from a 5 + * series if we unexpectedly have to continue it, but still gives plenty of + * room, up to 255, of numbers that will fit into a byte in case there is + * something else unforeseen */ +# undef PERL_REVISION +# undef PERL_VERSION +# undef PERL_SUBVERSION +# define D_PPP_REVISION 5 +# define D_PPP_VERSION 201 +# define D_PPP_SUBVERSION 201 +# if (defined(__clang__) /* _Pragma here doesn't work with gcc */ \ + && ( (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) \ + || defined(_STDC_C99) \ + || defined(__c99))) +# define D_PPP_STRINGIFY(x) #x +# define D_PPP_deprecate(xyz) _Pragma(D_PPP_STRINGIFY(GCC warning(D_PPP_STRINGIFY(xyz) " is deprecated"))) +# define PERL_REVISION (D_PPP_REVISION D_PPP_deprecate(PERL_REVISION)) +# define PERL_VERSION (D_PPP_REVISION D_PPP_deprecate(PERL_VERSION)) +# define PERL_SUBVERSION (D_PPP_SUBVERSION D_PPP_deprecate(PERL_SUBVERSION)) +# else +# define PERL_REVISION D_PPP_REVISION +# define PERL_VERSION D_PPP_REVISION +# define PERL_SUBVERSION D_PPP_SUBVERSION +# endif +#endif + +/* Warning: PERL_PATCHLEVEL PATCHLEVEL SUBVERSION PERL_REVISION PERL_VERSION + * PERL_SUBVERSION PERL_BCDVERSION + * + * You should be using PERL_VERSION_xy(maj,min,ptch) instead of this, where xy + * is one of EQ, NE, LE, GT, LT, GE + */ + +/* Replace PERL_PATCHLEVEL with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ +/* Replace PATCHLEVEL with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ +/* Replace SUBVERSION with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ +/* Replace PERL_REVISION with PERL_VERSION_xy(a,b,c) (where xy is EQ,LT,GT...) */ +/* Replace PERL_VERSION with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ +/* Replace PERL_SUBVERSION with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ +/* Replace PERL_BCDVERSION with PERL_VERSION_xy(5,a,b) (where xy is EQ,LT,GT...) */ + +#define D_PPP_DEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10)) +#define D_PPP_JNP_TO_BCD(j,n,p) ((D_PPP_DEC2BCD(j)<<24)|(D_PPP_DEC2BCD(n)<<12)|D_PPP_DEC2BCD(p)) +#define PERL_BCDVERSION D_PPP_JNP_TO_BCD(D_PPP_MAJOR, \ + D_PPP_MINOR, \ + D_PPP_PATCH) + +/* These differ from the versions outside D:P in using PERL_BCDVERSION instead + * of PERL_DECIMAL_VERSION. The formats printing in this module assume BCD, so + * always use it */ +#undef PERL_VERSION_EQ +#undef PERL_VERSION_NE +#undef PERL_VERSION_LT +#undef PERL_VERSION_GE +#undef PERL_VERSION_LE +#undef PERL_VERSION_GT + +/* N.B. These don't work if the patch number is 42 or 92, as those are what '*' + * is in ASCII and EBCDIC respectively */ +#ifndef PERL_VERSION_EQ +# define PERL_VERSION_EQ(j,n,p) \ + (((p) == '*') ? ( (j) == D_PPP_VERSION_MAJOR \ + && (n) == D_PPP_VERSION_MINOR) \ + : (PERL_BCDVERSION == D_PPP_JNP_TO_BCD(j,n,p))) +#endif + +#ifndef PERL_VERSION_NE +# define PERL_VERSION_NE(j,n,p) (! PERL_VERSION_EQ(j,n,p)) +#endif +#ifndef PERL_VERSION_LT +# define PERL_VERSION_LT(j,n,p) /* p=='*' means _LT(j,n,0) */ \ + (PERL_BCDVERSION < D_PPP_JNP_TO_BCD( (j), \ + (n), \ + (((p) == '*') ? 0 : (p)))) +#endif + +#ifndef PERL_VERSION_GE +# define PERL_VERSION_GE(j,n,p) (! PERL_VERSION_LT(j,n,p)) +#endif +#ifndef PERL_VERSION_LE +# define PERL_VERSION_LE(j,n,p) /* p=='*' means _LT(j,n+1,0) */ \ + (PERL_BCDVERSION < D_PPP_JNP_TO_BCD( (j), \ + (((p) == '*') ? ((n)+1) : (n)), \ + (((p) == '*') ? 0 : (p)))) +#endif + +#ifndef PERL_VERSION_GT +# define PERL_VERSION_GT(j,n,p) (! PERL_VERSION_LE(j,n,p)) +#endif +#ifndef dTHR +# define dTHR dNOOP +#endif +#ifndef dTHX +# define dTHX dNOOP +#endif + +/* Hint: dTHX + + For pre-5.6.0 thread compatibility, instead use dTHXR, available only through + ppport.h */ +#ifndef dTHXa +# define dTHXa(x) dNOOP +#endif +#ifndef pTHX +# define pTHX void +#endif + +#ifndef pTHX_ +# define pTHX_ +#endif + +#ifndef aTHX +# define aTHX +#endif + +/* Hint: aTHX + + For pre-5.6.0 thread compatibility, instead use aTHXR, available only through + ppport.h */ +#ifndef aTHX_ +# define aTHX_ +#endif + +/* Hint: aTHX_ + + For pre-5.6.0 thread compatibility, instead use aTHXR_, available only + through ppport.h */ + +#if (PERL_BCDVERSION < 0x5006000) +# ifdef USE_THREADS +# define aTHXR thr +# define aTHXR_ thr, +# else +# define aTHXR +# define aTHXR_ +# endif +# define dTHXR dTHR +#else +# define aTHXR aTHX +# define aTHXR_ aTHX_ +# define dTHXR dTHX +#endif +#ifndef dTHXoa +# define dTHXoa(x) dTHXa(x) +#endif + +#ifdef I_LIMITS +# include +#endif + +#ifndef PERL_UCHAR_MIN +# define PERL_UCHAR_MIN ((unsigned char)0) +#endif + +#ifndef PERL_UCHAR_MAX +# ifdef UCHAR_MAX +# define PERL_UCHAR_MAX ((unsigned char)UCHAR_MAX) +# else +# ifdef MAXUCHAR +# define PERL_UCHAR_MAX ((unsigned char)MAXUCHAR) +# else +# define PERL_UCHAR_MAX ((unsigned char)~(unsigned)0) +# endif +# endif +#endif + +#ifndef PERL_USHORT_MIN +# define PERL_USHORT_MIN ((unsigned short)0) +#endif + +#ifndef PERL_USHORT_MAX +# ifdef USHORT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHORT_MAX) +# else +# ifdef MAXUSHORT +# define PERL_USHORT_MAX ((unsigned short)MAXUSHORT) +# else +# ifdef USHRT_MAX +# define PERL_USHORT_MAX ((unsigned short)USHRT_MAX) +# else +# define PERL_USHORT_MAX ((unsigned short)~(unsigned)0) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MAX +# ifdef SHORT_MAX +# define PERL_SHORT_MAX ((short)SHORT_MAX) +# else +# ifdef MAXSHORT /* Often used in */ +# define PERL_SHORT_MAX ((short)MAXSHORT) +# else +# ifdef SHRT_MAX +# define PERL_SHORT_MAX ((short)SHRT_MAX) +# else +# define PERL_SHORT_MAX ((short) (PERL_USHORT_MAX >> 1)) +# endif +# endif +# endif +#endif + +#ifndef PERL_SHORT_MIN +# ifdef SHORT_MIN +# define PERL_SHORT_MIN ((short)SHORT_MIN) +# else +# ifdef MINSHORT +# define PERL_SHORT_MIN ((short)MINSHORT) +# else +# ifdef SHRT_MIN +# define PERL_SHORT_MIN ((short)SHRT_MIN) +# else +# define PERL_SHORT_MIN (-PERL_SHORT_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +#ifndef PERL_UINT_MAX +# ifdef UINT_MAX +# define PERL_UINT_MAX ((unsigned int)UINT_MAX) +# else +# ifdef MAXUINT +# define PERL_UINT_MAX ((unsigned int)MAXUINT) +# else +# define PERL_UINT_MAX (~(unsigned int)0) +# endif +# endif +#endif + +#ifndef PERL_UINT_MIN +# define PERL_UINT_MIN ((unsigned int)0) +#endif + +#ifndef PERL_INT_MAX +# ifdef INT_MAX +# define PERL_INT_MAX ((int)INT_MAX) +# else +# ifdef MAXINT /* Often used in */ +# define PERL_INT_MAX ((int)MAXINT) +# else +# define PERL_INT_MAX ((int)(PERL_UINT_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_INT_MIN +# ifdef INT_MIN +# define PERL_INT_MIN ((int)INT_MIN) +# else +# ifdef MININT +# define PERL_INT_MIN ((int)MININT) +# else +# define PERL_INT_MIN (-PERL_INT_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MAX +# ifdef ULONG_MAX +# define PERL_ULONG_MAX ((unsigned long)ULONG_MAX) +# else +# ifdef MAXULONG +# define PERL_ULONG_MAX ((unsigned long)MAXULONG) +# else +# define PERL_ULONG_MAX (~(unsigned long)0) +# endif +# endif +#endif + +#ifndef PERL_ULONG_MIN +# define PERL_ULONG_MIN ((unsigned long)0L) +#endif + +#ifndef PERL_LONG_MAX +# ifdef LONG_MAX +# define PERL_LONG_MAX ((long)LONG_MAX) +# else +# ifdef MAXLONG +# define PERL_LONG_MAX ((long)MAXLONG) +# else +# define PERL_LONG_MAX ((long) (PERL_ULONG_MAX >> 1)) +# endif +# endif +#endif + +#ifndef PERL_LONG_MIN +# ifdef LONG_MIN +# define PERL_LONG_MIN ((long)LONG_MIN) +# else +# ifdef MINLONG +# define PERL_LONG_MIN ((long)MINLONG) +# else +# define PERL_LONG_MIN (-PERL_LONG_MAX - ((3 & -1) == 3)) +# endif +# endif +#endif + +#if defined(HAS_QUAD) && (defined(convex) || defined(uts)) +# ifndef PERL_UQUAD_MAX +# ifdef ULONGLONG_MAX +# define PERL_UQUAD_MAX ((unsigned long long)ULONGLONG_MAX) +# else +# ifdef MAXULONGLONG +# define PERL_UQUAD_MAX ((unsigned long long)MAXULONGLONG) +# else +# define PERL_UQUAD_MAX (~(unsigned long long)0) +# endif +# endif +# endif + +# ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN ((unsigned long long)0L) +# endif + +# ifndef PERL_QUAD_MAX +# ifdef LONGLONG_MAX +# define PERL_QUAD_MAX ((long long)LONGLONG_MAX) +# else +# ifdef MAXLONGLONG +# define PERL_QUAD_MAX ((long long)MAXLONGLONG) +# else +# define PERL_QUAD_MAX ((long long) (PERL_UQUAD_MAX >> 1)) +# endif +# endif +# endif + +# ifndef PERL_QUAD_MIN +# ifdef LONGLONG_MIN +# define PERL_QUAD_MIN ((long long)LONGLONG_MIN) +# else +# ifdef MINLONGLONG +# define PERL_QUAD_MIN ((long long)MINLONGLONG) +# else +# define PERL_QUAD_MIN (-PERL_QUAD_MAX - ((3 & -1) == 3)) +# endif +# endif +# endif +#endif + +/* This is based on code from 5.003 perl.h */ +#ifdef HAS_QUAD +# ifdef cray +#ifndef IVTYPE +# define IVTYPE int +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_INT_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_INT_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UINT_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UINT_MAX +#endif + +# ifdef INTSIZE +#ifndef IVSIZE +# define IVSIZE INTSIZE +#endif + +# endif +# else +# if defined(convex) || defined(uts) +#ifndef IVTYPE +# define IVTYPE long long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_QUAD_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_QUAD_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_UQUAD_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_UQUAD_MAX +#endif + +# ifdef LONGLONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGLONGSIZE +#endif + +# endif +# else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +# ifdef LONGSIZE +#ifndef IVSIZE +# define IVSIZE LONGSIZE +#endif + +# endif +# endif +# endif +#ifndef IVSIZE +# define IVSIZE 8 +#endif + +#ifndef LONGSIZE +# define LONGSIZE 8 +#endif + +#ifndef PERL_QUAD_MIN +# define PERL_QUAD_MIN IV_MIN +#endif + +#ifndef PERL_QUAD_MAX +# define PERL_QUAD_MAX IV_MAX +#endif + +#ifndef PERL_UQUAD_MIN +# define PERL_UQUAD_MIN UV_MIN +#endif + +#ifndef PERL_UQUAD_MAX +# define PERL_UQUAD_MAX UV_MAX +#endif + +#else +#ifndef IVTYPE +# define IVTYPE long +#endif + +#ifndef LONGSIZE +# define LONGSIZE 4 +#endif + +#ifndef IV_MIN +# define IV_MIN PERL_LONG_MIN +#endif + +#ifndef IV_MAX +# define IV_MAX PERL_LONG_MAX +#endif + +#ifndef UV_MIN +# define UV_MIN PERL_ULONG_MIN +#endif + +#ifndef UV_MAX +# define UV_MAX PERL_ULONG_MAX +#endif + +#endif + +#ifndef IVSIZE +# ifdef LONGSIZE +# define IVSIZE LONGSIZE +# else +# define IVSIZE 4 /* A bold guess, but the best we can make. */ +# endif +#endif +#ifndef UVTYPE +# define UVTYPE unsigned IVTYPE +#endif + +#ifndef UVSIZE +# define UVSIZE IVSIZE +#endif + +#ifndef PERL_SIGNALS_UNSAFE_FLAG + +#define PERL_SIGNALS_UNSAFE_FLAG 0x0001 + +#if (PERL_BCDVERSION < 0x5008000) +# define D_PPP_PERL_SIGNALS_INIT PERL_SIGNALS_UNSAFE_FLAG +#else +# define D_PPP_PERL_SIGNALS_INIT 0 +#endif + +#if defined(NEED_PL_signals) +static U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#elif defined(NEED_PL_signals_GLOBAL) +U32 DPPP_(my_PL_signals) = D_PPP_PERL_SIGNALS_INIT; +#else +extern U32 DPPP_(my_PL_signals); +#endif +#define PL_signals DPPP_(my_PL_signals) + +#endif + +/* Hint: PL_ppaddr + * Calling an op via PL_ppaddr requires passing a context argument + * for threaded builds. Since the context argument is different for + * 5.005 perls, you can use aTHXR (supplied by ppport.h), which will + * automatically be defined as the correct argument. + */ + +#if (PERL_BCDVERSION <= 0x5005005) +/* Replace: 1 */ +# define PL_ppaddr ppaddr +# define PL_no_modify no_modify +/* Replace: 0 */ +#endif + +#if (PERL_BCDVERSION <= 0x5004005) +/* Replace: 1 */ +# define PL_DBsignal DBsignal +# define PL_DBsingle DBsingle +# define PL_DBsub DBsub +# define PL_DBtrace DBtrace +# define PL_Sv Sv +# define PL_Xpv Xpv +# define PL_bufend bufend +# define PL_bufptr bufptr +# define PL_compiling compiling +# define PL_copline copline +# define PL_curcop curcop +# define PL_curstash curstash +# define PL_debstash debstash +# define PL_defgv defgv +# define PL_diehook diehook +# define PL_dirty dirty +# define PL_dowarn dowarn +# define PL_errgv errgv +# define PL_error_count error_count +# define PL_expect expect +# define PL_hexdigit hexdigit +# define PL_hints hints +# define PL_in_my in_my +# define PL_laststatval laststatval +# define PL_lex_state lex_state +# define PL_lex_stuff lex_stuff +# define PL_linestr linestr +# define PL_na na +# define PL_perl_destruct_level perl_destruct_level +# define PL_perldb perldb +# define PL_rsfp_filters rsfp_filters +# define PL_rsfp rsfp +# define PL_stack_base stack_base +# define PL_stack_sp stack_sp +# define PL_statcache statcache +# define PL_stdingv stdingv +# define PL_sv_arenaroot sv_arenaroot +# define PL_sv_no sv_no +# define PL_sv_undef sv_undef +# define PL_sv_yes sv_yes +# define PL_tainted tainted +# define PL_tainting tainting +# define PL_tokenbuf tokenbuf +# define PL_mess_sv mess_sv +/* Replace: 0 */ +#endif + +/* Warning: PL_parser + * For perl versions earlier than 5.9.5, this is an always + * non-NULL dummy. Also, it cannot be dereferenced. Don't + * use it if you can avoid it, and unless you absolutely know + * what you're doing. + * If you always check that PL_parser is non-NULL, you can + * define DPPP_PL_parser_NO_DUMMY to avoid the creation of + * a dummy parser structure. + */ + +#if (PERL_BCDVERSION >= 0x5009005) +# ifdef DPPP_PL_parser_NO_DUMMY +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (croak("panic: PL_parser == NULL in %s:%d", \ + __FILE__, __LINE__), (yy_parser *) NULL))->var) +# else +# ifdef DPPP_PL_parser_NO_DUMMY_WARNING +# define D_PPP_parser_dummy_warning(var) +# else +# define D_PPP_parser_dummy_warning(var) \ + warn("warning: dummy PL_" #var " used in %s:%d", __FILE__, __LINE__), +# endif +# define D_PPP_my_PL_parser_var(var) ((PL_parser ? PL_parser : \ + (D_PPP_parser_dummy_warning(var) &DPPP_(dummy_PL_parser)))->var) +#if defined(NEED_PL_parser) +static yy_parser DPPP_(dummy_PL_parser); +#elif defined(NEED_PL_parser_GLOBAL) +yy_parser DPPP_(dummy_PL_parser); +#else +extern yy_parser DPPP_(dummy_PL_parser); +#endif + +# endif + +/* 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 */ +/* Warning: PL_expect, PL_copline, PL_rsfp, PL_rsfp_filters, PL_linestr, PL_bufptr, PL_bufend, PL_lex_state, PL_lex_stuff, PL_tokenbuf + * Do not use this variable unless you know exactly what you're + * doing. It is internal to the perl parser and may change or even + * be removed in the future. As of perl 5.9.5, you have to check + * for (PL_parser != NULL) for this variable to have any effect. + * An always non-NULL PL_parser dummy is provided for earlier + * perl versions. + * If PL_parser is NULL when you try to access this variable, a + * dummy is being accessed instead and a warning is issued unless + * you define DPPP_PL_parser_NO_DUMMY_WARNING. + * If DPPP_PL_parser_NO_DUMMY is defined, the code trying to access + * this variable will croak with a panic message. + */ + +# define PL_expect D_PPP_my_PL_parser_var(expect) +# define PL_copline D_PPP_my_PL_parser_var(copline) +# define PL_rsfp D_PPP_my_PL_parser_var(rsfp) +# define PL_rsfp_filters D_PPP_my_PL_parser_var(rsfp_filters) +# define PL_linestr D_PPP_my_PL_parser_var(linestr) +# define PL_bufptr D_PPP_my_PL_parser_var(bufptr) +# define PL_bufend D_PPP_my_PL_parser_var(bufend) +# define PL_lex_state D_PPP_my_PL_parser_var(lex_state) +# define PL_lex_stuff D_PPP_my_PL_parser_var(lex_stuff) +# define PL_tokenbuf D_PPP_my_PL_parser_var(tokenbuf) +# define PL_in_my D_PPP_my_PL_parser_var(in_my) +# define PL_in_my_stash D_PPP_my_PL_parser_var(in_my_stash) +# define PL_error_count D_PPP_my_PL_parser_var(error_count) + + +#else + +/* ensure that PL_parser != NULL and cannot be dereferenced */ +# define PL_parser ((void *) 1) + +#endif + +#if (PERL_BCDVERSION <= 0x5003022) +# undef start_subparse +# if (PERL_BCDVERSION < 0x5003022) +#ifndef start_subparse +# define start_subparse(a, b) Perl_start_subparse() +#endif + +# else +#ifndef start_subparse +# define start_subparse(a, b) Perl_start_subparse(b) +#endif + +# endif + +#if (PERL_BCDVERSION < 0x5003007) +foo +#endif +#endif + +/* newCONSTSUB from IO.xs is in the core starting with 5.004_63 */ +#if (PERL_BCDVERSION < 0x5004063) && (PERL_BCDVERSION != 0x5004005) + +/* And before that, we need to make sure this gets compiled for the functions + * that rely on it */ +#define NEED_newCONSTSUB + +#if defined(NEED_newCONSTSUB) +static CV * DPPP_(my_newCONSTSUB)(HV * stash, const char * name, SV * sv); +static +#else +extern CV * DPPP_(my_newCONSTSUB)(HV * stash, const char * name, SV * sv); +#endif + +#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL) + +#ifdef newCONSTSUB +# undef newCONSTSUB +#endif +#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c) +#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB) + + +/* This is just a trick to avoid a dependency of newCONSTSUB on PL_parser */ +/* (There's no PL_parser in perl < 5.005, so this is completely safe) */ +#define D_PPP_PL_copline PL_copline + +CV * +DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv) +{ + CV *cv; + U32 oldhints = PL_hints; + HV *old_cop_stash = PL_curcop->cop_stash; + HV *old_curstash = PL_curstash; + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = D_PPP_PL_copline; + + PL_hints &= ~HINT_BLOCK_SCOPE; + if (stash) + PL_curstash = PL_curcop->cop_stash = stash; + + cv = newSUB( + + start_subparse(FALSE, 0), + + newSVOP(OP_CONST, 0, newSVpv((char *) name, 0)), + newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ + newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) + ); + + PL_hints = oldhints; + PL_curcop->cop_stash = old_cop_stash; + PL_curstash = old_curstash; + PL_curcop->cop_line = oldline; + + return cv; +} +#endif +#endif +#ifndef PERL_MAGIC_sv +# define PERL_MAGIC_sv '\0' +#endif + +#ifndef PERL_MAGIC_overload +# define PERL_MAGIC_overload 'A' +#endif + +#ifndef PERL_MAGIC_overload_elem +# define PERL_MAGIC_overload_elem 'a' +#endif + +#ifndef PERL_MAGIC_overload_table +# define PERL_MAGIC_overload_table 'c' +#endif + +#ifndef PERL_MAGIC_bm +# define PERL_MAGIC_bm 'B' +#endif + +#ifndef PERL_MAGIC_regdata +# define PERL_MAGIC_regdata 'D' +#endif + +#ifndef PERL_MAGIC_regdatum +# define PERL_MAGIC_regdatum 'd' +#endif + +#ifndef PERL_MAGIC_env +# define PERL_MAGIC_env 'E' +#endif + +#ifndef PERL_MAGIC_envelem +# define PERL_MAGIC_envelem 'e' +#endif + +#ifndef PERL_MAGIC_fm +# define PERL_MAGIC_fm 'f' +#endif + +#ifndef PERL_MAGIC_regex_global +# define PERL_MAGIC_regex_global 'g' +#endif + +#ifndef PERL_MAGIC_isa +# define PERL_MAGIC_isa 'I' +#endif + +#ifndef PERL_MAGIC_isaelem +# define PERL_MAGIC_isaelem 'i' +#endif + +#ifndef PERL_MAGIC_nkeys +# define PERL_MAGIC_nkeys 'k' +#endif + +#ifndef PERL_MAGIC_dbfile +# define PERL_MAGIC_dbfile 'L' +#endif + +#ifndef PERL_MAGIC_dbline +# define PERL_MAGIC_dbline 'l' +#endif + +#ifndef PERL_MAGIC_mutex +# define PERL_MAGIC_mutex 'm' +#endif + +#ifndef PERL_MAGIC_shared +# define PERL_MAGIC_shared 'N' +#endif + +#ifndef PERL_MAGIC_shared_scalar +# define PERL_MAGIC_shared_scalar 'n' +#endif + +#ifndef PERL_MAGIC_collxfrm +# define PERL_MAGIC_collxfrm 'o' +#endif + +#ifndef PERL_MAGIC_tied +# define PERL_MAGIC_tied 'P' +#endif + +#ifndef PERL_MAGIC_tiedelem +# define PERL_MAGIC_tiedelem 'p' +#endif + +#ifndef PERL_MAGIC_tiedscalar +# define PERL_MAGIC_tiedscalar 'q' +#endif + +#ifndef PERL_MAGIC_qr +# define PERL_MAGIC_qr 'r' +#endif + +#ifndef PERL_MAGIC_sig +# define PERL_MAGIC_sig 'S' +#endif + +#ifndef PERL_MAGIC_sigelem +# define PERL_MAGIC_sigelem 's' +#endif + +#ifndef PERL_MAGIC_taint +# define PERL_MAGIC_taint 't' +#endif + +#ifndef PERL_MAGIC_uvar +# define PERL_MAGIC_uvar 'U' +#endif + +#ifndef PERL_MAGIC_uvar_elem +# define PERL_MAGIC_uvar_elem 'u' +#endif + +#ifndef PERL_MAGIC_vstring +# define PERL_MAGIC_vstring 'V' +#endif + +#ifndef PERL_MAGIC_vec +# define PERL_MAGIC_vec 'v' +#endif + +#ifndef PERL_MAGIC_utf8 +# define PERL_MAGIC_utf8 'w' +#endif + +#ifndef PERL_MAGIC_substr +# define PERL_MAGIC_substr 'x' +#endif + +#ifndef PERL_MAGIC_defelem +# define PERL_MAGIC_defelem 'y' +#endif + +#ifndef PERL_MAGIC_glob +# define PERL_MAGIC_glob '*' +#endif + +#ifndef PERL_MAGIC_arylen +# define PERL_MAGIC_arylen '#' +#endif + +#ifndef PERL_MAGIC_pos +# define PERL_MAGIC_pos '.' +#endif + +#ifndef PERL_MAGIC_backref +# define PERL_MAGIC_backref '<' +#endif + +#ifndef PERL_MAGIC_ext +# define PERL_MAGIC_ext '~' +#endif + +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#ifndef PERL_STATIC_INLINE +# define PERL_STATIC_INLINE static inline +#endif + +#else +#ifndef PERL_STATIC_INLINE +# define PERL_STATIC_INLINE static +#endif + +#endif +#ifndef cBOOL +# define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0) +#endif + +#ifndef OpHAS_SIBLING +# define OpHAS_SIBLING(o) (cBOOL((o)->op_sibling)) +#endif + +#ifndef OpSIBLING +# define OpSIBLING(o) (0 + (o)->op_sibling) +#endif + +#ifndef OpMORESIB_set +# define OpMORESIB_set(o, sib) ((o)->op_sibling = (sib)) +#endif + +#ifndef OpLASTSIB_set +# define OpLASTSIB_set(o, parent) ((o)->op_sibling = NULL) +#endif + +#ifndef OpMAYBESIB_set +# define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib)) +#endif + +#ifndef HEf_SVKEY +# define HEf_SVKEY -2 +#endif + +#if defined(DEBUGGING) && !defined(__COVERITY__) +#ifndef __ASSERT_ +# define __ASSERT_(statement) assert(statement), +#endif + +#else +#ifndef __ASSERT_ +# define __ASSERT_(statement) +#endif + +#endif +#ifndef __has_builtin +# define __has_builtin(x) 0 +#endif + +#if __has_builtin(__builtin_unreachable) +# define D_PPP_HAS_BUILTIN_UNREACHABLE +#elif (defined(__GNUC__) && ( __GNUC__ > 4 \ + || __GNUC__ == 4 && __GNUC_MINOR__ >= 5)) +# define D_PPP_HAS_BUILTIN_UNREACHABLE +#endif + +#ifndef ASSUME +# ifdef DEBUGGING +# define ASSUME(x) assert(x) +# elif defined(_MSC_VER) +# define ASSUME(x) __assume(x) +# elif defined(__ARMCC_VERSION) +# define ASSUME(x) __promise(x) +# elif defined(D_PPP_HAS_BUILTIN_UNREACHABLE) +# define ASSUME(x) ((x) ? (void) 0 : __builtin_unreachable()) +# else +# define ASSUME(x) assert(x) +# endif +#endif + +#ifndef NOT_REACHED +# ifdef D_PPP_HAS_BUILTIN_UNREACHABLE +# define NOT_REACHED \ + STMT_START { \ + ASSUME(!"UNREACHABLE"); __builtin_unreachable(); \ + } STMT_END +# elif ! defined(__GNUC__) && (defined(__sun) || defined(__hpux)) +# define NOT_REACHED +# else +# define NOT_REACHED ASSUME(!"UNREACHABLE") +# endif +#endif + +#ifndef WIDEST_UTYPE +# ifdef QUADKIND +# ifdef U64TYPE +# define WIDEST_UTYPE U64TYPE +# else +# define WIDEST_UTYPE unsigned Quad_t +# endif +# else +# define WIDEST_UTYPE U32 +# endif +#endif + +/* These could become provided if/when they become part of the public API */ +#ifndef withinCOUNT +# define withinCOUNT(c, l, n) \ + (((WIDEST_UTYPE) (((c)) - ((l) | 0))) <= (((WIDEST_UTYPE) ((n) | 0)))) +#endif + +#ifndef inRANGE +# define inRANGE(c, l, u) \ + ( (sizeof(c) == sizeof(U8)) ? withinCOUNT(((U8) (c)), (l), ((u) - (l))) \ + : (sizeof(c) == sizeof(U32)) ? withinCOUNT(((U32) (c)), (l), ((u) - (l))) \ + : (withinCOUNT(((WIDEST_UTYPE) (c)), (l), ((u) - (l))))) +#endif + +/* The '| 0' part ensures a compiler error if c is not integer (like e.g., a + * pointer) */ +#undef FITS_IN_8_BITS /* handy.h version uses a core-only constant */ +#ifndef FITS_IN_8_BITS +# define FITS_IN_8_BITS(c) ( (sizeof(c) == 1) \ + || !(((WIDEST_UTYPE)((c) | 0)) & ~0xFF)) +#endif + +/* Create the macro for "is'macro'_utf8_safe(s, e)". For code points below + * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code + * point. That is so that it can automatically get the bug fixes done in this + * file. */ +#define D_PPP_IS_GENERIC_UTF8_SAFE(s, e, macro) \ + (((e) - (s)) <= 0 \ + ? 0 \ + : UTF8_IS_INVARIANT((s)[0]) \ + ? is ## macro ## _L1((s)[0]) \ + : (((e) - (s)) < UTF8SKIP(s)) \ + ? 0 \ + : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ + /* The cast in the line below is only to silence warnings */ \ + ? is ## macro ## _L1((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ + UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ + & UTF_START_MASK(2), \ + (s)[1]))) \ + : is ## macro ## _utf8(s)) + +/* Create the macro for "is'macro'_LC_utf8_safe(s, e)". For code points below + * 256, it calls the equivalent _L1 macro by converting the UTF-8 to code + * point. That is so that it can automatically get the bug fixes done in this + * file. */ +#define D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, macro) \ + (((e) - (s)) <= 0 \ + ? 0 \ + : UTF8_IS_INVARIANT((s)[0]) \ + ? is ## macro ## _LC((s)[0]) \ + : (((e) - (s)) < UTF8SKIP(s)) \ + ? 0 \ + : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ + /* The cast in the line below is only to silence warnings */ \ + ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ + UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ + & UTF_START_MASK(2), \ + (s)[1]))) \ + : is ## macro ## _utf8(s)) + +/* A few of the early functions are broken. For these and the non-LC case, + * machine generated code is substituted. But that code doesn't work for + * locales. This is just like the above macro, but at the end, we call the + * macro we've generated for the above 255 case, which is correct since locale + * isn't involved. This will generate extra code to handle the 0-255 inputs, + * but hopefully it will be optimized out by the C compiler. But just in case + * it isn't, this macro is only used on the few versions that are broken */ + +#define D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, macro) \ + (((e) - (s)) <= 0 \ + ? 0 \ + : UTF8_IS_INVARIANT((s)[0]) \ + ? is ## macro ## _LC((s)[0]) \ + : (((e) - (s)) < UTF8SKIP(s)) \ + ? 0 \ + : UTF8_IS_DOWNGRADEABLE_START((s)[0]) \ + /* The cast in the line below is only to silence warnings */ \ + ? is ## macro ## _LC((WIDEST_UTYPE) LATIN1_TO_NATIVE( \ + UTF8_ACCUMULATE(NATIVE_UTF8_TO_I8((s)[0]) \ + & UTF_START_MASK(2), \ + (s)[1]))) \ + : is ## macro ## _utf8_safe(s, e)) +#ifndef SvRX +# define SvRX(rv) (SvROK((rv)) ? (SvMAGICAL(SvRV((rv))) ? (mg_find(SvRV((rv)), PERL_MAGIC_qr) ? mg_find(SvRV((rv)), PERL_MAGIC_qr)->mg_obj : NULL) : NULL) : NULL) +#endif + +#ifndef SvRXOK +# define SvRXOK(sv) (!!SvRX(sv)) +#endif + +#ifndef PERL_UNUSED_DECL +# ifdef HASATTRIBUTE +# if (defined(__GNUC__) && defined(__cplusplus)) || defined(__INTEL_COMPILER) +# define PERL_UNUSED_DECL +# else +# define PERL_UNUSED_DECL __attribute__((unused)) +# endif +# else +# define PERL_UNUSED_DECL +# endif +#endif + +#ifndef PERL_UNUSED_ARG +# if defined(lint) && defined(S_SPLINT_S) /* www.splint.org */ +# include +# define PERL_UNUSED_ARG(x) NOTE(ARGUNUSED(x)) +# else +# define PERL_UNUSED_ARG(x) ((void)x) +# endif +#endif + +#ifndef PERL_UNUSED_VAR +# define PERL_UNUSED_VAR(x) ((void)x) +#endif + +#ifndef PERL_UNUSED_CONTEXT +# ifdef USE_ITHREADS +# define PERL_UNUSED_CONTEXT PERL_UNUSED_ARG(my_perl) +# else +# define PERL_UNUSED_CONTEXT +# endif +#endif + +#ifndef PERL_UNUSED_RESULT +# if defined(__GNUC__) && defined(HASATTRIBUTE_WARN_UNUSED_RESULT) +# define PERL_UNUSED_RESULT(v) STMT_START { __typeof__(v) z = (v); (void)sizeof(z); } STMT_END +# else +# define PERL_UNUSED_RESULT(v) ((void)(v)) +# endif +#endif +#ifndef NOOP +# define NOOP /*EMPTY*/(void)0 +#endif + +#if (PERL_BCDVERSION < 0x5006001) && (PERL_BCDVERSION < 0x5027007) +#undef dNOOP +#ifndef dNOOP +# define dNOOP struct Perl___notused_struct +#endif + +#endif + +#ifndef NVTYPE +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) +# define NVTYPE long double +# else +# define NVTYPE double +# endif +typedef NVTYPE NV; +#endif + +#ifndef INT2PTR +# if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE) +# define PTRV UV +# define INT2PTR(any,d) (any)(d) +# else +# if PTRSIZE == LONGSIZE +# define PTRV unsigned long +# else +# define PTRV unsigned +# endif +# define INT2PTR(any,d) (any)(PTRV)(d) +# endif +#endif + +#ifndef PTR2ul +# if PTRSIZE == LONGSIZE +# define PTR2ul(p) (unsigned long)(p) +# else +# define PTR2ul(p) INT2PTR(unsigned long,p) +# endif +#endif +#ifndef PTR2nat +# define PTR2nat(p) (PTRV)(p) +#endif + +#ifndef NUM2PTR +# define NUM2PTR(any,d) (any)PTR2nat(d) +#endif + +#ifndef PTR2IV +# define PTR2IV(p) INT2PTR(IV,p) +#endif + +#ifndef PTR2UV +# define PTR2UV(p) INT2PTR(UV,p) +#endif + +#ifndef PTR2NV +# define PTR2NV(p) NUM2PTR(NV,p) +#endif + +#undef START_EXTERN_C +#undef END_EXTERN_C +#undef EXTERN_C +#ifdef __cplusplus +# define START_EXTERN_C extern "C" { +# define END_EXTERN_C } +# define EXTERN_C extern "C" +#else +# define START_EXTERN_C +# define END_EXTERN_C +# define EXTERN_C extern +#endif + +#if (PERL_BCDVERSION < 0x5004000) || defined(PERL_GCC_PEDANTIC) +# ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN +#ifndef PERL_GCC_BRACE_GROUPS_FORBIDDEN +# define PERL_GCC_BRACE_GROUPS_FORBIDDEN +#endif + +# endif +#endif + +#if ! defined(__GNUC__) || defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) || defined(__cplusplus) +# undef PERL_USE_GCC_BRACE_GROUPS +#else +# ifndef PERL_USE_GCC_BRACE_GROUPS +# define PERL_USE_GCC_BRACE_GROUPS +# endif +#endif + +#undef STMT_START +#undef STMT_END +#if defined(VOIDFLAGS) && defined(PERL_USE_GCC_BRACE_GROUPS) +# define STMT_START (void)( /* gcc supports ``({ STATEMENTS; })'' */ +# define STMT_END ) +#else +# if defined(VOIDFLAGS) && (VOIDFLAGS) && (defined(sun) || defined(__sun__)) && !defined(__GNUC__) +# define STMT_START if (1) +# define STMT_END else (void)0 +# else +# define STMT_START do +# define STMT_END while (0) +# endif +#endif +#ifndef boolSV +# define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no) +#endif + +/* DEFSV appears first in 5.004_56 */ +#ifndef DEFSV +# define DEFSV GvSV(PL_defgv) +#endif + +#ifndef SAVE_DEFSV +# define SAVE_DEFSV SAVESPTR(GvSV(PL_defgv)) +#endif + +#ifndef DEFSV_set +# define DEFSV_set(sv) (DEFSV = (sv)) +#endif + +/* Older perls (<=5.003) lack AvFILLp */ +#ifndef AvFILLp +# define AvFILLp AvFILL +#endif +#ifndef av_tindex +# define av_tindex AvFILL +#endif + +#ifndef av_top_index +# define av_top_index AvFILL +#endif + +#ifndef av_count +# define av_count(av) (AvFILL(av)+1) +#endif +#ifndef ERRSV +# define ERRSV get_sv("@",FALSE) +#endif + +/* Hint: gv_stashpvn + * This function's backport doesn't support the length parameter, but + * rather ignores it. Portability can only be ensured if the length + * parameter is used for speed reasons, but the length can always be + * correctly computed from the string argument. + */ +#ifndef gv_stashpvn +# define gv_stashpvn(str,len,create) gv_stashpv(str,create) +#endif + +/* Replace: 1 */ +#ifndef get_cv +# define get_cv perl_get_cv +#endif + +#ifndef get_sv +# define get_sv perl_get_sv +#endif + +#ifndef get_av +# define get_av perl_get_av +#endif + +#ifndef get_hv +# define get_hv perl_get_hv +#endif + +/* Replace: 0 */ +#ifndef dUNDERBAR +# define dUNDERBAR dNOOP +#endif + +#ifndef UNDERBAR +# define UNDERBAR DEFSV +#endif +#ifndef dAX +# define dAX I32 ax = MARK - PL_stack_base + 1 +#endif + +#ifndef dITEMS +# define dITEMS I32 items = SP - MARK +#endif +#ifndef dXSTARG +# define dXSTARG SV * targ = sv_newmortal() +#endif +#ifndef dAXMARK +# define dAXMARK I32 ax = POPMARK; \ + SV ** const mark = PL_stack_base + ax++ +#endif +#ifndef XSprePUSH +# define XSprePUSH (sp = PL_stack_base + ax - 1) +#endif + +#if (PERL_BCDVERSION < 0x5005000) +# undef XSRETURN +# define XSRETURN(off) \ + STMT_START { \ + PL_stack_sp = PL_stack_base + ax + ((off) - 1); \ + return; \ + } STMT_END +#endif +#ifndef XSPROTO +# define XSPROTO(name) void name(pTHX_ CV* cv) +#endif + +#ifndef SVfARG +# define SVfARG(p) ((void*)(p)) +#endif +#ifndef PERL_ABS +# define PERL_ABS(x) ((x) < 0 ? -(x) : (x)) +#endif +#ifndef dVAR +# define dVAR dNOOP +#endif +#ifndef SVf +# define SVf "_" +#endif +#ifndef CPERLscope +# define CPERLscope(x) x +#endif +#ifndef PERL_HASH +# define PERL_HASH(hash,str,len) \ + STMT_START { \ + const char *s_PeRlHaSh = str; \ + I32 i_PeRlHaSh = len; \ + U32 hash_PeRlHaSh = 0; \ + while (i_PeRlHaSh--) \ + hash_PeRlHaSh = hash_PeRlHaSh * 33 + *s_PeRlHaSh++; \ + (hash) = hash_PeRlHaSh; \ + } STMT_END +#endif + +#ifndef PERLIO_FUNCS_DECL +# ifdef PERLIO_FUNCS_CONST +# define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs) +# else +# define PERLIO_FUNCS_DECL(funcs) PerlIO_funcs funcs +# define PERLIO_FUNCS_CAST(funcs) (funcs) +# endif +#endif + +/* provide these typedefs for older perls */ +#if (PERL_BCDVERSION < 0x5009003) + +# ifdef ARGSproto +typedef OP* (CPERLscope(*Perl_ppaddr_t))(ARGSproto); +# else +typedef OP* (CPERLscope(*Perl_ppaddr_t))(pTHX); +# endif + +typedef OP* (CPERLscope(*Perl_check_t)) (pTHX_ OP*); + +#endif + +/* On versions without NATIVE_TO_ASCII, only ASCII is supported */ +#if defined(EBCDIC) && defined(NATIVE_TO_ASCI) +#ifndef NATIVE_TO_LATIN1 +# define NATIVE_TO_LATIN1(c) NATIVE_TO_ASCII(c) +#endif + +#ifndef LATIN1_TO_NATIVE +# define LATIN1_TO_NATIVE(c) ASCII_TO_NATIVE(c) +#endif + +#ifndef NATIVE_TO_UNI +# define NATIVE_TO_UNI(c) ((c) > 255 ? (c) : NATIVE_TO_LATIN1(c)) +#endif + +#ifndef UNI_TO_NATIVE +# define UNI_TO_NATIVE(c) ((c) > 255 ? (c) : LATIN1_TO_NATIVE(c)) +#endif + +#else +#ifndef NATIVE_TO_LATIN1 +# define NATIVE_TO_LATIN1(c) (c) +#endif + +#ifndef LATIN1_TO_NATIVE +# define LATIN1_TO_NATIVE(c) (c) +#endif + +#ifndef NATIVE_TO_UNI +# define NATIVE_TO_UNI(c) (c) +#endif + +#ifndef UNI_TO_NATIVE +# define UNI_TO_NATIVE(c) (c) +#endif + +#endif + +/* Warning: LATIN1_TO_NATIVE, NATIVE_TO_LATIN1 NATIVE_TO_UNI UNI_TO_NATIVE + EBCDIC is not supported on versions earlier than 5.7.1 + */ + +/* The meaning of this changed; use the modern version */ +#undef isPSXSPC +#undef isPSXSPC_A +#undef isPSXSPC_L1 + +/* Hint: isPSXSPC, isPSXSPC_A, isPSXSPC_L1, isPSXSPC_utf8_safe + This is equivalent to the corresponding isSPACE-type macro. On perls + before 5.18, this matched a vertical tab and SPACE didn't. But the + ppport.h SPACE version does match VT in all perl releases. Since VT's are + extremely rarely found in real-life files, this difference effectively + doesn't matter */ + +/* Hint: isSPACE, isSPACE_A, isSPACE_L1, isSPACE_utf8_safe + Until Perl 5.18, this did not match the vertical tab (VT). The ppport.h + version does match it in all perl releases. Since VT's are extremely rarely + found in real-life files, this difference effectively doesn't matter */ + +#ifdef EBCDIC + +/* This is the first version where these macros are fully correct on EBCDIC + * platforms. Relying on the C library functions, as earlier releases did, + * causes problems with locales */ +# if (PERL_BCDVERSION < 0x5022000) +# undef isALNUM +# undef isALNUM_A +# undef isALNUM_L1 +# undef isALNUMC +# undef isALNUMC_A +# undef isALNUMC_L1 +# undef isALPHA +# undef isALPHA_A +# undef isALPHA_L1 +# undef isALPHANUMERIC +# undef isALPHANUMERIC_A +# undef isALPHANUMERIC_L1 +# undef isASCII +# undef isASCII_A +# undef isASCII_L1 +# undef isBLANK +# undef isBLANK_A +# undef isBLANK_L1 +# undef isCNTRL +# undef isCNTRL_A +# undef isCNTRL_L1 +# undef isDIGIT +# undef isDIGIT_A +# undef isDIGIT_L1 +# undef isGRAPH +# undef isGRAPH_A +# undef isGRAPH_L1 +# undef isIDCONT +# undef isIDCONT_A +# undef isIDCONT_L1 +# undef isIDFIRST +# undef isIDFIRST_A +# undef isIDFIRST_L1 +# undef isLOWER +# undef isLOWER_A +# undef isLOWER_L1 +# undef isOCTAL +# undef isOCTAL_A +# undef isOCTAL_L1 +# undef isPRINT +# undef isPRINT_A +# undef isPRINT_L1 +# undef isPUNCT +# undef isPUNCT_A +# undef isPUNCT_L1 +# undef isSPACE +# undef isSPACE_A +# undef isSPACE_L1 +# undef isUPPER +# undef isUPPER_A +# undef isUPPER_L1 +# undef isWORDCHAR +# undef isWORDCHAR_A +# undef isWORDCHAR_L1 +# undef isXDIGIT +# undef isXDIGIT_A +# undef isXDIGIT_L1 +# endif +#ifndef isASCII +# define isASCII(c) (isCNTRL(c) || isPRINT(c)) +#endif + + /* The below is accurate for all EBCDIC code pages supported by + * all the versions of Perl overridden by this */ +#ifndef isCNTRL +# define isCNTRL(c) ( (c) == '\0' || (c) == '\a' || (c) == '\b' \ + || (c) == '\f' || (c) == '\n' || (c) == '\r' \ + || (c) == '\t' || (c) == '\v' \ + || ((c) <= 3 && (c) >= 1) /* SOH, STX, ETX */ \ + || (c) == 7 /* U+7F DEL */ \ + || ((c) <= 0x13 && (c) >= 0x0E) /* SO, SI */ \ + /* DLE, DC[1-3] */ \ + || (c) == 0x18 /* U+18 CAN */ \ + || (c) == 0x19 /* U+19 EOM */ \ + || ((c) <= 0x1F && (c) >= 0x1C) /* [FGRU]S */ \ + || (c) == 0x26 /* U+17 ETB */ \ + || (c) == 0x27 /* U+1B ESC */ \ + || (c) == 0x2D /* U+05 ENQ */ \ + || (c) == 0x2E /* U+06 ACK */ \ + || (c) == 0x32 /* U+16 SYN */ \ + || (c) == 0x37 /* U+04 EOT */ \ + || (c) == 0x3C /* U+14 DC4 */ \ + || (c) == 0x3D /* U+15 NAK */ \ + || (c) == 0x3F /* U+1A SUB */ \ + ) +#endif + +#if '^' == 106 /* EBCDIC POSIX-BC */ +# define D_PPP_OUTLIER_CONTROL 0x5F +#else /* EBCDIC 1047 037 */ +# define D_PPP_OUTLIER_CONTROL 0xFF +#endif + +/* The controls are everything below blank, plus one outlier */ +#ifndef isCNTRL_L1 +# define isCNTRL_L1(c) ((WIDEST_UTYPE) (c) < ' ' \ + || (WIDEST_UTYPE) (c) == D_PPP_OUTLIER_CONTROL) +#endif + +/* The ordering of the tests in this and isUPPER are to exclude most characters + * early */ +#ifndef isLOWER +# define isLOWER(c) ( (c) >= 'a' && (c) <= 'z' \ + && ( (c) <= 'i' \ + || ((c) >= 'j' && (c) <= 'r') \ + || (c) >= 's')) +#endif + +#ifndef isUPPER +# define isUPPER(c) ( (c) >= 'A' && (c) <= 'Z' \ + && ( (c) <= 'I' \ + || ((c) >= 'J' && (c) <= 'R') \ + || (c) >= 'S')) +#endif + +#else /* Above is EBCDIC; below is ASCII */ + +# if (PERL_BCDVERSION < 0x5004000) +/* The implementation of these in older perl versions can give wrong results if + * the C program locale is set to other than the C locale */ +# undef isALNUM +# undef isALNUM_A +# undef isALPHA +# undef isALPHA_A +# undef isDIGIT +# undef isDIGIT_A +# undef isIDFIRST +# undef isIDFIRST_A +# undef isLOWER +# undef isLOWER_A +# undef isUPPER +# undef isUPPER_A +# endif + +# if (PERL_BCDVERSION == 0x5007000) /* this perl made space GRAPH */ +# undef isGRAPH +# endif + +# if (PERL_BCDVERSION < 0x5008000) /* earlier perls omitted DEL */ +# undef isCNTRL +# endif + +# if (PERL_BCDVERSION < 0x5010000) +/* earlier perls included all of the isSPACE() characters, which is wrong. The + * version provided by Devel::PPPort always overrides an existing buggy + * version. */ +# undef isPRINT +# undef isPRINT_A +# endif + +# if (PERL_BCDVERSION < 0x5014000) +/* earlier perls always returned true if the parameter was a signed char */ +# undef isASCII +# undef isASCII_A +# endif + +# if (PERL_BCDVERSION < 0x5017008) /* earlier perls didn't include PILCROW, SECTION SIGN */ +# undef isPUNCT_L1 +# endif + +# if (PERL_BCDVERSION < 0x5013007) /* khw didn't investigate why this failed */ +# undef isALNUMC_L1 +#endif + +# if (PERL_BCDVERSION < 0x5020000) /* earlier perls didn't include \v */ +# undef isSPACE +# undef isSPACE_A +# undef isSPACE_L1 + +# endif +#ifndef isASCII +# define isASCII(c) ((WIDEST_UTYPE) (c) <= 127) +#endif + +#ifndef isCNTRL +# define isCNTRL(c) ((WIDEST_UTYPE) (c) < ' ' || (c) == 127) +#endif + +#ifndef isCNTRL_L1 +# define isCNTRL_L1(c) ( (WIDEST_UTYPE) (c) < ' ' \ + || inRANGE((c), 0x7F, 0x9F)) +#endif + +#ifndef isLOWER +# define isLOWER(c) inRANGE((c), 'a', 'z') +#endif + +#ifndef isUPPER +# define isUPPER(c) inRANGE((c), 'A', 'Z') +#endif + +#endif /* Below are definitions common to EBCDIC and ASCII */ +#ifndef isASCII_L1 +# define isASCII_L1(c) isASCII(c) +#endif + +#ifndef isASCII_LC +# define isASCII_LC(c) isASCII(c) +#endif + +#ifndef isALNUM +# define isALNUM(c) isWORDCHAR(c) +#endif + +#ifndef isALNUMC +# define isALNUMC(c) isALPHANUMERIC(c) +#endif + +#ifndef isALNUMC_L1 +# define isALNUMC_L1(c) isALPHANUMERIC_L1(c) +#endif + +#ifndef isALPHA +# define isALPHA(c) (isUPPER(c) || isLOWER(c)) +#endif + +#ifndef isALPHA_L1 +# define isALPHA_L1(c) (isUPPER_L1(c) || isLOWER_L1(c)) +#endif + +#ifndef isALPHANUMERIC +# define isALPHANUMERIC(c) (isALPHA(c) || isDIGIT(c)) +#endif + +#ifndef isALPHANUMERIC_L1 +# define isALPHANUMERIC_L1(c) (isALPHA_L1(c) || isDIGIT(c)) +#endif + +#ifndef isALPHANUMERIC_LC +# define isALPHANUMERIC_LC(c) (isALPHA_LC(c) || isDIGIT_LC(c)) +#endif + +#ifndef isBLANK +# define isBLANK(c) ((c) == ' ' || (c) == '\t') +#endif + +#ifndef isBLANK_L1 +# define isBLANK_L1(c) ( isBLANK(c) \ + || ( FITS_IN_8_BITS(c) \ + && NATIVE_TO_LATIN1((U8) c) == 0xA0)) +#endif + +#ifndef isBLANK_LC +# define isBLANK_LC(c) isBLANK(c) +#endif + +#ifndef isDIGIT +# define isDIGIT(c) inRANGE(c, '0', '9') +#endif + +#ifndef isDIGIT_L1 +# define isDIGIT_L1(c) isDIGIT(c) +#endif + +#ifndef isGRAPH +# define isGRAPH(c) (isWORDCHAR(c) || isPUNCT(c)) +#endif + +#ifndef isGRAPH_L1 +# define isGRAPH_L1(c) ( isPRINT_L1(c) \ + && (c) != ' ' \ + && NATIVE_TO_LATIN1((U8) c) != 0xA0) +#endif + +#ifndef isIDCONT +# define isIDCONT(c) isWORDCHAR(c) +#endif + +#ifndef isIDCONT_L1 +# define isIDCONT_L1(c) isWORDCHAR_L1(c) +#endif + +#ifndef isIDCONT_LC +# define isIDCONT_LC(c) isWORDCHAR_LC(c) +#endif + +#ifndef isIDFIRST +# define isIDFIRST(c) (isALPHA(c) || (c) == '_') +#endif + +#ifndef isIDFIRST_L1 +# define isIDFIRST_L1(c) (isALPHA_L1(c) || (U8) (c) == '_') +#endif + +#ifndef isIDFIRST_LC +# define isIDFIRST_LC(c) (isALPHA_LC(c) || (U8) (c) == '_') +#endif + +#ifndef isLOWER_L1 +# define isLOWER_L1(c) ( isLOWER(c) \ + || ( FITS_IN_8_BITS(c) \ + && ( ( NATIVE_TO_LATIN1((U8) c) >= 0xDF \ + && NATIVE_TO_LATIN1((U8) c) != 0xF7) \ + || NATIVE_TO_LATIN1((U8) c) == 0xAA \ + || NATIVE_TO_LATIN1((U8) c) == 0xBA \ + || NATIVE_TO_LATIN1((U8) c) == 0xB5))) +#endif + +#ifndef isOCTAL +# define isOCTAL(c) (((WIDEST_UTYPE)((c)) & ~7) == '0') +#endif + +#ifndef isOCTAL_L1 +# define isOCTAL_L1(c) isOCTAL(c) +#endif + +#ifndef isPRINT +# define isPRINT(c) (isGRAPH(c) || (c) == ' ') +#endif + +#ifndef isPRINT_L1 +# define isPRINT_L1(c) (FITS_IN_8_BITS(c) && ! isCNTRL_L1(c)) +#endif + +#ifndef isPSXSPC +# define isPSXSPC(c) isSPACE(c) +#endif + +#ifndef isPSXSPC_L1 +# define isPSXSPC_L1(c) isSPACE_L1(c) +#endif + +#ifndef isPUNCT +# define isPUNCT(c) ( (c) == '-' || (c) == '!' || (c) == '"' \ + || (c) == '#' || (c) == '$' || (c) == '%' \ + || (c) == '&' || (c) == '\'' || (c) == '(' \ + || (c) == ')' || (c) == '*' || (c) == '+' \ + || (c) == ',' || (c) == '.' || (c) == '/' \ + || (c) == ':' || (c) == ';' || (c) == '<' \ + || (c) == '=' || (c) == '>' || (c) == '?' \ + || (c) == '@' || (c) == '[' || (c) == '\\' \ + || (c) == ']' || (c) == '^' || (c) == '_' \ + || (c) == '`' || (c) == '{' || (c) == '|' \ + || (c) == '}' || (c) == '~') +#endif + +#ifndef isPUNCT_L1 +# define isPUNCT_L1(c) ( isPUNCT(c) \ + || ( FITS_IN_8_BITS(c) \ + && ( NATIVE_TO_LATIN1((U8) c) == 0xA1 \ + || NATIVE_TO_LATIN1((U8) c) == 0xA7 \ + || NATIVE_TO_LATIN1((U8) c) == 0xAB \ + || NATIVE_TO_LATIN1((U8) c) == 0xB6 \ + || NATIVE_TO_LATIN1((U8) c) == 0xB7 \ + || NATIVE_TO_LATIN1((U8) c) == 0xBB \ + || NATIVE_TO_LATIN1((U8) c) == 0xBF))) +#endif + +#ifndef isSPACE +# define isSPACE(c) ( isBLANK(c) || (c) == '\n' || (c) == '\r' \ + || (c) == '\v' || (c) == '\f') +#endif + +#ifndef isSPACE_L1 +# define isSPACE_L1(c) ( isSPACE(c) \ + || (FITS_IN_8_BITS(c) \ + && ( NATIVE_TO_LATIN1((U8) c) == 0x85 \ + || NATIVE_TO_LATIN1((U8) c) == 0xA0))) +#endif + +#ifndef isUPPER_L1 +# define isUPPER_L1(c) ( isUPPER(c) \ + || (FITS_IN_8_BITS(c) \ + && ( NATIVE_TO_LATIN1((U8) c) >= 0xC0 \ + && NATIVE_TO_LATIN1((U8) c) <= 0xDE \ + && NATIVE_TO_LATIN1((U8) c) != 0xD7))) +#endif + +#ifndef isWORDCHAR +# define isWORDCHAR(c) (isALPHANUMERIC(c) || (c) == '_') +#endif + +#ifndef isWORDCHAR_L1 +# define isWORDCHAR_L1(c) (isIDFIRST_L1(c) || isDIGIT(c)) +#endif + +#ifndef isWORDCHAR_LC +# define isWORDCHAR_LC(c) (isIDFIRST_LC(c) || isDIGIT_LC(c)) +#endif + +#ifndef isXDIGIT +# define isXDIGIT(c) ( isDIGIT(c) \ + || inRANGE((c), 'a', 'f') \ + || inRANGE((c), 'A', 'F')) +#endif + +#ifndef isXDIGIT_L1 +# define isXDIGIT_L1(c) isXDIGIT(c) +#endif + +#ifndef isXDIGIT_LC +# define isXDIGIT_LC(c) isxdigit(c) +#endif +#ifndef isALNUM_A +# define isALNUM_A(c) isALNUM(c) +#endif + +#ifndef isALNUMC_A +# define isALNUMC_A(c) isALNUMC(c) +#endif + +#ifndef isALPHA_A +# define isALPHA_A(c) isALPHA(c) +#endif + +#ifndef isALPHANUMERIC_A +# define isALPHANUMERIC_A(c) isALPHANUMERIC(c) +#endif + +#ifndef isASCII_A +# define isASCII_A(c) isASCII(c) +#endif + +#ifndef isBLANK_A +# define isBLANK_A(c) isBLANK(c) +#endif + +#ifndef isCNTRL_A +# define isCNTRL_A(c) isCNTRL(c) +#endif + +#ifndef isDIGIT_A +# define isDIGIT_A(c) isDIGIT(c) +#endif + +#ifndef isGRAPH_A +# define isGRAPH_A(c) isGRAPH(c) +#endif + +#ifndef isIDCONT_A +# define isIDCONT_A(c) isIDCONT(c) +#endif + +#ifndef isIDFIRST_A +# define isIDFIRST_A(c) isIDFIRST(c) +#endif + +#ifndef isLOWER_A +# define isLOWER_A(c) isLOWER(c) +#endif + +#ifndef isOCTAL_A +# define isOCTAL_A(c) isOCTAL(c) +#endif + +#ifndef isPRINT_A +# define isPRINT_A(c) isPRINT(c) +#endif + +#ifndef isPSXSPC_A +# define isPSXSPC_A(c) isPSXSPC(c) +#endif + +#ifndef isPUNCT_A +# define isPUNCT_A(c) isPUNCT(c) +#endif + +#ifndef isSPACE_A +# define isSPACE_A(c) isSPACE(c) +#endif + +#ifndef isUPPER_A +# define isUPPER_A(c) isUPPER(c) +#endif + +#ifndef isWORDCHAR_A +# define isWORDCHAR_A(c) isWORDCHAR(c) +#endif + +#ifndef isXDIGIT_A +# define isXDIGIT_A(c) isXDIGIT(c) +#endif +#ifndef isASCII_utf8_safe +# define isASCII_utf8_safe(s,e) (((e) - (s)) <= 0 ? 0 : isASCII(*(s))) +#endif + +#ifndef isASCII_uvchr +# define isASCII_uvchr(c) (FITS_IN_8_BITS(c) ? isASCII_L1(c) : 0) +#endif + +#if (PERL_BCDVERSION >= 0x5006000) +# ifdef isALPHA_uni /* If one defined, all are; this is just an exemplar */ +# define D_PPP_is_ctype(upper, lower, c) \ + (FITS_IN_8_BITS(c) \ + ? is ## upper ## _L1(c) \ + : is ## upper ## _uni((UV) (c))) /* _uni is old synonym */ +# else +# define D_PPP_is_ctype(upper, lower, c) \ + (FITS_IN_8_BITS(c) \ + ? is ## upper ## _L1(c) \ + : is_uni_ ## lower((UV) (c))) /* is_uni_ is even older */ +# endif +#ifndef isALPHA_uvchr +# define isALPHA_uvchr(c) D_PPP_is_ctype(ALPHA, alpha, c) +#endif + +#ifndef isALPHANUMERIC_uvchr +# define isALPHANUMERIC_uvchr(c) (isALPHA_uvchr(c) || isDIGIT_uvchr(c)) +#endif + +# ifdef is_uni_blank +#ifndef isBLANK_uvchr +# define isBLANK_uvchr(c) D_PPP_is_ctype(BLANK, blank, c) +#endif + +# else +#ifndef isBLANK_uvchr +# define isBLANK_uvchr(c) (FITS_IN_8_BITS(c) \ + ? isBLANK_L1(c) \ + : ( (UV) (c) == 0x1680 /* Unicode 3.0 */ \ + || inRANGE((UV) (c), 0x2000, 0x200A) \ + || (UV) (c) == 0x202F /* Unicode 3.0 */\ + || (UV) (c) == 0x205F /* Unicode 3.2 */\ + || (UV) (c) == 0x3000)) +#endif + +# endif +#ifndef isCNTRL_uvchr +# define isCNTRL_uvchr(c) D_PPP_is_ctype(CNTRL, cntrl, c) +#endif + +#ifndef isDIGIT_uvchr +# define isDIGIT_uvchr(c) D_PPP_is_ctype(DIGIT, digit, c) +#endif + +#ifndef isGRAPH_uvchr +# define isGRAPH_uvchr(c) D_PPP_is_ctype(GRAPH, graph, c) +#endif + +#ifndef isIDCONT_uvchr +# define isIDCONT_uvchr(c) isWORDCHAR_uvchr(c) +#endif + +#ifndef isIDFIRST_uvchr +# define isIDFIRST_uvchr(c) D_PPP_is_ctype(IDFIRST, idfirst, c) +#endif + +#ifndef isLOWER_uvchr +# define isLOWER_uvchr(c) D_PPP_is_ctype(LOWER, lower, c) +#endif + +#ifndef isPRINT_uvchr +# define isPRINT_uvchr(c) D_PPP_is_ctype(PRINT, print, c) +#endif + +#ifndef isPSXSPC_uvchr +# define isPSXSPC_uvchr(c) isSPACE_uvchr(c) +#endif + +#ifndef isPUNCT_uvchr +# define isPUNCT_uvchr(c) D_PPP_is_ctype(PUNCT, punct, c) +#endif + +#ifndef isSPACE_uvchr +# define isSPACE_uvchr(c) D_PPP_is_ctype(SPACE, space, c) +#endif + +#ifndef isUPPER_uvchr +# define isUPPER_uvchr(c) D_PPP_is_ctype(UPPER, upper, c) +#endif + +#ifndef isXDIGIT_uvchr +# define isXDIGIT_uvchr(c) D_PPP_is_ctype(XDIGIT, xdigit, c) +#endif + +#ifndef isWORDCHAR_uvchr +# define isWORDCHAR_uvchr(c) (FITS_IN_8_BITS(c) \ + ? isWORDCHAR_L1(c) : isALPHANUMERIC_uvchr(c)) +#endif +#ifndef isALPHA_utf8_safe +# define isALPHA_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHA) +#endif + +# ifdef isALPHANUMERIC_utf8 +#ifndef isALPHANUMERIC_utf8_safe +# define isALPHANUMERIC_utf8_safe(s,e) \ + D_PPP_IS_GENERIC_UTF8_SAFE(s, e, ALPHANUMERIC) +#endif + +# else +#ifndef isALPHANUMERIC_utf8_safe +# define isALPHANUMERIC_utf8_safe(s,e) \ + (isALPHA_utf8_safe(s,e) || isDIGIT_utf8_safe(s,e)) +#endif + +# endif + +/* This was broken before 5.18, and just use this instead of worrying about + * which releases the official works on */ +# if 'A' == 65 +#ifndef isBLANK_utf8_safe +# define isBLANK_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? /* Machine generated */ \ + ( ( 0x09 == ((const U8*)s)[0] || 0x20 == ((const U8*)s)[0] ) ? 1 \ + : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ + ( ( 0xC2 == ((const U8*)s)[0] ) ? \ + ( ( 0xA0 == ((const U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0xE1 == ((const U8*)s)[0] ) ? \ + ( ( ( 0x9A == ((const U8*)s)[1] ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( 0xE2 == ((const U8*)s)[0] ) ? \ + ( ( 0x80 == ((const U8*)s)[1] ) ? \ + ( ( inRANGE(((const U8*)s)[2], 0x80, 0x8A ) || 0xAF == ((const U8*)s)[2] ) ? 3 : 0 )\ + : ( ( 0x81 == ((const U8*)s)[1] ) && ( 0x9F == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( ( ( 0xE3 == ((const U8*)s)[0] ) && ( 0x80 == ((const U8*)s)[1] ) ) && ( 0x80 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : 0 ) \ + : 0 ) +#endif + +# elif 'A' == 193 && '^' == 95 /* EBCDIC 1047 */ +#ifndef isBLANK_utf8_safe +# define isBLANK_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? \ + ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1 \ + : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ + ( ( 0x80 == ((const U8*)s)[0] ) ? \ + ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0xBC == ((const U8*)s)[0] ) ? \ + ( ( ( 0x63 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( 0xCA == ((const U8*)s)[0] ) ? \ + ( ( 0x41 == ((const U8*)s)[1] ) ? \ + ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\ + : ( 0x42 == ((const U8*)s)[1] ) ? \ + ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x73 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : 0 ) \ +: 0 ) +#endif + +# elif 'A' == 193 && '^' == 176 /* EBCDIC 037 */ +#ifndef isBLANK_utf8_safe +# define isBLANK_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? \ + ( ( 0x05 == ((const U8*)s)[0] || 0x40 == ((const U8*)s)[0] ) ? 1 \ + : ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) ? \ + ( ( 0x78 == ((const U8*)s)[0] ) ? \ + ( ( 0x41 == ((const U8*)s)[1] ) ? 2 : 0 ) \ + : ( 0xBD == ((const U8*)s)[0] ) ? \ + ( ( ( 0x62 == ((const U8*)s)[1] ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( 0xCA == ((const U8*)s)[0] ) ? \ + ( ( 0x41 == ((const U8*)s)[1] ) ? \ + ( ( inRANGE(((const U8*)s)[2], 0x41, 0x4A ) || 0x51 == ((const U8*)s)[2] ) ? 3 : 0 )\ + : ( 0x42 == ((const U8*)s)[1] ) ? \ + ( ( 0x56 == ((const U8*)s)[2] ) ? 3 : 0 ) \ + : ( ( 0x43 == ((const U8*)s)[1] ) && ( 0x72 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : ( ( ( 0xCE == ((const U8*)s)[0] ) && ( 0x41 == ((const U8*)s)[1] ) ) && ( 0x41 == ((const U8*)s)[2] ) ) ? 3 : 0 )\ + : 0 ) \ +: 0 ) +#endif + +# else +# error Unknown character set +# endif +#ifndef isCNTRL_utf8_safe +# define isCNTRL_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, CNTRL) +#endif + +#ifndef isDIGIT_utf8_safe +# define isDIGIT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, DIGIT) +#endif + +#ifndef isGRAPH_utf8_safe +# define isGRAPH_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, GRAPH) +#endif + +# ifdef isIDCONT_utf8 +#ifndef isIDCONT_utf8_safe +# define isIDCONT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDCONT) +#endif + +# else +#ifndef isIDCONT_utf8_safe +# define isIDCONT_utf8_safe(s,e) isWORDCHAR_utf8_safe(s,e) +#endif + +# endif +#ifndef isIDFIRST_utf8_safe +# define isIDFIRST_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, IDFIRST) +#endif + +#ifndef isLOWER_utf8_safe +# define isLOWER_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, LOWER) +#endif + +#ifndef isPRINT_utf8_safe +# define isPRINT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PRINT) +#endif + +# undef isPSXSPC_utf8_safe /* Use the modern definition */ +#ifndef isPSXSPC_utf8_safe +# define isPSXSPC_utf8_safe(s,e) isSPACE_utf8_safe(s,e) +#endif +#ifndef isPUNCT_utf8_safe +# define isPUNCT_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, PUNCT) +#endif + +#ifndef isSPACE_utf8_safe +# define isSPACE_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, SPACE) +#endif + +#ifndef isUPPER_utf8_safe +# define isUPPER_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, UPPER) +#endif + +# ifdef isWORDCHAR_utf8 +#ifndef isWORDCHAR_utf8_safe +# define isWORDCHAR_utf8_safe(s,e) D_PPP_IS_GENERIC_UTF8_SAFE(s, e, WORDCHAR) +#endif + +# else +#ifndef isWORDCHAR_utf8_safe +# define isWORDCHAR_utf8_safe(s,e) \ + (isALPHANUMERIC_utf8_safe(s,e) || (*(s)) == '_') +#endif + +# endif + +/* This was broken before 5.12, and just use this instead of worrying about + * which releases the official works on */ +# if 'A' == 65 +#ifndef isXDIGIT_utf8_safe +# define isXDIGIT_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? \ + ( ( inRANGE(((const U8*)s)[0], 0x30, 0x39 ) || inRANGE(((const U8*)s)[0], 0x41, 0x46 ) || inRANGE(((const U8*)s)[0], 0x61, 0x66 ) ) ? 1\ + : ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xEF == ((const U8*)s)[0] ) ) ? ( ( 0xBC == ((const U8*)s)[1] ) ?\ + ( ( inRANGE(((const U8*)s)[2], 0x90, 0x99 ) || inRANGE(((const U8*)s)[2], 0xA1, 0xA6 ) ) ? 3 : 0 )\ + : ( ( 0xBD == ((const U8*)s)[1] ) && ( inRANGE(((const U8*)s)[2], 0x81, 0x86 ) ) ) ? 3 : 0 ) : 0 )\ +: 0 ) +#endif + +# elif 'A' == 193 && '^' == 95 /* EBCDIC 1047 */ +#ifndef isXDIGIT_utf8_safe +# define isXDIGIT_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? \ + ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\ + : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x73 == ((const U8*)s)[1] ) ) ? ( ( 0x67 == ((const U8*)s)[2] ) ?\ + ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || inRANGE(((const U8*)s)[3], 0x62, 0x68 ) ) ? 4 : 0 )\ + : ( ( inRANGE(((const U8*)s)[2], 0x68, 0x69 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\ +: 0 ) +#endif + +# elif 'A' == 193 && '^' == 176 /* EBCDIC 037 */ +#ifndef isXDIGIT_utf8_safe +# define isXDIGIT_utf8_safe(s,e) \ +( ( LIKELY((e) > (s)) ) ? \ + ( ( inRANGE(((const U8*)s)[0], 0x81, 0x86 ) || inRANGE(((const U8*)s)[0], 0xC1, 0xC6 ) || inRANGE(((const U8*)s)[0], 0xF0, 0xF9 ) ) ? 1\ + : ( ( ( LIKELY(((e) - (s)) >= UTF8SKIP(s)) ) && ( 0xDD == ((const U8*)s)[0] ) ) && ( 0x72 == ((const U8*)s)[1] ) ) ? ( ( 0x66 == ((const U8*)s)[2] ) ?\ + ( ( inRANGE(((const U8*)s)[3], 0x57, 0x59 ) || 0x5F == ((const U8*)s)[3] || inRANGE(((const U8*)s)[3], 0x62, 0x67 ) ) ? 4 : 0 )\ + : ( ( inRANGE(((const U8*)s)[2], 0x67, 0x68 ) ) && ( inRANGE(((const U8*)s)[3], 0x42, 0x47 ) ) ) ? 4 : 0 ) : 0 )\ +: 0 ) +#endif + +# else +# error Unknown character set +# endif +#ifndef isALPHA_LC_utf8_safe +# define isALPHA_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHA) +#endif + +# ifdef isALPHANUMERIC_utf8 +#ifndef isALPHANUMERIC_LC_utf8_safe +# define isALPHANUMERIC_LC_utf8_safe(s,e) \ + D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, ALPHANUMERIC) +#endif + +# else +#ifndef isALPHANUMERIC_LC_utf8_safe +# define isALPHANUMERIC_LC_utf8_safe(s,e) \ + (isALPHA_LC_utf8_safe(s,e) || isDIGIT_LC_utf8_safe(s,e)) +#endif + +# endif +#ifndef isBLANK_LC_utf8_safe +# define isBLANK_LC_utf8_safe(s,e) \ + D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, BLANK) +#endif + +#ifndef isCNTRL_LC_utf8_safe +# define isCNTRL_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, CNTRL) +#endif + +#ifndef isDIGIT_LC_utf8_safe +# define isDIGIT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, DIGIT) +#endif + +#ifndef isGRAPH_LC_utf8_safe +# define isGRAPH_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, GRAPH) +#endif + +# ifdef isIDCONT_utf8 +#ifndef isIDCONT_LC_utf8_safe +# define isIDCONT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDCONT) +#endif + +# else +#ifndef isIDCONT_LC_utf8_safe +# define isIDCONT_LC_utf8_safe(s,e) isWORDCHAR_LC_utf8_safe(s,e) +#endif + +# endif +#ifndef isIDFIRST_LC_utf8_safe +# define isIDFIRST_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, IDFIRST) +#endif + +#ifndef isLOWER_LC_utf8_safe +# define isLOWER_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, LOWER) +#endif + +#ifndef isPRINT_LC_utf8_safe +# define isPRINT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PRINT) +#endif + +# undef isPSXSPC_LC_utf8_safe /* Use the modern definition */ +#ifndef isPSXSPC_LC_utf8_safe +# define isPSXSPC_LC_utf8_safe(s,e) isSPACE_LC_utf8_safe(s,e) +#endif +#ifndef isPUNCT_LC_utf8_safe +# define isPUNCT_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, PUNCT) +#endif + +#ifndef isSPACE_LC_utf8_safe +# define isSPACE_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, SPACE) +#endif + +#ifndef isUPPER_LC_utf8_safe +# define isUPPER_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, UPPER) +#endif + +# ifdef isWORDCHAR_utf8 +#ifndef isWORDCHAR_LC_utf8_safe +# define isWORDCHAR_LC_utf8_safe(s,e) D_PPP_IS_GENERIC_LC_UTF8_SAFE(s, e, WORDCHAR) +#endif + +# else +#ifndef isWORDCHAR_LC_utf8_safe +# define isWORDCHAR_LC_utf8_safe(s,e) \ + (isALPHANUMERIC_LC_utf8_safe(s,e) || (*(s)) == '_') +#endif + +# endif +#ifndef isXDIGIT_LC_utf8_safe +# define isXDIGIT_LC_utf8_safe(s,e) \ + D_PPP_IS_GENERIC_LC_UTF8_SAFE_BROKEN(s, e, XDIGIT) +#endif + +/* Warning: isALPHANUMERIC_utf8_safe, isALPHA_utf8_safe, isASCII_utf8_safe, + * isBLANK_utf8_safe, isCNTRL_utf8_safe, isDIGIT_utf8_safe, isGRAPH_utf8_safe, + * isIDCONT_utf8_safe, isIDFIRST_utf8_safe, isLOWER_utf8_safe, + * isPRINT_utf8_safe, isPSXSPC_utf8_safe, isPUNCT_utf8_safe, isSPACE_utf8_safe, + * isUPPER_utf8_safe, isWORDCHAR_utf8_safe, isWORDCHAR_utf8_safe, + * isXDIGIT_utf8_safe, + * isALPHANUMERIC_LC_utf8_safe, isALPHA_LC_utf8_safe, isASCII_LC_utf8_safe, + * isBLANK_LC_utf8_safe, isCNTRL_LC_utf8_safe, isDIGIT_LC_utf8_safe, + * isGRAPH_LC_utf8_safe, isIDCONT_LC_utf8_safe, isIDFIRST_LC_utf8_safe, + * isLOWER_LC_utf8_safe, isPRINT_LC_utf8_safe, isPSXSPC_LC_utf8_safe, + * isPUNCT_LC_utf8_safe, isSPACE_LC_utf8_safe, isUPPER_LC_utf8_safe, + * isWORDCHAR_LC_utf8_safe, isWORDCHAR_LC_utf8_safe, isXDIGIT_LC_utf8_safe, + * isALPHANUMERIC_uvchr, isALPHA_uvchr, isASCII_uvchr, isBLANK_uvchr, + * isCNTRL_uvchr, isDIGIT_uvchr, isGRAPH_uvchr, isIDCONT_uvchr, + * isIDFIRST_uvchr, isLOWER_uvchr, isPRINT_uvchr, isPSXSPC_uvchr, + * isPUNCT_uvchr, isSPACE_uvchr, isUPPER_uvchr, isWORDCHAR_uvchr, + * isWORDCHAR_uvchr, isXDIGIT_uvchr + * + * The UTF-8 handling is buggy in early Perls, and this can give inaccurate + * results for code points above 0xFF, until the implementation started + * settling down in 5.12 and 5.14 */ + +#endif + +#define D_PPP_TOO_SHORT_MSG "Malformed UTF-8 character starting with:" \ + " \\x%02x (too short; %d bytes available, need" \ + " %d)\n" +/* Perls starting here had a new API which handled multi-character results */ +#if (PERL_BCDVERSION >= 0x5007003) +#ifndef toLOWER_uvchr +# define toLOWER_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_lower(NATIVE_TO_UNI(c), s, l)) +#endif + +#ifndef toUPPER_uvchr +# define toUPPER_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_upper(NATIVE_TO_UNI(c), s, l)) +#endif + +#ifndef toTITLE_uvchr +# define toTITLE_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_title(NATIVE_TO_UNI(c), s, l)) +#endif + +#ifndef toFOLD_uvchr +# define toFOLD_uvchr(c, s, l) UNI_TO_NATIVE(to_uni_fold( NATIVE_TO_UNI(c), s, l)) +#endif + +# if (PERL_BCDVERSION != 0x5015006) /* Just this version is broken */ + + /* Prefer the macro to the function */ +# if defined toLOWER_utf8 +# define D_PPP_TO_LOWER_CALLEE(s,r,l) toLOWER_utf8(s,r,l) +# else +# define D_PPP_TO_LOWER_CALLEE(s,r,l) to_utf8_lower(s,r,l) +# endif +# if defined toTITLE_utf8 +# define D_PPP_TO_TITLE_CALLEE(s,r,l) toTITLE_utf8(s,r,l) +# else +# define D_PPP_TO_TITLE_CALLEE(s,r,l) to_utf8_title(s,r,l) +# endif +# if defined toUPPER_utf8 +# define D_PPP_TO_UPPER_CALLEE(s,r,l) toUPPER_utf8(s,r,l) +# else +# define D_PPP_TO_UPPER_CALLEE(s,r,l) to_utf8_upper(s,r,l) +# endif +# if defined toFOLD_utf8 +# define D_PPP_TO_FOLD_CALLEE(s,r,l) toFOLD_utf8(s,r,l) +# else +# define D_PPP_TO_FOLD_CALLEE(s,r,l) to_utf8_fold(s,r,l) +# endif +# else /* Below is 5.15.6, which failed to make the macros available +# outside of core, so we have to use the 'Perl_' form. khw +# decided it was easier to just handle this case than have to +# document the exception, and make an exception in the tests below +# */ +# define D_PPP_TO_LOWER_CALLEE(s,r,l) \ + Perl__to_utf8_lower_flags(aTHX_ s, r, l, 0, NULL) +# define D_PPP_TO_TITLE_CALLEE(s,r,l) \ + Perl__to_utf8_title_flags(aTHX_ s, r, l, 0, NULL) +# define D_PPP_TO_UPPER_CALLEE(s,r,l) \ + Perl__to_utf8_upper_flags(aTHX_ s, r, l, 0, NULL) +# define D_PPP_TO_FOLD_CALLEE(s,r,l) \ + Perl__to_utf8_fold_flags(aTHX_ s, r, l, FOLD_FLAGS_FULL, NULL) +# endif + +/* The actual implementation of the backported macros. If too short, croak, + * otherwise call the original that doesn't have an upper limit parameter */ +# define D_PPP_GENERIC_MULTI_ARG_TO(name, s, e,r,l) \ + (((((e) - (s)) <= 0) \ + /* We could just do nothing, but modern perls croak */ \ + ? (croak("Attempting case change on zero length string"), \ + 0) /* So looks like it returns something, and will compile */ \ + : ((e) - (s)) < UTF8SKIP(s)) \ + ? (croak(D_PPP_TOO_SHORT_MSG, \ + s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \ + 0) \ + : D_PPP_TO_ ## name ## _CALLEE(s,r,l)) +#ifndef toUPPER_utf8_safe +# define toUPPER_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_MULTI_ARG_TO(UPPER,s,e,r,l) +#endif + +#ifndef toLOWER_utf8_safe +# define toLOWER_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_MULTI_ARG_TO(LOWER,s,e,r,l) +#endif + +#ifndef toTITLE_utf8_safe +# define toTITLE_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_MULTI_ARG_TO(TITLE,s,e,r,l) +#endif + +#ifndef toFOLD_utf8_safe +# define toFOLD_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_MULTI_ARG_TO(FOLD,s,e,r,l) +#endif + +#elif (PERL_BCDVERSION >= 0x5006000) + +/* Here we have UTF-8 support, but using the original API where the case + * changing functions merely returned the changed code point; hence they + * couldn't handle multi-character results. */ + +# ifdef uvchr_to_utf8 +# define D_PPP_UV_TO_UTF8 uvchr_to_utf8 +# else +# define D_PPP_UV_TO_UTF8 uv_to_utf8 +# endif + + /* Get the utf8 of the case changed value, and store its length; then have + * to re-calculate the changed case value in order to return it */ +# define D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(name, c, s, l) \ + (*(l) = (D_PPP_UV_TO_UTF8(s, \ + UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c)))) - (s)), \ + UNI_TO_NATIVE(to_uni_ ## name(NATIVE_TO_UNI(c)))) +#ifndef toLOWER_uvchr +# define toLOWER_uvchr(c, s, l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(lower, c, s, l) +#endif + +#ifndef toUPPER_uvchr +# define toUPPER_uvchr(c, s, l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(upper, c, s, l) +#endif + +#ifndef toTITLE_uvchr +# define toTITLE_uvchr(c, s, l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UVCHR(title, c, s, l) +#endif + +#ifndef toFOLD_uvchr +# define toFOLD_uvchr(c, s, l) toLOWER_uvchr(c, s, l) +#endif + +# define D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(name, s, e, r, l) \ + (((((e) - (s)) <= 0) \ + ? (croak("Attempting case change on zero length string"), \ + 0) /* So looks like it returns something, and will compile */ \ + : ((e) - (s)) < UTF8SKIP(s)) \ + ? (croak(D_PPP_TOO_SHORT_MSG, \ + s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \ + 0) \ + /* Get the changed code point and store its UTF-8 */ \ + : D_PPP_UV_TO_UTF8(r, to_utf8_ ## name(s)), \ + /* Then store its length, and re-get code point for return */ \ + *(l) = UTF8SKIP(r), to_utf8_ ## name(r)) + +/* Warning: toUPPER_utf8_safe, toLOWER_utf8_safe, toTITLE_utf8_safe, + * toUPPER_uvchr, toLOWER_uvchr, toTITLE_uvchr + The UTF-8 case changing operations had bugs before around 5.12 or 5.14; + this backport does not correct them. + + In perls before 7.3, multi-character case changing is not implemented; this + backport uses the simple case changes available in those perls. */ +#ifndef toUPPER_utf8_safe +# define toUPPER_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(upper, s, e, r, l) +#endif + +#ifndef toLOWER_utf8_safe +# define toLOWER_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(lower, s, e, r, l) +#endif + +#ifndef toTITLE_utf8_safe +# define toTITLE_utf8_safe(s,e,r,l) \ + D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(title, s, e, r, l) +#endif + + /* Warning: toFOLD_utf8_safe, toFOLD_uvchr + The UTF-8 case changing operations had bugs before around 5.12 or 5.14; + this backport does not correct them. + + In perls before 7.3, case folding is not implemented; instead, this + backport substitutes simple (not multi-character, which isn't available) + lowercasing. This gives the correct result in most, but not all, instances + */ +#ifndef toFOLD_utf8_safe +# define toFOLD_utf8_safe(s,e,r,l) toLOWER_utf8_safe(s,e,r,l) +#endif + +#endif + +/* Until we figure out how to support this in older perls... */ +#if (PERL_BCDVERSION >= 0x5008000) +#ifndef HeUTF8 +# define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \ + SvUTF8(HeKEY_sv(he)) : \ + (U32)HeKUTF8(he)) +#endif + +#endif +#ifndef C_ARRAY_LENGTH +# define C_ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) +#endif + +#ifndef C_ARRAY_END +# define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a)) +#endif +#ifndef LIKELY +# define LIKELY(x) (x) +#endif + +#ifndef UNLIKELY +# define UNLIKELY(x) (x) +#endif + +#ifndef MUTABLE_PTR +#if defined(PERL_USE_GCC_BRACE_GROUPS) +# define MUTABLE_PTR(p) ({ void *_p = (p); _p; }) +#else +# define MUTABLE_PTR(p) ((void *) (p)) +#endif +#endif +#ifndef MUTABLE_AV +# define MUTABLE_AV(p) ((AV *)MUTABLE_PTR(p)) +#endif + +#ifndef MUTABLE_CV +# define MUTABLE_CV(p) ((CV *)MUTABLE_PTR(p)) +#endif + +#ifndef MUTABLE_GV +# define MUTABLE_GV(p) ((GV *)MUTABLE_PTR(p)) +#endif + +#ifndef MUTABLE_HV +# define MUTABLE_HV(p) ((HV *)MUTABLE_PTR(p)) +#endif + +#ifndef MUTABLE_IO +# define MUTABLE_IO(p) ((IO *)MUTABLE_PTR(p)) +#endif + +#ifndef MUTABLE_SV +# define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(vnewSVpvf) +#if defined(PERL_USE_GCC_BRACE_GROUPS) +# define vnewSVpvf(pat, args) ({ SV *_sv = newSV(0); sv_vsetpvfn(_sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)); _sv; }) +#else +# define vnewSVpvf(pat, args) ((PL_Sv = newSV(0)), sv_vsetpvfn(PL_Sv, (pat), strlen((pat)), (args), Null(SV**), 0, Null(bool*)), PL_Sv) +#endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf) +# define sv_vcatpvf(sv, pat, args) sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf) +# define sv_vsetpvf(sv, pat, args) sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)) +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg) +#if defined(NEED_sv_catpvf_mg) +static void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); +#endif + +#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL) + +#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg) + + +void +DPPP_(my_sv_catpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_catpvf_mg_nocontext) +#if defined(NEED_sv_catpvf_mg_nocontext) +static void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); +static +#else +extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); +#endif + +#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL) + +#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) +#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext) + + +void +DPPP_(my_sv_catpvf_mg_nocontext)(SV * const sv, const char * const pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_catpvf_mg depends on sv_catpvf_mg_nocontext */ +#ifndef sv_catpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext +# else +# define sv_catpvf_mg Perl_sv_catpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vcatpvf_mg) +# define sv_vcatpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg) +#if defined(NEED_sv_setpvf_mg) +static void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...); +#endif + +#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL) + +#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg) + + +void +DPPP_(my_sv_setpvf_mg)(pTHX_ SV * const sv, const char * const pat, ...) +{ + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif + +#ifdef PERL_IMPLICIT_CONTEXT +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_setpvf_mg_nocontext) +#if defined(NEED_sv_setpvf_mg_nocontext) +static void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); +static +#else +extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...); +#endif + +#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL) + +#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) +#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext) + + +void +DPPP_(my_sv_setpvf_mg_nocontext)(SV * const sv, const char * const pat, ...) +{ + dTHX; + va_list args; + va_start(args, pat); + sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*)); + SvSETMAGIC(sv); + va_end(args); +} + +#endif +#endif +#endif + +/* sv_setpvf_mg depends on sv_setpvf_mg_nocontext */ +#ifndef sv_setpvf_mg +# ifdef PERL_IMPLICIT_CONTEXT +# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext +# else +# define sv_setpvf_mg Perl_sv_setpvf_mg +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(sv_vsetpvf_mg) +# define sv_vsetpvf_mg(sv, pat, args) \ + STMT_START { \ + sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*)); \ + SvSETMAGIC(sv); \ + } STMT_END +#endif + +/* Hint: sv_2pv_nolen + * Use the SvPV_nolen() or SvPV_nolen_const() macros instead of sv_2pv_nolen(). + */ +#ifndef sv_2pv_nolen +# define sv_2pv_nolen(sv) SvPV_nolen(sv) +#endif + +#ifdef SvPVbyte + +/* Hint: SvPVbyte + * Does not work in perl-5.6.1, ppport.h implements a version + * borrowed from perl-5.7.3. + */ + +#if (PERL_BCDVERSION < 0x5007000) +#ifndef sv_2pvbyte +# define sv_2pvbyte(sv, lp) (sv_utf8_downgrade((sv), 0), SvPV((sv), *(lp))) +#endif + +/* Hint: sv_2pvbyte + * Use the SvPVbyte() macro instead of sv_2pvbyte(). + */ + +/* Replace sv_2pvbyte with SvPVbyte */ + +#undef SvPVbyte + +#define SvPVbyte(sv, lp) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_UTF8)) == (SVf_POK) \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pvbyte(sv, &lp)) + +#endif + +#else + +# define SvPVbyte SvPV +# define sv_2pvbyte sv_2pv + +#endif +#ifndef sv_2pvbyte_nolen +# define sv_2pvbyte_nolen(sv) sv_2pv_nolen(sv) +#endif + +/* Hint: sv_pvn + * Always use the SvPV() macro instead of sv_pvn(). + */ + +/* Replace sv_pvn with SvPV */ + +/* Hint: sv_pvn_force + * Always use the SvPV_force() macro instead of sv_pvn_force(). + */ + +/* Replace sv_pvn_force with SvPV_force */ + +/* If these are undefined, they're not handled by the core anyway */ +#ifndef SV_IMMEDIATE_UNREF +# define SV_IMMEDIATE_UNREF 0 +#endif + +#ifndef SV_GMAGIC +# define SV_GMAGIC 0 +#endif + +#ifndef SV_COW_DROP_PV +# define SV_COW_DROP_PV 0 +#endif + +#ifndef SV_UTF8_NO_ENCODING +# define SV_UTF8_NO_ENCODING 0 +#endif + +#ifndef SV_CONST_RETURN +# define SV_CONST_RETURN 0 +#endif + +#ifndef SV_MUTABLE_RETURN +# define SV_MUTABLE_RETURN 0 +#endif + +#ifndef SV_SMAGIC +# define SV_SMAGIC 0 +#endif + +#ifndef SV_HAS_TRAILING_NUL +# define SV_HAS_TRAILING_NUL 0 +#endif + +#ifndef SV_COW_SHARED_HASH_KEYS +# define SV_COW_SHARED_HASH_KEYS 0 +#endif + +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef sv_2pv_flags +# define sv_2pv_flags(sv, lp, flags) ({ SV *_sv = (sv); const I32 _flags = (flags); STRLEN *_lp = lp; _lp = _lp ? : &PL_na; (!(_flags & SV_GMAGIC) && SvGMAGICAL(_sv)) ? ({ char *_pv; SvGMAGICAL_off(_sv); _pv = sv_2pv(_sv, _lp); SvGMAGICAL_on(_sv); _pv; }) : sv_2pv(_sv, _lp); }) +#endif + +#ifndef sv_pvn_force_flags +# define sv_pvn_force_flags(sv, lp, flags) ({ SV *_sv = (sv); const I32 _flags = (flags); STRLEN *_lp = lp; _lp = _lp ? : &PL_na; (!(_flags & SV_GMAGIC) && SvGMAGICAL(_sv)) ? ({ char *_pv; SvGMAGICAL_off(_sv); _pv = sv_pvn_force(_sv, _lp); SvGMAGICAL_on(_sv); _pv; }) : sv_pvn_force(_sv, _lp); }) +#endif + +#else +#ifndef sv_2pv_flags +# define sv_2pv_flags(sv, lp, flags) ((PL_Sv = (sv)), (!((flags) & SV_GMAGIC) && SvGMAGICAL(PL_Sv)) ? (SvGMAGICAL_off(PL_Sv), (PL_Xpv = (XPV *)sv_2pv(PL_Sv, (lp) ? (lp) : &PL_na)), SvGMAGICAL_on(PL_Sv), (char *)PL_Xpv) : sv_2pv(PL_Sv, (lp) ? (lp) : &PL_na)) +#endif + +#ifndef sv_pvn_force_flags +# define sv_pvn_force_flags(sv, lp, flags) ((PL_Sv = (sv)), (!((flags) & SV_GMAGIC) && SvGMAGICAL(PL_Sv)) ? (SvGMAGICAL_off(PL_Sv), (PL_Xpv = (XPV *)sv_pvn_force(PL_Sv, (lp) ? (lp) : &PL_na)), SvGMAGICAL_on(PL_Sv), (char *)PL_Xpv) : sv_pvn_force(PL_Sv, (lp) ? (lp) : &PL_na)) +#endif + +#endif + +#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) ) +# define D_PPP_SVPV_NOLEN_LP_ARG &PL_na +#else +# define D_PPP_SVPV_NOLEN_LP_ARG 0 +#endif +#ifndef SvPV_const +# define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_mutable +# define SvPV_mutable(sv, lp) SvPV_flags_mutable(sv, lp, SV_GMAGIC) +#endif +#ifndef SvPV_flags +# define SvPV_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_2pv_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_flags_const +# define SvPV_flags_const(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_const(sv)) : \ + (const char*) sv_2pv_flags(sv, &lp, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_const_nolen +# define SvPV_flags_const_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : \ + (const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN)) +#endif +#ifndef SvPV_flags_mutable +# define SvPV_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) : \ + sv_2pv_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_force +# define SvPV_force(sv, lp) SvPV_force_flags(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nolen +# define SvPV_force_nolen(sv) SvPV_force_flags_nolen(sv, SV_GMAGIC) +#endif + +#ifndef SvPV_force_mutable +# define SvPV_force_mutable(sv, lp) SvPV_force_flags_mutable(sv, lp, SV_GMAGIC) +#endif + +#ifndef SvPV_force_nomg +# define SvPV_force_nomg(sv, lp) SvPV_force_flags(sv, lp, 0) +#endif + +#ifndef SvPV_force_nomg_nolen +# define SvPV_force_nomg_nolen(sv) SvPV_force_flags_nolen(sv, 0) +#endif +#ifndef SvPV_force_flags +# define SvPV_force_flags(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX(sv)) : sv_pvn_force_flags(sv, &lp, flags)) +#endif +#ifndef SvPV_force_flags_nolen +# define SvPV_force_flags_nolen(sv, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags)) +#endif +#ifndef SvPV_force_flags_mutable +# define SvPV_force_flags_mutable(sv, lp, flags) \ + ((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \ + ? ((lp = SvCUR(sv)), SvPVX_mutable(sv)) \ + : sv_pvn_force_flags(sv, &lp, flags|SV_MUTABLE_RETURN)) +#endif +#ifndef SvPV_nolen +# define SvPV_nolen(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC)) +#endif +#ifndef SvPV_nolen_const +# define SvPV_nolen_const(sv) \ + ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN)) +#endif + +# if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef SvPVx_nolen_const +# define SvPVx_nolen_const(sv) ({SV *sV_ = (sv); SvPV_nolen_const(sV_); }) +#endif + +# else +#ifndef SvPVx_nolen_const +# define SvPVx_nolen_const(sv) (PL_Sv = sv, SvPV_nolen_const(PL_Sv)) +#endif + +# endif +#ifndef SvPV_nomg +# define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const +# define SvPV_nomg_const(sv, lp) SvPV_flags_const(sv, lp, 0) +#endif + +#ifndef SvPV_nomg_const_nolen +# define SvPV_nomg_const_nolen(sv) SvPV_flags_const_nolen(sv, 0) +#endif + +#ifndef SvPV_nomg_nolen +# define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \ + ? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, 0)) +#endif +#ifndef SvPV_renew +# define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \ + SvPV_set((sv), (char *) saferealloc( \ + (Malloc_t)SvPVX(sv), (MEM_SIZE)((n)))); \ + } STMT_END +#endif +#ifndef SvPVCLEAR +# define SvPVCLEAR(sv) sv_setpvs((sv), "") +#endif +#ifndef WARN_ALL +# define WARN_ALL 0 +#endif + +#ifndef WARN_CLOSURE +# define WARN_CLOSURE 1 +#endif + +#ifndef WARN_DEPRECATED +# define WARN_DEPRECATED 2 +#endif + +#ifndef WARN_EXITING +# define WARN_EXITING 3 +#endif + +#ifndef WARN_GLOB +# define WARN_GLOB 4 +#endif + +#ifndef WARN_IO +# define WARN_IO 5 +#endif + +#ifndef WARN_CLOSED +# define WARN_CLOSED 6 +#endif + +#ifndef WARN_EXEC +# define WARN_EXEC 7 +#endif + +#ifndef WARN_LAYER +# define WARN_LAYER 8 +#endif + +#ifndef WARN_NEWLINE +# define WARN_NEWLINE 9 +#endif + +#ifndef WARN_PIPE +# define WARN_PIPE 10 +#endif + +#ifndef WARN_UNOPENED +# define WARN_UNOPENED 11 +#endif + +#ifndef WARN_MISC +# define WARN_MISC 12 +#endif + +#ifndef WARN_NUMERIC +# define WARN_NUMERIC 13 +#endif + +#ifndef WARN_ONCE +# define WARN_ONCE 14 +#endif + +#ifndef WARN_OVERFLOW +# define WARN_OVERFLOW 15 +#endif + +#ifndef WARN_PACK +# define WARN_PACK 16 +#endif + +#ifndef WARN_PORTABLE +# define WARN_PORTABLE 17 +#endif + +#ifndef WARN_RECURSION +# define WARN_RECURSION 18 +#endif + +#ifndef WARN_REDEFINE +# define WARN_REDEFINE 19 +#endif + +#ifndef WARN_REGEXP +# define WARN_REGEXP 20 +#endif + +#ifndef WARN_SEVERE +# define WARN_SEVERE 21 +#endif + +#ifndef WARN_DEBUGGING +# define WARN_DEBUGGING 22 +#endif + +#ifndef WARN_INPLACE +# define WARN_INPLACE 23 +#endif + +#ifndef WARN_INTERNAL +# define WARN_INTERNAL 24 +#endif + +#ifndef WARN_MALLOC +# define WARN_MALLOC 25 +#endif + +#ifndef WARN_SIGNAL +# define WARN_SIGNAL 26 +#endif + +#ifndef WARN_SUBSTR +# define WARN_SUBSTR 27 +#endif + +#ifndef WARN_SYNTAX +# define WARN_SYNTAX 28 +#endif + +#ifndef WARN_AMBIGUOUS +# define WARN_AMBIGUOUS 29 +#endif + +#ifndef WARN_BAREWORD +# define WARN_BAREWORD 30 +#endif + +#ifndef WARN_DIGIT +# define WARN_DIGIT 31 +#endif + +#ifndef WARN_PARENTHESIS +# define WARN_PARENTHESIS 32 +#endif + +#ifndef WARN_PRECEDENCE +# define WARN_PRECEDENCE 33 +#endif + +#ifndef WARN_PRINTF +# define WARN_PRINTF 34 +#endif + +#ifndef WARN_PROTOTYPE +# define WARN_PROTOTYPE 35 +#endif + +#ifndef WARN_QW +# define WARN_QW 36 +#endif + +#ifndef WARN_RESERVED +# define WARN_RESERVED 37 +#endif + +#ifndef WARN_SEMICOLON +# define WARN_SEMICOLON 38 +#endif + +#ifndef WARN_TAINT +# define WARN_TAINT 39 +#endif + +#ifndef WARN_THREADS +# define WARN_THREADS 40 +#endif + +#ifndef WARN_UNINITIALIZED +# define WARN_UNINITIALIZED 41 +#endif + +#ifndef WARN_UNPACK +# define WARN_UNPACK 42 +#endif + +#ifndef WARN_UNTIE +# define WARN_UNTIE 43 +#endif + +#ifndef WARN_UTF8 +# define WARN_UTF8 44 +#endif + +#ifndef WARN_VOID +# define WARN_VOID 45 +#endif + +#ifndef WARN_ASSERTIONS +# define WARN_ASSERTIONS 46 +#endif +#ifndef packWARN +# define packWARN(a) (a) +#endif + +#ifndef packWARN2 +# define packWARN2(a,b) (packWARN(a) << 8 | (b)) +#endif + +#ifndef packWARN3 +# define packWARN3(a,b,c) (packWARN2(a,b) << 8 | (c)) +#endif + +#ifndef packWARN4 +# define packWARN4(a,b,c,d) (packWARN3(a,b,c) << 8 | (d)) +#endif + +#ifndef ckWARN +# ifdef G_WARN_ON +# define ckWARN(a) (PL_dowarn & G_WARN_ON) +# else +# define ckWARN(a) PL_dowarn +# endif +#endif +#ifndef ckWARN2 +# define ckWARN2(a,b) (ckWARN(a) || ckWARN(b)) +#endif + +#ifndef ckWARN3 +# define ckWARN3(a,b,c) (ckWARN(c) || ckWARN2(a,b)) +#endif + +#ifndef ckWARN4 +# define ckWARN4(a,b,c,d) (ckWARN(d) || ckWARN3(a,b,c)) +#endif + +#ifndef ckWARN_d +# ifdef isLEXWARN_off +# define ckWARN_d(a) (isLEXWARN_off || ckWARN(a)) +# else +# define ckWARN_d(a) 1 +# endif +#endif +#ifndef ckWARN2_d +# define ckWARN2_d(a,b) (ckWARN_d(a) || ckWARN_d(b)) +#endif + +#ifndef ckWARN3_d +# define ckWARN3_d(a,b,c) (ckWARN_d(c) || ckWARN2_d(a,b)) +#endif + +#ifndef ckWARN4_d +# define ckWARN4_d(a,b,c,d) (ckWARN_d(d) || ckWARN3_d(a,b,c)) +#endif +#ifndef vwarner +# define vwarner(err, pat, argsp) \ + STMT_START { SV *sv; \ + PERL_UNUSED_ARG(err); \ + sv = vnewSVpvf(pat, argsp); \ + sv_2mortal(sv); \ + warn("%s", SvPV_nolen(sv)); \ + } STMT_END +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(warner) +# if defined(NEED_warner) +static void DPPP_(my_warner)(U32 err, const char * pat, ...); +static +#else +extern void DPPP_(my_warner)(U32 err, const char * pat, ...); +#endif + +#if defined(NEED_warner) || defined(NEED_warner_GLOBAL) + +#define Perl_warner DPPP_(my_warner) + + +void +DPPP_(my_warner)(U32 err, const char *pat, ...) +{ + va_list args; + va_start(args, pat); + vwarner(err, pat, &args); + va_end(args); +} + +# define warner Perl_warner + +# define Perl_warner_nocontext Perl_warner + +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(ck_warner) +# if defined(NEED_ck_warner) +static void DPPP_(my_ck_warner)(pTHX_ U32 err, const char * pat, ...); +static +#else +extern void DPPP_(my_ck_warner)(pTHX_ U32 err, const char * pat, ...); +#endif + +#if defined(NEED_ck_warner) || defined(NEED_ck_warner_GLOBAL) + +#define Perl_ck_warner DPPP_(my_ck_warner) + + +void +DPPP_(my_ck_warner)(pTHX_ U32 err, const char *pat, ...) +{ + va_list args; + + if ( ! ckWARN((err ) & 0xFF) + && ! ckWARN((err >> 8) & 0xFF) + && ! ckWARN((err >> 16) & 0xFF) + && ! ckWARN((err >> 24) & 0xFF)) + { + return; + } + + va_start(args, pat); + vwarner(err, pat, &args); + va_end(args); +} + +# define ck_warner Perl_ck_warner +# endif +#endif + +#if (PERL_BCDVERSION >= 0x5004000) && !defined(ck_warner_d) +# if defined(NEED_ck_warner_d) +static void DPPP_(my_ck_warner_d)(pTHX_ U32 err, const char * pat, ...); +static +#else +extern void DPPP_(my_ck_warner_d)(pTHX_ U32 err, const char * pat, ...); +#endif + +#if defined(NEED_ck_warner_d) || defined(NEED_ck_warner_d_GLOBAL) + +#define Perl_ck_warner_d DPPP_(my_ck_warner_d) + + +void +DPPP_(my_ck_warner_d)(pTHX_ U32 err, const char *pat, ...) +{ + va_list args; + + if ( ! ckWARN_d((err ) & 0xFF) + && ! ckWARN_d((err >> 8) & 0xFF) + && ! ckWARN_d((err >> 16) & 0xFF) + && ! ckWARN_d((err >> 24) & 0xFF)) + { + return; + } + + va_start(args, pat); + vwarner(err, pat, &args); + va_end(args); +} + +# define ck_warner_d Perl_ck_warner_d + + +# endif +#endif + +#ifndef IVdf +# if IVSIZE == LONGSIZE +# define IVdf "ld" +# define UVuf "lu" +# define UVof "lo" +# define UVxf "lx" +# define UVXf "lX" +# elif IVSIZE == INTSIZE +# define IVdf "d" +# define UVuf "u" +# define UVof "o" +# define UVxf "x" +# define UVXf "X" +# else +# error "cannot define IV/UV formats" +# endif +#endif + +#ifndef NVef +# if defined(USE_LONG_DOUBLE) && defined(HAS_LONG_DOUBLE) && \ + defined(PERL_PRIfldbl) && (PERL_BCDVERSION != 0x5006000) + /* Not very likely, but let's try anyway. */ +# define NVef PERL_PRIeldbl +# define NVff PERL_PRIfldbl +# define NVgf PERL_PRIgldbl +# else +# define NVef "e" +# define NVff "f" +# define NVgf "g" +# endif +#endif +#ifndef sv_setuv +# define sv_setuv(sv, uv) \ + STMT_START { \ + UV TeMpUv = uv; \ + if (TeMpUv <= IV_MAX) \ + sv_setiv(sv, TeMpUv); \ + else \ + sv_setnv(sv, (double)TeMpUv); \ + } STMT_END +#endif +#ifndef newSVuv +# define newSVuv(uv) ((uv) <= IV_MAX ? newSViv((IV)uv) : newSVnv((NV)uv)) +#endif + +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef sv_2uv +# define sv_2uv(sv) ({ SV *_sv = (sv); (UV) (SvNOK(_sv) ? SvNV(_sv) : sv_2nv(_sv)); }) +#endif + +#else +#ifndef sv_2uv +# define sv_2uv(sv) ((PL_Sv = (sv)), (UV) (SvNOK(PL_Sv) ? SvNV(PL_Sv) : sv_2nv(PL_Sv))) +#endif + +#endif +#ifndef SvUVX +# define SvUVX(sv) ((UV)SvIVX(sv)) +#endif + +#ifndef SvUVXx +# define SvUVXx(sv) SvUVX(sv) +#endif + +#ifndef SvUV +# define SvUV(sv) (SvIOK(sv) ? SvUVX(sv) : sv_2uv(sv)) +#endif + +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef SvUVx +# define SvUVx(sv) ({ SV *_sv = (sv)); SvUV(_sv); }) +#endif + +#else +#ifndef SvUVx +# define SvUVx(sv) ((PL_Sv = (sv)), SvUV(PL_Sv)) +#endif + +#endif + +/* Hint: sv_uv + * Always use the SvUVx() macro instead of sv_uv(). + */ +/* Replace sv_uv with SvUVx */ +#ifndef sv_uv +# define sv_uv(sv) SvUVx(sv) +#endif + +#if !defined(SvUOK) && defined(SvIOK_UV) +# define SvUOK(sv) SvIOK_UV(sv) +#endif +#ifndef XST_mUV +# define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) ) +#endif + +#ifndef XSRETURN_UV +# define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END +#endif +#ifndef PUSHu +# define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END +#endif + +#ifndef XPUSHu +# define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END +#endif + +#if !defined(my_strnlen) +#if defined(NEED_my_strnlen) +static Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen); +static +#else +extern Size_t DPPP_(my_my_strnlen)(const char * str, Size_t maxlen); +#endif + +#if defined(NEED_my_strnlen) || defined(NEED_my_strnlen_GLOBAL) + +#define my_strnlen DPPP_(my_my_strnlen) +#define Perl_my_strnlen DPPP_(my_my_strnlen) + + +Size_t +DPPP_(my_my_strnlen)(const char *str, Size_t maxlen) +{ + const char *p = str; + + while(maxlen-- && *p) + p++; + + return p - str; +} + +#endif +#endif + +#ifdef HAS_MEMCMP +#ifndef memNE +# define memNE(s1,s2,l) (memcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!memcmp(s1,s2,l)) +#endif + +#else +#ifndef memNE +# define memNE(s1,s2,l) (bcmp(s1,s2,l)) +#endif + +#ifndef memEQ +# define memEQ(s1,s2,l) (!bcmp(s1,s2,l)) +#endif + +#endif +#ifndef memEQs +# define memEQs(s1, l, s2) \ + (sizeof(s2)-1 == l && memEQ(s1, (s2 ""), (sizeof(s2)-1))) +#endif + +#ifndef memNEs +# define memNEs(s1, l, s2) !memEQs(s1, l, s2) +#endif +#ifndef memCHRs +# define memCHRs(s, c) ((const char *) memchr("" s "" , c, sizeof(s)-1)) +#endif +#ifndef MoveD +# define MoveD(s,d,n,t) memmove((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifndef CopyD +# define CopyD(s,d,n,t) memcpy((char*)(d),(char*)(s), (n) * sizeof(t)) +#endif + +#ifdef HAS_MEMSET +#ifndef ZeroD +# define ZeroD(d,n,t) memzero((char*)(d), (n) * sizeof(t)) +#endif + +#else +#ifndef ZeroD +# define ZeroD(d,n,t) ((void)memzero((char*)(d), (n) * sizeof(t)), d) +#endif + +#endif +#ifndef PoisonWith +# define PoisonWith(d,n,t,b) (void)memset((char*)(d), (U8)(b), (n) * sizeof(t)) +#endif + +#ifndef PoisonNew +# define PoisonNew(d,n,t) PoisonWith(d,n,t,0xAB) +#endif + +#ifndef PoisonFree +# define PoisonFree(d,n,t) PoisonWith(d,n,t,0xEF) +#endif + +#ifndef Poison +# define Poison(d,n,t) PoisonFree(d,n,t) +#endif +#ifndef Newx +# define Newx(v,n,t) New(0,v,n,t) +#endif + +#ifndef Newxc +# define Newxc(v,n,t,c) Newc(0,v,n,t,c) +#endif + +#ifndef Newxz +# define Newxz(v,n,t) Newz(0,v,n,t) +#endif + +#ifdef NEED_mess_sv +#define NEED_mess +#endif + +#ifdef NEED_mess +#define NEED_mess_nocontext +#define NEED_vmess +#endif + +#ifndef croak_sv +#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) ) +# if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) ) +# define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) \ + STMT_START { \ + SV *_errsv = ERRSV; \ + SvFLAGS(_errsv) = (SvFLAGS(_errsv) & ~SVf_UTF8) | \ + (SvFLAGS(sv) & SVf_UTF8); \ + } STMT_END +# else +# define D_PPP_FIX_UTF8_ERRSV_FOR_SV(sv) STMT_START {} STMT_END +# endif +# define croak_sv(sv) \ + STMT_START { \ + SV *_sv = (sv); \ + if (SvROK(_sv)) { \ + sv_setsv(ERRSV, _sv); \ + croak(NULL); \ + } else { \ + D_PPP_FIX_UTF8_ERRSV_FOR_SV(_sv); \ + croak("%" SVf, SVfARG(_sv)); \ + } \ + } STMT_END +#elif (PERL_BCDVERSION >= 0x5004000) +# define croak_sv(sv) croak("%" SVf, SVfARG(sv)) +#else +# define croak_sv(sv) croak("%s", SvPV_nolen(sv)) +#endif +#endif + +#ifndef die_sv +#if defined(NEED_die_sv) +static OP * DPPP_(my_die_sv)(pTHX_ SV * baseex); +static +#else +extern OP * DPPP_(my_die_sv)(pTHX_ SV * baseex); +#endif + +#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL) + +#ifdef die_sv +# undef die_sv +#endif +#define die_sv(a) DPPP_(my_die_sv)(aTHX_ a) +#define Perl_die_sv DPPP_(my_die_sv) + +OP * +DPPP_(my_die_sv)(pTHX_ SV *baseex) +{ + croak_sv(baseex); + return (OP *)NULL; +} +#endif +#endif + +#ifndef warn_sv +#if (PERL_BCDVERSION >= 0x5004000) +# define warn_sv(sv) warn("%" SVf, SVfARG(sv)) +#else +# define warn_sv(sv) warn("%s", SvPV_nolen(sv)) +#endif +#endif + +#if ! defined vmess && (PERL_BCDVERSION >= 0x5004000) +# if defined(NEED_vmess) +static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args); +static +#else +extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args); +#endif + +#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL) + +#ifdef vmess +# undef vmess +#endif +#define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b) +#define Perl_vmess DPPP_(my_vmess) + + +SV* +DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args) +{ + mess(pat, args); + return PL_mess_sv; +} +# endif +#endif + +#if (PERL_BCDVERSION < 0x5006000) && (PERL_BCDVERSION >= 0x5004000) +#undef mess +#endif + +#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext) && (PERL_BCDVERSION >= 0x5004000) +#if defined(NEED_mess_nocontext) +static SV * DPPP_(my_mess_nocontext)(const char * pat, ...); +static +#else +extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...); +#endif + +#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL) + +#define mess_nocontext DPPP_(my_mess_nocontext) +#define Perl_mess_nocontext DPPP_(my_mess_nocontext) + +SV* +DPPP_(my_mess_nocontext)(const char* pat, ...) +{ + dTHX; + SV *sv; + va_list args; + va_start(args, pat); + sv = vmess(pat, &args); + va_end(args); + return sv; +} +#endif +#endif + +#ifndef mess +#if defined(NEED_mess) +static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...); +static +#else +extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...); +#endif + +#if defined(NEED_mess) || defined(NEED_mess_GLOBAL) + +#define Perl_mess DPPP_(my_mess) + +SV* +DPPP_(my_mess)(pTHX_ const char* pat, ...) +{ + SV *sv; + va_list args; + va_start(args, pat); + sv = vmess(pat, &args); + va_end(args); + return sv; +} +#ifdef mess_nocontext +#define mess mess_nocontext +#else +#define mess Perl_mess_nocontext +#endif +#endif +#endif + +#if ! defined mess_sv && (PERL_BCDVERSION >= 0x5004000) +#if defined(NEED_mess_sv) +static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume); +static +#else +extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume); +#endif + +#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL) + +#ifdef mess_sv +# undef mess_sv +#endif +#define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b) +#define Perl_mess_sv DPPP_(my_mess_sv) + +SV * +DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume) +{ + SV *tmp; + SV *ret; + + if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') { + if (consume) + return basemsg; + ret = mess(""); + SvSetSV_nosteal(ret, basemsg); + return ret; + } + + if (consume) { + sv_catsv(basemsg, mess("")); + return basemsg; + } + + ret = mess(""); + tmp = newSVsv(ret); + SvSetSV_nosteal(ret, basemsg); + sv_catsv(ret, tmp); + sv_dec(tmp); + return ret; +} +#endif +#endif + +#ifndef warn_nocontext +#define warn_nocontext warn +#endif + +#ifndef croak_nocontext +#define croak_nocontext croak +#endif + +#ifndef croak_no_modify +#define croak_no_modify() croak_nocontext("%s", PL_no_modify) +#define Perl_croak_no_modify() croak_no_modify() +#endif + +#ifndef croak_memory_wrap +#if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) ) +# define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap) +#else +# define croak_memory_wrap() croak_nocontext("panic: memory wrap") +#endif +#endif + +#ifndef croak_xs_usage +#if defined(NEED_croak_xs_usage) +static void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params); +static +#else +extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params); +#endif + +#if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL) + +#define croak_xs_usage DPPP_(my_croak_xs_usage) +#define Perl_croak_xs_usage DPPP_(my_croak_xs_usage) + +#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE +#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) + +void +DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params) +{ + dTHX; + const GV *const gv = CvGV(cv); + + PERL_ARGS_ASSERT_CROAK_XS_USAGE; + + if (gv) { + const char *const gvname = GvNAME(gv); + const HV *const stash = GvSTASH(gv); + const char *const hvname = stash ? HvNAME(stash) : NULL; + + if (hvname) + croak("Usage: %s::%s(%s)", hvname, gvname, params); + else + croak("Usage: %s(%s)", gvname, params); + } else { + /* Pants. I don't think that it should be possible to get here. */ + croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params); + } +} +#endif +#endif +#endif +#ifndef mPUSHs +# define mPUSHs(s) PUSHs(sv_2mortal(s)) +#endif + +#ifndef PUSHmortal +# define PUSHmortal PUSHs(sv_newmortal()) +#endif + +#ifndef mPUSHp +# define mPUSHp(p,l) sv_setpvn(PUSHmortal, (p), (l)) +#endif + +#ifndef mPUSHn +# define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n)) +#endif + +#ifndef mPUSHi +# define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i)) +#endif + +#ifndef mPUSHu +# define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u)) +#endif +#ifndef mXPUSHs +# define mXPUSHs(s) XPUSHs(sv_2mortal(s)) +#endif + +#ifndef XPUSHmortal +# define XPUSHmortal XPUSHs(sv_newmortal()) +#endif + +#ifndef mXPUSHp +# define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn(PUSHmortal, (p), (l)); } STMT_END +#endif + +#ifndef mXPUSHn +# define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv(PUSHmortal, (NV)(n)); } STMT_END +#endif + +#ifndef mXPUSHi +# define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv(PUSHmortal, (IV)(i)); } STMT_END +#endif + +#ifndef mXPUSHu +# define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv(PUSHmortal, (UV)(u)); } STMT_END +#endif + +/* Replace: 1 */ +#ifndef call_sv +# define call_sv perl_call_sv +#endif + +#ifndef call_pv +# define call_pv perl_call_pv +#endif + +#ifndef call_argv +# define call_argv perl_call_argv +#endif + +#ifndef call_method +# define call_method perl_call_method +#endif + +#ifndef eval_sv +# define eval_sv perl_eval_sv +#endif + +#if (PERL_BCDVERSION >= 0x5003098) && (PERL_BCDVERSION < 0x5006000) +#ifndef eval_pv +# define eval_pv perl_eval_pv +#endif + +#endif +/* Replace: 0 */ + +#if (PERL_BCDVERSION < 0x5006000) +#ifndef Perl_eval_sv +# define Perl_eval_sv perl_eval_sv +#endif + +#if (PERL_BCDVERSION >= 0x5003098) +#ifndef Perl_eval_pv +# define Perl_eval_pv perl_eval_pv +#endif + +#endif +#endif +#ifndef G_LIST +# define G_LIST G_ARRAY /* Replace */ +#endif +#ifndef PERL_LOADMOD_DENY +# define PERL_LOADMOD_DENY 0x1 +#endif + +#ifndef PERL_LOADMOD_NOIMPORT +# define PERL_LOADMOD_NOIMPORT 0x2 +#endif + +#ifndef PERL_LOADMOD_IMPORT_OPS +# define PERL_LOADMOD_IMPORT_OPS 0x4 +#endif + +#if defined(PERL_USE_GCC_BRACE_GROUPS) +# define D_PPP_CROAK_IF_ERROR(cond) ({ \ + SV *_errsv; \ + ( (cond) \ + && (_errsv = ERRSV) \ + && (SvROK(_errsv) || SvTRUE(_errsv)) \ + && (croak_sv(_errsv), 1)); \ + }) +#else + PERL_STATIC_INLINE void D_PPP_CROAK_IF_ERROR(int cond) { + dTHX; + SV *errsv; + if (!cond) return; + errsv = ERRSV; + if (SvROK(errsv) || SvTRUE(errsv)) croak_sv(errsv); + } +# define D_PPP_CROAK_IF_ERROR(cond) D_PPP_CROAK_IF_ERROR(cond) +#endif + +#ifndef G_METHOD +# define G_METHOD 64 +# ifdef call_sv +# undef call_sv +# endif +# if (PERL_BCDVERSION < 0x5006000) +# define call_sv(sv, flags) ((flags) & G_METHOD ? perl_call_method((char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : perl_call_sv(sv, flags)) +# else +# define call_sv(sv, flags) ((flags) & G_METHOD ? Perl_call_method(aTHX_ (char *) SvPV_nolen_const(sv), \ + (flags) & ~G_METHOD) : Perl_call_sv(aTHX_ sv, flags)) +# endif +#endif + +#ifndef G_RETHROW +# define G_RETHROW 8192 +# ifdef eval_sv +# undef eval_sv +# endif +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define eval_sv(sv, flags) ({ I32 _flags = (flags); I32 _ret = Perl_eval_sv(aTHX_ sv, (_flags & ~G_RETHROW)); D_PPP_CROAK_IF_ERROR(_flags & G_RETHROW); _ret; }) +# else +# define eval_sv(sv, flags) ((PL_na = Perl_eval_sv(aTHX_ sv, ((flags) & ~G_RETHROW))), D_PPP_CROAK_IF_ERROR((flags) & G_RETHROW), (I32)PL_na) +# endif +#endif + +/* Older Perl versions have broken croak_on_error=1 */ +#if (PERL_BCDVERSION < 0x5031002) +# ifdef eval_pv +# undef eval_pv +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define eval_pv(p, croak_on_error) ({ SV *_sv = Perl_eval_pv(aTHX_ p, 0); D_PPP_CROAK_IF_ERROR(croak_on_error); _sv; }) +# else +# define eval_pv(p, croak_on_error) ((PL_Sv = Perl_eval_pv(aTHX_ p, 0)), D_PPP_CROAK_IF_ERROR(croak_on_error), PL_Sv) +# endif +# endif +#endif + +/* This is backport for Perl 5.3.97d and older which do not provide perl_eval_pv */ +#ifndef eval_pv +#if defined(NEED_eval_pv) +static SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error); +static +#else +extern SV * DPPP_(my_eval_pv)(const char * p, I32 croak_on_error); +#endif + +#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL) + +#ifdef eval_pv +# undef eval_pv +#endif +#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b) +#define Perl_eval_pv DPPP_(my_eval_pv) + + +SV* +DPPP_(my_eval_pv)(const char *p, I32 croak_on_error) +{ + dSP; + SV* sv = newSVpv(p, 0); + + PUSHMARK(sp); + eval_sv(sv, G_SCALAR); + SvREFCNT_dec(sv); + + SPAGAIN; + sv = POPs; + PUTBACK; + + D_PPP_CROAK_IF_ERROR(croak_on_error); + + return sv; +} + +#endif +#endif + +#if ! defined(vload_module) && defined(start_subparse) +#if defined(NEED_vload_module) +static void DPPP_(my_vload_module)(U32 flags, SV * name, SV * ver, va_list * args); +static +#else +extern void DPPP_(my_vload_module)(U32 flags, SV * name, SV * ver, va_list * args); +#endif + +#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL) + +#ifdef vload_module +# undef vload_module +#endif +#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d) +#define Perl_vload_module DPPP_(my_vload_module) + + +void +DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args) +{ + dTHR; + dVAR; + OP *veop, *imop; + + OP * const modname = newSVOP(OP_CONST, 0, name); + /* 5.005 has a somewhat hacky force_normal that doesn't croak on + SvREADONLY() if PL_compiling is true. Current perls take care in + ck_require() to correctly turn off SvREADONLY before calling + force_normal_flags(). This seems a better fix than fudging PL_compiling + */ + SvREADONLY_off(((SVOP*)modname)->op_sv); + modname->op_private |= OPpCONST_BARE; + if (ver) { + veop = newSVOP(OP_CONST, 0, ver); + } + else + veop = NULL; + if (flags & PERL_LOADMOD_NOIMPORT) { + imop = sawparens(newNULLLIST()); + } + else if (flags & PERL_LOADMOD_IMPORT_OPS) { + imop = va_arg(*args, OP*); + } + else { + SV *sv; + imop = NULL; + sv = va_arg(*args, SV*); + while (sv) { + imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv)); + sv = va_arg(*args, SV*); + } + } + { + const line_t ocopline = PL_copline; + COP * const ocurcop = PL_curcop; + const int oexpect = PL_expect; + + utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0), +#if (PERL_BCDVERSION > 0x5003000) + veop, +#endif + modname, imop); + PL_expect = oexpect; + PL_copline = ocopline; + PL_curcop = ocurcop; + } +} + +#endif +#endif + +#ifndef load_module +#if defined(NEED_load_module) +static void DPPP_(my_load_module)(U32 flags, SV * name, SV * ver, ...); +static +#else +extern void DPPP_(my_load_module)(U32 flags, SV * name, SV * ver, ...); +#endif + +#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL) + +#ifdef load_module +# undef load_module +#endif +#define load_module DPPP_(my_load_module) +#define Perl_load_module DPPP_(my_load_module) + + +void +DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...) +{ + va_list args; + va_start(args, ver); + vload_module(flags, name, ver, &args); + va_end(args); +} + +#endif +#endif +#ifndef newRV_inc +# define newRV_inc(sv) newRV(sv) /* Replace */ +#endif + +#ifndef newRV_noinc +#if defined(PERL_USE_GCC_BRACE_GROUPS) +# define newRV_noinc(sv) ({ SV *_sv = (SV *)newRV((sv)); SvREFCNT_dec((sv)); _sv; }) +#else +# define newRV_noinc(sv) ((PL_Sv = (SV *)newRV((sv))), SvREFCNT_dec((sv)), PL_Sv) +#endif +#endif + +/* + * Boilerplate macros for initializing and accessing interpreter-local + * data from C. All statics in extensions should be reworked to use + * this, if you want to make the extension thread-safe. See ext/re/re.xs + * for an example of the use of these macros. + * + * Code that uses these macros is responsible for the following: + * 1. #define MY_CXT_KEY to a unique string, e.g. "DynaLoader_guts" + * 2. Declare a typedef named my_cxt_t that is a structure that contains + * all the data that needs to be interpreter-local. + * 3. Use the START_MY_CXT macro after the declaration of my_cxt_t. + * 4. Use the MY_CXT_INIT macro such that it is called exactly once + * (typically put in the BOOT: section). + * 5. Use the members of the my_cxt_t structure everywhere as + * MY_CXT.member. + * 6. Use the dMY_CXT macro (a declaration) in all the functions that + * access MY_CXT. + */ + +#if defined(MULTIPLICITY) || defined(PERL_OBJECT) || \ + defined(PERL_CAPI) || defined(PERL_IMPLICIT_CONTEXT) + +#ifndef START_MY_CXT + +/* This must appear in all extensions that define a my_cxt_t structure, + * right after the definition (i.e. at file scope). The non-threads + * case below uses it to declare the data as static. */ +#define START_MY_CXT + +#if (PERL_BCDVERSION < 0x5004068) +/* Fetches the SV that keeps the per-interpreter data. */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = get_sv(MY_CXT_KEY, FALSE) +#else /* >= perl5.004_68 */ +#define dMY_CXT_SV \ + SV *my_cxt_sv = *hv_fetch(PL_modglobal, MY_CXT_KEY, \ + sizeof(MY_CXT_KEY)-1, TRUE) +#endif /* < perl5.004_68 */ + +/* This declaration should be used within all functions that use the + * interpreter-local data. */ +#define dMY_CXT \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = INT2PTR(my_cxt_t*,SvUV(my_cxt_sv)) + +/* Creates and zeroes the per-interpreter data. + * (We allocate my_cxtp in a Perl SV so that it will be released when + * the interpreter goes away.) */ +#define MY_CXT_INIT \ + dMY_CXT_SV; \ + /* newSV() allocates one more than needed */ \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Zero(my_cxtp, 1, my_cxt_t); \ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) + +/* This macro must be used to access members of the my_cxt_t structure. + * e.g. MYCXT.some_data */ +#define MY_CXT (*my_cxtp) + +/* Judicious use of these macros can reduce the number of times dMY_CXT + * is used. Use is similar to pTHX, aTHX etc. */ +#define pMY_CXT my_cxt_t *my_cxtp +#define pMY_CXT_ pMY_CXT, +#define _pMY_CXT ,pMY_CXT +#define aMY_CXT my_cxtp +#define aMY_CXT_ aMY_CXT, +#define _aMY_CXT ,aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +/* Clones the per-interpreter data. */ +#define MY_CXT_CLONE \ + dMY_CXT_SV; \ + my_cxt_t *my_cxtp = (my_cxt_t*)SvPVX(newSV(sizeof(my_cxt_t)-1));\ + Copy(INT2PTR(my_cxt_t*, SvUV(my_cxt_sv)), my_cxtp, 1, my_cxt_t);\ + sv_setuv(my_cxt_sv, PTR2UV(my_cxtp)) +#endif + +#else /* single interpreter */ + +#ifndef START_MY_CXT + +#define START_MY_CXT static my_cxt_t my_cxt; +#define dMY_CXT_SV dNOOP +#define dMY_CXT dNOOP +#define MY_CXT_INIT NOOP +#define MY_CXT my_cxt + +#define pMY_CXT void +#define pMY_CXT_ +#define _pMY_CXT +#define aMY_CXT +#define aMY_CXT_ +#define _aMY_CXT + +#endif /* START_MY_CXT */ + +#ifndef MY_CXT_CLONE +#define MY_CXT_CLONE NOOP +#endif + +#endif + +#ifndef SvREFCNT_inc +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (SvREFCNT(_sv))++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc(sv) \ + ((PL_Sv=(SV*)(sv)) ? (++(SvREFCNT(PL_Sv)),PL_Sv) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_simple +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_simple(sv) \ + ({ \ + if (sv) \ + (SvREFCNT(sv))++; \ + (SV *)(sv); \ + }) +# else +# define SvREFCNT_inc_simple(sv) \ + ((sv) ? (SvREFCNT(sv)++,(SV*)(sv)) : NULL) +# endif +#endif + +#ifndef SvREFCNT_inc_NN +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_NN(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + SvREFCNT(_sv)++; \ + _sv; \ + }) +# else +# define SvREFCNT_inc_NN(sv) \ + (PL_Sv=(SV*)(sv),++(SvREFCNT(PL_Sv)),PL_Sv) +# endif +#endif + +#ifndef SvREFCNT_inc_void +# ifdef PERL_USE_GCC_BRACE_GROUPS +# define SvREFCNT_inc_void(sv) \ + ({ \ + SV * const _sv = (SV*)(sv); \ + if (_sv) \ + (void)(SvREFCNT(_sv)++); \ + }) +# else +# define SvREFCNT_inc_void(sv) \ + (void)((PL_Sv=(SV*)(sv)) ? ++(SvREFCNT(PL_Sv)) : 0) +# endif +#endif +#ifndef SvREFCNT_inc_simple_void +# define SvREFCNT_inc_simple_void(sv) STMT_START { if (sv) SvREFCNT(sv)++; } STMT_END +#endif + +#ifndef SvREFCNT_inc_simple_NN +# define SvREFCNT_inc_simple_NN(sv) (++SvREFCNT(sv), (SV*)(sv)) +#endif + +#ifndef SvREFCNT_inc_void_NN +# define SvREFCNT_inc_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef SvREFCNT_inc_simple_void_NN +# define SvREFCNT_inc_simple_void_NN(sv) (void)(++SvREFCNT((SV*)(sv))) +#endif + +#ifndef newSV_type +#if defined(PERL_USE_GCC_BRACE_GROUPS) +# define newSV_type(t) ({ SV *_sv = newSV(0); sv_upgrade(_sv, (t)); _sv; }) +#else +# define newSV_type(t) ((PL_Sv = newSV(0)), sv_upgrade(PL_Sv, (t)), PL_Sv) +#endif +#endif + +#if (PERL_BCDVERSION < 0x5006000) +# define D_PPP_CONSTPV_ARG(x) ((char *) (x)) +#else +# define D_PPP_CONSTPV_ARG(x) (x) +#endif +#ifndef newSVpvn +# define newSVpvn(data,len) ((data) \ + ? ((len) ? newSVpv((data), (len)) : newSVpv("", 0)) \ + : newSV(0)) +#endif +#ifndef newSVpvn_utf8 +# define newSVpvn_utf8(s, len, u) newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0) +#endif +#ifndef SVf_UTF8 +# define SVf_UTF8 0 +#endif + +#ifndef newSVpvn_flags +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define newSVpvn_flags(s, len, flags) \ + ({ \ + SV * sv = newSVpvn(D_PPP_CONSTPV_ARG(s), (len)); \ + SvFLAGS(sv) |= ((flags) & SVf_UTF8); \ + if ((flags) & SVs_TEMP) sv = sv_2mortal(sv); \ + sv; \ + }) +# else + PERL_STATIC_INLINE SV* D_PPP_newSVpvn_flags(const char *const s, const STRLEN len, const U32 flags) + { + dTHX; + SV * sv = newSVpvn(s, len); + SvFLAGS(sv) |= (flags & SVf_UTF8); + if (flags & SVs_TEMP) return sv_2mortal(sv); + return sv; + } +# define newSVpvn_flags(s, len, flags) D_PPP_newSVpvn_flags((s), (len), (flags)) +# endif +#endif +#ifndef SV_NOSTEAL +# define SV_NOSTEAL 16 +#endif + +#if ( (PERL_BCDVERSION >= 0x5007003) && (PERL_BCDVERSION < 0x5008007) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009002) ) +#undef sv_setsv_flags +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#define sv_setsv_flags(dstr, sstr, flags) \ + STMT_START { \ + if (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) { \ + SvTEMP_off((SV *)(sstr)); \ + Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \ + SvTEMP_on((SV *)(sstr)); \ + } else { \ + Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL); \ + } \ + } STMT_END +#else +#define sv_setsv_flags(dstr, sstr, flags) \ + ( \ + (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) ? ( \ + SvTEMP_off((SV *)(sstr)), \ + Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL), \ + SvTEMP_on((SV *)(sstr)), \ + 1 \ + ) : ( \ + Perl_sv_setsv_flags(aTHX_ (dstr), (sstr), (flags) & ~SV_NOSTEAL), \ + 1 \ + ) \ + ) +#endif +#endif + +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef sv_setsv_flags +# define sv_setsv_flags(dstr, sstr, flags) \ + STMT_START { \ + if (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) { \ + SvTEMP_off((SV *)(sstr)); \ + if (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) { \ + SvGMAGICAL_off((SV *)(sstr)); \ + sv_setsv((dstr), (sstr)); \ + SvGMAGICAL_on((SV *)(sstr)); \ + } else { \ + sv_setsv((dstr), (sstr)); \ + } \ + SvTEMP_on((SV *)(sstr)); \ + } else { \ + if (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) { \ + SvGMAGICAL_off((SV *)(sstr)); \ + sv_setsv((dstr), (sstr)); \ + SvGMAGICAL_on((SV *)(sstr)); \ + } else { \ + sv_setsv((dstr), (sstr)); \ + } \ + } \ + } STMT_END +#endif + +#else +#ifndef sv_setsv_flags +# define sv_setsv_flags(dstr, sstr, flags) \ + ( \ + (((flags) & SV_NOSTEAL) && (sstr) && (SvFLAGS((SV *)(sstr)) & SVs_TEMP)) ? ( \ + SvTEMP_off((SV *)(sstr)), \ + (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) ? ( \ + SvGMAGICAL_off((SV *)(sstr)), \ + sv_setsv((dstr), (sstr)), \ + SvGMAGICAL_on((SV *)(sstr)), \ + 1 \ + ) : ( \ + sv_setsv((dstr), (sstr)), \ + 1 \ + ), \ + SvTEMP_on((SV *)(sstr)), \ + 1 \ + ) : ( \ + (!((flags) & SV_GMAGIC) && (sstr) && SvGMAGICAL((SV *)(sstr))) ? ( \ + SvGMAGICAL_off((SV *)(sstr)), \ + sv_setsv((dstr), (sstr)), \ + SvGMAGICAL_on((SV *)(sstr)), \ + 1 \ + ) : ( \ + sv_setsv((dstr), (sstr)), \ + 1 \ + ) \ + ) \ + ) +#endif + +#endif + +#ifndef newSVsv_flags +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define newSVsv_flags(sv, flags) \ + ({ \ + SV *n= newSV(0); \ + sv_setsv_flags(n, (sv), (flags)); \ + n; \ + }) +# else + PERL_STATIC_INLINE SV* D_PPP_newSVsv_flags(SV *const old, I32 flags) + { + dTHX; + SV *n= newSV(0); + sv_setsv_flags(n, old, flags); + return n; + } +# define newSVsv_flags(sv, flags) D_PPP_newSVsv_flags(sv, flags) +# endif +#endif +#ifndef newSVsv_nomg +# define newSVsv_nomg(sv) newSVsv_flags((sv), SV_NOSTEAL) +#endif + +#if (PERL_BCDVERSION >= 0x5017005) +#ifndef sv_mortalcopy_flags +# define sv_mortalcopy_flags(sv, flags) Perl_sv_mortalcopy_flags(aTHX_ (sv), (flags)) +#endif + +#else +#ifndef sv_mortalcopy_flags +# define sv_mortalcopy_flags(sv, flags) sv_2mortal(newSVsv_flags((sv), (flags))) +#endif + +#endif +#ifndef SvMAGIC_set +# define SvMAGIC_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_magic = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5009003) +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv))) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) (0 + SvPVX(sv)) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + (((XRV*) SvANY(sv))->xrv_rv = (val)); } STMT_END +#endif + +#else +#ifndef SvPVX_const +# define SvPVX_const(sv) ((const char*)((sv)->sv_u.svu_pv)) +#endif + +#ifndef SvPVX_mutable +# define SvPVX_mutable(sv) ((sv)->sv_u.svu_pv) +#endif +#ifndef SvRV_set +# define SvRV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_RV); \ + ((sv)->sv_u.svu_rv = (val)); } STMT_END +#endif + +#endif +#ifndef SvSTASH_set +# define SvSTASH_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \ + (((XPVMG*) SvANY(sv))->xmg_stash = (val)); } STMT_END +#endif + +#if (PERL_BCDVERSION < 0x5004000) +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVIV*) SvANY(sv))->xiv_iv = (IV) (val)); } STMT_END +#endif + +#else +#ifndef SvUV_set +# define SvUV_set(sv, val) \ + STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \ + (((XPVUV*) SvANY(sv))->xuv_uv = (val)); } STMT_END +#endif + +#endif + +/* Hint: newSVpvn_share + * The SVs created by this function only mimic the behaviour of + * shared PVs without really being shared. Only use if you know + * what you're doing. + */ + +#ifndef newSVpvn_share + +#if defined(NEED_newSVpvn_share) +static SV * DPPP_(my_newSVpvn_share)(pTHX_ const char * s, I32 len, U32 hash); +static +#else +extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char * s, I32 len, U32 hash); +#endif + +#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL) + +#ifdef newSVpvn_share +# undef newSVpvn_share +#endif +#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c) +#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share) + + +SV * +DPPP_(my_newSVpvn_share)(pTHX_ const char *s, I32 len, U32 hash) +{ + SV *sv; + if (len < 0) + len = -len; + if (!hash) + PERL_HASH(hash, (char*) s, len); + sv = newSVpvn((char *) s, len); + sv_upgrade(sv, SVt_PVIV); + SvIVX(sv) = hash; + SvREADONLY_on(sv); + SvPOK_on(sv); + return sv; +} + +#endif + +#endif +#ifndef SvSHARED_HASH +# define SvSHARED_HASH(sv) (0 + SvUVX(sv)) +#endif +#ifndef HvNAME_get +# define HvNAME_get(hv) HvNAME(hv) +#endif +#ifndef HvNAMELEN_get +# define HvNAMELEN_get(hv) (HvNAME_get(hv) ? (I32)strlen(HvNAME_get(hv)) : 0) +#endif + +#if (PERL_BCDVERSION >= 0x5009002) && (PERL_BCDVERSION <= 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */ +#undef gv_fetchpvn_flags +#endif + +#ifdef GV_NOADD_MASK +# define D_PPP_GV_NOADD_MASK GV_NOADD_MASK +#else +# define D_PPP_GV_NOADD_MASK 0xE0 +#endif +#ifndef gv_fetchpvn_flags +# define gv_fetchpvn_flags(name, len, flags, sv_type) gv_fetchpv(SvPVX(sv_2mortal(newSVpvn((name), (len)))), ((flags) & D_PPP_GV_NOADD_MASK) ? FALSE : TRUE, (I32)(sv_type)) +#endif +#ifndef GvSVn +# define GvSVn(gv) GvSV(gv) +#endif + +#ifndef isGV_with_GP +# define isGV_with_GP(gv) isGV(gv) +#endif + +#ifndef gv_fetchsv +# define gv_fetchsv(name, flags, svt) gv_fetchpv(SvPV_nolen_const(name), flags, svt) +#endif +#ifndef get_cvn_flags +# define get_cvn_flags(name, namelen, flags) get_cv(name, flags) +#endif + +#ifndef gv_init_pvn +# define gv_init_pvn(gv, stash, ptr, len, flags) gv_init(gv, stash, ptr, len, flags & GV_ADDMULTI ? TRUE : FALSE) +#endif + +/* concatenating with "" ensures that only literal strings are accepted as argument + * note that STR_WITH_LEN() can't be used as argument to macros or functions that + * under some configurations might be macros + */ +#ifndef STR_WITH_LEN +# define STR_WITH_LEN(s) (s ""), (sizeof(s)-1) +#endif +#ifndef newSVpvs +# define newSVpvs(str) newSVpvn(str "", sizeof(str) - 1) +#endif + +#ifndef newSVpvs_flags +# define newSVpvs_flags(str, flags) newSVpvn_flags(str "", sizeof(str) - 1, flags) +#endif + +#ifndef newSVpvs_share +# define newSVpvs_share(str) newSVpvn_share(str "", sizeof(str) - 1, 0) +#endif + +#ifndef sv_catpvs +# define sv_catpvs(sv, str) sv_catpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef sv_setpvs +# define sv_setpvs(sv, str) sv_setpvn(sv, str "", sizeof(str) - 1) +#endif + +#ifndef hv_fetchs +# define hv_fetchs(hv, key, lval) hv_fetch(hv, key "", sizeof(key) - 1, lval) +#endif + +#ifndef hv_stores +# define hv_stores(hv, key, val) hv_store(hv, key "", sizeof(key) - 1, val, 0) +#endif +#ifndef gv_fetchpvs +# define gv_fetchpvs(name, flags, svt) gv_fetchpvn_flags(name "", sizeof(name) - 1, flags, svt) +#endif + +#ifndef gv_stashpvs +# define gv_stashpvs(name, flags) gv_stashpvn(name "", sizeof(name) - 1, flags) +#endif +#ifndef get_cvs +# define get_cvs(name, flags) get_cvn_flags(name "", sizeof(name)-1, flags) +#endif + +#undef SvGETMAGIC +#ifndef SvGETMAGIC +# define SvGETMAGIC(x) ((void)(UNLIKELY(SvGMAGICAL(x)) && mg_get(x))) +#endif + +/* That's the best we can do... */ +#ifndef sv_catpvn_nomg +# define sv_catpvn_nomg sv_catpvn +#endif + +#ifndef sv_catsv_nomg +# define sv_catsv_nomg sv_catsv +#endif + +#ifndef sv_setsv_nomg +# define sv_setsv_nomg sv_setsv +#endif + +#ifndef sv_pvn_nomg +# define sv_pvn_nomg sv_pvn +#endif + +#ifdef SVf_IVisUV +#if defined(PERL_USE_GCC_BRACE_GROUPS) +#ifndef SvIV_nomg +# define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ({ SV *_sviv = sv_mortalcopy_flags((sv), SV_NOSTEAL); IV _iv = SvIV(_sviv); SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(_sviv) & SVf_IVisUV); _iv; })) +#endif + +#ifndef SvUV_nomg +# define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvUV((sv)) : ({ SV *_svuv = sv_mortalcopy_flags((sv), SV_NOSTEAL); UV _uv = SvUV(_svuv); SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(_svuv) & SVf_IVisUV); _uv; })) +#endif + +#else +#ifndef SvIV_nomg +# define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ((PL_Sv = sv_mortalcopy_flags((sv), SV_NOSTEAL)), sv_upgrade(PL_Sv, SVt_PVIV), (SvIVX(PL_Sv) = SvIV(PL_Sv)), (SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(PL_Sv) & SVf_IVisUV)), SvIVX(PL_Sv))) +#endif + +#ifndef SvUV_nomg +# define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : ((PL_Sv = sv_mortalcopy_flags((sv), SV_NOSTEAL)), sv_upgrade(PL_Sv, SVt_PVIV), (SvUVX(PL_Sv) = SvUV(PL_Sv)), (SvFLAGS((sv)) = (SvFLAGS((sv)) & ~SVf_IVisUV) | (SvFLAGS(PL_Sv) & SVf_IVisUV)), SvUVX(PL_Sv))) +#endif + +#endif +#else +#ifndef SvIV_nomg +# define SvIV_nomg(sv) (!SvGMAGICAL((sv)) ? SvIV((sv)) : SvIVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) +#endif + +#ifndef SvUV_nomg +# define SvUV_nomg(sv) (!SvGMAGICAL((sv)) ? SvUV((sv)) : SvUVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) +#endif + +#endif +#ifndef SvNV_nomg +# define SvNV_nomg(sv) (!SvGMAGICAL((sv)) ? SvNV((sv)) : SvNVx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) +#endif + +#ifndef SvTRUE_nomg +# define SvTRUE_nomg(sv) (!SvGMAGICAL((sv)) ? SvTRUE((sv)) : SvTRUEx(sv_mortalcopy_flags((sv), SV_NOSTEAL))) +#endif + +#ifndef sv_catpv_mg +# define sv_catpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catpvn_mg +# define sv_catpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_catpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_catsv_mg +# define sv_catsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_catsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setiv_mg +# define sv_setiv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setiv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setnv_mg +# define sv_setnv_mg(sv, num) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setnv(TeMpSv,num); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpv_mg +# define sv_setpv_mg(sv, ptr) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpv(TeMpSv,ptr); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setpvn_mg +# define sv_setpvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setpvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setsv_mg +# define sv_setsv_mg(dsv, ssv) \ + STMT_START { \ + SV *TeMpSv = dsv; \ + sv_setsv(TeMpSv,ssv); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_setuv_mg +# define sv_setuv_mg(sv, i) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_setuv(TeMpSv,i); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif + +#ifndef sv_usepvn_mg +# define sv_usepvn_mg(sv, ptr, len) \ + STMT_START { \ + SV *TeMpSv = sv; \ + sv_usepvn(TeMpSv,ptr,len); \ + SvSETMAGIC(TeMpSv); \ + } STMT_END +#endif +#ifndef SvVSTRING_mg +# define SvVSTRING_mg(sv) (SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_vstring) : NULL) +#endif + +/* Hint: sv_magic_portable + * This is a compatibility function that is only available with + * Devel::PPPort. It is NOT in the perl core. + * Its purpose is to mimic the 5.8.0 behaviour of sv_magic() when + * it is being passed a name pointer with namlen == 0. In that + * case, perl 5.8.0 and later store the pointer, not a copy of it. + * The compatibility can be provided back to perl 5.004. With + * earlier versions, the code will not compile. + */ + +#if (PERL_BCDVERSION < 0x5004000) + + /* code that uses sv_magic_portable will not compile */ + +#elif (PERL_BCDVERSION < 0x5008000) + +# define sv_magic_portable(sv, obj, how, name, namlen) \ + STMT_START { \ + SV *SvMp_sv = (sv); \ + char *SvMp_name = (char *) (name); \ + I32 SvMp_namlen = (namlen); \ + if (SvMp_name && SvMp_namlen == 0) \ + { \ + MAGIC *mg; \ + sv_magic(SvMp_sv, obj, how, 0, 0); \ + mg = SvMAGIC(SvMp_sv); \ + mg->mg_len = -42; /* XXX: this is the tricky part */ \ + mg->mg_ptr = SvMp_name; \ + } \ + else \ + { \ + sv_magic(SvMp_sv, obj, how, SvMp_name, SvMp_namlen); \ + } \ + } STMT_END + +#else + +# define sv_magic_portable(a, b, c, d, e) sv_magic(a, b, c, d, e) + +#endif + +#if !defined(mg_findext) +#if defined(NEED_mg_findext) +static MAGIC * DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL * vtbl); +static +#else +extern MAGIC * DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL * vtbl); +#endif + +#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL) + +#define mg_findext DPPP_(my_mg_findext) +#define Perl_mg_findext DPPP_(my_mg_findext) + + +MAGIC * +DPPP_(my_mg_findext)(const SV * sv, int type, const MGVTBL *vtbl) { + if (sv) { + MAGIC *mg; + +#ifdef AvPAD_NAMELIST + assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv))); +#endif + + for (mg = SvMAGIC (sv); mg; mg = mg->mg_moremagic) { + if (mg->mg_type == type && mg->mg_virtual == vtbl) + return mg; + } + } + + return NULL; +} + +#endif +#endif + +#if !defined(sv_unmagicext) +#if defined(NEED_sv_unmagicext) +static int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); +static +#else +extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl); +#endif + +#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL) + +#ifdef sv_unmagicext +# undef sv_unmagicext +#endif +#define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c) +#define Perl_sv_unmagicext DPPP_(my_sv_unmagicext) + + +int +DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) +{ + MAGIC* mg; + MAGIC** mgp; + + if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv)) + return 0; + mgp = &(SvMAGIC(sv)); + for (mg = *mgp; mg; mg = *mgp) { + const MGVTBL* const virt = mg->mg_virtual; + if (mg->mg_type == type && virt == vtbl) { + *mgp = mg->mg_moremagic; + if (virt && virt->svt_free) + virt->svt_free(aTHX_ sv, mg); + if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) { + if (mg->mg_len > 0) + Safefree(mg->mg_ptr); + else if (mg->mg_len == HEf_SVKEY) /* Questionable on older perls... */ + SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr)); + else if (mg->mg_type == PERL_MAGIC_utf8) + Safefree(mg->mg_ptr); + } + if (mg->mg_flags & MGf_REFCOUNTED) + SvREFCNT_dec(mg->mg_obj); + Safefree(mg); + } + else + mgp = &mg->mg_moremagic; + } + if (SvMAGIC(sv)) { + if (SvMAGICAL(sv)) /* if we're under save_magic, wait for restore_magic; */ + mg_magical(sv); /* else fix the flags now */ + } + else { + SvMAGICAL_off(sv); + SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; + } + return 0; +} + +#endif +#endif + +#ifdef USE_ITHREADS +#ifndef CopFILE +# define CopFILE(c) ((c)->cop_file) +#endif + +#ifndef CopFILEGV +# define CopFILEGV(c) (CopFILE(c) ? gv_fetchfile(CopFILE(c)) : Nullgv) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) ((c)->cop_file = savepv(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILE(c) ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILE(c) ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) ((c)->cop_stashpv) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) ((c)->cop_stashpv = ((pv) ? savepv(pv) : Nullch)) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) (CopSTASHPV(c) ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) ((hv) && (CopSTASHPV(c) == HvNAME(hv) \ + || (CopSTASHPV(c) && HvNAME(hv) \ + && strEQ(CopSTASHPV(c), HvNAME(hv))))) +#endif + +#else +#ifndef CopFILEGV +# define CopFILEGV(c) ((c)->cop_filegv) +#endif + +#ifndef CopFILEGV_set +# define CopFILEGV_set(c,gv) ((c)->cop_filegv = (GV*)SvREFCNT_inc(gv)) +#endif + +#ifndef CopFILE_set +# define CopFILE_set(c,pv) CopFILEGV_set((c), gv_fetchfile(pv)) +#endif + +#ifndef CopFILESV +# define CopFILESV(c) (CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv) +#endif + +#ifndef CopFILEAV +# define CopFILEAV(c) (CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav) +#endif + +#ifndef CopFILE +# define CopFILE(c) (CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch) +#endif + +#ifndef CopSTASH +# define CopSTASH(c) ((c)->cop_stash) +#endif + +#ifndef CopSTASH_set +# define CopSTASH_set(c,hv) ((c)->cop_stash = (hv)) +#endif + +#ifndef CopSTASHPV +# define CopSTASHPV(c) (CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch) +#endif + +#ifndef CopSTASHPV_set +# define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD)) +#endif + +#ifndef CopSTASH_eq +# define CopSTASH_eq(c,hv) (CopSTASH(c) == (hv)) +#endif + +#endif /* USE_ITHREADS */ + +#if (PERL_BCDVERSION >= 0x5006000) +#ifndef caller_cx + +# if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) +static I32 +DPPP_dopoptosub_at(const PERL_CONTEXT *cxstk, I32 startingblock) +{ + I32 i; + + for (i = startingblock; i >= 0; i--) { + const PERL_CONTEXT * const cx = &cxstk[i]; + switch (CxTYPE(cx)) { + default: + continue; + case CXt_EVAL: + case CXt_SUB: + case CXt_FORMAT: + return i; + } + } + return i; +} +# endif + +# if defined(NEED_caller_cx) +static const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT * * dbcxp); +static +#else +extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT * * dbcxp); +#endif + +#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL) + +#ifdef caller_cx +# undef caller_cx +#endif +#define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b) +#define Perl_caller_cx DPPP_(my_caller_cx) + + +const PERL_CONTEXT * +DPPP_(my_caller_cx)(pTHX_ I32 level, const PERL_CONTEXT **dbcxp) +{ + I32 cxix = DPPP_dopoptosub_at(cxstack, cxstack_ix); + const PERL_CONTEXT *cx; + const PERL_CONTEXT *ccstack = cxstack; + const PERL_SI *top_si = PL_curstackinfo; + + for (;;) { + /* we may be in a higher stacklevel, so dig down deeper */ + while (cxix < 0 && top_si->si_type != PERLSI_MAIN) { + top_si = top_si->si_prev; + ccstack = top_si->si_cxstack; + cxix = DPPP_dopoptosub_at(ccstack, top_si->si_cxix); + } + if (cxix < 0) + return NULL; + /* caller() should not report the automatic calls to &DB::sub */ + if (PL_DBsub && GvCV(PL_DBsub) && cxix >= 0 && + ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub)) + level++; + if (!level--) + break; + cxix = DPPP_dopoptosub_at(ccstack, cxix - 1); + } + + cx = &ccstack[cxix]; + if (dbcxp) *dbcxp = cx; + + if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) { + const I32 dbcxix = DPPP_dopoptosub_at(ccstack, cxix - 1); + /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the + field below is defined for any cx. */ + /* caller() should not report the automatic calls to &DB::sub */ + if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub)) + cx = &ccstack[dbcxix]; + } + + return cx; +} + +# endif +#endif /* caller_cx */ +#endif /* 5.6.0 */ +#ifndef IN_PERL_COMPILETIME +# define IN_PERL_COMPILETIME (PL_curcop == &PL_compiling) +#endif + +#ifndef IN_LOCALE_RUNTIME +# define IN_LOCALE_RUNTIME (PL_curcop->op_private & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE_COMPILETIME +# define IN_LOCALE_COMPILETIME (PL_hints & HINT_LOCALE) +#endif + +#ifndef IN_LOCALE +# define IN_LOCALE (IN_PERL_COMPILETIME ? IN_LOCALE_COMPILETIME : IN_LOCALE_RUNTIME) +#endif +#ifndef IS_NUMBER_IN_UV +# define IS_NUMBER_IN_UV 0x01 +#endif + +#ifndef IS_NUMBER_GREATER_THAN_UV_MAX +# define IS_NUMBER_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef IS_NUMBER_NOT_INT +# define IS_NUMBER_NOT_INT 0x04 +#endif + +#ifndef IS_NUMBER_NEG +# define IS_NUMBER_NEG 0x08 +#endif + +#ifndef IS_NUMBER_INFINITY +# define IS_NUMBER_INFINITY 0x10 +#endif + +#ifndef IS_NUMBER_NAN +# define IS_NUMBER_NAN 0x20 +#endif +#ifndef GROK_NUMERIC_RADIX +# define GROK_NUMERIC_RADIX(sp, send) grok_numeric_radix(sp, send) +#endif +#ifndef PERL_SCAN_GREATER_THAN_UV_MAX +# define PERL_SCAN_GREATER_THAN_UV_MAX 0x02 +#endif + +#ifndef PERL_SCAN_SILENT_ILLDIGIT +# define PERL_SCAN_SILENT_ILLDIGIT 0x04 +#endif + +#ifndef PERL_SCAN_ALLOW_UNDERSCORES +# define PERL_SCAN_ALLOW_UNDERSCORES 0x01 +#endif + +#ifndef PERL_SCAN_DISALLOW_PREFIX +# define PERL_SCAN_DISALLOW_PREFIX 0x02 +#endif + +#ifndef grok_numeric_radix +#if defined(NEED_grok_numeric_radix) +static bool DPPP_(my_grok_numeric_radix)(pTHX_ const char * * sp, const char * send); +static +#else +extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char * * sp, const char * send); +#endif + +#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL) + +#ifdef grok_numeric_radix +# undef grok_numeric_radix +#endif +#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b) +#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix) + +bool +DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send) +{ +#ifdef USE_LOCALE_NUMERIC +#ifdef PL_numeric_radix_sv + if (PL_numeric_radix_sv && IN_LOCALE) { + STRLEN len; + char* radix = SvPV(PL_numeric_radix_sv, len); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#else + /* older perls don't have PL_numeric_radix_sv so the radix + * must manually be requested from locale.h + */ +#include + dTHR; /* needed for older threaded perls */ + struct lconv *lc = localeconv(); + char *radix = lc->decimal_point; + if (radix && IN_LOCALE) { + STRLEN len = strlen(radix); + if (*sp + len <= send && memEQ(*sp, radix, len)) { + *sp += len; + return TRUE; + } + } +#endif +#endif /* USE_LOCALE_NUMERIC */ + /* always try "." if numeric radix didn't match because + * we may have data from different locales mixed */ + if (*sp < send && **sp == '.') { + ++*sp; + return TRUE; + } + return FALSE; +} +#endif +#endif + +#ifndef grok_number +#if defined(NEED_grok_number) +static int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +static +#else +extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep); +#endif + +#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL) + +#ifdef grok_number +# undef grok_number +#endif +#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c) +#define Perl_grok_number DPPP_(my_grok_number) + +int +DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep) +{ + const char *s = pv; + const char *send = pv + len; + const UV max_div_10 = UV_MAX / 10; + const char max_mod_10 = UV_MAX % 10; + int numtype = 0; + int sawinf = 0; + int sawnan = 0; + + while (s < send && isSPACE(*s)) + s++; + if (s == send) { + return 0; + } else if (*s == '-') { + s++; + numtype = IS_NUMBER_NEG; + } + else if (*s == '+') + s++; + + if (s == send) + return 0; + + /* next must be digit or the radix separator or beginning of infinity */ + if (isDIGIT(*s)) { + /* UVs are at least 32 bits, so the first 9 decimal digits cannot + overflow. */ + UV value = *s - '0'; + /* This construction seems to be more optimiser friendly. + (without it gcc does the isDIGIT test and the *s - '0' separately) + With it gcc on arm is managing 6 instructions (6 cycles) per digit. + In theory the optimiser could deduce how far to unroll the loop + before checking for overflow. */ + if (++s < send) { + int digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + digit = *s - '0'; + if (digit >= 0 && digit <= 9) { + value = value * 10 + digit; + if (++s < send) { + /* Now got 9 digits, so need to check + each time for overflow. */ + digit = *s - '0'; + while (digit >= 0 && digit <= 9 + && (value < max_div_10 + || (value == max_div_10 + && digit <= max_mod_10))) { + value = value * 10 + digit; + if (++s < send) + digit = *s - '0'; + else + break; + } + if (digit >= 0 && digit <= 9 + && (s < send)) { + /* value overflowed. + skip the remaining digits, don't + worry about setting *valuep. */ + do { + s++; + } while (s < send && isDIGIT(*s)); + numtype |= + IS_NUMBER_GREATER_THAN_UV_MAX; + goto skip_value; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + numtype |= IS_NUMBER_IN_UV; + if (valuep) + *valuep = value; + + skip_value: + if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT; + while (s < send && isDIGIT(*s)) /* optional digits after the radix */ + s++; + } + } + else if (GROK_NUMERIC_RADIX(&s, send)) { + numtype |= IS_NUMBER_NOT_INT | IS_NUMBER_IN_UV; /* valuep assigned below */ + /* no digits before the radix means we need digits after it */ + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + if (valuep) { + /* integer approximation is valid - it's 0. */ + *valuep = 0; + } + } + else + return 0; + } else if (*s == 'I' || *s == 'i') { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'F' && *s != 'f')) return 0; + s++; if (s < send && (*s == 'I' || *s == 'i')) { + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; if (s == send || (*s != 'I' && *s != 'i')) return 0; + s++; if (s == send || (*s != 'T' && *s != 't')) return 0; + s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0; + s++; + } + sawinf = 1; + } else if (*s == 'N' || *s == 'n') { + /* XXX TODO: There are signaling NaNs and quiet NaNs. */ + s++; if (s == send || (*s != 'A' && *s != 'a')) return 0; + s++; if (s == send || (*s != 'N' && *s != 'n')) return 0; + s++; + sawnan = 1; + } else + return 0; + + if (sawinf) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT; + } else if (sawnan) { + numtype &= IS_NUMBER_NEG; /* Keep track of sign */ + numtype |= IS_NUMBER_NAN | IS_NUMBER_NOT_INT; + } else if (s < send) { + /* we can have an optional exponent part */ + if (*s == 'e' || *s == 'E') { + /* The only flag we keep is sign. Blow away any "it's UV" */ + numtype &= IS_NUMBER_NEG; + numtype |= IS_NUMBER_NOT_INT; + s++; + if (s < send && (*s == '-' || *s == '+')) + s++; + if (s < send && isDIGIT(*s)) { + do { + s++; + } while (s < send && isDIGIT(*s)); + } + else + return 0; + } + } + while (s < send && isSPACE(*s)) + s++; + if (s >= send) + return numtype; + if (len == 10 && memEQ(pv, "0 but true", 10)) { + if (valuep) + *valuep = 0; + return IS_NUMBER_IN_UV; + } + return 0; +} +#endif +#endif + +/* + * The grok_* routines have been modified to use warn() instead of + * Perl_warner(). Also, 'hexdigit' was the former name of PL_hexdigit, + * which is why the stack variable has been renamed to 'xdigit'. + */ + +#ifndef grok_bin +#if defined(NEED_grok_bin) +static UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL) + +#ifdef grok_bin +# undef grok_bin +#endif +#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d) +#define Perl_grok_bin DPPP_(my_grok_bin) + +UV +DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_2 = UV_MAX / 2; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading b or 0b. + for compatibility silently suffer "b" and "0b" as valid binary + numbers. */ + if (len >= 1) { + if (s[0] == 'b') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'b') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + char bit = *s; + if (bit == '0' || bit == '1') { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_bin. */ + redo: + if (!overflowed) { + if (value <= max_div_2) { + value = (value << 1) | (bit - '0'); + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in binary number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 2.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount. */ + value_nv += (NV)(bit - '0'); + continue; + } + if (bit == '_' && len && allow_underscores && (bit = s[1]) + && (bit == '0' || bit == '1')) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal binary digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Binary number > 0b11111111111111111111111111111111 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_hex +#if defined(NEED_grok_hex) +static UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL) + +#ifdef grok_hex +# undef grok_hex +#endif +#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d) +#define Perl_grok_hex DPPP_(my_grok_hex) + +UV +DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_16 = UV_MAX / 16; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + const char *xdigit; + + if (!(*flags & PERL_SCAN_DISALLOW_PREFIX)) { + /* strip off leading x or 0x. + for compatibility silently suffer "x" and "0x" as valid hex numbers. + */ + if (len >= 1) { + if (s[0] == 'x') { + s++; + len--; + } + else if (len >= 2 && s[0] == '0' && s[1] == 'x') { + s+=2; + len-=2; + } + } + } + + for (; len-- && *s; s++) { + xdigit = strchr((char *) PL_hexdigit, *s); + if (xdigit) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + With gcc seems to be much straighter code than old scan_hex. */ + redo: + if (!overflowed) { + if (value <= max_div_16) { + value = (value << 4) | ((xdigit - PL_hexdigit) & 15); + continue; + } + warn("Integer overflow in hexadecimal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 16.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 16-tuples. */ + value_nv += (NV)((xdigit - PL_hexdigit) & 15); + continue; + } + if (*s == '_' && len && allow_underscores && s[1] + && (xdigit = strchr((char *) PL_hexdigit, s[1]))) + { + --len; + ++s; + goto redo; + } + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal hexadecimal digit '%c' ignored", *s); + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Hexadecimal number > 0xffffffff non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#ifndef grok_oct +#if defined(NEED_grok_oct) +static UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +static +#else +extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result); +#endif + +#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL) + +#ifdef grok_oct +# undef grok_oct +#endif +#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d) +#define Perl_grok_oct DPPP_(my_grok_oct) + +UV +DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result) +{ + const char *s = start; + STRLEN len = *len_p; + UV value = 0; + NV value_nv = 0; + + const UV max_div_8 = UV_MAX / 8; + bool allow_underscores = *flags & PERL_SCAN_ALLOW_UNDERSCORES; + bool overflowed = FALSE; + + for (; len-- && *s; s++) { + /* gcc 2.95 optimiser not smart enough to figure that this subtraction + out front allows slicker code. */ + int digit = *s - '0'; + if (digit >= 0 && digit <= 7) { + /* Write it in this wonky order with a goto to attempt to get the + compiler to make the common case integer-only loop pretty tight. + */ + redo: + if (!overflowed) { + if (value <= max_div_8) { + value = (value << 3) | digit; + continue; + } + /* Bah. We're just overflowed. */ + warn("Integer overflow in octal number"); + overflowed = TRUE; + value_nv = (NV) value; + } + value_nv *= 8.0; + /* If an NV has not enough bits in its mantissa to + * represent a UV this summing of small low-order numbers + * is a waste of time (because the NV cannot preserve + * the low-order bits anyway): we could just remember when + * did we overflow and in the end just multiply value_nv by the + * right amount of 8-tuples. */ + value_nv += (NV)digit; + continue; + } + if (digit == ('_' - '0') && len && allow_underscores + && (digit = s[1] - '0') && (digit >= 0 && digit <= 7)) + { + --len; + ++s; + goto redo; + } + /* Allow \octal to work the DWIM way (that is, stop scanning + * as soon as non-octal characters are seen, complain only iff + * someone seems to want to use the digits eight and nine). */ + if (digit == 8 || digit == 9) { + if (!(*flags & PERL_SCAN_SILENT_ILLDIGIT)) + warn("Illegal octal digit '%c' ignored", *s); + } + break; + } + + if ( ( overflowed && value_nv > 4294967295.0) +#if UVSIZE > 4 + || (!overflowed && value > 0xffffffff ) +#endif + ) { + warn("Octal number > 037777777777 non-portable"); + } + *len_p = s - start; + if (!overflowed) { + *flags = 0; + return value; + } + *flags = PERL_SCAN_GREATER_THAN_UV_MAX; + if (result) + *result = value_nv; + return UV_MAX; +} +#endif +#endif + +#if !defined(my_snprintf) +#if defined(NEED_my_snprintf) +static int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +static +#else +extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...); +#endif + +#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL) + +#define my_snprintf DPPP_(my_my_snprintf) +#define Perl_my_snprintf DPPP_(my_my_snprintf) + + +int +DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...) +{ + dTHX; + int retval; + va_list ap; + va_start(ap, format); +#ifdef HAS_VSNPRINTF + retval = vsnprintf(buffer, len, format, ap); +#else + retval = vsprintf(buffer, format, ap); +#endif + va_end(ap); + if (retval < 0 || (len > 0 && (Size_t)retval >= len)) + Perl_croak(aTHX_ "panic: my_snprintf buffer overflow"); + return retval; +} + +#endif +#endif + +#if !defined(my_sprintf) +#if defined(NEED_my_sprintf) +static int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +static +#else +extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...); +#endif + +#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL) + +#define my_sprintf DPPP_(my_my_sprintf) + + +/* Warning: my_sprintf + It's safer to use my_snprintf instead +*/ + +/* Replace my_sprintf with my_snprintf */ + +int +DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...) +{ + va_list args; + va_start(args, pat); + vsprintf(buffer, pat, args); + va_end(args); + return strlen(buffer); +} + +#endif +#endif + +#ifdef NO_XSLOCKS +# ifdef dJMPENV +# define dXCPT dJMPENV; int rEtV = 0 +# define XCPT_TRY_START JMPENV_PUSH(rEtV); if (rEtV == 0) +# define XCPT_TRY_END JMPENV_POP; +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW JMPENV_JUMP(rEtV) +# else +# define dXCPT Sigjmp_buf oldTOP; int rEtV = 0 +# define XCPT_TRY_START Copy(top_env, oldTOP, 1, Sigjmp_buf); rEtV = Sigsetjmp(top_env, 1); if (rEtV == 0) +# define XCPT_TRY_END Copy(oldTOP, top_env, 1, Sigjmp_buf); +# define XCPT_CATCH if (rEtV != 0) +# define XCPT_RETHROW Siglongjmp(top_env, rEtV) +# endif +#endif + +#if !defined(my_strlcat) +#if defined(NEED_my_strlcat) +static Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size); +#endif + +#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL) + +#define my_strlcat DPPP_(my_my_strlcat) +#define Perl_my_strlcat DPPP_(my_my_strlcat) + + +Size_t +DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size) +{ + Size_t used, length, copy; + + used = strlen(dst); + length = strlen(src); + if (size > 0 && used < size - 1) { + copy = (length >= size - used) ? size - used - 1 : length; + memcpy(dst + used, src, copy); + dst[used + copy] = '\0'; + } + return used + length; +} +#endif +#endif + +#if !defined(my_strlcpy) +#if defined(NEED_my_strlcpy) +static Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +static +#else +extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size); +#endif + +#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL) + +#define my_strlcpy DPPP_(my_my_strlcpy) +#define Perl_my_strlcpy DPPP_(my_my_strlcpy) + + +Size_t +DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size) +{ + Size_t length, copy; + + length = strlen(src); + if (size > 0) { + copy = (length >= size) ? size - 1 : length; + memcpy(dst, src, copy); + dst[copy] = '\0'; + } + return length; +} + +#endif +#endif + +#ifdef SVf_UTF8 +#ifndef SvUTF8 +# define SvUTF8(sv) (SvFLAGS(sv) & SVf_UTF8) +#endif + +#endif + +#if (PERL_BCDVERSION == 0x5019001) /* 5.19.1 does not have UTF8fARG, only broken UTF8f */ +#undef UTF8f +#endif + +#ifdef SVf_UTF8 +#ifndef UTF8f +# define UTF8f SVf +#endif + +#ifndef UTF8fARG +# define UTF8fARG(u,l,p) newSVpvn_flags((p), (l), ((u) ? SVf_UTF8 : 0) | SVs_TEMP) +#endif + +#endif + +#define D_PPP_MIN(a,b) (((a) <= (b)) ? (a) : (b)) +#ifndef UNICODE_REPLACEMENT +# define UNICODE_REPLACEMENT 0xFFFD +#endif + +#ifdef UTF8_MAXLEN +#ifndef UTF8_MAXBYTES +# define UTF8_MAXBYTES UTF8_MAXLEN +#endif + +#endif +#ifndef UTF_START_MARK +# define UTF_START_MARK(len) \ + (((len) > 7) ? 0xFF : (0xFF & (0xFE << (7-(len))))) +#endif + +/* On non-EBCDIC was valid for some releases earlier than this, but easier to + * just do one check */ +#if (PERL_BCDVERSION < 0x5018000) +# undef UTF8_MAXBYTES_CASE +#endif + +#if 'A' == 65 +# define D_PPP_BYTE_INFO_BITS 6 /* 6 bits meaningful in continuation bytes */ +#ifndef UTF8_MAXBYTES_CASE +# define UTF8_MAXBYTES_CASE 13 +#endif + +#else +# define D_PPP_BYTE_INFO_BITS 5 /* 5 bits meaningful in continuation bytes */ +#ifndef UTF8_MAXBYTES_CASE +# define UTF8_MAXBYTES_CASE 15 +#endif + +#endif +#ifndef UTF_ACCUMULATION_SHIFT +# define UTF_ACCUMULATION_SHIFT D_PPP_BYTE_INFO_BITS +#endif + +#ifdef NATIVE_TO_UTF +#ifndef NATIVE_UTF8_TO_I8 +# define NATIVE_UTF8_TO_I8(c) NATIVE_TO_UTF(c) +#endif + +#else /* System doesn't support EBCDIC */ +#ifndef NATIVE_UTF8_TO_I8 +# define NATIVE_UTF8_TO_I8(c) (c) +#endif + +#endif + +#ifdef UTF_TO_NATIVE +#ifndef I8_TO_NATIVE_UTF8 +# define I8_TO_NATIVE_UTF8(c) UTF_TO_NATIVE(c) +#endif + +#else /* System doesn't support EBCDIC */ +#ifndef I8_TO_NATIVE_UTF8 +# define I8_TO_NATIVE_UTF8(c) (c) +#endif + +#endif +#ifndef UTF_START_MASK +# define UTF_START_MASK(len) \ + (((len) >= 7) ? 0x00 : (0x1F >> ((len)-2))) +#endif + +#ifndef UTF_IS_CONTINUATION_MASK +# define UTF_IS_CONTINUATION_MASK \ + ((U8) (0xFF << UTF_ACCUMULATION_SHIFT)) +#endif + +#ifndef UTF_CONTINUATION_MARK +# define UTF_CONTINUATION_MARK \ + (UTF_IS_CONTINUATION_MASK & 0xB0) +#endif + +#ifndef UTF_MIN_START_BYTE +# define UTF_MIN_START_BYTE \ + ((UTF_CONTINUATION_MARK >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2)) +#endif +#ifndef UTF_MIN_ABOVE_LATIN1_BYTE +# define UTF_MIN_ABOVE_LATIN1_BYTE \ + ((0x100 >> UTF_ACCUMULATION_SHIFT) | UTF_START_MARK(2)) +#endif + +#if (PERL_BCDVERSION < 0x5007000) /* Was the complement of what should have been */ +# undef UTF8_IS_DOWNGRADEABLE_START +#endif +#ifndef UTF8_IS_DOWNGRADEABLE_START +# define UTF8_IS_DOWNGRADEABLE_START(c) \ + inRANGE(NATIVE_UTF8_TO_I8(c), \ + UTF_MIN_START_BYTE, UTF_MIN_ABOVE_LATIN1_BYTE - 1) +#endif + +#ifndef UTF_CONTINUATION_MASK +# define UTF_CONTINUATION_MASK \ + ((U8) ((1U << UTF_ACCUMULATION_SHIFT) - 1)) +#endif +#ifndef UTF8_ACCUMULATE +# define UTF8_ACCUMULATE(base, added) \ + (((base) << UTF_ACCUMULATION_SHIFT) \ + | ((NATIVE_UTF8_TO_I8(added)) \ + & UTF_CONTINUATION_MASK)) +#endif +#ifndef UTF8_ALLOW_ANYUV +# define UTF8_ALLOW_ANYUV 0 +#endif + +#ifndef UTF8_ALLOW_EMPTY +# define UTF8_ALLOW_EMPTY 0x0001 +#endif + +#ifndef UTF8_ALLOW_CONTINUATION +# define UTF8_ALLOW_CONTINUATION 0x0002 +#endif + +#ifndef UTF8_ALLOW_NON_CONTINUATION +# define UTF8_ALLOW_NON_CONTINUATION 0x0004 +#endif + +#ifndef UTF8_ALLOW_SHORT +# define UTF8_ALLOW_SHORT 0x0008 +#endif + +#ifndef UTF8_ALLOW_LONG +# define UTF8_ALLOW_LONG 0x0010 +#endif + +#ifndef UTF8_ALLOW_OVERFLOW +# define UTF8_ALLOW_OVERFLOW 0x0080 +#endif + +#ifndef UTF8_ALLOW_ANY +# define UTF8_ALLOW_ANY ( UTF8_ALLOW_CONTINUATION \ + |UTF8_ALLOW_NON_CONTINUATION \ + |UTF8_ALLOW_SHORT \ + |UTF8_ALLOW_LONG \ + |UTF8_ALLOW_OVERFLOW) +#endif + +#if defined UTF8SKIP + +/* Don't use official versions because they use MIN, which may not be available */ +#undef UTF8_SAFE_SKIP +#undef UTF8_CHK_SKIP +#ifndef UTF8_SAFE_SKIP +# define UTF8_SAFE_SKIP(s, e) ( \ + ((((e) - (s)) <= 0) \ + ? 0 \ + : D_PPP_MIN(((e) - (s)), UTF8SKIP(s)))) +#endif +#ifndef UTF8_CHK_SKIP +# define UTF8_CHK_SKIP(s) \ + (s[0] == '\0' ? 1 : ((U8) D_PPP_MIN(my_strnlen((char *) (s), UTF8SKIP(s)), \ + UTF8SKIP(s)))) +#endif + +/* UTF8_CHK_SKIP depends on my_strnlen */ +#ifndef UTF8_SKIP +# define UTF8_SKIP(s) UTF8SKIP(s) +#endif + +#endif + +#if 'A' == 65 +#ifndef UTF8_IS_INVARIANT +# define UTF8_IS_INVARIANT(c) isASCII(c) +#endif + +#else +#ifndef UTF8_IS_INVARIANT +# define UTF8_IS_INVARIANT(c) (isASCII(c) || isCNTRL_L1(c)) +#endif + +#endif +#ifndef UVCHR_IS_INVARIANT +# define UVCHR_IS_INVARIANT(c) UTF8_IS_INVARIANT(c) +#endif + +#ifdef UVCHR_IS_INVARIANT +# if 'A' != 65 || UVSIZE < 8 + /* 32 bit platform, which includes UTF-EBCDIC on the releases this is + * backported to */ +# define D_PPP_UVCHR_SKIP_UPPER(c) 7 +# else +# define D_PPP_UVCHR_SKIP_UPPER(c) \ + (((WIDEST_UTYPE) (c)) < \ + (((WIDEST_UTYPE) 1) << (6 * D_PPP_BYTE_INFO_BITS)) ? 7 : 13) +# endif +#ifndef UVCHR_SKIP +# define UVCHR_SKIP(c) \ + UVCHR_IS_INVARIANT(c) ? 1 : \ + (WIDEST_UTYPE) (c) < (32 * (1U << ( D_PPP_BYTE_INFO_BITS))) ? 2 : \ + (WIDEST_UTYPE) (c) < (16 * (1U << (2 * D_PPP_BYTE_INFO_BITS))) ? 3 : \ + (WIDEST_UTYPE) (c) < ( 8 * (1U << (3 * D_PPP_BYTE_INFO_BITS))) ? 4 : \ + (WIDEST_UTYPE) (c) < ( 4 * (1U << (4 * D_PPP_BYTE_INFO_BITS))) ? 5 : \ + (WIDEST_UTYPE) (c) < ( 2 * (1U << (5 * D_PPP_BYTE_INFO_BITS))) ? 6 : \ + D_PPP_UVCHR_SKIP_UPPER(c) +#endif + +#endif + +#ifdef is_ascii_string +#ifndef is_invariant_string +# define is_invariant_string(s,l) is_ascii_string(s,l) +#endif + +#ifndef is_utf8_invariant_string +# define is_utf8_invariant_string(s,l) is_ascii_string(s,l) +#endif + +/* Hint: is_ascii_string, is_invariant_string + is_utf8_invariant_string() does the same thing and is preferred because its + name is more accurate as to what it does */ +#endif + +#ifdef ibcmp_utf8 +#ifndef foldEQ_utf8 +# define foldEQ_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2) \ + cBOOL(! ibcmp_utf8(s1,pe1,l1,u1,s2,pe2,l2,u2)) +#endif + +#endif + +#if defined(is_utf8_string) && defined(UTF8SKIP) +#ifndef isUTF8_CHAR +# define isUTF8_CHAR(s, e) ( \ + (e) <= (s) || ! is_utf8_string(s, UTF8_SAFE_SKIP(s, e)) \ + ? 0 \ + : UTF8SKIP(s)) +#endif + +#endif + +#if 'A' == 65 +#ifndef BOM_UTF8 +# define BOM_UTF8 "\xEF\xBB\xBF" +#endif + +#ifndef REPLACEMENT_CHARACTER_UTF8 +# define REPLACEMENT_CHARACTER_UTF8 "\xEF\xBF\xBD" +#endif + +#elif '^' == 95 +#ifndef BOM_UTF8 +# define BOM_UTF8 "\xDD\x73\x66\x73" +#endif + +#ifndef REPLACEMENT_CHARACTER_UTF8 +# define REPLACEMENT_CHARACTER_UTF8 "\xDD\x73\x73\x71" +#endif + +#elif '^' == 176 +#ifndef BOM_UTF8 +# define BOM_UTF8 "\xDD\x72\x65\x72" +#endif + +#ifndef REPLACEMENT_CHARACTER_UTF8 +# define REPLACEMENT_CHARACTER_UTF8 "\xDD\x72\x72\x70" +#endif + +#else +# error Unknown character set +#endif + +#if (PERL_BCDVERSION < 0x5035010) + /* Versions prior to 5.31.4 accepted things that are now considered + * malformations, and didn't return -1 on error with warnings enabled. + * Versions before 5.35.10 dereferenced empty input without checking */ +# undef utf8_to_uvchr_buf +#endif + +/* This implementation brings modern, generally more restricted standards to + * utf8_to_uvchr_buf. Some of these are security related, and clearly must + * be done. But its arguable that the others need not, and hence should not. + * The reason they're here is that a module that intends to play with the + * latest perls should be able to work the same in all releases. An example is + * that perl no longer accepts any UV for a code point, but limits them to + * IV_MAX or below. This is for future internal use of the larger code points. + * If it turns out that some of these changes are breaking code that isn't + * intended to work with modern perls, the tighter restrictions could be + * relaxed. khw thinks this is unlikely, but has been wrong in the past. */ + +/* 5.6.0 is the first release with UTF-8, and we don't implement this function + * there due to its likely lack of still being in use, and the underlying + * implementation is very different from later ones, without the later + * safeguards, so would require extra work to deal with */ +#if (PERL_BCDVERSION >= 0x5006001) && ! defined(utf8_to_uvchr_buf) + /* Choose which underlying implementation to use. At least one must be + * present or the perl is too early to handle this function */ +# if defined(utf8n_to_uvchr) || defined(utf8_to_uvchr) || defined(utf8_to_uv) +# if defined(utf8n_to_uvchr) /* This is the preferred implementation */ +# define D_PPP_utf8_to_uvchr_buf_callee utf8n_to_uvchr +# elif /* Must be at least 5.6.1 from #if above; \ + If have both regular and _simple, regular has all args */ \ + defined(utf8_to_uv) && defined(utf8_to_uv_simple) +# define D_PPP_utf8_to_uvchr_buf_callee utf8_to_uv +# elif defined(utf8_to_uvchr) /* The below won't work well on error input */ +# define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) \ + utf8_to_uvchr((U8 *)(s), (retlen)) +# else +# define D_PPP_utf8_to_uvchr_buf_callee(s, curlen, retlen, flags) \ + utf8_to_uv((U8 *)(s), (retlen)) +# endif +# endif + +# if defined(NEED_utf8_to_uvchr_buf) +static UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen); +static +#else +extern UV DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 * s, const U8 * send, STRLEN * retlen); +#endif + +#if defined(NEED_utf8_to_uvchr_buf) || defined(NEED_utf8_to_uvchr_buf_GLOBAL) + +#ifdef utf8_to_uvchr_buf +# undef utf8_to_uvchr_buf +#endif +#define utf8_to_uvchr_buf(a,b,c) DPPP_(my_utf8_to_uvchr_buf)(aTHX_ a,b,c) +#define Perl_utf8_to_uvchr_buf DPPP_(my_utf8_to_uvchr_buf) + + +UV +DPPP_(my_utf8_to_uvchr_buf)(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) +{ +# if (PERL_BCDVERSION >= 0x5031004) /* But from above, must be < 5.35.10 */ +# if (PERL_BCDVERSION != 0x5035009) + + /* Versions less than 5.35.9 could dereference s on zero length, so + * pass it something where no harm comes from that. */ + if (send <= s) s = send = (U8 *) "?"; + return Perl_utf8_to_uvchr_buf_helper(aTHX_ s, send, retlen); + +# else /* Below is 5.35.9, which also works on non-empty input, but + for empty input, can wrongly dereference, and additionally is + also just plain broken */ + if (send > s) return Perl_utf8_to_uvchr_buf_helper(aTHX_ s, send, retlen); + if (! ckWARN_d(WARN_UTF8)) { + if (retlen) *retlen = 0; + return UNICODE_REPLACEMENT; + } + else { + s = send = (U8 *) "?"; + + /* Call just for its warning */ + (void) Perl__utf8n_to_uvchr_msgs_helper(s, 0, NULL, 0, NULL, NULL); + if (retlen) *retlen = (STRLEN) -1; + return 0; + } + +# endif +# else + + UV ret; + STRLEN curlen; + bool overflows = 0; + const U8 *cur_s = s; + const bool do_warnings = ckWARN_d(WARN_UTF8); +# if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC) + STRLEN overflow_length = 0; +# endif + + if (send > s) { + curlen = send - s; + } + else { + assert(0); /* Modern perls die under this circumstance */ + curlen = 0; + if (! do_warnings) { /* Handle empty here if no warnings needed */ + if (retlen) *retlen = 0; + return UNICODE_REPLACEMENT; + } + } + +# if (PERL_BCDVERSION < 0x5026000) && ! defined(EBCDIC) + + /* Perl did not properly detect overflow for much of its history on + * non-EBCDIC platforms, often returning an overlong value which may or may + * not have been tolerated in the call. Also, earlier versions, when they + * did detect overflow, may have disallowed it completely. Modern ones can + * replace it with the REPLACEMENT CHARACTER, depending on calling + * parameters. Therefore detect it ourselves in releases it was + * problematic in. */ + + if (curlen > 0 && UNLIKELY(*s >= 0xFE)) { + + /* First, on a 32-bit machine the first byte being at least \xFE + * automatically is overflow, as it indicates something requiring more + * than 31 bits */ + if (sizeof(ret) < 8) { + overflows = 1; + overflow_length = (*s == 0xFE) ? 7 : 13; + } + else { + const U8 highest[] = /* 2*63-1 */ + "\xFF\x80\x87\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF"; + const U8 *cur_h = highest; + + for (cur_s = s; cur_s < send; cur_s++, cur_h++) { + if (UNLIKELY(*cur_s == *cur_h)) { + continue; + } + + /* If this byte is larger than the corresponding highest UTF-8 + * byte, the sequence overflows; otherwise the byte is less + * than (as we handled the equality case above), and so the + * sequence doesn't overflow */ + overflows = *cur_s > *cur_h; + break; + + } + + /* Here, either we set the bool and broke out of the loop, or got + * to the end and all bytes are the same which indicates it doesn't + * overflow. If it did overflow, it would be this number of bytes + * */ + overflow_length = 13; + } + } + + if (UNLIKELY(overflows)) { + ret = 0; + + if (! do_warnings && retlen) { + *retlen = overflow_length; + } + } + else + +# endif /* < 5.26 */ + + /* Here, we are either in a release that properly detects overflow, or + * we have checked for overflow and the next statement is executing as + * part of the above conditional where we know we don't have overflow. + * + * The modern versions allow anything that evaluates to a legal UV, but + * not overlongs nor an empty input */ + ret = D_PPP_utf8_to_uvchr_buf_callee( + (U8 *) /* Early perls: no const */ + s, curlen, retlen, (UTF8_ALLOW_ANYUV + & ~(UTF8_ALLOW_LONG|UTF8_ALLOW_EMPTY))); + +# if (PERL_BCDVERSION >= 0x5026000) && (PERL_BCDVERSION < 0x5028000) + + /* But actually, more modern versions restrict the UV to being no more than + * what an IV can hold, so it could still have gotten it wrong about + * overflowing. */ + if (UNLIKELY(ret > IV_MAX)) { + overflows = 1; + } + +# endif + + if (UNLIKELY(overflows)) { + if (! do_warnings) { + if (retlen) { + *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s)); + *retlen = D_PPP_MIN(*retlen, curlen); + } + return UNICODE_REPLACEMENT; + } + else { + + /* We use the error message in use from 5.8-5.26 */ + Perl_warner(aTHX_ packWARN(WARN_UTF8), + "Malformed UTF-8 character (overflow at 0x%" UVxf + ", byte 0x%02x, after start byte 0x%02x)", + ret, *cur_s, *s); + if (retlen) { + *retlen = (STRLEN) -1; + } + return 0; + } + } + + /* Here, did not overflow, but if it failed for some other reason, and + * warnings are off, to emulate the behavior of the real utf8_to_uvchr(), + * try again, allowing anything. (Note a return of 0 is ok if the input + * was '\0') */ + if (UNLIKELY(ret == 0 && (curlen == 0 || *s != '\0'))) { + + /* If curlen is 0, we already handled the case where warnings are + * disabled, so this 'if' will be true, and so later on, we know that + * 's' is dereferencible */ + if (do_warnings) { + if (retlen) { + *retlen = (STRLEN) -1; + } + } + else { + ret = D_PPP_utf8_to_uvchr_buf_callee( + (U8 *) /* Early perls: no const */ + s, curlen, retlen, UTF8_ALLOW_ANY); + /* Override with the REPLACEMENT character, as that is what the + * modern version of this function returns */ + ret = UNICODE_REPLACEMENT; + +# if (PERL_BCDVERSION < 0x5016000) + + /* Versions earlier than this don't necessarily return the proper + * length. It should not extend past the end of string, nor past + * what the first byte indicates the length is, nor past the + * continuation characters */ + if (retlen && (IV) *retlen >= 0) { + unsigned int i = 1; + + *retlen = D_PPP_MIN(*retlen, curlen); + *retlen = D_PPP_MIN(*retlen, UTF8SKIP(s)); + do { +# ifdef UTF8_IS_CONTINUATION + if (! UTF8_IS_CONTINUATION(s[i])) +# else /* Versions without the above don't support EBCDIC anyway */ + if (s[i] < 0x80 || s[i] > 0xBF) +# endif + { + *retlen = i; + break; + } + } while (++i < *retlen); + } + +# endif /* end of < 5.16.0 */ + + } + } + + return ret; + +# endif /* end of < 5.31.4 */ + +} + +# endif +#endif + +#if defined(UTF8SKIP) && defined(utf8_to_uvchr_buf) +#undef utf8_to_uvchr /* Always redefine this unsafe function so that it refuses + to read past a NUL, making it much less likely to read + off the end of the buffer. A NUL indicates the start + of the next character anyway. If the input isn't + NUL-terminated, the function remains unsafe, as it + always has been. */ +#ifndef utf8_to_uvchr +# define utf8_to_uvchr(s, lp) \ + ((*(s) == '\0') \ + ? utf8_to_uvchr_buf(s,((s)+1), lp) /* Handle single NUL specially */ \ + : utf8_to_uvchr_buf(s, (s) + UTF8_CHK_SKIP(s), (lp))) +#endif + +#endif + +/* Hint: utf8_to_uvchr + Use utf8_to_uvchr_buf() instead. But ONLY if you KNOW the upper bound + of the input string (not resorting to using UTF8SKIP, etc., to infer it). + The backported utf8_to_uvchr() will do a better job to prevent most cases + of trying to read beyond the end of the buffer */ + +/* Replace utf8_to_uvchr with utf8_to_uvchr_buf */ + +#ifdef sv_len_utf8 +# if (PERL_BCDVERSION >= 0x5017005) +# ifndef sv_len_utf8_nomg +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define sv_len_utf8_nomg(sv) \ + ({ \ + SV *sv_ = (sv); \ + sv_len_utf8(!SvGMAGICAL(sv_) \ + ? sv_ \ + : sv_mortalcopy_flags(sv_, SV_NOSTEAL)); \ + }) +# else + PERL_STATIC_INLINE STRLEN D_PPP_sv_len_utf8_nomg(SV * sv) + { + dTHX; + if (SvGMAGICAL(sv)) + return sv_len_utf8(sv_mortalcopy_flags(sv, + SV_NOSTEAL)); + else return sv_len_utf8(sv); + } +# define sv_len_utf8_nomg(sv) D_PPP_sv_len_utf8_nomg(sv) +# endif +# endif +# else /* < 5.17.5 */ + /* Older Perl versions have broken sv_len_utf8() when passed sv does not + * have SVf_UTF8 flag set */ + /* Also note that SvGETMAGIC() may change presence of SVf_UTF8 flag */ +# undef sv_len_utf8 +# if defined(PERL_USE_GCC_BRACE_GROUPS) +# define sv_len_utf8_nomg(sv) \ + ({ \ + SV *sv2 = (sv); \ + STRLEN len; \ + if (SvUTF8(sv2)) { \ + if (SvGMAGICAL(sv2)) \ + len = Perl_sv_len_utf8(aTHX_ \ + sv_mortalcopy_flags(sv2, \ + SV_NOSTEAL));\ + else \ + len = Perl_sv_len_utf8(aTHX_ sv2); \ + } \ + else SvPV_nomg(sv2, len); \ + len; \ + }) +# define sv_len_utf8(sv) ({ SV *_sv1 = (sv); \ + SvGETMAGIC(_sv1); \ + sv_len_utf8_nomg(_sv1); \ + }) +# else /* Below is no brace groups */ + PERL_STATIC_INLINE STRLEN D_PPP_sv_len_utf8_nomg(SV * sv) + { + dTHX; + STRLEN len; + if (SvUTF8(sv)) { + if (SvGMAGICAL(sv)) + len = Perl_sv_len_utf8(aTHX_ + sv_mortalcopy_flags(sv, + SV_NOSTEAL)); + else + len = Perl_sv_len_utf8(aTHX_ sv); + } + else SvPV_nomg(sv, len); + return len; + } +# define sv_len_utf8_nomg(sv) D_PPP_sv_len_utf8_nomg(sv) + + PERL_STATIC_INLINE STRLEN D_PPP_sv_len_utf8(SV * sv) + { + dTHX; + SvGETMAGIC(sv); + return sv_len_utf8_nomg(sv); + } +# define sv_len_utf8(sv) D_PPP_sv_len_utf8(sv) +# endif +# endif /* End of < 5.17.5 */ +#endif +#ifndef PERL_PV_ESCAPE_QUOTE +# define PERL_PV_ESCAPE_QUOTE 0x0001 +#endif + +#ifndef PERL_PV_PRETTY_QUOTE +# define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_ELLIPSES +# define PERL_PV_PRETTY_ELLIPSES 0x0002 +#endif + +#ifndef PERL_PV_PRETTY_LTGT +# define PERL_PV_PRETTY_LTGT 0x0004 +#endif + +#ifndef PERL_PV_ESCAPE_FIRSTCHAR +# define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 +#endif + +#ifndef PERL_PV_ESCAPE_UNI +# define PERL_PV_ESCAPE_UNI 0x0100 +#endif + +#ifndef PERL_PV_ESCAPE_UNI_DETECT +# define PERL_PV_ESCAPE_UNI_DETECT 0x0200 +#endif + +#ifndef PERL_PV_ESCAPE_ALL +# define PERL_PV_ESCAPE_ALL 0x1000 +#endif + +#ifndef PERL_PV_ESCAPE_NOBACKSLASH +# define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 +#endif + +#ifndef PERL_PV_ESCAPE_NOCLEAR +# define PERL_PV_ESCAPE_NOCLEAR 0x4000 +#endif + +#ifndef PERL_PV_ESCAPE_RE +# define PERL_PV_ESCAPE_RE 0x8000 +#endif + +#ifndef PERL_PV_PRETTY_NOCLEAR +# define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR +#endif +#ifndef PERL_PV_PRETTY_DUMP +# define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE +#endif + +#ifndef PERL_PV_PRETTY_REGPROP +# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE +#endif + +/* Hint: pv_escape + * Note that unicode functionality is only backported to + * those perl versions that support it. For older perl + * versions, the implementation will fall back to bytes. + */ + +#ifndef pv_escape +#if defined(NEED_pv_escape) +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); +static +#else +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); +#endif + +#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL) + +#ifdef pv_escape +# undef pv_escape +#endif +#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f) +#define Perl_pv_escape DPPP_(my_pv_escape) + + +char * +DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str, + const STRLEN count, const STRLEN max, + STRLEN * const escaped, const U32 flags) +{ + const char esc = flags & PERL_PV_ESCAPE_RE ? '%' : '\\'; + const char dq = flags & PERL_PV_ESCAPE_QUOTE ? '"' : esc; + char octbuf[32] = "%123456789ABCDF"; + STRLEN wrote = 0; + STRLEN chsize = 0; + STRLEN readsize = 1; +#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf) + bool isuni = flags & PERL_PV_ESCAPE_UNI ? 1 : 0; +#endif + const char *pv = str; + const char * const end = pv + count; + octbuf[0] = esc; + + if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) + sv_setpvs(dsv, ""); + +#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf) + if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count)) + isuni = 1; +#endif + + for (; pv < end && (!max || wrote < max) ; pv += readsize) { + const UV u = +#if defined(is_utf8_string) && defined(utf8_to_uvchr_buf) + isuni ? utf8_to_uvchr_buf((U8*)pv, end, &readsize) : +#endif + (U8)*pv; + const U8 c = (U8)u & 0xFF; + + if (u > 255 || (flags & PERL_PV_ESCAPE_ALL)) { + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + chsize = my_snprintf(octbuf, sizeof octbuf, + "%" UVxf, u); + else + chsize = my_snprintf(octbuf, sizeof octbuf, + "%cx{%" UVxf "}", esc, u); + } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) { + chsize = 1; + } else { + if (c == dq || c == esc || !isPRINT(c)) { + chsize = 2; + switch (c) { + case '\\' : /* fallthrough */ + case '%' : if (c == esc) + octbuf[1] = esc; + else + chsize = 1; + break; + case '\v' : octbuf[1] = 'v'; break; + case '\t' : octbuf[1] = 't'; break; + case '\r' : octbuf[1] = 'r'; break; + case '\n' : octbuf[1] = 'n'; break; + case '\f' : octbuf[1] = 'f'; break; + case '"' : if (dq == '"') + octbuf[1] = '"'; + else + chsize = 1; + break; + default: chsize = my_snprintf(octbuf, sizeof octbuf, + pv < end && isDIGIT((U8)*(pv+readsize)) + ? "%c%03o" : "%c%o", esc, c); + } + } else { + chsize = 1; + } + } + if (max && wrote + chsize > max) { + break; + } else if (chsize > 1) { + sv_catpvn(dsv, octbuf, chsize); + wrote += chsize; + } else { + char tmp[2]; + my_snprintf(tmp, sizeof tmp, "%c", c); + sv_catpvn(dsv, tmp, 1); + wrote++; + } + if (flags & PERL_PV_ESCAPE_FIRSTCHAR) + break; + } + if (escaped != NULL) + *escaped= pv - str; + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_pretty +#if defined(NEED_pv_pretty) +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); +static +#else +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); +#endif + +#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL) + +#ifdef pv_pretty +# undef pv_pretty +#endif +#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g) +#define Perl_pv_pretty DPPP_(my_pv_pretty) + + +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) +{ + const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; + STRLEN escaped; + + if (!(flags & PERL_PV_PRETTY_NOCLEAR)) + sv_setpvs(dsv, ""); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, "<"); + + if (start_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(start_color)); + + pv_escape(dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR); + + if (end_color != NULL) + sv_catpv(dsv, D_PPP_CONSTPV_ARG(end_color)); + + if (dq == '"') + sv_catpvs(dsv, "\""); + else if (flags & PERL_PV_PRETTY_LTGT) + sv_catpvs(dsv, ">"); + + if ((flags & PERL_PV_PRETTY_ELLIPSES) && escaped < count) + sv_catpvs(dsv, "..."); + + return SvPVX(dsv); +} + +#endif +#endif + +#ifndef pv_display +#if defined(NEED_pv_display) +static char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +static +#else +extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim); +#endif + +#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL) + +#ifdef pv_display +# undef pv_display +#endif +#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e) +#define Perl_pv_display DPPP_(my_pv_display) + + +char * +DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) +{ + pv_pretty(dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP); + if (len > cur && pv[cur] == '\0') + sv_catpvs(dsv, "\\0"); + return SvPVX(dsv); +} + +#endif +#endif + +#if PERL_VERSION_LT(5,27,9) +#ifndef LC_NUMERIC_LOCK +# define LC_NUMERIC_LOCK +#endif + +#ifndef LC_NUMERIC_UNLOCK +# define LC_NUMERIC_UNLOCK +#endif + +# if PERL_VERSION_LT(5,19,0) +# undef STORE_LC_NUMERIC_SET_STANDARD +# undef RESTORE_LC_NUMERIC +# undef DECLARATION_FOR_LC_NUMERIC_MANIPULATION +# ifdef USE_LOCALE +#ifndef DECLARATION_FOR_LC_NUMERIC_MANIPULATION +# define DECLARATION_FOR_LC_NUMERIC_MANIPULATION char *LoC_ +#endif + +#ifndef STORE_NUMERIC_SET_STANDARD +# define STORE_NUMERIC_SET_STANDARD() \ + LoC_ = savepv(setlocale(LC_NUMERIC, NULL)); \ + SAVEFREEPV(LoC_); \ + setlocale(LC_NUMERIC, "C"); +#endif + +#ifndef RESTORE_LC_NUMERIC +# define RESTORE_LC_NUMERIC() \ + setlocale(LC_NUMERIC, LoC_); +#endif + +# else +#ifndef DECLARATION_FOR_LC_NUMERIC_MANIPULATION +# define DECLARATION_FOR_LC_NUMERIC_MANIPULATION +#endif + +#ifndef STORE_LC_NUMERIC_SET_STANDARD +# define STORE_LC_NUMERIC_SET_STANDARD() +#endif + +#ifndef RESTORE_LC_NUMERIC +# define RESTORE_LC_NUMERIC() +#endif + +# endif +# endif +#endif + +#ifndef LOCK_NUMERIC_STANDARD +# define LOCK_NUMERIC_STANDARD() +#endif + +#ifndef UNLOCK_NUMERIC_STANDARD +# define UNLOCK_NUMERIC_STANDARD() +#endif + +/* The names of these changed in 5.28 */ +#ifndef LOCK_LC_NUMERIC_STANDARD +# define LOCK_LC_NUMERIC_STANDARD LOCK_NUMERIC_STANDARD +#endif + +#ifndef UNLOCK_LC_NUMERIC_STANDARD +# define UNLOCK_LC_NUMERIC_STANDARD UNLOCK_NUMERIC_STANDARD +#endif + +/* If this doesn't exist, it's not needed, so is void noop */ +#ifndef switch_to_global_locale +# define switch_to_global_locale() +#endif + +/* Originally, this didn't return a value, but in perls like that, the value + * should always be TRUE. Add a return to Perl_sync_locale() when it's + * available. And actually do a sync when its not, if locales are available on + * this system. */ +#ifdef sync_locale +# if (PERL_BCDVERSION < 0x5027009) +# if (PERL_BCDVERSION >= 0x5021003) +# undef sync_locale +# define sync_locale() (Perl_sync_locale(aTHX), 1) +# elif defined(sync_locale) /* These should only be the 5.20 maints*/ +# undef sync_locale /* Just copy their defn and return 1 */ +# define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)), \ + new_collate(setlocale(LC_COLLATE, NULL)), \ + set_numeric_local(), \ + new_numeric(setlocale(LC_NUMERIC, NULL)), \ + 1) +# elif defined(new_ctype) && defined(LC_CTYPE) +# define sync_locale() (new_ctype(setlocale(LC_CTYPE, NULL)), 1) +# endif +# endif +#endif +#ifndef sync_locale +# define sync_locale() 1 +#endif + +#endif /* _P_P_PORTABILITY_H_ */ + +/* End of File ppport.h */ diff --git a/t/00-compile.t b/t/00-compile.t new file mode 100644 index 0000000..df3375d --- /dev/null +++ b/t/00-compile.t @@ -0,0 +1,60 @@ +use 5.006; +use strict; +use warnings; + +# this test was generated with Dist::Zilla::Plugin::Test::Compile 2.058 + +use Test::More; + +plan tests => 1 + ($ENV{AUTHOR_TESTING} ? 1 : 0); + +my @module_files = ( + 'File/KDBX/XS.pm' +); + + + +# no fake home requested + +my @switches = ( + -d 'blib' ? '-Mblib' : '-Ilib', +); + +use File::Spec; +use IPC::Open3; +use IO::Handle; + +open my $stdin, '<', File::Spec->devnull or die "can't open devnull: $!"; + +my @warnings; +for my $lib (@module_files) +{ + # see L + my $stderr = IO::Handle->new; + + diag('Running: ', join(', ', map { my $str = $_; $str =~ s/'/\\'/g; q{'} . $str . q{'} } + $^X, @switches, '-e', "require q[$lib]")) + if $ENV{PERL_COMPILE_TEST_DEBUG}; + + my $pid = open3($stdin, '>&STDERR', $stderr, $^X, @switches, '-e', "require q[$lib]"); + binmode $stderr, ':crlf' if $^O eq 'MSWin32'; + my @_warnings = <$stderr>; + waitpid($pid, 0); + is($?, 0, "$lib loaded ok"); + + shift @_warnings if @_warnings and $_warnings[0] =~ /^Using .*\bblib/ + and not eval { +require blib; blib->VERSION('1.01') }; + + if (@_warnings) + { + warn @_warnings; + push @warnings, @_warnings; + } +} + + + +is(scalar(@warnings), 0, 'no warnings found') + or diag 'got warnings: ', ( Test::More->can('explain') ? Test::More::explain(\@warnings) : join("\n", '', @warnings) ) if $ENV{AUTHOR_TESTING}; + + diff --git a/t/00-report-prereqs.dd b/t/00-report-prereqs.dd new file mode 100644 index 0000000..4a7e7f6 --- /dev/null +++ b/t/00-report-prereqs.dd @@ -0,0 +1,51 @@ +do { my $x = { + 'configure' => { + 'requires' => { + 'ExtUtils::MakeMaker' => '0' + } + }, + 'develop' => { + 'requires' => { + 'Dist::Zilla' => '5', + 'Dist::Zilla::Plugin::MakeMaker::Custom' => '0', + 'Dist::Zilla::Plugin::Meta::Contributors' => '0', + 'Dist::Zilla::PluginBundle::Author::CCM' => '0.012', + 'Pod::Coverage::TrustPod' => '0', + 'Software::License::Perl_5' => '0', + 'Test::CPAN::Changes' => '0.19', + 'Test::CPAN::Meta' => '0', + 'Test::CleanNamespaces' => '0.15', + 'Test::EOL' => '0', + 'Test::MinimumVersion' => '0', + 'Test::More' => '0.96', + 'Test::NoTabs' => '0', + 'Test::Perl::Critic' => '0', + 'Test::Pod' => '1.41', + 'Test::Pod::Coverage' => '1.08', + 'Test::Pod::No404s' => '0', + 'Test::Portability::Files' => '0' + } + }, + 'runtime' => { + 'requires' => { + 'XSLoader' => '0', + 'strict' => '0', + 'warnings' => '0' + } + }, + 'test' => { + 'recommends' => { + 'CPAN::Meta' => '2.120900' + }, + 'requires' => { + 'ExtUtils::MakeMaker' => '0', + 'File::Spec' => '0', + 'IO::Handle' => '0', + 'IPC::Open3' => '0', + 'Test::More' => '0', + 'perl' => '5.006' + } + } + }; + $x; + } \ No newline at end of file diff --git a/t/00-report-prereqs.t b/t/00-report-prereqs.t new file mode 100644 index 0000000..c3a94ca --- /dev/null +++ b/t/00-report-prereqs.t @@ -0,0 +1,193 @@ +#!perl + +use strict; +use warnings; + +# This test was generated by Dist::Zilla::Plugin::Test::ReportPrereqs 0.028 + +use Test::More tests => 1; + +use ExtUtils::MakeMaker; +use File::Spec; + +# from $version::LAX +my $lax_version_re = + qr/(?: undef | (?: (?:[0-9]+) (?: \. | (?:\.[0-9]+) (?:_[0-9]+)? )? + | + (?:\.[0-9]+) (?:_[0-9]+)? + ) | (?: + v (?:[0-9]+) (?: (?:\.[0-9]+)+ (?:_[0-9]+)? )? + | + (?:[0-9]+)? (?:\.[0-9]+){2,} (?:_[0-9]+)? + ) + )/x; + +# hide optional CPAN::Meta modules from prereq scanner +# and check if they are available +my $cpan_meta = "CPAN::Meta"; +my $cpan_meta_pre = "CPAN::Meta::Prereqs"; +my $HAS_CPAN_META = eval "require $cpan_meta; $cpan_meta->VERSION('2.120900')" && eval "require $cpan_meta_pre"; ## no critic + +# Verify requirements? +my $DO_VERIFY_PREREQS = 1; + +sub _max { + my $max = shift; + $max = ( $_ > $max ) ? $_ : $max for @_; + return $max; +} + +sub _merge_prereqs { + my ($collector, $prereqs) = @_; + + # CPAN::Meta::Prereqs object + if (ref $collector eq $cpan_meta_pre) { + return $collector->with_merged_prereqs( + CPAN::Meta::Prereqs->new( $prereqs ) + ); + } + + # Raw hashrefs + for my $phase ( keys %$prereqs ) { + for my $type ( keys %{ $prereqs->{$phase} } ) { + for my $module ( keys %{ $prereqs->{$phase}{$type} } ) { + $collector->{$phase}{$type}{$module} = $prereqs->{$phase}{$type}{$module}; + } + } + } + + return $collector; +} + +my @include = qw( + +); + +my @exclude = qw( + +); + +# Add static prereqs to the included modules list +my $static_prereqs = do './t/00-report-prereqs.dd'; + +# Merge all prereqs (either with ::Prereqs or a hashref) +my $full_prereqs = _merge_prereqs( + ( $HAS_CPAN_META ? $cpan_meta_pre->new : {} ), + $static_prereqs +); + +# Add dynamic prereqs to the included modules list (if we can) +my ($source) = grep { -f } 'MYMETA.json', 'MYMETA.yml'; +my $cpan_meta_error; +if ( $source && $HAS_CPAN_META + && (my $meta = eval { CPAN::Meta->load_file($source) } ) +) { + $full_prereqs = _merge_prereqs($full_prereqs, $meta->prereqs); +} +else { + $cpan_meta_error = $@; # capture error from CPAN::Meta->load_file($source) + $source = 'static metadata'; +} + +my @full_reports; +my @dep_errors; +my $req_hash = $HAS_CPAN_META ? $full_prereqs->as_string_hash : $full_prereqs; + +# Add static includes into a fake section +for my $mod (@include) { + $req_hash->{other}{modules}{$mod} = 0; +} + +for my $phase ( qw(configure build test runtime develop other) ) { + next unless $req_hash->{$phase}; + next if ($phase eq 'develop' and not $ENV{AUTHOR_TESTING}); + + for my $type ( qw(requires recommends suggests conflicts modules) ) { + next unless $req_hash->{$phase}{$type}; + + my $title = ucfirst($phase).' '.ucfirst($type); + my @reports = [qw/Module Want Have/]; + + for my $mod ( sort keys %{ $req_hash->{$phase}{$type} } ) { + next if $mod eq 'perl'; + next if grep { $_ eq $mod } @exclude; + + my $file = $mod; + $file =~ s{::}{/}g; + $file .= ".pm"; + my ($prefix) = grep { -e File::Spec->catfile($_, $file) } @INC; + + my $want = $req_hash->{$phase}{$type}{$mod}; + $want = "undef" unless defined $want; + $want = "any" if !$want && $want == 0; + + my $req_string = $want eq 'any' ? 'any version required' : "version '$want' required"; + + if ($prefix) { + my $have = MM->parse_version( File::Spec->catfile($prefix, $file) ); + $have = "undef" unless defined $have; + push @reports, [$mod, $want, $have]; + + if ( $DO_VERIFY_PREREQS && $HAS_CPAN_META && $type eq 'requires' ) { + if ( $have !~ /\A$lax_version_re\z/ ) { + push @dep_errors, "$mod version '$have' cannot be parsed ($req_string)"; + } + elsif ( ! $full_prereqs->requirements_for( $phase, $type )->accepts_module( $mod => $have ) ) { + push @dep_errors, "$mod version '$have' is not in required range '$want'"; + } + } + } + else { + push @reports, [$mod, $want, "missing"]; + + if ( $DO_VERIFY_PREREQS && $type eq 'requires' ) { + push @dep_errors, "$mod is not installed ($req_string)"; + } + } + } + + if ( @reports ) { + push @full_reports, "=== $title ===\n\n"; + + my $ml = _max( map { length $_->[0] } @reports ); + my $wl = _max( map { length $_->[1] } @reports ); + my $hl = _max( map { length $_->[2] } @reports ); + + if ($type eq 'modules') { + splice @reports, 1, 0, ["-" x $ml, "", "-" x $hl]; + push @full_reports, map { sprintf(" %*s %*s\n", -$ml, $_->[0], $hl, $_->[2]) } @reports; + } + else { + splice @reports, 1, 0, ["-" x $ml, "-" x $wl, "-" x $hl]; + push @full_reports, map { sprintf(" %*s %*s %*s\n", -$ml, $_->[0], $wl, $_->[1], $hl, $_->[2]) } @reports; + } + + push @full_reports, "\n"; + } + } +} + +if ( @full_reports ) { + diag "\nVersions for all modules listed in $source (including optional ones):\n\n", @full_reports; +} + +if ( $cpan_meta_error || @dep_errors ) { + diag "\n*** WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING ***\n"; +} + +if ( $cpan_meta_error ) { + my ($orig_source) = grep { -f } 'MYMETA.json', 'MYMETA.yml'; + diag "\nCPAN::Meta->load_file('$orig_source') failed with: $cpan_meta_error\n"; +} + +if ( @dep_errors ) { + diag join("\n", + "\nThe following REQUIRED prerequisites were not satisfied:\n", + @dep_errors, + "\n" + ); +} + +pass('Reported prereqs'); + +# vim: ts=4 sts=4 sw=4 et: diff --git a/t/kdf-aes.t b/t/kdf-aes.t new file mode 100644 index 0000000..3256899 --- /dev/null +++ b/t/kdf-aes.t @@ -0,0 +1,17 @@ +#!/usr/bin/env perl + +use warnings; +use strict; + +use File::KDBX::XS; +use Test::More; + +my $key = "\1" x 32; +my $seed = "\1" x 16; +my $rounds = 123; +my $expected = pack('H*', '7deb990760f2ff0f9b8248d63bfb7264'); + +my $result = File::KDBX::XS::kdf_aes_transform_half($key, $seed, $rounds); +is $result, $expected, 'AES KDF transform works' or diag unpack('H*', $result); + +done_testing; diff --git a/xt/author/clean-namespaces.t b/xt/author/clean-namespaces.t new file mode 100644 index 0000000..36387da --- /dev/null +++ b/xt/author/clean-namespaces.t @@ -0,0 +1,11 @@ +use strict; +use warnings; + +# this test was generated with Dist::Zilla::Plugin::Test::CleanNamespaces 0.006 + +use Test::More 0.94; +use Test::CleanNamespaces 0.15; + +subtest all_namespaces_clean => sub { all_namespaces_clean() }; + +done_testing; diff --git a/xt/author/critic.t b/xt/author/critic.t new file mode 100644 index 0000000..80ccdad --- /dev/null +++ b/xt/author/critic.t @@ -0,0 +1,7 @@ +#!perl + +use strict; +use warnings; + +use Test::Perl::Critic (-profile => "perlcritic.rc") x!! -e "perlcritic.rc"; +all_critic_ok(); diff --git a/xt/author/distmeta.t b/xt/author/distmeta.t new file mode 100644 index 0000000..c2280dc --- /dev/null +++ b/xt/author/distmeta.t @@ -0,0 +1,6 @@ +#!perl +# This file was automatically generated by Dist::Zilla::Plugin::MetaTests. + +use Test::CPAN::Meta; + +meta_yaml_ok(); diff --git a/xt/author/eol.t b/xt/author/eol.t new file mode 100644 index 0000000..fcb3e9e --- /dev/null +++ b/xt/author/eol.t @@ -0,0 +1,29 @@ +use strict; +use warnings; + +# this test was generated with Dist::Zilla::Plugin::Test::EOL 0.19 + +use Test::More 0.88; +use Test::EOL; + +my @files = ( + 'lib/File/KDBX/XS.pm', + 't/00-compile.t', + 't/00-report-prereqs.dd', + 't/00-report-prereqs.t', + 't/kdf-aes.t', + 'xt/author/clean-namespaces.t', + 'xt/author/critic.t', + 'xt/author/distmeta.t', + 'xt/author/eol.t', + 'xt/author/minimum-version.t', + 'xt/author/no-tabs.t', + 'xt/author/pod-coverage.t', + 'xt/author/pod-no404s.t', + 'xt/author/pod-syntax.t', + 'xt/author/portability.t', + 'xt/release/cpan-changes.t' +); + +eol_unix_ok($_, { trailing_whitespace => 1 }) foreach @files; +done_testing; diff --git a/xt/author/minimum-version.t b/xt/author/minimum-version.t new file mode 100644 index 0000000..277e084 --- /dev/null +++ b/xt/author/minimum-version.t @@ -0,0 +1,6 @@ +use strict; +use warnings; + +use Test::More; +use Test::MinimumVersion; +all_minimum_version_ok( qq{5.10.1} ); diff --git a/xt/author/no-tabs.t b/xt/author/no-tabs.t new file mode 100644 index 0000000..41425ec --- /dev/null +++ b/xt/author/no-tabs.t @@ -0,0 +1,29 @@ +use strict; +use warnings; + +# this test was generated with Dist::Zilla::Plugin::Test::NoTabs 0.15 + +use Test::More 0.88; +use Test::NoTabs; + +my @files = ( + 'lib/File/KDBX/XS.pm', + 't/00-compile.t', + 't/00-report-prereqs.dd', + 't/00-report-prereqs.t', + 't/kdf-aes.t', + 'xt/author/clean-namespaces.t', + 'xt/author/critic.t', + 'xt/author/distmeta.t', + 'xt/author/eol.t', + 'xt/author/minimum-version.t', + 'xt/author/no-tabs.t', + 'xt/author/pod-coverage.t', + 'xt/author/pod-no404s.t', + 'xt/author/pod-syntax.t', + 'xt/author/portability.t', + 'xt/release/cpan-changes.t' +); + +notabs_ok($_) foreach @files; +done_testing; diff --git a/xt/author/pod-coverage.t b/xt/author/pod-coverage.t new file mode 100644 index 0000000..66b3b64 --- /dev/null +++ b/xt/author/pod-coverage.t @@ -0,0 +1,7 @@ +#!perl +# This file was automatically generated by Dist::Zilla::Plugin::PodCoverageTests. + +use Test::Pod::Coverage 1.08; +use Pod::Coverage::TrustPod; + +all_pod_coverage_ok({ coverage_class => 'Pod::Coverage::TrustPod' }); diff --git a/xt/author/pod-no404s.t b/xt/author/pod-no404s.t new file mode 100644 index 0000000..eb9760c --- /dev/null +++ b/xt/author/pod-no404s.t @@ -0,0 +1,21 @@ +#!perl + +use strict; +use warnings; +use Test::More; + +foreach my $env_skip ( qw( + SKIP_POD_NO404S + AUTOMATED_TESTING +) ){ + plan skip_all => "\$ENV{$env_skip} is set, skipping" + if $ENV{$env_skip}; +} + +eval "use Test::Pod::No404s"; +if ( $@ ) { + plan skip_all => 'Test::Pod::No404s required for testing POD'; +} +else { + all_pod_files_ok(); +} diff --git a/xt/author/pod-syntax.t b/xt/author/pod-syntax.t new file mode 100644 index 0000000..e563e5d --- /dev/null +++ b/xt/author/pod-syntax.t @@ -0,0 +1,7 @@ +#!perl +# This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests. +use strict; use warnings; +use Test::More; +use Test::Pod 1.41; + +all_pod_files_ok(); diff --git a/xt/author/portability.t b/xt/author/portability.t new file mode 100644 index 0000000..c531252 --- /dev/null +++ b/xt/author/portability.t @@ -0,0 +1,10 @@ +use strict; +use warnings; + +use Test::More; + +eval 'use Test::Portability::Files'; +plan skip_all => 'Test::Portability::Files required for testing portability' + if $@; + +run_tests(); diff --git a/xt/release/cpan-changes.t b/xt/release/cpan-changes.t new file mode 100644 index 0000000..286005a --- /dev/null +++ b/xt/release/cpan-changes.t @@ -0,0 +1,10 @@ +use strict; +use warnings; + +# this test was generated with Dist::Zilla::Plugin::Test::CPAN::Changes 0.012 + +use Test::More 0.96 tests => 1; +use Test::CPAN::Changes; +subtest 'changes_ok' => sub { + changes_file_ok('Changes'); +};