GSP/GSP-Agent-Windows
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Windows agent repository

Browse source
This commit is contained in:
Frank Harris 2026-06-08 10:45:20 -05:00
commit a0db0c2e5b
10589 changed files with 3844063 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1432
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/B.pm Normal file
View file

File diff suppressed because it is too large Load diff

1929
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/B/Concise.pm Normal file
View file

File diff suppressed because it is too large Load diff

217
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/B/Showlex.pm Normal file
View file

@ -0,0 +1,217 @@
package B::Showlex;
our $VERSION = '1.05';
use strict;
use B qw(svref_2object comppadlist class);
use B::Terse ();
use B::Concise ();
#
# Invoke as
# perl -MO=Showlex,foo bar.pl
# to see the names of lexical variables used by &foo
# or as
# perl -MO=Showlex bar.pl
# to see the names of file scope lexicals used by bar.pl
#
# borrowed from B::Concise
our $walkHandle = \*STDOUT;
sub walk_output { # updates $walkHandle
$walkHandle = B::Concise::walk_output(@_);
#print "got $walkHandle";
#print $walkHandle "using it";
$walkHandle;
}
sub shownamearray {
my ($name, $av) = @_;
my @els = $av->ARRAY;
my $count = @els;
my $i;
print $walkHandle "$name has $count entries\n";
for ($i = 0; $i < $count; $i++) {
my $sv = $els[$i];
if (class($sv) ne "SPECIAL") {
printf $walkHandle "$i: (0x%lx) %s\n",
$$sv, $sv->PVX // "undef" || "const";
} else {
printf $walkHandle "$i: %s\n", $sv->terse;
#printf $walkHandle "$i: %s\n", B::Concise::concise_sv($sv);
}
}
}
sub showvaluearray {
my ($name, $av) = @_;
my @els = $av->ARRAY;
my $count = @els;
my $i;
print $walkHandle "$name has $count entries\n";
for ($i = 0; $i < $count; $i++) {
printf $walkHandle "$i: %s\n", $els[$i]->terse;
#print $walkHandle "$i: %s\n", B::Concise::concise_sv($els[$i]);
}
}
sub showlex {
my ($objname, $namesav, $valsav) = @_;
shownamearray("Pad of lexical names for $objname", $namesav);
showvaluearray("Pad of lexical values for $objname", $valsav);
}
my ($newlex, $nosp1); # rendering state vars
sub padname_terse {
my $name = shift;
return $name->terse if class($name) eq 'SPECIAL';
my $str = $name->PVX;
return sprintf "(0x%lx) %s",
$$name,
length $str ? qq'"$str"' : defined $str ? "const" : 'undef';
}
sub newlex { # drop-in for showlex
my ($objname, $names, $vals) = @_;
my @names = $names->ARRAY;
my @vals = $vals->ARRAY;
my $count = @names;
print $walkHandle "$objname Pad has $count entries\n";
printf $walkHandle "0: %s\n", padname_terse($names[0]) unless $nosp1;
for (my $i = 1; $i < $count; $i++) {
printf $walkHandle "$i: %s = %s\n", padname_terse($names[$i]),
$vals[$i]->terse,
unless $nosp1
and class($names[$i]) eq 'SPECIAL' || !$names[$i]->LEN;
}
}
sub showlex_obj {
my ($objname, $obj) = @_;
$objname =~ s/^&main::/&/;
showlex($objname, svref_2object($obj)->PADLIST->ARRAY) if !$newlex;
newlex ($objname, svref_2object($obj)->PADLIST->ARRAY) if $newlex;
}
sub showlex_main {
showlex("comppadlist", comppadlist->ARRAY) if !$newlex;
newlex ("main", comppadlist->ARRAY) if $newlex;
}
sub compile {
my @options = grep(/^-/, @_);
my @args = grep(!/^-/, @_);
for my $o (@options) {
$newlex = 1 if $o eq "-newlex";
$nosp1 = 1 if $o eq "-nosp";
}
return \&showlex_main unless @args;
return sub {
my $objref;
foreach my $objname (@args) {
next unless $objname; # skip nulls w/o carping
if (ref $objname) {
print $walkHandle "B::Showlex::compile($objname)\n";
$objref = $objname;
} else {
$objname = "main::$objname" unless $objname =~ /::/;
print $walkHandle "$objname:\n";
no strict 'refs';
die "err: unknown function ($objname)\n"
unless *{$objname}{CODE};
$objref = \&$objname;
}
showlex_obj($objname, $objref);
}
}
}
1;
__END__
=head1 NAME
B::Showlex - Show lexical variables used in functions or files
=head1 SYNOPSIS
perl -MO=Showlex[,-OPTIONS][,SUBROUTINE] foo.pl
=head1 DESCRIPTION
When a comma-separated list of subroutine names is given as options, Showlex
prints the lexical variables used in those subroutines. Otherwise, it prints
the file-scope lexicals in the file.
=head1 EXAMPLES
Traditional form:
$ perl -MO=Showlex -e 'my ($i,$j,$k)=(1,"foo")'
Pad of lexical names for comppadlist has 4 entries
0: (0x8caea4) undef
1: (0x9db0fb0) $i
2: (0x9db0f38) $j
3: (0x9db0f50) $k
Pad of lexical values for comppadlist has 5 entries
0: SPECIAL #1 &PL_sv_undef
1: NULL (0x9da4234)
2: NULL (0x9db0f2c)
3: NULL (0x9db0f44)
4: NULL (0x9da4264)
-e syntax OK
New-style form:
$ perl -MO=Showlex,-newlex -e 'my ($i,$j,$k)=(1,"foo")'
main Pad has 4 entries
0: (0x8caea4) undef
1: (0xa0c4fb8) "$i" = NULL (0xa0b8234)
2: (0xa0c4f40) "$j" = NULL (0xa0c4f34)
3: (0xa0c4f58) "$k" = NULL (0xa0c4f4c)
-e syntax OK
New form, no specials, outside O framework:
$ perl -MB::Showlex -e \
'my ($i,$j,$k)=(1,"foo"); B::Showlex::compile(-newlex,-nosp)->()'
main Pad has 4 entries
1: (0x998ffb0) "$i" = IV (0x9983234) 1
2: (0x998ff68) "$j" = PV (0x998ff5c) "foo"
3: (0x998ff80) "$k" = NULL (0x998ff74)
Note that this example shows the values of the lexicals, whereas the other
examples did not (as they're compile-time only).
=head2 OPTIONS
The C<-newlex> option produces a more readable C<< name => value >> format,
and is shown in the second example above.
The C<-nosp> option eliminates reporting of SPECIALs, such as C<0: SPECIAL
#1 &PL_sv_undef> above. Reporting of SPECIALs can sometimes overwhelm
your declared lexicals.
=head1 SEE ALSO
L<B::Showlex> can also be used outside of the O framework, as in the third
example. See L<B::Concise> for a fuller explanation of reasons.
=head1 TODO
Some of the reported info, such as hex addresses, is not particularly
valuable. Other information would be more useful for the typical
programmer, such as line-numbers, pad-slot reuses, etc.. Given this,
-newlex is not a particularly good flag-name.
=head1 AUTHOR
Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>
=cut

104
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/B/Terse.pm Normal file
View file

@ -0,0 +1,104 @@
package B::Terse;
our $VERSION = '1.09';
use strict;
use B qw(class @specialsv_name);
use B::Concise qw(concise_subref set_style_standard);
use Carp;
sub terse {
my ($order, $subref) = @_;
set_style_standard("terse");
if ($order eq "exec") {
concise_subref('exec', $subref);
} else {
concise_subref('basic', $subref);
}
}
sub compile {
my @args = @_;
my $order = @args ? shift(@args) : "";
$order = "-exec" if $order eq "exec";
unshift @args, $order if $order ne "";
B::Concise::compile("-terse", @args);
}
sub indent {
my ($level) = @_ ? shift : 0;
return " " x $level;
}
sub B::SV::terse {
my($sv, $level) = (@_, 0);
my %info;
B::Concise::concise_sv($sv, \%info);
my $s = indent($level)
. B::Concise::fmt_line(\%info, $sv,
"#svclass~(?((#svaddr))?)~#svval", 0);
chomp $s;
print "$s\n" unless defined wantarray;
$s;
}
sub B::NULL::terse {
my ($sv, $level) = (@_, 0);
my $s = indent($level) . sprintf "%s (0x%lx)", class($sv), $$sv;
print "$s\n" unless defined wantarray;
$s;
}
sub B::SPECIAL::terse {
my ($sv, $level) = (@_, 0);
my $s = indent($level)
. sprintf( "%s #%d %s", class($sv), $$sv, $specialsv_name[$$sv]);
print "$s\n" unless defined wantarray;
$s;
}
1;
__END__
=head1 NAME
B::Terse - Walk Perl syntax tree, printing terse info about ops
=head1 SYNOPSIS
perl -MO=Terse[,OPTIONS] foo.pl
=head1 DESCRIPTION
This module prints the contents of the parse tree, but without as much
information as CPAN module B::Debug. For comparison, C<print "Hello, world.">
produced 96 lines of output from B::Debug, but only 6 from B::Terse.
This module is useful for people who are writing their own back end,
or who are learning about the Perl internals. It's not useful to the
average programmer.
This version of B::Terse is really just a wrapper that calls L<B::Concise>
with the B<-terse> option. It is provided for compatibility with old scripts
(and habits) but using B::Concise directly is now recommended instead.
For compatibility with the old B::Terse, this module also adds a
method named C<terse> to B::OP and B::SV objects. The B::SV method is
largely compatible with the old one, though authors of new software
might be advised to choose a more user-friendly output format. The
B::OP C<terse> method, however, doesn't work well. Since B::Terse was
first written, much more information in OPs has migrated to the
scratchpad datastructure, but the C<terse> interface doesn't have any
way of getting to the correct pad. As a kludge, the new version will
always use the pad for the main program, but for OPs in subroutines
this will give the wrong answer or crash.
=head1 AUTHOR
The original version of B::Terse was written by Malcolm Beattie,
E<lt>mbeattie@sable.ox.ac.ukE<gt>. This wrapper was written by Stephen
McCamant, E<lt>smcc@MIT.EDUE<gt>.
=cut

496
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/B/Xref.pm Normal file
View file

@ -0,0 +1,496 @@
package B::Xref;
our $VERSION = '1.07';
=head1 NAME
B::Xref - Generates cross reference reports for Perl programs
=head1 SYNOPSIS
perl -MO=Xref[,OPTIONS] foo.pl
=head1 DESCRIPTION
The B::Xref module is used to generate a cross reference listing of all
definitions and uses of variables, subroutines and formats in a Perl program.
It is implemented as a backend for the Perl compiler.
The report generated is in the following format:
File filename1
Subroutine subname1
Package package1
object1 line numbers
object2 line numbers
...
Package package2
...
Each B<File> section reports on a single file. Each B<Subroutine> section
reports on a single subroutine apart from the special cases
"(definitions)" and "(main)". These report, respectively, on subroutine
definitions found by the initial symbol table walk and on the main part of
the program or module external to all subroutines.
The report is then grouped by the B<Package> of each variable,
subroutine or format with the special case "(lexicals)" meaning
lexical variables. Each B<object> name (implicitly qualified by its
containing B<Package>) includes its type character(s) at the beginning
where possible. Lexical variables are easier to track and even
included dereferencing information where possible.
The C<line numbers> are a comma separated list of line numbers (some
preceded by code letters) where that object is used in some way.
Simple uses aren't preceded by a code letter. Introductions (such as
where a lexical is first defined with C<my>) are indicated with the
letter "i". Subroutine and method calls are indicated by the character
"&". Subroutine definitions are indicated by "s" and format
definitions by "f".
For instance, here's part of the report from the I<pod2man> program that
comes with Perl:
Subroutine clear_noremap
Package (lexical)
$ready_to_print i1069, 1079
Package main
$& 1086
$. 1086
$0 1086
$1 1087
$2 1085, 1085
$3 1085, 1085
$ARGV 1086
%HTML_Escapes 1085, 1085
This shows the variables used in the subroutine C<clear_noremap>. The
variable C<$ready_to_print> is a my() (lexical) variable,
B<i>ntroduced (first declared with my()) on line 1069, and used on
line 1079. The variable C<$&> from the main package is used on 1086,
and so on.
A line number may be prefixed by a single letter:
=over 4
=item i
Lexical variable introduced (declared with my()) for the first time.
=item &
Subroutine or method call.
=item s
Subroutine defined.
=item r
Format defined.
=back
The most useful option the cross referencer has is to save the report
to a separate file. For instance, to save the report on
I<myperlprogram> to the file I<report>:
$ perl -MO=Xref,-oreport myperlprogram
=head1 OPTIONS
Option words are separated by commas (not whitespace) and follow the
usual conventions of compiler backend options.
=over 8
=item C<-oFILENAME>
Directs output to C<FILENAME> instead of standard output.
=item C<-r>
Raw output. Instead of producing a human-readable report, outputs a line
in machine-readable form for each definition/use of a variable/sub/format.
=item C<-d>
Don't output the "(definitions)" sections.
=item C<-D[tO]>
(Internal) debug options, probably only useful if C<-r> included.
The C<t> option prints the object on the top of the stack as it's
being tracked. The C<O> option prints each operator as it's being
processed in the execution order of the program.
=back
=head1 BUGS
Non-lexical variables are quite difficult to track through a program.
Sometimes the type of a non-lexical variable's use is impossible to
determine. Introductions of non-lexical non-scalars don't seem to be
reported properly.
=head1 AUTHOR
Malcolm Beattie, mbeattie@sable.ox.ac.uk.
=cut
use strict;
use Config;
use B qw(peekop class comppadlist main_start svref_2object walksymtable
OPpLVAL_INTRO SVf_POK SVf_ROK OPpOUR_INTRO cstring
);
sub UNKNOWN { ["?", "?", "?"] }
my @pad; # lexicals in current pad
# as ["(lexical)", type, name]
my %done; # keyed by $$op: set when each $op is done
my $top = UNKNOWN; # shadows top element of stack as
# [pack, type, name] (pack can be "(lexical)")
my $file; # shadows current filename
my $line; # shadows current line number
my $subname; # shadows current sub name
my %table; # Multi-level hash to record all uses etc.
my @todo = (); # List of CVs that need processing
my %code = (intro => "i", used => "",
subdef => "s", subused => "&",
formdef => "f", meth => "->");
# Options
my ($debug_op, $debug_top, $nodefs, $raw);
sub process {
my ($var, $event) = @_;
my ($pack, $type, $name) = @$var;
if ($type eq "*") {
if ($event eq "used") {
return;
} elsif ($event eq "subused") {
$type = "&";
}
}
$type =~ s/(.)\*$/$1/g;
if ($raw) {
printf "%-16s %-12s %5d %-12s %4s %-16s %s\n",
$file, $subname, $line, $pack, $type, $name, $event;
} else {
# Wheee
push(@{$table{$file}->{$subname}->{$pack}->{$type.$name}->{$event}},
$line);
}
}
sub load_pad {
my $padlist = shift;
my ($namelistav, $vallistav, @namelist, $ix);
@pad = ();
return if class($padlist) =~ '^(?:SPECIAL|NULL)\z';
($namelistav,$vallistav) = $padlist->ARRAY;
@namelist = $namelistav->ARRAY;
for ($ix = 1; $ix < @namelist; $ix++) {
my $namesv = $namelist[$ix];
next if class($namesv) eq "SPECIAL";
my ($type, $name) = $namesv->PV =~ /^(.)([^\0]*)(\0.*)?$/;
$pad[$ix] = ["(lexical)", $type || '?', $name || '?'];
}
if ($Config{useithreads}) {
my (@vallist);
@vallist = $vallistav->ARRAY;
for ($ix = 1; $ix < @vallist; $ix++) {
my $valsv = $vallist[$ix];
next unless class($valsv) eq "GV";
next if class($valsv->STASH) eq 'SPECIAL';
# these pad GVs don't have corresponding names, so same @pad
# array can be used without collisions
$pad[$ix] = [$valsv->STASH->NAME, "*", $valsv->NAME];
}
}
}
sub xref {
my $start = shift;
my $op;
for ($op = $start; $$op; $op = $op->next) {
last if $done{$$op}++;
warn sprintf("top = [%s, %s, %s]\n", @$top) if $debug_top;
warn peekop($op), "\n" if $debug_op;
my $opname = $op->name;
if ($opname =~ /^(or|and|mapwhile|grepwhile|range|cond_expr)$/) {
xref($op->other);
} elsif ($opname eq "match" || $opname eq "subst") {
xref($op->pmreplstart);
} elsif ($opname eq "substcont") {
xref($op->other->pmreplstart);
$op = $op->other;
redo;
} elsif ($opname eq "enterloop") {
xref($op->redoop);
xref($op->nextop);
xref($op->lastop);
} elsif ($opname eq "subst") {
xref($op->pmreplstart);
} else {
no strict 'refs';
my $ppname = "pp_$opname";
&$ppname($op) if defined(&$ppname);
}
}
}
sub xref_cv {
my $cv = shift;
my $pack = $cv->GV->STASH->NAME;
$subname = ($pack eq "main" ? "" : "$pack\::") . $cv->GV->NAME;
load_pad($cv->PADLIST);
xref($cv->START);
$subname = "(main)";
}
sub xref_object {
my $cvref = shift;
xref_cv(svref_2object($cvref));
}
sub xref_main {
$subname = "(main)";
load_pad(comppadlist);
xref(main_start);
while (@todo) {
xref_cv(shift @todo);
}
}
sub pp_nextstate {
my $op = shift;
$file = $op->file;
$line = $op->line;
$top = UNKNOWN;
}
sub pp_padrange {
my $op = shift;
my $count = $op->private & 127;
for my $i (0..$count-1) {
$top = $pad[$op->targ + $i];
process($top, $op->private & OPpLVAL_INTRO ? "intro" : "used");
}
}
sub pp_padsv {
my $op = shift;
$top = $pad[$op->targ];
process($top, $op->private & OPpLVAL_INTRO ? "intro" : "used");
}
sub pp_padav { pp_padsv(@_) }
sub pp_padhv { pp_padsv(@_) }
sub deref {
my ($op, $var, $as) = @_;
$var->[1] = $as . $var->[1];
process($var, $op->private & OPpOUR_INTRO ? "intro" : "used");
}
sub pp_rv2cv { deref(shift, $top, "&"); }
sub pp_rv2hv { deref(shift, $top, "%"); }
sub pp_rv2sv { deref(shift, $top, "\$"); }
sub pp_rv2av { deref(shift, $top, "\@"); }
sub pp_rv2gv { deref(shift, $top, "*"); }
sub pp_gvsv {
my $op = shift;
my $gv;
if ($Config{useithreads}) {
$top = $pad[$op->padix];
$top = UNKNOWN unless $top;
$top->[1] = '$';
}
else {
$gv = $op->gv;
$top = [$gv->STASH->NAME, '$', $gv->SAFENAME];
}
process($top, $op->private & OPpLVAL_INTRO ||
$op->private & OPpOUR_INTRO ? "intro" : "used");
}
sub pp_gv {
my $op = shift;
my $gv;
if ($Config{useithreads}) {
$top = $pad[$op->padix];
$top = UNKNOWN unless $top;
$top->[1] = '*';
}
else {
$gv = $op->gv;
if ($gv->FLAGS & SVf_ROK) { # sub ref
my $cv = $gv->RV;
$top = [$cv->STASH->NAME, '*', B::safename($cv->NAME_HEK)]
}
else {
$top = [$gv->STASH->NAME, '*', $gv->SAFENAME];
}
}
process($top, $op->private & OPpLVAL_INTRO ? "intro" : "used");
}
sub pp_const {
my $op = shift;
my $sv = $op->sv;
# constant could be in the pad (under useithreads)
if ($$sv) {
$top = ["?", "",
(class($sv) ne "SPECIAL" && $sv->FLAGS & SVf_POK)
? cstring($sv->PV) : "?"];
}
else {
$top = $pad[$op->targ];
$top = UNKNOWN unless $top;
}
}
sub pp_method {
my $op = shift;
$top = ["(method)", "->".$top->[1], $top->[2]];
}
sub pp_entersub {
my $op = shift;
if ($top->[1] eq "m") {
process($top, "meth");
} else {
process($top, "subused");
}
$top = UNKNOWN;
}
#
# Stuff for cross referencing definitions of variables and subs
#
sub B::GV::xref {
my $gv = shift;
my $cv = $gv->CV;
if ($$cv) {
#return if $done{$$cv}++;
$file = $gv->FILE;
$line = $gv->LINE;
process([$gv->STASH->NAME, "&", $gv->NAME], "subdef");
push(@todo, $cv);
}
my $form = $gv->FORM;
if ($$form) {
return if $done{$$form}++;
$file = $gv->FILE;
$line = $gv->LINE;
process([$gv->STASH->NAME, "", $gv->NAME], "formdef");
}
}
sub xref_definitions {
my ($pack, %exclude);
return if $nodefs;
$subname = "(definitions)";
foreach $pack (qw(B O AutoLoader DynaLoader XSLoader Config DB VMS
strict vars FileHandle Exporter Carp PerlIO::Layer
attributes utf8 warnings)) {
$exclude{$pack."::"} = 1;
}
no strict qw(vars refs);
walksymtable(\%{"main::"}, "xref", sub { !defined($exclude{$_[0]}) });
}
sub output {
return if $raw;
my ($file, $subname, $pack, $name, $ev, $perfile, $persubname,
$perpack, $pername, $perev);
foreach $file (sort(keys(%table))) {
$perfile = $table{$file};
print "File $file\n";
foreach $subname (sort(keys(%$perfile))) {
$persubname = $perfile->{$subname};
print " Subroutine $subname\n";
foreach $pack (sort(keys(%$persubname))) {
$perpack = $persubname->{$pack};
print " Package $pack\n";
foreach $name (sort(keys(%$perpack))) {
$pername = $perpack->{$name};
my @lines;
foreach $ev (qw(intro formdef subdef meth subused used)) {
$perev = $pername->{$ev};
if (defined($perev) && @$perev) {
my $code = $code{$ev};
push(@lines, map("$code$_", @$perev));
}
}
printf " %-16s %s\n", $name, join(", ", @lines);
}
}
}
}
}
sub compile {
my @options = @_;
my ($option, $opt, $arg);
OPTION:
while ($option = shift @options) {
if ($option =~ /^-(.)(.*)/) {
$opt = $1;
$arg = $2;
} else {
unshift @options, $option;
last OPTION;
}
if ($opt eq "-" && $arg eq "-") {
shift @options;
last OPTION;
} elsif ($opt eq "o") {
$arg ||= shift @options;
open(STDOUT, '>', $arg) or return "$arg: $!\n";
} elsif ($opt eq "d") {
$nodefs = 1;
} elsif ($opt eq "r") {
$raw = 1;
} elsif ($opt eq "D") {
$arg ||= shift @options;
foreach $arg (split(//, $arg)) {
if ($arg eq "o") {
B->debug(1);
} elsif ($arg eq "O") {
$debug_op = 1;
} elsif ($arg eq "t") {
$debug_top = 1;
}
}
}
}
if (@options) {
return sub {
my $objname;
xref_definitions();
foreach $objname (@options) {
$objname = "main::$objname" unless $objname =~ /::/;
eval "xref_object(\\&$objname)";
die "xref_object(\\&$objname) failed: $@" if $@;
}
output();
}
} else {
return sub {
xref_definitions();
xref_main();
output();
}
}
}
1;

58
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/EXTERN.h Normal file
View file

@ -0,0 +1,58 @@
/* EXTERN.h
*
* Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999,
* 2000, 2001, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* EXT: designates a global var which is defined in perl.h
*
* dEXT: designates a global var which is defined in another
* file, so we can't count on finding it in perl.h
* (this practice should be avoided).
*/
#undef EXT
#undef dEXT
#undef EXTCONST
#undef dEXTCONST
# if defined(WIN32) && !defined(PERL_STATIC_SYMS)
/* miniperl should not export anything */
# if defined(PERL_IS_MINIPERL)
# define EXT extern
# define dEXT
# define EXTCONST extern const
# define dEXTCONST const
# elif defined(PERLDLL)
# define EXT EXTERN_C __declspec(dllexport)
# define dEXT
# define EXTCONST EXTERN_C __declspec(dllexport) const
# define dEXTCONST const
# else
# define EXT EXTERN_C __declspec(dllimport)
# define dEXT
# define EXTCONST EXTERN_C __declspec(dllimport) const
# define dEXTCONST const
# endif
# else
# if defined(__CYGWIN__) && defined(USEIMPORTLIB)
# define EXT extern __declspec(dllimport)
# define dEXT
# define EXTCONST extern __declspec(dllimport) const
# define dEXTCONST const
# else
# define EXT extern
# define dEXT
# define EXTCONST extern const
# define dEXTCONST const
# endif
# endif
#undef INIT
#define INIT(...)
#undef DOINIT

51
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/INTERN.h Normal file
View file

@ -0,0 +1,51 @@
/* INTERN.h
*
* Copyright (C) 1991, 1992, 1993, 1995, 1996, 1998, 2000, 2001,
* by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* EXT designates a global var which is defined in perl.h
* dEXT designates a global var which is defined in another
* file, so we can't count on finding it in perl.h
* (this practice should be avoided).
*/
#undef EXT
#undef dEXT
#undef EXTCONST
#undef dEXTCONST
# if (defined(WIN32) && defined(__MINGW32__) && ! defined(PERL_IS_MINIPERL))
# ifdef __cplusplus
# define EXT __declspec(dllexport)
# define dEXT
# define EXTCONST __declspec(dllexport) extern const
# define dEXTCONST const
# else
# define EXT __declspec(dllexport)
# define dEXT
# define EXTCONST __declspec(dllexport) const
# define dEXTCONST const
# endif
# else
# ifdef __cplusplus
# define EXT
# define dEXT
# define EXTCONST EXTERN_C const
# define dEXTCONST const
# else
# define EXT
# define dEXT
# define EXTCONST const
# define dEXTCONST const
# endif
# endif
#undef INIT
#define INIT(...) = __VA_ARGS__
#define DOINIT

676
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/XSUB.h Normal file
View file

@ -0,0 +1,676 @@
/* XSUB.h
*
* Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
* 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#ifndef PERL_XSUB_H_
#define PERL_XSUB_H_ 1
/* first, some documentation for xsubpp-generated items */
/*
=for apidoc_section $XS
F<xsubpp> compiles XS code into C. See L<perlutil/xsubpp>.
=for comment
Some variables below are flagged with 'u' because Devel::PPPort can't currently
readily test them as they spring into existence by compiling with xsubpp.
=for apidoc Amnu|char*|CLASS
Variable which is setup by C<xsubpp> to indicate the
class name for a C++ XS constructor. This is always a C<char*>. See
C<L</THIS>>.
=for apidoc Amnu|type|RETVAL
Variable which is setup by C<xsubpp> to hold the return value for an
XSUB. This is always the proper type for the XSUB. See
L<perlxs/"The RETVAL Variable">.
=for apidoc Amnu|type|THIS
Variable which is setup by C<xsubpp> to designate the object in a C++
XSUB. This is always the proper type for the C++ object. See C<L</CLASS>> and
L<perlxs/"Using XS With C++">.
=for apidoc Amn|Stack_off_t|ax
Variable which is setup by C<xsubpp> to indicate the stack base offset,
used by the C<ST>, C<XSprePUSH> and C<XSRETURN> macros. The C<dMARK> macro
must be called prior to setup the C<MARK> variable.
=for apidoc Amn|Stack_off_t|items
Variable which is setup by C<xsubpp> to indicate the number of
items on the stack. See L<perlxs/"Variable-length Parameter Lists">.
=for apidoc Amn|I32|ix
Variable which is setup by C<xsubpp> to indicate which of an
XSUB's aliases was used to invoke it. See L<perlxs/"The ALIAS: Keyword">.
=for apidoc Am|SV*|ST|int ix
Used to access elements on the XSUB's stack.
=for apidoc Ay||XS|name
Macro to declare an XSUB and its C parameter list. This is handled by
C<xsubpp>. It is the same as using the more explicit C<XS_EXTERNAL> macro; the
latter is preferred.
=for apidoc Ayu||XS_INTERNAL|name
Macro to declare an XSUB and its C parameter list without exporting the symbols.
This is handled by C<xsubpp> and generally preferable over exporting the XSUB
symbols unnecessarily.
=for comment
XS_INTERNAL marked 'u' because declaring a function static within our test
function doesn't work
=for apidoc Ay||XS_EXTERNAL|name
Macro to declare an XSUB and its C parameter list explicitly exporting the symbols.
=for apidoc Ay||XSPROTO|name
Macro used by C<L</XS_INTERNAL>> and C<L</XS_EXTERNAL>> to declare a function
prototype. You probably shouldn't be using this directly yourself.
=for apidoc Amn;||dAX
Sets up the C<ax> variable.
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
=for apidoc Amn;||dAXMARK
Sets up the C<ax> variable and stack marker variable C<mark>.
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
=for apidoc Amn;||dITEMS
Sets up the C<items> variable.
This is usually handled automatically by C<xsubpp> by calling C<dXSARGS>.
=for apidoc Amn;||dXSARGS
Sets up stack and mark pointers for an XSUB, calling C<dSP> and C<dMARK>.
Sets up the C<ax> and C<items> variables by calling C<dAX> and C<dITEMS>.
This is usually handled automatically by C<xsubpp>.
=for apidoc Amn;||dXSI32
Sets up the C<ix> variable for an XSUB which has aliases. This is usually
handled automatically by C<xsubpp>.
=for apidoc Amn;||dUNDERBAR
Sets up any variable needed by the C<UNDERBAR> macro. It used to define
C<padoff_du>, but it is currently a noop. However, it is strongly advised
to still use it for ensuring past and future compatibility.
=for apidoc AmnU||UNDERBAR
The SV* corresponding to the C<$_> variable. Works even if there
is a lexical C<$_> in scope.
=cut
*/
#ifndef PERL_UNUSED_ARG
# define PERL_UNUSED_ARG(x) ((void)sizeof(x))
#endif
#ifndef PERL_UNUSED_VAR
# define PERL_UNUSED_VAR(x) ((void)sizeof(x))
#endif
#define ST(off) PL_stack_base[ax + (off)]
/* XSPROTO() is also used by SWIG like this:
*
* typedef XSPROTO(SwigPerlWrapper);
* typedef SwigPerlWrapper *SwigPerlWrapperPtr;
*
* This code needs to be compilable under both C and C++.
*
* Don't forget to change the __attribute__unused__ version of XS()
* below too if you change XSPROTO() here.
*/
/* XS_INTERNAL is the explicit static-linkage variant of the default
* XS macro.
*
* XS_EXTERNAL is the same as XS_INTERNAL except it does not include
* "STATIC", ie. it exports XSUB symbols. You probably don't want that.
*/
#define XSPROTO(name) void name(pTHX_ CV* cv __attribute__unused__)
#undef XS
#undef XS_EXTERNAL
#undef XS_INTERNAL
#if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
# define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
# define XS_INTERNAL(name) STATIC XSPROTO(name)
#elif defined(__cplusplus)
# define XS_EXTERNAL(name) extern "C" XSPROTO(name)
# define XS_INTERNAL(name) static XSPROTO(name)
#elif defined(HASATTRIBUTE_UNUSED)
# define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
# define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#else
# define XS_EXTERNAL(name) XSPROTO(name)
# define XS_INTERNAL(name) STATIC XSPROTO(name)
#endif
/* We do export xsub symbols by default for the public XS macro.
* Try explicitly using XS_INTERNAL/XS_EXTERNAL instead, please. */
#define XS(name) XS_EXTERNAL(name)
#define dAX const Stack_off_t ax = (Stack_off_t)(MARK - PL_stack_base + 1)
#define dAXMARK \
Stack_off_t ax = POPMARK; \
SV **mark = PL_stack_base + ax++
#define dITEMS Stack_off_t items = (Stack_off_t)(SP - MARK)
#define dXSARGS \
dSP; dAXMARK; dITEMS
/* These 3 macros are replacements for dXSARGS macro only in bootstrap.
They factor out common code in every BOOT XSUB. Computation of vars mark
and items will optimize away in most BOOT functions. Var ax can never be
optimized away since BOOT must return &PL_sv_yes by default from xsubpp.
Note these macros are not drop in replacements for dXSARGS since they set
PL_xsubfilename. */
#define dXSBOOTARGSXSAPIVERCHK \
Stack_off_t ax = XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK; \
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
#define dXSBOOTARGSAPIVERCHK \
Stack_off_t ax = XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK; \
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
/* dXSBOOTARGSNOVERCHK has no API in xsubpp to choose it so do
#undef dXSBOOTARGSXSAPIVERCHK
#define dXSBOOTARGSXSAPIVERCHK dXSBOOTARGSNOVERCHK */
#define dXSBOOTARGSNOVERCHK \
Stack_off_t ax = XS_SETXSUBFN_POPMARK; \
SV **mark = PL_stack_base + ax - 1; dSP; dITEMS
#define dXSTARG SV * const targ = ((PL_op->op_private & OPpENTERSUB_HASTARG) \
? PAD_SV(PL_op->op_targ) : sv_newmortal())
/* Should be used before final PUSHi etc. if not in PPCODE section. */
#define XSprePUSH (sp = PL_stack_base + ax - 1)
#define XSANY CvXSUBANY(cv)
#define dXSI32 I32 ix = XSANY.any_i32
#ifdef __cplusplus
# define XSINTERFACE_CVT(ret,name) ret (*name)(...)
# define XSINTERFACE_CVT_ANON(ret) ret (*)(...)
#else
# define XSINTERFACE_CVT(ret,name) ret (*name)()
# define XSINTERFACE_CVT_ANON(ret) ret (*)()
#endif
#define dXSFUNCTION(ret) XSINTERFACE_CVT(ret,XSFUNCTION)
#define XSINTERFACE_FUNC(ret,cv,f) ((XSINTERFACE_CVT_ANON(ret))(f))
#define XSINTERFACE_FUNC_SET(cv,f) \
CvXSUBANY(cv).any_dxptr = (void (*) (pTHX_ void*))(f)
#define dUNDERBAR dNOOP
#define UNDERBAR find_rundefsv()
/* Simple macros to put new mortal values onto the stack. */
/* Typically used to return values from XS functions. */
/*
=for apidoc_section $stack
=for apidoc Am|void|XST_mIV|int pos|IV iv
Place an integer into the specified position C<pos> on the stack. The
value is stored in a new mortal SV.
=for apidoc Am|void|XST_mNV|int pos|NV nv
Place a double into the specified position C<pos> on the stack. The value
is stored in a new mortal SV.
=for apidoc Am|void|XST_mPV|int pos|char* str
Place a copy of a string into the specified position C<pos> on the stack.
The value is stored in a new mortal SV.
=for apidoc Am|void|XST_mUV|int pos|UV uv
Place an unsigned integer into the specified position C<pos> on the stack. The
value is stored in a new mortal SV.
=for apidoc Am|void|XST_mNO|int pos
Place C<&PL_sv_no> into the specified position C<pos> on the
stack.
=for apidoc Am|void|XST_mYES|int pos
Place C<&PL_sv_yes> into the specified position C<pos> on the
stack.
=for apidoc Am|void|XST_mUNDEF|int pos
Place C<&PL_sv_undef> into the specified position C<pos> on the
stack.
=for apidoc Am|void|XSRETURN|int nitems
Return from XSUB, indicating number of items on the stack. This is usually
handled by C<xsubpp>.
=for apidoc Am|void|XSRETURN_IV|IV iv
Return an integer from an XSUB immediately. Uses C<XST_mIV>.
=for apidoc Am|void|XSRETURN_UV|IV uv
Return an integer from an XSUB immediately. Uses C<XST_mUV>.
=for apidoc Am|void|XSRETURN_NV|NV nv
Return a double from an XSUB immediately. Uses C<XST_mNV>.
=for apidoc Am|void|XSRETURN_PV|char* str
Return a copy of a string from an XSUB immediately. Uses C<XST_mPV>.
=for apidoc Amn;||XSRETURN_NO
Return C<&PL_sv_no> from an XSUB immediately. Uses C<XST_mNO>.
=for apidoc Amn;||XSRETURN_YES
Return C<&PL_sv_yes> from an XSUB immediately. Uses C<XST_mYES>.
=for apidoc Amn;||XSRETURN_UNDEF
Return C<&PL_sv_undef> from an XSUB immediately. Uses C<XST_mUNDEF>.
=for apidoc Amn;||XSRETURN_EMPTY
Return an empty list from an XSUB immediately.
=for apidoc AmU||newXSproto|char* name|XSUBADDR_t f|char* filename|const char *proto
Used by C<xsubpp> to hook up XSUBs as Perl subs. Adds Perl prototypes to
the subs.
=for apidoc AmnU||XS_VERSION
The version identifier for an XS module. This is usually
handled automatically by C<ExtUtils::MakeMaker>. See
C<L</XS_VERSION_BOOTCHECK>>.
=for apidoc Amn;||XS_VERSION_BOOTCHECK
Macro to verify that a PM module's C<$VERSION> variable matches the XS
module's C<XS_VERSION> variable. This is usually handled automatically by
C<xsubpp>. See L<perlxs/"The VERSIONCHECK: Keyword">.
=for apidoc Amn;||XS_APIVERSION_BOOTCHECK
Macro to verify that the perl api version an XS module has been compiled against
matches the api version of the perl interpreter it's being loaded into.
=for apidoc_section $exceptions
=for apidoc Amn;||dXCPT
Set up necessary local variables for exception handling.
See L<perlguts/"Exception Handling">.
=for apidoc AmnU||XCPT_TRY_START
Starts a try block. See L<perlguts/"Exception Handling">.
=for apidoc AmnU||XCPT_TRY_END
Ends a try block. See L<perlguts/"Exception Handling">.
=for apidoc AmnU||XCPT_CATCH
Introduces a catch block. See L<perlguts/"Exception Handling">.
=for apidoc Amn;||XCPT_RETHROW
Rethrows a previously caught exception. See L<perlguts/"Exception Handling">.
=cut
*/
#define XST_mIV(i,v) (ST(i) = sv_2mortal(newSViv(v)) )
#define XST_mUV(i,v) (ST(i) = sv_2mortal(newSVuv(v)) )
#define XST_mNV(i,v) (ST(i) = sv_2mortal(newSVnv(v)) )
#define XST_mPV(i,v) (ST(i) = sv_2mortal(newSVpv(v,0)))
#define XST_mPVN(i,v,n) (ST(i) = newSVpvn_flags(v,n, SVs_TEMP))
#define XST_mNO(i) (ST(i) = &PL_sv_no )
#define XST_mYES(i) (ST(i) = &PL_sv_yes )
#define XST_mUNDEF(i) (ST(i) = &PL_sv_undef)
#define XSRETURN(off) \
STMT_START { \
const IV tmpXSoff = (off); \
assert(tmpXSoff >= 0);\
PL_stack_sp = PL_stack_base + ax + (tmpXSoff - 1); \
return; \
} STMT_END
#define XSRETURN_IV(v) STMT_START { XST_mIV(0,v); XSRETURN(1); } STMT_END
#define XSRETURN_UV(v) STMT_START { XST_mUV(0,v); XSRETURN(1); } STMT_END
#define XSRETURN_NV(v) STMT_START { XST_mNV(0,v); XSRETURN(1); } STMT_END
#define XSRETURN_PV(v) STMT_START { XST_mPV(0,v); XSRETURN(1); } STMT_END
#define XSRETURN_PVN(v,n) STMT_START { XST_mPVN(0,v,n); XSRETURN(1); } STMT_END
#define XSRETURN_NO STMT_START { XST_mNO(0); XSRETURN(1); } STMT_END
#define XSRETURN_YES STMT_START { XST_mYES(0); XSRETURN(1); } STMT_END
#define XSRETURN_UNDEF STMT_START { XST_mUNDEF(0); XSRETURN(1); } STMT_END
#define XSRETURN_EMPTY STMT_START { XSRETURN(0); } STMT_END
#define newXSproto(a,b,c,d) newXS_flags(a,b,c,d,0)
#ifdef XS_VERSION
# define XS_VERSION_BOOTCHECK \
Perl_xs_handshake(HS_KEY(FALSE, FALSE, "", XS_VERSION), HS_CXT, __FILE__, \
items, ax, XS_VERSION)
#else
# define XS_VERSION_BOOTCHECK
#endif
#define XS_APIVERSION_BOOTCHECK \
Perl_xs_handshake(HS_KEY(FALSE, FALSE, "v" PERL_API_VERSION_STRING, ""), \
HS_CXT, __FILE__, items, ax, "v" PERL_API_VERSION_STRING)
/* public API, this is a combination of XS_VERSION_BOOTCHECK and
XS_APIVERSION_BOOTCHECK in 1, and is backportable */
#ifdef XS_VERSION
# define XS_BOTHVERSION_BOOTCHECK \
Perl_xs_handshake(HS_KEY(FALSE, FALSE, "v" PERL_API_VERSION_STRING, XS_VERSION), \
HS_CXT, __FILE__, items, ax, "v" PERL_API_VERSION_STRING, XS_VERSION)
#else
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
# define XS_BOTHVERSION_BOOTCHECK XS_APIVERSION_BOOTCHECK
#endif
/* private API */
#define XS_APIVERSION_POPMARK_BOOTCHECK \
Perl_xs_handshake(HS_KEY(FALSE, TRUE, "v" PERL_API_VERSION_STRING, ""), \
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING)
#ifdef XS_VERSION
# define XS_BOTHVERSION_POPMARK_BOOTCHECK \
Perl_xs_handshake(HS_KEY(FALSE, TRUE, "v" PERL_API_VERSION_STRING, XS_VERSION), \
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING, XS_VERSION)
#else
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
# define XS_BOTHVERSION_POPMARK_BOOTCHECK XS_APIVERSION_POPMARK_BOOTCHECK
#endif
#define XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK \
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "v" PERL_API_VERSION_STRING, ""), \
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING)
#ifdef XS_VERSION
# define XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK \
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "v" PERL_API_VERSION_STRING, XS_VERSION),\
HS_CXT, __FILE__, "v" PERL_API_VERSION_STRING, XS_VERSION)
#else
/* should this be a #error? if you want both checked, you better supply XS_VERSION right? */
# define XS_BOTHVERSION_SETXSUBFN_POPMARK_BOOTCHECK XS_APIVERSION_SETXSUBFN_POPMARK_BOOTCHECK
#endif
/* For a normal bootstrap without API or XS version checking.
Useful for static XS modules or debugging/testing scenarios.
If this macro gets heavily used in the future, it should separated into
a separate function independent of Perl_xs_handshake for efficiency */
#define XS_SETXSUBFN_POPMARK \
Perl_xs_handshake(HS_KEY(TRUE, TRUE, "", "") | HSf_NOCHK, HS_CXT, __FILE__)
#ifdef NO_XSLOCKS
# 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)
#endif
/*
The DBM_setFilter & DBM_ckFilter macros are only used by
the *DB*_File modules
*/
#define DBM_setFilter(db_type,code) \
STMT_START { \
if (db_type) \
RETVAL = sv_mortalcopy(db_type) ; \
ST(0) = RETVAL ; \
if (db_type && (code == &PL_sv_undef)) { \
SvREFCNT_dec_NN(db_type) ; \
db_type = NULL ; \
} \
else if (code) { \
if (db_type) \
sv_setsv(db_type, code) ; \
else \
db_type = newSVsv(code) ; \
} \
} STMT_END
#define DBM_ckFilter(arg,type,name) \
STMT_START { \
if (db->type) { \
if (db->filtering) { \
croak("recursion detected in %s", name) ; \
} \
ENTER ; \
SAVETMPS ; \
SAVEINT(db->filtering) ; \
db->filtering = TRUE ; \
SAVE_DEFSV ; \
if (name[7] == 's') \
arg = newSVsv(arg); \
DEFSV_set(arg) ; \
SvTEMP_off(arg) ; \
PUSHMARK(SP) ; \
PUTBACK ; \
(void) perl_call_sv(db->type, G_DISCARD); \
SPAGAIN ; \
PUTBACK ; \
FREETMPS ; \
LEAVE ; \
if (name[7] == 's'){ \
arg = sv_2mortal(arg); \
} \
} \
} STMT_END
#if 1 /* for compatibility */
# define VTBL_sv &PL_vtbl_sv
# define VTBL_env &PL_vtbl_env
# define VTBL_envelem &PL_vtbl_envelem
# define VTBL_sigelem &PL_vtbl_sigelem
# define VTBL_pack &PL_vtbl_pack
# define VTBL_packelem &PL_vtbl_packelem
# define VTBL_dbline &PL_vtbl_dbline
# define VTBL_isa &PL_vtbl_isa
# define VTBL_isaelem &PL_vtbl_isaelem
# define VTBL_arylen &PL_vtbl_arylen
# define VTBL_glob &PL_vtbl_glob
# define VTBL_mglob &PL_vtbl_mglob
# define VTBL_nkeys &PL_vtbl_nkeys
# define VTBL_taint &PL_vtbl_taint
# define VTBL_substr &PL_vtbl_substr
# define VTBL_vec &PL_vtbl_vec
# define VTBL_pos &PL_vtbl_pos
# define VTBL_bm &PL_vtbl_bm
# define VTBL_fm &PL_vtbl_fm
# define VTBL_uvar &PL_vtbl_uvar
# define VTBL_defelem &PL_vtbl_defelem
# define VTBL_regexp &PL_vtbl_regexp
# define VTBL_regdata &PL_vtbl_regdata
# define VTBL_regdatum &PL_vtbl_regdatum
# ifdef USE_LOCALE_COLLATE
# define VTBL_collxfrm &PL_vtbl_collxfrm
# endif
# define VTBL_amagic &PL_vtbl_amagic
# define VTBL_amagicelem &PL_vtbl_amagicelem
#endif
#if defined(MULTIPLICITY) && !defined(PERL_NO_GET_CONTEXT) && !defined(PERL_CORE)
# undef aTHX
# undef aTHX_
# define aTHX PERL_GET_THX
# define aTHX_ aTHX,
#endif
#if defined(PERL_IMPLICIT_SYS) && !defined(PERL_CORE)
# ifndef NO_XSLOCKS
# undef closedir
# undef opendir
# undef stdin
# undef stdout
# undef stderr
# undef feof
# undef ferror
# undef fgetpos
# undef ioctl
# undef getlogin
# undef getc
# undef ungetc
# undef fileno
/* to avoid warnings: "xyz" redefined */
#ifdef WIN32
# undef popen
# undef pclose
#endif /* WIN32 */
# undef socketpair
# define mkdir PerlDir_mkdir
# define chdir PerlDir_chdir
# define rmdir PerlDir_rmdir
# define closedir PerlDir_close
# define opendir PerlDir_open
# define readdir PerlDir_read
# define rewinddir PerlDir_rewind
# define seekdir PerlDir_seek
# define telldir PerlDir_tell
# define putenv PerlEnv_putenv
# define getenv PerlEnv_getenv
# define uname PerlEnv_uname
# define stdin PerlSIO_stdin
# define stdout PerlSIO_stdout
# define stderr PerlSIO_stderr
# define fopen PerlSIO_fopen
# define fclose PerlSIO_fclose
# define feof PerlSIO_feof
# define ferror PerlSIO_ferror
# define clearerr PerlSIO_clearerr
# define getc PerlSIO_getc
# define fgets PerlSIO_fgets
# define fputc PerlSIO_fputc
# define fputs PerlSIO_fputs
# define fflush PerlSIO_fflush
# define ungetc PerlSIO_ungetc
# define fileno PerlSIO_fileno
# define fdopen PerlSIO_fdopen
# define freopen PerlSIO_freopen
# define fread PerlSIO_fread
# define fwrite PerlSIO_fwrite
# define setbuf PerlSIO_setbuf
# define setvbuf PerlSIO_setvbuf
# define setlinebuf PerlSIO_setlinebuf
# define stdoutf PerlSIO_stdoutf
# define vfprintf PerlSIO_vprintf
# define ftell PerlSIO_ftell
# define fseek PerlSIO_fseek
# define fgetpos PerlSIO_fgetpos
# define fsetpos PerlSIO_fsetpos
# define frewind PerlSIO_rewind
# define tmpfile PerlSIO_tmpfile
# define access PerlLIO_access
# define chmod PerlLIO_chmod
# define chsize PerlLIO_chsize
# define close PerlLIO_close
# define dup PerlLIO_dup
# define dup2 PerlLIO_dup2
# define flock PerlLIO_flock
# define fstat PerlLIO_fstat
# define ioctl PerlLIO_ioctl
# define isatty PerlLIO_isatty
# define link PerlLIO_link
# define lseek PerlLIO_lseek
# define lstat PerlLIO_lstat
# define mktemp PerlLIO_mktemp
# define open PerlLIO_open
# define read PerlLIO_read
# define rename PerlLIO_rename
# define setmode PerlLIO_setmode
# define stat(buf,sb) PerlLIO_stat(buf,sb)
# define tmpnam PerlLIO_tmpnam
# define umask PerlLIO_umask
# define unlink PerlLIO_unlink
# define utime PerlLIO_utime
# define write PerlLIO_write
# define malloc PerlMem_malloc
# define calloc PerlMem_calloc
# define realloc PerlMem_realloc
# define free PerlMem_free
# define abort PerlProc_abort
# define exit PerlProc_exit
# define _exit PerlProc__exit
# define execl PerlProc_execl
# define execv PerlProc_execv
# define execvp PerlProc_execvp
# define getuid PerlProc_getuid
# define geteuid PerlProc_geteuid
# define getgid PerlProc_getgid
# define getegid PerlProc_getegid
# define getlogin PerlProc_getlogin
# define kill PerlProc_kill
# define killpg PerlProc_killpg
# define pause PerlProc_pause
# define popen PerlProc_popen
# define pclose PerlProc_pclose
# define pipe PerlProc_pipe
# define setuid PerlProc_setuid
# define setgid PerlProc_setgid
# define sleep PerlProc_sleep
# define times PerlProc_times
# define wait PerlProc_wait
# define signal PerlProc_signal
# define getpid PerlProc_getpid
# define gettimeofday PerlProc_gettimeofday
# define htonl PerlSock_htonl
# define htons PerlSock_htons
# define ntohl PerlSock_ntohl
# define ntohs PerlSock_ntohs
# define accept PerlSock_accept
# define bind PerlSock_bind
# define connect PerlSock_connect
# define endhostent PerlSock_endhostent
# define endnetent PerlSock_endnetent
# define endprotoent PerlSock_endprotoent
# define endservent PerlSock_endservent
# define gethostbyaddr PerlSock_gethostbyaddr
# define gethostbyname PerlSock_gethostbyname
# define gethostent PerlSock_gethostent
# define gethostname PerlSock_gethostname
# define getnetbyaddr PerlSock_getnetbyaddr
# define getnetbyname PerlSock_getnetbyname
# define getnetent PerlSock_getnetent
# define getpeername PerlSock_getpeername
# define getprotobyname PerlSock_getprotobyname
# define getprotobynumber PerlSock_getprotobynumber
# define getprotoent PerlSock_getprotoent
# define getservbyname PerlSock_getservbyname
# define getservbyport PerlSock_getservbyport
# define getservent PerlSock_getservent
# define getsockname PerlSock_getsockname
# define getsockopt PerlSock_getsockopt
# define inet_addr PerlSock_inet_addr
# define inet_ntoa PerlSock_inet_ntoa
# define listen PerlSock_listen
# define recv PerlSock_recv
# define recvfrom PerlSock_recvfrom
# define select PerlSock_select
# define send PerlSock_send
# define sendto PerlSock_sendto
# define sethostent PerlSock_sethostent
# define setnetent PerlSock_setnetent
# define setprotoent PerlSock_setprotoent
# define setservent PerlSock_setservent
# define setsockopt PerlSock_setsockopt
# define shutdown PerlSock_shutdown
# define socket PerlSock_socket
# define socketpair PerlSock_socketpair
# undef fd_set
# undef FD_SET
# undef FD_CLR
# undef FD_ISSET
# undef FD_ZERO
# define fd_set Perl_fd_set
# define FD_SET(n,p) PERL_FD_SET(n,p)
# define FD_CLR(n,p) PERL_FD_CLR(n,p)
# define FD_ISSET(n,p) PERL_FD_ISSET(n,p)
# define FD_ZERO(p) PERL_FD_ZERO(p)
# endif /* NO_XSLOCKS */
#endif /* PERL_IMPLICIT_SYS && !PERL_CORE */
#endif /* PERL_XSUB_H_ */ /* include guard */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

225
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/av.h Normal file
View file

@ -0,0 +1,225 @@
/* av.h
*
* Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000,
* 2001, 2002, 2005, 2006, 2007, 2008, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
struct xpvav {
HV* xmg_stash; /* class package */
union _xmgu xmg_u;
SSize_t xav_fill; /* Index of last element present */
SSize_t xav_max; /* max index for which array has space */
SV** xav_alloc; /* pointer to beginning of C array of SVs */
};
/* SV* xav_arylen; */
/* SVpav_REAL is set for all AVs whose xav_array contents are refcounted
* and initialized such that any element can be retrieved as a SV*.
* Such AVs may be referred to as "real" AVs. Examples include regular
* perl arrays, tiedarrays (since v5.16), and padlist AVs.
*
* Some things do not set SVpav_REAL, to indicate that they are cheating
* (for efficiency) by not refcounting the AV's contents or ensuring that
* all elements are safe for arbitrary access. This type of AV may be
* referred to as "fake" AVs. Examples include "@_" (unless tied), the
* scratchpad list, and the backrefs list on an object or stash.
*
* SVpav_REIFY is only meaningful on such "fake" AVs (i.e. where SVpav_REAL
* is not set). It indicates that the fake AV is capable of becoming
* real if the array needs to be modified in some way. Functions that
* modify fake AVs check both flags to call av_reify() as appropriate.
*
* av_reify() transforms a fake AV into a real one through two actions.
* Allocated but unpopulated elements are initialized to make them safe for
* arbitrary retrieval and the reference counts of populated elements are
* incremented.
*
* Note that the Perl stack has neither flag set. (Thus,
* items that go on the stack are never refcounted.)
*
* These internal details are subject to change any time. AV
* manipulations external to perl should not care about any of this.
* GSAR 1999-09-10
*/
/*
=for apidoc ADmnU||Nullav
Null AV pointer.
(deprecated - use C<(AV *)NULL> instead)
=for apidoc Am|SSize_t|AvFILL|AV* av
Same as C<L</av_top_index>> or C<L</av_tindex>>.
=for apidoc Cm|SSize_t|AvFILLp|AV* av
If the array C<av> is empty, this returns -1; otherwise it returns the maximum
value of the indices of all the array elements which are currently defined in
C<av>. It does not handle magic, hence the C<p> private indication in its name.
=for apidoc Am|SV**|AvARRAY|AV* av
Returns a pointer to the AV's internal SV* array.
This is useful for doing pointer arithmetic on the array.
If all you need is to look up an array element, then prefer C<av_fetch>.
=cut
*/
#ifndef PERL_CORE
# define Nullav Null(AV*)
#endif
#define AvARRAY(av) ((av)->sv_u.svu_array)
#define AvALLOC(av) ((XPVAV*) SvANY(av))->xav_alloc
#define AvMAX(av) ((XPVAV*) SvANY(av))->xav_max
#define AvFILLp(av) ((XPVAV*) SvANY(av))->xav_fill
#define AvARYLEN(av) (*Perl_av_arylen_p(aTHX_ MUTABLE_AV(av)))
#define AvREAL(av) (SvFLAGS(av) & SVpav_REAL)
#define AvREAL_on(av) (SvFLAGS(av) |= SVpav_REAL)
#define AvREAL_off(av) (SvFLAGS(av) &= ~SVpav_REAL)
#define AvREAL_only(av) (AvREIFY_off(av), SvFLAGS(av) |= SVpav_REAL)
#define AvREIFY(av) (SvFLAGS(av) & SVpav_REIFY)
#define AvREIFY_on(av) (SvFLAGS(av) |= SVpav_REIFY)
#define AvREIFY_off(av) (SvFLAGS(av) &= ~SVpav_REIFY)
#define AvREIFY_only(av) (AvREAL_off(av), SvFLAGS(av) |= SVpav_REIFY)
#define AvREALISH(av) (SvFLAGS(av) & (SVpav_REAL|SVpav_REIFY))
#define AvFILL(av) ((SvRMAGICAL((const SV *) (av))) \
? mg_size(MUTABLE_SV(av)) : AvFILLp(av))
#define av_top_index(av) AvFILL(av)
#define av_tindex(av) av_top_index(av)
/* Note that it doesn't make sense to do this:
* SvGETMAGIC(av); IV x = av_tindex_nomg(av);
*/
# define av_top_index_skip_len_mg(av) \
(__ASSERT_(SvTYPE(av) == SVt_PVAV) AvFILLp(av))
# define av_tindex_skip_len_mg(av) av_top_index_skip_len_mg(av)
#define NEGATIVE_INDICES_VAR "NEGATIVE_INDICES"
/*
Note that there are both real and fake AVs; see the beginning of this file and
'av.c'
=for apidoc newAV
=for apidoc_item newAV_mortal
=for apidoc_item newAV_alloc_x
=for apidoc_item newAV_alloc_xz
These all create a new AV, setting the reference count to 1. If you also know
the initial elements of the array with, see L</C<av_make>>.
As background, an array consists of three things:
=over
=item 1.
A data structure containing information about the array as a whole, such as its
size and reference count.
=item 2.
A C language array of pointers to the individual elements. These are treated
as pointers to SVs, so all must be castable to SV*.
=item 3.
The individual elements themselves. These could be, for instance, SVs and/or
AVs and/or HVs, etc.
=back
An empty array need only have the first data structure, and all these functions
create that. They differ in what else they do, as follows:
=over
=item C<newAV> form
=for comment
'form' above and below is because otherwise have two =items with the same name,
can't link to them.
This does nothing beyond creating the whole-array data structure.
The Perl equivalent is approximately S<C<my @array;>>
This is useful when the minimum size of the array could be zero (perhaps there
are likely code paths that will entirely skip using it).
If the array does get used, the pointers data structure will need to be
allocated at that time. This will end up being done by L</av_extend>>,
either explicitly:
av_extend(av, len);
or implicitly when the first element is stored:
(void)av_store(av, 0, sv);
Unused array elements are typically initialized by C<av_extend>.
=item C<newAV_mortal> form
This also creates the whole-array data structure, but also mortalises it.
(That is to say, a reference to the AV is added to the C<temps> stack.)
=item C<newAV_alloc_x> form
This effectively does a C<newAV> followed by also allocating (uninitialized)
space for the pointers array. This is used when you know ahead of time the
likely minimum size of the array. It is more efficient to do this than doing a
plain C<newAV> followed by an C<av_extend>.
Of course the array can be extended later should it become necessary.
C<size> must be at least 1.
=item C<newAV_alloc_xz> form
This is C<newAV_alloc_x>, but initializes each pointer in it to NULL. This
gives added safety to guard against them being read before being set.
C<size> must be at least 1.
=back
The following examples all result in an array that can fit four elements
(indexes 0 .. 3):
AV *av = newAV();
av_extend(av, 3);
AV *av = newAV_alloc_x(4);
AV *av = newAV_alloc_xz(4);
In contrast, the following examples allocate an array that is only guaranteed
to fit one element without extending:
AV *av = newAV_alloc_x(1);
AV *av = newAV_alloc_xz(1);
=cut
*/
#define newAV() MUTABLE_AV(newSV_type(SVt_PVAV))
#define newAV_mortal() MUTABLE_AV(newSV_type_mortal(SVt_PVAV))
#define newAV_alloc_x(size) av_new_alloc(size,0)
#define newAV_alloc_xz(size) av_new_alloc(size,1)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

24
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/bitcount.h Normal file
View file

@ -0,0 +1,24 @@
/* bitcount.h:
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
*
* These values will populate PL_bitcount[]:
* this is a count of bits for each U8 value 0..255
*/
{
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
}

436086
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/charclass_invlists.h Normal file
View file

File diff suppressed because it is too large Load diff

5408
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/config.h Normal file
View file

File diff suppressed because it is too large Load diff

1445
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cop.h Normal file
View file

File diff suppressed because it is too large Load diff

373
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cv.h Normal file
View file

@ -0,0 +1,373 @@
/* cv.h
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001,
* 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/* This structure must match the beginning of XPVFM in sv.h */
struct xpvcv {
_XPV_HEAD;
_XPVCV_COMMON;
};
/*
=for apidoc Ayh||CV
=for apidoc ADmnU||Nullcv
Null CV pointer.
(deprecated - use C<(CV *)NULL> instead)
=for apidoc Am|HV*|CvSTASH|CV* cv
Returns the stash of the CV. A stash is the symbol table hash, containing
the package-scoped variables in the package where the subroutine was defined.
For more information, see L<perlguts>.
This also has a special use with XS AUTOLOAD subs.
See L<perlguts/Autoloading with XSUBs>.
=cut
*/
#ifndef PERL_CORE
# define Nullcv Null(CV*)
#endif
#define CvSTASH(sv) (MUTABLE_HV(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_stash))
#define CvSTASH_set(cv,st) Perl_cvstash_set(aTHX_ cv, st)
#define CvSTART(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_start
#define CvROOT(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_root
#define CvXSUB(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_root_u.xcv_xsub
#define CvXSUBANY(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_start_u.xcv_xsubany
#define CvGV(sv) Perl_CvGV(aTHX_ (CV *)(sv))
#define CvGV_set(cv,gv) Perl_cvgv_set(aTHX_ cv, gv)
#define CvHASGV(cv) cBOOL(SvANY(cv)->xcv_gv_u.xcv_gv)
#define CvFILE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_file
#ifdef USE_ITHREADS
# define CvFILE_set_from_cop(sv, cop) \
(CvFILE(sv) = savepv(CopFILE(cop)), CvDYNFILE_on(sv))
#else
# define CvFILE_set_from_cop(sv, cop) \
(CvFILE(sv) = CopFILE(cop), CvDYNFILE_off(sv))
#endif
#define CvFILEGV(sv) (gv_fetchfile(CvFILE(sv)))
#define CvDEPTH(sv) (*Perl_CvDEPTH((const CV *)sv))
/* For use when you only have a XPVCV*, not a real CV*.
Must be assert protected as in Perl_CvDEPTH before use. */
#define CvDEPTHunsafe(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_depth
/* these CvPADLIST/CvRESERVED asserts can be reverted one day, once stabilized */
#define CvPADLIST(sv) (*(assert_(!CvISXSUB((CV*)(sv))) \
&(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist)))
/* CvPADLIST_set is not public API, it can be removed one day, once stabilized */
#ifdef DEBUGGING
# define CvPADLIST_set(sv, padlist) Perl_set_padlist((CV*)sv, padlist)
#else
# define CvPADLIST_set(sv, padlist) (CvPADLIST(sv) = (padlist))
#endif
#define CvHSCXT(sv) *(assert_(CvISXSUB((CV*)(sv))) \
&(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_hscxt))
#ifdef DEBUGGING
# if PTRSIZE == 8
# define PoisonPADLIST(sv) \
(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)UINT64_C(0xEFEFEFEFEFEFEFEF))
# elif PTRSIZE == 4
# define PoisonPADLIST(sv) \
(((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_padlist_u.xcv_padlist = (PADLIST *)0xEFEFEFEF)
# else
# error unknown pointer size
# endif
#else
# define PoisonPADLIST(sv) NOOP
#endif
#define CvOUTSIDE(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside
#define CvOUTSIDE_SEQ(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_outside_seq
#define CvFLAGS(sv) ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_flags
/* These two are sometimes called on non-CVs */
#define CvPROTO(sv) \
( \
SvPOK(sv) \
? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \
? SvEND(sv)+1 : SvPVX_const(sv) \
: NULL \
)
#define CvPROTOLEN(sv) \
( \
SvPOK(sv) \
? SvTYPE(sv) == SVt_PVCV && CvAUTOLOAD(sv) \
? SvLEN(sv)-SvCUR(sv)-2 \
: SvCUR(sv) \
: 0 \
)
/* CV has the `:method` attribute. This used to be called CVf_METHOD but is
* renamed to avoid collision with CVf_IsMETHOD */
#define CVf_NOWARN_AMBIGUOUS 0x0001
#define CVf_LVALUE 0x0002 /* CV return value can be used as lvalue */
#define CVf_CONST 0x0004 /* inlinable sub */
#define CVf_ISXSUB 0x0008 /* CV is an XSUB, not pure perl. */
#define CVf_WEAKOUTSIDE 0x0010 /* CvOUTSIDE isn't ref counted */
#define CVf_CLONE 0x0020 /* anon CV uses external lexicals */
#define CVf_CLONED 0x0040 /* a clone of one of those */
#define CVf_ANON 0x0080 /* CV is not pointed to by a GV */
#define CVf_UNIQUE 0x0100 /* sub is only called once (eg PL_main_cv,
require, eval). */
#define CVf_NODEBUG 0x0200 /* no DB::sub indirection for this CV
(esp. useful for special XSUBs) */
#define CVf_CVGV_RC 0x0400 /* CvGV is reference counted */
#if defined(PERL_CORE) || defined(PERL_EXT)
# define CVf_SLABBED 0x0800 /* Holds refcount on op slab */
#endif
#define CVf_DYNFILE 0x1000 /* The filename is malloced */
#define CVf_AUTOLOAD 0x2000 /* SvPVX contains AUTOLOADed sub name */
/* 0x4000 previously CVf_HASEVAL */
#define CVf_NAMED 0x8000 /* Has a name HEK */
#define CVf_LEXICAL 0x10000 /* Omit package from name */
#define CVf_ANONCONST 0x20000 /* :const - create anonconst op */
#define CVf_SIGNATURE 0x40000 /* CV uses a signature */
#define CVf_REFCOUNTED_ANYSV 0x80000 /* CvXSUBANY().any_sv is refcounted */
#define CVf_IsMETHOD 0x100000 /* CV is a (real) method of a real class. Not
to be confused with what used to be called
CVf_METHOD; now CVf_NOWARN_AMBIGUOUS */
#define CVf_XS_RCSTACK 0x200000 /* the XS function understands a
reference-counted stack */
/* This symbol for optimised communication between toke.c and op.c: */
#define CVf_BUILTIN_ATTRS (CVf_NOWARN_AMBIGUOUS|CVf_LVALUE|CVf_ANONCONST)
#define CvCLONE(cv) (CvFLAGS(cv) & CVf_CLONE)
#define CvCLONE_on(cv) (CvFLAGS(cv) |= CVf_CLONE)
#define CvCLONE_off(cv) (CvFLAGS(cv) &= ~CVf_CLONE)
#define CvCLONED(cv) (CvFLAGS(cv) & CVf_CLONED)
#define CvCLONED_on(cv) (CvFLAGS(cv) |= CVf_CLONED)
#define CvCLONED_off(cv) (CvFLAGS(cv) &= ~CVf_CLONED)
#define CvANON(cv) (CvFLAGS(cv) & CVf_ANON)
#define CvANON_on(cv) (CvFLAGS(cv) |= CVf_ANON)
#define CvANON_off(cv) (CvFLAGS(cv) &= ~CVf_ANON)
/* CvEVAL or CvSPECIAL */
#define CvUNIQUE(cv) (CvFLAGS(cv) & CVf_UNIQUE)
#define CvUNIQUE_on(cv) (CvFLAGS(cv) |= CVf_UNIQUE)
#define CvUNIQUE_off(cv) (CvFLAGS(cv) &= ~CVf_UNIQUE)
#define CvNODEBUG(cv) (CvFLAGS(cv) & CVf_NODEBUG)
#define CvNODEBUG_on(cv) (CvFLAGS(cv) |= CVf_NODEBUG)
#define CvNODEBUG_off(cv) (CvFLAGS(cv) &= ~CVf_NODEBUG)
#define CvNOWARN_AMBIGUOUS(cv) (CvFLAGS(cv) & CVf_NOWARN_AMBIGUOUS)
#define CvNOWARN_AMBIGUOUS_on(cv) (CvFLAGS(cv) |= CVf_NOWARN_AMBIGUOUS)
#define CvNOWARN_AMBIGUOUS_off(cv) (CvFLAGS(cv) &= ~CVf_NOWARN_AMBIGUOUS)
#define CvLVALUE(cv) (CvFLAGS(cv) & CVf_LVALUE)
#define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE)
#define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE)
/* eval or PL_main_cv */
#define CvEVAL(cv) (CvUNIQUE(cv) && !SvFAKE(cv))
#define CvEVAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_off(cv))
#define CvEVAL_off(cv) CvUNIQUE_off(cv)
/* BEGIN|CHECK|INIT|UNITCHECK|END */
#define CvSPECIAL(cv) (CvUNIQUE(cv) && SvFAKE(cv))
#define CvSPECIAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_on(cv))
#define CvSPECIAL_off(cv) (CvUNIQUE_off(cv),SvFAKE_off(cv))
#define CvCONST(cv) (CvFLAGS(cv) & CVf_CONST)
#define CvCONST_on(cv) (CvFLAGS(cv) |= CVf_CONST)
#define CvCONST_off(cv) (CvFLAGS(cv) &= ~CVf_CONST)
#define CvWEAKOUTSIDE(cv) (CvFLAGS(cv) & CVf_WEAKOUTSIDE)
#define CvWEAKOUTSIDE_on(cv) (CvFLAGS(cv) |= CVf_WEAKOUTSIDE)
#define CvWEAKOUTSIDE_off(cv) (CvFLAGS(cv) &= ~CVf_WEAKOUTSIDE)
#define CvISXSUB(cv) (CvFLAGS(cv) & CVf_ISXSUB)
#define CvISXSUB_on(cv) (CvFLAGS(cv) |= CVf_ISXSUB)
#define CvISXSUB_off(cv) (CvFLAGS(cv) &= ~CVf_ISXSUB)
#define CvCVGV_RC(cv) (CvFLAGS(cv) & CVf_CVGV_RC)
#define CvCVGV_RC_on(cv) (CvFLAGS(cv) |= CVf_CVGV_RC)
#define CvCVGV_RC_off(cv) (CvFLAGS(cv) &= ~CVf_CVGV_RC)
#ifdef PERL_CORE
# define CvSLABBED(cv) (CvFLAGS(cv) & CVf_SLABBED)
# define CvSLABBED_on(cv) (CvFLAGS(cv) |= CVf_SLABBED)
# define CvSLABBED_off(cv) (CvFLAGS(cv) &= ~CVf_SLABBED)
#endif
#define CvDYNFILE(cv) (CvFLAGS(cv) & CVf_DYNFILE)
#define CvDYNFILE_on(cv) (CvFLAGS(cv) |= CVf_DYNFILE)
#define CvDYNFILE_off(cv) (CvFLAGS(cv) &= ~CVf_DYNFILE)
#define CvAUTOLOAD(cv) (CvFLAGS(cv) & CVf_AUTOLOAD)
#define CvAUTOLOAD_on(cv) (CvFLAGS(cv) |= CVf_AUTOLOAD)
#define CvAUTOLOAD_off(cv) (CvFLAGS(cv) &= ~CVf_AUTOLOAD)
#define CvNAMED(cv) (CvFLAGS(cv) & CVf_NAMED)
#define CvNAMED_on(cv) (CvFLAGS(cv) |= CVf_NAMED)
#define CvNAMED_off(cv) (CvFLAGS(cv) &= ~CVf_NAMED)
#define CvLEXICAL(cv) (CvFLAGS(cv) & CVf_LEXICAL)
#define CvLEXICAL_on(cv) (CvFLAGS(cv) |= CVf_LEXICAL)
#define CvLEXICAL_off(cv) (CvFLAGS(cv) &= ~CVf_LEXICAL)
#define CvANONCONST(cv) (CvFLAGS(cv) & CVf_ANONCONST)
#define CvANONCONST_on(cv) (CvFLAGS(cv) |= CVf_ANONCONST)
#define CvANONCONST_off(cv) (CvFLAGS(cv) &= ~CVf_ANONCONST)
#define CvSIGNATURE(cv) (CvFLAGS(cv) & CVf_SIGNATURE)
#define CvSIGNATURE_on(cv) (CvFLAGS(cv) |= CVf_SIGNATURE)
#define CvSIGNATURE_off(cv) (CvFLAGS(cv) &= ~CVf_SIGNATURE)
/*
=for apidoc m|bool|CvREFCOUNTED_ANYSV|CV *cv
If true, indicates that the C<CvXSUBANY(cv).any_sv> member contains an SV
pointer whose reference count should be decremented when the CV itself is
freed. In addition, C<cv_clone()> will increment the reference count, and
C<sv_dup()> will duplicate the entire pointed-to SV if this flag is set.
Any CV that wraps an XSUB has an C<ANY> union that the XSUB function is free
to use for its own purposes. It may be the case that the code wishes to store
an SV in the C<any_sv> member of this union. By setting this flag, this SV
reference will be properly reclaimed or duplicated when the CV itself is.
=for apidoc m|void|CvREFCOUNTED_ANYSV_on|CV *cv
Helper macro to turn on the C<CvREFCOUNTED_ANYSV> flag.
=for apidoc m|void|CvREFCOUNTED_ANYSV_off|CV *cv
Helper macro to turn off the C<CvREFCOUNTED_ANYSV> flag.
=cut
*/
#define CvREFCOUNTED_ANYSV(cv) (CvFLAGS(cv) & CVf_REFCOUNTED_ANYSV)
#define CvREFCOUNTED_ANYSV_on(cv) (CvFLAGS(cv) |= CVf_REFCOUNTED_ANYSV)
#define CvREFCOUNTED_ANYSV_off(cv) (CvFLAGS(cv) &= ~CVf_REFCOUNTED_ANYSV)
#define CvIsMETHOD(cv) (CvFLAGS(cv) & CVf_IsMETHOD)
#define CvIsMETHOD_on(cv) (CvFLAGS(cv) |= CVf_IsMETHOD)
#define CvIsMETHOD_off(cv) (CvFLAGS(cv) &= ~CVf_IsMETHOD)
#define CvXS_RCSTACK(cv) (CvFLAGS(cv) & CVf_XS_RCSTACK)
#define CvXS_RCSTACK_on(cv) (CvFLAGS(cv) |= CVf_XS_RCSTACK)
#define CvXS_RCSTACK_off(cv) (CvFLAGS(cv) &= ~CVf_XS_RCSTACK)
/* Back-compat */
#ifndef PERL_CORE
# define CVf_METHOD CVf_NOWARN_AMBIGUOUS
# define CvMETHOD(cv) CvNOWARN_AMBIGUOUS(cv)
# define CvMETHOD_on(cv) CvNOWARN_AMBIGUOUS_on(cv)
# define CvMETHOD_off(cv) CvNOWARN_AMBIGUOUS_off(cv)
#endif
/* Flags for newXS_flags */
#define XS_DYNAMIC_FILENAME 0x01 /* The filename isn't static */
PERL_STATIC_INLINE HEK *
CvNAME_HEK(CV *sv)
{
return CvNAMED(sv)
? ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_hek
: 0;
}
/* helper for the common pattern:
CvNAMED(sv) ? CvNAME_HEK((CV *)sv) : GvNAME_HEK(CvGV(sv))
*/
#define CvGvNAME_HEK(sv) ( \
CvNAMED((CV*)sv) ? \
((XPVCV*)MUTABLE_PTR(SvANY((SV*)sv)))->xcv_gv_u.xcv_hek\
: GvNAME_HEK(CvGV( (SV*) sv)) \
)
/* This lowers the reference count of the previous value, but does *not*
increment the reference count of the new value. */
#define CvNAME_HEK_set(cv, hek) ( \
CvNAME_HEK((CV *)(cv)) \
? unshare_hek(SvANY((CV *)(cv))->xcv_gv_u.xcv_hek) \
: (void)0, \
((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_gv_u.xcv_hek = (hek), \
CvNAMED_on(cv) \
)
/*
=for apidoc m|bool|CvWEAKOUTSIDE|CV *cv
Each CV has a pointer, C<CvOUTSIDE()>, to its lexically enclosing
CV (if any). Because pointers to anonymous sub prototypes are
stored in C<&> pad slots, it is a possible to get a circular reference,
with the parent pointing to the child and vice-versa. To avoid the
ensuing memory leak, we do not increment the reference count of the CV
pointed to by C<CvOUTSIDE> in the I<one specific instance> that the parent
has a C<&> pad slot pointing back to us. In this case, we set the
C<CvWEAKOUTSIDE> flag in the child. This allows us to determine under what
circumstances we should decrement the refcount of the parent when freeing
the child.
There is a further complication with non-closure anonymous subs (i.e. those
that do not refer to any lexicals outside that sub). In this case, the
anonymous prototype is shared rather than being cloned. This has the
consequence that the parent may be freed while there are still active
children, I<e.g.>,
BEGIN { $a = sub { eval '$x' } }
In this case, the BEGIN is freed immediately after execution since there
are no active references to it: the anon sub prototype has
C<CvWEAKOUTSIDE> set since it's not a closure, and $a points to the same
CV, so it doesn't contribute to BEGIN's refcount either. When $a is
executed, the C<eval '$x'> causes the chain of C<CvOUTSIDE>s to be followed,
and the freed BEGIN is accessed.
To avoid this, whenever a CV and its associated pad is freed, any
C<&> entries in the pad are explicitly removed from the pad, and if the
refcount of the pointed-to anon sub is still positive, then that
child's C<CvOUTSIDE> is set to point to its grandparent. This will only
occur in the single specific case of a non-closure anon prototype
having one or more active references (such as C<$a> above).
One other thing to consider is that a CV may be merely undefined
rather than freed, eg C<undef &foo>. In this case, its refcount may
not have reached zero, but we still delete its pad and its C<CvROOT> etc.
Since various children may still have their C<CvOUTSIDE> pointing at this
undefined CV, we keep its own C<CvOUTSIDE> for the time being, so that
the chain of lexical scopes is unbroken. For example, the following
should print 123:
my $x = 123;
sub tmp { sub { eval '$x' } }
my $a = tmp();
undef &tmp;
print $a->();
=cut
*/
typedef OP *(*Perl_call_checker)(pTHX_ OP *, GV *, SV *);
#define CALL_CHECKER_REQUIRE_GV MGf_REQUIRE_GV
#define CV_NAME_NOTQUAL 1
#ifdef PERL_CORE
# define CV_UNDEF_KEEP_NAME 1
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/cygperl5_40.dll Normal file
View file

Binary file not shown.

119
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/dosish.h Normal file
View file

@ -0,0 +1,119 @@
/* dosish.h
*
* Copyright (C) 1993, 1994, 1996, 1997, 1998, 1999,
* 2000, 2001, 2002, 2007, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#define ABORT() abort();
#ifndef SH_PATH
#define SH_PATH "/bin/sh"
#endif
#ifdef WIN32
# define PERL_SYS_INIT_BODY(c,v) \
MALLOC_CHECK_TAINT2(*c,*v) Perl_win32_init(c,v); PERLIO_INIT
# define PERL_SYS_TERM_BODY() Perl_win32_term()
# define BIT_BUCKET "nul"
#else
# define PERL_SYS_INIT_BODY(c,v) \
MALLOC_CHECK_TAINT2(*c,*v); PERLIO_INIT
# define BIT_BUCKET "\\dev\\nul" /* "wanna be like, umm, Newlined, or somethin?" */
#endif
/* Generally add things last-in first-terminated. IO and memory terminations
* need to be generally last
*
* BEWARE that using PerlIO in these will be using freed memory, so may appear
* to work, but must NOT be retained in production code. */
#ifndef PERL_SYS_TERM_BODY
# define PERL_SYS_TERM_BODY() \
ENV_TERM; USER_PROP_MUTEX_TERM; LOCALE_TERM; \
HINTS_REFCNT_TERM; KEYWORD_PLUGIN_MUTEX_TERM; \
OP_CHECK_MUTEX_TERM; OP_REFCNT_TERM; \
PERLIO_TERM; MALLOC_TERM;
#endif
#define dXSUB_SYS dNOOP
/* USEMYBINMODE
* This symbol, if defined, indicates that the program should
* use the routine my_binmode(FILE *fp, char iotype, int mode) to insure
* that a file is in "binary" mode -- that is, that no translation
* of bytes occurs on read or write operations.
*/
#undef USEMYBINMODE
/* Stat_t:
* This symbol holds the type used to declare buffers for information
* returned by stat(). It's usually just struct stat. It may be necessary
* to include <sys/stat.h> and <sys/types.h> to get any typedef'ed
* information.
*/
#if defined(WIN32)
# define Stat_t struct w32_stat
#else
# define Stat_t struct _stati64
#endif
/* USE_STAT_RDEV:
* This symbol is defined if this system has a stat structure declaring
* st_rdev
*/
#define USE_STAT_RDEV /**/
/* ACME_MESS:
* This symbol, if defined, indicates that error messages should be
* should be generated in a format that allows the use of the Acme
* GUI/editor's autofind feature.
*/
#undef ACME_MESS /**/
/* ALTERNATE_SHEBANG:
* This symbol, if defined, contains a "magic" string which may be used
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
* it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
*/
/* #define ALTERNATE_SHEBANG "#!" / **/
#include <signal.h>
/*
* fwrite1() should be a routine with the same calling sequence as fwrite(),
* but which outputs all of the bytes requested as a single stream (unlike
* fwrite() itself, which on some systems outputs several distinct records
* if the number_of_items parameter is >1).
*/
#define fwrite1 fwrite
#define Fstat(fd,bufptr) fstat((fd),(bufptr))
#define Fflush(fp) fflush(fp)
#define Mkdir(path,mode) mkdir((path),(mode))
#ifndef WIN32
# define Stat(fname,bufptr) stat((fname),(bufptr))
#else
# define HAS_IOCTL
# define HAS_UTIME
# define HAS_KILL
# define HAS_WAIT
# define HAS_CHOWN
#endif /* WIN32 */
/* Don't go reading from /dev/urandom */
#define PERL_NO_DEV_RANDOM
#ifdef WIN32
# define NO_ENVIRON_ARRAY
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

798
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/ebcdic_tables.h Normal file
View file

@ -0,0 +1,798 @@
/* -*- mode: C; buffer-read-only: t -*-
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/ebcdic.pl.
* Any changes made here will be lost!
*/
#ifndef PERL_EBCDIC_TABLES_H_ /* Guard against nested #includes */
#define PERL_EBCDIC_TABLES_H_ 1
/* This file contains definitions for various tables used in EBCDIC handling.
* More info is in utfebcdic.h
*
* Some of the tables are adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* which requires this copyright notice:
Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
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 OR COPYRIGHT HOLDERS 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.
*/
#if 'A' == 193 /* EBCDIC 1047 */ \
&& '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
&& '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21
/* Index is ASCII platform code point; value is EBCDIC 1047 equivalent */
# ifndef DOINIT
EXTCONST U8 PL_a2e[256];
# else
EXTCONST U8 PL_a2e[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x15,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAD,0xE0,0xBD,0x5F,0x6D,
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
/*8_*/0x20,0x21,0x22,0x23,0x24,0x25,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
/*A_*/0x41,0xAA,0x4A,0xB1,0x9F,0xB2,0x6A,0xB5,0xBB,0xB4,0x9A,0x8A,0xB0,0xCA,0xAF,0xBC,
/*B_*/0x90,0x8F,0xEA,0xFA,0xBE,0xA0,0xB6,0xB3,0x9D,0xDA,0x9B,0x8B,0xB7,0xB8,0xB9,0xAB,
/*C_*/0x64,0x65,0x62,0x66,0x63,0x67,0x9E,0x68,0x74,0x71,0x72,0x73,0x78,0x75,0x76,0x77,
/*D_*/0xAC,0x69,0xED,0xEE,0xEB,0xEF,0xEC,0xBF,0x80,0xFD,0xFE,0xFB,0xFC,0xBA,0xAE,0x59,
/*E_*/0x44,0x45,0x42,0x46,0x43,0x47,0x9C,0x48,0x54,0x51,0x52,0x53,0x58,0x55,0x56,0x57,
/*F_*/0x8C,0x49,0xCD,0xCE,0xCB,0xCF,0xCC,0xE1,0x70,0xDD,0xDE,0xDB,0xDC,0x8D,0x8E,0xDF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 code point; value is ASCII platform equivalent */
# ifndef DOINIT
EXTCONST U8 PL_e2a[256];
# else
EXTCONST U8 PL_e2a[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
/*4_*/0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
/*5_*/0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0x5E,
/*6_*/0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
/*7_*/0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
/*8_*/0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
/*9_*/0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
/*A_*/0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0x5B,0xDE,0xAE,
/*B_*/0xAC,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0xDD,0xA8,0xAF,0x5D,0xB4,0xD7,
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
/*E_*/0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* (Confusingly named) Index is EBCDIC 1047 I8 byte; value is
* EBCDIC 1047 UTF-EBCDIC equivalent */
# ifndef DOINIT
EXTCONST U8 PL_utf2e[256];
# else
EXTCONST U8 PL_utf2e[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x15,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAD,0xE0,0xBD,0x5F,0x6D,
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
/*8_*/0x20,0x21,0x22,0x23,0x24,0x25,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
/*A_*/0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x51,0x52,0x53,0x54,0x55,0x56,
/*B_*/0x57,0x58,0x59,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x70,0x71,0x72,0x73,
/*C_*/0x74,0x75,0x76,0x77,0x78,0x80,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x9A,0x9B,0x9C,
/*D_*/0x9D,0x9E,0x9F,0xA0,0xAA,0xAB,0xAC,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,
/*E_*/0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBF,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xDA,0xDB,
/*F_*/0xDC,0xDD,0xDE,0xDF,0xE1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xFA,0xFB,0xFC,0xFD,0xFE
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* (Confusingly named) Index is EBCDIC 1047 UTF-EBCDIC byte; value is
* EBCDIC 1047 I8 equivalent */
# ifndef DOINIT
EXTCONST U8 PL_e2utf[256];
# else
EXTCONST U8 PL_e2utf[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
/*4_*/0x20,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0x2E,0x3C,0x28,0x2B,0x7C,
/*5_*/0x26,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0x21,0x24,0x2A,0x29,0x3B,0x5E,
/*6_*/0x2D,0x2F,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0x2C,0x25,0x5F,0x3E,0x3F,
/*7_*/0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
/*8_*/0xC5,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
/*9_*/0xCC,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,
/*A_*/0xD3,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xD4,0xD5,0xD6,0x5B,0xD7,0xD8,
/*B_*/0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0x5D,0xE6,0xE7,
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
/*E_*/0x5C,0xF4,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xFB,0xFC,0xFD,0xFE,0xFF,0x9F
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 UTF-EBCDIC byte; value is UTF8SKIP for start bytes
* (including for overlongs); 1 for continuation. Adapted from the shadow
* flags table in tr16. The entries marked 9 in tr16 are continuation bytes
* and are marked as length 1 here so that we can recover. */
# ifndef DOINIT
EXTCONST U8 PL_utf8skip[256];
# else
EXTCONST U8 PL_utf8skip[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*1_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*2_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*3_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*4_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*5_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*6_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*7_*/ 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
/*8_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
/*9_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
/*A_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 2, 2,
/*B_*/ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 1, 3, 3,
/*C_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
/*D_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4,
/*E_*/ 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 5, 5, 5,
/*F_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 6, 6, 7, 14, 1
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 code point; value is its lowercase equivalent */
# ifndef DOINIT
EXTCONST U8 PL_latin1_lc[256];
# else
EXTCONST U8 PL_latin1_lc[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x70,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x70,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
/*9_*/0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9C,0x9F,
/*A_*/0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0x8C,0xAD,0x8E,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0x8D,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 code point; value is its uppercase equivalent.
* The 'mod' in the name means that codepoints whose uppercase is above 255 or
* longer than 1 character map to LATIN SMALL LETTER Y WITH DIARESIS */
# ifndef DOINIT
EXTCONST U8 PL_mod_latin1_uc[256];
# else
EXTCONST U8 PL_mod_latin1_uc[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0xDF,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x80,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xBA,0xAE,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9E,0x9F,
/*A_*/0xDF,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
/*D_*/0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
/*E_*/0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 code point; For A-Z, value is a-z; for a-z, value
* is A-Z; all other code points map to themselves */
# ifndef DOINIT
EXTCONST U8 PL_fold[256];
# else
EXTCONST U8 PL_fold[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 1047 code point; value is its other fold-pair equivalent
* (A => a; a => A, etc) in the 0-255 range. If no such equivalent, value is
* the code point itself */
# ifndef DOINIT
EXTCONST U8 PL_fold_latin1[256];
# else
EXTCONST U8 PL_fold_latin1[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x80,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x70,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xBA,0xAE,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9C,0x9F,
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0x8C,0xAD,0x8E,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0x8D,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U8 PL_extended_utf8_dfa_tab[416];
# else
EXTCONST U8 PL_extended_utf8_dfa_tab[416] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 0, 0, 0, 0, 0,
/*5_ */ 0, 10, 10, 10, 10, 10, 10, 11, 11, 11, 0, 0, 0, 0, 0, 0,
/*6_ */ 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0,
/*7_ */ 11, 11, 11, 11, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 12, 4, 4, 4,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 13, 5, 5,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 14, 6, 15, 1, 0,
/*N0= 0*/ 0, 1, 16, 32, 48, 64, 80, 1, 1, 1, 1, 1, 96,112,128,144,
/*N1= 16*/ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
/*N2= 32*/ 1, 1, 1, 1, 1, 1, 1, 16, 16, 16, 16, 16, 1, 1, 1, 1,
/*N3= 48*/ 1, 1, 1, 1, 1, 1, 1, 32, 32, 32, 32, 32, 1, 1, 1, 1,
/*N4= 64*/ 1, 1, 1, 1, 1, 1, 1, 48, 48, 48, 48, 48, 1, 1, 1, 1,
/*N5= 80*/ 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 64, 64, 1, 1, 1, 1,
/*N6= 96*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 32, 1, 1, 1, 1,
/*N7=112*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 48, 48, 1, 1, 1, 1,
/*N8=128*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 1, 1, 1, 1,
/*N9=144*/ 1, 1, 1, 1, 1, 1, 1, 1, 80, 80, 80, 80, 1, 1, 1, 1
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U16 PL_strict_utf8_dfa_tab[624];
# else
EXTCONST U16 PL_strict_utf8_dfa_tab[624] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 10, 11, 12, 12, 12, 12, 12, 12, 13, 14, 0, 0, 0, 0, 0,
/*5_ */ 0, 13, 14, 13, 14, 15, 16, 17, 18, 17, 0, 0, 0, 0, 0, 0,
/*6_ */ 0, 0, 18, 17, 18, 19, 20, 17, 18, 17, 18, 0, 0, 0, 0, 0,
/*7_ */ 17, 18, 21, 22, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 8, 6, 4, 5,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 9, 7, 1,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
/*N0 = 0*/ 0, 1, 23, 46, 69,138,115,184, 92,161, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*N1 = 23*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*N2 = 46*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
/*N3 = 69*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
/*N4 = 92*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46,
/*N5 =115*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 1, 1, 46,207,
/*N6 =138*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,276,
/*N7 =161*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 69,322, 69,322, 69,322, 69,322,
/*N8 =184*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*N9 =207*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23,230,253, 23, 23, 23, 23, 23,299,
/*N10=230*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
/*N11=253*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
/*N12=276*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299,
/*N13=299*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
/*N14=322*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,345,
/*N15=345*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U8 PL_c9_utf8_dfa_tab[368];
# else
EXTCONST U8 PL_c9_utf8_dfa_tab[368] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 0, 0, 0, 0, 0,
/*5_ */ 0, 11, 11, 11, 11, 11, 11, 12, 12, 12, 0, 0, 0, 0, 0, 0,
/*6_ */ 0, 0, 12, 12, 12, 13, 13, 12, 12, 12, 12, 0, 0, 0, 0, 0,
/*7_ */ 12, 12, 12, 12, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 2, 2,
/*B_ */ 2, 2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 3, 3, 0, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 6, 5, 4, 4,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 8, 7, 1,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
/*N0= 0*/ 0, 1, 14, 28, 42, 70, 56, 98, 84, 1, 1, 1, 1, 1,
/*N1=14*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
/*N2=28*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, 14, 14, 14, 14,
/*N3=42*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28,
/*N4=56*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28,
/*N5=70*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 1,
/*N6=84*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 42, 42,
/*N7=98*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 1, 1, 1, 1
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13*/
};
# endif
#endif /* EBCDIC 1047 */
#if 'A' == 193 /* EBCDIC 037 */ \
&& '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
&& '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37
/* Index is ASCII platform code point; value is EBCDIC 037 equivalent */
# ifndef DOINIT
EXTCONST U8 PL_a2e[256];
# else
EXTCONST U8 PL_a2e[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x25,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xBA,0xE0,0xBB,0xB0,0x6D,
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
/*8_*/0x20,0x21,0x22,0x23,0x24,0x15,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
/*A_*/0x41,0xAA,0x4A,0xB1,0x9F,0xB2,0x6A,0xB5,0xBD,0xB4,0x9A,0x8A,0x5F,0xCA,0xAF,0xBC,
/*B_*/0x90,0x8F,0xEA,0xFA,0xBE,0xA0,0xB6,0xB3,0x9D,0xDA,0x9B,0x8B,0xB7,0xB8,0xB9,0xAB,
/*C_*/0x64,0x65,0x62,0x66,0x63,0x67,0x9E,0x68,0x74,0x71,0x72,0x73,0x78,0x75,0x76,0x77,
/*D_*/0xAC,0x69,0xED,0xEE,0xEB,0xEF,0xEC,0xBF,0x80,0xFD,0xFE,0xFB,0xFC,0xAD,0xAE,0x59,
/*E_*/0x44,0x45,0x42,0x46,0x43,0x47,0x9C,0x48,0x54,0x51,0x52,0x53,0x58,0x55,0x56,0x57,
/*F_*/0x8C,0x49,0xCD,0xCE,0xCB,0xCF,0xCC,0xE1,0x70,0xDD,0xDE,0xDB,0xDC,0x8D,0x8E,0xDF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 code point; value is ASCII platform equivalent */
# ifndef DOINIT
EXTCONST U8 PL_e2a[256];
# else
EXTCONST U8 PL_e2a[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x85,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x80,0x81,0x82,0x83,0x84,0x0A,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
/*4_*/0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
/*5_*/0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0xAC,
/*6_*/0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
/*7_*/0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
/*8_*/0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
/*9_*/0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
/*A_*/0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0xDD,0xDE,0xAE,
/*B_*/0x5E,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0x5B,0x5D,0xAF,0xA8,0xB4,0xD7,
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
/*E_*/0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* (Confusingly named) Index is EBCDIC 037 I8 byte; value is
* EBCDIC 037 UTF-EBCDIC equivalent */
# ifndef DOINIT
EXTCONST U8 PL_utf2e[256];
# else
EXTCONST U8 PL_utf2e[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x37,0x2D,0x2E,0x2F,0x16,0x05,0x25,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x3C,0x3D,0x32,0x26,0x18,0x19,0x3F,0x27,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x40,0x5A,0x7F,0x7B,0x5B,0x6C,0x50,0x7D,0x4D,0x5D,0x5C,0x4E,0x6B,0x60,0x4B,0x61,
/*3_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0x7A,0x5E,0x4C,0x7E,0x6E,0x6F,
/*4_*/0x7C,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,
/*5_*/0xD7,0xD8,0xD9,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xBA,0xE0,0xBB,0xB0,0x6D,
/*6_*/0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
/*7_*/0x97,0x98,0x99,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xC0,0x4F,0xD0,0xA1,0x07,
/*8_*/0x20,0x21,0x22,0x23,0x24,0x15,0x06,0x17,0x28,0x29,0x2A,0x2B,0x2C,0x09,0x0A,0x1B,
/*9_*/0x30,0x31,0x1A,0x33,0x34,0x35,0x36,0x08,0x38,0x39,0x3A,0x3B,0x04,0x14,0x3E,0xFF,
/*A_*/0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x51,0x52,0x53,0x54,0x55,0x56,
/*B_*/0x57,0x58,0x59,0x5F,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x70,0x71,0x72,
/*C_*/0x73,0x74,0x75,0x76,0x77,0x78,0x80,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x9A,0x9B,
/*D_*/0x9C,0x9D,0x9E,0x9F,0xA0,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB1,0xB2,0xB3,0xB4,0xB5,
/*E_*/0xB6,0xB7,0xB8,0xB9,0xBC,0xBD,0xBE,0xBF,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xDA,0xDB,
/*F_*/0xDC,0xDD,0xDE,0xDF,0xE1,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xFA,0xFB,0xFC,0xFD,0xFE
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* (Confusingly named) Index is EBCDIC 037 UTF-EBCDIC byte; value is
* EBCDIC 037 I8 equivalent */
# ifndef DOINIT
EXTCONST U8 PL_e2utf[256];
# else
EXTCONST U8 PL_e2utf[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x9D,0x85,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x80,0x81,0x82,0x83,0x84,0x0A,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
/*3_*/0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
/*4_*/0x20,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0x2E,0x3C,0x28,0x2B,0x7C,
/*5_*/0x26,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0x21,0x24,0x2A,0x29,0x3B,0xB3,
/*6_*/0x2D,0x2F,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0x2C,0x25,0x5F,0x3E,0x3F,
/*7_*/0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
/*8_*/0xC6,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,
/*9_*/0xCD,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,
/*A_*/0xD4,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,
/*B_*/0x5E,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0x5B,0x5D,0xE4,0xE5,0xE6,0xE7,
/*C_*/0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
/*D_*/0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,
/*E_*/0x5C,0xF4,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,
/*F_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xFB,0xFC,0xFD,0xFE,0xFF,0x9F
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 UTF-EBCDIC byte; value is UTF8SKIP for start bytes
* (including for overlongs); 1 for continuation. Adapted from the shadow
* flags table in tr16. The entries marked 9 in tr16 are continuation bytes
* and are marked as length 1 here so that we can recover. */
# ifndef DOINIT
EXTCONST U8 PL_utf8skip[256];
# else
EXTCONST U8 PL_utf8skip[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*1_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*2_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*3_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*4_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*5_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*6_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*7_*/ 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
/*8_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
/*9_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
/*A_*/ 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2,
/*B_*/ 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 3, 3, 3, 3,
/*C_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3,
/*D_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 4,
/*E_*/ 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 5, 5, 5,
/*F_*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 6, 6, 7, 14, 1
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 code point; value is its lowercase equivalent */
# ifndef DOINIT
EXTCONST U8 PL_latin1_lc[256];
# else
EXTCONST U8 PL_latin1_lc[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x70,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x70,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
/*9_*/0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9C,0x9F,
/*A_*/0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0x8C,0x8D,0x8E,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 code point; value is its uppercase equivalent.
* The 'mod' in the name means that codepoints whose uppercase is above 255 or
* longer than 1 character map to LATIN SMALL LETTER Y WITH DIARESIS */
# ifndef DOINIT
EXTCONST U8 PL_mod_latin1_uc[256];
# else
EXTCONST U8 PL_mod_latin1_uc[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0xDF,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x80,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xAD,0xAE,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9E,0x9F,
/*A_*/0xDF,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
/*D_*/0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
/*E_*/0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 code point; For A-Z, value is a-z; for a-z, value
* is A-Z; all other code points map to themselves */
# ifndef DOINIT
EXTCONST U8 PL_fold[256];
# else
EXTCONST U8 PL_fold[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x80,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* Index is EBCDIC 037 code point; value is its other fold-pair equivalent
* (A => a; a => A, etc) in the 0-255 range. If no such equivalent, value is
* the code point itself */
# ifndef DOINIT
EXTCONST U8 PL_fold_latin1[256];
# else
EXTCONST U8 PL_fold_latin1[256] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_*/0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,
/*1_*/0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
/*2_*/0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
/*3_*/0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
/*4_*/0x40,0x41,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
/*5_*/0x50,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
/*6_*/0x60,0x61,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,
/*7_*/0x80,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,
/*8_*/0x70,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0x8A,0x8B,0xAC,0xAD,0xAE,0x8F,
/*9_*/0x90,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0x9A,0x9B,0x9E,0x9D,0x9C,0x9F,
/*A_*/0xA0,0xA1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xAA,0xAB,0x8C,0x8D,0x8E,0xAF,
/*B_*/0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
/*C_*/0xC0,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0xCA,0xEB,0xEC,0xED,0xEE,0xEF,
/*D_*/0xD0,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0xDA,0xFB,0xFC,0xFD,0xFE,0xDF,
/*E_*/0xE0,0xE1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xEA,0xCB,0xCC,0xCD,0xCE,0xCF,
/*F_*/0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xDB,0xDC,0xDD,0xDE,0xFF
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U8 PL_extended_utf8_dfa_tab[416];
# else
EXTCONST U8 PL_extended_utf8_dfa_tab[416] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 0, 0, 0, 0, 0,
/*5_ */ 0, 10, 10, 10, 10, 10, 10, 11, 11, 11, 0, 0, 0, 0, 0, 11,
/*6_ */ 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0,
/*7_ */ 11, 11, 11, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 12, 4, 4, 4,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 13, 5, 5,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 14, 6, 15, 1, 0,
/*N0= 0*/ 0, 1, 16, 32, 48, 64, 80, 1, 1, 1, 1, 1, 96,112,128,144,
/*N1= 16*/ 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1,
/*N2= 32*/ 1, 1, 1, 1, 1, 1, 1, 16, 16, 16, 16, 16, 1, 1, 1, 1,
/*N3= 48*/ 1, 1, 1, 1, 1, 1, 1, 32, 32, 32, 32, 32, 1, 1, 1, 1,
/*N4= 64*/ 1, 1, 1, 1, 1, 1, 1, 48, 48, 48, 48, 48, 1, 1, 1, 1,
/*N5= 80*/ 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 64, 64, 1, 1, 1, 1,
/*N6= 96*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 32, 1, 1, 1, 1,
/*N7=112*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 48, 48, 1, 1, 1, 1,
/*N8=128*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 64, 64, 64, 1, 1, 1, 1,
/*N9=144*/ 1, 1, 1, 1, 1, 1, 1, 1, 80, 80, 80, 80, 1, 1, 1, 1
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U16 PL_strict_utf8_dfa_tab[624];
# else
EXTCONST U16 PL_strict_utf8_dfa_tab[624] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 10, 11, 12, 12, 12, 12, 12, 12, 13, 14, 0, 0, 0, 0, 0,
/*5_ */ 0, 13, 14, 13, 14, 15, 16, 17, 18, 17, 0, 0, 0, 0, 0, 18,
/*6_ */ 0, 0, 17, 18, 19, 20, 17, 18, 17, 18, 17, 0, 0, 0, 0, 0,
/*7_ */ 18, 21, 22, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 8, 6, 4, 5,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 5, 9, 7, 1,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
/*N0 = 0*/ 0, 1, 23, 46, 69,138,115,184, 92,161, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*N1 = 23*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*N2 = 46*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
/*N3 = 69*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
/*N4 = 92*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46,
/*N5 =115*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 1, 1, 46,207,
/*N6 =138*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,276,
/*N7 =161*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 69,322, 69,322, 69,322, 69,322,
/*N8 =184*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 69,322, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*N9 =207*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23,230,253, 23, 23, 23, 23, 23,299,
/*N10=230*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
/*N11=253*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
/*N12=276*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299,
/*N13=299*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
/*N14=322*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,345,
/*N15=345*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,299
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22*/
};
# endif
/* The table below is adapted from
* https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
* See copyright notice at the beginning of this file.
*/
# ifndef DOINIT
EXTCONST U8 PL_c9_utf8_dfa_tab[368];
# else
EXTCONST U8 PL_c9_utf8_dfa_tab[368] = {
/* _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _A _B _C _D _E _F*/
/*0_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*1_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*2_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*3_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*4_ */ 0, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 0, 0, 0, 0, 0,
/*5_ */ 0, 11, 11, 11, 11, 11, 11, 12, 12, 12, 0, 0, 0, 0, 0, 12,
/*6_ */ 0, 0, 12, 12, 13, 13, 12, 12, 12, 12, 12, 0, 0, 0, 0, 0,
/*7_ */ 12, 12, 12, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0,
/*8_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*9_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*A_ */ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
/*B_ */ 0, 2, 2, 2, 2, 2, 1, 3, 3, 3, 0, 0, 3, 3, 3, 3,
/*C_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3,
/*D_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 6, 5, 4, 4,
/*E_ */ 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 8, 7, 1,
/*F_ */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
/*N0= 0*/ 0, 1, 14, 28, 42, 70, 56, 98, 84, 1, 1, 1, 1, 1,
/*N1=14*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
/*N2=28*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 14, 14, 14, 14, 14,
/*N3=42*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 28,
/*N4=56*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28,
/*N5=70*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 28, 28, 28, 28, 1,
/*N6=84*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 42, 42,
/*N7=98*/ 1, 1, 1, 1, 1, 1, 1, 1, 1, 42, 1, 1, 1, 1
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13*/
};
# endif
#endif /* EBCDIC 037 */
#endif /* PERL_EBCDIC_TABLES_H_ */
/* ex: set ro ft=c: */

2233
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embed.h Normal file
View file

File diff suppressed because it is too large Load diff

370
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/embedvar.h Normal file
View file

@ -0,0 +1,370 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* embedvar.h
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
* 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
* 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022
* by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/embed.pl from embed.fnc, intrpvar.h,
* perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and
* regen/HeaderParser.pm.
* Any changes made here will be lost!
*
* Edit those files and run 'make regen_headers' to effect changes.
*/
#if defined(MULTIPLICITY)
# define vTHX aTHX
# define PL_AboveLatin1 (vTHX->IAboveLatin1)
# define PL_an (vTHX->Ian)
# define PL_argvgv (vTHX->Iargvgv)
# define PL_argvout_stack (vTHX->Iargvout_stack)
# define PL_argvoutgv (vTHX->Iargvoutgv)
# define PL_Assigned_invlist (vTHX->IAssigned_invlist)
# define PL_basetime (vTHX->Ibasetime)
# define PL_beginav (vTHX->Ibeginav)
# define PL_beginav_save (vTHX->Ibeginav_save)
# define PL_blockhooks (vTHX->Iblockhooks)
# define PL_body_arenas (vTHX->Ibody_arenas)
# define PL_body_roots (vTHX->Ibody_roots)
# define PL_bodytarget (vTHX->Ibodytarget)
# define PL_breakable_sub_gen (vTHX->Ibreakable_sub_gen)
# define PL_CCC_non0_non230 (vTHX->ICCC_non0_non230)
# define PL_checkav (vTHX->Icheckav)
# define PL_checkav_save (vTHX->Icheckav_save)
# define PL_chopset (vTHX->Ichopset)
# define PL_clocktick (vTHX->Iclocktick)
# define PL_collation_ix (vTHX->Icollation_ix)
# define PL_collation_name (vTHX->Icollation_name)
# define PL_collation_standard (vTHX->Icollation_standard)
# define PL_collxfrm_base (vTHX->Icollxfrm_base)
# define PL_collxfrm_mult (vTHX->Icollxfrm_mult)
# define PL_colors (vTHX->Icolors)
# define PL_colorset (vTHX->Icolorset)
# define PL_compcv (vTHX->Icompcv)
# define PL_compiling (vTHX->Icompiling)
# define PL_comppad (vTHX->Icomppad)
# define PL_comppad_name (vTHX->Icomppad_name)
# define PL_comppad_name_fill (vTHX->Icomppad_name_fill)
# define PL_comppad_name_floor (vTHX->Icomppad_name_floor)
# define PL_constpadix (vTHX->Iconstpadix)
# define PL_cop_seqmax (vTHX->Icop_seqmax)
# define PL_ctype_name (vTHX->Ictype_name)
# define PL_cur_LC_ALL (vTHX->Icur_LC_ALL)
# define PL_cur_locale_obj (vTHX->Icur_locale_obj)
# define PL_curcop (vTHX->Icurcop)
# define PL_curcopdb (vTHX->Icurcopdb)
# define PL_curlocales (vTHX->Icurlocales)
# define PL_curpad (vTHX->Icurpad)
# define PL_curpm (vTHX->Icurpm)
# define PL_curpm_under (vTHX->Icurpm_under)
# define PL_curstack (vTHX->Icurstack)
# define PL_curstackinfo (vTHX->Icurstackinfo)
# define PL_curstash (vTHX->Icurstash)
# define PL_curstname (vTHX->Icurstname)
# define PL_custom_op_descs (vTHX->Icustom_op_descs)
# define PL_custom_op_names (vTHX->Icustom_op_names)
# define PL_custom_ops (vTHX->Icustom_ops)
# define PL_cv_has_eval (vTHX->Icv_has_eval)
# define PL_dbargs (vTHX->Idbargs)
# define PL_DBcontrol (vTHX->IDBcontrol)
# define PL_DBcv (vTHX->IDBcv)
# define PL_DBgv (vTHX->IDBgv)
# define PL_DBline (vTHX->IDBline)
# define PL_DBsignal (vTHX->IDBsignal)
# define PL_DBsingle (vTHX->IDBsingle)
# define PL_DBsub (vTHX->IDBsub)
# define PL_DBtrace (vTHX->IDBtrace)
# define PL_debstash (vTHX->Idebstash)
# define PL_debug (vTHX->Idebug)
# define PL_debug_pad (vTHX->Idebug_pad)
# define PL_def_layerlist (vTHX->Idef_layerlist)
# define PL_defgv (vTHX->Idefgv)
# define PL_defoutgv (vTHX->Idefoutgv)
# define PL_defstash (vTHX->Idefstash)
# define PL_delaymagic (vTHX->Idelaymagic)
# define PL_delaymagic_egid (vTHX->Idelaymagic_egid)
# define PL_delaymagic_euid (vTHX->Idelaymagic_euid)
# define PL_delaymagic_gid (vTHX->Idelaymagic_gid)
# define PL_delaymagic_uid (vTHX->Idelaymagic_uid)
# define PL_destroyhook (vTHX->Idestroyhook)
# define PL_diehook (vTHX->Idiehook)
# define PL_Dir (vTHX->IDir)
# define PL_doswitches (vTHX->Idoswitches)
# define PL_dowarn (vTHX->Idowarn)
# define PL_dump_re_max_len (vTHX->Idump_re_max_len)
# define PL_dumper_fd (vTHX->Idumper_fd)
# define PL_dumpindent (vTHX->Idumpindent)
# define PL_e_script (vTHX->Ie_script)
# define PL_efloatbuf (vTHX->Iefloatbuf)
# define PL_efloatsize (vTHX->Iefloatsize)
# define PL_endav (vTHX->Iendav)
# define PL_Env (vTHX->IEnv)
# define PL_envgv (vTHX->Ienvgv)
# define PL_errgv (vTHX->Ierrgv)
# define PL_errors (vTHX->Ierrors)
# define PL_eval_begin_nest_depth (vTHX->Ieval_begin_nest_depth)
# define PL_eval_root (vTHX->Ieval_root)
# define PL_eval_start (vTHX->Ieval_start)
# define PL_evalseq (vTHX->Ievalseq)
# define PL_exit_flags (vTHX->Iexit_flags)
# define PL_exitlist (vTHX->Iexitlist)
# define PL_exitlistlen (vTHX->Iexitlistlen)
# define PL_fdpid (vTHX->Ifdpid)
# define PL_filemode (vTHX->Ifilemode)
# define PL_firstgv (vTHX->Ifirstgv)
# define PL_fold_locale (vTHX->Ifold_locale)
# define PL_forkprocess (vTHX->Iforkprocess)
# define PL_formtarget (vTHX->Iformtarget)
# define PL_GCB_invlist (vTHX->IGCB_invlist)
# define PL_generation (vTHX->Igeneration)
# define PL_gensym (vTHX->Igensym)
# define PL_globalstash (vTHX->Iglobalstash)
# define PL_globhook (vTHX->Iglobhook)
# define PL_hash_rand_bits (vTHX->Ihash_rand_bits)
# define PL_hash_rand_bits_enabled (vTHX->Ihash_rand_bits_enabled)
# define PL_HasMultiCharFold (vTHX->IHasMultiCharFold)
# define PL_hintgv (vTHX->Ihintgv)
# define PL_hook__require__after (vTHX->Ihook__require__after)
# define PL_hook__require__before (vTHX->Ihook__require__before)
# define PL_hv_fetch_ent_mh (vTHX->Ihv_fetch_ent_mh)
# define PL_in_clean_all (vTHX->Iin_clean_all)
# define PL_in_clean_objs (vTHX->Iin_clean_objs)
# define PL_in_eval (vTHX->Iin_eval)
# define PL_in_load_module (vTHX->Iin_load_module)
# define PL_in_some_fold (vTHX->Iin_some_fold)
# define PL_in_utf8_COLLATE_locale (vTHX->Iin_utf8_COLLATE_locale)
# define PL_in_utf8_CTYPE_locale (vTHX->Iin_utf8_CTYPE_locale)
# define PL_in_utf8_turkic_locale (vTHX->Iin_utf8_turkic_locale)
# define PL_InBitmap (vTHX->IInBitmap)
# define PL_incgv (vTHX->Iincgv)
# define PL_initav (vTHX->Iinitav)
# define PL_InMultiCharFold (vTHX->IInMultiCharFold)
# define PL_inplace (vTHX->Iinplace)
# define PL_internal_random_state (vTHX->Iinternal_random_state)
# define PL_isarev (vTHX->Iisarev)
# define PL_known_layers (vTHX->Iknown_layers)
# define PL_langinfo_sv (vTHX->Ilanginfo_sv)
# define PL_last_in_gv (vTHX->Ilast_in_gv)
# define PL_lastfd (vTHX->Ilastfd)
# define PL_lastgotoprobe (vTHX->Ilastgotoprobe)
# define PL_laststatval (vTHX->Ilaststatval)
# define PL_laststype (vTHX->Ilaststype)
# define PL_Latin1 (vTHX->ILatin1)
# define PL_LB_invlist (vTHX->ILB_invlist)
# define PL_less_dicey_locale_buf (vTHX->Iless_dicey_locale_buf)
# define PL_less_dicey_locale_bufsize (vTHX->Iless_dicey_locale_bufsize)
# define PL_LIO (vTHX->ILIO)
# define PL_locale_mutex_depth (vTHX->Ilocale_mutex_depth)
# define PL_localizing (vTHX->Ilocalizing)
# define PL_localpatches (vTHX->Ilocalpatches)
# define PL_lockhook (vTHX->Ilockhook)
# define PL_main_cv (vTHX->Imain_cv)
# define PL_main_root (vTHX->Imain_root)
# define PL_main_start (vTHX->Imain_start)
# define PL_mainstack (vTHX->Imainstack)
# define PL_markstack (vTHX->Imarkstack)
# define PL_markstack_max (vTHX->Imarkstack_max)
# define PL_markstack_ptr (vTHX->Imarkstack_ptr)
# define PL_max_intro_pending (vTHX->Imax_intro_pending)
# define PL_maxsysfd (vTHX->Imaxsysfd)
# define PL_mbrlen_ps (vTHX->Imbrlen_ps)
# define PL_mbrtowc_ps (vTHX->Imbrtowc_ps)
# define PL_Mem (vTHX->IMem)
# define PL_mem_log (vTHX->Imem_log)
# define PL_memory_debug_header (vTHX->Imemory_debug_header)
# define PL_MemParse (vTHX->IMemParse)
# define PL_MemShared (vTHX->IMemShared)
# define PL_mess_sv (vTHX->Imess_sv)
# define PL_min_intro_pending (vTHX->Imin_intro_pending)
# define PL_minus_a (vTHX->Iminus_a)
# define PL_minus_c (vTHX->Iminus_c)
# define PL_minus_E (vTHX->Iminus_E)
# define PL_minus_F (vTHX->Iminus_F)
# define PL_minus_l (vTHX->Iminus_l)
# define PL_minus_n (vTHX->Iminus_n)
# define PL_minus_p (vTHX->Iminus_p)
# define PL_modcount (vTHX->Imodcount)
# define PL_modglobal (vTHX->Imodglobal)
# define PL_multideref_pc (vTHX->Imultideref_pc)
# define PL_my_cxt_list (vTHX->Imy_cxt_list)
# define PL_my_cxt_size (vTHX->Imy_cxt_size)
# define PL_na (vTHX->Ina)
# define PL_nomemok (vTHX->Inomemok)
# define PL_numeric_name (vTHX->Inumeric_name)
# define PL_numeric_radix_sv (vTHX->Inumeric_radix_sv)
# define PL_numeric_standard (vTHX->Inumeric_standard)
# define PL_numeric_underlying (vTHX->Inumeric_underlying)
# define PL_numeric_underlying_is_standard (vTHX->Inumeric_underlying_is_standard)
# define PL_ofsgv (vTHX->Iofsgv)
# define PL_oldname (vTHX->Ioldname)
# define PL_op (vTHX->Iop)
# define PL_op_exec_cnt (vTHX->Iop_exec_cnt)
# define PL_op_mask (vTHX->Iop_mask)
# define PL_opfreehook (vTHX->Iopfreehook)
# define PL_origalen (vTHX->Iorigalen)
# define PL_origargc (vTHX->Iorigargc)
# define PL_origargv (vTHX->Iorigargv)
# define PL_origfilename (vTHX->Iorigfilename)
# define PL_ors_sv (vTHX->Iors_sv)
# define PL_osname (vTHX->Iosname)
# define PL_pad_reset_pending (vTHX->Ipad_reset_pending)
# define PL_padix (vTHX->Ipadix)
# define PL_padix_floor (vTHX->Ipadix_floor)
# define PL_padlist_generation (vTHX->Ipadlist_generation)
# define PL_padname_const (vTHX->Ipadname_const)
# define PL_padname_undef (vTHX->Ipadname_undef)
# define PL_parser (vTHX->Iparser)
# define PL_patchlevel (vTHX->Ipatchlevel)
# define PL_peepp (vTHX->Ipeepp)
# define PL_perl_destruct_level (vTHX->Iperl_destruct_level)
# define PL_perldb (vTHX->Iperldb)
# define PL_perlio (vTHX->Iperlio)
# define PL_phase (vTHX->Iphase)
# define PL_pidstatus (vTHX->Ipidstatus)
# define PL_Posix_ptrs (vTHX->IPosix_ptrs)
# define PL_preambleav (vTHX->Ipreambleav)
# define PL_prevailing_version (vTHX->Iprevailing_version)
# define PL_Private_Use (vTHX->IPrivate_Use)
# define PL_Proc (vTHX->IProc)
# define PL_profiledata (vTHX->Iprofiledata)
# define PL_psig_name (vTHX->Ipsig_name)
# define PL_psig_pend (vTHX->Ipsig_pend)
# define PL_psig_ptr (vTHX->Ipsig_ptr)
# define PL_ptr_table (vTHX->Iptr_table)
# define PL_random_state (vTHX->Irandom_state)
# define PL_reentrant_buffer (vTHX->Ireentrant_buffer)
# define PL_reentrant_retint (vTHX->Ireentrant_retint)
# define PL_reg_curpm (vTHX->Ireg_curpm)
# define PL_regex_pad (vTHX->Iregex_pad)
# define PL_regex_padav (vTHX->Iregex_padav)
# define PL_registered_mros (vTHX->Iregistered_mros)
# define PL_regmatch_slab (vTHX->Iregmatch_slab)
# define PL_regmatch_state (vTHX->Iregmatch_state)
# define PL_replgv (vTHX->Ireplgv)
# define PL_restartjmpenv (vTHX->Irestartjmpenv)
# define PL_restartop (vTHX->Irestartop)
# define PL_rpeepp (vTHX->Irpeepp)
# define PL_rs (vTHX->Irs)
# define PL_runops (vTHX->Irunops)
# define PL_savebegin (vTHX->Isavebegin)
# define PL_savestack (vTHX->Isavestack)
# define PL_savestack_ix (vTHX->Isavestack_ix)
# define PL_savestack_max (vTHX->Isavestack_max)
# define PL_SB_invlist (vTHX->ISB_invlist)
# define PL_scopestack (vTHX->Iscopestack)
# define PL_scopestack_ix (vTHX->Iscopestack_ix)
# define PL_scopestack_max (vTHX->Iscopestack_max)
# define PL_scopestack_name (vTHX->Iscopestack_name)
# define PL_scratch_langinfo (vTHX->Iscratch_langinfo)
# define PL_scratch_locale_obj (vTHX->Iscratch_locale_obj)
# define PL_SCX_invlist (vTHX->ISCX_invlist)
# define PL_secondgv (vTHX->Isecondgv)
# define PL_setlocale_buf (vTHX->Isetlocale_buf)
# define PL_setlocale_bufsize (vTHX->Isetlocale_bufsize)
# define PL_sharehook (vTHX->Isharehook)
# define PL_sig_pending (vTHX->Isig_pending)
# define PL_sighandler1p (vTHX->Isighandler1p)
# define PL_sighandler3p (vTHX->Isighandler3p)
# define PL_sighandlerp (vTHX->Isighandlerp)
# define PL_signalhook (vTHX->Isignalhook)
# define PL_signals (vTHX->Isignals)
# define PL_Sock (vTHX->ISock)
# define PL_sortcop (vTHX->Isortcop)
# define PL_sortstash (vTHX->Isortstash)
# define PL_splitstr (vTHX->Isplitstr)
# define PL_srand_called (vTHX->Isrand_called)
# define PL_srand_override (vTHX->Isrand_override)
# define PL_srand_override_next (vTHX->Isrand_override_next)
# define PL_stack_base (vTHX->Istack_base)
# define PL_stack_max (vTHX->Istack_max)
# define PL_stack_sp (vTHX->Istack_sp)
# define PL_start_env (vTHX->Istart_env)
# define PL_stashcache (vTHX->Istashcache)
# define PL_stashpad (vTHX->Istashpad)
# define PL_stashpadix (vTHX->Istashpadix)
# define PL_stashpadmax (vTHX->Istashpadmax)
# define PL_statcache (vTHX->Istatcache)
# define PL_statgv (vTHX->Istatgv)
# define PL_statname (vTHX->Istatname)
# define PL_statusvalue (vTHX->Istatusvalue)
# define PL_statusvalue_posix (vTHX->Istatusvalue_posix)
# define PL_statusvalue_vms (vTHX->Istatusvalue_vms)
# define PL_stderrgv (vTHX->Istderrgv)
# define PL_stdingv (vTHX->Istdingv)
# define PL_StdIO (vTHX->IStdIO)
# define PL_strtab (vTHX->Istrtab)
# define PL_strxfrm_is_behaved (vTHX->Istrxfrm_is_behaved)
# define PL_strxfrm_max_cp (vTHX->Istrxfrm_max_cp)
# define PL_strxfrm_NUL_replacement (vTHX->Istrxfrm_NUL_replacement)
# define PL_sub_generation (vTHX->Isub_generation)
# define PL_subline (vTHX->Isubline)
# define PL_subname (vTHX->Isubname)
# define PL_Sv (vTHX->ISv)
# define PL_sv_arenaroot (vTHX->Isv_arenaroot)
# define PL_sv_consts (vTHX->Isv_consts)
# define PL_sv_count (vTHX->Isv_count)
# define PL_sv_immortals (vTHX->Isv_immortals)
# define PL_sv_no (vTHX->Isv_no)
# define PL_sv_root (vTHX->Isv_root)
# define PL_sv_serial (vTHX->Isv_serial)
# define PL_sv_undef (vTHX->Isv_undef)
# define PL_sv_yes (vTHX->Isv_yes)
# define PL_sv_zero (vTHX->Isv_zero)
# define PL_sys_intern (vTHX->Isys_intern)
# define PL_taint_warn (vTHX->Itaint_warn)
# define PL_tainted (vTHX->Itainted)
# define PL_tainting (vTHX->Itainting)
# define PL_threadhook (vTHX->Ithreadhook)
# define PL_tmps_floor (vTHX->Itmps_floor)
# define PL_tmps_ix (vTHX->Itmps_ix)
# define PL_tmps_max (vTHX->Itmps_max)
# define PL_tmps_stack (vTHX->Itmps_stack)
# define PL_top_env (vTHX->Itop_env)
# define PL_toptarget (vTHX->Itoptarget)
# define PL_TR_SPECIAL_HANDLING_UTF8 (vTHX->ITR_SPECIAL_HANDLING_UTF8)
# define PL_underlying_radix_sv (vTHX->Iunderlying_radix_sv)
# define PL_unicode (vTHX->Iunicode)
# define PL_unitcheckav (vTHX->Iunitcheckav)
# define PL_unitcheckav_save (vTHX->Iunitcheckav_save)
# define PL_unlockhook (vTHX->Iunlockhook)
# define PL_unsafe (vTHX->Iunsafe)
# define PL_UpperLatin1 (vTHX->IUpperLatin1)
# define PL_utf8_charname_begin (vTHX->Iutf8_charname_begin)
# define PL_utf8_charname_continue (vTHX->Iutf8_charname_continue)
# define PL_utf8_foldclosures (vTHX->Iutf8_foldclosures)
# define PL_utf8_idcont (vTHX->Iutf8_idcont)
# define PL_utf8_idstart (vTHX->Iutf8_idstart)
# define PL_utf8_mark (vTHX->Iutf8_mark)
# define PL_utf8_perl_idcont (vTHX->Iutf8_perl_idcont)
# define PL_utf8_perl_idstart (vTHX->Iutf8_perl_idstart)
# define PL_utf8_tofold (vTHX->Iutf8_tofold)
# define PL_utf8_tolower (vTHX->Iutf8_tolower)
# define PL_utf8_tosimplefold (vTHX->Iutf8_tosimplefold)
# define PL_utf8_totitle (vTHX->Iutf8_totitle)
# define PL_utf8_toupper (vTHX->Iutf8_toupper)
# define PL_utf8_xidcont (vTHX->Iutf8_xidcont)
# define PL_utf8_xidstart (vTHX->Iutf8_xidstart)
# define PL_utf8cache (vTHX->Iutf8cache)
# define PL_utf8locale (vTHX->Iutf8locale)
# define PL_warn_locale (vTHX->Iwarn_locale)
# define PL_warnhook (vTHX->Iwarnhook)
# define PL_watchaddr (vTHX->Iwatchaddr)
# define PL_watchok (vTHX->Iwatchok)
# define PL_WB_invlist (vTHX->IWB_invlist)
# define PL_wcrtomb_ps (vTHX->Iwcrtomb_ps)
# define PL_XPosix_ptrs (vTHX->IXPosix_ptrs)
# define PL_Xpv (vTHX->IXpv)
# define PL_xsubfilename (vTHX->Ixsubfilename)
# if !defined(PL_sawampersand)
# define PL_sawampersand (vTHX->Isawampersand)
# endif
#endif /* defined(MULTIPLICITY) */
/* ex: set ro ft=c: */

127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/fakesdio.h Normal file
View file

@ -0,0 +1,127 @@
/* fakesdio.h
*
* Copyright (C) 2000, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* This is "source level" stdio compatibility mode.
* We try and #define stdio functions in terms of PerlIO.
*/
#define _CANNOT "CANNOT"
#undef FILE
#define FILE PerlIO
#undef clearerr
#undef fclose
#undef fdopen
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fileno
#undef flockfile
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef ftrylockfile
#undef funlockfile
#undef fwrite
#undef getc
#undef getc_unlocked
#undef getw
#undef pclose
#undef popen
#undef putc
#undef putc_unlocked
#undef putw
#undef rewind
#undef setbuf
#undef setvbuf
#undef stderr
#undef stdin
#undef stdout
#undef tmpfile
#undef ungetc
#undef vfprintf
#undef printf
/* printf used to live in perl.h like this - more sophisticated
than the rest
*/
#if defined(__GNUC__) && !defined(__STRICT_ANSI__) && !defined(PERL_GCC_PEDANTIC)
#define printf(fmt,args...) PerlIO_stdoutf(fmt,##args)
#else
#define printf PerlIO_stdoutf
#endif
#define fprintf PerlIO_printf
#define stdin PerlIO_stdin()
#define stdout PerlIO_stdout()
#define stderr PerlIO_stderr()
#define tmpfile() PerlIO_tmpfile()
#define fclose(f) PerlIO_close(f)
#define fflush(f) PerlIO_flush(f)
#define fopen(p,m) PerlIO_open(p,m)
#define vfprintf(f,fmt,a) PerlIO_vprintf(f,fmt,a)
#define fgetc(f) PerlIO_getc(f)
#define fputc(c,f) PerlIO_putc(f,c)
#define fputs(s,f) PerlIO_puts(f,s)
#define getc(f) PerlIO_getc(f)
#define getc_unlocked(f) PerlIO_getc(f)
#define putc(c,f) PerlIO_putc(f,c)
#define putc_unlocked(c,f) PerlIO_putc(c,f)
#define ungetc(c,f) PerlIO_ungetc(f,c)
#if 0
/* return values of read/write need work */
#define fread(b,s,c,f) PerlIO_read(f,b,(s*c))
#define fwrite(b,s,c,f) PerlIO_write(f,b,(s*c))
#else
#define fread(b,s,c,f) _CANNOT fread
#define fwrite(b,s,c,f) _CANNOT fwrite
#endif
#define fseek(f,o,w) PerlIO_seek(f,o,w)
#define ftell(f) PerlIO_tell(f)
#define rewind(f) PerlIO_rewind(f)
#define clearerr(f) PerlIO_clearerr(f)
#define feof(f) PerlIO_eof(f)
#define ferror(f) PerlIO_error(f)
#define fdopen(fd,p) PerlIO_fdopen(fd,p)
#define fileno(f) PerlIO_fileno(f)
#define popen(c,m) my_popen(c,m)
#define pclose(f) my_pclose(f)
#define fsetpos(f,p) _CANNOT _fsetpos_
#define fgetpos(f,p) _CANNOT _fgetpos_
#define __filbuf(f) _CANNOT __filbuf_
#define _filbuf(f) _CANNOT _filbuf_
#define __flsbuf(c,f) _CANNOT __flsbuf_
#define _flsbuf(c,f) _CANNOT _flsbuf_
#define getw(f) _CANNOT _getw_
#define putw(v,f) _CANNOT _putw_
#if SFIO_VERSION < 20000101L
#define flockfile(f) _CANNOT _flockfile_
#define ftrylockfile(f) _CANNOT _ftrylockfile_
#define funlockfile(f) _CANNOT _funlockfile_
#endif
#define freopen(p,m,f) _CANNOT _freopen_
#define setbuf(f,b) _CANNOT _setbuf_
#define setvbuf(f,b,x,s) _CANNOT _setvbuf_
#define fscanf _CANNOT _fscanf_
#define fgets(s,n,f) _CANNOT _fgets_
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

614
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/feature.h Normal file
View file

@ -0,0 +1,614 @@
/* -*- mode: C; buffer-read-only: t -*-
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
This file is built by regen/feature.pl.
Any changes made here will be lost!
*/
#ifndef PERL_FEATURE_H_
#define PERL_FEATURE_H_
#if defined(PERL_CORE) || defined (PERL_EXT)
#define HINT_FEATURE_SHIFT 26
#define FEATURE_BAREWORD_FILEHANDLES_BIT 0x0001
#define FEATURE_BITWISE_BIT 0x0002
#define FEATURE_CLASS_BIT 0x0004
#define FEATURE___SUB___BIT 0x0008
#define FEATURE_MYREF_BIT 0x0010
#define FEATURE_DEFER_BIT 0x0020
#define FEATURE_EVALBYTES_BIT 0x0040
#define FEATURE_MORE_DELIMS_BIT 0x0080
#define FEATURE_FC_BIT 0x0100
#define FEATURE_INDIRECT_BIT 0x0200
#define FEATURE_ISA_BIT 0x0400
#define FEATURE_MODULE_TRUE_BIT 0x0800
#define FEATURE_MULTIDIMENSIONAL_BIT 0x1000
#define FEATURE_POSTDEREF_QQ_BIT 0x2000
#define FEATURE_REFALIASING_BIT 0x4000
#define FEATURE_SAY_BIT 0x8000
#define FEATURE_SIGNATURES_BIT 0x10000
#define FEATURE_STATE_BIT 0x20000
#define FEATURE_SWITCH_BIT 0x40000
#define FEATURE_TRY_BIT 0x80000
#define FEATURE_UNIEVAL_BIT 0x100000
#define FEATURE_UNICODE_BIT 0x200000
#define FEATURE_BUNDLE_DEFAULT 0
#define FEATURE_BUNDLE_510 1
#define FEATURE_BUNDLE_511 2
#define FEATURE_BUNDLE_515 3
#define FEATURE_BUNDLE_523 4
#define FEATURE_BUNDLE_527 5
#define FEATURE_BUNDLE_535 6
#define FEATURE_BUNDLE_537 7
#define FEATURE_BUNDLE_539 8
#define FEATURE_BUNDLE_CUSTOM (HINT_FEATURE_MASK >> HINT_FEATURE_SHIFT)
/* this is preserved for testing and asserts */
#define OLD_CURRENT_HINTS \
(PL_curcop == &PL_compiling ? PL_hints : PL_curcop->cop_hints)
/* this is the same thing, but simpler (no if) as PL_hints expands
to PL_compiling.cop_hints */
#define CURRENT_HINTS \
PL_curcop->cop_hints
#define CURRENT_FEATURE_BUNDLE \
((CURRENT_HINTS & HINT_FEATURE_MASK) >> HINT_FEATURE_SHIFT)
#define FEATURE_IS_ENABLED_MASK(mask) \
((CURRENT_HINTS & HINT_LOCALIZE_HH) \
? (PL_curcop->cop_features & (mask)) : FALSE)
/* The longest string we pass in. */
#define MAX_FEATURE_LEN (sizeof("bareword_filehandles")-1)
#define FEATURE_FC_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_FC_BIT)) \
)
#define FEATURE_ISA_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_535 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_ISA_BIT)) \
)
#define FEATURE_SAY_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_SAY_BIT)) \
)
#define FEATURE_TRY_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_539 \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_TRY_BIT)) \
)
#define FEATURE_CLASS_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_CLASS_BIT) \
)
#define FEATURE_DEFER_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_DEFER_BIT) \
)
#define FEATURE_STATE_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_STATE_BIT)) \
)
#define FEATURE_SWITCH_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_510 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_SWITCH_BIT)) \
)
#define FEATURE_BITWISE_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_527 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_BITWISE_BIT)) \
)
#define FEATURE_INDIRECT_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_INDIRECT_BIT)) \
)
#define FEATURE_EVALBYTES_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_EVALBYTES_BIT)) \
)
#define FEATURE_SIGNATURES_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_535 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_SIGNATURES_BIT)) \
)
#define FEATURE___SUB___IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE___SUB___BIT)) \
)
#define FEATURE_MODULE_TRUE_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_537 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_MODULE_TRUE_BIT)) \
)
#define FEATURE_REFALIASING_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_REFALIASING_BIT) \
)
#define FEATURE_POSTDEREF_QQ_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_523 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_POSTDEREF_QQ_BIT)) \
)
#define FEATURE_UNIEVAL_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_515 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_UNIEVAL_BIT)) \
)
#define FEATURE_MYREF_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_MYREF_BIT) \
)
#define FEATURE_UNICODE_IS_ENABLED \
( \
(CURRENT_FEATURE_BUNDLE >= FEATURE_BUNDLE_511 && \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_539) \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_UNICODE_BIT)) \
)
#define FEATURE_MULTIDIMENSIONAL_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_527 \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_MULTIDIMENSIONAL_BIT)) \
)
#define FEATURE_BAREWORD_FILEHANDLES_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE <= FEATURE_BUNDLE_535 \
|| (CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_BAREWORD_FILEHANDLES_BIT)) \
)
#define FEATURE_MORE_DELIMS_IS_ENABLED \
( \
CURRENT_FEATURE_BUNDLE == FEATURE_BUNDLE_CUSTOM && \
FEATURE_IS_ENABLED_MASK(FEATURE_MORE_DELIMS_BIT) \
)
#define SAVEFEATUREBITS() SAVEI32(PL_compiling.cop_features)
#define CLEARFEATUREBITS() (PL_compiling.cop_features = 0)
#define FETCHFEATUREBITSHH(hh) S_fetch_feature_bits_hh(aTHX_ (hh))
#endif /* PERL_CORE or PERL_EXT */
#ifdef PERL_IN_OP_C
PERL_STATIC_INLINE void
S_enable_feature_bundle(pTHX_ SV *ver)
{
SV *comp_ver = sv_newmortal();
PL_hints = (PL_hints &~ HINT_FEATURE_MASK)
| (
(sv_setnv(comp_ver, 5.039),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_539 :
(sv_setnv(comp_ver, 5.037),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_537 :
(sv_setnv(comp_ver, 5.035),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_535 :
(sv_setnv(comp_ver, 5.027),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_527 :
(sv_setnv(comp_ver, 5.023),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_523 :
(sv_setnv(comp_ver, 5.015),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_515 :
(sv_setnv(comp_ver, 5.011),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_511 :
(sv_setnv(comp_ver, 5.009005),
vcmp(ver, upg_version(comp_ver, FALSE)) >= 0)
? FEATURE_BUNDLE_510 :
FEATURE_BUNDLE_DEFAULT
) << HINT_FEATURE_SHIFT;
/* special case */
assert(PL_curcop == &PL_compiling);
if (FEATURE_UNICODE_IS_ENABLED) PL_hints |= HINT_UNI_8_BIT;
else PL_hints &= ~HINT_UNI_8_BIT;
}
#endif /* PERL_IN_OP_C */
#if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_CTL_C)
#define magic_sethint_feature(keysv, keypv, keylen, valsv, valbool) \
S_magic_sethint_feature(aTHX_ (keysv), (keypv), (keylen), (valsv), (valbool))
PERL_STATIC_INLINE void
S_magic_sethint_feature(pTHX_ SV *keysv, const char *keypv, STRLEN keylen,
SV *valsv, bool valbool) {
if (keysv)
keypv = SvPV_const(keysv, keylen);
if (memBEGINs(keypv, keylen, "feature_")) {
const char *subf = keypv + (sizeof("feature_")-1);
U32 mask = 0;
switch (*subf) {
case '_':
if (keylen == sizeof("feature___SUB__")-1
&& memcmp(subf+1, "_SUB__", keylen - sizeof("feature_")) == 0) {
mask = FEATURE___SUB___BIT;
break;
}
return;
case 'b':
if (keylen == sizeof("feature_bareword_filehandles")-1
&& memcmp(subf+1, "areword_filehandles", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_BAREWORD_FILEHANDLES_BIT;
break;
}
else if (keylen == sizeof("feature_bitwise")-1
&& memcmp(subf+1, "itwise", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_BITWISE_BIT;
break;
}
return;
case 'c':
if (keylen == sizeof("feature_class")-1
&& memcmp(subf+1, "lass", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_CLASS_BIT;
break;
}
return;
case 'd':
if (keylen == sizeof("feature_defer")-1
&& memcmp(subf+1, "efer", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_DEFER_BIT;
break;
}
return;
case 'e':
if (keylen == sizeof("feature_evalbytes")-1
&& memcmp(subf+1, "valbytes", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_EVALBYTES_BIT;
break;
}
return;
case 'f':
if (keylen == sizeof("feature_fc")-1
&& memcmp(subf+1, "c", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_FC_BIT;
break;
}
return;
case 'i':
if (keylen == sizeof("feature_indirect")-1
&& memcmp(subf+1, "ndirect", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_INDIRECT_BIT;
break;
}
else if (keylen == sizeof("feature_isa")-1
&& memcmp(subf+1, "sa", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_ISA_BIT;
break;
}
return;
case 'm':
if (keylen == sizeof("feature_module_true")-1
&& memcmp(subf+1, "odule_true", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_MODULE_TRUE_BIT;
break;
}
else if (keylen == sizeof("feature_more_delims")-1
&& memcmp(subf+1, "ore_delims", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_MORE_DELIMS_BIT;
break;
}
else if (keylen == sizeof("feature_multidimensional")-1
&& memcmp(subf+1, "ultidimensional", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_MULTIDIMENSIONAL_BIT;
break;
}
else if (keylen == sizeof("feature_myref")-1
&& memcmp(subf+1, "yref", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_MYREF_BIT;
break;
}
return;
case 'p':
if (keylen == sizeof("feature_postderef_qq")-1
&& memcmp(subf+1, "ostderef_qq", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_POSTDEREF_QQ_BIT;
break;
}
return;
case 'r':
if (keylen == sizeof("feature_refaliasing")-1
&& memcmp(subf+1, "efaliasing", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_REFALIASING_BIT;
break;
}
return;
case 's':
if (keylen == sizeof("feature_say")-1
&& memcmp(subf+1, "ay", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_SAY_BIT;
break;
}
else if (keylen == sizeof("feature_signatures")-1
&& memcmp(subf+1, "ignatures", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_SIGNATURES_BIT;
break;
}
else if (keylen == sizeof("feature_state")-1
&& memcmp(subf+1, "tate", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_STATE_BIT;
break;
}
else if (keylen == sizeof("feature_switch")-1
&& memcmp(subf+1, "witch", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_SWITCH_BIT;
break;
}
return;
case 't':
if (keylen == sizeof("feature_try")-1
&& memcmp(subf+1, "ry", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_TRY_BIT;
break;
}
return;
case 'u':
if (keylen == sizeof("feature_unicode")-1
&& memcmp(subf+1, "nicode", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_UNICODE_BIT;
break;
}
else if (keylen == sizeof("feature_unieval")-1
&& memcmp(subf+1, "nieval", keylen - sizeof("feature_")) == 0) {
mask = FEATURE_UNIEVAL_BIT;
break;
}
return;
default:
return;
}
if (valsv ? SvTRUE(valsv) : valbool)
PL_compiling.cop_features |= mask;
else
PL_compiling.cop_features &= ~mask;
}
}
#endif /* PERL_IN_MG_C */
/* subject to change */
struct perl_feature_bit {
const char *name;
STRLEN namelen;
U32 mask;
};
#ifdef PERL_IN_PP_CTL_C
static const struct perl_feature_bit
PL_feature_bits[] = {
{
/* feature bareword_filehandles */
"feature_bareword_filehandles",
STRLENs("feature_bareword_filehandles"),
FEATURE_BAREWORD_FILEHANDLES_BIT
},
{
/* feature bitwise */
"feature_bitwise",
STRLENs("feature_bitwise"),
FEATURE_BITWISE_BIT
},
{
/* feature class */
"feature_class",
STRLENs("feature_class"),
FEATURE_CLASS_BIT
},
{
/* feature current_sub */
"feature___SUB__",
STRLENs("feature___SUB__"),
FEATURE___SUB___BIT
},
{
/* feature declared_refs */
"feature_myref",
STRLENs("feature_myref"),
FEATURE_MYREF_BIT
},
{
/* feature defer */
"feature_defer",
STRLENs("feature_defer"),
FEATURE_DEFER_BIT
},
{
/* feature evalbytes */
"feature_evalbytes",
STRLENs("feature_evalbytes"),
FEATURE_EVALBYTES_BIT
},
{
/* feature extra_paired_delimiters */
"feature_more_delims",
STRLENs("feature_more_delims"),
FEATURE_MORE_DELIMS_BIT
},
{
/* feature fc */
"feature_fc",
STRLENs("feature_fc"),
FEATURE_FC_BIT
},
{
/* feature indirect */
"feature_indirect",
STRLENs("feature_indirect"),
FEATURE_INDIRECT_BIT
},
{
/* feature isa */
"feature_isa",
STRLENs("feature_isa"),
FEATURE_ISA_BIT
},
{
/* feature module_true */
"feature_module_true",
STRLENs("feature_module_true"),
FEATURE_MODULE_TRUE_BIT
},
{
/* feature multidimensional */
"feature_multidimensional",
STRLENs("feature_multidimensional"),
FEATURE_MULTIDIMENSIONAL_BIT
},
{
/* feature postderef_qq */
"feature_postderef_qq",
STRLENs("feature_postderef_qq"),
FEATURE_POSTDEREF_QQ_BIT
},
{
/* feature refaliasing */
"feature_refaliasing",
STRLENs("feature_refaliasing"),
FEATURE_REFALIASING_BIT
},
{
/* feature say */
"feature_say",
STRLENs("feature_say"),
FEATURE_SAY_BIT
},
{
/* feature signatures */
"feature_signatures",
STRLENs("feature_signatures"),
FEATURE_SIGNATURES_BIT
},
{
/* feature state */
"feature_state",
STRLENs("feature_state"),
FEATURE_STATE_BIT
},
{
/* feature switch */
"feature_switch",
STRLENs("feature_switch"),
FEATURE_SWITCH_BIT
},
{
/* feature try */
"feature_try",
STRLENs("feature_try"),
FEATURE_TRY_BIT
},
{
/* feature unicode_eval */
"feature_unieval",
STRLENs("feature_unieval"),
FEATURE_UNIEVAL_BIT
},
{
/* feature unicode_strings */
"feature_unicode",
STRLENs("feature_unicode"),
FEATURE_UNICODE_BIT
},
{ NULL, 0, 0U }
};
PERL_STATIC_INLINE void
S_fetch_feature_bits_hh(pTHX_ HV *hh) {
PL_compiling.cop_features = 0;
const struct perl_feature_bit *fb = PL_feature_bits;
while (fb->name) {
SV **svp = hv_fetch(hh, fb->name, (I32)fb->namelen, 0);
if (svp && SvTRUE(*svp))
PL_compiling.cop_features |= fb->mask;
++fb;
}
}
#endif
#endif /* PERL_FEATURE_H_ */
/* ex: set ro ft=c: */

27
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/form.h Normal file
View file

@ -0,0 +1,27 @@
/* form.h
*
* Copyright (C) 1991, 1992, 1993, 2000, 2004, 2011 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#define FF_END 0 /* tidy up, then return */
#define FF_LINEMARK 1 /* start (or end) of a line */
#define FF_LITERAL 2 /* append <arg> literal chars */
#define FF_SKIP 3 /* skip <arg> chars in format */
#define FF_FETCH 4 /* get next item and set field size to <arg> */
#define FF_CHECKNL 5 /* find max len of item (up to \n) that fits field */
#define FF_CHECKCHOP 6 /* like CHECKNL, but up to highest split point */
#define FF_SPACE 7 /* append padding space (diff of field, item size) */
#define FF_HALFSPACE 8 /* like FF_SPACE, but only append half as many */
#define FF_ITEM 9 /* append a text item, while blanking ctrl chars */
#define FF_CHOP 10 /* (for ^*) chop the current item */
#define FF_LINEGLOB 11 /* process @* */
#define FF_DECIMAL 12 /* do @##, ^##, where <arg>=(precision|flags) */
#define FF_NEWLINE 13 /* delete trailing spaces, then append \n */
#define FF_BLANK 14 /* for arg==0: do '~'; for arg>0 : do '~~' */
#define FF_MORE 15 /* replace long end of string with '...' */
#define FF_0DECIMAL 16 /* like FF_DECIMAL but for 0### */
#define FF_LINESNGL 17 /* process ^* */

8
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/git_version.h Normal file
View file

@ -0,0 +1,8 @@
/**************************************************************************
* WARNING: 'git_version.h' is automatically generated by make_patchnum.pl
* DO NOT EDIT DIRECTLY - edit make_patchnum.pl instead
***************************************************************************/
#define PERL_GIT_UNPUSHED_COMMITS \
/*leave-this-comment*/

326
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/gv.h Normal file
View file

@ -0,0 +1,326 @@
/* gv.h
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
* 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
struct gp {
SV * gp_sv; /* scalar value */
struct io * gp_io; /* filehandle value */
CV * gp_cv; /* subroutine value */
U32 gp_cvgen; /* generational validity of cached gp_cv */
U32 gp_refcnt; /* how many globs point to this? */
HV * gp_hv; /* hash value */
AV * gp_av; /* array value */
CV * gp_form; /* format value */
GV * gp_egv; /* effective gv, if *glob */
PERL_BITFIELD32 gp_line:31; /* line first declared at (for -w) */
PERL_BITFIELD32 gp_flags:1;
HEK * gp_file_hek; /* file first declared in (for -w) */
};
#define GvXPVGV(gv) ((XPVGV*)SvANY(gv))
#if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) && !defined(__INTEL_COMPILER)
# define GvGP(gv) \
((GP *)(*({GV *const _gvgp = (GV *) (gv); \
assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \
assert(isGV_with_GP(_gvgp)); \
&((_gvgp)->sv_u.svu_gp);})))
# define GvGP_set(gv,gp) \
{GV *const _gvgp = (GV *) (gv); \
assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \
assert(isGV_with_GP(_gvgp)); \
(_gvgp)->sv_u.svu_gp = (gp); }
# define GvFLAGS(gv) \
(*({GV *const _gvflags = (GV *) (gv); \
assert(SvTYPE(_gvflags) == SVt_PVGV || SvTYPE(_gvflags) == SVt_PVLV); \
assert(isGV_with_GP(_gvflags)); \
&(GvXPVGV(_gvflags)->xpv_cur);}))
# define GvSTASH(gv) \
(*({ GV * const _gvstash = (GV *) (gv); \
assert(isGV_with_GP(_gvstash)); \
assert(SvTYPE(_gvstash) == SVt_PVGV || SvTYPE(_gvstash) >= SVt_PVLV); \
&(GvXPVGV(_gvstash)->xnv_u.xgv_stash); \
}))
# define GvNAME_HEK(gv) \
(*({ GV * const _gvname_hek = (GV *) (gv); \
assert(isGV_with_GP(_gvname_hek)); \
assert(SvTYPE(_gvname_hek) == SVt_PVGV || SvTYPE(_gvname_hek) >= SVt_PVLV); \
&(GvXPVGV(_gvname_hek)->xiv_u.xivu_namehek); \
}))
# define GvNAME_get(gv) ({ assert(GvNAME_HEK(gv)); (char *)HEK_KEY(GvNAME_HEK(gv)); })
# define GvNAMELEN_get(gv) ({ assert(GvNAME_HEK(gv)); HEK_LEN(GvNAME_HEK(gv)); })
# define GvNAMEUTF8(gv) ({ assert(GvNAME_HEK(gv)); HEK_UTF8(GvNAME_HEK(gv)); })
#else
# define GvGP(gv) (0+(gv)->sv_u.svu_gp)
# define GvGP_set(gv,gp) ((gv)->sv_u.svu_gp = (gp))
# define GvFLAGS(gv) (GvXPVGV(gv)->xpv_cur)
# define GvSTASH(gv) (GvXPVGV(gv)->xnv_u.xgv_stash)
# define GvNAME_HEK(gv) (GvXPVGV(gv)->xiv_u.xivu_namehek)
# define GvNAME_get(gv) HEK_KEY(GvNAME_HEK(gv))
# define GvNAMELEN_get(gv) HEK_LEN(GvNAME_HEK(gv))
# define GvNAMEUTF8(gv) HEK_UTF8(GvNAME_HEK(gv))
#endif
#define GvNAME(gv) GvNAME_get(gv)
#define GvNAMELEN(gv) GvNAMELEN_get(gv)
/*
=for apidoc Am|SV*|GvSV|GV* gv
Return the SV from the GV.
Prior to Perl v5.9.3, this would add a scalar if none existed. Nowadays, use
C<L</GvSVn>> for that, or compile perl with S<C<-DPERL_CREATE_GVSV>>. See
L<perl5100delta>.
=for apidoc Am|SV*|GvSVn|GV* gv
Like C<L</GvSV>>, but creates an empty scalar if none already exists.
=for apidoc Am|AV*|GvAV|GV* gv
Return the AV from the GV.
=for apidoc Am|HV*|GvHV|GV* gv
Return the HV from the GV.
=for apidoc Am|CV*|GvCV|GV* gv
Return the CV from the GV.
=cut
*/
#define GvSV(gv) (GvGP(gv)->gp_sv)
#ifdef PERL_DONT_CREATE_GVSV
#define GvSVn(gv) (*(GvGP(gv)->gp_sv ? \
&(GvGP(gv)->gp_sv) : \
&(GvGP(gv_SVadd(gv))->gp_sv)))
#else
#define GvSVn(gv) GvSV(gv)
#endif
#define GvREFCNT(gv) (GvGP(gv)->gp_refcnt)
#define GvIO(gv) \
( \
(gv) \
&& ( \
SvTYPE((const SV*)(gv)) == SVt_PVGV \
|| SvTYPE((const SV*)(gv)) == SVt_PVLV \
) \
&& GvGP(gv) \
? GvIOp(gv) \
: NULL \
)
#define GvIOp(gv) (GvGP(gv)->gp_io)
#define GvIOn(gv) (GvIO(gv) ? GvIOp(gv) : GvIOp(gv_IOadd(gv)))
#define GvFORM(gv) (GvGP(gv)->gp_form)
#define GvAV(gv) (GvGP(gv)->gp_av)
#define GvAVn(gv) (GvGP(gv)->gp_av ? \
GvGP(gv)->gp_av : \
GvGP(gv_AVadd(gv))->gp_av)
#define GvHV(gv) ((GvGP(gv))->gp_hv)
#define GvHVn(gv) (GvGP(gv)->gp_hv ? \
GvGP(gv)->gp_hv : \
GvGP(gv_HVadd(gv))->gp_hv)
#define GvCV(gv) ((CV*)GvGP(gv)->gp_cv)
#define GvCV_set(gv,cv) (GvGP(gv)->gp_cv = (cv))
#define GvCVGEN(gv) (GvGP(gv)->gp_cvgen)
#define GvCVu(gv) (GvGP(gv)->gp_cvgen ? NULL : GvGP(gv)->gp_cv)
#define GvGPFLAGS(gv) (GvGP(gv)->gp_flags)
#define GvLINE(gv) (GvGP(gv)->gp_line)
#define GvFILE_HEK(gv) (GvGP(gv)->gp_file_hek)
#define GvFILEx(gv) HEK_KEY(GvFILE_HEK(gv))
#define GvFILE(gv) (GvFILE_HEK(gv) ? GvFILEx(gv) : NULL)
#define GvFILEGV(gv) (GvFILE_HEK(gv) ? gv_fetchfile(GvFILEx(gv)) : NULL)
#define GvEGV(gv) (GvGP(gv)->gp_egv)
#define GvEGVx(gv) (isGV_with_GP(gv) ? GvEGV(gv) : NULL)
#define GvENAME(gv) GvNAME(GvEGV(gv) ? GvEGV(gv) : gv)
#define GvENAMELEN(gv) GvNAMELEN(GvEGV(gv) ? GvEGV(gv) : gv)
#define GvENAMEUTF8(gv) GvNAMEUTF8(GvEGV(gv) ? GvEGV(gv) : gv)
#define GvENAME_HEK(gv) GvNAME_HEK(GvEGV(gv) ? GvEGV(gv) : gv)
#define GvESTASH(gv) GvSTASH(GvEGV(gv) ? GvEGV(gv) : gv)
/* GVf_INTRO is one-shot flag which indicates that the next assignment
of a reference to the glob is to be localised; it distinguishes
'local *g = $ref' from '*g = $ref'.
GVf_MULTI is used to implement the "used only once" warning. It is
always set on a glob when an existing name is referenced, and when
a name is created when the warning is disabled. A post parse scan
in gv_check() then reports any names where this isn't set.
GVf_ONCE_FATAL is set on a glob when it is created and fatal "used
only once" warnings are enabled, since PL_curcop no longer has the
fatal flag set at the point where the warnings are reported.
*/
#define GVf_INTRO 0x01
#define GVf_MULTI 0x02
#define GVf_ASSUMECV 0x04
#define GVf_RESERVED 0x08 /* unused */
#define GVf_IMPORTED 0xF0
#define GVf_IMPORTED_SV 0x10
#define GVf_IMPORTED_AV 0x20
#define GVf_IMPORTED_HV 0x40
#define GVf_IMPORTED_CV 0x80
#define GVf_ONCE_FATAL 0x100
#define GvINTRO(gv) (GvFLAGS(gv) & GVf_INTRO)
#define GvINTRO_on(gv) (GvFLAGS(gv) |= GVf_INTRO)
#define GvINTRO_off(gv) (GvFLAGS(gv) &= ~GVf_INTRO)
#define GvMULTI(gv) (GvFLAGS(gv) & GVf_MULTI)
#define GvMULTI_on(gv) (GvFLAGS(gv) |= GVf_MULTI)
#define GvMULTI_off(gv) (GvFLAGS(gv) &= ~GVf_MULTI)
#define GvASSUMECV(gv) (GvFLAGS(gv) & GVf_ASSUMECV)
#define GvASSUMECV_on(gv) (GvFLAGS(gv) |= GVf_ASSUMECV)
#define GvASSUMECV_off(gv) (GvFLAGS(gv) &= ~GVf_ASSUMECV)
#define GvIMPORTED(gv) (GvFLAGS(gv) & GVf_IMPORTED)
#define GvIMPORTED_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED)
#define GvIMPORTED_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED)
#define GvIMPORTED_SV(gv) (GvFLAGS(gv) & GVf_IMPORTED_SV)
#define GvIMPORTED_SV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_SV)
#define GvIMPORTED_SV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_SV)
#define GvIMPORTED_AV(gv) (GvFLAGS(gv) & GVf_IMPORTED_AV)
#define GvIMPORTED_AV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_AV)
#define GvIMPORTED_AV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_AV)
#define GvIMPORTED_HV(gv) (GvFLAGS(gv) & GVf_IMPORTED_HV)
#define GvIMPORTED_HV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_HV)
#define GvIMPORTED_HV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_HV)
#define GvIMPORTED_CV(gv) (GvFLAGS(gv) & GVf_IMPORTED_CV)
#define GvIMPORTED_CV_on(gv) (GvFLAGS(gv) |= GVf_IMPORTED_CV)
#define GvIMPORTED_CV_off(gv) (GvFLAGS(gv) &= ~GVf_IMPORTED_CV)
#define GvONCE_FATAL(gv) (GvFLAGS(gv) & GVf_ONCE_FATAL)
#define GvONCE_FATAL_on(gv) (GvFLAGS(gv) |= GVf_ONCE_FATAL)
#define GvONCE_FATAL_off(gv) (GvFLAGS(gv) &= ~GVf_ONCE_FATAL)
#ifndef PERL_CORE
# define GvIN_PAD(gv) 0
# define GvIN_PAD_on(gv) NOOP
# define GvIN_PAD_off(gv) NOOP
# define Nullgv Null(GV*)
#endif
#define DM_RUID 0x001
#define DM_EUID 0x002
#define DM_UID (DM_RUID|DM_EUID)
#define DM_ARRAY_ISA 0x004
#define DM_RGID 0x010
#define DM_EGID 0x020
#define DM_GID (DM_RGID|DM_EGID)
#define DM_DELAY 0x100
/*
* symbol creation flags, for use in gv_fetchpv() and get_*v()
*/
#define GV_ADD 0x01 /* add, if symbol not already there
For gv_name_set, adding a HEK for the first
time, so don't try to free what's there. */
#define GV_ADDMULTI 0x02 /* add, pretending it has been added
already; used also by gv_init_* */
#define GV_ADDWARN 0x04 /* add, but warn if symbol wasn't already there */
/* 0x08 UNUSED */
#define GV_NOINIT 0x10 /* add, but don't init symbol, if type != PVGV */
/* This is used by toke.c to avoid turing placeholder constants in the symbol
table into full PVGVs with attached constant subroutines. */
#define GV_NOADD_NOINIT 0x20 /* Don't add the symbol if it's not there.
Don't init it if it is there but ! PVGV */
#define GV_NOEXPAND 0x40 /* Don't expand SvOK() entries to PVGV */
#define GV_NOTQUAL 0x80 /* A plain symbol name, not qualified with a
package (so skip checks for :: and ') */
#define GV_AUTOLOAD 0x100 /* gv_fetchmethod_flags() should AUTOLOAD */
#define GV_CROAK 0x200 /* gv_fetchmethod_flags() should croak */
#define GV_ADDMG 0x400 /* add if magical */
#define GV_NO_SVGMAGIC 0x800 /* Skip get-magic on an SV argument;
used only by gv_fetchsv(_nomg) */
#define GV_CACHE_ONLY 0x1000 /* return stash only if found in cache;
used only in flags parameter to gv_stash* family */
/* Flags for gv_fetchmeth_pvn and gv_autoload_pvn*/
#define GV_SUPER 0x1000 /* SUPER::method */
#define GV_NOUNIVERSAL 0x2000 /* Skip UNIVERSAL lookup */
/* Flags for gv_autoload_*/
#define GV_AUTOLOAD_ISMETHOD 1 /* autoloading a method? */
/* SVf_UTF8 (more accurately the return value from SvUTF8) is also valid
as a flag to various gv_* functions, so ensure it lies
outside this range.
*/
#define GV_NOADD_MASK \
(SVf_UTF8|GV_NOADD_NOINIT|GV_NOEXPAND|GV_NOTQUAL|GV_ADDMG|GV_NO_SVGMAGIC)
/* The bit flags that don't cause gv_fetchpv() to add a symbol if not
found (with the exception GV_ADDMG, which *might* cause the symbol
to be added) */
/* gv_fetchfile_flags() */
#define GVF_NOADD 0x01 /* don't add the glob if it doesn't exist */
#define gv_fullname3(sv,gv,prefix) gv_fullname4(sv,gv,prefix,TRUE)
#define gv_efullname3(sv,gv,prefix) gv_efullname4(sv,gv,prefix,TRUE)
#define gv_fetchmethod(stash, name) gv_fetchmethod_autoload(stash, name, TRUE)
#define gv_fetchsv_nomg(n,f,t) gv_fetchsv(n,(f)|GV_NO_SVGMAGIC,t)
#define gv_init(gv,stash,name,len,multi) \
gv_init_pvn(gv,stash,name,len,GV_ADDMULTI*cBOOL(multi))
#define gv_fetchmeth(stash,name,len,level) gv_fetchmeth_pvn(stash, name, len, level, 0)
#define gv_fetchmeth_autoload(stash,name,len,level) gv_fetchmeth_pvn_autoload(stash, name, len, level, 0)
#define gv_fetchmethod_flags(stash,name,flags) gv_fetchmethod_pv_flags(stash, name, flags)
/*
=for apidoc gv_autoload4
Equivalent to C<L</gv_autoload_pvn>>.
=cut
*/
#define gv_autoload4(stash, name, len, autoload) \
gv_autoload_pvn(stash, name, len, cBOOL(autoload))
#define newGVgen(pack) newGVgen_flags(pack, 0)
#define gv_method_changed(gv) \
( \
assert_(isGV_with_GP(gv)) \
GvREFCNT(gv) > 1 \
? (void)++PL_sub_generation \
: mro_method_changed_in(GvSTASH(gv)) \
)
/*
=for apidoc gv_AVadd
=for apidoc_item gv_HVadd
=for apidoc_item gv_IOadd
=for apidoc_item gv_SVadd
Make sure there is a slot of the given type (AV, HV, IO, SV) in the GV C<gv>.
=cut
*/
#define gv_AVadd(gv) gv_add_by_type((gv), SVt_PVAV)
#define gv_HVadd(gv) gv_add_by_type((gv), SVt_PVHV)
#define gv_IOadd(gv) gv_add_by_type((gv), SVt_PVIO)
#define gv_SVadd(gv) gv_add_by_type((gv), SVt_NULL)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

3148
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/handy.h Normal file
View file

File diff suppressed because it is too large Load diff

711
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv.h Normal file
View file

@ -0,0 +1,711 @@
/* hv.h
*
* Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999,
* 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/* These control hash traversal randomization and the environment variable PERL_PERTURB_KEYS.
* Currently disabling this functionality will break a few tests, but should otherwise work fine.
* See perlrun for more details. */
#if defined(PERL_PERTURB_KEYS_DISABLED)
# define PL_HASH_RAND_BITS_ENABLED 0
# define PERL_HASH_ITER_BUCKET(iter) ((iter)->xhv_riter)
#else
# define PERL_HASH_RANDOMIZE_KEYS 1
# if defined(PERL_PERTURB_KEYS_RANDOM)
# define PL_HASH_RAND_BITS_ENABLED 1
# elif defined(PERL_PERTURB_KEYS_DETERMINISTIC)
# define PL_HASH_RAND_BITS_ENABLED 2
# else
# define USE_PERL_PERTURB_KEYS 1
# define PL_HASH_RAND_BITS_ENABLED PL_hash_rand_bits_enabled
# endif
# define PERL_HASH_ITER_BUCKET(iter) (((iter)->xhv_riter) ^ ((iter)->xhv_rand))
#endif
#ifdef PERL_USE_UNSHARED_KEYS_IN_LARGE_HASHES
#define LARGE_HASH_HEURISTIC(hv,new_max) S_large_hash_heuristic(aTHX_ (hv), (new_max))
#else
#define LARGE_HASH_HEURISTIC(hv,new_max) 0
#endif
/* entry in hash value chain */
struct he {
/* Keep hent_next first in this structure, because sv_free_arenas take
advantage of this to share code between the he arenas and the SV
body arenas */
HE *hent_next; /* next entry in chain */
HEK *hent_hek; /* hash key */
union {
SV *hent_val; /* scalar value that was hashed */
Size_t hent_refcount; /* references for this shared hash key */
} he_valu;
};
/* hash key -- defined separately for use as shared pointer */
struct hek {
U32 hek_hash; /* computed hash of key */
I32 hek_len; /* length of the hash key */
/* Be careful! Sometimes we store a pointer in the hek_key
* buffer, which means it must be 8 byte aligned or things
* dont work on aligned platforms like HPUX
* Also beware, the last byte of the hek_key buffer is a
* hidden flags byte about the key. */
char hek_key[1]; /* variable-length hash key */
/* the hash-key is \0-terminated */
/* after the \0 there is a byte for flags, such as whether the key
is UTF-8 or WAS-UTF-8, or an SV */
};
struct shared_he {
struct he shared_he_he;
struct hek shared_he_hek;
};
/* Subject to change.
Don't access this directly.
Use the funcs in mro_core.c
*/
struct mro_alg {
AV *(*resolve)(pTHX_ HV* stash, U32 level);
const char *name;
U16 length;
U16 kflags; /* For the hash API - set HVhek_UTF8 if name is UTF-8 */
U32 hash; /* or 0 */
};
struct mro_meta {
/* a hash holding the different MROs private data. */
HV *mro_linear_all;
/* a pointer directly to the current MROs private data. If mro_linear_all
is NULL, this owns the SV reference, else it is just a pointer to a
value stored in and owned by mro_linear_all. */
SV *mro_linear_current;
HV *mro_nextmethod; /* next::method caching */
U32 cache_gen; /* Bumping this invalidates our method cache */
U32 pkg_gen; /* Bumps when local methods/@ISA change */
const struct mro_alg *mro_which; /* which mro alg is in use? */
HV *isa; /* Everything this class @ISA */
HV *super; /* SUPER method cache */
CV *destroy; /* DESTROY method if destroy_gen non-zero */
U32 destroy_gen; /* Generation number of DESTROY cache */
};
#define MRO_GET_PRIVATE_DATA(smeta, which) \
(((smeta)->mro_which && (which) == (smeta)->mro_which) \
? (smeta)->mro_linear_current \
: Perl_mro_get_private_data(aTHX_ (smeta), (which)))
/* Subject to change.
Don't access this directly.
*/
union _xhvnameu {
HEK *xhvnameu_name; /* When xhv_name_count is 0 */
HEK **xhvnameu_names; /* When xhv_name_count is non-0 */
};
/* A struct defined by pad.h and used within class.c */
struct suspended_compcv;
struct xpvhv_aux {
union _xhvnameu xhv_name_u; /* name, if a symbol table */
AV *xhv_backreferences; /* back references for weak references */
HE *xhv_eiter; /* current entry of iterator */
I32 xhv_riter; /* current root of iterator */
/* Concerning xhv_name_count: When non-zero, xhv_name_u contains a pointer
* to an array of HEK pointers, this being the length. The first element is
* the name of the stash, which may be NULL. If xhv_name_count is positive,
* then *xhv_name is one of the effective names. If xhv_name_count is nega-
* tive, then xhv_name_u.xhvnameu_names[1] is the first effective name.
*/
I32 xhv_name_count;
struct mro_meta *xhv_mro_meta;
#ifdef PERL_HASH_RANDOMIZE_KEYS
U32 xhv_rand; /* random value for hash traversal */
U32 xhv_last_rand; /* last random value for hash traversal,
used to detect each() after insert for warnings */
#endif
U32 xhv_aux_flags; /* assorted extra flags */
/* The following fields are only valid if we have the flag HvAUXf_IS_CLASS */
HV *xhv_class_superclass; /* STASH of the :isa() base class */
CV *xhv_class_initfields_cv; /* CV for running initfields */
AV *xhv_class_adjust_blocks; /* CVs containing the ADJUST blocks */
PADNAMELIST *xhv_class_fields; /* PADNAMEs with PadnameIsFIELD() */
PADOFFSET xhv_class_next_fieldix;
HV *xhv_class_param_map; /* Maps param names to field index stored in UV */
struct suspended_compcv
*xhv_class_suspended_initfields_compcv;
};
#define HvAUXf_SCAN_STASH 0x1 /* stash is being scanned by gv_check */
#define HvAUXf_NO_DEREF 0x2 /* @{}, %{} etc (and nomethod) not present */
#define HvAUXf_IS_CLASS 0x4 /* the package is a 'class' */
#define HvSTASH_IS_CLASS(hv) \
(HvHasAUX(hv) && HvAUX(hv)->xhv_aux_flags & HvAUXf_IS_CLASS)
/* hash structure: */
/* This structure must match the beginning of struct xpvmg in sv.h. */
struct xpvhv {
HV* xmg_stash; /* class package */
union _xmgu xmg_u;
STRLEN xhv_keys; /* total keys, including placeholders */
STRLEN xhv_max; /* subscript of last element of xhv_array */
};
struct xpvhv_with_aux {
HV *xmg_stash; /* class package */
union _xmgu xmg_u;
STRLEN xhv_keys; /* total keys, including placeholders */
STRLEN xhv_max; /* subscript of last element of xhv_array */
struct xpvhv_aux xhv_aux;
};
/*
=for apidoc AmnU||HEf_SVKEY
This flag, used in the length slot of hash entries and magic structures,
specifies the structure contains an C<SV*> pointer where a C<char*> pointer
is to be expected. (For information only--not to be used).
=for apidoc ADmnU||Nullhv
Null HV pointer.
(deprecated - use C<(HV *)NULL> instead)
=for apidoc Am|char*|HvNAME|HV* stash
Returns the package name of a stash, or C<NULL> if C<stash> isn't a stash.
See C<L</SvSTASH>>, C<L</CvSTASH>>.
=for apidoc Am|STRLEN|HvNAMELEN|HV *stash
Returns the length of the stash's name.
Disfavored forms of HvNAME and HvNAMELEN; suppress mention of them
=for apidoc Cmh|char*|HvNAME_get|HV* stash
=for apidoc Amh|I32|HvNAMELEN_get|HV* stash
=for apidoc Am|unsigned char|HvNAMEUTF8|HV *stash
Returns true if the name is in UTF-8 encoding.
=for apidoc Am|char*|HvENAME|HV* stash
Returns the effective name of a stash, or NULL if there is none. The
effective name represents a location in the symbol table where this stash
resides. It is updated automatically when packages are aliased or deleted.
A stash that is no longer in the symbol table has no effective name. This
name is preferable to C<HvNAME> for use in MRO linearisations and isa
caches.
=for apidoc Am|STRLEN|HvENAMELEN|HV *stash
Returns the length of the stash's effective name.
=for apidoc Am|unsigned char|HvENAMEUTF8|HV *stash
Returns true if the effective name is in UTF-8 encoding.
=for apidoc Am|void*|HeKEY|HE* he
Returns the actual pointer stored in the key slot of the hash entry. The
pointer may be either C<char*> or C<SV*>, depending on the value of
C<HeKLEN()>. Can be assigned to. The C<HePV()> or C<HeSVKEY()> macros are
usually preferable for finding the value of a key.
=for apidoc Am|STRLEN|HeKLEN|HE* he
If this is negative, and amounts to C<HEf_SVKEY>, it indicates the entry
holds an C<SV*> key. Otherwise, holds the actual length of the key. Can
be assigned to. The C<HePV()> macro is usually preferable for finding key
lengths.
=for apidoc Am|SV*|HeVAL|HE* he
Returns the value slot (type C<SV*>)
stored in the hash entry. Can be assigned
to.
SV *foo= HeVAL(hv);
HeVAL(hv)= sv;
=for apidoc Am|U32|HeHASH|HE* he
Returns the computed hash stored in the hash entry.
=for apidoc Am|char*|HePV|HE* he|STRLEN len
Returns the key slot of the hash entry as a C<char*> value, doing any
necessary dereferencing of possibly C<SV*> keys. The length of the string
is placed in C<len> (this is a macro, so do I<not> use C<&len>). If you do
not care about what the length of the key is, you may use the global
variable C<PL_na>, though this is rather less efficient than using a local
variable. Remember though, that hash keys in perl are free to contain
embedded nulls, so using C<strlen()> or similar is not a good way to find
the length of hash keys. This is very similar to the C<SvPV()> macro
described elsewhere in this document. See also C<L</HeUTF8>>.
If you are using C<HePV> to get values to pass to C<newSVpvn()> to create a
new SV, you should consider using C<newSVhek(HeKEY_hek(he))> as it is more
efficient.
=for apidoc Am|U32|HeUTF8|HE* he
Returns whether the C<char *> value returned by C<HePV> is encoded in UTF-8,
doing any necessary dereferencing of possibly C<SV*> keys. The value returned
will be 0 or non-0, not necessarily 1 (or even a value with any low bits set),
so B<do not> blindly assign this to a C<bool> variable, as C<bool> may be a
typedef for C<char>.
=for apidoc Am|SV*|HeSVKEY|HE* he
Returns the key as an C<SV*>, or C<NULL> if the hash entry does not
contain an C<SV*> key.
=for apidoc Am|SV*|HeSVKEY_force|HE* he
Returns the key as an C<SV*>. Will create and return a temporary mortal
C<SV*> if the hash entry contains only a C<char*> key.
=for apidoc Am|SV*|HeSVKEY_set|HE* he|SV* sv
Sets the key to a given C<SV*>, taking care to set the appropriate flags to
indicate the presence of an C<SV*> key, and returns the same
C<SV*>.
=cut
*/
#define PERL_HASH_DEFAULT_HvMAX 7
/* these hash entry flags ride on hent_klen (for use only in magic/tied HVs) */
#define HEf_SVKEY -2 /* hent_key is an SV* */
#ifndef PERL_CORE
# define Nullhv Null(HV*)
#endif
#define HvARRAY(hv) ((hv)->sv_u.svu_hash)
/*
=for apidoc Am|STRLEN|HvFILL|HV *const hv
Returns the number of hash buckets that happen to be in use.
As of perl 5.25 this function is used only for debugging
purposes, and the number of used hash buckets is not
in any way cached, thus this function can be costly
to execute as it must iterate over all the buckets in the
hash.
=cut
*/
#define HvFILL(hv) Perl_hv_fill(aTHX_ MUTABLE_HV(hv))
#define HvMAX(hv) ((XPVHV*) SvANY(hv))->xhv_max
/*
=for apidoc Am|bool|HvHasAUX|HV *const hv
Returns true if the HV has a C<struct xpvhv_aux> extension. Use this to check
whether it is valid to call C<HvAUX()>.
=cut
*/
#define HvHasAUX(hv) (SvFLAGS(hv) & SVphv_HasAUX)
/* This quite intentionally does no flag checking first. That's your
responsibility. Use HvHasAUX() first */
#define HvAUX(hv) (&(((struct xpvhv_with_aux*) SvANY(hv))->xhv_aux))
#define HvRITER(hv) (*Perl_hv_riter_p(aTHX_ MUTABLE_HV(hv)))
#define HvEITER(hv) (*Perl_hv_eiter_p(aTHX_ MUTABLE_HV(hv)))
#define HvRITER_set(hv,r) Perl_hv_riter_set(aTHX_ MUTABLE_HV(hv), r)
#define HvEITER_set(hv,e) Perl_hv_eiter_set(aTHX_ MUTABLE_HV(hv), e)
#define HvRITER_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_riter : -1)
#define HvEITER_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_eiter : NULL)
#define HvRAND_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_rand : 0)
#define HvLASTRAND_get(hv) (HvHasAUX(hv) ? HvAUX(hv)->xhv_last_rand : 0)
#define HvNAME(hv) HvNAME_get(hv)
#define HvNAMELEN(hv) HvNAMELEN_get(hv)
#define HvENAME(hv) HvENAME_get(hv)
#define HvENAMELEN(hv) HvENAMELEN_get(hv)
/* Checking that hv is a valid package stash is the
caller's responsibility */
#define HvMROMETA(hv) (HvAUX(hv)->xhv_mro_meta \
? HvAUX(hv)->xhv_mro_meta \
: Perl_mro_meta_init(aTHX_ hv))
#define HvNAME_HEK_NN(hv) \
( \
HvAUX(hv)->xhv_name_count \
? *HvAUX(hv)->xhv_name_u.xhvnameu_names \
: HvAUX(hv)->xhv_name_u.xhvnameu_name \
)
/* This macro may go away without notice. */
#define HvNAME_HEK(hv) \
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name ? HvNAME_HEK_NN(hv) : NULL)
#define HvHasNAME(hv) \
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv))
#define HvNAME_get(hv) \
(HvHasNAME(hv) ? HEK_KEY(HvNAME_HEK_NN(hv)) : NULL)
#define HvNAMELEN_get(hv) \
((HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
? HEK_LEN(HvNAME_HEK_NN(hv)) : 0)
#define HvNAMEUTF8(hv) \
((HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name && HvNAME_HEK_NN(hv)) \
? HEK_UTF8(HvNAME_HEK_NN(hv)) : 0)
#define HvENAME_HEK_NN(hv) \
( \
HvAUX(hv)->xhv_name_count > 0 ? HvAUX(hv)->xhv_name_u.xhvnameu_names[0] : \
HvAUX(hv)->xhv_name_count < -1 ? HvAUX(hv)->xhv_name_u.xhvnameu_names[1] : \
HvAUX(hv)->xhv_name_count == -1 ? NULL : \
HvAUX(hv)->xhv_name_u.xhvnameu_name \
)
#define HvHasENAME_HEK(hv) \
(HvHasAUX(hv) && HvAUX(hv)->xhv_name_u.xhvnameu_name)
#define HvENAME_HEK(hv) \
(HvHasENAME_HEK(hv) ? HvENAME_HEK_NN(hv) : NULL)
#define HvHasENAME(hv) \
(HvHasENAME_HEK(hv) && HvAUX(hv)->xhv_name_count != -1)
#define HvENAME_get(hv) \
(HvHasENAME(hv) ? HEK_KEY(HvENAME_HEK_NN(hv)) : NULL)
#define HvENAMELEN_get(hv) \
(HvHasENAME(hv) ? HEK_LEN(HvENAME_HEK_NN(hv)) : 0)
#define HvENAMEUTF8(hv) \
(HvHasENAME(hv) ? HEK_UTF8(HvENAME_HEK_NN(hv)) : 0)
/*
* HvKEYS gets the number of keys that actually exist(), and is provided
* for backwards compatibility with old XS code. The core uses HvUSEDKEYS
* (keys, excluding placeholders) and HvTOTALKEYS (including placeholders)
*/
#define HvKEYS(hv) HvUSEDKEYS(hv)
#define HvUSEDKEYS(hv) (HvTOTALKEYS(hv) - HvPLACEHOLDERS_get(hv))
#define HvTOTALKEYS(hv) (((XPVHV*) SvANY(hv))->xhv_keys)
#define HvPLACEHOLDERS(hv) (*Perl_hv_placeholders_p(aTHX_ MUTABLE_HV(hv)))
#define HvPLACEHOLDERS_get(hv) (SvMAGIC(hv) ? Perl_hv_placeholders_get(aTHX_ (const HV *)hv) : 0)
#define HvPLACEHOLDERS_set(hv,p) Perl_hv_placeholders_set(aTHX_ MUTABLE_HV(hv), p)
/* This (now) flags whether *new* keys in the hash will be allocated from the
* shared string table. We have a heuristic to call HvSHAREKEYS_off() if a hash
* is "getting large". After which, the first keys in that hash will be from
* the shared string table, but subsequent keys will not be.
*
* If we didn't do this, we'd have to reallocate all keys when we switched this
* flag, which would be work for no real gain. */
#define HvSHAREKEYS(hv) (SvFLAGS(hv) & SVphv_SHAREKEYS)
#define HvSHAREKEYS_on(hv) (SvFLAGS(hv) |= SVphv_SHAREKEYS)
#define HvSHAREKEYS_off(hv) (SvFLAGS(hv) &= ~SVphv_SHAREKEYS)
/* This is an optimisation flag. It won't be set if all hash keys have a 0
* flag. Currently the only flags relate to utf8.
* Hence it won't be set if all keys are 8 bit only. It will be set if any key
* is utf8 (including 8 bit keys that were entered as utf8, and need upgrading
* when retrieved during iteration. It may still be set when there are no longer
* any utf8 keys.
* See HVhek_ENABLEHVKFLAGS for the trigger.
*/
#define HvHASKFLAGS(hv) (SvFLAGS(hv) & SVphv_HASKFLAGS)
#define HvHASKFLAGS_on(hv) (SvFLAGS(hv) |= SVphv_HASKFLAGS)
#define HvHASKFLAGS_off(hv) (SvFLAGS(hv) &= ~SVphv_HASKFLAGS)
#define HvLAZYDEL(hv) (SvFLAGS(hv) & SVphv_LAZYDEL)
#define HvLAZYDEL_on(hv) (SvFLAGS(hv) |= SVphv_LAZYDEL)
#define HvLAZYDEL_off(hv) (SvFLAGS(hv) &= ~SVphv_LAZYDEL)
#ifndef PERL_CORE
# define Nullhe Null(HE*)
#endif
#define HeNEXT(he) (he)->hent_next
#define HeKEY_hek(he) (he)->hent_hek
#define HeKEY(he) HEK_KEY(HeKEY_hek(he))
#define HeKEY_sv(he) (*(SV**)HeKEY(he))
#define HeKLEN(he) HEK_LEN(HeKEY_hek(he))
#define HeKUTF8(he) HEK_UTF8(HeKEY_hek(he))
#define HeKWASUTF8(he) HEK_WASUTF8(HeKEY_hek(he))
#define HeKLEN_UTF8(he) (HeKUTF8(he) ? -HeKLEN(he) : HeKLEN(he))
#define HeKFLAGS(he) HEK_FLAGS(HeKEY_hek(he))
#define HeVAL(he) (he)->he_valu.hent_val
#define HeHASH(he) HEK_HASH(HeKEY_hek(he))
#define HePV(he,lp) ((HeKLEN(he) == HEf_SVKEY) ? \
SvPV(HeKEY_sv(he),lp) : \
((lp = HeKLEN(he)), HeKEY(he)))
#define HeUTF8(he) ((HeKLEN(he) == HEf_SVKEY) ? \
SvUTF8(HeKEY_sv(he)) : \
(U32)HeKUTF8(he))
#define HeSVKEY(he) ((HeKEY(he) && \
HeKLEN(he) == HEf_SVKEY) ? \
HeKEY_sv(he) : NULL)
#define HeSVKEY_force(he) (HeKEY(he) ? \
((HeKLEN(he) == HEf_SVKEY) ? \
HeKEY_sv(he) : \
newSVpvn_flags(HeKEY(he), \
HeKLEN(he), \
SVs_TEMP | \
( HeKUTF8(he) ? SVf_UTF8 : 0 ))) : \
&PL_sv_undef)
#define HeSVKEY_set(he,sv) ((HeKLEN(he) = HEf_SVKEY), (HeKEY_sv(he) = sv))
#ifndef PERL_CORE
# define Nullhek Null(HEK*)
#endif
#define HEK_BASESIZE STRUCT_OFFSET(HEK, hek_key[0])
#define HEK_HASH(hek) (hek)->hek_hash
#define HEK_LEN(hek) (hek)->hek_len
#define HEK_KEY(hek) (hek)->hek_key
#define HEK_FLAGS(hek) (*((unsigned char *)(HEK_KEY(hek))+HEK_LEN(hek)+1))
#define HVhek_UTF8 0x01 /* Key is utf8 encoded. */
#define HVhek_WASUTF8 0x02 /* Key is bytes here, but was supplied as utf8. */
#define HVhek_NOTSHARED 0x04 /* This key isn't a shared hash key. */
/* the following flags are options for functions, they are not stored in heks */
#define HVhek_FREEKEY 0x100 /* Internal flag to say key is Newx()ed. */
#define HVhek_PLACEHOLD 0x200 /* Internal flag to create placeholder.
* (may change, but Storable is a core module) */
#define HVhek_KEYCANONICAL 0x400 /* Internal flag - key is in canonical form.
If the string is UTF-8, it cannot be
converted to bytes. */
#define HVhek_ENABLEHVKFLAGS (HVhek_UTF8|HVhek_WASUTF8)
#define HEK_UTF8(hek) (HEK_FLAGS(hek) & HVhek_UTF8)
#define HEK_UTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_UTF8)
#define HEK_UTF8_off(hek) (HEK_FLAGS(hek) &= ~HVhek_UTF8)
#define HEK_WASUTF8(hek) (HEK_FLAGS(hek) & HVhek_WASUTF8)
#define HEK_WASUTF8_on(hek) (HEK_FLAGS(hek) |= HVhek_WASUTF8)
#define HEK_WASUTF8_off(hek) (HEK_FLAGS(hek) &= ~HVhek_WASUTF8)
/* calculate HV array allocation */
#ifndef PERL_USE_LARGE_HV_ALLOC
/* Default to allocating the correct size - default to assuming that malloc()
is not broken and is efficient at allocating blocks sized at powers-of-two.
*/
# define PERL_HV_ARRAY_ALLOC_BYTES(size) ((size) * sizeof(HE*))
#else
# define MALLOC_OVERHEAD 16
# define PERL_HV_ARRAY_ALLOC_BYTES(size) \
(((size) < 64) \
? (size) * sizeof(HE*) \
: (size) * sizeof(HE*) * 2 - MALLOC_OVERHEAD)
#endif
/* Flags for hv_iternext_flags. */
#define HV_ITERNEXT_WANTPLACEHOLDERS 0x01 /* Don't skip placeholders. */
#define hv_iternext(hv) hv_iternext_flags(hv, 0)
#define hv_magic(hv, gv, how) sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0)
#define hv_undef(hv) Perl_hv_undef_flags(aTHX_ hv, 0)
#define Perl_sharepvn(pv, len, hash) HEK_KEY(share_hek(pv, len, hash))
#define sharepvn(pv, len, hash) Perl_sharepvn(pv, len, hash)
#define share_hek_hek(hek) \
(++(((struct shared_he *)(((char *)hek) \
- STRUCT_OFFSET(struct shared_he, \
shared_he_hek))) \
->shared_he_he.he_valu.hent_refcount), \
hek)
#define hv_store_ent(hv, keysv, val, hash) \
((HE *) hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISSTORE, \
(val), (hash)))
#define hv_exists_ent(hv, keysv, hash) \
cBOOL(hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash)))
#define hv_fetch_ent(hv, keysv, lval, hash) \
((HE *) hv_common((hv), (keysv), NULL, 0, 0, \
((lval) ? HV_FETCH_LVALUE : 0), NULL, (hash)))
#define hv_delete_ent(hv, key, flags, hash) \
(MUTABLE_SV(hv_common((hv), (key), NULL, 0, 0, (flags) | HV_DELETE, \
NULL, (hash))))
#define hv_store_flags(hv, key, klen, val, hash, flags) \
((SV**) hv_common((hv), NULL, (key), (klen), (flags), \
(HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), (val), \
(hash)))
#define hv_store(hv, key, klen, val, hash) \
((SV**) hv_common_key_len((hv), (key), (klen), \
(HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), \
(val), (hash)))
#define hv_exists(hv, key, klen) \
cBOOL(hv_common_key_len((hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0))
#define hv_fetch(hv, key, klen, lval) \
((SV**) hv_common_key_len((hv), (key), (klen), (lval) \
? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \
: HV_FETCH_JUST_SV, NULL, 0))
#define hv_delete(hv, key, klen, flags) \
(MUTABLE_SV(hv_common_key_len((hv), (key), (klen), \
(flags) | HV_DELETE, NULL, 0)))
/* Provide 's' suffix subs for constant strings (and avoid needing to count
* chars). See STR_WITH_LEN in handy.h - because these are macros we cant use
* STR_WITH_LEN to do the work, we have to unroll it. */
#define hv_existss(hv, key) \
hv_exists((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1))
#define hv_fetchs(hv, key, lval) \
hv_fetch((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (lval))
#define hv_deletes(hv, key, flags) \
hv_delete((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (flags))
#define hv_name_sets(hv, name, flags) \
hv_name_set((hv),ASSERT_IS_LITERAL(name),(sizeof(name)-1), flags)
#define hv_stores(hv, key, val) \
hv_store((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (val), 0)
#ifdef PERL_CORE
# define hv_storehek(hv, hek, val) \
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
HV_FETCH_ISSTORE|HV_FETCH_JUST_SV, (val), HEK_HASH(hek))
# define hv_fetchhek(hv, hek, lval) \
((SV **) \
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
(lval) \
? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \
: HV_FETCH_JUST_SV, \
NULL, HEK_HASH(hek)))
# define hv_deletehek(hv, hek, flags) \
hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
(flags)|HV_DELETE, NULL, HEK_HASH(hek))
#define hv_existshek(hv, hek) \
cBOOL(hv_common((hv), NULL, HEK_KEY(hek), HEK_LEN(hek), HEK_UTF8(hek), \
HV_FETCH_ISEXISTS, NULL, HEK_HASH(hek)))
#endif
/* This refcounted he structure is used for storing the hints used for lexical
pragmas. Without threads, it's basically struct he + refcount.
With threads, life gets more complex as the structure needs to be shared
between threads (because it hangs from OPs, which are shared), hence the
alternate definition and mutex. */
struct refcounted_he;
/* flags for the refcounted_he API */
#define REFCOUNTED_HE_KEY_UTF8 0x00000001
#define REFCOUNTED_HE_EXISTS 0x00000002
#ifdef PERL_CORE
/* Gosh. This really isn't a good name any longer. */
struct refcounted_he {
struct refcounted_he *refcounted_he_next; /* next entry in chain */
#ifdef USE_ITHREADS
U32 refcounted_he_hash;
U32 refcounted_he_keylen;
#else
HEK *refcounted_he_hek; /* hint key */
#endif
union {
IV refcounted_he_u_iv;
UV refcounted_he_u_uv;
STRLEN refcounted_he_u_len;
void *refcounted_he_u_ptr; /* Might be useful in future */
} refcounted_he_val;
U32 refcounted_he_refcnt; /* reference count */
/* First byte is flags. Then NUL-terminated value. Then for ithreads,
non-NUL terminated key. */
char refcounted_he_data[1];
};
/*
=for apidoc m|SV *|refcounted_he_fetch_pvs|const struct refcounted_he *chain|"key"|U32 flags
Like L</refcounted_he_fetch_pvn>, but takes a literal string
instead of a string/length pair, and no precomputed hash.
=cut
*/
#define refcounted_he_fetch_pvs(chain, key, flags) \
Perl_refcounted_he_fetch_pvn(aTHX_ chain, STR_WITH_LEN(key), 0, flags)
/*
=for apidoc m|struct refcounted_he *|refcounted_he_new_pvs|struct refcounted_he *parent|"key"|SV *value|U32 flags
Like L</refcounted_he_new_pvn>, but takes a literal string
instead of a string/length pair, and no precomputed hash.
=cut
*/
#define refcounted_he_new_pvs(parent, key, value, flags) \
Perl_refcounted_he_new_pvn(aTHX_ parent, STR_WITH_LEN(key), 0, value, flags)
/* Flag bits are HVhek_UTF8, HVhek_WASUTF8, then */
#define HVrhek_undef 0x00 /* Value is undef. */
#define HVrhek_delete 0x10 /* Value is placeholder - signifies delete. */
#define HVrhek_IV 0x20 /* Value is IV. */
#define HVrhek_UV 0x30 /* Value is UV. */
#define HVrhek_PV 0x40 /* Value is a (byte) string. */
#define HVrhek_PV_UTF8 0x50 /* Value is a (utf8) string. */
/* Two spare. As these have to live in the optree, you can't store anything
interpreter specific, such as SVs. :-( */
#define HVrhek_typemask 0x70
#ifdef USE_ITHREADS
/* A big expression to find the key offset */
#define REF_HE_KEY(chain) \
((((chain->refcounted_he_data[0] & 0x60) == 0x40) \
? chain->refcounted_he_val.refcounted_he_u_len + 1 : 0) \
+ 1 + chain->refcounted_he_data)
#endif
# ifdef USE_ITHREADS
# define HINTS_REFCNT_LOCK MUTEX_LOCK(&PL_hints_mutex)
# define HINTS_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_hints_mutex)
# else
# define HINTS_REFCNT_LOCK NOOP
# define HINTS_REFCNT_UNLOCK NOOP
# endif
#endif
#ifdef USE_ITHREADS
# define HINTS_REFCNT_INIT MUTEX_INIT(&PL_hints_mutex)
# define HINTS_REFCNT_TERM MUTEX_DESTROY(&PL_hints_mutex)
#else
# define HINTS_REFCNT_INIT NOOP
# define HINTS_REFCNT_TERM NOOP
#endif
/* Hash actions
* Passed in PERL_MAGIC_uvar calls
*/
#define HV_DISABLE_UVAR_XKEY 0x01
/* We need to ensure that these don't clash with G_DISCARD, which is 2, as it
is documented as being passed to hv_delete(). */
#define HV_FETCH_ISSTORE 0x04
#define HV_FETCH_ISEXISTS 0x08
#define HV_FETCH_LVALUE 0x10
#define HV_FETCH_JUST_SV 0x20
#define HV_DELETE 0x40
#define HV_FETCH_EMPTY_HE 0x80 /* Leave HeVAL null. */
/* Must not conflict with HVhek_UTF8 */
#define HV_NAME_SETALL 0x02
/*
=for apidoc newHV
Creates a new HV. The reference count is set to 1.
=cut
*/
#define newHV() MUTABLE_HV(newSV_type(SVt_PVHV))
#include "hv_func.h"
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

189
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_func.h Normal file
View file

@ -0,0 +1,189 @@
/* hash a key
*--------------------------------------------------------------------------------------
* The "hash seed" feature was added in Perl 5.8.1 to perturb the results
* to avoid "algorithmic complexity attacks".
*
* If USE_HASH_SEED is defined, hash randomisation is done by default
* (see also perl.c:perl_parse() and S_init_tls_and_interp() and util.c:get_hash_seed())
*/
#ifndef PERL_SEEN_HV_FUNC_H_ /* compile once */
#define PERL_SEEN_HV_FUNC_H_
#include "hv_macro.h"
#if !( 0 \
|| defined(PERL_HASH_FUNC_SIPHASH) \
|| defined(PERL_HASH_FUNC_SIPHASH13) \
|| defined(PERL_HASH_FUNC_ZAPHOD32) \
)
# ifdef CAN64BITHASH
# define PERL_HASH_FUNC_SIPHASH13
# else
# define PERL_HASH_FUNC_ZAPHOD32
# endif
#endif
#ifndef PERL_HASH_USE_SBOX32_ALSO
# if defined(PERL_HASH_USE_SBOX32) || !defined(PERL_HASH_NO_SBOX32)
# define PERL_HASH_USE_SBOX32_ALSO 1
# else
# define PERL_HASH_USE_SBOX32_ALSO 0
# endif
#endif
#undef PERL_HASH_USE_SBOX32
#undef PERL_HASH_NO_SBOX32
#if PERL_HASH_USE_SBOX32_ALSO != 0
# define PERL_HASH_USE_SBOX32
#else
# define PERL_HASH_NO_SBOX32
#endif
#ifndef SBOX32_MAX_LEN
#define SBOX32_MAX_LEN 24
#endif
/* this must be after the SBOX32_MAX_LEN define */
#include "sbox32_hash.h"
#if defined(PERL_HASH_FUNC_SIPHASH)
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_SIPHASH"
# define PVT__PERL_HASH_FUNC "SIPHASH_2_4"
# define PVT__PERL_HASH_WORD_TYPE U64
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 2)
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 4)
# define PVT__PERL_HASH_SEED_STATE(seed,state) S_perl_siphash_seed_state(seed,state)
# define PVT__PERL_HASH_WITH_STATE(state,str,len) S_perl_hash_siphash_2_4_with_state((state),(U8*)(str),(len))
#elif defined(PERL_HASH_FUNC_SIPHASH13)
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_SIPHASH13"
# define PVT__PERL_HASH_FUNC "SIPHASH_1_3"
# define PVT__PERL_HASH_WORD_TYPE U64
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 2)
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 4)
# define PVT__PERL_HASH_SEED_STATE(seed,state) S_perl_siphash_seed_state(seed,state)
# define PVT__PERL_HASH_WITH_STATE(state,str,len) S_perl_hash_siphash_1_3_with_state((state),(const U8*)(str),(len))
#elif defined(PERL_HASH_FUNC_ZAPHOD32)
# define PERL_HASH_FUNC_DEFINE "PERL_HASH_FUNC_ZAPHOD32"
# define PVT__PERL_HASH_FUNC "ZAPHOD32"
# define PVT__PERL_HASH_WORD_TYPE U32
# define PVT__PERL_HASH_WORD_SIZE sizeof(PVT__PERL_HASH_WORD_TYPE)
# define PVT__PERL_HASH_SEED_BYTES (PVT__PERL_HASH_WORD_SIZE * 3)
# define PVT__PERL_HASH_STATE_BYTES (PVT__PERL_HASH_WORD_SIZE * 3)
# define PVT__PERL_HASH_SEED_STATE(seed,state) zaphod32_seed_state(seed,state)
# define PVT__PERL_HASH_WITH_STATE(state,str,len) (U32)zaphod32_hash_with_state((state),(U8*)(str),(len))
# include "zaphod32_hash.h"
#endif
#ifndef PVT__PERL_HASH_WITH_STATE
#error "No hash function defined!"
#endif
#ifndef PVT__PERL_HASH_SEED_BYTES
#error "PVT__PERL_HASH_SEED_BYTES not defined"
#endif
#ifndef PVT__PERL_HASH_FUNC
#error "PVT__PERL_HASH_FUNC not defined"
#endif
/* Some siphash static functions are needed by XS::APItest even when
siphash isn't the current hash. For SipHash builds this needs to
be before the S_perl_hash_with_seed() definition.
*/
#include "perl_siphash.h"
#define PVT__PERL_HASH_SEED_roundup(x, y) ( ( ( (x) + ( (y) - 1 ) ) / (y) ) * (y) )
#define PVT_PERL_HASH_SEED_roundup(x) PVT__PERL_HASH_SEED_roundup(x,PVT__PERL_HASH_WORD_SIZE)
#define PL_hash_seed ((U8 *)PL_hash_seed_w)
#define PL_hash_state ((U8 *)PL_hash_state_w)
#if PERL_HASH_USE_SBOX32_ALSO == 0
# define PVT_PERL_HASH_FUNC PVT__PERL_HASH_FUNC
# define PVT_PERL_HASH_SEED_BYTES PVT__PERL_HASH_SEED_BYTES
# define PVT_PERL_HASH_STATE_BYTES PVT__PERL_HASH_STATE_BYTES
# define PVT_PERL_HASH_SEED_STATE(seed,state) PVT__PERL_HASH_SEED_STATE(seed,state)
# define PVT_PERL_HASH_WITH_STATE(state,str,len) PVT__PERL_HASH_WITH_STATE(state,str,len)
#else
#define PVT_PERL_HASH_FUNC "SBOX32_WITH_" PVT__PERL_HASH_FUNC
/* note the 4 in the below code comes from the fact the seed to initialize the SBOX is 128 bits */
#define PVT_PERL_HASH_SEED_BYTES ( PVT__PERL_HASH_SEED_BYTES + (int)( 4 * sizeof(U32)) )
#define PVT_PERL_HASH_STATE_BYTES \
( PVT__PERL_HASH_STATE_BYTES + ( ( 1 + ( 256 * SBOX32_MAX_LEN ) ) * sizeof(U32) ) )
#define PVT_PERL_HASH_SEED_STATE(seed,state) STMT_START { \
PVT__PERL_HASH_SEED_STATE(seed,state); \
sbox32_seed_state128(seed + PVT__PERL_HASH_SEED_BYTES, state + PVT__PERL_HASH_STATE_BYTES); \
} STMT_END
#define PVT_PERL_HASH_WITH_STATE(state,str,len) \
(LIKELY(len <= SBOX32_MAX_LEN) \
? sbox32_hash_with_state((state + PVT__PERL_HASH_STATE_BYTES),(const U8*)(str),(len)) \
: PVT__PERL_HASH_WITH_STATE((state),(str),(len)))
#endif
#define PERL_HASH_WITH_SEED(seed,hash,str,len) \
(hash) = S_perl_hash_with_seed((const U8 *) seed, (const U8 *) str,len)
#define PERL_HASH_WITH_STATE(state,hash,str,len) \
(hash) = PVT_PERL_HASH_WITH_STATE((state),(const U8*)(str),(len))
#define PERL_HASH_SEED_STATE(seed,state) PVT_PERL_HASH_SEED_STATE(seed,state)
#define PERL_HASH_SEED_BYTES PVT_PERL_HASH_SEED_roundup(PVT_PERL_HASH_SEED_BYTES)
#define PERL_HASH_STATE_BYTES PVT_PERL_HASH_SEED_roundup(PVT_PERL_HASH_STATE_BYTES)
#define PERL_HASH_FUNC PVT_PERL_HASH_FUNC
#define PERL_HASH_SEED_WORDS (PERL_HASH_SEED_BYTES/PVT__PERL_HASH_WORD_SIZE)
#define PERL_HASH_STATE_WORDS (PERL_HASH_STATE_BYTES/PVT__PERL_HASH_WORD_SIZE)
#ifdef PERL_USE_SINGLE_CHAR_HASH_CACHE
#define PERL_HASH(state,str,len) \
(hash) = ((len) < 2 ? ( (len) == 0 ? PL_hash_chars[256] : PL_hash_chars[(U8)(str)[0]] ) \
: PVT_PERL_HASH_WITH_STATE(PL_hash_state,(U8*)(str),(len)))
#else
#define PERL_HASH(hash,str,len) \
PERL_HASH_WITH_STATE(PL_hash_state,hash,(U8*)(str),(len))
#endif
/* Setup the hash seed, either we do things dynamically at start up,
* including reading from the environment, or we randomly setup the
* seed. The seed will be passed into the PERL_HASH_SEED_STATE() function
* defined for the configuration defined for this perl, which will then
* initialize whatever state it might need later in hashing. */
#ifndef PERL_HASH_SEED
# if defined(USE_HASH_SEED)
# define PERL_HASH_SEED PL_hash_seed
# else
/* this is a 512 bit seed, which should be more than enough for the
* configuration of any of our hash functions (with or without sbox).
* If you actually use a hard coded seed, you are strongly encouraged
* to replace this with something else of the correct length
* for the hash function you are using (24-32 bytes depending on build
* options). Repeat, you are *STRONGLY* encouraged not to use the value
* provided here.
*/
# define PERL_HASH_SEED \
((const U8 *)"A long string of pseudorandomly " \
"chosen bytes for hashing in Perl")
# endif
#endif
/* legacy - only mod_perl should be doing this. */
#ifdef PERL_HASH_INTERNAL_ACCESS
#define PERL_HASH_INTERNAL(hash,str,len) PERL_HASH(hash,str,len)
#endif
PERL_STATIC_INLINE U32
S_perl_hash_with_seed(const U8 * seed, const U8 *str, STRLEN len) {
PVT__PERL_HASH_WORD_TYPE state[PERL_HASH_STATE_WORDS];
PVT_PERL_HASH_SEED_STATE(seed,(U8*)state);
return PVT_PERL_HASH_WITH_STATE((U8*)state,str,len);
}
#endif /*compile once*/
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

85
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/hv_macro.h Normal file
View file

@ -0,0 +1,85 @@
#ifndef PERL_SEEN_HV_MACRO_H_ /* compile once */
#define PERL_SEEN_HV_MACRO_H_
#if IVSIZE == 8
#define CAN64BITHASH
#endif
#ifdef CAN64BITHASH
#ifndef U64TYPE
/* This probably isn't going to work, but failing with a compiler error due to
lack of uint64_t is no worse than failing right now with an #error. */
#define U64 uint64_t
#endif
#endif
/*-----------------------------------------------------------------------------
* Endianess and util macros
*
* The following 3 macros are defined in this section. The other macros defined
* are only needed to help derive these 3.
*
* U8TO16_LE(x) Read a little endian unsigned 16-bit int
* U8TO32_LE(x) Read a little endian unsigned 32-bit int
* U8TO64_LE(x) Read a little endian unsigned 64-bit int
* ROTL32(x,r) Rotate x left by r bits
* ROTL64(x,r) Rotate x left by r bits
* ROTR32(x,r) Rotate x right by r bits
* ROTR64(x,r) Rotate x right by r bits
*/
#ifndef U8TO16_LE
#define _shifted_octet(type,ptr,idx,shift) (((type)(((const U8*)(ptr))[(idx)]))<<(shift))
#if defined(USE_UNALIGNED_PTR_DEREF) && (BYTEORDER == 0x1234 || BYTEORDER == 0x12345678)
#define U8TO16_LE(ptr) (*((const U16*)(ptr)))
#define U8TO32_LE(ptr) (*((const U32*)(ptr)))
#define U8TO64_LE(ptr) (*((const U64*)(ptr)))
#else
#define U8TO16_LE(ptr) (_shifted_octet(U16,(ptr),0, 0)|\
_shifted_octet(U16,(ptr),1, 8))
#define U8TO32_LE(ptr) (_shifted_octet(U32,(ptr),0, 0)|\
_shifted_octet(U32,(ptr),1, 8)|\
_shifted_octet(U32,(ptr),2,16)|\
_shifted_octet(U32,(ptr),3,24))
#define U8TO64_LE(ptr) (_shifted_octet(U64,(ptr),0, 0)|\
_shifted_octet(U64,(ptr),1, 8)|\
_shifted_octet(U64,(ptr),2,16)|\
_shifted_octet(U64,(ptr),3,24)|\
_shifted_octet(U64,(ptr),4,32)|\
_shifted_octet(U64,(ptr),5,40)|\
_shifted_octet(U64,(ptr),6,48)|\
_shifted_octet(U64,(ptr),7,56))
#endif
#endif
/* Find best way to ROTL32/ROTL64 */
#if defined(_MSC_VER)
#include <stdlib.h> /* Microsoft put _rotl declaration in here */
#define ROTL32(x,r) _rotl(x,r)
#define ROTR32(x,r) _rotr(x,r)
#define ROTL64(x,r) _rotl64(x,r)
#define ROTR64(x,r) _rotr64(x,r)
#else
/* gcc recognises this code and generates a rotate instruction for CPUs with one */
#define ROTL32(x,r) (((U32)(x) << (r)) | ((U32)(x) >> (32 - (r))))
#define ROTR32(x,r) (((U32)(x) << (32 - (r))) | ((U32)(x) >> (r)))
#define ROTL64(x,r) ( ( (U64)(x) << (r) ) | ( (U64)(x) >> ( 64 - (r) ) ) )
#define ROTR64(x,r) ( ( (U64)(x) << ( 64 - (r) ) ) | ( (U64)(x) >> (r) ) )
#endif
#ifdef UV_IS_QUAD
#define ROTL_UV(x,r) ROTL64(x,r)
#define ROTR_UV(x,r) ROTL64(x,r)
#else
#define ROTL_UV(x,r) ROTL32(x,r)
#define ROTR_UV(x,r) ROTR32(x,r)
#endif
#if IVSIZE == 8
#define CAN64BITHASH
#endif
#endif

4729
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/inline.h Normal file
View file

File diff suppressed because it is too large Load diff

1107
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/intrpvar.h Normal file
View file

File diff suppressed because it is too large Load diff

375
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/invlist_inline.h Normal file
View file

@ -0,0 +1,375 @@
/* invlist_inline.h
*
* Copyright (C) 2012 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*/
#ifndef PERL_INVLIST_INLINE_H_
#define PERL_INVLIST_INLINE_H_
#if defined(PERL_IN_UTF8_C) \
|| defined(PERL_IN_REGCOMP_ANY) \
|| defined(PERL_IN_REGEXEC_C) \
|| defined(PERL_IN_TOKE_C) \
|| defined(PERL_IN_PP_C) \
|| defined(PERL_IN_OP_C) \
|| defined(PERL_IN_DOOP_C)
/* An element is in an inversion list iff its index is even numbered: 0, 2, 4,
* etc */
#define ELEMENT_RANGE_MATCHES_INVLIST(i) (! ((i) & 1))
#define PREV_RANGE_MATCHES_INVLIST(i) (! ELEMENT_RANGE_MATCHES_INVLIST(i))
/* This converts to/from our UVs to what the SV code is expecting: bytes. */
#define TO_INTERNAL_SIZE(x) ((x) * sizeof(UV))
#define FROM_INTERNAL_SIZE(x) ((x)/ sizeof(UV))
PERL_STATIC_INLINE bool
S_is_invlist(const SV* const invlist)
{
return invlist != NULL && SvTYPE(invlist) == SVt_INVLIST;
}
PERL_STATIC_INLINE bool*
S_get_invlist_offset_addr(SV* invlist)
{
/* Return the address of the field that says whether the inversion list is
* offset (it contains 1) or not (contains 0) */
PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR;
assert(is_invlist(invlist));
return &(((XINVLIST*) SvANY(invlist))->is_offset);
}
PERL_STATIC_INLINE UV
S__invlist_len(SV* const invlist)
{
/* Returns the current number of elements stored in the inversion list's
* array */
PERL_ARGS_ASSERT__INVLIST_LEN;
assert(is_invlist(invlist));
return (SvCUR(invlist) == 0)
? 0
: FROM_INTERNAL_SIZE(SvCUR(invlist)) - *get_invlist_offset_addr(invlist);
}
PERL_STATIC_INLINE bool
S__invlist_contains_cp(SV* const invlist, const UV cp)
{
/* Does <invlist> contain code point <cp> as part of the set? */
IV index = _invlist_search(invlist, cp);
PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP;
return index >= 0 && ELEMENT_RANGE_MATCHES_INVLIST(index);
}
PERL_STATIC_INLINE UV*
S_invlist_array(SV* const invlist)
{
/* Returns the pointer to the inversion list's array. Every time the
* length changes, this needs to be called in case malloc or realloc moved
* it */
PERL_ARGS_ASSERT_INVLIST_ARRAY;
/* Must not be empty. If these fail, you probably didn't check for <len>
* being non-zero before trying to get the array */
assert(_invlist_len(invlist));
/* The very first element always contains zero, The array begins either
* there, or if the inversion list is offset, at the element after it.
* The offset header field determines which; it contains 0 or 1 to indicate
* how much additionally to add */
assert(0 == *(SvPVX(invlist)));
return ((UV *) SvPVX(invlist) + *get_invlist_offset_addr(invlist));
}
#endif
#if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C)
PERL_STATIC_INLINE void
S_invlist_extend(pTHX_ SV* const invlist, const UV new_max)
{
/* Grow the maximum size of an inversion list */
PERL_ARGS_ASSERT_INVLIST_EXTEND;
assert(SvTYPE(invlist) == SVt_INVLIST);
/* Add one to account for the zero element at the beginning which may not
* be counted by the calling parameters */
SvGROW((SV *)invlist, TO_INTERNAL_SIZE(new_max + 1));
}
PERL_STATIC_INLINE void
S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
{
/* Sets the current number of elements stored in the inversion list.
* Updates SvCUR correspondingly */
PERL_UNUSED_CONTEXT;
PERL_ARGS_ASSERT_INVLIST_SET_LEN;
assert(SvTYPE(invlist) == SVt_INVLIST);
SvCUR_set(invlist,
(len == 0)
? 0
: TO_INTERNAL_SIZE(len + offset));
assert(SvLEN(invlist) == 0 || SvCUR(invlist) <= SvLEN(invlist));
}
PERL_STATIC_INLINE SV*
S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) {
return _add_range_to_invlist(invlist, cp, cp);
}
PERL_STATIC_INLINE UV
S_invlist_highest(SV* const invlist)
{
/* Returns the highest code point that matches an inversion list. This API
* has an ambiguity, as it returns 0 under either the highest is actually
* 0, or if the list is empty. If this distinction matters to you, check
* for emptiness before calling this function */
UV len = _invlist_len(invlist);
UV *array;
PERL_ARGS_ASSERT_INVLIST_HIGHEST;
if (len == 0) {
return 0;
}
array = invlist_array(invlist);
/* The last element in the array in the inversion list always starts a
* range that goes to infinity. That range may be for code points that are
* matched in the inversion list, or it may be for ones that aren't
* matched. In the latter case, the highest code point in the set is one
* less than the beginning of this range; otherwise it is the final element
* of this range: infinity */
return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
? UV_MAX
: array[len - 1] - 1;
}
# if defined(PERL_IN_REGCOMP_ANY)
PERL_STATIC_INLINE UV
S_invlist_highest_range_start(SV* const invlist)
{
/* Returns the lowest code point of the highest range in the inversion
* list parameter. This API has an ambiguity: it returns 0 either when
* the lowest such point is actually 0 or when the list is empty. If this
* distinction matters to you, check for emptiness before calling this
* function. */
UV len = _invlist_len(invlist);
UV *array;
PERL_ARGS_ASSERT_INVLIST_HIGHEST_RANGE_START;
if (len == 0) {
return 0;
}
array = invlist_array(invlist);
/* The last element in the array in the inversion list always starts a
* range that goes to infinity. That range may be for code points that are
* matched in the inversion list, or it may be for ones that aren't
* matched. In the first case, the lowest code point in the matching range
* is that the one that started the range. If the other case, the final
* matching range begins at the next element down (which may be 0 in the
* edge case). */
return (ELEMENT_RANGE_MATCHES_INVLIST(len - 1))
? array[len - 1]
: len == 1
? 0
: array[len - 2];
}
# endif
#endif
#if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_OP_C)
PERL_STATIC_INLINE STRLEN*
S_get_invlist_iter_addr(SV* invlist)
{
/* Return the address of the UV that contains the current iteration
* position */
PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR;
assert(is_invlist(invlist));
return &(((XINVLIST*) SvANY(invlist))->iterator);
}
PERL_STATIC_INLINE void
S_invlist_iterinit(SV* invlist) /* Initialize iterator for invlist */
{
PERL_ARGS_ASSERT_INVLIST_ITERINIT;
*get_invlist_iter_addr(invlist) = 0;
}
PERL_STATIC_INLINE void
S_invlist_iterfinish(SV* invlist)
{
/* Terminate iterator for invlist. This is to catch development errors.
* Any iteration that is interrupted before completed should call this
* function. Functions that add code points anywhere else but to the end
* of an inversion list assert that they are not in the middle of an
* iteration. If they were, the addition would make the iteration
* problematical: if the iteration hadn't reached the place where things
* were being added, it would be ok */
PERL_ARGS_ASSERT_INVLIST_ITERFINISH;
*get_invlist_iter_addr(invlist) = (STRLEN) UV_MAX;
}
STATIC bool
S_invlist_iternext(SV* invlist, UV* start, UV* end)
{
/* An C<invlist_iterinit> call on <invlist> must be used to set this up.
* This call sets in <*start> and <*end>, the next range in <invlist>.
* Returns <TRUE> if successful and the next call will return the next
* range; <FALSE> if was already at the end of the list. If the latter,
* <*start> and <*end> are unchanged, and the next call to this function
* will start over at the beginning of the list */
STRLEN* pos = get_invlist_iter_addr(invlist);
UV len = _invlist_len(invlist);
UV *array;
PERL_ARGS_ASSERT_INVLIST_ITERNEXT;
if (*pos >= len) {
*pos = (STRLEN) UV_MAX; /* Force iterinit() to be required next time */
return FALSE;
}
array = invlist_array(invlist);
*start = array[(*pos)++];
if (*pos >= len) {
*end = UV_MAX;
}
else {
*end = array[(*pos)++] - 1;
}
return TRUE;
}
#endif
#ifndef PERL_IN_REGCOMP_ANY
/* These symbols are only needed later in regcomp.c */
# undef TO_INTERNAL_SIZE
# undef FROM_INTERNAL_SIZE
#endif
#ifdef PERL_IN_REGCOMP_ANY
PERL_STATIC_INLINE
bool
S_invlist_is_iterating(const SV* const invlist)
{
PERL_ARGS_ASSERT_INVLIST_IS_ITERATING;
/* get_invlist_iter_addr()'s sv is non-const only because it returns a
* value that can be used to modify the invlist, it doesn't modify the
* invlist itself */
return *(get_invlist_iter_addr((SV*)invlist)) < (STRLEN) UV_MAX;
}
PERL_STATIC_INLINE
SV *
S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style)
{
/* Get the contents of an inversion list into a string SV so that they can
* be printed out. If 'traditional_style' is TRUE, it uses the format
* traditionally done for debug tracing; otherwise it uses a format
* suitable for just copying to the output, with blanks between ranges and
* a dash between range components */
UV start, end;
SV* output;
const char intra_range_delimiter = (traditional_style ? '\t' : '-');
const char inter_range_delimiter = (traditional_style ? '\n' : ' ');
if (traditional_style) {
output = newSVpvs("\n");
}
else {
output = newSVpvs("");
}
PERL_ARGS_ASSERT_INVLIST_CONTENTS;
assert(! invlist_is_iterating(invlist));
invlist_iterinit(invlist);
while (invlist_iternext(invlist, &start, &end)) {
if (end == UV_MAX) {
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%cINFTY%c",
start, intra_range_delimiter,
inter_range_delimiter);
}
else if (end != start) {
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c%04" UVXf "%c",
start,
intra_range_delimiter,
end, inter_range_delimiter);
}
else {
Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c",
start, inter_range_delimiter);
}
}
if (SvCUR(output) && ! traditional_style) {/* Get rid of trailing blank */
SvCUR_set(output, SvCUR(output) - 1);
}
return output;
}
PERL_STATIC_INLINE
UV
S_invlist_lowest(SV* const invlist)
{
/* Returns the lowest code point that matches an inversion list. This API
* has an ambiguity, as it returns 0 under either the lowest is actually
* 0, or if the list is empty. If this distinction matters to you, check
* for emptiness before calling this function */
UV len = _invlist_len(invlist);
UV *array;
PERL_ARGS_ASSERT_INVLIST_LOWEST;
if (len == 0) {
return 0;
}
array = invlist_array(invlist);
return array[0];
}
#endif
#endif /* PERL_INVLIST_INLINE_H_ */

1422
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/iperlsys.h Normal file
View file

File diff suppressed because it is too large Load diff

284
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/keywords.h Normal file
View file

@ -0,0 +1,284 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* keywords.h
*
* Copyright (C) 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2005,
* 2006, 2007 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/keywords.pl from its data.
* Any changes made here will be lost!
*/
#define KEY_NULL 0
#define KEY___FILE__ 1
#define KEY___LINE__ 2
#define KEY___PACKAGE__ 3
#define KEY___CLASS__ 4
#define KEY___DATA__ 5
#define KEY___END__ 6
#define KEY___SUB__ 7
#define KEY_ADJUST 8
#define KEY_AUTOLOAD 9
#define KEY_BEGIN 10
#define KEY_UNITCHECK 11
#define KEY_DESTROY 12
#define KEY_END 13
#define KEY_INIT 14
#define KEY_CHECK 15
#define KEY_abs 16
#define KEY_accept 17
#define KEY_alarm 18
#define KEY_and 19
#define KEY_atan2 20
#define KEY_bind 21
#define KEY_binmode 22
#define KEY_bless 23
#define KEY_break 24
#define KEY_caller 25
#define KEY_catch 26
#define KEY_chdir 27
#define KEY_chmod 28
#define KEY_chomp 29
#define KEY_chop 30
#define KEY_chown 31
#define KEY_chr 32
#define KEY_chroot 33
#define KEY_class 34
#define KEY_close 35
#define KEY_closedir 36
#define KEY_cmp 37
#define KEY_connect 38
#define KEY_continue 39
#define KEY_cos 40
#define KEY_crypt 41
#define KEY_dbmclose 42
#define KEY_dbmopen 43
#define KEY_default 44
#define KEY_defer 45
#define KEY_defined 46
#define KEY_delete 47
#define KEY_die 48
#define KEY_do 49
#define KEY_dump 50
#define KEY_each 51
#define KEY_else 52
#define KEY_elsif 53
#define KEY_endgrent 54
#define KEY_endhostent 55
#define KEY_endnetent 56
#define KEY_endprotoent 57
#define KEY_endpwent 58
#define KEY_endservent 59
#define KEY_eof 60
#define KEY_eq 61
#define KEY_eval 62
#define KEY_evalbytes 63
#define KEY_exec 64
#define KEY_exists 65
#define KEY_exit 66
#define KEY_exp 67
#define KEY_fc 68
#define KEY_fcntl 69
#define KEY_field 70
#define KEY_fileno 71
#define KEY_finally 72
#define KEY_flock 73
#define KEY_for 74
#define KEY_foreach 75
#define KEY_fork 76
#define KEY_format 77
#define KEY_formline 78
#define KEY_ge 79
#define KEY_getc 80
#define KEY_getgrent 81
#define KEY_getgrgid 82
#define KEY_getgrnam 83
#define KEY_gethostbyaddr 84
#define KEY_gethostbyname 85
#define KEY_gethostent 86
#define KEY_getlogin 87
#define KEY_getnetbyaddr 88
#define KEY_getnetbyname 89
#define KEY_getnetent 90
#define KEY_getpeername 91
#define KEY_getpgrp 92
#define KEY_getppid 93
#define KEY_getpriority 94
#define KEY_getprotobyname 95
#define KEY_getprotobynumber 96
#define KEY_getprotoent 97
#define KEY_getpwent 98
#define KEY_getpwnam 99
#define KEY_getpwuid 100
#define KEY_getservbyname 101
#define KEY_getservbyport 102
#define KEY_getservent 103
#define KEY_getsockname 104
#define KEY_getsockopt 105
#define KEY_given 106
#define KEY_glob 107
#define KEY_gmtime 108
#define KEY_goto 109
#define KEY_grep 110
#define KEY_gt 111
#define KEY_hex 112
#define KEY_if 113
#define KEY_index 114
#define KEY_int 115
#define KEY_ioctl 116
#define KEY_isa 117
#define KEY_join 118
#define KEY_keys 119
#define KEY_kill 120
#define KEY_last 121
#define KEY_lc 122
#define KEY_lcfirst 123
#define KEY_le 124
#define KEY_length 125
#define KEY_link 126
#define KEY_listen 127
#define KEY_local 128
#define KEY_localtime 129
#define KEY_lock 130
#define KEY_log 131
#define KEY_lstat 132
#define KEY_lt 133
#define KEY_m 134
#define KEY_map 135
#define KEY_method 136
#define KEY_mkdir 137
#define KEY_msgctl 138
#define KEY_msgget 139
#define KEY_msgrcv 140
#define KEY_msgsnd 141
#define KEY_my 142
#define KEY_ne 143
#define KEY_next 144
#define KEY_no 145
#define KEY_not 146
#define KEY_oct 147
#define KEY_open 148
#define KEY_opendir 149
#define KEY_or 150
#define KEY_ord 151
#define KEY_our 152
#define KEY_pack 153
#define KEY_package 154
#define KEY_pipe 155
#define KEY_pop 156
#define KEY_pos 157
#define KEY_print 158
#define KEY_printf 159
#define KEY_prototype 160
#define KEY_push 161
#define KEY_q 162
#define KEY_qq 163
#define KEY_qr 164
#define KEY_quotemeta 165
#define KEY_qw 166
#define KEY_qx 167
#define KEY_rand 168
#define KEY_read 169
#define KEY_readdir 170
#define KEY_readline 171
#define KEY_readlink 172
#define KEY_readpipe 173
#define KEY_recv 174
#define KEY_redo 175
#define KEY_ref 176
#define KEY_rename 177
#define KEY_require 178
#define KEY_reset 179
#define KEY_return 180
#define KEY_reverse 181
#define KEY_rewinddir 182
#define KEY_rindex 183
#define KEY_rmdir 184
#define KEY_s 185
#define KEY_say 186
#define KEY_scalar 187
#define KEY_seek 188
#define KEY_seekdir 189
#define KEY_select 190
#define KEY_semctl 191
#define KEY_semget 192
#define KEY_semop 193
#define KEY_send 194
#define KEY_setgrent 195
#define KEY_sethostent 196
#define KEY_setnetent 197
#define KEY_setpgrp 198
#define KEY_setpriority 199
#define KEY_setprotoent 200
#define KEY_setpwent 201
#define KEY_setservent 202
#define KEY_setsockopt 203
#define KEY_shift 204
#define KEY_shmctl 205
#define KEY_shmget 206
#define KEY_shmread 207
#define KEY_shmwrite 208
#define KEY_shutdown 209
#define KEY_sin 210
#define KEY_sleep 211
#define KEY_socket 212
#define KEY_socketpair 213
#define KEY_sort 214
#define KEY_splice 215
#define KEY_split 216
#define KEY_sprintf 217
#define KEY_sqrt 218
#define KEY_srand 219
#define KEY_stat 220
#define KEY_state 221
#define KEY_study 222
#define KEY_sub 223
#define KEY_substr 224
#define KEY_symlink 225
#define KEY_syscall 226
#define KEY_sysopen 227
#define KEY_sysread 228
#define KEY_sysseek 229
#define KEY_system 230
#define KEY_syswrite 231
#define KEY_tell 232
#define KEY_telldir 233
#define KEY_tie 234
#define KEY_tied 235
#define KEY_time 236
#define KEY_times 237
#define KEY_tr 238
#define KEY_try 239
#define KEY_truncate 240
#define KEY_uc 241
#define KEY_ucfirst 242
#define KEY_umask 243
#define KEY_undef 244
#define KEY_unless 245
#define KEY_unlink 246
#define KEY_unpack 247
#define KEY_unshift 248
#define KEY_untie 249
#define KEY_until 250
#define KEY_use 251
#define KEY_utime 252
#define KEY_values 253
#define KEY_vec 254
#define KEY_wait 255
#define KEY_waitpid 256
#define KEY_wantarray 257
#define KEY_warn 258
#define KEY_when 259
#define KEY_while 260
#define KEY_write 261
#define KEY_x 262
#define KEY_xor 263
#define KEY_y 264
/* Generated from:
* c8b75109fa56ce3ea3f30503a3b398f02e49036dc60d5fb36ea5ba9ffd6c596e regen/keywords.pl
* ex: set ro ft=c: */

796
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/l1_char_class_tab.h Normal file
View file

@ -0,0 +1,796 @@
/* -*- mode: C; buffer-read-only: t -*-
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/mk_PL_charclass.pl from Unicode::UCD.
* Any changes made here will be lost!
*/
/* For code points whose position is not the same as Unicode, both are shown
* in the comment*/
#if 'A' == 65 /* ASCII/Latin1 */
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
/* U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* U+A1 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+A2 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+A3 POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+A4 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+A5 YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+A6 BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+A7 SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+A8 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+A9 COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+AA FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+AB LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+AC NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+AD SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+AE REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+AF MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+B0 DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+B1 PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+B2 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+B3 SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+B4 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+B5 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+B6 PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+B7 MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
/* U+B8 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+B9 SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+BA MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+BB RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+BC 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+BD 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+BE 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* U+BF INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+C0 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C1 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C2 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C3 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C4 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C5 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C6 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C7 C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C8 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+C9 E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CA E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CB E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CC I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CD I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CE I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+CF I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D0 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D1 N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D2 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D3 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D4 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D5 O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D6 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+D8 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+D9 U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DA U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DB U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DC U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DD Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DE THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* U+DF sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E0 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E1 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E2 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E3 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E4 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E5 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E6 ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E8 e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+E9 e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+EA e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+EB e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+EC i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+ED i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+EE i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+EF i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F0 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F1 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F2 o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F3 o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F4 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F5 o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F6 o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F7 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* U+F8 o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+F9 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FA u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FB u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FC u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FD y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FE thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* U+FF y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)
#endif /* ASCII/Latin1 */
#if 'A' == 193 /* EBCDIC 1047 */ \
&& '\\' == 224 && '[' == 173 && ']' == 189 && '{' == 192 && '}' == 208 \
&& '^' == 95 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 21
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x04 U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x05 U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x06 U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x07 U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x08 U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x09 U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x0A U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x14 U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x15 U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* 0x16 U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x17 U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x1A U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x1B U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x20 U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x21 U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x22 U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x23 U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x24 U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x25 U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* 0x26 U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x27 U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x28 U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x29 U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2A U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2B U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2C U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2D U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2E U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2F U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x30 U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x31 U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x32 U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x33 U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x34 U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x35 U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x36 U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x37 U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x38 U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x39 U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3A U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3B U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3C U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3D U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3E U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3F U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x40 U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x41 U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x42 U+E2 I8=A1 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x43 U+E4 I8=A2 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x44 U+E0 I8=A3 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x45 U+E1 I8=A4 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x46 U+E3 I8=A5 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x47 U+E5 I8=A6 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x48 U+E7 I8=A7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x49 U+F1 I8=A8 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x4A U+A2 I8=A9 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x4B U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4C U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4D U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4E U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4F U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x50 U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x51 U+E9 I8=AA e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x52 U+EA I8=AB e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x53 U+EB I8=AC e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x54 U+E8 I8=AD e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x55 U+ED I8=AE i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x56 U+EE I8=AF i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x57 U+EF I8=B0 i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x58 U+EC I8=B1 i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x59 U+DF I8=B2 sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x5A U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5B U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5C U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5D U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5E U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5F U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x60 U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x61 U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x62 U+C2 I8=B3 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x63 U+C4 I8=B4 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x64 U+C0 I8=B5 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x65 U+C1 I8=B6 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x66 U+C3 I8=B7 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x67 U+C5 I8=B8 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x68 U+C7 I8=B9 C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x69 U+D1 I8=BA N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x6A U+A6 I8=BB BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x6B U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6C U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6D U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
/* 0x6E U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6F U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x70 U+F8 I8=BC o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x71 U+C9 I8=BD E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x72 U+CA I8=BE E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x73 U+CB I8=BF E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x74 U+C8 I8=C0 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x75 U+CD I8=C1 I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x76 U+CE I8=C2 I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x77 U+CF I8=C3 I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x78 U+CC I8=C4 I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x79 U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7A U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7B U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7C U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7D U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7E U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7F U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x80 U+D8 I8=C5 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x81 U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x82 U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x83 U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x84 U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x85 U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x86 U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x87 U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x88 U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x89 U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8A U+AB I8=C6 LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x8B U+BB I8=C7 RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x8C U+F0 I8=C8 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8D U+FD I8=C9 y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8E U+FE I8=CA thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8F U+B1 I8=CB PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x90 U+B0 I8=CC DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x91 U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x92 U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x93 U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x94 U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x95 U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x96 U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x97 U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x98 U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x99 U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9A U+AA I8=CD FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9B U+BA I8=CE MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9C U+E6 I8=CF ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9D U+B8 I8=D0 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0x9E U+C6 I8=D1 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x9F U+A4 I8=D2 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xA0 U+B5 I8=D3 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA1 U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xA2 U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA3 U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA4 U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA5 U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA6 U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA7 U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA8 U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA9 U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xAA U+A1 I8=D4 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xAB U+BF I8=D5 INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xAC U+D0 I8=D6 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xAD U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xAE U+DE I8=D7 THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xAF U+AE I8=D8 REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB0 U+AC I8=D9 NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB1 U+A3 I8=DA POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB2 U+A5 I8=DB YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB3 U+B7 I8=DC MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
/* 0xB4 U+A9 I8=DD COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB5 U+A7 I8=DE SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+B6 I8=DF PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xB7 U+BC I8=E0 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xB8 U+BD I8=E1 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xB9 U+BE I8=E2 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBA U+DD I8=E3 Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xBB U+A8 I8=E4 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBC U+AF I8=E5 MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBD U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xBE U+B4 I8=E6 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBF U+D7 I8=E7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xC0 U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xC1 U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC2 U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC3 U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC4 U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC5 U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC6 U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC7 U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xC8 U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xC9 U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xCA U+AD I8=E8 SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xCB U+F4 I8=E9 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCC U+F6 I8=EA o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCD U+F2 I8=EB o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCE U+F3 I8=EC o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCF U+F5 I8=ED o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xD0 U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xD1 U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD2 U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD3 U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD4 U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD5 U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD6 U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD7 U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD8 U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD9 U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xDA U+B9 I8=EE SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xDB U+FB I8=EF u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDC U+FC I8=F0 u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDD U+F9 I8=F1 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDE U+FA I8=F2 u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDF U+FF I8=F3 y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xE0 U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xE1 U+F7 I8=F4 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xE2 U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE3 U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE4 U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE5 U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE6 U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE7 U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE8 U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE9 U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEA U+B2 I8=F5 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xEB U+D4 I8=F6 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEC U+D6 I8=F7 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xED U+D2 I8=F8 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEE U+D3 I8=F9 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEF U+D5 I8=FA O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xF0 U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF1 U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF2 U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF3 U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF4 U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF5 U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF6 U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF7 U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF8 U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF9 U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xFA U+B3 I8=FB SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xFB U+DB I8=FC U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFC U+DC I8=FD U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFD U+D9 I8=FE U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFE U+DA I8=FF U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFF U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)
#endif /* EBCDIC 1047 */
#if 'A' == 193 /* EBCDIC 037 */ \
&& '\\' == 224 && '[' == 186 && ']' == 187 && '{' == 192 && '}' == 208 \
&& '^' == 176 && '~' == 161 && '!' == 90 && '#' == 123 && '|' == 79 \
&& '$' == 91 && '@' == 124 && '`' == 121 && '\n' == 37
/* U+00 NUL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+01 SOH */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+02 STX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+03 ETX */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x04 U+9C ST */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x05 U+09 HT */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x06 U+86 SSA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x07 U+7F DEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x08 U+97 EPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x09 U+8D RI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x0A U+8E SS2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+0B VT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0C FF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0D CR */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* U+0E SO */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+0F SI */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+10 DLE */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+11 DC1 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+12 DC2 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+13 DC3 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x14 U+9D OSC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x15 U+85 NEL */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* 0x16 U+08 BS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x17 U+87 ESA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+18 CAN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+19 EOM */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x1A U+92 PU2 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x1B U+8F SS3 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1C FS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1D GS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1E RS */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* U+1F US */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x20 U+80 PAD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x21 U+81 HOP */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x22 U+82 BPH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x23 U+83 NBH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x24 U+84 IND */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x25 U+0A LF */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_)|(1U<<CC_VERTSPACE_),
/* 0x26 U+17 ETB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x27 U+1B ESC */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x28 U+88 HTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x29 U+89 HTJ */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2A U+8A VTS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2B U+8B PLD */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2C U+8C PLU */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2D U+05 ENQ */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2E U+06 ACK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x2F U+07 BEL */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_MNEMONIC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x30 U+90 DCS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x31 U+91 PU1 */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x32 U+16 SYN */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x33 U+93 STS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x34 U+94 CCH */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x35 U+95 MW */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x36 U+96 SPA */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x37 U+04 EOT */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x38 U+98 SOS */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x39 U+99 SGC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3A U+9A SCI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3B U+9B CSI */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3C U+14 DC4 */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3D U+15 NAK */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3E U+9E PM */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x3F U+1A SUB */ (1U<<CC_ASCII_)|(1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_),
/* 0x40 U+20 SP */ (1U<<CC_ASCII_)|(1U<<CC_BLANK_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x41 U+A0 NBSP */ (1U<<CC_BLANK_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_)|(1U<<CC_SPACE_),
/* 0x42 U+E2 I8=A1 a with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x43 U+E4 I8=A2 a with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x44 U+E0 I8=A3 a with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x45 U+E1 I8=A4 a with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x46 U+E3 I8=A5 a with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x47 U+E5 I8=A6 a with ring */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x48 U+E7 I8=A7 c with cedilla */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x49 U+F1 I8=A8 n with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x4A U+A2 I8=A9 CENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x4B U+2E '.' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4C U+3C '<' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4D U+28 '(' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4E U+2B '+' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x4F U+7C '|' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x50 U+26 '&' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x51 U+E9 I8=AA e with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x52 U+EA I8=AB e with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x53 U+EB I8=AC e with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x54 U+E8 I8=AD e with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x55 U+ED I8=AE i with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x56 U+EE I8=AF i with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x57 U+EF I8=B0 i with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x58 U+EC I8=B1 i with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x59 U+DF I8=B2 sharp s */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x5A U+21 '!' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5B U+24 '$' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5C U+2A '*' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5D U+29 ')' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5E U+3B ';' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x5F U+AC I8=B3 NOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x60 U+2D '-' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x61 U+2F '/' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x62 U+C2 I8=B4 A with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x63 U+C4 I8=B5 A with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x64 U+C0 I8=B6 A with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x65 U+C1 I8=B7 A with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x66 U+C3 I8=B8 A with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x67 U+C5 I8=B9 A with RING */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x68 U+C7 I8=BA C with CEDILLA */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x69 U+D1 I8=BB N with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x6A U+A6 I8=BC BROKEN BAR */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x6B U+2C ',' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6C U+25 '%' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6D U+5F '_' */ (1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_WORDCHAR_),
/* 0x6E U+3E '>' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x6F U+3F '?' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x70 U+F8 I8=BD o with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x71 U+C9 I8=BE E with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x72 U+CA I8=BF E with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x73 U+CB I8=C0 E with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x74 U+C8 I8=C1 E with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x75 U+CD I8=C2 I with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x76 U+CE I8=C3 I with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x77 U+CF I8=C4 I with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x78 U+CC I8=C5 I with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x79 U+60 '`' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7A U+3A ':' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7B U+23 '#' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7C U+40 '@' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7D U+27 "'" */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7E U+3D '=' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x7F U+22 '"' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x80 U+D8 I8=C6 O with '/' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x81 U+61 'a' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x82 U+62 'b' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x83 U+63 'c' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x84 U+64 'd' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x85 U+65 'e' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x86 U+66 'f' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0x87 U+67 'g' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x88 U+68 'h' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x89 U+69 'i' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8A U+AB I8=C7 LEFT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x8B U+BB I8=C8 RIGHT-POINTING DOUBLE ANGLE QUOTE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0x8C U+F0 I8=C9 eth */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8D U+FD I8=CA y with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8E U+FE I8=CB thorn */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x8F U+B1 I8=CC PLUS-MINUS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x90 U+B0 I8=CD DEGREE */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0x91 U+6A 'j' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x92 U+6B 'k' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x93 U+6C 'l' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x94 U+6D 'm' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x95 U+6E 'n' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x96 U+6F 'o' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x97 U+70 'p' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x98 U+71 'q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x99 U+72 'r' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9A U+AA I8=CE FEMININE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9B U+BA I8=CF MASCULINE ORDINAL */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9C U+E6 I8=D0 ae */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0x9D U+B8 I8=D1 CEDILLA */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0x9E U+C6 I8=D2 AE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0x9F U+A4 I8=D3 CURRENCY */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xA0 U+B5 I8=D4 MICRO */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA1 U+7E '~' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xA2 U+73 's' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA3 U+74 't' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA4 U+75 'u' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA5 U+76 'v' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA6 U+77 'w' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA7 U+78 'x' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA8 U+79 'y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xA9 U+7A 'z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xAA U+A1 I8=D5 INVERTED '!' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xAB U+BF I8=D6 INVERTED '?' */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xAC U+D0 I8=D7 ETH */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xAD U+DD I8=D8 Y with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xAE U+DE I8=D9 THORN */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xAF U+AE I8=DA REGISTERED */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB0 U+5E '^' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xB1 U+A3 I8=DB POUND */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB2 U+A5 I8=DC YEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB3 U+B7 I8=DD MIDDLE DOT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_),
/* 0xB4 U+A9 I8=DE COPYRIGHT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xB5 U+A7 I8=DF SECTION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* U+B6 I8=E0 PILCROW */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xB7 U+BC I8=E1 1/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xB8 U+BD I8=E2 1/2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xB9 U+BE I8=E3 3/4 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBA U+5B '[' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xBB U+5D ']' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xBC U+AF I8=E4 MACRON */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBD U+A8 I8=E5 DIAERESIS */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBE U+B4 I8=E6 ACUTE ACCENT */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xBF U+D7 I8=E7 MULTIPLICATION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xC0 U+7B '{' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xC1 U+41 'A' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC2 U+42 'B' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC3 U+43 'C' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC4 U+44 'D' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC5 U+45 'E' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC6 U+46 'F' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xC7 U+47 'G' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xC8 U+48 'H' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xC9 U+49 'I' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xCA U+AD I8=E8 SOFT HYPHEN */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xCB U+F4 I8=E9 o with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCC U+F6 I8=EA o with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCD U+F2 I8=EB o with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCE U+F3 I8=EC o with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xCF U+F5 I8=ED o with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xD0 U+7D '}' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xD1 U+4A 'J' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD2 U+4B 'K' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD3 U+4C 'L' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD4 U+4D 'M' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD5 U+4E 'N' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD6 U+4F 'O' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD7 U+50 'P' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD8 U+51 'Q' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xD9 U+52 'R' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xDA U+B9 I8=EE SUPERSCRIPT 1 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xDB U+FB I8=EF u with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDC U+FC I8=F0 u with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDD U+F9 I8=F1 u with grave */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDE U+FA I8=F2 u with acute */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xDF U+FF I8=F3 y with diaeresis */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_LOWER_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_),
/* 0xE0 U+5C '\' */ (1U<<CC_ASCII_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_PUNCT_)|(1U<<CC_QUOTEMETA_),
/* 0xE1 U+F7 I8=F4 DIVISION */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_QUOTEMETA_),
/* 0xE2 U+53 'S' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NONLATIN1_SIMPLE_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE3 U+54 'T' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE4 U+55 'U' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE5 U+56 'V' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE6 U+57 'W' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE7 U+58 'X' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE8 U+59 'Y' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_NONLATIN1_FOLD_)|(1U<<CC_NON_FINAL_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xE9 U+5A 'Z' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEA U+B2 I8=F5 SUPERSCRIPT 2 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xEB U+D4 I8=F6 O with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEC U+D6 I8=F7 O with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xED U+D2 I8=F8 O with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEE U+D3 I8=F9 O with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xEF U+D5 I8=FA O with '~' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xF0 U+30 '0' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF1 U+31 '1' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_BINDIGIT_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF2 U+32 '2' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF3 U+33 '3' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF4 U+34 '4' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF5 U+35 '5' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF6 U+36 '6' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF7 U+37 '7' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_OCTDIGIT_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF8 U+38 '8' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xF9 U+39 '9' */ (1U<<CC_ALPHANUMERIC_)|(1U<<CC_ASCII_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_DIGIT_)|(1U<<CC_GRAPH_)|(1U<<CC_PRINT_)|(1U<<CC_WORDCHAR_)|(1U<<CC_XDIGIT_),
/* 0xFA U+B3 I8=FB SUPERSCRIPT 3 */ (1U<<CC_GRAPH_)|(1U<<CC_PRINT_),
/* 0xFB U+DB I8=FC U with '^' */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFC U+DC I8=FD U with DIAERESIS */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFD U+D9 I8=FE U with GRAVE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFE U+DA I8=FF U with ACUTE */ (1U<<CC_ALPHA_)|(1U<<CC_ALPHANUMERIC_)|(1U<<CC_CASED_)|(1U<<CC_CHARNAME_CONT_)|(1U<<CC_GRAPH_)|(1U<<CC_IDFIRST_)|(1U<<CC_IS_IN_SOME_FOLD_)|(1U<<CC_PRINT_)|(1U<<CC_UPPER_)|(1U<<CC_WORDCHAR_),
/* 0xFF U+9F APC */ (1U<<CC_CNTRL_)|(1U<<CC_QUOTEMETA_)
#endif /* EBCDIC 037 */
/* ex: set ro ft=c: */

BIN
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/libperl.dll.a Normal file
View file

Binary file not shown.

242
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/locale_table.h Normal file
View file

@ -0,0 +1,242 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* locale_table.h
*
* Copyright (C) 2023, 2024 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/locale.pl from data in regen/locale.pl.
* Any changes made here will be lost!
*/
/* This defines a macro for each individual locale category used on the this
* system. (The congomerate category LC_ALL is not included.) This
* file will be #included as the interior of various parallel arrays and in
* other constructs; each usage will re-#define the macro to generate its
* appropriate data.
*
* This guarantees the arrays will be parallel, and populated in the order
* given here. That order is mostly arbitrary. LC_CTYPE is first because when
* we are setting multiple categories, CTYPE often needs to match the other(s),
* and the way the code is constructed, if we set the other category first, we
* might otherwise have to set CTYPE twice.
*
* Each entry takes the token giving the category name, and either the name of
* a function to call that does specialized set up for this category when it is
* changed into, or NULL if no such set up is needed
*/
#ifdef LC_CTYPE
# if defined(NO_LOCALE) || defined(NO_LOCALE_CTYPE)
PERL_LOCALE_TABLE_ENTRY(CTYPE, NULL)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_CTYPE_AVAIL_ 0
# else
PERL_LOCALE_TABLE_ENTRY(CTYPE, S_new_ctype)
# define LC_CTYPE_AVAIL_ 1
# define USE_LOCALE_CTYPE
# endif
#else
# define LC_CTYPE_AVAIL_ 0
#endif
#ifdef LC_NUMERIC
# if defined(NO_LOCALE) || defined(NO_LOCALE_NUMERIC)
PERL_LOCALE_TABLE_ENTRY(NUMERIC, NULL)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_NUMERIC_AVAIL_ 0
# else
PERL_LOCALE_TABLE_ENTRY(NUMERIC, S_new_numeric)
# define LC_NUMERIC_AVAIL_ 1
# define USE_LOCALE_NUMERIC
# endif
#else
# define LC_NUMERIC_AVAIL_ 0
#endif
#ifdef LC_COLLATE
/* Perl outsources all its collation efforts to the libc strxfrm(), so
* if it isn't available on the system, default "C" locale collation
* gets used */
# if defined(NO_LOCALE) || defined(NO_LOCALE_COLLATE) || ! defined(HAS_STRXFRM)
PERL_LOCALE_TABLE_ENTRY(COLLATE, NULL)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_COLLATE_AVAIL_ 0
# else
PERL_LOCALE_TABLE_ENTRY(COLLATE, S_new_collate)
# define LC_COLLATE_AVAIL_ 1
# define USE_LOCALE_COLLATE
# endif
#else
# define LC_COLLATE_AVAIL_ 0
#endif
#ifdef LC_TIME
PERL_LOCALE_TABLE_ENTRY(TIME, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_TIME)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_TIME_AVAIL_ 0
# else
# define LC_TIME_AVAIL_ 1
# define USE_LOCALE_TIME
# endif
#else
# define LC_TIME_AVAIL_ 0
#endif
#ifdef LC_MESSAGES
PERL_LOCALE_TABLE_ENTRY(MESSAGES, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_MESSAGES)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_MESSAGES_AVAIL_ 0
# else
# define LC_MESSAGES_AVAIL_ 1
# define USE_LOCALE_MESSAGES
# endif
#else
# define LC_MESSAGES_AVAIL_ 0
#endif
#ifdef LC_MONETARY
PERL_LOCALE_TABLE_ENTRY(MONETARY, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_MONETARY)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_MONETARY_AVAIL_ 0
# else
# define LC_MONETARY_AVAIL_ 1
# define USE_LOCALE_MONETARY
# endif
#else
# define LC_MONETARY_AVAIL_ 0
#endif
#ifdef LC_ADDRESS
PERL_LOCALE_TABLE_ENTRY(ADDRESS, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_ADDRESS)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_ADDRESS_AVAIL_ 0
# else
# define LC_ADDRESS_AVAIL_ 1
# define USE_LOCALE_ADDRESS
# endif
#else
# define LC_ADDRESS_AVAIL_ 0
#endif
#ifdef LC_IDENTIFICATION
PERL_LOCALE_TABLE_ENTRY(IDENTIFICATION, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_IDENTIFICATION)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_IDENTIFICATION_AVAIL_ 0
# else
# define LC_IDENTIFICATION_AVAIL_ 1
# define USE_LOCALE_IDENTIFICATION
# endif
#else
# define LC_IDENTIFICATION_AVAIL_ 0
#endif
#ifdef LC_MEASUREMENT
PERL_LOCALE_TABLE_ENTRY(MEASUREMENT, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_MEASUREMENT)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_MEASUREMENT_AVAIL_ 0
# else
# define LC_MEASUREMENT_AVAIL_ 1
# define USE_LOCALE_MEASUREMENT
# endif
#else
# define LC_MEASUREMENT_AVAIL_ 0
#endif
#ifdef LC_PAPER
PERL_LOCALE_TABLE_ENTRY(PAPER, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_PAPER)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_PAPER_AVAIL_ 0
# else
# define LC_PAPER_AVAIL_ 1
# define USE_LOCALE_PAPER
# endif
#else
# define LC_PAPER_AVAIL_ 0
#endif
#ifdef LC_TELEPHONE
PERL_LOCALE_TABLE_ENTRY(TELEPHONE, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_TELEPHONE)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_TELEPHONE_AVAIL_ 0
# else
# define LC_TELEPHONE_AVAIL_ 1
# define USE_LOCALE_TELEPHONE
# endif
#else
# define LC_TELEPHONE_AVAIL_ 0
#endif
#ifdef LC_NAME
PERL_LOCALE_TABLE_ENTRY(NAME, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_NAME)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_NAME_AVAIL_ 0
# else
# define LC_NAME_AVAIL_ 1
# define USE_LOCALE_NAME
# endif
#else
# define LC_NAME_AVAIL_ 0
#endif
#ifdef LC_SYNTAX
PERL_LOCALE_TABLE_ENTRY(SYNTAX, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_SYNTAX)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_SYNTAX_AVAIL_ 0
# else
# define LC_SYNTAX_AVAIL_ 1
# define USE_LOCALE_SYNTAX
# endif
#else
# define LC_SYNTAX_AVAIL_ 0
#endif
#ifdef LC_TOD
PERL_LOCALE_TABLE_ENTRY(TOD, NULL)
# if defined(NO_LOCALE) || defined(NO_LOCALE_TOD)
# define HAS_IGNORED_LOCALE_CATEGORIES_
# define LC_TOD_AVAIL_ 0
# else
# define LC_TOD_AVAIL_ 1
# define USE_LOCALE_TOD
# endif
#else
# define LC_TOD_AVAIL_ 0
#endif
/* ex: set ro ft=c: */

62
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/malloc_ctl.h Normal file
View file

@ -0,0 +1,62 @@
#ifndef PERL_MALLOC_CTL_H_
# define PERL_MALLOC_CTL_H_
struct perl_mstats {
UV *nfree;
UV *ntotal;
IV topbucket, topbucket_ev, topbucket_odd, totfree, total, total_chain;
IV total_sbrk, sbrks, sbrk_good, sbrk_slack, start_slack, sbrked_remains;
IV minbucket;
/* Level 1 info */
UV *bucket_mem_size;
UV *bucket_available_size;
UV nbuckets;
};
typedef struct perl_mstats perl_mstats_t;
PERL_CALLCONV Malloc_t Perl_malloc (MEM_SIZE nbytes);
PERL_CALLCONV Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size);
PERL_CALLCONV Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes);
/* 'mfree' rather than 'free', since there is already a 'perl_free'
* that causes clashes with case-insensitive linkers */
PERL_CALLCONV Free_t Perl_mfree (Malloc_t where);
#ifndef NO_MALLOC_DYNAMIC_CFG
/* IV configuration data */
enum {
MallocCfg_FIRST_SBRK,
MallocCfg_MIN_SBRK,
MallocCfg_MIN_SBRK_FRAC1000,
MallocCfg_SBRK_ALLOW_FAILURES,
MallocCfg_SBRK_FAILURE_PRICE,
MallocCfg_sbrk_goodness,
MallocCfg_filldead,
MallocCfg_fillalive,
MallocCfg_fillcheck,
MallocCfg_skip_cfg_env,
MallocCfg_cfg_env_read,
MallocCfg_emergency_buffer_size,
MallocCfg_emergency_buffer_last_req,
MallocCfg_emergency_buffer_prepared_size,
MallocCfg_last
};
/* char* configuration data */
enum {
MallocCfgP_emergency_buffer,
MallocCfgP_emergency_buffer_prepared,
MallocCfgP_last
};
START_EXTERN_C
extern IV *MallocCfg_ptr;
extern char **MallocCfgP_ptr;
END_EXTERN_C
#endif
#endif

124
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/metaconfig.h Normal file
View file

@ -0,0 +1,124 @@
/* This is a placeholder file for symbols that should be exported
* into config_h.SH and Porting/Glossary. See also metaconfig.SH
*
* First version was created from the part in handy.h
* H.Merijn Brand 21 Dec 2010 (Tux)
*
* Mentioned variables are forced to be included into config_h.SH
* as they are only included if meta finds them referenced. That
* implies that noone can use them unless they are available and
* they won't be available unless used. When new symbols are probed
* in Configure, this is the way to force them into availability.
*
* Symbols should only be here temporarily. Once they are actually used,
* they should be removed from here.
*
* BIN
* CASTI32
* CASTNEGFLOAT
* CPPLAST
* CPPMINUS
* CPPRUN
* CPPSTDIN
* DOSUID
* DOUBLE_HAS_NEGATIVE_ZERO
* DOUBLE_HAS_SUBNORMALS
* DOUBLEMANTBITS
* DOUBLE_STYLE_CRAY
* DOUBLE_STYLE_IBM
* DOUBLE_STYLE_IEEE
* DOUBLE_STYLE_VAX
* DRAND48_R_PROTO
* Gid_t_f
* HAS_ASCTIME64
* HAS_ATOLF
* HAS_BUILTIN_ADD_OVERFLOW
* HAS_BUILTIN_MUL_OVERFLOW
* HAS_BUILTIN_SUB_OVERFLOW
* HAS_CSH
* HAS_CTERMID
* HAS_CTIME64
* HAS_DIFFTIME64
* HAS_DRAND48_PROTO
* HAS_DRAND48_R
* HAS_FD_SET
* HAS_FFS
* HAS_FFSL
* HAS_GETMNT
* HAS_GMTIME64
* HAS_GNULIBC
* HAS_INT64_T
* HAS_IPV6_MREQ_SOURCE
* HAS_ISLESS
* HAS_ISNORMAL
* HAS_LGAMMA_R
* HAS_LOCALECONV_L
* HAS_LOCALTIME64
* HAS_LSEEK_PROTO
* HAS_MKTIME64
* HAS_NANOSLEEP
* HAS_OPEN3
* HAS_OPENAT
* HAS_PRCTL
* HAS_PSEUDOFORK
* HAS_RANDOM_R
* HAS_SIGINFO_SI_VALUE
* HAS_SIGSETJMP
* HAS_SRAND48_R
* HAS_SRANDOM_R
* HAS_STRTOD_L
* HAS_STRTOLD_L
* HAS_STRUCT_FS_DATA
* HAS_STRUCT_STATFS
* HAS_STRUCT_STATFS_F_FLAGS
* HAS_TIME
* HAS_USTAT
* HAS_VFORK
* HAS_WCSCMP
* HAS_WCSXFRM
* I16SIZE
* I32SIZE
* I64SIZE
* I8SIZE
* I_GDBM
* INSTALL_USR_BIN_PERL
* I_STDBOOL
* I_SYS_MOUNT
* I_SYS_STATFS
* I_SYS_STATVFS
* I_SYS_VFS
* I_TIME
* I_USTAT
* I_VFORK
* I_XLOCALE
* LOCALTIME_R_NEEDS_TZSET
* LOC_SED
* LONGDBLMANTBITS
* LONG_DOUBLE_STYLE_IEEE
* LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE
* LONG_DOUBLE_STYLE_IEEE_EXTENDED
* LONG_DOUBLE_STYLE_IEEE_STD
* LONG_DOUBLE_STYLE_VAX
* OSVERS
* PERL_LC_ALL_CATEGORY_POSITIONS_INIT
* PERL_LC_ALL_SEPARATOR
* PERL_LC_ALL_USES_NAME_VALUE_PAIRS
* PERL_PRIeldbl
* PERL_SCNfldbl
* PERL_TARGETARCH
* PERL_VENDORARCH
* RANDOM_R_PROTO
* SRAND48_R_PROTO
* SRANDOM_R_PROTO
* STARTPERL
* ST_INO_SIGN
* ST_INO_SIZE
* U32_ALIGNMENT_REQUIRED
* U32of
* U32xf
* U32Xf
* U8SIZE
* Uid_t_f
* USE_CROSS_COMPILE
* USE_MORE_BITS
*/

89
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg.h Normal file
View file

@ -0,0 +1,89 @@
/* mg.h
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
* 2000, 2002, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
struct mgvtbl {
int (*svt_get) (pTHX_ SV *sv, MAGIC* mg);
int (*svt_set) (pTHX_ SV *sv, MAGIC* mg);
U32 (*svt_len) (pTHX_ SV *sv, MAGIC* mg);
int (*svt_clear) (pTHX_ SV *sv, MAGIC* mg);
int (*svt_free) (pTHX_ SV *sv, MAGIC* mg);
int (*svt_copy) (pTHX_ SV *sv, MAGIC* mg,
SV *nsv, const char *name, I32 namlen);
int (*svt_dup) (pTHX_ MAGIC *mg, CLONE_PARAMS *param);
int (*svt_local)(pTHX_ SV *nsv, MAGIC *mg);
};
struct magic {
MAGIC* mg_moremagic;
MGVTBL* mg_virtual; /* pointer to magic functions */
U16 mg_private;
char mg_type;
U8 mg_flags;
SSize_t mg_len;
SV* mg_obj;
char* mg_ptr;
};
#define MGf_TAINTEDDIR 1 /* PERL_MAGIC_envelem only */
#define MGf_MINMATCH 1 /* PERL_MAGIC_regex_global only */
#define MGf_REQUIRE_GV 1 /* PERL_MAGIC_checkcall only */
#define MGf_REFCOUNTED 2
#define MGf_GSKIP 4 /* skip further GETs until after next SET */
#define MGf_COPY 8 /* has an svt_copy MGVTBL entry */
#define MGf_DUP 0x10 /* has an svt_dup MGVTBL entry */
#define MGf_LOCAL 0x20 /* has an svt_local MGVTBL entry */
#define MGf_BYTES 0x40 /* PERL_MAGIC_regex_global only */
#define MGf_PERSIST 0x80 /* PERL_MAGIC_lvref only */
#define MgTAINTEDDIR(mg) (mg->mg_flags & MGf_TAINTEDDIR)
#define MgTAINTEDDIR_on(mg) (mg->mg_flags |= MGf_TAINTEDDIR)
#define MgTAINTEDDIR_off(mg) (mg->mg_flags &= ~MGf_TAINTEDDIR)
/* Extracts the SV stored in mg, or NULL. */
#define MgSV(mg) (((int)((mg)->mg_len) == HEf_SVKEY) ? \
MUTABLE_SV((mg)->mg_ptr) : \
NULL)
/* If mg contains an SV, these extract the PV stored in that SV;
otherwise, these extract the mg's mg_ptr/mg_len.
These do NOT account for the SV's UTF8 flag, so handle with care.
*/
#define MgPV(mg,lp) ((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ? \
SvPV(MUTABLE_SV((mg)->mg_ptr),lp) : \
(mg)->mg_ptr)
#define MgPV_const(mg,lp) ((((int)(lp = (mg)->mg_len)) == HEf_SVKEY) ? \
SvPV_const(MUTABLE_SV((mg)->mg_ptr),lp) : \
(const char*)(mg)->mg_ptr)
#define MgPV_nolen_const(mg) (((((int)(mg)->mg_len)) == HEf_SVKEY) ? \
SvPV_nolen_const(MUTABLE_SV((mg)->mg_ptr)) : \
(const char*)(mg)->mg_ptr)
#define SvTIED_mg(sv,how) (SvRMAGICAL(sv) ? mg_find((sv),(how)) : NULL)
#define SvTIED_obj(sv,mg) \
((mg)->mg_obj ? (mg)->mg_obj : sv_2mortal(newRV(sv)))
#if defined(PERL_CORE) || defined(PERL_EXT)
# define MgBYTEPOS(mg,sv,pv,len) S_MgBYTEPOS(aTHX_ mg,sv,pv,len)
/* assumes get-magic and stringification have already occurred */
# define MgBYTEPOS_set(mg,sv,pv,off) ( \
assert_((mg)->mg_type == PERL_MAGIC_regex_global) \
SvPOK(sv) && (!SvGMAGICAL(sv) || sv_only_taint_gmagic(sv)) \
? (mg)->mg_len = (off), (mg)->mg_flags |= MGf_BYTES \
: ((mg)->mg_len = DO_UTF8(sv) \
? (SSize_t)utf8_length((U8 *)(pv), (U8 *)(pv)+(off)) \
: (SSize_t)(off), \
(mg)->mg_flags &= ~MGf_BYTES))
#endif
#define whichsig(pv) whichsig_pv(pv)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

312
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_data.h Normal file
View file

@ -0,0 +1,312 @@
/* mg_data.h:
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
*
* These values will populate PL_magic_data[]: this is an array of
* per-magic U8 values containing an index into PL_magic_vtables[]
* plus two flags:
* PERL_MAGIC_READONLY_ACCEPTABLE
* PERL_MAGIC_VALUE_MAGIC
*/
{
/* sv '\0' Special scalar variable */
want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
/* arylen '#' Array length ($#ary) */
want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC,
0,
/* rhash '%' Extra data for restricted hashes */
magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
0,
0,
0,
0,
/* debugvar '*' $DB::single, signal, trace vars */
want_vtbl_debugvar,
0,
0,
0,
/* pos '.' pos() lvalue */
want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
/* symtab ':' Extra data for symbol tables */
magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
0,
/* backref '<' For weak ref data */
want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
0,
0,
0,
/* arylen_p '@' To move arylen out of XPVAV */
magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
0,
/* bm 'B' Boyer-Moore (fast string search) */
want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
0,
/* regdata 'D' Regex match position data (@+ and @- vars) */
want_vtbl_regdata,
/* env 'E' %ENV hash */
want_vtbl_env,
0,
0,
/* hints 'H' %^H hash */
want_vtbl_hints,
/* isa 'I' @ISA array */
want_vtbl_isa,
0,
0,
/* dbfile 'L' Debugger %_<filename */
magic_vtable_max,
0,
0,
0,
/* tied 'P' Tied array or hash */
want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC,
0,
0,
/* sig 'S' %SIG hash */
want_vtbl_sig,
0,
/* uvar 'U' Available for use by extensions */
want_vtbl_uvar,
/* vstring 'V' SV was vstring literal */
magic_vtable_max | PERL_MAGIC_VALUE_MAGIC,
0,
/* destruct 'X' destruct callback */
want_vtbl_destruct | PERL_MAGIC_VALUE_MAGIC,
/* nonelem 'Y' Array element that does not exist */
want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC,
/* hook 'Z' %{^HOOK} hash */
want_vtbl_hook,
0,
/* lvref '\' Lvalue reference constructor */
want_vtbl_lvref,
/* checkcall ']' Inlining/mutation of call to this CV */
want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC,
/* extvalue '^' Value magic available for use by extensions */
magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
0,
0,
0,
0,
/* overload_table 'c' Holds overload table (AMT) on stash */
want_vtbl_ovrld,
/* regdatum 'd' Regex match position data element */
want_vtbl_regdatum,
/* envelem 'e' %ENV hash element */
want_vtbl_envelem,
/* fm 'f' Formline ('compiled' format) */
want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
/* regex_global 'g' m//g target */
want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
/* hintselem 'h' %^H hash element */
want_vtbl_hintselem,
/* isaelem 'i' @ISA array element */
want_vtbl_isaelem,
0,
/* nkeys 'k' scalar(keys()) lvalue */
want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC,
/* dbline 'l' Debugger %_<filename element */
want_vtbl_dbline,
0,
0,
/* collxfrm 'o' Locale transformation */
want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC,
/* tiedelem 'p' Tied array or hash element */
want_vtbl_packelem,
/* tiedscalar 'q' Tied scalar or handle */
want_vtbl_packelem,
/* qr 'r' Precompiled qr// regex */
want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC,
/* sigelem 's' %SIG hash element */
want_vtbl_sigelem,
/* taint 't' Taintedness */
want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC,
0,
/* vec 'v' vec() lvalue */
want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC,
/* utf8 'w' Cached UTF-8 information */
want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC,
/* substr 'x' substr() lvalue */
want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC,
/* defelem 'y' Shadow "foreach" iterator variable / smart parameter vivification */
want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC,
/* hookelem 'z' %{^HOOK} hash element */
want_vtbl_hookelem,
0,
0,
0,
/* ext '~' Variable magic available for use by extensions */
magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
}

100
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_raw.h Normal file
View file

@ -0,0 +1,100 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* mg_raw.h
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/mg_vtable.pl.
* Any changes made here will be lost!
*/
{ '\0', "want_vtbl_sv | PERL_MAGIC_READONLY_ACCEPTABLE",
"/* sv '\\0' Special scalar variable */" },
{ '#', "want_vtbl_arylen | PERL_MAGIC_VALUE_MAGIC",
"/* arylen '#' Array length ($#ary) */" },
{ '%', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
"/* rhash '%' Extra data for restricted hashes */" },
{ '*', "want_vtbl_debugvar",
"/* debugvar '*' $DB::single, signal, trace vars */" },
{ '.', "want_vtbl_pos | PERL_MAGIC_VALUE_MAGIC",
"/* pos '.' pos() lvalue */" },
{ ':', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
"/* symtab ':' Extra data for symbol tables */" },
{ '<', "want_vtbl_backref | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* backref '<' For weak ref data */" },
{ '@', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
"/* arylen_p '@' To move arylen out of XPVAV */" },
{ 'B', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* bm 'B' Boyer-Moore (fast string search) */" },
{ 'c', "want_vtbl_ovrld",
"/* overload_table 'c' Holds overload table (AMT) on stash */" },
{ 'D', "want_vtbl_regdata",
"/* regdata 'D' Regex match position data (@+ and @- vars) */" },
{ 'd', "want_vtbl_regdatum",
"/* regdatum 'd' Regex match position data element */" },
{ 'E', "want_vtbl_env",
"/* env 'E' %ENV hash */" },
{ 'e', "want_vtbl_envelem",
"/* envelem 'e' %ENV hash element */" },
{ 'f', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* fm 'f' Formline ('compiled' format) */" },
{ 'g', "want_vtbl_mglob | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* regex_global 'g' m//g target */" },
{ 'H', "want_vtbl_hints",
"/* hints 'H' %^H hash */" },
{ 'h', "want_vtbl_hintselem",
"/* hintselem 'h' %^H hash element */" },
{ 'I', "want_vtbl_isa",
"/* isa 'I' @ISA array */" },
{ 'i', "want_vtbl_isaelem",
"/* isaelem 'i' @ISA array element */" },
{ 'k', "want_vtbl_nkeys | PERL_MAGIC_VALUE_MAGIC",
"/* nkeys 'k' scalar(keys()) lvalue */" },
{ 'L', "magic_vtable_max",
"/* dbfile 'L' Debugger %_<filename */" },
{ 'l', "want_vtbl_dbline",
"/* dbline 'l' Debugger %_<filename element */" },
{ 'o', "want_vtbl_collxfrm | PERL_MAGIC_VALUE_MAGIC",
"/* collxfrm 'o' Locale transformation */" },
{ 'P', "want_vtbl_pack | PERL_MAGIC_VALUE_MAGIC",
"/* tied 'P' Tied array or hash */" },
{ 'p', "want_vtbl_packelem",
"/* tiedelem 'p' Tied array or hash element */" },
{ 'q', "want_vtbl_packelem",
"/* tiedscalar 'q' Tied scalar or handle */" },
{ 'r', "want_vtbl_regexp | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* qr 'r' Precompiled qr// regex */" },
{ 'S', "want_vtbl_sig",
"/* sig 'S' %SIG hash */" },
{ 's', "want_vtbl_sigelem",
"/* sigelem 's' %SIG hash element */" },
{ 't', "want_vtbl_taint | PERL_MAGIC_VALUE_MAGIC",
"/* taint 't' Taintedness */" },
{ 'U', "want_vtbl_uvar",
"/* uvar 'U' Available for use by extensions */" },
{ 'V', "magic_vtable_max | PERL_MAGIC_VALUE_MAGIC",
"/* vstring 'V' SV was vstring literal */" },
{ 'v', "want_vtbl_vec | PERL_MAGIC_VALUE_MAGIC",
"/* vec 'v' vec() lvalue */" },
{ 'w', "want_vtbl_utf8 | PERL_MAGIC_VALUE_MAGIC",
"/* utf8 'w' Cached UTF-8 information */" },
{ 'X', "want_vtbl_destruct | PERL_MAGIC_VALUE_MAGIC",
"/* destruct 'X' destruct callback */" },
{ 'x', "want_vtbl_substr | PERL_MAGIC_VALUE_MAGIC",
"/* substr 'x' substr() lvalue */" },
{ 'Y', "want_vtbl_nonelem | PERL_MAGIC_VALUE_MAGIC",
"/* nonelem 'Y' Array element that does not exist */" },
{ 'y', "want_vtbl_defelem | PERL_MAGIC_VALUE_MAGIC",
"/* defelem 'y' Shadow \"foreach\" iterator variable / smart parameter vivification */" },
{ 'Z', "want_vtbl_hook",
"/* hook 'Z' %{^HOOK} hash */" },
{ 'z', "want_vtbl_hookelem",
"/* hookelem 'z' %{^HOOK} hash element */" },
{ '\\', "want_vtbl_lvref",
"/* lvref '\\' Lvalue reference constructor */" },
{ ']', "want_vtbl_checkcall | PERL_MAGIC_VALUE_MAGIC",
"/* checkcall ']' Inlining/mutation of call to this CV */" },
{ '^', "magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE | PERL_MAGIC_VALUE_MAGIC",
"/* extvalue '^' Value magic available for use by extensions */" },
{ '~', "magic_vtable_max | PERL_MAGIC_READONLY_ACCEPTABLE",
"/* ext '~' Variable magic available for use by extensions */" },
/* ex: set ro ft=c: */

255
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mg_vtable.h Normal file
View file

@ -0,0 +1,255 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* mg_vtable.h
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/mg_vtable.pl.
* Any changes made here will be lost!
*/
/* These constants should be used in preference to raw characters
* when using magic. Note that some perl guts still assume
* certain character properties of these constants, namely that
* isUPPER() and toLOWER() may do useful mappings.
*/
#define PERL_MAGIC_sv '\0' /* Special scalar variable */
#define PERL_MAGIC_arylen '#' /* Array length ($#ary) */
#define PERL_MAGIC_rhash '%' /* Extra data for restricted hashes */
#define PERL_MAGIC_debugvar '*' /* $DB::single, signal, trace vars */
#define PERL_MAGIC_pos '.' /* pos() lvalue */
#define PERL_MAGIC_symtab ':' /* Extra data for symbol tables */
#define PERL_MAGIC_backref '<' /* For weak ref data */
#define PERL_MAGIC_arylen_p '@' /* To move arylen out of XPVAV */
#define PERL_MAGIC_bm 'B' /* Boyer-Moore (fast string search) */
#define PERL_MAGIC_overload_table 'c' /* Holds overload table (AMT) on stash */
#define PERL_MAGIC_regdata 'D' /* Regex match position data
(@+ and @- vars) */
#define PERL_MAGIC_regdatum 'd' /* Regex match position data element */
#define PERL_MAGIC_env 'E' /* %ENV hash */
#define PERL_MAGIC_envelem 'e' /* %ENV hash element */
#define PERL_MAGIC_fm 'f' /* Formline ('compiled' format) */
#define PERL_MAGIC_regex_global 'g' /* m//g target */
#define PERL_MAGIC_hints 'H' /* %^H hash */
#define PERL_MAGIC_hintselem 'h' /* %^H hash element */
#define PERL_MAGIC_isa 'I' /* @ISA array */
#define PERL_MAGIC_isaelem 'i' /* @ISA array element */
#define PERL_MAGIC_nkeys 'k' /* scalar(keys()) lvalue */
#define PERL_MAGIC_dbfile 'L' /* Debugger %_<filename */
#define PERL_MAGIC_dbline 'l' /* Debugger %_<filename element */
#define PERL_MAGIC_shared 'N' /* Shared between threads */
#define PERL_MAGIC_shared_scalar 'n' /* Shared between threads */
#define PERL_MAGIC_collxfrm 'o' /* Locale transformation */
#define PERL_MAGIC_tied 'P' /* Tied array or hash */
#define PERL_MAGIC_tiedelem 'p' /* Tied array or hash element */
#define PERL_MAGIC_tiedscalar 'q' /* Tied scalar or handle */
#define PERL_MAGIC_qr 'r' /* Precompiled qr// regex */
#define PERL_MAGIC_sig 'S' /* %SIG hash */
#define PERL_MAGIC_sigelem 's' /* %SIG hash element */
#define PERL_MAGIC_taint 't' /* Taintedness */
#define PERL_MAGIC_uvar 'U' /* Available for use by extensions */
#define PERL_MAGIC_uvar_elem 'u' /* Reserved for use by extensions */
#define PERL_MAGIC_vstring 'V' /* SV was vstring literal */
#define PERL_MAGIC_vec 'v' /* vec() lvalue */
#define PERL_MAGIC_utf8 'w' /* Cached UTF-8 information */
#define PERL_MAGIC_destruct 'X' /* destruct callback */
#define PERL_MAGIC_substr 'x' /* substr() lvalue */
#define PERL_MAGIC_nonelem 'Y' /* Array element that does not exist */
#define PERL_MAGIC_defelem 'y' /* Shadow "foreach" iterator variable /
smart parameter vivification */
#define PERL_MAGIC_hook 'Z' /* %{^HOOK} hash */
#define PERL_MAGIC_hookelem 'z' /* %{^HOOK} hash element */
#define PERL_MAGIC_lvref '\\' /* Lvalue reference constructor */
#define PERL_MAGIC_checkcall ']' /* Inlining/mutation of call to this CV */
#define PERL_MAGIC_extvalue '^' /* Value magic available for use by extensions */
#define PERL_MAGIC_ext '~' /* Variable magic available for use by extensions */
enum { /* pass one of these to get_vtbl */
want_vtbl_arylen,
want_vtbl_arylen_p,
want_vtbl_backref,
want_vtbl_checkcall,
want_vtbl_collxfrm,
want_vtbl_dbline,
want_vtbl_debugvar,
want_vtbl_defelem,
want_vtbl_destruct,
want_vtbl_env,
want_vtbl_envelem,
want_vtbl_hints,
want_vtbl_hintselem,
want_vtbl_hook,
want_vtbl_hookelem,
want_vtbl_isa,
want_vtbl_isaelem,
want_vtbl_lvref,
want_vtbl_mglob,
want_vtbl_nkeys,
want_vtbl_nonelem,
want_vtbl_ovrld,
want_vtbl_pack,
want_vtbl_packelem,
want_vtbl_pos,
want_vtbl_regdata,
want_vtbl_regdatum,
want_vtbl_regexp,
want_vtbl_sig,
want_vtbl_sigelem,
want_vtbl_substr,
want_vtbl_sv,
want_vtbl_taint,
want_vtbl_utf8,
want_vtbl_uvar,
want_vtbl_vec,
magic_vtable_max
};
#ifdef DOINIT
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max] = {
"arylen",
"arylen_p",
"backref",
"checkcall",
"collxfrm",
"dbline",
"debugvar",
"defelem",
"destruct",
"env",
"envelem",
"hints",
"hintselem",
"hook",
"hookelem",
"isa",
"isaelem",
"lvref",
"mglob",
"nkeys",
"nonelem",
"ovrld",
"pack",
"packelem",
"pos",
"regdata",
"regdatum",
"regexp",
"sig",
"sigelem",
"substr",
"sv",
"taint",
"utf8",
"uvar",
"vec"
};
#else
EXTCONST char * const PL_magic_vtable_names[magic_vtable_max];
#endif
/* These all need to be 0, not NULL, as NULL can be (void*)0, which is a
* pointer to data, whereas we're assigning pointers to functions, which are
* not the same beast. ANSI doesn't allow the assignment from one to the other.
* (although most, but not all, compilers are prepared to do it)
*/
/* order is:
get
set
len
clear
free
copy
dup
local
*/
#ifdef DOINIT
EXT_MGVTBL PL_magic_vtables[magic_vtable_max] = {
{ (int (*)(pTHX_ SV *, MAGIC *))Perl_magic_getarylen, Perl_magic_setarylen, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, Perl_magic_cleararylen_p, Perl_magic_freearylen_p, 0, 0, 0 },
{ 0, 0, 0, 0, Perl_magic_killbackrefs, 0, 0, 0 },
{ 0, 0, 0, 0, 0, Perl_magic_copycallchecker, 0, 0 },
#ifdef USE_LOCALE_COLLATE
{ 0, Perl_magic_setcollxfrm, 0, 0, Perl_magic_freecollxfrm, 0, 0, 0 },
#else
{ 0, 0, 0, 0, 0, 0, 0, 0 },
#endif
{ 0, Perl_magic_setdbline, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_getdebugvar, Perl_magic_setdebugvar, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_getdefelem, Perl_magic_setdefelem, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, Perl_magic_freedestruct, 0, 0, 0 },
{ 0, Perl_magic_set_all_env, 0, Perl_magic_clear_all_env, 0, 0, 0, 0 },
{ 0, Perl_magic_setenv, 0, Perl_magic_clearenv, 0, 0, 0, 0 },
{ 0, 0, 0, Perl_magic_clearhints, 0, 0, 0, 0 },
{ 0, Perl_magic_sethint, 0, Perl_magic_clearhint, 0, 0, 0, 0 },
{ 0, Perl_magic_sethookall, 0, Perl_magic_clearhookall, 0, 0, 0, 0 },
{ 0, Perl_magic_sethook, 0, Perl_magic_clearhook, 0, 0, 0, 0 },
{ 0, Perl_magic_setisa, 0, Perl_magic_clearisa, 0, 0, 0, 0 },
{ 0, Perl_magic_setisa, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setlvref, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setmglob, 0, 0, Perl_magic_freemglob, 0, 0, 0 },
{ Perl_magic_getnkeys, Perl_magic_setnkeys, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setnonelem, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, Perl_magic_freeovrld, 0, 0, 0 },
{ 0, 0, Perl_magic_sizepack, Perl_magic_wipepack, 0, 0, 0, 0 },
{ Perl_magic_getpack, Perl_magic_setpack, 0, Perl_magic_clearpack, 0, 0, 0, 0 },
{ Perl_magic_getpos, Perl_magic_setpos, 0, 0, 0, 0, 0, 0 },
{ 0, 0, Perl_magic_regdata_cnt, 0, 0, 0, 0, 0 },
{ Perl_magic_regdatum_get, Perl_magic_regdatum_set, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setregexp, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setsigall, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_getsig, Perl_magic_setsig, 0, Perl_magic_clearsig, 0, 0, 0, 0 },
{ Perl_magic_getsubstr, Perl_magic_setsubstr, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_get, Perl_magic_set, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_gettaint, Perl_magic_settaint, 0, 0, 0, 0, 0, 0 },
{ 0, Perl_magic_setutf8, 0, 0, Perl_magic_freeutf8, 0, 0, 0 },
{ Perl_magic_getuvar, Perl_magic_setuvar, 0, 0, 0, 0, 0, 0 },
{ Perl_magic_getvec, Perl_magic_setvec, 0, 0, 0, 0, 0, 0 }
};
#else
EXT_MGVTBL PL_magic_vtables[magic_vtable_max];
#endif
#define want_vtbl_bm want_vtbl_regexp
#define want_vtbl_fm want_vtbl_regexp
#define PL_vtbl_arylen PL_magic_vtables[want_vtbl_arylen]
#define PL_vtbl_arylen_p PL_magic_vtables[want_vtbl_arylen_p]
#define PL_vtbl_backref PL_magic_vtables[want_vtbl_backref]
#define PL_vtbl_bm PL_magic_vtables[want_vtbl_bm]
#define PL_vtbl_checkcall PL_magic_vtables[want_vtbl_checkcall]
#define PL_vtbl_collxfrm PL_magic_vtables[want_vtbl_collxfrm]
#define PL_vtbl_dbline PL_magic_vtables[want_vtbl_dbline]
#define PL_vtbl_debugvar PL_magic_vtables[want_vtbl_debugvar]
#define PL_vtbl_defelem PL_magic_vtables[want_vtbl_defelem]
#define PL_vtbl_destruct PL_magic_vtables[want_vtbl_destruct]
#define PL_vtbl_env PL_magic_vtables[want_vtbl_env]
#define PL_vtbl_envelem PL_magic_vtables[want_vtbl_envelem]
#define PL_vtbl_fm PL_magic_vtables[want_vtbl_fm]
#define PL_vtbl_hints PL_magic_vtables[want_vtbl_hints]
#define PL_vtbl_hintselem PL_magic_vtables[want_vtbl_hintselem]
#define PL_vtbl_hook PL_magic_vtables[want_vtbl_hook]
#define PL_vtbl_hookelem PL_magic_vtables[want_vtbl_hookelem]
#define PL_vtbl_isa PL_magic_vtables[want_vtbl_isa]
#define PL_vtbl_isaelem PL_magic_vtables[want_vtbl_isaelem]
#define PL_vtbl_lvref PL_magic_vtables[want_vtbl_lvref]
#define PL_vtbl_mglob PL_magic_vtables[want_vtbl_mglob]
#define PL_vtbl_nkeys PL_magic_vtables[want_vtbl_nkeys]
#define PL_vtbl_nonelem PL_magic_vtables[want_vtbl_nonelem]
#define PL_vtbl_ovrld PL_magic_vtables[want_vtbl_ovrld]
#define PL_vtbl_pack PL_magic_vtables[want_vtbl_pack]
#define PL_vtbl_packelem PL_magic_vtables[want_vtbl_packelem]
#define PL_vtbl_pos PL_magic_vtables[want_vtbl_pos]
#define PL_vtbl_regdata PL_magic_vtables[want_vtbl_regdata]
#define PL_vtbl_regdatum PL_magic_vtables[want_vtbl_regdatum]
#define PL_vtbl_regexp PL_magic_vtables[want_vtbl_regexp]
#define PL_vtbl_sig PL_magic_vtables[want_vtbl_sig]
#define PL_vtbl_sigelem PL_magic_vtables[want_vtbl_sigelem]
#define PL_vtbl_substr PL_magic_vtables[want_vtbl_substr]
#define PL_vtbl_sv PL_magic_vtables[want_vtbl_sv]
#define PL_vtbl_taint PL_magic_vtables[want_vtbl_taint]
#define PL_vtbl_utf8 PL_magic_vtables[want_vtbl_utf8]
#define PL_vtbl_uvar PL_magic_vtables[want_vtbl_uvar]
#define PL_vtbl_vec PL_magic_vtables[want_vtbl_vec]
/* ex: set ro ft=c: */

54
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/mydtrace.h Normal file
View file

@ -0,0 +1,54 @@
/* mydtrace.h
*
* Copyright (C) 2008, 2010, 2011 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* Provides macros that wrap the various DTrace probes we use. We add
* an extra level of wrapping to encapsulate the _ENABLED tests.
*/
#if defined(USE_DTRACE) && defined(PERL_CORE)
# include "perldtrace.h"
# define PERL_DTRACE_PROBE_ENTRY(cv) \
if (PERL_SUB_ENTRY_ENABLED()) \
Perl_dtrace_probe_call(aTHX_ cv, TRUE);
# define PERL_DTRACE_PROBE_RETURN(cv) \
if (PERL_SUB_ENTRY_ENABLED()) \
Perl_dtrace_probe_call(aTHX_ cv, FALSE);
# define PERL_DTRACE_PROBE_FILE_LOADING(name) \
if (PERL_SUB_ENTRY_ENABLED()) \
Perl_dtrace_probe_load(aTHX_ name, TRUE);
# define PERL_DTRACE_PROBE_FILE_LOADED(name) \
if (PERL_SUB_ENTRY_ENABLED()) \
Perl_dtrace_probe_load(aTHX_ name, FALSE);
# define PERL_DTRACE_PROBE_OP(op) \
if (PERL_OP_ENTRY_ENABLED()) \
Perl_dtrace_probe_op(aTHX_ op);
# define PERL_DTRACE_PROBE_PHASE(phase) \
if (PERL_OP_ENTRY_ENABLED()) \
Perl_dtrace_probe_phase(aTHX_ phase);
#else
/* NOPs */
# define PERL_DTRACE_PROBE_ENTRY(cv)
# define PERL_DTRACE_PROBE_RETURN(cv)
# define PERL_DTRACE_PROBE_FILE_LOADING(cv)
# define PERL_DTRACE_PROBE_FILE_LOADED(cv)
# define PERL_DTRACE_PROBE_OP(op)
# define PERL_DTRACE_PROBE_PHASE(phase)
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

134
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/nostdio.h Normal file
View file

@ -0,0 +1,134 @@
/* nostdio.h
*
* Copyright (C) 1996, 2000, 2001, 2005, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* Strong denial of stdio - make all stdio calls (we can think of) errors
*/
/* This is a 1st attempt to stop other include files pulling
in real <stdio.h>.
A more ambitious set of possible symbols can be found in
sfio.h (inside an _cplusplus gard).
It is completely pointless as we have already included it ourselves.
*/
#if !defined(_STDIO_H) && !defined(FILE) && !defined(_STDIO_INCLUDED) && !defined(__STDIO_LOADED)
# define _STDIO_H
# define _STDIO_INCLUDED
# define __STDIO_LOADED
struct _FILE;
# define FILE struct _FILE
#endif
#if !defined(OEMVS)
# define _CANNOT "CANNOT"
# undef clearerr
# undef fclose
# undef fdopen
# undef feof
# undef ferror
# undef fflush
# undef fgetc
# undef fgetpos
# undef fgets
# undef fileno
# undef flockfile
# undef fopen
# undef fprintf
# undef fputc
# undef fputs
# undef fread
# undef freopen
# undef fscanf
# undef fseek
# undef fsetpos
# undef ftell
# undef ftrylockfile
# undef funlockfile
# undef fwrite
# undef getc
# undef getc_unlocked
# undef getw
# undef pclose
# undef popen
# undef putc
# undef putc_unlocked
# undef putw
# undef rewind
# undef setbuf
# undef setvbuf
# undef stderr
# undef stdin
# undef stdout
# undef tmpfile
# undef ungetc
# undef vfprintf
# undef printf
# define fprintf _CANNOT _fprintf_
# define printf _CANNOT _printf_
# define stdin _CANNOT _stdin_
# define stdout _CANNOT _stdout_
# define stderr _CANNOT _stderr_
# ifndef OS2
# define tmpfile() _CANNOT _tmpfile_
# endif
# define fclose(f) _CANNOT _fclose_
# define fflush(f) _CANNOT _fflush_
# define fopen(p,m) _CANNOT _fopen_
# define freopen(p,m,f) _CANNOT _freopen_
# define setbuf(f,b) _CANNOT _setbuf_
# define setvbuf(f,b,x,s) _CANNOT _setvbuf_
# define fscanf _CANNOT _fscanf_
# define vfprintf(f,fmt,a) _CANNOT _vfprintf_
# define fgetc(f) _CANNOT _fgetc_
# define fgets(s,n,f) _CANNOT _fgets_
# define fputc(c,f) _CANNOT _fputc_
# define fputs(s,f) _CANNOT _fputs_
# define getc(f) _CANNOT _getc_
# define putc(c,f) _CANNOT _putc_
# ifndef OS2
# define ungetc(c,f) _CANNOT _ungetc_
# endif
# define fread(b,s,c,f) _CANNOT _fread_
# define fwrite(b,s,c,f) _CANNOT _fwrite_
# define fgetpos(f,p) _CANNOT _fgetpos_
# define fseek(f,o,w) _CANNOT _fseek_
# define fsetpos(f,p) _CANNOT _fsetpos_
# define ftell(f) _CANNOT _ftell_
# define rewind(f) _CANNOT _rewind_
# define clearerr(f) _CANNOT _clearerr_
# define feof(f) _CANNOT _feof_
# define ferror(f) _CANNOT _ferror_
# define __filbuf(f) _CANNOT __filbuf_
# define __flsbuf(c,f) _CANNOT __flsbuf_
# define _filbuf(f) _CANNOT _filbuf_
# define _flsbuf(c,f) _CANNOT _flsbuf_
# define fdopen(fd,p) _CANNOT _fdopen_
# define fileno(f) _CANNOT _fileno_
# if defined(SFIO_VERSION) && SFIO_VERSION < 20000101L
# define flockfile(f) _CANNOT _flockfile_
# define ftrylockfile(f) _CANNOT _ftrylockfile_
# define funlockfile(f) _CANNOT _funlockfile_
# endif
# define getc_unlocked(f) _CANNOT _getc_unlocked_
# define putc_unlocked(c,f) _CANNOT _putc_unlocked_
# define popen(c,m) _CANNOT _popen_
# define getw(f) _CANNOT _getw_
# define putw(v,f) _CANNOT _putw_
# ifndef OS2
# define pclose(f) _CANNOT _pclose_
# endif
#endif /*not define OEMVS */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

1178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op.h Normal file
View file

File diff suppressed because it is too large Load diff

157
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/op_reg_common.h Normal file
View file

@ -0,0 +1,157 @@
/* op_reg_common.h
*
* Definitions common to by op.h and regexp.h
*
* Copyright (C) 2010, 2011 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/* These defines are used in both op.h and regexp.h The definitions use the
* shift form so that ext/B/Makefile.PL will pick them up.
*
* Data structures used in the two headers have common fields, and in fact one
* is copied onto the other. This makes it easy to keep them in sync */
/* This tells where the first of these bits is. Setting it to 0 saved cycles
* and memory. I (khw) think the code will work if changed back, but haven't
* tested it */
/* Make sure to update ext/re/re.pm when changing this! */
#ifndef RXf_PMf_STD_PMMOD_SHIFT /* Only expand #include of this file once */
#define RXf_PMf_STD_PMMOD_SHIFT 0
/* The bits need to be ordered so that the msixn are contiguous starting at bit
* RXf_PMf_STD_PMMOD_SHIFT, followed by the p. See STD_PAT_MODS and
* INT_PAT_MODS in regexp.h for the reason contiguity is needed */
/* Make sure to update lib/re.pm when changing these! */
/* Make sure you keep the pure PMf_ versions below in sync */
#define RXf_PMf_MULTILINE (1U << (RXf_PMf_STD_PMMOD_SHIFT+0)) /* /m */
#define RXf_PMf_SINGLELINE (1U << (RXf_PMf_STD_PMMOD_SHIFT+1)) /* /s */
#define RXf_PMf_FOLD (1U << (RXf_PMf_STD_PMMOD_SHIFT+2)) /* /i */
#define RXf_PMf_EXTENDED (1U << (RXf_PMf_STD_PMMOD_SHIFT+3)) /* /x */
#define RXf_PMf_EXTENDED_MORE (1U << (RXf_PMf_STD_PMMOD_SHIFT+4)) /* /xx */
#define RXf_PMf_NOCAPTURE (1U << (RXf_PMf_STD_PMMOD_SHIFT+5)) /* /n */
#define RXf_PMf_KEEPCOPY (1U << (RXf_PMf_STD_PMMOD_SHIFT+6)) /* /p */
/* The character set for the regex is stored in a field of more than one bit
* using an enum, for reasons of compactness and to ensure that the options are
* mutually exclusive */
/* Make sure to update ext/re/re.pm and regcomp.sym (as these are used as
* offsets for various node types, like POSIXD vs POSIXL, etc) when changing
* this! */
typedef enum {
REGEX_DEPENDS_CHARSET = 0,
REGEX_LOCALE_CHARSET,
REGEX_UNICODE_CHARSET,
REGEX_ASCII_RESTRICTED_CHARSET,
REGEX_ASCII_MORE_RESTRICTED_CHARSET
} regex_charset;
#define _RXf_PMf_CHARSET_SHIFT ((RXf_PMf_STD_PMMOD_SHIFT)+7)
#define RXf_PMf_CHARSET (7U << (_RXf_PMf_CHARSET_SHIFT)) /* 3 bits */
/* Manually decorate these functions here with gcc-style attributes just to
* avoid making the regex_charset typedef global, which it would need to be for
* proto.h to understand it */
PERL_STATIC_INLINE void
set_regex_charset(U32 * const flags, const regex_charset cs)
__attribute__nonnull__(1);
PERL_STATIC_INLINE void
set_regex_charset(U32 * const flags, const regex_charset cs)
{
/* Sets the character set portion of 'flags' to 'cs', which is a member of
* the above enum */
*flags &= ~RXf_PMf_CHARSET;
*flags |= (cs << _RXf_PMf_CHARSET_SHIFT);
}
PERL_STATIC_INLINE regex_charset
get_regex_charset(const U32 flags)
__attribute__warn_unused_result__;
PERL_STATIC_INLINE regex_charset
get_regex_charset(const U32 flags)
{
/* Returns the enum corresponding to the character set in 'flags' */
return (regex_charset) ((flags & RXf_PMf_CHARSET) >> _RXf_PMf_CHARSET_SHIFT);
}
#define RXf_PMf_STRICT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+10))
#define _RXf_PMf_SHIFT_COMPILETIME (RXf_PMf_STD_PMMOD_SHIFT+11)
/*
Set in Perl_pmruntime if op_flags & OPf_SPECIAL, i.e. split. Will
be used by regex engines to check whether they should set
RXf_SKIPWHITE
*/
#define RXf_PMf_SPLIT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+11))
/* Next available bit after the above. Name begins with '_' so won't be
* exported by B */
#define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+12)
/* Mask of the above bits. These need to be transferred from op_pmflags to
* re->extflags during compilation */
#define RXf_PMf_COMPILETIME \
( RXf_PMf_MULTILINE \
| RXf_PMf_SINGLELINE \
| RXf_PMf_FOLD \
| RXf_PMf_EXTENDED \
| RXf_PMf_EXTENDED_MORE \
| RXf_PMf_KEEPCOPY \
| RXf_PMf_NOCAPTURE \
| RXf_PMf_CHARSET \
| RXf_PMf_STRICT )
#define RXf_PMf_FLAGCOPYMASK \
( RXf_PMf_COMPILETIME \
| RXf_PMf_SPLIT )
/* Temporary to get Jenkins happy again
* See thread starting at http://nntp.perl.org/group/perl.perl5.porters/220710
*/
#if 0
/* Exclude win32 because it can't cope with I32_MAX definition */
#ifndef WIN32
# if RXf_PMf_COMPILETIME > I32_MAX
# error RXf_PMf_COMPILETIME wont fit in arg2 field of eval node
# endif
#endif
#endif
/* These copies need to be numerical or ext/B/Makefile.PL won't think they are
* constants */
#define PMf_MULTILINE (1U<<0)
#define PMf_SINGLELINE (1U<<1)
#define PMf_FOLD (1U<<2)
#define PMf_EXTENDED (1U<<3)
#define PMf_EXTENDED_MORE (1U<<4)
#define PMf_NOCAPTURE (1U<<5)
#define PMf_KEEPCOPY (1U<<6)
#define PMf_CHARSET (7U<<7)
#define PMf_STRICT (1U<<10)
#define PMf_SPLIT (1U<<11)
#if PMf_MULTILINE != RXf_PMf_MULTILINE || PMf_SINGLELINE != RXf_PMf_SINGLELINE || PMf_FOLD != RXf_PMf_FOLD || PMf_EXTENDED != RXf_PMf_EXTENDED || PMf_EXTENDED_MORE != RXf_PMf_EXTENDED_MORE || PMf_KEEPCOPY != RXf_PMf_KEEPCOPY || PMf_SPLIT != RXf_PMf_SPLIT || PMf_CHARSET != RXf_PMf_CHARSET || PMf_NOCAPTURE != RXf_PMf_NOCAPTURE || PMf_STRICT != RXf_PMf_STRICT
# error RXf_PMf defines are wrong
#endif
/* Error check that haven't left something out of this. This isn't done
* directly in the #define because doing so confuses regcomp.pl.
* (2**n - 1) is n 1 bits, so the below gets the contiguous bits between the
* beginning and ending shifts */
#if RXf_PMf_COMPILETIME != ((nBIT_MASK(_RXf_PMf_SHIFT_COMPILETIME)) \
& (~(nBIT_MASK( RXf_PMf_STD_PMMOD_SHIFT))))
# error RXf_PMf_COMPILETIME is invalid
#endif
#endif /* Include only once */

3536
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opcode.h Normal file
View file

File diff suppressed because it is too large Load diff

468
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/opnames.h Normal file
View file

@ -0,0 +1,468 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* opnames.h
*
* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
* 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/opcode.pl from its data.
* Any changes made here will be lost!
*/
typedef enum opcode {
OP_NULL = 0,
OP_STUB = 1,
OP_SCALAR = 2,
OP_PUSHMARK = 3,
OP_WANTARRAY = 4,
OP_CONST = 5,
OP_GVSV = 6,
OP_GV = 7,
OP_GELEM = 8,
OP_PADSV = 9,
OP_PADSV_STORE = 10,
OP_PADAV = 11,
OP_PADHV = 12,
OP_PADANY = 13,
OP_RV2GV = 14,
OP_RV2SV = 15,
OP_AV2ARYLEN = 16,
OP_RV2CV = 17,
OP_ANONCODE = 18,
OP_PROTOTYPE = 19,
OP_REFGEN = 20,
OP_SREFGEN = 21,
OP_REF = 22,
OP_BLESS = 23,
OP_BACKTICK = 24,
OP_GLOB = 25,
OP_READLINE = 26,
OP_RCATLINE = 27,
OP_REGCMAYBE = 28,
OP_REGCRESET = 29,
OP_REGCOMP = 30,
OP_MATCH = 31,
OP_QR = 32,
OP_SUBST = 33,
OP_SUBSTCONT = 34,
OP_TRANS = 35,
OP_TRANSR = 36,
OP_SASSIGN = 37,
OP_AASSIGN = 38,
OP_CHOP = 39,
OP_SCHOP = 40,
OP_CHOMP = 41,
OP_SCHOMP = 42,
OP_DEFINED = 43,
OP_UNDEF = 44,
OP_STUDY = 45,
OP_POS = 46,
OP_PREINC = 47,
OP_I_PREINC = 48,
OP_PREDEC = 49,
OP_I_PREDEC = 50,
OP_POSTINC = 51,
OP_I_POSTINC = 52,
OP_POSTDEC = 53,
OP_I_POSTDEC = 54,
OP_POW = 55,
OP_MULTIPLY = 56,
OP_I_MULTIPLY = 57,
OP_DIVIDE = 58,
OP_I_DIVIDE = 59,
OP_MODULO = 60,
OP_I_MODULO = 61,
OP_REPEAT = 62,
OP_ADD = 63,
OP_I_ADD = 64,
OP_SUBTRACT = 65,
OP_I_SUBTRACT = 66,
OP_CONCAT = 67,
OP_MULTICONCAT = 68,
OP_STRINGIFY = 69,
OP_LEFT_SHIFT = 70,
OP_RIGHT_SHIFT = 71,
OP_LT = 72,
OP_I_LT = 73,
OP_GT = 74,
OP_I_GT = 75,
OP_LE = 76,
OP_I_LE = 77,
OP_GE = 78,
OP_I_GE = 79,
OP_EQ = 80,
OP_I_EQ = 81,
OP_NE = 82,
OP_I_NE = 83,
OP_NCMP = 84,
OP_I_NCMP = 85,
OP_SLT = 86,
OP_SGT = 87,
OP_SLE = 88,
OP_SGE = 89,
OP_SEQ = 90,
OP_SNE = 91,
OP_SCMP = 92,
OP_BIT_AND = 93,
OP_BIT_XOR = 94,
OP_BIT_OR = 95,
OP_NBIT_AND = 96,
OP_NBIT_XOR = 97,
OP_NBIT_OR = 98,
OP_SBIT_AND = 99,
OP_SBIT_XOR = 100,
OP_SBIT_OR = 101,
OP_NEGATE = 102,
OP_I_NEGATE = 103,
OP_NOT = 104,
OP_COMPLEMENT = 105,
OP_NCOMPLEMENT = 106,
OP_SCOMPLEMENT = 107,
OP_SMARTMATCH = 108,
OP_ATAN2 = 109,
OP_SIN = 110,
OP_COS = 111,
OP_RAND = 112,
OP_SRAND = 113,
OP_EXP = 114,
OP_LOG = 115,
OP_SQRT = 116,
OP_INT = 117,
OP_HEX = 118,
OP_OCT = 119,
OP_ABS = 120,
OP_LENGTH = 121,
OP_SUBSTR = 122,
OP_VEC = 123,
OP_INDEX = 124,
OP_RINDEX = 125,
OP_SPRINTF = 126,
OP_FORMLINE = 127,
OP_ORD = 128,
OP_CHR = 129,
OP_CRYPT = 130,
OP_UCFIRST = 131,
OP_LCFIRST = 132,
OP_UC = 133,
OP_LC = 134,
OP_QUOTEMETA = 135,
OP_RV2AV = 136,
OP_AELEMFAST = 137,
OP_AELEMFAST_LEX = 138,
OP_AELEMFASTLEX_STORE = 139,
OP_AELEM = 140,
OP_ASLICE = 141,
OP_KVASLICE = 142,
OP_AEACH = 143,
OP_AVALUES = 144,
OP_AKEYS = 145,
OP_EACH = 146,
OP_VALUES = 147,
OP_KEYS = 148,
OP_DELETE = 149,
OP_EXISTS = 150,
OP_RV2HV = 151,
OP_HELEM = 152,
OP_HSLICE = 153,
OP_KVHSLICE = 154,
OP_MULTIDEREF = 155,
OP_UNPACK = 156,
OP_PACK = 157,
OP_SPLIT = 158,
OP_JOIN = 159,
OP_LIST = 160,
OP_LSLICE = 161,
OP_ANONLIST = 162,
OP_ANONHASH = 163,
OP_EMPTYAVHV = 164,
OP_SPLICE = 165,
OP_PUSH = 166,
OP_POP = 167,
OP_SHIFT = 168,
OP_UNSHIFT = 169,
OP_SORT = 170,
OP_REVERSE = 171,
OP_GREPSTART = 172,
OP_GREPWHILE = 173,
OP_MAPSTART = 174,
OP_MAPWHILE = 175,
OP_RANGE = 176,
OP_FLIP = 177,
OP_FLOP = 178,
OP_AND = 179,
OP_OR = 180,
OP_XOR = 181,
OP_DOR = 182,
OP_COND_EXPR = 183,
OP_ANDASSIGN = 184,
OP_ORASSIGN = 185,
OP_DORASSIGN = 186,
OP_ENTERSUB = 187,
OP_LEAVESUB = 188,
OP_LEAVESUBLV = 189,
OP_ARGCHECK = 190,
OP_ARGELEM = 191,
OP_ARGDEFELEM = 192,
OP_CALLER = 193,
OP_WARN = 194,
OP_DIE = 195,
OP_RESET = 196,
OP_LINESEQ = 197,
OP_NEXTSTATE = 198,
OP_DBSTATE = 199,
OP_UNSTACK = 200,
OP_ENTER = 201,
OP_LEAVE = 202,
OP_SCOPE = 203,
OP_ENTERITER = 204,
OP_ITER = 205,
OP_ENTERLOOP = 206,
OP_LEAVELOOP = 207,
OP_RETURN = 208,
OP_LAST = 209,
OP_NEXT = 210,
OP_REDO = 211,
OP_DUMP = 212,
OP_GOTO = 213,
OP_EXIT = 214,
OP_METHOD = 215,
OP_METHOD_NAMED = 216,
OP_METHOD_SUPER = 217,
OP_METHOD_REDIR = 218,
OP_METHOD_REDIR_SUPER = 219,
OP_ENTERGIVEN = 220,
OP_LEAVEGIVEN = 221,
OP_ENTERWHEN = 222,
OP_LEAVEWHEN = 223,
OP_BREAK = 224,
OP_CONTINUE = 225,
OP_OPEN = 226,
OP_CLOSE = 227,
OP_PIPE_OP = 228,
OP_FILENO = 229,
OP_UMASK = 230,
OP_BINMODE = 231,
OP_TIE = 232,
OP_UNTIE = 233,
OP_TIED = 234,
OP_DBMOPEN = 235,
OP_DBMCLOSE = 236,
OP_SSELECT = 237,
OP_SELECT = 238,
OP_GETC = 239,
OP_READ = 240,
OP_ENTERWRITE = 241,
OP_LEAVEWRITE = 242,
OP_PRTF = 243,
OP_PRINT = 244,
OP_SAY = 245,
OP_SYSOPEN = 246,
OP_SYSSEEK = 247,
OP_SYSREAD = 248,
OP_SYSWRITE = 249,
OP_EOF = 250,
OP_TELL = 251,
OP_SEEK = 252,
OP_TRUNCATE = 253,
OP_FCNTL = 254,
OP_IOCTL = 255,
OP_FLOCK = 256,
OP_SEND = 257,
OP_RECV = 258,
OP_SOCKET = 259,
OP_SOCKPAIR = 260,
OP_BIND = 261,
OP_CONNECT = 262,
OP_LISTEN = 263,
OP_ACCEPT = 264,
OP_SHUTDOWN = 265,
OP_GSOCKOPT = 266,
OP_SSOCKOPT = 267,
OP_GETSOCKNAME = 268,
OP_GETPEERNAME = 269,
OP_LSTAT = 270,
OP_STAT = 271,
OP_FTRREAD = 272,
OP_FTRWRITE = 273,
OP_FTREXEC = 274,
OP_FTEREAD = 275,
OP_FTEWRITE = 276,
OP_FTEEXEC = 277,
OP_FTIS = 278,
OP_FTSIZE = 279,
OP_FTMTIME = 280,
OP_FTATIME = 281,
OP_FTCTIME = 282,
OP_FTROWNED = 283,
OP_FTEOWNED = 284,
OP_FTZERO = 285,
OP_FTSOCK = 286,
OP_FTCHR = 287,
OP_FTBLK = 288,
OP_FTFILE = 289,
OP_FTDIR = 290,
OP_FTPIPE = 291,
OP_FTSUID = 292,
OP_FTSGID = 293,
OP_FTSVTX = 294,
OP_FTLINK = 295,
OP_FTTTY = 296,
OP_FTTEXT = 297,
OP_FTBINARY = 298,
OP_CHDIR = 299,
OP_CHOWN = 300,
OP_CHROOT = 301,
OP_UNLINK = 302,
OP_CHMOD = 303,
OP_UTIME = 304,
OP_RENAME = 305,
OP_LINK = 306,
OP_SYMLINK = 307,
OP_READLINK = 308,
OP_MKDIR = 309,
OP_RMDIR = 310,
OP_OPEN_DIR = 311,
OP_READDIR = 312,
OP_TELLDIR = 313,
OP_SEEKDIR = 314,
OP_REWINDDIR = 315,
OP_CLOSEDIR = 316,
OP_FORK = 317,
OP_WAIT = 318,
OP_WAITPID = 319,
OP_SYSTEM = 320,
OP_EXEC = 321,
OP_KILL = 322,
OP_GETPPID = 323,
OP_GETPGRP = 324,
OP_SETPGRP = 325,
OP_GETPRIORITY = 326,
OP_SETPRIORITY = 327,
OP_TIME = 328,
OP_TMS = 329,
OP_LOCALTIME = 330,
OP_GMTIME = 331,
OP_ALARM = 332,
OP_SLEEP = 333,
OP_SHMGET = 334,
OP_SHMCTL = 335,
OP_SHMREAD = 336,
OP_SHMWRITE = 337,
OP_MSGGET = 338,
OP_MSGCTL = 339,
OP_MSGSND = 340,
OP_MSGRCV = 341,
OP_SEMOP = 342,
OP_SEMGET = 343,
OP_SEMCTL = 344,
OP_REQUIRE = 345,
OP_DOFILE = 346,
OP_HINTSEVAL = 347,
OP_ENTEREVAL = 348,
OP_LEAVEEVAL = 349,
OP_ENTERTRY = 350,
OP_LEAVETRY = 351,
OP_GHBYNAME = 352,
OP_GHBYADDR = 353,
OP_GHOSTENT = 354,
OP_GNBYNAME = 355,
OP_GNBYADDR = 356,
OP_GNETENT = 357,
OP_GPBYNAME = 358,
OP_GPBYNUMBER = 359,
OP_GPROTOENT = 360,
OP_GSBYNAME = 361,
OP_GSBYPORT = 362,
OP_GSERVENT = 363,
OP_SHOSTENT = 364,
OP_SNETENT = 365,
OP_SPROTOENT = 366,
OP_SSERVENT = 367,
OP_EHOSTENT = 368,
OP_ENETENT = 369,
OP_EPROTOENT = 370,
OP_ESERVENT = 371,
OP_GPWNAM = 372,
OP_GPWUID = 373,
OP_GPWENT = 374,
OP_SPWENT = 375,
OP_EPWENT = 376,
OP_GGRNAM = 377,
OP_GGRGID = 378,
OP_GGRENT = 379,
OP_SGRENT = 380,
OP_EGRENT = 381,
OP_GETLOGIN = 382,
OP_SYSCALL = 383,
OP_LOCK = 384,
OP_ONCE = 385,
OP_CUSTOM = 386,
OP_COREARGS = 387,
OP_AVHVSWITCH = 388,
OP_RUNCV = 389,
OP_FC = 390,
OP_PADCV = 391,
OP_INTROCV = 392,
OP_CLONECV = 393,
OP_PADRANGE = 394,
OP_REFASSIGN = 395,
OP_LVREF = 396,
OP_LVREFSLICE = 397,
OP_LVAVREF = 398,
OP_ANONCONST = 399,
OP_ISA = 400,
OP_CMPCHAIN_AND = 401,
OP_CMPCHAIN_DUP = 402,
OP_ENTERTRYCATCH = 403,
OP_LEAVETRYCATCH = 404,
OP_POPTRY = 405,
OP_CATCH = 406,
OP_PUSHDEFER = 407,
OP_IS_BOOL = 408,
OP_IS_WEAK = 409,
OP_WEAKEN = 410,
OP_UNWEAKEN = 411,
OP_BLESSED = 412,
OP_REFADDR = 413,
OP_REFTYPE = 414,
OP_CEIL = 415,
OP_FLOOR = 416,
OP_IS_TAINTED = 417,
OP_HELEMEXISTSOR = 418,
OP_METHSTART = 419,
OP_INITFIELD = 420,
OP_CLASSNAME = 421,
OP_max
} opcode;
#define MAXO 422
#define OP_FREED MAXO
/* the OP_IS_* macros are optimized to a simple range check because
all the member OPs are contiguous in regen/opcodes table.
opcode.pl verifies the range contiguity, or generates an OR-equals
expression */
#define OP_IS_SOCKET(op) \
((op) >= OP_SEND && (op) <= OP_GETPEERNAME)
#define OP_IS_FILETEST(op) \
((op) >= OP_FTRREAD && (op) <= OP_FTBINARY)
#define OP_IS_FILETEST_ACCESS(op) \
((op) >= OP_FTRREAD && (op) <= OP_FTEEXEC)
#define OP_IS_NUMCOMPARE(op) \
((op) >= OP_LT && (op) <= OP_I_NCMP)
#define OP_IS_DIRHOP(op) \
((op) >= OP_READDIR && (op) <= OP_CLOSEDIR)
#define OP_IS_INFIX_BIT(op) \
((op) >= OP_BIT_AND && (op) <= OP_SBIT_OR)
/* ex: set ro ft=c: */

98
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/overload.h Normal file
View file

@ -0,0 +1,98 @@
/* -*- mode: C; buffer-read-only: t -*-
*
* overload.h
*
* Copyright (C) 1997, 1998, 2000, 2001, 2005, 2006, 2007, 2011
* by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
* This file is built by regen/overload.pl.
* Any changes made here will be lost!
*/
enum {
fallback_amg, /* 0x00 fallback */
to_sv_amg, /* 0x01 ${} */
to_av_amg, /* 0x02 @{} */
to_hv_amg, /* 0x03 %{} */
to_gv_amg, /* 0x04 *{} */
to_cv_amg, /* 0x05 &{} */
inc_amg, /* 0x06 ++ */
dec_amg, /* 0x07 -- */
bool__amg, /* 0x08 bool */
numer_amg, /* 0x09 0+ */
string_amg, /* 0x0a "" */
not_amg, /* 0x0b ! */
copy_amg, /* 0x0c = */
abs_amg, /* 0x0d abs */
neg_amg, /* 0x0e neg */
iter_amg, /* 0x0f <> */
int_amg, /* 0x10 int */
lt_amg, /* 0x11 < */
le_amg, /* 0x12 <= */
gt_amg, /* 0x13 > */
ge_amg, /* 0x14 >= */
eq_amg, /* 0x15 == */
ne_amg, /* 0x16 != */
slt_amg, /* 0x17 lt */
sle_amg, /* 0x18 le */
sgt_amg, /* 0x19 gt */
sge_amg, /* 0x1a ge */
seq_amg, /* 0x1b eq */
sne_amg, /* 0x1c ne */
nomethod_amg, /* 0x1d nomethod */
add_amg, /* 0x1e + */
add_ass_amg, /* 0x1f += */
subtr_amg, /* 0x20 - */
subtr_ass_amg, /* 0x21 -= */
mult_amg, /* 0x22 * */
mult_ass_amg, /* 0x23 *= */
div_amg, /* 0x24 / */
div_ass_amg, /* 0x25 /= */
modulo_amg, /* 0x26 % */
modulo_ass_amg, /* 0x27 %= */
pow_amg, /* 0x28 ** */
pow_ass_amg, /* 0x29 **= */
lshift_amg, /* 0x2a << */
lshift_ass_amg, /* 0x2b <<= */
rshift_amg, /* 0x2c >> */
rshift_ass_amg, /* 0x2d >>= */
band_amg, /* 0x2e & */
band_ass_amg, /* 0x2f &= */
sband_amg, /* 0x30 &. */
sband_ass_amg, /* 0x31 &.= */
bor_amg, /* 0x32 | */
bor_ass_amg, /* 0x33 |= */
sbor_amg, /* 0x34 |. */
sbor_ass_amg, /* 0x35 |.= */
bxor_amg, /* 0x36 ^ */
bxor_ass_amg, /* 0x37 ^= */
sbxor_amg, /* 0x38 ^. */
sbxor_ass_amg, /* 0x39 ^.= */
ncmp_amg, /* 0x3a <=> */
scmp_amg, /* 0x3b cmp */
compl_amg, /* 0x3c ~ */
scompl_amg, /* 0x3d ~. */
atan2_amg, /* 0x3e atan2 */
cos_amg, /* 0x3f cos */
sin_amg, /* 0x40 sin */
exp_amg, /* 0x41 exp */
log_amg, /* 0x42 log */
sqrt_amg, /* 0x43 sqrt */
repeat_amg, /* 0x44 x */
repeat_ass_amg, /* 0x45 x= */
concat_amg, /* 0x46 . */
concat_ass_amg, /* 0x47 .= */
smart_amg, /* 0x48 ~~ */
ftest_amg, /* 0x49 -X */
regexp_amg, /* 0x4a qr */
max_amg_code
/* Do not leave a trailing comma here. C9X allows it, C89 doesn't. */
};
#define NofAMmeth max_amg_code
/* ex: set ro ft=c: */

570
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pad.h Normal file
View file

@ -0,0 +1,570 @@
/* pad.h
*
* Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
* 2009, 2010, 2011 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* This file defines the types and macros associated with the API for
* manipulating scratchpads, which are used by perl to store lexical
* variables, op targets and constants.
*/
/* offsets within a pad */
typedef SSize_t PADOFFSET; /* signed so that -1 is a valid value */
#define NOT_IN_PAD ((PADOFFSET) -1)
/* B.xs expects the first members of these two structs to line up
(xpadl_max with xpadnl_fill).
*/
struct padlist {
SSize_t xpadl_max; /* max index for which array has space */
union {
PAD ** xpadlarr_alloc; /* Pointer to beginning of array of AVs.
Note that a 'padnamelist *' is stored
in the 0 index of the AV. */
struct {
PADNAMELIST * padnl;
PAD * pad_1; /* this slice of PAD * array always alloced */
PAD * pad_2; /* maybe unalloced */
} * xpadlarr_dbg; /* for use with a C debugger only */
} xpadl_arr;
U32 xpadl_id; /* Semi-unique ID, shared between clones */
U32 xpadl_outid; /* ID of outer pad */
};
struct padnamelist {
SSize_t xpadnl_fill; /* max index in use */
PADNAME ** xpadnl_alloc; /* pointer to beginning of array */
SSize_t xpadnl_max; /* max index for which array has space */
PADOFFSET xpadnl_max_named; /* highest index with len > 0 */
U32 xpadnl_refcnt;
};
/* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
define one or the other. */
#if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
# error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
#endif
#if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
# define PERL_PADNAME_MINIMAL
#endif
struct padname_fieldinfo;
#define _PADNAME_BASE \
char * xpadn_pv; \
HV * xpadn_ourstash; \
union { \
HV * xpadn_typestash; \
CV * xpadn_protocv; \
} xpadn_type_u; \
struct padname_fieldinfo *xpadn_fieldinfo; \
U32 xpadn_low; \
U32 xpadn_high; \
U32 xpadn_refcnt; \
int xpadn_gen; \
U8 xpadn_len; \
U8 xpadn_flags
struct padname {
_PADNAME_BASE;
};
struct padname_with_str {
#ifdef PERL_PADNAME_MINIMAL
_PADNAME_BASE;
#else
struct padname xpadn_padname;
#endif
char xpadn_str[1];
};
#undef _PADNAME_BASE
#define PADNAME_FROM_PV(s) \
((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
/* Most padnames are not field names. Keep all the field-related info in its
* own substructure, stored in ->xpadn_fieldinfo.
*/
struct padname_fieldinfo {
U32 refcount;
PADOFFSET fieldix; /* index of this field within ObjectFIELDS() array */
HV *fieldstash; /* original class package which added this field */
OP *defop; /* optree fragment for defaulting expression */
SV *paramname; /* name of the :param to look for in constructor */
int def_if_undef : 1; /* default op uses //= */
int def_if_false : 1; /* default op uses ||= */
};
/* a value that PL_cop_seqmax is guaranteed never to be,
* flagging that a lexical is being introduced, or has not yet left scope
*/
#define PERL_PADSEQ_INTRO U32_MAX
#define COP_SEQMAX_INC \
(PL_cop_seqmax++, \
(void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
/* B.xs needs these for the benefit of B::Deparse */
/* Low range end is exclusive (valid from the cop seq after this one) */
/* High range end is inclusive (valid up to this cop seq) */
#define COP_SEQ_RANGE_LOW(pn) (pn)->xpadn_low
#define COP_SEQ_RANGE_HIGH(pn) (pn)->xpadn_high
#define PARENT_PAD_INDEX(pn) (pn)->xpadn_low
#define PARENT_FAKELEX_FLAGS(pn) (pn)->xpadn_high
/* Flags set in the SvIVX field of FAKE namesvs */
#define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */
#define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */
/* flags for the pad_new() function */
#define padnew_CLONE 1 /* this pad is for a cloned CV */
#define padnew_SAVE 2 /* save old globals */
#define padnew_SAVESUB 4 /* also save extra stuff for start of sub */
/* values for the pad_tidy() function */
typedef enum {
padtidy_SUB, /* tidy up a pad for a sub, */
padtidy_SUBCLONE, /* a cloned sub, */
padtidy_FORMAT /* or a format */
} padtidy_type;
/* flags for pad_add_name_pvn. */
#define padadd_OUR 0x01 /* our declaration. */
#define padadd_STATE 0x02 /* state declaration. */
#define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */
#define padadd_STALEOK 0x08 /* allow stale lexical in active
* sub, but only one level up */
#define padadd_FIELD 0x10 /* set PADNAMEt_FIELD */
#define padfind_FIELD_OK 0x20 /* pad_findlex is permitted to see fields */
/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
* whether PL_comppad and PL_curpad are consistent and whether they have
* active values */
#ifdef DEBUGGING
# define ASSERT_CURPAD_LEGAL(label) \
if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \
Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
# define ASSERT_CURPAD_ACTIVE(label) \
if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \
Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
#else
# define ASSERT_CURPAD_LEGAL(label)
# define ASSERT_CURPAD_ACTIVE(label)
#endif
/* Note: the following three macros are actually defined in scope.h, but
* they are documented here for completeness, since they directly or
* indirectly affect pads. */
/*
=for apidoc m|void|SAVEPADSV |PADOFFSET po
Save a pad slot (used to restore after an iteration)
=cut
XXX DAPM it would make more sense to make the arg a PADOFFSET
=for apidoc m|void|SAVECLEARSV |SV **svp
Clear the pointed to pad value on scope exit. (i.e. the runtime action of
C<my>)
=for apidoc m|void|SAVECOMPPAD
save C<PL_comppad> and C<PL_curpad>
=for apidoc Amx|PAD **|PadlistARRAY|PADLIST * padlist
The C array of a padlist, containing the pads. Only subscript it with
numbers >= 1, as the 0th entry is not guaranteed to remain usable.
=for apidoc Amx|SSize_t|PadlistMAX|PADLIST * padlist
The index of the last allocated space in the padlist. Note that the last
pad may be in an earlier slot. Any entries following it will be C<NULL> in
that case.
=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST * padlist
The names associated with pad entries.
=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST * padlist
The C array of pad names.
=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST * padlist
The index of the last pad name.
=for apidoc Amx|U32|PadlistREFCNT|PADLIST * padlist
The reference count of the padlist. Currently this is always 1.
=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST * pnl
The C array of pad names.
=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST * pnl
The index of the last pad name.
=for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST * pnl
The reference count of the pad name list.
=for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST * pnl
Lowers the reference count of the pad name list.
=for apidoc Amx|SV **|PadARRAY|PAD * pad
The C array of pad entries.
=for apidoc Amx|SSize_t|PadMAX|PAD * pad
The index of the last pad entry.
=for apidoc Amx|char *|PadnamePV|PADNAME * pn
The name stored in the pad name struct. This returns C<NULL> for a target
slot.
=for apidoc Amx|STRLEN|PadnameLEN|PADNAME * pn
The length of the name.
=for apidoc Amx|bool|PadnameUTF8|PADNAME * pn
Whether PadnamePV is in UTF-8. Currently, this is always true.
=for apidoc Amx|SV *|PadnameSV|PADNAME * pn
Returns the pad name as a mortal SV.
=for apidoc m|bool|PadnameIsOUR|PADNAME * pn
Whether this is an "our" variable.
=for apidoc m|HV *|PadnameOURSTASH|PADNAME * pn
The stash in which this "our" variable was declared.
=for apidoc m|bool|PadnameOUTER|PADNAME * pn
Whether this entry belongs to an outer pad. Entries for which this is true
are often referred to as 'fake'.
=for apidoc m|bool|PadnameIsSTATE|PADNAME * pn
Whether this is a "state" variable.
=for apidoc m|bool|PadnameIsFIELD|PADNAME * pn
Whether this is a "field" variable. PADNAMEs where this is true will
have additional information available via C<PadnameFIELDINFO>.
=for apidoc m|HV *|PadnameTYPE|PADNAME * pn
The stash associated with a typed lexical. This returns the C<%Foo::> hash
for C<my Foo $bar>.
=for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME * pn
The reference count of the pad name.
=for apidoc Amx|PADNAME *|PadnameREFCNT_inc|PADNAME * pn
Increases the reference count of the pad name. Returns the pad name itself.
=for apidoc Amx|void|PadnameREFCNT_dec|PADNAME * pn
Lowers the reference count of the pad name.
=for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
Set the slot at offset C<po> in the current pad to C<sv>
=for apidoc m|SV *|PAD_SV |PADOFFSET po
Get the value at offset C<po> in the current pad
=for apidoc m|SV *|PAD_SVl |PADOFFSET po
Lightweight and lvalue version of C<PAD_SV>.
Get or set the value at offset C<po> in the current pad.
Unlike C<PAD_SV>, does not print diagnostics with -DX.
For internal use only.
=for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po
Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
=for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n
Set the current pad to be pad C<n> in the padlist, saving
the previous current pad. NB currently this macro expands to a string too
long for some compilers, so it's best to replace it with
SAVECOMPPAD();
PAD_SET_CUR_NOSAVE(padlist,n);
=for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n
like PAD_SET_CUR, but without the save
=for apidoc m|void|PAD_SAVE_SETNULLPAD
Save the current pad then set it to null.
=for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
Save the current pad to the local variable C<opad>, then make the
current pad equal to C<npad>
=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
Restore the old pad saved into the local variable C<opad> by C<PAD_SAVE_LOCAL()>
=cut
*/
#define PadlistARRAY(pl) (pl)->xpadl_arr.xpadlarr_alloc
#define PadlistMAX(pl) (pl)->xpadl_max
#define PadlistNAMES(pl) *((PADNAMELIST **)PadlistARRAY(pl))
#define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl))
#define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl))
#define PadlistREFCNT(pl) 1 /* reserved for future use */
#define PadnamelistARRAY(pnl) (pnl)->xpadnl_alloc
#define PadnamelistMAX(pnl) (pnl)->xpadnl_fill
#define PadnamelistMAXNAMED(pnl) (pnl)->xpadnl_max_named
#define PadnamelistREFCNT(pnl) (pnl)->xpadnl_refcnt
#define PadnamelistREFCNT_inc(pnl) Perl_padnamelist_refcnt_inc(pnl)
#define PadnamelistREFCNT_dec(pnl) Perl_padnamelist_free(aTHX_ pnl)
#define PadARRAY(pad) AvARRAY(pad)
#define PadMAX(pad) AvFILLp(pad)
#define PadnamePV(pn) (pn)->xpadn_pv
#define PadnameLEN(pn) (pn)->xpadn_len
#define PadnameUTF8(pn) 1
#define PadnameSV(pn) \
newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
#define PadnameFLAGS(pn) (pn)->xpadn_flags
#define PadnameIsOUR(pn) cBOOL((pn)->xpadn_ourstash)
#define PadnameOURSTASH(pn) (pn)->xpadn_ourstash
#define PadnameTYPE(pn) (pn)->xpadn_type_u.xpadn_typestash
#define PadnameHasTYPE(pn) cBOOL(PadnameTYPE(pn))
#define PadnamePROTOCV(pn) (pn)->xpadn_type_u.xpadn_protocv
#define PadnameREFCNT(pn) (pn)->xpadn_refcnt
#define PadnameREFCNT_inc(pn) Perl_padname_refcnt_inc(pn)
#define PadnameREFCNT_dec(pn) Perl_padname_free(aTHX_ pn)
#define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
#define PadnameTYPE_set(pn,s) (PadnameTYPE(pn) = (s))
#define PadnameFIELDINFO(pn) (pn)->xpadn_fieldinfo
#define PadnameOUTER(pn) (PadnameFLAGS(pn) & PADNAMEf_OUTER)
#define PadnameIsSTATE(pn) (PadnameFLAGS(pn) & PADNAMEf_STATE)
#define PadnameLVALUE(pn) (PadnameFLAGS(pn) & PADNAMEf_LVALUE)
#define PadnameIsFIELD(pn) (PadnameFLAGS(pn) & PADNAMEf_FIELD)
#define PadnameLVALUE_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_LVALUE)
#define PadnameIsSTATE_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_STATE)
#define PADNAMEf_OUTER 0x01 /* outer lexical var */
#define PADNAMEf_STATE 0x02 /* state var */
#define PADNAMEf_LVALUE 0x04 /* used as lvalue */
#define PADNAMEf_TYPED 0x08 /* for B; unused by core */
#define PADNAMEf_OUR 0x10 /* for B; unused by core */
#define PADNAMEf_FIELD 0x20 /* field var */
/* backward compatibility */
#ifndef PERL_CORE
# define SvPAD_STATE PadnameIsSTATE
# define SvPAD_TYPED PadnameHasTYPE
# define SvPAD_OUR(pn) cBOOL(PadnameOURSTASH(pn))
# define SvPAD_STATE_on PadnameIsSTATE_on
# define SvPAD_TYPED_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_TYPED)
# define SvPAD_OUR_on(pn) (PadnameFLAGS(pn) |= PADNAMEf_OUR)
# define SvOURSTASH PadnameOURSTASH
# define SvOURSTASH_set PadnameOURSTASH_set
# define SVpad_STATE PADNAMEf_STATE
# define SVpad_TYPED PADNAMEf_TYPED
# define SVpad_OUR PADNAMEf_OUR
# define PADNAMEt_OUTER PADNAMEf_OUTER
# define PADNAMEt_STATE PADNAMEf_STATE
# define PADNAMEt_LVALUE PADNAMEf_LVALUE
# define PADNAMEt_TYPED PADNAMEf_TYPED
# define PADNAMEt_OUR PADNAMEf_OUR
#endif
#ifdef USE_ITHREADS
# define padnamelist_dup_inc(pnl,param) PadnamelistREFCNT_inc(padnamelist_dup(pnl,param))
# define padname_dup_inc(pn,param) PadnameREFCNT_inc(padname_dup(pn,param))
#endif
#ifdef DEBUGGING
# define PAD_SV(po) pad_sv(po)
# define PAD_SETSV(po,sv) pad_setsv(po,sv)
#else
# define PAD_SV(po) (PL_curpad[po])
# define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
#endif
#define PAD_SVl(po) (PL_curpad[po])
#define PAD_BASE_SV(padlist, po) \
(PadlistARRAY(padlist)[1]) \
? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
: NULL;
#define PAD_SET_CUR_NOSAVE(padlist,nth) \
PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]); \
PL_curpad = AvARRAY(PL_comppad); \
DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
"Pad 0x%" UVxf "[0x%" UVxf "] set_cur depth=%d\n", \
PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
#define PAD_SET_CUR(padlist,nth) \
SAVECOMPPAD(); \
PAD_SET_CUR_NOSAVE(padlist,nth);
#define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \
PL_comppad = NULL; PL_curpad = NULL; \
DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
#define PAD_SAVE_LOCAL(opad,npad) \
opad = PL_comppad; \
PL_comppad = (npad); \
PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
"Pad 0x%" UVxf "[0x%" UVxf "] save_local\n", \
PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
#define PAD_RESTORE_LOCAL(opad) \
assert(!opad || !SvIS_FREED(opad)); \
PL_comppad = opad; \
PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
"Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n", \
PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
/*
=for apidoc m|void|CX_CURPAD_SAVE|struct context
Save the current pad in the given context block structure.
=for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
Access the SV at offset C<po> in the saved current pad in the given
context block structure (can be used as an lvalue).
=cut
*/
#define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad
#define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
/*
=for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
Return the flags for the current compiling pad name
at offset C<po>. Assumes a valid slot entry.
=for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
Return the name of the current compiling pad name
at offset C<po>. Assumes a valid slot entry.
=for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
Return the type (stash) of the current compiling pad name at offset
C<po>. Must be a valid name. Returns null if not typed.
=for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
Return the stash associated with an C<our> variable.
Assumes the slot entry is a valid C<our> lexical.
=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
The generation number of the name at offset C<po> in the current
compiling pad (lvalue).
=for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
Sets the generation number of the name at offset C<po> in the current
ling pad (lvalue) to C<gen>.
=cut
*/
#define PAD_COMPNAME(po) PAD_COMPNAME_SV(po)
#define PAD_COMPNAME_SV(po) (PadnamelistARRAY(PL_comppad_name)[(po)])
#define PAD_COMPNAME_FLAGS(po) PadnameFLAGS(PAD_COMPNAME(po))
#define PAD_COMPNAME_FLAGS_isOUR(po) PadnameIsOUR(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_PV(po) PadnamePV(PAD_COMPNAME(po))
#define PAD_COMPNAME_TYPE(po) PadnameTYPE(PAD_COMPNAME(po))
#define PAD_COMPNAME_OURSTASH(po) (PadnameOURSTASH(PAD_COMPNAME_SV(po)))
#define PAD_COMPNAME_GEN(po) \
((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
#define PAD_COMPNAME_GEN_set(po, gen) \
(PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))
/*
=for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
Clone the state variables associated with running and compiling pads.
=cut
*/
/* NB - we set PL_comppad to null unless it points at a value that
* has already been dup'ed, ie it points to part of an active padlist.
* Otherwise PL_comppad ends up being a leaked scalar in code like
* the following:
* threads->create(sub { threads->create(sub {...} ) } );
* where the second thread dups the outer sub's comppad but not the
* sub's CV or padlist. */
#define PAD_CLONE_VARS(proto_perl, param) \
PL_comppad = av_dup(proto_perl->Icomppad, param); \
PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
PL_comppad_name = \
padnamelist_dup(proto_perl->Icomppad_name, param); \
PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \
PL_min_intro_pending = proto_perl->Imin_intro_pending; \
PL_max_intro_pending = proto_perl->Imax_intro_pending; \
PL_padix = proto_perl->Ipadix; \
PL_padix_floor = proto_perl->Ipadix_floor; \
PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \
PL_cop_seqmax = proto_perl->Icop_seqmax;
/*
=for apidoc Am|PADOFFSET|pad_add_name_pvs|"name"|U32 flags|HV *typestash|HV *ourstash
Exactly like L</pad_add_name_pvn>, but takes a literal string
instead of a string/length pair.
=cut
*/
#define pad_add_name_pvs(name,flags,typestash,ourstash) \
Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
/*
=for apidoc Am|PADOFFSET|pad_findmy_pvs|"name"|U32 flags
Exactly like L</pad_findmy_pvn>, but takes a literal string
instead of a string/length pair.
=cut
*/
#define pad_findmy_pvs(name,flags) \
Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
struct suspended_compcv
{
CV *compcv;
STRLEN padix, constpadix;
STRLEN comppad_name_fill;
STRLEN min_intro_pending, max_intro_pending;
bool cv_has_eval, pad_reset_pending;
};
#define resume_compcv_final(buffer) Perl_resume_compcv(aTHX_ buffer, false)
#define resume_compcv_and_save(buffer) Perl_resume_compcv(aTHX_ buffer, true)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

165
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/parser.h Normal file
View file

@ -0,0 +1,165 @@
/* parser.h
*
* Copyright (c) 2006, 2007, 2009, 2010, 2011 Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* This file defines the layout of the parser object used by the parser
* and lexer (perly.c, toke.c).
*/
#define YYEMPTY (-2)
typedef struct {
YYSTYPE val; /* semantic value */
short state;
I32 savestack_ix; /* size of savestack at this state */
CV *compcv; /* value of PL_compcv when this value was created */
#ifdef DEBUGGING
const char *name; /* token/rule name for -Dpv */
#endif
} yy_stack_frame;
/* Fields that need to be shared with (i.e., visible to) inner lex-
ing scopes. */
typedef struct yy_lexshared {
struct yy_lexshared *ls_prev;
SV *ls_linestr; /* mirrors PL_parser->linestr */
char *ls_bufptr; /* mirrors PL_parser->bufptr */
char *re_eval_start; /* start of "(?{..." text */
SV *re_eval_str; /* "(?{...})" text */
} LEXSHARED;
typedef struct yy_parser {
/* parser state */
struct yy_parser *old_parser; /* previous value of PL_parser */
YYSTYPE yylval; /* value of lookahead symbol, set by yylex() */
int yychar; /* The lookahead symbol. */
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
yy_stack_frame *stack; /* base of stack */
yy_stack_frame *stack_max1;/* (top-1)th element of allocated stack */
yy_stack_frame *ps; /* current stack frame */
int yylen; /* length of active reduction */
/* lexer state */
I32 lex_formbrack; /* bracket count at outer format level */
I32 lex_brackets; /* square and curly bracket count */
I32 lex_casemods; /* casemod count */
char *lex_brackstack;/* what kind of brackets to pop */
char *lex_casestack; /* what kind of case mods in effect */
U8 lex_defer; /* state after determined token */
U8 lex_dojoin; /* doing an array interpolation
1 = @{...} 2 = ->@ */
U8 expect; /* how to interpret ambiguous tokens */
bool preambled;
bool sub_no_recover; /* can't recover from a sublex error */
U8 sub_error_count; /* the number of errors before sublexing */
OP *lex_inpat; /* in pattern $) and $| are special */
OP *lex_op; /* extra info to pass back on op */
SV *lex_repl; /* runtime replacement from s/// */
U16 lex_inwhat; /* what kind of quoting are we in */
OPCODE last_lop_op; /* last named list or unary operator */
I32 lex_starts; /* how many interps done on level */
SV *lex_stuff; /* runtime pattern from m// or s/// */
I32 multi_start; /* 1st line of multi-line string */
I32 multi_end; /* last line of multi-line string */
UV multi_open; /* delimiter code point of said string */
UV multi_close; /* delimiter code point of said string */
bool lex_re_reparsing; /* we're doing G_RE_REPARSING */
U8 lex_super_state;/* lexer state to save */
U16 lex_sub_inwhat; /* "lex_inwhat" to use in sublex_push */
I32 lex_allbrackets;/* (), [], {}, ?: bracket count */
OP *lex_sub_op; /* current op in y/// or pattern */
SV *lex_sub_repl; /* repl of s/// used in sublex_push */
LEXSHARED *lex_shared;
SV *linestr; /* current chunk of src text */
char *bufptr; /* carries the cursor (current parsing
position) from one invocation of yylex
to the next */
char *oldbufptr; /* in yylex, beginning of current token */
char *oldoldbufptr; /* in yylex, beginning of previous token */
char *bufend;
char *linestart; /* beginning of most recently read line */
char *last_uni; /* position of last named-unary op */
char *last_lop; /* position of last list operator */
/* copline is used to pass a specific line number to newSTATEOP. It
is a one-time line number, as newSTATEOP invalidates it (sets it to
NOLINE) after using it. The purpose of this is to report line num-
bers in multiline constructs using the number of the first line. */
line_t copline;
U16 in_my; /* we're compiling a "my"/"our" declaration */
U8 lex_state; /* next token is determined */
U8 error_count; /* how many compile errors so far, max 10 */
HV *in_my_stash; /* declared class of this "my" declaration */
PerlIO *rsfp; /* current source file pointer */
AV *rsfp_filters; /* holds chain of active source filters */
YYSTYPE nextval[5]; /* value of next token, if any */
I32 nexttype[5]; /* type of next token */
U8 nexttoke;
U8 form_lex_state; /* remember lex_state when parsing fmt */
U8 lex_fakeeof; /* precedence at which to fake EOF */
U8 lex_flags;
COP *saved_curcop; /* the previous PL_curcop */
char tokenbuf[256];
line_t herelines; /* number of lines in here-doc */
line_t preambling; /* line # when processing $ENV{PERL5DB} */
/* these are valid while parsing a subroutine signature */
UV sig_elems; /* number of signature elements seen so far */
UV sig_optelems; /* number of optional signature elems seen */
char sig_slurpy; /* the sigil of the slurpy var (or null) */
bool sig_seen; /* the currently parsing sub has a signature */
bool recheck_utf8_validity;
PERL_BITFIELD16 in_pod:1; /* lexer is within a =pod section */
PERL_BITFIELD16 filtered:1; /* source filters in evalbytes */
PERL_BITFIELD16 saw_infix_sigil:1; /* saw & or * or % operator */
PERL_BITFIELD16 parsed_sub:1; /* last thing parsed was a sub */
} yy_parser;
/* flags for lexer API */
#define LEX_STUFF_UTF8 0x00000001
#define LEX_KEEP_PREVIOUS 0x00000002
#ifdef PERL_CORE
# define LEX_START_SAME_FILTER 0x00000001
# define LEX_IGNORE_UTF8_HINTS 0x00000002
# define LEX_EVALBYTES 0x00000004
# define LEX_START_COPIED 0x00000008
# define LEX_DONT_CLOSE_RSFP 0x00000010
# define LEX_START_FLAGS \
(LEX_START_SAME_FILTER|LEX_START_COPIED \
|LEX_IGNORE_UTF8_HINTS|LEX_EVALBYTES|LEX_DONT_CLOSE_RSFP)
#endif
/* flags for parser API */
#define PARSE_OPTIONAL 0x00000001
/* values for lex_fakeeof */
enum {
LEX_FAKEEOF_NEVER, /* don't fake EOF */
LEX_FAKEEOF_CLOSING, /* fake EOF at unmatched closing punctuation */
LEX_FAKEEOF_NONEXPR, /* ... and at token that can't be in expression */
LEX_FAKEEOF_LOWLOGIC, /* ... and at low-precedence logic operator */
LEX_FAKEEOF_COMMA, /* ... and at comma */
LEX_FAKEEOF_ASSIGN, /* ... and at assignment operator */
LEX_FAKEEOF_IFELSE, /* ... and at ?: operator */
LEX_FAKEEOF_RANGE, /* ... and at range operator */
LEX_FAKEEOF_LOGIC, /* ... and at logic operator */
LEX_FAKEEOF_BITWISE, /* ... and at bitwise operator */
LEX_FAKEEOF_COMPARE, /* ... and at comparison operator */
LEX_FAKEEOF_MAX
};
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

178
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/patchlevel.h Normal file
View file

@ -0,0 +1,178 @@
/* patchlevel.h
*
* Copyright (C) 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
* 2003, 2004, 2005, 2006, 2007, 2008, 2009, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
=for apidoc AmDnU|U8|PERL_REVISION
The major number component of the perl interpreter currently being compiled or
executing. This has been C<5> from 1993 into 2020.
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
=for apidoc AmDnU|U8|PERL_VERSION
The minor number component of the perl interpreter currently being compiled or
executing. Between 1993 into 2020, this has ranged from 0 to 33.
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
=for apidoc AmDnU|U8|PERL_SUBVERSION
The micro number component of the perl interpreter currently being compiled or
executing. In stable releases this gives the dot release number for
maintenance updates. In development releases this gives a tag for a snapshot
of the status at various points in the development cycle.
Instead use one of the version comparison macros. See C<L</PERL_VERSION_EQ>>.
=cut
*/
#ifndef __PATCHLEVEL_H_INCLUDED__
/* do not adjust the whitespace! Configure expects the numbers to be
* exactly on the third column */
#define PERL_REVISION 5 /* age */
#define PERL_VERSION 40 /* epoch */
#define PERL_SUBVERSION 3 /* generation */
/* The following numbers describe the earliest compatible version of
Perl ("compatibility" here being defined as sufficient binary/API
compatibility to run XS code built with the older version).
Normally this should not change across maintenance releases.
Note that this only refers to an out-of-the-box build. Many non-default
options such as usemultiplicity tend to break binary compatibility
more often.
This is used by Configure et al to figure out
PERL_INC_VERSION_LIST, which lists version libraries
to include in @INC. See INSTALL for how this works.
Porting/bump-perl-version will automatically set these to the version of perl
to be released for blead releases, and to 5.X.0 for maint releases. Manually
changing them should not be necessary.
*/
#define PERL_API_REVISION 5
#define PERL_API_VERSION 40
#define PERL_API_SUBVERSION 0
/*
XXX Note: The selection of non-default Configure options, such
as -Duselonglong may invalidate these settings. Currently, Configure
does not adequately test for this. A.D. Jan 13, 2000
*/
#define __PATCHLEVEL_H_INCLUDED__
#endif
/*
local_patches -- list of locally applied less-than-subversion patches.
If you're distributing such a patch, please give it a name and a
one-line description, placed just before the last NULL in the array
below. If your patch fixes a bug in the perlbug database, please
mention the bugid. If your patch *IS* dependent on a prior patch,
please place your applied patch line after its dependencies. This
will help tracking of patch dependencies.
Please either use 'diff --unified=0' if your diff supports
that or edit the hunk of the diff output which adds your patch
to this list, to remove context lines which would give patch
problems. For instance, if the original context diff is
*** patchlevel.h.orig <date here>
--- patchlevel.h <date here>
*** 38,43 ***
--- 38,44 ---
,"FOO1235 - some patch"
,"BAR3141 - another patch"
,"BAZ2718 - and another patch"
+ ,"MINE001 - my new patch"
,NULL
};
please change it to
*** patchlevel.h.orig <date here>
--- patchlevel.h <date here>
*** 41,43 ***
--- 41,44 ---
+ ,"MINE001 - my new patch"
,NULL
};
(Note changes to line numbers as well as removal of context lines.)
This will prevent patch from choking if someone has previously
applied different patches than you.
History has shown that nobody distributes patches that also
modify patchlevel.h. Do it yourself. The following perl
program can be used to add a comment to patchlevel.h:
#!perl
die "Usage: perl -x patchlevel.h comment ..." unless @ARGV;
open PLIN, "<", "patchlevel.h" or die "Couldn't open patchlevel.h : $!";
open PLOUT, ">", "patchlevel.new" or die "Couldn't write on patchlevel.new : $!";
my $seen=0;
while (<PLIN>) {
if (/^(\s+),NULL/ and $seen) {
my $pre = $1;
while (my $c = shift @ARGV){
$c =~ s|\\|\\\\|g;
$c =~ s|"|\\"|g;
print PLOUT qq{$pre,"$c"\n};
}
}
$seen++ if /local_patches\[\]/;
print PLOUT;
}
close PLOUT or die "Couldn't close filehandle writing to patchlevel.new : $!";
close PLIN or die "Couldn't close filehandle reading from patchlevel.h : $!";
close DATA; # needed to allow unlink to work win32.
unlink "patchlevel.bak" or warn "Couldn't unlink patchlevel.bak : $!"
if -e "patchlevel.bak";
rename "patchlevel.h", "patchlevel.bak" or
die "Couldn't rename patchlevel.h to patchlevel.bak : $!";
rename "patchlevel.new", "patchlevel.h" or
die "Couldn't rename patchlevel.new to patchlevel.h : $!";
__END__
Please keep empty lines below so that context diffs of this file do
not ever collect the lines belonging to local_patches() into the same
hunk.
*/
#if !defined(PERL_PATCHLEVEL_H_IMPLICIT) && !defined(LOCAL_PATCH_COUNT)
# if defined(PERL_IS_MINIPERL)
# define PERL_PATCHNUM "UNKNOWN-miniperl"
# define PERL_GIT_UNPUSHED_COMMITS /*leave-this-comment*/
# else
# include "git_version.h"
# endif
static const char * const local_patches[] = {
NULL
#ifdef PERL_GIT_UNCOMMITTED_CHANGES
,"uncommitted-changes"
#endif
PERL_GIT_UNPUSHED_COMMITS /* do not remove this line */
,"Cygwin: README"
,"Cygwin: modify hints"
,"Cygwin: Win32 correct UTF8 handling for tests"
,NULL
};
/* Initial space prevents this variable from being inserted in config.sh */
# define LOCAL_PATCH_COUNT \
((int)(C_ARRAY_LENGTH(local_patches)-2))
/* the old terms of reference, add them only when explicitly included */
#define PATCHLEVEL PERL_VERSION
#undef SUBVERSION /* OS/390 has a SUBVERSION in a system header */
#define SUBVERSION PERL_SUBVERSION
#endif

9264
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl.h Normal file
View file

File diff suppressed because it is too large Load diff

182
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_inc_macro.h Normal file
View file

@ -0,0 +1,182 @@
/* just define a list of macros to push elements in INC
* so we can easily use them and change order on demand
*
* list of available INCPUSH macros
* - INCPUSH_APPLLIB_EXP
* - INCPUSH_SITEARCH_EXP
* - INCPUSH_SITELIB_EXP
* - INCPUSH_PERL_VENDORARCH_EXP
* - INCPUSH_PERL_VENDORLIB_EXP
* - INCPUSH_ARCHLIB_EXP
* - INCPUSH_PRIVLIB_EXP
* - INCPUSH_PERL_OTHERLIBDIRS
* - INCPUSH_PERL5LIB
* - INCPUSH_APPLLIB_OLD_EXP
* - INCPUSH_SITELIB_STEM
* - INCPUSH_PERL_VENDORLIB_STEM
* - INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
*/
#ifndef DEFINE_INC_MACROS
/* protect against multiple inclusions */
#define DEFINE_INC_MACROS 1
#ifdef APPLLIB_EXP
# define INCPUSH_APPLLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#endif
#ifdef SITEARCH_EXP
/* sitearch is always relative to sitelib on Windows for
* DLL-based path intuition to work correctly */
# if !defined(WIN32)
# define INCPUSH_SITEARCH_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITEARCH_EXP), \
INCPUSH_CAN_RELOCATE);
# endif
#endif
#ifdef SITELIB_EXP
# if defined(WIN32)
/* this picks up sitearch as well */
# define INCPUSH_SITELIB_EXP s = PerlEnv_sitelib_path(PERL_FS_VERSION, &len); \
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
# else
# define INCPUSH_SITELIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_EXP), \
INCPUSH_CAN_RELOCATE);
# endif
#endif
#ifdef PERL_VENDORARCH_EXP
/* vendorarch is always relative to vendorlib on Windows for
* DLL-based path intuition to work correctly */
# if !defined(WIN32)
# define INCPUSH_PERL_VENDORARCH_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORARCH_EXP), INCPUSH_CAN_RELOCATE);
# endif
#endif
#ifdef PERL_VENDORLIB_EXP
# if defined(WIN32)
/* this picks up vendorarch as well */
# define INCPUSH_PERL_VENDORLIB_EXP s = PerlEnv_vendorlib_path(PERL_FS_VERSION, &len); \
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
# else
# define INCPUSH_PERL_VENDORLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_EXP), INCPUSH_CAN_RELOCATE);
# endif
#endif
#ifdef ARCHLIB_EXP
# define INCPUSH_ARCHLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(ARCHLIB_EXP), INCPUSH_CAN_RELOCATE);
#endif
/* used by INCPUSH_PRIVLIB_EXP */
#ifndef PRIVLIB_EXP
# define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
#endif
#if defined(WIN32)
# define INCPUSH_PRIVLIB_EXP s = PerlEnv_lib_path(PERL_FS_VERSION, &len); \
if (s) incpush_use_sep(s, len, INCPUSH_ADD_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#else
# define INCPUSH_PRIVLIB_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(PRIVLIB_EXP), INCPUSH_CAN_RELOCATE);
#endif
#ifdef PERL_OTHERLIBDIRS
# define INCPUSH_PERL_OTHERLIBDIRS S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
INCPUSH_ADD_VERSIONED_SUB_DIRS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
#endif
/* submacros for INCPUSH_PERL5LIB */
#define _INCPUSH_PERL5LIB_IF if (perl5lib && *perl5lib != '\0')
#ifndef VMS
# define _INCPUSH_PERL5LIB_ADD _INCPUSH_PERL5LIB_IF incpush_use_sep(perl5lib, 0, INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR);
#else
/* VMS */
/* Treat PERL5?LIB as a possible search list logical name -- the
* "natural" VMS idiom for a Unix path string. We allow each
* element to be a set of |-separated directories for compatibility.
*/
# define _INCPUSH_PERL5LIB_ADD char buf[256]; \
int idx = 0; \
if (vmstrnenv("PERL5LIB",buf,0,NULL,0)) \
do { \
incpush_use_sep(buf, 0, \
INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR); \
} while (vmstrnenv("PERL5LIB",buf,++idx,NULL,0));
#endif
/* this macro is special and use submacros from above */
#define INCPUSH_PERL5LIB if (!TAINTING_get) { _INCPUSH_PERL5LIB_ADD }
/* Use the ~-expanded versions of APPLLIB (undocumented),
SITELIB and VENDORLIB for older versions
*/
#ifdef APPLLIB_EXP
# define INCPUSH_APPLLIB_OLD_EXP S_incpush_use_sep(aTHX_ STR_WITH_LEN(APPLLIB_EXP), \
INCPUSH_ADD_OLD_VERS|INCPUSH_NOT_BASEDIR|INCPUSH_CAN_RELOCATE);
#endif
#if defined(SITELIB_STEM) && defined(PERL_INC_VERSION_LIST)
/* Search for version-specific dirs below here */
# define INCPUSH_SITELIB_STEM S_incpush_use_sep(aTHX_ STR_WITH_LEN(SITELIB_STEM), \
INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
#endif
#if defined(PERL_VENDORLIB_STEM) && defined(PERL_INC_VERSION_LIST)
/* Search for version-specific dirs below here */
# define INCPUSH_PERL_VENDORLIB_STEM S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_VENDORLIB_STEM), \
INCPUSH_ADD_OLD_VERS|INCPUSH_CAN_RELOCATE);
#endif
#ifdef PERL_OTHERLIBDIRS
# define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY S_incpush_use_sep(aTHX_ STR_WITH_LEN(PERL_OTHERLIBDIRS), \
INCPUSH_ADD_OLD_VERS|INCPUSH_ADD_ARCHONLY_SUB_DIRS|INCPUSH_CAN_RELOCATE);
#endif
/* define all undefined macros... */
#ifndef INCPUSH_APPLLIB_EXP
#define INCPUSH_APPLLIB_EXP
#endif
#ifndef INCPUSH_SITEARCH_EXP
#define INCPUSH_SITEARCH_EXP
#endif
#ifndef INCPUSH_SITELIB_EXP
#define INCPUSH_SITELIB_EXP
#endif
#ifndef INCPUSH_PERL_VENDORARCH_EXP
#define INCPUSH_PERL_VENDORARCH_EXP
#endif
#ifndef INCPUSH_PERL_VENDORLIB_EXP
#define INCPUSH_PERL_VENDORLIB_EXP
#endif
#ifndef INCPUSH_ARCHLIB_EXP
#define INCPUSH_ARCHLIB_EXP
#endif
#ifndef INCPUSH_PRIVLIB_EXP
#define INCPUSH_PRIVLIB_EXP
#endif
#ifndef INCPUSH_PERL_OTHERLIBDIRS
#define INCPUSH_PERL_OTHERLIBDIRS
#endif
#ifndef INCPUSH_PERL5LIB
#define INCPUSH_PERL5LIB
#endif
#ifndef INCPUSH_APPLLIB_OLD_EXP
#define INCPUSH_APPLLIB_OLD_EXP
#endif
#ifndef INCPUSH_SITELIB_STEM
#define INCPUSH_SITELIB_STEM
#endif
#ifndef INCPUSH_PERL_VENDORLIB_STEM
#define INCPUSH_PERL_VENDORLIB_STEM
#endif
#ifndef INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
#define INCPUSH_PERL_OTHERLIBDIRS_ARCHONLY
#endif
#endif /* DEFINE_INC_MACROS */

337
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_langinfo.h Normal file
View file

@ -0,0 +1,337 @@
/* Replaces <langinfo.h>, and allows our code to work on systems that don't
* have that. */
#ifndef PERL_LANGINFO_H
#define PERL_LANGINFO_H 1
#include "config.h"
#if defined(I_LANGINFO)
# include <langinfo.h>
#else
typedef int nl_item; /* Substitute 'int' for emulated nl_langinfo() */
#endif
/* NOTE that this file is parsed by ext/XS-APItest/t/locale.t, so be careful
* with changes */
/* If foo doesn't exist define it to a negative number. */
#ifndef CODESET
# define CODESET -1
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef D_T_FMT
# define D_T_FMT -2
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef D_FMT
# define D_FMT -3
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef T_FMT
# define T_FMT -4
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef T_FMT_AMPM
# define T_FMT_AMPM -5
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef AM_STR
# define AM_STR -6
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef PM_STR
# define PM_STR -7
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_1
# define DAY_1 -8
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_2
# define DAY_2 -9
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_3
# define DAY_3 -10
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_4
# define DAY_4 -11
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_5
# define DAY_5 -12
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_6
# define DAY_6 -13
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef DAY_7
# define DAY_7 -14
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_1
# define ABDAY_1 -15
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_2
# define ABDAY_2 -16
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_3
# define ABDAY_3 -17
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_4
# define ABDAY_4 -18
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_5
# define ABDAY_5 -19
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_6
# define ABDAY_6 -20
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABDAY_7
# define ABDAY_7 -21
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_1
# define MON_1 -22
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_2
# define MON_2 -23
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_3
# define MON_3 -24
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_4
# define MON_4 -25
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_5
# define MON_5 -26
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_6
# define MON_6 -27
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_7
# define MON_7 -28
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_8
# define MON_8 -29
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_9
# define MON_9 -30
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_10
# define MON_10 -31
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_11
# define MON_11 -32
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef MON_12
# define MON_12 -33
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_1
# define ABMON_1 -34
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_2
# define ABMON_2 -35
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_3
# define ABMON_3 -36
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_4
# define ABMON_4 -37
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_5
# define ABMON_5 -38
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_6
# define ABMON_6 -39
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_7
# define ABMON_7 -40
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_8
# define ABMON_8 -41
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_9
# define ABMON_9 -42
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_10
# define ABMON_10 -43
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_11
# define ABMON_11 -44
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ABMON_12
# define ABMON_12 -45
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ERA
# define ERA -46
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ERA_D_FMT
# define ERA_D_FMT -47
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ERA_D_T_FMT
# define ERA_D_T_FMT -48
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ERA_T_FMT
# define ERA_T_FMT -49
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef ALT_DIGITS
# define ALT_DIGITS -50
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef RADIXCHAR
# define RADIXCHAR -51
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef THOUSEP
# define THOUSEP -52
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef YESEXPR
# define YESEXPR -53
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef YESSTR
# define YESSTR -54
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef NOEXPR
# define NOEXPR -55
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef NOSTR
# define NOSTR -56
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#ifndef CRNCYSTR
# define CRNCYSTR -57
# define HAS_MISSING_LANGINFO_ITEM_
#endif
/* The rest of the items are gnu extensions, and are not #defined by its
* langinfo.h. There is a slight possibility that one of these numbers could
* conflict with some other value, in which case after much gnashing of teeth
* you will find this comment, and end up having to adjust the numbers. But
* glibc values are not (so far) negative */
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_ADDRESS)
# define _NL_ADDRESS_POSTAL_FMT -58
# define _NL_ADDRESS_COUNTRY_NAME -59
# define _NL_ADDRESS_COUNTRY_POST -60
# define _NL_ADDRESS_COUNTRY_AB2 -61
# define _NL_ADDRESS_COUNTRY_AB3 -62
# define _NL_ADDRESS_COUNTRY_CAR -63
# define _NL_ADDRESS_COUNTRY_NUM -64
# define _NL_ADDRESS_COUNTRY_ISBN -65
# define _NL_ADDRESS_LANG_NAME -66
# define _NL_ADDRESS_LANG_AB -67
# define _NL_ADDRESS_LANG_TERM -68
# define _NL_ADDRESS_LANG_LIB -69
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_IDENTIFICATION)
# define _NL_IDENTIFICATION_TITLE -70
# define _NL_IDENTIFICATION_SOURCE -71
# define _NL_IDENTIFICATION_ADDRESS -72
# define _NL_IDENTIFICATION_CONTACT -73
# define _NL_IDENTIFICATION_EMAIL -74
# define _NL_IDENTIFICATION_TEL -75
# define _NL_IDENTIFICATION_FAX -76
# define _NL_IDENTIFICATION_LANGUAGE -77
# define _NL_IDENTIFICATION_TERRITORY -78
# define _NL_IDENTIFICATION_AUDIENCE -79
# define _NL_IDENTIFICATION_APPLICATION -80
# define _NL_IDENTIFICATION_ABBREVIATION -81
# define _NL_IDENTIFICATION_REVISION -82
# define _NL_IDENTIFICATION_DATE -83
# define _NL_IDENTIFICATION_CATEGORY -84
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_MEASUREMENT)
# define _NL_MEASUREMENT_MEASUREMENT -85
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_NAME)
# define _NL_NAME_NAME_FMT -86
# define _NL_NAME_NAME_GEN -87
# define _NL_NAME_NAME_MR -88
# define _NL_NAME_NAME_MRS -89
# define _NL_NAME_NAME_MISS -90
# define _NL_NAME_NAME_MS -91
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_PAPER)
# define _NL_PAPER_HEIGHT -92
# define _NL_PAPER_WIDTH -93
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#if ! defined(HAS_NL_LANGINFO) || ! defined(LC_TELEPHONE)
# define _NL_TELEPHONE_TEL_INT_FMT -94
# define _NL_TELEPHONE_TEL_DOM_FMT -95
# define _NL_TELEPHONE_INT_SELECT -96
# define _NL_TELEPHONE_INT_PREFIX -97
# define HAS_MISSING_LANGINFO_ITEM_
#endif
/* All these categories have to be emulated if not available on the platform */
#if ! LC_CTYPE_AVAIL_ \
|| ! LC_MESSAGES_AVAIL_ \
|| ! LC_MONETARY_AVAIL_ \
|| ! LC_NUMERIC_AVAIL_ \
|| ! LC_TIME_AVAIL_ \
|| ! LC_ADDRESS_AVAIL_ \
|| ! LC_IDENTIFICATION_AVAIL_ \
|| ! LC_MEASUREMENT_AVAIL_ \
|| ! LC_NAME_AVAIL_ \
|| ! LC_PAPER_AVAIL_ \
|| ! LC_TELEPHONE_AVAIL_
# define HAS_MISSING_LANGINFO_ITEM_
#endif
#endif /* PERL_LANGINFO_H */

127
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perl_siphash.h Normal file
View file

@ -0,0 +1,127 @@
/* This is SipHash by Jean-Philippe Aumasson and Daniel J. Bernstein.
* The authors claim it is relatively secure compared to the alternatives
* and that performance wise it is a suitable hash for languages like Perl.
* See:
*
* https://www.131002.net/siphash/
*
* This implementation seems to perform slightly slower than one-at-a-time for
* short keys, but degrades slower for longer keys. Murmur Hash outperforms it
* regardless of keys size.
*
* It is 64 bit only.
*/
#ifdef CAN64BITHASH
#define SIPROUND \
STMT_START { \
v0 += v1; v1=ROTL64(v1,13); v1 ^= v0; v0=ROTL64(v0,32); \
v2 += v3; v3=ROTL64(v3,16); v3 ^= v2; \
v0 += v3; v3=ROTL64(v3,21); v3 ^= v0; \
v2 += v1; v1=ROTL64(v1,17); v1 ^= v2; v2=ROTL64(v2,32); \
} STMT_END
#define SIPHASH_SEED_STATE(key,v0,v1,v2,v3) \
do { \
v0 = v2 = U8TO64_LE(key + 0); \
v1 = v3 = U8TO64_LE(key + 8); \
/* "somepseudorandomlygeneratedbytes" */ \
v0 ^= UINT64_C(0x736f6d6570736575); \
v1 ^= UINT64_C(0x646f72616e646f6d); \
v2 ^= UINT64_C(0x6c7967656e657261); \
v3 ^= UINT64_C(0x7465646279746573); \
} while (0)
PERL_STATIC_INLINE
void S_perl_siphash_seed_state(const unsigned char * const seed_buf, unsigned char * state_buf) {
U64 *v= (U64*) state_buf;
SIPHASH_SEED_STATE(seed_buf, v[0],v[1],v[2],v[3]);
}
#define PERL_SIPHASH_FNC(FNC,SIP_ROUNDS,SIP_FINAL_ROUNDS) \
PERL_STATIC_INLINE U64 \
FNC ## _with_state_64 \
(const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
{ \
const int left = inlen & 7; \
const U8 *end = in + inlen - left; \
\
U64 b = ( ( U64 )(inlen) ) << 56; \
U64 m; \
U64 v0 = U8TO64_LE(state); \
U64 v1 = U8TO64_LE(state+8); \
U64 v2 = U8TO64_LE(state+16); \
U64 v3 = U8TO64_LE(state+24); \
\
for ( ; in != end; in += 8 ) \
{ \
m = U8TO64_LE( in ); \
v3 ^= m; \
\
SIP_ROUNDS; \
\
v0 ^= m; \
} \
\
switch( left ) \
{ \
case 7: b |= ( ( U64 )in[ 6] ) << 48; /*FALLTHROUGH*/ \
case 6: b |= ( ( U64 )in[ 5] ) << 40; /*FALLTHROUGH*/ \
case 5: b |= ( ( U64 )in[ 4] ) << 32; /*FALLTHROUGH*/ \
case 4: b |= ( ( U64 )in[ 3] ) << 24; /*FALLTHROUGH*/ \
case 3: b |= ( ( U64 )in[ 2] ) << 16; /*FALLTHROUGH*/ \
case 2: b |= ( ( U64 )in[ 1] ) << 8; /*FALLTHROUGH*/ \
case 1: b |= ( ( U64 )in[ 0] ); break; \
case 0: break; \
} \
\
v3 ^= b; \
\
SIP_ROUNDS; \
\
v0 ^= b; \
\
v2 ^= 0xff; \
\
SIP_FINAL_ROUNDS \
\
b = v0 ^ v1 ^ v2 ^ v3; \
return b; \
} \
\
PERL_STATIC_INLINE U32 \
FNC ## _with_state \
(const unsigned char * const state, const unsigned char *in, const STRLEN inlen) \
{ \
union { \
U64 h64; \
U32 h32[2]; \
} h; \
h.h64= FNC ## _with_state_64(state,in,inlen); \
return h.h32[0] ^ h.h32[1]; \
} \
\
\
PERL_STATIC_INLINE U32 \
FNC (const unsigned char * const seed, const unsigned char *in, const STRLEN inlen) \
{ \
U64 state[4]; \
SIPHASH_SEED_STATE(seed,state[0],state[1],state[2],state[3]); \
return FNC ## _with_state((U8*)state,in,inlen); \
}
PERL_SIPHASH_FNC(
S_perl_hash_siphash_1_3
,SIPROUND;
,SIPROUND;SIPROUND;SIPROUND;
)
PERL_SIPHASH_FNC(
S_perl_hash_siphash_2_4
,SIPROUND;SIPROUND;
,SIPROUND;SIPROUND;SIPROUND;SIPROUND;
)
#endif /* defined(CAN64BITHASH) */

22
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlapi.h Normal file
View file

@ -0,0 +1,22 @@
/*
*
* perlapi.h
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
* 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* This file used to declare accessor functions for Perl variables
* when PERL_GLOBAL_STRUCT was enabled, but that no longer exists.
* This file is kept for backwards compatibility with XS code that
* might include it.
*/
#ifndef __perlapi_h__
#define __perlapi_h__
#endif /* __perlapi_h__ */

350
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlio.h Normal file
View file

@ -0,0 +1,350 @@
/* perlio.h
*
* Copyright (C) 1996, 1997, 1999, 2000, 2001, 2002, 2003,
* 2004, 2005, 2006, 2007, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#ifndef PERLIO_H_
#define PERLIO_H_
/*
Interface for perl to IO functions.
There is a hierarchy of Configure determined #define controls:
USE_STDIO - No longer available via Configure. Formerly forced
PerlIO_xxx() to be #define-d onto stdio functions.
Now generates compile-time error.
USE_PERLIO - The primary Configure variable that enables PerlIO.
PerlIO_xxx() are real functions
defined in perlio.c which implement extra functionality
required for utf8 support.
*/
#ifndef USE_PERLIO
# define USE_STDIO
#endif
#ifdef USE_STDIO
# error "stdio is no longer supported as the default base layer -- use perlio."
#endif
/*-------------------- End of Configure controls ---------------------------*/
/*
* Although we may not want stdio to be used including <stdio.h> here
* avoids issues where stdio.h has strange side effects
*/
#include <stdio.h>
#if defined(USE_64_BIT_STDIO) && defined(HAS_FTELLO) && !defined(USE_FTELL64)
#define ftell ftello
#endif
#if defined(USE_64_BIT_STDIO) && defined(HAS_FSEEKO) && !defined(USE_FSEEK64)
#define fseek fseeko
#endif
/* BS2000 includes are sometimes a bit non standard :-( */
#if defined(POSIX_BC) && defined(O_BINARY) && !defined(O_TEXT)
#undef O_BINARY
#endif
#ifndef PerlIO
/* ----------- PerlIO implementation ---------- */
/* PerlIO not #define-d to something else - define the implementation */
typedef struct _PerlIO PerlIOl;
typedef struct _PerlIO_funcs PerlIO_funcs;
typedef PerlIOl *PerlIO;
#define PerlIO PerlIO
#define PERLIO_LAYERS 1
/*
=for apidoc_section $io
=for apidoc Amu||PERLIO_FUNCS_DECL|PerlIO * ftab
Declare C<ftab> to be a PerlIO function table, that is, of type
C<PerlIO_funcs>.
=for apidoc Ay|PerlIO_funcs *|PERLIO_FUNCS_CAST|PerlIO * func
Cast the pointer C<func> to be of type S<C<PerlIO_funcs *>>.
=cut
*/
#define PERLIO_FUNCS_DECL(funcs) const PerlIO_funcs funcs
#define PERLIO_FUNCS_CAST(funcs) (PerlIO_funcs*)(funcs)
PERL_CALLCONV void PerlIO_define_layer(pTHX_ PerlIO_funcs *tab);
PERL_CALLCONV PerlIO_funcs *PerlIO_find_layer(pTHX_ const char *name,
STRLEN len,
int load);
PERL_CALLCONV PerlIO *PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab),
const char *mode, SV *arg);
PERL_CALLCONV void PerlIO_pop(pTHX_ PerlIO *f);
PERL_CALLCONV AV* PerlIO_get_layers(pTHX_ PerlIO *f);
PERL_CALLCONV void PerlIO_clone(pTHX_ PerlInterpreter *proto,
CLONE_PARAMS *param);
#endif /* PerlIO */
/* ----------- End of implementation choices ---------- */
/* We now need to determine what happens if source trys to use stdio.
* There are three cases based on PERLIO_NOT_STDIO which XS code
* can set how it wants.
*/
#ifdef PERL_CORE
/* Make a choice for perl core code
- currently this is set to try and catch lingering raw stdio calls.
This is a known issue with some non UNIX ports which still use
"native" stdio features.
*/
# ifndef PERLIO_NOT_STDIO
# define PERLIO_NOT_STDIO 1
# endif
#else
# ifndef PERLIO_NOT_STDIO
# define PERLIO_NOT_STDIO 0
# endif
#endif
#ifdef PERLIO_NOT_STDIO
#if PERLIO_NOT_STDIO
/*
* PERLIO_NOT_STDIO #define'd as 1
* Case 1: Strong denial of stdio - make all stdio calls (we can think of) errors
*/
#include "nostdio.h"
#else /* if PERLIO_NOT_STDIO */
/*
* PERLIO_NOT_STDIO #define'd as 0
* Case 2: Declares that both PerlIO and stdio can be used
*/
#endif /* if PERLIO_NOT_STDIO */
#else /* ifdef PERLIO_NOT_STDIO */
/*
* PERLIO_NOT_STDIO not defined
* Case 3: Try and fake stdio calls as PerlIO calls
*/
#include "fakesdio.h"
#endif /* ifndef PERLIO_NOT_STDIO */
/* ----------- fill in things that have not got #define'd ---------- */
#ifndef Fpos_t
#define Fpos_t Off_t
#endif
#ifndef EOF
#define EOF (-1)
#endif
/* This is to catch case with no stdio */
#ifndef BUFSIZ
#define BUFSIZ 1024
#endif
/* The default buffer size for the perlio buffering layer */
#ifndef PERLIOBUF_DEFAULT_BUFSIZ
#define PERLIOBUF_DEFAULT_BUFSIZ (BUFSIZ > 8192 ? BUFSIZ : 8192)
#endif
#ifndef SEEK_SET
#define SEEK_SET 0
#endif
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif
#ifndef SEEK_END
#define SEEK_END 2
#endif
#define PERLIO_DUP_CLONE 1
#define PERLIO_DUP_FD 2
/* --------------------- Now prototypes for functions --------------- */
START_EXTERN_C
#ifndef __attribute__format__
# ifdef HASATTRIBUTE_FORMAT
# define __attribute__format__(x,y,z) __attribute__((format(x,y,z)))
# else
# define __attribute__format__(x,y,z)
# endif
#endif
#ifndef PerlIO_init
PERL_CALLCONV void PerlIO_init(pTHX);
#endif
#ifndef PerlIO_stdoutf
PERL_CALLCONV int PerlIO_stdoutf(const char *, ...)
__attribute__format__(__printf__, 1, 2);
#endif
#ifndef PerlIO_puts
PERL_CALLCONV int PerlIO_puts(PerlIO *, const char *);
#endif
#ifndef PerlIO_open
PERL_CALLCONV PerlIO *PerlIO_open(const char *, const char *);
#endif
#ifndef PerlIO_openn
PERL_CALLCONV PerlIO *PerlIO_openn(pTHX_ const char *layers, const char *mode,
int fd, int imode, int perm, PerlIO *old,
int narg, SV **arg);
#endif
#ifndef PerlIO_eof
PERL_CALLCONV int PerlIO_eof(PerlIO *);
#endif
#ifndef PerlIO_error
PERL_CALLCONV int PerlIO_error(PerlIO *);
#endif
#ifndef PerlIO_clearerr
PERL_CALLCONV void PerlIO_clearerr(PerlIO *);
#endif
#ifndef PerlIO_getc
PERL_CALLCONV int PerlIO_getc(PerlIO *);
#endif
#ifndef PerlIO_putc
PERL_CALLCONV int PerlIO_putc(PerlIO *, int);
#endif
#ifndef PerlIO_ungetc
PERL_CALLCONV int PerlIO_ungetc(PerlIO *, int);
#endif
#ifndef PerlIO_fdopen
PERL_CALLCONV PerlIO *PerlIO_fdopen(int, const char *);
#endif
#ifndef PerlIO_importFILE
PERL_CALLCONV PerlIO *PerlIO_importFILE(FILE *, const char *);
#endif
#ifndef PerlIO_exportFILE
PERL_CALLCONV FILE *PerlIO_exportFILE(PerlIO *, const char *);
#endif
#ifndef PerlIO_findFILE
PERL_CALLCONV FILE *PerlIO_findFILE(PerlIO *);
#endif
#ifndef PerlIO_releaseFILE
PERL_CALLCONV void PerlIO_releaseFILE(PerlIO *, FILE *);
#endif
#ifndef PerlIO_read
PERL_CALLCONV SSize_t PerlIO_read(PerlIO *, void *, Size_t);
#endif
#ifndef PerlIO_unread
PERL_CALLCONV SSize_t PerlIO_unread(PerlIO *, const void *, Size_t);
#endif
#ifndef PerlIO_write
PERL_CALLCONV SSize_t PerlIO_write(PerlIO *, const void *, Size_t);
#endif
#ifndef PerlIO_setlinebuf
PERL_CALLCONV void PerlIO_setlinebuf(PerlIO *);
#endif
#ifndef PerlIO_printf
PERL_CALLCONV int PerlIO_printf(PerlIO *, const char *, ...)
__attribute__format__(__printf__, 2, 3);
#endif
#ifndef PerlIO_vprintf
PERL_CALLCONV int PerlIO_vprintf(PerlIO *, const char *, va_list);
#endif
#ifndef PerlIO_tell
PERL_CALLCONV Off_t PerlIO_tell(PerlIO *);
#endif
#ifndef PerlIO_seek
PERL_CALLCONV int PerlIO_seek(PerlIO *, Off_t, int);
#endif
#ifndef PerlIO_rewind
PERL_CALLCONV void PerlIO_rewind(PerlIO *);
#endif
#ifndef PerlIO_has_base
PERL_CALLCONV int PerlIO_has_base(PerlIO *);
#endif
#ifndef PerlIO_has_cntptr
PERL_CALLCONV int PerlIO_has_cntptr(PerlIO *);
#endif
#ifndef PerlIO_fast_gets
PERL_CALLCONV int PerlIO_fast_gets(PerlIO *);
#endif
#ifndef PerlIO_canset_cnt
PERL_CALLCONV int PerlIO_canset_cnt(PerlIO *);
#endif
#ifndef PerlIO_get_ptr
PERL_CALLCONV STDCHAR *PerlIO_get_ptr(PerlIO *);
#endif
#ifndef PerlIO_get_cnt
PERL_CALLCONV SSize_t PerlIO_get_cnt(PerlIO *);
#endif
#ifndef PerlIO_set_cnt
PERL_CALLCONV void PerlIO_set_cnt(PerlIO *, SSize_t);
#endif
#ifndef PerlIO_set_ptrcnt
PERL_CALLCONV void PerlIO_set_ptrcnt(PerlIO *, STDCHAR *, SSize_t);
#endif
#ifndef PerlIO_get_base
PERL_CALLCONV STDCHAR *PerlIO_get_base(PerlIO *);
#endif
#ifndef PerlIO_get_bufsiz
PERL_CALLCONV SSize_t PerlIO_get_bufsiz(PerlIO *);
#endif
#ifndef PerlIO_tmpfile
PERL_CALLCONV PerlIO *PerlIO_tmpfile(void);
#endif
#ifndef PerlIO_tmpfile_flags
PERL_CALLCONV PerlIO *PerlIO_tmpfile_flags(int flags);
#endif
#ifndef PerlIO_stdin
PERL_CALLCONV PerlIO *PerlIO_stdin(void);
#endif
#ifndef PerlIO_stdout
PERL_CALLCONV PerlIO *PerlIO_stdout(void);
#endif
#ifndef PerlIO_stderr
PERL_CALLCONV PerlIO *PerlIO_stderr(void);
#endif
#ifndef PerlIO_getpos
PERL_CALLCONV int PerlIO_getpos(PerlIO *, SV *);
#endif
#ifndef PerlIO_setpos
PERL_CALLCONV int PerlIO_setpos(PerlIO *, SV *);
#endif
#ifndef PerlIO_fdupopen
PERL_CALLCONV PerlIO *PerlIO_fdupopen(pTHX_ PerlIO *, CLONE_PARAMS *, int);
#endif
#if !defined(PerlIO_modestr)
PERL_CALLCONV char *PerlIO_modestr(PerlIO *, char *buf);
#endif
#ifndef PerlIO_isutf8
PERL_CALLCONV int PerlIO_isutf8(PerlIO *);
#endif
#ifndef PerlIO_apply_layers
PERL_CALLCONV int PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode,
const char *names);
#endif
#ifndef PerlIO_binmode
PERL_CALLCONV int PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int omode,
const char *names);
#endif
#ifndef PerlIO_getname
PERL_CALLCONV char *PerlIO_getname(PerlIO *, char *);
#endif
PERL_CALLCONV void PerlIO_destruct(pTHX);
PERL_CALLCONV int PerlIO_intmode2str(int rawmode, char *mode, int *writing);
#ifdef PERLIO_LAYERS
PERL_CALLCONV void PerlIO_cleanup(pTHX);
PERL_CALLCONV void PerlIO_debug(const char *fmt, ...)
__attribute__format__(__printf__, 1, 2);
typedef struct PerlIO_list_s PerlIO_list_t;
#endif
END_EXTERN_C
#endif /* PERLIO_H_ */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

283
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perliol.h Normal file
View file

@ -0,0 +1,283 @@
#ifndef PERLIOL_H_
#define PERLIOL_H_
typedef struct {
PerlIO_funcs *funcs;
SV *arg;
} PerlIO_pair_t;
struct PerlIO_list_s {
IV refcnt;
IV cur;
IV len;
PerlIO_pair_t *array;
};
struct _PerlIO_funcs {
Size_t fsize;
const char *name;
Size_t size;
U32 kind;
IV (*Pushed) (pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
IV (*Popped) (pTHX_ PerlIO *f);
PerlIO *(*Open) (pTHX_ PerlIO_funcs *tab,
PerlIO_list_t *layers, IV n,
const char *mode,
int fd, int imode, int perm,
PerlIO *old, int narg, SV **args);
IV (*Binmode)(pTHX_ PerlIO *f);
SV *(*Getarg) (pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags);
IV (*Fileno) (pTHX_ PerlIO *f);
PerlIO *(*Dup) (pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
/* Unix-like functions - cf sfio line disciplines */
SSize_t(*Read) (pTHX_ PerlIO *f, void *vbuf, Size_t count);
SSize_t(*Unread) (pTHX_ PerlIO *f, const void *vbuf, Size_t count);
SSize_t(*Write) (pTHX_ PerlIO *f, const void *vbuf, Size_t count);
IV (*Seek) (pTHX_ PerlIO *f, Off_t offset, int whence);
Off_t(*Tell) (pTHX_ PerlIO *f);
IV (*Close) (pTHX_ PerlIO *f);
/* Stdio-like buffered IO functions */
IV (*Flush) (pTHX_ PerlIO *f);
IV (*Fill) (pTHX_ PerlIO *f);
IV (*Eof) (pTHX_ PerlIO *f);
IV (*Error) (pTHX_ PerlIO *f);
void (*Clearerr) (pTHX_ PerlIO *f);
void (*Setlinebuf) (pTHX_ PerlIO *f);
/* Perl's snooping functions */
STDCHAR *(*Get_base) (pTHX_ PerlIO *f);
Size_t(*Get_bufsiz) (pTHX_ PerlIO *f);
STDCHAR *(*Get_ptr) (pTHX_ PerlIO *f);
SSize_t(*Get_cnt) (pTHX_ PerlIO *f);
void (*Set_ptrcnt) (pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
};
/*--------------------------------------------------------------------------------------*/
/* Kind values */
#define PERLIO_K_RAW 0x00000001
#define PERLIO_K_BUFFERED 0x00000002
#define PERLIO_K_CANCRLF 0x00000004
#define PERLIO_K_FASTGETS 0x00000008
#define PERLIO_K_DUMMY 0x00000010
#define PERLIO_K_UTF8 0x00008000
#define PERLIO_K_DESTRUCT 0x00010000
#define PERLIO_K_MULTIARG 0x00020000
/*--------------------------------------------------------------------------------------*/
struct _PerlIO {
PerlIOl *next; /* Lower layer */
PerlIO_funcs *tab; /* Functions for this layer */
U32 flags; /* Various flags for state */
int err; /* Saved errno value */
#ifdef VMS
unsigned os_err; /* Saved vaxc$errno value */
#elif defined (OS2)
unsigned long os_err;
#elif defined (WIN32)
DWORD os_err; /* Saved GetLastError() value */
#endif
PerlIOl *head; /* our ultimate parent pointer */
};
/*--------------------------------------------------------------------------------------*/
/* Flag values */
#define PERLIO_F_EOF 0x00000100
#define PERLIO_F_CANWRITE 0x00000200
#define PERLIO_F_CANREAD 0x00000400
#define PERLIO_F_ERROR 0x00000800
#define PERLIO_F_TRUNCATE 0x00001000
#define PERLIO_F_APPEND 0x00002000
#define PERLIO_F_CRLF 0x00004000
#define PERLIO_F_UTF8 0x00008000
#define PERLIO_F_UNBUF 0x00010000
#define PERLIO_F_WRBUF 0x00020000
#define PERLIO_F_RDBUF 0x00040000
#define PERLIO_F_LINEBUF 0x00080000
#define PERLIO_F_TEMP 0x00100000
#define PERLIO_F_OPEN 0x00200000
#define PERLIO_F_FASTGETS 0x00400000
#define PERLIO_F_TTY 0x00800000
#define PERLIO_F_NOTREG 0x01000000
#define PERLIO_F_CLEARED 0x02000000 /* layer cleared but not freed */
#define PerlIOBase(f) (*(f))
#define PerlIOSelf(f,type) ((type *)PerlIOBase(f))
#define PerlIONext(f) (&(PerlIOBase(f)->next))
#define PerlIOValid(f) ((f) && *(f))
/*--------------------------------------------------------------------------------------*/
EXTCONST PerlIO_funcs PerlIO_unix;
EXTCONST PerlIO_funcs PerlIO_perlio;
EXTCONST PerlIO_funcs PerlIO_stdio;
EXTCONST PerlIO_funcs PerlIO_crlf;
EXTCONST PerlIO_funcs PerlIO_utf8;
EXTCONST PerlIO_funcs PerlIO_byte;
EXTCONST PerlIO_funcs PerlIO_raw;
EXTCONST PerlIO_funcs PerlIO_pending;
PERL_CALLCONV PerlIO *PerlIO_allocate(pTHX);
PERL_CALLCONV SV *PerlIO_arg_fetch(PerlIO_list_t *av, IV n);
#define PerlIOArg PerlIO_arg_fetch(layers,n)
#ifdef PERLIO_USING_CRLF
#define PERLIO_STDTEXT "t"
#else
#define PERLIO_STDTEXT ""
#endif
/*--------------------------------------------------------------------------------------*/
/* perlio buffer layer
As this is reasonably generic its struct and "methods" are declared here
so they can be used to "inherit" from it.
*/
typedef struct {
struct _PerlIO base; /* Base "class" info */
STDCHAR *buf; /* Start of buffer */
STDCHAR *end; /* End of valid part of buffer */
STDCHAR *ptr; /* Current position in buffer */
Off_t posn; /* Offset of buf into the file */
Size_t bufsiz; /* Real size of buffer */
IV oneword; /* Emergency buffer */
} PerlIOBuf;
PERL_CALLCONV int PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
PerlIO_list_t *layers, IV n, IV max);
PERL_CALLCONV int PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names);
PERL_CALLCONV PerlIO_funcs *PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def);
PERL_CALLCONV SV *PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param);
PERL_CALLCONV void PerlIO_cleantable(pTHX_ PerlIOl **tablep);
PERL_CALLCONV SV * PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab);
PERL_CALLCONV void PerlIO_default_buffer(pTHX_ PerlIO_list_t *av);
PERL_CALLCONV void PerlIO_stdstreams(pTHX);
PERL_CALLCONV int PerlIO__close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO_list_t * PerlIO_resolve_layers(pTHX_ const char *layers, const char *mode, int narg, SV **args);
PERL_CALLCONV PerlIO_funcs * PerlIO_default_layer(pTHX_ I32 n);
PERL_CALLCONV PerlIO_list_t * PerlIO_default_layers(pTHX);
PERL_CALLCONV PerlIO * PerlIO_reopen(const char *path, const char *mode, PerlIO *f);
PERL_CALLCONV PerlIO_list_t *PerlIO_list_alloc(pTHX);
PERL_CALLCONV PerlIO_list_t *PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param);
PERL_CALLCONV void PerlIO_list_free(pTHX_ PerlIO_list_t *list);
PERL_CALLCONV void PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg);
PERL_CALLCONV void PerlIO_list_free(pTHX_ PerlIO_list_t *list);
/* PerlIO_teardown doesn't need exporting, but the EXTERN_C is needed
* for compiling as C++. Must also match with what perl.h says. */
EXTERN_C void PerlIO_teardown(void);
/*--------------------------------------------------------------------------------------*/
/* Generic, or stub layer functions */
PERL_CALLCONV IV PerlIOBase_binmode(pTHX_ PerlIO *f);
PERL_CALLCONV void PerlIOBase_clearerr(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV PerlIOBase_eof(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_error(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_fileno(pTHX_ PerlIO *f);
PERL_CALLCONV void PerlIOBase_flush_linebuf(pTHX);
PERL_CALLCONV IV PerlIOBase_noop_fail(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_noop_ok(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_popped(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV PerlIO * PerlIOBase_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args);
PERL_CALLCONV SSize_t PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV void PerlIOBase_setlinebuf(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
/* Buf */
PERL_CALLCONV Size_t PerlIOBuf_bufsiz(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBuf_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV PerlIOBuf_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBuf_flush(pTHX_ PerlIO *f);
PERL_CALLCONV STDCHAR * PerlIOBuf_get_base(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOBuf_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV STDCHAR * PerlIOBuf_get_ptr(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *old, int narg, SV **args);
PERL_CALLCONV IV PerlIOBuf_popped(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
PERL_CALLCONV Off_t PerlIOBuf_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
/* Crlf */
PERL_CALLCONV IV PerlIOCrlf_binmode(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOCrlf_flush(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOCrlf_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV void PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
PERL_CALLCONV SSize_t PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
/* Pending */
PERL_CALLCONV IV PerlIOPending_close(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOPending_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOPending_flush(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
/* Pop */
PERL_CALLCONV IV PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
/* Raw */
PERL_CALLCONV IV PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
/* Stdio */
PERL_CALLCONV void PerlIOStdio_clearerr(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOStdio_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV PerlIOStdio_eof(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOStdio_error(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOStdio_fileno(pTHX_ PerlIO *f);
#ifdef USE_STDIO_PTR
PERL_CALLCONV STDCHAR * PerlIOStdio_get_ptr(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOStdio_get_cnt(pTHX_ PerlIO *f);
PERL_CALLCONV void PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt);
#endif
PERL_CALLCONV IV PerlIOStdio_fill(pTHX_ PerlIO *f);
PERL_CALLCONV IV PerlIOStdio_flush(pTHX_ PerlIO *f);
#ifdef FILE_base
PERL_CALLCONV STDCHAR * PerlIOStdio_get_base(pTHX_ PerlIO *f);
PERL_CALLCONV Size_t PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f);
#endif
PERL_CALLCONV char * PerlIOStdio_mode(const char *mode, char *tmode);
PERL_CALLCONV PerlIO * PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args);
PERL_CALLCONV IV PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV IV PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV void PerlIOStdio_setlinebuf(pTHX_ PerlIO *f);
PERL_CALLCONV Off_t PerlIOStdio_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
PERL_CALLCONV SSize_t PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
/* Unix */
PERL_CALLCONV IV PerlIOUnix_close(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags);
PERL_CALLCONV IV PerlIOUnix_fileno(pTHX_ PerlIO *f);
PERL_CALLCONV int PerlIOUnix_oflags(const char *mode);
PERL_CALLCONV PerlIO * PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers, IV n, const char *mode, int fd, int imode, int perm, PerlIO *f, int narg, SV **args);
PERL_CALLCONV IV PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
PERL_CALLCONV SSize_t PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count);
PERL_CALLCONV int PerlIOUnix_refcnt_dec(int fd);
PERL_CALLCONV void PerlIOUnix_refcnt_inc(int fd);
PERL_CALLCONV int PerlIOUnix_refcnt(int fd);
PERL_CALLCONV IV PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
PERL_CALLCONV Off_t PerlIOUnix_tell(pTHX_ PerlIO *f);
PERL_CALLCONV SSize_t PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count);
/* Utf8 */
PERL_CALLCONV IV PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab);
#endif /* PERLIOL_H_ */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

21
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlsdio.h Normal file
View file

@ -0,0 +1,21 @@
/* perlsdio.h
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001,
* 2002, 2003, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/* Shouldn't be possible to get here, but if we did ... */
#ifdef PERLIO_IS_STDIO
# error "stdio is no longer supported as the default base layer -- use perlio."
#endif /* PERLIO_IS_STDIO */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

33
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlstatic.h Normal file
View file

@ -0,0 +1,33 @@
/* perlstatic.h
*
* 'I don't know half of you half as well as I should like; and I like less
* than half of you half as well as you deserve.'
*
* Copyright (C) 2020 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* This file is a home for static functions that we don't consider suitable for
* inlining, but for which giving the compiler full knowledge of may be
* advantageous. Functions that have potential tail call optimizations are a
* likely component.
*/
/* saves machine code for a common noreturn idiom typically used in Newx*() */
GCC_DIAG_IGNORE_DECL(-Wunused-function);
STATIC void
Perl_croak_memory_wrap(void)
{
Perl_croak_nocontext("%s",PL_memory_wrap);
}
GCC_DIAG_RESTORE_DECL;
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

400
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perlvars.h Normal file
View file

@ -0,0 +1,400 @@
/* perlvars.h
*
* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
* by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
=head1 Global Variables
These variables are global to an entire process. They are shared between
all interpreters and all threads in a process. Any variables not documented
here may be changed or removed without notice, so don't use them!
If you feel you really do need to use an unlisted variable, first send email to
L<perl5-porters@perl.org|mailto:perl5-porters@perl.org>. It may be that
someone there will point out a way to accomplish what you need without using an
internal variable. But if not, you should get a go-ahead to document and then
use the variable.
=cut
*/
/* Don't forget to re-run regen/embed.pl to propagate changes! */
/* This file describes the "global" variables used by perl
* This used to be in perl.h directly but we want to abstract out into
* distinct files which are per-thread, per-interpreter or really global,
* and how they're initialized.
*
* The 'G' prefix is only needed for vars that need appropriate #defines
* generated in embed*.h. Such symbols are also used to generate
* the appropriate export list for win32. */
/* global state */
#if defined(USE_ITHREADS)
PERLVAR(G, op_mutex, perl_mutex) /* Mutex for op refcounting */
#endif
PERLVARI(G, curinterp, PerlInterpreter *, NULL)
/* currently running interpreter
* (initial parent interpreter under
* useithreads) */
#if defined(USE_ITHREADS)
PERLVAR(G, thr_key, perl_key) /* key to retrieve per-thread struct */
#endif
/* XXX does anyone even use this? */
PERLVARI(G, do_undump, bool, FALSE) /* -u or dump seen? */
#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
PERLVARI(G, sig_handlers_initted, int, 0)
#endif
#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
PERLVARA(G, sig_ignoring, SIG_SIZE, int)
/* which signals we are ignoring */
#endif
#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
PERLVARA(G, sig_defaulting, SIG_SIZE, int)
#endif
/* XXX signals are process-wide anyway, so we
* ignore the implications of this for threading */
#ifndef HAS_SIGACTION
PERLVARI(G, sig_trapped, int, 0)
#endif
/* If Perl has to ignore SIGPFE, this is its saved state.
* See perl.h macros PERL_FPU_INIT and PERL_FPU_{PRE,POST}_EXEC. */
PERLVAR(G, sigfpe_saved, Sighandler_t)
/* these ptrs to functions are to avoid linkage problems; see
* perl-5.8.0-2193-g5c1546dc48
*/
PERLVARI(G, csighandlerp, Sighandler_t, Perl_csighandler)
PERLVARI(G, csighandler1p, Sighandler1_t, Perl_csighandler1)
PERLVARI(G, csighandler3p, Sighandler3_t, Perl_csighandler3)
/* This is constant on most architectures, a global on OS/2 */
#ifdef OS2
PERLVARI(G, sh_path, char *, SH_PATH) /* full path of shell */
#endif
#ifdef USE_PERLIO
# if defined(USE_ITHREADS)
PERLVAR(G, perlio_mutex, perl_mutex) /* Mutex for perlio fd refcounts */
# endif
PERLVARI(G, perlio_fd_refcnt, int *, 0) /* Pointer to array of fd refcounts. */
PERLVARI(G, perlio_fd_refcnt_size, int, 0) /* Size of the array */
PERLVARI(G, perlio_debug_fd, int, 0) /* the fd to write perlio debug into, 0 means not set yet */
#endif
#ifdef HAS_MMAP
PERLVARI(G, mmap_page_size, IV, 0)
#endif
#if defined(USE_ITHREADS)
PERLVAR(G, hints_mutex, perl_mutex) /* Mutex for refcounted he refcounting */
PERLVAR(G, env_mutex, perl_RnW1_mutex_t) /* Mutex for accessing ENV */
PERLVAR(G, locale_mutex, perl_mutex) /* Mutex related to locale handling */
#endif
#ifdef USE_POSIX_2008_LOCALE
PERLVARI(G, C_locale_obj, locale_t, NULL)
#endif
PERLVARI(G, watch_pvx, char *, NULL)
/*
=for apidoc AmnU|Perl_check_t *|PL_check
Array, indexed by opcode, of functions that will be called for the "check"
phase of optree building during compilation of Perl code. For most (but
not all) types of op, once the op has been initially built and populated
with child ops it will be filtered through the check function referenced
by the appropriate element of this array. The new op is passed in as the
sole argument to the check function, and the check function returns the
completed op. The check function may (as the name suggests) check the op
for validity and signal errors. It may also initialise or modify parts of
the ops, or perform more radical surgery such as adding or removing child
ops, or even throw the op away and return a different op in its place.
This array of function pointers is a convenient place to hook into the
compilation process. An XS module can put its own custom check function
in place of any of the standard ones, to influence the compilation of a
particular type of op. However, a custom check function must never fully
replace a standard check function (or even a custom check function from
another module). A module modifying checking must instead B<wrap> the
preexisting check function. A custom check function must be selective
about when to apply its custom behaviour. In the usual case where
it decides not to do anything special with an op, it must chain the
preexisting op function. Check functions are thus linked in a chain,
with the core's base checker at the end.
For thread safety, modules should not write directly to this array.
Instead, use the function L</wrap_op_checker>.
=for apidoc Amn|enum perl_phase|PL_phase
A value that indicates the current Perl interpreter's phase. Possible values
include C<PERL_PHASE_CONSTRUCT>, C<PERL_PHASE_START>, C<PERL_PHASE_CHECK>,
C<PERL_PHASE_INIT>, C<PERL_PHASE_RUN>, C<PERL_PHASE_END>, and
C<PERL_PHASE_DESTRUCT>.
For example, the following determines whether the interpreter is in
global destruction:
if (PL_phase == PERL_PHASE_DESTRUCT) {
// we are in global destruction
}
C<PL_phase> was introduced in Perl 5.14; in prior perls you can use
C<PL_dirty> (boolean) to determine whether the interpreter is in global
destruction. (Use of C<PL_dirty> is discouraged since 5.14.)
=cut
*/
#if defined(USE_ITHREADS)
PERLVAR(G, check_mutex, perl_mutex) /* Mutex for PL_check */
#endif
/* allocate a unique index to every module that calls MY_CXT_INIT */
#ifdef MULTIPLICITY
# ifdef USE_ITHREADS
PERLVAR(G, my_ctx_mutex, perl_mutex)
PERLVARI(G, veto_switch_non_tTHX_context, int, FALSE)
# endif
PERLVARI(G, my_cxt_index, int, 0)
#endif
/* this is currently set without MUTEX protection, so keep it a type which
* can be set atomically (ie not a bit field) */
PERLVARI(G, veto_cleanup, int, FALSE) /* exit without cleanup */
/*
=for apidoc AmnUx|Perl_keyword_plugin_t|PL_keyword_plugin
Function pointer, pointing at a function used to handle extended keywords.
The function should be declared as
int keyword_plugin_function(pTHX_
char *keyword_ptr, STRLEN keyword_len,
OP **op_ptr)
The function is called from the tokeniser, whenever a possible keyword
is seen. C<keyword_ptr> points at the word in the parser's input
buffer, and C<keyword_len> gives its length; it is not null-terminated.
The function is expected to examine the word, and possibly other state
such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it
as an extended keyword. If it does not, the function should return
C<KEYWORD_PLUGIN_DECLINE>, and the normal parser process will continue.
If the function wants to handle the keyword, it first must
parse anything following the keyword that is part of the syntax
introduced by the keyword. See L</Lexer interface> for details.
When a keyword is being handled, the plugin function must build
a tree of C<OP> structures, representing the code that was parsed.
The root of the tree must be stored in C<*op_ptr>. The function then
returns a constant indicating the syntactic role of the construct that
it has parsed: C<KEYWORD_PLUGIN_STMT> if it is a complete statement, or
C<KEYWORD_PLUGIN_EXPR> if it is an expression. Note that a statement
construct cannot be used inside an expression (except via C<do BLOCK>
and similar), and an expression is not a complete statement (it requires
at least a terminating semicolon).
When a keyword is handled, the plugin function may also have
(compile-time) side effects. It may modify C<%^H>, define functions, and
so on. Typically, if side effects are the main purpose of a handler,
it does not wish to generate any ops to be included in the normal
compilation. In this case it is still required to supply an op tree,
but it suffices to generate a single null op.
That's how the C<*PL_keyword_plugin> function needs to behave overall.
Conventionally, however, one does not completely replace the existing
handler function. Instead, take a copy of C<PL_keyword_plugin> before
assigning your own function pointer to it. Your handler function should
look for keywords that it is interested in and handle those. Where it
is not interested, it should call the saved plugin function, passing on
the arguments it received. Thus C<PL_keyword_plugin> actually points
at a chain of handler functions, all of which have an opportunity to
handle keywords, and only the last function in the chain (built into
the Perl core) will normally return C<KEYWORD_PLUGIN_DECLINE>.
For thread safety, modules should not set this variable directly.
Instead, use the function L</wrap_keyword_plugin>.
=cut
*/
#if defined(USE_ITHREADS)
PERLVAR(G, keyword_plugin_mutex, perl_mutex) /* Mutex for PL_keyword_plugin and PL_infix_plugin */
#endif
PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard)
/*
=for apidoc AmnUx|Perl_infix_plugin_t|PL_infix_plugin
B<NOTE:> This API exists entirely for the purpose of making the CPAN module
C<XS::Parse::Infix> work. It is not expected that additional modules will make
use of it; rather, that they should use C<XS::Parse::Infix> to provide parsing
of new infix operators.
Function pointer, pointing at a function used to handle extended infix
operators. The function should be declared as
int infix_plugin_function(pTHX_
char *opname, STRLEN oplen,
struct Perl_custom_infix **infix_ptr)
The function is called from the tokenizer whenever a possible infix operator
is seen. C<opname> points to the operator name in the parser's input buffer,
and C<oplen> gives the I<maximum> number of bytes of it that should be
consumed; it is not null-terminated. The function is expected to examine the
operator name and possibly other state such as L<%^H|perlvar/%^H>, to
determine whether it wants to handle the operator name.
As compared to the single stage of C<PL_keyword_plugin>, parsing of additional
infix operators occurs in three separate stages. This is because of the more
complex interactions it has with the parser, to ensure that operator
precedence rules work correctly. These stages are co-ordinated by the use of
an additional information structure.
If the function wants to handle the infix operator, it must set the variable
pointed to by C<infix_ptr> to the address of a structure that provides this
additional information about the subsequent parsing stages. If it does not,
it should make a call to the next function in the chain.
This structure has the following definition:
struct Perl_custom_infix {
enum Perl_custom_infix_precedence prec;
void (*parse)(pTHX_ SV **opdata,
struct Perl_custom_infix *);
OP *(*build_op)(pTHX_ SV **opdata, OP *lhs, OP *rhs,
struct Perl_custom_infix *);
};
The function must then return an integer giving the number of bytes consumed
by the name of this operator. In the case of an operator whose name is
composed of identifier characters, this must be equal to C<oplen>. In the case
of an operator named by non-identifier characters, this is permitted to be
shorter than C<oplen>, and any additional characters after it will not be
claimed by the infix operator but instead will be consumed by the tokenizer
and parser as normal.
If the optional C<parse> function is provided, it is called immediately by the
parser to let the operator's definition consume any additional syntax from the
source code. This should I<not> be used for normal operand parsing, but it may
be useful when implementing things like parametric operators or meta-operators
that consume more syntax themselves. This function may use the variable
pointed to by C<opdata> to provide an SV containing additional data to be
passed into the C<build_op> function later on.
The information structure gives the operator precedence level in the C<prec>
field. This is used to tell the parser how much of the surrounding syntax
before and after should be considered as operands to the operator.
The tokenizer and parser will then continue to operate as normal until enough
additional input has been parsed to form both the left- and right-hand side
operands to the operator, according to the precedence level. At this point the
C<build_op> function is called, being passed the left- and right-hand operands
as optree fragments. It is expected to combine them into the resulting optree
fragment, which it should return.
After the C<build_op> function has returned, if the variable pointed to by
C<opdata> was set to a non-C<NULL> value, it will then be destroyed by calling
C<SvREFCNT_dec()>.
For thread safety, modules should not set this variable directly.
Instead, use the function L</wrap_infix_plugin>.
However, that all said, the introductory note above still applies. This
variable is provided in core perl only for the benefit of the
C<XS::Parse::Infix> module. That module acts as a central registry for infix
operators, automatically handling things like deparse support and
discovery/reflection, and these abilities only work because it knows all the
registered operators. Other modules should not use this interpreter variable
directly to implement them because then those central features would no longer
work properly.
Furthermore, it is likely that this (experimental) API will be replaced in a
future Perl version by a more complete API that fully implements the central
registry and other semantics currently provided by C<XS::Parse::Infix>, once
the module has had sufficient experimental testing time. This current
mechanism exists only as an interim measure to get to that stage.
=cut
*/
PERLVARI(G, infix_plugin, Perl_infix_plugin_t, Perl_infix_plugin_standard)
PERLVARI(G, op_sequence, HV *, NULL) /* dump.c */
PERLVARI(G, op_seq, UV, 0) /* dump.c */
#ifdef USE_ITHREADS
PERLVAR(G, dollarzero_mutex, perl_mutex) /* Modifying $0 */
#endif
/* Restricted hashes placeholder value.
In theory, the contents are never used, only the address.
In practice, &PL_sv_placeholder is returned by some APIs, and the calling
code is checking SvOK(). */
PERLVAR(G, sv_placeholder, SV)
#if defined(MYMALLOC) && defined(USE_ITHREADS)
PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */
#endif
PERLVARI(G, hash_seed_set, bool, FALSE) /* perl.c */
PERLVARA(G, hash_seed_w, PERL_HASH_SEED_WORDS, PVT__PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
#if defined(PERL_HASH_STATE_BYTES)
PERLVARA(G, hash_state_w, PERL_HASH_STATE_WORDS, PVT__PERL_HASH_WORD_TYPE) /* perl.c and hv.h */
#endif
#if defined(PERL_USE_SINGLE_CHAR_HASH_CACHE)
#define PERL_SINGLE_CHAR_HASH_CACHE_ELEMS ((1+256) * sizeof(U32))
PERLVARA(G, hash_chars, PERL_SINGLE_CHAR_HASH_CACHE_ELEMS, unsigned char) /* perl.c and hv.h */
#endif
/* The path separator can vary depending on whether we're running under DCL or
* a Unix shell.
*/
#ifdef __VMS
PERLVAR(G, perllib_sep, char)
#endif
/* Definitions of user-defined \p{} properties, as the subs that define them
* are only called once */
PERLVARI(G, user_def_props, HV *, NULL)
#if defined(USE_ITHREADS)
PERLVAR(G, user_def_props_aTHX, PerlInterpreter *) /* aTHX that user_def_props
was defined in */
PERLVAR(G, user_prop_mutex, perl_mutex) /* Mutex for manipulating
PL_user_defined_properties */
#endif
/* these record the best way to perform certain IO operations while
* atomically setting FD_CLOEXEC. On the first call, a probe is done
* and the result recorded for use by subsequent calls.
* In theory these variables aren't thread-safe, but the worst that can
* happen is that two treads will both do an initial probe
*/
PERLVARI(G, strategy_dup, int, 0) /* doio.c */
PERLVARI(G, strategy_dup2, int, 0) /* doio.c */
PERLVARI(G, strategy_open, int, 0) /* doio.c */
PERLVARI(G, strategy_open3, int, 0) /* doio.c */
PERLVARI(G, strategy_mkstemp, int, 0) /* doio.c */
PERLVARI(G, strategy_socket, int, 0) /* doio.c */
PERLVARI(G, strategy_accept, int, 0) /* doio.c */
PERLVARI(G, strategy_pipe, int, 0) /* doio.c */
PERLVARI(G, strategy_socketpair, int, 0) /* doio.c */
PERLVARI(G, my_environ, char **, NULL)
PERLVARI(G, origenviron, char **, NULL)

246
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/perly.h Normal file
View file

@ -0,0 +1,246 @@
/* -*- mode: C; buffer-read-only: t -*-
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
This file is built by regen_perly.pl from perly.y.
Any changes made here will be lost!
*/
#define PERL_BISON_VERSION 30007
#ifdef PERL_CORE
/* A Bison parser, made by GNU Bison 3.7. */
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
Inc.
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 3 of the License, 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, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
especially those whose name start with YY_ or yy_. They are
private implementation details that can be changed or removed. */
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Token kinds. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
YYEMPTY = -2,
YYEOF = 0, /* "end of file" */
YYerror = 256, /* error */
YYUNDEF = 257, /* "invalid token" */
GRAMPROG = 258, /* GRAMPROG */
GRAMEXPR = 259, /* GRAMEXPR */
GRAMBLOCK = 260, /* GRAMBLOCK */
GRAMBARESTMT = 261, /* GRAMBARESTMT */
GRAMFULLSTMT = 262, /* GRAMFULLSTMT */
GRAMSTMTSEQ = 263, /* GRAMSTMTSEQ */
GRAMSUBSIGNATURE = 264, /* GRAMSUBSIGNATURE */
PERLY_AMPERSAND = 265, /* PERLY_AMPERSAND */
PERLY_BRACE_OPEN = 266, /* PERLY_BRACE_OPEN */
PERLY_BRACE_CLOSE = 267, /* PERLY_BRACE_CLOSE */
PERLY_BRACKET_OPEN = 268, /* PERLY_BRACKET_OPEN */
PERLY_BRACKET_CLOSE = 269, /* PERLY_BRACKET_CLOSE */
PERLY_COMMA = 270, /* PERLY_COMMA */
PERLY_DOLLAR = 271, /* PERLY_DOLLAR */
PERLY_DOT = 272, /* PERLY_DOT */
PERLY_EQUAL_SIGN = 273, /* PERLY_EQUAL_SIGN */
PERLY_MINUS = 274, /* PERLY_MINUS */
PERLY_PERCENT_SIGN = 275, /* PERLY_PERCENT_SIGN */
PERLY_PLUS = 276, /* PERLY_PLUS */
PERLY_SEMICOLON = 277, /* PERLY_SEMICOLON */
PERLY_SLASH = 278, /* PERLY_SLASH */
PERLY_SNAIL = 279, /* PERLY_SNAIL */
PERLY_STAR = 280, /* PERLY_STAR */
KW_FORMAT = 281, /* KW_FORMAT */
KW_PACKAGE = 282, /* KW_PACKAGE */
KW_CLASS = 283, /* KW_CLASS */
KW_LOCAL = 284, /* KW_LOCAL */
KW_MY = 285, /* KW_MY */
KW_FIELD = 286, /* KW_FIELD */
KW_IF = 287, /* KW_IF */
KW_ELSE = 288, /* KW_ELSE */
KW_ELSIF = 289, /* KW_ELSIF */
KW_UNLESS = 290, /* KW_UNLESS */
KW_FOR = 291, /* KW_FOR */
KW_UNTIL = 292, /* KW_UNTIL */
KW_WHILE = 293, /* KW_WHILE */
KW_CONTINUE = 294, /* KW_CONTINUE */
KW_GIVEN = 295, /* KW_GIVEN */
KW_WHEN = 296, /* KW_WHEN */
KW_DEFAULT = 297, /* KW_DEFAULT */
KW_TRY = 298, /* KW_TRY */
KW_CATCH = 299, /* KW_CATCH */
KW_FINALLY = 300, /* KW_FINALLY */
KW_DEFER = 301, /* KW_DEFER */
KW_REQUIRE = 302, /* KW_REQUIRE */
KW_DO = 303, /* KW_DO */
KW_USE_or_NO = 304, /* KW_USE_or_NO */
KW_SUB_named = 305, /* KW_SUB_named */
KW_SUB_named_sig = 306, /* KW_SUB_named_sig */
KW_SUB_anon = 307, /* KW_SUB_anon */
KW_SUB_anon_sig = 308, /* KW_SUB_anon_sig */
KW_METHOD_named = 309, /* KW_METHOD_named */
KW_METHOD_anon = 310, /* KW_METHOD_anon */
BAREWORD = 311, /* BAREWORD */
METHCALL0 = 312, /* METHCALL0 */
METHCALL = 313, /* METHCALL */
THING = 314, /* THING */
PMFUNC = 315, /* PMFUNC */
PRIVATEREF = 316, /* PRIVATEREF */
QWLIST = 317, /* QWLIST */
FUNC0OP = 318, /* FUNC0OP */
FUNC0SUB = 319, /* FUNC0SUB */
UNIOPSUB = 320, /* UNIOPSUB */
LSTOPSUB = 321, /* LSTOPSUB */
PLUGEXPR = 322, /* PLUGEXPR */
PLUGSTMT = 323, /* PLUGSTMT */
LABEL = 324, /* LABEL */
LOOPEX = 325, /* LOOPEX */
DOTDOT = 326, /* DOTDOT */
YADAYADA = 327, /* YADAYADA */
FUNC0 = 328, /* FUNC0 */
FUNC1 = 329, /* FUNC1 */
FUNC = 330, /* FUNC */
UNIOP = 331, /* UNIOP */
LSTOP = 332, /* LSTOP */
POWOP = 333, /* POWOP */
MULOP = 334, /* MULOP */
ADDOP = 335, /* ADDOP */
DOLSHARP = 336, /* DOLSHARP */
HASHBRACK = 337, /* HASHBRACK */
NOAMP = 338, /* NOAMP */
COLONATTR = 339, /* COLONATTR */
FORMLBRACK = 340, /* FORMLBRACK */
FORMRBRACK = 341, /* FORMRBRACK */
SUBLEXSTART = 342, /* SUBLEXSTART */
SUBLEXEND = 343, /* SUBLEXEND */
PHASER = 344, /* PHASER */
PREC_LOW = 345, /* PREC_LOW */
PLUGIN_LOW_OP = 346, /* PLUGIN_LOW_OP */
OROP = 347, /* OROP */
PLUGIN_LOGICAL_OR_LOW_OP = 348, /* PLUGIN_LOGICAL_OR_LOW_OP */
ANDOP = 349, /* ANDOP */
PLUGIN_LOGICAL_AND_LOW_OP = 350, /* PLUGIN_LOGICAL_AND_LOW_OP */
NOTOP = 351, /* NOTOP */
ASSIGNOP = 352, /* ASSIGNOP */
PLUGIN_ASSIGN_OP = 353, /* PLUGIN_ASSIGN_OP */
PERLY_QUESTION_MARK = 354, /* PERLY_QUESTION_MARK */
PERLY_COLON = 355, /* PERLY_COLON */
OROR = 356, /* OROR */
DORDOR = 357, /* DORDOR */
PLUGIN_LOGICAL_OR_OP = 358, /* PLUGIN_LOGICAL_OR_OP */
ANDAND = 359, /* ANDAND */
PLUGIN_LOGICAL_AND_OP = 360, /* PLUGIN_LOGICAL_AND_OP */
BITOROP = 361, /* BITOROP */
BITANDOP = 362, /* BITANDOP */
CHEQOP = 363, /* CHEQOP */
NCEQOP = 364, /* NCEQOP */
CHRELOP = 365, /* CHRELOP */
NCRELOP = 366, /* NCRELOP */
PLUGIN_REL_OP = 367, /* PLUGIN_REL_OP */
SHIFTOP = 368, /* SHIFTOP */
PLUGIN_ADD_OP = 369, /* PLUGIN_ADD_OP */
PLUGIN_MUL_OP = 370, /* PLUGIN_MUL_OP */
MATCHOP = 371, /* MATCHOP */
PERLY_EXCLAMATION_MARK = 372, /* PERLY_EXCLAMATION_MARK */
PERLY_TILDE = 373, /* PERLY_TILDE */
UMINUS = 374, /* UMINUS */
REFGEN = 375, /* REFGEN */
PLUGIN_POW_OP = 376, /* PLUGIN_POW_OP */
PREINC = 377, /* PREINC */
PREDEC = 378, /* PREDEC */
POSTINC = 379, /* POSTINC */
POSTDEC = 380, /* POSTDEC */
POSTJOIN = 381, /* POSTJOIN */
PLUGIN_HIGH_OP = 382, /* PLUGIN_HIGH_OP */
ARROW = 383, /* ARROW */
PERLY_PAREN_CLOSE = 384, /* PERLY_PAREN_CLOSE */
PERLY_PAREN_OPEN = 385 /* PERLY_PAREN_OPEN */
};
typedef enum yytokentype yytoken_kind_t;
#endif
/* Value type. */
#ifdef PERL_IN_TOKE_C
static bool
S_is_opval_token(int type) {
switch (type) {
case BAREWORD:
case FUNC0OP:
case FUNC0SUB:
case LABEL:
case LSTOPSUB:
case METHCALL:
case METHCALL0:
case PLUGEXPR:
case PLUGSTMT:
case PMFUNC:
case PRIVATEREF:
case QWLIST:
case THING:
case UNIOPSUB:
return 1;
}
return 0;
}
#endif /* PERL_IN_TOKE_C */
#endif /* PERL_CORE */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{
I32 ival; /* __DEFAULT__ (marker for regen_perly.pl;
must always be 1st union member) */
void *pval;
OP *opval;
GV *gvval;
};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
int yyparse (void);
/* Generated from:
* 823630846fc59cc2a19502726ec723b568eabded55fdc5e9722c600e1098779e perly.y
* acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
* ex: set ro ft=c: */

742
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp.h Normal file
View file

@ -0,0 +1,742 @@
/* pp.h
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
* 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
=for apidoc_section $rpp
=for apidoc Amux||XSPP_wrapped|xsppw_name|I32 xsppw_nargs|I32 xsppw_nlists
Declare and wrap a non-reference-counted PP-style function.
On traditional perl builds where the stack isn't reference-counted, this
just produces a function declaration like
OP * xsppw_name(pTHX)
Conversely, in ref-counted builds it creates xsppw_name() as a small
wrapper function which calls the real function via a wrapper which
processes the args and return values to ensure that reference counts are
properly handled for code which uses old-style dSP, PUSHs(), POPs() etc,
which don't adjust the reference counts of the items they manipulate.
xsppw_nargs indicates how many arguments the function consumes off the
stack. It can be a constant value or an expression, such as
((PL_op->op_flags & OPf_STACKED) ? 2 : 1)
Alternatively if xsppw_nlists is 1, it indicates that the PP function
consumes a list (or - rarely - if 2, consumes two lists, like
pp_aassign()), as indicated by the top markstack position.
This is intended as a temporary fix when converting XS code to run under
PERL_RC_STACK builds. In the longer term, the PP function should be
rewritten to replace PUSHs() etc with rpp_push_1() etc.
=cut
*/
#ifdef PERL_RC_STACK
# define XSPP_wrapped(xsppw_name, xsppw_nargs, xsppw_nlists) \
\
STATIC OP* S_##xsppw_name##_norc(pTHX); \
OP* xsppw_name(pTHX) \
{ \
return Perl_pp_wrap(aTHX_ S_##xsppw_name##_norc, \
(xsppw_nargs), (xsppw_nlists)); \
} \
STATIC OP* S_##xsppw_name##_norc(pTHX)
#else
# define XSPP_wrapped(xsppw_name, xsppw_nargs, xsppw_nlists) \
OP * xsppw_name(pTHX)
#endif
#define PP_wrapped(ppw_name, ppw_nargs, ppw_nlists) \
XSPP_wrapped(Perl_##ppw_name, ppw_nargs, ppw_nlists)
#define PP(s) OP * Perl_##s(pTHX)
/*
=for apidoc_section $stack
=for apidoc AmnU||SP
Stack pointer. This is usually handled by C<xsubpp>. See C<L</dSP>> and
C<SPAGAIN>.
=for apidoc AmnU||MARK
Stack marker variable for the XSUB. See C<L</dMARK>>.
=for apidoc Am|void|PUSHMARK|SP
Opening bracket for arguments on a callback. See C<L</PUTBACK>> and
L<perlcall>.
=for apidoc Amn;||dSP
Declares a local copy of perl's stack pointer for the XSUB, available via
the C<SP> macro. See C<L</SP>>.
=for apidoc m;||djSP
Declare Just C<SP>. This is actually identical to C<dSP>, and declares
a local copy of perl's stack pointer, available via the C<SP> macro.
See C<L<perlapi/SP>>. (Available for backward source code compatibility with
the old (Perl 5.005) thread model.)
=for apidoc Amn;||dMARK
Declare a stack marker variable, C<mark>, for the XSUB. See C<L</MARK>> and
C<L</dORIGMARK>>.
=for apidoc Amn;||dORIGMARK
Saves the original stack mark for the XSUB. See C<L</ORIGMARK>>.
=for apidoc AmnU||ORIGMARK
The original stack mark for the XSUB. See C<L</dORIGMARK>>.
=for apidoc Amn;||SPAGAIN
Refetch the stack pointer. Used after a callback. See L<perlcall>.
=cut */
#undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
#define SP sp
#define MARK mark
/*
=for apidoc Amn;||TARG
C<TARG> is short for "target". It is an entry in the pad that an OPs
C<op_targ> refers to. It is scratchpad space, often used as a return
value for the OP, but some use it for other purposes.
=cut
*/
#define TARG targ
#define PUSHMARK(p) \
STMT_START { \
Stack_off_t * mark_stack_entry; \
if (UNLIKELY((mark_stack_entry = ++PL_markstack_ptr) \
== PL_markstack_max)) \
mark_stack_entry = markstack_grow(); \
*mark_stack_entry = (Stack_off_t)((p) - PL_stack_base); \
DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, \
"MARK push %p %" IVdf "\n", \
PL_markstack_ptr, (IV)*mark_stack_entry))); \
} STMT_END
#define TOPMARK Perl_TOPMARK(aTHX)
#define POPMARK Perl_POPMARK(aTHX)
#define INCMARK \
STMT_START { \
DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, \
"MARK inc %p %" IVdf "\n", \
(PL_markstack_ptr+1), (IV)*(PL_markstack_ptr+1)))); \
PL_markstack_ptr++; \
} STMT_END
#define dSP SV **sp = PL_stack_sp
#define djSP dSP
#define dMARK SV **mark = PL_stack_base + POPMARK
#define dORIGMARK const SSize_t origmark = (SSize_t)(mark - PL_stack_base)
#define ORIGMARK (PL_stack_base + origmark)
#define SPAGAIN sp = PL_stack_sp
#define MSPAGAIN STMT_START { sp = PL_stack_sp; mark = ORIGMARK; } STMT_END
#define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
#define dTARGETSTACKED SV * GETTARGETSTACKED
#define GETTARGET targ = PAD_SV(PL_op->op_targ)
/*
=for apidoc Amn;||dTARGET
Declare that this function uses C<TARG>, and initializes it
=cut
*/
#define dTARGET SV * GETTARGET
#define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
#define dATARGET SV * GETATARGET
#define dTARG SV *targ
#define NORMAL PL_op->op_next
#define DIE return Perl_die
/*
=for apidoc Amn;||PUTBACK
Closing bracket for XSUB arguments. This is usually handled by C<xsubpp>.
See C<L</PUSHMARK>> and L<perlcall> for other uses.
=for apidoc Amn|SV*|POPs
Pops an SV off the stack.
=for apidoc Amn|char*|POPp
Pops a string off the stack.
=for apidoc Amn|char*|POPpx
Pops a string off the stack. Identical to POPp. There are two names for
historical reasons.
=for apidoc Amn|char*|POPpbytex
Pops a string off the stack which must consist of bytes i.e. characters < 256.
=for apidoc Amn|NV|POPn
Pops a double off the stack.
=for apidoc Amn|IV|POPi
Pops an integer off the stack.
=for apidoc Amn|UV|POPu
Pops an unsigned integer off the stack.
=for apidoc Amn|long|POPl
Pops a long off the stack.
=for apidoc Amn|long|POPul
Pops an unsigned long off the stack.
=cut
*/
#define PUTBACK PL_stack_sp = sp
#define RETURN return (PUTBACK, NORMAL)
#define RETURNOP(o) return (PUTBACK, o)
#define RETURNX(x) return (x, PUTBACK, NORMAL)
#ifdef PERL_RC_STACK
# define POPs (assert(!rpp_stack_is_rc()), *sp--)
#else
# define POPs (*sp--)
#endif
#define POPp POPpx
#define POPpx (SvPVx_nolen(POPs))
#define POPpconstx (SvPVx_nolen_const(POPs))
#define POPpbytex (SvPVbytex_nolen(POPs))
#define POPn (SvNVx(POPs))
#define POPi ((IV)SvIVx(POPs))
#define POPu ((UV)SvUVx(POPs))
#define POPl ((long)SvIVx(POPs))
#define POPul ((unsigned long)SvIVx(POPs))
#define TOPs (*sp)
#define TOPm1s (*(sp-1))
#define TOPp1s (*(sp+1))
#define TOPp TOPpx
#define TOPpx (SvPV_nolen(TOPs))
#define TOPn (SvNV(TOPs))
#define TOPi ((IV)SvIV(TOPs))
#define TOPu ((UV)SvUV(TOPs))
#define TOPl ((long)SvIV(TOPs))
#define TOPul ((unsigned long)SvUV(TOPs))
/* Go to some pains in the rare event that we must extend the stack. */
/*
=for apidoc Am|void|EXTEND|SP|SSize_t nitems
Used to extend the argument stack for an XSUB's return values. Once
used, guarantees that there is room for at least C<nitems> to be pushed
onto the stack.
=for apidoc Am|void|PUSHs|SV* sv
Push an SV onto the stack. The stack must have room for this element.
Does not handle 'set' magic. Does not use C<TARG>. See also
C<L</PUSHmortal>>, C<L</XPUSHs>>, and C<L</XPUSHmortal>>.
=for apidoc Am|void|PUSHp|char* str|STRLEN len
Push a string onto the stack. The stack must have room for this element.
The C<len> indicates the length of the string. Handles 'set' magic. Uses
C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it. Do not
call multiple C<TARG>-oriented macros to return lists from XSUB's - see
C<L</mPUSHp>> instead. See also C<L</XPUSHp>> and C<L</mXPUSHp>>.
=for apidoc Am|void|PUSHpvs|"literal string"
A variation on C<PUSHp> that takes a literal string and calculates its size
directly.
=for apidoc Am|void|PUSHn|NV nv
Push a double onto the stack. The stack must have room for this element.
Handles 'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it. Do not call multiple C<TARG>-oriented macros to
return lists from XSUB's - see C<L</mPUSHn>> instead. See also C<L</XPUSHn>>
and C<L</mXPUSHn>>.
=for apidoc Am|void|PUSHi|IV iv
Push an integer onto the stack. The stack must have room for this element.
Handles 'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it. Do not call multiple C<TARG>-oriented macros to
return lists from XSUB's - see C<L</mPUSHi>> instead. See also C<L</XPUSHi>>
and C<L</mXPUSHi>>.
=for apidoc Am|void|PUSHu|UV uv
Push an unsigned integer onto the stack. The stack must have room for this
element. Handles 'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG>
should be called to declare it. Do not call multiple C<TARG>-oriented
macros to return lists from XSUB's - see C<L</mPUSHu>> instead. See also
C<L</XPUSHu>> and C<L</mXPUSHu>>.
=for apidoc Am|void|XPUSHs|SV* sv
Push an SV onto the stack, extending the stack if necessary. Does not
handle 'set' magic. Does not use C<TARG>. See also C<L</XPUSHmortal>>,
C<PUSHs> and C<PUSHmortal>.
=for apidoc Am|void|XPUSHp|char* str|STRLEN len
Push a string onto the stack, extending the stack if necessary. The C<len>
indicates the length of the string. Handles 'set' magic. Uses C<TARG>, so
C<dTARGET> or C<dXSTARG> should be called to declare it. Do not call
multiple C<TARG>-oriented macros to return lists from XSUB's - see
C<L</mXPUSHp>> instead. See also C<L</PUSHp>> and C<L</mPUSHp>>.
=for apidoc Am|void|XPUSHpvs|"literal string"
A variation on C<XPUSHp> that takes a literal string and calculates its size
directly.
=for apidoc Am|void|XPUSHn|NV nv
Push a double onto the stack, extending the stack if necessary. Handles
'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
declare it. Do not call multiple C<TARG>-oriented macros to return lists
from XSUB's - see C<L</mXPUSHn>> instead. See also C<L</PUSHn>> and
C<L</mPUSHn>>.
=for apidoc Am|void|XPUSHi|IV iv
Push an integer onto the stack, extending the stack if necessary. Handles
'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
declare it. Do not call multiple C<TARG>-oriented macros to return lists
from XSUB's - see C<L</mXPUSHi>> instead. See also C<L</PUSHi>> and
C<L</mPUSHi>>.
=for apidoc Am|void|XPUSHu|UV uv
Push an unsigned integer onto the stack, extending the stack if necessary.
Handles 'set' magic. Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
called to declare it. Do not call multiple C<TARG>-oriented macros to
return lists from XSUB's - see C<L</mXPUSHu>> instead. See also C<L</PUSHu>> and
C<L</mPUSHu>>.
=for apidoc Am|void|mPUSHs|SV* sv
Push an SV onto the stack and mortalizes the SV. The stack must have room
for this element. Does not use C<TARG>. See also C<L</PUSHs>> and
C<L</mXPUSHs>>.
=for apidoc Amn|void|PUSHmortal
Push a new mortal SV onto the stack. The stack must have room for this
element. Does not use C<TARG>. See also C<L</PUSHs>>, C<L</XPUSHmortal>> and
C<L</XPUSHs>>.
=for apidoc Am|void|mPUSHp|char* str|STRLEN len
Push a string onto the stack. The stack must have room for this element.
The C<len> indicates the length of the string. Does not use C<TARG>.
See also C<L</PUSHp>>, C<L</mXPUSHp>> and C<L</XPUSHp>>.
=for apidoc Am|void|mPUSHpvs|"literal string"
A variation on C<mPUSHp> that takes a literal string and calculates its size
directly.
=for apidoc Am|void|mPUSHn|NV nv
Push a double onto the stack. The stack must have room for this element.
Does not use C<TARG>. See also C<L</PUSHn>>, C<L</mXPUSHn>> and C<L</XPUSHn>>.
=for apidoc Am|void|mPUSHi|IV iv
Push an integer onto the stack. The stack must have room for this element.
Does not use C<TARG>. See also C<L</PUSHi>>, C<L</mXPUSHi>> and C<L</XPUSHi>>.
=for apidoc Am|void|mPUSHu|UV uv
Push an unsigned integer onto the stack. The stack must have room for this
element. Does not use C<TARG>. See also C<L</PUSHu>>, C<L</mXPUSHu>> and
C<L</XPUSHu>>.
=for apidoc Am|void|mXPUSHs|SV* sv
Push an SV onto the stack, extending the stack if necessary and mortalizes
the SV. Does not use C<TARG>. See also C<L</XPUSHs>> and C<L</mPUSHs>>.
=for apidoc Amn|void|XPUSHmortal
Push a new mortal SV onto the stack, extending the stack if necessary.
Does not use C<TARG>. See also C<L</XPUSHs>>, C<L</PUSHmortal>> and
C<L</PUSHs>>.
=for apidoc Am|void|mXPUSHp|char* str|STRLEN len
Push a string onto the stack, extending the stack if necessary. The C<len>
indicates the length of the string. Does not use C<TARG>. See also
C<L</XPUSHp>>, C<mPUSHp> and C<PUSHp>.
=for apidoc Am|void|mXPUSHpvs|"literal string"
A variation on C<mXPUSHp> that takes a literal string and calculates its size
directly.
=for apidoc Am|void|mXPUSHn|NV nv
Push a double onto the stack, extending the stack if necessary.
Does not use C<TARG>. See also C<L</XPUSHn>>, C<L</mPUSHn>> and C<L</PUSHn>>.
=for apidoc Am|void|mXPUSHi|IV iv
Push an integer onto the stack, extending the stack if necessary.
Does not use C<TARG>. See also C<L</XPUSHi>>, C<L</mPUSHi>> and C<L</PUSHi>>.
=for apidoc Am|void|mXPUSHu|UV uv
Push an unsigned integer onto the stack, extending the stack if necessary.
Does not use C<TARG>. See also C<L</XPUSHu>>, C<L</mPUSHu>> and C<L</PUSHu>>.
=cut
*/
/* EXTEND_HWM_SET: note the high-water-mark to which the stack has been
* requested to be extended (which is likely to be less than PL_stack_max)
*/
#ifdef PERL_USE_HWM
# define EXTEND_HWM_SET(p, n) \
STMT_START { \
SSize_t extend_hwm_set_ix = (p) - PL_stack_base + (n); \
if (extend_hwm_set_ix > PL_curstackinfo->si_stack_hwm) \
PL_curstackinfo->si_stack_hwm = extend_hwm_set_ix; \
} STMT_END
#else
# define EXTEND_HWM_SET(p, n) NOOP
#endif
/* _EXTEND_SAFE_N(n): private helper macro for EXTEND().
* Tests whether the value of n would be truncated when implicitly cast to
* SSize_t as an arg to stack_grow(). If so, sets it to -1 instead to
* trigger a panic. It will be constant folded on platforms where this
* can't happen.
*/
#define _EXTEND_SAFE_N(n) \
(sizeof(n) > sizeof(SSize_t) && ((SSize_t)(n) != (n)) ? -1 : (n))
#ifdef STRESS_REALLOC
# define EXTEND_SKIP(p, n) EXTEND_HWM_SET(p, n)
# define EXTEND(p,n) STMT_START { \
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
PERL_UNUSED_VAR(sp); \
} STMT_END
/* Same thing, but update mark register too. */
# define MEXTEND(p,n) STMT_START { \
const SSize_t markoff = mark - PL_stack_base; \
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
mark = PL_stack_base + markoff; \
PERL_UNUSED_VAR(sp); \
} STMT_END
#else
/* _EXTEND_NEEDS_GROW(p,n): private helper macro for EXTEND().
* Tests to see whether n is too big and we need to grow the stack. Be
* very careful if modifying this. There are many ways to get things wrong
* (wrapping, truncating etc) that could cause a false negative and cause
* the call to stack_grow() to be skipped. On the other hand, false
* positives are safe.
* Bear in mind that sizeof(p) may be less than, equal to, or greater
* than sizeof(n), and while n is documented to be signed, someone might
* pass an unsigned value or expression. In general don't use casts to
* avoid warnings; instead expect the caller to fix their code.
* It is legal for p to be greater than PL_stack_max.
* If the allocated stack is already very large but current usage is
* small, then PL_stack_max - p might wrap round to a negative value, but
* this just gives a safe false positive
*/
# define _EXTEND_NEEDS_GROW(p,n) ((n) < 0 || PL_stack_max - (p) < (n))
/* EXTEND_SKIP(): used for where you would normally call EXTEND(), but
* you know for sure that a previous op will have already extended the
* stack sufficiently. For example pp_enteriter ensures that there
* is always at least 1 free slot, so pp_iter can return &PL_sv_yes/no
* without checking each time. Calling EXTEND_SKIP() defeats the HWM
* debugging mechanism which would otherwise whine
*/
# define EXTEND_SKIP(p, n) STMT_START { \
EXTEND_HWM_SET(p, n); \
assert(!_EXTEND_NEEDS_GROW(p,n)); \
} STMT_END
# define EXTEND(p,n) STMT_START { \
EXTEND_HWM_SET(p, n); \
if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
PERL_UNUSED_VAR(sp); \
} \
} STMT_END
/* Same thing, but update mark register too. */
# define MEXTEND(p,n) STMT_START { \
EXTEND_HWM_SET(p, n); \
if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \
const SSize_t markoff = mark - PL_stack_base;\
sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \
mark = PL_stack_base + markoff; \
PERL_UNUSED_VAR(sp); \
} \
} STMT_END
#endif
/* set TARG to the IV value i. If do_taint is false,
* assume that PL_tainted can never be true */
#define TARGi(i, do_taint) \
STMT_START { \
IV TARGi_iv = i; \
if (LIKELY( \
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
& (do_taint ? !TAINT_get : 1))) \
{ \
/* Cheap SvIOK_only(). \
* Assert that flags which SvIOK_only() would test or \
* clear can't be set, because we're SVt_IV */ \
assert(!(SvFLAGS(TARG) & \
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK))))); \
SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK); \
/* SvIV_set() where sv_any points to head */ \
TARG->sv_u.svu_iv = TARGi_iv; \
} \
else \
sv_setiv_mg(targ, TARGi_iv); \
} STMT_END
/* set TARG to the UV value u. If do_taint is false,
* assume that PL_tainted can never be true */
#define TARGu(u, do_taint) \
STMT_START { \
UV TARGu_uv = u; \
if (LIKELY( \
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST|SVf_IVisUV)) == SVt_IV) \
& (do_taint ? !TAINT_get : 1) \
& (TARGu_uv <= (UV)IV_MAX))) \
{ \
/* Cheap SvIOK_only(). \
* Assert that flags which SvIOK_only() would test or \
* clear can't be set, because we're SVt_IV */ \
assert(!(SvFLAGS(TARG) & \
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_IOK|SVp_IOK))))); \
SvFLAGS(TARG) |= (SVf_IOK|SVp_IOK); \
/* SvIV_set() where sv_any points to head */ \
TARG->sv_u.svu_iv = TARGu_uv; \
} \
else \
sv_setuv_mg(targ, TARGu_uv); \
} STMT_END
/* set TARG to the NV value n. If do_taint is false,
* assume that PL_tainted can never be true */
#define TARGn(n, do_taint) \
STMT_START { \
NV TARGn_nv = n; \
if (LIKELY( \
((SvFLAGS(TARG) & (SVTYPEMASK|SVf_THINKFIRST)) == SVt_NV) \
& (do_taint ? !TAINT_get : 1))) \
{ \
/* Cheap SvNOK_only(). \
* Assert that flags which SvNOK_only() would test or \
* clear can't be set, because we're SVt_NV */ \
assert(!(SvFLAGS(TARG) & \
(SVf_OOK|SVf_UTF8|(SVf_OK & ~(SVf_NOK|SVp_NOK))))); \
SvFLAGS(TARG) |= (SVf_NOK|SVp_NOK); \
SvNV_set(TARG, TARGn_nv); \
} \
else \
sv_setnv_mg(targ, TARGn_nv); \
} STMT_END
#ifdef PERL_RC_STACK
# define PUSHs(s) (assert(!rpp_stack_is_rc()), *++sp = (s))
#else
# define PUSHs(s) (*++sp = (s))
#endif
#define PUSHTARG STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
#define PUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
#define PUSHpvs(s) PUSHp("" s "", sizeof(s)-1)
#define PUSHn(n) STMT_START { TARGn(n,1); PUSHs(TARG); } STMT_END
#define PUSHi(i) STMT_START { TARGi(i,1); PUSHs(TARG); } STMT_END
#define PUSHu(u) STMT_START { TARGu(u,1); PUSHs(TARG); } STMT_END
#define XPUSHs(s) STMT_START { EXTEND(sp,1); PUSHs(s); } STMT_END
#define XPUSHTARG STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
#define XPUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
#define XPUSHpvs(s) XPUSHp("" s "", sizeof(s)-1)
#define XPUSHn(n) STMT_START { TARGn(n,1); XPUSHs(TARG); } STMT_END
#define XPUSHi(i) STMT_START { TARGi(i,1); XPUSHs(TARG); } STMT_END
#define XPUSHu(u) STMT_START { TARGu(u,1); XPUSHs(TARG); } STMT_END
#define XPUSHundef STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END
#define mPUSHs(s) PUSHs(sv_2mortal(s))
#define PUSHmortal PUSHs(sv_newmortal())
#define mPUSHp(p,l) PUSHs(newSVpvn_flags((p), (l), SVs_TEMP))
#define mPUSHpvs(s) mPUSHp("" s "", sizeof(s)-1)
#define mPUSHn(n) sv_setnv(PUSHmortal, (NV)(n))
#define mPUSHi(i) sv_setiv(PUSHmortal, (IV)(i))
#define mPUSHu(u) sv_setuv(PUSHmortal, (UV)(u))
#define mXPUSHs(s) XPUSHs(sv_2mortal(s))
#define XPUSHmortal XPUSHs(sv_newmortal())
#define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); mPUSHp((p), (l)); } STMT_END
#define mXPUSHpvs(s) mXPUSHp("" s "", sizeof(s)-1)
#define mXPUSHn(n) STMT_START { EXTEND(sp,1); mPUSHn(n); } STMT_END
#define mXPUSHi(i) STMT_START { EXTEND(sp,1); mPUSHi(i); } STMT_END
#define mXPUSHu(u) STMT_START { EXTEND(sp,1); mPUSHu(u); } STMT_END
#define SETs(s) (*sp = s)
#define SETTARG STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
#define SETp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
#define SETn(n) STMT_START { TARGn(n,1); SETs(TARG); } STMT_END
#define SETi(i) STMT_START { TARGi(i,1); SETs(TARG); } STMT_END
#define SETu(u) STMT_START { TARGu(u,1); SETs(TARG); } STMT_END
#define dTOPss SV *sv = TOPs
#define dPOPss SV *sv = POPs
#define dTOPnv NV value = TOPn
#define dPOPnv NV value = POPn
#define dPOPnv_nomg NV value = (sp--, SvNV_nomg(TOPp1s))
#define dTOPiv IV value = TOPi
#define dPOPiv IV value = POPi
#define dTOPuv UV value = TOPu
#define dPOPuv UV value = POPu
#define dPOPXssrl(X) SV *right = POPs; SV *left = CAT2(X,s)
#define dPOPXnnrl(X) NV right = POPn; NV left = CAT2(X,n)
#define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i)
#define USE_LEFT(sv) \
(SvOK(sv) || !(PL_op->op_flags & OPf_STACKED))
#define dPOPXiirl_ul_nomg(X) \
IV right = (sp--, SvIV_nomg(TOPp1s)); \
SV *leftsv = CAT2(X,s); \
IV left = USE_LEFT(leftsv) ? SvIV_nomg(leftsv) : 0
#define dPOPPOPssrl dPOPXssrl(POP)
#define dPOPPOPnnrl dPOPXnnrl(POP)
#define dPOPPOPiirl dPOPXiirl(POP)
#define dPOPTOPssrl dPOPXssrl(TOP)
#define dPOPTOPnnrl dPOPXnnrl(TOP)
#define dPOPTOPnnrl_nomg \
NV right = SvNV_nomg(TOPs); NV left = (sp--, SvNV_nomg(TOPs))
#define dPOPTOPiirl dPOPXiirl(TOP)
#define dPOPTOPiirl_ul_nomg dPOPXiirl_ul_nomg(TOP)
#define dPOPTOPiirl_nomg \
IV right = SvIV_nomg(TOPs); IV left = (sp--, SvIV_nomg(TOPs))
#define RETPUSHYES RETURNX(PUSHs(&PL_sv_yes))
#define RETPUSHNO RETURNX(PUSHs(&PL_sv_no))
#define RETPUSHUNDEF RETURNX(PUSHs(&PL_sv_undef))
#define RETSETYES RETURNX(SETs(&PL_sv_yes))
#define RETSETNO RETURNX(SETs(&PL_sv_no))
#define RETSETUNDEF RETURNX(SETs(&PL_sv_undef))
#define RETSETTARG STMT_START { SETTARG; RETURN; } STMT_END
#define ARGTARG PL_op->op_targ
#define MAXARG (PL_op->op_private & OPpARG4_MASK)
/* for backcompat - use switch_argstack() instead */
#define SWITCHSTACK(f,t) \
STMT_START { \
PL_curstack = f; \
PL_stack_sp = sp; \
switch_argstack(t); \
sp = PL_stack_sp; \
} STMT_END
#define EXTEND_MORTAL(n) \
STMT_START { \
SSize_t eMiX = PL_tmps_ix + (n); \
if (UNLIKELY(eMiX >= PL_tmps_max)) \
(void)Perl_tmps_grow_p(aTHX_ eMiX); \
} STMT_END
#define AMGf_noright 1
#define AMGf_noleft 2
#define AMGf_assign 4 /* op supports mutator variant, e.g. $x += 1 */
#define AMGf_unary 8
#define AMGf_numeric 0x10 /* for Perl_try_amagic_bin */
#define AMGf_want_list 0x40
#define AMGf_numarg 0x80
/* do SvGETMAGIC on the stack args before checking for overload */
#define tryAMAGICun_MG(method, flags) STMT_START { \
if ( UNLIKELY((SvFLAGS(TOPs) & (SVf_ROK|SVs_GMG))) \
&& Perl_try_amagic_un(aTHX_ method, flags)) \
return NORMAL; \
} STMT_END
#define tryAMAGICbin_MG(method, flags) STMT_START { \
if ( UNLIKELY(((SvFLAGS(TOPm1s)|SvFLAGS(TOPs)) & (SVf_ROK|SVs_GMG))) \
&& Perl_try_amagic_bin(aTHX_ method, flags)) \
return NORMAL; \
} STMT_END
#define AMG_CALLunary(sv,meth) \
amagic_call(sv,&PL_sv_undef, meth, AMGf_noright | AMGf_unary)
/* No longer used in core. Use AMG_CALLunary instead */
#define AMG_CALLun(sv,meth) AMG_CALLunary(sv, CAT2(meth,_amg))
/* This is no longer used anywhere in the core. You might wish to consider
calling amagic_deref_call() directly, as it has a cleaner interface. */
#define tryAMAGICunDEREF(meth) \
STMT_START { \
sv = amagic_deref_call(*sp, CAT2(meth,_amg)); \
SPAGAIN; \
} STMT_END
/* 2019: no longer used in core */
#define opASSIGN (PL_op->op_flags & OPf_STACKED)
/*
=for apidoc mnU||LVRET
True if this op will be the return value of an lvalue subroutine
=cut */
#define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub())
#define SvCANEXISTDELETE(sv) \
(!SvRMAGICAL(sv) \
|| !(mg = mg_find((const SV *) sv, PERL_MAGIC_tied)) \
|| ( (stash = SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(sv), mg)))) \
&& gv_fetchmethod_autoload(stash, "EXISTS", TRUE) \
&& gv_fetchmethod_autoload(stash, "DELETE", TRUE) \
) \
)
#ifdef PERL_CORE
/* These are just for Perl_tied_method(), which is not part of the public API.
Use 0x04 rather than the next available bit, to help the compiler if the
architecture can generate more efficient instructions. */
# define TIED_METHOD_MORTALIZE_NOT_NEEDED 0x04
# define TIED_METHOD_ARGUMENTS_ON_STACK 0x08
# define TIED_METHOD_SAY 0x10
/* Used in various places that need to dereference a glob or globref */
# define MAYBE_DEREF_GV_flags(sv,phlags) \
( \
(void)(((phlags) & SV_GMAGIC) && (SvGETMAGIC(sv),0)), \
isGV_with_GP(sv) \
? (GV *)(sv) \
: SvROK(sv) && SvTYPE(SvRV(sv)) <= SVt_PVLV && \
(SvGETMAGIC(SvRV(sv)), isGV_with_GP(SvRV(sv))) \
? (GV *)SvRV(sv) \
: NULL \
)
# define MAYBE_DEREF_GV(sv) MAYBE_DEREF_GV_flags(sv,SV_GMAGIC)
# define MAYBE_DEREF_GV_nomg(sv) MAYBE_DEREF_GV_flags(sv,0)
# define FIND_RUNCV_padid_eq 1
# define FIND_RUNCV_level_eq 2
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

325
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/pp_proto.h Normal file
View file

@ -0,0 +1,325 @@
/* -*- mode: C; buffer-read-only: t -*-
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
This file is built by opcode.pl from its data.
Any changes made here will be lost!
*/
PERL_CALLCONV PP(do_kv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aassign) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_abs) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_accept) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_add) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aeach) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aelem) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aelemfast) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aelemfastlex_store) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_akeys) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_alarm) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_and) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_anoncode) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_anonconst) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_anonhash) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_anonlist) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_argcheck) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_argdefelem) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_argelem) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_aslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_atan2) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_av2arylen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_avhvswitch) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_backtick) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_bind) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_binmode) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_bit_and) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_bit_or) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_bless) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_blessed) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_break) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_caller) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_catch) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ceil) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_chdir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_chop) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_chown) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_chr) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_chroot) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_classname) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_clonecv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_close) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_closedir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_cmpchain_and) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_cmpchain_dup) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_complement) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_concat) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_cond_expr) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_const) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_continue) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_coreargs) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_crypt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_dbmopen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_dbstate) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_defined) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_delete) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_die) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_divide) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_each) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ehostent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_emptyavhv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_enter) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_entereval) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_entergiven) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_enteriter) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_enterloop) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_entersub) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_entertry) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_entertrycatch) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_enterwhen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_enterwrite) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_eof) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_eq) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_exec) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_exists) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_exit) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_fc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_fileno) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_flip) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_flock) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_floor) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_flop) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_fork) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_formline) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ftis) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ftlink) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ftrowned) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ftrread) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_fttext) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_fttty) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ge) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gelem) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getlogin) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getpeername) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getpgrp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getppid) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_getpriority) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ggrent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ghostent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_glob) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gmtime) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gnetent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_goto) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gprotoent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gpwent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_grepstart) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_grepwhile) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gservent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_gvsv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_helem) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_helemexistsor) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_hintseval) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_hslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_add) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_divide) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_eq) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_ge) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_gt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_le) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_lt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_modulo) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_multiply) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_ncmp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_ne) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_negate) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_i_subtract) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_index) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_initfield) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_int) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_introcv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ioctl) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_is_bool) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_is_tainted) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_is_weak) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_isa) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_iter) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_join) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_kvaslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_kvhslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_last) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_le) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leave) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leaveeval) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavegiven) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leaveloop) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavesub) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavesublv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavetry) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavetrycatch) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavewhen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_leavewrite) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_left_shift) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_length) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_link) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_list) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_listen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lock) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lvavref) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lvref) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_lvrefslice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_mapwhile) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_match) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_method) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_method_named) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_method_redir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_method_redir_super) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_method_super) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_methstart) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_mkdir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_modulo) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_multiconcat) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_multideref) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_multiply) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_nbit_and) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_nbit_or) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ncmp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ncomplement) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ne) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_negate) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_next) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_nextstate) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_not) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_null) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_oct) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_once) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_open) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_open_dir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_or) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ord) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pack) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padav) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padcv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padhv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padrange) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padsv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_padsv_store) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pipe_op) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_poptry) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pos) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_postdec) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_postinc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pow) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_predec) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_preinc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_print) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_prototype) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_prtf) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_push) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pushdefer) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_pushmark) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_qr) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_quotemeta) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rand) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_range) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rcatline) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_readdir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_readline) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_readlink) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_redo) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ref) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_refaddr) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_refassign) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_refgen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_reftype) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_regcomp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_regcreset) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rename) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_repeat) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_require) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_reset) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_return) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_reverse) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rewinddir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_right_shift) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rmdir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_runcv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rv2av) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rv2cv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rv2gv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_rv2sv) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sassign) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sbit_and) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sbit_or) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_schop) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_scmp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_scomplement) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_seekdir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_select) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_semctl) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_semget) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_seq) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_setpgrp) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_setpriority) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_shift) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_shmwrite) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_shostent) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_shutdown) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sin) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sle) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sleep) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_smartmatch) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sne) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_socket) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sockpair) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sort) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_splice) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_split) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sprintf) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_srand) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_srefgen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sselect) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ssockopt) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_stat) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_stringify) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_stub) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_study) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_subst) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_substcont) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_substr) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_subtract) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_syscall) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sysopen) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sysread) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_sysseek) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_system) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_syswrite) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_tell) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_telldir) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_tie) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_tied) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_time) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_tms) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_trans) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_truncate) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_uc) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_ucfirst) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_umask) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_undef) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_unpack) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_unshift) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_unstack) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_untie) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_unweaken) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_vec) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_wait) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_waitpid) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_wantarray) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_warn) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_weaken) __attribute__visibility__("hidden");
PERL_CALLCONV PP(pp_xor) __attribute__visibility__("hidden");
PERL_CALLCONV PP(unimplemented_op) __attribute__visibility__("hidden");
/* ex: set ro ft=c: */

10870
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/proto.h Normal file
View file

File diff suppressed because it is too large Load diff

1702
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reentr.h Normal file
View file

File diff suppressed because it is too large Load diff

3858
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcharclass.h Normal file
View file

File diff suppressed because it is too large Load diff

1575
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp.h Normal file
View file

File diff suppressed because it is too large Load diff

1260
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regcomp_internal.h Normal file
View file

File diff suppressed because it is too large Load diff

1098
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regexp.h Normal file
View file

File diff suppressed because it is too large Load diff

64
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/reginline.h Normal file
View file

@ -0,0 +1,64 @@
#ifndef PERL_REGINLINE_H
/*
- regnext - dig the "next" pointer out of a node
*/
PERL_STATIC_INLINE
regnode *
Perl_regnext(pTHX_ const regnode *p)
{
I32 offset;
if (!p)
return(NULL);
if (OP(p) > REGNODE_MAX) { /* regnode.type is unsigned */
Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d",
(int)OP(p), (int)REGNODE_MAX);
}
offset = (REGNODE_OFF_BY_ARG(OP(p)) ? ARG1u(p) : NEXT_OFF(p));
if (offset == 0)
return(NULL);
return(regnode *)(p+offset);
}
/*
- regnode_after - find the node physically following p in memory,
taking into account the size of p as determined by OP(p), our
sizing data, and possibly the STR_SZ() macro.
*/
PERL_STATIC_INLINE
regnode *
Perl_regnode_after(pTHX_ const regnode *p, const bool varies)
{
assert(p);
const U8 op = OP(p);
assert(op < REGNODE_MAX);
const regnode *ret = p + NODE_STEP_REGNODE + REGNODE_ARG_LEN(op);
if (varies || REGNODE_ARG_LEN_VARIES(op))
ret += STR_SZ(STR_LEN(p));
return (regnode *)ret;
}
/* validate that the passed in node and extra length would match that
* returned by regnode_after() */
PERL_STATIC_INLINE
bool
Perl_check_regnode_after(pTHX_ const regnode *p, const STRLEN extra)
{
const regnode *nextoper = regnode_after((regnode *)p,FALSE);
const regnode *other = REGNODE_AFTER_PLUS(p, extra);
if (nextoper != other) {
return FALSE;
}
return TRUE;
}
#define PERL_REGINLINE_H
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

2980
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/regnodes.h Normal file
View file

File diff suppressed because it is too large Load diff

1736
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sbox32_hash.h Normal file
View file

File diff suppressed because it is too large Load diff

322
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope.h Normal file
View file

@ -0,0 +1,322 @@
/* scope.h
*
* Copyright (C) 1993, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
* 2002, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#include "scope_types.h"
#define SAVEf_SETMAGIC 1
#define SAVEf_KEEPOLDELEM 2
#define SAVE_TIGHT_SHIFT 6
#define SAVE_MASK 0x3F
#define save_aelem(av,idx,sptr) save_aelem_flags(av,idx,sptr,SAVEf_SETMAGIC)
#define save_helem(hv,key,sptr) save_helem_flags(hv,key,sptr,SAVEf_SETMAGIC)
#ifndef SCOPE_SAVES_SIGNAL_MASK
#define SCOPE_SAVES_SIGNAL_MASK 0
#endif
/* the maximum number of entries that might be pushed using the SS_ADD*
* macros */
#define SS_MAXPUSH 4
#define SSGROW(need) if (UNLIKELY(PL_savestack_ix + (I32)(need) > PL_savestack_max)) savestack_grow_cnt(need)
#define SSCHECK(need) SSGROW(need) /* legacy */
#define SSPUSHINT(i) (PL_savestack[PL_savestack_ix++].any_i32 = (I32)(i))
#define SSPUSHLONG(i) (PL_savestack[PL_savestack_ix++].any_long = (long)(i))
#define SSPUSHBOOL(p) (PL_savestack[PL_savestack_ix++].any_bool = (p))
#define SSPUSHIV(i) (PL_savestack[PL_savestack_ix++].any_iv = (IV)(i))
#define SSPUSHUV(u) (PL_savestack[PL_savestack_ix++].any_uv = (UV)(u))
#define SSPUSHPTR(p) (PL_savestack[PL_savestack_ix++].any_ptr = (void*)(p))
#define SSPUSHDPTR(p) (PL_savestack[PL_savestack_ix++].any_dptr = (p))
#define SSPUSHDXPTR(p) (PL_savestack[PL_savestack_ix++].any_dxptr = (p))
/* SS_ADD*: newer, faster versions of the above. Don't mix the two sets of
* macros. These are fast because they save reduce accesses to the PL_
* vars and move the size check to the end. Doing the check last means
* that values in registers will have been pushed and no longer needed, so
* don't need saving around the call to grow. Also, tail-call elimination
* of the grow() can be done. These changes reduce the code of something
* like save_pushptrptr() to half its former size.
* Of course, doing the size check *after* pushing means we must always
* ensure there are SS_MAXPUSH free slots on the savestack. This is ensured by
* savestack_grow_cnt always allocating SS_MAXPUSH slots
* more than asked for, or that it sets PL_savestack_max to
*
* These are for internal core use only and are subject to change */
#define dSS_ADD \
I32 ix = PL_savestack_ix; \
ANY *ssp = &PL_savestack[ix]
#define SS_ADD_END(need) \
assert((need) <= SS_MAXPUSH); \
ix += (need); \
PL_savestack_ix = ix; \
assert(ix <= PL_savestack_max + SS_MAXPUSH); \
if (UNLIKELY(ix > PL_savestack_max)) savestack_grow_cnt(ix - PL_savestack_max); \
assert(PL_savestack_ix <= PL_savestack_max);
#define SS_ADD_INT(i) ((ssp++)->any_i32 = (I32)(i))
#define SS_ADD_LONG(i) ((ssp++)->any_long = (long)(i))
#define SS_ADD_BOOL(p) ((ssp++)->any_bool = (p))
#define SS_ADD_IV(i) ((ssp++)->any_iv = (IV)(i))
#define SS_ADD_UV(u) ((ssp++)->any_uv = (UV)(u))
#define SS_ADD_PTR(p) ((ssp++)->any_ptr = (void*)(p))
#define SS_ADD_DPTR(p) ((ssp++)->any_dptr = (p))
#define SS_ADD_DXPTR(p) ((ssp++)->any_dxptr = (p))
#define SSPOPINT (PL_savestack[--PL_savestack_ix].any_i32)
#define SSPOPLONG (PL_savestack[--PL_savestack_ix].any_long)
#define SSPOPBOOL (PL_savestack[--PL_savestack_ix].any_bool)
#define SSPOPIV (PL_savestack[--PL_savestack_ix].any_iv)
#define SSPOPUV (PL_savestack[--PL_savestack_ix].any_uv)
#define SSPOPPTR (PL_savestack[--PL_savestack_ix].any_ptr)
#define SSPOPDPTR (PL_savestack[--PL_savestack_ix].any_dptr)
#define SSPOPDXPTR (PL_savestack[--PL_savestack_ix].any_dxptr)
/*
=for apidoc_section $callback
=for apidoc Amn;||SAVETMPS
Opening bracket for temporaries on a callback. See C<L</FREETMPS>> and
L<perlcall>.
=for apidoc Amn;||FREETMPS
Closing bracket for temporaries on a callback. See C<L</SAVETMPS>> and
L<perlcall>.
=for apidoc Amn;||ENTER
Opening bracket on a callback. See C<L</LEAVE>> and L<perlcall>.
=for apidoc Amn;||LEAVE
Closing bracket on a callback. See C<L</ENTER>> and L<perlcall>.
=for apidoc Am;||ENTER_with_name|"name"
Same as C<L</ENTER>>, but when debugging is enabled it also associates the
given literal string with the new scope.
=for apidoc Am;||LEAVE_with_name|"name"
Same as C<L</LEAVE>>, but when debugging is enabled it first checks that the
scope has the given name. C<name> must be a literal string.
=cut
*/
#define SAVETMPS Perl_savetmps(aTHX)
#define FREETMPS if (PL_tmps_ix > PL_tmps_floor) free_tmps()
#ifdef DEBUGGING
#define ENTER \
STMT_START { \
push_scope(); \
DEBUG_SCOPE("ENTER") \
} STMT_END
#define LEAVE \
STMT_START { \
DEBUG_SCOPE("LEAVE") \
pop_scope(); \
} STMT_END
#define ENTER_with_name(name) \
STMT_START { \
push_scope(); \
if (PL_scopestack_name) \
PL_scopestack_name[PL_scopestack_ix-1] = ASSERT_IS_LITERAL(name);\
DEBUG_SCOPE("ENTER \"" name "\"") \
} STMT_END
#define LEAVE_with_name(name) \
STMT_START { \
DEBUG_SCOPE("LEAVE \"" name "\"") \
if (PL_scopestack_name) { \
CLANG_DIAG_IGNORE_STMT(-Wstring-compare); \
assert(((char*)PL_scopestack_name[PL_scopestack_ix-1] \
== (char*)ASSERT_IS_LITERAL(name)) \
|| strEQ(PL_scopestack_name[PL_scopestack_ix-1], name)); \
CLANG_DIAG_RESTORE_STMT; \
} \
pop_scope(); \
} STMT_END
#else
#define ENTER push_scope()
#define LEAVE pop_scope()
#define ENTER_with_name(name) ENTER
#define LEAVE_with_name(name) LEAVE
#endif
#define LEAVE_SCOPE(old) STMT_START { \
if (PL_savestack_ix > old) leave_scope(old); \
} STMT_END
#define SAVEI8(i) save_I8((I8*)&(i))
#define SAVEI16(i) save_I16((I16*)&(i))
#define SAVEI32(i) save_I32((I32*)&(i))
#define SAVEINT(i) save_int((int*)&(i))
#define SAVEIV(i) save_iv((IV*)&(i))
#define SAVELONG(l) save_long((long*)&(l))
#define SAVESTRLEN(l) Perl_save_strlen(aTHX_ (STRLEN*)&(l))
#define SAVEBOOL(b) save_bool(&(b))
#define SAVESPTR(s) save_sptr((SV**)&(s))
#define SAVEPPTR(s) save_pptr((char**)&(s))
#define SAVEVPTR(s) save_vptr((void*)&(s))
#define SAVEPADSVANDMORTALIZE(s) save_padsv_and_mortalize(s)
#define SAVEFREESV(s) save_freesv(MUTABLE_SV(s))
#define SAVEFREEPADNAME(s) save_pushptr((void *)(s), SAVEt_FREEPADNAME)
#define SAVEMORTALIZESV(s) save_mortalizesv(MUTABLE_SV(s))
#define SAVEFREEOP(o) save_freeop((OP*)(o))
#define SAVEFREEPV(p) save_freepv((char*)(p))
#define SAVECLEARSV(sv) save_clearsv((SV**)&(sv))
#define SAVEGENERICSV(s) save_generic_svref((SV**)&(s))
#define SAVEGENERICPV(s) save_generic_pvref((char**)&(s))
#define SAVERCPV(s) save_rcpv((char**)&(s))
#define SAVEFREERCPV(s) save_freercpv(s)
#define SAVESHAREDPV(s) save_shared_pvref((char**)&(s))
#define SAVESETSVFLAGS(sv,mask,val) save_set_svflags(sv,mask,val)
#define SAVEFREECOPHH(h) save_pushptr((void *)(h), SAVEt_FREECOPHH)
#define SAVEDELETE(h,k,l) \
save_delete(MUTABLE_HV(h), (char*)(k), (I32)(l))
#define SAVEHDELETE(h,s) \
save_hdelete(MUTABLE_HV(h), (s))
#define SAVEADELETE(a,k) \
save_adelete(MUTABLE_AV(a), (SSize_t)(k))
#define SAVEDESTRUCTOR(f,p) \
save_destructor((DESTRUCTORFUNC_NOCONTEXT_t)(f), (void*)(p))
#define SAVEDESTRUCTOR_X(f,p) \
save_destructor_x((DESTRUCTORFUNC_t)(f), (void*)(p))
#define MORTALSVFUNC_X(f,sv) \
mortal_svfunc_x((SVFUNC_t)(f), sv)
#define MORTALDESTRUCTOR_SV(coderef,args) \
mortal_destructor_sv(coderef,args)
#define SAVESTACK_POS() \
STMT_START { \
dSS_ADD; \
SS_ADD_INT(PL_stack_sp - PL_stack_base); \
SS_ADD_UV(SAVEt_STACK_POS); \
SS_ADD_END(2); \
} STMT_END
#define SAVEOP() save_op()
#define SAVEHINTS() save_hints()
#define SAVECOMPPAD() save_pushptr(MUTABLE_SV(PL_comppad), SAVEt_COMPPAD)
#define SAVESWITCHSTACK(f,t) \
STMT_START { \
save_pushptrptr(MUTABLE_SV(f), MUTABLE_SV(t), SAVEt_SAVESWITCHSTACK); \
SWITCHSTACK((f),(t)); \
PL_curstackinfo->si_stack = (t); \
} STMT_END
/* Note these are special, we can't just use a save_pushptrptr() on them
* as the target might change after a fork or thread start. */
#define SAVECOMPILEWARNINGS() save_pushptr(PL_compiling.cop_warnings, SAVEt_COMPILE_WARNINGS)
#define SAVECURCOPWARNINGS() save_pushptr(PL_curcop->cop_warnings, SAVEt_CURCOP_WARNINGS)
#define SAVEPARSER(p) save_pushptr((p), SAVEt_PARSER)
#ifdef USE_ITHREADS
# define SAVECOPSTASH_FREE(c) SAVEIV((c)->cop_stashoff)
# define SAVECOPFILE_x(c) SAVEPPTR((c)->cop_file)
# define SAVECOPFILE(c) \
STMT_START { \
SAVECOPFILE_x(c); \
CopFILE_debug((c),"SAVECOPFILE",0); \
} STMT_END
# define SAVECOPFILE_FREE_x(c) SAVERCPV((c)->cop_file)
# define SAVECOPFILE_FREE(c) \
STMT_START { \
SAVECOPFILE_FREE_x(c); \
CopFILE_debug((c),"SAVECOPFILE_FREE",0); \
} STMT_END
#else
# /* XXX not refcounted */
# define SAVECOPSTASH_FREE(c) SAVESPTR(CopSTASH(c))
# define SAVECOPFILE(c) SAVESPTR(CopFILEGV(c))
# define SAVECOPFILE_FREE(c) SAVEGENERICSV(CopFILEGV(c))
#endif
#define SAVECOPLINE(c) SAVEI32(CopLINE(c))
/*
=for apidoc_section $stack
=for apidoc Am|SSize_t|SSNEW |Size_t size
=for apidoc_item | |SSNEWa |Size_t size|Size_t align
=for apidoc_item | |SSNEWat|Size_t size|type|Size_t align
=for apidoc_item | |SSNEWt |Size_t size|type
These each temporarily allocate data on the savestack, returning an SSize_t
index into the savestack, because a pointer would get broken if the savestack
is moved on reallocation. Use L</C<SSPTR>> to convert the returned index into
a pointer.
The forms differ in that plain C<SSNEW> allocates C<size> bytes;
C<SSNEWt> and C<SSNEWat> allocate C<size> objects, each of which is type
C<type>;
and <SSNEWa> and C<SSNEWat> make sure to align the new data to an C<align>
boundary. The most useful value for the alignment is likely to be
L</C<MEM_ALIGNBYTES>>. The alignment will be preserved through savestack
reallocation B<only> if realloc returns data aligned to a size divisible by
"align"!
=for apidoc Am|type |SSPTR |SSize_t index|type
=for apidoc_item|type *|SSPTRt|SSize_t index|type
These convert the C<index> returned by L/<C<SSNEW>> and kin into actual pointers.
The difference is that C<SSPTR> casts the result to C<type>, and C<SSPTRt>
casts it to a pointer of that C<type>.
=cut
*/
#define SSNEW(size) Perl_save_alloc(aTHX_ (size), 0)
#define SSNEWt(n,t) SSNEW((n)*sizeof(t))
#define SSNEWa(size,align) Perl_save_alloc(aTHX_ (size), \
(I32)(align - ((size_t)((caddr_t)&PL_savestack[PL_savestack_ix]) % align)) % align)
#define SSNEWat(n,t,align) SSNEWa((n)*sizeof(t), align)
#define SSPTR(off,type) (assert(sizeof(off) >= sizeof(SSize_t)), (type) ((char*)PL_savestack + off))
#define SSPTRt(off,type) (assert(sizeof(off) >= sizeof(SSize_t)), (type*) ((char*)PL_savestack + off))
#define save_freesv(op) save_pushptr((void *)(op), SAVEt_FREESV)
#define save_mortalizesv(op) save_pushptr((void *)(op), SAVEt_MORTALIZESV)
# define save_freeop(op) \
STMT_START { \
OP * const _o = (OP *)(op); \
assert(!_o->op_savefree); \
_o->op_savefree = 1; \
save_pushptr((void *)(_o), SAVEt_FREEOP); \
} STMT_END
#define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV)
/*
=for apidoc_section $callback
=for apidoc save_op
Implements C<SAVEOP>.
=cut
*/
#define save_op() save_pushptr((void *)(PL_op), SAVEt_OP)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

151
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/scope_types.h Normal file
View file

@ -0,0 +1,151 @@
/* -*- mode: C; buffer-read-only: t -*-
Copyright (C) 2022 by Larry Wall and others
You may distribute under the terms of either the GNU General Public
License or the Artistic License, as specified in the README file.
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
This file is built by regen/scope_types.pl.
Any changes made here will be lost!
The defines and contents of the leave_scope_arg_counts[] array
must match. To add a new type modify the __DATA__ section in
regen/scope_types.pl and run `make regen` to rebuild the file.
*/
/* zero args */
#define SAVEt_ALLOC 0
#define SAVEt_CLEARPADRANGE 1
#define SAVEt_CLEARSV 2
#define SAVEt_REGCONTEXT 3
/* one arg */
#define SAVEt_TMPSFLOOR 4
#define SAVEt_BOOL 5
#define SAVEt_COMPILE_WARNINGS 6
#define SAVEt_CURCOP_WARNINGS 7
#define SAVEt_COMPPAD 8
#define SAVEt_FREECOPHH 9
#define SAVEt_FREEOP 10
#define SAVEt_FREEPV 11
#define SAVEt_FREESV 12
#define SAVEt_I16 13
#define SAVEt_I32_SMALL 14
#define SAVEt_I8 15
#define SAVEt_INT_SMALL 16
#define SAVEt_MORTALIZESV 17
#define SAVEt_NSTAB 18
#define SAVEt_OP 19
#define SAVEt_PARSER 20
#define SAVEt_STACK_POS 21
#define SAVEt_READONLY_OFF 22
#define SAVEt_FREEPADNAME 23
#define SAVEt_STRLEN_SMALL 24
#define SAVEt_FREERCPV 25
/* two args */
#define SAVEt_AV 26
#define SAVEt_DESTRUCTOR 27
#define SAVEt_DESTRUCTOR_X 28
#define SAVEt_GENERIC_PVREF 29
#define SAVEt_GENERIC_SVREF 30
#define SAVEt_GP 31
#define SAVEt_GVSV 32
#define SAVEt_HINTS 33
#define SAVEt_HPTR 34
#define SAVEt_HV 35
#define SAVEt_I32 36
#define SAVEt_INT 37
#define SAVEt_ITEM 38
#define SAVEt_IV 39
#define SAVEt_LONG 40
#define SAVEt_PPTR 41
#define SAVEt_SAVESWITCHSTACK 42
#define SAVEt_SHARED_PVREF 43
#define SAVEt_SPTR 44
#define SAVEt_STRLEN 45
#define SAVEt_SV 46
#define SAVEt_SVREF 47
#define SAVEt_VPTR 48
#define SAVEt_ADELETE 49
#define SAVEt_APTR 50
#define SAVEt_RCPV 51
/* three args */
#define SAVEt_HELEM 52
#define SAVEt_PADSV_AND_MORTALIZE 53
#define SAVEt_SET_SVFLAGS 54
#define SAVEt_GVSLOT 55
#define SAVEt_AELEM 56
#define SAVEt_DELETE 57
#define SAVEt_HINTS_HH 58
static const U8 leave_scope_arg_counts[] = {
0, /* SAVEt_ALLOC */
0, /* SAVEt_CLEARPADRANGE */
0, /* SAVEt_CLEARSV */
0, /* SAVEt_REGCONTEXT */
1, /* SAVEt_TMPSFLOOR */
1, /* SAVEt_BOOL */
1, /* SAVEt_COMPILE_WARNINGS */
1, /* SAVEt_CURCOP_WARNINGS */
1, /* SAVEt_COMPPAD */
1, /* SAVEt_FREECOPHH */
1, /* SAVEt_FREEOP */
1, /* SAVEt_FREEPV */
1, /* SAVEt_FREESV */
1, /* SAVEt_I16 */
1, /* SAVEt_I32_SMALL */
1, /* SAVEt_I8 */
1, /* SAVEt_INT_SMALL */
1, /* SAVEt_MORTALIZESV */
1, /* SAVEt_NSTAB */
1, /* SAVEt_OP */
1, /* SAVEt_PARSER */
1, /* SAVEt_STACK_POS */
1, /* SAVEt_READONLY_OFF */
1, /* SAVEt_FREEPADNAME */
1, /* SAVEt_STRLEN_SMALL */
1, /* SAVEt_FREERCPV */
2, /* SAVEt_AV */
2, /* SAVEt_DESTRUCTOR */
2, /* SAVEt_DESTRUCTOR_X */
2, /* SAVEt_GENERIC_PVREF */
2, /* SAVEt_GENERIC_SVREF */
2, /* SAVEt_GP */
2, /* SAVEt_GVSV */
2, /* SAVEt_HINTS */
2, /* SAVEt_HPTR */
2, /* SAVEt_HV */
2, /* SAVEt_I32 */
2, /* SAVEt_INT */
2, /* SAVEt_ITEM */
2, /* SAVEt_IV */
2, /* SAVEt_LONG */
2, /* SAVEt_PPTR */
2, /* SAVEt_SAVESWITCHSTACK */
2, /* SAVEt_SHARED_PVREF */
2, /* SAVEt_SPTR */
2, /* SAVEt_STRLEN */
2, /* SAVEt_SV */
2, /* SAVEt_SVREF */
2, /* SAVEt_VPTR */
2, /* SAVEt_ADELETE */
2, /* SAVEt_APTR */
2, /* SAVEt_RCPV */
3, /* SAVEt_HELEM */
3, /* SAVEt_PADSV_AND_MORTALIZE */
3, /* SAVEt_SET_SVFLAGS */
3, /* SAVEt_GVSLOT */
3, /* SAVEt_AELEM */
3, /* SAVEt_DELETE */
3 /* SAVEt_HINTS_HH */
};
#define MAX_SAVEt 58
/* ex: set ro ft=c: */

2726
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv.h Normal file
View file

File diff suppressed because it is too large Load diff

1019
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/sv_inline.h Normal file
View file

File diff suppressed because it is too large Load diff

549
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/thread.h Normal file
View file

@ -0,0 +1,549 @@
/* thread.h
*
* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
* by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#if defined(USE_ITHREADS)
#if defined(VMS)
#include <builtins.h>
#endif
#ifdef WIN32
# include <win32thread.h>
#else
# ifdef OLD_PTHREADS_API /* Here be dragons. */
# define DETACH(t) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_detach(&(t)->self))) { \
MUTEX_UNLOCK(&(t)->mutex); \
Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} \
} STMT_END
# define PERL_GET_CONTEXT Perl_get_context()
# define PERL_SET_CONTEXT(t) Perl_set_context((void*)t)
# define PTHREAD_GETSPECIFIC_INT
# ifdef OEMVS
# define pthread_addr_t void *
# define pthread_create(t,a,s,d) pthread_create(t,&(a),s,d)
# define pthread_keycreate pthread_key_create
# endif
# ifdef VMS
# define pthread_attr_init(a) pthread_attr_create(a)
# define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_setdetach_np(a,s)
# define PTHREAD_CREATE(t,a,s,d) pthread_create(t,a,s,d)
# define pthread_key_create(k,d) pthread_keycreate(k,(pthread_destructor_t)(d))
# define pthread_mutexattr_init(a) pthread_mutexattr_create(a)
# define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t)
# endif
# if defined(__hpux) && defined(__ux_version) && __ux_version <= 1020
# define pthread_attr_init(a) pthread_attr_create(a)
/* XXX pthread_setdetach_np() missing in DCE threads on HP-UX 10.20 */
# define PTHREAD_ATTR_SETDETACHSTATE(a,s) (0)
# define PTHREAD_CREATE(t,a,s,d) pthread_create(t,a,s,d)
# define pthread_key_create(k,d) pthread_keycreate(k,(pthread_destructor_t)(d))
# define pthread_mutexattr_init(a) pthread_mutexattr_create(a)
# define pthread_mutexattr_settype(a,t) pthread_mutexattr_setkind_np(a,t)
# endif
# if defined(OEMVS)
# define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,&(s))
# define YIELD pthread_yield(NULL)
# endif
# endif
# if !defined(__hpux) || !defined(__ux_version) || __ux_version > 1020
# define pthread_mutexattr_default NULL
# define pthread_condattr_default NULL
# endif
#endif
#ifndef PTHREAD_CREATE
/* You are not supposed to pass NULL as the 2nd arg of PTHREAD_CREATE(). */
# define PTHREAD_CREATE(t,a,s,d) pthread_create(t,&(a),s,d)
#endif
#ifndef PTHREAD_ATTR_SETDETACHSTATE
# define PTHREAD_ATTR_SETDETACHSTATE(a,s) pthread_attr_setdetachstate(a,s)
#endif
#ifndef PTHREAD_CREATE_JOINABLE
# ifdef OLD_PTHREAD_CREATE_JOINABLE
# define PTHREAD_CREATE_JOINABLE OLD_PTHREAD_CREATE_JOINABLE
# else
# define PTHREAD_CREATE_JOINABLE 0 /* Panic? No, guess. */
# endif
#endif
#ifdef __VMS
/* Default is 1024 on VAX, 8192 otherwise */
# ifdef __ia64
# define THREAD_CREATE_NEEDS_STACK (48*1024)
# else
# define THREAD_CREATE_NEEDS_STACK (32*1024)
# endif
#endif
#ifdef I_MACH_CTHREADS
/* cthreads interface */
/* #include <mach/cthreads.h> is in perl.h #ifdef I_MACH_CTHREADS */
#define MUTEX_INIT(m) \
STMT_START { \
*m = mutex_alloc(); \
if (*m) { \
mutex_init(*m); \
} else { \
Perl_croak_nocontext("panic: MUTEX_INIT [%s:%d]", \
__FILE__, __LINE__); \
} \
} STMT_END
#define MUTEX_LOCK(m) mutex_lock(*m)
#define MUTEX_UNLOCK(m) mutex_unlock(*m)
#define MUTEX_DESTROY(m) \
STMT_START { \
mutex_free(*m); \
*m = 0; \
} STMT_END
#define COND_INIT(c) \
STMT_START { \
*c = condition_alloc(); \
if (*c) { \
condition_init(*c); \
} \
else { \
Perl_croak_nocontext("panic: COND_INIT [%s:%d]", \
__FILE__, __LINE__); \
} \
} STMT_END
#define COND_SIGNAL(c) condition_signal(*c)
#define COND_BROADCAST(c) condition_broadcast(*c)
#define COND_WAIT(c, m) condition_wait(*c, *m)
#define COND_DESTROY(c) \
STMT_START { \
condition_free(*c); \
*c = 0; \
} STMT_END
#define THREAD_RET_TYPE any_t
#define DETACH(t) cthread_detach(t->self)
#define JOIN(t, avp) (*(avp) = MUTABLE_AV(cthread_join(t->self)))
#define PERL_SET_CONTEXT(t) cthread_set_data(cthread_self(), t)
#define PERL_GET_CONTEXT cthread_data(cthread_self())
#define INIT_THREADS cthread_init()
#define YIELD cthread_yield()
#define ALLOC_THREAD_KEY NOOP
#define FREE_THREAD_KEY NOOP
#define SET_THREAD_SELF(thr) (thr->self = cthread_self())
#endif /* I_MACH_CTHREADS */
#ifndef YIELD
# ifdef SCHED_YIELD
# define YIELD SCHED_YIELD
# elif defined(HAS_SCHED_YIELD)
# define YIELD sched_yield()
# elif defined(HAS_PTHREAD_YIELD)
/* pthread_yield(NULL) platforms are expected
* to have #defined YIELD for themselves. */
# define YIELD pthread_yield()
# endif
#endif
#ifdef __hpux
# define MUTEX_INIT_NEEDS_MUTEX_ZEROED
#endif
#ifndef MUTEX_INIT
# ifdef MUTEX_INIT_NEEDS_MUTEX_ZEROED
/* Temporary workaround, true bug is deeper. --jhi 1999-02-25 */
# define MUTEX_INIT(m) \
STMT_START { \
int _eC_; \
Zero((m), 1, perl_mutex); \
if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default)))\
Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# else
# define MUTEX_INIT(m) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default))) \
Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# endif
# ifdef PERL_TSA_ACTIVE
# define perl_pthread_mutex_lock(m) perl_tsa_mutex_lock(m)
# define perl_pthread_mutex_unlock(m) perl_tsa_mutex_unlock(m)
# else
# define perl_pthread_mutex_lock(m) pthread_mutex_lock(m)
# define perl_pthread_mutex_unlock(m) pthread_mutex_unlock(m)
# endif
# define MUTEX_LOCK(m) \
STMT_START { \
dSAVE_ERRNO; \
int _eC_; \
if ((_eC_ = perl_pthread_mutex_lock((m)))) \
Perl_croak_nocontext("panic: MUTEX_LOCK (%d) [%s:%d]",\
_eC_, __FILE__, __LINE__); \
RESTORE_ERRNO; \
} STMT_END
# define MUTEX_UNLOCK(m) \
STMT_START { \
dSAVE_ERRNO; /* Shouldn't be necessary as panics if fails */\
int _eC_; \
if ((_eC_ = perl_pthread_mutex_unlock((m)))) { \
Perl_croak_nocontext( \
"panic: MUTEX_UNLOCK (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} \
RESTORE_ERRNO; \
} STMT_END
# define MUTEX_DESTROY(m) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_mutex_destroy((m)))) { \
dTHX; \
if (PL_phase != PERL_PHASE_DESTRUCT) { \
Perl_croak_nocontext("panic: MUTEX_DESTROY (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} \
} \
} STMT_END
#endif /* MUTEX_INIT */
#ifndef COND_INIT
# define COND_INIT(c) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_cond_init((c), pthread_condattr_default))) \
Perl_croak_nocontext("panic: COND_INIT (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# define COND_SIGNAL(c) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_cond_signal((c)))) \
Perl_croak_nocontext("panic: COND_SIGNAL (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# define COND_BROADCAST(c) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_cond_broadcast((c)))) \
Perl_croak_nocontext("panic: COND_BROADCAST (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# define COND_WAIT(c, m) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_cond_wait((c), (m)))) \
Perl_croak_nocontext("panic: COND_WAIT (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
# define COND_DESTROY(c) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_cond_destroy((c)))) { \
dTHX; \
if (PL_phase != PERL_PHASE_DESTRUCT) { \
Perl_croak_nocontext("panic: COND_DESTROY (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} \
} \
} STMT_END
#endif /* COND_INIT */
#if defined(MUTEX_LOCK) && defined(MUTEX_UNLOCK) \
&& defined(COND_SIGNAL) && defined(COND_WAIT)
/* These emulate native many-reader/1-writer locks.
* Basically a locking reader just locks the semaphore long enough to increment
* a counter; and similarly decrements it when when through. Any writer will
* run only when the count of readers is 0. That is because it blocks on that
* semaphore (doing a COND_WAIT) until it gets control of it, which won't
* happen unless the count becomes 0. ALL readers and other writers are then
* blocked until it releases the semaphore. The reader whose unlocking causes
* the count to become 0 signals any waiting writers, and the system guarantees
* that only one gets control at a time */
# define PERL_READ_LOCK(mutex) \
STMT_START { \
MUTEX_LOCK(&(mutex)->lock); \
(mutex)->readers_count++; \
MUTEX_UNLOCK(&(mutex)->lock); \
} STMT_END
# define PERL_READ_UNLOCK(mutex) \
STMT_START { \
MUTEX_LOCK(&(mutex)->lock); \
(mutex)->readers_count--; \
if ((mutex)->readers_count <= 0) { \
assert((mutex)->readers_count == 0); \
COND_SIGNAL(&(mutex)->wakeup); \
(mutex)->readers_count = 0; \
} \
MUTEX_UNLOCK(&(mutex)->lock); \
} STMT_END
# define PERL_WRITE_LOCK(mutex) \
STMT_START { \
MUTEX_LOCK(&(mutex)->lock); \
do { \
if ((mutex)->readers_count <= 0) { \
assert((mutex)->readers_count == 0); \
(mutex)->readers_count = 0; \
break; \
} \
COND_WAIT(&(mutex)->wakeup, &(mutex)->lock); \
} \
while (1); \
\
/* Here, the mutex is locked, with no readers */ \
} STMT_END
# define PERL_WRITE_UNLOCK(mutex) \
STMT_START { \
COND_SIGNAL(&(mutex)->wakeup); \
MUTEX_UNLOCK(&(mutex)->lock); \
} STMT_END
# define PERL_RW_MUTEX_INIT(mutex) \
STMT_START { \
MUTEX_INIT(&(mutex)->lock); \
COND_INIT(&(mutex)->wakeup); \
(mutex)->readers_count = 0; \
} STMT_END
# define PERL_RW_MUTEX_DESTROY(mutex) \
STMT_START { \
COND_DESTROY(&(mutex)->wakeup); \
MUTEX_DESTROY(&(mutex)->lock); \
} STMT_END
#endif
/* DETACH(t) must only be called while holding t->mutex */
#ifndef DETACH
# define DETACH(t) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_detach((t)->self))) { \
MUTEX_UNLOCK(&(t)->mutex); \
Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} \
} STMT_END
#endif /* DETACH */
#ifndef JOIN
# define JOIN(t, avp) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_join((t)->self, (void**)(avp)))) \
Perl_croak_nocontext("panic: pthread_join (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
} STMT_END
#endif /* JOIN */
/* Use an unchecked fetch of thread-specific data instead of a checked one.
* It would fail if the key were bogus, but if the key were bogus then
* Really Bad Things would be happening anyway. --dan */
#if (defined(__ALPHA) && (__VMS_VER >= 70000000)) || \
(defined(__alpha) && defined(__osf__) && !defined(__GNUC__)) /* Available only on >= 4.0 */
# define HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP /* Configure test needed */
#endif
#ifdef HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP
# define PTHREAD_GETSPECIFIC(key) pthread_unchecked_getspecific_np(key)
#else
# define PTHREAD_GETSPECIFIC(key) pthread_getspecific(key)
#endif
#if defined(PERL_THREAD_LOCAL) && !defined(PERL_GET_CONTEXT) && !defined(PERL_SET_CONTEXT) && !defined(__cplusplus)
/* Use C11 thread-local storage, where possible.
* Frustratingly we can't use it for C++ extensions, C++ and C disagree on the
* syntax used for thread local storage, meaning that the working token that
* Configure probed for C turns out to be a compiler error on C++. Great.
* (Well, unless one or both is supporting non-standard syntax as an extension)
* As Configure doesn't have a way to probe for C++ dialects, we just take the
* safe option and do the same as 5.34.0 and earlier - use pthreads on C++.
* Of course, if C++ XS extensions really want to avoid *all* this overhead,
* they should #define PERL_NO_GET_CONTEXT and pass aTHX/aTHX_ explicitly) */
# define PERL_USE_THREAD_LOCAL
extern PERL_THREAD_LOCAL void *PL_current_context;
# define PERL_GET_CONTEXT PL_current_context
/* We must also call pthread_setspecific() always, as C++ code has to read it
* with pthreads (the #else side just below) */
# define PERL_SET_CONTEXT(t) \
STMT_START { \
int _eC_; \
if ((_eC_ = pthread_setspecific(PL_thr_key, \
PL_current_context = (void *)(t)))) \
Perl_croak_nocontext("panic: pthread_setspecific (%d) [%s:%d]", \
_eC_, __FILE__, __LINE__); \
PERL_SET_NON_tTHX_CONTEXT(t); \
} STMT_END
#else
/* else fall back to pthreads */
# ifndef PERL_GET_CONTEXT
# define PERL_GET_CONTEXT PTHREAD_GETSPECIFIC(PL_thr_key)
# endif
/* For C++ extensions built on a system where the C compiler provides thread
* local storage that call PERL_SET_CONTEXT() also need to set
* PL_current_context, so need to call into C code to do this.
* To avoid exploding code complexity, do this also on C platforms that don't
* support thread local storage. PERL_SET_CONTEXT is not called that often. */
# ifndef PERL_SET_CONTEXT
# define PERL_SET_CONTEXT(t) Perl_set_context((void*)t)
# endif /* PERL_SET_CONTEXT */
#endif /* PERL_THREAD_LOCAL */
#ifndef INIT_THREADS
# ifdef NEED_PTHREAD_INIT
# define INIT_THREADS pthread_init()
# endif
#endif
#ifndef ALLOC_THREAD_KEY
# define ALLOC_THREAD_KEY \
STMT_START { \
if (pthread_key_create(&PL_thr_key, 0)) { \
PERL_UNUSED_RESULT(write(2, STR_WITH_LEN("panic: pthread_key_create failed\n"))); \
exit(1); \
} \
} STMT_END
#endif
#ifndef FREE_THREAD_KEY
# define FREE_THREAD_KEY \
STMT_START { \
pthread_key_delete(PL_thr_key); \
} STMT_END
#endif
#ifndef PTHREAD_ATFORK
# ifdef HAS_PTHREAD_ATFORK
# define PTHREAD_ATFORK(prepare,parent,child) \
pthread_atfork(prepare,parent,child)
# else
# define PTHREAD_ATFORK(prepare,parent,child) \
NOOP
# endif
#endif
#ifndef THREAD_RET_TYPE
# define THREAD_RET_TYPE void *
#endif /* THREAD_RET */
# define LOCK_DOLLARZERO_MUTEX MUTEX_LOCK(&PL_dollarzero_mutex)
# define UNLOCK_DOLLARZERO_MUTEX MUTEX_UNLOCK(&PL_dollarzero_mutex)
#endif /* USE_ITHREADS */
#ifndef MUTEX_LOCK
# define MUTEX_LOCK(m) NOOP
#endif
#ifndef MUTEX_UNLOCK
# define MUTEX_UNLOCK(m) NOOP
#endif
#ifndef MUTEX_INIT
# define MUTEX_INIT(m) NOOP
#endif
#ifndef MUTEX_DESTROY
# define MUTEX_DESTROY(m) NOOP
#endif
#ifndef COND_INIT
# define COND_INIT(c) NOOP
#endif
#ifndef COND_SIGNAL
# define COND_SIGNAL(c) NOOP
#endif
#ifndef COND_BROADCAST
# define COND_BROADCAST(c) NOOP
#endif
#ifndef COND_WAIT
# define COND_WAIT(c, m) NOOP
#endif
#ifndef COND_DESTROY
# define COND_DESTROY(c) NOOP
#endif
#ifndef PERL_READ_LOCK
# define PERL_READ_LOCK NOOP
# define PERL_READ_UNLOCK NOOP
# define PERL_WRITE_LOCK NOOP
# define PERL_WRITE_UNLOCK NOOP
# define PERL_RW_MUTEX_INIT NOOP
# define PERL_RW_MUTEX_DESTROY NOOP
#endif
#ifndef LOCK_DOLLARZERO_MUTEX
# define LOCK_DOLLARZERO_MUTEX NOOP
#endif
#ifndef UNLOCK_DOLLARZERO_MUTEX
# define UNLOCK_DOLLARZERO_MUTEX NOOP
#endif
/* THR, SET_THR, and dTHR are there for compatibility with old versions */
#ifndef THR
# define THR PERL_GET_THX
#endif
#ifndef SET_THR
# define SET_THR(t) PERL_SET_THX(t)
#endif
#ifndef dTHR
# define dTHR dNOOP
#endif
#ifndef INIT_THREADS
# define INIT_THREADS NOOP
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

48
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/time64.h Normal file
View file

@ -0,0 +1,48 @@
#include <time.h>
#include "time64_config.h"
#ifndef PERL_TIME64_H_
# define PERL_TIME64_H_
/* Set our custom types */
typedef INT_64_T Int64;
typedef Int64 Time64_T;
typedef I32 Year;
/* A copy of the tm struct but with a 64 bit year */
struct TM64 {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
Year tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
#ifdef HAS_TM_TM_GMTOFF
long tm_gmtoff;
#endif
#ifdef HAS_TM_TM_ZONE
const char *tm_zone;
#endif
};
/* Decide which tm struct to use */
#ifdef USE_TM64
#define TM TM64
#else
#define TM tm
#endif
/* Declare functions */
struct TM *Perl_gmtime64_r (const Time64_T *, struct TM *);
struct TM *Perl_localtime64_r (const Time64_T *, struct TM *);
#endif

87
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/time64_config.h Normal file
View file

@ -0,0 +1,87 @@
#ifndef PERL_TIME64_CONFIG_H_
# define PERL_TIME64_CONFIG_H_
#include "reentr.h"
/* Configuration
-------------
Define as appropriate for your system.
Sensible defaults provided.
*/
/* Debugging
TIME_64_DEBUG
Define if you want debugging messages
*/
/* #define TIME_64_DEBUG */
/* INT_64_T
A numeric type to store time and others.
Must be defined.
*/
#define INT_64_T NV
/* USE_TM64
Should we use a 64 bit safe replacement for tm? This will
let you go past year 2 billion but the struct will be incompatible
with tm. Conversion functions will be provided.
*/
#define USE_TM64
/* Availability of system functions.
HAS_GMTIME_R
Define if your system has gmtime_r()
HAS_LOCALTIME_R
Define if your system has localtime_r()
HAS_TIMEGM
Define if your system has timegm(), a GNU extension.
*/
/* Set in config.h */
/* Details of non-standard tm struct elements.
HAS_TM_TM_GMTOFF
True if your tm struct has a "tm_gmtoff" element.
A BSD extension.
HAS_TM_TM_ZONE
True if your tm struct has a "tm_zone" element.
A BSD extension.
*/
/* Set in config.h */
/* USE_SYSTEM_LOCALTIME
USE_SYSTEM_GMTIME
Should we use the system functions if the time is inside their range?
Your system localtime() is probably more accurate, but our gmtime() is
fast and safe. Except on VMS, where we need the homegrown gmtime()
override to shift between UTC and local for the vmsish 'time' pragma.
*/
#define USE_SYSTEM_LOCALTIME
#ifdef VMS
# define USE_SYSTEM_GMTIME
#endif
/* SYSTEM_LOCALTIME_MAX
SYSTEM_LOCALTIME_MIN
SYSTEM_GMTIME_MAX
SYSTEM_GMTIME_MIN
Maximum and minimum values your system's gmtime() and localtime()
can handle. We will use your system functions if the time falls
inside these ranges.
*/
#define SYSTEM_LOCALTIME_MAX CAT2(LOCALTIME_MAX,.0)
#define SYSTEM_LOCALTIME_MIN CAT2(LOCALTIME_MIN,.0)
#define SYSTEM_GMTIME_MAX CAT2(GMTIME_MAX,.0)
#define SYSTEM_GMTIME_MIN CAT2(GMTIME_MIN,.0)
#endif /* PERL_TIME64_CONFIG_H_ */

7765
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uni_keywords.h Normal file
View file

File diff suppressed because it is too large Load diff

259
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/unicode_constants.h Normal file
View file

File diff suppressed because one or more lines are too long

175
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/unixish.h Normal file
View file

@ -0,0 +1,175 @@
/* unixish.h
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
* 2003, 2006, 2007, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
/*
* The following symbols are defined if your operating system supports
* functions by that name. All Unixes I know of support them, thus they
* are not checked by the configuration script, but are directly defined
* here.
*/
/* HAS_IOCTL:
* This symbol, if defined, indicates that the ioctl() routine is
* available to set I/O characteristics
*/
#define HAS_IOCTL /**/
/* HAS_UTIME:
* This symbol, if defined, indicates that the routine utime() is
* available to update the access and modification times of files.
*/
#define HAS_UTIME /**/
/* HAS_GROUP
* This symbol, if defined, indicates that the getgrnam() and
* getgrgid() routines are available to get group entries.
* The getgrent() has a separate definition, HAS_GETGRENT.
*/
#define HAS_GROUP /**/
/* HAS_PASSWD
* This symbol, if defined, indicates that the getpwnam() and
* getpwuid() routines are available to get password entries.
* The getpwent() has a separate definition, HAS_GETPWENT.
*/
#define HAS_PASSWD /**/
#define HAS_KILL
#define HAS_WAIT
/* USEMYBINMODE
* This symbol, if defined, indicates that the program should
* use the routine my_binmode(FILE *fp, char iotype) to insure
* that a file is in "binary" mode -- that is, that no translation
* of bytes occurs on read or write operations.
*/
#undef USEMYBINMODE
/* Stat_t:
* This symbol holds the type used to declare buffers for information
* returned by stat(). It's usually just struct stat. It may be necessary
* to include <sys/stat.h> and <sys/types.h> to get any typedef'ed
* information.
*/
#define Stat_t struct stat
/* USE_STAT_RDEV:
* This symbol is defined if this system has a stat structure declaring
* st_rdev
*/
#define USE_STAT_RDEV /**/
/* ACME_MESS:
* This symbol, if defined, indicates that error messages should be
* should be generated in a format that allows the use of the Acme
* GUI/editor's autofind feature.
*/
#undef ACME_MESS /**/
/* UNLINK_ALL_VERSIONS:
* This symbol, if defined, indicates that the program should arrange
* to remove all versions of a file if unlink() is called. This is
* probably only relevant for VMS.
*/
/* #define UNLINK_ALL_VERSIONS / **/
/* VMS:
* This symbol, if defined, indicates that the program is running under
* VMS. It is currently automatically set by cpps running under VMS,
* and is included here for completeness only.
*/
/* #define VMS / **/
/* ALTERNATE_SHEBANG:
* This symbol, if defined, contains a "magic" string which may be used
* as the first line of a Perl program designed to be executed directly
* by name, instead of the standard Unix #!. If ALTERNATE_SHEBANG
* begins with a character other then #, then Perl will only treat
* it as a command line if it finds the string "perl" in the first
* word; otherwise it's treated as the first line of code in the script.
* (IOW, Perl won't hand off to another interpreter via an alternate
* shebang sequence that might be legal Perl code.)
*/
/* #define ALTERNATE_SHEBANG "#!" / **/
# include <signal.h>
#ifndef SIGABRT
# define SIGABRT SIGILL
#endif
#ifndef SIGILL
# define SIGILL 6 /* blech */
#endif
#define ABORT() kill(PerlProc_getpid(),SIGABRT);
/*
* fwrite1() should be a routine with the same calling sequence as fwrite(),
* but which outputs all of the bytes requested as a single stream (unlike
* fwrite() itself, which on some systems outputs several distinct records
* if the number_of_items parameter is >1).
*/
#define fwrite1 fwrite
#define Stat(fname,bufptr) stat((fname),(bufptr))
#ifdef __amigaos4__
int afstat(int fd, struct stat *statb);
# define Fstat(fd,bufptr) afstat((fd),(bufptr))
#endif
#ifndef Fstat
# define Fstat(fd,bufptr) fstat((fd),(bufptr))
#endif
#define Fflush(fp) fflush(fp)
#define Mkdir(path,mode) mkdir((path),(mode))
#if defined(__amigaos4__)
# define PLATFORM_SYS_TERM_ amigaos4_dispose_fork_array()
# define PLATFORM_SYS_INIT_ STMT_START { \
amigaos4_init_fork_array(); \
amigaos4_init_environ_sema(); \
} STMT_END
#else
# define PLATFORM_SYS_TERM_ NOOP
# define PLATFORM_SYS_INIT_ NOOP
#endif
#ifndef PERL_SYS_INIT_BODY
#define PERL_SYS_INIT_BODY(c,v) \
MALLOC_CHECK_TAINT2(*c,*v) PERL_FPU_INIT; PERLIO_INIT; \
MALLOC_INIT; PLATFORM_SYS_INIT_;
#endif
/* Generally add things last-in first-terminated. IO and memory terminations
* need to be generally last
*
* BEWARE that using PerlIO in these will be using freed memory, so may appear
* to work, but must NOT be retained in production code. */
#ifndef PERL_SYS_TERM_BODY
# define PERL_SYS_TERM_BODY() \
ENV_TERM; USER_PROP_MUTEX_TERM; LOCALE_TERM; \
HINTS_REFCNT_TERM; KEYWORD_PLUGIN_MUTEX_TERM; \
OP_CHECK_MUTEX_TERM; OP_REFCNT_TERM; \
PERLIO_TERM; MALLOC_TERM; \
PLATFORM_SYS_TERM_;
#endif
#define BIT_BUCKET "/dev/null"
#define dXSUB_SYS dNOOP
#ifndef NO_ENVIRON_ARRAY
#define USE_ENVIRON_ARRAY
#endif
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

1319
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utf8.h Normal file
View file

File diff suppressed because it is too large Load diff

208
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/utfebcdic.h Normal file
View file

@ -0,0 +1,208 @@
/* utfebcdic.h
*
* Copyright (C) 2001, 2002, 2003, 2005, 2006, 2007, 2009,
* 2010, 2011 by Larry Wall, Nick Ing-Simmons, and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
* Macros to implement UTF-EBCDIC as perl's internal encoding
* Adapted from version 7.1 of Unicode Technical Report #16:
* http://www.unicode.org/reports/tr16
*
* To summarize, the way it works is:
* To convert an EBCDIC code point to UTF-EBCDIC:
* 1) convert to Unicode. No conversion is necessary for code points above
* 255, as Unicode and EBCDIC are identical in this range. For smaller
* code points, the conversion is done by lookup in the PL_e2a table (with
* inverse PL_a2e) in the generated file 'ebcdic_tables.h'. The 'a'
* stands for ASCII platform, meaning 0-255 Unicode. Use
* NATIVE_TO_LATIN1() and LATIN1_TO_NATIVE(), respectively to perform this
* lookup. NATIVE_TO_UNI() and UNI_TO_NATIVE() are similarly used for any
* input, and know to avoid the lookup for inputs above 255.
* 2) convert that to a utf8-like string called I8 ('I' stands for
* intermediate) with variant characters occupying multiple bytes. This
* step is similar to the utf8-creating step from Unicode, but the details
* are different. This transformation is called UTF8-Mod. There is a
* chart about the bit patterns in a comment later in this file. But
* essentially here are the differences:
* UTF8 I8
* invariant byte starts with 0 starts with 0 or 100
* continuation byte starts with 10 starts with 101
* start byte same in both: if the code point requires N bytes,
* then the leading N bits are 1, followed by a 0. If
* all 8 bits in the first byte are 1, the code point
* will occupy 14 bytes (compared to 13 in Perl's
* extended UTF-8). This is incompatible with what
* tr16 implies should be the representation of code
* points 2**30 and above, but allows Perl to be able
* to represent all code points that fit in a 64-bit
* word in either our extended UTF-EBCDIC or UTF-8.
* 3) Use the algorithm in tr16 to convert each byte from step 2 into
* final UTF-EBCDIC. This is done by table lookup from a table
* constructed from the algorithm, reproduced in ebcdic_tables.h as
* PL_utf2e, with its inverse being PL_e2utf. They are constructed so that
* all EBCDIC invariants remain invariant, but no others do, and the first
* byte of a variant will always have its upper bit set. But note that
* the upper bit of some invariants is also 1. The table also is designed
* so that lexically comparing two UTF-EBCDIC-variant characters yields
* the Unicode code point order. (To get native code point order, one has
* to convert the latin1-range characters to their native code point
* value.) The macros NATIVE_UTF8_TO_I8() and I8_TO_NATIVE_UTF8() do the
* table lookups.
*
* For example, the ordinal value of 'A' is 193 in EBCDIC, and also is 193 in
* UTF-EBCDIC. Step 1) converts it to 65, Step 2 leaves it at 65, and Step 3
* converts it back to 193. As an example of how a variant character works,
* take LATIN SMALL LETTER Y WITH DIAERESIS, which is typically 0xDF in
* EBCDIC. Step 1 converts it to the Unicode value, 0xFF. Step 2 converts
* that to two bytes = 11000111 10111111 = C7 BF, and Step 3 converts those to
* 0x8B 0x73.
*
* If you're starting from Unicode, skip step 1. For UTF-EBCDIC to straight
* EBCDIC, reverse the steps.
*
* The EBCDIC invariants have been chosen to be those characters whose Unicode
* equivalents have ordinal numbers less than 160, that is the same characters
* that are expressible in ASCII, plus the C1 controls. So there are 160
* invariants instead of the 128 in UTF-8.
*
* The purpose of Step 3 is to make the encoding be invariant for the chosen
* characters. This messes up the convenient patterns found in step 2, so
* generally, one has to undo step 3 into a temporary to use them, using the
* macro NATIVE_TO_I8(). However, one "shadow", or parallel table,
* PL_utf8skip, has been constructed that doesn't require undoing things. It
* is such that for each byte, it says how long the sequence is if that
* (UTF-EBCDIC) byte were to begin it.
*
* There are actually 3 slightly different UTF-EBCDIC encodings in
* ebcdic_tables.h, one for each of the code pages recognized by Perl. That
* means that there are actually three different sets of tables, one for each
* code page. (If Perl is compiled on platforms using another EBCDIC code
* page, it may not compile, or Perl may silently mistake it for one of the
* three.)
*
* Note that tr16 actually only specifies one version of UTF-EBCDIC, based on
* the 1047 encoding, and which is supposed to be used for all code pages.
* But this doesn't work. To illustrate the problem, consider the '^' character.
* On a 037 code page it is the single byte 176, whereas under 1047 UTF-EBCDIC
* it is the single byte 95. If Perl implemented tr16 exactly, it would mean
* that changing a string containing '^' to UTF-EBCDIC would change that '^'
* from 176 to 95 (and vice-versa), violating the rule that ASCII-range
* characters are the same in UTF-8 or not. Much code in Perl assumes this
* rule. See for example
* http://grokbase.com/t/perl/mvs/025xf0yhmn/utf-ebcdic-for-posix-bc-malformed-utf-8-character
* What Perl does is create a version of UTF-EBCDIC suited to each code page;
* the one for the 1047 code page is identical to what's specified in tr16.
* This complicates interchanging files between computers using different code
* pages. Best is to convert to I8 before sending them, as the I8
* representation is the same no matter what the underlying code page is.
*
* Because of the way UTF-EBCDIC is constructed, the lowest 32 code points that
* aren't equivalent to ASCII characters nor C1 controls form the set of
* continuation bytes; the remaining 64 non-ASCII, non-control code points form
* the potential start bytes, in order. (However, the first 5 of these lead to
* malformed overlongs, so there really are only 59 start bytes, and the first
* three of the 59 are the start bytes for the Latin1 range.) Hence the
* UTF-EBCDIC for the smallest variant code point, 0x160, will have likely 0x41
* as its continuation byte, provided 0x41 isn't an ASCII or C1 equivalent.
* And its start byte will be the code point that is 37 (32+5) non-ASCII,
* non-control code points past it. (0 - 3F are controls, and 40 is SPACE,
* leaving 41 as the first potentially available one.) In contrast, on ASCII
* platforms, the first 64 (not 32) non-ASCII code points are the continuation
* bytes. And the first 2 (not 5) potential start bytes form overlong
* malformed sequences.
*
* EBCDIC characters above 0xFF are the same as Unicode in Perl's
* implementation of all 3 encodings, so for those Step 1 is trivial.
*
* (Note that the entries for invariant characters are necessarily the same in
* PL_e2a and PL_e2utf; likewise for their inverses.)
*
* UTF-EBCDIC strings are the same length or longer than UTF-8 representations
* of the same string. The maximum code point representable as 2 bytes in
* UTF-EBCDIC is 0x3FFF, instead of 0x7FFF in UTF-8.
*/
START_EXTERN_C
#include "ebcdic_tables.h"
END_EXTERN_C
/* EBCDIC-happy ways of converting native code to UTF-8 */
/* Use these when ch is known to be < 256 */
#define NATIVE_TO_LATIN1(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) PL_e2a[(U8)(ch)])
#define LATIN1_TO_NATIVE(ch) (__ASSERT_(FITS_IN_8_BITS(ch)) PL_a2e[(U8)(ch)])
/* Use these on bytes */
#define NATIVE_UTF8_TO_I8(b) (__ASSERT_(FITS_IN_8_BITS(b)) PL_e2utf[(U8)(b)])
#define I8_TO_NATIVE_UTF8(b) (__ASSERT_(FITS_IN_8_BITS(b)) PL_utf2e[(U8)(b)])
/* Transforms in wide UV chars */
#define NATIVE_TO_UNI(ch) \
(FITS_IN_8_BITS(ch) ? NATIVE_TO_LATIN1(ch) : (UV) (ch))
#define UNI_TO_NATIVE(ch) \
(FITS_IN_8_BITS(ch) ? LATIN1_TO_NATIVE(ch) : (UV) (ch))
/*
The following table is adapted from tr16, it shows the I8 encoding of Unicode code points.
Unicode U32 Bit pattern 1st Byte 2nd Byte 3rd Byte 4th Byte 5th Byte 6th Byte 7th Byte
U+0000..U+007F 000000000xxxxxxx 0xxxxxxx
U+0080..U+009F 00000000100xxxxx 100xxxxx
U+00A0..U+03FF 000000yyyyyxxxxx 110yyyyy 101xxxxx
U+0400..U+3FFF 00zzzzyyyyyxxxxx 1110zzzz 101yyyyy 101xxxxx
U+4000..U+3FFFF 0wwwzzzzzyyyyyxxxxx 11110www 101zzzzz 101yyyyy 101xxxxx
U+40000..U+3FFFFF 0vvwwwwwzzzzzyyyyyxxxxx 111110vv 101wwwww 101zzzzz 101yyyyy 101xxxxx
U+400000..U+3FFFFFF 0uvvvvvwwwwwzzzzzyyyyyxxxxx 1111110u 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx
U+4000000..U+3FFFFFFF 00uuuuuvvvvvwwwwwzzzzzyyyyyxxxxx 11111110 101uuuuu 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx
Beyond this, Perl uses an incompatible extension, similar to the one used in
regular UTF-8. There are now 14 bytes. A full 32 bits of information thus looks like this:
1st Byte 2nd-7th 8th Byte 9th Byte 10th B 11th B 12th B 13th B 14th B
U+40000000..U+FFFFFFFF ttuuuuuvvvvvwwwwwzzzzzyyyyyxxxxx 11111111 10100000 101000tt 101uuuuu 101vvvvv 101wwwww 101zzzzz 101yyyyy 101xxxxx
For 32-bit words, the 2nd through 7th bytes effectively function as leading
zeros. Above 32 bits, these fill up, with each byte yielding 5 bits of
information, so that with 13 continuation bytes, we can handle 65 bits, just
above what a 64 bit word can hold
The following table gives the I8:
I8 Code Points 1st Byte 2nd Byte 3rd 4th 5th 6th 7th 8th 9th-14th
0x0000..0x009F 00..9F
0x00A0..0x00FF * C5..C7 A0..BF
U+0100..U+03FF C8..DF A0..BF
U+0400..U+3FFF * E1..EF A0..BF A0..BF
U+4000..U+7FFF F0 * B0..BF A0..BF A0..BF
U+8000..U+D7FF F1 A0..B5 A0..BF A0..BF
U+D800..U+DFFF F1 B6..B7 A0..BF A0..BF (surrogates)
U+E000..U+FFFF F1 B8..BF A0..BF A0..BF
U+10000..U+3FFFF F2..F7 A0..BF A0..BF A0..BF
U+40000..U+FFFFF F8 * A8..BF A0..BF A0..BF A0..BF
U+100000..U+10FFFF F9 A0..A1 A0..BF A0..BF A0..BF
Below are above-Unicode code points
U+110000..U+1FFFFF F9 A2..BF A0..BF A0..BF A0..BF
U+200000..U+3FFFFF FA..FB A0..BF A0..BF A0..BF A0..BF
U+400000..U+1FFFFFF FC * A4..BF A0..BF A0..BF A0..BF A0..BF
U+2000000..U+3FFFFFF FD A0..BF A0..BF A0..BF A0..BF A0..BF
U+4000000..U+3FFFFFFF FE * A2..BF A0..BF A0..BF A0..BF A0..BF A0..BF
U+40000000.. FF A0..BF A0..BF A0..BF A0..BF A0..BF A0..BF * A1..BF A0..BF
Note the gaps before several of the byte entries above marked by '*'. These are
caused by legal UTF-8 avoiding non-shortest encodings: it is technically
possible to UTF-8-encode a single code point in different ways, but that is
explicitly forbidden, and the shortest possible encoding should always be used
(and that is what Perl does). */
#define UTF_CONTINUATION_BYTE_INFO_BITS UTF_EBCDIC_CONTINUATION_BYTE_INFO_BITS
/* ^? is defined to be APC on EBCDIC systems, as specified in Unicode Technical
* Report #16. See the definition of toCTRL() for more */
#define QUESTION_MARK_CTRL LATIN1_TO_NATIVE(0x9F)
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

285
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/util.h Normal file
View file

@ -0,0 +1,285 @@
/* util.h
*
* Copyright (C) 1991, 1992, 1993, 1999, 2001, 2002, 2003, 2004, 2005,
* 2007, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
*
*/
#ifndef PERL_UTIL_H_
#define PERL_UTIL_H_
#ifdef VMS
# define PERL_FILE_IS_ABSOLUTE(f) \
(*(f) == '/' \
|| (strchr(f,':') \
|| ((*(f) == '[' || *(f) == '<') \
&& (isWORDCHAR((f)[1]) || memCHRs("$-_]>",(f)[1])))))
#elif defined(WIN32) || defined(__CYGWIN__)
# define PERL_FILE_IS_ABSOLUTE(f) \
(*(f) == '/' || *(f) == '\\' /* UNC/rooted path */ \
|| ((f)[0] && (f)[1] == ':')) /* drive name */
#elif defined(DOSISH)
# define PERL_FILE_IS_ABSOLUTE(f) \
(*(f) == '/' \
|| ((f)[0] && (f)[1] == ':')) /* drive name */
#else /* NOT DOSISH */
# define PERL_FILE_IS_ABSOLUTE(f) (*(f) == '/')
#endif
/*
=for apidoc_section $string
=for apidoc ibcmp
This is a synonym for S<C<(! foldEQ())>>
=for apidoc ibcmp_locale
This is a synonym for S<C<(! foldEQ_locale())>>
=for apidoc ibcmp_utf8
This is a synonym for S<C<(! foldEQ_utf8())>>
=cut
*/
#define ibcmp(s1, s2, len) cBOOL(! foldEQ(s1, s2, len))
#define ibcmp_locale(s1, s2, len) cBOOL(! foldEQ_locale(s1, s2, len))
#define ibcmp_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2) \
cBOOL(! foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2))
/* outside the core, perl.h undefs HAS_QUAD if IV isn't 64-bit
We can't swap this to HAS_QUAD, because the logic here affects the type of
perl_drand48_t below, and that is visible outside of the core. */
#if defined(U64TYPE)
/* use a faster implementation when quads are available */
# define PERL_DRAND48_QUAD
#endif
#ifdef PERL_DRAND48_QUAD
/* U64 is only defined under PERL_CORE, but this needs to be visible
* elsewhere so the definition of PerlInterpreter is complete.
*/
typedef U64TYPE perl_drand48_t;
#else
struct PERL_DRAND48_T {
U16 seed[3];
};
typedef struct PERL_DRAND48_T perl_drand48_t;
#endif
#define PL_RANDOM_STATE_TYPE perl_drand48_t
#define Perl_drand48_init(seed) (Perl_drand48_init_r(&PL_random_state, (seed)))
#define Perl_drand48() (Perl_drand48_r(&PL_random_state))
#ifdef PERL_CORE
/* uses a different source of randomness to avoid interfering with the results
* of rand() */
#define Perl_internal_drand48() (Perl_drand48_r(&PL_internal_random_state))
#endif
#ifdef USE_C_BACKTRACE
typedef struct {
/* The number of frames returned. */
UV frame_count;
/* The total size of the Perl_c_backtrace, including this header,
* the frames, and the name strings. */
UV total_bytes;
} Perl_c_backtrace_header;
typedef struct {
void* addr; /* the program counter at this frame */
/* We could use Dl_info (as used by dladdr()) for many of these but
* that would be naughty towards non-dlfcn systems (hi there, Win32). */
void* symbol_addr; /* symbol address (hint: try symbol_addr - addr) */
void* object_base_addr; /* base address of the shared object */
/* The offsets are from the beginning of the whole backtrace,
* which makes the backtrace relocatable. */
STRLEN object_name_offset; /* pathname of the shared object */
STRLEN object_name_size; /* length of the pathname */
STRLEN symbol_name_offset; /* symbol name */
STRLEN symbol_name_size; /* length of the symbol name */
STRLEN source_name_offset; /* source code file name */
STRLEN source_name_size; /* length of the source code file name */
STRLEN source_line_number; /* source code line number */
/* OS X notes: atos(1) (more recently, "xcrun atos"), but the C
* API atos() uses is unknown (private "Symbolicator" framework,
* might require Objective-C even if the API would be known).
* Currently we open read pipe to "xcrun atos" and parse the
* output - quite disgusting. And that won't work if the
* Developer Tools isn't installed. */
/* FreeBSD notes: execinfo.h exists, but probably would need also
* the library -lexecinfo. BFD exists if the pkg devel/binutils
* has been installed, but there seems to be a known problem that
* the "bfd.h" getting installed refers to "ansidecl.h", which
* doesn't get installed. */
/* Win32 notes: as moral equivalents of backtrace() + dladdr(),
* one could possibly first use GetCurrentProcess() +
* SymInitialize(), and then CaptureStackBackTrace() +
* SymFromAddr(). */
/* Note that using the compiler optimizer easily leads into much
* of this information, like the symbol names (think inlining),
* and source code locations getting lost or confused. In many
* cases keeping the debug information (-g) is necessary.
*
* Note that for example with gcc you can do both -O and -g.
*
* Note, however, that on some platforms (e.g. OSX + clang (cc))
* backtrace() + dladdr() works fine without -g. */
/* For example: the mere presence of <bfd.h> is no guarantee: e.g.
* OS X has that, but BFD does not seem to work on the OSX executables.
*
* Another niceness would be to able to see something about
* the function arguments, however gdb/lldb manage to do that. */
} Perl_c_backtrace_frame;
typedef struct {
Perl_c_backtrace_header header;
Perl_c_backtrace_frame frame_info[1];
/* After the header come:
* (1) header.frame_count frames
* (2) frame_count times the \0-terminated strings (object_name
* and so forth). The frames contain the pointers to the starts
* of these strings, and the lengths of these strings. */
} Perl_c_backtrace;
#define Perl_free_c_backtrace(bt) Safefree(bt)
#endif /* USE_C_BACKTRACE */
/* Use a packed 32 bit constant "key" to start the handshake. The key defines
ABI compatibility, and how to process the vararg list.
Note, some bits may be taken from INTRPSIZE (but then a simple x86 AX register
can't be used to read it) and 4 bits from API version len can also be taken,
since v00.00.00 is 9 bytes long. XS version length should not have any bits
taken since XS_VERSION lengths can get quite long since they are user
selectable. These spare bits allow for additional features for the varargs
stuff or ABI compat test flags in the future.
*/
#define HSm_APIVERLEN 0x0000001F /* perl version string won't be more than 31 chars */
#define HS_APIVERLEN_MAX HSm_APIVERLEN
#define HSm_XSVERLEN 0x0000FF00 /* if 0, not present, dont check, die if over 255*/
#define HS_XSVERLEN_MAX 0xFF
/* uses var file to set default filename for newXS_deffile to use for CvFILE */
#define HSf_SETXSUBFN 0x00000020
#define HSf_POPMARK 0x00000040 /* popmark mode or you must supply ax and items */
#define HSf_IMP_CXT 0x00000080 /* ABI, threaded, MULTIPLICITY, pTHX_ present */
#define HSm_INTRPSIZE 0xFFFF0000 /* ABI, interp struct size */
/* A mask of bits in the key which must always match between a XS mod and interp.
Also if all ABI bits in a key are true, skip all ABI checks, it is very
the unlikely interp size will all 1 bits */
/* Maybe HSm_APIVERLEN one day if Perl_xs_apiversion_bootcheck is changed to a memcmp */
#define HSm_KEY_MATCH (HSm_INTRPSIZE|HSf_IMP_CXT)
#define HSf_NOCHK HSm_KEY_MATCH /* if all ABI bits are 1 in the key, dont chk */
#define HS_GETINTERPSIZE(key) ((key) >> 16)
/* if in the future "" and NULL must be separated, XSVERLEN would be 0
means arg not present, 1 is empty string/null byte */
/* (((key) & 0x0000FF00) >> 8) is less efficient on Visual C */
#define HS_GETXSVERLEN(key) ((U8) ((key) >> 8))
#define HS_GETAPIVERLEN(key) ((key) & HSm_APIVERLEN)
/* internal to util.h macro to create a packed handshake key, all args must be constants */
/* U32 return = (U16 interpsize, bool cxt, bool setxsubfn, bool popmark,
U5 (FIVE!) apiverlen, U8 xsverlen) */
#define HS_KEYp(interpsize, cxt, setxsubfn, popmark, apiverlen, xsverlen) \
(((interpsize) << 16) \
| ((xsverlen) > HS_XSVERLEN_MAX \
? (Perl_croak_nocontext("panic: handshake overflow"), HS_XSVERLEN_MAX) \
: (xsverlen) << 8) \
| (cBOOL(setxsubfn) ? HSf_SETXSUBFN : 0) \
| (cBOOL(cxt) ? HSf_IMP_CXT : 0) \
| (cBOOL(popmark) ? HSf_POPMARK : 0) \
| ((apiverlen) > HS_APIVERLEN_MAX \
? (Perl_croak_nocontext("panic: handshake overflow"), HS_APIVERLEN_MAX) \
: (apiverlen)))
/* overflows above will optimize away unless they will execute */
/* public macro for core usage to create a packed handshake key but this is
not public API. This more friendly version already collected all ABI info */
/* U32 return = (bool setxsubfn, bool popmark, "litteral_string_api_ver",
"litteral_string_xs_ver") */
#ifdef MULTIPLICITY
# define HS_KEY(setxsubfn, popmark, apiver, xsver) \
HS_KEYp(sizeof(PerlInterpreter), TRUE, setxsubfn, popmark, \
sizeof("" apiver "")-1, sizeof("" xsver "")-1)
# define HS_CXT aTHX
#else
# define HS_KEY(setxsubfn, popmark, apiver, xsver) \
HS_KEYp(sizeof(struct PerlHandShakeInterpreter), FALSE, setxsubfn, popmark, \
sizeof("" apiver "")-1, sizeof("" xsver "")-1)
# define HS_CXT cv
#endif
/*
=for apidoc instr
Same as L<strstr(3)>, which finds and returns a pointer to the first occurrence
of the NUL-terminated substring C<little> in the NUL-terminated string C<big>,
returning NULL if not found. The terminating NUL bytes are not compared.
=cut
*/
#define instr(haystack, needle) strstr((char *) haystack, (char *) needle)
#ifdef HAS_MEMMEM
# define ninstr(big, bigend, little, lend) \
(__ASSERT_(bigend >= big) \
__ASSERT_(lend >= little) \
(char *) memmem((big), (bigend) - (big), \
(little), (lend) - (little)))
#else
# define ninstr(a,b,c,d) Perl_ninstr(a,b,c,d)
#endif
#ifdef __Lynx__
/* Missing proto on LynxOS */
int mkstemp(char*);
#endif
#ifdef PERL_CORE
# if defined(VMS)
/* only useful for calls to our mkostemp() emulation */
# define O_VMS_DELETEONCLOSE 0x40000000
# ifdef HAS_MKOSTEMP
# error 134221 will need a new solution for VMS
# endif
# else
# define O_VMS_DELETEONCLOSE 0
# endif
#endif
#if defined(HAS_MKOSTEMP) && defined(PERL_CORE)
# define Perl_my_mkostemp(templte, flags) mkostemp(templte, flags)
#endif
#if defined(HAS_MKSTEMP) && defined(PERL_CORE)
# define Perl_my_mkstemp(templte) mkstemp(templte)
#endif
#endif /* PERL_UTIL_H_ */
/*
* ex: set ts=8 sts=4 sw=4 et:
*/

23
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/uudmap.h Normal file
View file

@ -0,0 +1,23 @@
/* uudmap.h:
* THIS FILE IS AUTO-GENERATED DURING THE BUILD by: ./generate_uudmap
*
* These values will populate PL_uumap[], as used by unpack('u')
*/
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}

114
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/vutil.h Normal file
View file

@ -0,0 +1,114 @@
/* This file is part of the "version" CPAN distribution. Please avoid
editing it in the perl core. */
/* The MUTABLE_*() macros cast pointers to the types shown, in such a way
* (compiler permitting) that casting away const-ness will give a warning;
* e.g.:
*
* const SV *sv = ...;
* AV *av1 = (AV*)sv; <== BAD: the const has been silently cast away
* AV *av2 = MUTABLE_AV(sv); <== GOOD: it may warn
*/
#if PERL_VERSION_LT(5,15,4)
# define ISA_VERSION_OBJ(v) (sv_isobject(v) && sv_derived_from(v,"version"))
#else
# define ISA_VERSION_OBJ(v) (sv_isobject(v) && sv_derived_from_pvn(v,"version",7,0))
#endif
#if PERL_VERSION_GE(5,9,0) && !defined(PERL_CORE)
# define VUTIL_REPLACE_CORE 1
static const char * Perl_scan_version2(pTHX_ const char *s, SV *rv, bool qv);
static SV * Perl_new_version2(pTHX_ SV *ver);
static SV * Perl_upg_version2(pTHX_ SV *sv, bool qv);
static SV * Perl_vstringify2(pTHX_ SV *vs);
static SV * Perl_vverify2(pTHX_ SV *vs);
static SV * Perl_vnumify2(pTHX_ SV *vs);
static SV * Perl_vnormal2(pTHX_ SV *vs);
static SV * Perl_vstringify2(pTHX_ SV *vs);
static int Perl_vcmp2(pTHX_ SV *lsv, SV *rsv);
static const char * Perl_prescan_version2(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha);
# define SCAN_VERSION(a,b,c) Perl_scan_version2(aTHX_ a,b,c)
# define NEW_VERSION(a) Perl_new_version2(aTHX_ a)
# define UPG_VERSION(a,b) Perl_upg_version2(aTHX_ a, b)
# define VSTRINGIFY(a) Perl_vstringify2(aTHX_ a)
# define VVERIFY(a) Perl_vverify2(aTHX_ a)
# define VNUMIFY(a) Perl_vnumify2(aTHX_ a)
# define VNORMAL(a) Perl_vnormal2(aTHX_ a)
# define VCMP(a,b) Perl_vcmp2(aTHX_ a,b)
# define PRESCAN_VERSION(a,b,c,d,e,f,g) Perl_prescan_version2(aTHX_ a,b,c,d,e,f,g)
# undef is_LAX_VERSION
# define is_LAX_VERSION(a,b) \
(a != Perl_prescan_version2(aTHX_ a, FALSE, b, NULL, NULL, NULL, NULL))
# undef is_STRICT_VERSION
# define is_STRICT_VERSION(a,b) \
(a != Perl_prescan_version2(aTHX_ a, TRUE, b, NULL, NULL, NULL, NULL))
#else
const char * Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv);
SV * Perl_new_version(pTHX_ SV *ver);
SV * Perl_upg_version(pTHX_ SV *sv, bool qv);
SV * Perl_vverify(pTHX_ SV *vs);
SV * Perl_vnumify(pTHX_ SV *vs);
SV * Perl_vnormal(pTHX_ SV *vs);
SV * Perl_vstringify(pTHX_ SV *vs);
int Perl_vcmp(pTHX_ SV *lsv, SV *rsv);
const char * Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha);
# define SCAN_VERSION(a,b,c) Perl_scan_version(aTHX_ a,b,c)
# define NEW_VERSION(a) Perl_new_version(aTHX_ a)
# define UPG_VERSION(a,b) Perl_upg_version(aTHX_ a, b)
# define VSTRINGIFY(a) Perl_vstringify(aTHX_ a)
# define VVERIFY(a) Perl_vverify(aTHX_ a)
# define VNUMIFY(a) Perl_vnumify(aTHX_ a)
# define VNORMAL(a) Perl_vnormal(aTHX_ a)
# define VCMP(a,b) Perl_vcmp(aTHX_ a,b)
# define PRESCAN_VERSION(a,b,c,d,e,f,g) Perl_prescan_version(aTHX_ a,b,c,d,e,f,g)
# ifndef is_LAX_VERSION
# define is_LAX_VERSION(a,b) \
(a != Perl_prescan_version(aTHX_ a, FALSE, b, NULL, NULL, NULL, NULL))
# endif
# ifndef is_STRICT_VERSION
# define is_STRICT_VERSION(a,b) \
(a != Perl_prescan_version(aTHX_ a, TRUE, b, NULL, NULL, NULL, NULL))
# endif
#endif
#if PERL_VERSION_LT(5,11,4)
# define BADVERSION(a,b,c) \
if (b) { \
*b = c; \
} \
return a;
# define PERL_ARGS_ASSERT_PRESCAN_VERSION \
assert(s); assert(sqv); assert(ssaw_decimal);\
assert(swidth); assert(salpha);
# define PERL_ARGS_ASSERT_SCAN_VERSION \
assert(s); assert(rv)
# define PERL_ARGS_ASSERT_NEW_VERSION \
assert(ver)
# define PERL_ARGS_ASSERT_UPG_VERSION \
assert(ver)
# define PERL_ARGS_ASSERT_VVERIFY \
assert(vs)
# define PERL_ARGS_ASSERT_VNUMIFY \
assert(vs)
# define PERL_ARGS_ASSERT_VNORMAL \
assert(vs)
# define PERL_ARGS_ASSERT_VSTRINGIFY \
assert(vs)
# define PERL_ARGS_ASSERT_VCMP \
assert(lhv); assert(rhv)
# define PERL_ARGS_ASSERT_CK_WARNER \
assert(pat)
#endif
/* ex: set ro: */

368
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/warnings.h Normal file
View file

@ -0,0 +1,368 @@
/* -*- mode: C; buffer-read-only: t -*-
!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
This file is built by regen/warnings.pl.
Any changes made here will be lost!
*/
#define Perl_Warn_Off_(x) ((x) / 8)
#define Perl_Warn_Bit_(x) (1 << ((x) % 8))
#define PerlWarnIsSet_(a, x) ((a)[Perl_Warn_Off_(x)] & Perl_Warn_Bit_(x))
#define G_WARN_OFF 0 /* $^W == 0 */
#define G_WARN_ON 1 /* -w flag and $^W != 0 */
#define G_WARN_ALL_ON 2 /* -W flag */
#define G_WARN_ALL_OFF 4 /* -X flag */
#define G_WARN_ONCE 8 /* set if 'once' ever enabled */
#define G_WARN_ALL_MASK (G_WARN_ALL_ON|G_WARN_ALL_OFF)
#define pWARN_STD NULL
#define pWARN_ALL &PL_WARN_ALL /* use warnings 'all' */
#define pWARN_NONE &PL_WARN_NONE /* no warnings 'all' */
#define specialWARN(x) ((x) == pWARN_STD || (x) == pWARN_ALL || \
(x) == pWARN_NONE)
/* if PL_warnhook is set to this value, then warnings die */
#define PERL_WARNHOOK_FATAL (&PL_sv_placeholder)
/* Warnings Categories added in Perl 5.008 */
#define WARN_ALL 0
#define WARN_CLOSURE 1
#define WARN_DEPRECATED 2
#define WARN_EXITING 3
#define WARN_GLOB 4
#define WARN_IO 5
#define WARN_CLOSED 6
#define WARN_EXEC 7
#define WARN_LAYER 8
#define WARN_NEWLINE 9
#define WARN_PIPE 10
#define WARN_UNOPENED 11
#define WARN_MISC 12
#define WARN_NUMERIC 13
#define WARN_ONCE 14
#define WARN_OVERFLOW 15
#define WARN_PACK 16
#define WARN_PORTABLE 17
#define WARN_RECURSION 18
#define WARN_REDEFINE 19
#define WARN_REGEXP 20
#define WARN_SEVERE 21
#define WARN_DEBUGGING 22
#define WARN_INPLACE 23
#define WARN_INTERNAL 24
#define WARN_MALLOC 25
#define WARN_SIGNAL 26
#define WARN_SUBSTR 27
#define WARN_SYNTAX 28
#define WARN_AMBIGUOUS 29
#define WARN_BAREWORD 30
#define WARN_DIGIT 31
#define WARN_PARENTHESIS 32
#define WARN_PRECEDENCE 33
#define WARN_PRINTF 34
#define WARN_PROTOTYPE 35
#define WARN_QW 36
#define WARN_RESERVED 37
#define WARN_SEMICOLON 38
#define WARN_TAINT 39
#define WARN_THREADS 40
#define WARN_UNINITIALIZED 41
#define WARN_UNPACK 42
#define WARN_UNTIE 43
#define WARN_UTF8 44
#define WARN_VOID 45
/* Warnings Categories added in Perl 5.011 */
#define WARN_IMPRECISION 46
#define WARN_ILLEGALPROTO 47
/* Warnings Categories added in Perl 5.011003 */
#define WARN_DEPRECATED__GOTO_CONSTRUCT 48
#define WARN_DEPRECATED__UNICODE_PROPERTY_NAME 49
/* Warnings Categories added in Perl 5.013 */
#define WARN_NON_UNICODE 50
#define WARN_NONCHAR 51
#define WARN_SURROGATE 52
/* Warnings Categories added in Perl 5.017 */
#define WARN_EXPERIMENTAL 53
#define WARN_EXPERIMENTAL__REGEX_SETS 54
/* Warnings Categories added in Perl 5.019 */
#define WARN_SYSCALLS 55
/* Warnings Categories added in Perl 5.021 */
#define WARN_EXPERIMENTAL__RE_STRICT 56
#define WARN_EXPERIMENTAL__REFALIASING 57
#define WARN_LOCALE 58
#define WARN_MISSING 59
#define WARN_REDUNDANT 60
/* Warnings Categories added in Perl 5.025 */
#define WARN_EXPERIMENTAL__DECLARED_REFS 61
/* Warnings Categories added in Perl 5.025011 */
#define WARN_DEPRECATED__DOT_IN_INC 62
/* Warnings Categories added in Perl 5.027 */
#define WARN_SHADOW 63
/* Warnings Categories added in Perl 5.029 */
#define WARN_EXPERIMENTAL__PRIVATE_USE 64
#define WARN_EXPERIMENTAL__UNIPROP_WILDCARDS 65
#define WARN_EXPERIMENTAL__VLB 66
/* Warnings Categories added in Perl 5.033 */
#define WARN_EXPERIMENTAL__TRY 67
/* Warnings Categories added in Perl 5.035 */
#define WARN_EXPERIMENTAL__ARGS_ARRAY_WITH_SIGNATURES 68
#define WARN_EXPERIMENTAL__BUILTIN 69
#define WARN_EXPERIMENTAL__DEFER 70
#define WARN_EXPERIMENTAL__EXTRA_PAIRED_DELIMITERS 71
#define WARN_SCALAR 72
/* Warnings Categories added in Perl 5.035009 */
#define WARN_DEPRECATED__VERSION_DOWNGRADE 73
/* Warnings Categories added in Perl 5.03501 */
#define WARN_DEPRECATED__DELIMITER_WILL_BE_PAIRED 74
/* Warnings Categories added in Perl 5.037 */
#define WARN_EXPERIMENTAL__CLASS 75
/* Warnings Categories added in Perl 5.037009 */
#define WARN_DEPRECATED__APOSTROPHE_AS_PACKAGE_SEPARATOR 76
/* Warnings Categories added in Perl 5.03701 */
#define WARN_DEPRECATED__SMARTMATCH 77
/* Warnings Categories added in Perl 5.039002 */
#define WARN_DEPRECATED__MISSING_IMPORT_CALLED_WITH_ARGS 78
/* Warnings Categories added in Perl 5.039008 */
#define WARN_DEPRECATED__SUBSEQUENT_USE_VERSION 79
#define WARNsize 20
#define WARN_ALLstring "\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125"
#define WARN_NONEstring "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
#define isLEXWARN_on \
cBOOL(PL_curcop && PL_curcop->cop_warnings != pWARN_STD)
#define isLEXWARN_off \
cBOOL(!PL_curcop || PL_curcop->cop_warnings == pWARN_STD)
#define isWARN_ONCE (PL_dowarn & (G_WARN_ON|G_WARN_ONCE))
#define hasWARNBIT(c,x) (RCPV_LEN(c) > (2*(x)/8))
#define isWARN_on(c,x) (hasWARNBIT(c,x) \
? PerlWarnIsSet_((U8 *)(c), 2*(x)) \
: 0)
#define isWARNf_on(c,x) (hasWARNBIT(c,x) \
? PerlWarnIsSet_((U8 *)(c), 2*(x)+1) \
: 0)
#define DUP_WARNINGS(p) Perl_dup_warnings(aTHX_ p)
#define free_and_set_cop_warnings(cmp,w) STMT_START { \
if (!specialWARN((cmp)->cop_warnings)) rcpv_free((cmp)->cop_warnings); \
(cmp)->cop_warnings = w; \
} STMT_END
/*
=head1 Warning and Dieing
In all these calls, the C<U32 wI<n>> parameters are warning category
constants. You can see the ones currently available in
L<warnings/Category Hierarchy>, just capitalize all letters in the names
and prefix them by C<WARN_>. So, for example, the category C<void> used in a
perl program becomes C<WARN_VOID> when used in XS code and passed to one of
the calls below.
=for apidoc Am|bool|ckWARN|U32 w
=for apidoc_item ||ckWARN2|U32 w1|U32 w2
=for apidoc_item ||ckWARN3|U32 w1|U32 w2|U32 w3
=for apidoc_item ||ckWARN4|U32 w1|U32 w2|U32 w3|U32 w4
These return a boolean as to whether or not warnings are enabled for any of
the warning category(ies) parameters: C<w>, C<w1>, ....
Should any of the categories by default be enabled even if not within the
scope of S<C<use warnings>>, instead use the C<L</ckWARN_d>> macros.
The categories must be completely independent, one may not be subclassed from
the other.
=for apidoc Am|bool|ckWARN_d|U32 w
=for apidoc_item ||ckWARN2_d|U32 w1|U32 w2
=for apidoc_item ||ckWARN3_d|U32 w1|U32 w2|U32 w3
=for apidoc_item ||ckWARN4_d|U32 w1|U32 w2|U32 w3|U32 w4
Like C<L</ckWARN>>, but for use if and only if the warning category(ies) is by
default enabled even if not within the scope of S<C<use warnings>>.
=for apidoc Am|U32|packWARN|U32 w1
=for apidoc_item ||packWARN2|U32 w1|U32 w2
=for apidoc_item ||packWARN3|U32 w1|U32 w2|U32 w3
=for apidoc_item ||packWARN4|U32 w1|U32 w2|U32 w3|U32 w4
These macros are used to pack warning categories into a single U32 to pass to
macros and functions that take a warning category parameter. The number of
categories to pack is given by the name, with a corresponding number of
category parameters passed.
=cut
*/
#define ckWARN(w) Perl_ckwarn(aTHX_ packWARN(w))
/* The w1, w2 ... should be independent warnings categories; one shouldn't be
* a subcategory of any other */
#define ckWARN2(w1,w2) Perl_ckwarn(aTHX_ packWARN2(w1,w2))
#define ckWARN3(w1,w2,w3) Perl_ckwarn(aTHX_ packWARN3(w1,w2,w3))
#define ckWARN4(w1,w2,w3,w4) Perl_ckwarn(aTHX_ packWARN4(w1,w2,w3,w4))
#define ckWARN_d(w) Perl_ckwarn_d(aTHX_ packWARN(w))
#define ckWARN2_d(w1,w2) Perl_ckwarn_d(aTHX_ packWARN2(w1,w2))
#define ckWARN3_d(w1,w2,w3) Perl_ckwarn_d(aTHX_ packWARN3(w1,w2,w3))
#define ckWARN4_d(w1,w2,w3,w4) Perl_ckwarn_d(aTHX_ packWARN4(w1,w2,w3,w4))
#define WARNshift 8
#define packWARN(a) (a )
/* The a, b, ... should be independent warnings categories; one shouldn't be
* a subcategory of any other */
#define packWARN2(a,b) ((a) | ((b)<<8) )
#define packWARN3(a,b,c) ((a) | ((b)<<8) | ((c)<<16) )
#define packWARN4(a,b,c,d) ((a) | ((b)<<8) | ((c)<<16) | ((d) <<24))
#define unpackWARN1(x) ((U8) (x) )
#define unpackWARN2(x) ((U8) ((x) >> 8))
#define unpackWARN3(x) ((U8) ((x) >> 16))
#define unpackWARN4(x) ((U8) ((x) >> 24))
#define ckDEAD(x) \
(PL_curcop && \
!specialWARN(PL_curcop->cop_warnings) && \
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN1(x)) || \
(unpackWARN2(x) && \
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN2(x)) || \
(unpackWARN3(x) && \
(isWARNf_on(PL_curcop->cop_warnings, unpackWARN3(x)) || \
(unpackWARN4(x) && \
isWARNf_on(PL_curcop->cop_warnings, unpackWARN4(x)))))))))
/*
=for apidoc Amnh||WARN_ALL
=for apidoc Amnh||WARN_CLOSURE
=for apidoc Amnh||WARN_DEPRECATED
=for apidoc Amnh||WARN_EXITING
=for apidoc Amnh||WARN_GLOB
=for apidoc Amnh||WARN_IO
=for apidoc Amnh||WARN_CLOSED
=for apidoc Amnh||WARN_EXEC
=for apidoc Amnh||WARN_LAYER
=for apidoc Amnh||WARN_NEWLINE
=for apidoc Amnh||WARN_PIPE
=for apidoc Amnh||WARN_UNOPENED
=for apidoc Amnh||WARN_MISC
=for apidoc Amnh||WARN_NUMERIC
=for apidoc Amnh||WARN_ONCE
=for apidoc Amnh||WARN_OVERFLOW
=for apidoc Amnh||WARN_PACK
=for apidoc Amnh||WARN_PORTABLE
=for apidoc Amnh||WARN_RECURSION
=for apidoc Amnh||WARN_REDEFINE
=for apidoc Amnh||WARN_REGEXP
=for apidoc Amnh||WARN_SEVERE
=for apidoc Amnh||WARN_DEBUGGING
=for apidoc Amnh||WARN_INPLACE
=for apidoc Amnh||WARN_INTERNAL
=for apidoc Amnh||WARN_MALLOC
=for apidoc Amnh||WARN_SIGNAL
=for apidoc Amnh||WARN_SUBSTR
=for apidoc Amnh||WARN_SYNTAX
=for apidoc Amnh||WARN_AMBIGUOUS
=for apidoc Amnh||WARN_BAREWORD
=for apidoc Amnh||WARN_DIGIT
=for apidoc Amnh||WARN_PARENTHESIS
=for apidoc Amnh||WARN_PRECEDENCE
=for apidoc Amnh||WARN_PRINTF
=for apidoc Amnh||WARN_PROTOTYPE
=for apidoc Amnh||WARN_QW
=for apidoc Amnh||WARN_RESERVED
=for apidoc Amnh||WARN_SEMICOLON
=for apidoc Amnh||WARN_TAINT
=for apidoc Amnh||WARN_THREADS
=for apidoc Amnh||WARN_UNINITIALIZED
=for apidoc Amnh||WARN_UNPACK
=for apidoc Amnh||WARN_UNTIE
=for apidoc Amnh||WARN_UTF8
=for apidoc Amnh||WARN_VOID
=for apidoc Amnh||WARN_IMPRECISION
=for apidoc Amnh||WARN_ILLEGALPROTO
=for apidoc Amnh||WARN_DEPRECATED__GOTO_CONSTRUCT
=for apidoc Amnh||WARN_DEPRECATED__UNICODE_PROPERTY_NAME
=for apidoc Amnh||WARN_NON_UNICODE
=for apidoc Amnh||WARN_NONCHAR
=for apidoc Amnh||WARN_SURROGATE
=for apidoc Amnh||WARN_EXPERIMENTAL
=for apidoc Amnh||WARN_EXPERIMENTAL__REGEX_SETS
=for apidoc Amnh||WARN_SYSCALLS
=for apidoc Amnh||WARN_EXPERIMENTAL__RE_STRICT
=for apidoc Amnh||WARN_EXPERIMENTAL__REFALIASING
=for apidoc Amnh||WARN_LOCALE
=for apidoc Amnh||WARN_MISSING
=for apidoc Amnh||WARN_REDUNDANT
=for apidoc Amnh||WARN_EXPERIMENTAL__DECLARED_REFS
=for apidoc Amnh||WARN_DEPRECATED__DOT_IN_INC
=for apidoc Amnh||WARN_SHADOW
=for apidoc Amnh||WARN_EXPERIMENTAL__PRIVATE_USE
=for apidoc Amnh||WARN_EXPERIMENTAL__UNIPROP_WILDCARDS
=for apidoc Amnh||WARN_EXPERIMENTAL__VLB
=for apidoc Amnh||WARN_EXPERIMENTAL__TRY
=for apidoc Amnh||WARN_EXPERIMENTAL__ARGS_ARRAY_WITH_SIGNATURES
=for apidoc Amnh||WARN_EXPERIMENTAL__BUILTIN
=for apidoc Amnh||WARN_EXPERIMENTAL__DEFER
=for apidoc Amnh||WARN_EXPERIMENTAL__EXTRA_PAIRED_DELIMITERS
=for apidoc Amnh||WARN_SCALAR
=for apidoc Amnh||WARN_DEPRECATED__VERSION_DOWNGRADE
=for apidoc Amnh||WARN_DEPRECATED__DELIMITER_WILL_BE_PAIRED
=for apidoc Amnh||WARN_EXPERIMENTAL__CLASS
=for apidoc Amnh||WARN_DEPRECATED__APOSTROPHE_AS_PACKAGE_SEPARATOR
=for apidoc Amnh||WARN_DEPRECATED__SMARTMATCH
=for apidoc Amnh||WARN_DEPRECATED__MISSING_IMPORT_CALLED_WITH_ARGS
=for apidoc Amnh||WARN_DEPRECATED__SUBSEQUENT_USE_VERSION
=cut
*/
/* end of file warnings.h */
/* ex: set ro ft=c: */

292
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/CORE/zaphod32_hash.h Normal file
View file

@ -0,0 +1,292 @@
#ifndef DEBUG_ZAPHOD32_HASH
#define DEBUG_ZAPHOD32_HASH 0
#if DEBUG_ZAPHOD32_HASH == 1
#include <stdio.h>
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5) printf(pat, v0, v1, v2, v3, v4, v5)
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4) printf(pat, v0, v1, v2, v3, v4)
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3) printf(pat, v0, v1, v2, v3)
#define ZAPHOD32_WARN3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
#define ZAPHOD32_WARN2(pat,v0,v1) printf(pat, v0, v1)
#define NOTE3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
#elif DEBUG_ZAPHOD32_HASH == 2
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5)
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4)
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3)
#define ZAPHOD32_WARN3(pat,v0,v1,v2)
#define ZAPHOD32_WARN2(pat,v0,v1)
#define NOTE3(pat,v0,v1,v2) printf(pat, v0, v1, v2)
#else
#define ZAPHOD32_WARN6(pat,v0,v1,v2,v3,v4,v5)
#define ZAPHOD32_WARN5(pat,v0,v1,v2,v3,v4)
#define ZAPHOD32_WARN4(pat,v0,v1,v2,v3)
#define ZAPHOD32_WARN3(pat,v0,v1,v2)
#define NOTE3(pat,v0,v1,v2)
#define ZAPHOD32_WARN2(pat,v0,v1)
#endif
/* Find best way to ROTL32/ROTL64 */
#ifndef ROTL32
#if defined(_MSC_VER)
#include <stdlib.h> /* Microsoft put _rotl declaration in here */
#define ROTL32(x,r) _rotl(x,r)
#define ROTR32(x,r) _rotr(x,r)
#else
/* gcc recognises this code and generates a rotate instruction for CPUs with one */
#define ROTL32(x,r) (((U32)(x) << (r)) | ((U32)(x) >> (32 - (r))))
#define ROTR32(x,r) (((U32)(x) << (32 - (r))) | ((U32)(x) >> (r)))
#endif
#endif
#ifndef PERL_SEEN_HV_FUNC_H_
#if !defined(U64)
#include <stdint.h>
#define U64 uint64_t
#endif
#if !defined(U32)
#define U32 uint32_t
#endif
#if !defined(U8)
#define U8 unsigned char
#endif
#if !defined(U16)
#define U16 uint16_t
#endif
#ifndef STRLEN
#define STRLEN int
#endif
#endif
#ifndef ZAPHOD32_STATIC_INLINE
#ifdef PERL_STATIC_INLINE
#define ZAPHOD32_STATIC_INLINE PERL_STATIC_INLINE
#else
#define ZAPHOD32_STATIC_INLINE static inline
#endif
#endif
#ifndef STMT_START
#define STMT_START do
#define STMT_END while(0)
#endif
/* This is two marsaglia xor-shift permutes, with a prime-multiple
* sandwiched inside. The end result of doing this twice with different
* primes is a completely avalanched v. */
#define ZAPHOD32_SCRAMBLE32(v,prime) STMT_START { \
v ^= (v>>9); \
v ^= (v<<21); \
v ^= (v>>16); \
v *= prime; \
v ^= (v>>17); \
v ^= (v<<15); \
v ^= (v>>23); \
} STMT_END
#define ZAPHOD32_FINALIZE(v0,v1,v2) STMT_START { \
ZAPHOD32_WARN3("v0=%08x v1=%08x v2=%08x - ZAPHOD32 FINALIZE\n", \
(unsigned int)v0, (unsigned int)v1, (unsigned int)v2); \
v2 += v0; \
v1 -= v2; \
v1 = ROTL32(v1, 6); \
v2 ^= v1; \
v2 = ROTL32(v2, 28); \
v1 ^= v2; \
v0 += v1; \
v1 = ROTL32(v1, 24); \
v2 += v1; \
v2 = ROTL32(v2, 18) + v1; \
v0 ^= v2; \
v0 = ROTL32(v0, 20); \
v2 += v0; \
v1 ^= v2; \
v0 += v1; \
v0 = ROTL32(v0, 5); \
v2 += v0; \
v2 = ROTL32(v2, 22); \
v0 -= v1; \
v1 -= v2; \
v1 = ROTL32(v1, 17); \
} STMT_END
#define ZAPHOD32_MIX(v0,v1,v2,text) STMT_START { \
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x - ZAPHOD32 %s MIX\n", \
(unsigned int)v0,(unsigned int)v1,(unsigned int)v2, text ); \
v0 = ROTL32(v0,16) - v2; \
v1 = ROTR32(v1,13) ^ v2; \
v2 = ROTL32(v2,17) + v1; \
v0 = ROTR32(v0, 2) + v1; \
v1 = ROTR32(v1,17) - v0; \
v2 = ROTR32(v2, 7) ^ v0; \
} STMT_END
ZAPHOD32_STATIC_INLINE
void zaphod32_seed_state (
const U8 *seed_ch,
U8 *state_ch
) {
const U32 *seed= (const U32 *)seed_ch;
U32 *state= (U32 *)state_ch;
/* hex expansion of PI, skipping first two digits. PI= 3.2[43f6...]
*
* PI value in hex from here:
*
* http://turner.faculty.swau.edu/mathematics/materialslibrary/pi/pibases.html
*
* Ensure that the three state vectors are nonzero regardless of
* the seed. The idea of these two steps is to ensure that the 0
* state comes from a seed utterly unlike that of the value we
* replace it with.
*/
state[0]= seed[0] ^ 0x43f6a888;
state[1]= seed[1] ^ 0x5a308d31;
state[2]= seed[2] ^ 0x3198a2e0;
if (!state[0]) state[0] = 1;
if (!state[1]) state[1] = 2;
if (!state[2]) state[2] = 4;
/* these are pseudo-randomly selected primes between 2**31 and 2**32
* (I generated a big list and then randomly chose some from the list) */
ZAPHOD32_SCRAMBLE32(state[0],0x9fade23b);
ZAPHOD32_SCRAMBLE32(state[1],0xaa6f908d);
ZAPHOD32_SCRAMBLE32(state[2],0xcdf6b72d);
/* now that we have scrambled we do some mixing to avalanche the
* state bits to gether */
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 1/4");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 2/4");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 3/4");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE A 4/4");
/* and then scramble them again with different primes */
ZAPHOD32_SCRAMBLE32(state[0],0xc95d22a9);
ZAPHOD32_SCRAMBLE32(state[1],0x8497242b);
ZAPHOD32_SCRAMBLE32(state[2],0x9c5cc4e9);
/* and a thorough final mix */
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 1/5");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 2/5");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 3/5");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 4/5");
ZAPHOD32_MIX(state[0],state[1],state[2],"ZAPHOD32 SEED-STATE B 5/5");
}
ZAPHOD32_STATIC_INLINE
U32 zaphod32_hash_with_state(
const U8 *state_ch,
const U8 *key,
const STRLEN key_len
) {
const U32 *state= (const U32 *)state_ch;
const U8 *end;
STRLEN len = key_len;
U32 v0= state[0];
U32 v1= state[1];
U32 v2= state[2] ^ (0xC41A7AB1 * ((U32)key_len + 1));
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x ln=%08x HASH START\n",
(unsigned int)state[0], (unsigned int)state[1],
(unsigned int)state[2], (unsigned int)key_len);
{
switch (len) {
default: goto zaphod32_read8;
case 12: v2 += (U32)key[11] << 24; /* FALLTHROUGH */
case 11: v2 += (U32)key[10] << 16; /* FALLTHROUGH */
case 10: v2 += (U32)U8TO16_LE(key+8);
v1 -= U8TO32_LE(key+4);
v0 += U8TO32_LE(key+0);
goto zaphod32_finalize;
case 9: v2 += (U32)key[8]; /* FALLTHROUGH */
case 8: v1 -= U8TO32_LE(key+4);
v0 += U8TO32_LE(key+0);
goto zaphod32_finalize;
case 7: v2 += (U32)key[6]; /* FALLTHROUGH */
case 6: v0 += (U32)U8TO16_LE(key+4);
v1 -= U8TO32_LE(key+0);
goto zaphod32_finalize;
case 5: v0 += (U32)key[4]; /* FALLTHROUGH */
case 4: v1 -= U8TO32_LE(key+0);
goto zaphod32_finalize;
case 3: v2 += (U32)key[2]; /* FALLTHROUGH */
case 2: v0 += (U32)U8TO16_LE(key);
break;
case 1: v0 += (U32)key[0];
break;
case 0: v2 ^= 0xFF;
break;
}
v0 -= v2;
v2 = ROTL32(v2, 8) ^ v0;
v0 = ROTR32(v0,16) + v2;
v2 += v0;
v0 += v0 >> 9;
v0 += v2;
v2 ^= v0;
v2 += v2 << 4;
v0 -= v2;
v2 = ROTR32(v2, 8) ^ v0;
v0 = ROTL32(v0,16) ^ v2;
v2 = ROTL32(v2,10) + v0;
v0 = ROTR32(v0,30) + v2;
v2 = ROTR32(v2,12);
return v0 ^ v2;
}
/* if (len >= 8) */ /* this block is only reached by a goto above, so this condition
is commented out, but if the above block is removed it would
be necessary to use this. */
{
zaphod32_read8:
len = key_len & 0x7;
end = key + key_len - len;
do {
v1 -= U8TO32_LE(key+0);
v0 += U8TO32_LE(key+4);
ZAPHOD32_MIX(v0,v1,v2,"MIX 2-WORDS A");
key += 8;
} while ( key < end );
}
if ( len >= 4 ) {
v1 -= U8TO32_LE(key);
key += 4;
}
v0 += (U32)(key_len) << 24;
switch (len & 0x3) {
case 3: v2 += (U32)key[2]; /* FALLTHROUGH */
case 2: v0 += (U32)U8TO16_LE(key);
break;
case 1: v0 += (U32)key[0];
break;
case 0: v2 ^= 0xFF;
break;
}
zaphod32_finalize:
ZAPHOD32_FINALIZE(v0,v1,v2);
ZAPHOD32_WARN4("v0=%08x v1=%08x v2=%08x hh=%08x - FINAL\n\n",
(unsigned int)v0, (unsigned int)v1, (unsigned int)v2,
(unsigned int)v0 ^ v1 ^ v2);
return v0 ^ v1 ^ v2;
}
ZAPHOD32_STATIC_INLINE U32 zaphod32_hash(
const U8 *seed_ch,
const U8 *key,
const STRLEN key_len
) {
U32 state[3];
zaphod32_seed_state(seed_ch,(U8*)state);
return zaphod32_hash_with_state((U8*)state,key,key_len);
}
#endif

390
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Compress/Raw/Bzip2.pm Normal file
View file

@ -0,0 +1,390 @@
package Compress::Raw::Bzip2;
use strict ;
use warnings ;
require 5.006 ;
require Exporter;
use Carp ;
use bytes ;
our ($VERSION, $XS_VERSION, @ISA, @EXPORT, $AUTOLOAD);
$VERSION = '2.212';
$XS_VERSION = $VERSION;
$VERSION = eval $VERSION;
@ISA = qw(Exporter);
# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.
@EXPORT = qw(
BZ_RUN
BZ_FLUSH
BZ_FINISH
BZ_OK
BZ_RUN_OK
BZ_FLUSH_OK
BZ_FINISH_OK
BZ_STREAM_END
BZ_SEQUENCE_ERROR
BZ_PARAM_ERROR
BZ_MEM_ERROR
BZ_DATA_ERROR
BZ_DATA_ERROR_MAGIC
BZ_IO_ERROR
BZ_UNEXPECTED_EOF
BZ_OUTBUFF_FULL
BZ_CONFIG_ERROR
);
sub AUTOLOAD {
my($constname);
($constname = $AUTOLOAD) =~ s/.*:://;
my ($error, $val) = constant($constname);
Carp::croak $error if $error;
no strict 'refs';
*{$AUTOLOAD} = sub { $val };
goto &{$AUTOLOAD};
}
use constant FLAG_APPEND => 1 ;
use constant FLAG_CRC => 2 ;
use constant FLAG_ADLER => 4 ;
use constant FLAG_CONSUME_INPUT => 8 ;
eval {
require XSLoader;
XSLoader::load('Compress::Raw::Bzip2', $XS_VERSION);
1;
}
or do {
require DynaLoader;
local @ISA = qw(DynaLoader);
bootstrap Compress::Raw::Bzip2 $XS_VERSION ;
};
#sub Compress::Raw::Bzip2::new
#{
# my $class = shift ;
# my ($ptr, $status) = _new(@_);
# return wantarray ? (undef, $status) : undef
# unless $ptr ;
# my $obj = bless [$ptr], $class ;
# return wantarray ? ($obj, $status) : $obj;
#}
#
#package Compress::Raw::Bunzip2 ;
#
#sub Compress::Raw::Bunzip2::new
#{
# my $class = shift ;
# my ($ptr, $status) = _new(@_);
# return wantarray ? (undef, $status) : undef
# unless $ptr ;
# my $obj = bless [$ptr], $class ;
# return wantarray ? ($obj, $status) : $obj;
#}
sub Compress::Raw::Bzip2::STORABLE_freeze
{
my $type = ref shift;
croak "Cannot freeze $type object\n";
}
sub Compress::Raw::Bzip2::STORABLE_thaw
{
my $type = ref shift;
croak "Cannot thaw $type object\n";
}
sub Compress::Raw::Bunzip2::STORABLE_freeze
{
my $type = ref shift;
croak "Cannot freeze $type object\n";
}
sub Compress::Raw::Bunzip2::STORABLE_thaw
{
my $type = ref shift;
croak "Cannot thaw $type object\n";
}
package Compress::Raw::Bzip2;
1;
__END__
=head1 NAME
Compress::Raw::Bzip2 - Low-Level Interface to bzip2 compression library
=head1 SYNOPSIS
use Compress::Raw::Bzip2 ;
my ($bz, $status) = new Compress::Raw::Bzip2 [OPTS]
or die "Cannot create bzip2 object: $bzerno\n";
$status = $bz->bzdeflate($input, $output);
$status = $bz->bzflush($output);
$status = $bz->bzclose($output);
my ($bz, $status) = new Compress::Raw::Bunzip2 [OPTS]
or die "Cannot create bunzip2 object: $bzerno\n";
$status = $bz->bzinflate($input, $output);
my $version = Compress::Raw::Bzip2::bzlibversion();
=head1 DESCRIPTION
C<Compress::Raw::Bzip2> provides an interface to the in-memory
compression/uncompression functions from the bzip2 compression library.
Although the primary purpose for the existence of C<Compress::Raw::Bzip2>
is for use by the C<IO::Compress::Bzip2> and C<IO::Compress::Bunzip2>
modules, it can be used on its own for simple compression/uncompression
tasks.
=head1 Compression
=head2 ($z, $status) = new Compress::Raw::Bzip2 $appendOutput, $blockSize100k, $workfactor;
Creates a new compression object.
If successful, it will return the initialised compression object, C<$z>
and a C<$status> of C<BZ_OK> in a list context. In scalar context it
returns the deflation object, C<$z>, only.
If not successful, the returned compression object, C<$z>, will be
I<undef> and C<$status> will hold the a I<bzip2> error code.
Below is a list of the valid options:
=over 5
=item B<$appendOutput>
Controls whether the compressed data is appended to the output buffer in
the C<bzdeflate>, C<bzflush> and C<bzclose> methods.
Defaults to 1.
=item B<$blockSize100k>
To quote the bzip2 documentation
blockSize100k specifies the block size to be used for compression. It
should be a value between 1 and 9 inclusive, and the actual block size
used is 100000 x this figure. 9 gives the best compression but takes
most memory.
Defaults to 1.
=item B<$workfactor>
To quote the bzip2 documentation
This parameter controls how the compression phase behaves when
presented with worst case, highly repetitive, input data. If
compression runs into difficulties caused by repetitive data, the
library switches from the standard sorting algorithm to a fallback
algorithm. The fallback is slower than the standard algorithm by
perhaps a factor of three, but always behaves reasonably, no matter how
bad the input.
Lower values of workFactor reduce the amount of effort the standard
algorithm will expend before resorting to the fallback. You should set
this parameter carefully; too low, and many inputs will be handled by
the fallback algorithm and so compress rather slowly, too high, and
your average-to-worst case compression times can become very large. The
default value of 30 gives reasonable behaviour over a wide range of
circumstances.
Allowable values range from 0 to 250 inclusive. 0 is a special case,
equivalent to using the default value of 30.
Defaults to 0.
=back
=head2 $status = $bz->bzdeflate($input, $output);
Reads the contents of C<$input>, compresses it and writes the compressed
data to C<$output>.
Returns C<BZ_RUN_OK> on success and a C<bzip2> error code on failure.
If C<appendOutput> is enabled in the constructor for the bzip2 object, the
compressed data will be appended to C<$output>. If not enabled, C<$output>
will be truncated before the compressed data is written to it.
=head2 $status = $bz->bzflush($output);
Flushes any pending compressed data to C<$output>.
Returns C<BZ_RUN_OK> on success and a C<bzip2> error code on failure.
=head2 $status = $bz->bzclose($output);
Terminates the compressed data stream and flushes any pending compressed
data to C<$output>.
Returns C<BZ_STREAM_END> on success and a C<bzip2> error code on failure.
=head2 Example
=head1 Uncompression
=head2 ($z, $status) = new Compress::Raw::Bunzip2 $appendOutput, $consumeInput, $small, $verbosity, $limitOutput;
If successful, it will return the initialised uncompression object, C<$z>
and a C<$status> of C<BZ_OK> in a list context. In scalar context it
returns the deflation object, C<$z>, only.
If not successful, the returned uncompression object, C<$z>, will be
I<undef> and C<$status> will hold the a I<bzip2> error code.
Below is a list of the valid options:
=over 5
=item B<$appendOutput>
Controls whether the compressed data is appended to the output buffer in the
C<bzinflate>, C<bzflush> and C<bzclose> methods.
Defaults to 1.
=item B<$consumeInput>
=item B<$small>
To quote the bzip2 documentation
If small is nonzero, the library will use an alternative decompression
algorithm which uses less memory but at the cost of decompressing more
slowly (roughly speaking, half the speed, but the maximum memory
requirement drops to around 2300k).
Defaults to 0.
=item B<$limitOutput>
The C<LimitOutput> option changes the behavior of the C<< $i->bzinflate >>
method so that the amount of memory used by the output buffer can be
limited.
When C<LimitOutput> is used the size of the output buffer used will either
be the 16k or the amount of memory already allocated to C<$output>,
whichever is larger. Predicting the output size available is tricky, so
don't rely on getting an exact output buffer size.
When C<LimitOutout> is not specified C<< $i->bzinflate >> will use as much
memory as it takes to write all the uncompressed data it creates by
uncompressing the input buffer.
If C<LimitOutput> is enabled, the C<ConsumeInput> option will also be
enabled.
This option defaults to false.
=item B<$verbosity>
This parameter is ignored.
Defaults to 0.
=back
=head2 $status = $z->bzinflate($input, $output);
Uncompresses C<$input> and writes the uncompressed data to C<$output>.
Returns C<BZ_OK> if the uncompression was successful, but the end of the
compressed data stream has not been reached. Returns C<BZ_STREAM_END> on
successful uncompression and the end of the compression stream has been
reached.
If C<consumeInput> is enabled in the constructor for the bunzip2 object,
C<$input> will have all compressed data removed from it after
uncompression. On C<BZ_OK> return this will mean that C<$input> will be an
empty string; when C<BZ_STREAM_END> C<$input> will either be an empty
string or will contain whatever data immediately followed the compressed
data stream.
If C<appendOutput> is enabled in the constructor for the bunzip2 object,
the uncompressed data will be appended to C<$output>. If not enabled,
C<$output> will be truncated before the uncompressed data is written to it.
=head1 Misc
=head2 my $version = Compress::Raw::Bzip2::bzlibversion();
Returns the version of the underlying bzip2 library.
=head1 Constants
The following bzip2 constants are exported by this module
BZ_RUN
BZ_FLUSH
BZ_FINISH
BZ_OK
BZ_RUN_OK
BZ_FLUSH_OK
BZ_FINISH_OK
BZ_STREAM_END
BZ_SEQUENCE_ERROR
BZ_PARAM_ERROR
BZ_MEM_ERROR
BZ_DATA_ERROR
BZ_DATA_ERROR_MAGIC
BZ_IO_ERROR
BZ_UNEXPECTED_EOF
BZ_OUTBUFF_FULL
BZ_CONFIG_ERROR
=head1 SUPPORT
General feedback/questions/bug reports should be sent to
L<https://github.com/pmqs/Compress-Raw-Bzip2/issues> (preferred) or
L<https://rt.cpan.org/Public/Dist/Display.html?Name=Compress-Raw-Bzip2>.
=head1 SEE ALSO
L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzma>, L<IO::Uncompress::UnLzma>, L<IO::Compress::Xz>, L<IO::Uncompress::UnXz>, L<IO::Compress::Lzip>, L<IO::Uncompress::UnLzip>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Compress::Zstd>, L<IO::Uncompress::UnZstd>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
L<IO::Compress::FAQ|IO::Compress::FAQ>
L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
L<Archive::Tar|Archive::Tar>,
L<IO::Zlib|IO::Zlib>
The primary site for the bzip2 program is L<https://sourceware.org/bzip2/>.
See the module L<Compress::Bzip2|Compress::Bzip2>
=head1 AUTHOR
This module was written by Paul Marquess, C<pmqs@cpan.org>.
=head1 MODIFICATION HISTORY
See the Changes file.
=head1 COPYRIGHT AND LICENSE
Copyright (c) 2005-2024 Paul Marquess. All rights reserved.
This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

1643
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Compress/Raw/Zlib.pm Normal file
View file

File diff suppressed because it is too large Load diff

111
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Config.pm Normal file
View file

@ -0,0 +1,111 @@
# This file was created by configpm when Perl was built. Any changes
# made to this file will be lost the next time perl is built.
# for a description of the variables, please have a look at the
# Glossary file, as written in the Porting folder, or use the url:
# https://github.com/Perl/perl5/blob/blead/Porting/Glossary
package Config;
use strict;
use warnings;
our ( %Config, $VERSION );
$VERSION = "5.040003";
# Skip @Config::EXPORT because it only contains %Config, which we special
# case below as it's not a function. @Config::EXPORT won't change in the
# lifetime of Perl 5.
my %Export_Cache = (myconfig => 1, config_sh => 1, config_vars => 1,
config_re => 1, compile_date => 1, local_patches => 1,
bincompat_options => 1, non_bincompat_options => 1,
header_files => 1);
@Config::EXPORT = qw(%Config);
@Config::EXPORT_OK = keys %Export_Cache;
# Need to stub all the functions to make code such as print Config::config_sh
# keep working
sub bincompat_options;
sub compile_date;
sub config_re;
sub config_sh;
sub config_vars;
sub header_files;
sub local_patches;
sub myconfig;
sub non_bincompat_options;
# Define our own import method to avoid pulling in the full Exporter:
sub import {
shift;
@_ = @Config::EXPORT unless @_;
my @funcs = grep $_ ne '%Config', @_;
my $export_Config = @funcs < @_ ? 1 : 0;
no strict 'refs';
my $callpkg = caller(0);
foreach my $func (@funcs) {
die qq{"$func" is not exported by the Config module\n}
unless $Export_Cache{$func};
*{$callpkg.'::'.$func} = \&{$func};
}
*{"$callpkg\::Config"} = \%Config if $export_Config;
return;
}
die "$0: Perl lib version (5.40.3) doesn't match executable '$^X' version ($])"
unless $^V;
$^V eq 5.40.3
or die sprintf "%s: Perl lib version (5.40.3) doesn't match executable '$^X' version (%vd)", $0, $^V;
sub FETCH {
my($self, $key) = @_;
# check for cached value (which may be undef so we use exists not defined)
return exists $self->{$key} ? $self->{$key} : $self->fetch_string($key);
}
sub TIEHASH {
bless $_[1], $_[0];
}
sub DESTROY { }
sub AUTOLOAD {
require 'Config_heavy.pl';
goto \&launcher unless $Config::AUTOLOAD =~ /launcher$/;
die "&Config::AUTOLOAD failed on $Config::AUTOLOAD";
}
# tie returns the object, so the value returned to require will be true.
tie %Config, 'Config', {
archlibexp => '/usr/lib/perl5/5.40/x86_64-cygwin-threads',
archname => 'x86_64-cygwin-threads-multi',
cc => 'gcc',
d_readlink => 'define',
d_symlink => 'define',
dlext => 'dll',
dlsrc => 'dl_dlopen.xs',
dont_use_nlink => undef,
exe_ext => '.exe',
inc_version_list => ' ',
intsize => '4',
ldlibpthname => 'PATH',
libpth => '/usr/lib',
osname => 'cygwin',
osvers => '3.6.4-1.x86_64',
path_sep => ':',
privlibexp => '/usr/share/perl5/5.40',
scriptdir => '/usr/bin',
sitearchexp => '/usr/local/lib/perl5/site_perl/5.40/x86_64-cygwin-threads',
sitelibexp => '/usr/local/share/perl5/site_perl/5.40',
so => 'dll',
useithreads => 'define',
usevendorprefix => 'define',
version => '5.40.3',
};

10000
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Config.pod Normal file
View file

File diff suppressed because it is too large Load diff

12
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Config_git.pl Normal file
View file

@ -0,0 +1,12 @@
######################################################################
# WARNING: 'lib/Config_git.pl' is generated by make_patchnum.pl
# DO NOT EDIT DIRECTLY - edit make_patchnum.pl instead
######################################################################
$Config::Git_Data=<<'ENDOFGIT';
git_commit_id=''
git_describe=''
git_branch=''
git_uncommitted_changes=''
git_commit_id_title=''
ENDOFGIT

1537
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Config_heavy.pl Normal file
View file

File diff suppressed because it is too large Load diff

829
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Cwd.pm Normal file
View file

@ -0,0 +1,829 @@
package Cwd;
use strict;
use Exporter;
our $VERSION = '3.91';
my $xs_version = $VERSION;
$VERSION =~ tr/_//d;
our @ISA = qw/ Exporter /;
our @EXPORT = qw(cwd getcwd fastcwd fastgetcwd);
push @EXPORT, qw(getdcwd) if $^O eq 'MSWin32';
our @EXPORT_OK = qw(chdir abs_path fast_abs_path realpath fast_realpath);
# sys_cwd may keep the builtin command
# All the functionality of this module may provided by builtins,
# there is no sense to process the rest of the file.
# The best choice may be to have this in BEGIN, but how to return from BEGIN?
if ($^O eq 'os2') {
local $^W = 0;
*cwd = defined &sys_cwd ? \&sys_cwd : \&_os2_cwd;
*getcwd = \&cwd;
*fastgetcwd = \&cwd;
*fastcwd = \&cwd;
*fast_abs_path = \&sys_abspath if defined &sys_abspath;
*abs_path = \&fast_abs_path;
*realpath = \&fast_abs_path;
*fast_realpath = \&fast_abs_path;
return 1;
}
# Need to look up the feature settings on VMS. The preferred way is to use the
# VMS::Feature module, but that may not be available to dual life modules.
my $use_vms_feature;
BEGIN {
if ($^O eq 'VMS') {
if (eval { local $SIG{__DIE__};
local @INC = @INC;
pop @INC if $INC[-1] eq '.';
require VMS::Feature; }) {
$use_vms_feature = 1;
}
}
}
# Need to look up the UNIX report mode. This may become a dynamic mode
# in the future.
sub _vms_unix_rpt {
my $unix_rpt;
if ($use_vms_feature) {
$unix_rpt = VMS::Feature::current("filename_unix_report");
} else {
my $env_unix_rpt = $ENV{'DECC$FILENAME_UNIX_REPORT'} || '';
$unix_rpt = $env_unix_rpt =~ /^[ET1]/i;
}
return $unix_rpt;
}
# Need to look up the EFS character set mode. This may become a dynamic
# mode in the future.
sub _vms_efs {
my $efs;
if ($use_vms_feature) {
$efs = VMS::Feature::current("efs_charset");
} else {
my $env_efs = $ENV{'DECC$EFS_CHARSET'} || '';
$efs = $env_efs =~ /^[ET1]/i;
}
return $efs;
}
# If loading the XS stuff doesn't work, we can fall back to pure perl
if(! defined &getcwd && defined &DynaLoader::boot_DynaLoader) { # skipped on miniperl
require XSLoader;
XSLoader::load( __PACKAGE__, $xs_version);
}
# Big nasty table of function aliases
my %METHOD_MAP =
(
VMS =>
{
cwd => '_vms_cwd',
getcwd => '_vms_cwd',
fastcwd => '_vms_cwd',
fastgetcwd => '_vms_cwd',
abs_path => '_vms_abs_path',
fast_abs_path => '_vms_abs_path',
},
MSWin32 =>
{
# We assume that &_NT_cwd is defined as an XSUB or in the core.
cwd => '_NT_cwd',
getcwd => '_NT_cwd',
fastcwd => '_NT_cwd',
fastgetcwd => '_NT_cwd',
abs_path => 'fast_abs_path',
realpath => 'fast_abs_path',
},
dos =>
{
cwd => '_dos_cwd',
getcwd => '_dos_cwd',
fastgetcwd => '_dos_cwd',
fastcwd => '_dos_cwd',
abs_path => 'fast_abs_path',
},
# QNX4. QNX6 has a $os of 'nto'.
qnx =>
{
cwd => '_qnx_cwd',
getcwd => '_qnx_cwd',
fastgetcwd => '_qnx_cwd',
fastcwd => '_qnx_cwd',
abs_path => '_qnx_abs_path',
fast_abs_path => '_qnx_abs_path',
},
cygwin =>
{
getcwd => 'cwd',
fastgetcwd => 'cwd',
fastcwd => 'cwd',
abs_path => 'fast_abs_path',
realpath => 'fast_abs_path',
},
amigaos =>
{
getcwd => '_backtick_pwd',
fastgetcwd => '_backtick_pwd',
fastcwd => '_backtick_pwd',
abs_path => 'fast_abs_path',
}
);
$METHOD_MAP{NT} = $METHOD_MAP{MSWin32};
# Find the pwd command in the expected locations. We assume these
# are safe. This prevents _backtick_pwd() consulting $ENV{PATH}
# so everything works under taint mode.
my $pwd_cmd;
if($^O ne 'MSWin32') {
foreach my $try ('/bin/pwd',
'/usr/bin/pwd',
'/QOpenSys/bin/pwd', # OS/400 PASE.
) {
if( -x $try ) {
$pwd_cmd = $try;
last;
}
}
}
# Android has a built-in pwd. Using $pwd_cmd will DTRT if
# this perl was compiled with -Dd_useshellcmds, which is the
# default for Android, but the block below is needed for the
# miniperl running on the host when cross-compiling, and
# potentially for native builds with -Ud_useshellcmds.
if ($^O =~ /android/) {
# If targetsh is executable, then we're either a full
# perl, or a miniperl for a native build.
if ( exists($Config::Config{targetsh}) && -x $Config::Config{targetsh}) {
$pwd_cmd = "$Config::Config{targetsh} -c pwd"
}
else {
my $sh = $Config::Config{sh} || (-x '/system/bin/sh' ? '/system/bin/sh' : 'sh');
$pwd_cmd = "$sh -c pwd"
}
}
my $found_pwd_cmd = defined($pwd_cmd);
# Lazy-load Carp
sub _carp { require Carp; Carp::carp(@_) }
sub _croak { require Carp; Carp::croak(@_) }
# The 'natural and safe form' for UNIX (pwd may be setuid root)
sub _backtick_pwd {
# Localize %ENV entries in a way that won't create new hash keys.
# Under AmigaOS we don't want to localize as it stops perl from
# finding 'sh' in the PATH.
my @localize = grep exists $ENV{$_}, qw(IFS CDPATH ENV BASH_ENV) if $^O ne "amigaos";
local @ENV{@localize} if @localize;
# empty PATH is the same as "." on *nix, so localize it to /something/
# we won't *use* the path as code above turns $pwd_cmd into a specific
# executable, but it will blow up anyway under taint. We could set it to
# anything absolute. Perhaps "/" would be better.
local $ENV{PATH}= "/usr/bin"
if $^O ne "amigaos";
my $cwd = `$pwd_cmd`;
# Belt-and-suspenders in case someone said "undef $/".
local $/ = "\n";
# `pwd` may fail e.g. if the disk is full
chomp($cwd) if defined $cwd;
$cwd;
}
# Since some ports may predefine cwd internally (e.g., NT)
# we take care not to override an existing definition for cwd().
unless ($METHOD_MAP{$^O}{cwd} or defined &cwd) {
if( $found_pwd_cmd )
{
*cwd = \&_backtick_pwd;
}
else {
# getcwd() might have an empty prototype
*cwd = sub { getcwd(); };
}
}
if ($^O eq 'cygwin') {
# We need to make sure cwd() is called with no args, because it's
# got an arg-less prototype and will die if args are present.
local $^W = 0;
my $orig_cwd = \&cwd;
*cwd = sub { &$orig_cwd() }
}
# set a reasonable (and very safe) default for fastgetcwd, in case it
# isn't redefined later (20001212 rspier)
*fastgetcwd = \&cwd;
# A non-XS version of getcwd() - also used to bootstrap the perl build
# process, when miniperl is running and no XS loading happens.
sub _perl_getcwd
{
abs_path('.');
}
# By John Bazik
#
# Usage: $cwd = &fastcwd;
#
# This is a faster version of getcwd. It's also more dangerous because
# you might chdir out of a directory that you can't chdir back into.
sub fastcwd_ {
my($odev, $oino, $cdev, $cino, $tdev, $tino);
my(@path, $path);
local(*DIR);
my($orig_cdev, $orig_cino) = stat('.');
($cdev, $cino) = ($orig_cdev, $orig_cino);
for (;;) {
my $direntry;
($odev, $oino) = ($cdev, $cino);
CORE::chdir('..') || return undef;
($cdev, $cino) = stat('.');
last if $odev == $cdev && $oino eq $cino;
opendir(DIR, '.') || return undef;
for (;;) {
$direntry = readdir(DIR);
last unless defined $direntry;
next if $direntry eq '.';
next if $direntry eq '..';
($tdev, $tino) = lstat($direntry);
last unless $tdev != $odev || $tino ne $oino;
}
closedir(DIR);
return undef unless defined $direntry; # should never happen
unshift(@path, $direntry);
}
$path = '/' . join('/', @path);
if ($^O eq 'apollo') { $path = "/".$path; }
# At this point $path may be tainted (if tainting) and chdir would fail.
# Untaint it then check that we landed where we started.
$path =~ /^(.*)\z/s # untaint
&& CORE::chdir($1) or return undef;
($cdev, $cino) = stat('.');
die "Unstable directory path, current directory changed unexpectedly"
if $cdev != $orig_cdev || $cino ne $orig_cino;
$path;
}
if (not defined &fastcwd) { *fastcwd = \&fastcwd_ }
# Keeps track of current working directory in PWD environment var
# Usage:
# use Cwd 'chdir';
# chdir $newdir;
my $chdir_init = 0;
sub chdir_init {
if ($ENV{'PWD'} and $^O ne 'os2' and $^O ne 'dos' and $^O ne 'MSWin32') {
my($dd,$di) = stat('.');
my($pd,$pi) = stat($ENV{'PWD'});
if (!defined $dd or !defined $pd or $di ne $pi or $dd != $pd) {
$ENV{'PWD'} = cwd();
}
}
else {
my $wd = cwd();
$wd = Win32::GetFullPathName($wd) if $^O eq 'MSWin32';
$ENV{'PWD'} = $wd;
}
# Strip an automounter prefix (where /tmp_mnt/foo/bar == /foo/bar)
if ($^O ne 'MSWin32' and $ENV{'PWD'} =~ m|(/[^/]+(/[^/]+/[^/]+))(.*)|s) {
my($pd,$pi) = stat($2);
my($dd,$di) = stat($1);
if (defined $pd and defined $dd and $di ne $pi and $dd == $pd) {
$ENV{'PWD'}="$2$3";
}
}
$chdir_init = 1;
}
sub chdir {
my $newdir = @_ ? shift : ''; # allow for no arg (chdir to HOME dir)
if ($^O eq "cygwin") {
$newdir =~ s|\A///+|//|;
$newdir =~ s|(?<=[^/])//+|/|g;
}
elsif ($^O ne 'MSWin32') {
$newdir =~ s|///*|/|g;
}
chdir_init() unless $chdir_init;
my $newpwd;
if ($^O eq 'MSWin32') {
# get the full path name *before* the chdir()
$newpwd = Win32::GetFullPathName($newdir);
}
return 0 unless CORE::chdir $newdir;
if ($^O eq 'VMS') {
return $ENV{'PWD'} = $ENV{'DEFAULT'}
}
elsif ($^O eq 'MSWin32') {
$ENV{'PWD'} = $newpwd;
return 1;
}
if (ref $newdir eq 'GLOB') { # in case a file/dir handle is passed in
$ENV{'PWD'} = cwd();
} elsif ($newdir =~ m#^/#s) {
$ENV{'PWD'} = $newdir;
} else {
my @curdir = split(m#/#,$ENV{'PWD'});
@curdir = ('') unless @curdir;
my $component;
foreach $component (split(m#/#, $newdir)) {
next if $component eq '.';
pop(@curdir),next if $component eq '..';
push(@curdir,$component);
}
$ENV{'PWD'} = join('/',@curdir) || '/';
}
1;
}
sub _perl_abs_path
{
my $start = @_ ? shift : '.';
my($dotdots, $cwd, @pst, @cst, $dir, @tst);
unless (@cst = stat( $start ))
{
return undef;
}
unless (-d _) {
# Make sure we can be invoked on plain files, not just directories.
# NOTE that this routine assumes that '/' is the only directory separator.
my ($dir, $file) = $start =~ m{^(.*)/(.+)$}
or return cwd() . '/' . $start;
# Can't use "-l _" here, because the previous stat was a stat(), not an lstat().
if (-l $start) {
my $link_target = readlink($start);
die "Can't resolve link $start: $!" unless defined $link_target;
require File::Spec;
$link_target = $dir . '/' . $link_target
unless File::Spec->file_name_is_absolute($link_target);
return abs_path($link_target);
}
return $dir ? abs_path($dir) . "/$file" : "/$file";
}
$cwd = '';
$dotdots = $start;
do
{
$dotdots .= '/..';
@pst = @cst;
local *PARENT;
unless (opendir(PARENT, $dotdots))
{
return undef;
}
unless (@cst = stat($dotdots))
{
my $e = $!;
closedir(PARENT);
$! = $e;
return undef;
}
if ($pst[0] == $cst[0] && $pst[1] eq $cst[1])
{
$dir = undef;
}
else
{
do
{
unless (defined ($dir = readdir(PARENT)))
{
closedir(PARENT);
require Errno;
$! = Errno::ENOENT();
return undef;
}
$tst[0] = $pst[0]+1 unless (@tst = lstat("$dotdots/$dir"))
}
while ($dir eq '.' || $dir eq '..' || $tst[0] != $pst[0] ||
$tst[1] ne $pst[1]);
}
$cwd = (defined $dir ? "$dir" : "" ) . "/$cwd" ;
closedir(PARENT);
} while (defined $dir);
chop($cwd) unless $cwd eq '/'; # drop the trailing /
$cwd;
}
my $Curdir;
sub fast_abs_path {
local $ENV{PWD} = $ENV{PWD} || ''; # Guard against clobberage
my $cwd = getcwd();
defined $cwd or return undef;
require File::Spec;
my $path = @_ ? shift : ($Curdir ||= File::Spec->curdir);
# Detaint else we'll explode in taint mode. This is safe because
# we're not doing anything dangerous with it.
($path) = $path =~ /(.*)/s;
($cwd) = $cwd =~ /(.*)/s;
unless (-e $path) {
require Errno;
$! = Errno::ENOENT();
return undef;
}
unless (-d _) {
# Make sure we can be invoked on plain files, not just directories.
my ($vol, $dir, $file) = File::Spec->splitpath($path);
return File::Spec->catfile($cwd, $path) unless length $dir;
if (-l $path) {
my $link_target = readlink($path);
defined $link_target or return undef;
$link_target = File::Spec->catpath($vol, $dir, $link_target)
unless File::Spec->file_name_is_absolute($link_target);
return fast_abs_path($link_target);
}
return $dir eq File::Spec->rootdir
? File::Spec->catpath($vol, $dir, $file)
: fast_abs_path(File::Spec->catpath($vol, $dir, '')) . '/' . $file;
}
if (!CORE::chdir($path)) {
return undef;
}
my $realpath = getcwd();
if (! ((-d $cwd) && (CORE::chdir($cwd)))) {
_croak("Cannot chdir back to $cwd: $!");
}
$realpath;
}
# added function alias to follow principle of least surprise
# based on previous aliasing. --tchrist 27-Jan-00
*fast_realpath = \&fast_abs_path;
# --- PORTING SECTION ---
# VMS: $ENV{'DEFAULT'} points to default directory at all times
# 06-Mar-1996 Charles Bailey bailey@newman.upenn.edu
# Note: Use of Cwd::chdir() causes the logical name PWD to be defined
# in the process logical name table as the default device and directory
# seen by Perl. This may not be the same as the default device
# and directory seen by DCL after Perl exits, since the effects
# the CRTL chdir() function persist only until Perl exits.
sub _vms_cwd {
return $ENV{'DEFAULT'};
}
sub _vms_abs_path {
return $ENV{'DEFAULT'} unless @_;
my $path = shift;
my $efs = _vms_efs;
my $unix_rpt = _vms_unix_rpt;
if (defined &VMS::Filespec::vmsrealpath) {
my $path_unix = 0;
my $path_vms = 0;
$path_unix = 1 if ($path =~ m#(?<=\^)/#);
$path_unix = 1 if ($path =~ /^\.\.?$/);
$path_vms = 1 if ($path =~ m#[\[<\]]#);
$path_vms = 1 if ($path =~ /^--?$/);
my $unix_mode = $path_unix;
if ($efs) {
# In case of a tie, the Unix report mode decides.
if ($path_vms == $path_unix) {
$unix_mode = $unix_rpt;
} else {
$unix_mode = 0 if $path_vms;
}
}
if ($unix_mode) {
# Unix format
return VMS::Filespec::unixrealpath($path);
}
# VMS format
my $new_path = VMS::Filespec::vmsrealpath($path);
# Perl expects directories to be in directory format
$new_path = VMS::Filespec::pathify($new_path) if -d $path;
return $new_path;
}
# Fallback to older algorithm if correct ones are not
# available.
if (-l $path) {
my $link_target = readlink($path);
die "Can't resolve link $path: $!" unless defined $link_target;
return _vms_abs_path($link_target);
}
# may need to turn foo.dir into [.foo]
my $pathified = VMS::Filespec::pathify($path);
$path = $pathified if defined $pathified;
return VMS::Filespec::rmsexpand($path);
}
sub _os2_cwd {
my $pwd = `cmd /c cd`;
chomp $pwd;
$pwd =~ s:\\:/:g ;
$ENV{'PWD'} = $pwd;
return $pwd;
}
sub _win32_cwd_simple {
my $pwd = `cd`;
chomp $pwd;
$pwd =~ s:\\:/:g ;
$ENV{'PWD'} = $pwd;
return $pwd;
}
sub _win32_cwd {
my $pwd;
$pwd = Win32::GetCwd();
$pwd =~ s:\\:/:g ;
$ENV{'PWD'} = $pwd;
return $pwd;
}
*_NT_cwd = defined &Win32::GetCwd ? \&_win32_cwd : \&_win32_cwd_simple;
sub _dos_cwd {
my $pwd;
if (!defined &Dos::GetCwd) {
chomp($pwd = `command /c cd`);
$pwd =~ s:\\:/:g ;
} else {
$pwd = Dos::GetCwd();
}
$ENV{'PWD'} = $pwd;
return $pwd;
}
sub _qnx_cwd {
local $ENV{PATH} = '';
local $ENV{CDPATH} = '';
local $ENV{ENV} = '';
my $pwd = `/usr/bin/fullpath -t`;
chomp $pwd;
$ENV{'PWD'} = $pwd;
return $pwd;
}
sub _qnx_abs_path {
local $ENV{PATH} = '';
local $ENV{CDPATH} = '';
local $ENV{ENV} = '';
my $path = @_ ? shift : '.';
local *REALPATH;
defined( open(REALPATH, '-|') || exec '/usr/bin/fullpath', '-t', $path ) or
die "Can't open /usr/bin/fullpath: $!";
my $realpath = <REALPATH>;
close REALPATH;
chomp $realpath;
return $realpath;
}
# Now that all the base-level functions are set up, alias the
# user-level functions to the right places
if (exists $METHOD_MAP{$^O}) {
my $map = $METHOD_MAP{$^O};
foreach my $name (keys %$map) {
local $^W = 0; # assignments trigger 'subroutine redefined' warning
no strict 'refs';
*{$name} = \&{$map->{$name}};
}
}
# built-in from 5.30
*getcwd = \&Internals::getcwd
if !defined &getcwd && defined &Internals::getcwd;
# In case the XS version doesn't load.
*abs_path = \&_perl_abs_path unless defined &abs_path;
*getcwd = \&_perl_getcwd unless defined &getcwd;
# added function alias for those of us more
# used to the libc function. --tchrist 27-Jan-00
*realpath = \&abs_path;
1;
__END__
=head1 NAME
Cwd - get pathname of current working directory
=head1 SYNOPSIS
use Cwd;
my $dir = getcwd;
use Cwd 'abs_path';
my $abs_path = abs_path($file);
=head1 DESCRIPTION
This module provides functions for determining the pathname of the
current working directory. It is recommended that getcwd (or another
*cwd() function) be used in I<all> code to ensure portability.
By default, it exports the functions cwd(), getcwd(), fastcwd(), and
fastgetcwd() (and, on Win32, getdcwd()) into the caller's namespace.
=head2 getcwd and friends
Each of these functions are called without arguments and return the
absolute path of the current working directory.
=over 4
=item getcwd
my $cwd = getcwd();
Returns the current working directory. On error returns C<undef>,
with C<$!> set to indicate the error.
Exposes the POSIX function getcwd(3) or re-implements it if it's not
available.
=item cwd
my $cwd = cwd();
The cwd() is the most natural form for the current architecture. For
most systems it is identical to `pwd` (but without the trailing line
terminator).
=item fastcwd
my $cwd = fastcwd();
A more dangerous version of getcwd(), but potentially faster.
It might conceivably chdir() you out of a directory that it can't
chdir() you back into. If fastcwd encounters a problem it will return
undef but will probably leave you in a different directory. For a
measure of extra security, if everything appears to have worked, the
fastcwd() function will check that it leaves you in the same directory
that it started in. If it has changed it will C<die> with the message
"Unstable directory path, current directory changed
unexpectedly". That should never happen.
=item fastgetcwd
my $cwd = fastgetcwd();
The fastgetcwd() function is provided as a synonym for cwd().
=item getdcwd
my $cwd = getdcwd();
my $cwd = getdcwd('C:');
The getdcwd() function is also provided on Win32 to get the current working
directory on the specified drive, since Windows maintains a separate current
working directory for each drive. If no drive is specified then the current
drive is assumed.
This function simply calls the Microsoft C library _getdcwd() function.
=back
=head2 abs_path and friends
These functions are exported only on request. They each take a single
argument and return the absolute pathname for it. If no argument is
given they'll use the current working directory.
=over 4
=item abs_path
my $abs_path = abs_path($file);
Uses the same algorithm as getcwd(). Symbolic links and relative-path
components ("." and "..") are resolved to return the canonical
pathname, just like realpath(3). On error returns C<undef>, with C<$!>
set to indicate the error.
=item realpath
my $abs_path = realpath($file);
A synonym for abs_path().
=item fast_abs_path
my $abs_path = fast_abs_path($file);
A more dangerous, but potentially faster version of abs_path.
=back
=head2 $ENV{PWD}
If you ask to override your chdir() built-in function,
use Cwd qw(chdir);
then your PWD environment variable will be kept up to date. Note that
it will only be kept up to date if all packages which use chdir import
it from Cwd.
=head1 NOTES
=over 4
=item *
Since the path separators are different on some operating systems ('/'
on Unix, ':' on MacPerl, etc...) we recommend you use the File::Spec
modules wherever portability is a concern.
=item *
Actually, on Mac OS, the C<getcwd()>, C<fastgetcwd()> and C<fastcwd()>
functions are all aliases for the C<cwd()> function, which, on Mac OS,
calls `pwd`. Likewise, the C<abs_path()> function is an alias for
C<fast_abs_path()>.
=back
=head1 AUTHOR
Maintained by perl5-porters <F<perl5-porters@perl.org>>.
=head1 COPYRIGHT
Copyright (c) 2004 by the Perl 5 Porters. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
Portions of the C code in this library are copyright (c) 1994 by the
Regents of the University of California. All rights reserved. The
license on this code is compatible with the licensing of the rest of
the distribution - please see the source code in F<Cwd.xs> for the
details.
=head1 SEE ALSO
L<File::chdir>
=cut

2348
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/DB_File.pm Normal file
View file

File diff suppressed because it is too large Load diff

1464
OGP64/lib/perl5/5.40/x86_64-cygwin-threads/Data/Dumper.pm Normal file
View file

File diff suppressed because it is too large Load diff

Some files were not shown because too many files have changed in this diff Show more