diff options
Diffstat (limited to 'Master/xemtex/perl/lib')
537 files changed, 83061 insertions, 0 deletions
diff --git a/Master/xemtex/perl/lib/AnyDBM_File.pm b/Master/xemtex/perl/lib/AnyDBM_File.pm new file mode 100644 index 00000000000..d73abab0f9e --- /dev/null +++ b/Master/xemtex/perl/lib/AnyDBM_File.pm @@ -0,0 +1,93 @@ +package AnyDBM_File; + +use 5.006_001; +our $VERSION = '1.00'; +our @ISA = qw(NDBM_File DB_File GDBM_File SDBM_File ODBM_File) unless @ISA; + +my $mod; +for $mod (@ISA) { + if (eval "require $mod") { + @ISA = ($mod); # if we leave @ISA alone, warnings abound + return 1; + } +} + +die "No DBM package was successfully found or installed"; +#return 0; + +=head1 NAME + +AnyDBM_File - provide framework for multiple DBMs + +NDBM_File, DB_File, GDBM_File, SDBM_File, ODBM_File - various DBM implementations + +=head1 SYNOPSIS + + use AnyDBM_File; + +=head1 DESCRIPTION + +This module is a "pure virtual base class"--it has nothing of its own. +It's just there to inherit from one of the various DBM packages. It +prefers ndbm for compatibility reasons with Perl 4, then Berkeley DB (See +L<DB_File>), GDBM, SDBM (which is always there--it comes with Perl), and +finally ODBM. This way old programs that used to use NDBM via dbmopen() +can still do so, but new ones can reorder @ISA: + + BEGIN { @AnyDBM_File::ISA = qw(DB_File GDBM_File NDBM_File) } + use AnyDBM_File; + +Having multiple DBM implementations makes it trivial to copy database formats: + + use POSIX; use NDBM_File; use DB_File; + tie %newhash, 'DB_File', $new_filename, O_CREAT|O_RDWR; + tie %oldhash, 'NDBM_File', $old_filename, 1, 0; + %newhash = %oldhash; + +=head2 DBM Comparisons + +Here's a partial table of features the different packages offer: + + odbm ndbm sdbm gdbm bsd-db + ---- ---- ---- ---- ------ + Linkage comes w/ perl yes yes yes yes yes + Src comes w/ perl no no yes no no + Comes w/ many unix os yes yes[0] no no no + Builds ok on !unix ? ? yes yes ? + Code Size ? ? small big big + Database Size ? ? small big? ok[1] + Speed ? ? slow ok fast + FTPable no no yes yes yes + Easy to build N/A N/A yes yes ok[2] + Size limits 1k 4k 1k[3] none none + Byte-order independent no no no no yes + Licensing restrictions ? ? no yes no + + +=over 4 + +=item [0] + +on mixed universe machines, may be in the bsd compat library, +which is often shunned. + +=item [1] + +Can be trimmed if you compile for one access method. + +=item [2] + +See L<DB_File>. +Requires symbolic links. + +=item [3] + +By default, but can be redefined. + +=back + +=head1 SEE ALSO + +dbm(3), ndbm(3), DB_File(3), L<perldbmfilter> + +=cut diff --git a/Master/xemtex/perl/lib/AutoLoader.pm b/Master/xemtex/perl/lib/AutoLoader.pm new file mode 100644 index 00000000000..b42d5ff4b68 --- /dev/null +++ b/Master/xemtex/perl/lib/AutoLoader.pm @@ -0,0 +1,337 @@ +package AutoLoader; + +use 5.006_001; +our(@EXPORT, @EXPORT_OK, $VERSION); + +my $is_dosish; +my $is_epoc; +my $is_vms; +my $is_macos; + +BEGIN { + require Exporter; + @EXPORT = @EXPORT = (); + @EXPORT_OK = @EXPORT_OK = qw(AUTOLOAD); + $is_dosish = $^O eq 'dos' || $^O eq 'os2' || $^O eq 'MSWin32' || $^O eq 'NetWare'; + $is_epoc = $^O eq 'epoc'; + $is_vms = $^O eq 'VMS'; + $is_macos = $^O eq 'MacOS'; + $VERSION = '5.59'; +} + +AUTOLOAD { + my $sub = $AUTOLOAD; + my $filename; + # Braces used to preserve $1 et al. + { + # Try to find the autoloaded file from the package-qualified + # name of the sub. e.g., if the sub needed is + # Getopt::Long::GetOptions(), then $INC{Getopt/Long.pm} is + # something like '/usr/lib/perl5/Getopt/Long.pm', and the + # autoload file is '/usr/lib/perl5/auto/Getopt/Long/GetOptions.al'. + # + # However, if @INC is a relative path, this might not work. If, + # for example, @INC = ('lib'), then $INC{Getopt/Long.pm} is + # 'lib/Getopt/Long.pm', and we want to require + # 'auto/Getopt/Long/GetOptions.al' (without the leading 'lib'). + # In this case, we simple prepend the 'auto/' and let the + # C<require> take care of the searching for us. + + my ($pkg,$func) = ($sub =~ /(.*)::([^:]+)$/); + $pkg =~ s#::#/#g; + if (defined($filename = $INC{"$pkg.pm"})) { + if ($is_macos) { + $pkg =~ tr#/#:#; + $filename =~ s#^(.*)$pkg\.pm\z#$1auto:$pkg:$func.al#s; + } else { + $filename =~ s#^(.*)$pkg\.pm\z#$1auto/$pkg/$func.al#s; + } + + # if the file exists, then make sure that it is a + # a fully anchored path (i.e either '/usr/lib/auto/foo/bar.al', + # or './lib/auto/foo/bar.al'. This avoids C<require> searching + # (and failing) to find the 'lib/auto/foo/bar.al' because it + # looked for 'lib/lib/auto/foo/bar.al', given @INC = ('lib'). + + if (-r $filename) { + unless ($filename =~ m|^/|s) { + if ($is_dosish) { + unless ($filename =~ m{^([a-z]:)?[\\/]}is) { + if ($^O ne 'NetWare') { + $filename = "./$filename"; + } else { + $filename = "$filename"; + } + } + } + elsif ($is_epoc) { + unless ($filename =~ m{^([a-z?]:)?[\\/]}is) { + $filename = "./$filename"; + } + } + elsif ($is_vms) { + # XXX todo by VMSmiths + $filename = "./$filename"; + } + elsif (!$is_macos) { + $filename = "./$filename"; + } + } + } + else { + $filename = undef; + } + } + unless (defined $filename) { + # let C<require> do the searching + $filename = "auto/$sub.al"; + $filename =~ s#::#/#g; + } + } + my $save = $@; + local $!; # Do not munge the value. + eval { local $SIG{__DIE__}; require $filename }; + if ($@) { + if (substr($sub,-9) eq '::DESTROY') { + *$sub = sub {}; + } else { + # The load might just have failed because the filename was too + # long for some old SVR3 systems which treat long names as errors. + # If we can succesfully truncate a long name then it's worth a go. + # There is a slight risk that we could pick up the wrong file here + # but autosplit should have warned about that when splitting. + if ($filename =~ s/(\w{12,})\.al$/substr($1,0,11).".al"/e){ + eval { local $SIG{__DIE__}; require $filename }; + } + if ($@){ + $@ =~ s/ at .*\n//; + my $error = $@; + require Carp; + Carp::croak($error); + } + } + } + $@ = $save; + goto &$sub; +} + +sub import { + my $pkg = shift; + my $callpkg = caller; + + # + # Export symbols, but not by accident of inheritance. + # + + if ($pkg eq 'AutoLoader') { + local $Exporter::ExportLevel = 1; + Exporter::import $pkg, @_; + } + + # + # Try to find the autosplit index file. Eg., if the call package + # is POSIX, then $INC{POSIX.pm} is something like + # '/usr/local/lib/perl5/POSIX.pm', and the autosplit index file is in + # '/usr/local/lib/perl5/auto/POSIX/autosplit.ix', so we require that. + # + # However, if @INC is a relative path, this might not work. If, + # for example, @INC = ('lib'), then + # $INC{POSIX.pm} is 'lib/POSIX.pm', and we want to require + # 'auto/POSIX/autosplit.ix' (without the leading 'lib'). + # + + (my $calldir = $callpkg) =~ s#::#/#g; + my $path = $INC{$calldir . '.pm'}; + if (defined($path)) { + # Try absolute path name. + if ($is_macos) { + (my $malldir = $calldir) =~ tr#/#:#; + $path =~ s#^(.*)$malldir\.pm\z#$1auto:$malldir:autosplit.ix#s; + } else { + $path =~ s#^(.*)$calldir\.pm\z#$1auto/$calldir/autosplit.ix#; + } + + eval { require $path; }; + # If that failed, try relative path with normal @INC searching. + if ($@) { + $path ="auto/$calldir/autosplit.ix"; + eval { require $path; }; + } + if ($@) { + my $error = $@; + require Carp; + Carp::carp($error); + } + } +} + +sub unimport { + my $callpkg = caller; + eval "package $callpkg; sub AUTOLOAD;"; +} + +1; + +__END__ + +=head1 NAME + +AutoLoader - load subroutines only on demand + +=head1 SYNOPSIS + + package Foo; + use AutoLoader 'AUTOLOAD'; # import the default AUTOLOAD subroutine + + package Bar; + use AutoLoader; # don't import AUTOLOAD, define our own + sub AUTOLOAD { + ... + $AutoLoader::AUTOLOAD = "..."; + goto &AutoLoader::AUTOLOAD; + } + +=head1 DESCRIPTION + +The B<AutoLoader> module works with the B<AutoSplit> module and the +C<__END__> token to defer the loading of some subroutines until they are +used rather than loading them all at once. + +To use B<AutoLoader>, the author of a module has to place the +definitions of subroutines to be autoloaded after an C<__END__> token. +(See L<perldata>.) The B<AutoSplit> module can then be run manually to +extract the definitions into individual files F<auto/funcname.al>. + +B<AutoLoader> implements an AUTOLOAD subroutine. When an undefined +subroutine in is called in a client module of B<AutoLoader>, +B<AutoLoader>'s AUTOLOAD subroutine attempts to locate the subroutine in a +file with a name related to the location of the file from which the +client module was read. As an example, if F<POSIX.pm> is located in +F</usr/local/lib/perl5/POSIX.pm>, B<AutoLoader> will look for perl +subroutines B<POSIX> in F</usr/local/lib/perl5/auto/POSIX/*.al>, where +the C<.al> file has the same name as the subroutine, sans package. If +such a file exists, AUTOLOAD will read and evaluate it, +thus (presumably) defining the needed subroutine. AUTOLOAD will then +C<goto> the newly defined subroutine. + +Once this process completes for a given function, it is defined, so +future calls to the subroutine will bypass the AUTOLOAD mechanism. + +=head2 Subroutine Stubs + +In order for object method lookup and/or prototype checking to operate +correctly even when methods have not yet been defined it is necessary to +"forward declare" each subroutine (as in C<sub NAME;>). See +L<perlsub/"SYNOPSIS">. Such forward declaration creates "subroutine +stubs", which are place holders with no code. + +The AutoSplit and B<AutoLoader> modules automate the creation of forward +declarations. The AutoSplit module creates an 'index' file containing +forward declarations of all the AutoSplit subroutines. When the +AutoLoader module is 'use'd it loads these declarations into its callers +package. + +Because of this mechanism it is important that B<AutoLoader> is always +C<use>d and not C<require>d. + +=head2 Using B<AutoLoader>'s AUTOLOAD Subroutine + +In order to use B<AutoLoader>'s AUTOLOAD subroutine you I<must> +explicitly import it: + + use AutoLoader 'AUTOLOAD'; + +=head2 Overriding B<AutoLoader>'s AUTOLOAD Subroutine + +Some modules, mainly extensions, provide their own AUTOLOAD subroutines. +They typically need to check for some special cases (such as constants) +and then fallback to B<AutoLoader>'s AUTOLOAD for the rest. + +Such modules should I<not> import B<AutoLoader>'s AUTOLOAD subroutine. +Instead, they should define their own AUTOLOAD subroutines along these +lines: + + use AutoLoader; + use Carp; + + sub AUTOLOAD { + my $sub = $AUTOLOAD; + (my $constname = $sub) =~ s/.*:://; + my $val = constant($constname, @_ ? $_[0] : 0); + if ($! != 0) { + if ($! =~ /Invalid/ || $!{EINVAL}) { + $AutoLoader::AUTOLOAD = $sub; + goto &AutoLoader::AUTOLOAD; + } + else { + croak "Your vendor has not defined constant $constname"; + } + } + *$sub = sub { $val }; # same as: eval "sub $sub { $val }"; + goto &$sub; + } + +If any module's own AUTOLOAD subroutine has no need to fallback to the +AutoLoader's AUTOLOAD subroutine (because it doesn't have any AutoSplit +subroutines), then that module should not use B<AutoLoader> at all. + +=head2 Package Lexicals + +Package lexicals declared with C<my> in the main block of a package +using B<AutoLoader> will not be visible to auto-loaded subroutines, due to +the fact that the given scope ends at the C<__END__> marker. A module +using such variables as package globals will not work properly under the +B<AutoLoader>. + +The C<vars> pragma (see L<perlmod/"vars">) may be used in such +situations as an alternative to explicitly qualifying all globals with +the package namespace. Variables pre-declared with this pragma will be +visible to any autoloaded routines (but will not be invisible outside +the package, unfortunately). + +=head2 Not Using AutoLoader + +You can stop using AutoLoader by simply + + no AutoLoader; + +=head2 B<AutoLoader> vs. B<SelfLoader> + +The B<AutoLoader> is similar in purpose to B<SelfLoader>: both delay the +loading of subroutines. + +B<SelfLoader> uses the C<__DATA__> marker rather than C<__END__>. +While this avoids the use of a hierarchy of disk files and the +associated open/close for each routine loaded, B<SelfLoader> suffers a +startup speed disadvantage in the one-time parsing of the lines after +C<__DATA__>, after which routines are cached. B<SelfLoader> can also +handle multiple packages in a file. + +B<AutoLoader> only reads code as it is requested, and in many cases +should be faster, but requires a mechanism like B<AutoSplit> be used to +create the individual files. L<ExtUtils::MakeMaker> will invoke +B<AutoSplit> automatically if B<AutoLoader> is used in a module source +file. + +=head1 CAVEATS + +AutoLoaders prior to Perl 5.002 had a slightly different interface. Any +old modules which use B<AutoLoader> should be changed to the new calling +style. Typically this just means changing a require to a use, adding +the explicit C<'AUTOLOAD'> import if needed, and removing B<AutoLoader> +from C<@ISA>. + +On systems with restrictions on file name length, the file corresponding +to a subroutine may have a shorter name that the routine itself. This +can lead to conflicting file names. The I<AutoSplit> package warns of +these potential conflicts when used to split a module. + +AutoLoader may fail to find the autosplit files (or even find the wrong +ones) in cases where C<@INC> contains relative paths, B<and> the program +does C<chdir>. + +=head1 SEE ALSO + +L<SelfLoader> - an autoloader that doesn't use external files. + +=cut diff --git a/Master/xemtex/perl/lib/B.pm b/Master/xemtex/perl/lib/B.pm new file mode 100644 index 00000000000..feca2e59d6e --- /dev/null +++ b/Master/xemtex/perl/lib/B.pm @@ -0,0 +1,971 @@ +# B.pm +# +# Copyright (c) 1996, 1997, 1998 Malcolm Beattie +# +# You may distribute under the terms of either the GNU General Public +# License or the Artistic License, as specified in the README file. +# +package B; + +our $VERSION = '1.01'; + +use XSLoader (); +require Exporter; +@ISA = qw(Exporter); + +# walkoptree_slow comes from B.pm (you are there), +# walkoptree comes from B.xs +@EXPORT_OK = qw(minus_c ppname save_BEGINs + class peekop cast_I32 cstring cchar hash threadsv_names + main_root main_start main_cv svref_2object opnumber + amagic_generation perlstring + walkoptree_slow walkoptree walkoptree_exec walksymtable + parents comppadlist sv_undef compile_stats timing_info + begin_av init_av end_av regex_padav); + +sub OPf_KIDS (); +use strict; +@B::SV::ISA = 'B::OBJECT'; +@B::NULL::ISA = 'B::SV'; +@B::PV::ISA = 'B::SV'; +@B::IV::ISA = 'B::SV'; +@B::NV::ISA = 'B::IV'; +@B::RV::ISA = 'B::SV'; +@B::PVIV::ISA = qw(B::PV B::IV); +@B::PVNV::ISA = qw(B::PV B::NV); +@B::PVMG::ISA = 'B::PVNV'; +@B::PVLV::ISA = 'B::PVMG'; +@B::BM::ISA = 'B::PVMG'; +@B::AV::ISA = 'B::PVMG'; +@B::GV::ISA = 'B::PVMG'; +@B::HV::ISA = 'B::PVMG'; +@B::CV::ISA = 'B::PVMG'; +@B::IO::ISA = 'B::PVMG'; +@B::FM::ISA = 'B::CV'; + +@B::OP::ISA = 'B::OBJECT'; +@B::UNOP::ISA = 'B::OP'; +@B::BINOP::ISA = 'B::UNOP'; +@B::LOGOP::ISA = 'B::UNOP'; +@B::LISTOP::ISA = 'B::BINOP'; +@B::SVOP::ISA = 'B::OP'; +@B::PADOP::ISA = 'B::OP'; +@B::PVOP::ISA = 'B::OP'; +@B::CVOP::ISA = 'B::OP'; +@B::LOOP::ISA = 'B::LISTOP'; +@B::PMOP::ISA = 'B::LISTOP'; +@B::COP::ISA = 'B::OP'; + +@B::SPECIAL::ISA = 'B::OBJECT'; + +{ + # Stop "-w" from complaining about the lack of a real B::OBJECT class + package B::OBJECT; +} + +sub B::GV::SAFENAME { + my $name = (shift())->NAME; + + # The regex below corresponds to the isCONTROLVAR macro + # from toke.c + + $name =~ s/^([\cA-\cZ\c\\c[\c]\c?\c_\c^])/"^". + chr( utf8::unicode_to_native( 64 ^ ord($1) ))/e; + + # When we say unicode_to_native we really mean ascii_to_native, + # which matters iff this is a non-ASCII platform (EBCDIC). + + return $name; +} + +sub B::IV::int_value { + my ($self) = @_; + return (($self->FLAGS() & SVf_IVisUV()) ? $self->UVX : $self->IV); +} + +sub B::NULL::as_string() {""} +sub B::IV::as_string() {goto &B::IV::int_value} +sub B::PV::as_string() {goto &B::PV::PV} + +my $debug; +my $op_count = 0; +my @parents = (); + +sub debug { + my ($class, $value) = @_; + $debug = $value; + walkoptree_debug($value); +} + +sub class { + my $obj = shift; + my $name = ref $obj; + $name =~ s/^.*:://; + return $name; +} + +sub parents { \@parents } + +# For debugging +sub peekop { + my $op = shift; + return sprintf("%s (0x%x) %s", class($op), $$op, $op->name); +} + +sub walkoptree_slow { + my($op, $method, $level) = @_; + $op_count++; # just for statistics + $level ||= 0; + warn(sprintf("walkoptree: %d. %s\n", $level, peekop($op))) if $debug; + $op->$method($level); + if ($$op && ($op->flags & OPf_KIDS)) { + my $kid; + unshift(@parents, $op); + for ($kid = $op->first; $$kid; $kid = $kid->sibling) { + walkoptree_slow($kid, $method, $level + 1); + } + shift @parents; + } + if (class($op) eq 'PMOP' && $op->pmreplroot && ${$op->pmreplroot}) { + unshift(@parents, $op); + walkoptree_slow($op->pmreplroot, $method, $level + 1); + shift @parents; + } +} + +sub compile_stats { + return "Total number of OPs processed: $op_count\n"; +} + +sub timing_info { + my ($sec, $min, $hr) = localtime; + my ($user, $sys) = times; + sprintf("%02d:%02d:%02d user=$user sys=$sys", + $hr, $min, $sec, $user, $sys); +} + +my %symtable; + +sub clearsym { + %symtable = (); +} + +sub savesym { + my ($obj, $value) = @_; +# warn(sprintf("savesym: sym_%x => %s\n", $$obj, $value)); # debug + $symtable{sprintf("sym_%x", $$obj)} = $value; +} + +sub objsym { + my $obj = shift; + return $symtable{sprintf("sym_%x", $$obj)}; +} + +sub walkoptree_exec { + my ($op, $method, $level) = @_; + $level ||= 0; + my ($sym, $ppname); + my $prefix = " " x $level; + for (; $$op; $op = $op->next) { + $sym = objsym($op); + if (defined($sym)) { + print $prefix, "goto $sym\n"; + return; + } + savesym($op, sprintf("%s (0x%lx)", class($op), $$op)); + $op->$method($level); + $ppname = $op->name; + if ($ppname =~ + /^(or|and|mapwhile|grepwhile|entertry|range|cond_expr)$/) + { + print $prefix, uc($1), " => {\n"; + walkoptree_exec($op->other, $method, $level + 1); + print $prefix, "}\n"; + } elsif ($ppname eq "match" || $ppname eq "subst") { + my $pmreplstart = $op->pmreplstart; + if ($$pmreplstart) { + print $prefix, "PMREPLSTART => {\n"; + walkoptree_exec($pmreplstart, $method, $level + 1); + print $prefix, "}\n"; + } + } elsif ($ppname eq "substcont") { + print $prefix, "SUBSTCONT => {\n"; + walkoptree_exec($op->other->pmreplstart, $method, $level + 1); + print $prefix, "}\n"; + $op = $op->other; + } elsif ($ppname eq "enterloop") { + print $prefix, "REDO => {\n"; + walkoptree_exec($op->redoop, $method, $level + 1); + print $prefix, "}\n", $prefix, "NEXT => {\n"; + walkoptree_exec($op->nextop, $method, $level + 1); + print $prefix, "}\n", $prefix, "LAST => {\n"; + walkoptree_exec($op->lastop, $method, $level + 1); + print $prefix, "}\n"; + } elsif ($ppname eq "subst") { + my $replstart = $op->pmreplstart; + if ($$replstart) { + print $prefix, "SUBST => {\n"; + walkoptree_exec($replstart, $method, $level + 1); + print $prefix, "}\n"; + } + } + } +} + +sub walksymtable { + my ($symref, $method, $recurse, $prefix) = @_; + my $sym; + my $ref; + my $fullname; + no strict 'refs'; + $prefix = '' unless defined $prefix; + while (($sym, $ref) = each %$symref) { + $fullname = "*main::".$prefix.$sym; + if ($sym =~ /::$/) { + $sym = $prefix . $sym; + if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) { + walksymtable(\%$fullname, $method, $recurse, $sym); + } + } else { + svref_2object(\*$fullname)->$method(); + } + } +} + +{ + package B::Section; + my $output_fh; + my %sections; + + sub new { + my ($class, $section, $symtable, $default) = @_; + $output_fh ||= FileHandle->new_tmpfile; + my $obj = bless [-1, $section, $symtable, $default], $class; + $sections{$section} = $obj; + return $obj; + } + + sub get { + my ($class, $section) = @_; + return $sections{$section}; + } + + sub add { + my $section = shift; + while (defined($_ = shift)) { + print $output_fh "$section->[1]\t$_\n"; + $section->[0]++; + } + } + + sub index { + my $section = shift; + return $section->[0]; + } + + sub name { + my $section = shift; + return $section->[1]; + } + + sub symtable { + my $section = shift; + return $section->[2]; + } + + sub default { + my $section = shift; + return $section->[3]; + } + + sub output { + my ($section, $fh, $format) = @_; + my $name = $section->name; + my $sym = $section->symtable || {}; + my $default = $section->default; + + seek($output_fh, 0, 0); + while (<$output_fh>) { + chomp; + s/^(.*?)\t//; + if ($1 eq $name) { + s{(s\\_[0-9a-f]+)} { + exists($sym->{$1}) ? $sym->{$1} : $default; + }ge; + printf $fh $format, $_; + } + } + } +} + +XSLoader::load 'B'; + +1; + +__END__ + +=head1 NAME + +B - The Perl Compiler + +=head1 SYNOPSIS + + use B; + +=head1 DESCRIPTION + +The C<B> module supplies classes which allow a Perl program to delve +into its own innards. It is the module used to implement the +"backends" of the Perl compiler. Usage of the compiler does not +require knowledge of this module: see the F<O> module for the +user-visible part. The C<B> module is of use to those who want to +write new compiler backends. This documentation assumes that the +reader knows a fair amount about perl's internals including such +things as SVs, OPs and the internal symbol table and syntax tree +of a program. + +=head1 OVERVIEW OF CLASSES + +The C structures used by Perl's internals to hold SV and OP +information (PVIV, AV, HV, ..., OP, SVOP, UNOP, ...) are modelled on a +class hierarchy and the C<B> module gives access to them via a true +object hierarchy. Structure fields which point to other objects +(whether types of SV or types of OP) are represented by the C<B> +module as Perl objects of the appropriate class. The bulk of the C<B> +module is the methods for accessing fields of these structures. Note +that all access is read-only: you cannot modify the internals by +using this module. + +=head2 SV-RELATED CLASSES + +B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV, +B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in +the obvious way to the underlying C structures of similar names. The +inheritance hierarchy mimics the underlying C "inheritance". Access +methods correspond to the underlying C macros for field access, +usually with the leading "class indication" prefix removed (Sv, Av, +Hv, ...). The leading prefix is only left in cases where its removal +would cause a clash in method name. For example, C<GvREFCNT> stays +as-is since its abbreviation would clash with the "superclass" method +C<REFCNT> (corresponding to the C function C<SvREFCNT>). + +=head2 B::SV METHODS + +=over 4 + +=item REFCNT + +=item FLAGS + +=back + +=head2 B::IV METHODS + +=over 4 + +=item IV + +Returns the value of the IV, I<interpreted as +a signed integer>. This will be misleading +if C<FLAGS & SVf_IVisUV>. Perhaps you want the +C<int_value> method instead? + +=item IVX + +=item UVX + +=item int_value + +This method returns the value of the IV as an integer. +It differs from C<IV> in that it returns the correct +value regardless of whether it's stored signed or +unsigned. + +=item needs64bits + +=item packiv + +=back + +=head2 B::NV METHODS + +=over 4 + +=item NV + +=item NVX + +=back + +=head2 B::RV METHODS + +=over 4 + +=item RV + +=back + +=head2 B::PV METHODS + +=over 4 + +=item PV + +This method is the one you usually want. It constructs a +string using the length and offset information in the struct: +for ordinary scalars it will return the string that you'd see +from Perl, even if it contains null characters. + +=item RV + +Same as B::RV::RV, except that it will die() if the PV isn't +a reference. + +=item PVX + +This method is less often useful. It assumes that the string +stored in the struct is null-terminated, and disregards the +length information. + +It is the appropriate method to use if you need to get the name +of a lexical variable from a padname array. Lexical variable names +are always stored with a null terminator, and the length field +(SvCUR) is overloaded for other purposes and can't be relied on here. + +=back + +=head2 B::PVMG METHODS + +=over 4 + +=item MAGIC + +=item SvSTASH + +=back + +=head2 B::MAGIC METHODS + +=over 4 + +=item MOREMAGIC + +=item precomp + +Only valid on r-magic, returns the string that generated the regexp. + +=item PRIVATE + +=item TYPE + +=item FLAGS + +=item OBJ + +Will die() if called on r-magic. + +=item PTR + +=item REGEX + +Only valid on r-magic, returns the integer value of the REGEX stored +in the MAGIC. + +=back + +=head2 B::PVLV METHODS + +=over 4 + +=item TARGOFF + +=item TARGLEN + +=item TYPE + +=item TARG + +=back + +=head2 B::BM METHODS + +=over 4 + +=item USEFUL + +=item PREVIOUS + +=item RARE + +=item TABLE + +=back + +=head2 B::GV METHODS + +=over 4 + +=item is_empty + +This method returns TRUE if the GP field of the GV is NULL. + +=item NAME + +=item SAFENAME + +This method returns the name of the glob, but if the first +character of the name is a control character, then it converts +it to ^X first, so that *^G would return "^G" rather than "\cG". + +It's useful if you want to print out the name of a variable. +If you restrict yourself to globs which exist at compile-time +then the result ought to be unambiguous, because code like +C<${"^G"} = 1> is compiled as two ops - a constant string and +a dereference (rv2gv) - so that the glob is created at runtime. + +If you're working with globs at runtime, and need to disambiguate +*^G from *{"^G"}, then you should use the raw NAME method. + +=item STASH + +=item SV + +=item IO + +=item FORM + +=item AV + +=item HV + +=item EGV + +=item CV + +=item CVGEN + +=item LINE + +=item FILE + +=item FILEGV + +=item GvREFCNT + +=item FLAGS + +=back + +=head2 B::IO METHODS + +=over 4 + +=item LINES + +=item PAGE + +=item PAGE_LEN + +=item LINES_LEFT + +=item TOP_NAME + +=item TOP_GV + +=item FMT_NAME + +=item FMT_GV + +=item BOTTOM_NAME + +=item BOTTOM_GV + +=item SUBPROCESS + +=item IoTYPE + +=item IoFLAGS + +=item IsSTD + +Takes one arguments ( 'stdin' | 'stdout' | 'stderr' ) and returns true +if the IoIFP of the object is equal to the handle whose name was +passed as argument ( i.e. $io->IsSTD('stderr') is true if +IoIFP($io) == PerlIO_stdin() ). + +=back + +=head2 B::AV METHODS + +=over 4 + +=item FILL + +=item MAX + +=item OFF + +=item ARRAY + +=item AvFLAGS + +=back + +=head2 B::CV METHODS + +=over 4 + +=item STASH + +=item START + +=item ROOT + +=item GV + +=item FILE + +=item DEPTH + +=item PADLIST + +=item OUTSIDE + +=item XSUB + +=item XSUBANY + +For constant subroutines, returns the constant SV returned by the subroutine. + +=item CvFLAGS + +=item const_sv + +=back + +=head2 B::HV METHODS + +=over 4 + +=item FILL + +=item MAX + +=item KEYS + +=item RITER + +=item NAME + +=item PMROOT + +=item ARRAY + +=back + +=head2 OP-RELATED CLASSES + +B::OP, B::UNOP, B::BINOP, B::LOGOP, B::LISTOP, B::PMOP, +B::SVOP, B::PADOP, B::PVOP, B::CVOP, B::LOOP, B::COP. +These classes correspond in +the obvious way to the underlying C structures of similar names. The +inheritance hierarchy mimics the underlying C "inheritance". Access +methods correspond to the underlying C structre field names, with the +leading "class indication" prefix removed (op_). + +=head2 B::OP METHODS + +=over 4 + +=item next + +=item sibling + +=item name + +This returns the op name as a string (e.g. "add", "rv2av"). + +=item ppaddr + +This returns the function name as a string (e.g. "PL_ppaddr[OP_ADD]", +"PL_ppaddr[OP_RV2AV]"). + +=item desc + +This returns the op description from the global C PL_op_desc array +(e.g. "addition" "array deref"). + +=item targ + +=item type + +=item seq + +=item flags + +=item private + +=back + +=head2 B::UNOP METHOD + +=over 4 + +=item first + +=back + +=head2 B::BINOP METHOD + +=over 4 + +=item last + +=back + +=head2 B::LOGOP METHOD + +=over 4 + +=item other + +=back + +=head2 B::LISTOP METHOD + +=over 4 + +=item children + +=back + +=head2 B::PMOP METHODS + +=over 4 + +=item pmreplroot + +=item pmreplstart + +=item pmnext + +=item pmregexp + +=item pmflags + +=item pmdynflags + +=item pmpermflags + +=item precomp + +=item pmoffet + +Only when perl was compiled with ithreads. + +=back + +=head2 B::SVOP METHOD + +=over 4 + +=item sv + +=item gv + +=back + +=head2 B::PADOP METHOD + +=over 4 + +=item padix + +=back + +=head2 B::PVOP METHOD + +=over 4 + +=item pv + +=back + +=head2 B::LOOP METHODS + +=over 4 + +=item redoop + +=item nextop + +=item lastop + +=back + +=head2 B::COP METHODS + +=over 4 + +=item label + +=item stash + +=item file + +=item cop_seq + +=item arybase + +=item line + +=back + +=head1 FUNCTIONS EXPORTED BY C<B> + +The C<B> module exports a variety of functions: some are simple +utility functions, others provide a Perl program with a way to +get an initial "handle" on an internal object. + +=over 4 + +=item main_cv + +Return the (faked) CV corresponding to the main part of the Perl +program. + +=item init_av + +Returns the AV object (i.e. in class B::AV) representing INIT blocks. + +=item begin_av + +Returns the AV object (i.e. in class B::AV) representing BEGIN blocks. + +=item end_av + +Returns the AV object (i.e. in class B::AV) representing END blocks. + +=item main_root + +Returns the root op (i.e. an object in the appropriate B::OP-derived +class) of the main part of the Perl program. + +=item main_start + +Returns the starting op of the main part of the Perl program. + +=item comppadlist + +Returns the AV object (i.e. in class B::AV) of the global comppadlist. + +=item regex_padav + +Only when perl was compiled with ithreads. + +=item sv_undef + +Returns the SV object corresponding to the C variable C<sv_undef>. + +=item sv_yes + +Returns the SV object corresponding to the C variable C<sv_yes>. + +=item sv_no + +Returns the SV object corresponding to the C variable C<sv_no>. + +=item amagic_generation + +Returns the SV object corresponding to the C variable C<amagic_generation>. + +=item walkoptree(OP, METHOD) + +Does a tree-walk of the syntax tree based at OP and calls METHOD on +each op it visits. Each node is visited before its children. If +C<walkoptree_debug> (q.v.) has been called to turn debugging on then +the method C<walkoptree_debug> is called on each op before METHOD is +called. + +=item walkoptree_debug(DEBUG) + +Returns the current debugging flag for C<walkoptree>. If the optional +DEBUG argument is non-zero, it sets the debugging flag to that. See +the description of C<walkoptree> above for what the debugging flag +does. + +=item walksymtable(SYMREF, METHOD, RECURSE, PREFIX) + +Walk the symbol table starting at SYMREF and call METHOD on each +symbol (a B::GV object) visited. When the walk reaches package +symbols (such as "Foo::") it invokes RECURSE, passing in the symbol +name, and only recurses into the package if that sub returns true. + +PREFIX is the name of the SYMREF you're walking. + +For example... + + # Walk CGI's symbol table calling print_subs on each symbol. + # Only recurse into CGI::Util:: + walksymtable(\%CGI::, 'print_subs', sub { $_[0] eq 'CGI::Util::' }, + 'CGI::'); + +print_subs() is a B::GV method you have declared. + + +=item svref_2object(SV) + +Takes any Perl variable and turns it into an object in the +appropriate B::OP-derived or B::SV-derived class. Apart from functions +such as C<main_root>, this is the primary way to get an initial +"handle" on an internal perl data structure which can then be followed +with the other access methods. + +=item ppname(OPNUM) + +Return the PP function name (e.g. "pp_add") of op number OPNUM. + +=item hash(STR) + +Returns a string in the form "0x..." representing the value of the +internal hash function used by perl on string STR. + +=item cast_I32(I) + +Casts I to the internal I32 type used by that perl. + + +=item minus_c + +Does the equivalent of the C<-c> command-line option. Obviously, this +is only useful in a BEGIN block or else the flag is set too late. + + +=item cstring(STR) + +Returns a double-quote-surrounded escaped version of STR which can +be used as a string in C source code. + +=item perlstring(STR) + +Returns a double-quote-surrounded escaped version of STR which can +be used as a string in Perl source code. + +=item class(OBJ) + +Returns the class of an object without the part of the classname +preceding the first "::". This is used to turn "B::UNOP" into +"UNOP" for example. + +=item threadsv_names + +In a perl compiled for threads, this returns a list of the special +per-thread threadsv variables. + +=back + +=head1 AUTHOR + +Malcolm Beattie, C<mbeattie@sable.ox.ac.uk> + +=cut diff --git a/Master/xemtex/perl/lib/B/Deparse.pm b/Master/xemtex/perl/lib/B/Deparse.pm new file mode 100644 index 00000000000..924f4366d66 --- /dev/null +++ b/Master/xemtex/perl/lib/B/Deparse.pm @@ -0,0 +1,4233 @@ +# B::Deparse.pm +# Copyright (c) 1998, 1999, 2000 Stephen McCamant. All rights reserved. +# This module is free software; you can redistribute and/or modify +# it under the same terms as Perl itself. + +# This is based on the module of the same name by Malcolm Beattie, +# but essentially none of his code remains. + +package B::Deparse; +use Carp; +use B qw(class main_root main_start main_cv svref_2object opnumber perlstring + OPf_WANT OPf_WANT_VOID OPf_WANT_SCALAR OPf_WANT_LIST + OPf_KIDS OPf_REF OPf_STACKED OPf_SPECIAL OPf_MOD + OPpLVAL_INTRO OPpOUR_INTRO OPpENTERSUB_AMPER OPpSLICE OPpCONST_BARE + OPpTRANS_SQUASH OPpTRANS_DELETE OPpTRANS_COMPLEMENT OPpTARGET_MY + OPpCONST_ARYBASE OPpEXISTS_SUB OPpSORT_NUMERIC OPpSORT_INTEGER + OPpSORT_REVERSE + SVf_IOK SVf_NOK SVf_ROK SVf_POK SVpad_OUR + CVf_METHOD CVf_LOCKED CVf_LVALUE + PMf_KEEP PMf_GLOBAL PMf_CONTINUE PMf_EVAL PMf_ONCE PMf_SKIPWHITE + PMf_MULTILINE PMf_SINGLELINE PMf_FOLD PMf_EXTENDED); +$VERSION = 0.63; +use strict; +use vars qw/$AUTOLOAD/; +use warnings (); + +# Changes between 0.50 and 0.51: +# - fixed nulled leave with live enter in sort { } +# - fixed reference constants (\"str") +# - handle empty programs gracefully +# - handle infinte loops (for (;;) {}, while (1) {}) +# - differentiate between `for my $x ...' and `my $x; for $x ...' +# - various minor cleanups +# - moved globals into an object +# - added `-u', like B::C +# - package declarations using cop_stash +# - subs, formats and code sorted by cop_seq +# Changes between 0.51 and 0.52: +# - added pp_threadsv (special variables under USE_5005THREADS) +# - added documentation +# Changes between 0.52 and 0.53: +# - many changes adding precedence contexts and associativity +# - added `-p' and `-s' output style options +# - various other minor fixes +# Changes between 0.53 and 0.54: +# - added support for new `for (1..100)' optimization, +# thanks to Gisle Aas +# Changes between 0.54 and 0.55: +# - added support for new qr// construct +# - added support for new pp_regcreset OP +# Changes between 0.55 and 0.56: +# - tested on base/*.t, cmd/*.t, comp/*.t, io/*.t +# - fixed $# on non-lexicals broken in last big rewrite +# - added temporary fix for change in opcode of OP_STRINGIFY +# - fixed problem in 0.54's for() patch in `for (@ary)' +# - fixed precedence in conditional of ?: +# - tweaked list paren elimination in `my($x) = @_' +# - made continue-block detection trickier wrt. null ops +# - fixed various prototype problems in pp_entersub +# - added support for sub prototypes that never get GVs +# - added unquoting for special filehandle first arg in truncate +# - print doubled rv2gv (a bug) as `*{*GV}' instead of illegal `**GV' +# - added semicolons at the ends of blocks +# - added -l `#line' declaration option -- fixes cmd/subval.t 27,28 +# Changes between 0.56 and 0.561: +# - fixed multiply-declared my var in pp_truncate (thanks to Sarathy) +# - used new B.pm symbolic constants (done by Nick Ing-Simmons) +# Changes between 0.561 and 0.57: +# - stylistic changes to symbolic constant stuff +# - handled scope in s///e replacement code +# - added unquote option for expanding "" into concats, etc. +# - split method and proto parts of pp_entersub into separate functions +# - various minor cleanups +# Changes after 0.57: +# - added parens in \&foo (patch by Albert Dvornik) +# Changes between 0.57 and 0.58: +# - fixed `0' statements that weren't being printed +# - added methods for use from other programs +# (based on patches from James Duncan and Hugo van der Sanden) +# - added -si and -sT to control indenting (also based on a patch from Hugo) +# - added -sv to print something else instead of '???' +# - preliminary version of utf8 tr/// handling +# Changes after 0.58: +# - uses of $op->ppaddr changed to new $op->name (done by Sarathy) +# - added support for Hugo's new OP_SETSTATE (like nextstate) +# Changes between 0.58 and 0.59 +# - added support for Chip's OP_METHOD_NAMED +# - added support for Ilya's OPpTARGET_MY optimization +# - elided arrows before `()' subscripts when possible +# Changes between 0.59 and 0.60 +# - support for method attribues was added +# - some warnings fixed +# - separate recognition of constant subs +# - rewrote continue block handling, now recoginizing for loops +# - added more control of expanding control structures +# Changes between 0.60 and 0.61 (mostly by Robin Houston) +# - many bug-fixes +# - support for pragmas and 'use' +# - support for the little-used $[ variable +# - support for __DATA__ sections +# - UTF8 support +# - BEGIN, CHECK, INIT and END blocks +# - scoping of subroutine declarations fixed +# - compile-time output from the input program can be suppressed, so that the +# output is just the deparsed code. (a change to O.pm in fact) +# - our() declarations +# - *all* the known bugs are now listed in the BUGS section +# - comprehensive test mechanism (TEST -deparse) +# Changes between 0.62 and 0.63 (mostly by Rafael Garcia-Suarez) +# - bug-fixes +# - new switch -P +# - support for command-line switches (-l, -0, etc.) + +# Todo: +# (See also BUGS section at the end of this file) +# +# - finish tr/// changes +# - add option for even more parens (generalize \&foo change) +# - left/right context +# - treat top-level block specially for incremental output +# - copy comments (look at real text with $^P?) +# - avoid semis in one-statement blocks +# - associativity of &&=, ||=, ?: +# - ',' => '=>' (auto-unquote?) +# - break long lines ("\r" as discretionary break?) +# - configurable syntax highlighting: ANSI color, HTML, TeX, etc. +# - more style options: brace style, hex vs. octal, quotes, ... +# - print big ints as hex/octal instead of decimal (heuristic?) +# - handle `my $x if 0'? +# - coordinate with Data::Dumper (both directions? see previous) +# - version using op_next instead of op_first/sibling? +# - avoid string copies (pass arrays, one big join?) +# - here-docs? + +# Tests that will always fail: +# (see t/TEST for the short list) + +# Object fields (were globals): +# +# avoid_local: +# (local($a), local($b)) and local($a, $b) have the same internal +# representation but the short form looks better. We notice we can +# use a large-scale local when checking the list, but need to prevent +# individual locals too. This hash holds the addresses of OPs that +# have already had their local-ness accounted for. The same thing +# is done with my(). +# +# curcv: +# CV for current sub (or main program) being deparsed +# +# curcvlex: +# Cached hash of lexical variables for curcv: keys are names, +# each value is an array of pairs, indicating the cop_seq of scopes +# in which a var of that name is valid. +# +# curcop: +# COP for statement being deparsed +# +# curstash: +# name of the current package for deparsed code +# +# subs_todo: +# array of [cop_seq, CV, is_format?] for subs and formats we still +# want to deparse +# +# protos_todo: +# as above, but [name, prototype] for subs that never got a GV +# +# subs_done, forms_done: +# keys are addresses of GVs for subs and formats we've already +# deparsed (or at least put into subs_todo) +# +# subs_declared +# keys are names of subs for which we've printed declarations. +# That means we can omit parentheses from the arguments. +# +# subs_deparsed +# Keeps track of fully qualified names of all deparsed subs. +# +# parens: -p +# linenums: -l +# unquote: -q +# cuddle: ` ' or `\n', depending on -sC +# indent_size: -si +# use_tabs: -sT +# ex_const: -sv + +# A little explanation of how precedence contexts and associativity +# work: +# +# deparse() calls each per-op subroutine with an argument $cx (short +# for context, but not the same as the cx* in the perl core), which is +# a number describing the op's parents in terms of precedence, whether +# they're inside an expression or at statement level, etc. (see +# chart below). When ops with children call deparse on them, they pass +# along their precedence. Fractional values are used to implement +# associativity (`($x + $y) + $z' => `$x + $y + $y') and related +# parentheses hacks. The major disadvantage of this scheme is that +# it doesn't know about right sides and left sides, so say if you +# assign a listop to a variable, it can't tell it's allowed to leave +# the parens off the listop. + +# Precedences: +# 26 [TODO] inside interpolation context ("") +# 25 left terms and list operators (leftward) +# 24 left -> +# 23 nonassoc ++ -- +# 22 right ** +# 21 right ! ~ \ and unary + and - +# 20 left =~ !~ +# 19 left * / % x +# 18 left + - . +# 17 left << >> +# 16 nonassoc named unary operators +# 15 nonassoc < > <= >= lt gt le ge +# 14 nonassoc == != <=> eq ne cmp +# 13 left & +# 12 left | ^ +# 11 left && +# 10 left || +# 9 nonassoc .. ... +# 8 right ?: +# 7 right = += -= *= etc. +# 6 left , => +# 5 nonassoc list operators (rightward) +# 4 right not +# 3 left and +# 2 left or xor +# 1 statement modifiers +# 0 statement level + +# Also, lineseq may pass a fourth parameter to the pp_ routines: +# if present, the fourth parameter is passed on by deparse. +# +# If present and true, it means that the op exists directly as +# part of a lineseq. Currently it's only used by scopeop to +# decide whether its results need to be enclosed in a do {} block. + +# Nonprinting characters with special meaning: +# \cS - steal parens (see maybe_parens_unop) +# \n - newline and indent +# \t - increase indent +# \b - decrease indent (`outdent') +# \f - flush left (no indent) +# \cK - kill following semicolon, if any + +sub null { + my $op = shift; + return class($op) eq "NULL"; +} + +sub todo { + my $self = shift; + my($cv, $is_form) = @_; + return unless ($cv->FILE eq $0 || exists $self->{files}{$cv->FILE}); + my $seq; + if (!null($cv->START) and is_state($cv->START)) { + $seq = $cv->START->cop_seq; + } else { + $seq = 0; + } + push @{$self->{'subs_todo'}}, [$seq, $cv, $is_form]; + unless ($is_form || class($cv->STASH) eq 'SPECIAL') { + $self->{'subs_deparsed'}{$cv->STASH->NAME."::".$cv->GV->NAME} = 1; + } +} + +sub next_todo { + my $self = shift; + my $ent = shift @{$self->{'subs_todo'}}; + my $cv = $ent->[1]; + my $gv = $cv->GV; + my $name = $self->gv_name($gv); + if ($ent->[2]) { + return "format $name =\n" + . $self->deparse_format($ent->[1]). "\n"; + } else { + $self->{'subs_declared'}{$name} = 1; + if ($name eq "BEGIN") { + my $use_dec = $self->begin_is_use($cv); + if (defined ($use_dec)) { + return () if 0 == length($use_dec); + return $use_dec; + } + } + my $l = ''; + if ($self->{'linenums'}) { + my $line = $gv->LINE; + my $file = $gv->FILE; + $l = "\n\f#line $line \"$file\"\n"; + } + return "${l}sub $name " . $self->deparse_sub($cv); + } +} + +# Return a "use" declaration for this BEGIN block, if appropriate +sub begin_is_use { + my ($self, $cv) = @_; + my $root = $cv->ROOT; + local @$self{qw'curcv curcvlex'} = ($cv); +#require B::Debug; +#B::walkoptree($cv->ROOT, "debug"); + my $lineseq = $root->first; + return if $lineseq->name ne "lineseq"; + + my $req_op = $lineseq->first->sibling; + return if $req_op->name ne "require"; + + my $module; + if ($req_op->first->private & OPpCONST_BARE) { + # Actually it should always be a bareword + $module = $self->const_sv($req_op->first)->PV; + $module =~ s[/][::]g; + $module =~ s/.pm$//; + } + else { + $module = const($self->const_sv($req_op->first)); + } + + my $version; + my $version_op = $req_op->sibling; + return if class($version_op) eq "NULL"; + if ($version_op->name eq "lineseq") { + # We have a version parameter; skip nextstate & pushmark + my $constop = $version_op->first->next->next; + + return unless $self->const_sv($constop)->PV eq $module; + $constop = $constop->sibling; + $version = $self->const_sv($constop)->int_value; + $constop = $constop->sibling; + return if $constop->name ne "method_named"; + return if $self->const_sv($constop)->PV ne "VERSION"; + } + + $lineseq = $version_op->sibling; + return if $lineseq->name ne "lineseq"; + my $entersub = $lineseq->first->sibling; + if ($entersub->name eq "stub") { + return "use $module $version ();\n" if defined $version; + return "use $module ();\n"; + } + return if $entersub->name ne "entersub"; + + # See if there are import arguments + my $args = ''; + + my $svop = $entersub->first->sibling; # Skip over pushmark + return unless $self->const_sv($svop)->PV eq $module; + + # Pull out the arguments + for ($svop=$svop->sibling; $svop->name ne "method_named"; + $svop = $svop->sibling) { + $args .= ", " if length($args); + $args .= $self->deparse($svop, 6); + } + + my $use = 'use'; + my $method_named = $svop; + return if $method_named->name ne "method_named"; + my $method_name = $self->const_sv($method_named)->PV; + + if ($method_name eq "unimport") { + $use = 'no'; + } + + # Certain pragmas are dealt with using hint bits, + # so we ignore them here + if ($module eq 'strict' || $module eq 'integer' + || $module eq 'bytes' || $module eq 'warnings') { + return ""; + } + + if (defined $version && length $args) { + return "$use $module $version ($args);\n"; + } elsif (defined $version) { + return "$use $module $version;\n"; + } elsif (length $args) { + return "$use $module ($args);\n"; + } else { + return "$use $module;\n"; + } +} + +sub stash_subs { + my ($self, $pack) = @_; + my (@ret, $stash); + if (!defined $pack) { + $pack = ''; + $stash = \%::; + } + else { + $pack =~ s/(::)?$/::/; + no strict 'refs'; + $stash = \%$pack; + } + my %stash = svref_2object($stash)->ARRAY; + while (my ($key, $val) = each %stash) { + next if $key eq 'main::'; # avoid infinite recursion + my $class = class($val); + if ($class eq "PV") { + # Just a prototype. As an ugly but fairly effective way + # to find out if it belongs here is to see if the AUTOLOAD + # (if any) for the stash was defined in one of our files. + my $A = $stash{"AUTOLOAD"}; + if (defined ($A) && class($A) eq "GV" && defined($A->CV) + && class($A->CV) eq "CV") { + my $AF = $A->FILE; + next unless $AF eq $0 || exists $self->{'files'}{$AF}; + } + push @{$self->{'protos_todo'}}, [$pack . $key, $val->PV]; + } elsif ($class eq "IV") { + # Just a name. As above. + my $A = $stash{"AUTOLOAD"}; + if (defined ($A) && class($A) eq "GV" && defined($A->CV) + && class($A->CV) eq "CV") { + my $AF = $A->FILE; + next unless $AF eq $0 || exists $self->{'files'}{$AF}; + } + push @{$self->{'protos_todo'}}, [$pack . $key, undef]; + } elsif ($class eq "GV") { + if (class(my $cv = $val->CV) ne "SPECIAL") { + next if $self->{'subs_done'}{$$val}++; + next if $$val != ${$cv->GV}; # Ignore imposters + $self->todo($cv, 0); + } + if (class(my $cv = $val->FORM) ne "SPECIAL") { + next if $self->{'forms_done'}{$$val}++; + next if $$val != ${$cv->GV}; # Ignore imposters + $self->todo($cv, 1); + } + if (class($val->HV) ne "SPECIAL" && $key =~ /::$/) { + $self->stash_subs($pack . $key); + } + } + } +} + +sub print_protos { + my $self = shift; + my $ar; + my @ret; + foreach $ar (@{$self->{'protos_todo'}}) { + my $proto = (defined $ar->[1] ? " (". $ar->[1] . ")" : ""); + push @ret, "sub " . $ar->[0] . "$proto;\n"; + } + delete $self->{'protos_todo'}; + return @ret; +} + +sub style_opts { + my $self = shift; + my $opts = shift; + my $opt; + while (length($opt = substr($opts, 0, 1))) { + if ($opt eq "C") { + $self->{'cuddle'} = " "; + $opts = substr($opts, 1); + } elsif ($opt eq "i") { + $opts =~ s/^i(\d+)//; + $self->{'indent_size'} = $1; + } elsif ($opt eq "T") { + $self->{'use_tabs'} = 1; + $opts = substr($opts, 1); + } elsif ($opt eq "v") { + $opts =~ s/^v([^.]*)(.|$)//; + $self->{'ex_const'} = $1; + } + } +} + +sub new { + my $class = shift; + my $self = bless {}, $class; + $self->{'subs_todo'} = []; + $self->{'files'} = {}; + $self->{'curstash'} = "main"; + $self->{'curcop'} = undef; + $self->{'cuddle'} = "\n"; + $self->{'indent_size'} = 4; + $self->{'use_tabs'} = 0; + $self->{'expand'} = 0; + $self->{'unquote'} = 0; + $self->{'linenums'} = 0; + $self->{'parens'} = 0; + $self->{'ex_const'} = "'???'"; + + $self->{'ambient_arybase'} = 0; + $self->{'ambient_warnings'} = undef; # Assume no lexical warnings + $self->{'ambient_hints'} = 0; + $self->init(); + + while (my $arg = shift @_) { + if ($arg =~ /^-f(.*)/) { + $self->{'files'}{$1} = 1; + } elsif ($arg eq "-p") { + $self->{'parens'} = 1; + } elsif ($arg eq "-P") { + $self->{'noproto'} = 1; + } elsif ($arg eq "-l") { + $self->{'linenums'} = 1; + } elsif ($arg eq "-q") { + $self->{'unquote'} = 1; + } elsif (substr($arg, 0, 2) eq "-s") { + $self->style_opts(substr $arg, 2); + } elsif ($arg =~ /^-x(\d)$/) { + $self->{'expand'} = $1; + } + } + return $self; +} + +{ + # Mask out the bits that L<warnings::register> uses + my $WARN_MASK; + BEGIN { + $WARN_MASK = $warnings::Bits{all} | $warnings::DeadBits{all}; + } + sub WARN_MASK () { + return $WARN_MASK; + } +} + +# Initialise the contextual information, either from +# defaults provided with the ambient_pragmas method, +# or from perl's own defaults otherwise. +sub init { + my $self = shift; + + $self->{'arybase'} = $self->{'ambient_arybase'}; + $self->{'warnings'} = defined ($self->{'ambient_warnings'}) + ? $self->{'ambient_warnings'} & WARN_MASK + : undef; + $self->{'hints'} = $self->{'ambient_hints'} & 0xFF; + + # also a convenient place to clear out subs_declared + delete $self->{'subs_declared'}; +} + +sub compile { + my(@args) = @_; + return sub { + my $self = B::Deparse->new(@args); + # First deparse command-line args + if (defined $^I) { # deparse -i + print q(BEGIN { $^I = ).perlstring($^I).qq(; }\n); + } + if ($^W) { # deparse -w + print qq(BEGIN { \$^W = $^W; }\n); + } + if ($/ ne "\n" or defined $O::savebackslash) { # deparse -l and -0 + my $fs = perlstring($/) || 'undef'; + my $bs = perlstring($O::savebackslash) || 'undef'; + print qq(BEGIN { \$/ = $fs; \$\\ = $bs; }\n); + } + my @BEGINs = B::begin_av->isa("B::AV") ? B::begin_av->ARRAY : (); + my @INITs = B::init_av->isa("B::AV") ? B::init_av->ARRAY : (); + my @ENDs = B::end_av->isa("B::AV") ? B::end_av->ARRAY : (); + for my $block (@BEGINs, @INITs, @ENDs) { + $self->todo($block, 0); + } + $self->stash_subs(); + $self->{'curcv'} = main_cv; + $self->{'curcvlex'} = undef; + print $self->print_protos; + @{$self->{'subs_todo'}} = + sort {$a->[0] <=> $b->[0]} @{$self->{'subs_todo'}}; + print $self->indent($self->deparse(main_root, 0)), "\n" + unless null main_root; + my @text; + while (scalar(@{$self->{'subs_todo'}})) { + push @text, $self->next_todo; + } + print $self->indent(join("", @text)), "\n" if @text; + + # Print __DATA__ section, if necessary + no strict 'refs'; + my $laststash = defined $self->{'curcop'} + ? $self->{'curcop'}->stash->NAME : $self->{'curstash'}; + if (defined *{$laststash."::DATA"}{IO}) { + print "__DATA__\n"; + print readline(*{$laststash."::DATA"}); + } + } +} + +sub coderef2text { + my $self = shift; + my $sub = shift; + croak "Usage: ->coderef2text(CODEREF)" unless UNIVERSAL::isa($sub, "CODE"); + + $self->init(); + return $self->indent($self->deparse_sub(svref_2object($sub))); +} + +sub ambient_pragmas { + my $self = shift; + my ($arybase, $hint_bits, $warning_bits) = (0, 0); + + while (@_ > 1) { + my $name = shift(); + my $val = shift(); + + if ($name eq 'strict') { + require strict; + + if ($val eq 'none') { + $hint_bits &= ~strict::bits(qw/refs subs vars/); + next(); + } + + my @names; + if ($val eq "all") { + @names = qw/refs subs vars/; + } + elsif (ref $val) { + @names = @$val; + } + else { + @names = split' ', $val; + } + $hint_bits |= strict::bits(@names); + } + + elsif ($name eq '$[') { + $arybase = $val; + } + + elsif ($name eq 'integer' + || $name eq 'bytes' + || $name eq 'utf8') { + require "$name.pm"; + if ($val) { + $hint_bits |= ${$::{"${name}::"}{"hint_bits"}}; + } + else { + $hint_bits &= ~${$::{"${name}::"}{"hint_bits"}}; + } + } + + elsif ($name eq 're') { + require re; + if ($val eq 'none') { + $hint_bits &= ~re::bits(qw/taint eval/); + next(); + } + + my @names; + if ($val eq 'all') { + @names = qw/taint eval/; + } + elsif (ref $val) { + @names = @$val; + } + else { + @names = split' ',$val; + } + $hint_bits |= re::bits(@names); + } + + elsif ($name eq 'warnings') { + if ($val eq 'none') { + $warning_bits = $warnings::NONE; + next(); + } + + my @names; + if (ref $val) { + @names = @$val; + } + else { + @names = split/\s+/, $val; + } + + $warning_bits = $warnings::NONE if !defined ($warning_bits); + $warning_bits |= warnings::bits(@names); + } + + elsif ($name eq 'warning_bits') { + $warning_bits = $val; + } + + elsif ($name eq 'hint_bits') { + $hint_bits = $val; + } + + else { + croak "Unknown pragma type: $name"; + } + } + if (@_) { + croak "The ambient_pragmas method expects an even number of args"; + } + + $self->{'ambient_arybase'} = $arybase; + $self->{'ambient_warnings'} = $warning_bits; + $self->{'ambient_hints'} = $hint_bits; +} + +sub deparse { + my $self = shift; + my($op, $cx, $flags) = @_; + + Carp::confess("Null op in deparse") if !defined($op) + || class($op) eq "NULL"; + my $meth = "pp_" . $op->name; + if (is_scope($op)) { + return $self->$meth($op, $cx, $flags); + } + return $self->$meth($op, $cx); +} + +sub indent { + my $self = shift; + my $txt = shift; + my @lines = split(/\n/, $txt); + my $leader = ""; + my $level = 0; + my $line; + for $line (@lines) { + my $cmd = substr($line, 0, 1); + if ($cmd eq "\t" or $cmd eq "\b") { + $level += ($cmd eq "\t" ? 1 : -1) * $self->{'indent_size'}; + if ($self->{'use_tabs'}) { + $leader = "\t" x ($level / 8) . " " x ($level % 8); + } else { + $leader = " " x $level; + } + $line = substr($line, 1); + } + if (substr($line, 0, 1) eq "\f") { + $line = substr($line, 1); # no indent + } else { + $line = $leader . $line; + } + $line =~ s/\cK;?//g; + } + return join("\n", @lines); +} + +sub deparse_sub { + my $self = shift; + my $cv = shift; + my $proto = ""; +Carp::confess("NULL in deparse_sub") if !defined($cv) || $cv->isa("B::NULL"); +Carp::confess("SPECIAL in deparse_sub") if $cv->isa("B::SPECIAL"); + local $self->{'curcop'} = $self->{'curcop'}; + if ($cv->FLAGS & SVf_POK) { + $proto = "(". $cv->PV . ") "; + } + if ($cv->CvFLAGS & (CVf_METHOD|CVf_LOCKED|CVf_LVALUE)) { + $proto .= ": "; + $proto .= "lvalue " if $cv->CvFLAGS & CVf_LVALUE; + $proto .= "locked " if $cv->CvFLAGS & CVf_LOCKED; + $proto .= "method " if $cv->CvFLAGS & CVf_METHOD; + } + + local($self->{'curcv'}) = $cv; + local($self->{'curcvlex'}); + local(@$self{qw'curstash warnings hints'}) + = @$self{qw'curstash warnings hints'}; + my $body; + if (not null $cv->ROOT) { + my $lineseq = $cv->ROOT->first; + if ($lineseq->name eq "lineseq") { + my @ops; + for(my$o=$lineseq->first; $$o; $o=$o->sibling) { + push @ops, $o; + } + $body = $self->lineseq(undef, @ops).";"; + my $scope_en = $self->find_scope_en($lineseq); + if (defined $scope_en) { + my $subs = join"", $self->seq_subs($scope_en); + $body .= ";\n$subs" if length($subs); + } + } + else { + $body = $self->deparse($cv->ROOT->first, 0); + } + } + else { + my $sv = $cv->const_sv; + if ($$sv) { + # uh-oh. inlinable sub... format it differently + return $proto . "{ " . const($sv) . " }\n"; + } else { # XSUB? (or just a declaration) + return "$proto;\n"; + } + } + return $proto ."{\n\t$body\n\b}" ."\n"; +} + +sub deparse_format { + my $self = shift; + my $form = shift; + my @text; + local($self->{'curcv'}) = $form; + local($self->{'curcvlex'}); + local($self->{'in_format'}) = 1; + local(@$self{qw'curstash warnings hints'}) + = @$self{qw'curstash warnings hints'}; + my $op = $form->ROOT; + my $kid; + return "\f." if $op->first->name eq 'stub' + || $op->first->name eq 'nextstate'; + $op = $op->first->first; # skip leavewrite, lineseq + while (not null $op) { + $op = $op->sibling; # skip nextstate + my @exprs; + $kid = $op->first->sibling; # skip pushmark + push @text, "\f".$self->const_sv($kid)->PV; + $kid = $kid->sibling; + for (; not null $kid; $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 0); + } + push @text, "\f".join(", ", @exprs)."\n" if @exprs; + $op = $op->sibling; + } + return join("", @text) . "\f."; +} + +sub is_scope { + my $op = shift; + return $op->name eq "leave" || $op->name eq "scope" + || $op->name eq "lineseq" + || ($op->name eq "null" && class($op) eq "UNOP" + && (is_scope($op->first) || $op->first->name eq "enter")); +} + +sub is_state { + my $name = $_[0]->name; + return $name eq "nextstate" || $name eq "dbstate" || $name eq "setstate"; +} + +sub is_miniwhile { # check for one-line loop (`foo() while $y--') + my $op = shift; + return (!null($op) and null($op->sibling) + and $op->name eq "null" and class($op) eq "UNOP" + and (($op->first->name =~ /^(and|or)$/ + and $op->first->first->sibling->name eq "lineseq") + or ($op->first->name eq "lineseq" + and not null $op->first->first->sibling + and $op->first->first->sibling->name eq "unstack") + )); +} + +sub is_scalar { + my $op = shift; + return ($op->name eq "rv2sv" or + $op->name eq "padsv" or + $op->name eq "gv" or # only in array/hash constructs + $op->flags & OPf_KIDS && !null($op->first) + && $op->first->name eq "gvsv"); +} + +sub maybe_parens { + my $self = shift; + my($text, $cx, $prec) = @_; + if ($prec < $cx # unary ops nest just fine + or $prec == $cx and $cx != 4 and $cx != 16 and $cx != 21 + or $self->{'parens'}) + { + $text = "($text)"; + # In a unop, let parent reuse our parens; see maybe_parens_unop + $text = "\cS" . $text if $cx == 16; + return $text; + } else { + return $text; + } +} + +# same as above, but get around the `if it looks like a function' rule +sub maybe_parens_unop { + my $self = shift; + my($name, $kid, $cx) = @_; + if ($cx > 16 or $self->{'parens'}) { + $kid = $self->deparse($kid, 1); + if ($name eq "umask" && $kid =~ /^\d+$/) { + $kid = sprintf("%#o", $kid); + } + return "$name($kid)"; + } else { + $kid = $self->deparse($kid, 16); + if ($name eq "umask" && $kid =~ /^\d+$/) { + $kid = sprintf("%#o", $kid); + } + if (substr($kid, 0, 1) eq "\cS") { + # use kid's parens + return $name . substr($kid, 1); + } elsif (substr($kid, 0, 1) eq "(") { + # avoid looks-like-a-function trap with extra parens + # (`+' can lead to ambiguities) + return "$name(" . $kid . ")"; + } else { + return "$name $kid"; + } + } +} + +sub maybe_parens_func { + my $self = shift; + my($func, $text, $cx, $prec) = @_; + if ($prec <= $cx or substr($text, 0, 1) eq "(" or $self->{'parens'}) { + return "$func($text)"; + } else { + return "$func $text"; + } +} + +sub maybe_local { + my $self = shift; + my($op, $cx, $text) = @_; + my $our_intro = ($op->name =~ /^(gv|rv2)[ash]v$/) ? OPpOUR_INTRO : 0; + if ($op->private & (OPpLVAL_INTRO|$our_intro) + and not $self->{'avoid_local'}{$$op}) { + my $our_local = ($op->private & OPpLVAL_INTRO) ? "local" : "our"; + if (want_scalar($op)) { + return "$our_local $text"; + } else { + return $self->maybe_parens_func("$our_local", $text, $cx, 16); + } + } else { + return $text; + } +} + +sub maybe_targmy { + my $self = shift; + my($op, $cx, $func, @args) = @_; + if ($op->private & OPpTARGET_MY) { + my $var = $self->padname($op->targ); + my $val = $func->($self, $op, 7, @args); + return $self->maybe_parens("$var = $val", $cx, 7); + } else { + return $func->($self, $op, $cx, @args); + } +} + +sub padname_sv { + my $self = shift; + my $targ = shift; + return (($self->{'curcv'}->PADLIST->ARRAY)[0]->ARRAY)[$targ]; +} + +sub maybe_my { + my $self = shift; + my($op, $cx, $text) = @_; + if ($op->private & OPpLVAL_INTRO and not $self->{'avoid_local'}{$$op}) { + if (want_scalar($op)) { + return "my $text"; + } else { + return $self->maybe_parens_func("my", $text, $cx, 16); + } + } else { + return $text; + } +} + +# The following OPs don't have functions: + +# pp_padany -- does not exist after parsing + +sub AUTOLOAD { + if ($AUTOLOAD =~ s/^.*::pp_//) { + warn "unexpected OP_".uc $AUTOLOAD; + return "XXX"; + } else { + die "Undefined subroutine $AUTOLOAD called"; + } +} + +sub DESTROY {} # Do not AUTOLOAD + +# $root should be the op which represents the root of whatever +# we're sequencing here. If it's undefined, then we don't append +# any subroutine declarations to the deparsed ops, otherwise we +# append appropriate declarations. +sub lineseq { + my($self, $root, @ops) = @_; + my($expr, @exprs); + + my $out_cop = $self->{'curcop'}; + my $out_seq = defined($out_cop) ? $out_cop->cop_seq : undef; + my $limit_seq; + if (defined $root) { + $limit_seq = $out_seq; + my $nseq = $self->find_scope_st($root->sibling) if ${$root->sibling}; + $limit_seq = $nseq if !defined($limit_seq) + or defined($nseq) && $nseq < $limit_seq; + } + $limit_seq = $self->{'limit_seq'} + if defined($self->{'limit_seq'}) + && (!defined($limit_seq) || $self->{'limit_seq'} < $limit_seq); + local $self->{'limit_seq'} = $limit_seq; + for (my $i = 0; $i < @ops; $i++) { + $expr = ""; + if (is_state $ops[$i]) { + $expr = $self->deparse($ops[$i], 0); + $i++; + if ($i > $#ops) { + push @exprs, $expr; + last; + } + } + if (!is_state $ops[$i] and (my $ls = $ops[$i+1]) and + !null($ops[$i+1]) and $ops[$i+1]->name eq "lineseq") + { + if ($ls->first && !null($ls->first) && is_state($ls->first) + && (my $sib = $ls->first->sibling)) { + if (!null($sib) && $sib->name eq "leaveloop") { + push @exprs, $expr . $self->for_loop($ops[$i], 0); + $i++; + next; + } + } + } + $expr .= $self->deparse($ops[$i], 0, (@ops != 1)); + $expr =~ s/;\n?\z//; + push @exprs, $expr; + } + my $body = join(";\n", grep {length} @exprs); + my $subs = ""; + if (defined $root && defined $limit_seq && !$self->{'in_format'}) { + $subs = join "\n", $self->seq_subs($limit_seq); + } + return join(";\n", grep {length} $body, $subs); +} + +sub scopeop { + my($real_block, $self, $op, $cx, $flags) = @_; + my $kid; + my @kids; + + local(@$self{qw'curstash warnings hints'}) + = @$self{qw'curstash warnings hints'} if $real_block; + if ($real_block) { + $kid = $op->first->sibling; # skip enter + if (is_miniwhile($kid)) { + my $top = $kid->first; + my $name = $top->name; + if ($name eq "and") { + $name = "while"; + } elsif ($name eq "or") { + $name = "until"; + } else { # no conditional -> while 1 or until 0 + return $self->deparse($top->first, 1) . " while 1"; + } + my $cond = $top->first; + my $body = $cond->sibling->first; # skip lineseq + $cond = $self->deparse($cond, 1); + $body = $self->deparse($body, 1); + return "$body $name $cond"; + } + } else { + $kid = $op->first; + } + for (; !null($kid); $kid = $kid->sibling) { + push @kids, $kid; + } + if ($flags || $cx > 0) { # inside an expression, (a do {} while for lineseq) + return "do {\n\t" . $self->lineseq($op, @kids) . "\n\b}"; + } else { + my $lineseq = $self->lineseq($op, @kids); + return (length ($lineseq) ? "$lineseq;" : ""); + } +} + +sub pp_scope { scopeop(0, @_); } +sub pp_lineseq { scopeop(0, @_); } +sub pp_leave { scopeop(1, @_); } + +# The BEGIN {} is used here because otherwise this code isn't executed +# when you run B::Deparse on itself. +my %globalnames; +BEGIN { map($globalnames{$_}++, "SIG", "STDIN", "STDOUT", "STDERR", "INC", + "ENV", "ARGV", "ARGVOUT", "_"); } + +sub gv_name { + my $self = shift; + my $gv = shift; +Carp::confess() if $gv->isa("B::CV"); + my $stash = $gv->STASH->NAME; + my $name = $gv->SAFENAME; + if (($stash eq 'main' && $globalnames{$name}) + or ($stash eq $self->{'curstash'} && !$globalnames{$name}) + or $name =~ /^[^A-Za-z_]/) + { + $stash = ""; + } else { + $stash = $stash . "::"; + } + if ($name =~ /^(\^..|{)/) { + $name = "{$name}"; # ${^WARNING_BITS}, etc and ${ + } + return $stash . $name; +} + +# Return the name to use for a stash variable. +# If a lexical with the same name is in scope, it may need to be +# fully-qualified. +sub stash_variable { + my ($self, $prefix, $name) = @_; + + return "$prefix$name" if $name =~ /::/; + + unless ($prefix eq '$' || $prefix eq '@' || + $prefix eq '%' || $prefix eq '$#') { + return "$prefix$name"; + } + + my $v = ($prefix eq '$#' ? '@' : $prefix) . $name; + return $prefix .$self->{'curstash'}.'::'. $name if $self->lex_in_scope($v); + return "$prefix$name"; +} + +sub lex_in_scope { + my ($self, $name) = @_; + $self->populate_curcvlex() if !defined $self->{'curcvlex'}; + + return 0 if !defined($self->{'curcop'}); + my $seq = $self->{'curcop'}->cop_seq; + return 0 if !exists $self->{'curcvlex'}{$name}; + for my $a (@{$self->{'curcvlex'}{$name}}) { + my ($st, $en) = @$a; + return 1 if $seq > $st && $seq <= $en; + } + return 0; +} + +sub populate_curcvlex { + my $self = shift; + for (my $cv = $self->{'curcv'}; class($cv) eq "CV"; $cv = $cv->OUTSIDE) { + my @padlist = $cv->PADLIST->ARRAY; + my @ns = $padlist[0]->ARRAY; + + for (my $i=0; $i<@ns; ++$i) { + next if class($ns[$i]) eq "SPECIAL"; + next if $ns[$i]->FLAGS & SVpad_OUR; # Skip "our" vars + if (class($ns[$i]) eq "PV") { + # Probably that pesky lexical @_ + next; + } + my $name = $ns[$i]->PVX; + my $seq_st = $ns[$i]->NVX; + my $seq_en = int($ns[$i]->IVX); + + push @{$self->{'curcvlex'}{$name}}, [$seq_st, $seq_en]; + } + } +} + +sub find_scope_st { ((find_scope(@_))[0]); } +sub find_scope_en { ((find_scope(@_))[1]); } + +# Recurses down the tree, looking for pad variable introductions and COPs +sub find_scope { + my ($self, $op, $scope_st, $scope_en) = @_; + carp("Undefined op in find_scope") if !defined $op; + return ($scope_st, $scope_en) unless $op->flags & OPf_KIDS; + + for (my $o=$op->first; $$o; $o=$o->sibling) { + if ($o->name =~ /^pad.v$/ && $o->private & OPpLVAL_INTRO) { + my $s = int($self->padname_sv($o->targ)->NVX); + my $e = $self->padname_sv($o->targ)->IVX; + $scope_st = $s if !defined($scope_st) || $s < $scope_st; + $scope_en = $e if !defined($scope_en) || $e > $scope_en; + } + elsif (is_state($o)) { + my $c = $o->cop_seq; + $scope_st = $c if !defined($scope_st) || $c < $scope_st; + $scope_en = $c if !defined($scope_en) || $c > $scope_en; + } + elsif ($o->flags & OPf_KIDS) { + ($scope_st, $scope_en) = + $self->find_scope($o, $scope_st, $scope_en) + } + } + + return ($scope_st, $scope_en); +} + +# Returns a list of subs which should be inserted before the COP +sub cop_subs { + my ($self, $op, $out_seq) = @_; + my $seq = $op->cop_seq; + # If we have nephews, then our sequence number indicates + # the cop_seq of the end of some sort of scope. + if (class($op->sibling) ne "NULL" && $op->sibling->flags & OPf_KIDS + and my $nseq = $self->find_scope_st($op->sibling) ) { + $seq = $nseq; + } + $seq = $out_seq if defined($out_seq) && $out_seq < $seq; + return $self->seq_subs($seq); +} + +sub seq_subs { + my ($self, $seq) = @_; + my @text; +#push @text, "# ($seq)\n"; + + return "" if !defined $seq; + while (scalar(@{$self->{'subs_todo'}}) + and $seq > $self->{'subs_todo'}[0][0]) { + push @text, $self->next_todo; + } + return @text; +} + +# Notice how subs and formats are inserted between statements here; +# also $[ assignments and pragmas. +sub pp_nextstate { + my $self = shift; + my($op, $cx) = @_; + $self->{'curcop'} = $op; + my @text; + push @text, $self->cop_subs($op); + push @text, $op->label . ": " if $op->label; + my $stash = $op->stashpv; + if ($stash ne $self->{'curstash'}) { + push @text, "package $stash;\n"; + $self->{'curstash'} = $stash; + } + if ($self->{'linenums'}) { + push @text, "\f#line " . $op->line . + ' "' . $op->file, qq'"\n'; + } + + if ($self->{'arybase'} != $op->arybase) { + push @text, '$[ = '. $op->arybase .";\n"; + $self->{'arybase'} = $op->arybase; + } + + my $warnings = $op->warnings; + my $warning_bits; + if ($warnings->isa("B::SPECIAL") && $$warnings == 4) { + $warning_bits = $warnings::Bits{"all"} & WARN_MASK; + } + elsif ($warnings->isa("B::SPECIAL") && $$warnings == 5) { + $warning_bits = $warnings::NONE; + } + elsif ($warnings->isa("B::SPECIAL")) { + $warning_bits = undef; + } + else { + $warning_bits = $warnings->PV & WARN_MASK; + } + + if (defined ($warning_bits) and + !defined($self->{warnings}) || $self->{'warnings'} ne $warning_bits) { + push @text, declare_warnings($self->{'warnings'}, $warning_bits); + $self->{'warnings'} = $warning_bits; + } + + if ($self->{'hints'} != $op->private) { + push @text, declare_hints($self->{'hints'}, $op->private); + $self->{'hints'} = $op->private; + } + + return join("", @text); +} + +sub declare_warnings { + my ($from, $to) = @_; + if (($to & WARN_MASK) eq warnings::bits("all")) { + return "use warnings;\n"; + } + elsif (($to & WARN_MASK) eq "\0"x length($to)) { + return "no warnings;\n"; + } + return "BEGIN {\${^WARNING_BITS} = ".perlstring($to)."}\n"; +} + +sub declare_hints { + my ($from, $to) = @_; + my $use = $to & ~$from; + my $no = $from & ~$to; + my $decls = ""; + for my $pragma (hint_pragmas($use)) { + $decls .= "use $pragma;\n"; + } + for my $pragma (hint_pragmas($no)) { + $decls .= "no $pragma;\n"; + } + return $decls; +} + +sub hint_pragmas { + my ($bits) = @_; + my @pragmas; + push @pragmas, "integer" if $bits & 0x1; + push @pragmas, "strict 'refs'" if $bits & 0x2; + push @pragmas, "bytes" if $bits & 0x8; + return @pragmas; +} + +sub pp_dbstate { pp_nextstate(@_) } +sub pp_setstate { pp_nextstate(@_) } + +sub pp_unstack { return "" } # see also leaveloop + +sub baseop { + my $self = shift; + my($op, $cx, $name) = @_; + return $name; +} + +sub pp_stub { + my $self = shift; + my($op, $cx, $name) = @_; + if ($cx) { + return "()"; + } + else { + return "();"; + } +} +sub pp_wantarray { baseop(@_, "wantarray") } +sub pp_fork { baseop(@_, "fork") } +sub pp_wait { maybe_targmy(@_, \&baseop, "wait") } +sub pp_getppid { maybe_targmy(@_, \&baseop, "getppid") } +sub pp_time { maybe_targmy(@_, \&baseop, "time") } +sub pp_tms { baseop(@_, "times") } +sub pp_ghostent { baseop(@_, "gethostent") } +sub pp_gnetent { baseop(@_, "getnetent") } +sub pp_gprotoent { baseop(@_, "getprotoent") } +sub pp_gservent { baseop(@_, "getservent") } +sub pp_ehostent { baseop(@_, "endhostent") } +sub pp_enetent { baseop(@_, "endnetent") } +sub pp_eprotoent { baseop(@_, "endprotoent") } +sub pp_eservent { baseop(@_, "endservent") } +sub pp_gpwent { baseop(@_, "getpwent") } +sub pp_spwent { baseop(@_, "setpwent") } +sub pp_epwent { baseop(@_, "endpwent") } +sub pp_ggrent { baseop(@_, "getgrent") } +sub pp_sgrent { baseop(@_, "setgrent") } +sub pp_egrent { baseop(@_, "endgrent") } +sub pp_getlogin { baseop(@_, "getlogin") } + +sub POSTFIX () { 1 } + +# I couldn't think of a good short name, but this is the category of +# symbolic unary operators with interesting precedence + +sub pfixop { + my $self = shift; + my($op, $cx, $name, $prec, $flags) = (@_, 0); + my $kid = $op->first; + $kid = $self->deparse($kid, $prec); + return $self->maybe_parens(($flags & POSTFIX) ? "$kid$name" : "$name$kid", + $cx, $prec); +} + +sub pp_preinc { pfixop(@_, "++", 23) } +sub pp_predec { pfixop(@_, "--", 23) } +sub pp_postinc { maybe_targmy(@_, \&pfixop, "++", 23, POSTFIX) } +sub pp_postdec { maybe_targmy(@_, \&pfixop, "--", 23, POSTFIX) } +sub pp_i_preinc { pfixop(@_, "++", 23) } +sub pp_i_predec { pfixop(@_, "--", 23) } +sub pp_i_postinc { maybe_targmy(@_, \&pfixop, "++", 23, POSTFIX) } +sub pp_i_postdec { maybe_targmy(@_, \&pfixop, "--", 23, POSTFIX) } +sub pp_complement { maybe_targmy(@_, \&pfixop, "~", 21) } + +sub pp_negate { maybe_targmy(@_, \&real_negate) } +sub real_negate { + my $self = shift; + my($op, $cx) = @_; + if ($op->first->name =~ /^(i_)?negate$/) { + # avoid --$x + $self->pfixop($op, $cx, "-", 21.5); + } else { + $self->pfixop($op, $cx, "-", 21); + } +} +sub pp_i_negate { pp_negate(@_) } + +sub pp_not { + my $self = shift; + my($op, $cx) = @_; + if ($cx <= 4) { + $self->pfixop($op, $cx, "not ", 4); + } else { + $self->pfixop($op, $cx, "!", 21); + } +} + +sub unop { + my $self = shift; + my($op, $cx, $name) = @_; + my $kid; + if ($op->flags & OPf_KIDS) { + $kid = $op->first; + if (defined prototype("CORE::$name") + && prototype("CORE::$name") =~ /^;?\*/ + && $kid->name eq "rv2gv") { + $kid = $kid->first; + } + + return $self->maybe_parens_unop($name, $kid, $cx); + } else { + return $name . ($op->flags & OPf_SPECIAL ? "()" : ""); + } +} + +sub pp_chop { maybe_targmy(@_, \&unop, "chop") } +sub pp_chomp { maybe_targmy(@_, \&unop, "chomp") } +sub pp_schop { maybe_targmy(@_, \&unop, "chop") } +sub pp_schomp { maybe_targmy(@_, \&unop, "chomp") } +sub pp_defined { unop(@_, "defined") } +sub pp_undef { unop(@_, "undef") } +sub pp_study { unop(@_, "study") } +sub pp_ref { unop(@_, "ref") } +sub pp_pos { maybe_local(@_, unop(@_, "pos")) } + +sub pp_sin { maybe_targmy(@_, \&unop, "sin") } +sub pp_cos { maybe_targmy(@_, \&unop, "cos") } +sub pp_rand { maybe_targmy(@_, \&unop, "rand") } +sub pp_srand { unop(@_, "srand") } +sub pp_exp { maybe_targmy(@_, \&unop, "exp") } +sub pp_log { maybe_targmy(@_, \&unop, "log") } +sub pp_sqrt { maybe_targmy(@_, \&unop, "sqrt") } +sub pp_int { maybe_targmy(@_, \&unop, "int") } +sub pp_hex { maybe_targmy(@_, \&unop, "hex") } +sub pp_oct { maybe_targmy(@_, \&unop, "oct") } +sub pp_abs { maybe_targmy(@_, \&unop, "abs") } + +sub pp_length { maybe_targmy(@_, \&unop, "length") } +sub pp_ord { maybe_targmy(@_, \&unop, "ord") } +sub pp_chr { maybe_targmy(@_, \&unop, "chr") } + +sub pp_each { unop(@_, "each") } +sub pp_values { unop(@_, "values") } +sub pp_keys { unop(@_, "keys") } +sub pp_pop { unop(@_, "pop") } +sub pp_shift { unop(@_, "shift") } + +sub pp_caller { unop(@_, "caller") } +sub pp_reset { unop(@_, "reset") } +sub pp_exit { unop(@_, "exit") } +sub pp_prototype { unop(@_, "prototype") } + +sub pp_close { unop(@_, "close") } +sub pp_fileno { unop(@_, "fileno") } +sub pp_umask { unop(@_, "umask") } +sub pp_untie { unop(@_, "untie") } +sub pp_tied { unop(@_, "tied") } +sub pp_dbmclose { unop(@_, "dbmclose") } +sub pp_getc { unop(@_, "getc") } +sub pp_eof { unop(@_, "eof") } +sub pp_tell { unop(@_, "tell") } +sub pp_getsockname { unop(@_, "getsockname") } +sub pp_getpeername { unop(@_, "getpeername") } + +sub pp_chdir { maybe_targmy(@_, \&unop, "chdir") } +sub pp_chroot { maybe_targmy(@_, \&unop, "chroot") } +sub pp_readlink { unop(@_, "readlink") } +sub pp_rmdir { maybe_targmy(@_, \&unop, "rmdir") } +sub pp_readdir { unop(@_, "readdir") } +sub pp_telldir { unop(@_, "telldir") } +sub pp_rewinddir { unop(@_, "rewinddir") } +sub pp_closedir { unop(@_, "closedir") } +sub pp_getpgrp { maybe_targmy(@_, \&unop, "getpgrp") } +sub pp_localtime { unop(@_, "localtime") } +sub pp_gmtime { unop(@_, "gmtime") } +sub pp_alarm { unop(@_, "alarm") } +sub pp_sleep { maybe_targmy(@_, \&unop, "sleep") } + +sub pp_dofile { unop(@_, "do") } +sub pp_entereval { unop(@_, "eval") } + +sub pp_ghbyname { unop(@_, "gethostbyname") } +sub pp_gnbyname { unop(@_, "getnetbyname") } +sub pp_gpbyname { unop(@_, "getprotobyname") } +sub pp_shostent { unop(@_, "sethostent") } +sub pp_snetent { unop(@_, "setnetent") } +sub pp_sprotoent { unop(@_, "setprotoent") } +sub pp_sservent { unop(@_, "setservent") } +sub pp_gpwnam { unop(@_, "getpwnam") } +sub pp_gpwuid { unop(@_, "getpwuid") } +sub pp_ggrnam { unop(@_, "getgrnam") } +sub pp_ggrgid { unop(@_, "getgrgid") } + +sub pp_lock { unop(@_, "lock") } + +sub pp_exists { + my $self = shift; + my($op, $cx) = @_; + my $arg; + if ($op->private & OPpEXISTS_SUB) { + # Checking for the existence of a subroutine + return $self->maybe_parens_func("exists", + $self->pp_rv2cv($op->first, 16), $cx, 16); + } + if ($op->flags & OPf_SPECIAL) { + # Array element, not hash element + return $self->maybe_parens_func("exists", + $self->pp_aelem($op->first, 16), $cx, 16); + } + return $self->maybe_parens_func("exists", $self->pp_helem($op->first, 16), + $cx, 16); +} + +sub pp_delete { + my $self = shift; + my($op, $cx) = @_; + my $arg; + if ($op->private & OPpSLICE) { + if ($op->flags & OPf_SPECIAL) { + # Deleting from an array, not a hash + return $self->maybe_parens_func("delete", + $self->pp_aslice($op->first, 16), + $cx, 16); + } + return $self->maybe_parens_func("delete", + $self->pp_hslice($op->first, 16), + $cx, 16); + } else { + if ($op->flags & OPf_SPECIAL) { + # Deleting from an array, not a hash + return $self->maybe_parens_func("delete", + $self->pp_aelem($op->first, 16), + $cx, 16); + } + return $self->maybe_parens_func("delete", + $self->pp_helem($op->first, 16), + $cx, 16); + } +} + +sub pp_require { + my $self = shift; + my($op, $cx) = @_; + if (class($op) eq "UNOP" and $op->first->name eq "const" + and $op->first->private & OPpCONST_BARE) + { + my $name = $self->const_sv($op->first)->PV; + $name =~ s[/][::]g; + $name =~ s/\.pm//g; + return "require $name"; + } else { + $self->unop($op, $cx, "require"); + } +} + +sub pp_scalar { + my $self = shift; + my($op, $cv) = @_; + my $kid = $op->first; + if (not null $kid->sibling) { + # XXX Was a here-doc + return $self->dquote($op); + } + $self->unop(@_, "scalar"); +} + + +sub padval { + my $self = shift; + my $targ = shift; + return (($self->{'curcv'}->PADLIST->ARRAY)[1]->ARRAY)[$targ]; +} + +sub pp_refgen { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first; + if ($kid->name eq "null") { + $kid = $kid->first; + if ($kid->name eq "anonlist" || $kid->name eq "anonhash") { + my($pre, $post) = @{{"anonlist" => ["[","]"], + "anonhash" => ["{","}"]}->{$kid->name}}; + my($expr, @exprs); + $kid = $kid->first->sibling; # skip pushmark + for (; !null($kid); $kid = $kid->sibling) { + $expr = $self->deparse($kid, 6); + push @exprs, $expr; + } + return $pre . join(", ", @exprs) . $post; + } elsif (!null($kid->sibling) and + $kid->sibling->name eq "anoncode") { + return "sub " . + $self->deparse_sub($self->padval($kid->sibling->targ)); + } elsif ($kid->name eq "pushmark") { + my $sib_name = $kid->sibling->name; + if ($sib_name =~ /^(pad|rv2)[ah]v$/ + and not $kid->sibling->flags & OPf_REF) + { + # The @a in \(@a) isn't in ref context, but only when the + # parens are there. + return "\\(" . $self->deparse($kid->sibling, 1) . ")"; + } elsif ($sib_name eq 'entersub') { + my $text = $self->deparse($kid->sibling, 1); + # Always show parens for \(&func()), but only with -p otherwise + $text = "($text)" if $self->{'parens'} + or $kid->sibling->private & OPpENTERSUB_AMPER; + return "\\$text"; + } + } + } + $self->pfixop($op, $cx, "\\", 20); +} + +sub pp_srefgen { pp_refgen(@_) } + +sub pp_readline { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first; + $kid = $kid->first if $kid->name eq "rv2gv"; # <$fh> + return "<" . $self->deparse($kid, 1) . ">" if is_scalar($kid); + return $self->unop($op, $cx, "readline"); +} + +sub pp_rcatline { + my $self = shift; + my($op) = @_; + return "<" . $self->gv_name($op->gv) . ">"; +} + +# Unary operators that can occur as pseudo-listops inside double quotes +sub dq_unop { + my $self = shift; + my($op, $cx, $name, $prec, $flags) = (@_, 0, 0); + my $kid; + if ($op->flags & OPf_KIDS) { + $kid = $op->first; + # If there's more than one kid, the first is an ex-pushmark. + $kid = $kid->sibling if not null $kid->sibling; + return $self->maybe_parens_unop($name, $kid, $cx); + } else { + return $name . ($op->flags & OPf_SPECIAL ? "()" : ""); + } +} + +sub pp_ucfirst { dq_unop(@_, "ucfirst") } +sub pp_lcfirst { dq_unop(@_, "lcfirst") } +sub pp_uc { dq_unop(@_, "uc") } +sub pp_lc { dq_unop(@_, "lc") } +sub pp_quotemeta { maybe_targmy(@_, \&dq_unop, "quotemeta") } + +sub loopex { + my $self = shift; + my ($op, $cx, $name) = @_; + if (class($op) eq "PVOP") { + return "$name " . $op->pv; + } elsif (class($op) eq "OP") { + return $name; + } elsif (class($op) eq "UNOP") { + # Note -- loop exits are actually exempt from the + # looks-like-a-func rule, but a few extra parens won't hurt + return $self->maybe_parens_unop($name, $op->first, $cx); + } +} + +sub pp_last { loopex(@_, "last") } +sub pp_next { loopex(@_, "next") } +sub pp_redo { loopex(@_, "redo") } +sub pp_goto { loopex(@_, "goto") } +sub pp_dump { loopex(@_, "dump") } + +sub ftst { + my $self = shift; + my($op, $cx, $name) = @_; + if (class($op) eq "UNOP") { + # Genuine `-X' filetests are exempt from the LLAFR, but not + # l?stat(); for the sake of clarity, give'em all parens + return $self->maybe_parens_unop($name, $op->first, $cx); + } elsif (class($op) eq "SVOP") { + return $self->maybe_parens_func($name, $self->pp_gv($op, 1), $cx, 16); + } else { # I don't think baseop filetests ever survive ck_ftst, but... + return $name; + } +} + +sub pp_lstat { ftst(@_, "lstat") } +sub pp_stat { ftst(@_, "stat") } +sub pp_ftrread { ftst(@_, "-R") } +sub pp_ftrwrite { ftst(@_, "-W") } +sub pp_ftrexec { ftst(@_, "-X") } +sub pp_fteread { ftst(@_, "-r") } +sub pp_ftewrite { ftst(@_, "-w") } +sub pp_fteexec { ftst(@_, "-x") } +sub pp_ftis { ftst(@_, "-e") } +sub pp_fteowned { ftst(@_, "-O") } +sub pp_ftrowned { ftst(@_, "-o") } +sub pp_ftzero { ftst(@_, "-z") } +sub pp_ftsize { ftst(@_, "-s") } +sub pp_ftmtime { ftst(@_, "-M") } +sub pp_ftatime { ftst(@_, "-A") } +sub pp_ftctime { ftst(@_, "-C") } +sub pp_ftsock { ftst(@_, "-S") } +sub pp_ftchr { ftst(@_, "-c") } +sub pp_ftblk { ftst(@_, "-b") } +sub pp_ftfile { ftst(@_, "-f") } +sub pp_ftdir { ftst(@_, "-d") } +sub pp_ftpipe { ftst(@_, "-p") } +sub pp_ftlink { ftst(@_, "-l") } +sub pp_ftsuid { ftst(@_, "-u") } +sub pp_ftsgid { ftst(@_, "-g") } +sub pp_ftsvtx { ftst(@_, "-k") } +sub pp_fttty { ftst(@_, "-t") } +sub pp_fttext { ftst(@_, "-T") } +sub pp_ftbinary { ftst(@_, "-B") } + +sub SWAP_CHILDREN () { 1 } +sub ASSIGN () { 2 } # has OP= variant +sub LIST_CONTEXT () { 4 } # Assignment is in list context + +my(%left, %right); + +sub assoc_class { + my $op = shift; + my $name = $op->name; + if ($name eq "concat" and $op->first->name eq "concat") { + # avoid spurious `=' -- see comment in pp_concat + return "concat"; + } + if ($name eq "null" and class($op) eq "UNOP" + and $op->first->name =~ /^(and|x?or)$/ + and null $op->first->sibling) + { + # Like all conditional constructs, OP_ANDs and OP_ORs are topped + # with a null that's used as the common end point of the two + # flows of control. For precedence purposes, ignore it. + # (COND_EXPRs have these too, but we don't bother with + # their associativity). + return assoc_class($op->first); + } + return $name . ($op->flags & OPf_STACKED ? "=" : ""); +} + +# Left associative operators, like `+', for which +# $a + $b + $c is equivalent to ($a + $b) + $c + +BEGIN { + %left = ('multiply' => 19, 'i_multiply' => 19, + 'divide' => 19, 'i_divide' => 19, + 'modulo' => 19, 'i_modulo' => 19, + 'repeat' => 19, + 'add' => 18, 'i_add' => 18, + 'subtract' => 18, 'i_subtract' => 18, + 'concat' => 18, + 'left_shift' => 17, 'right_shift' => 17, + 'bit_and' => 13, + 'bit_or' => 12, 'bit_xor' => 12, + 'and' => 3, + 'or' => 2, 'xor' => 2, + ); +} + +sub deparse_binop_left { + my $self = shift; + my($op, $left, $prec) = @_; + if ($left{assoc_class($op)} && $left{assoc_class($left)} + and $left{assoc_class($op)} == $left{assoc_class($left)}) + { + return $self->deparse($left, $prec - .00001); + } else { + return $self->deparse($left, $prec); + } +} + +# Right associative operators, like `=', for which +# $a = $b = $c is equivalent to $a = ($b = $c) + +BEGIN { + %right = ('pow' => 22, + 'sassign=' => 7, 'aassign=' => 7, + 'multiply=' => 7, 'i_multiply=' => 7, + 'divide=' => 7, 'i_divide=' => 7, + 'modulo=' => 7, 'i_modulo=' => 7, + 'repeat=' => 7, + 'add=' => 7, 'i_add=' => 7, + 'subtract=' => 7, 'i_subtract=' => 7, + 'concat=' => 7, + 'left_shift=' => 7, 'right_shift=' => 7, + 'bit_and=' => 7, + 'bit_or=' => 7, 'bit_xor=' => 7, + 'andassign' => 7, + 'orassign' => 7, + ); +} + +sub deparse_binop_right { + my $self = shift; + my($op, $right, $prec) = @_; + if ($right{assoc_class($op)} && $right{assoc_class($right)} + and $right{assoc_class($op)} == $right{assoc_class($right)}) + { + return $self->deparse($right, $prec - .00001); + } else { + return $self->deparse($right, $prec); + } +} + +sub binop { + my $self = shift; + my ($op, $cx, $opname, $prec, $flags) = (@_, 0); + my $left = $op->first; + my $right = $op->last; + my $eq = ""; + if ($op->flags & OPf_STACKED && $flags & ASSIGN) { + $eq = "="; + $prec = 7; + } + if ($flags & SWAP_CHILDREN) { + ($left, $right) = ($right, $left); + } + $left = $self->deparse_binop_left($op, $left, $prec); + $left = "($left)" if $flags & LIST_CONTEXT + && $left !~ /^(my|our|local|)[\@\(]/; + $right = $self->deparse_binop_right($op, $right, $prec); + return $self->maybe_parens("$left $opname$eq $right", $cx, $prec); +} + +sub pp_add { maybe_targmy(@_, \&binop, "+", 18, ASSIGN) } +sub pp_multiply { maybe_targmy(@_, \&binop, "*", 19, ASSIGN) } +sub pp_subtract { maybe_targmy(@_, \&binop, "-",18, ASSIGN) } +sub pp_divide { maybe_targmy(@_, \&binop, "/", 19, ASSIGN) } +sub pp_modulo { maybe_targmy(@_, \&binop, "%", 19, ASSIGN) } +sub pp_i_add { maybe_targmy(@_, \&binop, "+", 18, ASSIGN) } +sub pp_i_multiply { maybe_targmy(@_, \&binop, "*", 19, ASSIGN) } +sub pp_i_subtract { maybe_targmy(@_, \&binop, "-", 18, ASSIGN) } +sub pp_i_divide { maybe_targmy(@_, \&binop, "/", 19, ASSIGN) } +sub pp_i_modulo { maybe_targmy(@_, \&binop, "%", 19, ASSIGN) } +sub pp_pow { maybe_targmy(@_, \&binop, "**", 22, ASSIGN) } + +sub pp_left_shift { maybe_targmy(@_, \&binop, "<<", 17, ASSIGN) } +sub pp_right_shift { maybe_targmy(@_, \&binop, ">>", 17, ASSIGN) } +sub pp_bit_and { maybe_targmy(@_, \&binop, "&", 13, ASSIGN) } +sub pp_bit_or { maybe_targmy(@_, \&binop, "|", 12, ASSIGN) } +sub pp_bit_xor { maybe_targmy(@_, \&binop, "^", 12, ASSIGN) } + +sub pp_eq { binop(@_, "==", 14) } +sub pp_ne { binop(@_, "!=", 14) } +sub pp_lt { binop(@_, "<", 15) } +sub pp_gt { binop(@_, ">", 15) } +sub pp_ge { binop(@_, ">=", 15) } +sub pp_le { binop(@_, "<=", 15) } +sub pp_ncmp { binop(@_, "<=>", 14) } +sub pp_i_eq { binop(@_, "==", 14) } +sub pp_i_ne { binop(@_, "!=", 14) } +sub pp_i_lt { binop(@_, "<", 15) } +sub pp_i_gt { binop(@_, ">", 15) } +sub pp_i_ge { binop(@_, ">=", 15) } +sub pp_i_le { binop(@_, "<=", 15) } +sub pp_i_ncmp { binop(@_, "<=>", 14) } + +sub pp_seq { binop(@_, "eq", 14) } +sub pp_sne { binop(@_, "ne", 14) } +sub pp_slt { binop(@_, "lt", 15) } +sub pp_sgt { binop(@_, "gt", 15) } +sub pp_sge { binop(@_, "ge", 15) } +sub pp_sle { binop(@_, "le", 15) } +sub pp_scmp { binop(@_, "cmp", 14) } + +sub pp_sassign { binop(@_, "=", 7, SWAP_CHILDREN) } +sub pp_aassign { binop(@_, "=", 7, SWAP_CHILDREN | LIST_CONTEXT) } + +# `.' is special because concats-of-concats are optimized to save copying +# by making all but the first concat stacked. The effect is as if the +# programmer had written `($a . $b) .= $c', except legal. +sub pp_concat { maybe_targmy(@_, \&real_concat) } +sub real_concat { + my $self = shift; + my($op, $cx) = @_; + my $left = $op->first; + my $right = $op->last; + my $eq = ""; + my $prec = 18; + if ($op->flags & OPf_STACKED and $op->first->name ne "concat") { + $eq = "="; + $prec = 7; + } + $left = $self->deparse_binop_left($op, $left, $prec); + $right = $self->deparse_binop_right($op, $right, $prec); + return $self->maybe_parens("$left .$eq $right", $cx, $prec); +} + +# `x' is weird when the left arg is a list +sub pp_repeat { + my $self = shift; + my($op, $cx) = @_; + my $left = $op->first; + my $right = $op->last; + my $eq = ""; + my $prec = 19; + if ($op->flags & OPf_STACKED) { + $eq = "="; + $prec = 7; + } + if (null($right)) { # list repeat; count is inside left-side ex-list + my $kid = $left->first->sibling; # skip pushmark + my @exprs; + for (; !null($kid->sibling); $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 6); + } + $right = $kid; + $left = "(" . join(", ", @exprs). ")"; + } else { + $left = $self->deparse_binop_left($op, $left, $prec); + } + $right = $self->deparse_binop_right($op, $right, $prec); + return $self->maybe_parens("$left x$eq $right", $cx, $prec); +} + +sub range { + my $self = shift; + my ($op, $cx, $type) = @_; + my $left = $op->first; + my $right = $left->sibling; + $left = $self->deparse($left, 9); + $right = $self->deparse($right, 9); + return $self->maybe_parens("$left $type $right", $cx, 9); +} + +sub pp_flop { + my $self = shift; + my($op, $cx) = @_; + my $flip = $op->first; + my $type = ($flip->flags & OPf_SPECIAL) ? "..." : ".."; + return $self->range($flip->first, $cx, $type); +} + +# one-line while/until is handled in pp_leave + +sub logop { + my $self = shift; + my ($op, $cx, $lowop, $lowprec, $highop, $highprec, $blockname) = @_; + my $left = $op->first; + my $right = $op->first->sibling; + if ($cx == 0 and is_scope($right) and $blockname + and $self->{'expand'} < 7) + { # if ($a) {$b} + $left = $self->deparse($left, 1); + $right = $self->deparse($right, 0); + return "$blockname ($left) {\n\t$right\n\b}\cK"; + } elsif ($cx == 0 and $blockname and not $self->{'parens'} + and $self->{'expand'} < 7) { # $b if $a + $right = $self->deparse($right, 1); + $left = $self->deparse($left, 1); + return "$right $blockname $left"; + } elsif ($cx > $lowprec and $highop) { # $a && $b + $left = $self->deparse_binop_left($op, $left, $highprec); + $right = $self->deparse_binop_right($op, $right, $highprec); + return $self->maybe_parens("$left $highop $right", $cx, $highprec); + } else { # $a and $b + $left = $self->deparse_binop_left($op, $left, $lowprec); + $right = $self->deparse_binop_right($op, $right, $lowprec); + return $self->maybe_parens("$left $lowop $right", $cx, $lowprec); + } +} + +sub pp_and { logop(@_, "and", 3, "&&", 11, "if") } +sub pp_or { logop(@_, "or", 2, "||", 10, "unless") } + +# xor is syntactically a logop, but it's really a binop (contrary to +# old versions of opcode.pl). Syntax is what matters here. +sub pp_xor { logop(@_, "xor", 2, "", 0, "") } + +sub logassignop { + my $self = shift; + my ($op, $cx, $opname) = @_; + my $left = $op->first; + my $right = $op->first->sibling->first; # skip sassign + $left = $self->deparse($left, 7); + $right = $self->deparse($right, 7); + return $self->maybe_parens("$left $opname $right", $cx, 7); +} + +sub pp_andassign { logassignop(@_, "&&=") } +sub pp_orassign { logassignop(@_, "||=") } + +sub listop { + my $self = shift; + my($op, $cx, $name) = @_; + my(@exprs); + my $parens = ($cx >= 5) || $self->{'parens'}; + my $kid = $op->first->sibling; + return $name if null $kid; + my $first; + $name = "socketpair" if $name eq "sockpair"; + if (defined prototype("CORE::$name") + && prototype("CORE::$name") =~ /^;?\*/ + && $kid->name eq "rv2gv") { + $first = $self->deparse($kid->first, 6); + } + else { + $first = $self->deparse($kid, 6); + } + if ($name eq "chmod" && $first =~ /^\d+$/) { + $first = sprintf("%#o", $first); + } + $first = "+$first" if not $parens and substr($first, 0, 1) eq "("; + push @exprs, $first; + $kid = $kid->sibling; + for (; !null($kid); $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 6); + } + if ($parens) { + return "$name(" . join(", ", @exprs) . ")"; + } else { + return "$name " . join(", ", @exprs); + } +} + +sub pp_bless { listop(@_, "bless") } +sub pp_atan2 { maybe_targmy(@_, \&listop, "atan2") } +sub pp_substr { maybe_local(@_, listop(@_, "substr")) } +sub pp_vec { maybe_local(@_, listop(@_, "vec")) } +sub pp_index { maybe_targmy(@_, \&listop, "index") } +sub pp_rindex { maybe_targmy(@_, \&listop, "rindex") } +sub pp_sprintf { maybe_targmy(@_, \&listop, "sprintf") } +sub pp_formline { listop(@_, "formline") } # see also deparse_format +sub pp_crypt { maybe_targmy(@_, \&listop, "crypt") } +sub pp_unpack { listop(@_, "unpack") } +sub pp_pack { listop(@_, "pack") } +sub pp_join { maybe_targmy(@_, \&listop, "join") } +sub pp_splice { listop(@_, "splice") } +sub pp_push { maybe_targmy(@_, \&listop, "push") } +sub pp_unshift { maybe_targmy(@_, \&listop, "unshift") } +sub pp_reverse { listop(@_, "reverse") } +sub pp_warn { listop(@_, "warn") } +sub pp_die { listop(@_, "die") } +# Actually, return is exempt from the LLAFR (see examples in this very +# module!), but for consistency's sake, ignore that fact +sub pp_return { listop(@_, "return") } +sub pp_open { listop(@_, "open") } +sub pp_pipe_op { listop(@_, "pipe") } +sub pp_tie { listop(@_, "tie") } +sub pp_binmode { listop(@_, "binmode") } +sub pp_dbmopen { listop(@_, "dbmopen") } +sub pp_sselect { listop(@_, "select") } +sub pp_select { listop(@_, "select") } +sub pp_read { listop(@_, "read") } +sub pp_sysopen { listop(@_, "sysopen") } +sub pp_sysseek { listop(@_, "sysseek") } +sub pp_sysread { listop(@_, "sysread") } +sub pp_syswrite { listop(@_, "syswrite") } +sub pp_send { listop(@_, "send") } +sub pp_recv { listop(@_, "recv") } +sub pp_seek { listop(@_, "seek") } +sub pp_fcntl { listop(@_, "fcntl") } +sub pp_ioctl { listop(@_, "ioctl") } +sub pp_flock { maybe_targmy(@_, \&listop, "flock") } +sub pp_socket { listop(@_, "socket") } +sub pp_sockpair { listop(@_, "sockpair") } +sub pp_bind { listop(@_, "bind") } +sub pp_connect { listop(@_, "connect") } +sub pp_listen { listop(@_, "listen") } +sub pp_accept { listop(@_, "accept") } +sub pp_shutdown { listop(@_, "shutdown") } +sub pp_gsockopt { listop(@_, "getsockopt") } +sub pp_ssockopt { listop(@_, "setsockopt") } +sub pp_chown { maybe_targmy(@_, \&listop, "chown") } +sub pp_unlink { maybe_targmy(@_, \&listop, "unlink") } +sub pp_chmod { maybe_targmy(@_, \&listop, "chmod") } +sub pp_utime { maybe_targmy(@_, \&listop, "utime") } +sub pp_rename { maybe_targmy(@_, \&listop, "rename") } +sub pp_link { maybe_targmy(@_, \&listop, "link") } +sub pp_symlink { maybe_targmy(@_, \&listop, "symlink") } +sub pp_mkdir { maybe_targmy(@_, \&listop, "mkdir") } +sub pp_open_dir { listop(@_, "opendir") } +sub pp_seekdir { listop(@_, "seekdir") } +sub pp_waitpid { maybe_targmy(@_, \&listop, "waitpid") } +sub pp_system { maybe_targmy(@_, \&listop, "system") } +sub pp_exec { maybe_targmy(@_, \&listop, "exec") } +sub pp_kill { maybe_targmy(@_, \&listop, "kill") } +sub pp_setpgrp { maybe_targmy(@_, \&listop, "setpgrp") } +sub pp_getpriority { maybe_targmy(@_, \&listop, "getpriority") } +sub pp_setpriority { maybe_targmy(@_, \&listop, "setpriority") } +sub pp_shmget { listop(@_, "shmget") } +sub pp_shmctl { listop(@_, "shmctl") } +sub pp_shmread { listop(@_, "shmread") } +sub pp_shmwrite { listop(@_, "shmwrite") } +sub pp_msgget { listop(@_, "msgget") } +sub pp_msgctl { listop(@_, "msgctl") } +sub pp_msgsnd { listop(@_, "msgsnd") } +sub pp_msgrcv { listop(@_, "msgrcv") } +sub pp_semget { listop(@_, "semget") } +sub pp_semctl { listop(@_, "semctl") } +sub pp_semop { listop(@_, "semop") } +sub pp_ghbyaddr { listop(@_, "gethostbyaddr") } +sub pp_gnbyaddr { listop(@_, "getnetbyaddr") } +sub pp_gpbynumber { listop(@_, "getprotobynumber") } +sub pp_gsbyname { listop(@_, "getservbyname") } +sub pp_gsbyport { listop(@_, "getservbyport") } +sub pp_syscall { listop(@_, "syscall") } + +sub pp_glob { + my $self = shift; + my($op, $cx) = @_; + my $text = $self->dq($op->first->sibling); # skip pushmark + if ($text =~ /^\$?(\w|::|\`)+$/ # could look like a readline + or $text =~ /[<>]/) { + return 'glob(' . single_delim('qq', '"', $text) . ')'; + } else { + return '<' . $text . '>'; + } +} + +# Truncate is special because OPf_SPECIAL makes a bareword first arg +# be a filehandle. This could probably be better fixed in the core +# by moving the GV lookup into ck_truc. + +sub pp_truncate { + my $self = shift; + my($op, $cx) = @_; + my(@exprs); + my $parens = ($cx >= 5) || $self->{'parens'}; + my $kid = $op->first->sibling; + my $fh; + if ($op->flags & OPf_SPECIAL) { + # $kid is an OP_CONST + $fh = $self->const_sv($kid)->PV; + } else { + $fh = $self->deparse($kid, 6); + $fh = "+$fh" if not $parens and substr($fh, 0, 1) eq "("; + } + my $len = $self->deparse($kid->sibling, 6); + if ($parens) { + return "truncate($fh, $len)"; + } else { + return "truncate $fh, $len"; + } +} + +sub indirop { + my $self = shift; + my($op, $cx, $name) = @_; + my($expr, @exprs); + my $kid = $op->first->sibling; + my $indir = ""; + if ($op->flags & OPf_STACKED) { + $indir = $kid; + $indir = $indir->first; # skip rv2gv + if (is_scope($indir)) { + $indir = "{" . $self->deparse($indir, 0) . "}"; + } elsif ($indir->name eq "const" && $indir->private & OPpCONST_BARE) { + $indir = $self->const_sv($indir)->PV; + } else { + $indir = $self->deparse($indir, 24); + } + $indir = $indir . " "; + $kid = $kid->sibling; + } + if ($name eq "sort" && $op->private & (OPpSORT_NUMERIC | OPpSORT_INTEGER)) { + $indir = ($op->private & OPpSORT_REVERSE) ? '{$b <=> $a} ' + : '{$a <=> $b} '; + } + elsif ($name eq "sort" && $op->private & OPpSORT_REVERSE) { + $indir = '{$b cmp $a} '; + } + for (; !null($kid); $kid = $kid->sibling) { + $expr = $self->deparse($kid, 6); + push @exprs, $expr; + } + return $self->maybe_parens_func($name, $indir . join(", ", @exprs), + $cx, 5); +} + +sub pp_prtf { indirop(@_, "printf") } +sub pp_print { indirop(@_, "print") } +sub pp_sort { indirop(@_, "sort") } + +sub mapop { + my $self = shift; + my($op, $cx, $name) = @_; + my($expr, @exprs); + my $kid = $op->first; # this is the (map|grep)start + $kid = $kid->first->sibling; # skip a pushmark + my $code = $kid->first; # skip a null + if (is_scope $code) { + $code = "{" . $self->deparse($code, 0) . "} "; + } else { + $code = $self->deparse($code, 24) . ", "; + } + $kid = $kid->sibling; + for (; !null($kid); $kid = $kid->sibling) { + $expr = $self->deparse($kid, 6); + push @exprs, $expr if defined $expr; + } + return $self->maybe_parens_func($name, $code . join(", ", @exprs), $cx, 5); +} + +sub pp_mapwhile { mapop(@_, "map") } +sub pp_grepwhile { mapop(@_, "grep") } + +sub pp_list { + my $self = shift; + my($op, $cx) = @_; + my($expr, @exprs); + my $kid = $op->first->sibling; # skip pushmark + my $lop; + my $local = "either"; # could be local(...), my(...) or our(...) + for ($lop = $kid; !null($lop); $lop = $lop->sibling) { + # This assumes that no other private flags equal 128, and that + # OPs that store things other than flags in their op_private, + # like OP_AELEMFAST, won't be immediate children of a list. + # + # OP_ENTERSUB can break this logic, so check for it. + # I suspect that open and exit can too. + + if (!($lop->private & (OPpLVAL_INTRO|OPpOUR_INTRO) + or $lop->name eq "undef") + or $lop->name eq "entersub" + or $lop->name eq "exit" + or $lop->name eq "open") + { + $local = ""; # or not + last; + } + if ($lop->name =~ /^pad[ash]v$/) { # my() + ($local = "", last) if $local eq "local" || $local eq "our"; + $local = "my"; + } elsif ($lop->name =~ /^(gv|rv2)[ash]v$/ + && $lop->private & OPpOUR_INTRO + or $lop->name eq "null" && $lop->first->name eq "gvsv" + && $lop->first->private & OPpOUR_INTRO) { # our() + ($local = "", last) if $local eq "my" || $local eq "local"; + $local = "our"; + } elsif ($lop->name ne "undef") { # local() + ($local = "", last) if $local eq "my" || $local eq "our"; + $local = "local"; + } + } + $local = "" if $local eq "either"; # no point if it's all undefs + return $self->deparse($kid, $cx) if null $kid->sibling and not $local; + for (; !null($kid); $kid = $kid->sibling) { + if ($local) { + if (class($kid) eq "UNOP" and $kid->first->name eq "gvsv") { + $lop = $kid->first; + } else { + $lop = $kid; + } + $self->{'avoid_local'}{$$lop}++; + $expr = $self->deparse($kid, 6); + delete $self->{'avoid_local'}{$$lop}; + } else { + $expr = $self->deparse($kid, 6); + } + push @exprs, $expr; + } + if ($local) { + return "$local(" . join(", ", @exprs) . ")"; + } else { + return $self->maybe_parens( join(", ", @exprs), $cx, 6); + } +} + +sub is_ifelse_cont { + my $op = shift; + return ($op->name eq "null" and class($op) eq "UNOP" + and $op->first->name =~ /^(and|cond_expr)$/ + and is_scope($op->first->first->sibling)); +} + +sub pp_cond_expr { + my $self = shift; + my($op, $cx) = @_; + my $cond = $op->first; + my $true = $cond->sibling; + my $false = $true->sibling; + my $cuddle = $self->{'cuddle'}; + unless ($cx == 0 and (is_scope($true) and $true->name ne "null") and + (is_scope($false) || is_ifelse_cont($false)) + and $self->{'expand'} < 7) { + $cond = $self->deparse($cond, 8); + $true = $self->deparse($true, 8); + $false = $self->deparse($false, 8); + return $self->maybe_parens("$cond ? $true : $false", $cx, 8); + } + + $cond = $self->deparse($cond, 1); + $true = $self->deparse($true, 0); + my $head = "if ($cond) {\n\t$true\n\b}"; + my @elsifs; + while (!null($false) and is_ifelse_cont($false)) { + my $newop = $false->first; + my $newcond = $newop->first; + my $newtrue = $newcond->sibling; + $false = $newtrue->sibling; # last in chain is OP_AND => no else + $newcond = $self->deparse($newcond, 1); + $newtrue = $self->deparse($newtrue, 0); + push @elsifs, "elsif ($newcond) {\n\t$newtrue\n\b}"; + } + if (!null($false)) { + $false = $cuddle . "else {\n\t" . + $self->deparse($false, 0) . "\n\b}\cK"; + } else { + $false = "\cK"; + } + return $head . join($cuddle, "", @elsifs) . $false; +} + +sub loop_common { + my $self = shift; + my($op, $cx, $init) = @_; + my $enter = $op->first; + my $kid = $enter->sibling; + local(@$self{qw'curstash warnings hints'}) + = @$self{qw'curstash warnings hints'}; + my $head = ""; + my $bare = 0; + my $body; + my $cond = undef; + if ($kid->name eq "lineseq") { # bare or infinite loop + if (is_state $kid->last) { # infinite + $head = "while (1) "; # Can't use for(;;) if there's a continue + $cond = ""; + } else { + $bare = 1; + } + $body = $kid; + } elsif ($enter->name eq "enteriter") { # foreach + my $ary = $enter->first->sibling; # first was pushmark + my $var = $ary->sibling; + if ($enter->flags & OPf_STACKED + and not null $ary->first->sibling->sibling) + { + $ary = $self->deparse($ary->first->sibling, 9) . " .. " . + $self->deparse($ary->first->sibling->sibling, 9); + } else { + $ary = $self->deparse($ary, 1); + } + if (null $var) { + if ($enter->flags & OPf_SPECIAL) { # thread special var + $var = $self->pp_threadsv($enter, 1); + } else { # regular my() variable + $var = $self->pp_padsv($enter, 1); + if ($self->padname_sv($enter->targ)->IVX == + $kid->first->first->sibling->last->cop_seq) + { + # If the scope of this variable closes at the last + # statement of the loop, it must have been + # declared here. + $var = "my " . $var; + } + } + } elsif ($var->name eq "rv2gv") { + $var = $self->pp_rv2sv($var, 1); + } elsif ($var->name eq "gv") { + $var = "\$" . $self->deparse($var, 1); + } + $head = "foreach $var ($ary) "; + $body = $kid->first->first->sibling; # skip OP_AND and OP_ITER + } elsif ($kid->name eq "null") { # while/until + $kid = $kid->first; + my $name = {"and" => "while", "or" => "until"}->{$kid->name}; + $cond = $self->deparse($kid->first, 1); + $head = "$name ($cond) "; + $body = $kid->first->sibling; + } elsif ($kid->name eq "stub") { # bare and empty + return "{;}"; # {} could be a hashref + } + # If there isn't a continue block, then the next pointer for the loop + # will point to the unstack, which is kid's penultimate child, except + # in a bare loop, when it will point to the leaveloop. When neither of + # these conditions hold, then the third-to-last child in the continue + # block (or the last in a bare loop). + my $cont_start = $enter->nextop; + my $cont; + if ($$cont_start != $$op && ${$cont_start->sibling} != ${$body->last}) { + if ($bare) { + $cont = $body->last; + } else { + $cont = $body->first; + while (!null($cont->sibling->sibling->sibling)) { + $cont = $cont->sibling; + } + } + my $state = $body->first; + my $cuddle = $self->{'cuddle'}; + my @states; + for (; $$state != $$cont; $state = $state->sibling) { + push @states, $state; + } + $body = $self->lineseq(undef, @states); + if (defined $cond and not is_scope $cont and $self->{'expand'} < 3) { + $head = "for ($init; $cond; " . $self->deparse($cont, 1) .") "; + $cont = "\cK"; + } else { + $cont = $cuddle . "continue {\n\t" . + $self->deparse($cont, 0) . "\n\b}\cK"; + } + } else { + return "" if !defined $body; + if (length $init) { + $head = "for ($init; $cond;) "; + } + $cont = "\cK"; + $body = $self->deparse($body, 0); + } + $body =~ s/;?$/;\n/; + + return $head . "{\n\t" . $body . "\b}" . $cont; +} + +sub pp_leaveloop { loop_common(@_, "") } + +sub for_loop { + my $self = shift; + my($op, $cx) = @_; + my $init = $self->deparse($op, 1); + return $self->loop_common($op->sibling->first->sibling, $cx, $init); +} + +sub pp_leavetry { + my $self = shift; + return "eval {\n\t" . $self->pp_leave(@_) . "\n\b}"; +} + +BEGIN { eval "sub OP_CONST () {" . opnumber("const") . "}" } +BEGIN { eval "sub OP_STRINGIFY () {" . opnumber("stringify") . "}" } +BEGIN { eval "sub OP_RV2SV () {" . opnumber("rv2sv") . "}" } +BEGIN { eval "sub OP_LIST () {" . opnumber("list") . "}" } + +sub pp_null { + my $self = shift; + my($op, $cx) = @_; + if (class($op) eq "OP") { + # old value is lost + return $self->{'ex_const'} if $op->targ == OP_CONST; + } elsif ($op->first->name eq "pushmark") { + return $self->pp_list($op, $cx); + } elsif ($op->first->name eq "enter") { + return $self->pp_leave($op, $cx); + } elsif ($op->targ == OP_STRINGIFY) { + return $self->dquote($op, $cx); + } elsif (!null($op->first->sibling) and + $op->first->sibling->name eq "readline" and + $op->first->sibling->flags & OPf_STACKED) { + return $self->maybe_parens($self->deparse($op->first, 7) . " = " + . $self->deparse($op->first->sibling, 7), + $cx, 7); + } elsif (!null($op->first->sibling) and + $op->first->sibling->name eq "trans" and + $op->first->sibling->flags & OPf_STACKED) { + return $self->maybe_parens($self->deparse($op->first, 20) . " =~ " + . $self->deparse($op->first->sibling, 20), + $cx, 20); + } elsif ($op->flags & OPf_SPECIAL && $cx == 0 && !$op->targ) { + return "do {\n\t". $self->deparse($op->first, $cx) ."\n\b};"; + } elsif (!null($op->first->sibling) and + $op->first->sibling->name eq "null" and + class($op->first->sibling) eq "UNOP" and + $op->first->sibling->first->flags & OPf_STACKED and + $op->first->sibling->first->name eq "rcatline") { + return $self->maybe_parens($self->deparse($op->first, 18) . " .= " + . $self->deparse($op->first->sibling, 18), + $cx, 18); + } else { + return $self->deparse($op->first, $cx); + } +} + +sub padname { + my $self = shift; + my $targ = shift; + return $self->padname_sv($targ)->PVX; +} + +sub padany { + my $self = shift; + my $op = shift; + return substr($self->padname($op->targ), 1); # skip $/@/% +} + +sub pp_padsv { + my $self = shift; + my($op, $cx) = @_; + return $self->maybe_my($op, $cx, $self->padname($op->targ)); +} + +sub pp_padav { pp_padsv(@_) } +sub pp_padhv { pp_padsv(@_) } + +my @threadsv_names; + +BEGIN { + @threadsv_names = ("_", "1", "2", "3", "4", "5", "6", "7", "8", "9", + "&", "`", "'", "+", "/", ".", ",", "\\", '"', ";", + "^", "-", "%", "=", "|", "~", ":", "^A", "^E", + "!", "@"); +} + +sub pp_threadsv { + my $self = shift; + my($op, $cx) = @_; + return $self->maybe_local($op, $cx, "\$" . $threadsv_names[$op->targ]); +} + +sub gv_or_padgv { + my $self = shift; + my $op = shift; + if (class($op) eq "PADOP") { + return $self->padval($op->padix); + } else { # class($op) eq "SVOP" + return $op->gv; + } +} + +sub pp_gvsv { + my $self = shift; + my($op, $cx) = @_; + my $gv = $self->gv_or_padgv($op); + return $self->maybe_local($op, $cx, $self->stash_variable("\$", + $self->gv_name($gv))); +} + +sub pp_gv { + my $self = shift; + my($op, $cx) = @_; + my $gv = $self->gv_or_padgv($op); + return $self->gv_name($gv); +} + +sub pp_aelemfast { + my $self = shift; + my($op, $cx) = @_; + my $gv = $self->gv_or_padgv($op); + my $name = $self->gv_name($gv); + $name = $self->{'curstash'}."::$name" + if $name !~ /::/ && $self->lex_in_scope('@'.$name); + + return "\$" . $name . "[" . + ($op->private + $self->{'arybase'}) . "]"; +} + +sub rv2x { + my $self = shift; + my($op, $cx, $type) = @_; + + if (class($op) eq 'NULL' || !$op->can("first")) { + carp("Unexpected op in pp_rv2x"); + return 'XXX'; + } + my $kid = $op->first; + my $str = $self->deparse($kid, 0); + return $self->stash_variable($type, $str) if is_scalar($kid); + return $type ."{$str}"; +} + +sub pp_rv2sv { maybe_local(@_, rv2x(@_, "\$")) } +sub pp_rv2hv { maybe_local(@_, rv2x(@_, "%")) } +sub pp_rv2gv { maybe_local(@_, rv2x(@_, "*")) } + +# skip rv2av +sub pp_av2arylen { + my $self = shift; + my($op, $cx) = @_; + if ($op->first->name eq "padav") { + return $self->maybe_local($op, $cx, '$#' . $self->padany($op->first)); + } else { + return $self->maybe_local($op, $cx, + $self->rv2x($op->first, $cx, '$#')); + } +} + +# skip down to the old, ex-rv2cv +sub pp_rv2cv { + my ($self, $op, $cx) = @_; + if (!null($op->first) && $op->first->name eq 'null' && + $op->first->targ eq OP_LIST) + { + return $self->rv2x($op->first->first->sibling, $cx, "&") + } + else { + return $self->rv2x($op, $cx, "") + } +} + +sub pp_rv2av { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first; + if ($kid->name eq "const") { # constant list + my $av = $self->const_sv($kid); + return "(" . join(", ", map(const($_), $av->ARRAY)) . ")"; + } else { + return $self->maybe_local($op, $cx, $self->rv2x($op, $cx, "\@")); + } + } + +sub is_subscriptable { + my $op = shift; + if ($op->name =~ /^[ahg]elem/) { + return 1; + } elsif ($op->name eq "entersub") { + my $kid = $op->first; + return 0 unless null $kid->sibling; + $kid = $kid->first; + $kid = $kid->sibling until null $kid->sibling; + return 0 if is_scope($kid); + $kid = $kid->first; + return 0 if $kid->name eq "gv"; + return 0 if is_scalar($kid); + return is_subscriptable($kid); + } else { + return 0; + } +} + +sub elem { + my $self = shift; + my ($op, $cx, $left, $right, $padname) = @_; + my($array, $idx) = ($op->first, $op->first->sibling); + unless ($array->name eq $padname) { # Maybe this has been fixed + $array = $array->first; # skip rv2av (or ex-rv2av in _53+) + } + if ($array->name eq $padname) { + $array = $self->padany($array); + } elsif (is_scope($array)) { # ${expr}[0] + $array = "{" . $self->deparse($array, 0) . "}"; + } elsif ($array->name eq "gv") { + $array = $self->gv_name($self->gv_or_padgv($array)); + if ($array !~ /::/) { + my $prefix = ($left eq '[' ? '@' : '%'); + $array = $self->{curstash}.'::'.$array + if $self->lex_in_scope($prefix . $array); + } + } elsif (is_scalar $array) { # $x[0], $$x[0], ... + $array = $self->deparse($array, 24); + } else { + # $x[20][3]{hi} or expr->[20] + my $arrow = is_subscriptable($array) ? "" : "->"; + return $self->deparse($array, 24) . $arrow . + $left . $self->deparse($idx, 1) . $right; + } + $idx = $self->deparse($idx, 1); + + # Outer parens in an array index will confuse perl + # if we're interpolating in a regular expression, i.e. + # /$x$foo[(-1)]/ is *not* the same as /$x$foo[-1]/ + # + # If $self->{parens}, then an initial '(' will + # definitely be paired with a final ')'. If + # !$self->{parens}, the misleading parens won't + # have been added in the first place. + # + # [You might think that we could get "(...)...(...)" + # where the initial and final parens do not match + # each other. But we can't, because the above would + # only happen if there's an infix binop between the + # two pairs of parens, and *that* means that the whole + # expression would be parenthesized as well.] + # + $idx =~ s/^\((.*)\)$/$1/ if $self->{'parens'}; + + # Hash-element braces will autoquote a bareword inside themselves. + # We need to make sure that C<$hash{warn()}> doesn't come out as + # C<$hash{warn}>, which has a quite different meaning. Currently + # B::Deparse will always quote strings, even if the string was a + # bareword in the original (i.e. the OPpCONST_BARE flag is ignored + # for constant strings.) So we can cheat slightly here - if we see + # a bareword, we know that it is supposed to be a function call. + # + $idx =~ s/^([A-Za-z_]\w*)$/$1()/; + + return "\$" . $array . $left . $idx . $right; +} + +sub pp_aelem { maybe_local(@_, elem(@_, "[", "]", "padav")) } +sub pp_helem { maybe_local(@_, elem(@_, "{", "}", "padhv")) } + +sub pp_gelem { + my $self = shift; + my($op, $cx) = @_; + my($glob, $part) = ($op->first, $op->last); + $glob = $glob->first; # skip rv2gv + $glob = $glob->first if $glob->name eq "rv2gv"; # this one's a bug + my $scope = is_scope($glob); + $glob = $self->deparse($glob, 0); + $part = $self->deparse($part, 1); + return "*" . ($scope ? "{$glob}" : $glob) . "{$part}"; +} + +sub slice { + my $self = shift; + my ($op, $cx, $left, $right, $regname, $padname) = @_; + my $last; + my(@elems, $kid, $array, $list); + if (class($op) eq "LISTOP") { + $last = $op->last; + } else { # ex-hslice inside delete() + for ($kid = $op->first; !null $kid->sibling; $kid = $kid->sibling) {} + $last = $kid; + } + $array = $last; + $array = $array->first + if $array->name eq $regname or $array->name eq "null"; + if (is_scope($array)) { + $array = "{" . $self->deparse($array, 0) . "}"; + } elsif ($array->name eq $padname) { + $array = $self->padany($array); + } else { + $array = $self->deparse($array, 24); + } + $kid = $op->first->sibling; # skip pushmark + if ($kid->name eq "list") { + $kid = $kid->first->sibling; # skip list, pushmark + for (; !null $kid; $kid = $kid->sibling) { + push @elems, $self->deparse($kid, 6); + } + $list = join(", ", @elems); + } else { + $list = $self->deparse($kid, 1); + } + return "\@" . $array . $left . $list . $right; +} + +sub pp_aslice { maybe_local(@_, slice(@_, "[", "]", "rv2av", "padav")) } +sub pp_hslice { maybe_local(@_, slice(@_, "{", "}", "rv2hv", "padhv")) } + +sub pp_lslice { + my $self = shift; + my($op, $cx) = @_; + my $idx = $op->first; + my $list = $op->last; + my(@elems, $kid); + $list = $self->deparse($list, 1); + $idx = $self->deparse($idx, 1); + return "($list)" . "[$idx]"; +} + +sub want_scalar { + my $op = shift; + return ($op->flags & OPf_WANT) == OPf_WANT_SCALAR; +} + +sub want_list { + my $op = shift; + return ($op->flags & OPf_WANT) == OPf_WANT_LIST; +} + +sub method { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first->sibling; # skip pushmark + my($meth, $obj, @exprs); + if ($kid->name eq "list" and want_list $kid) { + # When an indirect object isn't a bareword but the args are in + # parens, the parens aren't part of the method syntax (the LLAFR + # doesn't apply), but they make a list with OPf_PARENS set that + # doesn't get flattened by the append_elem that adds the method, + # making a (object, arg1, arg2, ...) list where the object + # usually is. This can be distinguished from + # `($obj, $arg1, $arg2)->meth()' (which is legal if $arg2 is an + # object) because in the later the list is in scalar context + # as the left side of -> always is, while in the former + # the list is in list context as method arguments always are. + # (Good thing there aren't method prototypes!) + $meth = $kid->sibling; + $kid = $kid->first->sibling; # skip pushmark + $obj = $kid; + $kid = $kid->sibling; + for (; not null $kid; $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 6); + } + } else { + $obj = $kid; + $kid = $kid->sibling; + for (; !null ($kid->sibling) && $kid->name ne "method_named"; + $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 6); + } + $meth = $kid; + } + $obj = $self->deparse($obj, 24); + if ($meth->name eq "method_named") { + $meth = $self->const_sv($meth)->PV; + } else { + $meth = $meth->first; + if ($meth->name eq "const") { + # As of 5.005_58, this case is probably obsoleted by the + # method_named case above + $meth = $self->const_sv($meth)->PV; # needs to be bare + } else { + $meth = $self->deparse($meth, 1); + } + } + my $args = join(", ", @exprs); + $kid = $obj . "->" . $meth; + if (length $args) { + return $kid . "(" . $args . ")"; # parens mandatory + } else { + return $kid; + } +} + +# returns "&" if the prototype doesn't match the args, +# or ("", $args_after_prototype_demunging) if it does. +sub check_proto { + my $self = shift; + return "&" if $self->{'noproto'}; + my($proto, @args) = @_; + my($arg, $real); + my $doneok = 0; + my @reals; + # An unbackslashed @ or % gobbles up the rest of the args + 1 while $proto =~ s/(?<!\\)([@%])[^\]]+$/$1/; + while ($proto) { + $proto =~ s/^(\\?[\$\@&%*]|\\\[[\$\@&%*]+\]|;)//; + my $chr = $1; + if ($chr eq "") { + return "&" if @args; + } elsif ($chr eq ";") { + $doneok = 1; + } elsif ($chr eq "@" or $chr eq "%") { + push @reals, map($self->deparse($_, 6), @args); + @args = (); + } else { + $arg = shift @args; + last unless $arg; + if ($chr eq "\$") { + if (want_scalar $arg) { + push @reals, $self->deparse($arg, 6); + } else { + return "&"; + } + } elsif ($chr eq "&") { + if ($arg->name =~ /^(s?refgen|undef)$/) { + push @reals, $self->deparse($arg, 6); + } else { + return "&"; + } + } elsif ($chr eq "*") { + if ($arg->name =~ /^s?refgen$/ + and $arg->first->first->name eq "rv2gv") + { + $real = $arg->first->first; # skip refgen, null + if ($real->first->name eq "gv") { + push @reals, $self->deparse($real, 6); + } else { + push @reals, $self->deparse($real->first, 6); + } + } else { + return "&"; + } + } elsif (substr($chr, 0, 1) eq "\\") { + $chr =~ tr/\\[]//d; + if ($arg->name =~ /^s?refgen$/ and + !null($real = $arg->first) and + ($chr =~ /\$/ && is_scalar($real->first) + or ($chr =~ /@/ + && class($real->first->sibling) ne 'NULL' + && $real->first->sibling->name + =~ /^(rv2|pad)av$/) + or ($chr =~ /%/ + && class($real->first->sibling) ne 'NULL' + && $real->first->sibling->name + =~ /^(rv2|pad)hv$/) + #or ($chr =~ /&/ # This doesn't work + # && $real->first->name eq "rv2cv") + or ($chr =~ /\*/ + && $real->first->name eq "rv2gv"))) + { + push @reals, $self->deparse($real, 6); + } else { + return "&"; + } + } + } + } + return "&" if $proto and !$doneok; # too few args and no `;' + return "&" if @args; # too many args + return ("", join ", ", @reals); +} + +sub pp_entersub { + my $self = shift; + my($op, $cx) = @_; + return $self->method($op, $cx) unless null $op->first->sibling; + my $prefix = ""; + my $amper = ""; + my($kid, @exprs); + if ($op->flags & OPf_SPECIAL && !($op->flags & OPf_MOD)) { + $prefix = "do "; + } elsif ($op->private & OPpENTERSUB_AMPER) { + $amper = "&"; + } + $kid = $op->first; + $kid = $kid->first->sibling; # skip ex-list, pushmark + for (; not null $kid->sibling; $kid = $kid->sibling) { + push @exprs, $kid; + } + my $simple = 0; + my $proto = undef; + if (is_scope($kid)) { + $amper = "&"; + $kid = "{" . $self->deparse($kid, 0) . "}"; + } elsif ($kid->first->name eq "gv") { + my $gv = $self->gv_or_padgv($kid->first); + if (class($gv->CV) ne "SPECIAL") { + $proto = $gv->CV->PV if $gv->CV->FLAGS & SVf_POK; + } + $simple = 1; # only calls of named functions can be prototyped + $kid = $self->deparse($kid, 24); + } elsif (is_scalar ($kid->first) && $kid->first->name ne 'rv2cv') { + $amper = "&"; + $kid = $self->deparse($kid, 24); + } else { + $prefix = ""; + my $arrow = is_subscriptable($kid->first) ? "" : "->"; + $kid = $self->deparse($kid, 24) . $arrow; + } + + # Doesn't matter how many prototypes there are, if + # they haven't happened yet! + my $declared; + { + no strict 'refs'; + no warnings 'uninitialized'; + $declared = exists $self->{'subs_declared'}{$kid} + || ( + defined &{ %{$self->{'curstash'}."::"}->{$kid} } + && !exists + $self->{'subs_deparsed'}{$self->{'curstash'}."::".$kid} + && defined prototype $self->{'curstash'}."::".$kid + ); + if (!$declared && defined($proto)) { + # Avoid "too early to check prototype" warning + ($amper, $proto) = ('&'); + } + } + + my $args; + if ($declared and defined $proto and not $amper) { + ($amper, $args) = $self->check_proto($proto, @exprs); + if ($amper eq "&") { + $args = join(", ", map($self->deparse($_, 6), @exprs)); + } + } else { + $args = join(", ", map($self->deparse($_, 6), @exprs)); + } + if ($prefix or $amper) { + if ($op->flags & OPf_STACKED) { + return $prefix . $amper . $kid . "(" . $args . ")"; + } else { + return $prefix . $amper. $kid; + } + } else { + # glob() invocations can be translated into calls of + # CORE::GLOBAL::glob with a second parameter, a number. + # Reverse this. + if ($kid eq "CORE::GLOBAL::glob") { + $kid = "glob"; + $args =~ s/\s*,[^,]+$//; + } + + # It's a syntax error to call CORE::GLOBAL::foo without a prefix, + # so it must have been translated from a keyword call. Translate + # it back. + $kid =~ s/^CORE::GLOBAL:://; + + if (!$declared) { + return "$kid(" . $args . ")"; + } elsif (defined $proto and $proto eq "") { + return $kid; + } elsif (defined $proto and $proto eq "\$" and is_scalar($exprs[0])) { + return $self->maybe_parens_func($kid, $args, $cx, 16); + } elsif (defined($proto) && $proto or $simple) { + return $self->maybe_parens_func($kid, $args, $cx, 5); + } else { + return "$kid(" . $args . ")"; + } + } +} + +sub pp_enterwrite { unop(@_, "write") } + +# escape things that cause interpolation in double quotes, +# but not character escapes +sub uninterp { + my($str) = @_; + $str =~ s/(^|\G|[^\\])((?:\\\\)*)([\$\@]|\\[uUlLQE])/$1$2\\$3/g; + return $str; +} + +{ +my $bal; +BEGIN { + use re "eval"; + # Matches any string which is balanced with respect to {braces} + $bal = qr( + (?: + [^\\{}] + | \\\\ + | \\[{}] + | \{(??{$bal})\} + )* + )x; +} + +# the same, but treat $|, $), $( and $ at the end of the string differently +sub re_uninterp { + my($str) = @_; + + $str =~ s/ + ( ^|\G # $1 + | [^\\] + ) + + ( # $2 + (?:\\\\)* + ) + + ( # $3 + (\(\?\??\{$bal\}\)) # $4 + | [\$\@] + (?!\||\)|\(|$) + | \\[uUlLQE] + ) + + /length($4) ? "$1$2$4" : "$1$2\\$3"/xeg; + + return $str; +} + +# This is for regular expressions with the /x modifier +# We have to leave comments unmangled. +sub re_uninterp_extended { + my($str) = @_; + + $str =~ s/ + ( ^|\G # $1 + | [^\\] + ) + + ( # $2 + (?:\\\\)* + ) + + ( # $3 + ( \(\?\??\{$bal\}\) # $4 (skip over (?{}) and (??{}) blocks) + | \#[^\n]* # (skip over comments) + ) + | [\$\@] + (?!\||\)|\(|$|\s) + | \\[uUlLQE] + ) + + /length($4) ? "$1$2$4" : "$1$2\\$3"/xeg; + + return $str; +} +} + +my %unctrl = # portable to to EBCDIC + ( + "\c@" => '\c@', # unused + "\cA" => '\cA', + "\cB" => '\cB', + "\cC" => '\cC', + "\cD" => '\cD', + "\cE" => '\cE', + "\cF" => '\cF', + "\cG" => '\cG', + "\cH" => '\cH', + "\cI" => '\cI', + "\cJ" => '\cJ', + "\cK" => '\cK', + "\cL" => '\cL', + "\cM" => '\cM', + "\cN" => '\cN', + "\cO" => '\cO', + "\cP" => '\cP', + "\cQ" => '\cQ', + "\cR" => '\cR', + "\cS" => '\cS', + "\cT" => '\cT', + "\cU" => '\cU', + "\cV" => '\cV', + "\cW" => '\cW', + "\cX" => '\cX', + "\cY" => '\cY', + "\cZ" => '\cZ', + "\c[" => '\c[', # unused + "\c\\" => '\c\\', # unused + "\c]" => '\c]', # unused + "\c_" => '\c_', # unused + ); + +# character escapes, but not delimiters that might need to be escaped +sub escape_str { # ASCII, UTF8 + my($str) = @_; + $str =~ s/(.)/ord($1) > 255 ? sprintf("\\x{%x}", ord($1)) : $1/eg; + $str =~ s/\a/\\a/g; +# $str =~ s/\cH/\\b/g; # \b means something different in a regex + $str =~ s/\t/\\t/g; + $str =~ s/\n/\\n/g; + $str =~ s/\e/\\e/g; + $str =~ s/\f/\\f/g; + $str =~ s/\r/\\r/g; + $str =~ s/([\cA-\cZ])/$unctrl{$1}/ge; + $str =~ s/([[:^print:]])/sprintf("\\%03o", ord($1))/ge; + return $str; +} + +# For regexes with the /x modifier. +# Leave whitespace unmangled. +sub escape_extended_re { + my($str) = @_; + $str =~ s/(.)/ord($1) > 255 ? sprintf("\\x{%x}", ord($1)) : $1/eg; + $str =~ s/([[:^print:]])/ + ($1 =~ y! \t\n!!) ? $1 : sprintf("\\%03o", ord($1))/ge; + $str =~ s/\n/\n\f/g; + return $str; +} + +# Don't do this for regexen +sub unback { + my($str) = @_; + $str =~ s/\\/\\\\/g; + return $str; +} + +# Remove backslashes which precede literal control characters, +# to avoid creating ambiguity when we escape the latter. +sub re_unback { + my($str) = @_; + + # the insane complexity here is due to the behaviour of "\c\" + $str =~ s/(^|[^\\]|\\c\\)(?<!\\c)\\(\\\\)*(?=[[:^print:]])/$1$2/g; + return $str; +} + +sub balanced_delim { + my($str) = @_; + my @str = split //, $str; + my($ar, $open, $close, $fail, $c, $cnt); + for $ar (['[',']'], ['(',')'], ['<','>'], ['{','}']) { + ($open, $close) = @$ar; + $fail = 0; $cnt = 0; + for $c (@str) { + if ($c eq $open) { + $cnt++; + } elsif ($c eq $close) { + $cnt--; + if ($cnt < 0) { + # qq()() isn't ")(" + $fail = 1; + last; + } + } + } + $fail = 1 if $cnt != 0; + return ($open, "$open$str$close") if not $fail; + } + return ("", $str); +} + +sub single_delim { + my($q, $default, $str) = @_; + return "$default$str$default" if $default and index($str, $default) == -1; + if ($q ne 'qr') { + (my $succeed, $str) = balanced_delim($str); + return "$q$str" if $succeed; + } + for my $delim ('/', '"', '#') { + return "$q$delim" . $str . $delim if index($str, $delim) == -1; + } + if ($default) { + $str =~ s/$default/\\$default/g; + return "$default$str$default"; + } else { + $str =~ s[/][\\/]g; + return "$q/$str/"; + } +} + +sub const { + my $sv = shift; + if (class($sv) eq "SPECIAL") { + return ('undef', '1', '0')[$$sv-1]; # sv_undef, sv_yes, sv_no + } elsif (class($sv) eq "NULL") { + return 'undef'; + } elsif ($sv->FLAGS & SVf_IOK) { + return $sv->int_value; + } elsif ($sv->FLAGS & SVf_NOK) { + # try the default stringification + my $r = "".$sv->NV; + if ($r =~ /e/) { + # If it's in scientific notation, we might have lost information + return sprintf("%.20e", $sv->NV); + } + return $r; + } elsif ($sv->FLAGS & SVf_ROK && $sv->can("RV")) { + return "\\(" . const($sv->RV) . ")"; # constant folded + } elsif ($sv->FLAGS & SVf_POK) { + my $str = $sv->PV; + if ($str =~ /[^ -~]/) { # ASCII for non-printing + return single_delim("qq", '"', uninterp escape_str unback $str); + } else { + return single_delim("q", "'", unback $str); + } + } else { + return "undef"; + } +} + +sub const_sv { + my $self = shift; + my $op = shift; + my $sv = $op->sv; + # the constant could be in the pad (under useithreads) + $sv = $self->padval($op->targ) unless $$sv; + return $sv; +} + +sub pp_const { + my $self = shift; + my($op, $cx) = @_; + if ($op->private & OPpCONST_ARYBASE) { + return '$['; + } +# if ($op->private & OPpCONST_BARE) { # trouble with `=>' autoquoting +# return $self->const_sv($op)->PV; +# } + my $sv = $self->const_sv($op); +# return const($sv); + my $c = const $sv; + return $c =~ /^-\d/ ? $self->maybe_parens($c, $cx, 21) : $c; +} + +sub dq { + my $self = shift; + my $op = shift; + my $type = $op->name; + if ($type eq "const") { + return '$[' if $op->private & OPpCONST_ARYBASE; + return uninterp(escape_str(unback($self->const_sv($op)->as_string))); + } elsif ($type eq "concat") { + my $first = $self->dq($op->first); + my $last = $self->dq($op->last); + + # Disambiguate "${foo}bar", "${foo}{bar}", "${foo}[1]" + ($last =~ /^[A-Z\\\^\[\]_?]/ && + $first =~ s/([\$@])\^$/${1}{^}/) # "${^}W" etc + || ($last =~ /^[{\[\w_]/ && + $first =~ s/([\$@])([A-Za-z_]\w*)$/${1}{$2}/); + + return $first . $last; + } elsif ($type eq "uc") { + return '\U' . $self->dq($op->first->sibling) . '\E'; + } elsif ($type eq "lc") { + return '\L' . $self->dq($op->first->sibling) . '\E'; + } elsif ($type eq "ucfirst") { + return '\u' . $self->dq($op->first->sibling); + } elsif ($type eq "lcfirst") { + return '\l' . $self->dq($op->first->sibling); + } elsif ($type eq "quotemeta") { + return '\Q' . $self->dq($op->first->sibling) . '\E'; + } elsif ($type eq "join") { + return $self->deparse($op->last, 26); # was join($", @ary) + } else { + return $self->deparse($op, 26); + } +} + +sub pp_backtick { + my $self = shift; + my($op, $cx) = @_; + # skip pushmark + return single_delim("qx", '`', $self->dq($op->first->sibling)); +} + +sub dquote { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first->sibling; # skip ex-stringify, pushmark + return $self->deparse($kid, $cx) if $self->{'unquote'}; + $self->maybe_targmy($kid, $cx, + sub {single_delim("qq", '"', $self->dq($_[1]))}); +} + +# OP_STRINGIFY is a listop, but it only ever has one arg +sub pp_stringify { maybe_targmy(@_, \&dquote) } + +# tr/// and s/// (and tr[][], tr[]//, tr###, etc) +# note that tr(from)/to/ is OK, but not tr/from/(to) +sub double_delim { + my($from, $to) = @_; + my($succeed, $delim); + if ($from !~ m[/] and $to !~ m[/]) { + return "/$from/$to/"; + } elsif (($succeed, $from) = balanced_delim($from) and $succeed) { + if (($succeed, $to) = balanced_delim($to) and $succeed) { + return "$from$to"; + } else { + for $delim ('/', '"', '#') { # note no `'' -- s''' is special + return "$from$delim$to$delim" if index($to, $delim) == -1; + } + $to =~ s[/][\\/]g; + return "$from/$to/"; + } + } else { + for $delim ('/', '"', '#') { # note no ' + return "$delim$from$delim$to$delim" + if index($to . $from, $delim) == -1; + } + $from =~ s[/][\\/]g; + $to =~ s[/][\\/]g; + return "/$from/$to/"; + } +} + +# Only used by tr///, so backslashes hyphens +sub pchr { # ASCII + my($n) = @_; + if ($n == ord '\\') { + return '\\\\'; + } elsif ($n == ord "-") { + return "\\-"; + } elsif ($n >= ord(' ') and $n <= ord('~')) { + return chr($n); + } elsif ($n == ord "\a") { + return '\\a'; + } elsif ($n == ord "\b") { + return '\\b'; + } elsif ($n == ord "\t") { + return '\\t'; + } elsif ($n == ord "\n") { + return '\\n'; + } elsif ($n == ord "\e") { + return '\\e'; + } elsif ($n == ord "\f") { + return '\\f'; + } elsif ($n == ord "\r") { + return '\\r'; + } elsif ($n >= ord("\cA") and $n <= ord("\cZ")) { + return '\\c' . chr(ord("@") + $n); + } else { +# return '\x' . sprintf("%02x", $n); + return '\\' . sprintf("%03o", $n); + } +} + +sub collapse { + my(@chars) = @_; + my($str, $c, $tr) = (""); + for ($c = 0; $c < @chars; $c++) { + $tr = $chars[$c]; + $str .= pchr($tr); + if ($c <= $#chars - 2 and $chars[$c + 1] == $tr + 1 and + $chars[$c + 2] == $tr + 2) + { + for (; $c <= $#chars-1 and $chars[$c + 1] == $chars[$c] + 1; $c++) + {} + $str .= "-"; + $str .= pchr($chars[$c]); + } + } + return $str; +} + +sub tr_decode_byte { + my($table, $flags) = @_; + my(@table) = unpack("s*", $table); + splice @table, 0x100, 1; # Number of subsequent elements + my($c, $tr, @from, @to, @delfrom, $delhyphen); + if ($table[ord "-"] != -1 and + $table[ord("-") - 1] == -1 || $table[ord("-") + 1] == -1) + { + $tr = $table[ord "-"]; + $table[ord "-"] = -1; + if ($tr >= 0) { + @from = ord("-"); + @to = $tr; + } else { # -2 ==> delete + $delhyphen = 1; + } + } + for ($c = 0; $c < @table; $c++) { + $tr = $table[$c]; + if ($tr >= 0) { + push @from, $c; push @to, $tr; + } elsif ($tr == -2) { + push @delfrom, $c; + } + } + @from = (@from, @delfrom); + if ($flags & OPpTRANS_COMPLEMENT) { + my @newfrom = (); + my %from; + @from{@from} = (1) x @from; + for ($c = 0; $c < 256; $c++) { + push @newfrom, $c unless $from{$c}; + } + @from = @newfrom; + } + unless ($flags & OPpTRANS_DELETE || !@to) { + pop @to while $#to and $to[$#to] == $to[$#to -1]; + } + my($from, $to); + $from = collapse(@from); + $to = collapse(@to); + $from .= "-" if $delhyphen; + return ($from, $to); +} + +sub tr_chr { + my $x = shift; + if ($x == ord "-") { + return "\\-"; + } elsif ($x == ord "\\") { + return "\\\\"; + } else { + return chr $x; + } +} + +# XXX This doesn't yet handle all cases correctly either + +sub tr_decode_utf8 { + my($swash_hv, $flags) = @_; + my %swash = $swash_hv->ARRAY; + my $final = undef; + $final = $swash{'FINAL'}->IV if exists $swash{'FINAL'}; + my $none = $swash{"NONE"}->IV; + my $extra = $none + 1; + my(@from, @delfrom, @to); + my $line; + foreach $line (split /\n/, $swash{'LIST'}->PV) { + my($min, $max, $result) = split(/\t/, $line); + $min = hex $min; + if (length $max) { + $max = hex $max; + } else { + $max = $min; + } + $result = hex $result; + if ($result == $extra) { + push @delfrom, [$min, $max]; + } else { + push @from, [$min, $max]; + push @to, [$result, $result + $max - $min]; + } + } + for my $i (0 .. $#from) { + if ($from[$i][0] == ord '-') { + unshift @from, splice(@from, $i, 1); + unshift @to, splice(@to, $i, 1); + last; + } elsif ($from[$i][1] == ord '-') { + $from[$i][1]--; + $to[$i][1]--; + unshift @from, ord '-'; + unshift @to, ord '-'; + last; + } + } + for my $i (0 .. $#delfrom) { + if ($delfrom[$i][0] == ord '-') { + push @delfrom, splice(@delfrom, $i, 1); + last; + } elsif ($delfrom[$i][1] == ord '-') { + $delfrom[$i][1]--; + push @delfrom, ord '-'; + last; + } + } + if (defined $final and $to[$#to][1] != $final) { + push @to, [$final, $final]; + } + push @from, @delfrom; + if ($flags & OPpTRANS_COMPLEMENT) { + my @newfrom; + my $next = 0; + for my $i (0 .. $#from) { + push @newfrom, [$next, $from[$i][0] - 1]; + $next = $from[$i][1] + 1; + } + @from = (); + for my $range (@newfrom) { + if ($range->[0] <= $range->[1]) { + push @from, $range; + } + } + } + my($from, $to, $diff); + for my $chunk (@from) { + $diff = $chunk->[1] - $chunk->[0]; + if ($diff > 1) { + $from .= tr_chr($chunk->[0]) . "-" . tr_chr($chunk->[1]); + } elsif ($diff == 1) { + $from .= tr_chr($chunk->[0]) . tr_chr($chunk->[1]); + } else { + $from .= tr_chr($chunk->[0]); + } + } + for my $chunk (@to) { + $diff = $chunk->[1] - $chunk->[0]; + if ($diff > 1) { + $to .= tr_chr($chunk->[0]) . "-" . tr_chr($chunk->[1]); + } elsif ($diff == 1) { + $to .= tr_chr($chunk->[0]) . tr_chr($chunk->[1]); + } else { + $to .= tr_chr($chunk->[0]); + } + } + #$final = sprintf("%04x", $final) if defined $final; + #$none = sprintf("%04x", $none) if defined $none; + #$extra = sprintf("%04x", $extra) if defined $extra; + #print STDERR "final: $final\n none: $none\nextra: $extra\n"; + #print STDERR $swash{'LIST'}->PV; + return (escape_str($from), escape_str($to)); +} + +sub pp_trans { + my $self = shift; + my($op, $cx) = @_; + my($from, $to); + if (class($op) eq "PVOP") { + ($from, $to) = tr_decode_byte($op->pv, $op->private); + } else { # class($op) eq "SVOP" + ($from, $to) = tr_decode_utf8($op->sv->RV, $op->private); + } + my $flags = ""; + $flags .= "c" if $op->private & OPpTRANS_COMPLEMENT; + $flags .= "d" if $op->private & OPpTRANS_DELETE; + $to = "" if $from eq $to and $flags eq ""; + $flags .= "s" if $op->private & OPpTRANS_SQUASH; + return "tr" . double_delim($from, $to) . $flags; +} + +# Like dq(), but different +sub re_dq { + my $self = shift; + my ($op, $extended) = @_; + + my $type = $op->name; + if ($type eq "const") { + return '$[' if $op->private & OPpCONST_ARYBASE; + my $unbacked = re_unback($self->const_sv($op)->as_string); + return re_uninterp_extended(escape_extended_re($unbacked)) + if $extended; + return re_uninterp(escape_str($unbacked)); + } elsif ($type eq "concat") { + my $first = $self->re_dq($op->first, $extended); + my $last = $self->re_dq($op->last, $extended); + + # Disambiguate "${foo}bar", "${foo}{bar}", "${foo}[1]" + ($last =~ /^[A-Z\\\^\[\]_?]/ && + $first =~ s/([\$@])\^$/${1}{^}/) # "${^}W" etc + || ($last =~ /^[{\[\w_]/ && + $first =~ s/([\$@])([A-Za-z_]\w*)$/${1}{$2}/); + + return $first . $last; + } elsif ($type eq "uc") { + return '\U' . $self->re_dq($op->first->sibling, $extended) . '\E'; + } elsif ($type eq "lc") { + return '\L' . $self->re_dq($op->first->sibling, $extended) . '\E'; + } elsif ($type eq "ucfirst") { + return '\u' . $self->re_dq($op->first->sibling, $extended); + } elsif ($type eq "lcfirst") { + return '\l' . $self->re_dq($op->first->sibling, $extended); + } elsif ($type eq "quotemeta") { + return '\Q' . $self->re_dq($op->first->sibling, $extended) . '\E'; + } elsif ($type eq "join") { + return $self->deparse($op->last, 26); # was join($", @ary) + } else { + return $self->deparse($op, 26); + } +} + +sub pure_string { + my ($self, $op) = @_; + my $type = $op->name; + + if ($type eq 'const') { + return 1; + } + elsif ($type =~ /^[ul]c(first)?$/ || $type eq 'quotemeta') { + return $self->pure_string($op->first->sibling); + } + elsif ($type eq 'join') { + my $join_op = $op->first->sibling; # Skip pushmark + return 0 unless $join_op->name eq 'null' && $join_op->targ eq OP_RV2SV; + + my $gvop = $join_op->first; + return 0 unless $gvop->name eq 'gvsv'; + return 0 unless '"' eq $self->gv_name($self->gv_or_padgv($gvop)); + + return 0 unless ${$join_op->sibling} eq ${$op->last}; + return 0 unless $op->last->name =~ /^(rv2|pad)av$/; + } + elsif ($type eq 'concat') { + return $self->pure_string($op->first) + && $self->pure_string($op->last); + } + elsif (is_scalar($op) || $type =~ /^[ah]elem(fast)?$/) { + return 1; + } + else { + return 0; + } + + return 1; +} + +sub regcomp { + my $self = shift; + my($op, $cx, $extended) = @_; + my $kid = $op->first; + $kid = $kid->first if $kid->name eq "regcmaybe"; + $kid = $kid->first if $kid->name eq "regcreset"; + return ($self->re_dq($kid, $extended), 1) if $self->pure_string($kid); + return ($self->deparse($kid, $cx), 0); +} + +sub pp_regcomp { + my ($self, $op, $cx) = @_; + return (($self->regcomp($op, $cx, 0))[0]); +} + +# osmic acid -- see osmium tetroxide + +my %matchwords; +map($matchwords{join "", sort split //, $_} = $_, 'cig', 'cog', 'cos', 'cogs', + 'cox', 'go', 'is', 'ism', 'iso', 'mig', 'mix', 'osmic', 'ox', 'sic', + 'sig', 'six', 'smog', 'so', 'soc', 'sog', 'xi'); + +sub matchop { + my $self = shift; + my($op, $cx, $name, $delim) = @_; + my $kid = $op->first; + my ($binop, $var, $re) = ("", "", ""); + if ($op->flags & OPf_STACKED) { + $binop = 1; + $var = $self->deparse($kid, 20); + $kid = $kid->sibling; + } + my $quote = 1; + my $extended = ($op->pmflags & PMf_EXTENDED); + if (null $kid) { + my $unbacked = re_unback($op->precomp); + if ($extended) { + $re = re_uninterp_extended(escape_extended_re($unbacked)); + } else { + $re = re_uninterp(escape_str(re_unback($op->precomp))); + } + } elsif ($kid->name ne 'regcomp') { + carp("found ".$kid->name." where regcomp expected"); + } else { + ($re, $quote) = $self->regcomp($kid, 1, $extended); + } + my $flags = ""; + $flags .= "c" if $op->pmflags & PMf_CONTINUE; + $flags .= "g" if $op->pmflags & PMf_GLOBAL; + $flags .= "i" if $op->pmflags & PMf_FOLD; + $flags .= "m" if $op->pmflags & PMf_MULTILINE; + $flags .= "o" if $op->pmflags & PMf_KEEP; + $flags .= "s" if $op->pmflags & PMf_SINGLELINE; + $flags .= "x" if $op->pmflags & PMf_EXTENDED; + $flags = $matchwords{$flags} if $matchwords{$flags}; + if ($op->pmflags & PMf_ONCE) { # only one kind of delimiter works here + $re =~ s/\?/\\?/g; + $re = "?$re?"; + } elsif ($quote) { + $re = single_delim($name, $delim, $re); + } + $re = $re . $flags if $quote; + if ($binop) { + return $self->maybe_parens("$var =~ $re", $cx, 20); + } else { + return $re; + } +} + +sub pp_match { matchop(@_, "m", "/") } +sub pp_pushre { matchop(@_, "m", "/") } +sub pp_qr { matchop(@_, "qr", "") } + +sub pp_split { + my $self = shift; + my($op, $cx) = @_; + my($kid, @exprs, $ary, $expr); + $kid = $op->first; + # under ithreads pmreplroot is an integer, not an SV + my $replroot = $kid->pmreplroot; + if ( ( ref($replroot) && $$replroot ) || + ( !ref($replroot) && $replroot ) ) { + $ary = $self->stash_variable('@', $self->gv_name($kid->pmreplroot)); + } + for (; !null($kid); $kid = $kid->sibling) { + push @exprs, $self->deparse($kid, 6); + } + + # handle special case of split(), and split(" ") that compiles to /\s+/ + $kid = $op->first; + if ($kid->flags & OPf_SPECIAL + && $exprs[0] eq '/\\s+/' + && $kid->pmflags & PMf_SKIPWHITE ) { + $exprs[0] = '" "'; + } + + $expr = "split(" . join(", ", @exprs) . ")"; + if ($ary) { + return $self->maybe_parens("$ary = $expr", $cx, 7); + } else { + return $expr; + } +} + +# oxime -- any of various compounds obtained chiefly by the action of +# hydroxylamine on aldehydes and ketones and characterized by the +# bivalent grouping C=NOH [Webster's Tenth] + +my %substwords; +map($substwords{join "", sort split //, $_} = $_, 'ego', 'egoism', 'em', + 'es', 'ex', 'exes', 'gee', 'go', 'goes', 'ie', 'ism', 'iso', 'me', + 'meese', 'meso', 'mig', 'mix', 'os', 'ox', 'oxime', 'see', 'seem', + 'seg', 'sex', 'sig', 'six', 'smog', 'sog', 'some', 'xi'); + +sub pp_subst { + my $self = shift; + my($op, $cx) = @_; + my $kid = $op->first; + my($binop, $var, $re, $repl) = ("", "", "", ""); + if ($op->flags & OPf_STACKED) { + $binop = 1; + $var = $self->deparse($kid, 20); + $kid = $kid->sibling; + } + my $flags = ""; + if (null($op->pmreplroot)) { + $repl = $self->dq($kid); + $kid = $kid->sibling; + } else { + $repl = $op->pmreplroot->first; # skip substcont + while ($repl->name eq "entereval") { + $repl = $repl->first; + $flags .= "e"; + } + if ($op->pmflags & PMf_EVAL) { + $repl = $self->deparse($repl, 0); + } else { + $repl = $self->dq($repl); + } + } + my $extended = ($op->pmflags & PMf_EXTENDED); + if (null $kid) { + my $unbacked = re_unback($op->precomp); + if ($extended) { + $re = re_uninterp_extended(escape_extended_re($unbacked)); + } + else { + $re = re_uninterp(escape_str($unbacked)); + } + } else { + ($re) = $self->regcomp($kid, 1, $extended); + } + $flags .= "e" if $op->pmflags & PMf_EVAL; + $flags .= "g" if $op->pmflags & PMf_GLOBAL; + $flags .= "i" if $op->pmflags & PMf_FOLD; + $flags .= "m" if $op->pmflags & PMf_MULTILINE; + $flags .= "o" if $op->pmflags & PMf_KEEP; + $flags .= "s" if $op->pmflags & PMf_SINGLELINE; + $flags .= "x" if $extended; + $flags = $substwords{$flags} if $substwords{$flags}; + if ($binop) { + return $self->maybe_parens("$var =~ s" + . double_delim($re, $repl) . $flags, + $cx, 20); + } else { + return "s". double_delim($re, $repl) . $flags; + } +} + +1; +__END__ + +=head1 NAME + +B::Deparse - Perl compiler backend to produce perl code + +=head1 SYNOPSIS + +B<perl> B<-MO=Deparse>[B<,-u>I<PACKAGE>][B<,-p>][B<,-q>][B<,-l>] + [B<,-s>I<LETTERS>][B<,-x>I<LEVEL>] I<prog.pl> + +=head1 DESCRIPTION + +B::Deparse is a backend module for the Perl compiler that generates +perl source code, based on the internal compiled structure that perl +itself creates after parsing a program. The output of B::Deparse won't +be exactly the same as the original source, since perl doesn't keep +track of comments or whitespace, and there isn't a one-to-one +correspondence between perl's syntactical constructions and their +compiled form, but it will often be close. When you use the B<-p> +option, the output also includes parentheses even when they are not +required by precedence, which can make it easy to see if perl is +parsing your expressions the way you intended. + +Please note that this module is mainly new and untested code and is +still under development, so it may change in the future. + +=head1 OPTIONS + +As with all compiler backend options, these must follow directly after +the '-MO=Deparse', separated by a comma but not any white space. + +=over 4 + +=item B<-l> + +Add '#line' declarations to the output based on the line and file +locations of the original code. + +=item B<-p> + +Print extra parentheses. Without this option, B::Deparse includes +parentheses in its output only when they are needed, based on the +structure of your program. With B<-p>, it uses parentheses (almost) +whenever they would be legal. This can be useful if you are used to +LISP, or if you want to see how perl parses your input. If you say + + if ($var & 0x7f == 65) {print "Gimme an A!"} + print ($which ? $a : $b), "\n"; + $name = $ENV{USER} or "Bob"; + +C<B::Deparse,-p> will print + + if (($var & 0)) { + print('Gimme an A!') + }; + (print(($which ? $a : $b)), '???'); + (($name = $ENV{'USER'}) or '???') + +which probably isn't what you intended (the C<'???'> is a sign that +perl optimized away a constant value). + +=item B<-P> + +Disable prototype checking. With this option, all function calls are +deparsed as if no prototype was defined for them. In other words, + + perl -MO=Deparse,-P -e 'sub foo (\@) { 1 } foo @x' + +will print + + sub foo (\@) { + 1; + } + &foo(\@x); + +making clear how the parameters are actually passed to C<foo>. + +=item B<-q> + +Expand double-quoted strings into the corresponding combinations of +concatenation, uc, ucfirst, lc, lcfirst, quotemeta, and join. For +instance, print + + print "Hello, $world, @ladies, \u$gentlemen\E, \u\L$me!"; + +as + + print 'Hello, ' . $world . ', ' . join($", @ladies) . ', ' + . ucfirst($gentlemen) . ', ' . ucfirst(lc $me . '!'); + +Note that the expanded form represents the way perl handles such +constructions internally -- this option actually turns off the reverse +translation that B::Deparse usually does. On the other hand, note that +C<$x = "$y"> is not the same as C<$x = $y>: the former makes the value +of $y into a string before doing the assignment. + +=item B<-f>I<FILE> + +Normally, B::Deparse deparses the main code of a program, and all the subs +defined in the same file. To include subs defined in other files, pass the +B<-f> option with the filename. You can pass the B<-f> option several times, to +include more than one secondary file. (Most of the time you don't want to +use it at all.) You can also use this option to include subs which are +defined in the scope of a B<#line> directive with two parameters. + +=item B<-s>I<LETTERS> + +Tweak the style of B::Deparse's output. The letters should follow +directly after the 's', with no space or punctuation. The following +options are available: + +=over 4 + +=item B<C> + +Cuddle C<elsif>, C<else>, and C<continue> blocks. For example, print + + if (...) { + ... + } else { + ... + } + +instead of + + if (...) { + ... + } + else { + ... + } + +The default is not to cuddle. + +=item B<i>I<NUMBER> + +Indent lines by multiples of I<NUMBER> columns. The default is 4 columns. + +=item B<T> + +Use tabs for each 8 columns of indent. The default is to use only spaces. +For instance, if the style options are B<-si4T>, a line that's indented +3 times will be preceded by one tab and four spaces; if the options were +B<-si8T>, the same line would be preceded by three tabs. + +=item B<v>I<STRING>B<.> + +Print I<STRING> for the value of a constant that can't be determined +because it was optimized away (mnemonic: this happens when a constant +is used in B<v>oid context). The end of the string is marked by a period. +The string should be a valid perl expression, generally a constant. +Note that unless it's a number, it probably needs to be quoted, and on +a command line quotes need to be protected from the shell. Some +conventional values include 0, 1, 42, '', 'foo', and +'Useless use of constant omitted' (which may need to be +B<-sv"'Useless use of constant omitted'."> +or something similar depending on your shell). The default is '???'. +If you're using B::Deparse on a module or other file that's require'd, +you shouldn't use a value that evaluates to false, since the customary +true constant at the end of a module will be in void context when the +file is compiled as a main program. + +=back + +=item B<-x>I<LEVEL> + +Expand conventional syntax constructions into equivalent ones that expose +their internal operation. I<LEVEL> should be a digit, with higher values +meaning more expansion. As with B<-q>, this actually involves turning off +special cases in B::Deparse's normal operations. + +If I<LEVEL> is at least 3, for loops will be translated into equivalent +while loops with continue blocks; for instance + + for ($i = 0; $i < 10; ++$i) { + print $i; + } + +turns into + + $i = 0; + while ($i < 10) { + print $i; + } continue { + ++$i + } + +Note that in a few cases this translation can't be perfectly carried back +into the source code -- if the loop's initializer declares a my variable, +for instance, it won't have the correct scope outside of the loop. + +If I<LEVEL> is at least 7, if statements will be translated into equivalent +expressions using C<&&>, C<?:> and C<do {}>; for instance + + print 'hi' if $nice; + if ($nice) { + print 'hi'; + } + if ($nice) { + print 'hi'; + } else { + print 'bye'; + } + +turns into + + $nice and print 'hi'; + $nice and do { print 'hi' }; + $nice ? do { print 'hi' } : do { print 'bye' }; + +Long sequences of elsifs will turn into nested ternary operators, which +B::Deparse doesn't know how to indent nicely. + +=back + +=head1 USING B::Deparse AS A MODULE + +=head2 Synopsis + + use B::Deparse; + $deparse = B::Deparse->new("-p", "-sC"); + $body = $deparse->coderef2text(\&func); + eval "sub func $body"; # the inverse operation + +=head2 Description + +B::Deparse can also be used on a sub-by-sub basis from other perl +programs. + +=head2 new + + $deparse = B::Deparse->new(OPTIONS) + +Create an object to store the state of a deparsing operation and any +options. The options are the same as those that can be given on the +command line (see L</OPTIONS>); options that are separated by commas +after B<-MO=Deparse> should be given as separate strings. Some +options, like B<-u>, don't make sense for a single subroutine, so +don't pass them. + +=head2 ambient_pragmas + + $deparse->ambient_pragmas(strict => 'all', '$[' => $[); + +The compilation of a subroutine can be affected by a few compiler +directives, B<pragmas>. These are: + +=over 4 + +=item * + +use strict; + +=item * + +use warnings; + +=item * + +Assigning to the special variable $[ + +=item * + +use integer; + +=item * + +use bytes; + +=item * + +use utf8; + +=item * + +use re; + +=back + +Ordinarily, if you use B::Deparse on a subroutine which has +been compiled in the presence of one or more of these pragmas, +the output will include statements to turn on the appropriate +directives. So if you then compile the code returned by coderef2text, +it will behave the same way as the subroutine which you deparsed. + +However, you may know that you intend to use the results in a +particular context, where some pragmas are already in scope. In +this case, you use the B<ambient_pragmas> method to describe the +assumptions you wish to make. + +Not all of the options currently have any useful effect. See +L</BUGS> for more details. + +The parameters it accepts are: + +=over 4 + +=item strict + +Takes a string, possibly containing several values separated +by whitespace. The special values "all" and "none" mean what you'd +expect. + + $deparse->ambient_pragmas(strict => 'subs refs'); + +=item $[ + +Takes a number, the value of the array base $[. + +=item bytes + +=item utf8 + +=item integer + +If the value is true, then the appropriate pragma is assumed to +be in the ambient scope, otherwise not. + +=item re + +Takes a string, possibly containing a whitespace-separated list of +values. The values "all" and "none" are special. It's also permissible +to pass an array reference here. + + $deparser->ambient_pragmas(re => 'eval'); + + +=item warnings + +Takes a string, possibly containing a whitespace-separated list of +values. The values "all" and "none" are special, again. It's also +permissible to pass an array reference here. + + $deparser->ambient_pragmas(warnings => [qw[void io]]); + +If one of the values is the string "FATAL", then all the warnings +in that list will be considered fatal, just as with the B<warnings> +pragma itself. Should you need to specify that some warnings are +fatal, and others are merely enabled, you can pass the B<warnings> +parameter twice: + + $deparser->ambient_pragmas( + warnings => 'all', + warnings => [FATAL => qw/void io/], + ); + +See L<perllexwarn> for more information about lexical warnings. + +=item hint_bits + +=item warning_bits + +These two parameters are used to specify the ambient pragmas in +the format used by the special variables $^H and ${^WARNING_BITS}. + +They exist principally so that you can write code like: + + { my ($hint_bits, $warning_bits); + BEGIN {($hint_bits, $warning_bits) = ($^H, ${^WARNING_BITS})} + $deparser->ambient_pragmas ( + hint_bits => $hint_bits, + warning_bits => $warning_bits, + '$[' => 0 + $[ + ); } + +which specifies that the ambient pragmas are exactly those which +are in scope at the point of calling. + +=back + +=head2 coderef2text + + $body = $deparse->coderef2text(\&func) + $body = $deparse->coderef2text(sub ($$) { ... }) + +Return source code for the body of a subroutine (a block, optionally +preceded by a prototype in parens), given a reference to the +sub. Because a subroutine can have no names, or more than one name, +this method doesn't return a complete subroutine definition -- if you +want to eval the result, you should prepend "sub subname ", or "sub " +for an anonymous function constructor. Unless the sub was defined in +the main:: package, the code will include a package declaration. + +=head1 BUGS + +=over 4 + +=item * + +The only pragmas to be completely supported are: C<use warnings>, +C<use strict 'refs'>, C<use bytes>, and C<use integer>. (C<$[>, which +behaves like a pragma, is also supported.) + +Excepting those listed above, we're currently unable to guarantee that +B::Deparse will produce a pragma at the correct point in the program. +Since the effects of pragmas are often lexically scoped, this can mean +that the pragma holds sway over a different portion of the program +than in the input file. + +=item * + +In fact, the above is a specific instance of a more general problem: +we can't guarantee to produce BEGIN blocks or C<use> declarations in +exactly the right place. So if you use a module which affects compilation +(such as by over-riding keywords, overloading constants or whatever) +then the output code might not work as intended. + +This is the most serious outstanding problem, and will be very hard +to fix. + +=item * + +If a keyword is over-ridden, and your program explicitly calls +the built-in version by using CORE::keyword, the output of B::Deparse +will not reflect this. If you run the resulting code, it will call +the over-ridden version rather than the built-in one. (Maybe there +should be an option to B<always> print keyword calls as C<CORE::name>.) + +=item * + +C<sort foo (1, 2, 3)> comes out as C<sort (foo 1, 2, 3)>, which +causes perl to issue a warning. + +The obvious fix doesn't work, because these are different: + + print (FOO 1, 2, 3), 4, 5, 6; + print FOO (1, 2, 3), 4, 5, 6; + +=item * + +Constants (other than simple strings or numbers) don't work properly. +Pathological examples that fail (and probably always will) include: + + use constant E2BIG => ($!=7); + use constant x=>\$x; print x + +The following could (and should) be made to work: + + use constant regex => qr/blah/; + print regex; + +=item * + +An input file that uses source filtering probably won't be deparsed into +runnable code, because it will still include the B<use> declaration +for the source filtering module, even though the code that is +produced is already ordinary Perl which shouldn't be filtered again. + +=item * + +There are probably many more bugs on non-ASCII platforms (EBCDIC). + +=back + +=head1 AUTHOR + +Stephen McCamant <smcc@CSUA.Berkeley.EDU>, based on an earlier +version by Malcolm Beattie <mbeattie@sable.ox.ac.uk>, with +contributions from Gisle Aas, James Duncan, Albert Dvornik, Robin +Houston, Hugo van der Sanden, Gurusamy Sarathy, Nick Ing-Simmons, +and Rafael Garcia-Suarez. + +=cut diff --git a/Master/xemtex/perl/lib/Carp.pm b/Master/xemtex/perl/lib/Carp.pm new file mode 100644 index 00000000000..6199f894487 --- /dev/null +++ b/Master/xemtex/perl/lib/Carp.pm @@ -0,0 +1,196 @@ +package Carp; + +our $VERSION = '1.01'; + +=head1 NAME + +carp - warn of errors (from perspective of caller) + +cluck - warn of errors with stack backtrace + (not exported by default) + +croak - die of errors (from perspective of caller) + +confess - die of errors with stack backtrace + +shortmess - return the message that carp and croak produce + +longmess - return the message that cluck and confess produce + +=head1 SYNOPSIS + + use Carp; + croak "We're outta here!"; + + use Carp qw(cluck); + cluck "This is how we got here!"; + + print FH Carp::shortmess("This will have caller's details added"); + print FH Carp::longmess("This will have stack backtrace added"); + +=head1 DESCRIPTION + +The Carp routines are useful in your own modules because +they act like die() or warn(), but with a message which is more +likely to be useful to a user of your module. In the case of +cluck, confess, and longmess that context is a summary of every +call in the call-stack. For a shorter message you can use carp, +croak or shortmess which report the error as being from where +your module was called. There is no guarantee that that is where +the error was, but it is a good educated guess. + +Here is a more complete description of how shortmess works. What +it does is search the call-stack for a function call stack where +it hasn't been told that there shouldn't be an error. If every +call is marked safe, it then gives up and gives a full stack +backtrace instead. In other words it presumes that the first likely +looking potential suspect is guilty. Its rules for telling whether +a call shouldn't generate errors work as follows: + +=over 4 + +=item 1. + +Any call from a package to itself is safe. + +=item 2. + +Packages claim that there won't be errors on calls to or from +packages explicitly marked as safe by inclusion in @CARP_NOT, or +(if that array is empty) @ISA. The ability to override what +@ISA says is new in 5.8. + +=item 3. + +The trust in item 2 is transitive. If A trusts B, and B +trusts C, then A trusts C. So if you do not override @ISA +with @CARP_NOT, then this trust relationship is identical to, +"inherits from". + +=item 4. + +Any call from an internal Perl module is safe. (Nothing keeps +user modules from marking themselves as internal to Perl, but +this practice is discouraged.) + +=item 5. + +Any call to Carp is safe. (This rule is what keeps it from +reporting the error where you call carp/croak/shortmess.) + +=back + +=head2 Forcing a Stack Trace + +As a debugging aid, you can force Carp to treat a croak as a confess +and a carp as a cluck across I<all> modules. In other words, force a +detailed stack trace to be given. This can be very helpful when trying +to understand why, or from where, a warning or error is being generated. + +This feature is enabled by 'importing' the non-existent symbol +'verbose'. You would typically enable it by saying + + perl -MCarp=verbose script.pl + +or by including the string C<MCarp=verbose> in the PERL5OPT +environment variable. + +=head1 BUGS + +The Carp routines don't handle exception objects currently. +If called with a first argument that is a reference, they simply +call die() or warn(), as appropriate. + +=cut + +# This package is heavily used. Be small. Be fast. Be good. + +# Comments added by Andy Wardley <abw@kfs.org> 09-Apr-98, based on an +# _almost_ complete understanding of the package. Corrections and +# comments are welcome. + +# The members of %Internal are packages that are internal to perl. +# Carp will not report errors from within these packages if it +# can. The members of %CarpInternal are internal to Perl's warning +# system. Carp will not report errors from within these packages +# either, and will not report calls *to* these packages for carp and +# croak. They replace $CarpLevel, which is deprecated. The +# $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval +# text and function arguments should be formatted when printed. + +$CarpInternal{Carp}++; +$CarpInternal{warnings}++; +$CarpLevel = 0; # How many extra package levels to skip on carp. + # How many calls to skip on confess. + # Reconciling these notions is hard, use + # %Internal and %CarpInternal instead. +$MaxEvalLen = 0; # How much eval '...text...' to show. 0 = all. +$MaxArgLen = 64; # How much of each argument to print. 0 = all. +$MaxArgNums = 8; # How many arguments to print. 0 = all. +$Verbose = 0; # If true then make shortmess call longmess instead + +require Exporter; +@ISA = ('Exporter'); +@EXPORT = qw(confess croak carp); +@EXPORT_OK = qw(cluck verbose longmess shortmess); +@EXPORT_FAIL = qw(verbose); # hook to enable verbose mode + + +# if the caller specifies verbose usage ("perl -MCarp=verbose script.pl") +# then the following method will be called by the Exporter which knows +# to do this thanks to @EXPORT_FAIL, above. $_[1] will contain the word +# 'verbose'. + +sub export_fail { + shift; + $Verbose = shift if $_[0] eq 'verbose'; + return @_; +} + + +# longmess() crawls all the way up the stack reporting on all the function +# calls made. The error string, $error, is originally constructed from the +# arguments passed into longmess() via confess(), cluck() or shortmess(). +# This gets appended with the stack trace messages which are generated for +# each function call on the stack. + +sub longmess { + { local $@; require Carp::Heavy; } # XXX fix require to not clear $@? + # Icky backwards compatibility wrapper. :-( + my $call_pack = caller(); + if ($Internal{$call_pack} or $CarpInternal{$call_pack}) { + return longmess_heavy(@_); + } + else { + local $CarpLevel = $CarpLevel + 1; + return longmess_heavy(@_); + } +} + + +# shortmess() is called by carp() and croak() to skip all the way up to +# the top-level caller's package and report the error from there. confess() +# and cluck() generate a full stack trace so they call longmess() to +# generate that. In verbose mode shortmess() calls longmess() so +# you always get a stack trace + +sub shortmess { # Short-circuit &longmess if called via multiple packages + { local $@; require Carp::Heavy; } # XXX fix require to not clear $@? + # Icky backwards compatibility wrapper. :-( + my $call_pack = caller(); + local @CARP_NOT = caller(); + shortmess_heavy(@_); +} + + +# the following four functions call longmess() or shortmess() depending on +# whether they should generate a full stack trace (confess() and cluck()) +# or simply report the caller's package (croak() and carp()), respectively. +# confess() and croak() die, carp() and cluck() warn. + +sub croak { die shortmess @_ } +sub confess { die longmess @_ } +sub carp { warn shortmess @_ } +sub cluck { warn longmess @_ } + +1; diff --git a/Master/xemtex/perl/lib/Carp/Heavy.pm b/Master/xemtex/perl/lib/Carp/Heavy.pm new file mode 100644 index 00000000000..c3d3c26fa1a --- /dev/null +++ b/Master/xemtex/perl/lib/Carp/Heavy.pm @@ -0,0 +1,247 @@ +# Carp::Heavy uses some variables in common with Carp. +package Carp; + +=head1 NAME + +Carp heavy machinery - no user serviceable parts inside + +=cut + +# use strict; # not yet + +# On one line so MakeMaker will see it. +use Carp; our $VERSION = $Carp::VERSION; + +our ($CarpLevel, $MaxArgNums, $MaxEvalLen, $MaxArgLen, $Verbose); + +sub caller_info { + my $i = shift(@_) + 1; + package DB; + my %call_info; + @call_info{ + qw(pack file line sub has_args wantarray evaltext is_require) + } = caller($i); + + unless (defined $call_info{pack}) { + return (); + } + + my $sub_name = Carp::get_subname(\%call_info); + if ($call_info{has_args}) { + my @args = map {Carp::format_arg($_)} @DB::args; + if ($MaxArgNums and @args > $MaxArgNums) { # More than we want to show? + $#args = $MaxArgNums; + push @args, '...'; + } + # Push the args onto the subroutine + $sub_name .= '(' . join (',', @args) . ')'; + } + $call_info{sub_name} = $sub_name; + return wantarray() ? %call_info : \%call_info; +} + +# Transform an argument to a function into a string. +sub format_arg { + my $arg = shift; + if (not defined($arg)) { + $arg = 'undef'; + } + elsif (ref($arg)) { + $arg = defined($overload::VERSION) ? overload::StrVal($arg) : "$arg"; + } + $arg =~ s/'/\\'/g; + $arg = str_len_trim($arg, $MaxArgLen); + + # Quote it? + $arg = "'$arg'" unless $arg =~ /^-?[\d.]+\z/; + + # The following handling of "control chars" is direct from + # the original code - I think it is broken on Unicode though. + # Suggestions? + $arg =~ s/([[:cntrl:]]|[[:^ascii:]])/sprintf("\\x{%x}",ord($1))/eg; + return $arg; +} + +# Takes an inheritance cache and a package and returns +# an anon hash of known inheritances and anon array of +# inheritances which consequences have not been figured +# for. +sub get_status { + my $cache = shift; + my $pkg = shift; + $cache->{$pkg} ||= [{$pkg => $pkg}, [trusts_directly($pkg)]]; + return @{$cache->{$pkg}}; +} + +# Takes the info from caller() and figures out the name of +# the sub/require/eval +sub get_subname { + my $info = shift; + if (defined($info->{evaltext})) { + my $eval = $info->{evaltext}; + if ($info->{is_require}) { + return "require $eval"; + } + else { + $eval =~ s/([\\\'])/\\$1/g; + return "eval '" . str_len_trim($eval, $MaxEvalLen) . "'"; + } + } + + return ($info->{sub} eq '(eval)') ? 'eval {...}' : $info->{sub}; +} + +# Figures out what call (from the point of view of the caller) +# the long error backtrace should start at. +sub long_error_loc { + my $i; + my $lvl = $CarpLevel; + { + my $pkg = caller(++$i); + unless(defined($pkg)) { + # This *shouldn't* happen. + if (%Internal) { + local %Internal; + $i = long_error_loc(); + last; + } + else { + # OK, now I am irritated. + return 2; + } + } + redo if $CarpInternal{$pkg}; + redo unless 0 > --$lvl; + redo if $Internal{$pkg}; + } + return $i - 1; +} + + +sub longmess_heavy { + return @_ if ref($_[0]); # don't break references as exceptions + my $i = long_error_loc(); + return ret_backtrace($i, @_); +} + +# Returns a full stack backtrace starting from where it is +# told. +sub ret_backtrace { + my ($i, @error) = @_; + my $mess; + my $err = join '', @error; + $i++; + + my $tid_msg = ''; + if (defined &Thread::tid) { + my $tid = Thread->self->tid; + $tid_msg = " thread $tid" if $tid; + } + + { if ($err =~ /\n$/) { # extra block to localise $1 etc + $mess = $err; + } + else { + my %i = caller_info($i); + $mess = "$err at $i{file} line $i{line}$tid_msg\n"; + }} + + while (my %i = caller_info(++$i)) { + $mess .= "\t$i{sub_name} called at $i{file} line $i{line}$tid_msg\n"; + } + + return $mess; +} + +sub ret_summary { + my ($i, @error) = @_; + my $mess; + my $err = join '', @error; + $i++; + + my $tid_msg = ''; + if (defined &Thread::tid) { + my $tid = Thread->self->tid; + $tid_msg = " thread $tid" if $tid; + } + + my %i = caller_info($i); + return "$err at $i{file} line $i{line}$tid_msg\n"; +} + + +sub short_error_loc { + my $cache; + my $i = 1; + my $lvl = $CarpLevel; + { + my $called = caller($i++); + my $caller = caller($i); + return 0 unless defined($caller); # What happened? + redo if $Internal{$caller}; + redo if $CarpInternal{$called}; + redo if trusts($called, $caller, $cache); + redo if trusts($caller, $called, $cache); + redo unless 0 > --$lvl; + } + return $i - 1; +} + +sub shortmess_heavy { + return longmess_heavy(@_) if $Verbose; + return @_ if ref($_[0]); # don't break references as exceptions + my $i = short_error_loc(); + if ($i) { + ret_summary($i, @_); + } + else { + longmess_heavy(@_); + } +} + +# If a string is too long, trims it with ... +sub str_len_trim { + my $str = shift; + my $max = shift || 0; + if (2 < $max and $max < length($str)) { + substr($str, $max - 3) = '...'; + } + return $str; +} + +# Takes two packages and an optional cache. Says whether the +# first inherits from the second. +# +# Recursive versions of this have to work to avoid certain +# possible endless loops, and when following long chains of +# inheritance are less efficient. +sub trusts { + my $child = shift; + my $parent = shift; + my $cache = shift || {}; + my ($known, $partial) = get_status($cache, $child); + # Figure out consequences until we have an answer + while (@$partial and not exists $known->{$parent}) { + my $anc = shift @$partial; + next if exists $known->{$anc}; + $known->{$anc}++; + my ($anc_knows, $anc_partial) = get_status($cache, $anc); + my @found = keys %$anc_knows; + @$known{@found} = (); + push @$partial, @$anc_partial; + } + return exists $known->{$parent}; +} + +# Takes a package and gives a list of those trusted directly +sub trusts_directly { + my $class = shift; + no strict 'refs'; + no warnings 'once'; + return @{"$class\::CARP_NOT"} + ? @{"$class\::CARP_NOT"} + : @{"$class\::ISA"}; +} + +1; + diff --git a/Master/xemtex/perl/lib/Class/Struct.pm b/Master/xemtex/perl/lib/Class/Struct.pm new file mode 100644 index 00000000000..bad4f78165f --- /dev/null +++ b/Master/xemtex/perl/lib/Class/Struct.pm @@ -0,0 +1,632 @@ +package Class::Struct; + +## See POD after __END__ + +use 5.006_001; + +use strict; +use warnings::register; +our(@ISA, @EXPORT, $VERSION); + +use Carp; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(struct); + +$VERSION = '0.61'; + +## Tested on 5.002 and 5.003 without class membership tests: +my $CHECK_CLASS_MEMBERSHIP = ($] >= 5.003_95); + +my $print = 0; +sub printem { + if (@_) { $print = shift } + else { $print++ } +} + +{ + package Class::Struct::Tie_ISA; + + sub TIEARRAY { + my $class = shift; + return bless [], $class; + } + + sub STORE { + my ($self, $index, $value) = @_; + Class::Struct::_subclass_error(); + } + + sub FETCH { + my ($self, $index) = @_; + $self->[$index]; + } + + sub FETCHSIZE { + my $self = shift; + return scalar(@$self); + } + + sub DESTROY { } +} + +sub import { + my $self = shift; + + if ( @_ == 0 ) { + $self->export_to_level( 1, $self, @EXPORT ); + } elsif ( @_ == 1 ) { + # This is admittedly a little bit silly: + # do we ever export anything else than 'struct'...? + $self->export_to_level( 1, $self, @_ ); + } else { + &struct; + } +} + +sub struct { + + # Determine parameter list structure, one of: + # struct( class => [ element-list ]) + # struct( class => { element-list }) + # struct( element-list ) + # Latter form assumes current package name as struct name. + + my ($class, @decls); + my $base_type = ref $_[1]; + if ( $base_type eq 'HASH' ) { + $class = shift; + @decls = %{shift()}; + _usage_error() if @_; + } + elsif ( $base_type eq 'ARRAY' ) { + $class = shift; + @decls = @{shift()}; + _usage_error() if @_; + } + else { + $base_type = 'ARRAY'; + $class = (caller())[0]; + @decls = @_; + } + + _usage_error() if @decls % 2 == 1; + + # Ensure we are not, and will not be, a subclass. + + my $isa = do { + no strict 'refs'; + \@{$class . '::ISA'}; + }; + _subclass_error() if @$isa; + tie @$isa, 'Class::Struct::Tie_ISA'; + + # Create constructor. + + croak "function 'new' already defined in package $class" + if do { no strict 'refs'; defined &{$class . "::new"} }; + + my @methods = (); + my %refs = (); + my %arrays = (); + my %hashes = (); + my %classes = (); + my $got_class = 0; + my $out = ''; + + $out = "{\n package $class;\n use Carp;\n sub new {\n"; + $out .= " my (\$class, \%init) = \@_;\n"; + $out .= " \$class = __PACKAGE__ unless \@_;\n"; + + my $cnt = 0; + my $idx = 0; + my( $cmt, $name, $type, $elem ); + + if( $base_type eq 'HASH' ){ + $out .= " my(\$r) = {};\n"; + $cmt = ''; + } + elsif( $base_type eq 'ARRAY' ){ + $out .= " my(\$r) = [];\n"; + } + while( $idx < @decls ){ + $name = $decls[$idx]; + $type = $decls[$idx+1]; + push( @methods, $name ); + if( $base_type eq 'HASH' ){ + $elem = "{'${class}::$name'}"; + } + elsif( $base_type eq 'ARRAY' ){ + $elem = "[$cnt]"; + ++$cnt; + $cmt = " # $name"; + } + if( $type =~ /^\*(.)/ ){ + $refs{$name}++; + $type = $1; + } + my $init = "defined(\$init{'$name'}) ? \$init{'$name'} :"; + if( $type eq '@' ){ + $out .= " croak 'Initializer for $name must be array reference'\n"; + $out .= " if defined(\$init{'$name'}) && ref(\$init{'$name'}) ne 'ARRAY';\n"; + $out .= " \$r->$elem = $init [];$cmt\n"; + $arrays{$name}++; + } + elsif( $type eq '%' ){ + $out .= " croak 'Initializer for $name must be hash reference'\n"; + $out .= " if defined(\$init{'$name'}) && ref(\$init{'$name'}) ne 'HASH';\n"; + $out .= " \$r->$elem = $init {};$cmt\n"; + $hashes{$name}++; + } + elsif ( $type eq '$') { + $out .= " \$r->$elem = $init undef;$cmt\n"; + } + elsif( $type =~ /^\w+(?:::\w+)*$/ ){ + $out .= " if (defined(\$init{'$name'})) {\n"; + $out .= " if (ref \$init{'$name'} eq 'HASH')\n"; + $out .= " { \$r->$elem = $type->new(\%{\$init{'$name'}}) } $cmt\n"; + $out .= " elsif (UNIVERSAL::isa(\$init{'$name'}, '$type'))\n"; + $out .= " { \$r->$elem = \$init{'$name'} } $cmt\n"; + $out .= " else { croak 'Initializer for $name must be hash or $type reference' }\n"; + $out .= " }\n"; + $classes{$name} = $type; + $got_class = 1; + } + else{ + croak "'$type' is not a valid struct element type"; + } + $idx += 2; + } + $out .= " bless \$r, \$class;\n }\n"; + + # Create accessor methods. + + my( $pre, $pst, $sel ); + $cnt = 0; + foreach $name (@methods){ + if ( do { no strict 'refs'; defined &{$class . "::$name"} } ) { + warnings::warnif("function '$name' already defined, overrides struct accessor method"); + } + else { + $pre = $pst = $cmt = $sel = ''; + if( defined $refs{$name} ){ + $pre = "\\("; + $pst = ")"; + $cmt = " # returns ref"; + } + $out .= " sub $name {$cmt\n my \$r = shift;\n"; + if( $base_type eq 'ARRAY' ){ + $elem = "[$cnt]"; + ++$cnt; + } + elsif( $base_type eq 'HASH' ){ + $elem = "{'${class}::$name'}"; + } + if( defined $arrays{$name} ){ + $out .= " my \$i;\n"; + $out .= " \@_ ? (\$i = shift) : return \$r->$elem;\n"; + $out .= " if (ref(\$i) eq 'ARRAY' && !\@_) { \$r->$elem = \$i; return \$r }\n"; + $sel = "->[\$i]"; + } + elsif( defined $hashes{$name} ){ + $out .= " my \$i;\n"; + $out .= " \@_ ? (\$i = shift) : return \$r->$elem;\n"; + $out .= " if (ref(\$i) eq 'HASH' && !\@_) { \$r->$elem = \$i; return \$r }\n"; + $sel = "->{\$i}"; + } + elsif( defined $classes{$name} ){ + if ( $CHECK_CLASS_MEMBERSHIP ) { + $out .= " croak '$name argument is wrong class' if \@_ && ! UNIVERSAL::isa(\$_[0], '$classes{$name}');\n"; + } + } + $out .= " croak 'Too many args to $name' if \@_ > 1;\n"; + $out .= " \@_ ? ($pre\$r->$elem$sel = shift$pst) : $pre\$r->$elem$sel$pst;\n"; + $out .= " }\n"; + } + } + $out .= "}\n1;\n"; + + print $out if $print; + my $result = eval $out; + carp $@ if $@; +} + +sub _usage_error { + confess "struct usage error"; +} + +sub _subclass_error { + croak 'struct class cannot be a subclass (@ISA not allowed)'; +} + +1; # for require + + +__END__ + +=head1 NAME + +Class::Struct - declare struct-like datatypes as Perl classes + +=head1 SYNOPSIS + + use Class::Struct; + # declare struct, based on array: + struct( CLASS_NAME => [ ELEMENT_NAME => ELEMENT_TYPE, ... ]); + # declare struct, based on hash: + struct( CLASS_NAME => { ELEMENT_NAME => ELEMENT_TYPE, ... }); + + package CLASS_NAME; + use Class::Struct; + # declare struct, based on array, implicit class name: + struct( ELEMENT_NAME => ELEMENT_TYPE, ... ); + + # Declare struct at compile time + use Class::Struct CLASS_NAME => [ ELEMENT_NAME => ELEMENT_TYPE, ... ]; + use Class::Struct CLASS_NAME => { ELEMENT_NAME => ELEMENT_TYPE, ... }; + + package Myobj; + use Class::Struct; + # declare struct with four types of elements: + struct( s => '$', a => '@', h => '%', c => 'My_Other_Class' ); + + $obj = new Myobj; # constructor + + # scalar type accessor: + $element_value = $obj->s; # element value + $obj->s('new value'); # assign to element + + # array type accessor: + $ary_ref = $obj->a; # reference to whole array + $ary_element_value = $obj->a(2); # array element value + $obj->a(2, 'new value'); # assign to array element + + # hash type accessor: + $hash_ref = $obj->h; # reference to whole hash + $hash_element_value = $obj->h('x'); # hash element value + $obj->h('x', 'new value'); # assign to hash element + + # class type accessor: + $element_value = $obj->c; # object reference + $obj->c->method(...); # call method of object + $obj->c(new My_Other_Class); # assign a new object + +=head1 DESCRIPTION + +C<Class::Struct> exports a single function, C<struct>. +Given a list of element names and types, and optionally +a class name, C<struct> creates a Perl 5 class that implements +a "struct-like" data structure. + +The new class is given a constructor method, C<new>, for creating +struct objects. + +Each element in the struct data has an accessor method, which is +used to assign to the element and to fetch its value. The +default accessor can be overridden by declaring a C<sub> of the +same name in the package. (See Example 2.) + +Each element's type can be scalar, array, hash, or class. + +=head2 The C<struct()> function + +The C<struct> function has three forms of parameter-list. + + struct( CLASS_NAME => [ ELEMENT_LIST ]); + struct( CLASS_NAME => { ELEMENT_LIST }); + struct( ELEMENT_LIST ); + +The first and second forms explicitly identify the name of the +class being created. The third form assumes the current package +name as the class name. + +An object of a class created by the first and third forms is +based on an array, whereas an object of a class created by the +second form is based on a hash. The array-based forms will be +somewhat faster and smaller; the hash-based forms are more +flexible. + +The class created by C<struct> must not be a subclass of another +class other than C<UNIVERSAL>. + +It can, however, be used as a superclass for other classes. To facilitate +this, the generated constructor method uses a two-argument blessing. +Furthermore, if the class is hash-based, the key of each element is +prefixed with the class name (see I<Perl Cookbook>, Recipe 13.12). + +A function named C<new> must not be explicitly defined in a class +created by C<struct>. + +The I<ELEMENT_LIST> has the form + + NAME => TYPE, ... + +Each name-type pair declares one element of the struct. Each +element name will be defined as an accessor method unless a +method by that name is explicitly defined; in the latter case, a +warning is issued if the warning flag (B<-w>) is set. + +=head2 Class Creation at Compile Time + +C<Class::Struct> can create your class at compile time. The main reason +for doing this is obvious, so your class acts like every other class in +Perl. Creating your class at compile time will make the order of events +similar to using any other class ( or Perl module ). + +There is no significant speed gain between compile time and run time +class creation, there is just a new, more standard order of events. + +=head2 Element Types and Accessor Methods + +The four element types -- scalar, array, hash, and class -- are +represented by strings -- C<'$'>, C<'@'>, C<'%'>, and a class name -- +optionally preceded by a C<'*'>. + +The accessor method provided by C<struct> for an element depends +on the declared type of the element. + +=over 4 + +=item Scalar (C<'$'> or C<'*$'>) + +The element is a scalar, and by default is initialized to C<undef> +(but see L<Initializing with new>). + +The accessor's argument, if any, is assigned to the element. + +If the element type is C<'$'>, the value of the element (after +assignment) is returned. If the element type is C<'*$'>, a reference +to the element is returned. + +=item Array (C<'@'> or C<'*@'>) + +The element is an array, initialized by default to C<()>. + +With no argument, the accessor returns a reference to the +element's whole array (whether or not the element was +specified as C<'@'> or C<'*@'>). + +With one or two arguments, the first argument is an index +specifying one element of the array; the second argument, if +present, is assigned to the array element. If the element type +is C<'@'>, the accessor returns the array element value. If the +element type is C<'*@'>, a reference to the array element is +returned. + +As a special case, when the accessor is called with an array reference +as the sole argument, this causes an assignment of the whole array element. +The object reference is returned. + +=item Hash (C<'%'> or C<'*%'>) + +The element is a hash, initialized by default to C<()>. + +With no argument, the accessor returns a reference to the +element's whole hash (whether or not the element was +specified as C<'%'> or C<'*%'>). + +With one or two arguments, the first argument is a key specifying +one element of the hash; the second argument, if present, is +assigned to the hash element. If the element type is C<'%'>, the +accessor returns the hash element value. If the element type is +C<'*%'>, a reference to the hash element is returned. + +As a special case, when the accessor is called with a hash reference +as the sole argument, this causes an assignment of the whole hash element. +The object reference is returned. + +=item Class (C<'Class_Name'> or C<'*Class_Name'>) + +The element's value must be a reference blessed to the named +class or to one of its subclasses. The element is not initialized +by default. + +The accessor's argument, if any, is assigned to the element. The +accessor will C<croak> if this is not an appropriate object +reference. + +If the element type does not start with a C<'*'>, the accessor +returns the element value (after assignment). If the element type +starts with a C<'*'>, a reference to the element itself is returned. + +=back + +=head2 Initializing with C<new> + +C<struct> always creates a constructor called C<new>. That constructor +may take a list of initializers for the various elements of the new +struct. + +Each initializer is a pair of values: I<element name>C< =E<gt> >I<value>. +The initializer value for a scalar element is just a scalar value. The +initializer for an array element is an array reference. The initializer +for a hash is a hash reference. + +The initializer for a class element is an object of the corresponding class, +or of one of it's subclasses, or a reference to a hash containing named +arguments to be passed to the element's constructor. + +See Example 3 below for an example of initialization. + +=head1 EXAMPLES + +=over 4 + +=item Example 1 + +Giving a struct element a class type that is also a struct is how +structs are nested. Here, C<timeval> represents a time (seconds and +microseconds), and C<rusage> has two elements, each of which is of +type C<timeval>. + + use Class::Struct; + + struct( rusage => { + ru_utime => timeval, # seconds + ru_stime => timeval, # microseconds + }); + + struct( timeval => [ + tv_secs => '$', + tv_usecs => '$', + ]); + + # create an object: + my $t = new rusage; + + # $t->ru_utime and $t->ru_stime are objects of type timeval. + # set $t->ru_utime to 100.0 sec and $t->ru_stime to 5.0 sec. + $t->ru_utime->tv_secs(100); + $t->ru_utime->tv_usecs(0); + $t->ru_stime->tv_secs(5); + $t->ru_stime->tv_usecs(0); + +=item Example 2 + +An accessor function can be redefined in order to provide +additional checking of values, etc. Here, we want the C<count> +element always to be nonnegative, so we redefine the C<count> +accessor accordingly. + + package MyObj; + use Class::Struct; + + # declare the struct + struct ( 'MyObj', { count => '$', stuff => '%' } ); + + # override the default accessor method for 'count' + sub count { + my $self = shift; + if ( @_ ) { + die 'count must be nonnegative' if $_[0] < 0; + $self->{'count'} = shift; + warn "Too many args to count" if @_; + } + return $self->{'count'}; + } + + package main; + $x = new MyObj; + print "\$x->count(5) = ", $x->count(5), "\n"; + # prints '$x->count(5) = 5' + + print "\$x->count = ", $x->count, "\n"; + # prints '$x->count = 5' + + print "\$x->count(-5) = ", $x->count(-5), "\n"; + # dies due to negative argument! + +=item Example 3 + +The constructor of a generated class can be passed a list +of I<element>=>I<value> pairs, with which to initialize the struct. +If no initializer is specified for a particular element, its default +initialization is performed instead. Initializers for non-existent +elements are silently ignored. + +Note that the initializer for a nested class may be specified as +an object of that class, or as a reference to a hash of initializers +that are passed on to the nested struct's constructor. + + use Class::Struct; + + struct Breed => + { + name => '$', + cross => '$', + }; + + struct Cat => + [ + name => '$', + kittens => '@', + markings => '%', + breed => 'Breed', + ]; + + + my $cat = Cat->new( name => 'Socks', + kittens => ['Monica', 'Kenneth'], + markings => { socks=>1, blaze=>"white" }, + breed => Breed->new(name=>'short-hair', cross=>1), + or: breed => {name=>'short-hair', cross=>1}, + ); + + print "Once a cat called ", $cat->name, "\n"; + print "(which was a ", $cat->breed->name, ")\n"; + print "had two kittens: ", join(' and ', @{$cat->kittens}), "\n"; + +=back + +=head1 Author and Modification History + +Modified by Damian Conway, 2001-09-10, v0.62. + + Modified implicit construction of nested objects. + Now will also take an object ref instead of requiring a hash ref. + Also default initializes nested object attributes to undef, rather + than calling object constructor without args + Original over-helpfulness was fraught with problems: + * the class's constructor might not be called 'new' + * the class might not have a hash-like-arguments constructor + * the class might not have a no-argument constructor + * "recursive" data structures didn't work well: + package Person; + struct { mother => 'Person', father => 'Person'}; + + +Modified by Casey West, 2000-11-08, v0.59. + + Added the ability for compile time class creation. + +Modified by Damian Conway, 1999-03-05, v0.58. + + Added handling of hash-like arg list to class ctor. + + Changed to two-argument blessing in ctor to support + derivation from created classes. + + Added classname prefixes to keys in hash-based classes + (refer to "Perl Cookbook", Recipe 13.12 for rationale). + + Corrected behaviour of accessors for '*@' and '*%' struct + elements. Package now implements documented behaviour when + returning a reference to an entire hash or array element. + Previously these were returned as a reference to a reference + to the element. + +Renamed to C<Class::Struct> and modified by Jim Miner, 1997-04-02. + + members() function removed. + Documentation corrected and extended. + Use of struct() in a subclass prohibited. + User definition of accessor allowed. + Treatment of '*' in element types corrected. + Treatment of classes as element types corrected. + Class name to struct() made optional. + Diagnostic checks added. + +Originally C<Class::Template> by Dean Roehrich. + + # Template.pm --- struct/member template builder + # 12mar95 + # Dean Roehrich + # + # changes/bugs fixed since 28nov94 version: + # - podified + # changes/bugs fixed since 21nov94 version: + # - Fixed examples. + # changes/bugs fixed since 02sep94 version: + # - Moved to Class::Template. + # changes/bugs fixed since 20feb94 version: + # - Updated to be a more proper module. + # - Added "use strict". + # - Bug in build_methods, was using @var when @$var needed. + # - Now using my() rather than local(). + # + # Uses perl5 classes to create nested data types. + # This is offered as one implementation of Tom Christiansen's "structs.pl" + # idea. + +=cut diff --git a/Master/xemtex/perl/lib/Config.pm b/Master/xemtex/perl/lib/Config.pm new file mode 100644 index 00000000000..c5b8bd0be9c --- /dev/null +++ b/Master/xemtex/perl/lib/Config.pm @@ -0,0 +1,8895 @@ +package Config; +use Exporter (); +@EXPORT = qw(%Config); +@EXPORT_OK = qw(myconfig config_sh config_vars); + +# Define our own import method to avoid pulling in the full Exporter: +sub import { + my $pkg = shift; + @_ = @EXPORT unless @_; + my @func = grep {$_ ne '%Config'} @_; + local $Exporter::ExportLevel = 1; + Exporter::import('Config', @func) if @func; + return if @func == @_; + my $callpkg = caller(0); + *{"$callpkg\::Config"} = \%Config; +} + +die "Perl lib version (v5.8.0) doesn't match executable version ($])" + unless $^V; + +$^V eq v5.8.0 + or die "Perl lib version (v5.8.0) doesn't match executable version (" . + (sprintf "v%vd",$^V) . ")"; + +# 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. + +## Configured by: popineau@ANSIBLE +### Target system: WIN32 + +my $config_sh = <<'!END!'; +archlibexp='c:\Local\Perl\lib' +archname='MSWin32-x86-multi-thread' +cc='cl' +ccflags='-nologo -GF -W3 -MD -DNDEBUG -O2xtb2 -G6 -GL -DWIN32 -D_CONSOLE -DNO_STRICT -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -DPERL_MSVCRT_READFIX' +cppflags='-DWIN32' +dlsrc='dl_win32.xs' +dynamic_ext='Storable Encode XS/Typemap B/C IO MIME/Base64 Devel/Peek Opcode Time/HiRes attrs ByteLoader PerlIO/scalar Unicode/Normalize re B XS/APItest Encode/Unicode SDBM_File PerlIO/via PerlIO/encoding Fcntl Sys/Hostname Digest/MD5 Devel/PPPort POSIX Filter/Util/Call Socket threads/shared Data/Dumper List/Util threads File/Glob Devel/DProf Cwd' +extensions='Storable Encode XS/Typemap B/C IO MIME/Base64 Devel/Peek Opcode Time/HiRes attrs ByteLoader PerlIO/scalar Unicode/Normalize re B XS/APItest Encode/Unicode SDBM_File PerlIO/via PerlIO/encoding Fcntl Sys/Hostname Digest/MD5 Devel/PPPort POSIX Filter/Util/Call Socket threads/shared Data/Dumper List/Util threads File/Glob Devel/DProf Cwd' +installarchlib='c:\Local\Perl\lib' +installprivlib='c:\Local\Perl\lib' +libpth='..\..\texk\msvc\lib' +libs=' oldnames.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib netapi32.lib uuid.lib wsock32.lib mpr.lib winmm.lib version.lib odbc32.lib odbccp32.lib msvcrt.lib' +osname='MSWin32' +osvers='4.0' +prefix='c:\Local\Perl' +privlibexp='c:\Local\Perl\lib' +sharpbang='#!' +shsharp='true' +sig_name='ZERO HUP INT QUIT ILL NUM05 NUM06 NUM07 FPE KILL NUM10 SEGV NUM12 PIPE ALRM TERM NUM16 NUM17 NUM18 NUM19 CHLD BREAK ABRT STOP NUM24 CONT CLD' +sig_num='0 1 2 21 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 20 0' +so='dll' +startsh='#!/bin/sh' +static_ext=' ' +Author='' +Date='$Date' +Header='' +Id='$Id' +Locker='' +Log='$Log' +PERL_API_REVISION='5' +PERL_API_SUBVERSION='0' +PERL_API_VERSION='8' +PERL_CONFIG_SH='true' +PERL_PATCHLEVEL='8' +PERL_REVISION='5' +PERL_SUBVERSION='0' +PERL_VERSION='8' +RCSfile='$RCSfile' +Revision='$Revision' +Source='' +State='' +_a='.lib' +_exe='.exe' +_o='.obj' +afs='false' +afsroot='/afs' +alignbytes='8' +ansi2knr='' +aphostname='' +api_revision='5' +api_subversion='0' +api_version='8' +api_versionstring='5.8.0' +ar='lib' +archlib='c:\Local\Perl\lib' +archname64='' +archobjs='' +asctime_r_proto='0' +awk='awk' +baserev='5' +bash='' +bin='c:\Local\Perl\bin' +binexp='c:\Local\Perl\bin' +bison='' +byacc='byacc' +byteorder='1234' +c='' +castflags='0' +cat='type' +cccdlflags=' ' +ccdlflags=' ' +ccflags_uselargefiles='' +ccname='' +ccsymbols='' +ccversion='' +cf_by='popineau' +cf_email='popineau@ANSIBLE' +cf_time='Mon Aug 18 21:40:53 2003' +charsize='1' +chgrp='' +chmod='' +chown='' +clocktype='clock_t' +comm='' +compress='' +contains='grep' +cp='copy' +cpio='' +cpp='cl -nologo -E' +cpp_stuff='42' +cppccsymbols='' +cpplast='' +cppminus='' +cpprun='cl -nologo -E' +cppstdin='cppstdin' +cppsymbols='' +crypt_r_proto='0' +cryptlib='' +csh='undef' +ctermid_r_proto='0' +ctime_r_proto='0' +d_Gconvert='sprintf((b),"%.*g",(n),(x))' +d_PRIEUldbl='undef' +d_PRIFUldbl='undef' +d_PRIGUldbl='undef' +d_PRIXU64='undef' +d_PRId64='undef' +d_PRIeldbl='undef' +d_PRIfldbl='undef' +d_PRIgldbl='undef' +d_PRIi64='undef' +d_PRIo64='undef' +d_PRIu64='undef' +d_PRIx64='undef' +d_SCNfldbl='undef' +d__fwalk='undef' +d_access='define' +d_accessx='undef' +d_alarm='define' +d_archlib='define' +d_asctime_r='undef' +d_atolf='undef' +d_atoll='undef' +d_attribut='undef' +d_bcmp='undef' +d_bcopy='undef' +d_bsd='define' +d_bsdgetpgrp='undef' +d_bsdsetpgrp='undef' +d_bzero='undef' +d_casti32='undef' +d_castneg='define' +d_charvspr='undef' +d_chown='undef' +d_chroot='undef' +d_chsize='define' +d_class='undef' +d_closedir='define' +d_cmsghdr_s='undef' +d_const='define' +d_crypt='undef' +d_crypt_r='undef' +d_csh='undef' +d_ctermid_r='undef' +d_ctime_r='undef' +d_cuserid='undef' +d_dbl_dig='define' +d_dbminitproto='undef' +d_difftime='define' +d_dirfd='undef' +d_dirnamlen='define' +d_dlerror='define' +d_dlopen='define' +d_dlsymun='undef' +d_dosuid='undef' +d_drand48_r='undef' +d_drand48proto='undef' +d_dup2='define' +d_eaccess='undef' +d_endgrent='undef' +d_endgrent_r='undef' +d_endhent='undef' +d_endhostent_r='undef' +d_endnent='undef' +d_endnetent_r='undef' +d_endpent='undef' +d_endprotoent_r='undef' +d_endpwent='undef' +d_endpwent_r='undef' +d_endsent='undef' +d_endservent_r='undef' +d_eofnblk='define' +d_eunice='undef' +d_fchdir='undef' +d_fchmod='undef' +d_fchown='undef' +d_fcntl='undef' +d_fcntl_can_lock='undef' +d_fd_macros='define' +d_fd_set='define' +d_fds_bits='define' +d_fgetpos='define' +d_finite='undef' +d_finitel='undef' +d_flexfnam='define' +d_flock='define' +d_flockproto='define' +d_fork='undef' +d_fp_class='undef' +d_fpathconf='undef' +d_fpclass='undef' +d_fpclassify='undef' +d_fpclassl='undef' +d_fpos64_t='undef' +d_frexpl='undef' +d_fs_data_s='undef' +d_fseeko='undef' +d_fsetpos='define' +d_fstatfs='undef' +d_fstatvfs='undef' +d_fsync='undef' +d_ftello='undef' +d_ftime='define' +d_getcwd='define' +d_getespwnam='undef' +d_getfsstat='undef' +d_getgrent='undef' +d_getgrent_r='undef' +d_getgrgid_r='undef' +d_getgrnam_r='undef' +d_getgrps='undef' +d_gethbyaddr='define' +d_gethbyname='define' +d_gethent='undef' +d_gethname='define' +d_gethostbyaddr_r='undef' +d_gethostbyname_r='undef' +d_gethostent_r='undef' +d_gethostprotos='define' +d_getitimer='undef' +d_getlogin='define' +d_getlogin_r='undef' +d_getmnt='undef' +d_getmntent='undef' +d_getnbyaddr='undef' +d_getnbyname='undef' +d_getnent='undef' +d_getnetbyaddr_r='undef' +d_getnetbyname_r='undef' +d_getnetent_r='undef' +d_getnetprotos='undef' +d_getpagsz='undef' +d_getpbyname='define' +d_getpbynumber='define' +d_getpent='undef' +d_getpgid='undef' +d_getpgrp2='undef' +d_getpgrp='undef' +d_getppid='undef' +d_getprior='undef' +d_getprotobyname_r='undef' +d_getprotobynumber_r='undef' +d_getprotoent_r='undef' +d_getprotoprotos='define' +d_getprpwnam='undef' +d_getpwent='undef' +d_getpwent_r='undef' +d_getpwnam_r='undef' +d_getpwuid_r='undef' +d_getsbyname='define' +d_getsbyport='define' +d_getsent='undef' +d_getservbyname_r='undef' +d_getservbyport_r='undef' +d_getservent_r='undef' +d_getservprotos='define' +d_getspnam='undef' +d_getspnam_r='undef' +d_gettimeod='define' +d_gmtime_r='undef' +d_gnulibc='undef' +d_grpasswd='undef' +d_hasmntopt='undef' +d_htonl='define' +d_index='undef' +d_inetaton='undef' +d_int64_t='undef' +d_isascii='define' +d_isfinite='undef' +d_isinf='undef' +d_isnan='define' +d_isnanl='undef' +d_killpg='undef' +d_lchown='undef' +d_ldbl_dig='define' +d_link='define' +d_localtime_r='undef' +d_locconv='define' +d_lockf='undef' +d_longdbl='define' +d_longlong='undef' +d_lseekproto='define' +d_lstat='undef' +d_madvise='undef' +d_mblen='define' +d_mbstowcs='define' +d_mbtowc='define' +d_memchr='define' +d_memcmp='define' +d_memcpy='define' +d_memmove='define' +d_memset='define' +d_mkdir='define' +d_mkdtemp='undef' +d_mkfifo='undef' +d_mkstemp='undef' +d_mkstemps='undef' +d_mktime='define' +d_mmap='undef' +d_modfl='undef' +d_modfl_pow32_bug='undef' +d_mprotect='undef' +d_msg='undef' +d_msg_ctrunc='undef' +d_msg_dontroute='undef' +d_msg_oob='undef' +d_msg_peek='undef' +d_msg_proxy='undef' +d_msgctl='undef' +d_msgget='undef' +d_msghdr_s='undef' +d_msgrcv='undef' +d_msgsnd='undef' +d_msync='undef' +d_munmap='undef' +d_mymalloc='undef' +d_nice='undef' +d_nl_langinfo='undef' +d_nv_preserves_uv='define' +d_off64_t='undef' +d_old_pthread_create_joinable='undef' +d_oldpthreads='undef' +d_oldsock='undef' +d_open3='undef' +d_pathconf='undef' +d_pause='define' +d_perl_otherlibdirs='undef' +d_phostname='undef' +d_pipe='define' +d_poll='undef' +d_portable='define' +d_procselfexe='undef' +d_pthread_atfork='undef' +d_pthread_yield='undef' +d_pwage='undef' +d_pwchange='undef' +d_pwclass='undef' +d_pwcomment='undef' +d_pwexpire='undef' +d_pwgecos='undef' +d_pwpasswd='undef' +d_pwquota='undef' +d_qgcvt='undef' +d_quad='undef' +d_random_r='undef' +d_readdir64_r='undef' +d_readdir='define' +d_readdir_r='undef' +d_readlink='undef' +d_readv='undef' +d_recvmsg='undef' +d_rename='define' +d_rewinddir='define' +d_rmdir='define' +d_safebcpy='undef' +d_safemcpy='undef' +d_sanemcmp='define' +d_sbrkproto='undef' +d_sched_yield='undef' +d_scm_rights='undef' +d_seekdir='define' +d_select='define' +d_sem='undef' +d_semctl='undef' +d_semctl_semid_ds='undef' +d_semctl_semun='undef' +d_semget='undef' +d_semop='undef' +d_sendmsg='undef' +d_setegid='undef' +d_seteuid='undef' +d_setgrent='undef' +d_setgrent_r='undef' +d_setgrps='undef' +d_sethent='undef' +d_sethostent_r='undef' +d_setitimer='undef' +d_setlinebuf='undef' +d_setlocale='define' +d_setlocale_r='undef' +d_setnent='undef' +d_setnetent_r='undef' +d_setpent='undef' +d_setpgid='undef' +d_setpgrp2='undef' +d_setpgrp='undef' +d_setprior='undef' +d_setproctitle='undef' +d_setprotoent_r='undef' +d_setpwent='undef' +d_setpwent_r='undef' +d_setregid='undef' +d_setresgid='undef' +d_setresuid='undef' +d_setreuid='undef' +d_setrgid='undef' +d_setruid='undef' +d_setsent='undef' +d_setservent_r='undef' +d_setsid='undef' +d_setvbuf='define' +d_sfio='undef' +d_shm='undef' +d_shmat='undef' +d_shmatprototype='undef' +d_shmctl='undef' +d_shmdt='undef' +d_shmget='undef' +d_sigaction='undef' +d_sigprocmask='undef' +d_sigsetjmp='undef' +d_sockatmark='undef' +d_sockatmarkproto='undef' +d_socket='define' +d_socklen_t='undef' +d_sockpair='undef' +d_socks5_init='undef' +d_sqrtl='undef' +d_srand48_r='undef' +d_srandom_r='undef' +d_sresgproto='undef' +d_sresuproto='undef' +d_statblks='undef' +d_statfs_f_flags='undef' +d_statfs_s='undef' +d_statvfs='undef' +d_stdio_cnt_lval='define' +d_stdio_ptr_lval='define' +d_stdio_ptr_lval_nochange_cnt='define' +d_stdio_ptr_lval_sets_cnt='undef' +d_stdio_stream_array='undef' +d_stdiobase='define' +d_stdstdio='define' +d_strchr='define' +d_strcoll='define' +d_strctcpy='define' +d_strerrm='strerror(e)' +d_strerror='define' +d_strerror_r='undef' +d_strftime='define' +d_strtod='define' +d_strtol='define' +d_strtold='undef' +d_strtoll='undef' +d_strtoq='undef' +d_strtoul='define' +d_strtoull='undef' +d_strtouq='undef' +d_strxfrm='define' +d_suidsafe='undef' +d_symlink='undef' +d_syscall='undef' +d_syscallproto='undef' +d_sysconf='undef' +d_sysernlst='' +d_syserrlst='define' +d_system='define' +d_tcgetpgrp='undef' +d_tcsetpgrp='undef' +d_telldir='define' +d_telldirproto='define' +d_time='define' +d_times='define' +d_tm_tm_gmtoff='undef' +d_tm_tm_zone='undef' +d_tmpnam_r='undef' +d_truncate='undef' +d_ttyname_r='undef' +d_tzname='define' +d_u32align='define' +d_ualarm='undef' +d_umask='define' +d_uname='define' +d_union_semun='define' +d_unordered='undef' +d_usleep='undef' +d_usleepproto='undef' +d_ustat='undef' +d_vendorarch='undef' +d_vendorbin='undef' +d_vendorlib='undef' +d_vfork='undef' +d_void_closedir='undef' +d_voidsig='define' +d_voidtty='' +d_volatile='define' +d_vprintf='define' +d_wait4='undef' +d_waitpid='define' +d_wcstombs='define' +d_wctomb='define' +d_writev='undef' +d_xenix='undef' +date='date' +db_hashtype='int' +db_prefixtype='int' +db_version_major='0' +db_version_minor='0' +db_version_patch='0' +defvoidused='15' +direntrytype='struct direct' +dlext='dll' +doublesize='8' +drand01='(rand()/(double)((unsigned)1<<RANDBITS))' +drand48_r_proto='0' +eagain='EAGAIN' +ebcdic='undef' +echo='echo' +egrep='egrep' +emacs='' +endgrent_r_proto='0' +endhostent_r_proto='0' +endnetent_r_proto='0' +endprotoent_r_proto='0' +endpwent_r_proto='0' +endservent_r_proto='0' +eunicefix=':' +exe_ext='.exe' +expr='expr' +extras='' +fflushNULL='define' +fflushall='undef' +find='find' +firstmakefile='makefile' +flex='' +fpossize='8' +fpostype='fpos_t' +freetype='void' +full_ar='' +full_csh='' +full_sed='' +gccosandvers='' +gccversion='' +getgrent_r_proto='0' +getgrgid_r_proto='0' +getgrnam_r_proto='0' +gethostbyaddr_r_proto='0' +gethostbyname_r_proto='0' +gethostent_r_proto='0' +getlogin_r_proto='0' +getnetbyaddr_r_proto='0' +getnetbyname_r_proto='0' +getnetent_r_proto='0' +getprotobyname_r_proto='0' +getprotobynumber_r_proto='0' +getprotoent_r_proto='0' +getpwent_r_proto='0' +getpwnam_r_proto='0' +getpwuid_r_proto='0' +getservbyname_r_proto='0' +getservbyport_r_proto='0' +getservent_r_proto='0' +getspnam_r_proto='0' +gidformat='"ld"' +gidsign='-1' +gidsize='4' +gidtype='gid_t' +glibpth='/usr/shlib /lib/pa1.1 /usr/lib/large /lib /usr/lib /usr/lib/386 /lib/386 /lib/large /usr/lib/small /lib/small /usr/ccs/lib /usr/ucblib /usr/shlib ' +gmake='gmake' +gmtime_r_proto='0' +grep='grep' +groupcat='' +groupstype='gid_t' +gzip='gzip' +h_fcntl='false' +h_sysfile='true' +hint='recommended' +hostcat='ypcat hosts' +i16size='2' +i16type='short' +i32size='4' +i32type='long' +i64size='8' +i64type='__int64' +i8size='1' +i8type='char' +i_arpainet='define' +i_bsdioctl='' +i_crypt='undef' +i_db='undef' +i_dbm='undef' +i_dirent='define' +i_dld='undef' +i_dlfcn='define' +i_fcntl='define' +i_float='define' +i_fp='undef' +i_fp_class='undef' +i_gdbm='undef' +i_grp='undef' +i_ieeefp='undef' +i_inttypes='undef' +i_langinfo='undef' +i_libutil='undef' +i_limits='define' +i_locale='define' +i_machcthr='undef' +i_malloc='define' +i_math='define' +i_memory='undef' +i_mntent='undef' +i_ndbm='undef' +i_netdb='undef' +i_neterrno='undef' +i_netinettcp='undef' +i_niin='undef' +i_poll='undef' +i_prot='undef' +i_pthread='undef' +i_pwd='undef' +i_rpcsvcdbm='define' +i_sfio='undef' +i_sgtty='undef' +i_shadow='undef' +i_socks='undef' +i_stdarg='define' +i_stddef='define' +i_stdlib='define' +i_string='define' +i_sunmath='undef' +i_sysaccess='undef' +i_sysdir='undef' +i_sysfile='undef' +i_sysfilio='define' +i_sysin='undef' +i_sysioctl='undef' +i_syslog='undef' +i_sysmman='undef' +i_sysmode='undef' +i_sysmount='undef' +i_sysndir='undef' +i_sysparam='undef' +i_sysresrc='undef' +i_syssecrt='undef' +i_sysselct='undef' +i_syssockio='undef' +i_sysstat='define' +i_sysstatfs='undef' +i_sysstatvfs='undef' +i_systime='undef' +i_systimek='undef' +i_systimes='undef' +i_systypes='define' +i_sysuio='undef' +i_sysun='undef' +i_sysutsname='undef' +i_sysvfs='undef' +i_syswait='undef' +i_termio='undef' +i_termios='undef' +i_time='define' +i_unistd='undef' +i_ustat='undef' +i_utime='define' +i_values='undef' +i_varargs='undef' +i_varhdr='varargs.h' +i_vfork='undef' +ignore_versioned_solibs='' +inc_version_list='' +inc_version_list_init='0' +incpath='..\..\texk\msvc\include' +inews='' +installbin='c:\Local\Perl\bin' +installhtmldir='c:\Local\Perl\html' +installhtmlhelpdir='c:\Local\Perl\htmlhelp' +installman1dir='c:\Local\Perl\man\man1' +installman3dir='c:\Local\Perl\man\man3' +installprefix='c:\Local\Perl' +installprefixexp='c:\Local\Perl' +installscript='c:\Local\Perl\bin' +installsitearch='c:\Local\Perl\site\lib' +installsitebin='c:\Local\Perl\bin' +installsitelib='c:\Local\Perl\site\lib' +installstyle='lib' +installusrbinperl='undef' +installvendorarch='' +installvendorbin='' +installvendorlib='' +intsize='4' +issymlink='' +ivdformat='"ld"' +ivsize='4' +ivtype='long' +known_extensions='B B/C ByteLoader Cwd Data/Dumper Devel/DProf Devel/PPPort Devel/Peek Digest/MD5 Encode Encode/Byte Encode/CN Encode/EBCDIC Encode/JP Encode/KR Encode/Symbol Encode/TW Encode/Unicode Errno Fcntl File/Glob Filter/Util/Call IO List/Util MIME/Base64 Opcode POSIX PerlIO/encoding PerlIO/scalar PerlIO/via SDBM_File Socket Storable Sys/Hostname Thread Time/HiRes Unicode/Normalize XS/APItest XS/Typemap attrs re threads threads/shared' +ksh='' +ld='link' +lddlflags='-dll -nologo -nodefaultlib -release -LTCG -libpath:"c:\Local\Perl\lib\CORE" -machine:x86' +ldflags='-nologo -nodefaultlib -release -LTCG -libpath:"c:\Local\Perl\lib\CORE" -machine:x86' +ldflags_uselargefiles='' +ldlibpthname='' +less='less' +lib_ext='.lib' +libc='msvcrt.lib' +libperl='perl58.lib' +libsdirs='' +libsfiles='' +libsfound='' +libspath='' +libswanted='net socket inet nsl nm ndbm gdbm dbm db malloc dl dld ld sun m c cposix posix ndir dir crypt ucb bsd BSD PW x' +line='line' +lint='' +lkflags='' +ln='' +lns='copy' +localtime_r_proto='0' +locincpth='/usr/local/include /opt/local/include /usr/gnu/include /opt/gnu/include /usr/GNU/include /opt/GNU/include' +loclibpth='/usr/local/lib /opt/local/lib /usr/gnu/lib /opt/gnu/lib /usr/GNU/lib /opt/GNU/lib' +longdblsize='10' +longlongsize='8' +longsize='4' +lp='' +lpr='' +ls='dir' +lseeksize='4' +lseektype='off_t' +mail='' +mailx='' +make='nmake' +make_set_make='#' +mallocobj='malloc.o' +mallocsrc='malloc.c' +malloctype='void *' +man1dir='c:\Local\Perl\man\man1' +man1direxp='c:\Local\Perl\man\man1' +man1ext='1' +man3dir='c:\Local\Perl\man\man3' +man3direxp='c:\Local\Perl\man\man3' +man3ext='3' +mips_type='' +mkdir='mkdir' +mmaptype='void *' +modetype='mode_t' +more='more /e' +multiarch='undef' +mv='' +myarchname='MSWin32' +mydomain='' +myhostname='' +myuname='' +n='-n' +need_va_copy='undef' +netdb_hlen_type='int' +netdb_host_type='char *' +netdb_name_type='char *' +netdb_net_type='long' +nm='' +nm_opt='' +nm_so_opt='' +nonxs_ext='Encode/TW Encode/Byte Errno Encode/KR Encode/EBCDIC Encode/JP Encode/Symbol Encode/CN' +nroff='' +nvEUformat='"E"' +nvFUformat='"F"' +nvGUformat='"G"' +nv_preserves_uv_bits='32' +nveformat='"e"' +nvfformat='"f"' +nvgformat='"g"' +nvsize='8' +nvtype='double' +o_nonblock='O_NONBLOCK' +obj_ext='.obj' +old_pthread_create_joinable='' +optimize='-MD -DNDEBUG -O2xtb2 -G6 -GL' +orderlib='false' +otherlibdirs='' +package='perl5' +pager='more /e' +passcat='' +patchlevel='' +path_sep=';' +perl5='' +perl='perl' +perladmin='' +perllibs=' oldnames.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib netapi32.lib uuid.lib wsock32.lib mpr.lib winmm.lib version.lib odbc32.lib odbccp32.lib msvcrt.lib' +perlpath='c:\Local\Perl\bin\perl.exe' +pg='' +phostname='hostname' +pidtype='int' +plibpth='' +pm_apiversion='5.005' +pmake='' +pr='' +prefixexp='c:' +privlib='c:\Local\Perl\lib' +procselfexe='' +prototype='define' +ptrsize='4' +quadkind='5' +quadtype='__int64' +randbits='15' +randfunc='rand' +random_r_proto='0' +randseedtype='unsigned' +ranlib='rem' +rd_nodata='-1' +readdir64_r_proto='0' +readdir_r_proto='0' +revision='5' +rm='del' +rmail='' +runnm='true' +sPRIEUldbl='"E"' +sPRIFUldbl='"F"' +sPRIGUldbl='"G"' +sPRIXU64='"lX"' +sPRId64='"ld"' +sPRIeldbl='"e"' +sPRIfldbl='"f"' +sPRIgldbl='"g"' +sPRIi64='"li"' +sPRIo64='"lo"' +sPRIu64='"lu"' +sPRIx64='"lx"' +sSCNfldbl='"f"' +sched_yield='' +scriptdir='c:\Local\Perl\bin' +scriptdirexp='c:\Local\Perl\bin' +sed='sed' +seedfunc='srand' +selectminbits='32' +selecttype='Perl_fd_set *' +sendmail='blat' +setgrent_r_proto='0' +sethostent_r_proto='0' +setlocale_r_proto='0' +setnetent_r_proto='0' +setprotoent_r_proto='0' +setpwent_r_proto='0' +setservent_r_proto='0' +sh='cmd /x /c' +shar='' +shmattype='void *' +shortsize='2' +shrpenv='' +sig_count='26' +sig_name_init='"ZERO", "HUP", "INT", "QUIT", "ILL", "NUM05", "NUM06", "NUM07", "FPE", "KILL", "NUM10", "SEGV", "NUM12", "PIPE", "ALRM", "TERM", "NUM16", "NUM17", "NUM18", "NUM19", "CHLD", "BREAK", "ABRT", "STOP", "NUM24", "CONT", "CLD", 0' +sig_num_init='0, 1, 2, 21, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 20, 0' +sig_size='27' +signal_t='void' +sitearch='c:\Local\Perl\site\lib' +sitearchexp='c:\Local\Perl\site\lib' +sitebin='c:\Local\Perl\site\bin' +sitebinexp='c:\Local\Perl\site\bin' +sitelib='c:\Local\Perl\site\lib' +sitelib_stem='' +sitelibexp='c:\Local\Perl\site\lib' +siteprefix='c:\Local\Perl\site' +siteprefixexp='c:\Local\Perl\site' +sizesize='4' +sizetype='size_t' +sleep='' +smail='' +sockethdr='' +socketlib='' +socksizetype='int' +sort='sort' +spackage='Perl5' +spitshell='' +srand48_r_proto='0' +srandom_r_proto='0' +src='' +ssizetype='int' +startperl='#!perl' +stdchar='char' +stdio_base='((fp)->_base)' +stdio_bufsiz='((fp)->_cnt + (fp)->_ptr - (fp)->_base)' +stdio_cnt='((fp)->_cnt)' +stdio_filbuf='' +stdio_ptr='((fp)->_ptr)' +stdio_stream_array='' +strerror_r_proto='0' +strings='/usr/include/string.h' +submit='' +subversion='' +sysman='/usr/man/man1' +tail='' +tar='' +targetarch='' +tbl='' +tee='' +test='' +timeincl='/usr/include/sys/time.h ' +timetype='time_t' +tmpnam_r_proto='0' +touch='touch' +tr='' +trnl='\012' +troff='' +ttyname_r_proto='0' +u16size='2' +u16type='unsigned short' +u32size='4' +u32type='unsigned long' +u64size='8' +u64type='unsigned __int64' +u8size='1' +u8type='unsigned char' +uidformat='"ld"' +uidsign='-1' +uidsize='4' +uidtype='uid_t' +uname='uname' +uniq='uniq' +uquadtype='unsigned __int64' +use5005threads='undef' +use64bitall='undef' +use64bitint='undef' +usecrosscompile='undef' +usedl='define' +useithreads='define' +uselargefiles='undef' +uselongdouble='undef' +usemorebits='undef' +usemultiplicity='define' +usemymalloc='n' +usenm='false' +useopcode='true' +useperlio='define' +useposix='true' +usereentrant='undef' +usesfio='false' +useshrplib='yes' +usesocks='undef' +usethreads='undef' +usevendorprefix='undef' +usevfork='false' +usrinc='/usr/include' +uuname='' +uvXUformat='"lX"' +uvoformat='"lo"' +uvsize='4' +uvtype='unsigned long' +uvuformat='"lu"' +uvxformat='"lx"' +vendorarch='' +vendorarchexp='' +vendorbin='' +vendorbinexp='' +vendorlib='' +vendorlib_stem='' +vendorlibexp='' +vendorprefix='' +vendorprefixexp='' +version='5.8.0' +version_patchlevel_string='version 8 subversion 0' +versiononly='undef' +vi='' +voidflags='15' +xlibpth='/usr/lib/386 /lib/386' +xs_apiversion='5.6.0' +zcat='' +zip='zip' +!END! + +my $summary = <<'!END!'; +Summary of my $package (revision $baserev $version_patchlevel_string) configuration: + Platform: + osname=$osname, osvers=$osvers, archname=$archname + uname='$myuname' + config_args='$config_args' + hint=$hint, useposix=$useposix, d_sigaction=$d_sigaction + usethreads=$usethreads use5005threads=$use5005threads useithreads=$useithreads usemultiplicity=$usemultiplicity + useperlio=$useperlio d_sfio=$d_sfio uselargefiles=$uselargefiles usesocks=$usesocks + use64bitint=$use64bitint use64bitall=$use64bitall uselongdouble=$uselongdouble + usemymalloc=$usemymalloc, bincompat5005=undef + Compiler: + cc='$cc', ccflags ='$ccflags', + optimize='$optimize', + cppflags='$cppflags' + ccversion='$ccversion', gccversion='$gccversion', gccosandvers='$gccosandvers' + intsize=$intsize, longsize=$longsize, ptrsize=$ptrsize, doublesize=$doublesize, byteorder=$byteorder + d_longlong=$d_longlong, longlongsize=$longlongsize, d_longdbl=$d_longdbl, longdblsize=$longdblsize + ivtype='$ivtype', ivsize=$ivsize, nvtype='$nvtype', nvsize=$nvsize, Off_t='$lseektype', lseeksize=$lseeksize + alignbytes=$alignbytes, prototype=$prototype + Linker and Libraries: + ld='$ld', ldflags ='$ldflags' + libpth=$libpth + libs=$libs + perllibs=$perllibs + libc=$libc, so=$so, useshrplib=$useshrplib, libperl=$libperl + gnulibc_version='$gnulibc_version' + Dynamic Linking: + dlsrc=$dlsrc, dlext=$dlext, d_dlsymun=$d_dlsymun, ccdlflags='$ccdlflags' + cccdlflags='$cccdlflags', lddlflags='$lddlflags' + +!END! +my $summary_expanded = 0; + +sub myconfig { + return $summary if $summary_expanded; + $summary =~ s{\$(\w+)} + { my $c = $Config{$1}; defined($c) ? $c : 'undef' }ge; + $summary_expanded = 1; + $summary; +} + +sub FETCH { + # check for cached value (which may be undef so we use exists not defined) + return $_[0]->{$_[1]} if (exists $_[0]->{$_[1]}); + + # Search for it in the big string + my($value, $start, $marker, $quote_type); + + $quote_type = "'"; + # Virtual entries. + if ($_[1] eq 'byteorder') { + # byteorder does exist on its own but we overlay a virtual + # dynamically recomputed value. + my $t = $Config{ivtype}; + my $s = $Config{ivsize}; + my $f = $t eq 'long' ? 'L!' : $s == 8 ? 'Q': 'I'; + if ($s == 4 || $s == 8) { + my $i = 0; + foreach my $c (reverse(2..$s)) { $i |= ord($c); $i <<= 8 } + $i |= ord(1); + $value = join('', unpack('a'x$s, pack($f, $i))); + } else { + $value = '?'x$s; + } + } elsif ($_[1] =~ /^((?:cc|ld)flags|libs(?:wanted)?)_nolargefiles/) { + # These are purely virtual, they do not exist, but need to + # be computed on demand for largefile-incapable extensions. + my $key = "${1}_uselargefiles"; + $value = $Config{$1}; + my $withlargefiles = $Config{$key}; + if ($key =~ /^(?:cc|ld)flags_/) { + $value =~ s/\Q$withlargefiles\E\b//; + } elsif ($key =~ /^libs/) { + my @lflibswanted = split(' ', $Config{libswanted_uselargefiles}); + if (@lflibswanted) { + my %lflibswanted; + @lflibswanted{@lflibswanted} = (); + if ($key =~ /^libs_/) { + my @libs = grep { /^-l(.+)/ && + not exists $lflibswanted{$1} } + split(' ', $Config{libs}); + $Config{libs} = join(' ', @libs); + } elsif ($key =~ /^libswanted_/) { + my @libswanted = grep { not exists $lflibswanted{$_} } + split(' ', $Config{libswanted}); + $Config{libswanted} = join(' ', @libswanted); + } + } + } + } else { + $marker = "$_[1]="; + # return undef unless (($value) = $config_sh =~ m/^$_[1]='(.*)'\s*$/m); + # Check for the common case, ' delimeted + $start = index($config_sh, "\n$marker$quote_type"); + # If that failed, check for " delimited + if ($start == -1) { + $quote_type = '"'; + $start = index($config_sh, "\n$marker$quote_type"); + } + return undef if ( ($start == -1) && # in case it's first + (substr($config_sh, 0, length($marker)) ne $marker) ); + if ($start == -1) { + # It's the very first thing we found. Skip $start forward + # and figure out the quote mark after the =. + $start = length($marker) + 1; + $quote_type = substr($config_sh, $start - 1, 1); + } + else { + $start += length($marker) + 2; + } + $value = substr($config_sh, $start, + index($config_sh, "$quote_type\n", $start) - $start); + } + # If we had a double-quote, we'd better eval it so escape + # sequences and such can be interpolated. Since the incoming + # value is supposed to follow shell rules and not perl rules, + # we escape any perl variable markers + if ($quote_type eq '"') { + $value =~ s/\$/\\\$/g; + $value =~ s/\@/\\\@/g; + eval "\$value = \"$value\""; + } + #$value = sprintf($value) if $quote_type eq '"'; + # So we can say "if $Config{'foo'}". + $value = undef if $value eq 'undef'; + $_[0]->{$_[1]} = $value; # cache it + return $value; +} + +my $prevpos = 0; + +sub FIRSTKEY { + $prevpos = 0; + # my($key) = $config_sh =~ m/^(.*?)=/; + substr($config_sh, 0, index($config_sh, '=') ); + # $key; +} + +sub NEXTKEY { + # Find out how the current key's quoted so we can skip to its end. + my $quote = substr($config_sh, index($config_sh, "=", $prevpos)+1, 1); + my $pos = index($config_sh, qq($quote\n), $prevpos) + 2; + my $len = index($config_sh, "=", $pos) - $pos; + $prevpos = $pos; + $len > 0 ? substr($config_sh, $pos, $len) : undef; +} + +sub EXISTS { + # exists($_[0]->{$_[1]}) or $config_sh =~ m/^$_[1]=/m; + exists($_[0]->{$_[1]}) or + index($config_sh, "\n$_[1]='") != -1 or + substr($config_sh, 0, length($_[1])+2) eq "$_[1]='" or + index($config_sh, "\n$_[1]=\"") != -1 or + substr($config_sh, 0, length($_[1])+2) eq "$_[1]=\"" or + $_[1] =~ /^(?:(?:cc|ld)flags|libs(?:wanted)?)_nolargefiles$/; +} + +sub STORE { die "\%Config::Config is read-only\n" } +sub DELETE { &STORE } +sub CLEAR { &STORE } + + +sub config_sh { + $config_sh +} + +sub config_re { + my $re = shift; + my @matches = grep /^$re=/, split /^/, $config_sh; + @matches ? (print @matches) : print "$re: not found\n"; +} + +sub config_vars { + foreach(@_){ + config_re($_), next if /\W/; + my $v=(exists $Config{$_}) ? $Config{$_} : 'UNKNOWN'; + $v='undef' unless defined $v; + print "$_='$v';\n"; + } +} + +sub TIEHASH { bless {} } + +# avoid Config..Exporter..UNIVERSAL search for DESTROY then AUTOLOAD +sub DESTROY { } + +tie %Config, 'Config'; + +1; +__END__ + +=head1 NAME + +Config - access Perl configuration information + +=head1 SYNOPSIS + + use Config; + if ($Config{'cc'} =~ /gcc/) { + print "built by gcc\n"; + } + + use Config qw(myconfig config_sh config_vars); + + print myconfig(); + + print config_sh(); + + config_vars(qw(osname archname)); + + +=head1 DESCRIPTION + +The Config module contains all the information that was available to +the C<Configure> program at Perl build time (over 900 values). + +Shell variables from the F<config.sh> file (written by Configure) are +stored in the readonly-variable C<%Config>, indexed by their names. + +Values stored in config.sh as 'undef' are returned as undefined +values. The perl C<exists> function can be used to check if a +named variable exists. + +=over 4 + +=item myconfig() + +Returns a textual summary of the major perl configuration values. +See also C<-V> in L<perlrun/Switches>. + +=item config_sh() + +Returns the entire perl configuration information in the form of the +original config.sh shell variable assignment script. + +=item config_vars(@names) + +Prints to STDOUT the values of the named configuration variable. Each is +printed on a separate line in the form: + + name='value'; + +Names which are unknown are output as C<name='UNKNOWN';>. +See also C<-V:name> in L<perlrun/Switches>. + +=back + +=head1 EXAMPLE + +Here's a more sophisticated example of using %Config: + + use Config; + use strict; + + my %sig_num; + my @sig_name; + unless($Config{sig_name} && $Config{sig_num}) { + die "No sigs?"; + } else { + my @names = split ' ', $Config{sig_name}; + @sig_num{@names} = split ' ', $Config{sig_num}; + foreach (@names) { + $sig_name[$sig_num{$_}] ||= $_; + } + } + + print "signal #17 = $sig_name[17]\n"; + if ($sig_num{ALRM}) { + print "SIGALRM is $sig_num{ALRM}\n"; + } + +=head1 WARNING + +Because this information is not stored within the perl executable +itself it is possible (but unlikely) that the information does not +relate to the actual perl binary which is being used to access it. + +The Config module is installed into the architecture and version +specific library directory ($Config{installarchlib}) and it checks the +perl version number when loaded. + +The values stored in config.sh may be either single-quoted or +double-quoted. Double-quoted strings are handy for those cases where you +need to include escape sequences in the strings. To avoid runtime variable +interpolation, any C<$> and C<@> characters are replaced by C<\$> and +C<\@>, respectively. This isn't foolproof, of course, so don't embed C<\$> +or C<\@> in double-quoted strings unless you're willing to deal with the +consequences. (The slashes will end up escaped and the C<$> or C<@> will +trigger variable interpolation) + +=head1 GLOSSARY + +Most C<Config> variables are determined by the C<Configure> script +on platforms supported by it (which is most UNIX platforms). Some +platforms have custom-made C<Config> variables, and may thus not have +some of the variables described below, or may have extraneous variables +specific to that particular port. See the port specific documentation +in such cases. + +=head2 _ + +=over 4 + +=item C<_a> + +From F<Unix.U>: + +This variable defines the extension used for ordinary library files. +For unix, it is F<.a>. The F<.> is included. Other possible +values include F<.lib>. + +=item C<_exe> + +From F<Unix.U>: + +This variable defines the extension used for executable files. +C<DJGPP>, Cygwin and F<OS/2> use F<.exe>. Stratus C<VOS> uses F<.pm>. +On operating systems which do not require a specific extension +for executable files, this variable is empty. + +=item C<_o> + +From F<Unix.U>: + +This variable defines the extension used for object files. +For unix, it is F<.o>. The F<.> is included. Other possible +values include F<.obj>. + +=back + +=head2 a + +=over 4 + +=item C<afs> + +From F<afs.U>: + +This variable is set to C<true> if C<AFS> (Andrew File System) is used +on the system, C<false> otherwise. It is possible to override this +with a hint value or command line option, but you'd better know +what you are doing. + +=item C<afsroot> + +From F<afs.U>: + +This variable is by default set to F</afs>. In the unlikely case +this is not the correct root, it is possible to override this with +a hint value or command line option. This will be used in subsequent +tests for AFSness in the Perl configure and test process. + +=item C<alignbytes> + +From F<alignbytes.U>: + +This variable holds the number of bytes required to align a +double-- or a long double when applicable. Usual values are +2, 4 and 8. The default is eight, for safety. + +=item C<ansi2knr> + +From F<ansi2knr.U>: + +This variable is set if the user needs to run ansi2knr. +Currently, this is not supported, so we just abort. + +=item C<aphostname> + +From F<d_gethname.U>: + +This variable contains the command which can be used to compute the +host name. The command is fully qualified by its absolute path, to make +it safe when used by a process with super-user privileges. + +=item C<api_revision> + +From F<patchlevel.U>: + +The three variables, api_revision, api_version, and +api_subversion, specify the version of the oldest perl binary +compatible with the present perl. In a full version string +such as F<5.6.1>, api_revision is the C<5>. +Prior to 5.5.640, the format was a floating point number, +like 5.00563. + +F<perl.c>:incpush() and F<lib/lib.pm> will automatically search in +F<$sitelib/.>. for older directories back to the limit specified +by these api_ variables. This is only useful if you have a +perl library directory tree structured like the default one. +See C<INSTALL> for how this works. The versioned site_perl +directory was introduced in 5.005, so that is the lowest +possible value. The version list appropriate for the current +system is determined in F<inc_version_list.U>. + +C<XXX> To do: Since compatibility can depend on compile time +options (such as bincompat, longlong, etc.) it should +(perhaps) be set by Configure, but currently it isn't. +Currently, we read a hard-wired value from F<patchlevel.h>. +Perhaps what we ought to do is take the hard-wired value from +F<patchlevel.h> but then modify it if the current Configure +options warrant. F<patchlevel.h> then would use an #ifdef guard. + +=item C<api_subversion> + +From F<patchlevel.U>: + +The three variables, api_revision, api_version, and +api_subversion, specify the version of the oldest perl binary +compatible with the present perl. In a full version string +such as F<5.6.1>, api_subversion is the C<1>. See api_revision for +full details. + +=item C<api_version> + +From F<patchlevel.U>: + +The three variables, api_revision, api_version, and +api_subversion, specify the version of the oldest perl binary +compatible with the present perl. In a full version string +such as F<5.6.1>, api_version is the C<6>. See api_revision for +full details. As a special case, 5.5.0 is rendered in the +old-style as 5.005. (In the 5.005_0x maintenance series, +this was the only versioned directory in $sitelib.) + +=item C<api_versionstring> + +From F<patchlevel.U>: + +This variable combines api_revision, api_version, and +api_subversion in a format such as 5.6.1 (or 5_6_1) suitable +for use as a directory name. This is filesystem dependent. + +=item C<ar> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the ar program. After Configure runs, +the value is reset to a plain C<ar> and is not useful. + +=item C<archlib> + +From F<archlib.U>: + +This variable holds the name of the directory in which the user wants +to put architecture-dependent public library files for $package. +It is most often a local directory such as F</usr/local/lib>. +Programs using this variable must be prepared to deal +with filename expansion. + +=item C<archlibexp> + +From F<archlib.U>: + +This variable is the same as the archlib variable, but is +filename expanded at configuration time, for convenient use. + +=item C<archname64> + +From F<use64bits.U>: + +This variable is used for the 64-bitness part of $archname. + +=item C<archname> + +From F<archname.U>: + +This variable is a short name to characterize the current +architecture. It is used mainly to construct the default archlib. + +=item C<archobjs> + +From F<Unix.U>: + +This variable defines any additional objects that must be linked +in with the program on this architecture. On unix, it is usually +empty. It is typically used to include emulations of unix calls +or other facilities. For perl on F<OS/2>, for example, this would +include F<os2/os2.obj>. + +=item C<asctime_r_proto> + +From F<d_asctime_r.U>: + +This variable encodes the prototype of asctime_r. +It is zero if d_asctime_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_asctime_r +is defined. + +=item C<awk> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the awk program. After Configure runs, +the value is reset to a plain C<awk> and is not useful. + +=back + +=head2 b + +=over 4 + +=item C<baserev> + +From F<baserev.U>: + +The base revision level of this package, from the F<.package> file. + +=item C<bash> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<bin> + +From F<bin.U>: + +This variable holds the name of the directory in which the user wants +to put publicly executable images for the package in question. It +is most often a local directory such as F</usr/local/bin>. Programs using +this variable must be prepared to deal with F<~name> substitution. + +=item C<binexp> + +From F<bin.U>: + +This is the same as the bin variable, but is filename expanded at +configuration time, for use in your makefiles. + +=item C<bison> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the bison program. After Configure runs, +the value is reset to a plain C<bison> and is not useful. + +=item C<byacc> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the byacc program. After Configure runs, +the value is reset to a plain C<byacc> and is not useful. + +=item C<byteorder> + +From F<byteorder.U>: + +This variable holds the byte order in a C<UV>. In the following, +larger digits indicate more significance. The variable byteorder +is either 4321 on a big-endian machine, or 1234 on a little-endian, +or 87654321 on a Cray ... or 3412 with weird order ! + +=back + +=head2 c + +=over 4 + +=item C<c> + +From F<n.U>: + +This variable contains the \c string if that is what causes the echo +command to suppress newline. Otherwise it is null. Correct usage is +$echo $n "prompt for a question: $c". + +=item C<castflags> + +From F<d_castneg.U>: + +This variable contains a flag that precise difficulties the +compiler has casting odd floating values to unsigned long: +0 = ok +1 = couldn't cast < 0 +2 = couldn't cast >= 0x80000000 +4 = couldn't cast in argument expression list + +=item C<cat> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the cat program. After Configure runs, +the value is reset to a plain C<cat> and is not useful. + +=item C<cc> + +From F<cc.U>: + +This variable holds the name of a command to execute a C compiler which +can resolve multiple global references that happen to have the same +name. Usual values are C<cc> and C<gcc>. +Fervent C<ANSI> compilers may be called C<c89>. C<AIX> has xlc. + +=item C<cccdlflags> + +From F<dlsrc.U>: + +This variable contains any special flags that might need to be +passed with C<cc -c> to compile modules to be used to create a shared +library that will be used for dynamic loading. For hpux, this +should be +z. It is up to the makefile to use it. + +=item C<ccdlflags> + +From F<dlsrc.U>: + +This variable contains any special flags that might need to be +passed to cc to link with a shared library for dynamic loading. +It is up to the makefile to use it. For sunos 4.1, it should +be empty. + +=item C<ccflags> + +From F<ccflags.U>: + +This variable contains any additional C compiler flags desired by +the user. It is up to the Makefile to use this. + +=item C<ccflags_uselargefiles> + +From F<uselfs.U>: + +This variable contains the compiler flags needed by large file builds +and added to ccflags by hints files. + +=item C<ccname> + +From F<Checkcc.U>: + +This can set either by hints files or by Configure. If using +gcc, this is gcc, and if not, usually equal to cc, unimpressive, no? +Some platforms, however, make good use of this by storing the +flavor of the C compiler being used here. For example if using +the Sun WorkShop suite, ccname will be C<workshop>. + +=item C<ccsymbols> + +From F<Cppsym.U>: + +The variable contains the symbols defined by the C compiler alone. +The symbols defined by cpp or by cc when it calls cpp are not in +this list, see cppsymbols and cppccsymbols. +The list is a space-separated list of symbol=value tokens. + +=item C<ccversion> + +From F<Checkcc.U>: + +This can set either by hints files or by Configure. If using +a (non-gcc) vendor cc, this variable may contain a version for +the compiler. + +=item C<cf_by> + +From F<cf_who.U>: + +Login name of the person who ran the Configure script and answered the +questions. This is used to tag both F<config.sh> and F<config_h.SH>. + +=item C<cf_email> + +From F<cf_email.U>: + +Electronic mail address of the person who ran Configure. This can be +used by units that require the user's e-mail, like F<MailList.U>. + +=item C<cf_time> + +From F<cf_who.U>: + +Holds the output of the C<date> command when the configuration file was +produced. This is used to tag both F<config.sh> and F<config_h.SH>. + +=item C<charsize> + +From F<charsize.U>: + +This variable contains the value of the C<CHARSIZE> symbol, which +indicates to the C program how many bytes there are in a character. + +=item C<chgrp> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<chmod> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the chmod program. After Configure runs, +the value is reset to a plain C<chmod> and is not useful. + +=item C<chown> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<clocktype> + +From F<d_times.U>: + +This variable holds the type returned by times(). It can be long, +or clock_t on C<BSD> sites (in which case <sys/types.h> should be +included). + +=item C<comm> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the comm program. After Configure runs, +the value is reset to a plain C<comm> and is not useful. + +=item C<compress> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<contains> + +From F<contains.U>: + +This variable holds the command to do a grep with a proper return +status. On most sane systems it is simply C<grep>. On insane systems +it is a grep followed by a cat followed by a test. This variable +is primarily for the use of other Configure units. + +=item C<cp> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the cp program. After Configure runs, +the value is reset to a plain C<cp> and is not useful. + +=item C<cpio> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<cpp> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the cpp program. After Configure runs, +the value is reset to a plain C<cpp> and is not useful. + +=item C<cpp_stuff> + +From F<cpp_stuff.U>: + +This variable contains an identification of the catenation mechanism +used by the C preprocessor. + +=item C<cppccsymbols> + +From F<Cppsym.U>: + +The variable contains the symbols defined by the C compiler +when it calls cpp. The symbols defined by the cc alone or cpp +alone are not in this list, see ccsymbols and cppsymbols. +The list is a space-separated list of symbol=value tokens. + +=item C<cppflags> + +From F<ccflags.U>: + +This variable holds the flags that will be passed to the C pre- +processor. It is up to the Makefile to use it. + +=item C<cpplast> + +From F<cppstdin.U>: + +This variable has the same functionality as cppminus, only it applies +to cpprun and not cppstdin. + +=item C<cppminus> + +From F<cppstdin.U>: + +This variable contains the second part of the string which will invoke +the C preprocessor on the standard input and produce to standard +output. This variable will have the value C<-> if cppstdin needs +a minus to specify standard input, otherwise the value is "". + +=item C<cpprun> + +From F<cppstdin.U>: + +This variable contains the command which will invoke a C preprocessor +on standard input and put the output to stdout. It is guaranteed not +to be a wrapper and may be a null string if no preprocessor can be +made directly available. This preprocessor might be different from the +one used by the C compiler. Don't forget to append cpplast after the +preprocessor options. + +=item C<cppstdin> + +From F<cppstdin.U>: + +This variable contains the command which will invoke the C +preprocessor on standard input and put the output to stdout. +It is primarily used by other Configure units that ask about +preprocessor symbols. + +=item C<cppsymbols> + +From F<Cppsym.U>: + +The variable contains the symbols defined by the C preprocessor +alone. The symbols defined by cc or by cc when it calls cpp are +not in this list, see ccsymbols and cppccsymbols. +The list is a space-separated list of symbol=value tokens. + +=item C<crypt_r_proto> + +From F<d_crypt_r.U>: + +This variable encodes the prototype of crypt_r. +It is zero if d_crypt_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_crypt_r +is defined. + +=item C<cryptlib> + +From F<d_crypt.U>: + +This variable holds -lcrypt or the path to a F<libcrypt.a> archive if +the crypt() function is not defined in the standard C library. It is +up to the Makefile to use this. + +=item C<csh> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the csh program. After Configure runs, +the value is reset to a plain C<csh> and is not useful. + +=item C<ctermid_r_proto> + +From F<d_ctermid_r.U>: + +This variable encodes the prototype of ctermid_r. +It is zero if d_ctermid_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_ctermid_r +is defined. + +=item C<ctime_r_proto> + +From F<d_ctime_r.U>: + +This variable encodes the prototype of ctime_r. +It is zero if d_ctime_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_ctime_r +is defined. + +=back + +=head2 d + +=over 4 + +=item C<d__fwalk> + +From F<d__fwalk.U>: + +This variable conditionally defines C<HAS__FWALK> if _fwalk() is +available to apply a function to all the file handles. + +=item C<d_access> + +From F<d_access.U>: + +This variable conditionally defines C<HAS_ACCESS> if the access() system +call is available to check for access permissions using real IDs. + +=item C<d_accessx> + +From F<d_accessx.U>: + +This variable conditionally defines the C<HAS_ACCESSX> symbol, which +indicates to the C program that the accessx() routine is available. + +=item C<d_alarm> + +From F<d_alarm.U>: + +This variable conditionally defines the C<HAS_ALARM> symbol, which +indicates to the C program that the alarm() routine is available. + +=item C<d_archlib> + +From F<archlib.U>: + +This variable conditionally defines C<ARCHLIB> to hold the pathname +of architecture-dependent library files for $package. If +$archlib is the same as $privlib, then this is set to undef. + +=item C<d_asctime_r> + +From F<d_asctime_r.U>: + +This variable conditionally defines the C<HAS_ASCTIME_R> symbol, +which indicates to the C program that the asctime_r() +routine is available. + +=item C<d_atolf> + +From F<atolf.U>: + +This variable conditionally defines the C<HAS_ATOLF> symbol, which +indicates to the C program that the atolf() routine is available. + +=item C<d_atoll> + +From F<atoll.U>: + +This variable conditionally defines the C<HAS_ATOLL> symbol, which +indicates to the C program that the atoll() routine is available. + +=item C<d_attribut> + +From F<d_attribut.U>: + +This variable conditionally defines C<HASATTRIBUTE>, which +indicates the C compiler can check for function attributes, +such as printf formats. + +=item C<d_bcmp> + +From F<d_bcmp.U>: + +This variable conditionally defines the C<HAS_BCMP> symbol if +the bcmp() routine is available to compare strings. + +=item C<d_bcopy> + +From F<d_bcopy.U>: + +This variable conditionally defines the C<HAS_BCOPY> symbol if +the bcopy() routine is available to copy strings. + +=item C<d_bsd> + +From F<Guess.U>: + +This symbol conditionally defines the symbol C<BSD> when running on a +C<BSD> system. + +=item C<d_bsdgetpgrp> + +From F<d_getpgrp.U>: + +This variable conditionally defines C<USE_BSD_GETPGRP> if +getpgrp needs one arguments whereas C<USG> one needs none. + +=item C<d_bsdsetpgrp> + +From F<d_setpgrp.U>: + +This variable conditionally defines C<USE_BSD_SETPGRP> if +setpgrp needs two arguments whereas C<USG> one needs none. +See also d_setpgid for a C<POSIX> interface. + +=item C<d_bzero> + +From F<d_bzero.U>: + +This variable conditionally defines the C<HAS_BZERO> symbol if +the bzero() routine is available to set memory to 0. + +=item C<d_casti32> + +From F<d_casti32.U>: + +This variable conditionally defines CASTI32, which indicates +whether the C compiler can cast large floats to 32-bit ints. + +=item C<d_castneg> + +From F<d_castneg.U>: + +This variable conditionally defines C<CASTNEG>, which indicates +wether the C compiler can cast negative float to unsigned. + +=item C<d_charvspr> + +From F<d_vprintf.U>: + +This variable conditionally defines C<CHARVSPRINTF> if this system +has vsprintf returning type (char*). The trend seems to be to +declare it as "int vsprintf()". + +=item C<d_chown> + +From F<d_chown.U>: + +This variable conditionally defines the C<HAS_CHOWN> symbol, which +indicates to the C program that the chown() routine is available. + +=item C<d_chroot> + +From F<d_chroot.U>: + +This variable conditionally defines the C<HAS_CHROOT> symbol, which +indicates to the C program that the chroot() routine is available. + +=item C<d_chsize> + +From F<d_chsize.U>: + +This variable conditionally defines the C<CHSIZE> symbol, which +indicates to the C program that the chsize() routine is available +to truncate files. You might need a -lx to get this routine. + +=item C<d_class> + +From F<d_class.U>: + +This variable conditionally defines the C<HAS_CLASS> symbol, which +indicates to the C program that the class() routine is available. + +=item C<d_closedir> + +From F<d_closedir.U>: + +This variable conditionally defines C<HAS_CLOSEDIR> if closedir() is +available. + +=item C<d_cmsghdr_s> + +From F<d_cmsghdr_s.U>: + +This variable conditionally defines the C<HAS_STRUCT_CMSGHDR> symbol, +which indicates that the struct cmsghdr is supported. + +=item C<d_const> + +From F<d_const.U>: + +This variable conditionally defines the C<HASCONST> symbol, which +indicates to the C program that this C compiler knows about the +const type. + +=item C<d_crypt> + +From F<d_crypt.U>: + +This variable conditionally defines the C<CRYPT> symbol, which +indicates to the C program that the crypt() routine is available +to encrypt passwords and the like. + +=item C<d_crypt_r> + +From F<d_crypt_r.U>: + +This variable conditionally defines the C<HAS_CRYPT_R> symbol, +which indicates to the C program that the crypt_r() +routine is available. + +=item C<d_csh> + +From F<d_csh.U>: + +This variable conditionally defines the C<CSH> symbol, which +indicates to the C program that the C-shell exists. + +=item C<d_ctermid_r> + +From F<d_ctermid_r.U>: + +This variable conditionally defines the C<HAS_CTERMID_R> symbol, +which indicates to the C program that the ctermid_r() +routine is available. + +=item C<d_ctime_r> + +From F<d_ctime_r.U>: + +This variable conditionally defines the C<HAS_CTIME_R> symbol, +which indicates to the C program that the ctime_r() +routine is available. + +=item C<d_cuserid> + +From F<d_cuserid.U>: + +This variable conditionally defines the C<HAS_CUSERID> symbol, which +indicates to the C program that the cuserid() routine is available +to get character login names. + +=item C<d_dbl_dig> + +From F<d_dbl_dig.U>: + +This variable conditionally defines d_dbl_dig if this system's +header files provide C<DBL_DIG>, which is the number of significant +digits in a double precision number. + +=item C<d_dbminitproto> + +From F<d_dbminitproto.U>: + +This variable conditionally defines the C<HAS_DBMINIT_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the dbminit() function. Otherwise, it is +up to the program to supply one. + +=item C<d_difftime> + +From F<d_difftime.U>: + +This variable conditionally defines the C<HAS_DIFFTIME> symbol, which +indicates to the C program that the difftime() routine is available. + +=item C<d_dirfd> + +From F<d_dirfd.U>: + +This variable conditionally defines the C<HAS_DIRFD> constant, +which indicates to the C program that dirfd() is available +to return the file descriptor of a directory stream. + +=item C<d_dirnamlen> + +From F<i_dirent.U>: + +This variable conditionally defines C<DIRNAMLEN>, which indicates +to the C program that the length of directory entry names is +provided by a d_namelen field. + +=item C<d_dlerror> + +From F<d_dlerror.U>: + +This variable conditionally defines the C<HAS_DLERROR> symbol, which +indicates to the C program that the dlerror() routine is available. + +=item C<d_dlopen> + +From F<d_dlopen.U>: + +This variable conditionally defines the C<HAS_DLOPEN> symbol, which +indicates to the C program that the dlopen() routine is available. + +=item C<d_dlsymun> + +From F<d_dlsymun.U>: + +This variable conditionally defines C<DLSYM_NEEDS_UNDERSCORE>, which +indicates that we need to prepend an underscore to the symbol +name before calling dlsym(). + +=item C<d_dosuid> + +From F<d_dosuid.U>: + +This variable conditionally defines the symbol C<DOSUID>, which +tells the C program that it should insert setuid emulation code +on hosts which have setuid #! scripts disabled. + +=item C<d_drand48_r> + +From F<d_drand48_r.U>: + +This variable conditionally defines the HAS_DRAND48_R symbol, +which indicates to the C program that the drand48_r() +routine is available. + +=item C<d_drand48proto> + +From F<d_drand48proto.U>: + +This variable conditionally defines the HAS_DRAND48_PROTO symbol, +which indicates to the C program that the system provides +a prototype for the drand48() function. Otherwise, it is +up to the program to supply one. + +=item C<d_dup2> + +From F<d_dup2.U>: + +This variable conditionally defines HAS_DUP2 if dup2() is +available to duplicate file descriptors. + +=item C<d_eaccess> + +From F<d_eaccess.U>: + +This variable conditionally defines the C<HAS_EACCESS> symbol, which +indicates to the C program that the eaccess() routine is available. + +=item C<d_endgrent> + +From F<d_endgrent.U>: + +This variable conditionally defines the C<HAS_ENDGRENT> symbol, which +indicates to the C program that the endgrent() routine is available +for sequential access of the group database. + +=item C<d_endgrent_r> + +From F<d_endgrent_r.U>: + +This variable conditionally defines the C<HAS_ENDGRENT_R> symbol, +which indicates to the C program that the endgrent_r() +routine is available. + +=item C<d_endhent> + +From F<d_endhent.U>: + +This variable conditionally defines C<HAS_ENDHOSTENT> if endhostent() is +available to close whatever was being used for host queries. + +=item C<d_endhostent_r> + +From F<d_endhostent_r.U>: + +This variable conditionally defines the C<HAS_ENDHOSTENT_R> symbol, +which indicates to the C program that the endhostent_r() +routine is available. + +=item C<d_endnent> + +From F<d_endnent.U>: + +This variable conditionally defines C<HAS_ENDNETENT> if endnetent() is +available to close whatever was being used for network queries. + +=item C<d_endnetent_r> + +From F<d_endnetent_r.U>: + +This variable conditionally defines the C<HAS_ENDNETENT_R> symbol, +which indicates to the C program that the endnetent_r() +routine is available. + +=item C<d_endpent> + +From F<d_endpent.U>: + +This variable conditionally defines C<HAS_ENDPROTOENT> if endprotoent() is +available to close whatever was being used for protocol queries. + +=item C<d_endprotoent_r> + +From F<d_endprotoent_r.U>: + +This variable conditionally defines the C<HAS_ENDPROTOENT_R> symbol, +which indicates to the C program that the endprotoent_r() +routine is available. + +=item C<d_endpwent> + +From F<d_endpwent.U>: + +This variable conditionally defines the C<HAS_ENDPWENT> symbol, which +indicates to the C program that the endpwent() routine is available +for sequential access of the passwd database. + +=item C<d_endpwent_r> + +From F<d_endpwent_r.U>: + +This variable conditionally defines the C<HAS_ENDPWENT_R> symbol, +which indicates to the C program that the endpwent_r() +routine is available. + +=item C<d_endsent> + +From F<d_endsent.U>: + +This variable conditionally defines C<HAS_ENDSERVENT> if endservent() is +available to close whatever was being used for service queries. + +=item C<d_endservent_r> + +From F<d_endservent_r.U>: + +This variable conditionally defines the C<HAS_ENDSERVENT_R> symbol, +which indicates to the C program that the endservent_r() +routine is available. + +=item C<d_eofnblk> + +From F<nblock_io.U>: + +This variable conditionally defines C<EOF_NONBLOCK> if C<EOF> can be seen +when reading from a non-blocking I/O source. + +=item C<d_eunice> + +From F<Guess.U>: + +This variable conditionally defines the symbols C<EUNICE> and C<VAX>, which +alerts the C program that it must deal with ideosyncracies of C<VMS>. + +=item C<d_fchdir> + +From F<d_fchdir.U>: + +This variable conditionally defines the C<HAS_FCHDIR> symbol, which +indicates to the C program that the fchdir() routine is available. + +=item C<d_fchmod> + +From F<d_fchmod.U>: + +This variable conditionally defines the C<HAS_FCHMOD> symbol, which +indicates to the C program that the fchmod() routine is available +to change mode of opened files. + +=item C<d_fchown> + +From F<d_fchown.U>: + +This variable conditionally defines the C<HAS_FCHOWN> symbol, which +indicates to the C program that the fchown() routine is available +to change ownership of opened files. + +=item C<d_fcntl> + +From F<d_fcntl.U>: + +This variable conditionally defines the C<HAS_FCNTL> symbol, and indicates +whether the fcntl() function exists + +=item C<d_fcntl_can_lock> + +From F<d_fcntl_can_lock.U>: + +This variable conditionally defines the C<FCNTL_CAN_LOCK> symbol +and indicates whether file locking with fcntl() works. + +=item C<d_fd_macros> + +From F<d_fd_set.U>: + +This variable contains the eventual value of the C<HAS_FD_MACROS> symbol, +which indicates if your C compiler knows about the macros which +manipulate an fd_set. + +=item C<d_fd_set> + +From F<d_fd_set.U>: + +This variable contains the eventual value of the C<HAS_FD_SET> symbol, +which indicates if your C compiler knows about the fd_set typedef. + +=item C<d_fds_bits> + +From F<d_fd_set.U>: + +This variable contains the eventual value of the C<HAS_FDS_BITS> symbol, +which indicates if your fd_set typedef contains the fds_bits member. +If you have an fd_set typedef, but the dweebs who installed it did +a half-fast job and neglected to provide the macros to manipulate +an fd_set, C<HAS_FDS_BITS> will let us know how to fix the gaffe. + +=item C<d_fgetpos> + +From F<d_fgetpos.U>: + +This variable conditionally defines C<HAS_FGETPOS> if fgetpos() is +available to get the file position indicator. + +=item C<d_finite> + +From F<d_finite.U>: + +This variable conditionally defines the C<HAS_FINITE> symbol, which +indicates to the C program that the finite() routine is available. + +=item C<d_finitel> + +From F<d_finitel.U>: + +This variable conditionally defines the C<HAS_FINITEL> symbol, which +indicates to the C program that the finitel() routine is available. + +=item C<d_flexfnam> + +From F<d_flexfnam.U>: + +This variable conditionally defines the C<FLEXFILENAMES> symbol, which +indicates that the system supports filenames longer than 14 characters. + +=item C<d_flock> + +From F<d_flock.U>: + +This variable conditionally defines C<HAS_FLOCK> if flock() is +available to do file locking. + +=item C<d_flockproto> + +From F<d_flockproto.U>: + +This variable conditionally defines the C<HAS_FLOCK_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the flock() function. Otherwise, it is +up to the program to supply one. + +=item C<d_fork> + +From F<d_fork.U>: + +This variable conditionally defines the C<HAS_FORK> symbol, which +indicates to the C program that the fork() routine is available. + +=item C<d_fp_class> + +From F<d_fp_class.U>: + +This variable conditionally defines the C<HAS_FP_CLASS> symbol, which +indicates to the C program that the fp_class() routine is available. + +=item C<d_fpathconf> + +From F<d_pathconf.U>: + +This variable conditionally defines the C<HAS_FPATHCONF> symbol, which +indicates to the C program that the pathconf() routine is available +to determine file-system related limits and options associated +with a given open file descriptor. + +=item C<d_fpclass> + +From F<d_fpclass.U>: + +This variable conditionally defines the C<HAS_FPCLASS> symbol, which +indicates to the C program that the fpclass() routine is available. + +=item C<d_fpclassify> + +From F<d_fpclassify.U>: + +This variable conditionally defines the C<HAS_FPCLASSIFY> symbol, which +indicates to the C program that the fpclassify() routine is available. + +=item C<d_fpclassl> + +From F<d_fpclassl.U>: + +This variable conditionally defines the C<HAS_FPCLASSL> symbol, which +indicates to the C program that the fpclassl() routine is available. + +=item C<d_fpos64_t> + +From F<d_fpos64_t.U>: + +This symbol will be defined if the C compiler supports fpos64_t. + +=item C<d_frexpl> + +From F<d_frexpl.U>: + +This variable conditionally defines the C<HAS_FREXPL> symbol, which +indicates to the C program that the frexpl() routine is available. + +=item C<d_fs_data_s> + +From F<d_fs_data_s.U>: + +This variable conditionally defines the C<HAS_STRUCT_FS_DATA> symbol, +which indicates that the struct fs_data is supported. + +=item C<d_fseeko> + +From F<d_fseeko.U>: + +This variable conditionally defines the C<HAS_FSEEKO> symbol, which +indicates to the C program that the fseeko() routine is available. + +=item C<d_fsetpos> + +From F<d_fsetpos.U>: + +This variable conditionally defines C<HAS_FSETPOS> if fsetpos() is +available to set the file position indicator. + +=item C<d_fstatfs> + +From F<d_fstatfs.U>: + +This variable conditionally defines the C<HAS_FSTATFS> symbol, which +indicates to the C program that the fstatfs() routine is available. + +=item C<d_fstatvfs> + +From F<d_statvfs.U>: + +This variable conditionally defines the C<HAS_FSTATVFS> symbol, which +indicates to the C program that the fstatvfs() routine is available. + +=item C<d_fsync> + +From F<d_fsync.U>: + +This variable conditionally defines the C<HAS_FSYNC> symbol, which +indicates to the C program that the fsync() routine is available. + +=item C<d_ftello> + +From F<d_ftello.U>: + +This variable conditionally defines the C<HAS_FTELLO> symbol, which +indicates to the C program that the ftello() routine is available. + +=item C<d_ftime> + +From F<d_ftime.U>: + +This variable conditionally defines the C<HAS_FTIME> symbol, which indicates +that the ftime() routine exists. The ftime() routine is basically +a sub-second accuracy clock. + +=item C<d_Gconvert> + +From F<d_gconvert.U>: + +This variable holds what Gconvert is defined as to convert +floating point numbers into strings. By default, Configure +sets C<this> macro to use the first of gconvert, gcvt, or sprintf +that pass sprintf-%g-like behaviour tests. If perl is using +long doubles, the macro uses the first of the following +functions that pass Configure's tests: qgcvt, sprintf (if +Configure knows how to make sprintf format long doubles--see +sPRIgldbl), gconvert, gcvt, and sprintf (casting to double). +The gconvert_preference and gconvert_ld_preference variables +can be used to alter Configure's preferences, for doubles and +long doubles, respectively. If present, they contain a +space-separated list of one or more of the above function +names in the order they should be tried. + +d_Gconvert may be set to override Configure with a platform- +specific function. If this function expects a double, a +different value may need to be set by the F<uselongdouble.cbu> +call-back unit so that long doubles can be formatted without +loss of precision. + +=item C<d_getcwd> + +From F<d_getcwd.U>: + +This variable conditionally defines the C<HAS_GETCWD> symbol, which +indicates to the C program that the getcwd() routine is available +to get the current working directory. + +=item C<d_getespwnam> + +From F<d_getespwnam.U>: + +This variable conditionally defines C<HAS_GETESPWNAM> if getespwnam() is +available to retrieve enchanced (shadow) password entries by name. + +=item C<d_getfsstat> + +From F<d_getfsstat.U>: + +This variable conditionally defines the C<HAS_GETFSSTAT> symbol, which +indicates to the C program that the getfsstat() routine is available. + +=item C<d_getgrent> + +From F<d_getgrent.U>: + +This variable conditionally defines the C<HAS_GETGRENT> symbol, which +indicates to the C program that the getgrent() routine is available +for sequential access of the group database. + +=item C<d_getgrent_r> + +From F<d_getgrent_r.U>: + +This variable conditionally defines the C<HAS_GETGRENT_R> symbol, +which indicates to the C program that the getgrent_r() +routine is available. + +=item C<d_getgrgid_r> + +From F<d_getgrgid_r.U>: + +This variable conditionally defines the C<HAS_GETGRGID_R> symbol, +which indicates to the C program that the getgrgid_r() +routine is available. + +=item C<d_getgrnam_r> + +From F<d_getgrnam_r.U>: + +This variable conditionally defines the C<HAS_GETGRNAM_R> symbol, +which indicates to the C program that the getgrnam_r() +routine is available. + +=item C<d_getgrps> + +From F<d_getgrps.U>: + +This variable conditionally defines the C<HAS_GETGROUPS> symbol, which +indicates to the C program that the getgroups() routine is available +to get the list of process groups. + +=item C<d_gethbyaddr> + +From F<d_gethbyad.U>: + +This variable conditionally defines the C<HAS_GETHOSTBYADDR> symbol, which +indicates to the C program that the gethostbyaddr() routine is available +to look up hosts by their C<IP> addresses. + +=item C<d_gethbyname> + +From F<d_gethbynm.U>: + +This variable conditionally defines the C<HAS_GETHOSTBYNAME> symbol, which +indicates to the C program that the gethostbyname() routine is available +to look up host names in some data base or other. + +=item C<d_gethent> + +From F<d_gethent.U>: + +This variable conditionally defines C<HAS_GETHOSTENT> if gethostent() is +available to look up host names in some data base or another. + +=item C<d_gethname> + +From F<d_gethname.U>: + +This variable conditionally defines the C<HAS_GETHOSTNAME> symbol, which +indicates to the C program that the gethostname() routine may be +used to derive the host name. + +=item C<d_gethostbyaddr_r> + +From F<d_gethostbyaddr_r.U>: + +This variable conditionally defines the C<HAS_GETHOSTBYADDR_R> symbol, +which indicates to the C program that the gethostbyaddr_r() +routine is available. + +=item C<d_gethostbyname_r> + +From F<d_gethostbyname_r.U>: + +This variable conditionally defines the C<HAS_GETHOSTBYNAME_R> symbol, +which indicates to the C program that the gethostbyname_r() +routine is available. + +=item C<d_gethostent_r> + +From F<d_gethostent_r.U>: + +This variable conditionally defines the C<HAS_GETHOSTENT_R> symbol, +which indicates to the C program that the gethostent_r() +routine is available. + +=item C<d_gethostprotos> + +From F<d_gethostprotos.U>: + +This variable conditionally defines the C<HAS_GETHOST_PROTOS> symbol, +which indicates to the C program that <netdb.h> supplies +prototypes for the various gethost*() functions. +See also F<netdbtype.U> for probing for various netdb types. + +=item C<d_getitimer> + +From F<d_getitimer.U>: + +This variable conditionally defines the C<HAS_GETITIMER> symbol, which +indicates to the C program that the getitimer() routine is available. + +=item C<d_getlogin> + +From F<d_getlogin.U>: + +This variable conditionally defines the C<HAS_GETLOGIN> symbol, which +indicates to the C program that the getlogin() routine is available +to get the login name. + +=item C<d_getlogin_r> + +From F<d_getlogin_r.U>: + +This variable conditionally defines the C<HAS_GETLOGIN_R> symbol, +which indicates to the C program that the getlogin_r() +routine is available. + +=item C<d_getmnt> + +From F<d_getmnt.U>: + +This variable conditionally defines the C<HAS_GETMNT> symbol, which +indicates to the C program that the getmnt() routine is available +to retrieve one or more mount info blocks by filename. + +=item C<d_getmntent> + +From F<d_getmntent.U>: + +This variable conditionally defines the C<HAS_GETMNTENT> symbol, which +indicates to the C program that the getmntent() routine is available +to iterate through mounted files to get their mount info. + +=item C<d_getnbyaddr> + +From F<d_getnbyad.U>: + +This variable conditionally defines the C<HAS_GETNETBYADDR> symbol, which +indicates to the C program that the getnetbyaddr() routine is available +to look up networks by their C<IP> addresses. + +=item C<d_getnbyname> + +From F<d_getnbynm.U>: + +This variable conditionally defines the C<HAS_GETNETBYNAME> symbol, which +indicates to the C program that the getnetbyname() routine is available +to look up networks by their names. + +=item C<d_getnent> + +From F<d_getnent.U>: + +This variable conditionally defines C<HAS_GETNETENT> if getnetent() is +available to look up network names in some data base or another. + +=item C<d_getnetbyaddr_r> + +From F<d_getnetbyaddr_r.U>: + +This variable conditionally defines the C<HAS_GETNETBYADDR_R> symbol, +which indicates to the C program that the getnetbyaddr_r() +routine is available. + +=item C<d_getnetbyname_r> + +From F<d_getnetbyname_r.U>: + +This variable conditionally defines the C<HAS_GETNETBYNAME_R> symbol, +which indicates to the C program that the getnetbyname_r() +routine is available. + +=item C<d_getnetent_r> + +From F<d_getnetent_r.U>: + +This variable conditionally defines the C<HAS_GETNETENT_R> symbol, +which indicates to the C program that the getnetent_r() +routine is available. + +=item C<d_getnetprotos> + +From F<d_getnetprotos.U>: + +This variable conditionally defines the C<HAS_GETNET_PROTOS> symbol, +which indicates to the C program that <netdb.h> supplies +prototypes for the various getnet*() functions. +See also F<netdbtype.U> for probing for various netdb types. + +=item C<d_getpagsz> + +From F<d_getpagsz.U>: + +This variable conditionally defines C<HAS_GETPAGESIZE> if getpagesize() +is available to get the system page size. + +=item C<d_getpbyname> + +From F<d_getprotby.U>: + +This variable conditionally defines the C<HAS_GETPROTOBYNAME> +symbol, which indicates to the C program that the +getprotobyname() routine is available to look up protocols +by their name. + +=item C<d_getpbynumber> + +From F<d_getprotby.U>: + +This variable conditionally defines the C<HAS_GETPROTOBYNUMBER> +symbol, which indicates to the C program that the +getprotobynumber() routine is available to look up protocols +by their number. + +=item C<d_getpent> + +From F<d_getpent.U>: + +This variable conditionally defines C<HAS_GETPROTOENT> if getprotoent() is +available to look up protocols in some data base or another. + +=item C<d_getpgid> + +From F<d_getpgid.U>: + +This variable conditionally defines the C<HAS_GETPGID> symbol, which +indicates to the C program that the getpgid(pid) function +is available to get the process group id. + +=item C<d_getpgrp2> + +From F<d_getpgrp2.U>: + +This variable conditionally defines the HAS_GETPGRP2 symbol, which +indicates to the C program that the getpgrp2() (as in F<DG/C<UX>>) routine +is available to get the current process group. + +=item C<d_getpgrp> + +From F<d_getpgrp.U>: + +This variable conditionally defines C<HAS_GETPGRP> if getpgrp() is +available to get the current process group. + +=item C<d_getppid> + +From F<d_getppid.U>: + +This variable conditionally defines the C<HAS_GETPPID> symbol, which +indicates to the C program that the getppid() routine is available +to get the parent process C<ID>. + +=item C<d_getprior> + +From F<d_getprior.U>: + +This variable conditionally defines C<HAS_GETPRIORITY> if getpriority() +is available to get a process's priority. + +=item C<d_getprotobyname_r> + +From F<d_getprotobyname_r.U>: + +This variable conditionally defines the C<HAS_GETPROTOBYNAME_R> symbol, +which indicates to the C program that the getprotobyname_r() +routine is available. + +=item C<d_getprotobynumber_r> + +From F<d_getprotobynumber_r.U>: + +This variable conditionally defines the C<HAS_GETPROTOBYNUMBER_R> symbol, +which indicates to the C program that the getprotobynumber_r() +routine is available. + +=item C<d_getprotoent_r> + +From F<d_getprotoent_r.U>: + +This variable conditionally defines the C<HAS_GETPROTOENT_R> symbol, +which indicates to the C program that the getprotoent_r() +routine is available. + +=item C<d_getprotoprotos> + +From F<d_getprotoprotos.U>: + +This variable conditionally defines the C<HAS_GETPROTO_PROTOS> symbol, +which indicates to the C program that <netdb.h> supplies +prototypes for the various getproto*() functions. +See also F<netdbtype.U> for probing for various netdb types. + +=item C<d_getprpwnam> + +From F<d_getprpwnam.U>: + +This variable conditionally defines C<HAS_GETPRPWNAM> if getprpwnam() is +available to retrieve protected (shadow) password entries by name. + +=item C<d_getpwent> + +From F<d_getpwent.U>: + +This variable conditionally defines the C<HAS_GETPWENT> symbol, which +indicates to the C program that the getpwent() routine is available +for sequential access of the passwd database. + +=item C<d_getpwent_r> + +From F<d_getpwent_r.U>: + +This variable conditionally defines the C<HAS_GETPWENT_R> symbol, +which indicates to the C program that the getpwent_r() +routine is available. + +=item C<d_getpwnam_r> + +From F<d_getpwnam_r.U>: + +This variable conditionally defines the C<HAS_GETPWNAM_R> symbol, +which indicates to the C program that the getpwnam_r() +routine is available. + +=item C<d_getpwuid_r> + +From F<d_getpwuid_r.U>: + +This variable conditionally defines the C<HAS_GETPWUID_R> symbol, +which indicates to the C program that the getpwuid_r() +routine is available. + +=item C<d_getsbyname> + +From F<d_getsrvby.U>: + +This variable conditionally defines the C<HAS_GETSERVBYNAME> +symbol, which indicates to the C program that the +getservbyname() routine is available to look up services +by their name. + +=item C<d_getsbyport> + +From F<d_getsrvby.U>: + +This variable conditionally defines the C<HAS_GETSERVBYPORT> +symbol, which indicates to the C program that the +getservbyport() routine is available to look up services +by their port. + +=item C<d_getsent> + +From F<d_getsent.U>: + +This variable conditionally defines C<HAS_GETSERVENT> if getservent() is +available to look up network services in some data base or another. + +=item C<d_getservbyname_r> + +From F<d_getservbyname_r.U>: + +This variable conditionally defines the C<HAS_GETSERVBYNAME_R> symbol, +which indicates to the C program that the getservbyname_r() +routine is available. + +=item C<d_getservbyport_r> + +From F<d_getservbyport_r.U>: + +This variable conditionally defines the C<HAS_GETSERVBYPORT_R> symbol, +which indicates to the C program that the getservbyport_r() +routine is available. + +=item C<d_getservent_r> + +From F<d_getservent_r.U>: + +This variable conditionally defines the C<HAS_GETSERVENT_R> symbol, +which indicates to the C program that the getservent_r() +routine is available. + +=item C<d_getservprotos> + +From F<d_getservprotos.U>: + +This variable conditionally defines the C<HAS_GETSERV_PROTOS> symbol, +which indicates to the C program that <netdb.h> supplies +prototypes for the various getserv*() functions. +See also F<netdbtype.U> for probing for various netdb types. + +=item C<d_getspnam> + +From F<d_getspnam.U>: + +This variable conditionally defines C<HAS_GETSPNAM> if getspnam() is +available to retrieve SysV shadow password entries by name. + +=item C<d_getspnam_r> + +From F<d_getspnam_r.U>: + +This variable conditionally defines the C<HAS_GETSPNAM_R> symbol, +which indicates to the C program that the getspnam_r() +routine is available. + +=item C<d_gettimeod> + +From F<d_ftime.U>: + +This variable conditionally defines the C<HAS_GETTIMEOFDAY> symbol, which +indicates that the gettimeofday() system call exists (to obtain a +sub-second accuracy clock). You should probably include <sys/resource.h>. + +=item C<d_gmtime_r> + +From F<d_gmtime_r.U>: + +This variable conditionally defines the C<HAS_GMTIME_R> symbol, +which indicates to the C program that the gmtime_r() +routine is available. + +=item C<d_gnulibc> + +From F<d_gnulibc.U>: + +Defined if we're dealing with the C<GNU> C Library. + +=item C<d_grpasswd> + +From F<i_grp.U>: + +This variable conditionally defines C<GRPASSWD>, which indicates +that struct group in <grp.h> contains gr_passwd. + +=item C<d_hasmntopt> + +From F<d_hasmntopt.U>: + +This variable conditionally defines the C<HAS_HASMNTOPT> symbol, which +indicates to the C program that the hasmntopt() routine is available +to query the mount options of file systems. + +=item C<d_htonl> + +From F<d_htonl.U>: + +This variable conditionally defines C<HAS_HTONL> if htonl() and its +friends are available to do network order byte swapping. + +=item C<d_index> + +From F<d_strchr.U>: + +This variable conditionally defines C<HAS_INDEX> if index() and +rindex() are available for string searching. + +=item C<d_inetaton> + +From F<d_inetaton.U>: + +This variable conditionally defines the C<HAS_INET_ATON> symbol, which +indicates to the C program that the inet_aton() function is available +to parse C<IP> address C<dotted-quad> strings. + +=item C<d_int64_t> + +From F<d_int64_t.U>: + +This symbol will be defined if the C compiler supports int64_t. + +=item C<d_isascii> + +From F<d_isascii.U>: + +This variable conditionally defines the C<HAS_ISASCII> constant, +which indicates to the C program that isascii() is available. + +=item C<d_isfinite> + +From F<d_isfinite.U>: + +This variable conditionally defines the C<HAS_ISFINITE> symbol, which +indicates to the C program that the isfinite() routine is available. + +=item C<d_isinf> + +From F<d_isinf.U>: + +This variable conditionally defines the C<HAS_ISINF> symbol, which +indicates to the C program that the isinf() routine is available. + +=item C<d_isnan> + +From F<d_isnan.U>: + +This variable conditionally defines the C<HAS_ISNAN> symbol, which +indicates to the C program that the isnan() routine is available. + +=item C<d_isnanl> + +From F<d_isnanl.U>: + +This variable conditionally defines the C<HAS_ISNANL> symbol, which +indicates to the C program that the isnanl() routine is available. + +=item C<d_killpg> + +From F<d_killpg.U>: + +This variable conditionally defines the C<HAS_KILLPG> symbol, which +indicates to the C program that the killpg() routine is available +to kill process groups. + +=item C<d_lchown> + +From F<d_lchown.U>: + +This variable conditionally defines the C<HAS_LCHOWN> symbol, which +indicates to the C program that the lchown() routine is available +to operate on a symbolic link (instead of following the link). + +=item C<d_ldbl_dig> + +From F<d_ldbl_dig.U>: + +This variable conditionally defines d_ldbl_dig if this system's +header files provide C<LDBL_DIG>, which is the number of significant +digits in a long double precision number. + +=item C<d_link> + +From F<d_link.U>: + +This variable conditionally defines C<HAS_LINK> if link() is +available to create hard links. + +=item C<d_localtime_r> + +From F<d_localtime_r.U>: + +This variable conditionally defines the C<HAS_LOCALTIME_R> symbol, +which indicates to the C program that the localtime_r() +routine is available. + +=item C<d_locconv> + +From F<d_locconv.U>: + +This variable conditionally defines C<HAS_LOCALECONV> if localeconv() is +available for numeric and monetary formatting conventions. + +=item C<d_lockf> + +From F<d_lockf.U>: + +This variable conditionally defines C<HAS_LOCKF> if lockf() is +available to do file locking. + +=item C<d_longdbl> + +From F<d_longdbl.U>: + +This variable conditionally defines C<HAS_LONG_DOUBLE> if +the long double type is supported. + +=item C<d_longlong> + +From F<d_longlong.U>: + +This variable conditionally defines C<HAS_LONG_LONG> if +the long long type is supported. + +=item C<d_lseekproto> + +From F<d_lseekproto.U>: + +This variable conditionally defines the C<HAS_LSEEK_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the lseek() function. Otherwise, it is +up to the program to supply one. + +=item C<d_lstat> + +From F<d_lstat.U>: + +This variable conditionally defines C<HAS_LSTAT> if lstat() is +available to do file stats on symbolic links. + +=item C<d_madvise> + +From F<d_madvise.U>: + +This variable conditionally defines C<HAS_MADVISE> if madvise() is +available to map a file into memory. + +=item C<d_mblen> + +From F<d_mblen.U>: + +This variable conditionally defines the C<HAS_MBLEN> symbol, which +indicates to the C program that the mblen() routine is available +to find the number of bytes in a multibye character. + +=item C<d_mbstowcs> + +From F<d_mbstowcs.U>: + +This variable conditionally defines the C<HAS_MBSTOWCS> symbol, which +indicates to the C program that the mbstowcs() routine is available +to convert a multibyte string into a wide character string. + +=item C<d_mbtowc> + +From F<d_mbtowc.U>: + +This variable conditionally defines the C<HAS_MBTOWC> symbol, which +indicates to the C program that the mbtowc() routine is available +to convert multibyte to a wide character. + +=item C<d_memchr> + +From F<d_memchr.U>: + +This variable conditionally defines the C<HAS_MEMCHR> symbol, which +indicates to the C program that the memchr() routine is available +to locate characters within a C string. + +=item C<d_memcmp> + +From F<d_memcmp.U>: + +This variable conditionally defines the C<HAS_MEMCMP> symbol, which +indicates to the C program that the memcmp() routine is available +to compare blocks of memory. + +=item C<d_memcpy> + +From F<d_memcpy.U>: + +This variable conditionally defines the C<HAS_MEMCPY> symbol, which +indicates to the C program that the memcpy() routine is available +to copy blocks of memory. + +=item C<d_memmove> + +From F<d_memmove.U>: + +This variable conditionally defines the C<HAS_MEMMOVE> symbol, which +indicates to the C program that the memmove() routine is available +to copy potentatially overlapping blocks of memory. + +=item C<d_memset> + +From F<d_memset.U>: + +This variable conditionally defines the C<HAS_MEMSET> symbol, which +indicates to the C program that the memset() routine is available +to set blocks of memory. + +=item C<d_mkdir> + +From F<d_mkdir.U>: + +This variable conditionally defines the C<HAS_MKDIR> symbol, which +indicates to the C program that the mkdir() routine is available +to create F<directories.>. + +=item C<d_mkdtemp> + +From F<d_mkdtemp.U>: + +This variable conditionally defines the C<HAS_MKDTEMP> symbol, which +indicates to the C program that the mkdtemp() routine is available +to exclusively create a uniquely named temporary directory. + +=item C<d_mkfifo> + +From F<d_mkfifo.U>: + +This variable conditionally defines the C<HAS_MKFIFO> symbol, which +indicates to the C program that the mkfifo() routine is available. + +=item C<d_mkstemp> + +From F<d_mkstemp.U>: + +This variable conditionally defines the C<HAS_MKSTEMP> symbol, which +indicates to the C program that the mkstemp() routine is available +to exclusively create and open a uniquely named temporary file. + +=item C<d_mkstemps> + +From F<d_mkstemps.U>: + +This variable conditionally defines the C<HAS_MKSTEMPS> symbol, which +indicates to the C program that the mkstemps() routine is available +to exclusively create and open a uniquely named (with a suffix) +temporary file. + +=item C<d_mktime> + +From F<d_mktime.U>: + +This variable conditionally defines the C<HAS_MKTIME> symbol, which +indicates to the C program that the mktime() routine is available. + +=item C<d_mmap> + +From F<d_mmap.U>: + +This variable conditionally defines C<HAS_MMAP> if mmap() is +available to map a file into memory. + +=item C<d_modfl> + +From F<d_modfl.U>: + +This variable conditionally defines the C<HAS_MODFL> symbol, which +indicates to the C program that the modfl() routine is available. + +=item C<d_modfl_pow32_bug> + +From F<d_modfl.U>: + +This variable conditionally defines the HAS_MODFL_POW32_BUG symbol, +which indicates that modfl() is broken for long doubles >= pow(2, 32). +For example from 4294967303.150000 one would get 4294967302.000000 +and 1.150000. The bug has been seen in certain versions of glibc, +release 2.2.2 is known to be okay. + +=item C<d_mprotect> + +From F<d_mprotect.U>: + +This variable conditionally defines C<HAS_MPROTECT> if mprotect() is +available to modify the access protection of a memory mapped file. + +=item C<d_msg> + +From F<d_msg.U>: + +This variable conditionally defines the C<HAS_MSG> symbol, which +indicates that the entire msg*(2) library is present. + +=item C<d_msg_ctrunc> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_MSG_CTRUNC> symbol, +which indicates that the C<MSG_CTRUNC> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_msg_dontroute> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_MSG_DONTROUTE> symbol, +which indicates that the C<MSG_DONTROUTE> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_msg_oob> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_MSG_OOB> symbol, +which indicates that the C<MSG_OOB> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_msg_peek> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_MSG_PEEK> symbol, +which indicates that the C<MSG_PEEK> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_msg_proxy> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_MSG_PROXY> symbol, +which indicates that the C<MSG_PROXY> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_msgctl> + +From F<d_msgctl.U>: + +This variable conditionally defines the C<HAS_MSGCTL> symbol, which +indicates to the C program that the msgctl() routine is available. + +=item C<d_msgget> + +From F<d_msgget.U>: + +This variable conditionally defines the C<HAS_MSGGET> symbol, which +indicates to the C program that the msgget() routine is available. + +=item C<d_msghdr_s> + +From F<d_msghdr_s.U>: + +This variable conditionally defines the C<HAS_STRUCT_MSGHDR> symbol, +which indicates that the struct msghdr is supported. + +=item C<d_msgrcv> + +From F<d_msgrcv.U>: + +This variable conditionally defines the C<HAS_MSGRCV> symbol, which +indicates to the C program that the msgrcv() routine is available. + +=item C<d_msgsnd> + +From F<d_msgsnd.U>: + +This variable conditionally defines the C<HAS_MSGSND> symbol, which +indicates to the C program that the msgsnd() routine is available. + +=item C<d_msync> + +From F<d_msync.U>: + +This variable conditionally defines C<HAS_MSYNC> if msync() is +available to synchronize a mapped file. + +=item C<d_munmap> + +From F<d_munmap.U>: + +This variable conditionally defines C<HAS_MUNMAP> if munmap() is +available to unmap a region mapped by mmap(). + +=item C<d_mymalloc> + +From F<mallocsrc.U>: + +This variable conditionally defines C<MYMALLOC> in case other parts +of the source want to take special action if C<MYMALLOC> is used. +This may include different sorts of profiling or error detection. + +=item C<d_nice> + +From F<d_nice.U>: + +This variable conditionally defines the C<HAS_NICE> symbol, which +indicates to the C program that the nice() routine is available. + +=item C<d_nl_langinfo> + +From F<d_nl_langinfo.U>: + +This variable conditionally defines the C<HAS_NL_LANGINFO> symbol, which +indicates to the C program that the nl_langinfo() routine is available. + +=item C<d_nv_preserves_uv> + +From F<perlxv.U>: + +This variable indicates whether a variable of type nvtype +can preserve all the bits a variable of type uvtype. + +=item C<d_off64_t> + +From F<d_off64_t.U>: + +This symbol will be defined if the C compiler supports off64_t. + +=item C<d_old_pthread_create_joinable> + +From F<d_pthrattrj.U>: + +This variable conditionally defines pthread_create_joinable. +undef if F<pthread.h> defines C<PTHREAD_CREATE_JOINABLE>. + +=item C<d_oldpthreads> + +From F<usethreads.U>: + +This variable conditionally defines the C<OLD_PTHREADS_API> symbol, +and indicates that Perl should be built to use the old +draft C<POSIX> threads C<API>. This is only potentially meaningful if +usethreads is set. + +=item C<d_oldsock> + +From F<d_socket.U>: + +This variable conditionally defines the C<OLDSOCKET> symbol, which +indicates that the C<BSD> socket interface is based on 4.1c and not 4.2. + +=item C<d_open3> + +From F<d_open3.U>: + +This variable conditionally defines the HAS_OPEN3 manifest constant, +which indicates to the C program that the 3 argument version of +the open(2) function is available. + +=item C<d_pathconf> + +From F<d_pathconf.U>: + +This variable conditionally defines the C<HAS_PATHCONF> symbol, which +indicates to the C program that the pathconf() routine is available +to determine file-system related limits and options associated +with a given filename. + +=item C<d_pause> + +From F<d_pause.U>: + +This variable conditionally defines the C<HAS_PAUSE> symbol, which +indicates to the C program that the pause() routine is available +to suspend a process until a signal is received. + +=item C<d_perl_otherlibdirs> + +From F<otherlibdirs.U>: + +This variable conditionally defines C<PERL_OTHERLIBDIRS>, which +contains a colon-separated set of paths for the perl binary to +include in @C<INC>. See also otherlibdirs. + +=item C<d_phostname> + +From F<d_gethname.U>: + +This variable conditionally defines the C<HAS_PHOSTNAME> symbol, which +contains the shell command which, when fed to popen(), may be +used to derive the host name. + +=item C<d_pipe> + +From F<d_pipe.U>: + +This variable conditionally defines the C<HAS_PIPE> symbol, which +indicates to the C program that the pipe() routine is available +to create an inter-process channel. + +=item C<d_poll> + +From F<d_poll.U>: + +This variable conditionally defines the C<HAS_POLL> symbol, which +indicates to the C program that the poll() routine is available +to poll active file descriptors. + +=item C<d_portable> + +From F<d_portable.U>: + +This variable conditionally defines the C<PORTABLE> symbol, which +indicates to the C program that it should not assume that it is +running on the machine it was compiled on. + +=item C<d_PRId64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRId64 symbol, which +indiciates that stdio has a symbol to print 64-bit decimal numbers. + +=item C<d_PRIeldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. + +=item C<d_PRIEUldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. +The C<U> in the name is to separate this from d_PRIeldbl so that even +case-blind systems can see the difference. + +=item C<d_PRIfldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. + +=item C<d_PRIFUldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. +The C<U> in the name is to separate this from d_PRIfldbl so that even +case-blind systems can see the difference. + +=item C<d_PRIgldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. + +=item C<d_PRIGUldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to print long doubles. +The C<U> in the name is to separate this from d_PRIgldbl so that even +case-blind systems can see the difference. + +=item C<d_PRIi64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRIi64 symbol, which +indiciates that stdio has a symbol to print 64-bit decimal numbers. + +=item C<d_PRIo64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRIo64 symbol, which +indiciates that stdio has a symbol to print 64-bit octal numbers. + +=item C<d_PRIu64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRIu64 symbol, which +indiciates that stdio has a symbol to print 64-bit unsigned decimal +numbers. + +=item C<d_PRIx64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRIx64 symbol, which +indiciates that stdio has a symbol to print 64-bit hexadecimal numbers. + +=item C<d_PRIXU64> + +From F<quadfio.U>: + +This variable conditionally defines the PERL_PRIXU64 symbol, which +indiciates that stdio has a symbol to print 64-bit hExADECimAl numbers. +The C<U> in the name is to separate this from d_PRIx64 so that even +case-blind systems can see the difference. + +=item C<d_procselfexe> + +From F<d_procselfexe.U>: + +Defined if $procselfexe is symlink to the absolute +pathname of the executing program. + +=item C<d_pthread_atfork> + +From F<d_pthread_atfork.U>: + +This variable conditionally defines the C<HAS_PTHREAD_ATFORK> symbol, +which indicates to the C program that the pthread_atfork() +routine is available. + +=item C<d_pthread_yield> + +From F<d_pthread_y.U>: + +This variable conditionally defines the C<HAS_PTHREAD_YIELD> +symbol if the pthread_yield routine is available to yield +the execution of the current thread. + +=item C<d_pwage> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWAGE>, which indicates +that struct passwd contains pw_age. + +=item C<d_pwchange> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWCHANGE>, which indicates +that struct passwd contains pw_change. + +=item C<d_pwclass> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWCLASS>, which indicates +that struct passwd contains pw_class. + +=item C<d_pwcomment> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWCOMMENT>, which indicates +that struct passwd contains pw_comment. + +=item C<d_pwexpire> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWEXPIRE>, which indicates +that struct passwd contains pw_expire. + +=item C<d_pwgecos> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWGECOS>, which indicates +that struct passwd contains pw_gecos. + +=item C<d_pwpasswd> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWPASSWD>, which indicates +that struct passwd contains pw_passwd. + +=item C<d_pwquota> + +From F<i_pwd.U>: + +This variable conditionally defines C<PWQUOTA>, which indicates +that struct passwd contains pw_quota. + +=item C<d_qgcvt> + +From F<d_qgcvt.U>: + +This variable conditionally defines the C<HAS_QGCVT> symbol, which +indicates to the C program that the qgcvt() routine is available. + +=item C<d_quad> + +From F<quadtype.U>: + +This variable, if defined, tells that there's a 64-bit integer type, +quadtype. + +=item C<d_random_r> + +From F<d_random_r.U>: + +This variable conditionally defines the C<HAS_RANDOM_R> symbol, +which indicates to the C program that the random_r() +routine is available. + +=item C<d_readdir64_r> + +From F<d_readdir64_r.U>: + +This variable conditionally defines the HAS_READDIR64_R symbol, +which indicates to the C program that the readdir64_r() +routine is available. + +=item C<d_readdir> + +From F<d_readdir.U>: + +This variable conditionally defines C<HAS_READDIR> if readdir() is +available to read directory entries. + +=item C<d_readdir_r> + +From F<d_readdir_r.U>: + +This variable conditionally defines the C<HAS_READDIR_R> symbol, +which indicates to the C program that the readdir_r() +routine is available. + +=item C<d_readlink> + +From F<d_readlink.U>: + +This variable conditionally defines the C<HAS_READLINK> symbol, which +indicates to the C program that the readlink() routine is available +to read the value of a symbolic link. + +=item C<d_readv> + +From F<d_readv.U>: + +This variable conditionally defines the C<HAS_READV> symbol, which +indicates to the C program that the readv() routine is available. + +=item C<d_recvmsg> + +From F<d_recvmsg.U>: + +This variable conditionally defines the C<HAS_RECVMSG> symbol, which +indicates to the C program that the recvmsg() routine is available. + +=item C<d_rename> + +From F<d_rename.U>: + +This variable conditionally defines the C<HAS_RENAME> symbol, which +indicates to the C program that the rename() routine is available +to rename files. + +=item C<d_rewinddir> + +From F<d_readdir.U>: + +This variable conditionally defines C<HAS_REWINDDIR> if rewinddir() is +available. + +=item C<d_rmdir> + +From F<d_rmdir.U>: + +This variable conditionally defines C<HAS_RMDIR> if rmdir() is +available to remove directories. + +=item C<d_safebcpy> + +From F<d_safebcpy.U>: + +This variable conditionally defines the C<HAS_SAFE_BCOPY> symbol if +the bcopy() routine can do overlapping copies. Normally, you +should probably use memmove(). + +=item C<d_safemcpy> + +From F<d_safemcpy.U>: + +This variable conditionally defines the C<HAS_SAFE_MEMCPY> symbol if +the memcpy() routine can do overlapping copies. +For overlapping copies, memmove() should be used, if available. + +=item C<d_sanemcmp> + +From F<d_sanemcmp.U>: + +This variable conditionally defines the C<HAS_SANE_MEMCMP> symbol if +the memcpy() routine is available and can be used to compare relative +magnitudes of chars with their high bits set. + +=item C<d_sbrkproto> + +From F<d_sbrkproto.U>: + +This variable conditionally defines the C<HAS_SBRK_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the sbrk() function. Otherwise, it is +up to the program to supply one. + +=item C<d_sched_yield> + +From F<d_pthread_y.U>: + +This variable conditionally defines the C<HAS_SCHED_YIELD> +symbol if the sched_yield routine is available to yield +the execution of the current thread. + +=item C<d_scm_rights> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_SCM_RIGHTS> symbol, +which indicates that the C<SCM_RIGHTS> is available. #ifdef is +not enough because it may be an enum, glibc has been known to do this. + +=item C<d_SCNfldbl> + +From F<longdblfio.U>: + +This variable conditionally defines the PERL_PRIfldbl symbol, which +indiciates that stdio has a symbol to scan long doubles. + +=item C<d_seekdir> + +From F<d_readdir.U>: + +This variable conditionally defines C<HAS_SEEKDIR> if seekdir() is +available. + +=item C<d_select> + +From F<d_select.U>: + +This variable conditionally defines C<HAS_SELECT> if select() is +available to select active file descriptors. A <sys/time.h> +inclusion may be necessary for the timeout field. + +=item C<d_sem> + +From F<d_sem.U>: + +This variable conditionally defines the C<HAS_SEM> symbol, which +indicates that the entire sem*(2) library is present. + +=item C<d_semctl> + +From F<d_semctl.U>: + +This variable conditionally defines the C<HAS_SEMCTL> symbol, which +indicates to the C program that the semctl() routine is available. + +=item C<d_semctl_semid_ds> + +From F<d_union_semun.U>: + +This variable conditionally defines C<USE_SEMCTL_SEMID_DS>, which +indicates that struct semid_ds * is to be used for semctl C<IPC_STAT>. + +=item C<d_semctl_semun> + +From F<d_union_semun.U>: + +This variable conditionally defines C<USE_SEMCTL_SEMUN>, which +indicates that union semun is to be used for semctl C<IPC_STAT>. + +=item C<d_semget> + +From F<d_semget.U>: + +This variable conditionally defines the C<HAS_SEMGET> symbol, which +indicates to the C program that the semget() routine is available. + +=item C<d_semop> + +From F<d_semop.U>: + +This variable conditionally defines the C<HAS_SEMOP> symbol, which +indicates to the C program that the semop() routine is available. + +=item C<d_sendmsg> + +From F<d_sendmsg.U>: + +This variable conditionally defines the C<HAS_SENDMSG> symbol, which +indicates to the C program that the sendmsg() routine is available. + +=item C<d_setegid> + +From F<d_setegid.U>: + +This variable conditionally defines the C<HAS_SETEGID> symbol, which +indicates to the C program that the setegid() routine is available +to change the effective gid of the current program. + +=item C<d_seteuid> + +From F<d_seteuid.U>: + +This variable conditionally defines the C<HAS_SETEUID> symbol, which +indicates to the C program that the seteuid() routine is available +to change the effective uid of the current program. + +=item C<d_setgrent> + +From F<d_setgrent.U>: + +This variable conditionally defines the C<HAS_SETGRENT> symbol, which +indicates to the C program that the setgrent() routine is available +for initializing sequential access to the group database. + +=item C<d_setgrent_r> + +From F<d_setgrent_r.U>: + +This variable conditionally defines the C<HAS_SETGRENT_R> symbol, +which indicates to the C program that the setgrent_r() +routine is available. + +=item C<d_setgrps> + +From F<d_setgrps.U>: + +This variable conditionally defines the C<HAS_SETGROUPS> symbol, which +indicates to the C program that the setgroups() routine is available +to set the list of process groups. + +=item C<d_sethent> + +From F<d_sethent.U>: + +This variable conditionally defines C<HAS_SETHOSTENT> if sethostent() is +available. + +=item C<d_sethostent_r> + +From F<d_sethostent_r.U>: + +This variable conditionally defines the C<HAS_SETHOSTENT_R> symbol, +which indicates to the C program that the sethostent_r() +routine is available. + +=item C<d_setitimer> + +From F<d_setitimer.U>: + +This variable conditionally defines the C<HAS_SETITIMER> symbol, which +indicates to the C program that the setitimer() routine is available. + +=item C<d_setlinebuf> + +From F<d_setlnbuf.U>: + +This variable conditionally defines the C<HAS_SETLINEBUF> symbol, which +indicates to the C program that the setlinebuf() routine is available +to change stderr or stdout from block-buffered or unbuffered to a +line-buffered mode. + +=item C<d_setlocale> + +From F<d_setlocale.U>: + +This variable conditionally defines C<HAS_SETLOCALE> if setlocale() is +available to handle locale-specific ctype implementations. + +=item C<d_setlocale_r> + +From F<d_setlocale_r.U>: + +This variable conditionally defines the C<HAS_SETLOCALE_R> symbol, +which indicates to the C program that the setlocale_r() +routine is available. + +=item C<d_setnent> + +From F<d_setnent.U>: + +This variable conditionally defines C<HAS_SETNETENT> if setnetent() is +available. + +=item C<d_setnetent_r> + +From F<d_setnetent_r.U>: + +This variable conditionally defines the C<HAS_SETNETENT_R> symbol, +which indicates to the C program that the setnetent_r() +routine is available. + +=item C<d_setpent> + +From F<d_setpent.U>: + +This variable conditionally defines C<HAS_SETPROTOENT> if setprotoent() is +available. + +=item C<d_setpgid> + +From F<d_setpgid.U>: + +This variable conditionally defines the C<HAS_SETPGID> symbol if the +setpgid(pid, gpid) function is available to set process group C<ID>. + +=item C<d_setpgrp2> + +From F<d_setpgrp2.U>: + +This variable conditionally defines the HAS_SETPGRP2 symbol, which +indicates to the C program that the setpgrp2() (as in F<DG/C<UX>>) routine +is available to set the current process group. + +=item C<d_setpgrp> + +From F<d_setpgrp.U>: + +This variable conditionally defines C<HAS_SETPGRP> if setpgrp() is +available to set the current process group. + +=item C<d_setprior> + +From F<d_setprior.U>: + +This variable conditionally defines C<HAS_SETPRIORITY> if setpriority() +is available to set a process's priority. + +=item C<d_setproctitle> + +From F<d_setproctitle.U>: + +This variable conditionally defines the C<HAS_SETPROCTITLE> symbol, +which indicates to the C program that the setproctitle() routine +is available. + +=item C<d_setprotoent_r> + +From F<d_setprotoent_r.U>: + +This variable conditionally defines the C<HAS_SETPROTOENT_R> symbol, +which indicates to the C program that the setprotoent_r() +routine is available. + +=item C<d_setpwent> + +From F<d_setpwent.U>: + +This variable conditionally defines the C<HAS_SETPWENT> symbol, which +indicates to the C program that the setpwent() routine is available +for initializing sequential access to the passwd database. + +=item C<d_setpwent_r> + +From F<d_setpwent_r.U>: + +This variable conditionally defines the C<HAS_SETPWENT_R> symbol, +which indicates to the C program that the setpwent_r() +routine is available. + +=item C<d_setregid> + +From F<d_setregid.U>: + +This variable conditionally defines C<HAS_SETREGID> if setregid() is +available to change the real and effective gid of the current +process. + +=item C<d_setresgid> + +From F<d_setregid.U>: + +This variable conditionally defines C<HAS_SETRESGID> if setresgid() is +available to change the real, effective and saved gid of the current +process. + +=item C<d_setresuid> + +From F<d_setreuid.U>: + +This variable conditionally defines C<HAS_SETREUID> if setresuid() is +available to change the real, effective and saved uid of the current +process. + +=item C<d_setreuid> + +From F<d_setreuid.U>: + +This variable conditionally defines C<HAS_SETREUID> if setreuid() is +available to change the real and effective uid of the current +process. + +=item C<d_setrgid> + +From F<d_setrgid.U>: + +This variable conditionally defines the C<HAS_SETRGID> symbol, which +indicates to the C program that the setrgid() routine is available +to change the real gid of the current program. + +=item C<d_setruid> + +From F<d_setruid.U>: + +This variable conditionally defines the C<HAS_SETRUID> symbol, which +indicates to the C program that the setruid() routine is available +to change the real uid of the current program. + +=item C<d_setsent> + +From F<d_setsent.U>: + +This variable conditionally defines C<HAS_SETSERVENT> if setservent() is +available. + +=item C<d_setservent_r> + +From F<d_setservent_r.U>: + +This variable conditionally defines the C<HAS_SETSERVENT_R> symbol, +which indicates to the C program that the setservent_r() +routine is available. + +=item C<d_setsid> + +From F<d_setsid.U>: + +This variable conditionally defines C<HAS_SETSID> if setsid() is +available to set the process group C<ID>. + +=item C<d_setvbuf> + +From F<d_setvbuf.U>: + +This variable conditionally defines the C<HAS_SETVBUF> symbol, which +indicates to the C program that the setvbuf() routine is available +to change buffering on an open stdio stream. + +=item C<d_sfio> + +From F<d_sfio.U>: + +This variable conditionally defines the C<USE_SFIO> symbol, +and indicates whether sfio is available (and should be used). + +=item C<d_shm> + +From F<d_shm.U>: + +This variable conditionally defines the C<HAS_SHM> symbol, which +indicates that the entire shm*(2) library is present. + +=item C<d_shmat> + +From F<d_shmat.U>: + +This variable conditionally defines the C<HAS_SHMAT> symbol, which +indicates to the C program that the shmat() routine is available. + +=item C<d_shmatprototype> + +From F<d_shmat.U>: + +This variable conditionally defines the C<HAS_SHMAT_PROTOTYPE> +symbol, which indicates that F<sys/shm.h> has a prototype for +shmat. + +=item C<d_shmctl> + +From F<d_shmctl.U>: + +This variable conditionally defines the C<HAS_SHMCTL> symbol, which +indicates to the C program that the shmctl() routine is available. + +=item C<d_shmdt> + +From F<d_shmdt.U>: + +This variable conditionally defines the C<HAS_SHMDT> symbol, which +indicates to the C program that the shmdt() routine is available. + +=item C<d_shmget> + +From F<d_shmget.U>: + +This variable conditionally defines the C<HAS_SHMGET> symbol, which +indicates to the C program that the shmget() routine is available. + +=item C<d_sigaction> + +From F<d_sigaction.U>: + +This variable conditionally defines the C<HAS_SIGACTION> symbol, which +indicates that the Vr4 sigaction() routine is available. + +=item C<d_sigprocmask> + +From F<d_sigprocmask.U>: + +This variable conditionally defines C<HAS_SIGPROCMASK> +if sigprocmask() is available to examine or change the signal mask +of the calling process. + +=item C<d_sigsetjmp> + +From F<d_sigsetjmp.U>: + +This variable conditionally defines the C<HAS_SIGSETJMP> symbol, +which indicates that the sigsetjmp() routine is available to +call setjmp() and optionally save the process's signal mask. + +=item C<d_sockatmark> + +From F<d_sockatmark.U>: + +This variable conditionally defines the C<HAS_SOCKATMARK> symbol, which +indicates to the C program that the sockatmark() routine is available. + +=item C<d_sockatmarkproto> + +From F<d_sockatmarkproto.U>: + +This variable conditionally defines the C<HAS_SOCKATMARK_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the sockatmark() function. Otherwise, it is +up to the program to supply one. + +=item C<d_socket> + +From F<d_socket.U>: + +This variable conditionally defines C<HAS_SOCKET>, which indicates +that the C<BSD> socket interface is supported. + +=item C<d_socklen_t> + +From F<d_socklen_t.U>: + +This symbol will be defined if the C compiler supports socklen_t. + +=item C<d_sockpair> + +From F<d_socket.U>: + +This variable conditionally defines the C<HAS_SOCKETPAIR> symbol, which +indicates that the C<BSD> socketpair() is supported. + +=item C<d_socks5_init> + +From F<d_socks5_init.U>: + +This variable conditionally defines the HAS_SOCKS5_INIT symbol, which +indicates to the C program that the socks5_init() routine is available. + +=item C<d_sqrtl> + +From F<d_sqrtl.U>: + +This variable conditionally defines the C<HAS_SQRTL> symbol, which +indicates to the C program that the sqrtl() routine is available. + +=item C<d_srand48_r> + +From F<d_srand48_r.U>: + +This variable conditionally defines the HAS_SRAND48_R symbol, +which indicates to the C program that the srand48_r() +routine is available. + +=item C<d_srandom_r> + +From F<d_srandom_r.U>: + +This variable conditionally defines the C<HAS_SRANDOM_R> symbol, +which indicates to the C program that the srandom_r() +routine is available. + +=item C<d_sresgproto> + +From F<d_sresgproto.U>: + +This variable conditionally defines the C<HAS_SETRESGID_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the setresgid() function. Otherwise, it is +up to the program to supply one. + +=item C<d_sresuproto> + +From F<d_sresuproto.U>: + +This variable conditionally defines the C<HAS_SETRESUID_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the setresuid() function. Otherwise, it is +up to the program to supply one. + +=item C<d_statblks> + +From F<d_statblks.U>: + +This variable conditionally defines C<USE_STAT_BLOCKS> +if this system has a stat structure declaring +st_blksize and st_blocks. + +=item C<d_statfs_f_flags> + +From F<d_statfs_f_flags.U>: + +This variable conditionally defines the C<HAS_STRUCT_STATFS_F_FLAGS> +symbol, which indicates to struct statfs from has f_flags member. +This kind of struct statfs is coming from F<sys/mount.h> (C<BSD>), +not from F<sys/statfs.h> (C<SYSV>). + +=item C<d_statfs_s> + +From F<d_statfs_s.U>: + +This variable conditionally defines the C<HAS_STRUCT_STATFS> symbol, +which indicates that the struct statfs is supported. + +=item C<d_statvfs> + +From F<d_statvfs.U>: + +This variable conditionally defines the C<HAS_STATVFS> symbol, which +indicates to the C program that the statvfs() routine is available. + +=item C<d_stdio_cnt_lval> + +From F<d_stdstdio.U>: + +This variable conditionally defines C<STDIO_CNT_LVALUE> if the +C<FILE_cnt> macro can be used as an lvalue. + +=item C<d_stdio_ptr_lval> + +From F<d_stdstdio.U>: + +This variable conditionally defines C<STDIO_PTR_LVALUE> if the +C<FILE_ptr> macro can be used as an lvalue. + +=item C<d_stdio_ptr_lval_nochange_cnt> + +From F<d_stdstdio.U>: + +This symbol is defined if using the C<FILE_ptr> macro as an lvalue +to increase the pointer by n leaves File_cnt(fp) unchanged. + +=item C<d_stdio_ptr_lval_sets_cnt> + +From F<d_stdstdio.U>: + +This symbol is defined if using the C<FILE_ptr> macro as an lvalue +to increase the pointer by n has the side effect of decreasing the +value of File_cnt(fp) by n. + +=item C<d_stdio_stream_array> + +From F<stdio_streams.U>: + +This variable tells whether there is an array holding +the stdio streams. + +=item C<d_stdiobase> + +From F<d_stdstdio.U>: + +This variable conditionally defines C<USE_STDIO_BASE> if this system +has a C<FILE> structure declaring a usable _base field (or equivalent) +in F<stdio.h>. + +=item C<d_stdstdio> + +From F<d_stdstdio.U>: + +This variable conditionally defines C<USE_STDIO_PTR> if this system +has a C<FILE> structure declaring usable _ptr and _cnt fields (or +equivalent) in F<stdio.h>. + +=item C<d_strchr> + +From F<d_strchr.U>: + +This variable conditionally defines C<HAS_STRCHR> if strchr() and +strrchr() are available for string searching. + +=item C<d_strcoll> + +From F<d_strcoll.U>: + +This variable conditionally defines C<HAS_STRCOLL> if strcoll() is +available to compare strings using collating information. + +=item C<d_strctcpy> + +From F<d_strctcpy.U>: + +This variable conditionally defines the C<USE_STRUCT_COPY> symbol, which +indicates to the C program that this C compiler knows how to copy +structures. + +=item C<d_strerrm> + +From F<d_strerror.U>: + +This variable holds what Strerrr is defined as to translate an error +code condition into an error message string. It could be C<strerror> +or a more C<complex> macro emulating strrror with sys_errlist[], or the +C<unknown> string when both strerror and sys_errlist are missing. + +=item C<d_strerror> + +From F<d_strerror.U>: + +This variable conditionally defines C<HAS_STRERROR> if strerror() is +available to translate error numbers to strings. + +=item C<d_strerror_r> + +From F<d_strerror_r.U>: + +This variable conditionally defines the C<HAS_STRERROR_R> symbol, +which indicates to the C program that the strerror_r() +routine is available. + +=item C<d_strftime> + +From F<d_strftime.U>: + +This variable conditionally defines the C<HAS_STRFTIME> symbol, which +indicates to the C program that the strftime() routine is available. + +=item C<d_strtod> + +From F<d_strtod.U>: + +This variable conditionally defines the C<HAS_STRTOD> symbol, which +indicates to the C program that the strtod() routine is available +to provide better numeric string conversion than atof(). + +=item C<d_strtol> + +From F<d_strtol.U>: + +This variable conditionally defines the C<HAS_STRTOL> symbol, which +indicates to the C program that the strtol() routine is available +to provide better numeric string conversion than atoi() and friends. + +=item C<d_strtold> + +From F<d_strtold.U>: + +This variable conditionally defines the C<HAS_STRTOLD> symbol, which +indicates to the C program that the strtold() routine is available. + +=item C<d_strtoll> + +From F<d_strtoll.U>: + +This variable conditionally defines the C<HAS_STRTOLL> symbol, which +indicates to the C program that the strtoll() routine is available. + +=item C<d_strtoq> + +From F<d_strtoq.U>: + +This variable conditionally defines the C<HAS_STRTOQ> symbol, which +indicates to the C program that the strtoq() routine is available. + +=item C<d_strtoul> + +From F<d_strtoul.U>: + +This variable conditionally defines the C<HAS_STRTOUL> symbol, which +indicates to the C program that the strtoul() routine is available +to provide conversion of strings to unsigned long. + +=item C<d_strtoull> + +From F<d_strtoull.U>: + +This variable conditionally defines the C<HAS_STRTOULL> symbol, which +indicates to the C program that the strtoull() routine is available. + +=item C<d_strtouq> + +From F<d_strtouq.U>: + +This variable conditionally defines the C<HAS_STRTOUQ> symbol, which +indicates to the C program that the strtouq() routine is available. + +=item C<d_strxfrm> + +From F<d_strxfrm.U>: + +This variable conditionally defines C<HAS_STRXFRM> if strxfrm() is +available to transform strings. + +=item C<d_suidsafe> + +From F<d_dosuid.U>: + +This variable conditionally defines C<SETUID_SCRIPTS_ARE_SECURE_NOW> +if setuid scripts can be secure. This test looks in F</dev/fd/>. + +=item C<d_symlink> + +From F<d_symlink.U>: + +This variable conditionally defines the C<HAS_SYMLINK> symbol, which +indicates to the C program that the symlink() routine is available +to create symbolic links. + +=item C<d_syscall> + +From F<d_syscall.U>: + +This variable conditionally defines C<HAS_SYSCALL> if syscall() is +available call arbitrary system calls. + +=item C<d_syscallproto> + +From F<d_syscallproto.U>: + +This variable conditionally defines the C<HAS_SYSCALL_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the syscall() function. Otherwise, it is +up to the program to supply one. + +=item C<d_sysconf> + +From F<d_sysconf.U>: + +This variable conditionally defines the C<HAS_SYSCONF> symbol, which +indicates to the C program that the sysconf() routine is available +to determine system related limits and options. + +=item C<d_sysernlst> + +From F<d_strerror.U>: + +This variable conditionally defines C<HAS_SYS_ERRNOLIST> if sys_errnolist[] +is available to translate error numbers to the symbolic name. + +=item C<d_syserrlst> + +From F<d_strerror.U>: + +This variable conditionally defines C<HAS_SYS_ERRLIST> if sys_errlist[] is +available to translate error numbers to strings. + +=item C<d_system> + +From F<d_system.U>: + +This variable conditionally defines C<HAS_SYSTEM> if system() is +available to issue a shell command. + +=item C<d_tcgetpgrp> + +From F<d_tcgtpgrp.U>: + +This variable conditionally defines the C<HAS_TCGETPGRP> symbol, which +indicates to the C program that the tcgetpgrp() routine is available. +to get foreground process group C<ID>. + +=item C<d_tcsetpgrp> + +From F<d_tcstpgrp.U>: + +This variable conditionally defines the C<HAS_TCSETPGRP> symbol, which +indicates to the C program that the tcsetpgrp() routine is available +to set foreground process group C<ID>. + +=item C<d_telldir> + +From F<d_readdir.U>: + +This variable conditionally defines C<HAS_TELLDIR> if telldir() is +available. + +=item C<d_telldirproto> + +From F<d_telldirproto.U>: + +This variable conditionally defines the C<HAS_TELLDIR_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the telldir() function. Otherwise, it is +up to the program to supply one. + +=item C<d_time> + +From F<d_time.U>: + +This variable conditionally defines the C<HAS_TIME> symbol, which indicates +that the time() routine exists. The time() routine is normaly +provided on C<UNIX> systems. + +=item C<d_times> + +From F<d_times.U>: + +This variable conditionally defines the C<HAS_TIMES> symbol, which indicates +that the times() routine exists. The times() routine is normaly +provided on C<UNIX> systems. You may have to include <sys/times.h>. + +=item C<d_tm_tm_gmtoff> + +From F<i_time.U>: + +This variable conditionally defines C<HAS_TM_TM_GMTOFF>, which indicates +indicates to the C program that the struct tm has the tm_gmtoff field. + +=item C<d_tm_tm_zone> + +From F<i_time.U>: + +This variable conditionally defines C<HAS_TM_TM_ZONE>, which indicates +indicates to the C program that the struct tm has the tm_zone field. + +=item C<d_tmpnam_r> + +From F<d_tmpnam_r.U>: + +This variable conditionally defines the C<HAS_TMPNAM_R> symbol, +which indicates to the C program that the tmpnam_r() +routine is available. + +=item C<d_truncate> + +From F<d_truncate.U>: + +This variable conditionally defines C<HAS_TRUNCATE> if truncate() is +available to truncate files. + +=item C<d_ttyname_r> + +From F<d_ttyname_r.U>: + +This variable conditionally defines the C<HAS_TTYNAME_R> symbol, +which indicates to the C program that the ttyname_r() +routine is available. + +=item C<d_tzname> + +From F<d_tzname.U>: + +This variable conditionally defines C<HAS_TZNAME> if tzname[] is +available to access timezone names. + +=item C<d_u32align> + +From F<d_u32align.U>: + +This variable tells whether you must access character data +through U32-aligned pointers. + +=item C<d_ualarm> + +From F<d_ualarm.U>: + +This variable conditionally defines the C<HAS_UALARM> symbol, which +indicates to the C program that the ualarm() routine is available. + +=item C<d_umask> + +From F<d_umask.U>: + +This variable conditionally defines the C<HAS_UMASK> symbol, which +indicates to the C program that the umask() routine is available. +to set and get the value of the file creation mask. + +=item C<d_uname> + +From F<d_gethname.U>: + +This variable conditionally defines the C<HAS_UNAME> symbol, which +indicates to the C program that the uname() routine may be +used to derive the host name. + +=item C<d_union_semun> + +From F<d_union_semun.U>: + +This variable conditionally defines C<HAS_UNION_SEMUN> if the +union semun is defined by including <sys/sem.h>. + +=item C<d_unordered> + +From F<d_unordered.U>: + +This variable conditionally defines the C<HAS_UNORDERED> symbol, which +indicates to the C program that the unordered() routine is available. + +=item C<d_usleep> + +From F<d_usleep.U>: + +This variable conditionally defines C<HAS_USLEEP> if usleep() is +available to do high granularity sleeps. + +=item C<d_usleepproto> + +From F<d_usleepproto.U>: + +This variable conditionally defines the C<HAS_USLEEP_PROTO> symbol, +which indicates to the C program that the system provides +a prototype for the usleep() function. Otherwise, it is +up to the program to supply one. + +=item C<d_ustat> + +From F<d_ustat.U>: + +This variable conditionally defines C<HAS_USTAT> if ustat() is +available to query file system statistics by dev_t. + +=item C<d_vendorarch> + +From F<vendorarch.U>: + +This variable conditionally defined C<PERL_VENDORARCH>. + +=item C<d_vendorbin> + +From F<vendorbin.U>: + +This variable conditionally defines C<PERL_VENDORBIN>. + +=item C<d_vendorlib> + +From F<vendorlib.U>: + +This variable conditionally defines C<PERL_VENDORLIB>. + +=item C<d_vfork> + +From F<d_vfork.U>: + +This variable conditionally defines the C<HAS_VFORK> symbol, which +indicates the vfork() routine is available. + +=item C<d_void_closedir> + +From F<d_closedir.U>: + +This variable conditionally defines C<VOID_CLOSEDIR> if closedir() +does not return a value. + +=item C<d_voidsig> + +From F<d_voidsig.U>: + +This variable conditionally defines C<VOIDSIG> if this system +declares "void (*signal(...))()" in F<signal.h>. The old way was to +declare it as "int (*signal(...))()". + +=item C<d_voidtty> + +From F<i_sysioctl.U>: + +This variable conditionally defines C<USE_IOCNOTTY> to indicate that the +ioctl() call with C<TIOCNOTTY> should be used to void tty association. +Otherwise (on C<USG> probably), it is enough to close the standard file +decriptors and do a setpgrp(). + +=item C<d_volatile> + +From F<d_volatile.U>: + +This variable conditionally defines the C<HASVOLATILE> symbol, which +indicates to the C program that this C compiler knows about the +volatile declaration. + +=item C<d_vprintf> + +From F<d_vprintf.U>: + +This variable conditionally defines the C<HAS_VPRINTF> symbol, which +indicates to the C program that the vprintf() routine is available +to printf with a pointer to an argument list. + +=item C<d_wait4> + +From F<d_wait4.U>: + +This variable conditionally defines the HAS_WAIT4 symbol, which +indicates the wait4() routine is available. + +=item C<d_waitpid> + +From F<d_waitpid.U>: + +This variable conditionally defines C<HAS_WAITPID> if waitpid() is +available to wait for child process. + +=item C<d_wcstombs> + +From F<d_wcstombs.U>: + +This variable conditionally defines the C<HAS_WCSTOMBS> symbol, which +indicates to the C program that the wcstombs() routine is available +to convert wide character strings to multibyte strings. + +=item C<d_wctomb> + +From F<d_wctomb.U>: + +This variable conditionally defines the C<HAS_WCTOMB> symbol, which +indicates to the C program that the wctomb() routine is available +to convert a wide character to a multibyte. + +=item C<d_writev> + +From F<d_writev.U>: + +This variable conditionally defines the C<HAS_WRITEV> symbol, which +indicates to the C program that the writev() routine is available. + +=item C<d_xenix> + +From F<Guess.U>: + +This variable conditionally defines the symbol C<XENIX>, which alerts +the C program that it runs under Xenix. + +=item C<date> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the date program. After Configure runs, +the value is reset to a plain C<date> and is not useful. + +=item C<db_hashtype> + +From F<i_db.U>: + +This variable contains the type of the hash structure element +in the <db.h> header file. In older versions of C<DB>, it was +int, while in newer ones it is u_int32_t. + +=item C<db_prefixtype> + +From F<i_db.U>: + +This variable contains the type of the prefix structure element +in the <db.h> header file. In older versions of C<DB>, it was +int, while in newer ones it is size_t. + +=item C<db_version_major> + +From F<i_db.U>: + +This variable contains the major version number of +Berkeley C<DB> found in the <db.h> header file. + +=item C<db_version_minor> + +From F<i_db.U>: + +This variable contains the minor version number of +Berkeley C<DB> found in the <db.h> header file. +For C<DB> version 1 this is always 0. + +=item C<db_version_patch> + +From F<i_db.U>: + +This variable contains the patch version number of +Berkeley C<DB> found in the <db.h> header file. +For C<DB> version 1 this is always 0. + +=item C<defvoidused> + +From F<voidflags.U>: + +This variable contains the default value of the C<VOIDUSED> symbol (15). + +=item C<direntrytype> + +From F<i_dirent.U>: + +This symbol is set to C<struct direct> or C<struct dirent> depending on +whether dirent is available or not. You should use this pseudo type to +portably declare your directory entries. + +=item C<dlext> + +From F<dlext.U>: + +This variable contains the extension that is to be used for the +dynamically loaded modules that perl generaties. + +=item C<dlsrc> + +From F<dlsrc.U>: + +This variable contains the name of the dynamic loading file that +will be used with the package. + +=item C<doublesize> + +From F<doublesize.U>: + +This variable contains the value of the C<DOUBLESIZE> symbol, which +indicates to the C program how many bytes there are in a double. + +=item C<drand01> + +From F<randfunc.U>: + +Indicates the macro to be used to generate normalized +random numbers. Uses randfunc, often divided by +(double) (((unsigned long) 1 << randbits)) in order to +normalize the result. +In C programs, the macro C<Drand01> is mapped to drand01. + +=item C<drand48_r_proto> + +From F<d_drand48_r.U>: + +This variable encodes the prototype of drand48_r. +It is zero if d_drand48_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_drand48_r +is defined. + +=item C<dynamic_ext> + +From F<Extensions.U>: + +This variable holds a list of C<XS> extension files we want to +link dynamically into the package. It is used by Makefile. + +=back + +=head2 e + +=over 4 + +=item C<eagain> + +From F<nblock_io.U>: + +This variable bears the symbolic errno code set by read() when no +data is present on the file and non-blocking I/O was enabled (otherwise, +read() blocks naturally). + +=item C<ebcdic> + +From F<ebcdic.U>: + +This variable conditionally defines C<EBCDIC> if this +system uses C<EBCDIC> encoding. Among other things, this +means that the character ranges are not contiguous. +See F<trnl.U> + +=item C<echo> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the echo program. After Configure runs, +the value is reset to a plain C<echo> and is not useful. + +=item C<egrep> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the egrep program. After Configure runs, +the value is reset to a plain C<egrep> and is not useful. + +=item C<emacs> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<endgrent_r_proto> + +From F<d_endgrent_r.U>: + +This variable encodes the prototype of endgrent_r. +It is zero if d_endgrent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endgrent_r +is defined. + +=item C<endhostent_r_proto> + +From F<d_endhostent_r.U>: + +This variable encodes the prototype of endhostent_r. +It is zero if d_endhostent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endhostent_r +is defined. + +=item C<endnetent_r_proto> + +From F<d_endnetent_r.U>: + +This variable encodes the prototype of endnetent_r. +It is zero if d_endnetent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endnetent_r +is defined. + +=item C<endprotoent_r_proto> + +From F<d_endprotoent_r.U>: + +This variable encodes the prototype of endprotoent_r. +It is zero if d_endprotoent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endprotoent_r +is defined. + +=item C<endpwent_r_proto> + +From F<d_endpwent_r.U>: + +This variable encodes the prototype of endpwent_r. +It is zero if d_endpwent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endpwent_r +is defined. + +=item C<endservent_r_proto> + +From F<d_endservent_r.U>: + +This variable encodes the prototype of endservent_r. +It is zero if d_endservent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_endservent_r +is defined. + +=item C<eunicefix> + +From F<Init.U>: + +When running under Eunice this variable contains a command which will +convert a shell script to the proper form of text file for it to be +executable by the shell. On other systems it is a no-op. + +=item C<exe_ext> + +From F<Unix.U>: + +This is an old synonym for _exe. + +=item C<expr> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the expr program. After Configure runs, +the value is reset to a plain C<expr> and is not useful. + +=item C<extensions> + +From F<Extensions.U>: + +This variable holds a list of all extension files (both C<XS> and +non-xs linked into the package. It is propagated to F<Config.pm> +and is typically used to test whether a particular extesion +is available. + +=item C<extras> + +From F<Extras.U>: + +This variable holds a list of extra modules to install. + +=back + +=head2 f + +=over 4 + +=item C<fflushall> + +From F<fflushall.U>: + +This symbol, if defined, tells that to flush +all pending stdio output one must loop through all +the stdio file handles stored in an array and fflush them. +Note that if fflushNULL is defined, fflushall will not +even be probed for and will be left undefined. + +=item C<fflushNULL> + +From F<fflushall.U>: + +This symbol, if defined, tells that fflush(C<NULL>) does flush +all pending stdio output. + +=item C<find> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<firstmakefile> + +From F<Unix.U>: + +This variable defines the first file searched by make. On unix, +it is makefile (then Makefile). On case-insensitive systems, +it might be something else. This is only used to deal with +convoluted make depend tricks. + +=item C<flex> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<fpossize> + +From F<fpossize.U>: + +This variable contains the size of a fpostype in bytes. + +=item C<fpostype> + +From F<fpostype.U>: + +This variable defines Fpos_t to be something like fpos_t, long, +uint, or whatever type is used to declare file positions in libc. + +=item C<freetype> + +From F<mallocsrc.U>: + +This variable contains the return type of free(). It is usually +void, but occasionally int. + +=item C<from> + +From F<Cross.U>: + +This variable contains the command used by Configure +to copy files from the target host. Useful and available +only during Perl build. +The string C<:> if not cross-compiling. + +=item C<full_ar> + +From F<Loc_ar.U>: + +This variable contains the full pathname to C<ar>, whether or +not the user has specified C<portability>. This is only used +in the F<Makefile.SH>. + +=item C<full_csh> + +From F<d_csh.U>: + +This variable contains the full pathname to C<csh>, whether or +not the user has specified C<portability>. This is only used +in the compiled C program, and we assume that all systems which +can share this executable will have the same full pathname to +F<csh.> + +=item C<full_sed> + +From F<Loc_sed.U>: + +This variable contains the full pathname to C<sed>, whether or +not the user has specified C<portability>. This is only used +in the compiled C program, and we assume that all systems which +can share this executable will have the same full pathname to +F<sed.> + +=back + +=head2 g + +=over 4 + +=item C<gccosandvers> + +From F<gccvers.U>: + +If C<GNU> cc (gcc) is used, this variable the operating system and +version used to compile the gcc. It is set to '' if not gcc, +or if nothing useful can be parsed as the os version. + +=item C<gccversion> + +From F<gccvers.U>: + +If C<GNU> cc (gcc) is used, this variable holds C<1> or C<2> to +indicate whether the compiler is version 1 or 2. This is used in +setting some of the default cflags. It is set to '' if not gcc. + +=item C<getgrent_r_proto> + +From F<d_getgrent_r.U>: + +This variable encodes the prototype of getgrent_r. +It is zero if d_getgrent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getgrent_r +is defined. + +=item C<getgrgid_r_proto> + +From F<d_getgrgid_r.U>: + +This variable encodes the prototype of getgrgid_r. +It is zero if d_getgrgid_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getgrgid_r +is defined. + +=item C<getgrnam_r_proto> + +From F<d_getgrnam_r.U>: + +This variable encodes the prototype of getgrnam_r. +It is zero if d_getgrnam_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getgrnam_r +is defined. + +=item C<gethostbyaddr_r_proto> + +From F<d_gethostbyaddr_r.U>: + +This variable encodes the prototype of gethostbyaddr_r. +It is zero if d_gethostbyaddr_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_gethostbyaddr_r +is defined. + +=item C<gethostbyname_r_proto> + +From F<d_gethostbyname_r.U>: + +This variable encodes the prototype of gethostbyname_r. +It is zero if d_gethostbyname_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_gethostbyname_r +is defined. + +=item C<gethostent_r_proto> + +From F<d_gethostent_r.U>: + +This variable encodes the prototype of gethostent_r. +It is zero if d_gethostent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_gethostent_r +is defined. + +=item C<getlogin_r_proto> + +From F<d_getlogin_r.U>: + +This variable encodes the prototype of getlogin_r. +It is zero if d_getlogin_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getlogin_r +is defined. + +=item C<getnetbyaddr_r_proto> + +From F<d_getnetbyaddr_r.U>: + +This variable encodes the prototype of getnetbyaddr_r. +It is zero if d_getnetbyaddr_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getnetbyaddr_r +is defined. + +=item C<getnetbyname_r_proto> + +From F<d_getnetbyname_r.U>: + +This variable encodes the prototype of getnetbyname_r. +It is zero if d_getnetbyname_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getnetbyname_r +is defined. + +=item C<getnetent_r_proto> + +From F<d_getnetent_r.U>: + +This variable encodes the prototype of getnetent_r. +It is zero if d_getnetent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getnetent_r +is defined. + +=item C<getprotobyname_r_proto> + +From F<d_getprotobyname_r.U>: + +This variable encodes the prototype of getprotobyname_r. +It is zero if d_getprotobyname_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getprotobyname_r +is defined. + +=item C<getprotobynumber_r_proto> + +From F<d_getprotobynumber_r.U>: + +This variable encodes the prototype of getprotobynumber_r. +It is zero if d_getprotobynumber_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getprotobynumber_r +is defined. + +=item C<getprotoent_r_proto> + +From F<d_getprotoent_r.U>: + +This variable encodes the prototype of getprotoent_r. +It is zero if d_getprotoent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getprotoent_r +is defined. + +=item C<getpwent_r_proto> + +From F<d_getpwent_r.U>: + +This variable encodes the prototype of getpwent_r. +It is zero if d_getpwent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getpwent_r +is defined. + +=item C<getpwnam_r_proto> + +From F<d_getpwnam_r.U>: + +This variable encodes the prototype of getpwnam_r. +It is zero if d_getpwnam_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getpwnam_r +is defined. + +=item C<getpwuid_r_proto> + +From F<d_getpwuid_r.U>: + +This variable encodes the prototype of getpwuid_r. +It is zero if d_getpwuid_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getpwuid_r +is defined. + +=item C<getservbyname_r_proto> + +From F<d_getservbyname_r.U>: + +This variable encodes the prototype of getservbyname_r. +It is zero if d_getservbyname_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getservbyname_r +is defined. + +=item C<getservbyport_r_proto> + +From F<d_getservbyport_r.U>: + +This variable encodes the prototype of getservbyport_r. +It is zero if d_getservbyport_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getservbyport_r +is defined. + +=item C<getservent_r_proto> + +From F<d_getservent_r.U>: + +This variable encodes the prototype of getservent_r. +It is zero if d_getservent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getservent_r +is defined. + +=item C<getspnam_r_proto> + +From F<d_getspnam_r.U>: + +This variable encodes the prototype of getspnam_r. +It is zero if d_getspnam_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_getspnam_r +is defined. + +=item C<gidformat> + +From F<gidf.U>: + +This variable contains the format string used for printing a Gid_t. + +=item C<gidsign> + +From F<gidsign.U>: + +This variable contains the signedness of a gidtype. +1 for unsigned, -1 for signed. + +=item C<gidsize> + +From F<gidsize.U>: + +This variable contains the size of a gidtype in bytes. + +=item C<gidtype> + +From F<gidtype.U>: + +This variable defines Gid_t to be something like gid_t, int, +ushort, or whatever type is used to declare the return type +of getgid(). Typically, it is the type of group ids in the kernel. + +=item C<glibpth> + +From F<libpth.U>: + +This variable holds the general path (space-separated) used to +find libraries. It may contain directories that do not exist on +this platform, libpth is the cleaned-up version. + +=item C<gmake> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the gmake program. After Configure runs, +the value is reset to a plain C<gmake> and is not useful. + +=item C<gmtime_r_proto> + +From F<d_gmtime_r.U>: + +This variable encodes the prototype of gmtime_r. +It is zero if d_gmtime_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_gmtime_r +is defined. + +=item C<gnulibc_version> + +From F<d_gnulibc.U>: + +This variable contains the version number of the C<GNU> C library. +It is usually something like F<2.2.5>. It is a plain '' if this +is not the C<GNU> C library, or if the version is unknown. + +=item C<grep> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the grep program. After Configure runs, +the value is reset to a plain C<grep> and is not useful. + +=item C<groupcat> + +From F<nis.U>: + +This variable contains a command that produces the text of the +F</etc/group> file. This is normally "cat F</etc/group>", but can be +"ypcat group" when C<NIS> is used. +On some systems, such as os390, there may be no equivalent +command, in which case this variable is unset. + +=item C<groupstype> + +From F<groupstype.U>: + +This variable defines Groups_t to be something like gid_t, int, +ushort, or whatever type is used for the second argument to +getgroups() and setgroups(). Usually, this is the same as +gidtype (gid_t), but sometimes it isn't. + +=item C<gzip> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the gzip program. After Configure runs, +the value is reset to a plain C<gzip> and is not useful. + +=back + +=head2 h + +=over 4 + +=item C<h_fcntl> + +From F<h_fcntl.U>: + +This is variable gets set in various places to tell i_fcntl that +<fcntl.h> should be included. + +=item C<h_sysfile> + +From F<h_sysfile.U>: + +This is variable gets set in various places to tell i_sys_file that +<sys/file.h> should be included. + +=item C<hint> + +From F<Oldconfig.U>: + +Gives the type of hints used for previous answers. May be one of +C<default>, C<recommended> or C<previous>. + +=item C<hostcat> + +From F<nis.U>: + +This variable contains a command that produces the text of the +F</etc/hosts> file. This is normally "cat F</etc/hosts>", but can be +"ypcat hosts" when C<NIS> is used. +On some systems, such as os390, there may be no equivalent +command, in which case this variable is unset. + +=back + +=head2 i + +=over 4 + +=item C<i16size> + +From F<perlxv.U>: + +This variable is the size of an I16 in bytes. + +=item C<i16type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's I16. + +=item C<i32size> + +From F<perlxv.U>: + +This variable is the size of an I32 in bytes. + +=item C<i32type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's I32. + +=item C<i64size> + +From F<perlxv.U>: + +This variable is the size of an I64 in bytes. + +=item C<i64type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's I64. + +=item C<i8size> + +From F<perlxv.U>: + +This variable is the size of an I8 in bytes. + +=item C<i8type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's I8. + +=item C<i_arpainet> + +From F<i_arpainet.U>: + +This variable conditionally defines the C<I_ARPA_INET> symbol, +and indicates whether a C program should include <arpa/inet.h>. + +=item C<i_bsdioctl> + +From F<i_sysioctl.U>: + +This variable conditionally defines the C<I_SYS_BSDIOCTL> symbol, which +indicates to the C program that <sys/bsdioctl.h> exists and should +be included. + +=item C<i_crypt> + +From F<i_crypt.U>: + +This variable conditionally defines the C<I_CRYPT> symbol, and indicates +whether a C program should include <crypt.h>. + +=item C<i_db> + +From F<i_db.U>: + +This variable conditionally defines the C<I_DB> symbol, and indicates +whether a C program may include Berkeley's C<DB> include file <db.h>. + +=item C<i_dbm> + +From F<i_dbm.U>: + +This variable conditionally defines the C<I_DBM> symbol, which +indicates to the C program that <dbm.h> exists and should +be included. + +=item C<i_dirent> + +From F<i_dirent.U>: + +This variable conditionally defines C<I_DIRENT>, which indicates +to the C program that it should include <dirent.h>. + +=item C<i_dld> + +From F<i_dld.U>: + +This variable conditionally defines the C<I_DLD> symbol, which +indicates to the C program that <dld.h> (C<GNU> dynamic loading) +exists and should be included. + +=item C<i_dlfcn> + +From F<i_dlfcn.U>: + +This variable conditionally defines the C<I_DLFCN> symbol, which +indicates to the C program that <dlfcn.h> exists and should +be included. + +=item C<i_fcntl> + +From F<i_fcntl.U>: + +This variable controls the value of C<I_FCNTL> (which tells +the C program to include <fcntl.h>). + +=item C<i_float> + +From F<i_float.U>: + +This variable conditionally defines the C<I_FLOAT> symbol, and indicates +whether a C program may include <float.h> to get symbols like C<DBL_MAX> +or C<DBL_MIN>, F<i.e>. machine dependent floating point values. + +=item C<i_fp> + +From F<i_fp.U>: + +This variable conditionally defines the C<I_FP> symbol, and indicates +whether a C program should include <fp.h>. + +=item C<i_fp_class> + +From F<i_fp_class.U>: + +This variable conditionally defines the C<I_FP_CLASS> symbol, and indicates +whether a C program should include <fp_class.h>. + +=item C<i_gdbm> + +From F<i_gdbm.U>: + +This variable conditionally defines the C<I_GDBM> symbol, which +indicates to the C program that <gdbm.h> exists and should +be included. + +=item C<i_grp> + +From F<i_grp.U>: + +This variable conditionally defines the C<I_GRP> symbol, and indicates +whether a C program should include <grp.h>. + +=item C<i_ieeefp> + +From F<i_ieeefp.U>: + +This variable conditionally defines the C<I_IEEEFP> symbol, and indicates +whether a C program should include <ieeefp.h>. + +=item C<i_inttypes> + +From F<i_inttypes.U>: + +This variable conditionally defines the C<I_INTTYPES> symbol, +and indicates whether a C program should include <inttypes.h>. + +=item C<i_langinfo> + +From F<i_langinfo.U>: + +This variable conditionally defines the C<I_LANGINFO> symbol, +and indicates whether a C program should include <langinfo.h>. + +=item C<i_libutil> + +From F<i_libutil.U>: + +This variable conditionally defines the C<I_LIBUTIL> symbol, and indicates +whether a C program should include <libutil.h>. + +=item C<i_limits> + +From F<i_limits.U>: + +This variable conditionally defines the C<I_LIMITS> symbol, and indicates +whether a C program may include <limits.h> to get symbols like C<WORD_BIT> +and friends. + +=item C<i_locale> + +From F<i_locale.U>: + +This variable conditionally defines the C<I_LOCALE> symbol, +and indicates whether a C program should include <locale.h>. + +=item C<i_machcthr> + +From F<i_machcthr.U>: + +This variable conditionally defines the C<I_MACH_CTHREADS> symbol, +and indicates whether a C program should include <mach/cthreads.h>. + +=item C<i_malloc> + +From F<i_malloc.U>: + +This variable conditionally defines the C<I_MALLOC> symbol, and indicates +whether a C program should include <malloc.h>. + +=item C<i_math> + +From F<i_math.U>: + +This variable conditionally defines the C<I_MATH> symbol, and indicates +whether a C program may include <math.h>. + +=item C<i_memory> + +From F<i_memory.U>: + +This variable conditionally defines the C<I_MEMORY> symbol, and indicates +whether a C program should include <memory.h>. + +=item C<i_mntent> + +From F<i_mntent.U>: + +This variable conditionally defines the C<I_MNTENT> symbol, and indicates +whether a C program should include <mntent.h>. + +=item C<i_ndbm> + +From F<i_ndbm.U>: + +This variable conditionally defines the C<I_NDBM> symbol, which +indicates to the C program that <ndbm.h> exists and should +be included. + +=item C<i_netdb> + +From F<i_netdb.U>: + +This variable conditionally defines the C<I_NETDB> symbol, and indicates +whether a C program should include <netdb.h>. + +=item C<i_neterrno> + +From F<i_neterrno.U>: + +This variable conditionally defines the C<I_NET_ERRNO> symbol, which +indicates to the C program that <net/errno.h> exists and should +be included. + +=item C<i_netinettcp> + +From F<i_netinettcp.U>: + +This variable conditionally defines the C<I_NETINET_TCP> symbol, +and indicates whether a C program should include <netinet/tcp.h>. + +=item C<i_niin> + +From F<i_niin.U>: + +This variable conditionally defines C<I_NETINET_IN>, which indicates +to the C program that it should include <netinet/in.h>. Otherwise, +you may try <sys/in.h>. + +=item C<i_poll> + +From F<i_poll.U>: + +This variable conditionally defines the C<I_POLL> symbol, and indicates +whether a C program should include <poll.h>. + +=item C<i_prot> + +From F<i_prot.U>: + +This variable conditionally defines the C<I_PROT> symbol, and indicates +whether a C program should include <prot.h>. + +=item C<i_pthread> + +From F<i_pthread.U>: + +This variable conditionally defines the C<I_PTHREAD> symbol, +and indicates whether a C program should include <pthread.h>. + +=item C<i_pwd> + +From F<i_pwd.U>: + +This variable conditionally defines C<I_PWD>, which indicates +to the C program that it should include <pwd.h>. + +=item C<i_rpcsvcdbm> + +From F<i_dbm.U>: + +This variable conditionally defines the C<I_RPCSVC_DBM> symbol, which +indicates to the C program that <rpcsvc/dbm.h> exists and should +be included. Some System V systems might need this instead of <dbm.h>. + +=item C<i_sfio> + +From F<i_sfio.U>: + +This variable conditionally defines the C<I_SFIO> symbol, +and indicates whether a C program should include <sfio.h>. + +=item C<i_sgtty> + +From F<i_termio.U>: + +This variable conditionally defines the C<I_SGTTY> symbol, which +indicates to the C program that it should include <sgtty.h> rather +than <termio.h>. + +=item C<i_shadow> + +From F<i_shadow.U>: + +This variable conditionally defines the C<I_SHADOW> symbol, and indicates +whether a C program should include <shadow.h>. + +=item C<i_socks> + +From F<i_socks.U>: + +This variable conditionally defines the C<I_SOCKS> symbol, and indicates +whether a C program should include <socks.h>. + +=item C<i_stdarg> + +From F<i_varhdr.U>: + +This variable conditionally defines the C<I_STDARG> symbol, which +indicates to the C program that <stdarg.h> exists and should +be included. + +=item C<i_stddef> + +From F<i_stddef.U>: + +This variable conditionally defines the C<I_STDDEF> symbol, which +indicates to the C program that <stddef.h> exists and should +be included. + +=item C<i_stdlib> + +From F<i_stdlib.U>: + +This variable conditionally defines the C<I_STDLIB> symbol, which +indicates to the C program that <stdlib.h> exists and should +be included. + +=item C<i_string> + +From F<i_string.U>: + +This variable conditionally defines the C<I_STRING> symbol, which +indicates that <string.h> should be included rather than <strings.h>. + +=item C<i_sunmath> + +From F<i_sunmath.U>: + +This variable conditionally defines the C<I_SUNMATH> symbol, and indicates +whether a C program should include <sunmath.h>. + +=item C<i_sysaccess> + +From F<i_sysaccess.U>: + +This variable conditionally defines the C<I_SYS_ACCESS> symbol, +and indicates whether a C program should include <sys/access.h>. + +=item C<i_sysdir> + +From F<i_sysdir.U>: + +This variable conditionally defines the C<I_SYS_DIR> symbol, and indicates +whether a C program should include <sys/dir.h>. + +=item C<i_sysfile> + +From F<i_sysfile.U>: + +This variable conditionally defines the C<I_SYS_FILE> symbol, and indicates +whether a C program should include <sys/file.h> to get C<R_OK> and friends. + +=item C<i_sysfilio> + +From F<i_sysioctl.U>: + +This variable conditionally defines the C<I_SYS_FILIO> symbol, which +indicates to the C program that <sys/filio.h> exists and should +be included in preference to <sys/ioctl.h>. + +=item C<i_sysin> + +From F<i_niin.U>: + +This variable conditionally defines C<I_SYS_IN>, which indicates +to the C program that it should include <sys/in.h> instead of +<netinet/in.h>. + +=item C<i_sysioctl> + +From F<i_sysioctl.U>: + +This variable conditionally defines the C<I_SYS_IOCTL> symbol, which +indicates to the C program that <sys/ioctl.h> exists and should +be included. + +=item C<i_syslog> + +From F<i_syslog.U>: + +This variable conditionally defines the C<I_SYSLOG> symbol, +and indicates whether a C program should include <syslog.h>. + +=item C<i_sysmman> + +From F<i_sysmman.U>: + +This variable conditionally defines the C<I_SYS_MMAN> symbol, and +indicates whether a C program should include <sys/mman.h>. + +=item C<i_sysmode> + +From F<i_sysmode.U>: + +This variable conditionally defines the C<I_SYSMODE> symbol, +and indicates whether a C program should include <sys/mode.h>. + +=item C<i_sysmount> + +From F<i_sysmount.U>: + +This variable conditionally defines the C<I_SYSMOUNT> symbol, +and indicates whether a C program should include <sys/mount.h>. + +=item C<i_sysndir> + +From F<i_sysndir.U>: + +This variable conditionally defines the C<I_SYS_NDIR> symbol, and indicates +whether a C program should include <sys/ndir.h>. + +=item C<i_sysparam> + +From F<i_sysparam.U>: + +This variable conditionally defines the C<I_SYS_PARAM> symbol, and indicates +whether a C program should include <sys/param.h>. + +=item C<i_sysresrc> + +From F<i_sysresrc.U>: + +This variable conditionally defines the C<I_SYS_RESOURCE> symbol, +and indicates whether a C program should include <sys/resource.h>. + +=item C<i_syssecrt> + +From F<i_syssecrt.U>: + +This variable conditionally defines the C<I_SYS_SECURITY> symbol, +and indicates whether a C program should include <sys/security.h>. + +=item C<i_sysselct> + +From F<i_sysselct.U>: + +This variable conditionally defines C<I_SYS_SELECT>, which indicates +to the C program that it should include <sys/select.h> in order to +get the definition of struct timeval. + +=item C<i_syssockio> + +From F<i_sysioctl.U>: + +This variable conditionally defines C<I_SYS_SOCKIO> to indicate to the +C program that socket ioctl codes may be found in <sys/sockio.h> +instead of <sys/ioctl.h>. + +=item C<i_sysstat> + +From F<i_sysstat.U>: + +This variable conditionally defines the C<I_SYS_STAT> symbol, +and indicates whether a C program should include <sys/stat.h>. + +=item C<i_sysstatfs> + +From F<i_sysstatfs.U>: + +This variable conditionally defines the C<I_SYSSTATFS> symbol, +and indicates whether a C program should include <sys/statfs.h>. + +=item C<i_sysstatvfs> + +From F<i_sysstatvfs.U>: + +This variable conditionally defines the C<I_SYSSTATVFS> symbol, +and indicates whether a C program should include <sys/statvfs.h>. + +=item C<i_systime> + +From F<i_time.U>: + +This variable conditionally defines C<I_SYS_TIME>, which indicates +to the C program that it should include <sys/time.h>. + +=item C<i_systimek> + +From F<i_time.U>: + +This variable conditionally defines C<I_SYS_TIME_KERNEL>, which +indicates to the C program that it should include <sys/time.h> +with C<KERNEL> defined. + +=item C<i_systimes> + +From F<i_systimes.U>: + +This variable conditionally defines the C<I_SYS_TIMES> symbol, and indicates +whether a C program should include <sys/times.h>. + +=item C<i_systypes> + +From F<i_systypes.U>: + +This variable conditionally defines the C<I_SYS_TYPES> symbol, +and indicates whether a C program should include <sys/types.h>. + +=item C<i_sysuio> + +From F<i_sysuio.U>: + +This variable conditionally defines the C<I_SYSUIO> symbol, and indicates +whether a C program should include <sys/uio.h>. + +=item C<i_sysun> + +From F<i_sysun.U>: + +This variable conditionally defines C<I_SYS_UN>, which indicates +to the C program that it should include <sys/un.h> to get C<UNIX> +domain socket definitions. + +=item C<i_sysutsname> + +From F<i_sysutsname.U>: + +This variable conditionally defines the C<I_SYSUTSNAME> symbol, +and indicates whether a C program should include <sys/utsname.h>. + +=item C<i_sysvfs> + +From F<i_sysvfs.U>: + +This variable conditionally defines the C<I_SYSVFS> symbol, +and indicates whether a C program should include <sys/vfs.h>. + +=item C<i_syswait> + +From F<i_syswait.U>: + +This variable conditionally defines C<I_SYS_WAIT>, which indicates +to the C program that it should include <sys/wait.h>. + +=item C<i_termio> + +From F<i_termio.U>: + +This variable conditionally defines the C<I_TERMIO> symbol, which +indicates to the C program that it should include <termio.h> rather +than <sgtty.h>. + +=item C<i_termios> + +From F<i_termio.U>: + +This variable conditionally defines the C<I_TERMIOS> symbol, which +indicates to the C program that the C<POSIX> <termios.h> file is +to be included. + +=item C<i_time> + +From F<i_time.U>: + +This variable conditionally defines C<I_TIME>, which indicates +to the C program that it should include <time.h>. + +=item C<i_unistd> + +From F<i_unistd.U>: + +This variable conditionally defines the C<I_UNISTD> symbol, and indicates +whether a C program should include <unistd.h>. + +=item C<i_ustat> + +From F<i_ustat.U>: + +This variable conditionally defines the C<I_USTAT> symbol, and indicates +whether a C program should include <ustat.h>. + +=item C<i_utime> + +From F<i_utime.U>: + +This variable conditionally defines the C<I_UTIME> symbol, and indicates +whether a C program should include <utime.h>. + +=item C<i_values> + +From F<i_values.U>: + +This variable conditionally defines the C<I_VALUES> symbol, and indicates +whether a C program may include <values.h> to get symbols like C<MAXLONG> +and friends. + +=item C<i_varargs> + +From F<i_varhdr.U>: + +This variable conditionally defines C<I_VARARGS>, which indicates +to the C program that it should include <varargs.h>. + +=item C<i_varhdr> + +From F<i_varhdr.U>: + +Contains the name of the header to be included to get va_dcl definition. +Typically one of F<varargs.h> or F<stdarg.h>. + +=item C<i_vfork> + +From F<i_vfork.U>: + +This variable conditionally defines the C<I_VFORK> symbol, and indicates +whether a C program should include F<vfork.h>. + +=item C<ignore_versioned_solibs> + +From F<libs.U>: + +This variable should be non-empty if non-versioned shared +libraries (F<libfoo.so.x.y>) are to be ignored (because they +cannot be linked against). + +=item C<inc_version_list> + +From F<inc_version_list.U>: + +This variable specifies the list of subdirectories in over +which F<perl.c>:incpush() and F<lib/lib.pm> will automatically +search when adding directories to @C<INC>. The elements in +the list are separated by spaces. This is only useful +if you have a perl library directory tree structured like the +default one. See C<INSTALL> for how this works. The versioned +site_perl directory was introduced in 5.005, so that is the +lowest possible value. + +=item C<inc_version_list_init> + +From F<inc_version_list.U>: + +This variable holds the same list as inc_version_list, but +each item is enclosed in double quotes and separated by commas, +suitable for use in the C<PERL_INC_VERSION_LIST> initialization. + +=item C<incpath> + +From F<usrinc.U>: + +This variable must preceed the normal include path to get hte +right one, as in F<$F<incpath/usr/include>> or F<$F<incpath/usr/lib>>. +Value can be "" or F</bsd43> on mips. + +=item C<inews> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<installarchlib> + +From F<archlib.U>: + +This variable is really the same as archlibexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installbin> + +From F<bin.U>: + +This variable is the same as binexp unless C<AFS> is running in which case +the user is explicitely prompted for it. This variable should always +be used in your makefiles for maximum portability. + +=item C<installman1dir> + +From F<man1dir.U>: + +This variable is really the same as man1direxp, unless you are using +C<AFS> in which case it points to the read/write location whereas +man1direxp only points to the read-only access location. For extra +portability, you should only use this variable within your makefiles. + +=item C<installman3dir> + +From F<man3dir.U>: + +This variable is really the same as man3direxp, unless you are using +C<AFS> in which case it points to the read/write location whereas +man3direxp only points to the read-only access location. For extra +portability, you should only use this variable within your makefiles. + +=item C<installprefix> + +From F<installprefix.U>: + +This variable holds the name of the directory below which +"make install" will install the package. For most users, this +is the same as prefix. However, it is useful for +installing the software into a different (usually temporary) +location after which it can be bundled up and moved somehow +to the final location specified by prefix. + +=item C<installprefixexp> + +From F<installprefix.U>: + +This variable holds the full absolute path of installprefix +with all F<~>-expansion done. + +=item C<installprivlib> + +From F<privlib.U>: + +This variable is really the same as privlibexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installscript> + +From F<scriptdir.U>: + +This variable is usually the same as scriptdirexp, unless you are on +a system running C<AFS>, in which case they may differ slightly. You +should always use this variable within your makefiles for portability. + +=item C<installsitearch> + +From F<sitearch.U>: + +This variable is really the same as sitearchexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installsitebin> + +From F<sitebin.U>: + +This variable is usually the same as sitebinexp, unless you are on +a system running C<AFS>, in which case they may differ slightly. You +should always use this variable within your makefiles for portability. + +=item C<installsitelib> + +From F<sitelib.U>: + +This variable is really the same as sitelibexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installstyle> + +From F<installstyle.U>: + +This variable describes the C<style> of the perl installation. +This is intended to be useful for tools that need to +manipulate entire perl distributions. Perl itself doesn't use +this to find its libraries -- the library directories are +stored directly in F<Config.pm>. Currently, there are only two +styles: C<lib> and F<lib/perl5>. The default library locations +(e.g. privlib, sitelib) are either F<$prefix/lib> or +F<$prefix/lib/perl5>. The former is useful if $prefix is a +directory dedicated to perl (e.g. F</opt/perl>), while the latter +is useful if $prefix is shared by many packages, e.g. if +$prefix=F</usr/local>. + +This may later be extended to include other information, so +be careful with pattern-matching on the results. + +For compatibility with F<perl5.005> and earlier, the default +setting is based on whether or not $prefix contains the string +C<perl>. + +=item C<installusrbinperl> + +From F<instubperl.U>: + +This variable tells whether Perl should be installed also as +F</usr/bin/perl> in addition to +F<$installbin/perl> + +=item C<installvendorarch> + +From F<vendorarch.U>: + +This variable is really the same as vendorarchexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installvendorbin> + +From F<vendorbin.U>: + +This variable is really the same as vendorbinexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<installvendorlib> + +From F<vendorlib.U>: + +This variable is really the same as vendorlibexp but may differ on +those systems using C<AFS>. For extra portability, only this variable +should be used in makefiles. + +=item C<intsize> + +From F<intsize.U>: + +This variable contains the value of the C<INTSIZE> symbol, which +indicates to the C program how many bytes there are in an int. + +=item C<issymlink> + +From F<issymlink.U>: + +This variable holds the test command to test for a symbolic link +(if they are supported). Typical values include C<test -h> and +C<test -L>. + +=item C<ivdformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<IV> as a signed decimal integer. + +=item C<ivsize> + +From F<perlxv.U>: + +This variable is the size of an C<IV> in bytes. + +=item C<ivtype> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's C<IV>. + +=back + +=head2 k + +=over 4 + +=item C<known_extensions> + +From F<Extensions.U>: + +This variable holds a list of all C<XS> extensions included in +the package. + +=item C<ksh> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=back + +=head2 l + +=over 4 + +=item C<ld> + +From F<dlsrc.U>: + +This variable indicates the program to be used to link +libraries for dynamic loading. On some systems, it is C<ld>. +On C<ELF> systems, it should be $cc. Mostly, we'll try to respect +the hint file setting. + +=item C<lddlflags> + +From F<dlsrc.U>: + +This variable contains any special flags that might need to be +passed to $ld to create a shared library suitable for dynamic +loading. It is up to the makefile to use it. For hpux, it +should be C<-b>. For sunos 4.1, it is empty. + +=item C<ldflags> + +From F<ccflags.U>: + +This variable contains any additional C loader flags desired by +the user. It is up to the Makefile to use this. + +=item C<ldflags_uselargefiles> + +From F<uselfs.U>: + +This variable contains the loader flags needed by large file builds +and added to ldflags by hints files. + +=item C<ldlibpthname> + +From F<libperl.U>: + +This variable holds the name of the shared library +search path, often C<LD_LIBRARY_PATH>. To get an empty +string, the hints file must set this to C<none>. + +=item C<less> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the less program. After Configure runs, +the value is reset to a plain C<less> and is not useful. + +=item C<lib_ext> + +From F<Unix.U>: + +This is an old synonym for _a. + +=item C<libc> + +From F<libc.U>: + +This variable contains the location of the C library. + +=item C<libperl> + +From F<libperl.U>: + +The perl executable is obtained by linking F<perlmain.c> with +libperl, any static extensions (usually just DynaLoader), +and any other libraries needed on this system. libperl +is usually F<libperl.a>, but can also be F<libperl.so.xxx> if +the user wishes to build a perl executable with a shared +library. + +=item C<libpth> + +From F<libpth.U>: + +This variable holds the general path (space-separated) used to find +libraries. It is intended to be used by other units. + +=item C<libs> + +From F<libs.U>: + +This variable holds the additional libraries we want to use. +It is up to the Makefile to deal with it. The list can be empty. + +=item C<libsdirs> + +From F<libs.U>: + +This variable holds the directory names aka dirnames of the libraries +we found and accepted, duplicates are removed. + +=item C<libsfiles> + +From F<libs.U>: + +This variable holds the filenames aka basenames of the libraries +we found and accepted. + +=item C<libsfound> + +From F<libs.U>: + +This variable holds the full pathnames of the libraries +we found and accepted. + +=item C<libspath> + +From F<libs.U>: + +This variable holds the directory names probed for libraries. + +=item C<libswanted> + +From F<Myinit.U>: + +This variable holds a list of all the libraries we want to +search. The order is chosen to pick up the c library +ahead of ucb or bsd libraries for SVR4. + +=item C<libswanted_uselargefiles> + +From F<uselfs.U>: + +This variable contains the libraries needed by large file builds +and added to ldflags by hints files. It is a space separated list +of the library names without the C<lib> prefix or any suffix, just +like F<libswanted.>. + +=item C<line> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<lint> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<lkflags> + +From F<ccflags.U>: + +This variable contains any additional C partial linker flags desired by +the user. It is up to the Makefile to use this. + +=item C<ln> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the ln program. After Configure runs, +the value is reset to a plain C<ln> and is not useful. + +=item C<lns> + +From F<lns.U>: + +This variable holds the name of the command to make +symbolic links (if they are supported). It can be used +in the Makefile. It is either C<ln -s> or C<ln> + +=item C<localtime_r_proto> + +From F<d_localtime_r.U>: + +This variable encodes the prototype of localtime_r. +It is zero if d_localtime_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_localtime_r +is defined. + +=item C<locincpth> + +From F<ccflags.U>: + +This variable contains a list of additional directories to be +searched by the compiler. The appropriate C<-I> directives will +be added to ccflags. This is intended to simplify setting +local directories from the Configure command line. +It's not much, but it parallels the loclibpth stuff in F<libpth.U>. + +=item C<loclibpth> + +From F<libpth.U>: + +This variable holds the paths (space-separated) used to find local +libraries. It is prepended to libpth, and is intended to be easily +set from the command line. + +=item C<longdblsize> + +From F<d_longdbl.U>: + +This variable contains the value of the C<LONG_DOUBLESIZE> symbol, which +indicates to the C program how many bytes there are in a long double, +if this system supports long doubles. + +=item C<longlongsize> + +From F<d_longlong.U>: + +This variable contains the value of the C<LONGLONGSIZE> symbol, which +indicates to the C program how many bytes there are in a long long, +if this system supports long long. + +=item C<longsize> + +From F<intsize.U>: + +This variable contains the value of the C<LONGSIZE> symbol, which +indicates to the C program how many bytes there are in a long. + +=item C<lp> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<lpr> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<ls> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the ls program. After Configure runs, +the value is reset to a plain C<ls> and is not useful. + +=item C<lseeksize> + +From F<lseektype.U>: + +This variable defines lseektype to be something like off_t, long, +or whatever type is used to declare lseek offset's type in the +kernel (which also appears to be lseek's return type). + +=item C<lseektype> + +From F<lseektype.U>: + +This variable defines lseektype to be something like off_t, long, +or whatever type is used to declare lseek offset's type in the +kernel (which also appears to be lseek's return type). + +=back + +=head2 m + +=over 4 + +=item C<mail> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<mailx> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<make> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the make program. After Configure runs, +the value is reset to a plain C<make> and is not useful. + +=item C<make_set_make> + +From F<make.U>: + +Some versions of C<make> set the variable C<MAKE>. Others do not. +This variable contains the string to be included in F<Makefile.SH> +so that C<MAKE> is set if needed, and not if not needed. +Possible values are: +make_set_make=C<#> # If your make program handles this for you, +make_set_make=C<MAKE=$make> # if it doesn't. +I used a comment character so that we can distinguish a +C<set> value (from a previous F<config.sh> or Configure C<-D> option) +from an uncomputed value. + +=item C<mallocobj> + +From F<mallocsrc.U>: + +This variable contains the name of the F<malloc.o> that this package +generates, if that F<malloc.o> is preferred over the system malloc. +Otherwise the value is null. This variable is intended for generating +Makefiles. See mallocsrc. + +=item C<mallocsrc> + +From F<mallocsrc.U>: + +This variable contains the name of the F<malloc.c> that comes with +the package, if that F<malloc.c> is preferred over the system malloc. +Otherwise the value is null. This variable is intended for generating +Makefiles. + +=item C<malloctype> + +From F<mallocsrc.U>: + +This variable contains the kind of ptr returned by malloc and realloc. + +=item C<man1dir> + +From F<man1dir.U>: + +This variable contains the name of the directory in which manual +source pages are to be put. It is the responsibility of the +F<Makefile.SH> to get the value of this into the proper command. +You must be prepared to do the F<~name> expansion yourself. + +=item C<man1direxp> + +From F<man1dir.U>: + +This variable is the same as the man1dir variable, but is filename +expanded at configuration time, for convenient use in makefiles. + +=item C<man1ext> + +From F<man1dir.U>: + +This variable contains the extension that the manual page should +have: one of C<n>, C<l>, or C<1>. The Makefile must supply the F<.>. +See man1dir. + +=item C<man3dir> + +From F<man3dir.U>: + +This variable contains the name of the directory in which manual +source pages are to be put. It is the responsibility of the +F<Makefile.SH> to get the value of this into the proper command. +You must be prepared to do the F<~name> expansion yourself. + +=item C<man3direxp> + +From F<man3dir.U>: + +This variable is the same as the man3dir variable, but is filename +expanded at configuration time, for convenient use in makefiles. + +=item C<man3ext> + +From F<man3dir.U>: + +This variable contains the extension that the manual page should +have: one of C<n>, C<l>, or C<3>. The Makefile must supply the F<.>. +See man3dir. + +=back + +=head2 M + +=over 4 + +=item C<Mcc> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the Mcc program. After Configure runs, +the value is reset to a plain C<Mcc> and is not useful. + +=item C<mips_type> + +From F<usrinc.U>: + +This variable holds the environment type for the mips system. +Possible values are "BSD 4.3" and "System V". + +=item C<mkdir> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the mkdir program. After Configure runs, +the value is reset to a plain C<mkdir> and is not useful. + +=item C<mmaptype> + +From F<d_mmap.U>: + +This symbol contains the type of pointer returned by mmap() +(and simultaneously the type of the first argument). +It can be C<void *> or C<caddr_t>. + +=item C<modetype> + +From F<modetype.U>: + +This variable defines modetype to be something like mode_t, +int, unsigned short, or whatever type is used to declare file +modes for system calls. + +=item C<more> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the more program. After Configure runs, +the value is reset to a plain C<more> and is not useful. + +=item C<multiarch> + +From F<multiarch.U>: + +This variable conditionally defines the C<MULTIARCH> symbol +which signifies the presence of multiplatform files. +This is normally set by hints files. + +=item C<mv> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<myarchname> + +From F<archname.U>: + +This variable holds the architecture name computed by Configure in +a previous run. It is not intended to be perused by any user and +should never be set in a hint file. + +=item C<mydomain> + +From F<myhostname.U>: + +This variable contains the eventual value of the C<MYDOMAIN> symbol, +which is the domain of the host the program is going to run on. +The domain must be appended to myhostname to form a complete host name. +The dot comes with mydomain, and need not be supplied by the program. + +=item C<myhostname> + +From F<myhostname.U>: + +This variable contains the eventual value of the C<MYHOSTNAME> symbol, +which is the name of the host the program is going to run on. +The domain is not kept with hostname, but must be gotten from mydomain. +The dot comes with mydomain, and need not be supplied by the program. + +=item C<myuname> + +From F<Oldconfig.U>: + +The output of C<uname -a> if available, otherwise the hostname. On Xenix, +pseudo variables assignments in the output are stripped, thank you. The +whole thing is then lower-cased. + +=back + +=head2 n + +=over 4 + +=item C<n> + +From F<n.U>: + +This variable contains the C<-n> flag if that is what causes the echo +command to suppress newline. Otherwise it is null. Correct usage is +$echo $n "prompt for a question: $c". + +=item C<need_va_copy> + +From F<need_va_copy.U>: + +This symbol, if defined, indicates that the system stores +the variable argument list datatype, va_list, in a format +that cannot be copied by simple assignment, so that some +other means must be used when copying is required. +As such systems vary in their provision (or non-provision) +of copying mechanisms, F<handy.h> defines a platform- +C<independent> macro, Perl_va_copy(src, dst), to do the job. + +=item C<netdb_hlen_type> + +From F<netdbtype.U>: + +This variable holds the type used for the 2nd argument to +gethostbyaddr(). Usually, this is int or size_t or unsigned. +This is only useful if you have gethostbyaddr(), naturally. + +=item C<netdb_host_type> + +From F<netdbtype.U>: + +This variable holds the type used for the 1st argument to +gethostbyaddr(). Usually, this is char * or void *, possibly +with or without a const prefix. +This is only useful if you have gethostbyaddr(), naturally. + +=item C<netdb_name_type> + +From F<netdbtype.U>: + +This variable holds the type used for the argument to +gethostbyname(). Usually, this is char * or const char *. +This is only useful if you have gethostbyname(), naturally. + +=item C<netdb_net_type> + +From F<netdbtype.U>: + +This variable holds the type used for the 1st argument to +getnetbyaddr(). Usually, this is int or long. +This is only useful if you have getnetbyaddr(), naturally. + +=item C<nm> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the nm program. After Configure runs, +the value is reset to a plain C<nm> and is not useful. + +=item C<nm_opt> + +From F<usenm.U>: + +This variable holds the options that may be necessary for nm. + +=item C<nm_so_opt> + +From F<usenm.U>: + +This variable holds the options that may be necessary for nm +to work on a shared library but that can not be used on an +archive library. Currently, this is only used by Linux, where +nm --dynamic is *required* to get symbols from an C<ELF> library which +has been stripped, but nm --dynamic is *fatal* on an archive library. +Maybe Linux should just always set usenm=false. + +=item C<nonxs_ext> + +From F<Extensions.U>: + +This variable holds a list of all non-xs extensions included +in the package. All of them will be built. + +=item C<nroff> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the nroff program. After Configure runs, +the value is reset to a plain C<nroff> and is not useful. + +=item C<nv_preserves_uv_bits> + +From F<perlxv.U>: + +This variable indicates how many of bits type uvtype +a variable nvtype can preserve. + +=item C<nveformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<NV> using %e-ish floating point format. + +=item C<nvEUformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<NV> using %E-ish floating point format. + +=item C<nvfformat> + +From F<perlxvf.U>: + +This variable confains the format string used for printing +a Perl C<NV> using %f-ish floating point format. + +=item C<nvFUformat> + +From F<perlxvf.U>: + +This variable confains the format string used for printing +a Perl C<NV> using %F-ish floating point format. + +=item C<nvgformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<NV> using %g-ish floating point format. + +=item C<nvGUformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<NV> using %G-ish floating point format. + +=item C<nvsize> + +From F<perlxv.U>: + +This variable is the size of an C<NV> in bytes. + +=item C<nvtype> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's C<NV>. + +=back + +=head2 o + +=over 4 + +=item C<o_nonblock> + +From F<nblock_io.U>: + +This variable bears the symbol value to be used during open() or fcntl() +to turn on non-blocking I/O for a file descriptor. If you wish to switch +between blocking and non-blocking, you may try ioctl(C<FIOSNBIO>) instead, +but that is only supported by some devices. + +=item C<obj_ext> + +From F<Unix.U>: + +This is an old synonym for _o. + +=item C<old_pthread_create_joinable> + +From F<d_pthrattrj.U>: + +This variable defines the constant to use for creating joinable +(aka undetached) pthreads. Unused if F<pthread.h> defines +C<PTHREAD_CREATE_JOINABLE>. If used, possible values are +C<PTHREAD_CREATE_UNDETACHED> and C<__UNDETACHED>. + +=item C<optimize> + +From F<ccflags.U>: + +This variable contains any F<optimizer/debugger> flag that should be used. +It is up to the Makefile to use it. + +=item C<orderlib> + +From F<orderlib.U>: + +This variable is C<true> if the components of libraries must be ordered +(with `lorder $* | tsort`) before placing them in an archive. Set to +C<false> if ranlib or ar can generate random libraries. + +=item C<osname> + +From F<Oldconfig.U>: + +This variable contains the operating system name (e.g. sunos, +solaris, hpux, etc.). It can be useful later on for setting +defaults. Any spaces are replaced with underscores. It is set +to a null string if we can't figure it out. + +=item C<osvers> + +From F<Oldconfig.U>: + +This variable contains the operating system version (e.g. +4.1.3, 5.2, etc.). It is primarily used for helping select +an appropriate hints file, but might be useful elsewhere for +setting defaults. It is set to '' if we can't figure it out. +We try to be flexible about how much of the version number +to keep, e.g. if 4.1.1, 4.1.2, and 4.1.3 are essentially the +same for this package, hints files might just be F<os_4.0> or +F<os_4.1>, etc., not keeping separate files for each little release. + +=item C<otherlibdirs> + +From F<otherlibdirs.U>: + +This variable contains a colon-separated set of paths for the perl +binary to search for additional library files or modules. +These directories will be tacked to the end of @C<INC>. +Perl will automatically search below each path for version- +and architecture-specific directories. See inc_version_list +for more details. +A value of C< > means C<none> and is used to preserve this value +for the next run through Configure. + +=back + +=head2 p + +=over 4 + +=item C<package> + +From F<package.U>: + +This variable contains the name of the package being constructed. +It is primarily intended for the use of later Configure units. + +=item C<pager> + +From F<pager.U>: + +This variable contains the name of the preferred pager on the system. +Usual values are (the full pathnames of) more, less, pg, or cat. + +=item C<passcat> + +From F<nis.U>: + +This variable contains a command that produces the text of the +F</etc/passwd> file. This is normally "cat F</etc/passwd>", but can be +"ypcat passwd" when C<NIS> is used. +On some systems, such as os390, there may be no equivalent +command, in which case this variable is unset. + +=item C<patchlevel> + +From F<patchlevel.U>: + +The patchlevel level of this package. +The value of patchlevel comes from the F<patchlevel.h> file. +In a version number such as 5.6.1, this is the C<6>. +In F<patchlevel.h>, this is referred to as C<PERL_VERSION>. + +=item C<path_sep> + +From F<Unix.U>: + +This is an old synonym for p_ in F<Head.U>, the character +used to separate elements in the command shell search C<PATH>. + +=item C<perl5> + +From F<perl5.U>: + +This variable contains the full path (if any) to a previously +installed F<perl5.005> or later suitable for running the script +to determine inc_version_list. + +=item C<perl> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<perl_patchlevel> + +From F<patchlevel.U>: + +This is the Perl patch level, a numeric change identifier, +as defined by whichever source code maintenance system +is used to maintain the patches; currently Perforce. +It does not correlate with the Perl version numbers or +the maintenance versus development dichotomy except +by also being increasing. + +=back + +=head2 P + +=over 4 + +=item C<PERL_REVISION> + +From F<Oldsyms.U>: + +In a Perl version number such as 5.6.2, this is the 5. +This value is manually set in F<patchlevel.h> + +=item C<PERL_SUBVERSION> + +From F<Oldsyms.U>: + +In a Perl version number such as 5.6.2, this is the 2. +Values greater than 50 represent potentially unstable +development subversions. +This value is manually set in F<patchlevel.h> + +=item C<PERL_VERSION> + +From F<Oldsyms.U>: + +In a Perl version number such as 5.6.2, this is the 6. +This value is manually set in F<patchlevel.h> + +=item C<perladmin> + +From F<perladmin.U>: + +Electronic mail address of the perl5 administrator. + +=item C<perllibs> + +From F<End.U>: + +The list of libraries needed by Perl only (any libraries needed +by extensions only will by dropped, if using dynamic loading). + +=item C<perlpath> + +From F<perlpath.U>: + +This variable contains the eventual value of the C<PERLPATH> symbol, +which contains the name of the perl interpreter to be used in +shell scripts and in the "eval C<exec>" idiom. This variable is +not necessarily the pathname of the file containing the perl +interpreter; you must append the executable extension (_exe) if +it is not already present. Note that Perl code that runs during +the Perl build process cannot reference this variable, as Perl +may not have been installed, or even if installed, may be a +different version of Perl. + +=item C<pg> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the pg program. After Configure runs, +the value is reset to a plain C<pg> and is not useful. + +=item C<phostname> + +From F<myhostname.U>: + +This variable contains the eventual value of the C<PHOSTNAME> symbol, +which is a command that can be fed to popen() to get the host name. +The program should probably not presume that the domain is or isn't +there already. + +=item C<pidtype> + +From F<pidtype.U>: + +This variable defines C<PIDTYPE> to be something like pid_t, int, +ushort, or whatever type is used to declare process ids in the kernel. + +=item C<plibpth> + +From F<libpth.U>: + +Holds the private path used by Configure to find out the libraries. +Its value is prepend to libpth. This variable takes care of special +machines, like the mips. Usually, it should be empty. + +=item C<pm_apiversion> + +From F<xs_apiversion.U>: + +This variable contains the version of the oldest perl +compatible with the present perl. (That is, pure perl modules +written for $pm_apiversion will still work for the current +version). F<perl.c>:incpush() and F<lib/lib.pm> will automatically +search in $sitelib for older directories across major versions +back to pm_apiversion. This is only useful if you have a perl +library directory tree structured like the default one. The +versioned site_perl library was introduced in 5.005, so that's +the default setting for this variable. It's hard to imagine +it changing before Perl6. It is included here for symmetry +with xs_apiveprsion -- the searching algorithms will +(presumably) be similar. +See the C<INSTALL> file for how this works. + +=item C<pmake> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<pr> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<prefix> + +From F<prefix.U>: + +This variable holds the name of the directory below which the +user will install the package. Usually, this is F</usr/local>, and +executables go in F</usr/local/bin>, library stuff in F</usr/local/lib>, +man pages in F</usr/local/man>, etc. It is only used to set defaults +for things in F<bin.U>, F<mansrc.U>, F<privlib.U>, or F<scriptdir.U>. + +=item C<prefixexp> + +From F<prefix.U>: + +This variable holds the full absolute path of the directory below +which the user will install the package. Derived from prefix. + +=item C<privlib> + +From F<privlib.U>: + +This variable contains the eventual value of the C<PRIVLIB> symbol, +which is the name of the private library for this package. It may +have a F<~> on the front. It is up to the makefile to eventually create +this directory while performing installation (with F<~> substitution). + +=item C<privlibexp> + +From F<privlib.U>: + +This variable is the F<~name> expanded version of privlib, so that you +may use it directly in Makefiles or shell scripts. + +=item C<procselfexe> + +From F<d_procselfexe.U>: + +If d_procselfexe is defined, $procselfexe is the filename +of the symbolic link pointing to the absolute pathname of +the executing program. + +=item C<prototype> + +From F<prototype.U>: + +This variable holds the eventual value of C<CAN_PROTOTYPE>, which +indicates the C compiler can handle funciton prototypes. + +=item C<ptrsize> + +From F<ptrsize.U>: + +This variable contains the value of the C<PTRSIZE> symbol, which +indicates to the C program how many bytes there are in a pointer. + +=back + +=head2 q + +=over 4 + +=item C<quadkind> + +From F<quadtype.U>: + +This variable, if defined, encodes the type of a quad: +1 = int, 2 = long, 3 = long long, 4 = int64_t. + +=item C<quadtype> + +From F<quadtype.U>: + +This variable defines Quad_t to be something like long, int, +long long, int64_t, or whatever type is used for 64-bit integers. + +=back + +=head2 r + +=over 4 + +=item C<randbits> + +From F<randfunc.U>: + +Indicates how many bits are produced by the function used to +generate normalized random numbers. + +=item C<randfunc> + +From F<randfunc.U>: + +Indicates the name of the random number function to use. +Values include drand48, random, and rand. In C programs, +the C<Drand01> macro is defined to generate uniformly distributed +random numbers over the range [0., 1.[ (see drand01 and nrand). + +=item C<random_r_proto> + +From F<d_random_r.U>: + +This variable encodes the prototype of random_r. +It is zero if d_random_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_random_r +is defined. + +=item C<randseedtype> + +From F<randfunc.U>: + +Indicates the type of the argument of the seedfunc. + +=item C<ranlib> + +From F<orderlib.U>: + +This variable is set to the pathname of the ranlib program, if it is +needed to generate random libraries. Set to C<:> if ar can generate +random libraries or if random libraries are not supported + +=item C<rd_nodata> + +From F<nblock_io.U>: + +This variable holds the return code from read() when no data is +present. It should be -1, but some systems return 0 when C<O_NDELAY> is +used, which is a shame because you cannot make the difference between +no data and an F<EOF.>. Sigh! + +=item C<readdir64_r_proto> + +From F<d_readdir64_r.U>: + +This variable encodes the prototype of readdir64_r. +It is zero if d_readdir64_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_readdir64_r +is defined. + +=item C<readdir_r_proto> + +From F<d_readdir_r.U>: + +This variable encodes the prototype of readdir_r. +It is zero if d_readdir_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_readdir_r +is defined. + +=item C<revision> + +From F<patchlevel.U>: + +The value of revision comes from the F<patchlevel.h> file. +In a version number such as 5.6.1, this is the C<5>. +In F<patchlevel.h>, this is referred to as C<PERL_REVISION>. + +=item C<rm> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the rm program. After Configure runs, +the value is reset to a plain C<rm> and is not useful. + +=item C<rmail> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<run> + +From F<Cross.U>: + +This variable contains the command used by Configure +to copy and execute a cross-compiled executable in the +target host. Useful and available only during Perl build. +Empty string '' if not cross-compiling. + +=item C<runnm> + +From F<usenm.U>: + +This variable contains C<true> or C<false> depending whether the +nm extraction should be performed or not, according to the value +of usenm and the flags on the Configure command line. + +=back + +=head2 s + +=over 4 + +=item C<sched_yield> + +From F<d_pthread_y.U>: + +This variable defines the way to yield the execution +of the current thread. + +=item C<scriptdir> + +From F<scriptdir.U>: + +This variable holds the name of the directory in which the user wants +to put publicly scripts for the package in question. It is either +the same directory as for binaries, or a special one that can be +mounted across different architectures, like F</usr/share>. Programs +must be prepared to deal with F<~name> expansion. + +=item C<scriptdirexp> + +From F<scriptdir.U>: + +This variable is the same as scriptdir, but is filename expanded +at configuration time, for programs not wanting to bother with it. + +=item C<sed> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the sed program. After Configure runs, +the value is reset to a plain C<sed> and is not useful. + +=item C<seedfunc> + +From F<randfunc.U>: + +Indicates the random number generating seed function. +Values include srand48, srandom, and srand. + +=item C<selectminbits> + +From F<selectminbits.U>: + +This variable holds the minimum number of bits operated by select. +That is, if you do select(n, ...), how many bits at least will be +cleared in the masks if some activity is detected. Usually this +is either n or 32*ceil(F<n/32>), especially many little-endians do +the latter. This is only useful if you have select(), naturally. + +=item C<selecttype> + +From F<selecttype.U>: + +This variable holds the type used for the 2nd, 3rd, and 4th +arguments to select. Usually, this is C<fd_set *>, if C<HAS_FD_SET> +is defined, and C<int *> otherwise. This is only useful if you +have select(), naturally. + +=item C<sendmail> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<setgrent_r_proto> + +From F<d_setgrent_r.U>: + +This variable encodes the prototype of setgrent_r. +It is zero if d_setgrent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setgrent_r +is defined. + +=item C<sethostent_r_proto> + +From F<d_sethostent_r.U>: + +This variable encodes the prototype of sethostent_r. +It is zero if d_sethostent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_sethostent_r +is defined. + +=item C<setlocale_r_proto> + +From F<d_setlocale_r.U>: + +This variable encodes the prototype of setlocale_r. +It is zero if d_setlocale_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setlocale_r +is defined. + +=item C<setnetent_r_proto> + +From F<d_setnetent_r.U>: + +This variable encodes the prototype of setnetent_r. +It is zero if d_setnetent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setnetent_r +is defined. + +=item C<setprotoent_r_proto> + +From F<d_setprotoent_r.U>: + +This variable encodes the prototype of setprotoent_r. +It is zero if d_setprotoent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setprotoent_r +is defined. + +=item C<setpwent_r_proto> + +From F<d_setpwent_r.U>: + +This variable encodes the prototype of setpwent_r. +It is zero if d_setpwent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setpwent_r +is defined. + +=item C<setservent_r_proto> + +From F<d_setservent_r.U>: + +This variable encodes the prototype of setservent_r. +It is zero if d_setservent_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_setservent_r +is defined. + +=item C<sh> + +From F<sh.U>: + +This variable contains the full pathname of the shell used +on this system to execute Bourne shell scripts. Usually, this will be +F</bin/sh>, though it's possible that some systems will have F</bin/ksh>, +F</bin/pdksh>, F</bin/ash>, F</bin/bash>, or even something such as +D:F</bin/sh.exe>. +This unit comes before F<Options.U>, so you can't set sh with a C<-D> +option, though you can override this (and startsh) +with C<-O -Dsh=F</bin/whatever> -Dstartsh=whatever> + +=item C<shar> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<sharpbang> + +From F<spitshell.U>: + +This variable contains the string #! if this system supports that +construct. + +=item C<shmattype> + +From F<d_shmat.U>: + +This symbol contains the type of pointer returned by shmat(). +It can be C<void *> or C<char *>. + +=item C<shortsize> + +From F<intsize.U>: + +This variable contains the value of the C<SHORTSIZE> symbol which +indicates to the C program how many bytes there are in a short. + +=item C<shrpenv> + +From F<libperl.U>: + +If the user builds a shared F<libperl.so>, then we need to tell the +C<perl> executable where it will be able to find the installed F<libperl.so>. +One way to do this on some systems is to set the environment variable +C<LD_RUN_PATH> to the directory that will be the final location of the +shared F<libperl.so>. The makefile can use this with something like +$shrpenv $(C<CC>) -o perl F<perlmain.o> $libperl $libs +Typical values are +shrpenv="env C<LD_RUN_PATH>=F<$archlibexp/C<CORE>>" +or +shrpenv='' +See the main perl F<Makefile.SH> for actual working usage. +Alternatively, we might be able to use a command line option such +as -R F<$archlibexp/C<CORE>> (Solaris) or -Wl,-rpath +F<$archlibexp/C<CORE>> (Linux). + +=item C<shsharp> + +From F<spitshell.U>: + +This variable tells further Configure units whether your sh can +handle # comments. + +=item C<sig_count> + +From F<sig_name.U>: + +This variable holds a number larger than the largest valid +signal number. This is usually the same as the C<NSIG> macro. + +=item C<sig_name> + +From F<sig_name.U>: + +This variable holds the signal names, space separated. The leading +C<SIG> in signal name is removed. A C<ZERO> is prepended to the +list. This is currently not used. + +=item C<sig_name_init> + +From F<sig_name.U>: + +This variable holds the signal names, enclosed in double quotes and +separated by commas, suitable for use in the C<SIG_NAME> definition +below. A C<ZERO> is prepended to the list, and the list is +terminated with a plain 0. The leading C<SIG> in signal names +is removed. See sig_num. + +=item C<sig_num> + +From F<sig_name.U>: + +This variable holds the signal numbers, space separated. A C<ZERO> is +prepended to the list (corresponding to the fake C<SIGZERO>), and +the list is terminated with a 0. Those numbers correspond to +the value of the signal listed in the same place within the +sig_name list. + +=item C<sig_num_init> + +From F<sig_name.U>: + +This variable holds the signal numbers, enclosed in double quotes and +separated by commas, suitable for use in the C<SIG_NUM> definition +below. A C<ZERO> is prepended to the list, and the list is +terminated with a plain 0. + +=item C<sig_size> + +From F<sig_name.U>: + +This variable contains the number of elements of the sig_name +and sig_num arrays, excluding the final C<NULL> entry. + +=item C<signal_t> + +From F<d_voidsig.U>: + +This variable holds the type of the signal handler (void or int). + +=item C<sitearch> + +From F<sitearch.U>: + +This variable contains the eventual value of the C<SITEARCH> symbol, +which is the name of the private library for this package. It may +have a F<~> on the front. It is up to the makefile to eventually create +this directory while performing installation (with F<~> substitution). +The standard distribution will put nothing in this directory. +After perl has been installed, users may install their own local +architecture-dependent modules in this directory with +MakeMaker F<Makefile.PL> +or equivalent. See C<INSTALL> for details. + +=item C<sitearchexp> + +From F<sitearch.U>: + +This variable is the F<~name> expanded version of sitearch, so that you +may use it directly in Makefiles or shell scripts. + +=item C<sitebin> + +From F<sitebin.U>: + +This variable holds the name of the directory in which the user wants +to put add-on publicly executable files for the package in question. It +is most often a local directory such as F</usr/local/bin>. Programs using +this variable must be prepared to deal with F<~name> substitution. +The standard distribution will put nothing in this directory. +After perl has been installed, users may install their own local +executables in this directory with +MakeMaker F<Makefile.PL> +or equivalent. See C<INSTALL> for details. + +=item C<sitebinexp> + +From F<sitebin.U>: + +This is the same as the sitebin variable, but is filename expanded at +configuration time, for use in your makefiles. + +=item C<sitelib> + +From F<sitelib.U>: + +This variable contains the eventual value of the C<SITELIB> symbol, +which is the name of the private library for this package. It may +have a F<~> on the front. It is up to the makefile to eventually create +this directory while performing installation (with F<~> substitution). +The standard distribution will put nothing in this directory. +After perl has been installed, users may install their own local +architecture-independent modules in this directory with +MakeMaker F<Makefile.PL> +or equivalent. See C<INSTALL> for details. + +=item C<sitelib_stem> + +From F<sitelib.U>: + +This variable is $sitelibexp with any trailing version-specific component +removed. The elements in inc_version_list (F<inc_version_list.U>) can +be tacked onto this variable to generate a list of directories to search. + +=item C<sitelibexp> + +From F<sitelib.U>: + +This variable is the F<~name> expanded version of sitelib, so that you +may use it directly in Makefiles or shell scripts. + +=item C<siteprefix> + +From F<siteprefix.U>: + +This variable holds the full absolute path of the directory below +which the user will install add-on packages. +See C<INSTALL> for usage and examples. + +=item C<siteprefixexp> + +From F<siteprefix.U>: + +This variable holds the full absolute path of the directory below +which the user will install add-on packages. Derived from siteprefix. + +=item C<sizesize> + +From F<sizesize.U>: + +This variable contains the size of a sizetype in bytes. + +=item C<sizetype> + +From F<sizetype.U>: + +This variable defines sizetype to be something like size_t, +unsigned long, or whatever type is used to declare length +parameters for string functions. + +=item C<sleep> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<smail> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<so> + +From F<so.U>: + +This variable holds the extension used to identify shared libraries +(also known as shared objects) on the system. Usually set to C<so>. + +=item C<sockethdr> + +From F<d_socket.U>: + +This variable has any cpp C<-I> flags needed for socket support. + +=item C<socketlib> + +From F<d_socket.U>: + +This variable has the names of any libraries needed for socket support. + +=item C<socksizetype> + +From F<socksizetype.U>: + +This variable holds the type used for the size argument +for various socket calls like accept. Usual values include +socklen_t, size_t, and int. + +=item C<sort> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the sort program. After Configure runs, +the value is reset to a plain C<sort> and is not useful. + +=item C<spackage> + +From F<package.U>: + +This variable contains the name of the package being constructed, +with the first letter uppercased, F<i.e>. suitable for starting +sentences. + +=item C<spitshell> + +From F<spitshell.U>: + +This variable contains the command necessary to spit out a runnable +shell on this system. It is either cat or a grep C<-v> for # comments. + +=item C<sPRId64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit decimal numbers (format C<d>) for output. + +=item C<sPRIeldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<e>) for output. + +=item C<sPRIEUldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<E>) for output. +The C<U> in the name is to separate this from sPRIeldbl so that even +case-blind systems can see the difference. + +=item C<sPRIfldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<f>) for output. + +=item C<sPRIFUldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<F>) for output. +The C<U> in the name is to separate this from sPRIfldbl so that even +case-blind systems can see the difference. + +=item C<sPRIgldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<g>) for output. + +=item C<sPRIGUldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<G>) for output. +The C<U> in the name is to separate this from sPRIgldbl so that even +case-blind systems can see the difference. + +=item C<sPRIi64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit decimal numbers (format C<i>) for output. + +=item C<sPRIo64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit octal numbers (format C<o>) for output. + +=item C<sPRIu64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit unsigned decimal numbers (format C<u>) for output. + +=item C<sPRIx64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit hexadecimal numbers (format C<x>) for output. + +=item C<sPRIXU64> + +From F<quadfio.U>: + +This variable, if defined, contains the string used by stdio to +format 64-bit hExADECimAl numbers (format C<X>) for output. +The C<U> in the name is to separate this from sPRIx64 so that even +case-blind systems can see the difference. + +=item C<srand48_r_proto> + +From F<d_srand48_r.U>: + +This variable encodes the prototype of srand48_r. +It is zero if d_srand48_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_srand48_r +is defined. + +=item C<srandom_r_proto> + +From F<d_srandom_r.U>: + +This variable encodes the prototype of srandom_r. +It is zero if d_srandom_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_srandom_r +is defined. + +=item C<src> + +From F<src.U>: + +This variable holds the path to the package source. It is up to +the Makefile to use this variable and set C<VPATH> accordingly to +find the sources remotely. + +=item C<sSCNfldbl> + +From F<longdblfio.U>: + +This variable, if defined, contains the string used by stdio to +format long doubles (format C<f>) for input. + +=item C<ssizetype> + +From F<ssizetype.U>: + +This variable defines ssizetype to be something like ssize_t, +long or int. It is used by functions that return a count +of bytes or an error condition. It must be a signed type. +We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). + +=item C<startperl> + +From F<startperl.U>: + +This variable contains the string to put on the front of a perl +script to make sure (hopefully) that it runs with perl and not some +shell. Of course, that leading line must be followed by the classical +perl idiom: +eval 'exec perl -S $0 ${1+C<$@>}' +if $running_under_some_shell; +to guarantee perl startup should the shell execute the script. Note +that this magic incatation is not understood by csh. + +=item C<startsh> + +From F<startsh.U>: + +This variable contains the string to put on the front of a shell +script to make sure (hopefully) that it runs with sh and not some +other shell. + +=item C<static_ext> + +From F<Extensions.U>: + +This variable holds a list of C<XS> extension files we want to +link statically into the package. It is used by Makefile. + +=item C<stdchar> + +From F<stdchar.U>: + +This variable conditionally defines C<STDCHAR> to be the type of char +used in F<stdio.h>. It has the values "unsigned char" or C<char>. + +=item C<stdio_base> + +From F<d_stdstdio.U>: + +This variable defines how, given a C<FILE> pointer, fp, to access the +_base field (or equivalent) of F<stdio.h>'s C<FILE> structure. This will +be used to define the macro FILE_base(fp). + +=item C<stdio_bufsiz> + +From F<d_stdstdio.U>: + +This variable defines how, given a C<FILE> pointer, fp, to determine +the number of bytes store in the I/O buffer pointer to by the +_base field (or equivalent) of F<stdio.h>'s C<FILE> structure. This will +be used to define the macro FILE_bufsiz(fp). + +=item C<stdio_cnt> + +From F<d_stdstdio.U>: + +This variable defines how, given a C<FILE> pointer, fp, to access the +_cnt field (or equivalent) of F<stdio.h>'s C<FILE> structure. This will +be used to define the macro FILE_cnt(fp). + +=item C<stdio_filbuf> + +From F<d_stdstdio.U>: + +This variable defines how, given a C<FILE> pointer, fp, to tell +stdio to refill its internal buffers (?). This will +be used to define the macro FILE_filbuf(fp). + +=item C<stdio_ptr> + +From F<d_stdstdio.U>: + +This variable defines how, given a C<FILE> pointer, fp, to access the +_ptr field (or equivalent) of F<stdio.h>'s C<FILE> structure. This will +be used to define the macro FILE_ptr(fp). + +=item C<stdio_stream_array> + +From F<stdio_streams.U>: + +This variable tells the name of the array holding the stdio streams. +Usual values include _iob, __iob, and __sF. + +=item C<strerror_r_proto> + +From F<d_strerror_r.U>: + +This variable encodes the prototype of strerror_r. +It is zero if d_strerror_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_strerror_r +is defined. + +=item C<strings> + +From F<i_string.U>: + +This variable holds the full path of the string header that will be +used. Typically F</usr/include/string.h> or F</usr/include/strings.h>. + +=item C<submit> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<subversion> + +From F<patchlevel.U>: + +The subversion level of this package. +The value of subversion comes from the F<patchlevel.h> file. +In a version number such as 5.6.1, this is the C<1>. +In F<patchlevel.h>, this is referred to as C<PERL_SUBVERSION>. +This is unique to perl. + +=item C<sysman> + +From F<sysman.U>: + +This variable holds the place where the manual is located on this +system. It is not the place where the user wants to put his manual +pages. Rather it is the place where Configure may look to find manual +for unix commands (section 1 of the manual usually). See mansrc. + +=back + +=head2 t + +=over 4 + +=item C<tail> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<tar> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<targetarch> + +From F<Cross.U>: + +If cross-compiling, this variable contains the target architecture. +If not, this will be empty. + +=item C<tbl> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<tee> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<test> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the test program. After Configure runs, +the value is reset to a plain C<test> and is not useful. + +=item C<timeincl> + +From F<i_time.U>: + +This variable holds the full path of the included time header(s). + +=item C<timetype> + +From F<d_time.U>: + +This variable holds the type returned by time(). It can be long, +or time_t on C<BSD> sites (in which case <sys/types.h> should be +included). Anyway, the type Time_t should be used. + +=item C<tmpnam_r_proto> + +From F<d_tmpnam_r.U>: + +This variable encodes the prototype of tmpnam_r. +It is zero if d_tmpnam_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_tmpnam_r +is defined. + +=item C<to> + +From F<Cross.U>: + +This variable contains the command used by Configure +to copy to from the target host. Useful and available +only during Perl build. +The string C<:> if not cross-compiling. + +=item C<touch> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the touch program. After Configure runs, +the value is reset to a plain C<touch> and is not useful. + +=item C<tr> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the tr program. After Configure runs, +the value is reset to a plain C<tr> and is not useful. + +=item C<trnl> + +From F<trnl.U>: + +This variable contains the value to be passed to the tr(1) +command to transliterate a newline. Typical values are +C<\012> and C<\n>. This is needed for C<EBCDIC> systems where +newline is not necessarily C<\012>. + +=item C<troff> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<ttyname_r_proto> + +From F<d_ttyname_r.U>: + +This variable encodes the prototype of ttyname_r. +It is zero if d_ttyname_r is undef, and one of the +C<REENTRANT_PROTO_T_ABC> macros of F<reentr.h> if d_ttyname_r +is defined. + +=back + +=head2 u + +=over 4 + +=item C<u16size> + +From F<perlxv.U>: + +This variable is the size of an U16 in bytes. + +=item C<u16type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's U16. + +=item C<u32size> + +From F<perlxv.U>: + +This variable is the size of an U32 in bytes. + +=item C<u32type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's U32. + +=item C<u64size> + +From F<perlxv.U>: + +This variable is the size of an U64 in bytes. + +=item C<u64type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's U64. + +=item C<u8size> + +From F<perlxv.U>: + +This variable is the size of an U8 in bytes. + +=item C<u8type> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's U8. + +=item C<uidformat> + +From F<uidf.U>: + +This variable contains the format string used for printing a Uid_t. + +=item C<uidsign> + +From F<uidsign.U>: + +This variable contains the signedness of a uidtype. +1 for unsigned, -1 for signed. + +=item C<uidsize> + +From F<uidsize.U>: + +This variable contains the size of a uidtype in bytes. + +=item C<uidtype> + +From F<uidtype.U>: + +This variable defines Uid_t to be something like uid_t, int, +ushort, or whatever type is used to declare user ids in the kernel. + +=item C<uname> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the uname program. After Configure runs, +the value is reset to a plain C<uname> and is not useful. + +=item C<uniq> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the uniq program. After Configure runs, +the value is reset to a plain C<uniq> and is not useful. + +=item C<uquadtype> + +From F<quadtype.U>: + +This variable defines Uquad_t to be something like unsigned long, +unsigned int, unsigned long long, uint64_t, or whatever type is +used for 64-bit integers. + +=item C<use5005threads> + +From F<usethreads.U>: + +This variable conditionally defines the USE_5005THREADS symbol, +and indicates that Perl should be built to use the 5.005-based +threading implementation. + +=item C<use64bitall> + +From F<use64bits.U>: + +This variable conditionally defines the USE_64_BIT_ALL symbol, +and indicates that 64-bit integer types should be used +when available. The maximal possible +64-bitness is employed: LP64 or ILP64, meaning that you will +be able to use more than 2 gigabytes of memory. This mode is +even more binary incompatible than USE_64_BIT_INT. You may not +be able to run the resulting executable in a 32-bit C<CPU> at all or +you may need at least to reboot your C<OS> to 64-bit mode. + +=item C<use64bitint> + +From F<use64bits.U>: + +This variable conditionally defines the USE_64_BIT_INT symbol, +and indicates that 64-bit integer types should be used +when available. The minimal possible 64-bitness +is employed, just enough to get 64-bit integers into Perl. +This may mean using for example "long longs", while your memory +may still be limited to 2 gigabytes. + +=item C<usecrosscompile> + +From F<Cross.U>: + +This variable conditionally defines the C<USE_CROSS_COMPILE> symbol, +and indicates that Perl has been cross-compiled. + +=item C<usedl> + +From F<dlsrc.U>: + +This variable indicates if the system supports dynamic +loading of some sort. See also dlsrc and dlobj. + +=item C<useithreads> + +From F<usethreads.U>: + +This variable conditionally defines the C<USE_ITHREADS> symbol, +and indicates that Perl should be built to use the interpreter-based +threading implementation. + +=item C<uselargefiles> + +From F<uselfs.U>: + +This variable conditionally defines the C<USE_LARGE_FILES> symbol, +and indicates that large file interfaces should be used when +available. + +=item C<uselongdouble> + +From F<uselongdbl.U>: + +This variable conditionally defines the C<USE_LONG_DOUBLE> symbol, +and indicates that long doubles should be used when available. + +=item C<usemorebits> + +From F<usemorebits.U>: + +This variable conditionally defines the C<USE_MORE_BITS> symbol, +and indicates that explicit 64-bit interfaces and long doubles +should be used when available. + +=item C<usemultiplicity> + +From F<usemultiplicity.U>: + +This variable conditionally defines the C<MULTIPLICITY> symbol, +and indicates that Perl should be built to use multiplicity. + +=item C<usemymalloc> + +From F<mallocsrc.U>: + +This variable contains y if the malloc that comes with this package +is desired over the system's version of malloc. People often include +special versions of malloc for effiency, but such versions are often +less portable. See also mallocsrc and mallocobj. +If this is C<y>, then -lmalloc is removed from $libs. + +=item C<usenm> + +From F<usenm.U>: + +This variable contains C<true> or C<false> depending whether the +nm extraction is wanted or not. + +=item C<useopcode> + +From F<Extensions.U>: + +This variable holds either C<true> or C<false> to indicate +whether the Opcode extension should be used. The sole +use for this currently is to allow an easy mechanism +for users to skip the Opcode extension from the Configure +command line. + +=item C<useperlio> + +From F<useperlio.U>: + +This variable conditionally defines the C<USE_PERLIO> symbol, +and indicates that the PerlIO abstraction should be +used throughout. + +=item C<useposix> + +From F<Extensions.U>: + +This variable holds either C<true> or C<false> to indicate +whether the C<POSIX> extension should be used. The sole +use for this currently is to allow an easy mechanism +for hints files to indicate that C<POSIX> will not compile +on a particular system. + +=item C<usereentrant> + +From F<usethreads.U>: + +This variable conditionally defines the C<USE_REENTRANT_API> symbol, +which indicates that the thread code may try to use the various +_r versions of library functions. This is only potentially +meaningful if usethreads is set and is very experimental, it is +not even prompted for. + +=item C<usesfio> + +From F<d_sfio.U>: + +This variable is set to true when the user agrees to use sfio. +It is set to false when sfio is not available or when the user +explicitely requests not to use sfio. It is here primarily so +that command-line settings can override the auto-detection of +d_sfio without running into a "WHOA THERE". + +=item C<useshrplib> + +From F<libperl.U>: + +This variable is set to C<yes> if the user wishes +to build a shared libperl, and C<no> otherwise. + +=item C<usesocks> + +From F<usesocks.U>: + +This variable conditionally defines the C<USE_SOCKS> symbol, +and indicates that Perl should be built to use C<SOCKS>. + +=item C<usethreads> + +From F<usethreads.U>: + +This variable conditionally defines the C<USE_THREADS> symbol, +and indicates that Perl should be built to use threads. + +=item C<usevendorprefix> + +From F<vendorprefix.U>: + +This variable tells whether the vendorprefix +and consequently other vendor* paths are in use. + +=item C<usevfork> + +From F<d_vfork.U>: + +This variable is set to true when the user accepts to use vfork. +It is set to false when no vfork is available or when the user +explicitely requests not to use vfork. + +=item C<usrinc> + +From F<usrinc.U>: + +This variable holds the path of the include files, which is +usually F</usr/include>. It is mainly used by other Configure units. + +=item C<uuname> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<uvoformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<UV> as an unsigned octal integer. + +=item C<uvsize> + +From F<perlxv.U>: + +This variable is the size of a C<UV> in bytes. + +=item C<uvtype> + +From F<perlxv.U>: + +This variable contains the C type used for Perl's C<UV>. + +=item C<uvuformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<UV> as an unsigned decimal integer. + +=item C<uvxformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<UV> as an unsigned hexadecimal integer in lowercase abcdef. + +=item C<uvXUformat> + +From F<perlxvf.U>: + +This variable contains the format string used for printing +a Perl C<UV> as an unsigned hexadecimal integer in uppercase C<ABCDEF>. + +=back + +=head2 v + +=over 4 + +=item C<vendorarch> + +From F<vendorarch.U>: + +This variable contains the value of the C<PERL_VENDORARCH> symbol. +It may have a F<~> on the front. +The standard distribution will put nothing in this directory. +Vendors who distribute perl may wish to place their own +architecture-dependent modules and extensions in this directory with +MakeMaker F<Makefile.PL> C<INSTALLDIRS>=vendor +or equivalent. See C<INSTALL> for details. + +=item C<vendorarchexp> + +From F<vendorarch.U>: + +This variable is the F<~name> expanded version of vendorarch, so that you +may use it directly in Makefiles or shell scripts. + +=item C<vendorbin> + +From F<vendorbin.U>: + +This variable contains the eventual value of the C<VENDORBIN> symbol. +It may have a F<~> on the front. +The standard distribution will put nothing in this directory. +Vendors who distribute perl may wish to place additional +binaries in this directory with +MakeMaker F<Makefile.PL> C<INSTALLDIRS>=vendor +or equivalent. See C<INSTALL> for details. + +=item C<vendorbinexp> + +From F<vendorbin.U>: + +This variable is the F<~name> expanded version of vendorbin, so that you +may use it directly in Makefiles or shell scripts. + +=item C<vendorlib> + +From F<vendorlib.U>: + +This variable contains the eventual value of the C<VENDORLIB> symbol, +which is the name of the private library for this package. +The standard distribution will put nothing in this directory. +Vendors who distribute perl may wish to place their own +modules in this directory with +MakeMaker F<Makefile.PL> C<INSTALLDIRS>=vendor +or equivalent. See C<INSTALL> for details. + +=item C<vendorlib_stem> + +From F<vendorlib.U>: + +This variable is $vendorlibexp with any trailing version-specific component +removed. The elements in inc_version_list (F<inc_version_list.U>) can +be tacked onto this variable to generate a list of directories to search. + +=item C<vendorlibexp> + +From F<vendorlib.U>: + +This variable is the F<~name> expanded version of vendorlib, so that you +may use it directly in Makefiles or shell scripts. + +=item C<vendorprefix> + +From F<vendorprefix.U>: + +This variable holds the full absolute path of the directory below +which the vendor will install add-on packages. +See C<INSTALL> for usage and examples. + +=item C<vendorprefixexp> + +From F<vendorprefix.U>: + +This variable holds the full absolute path of the directory below +which the vendor will install add-on packages. Derived from vendorprefix. + +=item C<version> + +From F<patchlevel.U>: + +The full version number of this package, such as 5.6.1 (or 5_6_1). +This combines revision, patchlevel, and subversion to get the +full version number, including any possible subversions. +This is suitable for use as a directory name, and hence is +filesystem dependent. + +=item C<version_patchlevel_string> + +From F<patchlevel.U>: + +This is a string combining version, subversion and +perl_patchlevel (if perl_patchlevel is non-zero). +It is typically something like +'version 7 subversion 1' or +'version 7 subversion 1 patchlevel 11224' +It is computed here to avoid duplication of code in F<myconfig.SH> +and F<lib/Config.pm>. + +=item C<versiononly> + +From F<versiononly.U>: + +If set, this symbol indicates that only the version-specific +components of a perl installation should be installed. +This may be useful for making a test installation of a new +version without disturbing the existing installation. +Setting versiononly is equivalent to setting installperl's -v option. +In particular, the non-versioned scripts and programs such as +a2p, c2ph, h2xs, pod2*, and perldoc are not installed +(see C<INSTALL> for a more complete list). Nor are the man +pages installed. +Usually, this is undef. + +=item C<vi> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<voidflags> + +From F<voidflags.U>: + +This variable contains the eventual value of the C<VOIDFLAGS> symbol, +which indicates how much support of the void type is given by this +compiler. See C<VOIDFLAGS> for more info. + +=back + +=head2 x + +=over 4 + +=item C<xlibpth> + +From F<libpth.U>: + +This variable holds extra path (space-separated) used to find +libraries on this platform, for example C<CPU>-specific libraries +(on multi-C<CPU> platforms) may be listed here. + +=item C<xs_apiversion> + +From F<xs_apiversion.U>: + +This variable contains the version of the oldest perl binary +compatible with the present perl. F<perl.c>:incpush() and +F<lib/lib.pm> will automatically search in $sitearch for older +directories across major versions back to xs_apiversion. +This is only useful if you have a perl library directory tree +structured like the default one. +See C<INSTALL> for how this works. +The versioned site_perl directory was introduced in 5.005, +so that is the lowest possible value. +Since this can depend on compile time options +it is set by Configure. Other non-default sources +of potential incompatibility, such as multiplicity, threads, +debugging, 64bits, sfio, etc., are not checked for currently, +though in principle we could go snooping around in old +F<Config.pm> files. + +=back + +=head2 y + +=over 4 + +=item C<yacc> + +From F<yacc.U>: + +This variable holds the name of the compiler compiler we +want to use in the Makefile. It can be yacc, byacc, or bison -y. + +=item C<yaccflags> + +From F<yacc.U>: + +This variable contains any additional yacc flags desired by the +user. It is up to the Makefile to use this. + +=back + +=head2 z + +=over 4 + +=item C<zcat> + +From F<Loc.U>: + +This variable is defined but not used by Configure. +The value is a plain '' and is not useful. + +=item C<zip> + +From F<Loc.U>: + +This variable is used internally by Configure to determine the +full pathname (if any) of the zip program. After Configure runs, +the value is reset to a plain C<zip> and is not useful. + + +=back + +=head1 NOTE + +This module contains a good example of how to use tie to implement a +cache and an example of how to make a tied variable readonly to those +outside of it. + +=cut + diff --git a/Master/xemtex/perl/lib/Cwd.pm b/Master/xemtex/perl/lib/Cwd.pm new file mode 100644 index 00000000000..8b00543e1e9 --- /dev/null +++ b/Master/xemtex/perl/lib/Cwd.pm @@ -0,0 +1,570 @@ +package Cwd; +use 5.006; + +=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() 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. + +Re-implements the getcwd(3) (or getwd(3)) functions in Perl. + +Taint-safe. + +=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). + +Taint-safe. + +=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(). + +=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. + +=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). + +Taint-safe. + +=item realpath + + my $abs_path = realpath($file); + +A synonym for abs_path(). + +Taint-safe. + +=item fast_abs_path + + my $abs_path = fast_abs_path($file); + +A more dangerous, but potentially faster version of abs_path. + +This function is B<Not> taint-safe : you can't use it in programs +that work under taint mode. + +=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 seperators 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 SEE ALSO + +L<File::chdir> + +=cut + +use strict; + +use Carp; + +our $VERSION = '2.06'; + +use base qw/ Exporter /; +our @EXPORT = qw(cwd getcwd fastcwd fastgetcwd); +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' && defined &sys_cwd && defined &sys_abspath) { + local $^W = 0; + *cwd = \&sys_cwd; + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + *abs_path = \&sys_abspath; + *fast_abs_path = \&abs_path; + *realpath = \&abs_path; + *fast_realpath = \&abs_path; + return 1; +} + +eval { + require XSLoader; + undef *Cwd::fastcwd; # avoid redefinition warning + XSLoader::load('Cwd'); +}; + + +# 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; +foreach my $try (qw(/bin/pwd /usr/bin/pwd)) { + if( -x $try ) { + $pwd_cmd = $try; + last; + } +} +$pwd_cmd ||= 'pwd'; + +# The 'natural and safe form' for UNIX (pwd may be setuid root) +sub _backtick_pwd { + local @ENV{qw(PATH IFS CDPATH ENV BASH_ENV)}; + 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(defined &cwd) { + # The pwd command is not available in some chroot(2)'ed environments + if( $^O eq 'MacOS' || (defined $ENV{PATH} && + grep { -x "$_/pwd" } split(':', $ENV{PATH})) ) + { + *cwd = \&_backtick_pwd; + } + else { + *cwd = \&getcwd; + } +} + +# set a reasonable (and very safe) default for fastgetcwd, in case it +# isn't redefined later (20001212 rspier) +*fastgetcwd = \&cwd; + +# By Brandon S. Allbery +# +# Usage: $cwd = getcwd(); + +sub 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 == $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 != $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 != $orig_cino; + $path; +} + + +# 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 != $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 == $pi and $dd == $pd) { + $ENV{'PWD'}="$2$3"; + } + } + $chdir_init = 1; +} + +sub chdir { + my $newdir = @_ ? shift : ''; # allow for no arg (chdir to HOME dir) + $newdir =~ s|///*|/|g unless $^O eq 'MSWin32'; + 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 'MacOS') { + return $ENV{'PWD'} = cwd(); + } + elsif ($^O eq 'MSWin32') { + $ENV{'PWD'} = $newpwd; + return 1; + } + + if ($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; +} + + +# In case the XS version doesn't load. +*abs_path = \&_perl_abs_path unless defined &abs_path; +sub _perl_abs_path +{ + my $start = @_ ? shift : '.'; + my($dotdots, $cwd, @pst, @cst, $dir, @tst); + + unless (@cst = stat( $start )) + { + carp "stat($start): $!"; + return ''; + } + $cwd = ''; + $dotdots = $start; + do + { + $dotdots .= '/..'; + @pst = @cst; + unless (opendir(PARENT, $dotdots)) + { + carp "opendir($dotdots): $!"; + return ''; + } + unless (@cst = stat($dotdots)) + { + carp "stat($dotdots): $!"; + closedir(PARENT); + return ''; + } + if ($pst[0] == $cst[0] && $pst[1] == $cst[1]) + { + $dir = undef; + } + else + { + do + { + unless (defined ($dir = readdir(PARENT))) + { + carp "readdir($dotdots): $!"; + closedir(PARENT); + return ''; + } + $tst[0] = $pst[0]+1 unless (@tst = lstat("$dotdots/$dir")) + } + while ($dir eq '.' || $dir eq '..' || $tst[0] != $pst[0] || + $tst[1] != $pst[1]); + } + $cwd = (defined $dir ? "$dir" : "" ) . "/$cwd" ; + closedir(PARENT); + } while (defined $dir); + chop($cwd) unless $cwd eq '/'; # drop the trailing / + $cwd; +} + + +# added function alias for those of us more +# used to the libc function. --tchrist 27-Jan-00 +*realpath = \&abs_path; + +sub fast_abs_path { + my $cwd = getcwd(); + require File::Spec; + my $path = @_ ? shift : File::Spec->curdir; + CORE::chdir($path) || croak "Cannot chdir to $path: $!"; + my $realpath = getcwd(); + -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 = VMS::Filespec::pathify($_[0]); + croak("Invalid path name $_[0]") unless defined $path; + return VMS::Filespec::rmsexpand($path); +} + +sub _os2_cwd { + $ENV{'PWD'} = `cmd /c cd`; + chop $ENV{'PWD'}; + $ENV{'PWD'} =~ s:\\:/:g ; + return $ENV{'PWD'}; +} + +sub _win32_cwd { + $ENV{'PWD'} = Win32::GetCwd(); + $ENV{'PWD'} =~ s:\\:/:g ; + return $ENV{'PWD'}; +} + +*_NT_cwd = \&_win32_cwd if (!defined &_NT_cwd && + defined &Win32::GetCwd); + +*_NT_cwd = \&_os2_cwd unless defined &_NT_cwd; + +sub _dos_cwd { + if (!defined &Dos::GetCwd) { + $ENV{'PWD'} = `command /c cd`; + chop $ENV{'PWD'}; + $ENV{'PWD'} =~ s:\\:/:g ; + } else { + $ENV{'PWD'} = Dos::GetCwd(); + } + return $ENV{'PWD'}; +} + +sub _qnx_cwd { + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; + $ENV{'PWD'} = `/usr/bin/fullpath -t`; + chop $ENV{'PWD'}; + return $ENV{'PWD'}; +} + +sub _qnx_abs_path { + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; + my $path = @_ ? shift : '.'; + my $realpath=`/usr/bin/fullpath -t $path`; + chop $realpath; + return $realpath; +} + +sub _epoc_cwd { + $ENV{'PWD'} = EPOC::getcwd(); + return $ENV{'PWD'}; +} + +{ + no warnings; # assignments trigger 'subroutine redefined' warning + + if ($^O eq 'VMS') { + *cwd = \&_vms_cwd; + *getcwd = \&_vms_cwd; + *fastcwd = \&_vms_cwd; + *fastgetcwd = \&_vms_cwd; + *abs_path = \&_vms_abs_path; + *fast_abs_path = \&_vms_abs_path; + } + elsif ($^O eq 'NT' or $^O eq '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; + } + elsif ($^O eq 'os2') { + # sys_cwd may keep the builtin command + *cwd = defined &sys_cwd ? \&sys_cwd : \&_os2_cwd; + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + *abs_path = \&fast_abs_path; + } + elsif ($^O eq 'dos') { + *cwd = \&_dos_cwd; + *getcwd = \&_dos_cwd; + *fastgetcwd = \&_dos_cwd; + *fastcwd = \&_dos_cwd; + *abs_path = \&fast_abs_path; + } + elsif ($^O =~ m/^(?:qnx|nto)$/ ) { + *cwd = \&_qnx_cwd; + *getcwd = \&_qnx_cwd; + *fastgetcwd = \&_qnx_cwd; + *fastcwd = \&_qnx_cwd; + *abs_path = \&_qnx_abs_path; + *fast_abs_path = \&_qnx_abs_path; + } + elsif ($^O eq 'cygwin') { + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + *abs_path = \&fast_abs_path; + } + elsif ($^O eq 'epoc') { + *cwd = \&_epoc_cwd; + *getcwd = \&_epoc_cwd; + *fastgetcwd = \&_epoc_cwd; + *fastcwd = \&_epoc_cwd; + *abs_path = \&fast_abs_path; + } + elsif ($^O eq 'MacOS') { + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + *abs_path = \&fast_abs_path; + } +} + + +1; diff --git a/Master/xemtex/perl/lib/Data/Dumper.pm b/Master/xemtex/perl/lib/Data/Dumper.pm new file mode 100644 index 00000000000..189ad007cbc --- /dev/null +++ b/Master/xemtex/perl/lib/Data/Dumper.pm @@ -0,0 +1,1160 @@ +# +# Data/Dumper.pm +# +# convert perl data structures into perl syntax suitable for both printing +# and eval +# +# Documentation at the __END__ +# + +package Data::Dumper; + +$VERSION = '2.12'; + +#$| = 1; + +use 5.006_001; +require Exporter; +use XSLoader (); +require overload; + +use Carp; + +@ISA = qw(Exporter); +@EXPORT = qw(Dumper); +@EXPORT_OK = qw(DumperX); + +XSLoader::load 'Data::Dumper'; + +# module vars and their defaults +$Indent = 2 unless defined $Indent; +$Purity = 0 unless defined $Purity; +$Pad = "" unless defined $Pad; +$Varname = "VAR" unless defined $Varname; +$Useqq = 0 unless defined $Useqq; +$Terse = 0 unless defined $Terse; +$Freezer = "" unless defined $Freezer; +$Toaster = "" unless defined $Toaster; +$Deepcopy = 0 unless defined $Deepcopy; +$Quotekeys = 1 unless defined $Quotekeys; +$Bless = "bless" unless defined $Bless; +#$Expdepth = 0 unless defined $Expdepth; +$Maxdepth = 0 unless defined $Maxdepth; +$Useperl = 0 unless defined $Useperl; +$Sortkeys = 0 unless defined $Sortkeys; +$Deparse = 0 unless defined $Deparse; + +# +# expects an arrayref of values to be dumped. +# can optionally pass an arrayref of names for the values. +# names must have leading $ sign stripped. begin the name with * +# to cause output of arrays and hashes rather than refs. +# +sub new { + my($c, $v, $n) = @_; + + croak "Usage: PACKAGE->new(ARRAYREF, [ARRAYREF])" + unless (defined($v) && (ref($v) eq 'ARRAY')); + $n = [] unless (defined($n) && (ref($v) eq 'ARRAY')); + + my($s) = { + level => 0, # current recursive depth + indent => $Indent, # various styles of indenting + pad => $Pad, # all lines prefixed by this string + xpad => "", # padding-per-level + apad => "", # added padding for hash keys n such + sep => "", # list separator + seen => {}, # local (nested) refs (id => [name, val]) + todump => $v, # values to dump [] + names => $n, # optional names for values [] + varname => $Varname, # prefix to use for tagging nameless ones + purity => $Purity, # degree to which output is evalable + useqq => $Useqq, # use "" for strings (backslashitis ensues) + terse => $Terse, # avoid name output (where feasible) + freezer => $Freezer, # name of Freezer method for objects + toaster => $Toaster, # name of method to revive objects + deepcopy => $Deepcopy, # dont cross-ref, except to stop recursion + quotekeys => $Quotekeys, # quote hash keys + 'bless' => $Bless, # keyword to use for "bless" +# expdepth => $Expdepth, # cutoff depth for explicit dumping + maxdepth => $Maxdepth, # depth beyond which we give up + useperl => $Useperl, # use the pure Perl implementation + sortkeys => $Sortkeys, # flag or filter for sorting hash keys + deparse => $Deparse, # use B::Deparse for coderefs + }; + + if ($Indent > 0) { + $s->{xpad} = " "; + $s->{sep} = "\n"; + } + return bless($s, $c); +} + +# +# add-to or query the table of already seen references +# +sub Seen { + my($s, $g) = @_; + if (defined($g) && (ref($g) eq 'HASH')) { + my($k, $v, $id); + while (($k, $v) = each %$g) { + if (defined $v and ref $v) { + ($id) = (overload::StrVal($v) =~ /\((.*)\)$/); + if ($k =~ /^[*](.*)$/) { + $k = (ref $v eq 'ARRAY') ? ( "\\\@" . $1 ) : + (ref $v eq 'HASH') ? ( "\\\%" . $1 ) : + (ref $v eq 'CODE') ? ( "\\\&" . $1 ) : + ( "\$" . $1 ) ; + } + elsif ($k !~ /^\$/) { + $k = "\$" . $k; + } + $s->{seen}{$id} = [$k, $v]; + } + else { + carp "Only refs supported, ignoring non-ref item \$$k"; + } + } + return $s; + } + else { + return map { @$_ } values %{$s->{seen}}; + } +} + +# +# set or query the values to be dumped +# +sub Values { + my($s, $v) = @_; + if (defined($v) && (ref($v) eq 'ARRAY')) { + $s->{todump} = [@$v]; # make a copy + return $s; + } + else { + return @{$s->{todump}}; + } +} + +# +# set or query the names of the values to be dumped +# +sub Names { + my($s, $n) = @_; + if (defined($n) && (ref($n) eq 'ARRAY')) { + $s->{names} = [@$n]; # make a copy + return $s; + } + else { + return @{$s->{names}}; + } +} + +sub DESTROY {} + +sub Dump { + return &Dumpxs + unless $Data::Dumper::Useperl || (ref($_[0]) && $_[0]->{useperl}) || + $Data::Dumper::Useqq || (ref($_[0]) && $_[0]->{useqq}) || + $Data::Dumper::Deparse || (ref($_[0]) && $_[0]->{deparse}); + return &Dumpperl; +} + +# +# dump the refs in the current dumper object. +# expects same args as new() if called via package name. +# +sub Dumpperl { + my($s) = shift; + my(@out, $val, $name); + my($i) = 0; + local(@post); + + $s = $s->new(@_) unless ref $s; + + for $val (@{$s->{todump}}) { + my $out = ""; + @post = (); + $name = $s->{names}[$i++]; + if (defined $name) { + if ($name =~ /^[*](.*)$/) { + if (defined $val) { + $name = (ref $val eq 'ARRAY') ? ( "\@" . $1 ) : + (ref $val eq 'HASH') ? ( "\%" . $1 ) : + (ref $val eq 'CODE') ? ( "\*" . $1 ) : + ( "\$" . $1 ) ; + } + else { + $name = "\$" . $1; + } + } + elsif ($name !~ /^\$/) { + $name = "\$" . $name; + } + } + else { + $name = "\$" . $s->{varname} . $i; + } + + my $valstr; + { + local($s->{apad}) = $s->{apad}; + $s->{apad} .= ' ' x (length($name) + 3) if $s->{indent} >= 2; + $valstr = $s->_dump($val, $name); + } + + $valstr = "$name = " . $valstr . ';' if @post or !$s->{terse}; + $out .= $s->{pad} . $valstr . $s->{sep}; + $out .= $s->{pad} . join(';' . $s->{sep} . $s->{pad}, @post) + . ';' . $s->{sep} if @post; + + push @out, $out; + } + return wantarray ? @out : join('', @out); +} + +# +# twist, toil and turn; +# and recurse, of course. +# sometimes sordidly; +# and curse if no recourse. +# +sub _dump { + my($s, $val, $name) = @_; + my($sname); + my($out, $realpack, $realtype, $type, $ipad, $id, $blesspad); + + $type = ref $val; + $out = ""; + + if ($type) { + + # prep it, if it looks like an object + if (my $freezer = $s->{freezer}) { + $val->$freezer() if UNIVERSAL::can($val, $freezer); + } + + ($realpack, $realtype, $id) = + (overload::StrVal($val) =~ /^(?:(.*)\=)?([^=]*)\(([^\(]*)\)$/); + + # if it has a name, we need to either look it up, or keep a tab + # on it so we know when we hit it later + if (defined($name) and length($name)) { + # keep a tab on it so that we dont fall into recursive pit + if (exists $s->{seen}{$id}) { +# if ($s->{expdepth} < $s->{level}) { + if ($s->{purity} and $s->{level} > 0) { + $out = ($realtype eq 'HASH') ? '{}' : + ($realtype eq 'ARRAY') ? '[]' : + 'do{my $o}' ; + push @post, $name . " = " . $s->{seen}{$id}[0]; + } + else { + $out = $s->{seen}{$id}[0]; + if ($name =~ /^([\@\%])/) { + my $start = $1; + if ($out =~ /^\\$start/) { + $out = substr($out, 1); + } + else { + $out = $start . '{' . $out . '}'; + } + } + } + return $out; +# } + } + else { + # store our name + $s->{seen}{$id} = [ (($name =~ /^[@%]/) ? ('\\' . $name ) : + ($realtype eq 'CODE' and + $name =~ /^[*](.*)$/) ? ('\\&' . $1 ) : + $name ), + $val ]; + } + } + + if ($realpack and $realpack eq 'Regexp') { + $out = "$val"; + $out =~ s,/,\\/,g; + return "qr/$out/"; + } + + # If purity is not set and maxdepth is set, then check depth: + # if we have reached maximum depth, return the string + # representation of the thing we are currently examining + # at this depth (i.e., 'Foo=ARRAY(0xdeadbeef)'). + if (!$s->{purity} + and $s->{maxdepth} > 0 + and $s->{level} >= $s->{maxdepth}) + { + return qq['$val']; + } + + # we have a blessed ref + if ($realpack) { + $out = $s->{'bless'} . '( '; + $blesspad = $s->{apad}; + $s->{apad} .= ' ' if ($s->{indent} >= 2); + } + + $s->{level}++; + $ipad = $s->{xpad} x $s->{level}; + + if ($realtype eq 'SCALAR' || $realtype eq 'REF') { + if ($realpack) { + $out .= 'do{\\(my $o = ' . $s->_dump($$val, "\${$name}") . ')}'; + } + else { + $out .= '\\' . $s->_dump($$val, "\${$name}"); + } + } + elsif ($realtype eq 'GLOB') { + $out .= '\\' . $s->_dump($$val, "*{$name}"); + } + elsif ($realtype eq 'ARRAY') { + my($v, $pad, $mname); + my($i) = 0; + $out .= ($name =~ /^\@/) ? '(' : '['; + $pad = $s->{sep} . $s->{pad} . $s->{apad}; + ($name =~ /^\@(.*)$/) ? ($mname = "\$" . $1) : + # omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar} + ($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) : + ($mname = $name . '->'); + $mname .= '->' if $mname =~ /^\*.+\{[A-Z]+\}$/; + for $v (@$val) { + $sname = $mname . '[' . $i . ']'; + $out .= $pad . $ipad . '#' . $i if $s->{indent} >= 3; + $out .= $pad . $ipad . $s->_dump($v, $sname); + $out .= "," if $i++ < $#$val; + } + $out .= $pad . ($s->{xpad} x ($s->{level} - 1)) if $i; + $out .= ($name =~ /^\@/) ? ')' : ']'; + } + elsif ($realtype eq 'HASH') { + my($k, $v, $pad, $lpad, $mname); + $out .= ($name =~ /^\%/) ? '(' : '{'; + $pad = $s->{sep} . $s->{pad} . $s->{apad}; + $lpad = $s->{apad}; + ($name =~ /^\%(.*)$/) ? ($mname = "\$" . $1) : + # omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar} + ($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) : + ($mname = $name . '->'); + $mname .= '->' if $mname =~ /^\*.+\{[A-Z]+\}$/; + my ($sortkeys, $keys, $key) = ("$s->{sortkeys}"); + if ($sortkeys) { + if (ref($s->{sortkeys}) eq 'CODE') { + $keys = $s->{sortkeys}($val); + unless (ref($keys) eq 'ARRAY') { + carp "Sortkeys subroutine did not return ARRAYREF"; + $keys = []; + } + } + else { + $keys = [ sort keys %$val ]; + } + } + while (($k, $v) = ! $sortkeys ? (each %$val) : + @$keys ? ($key = shift(@$keys), $val->{$key}) : + () ) + { + my $nk = $s->_dump($k, ""); + $nk = $1 if !$s->{quotekeys} and $nk =~ /^[\"\']([A-Za-z_]\w*)[\"\']$/; + $sname = $mname . '{' . $nk . '}'; + $out .= $pad . $ipad . $nk . " => "; + + # temporarily alter apad + $s->{apad} .= (" " x (length($nk) + 4)) if $s->{indent} >= 2; + $out .= $s->_dump($val->{$k}, $sname) . ","; + $s->{apad} = $lpad if $s->{indent} >= 2; + } + if (substr($out, -1) eq ',') { + chop $out; + $out .= $pad . ($s->{xpad} x ($s->{level} - 1)); + } + $out .= ($name =~ /^\%/) ? ')' : '}'; + } + elsif ($realtype eq 'CODE') { + if ($s->{deparse}) { + require B::Deparse; + my $sub = 'sub ' . (B::Deparse->new)->coderef2text($val); + $pad = $s->{sep} . $s->{pad} . $s->{xpad} . $s->{apad} . ' '; + $sub =~ s/\n/$pad/gse; + $out .= $sub; + } else { + $out .= 'sub { "DUMMY" }'; + carp "Encountered CODE ref, using dummy placeholder" if $s->{purity}; + } + } + else { + croak "Can\'t handle $realtype type."; + } + + if ($realpack) { # we have a blessed ref + $out .= ', \'' . $realpack . '\'' . ' )'; + $out .= '->' . $s->{toaster} . '()' if $s->{toaster} ne ''; + $s->{apad} = $blesspad; + } + $s->{level}--; + + } + else { # simple scalar + + my $ref = \$_[1]; + # first, catalog the scalar + if ($name ne '') { + ($id) = ("$ref" =~ /\(([^\(]*)\)$/); + if (exists $s->{seen}{$id}) { + if ($s->{seen}{$id}[2]) { + $out = $s->{seen}{$id}[0]; + #warn "[<$out]\n"; + return "\${$out}"; + } + } + else { + #warn "[>\\$name]\n"; + $s->{seen}{$id} = ["\\$name", $ref]; + } + } + if (ref($ref) eq 'GLOB' or "$ref" =~ /=GLOB\([^()]+\)$/) { # glob + my $name = substr($val, 1); + if ($name =~ /^[A-Za-z_][\w:]*$/) { + $name =~ s/^main::/::/; + $sname = $name; + } + else { + $sname = $s->_dump($name, ""); + $sname = '{' . $sname . '}'; + } + if ($s->{purity}) { + my $k; + local ($s->{level}) = 0; + for $k (qw(SCALAR ARRAY HASH)) { + my $gval = *$val{$k}; + next unless defined $gval; + next if $k eq "SCALAR" && ! defined $$gval; # always there + + # _dump can push into @post, so we hold our place using $postlen + my $postlen = scalar @post; + $post[$postlen] = "\*$sname = "; + local ($s->{apad}) = " " x length($post[$postlen]) if $s->{indent} >= 2; + $post[$postlen] .= $s->_dump($gval, "\*$sname\{$k\}"); + } + } + $out .= '*' . $sname; + } + elsif (!defined($val)) { + $out .= "undef"; + } + elsif ($val =~ /^(?:0|-?[1-9]\d{0,8})\z/) { # safe decimal number + $out .= $val; + } + else { # string + if ($s->{useqq} or $val =~ tr/\0-\377//c) { + # Fall back to qq if there's unicode + $out .= qquote($val, $s->{useqq}); + } + else { + $val =~ s/([\\\'])/\\$1/g; + $out .= '\'' . $val . '\''; + } + } + } + if ($id) { + # if we made it this far, $id was added to seen list at current + # level, so remove it to get deep copies + if ($s->{deepcopy}) { + delete($s->{seen}{$id}); + } + elsif ($name) { + $s->{seen}{$id}[2] = 1; + } + } + return $out; +} + +# +# non-OO style of earlier version +# +sub Dumper { + return Data::Dumper->Dump([@_]); +} + +# compat stub +sub DumperX { + return Data::Dumper->Dumpxs([@_], []); +} + +sub Dumpf { return Data::Dumper->Dump(@_) } + +sub Dumpp { print Data::Dumper->Dump(@_) } + +# +# reset the "seen" cache +# +sub Reset { + my($s) = shift; + $s->{seen} = {}; + return $s; +} + +sub Indent { + my($s, $v) = @_; + if (defined($v)) { + if ($v == 0) { + $s->{xpad} = ""; + $s->{sep} = ""; + } + else { + $s->{xpad} = " "; + $s->{sep} = "\n"; + } + $s->{indent} = $v; + return $s; + } + else { + return $s->{indent}; + } +} + +sub Pad { + my($s, $v) = @_; + defined($v) ? (($s->{pad} = $v), return $s) : $s->{pad}; +} + +sub Varname { + my($s, $v) = @_; + defined($v) ? (($s->{varname} = $v), return $s) : $s->{varname}; +} + +sub Purity { + my($s, $v) = @_; + defined($v) ? (($s->{purity} = $v), return $s) : $s->{purity}; +} + +sub Useqq { + my($s, $v) = @_; + defined($v) ? (($s->{useqq} = $v), return $s) : $s->{useqq}; +} + +sub Terse { + my($s, $v) = @_; + defined($v) ? (($s->{terse} = $v), return $s) : $s->{terse}; +} + +sub Freezer { + my($s, $v) = @_; + defined($v) ? (($s->{freezer} = $v), return $s) : $s->{freezer}; +} + +sub Toaster { + my($s, $v) = @_; + defined($v) ? (($s->{toaster} = $v), return $s) : $s->{toaster}; +} + +sub Deepcopy { + my($s, $v) = @_; + defined($v) ? (($s->{deepcopy} = $v), return $s) : $s->{deepcopy}; +} + +sub Quotekeys { + my($s, $v) = @_; + defined($v) ? (($s->{quotekeys} = $v), return $s) : $s->{quotekeys}; +} + +sub Bless { + my($s, $v) = @_; + defined($v) ? (($s->{'bless'} = $v), return $s) : $s->{'bless'}; +} + +sub Maxdepth { + my($s, $v) = @_; + defined($v) ? (($s->{'maxdepth'} = $v), return $s) : $s->{'maxdepth'}; +} + +sub Useperl { + my($s, $v) = @_; + defined($v) ? (($s->{'useperl'} = $v), return $s) : $s->{'useperl'}; +} + +sub Sortkeys { + my($s, $v) = @_; + defined($v) ? (($s->{'sortkeys'} = $v), return $s) : $s->{'sortkeys'}; +} + +sub Deparse { + my($s, $v) = @_; + defined($v) ? (($s->{'deparse'} = $v), return $s) : $s->{'deparse'}; +} + +# used by qquote below +my %esc = ( + "\a" => "\\a", + "\b" => "\\b", + "\t" => "\\t", + "\n" => "\\n", + "\f" => "\\f", + "\r" => "\\r", + "\e" => "\\e", +); + +# put a string value in double quotes +sub qquote { + local($_) = shift; + s/([\\\"\@\$])/\\$1/g; + my $bytes; { use bytes; $bytes = length } + s/([^\x00-\x7f])/'\x{'.sprintf("%x",ord($1)).'}'/ge if $bytes > length; + return qq("$_") unless + /[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~]/; # fast exit + + my $high = shift || ""; + s/([\a\b\t\n\f\r\e])/$esc{$1}/g; + + if (ord('^')==94) { # ascii + # no need for 3 digits in escape for these + s/([\0-\037])(?!\d)/'\\'.sprintf('%o',ord($1))/eg; + s/([\0-\037\177])/'\\'.sprintf('%03o',ord($1))/eg; + # all but last branch below not supported --BEHAVIOR SUBJECT TO CHANGE-- + if ($high eq "iso8859") { + s/([\200-\240])/'\\'.sprintf('%o',ord($1))/eg; + } elsif ($high eq "utf8") { +# use utf8; +# $str =~ s/([^\040-\176])/sprintf "\\x{%04x}", ord($1)/ge; + } elsif ($high eq "8bit") { + # leave it as it is + } else { + s/([\200-\377])/'\\'.sprintf('%03o',ord($1))/eg; + s/([^\040-\176])/sprintf "\\x{%04x}", ord($1)/ge; + } + } + else { # ebcdic + s{([^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~])(?!\d)} + {my $v = ord($1); '\\'.sprintf(($v <= 037 ? '%o' : '%03o'), $v)}eg; + s{([^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~])} + {'\\'.sprintf('%03o',ord($1))}eg; + } + + return qq("$_"); +} + +1; +__END__ + +=head1 NAME + +Data::Dumper - stringified perl data structures, suitable for both printing and C<eval> + +=head1 SYNOPSIS + + use Data::Dumper; + + # simple procedural interface + print Dumper($foo, $bar); + + # extended usage with names + print Data::Dumper->Dump([$foo, $bar], [qw(foo *ary)]); + + # configuration variables + { + local $Data::Dump::Purity = 1; + eval Data::Dumper->Dump([$foo, $bar], [qw(foo *ary)]); + } + + # OO usage + $d = Data::Dumper->new([$foo, $bar], [qw(foo *ary)]); + ... + print $d->Dump; + ... + $d->Purity(1)->Terse(1)->Deepcopy(1); + eval $d->Dump; + + +=head1 DESCRIPTION + +Given a list of scalars or reference variables, writes out their contents in +perl syntax. The references can also be objects. The contents of each +variable is output in a single Perl statement. Handles self-referential +structures correctly. + +The return value can be C<eval>ed to get back an identical copy of the +original reference structure. + +Any references that are the same as one of those passed in will be named +C<$VAR>I<n> (where I<n> is a numeric suffix), and other duplicate references +to substructures within C<$VAR>I<n> will be appropriately labeled using arrow +notation. You can specify names for individual values to be dumped if you +use the C<Dump()> method, or you can change the default C<$VAR> prefix to +something else. See C<$Data::Dumper::Varname> and C<$Data::Dumper::Terse> +below. + +The default output of self-referential structures can be C<eval>ed, but the +nested references to C<$VAR>I<n> will be undefined, since a recursive +structure cannot be constructed using one Perl statement. You should set the +C<Purity> flag to 1 to get additional statements that will correctly fill in +these references. + +In the extended usage form, the references to be dumped can be given +user-specified names. If a name begins with a C<*>, the output will +describe the dereferenced type of the supplied reference for hashes and +arrays, and coderefs. Output of names will be avoided where possible if +the C<Terse> flag is set. + +In many cases, methods that are used to set the internal state of the +object will return the object itself, so method calls can be conveniently +chained together. + +Several styles of output are possible, all controlled by setting +the C<Indent> flag. See L<Configuration Variables or Methods> below +for details. + + +=head2 Methods + +=over 4 + +=item I<PACKAGE>->new(I<ARRAYREF [>, I<ARRAYREF]>) + +Returns a newly created C<Data::Dumper> object. The first argument is an +anonymous array of values to be dumped. The optional second argument is an +anonymous array of names for the values. The names need not have a leading +C<$> sign, and must be comprised of alphanumeric characters. You can begin +a name with a C<*> to specify that the dereferenced type must be dumped +instead of the reference itself, for ARRAY and HASH references. + +The prefix specified by C<$Data::Dumper::Varname> will be used with a +numeric suffix if the name for a value is undefined. + +Data::Dumper will catalog all references encountered while dumping the +values. Cross-references (in the form of names of substructures in perl +syntax) will be inserted at all possible points, preserving any structural +interdependencies in the original set of values. Structure traversal is +depth-first, and proceeds in order from the first supplied value to +the last. + +=item I<$OBJ>->Dump I<or> I<PACKAGE>->Dump(I<ARRAYREF [>, I<ARRAYREF]>) + +Returns the stringified form of the values stored in the object (preserving +the order in which they were supplied to C<new>), subject to the +configuration options below. In a list context, it returns a list +of strings corresponding to the supplied values. + +The second form, for convenience, simply calls the C<new> method on its +arguments before dumping the object immediately. + +=item I<$OBJ>->Seen(I<[HASHREF]>) + +Queries or adds to the internal table of already encountered references. +You must use C<Reset> to explicitly clear the table if needed. Such +references are not dumped; instead, their names are inserted wherever they +are encountered subsequently. This is useful especially for properly +dumping subroutine references. + +Expects an anonymous hash of name => value pairs. Same rules apply for names +as in C<new>. If no argument is supplied, will return the "seen" list of +name => value pairs, in a list context. Otherwise, returns the object +itself. + +=item I<$OBJ>->Values(I<[ARRAYREF]>) + +Queries or replaces the internal array of values that will be dumped. +When called without arguments, returns the values. Otherwise, returns the +object itself. + +=item I<$OBJ>->Names(I<[ARRAYREF]>) + +Queries or replaces the internal array of user supplied names for the values +that will be dumped. When called without arguments, returns the names. +Otherwise, returns the object itself. + +=item I<$OBJ>->Reset + +Clears the internal table of "seen" references and returns the object +itself. + +=back + +=head2 Functions + +=over 4 + +=item Dumper(I<LIST>) + +Returns the stringified form of the values in the list, subject to the +configuration options below. The values will be named C<$VAR>I<n> in the +output, where I<n> is a numeric suffix. Will return a list of strings +in a list context. + +=back + +=head2 Configuration Variables or Methods + +Several configuration variables can be used to control the kind of output +generated when using the procedural interface. These variables are usually +C<local>ized in a block so that other parts of the code are not affected by +the change. + +These variables determine the default state of the object created by calling +the C<new> method, but cannot be used to alter the state of the object +thereafter. The equivalent method names should be used instead to query +or set the internal state of the object. + +The method forms return the object itself when called with arguments, +so that they can be chained together nicely. + +=over 4 + +=item $Data::Dumper::Indent I<or> I<$OBJ>->Indent(I<[NEWVAL]>) + +Controls the style of indentation. It can be set to 0, 1, 2 or 3. Style 0 +spews output without any newlines, indentation, or spaces between list +items. It is the most compact format possible that can still be called +valid perl. Style 1 outputs a readable form with newlines but no fancy +indentation (each level in the structure is simply indented by a fixed +amount of whitespace). Style 2 (the default) outputs a very readable form +which takes into account the length of hash keys (so the hash value lines +up). Style 3 is like style 2, but also annotates the elements of arrays +with their index (but the comment is on its own line, so array output +consumes twice the number of lines). Style 2 is the default. + +=item $Data::Dumper::Purity I<or> I<$OBJ>->Purity(I<[NEWVAL]>) + +Controls the degree to which the output can be C<eval>ed to recreate the +supplied reference structures. Setting it to 1 will output additional perl +statements that will correctly recreate nested references. The default is +0. + +=item $Data::Dumper::Pad I<or> I<$OBJ>->Pad(I<[NEWVAL]>) + +Specifies the string that will be prefixed to every line of the output. +Empty string by default. + +=item $Data::Dumper::Varname I<or> I<$OBJ>->Varname(I<[NEWVAL]>) + +Contains the prefix to use for tagging variable names in the output. The +default is "VAR". + +=item $Data::Dumper::Useqq I<or> I<$OBJ>->Useqq(I<[NEWVAL]>) + +When set, enables the use of double quotes for representing string values. +Whitespace other than space will be represented as C<[\n\t\r]>, "unsafe" +characters will be backslashed, and unprintable characters will be output as +quoted octal integers. Since setting this variable imposes a performance +penalty, the default is 0. C<Dump()> will run slower if this flag is set, +since the fast XSUB implementation doesn't support it yet. + +=item $Data::Dumper::Terse I<or> I<$OBJ>->Terse(I<[NEWVAL]>) + +When set, Data::Dumper will emit single, non-self-referential values as +atoms/terms rather than statements. This means that the C<$VAR>I<n> names +will be avoided where possible, but be advised that such output may not +always be parseable by C<eval>. + +=item $Data::Dumper::Freezer I<or> $I<OBJ>->Freezer(I<[NEWVAL]>) + +Can be set to a method name, or to an empty string to disable the feature. +Data::Dumper will invoke that method via the object before attempting to +stringify it. This method can alter the contents of the object (if, for +instance, it contains data allocated from C), and even rebless it in a +different package. The client is responsible for making sure the specified +method can be called via the object, and that the object ends up containing +only perl data types after the method has been called. Defaults to an empty +string. + +=item $Data::Dumper::Toaster I<or> $I<OBJ>->Toaster(I<[NEWVAL]>) + +Can be set to a method name, or to an empty string to disable the feature. +Data::Dumper will emit a method call for any objects that are to be dumped +using the syntax C<bless(DATA, CLASS)-E<gt>METHOD()>. Note that this means that +the method specified will have to perform any modifications required on the +object (like creating new state within it, and/or reblessing it in a +different package) and then return it. The client is responsible for making +sure the method can be called via the object, and that it returns a valid +object. Defaults to an empty string. + +=item $Data::Dumper::Deepcopy I<or> $I<OBJ>->Deepcopy(I<[NEWVAL]>) + +Can be set to a boolean value to enable deep copies of structures. +Cross-referencing will then only be done when absolutely essential +(i.e., to break reference cycles). Default is 0. + +=item $Data::Dumper::Quotekeys I<or> $I<OBJ>->Quotekeys(I<[NEWVAL]>) + +Can be set to a boolean value to control whether hash keys are quoted. +A false value will avoid quoting hash keys when it looks like a simple +string. Default is 1, which will always enclose hash keys in quotes. + +=item $Data::Dumper::Bless I<or> $I<OBJ>->Bless(I<[NEWVAL]>) + +Can be set to a string that specifies an alternative to the C<bless> +builtin operator used to create objects. A function with the specified +name should exist, and should accept the same arguments as the builtin. +Default is C<bless>. + +=item $Data::Dumper::Maxdepth I<or> $I<OBJ>->Maxdepth(I<[NEWVAL]>) + +Can be set to a positive integer that specifies the depth beyond which +which we don't venture into a structure. Has no effect when +C<Data::Dumper::Purity> is set. (Useful in debugger when we often don't +want to see more than enough). Default is 0, which means there is +no maximum depth. + +=item $Data::Dumper::Useperl I<or> $I<OBJ>->Useperl(I<[NEWVAL]>) + +Can be set to a boolean value which controls whether the pure Perl +implementation of C<Data::Dumper> is used. The C<Data::Dumper> module is +a dual implementation, with almost all functionality written in both +pure Perl and also in XS ('C'). Since the XS version is much faster, it +will always be used if possible. This option lets you override the +default behavior, usually for testing purposes only. Default is 0, which +means the XS implementation will be used if possible. + +=item $Data::Dumper::Sortkeys I<or> $I<OBJ>->Sortkeys(I<[NEWVAL]>) + +Can be set to a boolean value to control whether hash keys are dumped in +sorted order. A true value will cause the keys of all hashes to be +dumped in Perl's default sort order. Can also be set to a subroutine +reference which will be called for each hash that is dumped. In this +case C<Data::Dumper> will call the subroutine once for each hash, +passing it the reference of the hash. The purpose of the subroutine is +to return a reference to an array of the keys that will be dumped, in +the order that they should be dumped. Using this feature, you can +control both the order of the keys, and which keys are actually used. In +other words, this subroutine acts as a filter by which you can exclude +certain keys from being dumped. Default is 0, which means that hash keys +are not sorted. + +=item $Data::Dumper::Deparse I<or> $I<OBJ>->Deparse(I<[NEWVAL]>) + +Can be set to a boolean value to control whether code references are +turned into perl source code. If set to a true value, C<B::Deparse> +will be used to get the source of the code reference. Using this option +will force using the Perl implementation of the dumper, since the fast +XSUB implementation doesn't support it. + +Caution : use this option only if you know that your coderefs will be +properly reconstructed by C<B::Deparse>. + +=back + +=head2 Exports + +=over 4 + +=item Dumper + +=back + +=head1 EXAMPLES + +Run these code snippets to get a quick feel for the behavior of this +module. When you are through with these examples, you may want to +add or change the various configuration variables described above, +to see their behavior. (See the testsuite in the Data::Dumper +distribution for more examples.) + + + use Data::Dumper; + + package Foo; + sub new {bless {'a' => 1, 'b' => sub { return "foo" }}, $_[0]}; + + package Fuz; # a weird REF-REF-SCALAR object + sub new {bless \($_ = \ 'fu\'z'), $_[0]}; + + package main; + $foo = Foo->new; + $fuz = Fuz->new; + $boo = [ 1, [], "abcd", \*foo, + {1 => 'a', 023 => 'b', 0x45 => 'c'}, + \\"p\q\'r", $foo, $fuz]; + + ######## + # simple usage + ######## + + $bar = eval(Dumper($boo)); + print($@) if $@; + print Dumper($boo), Dumper($bar); # pretty print (no array indices) + + $Data::Dumper::Terse = 1; # don't output names where feasible + $Data::Dumper::Indent = 0; # turn off all pretty print + print Dumper($boo), "\n"; + + $Data::Dumper::Indent = 1; # mild pretty print + print Dumper($boo); + + $Data::Dumper::Indent = 3; # pretty print with array indices + print Dumper($boo); + + $Data::Dumper::Useqq = 1; # print strings in double quotes + print Dumper($boo); + + + ######## + # recursive structures + ######## + + @c = ('c'); + $c = \@c; + $b = {}; + $a = [1, $b, $c]; + $b->{a} = $a; + $b->{b} = $a->[1]; + $b->{c} = $a->[2]; + print Data::Dumper->Dump([$a,$b,$c], [qw(a b c)]); + + + $Data::Dumper::Purity = 1; # fill in the holes for eval + print Data::Dumper->Dump([$a, $b], [qw(*a b)]); # print as @a + print Data::Dumper->Dump([$b, $a], [qw(*b a)]); # print as %b + + + $Data::Dumper::Deepcopy = 1; # avoid cross-refs + print Data::Dumper->Dump([$b, $a], [qw(*b a)]); + + + $Data::Dumper::Purity = 0; # avoid cross-refs + print Data::Dumper->Dump([$b, $a], [qw(*b a)]); + + ######## + # deep structures + ######## + + $a = "pearl"; + $b = [ $a ]; + $c = { 'b' => $b }; + $d = [ $c ]; + $e = { 'd' => $d }; + $f = { 'e' => $e }; + print Data::Dumper->Dump([$f], [qw(f)]); + + $Data::Dumper::Maxdepth = 3; # no deeper than 3 refs down + print Data::Dumper->Dump([$f], [qw(f)]); + + + ######## + # object-oriented usage + ######## + + $d = Data::Dumper->new([$a,$b], [qw(a b)]); + $d->Seen({'*c' => $c}); # stash a ref without printing it + $d->Indent(3); + print $d->Dump; + $d->Reset->Purity(0); # empty the seen cache + print join "----\n", $d->Dump; + + + ######## + # persistence + ######## + + package Foo; + sub new { bless { state => 'awake' }, shift } + sub Freeze { + my $s = shift; + print STDERR "preparing to sleep\n"; + $s->{state} = 'asleep'; + return bless $s, 'Foo::ZZZ'; + } + + package Foo::ZZZ; + sub Thaw { + my $s = shift; + print STDERR "waking up\n"; + $s->{state} = 'awake'; + return bless $s, 'Foo'; + } + + package Foo; + use Data::Dumper; + $a = Foo->new; + $b = Data::Dumper->new([$a], ['c']); + $b->Freezer('Freeze'); + $b->Toaster('Thaw'); + $c = $b->Dump; + print $c; + $d = eval $c; + print Data::Dumper->Dump([$d], ['d']); + + + ######## + # symbol substitution (useful for recreating CODE refs) + ######## + + sub foo { print "foo speaking\n" } + *other = \&foo; + $bar = [ \&other ]; + $d = Data::Dumper->new([\&other,$bar],['*other','bar']); + $d->Seen({ '*foo' => \&foo }); + print $d->Dump; + + + ######## + # sorting and filtering hash keys + ######## + + $Data::Dumper::Sortkeys = \&my_filter; + my $foo = { map { (ord, "$_$_$_") } 'I'..'Q' }; + my $bar = { %$foo }; + my $baz = { reverse %$foo }; + print Dumper [ $foo, $bar, $baz ]; + + sub my_filter { + my ($hash) = @_; + # return an array ref containing the hash keys to dump + # in the order that you want them to be dumped + return [ + # Sort the keys of %$foo in reverse numeric order + $hash eq $foo ? (sort {$b <=> $a} keys %$hash) : + # Only dump the odd number keys of %$bar + $hash eq $bar ? (grep {$_ % 2} keys %$hash) : + # Sort keys in default order for all other hashes + (sort keys %$hash) + ]; + } + +=head1 BUGS + +Due to limitations of Perl subroutine call semantics, you cannot pass an +array or hash. Prepend it with a C<\> to pass its reference instead. This +will be remedied in time, now that Perl has subroutine prototypes. +For now, you need to use the extended usage form, and prepend the +name with a C<*> to output it as a hash or array. + +C<Data::Dumper> cheats with CODE references. If a code reference is +encountered in the structure being processed (and if you haven't set +the C<Deparse> flag), an anonymous subroutine that +contains the string '"DUMMY"' will be inserted in its place, and a warning +will be printed if C<Purity> is set. You can C<eval> the result, but bear +in mind that the anonymous sub that gets created is just a placeholder. +Someday, perl will have a switch to cache-on-demand the string +representation of a compiled piece of code, I hope. If you have prior +knowledge of all the code refs that your data structures are likely +to have, you can use the C<Seen> method to pre-seed the internal reference +table and make the dumped output point to them, instead. See L<EXAMPLES> +above. + +The C<Useqq> and C<Deparse> flags makes Dump() run slower, since the +XSUB implementation does not support them. + +SCALAR objects have the weirdest looking C<bless> workaround. + + +=head1 AUTHOR + +Gurusamy Sarathy gsar@activestate.com + +Copyright (c) 1996-98 Gurusamy Sarathy. All rights reserved. +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + + +=head1 VERSION + +Version 2.12 (unreleased) + +=head1 SEE ALSO + +perl(1) + +=cut diff --git a/Master/xemtex/perl/lib/Digest/MD5.pm b/Master/xemtex/perl/lib/Digest/MD5.pm new file mode 100644 index 00000000000..372e007cb70 --- /dev/null +++ b/Master/xemtex/perl/lib/Digest/MD5.pm @@ -0,0 +1,279 @@ +package Digest::MD5; + +use strict; +use vars qw($VERSION @ISA @EXPORT_OK); + +$VERSION = '2.20'; # $Date: 2002/05/06 05:15:09 $ + +require Exporter; +*import = \&Exporter::import; +@EXPORT_OK = qw(md5 md5_hex md5_base64); + +require DynaLoader; +@ISA=qw(DynaLoader); + +eval { + Digest::MD5->bootstrap($VERSION); +}; +if ($@) { + my $olderr = $@; + eval { + # Try to load the pure perl version + require Digest::Perl::MD5; + + Digest::Perl::MD5->import(qw(md5 md5_hex md5_base64)); + push(@ISA, "Digest::Perl::MD5"); # make OO interface work + }; + if ($@) { + # restore the original error + die $olderr; + } +} +else { + *reset = \&new; +} + +1; +__END__ + +=head1 NAME + +Digest::MD5 - Perl interface to the MD5 Algorithm + +=head1 SYNOPSIS + + # Functional style + use Digest::MD5 qw(md5 md5_hex md5_base64); + + $digest = md5($data); + $digest = md5_hex($data); + $digest = md5_base64($data); + + # OO style + use Digest::MD5; + + $ctx = Digest::MD5->new; + + $ctx->add($data); + $ctx->addfile(*FILE); + + $digest = $ctx->digest; + $digest = $ctx->hexdigest; + $digest = $ctx->b64digest; + +=head1 DESCRIPTION + +The C<Digest::MD5> module allows you to use the RSA Data Security +Inc. MD5 Message Digest algorithm from within Perl programs. The +algorithm takes as input a message of arbitrary length and produces as +output a 128-bit "fingerprint" or "message digest" of the input. + +The C<Digest::MD5> module provide a procedural interface for simple +use, as well as an object oriented interface that can handle messages +of arbitrary length and which can read files directly. + +A binary digest will be 16 bytes long. A hex digest will be 32 +characters long. A base64 digest will be 22 characters long. + +=head1 FUNCTIONS + +The following functions can be exported from the C<Digest::MD5> +module. No functions are exported by default. + +=over 4 + +=item md5($data,...) + +This function will concatenate all arguments, calculate the MD5 digest +of this "message", and return it in binary form. + +=item md5_hex($data,...) + +Same as md5(), but will return the digest in hexadecimal form. + +=item md5_base64($data,...) + +Same as md5(), but will return the digest as a base64 encoded string. + +The base64 encoded string returned is not padded to be a multiple of 4 +bytes long. If you want interoperability with other base64 encoded +md5 digests you might want to append the string "==" to the result. + +=back + +=head1 METHODS + +The following methods are available: + +=over 4 + +=item $md5 = Digest::MD5->new + +The constructor returns a new C<Digest::MD5> object which encapsulate +the state of the MD5 message-digest algorithm. You can add data to +the object and finally ask for the digest. + +If called as an instance method (i.e. $md5->new) it will just reset the +state the object to the state of a newly created object. No new +object is created in this case. + +=item $md5->reset + +This is just an alias for $md5->new. + +=item $md5->add($data,...) + +The $data provided as argument are appended to the message we +calculate the digest for. The return value is the $md5 object itself. + +=item $md5->addfile($io_handle) + +The $io_handle is read until EOF and the content is appended to the +message we calculate the digest for. The return value is the $md5 +object itself. + +In most cases you want to make sure that the $io_handle is set up to +be in binmode(). + +=item $md5->digest + +Return the binary digest for the message. + +Note that the C<digest> operation is effectively a destructive, +read-once operation. Once it has been performed, the C<Digest::MD5> +object is automatically C<reset> and can be used to calculate another +digest value. + +=item $md5->hexdigest + +Same as $md5->digest, but will return the digest in hexadecimal form. + +=item $md5->b64digest + +Same as $md5->digest, but will return the digest as a base64 encoded +string. + +The base64 encoded string returned is not padded to be a multiple of 4 +bytes long. If you want interoperability with other base64 encoded +md5 digests you might want to append the string "==" to the result. + +=back + + +=head1 EXAMPLES + +The simplest way to use this library is to import the md5_hex() +function (or one of its cousins): + + use Digest::MD5 qw(md5_hex); + print "Digest is ", md5_hex("foobarbaz"), "\n"; + +The above example would print out the message + + Digest is 6df23dc03f9b54cc38a0fc1483df6e21 + +provided that the implementation is working correctly. The same +checksum can also be calculated in OO style: + + use Digest::MD5; + + $md5 = Digest::MD5->new; + $md5->add('foo', 'bar'); + $md5->add('baz'); + $digest = $md5->hexdigest; + + print "Digest is $digest\n"; + +With OO style you can break the message arbitrary. This means that we +are no longer limited to have space for the whole message in memory, i.e. +we can handle messages of any size. + +This is useful when calculating checksum for files: + + use Digest::MD5; + + my $file = shift || "/etc/passwd"; + open(FILE, $file) or die "Can't open '$file': $!"; + binmode(FILE); + + $md5 = Digest::MD5->new; + while (<FILE>) { + $md5->add($_); + } + close(FILE); + print $md5->b64digest, " $file\n"; + +Or we can use the builtin addfile method for more efficient reading of +the file: + + use Digest::MD5; + + my $file = shift || "/etc/passwd"; + open(FILE, $file) or die "Can't open '$file': $!"; + binmode(FILE); + + print Digest::MD5->new->addfile(*FILE)->hexdigest, " $file\n"; + +=head1 SEE ALSO + +L<Digest>, +L<Digest::MD2>, +L<Digest::SHA1>, +L<Digest::HMAC> + +L<md5sum(1)> + +RFC 1321 + +=head1 COPYRIGHT + +This library is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + + Copyright 1998-2002 Gisle Aas. + Copyright 1995-1996 Neil Winton. + Copyright 1991-1992 RSA Data Security, Inc. + +The MD5 algorithm is defined in RFC 1321. The basic C code +implementing the algorithm is derived from that in the RFC and is +covered by the following copyright: + +=over 4 + +=item + +Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + +=back + +This copyright does not prohibit distribution of any version of Perl +containing this extension under the terms of the GNU or Artistic +licenses. + +=head1 AUTHORS + +The original MD5 interface was written by Neil Winton +(C<N.Winton@axion.bt.co.uk>). + +This release was made by Gisle Aas <gisle@ActiveState.com> + +=cut diff --git a/Master/xemtex/perl/lib/DynaLoader.pm b/Master/xemtex/perl/lib/DynaLoader.pm new file mode 100644 index 00000000000..da7923e2bc2 --- /dev/null +++ b/Master/xemtex/perl/lib/DynaLoader.pm @@ -0,0 +1,826 @@ + +# Generated from DynaLoader.pm.PL + +package DynaLoader; + +# And Gandalf said: 'Many folk like to know beforehand what is to +# be set on the table; but those who have laboured to prepare the +# feast like to keep their secret; for wonder makes the words of +# praise louder.' + +# (Quote from Tolkien suggested by Anno Siegel.) +# +# See pod text at end of file for documentation. +# See also ext/DynaLoader/README in source tree for other information. +# +# Tim.Bunce@ig.co.uk, August 1994 + +use vars qw($VERSION *AUTOLOAD); + +$VERSION = 1.04; # avoid typo warning + +require AutoLoader; +*AUTOLOAD = \&AutoLoader::AUTOLOAD; + +use Config; + +# The following require can't be removed during maintenance +# releases, sadly, because of the risk of buggy code that does +# require Carp; Carp::croak "..."; without brackets dying +# if Carp hasn't been loaded in earlier compile time. :-( +# We'll let those bugs get found on the development track. +require Carp if $] < 5.00450; + +# enable debug/trace messages from DynaLoader perl code +$dl_debug = $ENV{PERL_DL_DEBUG} || 0 unless defined $dl_debug; + +# +# Flags to alter dl_load_file behaviour. Assigned bits: +# 0x01 make symbols available for linking later dl_load_file's. +# (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL)) +# (ignored under VMS; effect is built-in to image linking) +# +# This is called as a class method $module->dl_load_flags. The +# definition here will be inherited and result on "default" loading +# behaviour unless a sub-class of DynaLoader defines its own version. +# + +sub dl_load_flags { 0x00 } + +# ($dl_dlext, $dlsrc) +# = @Config::Config{'dlext', 'dlsrc'}; + ($dl_dlext, $dlsrc) = ('dll','dl_win32.xs') +; +# Some systems need special handling to expand file specifications +# (VMS support by Charles Bailey <bailey@HMIVAX.HUMGEN.UPENN.EDU>) +# See dl_expandspec() for more details. Should be harmless but +# inefficient to define on systems that don't need it. +$Is_VMS = $^O eq 'VMS'; +$do_expand = $Is_VMS; +$Is_MacOS = $^O eq 'MacOS'; + +my $Mac_FS; +$Mac_FS = eval { require Mac::FileSpec::Unixish } if $Is_MacOS; + +@dl_require_symbols = (); # names of symbols we need +@dl_resolve_using = (); # names of files to link with +@dl_library_path = (); # path to look for files + +#XSLoader.pm may have added elements before we were required +#@dl_librefs = (); # things we have loaded +#@dl_modules = (); # Modules we have loaded + +# This is a fix to support DLD's unfortunate desire to relink -lc +@dl_resolve_using = dl_findfile('-lc') if $dlsrc eq "dl_dld.xs"; + +# Initialise @dl_library_path with the 'standard' library path +# for this platform as determined by Configure. + +push(@dl_library_path, split(' ', $Config::Config{libpth})); + + +my $ldlibpthname = $Config::Config{ldlibpthname}; +my $ldlibpthname_defined = defined $Config::Config{ldlibpthname}; +my $pthsep = $Config::Config{path_sep}; + +# Add to @dl_library_path any extra directories we can gather from environment +# during runtime. + +if ($ldlibpthname_defined && + exists $ENV{$ldlibpthname}) { + push(@dl_library_path, split(/$pthsep/, $ENV{$ldlibpthname})); +} + +# E.g. HP-UX supports both its native SHLIB_PATH *and* LD_LIBRARY_PATH. + +if ($ldlibpthname_defined && + $ldlibpthname ne 'LD_LIBRARY_PATH' && + exists $ENV{LD_LIBRARY_PATH}) { + push(@dl_library_path, split(/$pthsep/, $ENV{LD_LIBRARY_PATH})); +} + + +# No prizes for guessing why we don't say 'bootstrap DynaLoader;' here. +# NOTE: All dl_*.xs (including dl_none.xs) define a dl_error() XSUB +boot_DynaLoader('DynaLoader') if defined(&boot_DynaLoader) && + !defined(&dl_error); + +if ($dl_debug) { + print STDERR "DynaLoader.pm loaded (@INC, @dl_library_path)\n"; + print STDERR "DynaLoader not linked into this perl\n" + unless defined(&boot_DynaLoader); +} + +1; # End of main code + + +sub croak { require Carp; Carp::croak(@_) } + +sub bootstrap_inherit { + my $module = $_[0]; + local *isa = *{"$module\::ISA"}; + local @isa = (@isa, 'DynaLoader'); + # Cannot goto due to delocalization. Will report errors on a wrong line? + bootstrap(@_); +} + +# The bootstrap function cannot be autoloaded (without complications) +# so we define it here: + +sub bootstrap { + # use local vars to enable $module.bs script to edit values + local(@args) = @_; + local($module) = $args[0]; + local(@dirs, $file); + + unless ($module) { + require Carp; + Carp::confess("Usage: DynaLoader::bootstrap(module)"); + } + + # A common error on platforms which don't support dynamic loading. + # Since it's fatal and potentially confusing we give a detailed message. + croak("Can't load module $module, dynamic loading not available in this perl.\n". + " (You may need to build a new perl executable which either supports\n". + " dynamic loading or has the $module module statically linked into it.)\n") + unless defined(&dl_load_file); + + my @modparts = split(/::/,$module); + my $modfname = $modparts[-1]; + + # Some systems have restrictions on files names for DLL's etc. + # mod2fname returns appropriate file base name (typically truncated) + # It may also edit @modparts if required. + $modfname = &mod2fname(\@modparts) if defined &mod2fname; + + # Truncate the module name to 8.3 format for NetWare + if (($^O eq 'NetWare') && (length($modfname) > 8)) { + $modfname = substr($modfname, 0, 8); + } + + my $modpname = join(($Is_MacOS ? ':' : '/'),@modparts); + + print STDERR "DynaLoader::bootstrap for $module ", + ($Is_MacOS + ? "(:auto:$modpname:$modfname.$dl_dlext)\n" : + "(auto/$modpname/$modfname.$dl_dlext)\n") + if $dl_debug; + + foreach (@INC) { + chop($_ = VMS::Filespec::unixpath($_)) if $Is_VMS; + my $dir; + if ($Is_MacOS) { + my $path = $_; + if ($Mac_FS && ! -d $path) { + $path = Mac::FileSpec::Unixish::nativize($path); + } + $path .= ":" unless /:$/; + $dir = "${path}auto:$modpname"; + } else { + $dir = "$_/auto/$modpname"; + } + + next unless -d $dir; # skip over uninteresting directories + + # check for common cases to avoid autoload of dl_findfile + my $try = $Is_MacOS ? "$dir:$modfname.$dl_dlext" : "$dir/$modfname.$dl_dlext"; + last if $file = ($do_expand) ? dl_expandspec($try) : ((-f $try) && $try); + + # no luck here, save dir for possible later dl_findfile search + push @dirs, $dir; + } + # last resort, let dl_findfile have a go in all known locations + $file = dl_findfile(map("-L$_",@dirs,@INC), $modfname) unless $file; + + croak("Can't locate loadable object for module $module in \@INC (\@INC contains: @INC)") + unless $file; # wording similar to error from 'require' + + $file = uc($file) if $Is_VMS && $Config::Config{d_vms_case_sensitive_symbols}; + my $bootname = "boot_$module"; + $bootname =~ s/\W/_/g; + @dl_require_symbols = ($bootname); + + # Execute optional '.bootstrap' perl script for this module. + # The .bs file can be used to configure @dl_resolve_using etc to + # match the needs of the individual module on this architecture. + my $bs = $file; + $bs =~ s/(\.\w+)?(;\d*)?$/\.bs/; # look for .bs 'beside' the library + if (-s $bs) { # only read file if it's not empty + print STDERR "BS: $bs ($^O, $dlsrc)\n" if $dl_debug; + eval { do $bs; }; + warn "$bs: $@\n" if $@; + } + + my $boot_symbol_ref; + + if ($^O eq 'darwin') { + if ($boot_symbol_ref = dl_find_symbol(0, $bootname)) { + goto boot; #extension library has already been loaded, e.g. darwin + } + } + + # Many dynamic extension loading problems will appear to come from + # this section of code: XYZ failed at line 123 of DynaLoader.pm. + # Often these errors are actually occurring in the initialisation + # C code of the extension XS file. Perl reports the error as being + # in this perl code simply because this was the last perl code + # it executed. + + my $libref = dl_load_file($file, $module->dl_load_flags) or + croak("Can't load '$file' for module $module: ".dl_error()); + + push(@dl_librefs,$libref); # record loaded object + + my @unresolved = dl_undef_symbols(); + if (@unresolved) { + require Carp; + Carp::carp("Undefined symbols present after loading $file: @unresolved\n"); + } + + $boot_symbol_ref = dl_find_symbol($libref, $bootname) or + croak("Can't find '$bootname' symbol in $file\n"); + + push(@dl_modules, $module); # record loaded module + + boot: + my $xs = dl_install_xsub("${module}::bootstrap", $boot_symbol_ref, $file); + + # See comment block above + &$xs(@args); +} + + +#sub _check_file { # private utility to handle dl_expandspec vs -f tests +# my($file) = @_; +# return $file if (!$do_expand && -f $file); # the common case +# return $file if ( $do_expand && ($file=dl_expandspec($file))); +# return undef; +#} + + +# Let autosplit and the autoloader deal with these functions: +__END__ + + +sub dl_findfile { + # Read ext/DynaLoader/DynaLoader.doc for detailed information. + # This function does not automatically consider the architecture + # or the perl library auto directories. + my (@args) = @_; + my (@dirs, $dir); # which directories to search + my (@found); # full paths to real files we have found + my $dl_ext= 'dll'; # $Config::Config{'dlext'} suffix for perl extensions + my $dl_so = 'dll'; # $Config::Config{'so'} suffix for shared libraries + + print STDERR "dl_findfile(@args)\n" if $dl_debug; + + # accumulate directories but process files as they appear + arg: foreach(@args) { + # Special fast case: full filepath requires no search + if ($Is_VMS && m%[:>/\]]% && -f $_) { + push(@found,dl_expandspec(VMS::Filespec::vmsify($_))); + last arg unless wantarray; + next; + } + elsif ($Is_MacOS) { + if (m/:/ && -f $_) { + push(@found,$_); + last arg unless wantarray; + } + } + elsif (m:/: && -f $_ && !$do_expand) { + push(@found,$_); + last arg unless wantarray; + next; + } + + # Deal with directories first: + # Using a -L prefix is the preferred option (faster and more robust) + if (m:^-L:) { s/^-L//; push(@dirs, $_); next; } + + if ($Is_MacOS) { + # Otherwise we try to try to spot directories by a heuristic + # (this is a more complicated issue than it first appears) + if (m/:/ && -d $_) { push(@dirs, $_); next; } + # Only files should get this far... + my(@names, $name); # what filenames to look for + s/^-l//; + push(@names, $_); + foreach $dir (@dirs, @dl_library_path) { + next unless -d $dir; + $dir =~ s/^([^:]+)$/:$1/; + $dir =~ s/:$//; + foreach $name (@names) { + my($file) = "$dir:$name"; + print STDERR " checking in $dir for $name\n" if $dl_debug; + if (-f $file) { + push(@found, $file); + next arg; # no need to look any further + } + } + } + next; + } + + # Otherwise we try to try to spot directories by a heuristic + # (this is a more complicated issue than it first appears) + if (m:/: && -d $_) { push(@dirs, $_); next; } + + # VMS: we may be using native VMS directory syntax instead of + # Unix emulation, so check this as well + if ($Is_VMS && /[:>\]]/ && -d $_) { push(@dirs, $_); next; } + + # Only files should get this far... + my(@names, $name); # what filenames to look for + if (m:-l: ) { # convert -lname to appropriate library name + s/-l//; + push(@names,"lib$_.$dl_so"); + push(@names,"lib$_.a"); + } else { # Umm, a bare name. Try various alternatives: + # these should be ordered with the most likely first + push(@names,"$_.$dl_ext") unless m/\.$dl_ext$/o; + push(@names,"$_.$dl_so") unless m/\.$dl_so$/o; + push(@names,"lib$_.$dl_so") unless m:/:; + push(@names,"$_.a") if !m/\.a$/ and $dlsrc eq "dl_dld.xs"; + push(@names, $_); + } + foreach $dir (@dirs, @dl_library_path) { + next unless -d $dir; + chop($dir = VMS::Filespec::unixpath($dir)) if $Is_VMS; + foreach $name (@names) { + my($file) = "$dir/$name"; + print STDERR " checking in $dir for $name\n" if $dl_debug; + $file = ($do_expand) ? dl_expandspec($file) : (-f $file && $file); + #$file = _check_file($file); + if ($file) { + push(@found, $file); + next arg; # no need to look any further + } + } + } + } + if ($dl_debug) { + foreach(@dirs) { + print STDERR " dl_findfile ignored non-existent directory: $_\n" unless -d $_; + } + print STDERR "dl_findfile found: @found\n"; + } + return $found[0] unless wantarray; + @found; +} + + +sub dl_expandspec { + my($spec) = @_; + # Optional function invoked if DynaLoader.pm sets $do_expand. + # Most systems do not require or use this function. + # Some systems may implement it in the dl_*.xs file in which case + # this autoload version will not be called but is harmless. + + # This function is designed to deal with systems which treat some + # 'filenames' in a special way. For example VMS 'Logical Names' + # (something like unix environment variables - but different). + # This function should recognise such names and expand them into + # full file paths. + # Must return undef if $spec is invalid or file does not exist. + + my $file = $spec; # default output to input + + if ($Is_VMS) { # dl_expandspec should be defined in dl_vms.xs + require Carp; + Carp::croak("dl_expandspec: should be defined in XS file!\n"); + } else { + return undef unless -f $file; + } + print STDERR "dl_expandspec($spec) => $file\n" if $dl_debug; + $file; +} + +sub dl_find_symbol_anywhere +{ + my $sym = shift; + my $libref; + foreach $libref (@dl_librefs) { + my $symref = dl_find_symbol($libref,$sym); + return $symref if $symref; + } + return undef; +} + +=head1 NAME + +DynaLoader - Dynamically load C libraries into Perl code + +dl_error(), dl_findfile(), dl_expandspec(), dl_load_file(), dl_unload_file(), dl_find_symbol(), dl_find_symbol_anywhere(), dl_undef_symbols(), dl_install_xsub(), dl_load_flags(), bootstrap() - routines used by DynaLoader modules + +=head1 SYNOPSIS + + package YourPackage; + require DynaLoader; + @ISA = qw(... DynaLoader ...); + bootstrap YourPackage; + + # optional method for 'global' loading + sub dl_load_flags { 0x01 } + + +=head1 DESCRIPTION + +This document defines a standard generic interface to the dynamic +linking mechanisms available on many platforms. Its primary purpose is +to implement automatic dynamic loading of Perl modules. + +This document serves as both a specification for anyone wishing to +implement the DynaLoader for a new platform and as a guide for +anyone wishing to use the DynaLoader directly in an application. + +The DynaLoader is designed to be a very simple high-level +interface that is sufficiently general to cover the requirements +of SunOS, HP-UX, NeXT, Linux, VMS and other platforms. + +It is also hoped that the interface will cover the needs of OS/2, NT +etc and also allow pseudo-dynamic linking (using C<ld -A> at runtime). + +It must be stressed that the DynaLoader, by itself, is practically +useless for accessing non-Perl libraries because it provides almost no +Perl-to-C 'glue'. There is, for example, no mechanism for calling a C +library function or supplying arguments. A C::DynaLib module +is available from CPAN sites which performs that function for some +common system types. And since the year 2000, there's also Inline::C, +a module that allows you to write Perl subroutines in C. Also available +from your local CPAN site. + +DynaLoader Interface Summary + + @dl_library_path + @dl_resolve_using + @dl_require_symbols + $dl_debug + @dl_librefs + @dl_modules + Implemented in: + bootstrap($modulename) Perl + @filepaths = dl_findfile(@names) Perl + $flags = $modulename->dl_load_flags Perl + $symref = dl_find_symbol_anywhere($symbol) Perl + + $libref = dl_load_file($filename, $flags) C + $status = dl_unload_file($libref) C + $symref = dl_find_symbol($libref, $symbol) C + @symbols = dl_undef_symbols() C + dl_install_xsub($name, $symref [, $filename]) C + $message = dl_error C + +=over 4 + +=item @dl_library_path + +The standard/default list of directories in which dl_findfile() will +search for libraries etc. Directories are searched in order: +$dl_library_path[0], [1], ... etc + +@dl_library_path is initialised to hold the list of 'normal' directories +(F</usr/lib>, etc) determined by B<Configure> (C<$Config{'libpth'}>). This should +ensure portability across a wide range of platforms. + +@dl_library_path should also be initialised with any other directories +that can be determined from the environment at runtime (such as +LD_LIBRARY_PATH for SunOS). + +After initialisation @dl_library_path can be manipulated by an +application using push and unshift before calling dl_findfile(). +Unshift can be used to add directories to the front of the search order +either to save search time or to override libraries with the same name +in the 'normal' directories. + +The load function that dl_load_file() calls may require an absolute +pathname. The dl_findfile() function and @dl_library_path can be +used to search for and return the absolute pathname for the +library/object that you wish to load. + +=item @dl_resolve_using + +A list of additional libraries or other shared objects which can be +used to resolve any undefined symbols that might be generated by a +later call to load_file(). + +This is only required on some platforms which do not handle dependent +libraries automatically. For example the Socket Perl extension +library (F<auto/Socket/Socket.so>) contains references to many socket +functions which need to be resolved when it's loaded. Most platforms +will automatically know where to find the 'dependent' library (e.g., +F</usr/lib/libsocket.so>). A few platforms need to be told the +location of the dependent library explicitly. Use @dl_resolve_using +for this. + +Example usage: + + @dl_resolve_using = dl_findfile('-lsocket'); + +=item @dl_require_symbols + +A list of one or more symbol names that are in the library/object file +to be dynamically loaded. This is only required on some platforms. + +=item @dl_librefs + +An array of the handles returned by successful calls to dl_load_file(), +made by bootstrap, in the order in which they were loaded. +Can be used with dl_find_symbol() to look for a symbol in any of +the loaded files. + +=item @dl_modules + +An array of module (package) names that have been bootstrap'ed. + +=item dl_error() + +Syntax: + + $message = dl_error(); + +Error message text from the last failed DynaLoader function. Note +that, similar to errno in unix, a successful function call does not +reset this message. + +Implementations should detect the error as soon as it occurs in any of +the other functions and save the corresponding message for later +retrieval. This will avoid problems on some platforms (such as SunOS) +where the error message is very temporary (e.g., dlerror()). + +=item $dl_debug + +Internal debugging messages are enabled when $dl_debug is set true. +Currently setting $dl_debug only affects the Perl side of the +DynaLoader. These messages should help an application developer to +resolve any DynaLoader usage problems. + +$dl_debug is set to C<$ENV{'PERL_DL_DEBUG'}> if defined. + +For the DynaLoader developer/porter there is a similar debugging +variable added to the C code (see dlutils.c) and enabled if Perl was +built with the B<-DDEBUGGING> flag. This can also be set via the +PERL_DL_DEBUG environment variable. Set to 1 for minimal information or +higher for more. + +=item dl_findfile() + +Syntax: + + @filepaths = dl_findfile(@names) + +Determine the full paths (including file suffix) of one or more +loadable files given their generic names and optionally one or more +directories. Searches directories in @dl_library_path by default and +returns an empty list if no files were found. + +Names can be specified in a variety of platform independent forms. Any +names in the form B<-lname> are converted into F<libname.*>, where F<.*> is +an appropriate suffix for the platform. + +If a name does not already have a suitable prefix and/or suffix then +the corresponding file will be searched for by trying combinations of +prefix and suffix appropriate to the platform: "$name.o", "lib$name.*" +and "$name". + +If any directories are included in @names they are searched before +@dl_library_path. Directories may be specified as B<-Ldir>. Any other +names are treated as filenames to be searched for. + +Using arguments of the form C<-Ldir> and C<-lname> is recommended. + +Example: + + @dl_resolve_using = dl_findfile(qw(-L/usr/5lib -lposix)); + + +=item dl_expandspec() + +Syntax: + + $filepath = dl_expandspec($spec) + +Some unusual systems, such as VMS, require special filename handling in +order to deal with symbolic names for files (i.e., VMS's Logical Names). + +To support these systems a dl_expandspec() function can be implemented +either in the F<dl_*.xs> file or code can be added to the autoloadable +dl_expandspec() function in F<DynaLoader.pm>. See F<DynaLoader.pm> for +more information. + +=item dl_load_file() + +Syntax: + + $libref = dl_load_file($filename, $flags) + +Dynamically load $filename, which must be the path to a shared object +or library. An opaque 'library reference' is returned as a handle for +the loaded object. Returns undef on error. + +The $flags argument to alters dl_load_file behaviour. +Assigned bits: + + 0x01 make symbols available for linking later dl_load_file's. + (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL)) + (ignored under VMS; this is a normal part of image linking) + +(On systems that provide a handle for the loaded object such as SunOS +and HPUX, $libref will be that handle. On other systems $libref will +typically be $filename or a pointer to a buffer containing $filename. +The application should not examine or alter $libref in any way.) + +This is the function that does the real work. It should use the +current values of @dl_require_symbols and @dl_resolve_using if required. + + SunOS: dlopen($filename) + HP-UX: shl_load($filename) + Linux: dld_create_reference(@dl_require_symbols); dld_link($filename) + NeXT: rld_load($filename, @dl_resolve_using) + VMS: lib$find_image_symbol($filename,$dl_require_symbols[0]) + +(The dlopen() function is also used by Solaris and some versions of +Linux, and is a common choice when providing a "wrapper" on other +mechanisms as is done in the OS/2 port.) + +=item dl_unload_file() + +Syntax: + + $status = dl_unload_file($libref) + +Dynamically unload $libref, which must be an opaque 'library reference' as +returned from dl_load_file. Returns one on success and zero on failure. + +This function is optional and may not necessarily be provided on all platforms. +If it is defined, it is called automatically when the interpreter exits for +every shared object or library loaded by DynaLoader::bootstrap. All such +library references are stored in @dl_librefs by DynaLoader::Bootstrap as it +loads the libraries. The files are unloaded in last-in, first-out order. + +This unloading is usually necessary when embedding a shared-object perl (e.g. +one configured with -Duseshrplib) within a larger application, and the perl +interpreter is created and destroyed several times within the lifetime of the +application. In this case it is possible that the system dynamic linker will +unload and then subsequently reload the shared libperl without relocating any +references to it from any files DynaLoaded by the previous incarnation of the +interpreter. As a result, any shared objects opened by DynaLoader may point to +a now invalid 'ghost' of the libperl shared object, causing apparently random +memory corruption and crashes. This behaviour is most commonly seen when using +Apache and mod_perl built with the APXS mechanism. + + SunOS: dlclose($libref) + HP-UX: ??? + Linux: ??? + NeXT: ??? + VMS: ??? + +(The dlclose() function is also used by Solaris and some versions of +Linux, and is a common choice when providing a "wrapper" on other +mechanisms as is done in the OS/2 port.) + +=item dl_loadflags() + +Syntax: + + $flags = dl_loadflags $modulename; + +Designed to be a method call, and to be overridden by a derived class +(i.e. a class which has DynaLoader in its @ISA). The definition in +DynaLoader itself returns 0, which produces standard behavior from +dl_load_file(). + +=item dl_find_symbol() + +Syntax: + + $symref = dl_find_symbol($libref, $symbol) + +Return the address of the symbol $symbol or C<undef> if not found. If the +target system has separate functions to search for symbols of different +types then dl_find_symbol() should search for function symbols first and +then other types. + +The exact manner in which the address is returned in $symref is not +currently defined. The only initial requirement is that $symref can +be passed to, and understood by, dl_install_xsub(). + + SunOS: dlsym($libref, $symbol) + HP-UX: shl_findsym($libref, $symbol) + Linux: dld_get_func($symbol) and/or dld_get_symbol($symbol) + NeXT: rld_lookup("_$symbol") + VMS: lib$find_image_symbol($libref,$symbol) + + +=item dl_find_symbol_anywhere() + +Syntax: + + $symref = dl_find_symbol_anywhere($symbol) + +Applies dl_find_symbol() to the members of @dl_librefs and returns +the first match found. + +=item dl_undef_symbols() + +Example + + @symbols = dl_undef_symbols() + +Return a list of symbol names which remain undefined after load_file(). +Returns C<()> if not known. Don't worry if your platform does not provide +a mechanism for this. Most do not need it and hence do not provide it, +they just return an empty list. + + +=item dl_install_xsub() + +Syntax: + + dl_install_xsub($perl_name, $symref [, $filename]) + +Create a new Perl external subroutine named $perl_name using $symref as +a pointer to the function which implements the routine. This is simply +a direct call to newXSUB(). Returns a reference to the installed +function. + +The $filename parameter is used by Perl to identify the source file for +the function if required by die(), caller() or the debugger. If +$filename is not defined then "DynaLoader" will be used. + + +=item bootstrap() + +Syntax: + +bootstrap($module) + +This is the normal entry point for automatic dynamic loading in Perl. + +It performs the following actions: + +=over 8 + +=item * + +locates an auto/$module directory by searching @INC + +=item * + +uses dl_findfile() to determine the filename to load + +=item * + +sets @dl_require_symbols to C<("boot_$module")> + +=item * + +executes an F<auto/$module/$module.bs> file if it exists +(typically used to add to @dl_resolve_using any files which +are required to load the module on the current platform) + +=item * + +calls dl_load_flags() to determine how to load the file. + +=item * + +calls dl_load_file() to load the file + +=item * + +calls dl_undef_symbols() and warns if any symbols are undefined + +=item * + +calls dl_find_symbol() for "boot_$module" + +=item * + +calls dl_install_xsub() to install it as "${module}::bootstrap" + +=item * + +calls &{"${module}::bootstrap"} to bootstrap the module (actually +it uses the function reference returned by dl_install_xsub for speed) + +=back + +=back + + +=head1 AUTHOR + +Tim Bunce, 11 August 1994. + +This interface is based on the work and comments of (in no particular +order): Larry Wall, Robert Sanders, Dean Roehrich, Jeff Okamoto, Anno +Siegel, Thomas Neumann, Paul Marquess, Charles Bailey, myself and others. + +Larry Wall designed the elegant inherited bootstrap mechanism and +implemented the first Perl 5 dynamic loader using it. + +Solaris global loading added by Nick Ing-Simmons with design/coding +assistance from Tim Bunce, January 1996. + +=cut diff --git a/Master/xemtex/perl/lib/Errno.pm b/Master/xemtex/perl/lib/Errno.pm new file mode 100644 index 00000000000..e23fdf215d2 --- /dev/null +++ b/Master/xemtex/perl/lib/Errno.pm @@ -0,0 +1,221 @@ +# +# This file is auto-generated. ***ANY*** changes here will be lost +# + +package Errno; +our (@EXPORT_OK,%EXPORT_TAGS,@ISA,$VERSION,%errno,$AUTOLOAD); +use Exporter (); +use Config; +use strict; + +"$Config{'archname'}-$Config{'osvers'}" eq +"MSWin32-x86-multi-thread-4.0" or + die "Errno architecture (MSWin32-x86-multi-thread-4.0) does not match executable architecture ($Config{'archname'}-$Config{'osvers'})"; + +$VERSION = "1.09_00"; +$VERSION = eval $VERSION; +@ISA = qw(Exporter); + +@EXPORT_OK = qw(EROFS ESHUTDOWN EPROTONOSUPPORT ENFILE ENOLCK + EADDRINUSE ECONNABORTED EBADF EDEADLK ENOTDIR EINVAL ENOTTY EXDEV + ELOOP ECONNREFUSED EISCONN EFBIG ECONNRESET EPFNOSUPPORT ENOENT + EDISCON EWOULDBLOCK EDOM EMSGSIZE EDESTADDRREQ ENOTSOCK EIO ENOSPC + EINPROGRESS ENOBUFS ERANGE EADDRNOTAVAIL EAFNOSUPPORT ENOSYS EINTR + EHOSTDOWN EREMOTE EILSEQ ENOMEM ENOTCONN ENETUNREACH EPIPE ESTALE + EDQUOT EUSERS EOPNOTSUPP ESPIPE EALREADY EMFILE ENAMETOOLONG EACCES + ENOEXEC EISDIR EPROCLIM EBUSY E2BIG EPERM EEXIST ETOOMANYREFS + ESOCKTNOSUPPORT ETIMEDOUT ENXIO ESRCH ENODEV EFAULT EAGAIN EMLINK + EDEADLOCK ENOPROTOOPT ECHILD ENETDOWN EHOSTUNREACH EPROTOTYPE + ENETRESET ENOTEMPTY); + +%EXPORT_TAGS = ( + POSIX => [qw( + E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY + EBADF EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK + EDESTADDRREQ EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH + EINPROGRESS EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS + ENODEV ENOENT ENOEXEC ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTCONN + ENOTDIR ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM EPFNOSUPPORT + EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE EROFS + ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS + EUSERS EWOULDBLOCK EXDEV + )] +); + +sub EPERM () { 1 } +sub ENOENT () { 2 } +sub ESRCH () { 3 } +sub EINTR () { 4 } +sub EIO () { 5 } +sub ENXIO () { 6 } +sub E2BIG () { 7 } +sub ENOEXEC () { 8 } +sub EBADF () { 9 } +sub ECHILD () { 10 } +sub EAGAIN () { 11 } +sub ENOMEM () { 12 } +sub EACCES () { 13 } +sub EFAULT () { 14 } +sub EBUSY () { 16 } +sub EEXIST () { 17 } +sub EXDEV () { 18 } +sub ENODEV () { 19 } +sub ENOTDIR () { 20 } +sub EISDIR () { 21 } +sub EINVAL () { 22 } +sub ENFILE () { 23 } +sub EMFILE () { 24 } +sub ENOTTY () { 25 } +sub EFBIG () { 27 } +sub ENOSPC () { 28 } +sub ESPIPE () { 29 } +sub EROFS () { 30 } +sub EMLINK () { 31 } +sub EPIPE () { 32 } +sub EDOM () { 33 } +sub ERANGE () { 34 } +sub EDEADLK () { 36 } +sub EDEADLOCK () { 36 } +sub ENAMETOOLONG () { 38 } +sub ENOLCK () { 39 } +sub ENOSYS () { 40 } +sub ENOTEMPTY () { 41 } +sub EILSEQ () { 42 } +sub EWOULDBLOCK () { 10035 } +sub EINPROGRESS () { 10036 } +sub EALREADY () { 10037 } +sub ENOTSOCK () { 10038 } +sub EDESTADDRREQ () { 10039 } +sub EMSGSIZE () { 10040 } +sub EPROTOTYPE () { 10041 } +sub ENOPROTOOPT () { 10042 } +sub EPROTONOSUPPORT () { 10043 } +sub ESOCKTNOSUPPORT () { 10044 } +sub EOPNOTSUPP () { 10045 } +sub EPFNOSUPPORT () { 10046 } +sub EAFNOSUPPORT () { 10047 } +sub EADDRINUSE () { 10048 } +sub EADDRNOTAVAIL () { 10049 } +sub ENETDOWN () { 10050 } +sub ENETUNREACH () { 10051 } +sub ENETRESET () { 10052 } +sub ECONNABORTED () { 10053 } +sub ECONNRESET () { 10054 } +sub ENOBUFS () { 10055 } +sub EISCONN () { 10056 } +sub ENOTCONN () { 10057 } +sub ESHUTDOWN () { 10058 } +sub ETOOMANYREFS () { 10059 } +sub ETIMEDOUT () { 10060 } +sub ECONNREFUSED () { 10061 } +sub ELOOP () { 10062 } +sub EHOSTDOWN () { 10064 } +sub EHOSTUNREACH () { 10065 } +sub EPROCLIM () { 10067 } +sub EUSERS () { 10068 } +sub EDQUOT () { 10069 } +sub ESTALE () { 10070 } +sub EREMOTE () { 10071 } +sub EDISCON () { 10101 } + +sub TIEHASH { bless [] } + +sub FETCH { + my ($self, $errname) = @_; + my $proto = prototype("Errno::$errname"); + my $errno = ""; + if (defined($proto) && $proto eq "") { + no strict 'refs'; + $errno = &$errname; + $errno = 0 unless $! == $errno; + } + return $errno; +} + +sub STORE { + require Carp; + Carp::confess("ERRNO hash is read only!"); +} + +*CLEAR = \&STORE; +*DELETE = \&STORE; + +sub NEXTKEY { + my($k,$v); + while(($k,$v) = each %Errno::) { + my $proto = prototype("Errno::$k"); + last if (defined($proto) && $proto eq ""); + } + $k +} + +sub FIRSTKEY { + my $s = scalar keys %Errno::; # initialize iterator + goto &NEXTKEY; +} + +sub EXISTS { + my ($self, $errname) = @_; + my $proto = prototype($errname); + defined($proto) && $proto eq ""; +} + +tie %!, __PACKAGE__; + +1; +__END__ + +=head1 NAME + +Errno - System errno constants + +=head1 SYNOPSIS + + use Errno qw(EINTR EIO :POSIX); + +=head1 DESCRIPTION + +C<Errno> defines and conditionally exports all the error constants +defined in your system C<errno.h> include file. It has a single export +tag, C<:POSIX>, which will export all POSIX defined error numbers. + +C<Errno> also makes C<%!> magic such that each element of C<%!> has a +non-zero value only if C<$!> is set to that value. For example: + + use Errno; + + unless (open(FH, "/fangorn/spouse")) { + if ($!{ENOENT}) { + warn "Get a wife!\n"; + } else { + warn "This path is barred: $!"; + } + } + +If a specified constant C<EFOO> does not exist on the system, C<$!{EFOO}> +returns C<"">. You may use C<exists $!{EFOO}> to check whether the +constant is available on the system. + +=head1 CAVEATS + +Importing a particular constant may not be very portable, because the +import will fail on platforms that do not have that constant. A more +portable way to set C<$!> to a valid value is to use: + + if (exists &Errno::EFOO) { + $! = &Errno::EFOO; + } + +=head1 AUTHOR + +Graham Barr <gbarr@pobox.com> + +=head1 COPYRIGHT + +Copyright (c) 1997-8 Graham Barr. All rights reserved. +This program is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +=cut + diff --git a/Master/xemtex/perl/lib/Exporter.pm b/Master/xemtex/perl/lib/Exporter.pm new file mode 100644 index 00000000000..8b8d4c49392 --- /dev/null +++ b/Master/xemtex/perl/lib/Exporter.pm @@ -0,0 +1,416 @@ +package Exporter; + +require 5.006; + +# Be lean. +#use strict; +#no strict 'refs'; + +our $Debug = 0; +our $ExportLevel = 0; +our $Verbose ||= 0; +our $VERSION = '5.566'; +$Carp::Internal{Exporter} = 1; + +sub as_heavy { + require Exporter::Heavy; + # Unfortunately, this does not work if the caller is aliased as *name = \&foo + # Thus the need to create a lot of identical subroutines + my $c = (caller(1))[3]; + $c =~ s/.*:://; + \&{"Exporter::Heavy::heavy_$c"}; +} + +sub export { + goto &{as_heavy()}; +} + +sub import { + my $pkg = shift; + my $callpkg = caller($ExportLevel); + + # We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-( + my($exports, $export_cache, $fail) + = (\@{"$pkg\::EXPORT"}, \%{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"}); + return export $pkg, $callpkg, @_ + if $Verbose or $Debug or @$fail > 1; + my $args = @_ or @_ = @$exports; + + local $_; + if ($args and not %$export_cache) { + s/^&//, $export_cache->{$_} = 1 + foreach (@$exports, @{"$pkg\::EXPORT_OK"}); + } + my $heavy; + # Try very hard not to use {} and hence have to enter scope on the foreach + # We bomb out of the loop with last as soon as heavy is set. + if ($args or $fail) { + ($heavy = (/\W/ or $args and not exists $export_cache->{$_} + or @$fail and $_ eq $fail->[0])) and last + foreach (@_); + } else { + ($heavy = /\W/) and last + foreach (@_); + } + return export $pkg, $callpkg, ($args ? @_ : ()) if $heavy; + local $SIG{__WARN__} = + sub {require Carp; &Carp::carp}; + # shortcut for the common case of no type character + *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_; +} + +# Default methods + +sub export_fail { + my $self = shift; + @_; +} + +# Unfortunately, caller(1)[3] "does not work" if the caller is aliased as +# *name = \&foo. Thus the need to create a lot of identical subroutines +# Otherwise we could have aliased them to export(). + +sub export_to_level { + goto &{as_heavy()}; +} + +sub export_tags { + goto &{as_heavy()}; +} + +sub export_ok_tags { + goto &{as_heavy()}; +} + +sub require_version { + goto &{as_heavy()}; +} + +1; +__END__ + +=head1 NAME + +Exporter - Implements default import method for modules + +=head1 SYNOPSIS + +In module YourModule.pm: + + package YourModule; + require Exporter; + @ISA = qw(Exporter); + @EXPORT_OK = qw(munge frobnicate); # symbols to export on request + +In other files which wish to use YourModule: + + use ModuleName qw(frobnicate); # import listed symbols + frobnicate ($left, $right) # calls YourModule::frobnicate + +=head1 DESCRIPTION + +The Exporter module implements an C<import> method which allows a module +to export functions and variables to its users' namespaces. Many modules +use Exporter rather than implementing their own C<import> method because +Exporter provides a highly flexible interface, with an implementation optimised +for the common case. + +Perl automatically calls the C<import> method when processing a +C<use> statement for a module. Modules and C<use> are documented +in L<perlfunc> and L<perlmod>. Understanding the concept of +modules and how the C<use> statement operates is important to +understanding the Exporter. + +=head2 How to Export + +The arrays C<@EXPORT> and C<@EXPORT_OK> in a module hold lists of +symbols that are going to be exported into the users name space by +default, or which they can request to be exported, respectively. The +symbols can represent functions, scalars, arrays, hashes, or typeglobs. +The symbols must be given by full name with the exception that the +ampersand in front of a function is optional, e.g. + + @EXPORT = qw(afunc $scalar @array); # afunc is a function + @EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc + +If you are only exporting function names it is recommended to omit the +ampersand, as the implementation is faster this way. + +=head2 Selecting What To Export + +Do B<not> export method names! + +Do B<not> export anything else by default without a good reason! + +Exports pollute the namespace of the module user. If you must export +try to use @EXPORT_OK in preference to @EXPORT and avoid short or +common symbol names to reduce the risk of name clashes. + +Generally anything not exported is still accessible from outside the +module using the ModuleName::item_name (or $blessed_ref-E<gt>method) +syntax. By convention you can use a leading underscore on names to +informally indicate that they are 'internal' and not for public use. + +(It is actually possible to get private functions by saying: + + my $subref = sub { ... }; + $subref->(@args); # Call it as a function + $obj->$subref(@args); # Use it as a method + +However if you use them for methods it is up to you to figure out +how to make inheritance work.) + +As a general rule, if the module is trying to be object oriented +then export nothing. If it's just a collection of functions then +@EXPORT_OK anything but use @EXPORT with caution. For function and +method names use barewords in preference to names prefixed with +ampersands for the export lists. + +Other module design guidelines can be found in L<perlmod>. + +=head2 How to Import + +In other files which wish to use your module there are three basic ways for +them to load your module and import its symbols: + +=over 4 + +=item C<use ModuleName;> + +This imports all the symbols from ModuleName's @EXPORT into the namespace +of the C<use> statement. + +=item C<use ModuleName ();> + +This causes perl to load your module but does not import any symbols. + +=item C<use ModuleName qw(...);> + +This imports only the symbols listed by the caller into their namespace. +All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error +occurs. The advanced export features of Exporter are accessed like this, +but with list entries that are syntactically distinct from symbol names. + +=back + +Unless you want to use its advanced features, this is probably all you +need to know to use Exporter. + +=head1 Advanced features + +=head2 Specialised Import Lists + +If the first entry in an import list begins with !, : or / then the +list is treated as a series of specifications which either add to or +delete from the list of names to import. They are processed left to +right. Specifications are in the form: + + [!]name This name only + [!]:DEFAULT All names in @EXPORT + [!]:tag All names in $EXPORT_TAGS{tag} anonymous list + [!]/pattern/ All names in @EXPORT and @EXPORT_OK which match + +A leading ! indicates that matching names should be deleted from the +list of names to import. If the first specification is a deletion it +is treated as though preceded by :DEFAULT. If you just want to import +extra names in addition to the default set you will still need to +include :DEFAULT explicitly. + +e.g., Module.pm defines: + + @EXPORT = qw(A1 A2 A3 A4 A5); + @EXPORT_OK = qw(B1 B2 B3 B4 B5); + %EXPORT_TAGS = (T1 => [qw(A1 A2 B1 B2)], T2 => [qw(A1 A2 B3 B4)]); + + Note that you cannot use tags in @EXPORT or @EXPORT_OK. + Names in EXPORT_TAGS must also appear in @EXPORT or @EXPORT_OK. + +An application using Module can say something like: + + use Module qw(:DEFAULT :T2 !B3 A3); + +Other examples include: + + use Socket qw(!/^[AP]F_/ !SOMAXCONN !SOL_SOCKET); + use POSIX qw(:errno_h :termios_h !TCSADRAIN !/^EXIT/); + +Remember that most patterns (using //) will need to be anchored +with a leading ^, e.g., C</^EXIT/> rather than C</EXIT/>. + +You can say C<BEGIN { $Exporter::Verbose=1 }> to see how the +specifications are being processed and what is actually being imported +into modules. + +=head2 Exporting without using Exporter's import method + +Exporter has a special method, 'export_to_level' which is used in situations +where you can't directly call Exporter's import method. The export_to_level +method looks like: + + MyPackage->export_to_level($where_to_export, $package, @what_to_export); + +where $where_to_export is an integer telling how far up the calling stack +to export your symbols, and @what_to_export is an array telling what +symbols *to* export (usually this is @_). The $package argument is +currently unused. + +For example, suppose that you have a module, A, which already has an +import function: + + package A; + + @ISA = qw(Exporter); + @EXPORT_OK = qw ($b); + + sub import + { + $A::b = 1; # not a very useful import method + } + +and you want to Export symbol $A::b back to the module that called +package A. Since Exporter relies on the import method to work, via +inheritance, as it stands Exporter::import() will never get called. +Instead, say the following: + + package A; + @ISA = qw(Exporter); + @EXPORT_OK = qw ($b); + + sub import + { + $A::b = 1; + A->export_to_level(1, @_); + } + +This will export the symbols one level 'above' the current package - ie: to +the program or module that used package A. + +Note: Be careful not to modify '@_' at all before you call export_to_level +- or people using your package will get very unexplained results! + + +=head2 Module Version Checking + +The Exporter module will convert an attempt to import a number from a +module into a call to $module_name-E<gt>require_version($value). This can +be used to validate that the version of the module being used is +greater than or equal to the required version. + +The Exporter module supplies a default require_version method which +checks the value of $VERSION in the exporting module. + +Since the default require_version method treats the $VERSION number as +a simple numeric value it will regard version 1.10 as lower than +1.9. For this reason it is strongly recommended that you use numbers +with at least two decimal places, e.g., 1.09. + +=head2 Managing Unknown Symbols + +In some situations you may want to prevent certain symbols from being +exported. Typically this applies to extensions which have functions +or constants that may not exist on some systems. + +The names of any symbols that cannot be exported should be listed +in the C<@EXPORT_FAIL> array. + +If a module attempts to import any of these symbols the Exporter +will give the module an opportunity to handle the situation before +generating an error. The Exporter will call an export_fail method +with a list of the failed symbols: + + @failed_symbols = $module_name->export_fail(@failed_symbols); + +If the export_fail method returns an empty list then no error is +recorded and all the requested symbols are exported. If the returned +list is not empty then an error is generated for each symbol and the +export fails. The Exporter provides a default export_fail method which +simply returns the list unchanged. + +Uses for the export_fail method include giving better error messages +for some symbols and performing lazy architectural checks (put more +symbols into @EXPORT_FAIL by default and then take them out if someone +actually tries to use them and an expensive check shows that they are +usable on that platform). + +=head2 Tag Handling Utility Functions + +Since the symbols listed within %EXPORT_TAGS must also appear in either +@EXPORT or @EXPORT_OK, two utility functions are provided which allow +you to easily add tagged sets of symbols to @EXPORT or @EXPORT_OK: + + %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]); + + Exporter::export_tags('foo'); # add aa, bb and cc to @EXPORT + Exporter::export_ok_tags('bar'); # add aa, cc and dd to @EXPORT_OK + +Any names which are not tags are added to @EXPORT or @EXPORT_OK +unchanged but will trigger a warning (with C<-w>) to avoid misspelt tags +names being silently added to @EXPORT or @EXPORT_OK. Future versions +may make this a fatal error. + +=head2 Generating combined tags + +If several symbol categories exist in %EXPORT_TAGS, it's usually +useful to create the utility ":all" to simplify "use" statements. + +The simplest way to do this is: + + %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]); + + # add all the other ":class" tags to the ":all" class, + # deleting duplicates + { + my %seen; + + push @{$EXPORT_TAGS{all}}, + grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS; + } + +CGI.pm creates an ":all" tag which contains some (but not really +all) of its categories. That could be done with one small +change: + + # add some of the other ":class" tags to the ":all" class, + # deleting duplicates + { + my %seen; + + push @{$EXPORT_TAGS{all}}, + grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} + foreach qw/html2 html3 netscape form cgi internal/; + } + +Note that the tag names in %EXPORT_TAGS don't have the leading ':'. + +=head2 C<AUTOLOAD>ed Constants + +Many modules make use of C<AUTOLOAD>ing for constant subroutines to +avoid having to compile and waste memory on rarely used values (see +L<perlsub> for details on constant subroutines). Calls to such +constant subroutines are not optimized away at compile time because +they can't be checked at compile time for constancy. + +Even if a prototype is available at compile time, the body of the +subroutine is not (it hasn't been C<AUTOLOAD>ed yet). perl needs to +examine both the C<()> prototype and the body of a subroutine at +compile time to detect that it can safely replace calls to that +subroutine with the constant value. + +A workaround for this is to call the constants once in a C<BEGIN> block: + + package My ; + + use Socket ; + + foo( SO_LINGER ); ## SO_LINGER NOT optimized away; called at runtime + BEGIN { SO_LINGER } + foo( SO_LINGER ); ## SO_LINGER optimized away at compile time. + +This forces the C<AUTOLOAD> for C<SO_LINGER> to take place before +SO_LINGER is encountered later in C<My> package. + +If you are writing a package that C<AUTOLOAD>s, consider forcing +an C<AUTOLOAD> for any constants explicitly imported by other packages +or which are usually used when your package is C<use>d. + +=cut diff --git a/Master/xemtex/perl/lib/Exporter/Heavy.pm b/Master/xemtex/perl/lib/Exporter/Heavy.pm new file mode 100644 index 00000000000..3bdc4b4f204 --- /dev/null +++ b/Master/xemtex/perl/lib/Exporter/Heavy.pm @@ -0,0 +1,232 @@ +package Exporter::Heavy; + +use strict; +no strict 'refs'; + +# On one line so MakeMaker will see it. +require Exporter; our $VERSION = $Exporter::VERSION; +$Carp::Internal{"Exporter::Heavy"} = 1; +our $Verbose; + +=head1 NAME + +Exporter::Heavy - Exporter guts + +=head1 SYNOPSIS + +(internal use only) + +=head1 DESCRIPTION + +No user-serviceable parts inside. + +=cut + +# +# We go to a lot of trouble not to 'require Carp' at file scope, +# because Carp requires Exporter, and something has to give. +# + +sub heavy_export { + + # First make import warnings look like they're coming from the "use". + local $SIG{__WARN__} = sub { + my $text = shift; + if ($text =~ s/ at \S*Exporter\S*.pm line \d+.*\n//) { + require Carp; + local $Carp::CarpLevel = 1; # ignore package calling us too. + Carp::carp($text); + } + else { + warn $text; + } + }; + local $SIG{__DIE__} = sub { + require Carp; + local $Carp::CarpLevel = 1; # ignore package calling us too. + Carp::croak("$_[0]Illegal null symbol in \@${1}::EXPORT") + if $_[0] =~ /^Unable to create sub named "(.*?)::"/; + }; + + my($pkg, $callpkg, @imports) = @_; + my($type, $sym, $oops); + my($exports, $export_cache) = (\@{"${pkg}::EXPORT"}, + \%{"${pkg}::EXPORT"}); + + if (@imports) { + if (!%$export_cache) { + s/^&// foreach @$exports; + @{$export_cache}{@$exports} = (1) x @$exports; + my $ok = \@{"${pkg}::EXPORT_OK"}; + if (@$ok) { + s/^&// foreach @$ok; + @{$export_cache}{@$ok} = (1) x @$ok; + } + } + + if ($imports[0] =~ m#^[/!:]#){ + my $tagsref = \%{"${pkg}::EXPORT_TAGS"}; + my $tagdata; + my %imports; + my($remove, $spec, @names, @allexports); + # negated first item implies starting with default set: + unshift @imports, ':DEFAULT' if $imports[0] =~ m/^!/; + foreach $spec (@imports){ + $remove = $spec =~ s/^!//; + + if ($spec =~ s/^://){ + if ($spec eq 'DEFAULT'){ + @names = @$exports; + } + elsif ($tagdata = $tagsref->{$spec}) { + @names = @$tagdata; + } + else { + warn qq["$spec" is not defined in %${pkg}::EXPORT_TAGS]; + ++$oops; + next; + } + } + elsif ($spec =~ m:^/(.*)/$:){ + my $patn = $1; + @allexports = keys %$export_cache unless @allexports; # only do keys once + @names = grep(/$patn/, @allexports); # not anchored by default + } + else { + @names = ($spec); # is a normal symbol name + } + + warn "Import ".($remove ? "del":"add").": @names " + if $Verbose; + + if ($remove) { + foreach $sym (@names) { delete $imports{$sym} } + } + else { + @imports{@names} = (1) x @names; + } + } + @imports = keys %imports; + } + + my @carp; + foreach $sym (@imports) { + if (!$export_cache->{$sym}) { + if ($sym =~ m/^\d/) { + $pkg->VERSION($sym); # inherit from UNIVERSAL + # If the version number was the only thing specified + # then we should act as if nothing was specified: + if (@imports == 1) { + @imports = @$exports; + last; + } + # We need a way to emulate 'use Foo ()' but still + # allow an easy version check: "use Foo 1.23, ''"; + if (@imports == 2 and !$imports[1]) { + @imports = (); + last; + } + } elsif ($sym !~ s/^&// || !$export_cache->{$sym}) { + # accumulate the non-exports + push @carp, + qq["$sym" is not exported by the $pkg module\n]; + $oops++; + } + } + } + if ($oops) { + require Carp; + Carp::croak("@{carp}Can't continue after import errors"); + } + } + else { + @imports = @$exports; + } + + my($fail, $fail_cache) = (\@{"${pkg}::EXPORT_FAIL"}, + \%{"${pkg}::EXPORT_FAIL"}); + + if (@$fail) { + if (!%$fail_cache) { + # Build cache of symbols. Optimise the lookup by adding + # barewords twice... both with and without a leading &. + # (Technique could be applied to $export_cache at cost of memory) + my @expanded = map { /^\w/ ? ($_, '&'.$_) : $_ } @$fail; + warn "${pkg}::EXPORT_FAIL cached: @expanded" if $Verbose; + @{$fail_cache}{@expanded} = (1) x @expanded; + } + my @failed; + foreach $sym (@imports) { push(@failed, $sym) if $fail_cache->{$sym} } + if (@failed) { + @failed = $pkg->export_fail(@failed); + foreach $sym (@failed) { + require Carp; + Carp::carp(qq["$sym" is not implemented by the $pkg module ], + "on this architecture"); + } + if (@failed) { + require Carp; + Carp::croak("Can't continue after import errors"); + } + } + } + + warn "Importing into $callpkg from $pkg: ", + join(", ",sort @imports) if $Verbose; + + foreach $sym (@imports) { + # shortcut for the common case of no type character + (*{"${callpkg}::$sym"} = \&{"${pkg}::$sym"}, next) + unless $sym =~ s/^(\W)//; + $type = $1; + *{"${callpkg}::$sym"} = + $type eq '&' ? \&{"${pkg}::$sym"} : + $type eq '$' ? \${"${pkg}::$sym"} : + $type eq '@' ? \@{"${pkg}::$sym"} : + $type eq '%' ? \%{"${pkg}::$sym"} : + $type eq '*' ? *{"${pkg}::$sym"} : + do { require Carp; Carp::croak("Can't export symbol: $type$sym") }; + } +} + +sub heavy_export_to_level +{ + my $pkg = shift; + my $level = shift; + (undef) = shift; # XXX redundant arg + my $callpkg = caller($level); + $pkg->export($callpkg, @_); +} + +# Utility functions + +sub _push_tags { + my($pkg, $var, $syms) = @_; + my @nontag = (); + my $export_tags = \%{"${pkg}::EXPORT_TAGS"}; + push(@{"${pkg}::$var"}, + map { $export_tags->{$_} ? @{$export_tags->{$_}} + : scalar(push(@nontag,$_),$_) } + (@$syms) ? @$syms : keys %$export_tags); + if (@nontag and $^W) { + # This may change to a die one day + require Carp; + Carp::carp(join(", ", @nontag)." are not tags of $pkg"); + } +} + +sub heavy_require_version { + my($self, $wanted) = @_; + my $pkg = ref $self || $self; + return ${pkg}->VERSION($wanted); +} + +sub heavy_export_tags { + _push_tags((caller)[0], "EXPORT", \@_); +} + +sub heavy_export_ok_tags { + _push_tags((caller)[0], "EXPORT_OK", \@_); +} + +1; diff --git a/Master/xemtex/perl/lib/Fcntl.pm b/Master/xemtex/perl/lib/Fcntl.pm new file mode 100644 index 00000000000..6e4236713de --- /dev/null +++ b/Master/xemtex/perl/lib/Fcntl.pm @@ -0,0 +1,216 @@ +package Fcntl; + +=head1 NAME + +Fcntl - load the C Fcntl.h defines + +=head1 SYNOPSIS + + use Fcntl; + use Fcntl qw(:DEFAULT :flock); + +=head1 DESCRIPTION + +This module is just a translation of the C F<fnctl.h> file. +Unlike the old mechanism of requiring a translated F<fnctl.ph> +file, this uses the B<h2xs> program (see the Perl source distribution) +and your native C compiler. This means that it has a +far more likely chance of getting the numbers right. + +=head1 NOTE + +Only C<#define> symbols get translated; you must still correctly +pack up your own arguments to pass as args for locking functions, etc. + +=head1 EXPORTED SYMBOLS + +By default your system's F_* and O_* constants (eg, F_DUPFD and +O_CREAT) and the FD_CLOEXEC constant are exported into your namespace. + +You can request that the flock() constants (LOCK_SH, LOCK_EX, LOCK_NB +and LOCK_UN) be provided by using the tag C<:flock>. See L<Exporter>. + +You can request that the old constants (FAPPEND, FASYNC, FCREAT, +FDEFER, FEXCL, FNDELAY, FNONBLOCK, FSYNC, FTRUNC) be provided for +compatibility reasons by using the tag C<:Fcompat>. For new +applications the newer versions of these constants are suggested +(O_APPEND, O_ASYNC, O_CREAT, O_DEFER, O_EXCL, O_NDELAY, O_NONBLOCK, +O_SYNC, O_TRUNC). + +For ease of use also the SEEK_* constants (for seek() and sysseek(), +e.g. SEEK_END) and the S_I* constants (for chmod() and stat()) are +available for import. They can be imported either separately or using +the tags C<:seek> and C<:mode>. + +Please refer to your native fcntl(2), open(2), fseek(3), lseek(2) +(equal to Perl's seek() and sysseek(), respectively), and chmod(2) +documentation to see what constants are implemented in your system. + +See L<perlopentut> to learn about the uses of the O_* constants +with sysopen(). + +See L<perlfunc/seek> and L<perlfunc/sysseek> about the SEEK_* constants. + +See L<perlfunc/stat> about the S_I* constants. + +=cut + +our($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS, $AUTOLOAD); + +require Exporter; +use XSLoader (); +@ISA = qw(Exporter); +$VERSION = "1.04"; +# Items to export into callers namespace by default +# (move infrequently used names to @EXPORT_OK below) +@EXPORT = + qw( + FD_CLOEXEC + F_ALLOCSP + F_ALLOCSP64 + F_COMPAT + F_DUP2FD + F_DUPFD + F_EXLCK + F_FREESP + F_FREESP64 + F_FSYNC + F_FSYNC64 + F_GETFD + F_GETFL + F_GETLK + F_GETLK64 + F_GETOWN + F_NODNY + F_POSIX + F_RDACC + F_RDDNY + F_RDLCK + F_RWACC + F_RWDNY + F_SETFD + F_SETFL + F_SETLK + F_SETLK64 + F_SETLKW + F_SETLKW64 + F_SETOWN + F_SHARE + F_SHLCK + F_UNLCK + F_UNSHARE + F_WRACC + F_WRDNY + F_WRLCK + O_ACCMODE + O_ALIAS + O_APPEND + O_ASYNC + O_BINARY + O_CREAT + O_DEFER + O_DIRECT + O_DIRECTORY + O_DSYNC + O_EXCL + O_EXLOCK + O_LARGEFILE + O_NDELAY + O_NOCTTY + O_NOFOLLOW + O_NOINHERIT + O_NONBLOCK + O_RANDOM + O_RAW + O_RDONLY + O_RDWR + O_RSRC + O_RSYNC + O_SEQUENTIAL + O_SHLOCK + O_SYNC + O_TEMPORARY + O_TEXT + O_TRUNC + O_WRONLY + ); + +# Other items we are prepared to export if requested +@EXPORT_OK = qw( + FAPPEND + FASYNC + FCREAT + FDEFER + FDSYNC + FEXCL + FLARGEFILE + FNDELAY + FNONBLOCK + FRSYNC + FSYNC + FTRUNC + LOCK_EX + LOCK_NB + LOCK_SH + LOCK_UN + S_ISUID S_ISGID S_ISVTX S_ISTXT + _S_IFMT S_IFREG S_IFDIR S_IFLNK + S_IFSOCK S_IFBLK S_IFCHR S_IFIFO S_IFWHT S_ENFMT + S_IRUSR S_IWUSR S_IXUSR S_IRWXU + S_IRGRP S_IWGRP S_IXGRP S_IRWXG + S_IROTH S_IWOTH S_IXOTH S_IRWXO + S_IREAD S_IWRITE S_IEXEC + &S_ISREG &S_ISDIR &S_ISLNK &S_ISSOCK &S_ISBLK &S_ISCHR &S_ISFIFO + &S_ISWHT &S_ISENFMT &S_IFMT &S_IMODE + SEEK_SET + SEEK_CUR + SEEK_END +); +# Named groups of exports +%EXPORT_TAGS = ( + 'flock' => [qw(LOCK_SH LOCK_EX LOCK_NB LOCK_UN)], + 'Fcompat' => [qw(FAPPEND FASYNC FCREAT FDEFER FDSYNC FEXCL FLARGEFILE + FNDELAY FNONBLOCK FRSYNC FSYNC FTRUNC)], + 'seek' => [qw(SEEK_SET SEEK_CUR SEEK_END)], + 'mode' => [qw(S_ISUID S_ISGID S_ISVTX S_ISTXT + _S_IFMT S_IFREG S_IFDIR S_IFLNK + S_IFSOCK S_IFBLK S_IFCHR S_IFIFO S_IFWHT S_ENFMT + S_IRUSR S_IWUSR S_IXUSR S_IRWXU + S_IRGRP S_IWGRP S_IXGRP S_IRWXG + S_IROTH S_IWOTH S_IXOTH S_IRWXO + S_IREAD S_IWRITE S_IEXEC + S_ISREG S_ISDIR S_ISLNK S_ISSOCK + S_ISBLK S_ISCHR S_ISFIFO + S_ISWHT S_ISENFMT + S_IFMT S_IMODE + )], +); + +sub S_IFMT { @_ ? ( $_[0] & _S_IFMT() ) : _S_IFMT() } +sub S_IMODE { $_[0] & 07777 } + +sub S_ISREG { ( $_[0] & _S_IFMT() ) == S_IFREG() } +sub S_ISDIR { ( $_[0] & _S_IFMT() ) == S_IFDIR() } +sub S_ISLNK { ( $_[0] & _S_IFMT() ) == S_IFLNK() } +sub S_ISSOCK { ( $_[0] & _S_IFMT() ) == S_IFSOCK() } +sub S_ISBLK { ( $_[0] & _S_IFMT() ) == S_IFBLK() } +sub S_ISCHR { ( $_[0] & _S_IFMT() ) == S_IFCHR() } +sub S_ISFIFO { ( $_[0] & _S_IFMT() ) == S_IFIFO() } +sub S_ISWHT { ( $_[0] & _S_IFMT() ) == S_IFWHT() } +sub S_ISENFMT { ( $_[0] & _S_IFMT() ) == S_IFENFMT() } + +sub AUTOLOAD { + (my $constname = $AUTOLOAD) =~ s/.*:://; + die "&Fcntl::constant not defined" if $constname eq 'constant'; + my ($error, $val) = constant($constname); + if ($error) { + my (undef,$file,$line) = caller; + die "$error at $file line $line.\n"; + } + *$AUTOLOAD = sub { $val }; + goto &$AUTOLOAD; +} + +XSLoader::load 'Fcntl', $VERSION; + +1; diff --git a/Master/xemtex/perl/lib/File/Basename.pm b/Master/xemtex/perl/lib/File/Basename.pm new file mode 100644 index 00000000000..f2ef495cddf --- /dev/null +++ b/Master/xemtex/perl/lib/File/Basename.pm @@ -0,0 +1,289 @@ +package File::Basename; + +=head1 NAME + +fileparse - split a pathname into pieces + +basename - extract just the filename from a path + +dirname - extract just the directory from a path + +=head1 SYNOPSIS + + use File::Basename; + + ($name,$path,$suffix) = fileparse($fullname,@suffixlist) + fileparse_set_fstype($os_string); + $basename = basename($fullname,@suffixlist); + $dirname = dirname($fullname); + + ($name,$path,$suffix) = fileparse("lib/File/Basename.pm",qr{\.pm}); + fileparse_set_fstype("VMS"); + $basename = basename("lib/File/Basename.pm",qr{\.pm}); + $dirname = dirname("lib/File/Basename.pm"); + +=head1 DESCRIPTION + +These routines allow you to parse file specifications into useful +pieces using the syntax of different operating systems. + +=over 4 + +=item fileparse_set_fstype + +You select the syntax via the routine fileparse_set_fstype(). + +If the argument passed to it contains one of the substrings +"VMS", "MSDOS", "MacOS", "AmigaOS" or "MSWin32", the file specification +syntax of that operating system is used in future calls to +fileparse(), basename(), and dirname(). If it contains none of +these substrings, Unix syntax is used. This pattern matching is +case-insensitive. If you've selected VMS syntax, and the file +specification you pass to one of these routines contains a "/", +they assume you are using Unix emulation and apply the Unix syntax +rules instead, for that function call only. + +If the argument passed to it contains one of the substrings "VMS", +"MSDOS", "MacOS", "AmigaOS", "os2", "MSWin32" or "RISCOS", then the pattern +matching for suffix removal is performed without regard for case, +since those systems are not case-sensitive when opening existing files +(though some of them preserve case on file creation). + +If you haven't called fileparse_set_fstype(), the syntax is chosen +by examining the builtin variable C<$^O> according to these rules. + +=item fileparse + +The fileparse() routine divides a file specification into three +parts: a leading B<path>, a file B<name>, and a B<suffix>. The +B<path> contains everything up to and including the last directory +separator in the input file specification. The remainder of the input +file specification is then divided into B<name> and B<suffix> based on +the optional patterns you specify in C<@suffixlist>. Each element of +this list can be a qr-quoted pattern (or a string which is interpreted +as a regular expression), and is matched +against the end of B<name>. If this succeeds, the matching portion of +B<name> is removed and prepended to B<suffix>. By proper use of +C<@suffixlist>, you can remove file types or versions for examination. + +You are guaranteed that if you concatenate B<path>, B<name>, and +B<suffix> together in that order, the result will denote the same +file as the input file specification. + +=back + +=head1 EXAMPLES + +Using Unix file syntax: + + ($base,$path,$type) = fileparse('/virgil/aeneid/draft.book7', + qr{\.book\d+}); + +would yield + + $base eq 'draft' + $path eq '/virgil/aeneid/', + $type eq '.book7' + +Similarly, using VMS syntax: + + ($name,$dir,$type) = fileparse('Doc_Root:[Help]Rhetoric.Rnh', + qr{\..*}); + +would yield + + $name eq 'Rhetoric' + $dir eq 'Doc_Root:[Help]' + $type eq '.Rnh' + +=over + +=item C<basename> + +The basename() routine returns the first element of the list produced +by calling fileparse() with the same arguments, except that it always +quotes metacharacters in the given suffixes. It is provided for +programmer compatibility with the Unix shell command basename(1). + +=item C<dirname> + +The dirname() routine returns the directory portion of the input file +specification. When using VMS or MacOS syntax, this is identical to the +second element of the list produced by calling fileparse() with the same +input file specification. (Under VMS, if there is no directory information +in the input file specification, then the current default device and +directory are returned.) When using Unix or MSDOS syntax, the return +value conforms to the behavior of the Unix shell command dirname(1). This +is usually the same as the behavior of fileparse(), but differs in some +cases. For example, for the input file specification F<lib/>, fileparse() +considers the directory name to be F<lib/>, while dirname() considers the +directory name to be F<.>). + +=back + +=cut + + +## use strict; +# A bit of juggling to insure that C<use re 'taint';> always works, since +# File::Basename is used during the Perl build, when the re extension may +# not be available. +BEGIN { + unless (eval { require re; }) + { eval ' sub re::import { $^H |= 0x00100000; } ' } + import re 'taint'; +} + + + +use 5.006; +use warnings; +our(@ISA, @EXPORT, $VERSION, $Fileparse_fstype, $Fileparse_igncase); +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(fileparse fileparse_set_fstype basename dirname); +$VERSION = "2.71"; + + +# fileparse_set_fstype() - specify OS-based rules used in future +# calls to routines in this package +# +# Currently recognized values: VMS, MSDOS, MacOS, AmigaOS, os2, RISCOS +# Any other name uses Unix-style rules and is case-sensitive + +sub fileparse_set_fstype { + my @old = ($Fileparse_fstype, $Fileparse_igncase); + if (@_) { + $Fileparse_fstype = $_[0]; + $Fileparse_igncase = ($_[0] =~ /^(?:MacOS|VMS|AmigaOS|os2|RISCOS|MSWin32|MSDOS)/i); + } + wantarray ? @old : $old[0]; +} + +# fileparse() - parse file specification +# +# Version 2.4 27-Sep-1996 Charles Bailey bailey@genetics.upenn.edu + + +sub fileparse { + my($fullname,@suffices) = @_; + unless (defined $fullname) { + require Carp; + Carp::croak "fileparse(): need a valid pathname"; + } + my($fstype,$igncase) = ($Fileparse_fstype, $Fileparse_igncase); + my($dirpath,$tail,$suffix,$basename); + my($taint) = substr($fullname,0,0); # Is $fullname tainted? + + if ($fstype =~ /^VMS/i) { + if ($fullname =~ m#/#) { $fstype = '' } # We're doing Unix emulation + else { + ($dirpath,$basename) = ($fullname =~ /^(.*[:>\]])?(.*)/s); + $dirpath ||= ''; # should always be defined + } + } + if ($fstype =~ /^MS(DOS|Win32)|epoc/i) { + ($dirpath,$basename) = ($fullname =~ /^((?:.*[:\\\/])?)(.*)/s); + $dirpath .= '.\\' unless $dirpath =~ /[\\\/]\z/; + } + elsif ($fstype =~ /^os2/i) { + ($dirpath,$basename) = ($fullname =~ m#^((?:.*[:\\/])?)(.*)#s); + $dirpath = './' unless $dirpath; # Can't be 0 + $dirpath .= '/' unless $dirpath =~ m#[\\/]\z#; + } + elsif ($fstype =~ /^MacOS/si) { + ($dirpath,$basename) = ($fullname =~ /^(.*:)?(.*)/s); + $dirpath = ':' unless $dirpath; + } + elsif ($fstype =~ /^AmigaOS/i) { + ($dirpath,$basename) = ($fullname =~ /(.*[:\/])?(.*)/s); + $dirpath = './' unless $dirpath; + } + elsif ($fstype !~ /^VMS/i) { # default to Unix + ($dirpath,$basename) = ($fullname =~ m#^(.*/)?(.*)#s); + if ($^O eq 'VMS' and $fullname =~ m:^(/[^/]+/000000(/|$))(.*):) { + # dev:[000000] is top of VMS tree, similar to Unix '/' + # so strip it off and treat the rest as "normal" + my $devspec = $1; + my $remainder = $3; + ($dirpath,$basename) = ($remainder =~ m#^(.*/)?(.*)#s); + $dirpath ||= ''; # should always be defined + $dirpath = $devspec.$dirpath; + } + $dirpath = './' unless $dirpath; + } + + if (@suffices) { + $tail = ''; + foreach $suffix (@suffices) { + my $pat = ($igncase ? '(?i)' : '') . "($suffix)\$"; + if ($basename =~ s/$pat//s) { + $taint .= substr($suffix,0,0); + $tail = $1 . $tail; + } + } + } + + $tail .= $taint if defined $tail; # avoid warning if $tail == undef + wantarray ? ($basename .= $taint, $dirpath .= $taint, $tail) + : ($basename .= $taint); +} + + +# basename() - returns first element of list returned by fileparse() + +sub basename { + my($name) = shift; + (fileparse($name, map("\Q$_\E",@_)))[0]; +} + + +# dirname() - returns device and directory portion of file specification +# Behavior matches that of Unix dirname(1) exactly for Unix and MSDOS +# filespecs except for names ending with a separator, e.g., "/xx/yy/". +# This differs from the second element of the list returned +# by fileparse() in that the trailing '/' (Unix) or '\' (MSDOS) (and +# the last directory name if the filespec ends in a '/' or '\'), is lost. + +sub dirname { + my($basename,$dirname) = fileparse($_[0]); + my($fstype) = $Fileparse_fstype; + + if ($fstype =~ /VMS/i) { + if ($_[0] =~ m#/#) { $fstype = '' } + else { return $dirname || $ENV{DEFAULT} } + } + if ($fstype =~ /MacOS/i) { + if( !length($basename) && $dirname !~ /^[^:]+:\z/) { + $dirname =~ s/([^:]):\z/$1/s; + ($basename,$dirname) = fileparse $dirname; + } + $dirname .= ":" unless $dirname =~ /:\z/; + } + elsif ($fstype =~ /MS(DOS|Win32)|os2/i) { + $dirname =~ s/([^:])[\\\/]*\z/$1/; + unless( length($basename) ) { + ($basename,$dirname) = fileparse $dirname; + $dirname =~ s/([^:])[\\\/]*\z/$1/; + } + } + elsif ($fstype =~ /AmigaOS/i) { + if ( $dirname =~ /:\z/) { return $dirname } + chop $dirname; + $dirname =~ s#[^:/]+\z## unless length($basename); + } + else { + $dirname =~ s:(.)/*\z:$1:s; + unless( length($basename) ) { + local($File::Basename::Fileparse_fstype) = $fstype; + ($basename,$dirname) = fileparse $dirname; + $dirname =~ s:(.)/*\z:$1:s; + } + } + + $dirname; +} + +fileparse_set_fstype $^O; + +1; diff --git a/Master/xemtex/perl/lib/File/Compare.pm b/Master/xemtex/perl/lib/File/Compare.pm new file mode 100644 index 00000000000..0b73d7c7657 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Compare.pm @@ -0,0 +1,178 @@ +package File::Compare; + +use 5.006; +use strict; +use warnings; +our($VERSION, @ISA, @EXPORT, @EXPORT_OK, $Too_Big); + +require Exporter; +use Carp; + +$VERSION = '1.1003'; +@ISA = qw(Exporter); +@EXPORT = qw(compare); +@EXPORT_OK = qw(cmp compare_text); + +$Too_Big = 1024 * 1024 * 2; + +sub compare { + croak("Usage: compare( file1, file2 [, buffersize]) ") + unless(@_ == 2 || @_ == 3); + + my ($from,$to,$size) = @_; + my $text_mode = defined($size) && (ref($size) eq 'CODE' || $size < 0); + + my ($fromsize,$closefrom,$closeto); + local (*FROM, *TO); + + croak("from undefined") unless (defined $from); + croak("to undefined") unless (defined $to); + + if (ref($from) && + (UNIVERSAL::isa($from,'GLOB') || UNIVERSAL::isa($from,'IO::Handle'))) { + *FROM = *$from; + } elsif (ref(\$from) eq 'GLOB') { + *FROM = $from; + } else { + open(FROM,"<$from") or goto fail_open1; + unless ($text_mode) { + binmode FROM; + $fromsize = -s FROM; + } + $closefrom = 1; + } + + if (ref($to) && + (UNIVERSAL::isa($to,'GLOB') || UNIVERSAL::isa($to,'IO::Handle'))) { + *TO = *$to; + } elsif (ref(\$to) eq 'GLOB') { + *TO = $to; + } else { + open(TO,"<$to") or goto fail_open2; + binmode TO unless $text_mode; + $closeto = 1; + } + + if (!$text_mode && $closefrom && $closeto) { + # If both are opened files we know they differ if their size differ + goto fail_inner if $fromsize != -s TO; + } + + if ($text_mode) { + local $/ = "\n"; + my ($fline,$tline); + while (defined($fline = <FROM>)) { + goto fail_inner unless defined($tline = <TO>); + if (ref $size) { + # $size contains ref to comparison function + goto fail_inner if &$size($fline, $tline); + } else { + goto fail_inner if $fline ne $tline; + } + } + goto fail_inner if defined($tline = <TO>); + } + else { + unless (defined($size) && $size > 0) { + $size = $fromsize || -s TO || 0; + $size = 1024 if $size < 512; + $size = $Too_Big if $size > $Too_Big; + } + + my ($fr,$tr,$fbuf,$tbuf); + $fbuf = $tbuf = ''; + while(defined($fr = read(FROM,$fbuf,$size)) && $fr > 0) { + unless (defined($tr = read(TO,$tbuf,$fr)) && $tbuf eq $fbuf) { + goto fail_inner; + } + } + goto fail_inner if defined($tr = read(TO,$tbuf,$size)) && $tr > 0; + } + + close(TO) || goto fail_open2 if $closeto; + close(FROM) || goto fail_open1 if $closefrom; + + return 0; + + # All of these contortions try to preserve error messages... + fail_inner: + close(TO) || goto fail_open2 if $closeto; + close(FROM) || goto fail_open1 if $closefrom; + + return 1; + + fail_open2: + if ($closefrom) { + my $status = $!; + $! = 0; + close FROM; + $! = $status unless $!; + } + fail_open1: + return -1; +} + +sub cmp; +*cmp = \&compare; + +sub compare_text { + my ($from,$to,$cmp) = @_; + croak("Usage: compare_text( file1, file2 [, cmp-function])") + unless @_ == 2 || @_ == 3; + croak("Third arg to compare_text() function must be a code reference") + if @_ == 3 && ref($cmp) ne 'CODE'; + + # Using a negative buffer size puts compare into text_mode too + $cmp = -1 unless defined $cmp; + compare($from, $to, $cmp); +} + +1; + +__END__ + +=head1 NAME + +File::Compare - Compare files or filehandles + +=head1 SYNOPSIS + + use File::Compare; + + if (compare("file1","file2") == 0) { + print "They're equal\n"; + } + +=head1 DESCRIPTION + +The File::Compare::compare function compares the contents of two +sources, each of which can be a file or a file handle. It is exported +from File::Compare by default. + +File::Compare::cmp is a synonym for File::Compare::compare. It is +exported from File::Compare only by request. + +File::Compare::compare_text does a line by line comparison of the two +files. It stops as soon as a difference is detected. compare_text() +accepts an optional third argument: This must be a CODE reference to +a line comparison function, which returns 0 when both lines are considered +equal. For example: + + compare_text($file1, $file2) + +is basically equivalent to + + compare_text($file1, $file2, sub {$_[0] ne $_[1]} ) + +=head1 RETURN + +File::Compare::compare and its sibling functions return 0 if the files +are equal, 1 if the files are unequal, or -1 if an error was encountered. + +=head1 AUTHOR + +File::Compare was written by Nick Ing-Simmons. +Its original documentation was written by Chip Salzenberg. + +=cut + diff --git a/Master/xemtex/perl/lib/File/Copy.pm b/Master/xemtex/perl/lib/File/Copy.pm new file mode 100644 index 00000000000..08da5e5d31e --- /dev/null +++ b/Master/xemtex/perl/lib/File/Copy.pm @@ -0,0 +1,443 @@ +# File/Copy.pm. Written in 1994 by Aaron Sherman <ajs@ajs.com>. This +# source code has been placed in the public domain by the author. +# Please be kind and preserve the documentation. +# +# Additions copyright 1996 by Charles Bailey. Permission is granted +# to distribute the revised code under the same terms as Perl itself. + +package File::Copy; + +use 5.006; +use strict; +use warnings; +use Carp; +use File::Spec; +use Config; +our(@ISA, @EXPORT, @EXPORT_OK, $VERSION, $Too_Big, $Syscopy_is_copy); +sub copy; +sub syscopy; +sub cp; +sub mv; + +# Note that this module implements only *part* of the API defined by +# the File/Copy.pm module of the File-Tools-2.0 package. However, that +# package has not yet been updated to work with Perl 5.004, and so it +# would be a Bad Thing for the CPAN module to grab it and replace this +# module. Therefore, we set this module's version higher than 2.0. +$VERSION = '2.05'; + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(copy move); +@EXPORT_OK = qw(cp mv); + +$Too_Big = 1024 * 1024 * 2; + +my $macfiles; +if ($^O eq 'MacOS') { + $macfiles = eval { require Mac::MoreFiles }; + warn 'Mac::MoreFiles could not be loaded; using non-native syscopy' + if $^W; +} + +sub _catname { + my($from, $to) = @_; + if (not defined &basename) { + require File::Basename; + import File::Basename 'basename'; + } + + if ($^O eq 'MacOS') { + # a partial dir name that's valid only in the cwd (e.g. 'tmp') + $to = ':' . $to if $to !~ /:/; + } + + return File::Spec->catfile($to, basename($from)); +} + +sub copy { + croak("Usage: copy(FROM, TO [, BUFFERSIZE]) ") + unless(@_ == 2 || @_ == 3); + + my $from = shift; + my $to = shift; + + my $from_a_handle = (ref($from) + ? (ref($from) eq 'GLOB' + || UNIVERSAL::isa($from, 'GLOB') + || UNIVERSAL::isa($from, 'IO::Handle')) + : (ref(\$from) eq 'GLOB')); + my $to_a_handle = (ref($to) + ? (ref($to) eq 'GLOB' + || UNIVERSAL::isa($to, 'GLOB') + || UNIVERSAL::isa($to, 'IO::Handle')) + : (ref(\$to) eq 'GLOB')); + + if ($from eq $to) { # works for references, too + croak("'$from' and '$to' are identical (not copied)"); + } + + if ($Config{d_symlink} && $Config{d_readlink} && + !($^O eq 'Win32' || $^O eq 'os2' || $^O eq 'vms')) { + no warnings 'io'; # don't warn if -l on filehandle + if ((-e $from && -l $from) || (-e $to && -l $to)) { + my @fs = stat($from); + my @ts = stat($to); + if (@fs && @ts && $fs[0] == $ts[0] && $fs[1] == $ts[1]) { + croak("'$from' and '$to' are identical (not copied)"); + } + } + } + + if (!$from_a_handle && !$to_a_handle && -d $to && ! -d $from) { + $to = _catname($from, $to); + } + + if (defined &syscopy && !$Syscopy_is_copy + && !$to_a_handle + && !($from_a_handle && $^O eq 'os2' ) # OS/2 cannot handle handles + && !($from_a_handle && $^O eq 'mpeix') # and neither can MPE/iX. + && !($from_a_handle && $^O eq 'MSWin32') + && !($from_a_handle && $^O eq 'MacOS') + && !($from_a_handle && $^O eq 'NetWare') + ) + { + return syscopy($from, $to); + } + + my $closefrom = 0; + my $closeto = 0; + my ($size, $status, $r, $buf); + local($\) = ''; + + my $from_h; + if ($from_a_handle) { + $from_h = $from; + } else { + $from = _protect($from) if $from =~ /^\s/s; + $from_h = \do { local *FH }; + open($from_h, "< $from\0") or goto fail_open1; + binmode $from_h or die "($!,$^E)"; + $closefrom = 1; + } + + my $to_h; + if ($to_a_handle) { + $to_h = $to; + } else { + $to = _protect($to) if $to =~ /^\s/s; + $to_h = \do { local *FH }; + open($to_h,"> $to\0") or goto fail_open2; + binmode $to_h or die "($!,$^E)"; + $closeto = 1; + } + + if (@_) { + $size = shift(@_) + 0; + croak("Bad buffer size for copy: $size\n") unless ($size > 0); + } else { + $size = tied(*$from_h) ? 0 : -s $from_h || 0; + $size = 1024 if ($size < 512); + $size = $Too_Big if ($size > $Too_Big); + } + + $! = 0; + for (;;) { + my ($r, $w, $t); + defined($r = sysread($from_h, $buf, $size)) + or goto fail_inner; + last unless $r; + for ($w = 0; $w < $r; $w += $t) { + $t = syswrite($to_h, $buf, $r - $w, $w) + or goto fail_inner; + } + } + + close($to_h) || goto fail_open2 if $closeto; + close($from_h) || goto fail_open1 if $closefrom; + + # Use this idiom to avoid uninitialized value warning. + return 1; + + # All of these contortions try to preserve error messages... + fail_inner: + if ($closeto) { + $status = $!; + $! = 0; + close $to_h; + $! = $status unless $!; + } + fail_open2: + if ($closefrom) { + $status = $!; + $! = 0; + close $from_h; + $! = $status unless $!; + } + fail_open1: + return 0; +} + +sub move { + my($from,$to) = @_; + my($copied,$fromsz,$tosz1,$tomt1,$tosz2,$tomt2,$sts,$ossts); + + if (-d $to && ! -d $from) { + $to = _catname($from, $to); + } + + ($tosz1,$tomt1) = (stat($to))[7,9]; + $fromsz = -s $from; + if ($^O eq 'os2' and defined $tosz1 and defined $fromsz) { + # will not rename with overwrite + unlink $to; + } + return 1 if rename $from, $to; + + ($sts,$ossts) = ($! + 0, $^E + 0); + # Did rename return an error even though it succeeded, because $to + # is on a remote NFS file system, and NFS lost the server's ack? + return 1 if defined($fromsz) && !-e $from && # $from disappeared + (($tosz2,$tomt2) = (stat($to))[7,9]) && # $to's there + ($tosz1 != $tosz2 or $tomt1 != $tomt2) && # and changed + $tosz2 == $fromsz; # it's all there + + ($tosz1,$tomt1) = (stat($to))[7,9]; # just in case rename did something + return 1 if ($copied = copy($from,$to)) && unlink($from); + + ($tosz2,$tomt2) = ((stat($to))[7,9],0,0) if defined $tomt1; + unlink($to) if !defined($tomt1) or $tomt1 != $tomt2 or $tosz1 != $tosz2; + ($!,$^E) = ($sts,$ossts); + return 0; +} + +*cp = \© +*mv = \&move; + + +if ($^O eq 'MacOS') { + *_protect = sub { MacPerl::MakeFSSpec($_[0]) }; +} else { + *_protect = sub { "./$_[0]" }; +} + +# &syscopy is an XSUB under OS/2 +unless (defined &syscopy) { + if ($^O eq 'VMS') { + *syscopy = \&rmscopy; + } elsif ($^O eq 'mpeix') { + *syscopy = sub { + return 0 unless @_ == 2; + # Use the MPE cp program in order to + # preserve MPE file attributes. + return system('/bin/cp', '-f', $_[0], $_[1]) == 0; + }; + } elsif ($^O eq 'MSWin32') { + *syscopy = sub { + return 0 unless @_ == 2; + return Win32::CopyFile(@_, 1); + }; + } elsif ($macfiles) { + *syscopy = sub { + my($from, $to) = @_; + my($dir, $toname); + + return 0 unless -e $from; + + if ($to =~ /(.*:)([^:]+):?$/) { + ($dir, $toname) = ($1, $2); + } else { + ($dir, $toname) = (":", $to); + } + + unlink($to); + Mac::MoreFiles::FSpFileCopy($from, $dir, $toname, 1); + }; + } else { + $Syscopy_is_copy = 1; + *syscopy = \© + } +} + +1; + +__END__ + +=head1 NAME + +File::Copy - Copy files or filehandles + +=head1 SYNOPSIS + + use File::Copy; + + copy("file1","file2"); + copy("Copy.pm",\*STDOUT);' + move("/dev1/fileA","/dev2/fileB"); + + use POSIX; + use File::Copy cp; + + $n = FileHandle->new("/a/file","r"); + cp($n,"x");' + +=head1 DESCRIPTION + +The File::Copy module provides two basic functions, C<copy> and +C<move>, which are useful for getting the contents of a file from +one place to another. + +=over 4 + +=item * + +The C<copy> function takes two +parameters: a file to copy from and a file to copy to. Either +argument may be a string, a FileHandle reference or a FileHandle +glob. Obviously, if the first argument is a filehandle of some +sort, it will be read from, and if it is a file I<name> it will +be opened for reading. Likewise, the second argument will be +written to (and created if need be). Trying to copy a file on top +of itself is a fatal error. + +B<Note that passing in +files as handles instead of names may lead to loss of information +on some operating systems; it is recommended that you use file +names whenever possible.> Files are opened in binary mode where +applicable. To get a consistent behaviour when copying from a +filehandle to a file, use C<binmode> on the filehandle. + +An optional third parameter can be used to specify the buffer +size used for copying. This is the number of bytes from the +first file, that wil be held in memory at any given time, before +being written to the second file. The default buffer size depends +upon the file, but will generally be the whole file (up to 2Mb), or +1k for filehandles that do not reference files (eg. sockets). + +You may use the syntax C<use File::Copy "cp"> to get at the +"cp" alias for this function. The syntax is I<exactly> the same. + +=item * + +The C<move> function also takes two parameters: the current name +and the intended name of the file to be moved. If the destination +already exists and is a directory, and the source is not a +directory, then the source file will be renamed into the directory +specified by the destination. + +If possible, move() will simply rename the file. Otherwise, it copies +the file to the new location and deletes the original. If an error occurs +during this copy-and-delete process, you may be left with a (possibly partial) +copy of the file under the destination name. + +You may use the "mv" alias for this function in the same way that +you may use the "cp" alias for C<copy>. + +=back + +File::Copy also provides the C<syscopy> routine, which copies the +file specified in the first parameter to the file specified in the +second parameter, preserving OS-specific attributes and file +structure. For Unix systems, this is equivalent to the simple +C<copy> routine, which doesn't preserve OS-specific attributes. For +VMS systems, this calls the C<rmscopy> routine (see below). For OS/2 +systems, this calls the C<syscopy> XSUB directly. For Win32 systems, +this calls C<Win32::CopyFile>. + +On Mac OS (Classic), C<syscopy> calls C<Mac::MoreFiles::FSpFileCopy>, +if available. + +=head2 Special behaviour if C<syscopy> is defined (OS/2, VMS and Win32) + +If both arguments to C<copy> are not file handles, +then C<copy> will perform a "system copy" of +the input file to a new output file, in order to preserve file +attributes, indexed file structure, I<etc.> The buffer size +parameter is ignored. If either argument to C<copy> is a +handle to an opened file, then data is copied using Perl +operators, and no effort is made to preserve file attributes +or record structure. + +The system copy routine may also be called directly under VMS and OS/2 +as C<File::Copy::syscopy> (or under VMS as C<File::Copy::rmscopy>, which +is the routine that does the actual work for syscopy). + +=over 4 + +=item rmscopy($from,$to[,$date_flag]) + +The first and second arguments may be strings, typeglobs, typeglob +references, or objects inheriting from IO::Handle; +they are used in all cases to obtain the +I<filespec> of the input and output files, respectively. The +name and type of the input file are used as defaults for the +output file, if necessary. + +A new version of the output file is always created, which +inherits the structure and RMS attributes of the input file, +except for owner and protections (and possibly timestamps; +see below). All data from the input file is copied to the +output file; if either of the first two parameters to C<rmscopy> +is a file handle, its position is unchanged. (Note that this +means a file handle pointing to the output file will be +associated with an old version of that file after C<rmscopy> +returns, not the newly created version.) + +The third parameter is an integer flag, which tells C<rmscopy> +how to handle timestamps. If it is E<lt> 0, none of the input file's +timestamps are propagated to the output file. If it is E<gt> 0, then +it is interpreted as a bitmask: if bit 0 (the LSB) is set, then +timestamps other than the revision date are propagated; if bit 1 +is set, the revision date is propagated. If the third parameter +to C<rmscopy> is 0, then it behaves much like the DCL COPY command: +if the name or type of the output file was explicitly specified, +then no timestamps are propagated, but if they were taken implicitly +from the input filespec, then all timestamps other than the +revision date are propagated. If this parameter is not supplied, +it defaults to 0. + +Like C<copy>, C<rmscopy> returns 1 on success. If an error occurs, +it sets C<$!>, deletes the output file, and returns 0. + +=back + +=head1 RETURN + +All functions return 1 on success, 0 on failure. +$! will be set if an error was encountered. + +=head1 NOTES + +=over 4 + +=item * + +On Mac OS (Classic), the path separator is ':', not '/', and the +current directory is denoted as ':', not '.'. You should be careful +about specifying relative pathnames. While a full path always begins +with a volume name, a relative pathname should always begin with a +':'. If specifying a volume name only, a trailing ':' is required. + +E.g. + + copy("file1", "tmp"); # creates the file 'tmp' in the current directory + copy("file1", ":tmp:"); # creates :tmp:file1 + copy("file1", ":tmp"); # same as above + copy("file1", "tmp"); # same as above, if 'tmp' is a directory (but don't do + # that, since it may cause confusion, see example #1) + copy("file1", "tmp:file1"); # error, since 'tmp:' is not a volume + copy("file1", ":tmp:file1"); # ok, partial path + copy("file1", "DataHD:"); # creates DataHD:file1 + + move("MacintoshHD:fileA", "DataHD:fileB"); # moves (don't copies) files from one + # volume to another + +=back + +=head1 AUTHOR + +File::Copy was written by Aaron Sherman I<E<lt>ajs@ajs.comE<gt>> in 1995, +and updated by Charles Bailey I<E<lt>bailey@newman.upenn.eduE<gt>> in 1996. + +=cut + diff --git a/Master/xemtex/perl/lib/File/Find.pm b/Master/xemtex/perl/lib/File/Find.pm new file mode 100644 index 00000000000..72fd195c9b0 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Find.pm @@ -0,0 +1,1212 @@ +package File::Find; +use 5.006; +use strict; +use warnings; +use warnings::register; +our $VERSION = '1.04'; +require Exporter; +require Cwd; + +=head1 NAME + +File::Find - Traverse a directory tree. + +=head1 SYNOPSIS + + use File::Find; + find(\&wanted, @directories_to_seach); + sub wanted { ... } + + use File::Find; + finddepth(\&wanted, @directories_to_search); + sub wanted { ... } + + use File::Find; + find({ wanted => \&process, follow => 1 }, '.'); + +=head1 DESCRIPTION + +These are functions for searching through directory trees doing work +on each file found similar to the Unix I<find> command. File::Find +exports two functions, C<find> and C<finddepth>. They work similarly +but have subtle differences. + +=over 4 + +=item B<find> + + find(\&wanted, @directories); + find(\%options, @directories); + +find() does a breadth-first search over the given @directories in the +order they are given. In essense, it works from the top down. + +For each file or directory found the &wanted subroutine is called (see +below for details). Additionally, for each directory found it will go +into that directory and continue the search. + +=item B<finddepth> + + finddepth(\&wanted, @directories); + finddepth(\%options, @directories); + +finddepth() works just like find() except it does a depth-first search. +It works from the bottom of the directory tree up. + +=back + +=head2 %options + +The first argument to find() is either a hash reference describing the +operations to be performed for each file, or a code reference. The +code reference is described in L<The wanted function> below. + +Here are the possible keys for the hash: + +=over 3 + +=item C<wanted> + +The value should be a code reference. This code reference is +described in L<The wanted function> below. + +=item C<bydepth> + +Reports the name of a directory only AFTER all its entries +have been reported. Entry point finddepth() is a shortcut for +specifying C<{ bydepth =E<gt> 1 }> in the first argument of find(). + +=item C<preprocess> + +The value should be a code reference. This code reference is used to +preprocess the current directory. The name of currently processed +directory is in $File::Find::dir. Your preprocessing function is +called after readdir() but before the loop that calls the wanted() +function. It is called with a list of strings (actually file/directory +names) and is expected to return a list of strings. The code can be +used to sort the file/directory names alphabetically, numerically, +or to filter out directory entries based on their name alone. When +I<follow> or I<follow_fast> are in effect, C<preprocess> is a no-op. + +=item C<postprocess> + +The value should be a code reference. It is invoked just before leaving +the currently processed directory. It is called in void context with no +arguments. The name of the current directory is in $File::Find::dir. This +hook is handy for summarizing a directory, such as calculating its disk +usage. When I<follow> or I<follow_fast> are in effect, C<postprocess> is a +no-op. + +=item C<follow> + +Causes symbolic links to be followed. Since directory trees with symbolic +links (followed) may contain files more than once and may even have +cycles, a hash has to be built up with an entry for each file. +This might be expensive both in space and time for a large +directory tree. See I<follow_fast> and I<follow_skip> below. +If either I<follow> or I<follow_fast> is in effect: + +=over 6 + +=item * + +It is guaranteed that an I<lstat> has been called before the user's +I<wanted()> function is called. This enables fast file checks involving S< _>. + +=item * + +There is a variable C<$File::Find::fullname> which holds the absolute +pathname of the file with all symbolic links resolved + +=back + +=item C<follow_fast> + +This is similar to I<follow> except that it may report some files more +than once. It does detect cycles, however. Since only symbolic links +have to be hashed, this is much cheaper both in space and time. If +processing a file more than once (by the user's I<wanted()> function) +is worse than just taking time, the option I<follow> should be used. + +=item C<follow_skip> + +C<follow_skip==1>, which is the default, causes all files which are +neither directories nor symbolic links to be ignored if they are about +to be processed a second time. If a directory or a symbolic link +are about to be processed a second time, File::Find dies. +C<follow_skip==0> causes File::Find to die if any file is about to be +processed a second time. +C<follow_skip==2> causes File::Find to ignore any duplicate files and +directories but to proceed normally otherwise. + +=item C<dangling_symlinks> + +If true and a code reference, will be called with the symbolic link +name and the directory it lives in as arguments. Otherwise, if true +and warnings are on, warning "symbolic_link_name is a dangling +symbolic link\n" will be issued. If false, the dangling symbolic link +will be silently ignored. + +=item C<no_chdir> + +Does not C<chdir()> to each directory as it recurses. The wanted() +function will need to be aware of this, of course. In this case, +C<$_> will be the same as C<$File::Find::name>. + +=item C<untaint> + +If find is used in taint-mode (-T command line switch or if EUID != UID +or if EGID != GID) then internally directory names have to be untainted +before they can be chdir'ed to. Therefore they are checked against a regular +expression I<untaint_pattern>. Note that all names passed to the user's +I<wanted()> function are still tainted. If this option is used while +not in taint-mode, C<untaint> is a no-op. + +=item C<untaint_pattern> + +See above. This should be set using the C<qr> quoting operator. +The default is set to C<qr|^([-+@\w./]+)$|>. +Note that the parentheses are vital. + +=item C<untaint_skip> + +If set, a directory which fails the I<untaint_pattern> is skipped, +including all its sub-directories. The default is to 'die' in such a case. + +=back + +=head2 The wanted function + +The wanted() function does whatever verifications you want on each +file and directory. It takes no arguments but rather does its work +through a collection of variables. + +=over 4 + +=item C<$File::Find::dir> is the current directory name, + +=item C<$_> is the current filename within that directory + +=item C<$File::Find::name> is the complete pathname to the file. + +=back + +Don't modify these variables. + +For example, when examining the file /some/path/foo.ext you will have: + + $File::Find::dir = /some/path/ + $_ = foo.ext + $File::Find::name = /some/path/foo.ext + +You are chdir()'d toC<$File::Find::dir> when the function is called, +unless C<no_chdir> was specified. Note that when changing to +directories is in effect the root directory (F</>) is a somewhat +special case inasmuch as the concatenation of C<$File::Find::dir>, +C<'/'> and C<$_> is not literally equal to C<$File::Find::name>. The +table below summarizes all variants: + + $File::Find::name $File::Find::dir $_ + default / / . + no_chdir=>0 /etc / etc + /etc/x /etc x + + no_chdir=>1 / / / + /etc / /etc + /etc/x /etc /etc/x + + +When <follow> or <follow_fast> are in effect, there is +also a C<$File::Find::fullname>. The function may set +C<$File::Find::prune> to prune the tree unless C<bydepth> was +specified. Unless C<follow> or C<follow_fast> is specified, for +compatibility reasons (find.pl, find2perl) there are in addition the +following globals available: C<$File::Find::topdir>, +C<$File::Find::topdev>, C<$File::Find::topino>, +C<$File::Find::topmode> and C<$File::Find::topnlink>. + +This library is useful for the C<find2perl> tool, which when fed, + + find2perl / -name .nfs\* -mtime +7 \ + -exec rm -f {} \; -o -fstype nfs -prune + +produces something like: + + sub wanted { + /^\.nfs.*\z/s && + (($dev, $ino, $mode, $nlink, $uid, $gid) = lstat($_)) && + int(-M _) > 7 && + unlink($_) + || + ($nlink || (($dev, $ino, $mode, $nlink, $uid, $gid) = lstat($_))) && + $dev < 0 && + ($File::Find::prune = 1); + } + +Notice the C<_> in the above C<int(-M _)>: the C<_> is a magical +filehandle that caches the information from the preceding +stat(), lstat(), or filetest. + +Here's another interesting wanted function. It will find all symbolic +links that don't resolve: + + sub wanted { + -l && !-e && print "bogus link: $File::Find::name\n"; + } + +See also the script C<pfind> on CPAN for a nice application of this +module. + +=head1 WARNINGS + +If you run your program with the C<-w> switch, or if you use the +C<warnings> pragma, File::Find will report warnings for several weird +situations. You can disable these warnings by putting the statement + + no warnings 'File::Find'; + +in the appropriate scope. See L<perllexwarn> for more info about lexical +warnings. + +=head1 CAVEAT + +=over 2 + +=item $dont_use_nlink + +You can set the variable C<$File::Find::dont_use_nlink> to 1, if you want to +force File::Find to always stat directories. This was used for file systems +that do not have an C<nlink> count matching the number of sub-directories. +Examples are ISO-9660 (CD-ROM), AFS, HPFS (OS/2 file system), FAT (DOS file +system) and a couple of others. + +You shouldn't need to set this variable, since File::Find should now detect +such file systems on-the-fly and switch itself to using stat. This works even +for parts of your file system, like a mounted CD-ROM. + +If you do set C<$File::Find::dont_use_nlink> to 1, you will notice slow-downs. + +=item symlinks + +Be aware that the option to follow symbolic links can be dangerous. +Depending on the structure of the directory tree (including symbolic +links to directories) you might traverse a given (physical) directory +more than once (only if C<follow_fast> is in effect). +Furthermore, deleting or changing files in a symbolically linked directory +might cause very unpleasant surprises, since you delete or change files +in an unknown directory. + +=back + +=head1 NOTES + +=over 4 + +=item * + +Mac OS (Classic) users should note a few differences: + +=over 4 + +=item * + +The path separator is ':', not '/', and the current directory is denoted +as ':', not '.'. You should be careful about specifying relative pathnames. +While a full path always begins with a volume name, a relative pathname +should always begin with a ':'. If specifying a volume name only, a +trailing ':' is required. + +=item * + +C<$File::Find::dir> is guaranteed to end with a ':'. If C<$_> +contains the name of a directory, that name may or may not end with a +':'. Likewise, C<$File::Find::name>, which contains the complete +pathname to that directory, and C<$File::Find::fullname>, which holds +the absolute pathname of that directory with all symbolic links resolved, +may or may not end with a ':'. + +=item * + +The default C<untaint_pattern> (see above) on Mac OS is set to +C<qr|^(.+)$|>. Note that the parentheses are vital. + +=item * + +The invisible system file "Icon\015" is ignored. While this file may +appear in every directory, there are some more invisible system files +on every volume, which are all located at the volume root level (i.e. +"MacintoshHD:"). These system files are B<not> excluded automatically. +Your filter may use the following code to recognize invisible files or +directories (requires Mac::Files): + + use Mac::Files; + + # invisible() -- returns 1 if file/directory is invisible, + # 0 if it's visible or undef if an error occurred + + sub invisible($) { + my $file = shift; + my ($fileCat, $fileInfo); + my $invisible_flag = 1 << 14; + + if ( $fileCat = FSpGetCatInfo($file) ) { + if ($fileInfo = $fileCat->ioFlFndrInfo() ) { + return (($fileInfo->fdFlags & $invisible_flag) && 1); + } + } + return undef; + } + +Generally, invisible files are system files, unless an odd application +decides to use invisible files for its own purposes. To distinguish +such files from system files, you have to look at the B<type> and B<creator> +file attributes. The MacPerl built-in functions C<GetFileInfo(FILE)> and +C<SetFileInfo(CREATOR, TYPE, FILES)> offer access to these attributes +(see MacPerl.pm for details). + +Files that appear on the desktop actually reside in an (hidden) directory +named "Desktop Folder" on the particular disk volume. Note that, although +all desktop files appear to be on the same "virtual" desktop, each disk +volume actually maintains its own "Desktop Folder" directory. + +=back + +=back + +=head1 HISTORY + +File::Find used to produce incorrect results if called recursively. +During the development of perl 5.8 this bug was fixed. +The first fixed version of File::Find was 1.01. + +=cut + +our @ISA = qw(Exporter); +our @EXPORT = qw(find finddepth); + + +use strict; +my $Is_VMS; +my $Is_MacOS; + +require File::Basename; +require File::Spec; + +# Should ideally be my() not our() but local() currently +# refuses to operate on lexicals + +our %SLnkSeen; +our ($wanted_callback, $avoid_nlink, $bydepth, $no_chdir, $follow, + $follow_skip, $full_check, $untaint, $untaint_skip, $untaint_pat, + $pre_process, $post_process, $dangling_symlinks); + +sub contract_name { + my ($cdir,$fn) = @_; + + return substr($cdir,0,rindex($cdir,'/')) if $fn eq $File::Find::current_dir; + + $cdir = substr($cdir,0,rindex($cdir,'/')+1); + + $fn =~ s|^\./||; + + my $abs_name= $cdir . $fn; + + if (substr($fn,0,3) eq '../') { + 1 while $abs_name =~ s!/[^/]*/\.\./!/!; + } + + return $abs_name; +} + +# return the absolute name of a directory or file +sub contract_name_Mac { + my ($cdir,$fn) = @_; + my $abs_name; + + if ($fn =~ /^(:+)(.*)$/) { # valid pathname starting with a ':' + + my $colon_count = length ($1); + if ($colon_count == 1) { + $abs_name = $cdir . $2; + return $abs_name; + } + else { + # need to move up the tree, but + # only if it's not a volume name + for (my $i=1; $i<$colon_count; $i++) { + unless ($cdir =~ /^[^:]+:$/) { # volume name + $cdir =~ s/[^:]+:$//; + } + else { + return undef; + } + } + $abs_name = $cdir . $2; + return $abs_name; + } + + } + else { + + # $fn may be a valid path to a directory or file or (dangling) + # symlink, without a leading ':' + if ( (-e $fn) || (-l $fn) ) { + if ($fn =~ /^[^:]+:/) { # a volume name like DataHD:* + return $fn; # $fn is already an absolute path + } + else { + $abs_name = $cdir . $fn; + return $abs_name; + } + } + else { # argh!, $fn is not a valid directory/file + return undef; + } + } +} + +sub PathCombine($$) { + my ($Base,$Name) = @_; + my $AbsName; + + if ($Is_MacOS) { + # $Name is the resolved symlink (always a full path on MacOS), + # i.e. there's no need to call contract_name_Mac() + $AbsName = $Name; + + # (simple) check for recursion + if ( ( $Base =~ /^$AbsName/) && (-d $AbsName) ) { # recursion + return undef; + } + } + else { + if (substr($Name,0,1) eq '/') { + $AbsName= $Name; + } + else { + $AbsName= contract_name($Base,$Name); + } + + # (simple) check for recursion + my $newlen= length($AbsName); + if ($newlen <= length($Base)) { + if (($newlen == length($Base) || substr($Base,$newlen,1) eq '/') + && $AbsName eq substr($Base,0,$newlen)) + { + return undef; + } + } + } + return $AbsName; +} + +sub Follow_SymLink($) { + my ($AbsName) = @_; + + my ($NewName,$DEV, $INO); + ($DEV, $INO)= lstat $AbsName; + + while (-l _) { + if ($SLnkSeen{$DEV, $INO}++) { + if ($follow_skip < 2) { + die "$AbsName is encountered a second time"; + } + else { + return undef; + } + } + $NewName= PathCombine($AbsName, readlink($AbsName)); + unless(defined $NewName) { + if ($follow_skip < 2) { + die "$AbsName is a recursive symbolic link"; + } + else { + return undef; + } + } + else { + $AbsName= $NewName; + } + ($DEV, $INO) = lstat($AbsName); + return undef unless defined $DEV; # dangling symbolic link + } + + if ($full_check && defined $DEV && $SLnkSeen{$DEV, $INO}++) { + if ( ($follow_skip < 1) || ((-d _) && ($follow_skip < 2)) ) { + die "$AbsName encountered a second time"; + } + else { + return undef; + } + } + + return $AbsName; +} + +our($dir, $name, $fullname, $prune); +sub _find_dir_symlnk($$$); +sub _find_dir($$$); + +# check whether or not a scalar variable is tainted +# (code straight from the Camel, 3rd ed., page 561) +sub is_tainted_pp { + my $arg = shift; + my $nada = substr($arg, 0, 0); # zero-length + local $@; + eval { eval "# $nada" }; + return length($@) != 0; +} + +sub _find_opt { + my $wanted = shift; + die "invalid top directory" unless defined $_[0]; + + # This function must local()ize everything because callbacks may + # call find() or finddepth() + + local %SLnkSeen; + local ($wanted_callback, $avoid_nlink, $bydepth, $no_chdir, $follow, + $follow_skip, $full_check, $untaint, $untaint_skip, $untaint_pat, + $pre_process, $post_process, $dangling_symlinks); + local($dir, $name, $fullname, $prune); + + my $cwd = $wanted->{bydepth} ? Cwd::fastcwd() : Cwd::getcwd(); + my $cwd_untainted = $cwd; + my $check_t_cwd = 1; + $wanted_callback = $wanted->{wanted}; + $bydepth = $wanted->{bydepth}; + $pre_process = $wanted->{preprocess}; + $post_process = $wanted->{postprocess}; + $no_chdir = $wanted->{no_chdir}; + $full_check = $wanted->{follow}; + $follow = $full_check || $wanted->{follow_fast}; + $follow_skip = $wanted->{follow_skip}; + $untaint = $wanted->{untaint}; + $untaint_pat = $wanted->{untaint_pattern}; + $untaint_skip = $wanted->{untaint_skip}; + $dangling_symlinks = $wanted->{dangling_symlinks}; + + # for compatibility reasons (find.pl, find2perl) + local our ($topdir, $topdev, $topino, $topmode, $topnlink); + + # a symbolic link to a directory doesn't increase the link count + $avoid_nlink = $follow || $File::Find::dont_use_nlink; + + my ($abs_dir, $Is_Dir); + + Proc_Top_Item: + foreach my $TOP (@_) { + my $top_item = $TOP; + + if ($Is_MacOS) { + ($topdev,$topino,$topmode,$topnlink) = $follow ? stat $top_item : lstat $top_item; + $top_item = ":$top_item" + if ( (-d _) && ( $top_item !~ /:/ ) ); + } + else { + $top_item =~ s|/\z|| unless $top_item eq '/'; + ($topdev,$topino,$topmode,$topnlink) = $follow ? stat $top_item : lstat $top_item; + } + + $Is_Dir= 0; + + if ($follow) { + + if ($Is_MacOS) { + $cwd = "$cwd:" unless ($cwd =~ /:$/); # for safety + + if ($top_item eq $File::Find::current_dir) { + $abs_dir = $cwd; + } + else { + $abs_dir = contract_name_Mac($cwd, $top_item); + unless (defined $abs_dir) { + warnings::warnif "Can't determine absolute path for $top_item (No such file or directory)\n"; + next Proc_Top_Item; + } + } + + } + else { + if (substr($top_item,0,1) eq '/') { + $abs_dir = $top_item; + } + elsif ($top_item eq $File::Find::current_dir) { + $abs_dir = $cwd; + } + else { # care about any ../ + $abs_dir = contract_name("$cwd/",$top_item); + } + } + $abs_dir= Follow_SymLink($abs_dir); + unless (defined $abs_dir) { + if ($dangling_symlinks) { + if (ref $dangling_symlinks eq 'CODE') { + $dangling_symlinks->($top_item, $cwd); + } else { + warnings::warnif "$top_item is a dangling symbolic link\n"; + } + } + next Proc_Top_Item; + } + + if (-d _) { + _find_dir_symlnk($wanted, $abs_dir, $top_item); + $Is_Dir= 1; + } + } + else { # no follow + $topdir = $top_item; + unless (defined $topnlink) { + warnings::warnif "Can't stat $top_item: $!\n"; + next Proc_Top_Item; + } + if (-d _) { + $top_item =~ s/\.dir\z// if $Is_VMS; + _find_dir($wanted, $top_item, $topnlink); + $Is_Dir= 1; + } + else { + $abs_dir= $top_item; + } + } + + unless ($Is_Dir) { + unless (($_,$dir) = File::Basename::fileparse($abs_dir)) { + if ($Is_MacOS) { + ($dir,$_) = (':', $top_item); # $File::Find::dir, $_ + } + else { + ($dir,$_) = ('./', $top_item); + } + } + + $abs_dir = $dir; + if (( $untaint ) && (is_tainted($dir) )) { + ( $abs_dir ) = $dir =~ m|$untaint_pat|; + unless (defined $abs_dir) { + if ($untaint_skip == 0) { + die "directory $dir is still tainted"; + } + else { + next Proc_Top_Item; + } + } + } + + unless ($no_chdir || chdir $abs_dir) { + warnings::warnif "Couldn't chdir $abs_dir: $!\n"; + next Proc_Top_Item; + } + + $name = $abs_dir . $_; # $File::Find::name + + { $wanted_callback->() }; # protect against wild "next" + + } + + unless ( $no_chdir ) { + if ( ($check_t_cwd) && (($untaint) && (is_tainted($cwd) )) ) { + ( $cwd_untainted ) = $cwd =~ m|$untaint_pat|; + unless (defined $cwd_untainted) { + die "insecure cwd in find(depth)"; + } + $check_t_cwd = 0; + } + unless (chdir $cwd_untainted) { + die "Can't cd to $cwd: $!\n"; + } + } + } +} + +# API: +# $wanted +# $p_dir : "parent directory" +# $nlink : what came back from the stat +# preconditions: +# chdir (if not no_chdir) to dir + +sub _find_dir($$$) { + my ($wanted, $p_dir, $nlink) = @_; + my ($CdLvl,$Level) = (0,0); + my @Stack; + my @filenames; + my ($subcount,$sub_nlink); + my $SE= []; + my $dir_name= $p_dir; + my $dir_pref; + my $dir_rel = $File::Find::current_dir; + my $tainted = 0; + my $no_nlink; + + if ($Is_MacOS) { + $dir_pref= ($p_dir =~ /:$/) ? $p_dir : "$p_dir:"; # preface + } + else { + $dir_pref= ( $p_dir eq '/' ? '/' : "$p_dir/" ); + } + + local ($dir, $name, $prune, *DIR); + + unless ( $no_chdir || ($p_dir eq $File::Find::current_dir)) { + my $udir = $p_dir; + if (( $untaint ) && (is_tainted($p_dir) )) { + ( $udir ) = $p_dir =~ m|$untaint_pat|; + unless (defined $udir) { + if ($untaint_skip == 0) { + die "directory $p_dir is still tainted"; + } + else { + return; + } + } + } + unless (chdir $udir) { + warnings::warnif "Can't cd to $udir: $!\n"; + return; + } + } + + # push the starting directory + push @Stack,[$CdLvl,$p_dir,$dir_rel,-1] if $bydepth; + + if ($Is_MacOS) { + $p_dir = $dir_pref; # ensure trailing ':' + } + + while (defined $SE) { + unless ($bydepth) { + $dir= $p_dir; # $File::Find::dir + $name= $dir_name; # $File::Find::name + $_= ($no_chdir ? $dir_name : $dir_rel ); # $_ + # prune may happen here + $prune= 0; + { $wanted_callback->() }; # protect against wild "next" + next if $prune; + } + + # change to that directory + unless ($no_chdir || ($dir_rel eq $File::Find::current_dir)) { + my $udir= $dir_rel; + if ( ($untaint) && (($tainted) || ($tainted = is_tainted($dir_rel) )) ) { + ( $udir ) = $dir_rel =~ m|$untaint_pat|; + unless (defined $udir) { + if ($untaint_skip == 0) { + if ($Is_MacOS) { + die "directory ($p_dir) $dir_rel is still tainted"; + } + else { + die "directory (" . ($p_dir ne '/' ? $p_dir : '') . "/) $dir_rel is still tainted"; + } + } else { # $untaint_skip == 1 + next; + } + } + } + unless (chdir $udir) { + if ($Is_MacOS) { + warnings::warnif "Can't cd to ($p_dir) $udir: $!\n"; + } + else { + warnings::warnif "Can't cd to (" . + ($p_dir ne '/' ? $p_dir : '') . "/) $udir: $!\n"; + } + next; + } + $CdLvl++; + } + + if ($Is_MacOS) { + $dir_name = "$dir_name:" unless ($dir_name =~ /:$/); + } + + $dir= $dir_name; # $File::Find::dir + + # Get the list of files in the current directory. + unless (opendir DIR, ($no_chdir ? $dir_name : $File::Find::current_dir)) { + warnings::warnif "Can't opendir($dir_name): $!\n"; + next; + } + @filenames = readdir DIR; + closedir(DIR); + @filenames = $pre_process->(@filenames) if $pre_process; + push @Stack,[$CdLvl,$dir_name,"",-2] if $post_process; + + # default: use whatever was specifid + # (if $nlink >= 2, and $avoid_nlink == 0, this will switch back) + $no_nlink = $avoid_nlink; + # if dir has wrong nlink count, force switch to slower stat method + $no_nlink = 1 if ($nlink < 2); + + if ($nlink == 2 && !$no_nlink) { + # This dir has no subdirectories. + for my $FN (@filenames) { + next if $FN =~ $File::Find::skip_pattern; + + $name = $dir_pref . $FN; # $File::Find::name + $_ = ($no_chdir ? $name : $FN); # $_ + { $wanted_callback->() }; # protect against wild "next" + } + + } + else { + # This dir has subdirectories. + $subcount = $nlink - 2; + + for my $FN (@filenames) { + next if $FN =~ $File::Find::skip_pattern; + if ($subcount > 0 || $no_nlink) { + # Seen all the subdirs? + # check for directoriness. + # stat is faster for a file in the current directory + $sub_nlink = (lstat ($no_chdir ? $dir_pref . $FN : $FN))[3]; + + if (-d _) { + --$subcount; + $FN =~ s/\.dir\z// if $Is_VMS; + push @Stack,[$CdLvl,$dir_name,$FN,$sub_nlink]; + } + else { + $name = $dir_pref . $FN; # $File::Find::name + $_= ($no_chdir ? $name : $FN); # $_ + { $wanted_callback->() }; # protect against wild "next" + } + } + else { + $name = $dir_pref . $FN; # $File::Find::name + $_= ($no_chdir ? $name : $FN); # $_ + { $wanted_callback->() }; # protect against wild "next" + } + } + } + } + continue { + while ( defined ($SE = pop @Stack) ) { + ($Level, $p_dir, $dir_rel, $nlink) = @$SE; + if ($CdLvl > $Level && !$no_chdir) { + my $tmp; + if ($Is_MacOS) { + $tmp = (':' x ($CdLvl-$Level)) . ':'; + } + else { + $tmp = join('/',('..') x ($CdLvl-$Level)); + } + die "Can't cd to $dir_name" . $tmp + unless chdir ($tmp); + $CdLvl = $Level; + } + + if ($Is_MacOS) { + # $pdir always has a trailing ':', except for the starting dir, + # where $dir_rel eq ':' + $dir_name = "$p_dir$dir_rel"; + $dir_pref = "$dir_name:"; + } + else { + $dir_name = ($p_dir eq '/' ? "/$dir_rel" : "$p_dir/$dir_rel"); + $dir_pref = "$dir_name/"; + } + + if ( $nlink == -2 ) { + $name = $dir = $p_dir; # $File::Find::name / dir + $_ = $File::Find::current_dir; + $post_process->(); # End-of-directory processing + } + elsif ( $nlink < 0 ) { # must be finddepth, report dirname now + $name = $dir_name; + if ($Is_MacOS) { + if ($dir_rel eq ':') { # must be the top dir, where we started + $name =~ s|:$||; # $File::Find::name + $p_dir = "$p_dir:" unless ($p_dir =~ /:$/); + } + $dir = $p_dir; # $File::Find::dir + $_ = ($no_chdir ? $name : $dir_rel); # $_ + } + else { + if ( substr($name,-2) eq '/.' ) { + substr($name, length($name) == 2 ? -1 : -2) = ''; + } + $dir = $p_dir; + $_ = ($no_chdir ? $dir_name : $dir_rel ); + if ( substr($_,-2) eq '/.' ) { + substr($_, length($_) == 2 ? -1 : -2) = ''; + } + } + { $wanted_callback->() }; # protect against wild "next" + } + else { + push @Stack,[$CdLvl,$p_dir,$dir_rel,-1] if $bydepth; + last; + } + } + } +} + + +# API: +# $wanted +# $dir_loc : absolute location of a dir +# $p_dir : "parent directory" +# preconditions: +# chdir (if not no_chdir) to dir + +sub _find_dir_symlnk($$$) { + my ($wanted, $dir_loc, $p_dir) = @_; # $dir_loc is the absolute directory + my @Stack; + my @filenames; + my $new_loc; + my $updir_loc = $dir_loc; # untainted parent directory + my $SE = []; + my $dir_name = $p_dir; + my $dir_pref; + my $loc_pref; + my $dir_rel = $File::Find::current_dir; + my $byd_flag; # flag for pending stack entry if $bydepth + my $tainted = 0; + my $ok = 1; + + if ($Is_MacOS) { + $dir_pref = ($p_dir =~ /:$/) ? "$p_dir" : "$p_dir:"; + $loc_pref = ($dir_loc =~ /:$/) ? "$dir_loc" : "$dir_loc:"; + } else { + $dir_pref = ( $p_dir eq '/' ? '/' : "$p_dir/" ); + $loc_pref = ( $dir_loc eq '/' ? '/' : "$dir_loc/" ); + } + + local ($dir, $name, $fullname, $prune, *DIR); + + unless ($no_chdir) { + # untaint the topdir + if (( $untaint ) && (is_tainted($dir_loc) )) { + ( $updir_loc ) = $dir_loc =~ m|$untaint_pat|; # parent dir, now untainted + # once untainted, $updir_loc is pushed on the stack (as parent directory); + # hence, we don't need to untaint the parent directory every time we chdir + # to it later + unless (defined $updir_loc) { + if ($untaint_skip == 0) { + die "directory $dir_loc is still tainted"; + } + else { + return; + } + } + } + $ok = chdir($updir_loc) unless ($p_dir eq $File::Find::current_dir); + unless ($ok) { + warnings::warnif "Can't cd to $updir_loc: $!\n"; + return; + } + } + + push @Stack,[$dir_loc,$updir_loc,$p_dir,$dir_rel,-1] if $bydepth; + + if ($Is_MacOS) { + $p_dir = $dir_pref; # ensure trailing ':' + } + + while (defined $SE) { + + unless ($bydepth) { + # change (back) to parent directory (always untainted) + unless ($no_chdir) { + unless (chdir $updir_loc) { + warnings::warnif "Can't cd to $updir_loc: $!\n"; + next; + } + } + $dir= $p_dir; # $File::Find::dir + $name= $dir_name; # $File::Find::name + $_= ($no_chdir ? $dir_name : $dir_rel ); # $_ + $fullname= $dir_loc; # $File::Find::fullname + # prune may happen here + $prune= 0; + lstat($_); # make sure file tests with '_' work + { $wanted_callback->() }; # protect against wild "next" + next if $prune; + } + + # change to that directory + unless ($no_chdir || ($dir_rel eq $File::Find::current_dir)) { + $updir_loc = $dir_loc; + if ( ($untaint) && (($tainted) || ($tainted = is_tainted($dir_loc) )) ) { + # untaint $dir_loc, what will be pushed on the stack as (untainted) parent dir + ( $updir_loc ) = $dir_loc =~ m|$untaint_pat|; + unless (defined $updir_loc) { + if ($untaint_skip == 0) { + die "directory $dir_loc is still tainted"; + } + else { + next; + } + } + } + unless (chdir $updir_loc) { + warnings::warnif "Can't cd to $updir_loc: $!\n"; + next; + } + } + + if ($Is_MacOS) { + $dir_name = "$dir_name:" unless ($dir_name =~ /:$/); + } + + $dir = $dir_name; # $File::Find::dir + + # Get the list of files in the current directory. + unless (opendir DIR, ($no_chdir ? $dir_loc : $File::Find::current_dir)) { + warnings::warnif "Can't opendir($dir_loc): $!\n"; + next; + } + @filenames = readdir DIR; + closedir(DIR); + + for my $FN (@filenames) { + next if $FN =~ $File::Find::skip_pattern; + + # follow symbolic links / do an lstat + $new_loc = Follow_SymLink($loc_pref.$FN); + + # ignore if invalid symlink + next unless defined $new_loc; + + if (-d _) { + push @Stack,[$new_loc,$updir_loc,$dir_name,$FN,1]; + } + else { + $fullname = $new_loc; # $File::Find::fullname + $name = $dir_pref . $FN; # $File::Find::name + $_ = ($no_chdir ? $name : $FN); # $_ + { $wanted_callback->() }; # protect against wild "next" + } + } + + } + continue { + while (defined($SE = pop @Stack)) { + ($dir_loc, $updir_loc, $p_dir, $dir_rel, $byd_flag) = @$SE; + if ($Is_MacOS) { + # $p_dir always has a trailing ':', except for the starting dir, + # where $dir_rel eq ':' + $dir_name = "$p_dir$dir_rel"; + $dir_pref = "$dir_name:"; + $loc_pref = ($dir_loc =~ /:$/) ? $dir_loc : "$dir_loc:"; + } + else { + $dir_name = ($p_dir eq '/' ? "/$dir_rel" : "$p_dir/$dir_rel"); + $dir_pref = "$dir_name/"; + $loc_pref = "$dir_loc/"; + } + if ( $byd_flag < 0 ) { # must be finddepth, report dirname now + unless ($no_chdir || ($dir_rel eq $File::Find::current_dir)) { + unless (chdir $updir_loc) { # $updir_loc (parent dir) is always untainted + warnings::warnif "Can't cd to $updir_loc: $!\n"; + next; + } + } + $fullname = $dir_loc; # $File::Find::fullname + $name = $dir_name; # $File::Find::name + if ($Is_MacOS) { + if ($dir_rel eq ':') { # must be the top dir, where we started + $name =~ s|:$||; # $File::Find::name + $p_dir = "$p_dir:" unless ($p_dir =~ /:$/); + } + $dir = $p_dir; # $File::Find::dir + $_ = ($no_chdir ? $name : $dir_rel); # $_ + } + else { + if ( substr($name,-2) eq '/.' ) { + substr($name, length($name) == 2 ? -1 : -2) = ''; # $File::Find::name + } + $dir = $p_dir; # $File::Find::dir + $_ = ($no_chdir ? $dir_name : $dir_rel); # $_ + if ( substr($_,-2) eq '/.' ) { + substr($_, length($_) == 2 ? -1 : -2) = ''; + } + } + + lstat($_); # make sure file tests with '_' work + { $wanted_callback->() }; # protect against wild "next" + } + else { + push @Stack,[$dir_loc, $updir_loc, $p_dir, $dir_rel,-1] if $bydepth; + last; + } + } + } +} + + +sub wrap_wanted { + my $wanted = shift; + if ( ref($wanted) eq 'HASH' ) { + if ( $wanted->{follow} || $wanted->{follow_fast}) { + $wanted->{follow_skip} = 1 unless defined $wanted->{follow_skip}; + } + if ( $wanted->{untaint} ) { + $wanted->{untaint_pattern} = $File::Find::untaint_pattern + unless defined $wanted->{untaint_pattern}; + $wanted->{untaint_skip} = 0 unless defined $wanted->{untaint_skip}; + } + return $wanted; + } + else { + return { wanted => $wanted }; + } +} + +sub find { + my $wanted = shift; + _find_opt(wrap_wanted($wanted), @_); +} + +sub finddepth { + my $wanted = wrap_wanted(shift); + $wanted->{bydepth} = 1; + _find_opt($wanted, @_); +} + +# default +$File::Find::skip_pattern = qr/^\.{1,2}\z/; +$File::Find::untaint_pattern = qr|^([-+@\w./]+)$|; + +# These are hard-coded for now, but may move to hint files. +if ($^O eq 'VMS') { + $Is_VMS = 1; + $File::Find::dont_use_nlink = 1; +} +elsif ($^O eq 'MacOS') { + $Is_MacOS = 1; + $File::Find::dont_use_nlink = 1; + $File::Find::skip_pattern = qr/^Icon\015\z/; + $File::Find::untaint_pattern = qr|^(.+)$|; +} + +# this _should_ work properly on all platforms +# where File::Find can be expected to work +$File::Find::current_dir = File::Spec->curdir || '.'; + +$File::Find::dont_use_nlink = 1 + if $^O eq 'os2' || $^O eq 'dos' || $^O eq 'amigaos' || $^O eq 'MSWin32' || + $^O eq 'cygwin' || $^O eq 'epoc' || $^O eq 'qnx' || + $^O eq 'nto'; + +# Set dont_use_nlink in your hint file if your system's stat doesn't +# report the number of links in a directory as an indication +# of the number of files. +# See, e.g. hints/machten.sh for MachTen 2.2. +unless ($File::Find::dont_use_nlink) { + require Config; + $File::Find::dont_use_nlink = 1 if ($Config::Config{'dont_use_nlink'}); +} + +# We need a function that checks if a scalar is tainted. Either use the +# Scalar::Util module's tainted() function or our (slower) pure Perl +# fallback is_tainted_pp() +{ + local $@; + eval { require Scalar::Util }; + *is_tainted = $@ ? \&is_tainted_pp : \&Scalar::Util::tainted; +} + +1; diff --git a/Master/xemtex/perl/lib/File/Glob.pm b/Master/xemtex/perl/lib/File/Glob.pm new file mode 100644 index 00000000000..a704b567bb0 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Glob.pm @@ -0,0 +1,465 @@ +package File::Glob; + +use strict; +our($VERSION, @ISA, @EXPORT_OK, @EXPORT_FAIL, %EXPORT_TAGS, + $AUTOLOAD, $DEFAULT_FLAGS); + +use XSLoader (); + +@ISA = qw(Exporter); + +# NOTE: The glob() export is only here for compatibility with 5.6.0. +# csh_glob() should not be used directly, unless you know what you're doing. + +@EXPORT_OK = qw( + csh_glob + bsd_glob + glob + GLOB_ABEND + GLOB_ALPHASORT + GLOB_ALTDIRFUNC + GLOB_BRACE + GLOB_CSH + GLOB_ERR + GLOB_ERROR + GLOB_LIMIT + GLOB_MARK + GLOB_NOCASE + GLOB_NOCHECK + GLOB_NOMAGIC + GLOB_NOSORT + GLOB_NOSPACE + GLOB_QUOTE + GLOB_TILDE +); + +%EXPORT_TAGS = ( + 'glob' => [ qw( + GLOB_ABEND + GLOB_ALPHASORT + GLOB_ALTDIRFUNC + GLOB_BRACE + GLOB_CSH + GLOB_ERR + GLOB_ERROR + GLOB_LIMIT + GLOB_MARK + GLOB_NOCASE + GLOB_NOCHECK + GLOB_NOMAGIC + GLOB_NOSORT + GLOB_NOSPACE + GLOB_QUOTE + GLOB_TILDE + glob + bsd_glob + ) ], +); + +$VERSION = '1.01'; + +sub import { + require Exporter; + my $i = 1; + while ($i < @_) { + if ($_[$i] =~ /^:(case|nocase|globally)$/) { + splice(@_, $i, 1); + $DEFAULT_FLAGS &= ~GLOB_NOCASE() if $1 eq 'case'; + $DEFAULT_FLAGS |= GLOB_NOCASE() if $1 eq 'nocase'; + if ($1 eq 'globally') { + local $^W; + *CORE::GLOBAL::glob = \&File::Glob::csh_glob; + } + next; + } + ++$i; + } + goto &Exporter::import; +} + +sub AUTOLOAD { + # This AUTOLOAD is used to 'autoload' constants from the constant() + # XS function. If a constant is not found then control is passed + # to the AUTOLOAD in AutoLoader. + + my $constname; + ($constname = $AUTOLOAD) =~ s/.*:://; + my ($error, $val) = constant($constname); + if ($error) { + require Carp; + Carp::croak($error); + } + eval "sub $AUTOLOAD { $val }"; + goto &$AUTOLOAD; +} + +XSLoader::load 'File::Glob', $VERSION; + +# Preloaded methods go here. + +sub GLOB_ERROR { + return (constant('GLOB_ERROR'))[1]; +} + +sub GLOB_CSH () { + GLOB_BRACE() + | GLOB_NOMAGIC() + | GLOB_QUOTE() + | GLOB_TILDE() + | GLOB_ALPHASORT() +} + +$DEFAULT_FLAGS = GLOB_CSH(); +if ($^O =~ /^(?:MSWin32|VMS|os2|dos|riscos|MacOS)$/) { + $DEFAULT_FLAGS |= GLOB_NOCASE(); +} + +# Autoload methods go after =cut, and are processed by the autosplit program. + +sub bsd_glob { + my ($pat,$flags) = @_; + $flags = $DEFAULT_FLAGS if @_ < 2; + return doglob($pat,$flags); +} + +# File::Glob::glob() is deprecated because its prototype is different from +# CORE::glob() (use bsd_glob() instead) +sub glob { + goto &bsd_glob; +} + +## borrowed heavily from gsar's File::DosGlob +my %iter; +my %entries; + +sub csh_glob { + my $pat = shift; + my $cxix = shift; + my @pat; + + # glob without args defaults to $_ + $pat = $_ unless defined $pat; + + # extract patterns + $pat =~ s/^\s+//; # Protect against empty elements in + $pat =~ s/\s+$//; # things like < *.c> and <*.c >. + # These alone shouldn't trigger ParseWords. + if ($pat =~ /\s/) { + # XXX this is needed for compatibility with the csh + # implementation in Perl. Need to support a flag + # to disable this behavior. + require Text::ParseWords; + @pat = Text::ParseWords::parse_line('\s+',0,$pat); + } + + # assume global context if not provided one + $cxix = '_G_' unless defined $cxix; + $iter{$cxix} = 0 unless exists $iter{$cxix}; + + # if we're just beginning, do it all first + if ($iter{$cxix} == 0) { + if (@pat) { + $entries{$cxix} = [ map { doglob($_, $DEFAULT_FLAGS) } @pat ]; + } + else { + $entries{$cxix} = [ doglob($pat, $DEFAULT_FLAGS) ]; + } + } + + # chuck it all out, quick or slow + if (wantarray) { + delete $iter{$cxix}; + return @{delete $entries{$cxix}}; + } + else { + if ($iter{$cxix} = scalar @{$entries{$cxix}}) { + return shift @{$entries{$cxix}}; + } + else { + # return undef for EOL + delete $iter{$cxix}; + delete $entries{$cxix}; + return undef; + } + } +} + +1; +__END__ + +=head1 NAME + +File::Glob - Perl extension for BSD glob routine + +=head1 SYNOPSIS + + use File::Glob ':glob'; + @list = bsd_glob('*.[ch]'); + $homedir = bsd_glob('~gnat', GLOB_TILDE | GLOB_ERR); + if (GLOB_ERROR) { + # an error occurred reading $homedir + } + + ## override the core glob (CORE::glob() does this automatically + ## by default anyway, since v5.6.0) + use File::Glob ':globally'; + my @sources = <*.{c,h,y}> + + ## override the core glob, forcing case sensitivity + use File::Glob qw(:globally :case); + my @sources = <*.{c,h,y}> + + ## override the core glob forcing case insensitivity + use File::Glob qw(:globally :nocase); + my @sources = <*.{c,h,y}> + +=head1 DESCRIPTION + +File::Glob::bsd_glob() implements the FreeBSD glob(3) routine, which is +a superset of the POSIX glob() (described in IEEE Std 1003.2 "POSIX.2"). +bsd_glob() takes a mandatory C<pattern> argument, and an optional +C<flags> argument, and returns a list of filenames matching the +pattern, with interpretation of the pattern modified by the C<flags> +variable. + +Since v5.6.0, Perl's CORE::glob() is implemented in terms of bsd_glob(). +Note that they don't share the same prototype--CORE::glob() only accepts +a single argument. Due to historical reasons, CORE::glob() will also +split its argument on whitespace, treating it as multiple patterns, +whereas bsd_glob() considers them as one pattern. + +The POSIX defined flags for bsd_glob() are: + +=over 4 + +=item C<GLOB_ERR> + +Force bsd_glob() to return an error when it encounters a directory it +cannot open or read. Ordinarily bsd_glob() continues to find matches. + +=item C<GLOB_LIMIT> + +Make bsd_glob() return an error (GLOB_NOSPACE) when the pattern expands +to a size bigger than the system constant C<ARG_MAX> (usually found in +limits.h). If your system does not define this constant, bsd_glob() uses +C<sysconf(_SC_ARG_MAX)> or C<_POSIX_ARG_MAX> where available (in that +order). You can inspect these values using the standard C<POSIX> +extension. + +=item C<GLOB_MARK> + +Each pathname that is a directory that matches the pattern has a slash +appended. + +=item C<GLOB_NOCASE> + +By default, file names are assumed to be case sensitive; this flag +makes bsd_glob() treat case differences as not significant. + +=item C<GLOB_NOCHECK> + +If the pattern does not match any pathname, then bsd_glob() returns a list +consisting of only the pattern. If C<GLOB_QUOTE> is set, its effect +is present in the pattern returned. + +=item C<GLOB_NOSORT> + +By default, the pathnames are sorted in ascending ASCII order; this +flag prevents that sorting (speeding up bsd_glob()). + +=back + +The FreeBSD extensions to the POSIX standard are the following flags: + +=over 4 + +=item C<GLOB_BRACE> + +Pre-process the string to expand C<{pat,pat,...}> strings like csh(1). +The pattern '{}' is left unexpanded for historical reasons (and csh(1) +does the same thing to ease typing of find(1) patterns). + +=item C<GLOB_NOMAGIC> + +Same as C<GLOB_NOCHECK> but it only returns the pattern if it does not +contain any of the special characters "*", "?" or "[". C<NOMAGIC> is +provided to simplify implementing the historic csh(1) globbing +behaviour and should probably not be used anywhere else. + +=item C<GLOB_QUOTE> + +Use the backslash ('\') character for quoting: every occurrence of a +backslash followed by a character in the pattern is replaced by that +character, avoiding any special interpretation of the character. +(But see below for exceptions on DOSISH systems). + +=item C<GLOB_TILDE> + +Expand patterns that start with '~' to user name home directories. + +=item C<GLOB_CSH> + +For convenience, C<GLOB_CSH> is a synonym for +C<GLOB_BRACE | GLOB_NOMAGIC | GLOB_QUOTE | GLOB_TILDE | GLOB_ALPHASORT>. + +=back + +The POSIX provided C<GLOB_APPEND>, C<GLOB_DOOFFS>, and the FreeBSD +extensions C<GLOB_ALTDIRFUNC>, and C<GLOB_MAGCHAR> flags have not been +implemented in the Perl version because they involve more complex +interaction with the underlying C structures. + +The following flag has been added in the Perl implementation for +csh compatibility: + +=over 4 + +=item C<GLOB_ALPHASORT> + +If C<GLOB_NOSORT> is not in effect, sort filenames is alphabetical +order (case does not matter) rather than in ASCII order. + +=back + +=head1 DIAGNOSTICS + +bsd_glob() returns a list of matching paths, possibly zero length. If an +error occurred, &File::Glob::GLOB_ERROR will be non-zero and C<$!> will be +set. &File::Glob::GLOB_ERROR is guaranteed to be zero if no error occurred, +or one of the following values otherwise: + +=over 4 + +=item C<GLOB_NOSPACE> + +An attempt to allocate memory failed. + +=item C<GLOB_ABEND> + +The glob was stopped because an error was encountered. + +=back + +In the case where bsd_glob() has found some matching paths, but is +interrupted by an error, it will return a list of filenames B<and> +set &File::Glob::ERROR. + +Note that bsd_glob() deviates from POSIX and FreeBSD glob(3) behaviour +by not considering C<ENOENT> and C<ENOTDIR> as errors - bsd_glob() will +continue processing despite those errors, unless the C<GLOB_ERR> flag is +set. + +Be aware that all filenames returned from File::Glob are tainted. + +=head1 NOTES + +=over 4 + +=item * + +If you want to use multiple patterns, e.g. C<bsd_glob "a* b*">, you should +probably throw them in a set as in C<bsd_glob "{a*,b*}">. This is because +the argument to bsd_glob() isn't subjected to parsing by the C shell. +Remember that you can use a backslash to escape things. + +=item * + +On DOSISH systems, backslash is a valid directory separator character. +In this case, use of backslash as a quoting character (via GLOB_QUOTE) +interferes with the use of backslash as a directory separator. The +best (simplest, most portable) solution is to use forward slashes for +directory separators, and backslashes for quoting. However, this does +not match "normal practice" on these systems. As a concession to user +expectation, therefore, backslashes (under GLOB_QUOTE) only quote the +glob metacharacters '[', ']', '{', '}', '-', '~', and backslash itself. +All other backslashes are passed through unchanged. + +=item * + +Win32 users should use the real slash. If you really want to use +backslashes, consider using Sarathy's File::DosGlob, which comes with +the standard Perl distribution. + +=item * + +Mac OS (Classic) users should note a few differences. Since +Mac OS is not Unix, when the glob code encounters a tilde glob (e.g. +~user) and the C<GLOB_TILDE> flag is used, it simply returns that +pattern without doing any expansion. + +Glob on Mac OS is case-insensitive by default (if you don't use any +flags). If you specify any flags at all and still want glob +to be case-insensitive, you must include C<GLOB_NOCASE> in the flags. + +The path separator is ':' (aka colon), not '/' (aka slash). Mac OS users +should be careful about specifying relative pathnames. While a full path +always begins with a volume name, a relative pathname should always +begin with a ':'. If specifying a volume name only, a trailing ':' is +required. + +The specification of pathnames in glob patterns adheres to the usual Mac +OS conventions: The path separator is a colon ':', not a slash '/'. A +full path always begins with a volume name. A relative pathname on Mac +OS must always begin with a ':', except when specifying a file or +directory name in the current working directory, where the leading colon +is optional. If specifying a volume name only, a trailing ':' is +required. Due to these rules, a glob like E<lt>*:E<gt> will find all +mounted volumes, while a glob like E<lt>*E<gt> or E<lt>:*E<gt> will find +all files and directories in the current directory. + +Note that updirs in the glob pattern are resolved before the matching begins, +i.e. a pattern like "*HD:t?p::a*" will be matched as "*HD:a*". Note also, +that a single trailing ':' in the pattern is ignored (unless it's a volume +name pattern like "*HD:"), i.e. a glob like E<lt>:*:E<gt> will find both +directories I<and> files (and not, as one might expect, only directories). +You can, however, use the C<GLOB_MARK> flag to distinguish (without a file +test) directory names from file names. + +If the C<GLOB_MARK> flag is set, all directory paths will have a ':' appended. +Since a directory like 'lib:' is I<not> a valid I<relative> path on Mac OS, +both a leading and a trailing colon will be added, when the directory name in +question doesn't contain any colons (e.g. 'lib' becomes ':lib:'). + +=back + +=head1 AUTHOR + +The Perl interface was written by Nathan Torkington E<lt>gnat@frii.comE<gt>, +and is released under the artistic license. Further modifications were +made by Greg Bacon E<lt>gbacon@cs.uah.eduE<gt>, Gurusamy Sarathy +E<lt>gsar@activestate.comE<gt>, and Thomas Wegner +E<lt>wegner_thomas@yahoo.comE<gt>. The C glob code has the +following copyright: + + Copyright (c) 1989, 1993 The Regents of the University of California. + All rights reserved. + + This code is derived from software contributed to Berkeley by + Guido van Rossum. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the University nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + +=cut diff --git a/Master/xemtex/perl/lib/File/Path.pm b/Master/xemtex/perl/lib/File/Path.pm new file mode 100644 index 00000000000..46af24fdb20 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Path.pm @@ -0,0 +1,267 @@ +package File::Path; + +=head1 NAME + +File::Path - create or remove directory trees + +=head1 SYNOPSIS + + use File::Path; + + mkpath(['/foo/bar/baz', 'blurfl/quux'], 1, 0711); + rmtree(['foo/bar/baz', 'blurfl/quux'], 1, 1); + +=head1 DESCRIPTION + +The C<mkpath> function provides a convenient way to create directories, even +if your C<mkdir> kernel call won't create more than one level of directory at +a time. C<mkpath> takes three arguments: + +=over 4 + +=item * + +the name of the path to create, or a reference +to a list of paths to create, + +=item * + +a boolean value, which if TRUE will cause C<mkpath> +to print the name of each directory as it is created +(defaults to FALSE), and + +=item * + +the numeric mode to use when creating the directories +(defaults to 0777) + +=back + +It returns a list of all directories (including intermediates, determined +using the Unix '/' separator) created. + +If a system error prevents a directory from being created, then the +C<mkpath> function throws a fatal error with C<Carp::croak>. This error +can be trapped with an C<eval> block: + + eval { mkpath($dir) }; + if ($@) { + print "Couldn't create $dir: $@"; + } + +Similarly, the C<rmtree> function provides a convenient way to delete a +subtree from the directory structure, much like the Unix command C<rm -r>. +C<rmtree> takes three arguments: + +=over 4 + +=item * + +the root of the subtree to delete, or a reference to +a list of roots. All of the files and directories +below each root, as well as the roots themselves, +will be deleted. + +=item * + +a boolean value, which if TRUE will cause C<rmtree> to +print a message each time it examines a file, giving the +name of the file, and indicating whether it's using C<rmdir> +or C<unlink> to remove it, or that it's skipping it. +(defaults to FALSE) + +=item * + +a boolean value, which if TRUE will cause C<rmtree> to +skip any files to which you do not have delete access +(if running under VMS) or write access (if running +under another OS). This will change in the future when +a criterion for 'delete permission' under OSs other +than VMS is settled. (defaults to FALSE) + +=back + +It returns the number of files successfully deleted. Symlinks are +simply deleted and not followed. + +B<NOTE:> If the third parameter is not TRUE, C<rmtree> is B<unsecure> +in the face of failure or interruption. Files and directories which +were not deleted may be left with permissions reset to allow world +read and write access. Note also that the occurrence of errors in +rmtree can be determined I<only> by trapping diagnostic messages +using C<$SIG{__WARN__}>; it is not apparent from the return value. +Therefore, you must be extremely careful about using C<rmtree($foo,$bar,0> +in situations where security is an issue. + +=head1 AUTHORS + +Tim Bunce <F<Tim.Bunce@ig.co.uk>> and +Charles Bailey <F<bailey@newman.upenn.edu>> + +=cut + +use 5.006; +use Carp; +use File::Basename (); +use Exporter (); +use strict; +use warnings; + +our $VERSION = "1.05"; +our @ISA = qw( Exporter ); +our @EXPORT = qw( mkpath rmtree ); + +my $Is_VMS = $^O eq 'VMS'; +my $Is_MacOS = $^O eq 'MacOS'; + +# These OSes complain if you want to remove a file that you have no +# write permission to: +my $force_writeable = ($^O eq 'os2' || $^O eq 'dos' || $^O eq 'MSWin32' || + $^O eq 'amigaos' || $^O eq 'MacOS' || $^O eq 'epoc'); + +sub mkpath { + my($paths, $verbose, $mode) = @_; + # $paths -- either a path string or ref to list of paths + # $verbose -- optional print "mkdir $path" for each directory created + # $mode -- optional permissions, defaults to 0777 + local($")=$Is_MacOS ? ":" : "/"; + $mode = 0777 unless defined($mode); + $paths = [$paths] unless ref $paths; + my(@created,$path); + foreach $path (@$paths) { + $path .= '/' if $^O eq 'os2' and $path =~ /^\w:\z/s; # feature of CRT + # Logic wants Unix paths, so go with the flow. + if ($Is_VMS) { + next if $path eq '/'; + $path = VMS::Filespec::unixify($path); + if ($path =~ m:^(/[^/]+)/?\z:) { + $path = $1.'/000000'; + } + } + next if -d $path; + my $parent = File::Basename::dirname($path); + unless (-d $parent or $path eq $parent) { + push(@created,mkpath($parent, $verbose, $mode)); + } + print "mkdir $path\n" if $verbose; + unless (mkdir($path,$mode)) { + my $e = $!; + # allow for another process to have created it meanwhile + croak "mkdir $path: $e" unless -d $path; + } + push(@created, $path); + } + @created; +} + +sub rmtree { + my($roots, $verbose, $safe) = @_; + my(@files); + my($count) = 0; + $verbose ||= 0; + $safe ||= 0; + + if ( defined($roots) && length($roots) ) { + $roots = [$roots] unless ref $roots; + } + else { + carp "No root path(s) specified\n"; + return 0; + } + + my($root); + foreach $root (@{$roots}) { + if ($Is_MacOS) { + $root = ":$root" if $root !~ /:/; + $root =~ s#([^:])\z#$1:#; + } else { + $root =~ s#/\z##; + } + (undef, undef, my $rp) = lstat $root or next; + $rp &= 07777; # don't forget setuid, setgid, sticky bits + if ( -d _ ) { + # notabene: 0777 is for making readable in the first place, + # it's also intended to change it to writable in case we have + # to recurse in which case we are better than rm -rf for + # subtrees with strange permissions + chmod(0777, ($Is_VMS ? VMS::Filespec::fileify($root) : $root)) + or carp "Can't make directory $root read+writeable: $!" + unless $safe; + + if (opendir my $d, $root) { + no strict 'refs'; + if (!defined ${"\cTAINT"} or ${"\cTAINT"}) { + # Blindly untaint dir names + @files = map { /^(.*)$/s ; $1 } readdir $d; + } else { + @files = readdir $d; + } + closedir $d; + } + else { + carp "Can't read $root: $!"; + @files = (); + } + + # Deleting large numbers of files from VMS Files-11 filesystems + # is faster if done in reverse ASCIIbetical order + @files = reverse @files if $Is_VMS; + ($root = VMS::Filespec::unixify($root)) =~ s#\.dir\z## if $Is_VMS; + if ($Is_MacOS) { + @files = map("$root$_", @files); + } else { + @files = map("$root/$_", grep $_!~/^\.{1,2}\z/s,@files); + } + $count += rmtree(\@files,$verbose,$safe); + if ($safe && + ($Is_VMS ? !&VMS::Filespec::candelete($root) : !-w $root)) { + print "skipped $root\n" if $verbose; + next; + } + chmod 0777, $root + or carp "Can't make directory $root writeable: $!" + if $force_writeable; + print "rmdir $root\n" if $verbose; + if (rmdir $root) { + ++$count; + } + else { + carp "Can't remove directory $root: $!"; + chmod($rp, ($Is_VMS ? VMS::Filespec::fileify($root) : $root)) + or carp("and can't restore permissions to " + . sprintf("0%o",$rp) . "\n"); + } + } + else { + if ($safe && + ($Is_VMS ? !&VMS::Filespec::candelete($root) + : !(-l $root || -w $root))) + { + print "skipped $root\n" if $verbose; + next; + } + chmod 0666, $root + or carp "Can't make file $root writeable: $!" + if $force_writeable; + print "unlink $root\n" if $verbose; + # delete all versions under VMS + for (;;) { + unless (unlink $root) { + carp "Can't unlink file $root: $!"; + if ($force_writeable) { + chmod $rp, $root + or carp("and can't restore permissions to " + . sprintf("0%o",$rp) . "\n"); + } + last; + } + ++$count; + last unless $Is_VMS && lstat $root; + } + } + } + + $count; +} + +1; diff --git a/Master/xemtex/perl/lib/File/Spec.pm b/Master/xemtex/perl/lib/File/Spec.pm new file mode 100644 index 00000000000..529e34fe84a --- /dev/null +++ b/Master/xemtex/perl/lib/File/Spec.pm @@ -0,0 +1,292 @@ +package File::Spec; + +use strict; +our(@ISA, $VERSION); + +$VERSION = 0.83 ; + +my %module = (MacOS => 'Mac', + MSWin32 => 'Win32', + os2 => 'OS2', + VMS => 'VMS', + epoc => 'Epoc', + NetWare => 'Win32', # Yes, File::Spec::Win32 works on NetWare. + dos => 'OS2', # Yes, File::Spec::OS2 works on DJGPP. + cygwin => 'Cygwin'); + + +my $module = $module{$^O} || 'Unix'; + +require "File/Spec/$module.pm"; +@ISA = ("File::Spec::$module"); + +1; + +__END__ + +=head1 NAME + +File::Spec - portably perform operations on file names + +=head1 SYNOPSIS + + use File::Spec; + + $x=File::Spec->catfile('a', 'b', 'c'); + +which returns 'a/b/c' under Unix. Or: + + use File::Spec::Functions; + + $x = catfile('a', 'b', 'c'); + +=head1 DESCRIPTION + +This module is designed to support operations commonly performed on file +specifications (usually called "file names", but not to be confused with the +contents of a file, or Perl's file handles), such as concatenating several +directory and file names into a single path, or determining whether a path +is rooted. It is based on code directly taken from MakeMaker 5.17, code +written by Andreas KE<ouml>nig, Andy Dougherty, Charles Bailey, Ilya +Zakharevich, Paul Schinder, and others. + +Since these functions are different for most operating systems, each set of +OS specific routines is available in a separate module, including: + + File::Spec::Unix + File::Spec::Mac + File::Spec::OS2 + File::Spec::Win32 + File::Spec::VMS + +The module appropriate for the current OS is automatically loaded by +File::Spec. Since some modules (like VMS) make use of facilities available +only under that OS, it may not be possible to load all modules under all +operating systems. + +Since File::Spec is object oriented, subroutines should not be called directly, +as in: + + File::Spec::catfile('a','b'); + +but rather as class methods: + + File::Spec->catfile('a','b'); + +For simple uses, L<File::Spec::Functions> provides convenient functional +forms of these methods. + +=head1 METHODS + +=over 2 + +=item canonpath + +No physical check on the filesystem, but a logical cleanup of a +path. + + $cpath = File::Spec->canonpath( $path ) ; + +=item catdir + +Concatenate two or more directory names to form a complete path ending +with a directory. But remove the trailing slash from the resulting +string, because it doesn't look good, isn't necessary and confuses +OS2. Of course, if this is the root directory, don't cut off the +trailing slash :-) + + $path = File::Spec->catdir( @directories ); + +=item catfile + +Concatenate one or more directory names and a filename to form a +complete path ending with a filename + + $path = File::Spec->catfile( @directories, $filename ); + +=item curdir + +Returns a string representation of the current directory. + + $curdir = File::Spec->curdir(); + +=item devnull + +Returns a string representation of the null device. + + $devnull = File::Spec->devnull(); + +=item rootdir + +Returns a string representation of the root directory. + + $rootdir = File::Spec->rootdir(); + +=item tmpdir + +Returns a string representation of the first writable directory from a +list of possible temporary directories. Returns "" if no writable +temporary directories are found. The list of directories checked +depends on the platform; e.g. File::Spec::Unix checks $ENV{TMPDIR} and +/tmp. + + $tmpdir = File::Spec->tmpdir(); + +=item updir + +Returns a string representation of the parent directory. + + $updir = File::Spec->updir(); + +=item no_upwards + +Given a list of file names, strip out those that refer to a parent +directory. (Does not strip symlinks, only '.', '..', and equivalents.) + + @paths = File::Spec->no_upwards( @paths ); + +=item case_tolerant + +Returns a true or false value indicating, respectively, that alphabetic +is not or is significant when comparing file specifications. + + $is_case_tolerant = File::Spec->case_tolerant(); + +=item file_name_is_absolute + +Takes as argument a path and returns true if it is an absolute path. + + $is_absolute = File::Spec->file_name_is_absolute( $path ); + +This does not consult the local filesystem on Unix, Win32, OS/2, or +Mac OS (Classic). It does consult the working environment for VMS +(see L<File::Spec::VMS/file_name_is_absolute>). + +=item path + +Takes no argument, returns the environment variable PATH as an array. + + @PATH = File::Spec->path(); + +=item join + +join is the same as catfile. + +=item splitpath + +Splits a path in to volume, directory, and filename portions. On systems +with no concept of volume, returns undef for volume. + + ($volume,$directories,$file) = File::Spec->splitpath( $path ); + ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file ); + +For systems with no syntax differentiating filenames from directories, +assumes that the last file is a path unless $no_file is true or a +trailing separator or /. or /.. is present. On Unix this means that $no_file +true makes this return ( '', $path, '' ). + +The directory portion may or may not be returned with a trailing '/'. + +The results can be passed to L</catpath()> to get back a path equivalent to +(usually identical to) the original path. + +=item splitdir + +The opposite of L</catdir()>. + + @dirs = File::Spec->splitdir( $directories ); + +$directories must be only the directory portion of the path on systems +that have the concept of a volume or that have path syntax that differentiates +files from directories. + +Unlike just splitting the directories on the separator, empty +directory names (C<''>) can be returned, because these are significant +on some OSs. + +=item catpath() + +Takes volume, directory and file portions and returns an entire path. Under +Unix, $volume is ignored, and directory and file are catenated. A '/' is +inserted if need be. On other OSs, $volume is significant. + + $full_path = File::Spec->catpath( $volume, $directory, $file ); + +=item abs2rel + +Takes a destination path and an optional base path returns a relative path +from the base path to the destination path: + + $rel_path = File::Spec->abs2rel( $path ) ; + $rel_path = File::Spec->abs2rel( $path, $base ) ; + +If $base is not present or '', then L<cwd()|Cwd> is used. If $base is relative, +then it is converted to absolute form using L</rel2abs()>. This means that it +is taken to be relative to L<cwd()|Cwd>. + +On systems with the concept of a volume, this assumes that both paths +are on the $destination volume, and ignores the $base volume. + +On systems that have a grammar that indicates filenames, this ignores the +$base filename as well. Otherwise all path components are assumed to be +directories. + +If $path is relative, it is converted to absolute form using L</rel2abs()>. +This means that it is taken to be relative to L<cwd()|Cwd>. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=item rel2abs() + +Converts a relative path to an absolute path. + + $abs_path = File::Spec->rel2abs( $path ) ; + $abs_path = File::Spec->rel2abs( $path, $base ) ; + +If $base is not present or '', then L<cwd()|Cwd> is used. If $base is relative, +then it is converted to absolute form using L</rel2abs()>. This means that it +is taken to be relative to L<cwd()|Cwd>. + +On systems with the concept of a volume, this assumes that both paths +are on the $base volume, and ignores the $path volume. + +On systems that have a grammar that indicates filenames, this ignores the +$base filename as well. Otherwise all path components are assumed to be +directories. + +If $path is absolute, it is cleaned up and returned using L</canonpath()>. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=back + +For further information, please see L<File::Spec::Unix>, +L<File::Spec::Mac>, L<File::Spec::OS2>, L<File::Spec::Win32>, or +L<File::Spec::VMS>. + +=head1 SEE ALSO + +L<File::Spec::Unix>, L<File::Spec::Mac>, L<File::Spec::OS2>, +L<File::Spec::Win32>, L<File::Spec::VMS>, L<File::Spec::Functions>, +L<ExtUtils::MakeMaker> + +=head1 AUTHORS + +Kenneth Albanowski <kjahds@kjahds.com>, Andy Dougherty +<doughera@lafcol.lafayette.edu>, Andreas KE<ouml>nig +<A.Koenig@franz.ww.TU-Berlin.DE>, Tim Bunce <Tim.Bunce@ig.co.uk. +VMS support by Charles Bailey <bailey@newman.upenn.edu>. +OS/2 support by Ilya Zakharevich <ilya@math.ohio-state.edu>. +Mac support by Paul Schinder <schinder@pobox.com>, and Thomas Wegner +<wegner_thomas@yahoo.com>. abs2rel() and rel2abs() written by Shigio +Yamaguchi <shigio@tamacom.com>, modified by Barrie Slaymaker +<barries@slaysys.com>. splitpath(), splitdir(), catpath() and +catdir() by Barrie Slaymaker. diff --git a/Master/xemtex/perl/lib/File/Spec/Unix.pm b/Master/xemtex/perl/lib/File/Spec/Unix.pm new file mode 100644 index 00000000000..87ee5051022 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Spec/Unix.pm @@ -0,0 +1,482 @@ +package File::Spec::Unix; + +use strict; +our($VERSION); + +$VERSION = '1.4'; + +use Cwd; + +=head1 NAME + +File::Spec::Unix - File::Spec for Unix, base for other File::Spec modules + +=head1 SYNOPSIS + + require File::Spec::Unix; # Done automatically by File::Spec + +=head1 DESCRIPTION + +Methods for manipulating file specifications. Other File::Spec +modules, such as File::Spec::Mac, inherit from File::Spec::Unix and +override specific methods. + +=head1 METHODS + +=over 2 + +=item canonpath() + +No physical check on the filesystem, but a logical cleanup of a +path. On UNIX eliminates successive slashes and successive "/.". + + $cpath = File::Spec->canonpath( $path ) ; + +=cut + +sub canonpath { + my ($self,$path) = @_; + + # Handle POSIX-style node names beginning with double slash (qnx, nto) + # Handle network path names beginning with double slash (cygwin) + # (POSIX says: "a pathname that begins with two successive slashes + # may be interpreted in an implementation-defined manner, although + # more than two leading slashes shall be treated as a single slash.") + my $node = ''; + if ( $^O =~ m/^(?:qnx|nto|cygwin)$/ && $path =~ s:^(//[^/]+)(/|\z):/:s ) { + $node = $1; + } + # This used to be + # $path =~ s|/+|/|g unless($^O eq 'cygwin'); + # but that made tests 29, 30, 35, 46, and 213 (as of #13272) to fail + # (Mainly because trailing "" directories didn't get stripped). + # Why would cygwin avoid collapsing multiple slashes into one? --jhi + $path =~ s|/+|/|g; # xx////xx -> xx/xx + $path =~ s@(/\.)+(/|\Z(?!\n))@/@g; # xx/././xx -> xx/xx + $path =~ s|^(\./)+||s unless $path eq "./"; # ./xx -> xx + $path =~ s|^/(\.\./)+|/|s; # /../../xx -> xx + $path =~ s|/\Z(?!\n)|| unless $path eq "/"; # xx/ -> xx + return "$node$path"; +} + +=item catdir() + +Concatenate two or more directory names to form a complete path ending +with a directory. But remove the trailing slash from the resulting +string, because it doesn't look good, isn't necessary and confuses +OS2. Of course, if this is the root directory, don't cut off the +trailing slash :-) + +=cut + +sub catdir { + my $self = shift; + my @args = @_; + foreach (@args) { + # append a slash to each argument unless it has one there + $_ .= "/" if $_ eq '' || substr($_,-1) ne "/"; + } + return $self->canonpath(join('', @args)); +} + +=item catfile + +Concatenate one or more directory names and a filename to form a +complete path ending with a filename + +=cut + +sub catfile { + my $self = shift; + my $file = pop @_; + return $file unless @_; + my $dir = $self->catdir(@_); + $dir .= "/" unless substr($dir,-1) eq "/"; + return $dir.$file; +} + +=item curdir + +Returns a string representation of the current directory. "." on UNIX. + +=cut + +sub curdir { + return "."; +} + +=item devnull + +Returns a string representation of the null device. "/dev/null" on UNIX. + +=cut + +sub devnull { + return "/dev/null"; +} + +=item rootdir + +Returns a string representation of the root directory. "/" on UNIX. + +=cut + +sub rootdir { + return "/"; +} + +=item tmpdir + +Returns a string representation of the first writable directory +from the following list or "" if none are writable: + + $ENV{TMPDIR} + /tmp + +Since perl 5.8.0, if running under taint mode, and if $ENV{TMPDIR} +is tainted, it is not used. + +=cut + +my $tmpdir; +sub tmpdir { + return $tmpdir if defined $tmpdir; + my @dirlist = ($ENV{TMPDIR}, "/tmp"); + { + no strict 'refs'; + if (${"\cTAINT"}) { # Check for taint mode on perl >= 5.8.0 + require Scalar::Util; + shift @dirlist if Scalar::Util::tainted($ENV{TMPDIR}); + } + } + foreach (@dirlist) { + next unless defined && -d && -w _; + $tmpdir = $_; + last; + } + $tmpdir = '' unless defined $tmpdir; + return $tmpdir; +} + +=item updir + +Returns a string representation of the parent directory. ".." on UNIX. + +=cut + +sub updir { + return ".."; +} + +=item no_upwards + +Given a list of file names, strip out those that refer to a parent +directory. (Does not strip symlinks, only '.', '..', and equivalents.) + +=cut + +sub no_upwards { + my $self = shift; + return grep(!/^\.{1,2}\Z(?!\n)/s, @_); +} + +=item case_tolerant + +Returns a true or false value indicating, respectively, that alphabetic +is not or is significant when comparing file specifications. + +=cut + +sub case_tolerant { + return 0; +} + +=item file_name_is_absolute + +Takes as argument a path and returns true if it is an absolute path. + +This does not consult the local filesystem on Unix, Win32, OS/2 or Mac +OS (Classic). It does consult the working environment for VMS (see +L<File::Spec::VMS/file_name_is_absolute>). + +=cut + +sub file_name_is_absolute { + my ($self,$file) = @_; + return scalar($file =~ m:^/:s); +} + +=item path + +Takes no argument, returns the environment variable PATH as an array. + +=cut + +sub path { + my @path = split(':', $ENV{PATH}); + foreach (@path) { $_ = '.' if $_ eq '' } + return @path; +} + +=item join + +join is the same as catfile. + +=cut + +sub join { + my $self = shift; + return $self->catfile(@_); +} + +=item splitpath + + ($volume,$directories,$file) = File::Spec->splitpath( $path ); + ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file ); + +Splits a path in to volume, directory, and filename portions. On systems +with no concept of volume, returns undef for volume. + +For systems with no syntax differentiating filenames from directories, +assumes that the last file is a path unless $no_file is true or a +trailing separator or /. or /.. is present. On Unix this means that $no_file +true makes this return ( '', $path, '' ). + +The directory portion may or may not be returned with a trailing '/'. + +The results can be passed to L</catpath()> to get back a path equivalent to +(usually identical to) the original path. + +=cut + +sub splitpath { + my ($self,$path, $nofile) = @_; + + my ($volume,$directory,$file) = ('','',''); + + if ( $nofile ) { + $directory = $path; + } + else { + $path =~ m|^ ( (?: .* / (?: \.\.?\Z(?!\n) )? )? ) ([^/]*) |xs; + $directory = $1; + $file = $2; + } + + return ($volume,$directory,$file); +} + + +=item splitdir + +The opposite of L</catdir()>. + + @dirs = File::Spec->splitdir( $directories ); + +$directories must be only the directory portion of the path on systems +that have the concept of a volume or that have path syntax that differentiates +files from directories. + +Unlike just splitting the directories on the separator, empty +directory names (C<''>) can be returned, because these are significant +on some OSs. + +On Unix, + + File::Spec->splitdir( "/a/b//c/" ); + +Yields: + + ( '', 'a', 'b', '', 'c', '' ) + +=cut + +sub splitdir { + my ($self,$directories) = @_ ; + # + # split() likes to forget about trailing null fields, so here we + # check to be sure that there will not be any before handling the + # simple case. + # + if ( $directories !~ m|/\Z(?!\n)| ) { + return split( m|/|, $directories ); + } + else { + # + # since there was a trailing separator, add a file name to the end, + # then do the split, then replace it with ''. + # + my( @directories )= split( m|/|, "${directories}dummy" ) ; + $directories[ $#directories ]= '' ; + return @directories ; + } +} + + +=item catpath() + +Takes volume, directory and file portions and returns an entire path. Under +Unix, $volume is ignored, and directory and file are catenated. A '/' is +inserted if needed (though if the directory portion doesn't start with +'/' it is not added). On other OSs, $volume is significant. + +=cut + +sub catpath { + my ($self,$volume,$directory,$file) = @_; + + if ( $directory ne '' && + $file ne '' && + substr( $directory, -1 ) ne '/' && + substr( $file, 0, 1 ) ne '/' + ) { + $directory .= "/$file" ; + } + else { + $directory .= $file ; + } + + return $directory ; +} + +=item abs2rel + +Takes a destination path and an optional base path returns a relative path +from the base path to the destination path: + + $rel_path = File::Spec->abs2rel( $path ) ; + $rel_path = File::Spec->abs2rel( $path, $base ) ; + +If $base is not present or '', then L<cwd()|Cwd> is used. If $base is relative, +then it is converted to absolute form using L</rel2abs()>. This means that it +is taken to be relative to L<cwd()|Cwd>. + +On systems with the concept of a volume, this assumes that both paths +are on the $destination volume, and ignores the $base volume. + +On systems that have a grammar that indicates filenames, this ignores the +$base filename as well. Otherwise all path components are assumed to be +directories. + +If $path is relative, it is converted to absolute form using L</rel2abs()>. +This means that it is taken to be relative to L<cwd()|Cwd>. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=cut + +sub abs2rel { + my($self,$path,$base) = @_; + + # Clean up $path + if ( ! $self->file_name_is_absolute( $path ) ) { + $path = $self->rel2abs( $path ) ; + } + else { + $path = $self->canonpath( $path ) ; + } + + # Figure out the effective $base and clean it up. + if ( !defined( $base ) || $base eq '' ) { + $base = cwd() ; + } + elsif ( ! $self->file_name_is_absolute( $base ) ) { + $base = $self->rel2abs( $base ) ; + } + else { + $base = $self->canonpath( $base ) ; + } + + # Now, remove all leading components that are the same + my @pathchunks = $self->splitdir( $path); + my @basechunks = $self->splitdir( $base); + + while (@pathchunks && @basechunks && $pathchunks[0] eq $basechunks[0]) { + shift @pathchunks ; + shift @basechunks ; + } + + $path = CORE::join( '/', @pathchunks ); + $base = CORE::join( '/', @basechunks ); + + # $base now contains the directories the resulting relative path + # must ascend out of before it can descend to $path_directory. So, + # replace all names with $parentDir + $base =~ s|[^/]+|..|g ; + + # Glue the two together, using a separator if necessary, and preventing an + # empty result. + if ( $path ne '' && $base ne '' ) { + $path = "$base/$path" ; + } else { + $path = "$base$path" ; + } + + return $self->canonpath( $path ) ; +} + +=item rel2abs() + +Converts a relative path to an absolute path. + + $abs_path = File::Spec->rel2abs( $path ) ; + $abs_path = File::Spec->rel2abs( $path, $base ) ; + +If $base is not present or '', then L<cwd()|Cwd> is used. If $base is relative, +then it is converted to absolute form using L</rel2abs()>. This means that it +is taken to be relative to L<cwd()|Cwd>. + +On systems with the concept of a volume, this assumes that both paths +are on the $base volume, and ignores the $path volume. + +On systems that have a grammar that indicates filenames, this ignores the +$base filename as well. Otherwise all path components are assumed to be +directories. + +If $path is absolute, it is cleaned up and returned using L</canonpath()>. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=cut + +sub rel2abs { + my ($self,$path,$base ) = @_; + + # Clean up $path + if ( ! $self->file_name_is_absolute( $path ) ) { + # Figure out the effective $base and clean it up. + if ( !defined( $base ) || $base eq '' ) { + $base = cwd() ; + } + elsif ( ! $self->file_name_is_absolute( $base ) ) { + $base = $self->rel2abs( $base ) ; + } + else { + $base = $self->canonpath( $base ) ; + } + + # Glom them together + $path = $self->catdir( $base, $path ) ; + } + + return $self->canonpath( $path ) ; +} + + +=back + +=head1 SEE ALSO + +L<File::Spec> + +=cut + +1; diff --git a/Master/xemtex/perl/lib/File/Spec/Win32.pm b/Master/xemtex/perl/lib/File/Spec/Win32.pm new file mode 100644 index 00000000000..186052bb4d8 --- /dev/null +++ b/Master/xemtex/perl/lib/File/Spec/Win32.pm @@ -0,0 +1,370 @@ +package File::Spec::Win32; + +use strict; +use Cwd; +use vars qw(@ISA $VERSION); +require File::Spec::Unix; + +$VERSION = '1.3'; + +@ISA = qw(File::Spec::Unix); + +=head1 NAME + +File::Spec::Win32 - methods for Win32 file specs + +=head1 SYNOPSIS + + require File::Spec::Win32; # Done internally by File::Spec if needed + +=head1 DESCRIPTION + +See File::Spec::Unix for a documentation of the methods provided +there. This package overrides the implementation of these methods, not +the semantics. + +=over 4 + +=item devnull + +Returns a string representation of the null device. + +=cut + +sub devnull { + return "nul"; +} + +=item tmpdir + +Returns a string representation of the first existing directory +from the following list: + + $ENV{TMPDIR} + $ENV{TEMP} + $ENV{TMP} + SYS:/temp + C:/temp + /tmp + / + +The SYS:/temp is preferred in Novell NetWare. + +Since Perl 5.8.0, if running under taint mode, and if the environment +variables are tainted, they are not used. + +=cut + +my $tmpdir; +sub tmpdir { + return $tmpdir if defined $tmpdir; + my $self = shift; + my @dirlist = (@ENV{qw(TMPDIR TEMP TMP)}, qw(C:/temp /tmp /)); + { + no strict 'refs'; + if (${"\cTAINT"}) { # Check for taint mode on perl >= 5.8.0 + require Scalar::Util; + @dirlist = grep { ! Scalar::Util::tainted $_ } @dirlist; + } + } + foreach (@dirlist) { + next unless defined && -d; + $tmpdir = $_; + last; + } + $tmpdir = '' unless defined $tmpdir; + $tmpdir = $self->canonpath($tmpdir); + return $tmpdir; +} + +sub case_tolerant { + return 1; +} + +sub file_name_is_absolute { + my ($self,$file) = @_; + return scalar($file =~ m{^([a-z]:)?[\\/]}is); +} + +=item catfile + +Concatenate one or more directory names and a filename to form a +complete path ending with a filename + +=cut + +sub catfile { + my $self = shift; + my $file = pop @_; + return $file unless @_; + my $dir = $self->catdir(@_); + $dir .= "\\" unless substr($dir,-1) eq "\\"; + return $dir.$file; +} + +sub path { + my $path = $ENV{'PATH'} || $ENV{'Path'} || $ENV{'path'}; + my @path = split(';',$path); + foreach (@path) { $_ = '.' if $_ eq '' } + return @path; +} + +=item canonpath + +No physical check on the filesystem, but a logical cleanup of a +path. On UNIX eliminated successive slashes and successive "/.". + +=cut + +sub canonpath { + my ($self,$path) = @_; + $path =~ s/^([a-z]:)/\u$1/s; + $path =~ s|/|\\|g; + $path =~ s|([^\\])\\+|$1\\|g; # xx\\\\xx -> xx\xx + $path =~ s|(\\\.)+\\|\\|g; # xx\.\.\xx -> xx\xx + $path =~ s|^(\.\\)+||s unless $path eq ".\\"; # .\xx -> xx + $path =~ s|\\\Z(?!\n)|| + unless $path =~ m#^([A-Z]:)?\\\Z(?!\n)#s; # xx\ -> xx + return $path; +} + +=item splitpath + + ($volume,$directories,$file) = File::Spec->splitpath( $path ); + ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file ); + +Splits a path in to volume, directory, and filename portions. Assumes that +the last file is a path unless the path ends in '\\', '\\.', '\\..' +or $no_file is true. On Win32 this means that $no_file true makes this return +( $volume, $path, undef ). + +Separators accepted are \ and /. + +Volumes can be drive letters or UNC sharenames (\\server\share). + +The results can be passed to L</catpath> to get back a path equivalent to +(usually identical to) the original path. + +=cut + +sub splitpath { + my ($self,$path, $nofile) = @_; + my ($volume,$directory,$file) = ('','',''); + if ( $nofile ) { + $path =~ + m{^( (?:[a-zA-Z]:|(?:\\\\|//)[^\\/]+[\\/][^\\/]+)? ) + (.*) + }xs; + $volume = $1; + $directory = $2; + } + else { + $path =~ + m{^ ( (?: [a-zA-Z]: | + (?:\\\\|//)[^\\/]+[\\/][^\\/]+ + )? + ) + ( (?:.*[\\\\/](?:\.\.?\Z(?!\n))?)? ) + (.*) + }xs; + $volume = $1; + $directory = $2; + $file = $3; + } + + return ($volume,$directory,$file); +} + + +=item splitdir + +The opposite of L<catdir()|File::Spec/catdir()>. + + @dirs = File::Spec->splitdir( $directories ); + +$directories must be only the directory portion of the path on systems +that have the concept of a volume or that have path syntax that differentiates +files from directories. + +Unlike just splitting the directories on the separator, leading empty and +trailing directory entries can be returned, because these are significant +on some OSs. So, + + File::Spec->splitdir( "/a/b/c" ); + +Yields: + + ( '', 'a', 'b', '', 'c', '' ) + +=cut + +sub splitdir { + my ($self,$directories) = @_ ; + # + # split() likes to forget about trailing null fields, so here we + # check to be sure that there will not be any before handling the + # simple case. + # + if ( $directories !~ m|[\\/]\Z(?!\n)| ) { + return split( m|[\\/]|, $directories ); + } + else { + # + # since there was a trailing separator, add a file name to the end, + # then do the split, then replace it with ''. + # + my( @directories )= split( m|[\\/]|, "${directories}dummy" ) ; + $directories[ $#directories ]= '' ; + return @directories ; + } +} + + +=item catpath + +Takes volume, directory and file portions and returns an entire path. Under +Unix, $volume is ignored, and this is just like catfile(). On other OSs, +the $volume become significant. + +=cut + +sub catpath { + my ($self,$volume,$directory,$file) = @_; + + # If it's UNC, make sure the glue separator is there, reusing + # whatever separator is first in the $volume + $volume .= $1 + if ( $volume =~ m@^([\\/])[\\/][^\\/]+[\\/][^\\/]+\Z(?!\n)@s && + $directory =~ m@^[^\\/]@s + ) ; + + $volume .= $directory ; + + # If the volume is not just A:, make sure the glue separator is + # there, reusing whatever separator is first in the $volume if possible. + if ( $volume !~ m@^[a-zA-Z]:\Z(?!\n)@s && + $volume =~ m@[^\\/]\Z(?!\n)@ && + $file =~ m@[^\\/]@ + ) { + $volume =~ m@([\\/])@ ; + my $sep = $1 ? $1 : '\\' ; + $volume .= $sep ; + } + + $volume .= $file ; + + return $volume ; +} + + +sub abs2rel { + my($self,$path,$base) = @_; + + # Clean up $path + if ( ! $self->file_name_is_absolute( $path ) ) { + $path = $self->rel2abs( $path ) ; + } + else { + $path = $self->canonpath( $path ) ; + } + + # Figure out the effective $base and clean it up. + if ( !defined( $base ) || $base eq '' ) { + $base = cwd() ; + } + elsif ( ! $self->file_name_is_absolute( $base ) ) { + $base = $self->rel2abs( $base ) ; + } + else { + $base = $self->canonpath( $base ) ; + } + + # Split up paths + my ( undef, $path_directories, $path_file ) = + $self->splitpath( $path, 1 ) ; + + my $base_directories = ($self->splitpath( $base, 1 ))[1] ; + + # Now, remove all leading components that are the same + my @pathchunks = $self->splitdir( $path_directories ); + my @basechunks = $self->splitdir( $base_directories ); + + while ( @pathchunks && + @basechunks && + lc( $pathchunks[0] ) eq lc( $basechunks[0] ) + ) { + shift @pathchunks ; + shift @basechunks ; + } + + # No need to catdir, we know these are well formed. + $path_directories = CORE::join( '\\', @pathchunks ); + $base_directories = CORE::join( '\\', @basechunks ); + + # $base_directories now contains the directories the resulting relative + # path must ascend out of before it can descend to $path_directory. So, + # replace all names with $parentDir + + #FA Need to replace between backslashes... + $base_directories =~ s|[^\\]+|..|g ; + + # Glue the two together, using a separator if necessary, and preventing an + # empty result. + + #FA Must check that new directories are not empty. + if ( $path_directories ne '' && $base_directories ne '' ) { + $path_directories = "$base_directories\\$path_directories" ; + } else { + $path_directories = "$base_directories$path_directories" ; + } + + return $self->canonpath( + $self->catpath( "", $path_directories, $path_file ) + ) ; +} + + +sub rel2abs { + my ($self,$path,$base ) = @_; + + if ( ! $self->file_name_is_absolute( $path ) ) { + + if ( !defined( $base ) || $base eq '' ) { + $base = cwd() ; + } + elsif ( ! $self->file_name_is_absolute( $base ) ) { + $base = $self->rel2abs( $base ) ; + } + else { + $base = $self->canonpath( $base ) ; + } + + my ( $path_directories, $path_file ) = + ($self->splitpath( $path, 1 ))[1,2] ; + + my ( $base_volume, $base_directories ) = + $self->splitpath( $base, 1 ) ; + + $path = $self->catpath( + $base_volume, + $self->catdir( $base_directories, $path_directories ), + $path_file + ) ; + } + + return $self->canonpath( $path ) ; +} + +=back + +=head2 Note For File::Spec::Win32 Maintainers + +Novell NetWare inherits its File::Spec behaviour from File::Spec::Win32. + +=head1 SEE ALSO + +L<File::Spec> + +=cut + +1; diff --git a/Master/xemtex/perl/lib/File/Temp.pm b/Master/xemtex/perl/lib/File/Temp.pm new file mode 100644 index 00000000000..6f351dfa6ce --- /dev/null +++ b/Master/xemtex/perl/lib/File/Temp.pm @@ -0,0 +1,1876 @@ +package File::Temp; + +=head1 NAME + +File::Temp - return name and handle of a temporary file safely + +=begin __INTERNALS + +=head1 PORTABILITY + +This module is designed to be portable across operating systems +and it currently supports Unix, VMS, DOS, OS/2, Windows and +Mac OS (Classic). When +porting to a new OS there are generally three main issues +that have to be solved: + +=over 4 + +=item * + +Can the OS unlink an open file? If it can not then the +C<_can_unlink_opened_file> method should be modified. + +=item * + +Are the return values from C<stat> reliable? By default all the +return values from C<stat> are compared when unlinking a temporary +file using the filename and the handle. Operating systems other than +unix do not always have valid entries in all fields. If C<unlink0> fails +then the C<stat> comparison should be modified accordingly. + +=item * + +Security. Systems that can not support a test for the sticky bit +on a directory can not use the MEDIUM and HIGH security tests. +The C<_can_do_level> method should be modified accordingly. + +=back + +=end __INTERNALS + +=head1 SYNOPSIS + + use File::Temp qw/ tempfile tempdir /; + + $dir = tempdir( CLEANUP => 1 ); + ($fh, $filename) = tempfile( DIR => $dir ); + + ($fh, $filename) = tempfile( $template, DIR => $dir); + ($fh, $filename) = tempfile( $template, SUFFIX => '.dat'); + + $fh = tempfile(); + +MkTemp family: + + use File::Temp qw/ :mktemp /; + + ($fh, $file) = mkstemp( "tmpfileXXXXX" ); + ($fh, $file) = mkstemps( "tmpfileXXXXXX", $suffix); + + $tmpdir = mkdtemp( $template ); + + $unopened_file = mktemp( $template ); + +POSIX functions: + + use File::Temp qw/ :POSIX /; + + $file = tmpnam(); + $fh = tmpfile(); + + ($fh, $file) = tmpnam(); + ($fh, $file) = tmpfile(); + + +Compatibility functions: + + $unopened_file = File::Temp::tempnam( $dir, $pfx ); + +=begin later + +Objects (NOT YET IMPLEMENTED): + + require File::Temp; + + $fh = new File::Temp($template); + $fname = $fh->filename; + +=end later + +=head1 DESCRIPTION + +C<File::Temp> can be used to create and open temporary files in a safe way. +The tempfile() function can be used to return the name and the open +filehandle of a temporary file. The tempdir() function can +be used to create a temporary directory. + +The security aspect of temporary file creation is emphasized such that +a filehandle and filename are returned together. This helps guarantee +that a race condition can not occur where the temporary file is +created by another process between checking for the existence of the +file and its opening. Additional security levels are provided to +check, for example, that the sticky bit is set on world writable +directories. See L<"safe_level"> for more information. + +For compatibility with popular C library functions, Perl implementations of +the mkstemp() family of functions are provided. These are, mkstemp(), +mkstemps(), mkdtemp() and mktemp(). + +Additionally, implementations of the standard L<POSIX|POSIX> +tmpnam() and tmpfile() functions are provided if required. + +Implementations of mktemp(), tmpnam(), and tempnam() are provided, +but should be used with caution since they return only a filename +that was valid when function was called, so cannot guarantee +that the file will not exist by the time the caller opens the filename. + +=cut + +# 5.6.0 gives us S_IWOTH, S_IWGRP, our and auto-vivifying filehandls +# People would like a version on 5.005 so give them what they want :-) +use 5.005; +use strict; +use Carp; +use File::Spec 0.8; +use File::Path qw/ rmtree /; +use Fcntl 1.03; +use Errno; +require VMS::Stdio if $^O eq 'VMS'; + +# Need the Symbol package if we are running older perl +require Symbol if $] < 5.006; + + +# use 'our' on v5.6.0 +use vars qw($VERSION @EXPORT_OK %EXPORT_TAGS $DEBUG); + +$DEBUG = 0; + +# We are exporting functions + +use base qw/Exporter/; + +# Export list - to allow fine tuning of export table + +@EXPORT_OK = qw{ + tempfile + tempdir + tmpnam + tmpfile + mktemp + mkstemp + mkstemps + mkdtemp + unlink0 + }; + +# Groups of functions for export + +%EXPORT_TAGS = ( + 'POSIX' => [qw/ tmpnam tmpfile /], + 'mktemp' => [qw/ mktemp mkstemp mkstemps mkdtemp/], + ); + +# add contents of these tags to @EXPORT +Exporter::export_tags('POSIX','mktemp'); + +# Version number + +$VERSION = '0.13'; + +# This is a list of characters that can be used in random filenames + +my @CHARS = (qw/ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z + a b c d e f g h i j k l m n o p q r s t u v w x y z + 0 1 2 3 4 5 6 7 8 9 _ + /); + +# Maximum number of tries to make a temp file before failing + +use constant MAX_TRIES => 10; + +# Minimum number of X characters that should be in a template +use constant MINX => 4; + +# Default template when no template supplied + +use constant TEMPXXX => 'X' x 10; + +# Constants for the security level + +use constant STANDARD => 0; +use constant MEDIUM => 1; +use constant HIGH => 2; + +# OPENFLAGS. If we defined the flag to use with Sysopen here this gives +# us an optimisation when many temporary files are requested + +my $OPENFLAGS = O_CREAT | O_EXCL | O_RDWR; + +unless ($^O eq 'MacOS') { + for my $oflag (qw/ FOLLOW BINARY LARGEFILE EXLOCK NOINHERIT /) { + my ($bit, $func) = (0, "Fcntl::O_" . $oflag); + no strict 'refs'; + $OPENFLAGS |= $bit if eval { + # Make sure that redefined die handlers do not cause problems + # eg CGI::Carp + local $SIG{__DIE__} = sub {}; + local $SIG{__WARN__} = sub {}; + $bit = &$func(); + 1; + }; + } +} + +# On some systems the O_TEMPORARY flag can be used to tell the OS +# to automatically remove the file when it is closed. This is fine +# in most cases but not if tempfile is called with UNLINK=>0 and +# the filename is requested -- in the case where the filename is to +# be passed to another routine. This happens on windows. We overcome +# this by using a second open flags variable + +my $OPENTEMPFLAGS = $OPENFLAGS; +unless ($^O eq 'MacOS') { + for my $oflag (qw/ TEMPORARY /) { + my ($bit, $func) = (0, "Fcntl::O_" . $oflag); + no strict 'refs'; + $OPENTEMPFLAGS |= $bit if eval { + # Make sure that redefined die handlers do not cause problems + # eg CGI::Carp + local $SIG{__DIE__} = sub {}; + local $SIG{__WARN__} = sub {}; + $bit = &$func(); + 1; + }; + } +} + +# INTERNAL ROUTINES - not to be used outside of package + +# Generic routine for getting a temporary filename +# modelled on OpenBSD _gettemp() in mktemp.c + +# The template must contain X's that are to be replaced +# with the random values + +# Arguments: + +# TEMPLATE - string containing the XXXXX's that is converted +# to a random filename and opened if required + +# Optionally, a hash can also be supplied containing specific options +# "open" => if true open the temp file, else just return the name +# default is 0 +# "mkdir"=> if true, we are creating a temp directory rather than tempfile +# default is 0 +# "suffixlen" => number of characters at end of PATH to be ignored. +# default is 0. +# "unlink_on_close" => indicates that, if possible, the OS should remove +# the file as soon as it is closed. Usually indicates +# use of the O_TEMPORARY flag to sysopen. +# Usually irrelevant on unix + +# Optionally a reference to a scalar can be passed into the function +# On error this will be used to store the reason for the error +# "ErrStr" => \$errstr + +# "open" and "mkdir" can not both be true +# "unlink_on_close" is not used when "mkdir" is true. + +# The default options are equivalent to mktemp(). + +# Returns: +# filehandle - open file handle (if called with doopen=1, else undef) +# temp name - name of the temp file or directory + +# For example: +# ($fh, $name) = _gettemp($template, "open" => 1); + +# for the current version, failures are associated with +# stored in an error string and returned to give the reason whilst debugging +# This routine is not called by any external function +sub _gettemp { + + croak 'Usage: ($fh, $name) = _gettemp($template, OPTIONS);' + unless scalar(@_) >= 1; + + # the internal error string - expect it to be overridden + # Need this in case the caller decides not to supply us a value + # need an anonymous scalar + my $tempErrStr; + + # Default options + my %options = ( + "open" => 0, + "mkdir" => 0, + "suffixlen" => 0, + "unlink_on_close" => 0, + "ErrStr" => \$tempErrStr, + ); + + # Read the template + my $template = shift; + if (ref($template)) { + # Use a warning here since we have not yet merged ErrStr + carp "File::Temp::_gettemp: template must not be a reference"; + return (); + } + + # Check that the number of entries on stack are even + if (scalar(@_) % 2 != 0) { + # Use a warning here since we have not yet merged ErrStr + carp "File::Temp::_gettemp: Must have even number of options"; + return (); + } + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # Make sure the error string is set to undef + ${$options{ErrStr}} = undef; + + # Can not open the file and make a directory in a single call + if ($options{"open"} && $options{"mkdir"}) { + ${$options{ErrStr}} = "doopen and domkdir can not both be true\n"; + return (); + } + + # Find the start of the end of the Xs (position of last X) + # Substr starts from 0 + my $start = length($template) - 1 - $options{"suffixlen"}; + + # Check that we have at least MINX x X (eg 'XXXX") at the end of the string + # (taking suffixlen into account). Any fewer is insecure. + + # Do it using substr - no reason to use a pattern match since + # we know where we are looking and what we are looking for + + if (substr($template, $start - MINX + 1, MINX) ne 'X' x MINX) { + ${$options{ErrStr}} = "The template must contain at least ". + MINX . " 'X' characters\n"; + return (); + } + + # Replace all the X at the end of the substring with a + # random character or just all the XX at the end of a full string. + # Do it as an if, since the suffix adjusts which section to replace + # and suffixlen=0 returns nothing if used in the substr directly + # and generate a full path from the template + + my $path = _replace_XX($template, $options{"suffixlen"}); + + + # Split the path into constituent parts - eventually we need to check + # whether the directory exists + # We need to know whether we are making a temp directory + # or a tempfile + + my ($volume, $directories, $file); + my $parent; # parent directory + if ($options{"mkdir"}) { + # There is no filename at the end + ($volume, $directories, $file) = File::Spec->splitpath( $path, 1); + + # The parent is then $directories without the last directory + # Split the directory and put it back together again + my @dirs = File::Spec->splitdir($directories); + + # If @dirs only has one entry (i.e. the directory template) that means + # we are in the current directory + if ($#dirs == 0) { + $parent = File::Spec->curdir; + } else { + + if ($^O eq 'VMS') { # need volume to avoid relative dir spec + $parent = File::Spec->catdir($volume, @dirs[0..$#dirs-1]); + $parent = 'sys$disk:[]' if $parent eq ''; + } else { + + # Put it back together without the last one + $parent = File::Spec->catdir(@dirs[0..$#dirs-1]); + + # ...and attach the volume (no filename) + $parent = File::Spec->catpath($volume, $parent, ''); + } + + } + + } else { + + # Get rid of the last filename (use File::Basename for this?) + ($volume, $directories, $file) = File::Spec->splitpath( $path ); + + # Join up without the file part + $parent = File::Spec->catpath($volume,$directories,''); + + # If $parent is empty replace with curdir + $parent = File::Spec->curdir + unless $directories ne ''; + + } + + # Check that the parent directories exist + # Do this even for the case where we are simply returning a name + # not a file -- no point returning a name that includes a directory + # that does not exist or is not writable + + unless (-d $parent) { + ${$options{ErrStr}} = "Parent directory ($parent) is not a directory"; + return (); + } + unless (-w _) { + ${$options{ErrStr}} = "Parent directory ($parent) is not writable\n"; + return (); + } + + + # Check the stickiness of the directory and chown giveaway if required + # If the directory is world writable the sticky bit + # must be set + + if (File::Temp->safe_level == MEDIUM) { + my $safeerr; + unless (_is_safe($parent,\$safeerr)) { + ${$options{ErrStr}} = "Parent directory ($parent) is not safe ($safeerr)"; + return (); + } + } elsif (File::Temp->safe_level == HIGH) { + my $safeerr; + unless (_is_verysafe($parent, \$safeerr)) { + ${$options{ErrStr}} = "Parent directory ($parent) is not safe ($safeerr)"; + return (); + } + } + + + # Now try MAX_TRIES time to open the file + for (my $i = 0; $i < MAX_TRIES; $i++) { + + # Try to open the file if requested + if ($options{"open"}) { + my $fh; + + # If we are running before perl5.6.0 we can not auto-vivify + if ($] < 5.006) { + $fh = &Symbol::gensym; + } + + # Try to make sure this will be marked close-on-exec + # XXX: Win32 doesn't respect this, nor the proper fcntl, + # but may have O_NOINHERIT. This may or may not be in Fcntl. + local $^F = 2; + + # Store callers umask + my $umask = umask(); + + # Set a known umask + umask(066); + + # Attempt to open the file + my $open_success = undef; + if ( $^O eq 'VMS' and $options{"unlink_on_close"} ) { + # make it auto delete on close by setting FAB$V_DLT bit + $fh = VMS::Stdio::vmssysopen($path, $OPENFLAGS, 0600, 'fop=dlt'); + $open_success = $fh; + } else { + my $flags = ( $options{"unlink_on_close"} ? + $OPENTEMPFLAGS : + $OPENFLAGS ); + $open_success = sysopen($fh, $path, $flags, 0600); + } + if ( $open_success ) { + + # Reset umask + umask($umask) if defined $umask; + + # Opened successfully - return file handle and name + return ($fh, $path); + + } else { + # Reset umask + umask($umask) if defined $umask; + + # Error opening file - abort with error + # if the reason was anything but EEXIST + unless ($!{EEXIST}) { + ${$options{ErrStr}} = "Could not create temp file $path: $!"; + return (); + } + + # Loop round for another try + + } + } elsif ($options{"mkdir"}) { + + # Store callers umask + my $umask = umask(); + + # Set a known umask + umask(066); + + # Open the temp directory + if (mkdir( $path, 0700)) { + # created okay + # Reset umask + umask($umask) if defined $umask; + + return undef, $path; + } else { + + # Reset umask + umask($umask) if defined $umask; + + # Abort with error if the reason for failure was anything + # except EEXIST + unless ($!{EEXIST}) { + ${$options{ErrStr}} = "Could not create directory $path: $!"; + return (); + } + + # Loop round for another try + + } + + } else { + + # Return true if the file can not be found + # Directory has been checked previously + + return (undef, $path) unless -e $path; + + # Try again until MAX_TRIES + + } + + # Did not successfully open the tempfile/dir + # so try again with a different set of random letters + # No point in trying to increment unless we have only + # 1 X say and the randomness could come up with the same + # file MAX_TRIES in a row. + + # Store current attempt - in principal this implies that the + # 3rd time around the open attempt that the first temp file + # name could be generated again. Probably should store each + # attempt and make sure that none are repeated + + my $original = $path; + my $counter = 0; # Stop infinite loop + my $MAX_GUESS = 50; + + do { + + # Generate new name from original template + $path = _replace_XX($template, $options{"suffixlen"}); + + $counter++; + + } until ($path ne $original || $counter > $MAX_GUESS); + + # Check for out of control looping + if ($counter > $MAX_GUESS) { + ${$options{ErrStr}} = "Tried to get a new temp name different to the previous value $MAX_GUESS times.\nSomething wrong with template?? ($template)"; + return (); + } + + } + + # If we get here, we have run out of tries + ${ $options{ErrStr} } = "Have exceeded the maximum number of attempts (" + . MAX_TRIES . ") to open temp file/dir"; + + return (); + +} + +# Internal routine to return a random character from the +# character list. Does not do an srand() since rand() +# will do one automatically + +# No arguments. Return value is the random character + +# No longer called since _replace_XX runs a few percent faster if +# I inline the code. This is important if we are creating thousands of +# temporary files. + +sub _randchar { + + $CHARS[ int( rand( $#CHARS ) ) ]; + +} + +# Internal routine to replace the XXXX... with random characters +# This has to be done by _gettemp() every time it fails to +# open a temp file/dir + +# Arguments: $template (the template with XXX), +# $ignore (number of characters at end to ignore) + +# Returns: modified template + +sub _replace_XX { + + croak 'Usage: _replace_XX($template, $ignore)' + unless scalar(@_) == 2; + + my ($path, $ignore) = @_; + + # Do it as an if, since the suffix adjusts which section to replace + # and suffixlen=0 returns nothing if used in the substr directly + # Alternatively, could simply set $ignore to length($path)-1 + # Don't want to always use substr when not required though. + + if ($ignore) { + substr($path, 0, - $ignore) =~ s/X(?=X*\z)/$CHARS[ int( rand( $#CHARS ) ) ]/ge; + } else { + $path =~ s/X(?=X*\z)/$CHARS[ int( rand( $#CHARS ) ) ]/ge; + } + + return $path; +} + +# internal routine to check to see if the directory is safe +# First checks to see if the directory is not owned by the +# current user or root. Then checks to see if anyone else +# can write to the directory and if so, checks to see if +# it has the sticky bit set + +# Will not work on systems that do not support sticky bit + +#Args: directory path to check +# Optionally: reference to scalar to contain error message +# Returns true if the path is safe and false otherwise. +# Returns undef if can not even run stat() on the path + +# This routine based on version written by Tom Christiansen + +# Presumably, by the time we actually attempt to create the +# file or directory in this directory, it may not be safe +# anymore... Have to run _is_safe directly after the open. + +sub _is_safe { + + my $path = shift; + my $err_ref = shift; + + # Stat path + my @info = stat($path); + unless (scalar(@info)) { + $$err_ref = "stat(path) returned no values"; + return 0; + }; + return 1 if $^O eq 'VMS'; # owner delete control at file level + + # Check to see whether owner is neither superuser (or a system uid) nor me + # Use the real uid from the $< variable + # UID is in [4] + if ($info[4] > File::Temp->top_system_uid() && $info[4] != $<) { + + Carp::cluck(sprintf "uid=$info[4] topuid=%s \$<=$< path='$path'", + File::Temp->top_system_uid()); + + $$err_ref = "Directory owned neither by root nor the current user" + if ref($err_ref); + return 0; + } + + # check whether group or other can write file + # use 066 to detect either reading or writing + # use 022 to check writability + # Do it with S_IWOTH and S_IWGRP for portability (maybe) + # mode is in info[2] + if (($info[2] & &Fcntl::S_IWGRP) || # Is group writable? + ($info[2] & &Fcntl::S_IWOTH) ) { # Is world writable? + # Must be a directory + unless (-d _) { + $$err_ref = "Path ($path) is not a directory" + if ref($err_ref); + return 0; + } + # Must have sticky bit set + unless (-k _) { + $$err_ref = "Sticky bit not set on $path when dir is group|world writable" + if ref($err_ref); + return 0; + } + } + + return 1; +} + +# Internal routine to check whether a directory is safe +# for temp files. Safer than _is_safe since it checks for +# the possibility of chown giveaway and if that is a possibility +# checks each directory in the path to see if it is safe (with _is_safe) + +# If _PC_CHOWN_RESTRICTED is not set, does the full test of each +# directory anyway. + +# Takes optional second arg as scalar ref to error reason + +sub _is_verysafe { + + # Need POSIX - but only want to bother if really necessary due to overhead + require POSIX; + + my $path = shift; + print "_is_verysafe testing $path\n" if $DEBUG; + return 1 if $^O eq 'VMS'; # owner delete control at file level + + my $err_ref = shift; + + # Should Get the value of _PC_CHOWN_RESTRICTED if it is defined + # and If it is not there do the extensive test + my $chown_restricted; + $chown_restricted = &POSIX::_PC_CHOWN_RESTRICTED() + if eval { &POSIX::_PC_CHOWN_RESTRICTED(); 1}; + + # If chown_resticted is set to some value we should test it + if (defined $chown_restricted) { + + # Return if the current directory is safe + return _is_safe($path,$err_ref) if POSIX::sysconf( $chown_restricted ); + + } + + # To reach this point either, the _PC_CHOWN_RESTRICTED symbol + # was not avialable or the symbol was there but chown giveaway + # is allowed. Either way, we now have to test the entire tree for + # safety. + + # Convert path to an absolute directory if required + unless (File::Spec->file_name_is_absolute($path)) { + $path = File::Spec->rel2abs($path); + } + + # Split directory into components - assume no file + my ($volume, $directories, undef) = File::Spec->splitpath( $path, 1); + + # Slightly less efficient than having a function in File::Spec + # to chop off the end of a directory or even a function that + # can handle ../ in a directory tree + # Sometimes splitdir() returns a blank at the end + # so we will probably check the bottom directory twice in some cases + my @dirs = File::Spec->splitdir($directories); + + # Concatenate one less directory each time around + foreach my $pos (0.. $#dirs) { + # Get a directory name + my $dir = File::Spec->catpath($volume, + File::Spec->catdir(@dirs[0.. $#dirs - $pos]), + '' + ); + + print "TESTING DIR $dir\n" if $DEBUG; + + # Check the directory + return 0 unless _is_safe($dir,$err_ref); + + } + + return 1; +} + + + +# internal routine to determine whether unlink works on this +# platform for files that are currently open. +# Returns true if we can, false otherwise. + +# Currently WinNT, OS/2 and VMS can not unlink an opened file +# On VMS this is because the O_EXCL flag is used to open the +# temporary file. Currently I do not know enough about the issues +# on VMS to decide whether O_EXCL is a requirement. + +sub _can_unlink_opened_file { + + if ($^O eq 'MSWin32' || $^O eq 'os2' || $^O eq 'VMS' || $^O eq 'dos' || $^O eq 'MacOS') { + return 0; + } else { + return 1; + } + +} + +# internal routine to decide which security levels are allowed +# see safe_level() for more information on this + +# Controls whether the supplied security level is allowed + +# $cando = _can_do_level( $level ) + +sub _can_do_level { + + # Get security level + my $level = shift; + + # Always have to be able to do STANDARD + return 1 if $level == STANDARD; + + # Currently, the systems that can do HIGH or MEDIUM are identical + if ( $^O eq 'MSWin32' || $^O eq 'os2' || $^O eq 'cygwin' || $^O eq 'dos' || $^O eq 'MacOS') { + return 0; + } else { + return 1; + } + +} + +# This routine sets up a deferred unlinking of a specified +# filename and filehandle. It is used in the following cases: +# - Called by unlink0 if an opened file can not be unlinked +# - Called by tempfile() if files are to be removed on shutdown +# - Called by tempdir() if directories are to be removed on shutdown + +# Arguments: +# _deferred_unlink( $fh, $fname, $isdir ); +# +# - filehandle (so that it can be expclicitly closed if open +# - filename (the thing we want to remove) +# - isdir (flag to indicate that we are being given a directory) +# [and hence no filehandle] + +# Status is not referred to since all the magic is done with an END block + +{ + # Will set up two lexical variables to contain all the files to be + # removed. One array for files, another for directories + # They will only exist in this block + # This means we only have to set up a single END block to remove all files + # @files_to_unlink contains an array ref with the filehandle and filename + my (@files_to_unlink, @dirs_to_unlink); + + # Set up an end block to use these arrays + END { + # Files + foreach my $file (@files_to_unlink) { + # close the filehandle without checking its state + # in order to make real sure that this is closed + # if its already closed then I dont care about the answer + # probably a better way to do this + close($file->[0]); # file handle is [0] + + if (-f $file->[1]) { # file name is [1] + unlink $file->[1] or warn "Error removing ".$file->[1]; + } + } + # Dirs + foreach my $dir (@dirs_to_unlink) { + if (-d $dir) { + rmtree($dir, $DEBUG, 1); + } + } + + } + + # This is the sub called to register a file for deferred unlinking + # This could simply store the input parameters and defer everything + # until the END block. For now we do a bit of checking at this + # point in order to make sure that (1) we have a file/dir to delete + # and (2) we have been called with the correct arguments. + sub _deferred_unlink { + + croak 'Usage: _deferred_unlink($fh, $fname, $isdir)' + unless scalar(@_) == 3; + + my ($fh, $fname, $isdir) = @_; + + warn "Setting up deferred removal of $fname\n" + if $DEBUG; + + # If we have a directory, check that it is a directory + if ($isdir) { + + if (-d $fname) { + + # Directory exists so store it + # first on VMS turn []foo into [.foo] for rmtree + $fname = VMS::Filespec::vmspath($fname) if $^O eq 'VMS'; + push (@dirs_to_unlink, $fname); + + } else { + carp "Request to remove directory $fname could not be completed since it does not exist!\n" if $^W; + } + + } else { + + if (-f $fname) { + + # file exists so store handle and name for later removal + push(@files_to_unlink, [$fh, $fname]); + + } else { + carp "Request to remove file $fname could not be completed since it is not there!\n" if $^W; + } + + } + + } + + +} + +=head1 FUNCTIONS + +This section describes the recommended interface for generating +temporary files and directories. + +=over 4 + +=item B<tempfile> + +This is the basic function to generate temporary files. +The behaviour of the file can be changed using various options: + + ($fh, $filename) = tempfile(); + +Create a temporary file in the directory specified for temporary +files, as specified by the tmpdir() function in L<File::Spec>. + + ($fh, $filename) = tempfile($template); + +Create a temporary file in the current directory using the supplied +template. Trailing `X' characters are replaced with random letters to +generate the filename. At least four `X' characters must be present +in the template. + + ($fh, $filename) = tempfile($template, SUFFIX => $suffix) + +Same as previously, except that a suffix is added to the template +after the `X' translation. Useful for ensuring that a temporary +filename has a particular extension when needed by other applications. +But see the WARNING at the end. + + ($fh, $filename) = tempfile($template, DIR => $dir); + +Translates the template as before except that a directory name +is specified. + + ($fh, $filename) = tempfile($template, UNLINK => 1); + +Return the filename and filehandle as before except that the file is +automatically removed when the program exits. Default is for the file +to be removed if a file handle is requested and to be kept if the +filename is requested. In a scalar context (where no filename is +returned) the file is always deleted either on exit or when it is closed. + +If the template is not specified, a template is always +automatically generated. This temporary file is placed in tmpdir() +(L<File::Spec>) unless a directory is specified explicitly with the +DIR option. + + $fh = tempfile( $template, DIR => $dir ); + +If called in scalar context, only the filehandle is returned +and the file will automatically be deleted when closed (see +the description of tmpfile() elsewhere in this document). +This is the preferred mode of operation, as if you only +have a filehandle, you can never create a race condition +by fumbling with the filename. On systems that can not unlink +an open file or can not mark a file as temporary when it is opened +(for example, Windows NT uses the C<O_TEMPORARY> flag)) +the file is marked for deletion when the program ends (equivalent +to setting UNLINK to 1). The C<UNLINK> flag is ignored if present. + + (undef, $filename) = tempfile($template, OPEN => 0); + +This will return the filename based on the template but +will not open this file. Cannot be used in conjunction with +UNLINK set to true. Default is to always open the file +to protect from possible race conditions. A warning is issued +if warnings are turned on. Consider using the tmpnam() +and mktemp() functions described elsewhere in this document +if opening the file is not required. + +Options can be combined as required. + +=cut + +sub tempfile { + + # Can not check for argument count since we can have any + # number of args + + # Default options + my %options = ( + "DIR" => undef, # Directory prefix + "SUFFIX" => '', # Template suffix + "UNLINK" => 0, # Do not unlink file on exit + "OPEN" => 1, # Open file + ); + + # Check to see whether we have an odd or even number of arguments + my $template = (scalar(@_) % 2 == 1 ? shift(@_) : undef); + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # First decision is whether or not to open the file + if (! $options{"OPEN"}) { + + warn "tempfile(): temporary filename requested but not opened.\nPossibly unsafe, consider using tempfile() with OPEN set to true\n" + if $^W; + + } + + if ($options{"DIR"} and $^O eq 'VMS') { + + # on VMS turn []foo into [.foo] for concatenation + $options{"DIR"} = VMS::Filespec::vmspath($options{"DIR"}); + } + + # Construct the template + + # Have a choice of trying to work around the mkstemp/mktemp/tmpnam etc + # functions or simply constructing a template and using _gettemp() + # explicitly. Go for the latter + + # First generate a template if not defined and prefix the directory + # If no template must prefix the temp directory + if (defined $template) { + if ($options{"DIR"}) { + + $template = File::Spec->catfile($options{"DIR"}, $template); + + } + + } else { + + if ($options{"DIR"}) { + + $template = File::Spec->catfile($options{"DIR"}, TEMPXXX); + + } else { + + $template = File::Spec->catfile(File::Spec->tmpdir, TEMPXXX); + + } + + } + + # Now add a suffix + $template .= $options{"SUFFIX"}; + + # Determine whether we should tell _gettemp to unlink the file + # On unix this is irrelevant and can be worked out after the file is + # opened (simply by unlinking the open filehandle). On Windows or VMS + # we have to indicate temporary-ness when we open the file. In general + # we only want a true temporary file if we are returning just the + # filehandle - if the user wants the filename they probably do not + # want the file to disappear as soon as they close it. + # For this reason, tie unlink_on_close to the return context regardless + # of OS. + my $unlink_on_close = ( wantarray ? 0 : 1); + + # Create the file + my ($fh, $path, $errstr); + croak "Error in tempfile() using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => $options{'OPEN'}, + "mkdir"=> 0 , + "unlink_on_close" => $unlink_on_close, + "suffixlen" => length($options{'SUFFIX'}), + "ErrStr" => \$errstr, + ) ); + + # Set up an exit handler that can do whatever is right for the + # system. This removes files at exit when requested explicitly or when + # system is asked to unlink_on_close but is unable to do so because + # of OS limitations. + # The latter should be achieved by using a tied filehandle. + # Do not check return status since this is all done with END blocks. + _deferred_unlink($fh, $path, 0) if $options{"UNLINK"}; + + # Return + if (wantarray()) { + + if ($options{'OPEN'}) { + return ($fh, $path); + } else { + return (undef, $path); + } + + } else { + + # Unlink the file. It is up to unlink0 to decide what to do with + # this (whether to unlink now or to defer until later) + unlink0($fh, $path) or croak "Error unlinking file $path using unlink0"; + + # Return just the filehandle. + return $fh; + } + + +} + +=item B<tempdir> + +This is the recommended interface for creation of temporary directories. +The behaviour of the function depends on the arguments: + + $tempdir = tempdir(); + +Create a directory in tmpdir() (see L<File::Spec|File::Spec>). + + $tempdir = tempdir( $template ); + +Create a directory from the supplied template. This template is +similar to that described for tempfile(). `X' characters at the end +of the template are replaced with random letters to construct the +directory name. At least four `X' characters must be in the template. + + $tempdir = tempdir ( DIR => $dir ); + +Specifies the directory to use for the temporary directory. +The temporary directory name is derived from an internal template. + + $tempdir = tempdir ( $template, DIR => $dir ); + +Prepend the supplied directory name to the template. The template +should not include parent directory specifications itself. Any parent +directory specifications are removed from the template before +prepending the supplied directory. + + $tempdir = tempdir ( $template, TMPDIR => 1 ); + +Using the supplied template, create the temporary directory in +a standard location for temporary files. Equivalent to doing + + $tempdir = tempdir ( $template, DIR => File::Spec->tmpdir); + +but shorter. Parent directory specifications are stripped from the +template itself. The C<TMPDIR> option is ignored if C<DIR> is set +explicitly. Additionally, C<TMPDIR> is implied if neither a template +nor a directory are supplied. + + $tempdir = tempdir( $template, CLEANUP => 1); + +Create a temporary directory using the supplied template, but +attempt to remove it (and all files inside it) when the program +exits. Note that an attempt will be made to remove all files from +the directory even if they were not created by this module (otherwise +why ask to clean it up?). The directory removal is made with +the rmtree() function from the L<File::Path|File::Path> module. +Of course, if the template is not specified, the temporary directory +will be created in tmpdir() and will also be removed at program exit. + +=cut + +# ' + +sub tempdir { + + # Can not check for argument count since we can have any + # number of args + + # Default options + my %options = ( + "CLEANUP" => 0, # Remove directory on exit + "DIR" => '', # Root directory + "TMPDIR" => 0, # Use tempdir with template + ); + + # Check to see whether we have an odd or even number of arguments + my $template = (scalar(@_) % 2 == 1 ? shift(@_) : undef ); + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # Modify or generate the template + + # Deal with the DIR and TMPDIR options + if (defined $template) { + + # Need to strip directory path if using DIR or TMPDIR + if ($options{'TMPDIR'} || $options{'DIR'}) { + + # Strip parent directory from the filename + # + # There is no filename at the end + $template = VMS::Filespec::vmspath($template) if $^O eq 'VMS'; + my ($volume, $directories, undef) = File::Spec->splitpath( $template, 1); + + # Last directory is then our template + $template = (File::Spec->splitdir($directories))[-1]; + + # Prepend the supplied directory or temp dir + if ($options{"DIR"}) { + + $template = File::Spec->catdir($options{"DIR"}, $template); + + } elsif ($options{TMPDIR}) { + + # Prepend tmpdir + $template = File::Spec->catdir(File::Spec->tmpdir, $template); + + } + + } + + } else { + + if ($options{"DIR"}) { + + $template = File::Spec->catdir($options{"DIR"}, TEMPXXX); + + } else { + + $template = File::Spec->catdir(File::Spec->tmpdir, TEMPXXX); + + } + + } + + # Create the directory + my $tempdir; + my $suffixlen = 0; + if ($^O eq 'VMS') { # dir names can end in delimiters + $template =~ m/([\.\]:>]+)$/; + $suffixlen = length($1); + } + if ( ($^O eq 'MacOS') && (substr($template, -1) eq ':') ) { + # dir name has a trailing ':' + ++$suffixlen; + } + + my $errstr; + croak "Error in tempdir() using $template: $errstr" + unless ((undef, $tempdir) = _gettemp($template, + "open" => 0, + "mkdir"=> 1 , + "suffixlen" => $suffixlen, + "ErrStr" => \$errstr, + ) ); + + # Install exit handler; must be dynamic to get lexical + if ( $options{'CLEANUP'} && -d $tempdir) { + _deferred_unlink(undef, $tempdir, 1); + } + + # Return the dir name + return $tempdir; + +} + +=back + +=head1 MKTEMP FUNCTIONS + +The following functions are Perl implementations of the +mktemp() family of temp file generation system calls. + +=over 4 + +=item B<mkstemp> + +Given a template, returns a filehandle to the temporary file and the name +of the file. + + ($fh, $name) = mkstemp( $template ); + +In scalar context, just the filehandle is returned. + +The template may be any filename with some number of X's appended +to it, for example F</tmp/temp.XXXX>. The trailing X's are replaced +with unique alphanumeric combinations. + +=cut + + + +sub mkstemp { + + croak "Usage: mkstemp(template)" + if scalar(@_) != 1; + + my $template = shift; + + my ($fh, $path, $errstr); + croak "Error in mkstemp using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => 1, + "mkdir"=> 0 , + "suffixlen" => 0, + "ErrStr" => \$errstr, + ) ); + + if (wantarray()) { + return ($fh, $path); + } else { + return $fh; + } + +} + + +=item B<mkstemps> + +Similar to mkstemp(), except that an extra argument can be supplied +with a suffix to be appended to the template. + + ($fh, $name) = mkstemps( $template, $suffix ); + +For example a template of C<testXXXXXX> and suffix of C<.dat> +would generate a file similar to F<testhGji_w.dat>. + +Returns just the filehandle alone when called in scalar context. + +=cut + +sub mkstemps { + + croak "Usage: mkstemps(template, suffix)" + if scalar(@_) != 2; + + + my $template = shift; + my $suffix = shift; + + $template .= $suffix; + + my ($fh, $path, $errstr); + croak "Error in mkstemps using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => 1, + "mkdir"=> 0 , + "suffixlen" => length($suffix), + "ErrStr" => \$errstr, + ) ); + + if (wantarray()) { + return ($fh, $path); + } else { + return $fh; + } + +} + +=item B<mkdtemp> + +Create a directory from a template. The template must end in +X's that are replaced by the routine. + + $tmpdir_name = mkdtemp($template); + +Returns the name of the temporary directory created. +Returns undef on failure. + +Directory must be removed by the caller. + +=cut + +#' # for emacs + +sub mkdtemp { + + croak "Usage: mkdtemp(template)" + if scalar(@_) != 1; + + my $template = shift; + my $suffixlen = 0; + if ($^O eq 'VMS') { # dir names can end in delimiters + $template =~ m/([\.\]:>]+)$/; + $suffixlen = length($1); + } + if ( ($^O eq 'MacOS') && (substr($template, -1) eq ':') ) { + # dir name has a trailing ':' + ++$suffixlen; + } + my ($junk, $tmpdir, $errstr); + croak "Error creating temp directory from template $template\: $errstr" + unless (($junk, $tmpdir) = _gettemp($template, + "open" => 0, + "mkdir"=> 1 , + "suffixlen" => $suffixlen, + "ErrStr" => \$errstr, + ) ); + + return $tmpdir; + +} + +=item B<mktemp> + +Returns a valid temporary filename but does not guarantee +that the file will not be opened by someone else. + + $unopened_file = mktemp($template); + +Template is the same as that required by mkstemp(). + +=cut + +sub mktemp { + + croak "Usage: mktemp(template)" + if scalar(@_) != 1; + + my $template = shift; + + my ($tmpname, $junk, $errstr); + croak "Error getting name to temp file from template $template: $errstr" + unless (($junk, $tmpname) = _gettemp($template, + "open" => 0, + "mkdir"=> 0 , + "suffixlen" => 0, + "ErrStr" => \$errstr, + ) ); + + return $tmpname; +} + +=back + +=head1 POSIX FUNCTIONS + +This section describes the re-implementation of the tmpnam() +and tmpfile() functions described in L<POSIX> +using the mkstemp() from this module. + +Unlike the L<POSIX|POSIX> implementations, the directory used +for the temporary file is not specified in a system include +file (C<P_tmpdir>) but simply depends on the choice of tmpdir() +returned by L<File::Spec|File::Spec>. On some implementations this +location can be set using the C<TMPDIR> environment variable, which +may not be secure. +If this is a problem, simply use mkstemp() and specify a template. + +=over 4 + +=item B<tmpnam> + +When called in scalar context, returns the full name (including path) +of a temporary file (uses mktemp()). The only check is that the file does +not already exist, but there is no guarantee that that condition will +continue to apply. + + $file = tmpnam(); + +When called in list context, a filehandle to the open file and +a filename are returned. This is achieved by calling mkstemp() +after constructing a suitable template. + + ($fh, $file) = tmpnam(); + +If possible, this form should be used to prevent possible +race conditions. + +See L<File::Spec/tmpdir> for information on the choice of temporary +directory for a particular operating system. + +=cut + +sub tmpnam { + + # Retrieve the temporary directory name + my $tmpdir = File::Spec->tmpdir; + + croak "Error temporary directory is not writable" + if $tmpdir eq ''; + + # Use a ten character template and append to tmpdir + my $template = File::Spec->catfile($tmpdir, TEMPXXX); + + if (wantarray() ) { + return mkstemp($template); + } else { + return mktemp($template); + } + +} + +=item B<tmpfile> + +In scalar context, returns the filehandle of a temporary file. + + $fh = tmpfile(); + +The file is removed when the filehandle is closed or when the program +exits. No access to the filename is provided. + +If the temporary file can not be created undef is returned. +Currently this command will probably not work when the temporary +directory is on an NFS file system. + +=cut + +sub tmpfile { + + # Simply call tmpnam() in a list context + my ($fh, $file) = tmpnam(); + + # Make sure file is removed when filehandle is closed + # This will fail on NFS + unlink0($fh, $file) + or return undef; + + return $fh; + +} + +=back + +=head1 ADDITIONAL FUNCTIONS + +These functions are provided for backwards compatibility +with common tempfile generation C library functions. + +They are not exported and must be addressed using the full package +name. + +=over 4 + +=item B<tempnam> + +Return the name of a temporary file in the specified directory +using a prefix. The file is guaranteed not to exist at the time +the function was called, but such guarantees are good for one +clock tick only. Always use the proper form of C<sysopen> +with C<O_CREAT | O_EXCL> if you must open such a filename. + + $filename = File::Temp::tempnam( $dir, $prefix ); + +Equivalent to running mktemp() with $dir/$prefixXXXXXXXX +(using unix file convention as an example) + +Because this function uses mktemp(), it can suffer from race conditions. + +=cut + +sub tempnam { + + croak 'Usage tempnam($dir, $prefix)' unless scalar(@_) == 2; + + my ($dir, $prefix) = @_; + + # Add a string to the prefix + $prefix .= 'XXXXXXXX'; + + # Concatenate the directory to the file + my $template = File::Spec->catfile($dir, $prefix); + + return mktemp($template); + +} + +=back + +=head1 UTILITY FUNCTIONS + +Useful functions for dealing with the filehandle and filename. + +=over 4 + +=item B<unlink0> + +Given an open filehandle and the associated filename, make a safe +unlink. This is achieved by first checking that the filename and +filehandle initially point to the same file and that the number of +links to the file is 1 (all fields returned by stat() are compared). +Then the filename is unlinked and the filehandle checked once again to +verify that the number of links on that file is now 0. This is the +closest you can come to making sure that the filename unlinked was the +same as the file whose descriptor you hold. + + unlink0($fh, $path) or die "Error unlinking file $path safely"; + +Returns false on error. The filehandle is not closed since on some +occasions this is not required. + +On some platforms, for example Windows NT, it is not possible to +unlink an open file (the file must be closed first). On those +platforms, the actual unlinking is deferred until the program ends and +good status is returned. A check is still performed to make sure that +the filehandle and filename are pointing to the same thing (but not at +the time the end block is executed since the deferred removal may not +have access to the filehandle). + +Additionally, on Windows NT not all the fields returned by stat() can +be compared. For example, the C<dev> and C<rdev> fields seem to be +different. Also, it seems that the size of the file returned by stat() +does not always agree, with C<stat(FH)> being more accurate than +C<stat(filename)>, presumably because of caching issues even when +using autoflush (this is usually overcome by waiting a while after +writing to the tempfile before attempting to C<unlink0> it). + +Finally, on NFS file systems the link count of the file handle does +not always go to zero immediately after unlinking. Currently, this +command is expected to fail on NFS disks. + +=cut + +sub unlink0 { + + croak 'Usage: unlink0(filehandle, filename)' + unless scalar(@_) == 2; + + # Read args + my ($fh, $path) = @_; + + warn "Unlinking $path using unlink0\n" + if $DEBUG; + + # Stat the filehandle + my @fh = stat $fh; + + if ($fh[3] > 1 && $^W) { + carp "unlink0: fstat found too many links; SB=@fh" if $^W; + } + + # Stat the path + my @path = stat $path; + + unless (@path) { + carp "unlink0: $path is gone already" if $^W; + return; + } + + # this is no longer a file, but may be a directory, or worse + unless (-f _) { + confess "panic: $path is no longer a file: SB=@fh"; + } + + # Do comparison of each member of the array + # On WinNT dev and rdev seem to be different + # depending on whether it is a file or a handle. + # Cannot simply compare all members of the stat return + # Select the ones we can use + my @okstat = (0..$#fh); # Use all by default + if ($^O eq 'MSWin32') { + @okstat = (1,2,3,4,5,7,8,9,10); + } elsif ($^O eq 'os2') { + @okstat = (0, 2..$#fh); + } elsif ($^O eq 'VMS') { # device and file ID are sufficient + @okstat = (0, 1); + } elsif ($^O eq 'dos') { + @okstat = (0,2..7,11..$#fh); + } + + # Now compare each entry explicitly by number + for (@okstat) { + print "Comparing: $_ : $fh[$_] and $path[$_]\n" if $DEBUG; + # Use eq rather than == since rdev, blksize, and blocks (6, 11, + # and 12) will be '' on platforms that do not support them. This + # is fine since we are only comparing integers. + unless ($fh[$_] eq $path[$_]) { + warn "Did not match $_ element of stat\n" if $DEBUG; + return 0; + } + } + + # attempt remove the file (does not work on some platforms) + if (_can_unlink_opened_file()) { + # XXX: do *not* call this on a directory; possible race + # resulting in recursive removal + croak "unlink0: $path has become a directory!" if -d $path; + unlink($path) or return 0; + + # Stat the filehandle + @fh = stat $fh; + + print "Link count = $fh[3] \n" if $DEBUG; + + # Make sure that the link count is zero + # - Cygwin provides deferred unlinking, however, + # on Win9x the link count remains 1 + # On NFS the link count may still be 1 but we cant know that + # we are on NFS + return ( $fh[3] == 0 or $^O eq 'cygwin' ? 1 : 0); + + } else { + _deferred_unlink($fh, $path, 0); + return 1; + } + +} + +=back + +=head1 PACKAGE VARIABLES + +These functions control the global state of the package. + +=over 4 + +=item B<safe_level> + +Controls the lengths to which the module will go to check the safety of the +temporary file or directory before proceeding. +Options are: + +=over 8 + +=item STANDARD + +Do the basic security measures to ensure the directory exists and +is writable, that the umask() is fixed before opening of the file, +that temporary files are opened only if they do not already exist, and +that possible race conditions are avoided. Finally the L<unlink0|"unlink0"> +function is used to remove files safely. + +=item MEDIUM + +In addition to the STANDARD security, the output directory is checked +to make sure that it is owned either by root or the user running the +program. If the directory is writable by group or by other, it is then +checked to make sure that the sticky bit is set. + +Will not work on platforms that do not support the C<-k> test +for sticky bit. + +=item HIGH + +In addition to the MEDIUM security checks, also check for the +possibility of ``chown() giveaway'' using the L<POSIX|POSIX> +sysconf() function. If this is a possibility, each directory in the +path is checked in turn for safeness, recursively walking back to the +root directory. + +For platforms that do not support the L<POSIX|POSIX> +C<_PC_CHOWN_RESTRICTED> symbol (for example, Windows NT) it is +assumed that ``chown() giveaway'' is possible and the recursive test +is performed. + +=back + +The level can be changed as follows: + + File::Temp->safe_level( File::Temp::HIGH ); + +The level constants are not exported by the module. + +Currently, you must be running at least perl v5.6.0 in order to +run with MEDIUM or HIGH security. This is simply because the +safety tests use functions from L<Fcntl|Fcntl> that are not +available in older versions of perl. The problem is that the version +number for Fcntl is the same in perl 5.6.0 and in 5.005_03 even though +they are different versions. + +On systems that do not support the HIGH or MEDIUM safety levels +(for example Win NT or OS/2) any attempt to change the level will +be ignored. The decision to ignore rather than raise an exception +allows portable programs to be written with high security in mind +for the systems that can support this without those programs failing +on systems where the extra tests are irrelevant. + +If you really need to see whether the change has been accepted +simply examine the return value of C<safe_level>. + + $newlevel = File::Temp->safe_level( File::Temp::HIGH ); + die "Could not change to high security" + if $newlevel != File::Temp::HIGH; + +=cut + +{ + # protect from using the variable itself + my $LEVEL = STANDARD; + sub safe_level { + my $self = shift; + if (@_) { + my $level = shift; + if (($level != STANDARD) && ($level != MEDIUM) && ($level != HIGH)) { + carp "safe_level: Specified level ($level) not STANDARD, MEDIUM or HIGH - ignoring\n" if $^W; + } else { + # Dont allow this on perl 5.005 or earlier + if ($] < 5.006 && $level != STANDARD) { + # Cant do MEDIUM or HIGH checks + croak "Currently requires perl 5.006 or newer to do the safe checks"; + } + # Check that we are allowed to change level + # Silently ignore if we can not. + $LEVEL = $level if _can_do_level($level); + } + } + return $LEVEL; + } +} + +=item TopSystemUID + +This is the highest UID on the current system that refers to a root +UID. This is used to make sure that the temporary directory is +owned by a system UID (C<root>, C<bin>, C<sys> etc) rather than +simply by root. + +This is required since on many unix systems C</tmp> is not owned +by root. + +Default is to assume that any UID less than or equal to 10 is a root +UID. + + File::Temp->top_system_uid(10); + my $topid = File::Temp->top_system_uid; + +This value can be adjusted to reduce security checking if required. +The value is only relevant when C<safe_level> is set to MEDIUM or higher. + +=back + +=cut + +{ + my $TopSystemUID = 10; + sub top_system_uid { + my $self = shift; + if (@_) { + my $newuid = shift; + croak "top_system_uid: UIDs should be numeric" + unless $newuid =~ /^\d+$/s; + $TopSystemUID = $newuid; + } + return $TopSystemUID; + } +} + +=head1 WARNING + +For maximum security, endeavour always to avoid ever looking at, +touching, or even imputing the existence of the filename. You do not +know that that filename is connected to the same file as the handle +you have, and attempts to check this can only trigger more race +conditions. It's far more secure to use the filehandle alone and +dispense with the filename altogether. + +If you need to pass the handle to something that expects a filename +then, on a unix system, use C<"/dev/fd/" . fileno($fh)> for arbitrary +programs, or more generally C<< "+<=&" . fileno($fh) >> for Perl +programs. You will have to clear the close-on-exec bit on that file +descriptor before passing it to another process. + + use Fcntl qw/F_SETFD F_GETFD/; + fcntl($tmpfh, F_SETFD, 0) + or die "Can't clear close-on-exec flag on temp fh: $!\n"; + +=head2 Temporary files and NFS + +Some problems are associated with using temporary files that reside +on NFS file systems and it is recommended that a local filesystem +is used whenever possible. Some of the security tests will most probably +fail when the temp file is not local. Additionally, be aware that +the performance of I/O operations over NFS will not be as good as for +a local disk. + +=head1 HISTORY + +Originally began life in May 1999 as an XS interface to the system +mkstemp() function. In March 2000, the OpenBSD mkstemp() code was +translated to Perl for total control of the code's +security checking, to ensure the presence of the function regardless of +operating system and to help with portability. + +=head1 SEE ALSO + +L<POSIX/tmpnam>, L<POSIX/tmpfile>, L<File::Spec>, L<File::Path> + +See L<IO::File> and L<File::MkTemp> for different implementations of +temporary file handling. + +=head1 AUTHOR + +Tim Jenness E<lt>t.jenness@jach.hawaii.eduE<gt> + +Copyright (C) 1999-2001 Tim Jenness and the UK Particle Physics and +Astronomy Research Council. All Rights Reserved. This program is free +software; you can redistribute it and/or modify it under the same +terms as Perl itself. + +Original Perl implementation loosely based on the OpenBSD C code for +mkstemp(). Thanks to Tom Christiansen for suggesting that this module +should be written and providing ideas for code improvements and +security enhancements. + +=cut + + +1; diff --git a/Master/xemtex/perl/lib/FindBin.pm b/Master/xemtex/perl/lib/FindBin.pm new file mode 100644 index 00000000000..8be9cb6b5af --- /dev/null +++ b/Master/xemtex/perl/lib/FindBin.pm @@ -0,0 +1,183 @@ +# FindBin.pm +# +# Copyright (c) 1995 Graham Barr & Nick Ing-Simmons. All rights reserved. +# This program is free software; you can redistribute it and/or modify it +# under the same terms as Perl itself. + +=head1 NAME + +FindBin - Locate directory of original perl script + +=head1 SYNOPSIS + + use FindBin; + use lib "$FindBin::Bin/../lib"; + + or + + use FindBin qw($Bin); + use lib "$Bin/../lib"; + +=head1 DESCRIPTION + +Locates the full path to the script bin directory to allow the use +of paths relative to the bin directory. + +This allows a user to setup a directory tree for some software with +directories E<lt>rootE<gt>/bin and E<lt>rootE<gt>/lib and then the above example will allow +the use of modules in the lib directory without knowing where the software +tree is installed. + +If perl is invoked using the B<-e> option or the perl script is read from +C<STDIN> then FindBin sets both C<$Bin> and C<$RealBin> to the current +directory. + +=head1 EXPORTABLE VARIABLES + + $Bin - path to bin directory from where script was invoked + $Script - basename of script from which perl was invoked + $RealBin - $Bin with all links resolved + $RealScript - $Script with all links resolved + +=head1 KNOWN ISSUES + +If there are two modules using C<FindBin> from different directories +under the same interpreter, this won't work. Since C<FindBin> uses +C<BEGIN> block, it'll be executed only once, and only the first caller +will get it right. This is a problem under mod_perl and other persistent +Perl environments, where you shouldn't use this module. Which also means +that you should avoid using C<FindBin> in modules that you plan to put +on CPAN. The only way to make sure that C<FindBin> will work is to force +the C<BEGIN> block to be executed again: + + delete $INC{'FindBin.pm'}; + require FindBin; + +=head1 KNOWN BUGS + +If perl is invoked as + + perl filename + +and I<filename> does not have executable rights and a program called I<filename> +exists in the users C<$ENV{PATH}> which satisfies both B<-x> and B<-T> then FindBin +assumes that it was invoked via the C<$ENV{PATH}>. + +Workaround is to invoke perl as + + perl ./filename + +=head1 AUTHORS + +FindBin is supported as part of the core perl distribution. Please send bug +reports to E<lt>F<perlbug@perl.org>E<gt> using the perlbug program included with perl. + +Graham Barr E<lt>F<gbarr@pobox.com>E<gt> +Nick Ing-Simmons E<lt>F<nik@tiuk.ti.com>E<gt> + +=head1 COPYRIGHT + +Copyright (c) 1995 Graham Barr & Nick Ing-Simmons. All rights reserved. +This program is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +=cut + +package FindBin; +use Carp; +require 5.000; +require Exporter; +use Cwd qw(getcwd abs_path); +use Config; +use File::Basename; +use File::Spec; + +@EXPORT_OK = qw($Bin $Script $RealBin $RealScript $Dir $RealDir); +%EXPORT_TAGS = (ALL => [qw($Bin $Script $RealBin $RealScript $Dir $RealDir)]); +@ISA = qw(Exporter); + +$VERSION = "1.43"; + +BEGIN +{ + *Dir = \$Bin; + *RealDir = \$RealBin; + + if($0 eq '-e' || $0 eq '-') + { + # perl invoked with -e or script is on C<STDIN> + + $Script = $RealScript = $0; + $Bin = $RealBin = getcwd(); + } + else + { + my $script = $0; + + if ($^O eq 'VMS') + { + ($Bin,$Script) = VMS::Filespec::rmsexpand($0) =~ /(.*\])(.*)/s; + ($RealBin,$RealScript) = ($Bin,$Script); + } + else + { + my $dosish = ($^O eq 'MSWin32' or $^O eq 'os2'); + unless(($script =~ m#/# || ($dosish && $script =~ m#\\#)) + && -f $script) + { + my $dir; + foreach $dir (File::Spec->path) + { + my $scr = File::Spec->catfile($dir, $script); + if(-r $scr && (!$dosish || -x _)) + { + $script = $scr; + + if (-f $0) + { + # $script has been found via PATH but perl could have + # been invoked as 'perl file'. Do a dumb check to see + # if $script is a perl program, if not then $script = $0 + # + # well we actually only check that it is an ASCII file + # we know its executable so it is probably a script + # of some sort. + + $script = $0 unless(-T $script); + } + last; + } + } + } + + croak("Cannot find current script '$0'") unless(-f $script); + + # Ensure $script contains the complete path incase we C<chdir> + + $script = File::Spec->catfile(getcwd(), $script) + unless File::Spec->file_name_is_absolute($script); + + ($Script,$Bin) = fileparse($script); + + # Resolve $script if it is a link + while(1) + { + my $linktext = readlink($script); + + ($RealScript,$RealBin) = fileparse($script); + last unless defined $linktext; + + $script = (File::Spec->file_name_is_absolute($linktext)) + ? $linktext + : File::Spec->catfile($RealBin, $linktext); + } + + # Get absolute paths to directories + $Bin = abs_path($Bin) if($Bin); + $RealBin = abs_path($RealBin) if($RealBin); + } + } +} + +1; # Keep require happy + diff --git a/Master/xemtex/perl/lib/Getopt/Long.pm b/Master/xemtex/perl/lib/Getopt/Long.pm new file mode 100644 index 00000000000..7e1663d557a --- /dev/null +++ b/Master/xemtex/perl/lib/Getopt/Long.pm @@ -0,0 +1,2048 @@ +# GetOpt::Long.pm -- Universal options parsing + +package Getopt::Long; + +# RCS Status : $Id: GetoptLong.pm,v 2.58 2002-06-20 09:32:09+02 jv Exp $ +# Author : Johan Vromans +# Created On : Tue Sep 11 15:00:12 1990 +# Last Modified By: Johan Vromans +# Last Modified On: Thu Jun 20 07:48:05 2002 +# Update Count : 1083 +# Status : Released + +################ Copyright ################ + +# This program is Copyright 1990,2002 by Johan Vromans. +# This program is free software; you can redistribute it and/or +# modify it under the terms of the Perl Artistic License or the +# GNU General Public License as published by the Free Software +# Foundation; either version 2 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. +# +# If you do not have a copy of the GNU General Public License write to +# the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, +# MA 02139, USA. + +################ Module Preamble ################ + +use 5.004; + +use strict; + +use vars qw($VERSION); +$VERSION = 2.32; +# For testing versions only. +use vars qw($VERSION_STRING); +$VERSION_STRING = "2.32"; + +use Exporter; + +use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); +@ISA = qw(Exporter); +%EXPORT_TAGS = qw(); +BEGIN { + # Init immediately so their contents can be used in the 'use vars' below. + @EXPORT = qw(&GetOptions $REQUIRE_ORDER $PERMUTE $RETURN_IN_ORDER); + @EXPORT_OK = qw(); +} + +# User visible variables. +use vars @EXPORT, @EXPORT_OK; +use vars qw($error $debug $major_version $minor_version); +# Deprecated visible variables. +use vars qw($autoabbrev $getopt_compat $ignorecase $bundling $order + $passthrough); +# Official invisible variables. +use vars qw($genprefix $caller $gnu_compat); + +# Public subroutines. +sub Configure (@); +sub config (@); # deprecated name +sub GetOptions; + +# Private subroutines. +sub ConfigDefaults (); +sub ParseOptionSpec ($$); +sub OptCtl ($); +sub FindOption ($$$$); + +################ Local Variables ################ + +################ Resident subroutines ################ + +sub ConfigDefaults () { + # Handle POSIX compliancy. + if ( defined $ENV{"POSIXLY_CORRECT"} ) { + $genprefix = "(--|-)"; + $autoabbrev = 0; # no automatic abbrev of options + $bundling = 0; # no bundling of single letter switches + $getopt_compat = 0; # disallow '+' to start options + $order = $REQUIRE_ORDER; + } + else { + $genprefix = "(--|-|\\+)"; + $autoabbrev = 1; # automatic abbrev of options + $bundling = 0; # bundling off by default + $getopt_compat = 1; # allow '+' to start options + $order = $PERMUTE; + } + # Other configurable settings. + $debug = 0; # for debugging + $error = 0; # error tally + $ignorecase = 1; # ignore case when matching options + $passthrough = 0; # leave unrecognized options alone + $gnu_compat = 0; # require --opt=val if value is optional +} + +# Override import. +sub import { + my $pkg = shift; # package + my @syms = (); # symbols to import + my @config = (); # configuration + my $dest = \@syms; # symbols first + for ( @_ ) { + if ( $_ eq ':config' ) { + $dest = \@config; # config next + next; + } + push (@$dest, $_); # push + } + # Hide one level and call super. + local $Exporter::ExportLevel = 1; + $pkg->SUPER::import(@syms); + # And configure. + Configure (@config) if @config; +} + +################ Initialization ################ + +# Values for $order. See GNU getopt.c for details. +($REQUIRE_ORDER, $PERMUTE, $RETURN_IN_ORDER) = (0..2); +# Version major/minor numbers. +($major_version, $minor_version) = $VERSION =~ /^(\d+)\.(\d+)/; + +ConfigDefaults(); + +################ OO Interface ################ + +package Getopt::Long::Parser; + +# Store a copy of the default configuration. Since ConfigDefaults has +# just been called, what we get from Configure is the default. +my $default_config = do { + Getopt::Long::Configure () +}; + +sub new { + my $that = shift; + my $class = ref($that) || $that; + my %atts = @_; + + # Register the callers package. + my $self = { caller_pkg => (caller)[0] }; + + bless ($self, $class); + + # Process config attributes. + if ( defined $atts{config} ) { + my $save = Getopt::Long::Configure ($default_config, @{$atts{config}}); + $self->{settings} = Getopt::Long::Configure ($save); + delete ($atts{config}); + } + # Else use default config. + else { + $self->{settings} = $default_config; + } + + if ( %atts ) { # Oops + die(__PACKAGE__.": unhandled attributes: ". + join(" ", sort(keys(%atts)))."\n"); + } + + $self; +} + +sub configure { + my ($self) = shift; + + # Restore settings, merge new settings in. + my $save = Getopt::Long::Configure ($self->{settings}, @_); + + # Restore orig config and save the new config. + $self->{settings} = Getopt::Long::Configure ($save); +} + +sub getoptions { + my ($self) = shift; + + # Restore config settings. + my $save = Getopt::Long::Configure ($self->{settings}); + + # Call main routine. + my $ret = 0; + $Getopt::Long::caller = $self->{caller_pkg}; + + eval { + # Locally set exception handler to default, otherwise it will + # be called implicitly here, and again explicitly when we try + # to deliver the messages. + local ($SIG{__DIE__}) = '__DEFAULT__'; + $ret = Getopt::Long::GetOptions (@_); + }; + + # Restore saved settings. + Getopt::Long::Configure ($save); + + # Handle errors and return value. + die ($@) if $@; + return $ret; +} + +package Getopt::Long; + +# Indices in option control info. +# Note that ParseOptions uses the fields directly. Search for 'hard-wired'. +use constant CTL_TYPE => 0; +#use constant CTL_TYPE_FLAG => ''; +#use constant CTL_TYPE_NEG => '!'; +#use constant CTL_TYPE_INCR => '+'; +#use constant CTL_TYPE_INT => 'i'; +#use constant CTL_TYPE_INTINC => 'I'; +#use constant CTL_TYPE_XINT => 'o'; +#use constant CTL_TYPE_FLOAT => 'f'; +#use constant CTL_TYPE_STRING => 's'; + +use constant CTL_CNAME => 1; + +use constant CTL_MAND => 2; + +use constant CTL_DEST => 3; + use constant CTL_DEST_SCALAR => 0; + use constant CTL_DEST_ARRAY => 1; + use constant CTL_DEST_HASH => 2; + use constant CTL_DEST_CODE => 3; + +use constant CTL_DEFAULT => 4; + +# FFU. +#use constant CTL_RANGE => ; +#use constant CTL_REPEAT => ; + +sub GetOptions { + + my @optionlist = @_; # local copy of the option descriptions + my $argend = '--'; # option list terminator + my %opctl = (); # table of option specs + my $pkg = $caller || (caller)[0]; # current context + # Needed if linkage is omitted. + my @ret = (); # accum for non-options + my %linkage; # linkage + my $userlinkage; # user supplied HASH + my $opt; # current option + my $prefix = $genprefix; # current prefix + + $error = ''; + + print STDERR ("GetOpt::Long $Getopt::Long::VERSION (", + '$Revision: 2.58 $', ") ", + "called from package \"$pkg\".", + "\n ", + "ARGV: (@ARGV)", + "\n ", + "autoabbrev=$autoabbrev,". + "bundling=$bundling,", + "getopt_compat=$getopt_compat,", + "gnu_compat=$gnu_compat,", + "order=$order,", + "\n ", + "ignorecase=$ignorecase,", + "passthrough=$passthrough,", + "genprefix=\"$genprefix\".", + "\n") + if $debug; + + # Check for ref HASH as first argument. + # First argument may be an object. It's OK to use this as long + # as it is really a hash underneath. + $userlinkage = undef; + if ( @optionlist && ref($optionlist[0]) and + "$optionlist[0]" =~ /^(?:.*\=)?HASH\([^\(]*\)$/ ) { + $userlinkage = shift (@optionlist); + print STDERR ("=> user linkage: $userlinkage\n") if $debug; + } + + # See if the first element of the optionlist contains option + # starter characters. + # Be careful not to interpret '<>' as option starters. + if ( @optionlist && $optionlist[0] =~ /^\W+$/ + && !($optionlist[0] eq '<>' + && @optionlist > 0 + && ref($optionlist[1])) ) { + $prefix = shift (@optionlist); + # Turn into regexp. Needs to be parenthesized! + $prefix =~ s/(\W)/\\$1/g; + $prefix = "([" . $prefix . "])"; + print STDERR ("=> prefix=\"$prefix\"\n") if $debug; + } + + # Verify correctness of optionlist. + %opctl = (); + while ( @optionlist ) { + my $opt = shift (@optionlist); + + # Strip leading prefix so people can specify "--foo=i" if they like. + $opt = $+ if $opt =~ /^$prefix+(.*)$/s; + + if ( $opt eq '<>' ) { + if ( (defined $userlinkage) + && !(@optionlist > 0 && ref($optionlist[0])) + && (exists $userlinkage->{$opt}) + && ref($userlinkage->{$opt}) ) { + unshift (@optionlist, $userlinkage->{$opt}); + } + unless ( @optionlist > 0 + && ref($optionlist[0]) && ref($optionlist[0]) eq 'CODE' ) { + $error .= "Option spec <> requires a reference to a subroutine\n"; + # Kill the linkage (to avoid another error). + shift (@optionlist) + if @optionlist && ref($optionlist[0]); + next; + } + $linkage{'<>'} = shift (@optionlist); + next; + } + + # Parse option spec. + my ($name, $orig) = ParseOptionSpec ($opt, \%opctl); + unless ( defined $name ) { + # Failed. $orig contains the error message. Sorry for the abuse. + $error .= $orig; + # Kill the linkage (to avoid another error). + shift (@optionlist) + if @optionlist && ref($optionlist[0]); + next; + } + + # If no linkage is supplied in the @optionlist, copy it from + # the userlinkage if available. + if ( defined $userlinkage ) { + unless ( @optionlist > 0 && ref($optionlist[0]) ) { + if ( exists $userlinkage->{$orig} && + ref($userlinkage->{$orig}) ) { + print STDERR ("=> found userlinkage for \"$orig\": ", + "$userlinkage->{$orig}\n") + if $debug; + unshift (@optionlist, $userlinkage->{$orig}); + } + else { + # Do nothing. Being undefined will be handled later. + next; + } + } + } + + # Copy the linkage. If omitted, link to global variable. + if ( @optionlist > 0 && ref($optionlist[0]) ) { + print STDERR ("=> link \"$orig\" to $optionlist[0]\n") + if $debug; + my $rl = ref($linkage{$orig} = shift (@optionlist)); + + if ( $rl eq "ARRAY" ) { + $opctl{$name}[CTL_DEST] = CTL_DEST_ARRAY; + } + elsif ( $rl eq "HASH" ) { + $opctl{$name}[CTL_DEST] = CTL_DEST_HASH; + } + elsif ( $rl eq "SCALAR" || $rl eq "CODE" ) { + # Ok. + } + else { + $error .= "Invalid option linkage for \"$opt\"\n"; + } + } + else { + # Link to global $opt_XXX variable. + # Make sure a valid perl identifier results. + my $ov = $orig; + $ov =~ s/\W/_/g; + if ( $opctl{$name}[CTL_DEST] == CTL_DEST_ARRAY ) { + print STDERR ("=> link \"$orig\" to \@$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\@".$pkg."::opt_$ov;"); + } + elsif ( $opctl{$name}[CTL_DEST] == CTL_DEST_HASH ) { + print STDERR ("=> link \"$orig\" to \%$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\%".$pkg."::opt_$ov;"); + } + else { + print STDERR ("=> link \"$orig\" to \$$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\$".$pkg."::opt_$ov;"); + } + } + } + + # Bail out if errors found. + die ($error) if $error; + $error = 0; + + # Show the options tables if debugging. + if ( $debug ) { + my ($arrow, $k, $v); + $arrow = "=> "; + while ( ($k,$v) = each(%opctl) ) { + print STDERR ($arrow, "\$opctl{$k} = $v ", OptCtl($v), "\n"); + $arrow = " "; + } + } + + # Process argument list + my $goon = 1; + while ( $goon && @ARGV > 0 ) { + + # Get next argument. + $opt = shift (@ARGV); + print STDERR ("=> arg \"", $opt, "\"\n") if $debug; + + # Double dash is option list terminator. + last if $opt eq $argend; + + # Look it up. + my $tryopt = $opt; + my $found; # success status + my $key; # key (if hash type) + my $arg; # option argument + my $ctl; # the opctl entry + + ($found, $opt, $ctl, $arg, $key) = + FindOption ($prefix, $argend, $opt, \%opctl); + + if ( $found ) { + + # FindOption undefines $opt in case of errors. + next unless defined $opt; + + if ( defined $arg ) { + + # Get the canonical name. + print STDERR ("=> cname for \"$opt\" is ") if $debug; + $opt = $ctl->[CTL_CNAME]; + print STDERR ("\"$ctl->[CTL_CNAME]\"\n") if $debug; + + if ( defined $linkage{$opt} ) { + print STDERR ("=> ref(\$L{$opt}) -> ", + ref($linkage{$opt}), "\n") if $debug; + + if ( ref($linkage{$opt}) eq 'SCALAR' ) { + if ( $ctl->[CTL_TYPE] eq '+' ) { + print STDERR ("=> \$\$L{$opt} += \"$arg\"\n") + if $debug; + if ( defined ${$linkage{$opt}} ) { + ${$linkage{$opt}} += $arg; + } + else { + ${$linkage{$opt}} = $arg; + } + } + else { + print STDERR ("=> \$\$L{$opt} = \"$arg\"\n") + if $debug; + ${$linkage{$opt}} = $arg; + } + } + elsif ( ref($linkage{$opt}) eq 'ARRAY' ) { + print STDERR ("=> push(\@{\$L{$opt}, \"$arg\")\n") + if $debug; + push (@{$linkage{$opt}}, $arg); + } + elsif ( ref($linkage{$opt}) eq 'HASH' ) { + print STDERR ("=> \$\$L{$opt}->{$key} = \"$arg\"\n") + if $debug; + $linkage{$opt}->{$key} = $arg; + } + elsif ( ref($linkage{$opt}) eq 'CODE' ) { + print STDERR ("=> &L{$opt}(\"$opt\"", + $ctl->[CTL_DEST] == CTL_DEST_HASH ? ", \"$key\"" : "", + ", \"$arg\")\n") + if $debug; + my $eval_error = do { + local $@; + local $SIG{__DIE__} = '__DEFAULT__'; + eval { + &{$linkage{$opt}}($opt, + $ctl->[CTL_DEST] == CTL_DEST_HASH ? ($key) : (), + $arg); + }; + $@; + }; + print STDERR ("=> die($eval_error)\n") + if $debug && $eval_error ne ''; + if ( $eval_error =~ /^!/ ) { + if ( $eval_error =~ /^!FINISH\b/ ) { + $goon = 0; + } + } + elsif ( $eval_error ne '' ) { + warn ($eval_error); + $error++; + } + } + else { + print STDERR ("Invalid REF type \"", ref($linkage{$opt}), + "\" in linkage\n"); + die("Getopt::Long -- internal error!\n"); + } + } + # No entry in linkage means entry in userlinkage. + elsif ( $ctl->[CTL_DEST] == CTL_DEST_ARRAY ) { + if ( defined $userlinkage->{$opt} ) { + print STDERR ("=> push(\@{\$L{$opt}}, \"$arg\")\n") + if $debug; + push (@{$userlinkage->{$opt}}, $arg); + } + else { + print STDERR ("=>\$L{$opt} = [\"$arg\"]\n") + if $debug; + $userlinkage->{$opt} = [$arg]; + } + } + elsif ( $ctl->[CTL_DEST] == CTL_DEST_HASH ) { + if ( defined $userlinkage->{$opt} ) { + print STDERR ("=> \$L{$opt}->{$key} = \"$arg\"\n") + if $debug; + $userlinkage->{$opt}->{$key} = $arg; + } + else { + print STDERR ("=>\$L{$opt} = {$key => \"$arg\"}\n") + if $debug; + $userlinkage->{$opt} = {$key => $arg}; + } + } + else { + if ( $ctl->[CTL_TYPE] eq '+' ) { + print STDERR ("=> \$L{$opt} += \"$arg\"\n") + if $debug; + if ( defined $userlinkage->{$opt} ) { + $userlinkage->{$opt} += $arg; + } + else { + $userlinkage->{$opt} = $arg; + } + } + else { + print STDERR ("=>\$L{$opt} = \"$arg\"\n") if $debug; + $userlinkage->{$opt} = $arg; + } + } + } + } + + # Not an option. Save it if we $PERMUTE and don't have a <>. + elsif ( $order == $PERMUTE ) { + # Try non-options call-back. + my $cb; + if ( (defined ($cb = $linkage{'<>'})) ) { + print STDERR ("=> &L{$tryopt}(\"$tryopt\")\n") + if $debug; + my $eval_error = do { + local $@; + local $SIG{__DIE__} = '__DEFAULT__'; + eval { &$cb ($tryopt) }; + $@; + }; + print STDERR ("=> die($eval_error)\n") + if $debug && $eval_error ne ''; + if ( $eval_error =~ /^!/ ) { + if ( $eval_error =~ /^!FINISH\b/ ) { + $goon = 0; + } + } + elsif ( $eval_error ne '' ) { + warn ($eval_error); + $error++; + } + } + else { + print STDERR ("=> saving \"$tryopt\" ", + "(not an option, may permute)\n") if $debug; + push (@ret, $tryopt); + } + next; + } + + # ...otherwise, terminate. + else { + # Push this one back and exit. + unshift (@ARGV, $tryopt); + return ($error == 0); + } + + } + + # Finish. + if ( @ret && $order == $PERMUTE ) { + # Push back accumulated arguments + print STDERR ("=> restoring \"", join('" "', @ret), "\"\n") + if $debug; + unshift (@ARGV, @ret); + } + + return ($error == 0); +} + +# A readable representation of what's in an optbl. +sub OptCtl ($) { + my ($v) = @_; + my @v = map { defined($_) ? ($_) : ("<undef>") } @$v; + "[". + join(",", + "\"$v[CTL_TYPE]\"", + "\"$v[CTL_CNAME]\"", + $v[CTL_MAND] ? "O" : "M", + ("\$","\@","\%","\&")[$v[CTL_DEST] || 0], + "\"$v[CTL_DEFAULT]\"", +# $v[CTL_RANGE] || '', +# $v[CTL_REPEAT] || '', + ). "]"; +} + +# Parse an option specification and fill the tables. +sub ParseOptionSpec ($$) { + my ($opt, $opctl) = @_; + + # Match option spec. + if ( $opt !~ m;^ + ( + # Option name + (?: \w+[-\w]* ) + # Alias names, or "?" + (?: \| (?: \? | \w[-\w]* )? )* + )? + ( + # Either modifiers ... + [!+] + | + # ... or a value/dest specification + [=:] [ionfs] [@%]? + | + # ... or an optional-with-default spec + : (?: -?\d+ | \+ ) [@%]? + )? + $;x ) { + return (undef, "Error in option spec: \"$opt\"\n"); + } + + my ($names, $spec) = ($1, $2); + $spec = '' unless defined $spec; + + # $orig keeps track of the primary name the user specified. + # This name will be used for the internal or external linkage. + # In other words, if the user specifies "FoO|BaR", it will + # match any case combinations of 'foo' and 'bar', but if a global + # variable needs to be set, it will be $opt_FoO in the exact case + # as specified. + my $orig; + + my @names; + if ( defined $names ) { + @names = split (/\|/, $names); + $orig = $names[0]; + } + else { + @names = (''); + $orig = ''; + } + + # Construct the opctl entries. + my $entry; + if ( $spec eq '' || $spec eq '+' || $spec eq '!' ) { + # Fields are hard-wired here. + $entry = [$spec,$orig,0,CTL_DEST_SCALAR,undef]; + } + elsif ( $spec =~ /:(-?\d+|\+)([@%])?/ ) { + my $def = $1; + my $dest = $2; + my $type = $def eq '+' ? 'I' : 'i'; + $dest ||= '$'; + $dest = $dest eq '@' ? CTL_DEST_ARRAY + : $dest eq '%' ? CTL_DEST_HASH : CTL_DEST_SCALAR; + # Fields are hard-wired here. + $entry = [$type,$orig,0,$dest,$def eq '+' ? undef : $def]; + } + else { + my ($mand, $type, $dest) = $spec =~ /([=:])([ionfs])([@%])?/; + $type = 'i' if $type eq 'n'; + $dest ||= '$'; + $dest = $dest eq '@' ? CTL_DEST_ARRAY + : $dest eq '%' ? CTL_DEST_HASH : CTL_DEST_SCALAR; + # Fields are hard-wired here. + $entry = [$type,$orig,$mand eq '=',$dest,undef]; + } + + # Process all names. First is canonical, the rest are aliases. + my $dups = ''; + foreach ( @names ) { + + $_ = lc ($_) + if $ignorecase > (($bundling && length($_) == 1) ? 1 : 0); + + if ( exists $opctl->{$_} ) { + $dups .= "Duplicate specification \"$opt\" for option \"$_\"\n"; + } + + if ( $spec eq '!' ) { + $opctl->{"no$_"} = $entry; + $opctl->{$_} = [@$entry]; + $opctl->{$_}->[CTL_TYPE] = ''; + } + else { + $opctl->{$_} = $entry; + } + } + + if ( $dups && $^W ) { + foreach ( split(/\n+/, $dups) ) { + warn($_."\n"); + } + } + ($names[0], $orig); +} + +# Option lookup. +sub FindOption ($$$$) { + + # returns (1, $opt, $ctl, $arg, $key) if okay, + # returns (1, undef) if option in error, + # returns (0) otherwise. + + my ($prefix, $argend, $opt, $opctl) = @_; + + print STDERR ("=> find \"$opt\"\n") if $debug; + + return (0) unless $opt =~ /^$prefix(.*)$/s; + return (0) if $opt eq "-" && !defined $opctl->{''}; + + $opt = $+; + my $starter = $1; + + print STDERR ("=> split \"$starter\"+\"$opt\"\n") if $debug; + + my $optarg; # value supplied with --opt=value + my $rest; # remainder from unbundling + + # If it is a long option, it may include the value. + # With getopt_compat, only if not bundling. + if ( ($starter eq "--" + || ($getopt_compat && ($bundling == 0 || $bundling == 2))) + && $opt =~ /^([^=]+)=(.*)$/s ) { + $opt = $1; + $optarg = $2; + print STDERR ("=> option \"", $opt, + "\", optarg = \"$optarg\"\n") if $debug; + } + + #### Look it up ### + + my $tryopt = $opt; # option to try + + if ( $bundling && $starter eq '-' ) { + + # To try overrides, obey case ignore. + $tryopt = $ignorecase ? lc($opt) : $opt; + + # If bundling == 2, long options can override bundles. + if ( $bundling == 2 && length($tryopt) > 1 + && defined ($opctl->{$tryopt}) ) { + print STDERR ("=> $starter$tryopt overrides unbundling\n") + if $debug; + } + else { + $tryopt = $opt; + # Unbundle single letter option. + $rest = length ($tryopt) > 0 ? substr ($tryopt, 1) : ''; + $tryopt = substr ($tryopt, 0, 1); + $tryopt = lc ($tryopt) if $ignorecase > 1; + print STDERR ("=> $starter$tryopt unbundled from ", + "$starter$tryopt$rest\n") if $debug; + $rest = undef unless $rest ne ''; + } + } + + # Try auto-abbreviation. + elsif ( $autoabbrev ) { + # Sort the possible long option names. + my @names = sort(keys (%$opctl)); + # Downcase if allowed. + $opt = lc ($opt) if $ignorecase; + $tryopt = $opt; + # Turn option name into pattern. + my $pat = quotemeta ($opt); + # Look up in option names. + my @hits = grep (/^$pat/, @names); + print STDERR ("=> ", scalar(@hits), " hits (@hits) with \"$pat\" ", + "out of ", scalar(@names), "\n") if $debug; + + # Check for ambiguous results. + unless ( (@hits <= 1) || (grep ($_ eq $opt, @hits) == 1) ) { + # See if all matches are for the same option. + my %hit; + foreach ( @hits ) { + $_ = $opctl->{$_}->[CTL_CNAME] + if defined $opctl->{$_}->[CTL_CNAME]; + $hit{$_} = 1; + } + # Now see if it really is ambiguous. + unless ( keys(%hit) == 1 ) { + return (0) if $passthrough; + warn ("Option ", $opt, " is ambiguous (", + join(", ", @hits), ")\n"); + $error++; + return (1, undef); + } + @hits = keys(%hit); + } + + # Complete the option name, if appropriate. + if ( @hits == 1 && $hits[0] ne $opt ) { + $tryopt = $hits[0]; + $tryopt = lc ($tryopt) if $ignorecase; + print STDERR ("=> option \"$opt\" -> \"$tryopt\"\n") + if $debug; + } + } + + # Map to all lowercase if ignoring case. + elsif ( $ignorecase ) { + $tryopt = lc ($opt); + } + + # Check validity by fetching the info. + my $ctl = $opctl->{$tryopt}; + unless ( defined $ctl ) { + return (0) if $passthrough; + warn ("Unknown option: ", $opt, "\n"); + $error++; + return (1, undef); + } + # Apparently valid. + $opt = $tryopt; + print STDERR ("=> found ", OptCtl($ctl), + " for \"", $opt, "\"\n") if $debug; + + #### Determine argument status #### + + # If it is an option w/o argument, we're almost finished with it. + my $type = $ctl->[CTL_TYPE]; + my $arg; + + if ( $type eq '' || $type eq '!' || $type eq '+' ) { + if ( defined $optarg ) { + return (0) if $passthrough; + warn ("Option ", $opt, " does not take an argument\n"); + $error++; + undef $opt; + } + elsif ( $type eq '' || $type eq '+' ) { + # Supply explicit value. + $arg = 1; + } + else { + $opt =~ s/^no//i; # strip NO prefix + $arg = 0; # supply explicit value + } + unshift (@ARGV, $starter.$rest) if defined $rest; + return (1, $opt, $ctl, $arg); + } + + # Get mandatory status and type info. + my $mand = $ctl->[CTL_MAND]; + + # Check if there is an option argument available. + if ( $gnu_compat && defined $optarg && $optarg eq '' ) { + return (1, $opt, $ctl, $type eq 's' ? '' : 0) unless $mand; + $optarg = 0 unless $type eq 's'; + } + + # Check if there is an option argument available. + if ( defined $optarg + ? ($optarg eq '') + : !(defined $rest || @ARGV > 0) ) { + # Complain if this option needs an argument. + if ( $mand ) { + return (0) if $passthrough; + warn ("Option ", $opt, " requires an argument\n"); + $error++; + return (1, undef); + } + if ( $type eq 'I' ) { + # Fake incremental type. + my @c = @$ctl; + $c[CTL_TYPE] = '+'; + return (1, $opt, \@c, 1); + } + return (1, $opt, $ctl, + defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : + $type eq 's' ? '' : 0); + } + + # Get (possibly optional) argument. + $arg = (defined $rest ? $rest + : (defined $optarg ? $optarg : shift (@ARGV))); + + # Get key if this is a "name=value" pair for a hash option. + my $key; + if ($ctl->[CTL_DEST] == CTL_DEST_HASH && defined $arg) { + ($key, $arg) = ($arg =~ /^([^=]*)=(.*)$/s) ? ($1, $2) + : ($arg, defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : 1); + } + + #### Check if the argument is valid for this option #### + + if ( $type eq 's' ) { # string + # A mandatory string takes anything. + return (1, $opt, $ctl, $arg, $key) if $mand; + + # An optional string takes almost anything. + return (1, $opt, $ctl, $arg, $key) + if defined $optarg || defined $rest; + return (1, $opt, $ctl, $arg, $key) if $arg eq "-"; # ?? + + # Check for option or option list terminator. + if ($arg eq $argend || + $arg =~ /^$prefix.+/) { + # Push back. + unshift (@ARGV, $arg); + # Supply empty value. + $arg = ''; + } + } + + elsif ( $type eq 'i' # numeric/integer + || $type eq 'I' # numeric/integer w/ incr default + || $type eq 'o' ) { # dec/oct/hex/bin value + + my $o_valid = + $type eq 'o' ? "[-+]?[1-9][0-9]*|0x[0-9a-f]+|0b[01]+|0[0-7]*" + : "[-+]?[0-9]+"; + + if ( $bundling && defined $rest && $rest =~ /^($o_valid)(.*)$/si ) { + $arg = $1; + $rest = $2; + $arg = ($type eq 'o' && $arg =~ /^0/) ? oct($arg) : 0+$arg; + unshift (@ARGV, $starter.$rest) if defined $rest && $rest ne ''; + } + elsif ( $arg =~ /^($o_valid)$/si ) { + $arg = ($type eq 'o' && $arg =~ /^0/) ? oct($arg) : 0+$arg; + } + else { + if ( defined $optarg || $mand ) { + if ( $passthrough ) { + unshift (@ARGV, defined $rest ? $starter.$rest : $arg) + unless defined $optarg; + return (0); + } + warn ("Value \"", $arg, "\" invalid for option ", + $opt, " (", + $type eq 'o' ? "extended " : '', + "number expected)\n"); + $error++; + # Push back. + unshift (@ARGV, $starter.$rest) if defined $rest; + return (1, undef); + } + else { + # Push back. + unshift (@ARGV, defined $rest ? $starter.$rest : $arg); + if ( $type eq 'I' ) { + # Fake incremental type. + my @c = @$ctl; + $c[CTL_TYPE] = '+'; + return (1, $opt, \@c, 1); + } + # Supply default value. + $arg = defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : 0; + } + } + } + + elsif ( $type eq 'f' ) { # real number, int is also ok + # We require at least one digit before a point or 'e', + # and at least one digit following the point and 'e'. + # [-]NN[.NN][eNN] + if ( $bundling && defined $rest && + $rest =~ /^([-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?)(.*)$/s ) { + $arg = $1; + $rest = $+; + unshift (@ARGV, $starter.$rest) if defined $rest && $rest ne ''; + } + elsif ( $arg !~ /^[-+]?[0-9.]+(\.[0-9]+)?([eE][-+]?[0-9]+)?$/ ) { + if ( defined $optarg || $mand ) { + if ( $passthrough ) { + unshift (@ARGV, defined $rest ? $starter.$rest : $arg) + unless defined $optarg; + return (0); + } + warn ("Value \"", $arg, "\" invalid for option ", + $opt, " (real number expected)\n"); + $error++; + # Push back. + unshift (@ARGV, $starter.$rest) if defined $rest; + return (1, undef); + } + else { + # Push back. + unshift (@ARGV, defined $rest ? $starter.$rest : $arg); + # Supply default value. + $arg = 0.0; + } + } + } + else { + die("GetOpt::Long internal error (Can't happen)\n"); + } + return (1, $opt, $ctl, $arg, $key); +} + +# Getopt::Long Configuration. +sub Configure (@) { + my (@options) = @_; + + my $prevconfig = + [ $error, $debug, $major_version, $minor_version, + $autoabbrev, $getopt_compat, $ignorecase, $bundling, $order, + $gnu_compat, $passthrough, $genprefix ]; + + if ( ref($options[0]) eq 'ARRAY' ) { + ( $error, $debug, $major_version, $minor_version, + $autoabbrev, $getopt_compat, $ignorecase, $bundling, $order, + $gnu_compat, $passthrough, $genprefix ) = @{shift(@options)}; + } + + my $opt; + foreach $opt ( @options ) { + my $try = lc ($opt); + my $action = 1; + if ( $try =~ /^no_?(.*)$/s ) { + $action = 0; + $try = $+; + } + if ( ($try eq 'default' or $try eq 'defaults') && $action ) { + ConfigDefaults (); + } + elsif ( ($try eq 'posix_default' or $try eq 'posix_defaults') ) { + local $ENV{POSIXLY_CORRECT}; + $ENV{POSIXLY_CORRECT} = 1 if $action; + ConfigDefaults (); + } + elsif ( $try eq 'auto_abbrev' or $try eq 'autoabbrev' ) { + $autoabbrev = $action; + } + elsif ( $try eq 'getopt_compat' ) { + $getopt_compat = $action; + } + elsif ( $try eq 'gnu_getopt' ) { + if ( $action ) { + $gnu_compat = 1; + $bundling = 1; + $getopt_compat = 0; + $order = $PERMUTE; + } + } + elsif ( $try eq 'gnu_compat' ) { + $gnu_compat = $action; + } + elsif ( $try eq 'ignorecase' or $try eq 'ignore_case' ) { + $ignorecase = $action; + } + elsif ( $try eq 'ignore_case_always' ) { + $ignorecase = $action ? 2 : 0; + } + elsif ( $try eq 'bundling' ) { + $bundling = $action; + } + elsif ( $try eq 'bundling_override' ) { + $bundling = $action ? 2 : 0; + } + elsif ( $try eq 'require_order' ) { + $order = $action ? $REQUIRE_ORDER : $PERMUTE; + } + elsif ( $try eq 'permute' ) { + $order = $action ? $PERMUTE : $REQUIRE_ORDER; + } + elsif ( $try eq 'pass_through' or $try eq 'passthrough' ) { + $passthrough = $action; + } + elsif ( $try =~ /^prefix=(.+)$/ && $action ) { + $genprefix = $1; + # Turn into regexp. Needs to be parenthesized! + $genprefix = "(" . quotemeta($genprefix) . ")"; + eval { '' =~ /$genprefix/; }; + die("Getopt::Long: invalid pattern \"$genprefix\"") if $@; + } + elsif ( $try =~ /^prefix_pattern=(.+)$/ && $action ) { + $genprefix = $1; + # Parenthesize if needed. + $genprefix = "(" . $genprefix . ")" + unless $genprefix =~ /^\(.*\)$/; + eval { '' =~ /$genprefix/; }; + die("Getopt::Long: invalid pattern \"$genprefix\"") if $@; + } + elsif ( $try eq 'debug' ) { + $debug = $action; + } + else { + die("Getopt::Long: unknown config parameter \"$opt\"") + } + } + $prevconfig; +} + +# Deprecated name. +sub config (@) { + Configure (@_); +} + +################ Documentation ################ + +=head1 NAME + +Getopt::Long - Extended processing of command line options + +=head1 SYNOPSIS + + use Getopt::Long; + my $data = "file.dat"; + my $length = 24; + my $verbose; + $result = GetOptions ("length=i" => \$length, # numeric + "file=s" => \$data, # string + "verbose" => \$verbose); # flag + +=head1 DESCRIPTION + +The Getopt::Long module implements an extended getopt function called +GetOptions(). This function adheres to the POSIX syntax for command +line options, with GNU extensions. In general, this means that options +have long names instead of single letters, and are introduced with a +double dash "--". Support for bundling of command line options, as was +the case with the more traditional single-letter approach, is provided +but not enabled by default. + +=head1 Command Line Options, an Introduction + +Command line operated programs traditionally take their arguments from +the command line, for example filenames or other information that the +program needs to know. Besides arguments, these programs often take +command line I<options> as well. Options are not necessary for the +program to work, hence the name 'option', but are used to modify its +default behaviour. For example, a program could do its job quietly, +but with a suitable option it could provide verbose information about +what it did. + +Command line options come in several flavours. Historically, they are +preceded by a single dash C<->, and consist of a single letter. + + -l -a -c + +Usually, these single-character options can be bundled: + + -lac + +Options can have values, the value is placed after the option +character. Sometimes with whitespace in between, sometimes not: + + -s 24 -s24 + +Due to the very cryptic nature of these options, another style was +developed that used long names. So instead of a cryptic C<-l> one +could use the more descriptive C<--long>. To distinguish between a +bundle of single-character options and a long one, two dashes are used +to precede the option name. Early implementations of long options used +a plus C<+> instead. Also, option values could be specified either +like + + --size=24 + +or + + --size 24 + +The C<+> form is now obsolete and strongly deprecated. + +=head1 Getting Started with Getopt::Long + +Getopt::Long is the Perl5 successor of C<newgetopt.pl>. This was +the first Perl module that provided support for handling the new style +of command line options, hence the name Getopt::Long. This module +also supports single-character options and bundling. In this case, the +options are restricted to alphabetic characters only, and the +characters C<?> and C<->. + +To use Getopt::Long from a Perl program, you must include the +following line in your Perl program: + + use Getopt::Long; + +This will load the core of the Getopt::Long module and prepare your +program for using it. Most of the actual Getopt::Long code is not +loaded until you really call one of its functions. + +In the default configuration, options names may be abbreviated to +uniqueness, case does not matter, and a single dash is sufficient, +even for long option names. Also, options may be placed between +non-option arguments. See L<Configuring Getopt::Long> for more +details on how to configure Getopt::Long. + +=head2 Simple options + +The most simple options are the ones that take no values. Their mere +presence on the command line enables the option. Popular examples are: + + --all --verbose --quiet --debug + +Handling simple options is straightforward: + + my $verbose = ''; # option variable with default value (false) + my $all = ''; # option variable with default value (false) + GetOptions ('verbose' => \$verbose, 'all' => \$all); + +The call to GetOptions() parses the command line arguments that are +present in C<@ARGV> and sets the option variable to the value C<1> if +the option did occur on the command line. Otherwise, the option +variable is not touched. Setting the option value to true is often +called I<enabling> the option. + +The option name as specified to the GetOptions() function is called +the option I<specification>. Later we'll see that this specification +can contain more than just the option name. The reference to the +variable is called the option I<destination>. + +GetOptions() will return a true value if the command line could be +processed successfully. Otherwise, it will write error messages to +STDERR, and return a false result. + +=head2 A little bit less simple options + +Getopt::Long supports two useful variants of simple options: +I<negatable> options and I<incremental> options. + +A negatable option is specified with an exclamation mark C<!> after the +option name: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose!' => \$verbose); + +Now, using C<--verbose> on the command line will enable C<$verbose>, +as expected. But it is also allowed to use C<--noverbose>, which will +disable C<$verbose> by setting its value to C<0>. Using a suitable +default value, the program can find out whether C<$verbose> is false +by default, or disabled by using C<--noverbose>. + +An incremental option is specified with a plus C<+> after the +option name: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose+' => \$verbose); + +Using C<--verbose> on the command line will increment the value of +C<$verbose>. This way the program can keep track of how many times the +option occurred on the command line. For example, each occurrence of +C<--verbose> could increase the verbosity level of the program. + +=head2 Mixing command line option with other arguments + +Usually programs take command line options as well as other arguments, +for example, file names. It is good practice to always specify the +options first, and the other arguments last. Getopt::Long will, +however, allow the options and arguments to be mixed and 'filter out' +all the options before passing the rest of the arguments to the +program. To stop Getopt::Long from processing further arguments, +insert a double dash C<--> on the command line: + + --size 24 -- --all + +In this example, C<--all> will I<not> be treated as an option, but +passed to the program unharmed, in C<@ARGV>. + +=head2 Options with values + +For options that take values it must be specified whether the option +value is required or not, and what kind of value the option expects. + +Three kinds of values are supported: integer numbers, floating point +numbers, and strings. + +If the option value is required, Getopt::Long will take the +command line argument that follows the option and assign this to the +option variable. If, however, the option value is specified as +optional, this will only be done if that value does not look like a +valid command line option itself. + + my $tag = ''; # option variable with default value + GetOptions ('tag=s' => \$tag); + +In the option specification, the option name is followed by an equals +sign C<=> and the letter C<s>. The equals sign indicates that this +option requires a value. The letter C<s> indicates that this value is +an arbitrary string. Other possible value types are C<i> for integer +values, and C<f> for floating point values. Using a colon C<:> instead +of the equals sign indicates that the option value is optional. In +this case, if no suitable value is supplied, string valued options get +an empty string C<''> assigned, while numeric options are set to C<0>. + +=head2 Options with multiple values + +Options sometimes take several values. For example, a program could +use multiple directories to search for library files: + + --library lib/stdlib --library lib/extlib + +To accomplish this behaviour, simply specify an array reference as the +destination for the option: + + my @libfiles = (); + GetOptions ("library=s" => \@libfiles); + +Used with the example above, C<@libfiles> would contain two strings +upon completion: C<"lib/srdlib"> and C<"lib/extlib">, in that order. +It is also possible to specify that only integer or floating point +numbers are acceptible values. + +Often it is useful to allow comma-separated lists of values as well as +multiple occurrences of the options. This is easy using Perl's split() +and join() operators: + + my @libfiles = (); + GetOptions ("library=s" => \@libfiles); + @libfiles = split(/,/,join(',',@libfiles)); + +Of course, it is important to choose the right separator string for +each purpose. + +=head2 Options with hash values + +If the option destination is a reference to a hash, the option will +take, as value, strings of the form I<key>C<=>I<value>. The value will +be stored with the specified key in the hash. + + my %defines = (); + GetOptions ("define=s" => \%defines); + +When used with command line options: + + --define os=linux --define vendor=redhat + +the hash C<%defines> will contain two keys, C<"os"> with value +C<"linux> and C<"vendor"> with value C<"redhat">. +It is also possible to specify that only integer or floating point +numbers are acceptible values. The keys are always taken to be strings. + +=head2 User-defined subroutines to handle options + +Ultimate control over what should be done when (actually: each time) +an option is encountered on the command line can be achieved by +designating a reference to a subroutine (or an anonymous subroutine) +as the option destination. When GetOptions() encounters the option, it +will call the subroutine with two or three arguments. The first +argument is the name of the option. For a scalar or array destination, +the second argument is the value to be stored. For a hash destination, +the second arguments is the key to the hash, and the third argument +the value to be stored. It is up to the subroutine to store the value, +or do whatever it thinks is appropriate. + +A trivial application of this mechanism is to implement options that +are related to each other. For example: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose' => \$verbose, + 'quiet' => sub { $verbose = 0 }); + +Here C<--verbose> and C<--quiet> control the same variable +C<$verbose>, but with opposite values. + +If the subroutine needs to signal an error, it should call die() with +the desired error message as its argument. GetOptions() will catch the +die(), issue the error message, and record that an error result must +be returned upon completion. + +If the text of the error message starts with an exclamantion mark C<!> +it is interpreted specially by GetOptions(). There is currently one +special command implemented: C<die("!FINISH")> will cause GetOptions() +to stop processing options, as if it encountered a double dash C<-->. + +=head2 Options with multiple names + +Often it is user friendly to supply alternate mnemonic names for +options. For example C<--height> could be an alternate name for +C<--length>. Alternate names can be included in the option +specification, separated by vertical bar C<|> characters. To implement +the above example: + + GetOptions ('length|height=f' => \$length); + +The first name is called the I<primary> name, the other names are +called I<aliases>. + +Multiple alternate names are possible. + +=head2 Case and abbreviations + +Without additional configuration, GetOptions() will ignore the case of +option names, and allow the options to be abbreviated to uniqueness. + + GetOptions ('length|height=f' => \$length, "head" => \$head); + +This call will allow C<--l> and C<--L> for the length option, but +requires a least C<--hea> and C<--hei> for the head and height options. + +=head2 Summary of Option Specifications + +Each option specifier consists of two parts: the name specification +and the argument specification. + +The name specification contains the name of the option, optionally +followed by a list of alternative names separated by vertical bar +characters. + + length option name is "length" + length|size|l name is "length", aliases are "size" and "l" + +The argument specification is optional. If omitted, the option is +considered boolean, a value of 1 will be assigned when the option is +used on the command line. + +The argument specification can be + +=over 4 + +=item ! + +The option does not take an argument and may be negated, i.e. prefixed +by "no". E.g. C<"foo!"> will allow C<--foo> (a value of 1 will be +assigned) and C<--nofoo> (a value of 0 will be assigned). If the +option has aliases, this applies to the aliases as well. + +Using negation on a single letter option when bundling is in effect is +pointless and will result in a warning. + +=item + + +The option does not take an argument and will be incremented by 1 +every time it appears on the command line. E.g. C<"more+">, when used +with C<--more --more --more>, will increment the value three times, +resulting in a value of 3 (provided it was 0 or undefined at first). + +The C<+> specifier is ignored if the option destination is not a scalar. + +=item = I<type> [ I<desttype> ] + +The option requires an argument of the given type. Supported types +are: + +=over 4 + +=item s + +String. An arbitrary sequence of characters. It is valid for the +argument to start with C<-> or C<-->. + +=item i + +Integer. An optional leading plus or minus sign, followed by a +sequence of digits. + +=item o + +Extended integer, Perl style. This can be either an optional leading +plus or minus sign, followed by a sequence of digits, or an octal +string (a zero, optionally followed by '0', '1', .. '7'), or a +hexadecimal string (C<0x> followed by '0' .. '9', 'a' .. 'f', case +insensitive), or a binary string (C<0b> followed by a series of '0' +and '1'). + +=item f + +Real number. For example C<3.14>, C<-6.23E24> and so on. + +=back + +The I<desttype> can be C<@> or C<%> to specify that the option is +list or a hash valued. This is only needed when the destination for +the option value is not otherwise specified. It should be omitted when +not needed. + +=item : I<type> [ I<desttype> ] + +Like C<=>, but designates the argument as optional. +If omitted, an empty string will be assigned to string values options, +and the value zero to numeric options. + +Note that if a string argument starts with C<-> or C<-->, it will be +considered an option on itself. + +=item : I<number> [ I<desttype> ] + +Like C<:i>, but if the value is omitted, the I<number> will be assigned. + +=item : + [ I<desttype> ] + +Like C<:i>, but if the value is omitted, the current value for the +option will be incremented. + +=back + +=head1 Advanced Possibilities + +=head2 Object oriented interface + +Getopt::Long can be used in an object oriented way as well: + + use Getopt::Long; + $p = new Getopt::Long::Parser; + $p->configure(...configuration options...); + if ($p->getoptions(...options descriptions...)) ... + +Configuration options can be passed to the constructor: + + $p = new Getopt::Long::Parser + config => [...configuration options...]; + +=head2 Thread Safety + +Getopt::Long is thread safe when using ithreads as of Perl 5.8. It is +I<not> thread safe when using the older (experimental and now +obsolete) threads implementation that was added to Perl 5.005. + +=head2 Documentation and help texts + +Getopt::Long encourages the use of Pod::Usage to produce help +messages. For example: + + use Getopt::Long; + use Pod::Usage; + + my $man = 0; + my $help = 0; + + GetOptions('help|?' => \$help, man => \$man) or pod2usage(2); + pod2usage(1) if $help; + pod2usage(-exitstatus => 0, -verbose => 2) if $man; + + __END__ + + =head1 NAME + + sample - Using GetOpt::Long and Pod::Usage + + =head1 SYNOPSIS + + sample [options] [file ...] + + Options: + -help brief help message + -man full documentation + + =head1 OPTIONS + + =over 8 + + =item B<-help> + + Print a brief help message and exits. + + =item B<-man> + + Prints the manual page and exits. + + =back + + =head1 DESCRIPTION + + B<This program> will read the given input file(s) and do someting + useful with the contents thereof. + + =cut + +See L<Pod::Usage> for details. + +=head2 Storing options in a hash + +Sometimes, for example when there are a lot of options, having a +separate variable for each of them can be cumbersome. GetOptions() +supports, as an alternative mechanism, storing options in a hash. + +To obtain this, a reference to a hash must be passed I<as the first +argument> to GetOptions(). For each option that is specified on the +command line, the option value will be stored in the hash with the +option name as key. Options that are not actually used on the command +line will not be put in the hash, on other words, +C<exists($h{option})> (or defined()) can be used to test if an option +was used. The drawback is that warnings will be issued if the program +runs under C<use strict> and uses C<$h{option}> without testing with +exists() or defined() first. + + my %h = (); + GetOptions (\%h, 'length=i'); # will store in $h{length} + +For options that take list or hash values, it is necessary to indicate +this by appending an C<@> or C<%> sign after the type: + + GetOptions (\%h, 'colours=s@'); # will push to @{$h{colours}} + +To make things more complicated, the hash may contain references to +the actual destinations, for example: + + my $len = 0; + my %h = ('length' => \$len); + GetOptions (\%h, 'length=i'); # will store in $len + +This example is fully equivalent with: + + my $len = 0; + GetOptions ('length=i' => \$len); # will store in $len + +Any mixture is possible. For example, the most frequently used options +could be stored in variables while all other options get stored in the +hash: + + my $verbose = 0; # frequently referred + my $debug = 0; # frequently referred + my %h = ('verbose' => \$verbose, 'debug' => \$debug); + GetOptions (\%h, 'verbose', 'debug', 'filter', 'size=i'); + if ( $verbose ) { ... } + if ( exists $h{filter} ) { ... option 'filter' was specified ... } + +=head2 Bundling + +With bundling it is possible to set several single-character options +at once. For example if C<a>, C<v> and C<x> are all valid options, + + -vax + +would set all three. + +Getopt::Long supports two levels of bundling. To enable bundling, a +call to Getopt::Long::Configure is required. + +The first level of bundling can be enabled with: + + Getopt::Long::Configure ("bundling"); + +Configured this way, single-character options can be bundled but long +options B<must> always start with a double dash C<--> to avoid +abiguity. For example, when C<vax>, C<a>, C<v> and C<x> are all valid +options, + + -vax + +would set C<a>, C<v> and C<x>, but + + --vax + +would set C<vax>. + +The second level of bundling lifts this restriction. It can be enabled +with: + + Getopt::Long::Configure ("bundling_override"); + +Now, C<-vax> would set the option C<vax>. + +When any level of bundling is enabled, option values may be inserted +in the bundle. For example: + + -h24w80 + +is equivalent to + + -h 24 -w 80 + +When configured for bundling, single-character options are matched +case sensitive while long options are matched case insensitive. To +have the single-character options matched case insensitive as well, +use: + + Getopt::Long::Configure ("bundling", "ignorecase_always"); + +It goes without saying that bundling can be quite confusing. + +=head2 The lonesome dash + +Normally, a lone dash C<-> on the command line will not be considered +an option. Option processing will terminate (unless "permute" is +configured) and the dash will be left in C<@ARGV>. + +It is possible to get special treatment for a lone dash. This can be +achieved by adding an option specification with an empty name, for +example: + + GetOptions ('' => \$stdio); + +A lone dash on the command line will now be a legal option, and using +it will set variable C<$stdio>. + +=head2 Argument callback + +A special option 'name' C<<>> can be used to designate a subroutine +to handle non-option arguments. When GetOptions() encounters an +argument that does not look like an option, it will immediately call this +subroutine and passes it one parameter: the argument name. + +For example: + + my $width = 80; + sub process { ... } + GetOptions ('width=i' => \$width, '<>' => \&process); + +When applied to the following command line: + + arg1 --width=72 arg2 --width=60 arg3 + +This will call +C<process("arg1")> while C<$width> is C<80>, +C<process("arg2")> while C<$width> is C<72>, and +C<process("arg3")> while C<$width> is C<60>. + +This feature requires configuration option B<permute>, see section +L<Configuring Getopt::Long>. + + +=head1 Configuring Getopt::Long + +Getopt::Long can be configured by calling subroutine +Getopt::Long::Configure(). This subroutine takes a list of quoted +strings, each specifying a configuration option to be enabled, e.g. +C<ignore_case>, or disabled, e.g. C<no_ignore_case>. Case does not +matter. Multiple calls to Configure() are possible. + +Alternatively, as of version 2.24, the configuration options may be +passed together with the C<use> statement: + + use Getopt::Long qw(:config no_ignore_case bundling); + +The following options are available: + +=over 12 + +=item default + +This option causes all configuration options to be reset to their +default values. + +=item posix_default + +This option causes all configuration options to be reset to their +default values as if the environment variable POSIXLY_CORRECT had +been set. + +=item auto_abbrev + +Allow option names to be abbreviated to uniqueness. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C<auto_abbrev> is disabled. + +=item getopt_compat + +Allow C<+> to start options. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C<getopt_compat> is disabled. + +=item gnu_compat + +C<gnu_compat> controls whether C<--opt=> is allowed, and what it should +do. Without C<gnu_compat>, C<--opt=> gives an error. With C<gnu_compat>, +C<--opt=> will give option C<opt> and empty value. +This is the way GNU getopt_long() does it. + +=item gnu_getopt + +This is a short way of setting C<gnu_compat> C<bundling> C<permute> +C<no_getopt_compat>. With C<gnu_getopt>, command line handling should be +fully compatible with GNU getopt_long(). + +=item require_order + +Whether command line arguments are allowed to be mixed with options. +Default is disabled unless environment variable +POSIXLY_CORRECT has been set, in which case C<require_order> is enabled. + +See also C<permute>, which is the opposite of C<require_order>. + +=item permute + +Whether command line arguments are allowed to be mixed with options. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C<permute> is disabled. +Note that C<permute> is the opposite of C<require_order>. + +If C<permute> is enabled, this means that + + --foo arg1 --bar arg2 arg3 + +is equivalent to + + --foo --bar arg1 arg2 arg3 + +If an argument callback routine is specified, C<@ARGV> will always be +empty upon succesful return of GetOptions() since all options have been +processed. The only exception is when C<--> is used: + + --foo arg1 --bar arg2 -- arg3 + +This will call the callback routine for arg1 and arg2, and then +terminate GetOptions() leaving C<"arg2"> in C<@ARGV>. + +If C<require_order> is enabled, options processing +terminates when the first non-option is encountered. + + --foo arg1 --bar arg2 arg3 + +is equivalent to + + --foo -- arg1 --bar arg2 arg3 + +If C<pass_through> is also enabled, options processing will terminate +at the first unrecognized option, or non-option, whichever comes +first. + +=item bundling (default: disabled) + +Enabling this option will allow single-character options to be +bundled. To distinguish bundles from long option names, long options +I<must> be introduced with C<--> and bundles with C<->. + +Note that, if you have options C<a>, C<l> and C<all>, and +auto_abbrev enabled, possible arguments and option settings are: + + using argument sets option(s) + ------------------------------------------ + -a, --a a + -l, --l l + -al, -la, -ala, -all,... a, l + --al, --all all + +The suprising part is that C<--a> sets option C<a> (due to auto +completion), not C<all>. + +Note: disabling C<bundling> also disables C<bundling_override>. + +=item bundling_override (default: disabled) + +If C<bundling_override> is enabled, bundling is enabled as with +C<bundling> but now long option names override option bundles. + +Note: disabling C<bundling_override> also disables C<bundling>. + +B<Note:> Using option bundling can easily lead to unexpected results, +especially when mixing long options and bundles. Caveat emptor. + +=item ignore_case (default: enabled) + +If enabled, case is ignored when matching long option names. If, +however, bundling is enabled as well, single character options will be +treated case-sensitive. + +With C<ignore_case>, option specifications for options that only +differ in case, e.g., C<"foo"> and C<"Foo">, will be flagged as +duplicates. + +Note: disabling C<ignore_case> also disables C<ignore_case_always>. + +=item ignore_case_always (default: disabled) + +When bundling is in effect, case is ignored on single-character +options also. + +Note: disabling C<ignore_case_always> also disables C<ignore_case>. + +=item pass_through (default: disabled) + +Options that are unknown, ambiguous or supplied with an invalid option +value are passed through in C<@ARGV> instead of being flagged as +errors. This makes it possible to write wrapper scripts that process +only part of the user supplied command line arguments, and pass the +remaining options to some other program. + +If C<require_order> is enabled, options processing will terminate at +the first unrecognized option, or non-option, whichever comes first. +However, if C<permute> is enabled instead, results can become confusing. + +=item prefix + +The string that starts options. If a constant string is not +sufficient, see C<prefix_pattern>. + +=item prefix_pattern + +A Perl pattern that identifies the strings that introduce options. +Default is C<(--|-|\+)> unless environment variable +POSIXLY_CORRECT has been set, in which case it is C<(--|-)>. + +=item debug (default: disabled) + +Enable debugging output. + +=back + +=head1 Return values and Errors + +Configuration errors and errors in the option definitions are +signalled using die() and will terminate the calling program unless +the call to Getopt::Long::GetOptions() was embedded in C<eval { ... +}>, or die() was trapped using C<$SIG{__DIE__}>. + +GetOptions returns true to indicate success. +It returns false when the function detected one or more errors during +option parsing. These errors are signalled using warn() and can be +trapped with C<$SIG{__WARN__}>. + +Errors that can't happen are signalled using Carp::croak(). + +=head1 Legacy + +The earliest development of C<newgetopt.pl> started in 1990, with Perl +version 4. As a result, its development, and the development of +Getopt::Long, has gone through several stages. Since backward +compatibility has always been extremely important, the current version +of Getopt::Long still supports a lot of constructs that nowadays are +no longer necessary or otherwise unwanted. This section describes +briefly some of these 'features'. + +=head2 Default destinations + +When no destination is specified for an option, GetOptions will store +the resultant value in a global variable named C<opt_>I<XXX>, where +I<XXX> is the primary name of this option. When a progam executes +under C<use strict> (recommended), these variables must be +pre-declared with our() or C<use vars>. + + our $opt_length = 0; + GetOptions ('length=i'); # will store in $opt_length + +To yield a usable Perl variable, characters that are not part of the +syntax for variables are translated to underscores. For example, +C<--fpp-struct-return> will set the variable +C<$opt_fpp_struct_return>. Note that this variable resides in the +namespace of the calling program, not necessarily C<main>. For +example: + + GetOptions ("size=i", "sizes=i@"); + +with command line "-size 10 -sizes 24 -sizes 48" will perform the +equivalent of the assignments + + $opt_size = 10; + @opt_sizes = (24, 48); + +=head2 Alternative option starters + +A string of alternative option starter characters may be passed as the +first argument (or the first argument after a leading hash reference +argument). + + my $len = 0; + GetOptions ('/', 'length=i' => $len); + +Now the command line may look like: + + /length 24 -- arg + +Note that to terminate options processing still requires a double dash +C<-->. + +GetOptions() will not interpret a leading C<< "<>" >> as option starters +if the next argument is a reference. To force C<< "<" >> and C<< ">" >> as +option starters, use C<< "><" >>. Confusing? Well, B<using a starter +argument is strongly deprecated> anyway. + +=head2 Configuration variables + +Previous versions of Getopt::Long used variables for the purpose of +configuring. Although manipulating these variables still work, it is +strongly encouraged to use the C<Configure> routine that was introduced +in version 2.17. Besides, it is much easier. + +=head1 Trouble Shooting + +=head2 Warning: Ignoring '!' modifier for short option + +This warning is issued when the '!' modifier is applied to a short +(one-character) option and bundling is in effect. E.g., + + Getopt::Long::Configure("bundling"); + GetOptions("foo|f!" => \$foo); + +Note that older Getopt::Long versions did not issue a warning, because +the '!' modifier was applied to the first name only. This bug was +fixed in 2.22. + +Solution: separate the long and short names and apply the '!' to the +long names only, e.g., + + GetOptions("foo!" => \$foo, "f" => \$foo); + +=head2 GetOptions does not return a false result when an option is not supplied + +That's why they're called 'options'. + +=head2 GetOptions does not split the command line correctly + +The command line is not split by GetOptions, but by the command line +interpreter (CLI). On Unix, this is the shell. On Windows, it is +COMMAND.COM or CMD.EXE. Other operating systems have other CLIs. + +It is important to know that these CLIs may behave different when the +command line contains special characters, in particular quotes or +backslashes. For example, with Unix shells you can use single quotes +(C<'>) and double quotes (C<">) to group words together. The following +alternatives are equivalent on Unix: + + "two words" + 'two words' + two\ words + +In case of doubt, insert the following statement in front of your Perl +program: + + print STDERR (join("|",@ARGV),"\n"); + +to verify how your CLI passes the arguments to the program. + +=head2 How do I put a "-?" option into a Getopt::Long? + +You can only obtain this using an alias, and Getopt::Long of at least +version 2.13. + + use Getopt::Long; + GetOptions ("help|?"); # -help and -? will both set $opt_help + +=head1 AUTHOR + +Johan Vromans <jvromans@squirrel.nl> + +=head1 COPYRIGHT AND DISCLAIMER + +This program is Copyright 2002,1990 by Johan Vromans. +This program is free software; you can redistribute it and/or +modify it under the terms of the Perl Artistic License or the +GNU General Public License as published by the Free Software +Foundation; either version 2 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. + +If you do not have a copy of the GNU General Public License write to +the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, +MA 02139, USA. + +=cut + diff --git a/Master/xemtex/perl/lib/IO.pm b/Master/xemtex/perl/lib/IO.pm new file mode 100644 index 00000000000..0087530c7e6 --- /dev/null +++ b/Master/xemtex/perl/lib/IO.pm @@ -0,0 +1,47 @@ +# + +package IO; + +use XSLoader (); +use Carp; + +$VERSION = "1.20"; +XSLoader::load 'IO', $VERSION; + +sub import { + shift; + my @l = @_ ? @_ : qw(Handle Seekable File Pipe Socket Dir); + + eval join("", map { "require IO::" . (/(\w+)/)[0] . ";\n" } @l) + or croak $@; +} + +1; + +__END__ + +=head1 NAME + +IO - load various IO modules + +=head1 SYNOPSIS + + use IO; + +=head1 DESCRIPTION + +C<IO> provides a simple mechanism to load some of the IO modules at one go. +Currently this includes: + + IO::Handle + IO::Seekable + IO::File + IO::Pipe + IO::Socket + IO::Dir + +For more information on any of these modules, please see its respective +documentation. + +=cut + diff --git a/Master/xemtex/perl/lib/IO/File.pm b/Master/xemtex/perl/lib/IO/File.pm new file mode 100644 index 00000000000..d5520cbd933 --- /dev/null +++ b/Master/xemtex/perl/lib/IO/File.pm @@ -0,0 +1,169 @@ +# + +package IO::File; + +=head1 NAME + +IO::File - supply object methods for filehandles + +=head1 SYNOPSIS + + use IO::File; + + $fh = new IO::File; + if ($fh->open("< file")) { + print <$fh>; + $fh->close; + } + + $fh = new IO::File "> file"; + if (defined $fh) { + print $fh "bar\n"; + $fh->close; + } + + $fh = new IO::File "file", "r"; + if (defined $fh) { + print <$fh>; + undef $fh; # automatically closes the file + } + + $fh = new IO::File "file", O_WRONLY|O_APPEND; + if (defined $fh) { + print $fh "corge\n"; + + $pos = $fh->getpos; + $fh->setpos($pos); + + undef $fh; # automatically closes the file + } + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +C<IO::File> inherits from C<IO::Handle> and C<IO::Seekable>. It extends +these classes with methods that are specific to file handles. + +=head1 CONSTRUCTOR + +=over 4 + +=item new ( FILENAME [,MODE [,PERMS]] ) + +Creates an C<IO::File>. If it receives any parameters, they are passed to +the method C<open>; if the open fails, the object is destroyed. Otherwise, +it is returned to the caller. + +=item new_tmpfile + +Creates an C<IO::File> opened for read/write on a newly created temporary +file. On systems where this is possible, the temporary file is anonymous +(i.e. it is unlinked after creation, but held open). If the temporary +file cannot be created or opened, the C<IO::File> object is destroyed. +Otherwise, it is returned to the caller. + +=back + +=head1 METHODS + +=over 4 + +=item open( FILENAME [,MODE [,PERMS]] ) + +C<open> accepts one, two or three parameters. With one parameter, +it is just a front end for the built-in C<open> function. With two or three +parameters, the first parameter is a filename that may include +whitespace or other special characters, and the second parameter is +the open mode, optionally followed by a file permission value. + +If C<IO::File::open> receives a Perl mode string ("E<gt>", "+E<lt>", etc.) +or an ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic +Perl C<open> operator (but protects any special characters). + +If C<IO::File::open> is given a numeric mode, it passes that mode +and the optional permissions value to the Perl C<sysopen> operator. +The permissions default to 0666. + +For convenience, C<IO::File> exports the O_XXX constants from the +Fcntl module, if this module is available. + +=back + +=head1 SEE ALSO + +L<perlfunc>, +L<perlop/"I/O Operators">, +L<IO::Handle> +L<IO::Seekable> + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt>. + +=cut + +use 5.006_001; +use strict; +our($VERSION, @EXPORT, @EXPORT_OK, @ISA); +use Carp; +use Symbol; +use SelectSaver; +use IO::Seekable; +use File::Spec; + +require Exporter; + +@ISA = qw(IO::Handle IO::Seekable Exporter); + +$VERSION = "1.09"; + +@EXPORT = @IO::Seekable::EXPORT; + +eval { + # Make all Fcntl O_XXX constants available for importing + require Fcntl; + my @O = grep /^O_/, @Fcntl::EXPORT; + Fcntl->import(@O); # first we import what we want to export + push(@EXPORT, @O); +}; + +################################################ +## Constructor +## + +sub new { + my $type = shift; + my $class = ref($type) || $type || "IO::File"; + @_ >= 0 && @_ <= 3 + or croak "usage: new $class [FILENAME [,MODE [,PERMS]]]"; + my $fh = $class->SUPER::new(); + if (@_) { + $fh->open(@_) + or return undef; + } + $fh; +} + +################################################ +## Open +## + +sub open { + @_ >= 2 && @_ <= 4 or croak 'usage: $fh->open(FILENAME [,MODE [,PERMS]])'; + my ($fh, $file) = @_; + if (@_ > 2) { + my ($mode, $perms) = @_[2, 3]; + if ($mode =~ /^\d+$/) { + defined $perms or $perms = 0666; + return sysopen($fh, $file, $mode, $perms); + } + if (! File::Spec->file_name_is_absolute($file)) { + $file = File::Spec->catfile(File::Spec->curdir(),$file); + } + $file = IO::Handle::_open_mode_string($mode) . " $file\0"; + } + open($fh, $file); +} + +1; diff --git a/Master/xemtex/perl/lib/IO/Handle.pm b/Master/xemtex/perl/lib/IO/Handle.pm new file mode 100644 index 00000000000..81bec5a6c1a --- /dev/null +++ b/Master/xemtex/perl/lib/IO/Handle.pm @@ -0,0 +1,613 @@ + +package IO::Handle; + +=head1 NAME + +IO::Handle - supply object methods for I/O handles + +=head1 SYNOPSIS + + use IO::Handle; + + $io = new IO::Handle; + if ($io->fdopen(fileno(STDIN),"r")) { + print $io->getline; + $io->close; + } + + $io = new IO::Handle; + if ($io->fdopen(fileno(STDOUT),"w")) { + $io->print("Some text\n"); + } + + use IO::Handle '_IOLBF'; + $io->setvbuf($buffer_var, _IOLBF, 1024); + + undef $io; # automatically closes the file if it's open + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +C<IO::Handle> is the base class for all other IO handle classes. It is +not intended that objects of C<IO::Handle> would be created directly, +but instead C<IO::Handle> is inherited from by several other classes +in the IO hierarchy. + +If you are reading this documentation, looking for a replacement for +the C<FileHandle> package, then I suggest you read the documentation +for C<IO::File> too. + +=head1 CONSTRUCTOR + +=over 4 + +=item new () + +Creates a new C<IO::Handle> object. + +=item new_from_fd ( FD, MODE ) + +Creates an C<IO::Handle> like C<new> does. +It requires two parameters, which are passed to the method C<fdopen>; +if the fdopen fails, the object is destroyed. Otherwise, it is returned +to the caller. + +=back + +=head1 METHODS + +See L<perlfunc> for complete descriptions of each of the following +supported C<IO::Handle> methods, which are just front ends for the +corresponding built-in functions: + + $io->close + $io->eof + $io->fileno + $io->format_write( [FORMAT_NAME] ) + $io->getc + $io->read ( BUF, LEN, [OFFSET] ) + $io->print ( ARGS ) + $io->printf ( FMT, [ARGS] ) + $io->stat + $io->sysread ( BUF, LEN, [OFFSET] ) + $io->syswrite ( BUF, [LEN, [OFFSET]] ) + $io->truncate ( LEN ) + +See L<perlvar> for complete descriptions of each of the following +supported C<IO::Handle> methods. All of them return the previous +value of the attribute and takes an optional single argument that when +given will set the value. If no argument is given the previous value +is unchanged (except for $io->autoflush will actually turn ON +autoflush by default). + + $io->autoflush ( [BOOL] ) $| + $io->format_page_number( [NUM] ) $% + $io->format_lines_per_page( [NUM] ) $= + $io->format_lines_left( [NUM] ) $- + $io->format_name( [STR] ) $~ + $io->format_top_name( [STR] ) $^ + $io->input_line_number( [NUM]) $. + +The following methods are not supported on a per-filehandle basis. + + IO::Handle->format_line_break_characters( [STR] ) $: + IO::Handle->format_formfeed( [STR]) $^L + IO::Handle->output_field_separator( [STR] ) $, + IO::Handle->output_record_separator( [STR] ) $\ + + IO::Handle->input_record_separator( [STR] ) $/ + +Furthermore, for doing normal I/O you might need these: + +=over 4 + +=item $io->fdopen ( FD, MODE ) + +C<fdopen> is like an ordinary C<open> except that its first parameter +is not a filename but rather a file handle name, an IO::Handle object, +or a file descriptor number. + +=item $io->opened + +Returns true if the object is currently a valid file descriptor, false +otherwise. + +=item $io->getline + +This works like <$io> described in L<perlop/"I/O Operators"> +except that it's more readable and can be safely called in a +list context but still returns just one line. + +=item $io->getlines + +This works like <$io> when called in a list context to read all +the remaining lines in a file, except that it's more readable. +It will also croak() if accidentally called in a scalar context. + +=item $io->ungetc ( ORD ) + +Pushes a character with the given ordinal value back onto the given +handle's input stream. Only one character of pushback per handle is +guaranteed. + +=item $io->write ( BUF, LEN [, OFFSET ] ) + +This C<write> is like C<write> found in C, that is it is the +opposite of read. The wrapper for the perl C<write> function is +called C<format_write>. + +=item $io->error + +Returns a true value if the given handle has experienced any errors +since it was opened or since the last call to C<clearerr>, or if the +handle is invalid. It only returns false for a valid handle with no +outstanding errors. + +=item $io->clearerr + +Clear the given handle's error indicator. Returns -1 if the handle is +invalid, 0 otherwise. + +=item $io->sync + +C<sync> synchronizes a file's in-memory state with that on the +physical medium. C<sync> does not operate at the perlio api level, but +operates on the file descriptor (similar to sysread, sysseek and +systell). This means that any data held at the perlio api level will not +be synchronized. To synchronize data that is buffered at the perlio api +level you must use the flush method. C<sync> is not implemented on all +platforms. Returns "0 but true" on success, C<undef> on error, C<undef> +for an invalid handle. See L<fsync(3c)>. + +=item $io->flush + +C<flush> causes perl to flush any buffered data at the perlio api level. +Any unread data in the buffer will be discarded, and any unwritten data +will be written to the underlying file descriptor. Returns "0 but true" +on success, C<undef> on error. + +=item $io->printflush ( ARGS ) + +Turns on autoflush, print ARGS and then restores the autoflush status of the +C<IO::Handle> object. Returns the return value from print. + +=item $io->blocking ( [ BOOL ] ) + +If called with an argument C<blocking> will turn on non-blocking IO if +C<BOOL> is false, and turn it off if C<BOOL> is true. + +C<blocking> will return the value of the previous setting, or the +current setting if C<BOOL> is not given. + +If an error occurs C<blocking> will return undef and C<$!> will be set. + +=back + + +If the C functions setbuf() and/or setvbuf() are available, then +C<IO::Handle::setbuf> and C<IO::Handle::setvbuf> set the buffering +policy for an IO::Handle. The calling sequences for the Perl functions +are the same as their C counterparts--including the constants C<_IOFBF>, +C<_IOLBF>, and C<_IONBF> for setvbuf()--except that the buffer parameter +specifies a scalar variable to use as a buffer. You should only +change the buffer before any I/O, or immediately after calling flush. + +WARNING: A variable used as a buffer by C<setbuf> or C<setvbuf> B<must not +be modified> in any way until the IO::Handle is closed or C<setbuf> or +C<setvbuf> is called again, or memory corruption may result! Remember that +the order of global destruction is undefined, so even if your buffer +variable remains in scope until program termination, it may be undefined +before the file IO::Handle is closed. Note that you need to import the +constants C<_IOFBF>, C<_IOLBF>, and C<_IONBF> explicitly. Like C, setbuf +returns nothing. setvbuf returns "0 but true", on success, C<undef> on +failure. + +Lastly, there is a special method for working under B<-T> and setuid/gid +scripts: + +=over 4 + +=item $io->untaint + +Marks the object as taint-clean, and as such data read from it will also +be considered taint-clean. Note that this is a very trusting action to +take, and appropriate consideration for the data source and potential +vulnerability should be kept in mind. Returns 0 on success, -1 if setting +the taint-clean flag failed. (eg invalid handle) + +=back + +=head1 NOTE + +An C<IO::Handle> object is a reference to a symbol/GLOB reference (see +the C<Symbol> package). Some modules that +inherit from C<IO::Handle> may want to keep object related variables +in the hash table part of the GLOB. In an attempt to prevent modules +trampling on each other I propose the that any such module should prefix +its variables with its own name separated by _'s. For example the IO::Socket +module keeps a C<timeout> variable in 'io_socket_timeout'. + +=head1 SEE ALSO + +L<perlfunc>, +L<perlop/"I/O Operators">, +L<IO::File> + +=head1 BUGS + +Due to backwards compatibility, all filehandles resemble objects +of class C<IO::Handle>, or actually classes derived from that class. +They actually aren't. Which means you can't derive your own +class from C<IO::Handle> and inherit those methods. + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr E<lt>F<gbarr@pobox.com>E<gt> + +=cut + +use 5.006_001; +use strict; +our($VERSION, @EXPORT_OK, @ISA); +use Carp; +use Symbol; +use SelectSaver; +use IO (); # Load the XS module + +require Exporter; +@ISA = qw(Exporter); + +$VERSION = "1.21_00"; +$VERSION = eval $VERSION; + +@EXPORT_OK = qw( + autoflush + output_field_separator + output_record_separator + input_record_separator + input_line_number + format_page_number + format_lines_per_page + format_lines_left + format_name + format_top_name + format_line_break_characters + format_formfeed + format_write + + print + printf + getline + getlines + + printflush + flush + + SEEK_SET + SEEK_CUR + SEEK_END + _IOFBF + _IOLBF + _IONBF +); + +################################################ +## Constructors, destructors. +## + +sub new { + my $class = ref($_[0]) || $_[0] || "IO::Handle"; + @_ == 1 or croak "usage: new $class"; + my $io = gensym; + bless $io, $class; +} + +sub new_from_fd { + my $class = ref($_[0]) || $_[0] || "IO::Handle"; + @_ == 3 or croak "usage: new_from_fd $class FD, MODE"; + my $io = gensym; + shift; + IO::Handle::fdopen($io, @_) + or return undef; + bless $io, $class; +} + +# +# There is no need for DESTROY to do anything, because when the +# last reference to an IO object is gone, Perl automatically +# closes its associated files (if any). However, to avoid any +# attempts to autoload DESTROY, we here define it to do nothing. +# +sub DESTROY {} + + +################################################ +## Open and close. +## + +sub _open_mode_string { + my ($mode) = @_; + $mode =~ /^\+?(<|>>?)$/ + or $mode =~ s/^r(\+?)$/$1</ + or $mode =~ s/^w(\+?)$/$1>/ + or $mode =~ s/^a(\+?)$/$1>>/ + or croak "IO::Handle: bad open mode: $mode"; + $mode; +} + +sub fdopen { + @_ == 3 or croak 'usage: $io->fdopen(FD, MODE)'; + my ($io, $fd, $mode) = @_; + local(*GLOB); + + if (ref($fd) && "".$fd =~ /GLOB\(/o) { + # It's a glob reference; Alias it as we cannot get name of anon GLOBs + my $n = qualify(*GLOB); + *GLOB = *{*$fd}; + $fd = $n; + } elsif ($fd =~ m#^\d+$#) { + # It's an FD number; prefix with "=". + $fd = "=$fd"; + } + + open($io, _open_mode_string($mode) . '&' . $fd) + ? $io : undef; +} + +sub close { + @_ == 1 or croak 'usage: $io->close()'; + my($io) = @_; + + close($io); +} + +################################################ +## Normal I/O functions. +## + +# flock +# select + +sub opened { + @_ == 1 or croak 'usage: $io->opened()'; + defined fileno($_[0]); +} + +sub fileno { + @_ == 1 or croak 'usage: $io->fileno()'; + fileno($_[0]); +} + +sub getc { + @_ == 1 or croak 'usage: $io->getc()'; + getc($_[0]); +} + +sub eof { + @_ == 1 or croak 'usage: $io->eof()'; + eof($_[0]); +} + +sub print { + @_ or croak 'usage: $io->print(ARGS)'; + my $this = shift; + print $this @_; +} + +sub printf { + @_ >= 2 or croak 'usage: $io->printf(FMT,[ARGS])'; + my $this = shift; + printf $this @_; +} + +sub getline { + @_ == 1 or croak 'usage: $io->getline()'; + my $this = shift; + return scalar <$this>; +} + +*gets = \&getline; # deprecated + +sub getlines { + @_ == 1 or croak 'usage: $io->getlines()'; + wantarray or + croak 'Can\'t call $io->getlines in a scalar context, use $io->getline'; + my $this = shift; + return <$this>; +} + +sub truncate { + @_ == 2 or croak 'usage: $io->truncate(LEN)'; + truncate($_[0], $_[1]); +} + +sub read { + @_ == 3 || @_ == 4 or croak 'usage: $io->read(BUF, LEN [, OFFSET])'; + read($_[0], $_[1], $_[2], $_[3] || 0); +} + +sub sysread { + @_ == 3 || @_ == 4 or croak 'usage: $io->sysread(BUF, LEN [, OFFSET])'; + sysread($_[0], $_[1], $_[2], $_[3] || 0); +} + +sub write { + @_ >= 2 && @_ <= 4 or croak 'usage: $io->write(BUF [, LEN [, OFFSET]])'; + local($\) = ""; + $_[2] = length($_[1]) unless defined $_[2]; + print { $_[0] } substr($_[1], $_[3] || 0, $_[2]); +} + +sub syswrite { + @_ >= 2 && @_ <= 4 or croak 'usage: $io->syswrite(BUF [, LEN [, OFFSET]])'; + if (defined($_[2])) { + syswrite($_[0], $_[1], $_[2], $_[3] || 0); + } else { + syswrite($_[0], $_[1]); + } +} + +sub stat { + @_ == 1 or croak 'usage: $io->stat()'; + stat($_[0]); +} + +################################################ +## State modification functions. +## + +sub autoflush { + my $old = new SelectSaver qualify($_[0], caller); + my $prev = $|; + $| = @_ > 1 ? $_[1] : 1; + $prev; +} + +sub output_field_separator { + carp "output_field_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $,; + $, = $_[1] if @_ > 1; + $prev; +} + +sub output_record_separator { + carp "output_record_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $\; + $\ = $_[1] if @_ > 1; + $prev; +} + +sub input_record_separator { + carp "input_record_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $/; + $/ = $_[1] if @_ > 1; + $prev; +} + +sub input_line_number { + local $.; + my $tell = tell qualify($_[0], caller) if ref($_[0]); + my $prev = $.; + $. = $_[1] if @_ > 1; + $prev; +} + +sub format_page_number { + my $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $%; + $% = $_[1] if @_ > 1; + $prev; +} + +sub format_lines_per_page { + my $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $=; + $= = $_[1] if @_ > 1; + $prev; +} + +sub format_lines_left { + my $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $-; + $- = $_[1] if @_ > 1; + $prev; +} + +sub format_name { + my $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $~; + $~ = qualify($_[1], caller) if @_ > 1; + $prev; +} + +sub format_top_name { + my $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $^; + $^ = qualify($_[1], caller) if @_ > 1; + $prev; +} + +sub format_line_break_characters { + carp "format_line_break_characters is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $:; + $: = $_[1] if @_ > 1; + $prev; +} + +sub format_formfeed { + carp "format_formfeed is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $^L; + $^L = $_[1] if @_ > 1; + $prev; +} + +sub formline { + my $io = shift; + my $picture = shift; + local($^A) = $^A; + local($\) = ""; + formline($picture, @_); + print $io $^A; +} + +sub format_write { + @_ < 3 || croak 'usage: $io->write( [FORMAT_NAME] )'; + if (@_ == 2) { + my ($io, $fmt) = @_; + my $oldfmt = $io->format_name($fmt); + CORE::write($io); + $io->format_name($oldfmt); + } else { + CORE::write($_[0]); + } +} + +# XXX undocumented +sub fcntl { + @_ == 3 || croak 'usage: $io->fcntl( OP, VALUE );'; + my ($io, $op) = @_; + return fcntl($io, $op, $_[2]); +} + +# XXX undocumented +sub ioctl { + @_ == 3 || croak 'usage: $io->ioctl( OP, VALUE );'; + my ($io, $op) = @_; + return ioctl($io, $op, $_[2]); +} + +# this sub is for compatability with older releases of IO that used +# a sub called constant to detemine if a constant existed -- GMB +# +# The SEEK_* and _IO?BF constants were the only constants at that time +# any new code should just chech defined(&CONSTANT_NAME) + +sub constant { + no strict 'refs'; + my $name = shift; + (($name =~ /^(SEEK_(SET|CUR|END)|_IO[FLN]BF)$/) && defined &{$name}) + ? &{$name}() : undef; +} + + +# so that flush.pl can be deprecated + +sub printflush { + my $io = shift; + my $old = new SelectSaver qualify($io, caller) if ref($io); + local $| = 1; + if(ref($io)) { + print $io @_; + } + else { + print @_; + } +} + +1; diff --git a/Master/xemtex/perl/lib/IO/Seekable.pm b/Master/xemtex/perl/lib/IO/Seekable.pm new file mode 100644 index 00000000000..2ddee4d53ce --- /dev/null +++ b/Master/xemtex/perl/lib/IO/Seekable.pm @@ -0,0 +1,128 @@ +# + +package IO::Seekable; + +=head1 NAME + +IO::Seekable - supply seek based methods for I/O objects + +=head1 SYNOPSIS + + use IO::Seekable; + package IO::Something; + @ISA = qw(IO::Seekable); + +=head1 DESCRIPTION + +C<IO::Seekable> does not have a constructor of its own as it is intended to +be inherited by other C<IO::Handle> based objects. It provides methods +which allow seeking of the file descriptors. + +=over 4 + +=item $io->getpos + +Returns an opaque value that represents the current position of the +IO::File, or C<undef> if this is not possible (eg an unseekable stream such +as a terminal, pipe or socket). If the fgetpos() function is available in +your C library it is used to implements getpos, else perl emulates getpos +using C's ftell() function. + +=item $io->setpos + +Uses the value of a previous getpos call to return to a previously visited +position. Returns "0 but true" on success, C<undef> on failure. + +=back + +See L<perlfunc> for complete descriptions of each of the following +supported C<IO::Seekable> methods, which are just front ends for the +corresponding built-in functions: + +=over 4 + +=item $io->seek ( POS, WHENCE ) + +Seek the IO::File to position POS, relative to WHENCE: + +=over 8 + +=item WHENCE=0 (SEEK_SET) + +POS is absolute position. (Seek relative to the start of the file) + +=item WHENCE=1 (SEEK_CUR) + +POS is an offset from the current position. (Seek relative to current) + +=item WHENCE=2 (SEEK_END) + +POS is an offset from the end of the file. (Seek relative to end) + +=back + +The SEEK_* constants can be imported from the C<Fcntl> module if you +don't wish to use the numbers C<0> C<1> or C<2> in your code. + +Returns C<1> upon success, C<0> otherwise. + +=item $io->sysseek( POS, WHENCE ) + +Similar to $io->seek, but sets the IO::File's position using the system +call lseek(2) directly, so will confuse most perl IO operators except +sysread and syswrite (see L<perlfunc> for full details) + +Returns the new position, or C<undef> on failure. A position +of zero is returned as the string C<"0 but true"> + +=item $io->tell + +Returns the IO::File's current position, or -1 on error. + +=back + +=head1 SEE ALSO + +L<perlfunc>, +L<perlop/"I/O Operators">, +L<IO::Handle> +L<IO::File> + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr E<lt>gbarr@pobox.comE<gt> + +=cut + +use 5.006_001; +use Carp; +use strict; +our($VERSION, @EXPORT, @ISA); +use IO::Handle (); +# XXX we can't get these from IO::Handle or we'll get prototype +# mismatch warnings on C<use POSIX; use IO::File;> :-( +use Fcntl qw(SEEK_SET SEEK_CUR SEEK_END); +require Exporter; + +@EXPORT = qw(SEEK_SET SEEK_CUR SEEK_END); +@ISA = qw(Exporter); + +$VERSION = "1.08_00"; +$VERSION = eval $VERSION; + +sub seek { + @_ == 3 or croak 'usage: $io->seek(POS, WHENCE)'; + seek($_[0], $_[1], $_[2]); +} + +sub sysseek { + @_ == 3 or croak 'usage: $io->sysseek(POS, WHENCE)'; + sysseek($_[0], $_[1], $_[2]); +} + +sub tell { + @_ == 1 or croak 'usage: $io->tell()'; + tell($_[0]); +} + +1; diff --git a/Master/xemtex/perl/lib/List/Util.pm b/Master/xemtex/perl/lib/List/Util.pm new file mode 100644 index 00000000000..7686ffe82cd --- /dev/null +++ b/Master/xemtex/perl/lib/List/Util.pm @@ -0,0 +1,194 @@ +# List::Util.pm +# +# Copyright (c) 1997-2001 Graham Barr <gbarr@pobox.com>. All rights reserved. +# This program is free software; you can redistribute it and/or +# modify it under the same terms as Perl itself. + +package List::Util; + +require Exporter; +require DynaLoader; + +our @ISA = qw(Exporter DynaLoader); +our @EXPORT_OK = qw(first min max minstr maxstr reduce sum shuffle); +our $VERSION = "1.07_00"; +our $XS_VERSION = $VERSION; +$VERSION = eval $VERSION; + +bootstrap List::Util $XS_VERSION; + +1; + +__END__ + +=head1 NAME + +List::Util - A selection of general-utility list subroutines + +=head1 SYNOPSIS + + use List::Util qw(first max maxstr min minstr reduce shuffle sum); + +=head1 DESCRIPTION + +C<List::Util> contains a selection of subroutines that people have +expressed would be nice to have in the perl core, but the usage would +not really be high enough to warrant the use of a keyword, and the size +so small such that being individual extensions would be wasteful. + +By default C<List::Util> does not export any subroutines. The +subroutines defined are + +=over 4 + +=item first BLOCK LIST + +Similar to C<grep> in that it evaluates BLOCK setting C<$_> to each element +of LIST in turn. C<first> returns the first element where the result from +BLOCK is a true value. If BLOCK never returns true or LIST was empty then +C<undef> is returned. + + $foo = first { defined($_) } @list # first defined value in @list + $foo = first { $_ > $value } @list # first value in @list which + # is greater than $value + +This function could be implemented using C<reduce> like this + + $foo = reduce { defined($a) ? $a : wanted($b) ? $b : undef } undef, @list + +for example wanted() could be defined() which would return the first +defined value in @list + +=item max LIST + +Returns the entry in the list with the highest numerical value. If the +list is empty then C<undef> is returned. + + $foo = max 1..10 # 10 + $foo = max 3,9,12 # 12 + $foo = max @bar, @baz # whatever + +This function could be implemented using C<reduce> like this + + $foo = reduce { $a > $b ? $a : $b } 1..10 + +=item maxstr LIST + +Similar to C<max>, but treats all the entries in the list as strings +and returns the highest string as defined by the C<gt> operator. +If the list is empty then C<undef> is returned. + + $foo = maxstr 'A'..'Z' # 'Z' + $foo = maxstr "hello","world" # "world" + $foo = maxstr @bar, @baz # whatever + +This function could be implemented using C<reduce> like this + + $foo = reduce { $a gt $b ? $a : $b } 'A'..'Z' + +=item min LIST + +Similar to C<max> but returns the entry in the list with the lowest +numerical value. If the list is empty then C<undef> is returned. + + $foo = min 1..10 # 1 + $foo = min 3,9,12 # 3 + $foo = min @bar, @baz # whatever + +This function could be implemented using C<reduce> like this + + $foo = reduce { $a < $b ? $a : $b } 1..10 + +=item minstr LIST + +Similar to C<min>, but treats all the entries in the list as strings +and returns the lowest string as defined by the C<lt> operator. +If the list is empty then C<undef> is returned. + + $foo = minstr 'A'..'Z' # 'A' + $foo = minstr "hello","world" # "hello" + $foo = minstr @bar, @baz # whatever + +This function could be implemented using C<reduce> like this + + $foo = reduce { $a lt $b ? $a : $b } 'A'..'Z' + +=item reduce BLOCK LIST + +Reduces LIST by calling BLOCK multiple times, setting C<$a> and C<$b> +each time. The first call will be with C<$a> and C<$b> set to the first +two elements of the list, subsequent calls will be done by +setting C<$a> to the result of the previous call and C<$b> to the next +element in the list. + +Returns the result of the last call to BLOCK. If LIST is empty then +C<undef> is returned. If LIST only contains one element then that +element is returned and BLOCK is not executed. + + $foo = reduce { $a < $b ? $a : $b } 1..10 # min + $foo = reduce { $a lt $b ? $a : $b } 'aa'..'zz' # minstr + $foo = reduce { $a + $b } 1 .. 10 # sum + $foo = reduce { $a . $b } @bar # concat + +=item shuffle LIST + +Returns the elements of LIST in a random order + + @cards = shuffle 0..51 # 0..51 in a random order + +=item sum LIST + +Returns the sum of all the elements in LIST. + + $foo = sum 1..10 # 55 + $foo = sum 3,9,12 # 24 + $foo = sum @bar, @baz # whatever + +This function could be implemented using C<reduce> like this + + $foo = reduce { $a + $b } 1..10 + +=back + +=head1 KNOWN BUGS + +With perl versions prior to 5.005 there are some cases where reduce +will return an incorrect result. This will show up as test 7 of +reduce.t failing. + +=head1 SUGGESTED ADDITIONS + +The following are additions that have been requested, but I have been reluctant +to add due to them being very simple to implement in perl + + # One argument is true + + sub any { $_ && return 1 for @_; 0 } + + # All arguments are true + + sub all { $_ || return 0 for @_; 1 } + + # All arguments are false + + sub none { $_ && return 0 for @_; 1 } + + # One argument is false + + sub notall { $_ || return 1 for @_; 0 } + + # How many elements are true + + sub true { scalar grep { $_ } @_ } + + # How many elements are false + + sub false { scalar grep { !$_ } @_ } + +=head1 COPYRIGHT + +Copyright (c) 1997-2001 Graham Barr <gbarr@pobox.com>. All rights reserved. +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut diff --git a/Master/xemtex/perl/lib/POSIX.pm b/Master/xemtex/perl/lib/POSIX.pm new file mode 100644 index 00000000000..05634f01322 --- /dev/null +++ b/Master/xemtex/perl/lib/POSIX.pm @@ -0,0 +1,950 @@ +package POSIX; + +our(@ISA, %EXPORT_TAGS, @EXPORT_OK, $AUTOLOAD) = (); + +use AutoLoader; + +use XSLoader (); + +our $VERSION = "1.05" ; + +# Grandfather old foo_h form to new :foo_h form +my $loaded; + +sub import { + load_imports() unless $loaded++; + my $this = shift; + my @list = map { m/^\w+_h$/ ? ":$_" : $_ } @_; + local $Exporter::ExportLevel = 1; + Exporter::import($this,@list); +} + +sub croak { require Carp; goto &Carp::croak } +# declare usage to assist AutoLoad +sub usage; + +XSLoader::load 'POSIX', $VERSION; + +my %NON_CONSTS = (map {($_,1)} + qw(S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG WEXITSTATUS + WIFEXITED WIFSIGNALED WIFSTOPPED WSTOPSIG WTERMSIG)); + +sub AUTOLOAD { + if ($AUTOLOAD =~ /::(_?[a-z])/) { + # require AutoLoader; + $AutoLoader::AUTOLOAD = $AUTOLOAD; + goto &AutoLoader::AUTOLOAD + } + local $! = 0; + my $constname = $AUTOLOAD; + $constname =~ s/.*:://; + if ($NON_CONSTS{$constname}) { + my ($val, $error) = &int_macro_int($constname, $_[0]); + croak $error if $error; + *$AUTOLOAD = sub { &int_macro_int($constname, $_[0]) }; + } else { + my ($error, $val) = constant($constname); + croak $error if $error; + *$AUTOLOAD = sub { $val }; + } + + goto &$AUTOLOAD; +} + +sub POSIX::SigAction::new { + bless {HANDLER => $_[1], MASK => $_[2], FLAGS => $_[3] || 0}, $_[0]; +} + +1; +__END__ + +sub usage { + my ($mess) = @_; + croak "Usage: POSIX::$mess"; +} + +sub redef { + my ($mess) = @_; + croak "Use method $mess instead"; +} + +sub unimpl { + my ($mess) = @_; + $mess =~ s/xxx//; + croak "Unimplemented: POSIX::$mess"; +} + +sub assert { + usage "assert(expr)" if @_ != 1; + if (!$_[0]) { + croak "Assertion failed"; + } +} + +sub tolower { + usage "tolower(string)" if @_ != 1; + lc($_[0]); +} + +sub toupper { + usage "toupper(string)" if @_ != 1; + uc($_[0]); +} + +sub closedir { + usage "closedir(dirhandle)" if @_ != 1; + CORE::closedir($_[0]); +} + +sub opendir { + usage "opendir(directory)" if @_ != 1; + my $dirhandle; + CORE::opendir($dirhandle, $_[0]) + ? $dirhandle + : undef; +} + +sub readdir { + usage "readdir(dirhandle)" if @_ != 1; + CORE::readdir($_[0]); +} + +sub rewinddir { + usage "rewinddir(dirhandle)" if @_ != 1; + CORE::rewinddir($_[0]); +} + +sub errno { + usage "errno()" if @_ != 0; + $! + 0; +} + +sub creat { + usage "creat(filename, mode)" if @_ != 2; + &open($_[0], &O_WRONLY | &O_CREAT | &O_TRUNC, $_[1]); +} + +sub fcntl { + usage "fcntl(filehandle, cmd, arg)" if @_ != 3; + CORE::fcntl($_[0], $_[1], $_[2]); +} + +sub getgrgid { + usage "getgrgid(gid)" if @_ != 1; + CORE::getgrgid($_[0]); +} + +sub getgrnam { + usage "getgrnam(name)" if @_ != 1; + CORE::getgrnam($_[0]); +} + +sub atan2 { + usage "atan2(x,y)" if @_ != 2; + CORE::atan2($_[0], $_[1]); +} + +sub cos { + usage "cos(x)" if @_ != 1; + CORE::cos($_[0]); +} + +sub exp { + usage "exp(x)" if @_ != 1; + CORE::exp($_[0]); +} + +sub fabs { + usage "fabs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +sub log { + usage "log(x)" if @_ != 1; + CORE::log($_[0]); +} + +sub pow { + usage "pow(x,exponent)" if @_ != 2; + $_[0] ** $_[1]; +} + +sub sin { + usage "sin(x)" if @_ != 1; + CORE::sin($_[0]); +} + +sub sqrt { + usage "sqrt(x)" if @_ != 1; + CORE::sqrt($_[0]); +} + +sub getpwnam { + usage "getpwnam(name)" if @_ != 1; + CORE::getpwnam($_[0]); +} + +sub getpwuid { + usage "getpwuid(uid)" if @_ != 1; + CORE::getpwuid($_[0]); +} + +sub longjmp { + unimpl "longjmp() is C-specific: use die instead"; +} + +sub setjmp { + unimpl "setjmp() is C-specific: use eval {} instead"; +} + +sub siglongjmp { + unimpl "siglongjmp() is C-specific: use die instead"; +} + +sub sigsetjmp { + unimpl "sigsetjmp() is C-specific: use eval {} instead"; +} + +sub kill { + usage "kill(pid, sig)" if @_ != 2; + CORE::kill $_[1], $_[0]; +} + +sub raise { + usage "raise(sig)" if @_ != 1; + CORE::kill $_[0], $$; # Is this good enough? +} + +sub offsetof { + unimpl "offsetof() is C-specific, stopped"; +} + +sub clearerr { + redef "IO::Handle::clearerr()"; +} + +sub fclose { + redef "IO::Handle::close()"; +} + +sub fdopen { + redef "IO::Handle::new_from_fd()"; +} + +sub feof { + redef "IO::Handle::eof()"; +} + +sub fgetc { + redef "IO::Handle::getc()"; +} + +sub fgets { + redef "IO::Handle::gets()"; +} + +sub fileno { + redef "IO::Handle::fileno()"; +} + +sub fopen { + redef "IO::File::open()"; +} + +sub fprintf { + unimpl "fprintf() is C-specific--use printf instead"; +} + +sub fputc { + unimpl "fputc() is C-specific--use print instead"; +} + +sub fputs { + unimpl "fputs() is C-specific--use print instead"; +} + +sub fread { + unimpl "fread() is C-specific--use read instead"; +} + +sub freopen { + unimpl "freopen() is C-specific--use open instead"; +} + +sub fscanf { + unimpl "fscanf() is C-specific--use <> and regular expressions instead"; +} + +sub fseek { + redef "IO::Seekable::seek()"; +} + +sub ferror { + redef "IO::Handle::error()"; +} + +sub fflush { + redef "IO::Handle::flush()"; +} + +sub fgetpos { + redef "IO::Seekable::getpos()"; +} + +sub fsetpos { + redef "IO::Seekable::setpos()"; +} + +sub ftell { + redef "IO::Seekable::tell()"; +} + +sub fwrite { + unimpl "fwrite() is C-specific--use print instead"; +} + +sub getc { + usage "getc(handle)" if @_ != 1; + CORE::getc($_[0]); +} + +sub getchar { + usage "getchar()" if @_ != 0; + CORE::getc(STDIN); +} + +sub gets { + usage "gets()" if @_ != 0; + scalar <STDIN>; +} + +sub perror { + print STDERR "@_: " if @_; + print STDERR $!,"\n"; +} + +sub printf { + usage "printf(pattern, args...)" if @_ < 1; + CORE::printf STDOUT @_; +} + +sub putc { + unimpl "putc() is C-specific--use print instead"; +} + +sub putchar { + unimpl "putchar() is C-specific--use print instead"; +} + +sub puts { + unimpl "puts() is C-specific--use print instead"; +} + +sub remove { + usage "remove(filename)" if @_ != 1; + CORE::unlink($_[0]); +} + +sub rename { + usage "rename(oldfilename, newfilename)" if @_ != 2; + CORE::rename($_[0], $_[1]); +} + +sub rewind { + usage "rewind(filehandle)" if @_ != 1; + CORE::seek($_[0],0,0); +} + +sub scanf { + unimpl "scanf() is C-specific--use <> and regular expressions instead"; +} + +sub sprintf { + usage "sprintf(pattern,args)" if @_ == 0; + CORE::sprintf(shift,@_); +} + +sub sscanf { + unimpl "sscanf() is C-specific--use regular expressions instead"; +} + +sub tmpfile { + redef "IO::File::new_tmpfile()"; +} + +sub ungetc { + redef "IO::Handle::ungetc()"; +} + +sub vfprintf { + unimpl "vfprintf() is C-specific"; +} + +sub vprintf { + unimpl "vprintf() is C-specific"; +} + +sub vsprintf { + unimpl "vsprintf() is C-specific"; +} + +sub abs { + usage "abs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +sub atexit { + unimpl "atexit() is C-specific: use END {} instead"; +} + +sub atof { + unimpl "atof() is C-specific, stopped"; +} + +sub atoi { + unimpl "atoi() is C-specific, stopped"; +} + +sub atol { + unimpl "atol() is C-specific, stopped"; +} + +sub bsearch { + unimpl "bsearch() not supplied"; +} + +sub calloc { + unimpl "calloc() is C-specific, stopped"; +} + +sub div { + unimpl "div() is C-specific, stopped"; +} + +sub exit { + usage "exit(status)" if @_ != 1; + CORE::exit($_[0]); +} + +sub free { + unimpl "free() is C-specific, stopped"; +} + +sub getenv { + usage "getenv(name)" if @_ != 1; + $ENV{$_[0]}; +} + +sub labs { + unimpl "labs() is C-specific, use abs instead"; +} + +sub ldiv { + unimpl "ldiv() is C-specific, use / and int instead"; +} + +sub malloc { + unimpl "malloc() is C-specific, stopped"; +} + +sub qsort { + unimpl "qsort() is C-specific, use sort instead"; +} + +sub rand { + unimpl "rand() is non-portable, use Perl's rand instead"; +} + +sub realloc { + unimpl "realloc() is C-specific, stopped"; +} + +sub srand { + unimpl "srand()"; +} + +sub system { + usage "system(command)" if @_ != 1; + CORE::system($_[0]); +} + +sub memchr { + unimpl "memchr() is C-specific, use index() instead"; +} + +sub memcmp { + unimpl "memcmp() is C-specific, use eq instead"; +} + +sub memcpy { + unimpl "memcpy() is C-specific, use = instead"; +} + +sub memmove { + unimpl "memmove() is C-specific, use = instead"; +} + +sub memset { + unimpl "memset() is C-specific, use x instead"; +} + +sub strcat { + unimpl "strcat() is C-specific, use .= instead"; +} + +sub strchr { + unimpl "strchr() is C-specific, use index() instead"; +} + +sub strcmp { + unimpl "strcmp() is C-specific, use eq instead"; +} + +sub strcpy { + unimpl "strcpy() is C-specific, use = instead"; +} + +sub strcspn { + unimpl "strcspn() is C-specific, use regular expressions instead"; +} + +sub strerror { + usage "strerror(errno)" if @_ != 1; + local $! = $_[0]; + $! . ""; +} + +sub strlen { + unimpl "strlen() is C-specific, use length instead"; +} + +sub strncat { + unimpl "strncat() is C-specific, use .= instead"; +} + +sub strncmp { + unimpl "strncmp() is C-specific, use eq instead"; +} + +sub strncpy { + unimpl "strncpy() is C-specific, use = instead"; +} + +sub strpbrk { + unimpl "strpbrk() is C-specific, stopped"; +} + +sub strrchr { + unimpl "strrchr() is C-specific, use rindex() instead"; +} + +sub strspn { + unimpl "strspn() is C-specific, stopped"; +} + +sub strstr { + usage "strstr(big, little)" if @_ != 2; + CORE::index($_[0], $_[1]); +} + +sub strtok { + unimpl "strtok() is C-specific, stopped"; +} + +sub chmod { + usage "chmod(mode, filename)" if @_ != 2; + CORE::chmod($_[0], $_[1]); +} + +sub fstat { + usage "fstat(fd)" if @_ != 1; + local *TMP; + CORE::open(TMP, "<&$_[0]"); # Gross. + my @l = CORE::stat(TMP); + CORE::close(TMP); + @l; +} + +sub mkdir { + usage "mkdir(directoryname, mode)" if @_ != 2; + CORE::mkdir($_[0], $_[1]); +} + +sub stat { + usage "stat(filename)" if @_ != 1; + CORE::stat($_[0]); +} + +sub umask { + usage "umask(mask)" if @_ != 1; + CORE::umask($_[0]); +} + +sub wait { + usage "wait()" if @_ != 0; + CORE::wait(); +} + +sub waitpid { + usage "waitpid(pid, options)" if @_ != 2; + CORE::waitpid($_[0], $_[1]); +} + +sub gmtime { + usage "gmtime(time)" if @_ != 1; + CORE::gmtime($_[0]); +} + +sub localtime { + usage "localtime(time)" if @_ != 1; + CORE::localtime($_[0]); +} + +sub time { + usage "time()" if @_ != 0; + CORE::time; +} + +sub alarm { + usage "alarm(seconds)" if @_ != 1; + CORE::alarm($_[0]); +} + +sub chdir { + usage "chdir(directory)" if @_ != 1; + CORE::chdir($_[0]); +} + +sub chown { + usage "chown(filename, uid, gid)" if @_ != 3; + CORE::chown($_[0], $_[1], $_[2]); +} + +sub execl { + unimpl "execl() is C-specific, stopped"; +} + +sub execle { + unimpl "execle() is C-specific, stopped"; +} + +sub execlp { + unimpl "execlp() is C-specific, stopped"; +} + +sub execv { + unimpl "execv() is C-specific, stopped"; +} + +sub execve { + unimpl "execve() is C-specific, stopped"; +} + +sub execvp { + unimpl "execvp() is C-specific, stopped"; +} + +sub fork { + usage "fork()" if @_ != 0; + CORE::fork; +} + +sub getegid { + usage "getegid()" if @_ != 0; + $) + 0; +} + +sub geteuid { + usage "geteuid()" if @_ != 0; + $> + 0; +} + +sub getgid { + usage "getgid()" if @_ != 0; + $( + 0; +} + +sub getgroups { + usage "getgroups()" if @_ != 0; + my %seen; + grep(!$seen{$_}++, split(' ', $) )); +} + +sub getlogin { + usage "getlogin()" if @_ != 0; + CORE::getlogin(); +} + +sub getpgrp { + usage "getpgrp()" if @_ != 0; + CORE::getpgrp; +} + +sub getpid { + usage "getpid()" if @_ != 0; + $$; +} + +sub getppid { + usage "getppid()" if @_ != 0; + CORE::getppid; +} + +sub getuid { + usage "getuid()" if @_ != 0; + $<; +} + +sub isatty { + usage "isatty(filehandle)" if @_ != 1; + -t $_[0]; +} + +sub link { + usage "link(oldfilename, newfilename)" if @_ != 2; + CORE::link($_[0], $_[1]); +} + +sub rmdir { + usage "rmdir(directoryname)" if @_ != 1; + CORE::rmdir($_[0]); +} + +sub setbuf { + redef "IO::Handle::setbuf()"; +} + +sub setvbuf { + redef "IO::Handle::setvbuf()"; +} + +sub sleep { + usage "sleep(seconds)" if @_ != 1; + $_[0] - CORE::sleep($_[0]); +} + +sub unlink { + usage "unlink(filename)" if @_ != 1; + CORE::unlink($_[0]); +} + +sub utime { + usage "utime(filename, atime, mtime)" if @_ != 3; + CORE::utime($_[1], $_[2], $_[0]); +} + +sub load_imports { +%EXPORT_TAGS = ( + + assert_h => [qw(assert NDEBUG)], + + ctype_h => [qw(isalnum isalpha iscntrl isdigit isgraph islower + isprint ispunct isspace isupper isxdigit tolower toupper)], + + dirent_h => [], + + errno_h => [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT + EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED + ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT + EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS + EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH + ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM + ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR + ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM + EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE + ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT + ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY + EUSERS EWOULDBLOCK EXDEV errno)], + + fcntl_h => [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK + F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK + O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK + O_RDONLY O_RDWR O_TRUNC O_WRONLY + creat + SEEK_CUR SEEK_END SEEK_SET + S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID + S_IWGRP S_IWOTH S_IWUSR)], + + float_h => [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG + DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP + DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP + FLT_DIG FLT_EPSILON FLT_MANT_DIG + FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP + FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP + FLT_RADIX FLT_ROUNDS + LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG + LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP + LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)], + + grp_h => [], + + limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX + INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON + MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX + PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN + SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX + ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX + _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT + _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX + _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX + _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)], + + locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES + LC_MONETARY LC_NUMERIC LC_TIME NULL + localeconv setlocale)], + + math_h => [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod + frexp ldexp log10 modf pow sinh tan tanh)], + + pwd_h => [], + + setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)], + + signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK + SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM + SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL + SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN + SIGTTOU SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR + SIG_IGN SIG_SETMASK SIG_UNBLOCK raise sigaction signal + sigpending sigprocmask sigsuspend)], + + stdarg_h => [], + + stddef_h => [qw(NULL offsetof)], + + stdio_h => [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid + L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET + STREAM_MAX TMP_MAX stderr stdin stdout + clearerr fclose fdopen feof ferror fflush fgetc fgetpos + fgets fopen fprintf fputc fputs fread freopen + fscanf fseek fsetpos ftell fwrite getchar gets + perror putc putchar puts remove rewind + scanf setbuf setvbuf sscanf tmpfile tmpnam + ungetc vfprintf vprintf vsprintf)], + + stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX + abort atexit atof atoi atol bsearch calloc div + free getenv labs ldiv malloc mblen mbstowcs mbtowc + qsort realloc strtod strtol strtoul wcstombs wctomb)], + + string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat + strchr strcmp strcoll strcpy strcspn strerror strlen + strncat strncmp strncpy strpbrk strrchr strspn strstr + strtok strxfrm)], + + sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG + S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + fstat mkfifo)], + + sys_times_h => [], + + sys_types_h => [], + + sys_utsname_h => [qw(uname)], + + sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED + WNOHANG WSTOPSIG WTERMSIG WUNTRACED)], + + termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400 + B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL + CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK + ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR + INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST + PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION + TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW + TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART + VSTOP VSUSP VTIME + cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain + tcflow tcflush tcgetattr tcsendbreak tcsetattr )], + + time_h => [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime + difftime mktime strftime tzset tzname)], + + unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET + STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK + _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON + _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX + _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED + _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS + _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX + _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL + _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS + _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + _exit access ctermid cuserid + dup2 dup execl execle execlp execv execve execvp + fpathconf getcwd getegid geteuid getgid getgroups + getpid getuid isatty lseek pathconf pause setgid setpgid + setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)], + + utime_h => [], + +); + +# Exporter::export_tags(); +for (values %EXPORT_TAGS) { + push @EXPORT, @$_; +} + +@EXPORT_OK = qw( + abs + alarm + atan2 + chdir + chmod + chown + close + closedir + cos + exit + exp + fcntl + fileno + fork + getc + getgrgid + getgrnam + getlogin + getpgrp + getppid + getpwnam + getpwuid + gmtime + isatty + kill + link + localtime + log + mkdir + nice + open + opendir + pipe + printf + rand + read + readdir + rename + rewinddir + rmdir + sin + sleep + sprintf + sqrt + srand + stat + system + time + times + umask + unlink + utime + wait + waitpid + write +); + +require Exporter; +} diff --git a/Master/xemtex/perl/lib/SDBM_File.pm b/Master/xemtex/perl/lib/SDBM_File.pm new file mode 100644 index 00000000000..ee82a54145d --- /dev/null +++ b/Master/xemtex/perl/lib/SDBM_File.pm @@ -0,0 +1,116 @@ +package SDBM_File; + +use strict; +use warnings; + +require Tie::Hash; +use XSLoader (); + +our @ISA = qw(Tie::Hash); +our $VERSION = "1.03" ; + +XSLoader::load 'SDBM_File', $VERSION; + +1; + +__END__ + +=head1 NAME + +SDBM_File - Tied access to sdbm files + +=head1 SYNOPSIS + + use Fcntl; # For O_RDWR, O_CREAT, etc. + use SDBM_File; + + tie(%h, 'SDBM_File', 'filename', O_RDWR|O_CREAT, 0666) + or die "Couldn't tie SDBM file 'filename': $!; aborting"; + + # Now read and change the hash + $h{newkey} = newvalue; + print $h{oldkey}; + ... + + untie %h; + +=head1 DESCRIPTION + +C<SDBM_File> establishes a connection between a Perl hash variable and +a file in SDBM_File format;. You can manipulate the data in the file +just as if it were in a Perl hash, but when your program exits, the +data will remain in the file, to be used the next time your program +runs. + +Use C<SDBM_File> with the Perl built-in C<tie> function to establish +the connection between the variable and the file. The arguments to +C<tie> should be: + +=over 4 + +=item 1. + +The hash variable you want to tie. + +=item 2. + +The string C<"SDBM_File">. (Ths tells Perl to use the C<SDBM_File> +package to perform the functions of the hash.) + +=item 3. + +The name of the file you want to tie to the hash. + +=item 4. + +Flags. Use one of: + +=over 2 + +=item C<O_RDONLY> + +Read-only access to the data in the file. + +=item C<O_WRONLY> + +Write-only access to the data in the file. + +=item C<O_RDWR> + +Both read and write access. + +=back + +If you want to create the file if it does not exist, add C<O_CREAT> to +any of these, as in the example. If you omit C<O_CREAT> and the file +does not already exist, the C<tie> call will fail. + +=item 5. + +The default permissions to use if a new file is created. The actual +permissions will be modified by the user's umask, so you should +probably use 0666 here. (See L<perlfunc/umask>.) + +=back + +=head1 DIAGNOSTICS + +On failure, the C<tie> call returns an undefined value and probably +sets C<$!> to contain the reason the file could not be tied. + +=head2 C<sdbm store returned -1, errno 22, key "..." at ...> + +This warning is emmitted when you try to store a key or a value that +is too long. It means that the change was not recorded in the +database. See BUGS AND WARNINGS below. + +=head1 BUGS AND WARNINGS + +There are a number of limits on the size of the data that you can +store in the SDBM file. The most important is that the length of a +key, plus the length of its associated value, may not exceed 1008 +bytes. + +See L<perlfunc/tie>, L<perldbmfilter>, L<Fcntl> + +=cut diff --git a/Master/xemtex/perl/lib/Scalar/Util.pm b/Master/xemtex/perl/lib/Scalar/Util.pm new file mode 100644 index 00000000000..e518a4c445a --- /dev/null +++ b/Master/xemtex/perl/lib/Scalar/Util.pm @@ -0,0 +1,170 @@ +# Scalar::Util.pm +# +# Copyright (c) 1997-2001 Graham Barr <gbarr@pobox.com>. All rights reserved. +# This program is free software; you can redistribute it and/or +# modify it under the same terms as Perl itself. + +package Scalar::Util; + +require Exporter; +require List::Util; # List::Util loads the XS + +our @ISA = qw(Exporter); +our @EXPORT_OK = qw(blessed dualvar reftype weaken isweak tainted readonly openhandle); +our $VERSION = $List::Util::VERSION; + +sub openhandle ($) { + my $fh = shift; + my $rt = reftype($fh) || ''; + + return defined(fileno($fh)) ? $fh : undef + if $rt eq 'IO'; + + if (reftype(\$fh) eq 'GLOB') { # handle openhandle(*DATA) + $fh = \(my $tmp=$fh); + } + elsif ($rt ne 'GLOB') { + return undef; + } + + (tied(*$fh) or defined(fileno($fh))) + ? $fh : undef; +} + +1; + +__END__ + +=head1 NAME + +Scalar::Util - A selection of general-utility scalar subroutines + +=head1 SYNOPSIS + + use Scalar::Util qw(blessed dualvar isweak readonly reftype tainted weaken); + +=head1 DESCRIPTION + +C<Scalar::Util> contains a selection of subroutines that people have +expressed would be nice to have in the perl core, but the usage would +not really be high enough to warrant the use of a keyword, and the size +so small such that being individual extensions would be wasteful. + +By default C<Scalar::Util> does not export any subroutines. The +subroutines defined are + +=over 4 + +=item blessed EXPR + +If EXPR evaluates to a blessed reference the name of the package +that it is blessed into is returned. Otherwise C<undef> is returned. + + $scalar = "foo"; + $class = blessed $scalar; # undef + + $ref = []; + $class = blessed $ref; # undef + + $obj = bless [], "Foo"; + $class = blessed $obj; # "Foo" + +=item dualvar NUM, STRING + +Returns a scalar that has the value NUM in a numeric context and the +value STRING in a string context. + + $foo = dualvar 10, "Hello"; + $num = $foo + 2; # 12 + $str = $foo . " world"; # Hello world + +=item isweak EXPR + +If EXPR is a scalar which is a weak reference the result is true. + + $ref = \$foo; + $weak = isweak($ref); # false + weaken($ref); + $weak = isweak($ref); # true + +=item openhandle FH + +Returns FH if FH may be used as a filehandle and is open, or FH is a tied +handle. Otherwise C<undef> is returned. + + $fh = openhandle(*STDIN); # \*STDIN + $fh = openhandle(\*STDIN); # \*STDIN + $fh = openhandle(*NOTOPEN); # undef + $fh = openhandle("scalar"); # undef + +=item readonly SCALAR + +Returns true if SCALAR is readonly. + + sub foo { readonly($_[0]) } + + $readonly = foo($bar); # false + $readonly = foo(0); # true + +=item reftype EXPR + +If EXPR evaluates to a reference the type of the variable referenced +is returned. Otherwise C<undef> is returned. + + $type = reftype "string"; # undef + $type = reftype \$var; # SCALAR + $type = reftype []; # ARRAY + + $obj = bless {}, "Foo"; + $type = reftype $obj; # HASH + +=item tainted EXPR + +Return true if the result of EXPR is tainted + + $taint = tainted("constant"); # false + $taint = tainted($ENV{PWD}); # true if running under -T + +=item weaken REF + +REF will be turned into a weak reference. This means that it will not +hold a reference count on the object it references. Also when the reference +count on that object reaches zero, REF will be set to undef. + +This is useful for keeping copies of references , but you don't want to +prevent the object being DESTROY-ed at its usual time. + + { + my $var; + $ref = \$var; + weaken($ref); # Make $ref a weak reference + } + # $ref is now undef + +=back + +=head1 KNOWN BUGS + +There is a bug in perl5.6.0 with UV's that are >= 1<<31. This will +show up as tests 8 and 9 of dualvar.t failing + +=head1 COPYRIGHT + +Copyright (c) 1997-2001 Graham Barr <gbarr@pobox.com>. All rights reserved. +This program is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +Except weaken and isweak which are + +Copyright (c) 1999 Tuomas J. Lukka <lukka@iki.fi>. All rights reserved. +This program is free software; you can redistribute it and/or modify it +under the same terms as perl itself. + +=head1 BLATANT PLUG + +The weaken and isweak subroutines in this module and the patch to the core Perl +were written in connection with the APress book `Tuomas J. Lukka's Definitive +Guide to Object-Oriented Programming in Perl', to avoid explaining why certain +things would have to be done in cumbersome ways. + +=cut diff --git a/Master/xemtex/perl/lib/SelectSaver.pm b/Master/xemtex/perl/lib/SelectSaver.pm new file mode 100644 index 00000000000..08104f47d4c --- /dev/null +++ b/Master/xemtex/perl/lib/SelectSaver.pm @@ -0,0 +1,54 @@ +package SelectSaver; + +our $VERSION = '1.00'; + +=head1 NAME + +SelectSaver - save and restore selected file handle + +=head1 SYNOPSIS + + use SelectSaver; + + { + my $saver = new SelectSaver(FILEHANDLE); + # FILEHANDLE is selected + } + # previous handle is selected + + { + my $saver = new SelectSaver; + # new handle may be selected, or not + } + # previous handle is selected + +=head1 DESCRIPTION + +A C<SelectSaver> object contains a reference to the file handle that +was selected when it was created. If its C<new> method gets an extra +parameter, then that parameter is selected; otherwise, the selected +file handle remains unchanged. + +When a C<SelectSaver> is destroyed, it re-selects the file handle +that was selected when it was created. + +=cut + +require 5.000; +use Carp; +use Symbol; + +sub new { + @_ >= 1 && @_ <= 2 or croak 'usage: new SelectSaver [FILEHANDLE]'; + my $fh = select; + my $self = bless [$fh], $_[0]; + select qualify($_[1], caller) if @_ > 1; + $self; +} + +sub DESTROY { + my $this = $_[0]; + select $$this[0]; +} + +1; diff --git a/Master/xemtex/perl/lib/Symbol.pm b/Master/xemtex/perl/lib/Symbol.pm new file mode 100644 index 00000000000..98fb6763fe6 --- /dev/null +++ b/Master/xemtex/perl/lib/Symbol.pm @@ -0,0 +1,162 @@ +package Symbol; + +=head1 NAME + +Symbol - manipulate Perl symbols and their names + +=head1 SYNOPSIS + + use Symbol; + + $sym = gensym; + open($sym, "filename"); + $_ = <$sym>; + # etc. + + ungensym $sym; # no effect + + # replace *FOO{IO} handle but not $FOO, %FOO, etc. + *FOO = geniosym; + + print qualify("x"), "\n"; # "Test::x" + print qualify("x", "FOO"), "\n" # "FOO::x" + print qualify("BAR::x"), "\n"; # "BAR::x" + print qualify("BAR::x", "FOO"), "\n"; # "BAR::x" + print qualify("STDOUT", "FOO"), "\n"; # "main::STDOUT" (global) + print qualify(\*x), "\n"; # returns \*x + print qualify(\*x, "FOO"), "\n"; # returns \*x + + use strict refs; + print { qualify_to_ref $fh } "foo!\n"; + $ref = qualify_to_ref $name, $pkg; + + use Symbol qw(delete_package); + delete_package('Foo::Bar'); + print "deleted\n" unless exists $Foo::{'Bar::'}; + + +=head1 DESCRIPTION + +C<Symbol::gensym> creates an anonymous glob and returns a reference +to it. Such a glob reference can be used as a file or directory +handle. + +For backward compatibility with older implementations that didn't +support anonymous globs, C<Symbol::ungensym> is also provided. +But it doesn't do anything. + +C<Symbol::geniosym> creates an anonymous IO handle. This can be +assigned into an existing glob without affecting the non-IO portions +of the glob. + +C<Symbol::qualify> turns unqualified symbol names into qualified +variable names (e.g. "myvar" -E<gt> "MyPackage::myvar"). If it is given a +second parameter, C<qualify> uses it as the default package; +otherwise, it uses the package of its caller. Regardless, global +variable names (e.g. "STDOUT", "ENV", "SIG") are always qualified with +"main::". + +Qualification applies only to symbol names (strings). References are +left unchanged under the assumption that they are glob references, +which are qualified by their nature. + +C<Symbol::qualify_to_ref> is just like C<Symbol::qualify> except that it +returns a glob ref rather than a symbol name, so you can use the result +even if C<use strict 'refs'> is in effect. + +C<Symbol::delete_package> wipes out a whole package namespace. Note +this routine is not exported by default--you may want to import it +explicitly. + +=cut + +BEGIN { require 5.005; } + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(gensym ungensym qualify qualify_to_ref); +@EXPORT_OK = qw(delete_package geniosym); + +$VERSION = 1.04; + +my $genpkg = "Symbol::"; +my $genseq = 0; + +my %global = map {$_ => 1} qw(ARGV ARGVOUT ENV INC SIG STDERR STDIN STDOUT); + +# +# Note that we never _copy_ the glob; we just make a ref to it. +# If we did copy it, then SVf_FAKE would be set on the copy, and +# glob-specific behaviors (e.g. C<*$ref = \&func>) wouldn't work. +# +sub gensym () { + my $name = "GEN" . $genseq++; + my $ref = \*{$genpkg . $name}; + delete $$genpkg{$name}; + $ref; +} + +sub geniosym () { + my $sym = gensym(); + # force the IO slot to be filled + select(select $sym); + *$sym{IO}; +} + +sub ungensym ($) {} + +sub qualify ($;$) { + my ($name) = @_; + if (!ref($name) && index($name, '::') == -1 && index($name, "'") == -1) { + my $pkg; + # Global names: special character, "^xyz", or other. + if ($name =~ /^(([^a-z])|(\^[a-z_]+))\z/i || $global{$name}) { + # RGS 2001-11-05 : translate leading ^X to control-char + $name =~ s/^\^([a-z_])/'qq(\c'.$1.')'/eei; + $pkg = "main"; + } + else { + $pkg = (@_ > 1) ? $_[1] : caller; + } + $name = $pkg . "::" . $name; + } + $name; +} + +sub qualify_to_ref ($;$) { + return \*{ qualify $_[0], @_ > 1 ? $_[1] : caller }; +} + +# +# of Safe.pm lineage +# +sub delete_package ($) { + my $pkg = shift; + + # expand to full symbol table name if needed + + unless ($pkg =~ /^main::.*::$/) { + $pkg = "main$pkg" if $pkg =~ /^::/; + $pkg = "main::$pkg" unless $pkg =~ /^main::/; + $pkg .= '::' unless $pkg =~ /::$/; + } + + my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/; + my $stem_symtab = *{$stem}{HASH}; + return unless defined $stem_symtab and exists $stem_symtab->{$leaf}; + + + # free all the symbols in the package + + my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH}; + foreach my $name (keys %$leaf_symtab) { + undef *{$pkg . $name}; + } + + # delete the symbol table + + %$leaf_symtab = (); + delete $stem_symtab->{$leaf}; +} + +1; diff --git a/Master/xemtex/perl/lib/Term/Cap.pm b/Master/xemtex/perl/lib/Term/Cap.pm new file mode 100644 index 00000000000..03d2573d853 --- /dev/null +++ b/Master/xemtex/perl/lib/Term/Cap.pm @@ -0,0 +1,651 @@ +package Term::Cap; + +use Carp; +use strict; + +use vars qw($VERSION $VMS_TERMCAP); +use vars qw($termpat $state $first $entry); + +$VERSION = '1.07'; + +# Version undef: Thu Dec 14 20:02:42 CST 1995 by sanders@bsdi.com +# Version 1.00: Thu Nov 30 23:34:29 EST 2000 by schwern@pobox.com +# [PATCH] $VERSION crusade, strict, tests, etc... all over lib/ +# Version 1.01: Wed May 23 00:00:00 CST 2001 by d-lewart@uiuc.edu +# Avoid warnings in Tgetent and Tputs +# Version 1.02: Sat Nov 17 13:50:39 GMT 2001 by jns@gellyfish.com +# Altered layout of the POD +# Added Test::More to PREREQ_PM in Makefile.PL +# Fixed no argument Tgetent() +# Version 1.03: Wed Nov 28 10:09:38 GMT 2001 +# VMS Support from Charles Lane <lane@DUPHY4.Physics.Drexel.Edu> +# Version 1.04: Thu Nov 29 16:22:03 GMT 2001 +# Fixed warnings in test +# Version 1.05: Mon Dec 3 15:33:49 GMT 2001 +# Don't try to fall back on infocmp if it's not there. From chromatic. +# Version 1.06: Thu Dec 6 18:43:22 GMT 2001 +# Preload the default VMS termcap from Charles Lane +# Don't carp at setting OSPEED unless warnings are on. +# Version 1.07: Wed Jan 2 21:35:09 GMT 2002 +# Sanity check on infocmp output from Norton Allen +# Repaired INSTALLDIRS thanks to Michael Schwern + +# TODO: +# support Berkeley DB termcaps +# should probably be a .xs module +# force $FH into callers package? +# keep $FH in object at Tgetent time? + +=head1 NAME + +Term::Cap - Perl termcap interface + +=head1 SYNOPSIS + + require Term::Cap; + $terminal = Tgetent Term::Cap { TERM => undef, OSPEED => $ospeed }; + $terminal->Trequire(qw/ce ku kd/); + $terminal->Tgoto('cm', $col, $row, $FH); + $terminal->Tputs('dl', $count, $FH); + $terminal->Tpad($string, $count, $FH); + +=head1 DESCRIPTION + +These are low-level functions to extract and use capabilities from +a terminal capability (termcap) database. + +More information on the terminal capabilities will be found in the +termcap manpage on most Unix-like systems. + +=head2 METHODS + +=over 4 + +The output strings for B<Tputs> are cached for counts of 1 for performance. +B<Tgoto> and B<Tpad> do not cache. C<$self-E<gt>{_xx}> is the raw termcap +data and C<$self-E<gt>{xx}> is the cached version. + + print $terminal->Tpad($self->{_xx}, 1); + +B<Tgoto>, B<Tputs>, and B<Tpad> return the string and will also +output the string to $FH if specified. + + +=cut + +# Preload the default VMS termcap. +# If a different termcap is required then the text of one can be supplied +# in $Term::Cap::VMS_TERMCAP before Tgetent is called. + +if ( $^O eq 'VMS') { + chomp (my @entry = <DATA>); + $VMS_TERMCAP = join '', @entry; +} + +# Returns a list of termcap files to check. + +sub termcap_path { ## private + my @termcap_path; + # $TERMCAP, if it's a filespec + push(@termcap_path, $ENV{TERMCAP}) + if ((exists $ENV{TERMCAP}) && + (($^O eq 'os2' || $^O eq 'MSWin32' || $^O eq 'dos') + ? $ENV{TERMCAP} =~ /^[a-z]:[\\\/]/is + : $ENV{TERMCAP} =~ /^\//s)); + if ((exists $ENV{TERMPATH}) && ($ENV{TERMPATH})) { + # Add the users $TERMPATH + push(@termcap_path, split(/(:|\s+)/, $ENV{TERMPATH})) + } + else { + # Defaults + push(@termcap_path, + $ENV{'HOME'} . '/.termcap', + '/etc/termcap', + '/usr/share/misc/termcap', + ); + } + + # return the list of those termcaps that exist + return grep(-f, @termcap_path); +} + +=item B<Tgetent> + +Returns a blessed object reference which the user can +then use to send the control strings to the terminal using B<Tputs> +and B<Tgoto>. + +The function extracts the entry of the specified terminal +type I<TERM> (defaults to the environment variable I<TERM>) from the +database. + +It will look in the environment for a I<TERMCAP> variable. If +found, and the value does not begin with a slash, and the terminal +type name is the same as the environment string I<TERM>, the +I<TERMCAP> string is used instead of reading a termcap file. If +it does begin with a slash, the string is used as a path name of +the termcap file to search. If I<TERMCAP> does not begin with a +slash and name is different from I<TERM>, B<Tgetent> searches the +files F<$HOME/.termcap>, F</etc/termcap>, and F</usr/share/misc/termcap>, +in that order, unless the environment variable I<TERMPATH> exists, +in which case it specifies a list of file pathnames (separated by +spaces or colons) to be searched B<instead>. Whenever multiple +files are searched and a tc field occurs in the requested entry, +the entry it names must be found in the same file or one of the +succeeding files. If there is a C<:tc=...:> in the I<TERMCAP> +environment variable string it will continue the search in the +files as above. + +The extracted termcap entry is available in the object +as C<$self-E<gt>{TERMCAP}>. + +It takes a hash reference as an argument with two optional keys: + +=over 2 + +=item OSPEED + +The terminal output bit rate (often mistakenly called the baud rate) +for this terminal - if not set a warning will be generated +and it will be defaulted to 9600. I<OSPEED> can be be specified as +either a POSIX termios/SYSV termio speeds (where 9600 equals 9600) or +an old DSD-style speed ( where 13 equals 9600). + + +=item TERM + +The terminal type whose termcap entry will be used - if not supplied it will +default to $ENV{TERM}: if that is not set then B<Tgetent> will croak. + +=back + +It calls C<croak> on failure. + +=cut + +sub Tgetent { ## public -- static method + my $class = shift; + my ($self) = @_; + + $self = {} unless defined $self; + bless $self, $class; + + my($term,$cap,$search,$field,$max,$tmp_term,$TERMCAP); + local($termpat,$state,$first,$entry); # used inside eval + local $_; + + # Compute PADDING factor from OSPEED (to be used by Tpad) + if (! $self->{OSPEED}) { + if ( $^W ) { + carp "OSPEED was not set, defaulting to 9600"; + } + $self->{OSPEED} = 9600; + } + if ($self->{OSPEED} < 16) { + # delays for old style speeds + my @pad = (0,200,133.3,90.9,74.3,66.7,50,33.3,16.7,8.3,5.5,4.1,2,1,.5,.2); + $self->{PADDING} = $pad[$self->{OSPEED}]; + } + else { + $self->{PADDING} = 10000 / $self->{OSPEED}; + } + + $self->{TERM} = ($self->{TERM} || $ENV{TERM} || croak "TERM not set"); + $term = $self->{TERM}; # $term is the term type we are looking for + + # $tmp_term is always the next term (possibly :tc=...:) we are looking for + $tmp_term = $self->{TERM}; + # protect any pattern metacharacters in $tmp_term + $termpat = $tmp_term; $termpat =~ s/(\W)/\\$1/g; + + my $foo = (exists $ENV{TERMCAP} ? $ENV{TERMCAP} : ''); + + # $entry is the extracted termcap entry + if (($foo !~ m:^/:s) && ($foo =~ m/(^|\|)${termpat}[:|]/s)) { + $entry = $foo; + } + + my @termcap_path = termcap_path(); + + unless (@termcap_path || $entry) + { + # last resort--fake up a termcap from terminfo + local $ENV{TERM} = $term; + + if ( $^O eq 'VMS' ) { + $entry = $VMS_TERMCAP; + } + else { + if ( grep { -x "$_/infocmp" } split /:/, $ENV{PATH} ) { + eval + { + my $tmp = `infocmp -C 2>/dev/null`; + + if (( $tmp !~ m%^/%s ) && ( $tmp =~ /(^|\|)${termpat}[:|]/s)) { + $entry = $tmp; + } + }; + } + } + } + + croak "Can't find a valid termcap file" unless @termcap_path || $entry; + + $state = 1; # 0 == finished + # 1 == next file + # 2 == search again + + $first = 0; # first entry (keeps term name) + + $max = 32; # max :tc=...:'s + + if ($entry) { + # ok, we're starting with $TERMCAP + $first++; # we're the first entry + # do we need to continue? + if ($entry =~ s/:tc=([^:]+):/:/) { + $tmp_term = $1; + # protect any pattern metacharacters in $tmp_term + $termpat = $tmp_term; $termpat =~ s/(\W)/\\$1/g; + } + else { + $state = 0; # we're already finished + } + } + + # This is eval'ed inside the while loop for each file + $search = q{ + while (<TERMCAP>) { + next if /^\\t/ || /^#/; + if ($_ =~ m/(^|\\|)${termpat}[:|]/o) { + chomp; + s/^[^:]*:// if $first++; + $state = 0; + while ($_ =~ s/\\\\$//) { + defined(my $x = <TERMCAP>) or last; + $_ .= $x; chomp; + } + last; + } + } + defined $entry or $entry = ''; + $entry .= $_ if $_; + }; + + while ($state != 0) { + if ($state == 1) { + # get the next TERMCAP + $TERMCAP = shift @termcap_path + || croak "failed termcap lookup on $tmp_term"; + } + else { + # do the same file again + # prevent endless recursion + $max-- || croak "failed termcap loop at $tmp_term"; + $state = 1; # ok, maybe do a new file next time + } + + open(TERMCAP,"< $TERMCAP\0") || croak "open $TERMCAP: $!"; + eval $search; + die $@ if $@; + close TERMCAP; + + # If :tc=...: found then search this file again + $entry =~ s/:tc=([^:]+):/:/ && ($tmp_term = $1, $state = 2); + # protect any pattern metacharacters in $tmp_term + $termpat = $tmp_term; $termpat =~ s/(\W)/\\$1/g; + } + + croak "Can't find $term" if $entry eq ''; + $entry =~ s/:+\s*:+/:/g; # cleanup $entry + $entry =~ s/:+/:/g; # cleanup $entry + $self->{TERMCAP} = $entry; # save it + # print STDERR "DEBUG: $entry = ", $entry, "\n"; + + # Precompile $entry into the object + $entry =~ s/^[^:]*://; + foreach $field (split(/:[\s:\\]*/,$entry)) { + if (defined $field && $field =~ /^(\w\w)$/) { + $self->{'_' . $field} = 1 unless defined $self->{'_' . $1}; + # print STDERR "DEBUG: flag $1\n"; + } + elsif (defined $field && $field =~ /^(\w\w)\@/) { + $self->{'_' . $1} = ""; + # print STDERR "DEBUG: unset $1\n"; + } + elsif (defined $field && $field =~ /^(\w\w)#(.*)/) { + $self->{'_' . $1} = $2 unless defined $self->{'_' . $1}; + # print STDERR "DEBUG: numeric $1 = $2\n"; + } + elsif (defined $field && $field =~ /^(\w\w)=(.*)/) { + # print STDERR "DEBUG: string $1 = $2\n"; + next if defined $self->{'_' . ($cap = $1)}; + $_ = $2; + s/\\E/\033/g; + s/\\(\d\d\d)/pack('c',oct($1) & 0177)/eg; + s/\\n/\n/g; + s/\\r/\r/g; + s/\\t/\t/g; + s/\\b/\b/g; + s/\\f/\f/g; + s/\\\^/\377/g; + s/\^\?/\177/g; + s/\^(.)/pack('c',ord($1) & 31)/eg; + s/\\(.)/$1/g; + s/\377/^/g; + $self->{'_' . $cap} = $_; + } + # else { carp "junk in $term ignored: $field"; } + } + $self->{'_pc'} = "\0" unless defined $self->{'_pc'}; + $self->{'_bc'} = "\b" unless defined $self->{'_bc'}; + $self; +} + +# $terminal->Tpad($string, $cnt, $FH); + +=item B<Tpad> + +Outputs a literal string with appropriate padding for the current terminal. + +It takes three arguments: + +=over 2 + +=item B<$string> + +The literal string to be output. If it starts with a number and an optional +'*' then the padding will be increased by an amount relative to this number, +if the '*' is present then this amount will me multiplied by $cnt. This part +of $string is removed before output/ + +=item B<$cnt> + +Will be used to modify the padding applied to string as described above. + +=item B<$FH> + +An optional filehandle (or IO::Handle ) that output will be printed to. + +=back + +The padded $string is returned. + +=cut + +sub Tpad { ## public + my $self = shift; + my($string, $cnt, $FH) = @_; + my($decr, $ms); + + if (defined $string && $string =~ /(^[\d.]+)(\*?)(.*)$/) { + $ms = $1; + $ms *= $cnt if $2; + $string = $3; + $decr = $self->{PADDING}; + if ($decr > .1) { + $ms += $decr / 2; + $string .= $self->{'_pc'} x ($ms / $decr); + } + } + print $FH $string if $FH; + $string; +} + +# $terminal->Tputs($cap, $cnt, $FH); + +=item B<Tputs> + +Output the string for the given capability padded as appropriate without +any parameter substitution. + +It takes three arguments: + +=over 2 + +=item B<$cap> + +The capability whose string is to be output. + +=item B<$cnt> + +A count passed to Tpad to modify the padding applied to the output string. +If $cnt is zero or one then the resulting string will be cached. + +=item B<$FH> + +An optional filehandle (or IO::Handle ) that output will be printed to. + +=back + +The appropriate string for the capability will be returned. + +=cut + +sub Tputs { ## public + my $self = shift; + my($cap, $cnt, $FH) = @_; + my $string; + + $cnt = 0 unless $cnt; + + if ($cnt > 1) { + $string = Tpad($self, $self->{'_' . $cap}, $cnt); + } else { + # cache result because Tpad can be slow + unless (exists $self->{$cap}) { + $self->{$cap} = exists $self->{"_$cap"} ? + Tpad($self, $self->{"_$cap"}, 1) : undef; + } + $string = $self->{$cap}; + } + print $FH $string if $FH; + $string; +} + +# $terminal->Tgoto($cap, $col, $row, $FH); + +=item B<Tgoto> + +B<Tgoto> decodes a cursor addressing string with the given parameters. + +There are four arguments: + +=over 2 + +=item B<$cap> + +The name of the capability to be output. + +=item B<$col> + +The first value to be substituted in the output string ( usually the column +in a cursor addressing capability ) + +=item B<$row> + +The second value to be substituted in the output string (usually the row +in cursor addressing capabilities) + +=item B<$FH> + +An optional filehandle (or IO::Handle ) to which the output string will be +printed. + +=back + +Substitutions are made with $col and $row in the output string with the +following sprintf() line formats: + + %% output `%' + %d output value as in printf %d + %2 output value as in printf %2d + %3 output value as in printf %3d + %. output value as in printf %c + %+x add x to value, then do %. + + %>xy if value > x then add y, no output + %r reverse order of two parameters, no output + %i increment by one, no output + %B BCD (16*(value/10)) + (value%10), no output + + %n exclusive-or all parameters with 0140 (Datamedia 2500) + %D Reverse coding (value - 2*(value%16)), no output (Delta Data) + +The output string will be returned. + +=cut + +sub Tgoto { ## public + my $self = shift; + my($cap, $code, $tmp, $FH) = @_; + my $string = $self->{'_' . $cap}; + my $result = ''; + my $after = ''; + my $online = 0; + my @tmp = ($tmp,$code); + my $cnt = $code; + + while ($string =~ /^([^%]*)%(.)(.*)/) { + $result .= $1; + $code = $2; + $string = $3; + if ($code eq 'd') { + $result .= sprintf("%d",shift(@tmp)); + } + elsif ($code eq '.') { + $tmp = shift(@tmp); + if ($tmp == 0 || $tmp == 4 || $tmp == 10) { + if ($online) { + ++$tmp, $after .= $self->{'_up'} if $self->{'_up'}; + } + else { + ++$tmp, $after .= $self->{'_bc'}; + } + } + $result .= sprintf("%c",$tmp); + $online = !$online; + } + elsif ($code eq '+') { + $result .= sprintf("%c",shift(@tmp)+ord($string)); + $string = substr($string,1,99); + $online = !$online; + } + elsif ($code eq 'r') { + ($code,$tmp) = @tmp; + @tmp = ($tmp,$code); + $online = !$online; + } + elsif ($code eq '>') { + ($code,$tmp,$string) = unpack("CCa99",$string); + if ($tmp[$[] > $code) { + $tmp[$[] += $tmp; + } + } + elsif ($code eq '2') { + $result .= sprintf("%02d",shift(@tmp)); + $online = !$online; + } + elsif ($code eq '3') { + $result .= sprintf("%03d",shift(@tmp)); + $online = !$online; + } + elsif ($code eq 'i') { + ($code,$tmp) = @tmp; + @tmp = ($code+1,$tmp+1); + } + else { + return "OOPS"; + } + } + $string = Tpad($self, $result . $string . $after, $cnt); + print $FH $string if $FH; + $string; +} + +# $terminal->Trequire(qw/ce ku kd/); + +=item B<Trequire> + +Takes a list of capabilities as an argument and will croak if one is not +found. + +=cut + +sub Trequire { ## public + my $self = shift; + my($cap,@undefined); + foreach $cap (@_) { + push(@undefined, $cap) + unless defined $self->{'_' . $cap} && $self->{'_' . $cap}; + } + croak "Terminal does not support: (@undefined)" if @undefined; +} + +=back + +=head1 EXAMPLES + + use Term::Cap; + + # Get terminal output speed + require POSIX; + my $termios = new POSIX::Termios; + $termios->getattr; + my $ospeed = $termios->getospeed; + + # Old-style ioctl code to get ospeed: + # require 'ioctl.pl'; + # ioctl(TTY,$TIOCGETP,$sgtty); + # ($ispeed,$ospeed) = unpack('cc',$sgtty); + + # allocate and initialize a terminal structure + $terminal = Tgetent Term::Cap { TERM => undef, OSPEED => $ospeed }; + + # require certain capabilities to be available + $terminal->Trequire(qw/ce ku kd/); + + # Output Routines, if $FH is undefined these just return the string + + # Tgoto does the % expansion stuff with the given args + $terminal->Tgoto('cm', $col, $row, $FH); + + # Tputs doesn't do any % expansion. + $terminal->Tputs('dl', $count = 1, $FH); + +=head1 COPYRIGHT AND LICENSE + +Please see the README file in distribution. + +=head1 AUTHOR + +This module is part of the core Perl distribution and is also maintained +for CPAN by Jonathan Stowe <jns@gellyfish.com>. + +=head1 SEE ALSO + +termcap(5) + +=cut + +# Below is a default entry for systems where there are terminals but no +# termcap +1; +__DATA__ +vt220|vt200|DEC VT220 in vt100 emulation mode: +am:mi:xn:xo: +co#80:li#24: +RA=\E[?7l:SA=\E[?7h: +ac=kkllmmjjnnwwqquuttvvxx:ae=\E(B:al=\E[L:as=\E(0: +bl=^G:cd=\E[J:ce=\E[K:cl=\E[H\E[2J:cm=\E[%i%d;%dH: +cr=^M:cs=\E[%i%d;%dr:dc=\E[P:dl=\E[M:do=\E[B: +ei=\E[4l:ho=\E[H:im=\E[4h: +is=\E[1;24r\E[24;1H: +nd=\E[C: +kd=\E[B::kl=\E[D:kr=\E[C:ku=\E[A:le=^H: +mb=\E[5m:md=\E[1m:me=\E[m:mr=\E[7m: +kb=\0177: +r2=\E>\E[24;1H\E[?3l\E[?4l\E[?5l\E[?7h\E[?8h\E=:rc=\E8: +sc=\E7:se=\E[27m:sf=\ED:so=\E[7m:sr=\EM:ta=^I: +ue=\E[24m:up=\E[A:us=\E[4m:ve=\E[?25h:vi=\E[?25l: + diff --git a/Master/xemtex/perl/lib/Text/ParseWords.pm b/Master/xemtex/perl/lib/Text/ParseWords.pm new file mode 100644 index 00000000000..6949c459378 --- /dev/null +++ b/Master/xemtex/perl/lib/Text/ParseWords.pm @@ -0,0 +1,263 @@ +package Text::ParseWords; + +use vars qw($VERSION @ISA @EXPORT $PERL_SINGLE_QUOTE); +$VERSION = "3.21"; + +require 5.000; + +use Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(shellwords quotewords nested_quotewords parse_line); +@EXPORT_OK = qw(old_shellwords); + + +sub shellwords { + local(@lines) = @_; + $lines[$#lines] =~ s/\s+$//; + return(quotewords('\s+', 0, @lines)); +} + + + +sub quotewords { + my($delim, $keep, @lines) = @_; + my($line, @words, @allwords); + + + foreach $line (@lines) { + @words = parse_line($delim, $keep, $line); + return() unless (@words || !length($line)); + push(@allwords, @words); + } + return(@allwords); +} + + + +sub nested_quotewords { + my($delim, $keep, @lines) = @_; + my($i, @allwords); + + for ($i = 0; $i < @lines; $i++) { + @{$allwords[$i]} = parse_line($delim, $keep, $lines[$i]); + return() unless (@{$allwords[$i]} || !length($lines[$i])); + } + return(@allwords); +} + + + +sub parse_line { + # We will be testing undef strings + no warnings; + use re 'taint'; # if it's tainted, leave it as such + + my($delimiter, $keep, $line) = @_; + my($quote, $quoted, $unquoted, $delim, $word, @pieces); + + while (length($line)) { + + ($quote, $quoted, undef, $unquoted, $delim, undef) = + $line =~ m/^(["']) # a $quote + ((?:\\.|(?!\1)[^\\])*) # and $quoted text + \1 # followed by the same quote + ([\000-\377]*) # and the rest + | # --OR-- + ^((?:\\.|[^\\"'])*?) # an $unquoted text + (\Z(?!\n)|(?-x:$delimiter)|(?!^)(?=["'])) + # plus EOL, delimiter, or quote + ([\000-\377]*) # the rest + /x; # extended layout + return() unless( $quote || length($unquoted) || length($delim)); + + $line = $+; + + if ($keep) { + $quoted = "$quote$quoted$quote"; + } + else { + $unquoted =~ s/\\(.)/$1/g; + if (defined $quote) { + $quoted =~ s/\\(.)/$1/g if ($quote eq '"'); + $quoted =~ s/\\([\\'])/$1/g if ( $PERL_SINGLE_QUOTE && $quote eq "'"); + } + } + $word .= defined $quote ? $quoted : $unquoted; + + if (length($delim)) { + push(@pieces, $word); + push(@pieces, $delim) if ($keep eq 'delimiters'); + undef $word; + } + if (!length($line)) { + push(@pieces, $word); + } + } + return(@pieces); +} + + + +sub old_shellwords { + + # Usage: + # use ParseWords; + # @words = old_shellwords($line); + # or + # @words = old_shellwords(@lines); + + local($_) = join('', @_); + my(@words,$snippet,$field); + + s/^\s+//; + while ($_ ne '') { + $field = ''; + for (;;) { + if (s/^"(([^"\\]|\\.)*)"//) { + ($snippet = $1) =~ s#\\(.)#$1#g; + } + elsif (/^"/) { + return(); + } + elsif (s/^'(([^'\\]|\\.)*)'//) { + ($snippet = $1) =~ s#\\(.)#$1#g; + } + elsif (/^'/) { + return(); + } + elsif (s/^\\(.)//) { + $snippet = $1; + } + elsif (s/^([^\s\\'"]+)//) { + $snippet = $1; + } + else { + s/^\s+//; + last; + } + $field .= $snippet; + } + push(@words, $field); + } + @words; +} + +1; + +__END__ + +=head1 NAME + +Text::ParseWords - parse text into an array of tokens or array of arrays + +=head1 SYNOPSIS + + use Text::ParseWords; + @lists = &nested_quotewords($delim, $keep, @lines); + @words = "ewords($delim, $keep, @lines); + @words = &shellwords(@lines); + @words = &parse_line($delim, $keep, $line); + @words = &old_shellwords(@lines); # DEPRECATED! + +=head1 DESCRIPTION + +The &nested_quotewords() and "ewords() functions accept a delimiter +(which can be a regular expression) +and a list of lines and then breaks those lines up into a list of +words ignoring delimiters that appear inside quotes. "ewords() +returns all of the tokens in a single long list, while &nested_quotewords() +returns a list of token lists corresponding to the elements of @lines. +&parse_line() does tokenizing on a single string. The &*quotewords() +functions simply call &parse_lines(), so if you're only splitting +one line you can call &parse_lines() directly and save a function +call. + +The $keep argument is a boolean flag. If true, then the tokens are +split on the specified delimiter, but all other characters (quotes, +backslashes, etc.) are kept in the tokens. If $keep is false then the +&*quotewords() functions remove all quotes and backslashes that are +not themselves backslash-escaped or inside of single quotes (i.e., +"ewords() tries to interpret these characters just like the Bourne +shell). NB: these semantics are significantly different from the +original version of this module shipped with Perl 5.000 through 5.004. +As an additional feature, $keep may be the keyword "delimiters" which +causes the functions to preserve the delimiters in each string as +tokens in the token lists, in addition to preserving quote and +backslash characters. + +&shellwords() is written as a special case of "ewords(), and it +does token parsing with whitespace as a delimiter-- similar to most +Unix shells. + +=head1 EXAMPLES + +The sample program: + + use Text::ParseWords; + @words = "ewords('\s+', 0, q{this is "a test" of\ quotewords \"for you}); + $i = 0; + foreach (@words) { + print "$i: <$_>\n"; + $i++; + } + +produces: + + 0: <this> + 1: <is> + 2: <a test> + 3: <of quotewords> + 4: <"for> + 5: <you> + +demonstrating: + +=over 4 + +=item 0 + +a simple word + +=item 1 + +multiple spaces are skipped because of our $delim + +=item 2 + +use of quotes to include a space in a word + +=item 3 + +use of a backslash to include a space in a word + +=item 4 + +use of a backslash to remove the special meaning of a double-quote + +=item 5 + +another simple word (note the lack of effect of the +backslashed double-quote) + +=back + +Replacing C<"ewords('\s+', 0, q{this is...})> +with C<&shellwords(q{this is...})> +is a simpler way to accomplish the same thing. + +=head1 AUTHORS + +Maintainer is Hal Pomeranz <pomeranz@netcom.com>, 1994-1997 (Original +author unknown). Much of the code for &parse_line() (including the +primary regexp) from Joerk Behrends <jbehrends@multimediaproduzenten.de>. + +Examples section another documentation provided by John Heidemann +<johnh@ISI.EDU> + +Bug reports, patches, and nagging provided by lots of folks-- thanks +everybody! Special thanks to Michael Schwern <schwern@envirolink.org> +for assuring me that a &nested_quotewords() would be useful, and to +Jeff Friedl <jfriedl@yahoo-inc.com> for telling me not to worry about +error-checking (sort of-- you had to be there). + +=cut diff --git a/Master/xemtex/perl/lib/Text/Tabs.pm b/Master/xemtex/perl/lib/Text/Tabs.pm new file mode 100644 index 00000000000..b26f8f40548 --- /dev/null +++ b/Master/xemtex/perl/lib/Text/Tabs.pm @@ -0,0 +1,97 @@ + +package Text::Tabs; + +require Exporter; + +@ISA = (Exporter); +@EXPORT = qw(expand unexpand $tabstop); + +use vars qw($VERSION $tabstop $debug); +$VERSION = 98.112801; + +use strict; + +BEGIN { + $tabstop = 8; + $debug = 0; +} + +sub expand +{ + my (@l) = @_; + for $_ (@l) { + 1 while s/(^|\n)([^\t\n]*)(\t+)/ + $1. $2 . (" " x + ($tabstop * length($3) + - (length($2) % $tabstop))) + /sex; + } + return @l if wantarray; + return $l[0]; +} + +sub unexpand +{ + my (@l) = @_; + my @e; + my $x; + my $line; + my @lines; + my $lastbit; + for $x (@l) { + @lines = split("\n", $x, -1); + for $line (@lines) { + $line = expand($line); + @e = split(/(.{$tabstop})/,$line,-1); + $lastbit = pop(@e); + $lastbit = '' unless defined $lastbit; + $lastbit = "\t" + if $lastbit eq " "x$tabstop; + for $_ (@e) { + if ($debug) { + my $x = $_; + $x =~ s/\t/^I\t/gs; + print "sub on '$x'\n"; + } + s/ +$/\t/; + } + $line = join('',@e, $lastbit); + } + $x = join("\n", @lines); + } + return @l if wantarray; + return $l[0]; +} + +1; +__END__ + + +=head1 NAME + +Text::Tabs -- expand and unexpand tabs per the unix expand(1) and unexpand(1) + +=head1 SYNOPSIS + + use Text::Tabs; + + $tabstop = 4; + @lines_without_tabs = expand(@lines_with_tabs); + @lines_with_tabs = unexpand(@lines_without_tabs); + +=head1 DESCRIPTION + +Text::Tabs does about what the unix utilities expand(1) and unexpand(1) +do. Given a line with tabs in it, expand will replace the tabs with +the appropriate number of spaces. Given a line with or without tabs in +it, unexpand will add tabs when it can save bytes by doing so. Invisible +compression with plain ascii! + +=head1 BUGS + +expand doesn't handle newlines very quickly -- do not feed it an +entire document in one string. Instead feed it an array of lines. + +=head1 AUTHOR + +David Muir Sharnoff <muir@idiom.com> diff --git a/Master/xemtex/perl/lib/Text/Wrap.pm b/Master/xemtex/perl/lib/Text/Wrap.pm new file mode 100644 index 00000000000..8dd1f6c2512 --- /dev/null +++ b/Master/xemtex/perl/lib/Text/Wrap.pm @@ -0,0 +1,211 @@ +package Text::Wrap; + +require Exporter; + +@ISA = qw(Exporter); +@EXPORT = qw(wrap fill); +@EXPORT_OK = qw($columns $break $huge); + +$VERSION = 2001.0929; + +use vars qw($VERSION $columns $debug $break $huge $unexpand $tabstop + $separator); +use strict; + +BEGIN { + $columns = 76; # <= screen width + $debug = 0; + $break = '\s'; + $huge = 'wrap'; # alternatively: 'die' or 'overflow' + $unexpand = 1; + $tabstop = 8; + $separator = "\n"; +} + +use Text::Tabs qw(expand unexpand); + +sub wrap +{ + my ($ip, $xp, @t) = @_; + + local($Text::Tabs::tabstop) = $tabstop; + my $r = ""; + my $tail = pop(@t); + my $t = expand(join("", (map { /\s+\z/ ? ( $_ ) : ($_, ' ') } @t), $tail)); + my $lead = $ip; + my $ll = $columns - length(expand($ip)) - 1; + my $nll = $columns - length(expand($xp)) - 1; + my $nl = ""; + my $remainder = ""; + + use re 'taint'; + + pos($t) = 0; + while ($t !~ /\G\s*\Z/gc) { + if ($t =~ /\G([^\n]{0,$ll})($break|\z)/xmgc) { + $r .= $unexpand + ? unexpand($nl . $lead . $1) + : $nl . $lead . $1; + $remainder = $2; + } elsif ($huge eq 'wrap' && $t =~ /\G([^\n]{$ll})/gc) { + $r .= $unexpand + ? unexpand($nl . $lead . $1) + : $nl . $lead . $1; + $remainder = $separator; + } elsif ($huge eq 'overflow' && $t =~ /\G([^\n]*?)($break|\z)/xmgc) { + $r .= $unexpand + ? unexpand($nl . $lead . $1) + : $nl . $lead . $1; + $remainder = $2; + } elsif ($huge eq 'die') { + die "couldn't wrap '$t'"; + } else { + die "This shouldn't happen"; + } + + $lead = $xp; + $ll = $nll; + $nl = $separator; + } + $r .= $remainder; + + print "-----------$r---------\n" if $debug; + + print "Finish up with '$lead'\n" if $debug; + + $r .= $lead . substr($t, pos($t), length($t)-pos($t)) + if pos($t) ne length($t); + + print "-----------$r---------\n" if $debug;; + + return $r; +} + +sub fill +{ + my ($ip, $xp, @raw) = @_; + my @para; + my $pp; + + for $pp (split(/\n\s+/, join("\n",@raw))) { + $pp =~ s/\s+/ /g; + my $x = wrap($ip, $xp, $pp); + push(@para, $x); + } + + # if paragraph_indent is the same as line_indent, + # separate paragraphs with blank lines + + my $ps = ($ip eq $xp) ? "\n\n" : "\n"; + return join ($ps, @para); +} + +1; +__END__ + +=head1 NAME + +Text::Wrap - line wrapping to form simple paragraphs + +=head1 SYNOPSIS + +B<Example 1> + + use Text::Wrap + + $initial_tab = "\t"; # Tab before first line + $subsequent_tab = ""; # All other lines flush left + + print wrap($initial_tab, $subsequent_tab, @text); + print fill($initial_tab, $subsequent_tab, @text); + + @lines = wrap($initial_tab, $subsequent_tab, @text); + + @paragraphs = fill($initial_tab, $subsequent_tab, @text); + +B<Example 2> + + use Text::Wrap qw(wrap $columns $huge); + + $columns = 132; # Wrap at 132 characters + $huge = 'die'; + $huge = 'wrap'; + $huge = 'overflow'; + +B<Example 3> + + use Text::Wrap + + $Text::Wrap::columns = 72; + print wrap('', '', @text); + +=head1 DESCRIPTION + +C<Text::Wrap::wrap()> is a very simple paragraph formatter. It formats a +single paragraph at a time by breaking lines at word boundries. +Indentation is controlled for the first line (C<$initial_tab>) and +all subsquent lines (C<$subsequent_tab>) independently. Please note: +C<$initial_tab> and C<$subsequent_tab> are the literal strings that will +be used: it is unlikley you would want to pass in a number. + +Text::Wrap::fill() is a simple multi-paragraph formatter. It formats +each paragraph separately and then joins them together when it's done. It +will destory any whitespace in the original text. It breaks text into +paragraphs by looking for whitespace after a newline. In other respects +it acts like wrap(). + +=head1 OVERRIDES + +C<Text::Wrap::wrap()> has a number of variables that control its behavior. +Because other modules might be using C<Text::Wrap::wrap()> it is suggested +that you leave these variables alone! If you can't do that, then +use C<local($Text::Wrap::VARIABLE) = YOURVALUE> when you change the +values so that the original value is restored. This C<local()> trick +will not work if you import the variable into your own namespace. + +Lines are wrapped at C<$Text::Wrap::columns> columns. C<$Text::Wrap::columns> +should be set to the full width of your output device. In fact, +every resulting line will have length of no more than C<$columns - 1>. + +It is possible to control which characters terminate words by +modifying C<$Text::Wrap::break>. Set this to a string such as +C<'[\s:]'> (to break before spaces or colons) or a pre-compiled regexp +such as C<qr/[\s']/> (to break before spaces or apostrophes). The +default is simply C<'\s'>; that is, words are terminated by spaces. +(This means, among other things, that trailing punctuation such as +full stops or commas stay with the word they are "attached" to.) + +Beginner note: In example 2, above C<$columns> is imported into +the local namespace, and set locally. In example 3, +C<$Text::Wrap::columns> is set in its own namespace without importing it. + +C<Text::Wrap::wrap()> starts its work by expanding all the tabs in its +input into spaces. The last thing it does it to turn spaces back +into tabs. If you do not want tabs in your results, set +C<$Text::Wrap::unexapand> to a false value. Likewise if you do not +want to use 8-character tabstops, set C<$Text::Wrap::tabstop> to +the number of characters you do want for your tabstops. + +If you want to separate your lines with something other than C<\n> +then set C<$Text::Wrap::seporator> to your preference. + +When words that are longer than C<$columns> are encountered, they +are broken up. C<wrap()> adds a C<"\n"> at column C<$columns>. +This behavior can be overridden by setting C<$huge> to +'die' or to 'overflow'. When set to 'die', large words will cause +C<die()> to be called. When set to 'overflow', large words will be +left intact. + +Historical notes: 'die' used to be the default value of +C<$huge>. Now, 'wrap' is the default value. + +=head1 EXAMPLE + + print wrap("\t","","This is a bit of text that forms + a normal book-style paragraph"); + +=head1 AUTHOR + +David Muir Sharnoff <muir@idiom.com> with help from Tim Pierce and +many many others. + diff --git a/Master/xemtex/perl/lib/Tie/Hash.pm b/Master/xemtex/perl/lib/Tie/Hash.pm new file mode 100644 index 00000000000..282006984b9 --- /dev/null +++ b/Master/xemtex/perl/lib/Tie/Hash.pm @@ -0,0 +1,243 @@ +package Tie::Hash; + +our $VERSION = '1.00'; + +=head1 NAME + +Tie::Hash, Tie::StdHash, Tie::ExtraHash - base class definitions for tied hashes + +=head1 SYNOPSIS + + package NewHash; + require Tie::Hash; + + @ISA = (Tie::Hash); + + sub DELETE { ... } # Provides needed method + sub CLEAR { ... } # Overrides inherited method + + + package NewStdHash; + require Tie::Hash; + + @ISA = (Tie::StdHash); + + # All methods provided by default, define only those needing overrides + # Accessors access the storage in %{$_[0]}; + # TIEHANDLE should return a reference to the actual storage + sub DELETE { ... } + + package NewExtraHash; + require Tie::Hash; + + @ISA = (Tie::ExtraHash); + + # All methods provided by default, define only those needing overrides + # Accessors access the storage in %{$_[0][0]}; + # TIEHANDLE should return an array reference with the first element being + # the reference to the actual storage + sub DELETE { + $_[0][1]->('del', $_[0][0], $_[1]); # Call the report writer + delete $_[0][0]->{$_[1]}; # $_[0]->SUPER::DELETE($_[1]) } + + + package main; + + tie %new_hash, 'NewHash'; + tie %new_std_hash, 'NewStdHash'; + tie %new_extra_hash, 'NewExtraHash', + sub {warn "Doing \U$_[1]\E of $_[2].\n"}; + +=head1 DESCRIPTION + +This module provides some skeletal methods for hash-tying classes. See +L<perltie> for a list of the functions required in order to tie a hash +to a package. The basic B<Tie::Hash> package provides a C<new> method, as well +as methods C<TIEHASH>, C<EXISTS> and C<CLEAR>. The B<Tie::StdHash> and +B<Tie::ExtraHash> packages +provide most methods for hashes described in L<perltie> (the exceptions +are C<UNTIE> and C<DESTROY>). They cause tied hashes to behave exactly like standard hashes, +and allow for selective overwriting of methods. B<Tie::Hash> grandfathers the +C<new> method: it is used if C<TIEHASH> is not defined +in the case a class forgets to include a C<TIEHASH> method. + +For developers wishing to write their own tied hashes, the required methods +are briefly defined below. See the L<perltie> section for more detailed +descriptive, as well as example code: + +=over 4 + +=item TIEHASH classname, LIST + +The method invoked by the command C<tie %hash, classname>. Associates a new +hash instance with the specified class. C<LIST> would represent additional +arguments (along the lines of L<AnyDBM_File> and compatriots) needed to +complete the association. + +=item STORE this, key, value + +Store datum I<value> into I<key> for the tied hash I<this>. + +=item FETCH this, key + +Retrieve the datum in I<key> for the tied hash I<this>. + +=item FIRSTKEY this + +Return the first key in the hash. + +=item NEXTKEY this, lastkey + +Return the next key in the hash. + +=item EXISTS this, key + +Verify that I<key> exists with the tied hash I<this>. + +The B<Tie::Hash> implementation is a stub that simply croaks. + +=item DELETE this, key + +Delete the key I<key> from the tied hash I<this>. + +=item CLEAR this + +Clear all values from the tied hash I<this>. + +=back + +=head1 Inheriting from B<Tie::StdHash> + +The accessor methods assume that the actual storage for the data in the tied +hash is in the hash referenced by C<tied(%tiedhash)>. Thus overwritten +C<TIEHANDLE> method should return a hash reference, and the remaining methods +should operate on the hash referenced by the first argument: + + package ReportHash; + our @ISA = 'Tie::StdHash'; + + sub TIEHASH { + my $storage = bless {}, shift; + warn "New ReportHash created, stored in $storage.\n"; + $storage + } + sub STORE { + warn "Storing data with key $_[1] at $_[0].\n"; + $_[0]{$_[1]} = $_[2] + } + + +=head1 Inheriting from B<Tie::ExtraHash> + +The accessor methods assume that the actual storage for the data in the tied +hash is in the hash referenced by C<(tied(%tiedhash))[0]>. Thus overwritten +C<TIEHANDLE> method should return an array reference with the first +element being a hash reference, and the remaining methods should operate on the +hash C<< %{ $_[0]->[0] } >>: + + package ReportHash; + our @ISA = 'Tie::StdHash'; + + sub TIEHASH { + my $storage = bless {}, shift; + warn "New ReportHash created, stored in $storage.\n"; + [$storage, @_] + } + sub STORE { + warn "Storing data with key $_[1] at $_[0].\n"; + $_[0][0]{$_[1]} = $_[2] + } + +The default C<TIEHANDLE> method stores "extra" arguments to tie() starting +from offset 1 in the array referenced by C<tied(%tiedhash)>; this is the +same storage algorithm as in TIEHASH subroutine above. Hence, a typical +package inheriting from B<Tie::ExtraHash> does not need to overwrite this +method. + +=head1 C<UNTIE> and C<DESTROY> + +The methods C<UNTIE> and C<DESTROY> are not defined in B<Tie::Hash>, +B<Tie::StdHash>, or B<Tie::ExtraHash>. Tied hashes do not require +presense of these methods, but if defined, the methods will be called in +proper time, see L<perltie>. + +If needed, these methods should be defined by the package inheriting from +B<Tie::Hash>, B<Tie::StdHash>, or B<Tie::ExtraHash>. + +=head1 MORE INFORMATION + +The packages relating to various DBM-related implementations (F<DB_File>, +F<NDBM_File>, etc.) show examples of general tied hashes, as does the +L<Config> module. While these do not utilize B<Tie::Hash>, they serve as +good working examples. + +=cut + +use Carp; +use warnings::register; + +sub new { + my $pkg = shift; + $pkg->TIEHASH(@_); +} + +# Grandfather "new" + +sub TIEHASH { + my $pkg = shift; + if (defined &{"${pkg}::new"}) { + warnings::warnif("WARNING: calling ${pkg}->new since ${pkg}->TIEHASH is missing"); + $pkg->new(@_); + } + else { + croak "$pkg doesn't define a TIEHASH method"; + } +} + +sub EXISTS { + my $pkg = ref $_[0]; + croak "$pkg doesn't define an EXISTS method"; +} + +sub CLEAR { + my $self = shift; + my $key = $self->FIRSTKEY(@_); + my @keys; + + while (defined $key) { + push @keys, $key; + $key = $self->NEXTKEY(@_, $key); + } + foreach $key (@keys) { + $self->DELETE(@_, $key); + } +} + +# The Tie::StdHash package implements standard perl hash behaviour. +# It exists to act as a base class for classes which only wish to +# alter some parts of their behaviour. + +package Tie::StdHash; +# @ISA = qw(Tie::Hash); # would inherit new() only + +sub TIEHASH { bless {}, $_[0] } +sub STORE { $_[0]->{$_[1]} = $_[2] } +sub FETCH { $_[0]->{$_[1]} } +sub FIRSTKEY { my $a = scalar keys %{$_[0]}; each %{$_[0]} } +sub NEXTKEY { each %{$_[0]} } +sub EXISTS { exists $_[0]->{$_[1]} } +sub DELETE { delete $_[0]->{$_[1]} } +sub CLEAR { %{$_[0]} = () } + +package Tie::ExtraHash; + +sub TIEHASH { my $p = shift; bless [{}, @_], $p } +sub STORE { $_[0][0]{$_[1]} = $_[2] } +sub FETCH { $_[0][0]{$_[1]} } +sub FIRSTKEY { my $a = scalar keys %{$_[0][0]}; each %{$_[0][0]} } +sub NEXTKEY { each %{$_[0][0]} } +sub EXISTS { exists $_[0][0]->{$_[1]} } +sub DELETE { delete $_[0][0]->{$_[1]} } +sub CLEAR { %{$_[0][0]} = () } + +1; diff --git a/Master/xemtex/perl/lib/Tie/Scalar.pm b/Master/xemtex/perl/lib/Tie/Scalar.pm new file mode 100644 index 00000000000..c23c12187a8 --- /dev/null +++ b/Master/xemtex/perl/lib/Tie/Scalar.pm @@ -0,0 +1,140 @@ +package Tie::Scalar; + +our $VERSION = '1.00'; + +=head1 NAME + +Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars + +=head1 SYNOPSIS + + package NewScalar; + require Tie::Scalar; + + @ISA = (Tie::Scalar); + + sub FETCH { ... } # Provide a needed method + sub TIESCALAR { ... } # Overrides inherited method + + + package NewStdScalar; + require Tie::Scalar; + + @ISA = (Tie::StdScalar); + + # All methods provided by default, so define only what needs be overridden + sub FETCH { ... } + + + package main; + + tie $new_scalar, 'NewScalar'; + tie $new_std_scalar, 'NewStdScalar'; + +=head1 DESCRIPTION + +This module provides some skeletal methods for scalar-tying classes. See +L<perltie> for a list of the functions required in tying a scalar to a +package. The basic B<Tie::Scalar> package provides a C<new> method, as well +as methods C<TIESCALAR>, C<FETCH> and C<STORE>. The B<Tie::StdScalar> +package provides all the methods specified in L<perltie>. It inherits from +B<Tie::Scalar> and causes scalars tied to it to behave exactly like the +built-in scalars, allowing for selective overloading of methods. The C<new> +method is provided as a means of grandfathering, for classes that forget to +provide their own C<TIESCALAR> method. + +For developers wishing to write their own tied-scalar classes, the methods +are summarized below. The L<perltie> section not only documents these, but +has sample code as well: + +=over 4 + +=item TIESCALAR classname, LIST + +The method invoked by the command C<tie $scalar, classname>. Associates a new +scalar instance with the specified class. C<LIST> would represent additional +arguments (along the lines of L<AnyDBM_File> and compatriots) needed to +complete the association. + +=item FETCH this + +Retrieve the value of the tied scalar referenced by I<this>. + +=item STORE this, value + +Store data I<value> in the tied scalar referenced by I<this>. + +=item DESTROY this + +Free the storage associated with the tied scalar referenced by I<this>. +This is rarely needed, as Perl manages its memory quite well. But the +option exists, should a class wish to perform specific actions upon the +destruction of an instance. + +=back + +=head1 MORE INFORMATION + +The L<perltie> section uses a good example of tying scalars by associating +process IDs with priority. + +=cut + +use Carp; +use warnings::register; + +sub new { + my $pkg = shift; + $pkg->TIESCALAR(@_); +} + +# "Grandfather" the new, a la Tie::Hash + +sub TIESCALAR { + my $pkg = shift; + if ($pkg->can('new') and $pkg ne __PACKAGE__) { + warnings::warnif("WARNING: calling ${pkg}->new since ${pkg}->TIESCALAR is missing"); + $pkg->new(@_); + } + else { + croak "$pkg doesn't define a TIESCALAR method"; + } +} + +sub FETCH { + my $pkg = ref $_[0]; + croak "$pkg doesn't define a FETCH method"; +} + +sub STORE { + my $pkg = ref $_[0]; + croak "$pkg doesn't define a STORE method"; +} + +# +# The Tie::StdScalar package provides scalars that behave exactly like +# Perl's built-in scalars. Good base to inherit from, if you're only going to +# tweak a small bit. +# +package Tie::StdScalar; +@ISA = (Tie::Scalar); + +sub TIESCALAR { + my $class = shift; + my $instance = shift || undef; + return bless \$instance => $class; +} + +sub FETCH { + return ${$_[0]}; +} + +sub STORE { + ${$_[0]} = $_[1]; +} + +sub DESTROY { + undef ${$_[0]}; +} + +1; diff --git a/Master/xemtex/perl/lib/Time/HiRes.pm b/Master/xemtex/perl/lib/Time/HiRes.pm new file mode 100644 index 00000000000..63375320408 --- /dev/null +++ b/Master/xemtex/perl/lib/Time/HiRes.pm @@ -0,0 +1,357 @@ +package Time::HiRes; + +use strict; +use vars qw($VERSION $XS_VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD); + +require Exporter; +use XSLoader; + +@ISA = qw(Exporter); + +@EXPORT = qw( ); +@EXPORT_OK = qw (usleep sleep ualarm alarm gettimeofday time tv_interval + getitimer setitimer ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF); + +$VERSION = '1.20_00'; +$XS_VERSION = $VERSION; +$VERSION = eval $VERSION; + +sub AUTOLOAD { + my $constname; + ($constname= $AUTOLOAD) =~ s/.*:://; + my $val = constant($constname, @_ ? $_[0] : 0); + if ($!) { + my ($pack,$file,$line) = caller; + die "Your vendor has not defined Time::HiRes macro $constname, used at $file line $line.\n"; + } + { + no strict 'refs'; + *$AUTOLOAD = sub { $val }; + } + goto &$AUTOLOAD; +} + +XSLoader::load 'Time::HiRes', $XS_VERSION; + +# Preloaded methods go here. + +sub tv_interval { + # probably could have been done in C + my ($a, $b) = @_; + $b = [gettimeofday()] unless defined($b); + (${$b}[0] - ${$a}[0]) + ((${$b}[1] - ${$a}[1]) / 1_000_000); +} + +# Autoload methods go after =cut, and are processed by the autosplit program. + +1; +__END__ + +=head1 NAME + +Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers + +=head1 SYNOPSIS + + use Time::HiRes qw( usleep ualarm gettimeofday tv_interval ); + + usleep ($microseconds); + + ualarm ($microseconds); + ualarm ($microseconds, $interval_microseconds); + + $t0 = [gettimeofday]; + ($seconds, $microseconds) = gettimeofday; + + $elapsed = tv_interval ( $t0, [$seconds, $microseconds]); + $elapsed = tv_interval ( $t0, [gettimeofday]); + $elapsed = tv_interval ( $t0 ); + + use Time::HiRes qw ( time alarm sleep ); + + $now_fractions = time; + sleep ($floating_seconds); + alarm ($floating_seconds); + alarm ($floating_seconds, $floating_interval); + + use Time::HiRes qw( setitimer getitimer + ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ); + + setitimer ($which, $floating_seconds, $floating_interval ); + getitimer ($which); + +=head1 DESCRIPTION + +The C<Time::HiRes> module implements a Perl interface to the usleep, +ualarm, gettimeofday, and setitimer/getitimer system calls. See the +EXAMPLES section below and the test scripts for usage; see your system +documentation for the description of the underlying usleep, ualarm, +gettimeofday, and setitimer/getitimer calls. + +If your system lacks gettimeofday(2) or an emulation of it you don't +get gettimeofday() or the one-arg form of tv_interval(). +If you don't have usleep(3) or select(2) you don't get usleep() +or sleep(). If your system don't have ualarm(3) or setitimer(2) you +don't get ualarm() or alarm(). If you try to import an unimplemented +function in the C<use> statement it will fail at compile time. + +The following functions can be imported from this module. +No functions are exported by default. + +=over 4 + +=item gettimeofday () + +In array context returns a 2 element array with the seconds and +microseconds since the epoch. In scalar context returns floating +seconds like Time::HiRes::time() (see below). + +=item usleep ( $useconds ) + +Sleeps for the number of microseconds specified. Returns the number +of microseconds actually slept. Can sleep for more than one second +unlike the usleep system call. See also Time::HiRes::sleep() below. + +=item ualarm ( $useconds [, $interval_useconds ] ) + +Issues a ualarm call; interval_useconds is optional and will be 0 if +unspecified, resulting in alarm-like behaviour. + +=item tv_interval + +C<tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] )> + +Returns the floating seconds between the two times, which should have +been returned by gettimeofday(). If the second argument is omitted, +then the current time is used. + +=item time () + +Returns a floating seconds since the epoch. This function can be +imported, resulting in a nice drop-in replacement for the C<time> +provided with core Perl, see the EXAMPLES below. + +B<NOTE 1>: this higher resolution timer can return values either less or +more than the core time(), depending on whether your platforms rounds +the higher resolution timer values up, down, or to the nearest to get +the core time(), but naturally the difference should be never more than +half a second. + +B<NOTE 2>: Since Sunday, September 9th, 2001 at 01:46:40 AM GMT +(when the time() seconds since epoch rolled over to 1_000_000_000), +the default floating point format of Perl and the seconds since epoch +have conspired to produce an apparent bug: if you print the value of +Time::HiRes::time() you seem to be getting only five decimals, not six +as promised (microseconds). Not to worry, the microseconds are there +(assuming your platform supports such granularity). What is going on +is that the default floating point format of Perl only outputs 15 +digits. In this case that means ten digits before the decimal +separator and five after. To see the microseconds you can use either +printf/sprintf with C<%.6f>, or the gettimeofday() function in list +context, which will give you the seconds and microseconds as two +separate values. + +=item sleep ( $floating_seconds ) + +Sleeps for the specified amount of seconds. Returns the number of +seconds actually slept (a floating point value). This function can be +imported, resulting in a nice drop-in replacement for the C<sleep> +provided with perl, see the EXAMPLES below. + +=item alarm ( $floating_seconds [, $interval_floating_seconds ] ) + +The SIGALRM signal is sent after the specfified number of seconds. +Implemented using ualarm(). The $interval_floating_seconds argument +is optional and will be 0 if unspecified, resulting in alarm()-like +behaviour. This function can be imported, resulting in a nice drop-in +replacement for the C<alarm> provided with perl, see the EXAMPLES below. + +=item setitimer + +C<setitimer ( $which, $floating_seconds [, $interval_floating_seconds ] )> + +Start up an interval timer: after a certain time, a signal arrives, +and more signals may keep arriving at certain intervals. To disable +a timer, use time of zero. If interval is set to zero (or unspecified), +the timer is disabled B<after> the next delivered signal. + +Use of interval timers may interfere with alarm(), sleep(), and usleep(). +In standard-speak the "interaction is unspecified", which means that +I<anything> may happen: it may work, it may not. + +In scalar context, the remaining time in the timer is returned. + +In list context, both the remaining time and the interval are returned. + +There are three interval timers: the $which can be ITIMER_REAL, +ITIMER_VIRTUAL, or ITIMER_PROF. + +ITIMER_REAL results in alarm()-like behavior. Time is counted in +I<real time>, that is, wallclock time. SIGALRM is delivered when +the timer expires. + +ITIMER_VIRTUAL counts time in (process) I<virtual time>, that is, only +when the process is running. In multiprocessor/user/CPU systems this +may be more or less than real or wallclock time. (This time is also +known as the I<user time>.) SIGVTALRM is delivered when the timer expires. + +ITIMER_PROF counts time when either the process virtual time or when +the operating system is running on behalf of the process (such as +I/O). (This time is also known as the I<system time>.) (Collectively +these times are also known as the I<CPU time>.) SIGPROF is delivered +when the timer expires. SIGPROF can interrupt system calls. + +The semantics of interval timers for multithreaded programs are +system-specific, and some systems may support additional interval +timers. See your setitimer() documentation. + +=item getitimer ( $which ) + +Return the remaining time in the interval timer specified by $which. + +In scalar context, the remaining time is returned. + +In list context, both the remaining time and the interval are returned. +The interval is always what you put in using setitimer(). + +=back + +=head1 EXAMPLES + + use Time::HiRes qw(usleep ualarm gettimeofday tv_interval); + + $microseconds = 750_000; + usleep $microseconds; + + # signal alarm in 2.5s & every .1s thereafter + ualarm 2_500_000, 100_000; + + # get seconds and microseconds since the epoch + ($s, $usec) = gettimeofday; + + # measure elapsed time + # (could also do by subtracting 2 gettimeofday return values) + $t0 = [gettimeofday]; + # do bunch of stuff here + $t1 = [gettimeofday]; + # do more stuff here + $t0_t1 = tv_interval $t0, $t1; + + $elapsed = tv_interval ($t0, [gettimeofday]); + $elapsed = tv_interval ($t0); # equivalent code + + # + # replacements for time, alarm and sleep that know about + # floating seconds + # + use Time::HiRes; + $now_fractions = Time::HiRes::time; + Time::HiRes::sleep (2.5); + Time::HiRes::alarm (10.6666666); + + use Time::HiRes qw ( time alarm sleep ); + $now_fractions = time; + sleep (2.5); + alarm (10.6666666); + + # Arm an interval timer to go off first at 10 seconds and + # after that every 2.5 seconds, in process virtual time + + use Time::HiRes qw ( setitimer ITIMER_VIRTUAL time ); + + $SIG{VTLARM} = sub { print time, "\n" }; + setitimer(ITIMER_VIRTUAL, 10, 2.5); + +=head1 C API + +In addition to the perl API described above, a C API is available for +extension writers. The following C functions are available in the +modglobal hash: + + name C prototype + --------------- ---------------------- + Time::NVtime double (*)() + Time::U2time void (*)(UV ret[2]) + +Both functions return equivalent information (like C<gettimeofday>) +but with different representations. The names C<NVtime> and C<U2time> +were selected mainly because they are operating system independent. +(C<gettimeofday> is Un*x-centric.) + +Here is an example of using NVtime from C: + + double (*myNVtime)(); + SV **svp = hv_fetch(PL_modglobal, "Time::NVtime", 12, 0); + if (!svp) croak("Time::HiRes is required"); + if (!SvIOK(*svp)) croak("Time::NVtime isn't a function pointer"); + myNVtime = INT2PTR(double(*)(), SvIV(*svp)); + printf("The current time is: %f\n", (*myNVtime)()); + +=head1 CAVEATS + +Notice that the core time() maybe rounding rather than truncating. +What this means that the core time() may be giving time one second +later than gettimeofday(), also known as Time::HiRes::time(). + +=head1 AUTHORS + +D. Wegscheid <wegscd@whirlpool.com> +R. Schertler <roderick@argon.org> +J. Hietaniemi <jhi@iki.fi> +G. Aas <gisle@aas.no> + +=head1 REVISION + +$Id: HiRes.pm,v 1.20 1999/03/16 02:26:13 wegscd Exp $ + +$Log: HiRes.pm,v $ +Revision 1.20 1999/03/16 02:26:13 wegscd +Add documentation for NVTime and U2Time. + +Revision 1.19 1998/09/30 02:34:42 wegscd +No changes, bump version. + +Revision 1.18 1998/07/07 02:41:35 wegscd +No changes, bump version. + +Revision 1.17 1998/07/02 01:45:13 wegscd +Bump version to 1.17 + +Revision 1.16 1997/11/13 02:06:36 wegscd +version bump to accomodate HiRes.xs fix. + +Revision 1.15 1997/11/11 02:17:59 wegscd +POD editing, courtesy of Gisle Aas. + +Revision 1.14 1997/11/06 03:14:35 wegscd +Update version # for Makefile.PL and HiRes.xs changes. + +Revision 1.13 1997/11/05 05:36:25 wegscd +change version # for Makefile.pl and HiRes.xs changes. + +Revision 1.12 1997/10/13 20:55:33 wegscd +Force a new version for Makefile.PL changes. + +Revision 1.11 1997/09/05 19:59:33 wegscd +New version to bump version for README and Makefile.PL fixes. +Fix bad RCS log. + +Revision 1.10 1997/05/23 01:11:38 wegscd +Conditional compilation; EXPORT_FAIL fixes. + +Revision 1.2 1996/12/30 13:28:40 wegscd +Update documentation for what to do when missing ualarm() and friends. + +Revision 1.1 1996/10/17 20:53:31 wegscd +Fix =head1 being next to __END__ so pod2man works + +Revision 1.0 1996/09/03 18:25:15 wegscd +Initial revision + +=head1 COPYRIGHT + +Copyright (c) 1996-1997 Douglas E. Wegscheid. +All rights reserved. This program is free software; you can +redistribute it and/or modify it under the same terms as Perl itself. + +=cut diff --git a/Master/xemtex/perl/lib/Time/Local.pm b/Master/xemtex/perl/lib/Time/Local.pm new file mode 100644 index 00000000000..faef1d78694 --- /dev/null +++ b/Master/xemtex/perl/lib/Time/Local.pm @@ -0,0 +1,255 @@ +package Time::Local; +use 5.006; +require Exporter; +use Carp; +use Config; +use strict; +use integer; + +our $VERSION = '1.04'; +our @ISA = qw( Exporter ); +our @EXPORT = qw( timegm timelocal ); +our @EXPORT_OK = qw( timegm_nocheck timelocal_nocheck ); + +my @MonthDays = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); + +# Determine breakpoint for rolling century +my $ThisYear = (localtime())[5]; +my $Breakpoint = ($ThisYear + 50) % 100; +my $NextCentury = $ThisYear - $ThisYear % 100; + $NextCentury += 100 if $Breakpoint < 50; +my $Century = $NextCentury - 100; +my $SecOff = 0; + +my (%Options, %Cheat); + +my $MaxInt = ((1<<(8 * $Config{intsize} - 2))-1)*2 + 1; +my $MaxDay = int(($MaxInt-43200)/86400)-1; + +# Determine the EPOC day for this machine +my $Epoc = 0; +if ($^O eq 'vos') { +# work around posix-977 -- VOS doesn't handle dates in +# the range 1970-1980. + $Epoc = _daygm((0, 0, 0, 1, 0, 70, 4, 0)); +} +elsif ($^O eq 'MacOS') { + no integer; + + $MaxDay *=2 if $^O eq 'MacOS'; # time_t unsigned ... quick hack? + # MacOS time() is seconds since 1 Jan 1904, localtime + # so we need to calculate an offset to apply later + $Epoc = 693901; + $SecOff = timelocal(localtime(0)) - timelocal(gmtime(0)); + $Epoc += _daygm(gmtime(0)); +} +else { + $Epoc = _daygm(gmtime(0)); +} + +%Cheat=(); # clear the cache as epoc has changed + +sub _daygm { + $_[3] + ($Cheat{pack("ss",@_[4,5])} ||= do { + my $month = ($_[4] + 10) % 12; + my $year = $_[5] + 1900 - $month/10; + 365*$year + $year/4 - $year/100 + $year/400 + ($month*306 + 5)/10 - $Epoc + }); +} + + +sub _timegm { + my $sec = $SecOff + $_[0] + 60 * $_[1] + 3600 * $_[2]; + + no integer; + + $sec + 86400 * &_daygm; +} + + +sub timegm { + my ($sec,$min,$hour,$mday,$month,$year) = @_; + + if ($year >= 1000) { + $year -= 1900; + } + elsif ($year < 100 and $year >= 0) { + $year += ($year > $Breakpoint) ? $Century : $NextCentury; + } + + unless ($Options{no_range_check}) { + if (abs($year) >= 0x7fff) { + $year += 1900; + croak "Cannot handle date ($sec, $min, $hour, $mday, $month, $year)"; + } + + croak "Month '$month' out of range 0..11" if $month > 11 or $month < 0; + + my $md = $MonthDays[$month]; + ++$md unless $month != 1 or $year % 4 or !($year % 400); + + croak "Day '$mday' out of range 1..$md" if $mday > $md or $mday < 1; + croak "Hour '$hour' out of range 0..23" if $hour > 23 or $hour < 0; + croak "Minute '$min' out of range 0..59" if $min > 59 or $min < 0; + croak "Second '$sec' out of range 0..59" if $sec > 59 or $sec < 0; + } + + my $days = _daygm(undef, undef, undef, $mday, $month, $year); + + unless ($Options{no_range_check} or abs($days) < $MaxDay) { + $year += 1900; + croak "Cannot handle date ($sec, $min, $hour, $mday, $month, $year)"; + } + + $sec += $SecOff + 60*$min + 3600*$hour; + + no integer; + + $sec + 86400*$days; +} + + +sub timegm_nocheck { + local $Options{no_range_check} = 1; + &timegm; +} + + +sub timelocal { + no integer; + my $ref_t = &timegm; + my $loc_t = _timegm(localtime($ref_t)); + + # Is there a timezone offset from GMT or are we done + my $zone_off = $ref_t - $loc_t + or return $loc_t; + + # Adjust for timezone + $loc_t = $ref_t + $zone_off; + + # Are we close to a DST change or are we done + my $dst_off = $ref_t - _timegm(localtime($loc_t)) + or return $loc_t; + + # Adjust for DST change + $loc_t + $dst_off; +} + + +sub timelocal_nocheck { + local $Options{no_range_check} = 1; + &timelocal; +} + +1; + +__END__ + +=head1 NAME + +Time::Local - efficiently compute time from local and GMT time + +=head1 SYNOPSIS + + $time = timelocal($sec,$min,$hour,$mday,$mon,$year); + $time = timegm($sec,$min,$hour,$mday,$mon,$year); + +=head1 DESCRIPTION + +These routines are the inverse of built-in perl functions localtime() +and gmtime(). They accept a date as a six-element array, and return +the corresponding time(2) value in seconds since the Epoch (Midnight, +January 1, 1970). This value can be positive or negative. + +It is worth drawing particular attention to the expected ranges for +the values provided. The value for the day of the month is the actual day +(ie 1..31), while the month is the number of months since January (0..11). +This is consistent with the values returned from localtime() and gmtime(). + +The timelocal() and timegm() functions perform range checking on the +input $sec, $min, $hour, $mday, and $mon values by default. If you'd +rather they didn't, you can explicitly import the timelocal_nocheck() +and timegm_nocheck() functions. + + use Time::Local 'timelocal_nocheck'; + + { + # The 365th day of 1999 + print scalar localtime timelocal_nocheck 0,0,0,365,0,99; + + # The twenty thousandth day since 1970 + print scalar localtime timelocal_nocheck 0,0,0,20000,0,70; + + # And even the 10,000,000th second since 1999! + print scalar localtime timelocal_nocheck 10000000,0,0,1,0,99; + } + +Your mileage may vary when trying these with minutes and hours, +and it doesn't work at all for months. + +Strictly speaking, the year should also be specified in a form consistent +with localtime(), i.e. the offset from 1900. +In order to make the interpretation of the year easier for humans, +however, who are more accustomed to seeing years as two-digit or four-digit +values, the following conventions are followed: + +=over 4 + +=item * + +Years greater than 999 are interpreted as being the actual year, +rather than the offset from 1900. Thus, 1963 would indicate the year +Martin Luther King won the Nobel prize, not the year 2863. + +=item * + +Years in the range 100..999 are interpreted as offset from 1900, +so that 112 indicates 2012. This rule also applies to years less than zero +(but see note below regarding date range). + +=item * + +Years in the range 0..99 are interpreted as shorthand for years in the +rolling "current century," defined as 50 years on either side of the current +year. Thus, today, in 1999, 0 would refer to 2000, and 45 to 2045, +but 55 would refer to 1955. Twenty years from now, 55 would instead refer +to 2055. This is messy, but matches the way people currently think about +two digit dates. Whenever possible, use an absolute four digit year instead. + +=back + +The scheme above allows interpretation of a wide range of dates, particularly +if 4-digit years are used. + +Please note, however, that the range of dates that can be actually be handled +depends on the size of an integer (time_t) on a given platform. +Currently, this is 32 bits for most systems, yielding an approximate range +from Dec 1901 to Jan 2038. + +Both timelocal() and timegm() croak if given dates outside the supported +range. + +=head1 IMPLEMENTATION + +These routines are quite efficient and yet are always guaranteed to agree +with localtime() and gmtime(). We manage this by caching the start times +of any months we've seen before. If we know the start time of the month, +we can always calculate any time within the month. The start times +are calculated using a mathematical formula. Unlike other algorithms +that do multiple calls to gmtime(). + +timelocal() is implemented using the same cache. We just assume that we're +translating a GMT time, and then fudge it when we're done for the timezone +and daylight savings arguments. Note that the timezone is evaluated for +each date because countries occasionally change their official timezones. +Assuming that localtime() corrects for these changes, this routine will +also be correct. + +=head1 BUGS + +The whole scheme for interpreting two-digit years can be considered a bug. + +The proclivity to croak() is probably a bug. + +=cut + diff --git a/Master/xemtex/perl/lib/UNIVERSAL.pm b/Master/xemtex/perl/lib/UNIVERSAL.pm new file mode 100644 index 00000000000..92b4fcd352a --- /dev/null +++ b/Master/xemtex/perl/lib/UNIVERSAL.pm @@ -0,0 +1,118 @@ +package UNIVERSAL; + +our $VERSION = '1.00'; + +# UNIVERSAL should not contain any extra subs/methods beyond those +# that it exists to define. The use of Exporter below is a historical +# accident that can't be fixed without breaking code. Note that we +# *don't* set @ISA here, don't want all classes/objects inheriting from +# Exporter. It's bad enough that all classes have a import() method +# whenever UNIVERSAL.pm is loaded. +require Exporter; +*import = \&Exporter::import; +@EXPORT_OK = qw(isa can VERSION); + +1; +__END__ + +=head1 NAME + +UNIVERSAL - base class for ALL classes (blessed references) + +=head1 SYNOPSIS + + $is_io = $fd->isa("IO::Handle"); + $is_io = Class->isa("IO::Handle"); + + $sub = $obj->can("print"); + $sub = Class->can("print"); + + use UNIVERSAL qw( isa can VERSION ); + $yes = isa $ref, "HASH" ; + $sub = can $ref, "fandango" ; + $ver = VERSION $obj ; + +=head1 DESCRIPTION + +C<UNIVERSAL> is the base class which all bless references will inherit from, +see L<perlobj>. + +C<UNIVERSAL> provides the following methods and functions: + +=over 4 + +=item $obj->isa( TYPE ), CLASS->isa( TYPE ), isa( VAL, TYPE ) + + C<TYPE> is a package name + $obj is a blessed reference or a string containing a package name + C<CLASS> is a package name + C<VAL> is any of the above or an unblessed reference + +When used as an instance or class method (C<$obj->isa( TYPE )>), C<isa> +returns I<true> if $obj is blessed into package C<TYPE> or inherits from +package C<TYPE>. + +When used as a class method (C<CLASS->isa( TYPE )>; sometimes referred to as a +static method), C<isa> returns I<true> if C<CLASS> inherits from (or is itself) +the name of the package C<TYPE> or inherits from package C<TYPE>. + +When used as a function, like + + use UNIVERSAL qw( isa ) ; + $yes = isa $h, "HASH"; + $yes = isa "Foo", "Bar"; + +or + + require UNIVERSAL ; + $yes = UNIVERSAL::isa $a, "ARRAY"; + +, C<isa> returns I<true> in the same cases as above and also if C<VAL> is an +unblessed reference to a perl variable of type C<TYPE>, such as "HASH", +"ARRAY", or "Regexp". + +=item $obj->can( METHOD ), CLASS->can( METHOD ), can( VAL, METHOD ) + +C<can> checks if the object or class has a method called C<METHOD>. If it does +then a reference to the sub is returned. If it does not then I<undef> is +returned. This includes methods inherited or imported by C<$obj>, C<CLASS>, or +C<VAL>. + +C<can> cannot know whether an object will be able to provide a method +through AUTOLOAD, so a return value of I<undef> does not necessarily mean +the object will not be able to handle the method call. To get around +this some module authors use a forward declaration (see L<perlsub>) +for methods they will handle via AUTOLOAD. For such 'dummy' subs, C<can> +will still return a code reference, which, when called, will fall through +to the AUTOLOAD. If no suitable AUTOLOAD is provided, calling the coderef +will cause an error. + +C<can> can be called as a class (static) method, an object method, or a +function. + +When used as a function, if C<VAL> is a blessed reference or package name which +has a method called C<METHOD>, C<can> returns a reference to the subroutine. +If C<VAL> is not a blessed reference, or if it does not have a method +C<METHOD>, I<undef> is returned. + +=item VERSION ( [ REQUIRE ] ) + +C<VERSION> will return the value of the variable C<$VERSION> in the +package the object is blessed into. If C<REQUIRE> is given then +it will do a comparison and die if the package version is not +greater than or equal to C<REQUIRE>. + +C<VERSION> can be called as either a class (static) method, an object method or +or a function. + + +=back + +These subroutines should I<not> be imported via S<C<use UNIVERSAL qw(...)>>. +If you want simple local access to them you can do + + *isa = \&UNIVERSAL::isa; + +to import isa into your package. + +=cut diff --git a/Master/xemtex/perl/lib/XSLoader.pm b/Master/xemtex/perl/lib/XSLoader.pm new file mode 100644 index 00000000000..c5b3300a458 --- /dev/null +++ b/Master/xemtex/perl/lib/XSLoader.pm @@ -0,0 +1,138 @@ +# Generated from XSLoader.pm.PL (resolved %Config::Config value) + +package XSLoader; + +# And Gandalf said: 'Many folk like to know beforehand what is to +# be set on the table; but those who have laboured to prepare the +# feast like to keep their secret; for wonder makes the words of +# praise louder.' + +# (Quote from Tolkien sugested by Anno Siegel.) +# +# See pod text at end of file for documentation. +# See also ext/DynaLoader/README in source tree for other information. +# +# Tim.Bunce@ig.co.uk, August 1994 + +$VERSION = "0.01"; # avoid typo warning + +# enable debug/trace messages from DynaLoader perl code +# $dl_debug = $ENV{PERL_DL_DEBUG} || 0 unless defined $dl_debug; + + my $dl_dlext = 'dll'; + +package DynaLoader; + +# No prizes for guessing why we don't say 'bootstrap DynaLoader;' here. +# NOTE: All dl_*.xs (including dl_none.xs) define a dl_error() XSUB +boot_DynaLoader('DynaLoader') if defined(&boot_DynaLoader) && + !defined(&dl_error); +package XSLoader; + +1; # End of main code + +# The bootstrap function cannot be autoloaded (without complications) +# so we define it here: + +sub load { + package DynaLoader; + + my($module) = $_[0]; + + # work with static linking too + my $b = "$module\::bootstrap"; + goto &$b if defined &$b; + + goto retry unless $module and defined &dl_load_file; + + my @modparts = split(/::/,$module); + my $modfname = $modparts[-1]; + + my $modpname = join('/',@modparts); + my $modlibname = (caller())[1]; + my $c = @modparts; + $modlibname =~ s,[\\/][^\\/]+$,, while $c--; # Q&D basename + my $file = "$modlibname/auto/$modpname/$modfname.$dl_dlext"; + +# print STDERR "XSLoader::load for $module ($file)\n" if $dl_debug; + + my $bs = $file; + $bs =~ s/(\.\w+)?(;\d*)?$/\.bs/; # look for .bs 'beside' the library + + goto retry if not -f $file or -s $bs; + + my $bootname = "boot_$module"; + $bootname =~ s/\W/_/g; + @dl_require_symbols = ($bootname); + + my $boot_symbol_ref; + + if ($^O eq 'darwin') { + if ($boot_symbol_ref = dl_find_symbol(0, $bootname)) { + goto boot; #extension library has already been loaded, e.g. darwin + } + } + + # Many dynamic extension loading problems will appear to come from + # this section of code: XYZ failed at line 123 of DynaLoader.pm. + # Often these errors are actually occurring in the initialisation + # C code of the extension XS file. Perl reports the error as being + # in this perl code simply because this was the last perl code + # it executed. + + my $libref = dl_load_file($file, 0) or do { + require Carp; + Carp::croak("Can't load '$file' for module $module: " . dl_error()); + }; + push(@dl_librefs,$libref); # record loaded object + + my @unresolved = dl_undef_symbols(); + if (@unresolved) { + require Carp; + Carp::carp("Undefined symbols present after loading $file: @unresolved\n"); + } + + $boot_symbol_ref = dl_find_symbol($libref, $bootname) or do { + require Carp; + Carp::croak("Can't find '$bootname' symbol in $file\n"); + }; + + push(@dl_modules, $module); # record loaded module + + boot: + my $xs = dl_install_xsub("${module}::bootstrap", $boot_symbol_ref, $file); + + # See comment block above + return &$xs(@_); + + retry: + require DynaLoader; + goto &DynaLoader::bootstrap_inherit; +} + +__END__ + +=head1 NAME + +XSLoader - Dynamically load C libraries into Perl code + +=head1 SYNOPSIS + + package YourPackage; + use XSLoader; + + XSLoader::load 'YourPackage', @args; + +=head1 DESCRIPTION + +This module defines a standard I<simplified> interface to the dynamic +linking mechanisms available on many platforms. Its primary purpose is +to implement cheap automatic dynamic loading of Perl modules. + +For more complicated interface see L<DynaLoader>. + +=head1 AUTHOR + +Ilya Zakharevich: extraction from DynaLoader. + +=cut diff --git a/Master/xemtex/perl/lib/attributes.pm b/Master/xemtex/perl/lib/attributes.pm new file mode 100644 index 00000000000..2dacd02751e --- /dev/null +++ b/Master/xemtex/perl/lib/attributes.pm @@ -0,0 +1,414 @@ +package attributes; + +our $VERSION = 0.05; + +@EXPORT_OK = qw(get reftype); +@EXPORT = (); +%EXPORT_TAGS = (ALL => [@EXPORT, @EXPORT_OK]); + +use strict; + +sub croak { + require Carp; + goto &Carp::croak; +} + +sub carp { + require Carp; + goto &Carp::carp; +} + +## forward declaration(s) rather than wrapping the bootstrap call in BEGIN{} +#sub reftype ($) ; +#sub _fetch_attrs ($) ; +#sub _guess_stash ($) ; +#sub _modify_attrs ; +#sub _warn_reserved () ; +# +# The extra trips through newATTRSUB in the interpreter wipe out any savings +# from avoiding the BEGIN block. Just do the bootstrap now. +BEGIN { bootstrap attributes } + +sub import { + @_ > 2 && ref $_[2] or do { + require Exporter; + goto &Exporter::import; + }; + my (undef,$home_stash,$svref,@attrs) = @_; + + my $svtype = uc reftype($svref); + my $pkgmeth; + $pkgmeth = UNIVERSAL::can($home_stash, "MODIFY_${svtype}_ATTRIBUTES") + if defined $home_stash && $home_stash ne ''; + my @badattrs; + if ($pkgmeth) { + my @pkgattrs = _modify_attrs($svref, @attrs); + @badattrs = $pkgmeth->($home_stash, $svref, @attrs); + if (!@badattrs && @pkgattrs) { + return unless _warn_reserved; + @pkgattrs = grep { m/\A[[:lower:]]+(?:\z|\()/ } @pkgattrs; + if (@pkgattrs) { + for my $attr (@pkgattrs) { + $attr =~ s/\(.+\z//s; + } + my $s = ((@pkgattrs == 1) ? '' : 's'); + carp "$svtype package attribute$s " . + "may clash with future reserved word$s: " . + join(' : ' , @pkgattrs); + } + } + } + else { + @badattrs = _modify_attrs($svref, @attrs); + } + if (@badattrs) { + croak "Invalid $svtype attribute" . + (( @badattrs == 1 ) ? '' : 's') . + ": " . + join(' : ', @badattrs); + } +} + +sub get ($) { + @_ == 1 && ref $_[0] or + croak 'Usage: '.__PACKAGE__.'::get $ref'; + my $svref = shift; + my $svtype = uc reftype $svref; + my $stash = _guess_stash $svref; + $stash = caller unless defined $stash; + my $pkgmeth; + $pkgmeth = UNIVERSAL::can($stash, "FETCH_${svtype}_ATTRIBUTES") + if defined $stash && $stash ne ''; + return $pkgmeth ? + (_fetch_attrs($svref), $pkgmeth->($stash, $svref)) : + (_fetch_attrs($svref)) + ; +} + +sub require_version { goto &UNIVERSAL::VERSION } + +1; +__END__ +#The POD goes here + +=head1 NAME + +attributes - get/set subroutine or variable attributes + +=head1 SYNOPSIS + + sub foo : method ; + my ($x,@y,%z) : Bent = 1; + my $s = sub : method { ... }; + + use attributes (); # optional, to get subroutine declarations + my @attrlist = attributes::get(\&foo); + + use attributes 'get'; # import the attributes::get subroutine + my @attrlist = get \&foo; + +=head1 DESCRIPTION + +Subroutine declarations and definitions may optionally have attribute lists +associated with them. (Variable C<my> declarations also may, but see the +warning below.) Perl handles these declarations by passing some information +about the call site and the thing being declared along with the attribute +list to this module. In particular, the first example above is equivalent to +the following: + + use attributes __PACKAGE__, \&foo, 'method'; + +The second example in the synopsis does something equivalent to this: + + use attributes (); + my ($x,@y,%z); + attributes::->import(__PACKAGE__, \$x, 'Bent'); + attributes::->import(__PACKAGE__, \@y, 'Bent'); + attributes::->import(__PACKAGE__, \%z, 'Bent'); + ($x,@y,%z) = 1; + +Yes, that's a lot of expansion. + +B<WARNING>: attribute declarations for variables are still evolving. +The semantics and interfaces of such declarations could change in +future versions. They are present for purposes of experimentation +with what the semantics ought to be. Do not rely on the current +implementation of this feature. + +There are only a few attributes currently handled by Perl itself (or +directly by this module, depending on how you look at it.) However, +package-specific attributes are allowed by an extension mechanism. +(See L<"Package-specific Attribute Handling"> below.) + +The setting of subroutine attributes happens at compile time. +Variable attributes in C<our> declarations are also applied at compile time. +However, C<my> variables get their attributes applied at run-time. +This means that you have to I<reach> the run-time component of the C<my> +before those attributes will get applied. For example: + + my $x : Bent = 42 if 0; + +will neither assign 42 to $x I<nor> will it apply the C<Bent> attribute +to the variable. + +An attempt to set an unrecognized attribute is a fatal error. (The +error is trappable, but it still stops the compilation within that +C<eval>.) Setting an attribute with a name that's all lowercase +letters that's not a built-in attribute (such as "foo") will result in +a warning with B<-w> or C<use warnings 'reserved'>. + +=head2 Built-in Attributes + +The following are the built-in attributes for subroutines: + +=over 4 + +=item locked + +Setting this attribute is only meaningful when the subroutine or +method is to be called by multiple threads. When set on a method +subroutine (i.e., one marked with the B<method> attribute below), +Perl ensures that any invocation of it implicitly locks its first +argument before execution. When set on a non-method subroutine, +Perl ensures that a lock is taken on the subroutine itself before +execution. The semantics of the lock are exactly those of one +explicitly taken with the C<lock> operator immediately after the +subroutine is entered. + +=item method + +Indicates that the referenced subroutine is a method. +This has a meaning when taken together with the B<locked> attribute, +as described there. It also means that a subroutine so marked +will not trigger the "Ambiguous call resolved as CORE::%s" warning. + +=item lvalue + +Indicates that the referenced subroutine is a valid lvalue and can +be assigned to. The subroutine must return a modifiable value such +as a scalar variable, as described in L<perlsub>. + +=back + +For global variables there is C<unique> attribute: see L<perlfunc/our>. + +=head2 Available Subroutines + +The following subroutines are available for general use once this module +has been loaded: + +=over 4 + +=item get + +This routine expects a single parameter--a reference to a +subroutine or variable. It returns a list of attributes, which may be +empty. If passed invalid arguments, it uses die() (via L<Carp::croak|Carp>) +to raise a fatal exception. If it can find an appropriate package name +for a class method lookup, it will include the results from a +C<FETCH_I<type>_ATTRIBUTES> call in its return list, as described in +L<"Package-specific Attribute Handling"> below. +Otherwise, only L<built-in attributes|"Built-in Attributes"> will be returned. + +=item reftype + +This routine expects a single parameter--a reference to a subroutine or +variable. It returns the built-in type of the referenced variable, +ignoring any package into which it might have been blessed. +This can be useful for determining the I<type> value which forms part of +the method names described in L<"Package-specific Attribute Handling"> below. + +=back + +Note that these routines are I<not> exported by default. + +=head2 Package-specific Attribute Handling + +B<WARNING>: the mechanisms described here are still experimental. Do not +rely on the current implementation. In particular, there is no provision +for applying package attributes to 'cloned' copies of subroutines used as +closures. (See L<perlref/"Making References"> for information on closures.) +Package-specific attribute handling may change incompatibly in a future +release. + +When an attribute list is present in a declaration, a check is made to see +whether an attribute 'modify' handler is present in the appropriate package +(or its @ISA inheritance tree). Similarly, when C<attributes::get> is +called on a valid reference, a check is made for an appropriate attribute +'fetch' handler. See L<"EXAMPLES"> to see how the "appropriate package" +determination works. + +The handler names are based on the underlying type of the variable being +declared or of the reference passed. Because these attributes are +associated with subroutine or variable declarations, this deliberately +ignores any possibility of being blessed into some package. Thus, a +subroutine declaration uses "CODE" as its I<type>, and even a blessed +hash reference uses "HASH" as its I<type>. + +The class methods invoked for modifying and fetching are these: + +=over 4 + +=item FETCH_I<type>_ATTRIBUTES + +This method receives a single argument, which is a reference to the +variable or subroutine for which package-defined attributes are desired. +The expected return value is a list of associated attributes. +This list may be empty. + +=item MODIFY_I<type>_ATTRIBUTES + +This method is called with two fixed arguments, followed by the list of +attributes from the relevant declaration. The two fixed arguments are +the relevant package name and a reference to the declared subroutine or +variable. The expected return value as a list of attributes which were +not recognized by this handler. Note that this allows for a derived class +to delegate a call to its base class, and then only examine the attributes +which the base class didn't already handle for it. + +The call to this method is currently made I<during> the processing of the +declaration. In particular, this means that a subroutine reference will +probably be for an undefined subroutine, even if this declaration is +actually part of the definition. + +=back + +Calling C<attributes::get()> from within the scope of a null package +declaration C<package ;> for an unblessed variable reference will +not provide any starting package name for the 'fetch' method lookup. +Thus, this circumstance will not result in a method call for package-defined +attributes. A named subroutine knows to which symbol table entry it belongs +(or originally belonged), and it will use the corresponding package. +An anonymous subroutine knows the package name into which it was compiled +(unless it was also compiled with a null package declaration), and so it +will use that package name. + +=head2 Syntax of Attribute Lists + +An attribute list is a sequence of attribute specifications, separated by +whitespace or a colon (with optional whitespace). +Each attribute specification is a simple +name, optionally followed by a parenthesised parameter list. +If such a parameter list is present, it is scanned past as for the rules +for the C<q()> operator. (See L<perlop/"Quote and Quote-like Operators">.) +The parameter list is passed as it was found, however, and not as per C<q()>. + +Some examples of syntactically valid attribute lists: + + switch(10,foo(7,3)) : expensive + Ugly('\(") :Bad + _5x5 + locked method + +Some examples of syntactically invalid attribute lists (with annotation): + + switch(10,foo() # ()-string not balanced + Ugly('(') # ()-string not balanced + 5x5 # "5x5" not a valid identifier + Y2::north # "Y2::north" not a simple identifier + foo + bar # "+" neither a colon nor whitespace + +=head1 EXPORTS + +=head2 Default exports + +None. + +=head2 Available exports + +The routines C<get> and C<reftype> are exportable. + +=head2 Export tags defined + +The C<:ALL> tag will get all of the above exports. + +=head1 EXAMPLES + +Here are some samples of syntactically valid declarations, with annotation +as to how they resolve internally into C<use attributes> invocations by +perl. These examples are primarily useful to see how the "appropriate +package" is found for the possible method lookups for package-defined +attributes. + +=over 4 + +=item 1. + +Code: + + package Canine; + package Dog; + my Canine $spot : Watchful ; + +Effect: + + use attributes (); + attributes::->import(Canine => \$spot, "Watchful"); + +=item 2. + +Code: + + package Felis; + my $cat : Nervous; + +Effect: + + use attributes (); + attributes::->import(Felis => \$cat, "Nervous"); + +=item 3. + +Code: + + package X; + sub foo : locked ; + +Effect: + + use attributes X => \&foo, "locked"; + +=item 4. + +Code: + + package X; + sub Y::x : locked { 1 } + +Effect: + + use attributes Y => \&Y::x, "locked"; + +=item 5. + +Code: + + package X; + sub foo { 1 } + + package Y; + BEGIN { *bar = \&X::foo; } + + package Z; + sub Y::bar : locked ; + +Effect: + + use attributes X => \&X::foo, "locked"; + +=back + +This last example is purely for purposes of completeness. You should not +be trying to mess with the attributes of something in a package that's +not your own. + +=head1 SEE ALSO + +L<perlsub/"Private Variables via my()"> and +L<perlsub/"Subroutine Attributes"> for details on the basic declarations; +L<attrs> for the obsolescent form of subroutine attribute specification +which this module replaces; +L<perlfunc/use> for details on the normal invocation mechanism. + +=cut + diff --git a/Master/xemtex/perl/lib/auto/B/B.dll b/Master/xemtex/perl/lib/auto/B/B.dll Binary files differnew file mode 100644 index 00000000000..78e25799a7e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/B/B.dll diff --git a/Master/xemtex/perl/lib/auto/Cwd/Cwd.dll b/Master/xemtex/perl/lib/auto/Cwd/Cwd.dll Binary files differnew file mode 100644 index 00000000000..e06e55e5288 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/Cwd/Cwd.dll diff --git a/Master/xemtex/perl/lib/auto/Data/Dumper/Dumper.dll b/Master/xemtex/perl/lib/auto/Data/Dumper/Dumper.dll Binary files differnew file mode 100644 index 00000000000..f6bbfbc9e70 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/Data/Dumper/Dumper.dll diff --git a/Master/xemtex/perl/lib/auto/Digest/MD5/MD5.dll b/Master/xemtex/perl/lib/auto/Digest/MD5/MD5.dll Binary files differnew file mode 100644 index 00000000000..4892ae02cec --- /dev/null +++ b/Master/xemtex/perl/lib/auto/Digest/MD5/MD5.dll diff --git a/Master/xemtex/perl/lib/auto/DynaLoader/autosplit.ix b/Master/xemtex/perl/lib/auto/DynaLoader/autosplit.ix new file mode 100644 index 00000000000..d7605efa074 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/DynaLoader/autosplit.ix @@ -0,0 +1,8 @@ +# Index created by AutoSplit for ../LIB\DynaLoader.pm +# (file acts as timestamp) +package DynaLoader; +sub dl_findfile ; +sub dl_expandspec ; +sub dl_find_symbol_anywhere +; +1; diff --git a/Master/xemtex/perl/lib/auto/DynaLoader/dl_expandspec.al b/Master/xemtex/perl/lib/auto/DynaLoader/dl_expandspec.al new file mode 100644 index 00000000000..2943afff245 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/DynaLoader/dl_expandspec.al @@ -0,0 +1,34 @@ +# NOTE: Derived from ../LIB\DynaLoader.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package DynaLoader; + +#line 373 "../LIB\DynaLoader.pm (autosplit into ..\lib\auto\DynaLoader\dl_expandspec.al)" +sub dl_expandspec { + my($spec) = @_; + # Optional function invoked if DynaLoader.pm sets $do_expand. + # Most systems do not require or use this function. + # Some systems may implement it in the dl_*.xs file in which case + # this autoload version will not be called but is harmless. + + # This function is designed to deal with systems which treat some + # 'filenames' in a special way. For example VMS 'Logical Names' + # (something like unix environment variables - but different). + # This function should recognise such names and expand them into + # full file paths. + # Must return undef if $spec is invalid or file does not exist. + + my $file = $spec; # default output to input + + if ($Is_VMS) { # dl_expandspec should be defined in dl_vms.xs + require Carp; + Carp::croak("dl_expandspec: should be defined in XS file!\n"); + } else { + return undef unless -f $file; + } + print STDERR "dl_expandspec($spec) => $file\n" if $dl_debug; + $file; +} + +# end of DynaLoader::dl_expandspec +1; diff --git a/Master/xemtex/perl/lib/auto/DynaLoader/dl_find_symbol_anywhere.al b/Master/xemtex/perl/lib/auto/DynaLoader/dl_find_symbol_anywhere.al new file mode 100644 index 00000000000..b4a6ad15f09 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/DynaLoader/dl_find_symbol_anywhere.al @@ -0,0 +1,19 @@ +# NOTE: Derived from ../LIB\DynaLoader.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package DynaLoader; + +#line 399 "../LIB\DynaLoader.pm (autosplit into ..\lib\auto\DynaLoader\dl_find_symbol_anywhere.al)" +sub dl_find_symbol_anywhere +{ + my $sym = shift; + my $libref; + foreach $libref (@dl_librefs) { + my $symref = dl_find_symbol($libref,$sym); + return $symref if $symref; + } + return undef; +} + +1; +# end of DynaLoader::dl_find_symbol_anywhere diff --git a/Master/xemtex/perl/lib/auto/DynaLoader/dl_findfile.al b/Master/xemtex/perl/lib/auto/DynaLoader/dl_findfile.al new file mode 100644 index 00000000000..d91cf60d194 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/DynaLoader/dl_findfile.al @@ -0,0 +1,115 @@ +# NOTE: Derived from ../LIB\DynaLoader.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package DynaLoader; + +#line 265 "../LIB\DynaLoader.pm (autosplit into ..\lib\auto\DynaLoader\dl_findfile.al)" +sub dl_findfile { + # Read ext/DynaLoader/DynaLoader.doc for detailed information. + # This function does not automatically consider the architecture + # or the perl library auto directories. + my (@args) = @_; + my (@dirs, $dir); # which directories to search + my (@found); # full paths to real files we have found + my $dl_ext= 'dll'; # $Config::Config{'dlext'} suffix for perl extensions + my $dl_so = 'dll'; # $Config::Config{'so'} suffix for shared libraries + + print STDERR "dl_findfile(@args)\n" if $dl_debug; + + # accumulate directories but process files as they appear + arg: foreach(@args) { + # Special fast case: full filepath requires no search + if ($Is_VMS && m%[:>/\]]% && -f $_) { + push(@found,dl_expandspec(VMS::Filespec::vmsify($_))); + last arg unless wantarray; + next; + } + elsif ($Is_MacOS) { + if (m/:/ && -f $_) { + push(@found,$_); + last arg unless wantarray; + } + } + elsif (m:/: && -f $_ && !$do_expand) { + push(@found,$_); + last arg unless wantarray; + next; + } + + # Deal with directories first: + # Using a -L prefix is the preferred option (faster and more robust) + if (m:^-L:) { s/^-L//; push(@dirs, $_); next; } + + if ($Is_MacOS) { + # Otherwise we try to try to spot directories by a heuristic + # (this is a more complicated issue than it first appears) + if (m/:/ && -d $_) { push(@dirs, $_); next; } + # Only files should get this far... + my(@names, $name); # what filenames to look for + s/^-l//; + push(@names, $_); + foreach $dir (@dirs, @dl_library_path) { + next unless -d $dir; + $dir =~ s/^([^:]+)$/:$1/; + $dir =~ s/:$//; + foreach $name (@names) { + my($file) = "$dir:$name"; + print STDERR " checking in $dir for $name\n" if $dl_debug; + if (-f $file) { + push(@found, $file); + next arg; # no need to look any further + } + } + } + next; + } + + # Otherwise we try to try to spot directories by a heuristic + # (this is a more complicated issue than it first appears) + if (m:/: && -d $_) { push(@dirs, $_); next; } + + # VMS: we may be using native VMS directory syntax instead of + # Unix emulation, so check this as well + if ($Is_VMS && /[:>\]]/ && -d $_) { push(@dirs, $_); next; } + + # Only files should get this far... + my(@names, $name); # what filenames to look for + if (m:-l: ) { # convert -lname to appropriate library name + s/-l//; + push(@names,"lib$_.$dl_so"); + push(@names,"lib$_.a"); + } else { # Umm, a bare name. Try various alternatives: + # these should be ordered with the most likely first + push(@names,"$_.$dl_ext") unless m/\.$dl_ext$/o; + push(@names,"$_.$dl_so") unless m/\.$dl_so$/o; + push(@names,"lib$_.$dl_so") unless m:/:; + push(@names,"$_.a") if !m/\.a$/ and $dlsrc eq "dl_dld.xs"; + push(@names, $_); + } + foreach $dir (@dirs, @dl_library_path) { + next unless -d $dir; + chop($dir = VMS::Filespec::unixpath($dir)) if $Is_VMS; + foreach $name (@names) { + my($file) = "$dir/$name"; + print STDERR " checking in $dir for $name\n" if $dl_debug; + $file = ($do_expand) ? dl_expandspec($file) : (-f $file && $file); + #$file = _check_file($file); + if ($file) { + push(@found, $file); + next arg; # no need to look any further + } + } + } + } + if ($dl_debug) { + foreach(@dirs) { + print STDERR " dl_findfile ignored non-existent directory: $_\n" unless -d $_; + } + print STDERR "dl_findfile found: @found\n"; + } + return $found[0] unless wantarray; + @found; +} + +# end of DynaLoader::dl_findfile +1; diff --git a/Master/xemtex/perl/lib/auto/Fcntl/Fcntl.dll b/Master/xemtex/perl/lib/auto/Fcntl/Fcntl.dll Binary files differnew file mode 100644 index 00000000000..5cea87d315c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/Fcntl/Fcntl.dll diff --git a/Master/xemtex/perl/lib/auto/File/Glob/Glob.dll b/Master/xemtex/perl/lib/auto/File/Glob/Glob.dll Binary files differnew file mode 100644 index 00000000000..0ba64866dd3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/File/Glob/Glob.dll diff --git a/Master/xemtex/perl/lib/auto/IO/IO.dll b/Master/xemtex/perl/lib/auto/IO/IO.dll Binary files differnew file mode 100644 index 00000000000..60d92c3a6c0 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/IO/IO.dll diff --git a/Master/xemtex/perl/lib/auto/List/Util/Util.dll b/Master/xemtex/perl/lib/auto/List/Util/Util.dll Binary files differnew file mode 100644 index 00000000000..efb06c7f240 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/List/Util/Util.dll diff --git a/Master/xemtex/perl/lib/auto/POSIX/POSIX.dll b/Master/xemtex/perl/lib/auto/POSIX/POSIX.dll Binary files differnew file mode 100644 index 00000000000..2e090c5e742 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/POSIX.dll diff --git a/Master/xemtex/perl/lib/auto/POSIX/abs.al b/Master/xemtex/perl/lib/auto/POSIX/abs.al new file mode 100644 index 00000000000..298fd61df5c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/abs.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 391 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\abs.al)" +sub abs { + usage "abs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +# end of POSIX::abs +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/alarm.al b/Master/xemtex/perl/lib/auto/POSIX/alarm.al new file mode 100644 index 00000000000..3be4c8dc908 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/alarm.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 608 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\alarm.al)" +sub alarm { + usage "alarm(seconds)" if @_ != 1; + CORE::alarm($_[0]); +} + +# end of POSIX::alarm +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/assert.al b/Master/xemtex/perl/lib/auto/POSIX/assert.al new file mode 100644 index 00000000000..def2f62f767 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/assert.al @@ -0,0 +1,15 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 77 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\assert.al)" +sub assert { + usage "assert(expr)" if @_ != 1; + if (!$_[0]) { + croak "Assertion failed"; + } +} + +# end of POSIX::assert +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/atan2.al b/Master/xemtex/perl/lib/auto/POSIX/atan2.al new file mode 100644 index 00000000000..30795e97c4b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/atan2.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 142 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\atan2.al)" +sub atan2 { + usage "atan2(x,y)" if @_ != 2; + CORE::atan2($_[0], $_[1]); +} + +# end of POSIX::atan2 +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/atexit.al b/Master/xemtex/perl/lib/auto/POSIX/atexit.al new file mode 100644 index 00000000000..f8e4e9ef393 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/atexit.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 396 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\atexit.al)" +sub atexit { + unimpl "atexit() is C-specific: use END {} instead"; +} + +# end of POSIX::atexit +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/atof.al b/Master/xemtex/perl/lib/auto/POSIX/atof.al new file mode 100644 index 00000000000..731267c6b40 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/atof.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 400 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\atof.al)" +sub atof { + unimpl "atof() is C-specific, stopped"; +} + +# end of POSIX::atof +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/atoi.al b/Master/xemtex/perl/lib/auto/POSIX/atoi.al new file mode 100644 index 00000000000..a48dc6c29c3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/atoi.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 404 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\atoi.al)" +sub atoi { + unimpl "atoi() is C-specific, stopped"; +} + +# end of POSIX::atoi +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/atol.al b/Master/xemtex/perl/lib/auto/POSIX/atol.al new file mode 100644 index 00000000000..ba2278ca041 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/atol.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 408 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\atol.al)" +sub atol { + unimpl "atol() is C-specific, stopped"; +} + +# end of POSIX::atol +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/autosplit.ix b/Master/xemtex/perl/lib/auto/POSIX/autosplit.ix new file mode 100644 index 00000000000..7f244a3fb86 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/autosplit.ix @@ -0,0 +1,153 @@ +# Index created by AutoSplit for ..\..\lib\POSIX.pm +# (file acts as timestamp) +package POSIX; +sub usage ; +sub redef ; +sub unimpl ; +sub assert ; +sub tolower ; +sub toupper ; +sub closedir ; +sub opendir ; +sub readdir ; +sub rewinddir ; +sub errno ; +sub creat ; +sub fcntl ; +sub getgrgid ; +sub getgrnam ; +sub atan2 ; +sub cos ; +sub exp ; +sub fabs ; +sub log ; +sub pow ; +sub sin ; +sub sqrt ; +sub getpwnam ; +sub getpwuid ; +sub longjmp ; +sub setjmp ; +sub siglongjmp ; +sub sigsetjmp ; +sub kill ; +sub raise ; +sub offsetof ; +sub clearerr ; +sub fclose ; +sub fdopen ; +sub feof ; +sub fgetc ; +sub fgets ; +sub fileno ; +sub fopen ; +sub fprintf ; +sub fputc ; +sub fputs ; +sub fread ; +sub freopen ; +sub fscanf ; +sub fseek ; +sub ferror ; +sub fflush ; +sub fgetpos ; +sub fsetpos ; +sub ftell ; +sub fwrite ; +sub getc ; +sub getchar ; +sub gets ; +sub perror ; +sub printf ; +sub putc ; +sub putchar ; +sub puts ; +sub remove ; +sub rename ; +sub rewind ; +sub scanf ; +sub sprintf ; +sub sscanf ; +sub tmpfile ; +sub ungetc ; +sub vfprintf ; +sub vprintf ; +sub vsprintf ; +sub abs ; +sub atexit ; +sub atof ; +sub atoi ; +sub atol ; +sub bsearch ; +sub calloc ; +sub div ; +sub exit ; +sub free ; +sub getenv ; +sub labs ; +sub ldiv ; +sub malloc ; +sub qsort ; +sub rand ; +sub realloc ; +sub srand ; +sub system ; +sub memchr ; +sub memcmp ; +sub memcpy ; +sub memmove ; +sub memset ; +sub strcat ; +sub strchr ; +sub strcmp ; +sub strcpy ; +sub strcspn ; +sub strerror ; +sub strlen ; +sub strncat ; +sub strncmp ; +sub strncpy ; +sub strpbrk ; +sub strrchr ; +sub strspn ; +sub strstr ; +sub strtok ; +sub chmod ; +sub fstat ; +sub mkdir ; +sub stat ; +sub umask ; +sub wait ; +sub waitpid ; +sub gmtime ; +sub localtime ; +sub time ; +sub alarm ; +sub chdir ; +sub chown ; +sub execl ; +sub execle ; +sub execlp ; +sub execv ; +sub execve ; +sub execvp ; +sub fork ; +sub getegid ; +sub geteuid ; +sub getgid ; +sub getgroups ; +sub getlogin ; +sub getpgrp ; +sub getpid ; +sub getppid ; +sub getuid ; +sub isatty ; +sub link ; +sub rmdir ; +sub setbuf ; +sub setvbuf ; +sub sleep ; +sub unlink ; +sub utime ; +sub load_imports ; +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/bsearch.al b/Master/xemtex/perl/lib/auto/POSIX/bsearch.al new file mode 100644 index 00000000000..ae569040e00 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/bsearch.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 412 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\bsearch.al)" +sub bsearch { + unimpl "bsearch() not supplied"; +} + +# end of POSIX::bsearch +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/calloc.al b/Master/xemtex/perl/lib/auto/POSIX/calloc.al new file mode 100644 index 00000000000..8375767c30b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/calloc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 416 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\calloc.al)" +sub calloc { + unimpl "calloc() is C-specific, stopped"; +} + +# end of POSIX::calloc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/chdir.al b/Master/xemtex/perl/lib/auto/POSIX/chdir.al new file mode 100644 index 00000000000..7ebaad5aa95 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/chdir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 613 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\chdir.al)" +sub chdir { + usage "chdir(directory)" if @_ != 1; + CORE::chdir($_[0]); +} + +# end of POSIX::chdir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/chmod.al b/Master/xemtex/perl/lib/auto/POSIX/chmod.al new file mode 100644 index 00000000000..e57badcb3dd --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/chmod.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 554 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\chmod.al)" +sub chmod { + usage "chmod(mode, filename)" if @_ != 2; + CORE::chmod($_[0], $_[1]); +} + +# end of POSIX::chmod +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/chown.al b/Master/xemtex/perl/lib/auto/POSIX/chown.al new file mode 100644 index 00000000000..cfc23f0b072 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/chown.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 618 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\chown.al)" +sub chown { + usage "chown(filename, uid, gid)" if @_ != 3; + CORE::chown($_[0], $_[1], $_[2]); +} + +# end of POSIX::chown +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/clearerr.al b/Master/xemtex/perl/lib/auto/POSIX/clearerr.al new file mode 100644 index 00000000000..8c3b70743cb --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/clearerr.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 222 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\clearerr.al)" +sub clearerr { + redef "IO::Handle::clearerr()"; +} + +# end of POSIX::clearerr +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/closedir.al b/Master/xemtex/perl/lib/auto/POSIX/closedir.al new file mode 100644 index 00000000000..7ecdf46af31 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/closedir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 94 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\closedir.al)" +sub closedir { + usage "closedir(dirhandle)" if @_ != 1; + CORE::closedir($_[0]); +} + +# end of POSIX::closedir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/cos.al b/Master/xemtex/perl/lib/auto/POSIX/cos.al new file mode 100644 index 00000000000..17a90b50286 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/cos.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 147 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\cos.al)" +sub cos { + usage "cos(x)" if @_ != 1; + CORE::cos($_[0]); +} + +# end of POSIX::cos +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/creat.al b/Master/xemtex/perl/lib/auto/POSIX/creat.al new file mode 100644 index 00000000000..4645b72ab0e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/creat.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 122 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\creat.al)" +sub creat { + usage "creat(filename, mode)" if @_ != 2; + &open($_[0], &O_WRONLY | &O_CREAT | &O_TRUNC, $_[1]); +} + +# end of POSIX::creat +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/div.al b/Master/xemtex/perl/lib/auto/POSIX/div.al new file mode 100644 index 00000000000..272d1d23bbb --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/div.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 420 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\div.al)" +sub div { + unimpl "div() is C-specific, stopped"; +} + +# end of POSIX::div +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/errno.al b/Master/xemtex/perl/lib/auto/POSIX/errno.al new file mode 100644 index 00000000000..5195ab1efe1 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/errno.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 117 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\errno.al)" +sub errno { + usage "errno()" if @_ != 0; + $! + 0; +} + +# end of POSIX::errno +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execl.al b/Master/xemtex/perl/lib/auto/POSIX/execl.al new file mode 100644 index 00000000000..4f0e27566e8 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execl.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 623 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execl.al)" +sub execl { + unimpl "execl() is C-specific, stopped"; +} + +# end of POSIX::execl +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execle.al b/Master/xemtex/perl/lib/auto/POSIX/execle.al new file mode 100644 index 00000000000..303af430e07 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execle.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 627 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execle.al)" +sub execle { + unimpl "execle() is C-specific, stopped"; +} + +# end of POSIX::execle +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execlp.al b/Master/xemtex/perl/lib/auto/POSIX/execlp.al new file mode 100644 index 00000000000..772f718e44e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execlp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 631 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execlp.al)" +sub execlp { + unimpl "execlp() is C-specific, stopped"; +} + +# end of POSIX::execlp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execv.al b/Master/xemtex/perl/lib/auto/POSIX/execv.al new file mode 100644 index 00000000000..85b211db4ab --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execv.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 635 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execv.al)" +sub execv { + unimpl "execv() is C-specific, stopped"; +} + +# end of POSIX::execv +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execve.al b/Master/xemtex/perl/lib/auto/POSIX/execve.al new file mode 100644 index 00000000000..919580cbed1 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execve.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 639 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execve.al)" +sub execve { + unimpl "execve() is C-specific, stopped"; +} + +# end of POSIX::execve +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/execvp.al b/Master/xemtex/perl/lib/auto/POSIX/execvp.al new file mode 100644 index 00000000000..f55f8495f8d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/execvp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 643 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\execvp.al)" +sub execvp { + unimpl "execvp() is C-specific, stopped"; +} + +# end of POSIX::execvp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/exit.al b/Master/xemtex/perl/lib/auto/POSIX/exit.al new file mode 100644 index 00000000000..b03a880d66a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/exit.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 424 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\exit.al)" +sub exit { + usage "exit(status)" if @_ != 1; + CORE::exit($_[0]); +} + +# end of POSIX::exit +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/exp.al b/Master/xemtex/perl/lib/auto/POSIX/exp.al new file mode 100644 index 00000000000..d15d24f1128 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/exp.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 152 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\exp.al)" +sub exp { + usage "exp(x)" if @_ != 1; + CORE::exp($_[0]); +} + +# end of POSIX::exp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fabs.al b/Master/xemtex/perl/lib/auto/POSIX/fabs.al new file mode 100644 index 00000000000..2f5cbce7501 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fabs.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 157 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fabs.al)" +sub fabs { + usage "fabs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +# end of POSIX::fabs +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fclose.al b/Master/xemtex/perl/lib/auto/POSIX/fclose.al new file mode 100644 index 00000000000..1b4f7192da9 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fclose.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 226 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fclose.al)" +sub fclose { + redef "IO::Handle::close()"; +} + +# end of POSIX::fclose +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fcntl.al b/Master/xemtex/perl/lib/auto/POSIX/fcntl.al new file mode 100644 index 00000000000..0d8692e6cd7 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fcntl.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 127 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fcntl.al)" +sub fcntl { + usage "fcntl(filehandle, cmd, arg)" if @_ != 3; + CORE::fcntl($_[0], $_[1], $_[2]); +} + +# end of POSIX::fcntl +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fdopen.al b/Master/xemtex/perl/lib/auto/POSIX/fdopen.al new file mode 100644 index 00000000000..cc4b68b4df0 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fdopen.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 230 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fdopen.al)" +sub fdopen { + redef "IO::Handle::new_from_fd()"; +} + +# end of POSIX::fdopen +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/feof.al b/Master/xemtex/perl/lib/auto/POSIX/feof.al new file mode 100644 index 00000000000..2aa0580f31e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/feof.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 234 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\feof.al)" +sub feof { + redef "IO::Handle::eof()"; +} + +# end of POSIX::feof +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/ferror.al b/Master/xemtex/perl/lib/auto/POSIX/ferror.al new file mode 100644 index 00000000000..864c11609a6 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/ferror.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 282 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\ferror.al)" +sub ferror { + redef "IO::Handle::error()"; +} + +# end of POSIX::ferror +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fflush.al b/Master/xemtex/perl/lib/auto/POSIX/fflush.al new file mode 100644 index 00000000000..d4084b44569 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fflush.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 286 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fflush.al)" +sub fflush { + redef "IO::Handle::flush()"; +} + +# end of POSIX::fflush +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fgetc.al b/Master/xemtex/perl/lib/auto/POSIX/fgetc.al new file mode 100644 index 00000000000..55c6951da44 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fgetc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 238 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fgetc.al)" +sub fgetc { + redef "IO::Handle::getc()"; +} + +# end of POSIX::fgetc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fgetpos.al b/Master/xemtex/perl/lib/auto/POSIX/fgetpos.al new file mode 100644 index 00000000000..e354fdf5a4f --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fgetpos.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 290 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fgetpos.al)" +sub fgetpos { + redef "IO::Seekable::getpos()"; +} + +# end of POSIX::fgetpos +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fgets.al b/Master/xemtex/perl/lib/auto/POSIX/fgets.al new file mode 100644 index 00000000000..adb96ebfed6 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fgets.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 242 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fgets.al)" +sub fgets { + redef "IO::Handle::gets()"; +} + +# end of POSIX::fgets +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fileno.al b/Master/xemtex/perl/lib/auto/POSIX/fileno.al new file mode 100644 index 00000000000..2b9ef0d0f0b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fileno.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 246 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fileno.al)" +sub fileno { + redef "IO::Handle::fileno()"; +} + +# end of POSIX::fileno +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fopen.al b/Master/xemtex/perl/lib/auto/POSIX/fopen.al new file mode 100644 index 00000000000..8a85034722b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fopen.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 250 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fopen.al)" +sub fopen { + redef "IO::File::open()"; +} + +# end of POSIX::fopen +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fork.al b/Master/xemtex/perl/lib/auto/POSIX/fork.al new file mode 100644 index 00000000000..e7a7de97948 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fork.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 647 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fork.al)" +sub fork { + usage "fork()" if @_ != 0; + CORE::fork; +} + +# end of POSIX::fork +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fprintf.al b/Master/xemtex/perl/lib/auto/POSIX/fprintf.al new file mode 100644 index 00000000000..bdcebf38760 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fprintf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 254 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fprintf.al)" +sub fprintf { + unimpl "fprintf() is C-specific--use printf instead"; +} + +# end of POSIX::fprintf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fputc.al b/Master/xemtex/perl/lib/auto/POSIX/fputc.al new file mode 100644 index 00000000000..9233e689600 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fputc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 258 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fputc.al)" +sub fputc { + unimpl "fputc() is C-specific--use print instead"; +} + +# end of POSIX::fputc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fputs.al b/Master/xemtex/perl/lib/auto/POSIX/fputs.al new file mode 100644 index 00000000000..885cf9e4bb3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fputs.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 262 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fputs.al)" +sub fputs { + unimpl "fputs() is C-specific--use print instead"; +} + +# end of POSIX::fputs +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fread.al b/Master/xemtex/perl/lib/auto/POSIX/fread.al new file mode 100644 index 00000000000..ca411635f63 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fread.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 266 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fread.al)" +sub fread { + unimpl "fread() is C-specific--use read instead"; +} + +# end of POSIX::fread +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/free.al b/Master/xemtex/perl/lib/auto/POSIX/free.al new file mode 100644 index 00000000000..83ce0402725 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/free.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 429 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\free.al)" +sub free { + unimpl "free() is C-specific, stopped"; +} + +# end of POSIX::free +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/freopen.al b/Master/xemtex/perl/lib/auto/POSIX/freopen.al new file mode 100644 index 00000000000..cefb9db1dab --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/freopen.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 270 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\freopen.al)" +sub freopen { + unimpl "freopen() is C-specific--use open instead"; +} + +# end of POSIX::freopen +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fscanf.al b/Master/xemtex/perl/lib/auto/POSIX/fscanf.al new file mode 100644 index 00000000000..452877452c6 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fscanf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 274 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fscanf.al)" +sub fscanf { + unimpl "fscanf() is C-specific--use <> and regular expressions instead"; +} + +# end of POSIX::fscanf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fseek.al b/Master/xemtex/perl/lib/auto/POSIX/fseek.al new file mode 100644 index 00000000000..ffefc229066 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fseek.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 278 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fseek.al)" +sub fseek { + redef "IO::Seekable::seek()"; +} + +# end of POSIX::fseek +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fsetpos.al b/Master/xemtex/perl/lib/auto/POSIX/fsetpos.al new file mode 100644 index 00000000000..f43fc57c18a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fsetpos.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 294 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fsetpos.al)" +sub fsetpos { + redef "IO::Seekable::setpos()"; +} + +# end of POSIX::fsetpos +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fstat.al b/Master/xemtex/perl/lib/auto/POSIX/fstat.al new file mode 100644 index 00000000000..cd05ea95007 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fstat.al @@ -0,0 +1,17 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 559 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fstat.al)" +sub fstat { + usage "fstat(fd)" if @_ != 1; + local *TMP; + CORE::open(TMP, "<&$_[0]"); # Gross. + my @l = CORE::stat(TMP); + CORE::close(TMP); + @l; +} + +# end of POSIX::fstat +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/ftell.al b/Master/xemtex/perl/lib/auto/POSIX/ftell.al new file mode 100644 index 00000000000..dd6c347c710 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/ftell.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 298 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\ftell.al)" +sub ftell { + redef "IO::Seekable::tell()"; +} + +# end of POSIX::ftell +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/fwrite.al b/Master/xemtex/perl/lib/auto/POSIX/fwrite.al new file mode 100644 index 00000000000..d51037b1d17 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/fwrite.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 302 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\fwrite.al)" +sub fwrite { + unimpl "fwrite() is C-specific--use print instead"; +} + +# end of POSIX::fwrite +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getc.al b/Master/xemtex/perl/lib/auto/POSIX/getc.al new file mode 100644 index 00000000000..318c4bd6b0f --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getc.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 306 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getc.al)" +sub getc { + usage "getc(handle)" if @_ != 1; + CORE::getc($_[0]); +} + +# end of POSIX::getc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getchar.al b/Master/xemtex/perl/lib/auto/POSIX/getchar.al new file mode 100644 index 00000000000..eb1344fa4cc --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getchar.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 311 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getchar.al)" +sub getchar { + usage "getchar()" if @_ != 0; + CORE::getc(STDIN); +} + +# end of POSIX::getchar +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getegid.al b/Master/xemtex/perl/lib/auto/POSIX/getegid.al new file mode 100644 index 00000000000..6234a682aae --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getegid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 652 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getegid.al)" +sub getegid { + usage "getegid()" if @_ != 0; + $) + 0; +} + +# end of POSIX::getegid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getenv.al b/Master/xemtex/perl/lib/auto/POSIX/getenv.al new file mode 100644 index 00000000000..7ca5395c458 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getenv.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 433 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getenv.al)" +sub getenv { + usage "getenv(name)" if @_ != 1; + $ENV{$_[0]}; +} + +# end of POSIX::getenv +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/geteuid.al b/Master/xemtex/perl/lib/auto/POSIX/geteuid.al new file mode 100644 index 00000000000..829472d16ae --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/geteuid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 657 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\geteuid.al)" +sub geteuid { + usage "geteuid()" if @_ != 0; + $> + 0; +} + +# end of POSIX::geteuid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getgid.al b/Master/xemtex/perl/lib/auto/POSIX/getgid.al new file mode 100644 index 00000000000..b9f60fcea02 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getgid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 662 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getgid.al)" +sub getgid { + usage "getgid()" if @_ != 0; + $( + 0; +} + +# end of POSIX::getgid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getgrgid.al b/Master/xemtex/perl/lib/auto/POSIX/getgrgid.al new file mode 100644 index 00000000000..be95e0badbb --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getgrgid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 132 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getgrgid.al)" +sub getgrgid { + usage "getgrgid(gid)" if @_ != 1; + CORE::getgrgid($_[0]); +} + +# end of POSIX::getgrgid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getgrnam.al b/Master/xemtex/perl/lib/auto/POSIX/getgrnam.al new file mode 100644 index 00000000000..8cda0521600 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getgrnam.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 137 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getgrnam.al)" +sub getgrnam { + usage "getgrnam(name)" if @_ != 1; + CORE::getgrnam($_[0]); +} + +# end of POSIX::getgrnam +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getgroups.al b/Master/xemtex/perl/lib/auto/POSIX/getgroups.al new file mode 100644 index 00000000000..e3a31459b38 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getgroups.al @@ -0,0 +1,14 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 667 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getgroups.al)" +sub getgroups { + usage "getgroups()" if @_ != 0; + my %seen; + grep(!$seen{$_}++, split(' ', $) )); +} + +# end of POSIX::getgroups +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getlogin.al b/Master/xemtex/perl/lib/auto/POSIX/getlogin.al new file mode 100644 index 00000000000..3b9259b5f95 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getlogin.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 673 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getlogin.al)" +sub getlogin { + usage "getlogin()" if @_ != 0; + CORE::getlogin(); +} + +# end of POSIX::getlogin +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getpgrp.al b/Master/xemtex/perl/lib/auto/POSIX/getpgrp.al new file mode 100644 index 00000000000..b4771bcd799 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getpgrp.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 678 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getpgrp.al)" +sub getpgrp { + usage "getpgrp()" if @_ != 0; + CORE::getpgrp; +} + +# end of POSIX::getpgrp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getpid.al b/Master/xemtex/perl/lib/auto/POSIX/getpid.al new file mode 100644 index 00000000000..b85b2304d38 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getpid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 683 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getpid.al)" +sub getpid { + usage "getpid()" if @_ != 0; + $$; +} + +# end of POSIX::getpid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getppid.al b/Master/xemtex/perl/lib/auto/POSIX/getppid.al new file mode 100644 index 00000000000..66b4877dc31 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getppid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 688 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getppid.al)" +sub getppid { + usage "getppid()" if @_ != 0; + CORE::getppid; +} + +# end of POSIX::getppid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getpwnam.al b/Master/xemtex/perl/lib/auto/POSIX/getpwnam.al new file mode 100644 index 00000000000..89538d13b37 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getpwnam.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 182 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getpwnam.al)" +sub getpwnam { + usage "getpwnam(name)" if @_ != 1; + CORE::getpwnam($_[0]); +} + +# end of POSIX::getpwnam +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getpwuid.al b/Master/xemtex/perl/lib/auto/POSIX/getpwuid.al new file mode 100644 index 00000000000..27c8642d36b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getpwuid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 187 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getpwuid.al)" +sub getpwuid { + usage "getpwuid(uid)" if @_ != 1; + CORE::getpwuid($_[0]); +} + +# end of POSIX::getpwuid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/gets.al b/Master/xemtex/perl/lib/auto/POSIX/gets.al new file mode 100644 index 00000000000..ba8caa9cc5e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/gets.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 316 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\gets.al)" +sub gets { + usage "gets()" if @_ != 0; + scalar <STDIN>; +} + +# end of POSIX::gets +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/getuid.al b/Master/xemtex/perl/lib/auto/POSIX/getuid.al new file mode 100644 index 00000000000..c3a7a1e993f --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/getuid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 693 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\getuid.al)" +sub getuid { + usage "getuid()" if @_ != 0; + $<; +} + +# end of POSIX::getuid +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/gmtime.al b/Master/xemtex/perl/lib/auto/POSIX/gmtime.al new file mode 100644 index 00000000000..4f4b26f658a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/gmtime.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 593 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\gmtime.al)" +sub gmtime { + usage "gmtime(time)" if @_ != 1; + CORE::gmtime($_[0]); +} + +# end of POSIX::gmtime +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/isatty.al b/Master/xemtex/perl/lib/auto/POSIX/isatty.al new file mode 100644 index 00000000000..aff49f6fa73 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/isatty.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 698 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\isatty.al)" +sub isatty { + usage "isatty(filehandle)" if @_ != 1; + -t $_[0]; +} + +# end of POSIX::isatty +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/kill.al b/Master/xemtex/perl/lib/auto/POSIX/kill.al new file mode 100644 index 00000000000..ed4544cd1b8 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/kill.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 208 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\kill.al)" +sub kill { + usage "kill(pid, sig)" if @_ != 2; + CORE::kill $_[1], $_[0]; +} + +# end of POSIX::kill +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/labs.al b/Master/xemtex/perl/lib/auto/POSIX/labs.al new file mode 100644 index 00000000000..cb2aee982ec --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/labs.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 438 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\labs.al)" +sub labs { + unimpl "labs() is C-specific, use abs instead"; +} + +# end of POSIX::labs +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/ldiv.al b/Master/xemtex/perl/lib/auto/POSIX/ldiv.al new file mode 100644 index 00000000000..e30e8dddbb6 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/ldiv.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 442 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\ldiv.al)" +sub ldiv { + unimpl "ldiv() is C-specific, use / and int instead"; +} + +# end of POSIX::ldiv +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/link.al b/Master/xemtex/perl/lib/auto/POSIX/link.al new file mode 100644 index 00000000000..7f2cc18847f --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/link.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 703 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\link.al)" +sub link { + usage "link(oldfilename, newfilename)" if @_ != 2; + CORE::link($_[0], $_[1]); +} + +# end of POSIX::link +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/load_imports.al b/Master/xemtex/perl/lib/auto/POSIX/load_imports.al new file mode 100644 index 00000000000..5659bce963d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/load_imports.al @@ -0,0 +1,224 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 736 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\load_imports.al)" +sub load_imports { +%EXPORT_TAGS = ( + + assert_h => [qw(assert NDEBUG)], + + ctype_h => [qw(isalnum isalpha iscntrl isdigit isgraph islower + isprint ispunct isspace isupper isxdigit tolower toupper)], + + dirent_h => [], + + errno_h => [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT + EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED + ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT + EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS + EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH + ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM + ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR + ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM + EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE + ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT + ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY + EUSERS EWOULDBLOCK EXDEV errno)], + + fcntl_h => [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK + F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK + O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK + O_RDONLY O_RDWR O_TRUNC O_WRONLY + creat + SEEK_CUR SEEK_END SEEK_SET + S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID + S_IWGRP S_IWOTH S_IWUSR)], + + float_h => [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG + DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP + DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP + FLT_DIG FLT_EPSILON FLT_MANT_DIG + FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP + FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP + FLT_RADIX FLT_ROUNDS + LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG + LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP + LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)], + + grp_h => [], + + limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX + INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON + MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX + PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN + SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX + ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX + _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT + _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX + _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX + _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)], + + locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES + LC_MONETARY LC_NUMERIC LC_TIME NULL + localeconv setlocale)], + + math_h => [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod + frexp ldexp log10 modf pow sinh tan tanh)], + + pwd_h => [], + + setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)], + + signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK + SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM + SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL + SIGPIPE SIGQUIT SIGSEGV SIGSTOP SIGTERM SIGTSTP SIGTTIN + SIGTTOU SIGUSR1 SIGUSR2 SIG_BLOCK SIG_DFL SIG_ERR + SIG_IGN SIG_SETMASK SIG_UNBLOCK raise sigaction signal + sigpending sigprocmask sigsuspend)], + + stdarg_h => [], + + stddef_h => [qw(NULL offsetof)], + + stdio_h => [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid + L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET + STREAM_MAX TMP_MAX stderr stdin stdout + clearerr fclose fdopen feof ferror fflush fgetc fgetpos + fgets fopen fprintf fputc fputs fread freopen + fscanf fseek fsetpos ftell fwrite getchar gets + perror putc putchar puts remove rewind + scanf setbuf setvbuf sscanf tmpfile tmpnam + ungetc vfprintf vprintf vsprintf)], + + stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX + abort atexit atof atoi atol bsearch calloc div + free getenv labs ldiv malloc mblen mbstowcs mbtowc + qsort realloc strtod strtol strtoul wcstombs wctomb)], + + string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat + strchr strcmp strcoll strcpy strcspn strerror strlen + strncat strncmp strncpy strpbrk strrchr strspn strstr + strtok strxfrm)], + + sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG + S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + fstat mkfifo)], + + sys_times_h => [], + + sys_types_h => [], + + sys_utsname_h => [qw(uname)], + + sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED + WNOHANG WSTOPSIG WTERMSIG WUNTRACED)], + + termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400 + B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL + CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK + ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR + INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST + PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION + TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW + TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART + VSTOP VSUSP VTIME + cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain + tcflow tcflush tcgetattr tcsendbreak tcsetattr )], + + time_h => [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime + difftime mktime strftime tzset tzname)], + + unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET + STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK + _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON + _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX + _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED + _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS + _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX + _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL + _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS + _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + _exit access ctermid cuserid + dup2 dup execl execle execlp execv execve execvp + fpathconf getcwd getegid geteuid getgid getgroups + getpid getuid isatty lseek pathconf pause setgid setpgid + setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)], + + utime_h => [], + +); + +# Exporter::export_tags(); +for (values %EXPORT_TAGS) { + push @EXPORT, @$_; +} + +@EXPORT_OK = qw( + abs + alarm + atan2 + chdir + chmod + chown + close + closedir + cos + exit + exp + fcntl + fileno + fork + getc + getgrgid + getgrnam + getlogin + getpgrp + getppid + getpwnam + getpwuid + gmtime + isatty + kill + link + localtime + log + mkdir + nice + open + opendir + pipe + printf + rand + read + readdir + rename + rewinddir + rmdir + sin + sleep + sprintf + sqrt + srand + stat + system + time + times + umask + unlink + utime + wait + waitpid + write +); + +require Exporter; +} + +1; +# end of POSIX::load_imports diff --git a/Master/xemtex/perl/lib/auto/POSIX/localtime.al b/Master/xemtex/perl/lib/auto/POSIX/localtime.al new file mode 100644 index 00000000000..327eec0044c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/localtime.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 598 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\localtime.al)" +sub localtime { + usage "localtime(time)" if @_ != 1; + CORE::localtime($_[0]); +} + +# end of POSIX::localtime +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/log.al b/Master/xemtex/perl/lib/auto/POSIX/log.al new file mode 100644 index 00000000000..b04b0689863 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/log.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 162 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\log.al)" +sub log { + usage "log(x)" if @_ != 1; + CORE::log($_[0]); +} + +# end of POSIX::log +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/longjmp.al b/Master/xemtex/perl/lib/auto/POSIX/longjmp.al new file mode 100644 index 00000000000..2edb512681b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/longjmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 192 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\longjmp.al)" +sub longjmp { + unimpl "longjmp() is C-specific: use die instead"; +} + +# end of POSIX::longjmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/malloc.al b/Master/xemtex/perl/lib/auto/POSIX/malloc.al new file mode 100644 index 00000000000..c7afafcbb7a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/malloc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 446 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\malloc.al)" +sub malloc { + unimpl "malloc() is C-specific, stopped"; +} + +# end of POSIX::malloc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/memchr.al b/Master/xemtex/perl/lib/auto/POSIX/memchr.al new file mode 100644 index 00000000000..8de2367abd2 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/memchr.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 471 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\memchr.al)" +sub memchr { + unimpl "memchr() is C-specific, use index() instead"; +} + +# end of POSIX::memchr +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/memcmp.al b/Master/xemtex/perl/lib/auto/POSIX/memcmp.al new file mode 100644 index 00000000000..91169494c1d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/memcmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 475 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\memcmp.al)" +sub memcmp { + unimpl "memcmp() is C-specific, use eq instead"; +} + +# end of POSIX::memcmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/memcpy.al b/Master/xemtex/perl/lib/auto/POSIX/memcpy.al new file mode 100644 index 00000000000..39afe5ecfd9 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/memcpy.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 479 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\memcpy.al)" +sub memcpy { + unimpl "memcpy() is C-specific, use = instead"; +} + +# end of POSIX::memcpy +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/memmove.al b/Master/xemtex/perl/lib/auto/POSIX/memmove.al new file mode 100644 index 00000000000..14643d3610b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/memmove.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 483 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\memmove.al)" +sub memmove { + unimpl "memmove() is C-specific, use = instead"; +} + +# end of POSIX::memmove +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/memset.al b/Master/xemtex/perl/lib/auto/POSIX/memset.al new file mode 100644 index 00000000000..ea5df704a5e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/memset.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 487 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\memset.al)" +sub memset { + unimpl "memset() is C-specific, use x instead"; +} + +# end of POSIX::memset +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/mkdir.al b/Master/xemtex/perl/lib/auto/POSIX/mkdir.al new file mode 100644 index 00000000000..b3ce65784b5 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/mkdir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 568 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\mkdir.al)" +sub mkdir { + usage "mkdir(directoryname, mode)" if @_ != 2; + CORE::mkdir($_[0], $_[1]); +} + +# end of POSIX::mkdir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/offsetof.al b/Master/xemtex/perl/lib/auto/POSIX/offsetof.al new file mode 100644 index 00000000000..dc4d5065c1d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/offsetof.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 218 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\offsetof.al)" +sub offsetof { + unimpl "offsetof() is C-specific, stopped"; +} + +# end of POSIX::offsetof +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/opendir.al b/Master/xemtex/perl/lib/auto/POSIX/opendir.al new file mode 100644 index 00000000000..40aa101f3ca --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/opendir.al @@ -0,0 +1,16 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 99 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\opendir.al)" +sub opendir { + usage "opendir(directory)" if @_ != 1; + my $dirhandle; + CORE::opendir($dirhandle, $_[0]) + ? $dirhandle + : undef; +} + +# end of POSIX::opendir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/perror.al b/Master/xemtex/perl/lib/auto/POSIX/perror.al new file mode 100644 index 00000000000..2f65bc3a0cf --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/perror.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 321 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\perror.al)" +sub perror { + print STDERR "@_: " if @_; + print STDERR $!,"\n"; +} + +# end of POSIX::perror +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/pow.al b/Master/xemtex/perl/lib/auto/POSIX/pow.al new file mode 100644 index 00000000000..5f199d5fb29 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/pow.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 167 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\pow.al)" +sub pow { + usage "pow(x,exponent)" if @_ != 2; + $_[0] ** $_[1]; +} + +# end of POSIX::pow +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/printf.al b/Master/xemtex/perl/lib/auto/POSIX/printf.al new file mode 100644 index 00000000000..8c27863f9d9 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/printf.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 326 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\printf.al)" +sub printf { + usage "printf(pattern, args...)" if @_ < 1; + CORE::printf STDOUT @_; +} + +# end of POSIX::printf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/putc.al b/Master/xemtex/perl/lib/auto/POSIX/putc.al new file mode 100644 index 00000000000..773c795c192 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/putc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 331 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\putc.al)" +sub putc { + unimpl "putc() is C-specific--use print instead"; +} + +# end of POSIX::putc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/putchar.al b/Master/xemtex/perl/lib/auto/POSIX/putchar.al new file mode 100644 index 00000000000..b9ca943a724 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/putchar.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 335 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\putchar.al)" +sub putchar { + unimpl "putchar() is C-specific--use print instead"; +} + +# end of POSIX::putchar +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/puts.al b/Master/xemtex/perl/lib/auto/POSIX/puts.al new file mode 100644 index 00000000000..3b2dd7d90a6 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/puts.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 339 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\puts.al)" +sub puts { + unimpl "puts() is C-specific--use print instead"; +} + +# end of POSIX::puts +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/qsort.al b/Master/xemtex/perl/lib/auto/POSIX/qsort.al new file mode 100644 index 00000000000..eb9c6d3586a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/qsort.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 450 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\qsort.al)" +sub qsort { + unimpl "qsort() is C-specific, use sort instead"; +} + +# end of POSIX::qsort +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/raise.al b/Master/xemtex/perl/lib/auto/POSIX/raise.al new file mode 100644 index 00000000000..1399c31f800 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/raise.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 213 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\raise.al)" +sub raise { + usage "raise(sig)" if @_ != 1; + CORE::kill $_[0], $$; # Is this good enough? +} + +# end of POSIX::raise +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/rand.al b/Master/xemtex/perl/lib/auto/POSIX/rand.al new file mode 100644 index 00000000000..0a8b3982e3a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/rand.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 454 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\rand.al)" +sub rand { + unimpl "rand() is non-portable, use Perl's rand instead"; +} + +# end of POSIX::rand +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/readdir.al b/Master/xemtex/perl/lib/auto/POSIX/readdir.al new file mode 100644 index 00000000000..3c2e72fd0a0 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/readdir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 107 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\readdir.al)" +sub readdir { + usage "readdir(dirhandle)" if @_ != 1; + CORE::readdir($_[0]); +} + +# end of POSIX::readdir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/realloc.al b/Master/xemtex/perl/lib/auto/POSIX/realloc.al new file mode 100644 index 00000000000..28efa2ccec5 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/realloc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 458 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\realloc.al)" +sub realloc { + unimpl "realloc() is C-specific, stopped"; +} + +# end of POSIX::realloc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/redef.al b/Master/xemtex/perl/lib/auto/POSIX/redef.al new file mode 100644 index 00000000000..0265989b228 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/redef.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 66 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\redef.al)" +sub redef { + my ($mess) = @_; + croak "Use method $mess instead"; +} + +# end of POSIX::redef +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/remove.al b/Master/xemtex/perl/lib/auto/POSIX/remove.al new file mode 100644 index 00000000000..e07b2fc0bd3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/remove.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 343 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\remove.al)" +sub remove { + usage "remove(filename)" if @_ != 1; + CORE::unlink($_[0]); +} + +# end of POSIX::remove +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/rename.al b/Master/xemtex/perl/lib/auto/POSIX/rename.al new file mode 100644 index 00000000000..10e8447f8b8 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/rename.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 348 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\rename.al)" +sub rename { + usage "rename(oldfilename, newfilename)" if @_ != 2; + CORE::rename($_[0], $_[1]); +} + +# end of POSIX::rename +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/rewind.al b/Master/xemtex/perl/lib/auto/POSIX/rewind.al new file mode 100644 index 00000000000..5d7bc6fc17c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/rewind.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 353 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\rewind.al)" +sub rewind { + usage "rewind(filehandle)" if @_ != 1; + CORE::seek($_[0],0,0); +} + +# end of POSIX::rewind +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/rewinddir.al b/Master/xemtex/perl/lib/auto/POSIX/rewinddir.al new file mode 100644 index 00000000000..04ba2209b07 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/rewinddir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 112 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\rewinddir.al)" +sub rewinddir { + usage "rewinddir(dirhandle)" if @_ != 1; + CORE::rewinddir($_[0]); +} + +# end of POSIX::rewinddir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/rmdir.al b/Master/xemtex/perl/lib/auto/POSIX/rmdir.al new file mode 100644 index 00000000000..983a2262e9a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/rmdir.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 708 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\rmdir.al)" +sub rmdir { + usage "rmdir(directoryname)" if @_ != 1; + CORE::rmdir($_[0]); +} + +# end of POSIX::rmdir +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/scanf.al b/Master/xemtex/perl/lib/auto/POSIX/scanf.al new file mode 100644 index 00000000000..20774a6e869 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/scanf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 358 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\scanf.al)" +sub scanf { + unimpl "scanf() is C-specific--use <> and regular expressions instead"; +} + +# end of POSIX::scanf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/setbuf.al b/Master/xemtex/perl/lib/auto/POSIX/setbuf.al new file mode 100644 index 00000000000..3dee5e3eb99 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/setbuf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 713 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\setbuf.al)" +sub setbuf { + redef "IO::Handle::setbuf()"; +} + +# end of POSIX::setbuf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/setjmp.al b/Master/xemtex/perl/lib/auto/POSIX/setjmp.al new file mode 100644 index 00000000000..81cddb9ed62 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/setjmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 196 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\setjmp.al)" +sub setjmp { + unimpl "setjmp() is C-specific: use eval {} instead"; +} + +# end of POSIX::setjmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/setvbuf.al b/Master/xemtex/perl/lib/auto/POSIX/setvbuf.al new file mode 100644 index 00000000000..db1a791cb2c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/setvbuf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 717 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\setvbuf.al)" +sub setvbuf { + redef "IO::Handle::setvbuf()"; +} + +# end of POSIX::setvbuf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/siglongjmp.al b/Master/xemtex/perl/lib/auto/POSIX/siglongjmp.al new file mode 100644 index 00000000000..bfbf9916c52 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/siglongjmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 200 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\siglongjmp.al)" +sub siglongjmp { + unimpl "siglongjmp() is C-specific: use die instead"; +} + +# end of POSIX::siglongjmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sigsetjmp.al b/Master/xemtex/perl/lib/auto/POSIX/sigsetjmp.al new file mode 100644 index 00000000000..ef8ad5ec087 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sigsetjmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 204 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sigsetjmp.al)" +sub sigsetjmp { + unimpl "sigsetjmp() is C-specific: use eval {} instead"; +} + +# end of POSIX::sigsetjmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sin.al b/Master/xemtex/perl/lib/auto/POSIX/sin.al new file mode 100644 index 00000000000..97501e7fc5d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sin.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 172 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sin.al)" +sub sin { + usage "sin(x)" if @_ != 1; + CORE::sin($_[0]); +} + +# end of POSIX::sin +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sleep.al b/Master/xemtex/perl/lib/auto/POSIX/sleep.al new file mode 100644 index 00000000000..ed44ef67ceb --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sleep.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 721 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sleep.al)" +sub sleep { + usage "sleep(seconds)" if @_ != 1; + $_[0] - CORE::sleep($_[0]); +} + +# end of POSIX::sleep +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sprintf.al b/Master/xemtex/perl/lib/auto/POSIX/sprintf.al new file mode 100644 index 00000000000..dc02870b96a --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sprintf.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 362 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sprintf.al)" +sub sprintf { + usage "sprintf(pattern,args)" if @_ == 0; + CORE::sprintf(shift,@_); +} + +# end of POSIX::sprintf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sqrt.al b/Master/xemtex/perl/lib/auto/POSIX/sqrt.al new file mode 100644 index 00000000000..def6780521d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sqrt.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 177 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sqrt.al)" +sub sqrt { + usage "sqrt(x)" if @_ != 1; + CORE::sqrt($_[0]); +} + +# end of POSIX::sqrt +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/srand.al b/Master/xemtex/perl/lib/auto/POSIX/srand.al new file mode 100644 index 00000000000..6f4a41042b3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/srand.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 462 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\srand.al)" +sub srand { + unimpl "srand()"; +} + +# end of POSIX::srand +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/sscanf.al b/Master/xemtex/perl/lib/auto/POSIX/sscanf.al new file mode 100644 index 00000000000..fe5d61fe665 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/sscanf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 367 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\sscanf.al)" +sub sscanf { + unimpl "sscanf() is C-specific--use regular expressions instead"; +} + +# end of POSIX::sscanf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/stat.al b/Master/xemtex/perl/lib/auto/POSIX/stat.al new file mode 100644 index 00000000000..eb483e18f70 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/stat.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 573 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\stat.al)" +sub stat { + usage "stat(filename)" if @_ != 1; + CORE::stat($_[0]); +} + +# end of POSIX::stat +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strcat.al b/Master/xemtex/perl/lib/auto/POSIX/strcat.al new file mode 100644 index 00000000000..ed3e4fe582c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strcat.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 491 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strcat.al)" +sub strcat { + unimpl "strcat() is C-specific, use .= instead"; +} + +# end of POSIX::strcat +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strchr.al b/Master/xemtex/perl/lib/auto/POSIX/strchr.al new file mode 100644 index 00000000000..7802d2dc57d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strchr.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 495 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strchr.al)" +sub strchr { + unimpl "strchr() is C-specific, use index() instead"; +} + +# end of POSIX::strchr +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strcmp.al b/Master/xemtex/perl/lib/auto/POSIX/strcmp.al new file mode 100644 index 00000000000..07127207853 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strcmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 499 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strcmp.al)" +sub strcmp { + unimpl "strcmp() is C-specific, use eq instead"; +} + +# end of POSIX::strcmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strcpy.al b/Master/xemtex/perl/lib/auto/POSIX/strcpy.al new file mode 100644 index 00000000000..fc48c859e2e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strcpy.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 503 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strcpy.al)" +sub strcpy { + unimpl "strcpy() is C-specific, use = instead"; +} + +# end of POSIX::strcpy +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strcspn.al b/Master/xemtex/perl/lib/auto/POSIX/strcspn.al new file mode 100644 index 00000000000..1347dc79fd3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strcspn.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 507 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strcspn.al)" +sub strcspn { + unimpl "strcspn() is C-specific, use regular expressions instead"; +} + +# end of POSIX::strcspn +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strerror.al b/Master/xemtex/perl/lib/auto/POSIX/strerror.al new file mode 100644 index 00000000000..55dcb64350c --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strerror.al @@ -0,0 +1,14 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 511 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strerror.al)" +sub strerror { + usage "strerror(errno)" if @_ != 1; + local $! = $_[0]; + $! . ""; +} + +# end of POSIX::strerror +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strlen.al b/Master/xemtex/perl/lib/auto/POSIX/strlen.al new file mode 100644 index 00000000000..f417d1755aa --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strlen.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 517 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strlen.al)" +sub strlen { + unimpl "strlen() is C-specific, use length instead"; +} + +# end of POSIX::strlen +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strncat.al b/Master/xemtex/perl/lib/auto/POSIX/strncat.al new file mode 100644 index 00000000000..bb890c89858 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strncat.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 521 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strncat.al)" +sub strncat { + unimpl "strncat() is C-specific, use .= instead"; +} + +# end of POSIX::strncat +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strncmp.al b/Master/xemtex/perl/lib/auto/POSIX/strncmp.al new file mode 100644 index 00000000000..f8f0b2b5f84 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strncmp.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 525 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strncmp.al)" +sub strncmp { + unimpl "strncmp() is C-specific, use eq instead"; +} + +# end of POSIX::strncmp +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strncpy.al b/Master/xemtex/perl/lib/auto/POSIX/strncpy.al new file mode 100644 index 00000000000..a9680b90514 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strncpy.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 529 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strncpy.al)" +sub strncpy { + unimpl "strncpy() is C-specific, use = instead"; +} + +# end of POSIX::strncpy +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strpbrk.al b/Master/xemtex/perl/lib/auto/POSIX/strpbrk.al new file mode 100644 index 00000000000..18e7fa29bcf --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strpbrk.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 533 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strpbrk.al)" +sub strpbrk { + unimpl "strpbrk() is C-specific, stopped"; +} + +# end of POSIX::strpbrk +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strrchr.al b/Master/xemtex/perl/lib/auto/POSIX/strrchr.al new file mode 100644 index 00000000000..8a0ad300422 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strrchr.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 537 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strrchr.al)" +sub strrchr { + unimpl "strrchr() is C-specific, use rindex() instead"; +} + +# end of POSIX::strrchr +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strspn.al b/Master/xemtex/perl/lib/auto/POSIX/strspn.al new file mode 100644 index 00000000000..162341b05a3 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strspn.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 541 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strspn.al)" +sub strspn { + unimpl "strspn() is C-specific, stopped"; +} + +# end of POSIX::strspn +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strstr.al b/Master/xemtex/perl/lib/auto/POSIX/strstr.al new file mode 100644 index 00000000000..c99a491a780 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strstr.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 545 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strstr.al)" +sub strstr { + usage "strstr(big, little)" if @_ != 2; + CORE::index($_[0], $_[1]); +} + +# end of POSIX::strstr +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/strtok.al b/Master/xemtex/perl/lib/auto/POSIX/strtok.al new file mode 100644 index 00000000000..a574fde27ed --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/strtok.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 550 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\strtok.al)" +sub strtok { + unimpl "strtok() is C-specific, stopped"; +} + +# end of POSIX::strtok +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/system.al b/Master/xemtex/perl/lib/auto/POSIX/system.al new file mode 100644 index 00000000000..976f439cc35 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/system.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 466 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\system.al)" +sub system { + usage "system(command)" if @_ != 1; + CORE::system($_[0]); +} + +# end of POSIX::system +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/time.al b/Master/xemtex/perl/lib/auto/POSIX/time.al new file mode 100644 index 00000000000..3f90c0a999d --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/time.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 603 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\time.al)" +sub time { + usage "time()" if @_ != 0; + CORE::time; +} + +# end of POSIX::time +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/tmpfile.al b/Master/xemtex/perl/lib/auto/POSIX/tmpfile.al new file mode 100644 index 00000000000..a64d2aff625 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/tmpfile.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 371 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\tmpfile.al)" +sub tmpfile { + redef "IO::File::new_tmpfile()"; +} + +# end of POSIX::tmpfile +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/tolower.al b/Master/xemtex/perl/lib/auto/POSIX/tolower.al new file mode 100644 index 00000000000..8ec7b584813 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/tolower.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 84 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\tolower.al)" +sub tolower { + usage "tolower(string)" if @_ != 1; + lc($_[0]); +} + +# end of POSIX::tolower +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/toupper.al b/Master/xemtex/perl/lib/auto/POSIX/toupper.al new file mode 100644 index 00000000000..efc3c3ebeac --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/toupper.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 89 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\toupper.al)" +sub toupper { + usage "toupper(string)" if @_ != 1; + uc($_[0]); +} + +# end of POSIX::toupper +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/umask.al b/Master/xemtex/perl/lib/auto/POSIX/umask.al new file mode 100644 index 00000000000..6812329253e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/umask.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 578 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\umask.al)" +sub umask { + usage "umask(mask)" if @_ != 1; + CORE::umask($_[0]); +} + +# end of POSIX::umask +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/ungetc.al b/Master/xemtex/perl/lib/auto/POSIX/ungetc.al new file mode 100644 index 00000000000..b384b46b9d2 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/ungetc.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 375 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\ungetc.al)" +sub ungetc { + redef "IO::Handle::ungetc()"; +} + +# end of POSIX::ungetc +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/unimpl.al b/Master/xemtex/perl/lib/auto/POSIX/unimpl.al new file mode 100644 index 00000000000..b700d3d95b4 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/unimpl.al @@ -0,0 +1,14 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 71 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\unimpl.al)" +sub unimpl { + my ($mess) = @_; + $mess =~ s/xxx//; + croak "Unimplemented: POSIX::$mess"; +} + +# end of POSIX::unimpl +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/unlink.al b/Master/xemtex/perl/lib/auto/POSIX/unlink.al new file mode 100644 index 00000000000..f8a44b79620 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/unlink.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 726 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\unlink.al)" +sub unlink { + usage "unlink(filename)" if @_ != 1; + CORE::unlink($_[0]); +} + +# end of POSIX::unlink +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/usage.al b/Master/xemtex/perl/lib/auto/POSIX/usage.al new file mode 100644 index 00000000000..e81f8619b5e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/usage.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 61 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\usage.al)" +sub usage { + my ($mess) = @_; + croak "Usage: POSIX::$mess"; +} + +# end of POSIX::usage +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/utime.al b/Master/xemtex/perl/lib/auto/POSIX/utime.al new file mode 100644 index 00000000000..5ddf502f8cf --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/utime.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 731 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\utime.al)" +sub utime { + usage "utime(filename, atime, mtime)" if @_ != 3; + CORE::utime($_[1], $_[2], $_[0]); +} + +# end of POSIX::utime +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/vfprintf.al b/Master/xemtex/perl/lib/auto/POSIX/vfprintf.al new file mode 100644 index 00000000000..561853cc60f --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/vfprintf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 379 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\vfprintf.al)" +sub vfprintf { + unimpl "vfprintf() is C-specific"; +} + +# end of POSIX::vfprintf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/vprintf.al b/Master/xemtex/perl/lib/auto/POSIX/vprintf.al new file mode 100644 index 00000000000..aa597c30eaa --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/vprintf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 383 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\vprintf.al)" +sub vprintf { + unimpl "vprintf() is C-specific"; +} + +# end of POSIX::vprintf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/vsprintf.al b/Master/xemtex/perl/lib/auto/POSIX/vsprintf.al new file mode 100644 index 00000000000..fcc93ff270b --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/vsprintf.al @@ -0,0 +1,12 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 387 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\vsprintf.al)" +sub vsprintf { + unimpl "vsprintf() is C-specific"; +} + +# end of POSIX::vsprintf +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/wait.al b/Master/xemtex/perl/lib/auto/POSIX/wait.al new file mode 100644 index 00000000000..bb11314a208 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/wait.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 583 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\wait.al)" +sub wait { + usage "wait()" if @_ != 0; + CORE::wait(); +} + +# end of POSIX::wait +1; diff --git a/Master/xemtex/perl/lib/auto/POSIX/waitpid.al b/Master/xemtex/perl/lib/auto/POSIX/waitpid.al new file mode 100644 index 00000000000..2b10e7908b1 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/POSIX/waitpid.al @@ -0,0 +1,13 @@ +# NOTE: Derived from ..\..\lib\POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 588 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\waitpid.al)" +sub waitpid { + usage "waitpid(pid, options)" if @_ != 2; + CORE::waitpid($_[0], $_[1]); +} + +# end of POSIX::waitpid +1; diff --git a/Master/xemtex/perl/lib/auto/SDBM_File/SDBM_File.dll b/Master/xemtex/perl/lib/auto/SDBM_File/SDBM_File.dll Binary files differnew file mode 100644 index 00000000000..1b5a3da0bb1 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/SDBM_File/SDBM_File.dll diff --git a/Master/xemtex/perl/lib/auto/Time/HiRes/HiRes.dll b/Master/xemtex/perl/lib/auto/Time/HiRes/HiRes.dll Binary files differnew file mode 100644 index 00000000000..8e0ebb6ac3e --- /dev/null +++ b/Master/xemtex/perl/lib/auto/Time/HiRes/HiRes.dll diff --git a/Master/xemtex/perl/lib/auto/re/re.dll b/Master/xemtex/perl/lib/auto/re/re.dll Binary files differnew file mode 100644 index 00000000000..6b83e6c3ba1 --- /dev/null +++ b/Master/xemtex/perl/lib/auto/re/re.dll diff --git a/Master/xemtex/perl/lib/base.pm b/Master/xemtex/perl/lib/base.pm new file mode 100644 index 00000000000..37f220f63a9 --- /dev/null +++ b/Master/xemtex/perl/lib/base.pm @@ -0,0 +1,94 @@ +=head1 NAME + +base - Establish IS-A relationship with base class at compile time + +=head1 SYNOPSIS + + package Baz; + use base qw(Foo Bar); + +=head1 DESCRIPTION + +Roughly similar in effect to + + BEGIN { + require Foo; + require Bar; + push @ISA, qw(Foo Bar); + } + +Will also initialize the %FIELDS hash if one of the base classes has +it. Multiple inheritance of %FIELDS is not supported. The 'base' +pragma will croak if multiple base classes have a %FIELDS hash. See +L<fields> for a description of this feature. + +When strict 'vars' is in scope I<base> also let you assign to @ISA +without having to declare @ISA with the 'vars' pragma first. + +If any of the base classes are not loaded yet, I<base> silently +C<require>s them. Whether to C<require> a base class package is +determined by the absence of a global $VERSION in the base package. +If $VERSION is not detected even after loading it, <base> will +define $VERSION in the base package, setting it to the string +C<-1, set by base.pm>. + +=head1 HISTORY + +This module was introduced with Perl 5.004_04. + +=head1 SEE ALSO + +L<fields> + +=cut + +package base; + +use 5.006_001; +our $VERSION = "1.03"; + +sub import { + my $class = shift; + my $fields_base; + my $pkg = caller(0); + + foreach my $base (@_) { + next if $pkg->isa($base); + my $vglob; + if ($vglob = ${"$base\::"}{VERSION} and *$vglob{SCALAR}) { + $$vglob = "-1, set by base.pm" unless defined $$vglob; + } else { + eval "require $base"; + # Only ignore "Can't locate" errors from our eval require. + # Other fatal errors (syntax etc) must be reported. + die if $@ && $@ !~ /^Can't locate .*? at \(eval /; + unless (%{"$base\::"}) { + require Carp; + Carp::croak("Base class package \"$base\" is empty.\n", + "\t(Perhaps you need to 'use' the module ", + "which defines that package first.)"); + } + ${"$base\::VERSION"} = "-1, set by base.pm" unless defined ${"$base\::VERSION"}; + } + push @{"$pkg\::ISA"}, $base; + + # A simple test like (defined %{"$base\::FIELDS"}) will + # sometimes produce typo warnings because it would create + # the hash if it was not present before. + my $fglob; + if ($fglob = ${"$base\::"}{"FIELDS"} and *$fglob{HASH}) { + if ($fields_base) { + require Carp; + Carp::croak("Can't multiply inherit %FIELDS"); + } else { + $fields_base = $base; + } + } + } + if ($fields_base) { + require fields; + fields::inherit($pkg, $fields_base); + } +} + +1; diff --git a/Master/xemtex/perl/lib/bytes.pm b/Master/xemtex/perl/lib/bytes.pm new file mode 100644 index 00000000000..cd82abc75b5 --- /dev/null +++ b/Master/xemtex/perl/lib/bytes.pm @@ -0,0 +1,68 @@ +package bytes; + +our $VERSION = '1.00'; + +$bytes::hint_bits = 0x00000008; + +sub import { + $^H |= $bytes::hint_bits; +} + +sub unimport { + $^H &= ~$bytes::hint_bits; +} + +sub AUTOLOAD { + require "bytes_heavy.pl"; + goto &$AUTOLOAD; +} + +sub length ($); + +1; +__END__ + +=head1 NAME + +bytes - Perl pragma to force byte semantics rather than character semantics + +=head1 SYNOPSIS + + use bytes; + no bytes; + +=head1 DESCRIPTION + +The C<use bytes> pragma disables character semantics for the rest of the +lexical scope in which it appears. C<no bytes> can be used to reverse +the effect of C<use bytes> within the current lexical scope. + +Perl normally assumes character semantics in the presence of character +data (i.e. data that has come from a source that has been marked as +being of a particular character encoding). When C<use bytes> is in +effect, the encoding is temporarily ignored, and each string is treated +as a series of bytes. + +As an example, when Perl sees C<$x = chr(400)>, it encodes the character +in UTF-8 and stores it in $x. Then it is marked as character data, so, +for instance, C<length $x> returns C<1>. However, in the scope of the +C<bytes> pragma, $x is treated as a series of bytes - the bytes that make +up the UTF8 encoding - and C<length $x> returns C<2>: + + $x = chr(400); + print "Length is ", length $x, "\n"; # "Length is 1" + printf "Contents are %vd\n", $x; # "Contents are 400" + { + use bytes; + print "Length is ", length $x, "\n"; # "Length is 2" + printf "Contents are %vd\n", $x; # "Contents are 198.144" + } + +For more on the implications and differences between character +semantics and byte semantics, see L<perlunicode>. + +=head1 SEE ALSO + +L<perlunicode>, L<utf8> + +=cut diff --git a/Master/xemtex/perl/lib/bytes_heavy.pl b/Master/xemtex/perl/lib/bytes_heavy.pl new file mode 100644 index 00000000000..47bdbf91b0d --- /dev/null +++ b/Master/xemtex/perl/lib/bytes_heavy.pl @@ -0,0 +1,8 @@ +package bytes; + +sub length ($) { + BEGIN { bytes::import() } + return CORE::length($_[0]); +} + +1; diff --git a/Master/xemtex/perl/lib/constant.pm b/Master/xemtex/perl/lib/constant.pm new file mode 100644 index 00000000000..93086d53985 --- /dev/null +++ b/Master/xemtex/perl/lib/constant.pm @@ -0,0 +1,345 @@ +package constant; + +use strict; +use 5.006_00; +use warnings::register; + +our($VERSION, %declared); +$VERSION = '1.04'; + +#======================================================================= + +# Some names are evil choices. +my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD }; + +my %forced_into_main = map +($_, 1), + qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG }; + +my %forbidden = (%keywords, %forced_into_main); + +#======================================================================= +# import() - import symbols into user's namespace +# +# What we actually do is define a function in the caller's namespace +# which returns the value. The function we create will normally +# be inlined as a constant, thereby avoiding further sub calling +# overhead. +#======================================================================= +sub import { + my $class = shift; + return unless @_; # Ignore 'use constant;' + my %constants = (); + my $multiple = ref $_[0]; + + if ( $multiple ) { + if (ref $_[0] ne 'HASH') { + require Carp; + Carp::croak("Invalid reference type '".ref(shift)."' not 'HASH'"); + } + %constants = %{+shift}; + } else { + $constants{+shift} = undef; + } + + foreach my $name ( keys %constants ) { + unless (defined $name) { + require Carp; + Carp::croak("Can't use undef as constant name"); + } + my $pkg = caller; + + # Normal constant name + if ($name =~ /^_?[^\W_0-9]\w*\z/ and !$forbidden{$name}) { + # Everything is okay + + # Name forced into main, but we're not in main. Fatal. + } elsif ($forced_into_main{$name} and $pkg ne 'main') { + require Carp; + Carp::croak("Constant name '$name' is forced into main::"); + + # Starts with double underscore. Fatal. + } elsif ($name =~ /^__/) { + require Carp; + Carp::croak("Constant name '$name' begins with '__'"); + + # Maybe the name is tolerable + } elsif ($name =~ /^[A-Za-z_]\w*\z/) { + # Then we'll warn only if you've asked for warnings + if (warnings::enabled()) { + if ($keywords{$name}) { + warnings::warn("Constant name '$name' is a Perl keyword"); + } elsif ($forced_into_main{$name}) { + warnings::warn("Constant name '$name' is " . + "forced into package main::"); + } else { + # Catch-all - what did I miss? If you get this error, + # please let me know what your constant's name was. + # Write to <rootbeer@redcat.com>. Thanks! + warnings::warn("Constant name '$name' has unknown problems"); + } + } + + # Looks like a boolean + # use constant FRED == fred; + } elsif ($name =~ /^[01]?\z/) { + require Carp; + if (@_) { + Carp::croak("Constant name '$name' is invalid"); + } else { + Carp::croak("Constant name looks like boolean value"); + } + + } else { + # Must have bad characters + require Carp; + Carp::croak("Constant name '$name' has invalid characters"); + } + + { + no strict 'refs'; + my $full_name = "${pkg}::$name"; + $declared{$full_name}++; + if ($multiple) { + my $scalar = $constants{$name}; + *$full_name = sub () { $scalar }; + } else { + if (@_ == 1) { + my $scalar = $_[0]; + *$full_name = sub () { $scalar }; + } elsif (@_) { + my @list = @_; + *$full_name = sub () { @list }; + } else { + *$full_name = sub () { }; + } + } + } + } +} + +1; + +__END__ + +=head1 NAME + +constant - Perl pragma to declare constants + +=head1 SYNOPSIS + + use constant PI => 4 * atan2(1, 1); + use constant DEBUG => 0; + + print "Pi equals ", PI, "...\n" if DEBUG; + + use constant { + SEC => 0, + MIN => 1, + HOUR => 2, + MDAY => 3, + MON => 4, + YEAR => 5, + WDAY => 6, + YDAY => 7, + ISDST => 8, + }; + + use constant WEEKDAYS => qw( + Sunday Monday Tuesday Wednesday Thursday Friday Saturday + ); + + print "Today is ", (WEEKDAYS)[ (localtime)[WDAY] ], ".\n"; + +=head1 DESCRIPTION + +This will declare a symbol to be a constant with the given value. + +When you declare a constant such as C<PI> using the method shown +above, each machine your script runs upon can have as many digits +of accuracy as it can use. Also, your program will be easier to +read, more likely to be maintained (and maintained correctly), and +far less likely to send a space probe to the wrong planet because +nobody noticed the one equation in which you wrote C<3.14195>. + +When a constant is used in an expression, perl replaces it with its +value at compile time, and may then optimize the expression further. +In particular, any code in an C<if (CONSTANT)> block will be optimized +away if the constant is false. + +=head1 NOTES + +As with all C<use> directives, defining a constant happens at +compile time. Thus, it's probably not correct to put a constant +declaration inside of a conditional statement (like C<if ($foo) +{ use constant ... }>). + +Constants defined using this module cannot be interpolated into +strings like variables. However, concatenation works just fine: + + print "Pi equals PI...\n"; # WRONG: does not expand "PI" + print "Pi equals ".PI."...\n"; # right + +Even though a reference may be declared as a constant, the reference may +point to data which may be changed, as this code shows. + + use constant ARRAY => [ 1,2,3,4 ]; + print ARRAY->[1]; + ARRAY->[1] = " be changed"; + print ARRAY->[1]; + +Dereferencing constant references incorrectly (such as using an array +subscript on a constant hash reference, or vice versa) will be trapped at +compile time. + +Constants belong to the package they are defined in. To refer to a +constant defined in another package, specify the full package name, as +in C<Some::Package::CONSTANT>. Constants may be exported by modules, +and may also be called as either class or instance methods, that is, +as C<< Some::Package->CONSTANT >> or as C<< $obj->CONSTANT >> where +C<$obj> is an instance of C<Some::Package>. Subclasses may define +their own constants to override those in their base class. + +The use of all caps for constant names is merely a convention, +although it is recommended in order to make constants stand out +and to help avoid collisions with other barewords, keywords, and +subroutine names. Constant names must begin with a letter or +underscore. Names beginning with a double underscore are reserved. Some +poor choices for names will generate warnings, if warnings are enabled at +compile time. + +=head2 List constants + +Constants may be lists of more (or less) than one value. A constant +with no values evaluates to C<undef> in scalar context. Note that +constants with more than one value do I<not> return their last value in +scalar context as one might expect. They currently return the number +of values, but B<this may change in the future>. Do not use constants +with multiple values in scalar context. + +B<NOTE:> This implies that the expression defining the value of a +constant is evaluated in list context. This may produce surprises: + + use constant TIMESTAMP => localtime; # WRONG! + use constant TIMESTAMP => scalar localtime; # right + +The first line above defines C<TIMESTAMP> as a 9-element list, as +returned by localtime() in list context. To set it to the string +returned by localtime() in scalar context, an explicit C<scalar> +keyword is required. + +List constants are lists, not arrays. To index or slice them, they +must be placed in parentheses. + + my @workdays = WEEKDAYS[1 .. 5]; # WRONG! + my @workdays = (WEEKDAYS)[1 .. 5]; # right + +=head2 Defining multiple constants at once + +Instead of writing multiple C<use constant> statements, you may define +multiple constants in a single statement by giving, instead of the +constant name, a reference to a hash where the keys are the names of +the constants to be defined. Obviously, all constants defined using +this method must have a single value. + + use constant { + FOO => "A single value", + BAR => "This", "won't", "work!", # Error! + }; + +This is a fundamental limitation of the way hashes are constructed in +Perl. The error messages produced when this happens will often be +quite cryptic -- in the worst case there may be none at all, and +you'll only later find that something is broken. + +When defining multiple constants, you cannot use the values of other +constants defined in the same declaration. This is because the +calling package doesn't know about any constant within that group +until I<after> the C<use> statement is finished. + + use constant { + BITMASK => 0xAFBAEBA8, + NEGMASK => ~BITMASK, # Error! + }; + +=head2 Magic constants + +Magical values and references can be made into constants at compile +time, allowing for way cool stuff like this. (These error numbers +aren't totally portable, alas.) + + use constant E2BIG => ($! = 7); + print E2BIG, "\n"; # something like "Arg list too long" + print 0+E2BIG, "\n"; # "7" + +You can't produce a tied constant by giving a tied scalar as the +value. References to tied variables, however, can be used as +constants without any problems. + +=head1 TECHNICAL NOTES + +In the current implementation, scalar constants are actually +inlinable subroutines. As of version 5.004 of Perl, the appropriate +scalar constant is inserted directly in place of some subroutine +calls, thereby saving the overhead of a subroutine call. See +L<perlsub/"Constant Functions"> for details about how and when this +happens. + +In the rare case in which you need to discover at run time whether a +particular constant has been declared via this module, you may use +this function to examine the hash C<%constant::declared>. If the given +constant name does not include a package name, the current package is +used. + + sub declared ($) { + use constant 1.01; # don't omit this! + my $name = shift; + $name =~ s/^::/main::/; + my $pkg = caller; + my $full_name = $name =~ /::/ ? $name : "${pkg}::$name"; + $constant::declared{$full_name}; + } + +=head1 BUGS + +In the current version of Perl, list constants are not inlined +and some symbols may be redefined without generating a warning. + +It is not possible to have a subroutine or a keyword with the same +name as a constant in the same package. This is probably a Good Thing. + +A constant with a name in the list C<STDIN STDOUT STDERR ARGV ARGVOUT +ENV INC SIG> is not allowed anywhere but in package C<main::>, for +technical reasons. + +Unlike constants in some languages, these cannot be overridden +on the command line or via environment variables. + +You can get into trouble if you use constants in a context which +automatically quotes barewords (as is true for any subroutine call). +For example, you can't say C<$hash{CONSTANT}> because C<CONSTANT> will +be interpreted as a string. Use C<$hash{CONSTANT()}> or +C<$hash{+CONSTANT}> to prevent the bareword quoting mechanism from +kicking in. Similarly, since the C<< => >> operator quotes a bareword +immediately to its left, you have to say C<< CONSTANT() => 'value' >> +(or simply use a comma in place of the big arrow) instead of +C<< CONSTANT => 'value' >>. + +=head1 AUTHOR + +Tom Phoenix, E<lt>F<rootbeer@redcat.com>E<gt>, with help from +many other folks. + +Multiple constant declarations at once added by Casey West, +E<lt>F<casey@geeknest.com>E<gt>. + +Documentation mostly rewritten by Ilmari Karonen, +E<lt>F<perl@itz.pp.sci.fi>E<gt>. + +=head1 COPYRIGHT + +Copyright (C) 1997, 1999 Tom Phoenix + +This module is free software; you can redistribute it or modify it +under the same terms as Perl itself. + +=cut diff --git a/Master/xemtex/perl/lib/fields.pm b/Master/xemtex/perl/lib/fields.pm new file mode 100644 index 00000000000..be2a7aedab4 --- /dev/null +++ b/Master/xemtex/perl/lib/fields.pm @@ -0,0 +1,285 @@ +package fields; + +=head1 NAME + +fields - compile-time class fields + +=head1 SYNOPSIS + + { + package Foo; + use fields qw(foo bar _Foo_private); + sub new { + my Foo $self = shift; + unless (ref $self) { + $self = fields::new($self); + $self->{_Foo_private} = "this is Foo's secret"; + } + $self->{foo} = 10; + $self->{bar} = 20; + return $self; + } + } + + my Foo $var = Foo::->new; + $var->{foo} = 42; + + # this will generate a compile-time error + $var->{zap} = 42; + + # subclassing + { + package Bar; + use base 'Foo'; + use fields qw(baz _Bar_private); # not shared with Foo + sub new { + my $class = shift; + my $self = fields::new($class); + $self->SUPER::new(); # init base fields + $self->{baz} = 10; # init own fields + $self->{_Bar_private} = "this is Bar's secret"; + return $self; + } + } + +=head1 DESCRIPTION + +The C<fields> pragma enables compile-time verified class fields. + +NOTE: The current implementation keeps the declared fields in the %FIELDS +hash of the calling package, but this may change in future versions. +Do B<not> update the %FIELDS hash directly, because it must be created +at compile-time for it to be fully useful, as is done by this pragma. + +If a typed lexical variable holding a reference is used to access a +hash element and a package with the same name as the type has declared +class fields using this pragma, then the operation is turned into an +array access at compile time. + +The related C<base> pragma will combine fields from base classes and any +fields declared using the C<fields> pragma. This enables field +inheritance to work properly. + +Field names that start with an underscore character are made private to +the class and are not visible to subclasses. Inherited fields can be +overridden but will generate a warning if used together with the C<-w> +switch. + +The effect of all this is that you can have objects with named fields +which are as compact and as fast arrays to access. This only works +as long as the objects are accessed through properly typed variables. +If the objects are not typed, access is only checked at run time. + +The following functions are supported: + +=over 8 + +=item new + +fields::new() creates and blesses a pseudo-hash comprised of the fields +declared using the C<fields> pragma into the specified class. +This makes it possible to write a constructor like this: + + package Critter::Sounds; + use fields qw(cat dog bird); + + sub new { + my Critter::Sounds $self = shift; + $self = fields::new($self) unless ref $self; + $self->{cat} = 'meow'; # scalar element + @$self{'dog','bird'} = ('bark','tweet'); # slice + return $self; + } + +=item phash + +fields::phash() can be used to create and initialize a plain (unblessed) +pseudo-hash. This function should always be used instead of creating +pseudo-hashes directly. + +If the first argument is a reference to an array, the pseudo-hash will +be created with keys from that array. If a second argument is supplied, +it must also be a reference to an array whose elements will be used as +the values. If the second array contains less elements than the first, +the trailing elements of the pseudo-hash will not be initialized. +This makes it particularly useful for creating a pseudo-hash from +subroutine arguments: + + sub dogtag { + my $tag = fields::phash([qw(name rank ser_num)], [@_]); + } + +fields::phash() also accepts a list of key-value pairs that will +be used to construct the pseudo hash. Examples: + + my $tag = fields::phash(name => "Joe", + rank => "captain", + ser_num => 42); + + my $pseudohash = fields::phash(%args); + +=back + +=head1 SEE ALSO + +L<base>, +L<perlref/Pseudo-hashes: Using an array as a hash> + +=cut + +use 5.006_001; +use strict; +no strict 'refs'; +use warnings::register; +our(%attr, $VERSION); + +$VERSION = "1.02"; + +# some constants +sub _PUBLIC () { 1 } +sub _PRIVATE () { 2 } + +# The %attr hash holds the attributes of the currently assigned fields +# per class. The hash is indexed by class names and the hash value is +# an array reference. The first element in the array is the lowest field +# number not belonging to a base class. The remaining elements' indices +# are the field numbers. The values are integer bit masks, or undef +# in the case of base class private fields (which occupy a slot but are +# otherwise irrelevant to the class). + +sub import { + my $class = shift; + return unless @_; + my $package = caller(0); + # avoid possible typo warnings + %{"$package\::FIELDS"} = () unless %{"$package\::FIELDS"}; + my $fields = \%{"$package\::FIELDS"}; + my $fattr = ($attr{$package} ||= [1]); + my $next = @$fattr; + + if ($next > $fattr->[0] + and ($fields->{$_[0]} || 0) >= $fattr->[0]) + { + # There are already fields not belonging to base classes. + # Looks like a possible module reload... + $next = $fattr->[0]; + } + foreach my $f (@_) { + my $fno = $fields->{$f}; + + # Allow the module to be reloaded so long as field positions + # have not changed. + if ($fno and $fno != $next) { + require Carp; + if ($fno < $fattr->[0]) { + warnings::warnif("Hides field '$f' in base class") ; + } else { + Carp::croak("Field name '$f' already in use"); + } + } + $fields->{$f} = $next; + $fattr->[$next] = ($f =~ /^_/) ? _PRIVATE : _PUBLIC; + $next += 1; + } + if (@$fattr > $next) { + # Well, we gave them the benefit of the doubt by guessing the + # module was reloaded, but they appear to be declaring fields + # in more than one place. We can't be sure (without some extra + # bookkeeping) that the rest of the fields will be declared or + # have the same positions, so punt. + require Carp; + Carp::croak ("Reloaded module must declare all fields at once"); + } +} + +sub inherit { # called by base.pm when $base_fields is nonempty + my($derived, $base) = @_; + my $base_attr = $attr{$base}; + my $derived_attr = $attr{$derived} ||= []; + # avoid possible typo warnings + %{"$base\::FIELDS"} = () unless %{"$base\::FIELDS"}; + %{"$derived\::FIELDS"} = () unless %{"$derived\::FIELDS"}; + my $base_fields = \%{"$base\::FIELDS"}; + my $derived_fields = \%{"$derived\::FIELDS"}; + + $derived_attr->[0] = $base_attr ? scalar(@$base_attr) : 1; + while (my($k,$v) = each %$base_fields) { + my($fno); + if ($fno = $derived_fields->{$k} and $fno != $v) { + require Carp; + Carp::croak ("Inherited %FIELDS can't override existing %FIELDS"); + } + if ($base_attr->[$v] & _PRIVATE) { + $derived_attr->[$v] = undef; + } else { + $derived_attr->[$v] = $base_attr->[$v]; + $derived_fields->{$k} = $v; + } + } +} + +sub _dump # sometimes useful for debugging +{ + for my $pkg (sort keys %attr) { + print "\n$pkg"; + if (@{"$pkg\::ISA"}) { + print " (", join(", ", @{"$pkg\::ISA"}), ")"; + } + print "\n"; + my $fields = \%{"$pkg\::FIELDS"}; + for my $f (sort {$fields->{$a} <=> $fields->{$b}} keys %$fields) { + my $no = $fields->{$f}; + print " $no: $f"; + my $fattr = $attr{$pkg}[$no]; + if (defined $fattr) { + my @a; + push(@a, "public") if $fattr & _PUBLIC; + push(@a, "private") if $fattr & _PRIVATE; + push(@a, "inherited") if $no < $attr{$pkg}[0]; + print "\t(", join(", ", @a), ")"; + } + print "\n"; + } + } +} + +sub new { + my $class = shift; + $class = ref $class if ref $class; + return bless [\%{$class . "::FIELDS"}], $class; +} + +sub phash { + my $h; + my $v; + if (@_) { + if (ref $_[0] eq 'ARRAY') { + my $a = shift; + @$h{@$a} = 1 .. @$a; + if (@_) { + $v = shift; + unless (! @_ and ref $v eq 'ARRAY') { + require Carp; + Carp::croak ("Expected at most two array refs\n"); + } + } + } + else { + if (@_ % 2) { + require Carp; + Carp::croak ("Odd number of elements initializing pseudo-hash\n"); + } + my $i = 0; + @$h{grep ++$i % 2, @_} = 1 .. @_ / 2; + $i = 0; + $v = [grep $i++ % 2, @_]; + } + } + else { + $h = {}; + $v = []; + } + [ $h, @$v ]; +} + +1; diff --git a/Master/xemtex/perl/lib/integer.pm b/Master/xemtex/perl/lib/integer.pm new file mode 100644 index 00000000000..caa1ea6951f --- /dev/null +++ b/Master/xemtex/perl/lib/integer.pm @@ -0,0 +1,93 @@ +package integer; + +our $VERSION = '1.00'; + +=head1 NAME + +integer - Perl pragma to use integer arithmetic instead of floating point + +=head1 SYNOPSIS + + use integer; + $x = 10/3; + # $x is now 3, not 3.33333333333333333 + +=head1 DESCRIPTION + +This tells the compiler to use integer operations from here to the end +of the enclosing BLOCK. On many machines, this doesn't matter a great +deal for most computations, but on those without floating point +hardware, it can make a big difference in performance. + +Note that this only affects how most of the arithmetic and relational +B<operators> handle their operands and results, and B<not> how all +numbers everywhere are treated. Specifically, C<use integer;> has the +effect that before computing the results of the arithmetic operators +(+, -, *, /, %, +=, -=, *=, /=, %=, and unary minus), the comparison +operators (<, <=, >, >=, ==, !=, <=>), and the bitwise operators (|, &, +^, <<, >>, |=, &=, ^=, <<=, >>=), the operands have their fractional +portions truncated (or floored), and the result will have its +fractional portion truncated as well. In addition, the range of +operands and results is restricted to that of familiar two's complement +integers, i.e., -(2**31) .. (2**31-1) on 32-bit architectures, and +-(2**63) .. (2**63-1) on 64-bit architectures. For example, this code + + use integer; + $x = 5.8; + $y = 2.5; + $z = 2.7; + $a = 2**31 - 1; # Largest positive integer on 32-bit machines + $, = ", "; + print $x, -$x, $x + $y, $x - $y, $x / $y, $x * $y, $y == $z, $a, $a + 1; + +will print: 5.8, -5, 7, 3, 2, 10, 1, 2147483647, -2147483648 + +Note that $x is still printed as having its true non-integer value of +5.8 since it wasn't operated on. And note too the wrap-around from the +largest positive integer to the largest negative one. Also, arguments +passed to functions and the values returned by them are B<not> affected +by C<use integer;>. E.g., + + srand(1.5); + $, = ", "; + print sin(.5), cos(.5), atan2(1,2), sqrt(2), rand(10); + +will give the same result with or without C<use integer;> The power +operator C<**> is also not affected, so that 2 ** .5 is always the +square root of 2. Now, it so happens that the pre- and post- increment +and decrement operators, ++ and --, are not affected by C<use integer;> +either. Some may rightly consider this to be a bug -- but at least it's +a long-standing one. + +Finally, C<use integer;> also has an additional affect on the bitwise +operators. Normally, the operands and results are treated as +B<unsigned> integers, but with C<use integer;> the operands and results +are B<signed>. This means, among other things, that ~0 is -1, and -2 & +-5 is -6. + +Internally, native integer arithmetic (as provided by your C compiler) +is used. This means that Perl's own semantics for arithmetic +operations may not be preserved. One common source of trouble is the +modulus of negative numbers, which Perl does one way, but your hardware +may do another. + + % perl -le 'print (4 % -3)' + -2 + % perl -Minteger -le 'print (4 % -3)' + 1 + +See L<perlmodlib/"Pragmatic Modules">, L<perlop/"Integer Arithmetic"> + +=cut + +$integer::hint_bits = 0x1; + +sub import { + $^H |= $integer::hint_bits; +} + +sub unimport { + $^H &= ~$integer::hint_bits; +} + +1; diff --git a/Master/xemtex/perl/lib/lib.pm b/Master/xemtex/perl/lib/lib.pm new file mode 100644 index 00000000000..83b8d737cd7 --- /dev/null +++ b/Master/xemtex/perl/lib/lib.pm @@ -0,0 +1,205 @@ +package lib; + +# THIS FILE IS AUTOMATICALLY GENERATED FROM lib_pm.PL. +# ANY CHANGES TO THIS FILE WILL BE OVERWRITTEN BY THE NEXT PERL BUILD. + +use Config; + +use strict; + +my $archname = $Config{archname}; +my $version = $Config{version}; +my @inc_version_list = reverse split / /, $Config{inc_version_list}; + + +our @ORIG_INC = @INC; # take a handy copy of 'original' value +our $VERSION = '0.5564'; +my $Is_MacOS = $^O eq 'MacOS'; +my $Mac_FS; +if ($Is_MacOS) { + require File::Spec; + $Mac_FS = eval { require Mac::FileSpec::Unixish }; +} + +sub import { + shift; + + my %names; + foreach (reverse @_) { + if ($_ eq '') { + require Carp; + Carp::carp("Empty compile time value given to use lib"); + } + + local $_ = _nativize($_); + + if (-e && ! -d _) { + require Carp; + Carp::carp("Parameter to use lib must be directory, not file"); + } + unshift(@INC, $_); + # Add any previous version directories we found at configure time + foreach my $incver (@inc_version_list) + { + my $dir = $Is_MacOS + ? File::Spec->catdir( $_, $incver ) + : "$_/$incver"; + unshift(@INC, $dir) if -d $dir; + } + # Put a corresponding archlib directory in front of $_ if it + # looks like $_ has an archlib directory below it. + my($arch_auto_dir, $arch_dir, $version_dir, $version_arch_dir) + = _get_dirs($_); + unshift(@INC, $arch_dir) if -d $arch_auto_dir; + unshift(@INC, $version_dir) if -d $version_dir; + unshift(@INC, $version_arch_dir) if -d $version_arch_dir; + } + + # remove trailing duplicates + @INC = grep { ++$names{$_} == 1 } @INC; + return; +} + + +sub unimport { + shift; + + my %names; + foreach (@_) { + local $_ = _nativize($_); + + my($arch_auto_dir, $arch_dir, $version_dir, $version_arch_dir) + = _get_dirs($_); + ++$names{$_}; + ++$names{$arch_dir} if -d $arch_auto_dir; + ++$names{$version_dir} if -d $version_dir; + ++$names{$version_arch_dir} if -d $version_arch_dir; + } + + # Remove ALL instances of each named directory. + @INC = grep { !exists $names{$_} } @INC; + return; +} + +sub _get_dirs { + my($dir) = @_; + my($arch_auto_dir, $arch_dir, $version_dir, $version_arch_dir); + + # we could use this for all platforms in the future, but leave it + # Mac-only for now, until there is more time for testing it. + if ($Is_MacOS) { + $arch_auto_dir = File::Spec->catdir( $_, $archname, 'auto' ); + $arch_dir = File::Spec->catdir( $_, $archname, ); + $version_dir = File::Spec->catdir( $_, $version ); + $version_arch_dir = File::Spec->catdir( $_, $version, $archname ); + } else { + $arch_auto_dir = "$_/$archname/auto"; + $arch_dir = "$_/$archname"; + $version_dir = "$_/$version"; + $version_arch_dir = "$_/$version/$archname"; + } + return($arch_auto_dir, $arch_dir, $version_dir, $version_arch_dir); +} + +sub _nativize { + my($dir) = @_; + + if ($Is_MacOS && $Mac_FS && ! -d $dir) { + $dir = Mac::FileSpec::Unixish::nativize($dir); + $dir .= ":" unless $dir =~ /:$/; + } + + return $dir; +} + +1; +__END__ + +=head1 NAME + +lib - manipulate @INC at compile time + +=head1 SYNOPSIS + + use lib LIST; + + no lib LIST; + +=head1 DESCRIPTION + +This is a small simple module which simplifies the manipulation of @INC +at compile time. + +It is typically used to add extra directories to perl's search path so +that later C<use> or C<require> statements will find modules which are +not located on perl's default search path. + +=head2 Adding directories to @INC + +The parameters to C<use lib> are added to the start of the perl search +path. Saying + + use lib LIST; + +is I<almost> the same as saying + + BEGIN { unshift(@INC, LIST) } + +For each directory in LIST (called $dir here) the lib module also +checks to see if a directory called $dir/$archname/auto exists. +If so the $dir/$archname directory is assumed to be a corresponding +architecture specific directory and is added to @INC in front of $dir. + +To avoid memory leaks, all trailing duplicate entries in @INC are +removed. + +=head2 Deleting directories from @INC + +You should normally only add directories to @INC. If you need to +delete directories from @INC take care to only delete those which you +added yourself or which you are certain are not needed by other modules +in your script. Other modules may have added directories which they +need for correct operation. + +The C<no lib> statement deletes all instances of each named directory +from @INC. + +For each directory in LIST (called $dir here) the lib module also +checks to see if a directory called $dir/$archname/auto exists. +If so the $dir/$archname directory is assumed to be a corresponding +architecture specific directory and is also deleted from @INC. + +=head2 Restoring original @INC + +When the lib module is first loaded it records the current value of @INC +in an array C<@lib::ORIG_INC>. To restore @INC to that value you +can say + + @INC = @lib::ORIG_INC; + +=head1 CAVEATS + +In order to keep lib.pm small and simple, it only works with Unix +filepaths. This doesn't mean it only works on Unix, but non-Unix +users must first translate their file paths to Unix conventions. + + # VMS users wanting to put [.stuff.moo] into + # their @INC would write + use lib 'stuff/moo'; + +=head1 NOTES + +In the future, this module will likely use File::Spec for determining +paths, as it does now for Mac OS (where Unix-style or Mac-style paths +work, and Unix-style paths are converted properly to Mac-style paths +before being added to @INC). + +=head1 SEE ALSO + +FindBin - optional module which deals with paths relative to the source file. + +=head1 AUTHOR + +Tim Bunce, 2nd June 1995. + +=cut diff --git a/Master/xemtex/perl/lib/newgetopt.pl b/Master/xemtex/perl/lib/newgetopt.pl new file mode 100644 index 00000000000..95eef220fe7 --- /dev/null +++ b/Master/xemtex/perl/lib/newgetopt.pl @@ -0,0 +1,75 @@ +# $Id: newgetopt.pl,v 1.18 2001-09-21 15:34:59+02 jv Exp $ + +# This library is no longer being maintained, and is included for backward +# compatibility with Perl 4 programs which may require it. +# It is now just a wrapper around the Getopt::Long module. +# +# In particular, this should not be used as an example of modern Perl +# programming techniques. +# +# Suggested alternative: Getopt::Long + +{ package newgetopt; + + # Values for $order. See GNU getopt.c for details. + $REQUIRE_ORDER = 0; + $PERMUTE = 1; + $RETURN_IN_ORDER = 2; + + # Handle POSIX compliancy. + if ( defined $ENV{"POSIXLY_CORRECT"} ) { + $autoabbrev = 0; # no automatic abbrev of options (???) + $getopt_compat = 0; # disallow '+' to start options + $option_start = "(--|-)"; + $order = $REQUIRE_ORDER; + $bundling = 0; + $passthrough = 0; + } + else { + $autoabbrev = 1; # automatic abbrev of options + $getopt_compat = 1; # allow '+' to start options + $option_start = "(--|-|\\+)"; + $order = $PERMUTE; + $bundling = 0; + $passthrough = 0; + } + + # Other configurable settings. + $debug = 0; # for debugging + $ignorecase = 1; # ignore case when matching options + $argv_end = "--"; # don't change this! +} + +use Getopt::Long; + +################ Subroutines ################ + +sub NGetOpt { + + $Getopt::Long::debug = $newgetopt::debug + if defined $newgetopt::debug; + $Getopt::Long::autoabbrev = $newgetopt::autoabbrev + if defined $newgetopt::autoabbrev; + $Getopt::Long::getopt_compat = $newgetopt::getopt_compat + if defined $newgetopt::getopt_compat; + $Getopt::Long::option_start = $newgetopt::option_start + if defined $newgetopt::option_start; + $Getopt::Long::order = $newgetopt::order + if defined $newgetopt::order; + $Getopt::Long::bundling = $newgetopt::bundling + if defined $newgetopt::bundling; + $Getopt::Long::ignorecase = $newgetopt::ignorecase + if defined $newgetopt::ignorecase; + $Getopt::Long::ignorecase = $newgetopt::ignorecase + if defined $newgetopt::ignorecase; + $Getopt::Long::passthrough = $newgetopt::passthrough + if defined $newgetopt::passthrough; + + &GetOptions; +} + +################ Package return ################ + +1; + +################ End of newgetopt.pl ################ diff --git a/Master/xemtex/perl/lib/overload.pm b/Master/xemtex/perl/lib/overload.pm new file mode 100644 index 00000000000..fb1a0d1236e --- /dev/null +++ b/Master/xemtex/perl/lib/overload.pm @@ -0,0 +1,1432 @@ +package overload; + +our $VERSION = '1.00'; + +$overload::hint_bits = 0x20000; + +sub nil {} + +sub OVERLOAD { + $package = shift; + my %arg = @_; + my ($sub, $fb); + $ {$package . "::OVERLOAD"}{dummy}++; # Register with magic by touching. + *{$package . "::()"} = \&nil; # Make it findable via fetchmethod. + for (keys %arg) { + if ($_ eq 'fallback') { + $fb = $arg{$_}; + } else { + $sub = $arg{$_}; + if (not ref $sub and $sub !~ /::/) { + $ {$package . "::(" . $_} = $sub; + $sub = \&nil; + } + #print STDERR "Setting `$ {'package'}::\cO$_' to \\&`$sub'.\n"; + *{$package . "::(" . $_} = \&{ $sub }; + } + } + ${$package . "::()"} = $fb; # Make it findable too (fallback only). +} + +sub import { + $package = (caller())[0]; + # *{$package . "::OVERLOAD"} = \&OVERLOAD; + shift; + $package->overload::OVERLOAD(@_); +} + +sub unimport { + $package = (caller())[0]; + ${$package . "::OVERLOAD"}{dummy}++; # Upgrade the table + shift; + for (@_) { + if ($_ eq 'fallback') { + undef $ {$package . "::()"}; + } else { + delete $ {$package . "::"}{"(" . $_}; + } + } +} + +sub Overloaded { + my $package = shift; + $package = ref $package if ref $package; + $package->can('()'); +} + +sub ov_method { + my $globref = shift; + return undef unless $globref; + my $sub = \&{*$globref}; + return $sub if $sub ne \&nil; + return shift->can($ {*$globref}); +} + +sub OverloadedStringify { + my $package = shift; + $package = ref $package if ref $package; + #$package->can('(""') + ov_method mycan($package, '(""'), $package + or ov_method mycan($package, '(0+'), $package + or ov_method mycan($package, '(bool'), $package + or ov_method mycan($package, '(nomethod'), $package; +} + +sub Method { + my $package = shift; + $package = ref $package if ref $package; + #my $meth = $package->can('(' . shift); + ov_method mycan($package, '(' . shift), $package; + #return $meth if $meth ne \&nil; + #return $ {*{$meth}}; +} + +sub AddrRef { + my $package = ref $_[0]; + return "$_[0]" unless $package; + bless $_[0], overload::Fake; # Non-overloaded package + my $str = "$_[0]"; + bless $_[0], $package; # Back + $package . substr $str, index $str, '='; +} + +sub StrVal { + (ref $_[0] && OverloadedStringify($_[0]) or ref($_[0]) eq 'Regexp') ? + (AddrRef(shift)) : + "$_[0]"; +} + +sub mycan { # Real can would leave stubs. + my ($package, $meth) = @_; + return \*{$package . "::$meth"} if defined &{$package . "::$meth"}; + my $p; + foreach $p (@{$package . "::ISA"}) { + my $out = mycan($p, $meth); + return $out if $out; + } + return undef; +} + +%constants = ( + 'integer' => 0x1000, + 'float' => 0x2000, + 'binary' => 0x4000, + 'q' => 0x8000, + 'qr' => 0x10000, + ); + +%ops = ( with_assign => "+ - * / % ** << >> x .", + assign => "+= -= *= /= %= **= <<= >>= x= .=", + num_comparison => "< <= > >= == !=", + '3way_comparison'=> "<=> cmp", + str_comparison => "lt le gt ge eq ne", + binary => "& | ^", + unary => "neg ! ~", + mutators => '++ --', + func => "atan2 cos sin exp abs log sqrt int", + conversion => 'bool "" 0+', + iterators => '<>', + dereferencing => '${} @{} %{} &{} *{}', + special => 'nomethod fallback ='); + +use warnings::register; +sub constant { + # Arguments: what, sub + while (@_) { + if (@_ == 1) { + warnings::warnif ("Odd number of arguments for overload::constant"); + last; + } + elsif (!exists $constants {$_ [0]}) { + warnings::warnif ("`$_[0]' is not an overloadable type"); + } + elsif (!ref $_ [1] || "$_[1]" !~ /CODE\(0x[\da-f]+\)$/) { + # Can't use C<ref $_[1] eq "CODE"> above as code references can be + # blessed, and C<ref> would return the package the ref is blessed into. + if (warnings::enabled) { + $_ [1] = "undef" unless defined $_ [1]; + warnings::warn ("`$_[1]' is not a code reference"); + } + } + else { + $^H{$_[0]} = $_[1]; + $^H |= $constants{$_[0]} | $overload::hint_bits; + } + shift, shift; + } +} + +sub remove_constant { + # Arguments: what, sub + while (@_) { + delete $^H{$_[0]}; + $^H &= ~ $constants{$_[0]}; + shift, shift; + } +} + +1; + +__END__ + +=head1 NAME + +overload - Package for overloading perl operations + +=head1 SYNOPSIS + + package SomeThing; + + use overload + '+' => \&myadd, + '-' => \&mysub; + # etc + ... + + package main; + $a = new SomeThing 57; + $b=5+$a; + ... + if (overload::Overloaded $b) {...} + ... + $strval = overload::StrVal $b; + +=head1 DESCRIPTION + +=head2 Declaration of overloaded functions + +The compilation directive + + package Number; + use overload + "+" => \&add, + "*=" => "muas"; + +declares function Number::add() for addition, and method muas() in +the "class" C<Number> (or one of its base classes) +for the assignment form C<*=> of multiplication. + +Arguments of this directive come in (key, value) pairs. Legal values +are values legal inside a C<&{ ... }> call, so the name of a +subroutine, a reference to a subroutine, or an anonymous subroutine +will all work. Note that values specified as strings are +interpreted as methods, not subroutines. Legal keys are listed below. + +The subroutine C<add> will be called to execute C<$a+$b> if $a +is a reference to an object blessed into the package C<Number>, or if $a is +not an object from a package with defined mathemagic addition, but $b is a +reference to a C<Number>. It can also be called in other situations, like +C<$a+=7>, or C<$a++>. See L<MAGIC AUTOGENERATION>. (Mathemagical +methods refer to methods triggered by an overloaded mathematical +operator.) + +Since overloading respects inheritance via the @ISA hierarchy, the +above declaration would also trigger overloading of C<+> and C<*=> in +all the packages which inherit from C<Number>. + +=head2 Calling Conventions for Binary Operations + +The functions specified in the C<use overload ...> directive are called +with three (in one particular case with four, see L<Last Resort>) +arguments. If the corresponding operation is binary, then the first +two arguments are the two arguments of the operation. However, due to +general object calling conventions, the first argument should always be +an object in the package, so in the situation of C<7+$a>, the +order of the arguments is interchanged. It probably does not matter +when implementing the addition method, but whether the arguments +are reversed is vital to the subtraction method. The method can +query this information by examining the third argument, which can take +three different values: + +=over 7 + +=item FALSE + +the order of arguments is as in the current operation. + +=item TRUE + +the arguments are reversed. + +=item C<undef> + +the current operation is an assignment variant (as in +C<$a+=7>), but the usual function is called instead. This additional +information can be used to generate some optimizations. Compare +L<Calling Conventions for Mutators>. + +=back + +=head2 Calling Conventions for Unary Operations + +Unary operation are considered binary operations with the second +argument being C<undef>. Thus the functions that overloads C<{"++"}> +is called with arguments C<($a,undef,'')> when $a++ is executed. + +=head2 Calling Conventions for Mutators + +Two types of mutators have different calling conventions: + +=over + +=item C<++> and C<--> + +The routines which implement these operators are expected to actually +I<mutate> their arguments. So, assuming that $obj is a reference to a +number, + + sub incr { my $n = $ {$_[0]}; ++$n; $_[0] = bless \$n} + +is an appropriate implementation of overloaded C<++>. Note that + + sub incr { ++$ {$_[0]} ; shift } + +is OK if used with preincrement and with postincrement. (In the case +of postincrement a copying will be performed, see L<Copy Constructor>.) + +=item C<x=> and other assignment versions + +There is nothing special about these methods. They may change the +value of their arguments, and may leave it as is. The result is going +to be assigned to the value in the left-hand-side if different from +this value. + +This allows for the same method to be used as overloaded C<+=> and +C<+>. Note that this is I<allowed>, but not recommended, since by the +semantic of L<"Fallback"> Perl will call the method for C<+> anyway, +if C<+=> is not overloaded. + +=back + +B<Warning.> Due to the presence of assignment versions of operations, +routines which may be called in assignment context may create +self-referential structures. Currently Perl will not free self-referential +structures until cycles are C<explicitly> broken. You may get problems +when traversing your structures too. + +Say, + + use overload '+' => sub { bless [ \$_[0], \$_[1] ] }; + +is asking for trouble, since for code C<$obj += $foo> the subroutine +is called as C<$obj = add($obj, $foo, undef)>, or C<$obj = [\$obj, +\$foo]>. If using such a subroutine is an important optimization, one +can overload C<+=> explicitly by a non-"optimized" version, or switch +to non-optimized version if C<not defined $_[2]> (see +L<Calling Conventions for Binary Operations>). + +Even if no I<explicit> assignment-variants of operators are present in +the script, they may be generated by the optimizer. Say, C<",$obj,"> or +C<',' . $obj . ','> may be both optimized to + + my $tmp = ',' . $obj; $tmp .= ','; + +=head2 Overloadable Operations + +The following symbols can be specified in C<use overload> directive: + +=over 5 + +=item * I<Arithmetic operations> + + "+", "+=", "-", "-=", "*", "*=", "/", "/=", "%", "%=", + "**", "**=", "<<", "<<=", ">>", ">>=", "x", "x=", ".", ".=", + +For these operations a substituted non-assignment variant can be called if +the assignment variant is not available. Methods for operations C<+>, +C<->, C<+=>, and C<-=> can be called to automatically generate +increment and decrement methods. The operation C<-> can be used to +autogenerate missing methods for unary minus or C<abs>. + +See L<"MAGIC AUTOGENERATION">, L<"Calling Conventions for Mutators"> and +L<"Calling Conventions for Binary Operations">) for details of these +substitutions. + +=item * I<Comparison operations> + + "<", "<=", ">", ">=", "==", "!=", "<=>", + "lt", "le", "gt", "ge", "eq", "ne", "cmp", + +If the corresponding "spaceship" variant is available, it can be +used to substitute for the missing operation. During C<sort>ing +arrays, C<cmp> is used to compare values subject to C<use overload>. + +=item * I<Bit operations> + + "&", "^", "|", "neg", "!", "~", + +C<neg> stands for unary minus. If the method for C<neg> is not +specified, it can be autogenerated using the method for +subtraction. If the method for C<!> is not specified, it can be +autogenerated using the methods for C<bool>, or C<"">, or C<0+>. + +=item * I<Increment and decrement> + + "++", "--", + +If undefined, addition and subtraction methods can be +used instead. These operations are called both in prefix and +postfix form. + +=item * I<Transcendental functions> + + "atan2", "cos", "sin", "exp", "abs", "log", "sqrt", "int" + +If C<abs> is unavailable, it can be autogenerated using methods +for "E<lt>" or "E<lt>=E<gt>" combined with either unary minus or subtraction. + +Note that traditionally the Perl function L<int> rounds to 0, thus for +floating-point-like types one should follow the same semantic. If +C<int> is unavailable, it can be autogenerated using the overloading of +C<0+>. + +=item * I<Boolean, string and numeric conversion> + + 'bool', '""', '0+', + +If one or two of these operations are not overloaded, the remaining ones can +be used instead. C<bool> is used in the flow control operators +(like C<while>) and for the ternary C<?:> operation. These functions can +return any arbitrary Perl value. If the corresponding operation for this value +is overloaded too, that operation will be called again with this value. + +As a special case if the overload returns the object itself then it will +be used directly. An overloaded conversion returning the object is +probably a bug, because you're likely to get something that looks like +C<YourPackage=HASH(0x8172b34)>. + +=item * I<Iteration> + + "<>" + +If not overloaded, the argument will be converted to a filehandle or +glob (which may require a stringification). The same overloading +happens both for the I<read-filehandle> syntax C<E<lt>$varE<gt>> and +I<globbing> syntax C<E<lt>${var}E<gt>>. + +B<BUGS> Even in list context, the iterator is currently called only +once and with scalar context. + +=item * I<Dereferencing> + + '${}', '@{}', '%{}', '&{}', '*{}'. + +If not overloaded, the argument will be dereferenced I<as is>, thus +should be of correct type. These functions should return a reference +of correct type, or another object with overloaded dereferencing. + +As a special case if the overload returns the object itself then it +will be used directly (provided it is the correct type). + +The dereference operators must be specified explicitly they will not be passed to +"nomethod". + +=item * I<Special> + + "nomethod", "fallback", "=", + +see L<SPECIAL SYMBOLS FOR C<use overload>>. + +=back + +See L<"Fallback"> for an explanation of when a missing method can be +autogenerated. + +A computer-readable form of the above table is available in the hash +%overload::ops, with values being space-separated lists of names: + + with_assign => '+ - * / % ** << >> x .', + assign => '+= -= *= /= %= **= <<= >>= x= .=', + num_comparison => '< <= > >= == !=', + '3way_comparison'=> '<=> cmp', + str_comparison => 'lt le gt ge eq ne', + binary => '& | ^', + unary => 'neg ! ~', + mutators => '++ --', + func => 'atan2 cos sin exp abs log sqrt', + conversion => 'bool "" 0+', + iterators => '<>', + dereferencing => '${} @{} %{} &{} *{}', + special => 'nomethod fallback =' + +=head2 Inheritance and overloading + +Inheritance interacts with overloading in two ways. + +=over + +=item Strings as values of C<use overload> directive + +If C<value> in + + use overload key => value; + +is a string, it is interpreted as a method name. + +=item Overloading of an operation is inherited by derived classes + +Any class derived from an overloaded class is also overloaded. The +set of overloaded methods is the union of overloaded methods of all +the ancestors. If some method is overloaded in several ancestor, then +which description will be used is decided by the usual inheritance +rules: + +If C<A> inherits from C<B> and C<C> (in this order), C<B> overloads +C<+> with C<\&D::plus_sub>, and C<C> overloads C<+> by C<"plus_meth">, +then the subroutine C<D::plus_sub> will be called to implement +operation C<+> for an object in package C<A>. + +=back + +Note that since the value of the C<fallback> key is not a subroutine, +its inheritance is not governed by the above rules. In the current +implementation, the value of C<fallback> in the first overloaded +ancestor is used, but this is accidental and subject to change. + +=head1 SPECIAL SYMBOLS FOR C<use overload> + +Three keys are recognized by Perl that are not covered by the above +description. + +=head2 Last Resort + +C<"nomethod"> should be followed by a reference to a function of four +parameters. If defined, it is called when the overloading mechanism +cannot find a method for some operation. The first three arguments of +this function coincide with the arguments for the corresponding method if +it were found, the fourth argument is the symbol +corresponding to the missing method. If several methods are tried, +the last one is used. Say, C<1-$a> can be equivalent to + + &nomethodMethod($a,1,1,"-") + +if the pair C<"nomethod" =E<gt> "nomethodMethod"> was specified in the +C<use overload> directive. + +The C<"nomethod"> mechanism is I<not> used for the dereference operators +( ${} @{} %{} &{} *{} ). + + +If some operation cannot be resolved, and there is no function +assigned to C<"nomethod">, then an exception will be raised via die()-- +unless C<"fallback"> was specified as a key in C<use overload> directive. + + +=head2 Fallback + +The key C<"fallback"> governs what to do if a method for a particular +operation is not found. Three different cases are possible depending on +the value of C<"fallback">: + +=over 16 + +=item * C<undef> + +Perl tries to use a +substituted method (see L<MAGIC AUTOGENERATION>). If this fails, it +then tries to calls C<"nomethod"> value; if missing, an exception +will be raised. + +=item * TRUE + +The same as for the C<undef> value, but no exception is raised. Instead, +it silently reverts to what it would have done were there no C<use overload> +present. + +=item * defined, but FALSE + +No autogeneration is tried. Perl tries to call +C<"nomethod"> value, and if this is missing, raises an exception. + +=back + +B<Note.> C<"fallback"> inheritance via @ISA is not carved in stone +yet, see L<"Inheritance and overloading">. + +=head2 Copy Constructor + +The value for C<"="> is a reference to a function with three +arguments, i.e., it looks like the other values in C<use +overload>. However, it does not overload the Perl assignment +operator. This would go against Camel hair. + +This operation is called in the situations when a mutator is applied +to a reference that shares its object with some other reference, such +as + + $a=$b; + ++$a; + +To make this change $a and not change $b, a copy of C<$$a> is made, +and $a is assigned a reference to this new object. This operation is +done during execution of the C<++$a>, and not during the assignment, +(so before the increment C<$$a> coincides with C<$$b>). This is only +done if C<++> is expressed via a method for C<'++'> or C<'+='> (or +C<nomethod>). Note that if this operation is expressed via C<'+'> +a nonmutator, i.e., as in + + $a=$b; + $a=$a+1; + +then C<$a> does not reference a new copy of C<$$a>, since $$a does not +appear as lvalue when the above code is executed. + +If the copy constructor is required during the execution of some mutator, +but a method for C<'='> was not specified, it can be autogenerated as a +string copy if the object is a plain scalar. + +=over 5 + +=item B<Example> + +The actually executed code for + + $a=$b; + Something else which does not modify $a or $b.... + ++$a; + +may be + + $a=$b; + Something else which does not modify $a or $b.... + $a = $a->clone(undef,""); + $a->incr(undef,""); + +if $b was mathemagical, and C<'++'> was overloaded with C<\&incr>, +C<'='> was overloaded with C<\&clone>. + +=back + +Same behaviour is triggered by C<$b = $a++>, which is consider a synonym for +C<$b = $a; ++$a>. + +=head1 MAGIC AUTOGENERATION + +If a method for an operation is not found, and the value for C<"fallback"> is +TRUE or undefined, Perl tries to autogenerate a substitute method for +the missing operation based on the defined operations. Autogenerated method +substitutions are possible for the following operations: + +=over 16 + +=item I<Assignment forms of arithmetic operations> + +C<$a+=$b> can use the method for C<"+"> if the method for C<"+="> +is not defined. + +=item I<Conversion operations> + +String, numeric, and boolean conversion are calculated in terms of one +another if not all of them are defined. + +=item I<Increment and decrement> + +The C<++$a> operation can be expressed in terms of C<$a+=1> or C<$a+1>, +and C<$a--> in terms of C<$a-=1> and C<$a-1>. + +=item C<abs($a)> + +can be expressed in terms of C<$aE<lt>0> and C<-$a> (or C<0-$a>). + +=item I<Unary minus> + +can be expressed in terms of subtraction. + +=item I<Negation> + +C<!> and C<not> can be expressed in terms of boolean conversion, or +string or numerical conversion. + +=item I<Concatenation> + +can be expressed in terms of string conversion. + +=item I<Comparison operations> + +can be expressed in terms of its "spaceship" counterpart: either +C<E<lt>=E<gt>> or C<cmp>: + + <, >, <=, >=, ==, != in terms of <=> + lt, gt, le, ge, eq, ne in terms of cmp + +=item I<Iterator> + + <> in terms of builtin operations + +=item I<Dereferencing> + + ${} @{} %{} &{} *{} in terms of builtin operations + +=item I<Copy operator> + +can be expressed in terms of an assignment to the dereferenced value, if this +value is a scalar and not a reference. + +=back + +=head1 Losing overloading + +The restriction for the comparison operation is that even if, for example, +`C<cmp>' should return a blessed reference, the autogenerated `C<lt>' +function will produce only a standard logical value based on the +numerical value of the result of `C<cmp>'. In particular, a working +numeric conversion is needed in this case (possibly expressed in terms of +other conversions). + +Similarly, C<.=> and C<x=> operators lose their mathemagical properties +if the string conversion substitution is applied. + +When you chop() a mathemagical object it is promoted to a string and its +mathemagical properties are lost. The same can happen with other +operations as well. + +=head1 Run-time Overloading + +Since all C<use> directives are executed at compile-time, the only way to +change overloading during run-time is to + + eval 'use overload "+" => \&addmethod'; + +You can also use + + eval 'no overload "+", "--", "<="'; + +though the use of these constructs during run-time is questionable. + +=head1 Public functions + +Package C<overload.pm> provides the following public functions: + +=over 5 + +=item overload::StrVal(arg) + +Gives string value of C<arg> as in absence of stringify overloading. + +=item overload::Overloaded(arg) + +Returns true if C<arg> is subject to overloading of some operations. + +=item overload::Method(obj,op) + +Returns C<undef> or a reference to the method that implements C<op>. + +=back + +=head1 Overloading constants + +For some application Perl parser mangles constants too much. It is possible +to hook into this process via overload::constant() and overload::remove_constant() +functions. + +These functions take a hash as an argument. The recognized keys of this hash +are + +=over 8 + +=item integer + +to overload integer constants, + +=item float + +to overload floating point constants, + +=item binary + +to overload octal and hexadecimal constants, + +=item q + +to overload C<q>-quoted strings, constant pieces of C<qq>- and C<qx>-quoted +strings and here-documents, + +=item qr + +to overload constant pieces of regular expressions. + +=back + +The corresponding values are references to functions which take three arguments: +the first one is the I<initial> string form of the constant, the second one +is how Perl interprets this constant, the third one is how the constant is used. +Note that the initial string form does not +contain string delimiters, and has backslashes in backslash-delimiter +combinations stripped (thus the value of delimiter is not relevant for +processing of this string). The return value of this function is how this +constant is going to be interpreted by Perl. The third argument is undefined +unless for overloaded C<q>- and C<qr>- constants, it is C<q> in single-quote +context (comes from strings, regular expressions, and single-quote HERE +documents), it is C<tr> for arguments of C<tr>/C<y> operators, +it is C<s> for right-hand side of C<s>-operator, and it is C<qq> otherwise. + +Since an expression C<"ab$cd,,"> is just a shortcut for C<'ab' . $cd . ',,'>, +it is expected that overloaded constant strings are equipped with reasonable +overloaded catenation operator, otherwise absurd results will result. +Similarly, negative numbers are considered as negations of positive constants. + +Note that it is probably meaningless to call the functions overload::constant() +and overload::remove_constant() from anywhere but import() and unimport() methods. +From these methods they may be called as + + sub import { + shift; + return unless @_; + die "unknown import: @_" unless @_ == 1 and $_[0] eq ':constant'; + overload::constant integer => sub {Math::BigInt->new(shift)}; + } + +B<BUGS> Currently overloaded-ness of constants does not propagate +into C<eval '...'>. + +=head1 IMPLEMENTATION + +What follows is subject to change RSN. + +The table of methods for all operations is cached in magic for the +symbol table hash for the package. The cache is invalidated during +processing of C<use overload>, C<no overload>, new function +definitions, and changes in @ISA. However, this invalidation remains +unprocessed until the next C<bless>ing into the package. Hence if you +want to change overloading structure dynamically, you'll need an +additional (fake) C<bless>ing to update the table. + +(Every SVish thing has a magic queue, and magic is an entry in that +queue. This is how a single variable may participate in multiple +forms of magic simultaneously. For instance, environment variables +regularly have two forms at once: their %ENV magic and their taint +magic. However, the magic which implements overloading is applied to +the stashes, which are rarely used directly, thus should not slow down +Perl.) + +If an object belongs to a package using overload, it carries a special +flag. Thus the only speed penalty during arithmetic operations without +overloading is the checking of this flag. + +In fact, if C<use overload> is not present, there is almost no overhead +for overloadable operations, so most programs should not suffer +measurable performance penalties. A considerable effort was made to +minimize the overhead when overload is used in some package, but the +arguments in question do not belong to packages using overload. When +in doubt, test your speed with C<use overload> and without it. So far +there have been no reports of substantial speed degradation if Perl is +compiled with optimization turned on. + +There is no size penalty for data if overload is not used. The only +size penalty if overload is used in some package is that I<all> the +packages acquire a magic during the next C<bless>ing into the +package. This magic is three-words-long for packages without +overloading, and carries the cache table if the package is overloaded. + +Copying (C<$a=$b>) is shallow; however, a one-level-deep copying is +carried out before any operation that can imply an assignment to the +object $a (or $b) refers to, like C<$a++>. You can override this +behavior by defining your own copy constructor (see L<"Copy Constructor">). + +It is expected that arguments to methods that are not explicitly supposed +to be changed are constant (but this is not enforced). + +=head1 Metaphor clash + +One may wonder why the semantic of overloaded C<=> is so counter intuitive. +If it I<looks> counter intuitive to you, you are subject to a metaphor +clash. + +Here is a Perl object metaphor: + +I< object is a reference to blessed data> + +and an arithmetic metaphor: + +I< object is a thing by itself>. + +The I<main> problem of overloading C<=> is the fact that these metaphors +imply different actions on the assignment C<$a = $b> if $a and $b are +objects. Perl-think implies that $a becomes a reference to whatever +$b was referencing. Arithmetic-think implies that the value of "object" +$a is changed to become the value of the object $b, preserving the fact +that $a and $b are separate entities. + +The difference is not relevant in the absence of mutators. After +a Perl-way assignment an operation which mutates the data referenced by $a +would change the data referenced by $b too. Effectively, after +C<$a = $b> values of $a and $b become I<indistinguishable>. + +On the other hand, anyone who has used algebraic notation knows the +expressive power of the arithmetic metaphor. Overloading works hard +to enable this metaphor while preserving the Perlian way as far as +possible. Since it is not possible to freely mix two contradicting +metaphors, overloading allows the arithmetic way to write things I<as +far as all the mutators are called via overloaded access only>. The +way it is done is described in L<Copy Constructor>. + +If some mutator methods are directly applied to the overloaded values, +one may need to I<explicitly unlink> other values which references the +same value: + + $a = new Data 23; + ... + $b = $a; # $b is "linked" to $a + ... + $a = $a->clone; # Unlink $b from $a + $a->increment_by(4); + +Note that overloaded access makes this transparent: + + $a = new Data 23; + $b = $a; # $b is "linked" to $a + $a += 4; # would unlink $b automagically + +However, it would not make + + $a = new Data 23; + $a = 4; # Now $a is a plain 4, not 'Data' + +preserve "objectness" of $a. But Perl I<has> a way to make assignments +to an object do whatever you want. It is just not the overload, but +tie()ing interface (see L<perlfunc/tie>). Adding a FETCH() method +which returns the object itself, and STORE() method which changes the +value of the object, one can reproduce the arithmetic metaphor in its +completeness, at least for variables which were tie()d from the start. + +(Note that a workaround for a bug may be needed, see L<"BUGS">.) + +=head1 Cookbook + +Please add examples to what follows! + +=head2 Two-face scalars + +Put this in F<two_face.pm> in your Perl library directory: + + package two_face; # Scalars with separate string and + # numeric values. + sub new { my $p = shift; bless [@_], $p } + use overload '""' => \&str, '0+' => \&num, fallback => 1; + sub num {shift->[1]} + sub str {shift->[0]} + +Use it as follows: + + require two_face; + my $seven = new two_face ("vii", 7); + printf "seven=$seven, seven=%d, eight=%d\n", $seven, $seven+1; + print "seven contains `i'\n" if $seven =~ /i/; + +(The second line creates a scalar which has both a string value, and a +numeric value.) This prints: + + seven=vii, seven=7, eight=8 + seven contains `i' + +=head2 Two-face references + +Suppose you want to create an object which is accessible as both an +array reference and a hash reference, similar to the +L<pseudo-hash|perlref/"Pseudo-hashes: Using an array as a hash"> +builtin Perl type. Let's make it better than a pseudo-hash by +allowing index 0 to be treated as a normal element. + + package two_refs; + use overload '%{}' => \&gethash, '@{}' => sub { $ {shift()} }; + sub new { + my $p = shift; + bless \ [@_], $p; + } + sub gethash { + my %h; + my $self = shift; + tie %h, ref $self, $self; + \%h; + } + + sub TIEHASH { my $p = shift; bless \ shift, $p } + my %fields; + my $i = 0; + $fields{$_} = $i++ foreach qw{zero one two three}; + sub STORE { + my $self = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $$self->[$key] = shift; + } + sub FETCH { + my $self = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $$self->[$key]; + } + +Now one can access an object using both the array and hash syntax: + + my $bar = new two_refs 3,4,5,6; + $bar->[2] = 11; + $bar->{two} == 11 or die 'bad hash fetch'; + +Note several important features of this example. First of all, the +I<actual> type of $bar is a scalar reference, and we do not overload +the scalar dereference. Thus we can get the I<actual> non-overloaded +contents of $bar by just using C<$$bar> (what we do in functions which +overload dereference). Similarly, the object returned by the +TIEHASH() method is a scalar reference. + +Second, we create a new tied hash each time the hash syntax is used. +This allows us not to worry about a possibility of a reference loop, +which would lead to a memory leak. + +Both these problems can be cured. Say, if we want to overload hash +dereference on a reference to an object which is I<implemented> as a +hash itself, the only problem one has to circumvent is how to access +this I<actual> hash (as opposed to the I<virtual> hash exhibited by the +overloaded dereference operator). Here is one possible fetching routine: + + sub access_hash { + my ($self, $key) = (shift, shift); + my $class = ref $self; + bless $self, 'overload::dummy'; # Disable overloading of %{} + my $out = $self->{$key}; + bless $self, $class; # Restore overloading + $out; + } + +To remove creation of the tied hash on each access, one may an extra +level of indirection which allows a non-circular structure of references: + + package two_refs1; + use overload '%{}' => sub { ${shift()}->[1] }, + '@{}' => sub { ${shift()}->[0] }; + sub new { + my $p = shift; + my $a = [@_]; + my %h; + tie %h, $p, $a; + bless \ [$a, \%h], $p; + } + sub gethash { + my %h; + my $self = shift; + tie %h, ref $self, $self; + \%h; + } + + sub TIEHASH { my $p = shift; bless \ shift, $p } + my %fields; + my $i = 0; + $fields{$_} = $i++ foreach qw{zero one two three}; + sub STORE { + my $a = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $a->[$key] = shift; + } + sub FETCH { + my $a = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $a->[$key]; + } + +Now if $baz is overloaded like this, then C<$baz> is a reference to a +reference to the intermediate array, which keeps a reference to an +actual array, and the access hash. The tie()ing object for the access +hash is a reference to a reference to the actual array, so + +=over + +=item * + +There are no loops of references. + +=item * + +Both "objects" which are blessed into the class C<two_refs1> are +references to a reference to an array, thus references to a I<scalar>. +Thus the accessor expression C<$$foo-E<gt>[$ind]> involves no +overloaded operations. + +=back + +=head2 Symbolic calculator + +Put this in F<symbolic.pm> in your Perl library directory: + + package symbolic; # Primitive symbolic calculator + use overload nomethod => \&wrap; + + sub new { shift; bless ['n', @_] } + sub wrap { + my ($obj, $other, $inv, $meth) = @_; + ($obj, $other) = ($other, $obj) if $inv; + bless [$meth, $obj, $other]; + } + +This module is very unusual as overloaded modules go: it does not +provide any usual overloaded operators, instead it provides the L<Last +Resort> operator C<nomethod>. In this example the corresponding +subroutine returns an object which encapsulates operations done over +the objects: C<new symbolic 3> contains C<['n', 3]>, C<2 + new +symbolic 3> contains C<['+', 2, ['n', 3]]>. + +Here is an example of the script which "calculates" the side of +circumscribed octagon using the above package: + + require symbolic; + my $iter = 1; # 2**($iter+2) = 8 + my $side = new symbolic 1; + my $cnt = $iter; + + while ($cnt--) { + $side = (sqrt(1 + $side**2) - 1)/$side; + } + print "OK\n"; + +The value of $side is + + ['/', ['-', ['sqrt', ['+', 1, ['**', ['n', 1], 2]], + undef], 1], ['n', 1]] + +Note that while we obtained this value using a nice little script, +there is no simple way to I<use> this value. In fact this value may +be inspected in debugger (see L<perldebug>), but ony if +C<bareStringify> B<O>ption is set, and not via C<p> command. + +If one attempts to print this value, then the overloaded operator +C<""> will be called, which will call C<nomethod> operator. The +result of this operator will be stringified again, but this result is +again of type C<symbolic>, which will lead to an infinite loop. + +Add a pretty-printer method to the module F<symbolic.pm>: + + sub pretty { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + $b = 'u' unless defined $b; + $a = $a->pretty if ref $a; + $b = $b->pretty if ref $b; + "[$meth $a $b]"; + } + +Now one can finish the script by + + print "side = ", $side->pretty, "\n"; + +The method C<pretty> is doing object-to-string conversion, so it +is natural to overload the operator C<""> using this method. However, +inside such a method it is not necessary to pretty-print the +I<components> $a and $b of an object. In the above subroutine +C<"[$meth $a $b]"> is a catenation of some strings and components $a +and $b. If these components use overloading, the catenation operator +will look for an overloaded operator C<.>; if not present, it will +look for an overloaded operator C<"">. Thus it is enough to use + + use overload nomethod => \&wrap, '""' => \&str; + sub str { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + $b = 'u' unless defined $b; + "[$meth $a $b]"; + } + +Now one can change the last line of the script to + + print "side = $side\n"; + +which outputs + + side = [/ [- [sqrt [+ 1 [** [n 1 u] 2]] u] 1] [n 1 u]] + +and one can inspect the value in debugger using all the possible +methods. + +Something is still amiss: consider the loop variable $cnt of the +script. It was a number, not an object. We cannot make this value of +type C<symbolic>, since then the loop will not terminate. + +Indeed, to terminate the cycle, the $cnt should become false. +However, the operator C<bool> for checking falsity is overloaded (this +time via overloaded C<"">), and returns a long string, thus any object +of type C<symbolic> is true. To overcome this, we need a way to +compare an object to 0. In fact, it is easier to write a numeric +conversion routine. + +Here is the text of F<symbolic.pm> with such a routine added (and +slightly modified str()): + + package symbolic; # Primitive symbolic calculator + use overload + nomethod => \&wrap, '""' => \&str, '0+' => \# + + sub new { shift; bless ['n', @_] } + sub wrap { + my ($obj, $other, $inv, $meth) = @_; + ($obj, $other) = ($other, $obj) if $inv; + bless [$meth, $obj, $other]; + } + sub str { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + if (defined $b) { + "[$meth $a $b]"; + } else { + "[$meth $a]"; + } + } + my %subr = ( n => sub {$_[0]}, + sqrt => sub {sqrt $_[0]}, + '-' => sub {shift() - shift()}, + '+' => sub {shift() + shift()}, + '/' => sub {shift() / shift()}, + '*' => sub {shift() * shift()}, + '**' => sub {shift() ** shift()}, + ); + sub num { + my ($meth, $a, $b) = @{+shift}; + my $subr = $subr{$meth} + or die "Do not know how to ($meth) in symbolic"; + $a = $a->num if ref $a eq __PACKAGE__; + $b = $b->num if ref $b eq __PACKAGE__; + $subr->($a,$b); + } + +All the work of numeric conversion is done in %subr and num(). Of +course, %subr is not complete, it contains only operators used in the +example below. Here is the extra-credit question: why do we need an +explicit recursion in num()? (Answer is at the end of this section.) + +Use this module like this: + + require symbolic; + my $iter = new symbolic 2; # 16-gon + my $side = new symbolic 1; + my $cnt = $iter; + + while ($cnt) { + $cnt = $cnt - 1; # Mutator `--' not implemented + $side = (sqrt(1 + $side**2) - 1)/$side; + } + printf "%s=%f\n", $side, $side; + printf "pi=%f\n", $side*(2**($iter+2)); + +It prints (without so many line breaks) + + [/ [- [sqrt [+ 1 [** [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1] + [n 1]] 2]]] 1] + [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1] [n 1]]]=0.198912 + pi=3.182598 + +The above module is very primitive. It does not implement +mutator methods (C<++>, C<-=> and so on), does not do deep copying +(not required without mutators!), and implements only those arithmetic +operations which are used in the example. + +To implement most arithmetic operations is easy; one should just use +the tables of operations, and change the code which fills %subr to + + my %subr = ( 'n' => sub {$_[0]} ); + foreach my $op (split " ", $overload::ops{with_assign}) { + $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}"; + } + my @bins = qw(binary 3way_comparison num_comparison str_comparison); + foreach my $op (split " ", "@overload::ops{ @bins }") { + $subr{$op} = eval "sub {shift() $op shift()}"; + } + foreach my $op (split " ", "@overload::ops{qw(unary func)}") { + print "defining `$op'\n"; + $subr{$op} = eval "sub {$op shift()}"; + } + +Due to L<Calling Conventions for Mutators>, we do not need anything +special to make C<+=> and friends work, except filling C<+=> entry of +%subr, and defining a copy constructor (needed since Perl has no +way to know that the implementation of C<'+='> does not mutate +the argument, compare L<Copy Constructor>). + +To implement a copy constructor, add C<< '=' => \&cpy >> to C<use overload> +line, and code (this code assumes that mutators change things one level +deep only, so recursive copying is not needed): + + sub cpy { + my $self = shift; + bless [@$self], ref $self; + } + +To make C<++> and C<--> work, we need to implement actual mutators, +either directly, or in C<nomethod>. We continue to do things inside +C<nomethod>, thus add + + if ($meth eq '++' or $meth eq '--') { + @$obj = ($meth, (bless [@$obj]), 1); # Avoid circular reference + return $obj; + } + +after the first line of wrap(). This is not a most effective +implementation, one may consider + + sub inc { $_[0] = bless ['++', shift, 1]; } + +instead. + +As a final remark, note that one can fill %subr by + + my %subr = ( 'n' => sub {$_[0]} ); + foreach my $op (split " ", $overload::ops{with_assign}) { + $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}"; + } + my @bins = qw(binary 3way_comparison num_comparison str_comparison); + foreach my $op (split " ", "@overload::ops{ @bins }") { + $subr{$op} = eval "sub {shift() $op shift()}"; + } + foreach my $op (split " ", "@overload::ops{qw(unary func)}") { + $subr{$op} = eval "sub {$op shift()}"; + } + $subr{'++'} = $subr{'+'}; + $subr{'--'} = $subr{'-'}; + +This finishes implementation of a primitive symbolic calculator in +50 lines of Perl code. Since the numeric values of subexpressions +are not cached, the calculator is very slow. + +Here is the answer for the exercise: In the case of str(), we need no +explicit recursion since the overloaded C<.>-operator will fall back +to an existing overloaded operator C<"">. Overloaded arithmetic +operators I<do not> fall back to numeric conversion if C<fallback> is +not explicitly requested. Thus without an explicit recursion num() +would convert C<['+', $a, $b]> to C<$a + $b>, which would just rebuild +the argument of num(). + +If you wonder why defaults for conversion are different for str() and +num(), note how easy it was to write the symbolic calculator. This +simplicity is due to an appropriate choice of defaults. One extra +note: due to the explicit recursion num() is more fragile than sym(): +we need to explicitly check for the type of $a and $b. If components +$a and $b happen to be of some related type, this may lead to problems. + +=head2 I<Really> symbolic calculator + +One may wonder why we call the above calculator symbolic. The reason +is that the actual calculation of the value of expression is postponed +until the value is I<used>. + +To see it in action, add a method + + sub STORE { + my $obj = shift; + $#$obj = 1; + @$obj->[0,1] = ('=', shift); + } + +to the package C<symbolic>. After this change one can do + + my $a = new symbolic 3; + my $b = new symbolic 4; + my $c = sqrt($a**2 + $b**2); + +and the numeric value of $c becomes 5. However, after calling + + $a->STORE(12); $b->STORE(5); + +the numeric value of $c becomes 13. There is no doubt now that the module +symbolic provides a I<symbolic> calculator indeed. + +To hide the rough edges under the hood, provide a tie()d interface to the +package C<symbolic> (compare with L<Metaphor clash>). Add methods + + sub TIESCALAR { my $pack = shift; $pack->new(@_) } + sub FETCH { shift } + sub nop { } # Around a bug + +(the bug is described in L<"BUGS">). One can use this new interface as + + tie $a, 'symbolic', 3; + tie $b, 'symbolic', 4; + $a->nop; $b->nop; # Around a bug + + my $c = sqrt($a**2 + $b**2); + +Now numeric value of $c is 5. After C<$a = 12; $b = 5> the numeric value +of $c becomes 13. To insulate the user of the module add a method + + sub vars { my $p = shift; tie($_, $p), $_->nop foreach @_; } + +Now + + my ($a, $b); + symbolic->vars($a, $b); + my $c = sqrt($a**2 + $b**2); + + $a = 3; $b = 4; + printf "c5 %s=%f\n", $c, $c; + + $a = 12; $b = 5; + printf "c13 %s=%f\n", $c, $c; + +shows that the numeric value of $c follows changes to the values of $a +and $b. + +=head1 AUTHOR + +Ilya Zakharevich E<lt>F<ilya@math.mps.ohio-state.edu>E<gt>. + +=head1 DIAGNOSTICS + +When Perl is run with the B<-Do> switch or its equivalent, overloading +induces diagnostic messages. + +Using the C<m> command of Perl debugger (see L<perldebug>) one can +deduce which operations are overloaded (and which ancestor triggers +this overloading). Say, if C<eq> is overloaded, then the method C<(eq> +is shown by debugger. The method C<()> corresponds to the C<fallback> +key (in fact a presence of this method shows that this package has +overloading enabled, and it is what is used by the C<Overloaded> +function of module C<overload>). + +The module might issue the following warnings: + +=over 4 + +=item Odd number of arguments for overload::constant + +(W) The call to overload::constant contained an odd number of arguments. +The arguments should come in pairs. + +=item `%s' is not an overloadable type + +(W) You tried to overload a constant type the overload package is unaware of. + +=item `%s' is not a code reference + +(W) The second (fourth, sixth, ...) argument of overload::constant needs +to be a code reference. Either an anonymous subroutine, or a reference +to a subroutine. + +=back + +=head1 BUGS + +Because it is used for overloading, the per-package hash %OVERLOAD now +has a special meaning in Perl. The symbol table is filled with names +looking like line-noise. + +For the purpose of inheritance every overloaded package behaves as if +C<fallback> is present (possibly undefined). This may create +interesting effects if some package is not overloaded, but inherits +from two overloaded packages. + +Relation between overloading and tie()ing is broken. Overloading is +triggered or not basing on the I<previous> class of tie()d value. + +This happens because the presence of overloading is checked too early, +before any tie()d access is attempted. If the FETCH()ed class of the +tie()d value does not change, a simple workaround is to access the value +immediately after tie()ing, so that after this call the I<previous> class +coincides with the current one. + +B<Needed:> a way to fix this without a speed penalty. + +Barewords are not covered by overloaded string constants. + +This document is confusing. There are grammos and misleading language +used in places. It would seem a total rewrite is needed. + +=cut + diff --git a/Master/xemtex/perl/lib/re.pm b/Master/xemtex/perl/lib/re.pm new file mode 100644 index 00000000000..95e25407607 --- /dev/null +++ b/Master/xemtex/perl/lib/re.pm @@ -0,0 +1,134 @@ +package re; + +our $VERSION = 0.03; + +=head1 NAME + +re - Perl pragma to alter regular expression behaviour + +=head1 SYNOPSIS + + use re 'taint'; + ($x) = ($^X =~ /^(.*)$/s); # $x is tainted here + + $pat = '(?{ $foo = 1 })'; + use re 'eval'; + /foo${pat}bar/; # won't fail (when not under -T switch) + + { + no re 'taint'; # the default + ($x) = ($^X =~ /^(.*)$/s); # $x is not tainted here + + no re 'eval'; # the default + /foo${pat}bar/; # disallowed (with or without -T switch) + } + + use re 'debug'; # NOT lexically scoped (as others are) + /^(.*)$/s; # output debugging info during + # compile and run time + + use re 'debugcolor'; # same as 'debug', but with colored output + ... + +(We use $^X in these examples because it's tainted by default.) + +=head1 DESCRIPTION + +When C<use re 'taint'> is in effect, and a tainted string is the target +of a regex, the regex memories (or values returned by the m// operator +in list context) are tainted. This feature is useful when regex operations +on tainted data aren't meant to extract safe substrings, but to perform +other transformations. + +When C<use re 'eval'> is in effect, a regex is allowed to contain +C<(?{ ... })> zero-width assertions even if regular expression contains +variable interpolation. That is normally disallowed, since it is a +potential security risk. Note that this pragma is ignored when the regular +expression is obtained from tainted data, i.e. evaluation is always +disallowed with tainted regular expresssions. See L<perlre/(?{ code })>. + +For the purpose of this pragma, interpolation of precompiled regular +expressions (i.e., the result of C<qr//>) is I<not> considered variable +interpolation. Thus: + + /foo${pat}bar/ + +I<is> allowed if $pat is a precompiled regular expression, even +if $pat contains C<(?{ ... })> assertions. + +When C<use re 'debug'> is in effect, perl emits debugging messages when +compiling and using regular expressions. The output is the same as that +obtained by running a C<-DDEBUGGING>-enabled perl interpreter with the +B<-Dr> switch. It may be quite voluminous depending on the complexity +of the match. Using C<debugcolor> instead of C<debug> enables a +form of output that can be used to get a colorful display on terminals +that understand termcap color sequences. Set C<$ENV{PERL_RE_TC}> to a +comma-separated list of C<termcap> properties to use for highlighting +strings on/off, pre-point part on/off. +See L<perldebug/"Debugging regular expressions"> for additional info. + +The directive C<use re 'debug'> is I<not lexically scoped>, as the +other directives are. It has both compile-time and run-time effects. + +See L<perlmodlib/Pragmatic Modules>. + +=cut + +# N.B. File::Basename contains a literal for 'taint' as a fallback. If +# taint is changed here, File::Basename must be updated as well. +my %bitmask = ( +taint => 0x00100000, +eval => 0x00200000, +); + +sub setcolor { + eval { # Ignore errors + require Term::Cap; + + my $terminal = Tgetent Term::Cap ({OSPEED => 9600}); # Avoid warning. + my $props = $ENV{PERL_RE_TC} || 'md,me,so,se,us,ue'; + my @props = split /,/, $props; + my $colors = join "\t", map {$terminal->Tputs($_,1)} @props; + + $colors =~ s/\0//g; + $ENV{PERL_RE_COLORS} = $colors; + }; +} + +sub bits { + my $on = shift; + my $bits = 0; + unless (@_) { + require Carp; + Carp::carp("Useless use of \"re\" pragma"); + } + foreach my $s (@_){ + if ($s eq 'debug' or $s eq 'debugcolor') { + setcolor() if $s eq 'debugcolor'; + require XSLoader; + XSLoader::load('re'); + install() if $on; + uninstall() unless $on; + next; + } + if (exists $bitmask{$s}) { + $bits |= $bitmask{$s}; + } else { + require Carp; + Carp::carp("Unknown \"re\" subpragma '$s' (known ones are: @{[join(', ', map {qq('$_')} 'debug', 'debugcolor', sort keys %bitmask)]})"); + } + } + $bits; +} + +sub import { + shift; + $^H |= bits(1, @_); +} + +sub unimport { + shift; + $^H &= ~ bits(0, @_); +} + +1; diff --git a/Master/xemtex/perl/lib/strict.pm b/Master/xemtex/perl/lib/strict.pm new file mode 100644 index 00000000000..737cb18b1ad --- /dev/null +++ b/Master/xemtex/perl/lib/strict.pm @@ -0,0 +1,117 @@ +package strict; + +=head1 NAME + +strict - Perl pragma to restrict unsafe constructs + +=head1 SYNOPSIS + + use strict; + + use strict "vars"; + use strict "refs"; + use strict "subs"; + + use strict; + no strict "vars"; + +=head1 DESCRIPTION + +If no import list is supplied, all possible restrictions are assumed. +(This is the safest mode to operate in, but is sometimes too strict for +casual programming.) Currently, there are three possible things to be +strict about: "subs", "vars", and "refs". + +=over 6 + +=item C<strict refs> + +This generates a runtime error if you +use symbolic references (see L<perlref>). + + use strict 'refs'; + $ref = \$foo; + print $$ref; # ok + $ref = "foo"; + print $$ref; # runtime error; normally ok + $file = "STDOUT"; + print $file "Hi!"; # error; note: no comma after $file + +There is one exception to this rule: + + $bar = \&{'foo'}; + &$bar; + +is allowed so that C<goto &$AUTOLOAD> would not break under stricture. + + +=item C<strict vars> + +This generates a compile-time error if you access a variable that wasn't +declared via "our" or C<use vars>, +localized via C<my()>, or wasn't fully qualified. Because this is to avoid +variable suicide problems and subtle dynamic scoping issues, a merely +local() variable isn't good enough. See L<perlfunc/my> and +L<perlfunc/local>. + + use strict 'vars'; + $X::foo = 1; # ok, fully qualified + my $foo = 10; # ok, my() var + local $foo = 9; # blows up + + package Cinna; + our $bar; # Declares $bar in current package + $bar = 'HgS'; # ok, global declared via pragma + +The local() generated a compile-time error because you just touched a global +name without fully qualifying it. + +Because of their special use by sort(), the variables $a and $b are +exempted from this check. + +=item C<strict subs> + +This disables the poetry optimization, generating a compile-time error if +you try to use a bareword identifier that's not a subroutine, unless it +appears in curly braces or on the left hand side of the "=E<gt>" symbol. + + + use strict 'subs'; + $SIG{PIPE} = Plumber; # blows up + $SIG{PIPE} = "Plumber"; # just fine: bareword in curlies always ok + $SIG{PIPE} = \&Plumber; # preferred form + + + +=back + +See L<perlmodlib/Pragmatic Modules>. + + +=cut + +$strict::VERSION = "1.02"; + +my %bitmask = ( +refs => 0x00000002, +subs => 0x00000200, +vars => 0x00000400 +); + +sub bits { + my $bits = 0; + foreach my $s (@_){ $bits |= $bitmask{$s} || 0; }; + $bits; +} + +sub import { + shift; + $^H |= bits(@_ ? @_ : qw(refs subs vars)); +} + +sub unimport { + shift; + $^H &= ~ bits(@_ ? @_ : qw(refs subs vars)); +} + +1; diff --git a/Master/xemtex/perl/lib/subs.pm b/Master/xemtex/perl/lib/subs.pm new file mode 100644 index 00000000000..e5a9aa8827d --- /dev/null +++ b/Master/xemtex/perl/lib/subs.pm @@ -0,0 +1,40 @@ +package subs; + +our $VERSION = '1.00'; + +=head1 NAME + +subs - Perl pragma to predeclare sub names + +=head1 SYNOPSIS + + use subs qw(frob); + frob 3..10; + +=head1 DESCRIPTION + +This will predeclare all the subroutine whose names are +in the list, allowing you to use them without parentheses +even before they're declared. + +Unlike pragmas that affect the C<$^H> hints variable, the C<use vars> and +C<use subs> declarations are not BLOCK-scoped. They are thus effective +for the entire file in which they appear. You may not rescind such +declarations with C<no vars> or C<no subs>. + +See L<perlmodlib/Pragmatic Modules> and L<strict/strict subs>. + +=cut + +require 5.000; + +sub import { + my $callpack = caller; + my $pack = shift; + my @imports = @_; + foreach $sym (@imports) { + *{"${callpack}::$sym"} = \&{"${callpack}::$sym"}; + } +}; + +1; diff --git a/Master/xemtex/perl/lib/unicore/ArabLink.pl b/Master/xemtex/perl/lib/unicore/ArabLink.pl new file mode 100644 index 00000000000..f68a8af519a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/ArabLink.pl @@ -0,0 +1,49 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0621 U +0622 0625 R +0626 D +0627 R +0628 D +0629 R +062A 062E D +062F 0632 R +0633 063A D +0640 C +0641 0647 D +0648 R +0649 064A D +066E 066F D +0671 0673 R +0674 U +0675 0677 R +0678 0687 D +0688 0699 R +069A 06BF D +06C0 R +06C1 D +06C2 06CB R +06CC D +06CD R +06CE D +06CF R +06D0 06D1 D +06D2 06D3 R +06D5 R +06FA 06FC D +0710 R +0712 0714 D +0715 0719 R +071A 071D D +071E R +071F 0727 D +0728 R +0729 D +072A R +072B D +072C R +200D C +END diff --git a/Master/xemtex/perl/lib/unicore/ArabLnkGrp.pl b/Master/xemtex/perl/lib/unicore/ArabLnkGrp.pl new file mode 100644 index 00000000000..2e766d50a8f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/ArabLnkGrp.pl @@ -0,0 +1,98 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0621 <no shaping> +0622 0623 ALEF +0624 WAW +0625 ALEF +0626 YEH +0627 ALEF +0628 BEH +0629 TEH MARBUTA +062A 062B BEH +062C 062E HAH +062F 0630 DAL +0631 0632 REH +0633 0634 SEEN +0635 0636 SAD +0637 0638 TAH +0639 063A AIN +0640 <no shaping> +0641 FEH +0642 QAF +0643 KAF +0644 LAM +0645 MEEM +0646 NOON +0647 HEH +0648 WAW +0649 064A YEH +066E BEH +066F QAF +0671 0673 ALEF +0674 <no shaping> +0675 ALEF +0676 0677 WAW +0678 YEH +0679 0680 BEH +0681 0687 HAH +0688 0690 DAL +0691 0699 REH +069A 069C SEEN +069D 069E SAD +069F TAH +06A0 AIN +06A1 06A6 FEH +06A7 06A8 QAF +06A9 GAF +06AA SWASH KAF +06AB GAF +06AC 06AE KAF +06AF 06B4 GAF +06B5 06B8 LAM +06B9 06BD NOON +06BE KNOTTED HEH +06BF HAH +06C0 TEH MARBUTA +06C1 HEH GOAL +06C2 06C3 HAMZA ON HEH GOAL +06C4 06CB WAW +06CC YEH +06CD YEH WITH TAIL +06CE YEH +06CF WAW +06D0 06D1 YEH +06D2 06D3 YEH BARREE +06D5 TEH MARBUTA +06FA SEEN +06FB SAD +06FC AIN +0710 ALAPH +0712 BETH +0713 0714 GAMAL +0715 0716 DALATH RISH +0717 HE +0718 SYRIAC WAW +0719 ZAIN +071A HETH +071B 071C TETH +071D YUDH +071E YUDH HE +071F KAPH +0720 LAMADH +0721 MIM +0722 NUN +0723 SEMKATH +0724 FINAL SEMKATH +0725 E +0726 PE +0727 REVERSED PE +0728 SADHE +0729 QAPH +072A DALATH RISH +072B SHIN +072C TAW +200D <no shaping> +END diff --git a/Master/xemtex/perl/lib/unicore/Bidirectional.pl b/Master/xemtex/perl/lib/unicore/Bidirectional.pl new file mode 100644 index 00000000000..0fd1fff9321 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Bidirectional.pl @@ -0,0 +1,692 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0000 0008 BN +0009 S +000A B +000B S +000C WS +000D B +000E 001B BN +001C 001E B +001F S +0020 WS +0021 0022 ON +0023 0025 ET +0026 002A ON +002B ET +002C CS +002D ET +002E CS +002F ES +0030 0039 EN +003A CS +003B 0040 ON +0041 005A L +005B 0060 ON +0061 007A L +007B 007E ON +007F 0084 BN +0085 B +0086 009F BN +00A0 CS +00A1 ON +00A2 00A5 ET +00A6 00A9 ON +00AA L +00AB 00AF ON +00B0 00B1 ET +00B2 00B3 EN +00B4 ON +00B5 L +00B6 00B8 ON +00B9 EN +00BA L +00BB 00BF ON +00C0 00D6 L +00D7 ON +00D8 00F6 L +00F7 ON +00F8 0220 L +0222 0233 L +0250 02AD L +02B0 02B8 L +02B9 02BA ON +02BB 02C1 L +02C2 02CF ON +02D0 02D1 L +02D2 02DF ON +02E0 02E4 L +02E5 02ED ON +02EE L +0300 034F NSM +0360 036F NSM +0374 0375 ON +037A L +037E ON +0384 0385 ON +0386 L +0387 ON +0388 038A L +038C L +038E 03A1 L +03A3 03CE L +03D0 03F5 L +03F6 ON +0400 0482 L +0483 0486 NSM +0488 0489 NSM +048A 04CE L +04D0 04F5 L +04F8 04F9 L +0500 050F L +0531 0556 L +0559 055F L +0561 0587 L +0589 L +058A ON +0591 05A1 NSM +05A3 05B9 NSM +05BB 05BD NSM +05BE R +05BF NSM +05C0 R +05C1 05C2 NSM +05C3 R +05C4 NSM +05D0 05EA R +05F0 05F4 R +060C CS +061B AL +061F AL +0621 063A AL +0640 064A AL +064B 0655 NSM +0660 0669 AN +066A ET +066B 066C AN +066D 066F AL +0670 NSM +0671 06D5 AL +06D6 06DC NSM +06DD AL +06DE 06E4 NSM +06E5 06E6 AL +06E7 06E8 NSM +06E9 ON +06EA 06ED NSM +06F0 06F9 EN +06FA 06FE AL +0700 070D AL +070F BN +0710 AL +0711 NSM +0712 072C AL +0730 074A NSM +0780 07A5 AL +07A6 07B0 NSM +07B1 AL +0901 0902 NSM +0903 L +0905 0939 L +093C NSM +093D 0940 L +0941 0948 NSM +0949 094C L +094D NSM +0950 L +0951 0954 NSM +0958 0961 L +0962 0963 NSM +0964 0970 L +0981 NSM +0982 0983 L +0985 098C L +098F 0990 L +0993 09A8 L +09AA 09B0 L +09B2 L +09B6 09B9 L +09BC NSM +09BE 09C0 L +09C1 09C4 NSM +09C7 09C8 L +09CB 09CC L +09CD NSM +09D7 L +09DC 09DD L +09DF 09E1 L +09E2 09E3 NSM +09E6 09F1 L +09F2 09F3 ET +09F4 09FA L +0A02 NSM +0A05 0A0A L +0A0F 0A10 L +0A13 0A28 L +0A2A 0A30 L +0A32 0A33 L +0A35 0A36 L +0A38 0A39 L +0A3C NSM +0A3E 0A40 L +0A41 0A42 NSM +0A47 0A48 NSM +0A4B 0A4D NSM +0A59 0A5C L +0A5E L +0A66 0A6F L +0A70 0A71 NSM +0A72 0A74 L +0A81 0A82 NSM +0A83 L +0A85 0A8B L +0A8D L +0A8F 0A91 L +0A93 0AA8 L +0AAA 0AB0 L +0AB2 0AB3 L +0AB5 0AB9 L +0ABC NSM +0ABD 0AC0 L +0AC1 0AC5 NSM +0AC7 0AC8 NSM +0AC9 L +0ACB 0ACC L +0ACD NSM +0AD0 L +0AE0 L +0AE6 0AEF L +0B01 NSM +0B02 0B03 L +0B05 0B0C L +0B0F 0B10 L +0B13 0B28 L +0B2A 0B30 L +0B32 0B33 L +0B36 0B39 L +0B3C NSM +0B3D 0B3E L +0B3F NSM +0B40 L +0B41 0B43 NSM +0B47 0B48 L +0B4B 0B4C L +0B4D NSM +0B56 NSM +0B57 L +0B5C 0B5D L +0B5F 0B61 L +0B66 0B70 L +0B82 NSM +0B83 L +0B85 0B8A L +0B8E 0B90 L +0B92 0B95 L +0B99 0B9A L +0B9C L +0B9E 0B9F L +0BA3 0BA4 L +0BA8 0BAA L +0BAE 0BB5 L +0BB7 0BB9 L +0BBE 0BBF L +0BC0 NSM +0BC1 0BC2 L +0BC6 0BC8 L +0BCA 0BCC L +0BCD NSM +0BD7 L +0BE7 0BF2 L +0C01 0C03 L +0C05 0C0C L +0C0E 0C10 L +0C12 0C28 L +0C2A 0C33 L +0C35 0C39 L +0C3E 0C40 NSM +0C41 0C44 L +0C46 0C48 NSM +0C4A 0C4D NSM +0C55 0C56 NSM +0C60 0C61 L +0C66 0C6F L +0C82 0C83 L +0C85 0C8C L +0C8E 0C90 L +0C92 0CA8 L +0CAA 0CB3 L +0CB5 0CB9 L +0CBE L +0CBF NSM +0CC0 0CC4 L +0CC6 NSM +0CC7 0CC8 L +0CCA 0CCB L +0CCC 0CCD NSM +0CD5 0CD6 L +0CDE L +0CE0 0CE1 L +0CE6 0CEF L +0D02 0D03 L +0D05 0D0C L +0D0E 0D10 L +0D12 0D28 L +0D2A 0D39 L +0D3E 0D40 L +0D41 0D43 NSM +0D46 0D48 L +0D4A 0D4C L +0D4D NSM +0D57 L +0D60 0D61 L +0D66 0D6F L +0D82 0D83 L +0D85 0D96 L +0D9A 0DB1 L +0DB3 0DBB L +0DBD L +0DC0 0DC6 L +0DCA NSM +0DCF 0DD1 L +0DD2 0DD4 NSM +0DD6 NSM +0DD8 0DDF L +0DF2 0DF4 L +0E01 0E30 L +0E31 NSM +0E32 0E33 L +0E34 0E3A NSM +0E3F ET +0E40 0E46 L +0E47 0E4E NSM +0E4F 0E5B L +0E81 0E82 L +0E84 L +0E87 0E88 L +0E8A L +0E8D L +0E94 0E97 L +0E99 0E9F L +0EA1 0EA3 L +0EA5 L +0EA7 L +0EAA 0EAB L +0EAD 0EB0 L +0EB1 NSM +0EB2 0EB3 L +0EB4 0EB9 NSM +0EBB 0EBC NSM +0EBD L +0EC0 0EC4 L +0EC6 L +0EC8 0ECD NSM +0ED0 0ED9 L +0EDC 0EDD L +0F00 0F17 L +0F18 0F19 NSM +0F1A 0F34 L +0F35 NSM +0F36 L +0F37 NSM +0F38 L +0F39 NSM +0F3A 0F3D ON +0F3E 0F47 L +0F49 0F6A L +0F71 0F7E NSM +0F7F L +0F80 0F84 NSM +0F85 L +0F86 0F87 NSM +0F88 0F8B L +0F90 0F97 NSM +0F99 0FBC NSM +0FBE 0FC5 L +0FC6 NSM +0FC7 0FCC L +0FCF L +1000 1021 L +1023 1027 L +1029 102A L +102C L +102D 1030 NSM +1031 L +1032 NSM +1036 1037 NSM +1038 L +1039 NSM +1040 1057 L +1058 1059 NSM +10A0 10C5 L +10D0 10F8 L +10FB L +1100 1159 L +115F 11A2 L +11A8 11F9 L +1200 1206 L +1208 1246 L +1248 L +124A 124D L +1250 1256 L +1258 L +125A 125D L +1260 1286 L +1288 L +128A 128D L +1290 12AE L +12B0 L +12B2 12B5 L +12B8 12BE L +12C0 L +12C2 12C5 L +12C8 12CE L +12D0 12D6 L +12D8 12EE L +12F0 130E L +1310 L +1312 1315 L +1318 131E L +1320 1346 L +1348 135A L +1361 137C L +13A0 13F4 L +1401 1676 L +1680 WS +1681 169A L +169B 169C ON +16A0 16F0 L +1700 170C L +170E 1711 L +1712 1714 NSM +1720 1731 L +1732 1734 NSM +1735 1736 L +1740 1751 L +1752 1753 NSM +1760 176C L +176E 1770 L +1772 1773 NSM +1780 17B6 L +17B7 17BD NSM +17BE 17C5 L +17C6 NSM +17C7 17C8 L +17C9 17D3 NSM +17D4 17DA L +17DB ET +17DC L +17E0 17E9 L +1800 180A ON +180B 180D NSM +180E BN +1810 1819 L +1820 1877 L +1880 18A8 L +18A9 NSM +1E00 1E9B L +1EA0 1EF9 L +1F00 1F15 L +1F18 1F1D L +1F20 1F45 L +1F48 1F4D L +1F50 1F57 L +1F59 L +1F5B L +1F5D L +1F5F 1F7D L +1F80 1FB4 L +1FB6 1FBC L +1FBD ON +1FBE L +1FBF 1FC1 ON +1FC2 1FC4 L +1FC6 1FCC L +1FCD 1FCF ON +1FD0 1FD3 L +1FD6 1FDB L +1FDD 1FDF ON +1FE0 1FEC L +1FED 1FEF ON +1FF2 1FF4 L +1FF6 1FFC L +1FFD 1FFE ON +2000 200A WS +200B 200D BN +200E L +200F R +2010 2027 ON +2028 WS +2029 B +202A LRE +202B RLE +202C PDF +202D LRO +202E RLO +202F WS +2030 2034 ET +2035 2052 ON +2057 ON +205F WS +2060 2063 BN +206A 206F BN +2070 EN +2071 L +2074 2079 EN +207A 207B ET +207C 207E ON +207F L +2080 2089 EN +208A 208B ET +208C 208E ON +20A0 20B1 ET +20D0 20EA NSM +2100 2101 ON +2102 L +2103 2106 ON +2107 L +2108 2109 ON +210A 2113 L +2114 ON +2115 L +2116 2118 ON +2119 211D L +211E 2123 ON +2124 L +2125 ON +2126 L +2127 ON +2128 L +2129 ON +212A 212D L +212E ET +212F 2131 L +2132 ON +2133 2139 L +213A ON +213D 213F L +2140 2144 ON +2145 2149 L +214A 214B ON +2153 215F ON +2160 2183 L +2190 2211 ON +2212 2213 ET +2214 2335 ON +2336 237A L +237B 2394 ON +2395 L +2396 23CE ON +2400 2426 ON +2440 244A ON +2460 249B EN +249C 24E9 L +24EA EN +24EB 24FE ON +2500 2613 ON +2616 2617 ON +2619 267D ON +2680 2689 ON +2701 2704 ON +2706 2709 ON +270C 2727 ON +2729 274B ON +274D ON +274F 2752 ON +2756 ON +2758 275E ON +2761 2794 ON +2798 27AF ON +27B1 27BE ON +27D0 27EB ON +27F0 2AFF ON +2E80 2E99 ON +2E9B 2EF3 ON +2F00 2FD5 ON +2FF0 2FFB ON +3000 WS +3001 3004 ON +3005 3007 L +3008 3020 ON +3021 3029 L +302A 302F NSM +3030 ON +3031 3035 L +3036 3037 ON +3038 303C L +303D 303F ON +3041 3096 L +3099 309A NSM +309B 309C ON +309D 309F L +30A0 ON +30A1 30FA L +30FB ON +30FC 30FF L +3105 312C L +3131 318E L +3190 31B7 L +31F0 321C L +3220 3243 L +3251 325F ON +3260 327B L +327F 32B0 L +32B1 32BF ON +32C0 32CB L +32D0 32FE L +3300 3376 L +337B 33DD L +33E0 33FE L +A000 A48C L +A490 A4C6 ON +F900 FA2D L +FA30 FA6A L +FB00 FB06 L +FB13 FB17 L +FB1D R +FB1E NSM +FB1F FB28 R +FB29 ET +FB2A FB36 R +FB38 FB3C R +FB3E R +FB40 FB41 R +FB43 FB44 R +FB46 FB4F R +FB50 FBB1 AL +FBD3 FD3D AL +FD3E FD3F ON +FD50 FD8F AL +FD92 FDC7 AL +FDF0 FDFC AL +FE00 FE0F NSM +FE20 FE23 NSM +FE30 FE46 ON +FE49 FE4F ON +FE50 CS +FE51 ON +FE52 CS +FE54 ON +FE55 CS +FE56 FE5E ON +FE5F ET +FE60 FE61 ON +FE62 FE63 ET +FE64 FE66 ON +FE68 ON +FE69 FE6A ET +FE6B ON +FE70 FE74 AL +FE76 FEFC AL +FEFF BN +FF01 FF02 ON +FF03 FF05 ET +FF06 FF0A ON +FF0B ET +FF0C CS +FF0D ET +FF0E CS +FF0F ES +FF10 FF19 EN +FF1A CS +FF1B FF20 ON +FF21 FF3A L +FF3B FF40 ON +FF41 FF5A L +FF5B FF65 ON +FF66 FFBE L +FFC2 FFC7 L +FFCA FFCF L +FFD2 FFD7 L +FFDA FFDC L +FFE0 FFE1 ET +FFE2 FFE4 ON +FFE5 FFE6 ET +FFE8 FFEE ON +FFF9 FFFB BN +FFFC FFFD ON +10300 1031E L +10320 10323 L +10330 1034A L +10400 10425 L +10428 1044D L +1D000 1D0F5 L +1D100 1D126 L +1D12A 1D166 L +1D167 1D169 NSM +1D16A 1D172 L +1D173 1D17A BN +1D17B 1D182 NSM +1D183 1D184 L +1D185 1D18B NSM +1D18C 1D1A9 L +1D1AA 1D1AD NSM +1D1AE 1D1DD L +1D400 1D454 L +1D456 1D49C L +1D49E 1D49F L +1D4A2 L +1D4A5 1D4A6 L +1D4A9 1D4AC L +1D4AE 1D4B9 L +1D4BB L +1D4BD 1D4C0 L +1D4C2 1D4C3 L +1D4C5 1D505 L +1D507 1D50A L +1D50D 1D514 L +1D516 1D51C L +1D51E 1D539 L +1D53B 1D53E L +1D540 1D544 L +1D546 L +1D54A 1D550 L +1D552 1D6A3 L +1D6A8 1D7C9 L +1D7CE 1D7FF EN +2F800 2FA1D L +E0001 BN +E0020 E007F BN +END diff --git a/Master/xemtex/perl/lib/unicore/Blocks.pl b/Master/xemtex/perl/lib/unicore/Blocks.pl new file mode 100644 index 00000000000..07f2a325cab --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Blocks.pl @@ -0,0 +1,116 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0000 007F Basic Latin +0080 00FF Latin-1 Supplement +0100 017F Latin Extended-A +0180 024F Latin Extended-B +0250 02AF IPA Extensions +02B0 02FF Spacing Modifier Letters +0300 036F Combining Diacritical Marks +0370 03FF Greek and Coptic +0400 04FF Cyrillic +0500 052F Cyrillic Supplementary +0530 058F Armenian +0590 05FF Hebrew +0600 06FF Arabic +0700 074F Syriac +0780 07BF Thaana +0900 097F Devanagari +0980 09FF Bengali +0A00 0A7F Gurmukhi +0A80 0AFF Gujarati +0B00 0B7F Oriya +0B80 0BFF Tamil +0C00 0C7F Telugu +0C80 0CFF Kannada +0D00 0D7F Malayalam +0D80 0DFF Sinhala +0E00 0E7F Thai +0E80 0EFF Lao +0F00 0FFF Tibetan +1000 109F Myanmar +10A0 10FF Georgian +1100 11FF Hangul Jamo +1200 137F Ethiopic +13A0 13FF Cherokee +1400 167F Unified Canadian Aboriginal Syllabics +1680 169F Ogham +16A0 16FF Runic +1700 171F Tagalog +1720 173F Hanunoo +1740 175F Buhid +1760 177F Tagbanwa +1780 17FF Khmer +1800 18AF Mongolian +1E00 1EFF Latin Extended Additional +1F00 1FFF Greek Extended +2000 206F General Punctuation +2070 209F Superscripts and Subscripts +20A0 20CF Currency Symbols +20D0 20FF Combining Diacritical Marks for Symbols +2100 214F Letterlike Symbols +2150 218F Number Forms +2190 21FF Arrows +2200 22FF Mathematical Operators +2300 23FF Miscellaneous Technical +2400 243F Control Pictures +2440 245F Optical Character Recognition +2460 24FF Enclosed Alphanumerics +2500 257F Box Drawing +2580 259F Block Elements +25A0 25FF Geometric Shapes +2600 26FF Miscellaneous Symbols +2700 27BF Dingbats +27C0 27EF Miscellaneous Mathematical Symbols-A +27F0 27FF Supplemental Arrows-A +2800 28FF Braille Patterns +2900 297F Supplemental Arrows-B +2980 29FF Miscellaneous Mathematical Symbols-B +2A00 2AFF Supplemental Mathematical Operators +2E80 2EFF CJK Radicals Supplement +2F00 2FDF Kangxi Radicals +2FF0 2FFF Ideographic Description Characters +3000 303F CJK Symbols and Punctuation +3040 309F Hiragana +30A0 30FF Katakana +3100 312F Bopomofo +3130 318F Hangul Compatibility Jamo +3190 319F Kanbun +31A0 31BF Bopomofo Extended +31F0 31FF Katakana Phonetic Extensions +3200 32FF Enclosed CJK Letters and Months +3300 33FF CJK Compatibility +3400 4DBF CJK Unified Ideographs Extension A +4E00 9FFF CJK Unified Ideographs +A000 A48F Yi Syllables +A490 A4CF Yi Radicals +AC00 D7AF Hangul Syllables +D800 DB7F High Surrogates +DB80 DBFF High Private Use Surrogates +DC00 DFFF Low Surrogates +E000 F8FF Private Use Area +F900 FAFF CJK Compatibility Ideographs +FB00 FB4F Alphabetic Presentation Forms +FB50 FDFF Arabic Presentation Forms-A +FE00 FE0F Variation Selectors +FE20 FE2F Combining Half Marks +FE30 FE4F CJK Compatibility Forms +FE50 FE6F Small Form Variants +FE70 FEFF Arabic Presentation Forms-B +FF00 FFEF Halfwidth and Fullwidth Forms +FFF0 FFFF Specials +10300 1032F Old Italic +10330 1034F Gothic +10400 1044F Deseret +1D000 1D0FF Byzantine Musical Symbols +1D100 1D1FF Musical Symbols +1D400 1D7FF Mathematical Alphanumeric Symbols +20000 2A6DF CJK Unified Ideographs Extension B +2F800 2FA1F CJK Compatibility Ideographs Supplement +E0000 E007F Tags +F0000 FFFFF Supplementary Private Use Area-A +100000 10FFFF Supplementary Private Use Area-B +END diff --git a/Master/xemtex/perl/lib/unicore/Canonical.pl b/Master/xemtex/perl/lib/unicore/Canonical.pl new file mode 100644 index 00000000000..947fd2b9d5c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Canonical.pl @@ -0,0 +1,816 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +## +## Data in this file used by ../utf8_heavy.pl +## + +## Mapping from lc(canonical name) to filename in ./lib +%utf8::Canonical = ( + alphabetic => 'Alphabet', + + # InAlphabeticPresentationForms + alphabeticpresentationforms => 'InAlphab', + + arabic => 'Arabic', + + # InArabicPresentationFormsA + arabicpresentationformsa => 'InArabi3', + + # InArabicPresentationFormsB + arabicpresentationformsb => 'InArabi2', + + armenian => 'Armenian', + + # InArrows + arrows => 'InArrows', + + # AsciiHexDigit + asciihexdigit => 'AsciiHex', + + # InBasicLatin + basiclatin => 'InBasicL', + + bengali => 'Bengali', + + # BidiControl + bidicontrol => 'BidiCont', + + # InBlockElements + blockelements => 'InBlockE', + + bopomofo => 'Bopomofo', + + # InBopomofoExtended + bopomofoextended => 'InBopom2', + + # InBoxDrawing + boxdrawing => 'InBoxDra', + + # InBraillePatterns + braillepatterns => 'InBraill', + + buhid => 'Buhid', + + # InByzantineMusicalSymbols + byzantinemusicalsymbols => 'InByzant', + + # CanadianAboriginal + canadianaboriginal => 'Canadian', + + cherokee => 'Cherokee', + + # InCjkCompatibility + cjkcompatibility => 'InCjkCom', + + # InCjkCompatibilityForms + cjkcompatibilityforms => 'InCjkCo2', + + # InCjkCompatibilityIdeographs + cjkcompatibilityideographs => 'InCjkCo3', + + # InCjkCompatibilityIdeographsSupplement + cjkcompatibilityideographssupplement => 'InCjkCo4', + + # InCjkRadicalsSupplement + cjkradicalssupplement => 'InCjkRad', + + # InCjkSymbolsAndPunctuation + cjksymbolsandpunctuation => 'InCjkSym', + + # InCjkUnifiedIdeographs + cjkunifiedideographs => 'InCjkUni', + + # InCjkUnifiedIdeographsExtensionA + cjkunifiedideographsextensiona => 'InCjkUn3', + + # InCjkUnifiedIdeographsExtensionB + cjkunifiedideographsextensionb => 'InCjkUn2', + + # ClosePunctuation + closepunctuation => 'Pe', + + # InCombiningDiacriticalMarks + combiningdiacriticalmarks => 'InCombi2', + + # InCombiningDiacriticalMarksForSymbols + combiningdiacriticalmarksforsymbols => 'InCombi3', + + # InCombiningHalfMarks + combininghalfmarks => 'InCombin', + + common => 'Common', + + # ConnectorPunctuation + connectorpunctuation => 'Pc', + + control => 'Cc', + + # InControlPictures + controlpictures => 'InContro', + + # CurrencySymbol + currencysymbol => 'Sc', + + # InCurrencySymbols + currencysymbols => 'InCurren', + + cyrillic => 'Cyrillic', + + # InCyrillicSupplementary + cyrillicsupplementary => 'InCyril2', + + dash => 'Dash', + + # DashPunctuation + dashpunctuation => 'Pd', + + # DecimalNumber + decimalnumber => 'Nd', + + deprecated => 'Deprecat', + deseret => 'Deseret', + devanagari => 'Devanaga', + diacritic => 'Diacriti', + + # InDingbats + dingbats => 'InDingba', + + # InEnclosedAlphanumerics + enclosedalphanumerics => 'InEnclos', + + # InEnclosedCjkLettersAndMonths + enclosedcjklettersandmonths => 'InEnclo2', + + # EnclosingMark + enclosingmark => 'Me', + + ethiopic => 'Ethiopic', + extender => 'Extender', + + # FinalPunctuation + finalpunctuation => 'Pf', + + format => 'Cf', + + # InGeneralPunctuation + generalpunctuation => 'InGenera', + + # InGeometricShapes + geometricshapes => 'InGeomet', + + georgian => 'Georgian', + gothic => 'Gothic', + + # GraphemeLink + graphemelink => 'Grapheme', + + greek => 'Greek', + + # InGreekAndCoptic + greekandcoptic => 'InGreekA', + + # InGreekExtended + greekextended => 'InGreekE', + + gujarati => 'Gujarati', + gurmukhi => 'Gurmukhi', + + # InHalfwidthAndFullwidthForms + halfwidthandfullwidthforms => 'InHalfwi', + + han => 'Han', + hangul => 'Hangul', + + # InHangulCompatibilityJamo + hangulcompatibilityjamo => 'InHangu3', + + # InHangulJamo + hanguljamo => 'InHangul', + + # InHangulSyllables + hangulsyllables => 'InHangu2', + + hanunoo => 'Hanunoo', + hebrew => 'Hebrew', + + # HexDigit + hexdigit => 'HexDigit', + + # InHighPrivateUseSurrogates + highprivateusesurrogates => 'InHighPr', + + # InHighSurrogates + highsurrogates => 'InHighSu', + + hiragana => 'Hiragana', + hyphen => 'Hyphen', + + # IdContinue + idcontinue => 'IdContin', + + ideographic => 'Ideograp', + + # InIdeographicDescriptionCharacters + ideographicdescriptioncharacters => 'InIdeogr', + + # IdsBinaryOperator + idsbinaryoperator => 'IdsBinar', + + # IdStart + idstart => 'IdStart', + + # IdsTrinaryOperator + idstrinaryoperator => 'IdsTrina', + + # InAlphabeticPresentationForms + inalphabeticpresentationforms => 'InAlphab', + + # InArabic + inarabic => 'InArabic', + + # InArabicPresentationFormsA + inarabicpresentationformsa => 'InArabi3', + + # InArabicPresentationFormsB + inarabicpresentationformsb => 'InArabi2', + + # InArmenian + inarmenian => 'InArmeni', + + # InArrows + inarrows => 'InArrows', + + # InBasicLatin + inbasiclatin => 'InBasicL', + + # InBengali + inbengali => 'InBengal', + + # InBlockElements + inblockelements => 'InBlockE', + + # InBopomofo + inbopomofo => 'InBopomo', + + # InBopomofoExtended + inbopomofoextended => 'InBopom2', + + # InBoxDrawing + inboxdrawing => 'InBoxDra', + + # InBraillePatterns + inbraillepatterns => 'InBraill', + + # InBuhid + inbuhid => 'InBuhid', + + # InByzantineMusicalSymbols + inbyzantinemusicalsymbols => 'InByzant', + + # InCherokee + incherokee => 'InCherok', + + # InCjkCompatibility + incjkcompatibility => 'InCjkCom', + + # InCjkCompatibilityForms + incjkcompatibilityforms => 'InCjkCo2', + + # InCjkCompatibilityIdeographs + incjkcompatibilityideographs => 'InCjkCo3', + + # InCjkCompatibilityIdeographsSupplement + incjkcompatibilityideographssupplement => 'InCjkCo4', + + # InCjkRadicalsSupplement + incjkradicalssupplement => 'InCjkRad', + + # InCjkSymbolsAndPunctuation + incjksymbolsandpunctuation => 'InCjkSym', + + # InCjkUnifiedIdeographs + incjkunifiedideographs => 'InCjkUni', + + # InCjkUnifiedIdeographsExtensionA + incjkunifiedideographsextensiona => 'InCjkUn3', + + # InCjkUnifiedIdeographsExtensionB + incjkunifiedideographsextensionb => 'InCjkUn2', + + # InCombiningDiacriticalMarks + incombiningdiacriticalmarks => 'InCombi2', + + # InCombiningDiacriticalMarksForSymbols + incombiningdiacriticalmarksforsymbols => 'InCombi3', + + # InCombiningHalfMarks + incombininghalfmarks => 'InCombin', + + # InControlPictures + incontrolpictures => 'InContro', + + # InCurrencySymbols + incurrencysymbols => 'InCurren', + + # InCyrillic + incyrillic => 'InCyrill', + + # InCyrillicSupplementary + incyrillicsupplementary => 'InCyril2', + + # InDeseret + indeseret => 'InDesere', + + # InDevanagari + indevanagari => 'InDevana', + + # InDingbats + indingbats => 'InDingba', + + # InEnclosedAlphanumerics + inenclosedalphanumerics => 'InEnclos', + + # InEnclosedCjkLettersAndMonths + inenclosedcjklettersandmonths => 'InEnclo2', + + # InEthiopic + inethiopic => 'InEthiop', + + # InGeneralPunctuation + ingeneralpunctuation => 'InGenera', + + # InGeometricShapes + ingeometricshapes => 'InGeomet', + + # InGeorgian + ingeorgian => 'InGeorgi', + + # InGothic + ingothic => 'InGothic', + + # InGreekAndCoptic + ingreekandcoptic => 'InGreekA', + + # InGreekExtended + ingreekextended => 'InGreekE', + + # InGujarati + ingujarati => 'InGujara', + + # InGurmukhi + ingurmukhi => 'InGurmuk', + + # InHalfwidthAndFullwidthForms + inhalfwidthandfullwidthforms => 'InHalfwi', + + # InHangulCompatibilityJamo + inhangulcompatibilityjamo => 'InHangu3', + + # InHangulJamo + inhanguljamo => 'InHangul', + + # InHangulSyllables + inhangulsyllables => 'InHangu2', + + # InHanunoo + inhanunoo => 'InHanuno', + + # InHebrew + inhebrew => 'InHebrew', + + inherited => 'Inherite', + + # InHighPrivateUseSurrogates + inhighprivateusesurrogates => 'InHighPr', + + # InHighSurrogates + inhighsurrogates => 'InHighSu', + + # InHiragana + inhiragana => 'InHiraga', + + # InIdeographicDescriptionCharacters + inideographicdescriptioncharacters => 'InIdeogr', + + # InIpaExtensions + inipaextensions => 'InIpaExt', + + # InitialPunctuation + initialpunctuation => 'Pi', + + # InKanbun + inkanbun => 'InKanbun', + + # InKangxiRadicals + inkangxiradicals => 'InKangxi', + + # InKannada + inkannada => 'InKannad', + + # InKatakana + inkatakana => 'InKataka', + + # InKatakanaPhoneticExtensions + inkatakanaphoneticextensions => 'InKatak2', + + # InKhmer + inkhmer => 'InKhmer', + + # InLao + inlao => 'InLao', + + # InLatin1Supplement + inlatin1supplement => 'InLatin1', + + # InLatinExtendedA + inlatinextendeda => 'InLatin2', + + # InLatinExtendedAdditional + inlatinextendedadditional => 'InLatin3', + + # InLatinExtendedB + inlatinextendedb => 'InLatinE', + + # InLetterlikeSymbols + inletterlikesymbols => 'InLetter', + + # InLowSurrogates + inlowsurrogates => 'InLowSur', + + # InMalayalam + inmalayalam => 'InMalaya', + + # InMathematicalAlphanumericSymbols + inmathematicalalphanumericsymbols => 'InMathe2', + + # InMathematicalOperators + inmathematicaloperators => 'InMathem', + + # InMiscellaneousMathematicalSymbolsA + inmiscellaneousmathematicalsymbolsa => 'InMisce3', + + # InMiscellaneousMathematicalSymbolsB + inmiscellaneousmathematicalsymbolsb => 'InMisce4', + + # InMiscellaneousSymbols + inmiscellaneoussymbols => 'InMiscel', + + # InMiscellaneousTechnical + inmiscellaneoustechnical => 'InMisce2', + + # InMongolian + inmongolian => 'InMongol', + + # InMusicalSymbols + inmusicalsymbols => 'InMusica', + + # InMyanmar + inmyanmar => 'InMyanma', + + # InNumberForms + innumberforms => 'InNumber', + + # InOgham + inogham => 'InOgham', + + # InOldItalic + inolditalic => 'InOldIta', + + # InOpticalCharacterRecognition + inopticalcharacterrecognition => 'InOptica', + + # InOriya + inoriya => 'InOriya', + + # InPrivateUseArea + inprivateusearea => 'InPrivat', + + # InRunic + inrunic => 'InRunic', + + # InSinhala + insinhala => 'InSinhal', + + # InSmallFormVariants + insmallformvariants => 'InSmallF', + + # InSpacingModifierLetters + inspacingmodifierletters => 'InSpacin', + + # InSpecials + inspecials => 'InSpecia', + + # InSuperscriptsAndSubscripts + insuperscriptsandsubscripts => 'InSupers', + + # InSupplementalArrowsA + insupplementalarrowsa => 'InSuppl2', + + # InSupplementalArrowsB + insupplementalarrowsb => 'InSupple', + + # InSupplementalMathematicalOperators + insupplementalmathematicaloperators => 'InSuppl5', + + # InSupplementaryPrivateUseAreaA + insupplementaryprivateuseareaa => 'InSuppl3', + + # InSupplementaryPrivateUseAreaB + insupplementaryprivateuseareab => 'InSuppl4', + + # InSyriac + insyriac => 'InSyriac', + + # InTagalog + intagalog => 'InTagalo', + + # InTagbanwa + intagbanwa => 'InTagban', + + # InTags + intags => 'InTags', + + # InTamil + intamil => 'InTamil', + + # InTelugu + intelugu => 'InTelugu', + + # InThaana + inthaana => 'InThaana', + + # InThai + inthai => 'InThai', + + # InTibetan + intibetan => 'InTibeta', + + # InUnifiedCanadianAboriginalSyllabics + inunifiedcanadianaboriginalsyllabics => 'InUnifie', + + # InVariationSelectors + invariationselectors => 'InVariat', + + # InYiRadicals + inyiradicals => 'InYiRadi', + + # InYiSyllables + inyisyllables => 'InYiSyll', + + # InIpaExtensions + ipaextensions => 'InIpaExt', + + # JoinControl + joincontrol => 'JoinCont', + + # InKanbun + kanbun => 'InKanbun', + + # InKangxiRadicals + kangxiradicals => 'InKangxi', + + kannada => 'Kannada', + katakana => 'Katakana', + + # InKatakanaPhoneticExtensions + katakanaphoneticextensions => 'InKatak2', + + khmer => 'Khmer', + lao => 'Lao', + latin => 'Latin', + + # InLatin1Supplement + latin1supplement => 'InLatin1', + + # InLatinExtendedA + latinextendeda => 'InLatin2', + + # InLatinExtendedAdditional + latinextendedadditional => 'InLatin3', + + # InLatinExtendedB + latinextendedb => 'InLatinE', + + letter => 'L', + + # InLetterlikeSymbols + letterlikesymbols => 'InLetter', + + # LetterNumber + letternumber => 'Nl', + + # LineSeparator + lineseparator => 'Zl', + + # LogicalOrderException + logicalorderexception => 'LogicalO', + + lowercase => 'Lowercas', + + # LowercaseLetter + lowercaseletter => 'Ll', + + # InLowSurrogates + lowsurrogates => 'InLowSur', + + malayalam => 'Malayala', + mark => 'M', + math => 'Math', + + # InMathematicalAlphanumericSymbols + mathematicalalphanumericsymbols => 'InMathe2', + + # InMathematicalOperators + mathematicaloperators => 'InMathem', + + # MathSymbol + mathsymbol => 'Sm', + + # InMiscellaneousMathematicalSymbolsA + miscellaneousmathematicalsymbolsa => 'InMisce3', + + # InMiscellaneousMathematicalSymbolsB + miscellaneousmathematicalsymbolsb => 'InMisce4', + + # InMiscellaneousSymbols + miscellaneoussymbols => 'InMiscel', + + # InMiscellaneousTechnical + miscellaneoustechnical => 'InMisce2', + + # ModifierLetter + modifierletter => 'Lm', + + # ModifierSymbol + modifiersymbol => 'Sk', + + mongolian => 'Mongolia', + + # InMusicalSymbols + musicalsymbols => 'InMusica', + + myanmar => 'Myanmar', + + # NoncharacterCodePoint + noncharactercodepoint => 'Nonchara', + + # NonSpacingMark + nonspacingmark => 'Mn', + + number => 'N', + + # InNumberForms + numberforms => 'InNumber', + + ogham => 'Ogham', + + # OldItalic + olditalic => 'OldItali', + + # OpenPunctuation + openpunctuation => 'Ps', + + # InOpticalCharacterRecognition + opticalcharacterrecognition => 'InOptica', + + oriya => 'Oriya', + other => 'C', + + # OtherAlphabetic + otheralphabetic => 'OtherAlp', + + # OtherDefaultIgnorableCodePoint + otherdefaultignorablecodepoint => 'OtherDef', + + # OtherGraphemeExtend + othergraphemeextend => 'OtherGra', + + # OtherLetter + otherletter => 'Lo', + + # OtherLowercase + otherlowercase => 'OtherLow', + + # OtherMath + othermath => 'OtherMat', + + # OtherNumber + othernumber => 'No', + + # OtherPunctuation + otherpunctuation => 'Po', + + # OtherSymbol + othersymbol => 'So', + + # OtherUppercase + otheruppercase => 'OtherUpp', + + # ParagraphSeparator + paragraphseparator => 'Zp', + + # PrivateUse + privateuse => 'Co', + + # InPrivateUseArea + privateusearea => 'InPrivat', + + punctuation => 'P', + + # QuotationMark + quotationmark => 'Quotatio', + + radical => 'Radical', + runic => 'Runic', + separator => 'Z', + sinhala => 'Sinhala', + + # InSmallFormVariants + smallformvariants => 'InSmallF', + + # SoftDotted + softdotted => 'SoftDott', + + # SpaceSeparator + spaceseparator => 'Zs', + + # SpacingMark + spacingmark => 'Mc', + + # InSpacingModifierLetters + spacingmodifierletters => 'InSpacin', + + # InSpecials + specials => 'InSpecia', + + # InSuperscriptsAndSubscripts + superscriptsandsubscripts => 'InSupers', + + # InSupplementalArrowsA + supplementalarrowsa => 'InSuppl2', + + # InSupplementalArrowsB + supplementalarrowsb => 'InSupple', + + # InSupplementalMathematicalOperators + supplementalmathematicaloperators => 'InSuppl5', + + # InSupplementaryPrivateUseAreaA + supplementaryprivateuseareaa => 'InSuppl3', + + # InSupplementaryPrivateUseAreaB + supplementaryprivateuseareab => 'InSuppl4', + + surrogate => 'Cs', + symbol => 'S', + syriac => 'Syriac', + tagalog => 'Tagalog', + tagbanwa => 'Tagbanwa', + + # InTags + tags => 'InTags', + + tamil => 'Tamil', + telugu => 'Telugu', + + # TerminalPunctuation + terminalpunctuation => 'Terminal', + + thaana => 'Thaana', + thai => 'Thai', + tibetan => 'Tibetan', + + # TitlecaseLetter + titlecaseletter => 'Lt', + + unassigned => 'Cn', + + # InUnifiedCanadianAboriginalSyllabics + unifiedcanadianaboriginalsyllabics => 'InUnifie', + + # UnifiedIdeograph + unifiedideograph => 'UnifiedI', + + uppercase => 'Uppercas', + + # UppercaseLetter + uppercaseletter => 'Lu', + + # InVariationSelectors + variationselectors => 'InVariat', + + # WhiteSpace + whitespace => 'WhiteSpa', + + yi => 'Yi', + + # InYiRadicals + yiradicals => 'InYiRadi', + + # InYiSyllables + yisyllables => 'InYiSyll', + +); +1 diff --git a/Master/xemtex/perl/lib/unicore/Category.pl b/Master/xemtex/perl/lib/unicore/Category.pl new file mode 100644 index 00000000000..dba6ad9afc3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Category.pl @@ -0,0 +1,1732 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0000 001F Cc +0020 Zs +0021 0023 Po +0024 Sc +0025 0027 Po +0028 Ps +0029 Pe +002A Po +002B Sm +002C Po +002D Pd +002E 002F Po +0030 0039 Nd +003A 003B Po +003C 003E Sm +003F 0040 Po +0041 005A Lu +005B Ps +005C Po +005D Pe +005E Sk +005F Pc +0060 Sk +0061 007A Ll +007B Ps +007C Sm +007D Pe +007E Sm +007F 009F Cc +00A0 Zs +00A1 Po +00A2 00A5 Sc +00A6 00A7 So +00A8 Sk +00A9 So +00AA Ll +00AB Pi +00AC Sm +00AD Pd +00AE So +00AF Sk +00B0 So +00B1 Sm +00B2 00B3 No +00B4 Sk +00B5 Ll +00B6 So +00B7 Po +00B8 Sk +00B9 No +00BA Ll +00BB Pf +00BC 00BE No +00BF Po +00C0 00D6 Lu +00D7 Sm +00D8 00DE Lu +00DF 00F6 Ll +00F7 Sm +00F8 00FF Ll +0100 Lu +0101 Ll +0102 Lu +0103 Ll +0104 Lu +0105 Ll +0106 Lu +0107 Ll +0108 Lu +0109 Ll +010A Lu +010B Ll +010C Lu +010D Ll +010E Lu +010F Ll +0110 Lu +0111 Ll +0112 Lu +0113 Ll +0114 Lu +0115 Ll +0116 Lu +0117 Ll +0118 Lu +0119 Ll +011A Lu +011B Ll +011C Lu +011D Ll +011E Lu +011F Ll +0120 Lu +0121 Ll +0122 Lu +0123 Ll +0124 Lu +0125 Ll +0126 Lu +0127 Ll +0128 Lu +0129 Ll +012A Lu +012B Ll +012C Lu +012D Ll +012E Lu +012F Ll +0130 Lu +0131 Ll +0132 Lu +0133 Ll +0134 Lu +0135 Ll +0136 Lu +0137 0138 Ll +0139 Lu +013A Ll +013B Lu +013C Ll +013D Lu +013E Ll +013F Lu +0140 Ll +0141 Lu +0142 Ll +0143 Lu +0144 Ll +0145 Lu +0146 Ll +0147 Lu +0148 0149 Ll +014A Lu +014B Ll +014C Lu +014D Ll +014E Lu +014F Ll +0150 Lu +0151 Ll +0152 Lu +0153 Ll +0154 Lu +0155 Ll +0156 Lu +0157 Ll +0158 Lu +0159 Ll +015A Lu +015B Ll +015C Lu +015D Ll +015E Lu +015F Ll +0160 Lu +0161 Ll +0162 Lu +0163 Ll +0164 Lu +0165 Ll +0166 Lu +0167 Ll +0168 Lu +0169 Ll +016A Lu +016B Ll +016C Lu +016D Ll +016E Lu +016F Ll +0170 Lu +0171 Ll +0172 Lu +0173 Ll +0174 Lu +0175 Ll +0176 Lu +0177 Ll +0178 0179 Lu +017A Ll +017B Lu +017C Ll +017D Lu +017E 0180 Ll +0181 0182 Lu +0183 Ll +0184 Lu +0185 Ll +0186 0187 Lu +0188 Ll +0189 018B Lu +018C 018D Ll +018E 0191 Lu +0192 Ll +0193 0194 Lu +0195 Ll +0196 0198 Lu +0199 019B Ll +019C 019D Lu +019E Ll +019F 01A0 Lu +01A1 Ll +01A2 Lu +01A3 Ll +01A4 Lu +01A5 Ll +01A6 01A7 Lu +01A8 Ll +01A9 Lu +01AA 01AB Ll +01AC Lu +01AD Ll +01AE 01AF Lu +01B0 Ll +01B1 01B3 Lu +01B4 Ll +01B5 Lu +01B6 Ll +01B7 01B8 Lu +01B9 01BA Ll +01BB Lo +01BC Lu +01BD 01BF Ll +01C0 01C3 Lo +01C4 Lu +01C5 Lt +01C6 Ll +01C7 Lu +01C8 Lt +01C9 Ll +01CA Lu +01CB Lt +01CC Ll +01CD Lu +01CE Ll +01CF Lu +01D0 Ll +01D1 Lu +01D2 Ll +01D3 Lu +01D4 Ll +01D5 Lu +01D6 Ll +01D7 Lu +01D8 Ll +01D9 Lu +01DA Ll +01DB Lu +01DC 01DD Ll +01DE Lu +01DF Ll +01E0 Lu +01E1 Ll +01E2 Lu +01E3 Ll +01E4 Lu +01E5 Ll +01E6 Lu +01E7 Ll +01E8 Lu +01E9 Ll +01EA Lu +01EB Ll +01EC Lu +01ED Ll +01EE Lu +01EF 01F0 Ll +01F1 Lu +01F2 Lt +01F3 Ll +01F4 Lu +01F5 Ll +01F6 01F8 Lu +01F9 Ll +01FA Lu +01FB Ll +01FC Lu +01FD Ll +01FE Lu +01FF Ll +0200 Lu +0201 Ll +0202 Lu +0203 Ll +0204 Lu +0205 Ll +0206 Lu +0207 Ll +0208 Lu +0209 Ll +020A Lu +020B Ll +020C Lu +020D Ll +020E Lu +020F Ll +0210 Lu +0211 Ll +0212 Lu +0213 Ll +0214 Lu +0215 Ll +0216 Lu +0217 Ll +0218 Lu +0219 Ll +021A Lu +021B Ll +021C Lu +021D Ll +021E Lu +021F Ll +0220 Lu +0222 Lu +0223 Ll +0224 Lu +0225 Ll +0226 Lu +0227 Ll +0228 Lu +0229 Ll +022A Lu +022B Ll +022C Lu +022D Ll +022E Lu +022F Ll +0230 Lu +0231 Ll +0232 Lu +0233 Ll +0250 02AD Ll +02B0 02B8 Lm +02B9 02BA Sk +02BB 02C1 Lm +02C2 02CF Sk +02D0 02D1 Lm +02D2 02DF Sk +02E0 02E4 Lm +02E5 02ED Sk +02EE Lm +0300 034F Mn +0360 036F Mn +0374 0375 Sk +037A Lm +037E Po +0384 0385 Sk +0386 Lu +0387 Po +0388 038A Lu +038C Lu +038E 038F Lu +0390 Ll +0391 03A1 Lu +03A3 03AB Lu +03AC 03CE Ll +03D0 03D1 Ll +03D2 03D4 Lu +03D5 03D7 Ll +03D8 Lu +03D9 Ll +03DA Lu +03DB Ll +03DC Lu +03DD Ll +03DE Lu +03DF Ll +03E0 Lu +03E1 Ll +03E2 Lu +03E3 Ll +03E4 Lu +03E5 Ll +03E6 Lu +03E7 Ll +03E8 Lu +03E9 Ll +03EA Lu +03EB Ll +03EC Lu +03ED Ll +03EE Lu +03EF 03F3 Ll +03F4 Lu +03F5 Ll +03F6 Sm +0400 042F Lu +0430 045F Ll +0460 Lu +0461 Ll +0462 Lu +0463 Ll +0464 Lu +0465 Ll +0466 Lu +0467 Ll +0468 Lu +0469 Ll +046A Lu +046B Ll +046C Lu +046D Ll +046E Lu +046F Ll +0470 Lu +0471 Ll +0472 Lu +0473 Ll +0474 Lu +0475 Ll +0476 Lu +0477 Ll +0478 Lu +0479 Ll +047A Lu +047B Ll +047C Lu +047D Ll +047E Lu +047F Ll +0480 Lu +0481 Ll +0482 So +0483 0486 Mn +0488 0489 Me +048A Lu +048B Ll +048C Lu +048D Ll +048E Lu +048F Ll +0490 Lu +0491 Ll +0492 Lu +0493 Ll +0494 Lu +0495 Ll +0496 Lu +0497 Ll +0498 Lu +0499 Ll +049A Lu +049B Ll +049C Lu +049D Ll +049E Lu +049F Ll +04A0 Lu +04A1 Ll +04A2 Lu +04A3 Ll +04A4 Lu +04A5 Ll +04A6 Lu +04A7 Ll +04A8 Lu +04A9 Ll +04AA Lu +04AB Ll +04AC Lu +04AD Ll +04AE Lu +04AF Ll +04B0 Lu +04B1 Ll +04B2 Lu +04B3 Ll +04B4 Lu +04B5 Ll +04B6 Lu +04B7 Ll +04B8 Lu +04B9 Ll +04BA Lu +04BB Ll +04BC Lu +04BD Ll +04BE Lu +04BF Ll +04C0 04C1 Lu +04C2 Ll +04C3 Lu +04C4 Ll +04C5 Lu +04C6 Ll +04C7 Lu +04C8 Ll +04C9 Lu +04CA Ll +04CB Lu +04CC Ll +04CD Lu +04CE Ll +04D0 Lu +04D1 Ll +04D2 Lu +04D3 Ll +04D4 Lu +04D5 Ll +04D6 Lu +04D7 Ll +04D8 Lu +04D9 Ll +04DA Lu +04DB Ll +04DC Lu +04DD Ll +04DE Lu +04DF Ll +04E0 Lu +04E1 Ll +04E2 Lu +04E3 Ll +04E4 Lu +04E5 Ll +04E6 Lu +04E7 Ll +04E8 Lu +04E9 Ll +04EA Lu +04EB Ll +04EC Lu +04ED Ll +04EE Lu +04EF Ll +04F0 Lu +04F1 Ll +04F2 Lu +04F3 Ll +04F4 Lu +04F5 Ll +04F8 Lu +04F9 Ll +0500 Lu +0501 Ll +0502 Lu +0503 Ll +0504 Lu +0505 Ll +0506 Lu +0507 Ll +0508 Lu +0509 Ll +050A Lu +050B Ll +050C Lu +050D Ll +050E Lu +050F Ll +0531 0556 Lu +0559 Lm +055A 055F Po +0561 0587 Ll +0589 Po +058A Pd +0591 05A1 Mn +05A3 05B9 Mn +05BB 05BD Mn +05BE Po +05BF Mn +05C0 Po +05C1 05C2 Mn +05C3 Po +05C4 Mn +05D0 05EA Lo +05F0 05F2 Lo +05F3 05F4 Po +060C Po +061B Po +061F Po +0621 063A Lo +0640 Lm +0641 064A Lo +064B 0655 Mn +0660 0669 Nd +066A 066D Po +066E 066F Lo +0670 Mn +0671 06D3 Lo +06D4 Po +06D5 Lo +06D6 06DC Mn +06DD Cf +06DE Me +06DF 06E4 Mn +06E5 06E6 Lm +06E7 06E8 Mn +06E9 So +06EA 06ED Mn +06F0 06F9 Nd +06FA 06FC Lo +06FD 06FE So +0700 070D Po +070F Cf +0710 Lo +0711 Mn +0712 072C Lo +0730 074A Mn +0780 07A5 Lo +07A6 07B0 Mn +07B1 Lo +0901 0902 Mn +0903 Mc +0905 0939 Lo +093C Mn +093D Lo +093E 0940 Mc +0941 0948 Mn +0949 094C Mc +094D Mn +0950 Lo +0951 0954 Mn +0958 0961 Lo +0962 0963 Mn +0964 0965 Po +0966 096F Nd +0970 Po +0981 Mn +0982 0983 Mc +0985 098C Lo +098F 0990 Lo +0993 09A8 Lo +09AA 09B0 Lo +09B2 Lo +09B6 09B9 Lo +09BC Mn +09BE 09C0 Mc +09C1 09C4 Mn +09C7 09C8 Mc +09CB 09CC Mc +09CD Mn +09D7 Mc +09DC 09DD Lo +09DF 09E1 Lo +09E2 09E3 Mn +09E6 09EF Nd +09F0 09F1 Lo +09F2 09F3 Sc +09F4 09F9 No +09FA So +0A02 Mn +0A05 0A0A Lo +0A0F 0A10 Lo +0A13 0A28 Lo +0A2A 0A30 Lo +0A32 0A33 Lo +0A35 0A36 Lo +0A38 0A39 Lo +0A3C Mn +0A3E 0A40 Mc +0A41 0A42 Mn +0A47 0A48 Mn +0A4B 0A4D Mn +0A59 0A5C Lo +0A5E Lo +0A66 0A6F Nd +0A70 0A71 Mn +0A72 0A74 Lo +0A81 0A82 Mn +0A83 Mc +0A85 0A8B Lo +0A8D Lo +0A8F 0A91 Lo +0A93 0AA8 Lo +0AAA 0AB0 Lo +0AB2 0AB3 Lo +0AB5 0AB9 Lo +0ABC Mn +0ABD Lo +0ABE 0AC0 Mc +0AC1 0AC5 Mn +0AC7 0AC8 Mn +0AC9 Mc +0ACB 0ACC Mc +0ACD Mn +0AD0 Lo +0AE0 Lo +0AE6 0AEF Nd +0B01 Mn +0B02 0B03 Mc +0B05 0B0C Lo +0B0F 0B10 Lo +0B13 0B28 Lo +0B2A 0B30 Lo +0B32 0B33 Lo +0B36 0B39 Lo +0B3C Mn +0B3D Lo +0B3E Mc +0B3F Mn +0B40 Mc +0B41 0B43 Mn +0B47 0B48 Mc +0B4B 0B4C Mc +0B4D Mn +0B56 Mn +0B57 Mc +0B5C 0B5D Lo +0B5F 0B61 Lo +0B66 0B6F Nd +0B70 So +0B82 Mn +0B83 Lo +0B85 0B8A Lo +0B8E 0B90 Lo +0B92 0B95 Lo +0B99 0B9A Lo +0B9C Lo +0B9E 0B9F Lo +0BA3 0BA4 Lo +0BA8 0BAA Lo +0BAE 0BB5 Lo +0BB7 0BB9 Lo +0BBE 0BBF Mc +0BC0 Mn +0BC1 0BC2 Mc +0BC6 0BC8 Mc +0BCA 0BCC Mc +0BCD Mn +0BD7 Mc +0BE7 0BEF Nd +0BF0 0BF2 No +0C01 0C03 Mc +0C05 0C0C Lo +0C0E 0C10 Lo +0C12 0C28 Lo +0C2A 0C33 Lo +0C35 0C39 Lo +0C3E 0C40 Mn +0C41 0C44 Mc +0C46 0C48 Mn +0C4A 0C4D Mn +0C55 0C56 Mn +0C60 0C61 Lo +0C66 0C6F Nd +0C82 0C83 Mc +0C85 0C8C Lo +0C8E 0C90 Lo +0C92 0CA8 Lo +0CAA 0CB3 Lo +0CB5 0CB9 Lo +0CBE Mc +0CBF Mn +0CC0 0CC4 Mc +0CC6 Mn +0CC7 0CC8 Mc +0CCA 0CCB Mc +0CCC 0CCD Mn +0CD5 0CD6 Mc +0CDE Lo +0CE0 0CE1 Lo +0CE6 0CEF Nd +0D02 0D03 Mc +0D05 0D0C Lo +0D0E 0D10 Lo +0D12 0D28 Lo +0D2A 0D39 Lo +0D3E 0D40 Mc +0D41 0D43 Mn +0D46 0D48 Mc +0D4A 0D4C Mc +0D4D Mn +0D57 Mc +0D60 0D61 Lo +0D66 0D6F Nd +0D82 0D83 Mc +0D85 0D96 Lo +0D9A 0DB1 Lo +0DB3 0DBB Lo +0DBD Lo +0DC0 0DC6 Lo +0DCA Mn +0DCF 0DD1 Mc +0DD2 0DD4 Mn +0DD6 Mn +0DD8 0DDF Mc +0DF2 0DF3 Mc +0DF4 Po +0E01 0E30 Lo +0E31 Mn +0E32 0E33 Lo +0E34 0E3A Mn +0E3F Sc +0E40 0E45 Lo +0E46 Lm +0E47 0E4E Mn +0E4F Po +0E50 0E59 Nd +0E5A 0E5B Po +0E81 0E82 Lo +0E84 Lo +0E87 0E88 Lo +0E8A Lo +0E8D Lo +0E94 0E97 Lo +0E99 0E9F Lo +0EA1 0EA3 Lo +0EA5 Lo +0EA7 Lo +0EAA 0EAB Lo +0EAD 0EB0 Lo +0EB1 Mn +0EB2 0EB3 Lo +0EB4 0EB9 Mn +0EBB 0EBC Mn +0EBD Lo +0EC0 0EC4 Lo +0EC6 Lm +0EC8 0ECD Mn +0ED0 0ED9 Nd +0EDC 0EDD Lo +0F00 Lo +0F01 0F03 So +0F04 0F12 Po +0F13 0F17 So +0F18 0F19 Mn +0F1A 0F1F So +0F20 0F29 Nd +0F2A 0F33 No +0F34 So +0F35 Mn +0F36 So +0F37 Mn +0F38 So +0F39 Mn +0F3A Ps +0F3B Pe +0F3C Ps +0F3D Pe +0F3E 0F3F Mc +0F40 0F47 Lo +0F49 0F6A Lo +0F71 0F7E Mn +0F7F Mc +0F80 0F84 Mn +0F85 Po +0F86 0F87 Mn +0F88 0F8B Lo +0F90 0F97 Mn +0F99 0FBC Mn +0FBE 0FC5 So +0FC6 Mn +0FC7 0FCC So +0FCF So +1000 1021 Lo +1023 1027 Lo +1029 102A Lo +102C Mc +102D 1030 Mn +1031 Mc +1032 Mn +1036 1037 Mn +1038 Mc +1039 Mn +1040 1049 Nd +104A 104F Po +1050 1055 Lo +1056 1057 Mc +1058 1059 Mn +10A0 10C5 Lu +10D0 10F8 Lo +10FB Po +1100 1159 Lo +115F 11A2 Lo +11A8 11F9 Lo +1200 1206 Lo +1208 1246 Lo +1248 Lo +124A 124D Lo +1250 1256 Lo +1258 Lo +125A 125D Lo +1260 1286 Lo +1288 Lo +128A 128D Lo +1290 12AE Lo +12B0 Lo +12B2 12B5 Lo +12B8 12BE Lo +12C0 Lo +12C2 12C5 Lo +12C8 12CE Lo +12D0 12D6 Lo +12D8 12EE Lo +12F0 130E Lo +1310 Lo +1312 1315 Lo +1318 131E Lo +1320 1346 Lo +1348 135A Lo +1361 1368 Po +1369 1371 Nd +1372 137C No +13A0 13F4 Lo +1401 166C Lo +166D 166E Po +166F 1676 Lo +1680 Zs +1681 169A Lo +169B Ps +169C Pe +16A0 16EA Lo +16EB 16ED Po +16EE 16F0 Nl +1700 170C Lo +170E 1711 Lo +1712 1714 Mn +1720 1731 Lo +1732 1734 Mn +1735 1736 Po +1740 1751 Lo +1752 1753 Mn +1760 176C Lo +176E 1770 Lo +1772 1773 Mn +1780 17B3 Lo +17B4 17B6 Mc +17B7 17BD Mn +17BE 17C5 Mc +17C6 Mn +17C7 17C8 Mc +17C9 17D3 Mn +17D4 17D6 Po +17D7 Lm +17D8 17DA Po +17DB Sc +17DC Lo +17E0 17E9 Nd +1800 1805 Po +1806 Pd +1807 180A Po +180B 180D Mn +180E Cf +1810 1819 Nd +1820 1842 Lo +1843 Lm +1844 1877 Lo +1880 18A8 Lo +18A9 Mn +1E00 Lu +1E01 Ll +1E02 Lu +1E03 Ll +1E04 Lu +1E05 Ll +1E06 Lu +1E07 Ll +1E08 Lu +1E09 Ll +1E0A Lu +1E0B Ll +1E0C Lu +1E0D Ll +1E0E Lu +1E0F Ll +1E10 Lu +1E11 Ll +1E12 Lu +1E13 Ll +1E14 Lu +1E15 Ll +1E16 Lu +1E17 Ll +1E18 Lu +1E19 Ll +1E1A Lu +1E1B Ll +1E1C Lu +1E1D Ll +1E1E Lu +1E1F Ll +1E20 Lu +1E21 Ll +1E22 Lu +1E23 Ll +1E24 Lu +1E25 Ll +1E26 Lu +1E27 Ll +1E28 Lu +1E29 Ll +1E2A Lu +1E2B Ll +1E2C Lu +1E2D Ll +1E2E Lu +1E2F Ll +1E30 Lu +1E31 Ll +1E32 Lu +1E33 Ll +1E34 Lu +1E35 Ll +1E36 Lu +1E37 Ll +1E38 Lu +1E39 Ll +1E3A Lu +1E3B Ll +1E3C Lu +1E3D Ll +1E3E Lu +1E3F Ll +1E40 Lu +1E41 Ll +1E42 Lu +1E43 Ll +1E44 Lu +1E45 Ll +1E46 Lu +1E47 Ll +1E48 Lu +1E49 Ll +1E4A Lu +1E4B Ll +1E4C Lu +1E4D Ll +1E4E Lu +1E4F Ll +1E50 Lu +1E51 Ll +1E52 Lu +1E53 Ll +1E54 Lu +1E55 Ll +1E56 Lu +1E57 Ll +1E58 Lu +1E59 Ll +1E5A Lu +1E5B Ll +1E5C Lu +1E5D Ll +1E5E Lu +1E5F Ll +1E60 Lu +1E61 Ll +1E62 Lu +1E63 Ll +1E64 Lu +1E65 Ll +1E66 Lu +1E67 Ll +1E68 Lu +1E69 Ll +1E6A Lu +1E6B Ll +1E6C Lu +1E6D Ll +1E6E Lu +1E6F Ll +1E70 Lu +1E71 Ll +1E72 Lu +1E73 Ll +1E74 Lu +1E75 Ll +1E76 Lu +1E77 Ll +1E78 Lu +1E79 Ll +1E7A Lu +1E7B Ll +1E7C Lu +1E7D Ll +1E7E Lu +1E7F Ll +1E80 Lu +1E81 Ll +1E82 Lu +1E83 Ll +1E84 Lu +1E85 Ll +1E86 Lu +1E87 Ll +1E88 Lu +1E89 Ll +1E8A Lu +1E8B Ll +1E8C Lu +1E8D Ll +1E8E Lu +1E8F Ll +1E90 Lu +1E91 Ll +1E92 Lu +1E93 Ll +1E94 Lu +1E95 1E9B Ll +1EA0 Lu +1EA1 Ll +1EA2 Lu +1EA3 Ll +1EA4 Lu +1EA5 Ll +1EA6 Lu +1EA7 Ll +1EA8 Lu +1EA9 Ll +1EAA Lu +1EAB Ll +1EAC Lu +1EAD Ll +1EAE Lu +1EAF Ll +1EB0 Lu +1EB1 Ll +1EB2 Lu +1EB3 Ll +1EB4 Lu +1EB5 Ll +1EB6 Lu +1EB7 Ll +1EB8 Lu +1EB9 Ll +1EBA Lu +1EBB Ll +1EBC Lu +1EBD Ll +1EBE Lu +1EBF Ll +1EC0 Lu +1EC1 Ll +1EC2 Lu +1EC3 Ll +1EC4 Lu +1EC5 Ll +1EC6 Lu +1EC7 Ll +1EC8 Lu +1EC9 Ll +1ECA Lu +1ECB Ll +1ECC Lu +1ECD Ll +1ECE Lu +1ECF Ll +1ED0 Lu +1ED1 Ll +1ED2 Lu +1ED3 Ll +1ED4 Lu +1ED5 Ll +1ED6 Lu +1ED7 Ll +1ED8 Lu +1ED9 Ll +1EDA Lu +1EDB Ll +1EDC Lu +1EDD Ll +1EDE Lu +1EDF Ll +1EE0 Lu +1EE1 Ll +1EE2 Lu +1EE3 Ll +1EE4 Lu +1EE5 Ll +1EE6 Lu +1EE7 Ll +1EE8 Lu +1EE9 Ll +1EEA Lu +1EEB Ll +1EEC Lu +1EED Ll +1EEE Lu +1EEF Ll +1EF0 Lu +1EF1 Ll +1EF2 Lu +1EF3 Ll +1EF4 Lu +1EF5 Ll +1EF6 Lu +1EF7 Ll +1EF8 Lu +1EF9 Ll +1F00 1F07 Ll +1F08 1F0F Lu +1F10 1F15 Ll +1F18 1F1D Lu +1F20 1F27 Ll +1F28 1F2F Lu +1F30 1F37 Ll +1F38 1F3F Lu +1F40 1F45 Ll +1F48 1F4D Lu +1F50 1F57 Ll +1F59 Lu +1F5B Lu +1F5D Lu +1F5F Lu +1F60 1F67 Ll +1F68 1F6F Lu +1F70 1F7D Ll +1F80 1F87 Ll +1F88 1F8F Lt +1F90 1F97 Ll +1F98 1F9F Lt +1FA0 1FA7 Ll +1FA8 1FAF Lt +1FB0 1FB4 Ll +1FB6 1FB7 Ll +1FB8 1FBB Lu +1FBC Lt +1FBD Sk +1FBE Ll +1FBF 1FC1 Sk +1FC2 1FC4 Ll +1FC6 1FC7 Ll +1FC8 1FCB Lu +1FCC Lt +1FCD 1FCF Sk +1FD0 1FD3 Ll +1FD6 1FD7 Ll +1FD8 1FDB Lu +1FDD 1FDF Sk +1FE0 1FE7 Ll +1FE8 1FEC Lu +1FED 1FEF Sk +1FF2 1FF4 Ll +1FF6 1FF7 Ll +1FF8 1FFB Lu +1FFC Lt +1FFD 1FFE Sk +2000 200B Zs +200C 200F Cf +2010 2015 Pd +2016 2017 Po +2018 Pi +2019 Pf +201A Ps +201B 201C Pi +201D Pf +201E Ps +201F Pi +2020 2027 Po +2028 Zl +2029 Zp +202A 202E Cf +202F Zs +2030 2038 Po +2039 Pi +203A Pf +203B 203E Po +203F 2040 Pc +2041 2043 Po +2044 Sm +2045 Ps +2046 Pe +2047 2051 Po +2052 Sm +2057 Po +205F Zs +2060 2063 Cf +206A 206F Cf +2070 No +2071 Ll +2074 2079 No +207A 207C Sm +207D Ps +207E Pe +207F Ll +2080 2089 No +208A 208C Sm +208D Ps +208E Pe +20A0 20B1 Sc +20D0 20DC Mn +20DD 20E0 Me +20E1 Mn +20E2 20E4 Me +20E5 20EA Mn +2100 2101 So +2102 Lu +2103 2106 So +2107 Lu +2108 2109 So +210A Ll +210B 210D Lu +210E 210F Ll +2110 2112 Lu +2113 Ll +2114 So +2115 Lu +2116 2118 So +2119 211D Lu +211E 2123 So +2124 Lu +2125 So +2126 Lu +2127 So +2128 Lu +2129 So +212A 212D Lu +212E So +212F Ll +2130 2131 Lu +2132 So +2133 Lu +2134 Ll +2135 2138 Lo +2139 Ll +213A So +213D Ll +213E 213F Lu +2140 2144 Sm +2145 Lu +2146 2149 Ll +214A So +214B Sm +2153 215F No +2160 2183 Nl +2190 2194 Sm +2195 2199 So +219A 219B Sm +219C 219F So +21A0 Sm +21A1 21A2 So +21A3 Sm +21A4 21A5 So +21A6 Sm +21A7 21AD So +21AE Sm +21AF 21CD So +21CE 21CF Sm +21D0 21D1 So +21D2 Sm +21D3 So +21D4 Sm +21D5 21F3 So +21F4 22FF Sm +2300 2307 So +2308 230B Sm +230C 231F So +2320 2321 Sm +2322 2328 So +2329 Ps +232A Pe +232B 237B So +237C Sm +237D 239A So +239B 23B3 Sm +23B4 Ps +23B5 Pe +23B6 Po +23B7 23CE So +2400 2426 So +2440 244A So +2460 249B No +249C 24E9 So +24EA 24FE No +2500 25B6 So +25B7 Sm +25B8 25C0 So +25C1 Sm +25C2 25F7 So +25F8 25FF Sm +2600 2613 So +2616 2617 So +2619 266E So +266F Sm +2670 267D So +2680 2689 So +2701 2704 So +2706 2709 So +270C 2727 So +2729 274B So +274D So +274F 2752 So +2756 So +2758 275E So +2761 2767 So +2768 Ps +2769 Pe +276A Ps +276B Pe +276C Ps +276D Pe +276E Ps +276F Pe +2770 Ps +2771 Pe +2772 Ps +2773 Pe +2774 Ps +2775 Pe +2776 2793 No +2794 So +2798 27AF So +27B1 27BE So +27D0 27E5 Sm +27E6 Ps +27E7 Pe +27E8 Ps +27E9 Pe +27EA Ps +27EB Pe +27F0 27FF Sm +2800 28FF So +2900 2982 Sm +2983 Ps +2984 Pe +2985 Ps +2986 Pe +2987 Ps +2988 Pe +2989 Ps +298A Pe +298B Ps +298C Pe +298D Ps +298E Pe +298F Ps +2990 Pe +2991 Ps +2992 Pe +2993 Ps +2994 Pe +2995 Ps +2996 Pe +2997 Ps +2998 Pe +2999 29D7 Sm +29D8 Ps +29D9 Pe +29DA Ps +29DB Pe +29DC 29FB Sm +29FC Ps +29FD Pe +29FE 2AFF Sm +2E80 2E99 So +2E9B 2EF3 So +2F00 2FD5 So +2FF0 2FFB So +3000 Zs +3001 3003 Po +3004 So +3005 Lm +3006 Lo +3007 Nl +3008 Ps +3009 Pe +300A Ps +300B Pe +300C Ps +300D Pe +300E Ps +300F Pe +3010 Ps +3011 Pe +3012 3013 So +3014 Ps +3015 Pe +3016 Ps +3017 Pe +3018 Ps +3019 Pe +301A Ps +301B Pe +301C Pd +301D Ps +301E 301F Pe +3020 So +3021 3029 Nl +302A 302F Mn +3030 Pd +3031 3035 Lm +3036 3037 So +3038 303A Nl +303B Lm +303C Lo +303D Po +303E 303F So +3041 3096 Lo +3099 309A Mn +309B 309C Sk +309D 309E Lm +309F Lo +30A0 Pd +30A1 30FA Lo +30FB Pc +30FC 30FE Lm +30FF Lo +3105 312C Lo +3131 318E Lo +3190 3191 So +3192 3195 No +3196 319F So +31A0 31B7 Lo +31F0 31FF Lo +3200 321C So +3220 3229 No +322A 3243 So +3251 325F No +3260 327B So +327F So +3280 3289 No +328A 32B0 So +32B1 32BF No +32C0 32CB So +32D0 32FE So +3300 3376 So +337B 33DD So +33E0 33FE So +3400 4DB5 Lo +4E00 9FA5 Lo +A000 A48C Lo +A490 A4C6 So +AC00 D7A3 Lo +D800 DFFF Cs +E000 F8FF Co +F900 FA2D Lo +FA30 FA6A Lo +FB00 FB06 Ll +FB13 FB17 Ll +FB1D Lo +FB1E Mn +FB1F FB28 Lo +FB29 Sm +FB2A FB36 Lo +FB38 FB3C Lo +FB3E Lo +FB40 FB41 Lo +FB43 FB44 Lo +FB46 FBB1 Lo +FBD3 FD3D Lo +FD3E Ps +FD3F Pe +FD50 FD8F Lo +FD92 FDC7 Lo +FDF0 FDFB Lo +FDFC Sc +FE00 FE0F Mn +FE20 FE23 Mn +FE30 Po +FE31 FE32 Pd +FE33 FE34 Pc +FE35 Ps +FE36 Pe +FE37 Ps +FE38 Pe +FE39 Ps +FE3A Pe +FE3B Ps +FE3C Pe +FE3D Ps +FE3E Pe +FE3F Ps +FE40 Pe +FE41 Ps +FE42 Pe +FE43 Ps +FE44 Pe +FE45 FE46 Po +FE49 FE4C Po +FE4D FE4F Pc +FE50 FE52 Po +FE54 FE57 Po +FE58 Pd +FE59 Ps +FE5A Pe +FE5B Ps +FE5C Pe +FE5D Ps +FE5E Pe +FE5F FE61 Po +FE62 Sm +FE63 Pd +FE64 FE66 Sm +FE68 Po +FE69 Sc +FE6A FE6B Po +FE70 FE74 Lo +FE76 FEFC Lo +FEFF Cf +FF01 FF03 Po +FF04 Sc +FF05 FF07 Po +FF08 Ps +FF09 Pe +FF0A Po +FF0B Sm +FF0C Po +FF0D Pd +FF0E FF0F Po +FF10 FF19 Nd +FF1A FF1B Po +FF1C FF1E Sm +FF1F FF20 Po +FF21 FF3A Lu +FF3B Ps +FF3C Po +FF3D Pe +FF3E Sk +FF3F Pc +FF40 Sk +FF41 FF5A Ll +FF5B Ps +FF5C Sm +FF5D Pe +FF5E Sm +FF5F Ps +FF60 Pe +FF61 Po +FF62 Ps +FF63 Pe +FF64 Po +FF65 Pc +FF66 FF6F Lo +FF70 Lm +FF71 FF9D Lo +FF9E FF9F Lm +FFA0 FFBE Lo +FFC2 FFC7 Lo +FFCA FFCF Lo +FFD2 FFD7 Lo +FFDA FFDC Lo +FFE0 FFE1 Sc +FFE2 Sm +FFE3 Sk +FFE4 So +FFE5 FFE6 Sc +FFE8 So +FFE9 FFEC Sm +FFED FFEE So +FFF9 FFFB Cf +FFFC FFFD So +10300 1031E Lo +10320 10323 No +10330 10349 Lo +1034A Nl +10400 10425 Lu +10428 1044D Ll +1D000 1D0F5 So +1D100 1D126 So +1D12A 1D164 So +1D165 1D166 Mc +1D167 1D169 Mn +1D16A 1D16C So +1D16D 1D172 Mc +1D173 1D17A Cf +1D17B 1D182 Mn +1D183 1D184 So +1D185 1D18B Mn +1D18C 1D1A9 So +1D1AA 1D1AD Mn +1D1AE 1D1DD So +1D400 1D419 Lu +1D41A 1D433 Ll +1D434 1D44D Lu +1D44E 1D454 Ll +1D456 1D467 Ll +1D468 1D481 Lu +1D482 1D49B Ll +1D49C Lu +1D49E 1D49F Lu +1D4A2 Lu +1D4A5 1D4A6 Lu +1D4A9 1D4AC Lu +1D4AE 1D4B5 Lu +1D4B6 1D4B9 Ll +1D4BB Ll +1D4BD 1D4C0 Ll +1D4C2 1D4C3 Ll +1D4C5 1D4CF Ll +1D4D0 1D4E9 Lu +1D4EA 1D503 Ll +1D504 1D505 Lu +1D507 1D50A Lu +1D50D 1D514 Lu +1D516 1D51C Lu +1D51E 1D537 Ll +1D538 1D539 Lu +1D53B 1D53E Lu +1D540 1D544 Lu +1D546 Lu +1D54A 1D550 Lu +1D552 1D56B Ll +1D56C 1D585 Lu +1D586 1D59F Ll +1D5A0 1D5B9 Lu +1D5BA 1D5D3 Ll +1D5D4 1D5ED Lu +1D5EE 1D607 Ll +1D608 1D621 Lu +1D622 1D63B Ll +1D63C 1D655 Lu +1D656 1D66F Ll +1D670 1D689 Lu +1D68A 1D6A3 Ll +1D6A8 1D6C0 Lu +1D6C1 Sm +1D6C2 1D6DA Ll +1D6DB Sm +1D6DC 1D6E1 Ll +1D6E2 1D6FA Lu +1D6FB Sm +1D6FC 1D714 Ll +1D715 Sm +1D716 1D71B Ll +1D71C 1D734 Lu +1D735 Sm +1D736 1D74E Ll +1D74F Sm +1D750 1D755 Ll +1D756 1D76E Lu +1D76F Sm +1D770 1D788 Ll +1D789 Sm +1D78A 1D78F Ll +1D790 1D7A8 Lu +1D7A9 Sm +1D7AA 1D7C2 Ll +1D7C3 Sm +1D7C4 1D7C9 Ll +1D7CE 1D7FF Nd +20000 2A6D6 Lo +2F800 2FA1D Lo +E0001 Cf +E0020 E007F Cf +F0000 FFFFD Co +100000 10FFFD Co +END diff --git a/Master/xemtex/perl/lib/unicore/CombiningClass.pl b/Master/xemtex/perl/lib/unicore/CombiningClass.pl new file mode 100644 index 00000000000..2b97b553e4e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/CombiningClass.pl @@ -0,0 +1,169 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0300 0314 230 +0315 232 +0316 0319 220 +031A 232 +031B 216 +031C 0320 220 +0321 0322 202 +0323 0326 220 +0327 0328 202 +0329 0333 220 +0334 0338 1 +0339 033C 220 +033D 0344 230 +0345 240 +0346 230 +0347 0349 220 +034A 034C 230 +034D 034E 220 +0360 0361 234 +0362 233 +0363 036F 230 +0483 0486 230 +0591 220 +0592 0595 230 +0596 220 +0597 0599 230 +059A 222 +059B 220 +059C 05A1 230 +05A3 05A7 220 +05A8 05A9 230 +05AA 220 +05AB 05AC 230 +05AD 222 +05AE 228 +05AF 230 +05B0 10 +05B1 11 +05B2 12 +05B3 13 +05B4 14 +05B5 15 +05B6 16 +05B7 17 +05B8 18 +05B9 19 +05BB 20 +05BC 21 +05BD 22 +05BF 23 +05C1 24 +05C2 25 +05C4 230 +064B 27 +064C 28 +064D 29 +064E 30 +064F 31 +0650 32 +0651 33 +0652 34 +0653 0654 230 +0655 220 +0670 35 +06D6 06DC 230 +06DF 06E2 230 +06E3 220 +06E4 230 +06E7 06E8 230 +06EA 220 +06EB 06EC 230 +06ED 220 +0711 36 +0730 230 +0731 220 +0732 0733 230 +0734 220 +0735 0736 230 +0737 0739 220 +073A 230 +073B 073C 220 +073D 230 +073E 220 +073F 0741 230 +0742 220 +0743 230 +0744 220 +0745 230 +0746 220 +0747 230 +0748 220 +0749 074A 230 +093C 7 +094D 9 +0951 230 +0952 220 +0953 0954 230 +09BC 7 +09CD 9 +0A3C 7 +0A4D 9 +0ABC 7 +0ACD 9 +0B3C 7 +0B4D 9 +0BCD 9 +0C4D 9 +0C55 84 +0C56 91 +0CCD 9 +0D4D 9 +0DCA 9 +0E38 0E39 103 +0E3A 9 +0E48 0E4B 107 +0EB8 0EB9 118 +0EC8 0ECB 122 +0F18 0F19 220 +0F35 220 +0F37 220 +0F39 216 +0F71 129 +0F72 130 +0F74 132 +0F7A 0F7D 130 +0F80 130 +0F82 0F83 230 +0F84 9 +0F86 0F87 230 +0FC6 220 +1037 7 +1039 9 +1714 9 +1734 9 +17D2 9 +18A9 228 +20D0 20D1 230 +20D2 20D3 1 +20D4 20D7 230 +20D8 20DA 1 +20DB 20DC 230 +20E1 230 +20E5 20E6 1 +20E7 230 +20E8 220 +20E9 230 +20EA 1 +302A 218 +302B 228 +302C 232 +302D 222 +302E 302F 224 +3099 309A 8 +FB1E 26 +FE20 FE23 230 +1D165 1D166 216 +1D167 1D169 1 +1D16D 226 +1D16E 1D172 216 +1D17B 1D182 220 +1D185 1D189 230 +1D18A 1D18B 220 +1D1AA 1D1AD 230 +END diff --git a/Master/xemtex/perl/lib/unicore/Decomposition.pl b/Master/xemtex/perl/lib/unicore/Decomposition.pl new file mode 100644 index 00000000000..739d8fc661b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Decomposition.pl @@ -0,0 +1,5120 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +00A0 <noBreak> 0020 +00A8 <compat> 0020 0308 +00AA <super> 0061 +00AF <compat> 0020 0304 +00B2 <super> 0032 +00B3 <super> 0033 +00B4 <compat> 0020 0301 +00B5 <compat> 03BC +00B8 <compat> 0020 0327 +00B9 <super> 0031 +00BA <super> 006F +00BC <fraction> 0031 2044 0034 +00BD <fraction> 0031 2044 0032 +00BE <fraction> 0033 2044 0034 +00C0 0041 0300 +00C1 0041 0301 +00C2 0041 0302 +00C3 0041 0303 +00C4 0041 0308 +00C5 0041 030A +00C7 0043 0327 +00C8 0045 0300 +00C9 0045 0301 +00CA 0045 0302 +00CB 0045 0308 +00CC 0049 0300 +00CD 0049 0301 +00CE 0049 0302 +00CF 0049 0308 +00D1 004E 0303 +00D2 004F 0300 +00D3 004F 0301 +00D4 004F 0302 +00D5 004F 0303 +00D6 004F 0308 +00D9 0055 0300 +00DA 0055 0301 +00DB 0055 0302 +00DC 0055 0308 +00DD 0059 0301 +00E0 0061 0300 +00E1 0061 0301 +00E2 0061 0302 +00E3 0061 0303 +00E4 0061 0308 +00E5 0061 030A +00E7 0063 0327 +00E8 0065 0300 +00E9 0065 0301 +00EA 0065 0302 +00EB 0065 0308 +00EC 0069 0300 +00ED 0069 0301 +00EE 0069 0302 +00EF 0069 0308 +00F1 006E 0303 +00F2 006F 0300 +00F3 006F 0301 +00F4 006F 0302 +00F5 006F 0303 +00F6 006F 0308 +00F9 0075 0300 +00FA 0075 0301 +00FB 0075 0302 +00FC 0075 0308 +00FD 0079 0301 +00FF 0079 0308 +0100 0041 0304 +0101 0061 0304 +0102 0041 0306 +0103 0061 0306 +0104 0041 0328 +0105 0061 0328 +0106 0043 0301 +0107 0063 0301 +0108 0043 0302 +0109 0063 0302 +010A 0043 0307 +010B 0063 0307 +010C 0043 030C +010D 0063 030C +010E 0044 030C +010F 0064 030C +0112 0045 0304 +0113 0065 0304 +0114 0045 0306 +0115 0065 0306 +0116 0045 0307 +0117 0065 0307 +0118 0045 0328 +0119 0065 0328 +011A 0045 030C +011B 0065 030C +011C 0047 0302 +011D 0067 0302 +011E 0047 0306 +011F 0067 0306 +0120 0047 0307 +0121 0067 0307 +0122 0047 0327 +0123 0067 0327 +0124 0048 0302 +0125 0068 0302 +0128 0049 0303 +0129 0069 0303 +012A 0049 0304 +012B 0069 0304 +012C 0049 0306 +012D 0069 0306 +012E 0049 0328 +012F 0069 0328 +0130 0049 0307 +0132 <compat> 0049 004A +0133 <compat> 0069 006A +0134 004A 0302 +0135 006A 0302 +0136 004B 0327 +0137 006B 0327 +0139 004C 0301 +013A 006C 0301 +013B 004C 0327 +013C 006C 0327 +013D 004C 030C +013E 006C 030C +013F <compat> 004C 00B7 +0140 <compat> 006C 00B7 +0143 004E 0301 +0144 006E 0301 +0145 004E 0327 +0146 006E 0327 +0147 004E 030C +0148 006E 030C +0149 <compat> 02BC 006E +014C 004F 0304 +014D 006F 0304 +014E 004F 0306 +014F 006F 0306 +0150 004F 030B +0151 006F 030B +0154 0052 0301 +0155 0072 0301 +0156 0052 0327 +0157 0072 0327 +0158 0052 030C +0159 0072 030C +015A 0053 0301 +015B 0073 0301 +015C 0053 0302 +015D 0073 0302 +015E 0053 0327 +015F 0073 0327 +0160 0053 030C +0161 0073 030C +0162 0054 0327 +0163 0074 0327 +0164 0054 030C +0165 0074 030C +0168 0055 0303 +0169 0075 0303 +016A 0055 0304 +016B 0075 0304 +016C 0055 0306 +016D 0075 0306 +016E 0055 030A +016F 0075 030A +0170 0055 030B +0171 0075 030B +0172 0055 0328 +0173 0075 0328 +0174 0057 0302 +0175 0077 0302 +0176 0059 0302 +0177 0079 0302 +0178 0059 0308 +0179 005A 0301 +017A 007A 0301 +017B 005A 0307 +017C 007A 0307 +017D 005A 030C +017E 007A 030C +017F <compat> 0073 +01A0 004F 031B +01A1 006F 031B +01AF 0055 031B +01B0 0075 031B +01C4 <compat> 0044 017D +01C5 <compat> 0044 017E +01C6 <compat> 0064 017E +01C7 <compat> 004C 004A +01C8 <compat> 004C 006A +01C9 <compat> 006C 006A +01CA <compat> 004E 004A +01CB <compat> 004E 006A +01CC <compat> 006E 006A +01CD 0041 030C +01CE 0061 030C +01CF 0049 030C +01D0 0069 030C +01D1 004F 030C +01D2 006F 030C +01D3 0055 030C +01D4 0075 030C +01D5 00DC 0304 +01D6 00FC 0304 +01D7 00DC 0301 +01D8 00FC 0301 +01D9 00DC 030C +01DA 00FC 030C +01DB 00DC 0300 +01DC 00FC 0300 +01DE 00C4 0304 +01DF 00E4 0304 +01E0 0226 0304 +01E1 0227 0304 +01E2 00C6 0304 +01E3 00E6 0304 +01E6 0047 030C +01E7 0067 030C +01E8 004B 030C +01E9 006B 030C +01EA 004F 0328 +01EB 006F 0328 +01EC 01EA 0304 +01ED 01EB 0304 +01EE 01B7 030C +01EF 0292 030C +01F0 006A 030C +01F1 <compat> 0044 005A +01F2 <compat> 0044 007A +01F3 <compat> 0064 007A +01F4 0047 0301 +01F5 0067 0301 +01F8 004E 0300 +01F9 006E 0300 +01FA 00C5 0301 +01FB 00E5 0301 +01FC 00C6 0301 +01FD 00E6 0301 +01FE 00D8 0301 +01FF 00F8 0301 +0200 0041 030F +0201 0061 030F +0202 0041 0311 +0203 0061 0311 +0204 0045 030F +0205 0065 030F +0206 0045 0311 +0207 0065 0311 +0208 0049 030F +0209 0069 030F +020A 0049 0311 +020B 0069 0311 +020C 004F 030F +020D 006F 030F +020E 004F 0311 +020F 006F 0311 +0210 0052 030F +0211 0072 030F +0212 0052 0311 +0213 0072 0311 +0214 0055 030F +0215 0075 030F +0216 0055 0311 +0217 0075 0311 +0218 0053 0326 +0219 0073 0326 +021A 0054 0326 +021B 0074 0326 +021E 0048 030C +021F 0068 030C +0226 0041 0307 +0227 0061 0307 +0228 0045 0327 +0229 0065 0327 +022A 00D6 0304 +022B 00F6 0304 +022C 00D5 0304 +022D 00F5 0304 +022E 004F 0307 +022F 006F 0307 +0230 022E 0304 +0231 022F 0304 +0232 0059 0304 +0233 0079 0304 +02B0 <super> 0068 +02B1 <super> 0266 +02B2 <super> 006A +02B3 <super> 0072 +02B4 <super> 0279 +02B5 <super> 027B +02B6 <super> 0281 +02B7 <super> 0077 +02B8 <super> 0079 +02D8 <compat> 0020 0306 +02D9 <compat> 0020 0307 +02DA <compat> 0020 030A +02DB <compat> 0020 0328 +02DC <compat> 0020 0303 +02DD <compat> 0020 030B +02E0 <super> 0263 +02E1 <super> 006C +02E2 <super> 0073 +02E3 <super> 0078 +02E4 <super> 0295 +0340 0300 +0341 0301 +0343 0313 +0344 0308 0301 +0374 02B9 +037A <compat> 0020 0345 +037E 003B +0384 <compat> 0020 0301 +0385 00A8 0301 +0386 0391 0301 +0387 00B7 +0388 0395 0301 +0389 0397 0301 +038A 0399 0301 +038C 039F 0301 +038E 03A5 0301 +038F 03A9 0301 +0390 03CA 0301 +03AA 0399 0308 +03AB 03A5 0308 +03AC 03B1 0301 +03AD 03B5 0301 +03AE 03B7 0301 +03AF 03B9 0301 +03B0 03CB 0301 +03CA 03B9 0308 +03CB 03C5 0308 +03CC 03BF 0301 +03CD 03C5 0301 +03CE 03C9 0301 +03D0 <compat> 03B2 +03D1 <compat> 03B8 +03D2 <compat> 03A5 +03D3 03D2 0301 +03D4 03D2 0308 +03D5 <compat> 03C6 +03D6 <compat> 03C0 +03F0 <compat> 03BA +03F1 <compat> 03C1 +03F2 <compat> 03C2 +03F4 <compat> 0398 +03F5 <compat> 03B5 +0400 0415 0300 +0401 0415 0308 +0403 0413 0301 +0407 0406 0308 +040C 041A 0301 +040D 0418 0300 +040E 0423 0306 +0419 0418 0306 +0439 0438 0306 +0450 0435 0300 +0451 0435 0308 +0453 0433 0301 +0457 0456 0308 +045C 043A 0301 +045D 0438 0300 +045E 0443 0306 +0476 0474 030F +0477 0475 030F +04C1 0416 0306 +04C2 0436 0306 +04D0 0410 0306 +04D1 0430 0306 +04D2 0410 0308 +04D3 0430 0308 +04D6 0415 0306 +04D7 0435 0306 +04DA 04D8 0308 +04DB 04D9 0308 +04DC 0416 0308 +04DD 0436 0308 +04DE 0417 0308 +04DF 0437 0308 +04E2 0418 0304 +04E3 0438 0304 +04E4 0418 0308 +04E5 0438 0308 +04E6 041E 0308 +04E7 043E 0308 +04EA 04E8 0308 +04EB 04E9 0308 +04EC 042D 0308 +04ED 044D 0308 +04EE 0423 0304 +04EF 0443 0304 +04F0 0423 0308 +04F1 0443 0308 +04F2 0423 030B +04F3 0443 030B +04F4 0427 0308 +04F5 0447 0308 +04F8 042B 0308 +04F9 044B 0308 +0587 <compat> 0565 0582 +0622 0627 0653 +0623 0627 0654 +0624 0648 0654 +0625 0627 0655 +0626 064A 0654 +0675 <compat> 0627 0674 +0676 <compat> 0648 0674 +0677 <compat> 06C7 0674 +0678 <compat> 064A 0674 +06C0 06D5 0654 +06C2 06C1 0654 +06D3 06D2 0654 +0929 0928 093C +0931 0930 093C +0934 0933 093C +0958 0915 093C +0959 0916 093C +095A 0917 093C +095B 091C 093C +095C 0921 093C +095D 0922 093C +095E 092B 093C +095F 092F 093C +09CB 09C7 09BE +09CC 09C7 09D7 +09DC 09A1 09BC +09DD 09A2 09BC +09DF 09AF 09BC +0A33 0A32 0A3C +0A36 0A38 0A3C +0A59 0A16 0A3C +0A5A 0A17 0A3C +0A5B 0A1C 0A3C +0A5E 0A2B 0A3C +0B48 0B47 0B56 +0B4B 0B47 0B3E +0B4C 0B47 0B57 +0B5C 0B21 0B3C +0B5D 0B22 0B3C +0B94 0B92 0BD7 +0BCA 0BC6 0BBE +0BCB 0BC7 0BBE +0BCC 0BC6 0BD7 +0C48 0C46 0C56 +0CC0 0CBF 0CD5 +0CC7 0CC6 0CD5 +0CC8 0CC6 0CD6 +0CCA 0CC6 0CC2 +0CCB 0CCA 0CD5 +0D4A 0D46 0D3E +0D4B 0D47 0D3E +0D4C 0D46 0D57 +0DDA 0DD9 0DCA +0DDC 0DD9 0DCF +0DDD 0DDC 0DCA +0DDE 0DD9 0DDF +0E33 <compat> 0E4D 0E32 +0EB3 <compat> 0ECD 0EB2 +0EDC <compat> 0EAB 0E99 +0EDD <compat> 0EAB 0EA1 +0F0C <noBreak> 0F0B +0F43 0F42 0FB7 +0F4D 0F4C 0FB7 +0F52 0F51 0FB7 +0F57 0F56 0FB7 +0F5C 0F5B 0FB7 +0F69 0F40 0FB5 +0F73 0F71 0F72 +0F75 0F71 0F74 +0F76 0FB2 0F80 +0F77 <compat> 0FB2 0F81 +0F78 0FB3 0F80 +0F79 <compat> 0FB3 0F81 +0F81 0F71 0F80 +0F93 0F92 0FB7 +0F9D 0F9C 0FB7 +0FA2 0FA1 0FB7 +0FA7 0FA6 0FB7 +0FAC 0FAB 0FB7 +0FB9 0F90 0FB5 +1026 1025 102E +1E00 0041 0325 +1E01 0061 0325 +1E02 0042 0307 +1E03 0062 0307 +1E04 0042 0323 +1E05 0062 0323 +1E06 0042 0331 +1E07 0062 0331 +1E08 00C7 0301 +1E09 00E7 0301 +1E0A 0044 0307 +1E0B 0064 0307 +1E0C 0044 0323 +1E0D 0064 0323 +1E0E 0044 0331 +1E0F 0064 0331 +1E10 0044 0327 +1E11 0064 0327 +1E12 0044 032D +1E13 0064 032D +1E14 0112 0300 +1E15 0113 0300 +1E16 0112 0301 +1E17 0113 0301 +1E18 0045 032D +1E19 0065 032D +1E1A 0045 0330 +1E1B 0065 0330 +1E1C 0228 0306 +1E1D 0229 0306 +1E1E 0046 0307 +1E1F 0066 0307 +1E20 0047 0304 +1E21 0067 0304 +1E22 0048 0307 +1E23 0068 0307 +1E24 0048 0323 +1E25 0068 0323 +1E26 0048 0308 +1E27 0068 0308 +1E28 0048 0327 +1E29 0068 0327 +1E2A 0048 032E +1E2B 0068 032E +1E2C 0049 0330 +1E2D 0069 0330 +1E2E 00CF 0301 +1E2F 00EF 0301 +1E30 004B 0301 +1E31 006B 0301 +1E32 004B 0323 +1E33 006B 0323 +1E34 004B 0331 +1E35 006B 0331 +1E36 004C 0323 +1E37 006C 0323 +1E38 1E36 0304 +1E39 1E37 0304 +1E3A 004C 0331 +1E3B 006C 0331 +1E3C 004C 032D +1E3D 006C 032D +1E3E 004D 0301 +1E3F 006D 0301 +1E40 004D 0307 +1E41 006D 0307 +1E42 004D 0323 +1E43 006D 0323 +1E44 004E 0307 +1E45 006E 0307 +1E46 004E 0323 +1E47 006E 0323 +1E48 004E 0331 +1E49 006E 0331 +1E4A 004E 032D +1E4B 006E 032D +1E4C 00D5 0301 +1E4D 00F5 0301 +1E4E 00D5 0308 +1E4F 00F5 0308 +1E50 014C 0300 +1E51 014D 0300 +1E52 014C 0301 +1E53 014D 0301 +1E54 0050 0301 +1E55 0070 0301 +1E56 0050 0307 +1E57 0070 0307 +1E58 0052 0307 +1E59 0072 0307 +1E5A 0052 0323 +1E5B 0072 0323 +1E5C 1E5A 0304 +1E5D 1E5B 0304 +1E5E 0052 0331 +1E5F 0072 0331 +1E60 0053 0307 +1E61 0073 0307 +1E62 0053 0323 +1E63 0073 0323 +1E64 015A 0307 +1E65 015B 0307 +1E66 0160 0307 +1E67 0161 0307 +1E68 1E62 0307 +1E69 1E63 0307 +1E6A 0054 0307 +1E6B 0074 0307 +1E6C 0054 0323 +1E6D 0074 0323 +1E6E 0054 0331 +1E6F 0074 0331 +1E70 0054 032D +1E71 0074 032D +1E72 0055 0324 +1E73 0075 0324 +1E74 0055 0330 +1E75 0075 0330 +1E76 0055 032D +1E77 0075 032D +1E78 0168 0301 +1E79 0169 0301 +1E7A 016A 0308 +1E7B 016B 0308 +1E7C 0056 0303 +1E7D 0076 0303 +1E7E 0056 0323 +1E7F 0076 0323 +1E80 0057 0300 +1E81 0077 0300 +1E82 0057 0301 +1E83 0077 0301 +1E84 0057 0308 +1E85 0077 0308 +1E86 0057 0307 +1E87 0077 0307 +1E88 0057 0323 +1E89 0077 0323 +1E8A 0058 0307 +1E8B 0078 0307 +1E8C 0058 0308 +1E8D 0078 0308 +1E8E 0059 0307 +1E8F 0079 0307 +1E90 005A 0302 +1E91 007A 0302 +1E92 005A 0323 +1E93 007A 0323 +1E94 005A 0331 +1E95 007A 0331 +1E96 0068 0331 +1E97 0074 0308 +1E98 0077 030A +1E99 0079 030A +1E9A <compat> 0061 02BE +1E9B 017F 0307 +1EA0 0041 0323 +1EA1 0061 0323 +1EA2 0041 0309 +1EA3 0061 0309 +1EA4 00C2 0301 +1EA5 00E2 0301 +1EA6 00C2 0300 +1EA7 00E2 0300 +1EA8 00C2 0309 +1EA9 00E2 0309 +1EAA 00C2 0303 +1EAB 00E2 0303 +1EAC 1EA0 0302 +1EAD 1EA1 0302 +1EAE 0102 0301 +1EAF 0103 0301 +1EB0 0102 0300 +1EB1 0103 0300 +1EB2 0102 0309 +1EB3 0103 0309 +1EB4 0102 0303 +1EB5 0103 0303 +1EB6 1EA0 0306 +1EB7 1EA1 0306 +1EB8 0045 0323 +1EB9 0065 0323 +1EBA 0045 0309 +1EBB 0065 0309 +1EBC 0045 0303 +1EBD 0065 0303 +1EBE 00CA 0301 +1EBF 00EA 0301 +1EC0 00CA 0300 +1EC1 00EA 0300 +1EC2 00CA 0309 +1EC3 00EA 0309 +1EC4 00CA 0303 +1EC5 00EA 0303 +1EC6 1EB8 0302 +1EC7 1EB9 0302 +1EC8 0049 0309 +1EC9 0069 0309 +1ECA 0049 0323 +1ECB 0069 0323 +1ECC 004F 0323 +1ECD 006F 0323 +1ECE 004F 0309 +1ECF 006F 0309 +1ED0 00D4 0301 +1ED1 00F4 0301 +1ED2 00D4 0300 +1ED3 00F4 0300 +1ED4 00D4 0309 +1ED5 00F4 0309 +1ED6 00D4 0303 +1ED7 00F4 0303 +1ED8 1ECC 0302 +1ED9 1ECD 0302 +1EDA 01A0 0301 +1EDB 01A1 0301 +1EDC 01A0 0300 +1EDD 01A1 0300 +1EDE 01A0 0309 +1EDF 01A1 0309 +1EE0 01A0 0303 +1EE1 01A1 0303 +1EE2 01A0 0323 +1EE3 01A1 0323 +1EE4 0055 0323 +1EE5 0075 0323 +1EE6 0055 0309 +1EE7 0075 0309 +1EE8 01AF 0301 +1EE9 01B0 0301 +1EEA 01AF 0300 +1EEB 01B0 0300 +1EEC 01AF 0309 +1EED 01B0 0309 +1EEE 01AF 0303 +1EEF 01B0 0303 +1EF0 01AF 0323 +1EF1 01B0 0323 +1EF2 0059 0300 +1EF3 0079 0300 +1EF4 0059 0323 +1EF5 0079 0323 +1EF6 0059 0309 +1EF7 0079 0309 +1EF8 0059 0303 +1EF9 0079 0303 +1F00 03B1 0313 +1F01 03B1 0314 +1F02 1F00 0300 +1F03 1F01 0300 +1F04 1F00 0301 +1F05 1F01 0301 +1F06 1F00 0342 +1F07 1F01 0342 +1F08 0391 0313 +1F09 0391 0314 +1F0A 1F08 0300 +1F0B 1F09 0300 +1F0C 1F08 0301 +1F0D 1F09 0301 +1F0E 1F08 0342 +1F0F 1F09 0342 +1F10 03B5 0313 +1F11 03B5 0314 +1F12 1F10 0300 +1F13 1F11 0300 +1F14 1F10 0301 +1F15 1F11 0301 +1F18 0395 0313 +1F19 0395 0314 +1F1A 1F18 0300 +1F1B 1F19 0300 +1F1C 1F18 0301 +1F1D 1F19 0301 +1F20 03B7 0313 +1F21 03B7 0314 +1F22 1F20 0300 +1F23 1F21 0300 +1F24 1F20 0301 +1F25 1F21 0301 +1F26 1F20 0342 +1F27 1F21 0342 +1F28 0397 0313 +1F29 0397 0314 +1F2A 1F28 0300 +1F2B 1F29 0300 +1F2C 1F28 0301 +1F2D 1F29 0301 +1F2E 1F28 0342 +1F2F 1F29 0342 +1F30 03B9 0313 +1F31 03B9 0314 +1F32 1F30 0300 +1F33 1F31 0300 +1F34 1F30 0301 +1F35 1F31 0301 +1F36 1F30 0342 +1F37 1F31 0342 +1F38 0399 0313 +1F39 0399 0314 +1F3A 1F38 0300 +1F3B 1F39 0300 +1F3C 1F38 0301 +1F3D 1F39 0301 +1F3E 1F38 0342 +1F3F 1F39 0342 +1F40 03BF 0313 +1F41 03BF 0314 +1F42 1F40 0300 +1F43 1F41 0300 +1F44 1F40 0301 +1F45 1F41 0301 +1F48 039F 0313 +1F49 039F 0314 +1F4A 1F48 0300 +1F4B 1F49 0300 +1F4C 1F48 0301 +1F4D 1F49 0301 +1F50 03C5 0313 +1F51 03C5 0314 +1F52 1F50 0300 +1F53 1F51 0300 +1F54 1F50 0301 +1F55 1F51 0301 +1F56 1F50 0342 +1F57 1F51 0342 +1F59 03A5 0314 +1F5B 1F59 0300 +1F5D 1F59 0301 +1F5F 1F59 0342 +1F60 03C9 0313 +1F61 03C9 0314 +1F62 1F60 0300 +1F63 1F61 0300 +1F64 1F60 0301 +1F65 1F61 0301 +1F66 1F60 0342 +1F67 1F61 0342 +1F68 03A9 0313 +1F69 03A9 0314 +1F6A 1F68 0300 +1F6B 1F69 0300 +1F6C 1F68 0301 +1F6D 1F69 0301 +1F6E 1F68 0342 +1F6F 1F69 0342 +1F70 03B1 0300 +1F71 03AC +1F72 03B5 0300 +1F73 03AD +1F74 03B7 0300 +1F75 03AE +1F76 03B9 0300 +1F77 03AF +1F78 03BF 0300 +1F79 03CC +1F7A 03C5 0300 +1F7B 03CD +1F7C 03C9 0300 +1F7D 03CE +1F80 1F00 0345 +1F81 1F01 0345 +1F82 1F02 0345 +1F83 1F03 0345 +1F84 1F04 0345 +1F85 1F05 0345 +1F86 1F06 0345 +1F87 1F07 0345 +1F88 1F08 0345 +1F89 1F09 0345 +1F8A 1F0A 0345 +1F8B 1F0B 0345 +1F8C 1F0C 0345 +1F8D 1F0D 0345 +1F8E 1F0E 0345 +1F8F 1F0F 0345 +1F90 1F20 0345 +1F91 1F21 0345 +1F92 1F22 0345 +1F93 1F23 0345 +1F94 1F24 0345 +1F95 1F25 0345 +1F96 1F26 0345 +1F97 1F27 0345 +1F98 1F28 0345 +1F99 1F29 0345 +1F9A 1F2A 0345 +1F9B 1F2B 0345 +1F9C 1F2C 0345 +1F9D 1F2D 0345 +1F9E 1F2E 0345 +1F9F 1F2F 0345 +1FA0 1F60 0345 +1FA1 1F61 0345 +1FA2 1F62 0345 +1FA3 1F63 0345 +1FA4 1F64 0345 +1FA5 1F65 0345 +1FA6 1F66 0345 +1FA7 1F67 0345 +1FA8 1F68 0345 +1FA9 1F69 0345 +1FAA 1F6A 0345 +1FAB 1F6B 0345 +1FAC 1F6C 0345 +1FAD 1F6D 0345 +1FAE 1F6E 0345 +1FAF 1F6F 0345 +1FB0 03B1 0306 +1FB1 03B1 0304 +1FB2 1F70 0345 +1FB3 03B1 0345 +1FB4 03AC 0345 +1FB6 03B1 0342 +1FB7 1FB6 0345 +1FB8 0391 0306 +1FB9 0391 0304 +1FBA 0391 0300 +1FBB 0386 +1FBC 0391 0345 +1FBD <compat> 0020 0313 +1FBE 03B9 +1FBF <compat> 0020 0313 +1FC0 <compat> 0020 0342 +1FC1 00A8 0342 +1FC2 1F74 0345 +1FC3 03B7 0345 +1FC4 03AE 0345 +1FC6 03B7 0342 +1FC7 1FC6 0345 +1FC8 0395 0300 +1FC9 0388 +1FCA 0397 0300 +1FCB 0389 +1FCC 0397 0345 +1FCD 1FBF 0300 +1FCE 1FBF 0301 +1FCF 1FBF 0342 +1FD0 03B9 0306 +1FD1 03B9 0304 +1FD2 03CA 0300 +1FD3 0390 +1FD6 03B9 0342 +1FD7 03CA 0342 +1FD8 0399 0306 +1FD9 0399 0304 +1FDA 0399 0300 +1FDB 038A +1FDD 1FFE 0300 +1FDE 1FFE 0301 +1FDF 1FFE 0342 +1FE0 03C5 0306 +1FE1 03C5 0304 +1FE2 03CB 0300 +1FE3 03B0 +1FE4 03C1 0313 +1FE5 03C1 0314 +1FE6 03C5 0342 +1FE7 03CB 0342 +1FE8 03A5 0306 +1FE9 03A5 0304 +1FEA 03A5 0300 +1FEB 038E +1FEC 03A1 0314 +1FED 00A8 0300 +1FEE 0385 +1FEF 0060 +1FF2 1F7C 0345 +1FF3 03C9 0345 +1FF4 03CE 0345 +1FF6 03C9 0342 +1FF7 1FF6 0345 +1FF8 039F 0300 +1FF9 038C +1FFA 03A9 0300 +1FFB 038F +1FFC 03A9 0345 +1FFD 00B4 +1FFE <compat> 0020 0314 +2000 2002 +2001 2003 +2002 2006 <compat> 0020 +2007 <noBreak> 0020 +2008 200A <compat> 0020 +2011 <noBreak> 2010 +2017 <compat> 0020 0333 +2024 <compat> 002E +2025 <compat> 002E 002E +2026 <compat> 002E 002E 002E +202F <noBreak> 0020 +2033 <compat> 2032 2032 +2034 <compat> 2032 2032 2032 +2036 <compat> 2035 2035 +2037 <compat> 2035 2035 2035 +203C <compat> 0021 0021 +203E <compat> 0020 0305 +2047 <compat> 003F 003F +2048 <compat> 003F 0021 +2049 <compat> 0021 003F +2057 <compat> 2032 2032 2032 2032 +205F <compat> 0020 +2070 <super> 0030 +2071 <super> 0069 +2074 <super> 0034 +2075 <super> 0035 +2076 <super> 0036 +2077 <super> 0037 +2078 <super> 0038 +2079 <super> 0039 +207A <super> 002B +207B <super> 2212 +207C <super> 003D +207D <super> 0028 +207E <super> 0029 +207F <super> 006E +2080 <sub> 0030 +2081 <sub> 0031 +2082 <sub> 0032 +2083 <sub> 0033 +2084 <sub> 0034 +2085 <sub> 0035 +2086 <sub> 0036 +2087 <sub> 0037 +2088 <sub> 0038 +2089 <sub> 0039 +208A <sub> 002B +208B <sub> 2212 +208C <sub> 003D +208D <sub> 0028 +208E <sub> 0029 +20A8 <compat> 0052 0073 +2100 <compat> 0061 002F 0063 +2101 <compat> 0061 002F 0073 +2102 <font> 0043 +2103 <compat> 00B0 0043 +2105 <compat> 0063 002F 006F +2106 <compat> 0063 002F 0075 +2107 <compat> 0190 +2109 <compat> 00B0 0046 +210A <font> 0067 +210B 210D <font> 0048 +210E <font> 0068 +210F <font> 0127 +2110 2111 <font> 0049 +2112 <font> 004C +2113 <font> 006C +2115 <font> 004E +2116 <compat> 004E 006F +2119 <font> 0050 +211A <font> 0051 +211B 211D <font> 0052 +2120 <super> 0053 004D +2121 <compat> 0054 0045 004C +2122 <super> 0054 004D +2124 <font> 005A +2126 03A9 +2128 <font> 005A +212A 004B +212B 00C5 +212C <font> 0042 +212D <font> 0043 +212F <font> 0065 +2130 <font> 0045 +2131 <font> 0046 +2133 <font> 004D +2134 <font> 006F +2135 <compat> 05D0 +2136 <compat> 05D1 +2137 <compat> 05D2 +2138 <compat> 05D3 +2139 <font> 0069 +213D <font> 03B3 +213E <font> 0393 +213F <font> 03A0 +2140 <font> 2211 +2145 <font> 0044 +2146 <font> 0064 +2147 <font> 0065 +2148 <font> 0069 +2149 <font> 006A +2153 <fraction> 0031 2044 0033 +2154 <fraction> 0032 2044 0033 +2155 <fraction> 0031 2044 0035 +2156 <fraction> 0032 2044 0035 +2157 <fraction> 0033 2044 0035 +2158 <fraction> 0034 2044 0035 +2159 <fraction> 0031 2044 0036 +215A <fraction> 0035 2044 0036 +215B <fraction> 0031 2044 0038 +215C <fraction> 0033 2044 0038 +215D <fraction> 0035 2044 0038 +215E <fraction> 0037 2044 0038 +215F <fraction> 0031 2044 +2160 <compat> 0049 +2161 <compat> 0049 0049 +2162 <compat> 0049 0049 0049 +2163 <compat> 0049 0056 +2164 <compat> 0056 +2165 <compat> 0056 0049 +2166 <compat> 0056 0049 0049 +2167 <compat> 0056 0049 0049 0049 +2168 <compat> 0049 0058 +2169 <compat> 0058 +216A <compat> 0058 0049 +216B <compat> 0058 0049 0049 +216C <compat> 004C +216D <compat> 0043 +216E <compat> 0044 +216F <compat> 004D +2170 <compat> 0069 +2171 <compat> 0069 0069 +2172 <compat> 0069 0069 0069 +2173 <compat> 0069 0076 +2174 <compat> 0076 +2175 <compat> 0076 0069 +2176 <compat> 0076 0069 0069 +2177 <compat> 0076 0069 0069 0069 +2178 <compat> 0069 0078 +2179 <compat> 0078 +217A <compat> 0078 0069 +217B <compat> 0078 0069 0069 +217C <compat> 006C +217D <compat> 0063 +217E <compat> 0064 +217F <compat> 006D +219A 2190 0338 +219B 2192 0338 +21AE 2194 0338 +21CD 21D0 0338 +21CE 21D4 0338 +21CF 21D2 0338 +2204 2203 0338 +2209 2208 0338 +220C 220B 0338 +2224 2223 0338 +2226 2225 0338 +222C <compat> 222B 222B +222D <compat> 222B 222B 222B +222F <compat> 222E 222E +2230 <compat> 222E 222E 222E +2241 223C 0338 +2244 2243 0338 +2247 2245 0338 +2249 2248 0338 +2260 003D 0338 +2262 2261 0338 +226D 224D 0338 +226E 003C 0338 +226F 003E 0338 +2270 2264 0338 +2271 2265 0338 +2274 2272 0338 +2275 2273 0338 +2278 2276 0338 +2279 2277 0338 +2280 227A 0338 +2281 227B 0338 +2284 2282 0338 +2285 2283 0338 +2288 2286 0338 +2289 2287 0338 +22AC 22A2 0338 +22AD 22A8 0338 +22AE 22A9 0338 +22AF 22AB 0338 +22E0 227C 0338 +22E1 227D 0338 +22E2 2291 0338 +22E3 2292 0338 +22EA 22B2 0338 +22EB 22B3 0338 +22EC 22B4 0338 +22ED 22B5 0338 +2329 3008 +232A 3009 +2460 <circle> 0031 +2461 <circle> 0032 +2462 <circle> 0033 +2463 <circle> 0034 +2464 <circle> 0035 +2465 <circle> 0036 +2466 <circle> 0037 +2467 <circle> 0038 +2468 <circle> 0039 +2469 <circle> 0031 0030 +246A <circle> 0031 0031 +246B <circle> 0031 0032 +246C <circle> 0031 0033 +246D <circle> 0031 0034 +246E <circle> 0031 0035 +246F <circle> 0031 0036 +2470 <circle> 0031 0037 +2471 <circle> 0031 0038 +2472 <circle> 0031 0039 +2473 <circle> 0032 0030 +2474 <compat> 0028 0031 0029 +2475 <compat> 0028 0032 0029 +2476 <compat> 0028 0033 0029 +2477 <compat> 0028 0034 0029 +2478 <compat> 0028 0035 0029 +2479 <compat> 0028 0036 0029 +247A <compat> 0028 0037 0029 +247B <compat> 0028 0038 0029 +247C <compat> 0028 0039 0029 +247D <compat> 0028 0031 0030 0029 +247E <compat> 0028 0031 0031 0029 +247F <compat> 0028 0031 0032 0029 +2480 <compat> 0028 0031 0033 0029 +2481 <compat> 0028 0031 0034 0029 +2482 <compat> 0028 0031 0035 0029 +2483 <compat> 0028 0031 0036 0029 +2484 <compat> 0028 0031 0037 0029 +2485 <compat> 0028 0031 0038 0029 +2486 <compat> 0028 0031 0039 0029 +2487 <compat> 0028 0032 0030 0029 +2488 <compat> 0031 002E +2489 <compat> 0032 002E +248A <compat> 0033 002E +248B <compat> 0034 002E +248C <compat> 0035 002E +248D <compat> 0036 002E +248E <compat> 0037 002E +248F <compat> 0038 002E +2490 <compat> 0039 002E +2491 <compat> 0031 0030 002E +2492 <compat> 0031 0031 002E +2493 <compat> 0031 0032 002E +2494 <compat> 0031 0033 002E +2495 <compat> 0031 0034 002E +2496 <compat> 0031 0035 002E +2497 <compat> 0031 0036 002E +2498 <compat> 0031 0037 002E +2499 <compat> 0031 0038 002E +249A <compat> 0031 0039 002E +249B <compat> 0032 0030 002E +249C <compat> 0028 0061 0029 +249D <compat> 0028 0062 0029 +249E <compat> 0028 0063 0029 +249F <compat> 0028 0064 0029 +24A0 <compat> 0028 0065 0029 +24A1 <compat> 0028 0066 0029 +24A2 <compat> 0028 0067 0029 +24A3 <compat> 0028 0068 0029 +24A4 <compat> 0028 0069 0029 +24A5 <compat> 0028 006A 0029 +24A6 <compat> 0028 006B 0029 +24A7 <compat> 0028 006C 0029 +24A8 <compat> 0028 006D 0029 +24A9 <compat> 0028 006E 0029 +24AA <compat> 0028 006F 0029 +24AB <compat> 0028 0070 0029 +24AC <compat> 0028 0071 0029 +24AD <compat> 0028 0072 0029 +24AE <compat> 0028 0073 0029 +24AF <compat> 0028 0074 0029 +24B0 <compat> 0028 0075 0029 +24B1 <compat> 0028 0076 0029 +24B2 <compat> 0028 0077 0029 +24B3 <compat> 0028 0078 0029 +24B4 <compat> 0028 0079 0029 +24B5 <compat> 0028 007A 0029 +24B6 <circle> 0041 +24B7 <circle> 0042 +24B8 <circle> 0043 +24B9 <circle> 0044 +24BA <circle> 0045 +24BB <circle> 0046 +24BC <circle> 0047 +24BD <circle> 0048 +24BE <circle> 0049 +24BF <circle> 004A +24C0 <circle> 004B +24C1 <circle> 004C +24C2 <circle> 004D +24C3 <circle> 004E +24C4 <circle> 004F +24C5 <circle> 0050 +24C6 <circle> 0051 +24C7 <circle> 0052 +24C8 <circle> 0053 +24C9 <circle> 0054 +24CA <circle> 0055 +24CB <circle> 0056 +24CC <circle> 0057 +24CD <circle> 0058 +24CE <circle> 0059 +24CF <circle> 005A +24D0 <circle> 0061 +24D1 <circle> 0062 +24D2 <circle> 0063 +24D3 <circle> 0064 +24D4 <circle> 0065 +24D5 <circle> 0066 +24D6 <circle> 0067 +24D7 <circle> 0068 +24D8 <circle> 0069 +24D9 <circle> 006A +24DA <circle> 006B +24DB <circle> 006C +24DC <circle> 006D +24DD <circle> 006E +24DE <circle> 006F +24DF <circle> 0070 +24E0 <circle> 0071 +24E1 <circle> 0072 +24E2 <circle> 0073 +24E3 <circle> 0074 +24E4 <circle> 0075 +24E5 <circle> 0076 +24E6 <circle> 0077 +24E7 <circle> 0078 +24E8 <circle> 0079 +24E9 <circle> 007A +24EA <circle> 0030 +2A0C <compat> 222B 222B 222B 222B +2A74 <compat> 003A 003A 003D +2A75 <compat> 003D 003D +2A76 <compat> 003D 003D 003D +2ADC 2ADD 0338 +2E9F <compat> 6BCD +2EF3 <compat> 9F9F +2F00 <compat> 4E00 +2F01 <compat> 4E28 +2F02 <compat> 4E36 +2F03 <compat> 4E3F +2F04 <compat> 4E59 +2F05 <compat> 4E85 +2F06 <compat> 4E8C +2F07 <compat> 4EA0 +2F08 <compat> 4EBA +2F09 <compat> 513F +2F0A <compat> 5165 +2F0B <compat> 516B +2F0C <compat> 5182 +2F0D <compat> 5196 +2F0E <compat> 51AB +2F0F <compat> 51E0 +2F10 <compat> 51F5 +2F11 <compat> 5200 +2F12 <compat> 529B +2F13 <compat> 52F9 +2F14 <compat> 5315 +2F15 <compat> 531A +2F16 <compat> 5338 +2F17 <compat> 5341 +2F18 <compat> 535C +2F19 <compat> 5369 +2F1A <compat> 5382 +2F1B <compat> 53B6 +2F1C <compat> 53C8 +2F1D <compat> 53E3 +2F1E <compat> 56D7 +2F1F <compat> 571F +2F20 <compat> 58EB +2F21 <compat> 5902 +2F22 <compat> 590A +2F23 <compat> 5915 +2F24 <compat> 5927 +2F25 <compat> 5973 +2F26 <compat> 5B50 +2F27 <compat> 5B80 +2F28 <compat> 5BF8 +2F29 <compat> 5C0F +2F2A <compat> 5C22 +2F2B <compat> 5C38 +2F2C <compat> 5C6E +2F2D <compat> 5C71 +2F2E <compat> 5DDB +2F2F <compat> 5DE5 +2F30 <compat> 5DF1 +2F31 <compat> 5DFE +2F32 <compat> 5E72 +2F33 <compat> 5E7A +2F34 <compat> 5E7F +2F35 <compat> 5EF4 +2F36 <compat> 5EFE +2F37 <compat> 5F0B +2F38 <compat> 5F13 +2F39 <compat> 5F50 +2F3A <compat> 5F61 +2F3B <compat> 5F73 +2F3C <compat> 5FC3 +2F3D <compat> 6208 +2F3E <compat> 6236 +2F3F <compat> 624B +2F40 <compat> 652F +2F41 <compat> 6534 +2F42 <compat> 6587 +2F43 <compat> 6597 +2F44 <compat> 65A4 +2F45 <compat> 65B9 +2F46 <compat> 65E0 +2F47 <compat> 65E5 +2F48 <compat> 66F0 +2F49 <compat> 6708 +2F4A <compat> 6728 +2F4B <compat> 6B20 +2F4C <compat> 6B62 +2F4D <compat> 6B79 +2F4E <compat> 6BB3 +2F4F <compat> 6BCB +2F50 <compat> 6BD4 +2F51 <compat> 6BDB +2F52 <compat> 6C0F +2F53 <compat> 6C14 +2F54 <compat> 6C34 +2F55 <compat> 706B +2F56 <compat> 722A +2F57 <compat> 7236 +2F58 <compat> 723B +2F59 <compat> 723F +2F5A <compat> 7247 +2F5B <compat> 7259 +2F5C <compat> 725B +2F5D <compat> 72AC +2F5E <compat> 7384 +2F5F <compat> 7389 +2F60 <compat> 74DC +2F61 <compat> 74E6 +2F62 <compat> 7518 +2F63 <compat> 751F +2F64 <compat> 7528 +2F65 <compat> 7530 +2F66 <compat> 758B +2F67 <compat> 7592 +2F68 <compat> 7676 +2F69 <compat> 767D +2F6A <compat> 76AE +2F6B <compat> 76BF +2F6C <compat> 76EE +2F6D <compat> 77DB +2F6E <compat> 77E2 +2F6F <compat> 77F3 +2F70 <compat> 793A +2F71 <compat> 79B8 +2F72 <compat> 79BE +2F73 <compat> 7A74 +2F74 <compat> 7ACB +2F75 <compat> 7AF9 +2F76 <compat> 7C73 +2F77 <compat> 7CF8 +2F78 <compat> 7F36 +2F79 <compat> 7F51 +2F7A <compat> 7F8A +2F7B <compat> 7FBD +2F7C <compat> 8001 +2F7D <compat> 800C +2F7E <compat> 8012 +2F7F <compat> 8033 +2F80 <compat> 807F +2F81 <compat> 8089 +2F82 <compat> 81E3 +2F83 <compat> 81EA +2F84 <compat> 81F3 +2F85 <compat> 81FC +2F86 <compat> 820C +2F87 <compat> 821B +2F88 <compat> 821F +2F89 <compat> 826E +2F8A <compat> 8272 +2F8B <compat> 8278 +2F8C <compat> 864D +2F8D <compat> 866B +2F8E <compat> 8840 +2F8F <compat> 884C +2F90 <compat> 8863 +2F91 <compat> 897E +2F92 <compat> 898B +2F93 <compat> 89D2 +2F94 <compat> 8A00 +2F95 <compat> 8C37 +2F96 <compat> 8C46 +2F97 <compat> 8C55 +2F98 <compat> 8C78 +2F99 <compat> 8C9D +2F9A <compat> 8D64 +2F9B <compat> 8D70 +2F9C <compat> 8DB3 +2F9D <compat> 8EAB +2F9E <compat> 8ECA +2F9F <compat> 8F9B +2FA0 <compat> 8FB0 +2FA1 <compat> 8FB5 +2FA2 <compat> 9091 +2FA3 <compat> 9149 +2FA4 <compat> 91C6 +2FA5 <compat> 91CC +2FA6 <compat> 91D1 +2FA7 <compat> 9577 +2FA8 <compat> 9580 +2FA9 <compat> 961C +2FAA <compat> 96B6 +2FAB <compat> 96B9 +2FAC <compat> 96E8 +2FAD <compat> 9751 +2FAE <compat> 975E +2FAF <compat> 9762 +2FB0 <compat> 9769 +2FB1 <compat> 97CB +2FB2 <compat> 97ED +2FB3 <compat> 97F3 +2FB4 <compat> 9801 +2FB5 <compat> 98A8 +2FB6 <compat> 98DB +2FB7 <compat> 98DF +2FB8 <compat> 9996 +2FB9 <compat> 9999 +2FBA <compat> 99AC +2FBB <compat> 9AA8 +2FBC <compat> 9AD8 +2FBD <compat> 9ADF +2FBE <compat> 9B25 +2FBF <compat> 9B2F +2FC0 <compat> 9B32 +2FC1 <compat> 9B3C +2FC2 <compat> 9B5A +2FC3 <compat> 9CE5 +2FC4 <compat> 9E75 +2FC5 <compat> 9E7F +2FC6 <compat> 9EA5 +2FC7 <compat> 9EBB +2FC8 <compat> 9EC3 +2FC9 <compat> 9ECD +2FCA <compat> 9ED1 +2FCB <compat> 9EF9 +2FCC <compat> 9EFD +2FCD <compat> 9F0E +2FCE <compat> 9F13 +2FCF <compat> 9F20 +2FD0 <compat> 9F3B +2FD1 <compat> 9F4A +2FD2 <compat> 9F52 +2FD3 <compat> 9F8D +2FD4 <compat> 9F9C +2FD5 <compat> 9FA0 +3000 <wide> 0020 +3036 <compat> 3012 +3038 <compat> 5341 +3039 <compat> 5344 +303A <compat> 5345 +304C 304B 3099 +304E 304D 3099 +3050 304F 3099 +3052 3051 3099 +3054 3053 3099 +3056 3055 3099 +3058 3057 3099 +305A 3059 3099 +305C 305B 3099 +305E 305D 3099 +3060 305F 3099 +3062 3061 3099 +3065 3064 3099 +3067 3066 3099 +3069 3068 3099 +3070 306F 3099 +3071 306F 309A +3073 3072 3099 +3074 3072 309A +3076 3075 3099 +3077 3075 309A +3079 3078 3099 +307A 3078 309A +307C 307B 3099 +307D 307B 309A +3094 3046 3099 +309B <compat> 0020 3099 +309C <compat> 0020 309A +309E 309D 3099 +309F <vertical> 3088 308A +30AC 30AB 3099 +30AE 30AD 3099 +30B0 30AF 3099 +30B2 30B1 3099 +30B4 30B3 3099 +30B6 30B5 3099 +30B8 30B7 3099 +30BA 30B9 3099 +30BC 30BB 3099 +30BE 30BD 3099 +30C0 30BF 3099 +30C2 30C1 3099 +30C5 30C4 3099 +30C7 30C6 3099 +30C9 30C8 3099 +30D0 30CF 3099 +30D1 30CF 309A +30D3 30D2 3099 +30D4 30D2 309A +30D6 30D5 3099 +30D7 30D5 309A +30D9 30D8 3099 +30DA 30D8 309A +30DC 30DB 3099 +30DD 30DB 309A +30F4 30A6 3099 +30F7 30EF 3099 +30F8 30F0 3099 +30F9 30F1 3099 +30FA 30F2 3099 +30FE 30FD 3099 +30FF <vertical> 30B3 30C8 +3131 <compat> 1100 +3132 <compat> 1101 +3133 <compat> 11AA +3134 <compat> 1102 +3135 <compat> 11AC +3136 <compat> 11AD +3137 <compat> 1103 +3138 <compat> 1104 +3139 <compat> 1105 +313A <compat> 11B0 +313B <compat> 11B1 +313C <compat> 11B2 +313D <compat> 11B3 +313E <compat> 11B4 +313F <compat> 11B5 +3140 <compat> 111A +3141 <compat> 1106 +3142 <compat> 1107 +3143 <compat> 1108 +3144 <compat> 1121 +3145 <compat> 1109 +3146 <compat> 110A +3147 <compat> 110B +3148 <compat> 110C +3149 <compat> 110D +314A <compat> 110E +314B <compat> 110F +314C <compat> 1110 +314D <compat> 1111 +314E <compat> 1112 +314F <compat> 1161 +3150 <compat> 1162 +3151 <compat> 1163 +3152 <compat> 1164 +3153 <compat> 1165 +3154 <compat> 1166 +3155 <compat> 1167 +3156 <compat> 1168 +3157 <compat> 1169 +3158 <compat> 116A +3159 <compat> 116B +315A <compat> 116C +315B <compat> 116D +315C <compat> 116E +315D <compat> 116F +315E <compat> 1170 +315F <compat> 1171 +3160 <compat> 1172 +3161 <compat> 1173 +3162 <compat> 1174 +3163 <compat> 1175 +3164 <compat> 1160 +3165 <compat> 1114 +3166 <compat> 1115 +3167 <compat> 11C7 +3168 <compat> 11C8 +3169 <compat> 11CC +316A <compat> 11CE +316B <compat> 11D3 +316C <compat> 11D7 +316D <compat> 11D9 +316E <compat> 111C +316F <compat> 11DD +3170 <compat> 11DF +3171 <compat> 111D +3172 <compat> 111E +3173 <compat> 1120 +3174 <compat> 1122 +3175 <compat> 1123 +3176 <compat> 1127 +3177 <compat> 1129 +3178 <compat> 112B +3179 <compat> 112C +317A <compat> 112D +317B <compat> 112E +317C <compat> 112F +317D <compat> 1132 +317E <compat> 1136 +317F <compat> 1140 +3180 <compat> 1147 +3181 <compat> 114C +3182 <compat> 11F1 +3183 <compat> 11F2 +3184 <compat> 1157 +3185 <compat> 1158 +3186 <compat> 1159 +3187 <compat> 1184 +3188 <compat> 1185 +3189 <compat> 1188 +318A <compat> 1191 +318B <compat> 1192 +318C <compat> 1194 +318D <compat> 119E +318E <compat> 11A1 +3192 <super> 4E00 +3193 <super> 4E8C +3194 <super> 4E09 +3195 <super> 56DB +3196 <super> 4E0A +3197 <super> 4E2D +3198 <super> 4E0B +3199 <super> 7532 +319A <super> 4E59 +319B <super> 4E19 +319C <super> 4E01 +319D <super> 5929 +319E <super> 5730 +319F <super> 4EBA +3200 <compat> 0028 1100 0029 +3201 <compat> 0028 1102 0029 +3202 <compat> 0028 1103 0029 +3203 <compat> 0028 1105 0029 +3204 <compat> 0028 1106 0029 +3205 <compat> 0028 1107 0029 +3206 <compat> 0028 1109 0029 +3207 <compat> 0028 110B 0029 +3208 <compat> 0028 110C 0029 +3209 <compat> 0028 110E 0029 +320A <compat> 0028 110F 0029 +320B <compat> 0028 1110 0029 +320C <compat> 0028 1111 0029 +320D <compat> 0028 1112 0029 +320E <compat> 0028 1100 1161 0029 +320F <compat> 0028 1102 1161 0029 +3210 <compat> 0028 1103 1161 0029 +3211 <compat> 0028 1105 1161 0029 +3212 <compat> 0028 1106 1161 0029 +3213 <compat> 0028 1107 1161 0029 +3214 <compat> 0028 1109 1161 0029 +3215 <compat> 0028 110B 1161 0029 +3216 <compat> 0028 110C 1161 0029 +3217 <compat> 0028 110E 1161 0029 +3218 <compat> 0028 110F 1161 0029 +3219 <compat> 0028 1110 1161 0029 +321A <compat> 0028 1111 1161 0029 +321B <compat> 0028 1112 1161 0029 +321C <compat> 0028 110C 116E 0029 +3220 <compat> 0028 4E00 0029 +3221 <compat> 0028 4E8C 0029 +3222 <compat> 0028 4E09 0029 +3223 <compat> 0028 56DB 0029 +3224 <compat> 0028 4E94 0029 +3225 <compat> 0028 516D 0029 +3226 <compat> 0028 4E03 0029 +3227 <compat> 0028 516B 0029 +3228 <compat> 0028 4E5D 0029 +3229 <compat> 0028 5341 0029 +322A <compat> 0028 6708 0029 +322B <compat> 0028 706B 0029 +322C <compat> 0028 6C34 0029 +322D <compat> 0028 6728 0029 +322E <compat> 0028 91D1 0029 +322F <compat> 0028 571F 0029 +3230 <compat> 0028 65E5 0029 +3231 <compat> 0028 682A 0029 +3232 <compat> 0028 6709 0029 +3233 <compat> 0028 793E 0029 +3234 <compat> 0028 540D 0029 +3235 <compat> 0028 7279 0029 +3236 <compat> 0028 8CA1 0029 +3237 <compat> 0028 795D 0029 +3238 <compat> 0028 52B4 0029 +3239 <compat> 0028 4EE3 0029 +323A <compat> 0028 547C 0029 +323B <compat> 0028 5B66 0029 +323C <compat> 0028 76E3 0029 +323D <compat> 0028 4F01 0029 +323E <compat> 0028 8CC7 0029 +323F <compat> 0028 5354 0029 +3240 <compat> 0028 796D 0029 +3241 <compat> 0028 4F11 0029 +3242 <compat> 0028 81EA 0029 +3243 <compat> 0028 81F3 0029 +3251 <circle> 0032 0031 +3252 <circle> 0032 0032 +3253 <circle> 0032 0033 +3254 <circle> 0032 0034 +3255 <circle> 0032 0035 +3256 <circle> 0032 0036 +3257 <circle> 0032 0037 +3258 <circle> 0032 0038 +3259 <circle> 0032 0039 +325A <circle> 0033 0030 +325B <circle> 0033 0031 +325C <circle> 0033 0032 +325D <circle> 0033 0033 +325E <circle> 0033 0034 +325F <circle> 0033 0035 +3260 <circle> 1100 +3261 <circle> 1102 +3262 <circle> 1103 +3263 <circle> 1105 +3264 <circle> 1106 +3265 <circle> 1107 +3266 <circle> 1109 +3267 <circle> 110B +3268 <circle> 110C +3269 <circle> 110E +326A <circle> 110F +326B <circle> 1110 +326C <circle> 1111 +326D <circle> 1112 +326E <circle> 1100 1161 +326F <circle> 1102 1161 +3270 <circle> 1103 1161 +3271 <circle> 1105 1161 +3272 <circle> 1106 1161 +3273 <circle> 1107 1161 +3274 <circle> 1109 1161 +3275 <circle> 110B 1161 +3276 <circle> 110C 1161 +3277 <circle> 110E 1161 +3278 <circle> 110F 1161 +3279 <circle> 1110 1161 +327A <circle> 1111 1161 +327B <circle> 1112 1161 +3280 <circle> 4E00 +3281 <circle> 4E8C +3282 <circle> 4E09 +3283 <circle> 56DB +3284 <circle> 4E94 +3285 <circle> 516D +3286 <circle> 4E03 +3287 <circle> 516B +3288 <circle> 4E5D +3289 <circle> 5341 +328A <circle> 6708 +328B <circle> 706B +328C <circle> 6C34 +328D <circle> 6728 +328E <circle> 91D1 +328F <circle> 571F +3290 <circle> 65E5 +3291 <circle> 682A +3292 <circle> 6709 +3293 <circle> 793E +3294 <circle> 540D +3295 <circle> 7279 +3296 <circle> 8CA1 +3297 <circle> 795D +3298 <circle> 52B4 +3299 <circle> 79D8 +329A <circle> 7537 +329B <circle> 5973 +329C <circle> 9069 +329D <circle> 512A +329E <circle> 5370 +329F <circle> 6CE8 +32A0 <circle> 9805 +32A1 <circle> 4F11 +32A2 <circle> 5199 +32A3 <circle> 6B63 +32A4 <circle> 4E0A +32A5 <circle> 4E2D +32A6 <circle> 4E0B +32A7 <circle> 5DE6 +32A8 <circle> 53F3 +32A9 <circle> 533B +32AA <circle> 5B97 +32AB <circle> 5B66 +32AC <circle> 76E3 +32AD <circle> 4F01 +32AE <circle> 8CC7 +32AF <circle> 5354 +32B0 <circle> 591C +32B1 <circle> 0033 0036 +32B2 <circle> 0033 0037 +32B3 <circle> 0033 0038 +32B4 <circle> 0033 0039 +32B5 <circle> 0034 0030 +32B6 <circle> 0034 0031 +32B7 <circle> 0034 0032 +32B8 <circle> 0034 0033 +32B9 <circle> 0034 0034 +32BA <circle> 0034 0035 +32BB <circle> 0034 0036 +32BC <circle> 0034 0037 +32BD <circle> 0034 0038 +32BE <circle> 0034 0039 +32BF <circle> 0035 0030 +32C0 <compat> 0031 6708 +32C1 <compat> 0032 6708 +32C2 <compat> 0033 6708 +32C3 <compat> 0034 6708 +32C4 <compat> 0035 6708 +32C5 <compat> 0036 6708 +32C6 <compat> 0037 6708 +32C7 <compat> 0038 6708 +32C8 <compat> 0039 6708 +32C9 <compat> 0031 0030 6708 +32CA <compat> 0031 0031 6708 +32CB <compat> 0031 0032 6708 +32D0 <circle> 30A2 +32D1 <circle> 30A4 +32D2 <circle> 30A6 +32D3 <circle> 30A8 +32D4 <circle> 30AA +32D5 <circle> 30AB +32D6 <circle> 30AD +32D7 <circle> 30AF +32D8 <circle> 30B1 +32D9 <circle> 30B3 +32DA <circle> 30B5 +32DB <circle> 30B7 +32DC <circle> 30B9 +32DD <circle> 30BB +32DE <circle> 30BD +32DF <circle> 30BF +32E0 <circle> 30C1 +32E1 <circle> 30C4 +32E2 <circle> 30C6 +32E3 <circle> 30C8 +32E4 <circle> 30CA +32E5 <circle> 30CB +32E6 <circle> 30CC +32E7 <circle> 30CD +32E8 <circle> 30CE +32E9 <circle> 30CF +32EA <circle> 30D2 +32EB <circle> 30D5 +32EC <circle> 30D8 +32ED <circle> 30DB +32EE <circle> 30DE +32EF <circle> 30DF +32F0 <circle> 30E0 +32F1 <circle> 30E1 +32F2 <circle> 30E2 +32F3 <circle> 30E4 +32F4 <circle> 30E6 +32F5 <circle> 30E8 +32F6 <circle> 30E9 +32F7 <circle> 30EA +32F8 <circle> 30EB +32F9 <circle> 30EC +32FA <circle> 30ED +32FB <circle> 30EF +32FC <circle> 30F0 +32FD <circle> 30F1 +32FE <circle> 30F2 +3300 <square> 30A2 30D1 30FC 30C8 +3301 <square> 30A2 30EB 30D5 30A1 +3302 <square> 30A2 30F3 30DA 30A2 +3303 <square> 30A2 30FC 30EB +3304 <square> 30A4 30CB 30F3 30B0 +3305 <square> 30A4 30F3 30C1 +3306 <square> 30A6 30A9 30F3 +3307 <square> 30A8 30B9 30AF 30FC 30C9 +3308 <square> 30A8 30FC 30AB 30FC +3309 <square> 30AA 30F3 30B9 +330A <square> 30AA 30FC 30E0 +330B <square> 30AB 30A4 30EA +330C <square> 30AB 30E9 30C3 30C8 +330D <square> 30AB 30ED 30EA 30FC +330E <square> 30AC 30ED 30F3 +330F <square> 30AC 30F3 30DE +3310 <square> 30AE 30AC +3311 <square> 30AE 30CB 30FC +3312 <square> 30AD 30E5 30EA 30FC +3313 <square> 30AE 30EB 30C0 30FC +3314 <square> 30AD 30ED +3315 <square> 30AD 30ED 30B0 30E9 30E0 +3316 <square> 30AD 30ED 30E1 30FC 30C8 30EB +3317 <square> 30AD 30ED 30EF 30C3 30C8 +3318 <square> 30B0 30E9 30E0 +3319 <square> 30B0 30E9 30E0 30C8 30F3 +331A <square> 30AF 30EB 30BC 30A4 30ED +331B <square> 30AF 30ED 30FC 30CD +331C <square> 30B1 30FC 30B9 +331D <square> 30B3 30EB 30CA +331E <square> 30B3 30FC 30DD +331F <square> 30B5 30A4 30AF 30EB +3320 <square> 30B5 30F3 30C1 30FC 30E0 +3321 <square> 30B7 30EA 30F3 30B0 +3322 <square> 30BB 30F3 30C1 +3323 <square> 30BB 30F3 30C8 +3324 <square> 30C0 30FC 30B9 +3325 <square> 30C7 30B7 +3326 <square> 30C9 30EB +3327 <square> 30C8 30F3 +3328 <square> 30CA 30CE +3329 <square> 30CE 30C3 30C8 +332A <square> 30CF 30A4 30C4 +332B <square> 30D1 30FC 30BB 30F3 30C8 +332C <square> 30D1 30FC 30C4 +332D <square> 30D0 30FC 30EC 30EB +332E <square> 30D4 30A2 30B9 30C8 30EB +332F <square> 30D4 30AF 30EB +3330 <square> 30D4 30B3 +3331 <square> 30D3 30EB +3332 <square> 30D5 30A1 30E9 30C3 30C9 +3333 <square> 30D5 30A3 30FC 30C8 +3334 <square> 30D6 30C3 30B7 30A7 30EB +3335 <square> 30D5 30E9 30F3 +3336 <square> 30D8 30AF 30BF 30FC 30EB +3337 <square> 30DA 30BD +3338 <square> 30DA 30CB 30D2 +3339 <square> 30D8 30EB 30C4 +333A <square> 30DA 30F3 30B9 +333B <square> 30DA 30FC 30B8 +333C <square> 30D9 30FC 30BF +333D <square> 30DD 30A4 30F3 30C8 +333E <square> 30DC 30EB 30C8 +333F <square> 30DB 30F3 +3340 <square> 30DD 30F3 30C9 +3341 <square> 30DB 30FC 30EB +3342 <square> 30DB 30FC 30F3 +3343 <square> 30DE 30A4 30AF 30ED +3344 <square> 30DE 30A4 30EB +3345 <square> 30DE 30C3 30CF +3346 <square> 30DE 30EB 30AF +3347 <square> 30DE 30F3 30B7 30E7 30F3 +3348 <square> 30DF 30AF 30ED 30F3 +3349 <square> 30DF 30EA +334A <square> 30DF 30EA 30D0 30FC 30EB +334B <square> 30E1 30AC +334C <square> 30E1 30AC 30C8 30F3 +334D <square> 30E1 30FC 30C8 30EB +334E <square> 30E4 30FC 30C9 +334F <square> 30E4 30FC 30EB +3350 <square> 30E6 30A2 30F3 +3351 <square> 30EA 30C3 30C8 30EB +3352 <square> 30EA 30E9 +3353 <square> 30EB 30D4 30FC +3354 <square> 30EB 30FC 30D6 30EB +3355 <square> 30EC 30E0 +3356 <square> 30EC 30F3 30C8 30B2 30F3 +3357 <square> 30EF 30C3 30C8 +3358 <compat> 0030 70B9 +3359 <compat> 0031 70B9 +335A <compat> 0032 70B9 +335B <compat> 0033 70B9 +335C <compat> 0034 70B9 +335D <compat> 0035 70B9 +335E <compat> 0036 70B9 +335F <compat> 0037 70B9 +3360 <compat> 0038 70B9 +3361 <compat> 0039 70B9 +3362 <compat> 0031 0030 70B9 +3363 <compat> 0031 0031 70B9 +3364 <compat> 0031 0032 70B9 +3365 <compat> 0031 0033 70B9 +3366 <compat> 0031 0034 70B9 +3367 <compat> 0031 0035 70B9 +3368 <compat> 0031 0036 70B9 +3369 <compat> 0031 0037 70B9 +336A <compat> 0031 0038 70B9 +336B <compat> 0031 0039 70B9 +336C <compat> 0032 0030 70B9 +336D <compat> 0032 0031 70B9 +336E <compat> 0032 0032 70B9 +336F <compat> 0032 0033 70B9 +3370 <compat> 0032 0034 70B9 +3371 <square> 0068 0050 0061 +3372 <square> 0064 0061 +3373 <square> 0041 0055 +3374 <square> 0062 0061 0072 +3375 <square> 006F 0056 +3376 <square> 0070 0063 +337B <square> 5E73 6210 +337C <square> 662D 548C +337D <square> 5927 6B63 +337E <square> 660E 6CBB +337F <square> 682A 5F0F 4F1A 793E +3380 <square> 0070 0041 +3381 <square> 006E 0041 +3382 <square> 03BC 0041 +3383 <square> 006D 0041 +3384 <square> 006B 0041 +3385 <square> 004B 0042 +3386 <square> 004D 0042 +3387 <square> 0047 0042 +3388 <square> 0063 0061 006C +3389 <square> 006B 0063 0061 006C +338A <square> 0070 0046 +338B <square> 006E 0046 +338C <square> 03BC 0046 +338D <square> 03BC 0067 +338E <square> 006D 0067 +338F <square> 006B 0067 +3390 <square> 0048 007A +3391 <square> 006B 0048 007A +3392 <square> 004D 0048 007A +3393 <square> 0047 0048 007A +3394 <square> 0054 0048 007A +3395 <square> 03BC 2113 +3396 <square> 006D 2113 +3397 <square> 0064 2113 +3398 <square> 006B 2113 +3399 <square> 0066 006D +339A <square> 006E 006D +339B <square> 03BC 006D +339C <square> 006D 006D +339D <square> 0063 006D +339E <square> 006B 006D +339F <square> 006D 006D 00B2 +33A0 <square> 0063 006D 00B2 +33A1 <square> 006D 00B2 +33A2 <square> 006B 006D 00B2 +33A3 <square> 006D 006D 00B3 +33A4 <square> 0063 006D 00B3 +33A5 <square> 006D 00B3 +33A6 <square> 006B 006D 00B3 +33A7 <square> 006D 2215 0073 +33A8 <square> 006D 2215 0073 00B2 +33A9 <square> 0050 0061 +33AA <square> 006B 0050 0061 +33AB <square> 004D 0050 0061 +33AC <square> 0047 0050 0061 +33AD <square> 0072 0061 0064 +33AE <square> 0072 0061 0064 2215 0073 +33AF <square> 0072 0061 0064 2215 0073 00B2 +33B0 <square> 0070 0073 +33B1 <square> 006E 0073 +33B2 <square> 03BC 0073 +33B3 <square> 006D 0073 +33B4 <square> 0070 0056 +33B5 <square> 006E 0056 +33B6 <square> 03BC 0056 +33B7 <square> 006D 0056 +33B8 <square> 006B 0056 +33B9 <square> 004D 0056 +33BA <square> 0070 0057 +33BB <square> 006E 0057 +33BC <square> 03BC 0057 +33BD <square> 006D 0057 +33BE <square> 006B 0057 +33BF <square> 004D 0057 +33C0 <square> 006B 03A9 +33C1 <square> 004D 03A9 +33C2 <square> 0061 002E 006D 002E +33C3 <square> 0042 0071 +33C4 <square> 0063 0063 +33C5 <square> 0063 0064 +33C6 <square> 0043 2215 006B 0067 +33C7 <square> 0043 006F 002E +33C8 <square> 0064 0042 +33C9 <square> 0047 0079 +33CA <square> 0068 0061 +33CB <square> 0048 0050 +33CC <square> 0069 006E +33CD <square> 004B 004B +33CE <square> 004B 004D +33CF <square> 006B 0074 +33D0 <square> 006C 006D +33D1 <square> 006C 006E +33D2 <square> 006C 006F 0067 +33D3 <square> 006C 0078 +33D4 <square> 006D 0062 +33D5 <square> 006D 0069 006C +33D6 <square> 006D 006F 006C +33D7 <square> 0050 0048 +33D8 <square> 0070 002E 006D 002E +33D9 <square> 0050 0050 004D +33DA <square> 0050 0052 +33DB <square> 0073 0072 +33DC <square> 0053 0076 +33DD <square> 0057 0062 +33E0 <compat> 0031 65E5 +33E1 <compat> 0032 65E5 +33E2 <compat> 0033 65E5 +33E3 <compat> 0034 65E5 +33E4 <compat> 0035 65E5 +33E5 <compat> 0036 65E5 +33E6 <compat> 0037 65E5 +33E7 <compat> 0038 65E5 +33E8 <compat> 0039 65E5 +33E9 <compat> 0031 0030 65E5 +33EA <compat> 0031 0031 65E5 +33EB <compat> 0031 0032 65E5 +33EC <compat> 0031 0033 65E5 +33ED <compat> 0031 0034 65E5 +33EE <compat> 0031 0035 65E5 +33EF <compat> 0031 0036 65E5 +33F0 <compat> 0031 0037 65E5 +33F1 <compat> 0031 0038 65E5 +33F2 <compat> 0031 0039 65E5 +33F3 <compat> 0032 0030 65E5 +33F4 <compat> 0032 0031 65E5 +33F5 <compat> 0032 0032 65E5 +33F6 <compat> 0032 0033 65E5 +33F7 <compat> 0032 0034 65E5 +33F8 <compat> 0032 0035 65E5 +33F9 <compat> 0032 0036 65E5 +33FA <compat> 0032 0037 65E5 +33FB <compat> 0032 0038 65E5 +33FC <compat> 0032 0039 65E5 +33FD <compat> 0033 0030 65E5 +33FE <compat> 0033 0031 65E5 +F900 8C48 +F901 66F4 +F902 8ECA +F903 8CC8 +F904 6ED1 +F905 4E32 +F906 53E5 +F907 F908 9F9C +F909 5951 +F90A 91D1 +F90B 5587 +F90C 5948 +F90D 61F6 +F90E 7669 +F90F 7F85 +F910 863F +F911 87BA +F912 88F8 +F913 908F +F914 6A02 +F915 6D1B +F916 70D9 +F917 73DE +F918 843D +F919 916A +F91A 99F1 +F91B 4E82 +F91C 5375 +F91D 6B04 +F91E 721B +F91F 862D +F920 9E1E +F921 5D50 +F922 6FEB +F923 85CD +F924 8964 +F925 62C9 +F926 81D8 +F927 881F +F928 5ECA +F929 6717 +F92A 6D6A +F92B 72FC +F92C 90CE +F92D 4F86 +F92E 51B7 +F92F 52DE +F930 64C4 +F931 6AD3 +F932 7210 +F933 76E7 +F934 8001 +F935 8606 +F936 865C +F937 8DEF +F938 9732 +F939 9B6F +F93A 9DFA +F93B 788C +F93C 797F +F93D 7DA0 +F93E 83C9 +F93F 9304 +F940 9E7F +F941 8AD6 +F942 58DF +F943 5F04 +F944 7C60 +F945 807E +F946 7262 +F947 78CA +F948 8CC2 +F949 96F7 +F94A 58D8 +F94B 5C62 +F94C 6A13 +F94D 6DDA +F94E 6F0F +F94F 7D2F +F950 7E37 +F951 964B +F952 52D2 +F953 808B +F954 51DC +F955 51CC +F956 7A1C +F957 7DBE +F958 83F1 +F959 9675 +F95A 8B80 +F95B 62CF +F95C 6A02 +F95D 8AFE +F95E 4E39 +F95F 5BE7 +F960 6012 +F961 7387 +F962 7570 +F963 5317 +F964 78FB +F965 4FBF +F966 5FA9 +F967 4E0D +F968 6CCC +F969 6578 +F96A 7D22 +F96B 53C3 +F96C 585E +F96D 7701 +F96E 8449 +F96F 8AAA +F970 6BBA +F971 8FB0 +F972 6C88 +F973 62FE +F974 82E5 +F975 63A0 +F976 7565 +F977 4EAE +F978 5169 +F979 51C9 +F97A 6881 +F97B 7CE7 +F97C 826F +F97D 8AD2 +F97E 91CF +F97F 52F5 +F980 5442 +F981 5973 +F982 5EEC +F983 65C5 +F984 6FFE +F985 792A +F986 95AD +F987 9A6A +F988 9E97 +F989 9ECE +F98A 529B +F98B 66C6 +F98C 6B77 +F98D 8F62 +F98E 5E74 +F98F 6190 +F990 6200 +F991 649A +F992 6F23 +F993 7149 +F994 7489 +F995 79CA +F996 7DF4 +F997 806F +F998 8F26 +F999 84EE +F99A 9023 +F99B 934A +F99C 5217 +F99D 52A3 +F99E 54BD +F99F 70C8 +F9A0 88C2 +F9A1 8AAA +F9A2 5EC9 +F9A3 5FF5 +F9A4 637B +F9A5 6BAE +F9A6 7C3E +F9A7 7375 +F9A8 4EE4 +F9A9 56F9 +F9AA 5BE7 +F9AB 5DBA +F9AC 601C +F9AD 73B2 +F9AE 7469 +F9AF 7F9A +F9B0 8046 +F9B1 9234 +F9B2 96F6 +F9B3 9748 +F9B4 9818 +F9B5 4F8B +F9B6 79AE +F9B7 91B4 +F9B8 96B8 +F9B9 60E1 +F9BA 4E86 +F9BB 50DA +F9BC 5BEE +F9BD 5C3F +F9BE 6599 +F9BF 6A02 +F9C0 71CE +F9C1 7642 +F9C2 84FC +F9C3 907C +F9C4 9F8D +F9C5 6688 +F9C6 962E +F9C7 5289 +F9C8 677B +F9C9 67F3 +F9CA 6D41 +F9CB 6E9C +F9CC 7409 +F9CD 7559 +F9CE 786B +F9CF 7D10 +F9D0 985E +F9D1 516D +F9D2 622E +F9D3 9678 +F9D4 502B +F9D5 5D19 +F9D6 6DEA +F9D7 8F2A +F9D8 5F8B +F9D9 6144 +F9DA 6817 +F9DB 7387 +F9DC 9686 +F9DD 5229 +F9DE 540F +F9DF 5C65 +F9E0 6613 +F9E1 674E +F9E2 68A8 +F9E3 6CE5 +F9E4 7406 +F9E5 75E2 +F9E6 7F79 +F9E7 88CF +F9E8 88E1 +F9E9 91CC +F9EA 96E2 +F9EB 533F +F9EC 6EBA +F9ED 541D +F9EE 71D0 +F9EF 7498 +F9F0 85FA +F9F1 96A3 +F9F2 9C57 +F9F3 9E9F +F9F4 6797 +F9F5 6DCB +F9F6 81E8 +F9F7 7ACB +F9F8 7B20 +F9F9 7C92 +F9FA 72C0 +F9FB 7099 +F9FC 8B58 +F9FD 4EC0 +F9FE 8336 +F9FF 523A +FA00 5207 +FA01 5EA6 +FA02 62D3 +FA03 7CD6 +FA04 5B85 +FA05 6D1E +FA06 66B4 +FA07 8F3B +FA08 884C +FA09 964D +FA0A 898B +FA0B 5ED3 +FA0C 5140 +FA0D 55C0 +FA10 585A +FA12 6674 +FA15 51DE +FA16 732A +FA17 76CA +FA18 793C +FA19 795E +FA1A 7965 +FA1B 798F +FA1C 9756 +FA1D 7CBE +FA1E 7FBD +FA20 8612 +FA22 8AF8 +FA25 9038 +FA26 90FD +FA2A 98EF +FA2B 98FC +FA2C 9928 +FA2D 9DB4 +FA30 4FAE +FA31 50E7 +FA32 514D +FA33 52C9 +FA34 52E4 +FA35 5351 +FA36 559D +FA37 5606 +FA38 5668 +FA39 5840 +FA3A 58A8 +FA3B 5C64 +FA3C 5C6E +FA3D 6094 +FA3E 6168 +FA3F 618E +FA40 61F2 +FA41 654F +FA42 65E2 +FA43 6691 +FA44 6885 +FA45 6D77 +FA46 6E1A +FA47 6F22 +FA48 716E +FA49 722B +FA4A 7422 +FA4B 7891 +FA4C 793E +FA4D 7949 +FA4E 7948 +FA4F 7950 +FA50 7956 +FA51 795D +FA52 798D +FA53 798E +FA54 7A40 +FA55 7A81 +FA56 7BC0 +FA57 7DF4 +FA58 7E09 +FA59 7E41 +FA5A 7F72 +FA5B 8005 +FA5C 81ED +FA5D FA5E 8279 +FA5F 8457 +FA60 8910 +FA61 8996 +FA62 8B01 +FA63 8B39 +FA64 8CD3 +FA65 8D08 +FA66 8FB6 +FA67 9038 +FA68 96E3 +FA69 97FF +FA6A 983B +FB00 <compat> 0066 0066 +FB01 <compat> 0066 0069 +FB02 <compat> 0066 006C +FB03 <compat> 0066 0066 0069 +FB04 <compat> 0066 0066 006C +FB05 <compat> 017F 0074 +FB06 <compat> 0073 0074 +FB13 <compat> 0574 0576 +FB14 <compat> 0574 0565 +FB15 <compat> 0574 056B +FB16 <compat> 057E 0576 +FB17 <compat> 0574 056D +FB1D 05D9 05B4 +FB1F 05F2 05B7 +FB20 <font> 05E2 +FB21 <font> 05D0 +FB22 <font> 05D3 +FB23 <font> 05D4 +FB24 <font> 05DB +FB25 <font> 05DC +FB26 <font> 05DD +FB27 <font> 05E8 +FB28 <font> 05EA +FB29 <font> 002B +FB2A 05E9 05C1 +FB2B 05E9 05C2 +FB2C FB49 05C1 +FB2D FB49 05C2 +FB2E 05D0 05B7 +FB2F 05D0 05B8 +FB30 05D0 05BC +FB31 05D1 05BC +FB32 05D2 05BC +FB33 05D3 05BC +FB34 05D4 05BC +FB35 05D5 05BC +FB36 05D6 05BC +FB38 05D8 05BC +FB39 05D9 05BC +FB3A 05DA 05BC +FB3B 05DB 05BC +FB3C 05DC 05BC +FB3E 05DE 05BC +FB40 05E0 05BC +FB41 05E1 05BC +FB43 05E3 05BC +FB44 05E4 05BC +FB46 05E6 05BC +FB47 05E7 05BC +FB48 05E8 05BC +FB49 05E9 05BC +FB4A 05EA 05BC +FB4B 05D5 05B9 +FB4C 05D1 05BF +FB4D 05DB 05BF +FB4E 05E4 05BF +FB4F <compat> 05D0 05DC +FB50 <isolated> 0671 +FB51 <final> 0671 +FB52 <isolated> 067B +FB53 <final> 067B +FB54 <initial> 067B +FB55 <medial> 067B +FB56 <isolated> 067E +FB57 <final> 067E +FB58 <initial> 067E +FB59 <medial> 067E +FB5A <isolated> 0680 +FB5B <final> 0680 +FB5C <initial> 0680 +FB5D <medial> 0680 +FB5E <isolated> 067A +FB5F <final> 067A +FB60 <initial> 067A +FB61 <medial> 067A +FB62 <isolated> 067F +FB63 <final> 067F +FB64 <initial> 067F +FB65 <medial> 067F +FB66 <isolated> 0679 +FB67 <final> 0679 +FB68 <initial> 0679 +FB69 <medial> 0679 +FB6A <isolated> 06A4 +FB6B <final> 06A4 +FB6C <initial> 06A4 +FB6D <medial> 06A4 +FB6E <isolated> 06A6 +FB6F <final> 06A6 +FB70 <initial> 06A6 +FB71 <medial> 06A6 +FB72 <isolated> 0684 +FB73 <final> 0684 +FB74 <initial> 0684 +FB75 <medial> 0684 +FB76 <isolated> 0683 +FB77 <final> 0683 +FB78 <initial> 0683 +FB79 <medial> 0683 +FB7A <isolated> 0686 +FB7B <final> 0686 +FB7C <initial> 0686 +FB7D <medial> 0686 +FB7E <isolated> 0687 +FB7F <final> 0687 +FB80 <initial> 0687 +FB81 <medial> 0687 +FB82 <isolated> 068D +FB83 <final> 068D +FB84 <isolated> 068C +FB85 <final> 068C +FB86 <isolated> 068E +FB87 <final> 068E +FB88 <isolated> 0688 +FB89 <final> 0688 +FB8A <isolated> 0698 +FB8B <final> 0698 +FB8C <isolated> 0691 +FB8D <final> 0691 +FB8E <isolated> 06A9 +FB8F <final> 06A9 +FB90 <initial> 06A9 +FB91 <medial> 06A9 +FB92 <isolated> 06AF +FB93 <final> 06AF +FB94 <initial> 06AF +FB95 <medial> 06AF +FB96 <isolated> 06B3 +FB97 <final> 06B3 +FB98 <initial> 06B3 +FB99 <medial> 06B3 +FB9A <isolated> 06B1 +FB9B <final> 06B1 +FB9C <initial> 06B1 +FB9D <medial> 06B1 +FB9E <isolated> 06BA +FB9F <final> 06BA +FBA0 <isolated> 06BB +FBA1 <final> 06BB +FBA2 <initial> 06BB +FBA3 <medial> 06BB +FBA4 <isolated> 06C0 +FBA5 <final> 06C0 +FBA6 <isolated> 06C1 +FBA7 <final> 06C1 +FBA8 <initial> 06C1 +FBA9 <medial> 06C1 +FBAA <isolated> 06BE +FBAB <final> 06BE +FBAC <initial> 06BE +FBAD <medial> 06BE +FBAE <isolated> 06D2 +FBAF <final> 06D2 +FBB0 <isolated> 06D3 +FBB1 <final> 06D3 +FBD3 <isolated> 06AD +FBD4 <final> 06AD +FBD5 <initial> 06AD +FBD6 <medial> 06AD +FBD7 <isolated> 06C7 +FBD8 <final> 06C7 +FBD9 <isolated> 06C6 +FBDA <final> 06C6 +FBDB <isolated> 06C8 +FBDC <final> 06C8 +FBDD <isolated> 0677 +FBDE <isolated> 06CB +FBDF <final> 06CB +FBE0 <isolated> 06C5 +FBE1 <final> 06C5 +FBE2 <isolated> 06C9 +FBE3 <final> 06C9 +FBE4 <isolated> 06D0 +FBE5 <final> 06D0 +FBE6 <initial> 06D0 +FBE7 <medial> 06D0 +FBE8 <initial> 0649 +FBE9 <medial> 0649 +FBEA <isolated> 0626 0627 +FBEB <final> 0626 0627 +FBEC <isolated> 0626 06D5 +FBED <final> 0626 06D5 +FBEE <isolated> 0626 0648 +FBEF <final> 0626 0648 +FBF0 <isolated> 0626 06C7 +FBF1 <final> 0626 06C7 +FBF2 <isolated> 0626 06C6 +FBF3 <final> 0626 06C6 +FBF4 <isolated> 0626 06C8 +FBF5 <final> 0626 06C8 +FBF6 <isolated> 0626 06D0 +FBF7 <final> 0626 06D0 +FBF8 <initial> 0626 06D0 +FBF9 <isolated> 0626 0649 +FBFA <final> 0626 0649 +FBFB <initial> 0626 0649 +FBFC <isolated> 06CC +FBFD <final> 06CC +FBFE <initial> 06CC +FBFF <medial> 06CC +FC00 <isolated> 0626 062C +FC01 <isolated> 0626 062D +FC02 <isolated> 0626 0645 +FC03 <isolated> 0626 0649 +FC04 <isolated> 0626 064A +FC05 <isolated> 0628 062C +FC06 <isolated> 0628 062D +FC07 <isolated> 0628 062E +FC08 <isolated> 0628 0645 +FC09 <isolated> 0628 0649 +FC0A <isolated> 0628 064A +FC0B <isolated> 062A 062C +FC0C <isolated> 062A 062D +FC0D <isolated> 062A 062E +FC0E <isolated> 062A 0645 +FC0F <isolated> 062A 0649 +FC10 <isolated> 062A 064A +FC11 <isolated> 062B 062C +FC12 <isolated> 062B 0645 +FC13 <isolated> 062B 0649 +FC14 <isolated> 062B 064A +FC15 <isolated> 062C 062D +FC16 <isolated> 062C 0645 +FC17 <isolated> 062D 062C +FC18 <isolated> 062D 0645 +FC19 <isolated> 062E 062C +FC1A <isolated> 062E 062D +FC1B <isolated> 062E 0645 +FC1C <isolated> 0633 062C +FC1D <isolated> 0633 062D +FC1E <isolated> 0633 062E +FC1F <isolated> 0633 0645 +FC20 <isolated> 0635 062D +FC21 <isolated> 0635 0645 +FC22 <isolated> 0636 062C +FC23 <isolated> 0636 062D +FC24 <isolated> 0636 062E +FC25 <isolated> 0636 0645 +FC26 <isolated> 0637 062D +FC27 <isolated> 0637 0645 +FC28 <isolated> 0638 0645 +FC29 <isolated> 0639 062C +FC2A <isolated> 0639 0645 +FC2B <isolated> 063A 062C +FC2C <isolated> 063A 0645 +FC2D <isolated> 0641 062C +FC2E <isolated> 0641 062D +FC2F <isolated> 0641 062E +FC30 <isolated> 0641 0645 +FC31 <isolated> 0641 0649 +FC32 <isolated> 0641 064A +FC33 <isolated> 0642 062D +FC34 <isolated> 0642 0645 +FC35 <isolated> 0642 0649 +FC36 <isolated> 0642 064A +FC37 <isolated> 0643 0627 +FC38 <isolated> 0643 062C +FC39 <isolated> 0643 062D +FC3A <isolated> 0643 062E +FC3B <isolated> 0643 0644 +FC3C <isolated> 0643 0645 +FC3D <isolated> 0643 0649 +FC3E <isolated> 0643 064A +FC3F <isolated> 0644 062C +FC40 <isolated> 0644 062D +FC41 <isolated> 0644 062E +FC42 <isolated> 0644 0645 +FC43 <isolated> 0644 0649 +FC44 <isolated> 0644 064A +FC45 <isolated> 0645 062C +FC46 <isolated> 0645 062D +FC47 <isolated> 0645 062E +FC48 <isolated> 0645 0645 +FC49 <isolated> 0645 0649 +FC4A <isolated> 0645 064A +FC4B <isolated> 0646 062C +FC4C <isolated> 0646 062D +FC4D <isolated> 0646 062E +FC4E <isolated> 0646 0645 +FC4F <isolated> 0646 0649 +FC50 <isolated> 0646 064A +FC51 <isolated> 0647 062C +FC52 <isolated> 0647 0645 +FC53 <isolated> 0647 0649 +FC54 <isolated> 0647 064A +FC55 <isolated> 064A 062C +FC56 <isolated> 064A 062D +FC57 <isolated> 064A 062E +FC58 <isolated> 064A 0645 +FC59 <isolated> 064A 0649 +FC5A <isolated> 064A 064A +FC5B <isolated> 0630 0670 +FC5C <isolated> 0631 0670 +FC5D <isolated> 0649 0670 +FC5E <isolated> 0020 064C 0651 +FC5F <isolated> 0020 064D 0651 +FC60 <isolated> 0020 064E 0651 +FC61 <isolated> 0020 064F 0651 +FC62 <isolated> 0020 0650 0651 +FC63 <isolated> 0020 0651 0670 +FC64 <final> 0626 0631 +FC65 <final> 0626 0632 +FC66 <final> 0626 0645 +FC67 <final> 0626 0646 +FC68 <final> 0626 0649 +FC69 <final> 0626 064A +FC6A <final> 0628 0631 +FC6B <final> 0628 0632 +FC6C <final> 0628 0645 +FC6D <final> 0628 0646 +FC6E <final> 0628 0649 +FC6F <final> 0628 064A +FC70 <final> 062A 0631 +FC71 <final> 062A 0632 +FC72 <final> 062A 0645 +FC73 <final> 062A 0646 +FC74 <final> 062A 0649 +FC75 <final> 062A 064A +FC76 <final> 062B 0631 +FC77 <final> 062B 0632 +FC78 <final> 062B 0645 +FC79 <final> 062B 0646 +FC7A <final> 062B 0649 +FC7B <final> 062B 064A +FC7C <final> 0641 0649 +FC7D <final> 0641 064A +FC7E <final> 0642 0649 +FC7F <final> 0642 064A +FC80 <final> 0643 0627 +FC81 <final> 0643 0644 +FC82 <final> 0643 0645 +FC83 <final> 0643 0649 +FC84 <final> 0643 064A +FC85 <final> 0644 0645 +FC86 <final> 0644 0649 +FC87 <final> 0644 064A +FC88 <final> 0645 0627 +FC89 <final> 0645 0645 +FC8A <final> 0646 0631 +FC8B <final> 0646 0632 +FC8C <final> 0646 0645 +FC8D <final> 0646 0646 +FC8E <final> 0646 0649 +FC8F <final> 0646 064A +FC90 <final> 0649 0670 +FC91 <final> 064A 0631 +FC92 <final> 064A 0632 +FC93 <final> 064A 0645 +FC94 <final> 064A 0646 +FC95 <final> 064A 0649 +FC96 <final> 064A 064A +FC97 <initial> 0626 062C +FC98 <initial> 0626 062D +FC99 <initial> 0626 062E +FC9A <initial> 0626 0645 +FC9B <initial> 0626 0647 +FC9C <initial> 0628 062C +FC9D <initial> 0628 062D +FC9E <initial> 0628 062E +FC9F <initial> 0628 0645 +FCA0 <initial> 0628 0647 +FCA1 <initial> 062A 062C +FCA2 <initial> 062A 062D +FCA3 <initial> 062A 062E +FCA4 <initial> 062A 0645 +FCA5 <initial> 062A 0647 +FCA6 <initial> 062B 0645 +FCA7 <initial> 062C 062D +FCA8 <initial> 062C 0645 +FCA9 <initial> 062D 062C +FCAA <initial> 062D 0645 +FCAB <initial> 062E 062C +FCAC <initial> 062E 0645 +FCAD <initial> 0633 062C +FCAE <initial> 0633 062D +FCAF <initial> 0633 062E +FCB0 <initial> 0633 0645 +FCB1 <initial> 0635 062D +FCB2 <initial> 0635 062E +FCB3 <initial> 0635 0645 +FCB4 <initial> 0636 062C +FCB5 <initial> 0636 062D +FCB6 <initial> 0636 062E +FCB7 <initial> 0636 0645 +FCB8 <initial> 0637 062D +FCB9 <initial> 0638 0645 +FCBA <initial> 0639 062C +FCBB <initial> 0639 0645 +FCBC <initial> 063A 062C +FCBD <initial> 063A 0645 +FCBE <initial> 0641 062C +FCBF <initial> 0641 062D +FCC0 <initial> 0641 062E +FCC1 <initial> 0641 0645 +FCC2 <initial> 0642 062D +FCC3 <initial> 0642 0645 +FCC4 <initial> 0643 062C +FCC5 <initial> 0643 062D +FCC6 <initial> 0643 062E +FCC7 <initial> 0643 0644 +FCC8 <initial> 0643 0645 +FCC9 <initial> 0644 062C +FCCA <initial> 0644 062D +FCCB <initial> 0644 062E +FCCC <initial> 0644 0645 +FCCD <initial> 0644 0647 +FCCE <initial> 0645 062C +FCCF <initial> 0645 062D +FCD0 <initial> 0645 062E +FCD1 <initial> 0645 0645 +FCD2 <initial> 0646 062C +FCD3 <initial> 0646 062D +FCD4 <initial> 0646 062E +FCD5 <initial> 0646 0645 +FCD6 <initial> 0646 0647 +FCD7 <initial> 0647 062C +FCD8 <initial> 0647 0645 +FCD9 <initial> 0647 0670 +FCDA <initial> 064A 062C +FCDB <initial> 064A 062D +FCDC <initial> 064A 062E +FCDD <initial> 064A 0645 +FCDE <initial> 064A 0647 +FCDF <medial> 0626 0645 +FCE0 <medial> 0626 0647 +FCE1 <medial> 0628 0645 +FCE2 <medial> 0628 0647 +FCE3 <medial> 062A 0645 +FCE4 <medial> 062A 0647 +FCE5 <medial> 062B 0645 +FCE6 <medial> 062B 0647 +FCE7 <medial> 0633 0645 +FCE8 <medial> 0633 0647 +FCE9 <medial> 0634 0645 +FCEA <medial> 0634 0647 +FCEB <medial> 0643 0644 +FCEC <medial> 0643 0645 +FCED <medial> 0644 0645 +FCEE <medial> 0646 0645 +FCEF <medial> 0646 0647 +FCF0 <medial> 064A 0645 +FCF1 <medial> 064A 0647 +FCF2 <medial> 0640 064E 0651 +FCF3 <medial> 0640 064F 0651 +FCF4 <medial> 0640 0650 0651 +FCF5 <isolated> 0637 0649 +FCF6 <isolated> 0637 064A +FCF7 <isolated> 0639 0649 +FCF8 <isolated> 0639 064A +FCF9 <isolated> 063A 0649 +FCFA <isolated> 063A 064A +FCFB <isolated> 0633 0649 +FCFC <isolated> 0633 064A +FCFD <isolated> 0634 0649 +FCFE <isolated> 0634 064A +FCFF <isolated> 062D 0649 +FD00 <isolated> 062D 064A +FD01 <isolated> 062C 0649 +FD02 <isolated> 062C 064A +FD03 <isolated> 062E 0649 +FD04 <isolated> 062E 064A +FD05 <isolated> 0635 0649 +FD06 <isolated> 0635 064A +FD07 <isolated> 0636 0649 +FD08 <isolated> 0636 064A +FD09 <isolated> 0634 062C +FD0A <isolated> 0634 062D +FD0B <isolated> 0634 062E +FD0C <isolated> 0634 0645 +FD0D <isolated> 0634 0631 +FD0E <isolated> 0633 0631 +FD0F <isolated> 0635 0631 +FD10 <isolated> 0636 0631 +FD11 <final> 0637 0649 +FD12 <final> 0637 064A +FD13 <final> 0639 0649 +FD14 <final> 0639 064A +FD15 <final> 063A 0649 +FD16 <final> 063A 064A +FD17 <final> 0633 0649 +FD18 <final> 0633 064A +FD19 <final> 0634 0649 +FD1A <final> 0634 064A +FD1B <final> 062D 0649 +FD1C <final> 062D 064A +FD1D <final> 062C 0649 +FD1E <final> 062C 064A +FD1F <final> 062E 0649 +FD20 <final> 062E 064A +FD21 <final> 0635 0649 +FD22 <final> 0635 064A +FD23 <final> 0636 0649 +FD24 <final> 0636 064A +FD25 <final> 0634 062C +FD26 <final> 0634 062D +FD27 <final> 0634 062E +FD28 <final> 0634 0645 +FD29 <final> 0634 0631 +FD2A <final> 0633 0631 +FD2B <final> 0635 0631 +FD2C <final> 0636 0631 +FD2D <initial> 0634 062C +FD2E <initial> 0634 062D +FD2F <initial> 0634 062E +FD30 <initial> 0634 0645 +FD31 <initial> 0633 0647 +FD32 <initial> 0634 0647 +FD33 <initial> 0637 0645 +FD34 <medial> 0633 062C +FD35 <medial> 0633 062D +FD36 <medial> 0633 062E +FD37 <medial> 0634 062C +FD38 <medial> 0634 062D +FD39 <medial> 0634 062E +FD3A <medial> 0637 0645 +FD3B <medial> 0638 0645 +FD3C <final> 0627 064B +FD3D <isolated> 0627 064B +FD50 <initial> 062A 062C 0645 +FD51 <final> 062A 062D 062C +FD52 <initial> 062A 062D 062C +FD53 <initial> 062A 062D 0645 +FD54 <initial> 062A 062E 0645 +FD55 <initial> 062A 0645 062C +FD56 <initial> 062A 0645 062D +FD57 <initial> 062A 0645 062E +FD58 <final> 062C 0645 062D +FD59 <initial> 062C 0645 062D +FD5A <final> 062D 0645 064A +FD5B <final> 062D 0645 0649 +FD5C <initial> 0633 062D 062C +FD5D <initial> 0633 062C 062D +FD5E <final> 0633 062C 0649 +FD5F <final> 0633 0645 062D +FD60 <initial> 0633 0645 062D +FD61 <initial> 0633 0645 062C +FD62 <final> 0633 0645 0645 +FD63 <initial> 0633 0645 0645 +FD64 <final> 0635 062D 062D +FD65 <initial> 0635 062D 062D +FD66 <final> 0635 0645 0645 +FD67 <final> 0634 062D 0645 +FD68 <initial> 0634 062D 0645 +FD69 <final> 0634 062C 064A +FD6A <final> 0634 0645 062E +FD6B <initial> 0634 0645 062E +FD6C <final> 0634 0645 0645 +FD6D <initial> 0634 0645 0645 +FD6E <final> 0636 062D 0649 +FD6F <final> 0636 062E 0645 +FD70 <initial> 0636 062E 0645 +FD71 <final> 0637 0645 062D +FD72 <initial> 0637 0645 062D +FD73 <initial> 0637 0645 0645 +FD74 <final> 0637 0645 064A +FD75 <final> 0639 062C 0645 +FD76 <final> 0639 0645 0645 +FD77 <initial> 0639 0645 0645 +FD78 <final> 0639 0645 0649 +FD79 <final> 063A 0645 0645 +FD7A <final> 063A 0645 064A +FD7B <final> 063A 0645 0649 +FD7C <final> 0641 062E 0645 +FD7D <initial> 0641 062E 0645 +FD7E <final> 0642 0645 062D +FD7F <final> 0642 0645 0645 +FD80 <final> 0644 062D 0645 +FD81 <final> 0644 062D 064A +FD82 <final> 0644 062D 0649 +FD83 <initial> 0644 062C 062C +FD84 <final> 0644 062C 062C +FD85 <final> 0644 062E 0645 +FD86 <initial> 0644 062E 0645 +FD87 <final> 0644 0645 062D +FD88 <initial> 0644 0645 062D +FD89 <initial> 0645 062D 062C +FD8A <initial> 0645 062D 0645 +FD8B <final> 0645 062D 064A +FD8C <initial> 0645 062C 062D +FD8D <initial> 0645 062C 0645 +FD8E <initial> 0645 062E 062C +FD8F <initial> 0645 062E 0645 +FD92 <initial> 0645 062C 062E +FD93 <initial> 0647 0645 062C +FD94 <initial> 0647 0645 0645 +FD95 <initial> 0646 062D 0645 +FD96 <final> 0646 062D 0649 +FD97 <final> 0646 062C 0645 +FD98 <initial> 0646 062C 0645 +FD99 <final> 0646 062C 0649 +FD9A <final> 0646 0645 064A +FD9B <final> 0646 0645 0649 +FD9C <final> 064A 0645 0645 +FD9D <initial> 064A 0645 0645 +FD9E <final> 0628 062E 064A +FD9F <final> 062A 062C 064A +FDA0 <final> 062A 062C 0649 +FDA1 <final> 062A 062E 064A +FDA2 <final> 062A 062E 0649 +FDA3 <final> 062A 0645 064A +FDA4 <final> 062A 0645 0649 +FDA5 <final> 062C 0645 064A +FDA6 <final> 062C 062D 0649 +FDA7 <final> 062C 0645 0649 +FDA8 <final> 0633 062E 0649 +FDA9 <final> 0635 062D 064A +FDAA <final> 0634 062D 064A +FDAB <final> 0636 062D 064A +FDAC <final> 0644 062C 064A +FDAD <final> 0644 0645 064A +FDAE <final> 064A 062D 064A +FDAF <final> 064A 062C 064A +FDB0 <final> 064A 0645 064A +FDB1 <final> 0645 0645 064A +FDB2 <final> 0642 0645 064A +FDB3 <final> 0646 062D 064A +FDB4 <initial> 0642 0645 062D +FDB5 <initial> 0644 062D 0645 +FDB6 <final> 0639 0645 064A +FDB7 <final> 0643 0645 064A +FDB8 <initial> 0646 062C 062D +FDB9 <final> 0645 062E 064A +FDBA <initial> 0644 062C 0645 +FDBB <final> 0643 0645 0645 +FDBC <final> 0644 062C 0645 +FDBD <final> 0646 062C 062D +FDBE <final> 062C 062D 064A +FDBF <final> 062D 062C 064A +FDC0 <final> 0645 062C 064A +FDC1 <final> 0641 0645 064A +FDC2 <final> 0628 062D 064A +FDC3 <initial> 0643 0645 0645 +FDC4 <initial> 0639 062C 0645 +FDC5 <initial> 0635 0645 0645 +FDC6 <final> 0633 062E 064A +FDC7 <final> 0646 062C 064A +FDF0 <isolated> 0635 0644 06D2 +FDF1 <isolated> 0642 0644 06D2 +FDF2 <isolated> 0627 0644 0644 0647 +FDF3 <isolated> 0627 0643 0628 0631 +FDF4 <isolated> 0645 062D 0645 062F +FDF5 <isolated> 0635 0644 0639 0645 +FDF6 <isolated> 0631 0633 0648 0644 +FDF7 <isolated> 0639 0644 064A 0647 +FDF8 <isolated> 0648 0633 0644 0645 +FDF9 <isolated> 0635 0644 0649 +FDFA <isolated> 0635 0644 0649 0020 0627 0644 0644 0647 0020 0639 0644 064A 0647 0020 0648 0633 0644 0645 +FDFB <isolated> 062C 0644 0020 062C 0644 0627 0644 0647 +FDFC <isolated> 0631 06CC 0627 0644 +FE30 <vertical> 2025 +FE31 <vertical> 2014 +FE32 <vertical> 2013 +FE33 FE34 <vertical> 005F +FE35 <vertical> 0028 +FE36 <vertical> 0029 +FE37 <vertical> 007B +FE38 <vertical> 007D +FE39 <vertical> 3014 +FE3A <vertical> 3015 +FE3B <vertical> 3010 +FE3C <vertical> 3011 +FE3D <vertical> 300A +FE3E <vertical> 300B +FE3F <vertical> 3008 +FE40 <vertical> 3009 +FE41 <vertical> 300C +FE42 <vertical> 300D +FE43 <vertical> 300E +FE44 <vertical> 300F +FE49 FE4C <compat> 203E +FE4D FE4F <compat> 005F +FE50 <small> 002C +FE51 <small> 3001 +FE52 <small> 002E +FE54 <small> 003B +FE55 <small> 003A +FE56 <small> 003F +FE57 <small> 0021 +FE58 <small> 2014 +FE59 <small> 0028 +FE5A <small> 0029 +FE5B <small> 007B +FE5C <small> 007D +FE5D <small> 3014 +FE5E <small> 3015 +FE5F <small> 0023 +FE60 <small> 0026 +FE61 <small> 002A +FE62 <small> 002B +FE63 <small> 002D +FE64 <small> 003C +FE65 <small> 003E +FE66 <small> 003D +FE68 <small> 005C +FE69 <small> 0024 +FE6A <small> 0025 +FE6B <small> 0040 +FE70 <isolated> 0020 064B +FE71 <medial> 0640 064B +FE72 <isolated> 0020 064C +FE74 <isolated> 0020 064D +FE76 <isolated> 0020 064E +FE77 <medial> 0640 064E +FE78 <isolated> 0020 064F +FE79 <medial> 0640 064F +FE7A <isolated> 0020 0650 +FE7B <medial> 0640 0650 +FE7C <isolated> 0020 0651 +FE7D <medial> 0640 0651 +FE7E <isolated> 0020 0652 +FE7F <medial> 0640 0652 +FE80 <isolated> 0621 +FE81 <isolated> 0622 +FE82 <final> 0622 +FE83 <isolated> 0623 +FE84 <final> 0623 +FE85 <isolated> 0624 +FE86 <final> 0624 +FE87 <isolated> 0625 +FE88 <final> 0625 +FE89 <isolated> 0626 +FE8A <final> 0626 +FE8B <initial> 0626 +FE8C <medial> 0626 +FE8D <isolated> 0627 +FE8E <final> 0627 +FE8F <isolated> 0628 +FE90 <final> 0628 +FE91 <initial> 0628 +FE92 <medial> 0628 +FE93 <isolated> 0629 +FE94 <final> 0629 +FE95 <isolated> 062A +FE96 <final> 062A +FE97 <initial> 062A +FE98 <medial> 062A +FE99 <isolated> 062B +FE9A <final> 062B +FE9B <initial> 062B +FE9C <medial> 062B +FE9D <isolated> 062C +FE9E <final> 062C +FE9F <initial> 062C +FEA0 <medial> 062C +FEA1 <isolated> 062D +FEA2 <final> 062D +FEA3 <initial> 062D +FEA4 <medial> 062D +FEA5 <isolated> 062E +FEA6 <final> 062E +FEA7 <initial> 062E +FEA8 <medial> 062E +FEA9 <isolated> 062F +FEAA <final> 062F +FEAB <isolated> 0630 +FEAC <final> 0630 +FEAD <isolated> 0631 +FEAE <final> 0631 +FEAF <isolated> 0632 +FEB0 <final> 0632 +FEB1 <isolated> 0633 +FEB2 <final> 0633 +FEB3 <initial> 0633 +FEB4 <medial> 0633 +FEB5 <isolated> 0634 +FEB6 <final> 0634 +FEB7 <initial> 0634 +FEB8 <medial> 0634 +FEB9 <isolated> 0635 +FEBA <final> 0635 +FEBB <initial> 0635 +FEBC <medial> 0635 +FEBD <isolated> 0636 +FEBE <final> 0636 +FEBF <initial> 0636 +FEC0 <medial> 0636 +FEC1 <isolated> 0637 +FEC2 <final> 0637 +FEC3 <initial> 0637 +FEC4 <medial> 0637 +FEC5 <isolated> 0638 +FEC6 <final> 0638 +FEC7 <initial> 0638 +FEC8 <medial> 0638 +FEC9 <isolated> 0639 +FECA <final> 0639 +FECB <initial> 0639 +FECC <medial> 0639 +FECD <isolated> 063A +FECE <final> 063A +FECF <initial> 063A +FED0 <medial> 063A +FED1 <isolated> 0641 +FED2 <final> 0641 +FED3 <initial> 0641 +FED4 <medial> 0641 +FED5 <isolated> 0642 +FED6 <final> 0642 +FED7 <initial> 0642 +FED8 <medial> 0642 +FED9 <isolated> 0643 +FEDA <final> 0643 +FEDB <initial> 0643 +FEDC <medial> 0643 +FEDD <isolated> 0644 +FEDE <final> 0644 +FEDF <initial> 0644 +FEE0 <medial> 0644 +FEE1 <isolated> 0645 +FEE2 <final> 0645 +FEE3 <initial> 0645 +FEE4 <medial> 0645 +FEE5 <isolated> 0646 +FEE6 <final> 0646 +FEE7 <initial> 0646 +FEE8 <medial> 0646 +FEE9 <isolated> 0647 +FEEA <final> 0647 +FEEB <initial> 0647 +FEEC <medial> 0647 +FEED <isolated> 0648 +FEEE <final> 0648 +FEEF <isolated> 0649 +FEF0 <final> 0649 +FEF1 <isolated> 064A +FEF2 <final> 064A +FEF3 <initial> 064A +FEF4 <medial> 064A +FEF5 <isolated> 0644 0622 +FEF6 <final> 0644 0622 +FEF7 <isolated> 0644 0623 +FEF8 <final> 0644 0623 +FEF9 <isolated> 0644 0625 +FEFA <final> 0644 0625 +FEFB <isolated> 0644 0627 +FEFC <final> 0644 0627 +FF01 <wide> 0021 +FF02 <wide> 0022 +FF03 <wide> 0023 +FF04 <wide> 0024 +FF05 <wide> 0025 +FF06 <wide> 0026 +FF07 <wide> 0027 +FF08 <wide> 0028 +FF09 <wide> 0029 +FF0A <wide> 002A +FF0B <wide> 002B +FF0C <wide> 002C +FF0D <wide> 002D +FF0E <wide> 002E +FF0F <wide> 002F +FF10 <wide> 0030 +FF11 <wide> 0031 +FF12 <wide> 0032 +FF13 <wide> 0033 +FF14 <wide> 0034 +FF15 <wide> 0035 +FF16 <wide> 0036 +FF17 <wide> 0037 +FF18 <wide> 0038 +FF19 <wide> 0039 +FF1A <wide> 003A +FF1B <wide> 003B +FF1C <wide> 003C +FF1D <wide> 003D +FF1E <wide> 003E +FF1F <wide> 003F +FF20 <wide> 0040 +FF21 <wide> 0041 +FF22 <wide> 0042 +FF23 <wide> 0043 +FF24 <wide> 0044 +FF25 <wide> 0045 +FF26 <wide> 0046 +FF27 <wide> 0047 +FF28 <wide> 0048 +FF29 <wide> 0049 +FF2A <wide> 004A +FF2B <wide> 004B +FF2C <wide> 004C +FF2D <wide> 004D +FF2E <wide> 004E +FF2F <wide> 004F +FF30 <wide> 0050 +FF31 <wide> 0051 +FF32 <wide> 0052 +FF33 <wide> 0053 +FF34 <wide> 0054 +FF35 <wide> 0055 +FF36 <wide> 0056 +FF37 <wide> 0057 +FF38 <wide> 0058 +FF39 <wide> 0059 +FF3A <wide> 005A +FF3B <wide> 005B +FF3C <wide> 005C +FF3D <wide> 005D +FF3E <wide> 005E +FF3F <wide> 005F +FF40 <wide> 0060 +FF41 <wide> 0061 +FF42 <wide> 0062 +FF43 <wide> 0063 +FF44 <wide> 0064 +FF45 <wide> 0065 +FF46 <wide> 0066 +FF47 <wide> 0067 +FF48 <wide> 0068 +FF49 <wide> 0069 +FF4A <wide> 006A +FF4B <wide> 006B +FF4C <wide> 006C +FF4D <wide> 006D +FF4E <wide> 006E +FF4F <wide> 006F +FF50 <wide> 0070 +FF51 <wide> 0071 +FF52 <wide> 0072 +FF53 <wide> 0073 +FF54 <wide> 0074 +FF55 <wide> 0075 +FF56 <wide> 0076 +FF57 <wide> 0077 +FF58 <wide> 0078 +FF59 <wide> 0079 +FF5A <wide> 007A +FF5B <wide> 007B +FF5C <wide> 007C +FF5D <wide> 007D +FF5E <wide> 007E +FF5F <wide> 2985 +FF60 <wide> 2986 +FF61 <narrow> 3002 +FF62 <narrow> 300C +FF63 <narrow> 300D +FF64 <narrow> 3001 +FF65 <narrow> 30FB +FF66 <narrow> 30F2 +FF67 <narrow> 30A1 +FF68 <narrow> 30A3 +FF69 <narrow> 30A5 +FF6A <narrow> 30A7 +FF6B <narrow> 30A9 +FF6C <narrow> 30E3 +FF6D <narrow> 30E5 +FF6E <narrow> 30E7 +FF6F <narrow> 30C3 +FF70 <narrow> 30FC +FF71 <narrow> 30A2 +FF72 <narrow> 30A4 +FF73 <narrow> 30A6 +FF74 <narrow> 30A8 +FF75 <narrow> 30AA +FF76 <narrow> 30AB +FF77 <narrow> 30AD +FF78 <narrow> 30AF +FF79 <narrow> 30B1 +FF7A <narrow> 30B3 +FF7B <narrow> 30B5 +FF7C <narrow> 30B7 +FF7D <narrow> 30B9 +FF7E <narrow> 30BB +FF7F <narrow> 30BD +FF80 <narrow> 30BF +FF81 <narrow> 30C1 +FF82 <narrow> 30C4 +FF83 <narrow> 30C6 +FF84 <narrow> 30C8 +FF85 <narrow> 30CA +FF86 <narrow> 30CB +FF87 <narrow> 30CC +FF88 <narrow> 30CD +FF89 <narrow> 30CE +FF8A <narrow> 30CF +FF8B <narrow> 30D2 +FF8C <narrow> 30D5 +FF8D <narrow> 30D8 +FF8E <narrow> 30DB +FF8F <narrow> 30DE +FF90 <narrow> 30DF +FF91 <narrow> 30E0 +FF92 <narrow> 30E1 +FF93 <narrow> 30E2 +FF94 <narrow> 30E4 +FF95 <narrow> 30E6 +FF96 <narrow> 30E8 +FF97 <narrow> 30E9 +FF98 <narrow> 30EA +FF99 <narrow> 30EB +FF9A <narrow> 30EC +FF9B <narrow> 30ED +FF9C <narrow> 30EF +FF9D <narrow> 30F3 +FF9E <narrow> 3099 +FF9F <narrow> 309A +FFA0 <narrow> 3164 +FFA1 <narrow> 3131 +FFA2 <narrow> 3132 +FFA3 <narrow> 3133 +FFA4 <narrow> 3134 +FFA5 <narrow> 3135 +FFA6 <narrow> 3136 +FFA7 <narrow> 3137 +FFA8 <narrow> 3138 +FFA9 <narrow> 3139 +FFAA <narrow> 313A +FFAB <narrow> 313B +FFAC <narrow> 313C +FFAD <narrow> 313D +FFAE <narrow> 313E +FFAF <narrow> 313F +FFB0 <narrow> 3140 +FFB1 <narrow> 3141 +FFB2 <narrow> 3142 +FFB3 <narrow> 3143 +FFB4 <narrow> 3144 +FFB5 <narrow> 3145 +FFB6 <narrow> 3146 +FFB7 <narrow> 3147 +FFB8 <narrow> 3148 +FFB9 <narrow> 3149 +FFBA <narrow> 314A +FFBB <narrow> 314B +FFBC <narrow> 314C +FFBD <narrow> 314D +FFBE <narrow> 314E +FFC2 <narrow> 314F +FFC3 <narrow> 3150 +FFC4 <narrow> 3151 +FFC5 <narrow> 3152 +FFC6 <narrow> 3153 +FFC7 <narrow> 3154 +FFCA <narrow> 3155 +FFCB <narrow> 3156 +FFCC <narrow> 3157 +FFCD <narrow> 3158 +FFCE <narrow> 3159 +FFCF <narrow> 315A +FFD2 <narrow> 315B +FFD3 <narrow> 315C +FFD4 <narrow> 315D +FFD5 <narrow> 315E +FFD6 <narrow> 315F +FFD7 <narrow> 3160 +FFDA <narrow> 3161 +FFDB <narrow> 3162 +FFDC <narrow> 3163 +FFE0 <wide> 00A2 +FFE1 <wide> 00A3 +FFE2 <wide> 00AC +FFE3 <wide> 00AF +FFE4 <wide> 00A6 +FFE5 <wide> 00A5 +FFE6 <wide> 20A9 +FFE8 <narrow> 2502 +FFE9 <narrow> 2190 +FFEA <narrow> 2191 +FFEB <narrow> 2192 +FFEC <narrow> 2193 +FFED <narrow> 25A0 +FFEE <narrow> 25CB +1D15E 1D157 1D165 +1D15F 1D158 1D165 +1D160 1D15F 1D16E +1D161 1D15F 1D16F +1D162 1D15F 1D170 +1D163 1D15F 1D171 +1D164 1D15F 1D172 +1D1BB 1D1B9 1D165 +1D1BC 1D1BA 1D165 +1D1BD 1D1BB 1D16E +1D1BE 1D1BC 1D16E +1D1BF 1D1BB 1D16F +1D1C0 1D1BC 1D16F +1D400 <font> 0041 +1D401 <font> 0042 +1D402 <font> 0043 +1D403 <font> 0044 +1D404 <font> 0045 +1D405 <font> 0046 +1D406 <font> 0047 +1D407 <font> 0048 +1D408 <font> 0049 +1D409 <font> 004A +1D40A <font> 004B +1D40B <font> 004C +1D40C <font> 004D +1D40D <font> 004E +1D40E <font> 004F +1D40F <font> 0050 +1D410 <font> 0051 +1D411 <font> 0052 +1D412 <font> 0053 +1D413 <font> 0054 +1D414 <font> 0055 +1D415 <font> 0056 +1D416 <font> 0057 +1D417 <font> 0058 +1D418 <font> 0059 +1D419 <font> 005A +1D41A <font> 0061 +1D41B <font> 0062 +1D41C <font> 0063 +1D41D <font> 0064 +1D41E <font> 0065 +1D41F <font> 0066 +1D420 <font> 0067 +1D421 <font> 0068 +1D422 <font> 0069 +1D423 <font> 006A +1D424 <font> 006B +1D425 <font> 006C +1D426 <font> 006D +1D427 <font> 006E +1D428 <font> 006F +1D429 <font> 0070 +1D42A <font> 0071 +1D42B <font> 0072 +1D42C <font> 0073 +1D42D <font> 0074 +1D42E <font> 0075 +1D42F <font> 0076 +1D430 <font> 0077 +1D431 <font> 0078 +1D432 <font> 0079 +1D433 <font> 007A +1D434 <font> 0041 +1D435 <font> 0042 +1D436 <font> 0043 +1D437 <font> 0044 +1D438 <font> 0045 +1D439 <font> 0046 +1D43A <font> 0047 +1D43B <font> 0048 +1D43C <font> 0049 +1D43D <font> 004A +1D43E <font> 004B +1D43F <font> 004C +1D440 <font> 004D +1D441 <font> 004E +1D442 <font> 004F +1D443 <font> 0050 +1D444 <font> 0051 +1D445 <font> 0052 +1D446 <font> 0053 +1D447 <font> 0054 +1D448 <font> 0055 +1D449 <font> 0056 +1D44A <font> 0057 +1D44B <font> 0058 +1D44C <font> 0059 +1D44D <font> 005A +1D44E <font> 0061 +1D44F <font> 0062 +1D450 <font> 0063 +1D451 <font> 0064 +1D452 <font> 0065 +1D453 <font> 0066 +1D454 <font> 0067 +1D456 <font> 0069 +1D457 <font> 006A +1D458 <font> 006B +1D459 <font> 006C +1D45A <font> 006D +1D45B <font> 006E +1D45C <font> 006F +1D45D <font> 0070 +1D45E <font> 0071 +1D45F <font> 0072 +1D460 <font> 0073 +1D461 <font> 0074 +1D462 <font> 0075 +1D463 <font> 0076 +1D464 <font> 0077 +1D465 <font> 0078 +1D466 <font> 0079 +1D467 <font> 007A +1D468 <font> 0041 +1D469 <font> 0042 +1D46A <font> 0043 +1D46B <font> 0044 +1D46C <font> 0045 +1D46D <font> 0046 +1D46E <font> 0047 +1D46F <font> 0048 +1D470 <font> 0049 +1D471 <font> 004A +1D472 <font> 004B +1D473 <font> 004C +1D474 <font> 004D +1D475 <font> 004E +1D476 <font> 004F +1D477 <font> 0050 +1D478 <font> 0051 +1D479 <font> 0052 +1D47A <font> 0053 +1D47B <font> 0054 +1D47C <font> 0055 +1D47D <font> 0056 +1D47E <font> 0057 +1D47F <font> 0058 +1D480 <font> 0059 +1D481 <font> 005A +1D482 <font> 0061 +1D483 <font> 0062 +1D484 <font> 0063 +1D485 <font> 0064 +1D486 <font> 0065 +1D487 <font> 0066 +1D488 <font> 0067 +1D489 <font> 0068 +1D48A <font> 0069 +1D48B <font> 006A +1D48C <font> 006B +1D48D <font> 006C +1D48E <font> 006D +1D48F <font> 006E +1D490 <font> 006F +1D491 <font> 0070 +1D492 <font> 0071 +1D493 <font> 0072 +1D494 <font> 0073 +1D495 <font> 0074 +1D496 <font> 0075 +1D497 <font> 0076 +1D498 <font> 0077 +1D499 <font> 0078 +1D49A <font> 0079 +1D49B <font> 007A +1D49C <font> 0041 +1D49E <font> 0043 +1D49F <font> 0044 +1D4A2 <font> 0047 +1D4A5 <font> 004A +1D4A6 <font> 004B +1D4A9 <font> 004E +1D4AA <font> 004F +1D4AB <font> 0050 +1D4AC <font> 0051 +1D4AE <font> 0053 +1D4AF <font> 0054 +1D4B0 <font> 0055 +1D4B1 <font> 0056 +1D4B2 <font> 0057 +1D4B3 <font> 0058 +1D4B4 <font> 0059 +1D4B5 <font> 005A +1D4B6 <font> 0061 +1D4B7 <font> 0062 +1D4B8 <font> 0063 +1D4B9 <font> 0064 +1D4BB <font> 0066 +1D4BD <font> 0068 +1D4BE <font> 0069 +1D4BF <font> 006A +1D4C0 <font> 006B +1D4C2 <font> 006D +1D4C3 <font> 006E +1D4C5 <font> 0070 +1D4C6 <font> 0071 +1D4C7 <font> 0072 +1D4C8 <font> 0073 +1D4C9 <font> 0074 +1D4CA <font> 0075 +1D4CB <font> 0076 +1D4CC <font> 0077 +1D4CD <font> 0078 +1D4CE <font> 0079 +1D4CF <font> 007A +1D4D0 <font> 0041 +1D4D1 <font> 0042 +1D4D2 <font> 0043 +1D4D3 <font> 0044 +1D4D4 <font> 0045 +1D4D5 <font> 0046 +1D4D6 <font> 0047 +1D4D7 <font> 0048 +1D4D8 <font> 0049 +1D4D9 <font> 004A +1D4DA <font> 004B +1D4DB <font> 004C +1D4DC <font> 004D +1D4DD <font> 004E +1D4DE <font> 004F +1D4DF <font> 0050 +1D4E0 <font> 0051 +1D4E1 <font> 0052 +1D4E2 <font> 0053 +1D4E3 <font> 0054 +1D4E4 <font> 0055 +1D4E5 <font> 0056 +1D4E6 <font> 0057 +1D4E7 <font> 0058 +1D4E8 <font> 0059 +1D4E9 <font> 005A +1D4EA <font> 0061 +1D4EB <font> 0062 +1D4EC <font> 0063 +1D4ED <font> 0064 +1D4EE <font> 0065 +1D4EF <font> 0066 +1D4F0 <font> 0067 +1D4F1 <font> 0068 +1D4F2 <font> 0069 +1D4F3 <font> 006A +1D4F4 <font> 006B +1D4F5 <font> 006C +1D4F6 <font> 006D +1D4F7 <font> 006E +1D4F8 <font> 006F +1D4F9 <font> 0070 +1D4FA <font> 0071 +1D4FB <font> 0072 +1D4FC <font> 0073 +1D4FD <font> 0074 +1D4FE <font> 0075 +1D4FF <font> 0076 +1D500 <font> 0077 +1D501 <font> 0078 +1D502 <font> 0079 +1D503 <font> 007A +1D504 <font> 0041 +1D505 <font> 0042 +1D507 <font> 0044 +1D508 <font> 0045 +1D509 <font> 0046 +1D50A <font> 0047 +1D50D <font> 004A +1D50E <font> 004B +1D50F <font> 004C +1D510 <font> 004D +1D511 <font> 004E +1D512 <font> 004F +1D513 <font> 0050 +1D514 <font> 0051 +1D516 <font> 0053 +1D517 <font> 0054 +1D518 <font> 0055 +1D519 <font> 0056 +1D51A <font> 0057 +1D51B <font> 0058 +1D51C <font> 0059 +1D51E <font> 0061 +1D51F <font> 0062 +1D520 <font> 0063 +1D521 <font> 0064 +1D522 <font> 0065 +1D523 <font> 0066 +1D524 <font> 0067 +1D525 <font> 0068 +1D526 <font> 0069 +1D527 <font> 006A +1D528 <font> 006B +1D529 <font> 006C +1D52A <font> 006D +1D52B <font> 006E +1D52C <font> 006F +1D52D <font> 0070 +1D52E <font> 0071 +1D52F <font> 0072 +1D530 <font> 0073 +1D531 <font> 0074 +1D532 <font> 0075 +1D533 <font> 0076 +1D534 <font> 0077 +1D535 <font> 0078 +1D536 <font> 0079 +1D537 <font> 007A +1D538 <font> 0041 +1D539 <font> 0042 +1D53B <font> 0044 +1D53C <font> 0045 +1D53D <font> 0046 +1D53E <font> 0047 +1D540 <font> 0049 +1D541 <font> 004A +1D542 <font> 004B +1D543 <font> 004C +1D544 <font> 004D +1D546 <font> 004F +1D54A <font> 0053 +1D54B <font> 0054 +1D54C <font> 0055 +1D54D <font> 0056 +1D54E <font> 0057 +1D54F <font> 0058 +1D550 <font> 0059 +1D552 <font> 0061 +1D553 <font> 0062 +1D554 <font> 0063 +1D555 <font> 0064 +1D556 <font> 0065 +1D557 <font> 0066 +1D558 <font> 0067 +1D559 <font> 0068 +1D55A <font> 0069 +1D55B <font> 006A +1D55C <font> 006B +1D55D <font> 006C +1D55E <font> 006D +1D55F <font> 006E +1D560 <font> 006F +1D561 <font> 0070 +1D562 <font> 0071 +1D563 <font> 0072 +1D564 <font> 0073 +1D565 <font> 0074 +1D566 <font> 0075 +1D567 <font> 0076 +1D568 <font> 0077 +1D569 <font> 0078 +1D56A <font> 0079 +1D56B <font> 007A +1D56C <font> 0041 +1D56D <font> 0042 +1D56E <font> 0043 +1D56F <font> 0044 +1D570 <font> 0045 +1D571 <font> 0046 +1D572 <font> 0047 +1D573 <font> 0048 +1D574 <font> 0049 +1D575 <font> 004A +1D576 <font> 004B +1D577 <font> 004C +1D578 <font> 004D +1D579 <font> 004E +1D57A <font> 004F +1D57B <font> 0050 +1D57C <font> 0051 +1D57D <font> 0052 +1D57E <font> 0053 +1D57F <font> 0054 +1D580 <font> 0055 +1D581 <font> 0056 +1D582 <font> 0057 +1D583 <font> 0058 +1D584 <font> 0059 +1D585 <font> 005A +1D586 <font> 0061 +1D587 <font> 0062 +1D588 <font> 0063 +1D589 <font> 0064 +1D58A <font> 0065 +1D58B <font> 0066 +1D58C <font> 0067 +1D58D <font> 0068 +1D58E <font> 0069 +1D58F <font> 006A +1D590 <font> 006B +1D591 <font> 006C +1D592 <font> 006D +1D593 <font> 006E +1D594 <font> 006F +1D595 <font> 0070 +1D596 <font> 0071 +1D597 <font> 0072 +1D598 <font> 0073 +1D599 <font> 0074 +1D59A <font> 0075 +1D59B <font> 0076 +1D59C <font> 0077 +1D59D <font> 0078 +1D59E <font> 0079 +1D59F <font> 007A +1D5A0 <font> 0041 +1D5A1 <font> 0042 +1D5A2 <font> 0043 +1D5A3 <font> 0044 +1D5A4 <font> 0045 +1D5A5 <font> 0046 +1D5A6 <font> 0047 +1D5A7 <font> 0048 +1D5A8 <font> 0049 +1D5A9 <font> 004A +1D5AA <font> 004B +1D5AB <font> 004C +1D5AC <font> 004D +1D5AD <font> 004E +1D5AE <font> 004F +1D5AF <font> 0050 +1D5B0 <font> 0051 +1D5B1 <font> 0052 +1D5B2 <font> 0053 +1D5B3 <font> 0054 +1D5B4 <font> 0055 +1D5B5 <font> 0056 +1D5B6 <font> 0057 +1D5B7 <font> 0058 +1D5B8 <font> 0059 +1D5B9 <font> 005A +1D5BA <font> 0061 +1D5BB <font> 0062 +1D5BC <font> 0063 +1D5BD <font> 0064 +1D5BE <font> 0065 +1D5BF <font> 0066 +1D5C0 <font> 0067 +1D5C1 <font> 0068 +1D5C2 <font> 0069 +1D5C3 <font> 006A +1D5C4 <font> 006B +1D5C5 <font> 006C +1D5C6 <font> 006D +1D5C7 <font> 006E +1D5C8 <font> 006F +1D5C9 <font> 0070 +1D5CA <font> 0071 +1D5CB <font> 0072 +1D5CC <font> 0073 +1D5CD <font> 0074 +1D5CE <font> 0075 +1D5CF <font> 0076 +1D5D0 <font> 0077 +1D5D1 <font> 0078 +1D5D2 <font> 0079 +1D5D3 <font> 007A +1D5D4 <font> 0041 +1D5D5 <font> 0042 +1D5D6 <font> 0043 +1D5D7 <font> 0044 +1D5D8 <font> 0045 +1D5D9 <font> 0046 +1D5DA <font> 0047 +1D5DB <font> 0048 +1D5DC <font> 0049 +1D5DD <font> 004A +1D5DE <font> 004B +1D5DF <font> 004C +1D5E0 <font> 004D +1D5E1 <font> 004E +1D5E2 <font> 004F +1D5E3 <font> 0050 +1D5E4 <font> 0051 +1D5E5 <font> 0052 +1D5E6 <font> 0053 +1D5E7 <font> 0054 +1D5E8 <font> 0055 +1D5E9 <font> 0056 +1D5EA <font> 0057 +1D5EB <font> 0058 +1D5EC <font> 0059 +1D5ED <font> 005A +1D5EE <font> 0061 +1D5EF <font> 0062 +1D5F0 <font> 0063 +1D5F1 <font> 0064 +1D5F2 <font> 0065 +1D5F3 <font> 0066 +1D5F4 <font> 0067 +1D5F5 <font> 0068 +1D5F6 <font> 0069 +1D5F7 <font> 006A +1D5F8 <font> 006B +1D5F9 <font> 006C +1D5FA <font> 006D +1D5FB <font> 006E +1D5FC <font> 006F +1D5FD <font> 0070 +1D5FE <font> 0071 +1D5FF <font> 0072 +1D600 <font> 0073 +1D601 <font> 0074 +1D602 <font> 0075 +1D603 <font> 0076 +1D604 <font> 0077 +1D605 <font> 0078 +1D606 <font> 0079 +1D607 <font> 007A +1D608 <font> 0041 +1D609 <font> 0042 +1D60A <font> 0043 +1D60B <font> 0044 +1D60C <font> 0045 +1D60D <font> 0046 +1D60E <font> 0047 +1D60F <font> 0048 +1D610 <font> 0049 +1D611 <font> 004A +1D612 <font> 004B +1D613 <font> 004C +1D614 <font> 004D +1D615 <font> 004E +1D616 <font> 004F +1D617 <font> 0050 +1D618 <font> 0051 +1D619 <font> 0052 +1D61A <font> 0053 +1D61B <font> 0054 +1D61C <font> 0055 +1D61D <font> 0056 +1D61E <font> 0057 +1D61F <font> 0058 +1D620 <font> 0059 +1D621 <font> 005A +1D622 <font> 0061 +1D623 <font> 0062 +1D624 <font> 0063 +1D625 <font> 0064 +1D626 <font> 0065 +1D627 <font> 0066 +1D628 <font> 0067 +1D629 <font> 0068 +1D62A <font> 0069 +1D62B <font> 006A +1D62C <font> 006B +1D62D <font> 006C +1D62E <font> 006D +1D62F <font> 006E +1D630 <font> 006F +1D631 <font> 0070 +1D632 <font> 0071 +1D633 <font> 0072 +1D634 <font> 0073 +1D635 <font> 0074 +1D636 <font> 0075 +1D637 <font> 0076 +1D638 <font> 0077 +1D639 <font> 0078 +1D63A <font> 0079 +1D63B <font> 007A +1D63C <font> 0041 +1D63D <font> 0042 +1D63E <font> 0043 +1D63F <font> 0044 +1D640 <font> 0045 +1D641 <font> 0046 +1D642 <font> 0047 +1D643 <font> 0048 +1D644 <font> 0049 +1D645 <font> 004A +1D646 <font> 004B +1D647 <font> 004C +1D648 <font> 004D +1D649 <font> 004E +1D64A <font> 004F +1D64B <font> 0050 +1D64C <font> 0051 +1D64D <font> 0052 +1D64E <font> 0053 +1D64F <font> 0054 +1D650 <font> 0055 +1D651 <font> 0056 +1D652 <font> 0057 +1D653 <font> 0058 +1D654 <font> 0059 +1D655 <font> 005A +1D656 <font> 0061 +1D657 <font> 0062 +1D658 <font> 0063 +1D659 <font> 0064 +1D65A <font> 0065 +1D65B <font> 0066 +1D65C <font> 0067 +1D65D <font> 0068 +1D65E <font> 0069 +1D65F <font> 006A +1D660 <font> 006B +1D661 <font> 006C +1D662 <font> 006D +1D663 <font> 006E +1D664 <font> 006F +1D665 <font> 0070 +1D666 <font> 0071 +1D667 <font> 0072 +1D668 <font> 0073 +1D669 <font> 0074 +1D66A <font> 0075 +1D66B <font> 0076 +1D66C <font> 0077 +1D66D <font> 0078 +1D66E <font> 0079 +1D66F <font> 007A +1D670 <font> 0041 +1D671 <font> 0042 +1D672 <font> 0043 +1D673 <font> 0044 +1D674 <font> 0045 +1D675 <font> 0046 +1D676 <font> 0047 +1D677 <font> 0048 +1D678 <font> 0049 +1D679 <font> 004A +1D67A <font> 004B +1D67B <font> 004C +1D67C <font> 004D +1D67D <font> 004E +1D67E <font> 004F +1D67F <font> 0050 +1D680 <font> 0051 +1D681 <font> 0052 +1D682 <font> 0053 +1D683 <font> 0054 +1D684 <font> 0055 +1D685 <font> 0056 +1D686 <font> 0057 +1D687 <font> 0058 +1D688 <font> 0059 +1D689 <font> 005A +1D68A <font> 0061 +1D68B <font> 0062 +1D68C <font> 0063 +1D68D <font> 0064 +1D68E <font> 0065 +1D68F <font> 0066 +1D690 <font> 0067 +1D691 <font> 0068 +1D692 <font> 0069 +1D693 <font> 006A +1D694 <font> 006B +1D695 <font> 006C +1D696 <font> 006D +1D697 <font> 006E +1D698 <font> 006F +1D699 <font> 0070 +1D69A <font> 0071 +1D69B <font> 0072 +1D69C <font> 0073 +1D69D <font> 0074 +1D69E <font> 0075 +1D69F <font> 0076 +1D6A0 <font> 0077 +1D6A1 <font> 0078 +1D6A2 <font> 0079 +1D6A3 <font> 007A +1D6A8 <font> 0391 +1D6A9 <font> 0392 +1D6AA <font> 0393 +1D6AB <font> 0394 +1D6AC <font> 0395 +1D6AD <font> 0396 +1D6AE <font> 0397 +1D6AF <font> 0398 +1D6B0 <font> 0399 +1D6B1 <font> 039A +1D6B2 <font> 039B +1D6B3 <font> 039C +1D6B4 <font> 039D +1D6B5 <font> 039E +1D6B6 <font> 039F +1D6B7 <font> 03A0 +1D6B8 <font> 03A1 +1D6B9 <font> 03F4 +1D6BA <font> 03A3 +1D6BB <font> 03A4 +1D6BC <font> 03A5 +1D6BD <font> 03A6 +1D6BE <font> 03A7 +1D6BF <font> 03A8 +1D6C0 <font> 03A9 +1D6C1 <font> 2207 +1D6C2 <font> 03B1 +1D6C3 <font> 03B2 +1D6C4 <font> 03B3 +1D6C5 <font> 03B4 +1D6C6 <font> 03B5 +1D6C7 <font> 03B6 +1D6C8 <font> 03B7 +1D6C9 <font> 03B8 +1D6CA <font> 03B9 +1D6CB <font> 03BA +1D6CC <font> 03BB +1D6CD <font> 03BC +1D6CE <font> 03BD +1D6CF <font> 03BE +1D6D0 <font> 03BF +1D6D1 <font> 03C0 +1D6D2 <font> 03C1 +1D6D3 <font> 03C2 +1D6D4 <font> 03C3 +1D6D5 <font> 03C4 +1D6D6 <font> 03C5 +1D6D7 <font> 03C6 +1D6D8 <font> 03C7 +1D6D9 <font> 03C8 +1D6DA <font> 03C9 +1D6DB <font> 2202 +1D6DC <font> 03F5 +1D6DD <font> 03D1 +1D6DE <font> 03F0 +1D6DF <font> 03D5 +1D6E0 <font> 03F1 +1D6E1 <font> 03D6 +1D6E2 <font> 0391 +1D6E3 <font> 0392 +1D6E4 <font> 0393 +1D6E5 <font> 0394 +1D6E6 <font> 0395 +1D6E7 <font> 0396 +1D6E8 <font> 0397 +1D6E9 <font> 0398 +1D6EA <font> 0399 +1D6EB <font> 039A +1D6EC <font> 039B +1D6ED <font> 039C +1D6EE <font> 039D +1D6EF <font> 039E +1D6F0 <font> 039F +1D6F1 <font> 03A0 +1D6F2 <font> 03A1 +1D6F3 <font> 03F4 +1D6F4 <font> 03A3 +1D6F5 <font> 03A4 +1D6F6 <font> 03A5 +1D6F7 <font> 03A6 +1D6F8 <font> 03A7 +1D6F9 <font> 03A8 +1D6FA <font> 03A9 +1D6FB <font> 2207 +1D6FC <font> 03B1 +1D6FD <font> 03B2 +1D6FE <font> 03B3 +1D6FF <font> 03B4 +1D700 <font> 03B5 +1D701 <font> 03B6 +1D702 <font> 03B7 +1D703 <font> 03B8 +1D704 <font> 03B9 +1D705 <font> 03BA +1D706 <font> 03BB +1D707 <font> 03BC +1D708 <font> 03BD +1D709 <font> 03BE +1D70A <font> 03BF +1D70B <font> 03C0 +1D70C <font> 03C1 +1D70D <font> 03C2 +1D70E <font> 03C3 +1D70F <font> 03C4 +1D710 <font> 03C5 +1D711 <font> 03C6 +1D712 <font> 03C7 +1D713 <font> 03C8 +1D714 <font> 03C9 +1D715 <font> 2202 +1D716 <font> 03F5 +1D717 <font> 03D1 +1D718 <font> 03F0 +1D719 <font> 03D5 +1D71A <font> 03F1 +1D71B <font> 03D6 +1D71C <font> 0391 +1D71D <font> 0392 +1D71E <font> 0393 +1D71F <font> 0394 +1D720 <font> 0395 +1D721 <font> 0396 +1D722 <font> 0397 +1D723 <font> 0398 +1D724 <font> 0399 +1D725 <font> 039A +1D726 <font> 039B +1D727 <font> 039C +1D728 <font> 039D +1D729 <font> 039E +1D72A <font> 039F +1D72B <font> 03A0 +1D72C <font> 03A1 +1D72D <font> 03F4 +1D72E <font> 03A3 +1D72F <font> 03A4 +1D730 <font> 03A5 +1D731 <font> 03A6 +1D732 <font> 03A7 +1D733 <font> 03A8 +1D734 <font> 03A9 +1D735 <font> 2207 +1D736 <font> 03B1 +1D737 <font> 03B2 +1D738 <font> 03B3 +1D739 <font> 03B4 +1D73A <font> 03B5 +1D73B <font> 03B6 +1D73C <font> 03B7 +1D73D <font> 03B8 +1D73E <font> 03B9 +1D73F <font> 03BA +1D740 <font> 03BB +1D741 <font> 03BC +1D742 <font> 03BD +1D743 <font> 03BE +1D744 <font> 03BF +1D745 <font> 03C0 +1D746 <font> 03C1 +1D747 <font> 03C2 +1D748 <font> 03C3 +1D749 <font> 03C4 +1D74A <font> 03C5 +1D74B <font> 03C6 +1D74C <font> 03C7 +1D74D <font> 03C8 +1D74E <font> 03C9 +1D74F <font> 2202 +1D750 <font> 03F5 +1D751 <font> 03D1 +1D752 <font> 03F0 +1D753 <font> 03D5 +1D754 <font> 03F1 +1D755 <font> 03D6 +1D756 <font> 0391 +1D757 <font> 0392 +1D758 <font> 0393 +1D759 <font> 0394 +1D75A <font> 0395 +1D75B <font> 0396 +1D75C <font> 0397 +1D75D <font> 0398 +1D75E <font> 0399 +1D75F <font> 039A +1D760 <font> 039B +1D761 <font> 039C +1D762 <font> 039D +1D763 <font> 039E +1D764 <font> 039F +1D765 <font> 03A0 +1D766 <font> 03A1 +1D767 <font> 03F4 +1D768 <font> 03A3 +1D769 <font> 03A4 +1D76A <font> 03A5 +1D76B <font> 03A6 +1D76C <font> 03A7 +1D76D <font> 03A8 +1D76E <font> 03A9 +1D76F <font> 2207 +1D770 <font> 03B1 +1D771 <font> 03B2 +1D772 <font> 03B3 +1D773 <font> 03B4 +1D774 <font> 03B5 +1D775 <font> 03B6 +1D776 <font> 03B7 +1D777 <font> 03B8 +1D778 <font> 03B9 +1D779 <font> 03BA +1D77A <font> 03BB +1D77B <font> 03BC +1D77C <font> 03BD +1D77D <font> 03BE +1D77E <font> 03BF +1D77F <font> 03C0 +1D780 <font> 03C1 +1D781 <font> 03C2 +1D782 <font> 03C3 +1D783 <font> 03C4 +1D784 <font> 03C5 +1D785 <font> 03C6 +1D786 <font> 03C7 +1D787 <font> 03C8 +1D788 <font> 03C9 +1D789 <font> 2202 +1D78A <font> 03F5 +1D78B <font> 03D1 +1D78C <font> 03F0 +1D78D <font> 03D5 +1D78E <font> 03F1 +1D78F <font> 03D6 +1D790 <font> 0391 +1D791 <font> 0392 +1D792 <font> 0393 +1D793 <font> 0394 +1D794 <font> 0395 +1D795 <font> 0396 +1D796 <font> 0397 +1D797 <font> 0398 +1D798 <font> 0399 +1D799 <font> 039A +1D79A <font> 039B +1D79B <font> 039C +1D79C <font> 039D +1D79D <font> 039E +1D79E <font> 039F +1D79F <font> 03A0 +1D7A0 <font> 03A1 +1D7A1 <font> 03F4 +1D7A2 <font> 03A3 +1D7A3 <font> 03A4 +1D7A4 <font> 03A5 +1D7A5 <font> 03A6 +1D7A6 <font> 03A7 +1D7A7 <font> 03A8 +1D7A8 <font> 03A9 +1D7A9 <font> 2207 +1D7AA <font> 03B1 +1D7AB <font> 03B2 +1D7AC <font> 03B3 +1D7AD <font> 03B4 +1D7AE <font> 03B5 +1D7AF <font> 03B6 +1D7B0 <font> 03B7 +1D7B1 <font> 03B8 +1D7B2 <font> 03B9 +1D7B3 <font> 03BA +1D7B4 <font> 03BB +1D7B5 <font> 03BC +1D7B6 <font> 03BD +1D7B7 <font> 03BE +1D7B8 <font> 03BF +1D7B9 <font> 03C0 +1D7BA <font> 03C1 +1D7BB <font> 03C2 +1D7BC <font> 03C3 +1D7BD <font> 03C4 +1D7BE <font> 03C5 +1D7BF <font> 03C6 +1D7C0 <font> 03C7 +1D7C1 <font> 03C8 +1D7C2 <font> 03C9 +1D7C3 <font> 2202 +1D7C4 <font> 03F5 +1D7C5 <font> 03D1 +1D7C6 <font> 03F0 +1D7C7 <font> 03D5 +1D7C8 <font> 03F1 +1D7C9 <font> 03D6 +1D7CE <font> 0030 +1D7CF <font> 0031 +1D7D0 <font> 0032 +1D7D1 <font> 0033 +1D7D2 <font> 0034 +1D7D3 <font> 0035 +1D7D4 <font> 0036 +1D7D5 <font> 0037 +1D7D6 <font> 0038 +1D7D7 <font> 0039 +1D7D8 <font> 0030 +1D7D9 <font> 0031 +1D7DA <font> 0032 +1D7DB <font> 0033 +1D7DC <font> 0034 +1D7DD <font> 0035 +1D7DE <font> 0036 +1D7DF <font> 0037 +1D7E0 <font> 0038 +1D7E1 <font> 0039 +1D7E2 <font> 0030 +1D7E3 <font> 0031 +1D7E4 <font> 0032 +1D7E5 <font> 0033 +1D7E6 <font> 0034 +1D7E7 <font> 0035 +1D7E8 <font> 0036 +1D7E9 <font> 0037 +1D7EA <font> 0038 +1D7EB <font> 0039 +1D7EC <font> 0030 +1D7ED <font> 0031 +1D7EE <font> 0032 +1D7EF <font> 0033 +1D7F0 <font> 0034 +1D7F1 <font> 0035 +1D7F2 <font> 0036 +1D7F3 <font> 0037 +1D7F4 <font> 0038 +1D7F5 <font> 0039 +1D7F6 <font> 0030 +1D7F7 <font> 0031 +1D7F8 <font> 0032 +1D7F9 <font> 0033 +1D7FA <font> 0034 +1D7FB <font> 0035 +1D7FC <font> 0036 +1D7FD <font> 0037 +1D7FE <font> 0038 +1D7FF <font> 0039 +2F800 4E3D +2F801 4E38 +2F802 4E41 +2F803 20122 +2F804 4F60 +2F805 4FAE +2F806 4FBB +2F807 5002 +2F808 507A +2F809 5099 +2F80A 50E7 +2F80B 50CF +2F80C 349E +2F80D 2063A +2F80E 514D +2F80F 5154 +2F810 5164 +2F811 5177 +2F812 2051C +2F813 34B9 +2F814 5167 +2F815 518D +2F816 2054B +2F817 5197 +2F818 51A4 +2F819 4ECC +2F81A 51AC +2F81B 51B5 +2F81C 291DF +2F81D 51F5 +2F81E 5203 +2F81F 34DF +2F820 523B +2F821 5246 +2F822 5272 +2F823 5277 +2F824 3515 +2F825 52C7 +2F826 52C9 +2F827 52E4 +2F828 52FA +2F829 5305 +2F82A 5306 +2F82B 5317 +2F82C 5349 +2F82D 5351 +2F82E 535A +2F82F 5373 +2F830 537D +2F831 2F833 537F +2F834 20A2C +2F835 7070 +2F836 53CA +2F837 53DF +2F838 20B63 +2F839 53EB +2F83A 53F1 +2F83B 5406 +2F83C 549E +2F83D 5438 +2F83E 5448 +2F83F 5468 +2F840 54A2 +2F841 54F6 +2F842 5510 +2F843 5553 +2F844 5563 +2F845 2F846 5584 +2F847 5599 +2F848 55AB +2F849 55B3 +2F84A 55C2 +2F84B 5716 +2F84C 5606 +2F84D 5717 +2F84E 5651 +2F84F 5674 +2F850 5207 +2F851 58EE +2F852 57CE +2F853 57F4 +2F854 580D +2F855 578B +2F856 5832 +2F857 5831 +2F858 58AC +2F859 214E4 +2F85A 58F2 +2F85B 58F7 +2F85C 5906 +2F85D 591A +2F85E 5922 +2F85F 5962 +2F860 216A8 +2F861 216EA +2F862 59EC +2F863 5A1B +2F864 5A27 +2F865 59D8 +2F866 5A66 +2F867 36EE +2F868 2136A +2F869 5B08 +2F86A 2F86B 5B3E +2F86C 219C8 +2F86D 5BC3 +2F86E 5BD8 +2F86F 5BE7 +2F870 5BF3 +2F871 21B18 +2F872 5BFF +2F873 5C06 +2F874 5F33 +2F875 5C22 +2F876 3781 +2F877 5C60 +2F878 5C6E +2F879 5CC0 +2F87A 5C8D +2F87B 21DE4 +2F87C 5D43 +2F87D 21DE6 +2F87E 5D6E +2F87F 5D6B +2F880 5D7C +2F881 5DE1 +2F882 5DE2 +2F883 382F +2F884 5DFD +2F885 5E28 +2F886 5E3D +2F887 5E69 +2F888 3862 +2F889 22183 +2F88A 387C +2F88B 5EB0 +2F88C 5EB3 +2F88D 5EB6 +2F88E 5ECA +2F88F 2A392 +2F890 5EFE +2F891 2F892 22331 +2F893 8201 +2F894 2F895 5F22 +2F896 38C7 +2F897 232B8 +2F898 261DA +2F899 5F62 +2F89A 5F6B +2F89B 38E3 +2F89C 5F9A +2F89D 5FCD +2F89E 5FD7 +2F89F 5FF9 +2F8A0 6081 +2F8A1 393A +2F8A2 391C +2F8A3 6094 +2F8A4 226D4 +2F8A5 60C7 +2F8A6 6148 +2F8A7 614C +2F8A8 614E +2F8A9 614C +2F8AA 617A +2F8AB 618E +2F8AC 61B2 +2F8AD 61A4 +2F8AE 61AF +2F8AF 61DE +2F8B0 61F2 +2F8B1 61F6 +2F8B2 6210 +2F8B3 621B +2F8B4 625D +2F8B5 62B1 +2F8B6 62D4 +2F8B7 6350 +2F8B8 22B0C +2F8B9 633D +2F8BA 62FC +2F8BB 6368 +2F8BC 6383 +2F8BD 63E4 +2F8BE 22BF1 +2F8BF 6422 +2F8C0 63C5 +2F8C1 63A9 +2F8C2 3A2E +2F8C3 6469 +2F8C4 647E +2F8C5 649D +2F8C6 6477 +2F8C7 3A6C +2F8C8 654F +2F8C9 656C +2F8CA 2300A +2F8CB 65E3 +2F8CC 66F8 +2F8CD 6649 +2F8CE 3B19 +2F8CF 6691 +2F8D0 3B08 +2F8D1 3AE4 +2F8D2 5192 +2F8D3 5195 +2F8D4 6700 +2F8D5 669C +2F8D6 80AD +2F8D7 43D9 +2F8D8 6717 +2F8D9 671B +2F8DA 6721 +2F8DB 675E +2F8DC 6753 +2F8DD 233C3 +2F8DE 3B49 +2F8DF 67FA +2F8E0 6785 +2F8E1 6852 +2F8E2 6885 +2F8E3 2346D +2F8E4 688E +2F8E5 681F +2F8E6 6914 +2F8E7 3B9D +2F8E8 6942 +2F8E9 69A3 +2F8EA 69EA +2F8EB 6AA8 +2F8EC 236A3 +2F8ED 6ADB +2F8EE 3C18 +2F8EF 6B21 +2F8F0 238A7 +2F8F1 6B54 +2F8F2 3C4E +2F8F3 6B72 +2F8F4 6B9F +2F8F5 6BBA +2F8F6 6BBB +2F8F7 23A8D +2F8F8 21D0B +2F8F9 23AFA +2F8FA 6C4E +2F8FB 23CBC +2F8FC 6CBF +2F8FD 6CCD +2F8FE 6C67 +2F8FF 6D16 +2F900 6D3E +2F901 6D77 +2F902 6D41 +2F903 6D69 +2F904 6D78 +2F905 6D85 +2F906 23D1E +2F907 6D34 +2F908 6E2F +2F909 6E6E +2F90A 3D33 +2F90B 6ECB +2F90C 6EC7 +2F90D 23ED1 +2F90E 6DF9 +2F90F 6F6E +2F910 23F5E +2F911 23F8E +2F912 6FC6 +2F913 7039 +2F914 701E +2F915 701B +2F916 3D96 +2F917 704A +2F918 707D +2F919 7077 +2F91A 70AD +2F91B 20525 +2F91C 7145 +2F91D 24263 +2F91E 719C +2F91F 43AB +2F920 7228 +2F921 7235 +2F922 7250 +2F923 24608 +2F924 7280 +2F925 7295 +2F926 24735 +2F927 24814 +2F928 737A +2F929 738B +2F92A 3EAC +2F92B 73A5 +2F92C 2F92D 3EB8 +2F92E 7447 +2F92F 745C +2F930 7471 +2F931 7485 +2F932 74CA +2F933 3F1B +2F934 7524 +2F935 24C36 +2F936 753E +2F937 24C92 +2F938 7570 +2F939 2219F +2F93A 7610 +2F93B 24FA1 +2F93C 24FB8 +2F93D 25044 +2F93E 3FFC +2F93F 4008 +2F940 76F4 +2F941 250F3 +2F942 250F2 +2F943 25119 +2F944 25133 +2F945 771E +2F946 2F947 771F +2F948 774A +2F949 4039 +2F94A 778B +2F94B 4046 +2F94C 4096 +2F94D 2541D +2F94E 784E +2F94F 788C +2F950 78CC +2F951 40E3 +2F952 25626 +2F953 7956 +2F954 2569A +2F955 256C5 +2F956 798F +2F957 79EB +2F958 412F +2F959 7A40 +2F95A 7A4A +2F95B 7A4F +2F95C 2597C +2F95D 2F95E 25AA7 +2F95F 7AAE +2F960 4202 +2F961 25BAB +2F962 7BC6 +2F963 7BC9 +2F964 4227 +2F965 25C80 +2F966 7CD2 +2F967 42A0 +2F968 7CE8 +2F969 7CE3 +2F96A 7D00 +2F96B 25F86 +2F96C 7D63 +2F96D 4301 +2F96E 7DC7 +2F96F 7E02 +2F970 7E45 +2F971 4334 +2F972 26228 +2F973 26247 +2F974 4359 +2F975 262D9 +2F976 7F7A +2F977 2633E +2F978 7F95 +2F979 7FFA +2F97A 8005 +2F97B 264DA +2F97C 26523 +2F97D 8060 +2F97E 265A8 +2F97F 8070 +2F980 2335F +2F981 43D5 +2F982 80B2 +2F983 8103 +2F984 440B +2F985 813E +2F986 5AB5 +2F987 267A7 +2F988 267B5 +2F989 23393 +2F98A 2339C +2F98B 8201 +2F98C 8204 +2F98D 8F9E +2F98E 446B +2F98F 8291 +2F990 828B +2F991 829D +2F992 52B3 +2F993 82B1 +2F994 82B3 +2F995 82BD +2F996 82E6 +2F997 26B3C +2F998 82E5 +2F999 831D +2F99A 8363 +2F99B 83AD +2F99C 8323 +2F99D 83BD +2F99E 83E7 +2F99F 8457 +2F9A0 8353 +2F9A1 83CA +2F9A2 83CC +2F9A3 83DC +2F9A4 26C36 +2F9A5 26D6B +2F9A6 26CD5 +2F9A7 452B +2F9A8 84F1 +2F9A9 84F3 +2F9AA 8516 +2F9AB 273CA +2F9AC 8564 +2F9AD 26F2C +2F9AE 455D +2F9AF 4561 +2F9B0 26FB1 +2F9B1 270D2 +2F9B2 456B +2F9B3 8650 +2F9B4 865C +2F9B5 8667 +2F9B6 8669 +2F9B7 86A9 +2F9B8 8688 +2F9B9 870E +2F9BA 86E2 +2F9BB 8779 +2F9BC 8728 +2F9BD 876B +2F9BE 8786 +2F9BF 4D57 +2F9C0 87E1 +2F9C1 8801 +2F9C2 45F9 +2F9C3 8860 +2F9C4 8863 +2F9C5 27667 +2F9C6 88D7 +2F9C7 88DE +2F9C8 4635 +2F9C9 88FA +2F9CA 34BB +2F9CB 278AE +2F9CC 27966 +2F9CD 46BE +2F9CE 46C7 +2F9CF 8AA0 +2F9D0 8AED +2F9D1 8B8A +2F9D2 8C55 +2F9D3 27CA8 +2F9D4 8CAB +2F9D5 8CC1 +2F9D6 8D1B +2F9D7 8D77 +2F9D8 27F2F +2F9D9 20804 +2F9DA 8DCB +2F9DB 8DBC +2F9DC 8DF0 +2F9DD 208DE +2F9DE 8ED4 +2F9DF 8F38 +2F9E0 285D2 +2F9E1 285ED +2F9E2 9094 +2F9E3 90F1 +2F9E4 9111 +2F9E5 2872E +2F9E6 911B +2F9E7 9238 +2F9E8 92D7 +2F9E9 92D8 +2F9EA 927C +2F9EB 93F9 +2F9EC 9415 +2F9ED 28BFA +2F9EE 958B +2F9EF 4995 +2F9F0 95B7 +2F9F1 28D77 +2F9F2 49E6 +2F9F3 96C3 +2F9F4 5DB2 +2F9F5 9723 +2F9F6 29145 +2F9F7 2921A +2F9F8 4A6E +2F9F9 4A76 +2F9FA 97E0 +2F9FB 2940A +2F9FC 4AB2 +2F9FD 29496 +2F9FE 2F9FF 980B +2FA00 9829 +2FA01 295B6 +2FA02 98E2 +2FA03 4B33 +2FA04 9929 +2FA05 99A7 +2FA06 99C2 +2FA07 99FE +2FA08 4BCE +2FA09 29B30 +2FA0A 9B12 +2FA0B 9C40 +2FA0C 9CFD +2FA0D 4CCE +2FA0E 4CED +2FA0F 9D67 +2FA10 2A0CE +2FA11 4CF8 +2FA12 2A105 +2FA13 2A20E +2FA14 2A291 +2FA15 9EBB +2FA16 4D56 +2FA17 9EF9 +2FA18 9EFE +2FA19 9F05 +2FA1A 9F0F +2FA1B 9F16 +2FA1C 9F3B +2FA1D 2A600 +END diff --git a/Master/xemtex/perl/lib/unicore/Exact.pl b/Master/xemtex/perl/lib/unicore/Exact.pl new file mode 100644 index 00000000000..61ba06a9e70 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Exact.pl @@ -0,0 +1,110 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +## +## Data in this file used by ../utf8_heavy.pl +## + +## Mapping from name to filename in ./lib +%utf8::Exact = ( + ASCII => 'ASCII', + All => 'Any', + Alnum => 'Alnum', + Alpha => 'Alpha', + Any => 'Any', + Assigned => 'Assigned', + BidiAL => 'BidiAL', + BidiAN => 'BidiAN', + BidiB => 'BidiB', + BidiBN => 'BidiBN', + BidiCS => 'BidiCS', + BidiEN => 'BidiEN', + BidiES => 'BidiES', + BidiET => 'BidiET', + BidiL => 'BidiL', + BidiLRE => 'BidiLRE', + BidiLRO => 'BidiLRO', + BidiNSM => 'BidiNSM', + BidiON => 'BidiON', + BidiPDF => 'BidiPDF', + BidiR => 'BidiR', + BidiRLE => 'BidiRLE', + BidiRLO => 'BidiRLO', + BidiS => 'BidiS', + BidiWS => 'BidiWS', + Blank => 'Blank', + C => 'C', + Canon => 'Canon', + Cc => 'Cc', + Cf => 'Cf', + Cn => 'Cn', + Cntrl => 'Cntrl', + Co => 'Co', + Compat => 'Compat', + Cs => 'Cs', + DCcircle => 'DCcircle', + DCcompat => 'DCcompat', + DCfinal => 'DCfinal', + DCfont => 'DCfont', + DCfraction => 'DCfracti', + DCinitial => 'DCinitia', + DCisolated => 'DCisolat', + DCmedial => 'DCmedial', + DCnarrow => 'DCnarrow', + DCnoBreak => 'DCnoBrea', + DCsmall => 'DCsmall', + DCsquare => 'DCsquare', + DCsub => 'DCsub', + DCsuper => 'DCsuper', + DCvertical => 'DCvertic', + DCwide => 'DCwide', + Digit => 'Digit', + Graph => 'Graph', + L => 'L', +'L&' => 'L_', + Ll => 'Ll', + Lm => 'Lm', + Lo => 'Lo', + Lower => 'Lower', + Lt => 'Lt', + Lu => 'Lu', + M => 'M', + Mc => 'Mc', + Me => 'Me', + Mirrored => 'Mirrored', + Mn => 'Mn', + N => 'N', + Nd => 'Nd', + Nl => 'Nl', + No => 'No', + P => 'P', + Pc => 'Pc', + Pd => 'Pd', + Pe => 'Pe', + Pf => 'Pf', + Pi => 'Pi', + Po => 'Po', + Print => 'Print', + Ps => 'Ps', + Punct => 'Punct', + S => 'S', + Sc => 'Sc', + Sk => 'Sk', + Sm => 'Sm', + So => 'So', + Space => 'Space', + SpacePerl => 'SpacePer', + Title => 'Title', + Upper => 'Upper', + Word => 'Word', + XDigit => 'XDigit', + Z => 'Z', + Zl => 'Zl', + Zp => 'Zp', + Zs => 'Zs', + _CanonDCIJ => '_CanonDC', + _CaseIgnorable => '_CaseIgn', + _CombAbove => '_CombAbo', +); +1; diff --git a/Master/xemtex/perl/lib/unicore/JamoShort.pl b/Master/xemtex/perl/lib/unicore/JamoShort.pl new file mode 100644 index 00000000000..4ab02fd5449 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/JamoShort.pl @@ -0,0 +1,73 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +1100 G +1101 GG +1102 N +1103 D +1104 DD +1105 R +1106 M +1107 B +1108 BB +1109 S +110A SS +110B +110C J +110D JJ +110E C +110F K +1110 T +1111 P +1112 H +1161 A +1162 AE +1163 YA +1164 YAE +1165 EO +1166 E +1167 YEO +1168 YE +1169 O +116A WA +116B WAE +116C OE +116D YO +116E U +116F WEO +1170 WE +1171 WI +1172 YU +1173 EU +1174 YI +1175 I +11A8 G +11A9 GG +11AA GS +11AB N +11AC NJ +11AD NH +11AE D +11AF L +11B0 LG +11B1 LM +11B2 LB +11B3 LS +11B4 LT +11B5 LP +11B6 LH +11B7 M +11B8 B +11B9 BS +11BA S +11BB SS +11BC NG +11BD J +11BE C +11BF K +11C0 T +11C1 P +11C2 H +END diff --git a/Master/xemtex/perl/lib/unicore/Lbrk.pl b/Master/xemtex/perl/lib/unicore/Lbrk.pl new file mode 100644 index 00000000000..0a4eb153697 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Lbrk.pl @@ -0,0 +1,1073 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0000 0008 CM +0009 BA +000A LF +000B CM +000C BK +000D CR +000E 001F CM +0020 SP +0021 EX +0022 QU +0023 AL +0024 PR +0025 PO +0026 AL +0027 QU +0028 OP +0029 CL +002A AL +002B PR +002C IS +002D HY +002E IS +002F SY +0030 0039 NU +003A 003B IS +003C 003E AL +003F EX +0040 005A AL +005B OP +005C PR +005D CL +005E 007A AL +007B OP +007C BA +007D CL +007E AL +007F 009F CM +00A0 GL +00A1 AI +00A2 PO +00A3 00A5 PR +00A6 AL +00A7 00A8 AI +00A9 AL +00AA AI +00AB QU +00AC AL +00AD BA +00AE 00AF AL +00B0 PO +00B1 PR +00B2 00B3 AI +00B4 BB +00B5 AL +00B6 00BA AI +00BB QU +00BC 00BF AI +00C0 00C5 AL +00C6 AI +00C7 00CF AL +00D0 AI +00D1 00D6 AL +00D7 00D8 AI +00D9 00DD AL +00DE 00E1 AI +00E2 00E5 AL +00E6 AI +00E7 AL +00E8 00EA AI +00EB AL +00EC 00ED AI +00EE 00EF AL +00F0 AI +00F1 AL +00F2 00F3 AI +00F4 00F6 AL +00F7 00FA AI +00FB AL +00FC AI +00FD AL +00FE AI +00FF 0100 AL +0101 AI +0102 0110 AL +0111 AI +0112 AL +0113 AI +0114 011A AL +011B AI +011C 0125 AL +0126 0127 AI +0128 012A AL +012B AI +012C 0130 AL +0131 0133 AI +0134 0137 AL +0138 AI +0139 013E AL +013F 0142 AI +0143 AL +0144 AI +0145 0147 AL +0148 014A AI +014B 014C AL +014D AI +014E 0151 AL +0152 0153 AI +0154 0165 AL +0166 0167 AI +0168 016A AL +016B AI +016C 01CD AL +01CE AI +01CF AL +01D0 AI +01D1 AL +01D2 AI +01D3 AL +01D4 AI +01D5 AL +01D6 AI +01D7 AL +01D8 AI +01D9 AL +01DA AI +01DB AL +01DC AI +01DD 0220 AL +0222 0233 AL +0250 AL +0251 AI +0252 0260 AL +0261 AI +0262 02AD AL +02B0 02C6 AL +02C7 AI +02C8 BB +02C9 02CB AI +02CC BB +02CD AI +02CE 02CF AL +02D0 AI +02D1 02D7 AL +02D8 02DB AI +02DC AL +02DD AI +02DE 02EE AL +0300 034F CM +0360 036F CM +0374 0375 AL +037A AL +037E AL +0384 038A AL +038C AL +038E 0390 AL +0391 03A1 AI +03A3 03A9 AI +03AA 03B0 AL +03B1 03C1 AI +03C2 AL +03C3 03C9 AI +03CA 03CE AL +03D0 03F6 AL +0400 AL +0401 AI +0402 040F AL +0410 044F AI +0450 AL +0451 AI +0452 0482 AL +0483 0486 CM +0488 0489 CM +048A 04CE AL +04D0 04F5 AL +04F8 04F9 AL +0500 050F AL +0531 0556 AL +0559 055F AL +0561 0587 AL +0589 IS +058A BA +0591 05A1 CM +05A3 05B9 CM +05BB 05BD CM +05BE AL +05BF CM +05C0 AL +05C1 05C2 CM +05C3 AL +05C4 CM +05D0 05EA AL +05F0 05F4 AL +060C AL +061B AL +061F AL +0621 063A AL +0640 064A AL +064B 0655 CM +0660 0669 NU +066A 066F AL +0670 CM +0671 06D5 AL +06D6 06E4 CM +06E5 06E6 AL +06E7 06E8 CM +06E9 AL +06EA 06ED CM +06F0 06F9 NU +06FA 06FE AL +0700 070D AL +070F CM +0710 AL +0711 CM +0712 072C AL +0730 074A CM +0780 07A5 AL +07A6 07B0 CM +07B1 AL +0901 0903 CM +0905 0939 AL +093C CM +093D AL +093E 094D CM +0950 AL +0951 0954 CM +0958 0961 AL +0962 0963 CM +0964 0965 AL +0966 096F NU +0970 AL +0981 0983 CM +0985 098C AL +098F 0990 AL +0993 09A8 AL +09AA 09B0 AL +09B2 AL +09B6 09B9 AL +09BC CM +09BE 09C4 CM +09C7 09C8 CM +09CB 09CD CM +09D7 CM +09DC 09DD AL +09DF 09E1 AL +09E2 09E3 CM +09E6 09EF NU +09F0 09F1 AL +09F2 09F3 PR +09F4 09FA AL +0A02 CM +0A05 0A0A AL +0A0F 0A10 AL +0A13 0A28 AL +0A2A 0A30 AL +0A32 0A33 AL +0A35 0A36 AL +0A38 0A39 AL +0A3C CM +0A3E 0A42 CM +0A47 0A48 CM +0A4B 0A4D CM +0A59 0A5C AL +0A5E AL +0A66 0A6F NU +0A70 0A71 CM +0A72 0A74 AL +0A81 0A83 CM +0A85 0A8B AL +0A8D AL +0A8F 0A91 AL +0A93 0AA8 AL +0AAA 0AB0 AL +0AB2 0AB3 AL +0AB5 0AB9 AL +0ABC CM +0ABD AL +0ABE 0AC5 CM +0AC7 0AC9 CM +0ACB 0ACD CM +0AD0 AL +0AE0 AL +0AE6 0AEF NU +0B01 0B03 CM +0B05 0B0C AL +0B0F 0B10 AL +0B13 0B28 AL +0B2A 0B30 AL +0B32 0B33 AL +0B36 0B39 AL +0B3C CM +0B3D AL +0B3E 0B43 CM +0B47 0B48 CM +0B4B 0B4D CM +0B56 0B57 CM +0B5C 0B5D AL +0B5F 0B61 AL +0B66 0B6F NU +0B70 AL +0B82 CM +0B83 AL +0B85 0B8A AL +0B8E 0B90 AL +0B92 0B95 AL +0B99 0B9A AL +0B9C AL +0B9E 0B9F AL +0BA3 0BA4 AL +0BA8 0BAA AL +0BAE 0BB5 AL +0BB7 0BB9 AL +0BBE 0BC2 CM +0BC6 0BC8 CM +0BCA 0BCD CM +0BD7 CM +0BE7 0BEF NU +0BF0 0BF2 AL +0C01 0C03 CM +0C05 0C0C AL +0C0E 0C10 AL +0C12 0C28 AL +0C2A 0C33 AL +0C35 0C39 AL +0C3E 0C44 CM +0C46 0C48 CM +0C4A 0C4D CM +0C55 0C56 CM +0C60 0C61 AL +0C66 0C6F NU +0C82 0C83 CM +0C85 0C8C AL +0C8E 0C90 AL +0C92 0CA8 AL +0CAA 0CB3 AL +0CB5 0CB9 AL +0CBE 0CC4 CM +0CC6 0CC8 CM +0CCA 0CCD CM +0CD5 0CD6 CM +0CDE AL +0CE0 0CE1 AL +0CE6 0CEF NU +0D02 0D03 CM +0D05 0D0C AL +0D0E 0D10 AL +0D12 0D28 AL +0D2A 0D39 AL +0D3E 0D43 CM +0D46 0D48 CM +0D4A 0D4D CM +0D57 CM +0D60 0D61 AL +0D66 0D6F NU +0D82 0D83 CM +0D85 0D96 AL +0D9A 0DB1 AL +0DB3 0DBB AL +0DBD AL +0DC0 0DC6 AL +0DCA CM +0DCF 0DD4 CM +0DD6 CM +0DD8 0DDF CM +0DF2 0DF3 CM +0DF4 AL +0E01 0E30 SA +0E31 CM +0E32 0E33 SA +0E34 0E3A CM +0E3F PR +0E40 0E46 SA +0E47 0E4E CM +0E4F AL +0E50 0E59 NU +0E5A 0E5B NS +0E81 0E82 SA +0E84 SA +0E87 0E88 SA +0E8A SA +0E8D SA +0E94 0E97 SA +0E99 0E9F SA +0EA1 0EA3 SA +0EA5 SA +0EA7 SA +0EAA 0EAB SA +0EAD 0EB0 SA +0EB1 CM +0EB2 0EB3 SA +0EB4 0EB9 CM +0EBB 0EBC CM +0EBD SA +0EC0 0EC4 SA +0EC6 SA +0EC8 0ECD CM +0ED0 0ED9 NU +0EDC 0EDD SA +0F00 0F0A AL +0F0B BA +0F0C GL +0F0D 0F17 AL +0F18 0F19 CM +0F1A 0F1F AL +0F20 0F29 NU +0F2A 0F34 AL +0F35 CM +0F36 AL +0F37 CM +0F38 AL +0F39 CM +0F3A OP +0F3B CL +0F3C OP +0F3D CL +0F3E 0F3F CM +0F40 0F47 AL +0F49 0F6A AL +0F71 0F84 CM +0F85 AL +0F86 0F87 CM +0F88 0F8B AL +0F90 0F97 CM +0F99 0FBC CM +0FBE 0FC5 AL +0FC6 CM +0FC7 0FCC AL +0FCF AL +1000 1021 SA +1023 1027 SA +1029 102A SA +102C 1032 CM +1036 1039 CM +1040 1049 NU +104A 104F AL +1050 1055 SA +1056 1059 CM +10A0 10C5 AL +10D0 10F8 AL +10FB AL +1100 1159 ID +115F ID +1160 11A2 CM +11A8 11F9 CM +1200 1206 AL +1208 1246 AL +1248 AL +124A 124D AL +1250 1256 AL +1258 AL +125A 125D AL +1260 1286 AL +1288 AL +128A 128D AL +1290 12AE AL +12B0 AL +12B2 12B5 AL +12B8 12BE AL +12C0 AL +12C2 12C5 AL +12C8 12CE AL +12D0 12D6 AL +12D8 12EE AL +12F0 130E AL +1310 AL +1312 1315 AL +1318 131E AL +1320 1346 AL +1348 135A AL +1361 BA +1362 1368 AL +1369 1371 NU +1372 137C AL +13A0 13F4 AL +1401 1676 AL +1680 BA +1681 169A AL +169B OP +169C CL +16A0 16F0 AL +1700 170C AL +170E 1711 AL +1712 1714 CM +1720 1731 AL +1732 1734 CM +1735 1736 AL +1740 1751 AL +1752 1753 CM +1760 176C AL +176E 1770 AL +1772 1773 CM +1780 17B3 SA +17B4 17D3 CM +17D4 NS +17D5 BA +17D6 17DA NS +17DB PR +17DC AL +17E0 17E9 NU +1800 1805 AL +1806 BB +1807 180A AL +180B 180E CM +1810 1819 NU +1820 1877 AL +1880 18A8 AL +18A9 CM +1E00 1E9B AL +1EA0 1EF9 AL +1F00 1F15 AL +1F18 1F1D AL +1F20 1F45 AL +1F48 1F4D AL +1F50 1F57 AL +1F59 AL +1F5B AL +1F5D AL +1F5F 1F7D AL +1F80 1FB4 AL +1FB6 1FC4 AL +1FC6 1FD3 AL +1FD6 1FDB AL +1FDD 1FEF AL +1FF2 1FF4 AL +1FF6 1FFE AL +2000 2006 BA +2007 GL +2008 200A BA +200B ZW +200C 200F CM +2010 BA +2011 GL +2012 2013 BA +2014 B2 +2015 2016 AI +2017 AL +2018 2019 QU +201A OP +201B 201D QU +201E OP +201F QU +2020 2021 AI +2022 2023 AL +2024 2026 IN +2027 BA +2028 2029 BK +202A 202E CM +202F GL +2030 2037 PO +2038 AL +2039 203A QU +203B AI +203C NS +203D 2043 AL +2044 NS +2045 OP +2046 CL +2047 2052 AL +2057 AL +205F BA +2060 GL +2061 2063 AL +206A 206F CM +2070 2071 AL +2074 AI +2075 207C AL +207D OP +207E CL +207F AI +2080 AL +2081 2084 AI +2085 208C AL +208D OP +208E CL +20A0 20A6 PR +20A7 PO +20A8 20B1 PR +20D0 20EA CM +2100 2102 AL +2103 PO +2104 AL +2105 AI +2106 2108 AL +2109 PO +210A 2112 AL +2113 AI +2114 2115 AL +2116 PR +2117 2120 AL +2121 2122 AI +2123 2125 AL +2126 PO +2127 212A AL +212B AI +212C 213A AL +213D 213F AL +2140 AI +2141 214B AL +2153 AL +2154 2155 AI +2156 215A AL +215B AI +215C 215D AL +215E AI +215F AL +2160 216B AI +216C 216F AL +2170 2179 AI +217A 2183 AL +2190 2199 AI +219A 21D1 AL +21D2 AI +21D3 AL +21D4 AI +21D5 21FF AL +2200 AI +2201 AL +2202 2203 AI +2204 2206 AL +2207 2208 AI +2209 220A AL +220B AI +220C 220E AL +220F AI +2210 AL +2211 AI +2212 2213 PR +2214 AL +2215 AI +2216 2219 AL +221A AI +221B 221C AL +221D 2220 AI +2221 2222 AL +2223 AI +2224 AL +2225 AI +2226 AL +2227 222C AI +222D AL +222E AI +222F 2233 AL +2234 2237 AI +2238 223B AL +223C 223D AI +223E 2247 AL +2248 AI +2249 224B AL +224C AI +224D 2251 AL +2252 AI +2253 225F AL +2260 2261 AI +2262 2263 AL +2264 2267 AI +2268 2269 AL +226A 226B AI +226C 226D AL +226E 226F AI +2270 2281 AL +2282 2283 AI +2284 2285 AL +2286 2287 AI +2288 2294 AL +2295 AI +2296 2298 AL +2299 AI +229A 22A4 AL +22A5 AI +22A6 22BE AL +22BF AI +22C0 2311 AL +2312 AI +2313 2328 AL +2329 OP +232A CL +232B 23B3 AL +23B4 OP +23B5 CL +23B6 QU +23B7 23CE AL +2400 2426 AL +2440 244A AL +2460 24BF AI +24C0 24CF AL +24D0 24E9 AI +24EA AL +24EB 24FE AI +2500 254B AI +254C 254F AL +2550 2574 AI +2575 257F AL +2580 258F AI +2590 2591 AL +2592 2595 AI +2596 259F AL +25A0 25A1 AI +25A2 AL +25A3 25A9 AI +25AA 25B1 AL +25B2 25B3 AI +25B4 25B5 AL +25B6 25B7 AI +25B8 25BB AL +25BC 25BD AI +25BE 25BF AL +25C0 25C1 AI +25C2 25C5 AL +25C6 25C8 AI +25C9 25CA AL +25CB AI +25CC 25CD AL +25CE 25D1 AI +25D2 25E1 AL +25E2 25E5 AI +25E6 25EE AL +25EF AI +25F0 2604 AL +2605 2606 AI +2607 2608 AL +2609 AI +260A 260D AL +260E 260F AI +2610 2613 AL +2616 2617 AI +2619 261B AL +261C AI +261D AL +261E AI +261F 263F AL +2640 AI +2641 AL +2642 AI +2643 265F AL +2660 2661 AI +2662 AL +2663 2665 AI +2666 AL +2667 266A AI +266B AL +266C 266D AI +266E AL +266F AI +2670 267D AL +2680 2689 AL +2701 2704 AL +2706 2709 AL +270C 2727 AL +2729 274B AL +274D AL +274F 2752 AL +2756 AL +2758 275A AL +275B 275E QU +2761 AL +2762 2763 EX +2764 2767 AL +2768 OP +2769 CL +276A OP +276B CL +276C OP +276D CL +276E OP +276F CL +2770 OP +2771 CL +2772 OP +2773 CL +2774 OP +2775 CL +2776 2794 AL +2798 27AF AL +27B1 27BE AL +27D0 27E5 AL +27E6 OP +27E7 CL +27E8 OP +27E9 CL +27EA OP +27EB CL +27F0 2982 AL +2983 OP +2984 CL +2985 OP +2986 CL +2987 OP +2988 CL +2989 OP +298A CL +298B OP +298C CL +298D OP +298E CL +298F OP +2990 CL +2991 OP +2992 CL +2993 OP +2994 CL +2995 OP +2996 CL +2997 OP +2998 CL +2999 29D7 AL +29D8 OP +29D9 CL +29DA OP +29DB CL +29DC 29FB AL +29FC OP +29FD CL +29FE 2AFF AL +2E80 2E99 ID +2E9B 2EF3 ID +2F00 2FD5 ID +2FF0 2FFB ID +3000 ID +3001 3002 CL +3003 3004 ID +3005 NS +3006 3007 ID +3008 OP +3009 CL +300A OP +300B CL +300C OP +300D CL +300E OP +300F CL +3010 OP +3011 CL +3012 3013 ID +3014 OP +3015 CL +3016 OP +3017 CL +3018 OP +3019 CL +301A OP +301B CL +301C NS +301D OP +301E 301F CL +3020 3029 ID +302A 302F CM +3030 303A ID +303B 303C NS +303D 303F ID +3041 NS +3042 ID +3043 NS +3044 ID +3045 NS +3046 ID +3047 NS +3048 ID +3049 NS +304A 3062 ID +3063 NS +3064 3082 ID +3083 NS +3084 ID +3085 NS +3086 ID +3087 NS +3088 308D ID +308E NS +308F 3094 ID +3095 3096 NS +3099 309A CM +309B 309E NS +309F ID +30A0 30A1 NS +30A2 ID +30A3 NS +30A4 ID +30A5 NS +30A6 ID +30A7 NS +30A8 ID +30A9 NS +30AA 30C2 ID +30C3 NS +30C4 30E2 ID +30E3 NS +30E4 ID +30E5 NS +30E6 ID +30E7 NS +30E8 30ED ID +30EE NS +30EF 30F4 ID +30F5 30F6 NS +30F7 30FA ID +30FB NS +30FC ID +30FD NS +30FE 30FF ID +3105 312C ID +3131 318E ID +3190 31B7 ID +31F0 31FF NS +3200 321C ID +3220 3243 ID +3251 327B ID +327F 32CB ID +32D0 32FE ID +3300 3376 ID +337B 33DD ID +33E0 33FE ID +3400 4DB5 ID +4E00 9FA5 ID +A000 A48C ID +A490 A4C6 ID +AC00 D7A3 ID +D800 DFFF SG +E000 F8FF XX +F900 FA2D ID +FA30 FA6A ID +FB00 FB06 AL +FB13 FB17 AL +FB1D AL +FB1E CM +FB1F FB36 AL +FB38 FB3C AL +FB3E AL +FB40 FB41 AL +FB43 FB44 AL +FB46 FBB1 AL +FBD3 FD3D AL +FD3E OP +FD3F CL +FD50 FD8F AL +FD92 FDC7 AL +FDF0 FDFB AL +FDFC PO +FE00 FE0F CM +FE20 FE23 CM +FE30 FE34 ID +FE35 OP +FE36 CL +FE37 OP +FE38 CL +FE39 OP +FE3A CL +FE3B OP +FE3C CL +FE3D OP +FE3E CL +FE3F OP +FE40 CL +FE41 OP +FE42 CL +FE43 OP +FE44 CL +FE45 FE46 ID +FE49 FE4F ID +FE50 CL +FE51 ID +FE52 CL +FE54 FE55 NS +FE56 FE57 EX +FE58 ID +FE59 OP +FE5A CL +FE5B OP +FE5C CL +FE5D OP +FE5E CL +FE5F FE66 ID +FE68 ID +FE69 PR +FE6A PO +FE6B ID +FE70 FE74 AL +FE76 FEFC AL +FEFF GL +FF01 EX +FF02 FF03 ID +FF04 PR +FF05 PO +FF06 FF07 ID +FF08 OP +FF09 CL +FF0A FF0B ID +FF0C CL +FF0D ID +FF0E CL +FF0F FF19 ID +FF1A FF1B NS +FF1C FF1E ID +FF1F EX +FF20 FF3A ID +FF3B OP +FF3C ID +FF3D CL +FF3E FF5A ID +FF5B OP +FF5C ID +FF5D CL +FF5E ID +FF5F OP +FF60 FF61 CL +FF62 OP +FF63 FF64 CL +FF65 NS +FF66 AL +FF67 FF70 NS +FF71 FF9D AL +FF9E FF9F NS +FFA0 FFBE AL +FFC2 FFC7 AL +FFCA FFCF AL +FFD2 FFD7 AL +FFDA FFDC AL +FFE0 PO +FFE1 PR +FFE2 FFE4 ID +FFE5 FFE6 PR +FFE8 FFEE AL +FFF9 FFFB CM +FFFC CB +FFFD AI +10300 1031E AL +10320 10323 AL +10330 1034A AL +10400 10425 AL +10428 1044D AL +1D000 1D0F5 AL +1D100 1D126 AL +1D12A 1D164 AL +1D165 1D169 CM +1D16A 1D16C AL +1D16D 1D182 CM +1D183 1D184 AL +1D185 1D18B CM +1D18C 1D1A9 AL +1D1AA 1D1AD CM +1D1AE 1D1DD AL +1D400 1D454 AL +1D456 1D49C AL +1D49E 1D49F AL +1D4A2 AL +1D4A5 1D4A6 AL +1D4A9 1D4AC AL +1D4AE 1D4B9 AL +1D4BB AL +1D4BD 1D4C0 AL +1D4C2 1D4C3 AL +1D4C5 1D505 AL +1D507 1D50A AL +1D50D 1D514 AL +1D516 1D51C AL +1D51E 1D539 AL +1D53B 1D53E AL +1D540 1D544 AL +1D546 AL +1D54A 1D550 AL +1D552 1D6A3 AL +1D6A8 1D7C9 AL +1D7CE 1D7FF NU +20000 2A6D6 ID +2F800 2FA1D ID +E0001 CM +E0020 E007F CM +F0000 FFFFD XX +100000 10FFFD XX +END diff --git a/Master/xemtex/perl/lib/unicore/Name.pl b/Master/xemtex/perl/lib/unicore/Name.pl new file mode 100644 index 00000000000..2dde9fdd3b1 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Name.pl @@ -0,0 +1,13869 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0000 NULL +0001 START OF HEADING +0002 START OF TEXT +0003 END OF TEXT +0004 END OF TRANSMISSION +0005 ENQUIRY +0006 ACKNOWLEDGE +0007 BELL +0008 BACKSPACE +0009 CHARACTER TABULATION +000A LINE FEED (LF) +000B LINE TABULATION +000C FORM FEED (FF) +000D CARRIAGE RETURN (CR) +000E SHIFT OUT +000F SHIFT IN +0010 DATA LINK ESCAPE +0011 DEVICE CONTROL ONE +0012 DEVICE CONTROL TWO +0013 DEVICE CONTROL THREE +0014 DEVICE CONTROL FOUR +0015 NEGATIVE ACKNOWLEDGE +0016 SYNCHRONOUS IDLE +0017 END OF TRANSMISSION BLOCK +0018 CANCEL +0019 END OF MEDIUM +001A SUBSTITUTE +001B ESCAPE +001C INFORMATION SEPARATOR FOUR +001D INFORMATION SEPARATOR THREE +001E INFORMATION SEPARATOR TWO +001F INFORMATION SEPARATOR ONE +0020 SPACE +0021 EXCLAMATION MARK +0022 QUOTATION MARK +0023 NUMBER SIGN +0024 DOLLAR SIGN +0025 PERCENT SIGN +0026 AMPERSAND +0027 APOSTROPHE +0028 LEFT PARENTHESIS +0029 RIGHT PARENTHESIS +002A ASTERISK +002B PLUS SIGN +002C COMMA +002D HYPHEN-MINUS +002E FULL STOP +002F SOLIDUS +0030 DIGIT ZERO +0031 DIGIT ONE +0032 DIGIT TWO +0033 DIGIT THREE +0034 DIGIT FOUR +0035 DIGIT FIVE +0036 DIGIT SIX +0037 DIGIT SEVEN +0038 DIGIT EIGHT +0039 DIGIT NINE +003A COLON +003B SEMICOLON +003C LESS-THAN SIGN +003D EQUALS SIGN +003E GREATER-THAN SIGN +003F QUESTION MARK +0040 COMMERCIAL AT +0041 LATIN CAPITAL LETTER A +0042 LATIN CAPITAL LETTER B +0043 LATIN CAPITAL LETTER C +0044 LATIN CAPITAL LETTER D +0045 LATIN CAPITAL LETTER E +0046 LATIN CAPITAL LETTER F +0047 LATIN CAPITAL LETTER G +0048 LATIN CAPITAL LETTER H +0049 LATIN CAPITAL LETTER I +004A LATIN CAPITAL LETTER J +004B LATIN CAPITAL LETTER K +004C LATIN CAPITAL LETTER L +004D LATIN CAPITAL LETTER M +004E LATIN CAPITAL LETTER N +004F LATIN CAPITAL LETTER O +0050 LATIN CAPITAL LETTER P +0051 LATIN CAPITAL LETTER Q +0052 LATIN CAPITAL LETTER R +0053 LATIN CAPITAL LETTER S +0054 LATIN CAPITAL LETTER T +0055 LATIN CAPITAL LETTER U +0056 LATIN CAPITAL LETTER V +0057 LATIN CAPITAL LETTER W +0058 LATIN CAPITAL LETTER X +0059 LATIN CAPITAL LETTER Y +005A LATIN CAPITAL LETTER Z +005B LEFT SQUARE BRACKET +005C REVERSE SOLIDUS +005D RIGHT SQUARE BRACKET +005E CIRCUMFLEX ACCENT +005F LOW LINE +0060 GRAVE ACCENT +0061 LATIN SMALL LETTER A +0062 LATIN SMALL LETTER B +0063 LATIN SMALL LETTER C +0064 LATIN SMALL LETTER D +0065 LATIN SMALL LETTER E +0066 LATIN SMALL LETTER F +0067 LATIN SMALL LETTER G +0068 LATIN SMALL LETTER H +0069 LATIN SMALL LETTER I +006A LATIN SMALL LETTER J +006B LATIN SMALL LETTER K +006C LATIN SMALL LETTER L +006D LATIN SMALL LETTER M +006E LATIN SMALL LETTER N +006F LATIN SMALL LETTER O +0070 LATIN SMALL LETTER P +0071 LATIN SMALL LETTER Q +0072 LATIN SMALL LETTER R +0073 LATIN SMALL LETTER S +0074 LATIN SMALL LETTER T +0075 LATIN SMALL LETTER U +0076 LATIN SMALL LETTER V +0077 LATIN SMALL LETTER W +0078 LATIN SMALL LETTER X +0079 LATIN SMALL LETTER Y +007A LATIN SMALL LETTER Z +007B LEFT CURLY BRACKET +007C VERTICAL LINE +007D RIGHT CURLY BRACKET +007E TILDE +007F DELETE +0080 0081 <control> +0082 BREAK PERMITTED HERE +0083 NO BREAK HERE +0084 <control> +0085 NEXT LINE (NEL) +0086 START OF SELECTED AREA +0087 END OF SELECTED AREA +0088 CHARACTER TABULATION SET +0089 CHARACTER TABULATION WITH JUSTIFICATION +008A LINE TABULATION SET +008B PARTIAL LINE FORWARD +008C PARTIAL LINE BACKWARD +008D REVERSE LINE FEED +008E SINGLE SHIFT TWO +008F SINGLE SHIFT THREE +0090 DEVICE CONTROL STRING +0091 PRIVATE USE ONE +0092 PRIVATE USE TWO +0093 SET TRANSMIT STATE +0094 CANCEL CHARACTER +0095 MESSAGE WAITING +0096 START OF GUARDED AREA +0097 END OF GUARDED AREA +0098 START OF STRING +0099 <control> +009A SINGLE CHARACTER INTRODUCER +009B CONTROL SEQUENCE INTRODUCER +009C STRING TERMINATOR +009D OPERATING SYSTEM COMMAND +009E PRIVACY MESSAGE +009F APPLICATION PROGRAM COMMAND +00A0 NO-BREAK SPACE +00A1 INVERTED EXCLAMATION MARK +00A2 CENT SIGN +00A3 POUND SIGN +00A4 CURRENCY SIGN +00A5 YEN SIGN +00A6 BROKEN BAR +00A7 SECTION SIGN +00A8 DIAERESIS +00A9 COPYRIGHT SIGN +00AA FEMININE ORDINAL INDICATOR +00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK +00AC NOT SIGN +00AD SOFT HYPHEN +00AE REGISTERED SIGN +00AF MACRON +00B0 DEGREE SIGN +00B1 PLUS-MINUS SIGN +00B2 SUPERSCRIPT TWO +00B3 SUPERSCRIPT THREE +00B4 ACUTE ACCENT +00B5 MICRO SIGN +00B6 PILCROW SIGN +00B7 MIDDLE DOT +00B8 CEDILLA +00B9 SUPERSCRIPT ONE +00BA MASCULINE ORDINAL INDICATOR +00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK +00BC VULGAR FRACTION ONE QUARTER +00BD VULGAR FRACTION ONE HALF +00BE VULGAR FRACTION THREE QUARTERS +00BF INVERTED QUESTION MARK +00C0 LATIN CAPITAL LETTER A WITH GRAVE +00C1 LATIN CAPITAL LETTER A WITH ACUTE +00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX +00C3 LATIN CAPITAL LETTER A WITH TILDE +00C4 LATIN CAPITAL LETTER A WITH DIAERESIS +00C5 LATIN CAPITAL LETTER A WITH RING ABOVE +00C6 LATIN CAPITAL LETTER AE +00C7 LATIN CAPITAL LETTER C WITH CEDILLA +00C8 LATIN CAPITAL LETTER E WITH GRAVE +00C9 LATIN CAPITAL LETTER E WITH ACUTE +00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX +00CB LATIN CAPITAL LETTER E WITH DIAERESIS +00CC LATIN CAPITAL LETTER I WITH GRAVE +00CD LATIN CAPITAL LETTER I WITH ACUTE +00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX +00CF LATIN CAPITAL LETTER I WITH DIAERESIS +00D0 LATIN CAPITAL LETTER ETH +00D1 LATIN CAPITAL LETTER N WITH TILDE +00D2 LATIN CAPITAL LETTER O WITH GRAVE +00D3 LATIN CAPITAL LETTER O WITH ACUTE +00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX +00D5 LATIN CAPITAL LETTER O WITH TILDE +00D6 LATIN CAPITAL LETTER O WITH DIAERESIS +00D7 MULTIPLICATION SIGN +00D8 LATIN CAPITAL LETTER O WITH STROKE +00D9 LATIN CAPITAL LETTER U WITH GRAVE +00DA LATIN CAPITAL LETTER U WITH ACUTE +00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX +00DC LATIN CAPITAL LETTER U WITH DIAERESIS +00DD LATIN CAPITAL LETTER Y WITH ACUTE +00DE LATIN CAPITAL LETTER THORN +00DF LATIN SMALL LETTER SHARP S +00E0 LATIN SMALL LETTER A WITH GRAVE +00E1 LATIN SMALL LETTER A WITH ACUTE +00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX +00E3 LATIN SMALL LETTER A WITH TILDE +00E4 LATIN SMALL LETTER A WITH DIAERESIS +00E5 LATIN SMALL LETTER A WITH RING ABOVE +00E6 LATIN SMALL LETTER AE +00E7 LATIN SMALL LETTER C WITH CEDILLA +00E8 LATIN SMALL LETTER E WITH GRAVE +00E9 LATIN SMALL LETTER E WITH ACUTE +00EA LATIN SMALL LETTER E WITH CIRCUMFLEX +00EB LATIN SMALL LETTER E WITH DIAERESIS +00EC LATIN SMALL LETTER I WITH GRAVE +00ED LATIN SMALL LETTER I WITH ACUTE +00EE LATIN SMALL LETTER I WITH CIRCUMFLEX +00EF LATIN SMALL LETTER I WITH DIAERESIS +00F0 LATIN SMALL LETTER ETH +00F1 LATIN SMALL LETTER N WITH TILDE +00F2 LATIN SMALL LETTER O WITH GRAVE +00F3 LATIN SMALL LETTER O WITH ACUTE +00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX +00F5 LATIN SMALL LETTER O WITH TILDE +00F6 LATIN SMALL LETTER O WITH DIAERESIS +00F7 DIVISION SIGN +00F8 LATIN SMALL LETTER O WITH STROKE +00F9 LATIN SMALL LETTER U WITH GRAVE +00FA LATIN SMALL LETTER U WITH ACUTE +00FB LATIN SMALL LETTER U WITH CIRCUMFLEX +00FC LATIN SMALL LETTER U WITH DIAERESIS +00FD LATIN SMALL LETTER Y WITH ACUTE +00FE LATIN SMALL LETTER THORN +00FF LATIN SMALL LETTER Y WITH DIAERESIS +0100 LATIN CAPITAL LETTER A WITH MACRON +0101 LATIN SMALL LETTER A WITH MACRON +0102 LATIN CAPITAL LETTER A WITH BREVE +0103 LATIN SMALL LETTER A WITH BREVE +0104 LATIN CAPITAL LETTER A WITH OGONEK +0105 LATIN SMALL LETTER A WITH OGONEK +0106 LATIN CAPITAL LETTER C WITH ACUTE +0107 LATIN SMALL LETTER C WITH ACUTE +0108 LATIN CAPITAL LETTER C WITH CIRCUMFLEX +0109 LATIN SMALL LETTER C WITH CIRCUMFLEX +010A LATIN CAPITAL LETTER C WITH DOT ABOVE +010B LATIN SMALL LETTER C WITH DOT ABOVE +010C LATIN CAPITAL LETTER C WITH CARON +010D LATIN SMALL LETTER C WITH CARON +010E LATIN CAPITAL LETTER D WITH CARON +010F LATIN SMALL LETTER D WITH CARON +0110 LATIN CAPITAL LETTER D WITH STROKE +0111 LATIN SMALL LETTER D WITH STROKE +0112 LATIN CAPITAL LETTER E WITH MACRON +0113 LATIN SMALL LETTER E WITH MACRON +0114 LATIN CAPITAL LETTER E WITH BREVE +0115 LATIN SMALL LETTER E WITH BREVE +0116 LATIN CAPITAL LETTER E WITH DOT ABOVE +0117 LATIN SMALL LETTER E WITH DOT ABOVE +0118 LATIN CAPITAL LETTER E WITH OGONEK +0119 LATIN SMALL LETTER E WITH OGONEK +011A LATIN CAPITAL LETTER E WITH CARON +011B LATIN SMALL LETTER E WITH CARON +011C LATIN CAPITAL LETTER G WITH CIRCUMFLEX +011D LATIN SMALL LETTER G WITH CIRCUMFLEX +011E LATIN CAPITAL LETTER G WITH BREVE +011F LATIN SMALL LETTER G WITH BREVE +0120 LATIN CAPITAL LETTER G WITH DOT ABOVE +0121 LATIN SMALL LETTER G WITH DOT ABOVE +0122 LATIN CAPITAL LETTER G WITH CEDILLA +0123 LATIN SMALL LETTER G WITH CEDILLA +0124 LATIN CAPITAL LETTER H WITH CIRCUMFLEX +0125 LATIN SMALL LETTER H WITH CIRCUMFLEX +0126 LATIN CAPITAL LETTER H WITH STROKE +0127 LATIN SMALL LETTER H WITH STROKE +0128 LATIN CAPITAL LETTER I WITH TILDE +0129 LATIN SMALL LETTER I WITH TILDE +012A LATIN CAPITAL LETTER I WITH MACRON +012B LATIN SMALL LETTER I WITH MACRON +012C LATIN CAPITAL LETTER I WITH BREVE +012D LATIN SMALL LETTER I WITH BREVE +012E LATIN CAPITAL LETTER I WITH OGONEK +012F LATIN SMALL LETTER I WITH OGONEK +0130 LATIN CAPITAL LETTER I WITH DOT ABOVE +0131 LATIN SMALL LETTER DOTLESS I +0132 LATIN CAPITAL LIGATURE IJ +0133 LATIN SMALL LIGATURE IJ +0134 LATIN CAPITAL LETTER J WITH CIRCUMFLEX +0135 LATIN SMALL LETTER J WITH CIRCUMFLEX +0136 LATIN CAPITAL LETTER K WITH CEDILLA +0137 LATIN SMALL LETTER K WITH CEDILLA +0138 LATIN SMALL LETTER KRA +0139 LATIN CAPITAL LETTER L WITH ACUTE +013A LATIN SMALL LETTER L WITH ACUTE +013B LATIN CAPITAL LETTER L WITH CEDILLA +013C LATIN SMALL LETTER L WITH CEDILLA +013D LATIN CAPITAL LETTER L WITH CARON +013E LATIN SMALL LETTER L WITH CARON +013F LATIN CAPITAL LETTER L WITH MIDDLE DOT +0140 LATIN SMALL LETTER L WITH MIDDLE DOT +0141 LATIN CAPITAL LETTER L WITH STROKE +0142 LATIN SMALL LETTER L WITH STROKE +0143 LATIN CAPITAL LETTER N WITH ACUTE +0144 LATIN SMALL LETTER N WITH ACUTE +0145 LATIN CAPITAL LETTER N WITH CEDILLA +0146 LATIN SMALL LETTER N WITH CEDILLA +0147 LATIN CAPITAL LETTER N WITH CARON +0148 LATIN SMALL LETTER N WITH CARON +0149 LATIN SMALL LETTER N PRECEDED BY APOSTROPHE +014A LATIN CAPITAL LETTER ENG +014B LATIN SMALL LETTER ENG +014C LATIN CAPITAL LETTER O WITH MACRON +014D LATIN SMALL LETTER O WITH MACRON +014E LATIN CAPITAL LETTER O WITH BREVE +014F LATIN SMALL LETTER O WITH BREVE +0150 LATIN CAPITAL LETTER O WITH DOUBLE ACUTE +0151 LATIN SMALL LETTER O WITH DOUBLE ACUTE +0152 LATIN CAPITAL LIGATURE OE +0153 LATIN SMALL LIGATURE OE +0154 LATIN CAPITAL LETTER R WITH ACUTE +0155 LATIN SMALL LETTER R WITH ACUTE +0156 LATIN CAPITAL LETTER R WITH CEDILLA +0157 LATIN SMALL LETTER R WITH CEDILLA +0158 LATIN CAPITAL LETTER R WITH CARON +0159 LATIN SMALL LETTER R WITH CARON +015A LATIN CAPITAL LETTER S WITH ACUTE +015B LATIN SMALL LETTER S WITH ACUTE +015C LATIN CAPITAL LETTER S WITH CIRCUMFLEX +015D LATIN SMALL LETTER S WITH CIRCUMFLEX +015E LATIN CAPITAL LETTER S WITH CEDILLA +015F LATIN SMALL LETTER S WITH CEDILLA +0160 LATIN CAPITAL LETTER S WITH CARON +0161 LATIN SMALL LETTER S WITH CARON +0162 LATIN CAPITAL LETTER T WITH CEDILLA +0163 LATIN SMALL LETTER T WITH CEDILLA +0164 LATIN CAPITAL LETTER T WITH CARON +0165 LATIN SMALL LETTER T WITH CARON +0166 LATIN CAPITAL LETTER T WITH STROKE +0167 LATIN SMALL LETTER T WITH STROKE +0168 LATIN CAPITAL LETTER U WITH TILDE +0169 LATIN SMALL LETTER U WITH TILDE +016A LATIN CAPITAL LETTER U WITH MACRON +016B LATIN SMALL LETTER U WITH MACRON +016C LATIN CAPITAL LETTER U WITH BREVE +016D LATIN SMALL LETTER U WITH BREVE +016E LATIN CAPITAL LETTER U WITH RING ABOVE +016F LATIN SMALL LETTER U WITH RING ABOVE +0170 LATIN CAPITAL LETTER U WITH DOUBLE ACUTE +0171 LATIN SMALL LETTER U WITH DOUBLE ACUTE +0172 LATIN CAPITAL LETTER U WITH OGONEK +0173 LATIN SMALL LETTER U WITH OGONEK +0174 LATIN CAPITAL LETTER W WITH CIRCUMFLEX +0175 LATIN SMALL LETTER W WITH CIRCUMFLEX +0176 LATIN CAPITAL LETTER Y WITH CIRCUMFLEX +0177 LATIN SMALL LETTER Y WITH CIRCUMFLEX +0178 LATIN CAPITAL LETTER Y WITH DIAERESIS +0179 LATIN CAPITAL LETTER Z WITH ACUTE +017A LATIN SMALL LETTER Z WITH ACUTE +017B LATIN CAPITAL LETTER Z WITH DOT ABOVE +017C LATIN SMALL LETTER Z WITH DOT ABOVE +017D LATIN CAPITAL LETTER Z WITH CARON +017E LATIN SMALL LETTER Z WITH CARON +017F LATIN SMALL LETTER LONG S +0180 LATIN SMALL LETTER B WITH STROKE +0181 LATIN CAPITAL LETTER B WITH HOOK +0182 LATIN CAPITAL LETTER B WITH TOPBAR +0183 LATIN SMALL LETTER B WITH TOPBAR +0184 LATIN CAPITAL LETTER TONE SIX +0185 LATIN SMALL LETTER TONE SIX +0186 LATIN CAPITAL LETTER OPEN O +0187 LATIN CAPITAL LETTER C WITH HOOK +0188 LATIN SMALL LETTER C WITH HOOK +0189 LATIN CAPITAL LETTER AFRICAN D +018A LATIN CAPITAL LETTER D WITH HOOK +018B LATIN CAPITAL LETTER D WITH TOPBAR +018C LATIN SMALL LETTER D WITH TOPBAR +018D LATIN SMALL LETTER TURNED DELTA +018E LATIN CAPITAL LETTER REVERSED E +018F LATIN CAPITAL LETTER SCHWA +0190 LATIN CAPITAL LETTER OPEN E +0191 LATIN CAPITAL LETTER F WITH HOOK +0192 LATIN SMALL LETTER F WITH HOOK +0193 LATIN CAPITAL LETTER G WITH HOOK +0194 LATIN CAPITAL LETTER GAMMA +0195 LATIN SMALL LETTER HV +0196 LATIN CAPITAL LETTER IOTA +0197 LATIN CAPITAL LETTER I WITH STROKE +0198 LATIN CAPITAL LETTER K WITH HOOK +0199 LATIN SMALL LETTER K WITH HOOK +019A LATIN SMALL LETTER L WITH BAR +019B LATIN SMALL LETTER LAMBDA WITH STROKE +019C LATIN CAPITAL LETTER TURNED M +019D LATIN CAPITAL LETTER N WITH LEFT HOOK +019E LATIN SMALL LETTER N WITH LONG RIGHT LEG +019F LATIN CAPITAL LETTER O WITH MIDDLE TILDE +01A0 LATIN CAPITAL LETTER O WITH HORN +01A1 LATIN SMALL LETTER O WITH HORN +01A2 LATIN CAPITAL LETTER OI +01A3 LATIN SMALL LETTER OI +01A4 LATIN CAPITAL LETTER P WITH HOOK +01A5 LATIN SMALL LETTER P WITH HOOK +01A6 LATIN LETTER YR +01A7 LATIN CAPITAL LETTER TONE TWO +01A8 LATIN SMALL LETTER TONE TWO +01A9 LATIN CAPITAL LETTER ESH +01AA LATIN LETTER REVERSED ESH LOOP +01AB LATIN SMALL LETTER T WITH PALATAL HOOK +01AC LATIN CAPITAL LETTER T WITH HOOK +01AD LATIN SMALL LETTER T WITH HOOK +01AE LATIN CAPITAL LETTER T WITH RETROFLEX HOOK +01AF LATIN CAPITAL LETTER U WITH HORN +01B0 LATIN SMALL LETTER U WITH HORN +01B1 LATIN CAPITAL LETTER UPSILON +01B2 LATIN CAPITAL LETTER V WITH HOOK +01B3 LATIN CAPITAL LETTER Y WITH HOOK +01B4 LATIN SMALL LETTER Y WITH HOOK +01B5 LATIN CAPITAL LETTER Z WITH STROKE +01B6 LATIN SMALL LETTER Z WITH STROKE +01B7 LATIN CAPITAL LETTER EZH +01B8 LATIN CAPITAL LETTER EZH REVERSED +01B9 LATIN SMALL LETTER EZH REVERSED +01BA LATIN SMALL LETTER EZH WITH TAIL +01BB LATIN LETTER TWO WITH STROKE +01BC LATIN CAPITAL LETTER TONE FIVE +01BD LATIN SMALL LETTER TONE FIVE +01BE LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE +01BF LATIN LETTER WYNN +01C0 LATIN LETTER DENTAL CLICK +01C1 LATIN LETTER LATERAL CLICK +01C2 LATIN LETTER ALVEOLAR CLICK +01C3 LATIN LETTER RETROFLEX CLICK +01C4 LATIN CAPITAL LETTER DZ WITH CARON +01C5 LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON +01C6 LATIN SMALL LETTER DZ WITH CARON +01C7 LATIN CAPITAL LETTER LJ +01C8 LATIN CAPITAL LETTER L WITH SMALL LETTER J +01C9 LATIN SMALL LETTER LJ +01CA LATIN CAPITAL LETTER NJ +01CB LATIN CAPITAL LETTER N WITH SMALL LETTER J +01CC LATIN SMALL LETTER NJ +01CD LATIN CAPITAL LETTER A WITH CARON +01CE LATIN SMALL LETTER A WITH CARON +01CF LATIN CAPITAL LETTER I WITH CARON +01D0 LATIN SMALL LETTER I WITH CARON +01D1 LATIN CAPITAL LETTER O WITH CARON +01D2 LATIN SMALL LETTER O WITH CARON +01D3 LATIN CAPITAL LETTER U WITH CARON +01D4 LATIN SMALL LETTER U WITH CARON +01D5 LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON +01D6 LATIN SMALL LETTER U WITH DIAERESIS AND MACRON +01D7 LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE +01D8 LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE +01D9 LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON +01DA LATIN SMALL LETTER U WITH DIAERESIS AND CARON +01DB LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE +01DC LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE +01DD LATIN SMALL LETTER TURNED E +01DE LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON +01DF LATIN SMALL LETTER A WITH DIAERESIS AND MACRON +01E0 LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON +01E1 LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON +01E2 LATIN CAPITAL LETTER AE WITH MACRON +01E3 LATIN SMALL LETTER AE WITH MACRON +01E4 LATIN CAPITAL LETTER G WITH STROKE +01E5 LATIN SMALL LETTER G WITH STROKE +01E6 LATIN CAPITAL LETTER G WITH CARON +01E7 LATIN SMALL LETTER G WITH CARON +01E8 LATIN CAPITAL LETTER K WITH CARON +01E9 LATIN SMALL LETTER K WITH CARON +01EA LATIN CAPITAL LETTER O WITH OGONEK +01EB LATIN SMALL LETTER O WITH OGONEK +01EC LATIN CAPITAL LETTER O WITH OGONEK AND MACRON +01ED LATIN SMALL LETTER O WITH OGONEK AND MACRON +01EE LATIN CAPITAL LETTER EZH WITH CARON +01EF LATIN SMALL LETTER EZH WITH CARON +01F0 LATIN SMALL LETTER J WITH CARON +01F1 LATIN CAPITAL LETTER DZ +01F2 LATIN CAPITAL LETTER D WITH SMALL LETTER Z +01F3 LATIN SMALL LETTER DZ +01F4 LATIN CAPITAL LETTER G WITH ACUTE +01F5 LATIN SMALL LETTER G WITH ACUTE +01F6 LATIN CAPITAL LETTER HWAIR +01F7 LATIN CAPITAL LETTER WYNN +01F8 LATIN CAPITAL LETTER N WITH GRAVE +01F9 LATIN SMALL LETTER N WITH GRAVE +01FA LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE +01FB LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE +01FC LATIN CAPITAL LETTER AE WITH ACUTE +01FD LATIN SMALL LETTER AE WITH ACUTE +01FE LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +01FF LATIN SMALL LETTER O WITH STROKE AND ACUTE +0200 LATIN CAPITAL LETTER A WITH DOUBLE GRAVE +0201 LATIN SMALL LETTER A WITH DOUBLE GRAVE +0202 LATIN CAPITAL LETTER A WITH INVERTED BREVE +0203 LATIN SMALL LETTER A WITH INVERTED BREVE +0204 LATIN CAPITAL LETTER E WITH DOUBLE GRAVE +0205 LATIN SMALL LETTER E WITH DOUBLE GRAVE +0206 LATIN CAPITAL LETTER E WITH INVERTED BREVE +0207 LATIN SMALL LETTER E WITH INVERTED BREVE +0208 LATIN CAPITAL LETTER I WITH DOUBLE GRAVE +0209 LATIN SMALL LETTER I WITH DOUBLE GRAVE +020A LATIN CAPITAL LETTER I WITH INVERTED BREVE +020B LATIN SMALL LETTER I WITH INVERTED BREVE +020C LATIN CAPITAL LETTER O WITH DOUBLE GRAVE +020D LATIN SMALL LETTER O WITH DOUBLE GRAVE +020E LATIN CAPITAL LETTER O WITH INVERTED BREVE +020F LATIN SMALL LETTER O WITH INVERTED BREVE +0210 LATIN CAPITAL LETTER R WITH DOUBLE GRAVE +0211 LATIN SMALL LETTER R WITH DOUBLE GRAVE +0212 LATIN CAPITAL LETTER R WITH INVERTED BREVE +0213 LATIN SMALL LETTER R WITH INVERTED BREVE +0214 LATIN CAPITAL LETTER U WITH DOUBLE GRAVE +0215 LATIN SMALL LETTER U WITH DOUBLE GRAVE +0216 LATIN CAPITAL LETTER U WITH INVERTED BREVE +0217 LATIN SMALL LETTER U WITH INVERTED BREVE +0218 LATIN CAPITAL LETTER S WITH COMMA BELOW +0219 LATIN SMALL LETTER S WITH COMMA BELOW +021A LATIN CAPITAL LETTER T WITH COMMA BELOW +021B LATIN SMALL LETTER T WITH COMMA BELOW +021C LATIN CAPITAL LETTER YOGH +021D LATIN SMALL LETTER YOGH +021E LATIN CAPITAL LETTER H WITH CARON +021F LATIN SMALL LETTER H WITH CARON +0220 LATIN CAPITAL LETTER N WITH LONG RIGHT LEG +0222 LATIN CAPITAL LETTER OU +0223 LATIN SMALL LETTER OU +0224 LATIN CAPITAL LETTER Z WITH HOOK +0225 LATIN SMALL LETTER Z WITH HOOK +0226 LATIN CAPITAL LETTER A WITH DOT ABOVE +0227 LATIN SMALL LETTER A WITH DOT ABOVE +0228 LATIN CAPITAL LETTER E WITH CEDILLA +0229 LATIN SMALL LETTER E WITH CEDILLA +022A LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON +022B LATIN SMALL LETTER O WITH DIAERESIS AND MACRON +022C LATIN CAPITAL LETTER O WITH TILDE AND MACRON +022D LATIN SMALL LETTER O WITH TILDE AND MACRON +022E LATIN CAPITAL LETTER O WITH DOT ABOVE +022F LATIN SMALL LETTER O WITH DOT ABOVE +0230 LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON +0231 LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON +0232 LATIN CAPITAL LETTER Y WITH MACRON +0233 LATIN SMALL LETTER Y WITH MACRON +0250 LATIN SMALL LETTER TURNED A +0251 LATIN SMALL LETTER ALPHA +0252 LATIN SMALL LETTER TURNED ALPHA +0253 LATIN SMALL LETTER B WITH HOOK +0254 LATIN SMALL LETTER OPEN O +0255 LATIN SMALL LETTER C WITH CURL +0256 LATIN SMALL LETTER D WITH TAIL +0257 LATIN SMALL LETTER D WITH HOOK +0258 LATIN SMALL LETTER REVERSED E +0259 LATIN SMALL LETTER SCHWA +025A LATIN SMALL LETTER SCHWA WITH HOOK +025B LATIN SMALL LETTER OPEN E +025C LATIN SMALL LETTER REVERSED OPEN E +025D LATIN SMALL LETTER REVERSED OPEN E WITH HOOK +025E LATIN SMALL LETTER CLOSED REVERSED OPEN E +025F LATIN SMALL LETTER DOTLESS J WITH STROKE +0260 LATIN SMALL LETTER G WITH HOOK +0261 LATIN SMALL LETTER SCRIPT G +0262 LATIN LETTER SMALL CAPITAL G +0263 LATIN SMALL LETTER GAMMA +0264 LATIN SMALL LETTER RAMS HORN +0265 LATIN SMALL LETTER TURNED H +0266 LATIN SMALL LETTER H WITH HOOK +0267 LATIN SMALL LETTER HENG WITH HOOK +0268 LATIN SMALL LETTER I WITH STROKE +0269 LATIN SMALL LETTER IOTA +026A LATIN LETTER SMALL CAPITAL I +026B LATIN SMALL LETTER L WITH MIDDLE TILDE +026C LATIN SMALL LETTER L WITH BELT +026D LATIN SMALL LETTER L WITH RETROFLEX HOOK +026E LATIN SMALL LETTER LEZH +026F LATIN SMALL LETTER TURNED M +0270 LATIN SMALL LETTER TURNED M WITH LONG LEG +0271 LATIN SMALL LETTER M WITH HOOK +0272 LATIN SMALL LETTER N WITH LEFT HOOK +0273 LATIN SMALL LETTER N WITH RETROFLEX HOOK +0274 LATIN LETTER SMALL CAPITAL N +0275 LATIN SMALL LETTER BARRED O +0276 LATIN LETTER SMALL CAPITAL OE +0277 LATIN SMALL LETTER CLOSED OMEGA +0278 LATIN SMALL LETTER PHI +0279 LATIN SMALL LETTER TURNED R +027A LATIN SMALL LETTER TURNED R WITH LONG LEG +027B LATIN SMALL LETTER TURNED R WITH HOOK +027C LATIN SMALL LETTER R WITH LONG LEG +027D LATIN SMALL LETTER R WITH TAIL +027E LATIN SMALL LETTER R WITH FISHHOOK +027F LATIN SMALL LETTER REVERSED R WITH FISHHOOK +0280 LATIN LETTER SMALL CAPITAL R +0281 LATIN LETTER SMALL CAPITAL INVERTED R +0282 LATIN SMALL LETTER S WITH HOOK +0283 LATIN SMALL LETTER ESH +0284 LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK +0285 LATIN SMALL LETTER SQUAT REVERSED ESH +0286 LATIN SMALL LETTER ESH WITH CURL +0287 LATIN SMALL LETTER TURNED T +0288 LATIN SMALL LETTER T WITH RETROFLEX HOOK +0289 LATIN SMALL LETTER U BAR +028A LATIN SMALL LETTER UPSILON +028B LATIN SMALL LETTER V WITH HOOK +028C LATIN SMALL LETTER TURNED V +028D LATIN SMALL LETTER TURNED W +028E LATIN SMALL LETTER TURNED Y +028F LATIN LETTER SMALL CAPITAL Y +0290 LATIN SMALL LETTER Z WITH RETROFLEX HOOK +0291 LATIN SMALL LETTER Z WITH CURL +0292 LATIN SMALL LETTER EZH +0293 LATIN SMALL LETTER EZH WITH CURL +0294 LATIN LETTER GLOTTAL STOP +0295 LATIN LETTER PHARYNGEAL VOICED FRICATIVE +0296 LATIN LETTER INVERTED GLOTTAL STOP +0297 LATIN LETTER STRETCHED C +0298 LATIN LETTER BILABIAL CLICK +0299 LATIN LETTER SMALL CAPITAL B +029A LATIN SMALL LETTER CLOSED OPEN E +029B LATIN LETTER SMALL CAPITAL G WITH HOOK +029C LATIN LETTER SMALL CAPITAL H +029D LATIN SMALL LETTER J WITH CROSSED-TAIL +029E LATIN SMALL LETTER TURNED K +029F LATIN LETTER SMALL CAPITAL L +02A0 LATIN SMALL LETTER Q WITH HOOK +02A1 LATIN LETTER GLOTTAL STOP WITH STROKE +02A2 LATIN LETTER REVERSED GLOTTAL STOP WITH STROKE +02A3 LATIN SMALL LETTER DZ DIGRAPH +02A4 LATIN SMALL LETTER DEZH DIGRAPH +02A5 LATIN SMALL LETTER DZ DIGRAPH WITH CURL +02A6 LATIN SMALL LETTER TS DIGRAPH +02A7 LATIN SMALL LETTER TESH DIGRAPH +02A8 LATIN SMALL LETTER TC DIGRAPH WITH CURL +02A9 LATIN SMALL LETTER FENG DIGRAPH +02AA LATIN SMALL LETTER LS DIGRAPH +02AB LATIN SMALL LETTER LZ DIGRAPH +02AC LATIN LETTER BILABIAL PERCUSSIVE +02AD LATIN LETTER BIDENTAL PERCUSSIVE +02B0 MODIFIER LETTER SMALL H +02B1 MODIFIER LETTER SMALL H WITH HOOK +02B2 MODIFIER LETTER SMALL J +02B3 MODIFIER LETTER SMALL R +02B4 MODIFIER LETTER SMALL TURNED R +02B5 MODIFIER LETTER SMALL TURNED R WITH HOOK +02B6 MODIFIER LETTER SMALL CAPITAL INVERTED R +02B7 MODIFIER LETTER SMALL W +02B8 MODIFIER LETTER SMALL Y +02B9 MODIFIER LETTER PRIME +02BA MODIFIER LETTER DOUBLE PRIME +02BB MODIFIER LETTER TURNED COMMA +02BC MODIFIER LETTER APOSTROPHE +02BD MODIFIER LETTER REVERSED COMMA +02BE MODIFIER LETTER RIGHT HALF RING +02BF MODIFIER LETTER LEFT HALF RING +02C0 MODIFIER LETTER GLOTTAL STOP +02C1 MODIFIER LETTER REVERSED GLOTTAL STOP +02C2 MODIFIER LETTER LEFT ARROWHEAD +02C3 MODIFIER LETTER RIGHT ARROWHEAD +02C4 MODIFIER LETTER UP ARROWHEAD +02C5 MODIFIER LETTER DOWN ARROWHEAD +02C6 MODIFIER LETTER CIRCUMFLEX ACCENT +02C7 CARON +02C8 MODIFIER LETTER VERTICAL LINE +02C9 MODIFIER LETTER MACRON +02CA MODIFIER LETTER ACUTE ACCENT +02CB MODIFIER LETTER GRAVE ACCENT +02CC MODIFIER LETTER LOW VERTICAL LINE +02CD MODIFIER LETTER LOW MACRON +02CE MODIFIER LETTER LOW GRAVE ACCENT +02CF MODIFIER LETTER LOW ACUTE ACCENT +02D0 MODIFIER LETTER TRIANGULAR COLON +02D1 MODIFIER LETTER HALF TRIANGULAR COLON +02D2 MODIFIER LETTER CENTRED RIGHT HALF RING +02D3 MODIFIER LETTER CENTRED LEFT HALF RING +02D4 MODIFIER LETTER UP TACK +02D5 MODIFIER LETTER DOWN TACK +02D6 MODIFIER LETTER PLUS SIGN +02D7 MODIFIER LETTER MINUS SIGN +02D8 BREVE +02D9 DOT ABOVE +02DA RING ABOVE +02DB OGONEK +02DC SMALL TILDE +02DD DOUBLE ACUTE ACCENT +02DE MODIFIER LETTER RHOTIC HOOK +02DF MODIFIER LETTER CROSS ACCENT +02E0 MODIFIER LETTER SMALL GAMMA +02E1 MODIFIER LETTER SMALL L +02E2 MODIFIER LETTER SMALL S +02E3 MODIFIER LETTER SMALL X +02E4 MODIFIER LETTER SMALL REVERSED GLOTTAL STOP +02E5 MODIFIER LETTER EXTRA-HIGH TONE BAR +02E6 MODIFIER LETTER HIGH TONE BAR +02E7 MODIFIER LETTER MID TONE BAR +02E8 MODIFIER LETTER LOW TONE BAR +02E9 MODIFIER LETTER EXTRA-LOW TONE BAR +02EA MODIFIER LETTER YIN DEPARTING TONE MARK +02EB MODIFIER LETTER YANG DEPARTING TONE MARK +02EC MODIFIER LETTER VOICING +02ED MODIFIER LETTER UNASPIRATED +02EE MODIFIER LETTER DOUBLE APOSTROPHE +0300 COMBINING GRAVE ACCENT +0301 COMBINING ACUTE ACCENT +0302 COMBINING CIRCUMFLEX ACCENT +0303 COMBINING TILDE +0304 COMBINING MACRON +0305 COMBINING OVERLINE +0306 COMBINING BREVE +0307 COMBINING DOT ABOVE +0308 COMBINING DIAERESIS +0309 COMBINING HOOK ABOVE +030A COMBINING RING ABOVE +030B COMBINING DOUBLE ACUTE ACCENT +030C COMBINING CARON +030D COMBINING VERTICAL LINE ABOVE +030E COMBINING DOUBLE VERTICAL LINE ABOVE +030F COMBINING DOUBLE GRAVE ACCENT +0310 COMBINING CANDRABINDU +0311 COMBINING INVERTED BREVE +0312 COMBINING TURNED COMMA ABOVE +0313 COMBINING COMMA ABOVE +0314 COMBINING REVERSED COMMA ABOVE +0315 COMBINING COMMA ABOVE RIGHT +0316 COMBINING GRAVE ACCENT BELOW +0317 COMBINING ACUTE ACCENT BELOW +0318 COMBINING LEFT TACK BELOW +0319 COMBINING RIGHT TACK BELOW +031A COMBINING LEFT ANGLE ABOVE +031B COMBINING HORN +031C COMBINING LEFT HALF RING BELOW +031D COMBINING UP TACK BELOW +031E COMBINING DOWN TACK BELOW +031F COMBINING PLUS SIGN BELOW +0320 COMBINING MINUS SIGN BELOW +0321 COMBINING PALATALIZED HOOK BELOW +0322 COMBINING RETROFLEX HOOK BELOW +0323 COMBINING DOT BELOW +0324 COMBINING DIAERESIS BELOW +0325 COMBINING RING BELOW +0326 COMBINING COMMA BELOW +0327 COMBINING CEDILLA +0328 COMBINING OGONEK +0329 COMBINING VERTICAL LINE BELOW +032A COMBINING BRIDGE BELOW +032B COMBINING INVERTED DOUBLE ARCH BELOW +032C COMBINING CARON BELOW +032D COMBINING CIRCUMFLEX ACCENT BELOW +032E COMBINING BREVE BELOW +032F COMBINING INVERTED BREVE BELOW +0330 COMBINING TILDE BELOW +0331 COMBINING MACRON BELOW +0332 COMBINING LOW LINE +0333 COMBINING DOUBLE LOW LINE +0334 COMBINING TILDE OVERLAY +0335 COMBINING SHORT STROKE OVERLAY +0336 COMBINING LONG STROKE OVERLAY +0337 COMBINING SHORT SOLIDUS OVERLAY +0338 COMBINING LONG SOLIDUS OVERLAY +0339 COMBINING RIGHT HALF RING BELOW +033A COMBINING INVERTED BRIDGE BELOW +033B COMBINING SQUARE BELOW +033C COMBINING SEAGULL BELOW +033D COMBINING X ABOVE +033E COMBINING VERTICAL TILDE +033F COMBINING DOUBLE OVERLINE +0340 COMBINING GRAVE TONE MARK +0341 COMBINING ACUTE TONE MARK +0342 COMBINING GREEK PERISPOMENI +0343 COMBINING GREEK KORONIS +0344 COMBINING GREEK DIALYTIKA TONOS +0345 COMBINING GREEK YPOGEGRAMMENI +0346 COMBINING BRIDGE ABOVE +0347 COMBINING EQUALS SIGN BELOW +0348 COMBINING DOUBLE VERTICAL LINE BELOW +0349 COMBINING LEFT ANGLE BELOW +034A COMBINING NOT TILDE ABOVE +034B COMBINING HOMOTHETIC ABOVE +034C COMBINING ALMOST EQUAL TO ABOVE +034D COMBINING LEFT RIGHT ARROW BELOW +034E COMBINING UPWARDS ARROW BELOW +034F COMBINING GRAPHEME JOINER +0360 COMBINING DOUBLE TILDE +0361 COMBINING DOUBLE INVERTED BREVE +0362 COMBINING DOUBLE RIGHTWARDS ARROW BELOW +0363 COMBINING LATIN SMALL LETTER A +0364 COMBINING LATIN SMALL LETTER E +0365 COMBINING LATIN SMALL LETTER I +0366 COMBINING LATIN SMALL LETTER O +0367 COMBINING LATIN SMALL LETTER U +0368 COMBINING LATIN SMALL LETTER C +0369 COMBINING LATIN SMALL LETTER D +036A COMBINING LATIN SMALL LETTER H +036B COMBINING LATIN SMALL LETTER M +036C COMBINING LATIN SMALL LETTER R +036D COMBINING LATIN SMALL LETTER T +036E COMBINING LATIN SMALL LETTER V +036F COMBINING LATIN SMALL LETTER X +0374 GREEK NUMERAL SIGN +0375 GREEK LOWER NUMERAL SIGN +037A GREEK YPOGEGRAMMENI +037E GREEK QUESTION MARK +0384 GREEK TONOS +0385 GREEK DIALYTIKA TONOS +0386 GREEK CAPITAL LETTER ALPHA WITH TONOS +0387 GREEK ANO TELEIA +0388 GREEK CAPITAL LETTER EPSILON WITH TONOS +0389 GREEK CAPITAL LETTER ETA WITH TONOS +038A GREEK CAPITAL LETTER IOTA WITH TONOS +038C GREEK CAPITAL LETTER OMICRON WITH TONOS +038E GREEK CAPITAL LETTER UPSILON WITH TONOS +038F GREEK CAPITAL LETTER OMEGA WITH TONOS +0390 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS +0391 GREEK CAPITAL LETTER ALPHA +0392 GREEK CAPITAL LETTER BETA +0393 GREEK CAPITAL LETTER GAMMA +0394 GREEK CAPITAL LETTER DELTA +0395 GREEK CAPITAL LETTER EPSILON +0396 GREEK CAPITAL LETTER ZETA +0397 GREEK CAPITAL LETTER ETA +0398 GREEK CAPITAL LETTER THETA +0399 GREEK CAPITAL LETTER IOTA +039A GREEK CAPITAL LETTER KAPPA +039B GREEK CAPITAL LETTER LAMDA +039C GREEK CAPITAL LETTER MU +039D GREEK CAPITAL LETTER NU +039E GREEK CAPITAL LETTER XI +039F GREEK CAPITAL LETTER OMICRON +03A0 GREEK CAPITAL LETTER PI +03A1 GREEK CAPITAL LETTER RHO +03A3 GREEK CAPITAL LETTER SIGMA +03A4 GREEK CAPITAL LETTER TAU +03A5 GREEK CAPITAL LETTER UPSILON +03A6 GREEK CAPITAL LETTER PHI +03A7 GREEK CAPITAL LETTER CHI +03A8 GREEK CAPITAL LETTER PSI +03A9 GREEK CAPITAL LETTER OMEGA +03AA GREEK CAPITAL LETTER IOTA WITH DIALYTIKA +03AB GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA +03AC GREEK SMALL LETTER ALPHA WITH TONOS +03AD GREEK SMALL LETTER EPSILON WITH TONOS +03AE GREEK SMALL LETTER ETA WITH TONOS +03AF GREEK SMALL LETTER IOTA WITH TONOS +03B0 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS +03B1 GREEK SMALL LETTER ALPHA +03B2 GREEK SMALL LETTER BETA +03B3 GREEK SMALL LETTER GAMMA +03B4 GREEK SMALL LETTER DELTA +03B5 GREEK SMALL LETTER EPSILON +03B6 GREEK SMALL LETTER ZETA +03B7 GREEK SMALL LETTER ETA +03B8 GREEK SMALL LETTER THETA +03B9 GREEK SMALL LETTER IOTA +03BA GREEK SMALL LETTER KAPPA +03BB GREEK SMALL LETTER LAMDA +03BC GREEK SMALL LETTER MU +03BD GREEK SMALL LETTER NU +03BE GREEK SMALL LETTER XI +03BF GREEK SMALL LETTER OMICRON +03C0 GREEK SMALL LETTER PI +03C1 GREEK SMALL LETTER RHO +03C2 GREEK SMALL LETTER FINAL SIGMA +03C3 GREEK SMALL LETTER SIGMA +03C4 GREEK SMALL LETTER TAU +03C5 GREEK SMALL LETTER UPSILON +03C6 GREEK SMALL LETTER PHI +03C7 GREEK SMALL LETTER CHI +03C8 GREEK SMALL LETTER PSI +03C9 GREEK SMALL LETTER OMEGA +03CA GREEK SMALL LETTER IOTA WITH DIALYTIKA +03CB GREEK SMALL LETTER UPSILON WITH DIALYTIKA +03CC GREEK SMALL LETTER OMICRON WITH TONOS +03CD GREEK SMALL LETTER UPSILON WITH TONOS +03CE GREEK SMALL LETTER OMEGA WITH TONOS +03D0 GREEK BETA SYMBOL +03D1 GREEK THETA SYMBOL +03D2 GREEK UPSILON WITH HOOK SYMBOL +03D3 GREEK UPSILON WITH ACUTE AND HOOK SYMBOL +03D4 GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL +03D5 GREEK PHI SYMBOL +03D6 GREEK PI SYMBOL +03D7 GREEK KAI SYMBOL +03D8 GREEK LETTER ARCHAIC KOPPA +03D9 GREEK SMALL LETTER ARCHAIC KOPPA +03DA GREEK LETTER STIGMA +03DB GREEK SMALL LETTER STIGMA +03DC GREEK LETTER DIGAMMA +03DD GREEK SMALL LETTER DIGAMMA +03DE GREEK LETTER KOPPA +03DF GREEK SMALL LETTER KOPPA +03E0 GREEK LETTER SAMPI +03E1 GREEK SMALL LETTER SAMPI +03E2 COPTIC CAPITAL LETTER SHEI +03E3 COPTIC SMALL LETTER SHEI +03E4 COPTIC CAPITAL LETTER FEI +03E5 COPTIC SMALL LETTER FEI +03E6 COPTIC CAPITAL LETTER KHEI +03E7 COPTIC SMALL LETTER KHEI +03E8 COPTIC CAPITAL LETTER HORI +03E9 COPTIC SMALL LETTER HORI +03EA COPTIC CAPITAL LETTER GANGIA +03EB COPTIC SMALL LETTER GANGIA +03EC COPTIC CAPITAL LETTER SHIMA +03ED COPTIC SMALL LETTER SHIMA +03EE COPTIC CAPITAL LETTER DEI +03EF COPTIC SMALL LETTER DEI +03F0 GREEK KAPPA SYMBOL +03F1 GREEK RHO SYMBOL +03F2 GREEK LUNATE SIGMA SYMBOL +03F3 GREEK LETTER YOT +03F4 GREEK CAPITAL THETA SYMBOL +03F5 GREEK LUNATE EPSILON SYMBOL +03F6 GREEK REVERSED LUNATE EPSILON SYMBOL +0400 CYRILLIC CAPITAL LETTER IE WITH GRAVE +0401 CYRILLIC CAPITAL LETTER IO +0402 CYRILLIC CAPITAL LETTER DJE +0403 CYRILLIC CAPITAL LETTER GJE +0404 CYRILLIC CAPITAL LETTER UKRAINIAN IE +0405 CYRILLIC CAPITAL LETTER DZE +0406 CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I +0407 CYRILLIC CAPITAL LETTER YI +0408 CYRILLIC CAPITAL LETTER JE +0409 CYRILLIC CAPITAL LETTER LJE +040A CYRILLIC CAPITAL LETTER NJE +040B CYRILLIC CAPITAL LETTER TSHE +040C CYRILLIC CAPITAL LETTER KJE +040D CYRILLIC CAPITAL LETTER I WITH GRAVE +040E CYRILLIC CAPITAL LETTER SHORT U +040F CYRILLIC CAPITAL LETTER DZHE +0410 CYRILLIC CAPITAL LETTER A +0411 CYRILLIC CAPITAL LETTER BE +0412 CYRILLIC CAPITAL LETTER VE +0413 CYRILLIC CAPITAL LETTER GHE +0414 CYRILLIC CAPITAL LETTER DE +0415 CYRILLIC CAPITAL LETTER IE +0416 CYRILLIC CAPITAL LETTER ZHE +0417 CYRILLIC CAPITAL LETTER ZE +0418 CYRILLIC CAPITAL LETTER I +0419 CYRILLIC CAPITAL LETTER SHORT I +041A CYRILLIC CAPITAL LETTER KA +041B CYRILLIC CAPITAL LETTER EL +041C CYRILLIC CAPITAL LETTER EM +041D CYRILLIC CAPITAL LETTER EN +041E CYRILLIC CAPITAL LETTER O +041F CYRILLIC CAPITAL LETTER PE +0420 CYRILLIC CAPITAL LETTER ER +0421 CYRILLIC CAPITAL LETTER ES +0422 CYRILLIC CAPITAL LETTER TE +0423 CYRILLIC CAPITAL LETTER U +0424 CYRILLIC CAPITAL LETTER EF +0425 CYRILLIC CAPITAL LETTER HA +0426 CYRILLIC CAPITAL LETTER TSE +0427 CYRILLIC CAPITAL LETTER CHE +0428 CYRILLIC CAPITAL LETTER SHA +0429 CYRILLIC CAPITAL LETTER SHCHA +042A CYRILLIC CAPITAL LETTER HARD SIGN +042B CYRILLIC CAPITAL LETTER YERU +042C CYRILLIC CAPITAL LETTER SOFT SIGN +042D CYRILLIC CAPITAL LETTER E +042E CYRILLIC CAPITAL LETTER YU +042F CYRILLIC CAPITAL LETTER YA +0430 CYRILLIC SMALL LETTER A +0431 CYRILLIC SMALL LETTER BE +0432 CYRILLIC SMALL LETTER VE +0433 CYRILLIC SMALL LETTER GHE +0434 CYRILLIC SMALL LETTER DE +0435 CYRILLIC SMALL LETTER IE +0436 CYRILLIC SMALL LETTER ZHE +0437 CYRILLIC SMALL LETTER ZE +0438 CYRILLIC SMALL LETTER I +0439 CYRILLIC SMALL LETTER SHORT I +043A CYRILLIC SMALL LETTER KA +043B CYRILLIC SMALL LETTER EL +043C CYRILLIC SMALL LETTER EM +043D CYRILLIC SMALL LETTER EN +043E CYRILLIC SMALL LETTER O +043F CYRILLIC SMALL LETTER PE +0440 CYRILLIC SMALL LETTER ER +0441 CYRILLIC SMALL LETTER ES +0442 CYRILLIC SMALL LETTER TE +0443 CYRILLIC SMALL LETTER U +0444 CYRILLIC SMALL LETTER EF +0445 CYRILLIC SMALL LETTER HA +0446 CYRILLIC SMALL LETTER TSE +0447 CYRILLIC SMALL LETTER CHE +0448 CYRILLIC SMALL LETTER SHA +0449 CYRILLIC SMALL LETTER SHCHA +044A CYRILLIC SMALL LETTER HARD SIGN +044B CYRILLIC SMALL LETTER YERU +044C CYRILLIC SMALL LETTER SOFT SIGN +044D CYRILLIC SMALL LETTER E +044E CYRILLIC SMALL LETTER YU +044F CYRILLIC SMALL LETTER YA +0450 CYRILLIC SMALL LETTER IE WITH GRAVE +0451 CYRILLIC SMALL LETTER IO +0452 CYRILLIC SMALL LETTER DJE +0453 CYRILLIC SMALL LETTER GJE +0454 CYRILLIC SMALL LETTER UKRAINIAN IE +0455 CYRILLIC SMALL LETTER DZE +0456 CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I +0457 CYRILLIC SMALL LETTER YI +0458 CYRILLIC SMALL LETTER JE +0459 CYRILLIC SMALL LETTER LJE +045A CYRILLIC SMALL LETTER NJE +045B CYRILLIC SMALL LETTER TSHE +045C CYRILLIC SMALL LETTER KJE +045D CYRILLIC SMALL LETTER I WITH GRAVE +045E CYRILLIC SMALL LETTER SHORT U +045F CYRILLIC SMALL LETTER DZHE +0460 CYRILLIC CAPITAL LETTER OMEGA +0461 CYRILLIC SMALL LETTER OMEGA +0462 CYRILLIC CAPITAL LETTER YAT +0463 CYRILLIC SMALL LETTER YAT +0464 CYRILLIC CAPITAL LETTER IOTIFIED E +0465 CYRILLIC SMALL LETTER IOTIFIED E +0466 CYRILLIC CAPITAL LETTER LITTLE YUS +0467 CYRILLIC SMALL LETTER LITTLE YUS +0468 CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS +0469 CYRILLIC SMALL LETTER IOTIFIED LITTLE YUS +046A CYRILLIC CAPITAL LETTER BIG YUS +046B CYRILLIC SMALL LETTER BIG YUS +046C CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS +046D CYRILLIC SMALL LETTER IOTIFIED BIG YUS +046E CYRILLIC CAPITAL LETTER KSI +046F CYRILLIC SMALL LETTER KSI +0470 CYRILLIC CAPITAL LETTER PSI +0471 CYRILLIC SMALL LETTER PSI +0472 CYRILLIC CAPITAL LETTER FITA +0473 CYRILLIC SMALL LETTER FITA +0474 CYRILLIC CAPITAL LETTER IZHITSA +0475 CYRILLIC SMALL LETTER IZHITSA +0476 CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT +0477 CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT +0478 CYRILLIC CAPITAL LETTER UK +0479 CYRILLIC SMALL LETTER UK +047A CYRILLIC CAPITAL LETTER ROUND OMEGA +047B CYRILLIC SMALL LETTER ROUND OMEGA +047C CYRILLIC CAPITAL LETTER OMEGA WITH TITLO +047D CYRILLIC SMALL LETTER OMEGA WITH TITLO +047E CYRILLIC CAPITAL LETTER OT +047F CYRILLIC SMALL LETTER OT +0480 CYRILLIC CAPITAL LETTER KOPPA +0481 CYRILLIC SMALL LETTER KOPPA +0482 CYRILLIC THOUSANDS SIGN +0483 COMBINING CYRILLIC TITLO +0484 COMBINING CYRILLIC PALATALIZATION +0485 COMBINING CYRILLIC DASIA PNEUMATA +0486 COMBINING CYRILLIC PSILI PNEUMATA +0488 COMBINING CYRILLIC HUNDRED THOUSANDS SIGN +0489 COMBINING CYRILLIC MILLIONS SIGN +048A CYRILLIC CAPITAL LETTER SHORT I WITH TAIL +048B CYRILLIC SMALL LETTER SHORT I WITH TAIL +048C CYRILLIC CAPITAL LETTER SEMISOFT SIGN +048D CYRILLIC SMALL LETTER SEMISOFT SIGN +048E CYRILLIC CAPITAL LETTER ER WITH TICK +048F CYRILLIC SMALL LETTER ER WITH TICK +0490 CYRILLIC CAPITAL LETTER GHE WITH UPTURN +0491 CYRILLIC SMALL LETTER GHE WITH UPTURN +0492 CYRILLIC CAPITAL LETTER GHE WITH STROKE +0493 CYRILLIC SMALL LETTER GHE WITH STROKE +0494 CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK +0495 CYRILLIC SMALL LETTER GHE WITH MIDDLE HOOK +0496 CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER +0497 CYRILLIC SMALL LETTER ZHE WITH DESCENDER +0498 CYRILLIC CAPITAL LETTER ZE WITH DESCENDER +0499 CYRILLIC SMALL LETTER ZE WITH DESCENDER +049A CYRILLIC CAPITAL LETTER KA WITH DESCENDER +049B CYRILLIC SMALL LETTER KA WITH DESCENDER +049C CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE +049D CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE +049E CYRILLIC CAPITAL LETTER KA WITH STROKE +049F CYRILLIC SMALL LETTER KA WITH STROKE +04A0 CYRILLIC CAPITAL LETTER BASHKIR KA +04A1 CYRILLIC SMALL LETTER BASHKIR KA +04A2 CYRILLIC CAPITAL LETTER EN WITH DESCENDER +04A3 CYRILLIC SMALL LETTER EN WITH DESCENDER +04A4 CYRILLIC CAPITAL LIGATURE EN GHE +04A5 CYRILLIC SMALL LIGATURE EN GHE +04A6 CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK +04A7 CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK +04A8 CYRILLIC CAPITAL LETTER ABKHASIAN HA +04A9 CYRILLIC SMALL LETTER ABKHASIAN HA +04AA CYRILLIC CAPITAL LETTER ES WITH DESCENDER +04AB CYRILLIC SMALL LETTER ES WITH DESCENDER +04AC CYRILLIC CAPITAL LETTER TE WITH DESCENDER +04AD CYRILLIC SMALL LETTER TE WITH DESCENDER +04AE CYRILLIC CAPITAL LETTER STRAIGHT U +04AF CYRILLIC SMALL LETTER STRAIGHT U +04B0 CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE +04B1 CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE +04B2 CYRILLIC CAPITAL LETTER HA WITH DESCENDER +04B3 CYRILLIC SMALL LETTER HA WITH DESCENDER +04B4 CYRILLIC CAPITAL LIGATURE TE TSE +04B5 CYRILLIC SMALL LIGATURE TE TSE +04B6 CYRILLIC CAPITAL LETTER CHE WITH DESCENDER +04B7 CYRILLIC SMALL LETTER CHE WITH DESCENDER +04B8 CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE +04B9 CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE +04BA CYRILLIC CAPITAL LETTER SHHA +04BB CYRILLIC SMALL LETTER SHHA +04BC CYRILLIC CAPITAL LETTER ABKHASIAN CHE +04BD CYRILLIC SMALL LETTER ABKHASIAN CHE +04BE CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER +04BF CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER +04C0 CYRILLIC LETTER PALOCHKA +04C1 CYRILLIC CAPITAL LETTER ZHE WITH BREVE +04C2 CYRILLIC SMALL LETTER ZHE WITH BREVE +04C3 CYRILLIC CAPITAL LETTER KA WITH HOOK +04C4 CYRILLIC SMALL LETTER KA WITH HOOK +04C5 CYRILLIC CAPITAL LETTER EL WITH TAIL +04C6 CYRILLIC SMALL LETTER EL WITH TAIL +04C7 CYRILLIC CAPITAL LETTER EN WITH HOOK +04C8 CYRILLIC SMALL LETTER EN WITH HOOK +04C9 CYRILLIC CAPITAL LETTER EN WITH TAIL +04CA CYRILLIC SMALL LETTER EN WITH TAIL +04CB CYRILLIC CAPITAL LETTER KHAKASSIAN CHE +04CC CYRILLIC SMALL LETTER KHAKASSIAN CHE +04CD CYRILLIC CAPITAL LETTER EM WITH TAIL +04CE CYRILLIC SMALL LETTER EM WITH TAIL +04D0 CYRILLIC CAPITAL LETTER A WITH BREVE +04D1 CYRILLIC SMALL LETTER A WITH BREVE +04D2 CYRILLIC CAPITAL LETTER A WITH DIAERESIS +04D3 CYRILLIC SMALL LETTER A WITH DIAERESIS +04D4 CYRILLIC CAPITAL LIGATURE A IE +04D5 CYRILLIC SMALL LIGATURE A IE +04D6 CYRILLIC CAPITAL LETTER IE WITH BREVE +04D7 CYRILLIC SMALL LETTER IE WITH BREVE +04D8 CYRILLIC CAPITAL LETTER SCHWA +04D9 CYRILLIC SMALL LETTER SCHWA +04DA CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS +04DB CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS +04DC CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS +04DD CYRILLIC SMALL LETTER ZHE WITH DIAERESIS +04DE CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS +04DF CYRILLIC SMALL LETTER ZE WITH DIAERESIS +04E0 CYRILLIC CAPITAL LETTER ABKHASIAN DZE +04E1 CYRILLIC SMALL LETTER ABKHASIAN DZE +04E2 CYRILLIC CAPITAL LETTER I WITH MACRON +04E3 CYRILLIC SMALL LETTER I WITH MACRON +04E4 CYRILLIC CAPITAL LETTER I WITH DIAERESIS +04E5 CYRILLIC SMALL LETTER I WITH DIAERESIS +04E6 CYRILLIC CAPITAL LETTER O WITH DIAERESIS +04E7 CYRILLIC SMALL LETTER O WITH DIAERESIS +04E8 CYRILLIC CAPITAL LETTER BARRED O +04E9 CYRILLIC SMALL LETTER BARRED O +04EA CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS +04EB CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS +04EC CYRILLIC CAPITAL LETTER E WITH DIAERESIS +04ED CYRILLIC SMALL LETTER E WITH DIAERESIS +04EE CYRILLIC CAPITAL LETTER U WITH MACRON +04EF CYRILLIC SMALL LETTER U WITH MACRON +04F0 CYRILLIC CAPITAL LETTER U WITH DIAERESIS +04F1 CYRILLIC SMALL LETTER U WITH DIAERESIS +04F2 CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE +04F3 CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE +04F4 CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS +04F5 CYRILLIC SMALL LETTER CHE WITH DIAERESIS +04F8 CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS +04F9 CYRILLIC SMALL LETTER YERU WITH DIAERESIS +0500 CYRILLIC CAPITAL LETTER KOMI DE +0501 CYRILLIC SMALL LETTER KOMI DE +0502 CYRILLIC CAPITAL LETTER KOMI DJE +0503 CYRILLIC SMALL LETTER KOMI DJE +0504 CYRILLIC CAPITAL LETTER KOMI ZJE +0505 CYRILLIC SMALL LETTER KOMI ZJE +0506 CYRILLIC CAPITAL LETTER KOMI DZJE +0507 CYRILLIC SMALL LETTER KOMI DZJE +0508 CYRILLIC CAPITAL LETTER KOMI LJE +0509 CYRILLIC SMALL LETTER KOMI LJE +050A CYRILLIC CAPITAL LETTER KOMI NJE +050B CYRILLIC SMALL LETTER KOMI NJE +050C CYRILLIC CAPITAL LETTER KOMI SJE +050D CYRILLIC SMALL LETTER KOMI SJE +050E CYRILLIC CAPITAL LETTER KOMI TJE +050F CYRILLIC SMALL LETTER KOMI TJE +0531 ARMENIAN CAPITAL LETTER AYB +0532 ARMENIAN CAPITAL LETTER BEN +0533 ARMENIAN CAPITAL LETTER GIM +0534 ARMENIAN CAPITAL LETTER DA +0535 ARMENIAN CAPITAL LETTER ECH +0536 ARMENIAN CAPITAL LETTER ZA +0537 ARMENIAN CAPITAL LETTER EH +0538 ARMENIAN CAPITAL LETTER ET +0539 ARMENIAN CAPITAL LETTER TO +053A ARMENIAN CAPITAL LETTER ZHE +053B ARMENIAN CAPITAL LETTER INI +053C ARMENIAN CAPITAL LETTER LIWN +053D ARMENIAN CAPITAL LETTER XEH +053E ARMENIAN CAPITAL LETTER CA +053F ARMENIAN CAPITAL LETTER KEN +0540 ARMENIAN CAPITAL LETTER HO +0541 ARMENIAN CAPITAL LETTER JA +0542 ARMENIAN CAPITAL LETTER GHAD +0543 ARMENIAN CAPITAL LETTER CHEH +0544 ARMENIAN CAPITAL LETTER MEN +0545 ARMENIAN CAPITAL LETTER YI +0546 ARMENIAN CAPITAL LETTER NOW +0547 ARMENIAN CAPITAL LETTER SHA +0548 ARMENIAN CAPITAL LETTER VO +0549 ARMENIAN CAPITAL LETTER CHA +054A ARMENIAN CAPITAL LETTER PEH +054B ARMENIAN CAPITAL LETTER JHEH +054C ARMENIAN CAPITAL LETTER RA +054D ARMENIAN CAPITAL LETTER SEH +054E ARMENIAN CAPITAL LETTER VEW +054F ARMENIAN CAPITAL LETTER TIWN +0550 ARMENIAN CAPITAL LETTER REH +0551 ARMENIAN CAPITAL LETTER CO +0552 ARMENIAN CAPITAL LETTER YIWN +0553 ARMENIAN CAPITAL LETTER PIWR +0554 ARMENIAN CAPITAL LETTER KEH +0555 ARMENIAN CAPITAL LETTER OH +0556 ARMENIAN CAPITAL LETTER FEH +0559 ARMENIAN MODIFIER LETTER LEFT HALF RING +055A ARMENIAN APOSTROPHE +055B ARMENIAN EMPHASIS MARK +055C ARMENIAN EXCLAMATION MARK +055D ARMENIAN COMMA +055E ARMENIAN QUESTION MARK +055F ARMENIAN ABBREVIATION MARK +0561 ARMENIAN SMALL LETTER AYB +0562 ARMENIAN SMALL LETTER BEN +0563 ARMENIAN SMALL LETTER GIM +0564 ARMENIAN SMALL LETTER DA +0565 ARMENIAN SMALL LETTER ECH +0566 ARMENIAN SMALL LETTER ZA +0567 ARMENIAN SMALL LETTER EH +0568 ARMENIAN SMALL LETTER ET +0569 ARMENIAN SMALL LETTER TO +056A ARMENIAN SMALL LETTER ZHE +056B ARMENIAN SMALL LETTER INI +056C ARMENIAN SMALL LETTER LIWN +056D ARMENIAN SMALL LETTER XEH +056E ARMENIAN SMALL LETTER CA +056F ARMENIAN SMALL LETTER KEN +0570 ARMENIAN SMALL LETTER HO +0571 ARMENIAN SMALL LETTER JA +0572 ARMENIAN SMALL LETTER GHAD +0573 ARMENIAN SMALL LETTER CHEH +0574 ARMENIAN SMALL LETTER MEN +0575 ARMENIAN SMALL LETTER YI +0576 ARMENIAN SMALL LETTER NOW +0577 ARMENIAN SMALL LETTER SHA +0578 ARMENIAN SMALL LETTER VO +0579 ARMENIAN SMALL LETTER CHA +057A ARMENIAN SMALL LETTER PEH +057B ARMENIAN SMALL LETTER JHEH +057C ARMENIAN SMALL LETTER RA +057D ARMENIAN SMALL LETTER SEH +057E ARMENIAN SMALL LETTER VEW +057F ARMENIAN SMALL LETTER TIWN +0580 ARMENIAN SMALL LETTER REH +0581 ARMENIAN SMALL LETTER CO +0582 ARMENIAN SMALL LETTER YIWN +0583 ARMENIAN SMALL LETTER PIWR +0584 ARMENIAN SMALL LETTER KEH +0585 ARMENIAN SMALL LETTER OH +0586 ARMENIAN SMALL LETTER FEH +0587 ARMENIAN SMALL LIGATURE ECH YIWN +0589 ARMENIAN FULL STOP +058A ARMENIAN HYPHEN +0591 HEBREW ACCENT ETNAHTA +0592 HEBREW ACCENT SEGOL +0593 HEBREW ACCENT SHALSHELET +0594 HEBREW ACCENT ZAQEF QATAN +0595 HEBREW ACCENT ZAQEF GADOL +0596 HEBREW ACCENT TIPEHA +0597 HEBREW ACCENT REVIA +0598 HEBREW ACCENT ZARQA +0599 HEBREW ACCENT PASHTA +059A HEBREW ACCENT YETIV +059B HEBREW ACCENT TEVIR +059C HEBREW ACCENT GERESH +059D HEBREW ACCENT GERESH MUQDAM +059E HEBREW ACCENT GERSHAYIM +059F HEBREW ACCENT QARNEY PARA +05A0 HEBREW ACCENT TELISHA GEDOLA +05A1 HEBREW ACCENT PAZER +05A3 HEBREW ACCENT MUNAH +05A4 HEBREW ACCENT MAHAPAKH +05A5 HEBREW ACCENT MERKHA +05A6 HEBREW ACCENT MERKHA KEFULA +05A7 HEBREW ACCENT DARGA +05A8 HEBREW ACCENT QADMA +05A9 HEBREW ACCENT TELISHA QETANA +05AA HEBREW ACCENT YERAH BEN YOMO +05AB HEBREW ACCENT OLE +05AC HEBREW ACCENT ILUY +05AD HEBREW ACCENT DEHI +05AE HEBREW ACCENT ZINOR +05AF HEBREW MARK MASORA CIRCLE +05B0 HEBREW POINT SHEVA +05B1 HEBREW POINT HATAF SEGOL +05B2 HEBREW POINT HATAF PATAH +05B3 HEBREW POINT HATAF QAMATS +05B4 HEBREW POINT HIRIQ +05B5 HEBREW POINT TSERE +05B6 HEBREW POINT SEGOL +05B7 HEBREW POINT PATAH +05B8 HEBREW POINT QAMATS +05B9 HEBREW POINT HOLAM +05BB HEBREW POINT QUBUTS +05BC HEBREW POINT DAGESH OR MAPIQ +05BD HEBREW POINT METEG +05BE HEBREW PUNCTUATION MAQAF +05BF HEBREW POINT RAFE +05C0 HEBREW PUNCTUATION PASEQ +05C1 HEBREW POINT SHIN DOT +05C2 HEBREW POINT SIN DOT +05C3 HEBREW PUNCTUATION SOF PASUQ +05C4 HEBREW MARK UPPER DOT +05D0 HEBREW LETTER ALEF +05D1 HEBREW LETTER BET +05D2 HEBREW LETTER GIMEL +05D3 HEBREW LETTER DALET +05D4 HEBREW LETTER HE +05D5 HEBREW LETTER VAV +05D6 HEBREW LETTER ZAYIN +05D7 HEBREW LETTER HET +05D8 HEBREW LETTER TET +05D9 HEBREW LETTER YOD +05DA HEBREW LETTER FINAL KAF +05DB HEBREW LETTER KAF +05DC HEBREW LETTER LAMED +05DD HEBREW LETTER FINAL MEM +05DE HEBREW LETTER MEM +05DF HEBREW LETTER FINAL NUN +05E0 HEBREW LETTER NUN +05E1 HEBREW LETTER SAMEKH +05E2 HEBREW LETTER AYIN +05E3 HEBREW LETTER FINAL PE +05E4 HEBREW LETTER PE +05E5 HEBREW LETTER FINAL TSADI +05E6 HEBREW LETTER TSADI +05E7 HEBREW LETTER QOF +05E8 HEBREW LETTER RESH +05E9 HEBREW LETTER SHIN +05EA HEBREW LETTER TAV +05F0 HEBREW LIGATURE YIDDISH DOUBLE VAV +05F1 HEBREW LIGATURE YIDDISH VAV YOD +05F2 HEBREW LIGATURE YIDDISH DOUBLE YOD +05F3 HEBREW PUNCTUATION GERESH +05F4 HEBREW PUNCTUATION GERSHAYIM +060C ARABIC COMMA +061B ARABIC SEMICOLON +061F ARABIC QUESTION MARK +0621 ARABIC LETTER HAMZA +0622 ARABIC LETTER ALEF WITH MADDA ABOVE +0623 ARABIC LETTER ALEF WITH HAMZA ABOVE +0624 ARABIC LETTER WAW WITH HAMZA ABOVE +0625 ARABIC LETTER ALEF WITH HAMZA BELOW +0626 ARABIC LETTER YEH WITH HAMZA ABOVE +0627 ARABIC LETTER ALEF +0628 ARABIC LETTER BEH +0629 ARABIC LETTER TEH MARBUTA +062A ARABIC LETTER TEH +062B ARABIC LETTER THEH +062C ARABIC LETTER JEEM +062D ARABIC LETTER HAH +062E ARABIC LETTER KHAH +062F ARABIC LETTER DAL +0630 ARABIC LETTER THAL +0631 ARABIC LETTER REH +0632 ARABIC LETTER ZAIN +0633 ARABIC LETTER SEEN +0634 ARABIC LETTER SHEEN +0635 ARABIC LETTER SAD +0636 ARABIC LETTER DAD +0637 ARABIC LETTER TAH +0638 ARABIC LETTER ZAH +0639 ARABIC LETTER AIN +063A ARABIC LETTER GHAIN +0640 ARABIC TATWEEL +0641 ARABIC LETTER FEH +0642 ARABIC LETTER QAF +0643 ARABIC LETTER KAF +0644 ARABIC LETTER LAM +0645 ARABIC LETTER MEEM +0646 ARABIC LETTER NOON +0647 ARABIC LETTER HEH +0648 ARABIC LETTER WAW +0649 ARABIC LETTER ALEF MAKSURA +064A ARABIC LETTER YEH +064B ARABIC FATHATAN +064C ARABIC DAMMATAN +064D ARABIC KASRATAN +064E ARABIC FATHA +064F ARABIC DAMMA +0650 ARABIC KASRA +0651 ARABIC SHADDA +0652 ARABIC SUKUN +0653 ARABIC MADDAH ABOVE +0654 ARABIC HAMZA ABOVE +0655 ARABIC HAMZA BELOW +0660 ARABIC-INDIC DIGIT ZERO +0661 ARABIC-INDIC DIGIT ONE +0662 ARABIC-INDIC DIGIT TWO +0663 ARABIC-INDIC DIGIT THREE +0664 ARABIC-INDIC DIGIT FOUR +0665 ARABIC-INDIC DIGIT FIVE +0666 ARABIC-INDIC DIGIT SIX +0667 ARABIC-INDIC DIGIT SEVEN +0668 ARABIC-INDIC DIGIT EIGHT +0669 ARABIC-INDIC DIGIT NINE +066A ARABIC PERCENT SIGN +066B ARABIC DECIMAL SEPARATOR +066C ARABIC THOUSANDS SEPARATOR +066D ARABIC FIVE POINTED STAR +066E ARABIC LETTER DOTLESS BEH +066F ARABIC LETTER DOTLESS QAF +0670 ARABIC LETTER SUPERSCRIPT ALEF +0671 ARABIC LETTER ALEF WASLA +0672 ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE +0673 ARABIC LETTER ALEF WITH WAVY HAMZA BELOW +0674 ARABIC LETTER HIGH HAMZA +0675 ARABIC LETTER HIGH HAMZA ALEF +0676 ARABIC LETTER HIGH HAMZA WAW +0677 ARABIC LETTER U WITH HAMZA ABOVE +0678 ARABIC LETTER HIGH HAMZA YEH +0679 ARABIC LETTER TTEH +067A ARABIC LETTER TTEHEH +067B ARABIC LETTER BEEH +067C ARABIC LETTER TEH WITH RING +067D ARABIC LETTER TEH WITH THREE DOTS ABOVE DOWNWARDS +067E ARABIC LETTER PEH +067F ARABIC LETTER TEHEH +0680 ARABIC LETTER BEHEH +0681 ARABIC LETTER HAH WITH HAMZA ABOVE +0682 ARABIC LETTER HAH WITH TWO DOTS VERTICAL ABOVE +0683 ARABIC LETTER NYEH +0684 ARABIC LETTER DYEH +0685 ARABIC LETTER HAH WITH THREE DOTS ABOVE +0686 ARABIC LETTER TCHEH +0687 ARABIC LETTER TCHEHEH +0688 ARABIC LETTER DDAL +0689 ARABIC LETTER DAL WITH RING +068A ARABIC LETTER DAL WITH DOT BELOW +068B ARABIC LETTER DAL WITH DOT BELOW AND SMALL TAH +068C ARABIC LETTER DAHAL +068D ARABIC LETTER DDAHAL +068E ARABIC LETTER DUL +068F ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS +0690 ARABIC LETTER DAL WITH FOUR DOTS ABOVE +0691 ARABIC LETTER RREH +0692 ARABIC LETTER REH WITH SMALL V +0693 ARABIC LETTER REH WITH RING +0694 ARABIC LETTER REH WITH DOT BELOW +0695 ARABIC LETTER REH WITH SMALL V BELOW +0696 ARABIC LETTER REH WITH DOT BELOW AND DOT ABOVE +0697 ARABIC LETTER REH WITH TWO DOTS ABOVE +0698 ARABIC LETTER JEH +0699 ARABIC LETTER REH WITH FOUR DOTS ABOVE +069A ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE +069B ARABIC LETTER SEEN WITH THREE DOTS BELOW +069C ARABIC LETTER SEEN WITH THREE DOTS BELOW AND THREE DOTS ABOVE +069D ARABIC LETTER SAD WITH TWO DOTS BELOW +069E ARABIC LETTER SAD WITH THREE DOTS ABOVE +069F ARABIC LETTER TAH WITH THREE DOTS ABOVE +06A0 ARABIC LETTER AIN WITH THREE DOTS ABOVE +06A1 ARABIC LETTER DOTLESS FEH +06A2 ARABIC LETTER FEH WITH DOT MOVED BELOW +06A3 ARABIC LETTER FEH WITH DOT BELOW +06A4 ARABIC LETTER VEH +06A5 ARABIC LETTER FEH WITH THREE DOTS BELOW +06A6 ARABIC LETTER PEHEH +06A7 ARABIC LETTER QAF WITH DOT ABOVE +06A8 ARABIC LETTER QAF WITH THREE DOTS ABOVE +06A9 ARABIC LETTER KEHEH +06AA ARABIC LETTER SWASH KAF +06AB ARABIC LETTER KAF WITH RING +06AC ARABIC LETTER KAF WITH DOT ABOVE +06AD ARABIC LETTER NG +06AE ARABIC LETTER KAF WITH THREE DOTS BELOW +06AF ARABIC LETTER GAF +06B0 ARABIC LETTER GAF WITH RING +06B1 ARABIC LETTER NGOEH +06B2 ARABIC LETTER GAF WITH TWO DOTS BELOW +06B3 ARABIC LETTER GUEH +06B4 ARABIC LETTER GAF WITH THREE DOTS ABOVE +06B5 ARABIC LETTER LAM WITH SMALL V +06B6 ARABIC LETTER LAM WITH DOT ABOVE +06B7 ARABIC LETTER LAM WITH THREE DOTS ABOVE +06B8 ARABIC LETTER LAM WITH THREE DOTS BELOW +06B9 ARABIC LETTER NOON WITH DOT BELOW +06BA ARABIC LETTER NOON GHUNNA +06BB ARABIC LETTER RNOON +06BC ARABIC LETTER NOON WITH RING +06BD ARABIC LETTER NOON WITH THREE DOTS ABOVE +06BE ARABIC LETTER HEH DOACHASHMEE +06BF ARABIC LETTER TCHEH WITH DOT ABOVE +06C0 ARABIC LETTER HEH WITH YEH ABOVE +06C1 ARABIC LETTER HEH GOAL +06C2 ARABIC LETTER HEH GOAL WITH HAMZA ABOVE +06C3 ARABIC LETTER TEH MARBUTA GOAL +06C4 ARABIC LETTER WAW WITH RING +06C5 ARABIC LETTER KIRGHIZ OE +06C6 ARABIC LETTER OE +06C7 ARABIC LETTER U +06C8 ARABIC LETTER YU +06C9 ARABIC LETTER KIRGHIZ YU +06CA ARABIC LETTER WAW WITH TWO DOTS ABOVE +06CB ARABIC LETTER VE +06CC ARABIC LETTER FARSI YEH +06CD ARABIC LETTER YEH WITH TAIL +06CE ARABIC LETTER YEH WITH SMALL V +06CF ARABIC LETTER WAW WITH DOT ABOVE +06D0 ARABIC LETTER E +06D1 ARABIC LETTER YEH WITH THREE DOTS BELOW +06D2 ARABIC LETTER YEH BARREE +06D3 ARABIC LETTER YEH BARREE WITH HAMZA ABOVE +06D4 ARABIC FULL STOP +06D5 ARABIC LETTER AE +06D6 ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA +06D7 ARABIC SMALL HIGH LIGATURE QAF WITH LAM WITH ALEF MAKSURA +06D8 ARABIC SMALL HIGH MEEM INITIAL FORM +06D9 ARABIC SMALL HIGH LAM ALEF +06DA ARABIC SMALL HIGH JEEM +06DB ARABIC SMALL HIGH THREE DOTS +06DC ARABIC SMALL HIGH SEEN +06DD ARABIC END OF AYAH +06DE ARABIC START OF RUB EL HIZB +06DF ARABIC SMALL HIGH ROUNDED ZERO +06E0 ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO +06E1 ARABIC SMALL HIGH DOTLESS HEAD OF KHAH +06E2 ARABIC SMALL HIGH MEEM ISOLATED FORM +06E3 ARABIC SMALL LOW SEEN +06E4 ARABIC SMALL HIGH MADDA +06E5 ARABIC SMALL WAW +06E6 ARABIC SMALL YEH +06E7 ARABIC SMALL HIGH YEH +06E8 ARABIC SMALL HIGH NOON +06E9 ARABIC PLACE OF SAJDAH +06EA ARABIC EMPTY CENTRE LOW STOP +06EB ARABIC EMPTY CENTRE HIGH STOP +06EC ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE +06ED ARABIC SMALL LOW MEEM +06F0 EXTENDED ARABIC-INDIC DIGIT ZERO +06F1 EXTENDED ARABIC-INDIC DIGIT ONE +06F2 EXTENDED ARABIC-INDIC DIGIT TWO +06F3 EXTENDED ARABIC-INDIC DIGIT THREE +06F4 EXTENDED ARABIC-INDIC DIGIT FOUR +06F5 EXTENDED ARABIC-INDIC DIGIT FIVE +06F6 EXTENDED ARABIC-INDIC DIGIT SIX +06F7 EXTENDED ARABIC-INDIC DIGIT SEVEN +06F8 EXTENDED ARABIC-INDIC DIGIT EIGHT +06F9 EXTENDED ARABIC-INDIC DIGIT NINE +06FA ARABIC LETTER SHEEN WITH DOT BELOW +06FB ARABIC LETTER DAD WITH DOT BELOW +06FC ARABIC LETTER GHAIN WITH DOT BELOW +06FD ARABIC SIGN SINDHI AMPERSAND +06FE ARABIC SIGN SINDHI POSTPOSITION MEN +0700 SYRIAC END OF PARAGRAPH +0701 SYRIAC SUPRALINEAR FULL STOP +0702 SYRIAC SUBLINEAR FULL STOP +0703 SYRIAC SUPRALINEAR COLON +0704 SYRIAC SUBLINEAR COLON +0705 SYRIAC HORIZONTAL COLON +0706 SYRIAC COLON SKEWED LEFT +0707 SYRIAC COLON SKEWED RIGHT +0708 SYRIAC SUPRALINEAR COLON SKEWED LEFT +0709 SYRIAC SUBLINEAR COLON SKEWED RIGHT +070A SYRIAC CONTRACTION +070B SYRIAC HARKLEAN OBELUS +070C SYRIAC HARKLEAN METOBELUS +070D SYRIAC HARKLEAN ASTERISCUS +070F SYRIAC ABBREVIATION MARK +0710 SYRIAC LETTER ALAPH +0711 SYRIAC LETTER SUPERSCRIPT ALAPH +0712 SYRIAC LETTER BETH +0713 SYRIAC LETTER GAMAL +0714 SYRIAC LETTER GAMAL GARSHUNI +0715 SYRIAC LETTER DALATH +0716 SYRIAC LETTER DOTLESS DALATH RISH +0717 SYRIAC LETTER HE +0718 SYRIAC LETTER WAW +0719 SYRIAC LETTER ZAIN +071A SYRIAC LETTER HETH +071B SYRIAC LETTER TETH +071C SYRIAC LETTER TETH GARSHUNI +071D SYRIAC LETTER YUDH +071E SYRIAC LETTER YUDH HE +071F SYRIAC LETTER KAPH +0720 SYRIAC LETTER LAMADH +0721 SYRIAC LETTER MIM +0722 SYRIAC LETTER NUN +0723 SYRIAC LETTER SEMKATH +0724 SYRIAC LETTER FINAL SEMKATH +0725 SYRIAC LETTER E +0726 SYRIAC LETTER PE +0727 SYRIAC LETTER REVERSED PE +0728 SYRIAC LETTER SADHE +0729 SYRIAC LETTER QAPH +072A SYRIAC LETTER RISH +072B SYRIAC LETTER SHIN +072C SYRIAC LETTER TAW +0730 SYRIAC PTHAHA ABOVE +0731 SYRIAC PTHAHA BELOW +0732 SYRIAC PTHAHA DOTTED +0733 SYRIAC ZQAPHA ABOVE +0734 SYRIAC ZQAPHA BELOW +0735 SYRIAC ZQAPHA DOTTED +0736 SYRIAC RBASA ABOVE +0737 SYRIAC RBASA BELOW +0738 SYRIAC DOTTED ZLAMA HORIZONTAL +0739 SYRIAC DOTTED ZLAMA ANGULAR +073A SYRIAC HBASA ABOVE +073B SYRIAC HBASA BELOW +073C SYRIAC HBASA-ESASA DOTTED +073D SYRIAC ESASA ABOVE +073E SYRIAC ESASA BELOW +073F SYRIAC RWAHA +0740 SYRIAC FEMININE DOT +0741 SYRIAC QUSHSHAYA +0742 SYRIAC RUKKAKHA +0743 SYRIAC TWO VERTICAL DOTS ABOVE +0744 SYRIAC TWO VERTICAL DOTS BELOW +0745 SYRIAC THREE DOTS ABOVE +0746 SYRIAC THREE DOTS BELOW +0747 SYRIAC OBLIQUE LINE ABOVE +0748 SYRIAC OBLIQUE LINE BELOW +0749 SYRIAC MUSIC +074A SYRIAC BARREKH +0780 THAANA LETTER HAA +0781 THAANA LETTER SHAVIYANI +0782 THAANA LETTER NOONU +0783 THAANA LETTER RAA +0784 THAANA LETTER BAA +0785 THAANA LETTER LHAVIYANI +0786 THAANA LETTER KAAFU +0787 THAANA LETTER ALIFU +0788 THAANA LETTER VAAVU +0789 THAANA LETTER MEEMU +078A THAANA LETTER FAAFU +078B THAANA LETTER DHAALU +078C THAANA LETTER THAA +078D THAANA LETTER LAAMU +078E THAANA LETTER GAAFU +078F THAANA LETTER GNAVIYANI +0790 THAANA LETTER SEENU +0791 THAANA LETTER DAVIYANI +0792 THAANA LETTER ZAVIYANI +0793 THAANA LETTER TAVIYANI +0794 THAANA LETTER YAA +0795 THAANA LETTER PAVIYANI +0796 THAANA LETTER JAVIYANI +0797 THAANA LETTER CHAVIYANI +0798 THAANA LETTER TTAA +0799 THAANA LETTER HHAA +079A THAANA LETTER KHAA +079B THAANA LETTER THAALU +079C THAANA LETTER ZAA +079D THAANA LETTER SHEENU +079E THAANA LETTER SAADHU +079F THAANA LETTER DAADHU +07A0 THAANA LETTER TO +07A1 THAANA LETTER ZO +07A2 THAANA LETTER AINU +07A3 THAANA LETTER GHAINU +07A4 THAANA LETTER QAAFU +07A5 THAANA LETTER WAAVU +07A6 THAANA ABAFILI +07A7 THAANA AABAAFILI +07A8 THAANA IBIFILI +07A9 THAANA EEBEEFILI +07AA THAANA UBUFILI +07AB THAANA OOBOOFILI +07AC THAANA EBEFILI +07AD THAANA EYBEYFILI +07AE THAANA OBOFILI +07AF THAANA OABOAFILI +07B0 THAANA SUKUN +07B1 THAANA LETTER NAA +0901 DEVANAGARI SIGN CANDRABINDU +0902 DEVANAGARI SIGN ANUSVARA +0903 DEVANAGARI SIGN VISARGA +0905 DEVANAGARI LETTER A +0906 DEVANAGARI LETTER AA +0907 DEVANAGARI LETTER I +0908 DEVANAGARI LETTER II +0909 DEVANAGARI LETTER U +090A DEVANAGARI LETTER UU +090B DEVANAGARI LETTER VOCALIC R +090C DEVANAGARI LETTER VOCALIC L +090D DEVANAGARI LETTER CANDRA E +090E DEVANAGARI LETTER SHORT E +090F DEVANAGARI LETTER E +0910 DEVANAGARI LETTER AI +0911 DEVANAGARI LETTER CANDRA O +0912 DEVANAGARI LETTER SHORT O +0913 DEVANAGARI LETTER O +0914 DEVANAGARI LETTER AU +0915 DEVANAGARI LETTER KA +0916 DEVANAGARI LETTER KHA +0917 DEVANAGARI LETTER GA +0918 DEVANAGARI LETTER GHA +0919 DEVANAGARI LETTER NGA +091A DEVANAGARI LETTER CA +091B DEVANAGARI LETTER CHA +091C DEVANAGARI LETTER JA +091D DEVANAGARI LETTER JHA +091E DEVANAGARI LETTER NYA +091F DEVANAGARI LETTER TTA +0920 DEVANAGARI LETTER TTHA +0921 DEVANAGARI LETTER DDA +0922 DEVANAGARI LETTER DDHA +0923 DEVANAGARI LETTER NNA +0924 DEVANAGARI LETTER TA +0925 DEVANAGARI LETTER THA +0926 DEVANAGARI LETTER DA +0927 DEVANAGARI LETTER DHA +0928 DEVANAGARI LETTER NA +0929 DEVANAGARI LETTER NNNA +092A DEVANAGARI LETTER PA +092B DEVANAGARI LETTER PHA +092C DEVANAGARI LETTER BA +092D DEVANAGARI LETTER BHA +092E DEVANAGARI LETTER MA +092F DEVANAGARI LETTER YA +0930 DEVANAGARI LETTER RA +0931 DEVANAGARI LETTER RRA +0932 DEVANAGARI LETTER LA +0933 DEVANAGARI LETTER LLA +0934 DEVANAGARI LETTER LLLA +0935 DEVANAGARI LETTER VA +0936 DEVANAGARI LETTER SHA +0937 DEVANAGARI LETTER SSA +0938 DEVANAGARI LETTER SA +0939 DEVANAGARI LETTER HA +093C DEVANAGARI SIGN NUKTA +093D DEVANAGARI SIGN AVAGRAHA +093E DEVANAGARI VOWEL SIGN AA +093F DEVANAGARI VOWEL SIGN I +0940 DEVANAGARI VOWEL SIGN II +0941 DEVANAGARI VOWEL SIGN U +0942 DEVANAGARI VOWEL SIGN UU +0943 DEVANAGARI VOWEL SIGN VOCALIC R +0944 DEVANAGARI VOWEL SIGN VOCALIC RR +0945 DEVANAGARI VOWEL SIGN CANDRA E +0946 DEVANAGARI VOWEL SIGN SHORT E +0947 DEVANAGARI VOWEL SIGN E +0948 DEVANAGARI VOWEL SIGN AI +0949 DEVANAGARI VOWEL SIGN CANDRA O +094A DEVANAGARI VOWEL SIGN SHORT O +094B DEVANAGARI VOWEL SIGN O +094C DEVANAGARI VOWEL SIGN AU +094D DEVANAGARI SIGN VIRAMA +0950 DEVANAGARI OM +0951 DEVANAGARI STRESS SIGN UDATTA +0952 DEVANAGARI STRESS SIGN ANUDATTA +0953 DEVANAGARI GRAVE ACCENT +0954 DEVANAGARI ACUTE ACCENT +0958 DEVANAGARI LETTER QA +0959 DEVANAGARI LETTER KHHA +095A DEVANAGARI LETTER GHHA +095B DEVANAGARI LETTER ZA +095C DEVANAGARI LETTER DDDHA +095D DEVANAGARI LETTER RHA +095E DEVANAGARI LETTER FA +095F DEVANAGARI LETTER YYA +0960 DEVANAGARI LETTER VOCALIC RR +0961 DEVANAGARI LETTER VOCALIC LL +0962 DEVANAGARI VOWEL SIGN VOCALIC L +0963 DEVANAGARI VOWEL SIGN VOCALIC LL +0964 DEVANAGARI DANDA +0965 DEVANAGARI DOUBLE DANDA +0966 DEVANAGARI DIGIT ZERO +0967 DEVANAGARI DIGIT ONE +0968 DEVANAGARI DIGIT TWO +0969 DEVANAGARI DIGIT THREE +096A DEVANAGARI DIGIT FOUR +096B DEVANAGARI DIGIT FIVE +096C DEVANAGARI DIGIT SIX +096D DEVANAGARI DIGIT SEVEN +096E DEVANAGARI DIGIT EIGHT +096F DEVANAGARI DIGIT NINE +0970 DEVANAGARI ABBREVIATION SIGN +0981 BENGALI SIGN CANDRABINDU +0982 BENGALI SIGN ANUSVARA +0983 BENGALI SIGN VISARGA +0985 BENGALI LETTER A +0986 BENGALI LETTER AA +0987 BENGALI LETTER I +0988 BENGALI LETTER II +0989 BENGALI LETTER U +098A BENGALI LETTER UU +098B BENGALI LETTER VOCALIC R +098C BENGALI LETTER VOCALIC L +098F BENGALI LETTER E +0990 BENGALI LETTER AI +0993 BENGALI LETTER O +0994 BENGALI LETTER AU +0995 BENGALI LETTER KA +0996 BENGALI LETTER KHA +0997 BENGALI LETTER GA +0998 BENGALI LETTER GHA +0999 BENGALI LETTER NGA +099A BENGALI LETTER CA +099B BENGALI LETTER CHA +099C BENGALI LETTER JA +099D BENGALI LETTER JHA +099E BENGALI LETTER NYA +099F BENGALI LETTER TTA +09A0 BENGALI LETTER TTHA +09A1 BENGALI LETTER DDA +09A2 BENGALI LETTER DDHA +09A3 BENGALI LETTER NNA +09A4 BENGALI LETTER TA +09A5 BENGALI LETTER THA +09A6 BENGALI LETTER DA +09A7 BENGALI LETTER DHA +09A8 BENGALI LETTER NA +09AA BENGALI LETTER PA +09AB BENGALI LETTER PHA +09AC BENGALI LETTER BA +09AD BENGALI LETTER BHA +09AE BENGALI LETTER MA +09AF BENGALI LETTER YA +09B0 BENGALI LETTER RA +09B2 BENGALI LETTER LA +09B6 BENGALI LETTER SHA +09B7 BENGALI LETTER SSA +09B8 BENGALI LETTER SA +09B9 BENGALI LETTER HA +09BC BENGALI SIGN NUKTA +09BE BENGALI VOWEL SIGN AA +09BF BENGALI VOWEL SIGN I +09C0 BENGALI VOWEL SIGN II +09C1 BENGALI VOWEL SIGN U +09C2 BENGALI VOWEL SIGN UU +09C3 BENGALI VOWEL SIGN VOCALIC R +09C4 BENGALI VOWEL SIGN VOCALIC RR +09C7 BENGALI VOWEL SIGN E +09C8 BENGALI VOWEL SIGN AI +09CB BENGALI VOWEL SIGN O +09CC BENGALI VOWEL SIGN AU +09CD BENGALI SIGN VIRAMA +09D7 BENGALI AU LENGTH MARK +09DC BENGALI LETTER RRA +09DD BENGALI LETTER RHA +09DF BENGALI LETTER YYA +09E0 BENGALI LETTER VOCALIC RR +09E1 BENGALI LETTER VOCALIC LL +09E2 BENGALI VOWEL SIGN VOCALIC L +09E3 BENGALI VOWEL SIGN VOCALIC LL +09E6 BENGALI DIGIT ZERO +09E7 BENGALI DIGIT ONE +09E8 BENGALI DIGIT TWO +09E9 BENGALI DIGIT THREE +09EA BENGALI DIGIT FOUR +09EB BENGALI DIGIT FIVE +09EC BENGALI DIGIT SIX +09ED BENGALI DIGIT SEVEN +09EE BENGALI DIGIT EIGHT +09EF BENGALI DIGIT NINE +09F0 BENGALI LETTER RA WITH MIDDLE DIAGONAL +09F1 BENGALI LETTER RA WITH LOWER DIAGONAL +09F2 BENGALI RUPEE MARK +09F3 BENGALI RUPEE SIGN +09F4 BENGALI CURRENCY NUMERATOR ONE +09F5 BENGALI CURRENCY NUMERATOR TWO +09F6 BENGALI CURRENCY NUMERATOR THREE +09F7 BENGALI CURRENCY NUMERATOR FOUR +09F8 BENGALI CURRENCY NUMERATOR ONE LESS THAN THE DENOMINATOR +09F9 BENGALI CURRENCY DENOMINATOR SIXTEEN +09FA BENGALI ISSHAR +0A02 GURMUKHI SIGN BINDI +0A05 GURMUKHI LETTER A +0A06 GURMUKHI LETTER AA +0A07 GURMUKHI LETTER I +0A08 GURMUKHI LETTER II +0A09 GURMUKHI LETTER U +0A0A GURMUKHI LETTER UU +0A0F GURMUKHI LETTER EE +0A10 GURMUKHI LETTER AI +0A13 GURMUKHI LETTER OO +0A14 GURMUKHI LETTER AU +0A15 GURMUKHI LETTER KA +0A16 GURMUKHI LETTER KHA +0A17 GURMUKHI LETTER GA +0A18 GURMUKHI LETTER GHA +0A19 GURMUKHI LETTER NGA +0A1A GURMUKHI LETTER CA +0A1B GURMUKHI LETTER CHA +0A1C GURMUKHI LETTER JA +0A1D GURMUKHI LETTER JHA +0A1E GURMUKHI LETTER NYA +0A1F GURMUKHI LETTER TTA +0A20 GURMUKHI LETTER TTHA +0A21 GURMUKHI LETTER DDA +0A22 GURMUKHI LETTER DDHA +0A23 GURMUKHI LETTER NNA +0A24 GURMUKHI LETTER TA +0A25 GURMUKHI LETTER THA +0A26 GURMUKHI LETTER DA +0A27 GURMUKHI LETTER DHA +0A28 GURMUKHI LETTER NA +0A2A GURMUKHI LETTER PA +0A2B GURMUKHI LETTER PHA +0A2C GURMUKHI LETTER BA +0A2D GURMUKHI LETTER BHA +0A2E GURMUKHI LETTER MA +0A2F GURMUKHI LETTER YA +0A30 GURMUKHI LETTER RA +0A32 GURMUKHI LETTER LA +0A33 GURMUKHI LETTER LLA +0A35 GURMUKHI LETTER VA +0A36 GURMUKHI LETTER SHA +0A38 GURMUKHI LETTER SA +0A39 GURMUKHI LETTER HA +0A3C GURMUKHI SIGN NUKTA +0A3E GURMUKHI VOWEL SIGN AA +0A3F GURMUKHI VOWEL SIGN I +0A40 GURMUKHI VOWEL SIGN II +0A41 GURMUKHI VOWEL SIGN U +0A42 GURMUKHI VOWEL SIGN UU +0A47 GURMUKHI VOWEL SIGN EE +0A48 GURMUKHI VOWEL SIGN AI +0A4B GURMUKHI VOWEL SIGN OO +0A4C GURMUKHI VOWEL SIGN AU +0A4D GURMUKHI SIGN VIRAMA +0A59 GURMUKHI LETTER KHHA +0A5A GURMUKHI LETTER GHHA +0A5B GURMUKHI LETTER ZA +0A5C GURMUKHI LETTER RRA +0A5E GURMUKHI LETTER FA +0A66 GURMUKHI DIGIT ZERO +0A67 GURMUKHI DIGIT ONE +0A68 GURMUKHI DIGIT TWO +0A69 GURMUKHI DIGIT THREE +0A6A GURMUKHI DIGIT FOUR +0A6B GURMUKHI DIGIT FIVE +0A6C GURMUKHI DIGIT SIX +0A6D GURMUKHI DIGIT SEVEN +0A6E GURMUKHI DIGIT EIGHT +0A6F GURMUKHI DIGIT NINE +0A70 GURMUKHI TIPPI +0A71 GURMUKHI ADDAK +0A72 GURMUKHI IRI +0A73 GURMUKHI URA +0A74 GURMUKHI EK ONKAR +0A81 GUJARATI SIGN CANDRABINDU +0A82 GUJARATI SIGN ANUSVARA +0A83 GUJARATI SIGN VISARGA +0A85 GUJARATI LETTER A +0A86 GUJARATI LETTER AA +0A87 GUJARATI LETTER I +0A88 GUJARATI LETTER II +0A89 GUJARATI LETTER U +0A8A GUJARATI LETTER UU +0A8B GUJARATI LETTER VOCALIC R +0A8D GUJARATI VOWEL CANDRA E +0A8F GUJARATI LETTER E +0A90 GUJARATI LETTER AI +0A91 GUJARATI VOWEL CANDRA O +0A93 GUJARATI LETTER O +0A94 GUJARATI LETTER AU +0A95 GUJARATI LETTER KA +0A96 GUJARATI LETTER KHA +0A97 GUJARATI LETTER GA +0A98 GUJARATI LETTER GHA +0A99 GUJARATI LETTER NGA +0A9A GUJARATI LETTER CA +0A9B GUJARATI LETTER CHA +0A9C GUJARATI LETTER JA +0A9D GUJARATI LETTER JHA +0A9E GUJARATI LETTER NYA +0A9F GUJARATI LETTER TTA +0AA0 GUJARATI LETTER TTHA +0AA1 GUJARATI LETTER DDA +0AA2 GUJARATI LETTER DDHA +0AA3 GUJARATI LETTER NNA +0AA4 GUJARATI LETTER TA +0AA5 GUJARATI LETTER THA +0AA6 GUJARATI LETTER DA +0AA7 GUJARATI LETTER DHA +0AA8 GUJARATI LETTER NA +0AAA GUJARATI LETTER PA +0AAB GUJARATI LETTER PHA +0AAC GUJARATI LETTER BA +0AAD GUJARATI LETTER BHA +0AAE GUJARATI LETTER MA +0AAF GUJARATI LETTER YA +0AB0 GUJARATI LETTER RA +0AB2 GUJARATI LETTER LA +0AB3 GUJARATI LETTER LLA +0AB5 GUJARATI LETTER VA +0AB6 GUJARATI LETTER SHA +0AB7 GUJARATI LETTER SSA +0AB8 GUJARATI LETTER SA +0AB9 GUJARATI LETTER HA +0ABC GUJARATI SIGN NUKTA +0ABD GUJARATI SIGN AVAGRAHA +0ABE GUJARATI VOWEL SIGN AA +0ABF GUJARATI VOWEL SIGN I +0AC0 GUJARATI VOWEL SIGN II +0AC1 GUJARATI VOWEL SIGN U +0AC2 GUJARATI VOWEL SIGN UU +0AC3 GUJARATI VOWEL SIGN VOCALIC R +0AC4 GUJARATI VOWEL SIGN VOCALIC RR +0AC5 GUJARATI VOWEL SIGN CANDRA E +0AC7 GUJARATI VOWEL SIGN E +0AC8 GUJARATI VOWEL SIGN AI +0AC9 GUJARATI VOWEL SIGN CANDRA O +0ACB GUJARATI VOWEL SIGN O +0ACC GUJARATI VOWEL SIGN AU +0ACD GUJARATI SIGN VIRAMA +0AD0 GUJARATI OM +0AE0 GUJARATI LETTER VOCALIC RR +0AE6 GUJARATI DIGIT ZERO +0AE7 GUJARATI DIGIT ONE +0AE8 GUJARATI DIGIT TWO +0AE9 GUJARATI DIGIT THREE +0AEA GUJARATI DIGIT FOUR +0AEB GUJARATI DIGIT FIVE +0AEC GUJARATI DIGIT SIX +0AED GUJARATI DIGIT SEVEN +0AEE GUJARATI DIGIT EIGHT +0AEF GUJARATI DIGIT NINE +0B01 ORIYA SIGN CANDRABINDU +0B02 ORIYA SIGN ANUSVARA +0B03 ORIYA SIGN VISARGA +0B05 ORIYA LETTER A +0B06 ORIYA LETTER AA +0B07 ORIYA LETTER I +0B08 ORIYA LETTER II +0B09 ORIYA LETTER U +0B0A ORIYA LETTER UU +0B0B ORIYA LETTER VOCALIC R +0B0C ORIYA LETTER VOCALIC L +0B0F ORIYA LETTER E +0B10 ORIYA LETTER AI +0B13 ORIYA LETTER O +0B14 ORIYA LETTER AU +0B15 ORIYA LETTER KA +0B16 ORIYA LETTER KHA +0B17 ORIYA LETTER GA +0B18 ORIYA LETTER GHA +0B19 ORIYA LETTER NGA +0B1A ORIYA LETTER CA +0B1B ORIYA LETTER CHA +0B1C ORIYA LETTER JA +0B1D ORIYA LETTER JHA +0B1E ORIYA LETTER NYA +0B1F ORIYA LETTER TTA +0B20 ORIYA LETTER TTHA +0B21 ORIYA LETTER DDA +0B22 ORIYA LETTER DDHA +0B23 ORIYA LETTER NNA +0B24 ORIYA LETTER TA +0B25 ORIYA LETTER THA +0B26 ORIYA LETTER DA +0B27 ORIYA LETTER DHA +0B28 ORIYA LETTER NA +0B2A ORIYA LETTER PA +0B2B ORIYA LETTER PHA +0B2C ORIYA LETTER BA +0B2D ORIYA LETTER BHA +0B2E ORIYA LETTER MA +0B2F ORIYA LETTER YA +0B30 ORIYA LETTER RA +0B32 ORIYA LETTER LA +0B33 ORIYA LETTER LLA +0B36 ORIYA LETTER SHA +0B37 ORIYA LETTER SSA +0B38 ORIYA LETTER SA +0B39 ORIYA LETTER HA +0B3C ORIYA SIGN NUKTA +0B3D ORIYA SIGN AVAGRAHA +0B3E ORIYA VOWEL SIGN AA +0B3F ORIYA VOWEL SIGN I +0B40 ORIYA VOWEL SIGN II +0B41 ORIYA VOWEL SIGN U +0B42 ORIYA VOWEL SIGN UU +0B43 ORIYA VOWEL SIGN VOCALIC R +0B47 ORIYA VOWEL SIGN E +0B48 ORIYA VOWEL SIGN AI +0B4B ORIYA VOWEL SIGN O +0B4C ORIYA VOWEL SIGN AU +0B4D ORIYA SIGN VIRAMA +0B56 ORIYA AI LENGTH MARK +0B57 ORIYA AU LENGTH MARK +0B5C ORIYA LETTER RRA +0B5D ORIYA LETTER RHA +0B5F ORIYA LETTER YYA +0B60 ORIYA LETTER VOCALIC RR +0B61 ORIYA LETTER VOCALIC LL +0B66 ORIYA DIGIT ZERO +0B67 ORIYA DIGIT ONE +0B68 ORIYA DIGIT TWO +0B69 ORIYA DIGIT THREE +0B6A ORIYA DIGIT FOUR +0B6B ORIYA DIGIT FIVE +0B6C ORIYA DIGIT SIX +0B6D ORIYA DIGIT SEVEN +0B6E ORIYA DIGIT EIGHT +0B6F ORIYA DIGIT NINE +0B70 ORIYA ISSHAR +0B82 TAMIL SIGN ANUSVARA +0B83 TAMIL SIGN VISARGA +0B85 TAMIL LETTER A +0B86 TAMIL LETTER AA +0B87 TAMIL LETTER I +0B88 TAMIL LETTER II +0B89 TAMIL LETTER U +0B8A TAMIL LETTER UU +0B8E TAMIL LETTER E +0B8F TAMIL LETTER EE +0B90 TAMIL LETTER AI +0B92 TAMIL LETTER O +0B93 TAMIL LETTER OO +0B94 TAMIL LETTER AU +0B95 TAMIL LETTER KA +0B99 TAMIL LETTER NGA +0B9A TAMIL LETTER CA +0B9C TAMIL LETTER JA +0B9E TAMIL LETTER NYA +0B9F TAMIL LETTER TTA +0BA3 TAMIL LETTER NNA +0BA4 TAMIL LETTER TA +0BA8 TAMIL LETTER NA +0BA9 TAMIL LETTER NNNA +0BAA TAMIL LETTER PA +0BAE TAMIL LETTER MA +0BAF TAMIL LETTER YA +0BB0 TAMIL LETTER RA +0BB1 TAMIL LETTER RRA +0BB2 TAMIL LETTER LA +0BB3 TAMIL LETTER LLA +0BB4 TAMIL LETTER LLLA +0BB5 TAMIL LETTER VA +0BB7 TAMIL LETTER SSA +0BB8 TAMIL LETTER SA +0BB9 TAMIL LETTER HA +0BBE TAMIL VOWEL SIGN AA +0BBF TAMIL VOWEL SIGN I +0BC0 TAMIL VOWEL SIGN II +0BC1 TAMIL VOWEL SIGN U +0BC2 TAMIL VOWEL SIGN UU +0BC6 TAMIL VOWEL SIGN E +0BC7 TAMIL VOWEL SIGN EE +0BC8 TAMIL VOWEL SIGN AI +0BCA TAMIL VOWEL SIGN O +0BCB TAMIL VOWEL SIGN OO +0BCC TAMIL VOWEL SIGN AU +0BCD TAMIL SIGN VIRAMA +0BD7 TAMIL AU LENGTH MARK +0BE7 TAMIL DIGIT ONE +0BE8 TAMIL DIGIT TWO +0BE9 TAMIL DIGIT THREE +0BEA TAMIL DIGIT FOUR +0BEB TAMIL DIGIT FIVE +0BEC TAMIL DIGIT SIX +0BED TAMIL DIGIT SEVEN +0BEE TAMIL DIGIT EIGHT +0BEF TAMIL DIGIT NINE +0BF0 TAMIL NUMBER TEN +0BF1 TAMIL NUMBER ONE HUNDRED +0BF2 TAMIL NUMBER ONE THOUSAND +0C01 TELUGU SIGN CANDRABINDU +0C02 TELUGU SIGN ANUSVARA +0C03 TELUGU SIGN VISARGA +0C05 TELUGU LETTER A +0C06 TELUGU LETTER AA +0C07 TELUGU LETTER I +0C08 TELUGU LETTER II +0C09 TELUGU LETTER U +0C0A TELUGU LETTER UU +0C0B TELUGU LETTER VOCALIC R +0C0C TELUGU LETTER VOCALIC L +0C0E TELUGU LETTER E +0C0F TELUGU LETTER EE +0C10 TELUGU LETTER AI +0C12 TELUGU LETTER O +0C13 TELUGU LETTER OO +0C14 TELUGU LETTER AU +0C15 TELUGU LETTER KA +0C16 TELUGU LETTER KHA +0C17 TELUGU LETTER GA +0C18 TELUGU LETTER GHA +0C19 TELUGU LETTER NGA +0C1A TELUGU LETTER CA +0C1B TELUGU LETTER CHA +0C1C TELUGU LETTER JA +0C1D TELUGU LETTER JHA +0C1E TELUGU LETTER NYA +0C1F TELUGU LETTER TTA +0C20 TELUGU LETTER TTHA +0C21 TELUGU LETTER DDA +0C22 TELUGU LETTER DDHA +0C23 TELUGU LETTER NNA +0C24 TELUGU LETTER TA +0C25 TELUGU LETTER THA +0C26 TELUGU LETTER DA +0C27 TELUGU LETTER DHA +0C28 TELUGU LETTER NA +0C2A TELUGU LETTER PA +0C2B TELUGU LETTER PHA +0C2C TELUGU LETTER BA +0C2D TELUGU LETTER BHA +0C2E TELUGU LETTER MA +0C2F TELUGU LETTER YA +0C30 TELUGU LETTER RA +0C31 TELUGU LETTER RRA +0C32 TELUGU LETTER LA +0C33 TELUGU LETTER LLA +0C35 TELUGU LETTER VA +0C36 TELUGU LETTER SHA +0C37 TELUGU LETTER SSA +0C38 TELUGU LETTER SA +0C39 TELUGU LETTER HA +0C3E TELUGU VOWEL SIGN AA +0C3F TELUGU VOWEL SIGN I +0C40 TELUGU VOWEL SIGN II +0C41 TELUGU VOWEL SIGN U +0C42 TELUGU VOWEL SIGN UU +0C43 TELUGU VOWEL SIGN VOCALIC R +0C44 TELUGU VOWEL SIGN VOCALIC RR +0C46 TELUGU VOWEL SIGN E +0C47 TELUGU VOWEL SIGN EE +0C48 TELUGU VOWEL SIGN AI +0C4A TELUGU VOWEL SIGN O +0C4B TELUGU VOWEL SIGN OO +0C4C TELUGU VOWEL SIGN AU +0C4D TELUGU SIGN VIRAMA +0C55 TELUGU LENGTH MARK +0C56 TELUGU AI LENGTH MARK +0C60 TELUGU LETTER VOCALIC RR +0C61 TELUGU LETTER VOCALIC LL +0C66 TELUGU DIGIT ZERO +0C67 TELUGU DIGIT ONE +0C68 TELUGU DIGIT TWO +0C69 TELUGU DIGIT THREE +0C6A TELUGU DIGIT FOUR +0C6B TELUGU DIGIT FIVE +0C6C TELUGU DIGIT SIX +0C6D TELUGU DIGIT SEVEN +0C6E TELUGU DIGIT EIGHT +0C6F TELUGU DIGIT NINE +0C82 KANNADA SIGN ANUSVARA +0C83 KANNADA SIGN VISARGA +0C85 KANNADA LETTER A +0C86 KANNADA LETTER AA +0C87 KANNADA LETTER I +0C88 KANNADA LETTER II +0C89 KANNADA LETTER U +0C8A KANNADA LETTER UU +0C8B KANNADA LETTER VOCALIC R +0C8C KANNADA LETTER VOCALIC L +0C8E KANNADA LETTER E +0C8F KANNADA LETTER EE +0C90 KANNADA LETTER AI +0C92 KANNADA LETTER O +0C93 KANNADA LETTER OO +0C94 KANNADA LETTER AU +0C95 KANNADA LETTER KA +0C96 KANNADA LETTER KHA +0C97 KANNADA LETTER GA +0C98 KANNADA LETTER GHA +0C99 KANNADA LETTER NGA +0C9A KANNADA LETTER CA +0C9B KANNADA LETTER CHA +0C9C KANNADA LETTER JA +0C9D KANNADA LETTER JHA +0C9E KANNADA LETTER NYA +0C9F KANNADA LETTER TTA +0CA0 KANNADA LETTER TTHA +0CA1 KANNADA LETTER DDA +0CA2 KANNADA LETTER DDHA +0CA3 KANNADA LETTER NNA +0CA4 KANNADA LETTER TA +0CA5 KANNADA LETTER THA +0CA6 KANNADA LETTER DA +0CA7 KANNADA LETTER DHA +0CA8 KANNADA LETTER NA +0CAA KANNADA LETTER PA +0CAB KANNADA LETTER PHA +0CAC KANNADA LETTER BA +0CAD KANNADA LETTER BHA +0CAE KANNADA LETTER MA +0CAF KANNADA LETTER YA +0CB0 KANNADA LETTER RA +0CB1 KANNADA LETTER RRA +0CB2 KANNADA LETTER LA +0CB3 KANNADA LETTER LLA +0CB5 KANNADA LETTER VA +0CB6 KANNADA LETTER SHA +0CB7 KANNADA LETTER SSA +0CB8 KANNADA LETTER SA +0CB9 KANNADA LETTER HA +0CBE KANNADA VOWEL SIGN AA +0CBF KANNADA VOWEL SIGN I +0CC0 KANNADA VOWEL SIGN II +0CC1 KANNADA VOWEL SIGN U +0CC2 KANNADA VOWEL SIGN UU +0CC3 KANNADA VOWEL SIGN VOCALIC R +0CC4 KANNADA VOWEL SIGN VOCALIC RR +0CC6 KANNADA VOWEL SIGN E +0CC7 KANNADA VOWEL SIGN EE +0CC8 KANNADA VOWEL SIGN AI +0CCA KANNADA VOWEL SIGN O +0CCB KANNADA VOWEL SIGN OO +0CCC KANNADA VOWEL SIGN AU +0CCD KANNADA SIGN VIRAMA +0CD5 KANNADA LENGTH MARK +0CD6 KANNADA AI LENGTH MARK +0CDE KANNADA LETTER FA +0CE0 KANNADA LETTER VOCALIC RR +0CE1 KANNADA LETTER VOCALIC LL +0CE6 KANNADA DIGIT ZERO +0CE7 KANNADA DIGIT ONE +0CE8 KANNADA DIGIT TWO +0CE9 KANNADA DIGIT THREE +0CEA KANNADA DIGIT FOUR +0CEB KANNADA DIGIT FIVE +0CEC KANNADA DIGIT SIX +0CED KANNADA DIGIT SEVEN +0CEE KANNADA DIGIT EIGHT +0CEF KANNADA DIGIT NINE +0D02 MALAYALAM SIGN ANUSVARA +0D03 MALAYALAM SIGN VISARGA +0D05 MALAYALAM LETTER A +0D06 MALAYALAM LETTER AA +0D07 MALAYALAM LETTER I +0D08 MALAYALAM LETTER II +0D09 MALAYALAM LETTER U +0D0A MALAYALAM LETTER UU +0D0B MALAYALAM LETTER VOCALIC R +0D0C MALAYALAM LETTER VOCALIC L +0D0E MALAYALAM LETTER E +0D0F MALAYALAM LETTER EE +0D10 MALAYALAM LETTER AI +0D12 MALAYALAM LETTER O +0D13 MALAYALAM LETTER OO +0D14 MALAYALAM LETTER AU +0D15 MALAYALAM LETTER KA +0D16 MALAYALAM LETTER KHA +0D17 MALAYALAM LETTER GA +0D18 MALAYALAM LETTER GHA +0D19 MALAYALAM LETTER NGA +0D1A MALAYALAM LETTER CA +0D1B MALAYALAM LETTER CHA +0D1C MALAYALAM LETTER JA +0D1D MALAYALAM LETTER JHA +0D1E MALAYALAM LETTER NYA +0D1F MALAYALAM LETTER TTA +0D20 MALAYALAM LETTER TTHA +0D21 MALAYALAM LETTER DDA +0D22 MALAYALAM LETTER DDHA +0D23 MALAYALAM LETTER NNA +0D24 MALAYALAM LETTER TA +0D25 MALAYALAM LETTER THA +0D26 MALAYALAM LETTER DA +0D27 MALAYALAM LETTER DHA +0D28 MALAYALAM LETTER NA +0D2A MALAYALAM LETTER PA +0D2B MALAYALAM LETTER PHA +0D2C MALAYALAM LETTER BA +0D2D MALAYALAM LETTER BHA +0D2E MALAYALAM LETTER MA +0D2F MALAYALAM LETTER YA +0D30 MALAYALAM LETTER RA +0D31 MALAYALAM LETTER RRA +0D32 MALAYALAM LETTER LA +0D33 MALAYALAM LETTER LLA +0D34 MALAYALAM LETTER LLLA +0D35 MALAYALAM LETTER VA +0D36 MALAYALAM LETTER SHA +0D37 MALAYALAM LETTER SSA +0D38 MALAYALAM LETTER SA +0D39 MALAYALAM LETTER HA +0D3E MALAYALAM VOWEL SIGN AA +0D3F MALAYALAM VOWEL SIGN I +0D40 MALAYALAM VOWEL SIGN II +0D41 MALAYALAM VOWEL SIGN U +0D42 MALAYALAM VOWEL SIGN UU +0D43 MALAYALAM VOWEL SIGN VOCALIC R +0D46 MALAYALAM VOWEL SIGN E +0D47 MALAYALAM VOWEL SIGN EE +0D48 MALAYALAM VOWEL SIGN AI +0D4A MALAYALAM VOWEL SIGN O +0D4B MALAYALAM VOWEL SIGN OO +0D4C MALAYALAM VOWEL SIGN AU +0D4D MALAYALAM SIGN VIRAMA +0D57 MALAYALAM AU LENGTH MARK +0D60 MALAYALAM LETTER VOCALIC RR +0D61 MALAYALAM LETTER VOCALIC LL +0D66 MALAYALAM DIGIT ZERO +0D67 MALAYALAM DIGIT ONE +0D68 MALAYALAM DIGIT TWO +0D69 MALAYALAM DIGIT THREE +0D6A MALAYALAM DIGIT FOUR +0D6B MALAYALAM DIGIT FIVE +0D6C MALAYALAM DIGIT SIX +0D6D MALAYALAM DIGIT SEVEN +0D6E MALAYALAM DIGIT EIGHT +0D6F MALAYALAM DIGIT NINE +0D82 SINHALA SIGN ANUSVARAYA +0D83 SINHALA SIGN VISARGAYA +0D85 SINHALA LETTER AYANNA +0D86 SINHALA LETTER AAYANNA +0D87 SINHALA LETTER AEYANNA +0D88 SINHALA LETTER AEEYANNA +0D89 SINHALA LETTER IYANNA +0D8A SINHALA LETTER IIYANNA +0D8B SINHALA LETTER UYANNA +0D8C SINHALA LETTER UUYANNA +0D8D SINHALA LETTER IRUYANNA +0D8E SINHALA LETTER IRUUYANNA +0D8F SINHALA LETTER ILUYANNA +0D90 SINHALA LETTER ILUUYANNA +0D91 SINHALA LETTER EYANNA +0D92 SINHALA LETTER EEYANNA +0D93 SINHALA LETTER AIYANNA +0D94 SINHALA LETTER OYANNA +0D95 SINHALA LETTER OOYANNA +0D96 SINHALA LETTER AUYANNA +0D9A SINHALA LETTER ALPAPRAANA KAYANNA +0D9B SINHALA LETTER MAHAAPRAANA KAYANNA +0D9C SINHALA LETTER ALPAPRAANA GAYANNA +0D9D SINHALA LETTER MAHAAPRAANA GAYANNA +0D9E SINHALA LETTER KANTAJA NAASIKYAYA +0D9F SINHALA LETTER SANYAKA GAYANNA +0DA0 SINHALA LETTER ALPAPRAANA CAYANNA +0DA1 SINHALA LETTER MAHAAPRAANA CAYANNA +0DA2 SINHALA LETTER ALPAPRAANA JAYANNA +0DA3 SINHALA LETTER MAHAAPRAANA JAYANNA +0DA4 SINHALA LETTER TAALUJA NAASIKYAYA +0DA5 SINHALA LETTER TAALUJA SANYOOGA NAAKSIKYAYA +0DA6 SINHALA LETTER SANYAKA JAYANNA +0DA7 SINHALA LETTER ALPAPRAANA TTAYANNA +0DA8 SINHALA LETTER MAHAAPRAANA TTAYANNA +0DA9 SINHALA LETTER ALPAPRAANA DDAYANNA +0DAA SINHALA LETTER MAHAAPRAANA DDAYANNA +0DAB SINHALA LETTER MUURDHAJA NAYANNA +0DAC SINHALA LETTER SANYAKA DDAYANNA +0DAD SINHALA LETTER ALPAPRAANA TAYANNA +0DAE SINHALA LETTER MAHAAPRAANA TAYANNA +0DAF SINHALA LETTER ALPAPRAANA DAYANNA +0DB0 SINHALA LETTER MAHAAPRAANA DAYANNA +0DB1 SINHALA LETTER DANTAJA NAYANNA +0DB3 SINHALA LETTER SANYAKA DAYANNA +0DB4 SINHALA LETTER ALPAPRAANA PAYANNA +0DB5 SINHALA LETTER MAHAAPRAANA PAYANNA +0DB6 SINHALA LETTER ALPAPRAANA BAYANNA +0DB7 SINHALA LETTER MAHAAPRAANA BAYANNA +0DB8 SINHALA LETTER MAYANNA +0DB9 SINHALA LETTER AMBA BAYANNA +0DBA SINHALA LETTER YAYANNA +0DBB SINHALA LETTER RAYANNA +0DBD SINHALA LETTER DANTAJA LAYANNA +0DC0 SINHALA LETTER VAYANNA +0DC1 SINHALA LETTER TAALUJA SAYANNA +0DC2 SINHALA LETTER MUURDHAJA SAYANNA +0DC3 SINHALA LETTER DANTAJA SAYANNA +0DC4 SINHALA LETTER HAYANNA +0DC5 SINHALA LETTER MUURDHAJA LAYANNA +0DC6 SINHALA LETTER FAYANNA +0DCA SINHALA SIGN AL-LAKUNA +0DCF SINHALA VOWEL SIGN AELA-PILLA +0DD0 SINHALA VOWEL SIGN KETTI AEDA-PILLA +0DD1 SINHALA VOWEL SIGN DIGA AEDA-PILLA +0DD2 SINHALA VOWEL SIGN KETTI IS-PILLA +0DD3 SINHALA VOWEL SIGN DIGA IS-PILLA +0DD4 SINHALA VOWEL SIGN KETTI PAA-PILLA +0DD6 SINHALA VOWEL SIGN DIGA PAA-PILLA +0DD8 SINHALA VOWEL SIGN GAETTA-PILLA +0DD9 SINHALA VOWEL SIGN KOMBUVA +0DDA SINHALA VOWEL SIGN DIGA KOMBUVA +0DDB SINHALA VOWEL SIGN KOMBU DEKA +0DDC SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA +0DDD SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA +0DDE SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA +0DDF SINHALA VOWEL SIGN GAYANUKITTA +0DF2 SINHALA VOWEL SIGN DIGA GAETTA-PILLA +0DF3 SINHALA VOWEL SIGN DIGA GAYANUKITTA +0DF4 SINHALA PUNCTUATION KUNDDALIYA +0E01 THAI CHARACTER KO KAI +0E02 THAI CHARACTER KHO KHAI +0E03 THAI CHARACTER KHO KHUAT +0E04 THAI CHARACTER KHO KHWAI +0E05 THAI CHARACTER KHO KHON +0E06 THAI CHARACTER KHO RAKHANG +0E07 THAI CHARACTER NGO NGU +0E08 THAI CHARACTER CHO CHAN +0E09 THAI CHARACTER CHO CHING +0E0A THAI CHARACTER CHO CHANG +0E0B THAI CHARACTER SO SO +0E0C THAI CHARACTER CHO CHOE +0E0D THAI CHARACTER YO YING +0E0E THAI CHARACTER DO CHADA +0E0F THAI CHARACTER TO PATAK +0E10 THAI CHARACTER THO THAN +0E11 THAI CHARACTER THO NANGMONTHO +0E12 THAI CHARACTER THO PHUTHAO +0E13 THAI CHARACTER NO NEN +0E14 THAI CHARACTER DO DEK +0E15 THAI CHARACTER TO TAO +0E16 THAI CHARACTER THO THUNG +0E17 THAI CHARACTER THO THAHAN +0E18 THAI CHARACTER THO THONG +0E19 THAI CHARACTER NO NU +0E1A THAI CHARACTER BO BAIMAI +0E1B THAI CHARACTER PO PLA +0E1C THAI CHARACTER PHO PHUNG +0E1D THAI CHARACTER FO FA +0E1E THAI CHARACTER PHO PHAN +0E1F THAI CHARACTER FO FAN +0E20 THAI CHARACTER PHO SAMPHAO +0E21 THAI CHARACTER MO MA +0E22 THAI CHARACTER YO YAK +0E23 THAI CHARACTER RO RUA +0E24 THAI CHARACTER RU +0E25 THAI CHARACTER LO LING +0E26 THAI CHARACTER LU +0E27 THAI CHARACTER WO WAEN +0E28 THAI CHARACTER SO SALA +0E29 THAI CHARACTER SO RUSI +0E2A THAI CHARACTER SO SUA +0E2B THAI CHARACTER HO HIP +0E2C THAI CHARACTER LO CHULA +0E2D THAI CHARACTER O ANG +0E2E THAI CHARACTER HO NOKHUK +0E2F THAI CHARACTER PAIYANNOI +0E30 THAI CHARACTER SARA A +0E31 THAI CHARACTER MAI HAN-AKAT +0E32 THAI CHARACTER SARA AA +0E33 THAI CHARACTER SARA AM +0E34 THAI CHARACTER SARA I +0E35 THAI CHARACTER SARA II +0E36 THAI CHARACTER SARA UE +0E37 THAI CHARACTER SARA UEE +0E38 THAI CHARACTER SARA U +0E39 THAI CHARACTER SARA UU +0E3A THAI CHARACTER PHINTHU +0E3F THAI CURRENCY SYMBOL BAHT +0E40 THAI CHARACTER SARA E +0E41 THAI CHARACTER SARA AE +0E42 THAI CHARACTER SARA O +0E43 THAI CHARACTER SARA AI MAIMUAN +0E44 THAI CHARACTER SARA AI MAIMALAI +0E45 THAI CHARACTER LAKKHANGYAO +0E46 THAI CHARACTER MAIYAMOK +0E47 THAI CHARACTER MAITAIKHU +0E48 THAI CHARACTER MAI EK +0E49 THAI CHARACTER MAI THO +0E4A THAI CHARACTER MAI TRI +0E4B THAI CHARACTER MAI CHATTAWA +0E4C THAI CHARACTER THANTHAKHAT +0E4D THAI CHARACTER NIKHAHIT +0E4E THAI CHARACTER YAMAKKAN +0E4F THAI CHARACTER FONGMAN +0E50 THAI DIGIT ZERO +0E51 THAI DIGIT ONE +0E52 THAI DIGIT TWO +0E53 THAI DIGIT THREE +0E54 THAI DIGIT FOUR +0E55 THAI DIGIT FIVE +0E56 THAI DIGIT SIX +0E57 THAI DIGIT SEVEN +0E58 THAI DIGIT EIGHT +0E59 THAI DIGIT NINE +0E5A THAI CHARACTER ANGKHANKHU +0E5B THAI CHARACTER KHOMUT +0E81 LAO LETTER KO +0E82 LAO LETTER KHO SUNG +0E84 LAO LETTER KHO TAM +0E87 LAO LETTER NGO +0E88 LAO LETTER CO +0E8A LAO LETTER SO TAM +0E8D LAO LETTER NYO +0E94 LAO LETTER DO +0E95 LAO LETTER TO +0E96 LAO LETTER THO SUNG +0E97 LAO LETTER THO TAM +0E99 LAO LETTER NO +0E9A LAO LETTER BO +0E9B LAO LETTER PO +0E9C LAO LETTER PHO SUNG +0E9D LAO LETTER FO TAM +0E9E LAO LETTER PHO TAM +0E9F LAO LETTER FO SUNG +0EA1 LAO LETTER MO +0EA2 LAO LETTER YO +0EA3 LAO LETTER LO LING +0EA5 LAO LETTER LO LOOT +0EA7 LAO LETTER WO +0EAA LAO LETTER SO SUNG +0EAB LAO LETTER HO SUNG +0EAD LAO LETTER O +0EAE LAO LETTER HO TAM +0EAF LAO ELLIPSIS +0EB0 LAO VOWEL SIGN A +0EB1 LAO VOWEL SIGN MAI KAN +0EB2 LAO VOWEL SIGN AA +0EB3 LAO VOWEL SIGN AM +0EB4 LAO VOWEL SIGN I +0EB5 LAO VOWEL SIGN II +0EB6 LAO VOWEL SIGN Y +0EB7 LAO VOWEL SIGN YY +0EB8 LAO VOWEL SIGN U +0EB9 LAO VOWEL SIGN UU +0EBB LAO VOWEL SIGN MAI KON +0EBC LAO SEMIVOWEL SIGN LO +0EBD LAO SEMIVOWEL SIGN NYO +0EC0 LAO VOWEL SIGN E +0EC1 LAO VOWEL SIGN EI +0EC2 LAO VOWEL SIGN O +0EC3 LAO VOWEL SIGN AY +0EC4 LAO VOWEL SIGN AI +0EC6 LAO KO LA +0EC8 LAO TONE MAI EK +0EC9 LAO TONE MAI THO +0ECA LAO TONE MAI TI +0ECB LAO TONE MAI CATAWA +0ECC LAO CANCELLATION MARK +0ECD LAO NIGGAHITA +0ED0 LAO DIGIT ZERO +0ED1 LAO DIGIT ONE +0ED2 LAO DIGIT TWO +0ED3 LAO DIGIT THREE +0ED4 LAO DIGIT FOUR +0ED5 LAO DIGIT FIVE +0ED6 LAO DIGIT SIX +0ED7 LAO DIGIT SEVEN +0ED8 LAO DIGIT EIGHT +0ED9 LAO DIGIT NINE +0EDC LAO HO NO +0EDD LAO HO MO +0F00 TIBETAN SYLLABLE OM +0F01 TIBETAN MARK GTER YIG MGO TRUNCATED A +0F02 TIBETAN MARK GTER YIG MGO -UM RNAM BCAD MA +0F03 TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA +0F04 TIBETAN MARK INITIAL YIG MGO MDUN MA +0F05 TIBETAN MARK CLOSING YIG MGO SGAB MA +0F06 TIBETAN MARK CARET YIG MGO PHUR SHAD MA +0F07 TIBETAN MARK YIG MGO TSHEG SHAD MA +0F08 TIBETAN MARK SBRUL SHAD +0F09 TIBETAN MARK BSKUR YIG MGO +0F0A TIBETAN MARK BKA- SHOG YIG MGO +0F0B TIBETAN MARK INTERSYLLABIC TSHEG +0F0C TIBETAN MARK DELIMITER TSHEG BSTAR +0F0D TIBETAN MARK SHAD +0F0E TIBETAN MARK NYIS SHAD +0F0F TIBETAN MARK TSHEG SHAD +0F10 TIBETAN MARK NYIS TSHEG SHAD +0F11 TIBETAN MARK RIN CHEN SPUNGS SHAD +0F12 TIBETAN MARK RGYA GRAM SHAD +0F13 TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN +0F14 TIBETAN MARK GTER TSHEG +0F15 TIBETAN LOGOTYPE SIGN CHAD RTAGS +0F16 TIBETAN LOGOTYPE SIGN LHAG RTAGS +0F17 TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS +0F18 TIBETAN ASTROLOGICAL SIGN -KHYUD PA +0F19 TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS +0F1A TIBETAN SIGN RDEL DKAR GCIG +0F1B TIBETAN SIGN RDEL DKAR GNYIS +0F1C TIBETAN SIGN RDEL DKAR GSUM +0F1D TIBETAN SIGN RDEL NAG GCIG +0F1E TIBETAN SIGN RDEL NAG GNYIS +0F1F TIBETAN SIGN RDEL DKAR RDEL NAG +0F20 TIBETAN DIGIT ZERO +0F21 TIBETAN DIGIT ONE +0F22 TIBETAN DIGIT TWO +0F23 TIBETAN DIGIT THREE +0F24 TIBETAN DIGIT FOUR +0F25 TIBETAN DIGIT FIVE +0F26 TIBETAN DIGIT SIX +0F27 TIBETAN DIGIT SEVEN +0F28 TIBETAN DIGIT EIGHT +0F29 TIBETAN DIGIT NINE +0F2A TIBETAN DIGIT HALF ONE +0F2B TIBETAN DIGIT HALF TWO +0F2C TIBETAN DIGIT HALF THREE +0F2D TIBETAN DIGIT HALF FOUR +0F2E TIBETAN DIGIT HALF FIVE +0F2F TIBETAN DIGIT HALF SIX +0F30 TIBETAN DIGIT HALF SEVEN +0F31 TIBETAN DIGIT HALF EIGHT +0F32 TIBETAN DIGIT HALF NINE +0F33 TIBETAN DIGIT HALF ZERO +0F34 TIBETAN MARK BSDUS RTAGS +0F35 TIBETAN MARK NGAS BZUNG NYI ZLA +0F36 TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN +0F37 TIBETAN MARK NGAS BZUNG SGOR RTAGS +0F38 TIBETAN MARK CHE MGO +0F39 TIBETAN MARK TSA -PHRU +0F3A TIBETAN MARK GUG RTAGS GYON +0F3B TIBETAN MARK GUG RTAGS GYAS +0F3C TIBETAN MARK ANG KHANG GYON +0F3D TIBETAN MARK ANG KHANG GYAS +0F3E TIBETAN SIGN YAR TSHES +0F3F TIBETAN SIGN MAR TSHES +0F40 TIBETAN LETTER KA +0F41 TIBETAN LETTER KHA +0F42 TIBETAN LETTER GA +0F43 TIBETAN LETTER GHA +0F44 TIBETAN LETTER NGA +0F45 TIBETAN LETTER CA +0F46 TIBETAN LETTER CHA +0F47 TIBETAN LETTER JA +0F49 TIBETAN LETTER NYA +0F4A TIBETAN LETTER TTA +0F4B TIBETAN LETTER TTHA +0F4C TIBETAN LETTER DDA +0F4D TIBETAN LETTER DDHA +0F4E TIBETAN LETTER NNA +0F4F TIBETAN LETTER TA +0F50 TIBETAN LETTER THA +0F51 TIBETAN LETTER DA +0F52 TIBETAN LETTER DHA +0F53 TIBETAN LETTER NA +0F54 TIBETAN LETTER PA +0F55 TIBETAN LETTER PHA +0F56 TIBETAN LETTER BA +0F57 TIBETAN LETTER BHA +0F58 TIBETAN LETTER MA +0F59 TIBETAN LETTER TSA +0F5A TIBETAN LETTER TSHA +0F5B TIBETAN LETTER DZA +0F5C TIBETAN LETTER DZHA +0F5D TIBETAN LETTER WA +0F5E TIBETAN LETTER ZHA +0F5F TIBETAN LETTER ZA +0F60 TIBETAN LETTER -A +0F61 TIBETAN LETTER YA +0F62 TIBETAN LETTER RA +0F63 TIBETAN LETTER LA +0F64 TIBETAN LETTER SHA +0F65 TIBETAN LETTER SSA +0F66 TIBETAN LETTER SA +0F67 TIBETAN LETTER HA +0F68 TIBETAN LETTER A +0F69 TIBETAN LETTER KSSA +0F6A TIBETAN LETTER FIXED-FORM RA +0F71 TIBETAN VOWEL SIGN AA +0F72 TIBETAN VOWEL SIGN I +0F73 TIBETAN VOWEL SIGN II +0F74 TIBETAN VOWEL SIGN U +0F75 TIBETAN VOWEL SIGN UU +0F76 TIBETAN VOWEL SIGN VOCALIC R +0F77 TIBETAN VOWEL SIGN VOCALIC RR +0F78 TIBETAN VOWEL SIGN VOCALIC L +0F79 TIBETAN VOWEL SIGN VOCALIC LL +0F7A TIBETAN VOWEL SIGN E +0F7B TIBETAN VOWEL SIGN EE +0F7C TIBETAN VOWEL SIGN O +0F7D TIBETAN VOWEL SIGN OO +0F7E TIBETAN SIGN RJES SU NGA RO +0F7F TIBETAN SIGN RNAM BCAD +0F80 TIBETAN VOWEL SIGN REVERSED I +0F81 TIBETAN VOWEL SIGN REVERSED II +0F82 TIBETAN SIGN NYI ZLA NAA DA +0F83 TIBETAN SIGN SNA LDAN +0F84 TIBETAN MARK HALANTA +0F85 TIBETAN MARK PALUTA +0F86 TIBETAN SIGN LCI RTAGS +0F87 TIBETAN SIGN YANG RTAGS +0F88 TIBETAN SIGN LCE TSA CAN +0F89 TIBETAN SIGN MCHU CAN +0F8A TIBETAN SIGN GRU CAN RGYINGS +0F8B TIBETAN SIGN GRU MED RGYINGS +0F90 TIBETAN SUBJOINED LETTER KA +0F91 TIBETAN SUBJOINED LETTER KHA +0F92 TIBETAN SUBJOINED LETTER GA +0F93 TIBETAN SUBJOINED LETTER GHA +0F94 TIBETAN SUBJOINED LETTER NGA +0F95 TIBETAN SUBJOINED LETTER CA +0F96 TIBETAN SUBJOINED LETTER CHA +0F97 TIBETAN SUBJOINED LETTER JA +0F99 TIBETAN SUBJOINED LETTER NYA +0F9A TIBETAN SUBJOINED LETTER TTA +0F9B TIBETAN SUBJOINED LETTER TTHA +0F9C TIBETAN SUBJOINED LETTER DDA +0F9D TIBETAN SUBJOINED LETTER DDHA +0F9E TIBETAN SUBJOINED LETTER NNA +0F9F TIBETAN SUBJOINED LETTER TA +0FA0 TIBETAN SUBJOINED LETTER THA +0FA1 TIBETAN SUBJOINED LETTER DA +0FA2 TIBETAN SUBJOINED LETTER DHA +0FA3 TIBETAN SUBJOINED LETTER NA +0FA4 TIBETAN SUBJOINED LETTER PA +0FA5 TIBETAN SUBJOINED LETTER PHA +0FA6 TIBETAN SUBJOINED LETTER BA +0FA7 TIBETAN SUBJOINED LETTER BHA +0FA8 TIBETAN SUBJOINED LETTER MA +0FA9 TIBETAN SUBJOINED LETTER TSA +0FAA TIBETAN SUBJOINED LETTER TSHA +0FAB TIBETAN SUBJOINED LETTER DZA +0FAC TIBETAN SUBJOINED LETTER DZHA +0FAD TIBETAN SUBJOINED LETTER WA +0FAE TIBETAN SUBJOINED LETTER ZHA +0FAF TIBETAN SUBJOINED LETTER ZA +0FB0 TIBETAN SUBJOINED LETTER -A +0FB1 TIBETAN SUBJOINED LETTER YA +0FB2 TIBETAN SUBJOINED LETTER RA +0FB3 TIBETAN SUBJOINED LETTER LA +0FB4 TIBETAN SUBJOINED LETTER SHA +0FB5 TIBETAN SUBJOINED LETTER SSA +0FB6 TIBETAN SUBJOINED LETTER SA +0FB7 TIBETAN SUBJOINED LETTER HA +0FB8 TIBETAN SUBJOINED LETTER A +0FB9 TIBETAN SUBJOINED LETTER KSSA +0FBA TIBETAN SUBJOINED LETTER FIXED-FORM WA +0FBB TIBETAN SUBJOINED LETTER FIXED-FORM YA +0FBC TIBETAN SUBJOINED LETTER FIXED-FORM RA +0FBE TIBETAN KU RU KHA +0FBF TIBETAN KU RU KHA BZHI MIG CAN +0FC0 TIBETAN CANTILLATION SIGN HEAVY BEAT +0FC1 TIBETAN CANTILLATION SIGN LIGHT BEAT +0FC2 TIBETAN CANTILLATION SIGN CANG TE-U +0FC3 TIBETAN CANTILLATION SIGN SBUB -CHAL +0FC4 TIBETAN SYMBOL DRIL BU +0FC5 TIBETAN SYMBOL RDO RJE +0FC6 TIBETAN SYMBOL PADMA GDAN +0FC7 TIBETAN SYMBOL RDO RJE RGYA GRAM +0FC8 TIBETAN SYMBOL PHUR PA +0FC9 TIBETAN SYMBOL NOR BU +0FCA TIBETAN SYMBOL NOR BU NYIS -KHYIL +0FCB TIBETAN SYMBOL NOR BU GSUM -KHYIL +0FCC TIBETAN SYMBOL NOR BU BZHI -KHYIL +0FCF TIBETAN SIGN RDEL NAG GSUM +1000 MYANMAR LETTER KA +1001 MYANMAR LETTER KHA +1002 MYANMAR LETTER GA +1003 MYANMAR LETTER GHA +1004 MYANMAR LETTER NGA +1005 MYANMAR LETTER CA +1006 MYANMAR LETTER CHA +1007 MYANMAR LETTER JA +1008 MYANMAR LETTER JHA +1009 MYANMAR LETTER NYA +100A MYANMAR LETTER NNYA +100B MYANMAR LETTER TTA +100C MYANMAR LETTER TTHA +100D MYANMAR LETTER DDA +100E MYANMAR LETTER DDHA +100F MYANMAR LETTER NNA +1010 MYANMAR LETTER TA +1011 MYANMAR LETTER THA +1012 MYANMAR LETTER DA +1013 MYANMAR LETTER DHA +1014 MYANMAR LETTER NA +1015 MYANMAR LETTER PA +1016 MYANMAR LETTER PHA +1017 MYANMAR LETTER BA +1018 MYANMAR LETTER BHA +1019 MYANMAR LETTER MA +101A MYANMAR LETTER YA +101B MYANMAR LETTER RA +101C MYANMAR LETTER LA +101D MYANMAR LETTER WA +101E MYANMAR LETTER SA +101F MYANMAR LETTER HA +1020 MYANMAR LETTER LLA +1021 MYANMAR LETTER A +1023 MYANMAR LETTER I +1024 MYANMAR LETTER II +1025 MYANMAR LETTER U +1026 MYANMAR LETTER UU +1027 MYANMAR LETTER E +1029 MYANMAR LETTER O +102A MYANMAR LETTER AU +102C MYANMAR VOWEL SIGN AA +102D MYANMAR VOWEL SIGN I +102E MYANMAR VOWEL SIGN II +102F MYANMAR VOWEL SIGN U +1030 MYANMAR VOWEL SIGN UU +1031 MYANMAR VOWEL SIGN E +1032 MYANMAR VOWEL SIGN AI +1036 MYANMAR SIGN ANUSVARA +1037 MYANMAR SIGN DOT BELOW +1038 MYANMAR SIGN VISARGA +1039 MYANMAR SIGN VIRAMA +1040 MYANMAR DIGIT ZERO +1041 MYANMAR DIGIT ONE +1042 MYANMAR DIGIT TWO +1043 MYANMAR DIGIT THREE +1044 MYANMAR DIGIT FOUR +1045 MYANMAR DIGIT FIVE +1046 MYANMAR DIGIT SIX +1047 MYANMAR DIGIT SEVEN +1048 MYANMAR DIGIT EIGHT +1049 MYANMAR DIGIT NINE +104A MYANMAR SIGN LITTLE SECTION +104B MYANMAR SIGN SECTION +104C MYANMAR SYMBOL LOCATIVE +104D MYANMAR SYMBOL COMPLETED +104E MYANMAR SYMBOL AFOREMENTIONED +104F MYANMAR SYMBOL GENITIVE +1050 MYANMAR LETTER SHA +1051 MYANMAR LETTER SSA +1052 MYANMAR LETTER VOCALIC R +1053 MYANMAR LETTER VOCALIC RR +1054 MYANMAR LETTER VOCALIC L +1055 MYANMAR LETTER VOCALIC LL +1056 MYANMAR VOWEL SIGN VOCALIC R +1057 MYANMAR VOWEL SIGN VOCALIC RR +1058 MYANMAR VOWEL SIGN VOCALIC L +1059 MYANMAR VOWEL SIGN VOCALIC LL +10A0 GEORGIAN CAPITAL LETTER AN +10A1 GEORGIAN CAPITAL LETTER BAN +10A2 GEORGIAN CAPITAL LETTER GAN +10A3 GEORGIAN CAPITAL LETTER DON +10A4 GEORGIAN CAPITAL LETTER EN +10A5 GEORGIAN CAPITAL LETTER VIN +10A6 GEORGIAN CAPITAL LETTER ZEN +10A7 GEORGIAN CAPITAL LETTER TAN +10A8 GEORGIAN CAPITAL LETTER IN +10A9 GEORGIAN CAPITAL LETTER KAN +10AA GEORGIAN CAPITAL LETTER LAS +10AB GEORGIAN CAPITAL LETTER MAN +10AC GEORGIAN CAPITAL LETTER NAR +10AD GEORGIAN CAPITAL LETTER ON +10AE GEORGIAN CAPITAL LETTER PAR +10AF GEORGIAN CAPITAL LETTER ZHAR +10B0 GEORGIAN CAPITAL LETTER RAE +10B1 GEORGIAN CAPITAL LETTER SAN +10B2 GEORGIAN CAPITAL LETTER TAR +10B3 GEORGIAN CAPITAL LETTER UN +10B4 GEORGIAN CAPITAL LETTER PHAR +10B5 GEORGIAN CAPITAL LETTER KHAR +10B6 GEORGIAN CAPITAL LETTER GHAN +10B7 GEORGIAN CAPITAL LETTER QAR +10B8 GEORGIAN CAPITAL LETTER SHIN +10B9 GEORGIAN CAPITAL LETTER CHIN +10BA GEORGIAN CAPITAL LETTER CAN +10BB GEORGIAN CAPITAL LETTER JIL +10BC GEORGIAN CAPITAL LETTER CIL +10BD GEORGIAN CAPITAL LETTER CHAR +10BE GEORGIAN CAPITAL LETTER XAN +10BF GEORGIAN CAPITAL LETTER JHAN +10C0 GEORGIAN CAPITAL LETTER HAE +10C1 GEORGIAN CAPITAL LETTER HE +10C2 GEORGIAN CAPITAL LETTER HIE +10C3 GEORGIAN CAPITAL LETTER WE +10C4 GEORGIAN CAPITAL LETTER HAR +10C5 GEORGIAN CAPITAL LETTER HOE +10D0 GEORGIAN LETTER AN +10D1 GEORGIAN LETTER BAN +10D2 GEORGIAN LETTER GAN +10D3 GEORGIAN LETTER DON +10D4 GEORGIAN LETTER EN +10D5 GEORGIAN LETTER VIN +10D6 GEORGIAN LETTER ZEN +10D7 GEORGIAN LETTER TAN +10D8 GEORGIAN LETTER IN +10D9 GEORGIAN LETTER KAN +10DA GEORGIAN LETTER LAS +10DB GEORGIAN LETTER MAN +10DC GEORGIAN LETTER NAR +10DD GEORGIAN LETTER ON +10DE GEORGIAN LETTER PAR +10DF GEORGIAN LETTER ZHAR +10E0 GEORGIAN LETTER RAE +10E1 GEORGIAN LETTER SAN +10E2 GEORGIAN LETTER TAR +10E3 GEORGIAN LETTER UN +10E4 GEORGIAN LETTER PHAR +10E5 GEORGIAN LETTER KHAR +10E6 GEORGIAN LETTER GHAN +10E7 GEORGIAN LETTER QAR +10E8 GEORGIAN LETTER SHIN +10E9 GEORGIAN LETTER CHIN +10EA GEORGIAN LETTER CAN +10EB GEORGIAN LETTER JIL +10EC GEORGIAN LETTER CIL +10ED GEORGIAN LETTER CHAR +10EE GEORGIAN LETTER XAN +10EF GEORGIAN LETTER JHAN +10F0 GEORGIAN LETTER HAE +10F1 GEORGIAN LETTER HE +10F2 GEORGIAN LETTER HIE +10F3 GEORGIAN LETTER WE +10F4 GEORGIAN LETTER HAR +10F5 GEORGIAN LETTER HOE +10F6 GEORGIAN LETTER FI +10F7 GEORGIAN LETTER YN +10F8 GEORGIAN LETTER ELIFI +10FB GEORGIAN PARAGRAPH SEPARATOR +1100 HANGUL CHOSEONG KIYEOK +1101 HANGUL CHOSEONG SSANGKIYEOK +1102 HANGUL CHOSEONG NIEUN +1103 HANGUL CHOSEONG TIKEUT +1104 HANGUL CHOSEONG SSANGTIKEUT +1105 HANGUL CHOSEONG RIEUL +1106 HANGUL CHOSEONG MIEUM +1107 HANGUL CHOSEONG PIEUP +1108 HANGUL CHOSEONG SSANGPIEUP +1109 HANGUL CHOSEONG SIOS +110A HANGUL CHOSEONG SSANGSIOS +110B HANGUL CHOSEONG IEUNG +110C HANGUL CHOSEONG CIEUC +110D HANGUL CHOSEONG SSANGCIEUC +110E HANGUL CHOSEONG CHIEUCH +110F HANGUL CHOSEONG KHIEUKH +1110 HANGUL CHOSEONG THIEUTH +1111 HANGUL CHOSEONG PHIEUPH +1112 HANGUL CHOSEONG HIEUH +1113 HANGUL CHOSEONG NIEUN-KIYEOK +1114 HANGUL CHOSEONG SSANGNIEUN +1115 HANGUL CHOSEONG NIEUN-TIKEUT +1116 HANGUL CHOSEONG NIEUN-PIEUP +1117 HANGUL CHOSEONG TIKEUT-KIYEOK +1118 HANGUL CHOSEONG RIEUL-NIEUN +1119 HANGUL CHOSEONG SSANGRIEUL +111A HANGUL CHOSEONG RIEUL-HIEUH +111B HANGUL CHOSEONG KAPYEOUNRIEUL +111C HANGUL CHOSEONG MIEUM-PIEUP +111D HANGUL CHOSEONG KAPYEOUNMIEUM +111E HANGUL CHOSEONG PIEUP-KIYEOK +111F HANGUL CHOSEONG PIEUP-NIEUN +1120 HANGUL CHOSEONG PIEUP-TIKEUT +1121 HANGUL CHOSEONG PIEUP-SIOS +1122 HANGUL CHOSEONG PIEUP-SIOS-KIYEOK +1123 HANGUL CHOSEONG PIEUP-SIOS-TIKEUT +1124 HANGUL CHOSEONG PIEUP-SIOS-PIEUP +1125 HANGUL CHOSEONG PIEUP-SSANGSIOS +1126 HANGUL CHOSEONG PIEUP-SIOS-CIEUC +1127 HANGUL CHOSEONG PIEUP-CIEUC +1128 HANGUL CHOSEONG PIEUP-CHIEUCH +1129 HANGUL CHOSEONG PIEUP-THIEUTH +112A HANGUL CHOSEONG PIEUP-PHIEUPH +112B HANGUL CHOSEONG KAPYEOUNPIEUP +112C HANGUL CHOSEONG KAPYEOUNSSANGPIEUP +112D HANGUL CHOSEONG SIOS-KIYEOK +112E HANGUL CHOSEONG SIOS-NIEUN +112F HANGUL CHOSEONG SIOS-TIKEUT +1130 HANGUL CHOSEONG SIOS-RIEUL +1131 HANGUL CHOSEONG SIOS-MIEUM +1132 HANGUL CHOSEONG SIOS-PIEUP +1133 HANGUL CHOSEONG SIOS-PIEUP-KIYEOK +1134 HANGUL CHOSEONG SIOS-SSANGSIOS +1135 HANGUL CHOSEONG SIOS-IEUNG +1136 HANGUL CHOSEONG SIOS-CIEUC +1137 HANGUL CHOSEONG SIOS-CHIEUCH +1138 HANGUL CHOSEONG SIOS-KHIEUKH +1139 HANGUL CHOSEONG SIOS-THIEUTH +113A HANGUL CHOSEONG SIOS-PHIEUPH +113B HANGUL CHOSEONG SIOS-HIEUH +113C HANGUL CHOSEONG CHITUEUMSIOS +113D HANGUL CHOSEONG CHITUEUMSSANGSIOS +113E HANGUL CHOSEONG CEONGCHIEUMSIOS +113F HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS +1140 HANGUL CHOSEONG PANSIOS +1141 HANGUL CHOSEONG IEUNG-KIYEOK +1142 HANGUL CHOSEONG IEUNG-TIKEUT +1143 HANGUL CHOSEONG IEUNG-MIEUM +1144 HANGUL CHOSEONG IEUNG-PIEUP +1145 HANGUL CHOSEONG IEUNG-SIOS +1146 HANGUL CHOSEONG IEUNG-PANSIOS +1147 HANGUL CHOSEONG SSANGIEUNG +1148 HANGUL CHOSEONG IEUNG-CIEUC +1149 HANGUL CHOSEONG IEUNG-CHIEUCH +114A HANGUL CHOSEONG IEUNG-THIEUTH +114B HANGUL CHOSEONG IEUNG-PHIEUPH +114C HANGUL CHOSEONG YESIEUNG +114D HANGUL CHOSEONG CIEUC-IEUNG +114E HANGUL CHOSEONG CHITUEUMCIEUC +114F HANGUL CHOSEONG CHITUEUMSSANGCIEUC +1150 HANGUL CHOSEONG CEONGCHIEUMCIEUC +1151 HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC +1152 HANGUL CHOSEONG CHIEUCH-KHIEUKH +1153 HANGUL CHOSEONG CHIEUCH-HIEUH +1154 HANGUL CHOSEONG CHITUEUMCHIEUCH +1155 HANGUL CHOSEONG CEONGCHIEUMCHIEUCH +1156 HANGUL CHOSEONG PHIEUPH-PIEUP +1157 HANGUL CHOSEONG KAPYEOUNPHIEUPH +1158 HANGUL CHOSEONG SSANGHIEUH +1159 HANGUL CHOSEONG YEORINHIEUH +115F HANGUL CHOSEONG FILLER +1160 HANGUL JUNGSEONG FILLER +1161 HANGUL JUNGSEONG A +1162 HANGUL JUNGSEONG AE +1163 HANGUL JUNGSEONG YA +1164 HANGUL JUNGSEONG YAE +1165 HANGUL JUNGSEONG EO +1166 HANGUL JUNGSEONG E +1167 HANGUL JUNGSEONG YEO +1168 HANGUL JUNGSEONG YE +1169 HANGUL JUNGSEONG O +116A HANGUL JUNGSEONG WA +116B HANGUL JUNGSEONG WAE +116C HANGUL JUNGSEONG OE +116D HANGUL JUNGSEONG YO +116E HANGUL JUNGSEONG U +116F HANGUL JUNGSEONG WEO +1170 HANGUL JUNGSEONG WE +1171 HANGUL JUNGSEONG WI +1172 HANGUL JUNGSEONG YU +1173 HANGUL JUNGSEONG EU +1174 HANGUL JUNGSEONG YI +1175 HANGUL JUNGSEONG I +1176 HANGUL JUNGSEONG A-O +1177 HANGUL JUNGSEONG A-U +1178 HANGUL JUNGSEONG YA-O +1179 HANGUL JUNGSEONG YA-YO +117A HANGUL JUNGSEONG EO-O +117B HANGUL JUNGSEONG EO-U +117C HANGUL JUNGSEONG EO-EU +117D HANGUL JUNGSEONG YEO-O +117E HANGUL JUNGSEONG YEO-U +117F HANGUL JUNGSEONG O-EO +1180 HANGUL JUNGSEONG O-E +1181 HANGUL JUNGSEONG O-YE +1182 HANGUL JUNGSEONG O-O +1183 HANGUL JUNGSEONG O-U +1184 HANGUL JUNGSEONG YO-YA +1185 HANGUL JUNGSEONG YO-YAE +1186 HANGUL JUNGSEONG YO-YEO +1187 HANGUL JUNGSEONG YO-O +1188 HANGUL JUNGSEONG YO-I +1189 HANGUL JUNGSEONG U-A +118A HANGUL JUNGSEONG U-AE +118B HANGUL JUNGSEONG U-EO-EU +118C HANGUL JUNGSEONG U-YE +118D HANGUL JUNGSEONG U-U +118E HANGUL JUNGSEONG YU-A +118F HANGUL JUNGSEONG YU-EO +1190 HANGUL JUNGSEONG YU-E +1191 HANGUL JUNGSEONG YU-YEO +1192 HANGUL JUNGSEONG YU-YE +1193 HANGUL JUNGSEONG YU-U +1194 HANGUL JUNGSEONG YU-I +1195 HANGUL JUNGSEONG EU-U +1196 HANGUL JUNGSEONG EU-EU +1197 HANGUL JUNGSEONG YI-U +1198 HANGUL JUNGSEONG I-A +1199 HANGUL JUNGSEONG I-YA +119A HANGUL JUNGSEONG I-O +119B HANGUL JUNGSEONG I-U +119C HANGUL JUNGSEONG I-EU +119D HANGUL JUNGSEONG I-ARAEA +119E HANGUL JUNGSEONG ARAEA +119F HANGUL JUNGSEONG ARAEA-EO +11A0 HANGUL JUNGSEONG ARAEA-U +11A1 HANGUL JUNGSEONG ARAEA-I +11A2 HANGUL JUNGSEONG SSANGARAEA +11A8 HANGUL JONGSEONG KIYEOK +11A9 HANGUL JONGSEONG SSANGKIYEOK +11AA HANGUL JONGSEONG KIYEOK-SIOS +11AB HANGUL JONGSEONG NIEUN +11AC HANGUL JONGSEONG NIEUN-CIEUC +11AD HANGUL JONGSEONG NIEUN-HIEUH +11AE HANGUL JONGSEONG TIKEUT +11AF HANGUL JONGSEONG RIEUL +11B0 HANGUL JONGSEONG RIEUL-KIYEOK +11B1 HANGUL JONGSEONG RIEUL-MIEUM +11B2 HANGUL JONGSEONG RIEUL-PIEUP +11B3 HANGUL JONGSEONG RIEUL-SIOS +11B4 HANGUL JONGSEONG RIEUL-THIEUTH +11B5 HANGUL JONGSEONG RIEUL-PHIEUPH +11B6 HANGUL JONGSEONG RIEUL-HIEUH +11B7 HANGUL JONGSEONG MIEUM +11B8 HANGUL JONGSEONG PIEUP +11B9 HANGUL JONGSEONG PIEUP-SIOS +11BA HANGUL JONGSEONG SIOS +11BB HANGUL JONGSEONG SSANGSIOS +11BC HANGUL JONGSEONG IEUNG +11BD HANGUL JONGSEONG CIEUC +11BE HANGUL JONGSEONG CHIEUCH +11BF HANGUL JONGSEONG KHIEUKH +11C0 HANGUL JONGSEONG THIEUTH +11C1 HANGUL JONGSEONG PHIEUPH +11C2 HANGUL JONGSEONG HIEUH +11C3 HANGUL JONGSEONG KIYEOK-RIEUL +11C4 HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK +11C5 HANGUL JONGSEONG NIEUN-KIYEOK +11C6 HANGUL JONGSEONG NIEUN-TIKEUT +11C7 HANGUL JONGSEONG NIEUN-SIOS +11C8 HANGUL JONGSEONG NIEUN-PANSIOS +11C9 HANGUL JONGSEONG NIEUN-THIEUTH +11CA HANGUL JONGSEONG TIKEUT-KIYEOK +11CB HANGUL JONGSEONG TIKEUT-RIEUL +11CC HANGUL JONGSEONG RIEUL-KIYEOK-SIOS +11CD HANGUL JONGSEONG RIEUL-NIEUN +11CE HANGUL JONGSEONG RIEUL-TIKEUT +11CF HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH +11D0 HANGUL JONGSEONG SSANGRIEUL +11D1 HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK +11D2 HANGUL JONGSEONG RIEUL-MIEUM-SIOS +11D3 HANGUL JONGSEONG RIEUL-PIEUP-SIOS +11D4 HANGUL JONGSEONG RIEUL-PIEUP-HIEUH +11D5 HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP +11D6 HANGUL JONGSEONG RIEUL-SSANGSIOS +11D7 HANGUL JONGSEONG RIEUL-PANSIOS +11D8 HANGUL JONGSEONG RIEUL-KHIEUKH +11D9 HANGUL JONGSEONG RIEUL-YEORINHIEUH +11DA HANGUL JONGSEONG MIEUM-KIYEOK +11DB HANGUL JONGSEONG MIEUM-RIEUL +11DC HANGUL JONGSEONG MIEUM-PIEUP +11DD HANGUL JONGSEONG MIEUM-SIOS +11DE HANGUL JONGSEONG MIEUM-SSANGSIOS +11DF HANGUL JONGSEONG MIEUM-PANSIOS +11E0 HANGUL JONGSEONG MIEUM-CHIEUCH +11E1 HANGUL JONGSEONG MIEUM-HIEUH +11E2 HANGUL JONGSEONG KAPYEOUNMIEUM +11E3 HANGUL JONGSEONG PIEUP-RIEUL +11E4 HANGUL JONGSEONG PIEUP-PHIEUPH +11E5 HANGUL JONGSEONG PIEUP-HIEUH +11E6 HANGUL JONGSEONG KAPYEOUNPIEUP +11E7 HANGUL JONGSEONG SIOS-KIYEOK +11E8 HANGUL JONGSEONG SIOS-TIKEUT +11E9 HANGUL JONGSEONG SIOS-RIEUL +11EA HANGUL JONGSEONG SIOS-PIEUP +11EB HANGUL JONGSEONG PANSIOS +11EC HANGUL JONGSEONG IEUNG-KIYEOK +11ED HANGUL JONGSEONG IEUNG-SSANGKIYEOK +11EE HANGUL JONGSEONG SSANGIEUNG +11EF HANGUL JONGSEONG IEUNG-KHIEUKH +11F0 HANGUL JONGSEONG YESIEUNG +11F1 HANGUL JONGSEONG YESIEUNG-SIOS +11F2 HANGUL JONGSEONG YESIEUNG-PANSIOS +11F3 HANGUL JONGSEONG PHIEUPH-PIEUP +11F4 HANGUL JONGSEONG KAPYEOUNPHIEUPH +11F5 HANGUL JONGSEONG HIEUH-NIEUN +11F6 HANGUL JONGSEONG HIEUH-RIEUL +11F7 HANGUL JONGSEONG HIEUH-MIEUM +11F8 HANGUL JONGSEONG HIEUH-PIEUP +11F9 HANGUL JONGSEONG YEORINHIEUH +1200 ETHIOPIC SYLLABLE HA +1201 ETHIOPIC SYLLABLE HU +1202 ETHIOPIC SYLLABLE HI +1203 ETHIOPIC SYLLABLE HAA +1204 ETHIOPIC SYLLABLE HEE +1205 ETHIOPIC SYLLABLE HE +1206 ETHIOPIC SYLLABLE HO +1208 ETHIOPIC SYLLABLE LA +1209 ETHIOPIC SYLLABLE LU +120A ETHIOPIC SYLLABLE LI +120B ETHIOPIC SYLLABLE LAA +120C ETHIOPIC SYLLABLE LEE +120D ETHIOPIC SYLLABLE LE +120E ETHIOPIC SYLLABLE LO +120F ETHIOPIC SYLLABLE LWA +1210 ETHIOPIC SYLLABLE HHA +1211 ETHIOPIC SYLLABLE HHU +1212 ETHIOPIC SYLLABLE HHI +1213 ETHIOPIC SYLLABLE HHAA +1214 ETHIOPIC SYLLABLE HHEE +1215 ETHIOPIC SYLLABLE HHE +1216 ETHIOPIC SYLLABLE HHO +1217 ETHIOPIC SYLLABLE HHWA +1218 ETHIOPIC SYLLABLE MA +1219 ETHIOPIC SYLLABLE MU +121A ETHIOPIC SYLLABLE MI +121B ETHIOPIC SYLLABLE MAA +121C ETHIOPIC SYLLABLE MEE +121D ETHIOPIC SYLLABLE ME +121E ETHIOPIC SYLLABLE MO +121F ETHIOPIC SYLLABLE MWA +1220 ETHIOPIC SYLLABLE SZA +1221 ETHIOPIC SYLLABLE SZU +1222 ETHIOPIC SYLLABLE SZI +1223 ETHIOPIC SYLLABLE SZAA +1224 ETHIOPIC SYLLABLE SZEE +1225 ETHIOPIC SYLLABLE SZE +1226 ETHIOPIC SYLLABLE SZO +1227 ETHIOPIC SYLLABLE SZWA +1228 ETHIOPIC SYLLABLE RA +1229 ETHIOPIC SYLLABLE RU +122A ETHIOPIC SYLLABLE RI +122B ETHIOPIC SYLLABLE RAA +122C ETHIOPIC SYLLABLE REE +122D ETHIOPIC SYLLABLE RE +122E ETHIOPIC SYLLABLE RO +122F ETHIOPIC SYLLABLE RWA +1230 ETHIOPIC SYLLABLE SA +1231 ETHIOPIC SYLLABLE SU +1232 ETHIOPIC SYLLABLE SI +1233 ETHIOPIC SYLLABLE SAA +1234 ETHIOPIC SYLLABLE SEE +1235 ETHIOPIC SYLLABLE SE +1236 ETHIOPIC SYLLABLE SO +1237 ETHIOPIC SYLLABLE SWA +1238 ETHIOPIC SYLLABLE SHA +1239 ETHIOPIC SYLLABLE SHU +123A ETHIOPIC SYLLABLE SHI +123B ETHIOPIC SYLLABLE SHAA +123C ETHIOPIC SYLLABLE SHEE +123D ETHIOPIC SYLLABLE SHE +123E ETHIOPIC SYLLABLE SHO +123F ETHIOPIC SYLLABLE SHWA +1240 ETHIOPIC SYLLABLE QA +1241 ETHIOPIC SYLLABLE QU +1242 ETHIOPIC SYLLABLE QI +1243 ETHIOPIC SYLLABLE QAA +1244 ETHIOPIC SYLLABLE QEE +1245 ETHIOPIC SYLLABLE QE +1246 ETHIOPIC SYLLABLE QO +1248 ETHIOPIC SYLLABLE QWA +124A ETHIOPIC SYLLABLE QWI +124B ETHIOPIC SYLLABLE QWAA +124C ETHIOPIC SYLLABLE QWEE +124D ETHIOPIC SYLLABLE QWE +1250 ETHIOPIC SYLLABLE QHA +1251 ETHIOPIC SYLLABLE QHU +1252 ETHIOPIC SYLLABLE QHI +1253 ETHIOPIC SYLLABLE QHAA +1254 ETHIOPIC SYLLABLE QHEE +1255 ETHIOPIC SYLLABLE QHE +1256 ETHIOPIC SYLLABLE QHO +1258 ETHIOPIC SYLLABLE QHWA +125A ETHIOPIC SYLLABLE QHWI +125B ETHIOPIC SYLLABLE QHWAA +125C ETHIOPIC SYLLABLE QHWEE +125D ETHIOPIC SYLLABLE QHWE +1260 ETHIOPIC SYLLABLE BA +1261 ETHIOPIC SYLLABLE BU +1262 ETHIOPIC SYLLABLE BI +1263 ETHIOPIC SYLLABLE BAA +1264 ETHIOPIC SYLLABLE BEE +1265 ETHIOPIC SYLLABLE BE +1266 ETHIOPIC SYLLABLE BO +1267 ETHIOPIC SYLLABLE BWA +1268 ETHIOPIC SYLLABLE VA +1269 ETHIOPIC SYLLABLE VU +126A ETHIOPIC SYLLABLE VI +126B ETHIOPIC SYLLABLE VAA +126C ETHIOPIC SYLLABLE VEE +126D ETHIOPIC SYLLABLE VE +126E ETHIOPIC SYLLABLE VO +126F ETHIOPIC SYLLABLE VWA +1270 ETHIOPIC SYLLABLE TA +1271 ETHIOPIC SYLLABLE TU +1272 ETHIOPIC SYLLABLE TI +1273 ETHIOPIC SYLLABLE TAA +1274 ETHIOPIC SYLLABLE TEE +1275 ETHIOPIC SYLLABLE TE +1276 ETHIOPIC SYLLABLE TO +1277 ETHIOPIC SYLLABLE TWA +1278 ETHIOPIC SYLLABLE CA +1279 ETHIOPIC SYLLABLE CU +127A ETHIOPIC SYLLABLE CI +127B ETHIOPIC SYLLABLE CAA +127C ETHIOPIC SYLLABLE CEE +127D ETHIOPIC SYLLABLE CE +127E ETHIOPIC SYLLABLE CO +127F ETHIOPIC SYLLABLE CWA +1280 ETHIOPIC SYLLABLE XA +1281 ETHIOPIC SYLLABLE XU +1282 ETHIOPIC SYLLABLE XI +1283 ETHIOPIC SYLLABLE XAA +1284 ETHIOPIC SYLLABLE XEE +1285 ETHIOPIC SYLLABLE XE +1286 ETHIOPIC SYLLABLE XO +1288 ETHIOPIC SYLLABLE XWA +128A ETHIOPIC SYLLABLE XWI +128B ETHIOPIC SYLLABLE XWAA +128C ETHIOPIC SYLLABLE XWEE +128D ETHIOPIC SYLLABLE XWE +1290 ETHIOPIC SYLLABLE NA +1291 ETHIOPIC SYLLABLE NU +1292 ETHIOPIC SYLLABLE NI +1293 ETHIOPIC SYLLABLE NAA +1294 ETHIOPIC SYLLABLE NEE +1295 ETHIOPIC SYLLABLE NE +1296 ETHIOPIC SYLLABLE NO +1297 ETHIOPIC SYLLABLE NWA +1298 ETHIOPIC SYLLABLE NYA +1299 ETHIOPIC SYLLABLE NYU +129A ETHIOPIC SYLLABLE NYI +129B ETHIOPIC SYLLABLE NYAA +129C ETHIOPIC SYLLABLE NYEE +129D ETHIOPIC SYLLABLE NYE +129E ETHIOPIC SYLLABLE NYO +129F ETHIOPIC SYLLABLE NYWA +12A0 ETHIOPIC SYLLABLE GLOTTAL A +12A1 ETHIOPIC SYLLABLE GLOTTAL U +12A2 ETHIOPIC SYLLABLE GLOTTAL I +12A3 ETHIOPIC SYLLABLE GLOTTAL AA +12A4 ETHIOPIC SYLLABLE GLOTTAL EE +12A5 ETHIOPIC SYLLABLE GLOTTAL E +12A6 ETHIOPIC SYLLABLE GLOTTAL O +12A7 ETHIOPIC SYLLABLE GLOTTAL WA +12A8 ETHIOPIC SYLLABLE KA +12A9 ETHIOPIC SYLLABLE KU +12AA ETHIOPIC SYLLABLE KI +12AB ETHIOPIC SYLLABLE KAA +12AC ETHIOPIC SYLLABLE KEE +12AD ETHIOPIC SYLLABLE KE +12AE ETHIOPIC SYLLABLE KO +12B0 ETHIOPIC SYLLABLE KWA +12B2 ETHIOPIC SYLLABLE KWI +12B3 ETHIOPIC SYLLABLE KWAA +12B4 ETHIOPIC SYLLABLE KWEE +12B5 ETHIOPIC SYLLABLE KWE +12B8 ETHIOPIC SYLLABLE KXA +12B9 ETHIOPIC SYLLABLE KXU +12BA ETHIOPIC SYLLABLE KXI +12BB ETHIOPIC SYLLABLE KXAA +12BC ETHIOPIC SYLLABLE KXEE +12BD ETHIOPIC SYLLABLE KXE +12BE ETHIOPIC SYLLABLE KXO +12C0 ETHIOPIC SYLLABLE KXWA +12C2 ETHIOPIC SYLLABLE KXWI +12C3 ETHIOPIC SYLLABLE KXWAA +12C4 ETHIOPIC SYLLABLE KXWEE +12C5 ETHIOPIC SYLLABLE KXWE +12C8 ETHIOPIC SYLLABLE WA +12C9 ETHIOPIC SYLLABLE WU +12CA ETHIOPIC SYLLABLE WI +12CB ETHIOPIC SYLLABLE WAA +12CC ETHIOPIC SYLLABLE WEE +12CD ETHIOPIC SYLLABLE WE +12CE ETHIOPIC SYLLABLE WO +12D0 ETHIOPIC SYLLABLE PHARYNGEAL A +12D1 ETHIOPIC SYLLABLE PHARYNGEAL U +12D2 ETHIOPIC SYLLABLE PHARYNGEAL I +12D3 ETHIOPIC SYLLABLE PHARYNGEAL AA +12D4 ETHIOPIC SYLLABLE PHARYNGEAL EE +12D5 ETHIOPIC SYLLABLE PHARYNGEAL E +12D6 ETHIOPIC SYLLABLE PHARYNGEAL O +12D8 ETHIOPIC SYLLABLE ZA +12D9 ETHIOPIC SYLLABLE ZU +12DA ETHIOPIC SYLLABLE ZI +12DB ETHIOPIC SYLLABLE ZAA +12DC ETHIOPIC SYLLABLE ZEE +12DD ETHIOPIC SYLLABLE ZE +12DE ETHIOPIC SYLLABLE ZO +12DF ETHIOPIC SYLLABLE ZWA +12E0 ETHIOPIC SYLLABLE ZHA +12E1 ETHIOPIC SYLLABLE ZHU +12E2 ETHIOPIC SYLLABLE ZHI +12E3 ETHIOPIC SYLLABLE ZHAA +12E4 ETHIOPIC SYLLABLE ZHEE +12E5 ETHIOPIC SYLLABLE ZHE +12E6 ETHIOPIC SYLLABLE ZHO +12E7 ETHIOPIC SYLLABLE ZHWA +12E8 ETHIOPIC SYLLABLE YA +12E9 ETHIOPIC SYLLABLE YU +12EA ETHIOPIC SYLLABLE YI +12EB ETHIOPIC SYLLABLE YAA +12EC ETHIOPIC SYLLABLE YEE +12ED ETHIOPIC SYLLABLE YE +12EE ETHIOPIC SYLLABLE YO +12F0 ETHIOPIC SYLLABLE DA +12F1 ETHIOPIC SYLLABLE DU +12F2 ETHIOPIC SYLLABLE DI +12F3 ETHIOPIC SYLLABLE DAA +12F4 ETHIOPIC SYLLABLE DEE +12F5 ETHIOPIC SYLLABLE DE +12F6 ETHIOPIC SYLLABLE DO +12F7 ETHIOPIC SYLLABLE DWA +12F8 ETHIOPIC SYLLABLE DDA +12F9 ETHIOPIC SYLLABLE DDU +12FA ETHIOPIC SYLLABLE DDI +12FB ETHIOPIC SYLLABLE DDAA +12FC ETHIOPIC SYLLABLE DDEE +12FD ETHIOPIC SYLLABLE DDE +12FE ETHIOPIC SYLLABLE DDO +12FF ETHIOPIC SYLLABLE DDWA +1300 ETHIOPIC SYLLABLE JA +1301 ETHIOPIC SYLLABLE JU +1302 ETHIOPIC SYLLABLE JI +1303 ETHIOPIC SYLLABLE JAA +1304 ETHIOPIC SYLLABLE JEE +1305 ETHIOPIC SYLLABLE JE +1306 ETHIOPIC SYLLABLE JO +1307 ETHIOPIC SYLLABLE JWA +1308 ETHIOPIC SYLLABLE GA +1309 ETHIOPIC SYLLABLE GU +130A ETHIOPIC SYLLABLE GI +130B ETHIOPIC SYLLABLE GAA +130C ETHIOPIC SYLLABLE GEE +130D ETHIOPIC SYLLABLE GE +130E ETHIOPIC SYLLABLE GO +1310 ETHIOPIC SYLLABLE GWA +1312 ETHIOPIC SYLLABLE GWI +1313 ETHIOPIC SYLLABLE GWAA +1314 ETHIOPIC SYLLABLE GWEE +1315 ETHIOPIC SYLLABLE GWE +1318 ETHIOPIC SYLLABLE GGA +1319 ETHIOPIC SYLLABLE GGU +131A ETHIOPIC SYLLABLE GGI +131B ETHIOPIC SYLLABLE GGAA +131C ETHIOPIC SYLLABLE GGEE +131D ETHIOPIC SYLLABLE GGE +131E ETHIOPIC SYLLABLE GGO +1320 ETHIOPIC SYLLABLE THA +1321 ETHIOPIC SYLLABLE THU +1322 ETHIOPIC SYLLABLE THI +1323 ETHIOPIC SYLLABLE THAA +1324 ETHIOPIC SYLLABLE THEE +1325 ETHIOPIC SYLLABLE THE +1326 ETHIOPIC SYLLABLE THO +1327 ETHIOPIC SYLLABLE THWA +1328 ETHIOPIC SYLLABLE CHA +1329 ETHIOPIC SYLLABLE CHU +132A ETHIOPIC SYLLABLE CHI +132B ETHIOPIC SYLLABLE CHAA +132C ETHIOPIC SYLLABLE CHEE +132D ETHIOPIC SYLLABLE CHE +132E ETHIOPIC SYLLABLE CHO +132F ETHIOPIC SYLLABLE CHWA +1330 ETHIOPIC SYLLABLE PHA +1331 ETHIOPIC SYLLABLE PHU +1332 ETHIOPIC SYLLABLE PHI +1333 ETHIOPIC SYLLABLE PHAA +1334 ETHIOPIC SYLLABLE PHEE +1335 ETHIOPIC SYLLABLE PHE +1336 ETHIOPIC SYLLABLE PHO +1337 ETHIOPIC SYLLABLE PHWA +1338 ETHIOPIC SYLLABLE TSA +1339 ETHIOPIC SYLLABLE TSU +133A ETHIOPIC SYLLABLE TSI +133B ETHIOPIC SYLLABLE TSAA +133C ETHIOPIC SYLLABLE TSEE +133D ETHIOPIC SYLLABLE TSE +133E ETHIOPIC SYLLABLE TSO +133F ETHIOPIC SYLLABLE TSWA +1340 ETHIOPIC SYLLABLE TZA +1341 ETHIOPIC SYLLABLE TZU +1342 ETHIOPIC SYLLABLE TZI +1343 ETHIOPIC SYLLABLE TZAA +1344 ETHIOPIC SYLLABLE TZEE +1345 ETHIOPIC SYLLABLE TZE +1346 ETHIOPIC SYLLABLE TZO +1348 ETHIOPIC SYLLABLE FA +1349 ETHIOPIC SYLLABLE FU +134A ETHIOPIC SYLLABLE FI +134B ETHIOPIC SYLLABLE FAA +134C ETHIOPIC SYLLABLE FEE +134D ETHIOPIC SYLLABLE FE +134E ETHIOPIC SYLLABLE FO +134F ETHIOPIC SYLLABLE FWA +1350 ETHIOPIC SYLLABLE PA +1351 ETHIOPIC SYLLABLE PU +1352 ETHIOPIC SYLLABLE PI +1353 ETHIOPIC SYLLABLE PAA +1354 ETHIOPIC SYLLABLE PEE +1355 ETHIOPIC SYLLABLE PE +1356 ETHIOPIC SYLLABLE PO +1357 ETHIOPIC SYLLABLE PWA +1358 ETHIOPIC SYLLABLE RYA +1359 ETHIOPIC SYLLABLE MYA +135A ETHIOPIC SYLLABLE FYA +1361 ETHIOPIC WORDSPACE +1362 ETHIOPIC FULL STOP +1363 ETHIOPIC COMMA +1364 ETHIOPIC SEMICOLON +1365 ETHIOPIC COLON +1366 ETHIOPIC PREFACE COLON +1367 ETHIOPIC QUESTION MARK +1368 ETHIOPIC PARAGRAPH SEPARATOR +1369 ETHIOPIC DIGIT ONE +136A ETHIOPIC DIGIT TWO +136B ETHIOPIC DIGIT THREE +136C ETHIOPIC DIGIT FOUR +136D ETHIOPIC DIGIT FIVE +136E ETHIOPIC DIGIT SIX +136F ETHIOPIC DIGIT SEVEN +1370 ETHIOPIC DIGIT EIGHT +1371 ETHIOPIC DIGIT NINE +1372 ETHIOPIC NUMBER TEN +1373 ETHIOPIC NUMBER TWENTY +1374 ETHIOPIC NUMBER THIRTY +1375 ETHIOPIC NUMBER FORTY +1376 ETHIOPIC NUMBER FIFTY +1377 ETHIOPIC NUMBER SIXTY +1378 ETHIOPIC NUMBER SEVENTY +1379 ETHIOPIC NUMBER EIGHTY +137A ETHIOPIC NUMBER NINETY +137B ETHIOPIC NUMBER HUNDRED +137C ETHIOPIC NUMBER TEN THOUSAND +13A0 CHEROKEE LETTER A +13A1 CHEROKEE LETTER E +13A2 CHEROKEE LETTER I +13A3 CHEROKEE LETTER O +13A4 CHEROKEE LETTER U +13A5 CHEROKEE LETTER V +13A6 CHEROKEE LETTER GA +13A7 CHEROKEE LETTER KA +13A8 CHEROKEE LETTER GE +13A9 CHEROKEE LETTER GI +13AA CHEROKEE LETTER GO +13AB CHEROKEE LETTER GU +13AC CHEROKEE LETTER GV +13AD CHEROKEE LETTER HA +13AE CHEROKEE LETTER HE +13AF CHEROKEE LETTER HI +13B0 CHEROKEE LETTER HO +13B1 CHEROKEE LETTER HU +13B2 CHEROKEE LETTER HV +13B3 CHEROKEE LETTER LA +13B4 CHEROKEE LETTER LE +13B5 CHEROKEE LETTER LI +13B6 CHEROKEE LETTER LO +13B7 CHEROKEE LETTER LU +13B8 CHEROKEE LETTER LV +13B9 CHEROKEE LETTER MA +13BA CHEROKEE LETTER ME +13BB CHEROKEE LETTER MI +13BC CHEROKEE LETTER MO +13BD CHEROKEE LETTER MU +13BE CHEROKEE LETTER NA +13BF CHEROKEE LETTER HNA +13C0 CHEROKEE LETTER NAH +13C1 CHEROKEE LETTER NE +13C2 CHEROKEE LETTER NI +13C3 CHEROKEE LETTER NO +13C4 CHEROKEE LETTER NU +13C5 CHEROKEE LETTER NV +13C6 CHEROKEE LETTER QUA +13C7 CHEROKEE LETTER QUE +13C8 CHEROKEE LETTER QUI +13C9 CHEROKEE LETTER QUO +13CA CHEROKEE LETTER QUU +13CB CHEROKEE LETTER QUV +13CC CHEROKEE LETTER SA +13CD CHEROKEE LETTER S +13CE CHEROKEE LETTER SE +13CF CHEROKEE LETTER SI +13D0 CHEROKEE LETTER SO +13D1 CHEROKEE LETTER SU +13D2 CHEROKEE LETTER SV +13D3 CHEROKEE LETTER DA +13D4 CHEROKEE LETTER TA +13D5 CHEROKEE LETTER DE +13D6 CHEROKEE LETTER TE +13D7 CHEROKEE LETTER DI +13D8 CHEROKEE LETTER TI +13D9 CHEROKEE LETTER DO +13DA CHEROKEE LETTER DU +13DB CHEROKEE LETTER DV +13DC CHEROKEE LETTER DLA +13DD CHEROKEE LETTER TLA +13DE CHEROKEE LETTER TLE +13DF CHEROKEE LETTER TLI +13E0 CHEROKEE LETTER TLO +13E1 CHEROKEE LETTER TLU +13E2 CHEROKEE LETTER TLV +13E3 CHEROKEE LETTER TSA +13E4 CHEROKEE LETTER TSE +13E5 CHEROKEE LETTER TSI +13E6 CHEROKEE LETTER TSO +13E7 CHEROKEE LETTER TSU +13E8 CHEROKEE LETTER TSV +13E9 CHEROKEE LETTER WA +13EA CHEROKEE LETTER WE +13EB CHEROKEE LETTER WI +13EC CHEROKEE LETTER WO +13ED CHEROKEE LETTER WU +13EE CHEROKEE LETTER WV +13EF CHEROKEE LETTER YA +13F0 CHEROKEE LETTER YE +13F1 CHEROKEE LETTER YI +13F2 CHEROKEE LETTER YO +13F3 CHEROKEE LETTER YU +13F4 CHEROKEE LETTER YV +1401 CANADIAN SYLLABICS E +1402 CANADIAN SYLLABICS AAI +1403 CANADIAN SYLLABICS I +1404 CANADIAN SYLLABICS II +1405 CANADIAN SYLLABICS O +1406 CANADIAN SYLLABICS OO +1407 CANADIAN SYLLABICS Y-CREE OO +1408 CANADIAN SYLLABICS CARRIER EE +1409 CANADIAN SYLLABICS CARRIER I +140A CANADIAN SYLLABICS A +140B CANADIAN SYLLABICS AA +140C CANADIAN SYLLABICS WE +140D CANADIAN SYLLABICS WEST-CREE WE +140E CANADIAN SYLLABICS WI +140F CANADIAN SYLLABICS WEST-CREE WI +1410 CANADIAN SYLLABICS WII +1411 CANADIAN SYLLABICS WEST-CREE WII +1412 CANADIAN SYLLABICS WO +1413 CANADIAN SYLLABICS WEST-CREE WO +1414 CANADIAN SYLLABICS WOO +1415 CANADIAN SYLLABICS WEST-CREE WOO +1416 CANADIAN SYLLABICS NASKAPI WOO +1417 CANADIAN SYLLABICS WA +1418 CANADIAN SYLLABICS WEST-CREE WA +1419 CANADIAN SYLLABICS WAA +141A CANADIAN SYLLABICS WEST-CREE WAA +141B CANADIAN SYLLABICS NASKAPI WAA +141C CANADIAN SYLLABICS AI +141D CANADIAN SYLLABICS Y-CREE W +141E CANADIAN SYLLABICS GLOTTAL STOP +141F CANADIAN SYLLABICS FINAL ACUTE +1420 CANADIAN SYLLABICS FINAL GRAVE +1421 CANADIAN SYLLABICS FINAL BOTTOM HALF RING +1422 CANADIAN SYLLABICS FINAL TOP HALF RING +1423 CANADIAN SYLLABICS FINAL RIGHT HALF RING +1424 CANADIAN SYLLABICS FINAL RING +1425 CANADIAN SYLLABICS FINAL DOUBLE ACUTE +1426 CANADIAN SYLLABICS FINAL DOUBLE SHORT VERTICAL STROKES +1427 CANADIAN SYLLABICS FINAL MIDDLE DOT +1428 CANADIAN SYLLABICS FINAL SHORT HORIZONTAL STROKE +1429 CANADIAN SYLLABICS FINAL PLUS +142A CANADIAN SYLLABICS FINAL DOWN TACK +142B CANADIAN SYLLABICS EN +142C CANADIAN SYLLABICS IN +142D CANADIAN SYLLABICS ON +142E CANADIAN SYLLABICS AN +142F CANADIAN SYLLABICS PE +1430 CANADIAN SYLLABICS PAAI +1431 CANADIAN SYLLABICS PI +1432 CANADIAN SYLLABICS PII +1433 CANADIAN SYLLABICS PO +1434 CANADIAN SYLLABICS POO +1435 CANADIAN SYLLABICS Y-CREE POO +1436 CANADIAN SYLLABICS CARRIER HEE +1437 CANADIAN SYLLABICS CARRIER HI +1438 CANADIAN SYLLABICS PA +1439 CANADIAN SYLLABICS PAA +143A CANADIAN SYLLABICS PWE +143B CANADIAN SYLLABICS WEST-CREE PWE +143C CANADIAN SYLLABICS PWI +143D CANADIAN SYLLABICS WEST-CREE PWI +143E CANADIAN SYLLABICS PWII +143F CANADIAN SYLLABICS WEST-CREE PWII +1440 CANADIAN SYLLABICS PWO +1441 CANADIAN SYLLABICS WEST-CREE PWO +1442 CANADIAN SYLLABICS PWOO +1443 CANADIAN SYLLABICS WEST-CREE PWOO +1444 CANADIAN SYLLABICS PWA +1445 CANADIAN SYLLABICS WEST-CREE PWA +1446 CANADIAN SYLLABICS PWAA +1447 CANADIAN SYLLABICS WEST-CREE PWAA +1448 CANADIAN SYLLABICS Y-CREE PWAA +1449 CANADIAN SYLLABICS P +144A CANADIAN SYLLABICS WEST-CREE P +144B CANADIAN SYLLABICS CARRIER H +144C CANADIAN SYLLABICS TE +144D CANADIAN SYLLABICS TAAI +144E CANADIAN SYLLABICS TI +144F CANADIAN SYLLABICS TII +1450 CANADIAN SYLLABICS TO +1451 CANADIAN SYLLABICS TOO +1452 CANADIAN SYLLABICS Y-CREE TOO +1453 CANADIAN SYLLABICS CARRIER DEE +1454 CANADIAN SYLLABICS CARRIER DI +1455 CANADIAN SYLLABICS TA +1456 CANADIAN SYLLABICS TAA +1457 CANADIAN SYLLABICS TWE +1458 CANADIAN SYLLABICS WEST-CREE TWE +1459 CANADIAN SYLLABICS TWI +145A CANADIAN SYLLABICS WEST-CREE TWI +145B CANADIAN SYLLABICS TWII +145C CANADIAN SYLLABICS WEST-CREE TWII +145D CANADIAN SYLLABICS TWO +145E CANADIAN SYLLABICS WEST-CREE TWO +145F CANADIAN SYLLABICS TWOO +1460 CANADIAN SYLLABICS WEST-CREE TWOO +1461 CANADIAN SYLLABICS TWA +1462 CANADIAN SYLLABICS WEST-CREE TWA +1463 CANADIAN SYLLABICS TWAA +1464 CANADIAN SYLLABICS WEST-CREE TWAA +1465 CANADIAN SYLLABICS NASKAPI TWAA +1466 CANADIAN SYLLABICS T +1467 CANADIAN SYLLABICS TTE +1468 CANADIAN SYLLABICS TTI +1469 CANADIAN SYLLABICS TTO +146A CANADIAN SYLLABICS TTA +146B CANADIAN SYLLABICS KE +146C CANADIAN SYLLABICS KAAI +146D CANADIAN SYLLABICS KI +146E CANADIAN SYLLABICS KII +146F CANADIAN SYLLABICS KO +1470 CANADIAN SYLLABICS KOO +1471 CANADIAN SYLLABICS Y-CREE KOO +1472 CANADIAN SYLLABICS KA +1473 CANADIAN SYLLABICS KAA +1474 CANADIAN SYLLABICS KWE +1475 CANADIAN SYLLABICS WEST-CREE KWE +1476 CANADIAN SYLLABICS KWI +1477 CANADIAN SYLLABICS WEST-CREE KWI +1478 CANADIAN SYLLABICS KWII +1479 CANADIAN SYLLABICS WEST-CREE KWII +147A CANADIAN SYLLABICS KWO +147B CANADIAN SYLLABICS WEST-CREE KWO +147C CANADIAN SYLLABICS KWOO +147D CANADIAN SYLLABICS WEST-CREE KWOO +147E CANADIAN SYLLABICS KWA +147F CANADIAN SYLLABICS WEST-CREE KWA +1480 CANADIAN SYLLABICS KWAA +1481 CANADIAN SYLLABICS WEST-CREE KWAA +1482 CANADIAN SYLLABICS NASKAPI KWAA +1483 CANADIAN SYLLABICS K +1484 CANADIAN SYLLABICS KW +1485 CANADIAN SYLLABICS SOUTH-SLAVEY KEH +1486 CANADIAN SYLLABICS SOUTH-SLAVEY KIH +1487 CANADIAN SYLLABICS SOUTH-SLAVEY KOH +1488 CANADIAN SYLLABICS SOUTH-SLAVEY KAH +1489 CANADIAN SYLLABICS CE +148A CANADIAN SYLLABICS CAAI +148B CANADIAN SYLLABICS CI +148C CANADIAN SYLLABICS CII +148D CANADIAN SYLLABICS CO +148E CANADIAN SYLLABICS COO +148F CANADIAN SYLLABICS Y-CREE COO +1490 CANADIAN SYLLABICS CA +1491 CANADIAN SYLLABICS CAA +1492 CANADIAN SYLLABICS CWE +1493 CANADIAN SYLLABICS WEST-CREE CWE +1494 CANADIAN SYLLABICS CWI +1495 CANADIAN SYLLABICS WEST-CREE CWI +1496 CANADIAN SYLLABICS CWII +1497 CANADIAN SYLLABICS WEST-CREE CWII +1498 CANADIAN SYLLABICS CWO +1499 CANADIAN SYLLABICS WEST-CREE CWO +149A CANADIAN SYLLABICS CWOO +149B CANADIAN SYLLABICS WEST-CREE CWOO +149C CANADIAN SYLLABICS CWA +149D CANADIAN SYLLABICS WEST-CREE CWA +149E CANADIAN SYLLABICS CWAA +149F CANADIAN SYLLABICS WEST-CREE CWAA +14A0 CANADIAN SYLLABICS NASKAPI CWAA +14A1 CANADIAN SYLLABICS C +14A2 CANADIAN SYLLABICS SAYISI TH +14A3 CANADIAN SYLLABICS ME +14A4 CANADIAN SYLLABICS MAAI +14A5 CANADIAN SYLLABICS MI +14A6 CANADIAN SYLLABICS MII +14A7 CANADIAN SYLLABICS MO +14A8 CANADIAN SYLLABICS MOO +14A9 CANADIAN SYLLABICS Y-CREE MOO +14AA CANADIAN SYLLABICS MA +14AB CANADIAN SYLLABICS MAA +14AC CANADIAN SYLLABICS MWE +14AD CANADIAN SYLLABICS WEST-CREE MWE +14AE CANADIAN SYLLABICS MWI +14AF CANADIAN SYLLABICS WEST-CREE MWI +14B0 CANADIAN SYLLABICS MWII +14B1 CANADIAN SYLLABICS WEST-CREE MWII +14B2 CANADIAN SYLLABICS MWO +14B3 CANADIAN SYLLABICS WEST-CREE MWO +14B4 CANADIAN SYLLABICS MWOO +14B5 CANADIAN SYLLABICS WEST-CREE MWOO +14B6 CANADIAN SYLLABICS MWA +14B7 CANADIAN SYLLABICS WEST-CREE MWA +14B8 CANADIAN SYLLABICS MWAA +14B9 CANADIAN SYLLABICS WEST-CREE MWAA +14BA CANADIAN SYLLABICS NASKAPI MWAA +14BB CANADIAN SYLLABICS M +14BC CANADIAN SYLLABICS WEST-CREE M +14BD CANADIAN SYLLABICS MH +14BE CANADIAN SYLLABICS ATHAPASCAN M +14BF CANADIAN SYLLABICS SAYISI M +14C0 CANADIAN SYLLABICS NE +14C1 CANADIAN SYLLABICS NAAI +14C2 CANADIAN SYLLABICS NI +14C3 CANADIAN SYLLABICS NII +14C4 CANADIAN SYLLABICS NO +14C5 CANADIAN SYLLABICS NOO +14C6 CANADIAN SYLLABICS Y-CREE NOO +14C7 CANADIAN SYLLABICS NA +14C8 CANADIAN SYLLABICS NAA +14C9 CANADIAN SYLLABICS NWE +14CA CANADIAN SYLLABICS WEST-CREE NWE +14CB CANADIAN SYLLABICS NWA +14CC CANADIAN SYLLABICS WEST-CREE NWA +14CD CANADIAN SYLLABICS NWAA +14CE CANADIAN SYLLABICS WEST-CREE NWAA +14CF CANADIAN SYLLABICS NASKAPI NWAA +14D0 CANADIAN SYLLABICS N +14D1 CANADIAN SYLLABICS CARRIER NG +14D2 CANADIAN SYLLABICS NH +14D3 CANADIAN SYLLABICS LE +14D4 CANADIAN SYLLABICS LAAI +14D5 CANADIAN SYLLABICS LI +14D6 CANADIAN SYLLABICS LII +14D7 CANADIAN SYLLABICS LO +14D8 CANADIAN SYLLABICS LOO +14D9 CANADIAN SYLLABICS Y-CREE LOO +14DA CANADIAN SYLLABICS LA +14DB CANADIAN SYLLABICS LAA +14DC CANADIAN SYLLABICS LWE +14DD CANADIAN SYLLABICS WEST-CREE LWE +14DE CANADIAN SYLLABICS LWI +14DF CANADIAN SYLLABICS WEST-CREE LWI +14E0 CANADIAN SYLLABICS LWII +14E1 CANADIAN SYLLABICS WEST-CREE LWII +14E2 CANADIAN SYLLABICS LWO +14E3 CANADIAN SYLLABICS WEST-CREE LWO +14E4 CANADIAN SYLLABICS LWOO +14E5 CANADIAN SYLLABICS WEST-CREE LWOO +14E6 CANADIAN SYLLABICS LWA +14E7 CANADIAN SYLLABICS WEST-CREE LWA +14E8 CANADIAN SYLLABICS LWAA +14E9 CANADIAN SYLLABICS WEST-CREE LWAA +14EA CANADIAN SYLLABICS L +14EB CANADIAN SYLLABICS WEST-CREE L +14EC CANADIAN SYLLABICS MEDIAL L +14ED CANADIAN SYLLABICS SE +14EE CANADIAN SYLLABICS SAAI +14EF CANADIAN SYLLABICS SI +14F0 CANADIAN SYLLABICS SII +14F1 CANADIAN SYLLABICS SO +14F2 CANADIAN SYLLABICS SOO +14F3 CANADIAN SYLLABICS Y-CREE SOO +14F4 CANADIAN SYLLABICS SA +14F5 CANADIAN SYLLABICS SAA +14F6 CANADIAN SYLLABICS SWE +14F7 CANADIAN SYLLABICS WEST-CREE SWE +14F8 CANADIAN SYLLABICS SWI +14F9 CANADIAN SYLLABICS WEST-CREE SWI +14FA CANADIAN SYLLABICS SWII +14FB CANADIAN SYLLABICS WEST-CREE SWII +14FC CANADIAN SYLLABICS SWO +14FD CANADIAN SYLLABICS WEST-CREE SWO +14FE CANADIAN SYLLABICS SWOO +14FF CANADIAN SYLLABICS WEST-CREE SWOO +1500 CANADIAN SYLLABICS SWA +1501 CANADIAN SYLLABICS WEST-CREE SWA +1502 CANADIAN SYLLABICS SWAA +1503 CANADIAN SYLLABICS WEST-CREE SWAA +1504 CANADIAN SYLLABICS NASKAPI SWAA +1505 CANADIAN SYLLABICS S +1506 CANADIAN SYLLABICS ATHAPASCAN S +1507 CANADIAN SYLLABICS SW +1508 CANADIAN SYLLABICS BLACKFOOT S +1509 CANADIAN SYLLABICS MOOSE-CREE SK +150A CANADIAN SYLLABICS NASKAPI SKW +150B CANADIAN SYLLABICS NASKAPI S-W +150C CANADIAN SYLLABICS NASKAPI SPWA +150D CANADIAN SYLLABICS NASKAPI STWA +150E CANADIAN SYLLABICS NASKAPI SKWA +150F CANADIAN SYLLABICS NASKAPI SCWA +1510 CANADIAN SYLLABICS SHE +1511 CANADIAN SYLLABICS SHI +1512 CANADIAN SYLLABICS SHII +1513 CANADIAN SYLLABICS SHO +1514 CANADIAN SYLLABICS SHOO +1515 CANADIAN SYLLABICS SHA +1516 CANADIAN SYLLABICS SHAA +1517 CANADIAN SYLLABICS SHWE +1518 CANADIAN SYLLABICS WEST-CREE SHWE +1519 CANADIAN SYLLABICS SHWI +151A CANADIAN SYLLABICS WEST-CREE SHWI +151B CANADIAN SYLLABICS SHWII +151C CANADIAN SYLLABICS WEST-CREE SHWII +151D CANADIAN SYLLABICS SHWO +151E CANADIAN SYLLABICS WEST-CREE SHWO +151F CANADIAN SYLLABICS SHWOO +1520 CANADIAN SYLLABICS WEST-CREE SHWOO +1521 CANADIAN SYLLABICS SHWA +1522 CANADIAN SYLLABICS WEST-CREE SHWA +1523 CANADIAN SYLLABICS SHWAA +1524 CANADIAN SYLLABICS WEST-CREE SHWAA +1525 CANADIAN SYLLABICS SH +1526 CANADIAN SYLLABICS YE +1527 CANADIAN SYLLABICS YAAI +1528 CANADIAN SYLLABICS YI +1529 CANADIAN SYLLABICS YII +152A CANADIAN SYLLABICS YO +152B CANADIAN SYLLABICS YOO +152C CANADIAN SYLLABICS Y-CREE YOO +152D CANADIAN SYLLABICS YA +152E CANADIAN SYLLABICS YAA +152F CANADIAN SYLLABICS YWE +1530 CANADIAN SYLLABICS WEST-CREE YWE +1531 CANADIAN SYLLABICS YWI +1532 CANADIAN SYLLABICS WEST-CREE YWI +1533 CANADIAN SYLLABICS YWII +1534 CANADIAN SYLLABICS WEST-CREE YWII +1535 CANADIAN SYLLABICS YWO +1536 CANADIAN SYLLABICS WEST-CREE YWO +1537 CANADIAN SYLLABICS YWOO +1538 CANADIAN SYLLABICS WEST-CREE YWOO +1539 CANADIAN SYLLABICS YWA +153A CANADIAN SYLLABICS WEST-CREE YWA +153B CANADIAN SYLLABICS YWAA +153C CANADIAN SYLLABICS WEST-CREE YWAA +153D CANADIAN SYLLABICS NASKAPI YWAA +153E CANADIAN SYLLABICS Y +153F CANADIAN SYLLABICS BIBLE-CREE Y +1540 CANADIAN SYLLABICS WEST-CREE Y +1541 CANADIAN SYLLABICS SAYISI YI +1542 CANADIAN SYLLABICS RE +1543 CANADIAN SYLLABICS R-CREE RE +1544 CANADIAN SYLLABICS WEST-CREE LE +1545 CANADIAN SYLLABICS RAAI +1546 CANADIAN SYLLABICS RI +1547 CANADIAN SYLLABICS RII +1548 CANADIAN SYLLABICS RO +1549 CANADIAN SYLLABICS ROO +154A CANADIAN SYLLABICS WEST-CREE LO +154B CANADIAN SYLLABICS RA +154C CANADIAN SYLLABICS RAA +154D CANADIAN SYLLABICS WEST-CREE LA +154E CANADIAN SYLLABICS RWAA +154F CANADIAN SYLLABICS WEST-CREE RWAA +1550 CANADIAN SYLLABICS R +1551 CANADIAN SYLLABICS WEST-CREE R +1552 CANADIAN SYLLABICS MEDIAL R +1553 CANADIAN SYLLABICS FE +1554 CANADIAN SYLLABICS FAAI +1555 CANADIAN SYLLABICS FI +1556 CANADIAN SYLLABICS FII +1557 CANADIAN SYLLABICS FO +1558 CANADIAN SYLLABICS FOO +1559 CANADIAN SYLLABICS FA +155A CANADIAN SYLLABICS FAA +155B CANADIAN SYLLABICS FWAA +155C CANADIAN SYLLABICS WEST-CREE FWAA +155D CANADIAN SYLLABICS F +155E CANADIAN SYLLABICS THE +155F CANADIAN SYLLABICS N-CREE THE +1560 CANADIAN SYLLABICS THI +1561 CANADIAN SYLLABICS N-CREE THI +1562 CANADIAN SYLLABICS THII +1563 CANADIAN SYLLABICS N-CREE THII +1564 CANADIAN SYLLABICS THO +1565 CANADIAN SYLLABICS THOO +1566 CANADIAN SYLLABICS THA +1567 CANADIAN SYLLABICS THAA +1568 CANADIAN SYLLABICS THWAA +1569 CANADIAN SYLLABICS WEST-CREE THWAA +156A CANADIAN SYLLABICS TH +156B CANADIAN SYLLABICS TTHE +156C CANADIAN SYLLABICS TTHI +156D CANADIAN SYLLABICS TTHO +156E CANADIAN SYLLABICS TTHA +156F CANADIAN SYLLABICS TTH +1570 CANADIAN SYLLABICS TYE +1571 CANADIAN SYLLABICS TYI +1572 CANADIAN SYLLABICS TYO +1573 CANADIAN SYLLABICS TYA +1574 CANADIAN SYLLABICS NUNAVIK HE +1575 CANADIAN SYLLABICS NUNAVIK HI +1576 CANADIAN SYLLABICS NUNAVIK HII +1577 CANADIAN SYLLABICS NUNAVIK HO +1578 CANADIAN SYLLABICS NUNAVIK HOO +1579 CANADIAN SYLLABICS NUNAVIK HA +157A CANADIAN SYLLABICS NUNAVIK HAA +157B CANADIAN SYLLABICS NUNAVIK H +157C CANADIAN SYLLABICS NUNAVUT H +157D CANADIAN SYLLABICS HK +157E CANADIAN SYLLABICS QAAI +157F CANADIAN SYLLABICS QI +1580 CANADIAN SYLLABICS QII +1581 CANADIAN SYLLABICS QO +1582 CANADIAN SYLLABICS QOO +1583 CANADIAN SYLLABICS QA +1584 CANADIAN SYLLABICS QAA +1585 CANADIAN SYLLABICS Q +1586 CANADIAN SYLLABICS TLHE +1587 CANADIAN SYLLABICS TLHI +1588 CANADIAN SYLLABICS TLHO +1589 CANADIAN SYLLABICS TLHA +158A CANADIAN SYLLABICS WEST-CREE RE +158B CANADIAN SYLLABICS WEST-CREE RI +158C CANADIAN SYLLABICS WEST-CREE RO +158D CANADIAN SYLLABICS WEST-CREE RA +158E CANADIAN SYLLABICS NGAAI +158F CANADIAN SYLLABICS NGI +1590 CANADIAN SYLLABICS NGII +1591 CANADIAN SYLLABICS NGO +1592 CANADIAN SYLLABICS NGOO +1593 CANADIAN SYLLABICS NGA +1594 CANADIAN SYLLABICS NGAA +1595 CANADIAN SYLLABICS NG +1596 CANADIAN SYLLABICS NNG +1597 CANADIAN SYLLABICS SAYISI SHE +1598 CANADIAN SYLLABICS SAYISI SHI +1599 CANADIAN SYLLABICS SAYISI SHO +159A CANADIAN SYLLABICS SAYISI SHA +159B CANADIAN SYLLABICS WOODS-CREE THE +159C CANADIAN SYLLABICS WOODS-CREE THI +159D CANADIAN SYLLABICS WOODS-CREE THO +159E CANADIAN SYLLABICS WOODS-CREE THA +159F CANADIAN SYLLABICS WOODS-CREE TH +15A0 CANADIAN SYLLABICS LHI +15A1 CANADIAN SYLLABICS LHII +15A2 CANADIAN SYLLABICS LHO +15A3 CANADIAN SYLLABICS LHOO +15A4 CANADIAN SYLLABICS LHA +15A5 CANADIAN SYLLABICS LHAA +15A6 CANADIAN SYLLABICS LH +15A7 CANADIAN SYLLABICS TH-CREE THE +15A8 CANADIAN SYLLABICS TH-CREE THI +15A9 CANADIAN SYLLABICS TH-CREE THII +15AA CANADIAN SYLLABICS TH-CREE THO +15AB CANADIAN SYLLABICS TH-CREE THOO +15AC CANADIAN SYLLABICS TH-CREE THA +15AD CANADIAN SYLLABICS TH-CREE THAA +15AE CANADIAN SYLLABICS TH-CREE TH +15AF CANADIAN SYLLABICS AIVILIK B +15B0 CANADIAN SYLLABICS BLACKFOOT E +15B1 CANADIAN SYLLABICS BLACKFOOT I +15B2 CANADIAN SYLLABICS BLACKFOOT O +15B3 CANADIAN SYLLABICS BLACKFOOT A +15B4 CANADIAN SYLLABICS BLACKFOOT WE +15B5 CANADIAN SYLLABICS BLACKFOOT WI +15B6 CANADIAN SYLLABICS BLACKFOOT WO +15B7 CANADIAN SYLLABICS BLACKFOOT WA +15B8 CANADIAN SYLLABICS BLACKFOOT NE +15B9 CANADIAN SYLLABICS BLACKFOOT NI +15BA CANADIAN SYLLABICS BLACKFOOT NO +15BB CANADIAN SYLLABICS BLACKFOOT NA +15BC CANADIAN SYLLABICS BLACKFOOT KE +15BD CANADIAN SYLLABICS BLACKFOOT KI +15BE CANADIAN SYLLABICS BLACKFOOT KO +15BF CANADIAN SYLLABICS BLACKFOOT KA +15C0 CANADIAN SYLLABICS SAYISI HE +15C1 CANADIAN SYLLABICS SAYISI HI +15C2 CANADIAN SYLLABICS SAYISI HO +15C3 CANADIAN SYLLABICS SAYISI HA +15C4 CANADIAN SYLLABICS CARRIER GHU +15C5 CANADIAN SYLLABICS CARRIER GHO +15C6 CANADIAN SYLLABICS CARRIER GHE +15C7 CANADIAN SYLLABICS CARRIER GHEE +15C8 CANADIAN SYLLABICS CARRIER GHI +15C9 CANADIAN SYLLABICS CARRIER GHA +15CA CANADIAN SYLLABICS CARRIER RU +15CB CANADIAN SYLLABICS CARRIER RO +15CC CANADIAN SYLLABICS CARRIER RE +15CD CANADIAN SYLLABICS CARRIER REE +15CE CANADIAN SYLLABICS CARRIER RI +15CF CANADIAN SYLLABICS CARRIER RA +15D0 CANADIAN SYLLABICS CARRIER WU +15D1 CANADIAN SYLLABICS CARRIER WO +15D2 CANADIAN SYLLABICS CARRIER WE +15D3 CANADIAN SYLLABICS CARRIER WEE +15D4 CANADIAN SYLLABICS CARRIER WI +15D5 CANADIAN SYLLABICS CARRIER WA +15D6 CANADIAN SYLLABICS CARRIER HWU +15D7 CANADIAN SYLLABICS CARRIER HWO +15D8 CANADIAN SYLLABICS CARRIER HWE +15D9 CANADIAN SYLLABICS CARRIER HWEE +15DA CANADIAN SYLLABICS CARRIER HWI +15DB CANADIAN SYLLABICS CARRIER HWA +15DC CANADIAN SYLLABICS CARRIER THU +15DD CANADIAN SYLLABICS CARRIER THO +15DE CANADIAN SYLLABICS CARRIER THE +15DF CANADIAN SYLLABICS CARRIER THEE +15E0 CANADIAN SYLLABICS CARRIER THI +15E1 CANADIAN SYLLABICS CARRIER THA +15E2 CANADIAN SYLLABICS CARRIER TTU +15E3 CANADIAN SYLLABICS CARRIER TTO +15E4 CANADIAN SYLLABICS CARRIER TTE +15E5 CANADIAN SYLLABICS CARRIER TTEE +15E6 CANADIAN SYLLABICS CARRIER TTI +15E7 CANADIAN SYLLABICS CARRIER TTA +15E8 CANADIAN SYLLABICS CARRIER PU +15E9 CANADIAN SYLLABICS CARRIER PO +15EA CANADIAN SYLLABICS CARRIER PE +15EB CANADIAN SYLLABICS CARRIER PEE +15EC CANADIAN SYLLABICS CARRIER PI +15ED CANADIAN SYLLABICS CARRIER PA +15EE CANADIAN SYLLABICS CARRIER P +15EF CANADIAN SYLLABICS CARRIER GU +15F0 CANADIAN SYLLABICS CARRIER GO +15F1 CANADIAN SYLLABICS CARRIER GE +15F2 CANADIAN SYLLABICS CARRIER GEE +15F3 CANADIAN SYLLABICS CARRIER GI +15F4 CANADIAN SYLLABICS CARRIER GA +15F5 CANADIAN SYLLABICS CARRIER KHU +15F6 CANADIAN SYLLABICS CARRIER KHO +15F7 CANADIAN SYLLABICS CARRIER KHE +15F8 CANADIAN SYLLABICS CARRIER KHEE +15F9 CANADIAN SYLLABICS CARRIER KHI +15FA CANADIAN SYLLABICS CARRIER KHA +15FB CANADIAN SYLLABICS CARRIER KKU +15FC CANADIAN SYLLABICS CARRIER KKO +15FD CANADIAN SYLLABICS CARRIER KKE +15FE CANADIAN SYLLABICS CARRIER KKEE +15FF CANADIAN SYLLABICS CARRIER KKI +1600 CANADIAN SYLLABICS CARRIER KKA +1601 CANADIAN SYLLABICS CARRIER KK +1602 CANADIAN SYLLABICS CARRIER NU +1603 CANADIAN SYLLABICS CARRIER NO +1604 CANADIAN SYLLABICS CARRIER NE +1605 CANADIAN SYLLABICS CARRIER NEE +1606 CANADIAN SYLLABICS CARRIER NI +1607 CANADIAN SYLLABICS CARRIER NA +1608 CANADIAN SYLLABICS CARRIER MU +1609 CANADIAN SYLLABICS CARRIER MO +160A CANADIAN SYLLABICS CARRIER ME +160B CANADIAN SYLLABICS CARRIER MEE +160C CANADIAN SYLLABICS CARRIER MI +160D CANADIAN SYLLABICS CARRIER MA +160E CANADIAN SYLLABICS CARRIER YU +160F CANADIAN SYLLABICS CARRIER YO +1610 CANADIAN SYLLABICS CARRIER YE +1611 CANADIAN SYLLABICS CARRIER YEE +1612 CANADIAN SYLLABICS CARRIER YI +1613 CANADIAN SYLLABICS CARRIER YA +1614 CANADIAN SYLLABICS CARRIER JU +1615 CANADIAN SYLLABICS SAYISI JU +1616 CANADIAN SYLLABICS CARRIER JO +1617 CANADIAN SYLLABICS CARRIER JE +1618 CANADIAN SYLLABICS CARRIER JEE +1619 CANADIAN SYLLABICS CARRIER JI +161A CANADIAN SYLLABICS SAYISI JI +161B CANADIAN SYLLABICS CARRIER JA +161C CANADIAN SYLLABICS CARRIER JJU +161D CANADIAN SYLLABICS CARRIER JJO +161E CANADIAN SYLLABICS CARRIER JJE +161F CANADIAN SYLLABICS CARRIER JJEE +1620 CANADIAN SYLLABICS CARRIER JJI +1621 CANADIAN SYLLABICS CARRIER JJA +1622 CANADIAN SYLLABICS CARRIER LU +1623 CANADIAN SYLLABICS CARRIER LO +1624 CANADIAN SYLLABICS CARRIER LE +1625 CANADIAN SYLLABICS CARRIER LEE +1626 CANADIAN SYLLABICS CARRIER LI +1627 CANADIAN SYLLABICS CARRIER LA +1628 CANADIAN SYLLABICS CARRIER DLU +1629 CANADIAN SYLLABICS CARRIER DLO +162A CANADIAN SYLLABICS CARRIER DLE +162B CANADIAN SYLLABICS CARRIER DLEE +162C CANADIAN SYLLABICS CARRIER DLI +162D CANADIAN SYLLABICS CARRIER DLA +162E CANADIAN SYLLABICS CARRIER LHU +162F CANADIAN SYLLABICS CARRIER LHO +1630 CANADIAN SYLLABICS CARRIER LHE +1631 CANADIAN SYLLABICS CARRIER LHEE +1632 CANADIAN SYLLABICS CARRIER LHI +1633 CANADIAN SYLLABICS CARRIER LHA +1634 CANADIAN SYLLABICS CARRIER TLHU +1635 CANADIAN SYLLABICS CARRIER TLHO +1636 CANADIAN SYLLABICS CARRIER TLHE +1637 CANADIAN SYLLABICS CARRIER TLHEE +1638 CANADIAN SYLLABICS CARRIER TLHI +1639 CANADIAN SYLLABICS CARRIER TLHA +163A CANADIAN SYLLABICS CARRIER TLU +163B CANADIAN SYLLABICS CARRIER TLO +163C CANADIAN SYLLABICS CARRIER TLE +163D CANADIAN SYLLABICS CARRIER TLEE +163E CANADIAN SYLLABICS CARRIER TLI +163F CANADIAN SYLLABICS CARRIER TLA +1640 CANADIAN SYLLABICS CARRIER ZU +1641 CANADIAN SYLLABICS CARRIER ZO +1642 CANADIAN SYLLABICS CARRIER ZE +1643 CANADIAN SYLLABICS CARRIER ZEE +1644 CANADIAN SYLLABICS CARRIER ZI +1645 CANADIAN SYLLABICS CARRIER ZA +1646 CANADIAN SYLLABICS CARRIER Z +1647 CANADIAN SYLLABICS CARRIER INITIAL Z +1648 CANADIAN SYLLABICS CARRIER DZU +1649 CANADIAN SYLLABICS CARRIER DZO +164A CANADIAN SYLLABICS CARRIER DZE +164B CANADIAN SYLLABICS CARRIER DZEE +164C CANADIAN SYLLABICS CARRIER DZI +164D CANADIAN SYLLABICS CARRIER DZA +164E CANADIAN SYLLABICS CARRIER SU +164F CANADIAN SYLLABICS CARRIER SO +1650 CANADIAN SYLLABICS CARRIER SE +1651 CANADIAN SYLLABICS CARRIER SEE +1652 CANADIAN SYLLABICS CARRIER SI +1653 CANADIAN SYLLABICS CARRIER SA +1654 CANADIAN SYLLABICS CARRIER SHU +1655 CANADIAN SYLLABICS CARRIER SHO +1656 CANADIAN SYLLABICS CARRIER SHE +1657 CANADIAN SYLLABICS CARRIER SHEE +1658 CANADIAN SYLLABICS CARRIER SHI +1659 CANADIAN SYLLABICS CARRIER SHA +165A CANADIAN SYLLABICS CARRIER SH +165B CANADIAN SYLLABICS CARRIER TSU +165C CANADIAN SYLLABICS CARRIER TSO +165D CANADIAN SYLLABICS CARRIER TSE +165E CANADIAN SYLLABICS CARRIER TSEE +165F CANADIAN SYLLABICS CARRIER TSI +1660 CANADIAN SYLLABICS CARRIER TSA +1661 CANADIAN SYLLABICS CARRIER CHU +1662 CANADIAN SYLLABICS CARRIER CHO +1663 CANADIAN SYLLABICS CARRIER CHE +1664 CANADIAN SYLLABICS CARRIER CHEE +1665 CANADIAN SYLLABICS CARRIER CHI +1666 CANADIAN SYLLABICS CARRIER CHA +1667 CANADIAN SYLLABICS CARRIER TTSU +1668 CANADIAN SYLLABICS CARRIER TTSO +1669 CANADIAN SYLLABICS CARRIER TTSE +166A CANADIAN SYLLABICS CARRIER TTSEE +166B CANADIAN SYLLABICS CARRIER TTSI +166C CANADIAN SYLLABICS CARRIER TTSA +166D CANADIAN SYLLABICS CHI SIGN +166E CANADIAN SYLLABICS FULL STOP +166F CANADIAN SYLLABICS QAI +1670 CANADIAN SYLLABICS NGAI +1671 CANADIAN SYLLABICS NNGI +1672 CANADIAN SYLLABICS NNGII +1673 CANADIAN SYLLABICS NNGO +1674 CANADIAN SYLLABICS NNGOO +1675 CANADIAN SYLLABICS NNGA +1676 CANADIAN SYLLABICS NNGAA +1680 OGHAM SPACE MARK +1681 OGHAM LETTER BEITH +1682 OGHAM LETTER LUIS +1683 OGHAM LETTER FEARN +1684 OGHAM LETTER SAIL +1685 OGHAM LETTER NION +1686 OGHAM LETTER UATH +1687 OGHAM LETTER DAIR +1688 OGHAM LETTER TINNE +1689 OGHAM LETTER COLL +168A OGHAM LETTER CEIRT +168B OGHAM LETTER MUIN +168C OGHAM LETTER GORT +168D OGHAM LETTER NGEADAL +168E OGHAM LETTER STRAIF +168F OGHAM LETTER RUIS +1690 OGHAM LETTER AILM +1691 OGHAM LETTER ONN +1692 OGHAM LETTER UR +1693 OGHAM LETTER EADHADH +1694 OGHAM LETTER IODHADH +1695 OGHAM LETTER EABHADH +1696 OGHAM LETTER OR +1697 OGHAM LETTER UILLEANN +1698 OGHAM LETTER IFIN +1699 OGHAM LETTER EAMHANCHOLL +169A OGHAM LETTER PEITH +169B OGHAM FEATHER MARK +169C OGHAM REVERSED FEATHER MARK +16A0 RUNIC LETTER FEHU FEOH FE F +16A1 RUNIC LETTER V +16A2 RUNIC LETTER URUZ UR U +16A3 RUNIC LETTER YR +16A4 RUNIC LETTER Y +16A5 RUNIC LETTER W +16A6 RUNIC LETTER THURISAZ THURS THORN +16A7 RUNIC LETTER ETH +16A8 RUNIC LETTER ANSUZ A +16A9 RUNIC LETTER OS O +16AA RUNIC LETTER AC A +16AB RUNIC LETTER AESC +16AC RUNIC LETTER LONG-BRANCH-OSS O +16AD RUNIC LETTER SHORT-TWIG-OSS O +16AE RUNIC LETTER O +16AF RUNIC LETTER OE +16B0 RUNIC LETTER ON +16B1 RUNIC LETTER RAIDO RAD REID R +16B2 RUNIC LETTER KAUNA +16B3 RUNIC LETTER CEN +16B4 RUNIC LETTER KAUN K +16B5 RUNIC LETTER G +16B6 RUNIC LETTER ENG +16B7 RUNIC LETTER GEBO GYFU G +16B8 RUNIC LETTER GAR +16B9 RUNIC LETTER WUNJO WYNN W +16BA RUNIC LETTER HAGLAZ H +16BB RUNIC LETTER HAEGL H +16BC RUNIC LETTER LONG-BRANCH-HAGALL H +16BD RUNIC LETTER SHORT-TWIG-HAGALL H +16BE RUNIC LETTER NAUDIZ NYD NAUD N +16BF RUNIC LETTER SHORT-TWIG-NAUD N +16C0 RUNIC LETTER DOTTED-N +16C1 RUNIC LETTER ISAZ IS ISS I +16C2 RUNIC LETTER E +16C3 RUNIC LETTER JERAN J +16C4 RUNIC LETTER GER +16C5 RUNIC LETTER LONG-BRANCH-AR AE +16C6 RUNIC LETTER SHORT-TWIG-AR A +16C7 RUNIC LETTER IWAZ EOH +16C8 RUNIC LETTER PERTHO PEORTH P +16C9 RUNIC LETTER ALGIZ EOLHX +16CA RUNIC LETTER SOWILO S +16CB RUNIC LETTER SIGEL LONG-BRANCH-SOL S +16CC RUNIC LETTER SHORT-TWIG-SOL S +16CD RUNIC LETTER C +16CE RUNIC LETTER Z +16CF RUNIC LETTER TIWAZ TIR TYR T +16D0 RUNIC LETTER SHORT-TWIG-TYR T +16D1 RUNIC LETTER D +16D2 RUNIC LETTER BERKANAN BEORC BJARKAN B +16D3 RUNIC LETTER SHORT-TWIG-BJARKAN B +16D4 RUNIC LETTER DOTTED-P +16D5 RUNIC LETTER OPEN-P +16D6 RUNIC LETTER EHWAZ EH E +16D7 RUNIC LETTER MANNAZ MAN M +16D8 RUNIC LETTER LONG-BRANCH-MADR M +16D9 RUNIC LETTER SHORT-TWIG-MADR M +16DA RUNIC LETTER LAUKAZ LAGU LOGR L +16DB RUNIC LETTER DOTTED-L +16DC RUNIC LETTER INGWAZ +16DD RUNIC LETTER ING +16DE RUNIC LETTER DAGAZ DAEG D +16DF RUNIC LETTER OTHALAN ETHEL O +16E0 RUNIC LETTER EAR +16E1 RUNIC LETTER IOR +16E2 RUNIC LETTER CWEORTH +16E3 RUNIC LETTER CALC +16E4 RUNIC LETTER CEALC +16E5 RUNIC LETTER STAN +16E6 RUNIC LETTER LONG-BRANCH-YR +16E7 RUNIC LETTER SHORT-TWIG-YR +16E8 RUNIC LETTER ICELANDIC-YR +16E9 RUNIC LETTER Q +16EA RUNIC LETTER X +16EB RUNIC SINGLE PUNCTUATION +16EC RUNIC MULTIPLE PUNCTUATION +16ED RUNIC CROSS PUNCTUATION +16EE RUNIC ARLAUG SYMBOL +16EF RUNIC TVIMADUR SYMBOL +16F0 RUNIC BELGTHOR SYMBOL +1700 TAGALOG LETTER A +1701 TAGALOG LETTER I +1702 TAGALOG LETTER U +1703 TAGALOG LETTER KA +1704 TAGALOG LETTER GA +1705 TAGALOG LETTER NGA +1706 TAGALOG LETTER TA +1707 TAGALOG LETTER DA +1708 TAGALOG LETTER NA +1709 TAGALOG LETTER PA +170A TAGALOG LETTER BA +170B TAGALOG LETTER MA +170C TAGALOG LETTER YA +170E TAGALOG LETTER LA +170F TAGALOG LETTER WA +1710 TAGALOG LETTER SA +1711 TAGALOG LETTER HA +1712 TAGALOG VOWEL SIGN I +1713 TAGALOG VOWEL SIGN U +1714 TAGALOG SIGN VIRAMA +1720 HANUNOO LETTER A +1721 HANUNOO LETTER I +1722 HANUNOO LETTER U +1723 HANUNOO LETTER KA +1724 HANUNOO LETTER GA +1725 HANUNOO LETTER NGA +1726 HANUNOO LETTER TA +1727 HANUNOO LETTER DA +1728 HANUNOO LETTER NA +1729 HANUNOO LETTER PA +172A HANUNOO LETTER BA +172B HANUNOO LETTER MA +172C HANUNOO LETTER YA +172D HANUNOO LETTER RA +172E HANUNOO LETTER LA +172F HANUNOO LETTER WA +1730 HANUNOO LETTER SA +1731 HANUNOO LETTER HA +1732 HANUNOO VOWEL SIGN I +1733 HANUNOO VOWEL SIGN U +1734 HANUNOO SIGN PAMUDPOD +1735 PHILIPPINE SINGLE PUNCTUATION +1736 PHILIPPINE DOUBLE PUNCTUATION +1740 BUHID LETTER A +1741 BUHID LETTER I +1742 BUHID LETTER U +1743 BUHID LETTER KA +1744 BUHID LETTER GA +1745 BUHID LETTER NGA +1746 BUHID LETTER TA +1747 BUHID LETTER DA +1748 BUHID LETTER NA +1749 BUHID LETTER PA +174A BUHID LETTER BA +174B BUHID LETTER MA +174C BUHID LETTER YA +174D BUHID LETTER RA +174E BUHID LETTER LA +174F BUHID LETTER WA +1750 BUHID LETTER SA +1751 BUHID LETTER HA +1752 BUHID VOWEL SIGN I +1753 BUHID VOWEL SIGN U +1760 TAGBANWA LETTER A +1761 TAGBANWA LETTER I +1762 TAGBANWA LETTER U +1763 TAGBANWA LETTER KA +1764 TAGBANWA LETTER GA +1765 TAGBANWA LETTER NGA +1766 TAGBANWA LETTER TA +1767 TAGBANWA LETTER DA +1768 TAGBANWA LETTER NA +1769 TAGBANWA LETTER PA +176A TAGBANWA LETTER BA +176B TAGBANWA LETTER MA +176C TAGBANWA LETTER YA +176E TAGBANWA LETTER LA +176F TAGBANWA LETTER WA +1770 TAGBANWA LETTER SA +1772 TAGBANWA VOWEL SIGN I +1773 TAGBANWA VOWEL SIGN U +1780 KHMER LETTER KA +1781 KHMER LETTER KHA +1782 KHMER LETTER KO +1783 KHMER LETTER KHO +1784 KHMER LETTER NGO +1785 KHMER LETTER CA +1786 KHMER LETTER CHA +1787 KHMER LETTER CO +1788 KHMER LETTER CHO +1789 KHMER LETTER NYO +178A KHMER LETTER DA +178B KHMER LETTER TTHA +178C KHMER LETTER DO +178D KHMER LETTER TTHO +178E KHMER LETTER NNO +178F KHMER LETTER TA +1790 KHMER LETTER THA +1791 KHMER LETTER TO +1792 KHMER LETTER THO +1793 KHMER LETTER NO +1794 KHMER LETTER BA +1795 KHMER LETTER PHA +1796 KHMER LETTER PO +1797 KHMER LETTER PHO +1798 KHMER LETTER MO +1799 KHMER LETTER YO +179A KHMER LETTER RO +179B KHMER LETTER LO +179C KHMER LETTER VO +179D KHMER LETTER SHA +179E KHMER LETTER SSO +179F KHMER LETTER SA +17A0 KHMER LETTER HA +17A1 KHMER LETTER LA +17A2 KHMER LETTER QA +17A3 KHMER INDEPENDENT VOWEL QAQ +17A4 KHMER INDEPENDENT VOWEL QAA +17A5 KHMER INDEPENDENT VOWEL QI +17A6 KHMER INDEPENDENT VOWEL QII +17A7 KHMER INDEPENDENT VOWEL QU +17A8 KHMER INDEPENDENT VOWEL QUK +17A9 KHMER INDEPENDENT VOWEL QUU +17AA KHMER INDEPENDENT VOWEL QUUV +17AB KHMER INDEPENDENT VOWEL RY +17AC KHMER INDEPENDENT VOWEL RYY +17AD KHMER INDEPENDENT VOWEL LY +17AE KHMER INDEPENDENT VOWEL LYY +17AF KHMER INDEPENDENT VOWEL QE +17B0 KHMER INDEPENDENT VOWEL QAI +17B1 KHMER INDEPENDENT VOWEL QOO TYPE ONE +17B2 KHMER INDEPENDENT VOWEL QOO TYPE TWO +17B3 KHMER INDEPENDENT VOWEL QAU +17B4 KHMER VOWEL INHERENT AQ +17B5 KHMER VOWEL INHERENT AA +17B6 KHMER VOWEL SIGN AA +17B7 KHMER VOWEL SIGN I +17B8 KHMER VOWEL SIGN II +17B9 KHMER VOWEL SIGN Y +17BA KHMER VOWEL SIGN YY +17BB KHMER VOWEL SIGN U +17BC KHMER VOWEL SIGN UU +17BD KHMER VOWEL SIGN UA +17BE KHMER VOWEL SIGN OE +17BF KHMER VOWEL SIGN YA +17C0 KHMER VOWEL SIGN IE +17C1 KHMER VOWEL SIGN E +17C2 KHMER VOWEL SIGN AE +17C3 KHMER VOWEL SIGN AI +17C4 KHMER VOWEL SIGN OO +17C5 KHMER VOWEL SIGN AU +17C6 KHMER SIGN NIKAHIT +17C7 KHMER SIGN REAHMUK +17C8 KHMER SIGN YUUKALEAPINTU +17C9 KHMER SIGN MUUSIKATOAN +17CA KHMER SIGN TRIISAP +17CB KHMER SIGN BANTOC +17CC KHMER SIGN ROBAT +17CD KHMER SIGN TOANDAKHIAT +17CE KHMER SIGN KAKABAT +17CF KHMER SIGN AHSDA +17D0 KHMER SIGN SAMYOK SANNYA +17D1 KHMER SIGN VIRIAM +17D2 KHMER SIGN COENG +17D3 KHMER SIGN BATHAMASAT +17D4 KHMER SIGN KHAN +17D5 KHMER SIGN BARIYOOSAN +17D6 KHMER SIGN CAMNUC PII KUUH +17D7 KHMER SIGN LEK TOO +17D8 KHMER SIGN BEYYAL +17D9 KHMER SIGN PHNAEK MUAN +17DA KHMER SIGN KOOMUUT +17DB KHMER CURRENCY SYMBOL RIEL +17DC KHMER SIGN AVAKRAHASANYA +17E0 KHMER DIGIT ZERO +17E1 KHMER DIGIT ONE +17E2 KHMER DIGIT TWO +17E3 KHMER DIGIT THREE +17E4 KHMER DIGIT FOUR +17E5 KHMER DIGIT FIVE +17E6 KHMER DIGIT SIX +17E7 KHMER DIGIT SEVEN +17E8 KHMER DIGIT EIGHT +17E9 KHMER DIGIT NINE +1800 MONGOLIAN BIRGA +1801 MONGOLIAN ELLIPSIS +1802 MONGOLIAN COMMA +1803 MONGOLIAN FULL STOP +1804 MONGOLIAN COLON +1805 MONGOLIAN FOUR DOTS +1806 MONGOLIAN TODO SOFT HYPHEN +1807 MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER +1808 MONGOLIAN MANCHU COMMA +1809 MONGOLIAN MANCHU FULL STOP +180A MONGOLIAN NIRUGU +180B MONGOLIAN FREE VARIATION SELECTOR ONE +180C MONGOLIAN FREE VARIATION SELECTOR TWO +180D MONGOLIAN FREE VARIATION SELECTOR THREE +180E MONGOLIAN VOWEL SEPARATOR +1810 MONGOLIAN DIGIT ZERO +1811 MONGOLIAN DIGIT ONE +1812 MONGOLIAN DIGIT TWO +1813 MONGOLIAN DIGIT THREE +1814 MONGOLIAN DIGIT FOUR +1815 MONGOLIAN DIGIT FIVE +1816 MONGOLIAN DIGIT SIX +1817 MONGOLIAN DIGIT SEVEN +1818 MONGOLIAN DIGIT EIGHT +1819 MONGOLIAN DIGIT NINE +1820 MONGOLIAN LETTER A +1821 MONGOLIAN LETTER E +1822 MONGOLIAN LETTER I +1823 MONGOLIAN LETTER O +1824 MONGOLIAN LETTER U +1825 MONGOLIAN LETTER OE +1826 MONGOLIAN LETTER UE +1827 MONGOLIAN LETTER EE +1828 MONGOLIAN LETTER NA +1829 MONGOLIAN LETTER ANG +182A MONGOLIAN LETTER BA +182B MONGOLIAN LETTER PA +182C MONGOLIAN LETTER QA +182D MONGOLIAN LETTER GA +182E MONGOLIAN LETTER MA +182F MONGOLIAN LETTER LA +1830 MONGOLIAN LETTER SA +1831 MONGOLIAN LETTER SHA +1832 MONGOLIAN LETTER TA +1833 MONGOLIAN LETTER DA +1834 MONGOLIAN LETTER CHA +1835 MONGOLIAN LETTER JA +1836 MONGOLIAN LETTER YA +1837 MONGOLIAN LETTER RA +1838 MONGOLIAN LETTER WA +1839 MONGOLIAN LETTER FA +183A MONGOLIAN LETTER KA +183B MONGOLIAN LETTER KHA +183C MONGOLIAN LETTER TSA +183D MONGOLIAN LETTER ZA +183E MONGOLIAN LETTER HAA +183F MONGOLIAN LETTER ZRA +1840 MONGOLIAN LETTER LHA +1841 MONGOLIAN LETTER ZHI +1842 MONGOLIAN LETTER CHI +1843 MONGOLIAN LETTER TODO LONG VOWEL SIGN +1844 MONGOLIAN LETTER TODO E +1845 MONGOLIAN LETTER TODO I +1846 MONGOLIAN LETTER TODO O +1847 MONGOLIAN LETTER TODO U +1848 MONGOLIAN LETTER TODO OE +1849 MONGOLIAN LETTER TODO UE +184A MONGOLIAN LETTER TODO ANG +184B MONGOLIAN LETTER TODO BA +184C MONGOLIAN LETTER TODO PA +184D MONGOLIAN LETTER TODO QA +184E MONGOLIAN LETTER TODO GA +184F MONGOLIAN LETTER TODO MA +1850 MONGOLIAN LETTER TODO TA +1851 MONGOLIAN LETTER TODO DA +1852 MONGOLIAN LETTER TODO CHA +1853 MONGOLIAN LETTER TODO JA +1854 MONGOLIAN LETTER TODO TSA +1855 MONGOLIAN LETTER TODO YA +1856 MONGOLIAN LETTER TODO WA +1857 MONGOLIAN LETTER TODO KA +1858 MONGOLIAN LETTER TODO GAA +1859 MONGOLIAN LETTER TODO HAA +185A MONGOLIAN LETTER TODO JIA +185B MONGOLIAN LETTER TODO NIA +185C MONGOLIAN LETTER TODO DZA +185D MONGOLIAN LETTER SIBE E +185E MONGOLIAN LETTER SIBE I +185F MONGOLIAN LETTER SIBE IY +1860 MONGOLIAN LETTER SIBE UE +1861 MONGOLIAN LETTER SIBE U +1862 MONGOLIAN LETTER SIBE ANG +1863 MONGOLIAN LETTER SIBE KA +1864 MONGOLIAN LETTER SIBE GA +1865 MONGOLIAN LETTER SIBE HA +1866 MONGOLIAN LETTER SIBE PA +1867 MONGOLIAN LETTER SIBE SHA +1868 MONGOLIAN LETTER SIBE TA +1869 MONGOLIAN LETTER SIBE DA +186A MONGOLIAN LETTER SIBE JA +186B MONGOLIAN LETTER SIBE FA +186C MONGOLIAN LETTER SIBE GAA +186D MONGOLIAN LETTER SIBE HAA +186E MONGOLIAN LETTER SIBE TSA +186F MONGOLIAN LETTER SIBE ZA +1870 MONGOLIAN LETTER SIBE RAA +1871 MONGOLIAN LETTER SIBE CHA +1872 MONGOLIAN LETTER SIBE ZHA +1873 MONGOLIAN LETTER MANCHU I +1874 MONGOLIAN LETTER MANCHU KA +1875 MONGOLIAN LETTER MANCHU RA +1876 MONGOLIAN LETTER MANCHU FA +1877 MONGOLIAN LETTER MANCHU ZHA +1880 MONGOLIAN LETTER ALI GALI ANUSVARA ONE +1881 MONGOLIAN LETTER ALI GALI VISARGA ONE +1882 MONGOLIAN LETTER ALI GALI DAMARU +1883 MONGOLIAN LETTER ALI GALI UBADAMA +1884 MONGOLIAN LETTER ALI GALI INVERTED UBADAMA +1885 MONGOLIAN LETTER ALI GALI BALUDA +1886 MONGOLIAN LETTER ALI GALI THREE BALUDA +1887 MONGOLIAN LETTER ALI GALI A +1888 MONGOLIAN LETTER ALI GALI I +1889 MONGOLIAN LETTER ALI GALI KA +188A MONGOLIAN LETTER ALI GALI NGA +188B MONGOLIAN LETTER ALI GALI CA +188C MONGOLIAN LETTER ALI GALI TTA +188D MONGOLIAN LETTER ALI GALI TTHA +188E MONGOLIAN LETTER ALI GALI DDA +188F MONGOLIAN LETTER ALI GALI NNA +1890 MONGOLIAN LETTER ALI GALI TA +1891 MONGOLIAN LETTER ALI GALI DA +1892 MONGOLIAN LETTER ALI GALI PA +1893 MONGOLIAN LETTER ALI GALI PHA +1894 MONGOLIAN LETTER ALI GALI SSA +1895 MONGOLIAN LETTER ALI GALI ZHA +1896 MONGOLIAN LETTER ALI GALI ZA +1897 MONGOLIAN LETTER ALI GALI AH +1898 MONGOLIAN LETTER TODO ALI GALI TA +1899 MONGOLIAN LETTER TODO ALI GALI ZHA +189A MONGOLIAN LETTER MANCHU ALI GALI GHA +189B MONGOLIAN LETTER MANCHU ALI GALI NGA +189C MONGOLIAN LETTER MANCHU ALI GALI CA +189D MONGOLIAN LETTER MANCHU ALI GALI JHA +189E MONGOLIAN LETTER MANCHU ALI GALI TTA +189F MONGOLIAN LETTER MANCHU ALI GALI DDHA +18A0 MONGOLIAN LETTER MANCHU ALI GALI TA +18A1 MONGOLIAN LETTER MANCHU ALI GALI DHA +18A2 MONGOLIAN LETTER MANCHU ALI GALI SSA +18A3 MONGOLIAN LETTER MANCHU ALI GALI CYA +18A4 MONGOLIAN LETTER MANCHU ALI GALI ZHA +18A5 MONGOLIAN LETTER MANCHU ALI GALI ZA +18A6 MONGOLIAN LETTER ALI GALI HALF U +18A7 MONGOLIAN LETTER ALI GALI HALF YA +18A8 MONGOLIAN LETTER MANCHU ALI GALI BHA +18A9 MONGOLIAN LETTER ALI GALI DAGALGA +1E00 LATIN CAPITAL LETTER A WITH RING BELOW +1E01 LATIN SMALL LETTER A WITH RING BELOW +1E02 LATIN CAPITAL LETTER B WITH DOT ABOVE +1E03 LATIN SMALL LETTER B WITH DOT ABOVE +1E04 LATIN CAPITAL LETTER B WITH DOT BELOW +1E05 LATIN SMALL LETTER B WITH DOT BELOW +1E06 LATIN CAPITAL LETTER B WITH LINE BELOW +1E07 LATIN SMALL LETTER B WITH LINE BELOW +1E08 LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE +1E09 LATIN SMALL LETTER C WITH CEDILLA AND ACUTE +1E0A LATIN CAPITAL LETTER D WITH DOT ABOVE +1E0B LATIN SMALL LETTER D WITH DOT ABOVE +1E0C LATIN CAPITAL LETTER D WITH DOT BELOW +1E0D LATIN SMALL LETTER D WITH DOT BELOW +1E0E LATIN CAPITAL LETTER D WITH LINE BELOW +1E0F LATIN SMALL LETTER D WITH LINE BELOW +1E10 LATIN CAPITAL LETTER D WITH CEDILLA +1E11 LATIN SMALL LETTER D WITH CEDILLA +1E12 LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW +1E13 LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW +1E14 LATIN CAPITAL LETTER E WITH MACRON AND GRAVE +1E15 LATIN SMALL LETTER E WITH MACRON AND GRAVE +1E16 LATIN CAPITAL LETTER E WITH MACRON AND ACUTE +1E17 LATIN SMALL LETTER E WITH MACRON AND ACUTE +1E18 LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW +1E19 LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW +1E1A LATIN CAPITAL LETTER E WITH TILDE BELOW +1E1B LATIN SMALL LETTER E WITH TILDE BELOW +1E1C LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE +1E1D LATIN SMALL LETTER E WITH CEDILLA AND BREVE +1E1E LATIN CAPITAL LETTER F WITH DOT ABOVE +1E1F LATIN SMALL LETTER F WITH DOT ABOVE +1E20 LATIN CAPITAL LETTER G WITH MACRON +1E21 LATIN SMALL LETTER G WITH MACRON +1E22 LATIN CAPITAL LETTER H WITH DOT ABOVE +1E23 LATIN SMALL LETTER H WITH DOT ABOVE +1E24 LATIN CAPITAL LETTER H WITH DOT BELOW +1E25 LATIN SMALL LETTER H WITH DOT BELOW +1E26 LATIN CAPITAL LETTER H WITH DIAERESIS +1E27 LATIN SMALL LETTER H WITH DIAERESIS +1E28 LATIN CAPITAL LETTER H WITH CEDILLA +1E29 LATIN SMALL LETTER H WITH CEDILLA +1E2A LATIN CAPITAL LETTER H WITH BREVE BELOW +1E2B LATIN SMALL LETTER H WITH BREVE BELOW +1E2C LATIN CAPITAL LETTER I WITH TILDE BELOW +1E2D LATIN SMALL LETTER I WITH TILDE BELOW +1E2E LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE +1E2F LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE +1E30 LATIN CAPITAL LETTER K WITH ACUTE +1E31 LATIN SMALL LETTER K WITH ACUTE +1E32 LATIN CAPITAL LETTER K WITH DOT BELOW +1E33 LATIN SMALL LETTER K WITH DOT BELOW +1E34 LATIN CAPITAL LETTER K WITH LINE BELOW +1E35 LATIN SMALL LETTER K WITH LINE BELOW +1E36 LATIN CAPITAL LETTER L WITH DOT BELOW +1E37 LATIN SMALL LETTER L WITH DOT BELOW +1E38 LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON +1E39 LATIN SMALL LETTER L WITH DOT BELOW AND MACRON +1E3A LATIN CAPITAL LETTER L WITH LINE BELOW +1E3B LATIN SMALL LETTER L WITH LINE BELOW +1E3C LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW +1E3D LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW +1E3E LATIN CAPITAL LETTER M WITH ACUTE +1E3F LATIN SMALL LETTER M WITH ACUTE +1E40 LATIN CAPITAL LETTER M WITH DOT ABOVE +1E41 LATIN SMALL LETTER M WITH DOT ABOVE +1E42 LATIN CAPITAL LETTER M WITH DOT BELOW +1E43 LATIN SMALL LETTER M WITH DOT BELOW +1E44 LATIN CAPITAL LETTER N WITH DOT ABOVE +1E45 LATIN SMALL LETTER N WITH DOT ABOVE +1E46 LATIN CAPITAL LETTER N WITH DOT BELOW +1E47 LATIN SMALL LETTER N WITH DOT BELOW +1E48 LATIN CAPITAL LETTER N WITH LINE BELOW +1E49 LATIN SMALL LETTER N WITH LINE BELOW +1E4A LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW +1E4B LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW +1E4C LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +1E4D LATIN SMALL LETTER O WITH TILDE AND ACUTE +1E4E LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS +1E4F LATIN SMALL LETTER O WITH TILDE AND DIAERESIS +1E50 LATIN CAPITAL LETTER O WITH MACRON AND GRAVE +1E51 LATIN SMALL LETTER O WITH MACRON AND GRAVE +1E52 LATIN CAPITAL LETTER O WITH MACRON AND ACUTE +1E53 LATIN SMALL LETTER O WITH MACRON AND ACUTE +1E54 LATIN CAPITAL LETTER P WITH ACUTE +1E55 LATIN SMALL LETTER P WITH ACUTE +1E56 LATIN CAPITAL LETTER P WITH DOT ABOVE +1E57 LATIN SMALL LETTER P WITH DOT ABOVE +1E58 LATIN CAPITAL LETTER R WITH DOT ABOVE +1E59 LATIN SMALL LETTER R WITH DOT ABOVE +1E5A LATIN CAPITAL LETTER R WITH DOT BELOW +1E5B LATIN SMALL LETTER R WITH DOT BELOW +1E5C LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON +1E5D LATIN SMALL LETTER R WITH DOT BELOW AND MACRON +1E5E LATIN CAPITAL LETTER R WITH LINE BELOW +1E5F LATIN SMALL LETTER R WITH LINE BELOW +1E60 LATIN CAPITAL LETTER S WITH DOT ABOVE +1E61 LATIN SMALL LETTER S WITH DOT ABOVE +1E62 LATIN CAPITAL LETTER S WITH DOT BELOW +1E63 LATIN SMALL LETTER S WITH DOT BELOW +1E64 LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE +1E65 LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE +1E66 LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE +1E67 LATIN SMALL LETTER S WITH CARON AND DOT ABOVE +1E68 LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE +1E69 LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE +1E6A LATIN CAPITAL LETTER T WITH DOT ABOVE +1E6B LATIN SMALL LETTER T WITH DOT ABOVE +1E6C LATIN CAPITAL LETTER T WITH DOT BELOW +1E6D LATIN SMALL LETTER T WITH DOT BELOW +1E6E LATIN CAPITAL LETTER T WITH LINE BELOW +1E6F LATIN SMALL LETTER T WITH LINE BELOW +1E70 LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW +1E71 LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW +1E72 LATIN CAPITAL LETTER U WITH DIAERESIS BELOW +1E73 LATIN SMALL LETTER U WITH DIAERESIS BELOW +1E74 LATIN CAPITAL LETTER U WITH TILDE BELOW +1E75 LATIN SMALL LETTER U WITH TILDE BELOW +1E76 LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW +1E77 LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW +1E78 LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +1E79 LATIN SMALL LETTER U WITH TILDE AND ACUTE +1E7A LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS +1E7B LATIN SMALL LETTER U WITH MACRON AND DIAERESIS +1E7C LATIN CAPITAL LETTER V WITH TILDE +1E7D LATIN SMALL LETTER V WITH TILDE +1E7E LATIN CAPITAL LETTER V WITH DOT BELOW +1E7F LATIN SMALL LETTER V WITH DOT BELOW +1E80 LATIN CAPITAL LETTER W WITH GRAVE +1E81 LATIN SMALL LETTER W WITH GRAVE +1E82 LATIN CAPITAL LETTER W WITH ACUTE +1E83 LATIN SMALL LETTER W WITH ACUTE +1E84 LATIN CAPITAL LETTER W WITH DIAERESIS +1E85 LATIN SMALL LETTER W WITH DIAERESIS +1E86 LATIN CAPITAL LETTER W WITH DOT ABOVE +1E87 LATIN SMALL LETTER W WITH DOT ABOVE +1E88 LATIN CAPITAL LETTER W WITH DOT BELOW +1E89 LATIN SMALL LETTER W WITH DOT BELOW +1E8A LATIN CAPITAL LETTER X WITH DOT ABOVE +1E8B LATIN SMALL LETTER X WITH DOT ABOVE +1E8C LATIN CAPITAL LETTER X WITH DIAERESIS +1E8D LATIN SMALL LETTER X WITH DIAERESIS +1E8E LATIN CAPITAL LETTER Y WITH DOT ABOVE +1E8F LATIN SMALL LETTER Y WITH DOT ABOVE +1E90 LATIN CAPITAL LETTER Z WITH CIRCUMFLEX +1E91 LATIN SMALL LETTER Z WITH CIRCUMFLEX +1E92 LATIN CAPITAL LETTER Z WITH DOT BELOW +1E93 LATIN SMALL LETTER Z WITH DOT BELOW +1E94 LATIN CAPITAL LETTER Z WITH LINE BELOW +1E95 LATIN SMALL LETTER Z WITH LINE BELOW +1E96 LATIN SMALL LETTER H WITH LINE BELOW +1E97 LATIN SMALL LETTER T WITH DIAERESIS +1E98 LATIN SMALL LETTER W WITH RING ABOVE +1E99 LATIN SMALL LETTER Y WITH RING ABOVE +1E9A LATIN SMALL LETTER A WITH RIGHT HALF RING +1E9B LATIN SMALL LETTER LONG S WITH DOT ABOVE +1EA0 LATIN CAPITAL LETTER A WITH DOT BELOW +1EA1 LATIN SMALL LETTER A WITH DOT BELOW +1EA2 LATIN CAPITAL LETTER A WITH HOOK ABOVE +1EA3 LATIN SMALL LETTER A WITH HOOK ABOVE +1EA4 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE +1EA5 LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE +1EA6 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE +1EA7 LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE +1EA8 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +1EA9 LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +1EAA LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE +1EAB LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE +1EAC LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW +1EAD LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW +1EAE LATIN CAPITAL LETTER A WITH BREVE AND ACUTE +1EAF LATIN SMALL LETTER A WITH BREVE AND ACUTE +1EB0 LATIN CAPITAL LETTER A WITH BREVE AND GRAVE +1EB1 LATIN SMALL LETTER A WITH BREVE AND GRAVE +1EB2 LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE +1EB3 LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE +1EB4 LATIN CAPITAL LETTER A WITH BREVE AND TILDE +1EB5 LATIN SMALL LETTER A WITH BREVE AND TILDE +1EB6 LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW +1EB7 LATIN SMALL LETTER A WITH BREVE AND DOT BELOW +1EB8 LATIN CAPITAL LETTER E WITH DOT BELOW +1EB9 LATIN SMALL LETTER E WITH DOT BELOW +1EBA LATIN CAPITAL LETTER E WITH HOOK ABOVE +1EBB LATIN SMALL LETTER E WITH HOOK ABOVE +1EBC LATIN CAPITAL LETTER E WITH TILDE +1EBD LATIN SMALL LETTER E WITH TILDE +1EBE LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE +1EBF LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE +1EC0 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE +1EC1 LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE +1EC2 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +1EC3 LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +1EC4 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE +1EC5 LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE +1EC6 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW +1EC7 LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW +1EC8 LATIN CAPITAL LETTER I WITH HOOK ABOVE +1EC9 LATIN SMALL LETTER I WITH HOOK ABOVE +1ECA LATIN CAPITAL LETTER I WITH DOT BELOW +1ECB LATIN SMALL LETTER I WITH DOT BELOW +1ECC LATIN CAPITAL LETTER O WITH DOT BELOW +1ECD LATIN SMALL LETTER O WITH DOT BELOW +1ECE LATIN CAPITAL LETTER O WITH HOOK ABOVE +1ECF LATIN SMALL LETTER O WITH HOOK ABOVE +1ED0 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE +1ED1 LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE +1ED2 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE +1ED3 LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE +1ED4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +1ED5 LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +1ED6 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE +1ED7 LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE +1ED8 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW +1ED9 LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW +1EDA LATIN CAPITAL LETTER O WITH HORN AND ACUTE +1EDB LATIN SMALL LETTER O WITH HORN AND ACUTE +1EDC LATIN CAPITAL LETTER O WITH HORN AND GRAVE +1EDD LATIN SMALL LETTER O WITH HORN AND GRAVE +1EDE LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE +1EDF LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +1EE0 LATIN CAPITAL LETTER O WITH HORN AND TILDE +1EE1 LATIN SMALL LETTER O WITH HORN AND TILDE +1EE2 LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +1EE3 LATIN SMALL LETTER O WITH HORN AND DOT BELOW +1EE4 LATIN CAPITAL LETTER U WITH DOT BELOW +1EE5 LATIN SMALL LETTER U WITH DOT BELOW +1EE6 LATIN CAPITAL LETTER U WITH HOOK ABOVE +1EE7 LATIN SMALL LETTER U WITH HOOK ABOVE +1EE8 LATIN CAPITAL LETTER U WITH HORN AND ACUTE +1EE9 LATIN SMALL LETTER U WITH HORN AND ACUTE +1EEA LATIN CAPITAL LETTER U WITH HORN AND GRAVE +1EEB LATIN SMALL LETTER U WITH HORN AND GRAVE +1EEC LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +1EED LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +1EEE LATIN CAPITAL LETTER U WITH HORN AND TILDE +1EEF LATIN SMALL LETTER U WITH HORN AND TILDE +1EF0 LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW +1EF1 LATIN SMALL LETTER U WITH HORN AND DOT BELOW +1EF2 LATIN CAPITAL LETTER Y WITH GRAVE +1EF3 LATIN SMALL LETTER Y WITH GRAVE +1EF4 LATIN CAPITAL LETTER Y WITH DOT BELOW +1EF5 LATIN SMALL LETTER Y WITH DOT BELOW +1EF6 LATIN CAPITAL LETTER Y WITH HOOK ABOVE +1EF7 LATIN SMALL LETTER Y WITH HOOK ABOVE +1EF8 LATIN CAPITAL LETTER Y WITH TILDE +1EF9 LATIN SMALL LETTER Y WITH TILDE +1F00 GREEK SMALL LETTER ALPHA WITH PSILI +1F01 GREEK SMALL LETTER ALPHA WITH DASIA +1F02 GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA +1F03 GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA +1F04 GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA +1F05 GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA +1F06 GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI +1F07 GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI +1F08 GREEK CAPITAL LETTER ALPHA WITH PSILI +1F09 GREEK CAPITAL LETTER ALPHA WITH DASIA +1F0A GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA +1F0B GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA +1F0C GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA +1F0D GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA +1F0E GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI +1F0F GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI +1F10 GREEK SMALL LETTER EPSILON WITH PSILI +1F11 GREEK SMALL LETTER EPSILON WITH DASIA +1F12 GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA +1F13 GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA +1F14 GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA +1F15 GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA +1F18 GREEK CAPITAL LETTER EPSILON WITH PSILI +1F19 GREEK CAPITAL LETTER EPSILON WITH DASIA +1F1A GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA +1F1B GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA +1F1C GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA +1F1D GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA +1F20 GREEK SMALL LETTER ETA WITH PSILI +1F21 GREEK SMALL LETTER ETA WITH DASIA +1F22 GREEK SMALL LETTER ETA WITH PSILI AND VARIA +1F23 GREEK SMALL LETTER ETA WITH DASIA AND VARIA +1F24 GREEK SMALL LETTER ETA WITH PSILI AND OXIA +1F25 GREEK SMALL LETTER ETA WITH DASIA AND OXIA +1F26 GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI +1F27 GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI +1F28 GREEK CAPITAL LETTER ETA WITH PSILI +1F29 GREEK CAPITAL LETTER ETA WITH DASIA +1F2A GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA +1F2B GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA +1F2C GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA +1F2D GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA +1F2E GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI +1F2F GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI +1F30 GREEK SMALL LETTER IOTA WITH PSILI +1F31 GREEK SMALL LETTER IOTA WITH DASIA +1F32 GREEK SMALL LETTER IOTA WITH PSILI AND VARIA +1F33 GREEK SMALL LETTER IOTA WITH DASIA AND VARIA +1F34 GREEK SMALL LETTER IOTA WITH PSILI AND OXIA +1F35 GREEK SMALL LETTER IOTA WITH DASIA AND OXIA +1F36 GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI +1F37 GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI +1F38 GREEK CAPITAL LETTER IOTA WITH PSILI +1F39 GREEK CAPITAL LETTER IOTA WITH DASIA +1F3A GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA +1F3B GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA +1F3C GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA +1F3D GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA +1F3E GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI +1F3F GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI +1F40 GREEK SMALL LETTER OMICRON WITH PSILI +1F41 GREEK SMALL LETTER OMICRON WITH DASIA +1F42 GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA +1F43 GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA +1F44 GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA +1F45 GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA +1F48 GREEK CAPITAL LETTER OMICRON WITH PSILI +1F49 GREEK CAPITAL LETTER OMICRON WITH DASIA +1F4A GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA +1F4B GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA +1F4C GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA +1F4D GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA +1F50 GREEK SMALL LETTER UPSILON WITH PSILI +1F51 GREEK SMALL LETTER UPSILON WITH DASIA +1F52 GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA +1F53 GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA +1F54 GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA +1F55 GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA +1F56 GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI +1F57 GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI +1F59 GREEK CAPITAL LETTER UPSILON WITH DASIA +1F5B GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA +1F5D GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA +1F5F GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI +1F60 GREEK SMALL LETTER OMEGA WITH PSILI +1F61 GREEK SMALL LETTER OMEGA WITH DASIA +1F62 GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA +1F63 GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA +1F64 GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA +1F65 GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA +1F66 GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI +1F67 GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI +1F68 GREEK CAPITAL LETTER OMEGA WITH PSILI +1F69 GREEK CAPITAL LETTER OMEGA WITH DASIA +1F6A GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA +1F6B GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA +1F6C GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA +1F6D GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA +1F6E GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI +1F6F GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI +1F70 GREEK SMALL LETTER ALPHA WITH VARIA +1F71 GREEK SMALL LETTER ALPHA WITH OXIA +1F72 GREEK SMALL LETTER EPSILON WITH VARIA +1F73 GREEK SMALL LETTER EPSILON WITH OXIA +1F74 GREEK SMALL LETTER ETA WITH VARIA +1F75 GREEK SMALL LETTER ETA WITH OXIA +1F76 GREEK SMALL LETTER IOTA WITH VARIA +1F77 GREEK SMALL LETTER IOTA WITH OXIA +1F78 GREEK SMALL LETTER OMICRON WITH VARIA +1F79 GREEK SMALL LETTER OMICRON WITH OXIA +1F7A GREEK SMALL LETTER UPSILON WITH VARIA +1F7B GREEK SMALL LETTER UPSILON WITH OXIA +1F7C GREEK SMALL LETTER OMEGA WITH VARIA +1F7D GREEK SMALL LETTER OMEGA WITH OXIA +1F80 GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI +1F81 GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI +1F82 GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +1F83 GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +1F84 GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +1F85 GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +1F86 GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI +1F87 GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI +1F88 GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI +1F89 GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI +1F8A GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +1F8B GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +1F8C GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +1F8D GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +1F8E GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI +1F8F GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI +1F90 GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI +1F91 GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI +1F92 GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +1F93 GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +1F94 GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +1F95 GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +1F96 GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI +1F97 GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI +1F98 GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI +1F99 GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI +1F9A GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +1F9B GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +1F9C GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +1F9D GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +1F9E GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI +1F9F GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI +1FA0 GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI +1FA1 GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI +1FA2 GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +1FA3 GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +1FA4 GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +1FA5 GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +1FA6 GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI +1FA7 GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI +1FA8 GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI +1FA9 GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI +1FAA GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +1FAB GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +1FAC GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +1FAD GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +1FAE GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI +1FAF GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI +1FB0 GREEK SMALL LETTER ALPHA WITH VRACHY +1FB1 GREEK SMALL LETTER ALPHA WITH MACRON +1FB2 GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI +1FB3 GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI +1FB4 GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI +1FB6 GREEK SMALL LETTER ALPHA WITH PERISPOMENI +1FB7 GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI +1FB8 GREEK CAPITAL LETTER ALPHA WITH VRACHY +1FB9 GREEK CAPITAL LETTER ALPHA WITH MACRON +1FBA GREEK CAPITAL LETTER ALPHA WITH VARIA +1FBB GREEK CAPITAL LETTER ALPHA WITH OXIA +1FBC GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI +1FBD GREEK KORONIS +1FBE GREEK PROSGEGRAMMENI +1FBF GREEK PSILI +1FC0 GREEK PERISPOMENI +1FC1 GREEK DIALYTIKA AND PERISPOMENI +1FC2 GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI +1FC3 GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI +1FC4 GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI +1FC6 GREEK SMALL LETTER ETA WITH PERISPOMENI +1FC7 GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI +1FC8 GREEK CAPITAL LETTER EPSILON WITH VARIA +1FC9 GREEK CAPITAL LETTER EPSILON WITH OXIA +1FCA GREEK CAPITAL LETTER ETA WITH VARIA +1FCB GREEK CAPITAL LETTER ETA WITH OXIA +1FCC GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI +1FCD GREEK PSILI AND VARIA +1FCE GREEK PSILI AND OXIA +1FCF GREEK PSILI AND PERISPOMENI +1FD0 GREEK SMALL LETTER IOTA WITH VRACHY +1FD1 GREEK SMALL LETTER IOTA WITH MACRON +1FD2 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA +1FD3 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA +1FD6 GREEK SMALL LETTER IOTA WITH PERISPOMENI +1FD7 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI +1FD8 GREEK CAPITAL LETTER IOTA WITH VRACHY +1FD9 GREEK CAPITAL LETTER IOTA WITH MACRON +1FDA GREEK CAPITAL LETTER IOTA WITH VARIA +1FDB GREEK CAPITAL LETTER IOTA WITH OXIA +1FDD GREEK DASIA AND VARIA +1FDE GREEK DASIA AND OXIA +1FDF GREEK DASIA AND PERISPOMENI +1FE0 GREEK SMALL LETTER UPSILON WITH VRACHY +1FE1 GREEK SMALL LETTER UPSILON WITH MACRON +1FE2 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA +1FE3 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA +1FE4 GREEK SMALL LETTER RHO WITH PSILI +1FE5 GREEK SMALL LETTER RHO WITH DASIA +1FE6 GREEK SMALL LETTER UPSILON WITH PERISPOMENI +1FE7 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI +1FE8 GREEK CAPITAL LETTER UPSILON WITH VRACHY +1FE9 GREEK CAPITAL LETTER UPSILON WITH MACRON +1FEA GREEK CAPITAL LETTER UPSILON WITH VARIA +1FEB GREEK CAPITAL LETTER UPSILON WITH OXIA +1FEC GREEK CAPITAL LETTER RHO WITH DASIA +1FED GREEK DIALYTIKA AND VARIA +1FEE GREEK DIALYTIKA AND OXIA +1FEF GREEK VARIA +1FF2 GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI +1FF3 GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI +1FF4 GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI +1FF6 GREEK SMALL LETTER OMEGA WITH PERISPOMENI +1FF7 GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI +1FF8 GREEK CAPITAL LETTER OMICRON WITH VARIA +1FF9 GREEK CAPITAL LETTER OMICRON WITH OXIA +1FFA GREEK CAPITAL LETTER OMEGA WITH VARIA +1FFB GREEK CAPITAL LETTER OMEGA WITH OXIA +1FFC GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI +1FFD GREEK OXIA +1FFE GREEK DASIA +2000 EN QUAD +2001 EM QUAD +2002 EN SPACE +2003 EM SPACE +2004 THREE-PER-EM SPACE +2005 FOUR-PER-EM SPACE +2006 SIX-PER-EM SPACE +2007 FIGURE SPACE +2008 PUNCTUATION SPACE +2009 THIN SPACE +200A HAIR SPACE +200B ZERO WIDTH SPACE +200C ZERO WIDTH NON-JOINER +200D ZERO WIDTH JOINER +200E LEFT-TO-RIGHT MARK +200F RIGHT-TO-LEFT MARK +2010 HYPHEN +2011 NON-BREAKING HYPHEN +2012 FIGURE DASH +2013 EN DASH +2014 EM DASH +2015 HORIZONTAL BAR +2016 DOUBLE VERTICAL LINE +2017 DOUBLE LOW LINE +2018 LEFT SINGLE QUOTATION MARK +2019 RIGHT SINGLE QUOTATION MARK +201A SINGLE LOW-9 QUOTATION MARK +201B SINGLE HIGH-REVERSED-9 QUOTATION MARK +201C LEFT DOUBLE QUOTATION MARK +201D RIGHT DOUBLE QUOTATION MARK +201E DOUBLE LOW-9 QUOTATION MARK +201F DOUBLE HIGH-REVERSED-9 QUOTATION MARK +2020 DAGGER +2021 DOUBLE DAGGER +2022 BULLET +2023 TRIANGULAR BULLET +2024 ONE DOT LEADER +2025 TWO DOT LEADER +2026 HORIZONTAL ELLIPSIS +2027 HYPHENATION POINT +2028 LINE SEPARATOR +2029 PARAGRAPH SEPARATOR +202A LEFT-TO-RIGHT EMBEDDING +202B RIGHT-TO-LEFT EMBEDDING +202C POP DIRECTIONAL FORMATTING +202D LEFT-TO-RIGHT OVERRIDE +202E RIGHT-TO-LEFT OVERRIDE +202F NARROW NO-BREAK SPACE +2030 PER MILLE SIGN +2031 PER TEN THOUSAND SIGN +2032 PRIME +2033 DOUBLE PRIME +2034 TRIPLE PRIME +2035 REVERSED PRIME +2036 REVERSED DOUBLE PRIME +2037 REVERSED TRIPLE PRIME +2038 CARET +2039 SINGLE LEFT-POINTING ANGLE QUOTATION MARK +203A SINGLE RIGHT-POINTING ANGLE QUOTATION MARK +203B REFERENCE MARK +203C DOUBLE EXCLAMATION MARK +203D INTERROBANG +203E OVERLINE +203F UNDERTIE +2040 CHARACTER TIE +2041 CARET INSERTION POINT +2042 ASTERISM +2043 HYPHEN BULLET +2044 FRACTION SLASH +2045 LEFT SQUARE BRACKET WITH QUILL +2046 RIGHT SQUARE BRACKET WITH QUILL +2047 DOUBLE QUESTION MARK +2048 QUESTION EXCLAMATION MARK +2049 EXCLAMATION QUESTION MARK +204A TIRONIAN SIGN ET +204B REVERSED PILCROW SIGN +204C BLACK LEFTWARDS BULLET +204D BLACK RIGHTWARDS BULLET +204E LOW ASTERISK +204F REVERSED SEMICOLON +2050 CLOSE UP +2051 TWO ASTERISKS ALIGNED VERTICALLY +2052 COMMERCIAL MINUS SIGN +2057 QUADRUPLE PRIME +205F MEDIUM MATHEMATICAL SPACE +2060 WORD JOINER +2061 FUNCTION APPLICATION +2062 INVISIBLE TIMES +2063 INVISIBLE SEPARATOR +206A INHIBIT SYMMETRIC SWAPPING +206B ACTIVATE SYMMETRIC SWAPPING +206C INHIBIT ARABIC FORM SHAPING +206D ACTIVATE ARABIC FORM SHAPING +206E NATIONAL DIGIT SHAPES +206F NOMINAL DIGIT SHAPES +2070 SUPERSCRIPT ZERO +2071 SUPERSCRIPT LATIN SMALL LETTER I +2074 SUPERSCRIPT FOUR +2075 SUPERSCRIPT FIVE +2076 SUPERSCRIPT SIX +2077 SUPERSCRIPT SEVEN +2078 SUPERSCRIPT EIGHT +2079 SUPERSCRIPT NINE +207A SUPERSCRIPT PLUS SIGN +207B SUPERSCRIPT MINUS +207C SUPERSCRIPT EQUALS SIGN +207D SUPERSCRIPT LEFT PARENTHESIS +207E SUPERSCRIPT RIGHT PARENTHESIS +207F SUPERSCRIPT LATIN SMALL LETTER N +2080 SUBSCRIPT ZERO +2081 SUBSCRIPT ONE +2082 SUBSCRIPT TWO +2083 SUBSCRIPT THREE +2084 SUBSCRIPT FOUR +2085 SUBSCRIPT FIVE +2086 SUBSCRIPT SIX +2087 SUBSCRIPT SEVEN +2088 SUBSCRIPT EIGHT +2089 SUBSCRIPT NINE +208A SUBSCRIPT PLUS SIGN +208B SUBSCRIPT MINUS +208C SUBSCRIPT EQUALS SIGN +208D SUBSCRIPT LEFT PARENTHESIS +208E SUBSCRIPT RIGHT PARENTHESIS +20A0 EURO-CURRENCY SIGN +20A1 COLON SIGN +20A2 CRUZEIRO SIGN +20A3 FRENCH FRANC SIGN +20A4 LIRA SIGN +20A5 MILL SIGN +20A6 NAIRA SIGN +20A7 PESETA SIGN +20A8 RUPEE SIGN +20A9 WON SIGN +20AA NEW SHEQEL SIGN +20AB DONG SIGN +20AC EURO SIGN +20AD KIP SIGN +20AE TUGRIK SIGN +20AF DRACHMA SIGN +20B0 GERMAN PENNY SIGN +20B1 PESO SIGN +20D0 COMBINING LEFT HARPOON ABOVE +20D1 COMBINING RIGHT HARPOON ABOVE +20D2 COMBINING LONG VERTICAL LINE OVERLAY +20D3 COMBINING SHORT VERTICAL LINE OVERLAY +20D4 COMBINING ANTICLOCKWISE ARROW ABOVE +20D5 COMBINING CLOCKWISE ARROW ABOVE +20D6 COMBINING LEFT ARROW ABOVE +20D7 COMBINING RIGHT ARROW ABOVE +20D8 COMBINING RING OVERLAY +20D9 COMBINING CLOCKWISE RING OVERLAY +20DA COMBINING ANTICLOCKWISE RING OVERLAY +20DB COMBINING THREE DOTS ABOVE +20DC COMBINING FOUR DOTS ABOVE +20DD COMBINING ENCLOSING CIRCLE +20DE COMBINING ENCLOSING SQUARE +20DF COMBINING ENCLOSING DIAMOND +20E0 COMBINING ENCLOSING CIRCLE BACKSLASH +20E1 COMBINING LEFT RIGHT ARROW ABOVE +20E2 COMBINING ENCLOSING SCREEN +20E3 COMBINING ENCLOSING KEYCAP +20E4 COMBINING ENCLOSING UPWARD POINTING TRIANGLE +20E5 COMBINING REVERSE SOLIDUS OVERLAY +20E6 COMBINING DOUBLE VERTICAL STROKE OVERLAY +20E7 COMBINING ANNUITY SYMBOL +20E8 COMBINING TRIPLE UNDERDOT +20E9 COMBINING WIDE BRIDGE ABOVE +20EA COMBINING LEFTWARDS ARROW OVERLAY +2100 ACCOUNT OF +2101 ADDRESSED TO THE SUBJECT +2102 DOUBLE-STRUCK CAPITAL C +2103 DEGREE CELSIUS +2104 CENTRE LINE SYMBOL +2105 CARE OF +2106 CADA UNA +2107 EULER CONSTANT +2108 SCRUPLE +2109 DEGREE FAHRENHEIT +210A SCRIPT SMALL G +210B SCRIPT CAPITAL H +210C BLACK-LETTER CAPITAL H +210D DOUBLE-STRUCK CAPITAL H +210E PLANCK CONSTANT +210F PLANCK CONSTANT OVER TWO PI +2110 SCRIPT CAPITAL I +2111 BLACK-LETTER CAPITAL I +2112 SCRIPT CAPITAL L +2113 SCRIPT SMALL L +2114 L B BAR SYMBOL +2115 DOUBLE-STRUCK CAPITAL N +2116 NUMERO SIGN +2117 SOUND RECORDING COPYRIGHT +2118 SCRIPT CAPITAL P +2119 DOUBLE-STRUCK CAPITAL P +211A DOUBLE-STRUCK CAPITAL Q +211B SCRIPT CAPITAL R +211C BLACK-LETTER CAPITAL R +211D DOUBLE-STRUCK CAPITAL R +211E PRESCRIPTION TAKE +211F RESPONSE +2120 SERVICE MARK +2121 TELEPHONE SIGN +2122 TRADE MARK SIGN +2123 VERSICLE +2124 DOUBLE-STRUCK CAPITAL Z +2125 OUNCE SIGN +2126 OHM SIGN +2127 INVERTED OHM SIGN +2128 BLACK-LETTER CAPITAL Z +2129 TURNED GREEK SMALL LETTER IOTA +212A KELVIN SIGN +212B ANGSTROM SIGN +212C SCRIPT CAPITAL B +212D BLACK-LETTER CAPITAL C +212E ESTIMATED SYMBOL +212F SCRIPT SMALL E +2130 SCRIPT CAPITAL E +2131 SCRIPT CAPITAL F +2132 TURNED CAPITAL F +2133 SCRIPT CAPITAL M +2134 SCRIPT SMALL O +2135 ALEF SYMBOL +2136 BET SYMBOL +2137 GIMEL SYMBOL +2138 DALET SYMBOL +2139 INFORMATION SOURCE +213A ROTATED CAPITAL Q +213D DOUBLE-STRUCK SMALL GAMMA +213E DOUBLE-STRUCK CAPITAL GAMMA +213F DOUBLE-STRUCK CAPITAL PI +2140 DOUBLE-STRUCK N-ARY SUMMATION +2141 TURNED SANS-SERIF CAPITAL G +2142 TURNED SANS-SERIF CAPITAL L +2143 REVERSED SANS-SERIF CAPITAL L +2144 TURNED SANS-SERIF CAPITAL Y +2145 DOUBLE-STRUCK ITALIC CAPITAL D +2146 DOUBLE-STRUCK ITALIC SMALL D +2147 DOUBLE-STRUCK ITALIC SMALL E +2148 DOUBLE-STRUCK ITALIC SMALL I +2149 DOUBLE-STRUCK ITALIC SMALL J +214A PROPERTY LINE +214B TURNED AMPERSAND +2153 VULGAR FRACTION ONE THIRD +2154 VULGAR FRACTION TWO THIRDS +2155 VULGAR FRACTION ONE FIFTH +2156 VULGAR FRACTION TWO FIFTHS +2157 VULGAR FRACTION THREE FIFTHS +2158 VULGAR FRACTION FOUR FIFTHS +2159 VULGAR FRACTION ONE SIXTH +215A VULGAR FRACTION FIVE SIXTHS +215B VULGAR FRACTION ONE EIGHTH +215C VULGAR FRACTION THREE EIGHTHS +215D VULGAR FRACTION FIVE EIGHTHS +215E VULGAR FRACTION SEVEN EIGHTHS +215F FRACTION NUMERATOR ONE +2160 ROMAN NUMERAL ONE +2161 ROMAN NUMERAL TWO +2162 ROMAN NUMERAL THREE +2163 ROMAN NUMERAL FOUR +2164 ROMAN NUMERAL FIVE +2165 ROMAN NUMERAL SIX +2166 ROMAN NUMERAL SEVEN +2167 ROMAN NUMERAL EIGHT +2168 ROMAN NUMERAL NINE +2169 ROMAN NUMERAL TEN +216A ROMAN NUMERAL ELEVEN +216B ROMAN NUMERAL TWELVE +216C ROMAN NUMERAL FIFTY +216D ROMAN NUMERAL ONE HUNDRED +216E ROMAN NUMERAL FIVE HUNDRED +216F ROMAN NUMERAL ONE THOUSAND +2170 SMALL ROMAN NUMERAL ONE +2171 SMALL ROMAN NUMERAL TWO +2172 SMALL ROMAN NUMERAL THREE +2173 SMALL ROMAN NUMERAL FOUR +2174 SMALL ROMAN NUMERAL FIVE +2175 SMALL ROMAN NUMERAL SIX +2176 SMALL ROMAN NUMERAL SEVEN +2177 SMALL ROMAN NUMERAL EIGHT +2178 SMALL ROMAN NUMERAL NINE +2179 SMALL ROMAN NUMERAL TEN +217A SMALL ROMAN NUMERAL ELEVEN +217B SMALL ROMAN NUMERAL TWELVE +217C SMALL ROMAN NUMERAL FIFTY +217D SMALL ROMAN NUMERAL ONE HUNDRED +217E SMALL ROMAN NUMERAL FIVE HUNDRED +217F SMALL ROMAN NUMERAL ONE THOUSAND +2180 ROMAN NUMERAL ONE THOUSAND C D +2181 ROMAN NUMERAL FIVE THOUSAND +2182 ROMAN NUMERAL TEN THOUSAND +2183 ROMAN NUMERAL REVERSED ONE HUNDRED +2190 LEFTWARDS ARROW +2191 UPWARDS ARROW +2192 RIGHTWARDS ARROW +2193 DOWNWARDS ARROW +2194 LEFT RIGHT ARROW +2195 UP DOWN ARROW +2196 NORTH WEST ARROW +2197 NORTH EAST ARROW +2198 SOUTH EAST ARROW +2199 SOUTH WEST ARROW +219A LEFTWARDS ARROW WITH STROKE +219B RIGHTWARDS ARROW WITH STROKE +219C LEFTWARDS WAVE ARROW +219D RIGHTWARDS WAVE ARROW +219E LEFTWARDS TWO HEADED ARROW +219F UPWARDS TWO HEADED ARROW +21A0 RIGHTWARDS TWO HEADED ARROW +21A1 DOWNWARDS TWO HEADED ARROW +21A2 LEFTWARDS ARROW WITH TAIL +21A3 RIGHTWARDS ARROW WITH TAIL +21A4 LEFTWARDS ARROW FROM BAR +21A5 UPWARDS ARROW FROM BAR +21A6 RIGHTWARDS ARROW FROM BAR +21A7 DOWNWARDS ARROW FROM BAR +21A8 UP DOWN ARROW WITH BASE +21A9 LEFTWARDS ARROW WITH HOOK +21AA RIGHTWARDS ARROW WITH HOOK +21AB LEFTWARDS ARROW WITH LOOP +21AC RIGHTWARDS ARROW WITH LOOP +21AD LEFT RIGHT WAVE ARROW +21AE LEFT RIGHT ARROW WITH STROKE +21AF DOWNWARDS ZIGZAG ARROW +21B0 UPWARDS ARROW WITH TIP LEFTWARDS +21B1 UPWARDS ARROW WITH TIP RIGHTWARDS +21B2 DOWNWARDS ARROW WITH TIP LEFTWARDS +21B3 DOWNWARDS ARROW WITH TIP RIGHTWARDS +21B4 RIGHTWARDS ARROW WITH CORNER DOWNWARDS +21B5 DOWNWARDS ARROW WITH CORNER LEFTWARDS +21B6 ANTICLOCKWISE TOP SEMICIRCLE ARROW +21B7 CLOCKWISE TOP SEMICIRCLE ARROW +21B8 NORTH WEST ARROW TO LONG BAR +21B9 LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR +21BA ANTICLOCKWISE OPEN CIRCLE ARROW +21BB CLOCKWISE OPEN CIRCLE ARROW +21BC LEFTWARDS HARPOON WITH BARB UPWARDS +21BD LEFTWARDS HARPOON WITH BARB DOWNWARDS +21BE UPWARDS HARPOON WITH BARB RIGHTWARDS +21BF UPWARDS HARPOON WITH BARB LEFTWARDS +21C0 RIGHTWARDS HARPOON WITH BARB UPWARDS +21C1 RIGHTWARDS HARPOON WITH BARB DOWNWARDS +21C2 DOWNWARDS HARPOON WITH BARB RIGHTWARDS +21C3 DOWNWARDS HARPOON WITH BARB LEFTWARDS +21C4 RIGHTWARDS ARROW OVER LEFTWARDS ARROW +21C5 UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW +21C6 LEFTWARDS ARROW OVER RIGHTWARDS ARROW +21C7 LEFTWARDS PAIRED ARROWS +21C8 UPWARDS PAIRED ARROWS +21C9 RIGHTWARDS PAIRED ARROWS +21CA DOWNWARDS PAIRED ARROWS +21CB LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON +21CC RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON +21CD LEFTWARDS DOUBLE ARROW WITH STROKE +21CE LEFT RIGHT DOUBLE ARROW WITH STROKE +21CF RIGHTWARDS DOUBLE ARROW WITH STROKE +21D0 LEFTWARDS DOUBLE ARROW +21D1 UPWARDS DOUBLE ARROW +21D2 RIGHTWARDS DOUBLE ARROW +21D3 DOWNWARDS DOUBLE ARROW +21D4 LEFT RIGHT DOUBLE ARROW +21D5 UP DOWN DOUBLE ARROW +21D6 NORTH WEST DOUBLE ARROW +21D7 NORTH EAST DOUBLE ARROW +21D8 SOUTH EAST DOUBLE ARROW +21D9 SOUTH WEST DOUBLE ARROW +21DA LEFTWARDS TRIPLE ARROW +21DB RIGHTWARDS TRIPLE ARROW +21DC LEFTWARDS SQUIGGLE ARROW +21DD RIGHTWARDS SQUIGGLE ARROW +21DE UPWARDS ARROW WITH DOUBLE STROKE +21DF DOWNWARDS ARROW WITH DOUBLE STROKE +21E0 LEFTWARDS DASHED ARROW +21E1 UPWARDS DASHED ARROW +21E2 RIGHTWARDS DASHED ARROW +21E3 DOWNWARDS DASHED ARROW +21E4 LEFTWARDS ARROW TO BAR +21E5 RIGHTWARDS ARROW TO BAR +21E6 LEFTWARDS WHITE ARROW +21E7 UPWARDS WHITE ARROW +21E8 RIGHTWARDS WHITE ARROW +21E9 DOWNWARDS WHITE ARROW +21EA UPWARDS WHITE ARROW FROM BAR +21EB UPWARDS WHITE ARROW ON PEDESTAL +21EC UPWARDS WHITE ARROW ON PEDESTAL WITH HORIZONTAL BAR +21ED UPWARDS WHITE ARROW ON PEDESTAL WITH VERTICAL BAR +21EE UPWARDS WHITE DOUBLE ARROW +21EF UPWARDS WHITE DOUBLE ARROW ON PEDESTAL +21F0 RIGHTWARDS WHITE ARROW FROM WALL +21F1 NORTH WEST ARROW TO CORNER +21F2 SOUTH EAST ARROW TO CORNER +21F3 UP DOWN WHITE ARROW +21F4 RIGHT ARROW WITH SMALL CIRCLE +21F5 DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW +21F6 THREE RIGHTWARDS ARROWS +21F7 LEFTWARDS ARROW WITH VERTICAL STROKE +21F8 RIGHTWARDS ARROW WITH VERTICAL STROKE +21F9 LEFT RIGHT ARROW WITH VERTICAL STROKE +21FA LEFTWARDS ARROW WITH DOUBLE VERTICAL STROKE +21FB RIGHTWARDS ARROW WITH DOUBLE VERTICAL STROKE +21FC LEFT RIGHT ARROW WITH DOUBLE VERTICAL STROKE +21FD LEFTWARDS OPEN-HEADED ARROW +21FE RIGHTWARDS OPEN-HEADED ARROW +21FF LEFT RIGHT OPEN-HEADED ARROW +2200 FOR ALL +2201 COMPLEMENT +2202 PARTIAL DIFFERENTIAL +2203 THERE EXISTS +2204 THERE DOES NOT EXIST +2205 EMPTY SET +2206 INCREMENT +2207 NABLA +2208 ELEMENT OF +2209 NOT AN ELEMENT OF +220A SMALL ELEMENT OF +220B CONTAINS AS MEMBER +220C DOES NOT CONTAIN AS MEMBER +220D SMALL CONTAINS AS MEMBER +220E END OF PROOF +220F N-ARY PRODUCT +2210 N-ARY COPRODUCT +2211 N-ARY SUMMATION +2212 MINUS SIGN +2213 MINUS-OR-PLUS SIGN +2214 DOT PLUS +2215 DIVISION SLASH +2216 SET MINUS +2217 ASTERISK OPERATOR +2218 RING OPERATOR +2219 BULLET OPERATOR +221A SQUARE ROOT +221B CUBE ROOT +221C FOURTH ROOT +221D PROPORTIONAL TO +221E INFINITY +221F RIGHT ANGLE +2220 ANGLE +2221 MEASURED ANGLE +2222 SPHERICAL ANGLE +2223 DIVIDES +2224 DOES NOT DIVIDE +2225 PARALLEL TO +2226 NOT PARALLEL TO +2227 LOGICAL AND +2228 LOGICAL OR +2229 INTERSECTION +222A UNION +222B INTEGRAL +222C DOUBLE INTEGRAL +222D TRIPLE INTEGRAL +222E CONTOUR INTEGRAL +222F SURFACE INTEGRAL +2230 VOLUME INTEGRAL +2231 CLOCKWISE INTEGRAL +2232 CLOCKWISE CONTOUR INTEGRAL +2233 ANTICLOCKWISE CONTOUR INTEGRAL +2234 THEREFORE +2235 BECAUSE +2236 RATIO +2237 PROPORTION +2238 DOT MINUS +2239 EXCESS +223A GEOMETRIC PROPORTION +223B HOMOTHETIC +223C TILDE OPERATOR +223D REVERSED TILDE +223E INVERTED LAZY S +223F SINE WAVE +2240 WREATH PRODUCT +2241 NOT TILDE +2242 MINUS TILDE +2243 ASYMPTOTICALLY EQUAL TO +2244 NOT ASYMPTOTICALLY EQUAL TO +2245 APPROXIMATELY EQUAL TO +2246 APPROXIMATELY BUT NOT ACTUALLY EQUAL TO +2247 NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO +2248 ALMOST EQUAL TO +2249 NOT ALMOST EQUAL TO +224A ALMOST EQUAL OR EQUAL TO +224B TRIPLE TILDE +224C ALL EQUAL TO +224D EQUIVALENT TO +224E GEOMETRICALLY EQUIVALENT TO +224F DIFFERENCE BETWEEN +2250 APPROACHES THE LIMIT +2251 GEOMETRICALLY EQUAL TO +2252 APPROXIMATELY EQUAL TO OR THE IMAGE OF +2253 IMAGE OF OR APPROXIMATELY EQUAL TO +2254 COLON EQUALS +2255 EQUALS COLON +2256 RING IN EQUAL TO +2257 RING EQUAL TO +2258 CORRESPONDS TO +2259 ESTIMATES +225A EQUIANGULAR TO +225B STAR EQUALS +225C DELTA EQUAL TO +225D EQUAL TO BY DEFINITION +225E MEASURED BY +225F QUESTIONED EQUAL TO +2260 NOT EQUAL TO +2261 IDENTICAL TO +2262 NOT IDENTICAL TO +2263 STRICTLY EQUIVALENT TO +2264 LESS-THAN OR EQUAL TO +2265 GREATER-THAN OR EQUAL TO +2266 LESS-THAN OVER EQUAL TO +2267 GREATER-THAN OVER EQUAL TO +2268 LESS-THAN BUT NOT EQUAL TO +2269 GREATER-THAN BUT NOT EQUAL TO +226A MUCH LESS-THAN +226B MUCH GREATER-THAN +226C BETWEEN +226D NOT EQUIVALENT TO +226E NOT LESS-THAN +226F NOT GREATER-THAN +2270 NEITHER LESS-THAN NOR EQUAL TO +2271 NEITHER GREATER-THAN NOR EQUAL TO +2272 LESS-THAN OR EQUIVALENT TO +2273 GREATER-THAN OR EQUIVALENT TO +2274 NEITHER LESS-THAN NOR EQUIVALENT TO +2275 NEITHER GREATER-THAN NOR EQUIVALENT TO +2276 LESS-THAN OR GREATER-THAN +2277 GREATER-THAN OR LESS-THAN +2278 NEITHER LESS-THAN NOR GREATER-THAN +2279 NEITHER GREATER-THAN NOR LESS-THAN +227A PRECEDES +227B SUCCEEDS +227C PRECEDES OR EQUAL TO +227D SUCCEEDS OR EQUAL TO +227E PRECEDES OR EQUIVALENT TO +227F SUCCEEDS OR EQUIVALENT TO +2280 DOES NOT PRECEDE +2281 DOES NOT SUCCEED +2282 SUBSET OF +2283 SUPERSET OF +2284 NOT A SUBSET OF +2285 NOT A SUPERSET OF +2286 SUBSET OF OR EQUAL TO +2287 SUPERSET OF OR EQUAL TO +2288 NEITHER A SUBSET OF NOR EQUAL TO +2289 NEITHER A SUPERSET OF NOR EQUAL TO +228A SUBSET OF WITH NOT EQUAL TO +228B SUPERSET OF WITH NOT EQUAL TO +228C MULTISET +228D MULTISET MULTIPLICATION +228E MULTISET UNION +228F SQUARE IMAGE OF +2290 SQUARE ORIGINAL OF +2291 SQUARE IMAGE OF OR EQUAL TO +2292 SQUARE ORIGINAL OF OR EQUAL TO +2293 SQUARE CAP +2294 SQUARE CUP +2295 CIRCLED PLUS +2296 CIRCLED MINUS +2297 CIRCLED TIMES +2298 CIRCLED DIVISION SLASH +2299 CIRCLED DOT OPERATOR +229A CIRCLED RING OPERATOR +229B CIRCLED ASTERISK OPERATOR +229C CIRCLED EQUALS +229D CIRCLED DASH +229E SQUARED PLUS +229F SQUARED MINUS +22A0 SQUARED TIMES +22A1 SQUARED DOT OPERATOR +22A2 RIGHT TACK +22A3 LEFT TACK +22A4 DOWN TACK +22A5 UP TACK +22A6 ASSERTION +22A7 MODELS +22A8 TRUE +22A9 FORCES +22AA TRIPLE VERTICAL BAR RIGHT TURNSTILE +22AB DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE +22AC DOES NOT PROVE +22AD NOT TRUE +22AE DOES NOT FORCE +22AF NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE +22B0 PRECEDES UNDER RELATION +22B1 SUCCEEDS UNDER RELATION +22B2 NORMAL SUBGROUP OF +22B3 CONTAINS AS NORMAL SUBGROUP +22B4 NORMAL SUBGROUP OF OR EQUAL TO +22B5 CONTAINS AS NORMAL SUBGROUP OR EQUAL TO +22B6 ORIGINAL OF +22B7 IMAGE OF +22B8 MULTIMAP +22B9 HERMITIAN CONJUGATE MATRIX +22BA INTERCALATE +22BB XOR +22BC NAND +22BD NOR +22BE RIGHT ANGLE WITH ARC +22BF RIGHT TRIANGLE +22C0 N-ARY LOGICAL AND +22C1 N-ARY LOGICAL OR +22C2 N-ARY INTERSECTION +22C3 N-ARY UNION +22C4 DIAMOND OPERATOR +22C5 DOT OPERATOR +22C6 STAR OPERATOR +22C7 DIVISION TIMES +22C8 BOWTIE +22C9 LEFT NORMAL FACTOR SEMIDIRECT PRODUCT +22CA RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT +22CB LEFT SEMIDIRECT PRODUCT +22CC RIGHT SEMIDIRECT PRODUCT +22CD REVERSED TILDE EQUALS +22CE CURLY LOGICAL OR +22CF CURLY LOGICAL AND +22D0 DOUBLE SUBSET +22D1 DOUBLE SUPERSET +22D2 DOUBLE INTERSECTION +22D3 DOUBLE UNION +22D4 PITCHFORK +22D5 EQUAL AND PARALLEL TO +22D6 LESS-THAN WITH DOT +22D7 GREATER-THAN WITH DOT +22D8 VERY MUCH LESS-THAN +22D9 VERY MUCH GREATER-THAN +22DA LESS-THAN EQUAL TO OR GREATER-THAN +22DB GREATER-THAN EQUAL TO OR LESS-THAN +22DC EQUAL TO OR LESS-THAN +22DD EQUAL TO OR GREATER-THAN +22DE EQUAL TO OR PRECEDES +22DF EQUAL TO OR SUCCEEDS +22E0 DOES NOT PRECEDE OR EQUAL +22E1 DOES NOT SUCCEED OR EQUAL +22E2 NOT SQUARE IMAGE OF OR EQUAL TO +22E3 NOT SQUARE ORIGINAL OF OR EQUAL TO +22E4 SQUARE IMAGE OF OR NOT EQUAL TO +22E5 SQUARE ORIGINAL OF OR NOT EQUAL TO +22E6 LESS-THAN BUT NOT EQUIVALENT TO +22E7 GREATER-THAN BUT NOT EQUIVALENT TO +22E8 PRECEDES BUT NOT EQUIVALENT TO +22E9 SUCCEEDS BUT NOT EQUIVALENT TO +22EA NOT NORMAL SUBGROUP OF +22EB DOES NOT CONTAIN AS NORMAL SUBGROUP +22EC NOT NORMAL SUBGROUP OF OR EQUAL TO +22ED DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL +22EE VERTICAL ELLIPSIS +22EF MIDLINE HORIZONTAL ELLIPSIS +22F0 UP RIGHT DIAGONAL ELLIPSIS +22F1 DOWN RIGHT DIAGONAL ELLIPSIS +22F2 ELEMENT OF WITH LONG HORIZONTAL STROKE +22F3 ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE +22F4 SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE +22F5 ELEMENT OF WITH DOT ABOVE +22F6 ELEMENT OF WITH OVERBAR +22F7 SMALL ELEMENT OF WITH OVERBAR +22F8 ELEMENT OF WITH UNDERBAR +22F9 ELEMENT OF WITH TWO HORIZONTAL STROKES +22FA CONTAINS WITH LONG HORIZONTAL STROKE +22FB CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE +22FC SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE +22FD CONTAINS WITH OVERBAR +22FE SMALL CONTAINS WITH OVERBAR +22FF Z NOTATION BAG MEMBERSHIP +2300 DIAMETER SIGN +2301 ELECTRIC ARROW +2302 HOUSE +2303 UP ARROWHEAD +2304 DOWN ARROWHEAD +2305 PROJECTIVE +2306 PERSPECTIVE +2307 WAVY LINE +2308 LEFT CEILING +2309 RIGHT CEILING +230A LEFT FLOOR +230B RIGHT FLOOR +230C BOTTOM RIGHT CROP +230D BOTTOM LEFT CROP +230E TOP RIGHT CROP +230F TOP LEFT CROP +2310 REVERSED NOT SIGN +2311 SQUARE LOZENGE +2312 ARC +2313 SEGMENT +2314 SECTOR +2315 TELEPHONE RECORDER +2316 POSITION INDICATOR +2317 VIEWDATA SQUARE +2318 PLACE OF INTEREST SIGN +2319 TURNED NOT SIGN +231A WATCH +231B HOURGLASS +231C TOP LEFT CORNER +231D TOP RIGHT CORNER +231E BOTTOM LEFT CORNER +231F BOTTOM RIGHT CORNER +2320 TOP HALF INTEGRAL +2321 BOTTOM HALF INTEGRAL +2322 FROWN +2323 SMILE +2324 UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS +2325 OPTION KEY +2326 ERASE TO THE RIGHT +2327 X IN A RECTANGLE BOX +2328 KEYBOARD +2329 LEFT-POINTING ANGLE BRACKET +232A RIGHT-POINTING ANGLE BRACKET +232B ERASE TO THE LEFT +232C BENZENE RING +232D CYLINDRICITY +232E ALL AROUND-PROFILE +232F SYMMETRY +2330 TOTAL RUNOUT +2331 DIMENSION ORIGIN +2332 CONICAL TAPER +2333 SLOPE +2334 COUNTERBORE +2335 COUNTERSINK +2336 APL FUNCTIONAL SYMBOL I-BEAM +2337 APL FUNCTIONAL SYMBOL SQUISH QUAD +2338 APL FUNCTIONAL SYMBOL QUAD EQUAL +2339 APL FUNCTIONAL SYMBOL QUAD DIVIDE +233A APL FUNCTIONAL SYMBOL QUAD DIAMOND +233B APL FUNCTIONAL SYMBOL QUAD JOT +233C APL FUNCTIONAL SYMBOL QUAD CIRCLE +233D APL FUNCTIONAL SYMBOL CIRCLE STILE +233E APL FUNCTIONAL SYMBOL CIRCLE JOT +233F APL FUNCTIONAL SYMBOL SLASH BAR +2340 APL FUNCTIONAL SYMBOL BACKSLASH BAR +2341 APL FUNCTIONAL SYMBOL QUAD SLASH +2342 APL FUNCTIONAL SYMBOL QUAD BACKSLASH +2343 APL FUNCTIONAL SYMBOL QUAD LESS-THAN +2344 APL FUNCTIONAL SYMBOL QUAD GREATER-THAN +2345 APL FUNCTIONAL SYMBOL LEFTWARDS VANE +2346 APL FUNCTIONAL SYMBOL RIGHTWARDS VANE +2347 APL FUNCTIONAL SYMBOL QUAD LEFTWARDS ARROW +2348 APL FUNCTIONAL SYMBOL QUAD RIGHTWARDS ARROW +2349 APL FUNCTIONAL SYMBOL CIRCLE BACKSLASH +234A APL FUNCTIONAL SYMBOL DOWN TACK UNDERBAR +234B APL FUNCTIONAL SYMBOL DELTA STILE +234C APL FUNCTIONAL SYMBOL QUAD DOWN CARET +234D APL FUNCTIONAL SYMBOL QUAD DELTA +234E APL FUNCTIONAL SYMBOL DOWN TACK JOT +234F APL FUNCTIONAL SYMBOL UPWARDS VANE +2350 APL FUNCTIONAL SYMBOL QUAD UPWARDS ARROW +2351 APL FUNCTIONAL SYMBOL UP TACK OVERBAR +2352 APL FUNCTIONAL SYMBOL DEL STILE +2353 APL FUNCTIONAL SYMBOL QUAD UP CARET +2354 APL FUNCTIONAL SYMBOL QUAD DEL +2355 APL FUNCTIONAL SYMBOL UP TACK JOT +2356 APL FUNCTIONAL SYMBOL DOWNWARDS VANE +2357 APL FUNCTIONAL SYMBOL QUAD DOWNWARDS ARROW +2358 APL FUNCTIONAL SYMBOL QUOTE UNDERBAR +2359 APL FUNCTIONAL SYMBOL DELTA UNDERBAR +235A APL FUNCTIONAL SYMBOL DIAMOND UNDERBAR +235B APL FUNCTIONAL SYMBOL JOT UNDERBAR +235C APL FUNCTIONAL SYMBOL CIRCLE UNDERBAR +235D APL FUNCTIONAL SYMBOL UP SHOE JOT +235E APL FUNCTIONAL SYMBOL QUOTE QUAD +235F APL FUNCTIONAL SYMBOL CIRCLE STAR +2360 APL FUNCTIONAL SYMBOL QUAD COLON +2361 APL FUNCTIONAL SYMBOL UP TACK DIAERESIS +2362 APL FUNCTIONAL SYMBOL DEL DIAERESIS +2363 APL FUNCTIONAL SYMBOL STAR DIAERESIS +2364 APL FUNCTIONAL SYMBOL JOT DIAERESIS +2365 APL FUNCTIONAL SYMBOL CIRCLE DIAERESIS +2366 APL FUNCTIONAL SYMBOL DOWN SHOE STILE +2367 APL FUNCTIONAL SYMBOL LEFT SHOE STILE +2368 APL FUNCTIONAL SYMBOL TILDE DIAERESIS +2369 APL FUNCTIONAL SYMBOL GREATER-THAN DIAERESIS +236A APL FUNCTIONAL SYMBOL COMMA BAR +236B APL FUNCTIONAL SYMBOL DEL TILDE +236C APL FUNCTIONAL SYMBOL ZILDE +236D APL FUNCTIONAL SYMBOL STILE TILDE +236E APL FUNCTIONAL SYMBOL SEMICOLON UNDERBAR +236F APL FUNCTIONAL SYMBOL QUAD NOT EQUAL +2370 APL FUNCTIONAL SYMBOL QUAD QUESTION +2371 APL FUNCTIONAL SYMBOL DOWN CARET TILDE +2372 APL FUNCTIONAL SYMBOL UP CARET TILDE +2373 APL FUNCTIONAL SYMBOL IOTA +2374 APL FUNCTIONAL SYMBOL RHO +2375 APL FUNCTIONAL SYMBOL OMEGA +2376 APL FUNCTIONAL SYMBOL ALPHA UNDERBAR +2377 APL FUNCTIONAL SYMBOL EPSILON UNDERBAR +2378 APL FUNCTIONAL SYMBOL IOTA UNDERBAR +2379 APL FUNCTIONAL SYMBOL OMEGA UNDERBAR +237A APL FUNCTIONAL SYMBOL ALPHA +237B NOT CHECK MARK +237C RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW +237D SHOULDERED OPEN BOX +237E BELL SYMBOL +237F VERTICAL LINE WITH MIDDLE DOT +2380 INSERTION SYMBOL +2381 CONTINUOUS UNDERLINE SYMBOL +2382 DISCONTINUOUS UNDERLINE SYMBOL +2383 EMPHASIS SYMBOL +2384 COMPOSITION SYMBOL +2385 WHITE SQUARE WITH CENTRE VERTICAL LINE +2386 ENTER SYMBOL +2387 ALTERNATIVE KEY SYMBOL +2388 HELM SYMBOL +2389 CIRCLED HORIZONTAL BAR WITH NOTCH +238A CIRCLED TRIANGLE DOWN +238B BROKEN CIRCLE WITH NORTHWEST ARROW +238C UNDO SYMBOL +238D MONOSTABLE SYMBOL +238E HYSTERESIS SYMBOL +238F OPEN-CIRCUIT-OUTPUT H-TYPE SYMBOL +2390 OPEN-CIRCUIT-OUTPUT L-TYPE SYMBOL +2391 PASSIVE-PULL-DOWN-OUTPUT SYMBOL +2392 PASSIVE-PULL-UP-OUTPUT SYMBOL +2393 DIRECT CURRENT SYMBOL FORM TWO +2394 SOFTWARE-FUNCTION SYMBOL +2395 APL FUNCTIONAL SYMBOL QUAD +2396 DECIMAL SEPARATOR KEY SYMBOL +2397 PREVIOUS PAGE +2398 NEXT PAGE +2399 PRINT SCREEN SYMBOL +239A CLEAR SCREEN SYMBOL +239B LEFT PARENTHESIS UPPER HOOK +239C LEFT PARENTHESIS EXTENSION +239D LEFT PARENTHESIS LOWER HOOK +239E RIGHT PARENTHESIS UPPER HOOK +239F RIGHT PARENTHESIS EXTENSION +23A0 RIGHT PARENTHESIS LOWER HOOK +23A1 LEFT SQUARE BRACKET UPPER CORNER +23A2 LEFT SQUARE BRACKET EXTENSION +23A3 LEFT SQUARE BRACKET LOWER CORNER +23A4 RIGHT SQUARE BRACKET UPPER CORNER +23A5 RIGHT SQUARE BRACKET EXTENSION +23A6 RIGHT SQUARE BRACKET LOWER CORNER +23A7 LEFT CURLY BRACKET UPPER HOOK +23A8 LEFT CURLY BRACKET MIDDLE PIECE +23A9 LEFT CURLY BRACKET LOWER HOOK +23AA CURLY BRACKET EXTENSION +23AB RIGHT CURLY BRACKET UPPER HOOK +23AC RIGHT CURLY BRACKET MIDDLE PIECE +23AD RIGHT CURLY BRACKET LOWER HOOK +23AE INTEGRAL EXTENSION +23AF HORIZONTAL LINE EXTENSION +23B0 UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION +23B1 UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION +23B2 SUMMATION TOP +23B3 SUMMATION BOTTOM +23B4 TOP SQUARE BRACKET +23B5 BOTTOM SQUARE BRACKET +23B6 BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET +23B7 RADICAL SYMBOL BOTTOM +23B8 LEFT VERTICAL BOX LINE +23B9 RIGHT VERTICAL BOX LINE +23BA HORIZONTAL SCAN LINE-1 +23BB HORIZONTAL SCAN LINE-3 +23BC HORIZONTAL SCAN LINE-7 +23BD HORIZONTAL SCAN LINE-9 +23BE DENTISTRY SYMBOL LIGHT VERTICAL AND TOP RIGHT +23BF DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM RIGHT +23C0 DENTISTRY SYMBOL LIGHT VERTICAL WITH CIRCLE +23C1 DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH CIRCLE +23C2 DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH CIRCLE +23C3 DENTISTRY SYMBOL LIGHT VERTICAL WITH TRIANGLE +23C4 DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH TRIANGLE +23C5 DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH TRIANGLE +23C6 DENTISTRY SYMBOL LIGHT VERTICAL AND WAVE +23C7 DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH WAVE +23C8 DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH WAVE +23C9 DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL +23CA DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL +23CB DENTISTRY SYMBOL LIGHT VERTICAL AND TOP LEFT +23CC DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM LEFT +23CD SQUARE FOOT +23CE RETURN SYMBOL +2400 SYMBOL FOR NULL +2401 SYMBOL FOR START OF HEADING +2402 SYMBOL FOR START OF TEXT +2403 SYMBOL FOR END OF TEXT +2404 SYMBOL FOR END OF TRANSMISSION +2405 SYMBOL FOR ENQUIRY +2406 SYMBOL FOR ACKNOWLEDGE +2407 SYMBOL FOR BELL +2408 SYMBOL FOR BACKSPACE +2409 SYMBOL FOR HORIZONTAL TABULATION +240A SYMBOL FOR LINE FEED +240B SYMBOL FOR VERTICAL TABULATION +240C SYMBOL FOR FORM FEED +240D SYMBOL FOR CARRIAGE RETURN +240E SYMBOL FOR SHIFT OUT +240F SYMBOL FOR SHIFT IN +2410 SYMBOL FOR DATA LINK ESCAPE +2411 SYMBOL FOR DEVICE CONTROL ONE +2412 SYMBOL FOR DEVICE CONTROL TWO +2413 SYMBOL FOR DEVICE CONTROL THREE +2414 SYMBOL FOR DEVICE CONTROL FOUR +2415 SYMBOL FOR NEGATIVE ACKNOWLEDGE +2416 SYMBOL FOR SYNCHRONOUS IDLE +2417 SYMBOL FOR END OF TRANSMISSION BLOCK +2418 SYMBOL FOR CANCEL +2419 SYMBOL FOR END OF MEDIUM +241A SYMBOL FOR SUBSTITUTE +241B SYMBOL FOR ESCAPE +241C SYMBOL FOR FILE SEPARATOR +241D SYMBOL FOR GROUP SEPARATOR +241E SYMBOL FOR RECORD SEPARATOR +241F SYMBOL FOR UNIT SEPARATOR +2420 SYMBOL FOR SPACE +2421 SYMBOL FOR DELETE +2422 BLANK SYMBOL +2423 OPEN BOX +2424 SYMBOL FOR NEWLINE +2425 SYMBOL FOR DELETE FORM TWO +2426 SYMBOL FOR SUBSTITUTE FORM TWO +2440 OCR HOOK +2441 OCR CHAIR +2442 OCR FORK +2443 OCR INVERTED FORK +2444 OCR BELT BUCKLE +2445 OCR BOW TIE +2446 OCR BRANCH BANK IDENTIFICATION +2447 OCR AMOUNT OF CHECK +2448 OCR DASH +2449 OCR CUSTOMER ACCOUNT NUMBER +244A OCR DOUBLE BACKSLASH +2460 CIRCLED DIGIT ONE +2461 CIRCLED DIGIT TWO +2462 CIRCLED DIGIT THREE +2463 CIRCLED DIGIT FOUR +2464 CIRCLED DIGIT FIVE +2465 CIRCLED DIGIT SIX +2466 CIRCLED DIGIT SEVEN +2467 CIRCLED DIGIT EIGHT +2468 CIRCLED DIGIT NINE +2469 CIRCLED NUMBER TEN +246A CIRCLED NUMBER ELEVEN +246B CIRCLED NUMBER TWELVE +246C CIRCLED NUMBER THIRTEEN +246D CIRCLED NUMBER FOURTEEN +246E CIRCLED NUMBER FIFTEEN +246F CIRCLED NUMBER SIXTEEN +2470 CIRCLED NUMBER SEVENTEEN +2471 CIRCLED NUMBER EIGHTEEN +2472 CIRCLED NUMBER NINETEEN +2473 CIRCLED NUMBER TWENTY +2474 PARENTHESIZED DIGIT ONE +2475 PARENTHESIZED DIGIT TWO +2476 PARENTHESIZED DIGIT THREE +2477 PARENTHESIZED DIGIT FOUR +2478 PARENTHESIZED DIGIT FIVE +2479 PARENTHESIZED DIGIT SIX +247A PARENTHESIZED DIGIT SEVEN +247B PARENTHESIZED DIGIT EIGHT +247C PARENTHESIZED DIGIT NINE +247D PARENTHESIZED NUMBER TEN +247E PARENTHESIZED NUMBER ELEVEN +247F PARENTHESIZED NUMBER TWELVE +2480 PARENTHESIZED NUMBER THIRTEEN +2481 PARENTHESIZED NUMBER FOURTEEN +2482 PARENTHESIZED NUMBER FIFTEEN +2483 PARENTHESIZED NUMBER SIXTEEN +2484 PARENTHESIZED NUMBER SEVENTEEN +2485 PARENTHESIZED NUMBER EIGHTEEN +2486 PARENTHESIZED NUMBER NINETEEN +2487 PARENTHESIZED NUMBER TWENTY +2488 DIGIT ONE FULL STOP +2489 DIGIT TWO FULL STOP +248A DIGIT THREE FULL STOP +248B DIGIT FOUR FULL STOP +248C DIGIT FIVE FULL STOP +248D DIGIT SIX FULL STOP +248E DIGIT SEVEN FULL STOP +248F DIGIT EIGHT FULL STOP +2490 DIGIT NINE FULL STOP +2491 NUMBER TEN FULL STOP +2492 NUMBER ELEVEN FULL STOP +2493 NUMBER TWELVE FULL STOP +2494 NUMBER THIRTEEN FULL STOP +2495 NUMBER FOURTEEN FULL STOP +2496 NUMBER FIFTEEN FULL STOP +2497 NUMBER SIXTEEN FULL STOP +2498 NUMBER SEVENTEEN FULL STOP +2499 NUMBER EIGHTEEN FULL STOP +249A NUMBER NINETEEN FULL STOP +249B NUMBER TWENTY FULL STOP +249C PARENTHESIZED LATIN SMALL LETTER A +249D PARENTHESIZED LATIN SMALL LETTER B +249E PARENTHESIZED LATIN SMALL LETTER C +249F PARENTHESIZED LATIN SMALL LETTER D +24A0 PARENTHESIZED LATIN SMALL LETTER E +24A1 PARENTHESIZED LATIN SMALL LETTER F +24A2 PARENTHESIZED LATIN SMALL LETTER G +24A3 PARENTHESIZED LATIN SMALL LETTER H +24A4 PARENTHESIZED LATIN SMALL LETTER I +24A5 PARENTHESIZED LATIN SMALL LETTER J +24A6 PARENTHESIZED LATIN SMALL LETTER K +24A7 PARENTHESIZED LATIN SMALL LETTER L +24A8 PARENTHESIZED LATIN SMALL LETTER M +24A9 PARENTHESIZED LATIN SMALL LETTER N +24AA PARENTHESIZED LATIN SMALL LETTER O +24AB PARENTHESIZED LATIN SMALL LETTER P +24AC PARENTHESIZED LATIN SMALL LETTER Q +24AD PARENTHESIZED LATIN SMALL LETTER R +24AE PARENTHESIZED LATIN SMALL LETTER S +24AF PARENTHESIZED LATIN SMALL LETTER T +24B0 PARENTHESIZED LATIN SMALL LETTER U +24B1 PARENTHESIZED LATIN SMALL LETTER V +24B2 PARENTHESIZED LATIN SMALL LETTER W +24B3 PARENTHESIZED LATIN SMALL LETTER X +24B4 PARENTHESIZED LATIN SMALL LETTER Y +24B5 PARENTHESIZED LATIN SMALL LETTER Z +24B6 CIRCLED LATIN CAPITAL LETTER A +24B7 CIRCLED LATIN CAPITAL LETTER B +24B8 CIRCLED LATIN CAPITAL LETTER C +24B9 CIRCLED LATIN CAPITAL LETTER D +24BA CIRCLED LATIN CAPITAL LETTER E +24BB CIRCLED LATIN CAPITAL LETTER F +24BC CIRCLED LATIN CAPITAL LETTER G +24BD CIRCLED LATIN CAPITAL LETTER H +24BE CIRCLED LATIN CAPITAL LETTER I +24BF CIRCLED LATIN CAPITAL LETTER J +24C0 CIRCLED LATIN CAPITAL LETTER K +24C1 CIRCLED LATIN CAPITAL LETTER L +24C2 CIRCLED LATIN CAPITAL LETTER M +24C3 CIRCLED LATIN CAPITAL LETTER N +24C4 CIRCLED LATIN CAPITAL LETTER O +24C5 CIRCLED LATIN CAPITAL LETTER P +24C6 CIRCLED LATIN CAPITAL LETTER Q +24C7 CIRCLED LATIN CAPITAL LETTER R +24C8 CIRCLED LATIN CAPITAL LETTER S +24C9 CIRCLED LATIN CAPITAL LETTER T +24CA CIRCLED LATIN CAPITAL LETTER U +24CB CIRCLED LATIN CAPITAL LETTER V +24CC CIRCLED LATIN CAPITAL LETTER W +24CD CIRCLED LATIN CAPITAL LETTER X +24CE CIRCLED LATIN CAPITAL LETTER Y +24CF CIRCLED LATIN CAPITAL LETTER Z +24D0 CIRCLED LATIN SMALL LETTER A +24D1 CIRCLED LATIN SMALL LETTER B +24D2 CIRCLED LATIN SMALL LETTER C +24D3 CIRCLED LATIN SMALL LETTER D +24D4 CIRCLED LATIN SMALL LETTER E +24D5 CIRCLED LATIN SMALL LETTER F +24D6 CIRCLED LATIN SMALL LETTER G +24D7 CIRCLED LATIN SMALL LETTER H +24D8 CIRCLED LATIN SMALL LETTER I +24D9 CIRCLED LATIN SMALL LETTER J +24DA CIRCLED LATIN SMALL LETTER K +24DB CIRCLED LATIN SMALL LETTER L +24DC CIRCLED LATIN SMALL LETTER M +24DD CIRCLED LATIN SMALL LETTER N +24DE CIRCLED LATIN SMALL LETTER O +24DF CIRCLED LATIN SMALL LETTER P +24E0 CIRCLED LATIN SMALL LETTER Q +24E1 CIRCLED LATIN SMALL LETTER R +24E2 CIRCLED LATIN SMALL LETTER S +24E3 CIRCLED LATIN SMALL LETTER T +24E4 CIRCLED LATIN SMALL LETTER U +24E5 CIRCLED LATIN SMALL LETTER V +24E6 CIRCLED LATIN SMALL LETTER W +24E7 CIRCLED LATIN SMALL LETTER X +24E8 CIRCLED LATIN SMALL LETTER Y +24E9 CIRCLED LATIN SMALL LETTER Z +24EA CIRCLED DIGIT ZERO +24EB NEGATIVE CIRCLED NUMBER ELEVEN +24EC NEGATIVE CIRCLED NUMBER TWELVE +24ED NEGATIVE CIRCLED NUMBER THIRTEEN +24EE NEGATIVE CIRCLED NUMBER FOURTEEN +24EF NEGATIVE CIRCLED NUMBER FIFTEEN +24F0 NEGATIVE CIRCLED NUMBER SIXTEEN +24F1 NEGATIVE CIRCLED NUMBER SEVENTEEN +24F2 NEGATIVE CIRCLED NUMBER EIGHTEEN +24F3 NEGATIVE CIRCLED NUMBER NINETEEN +24F4 NEGATIVE CIRCLED NUMBER TWENTY +24F5 DOUBLE CIRCLED DIGIT ONE +24F6 DOUBLE CIRCLED DIGIT TWO +24F7 DOUBLE CIRCLED DIGIT THREE +24F8 DOUBLE CIRCLED DIGIT FOUR +24F9 DOUBLE CIRCLED DIGIT FIVE +24FA DOUBLE CIRCLED DIGIT SIX +24FB DOUBLE CIRCLED DIGIT SEVEN +24FC DOUBLE CIRCLED DIGIT EIGHT +24FD DOUBLE CIRCLED DIGIT NINE +24FE DOUBLE CIRCLED NUMBER TEN +2500 BOX DRAWINGS LIGHT HORIZONTAL +2501 BOX DRAWINGS HEAVY HORIZONTAL +2502 BOX DRAWINGS LIGHT VERTICAL +2503 BOX DRAWINGS HEAVY VERTICAL +2504 BOX DRAWINGS LIGHT TRIPLE DASH HORIZONTAL +2505 BOX DRAWINGS HEAVY TRIPLE DASH HORIZONTAL +2506 BOX DRAWINGS LIGHT TRIPLE DASH VERTICAL +2507 BOX DRAWINGS HEAVY TRIPLE DASH VERTICAL +2508 BOX DRAWINGS LIGHT QUADRUPLE DASH HORIZONTAL +2509 BOX DRAWINGS HEAVY QUADRUPLE DASH HORIZONTAL +250A BOX DRAWINGS LIGHT QUADRUPLE DASH VERTICAL +250B BOX DRAWINGS HEAVY QUADRUPLE DASH VERTICAL +250C BOX DRAWINGS LIGHT DOWN AND RIGHT +250D BOX DRAWINGS DOWN LIGHT AND RIGHT HEAVY +250E BOX DRAWINGS DOWN HEAVY AND RIGHT LIGHT +250F BOX DRAWINGS HEAVY DOWN AND RIGHT +2510 BOX DRAWINGS LIGHT DOWN AND LEFT +2511 BOX DRAWINGS DOWN LIGHT AND LEFT HEAVY +2512 BOX DRAWINGS DOWN HEAVY AND LEFT LIGHT +2513 BOX DRAWINGS HEAVY DOWN AND LEFT +2514 BOX DRAWINGS LIGHT UP AND RIGHT +2515 BOX DRAWINGS UP LIGHT AND RIGHT HEAVY +2516 BOX DRAWINGS UP HEAVY AND RIGHT LIGHT +2517 BOX DRAWINGS HEAVY UP AND RIGHT +2518 BOX DRAWINGS LIGHT UP AND LEFT +2519 BOX DRAWINGS UP LIGHT AND LEFT HEAVY +251A BOX DRAWINGS UP HEAVY AND LEFT LIGHT +251B BOX DRAWINGS HEAVY UP AND LEFT +251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT +251D BOX DRAWINGS VERTICAL LIGHT AND RIGHT HEAVY +251E BOX DRAWINGS UP HEAVY AND RIGHT DOWN LIGHT +251F BOX DRAWINGS DOWN HEAVY AND RIGHT UP LIGHT +2520 BOX DRAWINGS VERTICAL HEAVY AND RIGHT LIGHT +2521 BOX DRAWINGS DOWN LIGHT AND RIGHT UP HEAVY +2522 BOX DRAWINGS UP LIGHT AND RIGHT DOWN HEAVY +2523 BOX DRAWINGS HEAVY VERTICAL AND RIGHT +2524 BOX DRAWINGS LIGHT VERTICAL AND LEFT +2525 BOX DRAWINGS VERTICAL LIGHT AND LEFT HEAVY +2526 BOX DRAWINGS UP HEAVY AND LEFT DOWN LIGHT +2527 BOX DRAWINGS DOWN HEAVY AND LEFT UP LIGHT +2528 BOX DRAWINGS VERTICAL HEAVY AND LEFT LIGHT +2529 BOX DRAWINGS DOWN LIGHT AND LEFT UP HEAVY +252A BOX DRAWINGS UP LIGHT AND LEFT DOWN HEAVY +252B BOX DRAWINGS HEAVY VERTICAL AND LEFT +252C BOX DRAWINGS LIGHT DOWN AND HORIZONTAL +252D BOX DRAWINGS LEFT HEAVY AND RIGHT DOWN LIGHT +252E BOX DRAWINGS RIGHT HEAVY AND LEFT DOWN LIGHT +252F BOX DRAWINGS DOWN LIGHT AND HORIZONTAL HEAVY +2530 BOX DRAWINGS DOWN HEAVY AND HORIZONTAL LIGHT +2531 BOX DRAWINGS RIGHT LIGHT AND LEFT DOWN HEAVY +2532 BOX DRAWINGS LEFT LIGHT AND RIGHT DOWN HEAVY +2533 BOX DRAWINGS HEAVY DOWN AND HORIZONTAL +2534 BOX DRAWINGS LIGHT UP AND HORIZONTAL +2535 BOX DRAWINGS LEFT HEAVY AND RIGHT UP LIGHT +2536 BOX DRAWINGS RIGHT HEAVY AND LEFT UP LIGHT +2537 BOX DRAWINGS UP LIGHT AND HORIZONTAL HEAVY +2538 BOX DRAWINGS UP HEAVY AND HORIZONTAL LIGHT +2539 BOX DRAWINGS RIGHT LIGHT AND LEFT UP HEAVY +253A BOX DRAWINGS LEFT LIGHT AND RIGHT UP HEAVY +253B BOX DRAWINGS HEAVY UP AND HORIZONTAL +253C BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL +253D BOX DRAWINGS LEFT HEAVY AND RIGHT VERTICAL LIGHT +253E BOX DRAWINGS RIGHT HEAVY AND LEFT VERTICAL LIGHT +253F BOX DRAWINGS VERTICAL LIGHT AND HORIZONTAL HEAVY +2540 BOX DRAWINGS UP HEAVY AND DOWN HORIZONTAL LIGHT +2541 BOX DRAWINGS DOWN HEAVY AND UP HORIZONTAL LIGHT +2542 BOX DRAWINGS VERTICAL HEAVY AND HORIZONTAL LIGHT +2543 BOX DRAWINGS LEFT UP HEAVY AND RIGHT DOWN LIGHT +2544 BOX DRAWINGS RIGHT UP HEAVY AND LEFT DOWN LIGHT +2545 BOX DRAWINGS LEFT DOWN HEAVY AND RIGHT UP LIGHT +2546 BOX DRAWINGS RIGHT DOWN HEAVY AND LEFT UP LIGHT +2547 BOX DRAWINGS DOWN LIGHT AND UP HORIZONTAL HEAVY +2548 BOX DRAWINGS UP LIGHT AND DOWN HORIZONTAL HEAVY +2549 BOX DRAWINGS RIGHT LIGHT AND LEFT VERTICAL HEAVY +254A BOX DRAWINGS LEFT LIGHT AND RIGHT VERTICAL HEAVY +254B BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL +254C BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL +254D BOX DRAWINGS HEAVY DOUBLE DASH HORIZONTAL +254E BOX DRAWINGS LIGHT DOUBLE DASH VERTICAL +254F BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL +2550 BOX DRAWINGS DOUBLE HORIZONTAL +2551 BOX DRAWINGS DOUBLE VERTICAL +2552 BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE +2553 BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE +2554 BOX DRAWINGS DOUBLE DOWN AND RIGHT +2555 BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE +2556 BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE +2557 BOX DRAWINGS DOUBLE DOWN AND LEFT +2558 BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE +2559 BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE +255A BOX DRAWINGS DOUBLE UP AND RIGHT +255B BOX DRAWINGS UP SINGLE AND LEFT DOUBLE +255C BOX DRAWINGS UP DOUBLE AND LEFT SINGLE +255D BOX DRAWINGS DOUBLE UP AND LEFT +255E BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE +255F BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE +2560 BOX DRAWINGS DOUBLE VERTICAL AND RIGHT +2561 BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE +2562 BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE +2563 BOX DRAWINGS DOUBLE VERTICAL AND LEFT +2564 BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE +2565 BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE +2566 BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL +2567 BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE +2568 BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE +2569 BOX DRAWINGS DOUBLE UP AND HORIZONTAL +256A BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE +256B BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE +256C BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL +256D BOX DRAWINGS LIGHT ARC DOWN AND RIGHT +256E BOX DRAWINGS LIGHT ARC DOWN AND LEFT +256F BOX DRAWINGS LIGHT ARC UP AND LEFT +2570 BOX DRAWINGS LIGHT ARC UP AND RIGHT +2571 BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT +2572 BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT +2573 BOX DRAWINGS LIGHT DIAGONAL CROSS +2574 BOX DRAWINGS LIGHT LEFT +2575 BOX DRAWINGS LIGHT UP +2576 BOX DRAWINGS LIGHT RIGHT +2577 BOX DRAWINGS LIGHT DOWN +2578 BOX DRAWINGS HEAVY LEFT +2579 BOX DRAWINGS HEAVY UP +257A BOX DRAWINGS HEAVY RIGHT +257B BOX DRAWINGS HEAVY DOWN +257C BOX DRAWINGS LIGHT LEFT AND HEAVY RIGHT +257D BOX DRAWINGS LIGHT UP AND HEAVY DOWN +257E BOX DRAWINGS HEAVY LEFT AND LIGHT RIGHT +257F BOX DRAWINGS HEAVY UP AND LIGHT DOWN +2580 UPPER HALF BLOCK +2581 LOWER ONE EIGHTH BLOCK +2582 LOWER ONE QUARTER BLOCK +2583 LOWER THREE EIGHTHS BLOCK +2584 LOWER HALF BLOCK +2585 LOWER FIVE EIGHTHS BLOCK +2586 LOWER THREE QUARTERS BLOCK +2587 LOWER SEVEN EIGHTHS BLOCK +2588 FULL BLOCK +2589 LEFT SEVEN EIGHTHS BLOCK +258A LEFT THREE QUARTERS BLOCK +258B LEFT FIVE EIGHTHS BLOCK +258C LEFT HALF BLOCK +258D LEFT THREE EIGHTHS BLOCK +258E LEFT ONE QUARTER BLOCK +258F LEFT ONE EIGHTH BLOCK +2590 RIGHT HALF BLOCK +2591 LIGHT SHADE +2592 MEDIUM SHADE +2593 DARK SHADE +2594 UPPER ONE EIGHTH BLOCK +2595 RIGHT ONE EIGHTH BLOCK +2596 QUADRANT LOWER LEFT +2597 QUADRANT LOWER RIGHT +2598 QUADRANT UPPER LEFT +2599 QUADRANT UPPER LEFT AND LOWER LEFT AND LOWER RIGHT +259A QUADRANT UPPER LEFT AND LOWER RIGHT +259B QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER LEFT +259C QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER RIGHT +259D QUADRANT UPPER RIGHT +259E QUADRANT UPPER RIGHT AND LOWER LEFT +259F QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT +25A0 BLACK SQUARE +25A1 WHITE SQUARE +25A2 WHITE SQUARE WITH ROUNDED CORNERS +25A3 WHITE SQUARE CONTAINING BLACK SMALL SQUARE +25A4 SQUARE WITH HORIZONTAL FILL +25A5 SQUARE WITH VERTICAL FILL +25A6 SQUARE WITH ORTHOGONAL CROSSHATCH FILL +25A7 SQUARE WITH UPPER LEFT TO LOWER RIGHT FILL +25A8 SQUARE WITH UPPER RIGHT TO LOWER LEFT FILL +25A9 SQUARE WITH DIAGONAL CROSSHATCH FILL +25AA BLACK SMALL SQUARE +25AB WHITE SMALL SQUARE +25AC BLACK RECTANGLE +25AD WHITE RECTANGLE +25AE BLACK VERTICAL RECTANGLE +25AF WHITE VERTICAL RECTANGLE +25B0 BLACK PARALLELOGRAM +25B1 WHITE PARALLELOGRAM +25B2 BLACK UP-POINTING TRIANGLE +25B3 WHITE UP-POINTING TRIANGLE +25B4 BLACK UP-POINTING SMALL TRIANGLE +25B5 WHITE UP-POINTING SMALL TRIANGLE +25B6 BLACK RIGHT-POINTING TRIANGLE +25B7 WHITE RIGHT-POINTING TRIANGLE +25B8 BLACK RIGHT-POINTING SMALL TRIANGLE +25B9 WHITE RIGHT-POINTING SMALL TRIANGLE +25BA BLACK RIGHT-POINTING POINTER +25BB WHITE RIGHT-POINTING POINTER +25BC BLACK DOWN-POINTING TRIANGLE +25BD WHITE DOWN-POINTING TRIANGLE +25BE BLACK DOWN-POINTING SMALL TRIANGLE +25BF WHITE DOWN-POINTING SMALL TRIANGLE +25C0 BLACK LEFT-POINTING TRIANGLE +25C1 WHITE LEFT-POINTING TRIANGLE +25C2 BLACK LEFT-POINTING SMALL TRIANGLE +25C3 WHITE LEFT-POINTING SMALL TRIANGLE +25C4 BLACK LEFT-POINTING POINTER +25C5 WHITE LEFT-POINTING POINTER +25C6 BLACK DIAMOND +25C7 WHITE DIAMOND +25C8 WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND +25C9 FISHEYE +25CA LOZENGE +25CB WHITE CIRCLE +25CC DOTTED CIRCLE +25CD CIRCLE WITH VERTICAL FILL +25CE BULLSEYE +25CF BLACK CIRCLE +25D0 CIRCLE WITH LEFT HALF BLACK +25D1 CIRCLE WITH RIGHT HALF BLACK +25D2 CIRCLE WITH LOWER HALF BLACK +25D3 CIRCLE WITH UPPER HALF BLACK +25D4 CIRCLE WITH UPPER RIGHT QUADRANT BLACK +25D5 CIRCLE WITH ALL BUT UPPER LEFT QUADRANT BLACK +25D6 LEFT HALF BLACK CIRCLE +25D7 RIGHT HALF BLACK CIRCLE +25D8 INVERSE BULLET +25D9 INVERSE WHITE CIRCLE +25DA UPPER HALF INVERSE WHITE CIRCLE +25DB LOWER HALF INVERSE WHITE CIRCLE +25DC UPPER LEFT QUADRANT CIRCULAR ARC +25DD UPPER RIGHT QUADRANT CIRCULAR ARC +25DE LOWER RIGHT QUADRANT CIRCULAR ARC +25DF LOWER LEFT QUADRANT CIRCULAR ARC +25E0 UPPER HALF CIRCLE +25E1 LOWER HALF CIRCLE +25E2 BLACK LOWER RIGHT TRIANGLE +25E3 BLACK LOWER LEFT TRIANGLE +25E4 BLACK UPPER LEFT TRIANGLE +25E5 BLACK UPPER RIGHT TRIANGLE +25E6 WHITE BULLET +25E7 SQUARE WITH LEFT HALF BLACK +25E8 SQUARE WITH RIGHT HALF BLACK +25E9 SQUARE WITH UPPER LEFT DIAGONAL HALF BLACK +25EA SQUARE WITH LOWER RIGHT DIAGONAL HALF BLACK +25EB WHITE SQUARE WITH VERTICAL BISECTING LINE +25EC WHITE UP-POINTING TRIANGLE WITH DOT +25ED UP-POINTING TRIANGLE WITH LEFT HALF BLACK +25EE UP-POINTING TRIANGLE WITH RIGHT HALF BLACK +25EF LARGE CIRCLE +25F0 WHITE SQUARE WITH UPPER LEFT QUADRANT +25F1 WHITE SQUARE WITH LOWER LEFT QUADRANT +25F2 WHITE SQUARE WITH LOWER RIGHT QUADRANT +25F3 WHITE SQUARE WITH UPPER RIGHT QUADRANT +25F4 WHITE CIRCLE WITH UPPER LEFT QUADRANT +25F5 WHITE CIRCLE WITH LOWER LEFT QUADRANT +25F6 WHITE CIRCLE WITH LOWER RIGHT QUADRANT +25F7 WHITE CIRCLE WITH UPPER RIGHT QUADRANT +25F8 UPPER LEFT TRIANGLE +25F9 UPPER RIGHT TRIANGLE +25FA LOWER LEFT TRIANGLE +25FB WHITE MEDIUM SQUARE +25FC BLACK MEDIUM SQUARE +25FD WHITE MEDIUM SMALL SQUARE +25FE BLACK MEDIUM SMALL SQUARE +25FF LOWER RIGHT TRIANGLE +2600 BLACK SUN WITH RAYS +2601 CLOUD +2602 UMBRELLA +2603 SNOWMAN +2604 COMET +2605 BLACK STAR +2606 WHITE STAR +2607 LIGHTNING +2608 THUNDERSTORM +2609 SUN +260A ASCENDING NODE +260B DESCENDING NODE +260C CONJUNCTION +260D OPPOSITION +260E BLACK TELEPHONE +260F WHITE TELEPHONE +2610 BALLOT BOX +2611 BALLOT BOX WITH CHECK +2612 BALLOT BOX WITH X +2613 SALTIRE +2616 WHITE SHOGI PIECE +2617 BLACK SHOGI PIECE +2619 REVERSED ROTATED FLORAL HEART BULLET +261A BLACK LEFT POINTING INDEX +261B BLACK RIGHT POINTING INDEX +261C WHITE LEFT POINTING INDEX +261D WHITE UP POINTING INDEX +261E WHITE RIGHT POINTING INDEX +261F WHITE DOWN POINTING INDEX +2620 SKULL AND CROSSBONES +2621 CAUTION SIGN +2622 RADIOACTIVE SIGN +2623 BIOHAZARD SIGN +2624 CADUCEUS +2625 ANKH +2626 ORTHODOX CROSS +2627 CHI RHO +2628 CROSS OF LORRAINE +2629 CROSS OF JERUSALEM +262A STAR AND CRESCENT +262B FARSI SYMBOL +262C ADI SHAKTI +262D HAMMER AND SICKLE +262E PEACE SYMBOL +262F YIN YANG +2630 TRIGRAM FOR HEAVEN +2631 TRIGRAM FOR LAKE +2632 TRIGRAM FOR FIRE +2633 TRIGRAM FOR THUNDER +2634 TRIGRAM FOR WIND +2635 TRIGRAM FOR WATER +2636 TRIGRAM FOR MOUNTAIN +2637 TRIGRAM FOR EARTH +2638 WHEEL OF DHARMA +2639 WHITE FROWNING FACE +263A WHITE SMILING FACE +263B BLACK SMILING FACE +263C WHITE SUN WITH RAYS +263D FIRST QUARTER MOON +263E LAST QUARTER MOON +263F MERCURY +2640 FEMALE SIGN +2641 EARTH +2642 MALE SIGN +2643 JUPITER +2644 SATURN +2645 URANUS +2646 NEPTUNE +2647 PLUTO +2648 ARIES +2649 TAURUS +264A GEMINI +264B CANCER +264C LEO +264D VIRGO +264E LIBRA +264F SCORPIUS +2650 SAGITTARIUS +2651 CAPRICORN +2652 AQUARIUS +2653 PISCES +2654 WHITE CHESS KING +2655 WHITE CHESS QUEEN +2656 WHITE CHESS ROOK +2657 WHITE CHESS BISHOP +2658 WHITE CHESS KNIGHT +2659 WHITE CHESS PAWN +265A BLACK CHESS KING +265B BLACK CHESS QUEEN +265C BLACK CHESS ROOK +265D BLACK CHESS BISHOP +265E BLACK CHESS KNIGHT +265F BLACK CHESS PAWN +2660 BLACK SPADE SUIT +2661 WHITE HEART SUIT +2662 WHITE DIAMOND SUIT +2663 BLACK CLUB SUIT +2664 WHITE SPADE SUIT +2665 BLACK HEART SUIT +2666 BLACK DIAMOND SUIT +2667 WHITE CLUB SUIT +2668 HOT SPRINGS +2669 QUARTER NOTE +266A EIGHTH NOTE +266B BEAMED EIGHTH NOTES +266C BEAMED SIXTEENTH NOTES +266D MUSIC FLAT SIGN +266E MUSIC NATURAL SIGN +266F MUSIC SHARP SIGN +2670 WEST SYRIAC CROSS +2671 EAST SYRIAC CROSS +2672 UNIVERSAL RECYCLING SYMBOL +2673 RECYCLING SYMBOL FOR TYPE-1 PLASTICS +2674 RECYCLING SYMBOL FOR TYPE-2 PLASTICS +2675 RECYCLING SYMBOL FOR TYPE-3 PLASTICS +2676 RECYCLING SYMBOL FOR TYPE-4 PLASTICS +2677 RECYCLING SYMBOL FOR TYPE-5 PLASTICS +2678 RECYCLING SYMBOL FOR TYPE-6 PLASTICS +2679 RECYCLING SYMBOL FOR TYPE-7 PLASTICS +267A RECYCLING SYMBOL FOR GENERIC MATERIALS +267B BLACK UNIVERSAL RECYCLING SYMBOL +267C RECYCLED PAPER SYMBOL +267D PARTIALLY-RECYCLED PAPER SYMBOL +2680 DIE FACE-1 +2681 DIE FACE-2 +2682 DIE FACE-3 +2683 DIE FACE-4 +2684 DIE FACE-5 +2685 DIE FACE-6 +2686 WHITE CIRCLE WITH DOT RIGHT +2687 WHITE CIRCLE WITH TWO DOTS +2688 BLACK CIRCLE WITH WHITE DOT RIGHT +2689 BLACK CIRCLE WITH TWO WHITE DOTS +2701 UPPER BLADE SCISSORS +2702 BLACK SCISSORS +2703 LOWER BLADE SCISSORS +2704 WHITE SCISSORS +2706 TELEPHONE LOCATION SIGN +2707 TAPE DRIVE +2708 AIRPLANE +2709 ENVELOPE +270C VICTORY HAND +270D WRITING HAND +270E LOWER RIGHT PENCIL +270F PENCIL +2710 UPPER RIGHT PENCIL +2711 WHITE NIB +2712 BLACK NIB +2713 CHECK MARK +2714 HEAVY CHECK MARK +2715 MULTIPLICATION X +2716 HEAVY MULTIPLICATION X +2717 BALLOT X +2718 HEAVY BALLOT X +2719 OUTLINED GREEK CROSS +271A HEAVY GREEK CROSS +271B OPEN CENTRE CROSS +271C HEAVY OPEN CENTRE CROSS +271D LATIN CROSS +271E SHADOWED WHITE LATIN CROSS +271F OUTLINED LATIN CROSS +2720 MALTESE CROSS +2721 STAR OF DAVID +2722 FOUR TEARDROP-SPOKED ASTERISK +2723 FOUR BALLOON-SPOKED ASTERISK +2724 HEAVY FOUR BALLOON-SPOKED ASTERISK +2725 FOUR CLUB-SPOKED ASTERISK +2726 BLACK FOUR POINTED STAR +2727 WHITE FOUR POINTED STAR +2729 STRESS OUTLINED WHITE STAR +272A CIRCLED WHITE STAR +272B OPEN CENTRE BLACK STAR +272C BLACK CENTRE WHITE STAR +272D OUTLINED BLACK STAR +272E HEAVY OUTLINED BLACK STAR +272F PINWHEEL STAR +2730 SHADOWED WHITE STAR +2731 HEAVY ASTERISK +2732 OPEN CENTRE ASTERISK +2733 EIGHT SPOKED ASTERISK +2734 EIGHT POINTED BLACK STAR +2735 EIGHT POINTED PINWHEEL STAR +2736 SIX POINTED BLACK STAR +2737 EIGHT POINTED RECTILINEAR BLACK STAR +2738 HEAVY EIGHT POINTED RECTILINEAR BLACK STAR +2739 TWELVE POINTED BLACK STAR +273A SIXTEEN POINTED ASTERISK +273B TEARDROP-SPOKED ASTERISK +273C OPEN CENTRE TEARDROP-SPOKED ASTERISK +273D HEAVY TEARDROP-SPOKED ASTERISK +273E SIX PETALLED BLACK AND WHITE FLORETTE +273F BLACK FLORETTE +2740 WHITE FLORETTE +2741 EIGHT PETALLED OUTLINED BLACK FLORETTE +2742 CIRCLED OPEN CENTRE EIGHT POINTED STAR +2743 HEAVY TEARDROP-SPOKED PINWHEEL ASTERISK +2744 SNOWFLAKE +2745 TIGHT TRIFOLIATE SNOWFLAKE +2746 HEAVY CHEVRON SNOWFLAKE +2747 SPARKLE +2748 HEAVY SPARKLE +2749 BALLOON-SPOKED ASTERISK +274A EIGHT TEARDROP-SPOKED PROPELLER ASTERISK +274B HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK +274D SHADOWED WHITE CIRCLE +274F LOWER RIGHT DROP-SHADOWED WHITE SQUARE +2750 UPPER RIGHT DROP-SHADOWED WHITE SQUARE +2751 LOWER RIGHT SHADOWED WHITE SQUARE +2752 UPPER RIGHT SHADOWED WHITE SQUARE +2756 BLACK DIAMOND MINUS WHITE X +2758 LIGHT VERTICAL BAR +2759 MEDIUM VERTICAL BAR +275A HEAVY VERTICAL BAR +275B HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT +275C HEAVY SINGLE COMMA QUOTATION MARK ORNAMENT +275D HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT +275E HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT +2761 CURVED STEM PARAGRAPH SIGN ORNAMENT +2762 HEAVY EXCLAMATION MARK ORNAMENT +2763 HEAVY HEART EXCLAMATION MARK ORNAMENT +2764 HEAVY BLACK HEART +2765 ROTATED HEAVY BLACK HEART BULLET +2766 FLORAL HEART +2767 ROTATED FLORAL HEART BULLET +2768 MEDIUM LEFT PARENTHESIS ORNAMENT +2769 MEDIUM RIGHT PARENTHESIS ORNAMENT +276A MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT +276B MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT +276C MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT +276D MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT +276E HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT +276F HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT +2770 HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT +2771 HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT +2772 LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT +2773 LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT +2774 MEDIUM LEFT CURLY BRACKET ORNAMENT +2775 MEDIUM RIGHT CURLY BRACKET ORNAMENT +2776 DINGBAT NEGATIVE CIRCLED DIGIT ONE +2777 DINGBAT NEGATIVE CIRCLED DIGIT TWO +2778 DINGBAT NEGATIVE CIRCLED DIGIT THREE +2779 DINGBAT NEGATIVE CIRCLED DIGIT FOUR +277A DINGBAT NEGATIVE CIRCLED DIGIT FIVE +277B DINGBAT NEGATIVE CIRCLED DIGIT SIX +277C DINGBAT NEGATIVE CIRCLED DIGIT SEVEN +277D DINGBAT NEGATIVE CIRCLED DIGIT EIGHT +277E DINGBAT NEGATIVE CIRCLED DIGIT NINE +277F DINGBAT NEGATIVE CIRCLED NUMBER TEN +2780 DINGBAT CIRCLED SANS-SERIF DIGIT ONE +2781 DINGBAT CIRCLED SANS-SERIF DIGIT TWO +2782 DINGBAT CIRCLED SANS-SERIF DIGIT THREE +2783 DINGBAT CIRCLED SANS-SERIF DIGIT FOUR +2784 DINGBAT CIRCLED SANS-SERIF DIGIT FIVE +2785 DINGBAT CIRCLED SANS-SERIF DIGIT SIX +2786 DINGBAT CIRCLED SANS-SERIF DIGIT SEVEN +2787 DINGBAT CIRCLED SANS-SERIF DIGIT EIGHT +2788 DINGBAT CIRCLED SANS-SERIF DIGIT NINE +2789 DINGBAT CIRCLED SANS-SERIF NUMBER TEN +278A DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ONE +278B DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT TWO +278C DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT THREE +278D DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FOUR +278E DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FIVE +278F DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SIX +2790 DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SEVEN +2791 DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT EIGHT +2792 DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT NINE +2793 DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN +2794 HEAVY WIDE-HEADED RIGHTWARDS ARROW +2798 HEAVY SOUTH EAST ARROW +2799 HEAVY RIGHTWARDS ARROW +279A HEAVY NORTH EAST ARROW +279B DRAFTING POINT RIGHTWARDS ARROW +279C HEAVY ROUND-TIPPED RIGHTWARDS ARROW +279D TRIANGLE-HEADED RIGHTWARDS ARROW +279E HEAVY TRIANGLE-HEADED RIGHTWARDS ARROW +279F DASHED TRIANGLE-HEADED RIGHTWARDS ARROW +27A0 HEAVY DASHED TRIANGLE-HEADED RIGHTWARDS ARROW +27A1 BLACK RIGHTWARDS ARROW +27A2 THREE-D TOP-LIGHTED RIGHTWARDS ARROWHEAD +27A3 THREE-D BOTTOM-LIGHTED RIGHTWARDS ARROWHEAD +27A4 BLACK RIGHTWARDS ARROWHEAD +27A5 HEAVY BLACK CURVED DOWNWARDS AND RIGHTWARDS ARROW +27A6 HEAVY BLACK CURVED UPWARDS AND RIGHTWARDS ARROW +27A7 SQUAT BLACK RIGHTWARDS ARROW +27A8 HEAVY CONCAVE-POINTED BLACK RIGHTWARDS ARROW +27A9 RIGHT-SHADED WHITE RIGHTWARDS ARROW +27AA LEFT-SHADED WHITE RIGHTWARDS ARROW +27AB BACK-TILTED SHADOWED WHITE RIGHTWARDS ARROW +27AC FRONT-TILTED SHADOWED WHITE RIGHTWARDS ARROW +27AD HEAVY LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW +27AE HEAVY UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW +27AF NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW +27B1 NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW +27B2 CIRCLED HEAVY WHITE RIGHTWARDS ARROW +27B3 WHITE-FEATHERED RIGHTWARDS ARROW +27B4 BLACK-FEATHERED SOUTH EAST ARROW +27B5 BLACK-FEATHERED RIGHTWARDS ARROW +27B6 BLACK-FEATHERED NORTH EAST ARROW +27B7 HEAVY BLACK-FEATHERED SOUTH EAST ARROW +27B8 HEAVY BLACK-FEATHERED RIGHTWARDS ARROW +27B9 HEAVY BLACK-FEATHERED NORTH EAST ARROW +27BA TEARDROP-BARBED RIGHTWARDS ARROW +27BB HEAVY TEARDROP-SHANKED RIGHTWARDS ARROW +27BC WEDGE-TAILED RIGHTWARDS ARROW +27BD HEAVY WEDGE-TAILED RIGHTWARDS ARROW +27BE OPEN-OUTLINED RIGHTWARDS ARROW +27D0 WHITE DIAMOND WITH CENTRED DOT +27D1 AND WITH DOT +27D2 ELEMENT OF OPENING UPWARDS +27D3 LOWER RIGHT CORNER WITH DOT +27D4 UPPER LEFT CORNER WITH DOT +27D5 LEFT OUTER JOIN +27D6 RIGHT OUTER JOIN +27D7 FULL OUTER JOIN +27D8 LARGE UP TACK +27D9 LARGE DOWN TACK +27DA LEFT AND RIGHT DOUBLE TURNSTILE +27DB LEFT AND RIGHT TACK +27DC LEFT MULTIMAP +27DD LONG RIGHT TACK +27DE LONG LEFT TACK +27DF UP TACK WITH CIRCLE ABOVE +27E0 LOZENGE DIVIDED BY HORIZONTAL RULE +27E1 WHITE CONCAVE-SIDED DIAMOND +27E2 WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK +27E3 WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK +27E4 WHITE SQUARE WITH LEFTWARDS TICK +27E5 WHITE SQUARE WITH RIGHTWARDS TICK +27E6 MATHEMATICAL LEFT WHITE SQUARE BRACKET +27E7 MATHEMATICAL RIGHT WHITE SQUARE BRACKET +27E8 MATHEMATICAL LEFT ANGLE BRACKET +27E9 MATHEMATICAL RIGHT ANGLE BRACKET +27EA MATHEMATICAL LEFT DOUBLE ANGLE BRACKET +27EB MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET +27F0 UPWARDS QUADRUPLE ARROW +27F1 DOWNWARDS QUADRUPLE ARROW +27F2 ANTICLOCKWISE GAPPED CIRCLE ARROW +27F3 CLOCKWISE GAPPED CIRCLE ARROW +27F4 RIGHT ARROW WITH CIRCLED PLUS +27F5 LONG LEFTWARDS ARROW +27F6 LONG RIGHTWARDS ARROW +27F7 LONG LEFT RIGHT ARROW +27F8 LONG LEFTWARDS DOUBLE ARROW +27F9 LONG RIGHTWARDS DOUBLE ARROW +27FA LONG LEFT RIGHT DOUBLE ARROW +27FB LONG LEFTWARDS ARROW FROM BAR +27FC LONG RIGHTWARDS ARROW FROM BAR +27FD LONG LEFTWARDS DOUBLE ARROW FROM BAR +27FE LONG RIGHTWARDS DOUBLE ARROW FROM BAR +27FF LONG RIGHTWARDS SQUIGGLE ARROW +2800 BRAILLE PATTERN BLANK +2801 BRAILLE PATTERN DOTS-1 +2802 BRAILLE PATTERN DOTS-2 +2803 BRAILLE PATTERN DOTS-12 +2804 BRAILLE PATTERN DOTS-3 +2805 BRAILLE PATTERN DOTS-13 +2806 BRAILLE PATTERN DOTS-23 +2807 BRAILLE PATTERN DOTS-123 +2808 BRAILLE PATTERN DOTS-4 +2809 BRAILLE PATTERN DOTS-14 +280A BRAILLE PATTERN DOTS-24 +280B BRAILLE PATTERN DOTS-124 +280C BRAILLE PATTERN DOTS-34 +280D BRAILLE PATTERN DOTS-134 +280E BRAILLE PATTERN DOTS-234 +280F BRAILLE PATTERN DOTS-1234 +2810 BRAILLE PATTERN DOTS-5 +2811 BRAILLE PATTERN DOTS-15 +2812 BRAILLE PATTERN DOTS-25 +2813 BRAILLE PATTERN DOTS-125 +2814 BRAILLE PATTERN DOTS-35 +2815 BRAILLE PATTERN DOTS-135 +2816 BRAILLE PATTERN DOTS-235 +2817 BRAILLE PATTERN DOTS-1235 +2818 BRAILLE PATTERN DOTS-45 +2819 BRAILLE PATTERN DOTS-145 +281A BRAILLE PATTERN DOTS-245 +281B BRAILLE PATTERN DOTS-1245 +281C BRAILLE PATTERN DOTS-345 +281D BRAILLE PATTERN DOTS-1345 +281E BRAILLE PATTERN DOTS-2345 +281F BRAILLE PATTERN DOTS-12345 +2820 BRAILLE PATTERN DOTS-6 +2821 BRAILLE PATTERN DOTS-16 +2822 BRAILLE PATTERN DOTS-26 +2823 BRAILLE PATTERN DOTS-126 +2824 BRAILLE PATTERN DOTS-36 +2825 BRAILLE PATTERN DOTS-136 +2826 BRAILLE PATTERN DOTS-236 +2827 BRAILLE PATTERN DOTS-1236 +2828 BRAILLE PATTERN DOTS-46 +2829 BRAILLE PATTERN DOTS-146 +282A BRAILLE PATTERN DOTS-246 +282B BRAILLE PATTERN DOTS-1246 +282C BRAILLE PATTERN DOTS-346 +282D BRAILLE PATTERN DOTS-1346 +282E BRAILLE PATTERN DOTS-2346 +282F BRAILLE PATTERN DOTS-12346 +2830 BRAILLE PATTERN DOTS-56 +2831 BRAILLE PATTERN DOTS-156 +2832 BRAILLE PATTERN DOTS-256 +2833 BRAILLE PATTERN DOTS-1256 +2834 BRAILLE PATTERN DOTS-356 +2835 BRAILLE PATTERN DOTS-1356 +2836 BRAILLE PATTERN DOTS-2356 +2837 BRAILLE PATTERN DOTS-12356 +2838 BRAILLE PATTERN DOTS-456 +2839 BRAILLE PATTERN DOTS-1456 +283A BRAILLE PATTERN DOTS-2456 +283B BRAILLE PATTERN DOTS-12456 +283C BRAILLE PATTERN DOTS-3456 +283D BRAILLE PATTERN DOTS-13456 +283E BRAILLE PATTERN DOTS-23456 +283F BRAILLE PATTERN DOTS-123456 +2840 BRAILLE PATTERN DOTS-7 +2841 BRAILLE PATTERN DOTS-17 +2842 BRAILLE PATTERN DOTS-27 +2843 BRAILLE PATTERN DOTS-127 +2844 BRAILLE PATTERN DOTS-37 +2845 BRAILLE PATTERN DOTS-137 +2846 BRAILLE PATTERN DOTS-237 +2847 BRAILLE PATTERN DOTS-1237 +2848 BRAILLE PATTERN DOTS-47 +2849 BRAILLE PATTERN DOTS-147 +284A BRAILLE PATTERN DOTS-247 +284B BRAILLE PATTERN DOTS-1247 +284C BRAILLE PATTERN DOTS-347 +284D BRAILLE PATTERN DOTS-1347 +284E BRAILLE PATTERN DOTS-2347 +284F BRAILLE PATTERN DOTS-12347 +2850 BRAILLE PATTERN DOTS-57 +2851 BRAILLE PATTERN DOTS-157 +2852 BRAILLE PATTERN DOTS-257 +2853 BRAILLE PATTERN DOTS-1257 +2854 BRAILLE PATTERN DOTS-357 +2855 BRAILLE PATTERN DOTS-1357 +2856 BRAILLE PATTERN DOTS-2357 +2857 BRAILLE PATTERN DOTS-12357 +2858 BRAILLE PATTERN DOTS-457 +2859 BRAILLE PATTERN DOTS-1457 +285A BRAILLE PATTERN DOTS-2457 +285B BRAILLE PATTERN DOTS-12457 +285C BRAILLE PATTERN DOTS-3457 +285D BRAILLE PATTERN DOTS-13457 +285E BRAILLE PATTERN DOTS-23457 +285F BRAILLE PATTERN DOTS-123457 +2860 BRAILLE PATTERN DOTS-67 +2861 BRAILLE PATTERN DOTS-167 +2862 BRAILLE PATTERN DOTS-267 +2863 BRAILLE PATTERN DOTS-1267 +2864 BRAILLE PATTERN DOTS-367 +2865 BRAILLE PATTERN DOTS-1367 +2866 BRAILLE PATTERN DOTS-2367 +2867 BRAILLE PATTERN DOTS-12367 +2868 BRAILLE PATTERN DOTS-467 +2869 BRAILLE PATTERN DOTS-1467 +286A BRAILLE PATTERN DOTS-2467 +286B BRAILLE PATTERN DOTS-12467 +286C BRAILLE PATTERN DOTS-3467 +286D BRAILLE PATTERN DOTS-13467 +286E BRAILLE PATTERN DOTS-23467 +286F BRAILLE PATTERN DOTS-123467 +2870 BRAILLE PATTERN DOTS-567 +2871 BRAILLE PATTERN DOTS-1567 +2872 BRAILLE PATTERN DOTS-2567 +2873 BRAILLE PATTERN DOTS-12567 +2874 BRAILLE PATTERN DOTS-3567 +2875 BRAILLE PATTERN DOTS-13567 +2876 BRAILLE PATTERN DOTS-23567 +2877 BRAILLE PATTERN DOTS-123567 +2878 BRAILLE PATTERN DOTS-4567 +2879 BRAILLE PATTERN DOTS-14567 +287A BRAILLE PATTERN DOTS-24567 +287B BRAILLE PATTERN DOTS-124567 +287C BRAILLE PATTERN DOTS-34567 +287D BRAILLE PATTERN DOTS-134567 +287E BRAILLE PATTERN DOTS-234567 +287F BRAILLE PATTERN DOTS-1234567 +2880 BRAILLE PATTERN DOTS-8 +2881 BRAILLE PATTERN DOTS-18 +2882 BRAILLE PATTERN DOTS-28 +2883 BRAILLE PATTERN DOTS-128 +2884 BRAILLE PATTERN DOTS-38 +2885 BRAILLE PATTERN DOTS-138 +2886 BRAILLE PATTERN DOTS-238 +2887 BRAILLE PATTERN DOTS-1238 +2888 BRAILLE PATTERN DOTS-48 +2889 BRAILLE PATTERN DOTS-148 +288A BRAILLE PATTERN DOTS-248 +288B BRAILLE PATTERN DOTS-1248 +288C BRAILLE PATTERN DOTS-348 +288D BRAILLE PATTERN DOTS-1348 +288E BRAILLE PATTERN DOTS-2348 +288F BRAILLE PATTERN DOTS-12348 +2890 BRAILLE PATTERN DOTS-58 +2891 BRAILLE PATTERN DOTS-158 +2892 BRAILLE PATTERN DOTS-258 +2893 BRAILLE PATTERN DOTS-1258 +2894 BRAILLE PATTERN DOTS-358 +2895 BRAILLE PATTERN DOTS-1358 +2896 BRAILLE PATTERN DOTS-2358 +2897 BRAILLE PATTERN DOTS-12358 +2898 BRAILLE PATTERN DOTS-458 +2899 BRAILLE PATTERN DOTS-1458 +289A BRAILLE PATTERN DOTS-2458 +289B BRAILLE PATTERN DOTS-12458 +289C BRAILLE PATTERN DOTS-3458 +289D BRAILLE PATTERN DOTS-13458 +289E BRAILLE PATTERN DOTS-23458 +289F BRAILLE PATTERN DOTS-123458 +28A0 BRAILLE PATTERN DOTS-68 +28A1 BRAILLE PATTERN DOTS-168 +28A2 BRAILLE PATTERN DOTS-268 +28A3 BRAILLE PATTERN DOTS-1268 +28A4 BRAILLE PATTERN DOTS-368 +28A5 BRAILLE PATTERN DOTS-1368 +28A6 BRAILLE PATTERN DOTS-2368 +28A7 BRAILLE PATTERN DOTS-12368 +28A8 BRAILLE PATTERN DOTS-468 +28A9 BRAILLE PATTERN DOTS-1468 +28AA BRAILLE PATTERN DOTS-2468 +28AB BRAILLE PATTERN DOTS-12468 +28AC BRAILLE PATTERN DOTS-3468 +28AD BRAILLE PATTERN DOTS-13468 +28AE BRAILLE PATTERN DOTS-23468 +28AF BRAILLE PATTERN DOTS-123468 +28B0 BRAILLE PATTERN DOTS-568 +28B1 BRAILLE PATTERN DOTS-1568 +28B2 BRAILLE PATTERN DOTS-2568 +28B3 BRAILLE PATTERN DOTS-12568 +28B4 BRAILLE PATTERN DOTS-3568 +28B5 BRAILLE PATTERN DOTS-13568 +28B6 BRAILLE PATTERN DOTS-23568 +28B7 BRAILLE PATTERN DOTS-123568 +28B8 BRAILLE PATTERN DOTS-4568 +28B9 BRAILLE PATTERN DOTS-14568 +28BA BRAILLE PATTERN DOTS-24568 +28BB BRAILLE PATTERN DOTS-124568 +28BC BRAILLE PATTERN DOTS-34568 +28BD BRAILLE PATTERN DOTS-134568 +28BE BRAILLE PATTERN DOTS-234568 +28BF BRAILLE PATTERN DOTS-1234568 +28C0 BRAILLE PATTERN DOTS-78 +28C1 BRAILLE PATTERN DOTS-178 +28C2 BRAILLE PATTERN DOTS-278 +28C3 BRAILLE PATTERN DOTS-1278 +28C4 BRAILLE PATTERN DOTS-378 +28C5 BRAILLE PATTERN DOTS-1378 +28C6 BRAILLE PATTERN DOTS-2378 +28C7 BRAILLE PATTERN DOTS-12378 +28C8 BRAILLE PATTERN DOTS-478 +28C9 BRAILLE PATTERN DOTS-1478 +28CA BRAILLE PATTERN DOTS-2478 +28CB BRAILLE PATTERN DOTS-12478 +28CC BRAILLE PATTERN DOTS-3478 +28CD BRAILLE PATTERN DOTS-13478 +28CE BRAILLE PATTERN DOTS-23478 +28CF BRAILLE PATTERN DOTS-123478 +28D0 BRAILLE PATTERN DOTS-578 +28D1 BRAILLE PATTERN DOTS-1578 +28D2 BRAILLE PATTERN DOTS-2578 +28D3 BRAILLE PATTERN DOTS-12578 +28D4 BRAILLE PATTERN DOTS-3578 +28D5 BRAILLE PATTERN DOTS-13578 +28D6 BRAILLE PATTERN DOTS-23578 +28D7 BRAILLE PATTERN DOTS-123578 +28D8 BRAILLE PATTERN DOTS-4578 +28D9 BRAILLE PATTERN DOTS-14578 +28DA BRAILLE PATTERN DOTS-24578 +28DB BRAILLE PATTERN DOTS-124578 +28DC BRAILLE PATTERN DOTS-34578 +28DD BRAILLE PATTERN DOTS-134578 +28DE BRAILLE PATTERN DOTS-234578 +28DF BRAILLE PATTERN DOTS-1234578 +28E0 BRAILLE PATTERN DOTS-678 +28E1 BRAILLE PATTERN DOTS-1678 +28E2 BRAILLE PATTERN DOTS-2678 +28E3 BRAILLE PATTERN DOTS-12678 +28E4 BRAILLE PATTERN DOTS-3678 +28E5 BRAILLE PATTERN DOTS-13678 +28E6 BRAILLE PATTERN DOTS-23678 +28E7 BRAILLE PATTERN DOTS-123678 +28E8 BRAILLE PATTERN DOTS-4678 +28E9 BRAILLE PATTERN DOTS-14678 +28EA BRAILLE PATTERN DOTS-24678 +28EB BRAILLE PATTERN DOTS-124678 +28EC BRAILLE PATTERN DOTS-34678 +28ED BRAILLE PATTERN DOTS-134678 +28EE BRAILLE PATTERN DOTS-234678 +28EF BRAILLE PATTERN DOTS-1234678 +28F0 BRAILLE PATTERN DOTS-5678 +28F1 BRAILLE PATTERN DOTS-15678 +28F2 BRAILLE PATTERN DOTS-25678 +28F3 BRAILLE PATTERN DOTS-125678 +28F4 BRAILLE PATTERN DOTS-35678 +28F5 BRAILLE PATTERN DOTS-135678 +28F6 BRAILLE PATTERN DOTS-235678 +28F7 BRAILLE PATTERN DOTS-1235678 +28F8 BRAILLE PATTERN DOTS-45678 +28F9 BRAILLE PATTERN DOTS-145678 +28FA BRAILLE PATTERN DOTS-245678 +28FB BRAILLE PATTERN DOTS-1245678 +28FC BRAILLE PATTERN DOTS-345678 +28FD BRAILLE PATTERN DOTS-1345678 +28FE BRAILLE PATTERN DOTS-2345678 +28FF BRAILLE PATTERN DOTS-12345678 +2900 RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE +2901 RIGHTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE +2902 LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE +2903 RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE +2904 LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE +2905 RIGHTWARDS TWO-HEADED ARROW FROM BAR +2906 LEFTWARDS DOUBLE ARROW FROM BAR +2907 RIGHTWARDS DOUBLE ARROW FROM BAR +2908 DOWNWARDS ARROW WITH HORIZONTAL STROKE +2909 UPWARDS ARROW WITH HORIZONTAL STROKE +290A UPWARDS TRIPLE ARROW +290B DOWNWARDS TRIPLE ARROW +290C LEFTWARDS DOUBLE DASH ARROW +290D RIGHTWARDS DOUBLE DASH ARROW +290E LEFTWARDS TRIPLE DASH ARROW +290F RIGHTWARDS TRIPLE DASH ARROW +2910 RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW +2911 RIGHTWARDS ARROW WITH DOTTED STEM +2912 UPWARDS ARROW TO BAR +2913 DOWNWARDS ARROW TO BAR +2914 RIGHTWARDS ARROW WITH TAIL WITH VERTICAL STROKE +2915 RIGHTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE +2916 RIGHTWARDS TWO-HEADED ARROW WITH TAIL +2917 RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE +2918 RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE +2919 LEFTWARDS ARROW-TAIL +291A RIGHTWARDS ARROW-TAIL +291B LEFTWARDS DOUBLE ARROW-TAIL +291C RIGHTWARDS DOUBLE ARROW-TAIL +291D LEFTWARDS ARROW TO BLACK DIAMOND +291E RIGHTWARDS ARROW TO BLACK DIAMOND +291F LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND +2920 RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND +2921 NORTH WEST AND SOUTH EAST ARROW +2922 NORTH EAST AND SOUTH WEST ARROW +2923 NORTH WEST ARROW WITH HOOK +2924 NORTH EAST ARROW WITH HOOK +2925 SOUTH EAST ARROW WITH HOOK +2926 SOUTH WEST ARROW WITH HOOK +2927 NORTH WEST ARROW AND NORTH EAST ARROW +2928 NORTH EAST ARROW AND SOUTH EAST ARROW +2929 SOUTH EAST ARROW AND SOUTH WEST ARROW +292A SOUTH WEST ARROW AND NORTH WEST ARROW +292B RISING DIAGONAL CROSSING FALLING DIAGONAL +292C FALLING DIAGONAL CROSSING RISING DIAGONAL +292D SOUTH EAST ARROW CROSSING NORTH EAST ARROW +292E NORTH EAST ARROW CROSSING SOUTH EAST ARROW +292F FALLING DIAGONAL CROSSING NORTH EAST ARROW +2930 RISING DIAGONAL CROSSING SOUTH EAST ARROW +2931 NORTH EAST ARROW CROSSING NORTH WEST ARROW +2932 NORTH WEST ARROW CROSSING NORTH EAST ARROW +2933 WAVE ARROW POINTING DIRECTLY RIGHT +2934 ARROW POINTING RIGHTWARDS THEN CURVING UPWARDS +2935 ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS +2936 ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS +2937 ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS +2938 RIGHT-SIDE ARC CLOCKWISE ARROW +2939 LEFT-SIDE ARC ANTICLOCKWISE ARROW +293A TOP ARC ANTICLOCKWISE ARROW +293B BOTTOM ARC ANTICLOCKWISE ARROW +293C TOP ARC CLOCKWISE ARROW WITH MINUS +293D TOP ARC ANTICLOCKWISE ARROW WITH PLUS +293E LOWER RIGHT SEMICIRCULAR CLOCKWISE ARROW +293F LOWER LEFT SEMICIRCULAR ANTICLOCKWISE ARROW +2940 ANTICLOCKWISE CLOSED CIRCLE ARROW +2941 CLOCKWISE CLOSED CIRCLE ARROW +2942 RIGHTWARDS ARROW ABOVE SHORT LEFTWARDS ARROW +2943 LEFTWARDS ARROW ABOVE SHORT RIGHTWARDS ARROW +2944 SHORT RIGHTWARDS ARROW ABOVE LEFTWARDS ARROW +2945 RIGHTWARDS ARROW WITH PLUS BELOW +2946 LEFTWARDS ARROW WITH PLUS BELOW +2947 RIGHTWARDS ARROW THROUGH X +2948 LEFT RIGHT ARROW THROUGH SMALL CIRCLE +2949 UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE +294A LEFT BARB UP RIGHT BARB DOWN HARPOON +294B LEFT BARB DOWN RIGHT BARB UP HARPOON +294C UP BARB RIGHT DOWN BARB LEFT HARPOON +294D UP BARB LEFT DOWN BARB RIGHT HARPOON +294E LEFT BARB UP RIGHT BARB UP HARPOON +294F UP BARB RIGHT DOWN BARB RIGHT HARPOON +2950 LEFT BARB DOWN RIGHT BARB DOWN HARPOON +2951 UP BARB LEFT DOWN BARB LEFT HARPOON +2952 LEFTWARDS HARPOON WITH BARB UP TO BAR +2953 RIGHTWARDS HARPOON WITH BARB UP TO BAR +2954 UPWARDS HARPOON WITH BARB RIGHT TO BAR +2955 DOWNWARDS HARPOON WITH BARB RIGHT TO BAR +2956 LEFTWARDS HARPOON WITH BARB DOWN TO BAR +2957 RIGHTWARDS HARPOON WITH BARB DOWN TO BAR +2958 UPWARDS HARPOON WITH BARB LEFT TO BAR +2959 DOWNWARDS HARPOON WITH BARB LEFT TO BAR +295A LEFTWARDS HARPOON WITH BARB UP FROM BAR +295B RIGHTWARDS HARPOON WITH BARB UP FROM BAR +295C UPWARDS HARPOON WITH BARB RIGHT FROM BAR +295D DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR +295E LEFTWARDS HARPOON WITH BARB DOWN FROM BAR +295F RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR +2960 UPWARDS HARPOON WITH BARB LEFT FROM BAR +2961 DOWNWARDS HARPOON WITH BARB LEFT FROM BAR +2962 LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN +2963 UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT +2964 RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN +2965 DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT +2966 LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP +2967 LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN +2968 RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP +2969 RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN +296A LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH +296B LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH +296C RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH +296D RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH +296E UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT +296F DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT +2970 RIGHT DOUBLE ARROW WITH ROUNDED HEAD +2971 EQUALS SIGN ABOVE RIGHTWARDS ARROW +2972 TILDE OPERATOR ABOVE RIGHTWARDS ARROW +2973 LEFTWARDS ARROW ABOVE TILDE OPERATOR +2974 RIGHTWARDS ARROW ABOVE TILDE OPERATOR +2975 RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO +2976 LESS-THAN ABOVE LEFTWARDS ARROW +2977 LEFTWARDS ARROW THROUGH LESS-THAN +2978 GREATER-THAN ABOVE RIGHTWARDS ARROW +2979 SUBSET ABOVE RIGHTWARDS ARROW +297A LEFTWARDS ARROW THROUGH SUBSET +297B SUPERSET ABOVE LEFTWARDS ARROW +297C LEFT FISH TAIL +297D RIGHT FISH TAIL +297E UP FISH TAIL +297F DOWN FISH TAIL +2980 TRIPLE VERTICAL BAR DELIMITER +2981 Z NOTATION SPOT +2982 Z NOTATION TYPE COLON +2983 LEFT WHITE CURLY BRACKET +2984 RIGHT WHITE CURLY BRACKET +2985 LEFT WHITE PARENTHESIS +2986 RIGHT WHITE PARENTHESIS +2987 Z NOTATION LEFT IMAGE BRACKET +2988 Z NOTATION RIGHT IMAGE BRACKET +2989 Z NOTATION LEFT BINDING BRACKET +298A Z NOTATION RIGHT BINDING BRACKET +298B LEFT SQUARE BRACKET WITH UNDERBAR +298C RIGHT SQUARE BRACKET WITH UNDERBAR +298D LEFT SQUARE BRACKET WITH TICK IN TOP CORNER +298E RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER +298F LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER +2990 RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER +2991 LEFT ANGLE BRACKET WITH DOT +2992 RIGHT ANGLE BRACKET WITH DOT +2993 LEFT ARC LESS-THAN BRACKET +2994 RIGHT ARC GREATER-THAN BRACKET +2995 DOUBLE LEFT ARC GREATER-THAN BRACKET +2996 DOUBLE RIGHT ARC LESS-THAN BRACKET +2997 LEFT BLACK TORTOISE SHELL BRACKET +2998 RIGHT BLACK TORTOISE SHELL BRACKET +2999 DOTTED FENCE +299A VERTICAL ZIGZAG LINE +299B MEASURED ANGLE OPENING LEFT +299C RIGHT ANGLE VARIANT WITH SQUARE +299D MEASURED RIGHT ANGLE WITH DOT +299E ANGLE WITH S INSIDE +299F ACUTE ANGLE +29A0 SPHERICAL ANGLE OPENING LEFT +29A1 SPHERICAL ANGLE OPENING UP +29A2 TURNED ANGLE +29A3 REVERSED ANGLE +29A4 ANGLE WITH UNDERBAR +29A5 REVERSED ANGLE WITH UNDERBAR +29A6 OBLIQUE ANGLE OPENING UP +29A7 OBLIQUE ANGLE OPENING DOWN +29A8 MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT +29A9 MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT +29AA MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT +29AB MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT +29AC MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP +29AD MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP +29AE MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN +29AF MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN +29B0 REVERSED EMPTY SET +29B1 EMPTY SET WITH OVERBAR +29B2 EMPTY SET WITH SMALL CIRCLE ABOVE +29B3 EMPTY SET WITH RIGHT ARROW ABOVE +29B4 EMPTY SET WITH LEFT ARROW ABOVE +29B5 CIRCLE WITH HORIZONTAL BAR +29B6 CIRCLED VERTICAL BAR +29B7 CIRCLED PARALLEL +29B8 CIRCLED REVERSE SOLIDUS +29B9 CIRCLED PERPENDICULAR +29BA CIRCLE DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BAR +29BB CIRCLE WITH SUPERIMPOSED X +29BC CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN +29BD UP ARROW THROUGH CIRCLE +29BE CIRCLED WHITE BULLET +29BF CIRCLED BULLET +29C0 CIRCLED LESS-THAN +29C1 CIRCLED GREATER-THAN +29C2 CIRCLE WITH SMALL CIRCLE TO THE RIGHT +29C3 CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT +29C4 SQUARED RISING DIAGONAL SLASH +29C5 SQUARED FALLING DIAGONAL SLASH +29C6 SQUARED ASTERISK +29C7 SQUARED SMALL CIRCLE +29C8 SQUARED SQUARE +29C9 TWO JOINED SQUARES +29CA TRIANGLE WITH DOT ABOVE +29CB TRIANGLE WITH UNDERBAR +29CC S IN TRIANGLE +29CD TRIANGLE WITH SERIFS AT BOTTOM +29CE RIGHT TRIANGLE ABOVE LEFT TRIANGLE +29CF LEFT TRIANGLE BESIDE VERTICAL BAR +29D0 VERTICAL BAR BESIDE RIGHT TRIANGLE +29D1 BOWTIE WITH LEFT HALF BLACK +29D2 BOWTIE WITH RIGHT HALF BLACK +29D3 BLACK BOWTIE +29D4 TIMES WITH LEFT HALF BLACK +29D5 TIMES WITH RIGHT HALF BLACK +29D6 WHITE HOURGLASS +29D7 BLACK HOURGLASS +29D8 LEFT WIGGLY FENCE +29D9 RIGHT WIGGLY FENCE +29DA LEFT DOUBLE WIGGLY FENCE +29DB RIGHT DOUBLE WIGGLY FENCE +29DC INCOMPLETE INFINITY +29DD TIE OVER INFINITY +29DE INFINITY NEGATED WITH VERTICAL BAR +29DF DOUBLE-ENDED MULTIMAP +29E0 SQUARE WITH CONTOURED OUTLINE +29E1 INCREASES AS +29E2 SHUFFLE PRODUCT +29E3 EQUALS SIGN AND SLANTED PARALLEL +29E4 EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE +29E5 IDENTICAL TO AND SLANTED PARALLEL +29E6 GLEICH STARK +29E7 THERMODYNAMIC +29E8 DOWN-POINTING TRIANGLE WITH LEFT HALF BLACK +29E9 DOWN-POINTING TRIANGLE WITH RIGHT HALF BLACK +29EA BLACK DIAMOND WITH DOWN ARROW +29EB BLACK LOZENGE +29EC WHITE CIRCLE WITH DOWN ARROW +29ED BLACK CIRCLE WITH DOWN ARROW +29EE ERROR-BARRED WHITE SQUARE +29EF ERROR-BARRED BLACK SQUARE +29F0 ERROR-BARRED WHITE DIAMOND +29F1 ERROR-BARRED BLACK DIAMOND +29F2 ERROR-BARRED WHITE CIRCLE +29F3 ERROR-BARRED BLACK CIRCLE +29F4 RULE-DELAYED +29F5 REVERSE SOLIDUS OPERATOR +29F6 SOLIDUS WITH OVERBAR +29F7 REVERSE SOLIDUS WITH HORIZONTAL STROKE +29F8 BIG SOLIDUS +29F9 BIG REVERSE SOLIDUS +29FA DOUBLE PLUS +29FB TRIPLE PLUS +29FC LEFT-POINTING CURVED ANGLE BRACKET +29FD RIGHT-POINTING CURVED ANGLE BRACKET +29FE TINY +29FF MINY +2A00 N-ARY CIRCLED DOT OPERATOR +2A01 N-ARY CIRCLED PLUS OPERATOR +2A02 N-ARY CIRCLED TIMES OPERATOR +2A03 N-ARY UNION OPERATOR WITH DOT +2A04 N-ARY UNION OPERATOR WITH PLUS +2A05 N-ARY SQUARE INTERSECTION OPERATOR +2A06 N-ARY SQUARE UNION OPERATOR +2A07 TWO LOGICAL AND OPERATOR +2A08 TWO LOGICAL OR OPERATOR +2A09 N-ARY TIMES OPERATOR +2A0A MODULO TWO SUM +2A0B SUMMATION WITH INTEGRAL +2A0C QUADRUPLE INTEGRAL OPERATOR +2A0D FINITE PART INTEGRAL +2A0E INTEGRAL WITH DOUBLE STROKE +2A0F INTEGRAL AVERAGE WITH SLASH +2A10 CIRCULATION FUNCTION +2A11 ANTICLOCKWISE INTEGRATION +2A12 LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE +2A13 LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE +2A14 LINE INTEGRATION NOT INCLUDING THE POLE +2A15 INTEGRAL AROUND A POINT OPERATOR +2A16 QUATERNION INTEGRAL OPERATOR +2A17 INTEGRAL WITH LEFTWARDS ARROW WITH HOOK +2A18 INTEGRAL WITH TIMES SIGN +2A19 INTEGRAL WITH INTERSECTION +2A1A INTEGRAL WITH UNION +2A1B INTEGRAL WITH OVERBAR +2A1C INTEGRAL WITH UNDERBAR +2A1D JOIN +2A1E LARGE LEFT TRIANGLE OPERATOR +2A1F Z NOTATION SCHEMA COMPOSITION +2A20 Z NOTATION SCHEMA PIPING +2A21 Z NOTATION SCHEMA PROJECTION +2A22 PLUS SIGN WITH SMALL CIRCLE ABOVE +2A23 PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE +2A24 PLUS SIGN WITH TILDE ABOVE +2A25 PLUS SIGN WITH DOT BELOW +2A26 PLUS SIGN WITH TILDE BELOW +2A27 PLUS SIGN WITH SUBSCRIPT TWO +2A28 PLUS SIGN WITH BLACK TRIANGLE +2A29 MINUS SIGN WITH COMMA ABOVE +2A2A MINUS SIGN WITH DOT BELOW +2A2B MINUS SIGN WITH FALLING DOTS +2A2C MINUS SIGN WITH RISING DOTS +2A2D PLUS SIGN IN LEFT HALF CIRCLE +2A2E PLUS SIGN IN RIGHT HALF CIRCLE +2A2F VECTOR OR CROSS PRODUCT +2A30 MULTIPLICATION SIGN WITH DOT ABOVE +2A31 MULTIPLICATION SIGN WITH UNDERBAR +2A32 SEMIDIRECT PRODUCT WITH BOTTOM CLOSED +2A33 SMASH PRODUCT +2A34 MULTIPLICATION SIGN IN LEFT HALF CIRCLE +2A35 MULTIPLICATION SIGN IN RIGHT HALF CIRCLE +2A36 CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT +2A37 MULTIPLICATION SIGN IN DOUBLE CIRCLE +2A38 CIRCLED DIVISION SIGN +2A39 PLUS SIGN IN TRIANGLE +2A3A MINUS SIGN IN TRIANGLE +2A3B MULTIPLICATION SIGN IN TRIANGLE +2A3C INTERIOR PRODUCT +2A3D RIGHTHAND INTERIOR PRODUCT +2A3E Z NOTATION RELATIONAL COMPOSITION +2A3F AMALGAMATION OR COPRODUCT +2A40 INTERSECTION WITH DOT +2A41 UNION WITH MINUS SIGN +2A42 UNION WITH OVERBAR +2A43 INTERSECTION WITH OVERBAR +2A44 INTERSECTION WITH LOGICAL AND +2A45 UNION WITH LOGICAL OR +2A46 UNION ABOVE INTERSECTION +2A47 INTERSECTION ABOVE UNION +2A48 UNION ABOVE BAR ABOVE INTERSECTION +2A49 INTERSECTION ABOVE BAR ABOVE UNION +2A4A UNION BESIDE AND JOINED WITH UNION +2A4B INTERSECTION BESIDE AND JOINED WITH INTERSECTION +2A4C CLOSED UNION WITH SERIFS +2A4D CLOSED INTERSECTION WITH SERIFS +2A4E DOUBLE SQUARE INTERSECTION +2A4F DOUBLE SQUARE UNION +2A50 CLOSED UNION WITH SERIFS AND SMASH PRODUCT +2A51 LOGICAL AND WITH DOT ABOVE +2A52 LOGICAL OR WITH DOT ABOVE +2A53 DOUBLE LOGICAL AND +2A54 DOUBLE LOGICAL OR +2A55 TWO INTERSECTING LOGICAL AND +2A56 TWO INTERSECTING LOGICAL OR +2A57 SLOPING LARGE OR +2A58 SLOPING LARGE AND +2A59 LOGICAL OR OVERLAPPING LOGICAL AND +2A5A LOGICAL AND WITH MIDDLE STEM +2A5B LOGICAL OR WITH MIDDLE STEM +2A5C LOGICAL AND WITH HORIZONTAL DASH +2A5D LOGICAL OR WITH HORIZONTAL DASH +2A5E LOGICAL AND WITH DOUBLE OVERBAR +2A5F LOGICAL AND WITH UNDERBAR +2A60 LOGICAL AND WITH DOUBLE UNDERBAR +2A61 SMALL VEE WITH UNDERBAR +2A62 LOGICAL OR WITH DOUBLE OVERBAR +2A63 LOGICAL OR WITH DOUBLE UNDERBAR +2A64 Z NOTATION DOMAIN ANTIRESTRICTION +2A65 Z NOTATION RANGE ANTIRESTRICTION +2A66 EQUALS SIGN WITH DOT BELOW +2A67 IDENTICAL WITH DOT ABOVE +2A68 TRIPLE HORIZONTAL BAR WITH DOUBLE VERTICAL STROKE +2A69 TRIPLE HORIZONTAL BAR WITH TRIPLE VERTICAL STROKE +2A6A TILDE OPERATOR WITH DOT ABOVE +2A6B TILDE OPERATOR WITH RISING DOTS +2A6C SIMILAR MINUS SIMILAR +2A6D CONGRUENT WITH DOT ABOVE +2A6E EQUALS WITH ASTERISK +2A6F ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT +2A70 APPROXIMATELY EQUAL OR EQUAL TO +2A71 EQUALS SIGN ABOVE PLUS SIGN +2A72 PLUS SIGN ABOVE EQUALS SIGN +2A73 EQUALS SIGN ABOVE TILDE OPERATOR +2A74 DOUBLE COLON EQUAL +2A75 TWO CONSECUTIVE EQUALS SIGNS +2A76 THREE CONSECUTIVE EQUALS SIGNS +2A77 EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW +2A78 EQUIVALENT WITH FOUR DOTS ABOVE +2A79 LESS-THAN WITH CIRCLE INSIDE +2A7A GREATER-THAN WITH CIRCLE INSIDE +2A7B LESS-THAN WITH QUESTION MARK ABOVE +2A7C GREATER-THAN WITH QUESTION MARK ABOVE +2A7D LESS-THAN OR SLANTED EQUAL TO +2A7E GREATER-THAN OR SLANTED EQUAL TO +2A7F LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE +2A80 GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE +2A81 LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE +2A82 GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE +2A83 LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT +2A84 GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT +2A85 LESS-THAN OR APPROXIMATE +2A86 GREATER-THAN OR APPROXIMATE +2A87 LESS-THAN AND SINGLE-LINE NOT EQUAL TO +2A88 GREATER-THAN AND SINGLE-LINE NOT EQUAL TO +2A89 LESS-THAN AND NOT APPROXIMATE +2A8A GREATER-THAN AND NOT APPROXIMATE +2A8B LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN +2A8C GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN +2A8D LESS-THAN ABOVE SIMILAR OR EQUAL +2A8E GREATER-THAN ABOVE SIMILAR OR EQUAL +2A8F LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN +2A90 GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN +2A91 LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL +2A92 GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL +2A93 LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL +2A94 GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL +2A95 SLANTED EQUAL TO OR LESS-THAN +2A96 SLANTED EQUAL TO OR GREATER-THAN +2A97 SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE +2A98 SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE +2A99 DOUBLE-LINE EQUAL TO OR LESS-THAN +2A9A DOUBLE-LINE EQUAL TO OR GREATER-THAN +2A9B DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN +2A9C DOUBLE-LINE SLANTED EQUAL TO OR GREATER-THAN +2A9D SIMILAR OR LESS-THAN +2A9E SIMILAR OR GREATER-THAN +2A9F SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN +2AA0 SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN +2AA1 DOUBLE NESTED LESS-THAN +2AA2 DOUBLE NESTED GREATER-THAN +2AA3 DOUBLE NESTED LESS-THAN WITH UNDERBAR +2AA4 GREATER-THAN OVERLAPPING LESS-THAN +2AA5 GREATER-THAN BESIDE LESS-THAN +2AA6 LESS-THAN CLOSED BY CURVE +2AA7 GREATER-THAN CLOSED BY CURVE +2AA8 LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL +2AA9 GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL +2AAA SMALLER THAN +2AAB LARGER THAN +2AAC SMALLER THAN OR EQUAL TO +2AAD LARGER THAN OR EQUAL TO +2AAE EQUALS SIGN WITH BUMPY ABOVE +2AAF PRECEDES ABOVE SINGLE-LINE EQUALS SIGN +2AB0 SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN +2AB1 PRECEDES ABOVE SINGLE-LINE NOT EQUAL TO +2AB2 SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO +2AB3 PRECEDES ABOVE EQUALS SIGN +2AB4 SUCCEEDS ABOVE EQUALS SIGN +2AB5 PRECEDES ABOVE NOT EQUAL TO +2AB6 SUCCEEDS ABOVE NOT EQUAL TO +2AB7 PRECEDES ABOVE ALMOST EQUAL TO +2AB8 SUCCEEDS ABOVE ALMOST EQUAL TO +2AB9 PRECEDES ABOVE NOT ALMOST EQUAL TO +2ABA SUCCEEDS ABOVE NOT ALMOST EQUAL TO +2ABB DOUBLE PRECEDES +2ABC DOUBLE SUCCEEDS +2ABD SUBSET WITH DOT +2ABE SUPERSET WITH DOT +2ABF SUBSET WITH PLUS SIGN BELOW +2AC0 SUPERSET WITH PLUS SIGN BELOW +2AC1 SUBSET WITH MULTIPLICATION SIGN BELOW +2AC2 SUPERSET WITH MULTIPLICATION SIGN BELOW +2AC3 SUBSET OF OR EQUAL TO WITH DOT ABOVE +2AC4 SUPERSET OF OR EQUAL TO WITH DOT ABOVE +2AC5 SUBSET OF ABOVE EQUALS SIGN +2AC6 SUPERSET OF ABOVE EQUALS SIGN +2AC7 SUBSET OF ABOVE TILDE OPERATOR +2AC8 SUPERSET OF ABOVE TILDE OPERATOR +2AC9 SUBSET OF ABOVE ALMOST EQUAL TO +2ACA SUPERSET OF ABOVE ALMOST EQUAL TO +2ACB SUBSET OF ABOVE NOT EQUAL TO +2ACC SUPERSET OF ABOVE NOT EQUAL TO +2ACD SQUARE LEFT OPEN BOX OPERATOR +2ACE SQUARE RIGHT OPEN BOX OPERATOR +2ACF CLOSED SUBSET +2AD0 CLOSED SUPERSET +2AD1 CLOSED SUBSET OR EQUAL TO +2AD2 CLOSED SUPERSET OR EQUAL TO +2AD3 SUBSET ABOVE SUPERSET +2AD4 SUPERSET ABOVE SUBSET +2AD5 SUBSET ABOVE SUBSET +2AD6 SUPERSET ABOVE SUPERSET +2AD7 SUPERSET BESIDE SUBSET +2AD8 SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET +2AD9 ELEMENT OF OPENING DOWNWARDS +2ADA PITCHFORK WITH TEE TOP +2ADB TRANSVERSAL INTERSECTION +2ADC FORKING +2ADD NONFORKING +2ADE SHORT LEFT TACK +2ADF SHORT DOWN TACK +2AE0 SHORT UP TACK +2AE1 PERPENDICULAR WITH S +2AE2 VERTICAL BAR TRIPLE RIGHT TURNSTILE +2AE3 DOUBLE VERTICAL BAR LEFT TURNSTILE +2AE4 VERTICAL BAR DOUBLE LEFT TURNSTILE +2AE5 DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE +2AE6 LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL +2AE7 SHORT DOWN TACK WITH OVERBAR +2AE8 SHORT UP TACK WITH UNDERBAR +2AE9 SHORT UP TACK ABOVE SHORT DOWN TACK +2AEA DOUBLE DOWN TACK +2AEB DOUBLE UP TACK +2AEC DOUBLE STROKE NOT SIGN +2AED REVERSED DOUBLE STROKE NOT SIGN +2AEE DOES NOT DIVIDE WITH REVERSED NEGATION SLASH +2AEF VERTICAL LINE WITH CIRCLE ABOVE +2AF0 VERTICAL LINE WITH CIRCLE BELOW +2AF1 DOWN TACK WITH CIRCLE BELOW +2AF2 PARALLEL WITH HORIZONTAL STROKE +2AF3 PARALLEL WITH TILDE OPERATOR +2AF4 TRIPLE VERTICAL BAR BINARY RELATION +2AF5 TRIPLE VERTICAL BAR WITH HORIZONTAL STROKE +2AF6 TRIPLE COLON OPERATOR +2AF7 TRIPLE NESTED LESS-THAN +2AF8 TRIPLE NESTED GREATER-THAN +2AF9 DOUBLE-LINE SLANTED LESS-THAN OR EQUAL TO +2AFA DOUBLE-LINE SLANTED GREATER-THAN OR EQUAL TO +2AFB TRIPLE SOLIDUS BINARY RELATION +2AFC LARGE TRIPLE VERTICAL BAR OPERATOR +2AFD DOUBLE SOLIDUS OPERATOR +2AFE WHITE VERTICAL BAR +2AFF N-ARY WHITE VERTICAL BAR +2E80 CJK RADICAL REPEAT +2E81 CJK RADICAL CLIFF +2E82 CJK RADICAL SECOND ONE +2E83 CJK RADICAL SECOND TWO +2E84 CJK RADICAL SECOND THREE +2E85 CJK RADICAL PERSON +2E86 CJK RADICAL BOX +2E87 CJK RADICAL TABLE +2E88 CJK RADICAL KNIFE ONE +2E89 CJK RADICAL KNIFE TWO +2E8A CJK RADICAL DIVINATION +2E8B CJK RADICAL SEAL +2E8C CJK RADICAL SMALL ONE +2E8D CJK RADICAL SMALL TWO +2E8E CJK RADICAL LAME ONE +2E8F CJK RADICAL LAME TWO +2E90 CJK RADICAL LAME THREE +2E91 CJK RADICAL LAME FOUR +2E92 CJK RADICAL SNAKE +2E93 CJK RADICAL THREAD +2E94 CJK RADICAL SNOUT ONE +2E95 CJK RADICAL SNOUT TWO +2E96 CJK RADICAL HEART ONE +2E97 CJK RADICAL HEART TWO +2E98 CJK RADICAL HAND +2E99 CJK RADICAL RAP +2E9B CJK RADICAL CHOKE +2E9C CJK RADICAL SUN +2E9D CJK RADICAL MOON +2E9E CJK RADICAL DEATH +2E9F CJK RADICAL MOTHER +2EA0 CJK RADICAL CIVILIAN +2EA1 CJK RADICAL WATER ONE +2EA2 CJK RADICAL WATER TWO +2EA3 CJK RADICAL FIRE +2EA4 CJK RADICAL PAW ONE +2EA5 CJK RADICAL PAW TWO +2EA6 CJK RADICAL SIMPLIFIED HALF TREE TRUNK +2EA7 CJK RADICAL COW +2EA8 CJK RADICAL DOG +2EA9 CJK RADICAL JADE +2EAA CJK RADICAL BOLT OF CLOTH +2EAB CJK RADICAL EYE +2EAC CJK RADICAL SPIRIT ONE +2EAD CJK RADICAL SPIRIT TWO +2EAE CJK RADICAL BAMBOO +2EAF CJK RADICAL SILK +2EB0 CJK RADICAL C-SIMPLIFIED SILK +2EB1 CJK RADICAL NET ONE +2EB2 CJK RADICAL NET TWO +2EB3 CJK RADICAL NET THREE +2EB4 CJK RADICAL NET FOUR +2EB5 CJK RADICAL MESH +2EB6 CJK RADICAL SHEEP +2EB7 CJK RADICAL RAM +2EB8 CJK RADICAL EWE +2EB9 CJK RADICAL OLD +2EBA CJK RADICAL BRUSH ONE +2EBB CJK RADICAL BRUSH TWO +2EBC CJK RADICAL MEAT +2EBD CJK RADICAL MORTAR +2EBE CJK RADICAL GRASS ONE +2EBF CJK RADICAL GRASS TWO +2EC0 CJK RADICAL GRASS THREE +2EC1 CJK RADICAL TIGER +2EC2 CJK RADICAL CLOTHES +2EC3 CJK RADICAL WEST ONE +2EC4 CJK RADICAL WEST TWO +2EC5 CJK RADICAL C-SIMPLIFIED SEE +2EC6 CJK RADICAL SIMPLIFIED HORN +2EC7 CJK RADICAL HORN +2EC8 CJK RADICAL C-SIMPLIFIED SPEECH +2EC9 CJK RADICAL C-SIMPLIFIED SHELL +2ECA CJK RADICAL FOOT +2ECB CJK RADICAL C-SIMPLIFIED CART +2ECC CJK RADICAL SIMPLIFIED WALK +2ECD CJK RADICAL WALK ONE +2ECE CJK RADICAL WALK TWO +2ECF CJK RADICAL CITY +2ED0 CJK RADICAL C-SIMPLIFIED GOLD +2ED1 CJK RADICAL LONG ONE +2ED2 CJK RADICAL LONG TWO +2ED3 CJK RADICAL C-SIMPLIFIED LONG +2ED4 CJK RADICAL C-SIMPLIFIED GATE +2ED5 CJK RADICAL MOUND ONE +2ED6 CJK RADICAL MOUND TWO +2ED7 CJK RADICAL RAIN +2ED8 CJK RADICAL BLUE +2ED9 CJK RADICAL C-SIMPLIFIED TANNED LEATHER +2EDA CJK RADICAL C-SIMPLIFIED LEAF +2EDB CJK RADICAL C-SIMPLIFIED WIND +2EDC CJK RADICAL C-SIMPLIFIED FLY +2EDD CJK RADICAL EAT ONE +2EDE CJK RADICAL EAT TWO +2EDF CJK RADICAL EAT THREE +2EE0 CJK RADICAL C-SIMPLIFIED EAT +2EE1 CJK RADICAL HEAD +2EE2 CJK RADICAL C-SIMPLIFIED HORSE +2EE3 CJK RADICAL BONE +2EE4 CJK RADICAL GHOST +2EE5 CJK RADICAL C-SIMPLIFIED FISH +2EE6 CJK RADICAL C-SIMPLIFIED BIRD +2EE7 CJK RADICAL C-SIMPLIFIED SALT +2EE8 CJK RADICAL SIMPLIFIED WHEAT +2EE9 CJK RADICAL SIMPLIFIED YELLOW +2EEA CJK RADICAL C-SIMPLIFIED FROG +2EEB CJK RADICAL J-SIMPLIFIED EVEN +2EEC CJK RADICAL C-SIMPLIFIED EVEN +2EED CJK RADICAL J-SIMPLIFIED TOOTH +2EEE CJK RADICAL C-SIMPLIFIED TOOTH +2EEF CJK RADICAL J-SIMPLIFIED DRAGON +2EF0 CJK RADICAL C-SIMPLIFIED DRAGON +2EF1 CJK RADICAL TURTLE +2EF2 CJK RADICAL J-SIMPLIFIED TURTLE +2EF3 CJK RADICAL C-SIMPLIFIED TURTLE +2F00 KANGXI RADICAL ONE +2F01 KANGXI RADICAL LINE +2F02 KANGXI RADICAL DOT +2F03 KANGXI RADICAL SLASH +2F04 KANGXI RADICAL SECOND +2F05 KANGXI RADICAL HOOK +2F06 KANGXI RADICAL TWO +2F07 KANGXI RADICAL LID +2F08 KANGXI RADICAL MAN +2F09 KANGXI RADICAL LEGS +2F0A KANGXI RADICAL ENTER +2F0B KANGXI RADICAL EIGHT +2F0C KANGXI RADICAL DOWN BOX +2F0D KANGXI RADICAL COVER +2F0E KANGXI RADICAL ICE +2F0F KANGXI RADICAL TABLE +2F10 KANGXI RADICAL OPEN BOX +2F11 KANGXI RADICAL KNIFE +2F12 KANGXI RADICAL POWER +2F13 KANGXI RADICAL WRAP +2F14 KANGXI RADICAL SPOON +2F15 KANGXI RADICAL RIGHT OPEN BOX +2F16 KANGXI RADICAL HIDING ENCLOSURE +2F17 KANGXI RADICAL TEN +2F18 KANGXI RADICAL DIVINATION +2F19 KANGXI RADICAL SEAL +2F1A KANGXI RADICAL CLIFF +2F1B KANGXI RADICAL PRIVATE +2F1C KANGXI RADICAL AGAIN +2F1D KANGXI RADICAL MOUTH +2F1E KANGXI RADICAL ENCLOSURE +2F1F KANGXI RADICAL EARTH +2F20 KANGXI RADICAL SCHOLAR +2F21 KANGXI RADICAL GO +2F22 KANGXI RADICAL GO SLOWLY +2F23 KANGXI RADICAL EVENING +2F24 KANGXI RADICAL BIG +2F25 KANGXI RADICAL WOMAN +2F26 KANGXI RADICAL CHILD +2F27 KANGXI RADICAL ROOF +2F28 KANGXI RADICAL INCH +2F29 KANGXI RADICAL SMALL +2F2A KANGXI RADICAL LAME +2F2B KANGXI RADICAL CORPSE +2F2C KANGXI RADICAL SPROUT +2F2D KANGXI RADICAL MOUNTAIN +2F2E KANGXI RADICAL RIVER +2F2F KANGXI RADICAL WORK +2F30 KANGXI RADICAL ONESELF +2F31 KANGXI RADICAL TURBAN +2F32 KANGXI RADICAL DRY +2F33 KANGXI RADICAL SHORT THREAD +2F34 KANGXI RADICAL DOTTED CLIFF +2F35 KANGXI RADICAL LONG STRIDE +2F36 KANGXI RADICAL TWO HANDS +2F37 KANGXI RADICAL SHOOT +2F38 KANGXI RADICAL BOW +2F39 KANGXI RADICAL SNOUT +2F3A KANGXI RADICAL BRISTLE +2F3B KANGXI RADICAL STEP +2F3C KANGXI RADICAL HEART +2F3D KANGXI RADICAL HALBERD +2F3E KANGXI RADICAL DOOR +2F3F KANGXI RADICAL HAND +2F40 KANGXI RADICAL BRANCH +2F41 KANGXI RADICAL RAP +2F42 KANGXI RADICAL SCRIPT +2F43 KANGXI RADICAL DIPPER +2F44 KANGXI RADICAL AXE +2F45 KANGXI RADICAL SQUARE +2F46 KANGXI RADICAL NOT +2F47 KANGXI RADICAL SUN +2F48 KANGXI RADICAL SAY +2F49 KANGXI RADICAL MOON +2F4A KANGXI RADICAL TREE +2F4B KANGXI RADICAL LACK +2F4C KANGXI RADICAL STOP +2F4D KANGXI RADICAL DEATH +2F4E KANGXI RADICAL WEAPON +2F4F KANGXI RADICAL DO NOT +2F50 KANGXI RADICAL COMPARE +2F51 KANGXI RADICAL FUR +2F52 KANGXI RADICAL CLAN +2F53 KANGXI RADICAL STEAM +2F54 KANGXI RADICAL WATER +2F55 KANGXI RADICAL FIRE +2F56 KANGXI RADICAL CLAW +2F57 KANGXI RADICAL FATHER +2F58 KANGXI RADICAL DOUBLE X +2F59 KANGXI RADICAL HALF TREE TRUNK +2F5A KANGXI RADICAL SLICE +2F5B KANGXI RADICAL FANG +2F5C KANGXI RADICAL COW +2F5D KANGXI RADICAL DOG +2F5E KANGXI RADICAL PROFOUND +2F5F KANGXI RADICAL JADE +2F60 KANGXI RADICAL MELON +2F61 KANGXI RADICAL TILE +2F62 KANGXI RADICAL SWEET +2F63 KANGXI RADICAL LIFE +2F64 KANGXI RADICAL USE +2F65 KANGXI RADICAL FIELD +2F66 KANGXI RADICAL BOLT OF CLOTH +2F67 KANGXI RADICAL SICKNESS +2F68 KANGXI RADICAL DOTTED TENT +2F69 KANGXI RADICAL WHITE +2F6A KANGXI RADICAL SKIN +2F6B KANGXI RADICAL DISH +2F6C KANGXI RADICAL EYE +2F6D KANGXI RADICAL SPEAR +2F6E KANGXI RADICAL ARROW +2F6F KANGXI RADICAL STONE +2F70 KANGXI RADICAL SPIRIT +2F71 KANGXI RADICAL TRACK +2F72 KANGXI RADICAL GRAIN +2F73 KANGXI RADICAL CAVE +2F74 KANGXI RADICAL STAND +2F75 KANGXI RADICAL BAMBOO +2F76 KANGXI RADICAL RICE +2F77 KANGXI RADICAL SILK +2F78 KANGXI RADICAL JAR +2F79 KANGXI RADICAL NET +2F7A KANGXI RADICAL SHEEP +2F7B KANGXI RADICAL FEATHER +2F7C KANGXI RADICAL OLD +2F7D KANGXI RADICAL AND +2F7E KANGXI RADICAL PLOW +2F7F KANGXI RADICAL EAR +2F80 KANGXI RADICAL BRUSH +2F81 KANGXI RADICAL MEAT +2F82 KANGXI RADICAL MINISTER +2F83 KANGXI RADICAL SELF +2F84 KANGXI RADICAL ARRIVE +2F85 KANGXI RADICAL MORTAR +2F86 KANGXI RADICAL TONGUE +2F87 KANGXI RADICAL OPPOSE +2F88 KANGXI RADICAL BOAT +2F89 KANGXI RADICAL STOPPING +2F8A KANGXI RADICAL COLOR +2F8B KANGXI RADICAL GRASS +2F8C KANGXI RADICAL TIGER +2F8D KANGXI RADICAL INSECT +2F8E KANGXI RADICAL BLOOD +2F8F KANGXI RADICAL WALK ENCLOSURE +2F90 KANGXI RADICAL CLOTHES +2F91 KANGXI RADICAL WEST +2F92 KANGXI RADICAL SEE +2F93 KANGXI RADICAL HORN +2F94 KANGXI RADICAL SPEECH +2F95 KANGXI RADICAL VALLEY +2F96 KANGXI RADICAL BEAN +2F97 KANGXI RADICAL PIG +2F98 KANGXI RADICAL BADGER +2F99 KANGXI RADICAL SHELL +2F9A KANGXI RADICAL RED +2F9B KANGXI RADICAL RUN +2F9C KANGXI RADICAL FOOT +2F9D KANGXI RADICAL BODY +2F9E KANGXI RADICAL CART +2F9F KANGXI RADICAL BITTER +2FA0 KANGXI RADICAL MORNING +2FA1 KANGXI RADICAL WALK +2FA2 KANGXI RADICAL CITY +2FA3 KANGXI RADICAL WINE +2FA4 KANGXI RADICAL DISTINGUISH +2FA5 KANGXI RADICAL VILLAGE +2FA6 KANGXI RADICAL GOLD +2FA7 KANGXI RADICAL LONG +2FA8 KANGXI RADICAL GATE +2FA9 KANGXI RADICAL MOUND +2FAA KANGXI RADICAL SLAVE +2FAB KANGXI RADICAL SHORT TAILED BIRD +2FAC KANGXI RADICAL RAIN +2FAD KANGXI RADICAL BLUE +2FAE KANGXI RADICAL WRONG +2FAF KANGXI RADICAL FACE +2FB0 KANGXI RADICAL LEATHER +2FB1 KANGXI RADICAL TANNED LEATHER +2FB2 KANGXI RADICAL LEEK +2FB3 KANGXI RADICAL SOUND +2FB4 KANGXI RADICAL LEAF +2FB5 KANGXI RADICAL WIND +2FB6 KANGXI RADICAL FLY +2FB7 KANGXI RADICAL EAT +2FB8 KANGXI RADICAL HEAD +2FB9 KANGXI RADICAL FRAGRANT +2FBA KANGXI RADICAL HORSE +2FBB KANGXI RADICAL BONE +2FBC KANGXI RADICAL TALL +2FBD KANGXI RADICAL HAIR +2FBE KANGXI RADICAL FIGHT +2FBF KANGXI RADICAL SACRIFICIAL WINE +2FC0 KANGXI RADICAL CAULDRON +2FC1 KANGXI RADICAL GHOST +2FC2 KANGXI RADICAL FISH +2FC3 KANGXI RADICAL BIRD +2FC4 KANGXI RADICAL SALT +2FC5 KANGXI RADICAL DEER +2FC6 KANGXI RADICAL WHEAT +2FC7 KANGXI RADICAL HEMP +2FC8 KANGXI RADICAL YELLOW +2FC9 KANGXI RADICAL MILLET +2FCA KANGXI RADICAL BLACK +2FCB KANGXI RADICAL EMBROIDERY +2FCC KANGXI RADICAL FROG +2FCD KANGXI RADICAL TRIPOD +2FCE KANGXI RADICAL DRUM +2FCF KANGXI RADICAL RAT +2FD0 KANGXI RADICAL NOSE +2FD1 KANGXI RADICAL EVEN +2FD2 KANGXI RADICAL TOOTH +2FD3 KANGXI RADICAL DRAGON +2FD4 KANGXI RADICAL TURTLE +2FD5 KANGXI RADICAL FLUTE +2FF0 IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT +2FF1 IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW +2FF2 IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT +2FF3 IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW +2FF4 IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND +2FF5 IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM ABOVE +2FF6 IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM BELOW +2FF7 IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LEFT +2FF8 IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER LEFT +2FF9 IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER RIGHT +2FFA IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER LEFT +2FFB IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID +3000 IDEOGRAPHIC SPACE +3001 IDEOGRAPHIC COMMA +3002 IDEOGRAPHIC FULL STOP +3003 DITTO MARK +3004 JAPANESE INDUSTRIAL STANDARD SYMBOL +3005 IDEOGRAPHIC ITERATION MARK +3006 IDEOGRAPHIC CLOSING MARK +3007 IDEOGRAPHIC NUMBER ZERO +3008 LEFT ANGLE BRACKET +3009 RIGHT ANGLE BRACKET +300A LEFT DOUBLE ANGLE BRACKET +300B RIGHT DOUBLE ANGLE BRACKET +300C LEFT CORNER BRACKET +300D RIGHT CORNER BRACKET +300E LEFT WHITE CORNER BRACKET +300F RIGHT WHITE CORNER BRACKET +3010 LEFT BLACK LENTICULAR BRACKET +3011 RIGHT BLACK LENTICULAR BRACKET +3012 POSTAL MARK +3013 GETA MARK +3014 LEFT TORTOISE SHELL BRACKET +3015 RIGHT TORTOISE SHELL BRACKET +3016 LEFT WHITE LENTICULAR BRACKET +3017 RIGHT WHITE LENTICULAR BRACKET +3018 LEFT WHITE TORTOISE SHELL BRACKET +3019 RIGHT WHITE TORTOISE SHELL BRACKET +301A LEFT WHITE SQUARE BRACKET +301B RIGHT WHITE SQUARE BRACKET +301C WAVE DASH +301D REVERSED DOUBLE PRIME QUOTATION MARK +301E DOUBLE PRIME QUOTATION MARK +301F LOW DOUBLE PRIME QUOTATION MARK +3020 POSTAL MARK FACE +3021 HANGZHOU NUMERAL ONE +3022 HANGZHOU NUMERAL TWO +3023 HANGZHOU NUMERAL THREE +3024 HANGZHOU NUMERAL FOUR +3025 HANGZHOU NUMERAL FIVE +3026 HANGZHOU NUMERAL SIX +3027 HANGZHOU NUMERAL SEVEN +3028 HANGZHOU NUMERAL EIGHT +3029 HANGZHOU NUMERAL NINE +302A IDEOGRAPHIC LEVEL TONE MARK +302B IDEOGRAPHIC RISING TONE MARK +302C IDEOGRAPHIC DEPARTING TONE MARK +302D IDEOGRAPHIC ENTERING TONE MARK +302E HANGUL SINGLE DOT TONE MARK +302F HANGUL DOUBLE DOT TONE MARK +3030 WAVY DASH +3031 VERTICAL KANA REPEAT MARK +3032 VERTICAL KANA REPEAT WITH VOICED SOUND MARK +3033 VERTICAL KANA REPEAT MARK UPPER HALF +3034 VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF +3035 VERTICAL KANA REPEAT MARK LOWER HALF +3036 CIRCLED POSTAL MARK +3037 IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL +3038 HANGZHOU NUMERAL TEN +3039 HANGZHOU NUMERAL TWENTY +303A HANGZHOU NUMERAL THIRTY +303B VERTICAL IDEOGRAPHIC ITERATION MARK +303C MASU MARK +303D PART ALTERNATION MARK +303E IDEOGRAPHIC VARIATION INDICATOR +303F IDEOGRAPHIC HALF FILL SPACE +3041 HIRAGANA LETTER SMALL A +3042 HIRAGANA LETTER A +3043 HIRAGANA LETTER SMALL I +3044 HIRAGANA LETTER I +3045 HIRAGANA LETTER SMALL U +3046 HIRAGANA LETTER U +3047 HIRAGANA LETTER SMALL E +3048 HIRAGANA LETTER E +3049 HIRAGANA LETTER SMALL O +304A HIRAGANA LETTER O +304B HIRAGANA LETTER KA +304C HIRAGANA LETTER GA +304D HIRAGANA LETTER KI +304E HIRAGANA LETTER GI +304F HIRAGANA LETTER KU +3050 HIRAGANA LETTER GU +3051 HIRAGANA LETTER KE +3052 HIRAGANA LETTER GE +3053 HIRAGANA LETTER KO +3054 HIRAGANA LETTER GO +3055 HIRAGANA LETTER SA +3056 HIRAGANA LETTER ZA +3057 HIRAGANA LETTER SI +3058 HIRAGANA LETTER ZI +3059 HIRAGANA LETTER SU +305A HIRAGANA LETTER ZU +305B HIRAGANA LETTER SE +305C HIRAGANA LETTER ZE +305D HIRAGANA LETTER SO +305E HIRAGANA LETTER ZO +305F HIRAGANA LETTER TA +3060 HIRAGANA LETTER DA +3061 HIRAGANA LETTER TI +3062 HIRAGANA LETTER DI +3063 HIRAGANA LETTER SMALL TU +3064 HIRAGANA LETTER TU +3065 HIRAGANA LETTER DU +3066 HIRAGANA LETTER TE +3067 HIRAGANA LETTER DE +3068 HIRAGANA LETTER TO +3069 HIRAGANA LETTER DO +306A HIRAGANA LETTER NA +306B HIRAGANA LETTER NI +306C HIRAGANA LETTER NU +306D HIRAGANA LETTER NE +306E HIRAGANA LETTER NO +306F HIRAGANA LETTER HA +3070 HIRAGANA LETTER BA +3071 HIRAGANA LETTER PA +3072 HIRAGANA LETTER HI +3073 HIRAGANA LETTER BI +3074 HIRAGANA LETTER PI +3075 HIRAGANA LETTER HU +3076 HIRAGANA LETTER BU +3077 HIRAGANA LETTER PU +3078 HIRAGANA LETTER HE +3079 HIRAGANA LETTER BE +307A HIRAGANA LETTER PE +307B HIRAGANA LETTER HO +307C HIRAGANA LETTER BO +307D HIRAGANA LETTER PO +307E HIRAGANA LETTER MA +307F HIRAGANA LETTER MI +3080 HIRAGANA LETTER MU +3081 HIRAGANA LETTER ME +3082 HIRAGANA LETTER MO +3083 HIRAGANA LETTER SMALL YA +3084 HIRAGANA LETTER YA +3085 HIRAGANA LETTER SMALL YU +3086 HIRAGANA LETTER YU +3087 HIRAGANA LETTER SMALL YO +3088 HIRAGANA LETTER YO +3089 HIRAGANA LETTER RA +308A HIRAGANA LETTER RI +308B HIRAGANA LETTER RU +308C HIRAGANA LETTER RE +308D HIRAGANA LETTER RO +308E HIRAGANA LETTER SMALL WA +308F HIRAGANA LETTER WA +3090 HIRAGANA LETTER WI +3091 HIRAGANA LETTER WE +3092 HIRAGANA LETTER WO +3093 HIRAGANA LETTER N +3094 HIRAGANA LETTER VU +3095 HIRAGANA LETTER SMALL KA +3096 HIRAGANA LETTER SMALL KE +3099 COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK +309A COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK +309B KATAKANA-HIRAGANA VOICED SOUND MARK +309C KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK +309D HIRAGANA ITERATION MARK +309E HIRAGANA VOICED ITERATION MARK +309F HIRAGANA DIGRAPH YORI +30A0 KATAKANA-HIRAGANA DOUBLE HYPHEN +30A1 KATAKANA LETTER SMALL A +30A2 KATAKANA LETTER A +30A3 KATAKANA LETTER SMALL I +30A4 KATAKANA LETTER I +30A5 KATAKANA LETTER SMALL U +30A6 KATAKANA LETTER U +30A7 KATAKANA LETTER SMALL E +30A8 KATAKANA LETTER E +30A9 KATAKANA LETTER SMALL O +30AA KATAKANA LETTER O +30AB KATAKANA LETTER KA +30AC KATAKANA LETTER GA +30AD KATAKANA LETTER KI +30AE KATAKANA LETTER GI +30AF KATAKANA LETTER KU +30B0 KATAKANA LETTER GU +30B1 KATAKANA LETTER KE +30B2 KATAKANA LETTER GE +30B3 KATAKANA LETTER KO +30B4 KATAKANA LETTER GO +30B5 KATAKANA LETTER SA +30B6 KATAKANA LETTER ZA +30B7 KATAKANA LETTER SI +30B8 KATAKANA LETTER ZI +30B9 KATAKANA LETTER SU +30BA KATAKANA LETTER ZU +30BB KATAKANA LETTER SE +30BC KATAKANA LETTER ZE +30BD KATAKANA LETTER SO +30BE KATAKANA LETTER ZO +30BF KATAKANA LETTER TA +30C0 KATAKANA LETTER DA +30C1 KATAKANA LETTER TI +30C2 KATAKANA LETTER DI +30C3 KATAKANA LETTER SMALL TU +30C4 KATAKANA LETTER TU +30C5 KATAKANA LETTER DU +30C6 KATAKANA LETTER TE +30C7 KATAKANA LETTER DE +30C8 KATAKANA LETTER TO +30C9 KATAKANA LETTER DO +30CA KATAKANA LETTER NA +30CB KATAKANA LETTER NI +30CC KATAKANA LETTER NU +30CD KATAKANA LETTER NE +30CE KATAKANA LETTER NO +30CF KATAKANA LETTER HA +30D0 KATAKANA LETTER BA +30D1 KATAKANA LETTER PA +30D2 KATAKANA LETTER HI +30D3 KATAKANA LETTER BI +30D4 KATAKANA LETTER PI +30D5 KATAKANA LETTER HU +30D6 KATAKANA LETTER BU +30D7 KATAKANA LETTER PU +30D8 KATAKANA LETTER HE +30D9 KATAKANA LETTER BE +30DA KATAKANA LETTER PE +30DB KATAKANA LETTER HO +30DC KATAKANA LETTER BO +30DD KATAKANA LETTER PO +30DE KATAKANA LETTER MA +30DF KATAKANA LETTER MI +30E0 KATAKANA LETTER MU +30E1 KATAKANA LETTER ME +30E2 KATAKANA LETTER MO +30E3 KATAKANA LETTER SMALL YA +30E4 KATAKANA LETTER YA +30E5 KATAKANA LETTER SMALL YU +30E6 KATAKANA LETTER YU +30E7 KATAKANA LETTER SMALL YO +30E8 KATAKANA LETTER YO +30E9 KATAKANA LETTER RA +30EA KATAKANA LETTER RI +30EB KATAKANA LETTER RU +30EC KATAKANA LETTER RE +30ED KATAKANA LETTER RO +30EE KATAKANA LETTER SMALL WA +30EF KATAKANA LETTER WA +30F0 KATAKANA LETTER WI +30F1 KATAKANA LETTER WE +30F2 KATAKANA LETTER WO +30F3 KATAKANA LETTER N +30F4 KATAKANA LETTER VU +30F5 KATAKANA LETTER SMALL KA +30F6 KATAKANA LETTER SMALL KE +30F7 KATAKANA LETTER VA +30F8 KATAKANA LETTER VI +30F9 KATAKANA LETTER VE +30FA KATAKANA LETTER VO +30FB KATAKANA MIDDLE DOT +30FC KATAKANA-HIRAGANA PROLONGED SOUND MARK +30FD KATAKANA ITERATION MARK +30FE KATAKANA VOICED ITERATION MARK +30FF KATAKANA DIGRAPH KOTO +3105 BOPOMOFO LETTER B +3106 BOPOMOFO LETTER P +3107 BOPOMOFO LETTER M +3108 BOPOMOFO LETTER F +3109 BOPOMOFO LETTER D +310A BOPOMOFO LETTER T +310B BOPOMOFO LETTER N +310C BOPOMOFO LETTER L +310D BOPOMOFO LETTER G +310E BOPOMOFO LETTER K +310F BOPOMOFO LETTER H +3110 BOPOMOFO LETTER J +3111 BOPOMOFO LETTER Q +3112 BOPOMOFO LETTER X +3113 BOPOMOFO LETTER ZH +3114 BOPOMOFO LETTER CH +3115 BOPOMOFO LETTER SH +3116 BOPOMOFO LETTER R +3117 BOPOMOFO LETTER Z +3118 BOPOMOFO LETTER C +3119 BOPOMOFO LETTER S +311A BOPOMOFO LETTER A +311B BOPOMOFO LETTER O +311C BOPOMOFO LETTER E +311D BOPOMOFO LETTER EH +311E BOPOMOFO LETTER AI +311F BOPOMOFO LETTER EI +3120 BOPOMOFO LETTER AU +3121 BOPOMOFO LETTER OU +3122 BOPOMOFO LETTER AN +3123 BOPOMOFO LETTER EN +3124 BOPOMOFO LETTER ANG +3125 BOPOMOFO LETTER ENG +3126 BOPOMOFO LETTER ER +3127 BOPOMOFO LETTER I +3128 BOPOMOFO LETTER U +3129 BOPOMOFO LETTER IU +312A BOPOMOFO LETTER V +312B BOPOMOFO LETTER NG +312C BOPOMOFO LETTER GN +3131 HANGUL LETTER KIYEOK +3132 HANGUL LETTER SSANGKIYEOK +3133 HANGUL LETTER KIYEOK-SIOS +3134 HANGUL LETTER NIEUN +3135 HANGUL LETTER NIEUN-CIEUC +3136 HANGUL LETTER NIEUN-HIEUH +3137 HANGUL LETTER TIKEUT +3138 HANGUL LETTER SSANGTIKEUT +3139 HANGUL LETTER RIEUL +313A HANGUL LETTER RIEUL-KIYEOK +313B HANGUL LETTER RIEUL-MIEUM +313C HANGUL LETTER RIEUL-PIEUP +313D HANGUL LETTER RIEUL-SIOS +313E HANGUL LETTER RIEUL-THIEUTH +313F HANGUL LETTER RIEUL-PHIEUPH +3140 HANGUL LETTER RIEUL-HIEUH +3141 HANGUL LETTER MIEUM +3142 HANGUL LETTER PIEUP +3143 HANGUL LETTER SSANGPIEUP +3144 HANGUL LETTER PIEUP-SIOS +3145 HANGUL LETTER SIOS +3146 HANGUL LETTER SSANGSIOS +3147 HANGUL LETTER IEUNG +3148 HANGUL LETTER CIEUC +3149 HANGUL LETTER SSANGCIEUC +314A HANGUL LETTER CHIEUCH +314B HANGUL LETTER KHIEUKH +314C HANGUL LETTER THIEUTH +314D HANGUL LETTER PHIEUPH +314E HANGUL LETTER HIEUH +314F HANGUL LETTER A +3150 HANGUL LETTER AE +3151 HANGUL LETTER YA +3152 HANGUL LETTER YAE +3153 HANGUL LETTER EO +3154 HANGUL LETTER E +3155 HANGUL LETTER YEO +3156 HANGUL LETTER YE +3157 HANGUL LETTER O +3158 HANGUL LETTER WA +3159 HANGUL LETTER WAE +315A HANGUL LETTER OE +315B HANGUL LETTER YO +315C HANGUL LETTER U +315D HANGUL LETTER WEO +315E HANGUL LETTER WE +315F HANGUL LETTER WI +3160 HANGUL LETTER YU +3161 HANGUL LETTER EU +3162 HANGUL LETTER YI +3163 HANGUL LETTER I +3164 HANGUL FILLER +3165 HANGUL LETTER SSANGNIEUN +3166 HANGUL LETTER NIEUN-TIKEUT +3167 HANGUL LETTER NIEUN-SIOS +3168 HANGUL LETTER NIEUN-PANSIOS +3169 HANGUL LETTER RIEUL-KIYEOK-SIOS +316A HANGUL LETTER RIEUL-TIKEUT +316B HANGUL LETTER RIEUL-PIEUP-SIOS +316C HANGUL LETTER RIEUL-PANSIOS +316D HANGUL LETTER RIEUL-YEORINHIEUH +316E HANGUL LETTER MIEUM-PIEUP +316F HANGUL LETTER MIEUM-SIOS +3170 HANGUL LETTER MIEUM-PANSIOS +3171 HANGUL LETTER KAPYEOUNMIEUM +3172 HANGUL LETTER PIEUP-KIYEOK +3173 HANGUL LETTER PIEUP-TIKEUT +3174 HANGUL LETTER PIEUP-SIOS-KIYEOK +3175 HANGUL LETTER PIEUP-SIOS-TIKEUT +3176 HANGUL LETTER PIEUP-CIEUC +3177 HANGUL LETTER PIEUP-THIEUTH +3178 HANGUL LETTER KAPYEOUNPIEUP +3179 HANGUL LETTER KAPYEOUNSSANGPIEUP +317A HANGUL LETTER SIOS-KIYEOK +317B HANGUL LETTER SIOS-NIEUN +317C HANGUL LETTER SIOS-TIKEUT +317D HANGUL LETTER SIOS-PIEUP +317E HANGUL LETTER SIOS-CIEUC +317F HANGUL LETTER PANSIOS +3180 HANGUL LETTER SSANGIEUNG +3181 HANGUL LETTER YESIEUNG +3182 HANGUL LETTER YESIEUNG-SIOS +3183 HANGUL LETTER YESIEUNG-PANSIOS +3184 HANGUL LETTER KAPYEOUNPHIEUPH +3185 HANGUL LETTER SSANGHIEUH +3186 HANGUL LETTER YEORINHIEUH +3187 HANGUL LETTER YO-YA +3188 HANGUL LETTER YO-YAE +3189 HANGUL LETTER YO-I +318A HANGUL LETTER YU-YEO +318B HANGUL LETTER YU-YE +318C HANGUL LETTER YU-I +318D HANGUL LETTER ARAEA +318E HANGUL LETTER ARAEAE +3190 IDEOGRAPHIC ANNOTATION LINKING MARK +3191 IDEOGRAPHIC ANNOTATION REVERSE MARK +3192 IDEOGRAPHIC ANNOTATION ONE MARK +3193 IDEOGRAPHIC ANNOTATION TWO MARK +3194 IDEOGRAPHIC ANNOTATION THREE MARK +3195 IDEOGRAPHIC ANNOTATION FOUR MARK +3196 IDEOGRAPHIC ANNOTATION TOP MARK +3197 IDEOGRAPHIC ANNOTATION MIDDLE MARK +3198 IDEOGRAPHIC ANNOTATION BOTTOM MARK +3199 IDEOGRAPHIC ANNOTATION FIRST MARK +319A IDEOGRAPHIC ANNOTATION SECOND MARK +319B IDEOGRAPHIC ANNOTATION THIRD MARK +319C IDEOGRAPHIC ANNOTATION FOURTH MARK +319D IDEOGRAPHIC ANNOTATION HEAVEN MARK +319E IDEOGRAPHIC ANNOTATION EARTH MARK +319F IDEOGRAPHIC ANNOTATION MAN MARK +31A0 BOPOMOFO LETTER BU +31A1 BOPOMOFO LETTER ZI +31A2 BOPOMOFO LETTER JI +31A3 BOPOMOFO LETTER GU +31A4 BOPOMOFO LETTER EE +31A5 BOPOMOFO LETTER ENN +31A6 BOPOMOFO LETTER OO +31A7 BOPOMOFO LETTER ONN +31A8 BOPOMOFO LETTER IR +31A9 BOPOMOFO LETTER ANN +31AA BOPOMOFO LETTER INN +31AB BOPOMOFO LETTER UNN +31AC BOPOMOFO LETTER IM +31AD BOPOMOFO LETTER NGG +31AE BOPOMOFO LETTER AINN +31AF BOPOMOFO LETTER AUNN +31B0 BOPOMOFO LETTER AM +31B1 BOPOMOFO LETTER OM +31B2 BOPOMOFO LETTER ONG +31B3 BOPOMOFO LETTER INNN +31B4 BOPOMOFO FINAL LETTER P +31B5 BOPOMOFO FINAL LETTER T +31B6 BOPOMOFO FINAL LETTER K +31B7 BOPOMOFO FINAL LETTER H +31F0 KATAKANA LETTER SMALL KU +31F1 KATAKANA LETTER SMALL SI +31F2 KATAKANA LETTER SMALL SU +31F3 KATAKANA LETTER SMALL TO +31F4 KATAKANA LETTER SMALL NU +31F5 KATAKANA LETTER SMALL HA +31F6 KATAKANA LETTER SMALL HI +31F7 KATAKANA LETTER SMALL HU +31F8 KATAKANA LETTER SMALL HE +31F9 KATAKANA LETTER SMALL HO +31FA KATAKANA LETTER SMALL MU +31FB KATAKANA LETTER SMALL RA +31FC KATAKANA LETTER SMALL RI +31FD KATAKANA LETTER SMALL RU +31FE KATAKANA LETTER SMALL RE +31FF KATAKANA LETTER SMALL RO +3200 PARENTHESIZED HANGUL KIYEOK +3201 PARENTHESIZED HANGUL NIEUN +3202 PARENTHESIZED HANGUL TIKEUT +3203 PARENTHESIZED HANGUL RIEUL +3204 PARENTHESIZED HANGUL MIEUM +3205 PARENTHESIZED HANGUL PIEUP +3206 PARENTHESIZED HANGUL SIOS +3207 PARENTHESIZED HANGUL IEUNG +3208 PARENTHESIZED HANGUL CIEUC +3209 PARENTHESIZED HANGUL CHIEUCH +320A PARENTHESIZED HANGUL KHIEUKH +320B PARENTHESIZED HANGUL THIEUTH +320C PARENTHESIZED HANGUL PHIEUPH +320D PARENTHESIZED HANGUL HIEUH +320E PARENTHESIZED HANGUL KIYEOK A +320F PARENTHESIZED HANGUL NIEUN A +3210 PARENTHESIZED HANGUL TIKEUT A +3211 PARENTHESIZED HANGUL RIEUL A +3212 PARENTHESIZED HANGUL MIEUM A +3213 PARENTHESIZED HANGUL PIEUP A +3214 PARENTHESIZED HANGUL SIOS A +3215 PARENTHESIZED HANGUL IEUNG A +3216 PARENTHESIZED HANGUL CIEUC A +3217 PARENTHESIZED HANGUL CHIEUCH A +3218 PARENTHESIZED HANGUL KHIEUKH A +3219 PARENTHESIZED HANGUL THIEUTH A +321A PARENTHESIZED HANGUL PHIEUPH A +321B PARENTHESIZED HANGUL HIEUH A +321C PARENTHESIZED HANGUL CIEUC U +3220 PARENTHESIZED IDEOGRAPH ONE +3221 PARENTHESIZED IDEOGRAPH TWO +3222 PARENTHESIZED IDEOGRAPH THREE +3223 PARENTHESIZED IDEOGRAPH FOUR +3224 PARENTHESIZED IDEOGRAPH FIVE +3225 PARENTHESIZED IDEOGRAPH SIX +3226 PARENTHESIZED IDEOGRAPH SEVEN +3227 PARENTHESIZED IDEOGRAPH EIGHT +3228 PARENTHESIZED IDEOGRAPH NINE +3229 PARENTHESIZED IDEOGRAPH TEN +322A PARENTHESIZED IDEOGRAPH MOON +322B PARENTHESIZED IDEOGRAPH FIRE +322C PARENTHESIZED IDEOGRAPH WATER +322D PARENTHESIZED IDEOGRAPH WOOD +322E PARENTHESIZED IDEOGRAPH METAL +322F PARENTHESIZED IDEOGRAPH EARTH +3230 PARENTHESIZED IDEOGRAPH SUN +3231 PARENTHESIZED IDEOGRAPH STOCK +3232 PARENTHESIZED IDEOGRAPH HAVE +3233 PARENTHESIZED IDEOGRAPH SOCIETY +3234 PARENTHESIZED IDEOGRAPH NAME +3235 PARENTHESIZED IDEOGRAPH SPECIAL +3236 PARENTHESIZED IDEOGRAPH FINANCIAL +3237 PARENTHESIZED IDEOGRAPH CONGRATULATION +3238 PARENTHESIZED IDEOGRAPH LABOR +3239 PARENTHESIZED IDEOGRAPH REPRESENT +323A PARENTHESIZED IDEOGRAPH CALL +323B PARENTHESIZED IDEOGRAPH STUDY +323C PARENTHESIZED IDEOGRAPH SUPERVISE +323D PARENTHESIZED IDEOGRAPH ENTERPRISE +323E PARENTHESIZED IDEOGRAPH RESOURCE +323F PARENTHESIZED IDEOGRAPH ALLIANCE +3240 PARENTHESIZED IDEOGRAPH FESTIVAL +3241 PARENTHESIZED IDEOGRAPH REST +3242 PARENTHESIZED IDEOGRAPH SELF +3243 PARENTHESIZED IDEOGRAPH REACH +3251 CIRCLED NUMBER TWENTY ONE +3252 CIRCLED NUMBER TWENTY TWO +3253 CIRCLED NUMBER TWENTY THREE +3254 CIRCLED NUMBER TWENTY FOUR +3255 CIRCLED NUMBER TWENTY FIVE +3256 CIRCLED NUMBER TWENTY SIX +3257 CIRCLED NUMBER TWENTY SEVEN +3258 CIRCLED NUMBER TWENTY EIGHT +3259 CIRCLED NUMBER TWENTY NINE +325A CIRCLED NUMBER THIRTY +325B CIRCLED NUMBER THIRTY ONE +325C CIRCLED NUMBER THIRTY TWO +325D CIRCLED NUMBER THIRTY THREE +325E CIRCLED NUMBER THIRTY FOUR +325F CIRCLED NUMBER THIRTY FIVE +3260 CIRCLED HANGUL KIYEOK +3261 CIRCLED HANGUL NIEUN +3262 CIRCLED HANGUL TIKEUT +3263 CIRCLED HANGUL RIEUL +3264 CIRCLED HANGUL MIEUM +3265 CIRCLED HANGUL PIEUP +3266 CIRCLED HANGUL SIOS +3267 CIRCLED HANGUL IEUNG +3268 CIRCLED HANGUL CIEUC +3269 CIRCLED HANGUL CHIEUCH +326A CIRCLED HANGUL KHIEUKH +326B CIRCLED HANGUL THIEUTH +326C CIRCLED HANGUL PHIEUPH +326D CIRCLED HANGUL HIEUH +326E CIRCLED HANGUL KIYEOK A +326F CIRCLED HANGUL NIEUN A +3270 CIRCLED HANGUL TIKEUT A +3271 CIRCLED HANGUL RIEUL A +3272 CIRCLED HANGUL MIEUM A +3273 CIRCLED HANGUL PIEUP A +3274 CIRCLED HANGUL SIOS A +3275 CIRCLED HANGUL IEUNG A +3276 CIRCLED HANGUL CIEUC A +3277 CIRCLED HANGUL CHIEUCH A +3278 CIRCLED HANGUL KHIEUKH A +3279 CIRCLED HANGUL THIEUTH A +327A CIRCLED HANGUL PHIEUPH A +327B CIRCLED HANGUL HIEUH A +327F KOREAN STANDARD SYMBOL +3280 CIRCLED IDEOGRAPH ONE +3281 CIRCLED IDEOGRAPH TWO +3282 CIRCLED IDEOGRAPH THREE +3283 CIRCLED IDEOGRAPH FOUR +3284 CIRCLED IDEOGRAPH FIVE +3285 CIRCLED IDEOGRAPH SIX +3286 CIRCLED IDEOGRAPH SEVEN +3287 CIRCLED IDEOGRAPH EIGHT +3288 CIRCLED IDEOGRAPH NINE +3289 CIRCLED IDEOGRAPH TEN +328A CIRCLED IDEOGRAPH MOON +328B CIRCLED IDEOGRAPH FIRE +328C CIRCLED IDEOGRAPH WATER +328D CIRCLED IDEOGRAPH WOOD +328E CIRCLED IDEOGRAPH METAL +328F CIRCLED IDEOGRAPH EARTH +3290 CIRCLED IDEOGRAPH SUN +3291 CIRCLED IDEOGRAPH STOCK +3292 CIRCLED IDEOGRAPH HAVE +3293 CIRCLED IDEOGRAPH SOCIETY +3294 CIRCLED IDEOGRAPH NAME +3295 CIRCLED IDEOGRAPH SPECIAL +3296 CIRCLED IDEOGRAPH FINANCIAL +3297 CIRCLED IDEOGRAPH CONGRATULATION +3298 CIRCLED IDEOGRAPH LABOR +3299 CIRCLED IDEOGRAPH SECRET +329A CIRCLED IDEOGRAPH MALE +329B CIRCLED IDEOGRAPH FEMALE +329C CIRCLED IDEOGRAPH SUITABLE +329D CIRCLED IDEOGRAPH EXCELLENT +329E CIRCLED IDEOGRAPH PRINT +329F CIRCLED IDEOGRAPH ATTENTION +32A0 CIRCLED IDEOGRAPH ITEM +32A1 CIRCLED IDEOGRAPH REST +32A2 CIRCLED IDEOGRAPH COPY +32A3 CIRCLED IDEOGRAPH CORRECT +32A4 CIRCLED IDEOGRAPH HIGH +32A5 CIRCLED IDEOGRAPH CENTRE +32A6 CIRCLED IDEOGRAPH LOW +32A7 CIRCLED IDEOGRAPH LEFT +32A8 CIRCLED IDEOGRAPH RIGHT +32A9 CIRCLED IDEOGRAPH MEDICINE +32AA CIRCLED IDEOGRAPH RELIGION +32AB CIRCLED IDEOGRAPH STUDY +32AC CIRCLED IDEOGRAPH SUPERVISE +32AD CIRCLED IDEOGRAPH ENTERPRISE +32AE CIRCLED IDEOGRAPH RESOURCE +32AF CIRCLED IDEOGRAPH ALLIANCE +32B0 CIRCLED IDEOGRAPH NIGHT +32B1 CIRCLED NUMBER THIRTY SIX +32B2 CIRCLED NUMBER THIRTY SEVEN +32B3 CIRCLED NUMBER THIRTY EIGHT +32B4 CIRCLED NUMBER THIRTY NINE +32B5 CIRCLED NUMBER FORTY +32B6 CIRCLED NUMBER FORTY ONE +32B7 CIRCLED NUMBER FORTY TWO +32B8 CIRCLED NUMBER FORTY THREE +32B9 CIRCLED NUMBER FORTY FOUR +32BA CIRCLED NUMBER FORTY FIVE +32BB CIRCLED NUMBER FORTY SIX +32BC CIRCLED NUMBER FORTY SEVEN +32BD CIRCLED NUMBER FORTY EIGHT +32BE CIRCLED NUMBER FORTY NINE +32BF CIRCLED NUMBER FIFTY +32C0 IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY +32C1 IDEOGRAPHIC TELEGRAPH SYMBOL FOR FEBRUARY +32C2 IDEOGRAPHIC TELEGRAPH SYMBOL FOR MARCH +32C3 IDEOGRAPHIC TELEGRAPH SYMBOL FOR APRIL +32C4 IDEOGRAPHIC TELEGRAPH SYMBOL FOR MAY +32C5 IDEOGRAPHIC TELEGRAPH SYMBOL FOR JUNE +32C6 IDEOGRAPHIC TELEGRAPH SYMBOL FOR JULY +32C7 IDEOGRAPHIC TELEGRAPH SYMBOL FOR AUGUST +32C8 IDEOGRAPHIC TELEGRAPH SYMBOL FOR SEPTEMBER +32C9 IDEOGRAPHIC TELEGRAPH SYMBOL FOR OCTOBER +32CA IDEOGRAPHIC TELEGRAPH SYMBOL FOR NOVEMBER +32CB IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER +32D0 CIRCLED KATAKANA A +32D1 CIRCLED KATAKANA I +32D2 CIRCLED KATAKANA U +32D3 CIRCLED KATAKANA E +32D4 CIRCLED KATAKANA O +32D5 CIRCLED KATAKANA KA +32D6 CIRCLED KATAKANA KI +32D7 CIRCLED KATAKANA KU +32D8 CIRCLED KATAKANA KE +32D9 CIRCLED KATAKANA KO +32DA CIRCLED KATAKANA SA +32DB CIRCLED KATAKANA SI +32DC CIRCLED KATAKANA SU +32DD CIRCLED KATAKANA SE +32DE CIRCLED KATAKANA SO +32DF CIRCLED KATAKANA TA +32E0 CIRCLED KATAKANA TI +32E1 CIRCLED KATAKANA TU +32E2 CIRCLED KATAKANA TE +32E3 CIRCLED KATAKANA TO +32E4 CIRCLED KATAKANA NA +32E5 CIRCLED KATAKANA NI +32E6 CIRCLED KATAKANA NU +32E7 CIRCLED KATAKANA NE +32E8 CIRCLED KATAKANA NO +32E9 CIRCLED KATAKANA HA +32EA CIRCLED KATAKANA HI +32EB CIRCLED KATAKANA HU +32EC CIRCLED KATAKANA HE +32ED CIRCLED KATAKANA HO +32EE CIRCLED KATAKANA MA +32EF CIRCLED KATAKANA MI +32F0 CIRCLED KATAKANA MU +32F1 CIRCLED KATAKANA ME +32F2 CIRCLED KATAKANA MO +32F3 CIRCLED KATAKANA YA +32F4 CIRCLED KATAKANA YU +32F5 CIRCLED KATAKANA YO +32F6 CIRCLED KATAKANA RA +32F7 CIRCLED KATAKANA RI +32F8 CIRCLED KATAKANA RU +32F9 CIRCLED KATAKANA RE +32FA CIRCLED KATAKANA RO +32FB CIRCLED KATAKANA WA +32FC CIRCLED KATAKANA WI +32FD CIRCLED KATAKANA WE +32FE CIRCLED KATAKANA WO +3300 SQUARE APAATO +3301 SQUARE ARUHUA +3302 SQUARE ANPEA +3303 SQUARE AARU +3304 SQUARE ININGU +3305 SQUARE INTI +3306 SQUARE UON +3307 SQUARE ESUKUUDO +3308 SQUARE EEKAA +3309 SQUARE ONSU +330A SQUARE OOMU +330B SQUARE KAIRI +330C SQUARE KARATTO +330D SQUARE KARORII +330E SQUARE GARON +330F SQUARE GANMA +3310 SQUARE GIGA +3311 SQUARE GINII +3312 SQUARE KYURII +3313 SQUARE GIRUDAA +3314 SQUARE KIRO +3315 SQUARE KIROGURAMU +3316 SQUARE KIROMEETORU +3317 SQUARE KIROWATTO +3318 SQUARE GURAMU +3319 SQUARE GURAMUTON +331A SQUARE KURUZEIRO +331B SQUARE KUROONE +331C SQUARE KEESU +331D SQUARE KORUNA +331E SQUARE KOOPO +331F SQUARE SAIKURU +3320 SQUARE SANTIIMU +3321 SQUARE SIRINGU +3322 SQUARE SENTI +3323 SQUARE SENTO +3324 SQUARE DAASU +3325 SQUARE DESI +3326 SQUARE DORU +3327 SQUARE TON +3328 SQUARE NANO +3329 SQUARE NOTTO +332A SQUARE HAITU +332B SQUARE PAASENTO +332C SQUARE PAATU +332D SQUARE BAARERU +332E SQUARE PIASUTORU +332F SQUARE PIKURU +3330 SQUARE PIKO +3331 SQUARE BIRU +3332 SQUARE HUARADDO +3333 SQUARE HUIITO +3334 SQUARE BUSSYERU +3335 SQUARE HURAN +3336 SQUARE HEKUTAARU +3337 SQUARE PESO +3338 SQUARE PENIHI +3339 SQUARE HERUTU +333A SQUARE PENSU +333B SQUARE PEEZI +333C SQUARE BEETA +333D SQUARE POINTO +333E SQUARE BORUTO +333F SQUARE HON +3340 SQUARE PONDO +3341 SQUARE HOORU +3342 SQUARE HOON +3343 SQUARE MAIKURO +3344 SQUARE MAIRU +3345 SQUARE MAHHA +3346 SQUARE MARUKU +3347 SQUARE MANSYON +3348 SQUARE MIKURON +3349 SQUARE MIRI +334A SQUARE MIRIBAARU +334B SQUARE MEGA +334C SQUARE MEGATON +334D SQUARE MEETORU +334E SQUARE YAADO +334F SQUARE YAARU +3350 SQUARE YUAN +3351 SQUARE RITTORU +3352 SQUARE RIRA +3353 SQUARE RUPII +3354 SQUARE RUUBURU +3355 SQUARE REMU +3356 SQUARE RENTOGEN +3357 SQUARE WATTO +3358 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO +3359 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ONE +335A IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWO +335B IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THREE +335C IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOUR +335D IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIVE +335E IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIX +335F IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVEN +3360 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHT +3361 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINE +3362 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TEN +3363 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ELEVEN +3364 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWELVE +3365 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THIRTEEN +3366 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOURTEEN +3367 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIFTEEN +3368 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIXTEEN +3369 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVENTEEN +336A IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHTEEN +336B IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINETEEN +336C IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY +336D IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-ONE +336E IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-TWO +336F IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-THREE +3370 IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR +3371 SQUARE HPA +3372 SQUARE DA +3373 SQUARE AU +3374 SQUARE BAR +3375 SQUARE OV +3376 SQUARE PC +337B SQUARE ERA NAME HEISEI +337C SQUARE ERA NAME SYOUWA +337D SQUARE ERA NAME TAISYOU +337E SQUARE ERA NAME MEIZI +337F SQUARE CORPORATION +3380 SQUARE PA AMPS +3381 SQUARE NA +3382 SQUARE MU A +3383 SQUARE MA +3384 SQUARE KA +3385 SQUARE KB +3386 SQUARE MB +3387 SQUARE GB +3388 SQUARE CAL +3389 SQUARE KCAL +338A SQUARE PF +338B SQUARE NF +338C SQUARE MU F +338D SQUARE MU G +338E SQUARE MG +338F SQUARE KG +3390 SQUARE HZ +3391 SQUARE KHZ +3392 SQUARE MHZ +3393 SQUARE GHZ +3394 SQUARE THZ +3395 SQUARE MU L +3396 SQUARE ML +3397 SQUARE DL +3398 SQUARE KL +3399 SQUARE FM +339A SQUARE NM +339B SQUARE MU M +339C SQUARE MM +339D SQUARE CM +339E SQUARE KM +339F SQUARE MM SQUARED +33A0 SQUARE CM SQUARED +33A1 SQUARE M SQUARED +33A2 SQUARE KM SQUARED +33A3 SQUARE MM CUBED +33A4 SQUARE CM CUBED +33A5 SQUARE M CUBED +33A6 SQUARE KM CUBED +33A7 SQUARE M OVER S +33A8 SQUARE M OVER S SQUARED +33A9 SQUARE PA +33AA SQUARE KPA +33AB SQUARE MPA +33AC SQUARE GPA +33AD SQUARE RAD +33AE SQUARE RAD OVER S +33AF SQUARE RAD OVER S SQUARED +33B0 SQUARE PS +33B1 SQUARE NS +33B2 SQUARE MU S +33B3 SQUARE MS +33B4 SQUARE PV +33B5 SQUARE NV +33B6 SQUARE MU V +33B7 SQUARE MV +33B8 SQUARE KV +33B9 SQUARE MV MEGA +33BA SQUARE PW +33BB SQUARE NW +33BC SQUARE MU W +33BD SQUARE MW +33BE SQUARE KW +33BF SQUARE MW MEGA +33C0 SQUARE K OHM +33C1 SQUARE M OHM +33C2 SQUARE AM +33C3 SQUARE BQ +33C4 SQUARE CC +33C5 SQUARE CD +33C6 SQUARE C OVER KG +33C7 SQUARE CO +33C8 SQUARE DB +33C9 SQUARE GY +33CA SQUARE HA +33CB SQUARE HP +33CC SQUARE IN +33CD SQUARE KK +33CE SQUARE KM CAPITAL +33CF SQUARE KT +33D0 SQUARE LM +33D1 SQUARE LN +33D2 SQUARE LOG +33D3 SQUARE LX +33D4 SQUARE MB SMALL +33D5 SQUARE MIL +33D6 SQUARE MOL +33D7 SQUARE PH +33D8 SQUARE PM +33D9 SQUARE PPM +33DA SQUARE PR +33DB SQUARE SR +33DC SQUARE SV +33DD SQUARE WB +33E0 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE +33E1 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWO +33E2 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THREE +33E3 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOUR +33E4 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIVE +33E5 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIX +33E6 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVEN +33E7 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHT +33E8 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINE +33E9 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TEN +33EA IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ELEVEN +33EB IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWELVE +33EC IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTEEN +33ED IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOURTEEN +33EE IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIFTEEN +33EF IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIXTEEN +33F0 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVENTEEN +33F1 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHTEEN +33F2 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINETEEN +33F3 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY +33F4 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-ONE +33F5 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-TWO +33F6 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-THREE +33F7 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FOUR +33F8 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FIVE +33F9 IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SIX +33FA IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SEVEN +33FB IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-EIGHT +33FC IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-NINE +33FD IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY +33FE IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE +3400 4DB5 CJK Ideograph Extension A +4E00 9FA5 CJK Ideograph +A000 YI SYLLABLE IT +A001 YI SYLLABLE IX +A002 YI SYLLABLE I +A003 YI SYLLABLE IP +A004 YI SYLLABLE IET +A005 YI SYLLABLE IEX +A006 YI SYLLABLE IE +A007 YI SYLLABLE IEP +A008 YI SYLLABLE AT +A009 YI SYLLABLE AX +A00A YI SYLLABLE A +A00B YI SYLLABLE AP +A00C YI SYLLABLE UOX +A00D YI SYLLABLE UO +A00E YI SYLLABLE UOP +A00F YI SYLLABLE OT +A010 YI SYLLABLE OX +A011 YI SYLLABLE O +A012 YI SYLLABLE OP +A013 YI SYLLABLE EX +A014 YI SYLLABLE E +A015 YI SYLLABLE WU +A016 YI SYLLABLE BIT +A017 YI SYLLABLE BIX +A018 YI SYLLABLE BI +A019 YI SYLLABLE BIP +A01A YI SYLLABLE BIET +A01B YI SYLLABLE BIEX +A01C YI SYLLABLE BIE +A01D YI SYLLABLE BIEP +A01E YI SYLLABLE BAT +A01F YI SYLLABLE BAX +A020 YI SYLLABLE BA +A021 YI SYLLABLE BAP +A022 YI SYLLABLE BUOX +A023 YI SYLLABLE BUO +A024 YI SYLLABLE BUOP +A025 YI SYLLABLE BOT +A026 YI SYLLABLE BOX +A027 YI SYLLABLE BO +A028 YI SYLLABLE BOP +A029 YI SYLLABLE BEX +A02A YI SYLLABLE BE +A02B YI SYLLABLE BEP +A02C YI SYLLABLE BUT +A02D YI SYLLABLE BUX +A02E YI SYLLABLE BU +A02F YI SYLLABLE BUP +A030 YI SYLLABLE BURX +A031 YI SYLLABLE BUR +A032 YI SYLLABLE BYT +A033 YI SYLLABLE BYX +A034 YI SYLLABLE BY +A035 YI SYLLABLE BYP +A036 YI SYLLABLE BYRX +A037 YI SYLLABLE BYR +A038 YI SYLLABLE PIT +A039 YI SYLLABLE PIX +A03A YI SYLLABLE PI +A03B YI SYLLABLE PIP +A03C YI SYLLABLE PIEX +A03D YI SYLLABLE PIE +A03E YI SYLLABLE PIEP +A03F YI SYLLABLE PAT +A040 YI SYLLABLE PAX +A041 YI SYLLABLE PA +A042 YI SYLLABLE PAP +A043 YI SYLLABLE PUOX +A044 YI SYLLABLE PUO +A045 YI SYLLABLE PUOP +A046 YI SYLLABLE POT +A047 YI SYLLABLE POX +A048 YI SYLLABLE PO +A049 YI SYLLABLE POP +A04A YI SYLLABLE PUT +A04B YI SYLLABLE PUX +A04C YI SYLLABLE PU +A04D YI SYLLABLE PUP +A04E YI SYLLABLE PURX +A04F YI SYLLABLE PUR +A050 YI SYLLABLE PYT +A051 YI SYLLABLE PYX +A052 YI SYLLABLE PY +A053 YI SYLLABLE PYP +A054 YI SYLLABLE PYRX +A055 YI SYLLABLE PYR +A056 YI SYLLABLE BBIT +A057 YI SYLLABLE BBIX +A058 YI SYLLABLE BBI +A059 YI SYLLABLE BBIP +A05A YI SYLLABLE BBIET +A05B YI SYLLABLE BBIEX +A05C YI SYLLABLE BBIE +A05D YI SYLLABLE BBIEP +A05E YI SYLLABLE BBAT +A05F YI SYLLABLE BBAX +A060 YI SYLLABLE BBA +A061 YI SYLLABLE BBAP +A062 YI SYLLABLE BBUOX +A063 YI SYLLABLE BBUO +A064 YI SYLLABLE BBUOP +A065 YI SYLLABLE BBOT +A066 YI SYLLABLE BBOX +A067 YI SYLLABLE BBO +A068 YI SYLLABLE BBOP +A069 YI SYLLABLE BBEX +A06A YI SYLLABLE BBE +A06B YI SYLLABLE BBEP +A06C YI SYLLABLE BBUT +A06D YI SYLLABLE BBUX +A06E YI SYLLABLE BBU +A06F YI SYLLABLE BBUP +A070 YI SYLLABLE BBURX +A071 YI SYLLABLE BBUR +A072 YI SYLLABLE BBYT +A073 YI SYLLABLE BBYX +A074 YI SYLLABLE BBY +A075 YI SYLLABLE BBYP +A076 YI SYLLABLE NBIT +A077 YI SYLLABLE NBIX +A078 YI SYLLABLE NBI +A079 YI SYLLABLE NBIP +A07A YI SYLLABLE NBIEX +A07B YI SYLLABLE NBIE +A07C YI SYLLABLE NBIEP +A07D YI SYLLABLE NBAT +A07E YI SYLLABLE NBAX +A07F YI SYLLABLE NBA +A080 YI SYLLABLE NBAP +A081 YI SYLLABLE NBOT +A082 YI SYLLABLE NBOX +A083 YI SYLLABLE NBO +A084 YI SYLLABLE NBOP +A085 YI SYLLABLE NBUT +A086 YI SYLLABLE NBUX +A087 YI SYLLABLE NBU +A088 YI SYLLABLE NBUP +A089 YI SYLLABLE NBURX +A08A YI SYLLABLE NBUR +A08B YI SYLLABLE NBYT +A08C YI SYLLABLE NBYX +A08D YI SYLLABLE NBY +A08E YI SYLLABLE NBYP +A08F YI SYLLABLE NBYRX +A090 YI SYLLABLE NBYR +A091 YI SYLLABLE HMIT +A092 YI SYLLABLE HMIX +A093 YI SYLLABLE HMI +A094 YI SYLLABLE HMIP +A095 YI SYLLABLE HMIEX +A096 YI SYLLABLE HMIE +A097 YI SYLLABLE HMIEP +A098 YI SYLLABLE HMAT +A099 YI SYLLABLE HMAX +A09A YI SYLLABLE HMA +A09B YI SYLLABLE HMAP +A09C YI SYLLABLE HMUOX +A09D YI SYLLABLE HMUO +A09E YI SYLLABLE HMUOP +A09F YI SYLLABLE HMOT +A0A0 YI SYLLABLE HMOX +A0A1 YI SYLLABLE HMO +A0A2 YI SYLLABLE HMOP +A0A3 YI SYLLABLE HMUT +A0A4 YI SYLLABLE HMUX +A0A5 YI SYLLABLE HMU +A0A6 YI SYLLABLE HMUP +A0A7 YI SYLLABLE HMURX +A0A8 YI SYLLABLE HMUR +A0A9 YI SYLLABLE HMYX +A0AA YI SYLLABLE HMY +A0AB YI SYLLABLE HMYP +A0AC YI SYLLABLE HMYRX +A0AD YI SYLLABLE HMYR +A0AE YI SYLLABLE MIT +A0AF YI SYLLABLE MIX +A0B0 YI SYLLABLE MI +A0B1 YI SYLLABLE MIP +A0B2 YI SYLLABLE MIEX +A0B3 YI SYLLABLE MIE +A0B4 YI SYLLABLE MIEP +A0B5 YI SYLLABLE MAT +A0B6 YI SYLLABLE MAX +A0B7 YI SYLLABLE MA +A0B8 YI SYLLABLE MAP +A0B9 YI SYLLABLE MUOT +A0BA YI SYLLABLE MUOX +A0BB YI SYLLABLE MUO +A0BC YI SYLLABLE MUOP +A0BD YI SYLLABLE MOT +A0BE YI SYLLABLE MOX +A0BF YI SYLLABLE MO +A0C0 YI SYLLABLE MOP +A0C1 YI SYLLABLE MEX +A0C2 YI SYLLABLE ME +A0C3 YI SYLLABLE MUT +A0C4 YI SYLLABLE MUX +A0C5 YI SYLLABLE MU +A0C6 YI SYLLABLE MUP +A0C7 YI SYLLABLE MURX +A0C8 YI SYLLABLE MUR +A0C9 YI SYLLABLE MYT +A0CA YI SYLLABLE MYX +A0CB YI SYLLABLE MY +A0CC YI SYLLABLE MYP +A0CD YI SYLLABLE FIT +A0CE YI SYLLABLE FIX +A0CF YI SYLLABLE FI +A0D0 YI SYLLABLE FIP +A0D1 YI SYLLABLE FAT +A0D2 YI SYLLABLE FAX +A0D3 YI SYLLABLE FA +A0D4 YI SYLLABLE FAP +A0D5 YI SYLLABLE FOX +A0D6 YI SYLLABLE FO +A0D7 YI SYLLABLE FOP +A0D8 YI SYLLABLE FUT +A0D9 YI SYLLABLE FUX +A0DA YI SYLLABLE FU +A0DB YI SYLLABLE FUP +A0DC YI SYLLABLE FURX +A0DD YI SYLLABLE FUR +A0DE YI SYLLABLE FYT +A0DF YI SYLLABLE FYX +A0E0 YI SYLLABLE FY +A0E1 YI SYLLABLE FYP +A0E2 YI SYLLABLE VIT +A0E3 YI SYLLABLE VIX +A0E4 YI SYLLABLE VI +A0E5 YI SYLLABLE VIP +A0E6 YI SYLLABLE VIET +A0E7 YI SYLLABLE VIEX +A0E8 YI SYLLABLE VIE +A0E9 YI SYLLABLE VIEP +A0EA YI SYLLABLE VAT +A0EB YI SYLLABLE VAX +A0EC YI SYLLABLE VA +A0ED YI SYLLABLE VAP +A0EE YI SYLLABLE VOT +A0EF YI SYLLABLE VOX +A0F0 YI SYLLABLE VO +A0F1 YI SYLLABLE VOP +A0F2 YI SYLLABLE VEX +A0F3 YI SYLLABLE VEP +A0F4 YI SYLLABLE VUT +A0F5 YI SYLLABLE VUX +A0F6 YI SYLLABLE VU +A0F7 YI SYLLABLE VUP +A0F8 YI SYLLABLE VURX +A0F9 YI SYLLABLE VUR +A0FA YI SYLLABLE VYT +A0FB YI SYLLABLE VYX +A0FC YI SYLLABLE VY +A0FD YI SYLLABLE VYP +A0FE YI SYLLABLE VYRX +A0FF YI SYLLABLE VYR +A100 YI SYLLABLE DIT +A101 YI SYLLABLE DIX +A102 YI SYLLABLE DI +A103 YI SYLLABLE DIP +A104 YI SYLLABLE DIEX +A105 YI SYLLABLE DIE +A106 YI SYLLABLE DIEP +A107 YI SYLLABLE DAT +A108 YI SYLLABLE DAX +A109 YI SYLLABLE DA +A10A YI SYLLABLE DAP +A10B YI SYLLABLE DUOX +A10C YI SYLLABLE DUO +A10D YI SYLLABLE DOT +A10E YI SYLLABLE DOX +A10F YI SYLLABLE DO +A110 YI SYLLABLE DOP +A111 YI SYLLABLE DEX +A112 YI SYLLABLE DE +A113 YI SYLLABLE DEP +A114 YI SYLLABLE DUT +A115 YI SYLLABLE DUX +A116 YI SYLLABLE DU +A117 YI SYLLABLE DUP +A118 YI SYLLABLE DURX +A119 YI SYLLABLE DUR +A11A YI SYLLABLE TIT +A11B YI SYLLABLE TIX +A11C YI SYLLABLE TI +A11D YI SYLLABLE TIP +A11E YI SYLLABLE TIEX +A11F YI SYLLABLE TIE +A120 YI SYLLABLE TIEP +A121 YI SYLLABLE TAT +A122 YI SYLLABLE TAX +A123 YI SYLLABLE TA +A124 YI SYLLABLE TAP +A125 YI SYLLABLE TUOT +A126 YI SYLLABLE TUOX +A127 YI SYLLABLE TUO +A128 YI SYLLABLE TUOP +A129 YI SYLLABLE TOT +A12A YI SYLLABLE TOX +A12B YI SYLLABLE TO +A12C YI SYLLABLE TOP +A12D YI SYLLABLE TEX +A12E YI SYLLABLE TE +A12F YI SYLLABLE TEP +A130 YI SYLLABLE TUT +A131 YI SYLLABLE TUX +A132 YI SYLLABLE TU +A133 YI SYLLABLE TUP +A134 YI SYLLABLE TURX +A135 YI SYLLABLE TUR +A136 YI SYLLABLE DDIT +A137 YI SYLLABLE DDIX +A138 YI SYLLABLE DDI +A139 YI SYLLABLE DDIP +A13A YI SYLLABLE DDIEX +A13B YI SYLLABLE DDIE +A13C YI SYLLABLE DDIEP +A13D YI SYLLABLE DDAT +A13E YI SYLLABLE DDAX +A13F YI SYLLABLE DDA +A140 YI SYLLABLE DDAP +A141 YI SYLLABLE DDUOX +A142 YI SYLLABLE DDUO +A143 YI SYLLABLE DDUOP +A144 YI SYLLABLE DDOT +A145 YI SYLLABLE DDOX +A146 YI SYLLABLE DDO +A147 YI SYLLABLE DDOP +A148 YI SYLLABLE DDEX +A149 YI SYLLABLE DDE +A14A YI SYLLABLE DDEP +A14B YI SYLLABLE DDUT +A14C YI SYLLABLE DDUX +A14D YI SYLLABLE DDU +A14E YI SYLLABLE DDUP +A14F YI SYLLABLE DDURX +A150 YI SYLLABLE DDUR +A151 YI SYLLABLE NDIT +A152 YI SYLLABLE NDIX +A153 YI SYLLABLE NDI +A154 YI SYLLABLE NDIP +A155 YI SYLLABLE NDIEX +A156 YI SYLLABLE NDIE +A157 YI SYLLABLE NDAT +A158 YI SYLLABLE NDAX +A159 YI SYLLABLE NDA +A15A YI SYLLABLE NDAP +A15B YI SYLLABLE NDOT +A15C YI SYLLABLE NDOX +A15D YI SYLLABLE NDO +A15E YI SYLLABLE NDOP +A15F YI SYLLABLE NDEX +A160 YI SYLLABLE NDE +A161 YI SYLLABLE NDEP +A162 YI SYLLABLE NDUT +A163 YI SYLLABLE NDUX +A164 YI SYLLABLE NDU +A165 YI SYLLABLE NDUP +A166 YI SYLLABLE NDURX +A167 YI SYLLABLE NDUR +A168 YI SYLLABLE HNIT +A169 YI SYLLABLE HNIX +A16A YI SYLLABLE HNI +A16B YI SYLLABLE HNIP +A16C YI SYLLABLE HNIET +A16D YI SYLLABLE HNIEX +A16E YI SYLLABLE HNIE +A16F YI SYLLABLE HNIEP +A170 YI SYLLABLE HNAT +A171 YI SYLLABLE HNAX +A172 YI SYLLABLE HNA +A173 YI SYLLABLE HNAP +A174 YI SYLLABLE HNUOX +A175 YI SYLLABLE HNUO +A176 YI SYLLABLE HNOT +A177 YI SYLLABLE HNOX +A178 YI SYLLABLE HNOP +A179 YI SYLLABLE HNEX +A17A YI SYLLABLE HNE +A17B YI SYLLABLE HNEP +A17C YI SYLLABLE HNUT +A17D YI SYLLABLE NIT +A17E YI SYLLABLE NIX +A17F YI SYLLABLE NI +A180 YI SYLLABLE NIP +A181 YI SYLLABLE NIEX +A182 YI SYLLABLE NIE +A183 YI SYLLABLE NIEP +A184 YI SYLLABLE NAX +A185 YI SYLLABLE NA +A186 YI SYLLABLE NAP +A187 YI SYLLABLE NUOX +A188 YI SYLLABLE NUO +A189 YI SYLLABLE NUOP +A18A YI SYLLABLE NOT +A18B YI SYLLABLE NOX +A18C YI SYLLABLE NO +A18D YI SYLLABLE NOP +A18E YI SYLLABLE NEX +A18F YI SYLLABLE NE +A190 YI SYLLABLE NEP +A191 YI SYLLABLE NUT +A192 YI SYLLABLE NUX +A193 YI SYLLABLE NU +A194 YI SYLLABLE NUP +A195 YI SYLLABLE NURX +A196 YI SYLLABLE NUR +A197 YI SYLLABLE HLIT +A198 YI SYLLABLE HLIX +A199 YI SYLLABLE HLI +A19A YI SYLLABLE HLIP +A19B YI SYLLABLE HLIEX +A19C YI SYLLABLE HLIE +A19D YI SYLLABLE HLIEP +A19E YI SYLLABLE HLAT +A19F YI SYLLABLE HLAX +A1A0 YI SYLLABLE HLA +A1A1 YI SYLLABLE HLAP +A1A2 YI SYLLABLE HLUOX +A1A3 YI SYLLABLE HLUO +A1A4 YI SYLLABLE HLUOP +A1A5 YI SYLLABLE HLOX +A1A6 YI SYLLABLE HLO +A1A7 YI SYLLABLE HLOP +A1A8 YI SYLLABLE HLEX +A1A9 YI SYLLABLE HLE +A1AA YI SYLLABLE HLEP +A1AB YI SYLLABLE HLUT +A1AC YI SYLLABLE HLUX +A1AD YI SYLLABLE HLU +A1AE YI SYLLABLE HLUP +A1AF YI SYLLABLE HLURX +A1B0 YI SYLLABLE HLUR +A1B1 YI SYLLABLE HLYT +A1B2 YI SYLLABLE HLYX +A1B3 YI SYLLABLE HLY +A1B4 YI SYLLABLE HLYP +A1B5 YI SYLLABLE HLYRX +A1B6 YI SYLLABLE HLYR +A1B7 YI SYLLABLE LIT +A1B8 YI SYLLABLE LIX +A1B9 YI SYLLABLE LI +A1BA YI SYLLABLE LIP +A1BB YI SYLLABLE LIET +A1BC YI SYLLABLE LIEX +A1BD YI SYLLABLE LIE +A1BE YI SYLLABLE LIEP +A1BF YI SYLLABLE LAT +A1C0 YI SYLLABLE LAX +A1C1 YI SYLLABLE LA +A1C2 YI SYLLABLE LAP +A1C3 YI SYLLABLE LUOT +A1C4 YI SYLLABLE LUOX +A1C5 YI SYLLABLE LUO +A1C6 YI SYLLABLE LUOP +A1C7 YI SYLLABLE LOT +A1C8 YI SYLLABLE LOX +A1C9 YI SYLLABLE LO +A1CA YI SYLLABLE LOP +A1CB YI SYLLABLE LEX +A1CC YI SYLLABLE LE +A1CD YI SYLLABLE LEP +A1CE YI SYLLABLE LUT +A1CF YI SYLLABLE LUX +A1D0 YI SYLLABLE LU +A1D1 YI SYLLABLE LUP +A1D2 YI SYLLABLE LURX +A1D3 YI SYLLABLE LUR +A1D4 YI SYLLABLE LYT +A1D5 YI SYLLABLE LYX +A1D6 YI SYLLABLE LY +A1D7 YI SYLLABLE LYP +A1D8 YI SYLLABLE LYRX +A1D9 YI SYLLABLE LYR +A1DA YI SYLLABLE GIT +A1DB YI SYLLABLE GIX +A1DC YI SYLLABLE GI +A1DD YI SYLLABLE GIP +A1DE YI SYLLABLE GIET +A1DF YI SYLLABLE GIEX +A1E0 YI SYLLABLE GIE +A1E1 YI SYLLABLE GIEP +A1E2 YI SYLLABLE GAT +A1E3 YI SYLLABLE GAX +A1E4 YI SYLLABLE GA +A1E5 YI SYLLABLE GAP +A1E6 YI SYLLABLE GUOT +A1E7 YI SYLLABLE GUOX +A1E8 YI SYLLABLE GUO +A1E9 YI SYLLABLE GUOP +A1EA YI SYLLABLE GOT +A1EB YI SYLLABLE GOX +A1EC YI SYLLABLE GO +A1ED YI SYLLABLE GOP +A1EE YI SYLLABLE GET +A1EF YI SYLLABLE GEX +A1F0 YI SYLLABLE GE +A1F1 YI SYLLABLE GEP +A1F2 YI SYLLABLE GUT +A1F3 YI SYLLABLE GUX +A1F4 YI SYLLABLE GU +A1F5 YI SYLLABLE GUP +A1F6 YI SYLLABLE GURX +A1F7 YI SYLLABLE GUR +A1F8 YI SYLLABLE KIT +A1F9 YI SYLLABLE KIX +A1FA YI SYLLABLE KI +A1FB YI SYLLABLE KIP +A1FC YI SYLLABLE KIEX +A1FD YI SYLLABLE KIE +A1FE YI SYLLABLE KIEP +A1FF YI SYLLABLE KAT +A200 YI SYLLABLE KAX +A201 YI SYLLABLE KA +A202 YI SYLLABLE KAP +A203 YI SYLLABLE KUOX +A204 YI SYLLABLE KUO +A205 YI SYLLABLE KUOP +A206 YI SYLLABLE KOT +A207 YI SYLLABLE KOX +A208 YI SYLLABLE KO +A209 YI SYLLABLE KOP +A20A YI SYLLABLE KET +A20B YI SYLLABLE KEX +A20C YI SYLLABLE KE +A20D YI SYLLABLE KEP +A20E YI SYLLABLE KUT +A20F YI SYLLABLE KUX +A210 YI SYLLABLE KU +A211 YI SYLLABLE KUP +A212 YI SYLLABLE KURX +A213 YI SYLLABLE KUR +A214 YI SYLLABLE GGIT +A215 YI SYLLABLE GGIX +A216 YI SYLLABLE GGI +A217 YI SYLLABLE GGIEX +A218 YI SYLLABLE GGIE +A219 YI SYLLABLE GGIEP +A21A YI SYLLABLE GGAT +A21B YI SYLLABLE GGAX +A21C YI SYLLABLE GGA +A21D YI SYLLABLE GGAP +A21E YI SYLLABLE GGUOT +A21F YI SYLLABLE GGUOX +A220 YI SYLLABLE GGUO +A221 YI SYLLABLE GGUOP +A222 YI SYLLABLE GGOT +A223 YI SYLLABLE GGOX +A224 YI SYLLABLE GGO +A225 YI SYLLABLE GGOP +A226 YI SYLLABLE GGET +A227 YI SYLLABLE GGEX +A228 YI SYLLABLE GGE +A229 YI SYLLABLE GGEP +A22A YI SYLLABLE GGUT +A22B YI SYLLABLE GGUX +A22C YI SYLLABLE GGU +A22D YI SYLLABLE GGUP +A22E YI SYLLABLE GGURX +A22F YI SYLLABLE GGUR +A230 YI SYLLABLE MGIEX +A231 YI SYLLABLE MGIE +A232 YI SYLLABLE MGAT +A233 YI SYLLABLE MGAX +A234 YI SYLLABLE MGA +A235 YI SYLLABLE MGAP +A236 YI SYLLABLE MGUOX +A237 YI SYLLABLE MGUO +A238 YI SYLLABLE MGUOP +A239 YI SYLLABLE MGOT +A23A YI SYLLABLE MGOX +A23B YI SYLLABLE MGO +A23C YI SYLLABLE MGOP +A23D YI SYLLABLE MGEX +A23E YI SYLLABLE MGE +A23F YI SYLLABLE MGEP +A240 YI SYLLABLE MGUT +A241 YI SYLLABLE MGUX +A242 YI SYLLABLE MGU +A243 YI SYLLABLE MGUP +A244 YI SYLLABLE MGURX +A245 YI SYLLABLE MGUR +A246 YI SYLLABLE HXIT +A247 YI SYLLABLE HXIX +A248 YI SYLLABLE HXI +A249 YI SYLLABLE HXIP +A24A YI SYLLABLE HXIET +A24B YI SYLLABLE HXIEX +A24C YI SYLLABLE HXIE +A24D YI SYLLABLE HXIEP +A24E YI SYLLABLE HXAT +A24F YI SYLLABLE HXAX +A250 YI SYLLABLE HXA +A251 YI SYLLABLE HXAP +A252 YI SYLLABLE HXUOT +A253 YI SYLLABLE HXUOX +A254 YI SYLLABLE HXUO +A255 YI SYLLABLE HXUOP +A256 YI SYLLABLE HXOT +A257 YI SYLLABLE HXOX +A258 YI SYLLABLE HXO +A259 YI SYLLABLE HXOP +A25A YI SYLLABLE HXEX +A25B YI SYLLABLE HXE +A25C YI SYLLABLE HXEP +A25D YI SYLLABLE NGIEX +A25E YI SYLLABLE NGIE +A25F YI SYLLABLE NGIEP +A260 YI SYLLABLE NGAT +A261 YI SYLLABLE NGAX +A262 YI SYLLABLE NGA +A263 YI SYLLABLE NGAP +A264 YI SYLLABLE NGUOT +A265 YI SYLLABLE NGUOX +A266 YI SYLLABLE NGUO +A267 YI SYLLABLE NGOT +A268 YI SYLLABLE NGOX +A269 YI SYLLABLE NGO +A26A YI SYLLABLE NGOP +A26B YI SYLLABLE NGEX +A26C YI SYLLABLE NGE +A26D YI SYLLABLE NGEP +A26E YI SYLLABLE HIT +A26F YI SYLLABLE HIEX +A270 YI SYLLABLE HIE +A271 YI SYLLABLE HAT +A272 YI SYLLABLE HAX +A273 YI SYLLABLE HA +A274 YI SYLLABLE HAP +A275 YI SYLLABLE HUOT +A276 YI SYLLABLE HUOX +A277 YI SYLLABLE HUO +A278 YI SYLLABLE HUOP +A279 YI SYLLABLE HOT +A27A YI SYLLABLE HOX +A27B YI SYLLABLE HO +A27C YI SYLLABLE HOP +A27D YI SYLLABLE HEX +A27E YI SYLLABLE HE +A27F YI SYLLABLE HEP +A280 YI SYLLABLE WAT +A281 YI SYLLABLE WAX +A282 YI SYLLABLE WA +A283 YI SYLLABLE WAP +A284 YI SYLLABLE WUOX +A285 YI SYLLABLE WUO +A286 YI SYLLABLE WUOP +A287 YI SYLLABLE WOX +A288 YI SYLLABLE WO +A289 YI SYLLABLE WOP +A28A YI SYLLABLE WEX +A28B YI SYLLABLE WE +A28C YI SYLLABLE WEP +A28D YI SYLLABLE ZIT +A28E YI SYLLABLE ZIX +A28F YI SYLLABLE ZI +A290 YI SYLLABLE ZIP +A291 YI SYLLABLE ZIEX +A292 YI SYLLABLE ZIE +A293 YI SYLLABLE ZIEP +A294 YI SYLLABLE ZAT +A295 YI SYLLABLE ZAX +A296 YI SYLLABLE ZA +A297 YI SYLLABLE ZAP +A298 YI SYLLABLE ZUOX +A299 YI SYLLABLE ZUO +A29A YI SYLLABLE ZUOP +A29B YI SYLLABLE ZOT +A29C YI SYLLABLE ZOX +A29D YI SYLLABLE ZO +A29E YI SYLLABLE ZOP +A29F YI SYLLABLE ZEX +A2A0 YI SYLLABLE ZE +A2A1 YI SYLLABLE ZEP +A2A2 YI SYLLABLE ZUT +A2A3 YI SYLLABLE ZUX +A2A4 YI SYLLABLE ZU +A2A5 YI SYLLABLE ZUP +A2A6 YI SYLLABLE ZURX +A2A7 YI SYLLABLE ZUR +A2A8 YI SYLLABLE ZYT +A2A9 YI SYLLABLE ZYX +A2AA YI SYLLABLE ZY +A2AB YI SYLLABLE ZYP +A2AC YI SYLLABLE ZYRX +A2AD YI SYLLABLE ZYR +A2AE YI SYLLABLE CIT +A2AF YI SYLLABLE CIX +A2B0 YI SYLLABLE CI +A2B1 YI SYLLABLE CIP +A2B2 YI SYLLABLE CIET +A2B3 YI SYLLABLE CIEX +A2B4 YI SYLLABLE CIE +A2B5 YI SYLLABLE CIEP +A2B6 YI SYLLABLE CAT +A2B7 YI SYLLABLE CAX +A2B8 YI SYLLABLE CA +A2B9 YI SYLLABLE CAP +A2BA YI SYLLABLE CUOX +A2BB YI SYLLABLE CUO +A2BC YI SYLLABLE CUOP +A2BD YI SYLLABLE COT +A2BE YI SYLLABLE COX +A2BF YI SYLLABLE CO +A2C0 YI SYLLABLE COP +A2C1 YI SYLLABLE CEX +A2C2 YI SYLLABLE CE +A2C3 YI SYLLABLE CEP +A2C4 YI SYLLABLE CUT +A2C5 YI SYLLABLE CUX +A2C6 YI SYLLABLE CU +A2C7 YI SYLLABLE CUP +A2C8 YI SYLLABLE CURX +A2C9 YI SYLLABLE CUR +A2CA YI SYLLABLE CYT +A2CB YI SYLLABLE CYX +A2CC YI SYLLABLE CY +A2CD YI SYLLABLE CYP +A2CE YI SYLLABLE CYRX +A2CF YI SYLLABLE CYR +A2D0 YI SYLLABLE ZZIT +A2D1 YI SYLLABLE ZZIX +A2D2 YI SYLLABLE ZZI +A2D3 YI SYLLABLE ZZIP +A2D4 YI SYLLABLE ZZIET +A2D5 YI SYLLABLE ZZIEX +A2D6 YI SYLLABLE ZZIE +A2D7 YI SYLLABLE ZZIEP +A2D8 YI SYLLABLE ZZAT +A2D9 YI SYLLABLE ZZAX +A2DA YI SYLLABLE ZZA +A2DB YI SYLLABLE ZZAP +A2DC YI SYLLABLE ZZOX +A2DD YI SYLLABLE ZZO +A2DE YI SYLLABLE ZZOP +A2DF YI SYLLABLE ZZEX +A2E0 YI SYLLABLE ZZE +A2E1 YI SYLLABLE ZZEP +A2E2 YI SYLLABLE ZZUX +A2E3 YI SYLLABLE ZZU +A2E4 YI SYLLABLE ZZUP +A2E5 YI SYLLABLE ZZURX +A2E6 YI SYLLABLE ZZUR +A2E7 YI SYLLABLE ZZYT +A2E8 YI SYLLABLE ZZYX +A2E9 YI SYLLABLE ZZY +A2EA YI SYLLABLE ZZYP +A2EB YI SYLLABLE ZZYRX +A2EC YI SYLLABLE ZZYR +A2ED YI SYLLABLE NZIT +A2EE YI SYLLABLE NZIX +A2EF YI SYLLABLE NZI +A2F0 YI SYLLABLE NZIP +A2F1 YI SYLLABLE NZIEX +A2F2 YI SYLLABLE NZIE +A2F3 YI SYLLABLE NZIEP +A2F4 YI SYLLABLE NZAT +A2F5 YI SYLLABLE NZAX +A2F6 YI SYLLABLE NZA +A2F7 YI SYLLABLE NZAP +A2F8 YI SYLLABLE NZUOX +A2F9 YI SYLLABLE NZUO +A2FA YI SYLLABLE NZOX +A2FB YI SYLLABLE NZOP +A2FC YI SYLLABLE NZEX +A2FD YI SYLLABLE NZE +A2FE YI SYLLABLE NZUX +A2FF YI SYLLABLE NZU +A300 YI SYLLABLE NZUP +A301 YI SYLLABLE NZURX +A302 YI SYLLABLE NZUR +A303 YI SYLLABLE NZYT +A304 YI SYLLABLE NZYX +A305 YI SYLLABLE NZY +A306 YI SYLLABLE NZYP +A307 YI SYLLABLE NZYRX +A308 YI SYLLABLE NZYR +A309 YI SYLLABLE SIT +A30A YI SYLLABLE SIX +A30B YI SYLLABLE SI +A30C YI SYLLABLE SIP +A30D YI SYLLABLE SIEX +A30E YI SYLLABLE SIE +A30F YI SYLLABLE SIEP +A310 YI SYLLABLE SAT +A311 YI SYLLABLE SAX +A312 YI SYLLABLE SA +A313 YI SYLLABLE SAP +A314 YI SYLLABLE SUOX +A315 YI SYLLABLE SUO +A316 YI SYLLABLE SUOP +A317 YI SYLLABLE SOT +A318 YI SYLLABLE SOX +A319 YI SYLLABLE SO +A31A YI SYLLABLE SOP +A31B YI SYLLABLE SEX +A31C YI SYLLABLE SE +A31D YI SYLLABLE SEP +A31E YI SYLLABLE SUT +A31F YI SYLLABLE SUX +A320 YI SYLLABLE SU +A321 YI SYLLABLE SUP +A322 YI SYLLABLE SURX +A323 YI SYLLABLE SUR +A324 YI SYLLABLE SYT +A325 YI SYLLABLE SYX +A326 YI SYLLABLE SY +A327 YI SYLLABLE SYP +A328 YI SYLLABLE SYRX +A329 YI SYLLABLE SYR +A32A YI SYLLABLE SSIT +A32B YI SYLLABLE SSIX +A32C YI SYLLABLE SSI +A32D YI SYLLABLE SSIP +A32E YI SYLLABLE SSIEX +A32F YI SYLLABLE SSIE +A330 YI SYLLABLE SSIEP +A331 YI SYLLABLE SSAT +A332 YI SYLLABLE SSAX +A333 YI SYLLABLE SSA +A334 YI SYLLABLE SSAP +A335 YI SYLLABLE SSOT +A336 YI SYLLABLE SSOX +A337 YI SYLLABLE SSO +A338 YI SYLLABLE SSOP +A339 YI SYLLABLE SSEX +A33A YI SYLLABLE SSE +A33B YI SYLLABLE SSEP +A33C YI SYLLABLE SSUT +A33D YI SYLLABLE SSUX +A33E YI SYLLABLE SSU +A33F YI SYLLABLE SSUP +A340 YI SYLLABLE SSYT +A341 YI SYLLABLE SSYX +A342 YI SYLLABLE SSY +A343 YI SYLLABLE SSYP +A344 YI SYLLABLE SSYRX +A345 YI SYLLABLE SSYR +A346 YI SYLLABLE ZHAT +A347 YI SYLLABLE ZHAX +A348 YI SYLLABLE ZHA +A349 YI SYLLABLE ZHAP +A34A YI SYLLABLE ZHUOX +A34B YI SYLLABLE ZHUO +A34C YI SYLLABLE ZHUOP +A34D YI SYLLABLE ZHOT +A34E YI SYLLABLE ZHOX +A34F YI SYLLABLE ZHO +A350 YI SYLLABLE ZHOP +A351 YI SYLLABLE ZHET +A352 YI SYLLABLE ZHEX +A353 YI SYLLABLE ZHE +A354 YI SYLLABLE ZHEP +A355 YI SYLLABLE ZHUT +A356 YI SYLLABLE ZHUX +A357 YI SYLLABLE ZHU +A358 YI SYLLABLE ZHUP +A359 YI SYLLABLE ZHURX +A35A YI SYLLABLE ZHUR +A35B YI SYLLABLE ZHYT +A35C YI SYLLABLE ZHYX +A35D YI SYLLABLE ZHY +A35E YI SYLLABLE ZHYP +A35F YI SYLLABLE ZHYRX +A360 YI SYLLABLE ZHYR +A361 YI SYLLABLE CHAT +A362 YI SYLLABLE CHAX +A363 YI SYLLABLE CHA +A364 YI SYLLABLE CHAP +A365 YI SYLLABLE CHUOT +A366 YI SYLLABLE CHUOX +A367 YI SYLLABLE CHUO +A368 YI SYLLABLE CHUOP +A369 YI SYLLABLE CHOT +A36A YI SYLLABLE CHOX +A36B YI SYLLABLE CHO +A36C YI SYLLABLE CHOP +A36D YI SYLLABLE CHET +A36E YI SYLLABLE CHEX +A36F YI SYLLABLE CHE +A370 YI SYLLABLE CHEP +A371 YI SYLLABLE CHUX +A372 YI SYLLABLE CHU +A373 YI SYLLABLE CHUP +A374 YI SYLLABLE CHURX +A375 YI SYLLABLE CHUR +A376 YI SYLLABLE CHYT +A377 YI SYLLABLE CHYX +A378 YI SYLLABLE CHY +A379 YI SYLLABLE CHYP +A37A YI SYLLABLE CHYRX +A37B YI SYLLABLE CHYR +A37C YI SYLLABLE RRAX +A37D YI SYLLABLE RRA +A37E YI SYLLABLE RRUOX +A37F YI SYLLABLE RRUO +A380 YI SYLLABLE RROT +A381 YI SYLLABLE RROX +A382 YI SYLLABLE RRO +A383 YI SYLLABLE RROP +A384 YI SYLLABLE RRET +A385 YI SYLLABLE RREX +A386 YI SYLLABLE RRE +A387 YI SYLLABLE RREP +A388 YI SYLLABLE RRUT +A389 YI SYLLABLE RRUX +A38A YI SYLLABLE RRU +A38B YI SYLLABLE RRUP +A38C YI SYLLABLE RRURX +A38D YI SYLLABLE RRUR +A38E YI SYLLABLE RRYT +A38F YI SYLLABLE RRYX +A390 YI SYLLABLE RRY +A391 YI SYLLABLE RRYP +A392 YI SYLLABLE RRYRX +A393 YI SYLLABLE RRYR +A394 YI SYLLABLE NRAT +A395 YI SYLLABLE NRAX +A396 YI SYLLABLE NRA +A397 YI SYLLABLE NRAP +A398 YI SYLLABLE NROX +A399 YI SYLLABLE NRO +A39A YI SYLLABLE NROP +A39B YI SYLLABLE NRET +A39C YI SYLLABLE NREX +A39D YI SYLLABLE NRE +A39E YI SYLLABLE NREP +A39F YI SYLLABLE NRUT +A3A0 YI SYLLABLE NRUX +A3A1 YI SYLLABLE NRU +A3A2 YI SYLLABLE NRUP +A3A3 YI SYLLABLE NRURX +A3A4 YI SYLLABLE NRUR +A3A5 YI SYLLABLE NRYT +A3A6 YI SYLLABLE NRYX +A3A7 YI SYLLABLE NRY +A3A8 YI SYLLABLE NRYP +A3A9 YI SYLLABLE NRYRX +A3AA YI SYLLABLE NRYR +A3AB YI SYLLABLE SHAT +A3AC YI SYLLABLE SHAX +A3AD YI SYLLABLE SHA +A3AE YI SYLLABLE SHAP +A3AF YI SYLLABLE SHUOX +A3B0 YI SYLLABLE SHUO +A3B1 YI SYLLABLE SHUOP +A3B2 YI SYLLABLE SHOT +A3B3 YI SYLLABLE SHOX +A3B4 YI SYLLABLE SHO +A3B5 YI SYLLABLE SHOP +A3B6 YI SYLLABLE SHET +A3B7 YI SYLLABLE SHEX +A3B8 YI SYLLABLE SHE +A3B9 YI SYLLABLE SHEP +A3BA YI SYLLABLE SHUT +A3BB YI SYLLABLE SHUX +A3BC YI SYLLABLE SHU +A3BD YI SYLLABLE SHUP +A3BE YI SYLLABLE SHURX +A3BF YI SYLLABLE SHUR +A3C0 YI SYLLABLE SHYT +A3C1 YI SYLLABLE SHYX +A3C2 YI SYLLABLE SHY +A3C3 YI SYLLABLE SHYP +A3C4 YI SYLLABLE SHYRX +A3C5 YI SYLLABLE SHYR +A3C6 YI SYLLABLE RAT +A3C7 YI SYLLABLE RAX +A3C8 YI SYLLABLE RA +A3C9 YI SYLLABLE RAP +A3CA YI SYLLABLE RUOX +A3CB YI SYLLABLE RUO +A3CC YI SYLLABLE RUOP +A3CD YI SYLLABLE ROT +A3CE YI SYLLABLE ROX +A3CF YI SYLLABLE RO +A3D0 YI SYLLABLE ROP +A3D1 YI SYLLABLE REX +A3D2 YI SYLLABLE RE +A3D3 YI SYLLABLE REP +A3D4 YI SYLLABLE RUT +A3D5 YI SYLLABLE RUX +A3D6 YI SYLLABLE RU +A3D7 YI SYLLABLE RUP +A3D8 YI SYLLABLE RURX +A3D9 YI SYLLABLE RUR +A3DA YI SYLLABLE RYT +A3DB YI SYLLABLE RYX +A3DC YI SYLLABLE RY +A3DD YI SYLLABLE RYP +A3DE YI SYLLABLE RYRX +A3DF YI SYLLABLE RYR +A3E0 YI SYLLABLE JIT +A3E1 YI SYLLABLE JIX +A3E2 YI SYLLABLE JI +A3E3 YI SYLLABLE JIP +A3E4 YI SYLLABLE JIET +A3E5 YI SYLLABLE JIEX +A3E6 YI SYLLABLE JIE +A3E7 YI SYLLABLE JIEP +A3E8 YI SYLLABLE JUOT +A3E9 YI SYLLABLE JUOX +A3EA YI SYLLABLE JUO +A3EB YI SYLLABLE JUOP +A3EC YI SYLLABLE JOT +A3ED YI SYLLABLE JOX +A3EE YI SYLLABLE JO +A3EF YI SYLLABLE JOP +A3F0 YI SYLLABLE JUT +A3F1 YI SYLLABLE JUX +A3F2 YI SYLLABLE JU +A3F3 YI SYLLABLE JUP +A3F4 YI SYLLABLE JURX +A3F5 YI SYLLABLE JUR +A3F6 YI SYLLABLE JYT +A3F7 YI SYLLABLE JYX +A3F8 YI SYLLABLE JY +A3F9 YI SYLLABLE JYP +A3FA YI SYLLABLE JYRX +A3FB YI SYLLABLE JYR +A3FC YI SYLLABLE QIT +A3FD YI SYLLABLE QIX +A3FE YI SYLLABLE QI +A3FF YI SYLLABLE QIP +A400 YI SYLLABLE QIET +A401 YI SYLLABLE QIEX +A402 YI SYLLABLE QIE +A403 YI SYLLABLE QIEP +A404 YI SYLLABLE QUOT +A405 YI SYLLABLE QUOX +A406 YI SYLLABLE QUO +A407 YI SYLLABLE QUOP +A408 YI SYLLABLE QOT +A409 YI SYLLABLE QOX +A40A YI SYLLABLE QO +A40B YI SYLLABLE QOP +A40C YI SYLLABLE QUT +A40D YI SYLLABLE QUX +A40E YI SYLLABLE QU +A40F YI SYLLABLE QUP +A410 YI SYLLABLE QURX +A411 YI SYLLABLE QUR +A412 YI SYLLABLE QYT +A413 YI SYLLABLE QYX +A414 YI SYLLABLE QY +A415 YI SYLLABLE QYP +A416 YI SYLLABLE QYRX +A417 YI SYLLABLE QYR +A418 YI SYLLABLE JJIT +A419 YI SYLLABLE JJIX +A41A YI SYLLABLE JJI +A41B YI SYLLABLE JJIP +A41C YI SYLLABLE JJIET +A41D YI SYLLABLE JJIEX +A41E YI SYLLABLE JJIE +A41F YI SYLLABLE JJIEP +A420 YI SYLLABLE JJUOX +A421 YI SYLLABLE JJUO +A422 YI SYLLABLE JJUOP +A423 YI SYLLABLE JJOT +A424 YI SYLLABLE JJOX +A425 YI SYLLABLE JJO +A426 YI SYLLABLE JJOP +A427 YI SYLLABLE JJUT +A428 YI SYLLABLE JJUX +A429 YI SYLLABLE JJU +A42A YI SYLLABLE JJUP +A42B YI SYLLABLE JJURX +A42C YI SYLLABLE JJUR +A42D YI SYLLABLE JJYT +A42E YI SYLLABLE JJYX +A42F YI SYLLABLE JJY +A430 YI SYLLABLE JJYP +A431 YI SYLLABLE NJIT +A432 YI SYLLABLE NJIX +A433 YI SYLLABLE NJI +A434 YI SYLLABLE NJIP +A435 YI SYLLABLE NJIET +A436 YI SYLLABLE NJIEX +A437 YI SYLLABLE NJIE +A438 YI SYLLABLE NJIEP +A439 YI SYLLABLE NJUOX +A43A YI SYLLABLE NJUO +A43B YI SYLLABLE NJOT +A43C YI SYLLABLE NJOX +A43D YI SYLLABLE NJO +A43E YI SYLLABLE NJOP +A43F YI SYLLABLE NJUX +A440 YI SYLLABLE NJU +A441 YI SYLLABLE NJUP +A442 YI SYLLABLE NJURX +A443 YI SYLLABLE NJUR +A444 YI SYLLABLE NJYT +A445 YI SYLLABLE NJYX +A446 YI SYLLABLE NJY +A447 YI SYLLABLE NJYP +A448 YI SYLLABLE NJYRX +A449 YI SYLLABLE NJYR +A44A YI SYLLABLE NYIT +A44B YI SYLLABLE NYIX +A44C YI SYLLABLE NYI +A44D YI SYLLABLE NYIP +A44E YI SYLLABLE NYIET +A44F YI SYLLABLE NYIEX +A450 YI SYLLABLE NYIE +A451 YI SYLLABLE NYIEP +A452 YI SYLLABLE NYUOX +A453 YI SYLLABLE NYUO +A454 YI SYLLABLE NYUOP +A455 YI SYLLABLE NYOT +A456 YI SYLLABLE NYOX +A457 YI SYLLABLE NYO +A458 YI SYLLABLE NYOP +A459 YI SYLLABLE NYUT +A45A YI SYLLABLE NYUX +A45B YI SYLLABLE NYU +A45C YI SYLLABLE NYUP +A45D YI SYLLABLE XIT +A45E YI SYLLABLE XIX +A45F YI SYLLABLE XI +A460 YI SYLLABLE XIP +A461 YI SYLLABLE XIET +A462 YI SYLLABLE XIEX +A463 YI SYLLABLE XIE +A464 YI SYLLABLE XIEP +A465 YI SYLLABLE XUOX +A466 YI SYLLABLE XUO +A467 YI SYLLABLE XOT +A468 YI SYLLABLE XOX +A469 YI SYLLABLE XO +A46A YI SYLLABLE XOP +A46B YI SYLLABLE XYT +A46C YI SYLLABLE XYX +A46D YI SYLLABLE XY +A46E YI SYLLABLE XYP +A46F YI SYLLABLE XYRX +A470 YI SYLLABLE XYR +A471 YI SYLLABLE YIT +A472 YI SYLLABLE YIX +A473 YI SYLLABLE YI +A474 YI SYLLABLE YIP +A475 YI SYLLABLE YIET +A476 YI SYLLABLE YIEX +A477 YI SYLLABLE YIE +A478 YI SYLLABLE YIEP +A479 YI SYLLABLE YUOT +A47A YI SYLLABLE YUOX +A47B YI SYLLABLE YUO +A47C YI SYLLABLE YUOP +A47D YI SYLLABLE YOT +A47E YI SYLLABLE YOX +A47F YI SYLLABLE YO +A480 YI SYLLABLE YOP +A481 YI SYLLABLE YUT +A482 YI SYLLABLE YUX +A483 YI SYLLABLE YU +A484 YI SYLLABLE YUP +A485 YI SYLLABLE YURX +A486 YI SYLLABLE YUR +A487 YI SYLLABLE YYT +A488 YI SYLLABLE YYX +A489 YI SYLLABLE YY +A48A YI SYLLABLE YYP +A48B YI SYLLABLE YYRX +A48C YI SYLLABLE YYR +A490 YI RADICAL QOT +A491 YI RADICAL LI +A492 YI RADICAL KIT +A493 YI RADICAL NYIP +A494 YI RADICAL CYP +A495 YI RADICAL SSI +A496 YI RADICAL GGOP +A497 YI RADICAL GEP +A498 YI RADICAL MI +A499 YI RADICAL HXIT +A49A YI RADICAL LYR +A49B YI RADICAL BBUT +A49C YI RADICAL MOP +A49D YI RADICAL YO +A49E YI RADICAL PUT +A49F YI RADICAL HXUO +A4A0 YI RADICAL TAT +A4A1 YI RADICAL GA +A4A2 YI RADICAL ZUP +A4A3 YI RADICAL CYT +A4A4 YI RADICAL DDUR +A4A5 YI RADICAL BUR +A4A6 YI RADICAL GGUO +A4A7 YI RADICAL NYOP +A4A8 YI RADICAL TU +A4A9 YI RADICAL OP +A4AA YI RADICAL JJUT +A4AB YI RADICAL ZOT +A4AC YI RADICAL PYT +A4AD YI RADICAL HMO +A4AE YI RADICAL YIT +A4AF YI RADICAL VUR +A4B0 YI RADICAL SHY +A4B1 YI RADICAL VEP +A4B2 YI RADICAL ZA +A4B3 YI RADICAL JO +A4B4 YI RADICAL NZUP +A4B5 YI RADICAL JJY +A4B6 YI RADICAL GOT +A4B7 YI RADICAL JJIE +A4B8 YI RADICAL WO +A4B9 YI RADICAL DU +A4BA YI RADICAL SHUR +A4BB YI RADICAL LIE +A4BC YI RADICAL CY +A4BD YI RADICAL CUOP +A4BE YI RADICAL CIP +A4BF YI RADICAL HXOP +A4C0 YI RADICAL SHAT +A4C1 YI RADICAL ZUR +A4C2 YI RADICAL SHOP +A4C3 YI RADICAL CHE +A4C4 YI RADICAL ZZIET +A4C5 YI RADICAL NBIE +A4C6 YI RADICAL KE +AC00 D7A3 Hangul Syllable +D800 DB7F Non Private Use High Surrogate +DB80 DBFF Private Use High Surrogate +DC00 DFFF Low Surrogate +E000 F8FF Private Use +F900 CJK COMPATIBILITY IDEOGRAPH-F900 +F901 CJK COMPATIBILITY IDEOGRAPH-F901 +F902 CJK COMPATIBILITY IDEOGRAPH-F902 +F903 CJK COMPATIBILITY IDEOGRAPH-F903 +F904 CJK COMPATIBILITY IDEOGRAPH-F904 +F905 CJK COMPATIBILITY IDEOGRAPH-F905 +F906 CJK COMPATIBILITY IDEOGRAPH-F906 +F907 CJK COMPATIBILITY IDEOGRAPH-F907 +F908 CJK COMPATIBILITY IDEOGRAPH-F908 +F909 CJK COMPATIBILITY IDEOGRAPH-F909 +F90A CJK COMPATIBILITY IDEOGRAPH-F90A +F90B CJK COMPATIBILITY IDEOGRAPH-F90B +F90C CJK COMPATIBILITY IDEOGRAPH-F90C +F90D CJK COMPATIBILITY IDEOGRAPH-F90D +F90E CJK COMPATIBILITY IDEOGRAPH-F90E +F90F CJK COMPATIBILITY IDEOGRAPH-F90F +F910 CJK COMPATIBILITY IDEOGRAPH-F910 +F911 CJK COMPATIBILITY IDEOGRAPH-F911 +F912 CJK COMPATIBILITY IDEOGRAPH-F912 +F913 CJK COMPATIBILITY IDEOGRAPH-F913 +F914 CJK COMPATIBILITY IDEOGRAPH-F914 +F915 CJK COMPATIBILITY IDEOGRAPH-F915 +F916 CJK COMPATIBILITY IDEOGRAPH-F916 +F917 CJK COMPATIBILITY IDEOGRAPH-F917 +F918 CJK COMPATIBILITY IDEOGRAPH-F918 +F919 CJK COMPATIBILITY IDEOGRAPH-F919 +F91A CJK COMPATIBILITY IDEOGRAPH-F91A +F91B CJK COMPATIBILITY IDEOGRAPH-F91B +F91C CJK COMPATIBILITY IDEOGRAPH-F91C +F91D CJK COMPATIBILITY IDEOGRAPH-F91D +F91E CJK COMPATIBILITY IDEOGRAPH-F91E +F91F CJK COMPATIBILITY IDEOGRAPH-F91F +F920 CJK COMPATIBILITY IDEOGRAPH-F920 +F921 CJK COMPATIBILITY IDEOGRAPH-F921 +F922 CJK COMPATIBILITY IDEOGRAPH-F922 +F923 CJK COMPATIBILITY IDEOGRAPH-F923 +F924 CJK COMPATIBILITY IDEOGRAPH-F924 +F925 CJK COMPATIBILITY IDEOGRAPH-F925 +F926 CJK COMPATIBILITY IDEOGRAPH-F926 +F927 CJK COMPATIBILITY IDEOGRAPH-F927 +F928 CJK COMPATIBILITY IDEOGRAPH-F928 +F929 CJK COMPATIBILITY IDEOGRAPH-F929 +F92A CJK COMPATIBILITY IDEOGRAPH-F92A +F92B CJK COMPATIBILITY IDEOGRAPH-F92B +F92C CJK COMPATIBILITY IDEOGRAPH-F92C +F92D CJK COMPATIBILITY IDEOGRAPH-F92D +F92E CJK COMPATIBILITY IDEOGRAPH-F92E +F92F CJK COMPATIBILITY IDEOGRAPH-F92F +F930 CJK COMPATIBILITY IDEOGRAPH-F930 +F931 CJK COMPATIBILITY IDEOGRAPH-F931 +F932 CJK COMPATIBILITY IDEOGRAPH-F932 +F933 CJK COMPATIBILITY IDEOGRAPH-F933 +F934 CJK COMPATIBILITY IDEOGRAPH-F934 +F935 CJK COMPATIBILITY IDEOGRAPH-F935 +F936 CJK COMPATIBILITY IDEOGRAPH-F936 +F937 CJK COMPATIBILITY IDEOGRAPH-F937 +F938 CJK COMPATIBILITY IDEOGRAPH-F938 +F939 CJK COMPATIBILITY IDEOGRAPH-F939 +F93A CJK COMPATIBILITY IDEOGRAPH-F93A +F93B CJK COMPATIBILITY IDEOGRAPH-F93B +F93C CJK COMPATIBILITY IDEOGRAPH-F93C +F93D CJK COMPATIBILITY IDEOGRAPH-F93D +F93E CJK COMPATIBILITY IDEOGRAPH-F93E +F93F CJK COMPATIBILITY IDEOGRAPH-F93F +F940 CJK COMPATIBILITY IDEOGRAPH-F940 +F941 CJK COMPATIBILITY IDEOGRAPH-F941 +F942 CJK COMPATIBILITY IDEOGRAPH-F942 +F943 CJK COMPATIBILITY IDEOGRAPH-F943 +F944 CJK COMPATIBILITY IDEOGRAPH-F944 +F945 CJK COMPATIBILITY IDEOGRAPH-F945 +F946 CJK COMPATIBILITY IDEOGRAPH-F946 +F947 CJK COMPATIBILITY IDEOGRAPH-F947 +F948 CJK COMPATIBILITY IDEOGRAPH-F948 +F949 CJK COMPATIBILITY IDEOGRAPH-F949 +F94A CJK COMPATIBILITY IDEOGRAPH-F94A +F94B CJK COMPATIBILITY IDEOGRAPH-F94B +F94C CJK COMPATIBILITY IDEOGRAPH-F94C +F94D CJK COMPATIBILITY IDEOGRAPH-F94D +F94E CJK COMPATIBILITY IDEOGRAPH-F94E +F94F CJK COMPATIBILITY IDEOGRAPH-F94F +F950 CJK COMPATIBILITY IDEOGRAPH-F950 +F951 CJK COMPATIBILITY IDEOGRAPH-F951 +F952 CJK COMPATIBILITY IDEOGRAPH-F952 +F953 CJK COMPATIBILITY IDEOGRAPH-F953 +F954 CJK COMPATIBILITY IDEOGRAPH-F954 +F955 CJK COMPATIBILITY IDEOGRAPH-F955 +F956 CJK COMPATIBILITY IDEOGRAPH-F956 +F957 CJK COMPATIBILITY IDEOGRAPH-F957 +F958 CJK COMPATIBILITY IDEOGRAPH-F958 +F959 CJK COMPATIBILITY IDEOGRAPH-F959 +F95A CJK COMPATIBILITY IDEOGRAPH-F95A +F95B CJK COMPATIBILITY IDEOGRAPH-F95B +F95C CJK COMPATIBILITY IDEOGRAPH-F95C +F95D CJK COMPATIBILITY IDEOGRAPH-F95D +F95E CJK COMPATIBILITY IDEOGRAPH-F95E +F95F CJK COMPATIBILITY IDEOGRAPH-F95F +F960 CJK COMPATIBILITY IDEOGRAPH-F960 +F961 CJK COMPATIBILITY IDEOGRAPH-F961 +F962 CJK COMPATIBILITY IDEOGRAPH-F962 +F963 CJK COMPATIBILITY IDEOGRAPH-F963 +F964 CJK COMPATIBILITY IDEOGRAPH-F964 +F965 CJK COMPATIBILITY IDEOGRAPH-F965 +F966 CJK COMPATIBILITY IDEOGRAPH-F966 +F967 CJK COMPATIBILITY IDEOGRAPH-F967 +F968 CJK COMPATIBILITY IDEOGRAPH-F968 +F969 CJK COMPATIBILITY IDEOGRAPH-F969 +F96A CJK COMPATIBILITY IDEOGRAPH-F96A +F96B CJK COMPATIBILITY IDEOGRAPH-F96B +F96C CJK COMPATIBILITY IDEOGRAPH-F96C +F96D CJK COMPATIBILITY IDEOGRAPH-F96D +F96E CJK COMPATIBILITY IDEOGRAPH-F96E +F96F CJK COMPATIBILITY IDEOGRAPH-F96F +F970 CJK COMPATIBILITY IDEOGRAPH-F970 +F971 CJK COMPATIBILITY IDEOGRAPH-F971 +F972 CJK COMPATIBILITY IDEOGRAPH-F972 +F973 CJK COMPATIBILITY IDEOGRAPH-F973 +F974 CJK COMPATIBILITY IDEOGRAPH-F974 +F975 CJK COMPATIBILITY IDEOGRAPH-F975 +F976 CJK COMPATIBILITY IDEOGRAPH-F976 +F977 CJK COMPATIBILITY IDEOGRAPH-F977 +F978 CJK COMPATIBILITY IDEOGRAPH-F978 +F979 CJK COMPATIBILITY IDEOGRAPH-F979 +F97A CJK COMPATIBILITY IDEOGRAPH-F97A +F97B CJK COMPATIBILITY IDEOGRAPH-F97B +F97C CJK COMPATIBILITY IDEOGRAPH-F97C +F97D CJK COMPATIBILITY IDEOGRAPH-F97D +F97E CJK COMPATIBILITY IDEOGRAPH-F97E +F97F CJK COMPATIBILITY IDEOGRAPH-F97F +F980 CJK COMPATIBILITY IDEOGRAPH-F980 +F981 CJK COMPATIBILITY IDEOGRAPH-F981 +F982 CJK COMPATIBILITY IDEOGRAPH-F982 +F983 CJK COMPATIBILITY IDEOGRAPH-F983 +F984 CJK COMPATIBILITY IDEOGRAPH-F984 +F985 CJK COMPATIBILITY IDEOGRAPH-F985 +F986 CJK COMPATIBILITY IDEOGRAPH-F986 +F987 CJK COMPATIBILITY IDEOGRAPH-F987 +F988 CJK COMPATIBILITY IDEOGRAPH-F988 +F989 CJK COMPATIBILITY IDEOGRAPH-F989 +F98A CJK COMPATIBILITY IDEOGRAPH-F98A +F98B CJK COMPATIBILITY IDEOGRAPH-F98B +F98C CJK COMPATIBILITY IDEOGRAPH-F98C +F98D CJK COMPATIBILITY IDEOGRAPH-F98D +F98E CJK COMPATIBILITY IDEOGRAPH-F98E +F98F CJK COMPATIBILITY IDEOGRAPH-F98F +F990 CJK COMPATIBILITY IDEOGRAPH-F990 +F991 CJK COMPATIBILITY IDEOGRAPH-F991 +F992 CJK COMPATIBILITY IDEOGRAPH-F992 +F993 CJK COMPATIBILITY IDEOGRAPH-F993 +F994 CJK COMPATIBILITY IDEOGRAPH-F994 +F995 CJK COMPATIBILITY IDEOGRAPH-F995 +F996 CJK COMPATIBILITY IDEOGRAPH-F996 +F997 CJK COMPATIBILITY IDEOGRAPH-F997 +F998 CJK COMPATIBILITY IDEOGRAPH-F998 +F999 CJK COMPATIBILITY IDEOGRAPH-F999 +F99A CJK COMPATIBILITY IDEOGRAPH-F99A +F99B CJK COMPATIBILITY IDEOGRAPH-F99B +F99C CJK COMPATIBILITY IDEOGRAPH-F99C +F99D CJK COMPATIBILITY IDEOGRAPH-F99D +F99E CJK COMPATIBILITY IDEOGRAPH-F99E +F99F CJK COMPATIBILITY IDEOGRAPH-F99F +F9A0 CJK COMPATIBILITY IDEOGRAPH-F9A0 +F9A1 CJK COMPATIBILITY IDEOGRAPH-F9A1 +F9A2 CJK COMPATIBILITY IDEOGRAPH-F9A2 +F9A3 CJK COMPATIBILITY IDEOGRAPH-F9A3 +F9A4 CJK COMPATIBILITY IDEOGRAPH-F9A4 +F9A5 CJK COMPATIBILITY IDEOGRAPH-F9A5 +F9A6 CJK COMPATIBILITY IDEOGRAPH-F9A6 +F9A7 CJK COMPATIBILITY IDEOGRAPH-F9A7 +F9A8 CJK COMPATIBILITY IDEOGRAPH-F9A8 +F9A9 CJK COMPATIBILITY IDEOGRAPH-F9A9 +F9AA CJK COMPATIBILITY IDEOGRAPH-F9AA +F9AB CJK COMPATIBILITY IDEOGRAPH-F9AB +F9AC CJK COMPATIBILITY IDEOGRAPH-F9AC +F9AD CJK COMPATIBILITY IDEOGRAPH-F9AD +F9AE CJK COMPATIBILITY IDEOGRAPH-F9AE +F9AF CJK COMPATIBILITY IDEOGRAPH-F9AF +F9B0 CJK COMPATIBILITY IDEOGRAPH-F9B0 +F9B1 CJK COMPATIBILITY IDEOGRAPH-F9B1 +F9B2 CJK COMPATIBILITY IDEOGRAPH-F9B2 +F9B3 CJK COMPATIBILITY IDEOGRAPH-F9B3 +F9B4 CJK COMPATIBILITY IDEOGRAPH-F9B4 +F9B5 CJK COMPATIBILITY IDEOGRAPH-F9B5 +F9B6 CJK COMPATIBILITY IDEOGRAPH-F9B6 +F9B7 CJK COMPATIBILITY IDEOGRAPH-F9B7 +F9B8 CJK COMPATIBILITY IDEOGRAPH-F9B8 +F9B9 CJK COMPATIBILITY IDEOGRAPH-F9B9 +F9BA CJK COMPATIBILITY IDEOGRAPH-F9BA +F9BB CJK COMPATIBILITY IDEOGRAPH-F9BB +F9BC CJK COMPATIBILITY IDEOGRAPH-F9BC +F9BD CJK COMPATIBILITY IDEOGRAPH-F9BD +F9BE CJK COMPATIBILITY IDEOGRAPH-F9BE +F9BF CJK COMPATIBILITY IDEOGRAPH-F9BF +F9C0 CJK COMPATIBILITY IDEOGRAPH-F9C0 +F9C1 CJK COMPATIBILITY IDEOGRAPH-F9C1 +F9C2 CJK COMPATIBILITY IDEOGRAPH-F9C2 +F9C3 CJK COMPATIBILITY IDEOGRAPH-F9C3 +F9C4 CJK COMPATIBILITY IDEOGRAPH-F9C4 +F9C5 CJK COMPATIBILITY IDEOGRAPH-F9C5 +F9C6 CJK COMPATIBILITY IDEOGRAPH-F9C6 +F9C7 CJK COMPATIBILITY IDEOGRAPH-F9C7 +F9C8 CJK COMPATIBILITY IDEOGRAPH-F9C8 +F9C9 CJK COMPATIBILITY IDEOGRAPH-F9C9 +F9CA CJK COMPATIBILITY IDEOGRAPH-F9CA +F9CB CJK COMPATIBILITY IDEOGRAPH-F9CB +F9CC CJK COMPATIBILITY IDEOGRAPH-F9CC +F9CD CJK COMPATIBILITY IDEOGRAPH-F9CD +F9CE CJK COMPATIBILITY IDEOGRAPH-F9CE +F9CF CJK COMPATIBILITY IDEOGRAPH-F9CF +F9D0 CJK COMPATIBILITY IDEOGRAPH-F9D0 +F9D1 CJK COMPATIBILITY IDEOGRAPH-F9D1 +F9D2 CJK COMPATIBILITY IDEOGRAPH-F9D2 +F9D3 CJK COMPATIBILITY IDEOGRAPH-F9D3 +F9D4 CJK COMPATIBILITY IDEOGRAPH-F9D4 +F9D5 CJK COMPATIBILITY IDEOGRAPH-F9D5 +F9D6 CJK COMPATIBILITY IDEOGRAPH-F9D6 +F9D7 CJK COMPATIBILITY IDEOGRAPH-F9D7 +F9D8 CJK COMPATIBILITY IDEOGRAPH-F9D8 +F9D9 CJK COMPATIBILITY IDEOGRAPH-F9D9 +F9DA CJK COMPATIBILITY IDEOGRAPH-F9DA +F9DB CJK COMPATIBILITY IDEOGRAPH-F9DB +F9DC CJK COMPATIBILITY IDEOGRAPH-F9DC +F9DD CJK COMPATIBILITY IDEOGRAPH-F9DD +F9DE CJK COMPATIBILITY IDEOGRAPH-F9DE +F9DF CJK COMPATIBILITY IDEOGRAPH-F9DF +F9E0 CJK COMPATIBILITY IDEOGRAPH-F9E0 +F9E1 CJK COMPATIBILITY IDEOGRAPH-F9E1 +F9E2 CJK COMPATIBILITY IDEOGRAPH-F9E2 +F9E3 CJK COMPATIBILITY IDEOGRAPH-F9E3 +F9E4 CJK COMPATIBILITY IDEOGRAPH-F9E4 +F9E5 CJK COMPATIBILITY IDEOGRAPH-F9E5 +F9E6 CJK COMPATIBILITY IDEOGRAPH-F9E6 +F9E7 CJK COMPATIBILITY IDEOGRAPH-F9E7 +F9E8 CJK COMPATIBILITY IDEOGRAPH-F9E8 +F9E9 CJK COMPATIBILITY IDEOGRAPH-F9E9 +F9EA CJK COMPATIBILITY IDEOGRAPH-F9EA +F9EB CJK COMPATIBILITY IDEOGRAPH-F9EB +F9EC CJK COMPATIBILITY IDEOGRAPH-F9EC +F9ED CJK COMPATIBILITY IDEOGRAPH-F9ED +F9EE CJK COMPATIBILITY IDEOGRAPH-F9EE +F9EF CJK COMPATIBILITY IDEOGRAPH-F9EF +F9F0 CJK COMPATIBILITY IDEOGRAPH-F9F0 +F9F1 CJK COMPATIBILITY IDEOGRAPH-F9F1 +F9F2 CJK COMPATIBILITY IDEOGRAPH-F9F2 +F9F3 CJK COMPATIBILITY IDEOGRAPH-F9F3 +F9F4 CJK COMPATIBILITY IDEOGRAPH-F9F4 +F9F5 CJK COMPATIBILITY IDEOGRAPH-F9F5 +F9F6 CJK COMPATIBILITY IDEOGRAPH-F9F6 +F9F7 CJK COMPATIBILITY IDEOGRAPH-F9F7 +F9F8 CJK COMPATIBILITY IDEOGRAPH-F9F8 +F9F9 CJK COMPATIBILITY IDEOGRAPH-F9F9 +F9FA CJK COMPATIBILITY IDEOGRAPH-F9FA +F9FB CJK COMPATIBILITY IDEOGRAPH-F9FB +F9FC CJK COMPATIBILITY IDEOGRAPH-F9FC +F9FD CJK COMPATIBILITY IDEOGRAPH-F9FD +F9FE CJK COMPATIBILITY IDEOGRAPH-F9FE +F9FF CJK COMPATIBILITY IDEOGRAPH-F9FF +FA00 CJK COMPATIBILITY IDEOGRAPH-FA00 +FA01 CJK COMPATIBILITY IDEOGRAPH-FA01 +FA02 CJK COMPATIBILITY IDEOGRAPH-FA02 +FA03 CJK COMPATIBILITY IDEOGRAPH-FA03 +FA04 CJK COMPATIBILITY IDEOGRAPH-FA04 +FA05 CJK COMPATIBILITY IDEOGRAPH-FA05 +FA06 CJK COMPATIBILITY IDEOGRAPH-FA06 +FA07 CJK COMPATIBILITY IDEOGRAPH-FA07 +FA08 CJK COMPATIBILITY IDEOGRAPH-FA08 +FA09 CJK COMPATIBILITY IDEOGRAPH-FA09 +FA0A CJK COMPATIBILITY IDEOGRAPH-FA0A +FA0B CJK COMPATIBILITY IDEOGRAPH-FA0B +FA0C CJK COMPATIBILITY IDEOGRAPH-FA0C +FA0D CJK COMPATIBILITY IDEOGRAPH-FA0D +FA0E CJK COMPATIBILITY IDEOGRAPH-FA0E +FA0F CJK COMPATIBILITY IDEOGRAPH-FA0F +FA10 CJK COMPATIBILITY IDEOGRAPH-FA10 +FA11 CJK COMPATIBILITY IDEOGRAPH-FA11 +FA12 CJK COMPATIBILITY IDEOGRAPH-FA12 +FA13 CJK COMPATIBILITY IDEOGRAPH-FA13 +FA14 CJK COMPATIBILITY IDEOGRAPH-FA14 +FA15 CJK COMPATIBILITY IDEOGRAPH-FA15 +FA16 CJK COMPATIBILITY IDEOGRAPH-FA16 +FA17 CJK COMPATIBILITY IDEOGRAPH-FA17 +FA18 CJK COMPATIBILITY IDEOGRAPH-FA18 +FA19 CJK COMPATIBILITY IDEOGRAPH-FA19 +FA1A CJK COMPATIBILITY IDEOGRAPH-FA1A +FA1B CJK COMPATIBILITY IDEOGRAPH-FA1B +FA1C CJK COMPATIBILITY IDEOGRAPH-FA1C +FA1D CJK COMPATIBILITY IDEOGRAPH-FA1D +FA1E CJK COMPATIBILITY IDEOGRAPH-FA1E +FA1F CJK COMPATIBILITY IDEOGRAPH-FA1F +FA20 CJK COMPATIBILITY IDEOGRAPH-FA20 +FA21 CJK COMPATIBILITY IDEOGRAPH-FA21 +FA22 CJK COMPATIBILITY IDEOGRAPH-FA22 +FA23 CJK COMPATIBILITY IDEOGRAPH-FA23 +FA24 CJK COMPATIBILITY IDEOGRAPH-FA24 +FA25 CJK COMPATIBILITY IDEOGRAPH-FA25 +FA26 CJK COMPATIBILITY IDEOGRAPH-FA26 +FA27 CJK COMPATIBILITY IDEOGRAPH-FA27 +FA28 CJK COMPATIBILITY IDEOGRAPH-FA28 +FA29 CJK COMPATIBILITY IDEOGRAPH-FA29 +FA2A CJK COMPATIBILITY IDEOGRAPH-FA2A +FA2B CJK COMPATIBILITY IDEOGRAPH-FA2B +FA2C CJK COMPATIBILITY IDEOGRAPH-FA2C +FA2D CJK COMPATIBILITY IDEOGRAPH-FA2D +FA30 CJK COMPATIBILITY IDEOGRAPH-FA30 +FA31 CJK COMPATIBILITY IDEOGRAPH-FA31 +FA32 CJK COMPATIBILITY IDEOGRAPH-FA32 +FA33 CJK COMPATIBILITY IDEOGRAPH-FA33 +FA34 CJK COMPATIBILITY IDEOGRAPH-FA34 +FA35 CJK COMPATIBILITY IDEOGRAPH-FA35 +FA36 CJK COMPATIBILITY IDEOGRAPH-FA36 +FA37 CJK COMPATIBILITY IDEOGRAPH-FA37 +FA38 CJK COMPATIBILITY IDEOGRAPH-FA38 +FA39 CJK COMPATIBILITY IDEOGRAPH-FA39 +FA3A CJK COMPATIBILITY IDEOGRAPH-FA3A +FA3B CJK COMPATIBILITY IDEOGRAPH-FA3B +FA3C CJK COMPATIBILITY IDEOGRAPH-FA3C +FA3D CJK COMPATIBILITY IDEOGRAPH-FA3D +FA3E CJK COMPATIBILITY IDEOGRAPH-FA3E +FA3F CJK COMPATIBILITY IDEOGRAPH-FA3F +FA40 CJK COMPATIBILITY IDEOGRAPH-FA40 +FA41 CJK COMPATIBILITY IDEOGRAPH-FA41 +FA42 CJK COMPATIBILITY IDEOGRAPH-FA42 +FA43 CJK COMPATIBILITY IDEOGRAPH-FA43 +FA44 CJK COMPATIBILITY IDEOGRAPH-FA44 +FA45 CJK COMPATIBILITY IDEOGRAPH-FA45 +FA46 CJK COMPATIBILITY IDEOGRAPH-FA46 +FA47 CJK COMPATIBILITY IDEOGRAPH-FA47 +FA48 CJK COMPATIBILITY IDEOGRAPH-FA48 +FA49 CJK COMPATIBILITY IDEOGRAPH-FA49 +FA4A CJK COMPATIBILITY IDEOGRAPH-FA4A +FA4B CJK COMPATIBILITY IDEOGRAPH-FA4B +FA4C CJK COMPATIBILITY IDEOGRAPH-FA4C +FA4D CJK COMPATIBILITY IDEOGRAPH-FA4D +FA4E CJK COMPATIBILITY IDEOGRAPH-FA4E +FA4F CJK COMPATIBILITY IDEOGRAPH-FA4F +FA50 CJK COMPATIBILITY IDEOGRAPH-FA50 +FA51 CJK COMPATIBILITY IDEOGRAPH-FA51 +FA52 CJK COMPATIBILITY IDEOGRAPH-FA52 +FA53 CJK COMPATIBILITY IDEOGRAPH-FA53 +FA54 CJK COMPATIBILITY IDEOGRAPH-FA54 +FA55 CJK COMPATIBILITY IDEOGRAPH-FA55 +FA56 CJK COMPATIBILITY IDEOGRAPH-FA56 +FA57 CJK COMPATIBILITY IDEOGRAPH-FA57 +FA58 CJK COMPATIBILITY IDEOGRAPH-FA58 +FA59 CJK COMPATIBILITY IDEOGRAPH-FA59 +FA5A CJK COMPATIBILITY IDEOGRAPH-FA5A +FA5B CJK COMPATIBILITY IDEOGRAPH-FA5B +FA5C CJK COMPATIBILITY IDEOGRAPH-FA5C +FA5D CJK COMPATIBILITY IDEOGRAPH-FA5D +FA5E CJK COMPATIBILITY IDEOGRAPH-FA5E +FA5F CJK COMPATIBILITY IDEOGRAPH-FA5F +FA60 CJK COMPATIBILITY IDEOGRAPH-FA60 +FA61 CJK COMPATIBILITY IDEOGRAPH-FA61 +FA62 CJK COMPATIBILITY IDEOGRAPH-FA62 +FA63 CJK COMPATIBILITY IDEOGRAPH-FA63 +FA64 CJK COMPATIBILITY IDEOGRAPH-FA64 +FA65 CJK COMPATIBILITY IDEOGRAPH-FA65 +FA66 CJK COMPATIBILITY IDEOGRAPH-FA66 +FA67 CJK COMPATIBILITY IDEOGRAPH-FA67 +FA68 CJK COMPATIBILITY IDEOGRAPH-FA68 +FA69 CJK COMPATIBILITY IDEOGRAPH-FA69 +FA6A CJK COMPATIBILITY IDEOGRAPH-FA6A +FB00 LATIN SMALL LIGATURE FF +FB01 LATIN SMALL LIGATURE FI +FB02 LATIN SMALL LIGATURE FL +FB03 LATIN SMALL LIGATURE FFI +FB04 LATIN SMALL LIGATURE FFL +FB05 LATIN SMALL LIGATURE LONG S T +FB06 LATIN SMALL LIGATURE ST +FB13 ARMENIAN SMALL LIGATURE MEN NOW +FB14 ARMENIAN SMALL LIGATURE MEN ECH +FB15 ARMENIAN SMALL LIGATURE MEN INI +FB16 ARMENIAN SMALL LIGATURE VEW NOW +FB17 ARMENIAN SMALL LIGATURE MEN XEH +FB1D HEBREW LETTER YOD WITH HIRIQ +FB1E HEBREW POINT JUDEO-SPANISH VARIKA +FB1F HEBREW LIGATURE YIDDISH YOD YOD PATAH +FB20 HEBREW LETTER ALTERNATIVE AYIN +FB21 HEBREW LETTER WIDE ALEF +FB22 HEBREW LETTER WIDE DALET +FB23 HEBREW LETTER WIDE HE +FB24 HEBREW LETTER WIDE KAF +FB25 HEBREW LETTER WIDE LAMED +FB26 HEBREW LETTER WIDE FINAL MEM +FB27 HEBREW LETTER WIDE RESH +FB28 HEBREW LETTER WIDE TAV +FB29 HEBREW LETTER ALTERNATIVE PLUS SIGN +FB2A HEBREW LETTER SHIN WITH SHIN DOT +FB2B HEBREW LETTER SHIN WITH SIN DOT +FB2C HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT +FB2D HEBREW LETTER SHIN WITH DAGESH AND SIN DOT +FB2E HEBREW LETTER ALEF WITH PATAH +FB2F HEBREW LETTER ALEF WITH QAMATS +FB30 HEBREW LETTER ALEF WITH MAPIQ +FB31 HEBREW LETTER BET WITH DAGESH +FB32 HEBREW LETTER GIMEL WITH DAGESH +FB33 HEBREW LETTER DALET WITH DAGESH +FB34 HEBREW LETTER HE WITH MAPIQ +FB35 HEBREW LETTER VAV WITH DAGESH +FB36 HEBREW LETTER ZAYIN WITH DAGESH +FB38 HEBREW LETTER TET WITH DAGESH +FB39 HEBREW LETTER YOD WITH DAGESH +FB3A HEBREW LETTER FINAL KAF WITH DAGESH +FB3B HEBREW LETTER KAF WITH DAGESH +FB3C HEBREW LETTER LAMED WITH DAGESH +FB3E HEBREW LETTER MEM WITH DAGESH +FB40 HEBREW LETTER NUN WITH DAGESH +FB41 HEBREW LETTER SAMEKH WITH DAGESH +FB43 HEBREW LETTER FINAL PE WITH DAGESH +FB44 HEBREW LETTER PE WITH DAGESH +FB46 HEBREW LETTER TSADI WITH DAGESH +FB47 HEBREW LETTER QOF WITH DAGESH +FB48 HEBREW LETTER RESH WITH DAGESH +FB49 HEBREW LETTER SHIN WITH DAGESH +FB4A HEBREW LETTER TAV WITH DAGESH +FB4B HEBREW LETTER VAV WITH HOLAM +FB4C HEBREW LETTER BET WITH RAFE +FB4D HEBREW LETTER KAF WITH RAFE +FB4E HEBREW LETTER PE WITH RAFE +FB4F HEBREW LIGATURE ALEF LAMED +FB50 ARABIC LETTER ALEF WASLA ISOLATED FORM +FB51 ARABIC LETTER ALEF WASLA FINAL FORM +FB52 ARABIC LETTER BEEH ISOLATED FORM +FB53 ARABIC LETTER BEEH FINAL FORM +FB54 ARABIC LETTER BEEH INITIAL FORM +FB55 ARABIC LETTER BEEH MEDIAL FORM +FB56 ARABIC LETTER PEH ISOLATED FORM +FB57 ARABIC LETTER PEH FINAL FORM +FB58 ARABIC LETTER PEH INITIAL FORM +FB59 ARABIC LETTER PEH MEDIAL FORM +FB5A ARABIC LETTER BEHEH ISOLATED FORM +FB5B ARABIC LETTER BEHEH FINAL FORM +FB5C ARABIC LETTER BEHEH INITIAL FORM +FB5D ARABIC LETTER BEHEH MEDIAL FORM +FB5E ARABIC LETTER TTEHEH ISOLATED FORM +FB5F ARABIC LETTER TTEHEH FINAL FORM +FB60 ARABIC LETTER TTEHEH INITIAL FORM +FB61 ARABIC LETTER TTEHEH MEDIAL FORM +FB62 ARABIC LETTER TEHEH ISOLATED FORM +FB63 ARABIC LETTER TEHEH FINAL FORM +FB64 ARABIC LETTER TEHEH INITIAL FORM +FB65 ARABIC LETTER TEHEH MEDIAL FORM +FB66 ARABIC LETTER TTEH ISOLATED FORM +FB67 ARABIC LETTER TTEH FINAL FORM +FB68 ARABIC LETTER TTEH INITIAL FORM +FB69 ARABIC LETTER TTEH MEDIAL FORM +FB6A ARABIC LETTER VEH ISOLATED FORM +FB6B ARABIC LETTER VEH FINAL FORM +FB6C ARABIC LETTER VEH INITIAL FORM +FB6D ARABIC LETTER VEH MEDIAL FORM +FB6E ARABIC LETTER PEHEH ISOLATED FORM +FB6F ARABIC LETTER PEHEH FINAL FORM +FB70 ARABIC LETTER PEHEH INITIAL FORM +FB71 ARABIC LETTER PEHEH MEDIAL FORM +FB72 ARABIC LETTER DYEH ISOLATED FORM +FB73 ARABIC LETTER DYEH FINAL FORM +FB74 ARABIC LETTER DYEH INITIAL FORM +FB75 ARABIC LETTER DYEH MEDIAL FORM +FB76 ARABIC LETTER NYEH ISOLATED FORM +FB77 ARABIC LETTER NYEH FINAL FORM +FB78 ARABIC LETTER NYEH INITIAL FORM +FB79 ARABIC LETTER NYEH MEDIAL FORM +FB7A ARABIC LETTER TCHEH ISOLATED FORM +FB7B ARABIC LETTER TCHEH FINAL FORM +FB7C ARABIC LETTER TCHEH INITIAL FORM +FB7D ARABIC LETTER TCHEH MEDIAL FORM +FB7E ARABIC LETTER TCHEHEH ISOLATED FORM +FB7F ARABIC LETTER TCHEHEH FINAL FORM +FB80 ARABIC LETTER TCHEHEH INITIAL FORM +FB81 ARABIC LETTER TCHEHEH MEDIAL FORM +FB82 ARABIC LETTER DDAHAL ISOLATED FORM +FB83 ARABIC LETTER DDAHAL FINAL FORM +FB84 ARABIC LETTER DAHAL ISOLATED FORM +FB85 ARABIC LETTER DAHAL FINAL FORM +FB86 ARABIC LETTER DUL ISOLATED FORM +FB87 ARABIC LETTER DUL FINAL FORM +FB88 ARABIC LETTER DDAL ISOLATED FORM +FB89 ARABIC LETTER DDAL FINAL FORM +FB8A ARABIC LETTER JEH ISOLATED FORM +FB8B ARABIC LETTER JEH FINAL FORM +FB8C ARABIC LETTER RREH ISOLATED FORM +FB8D ARABIC LETTER RREH FINAL FORM +FB8E ARABIC LETTER KEHEH ISOLATED FORM +FB8F ARABIC LETTER KEHEH FINAL FORM +FB90 ARABIC LETTER KEHEH INITIAL FORM +FB91 ARABIC LETTER KEHEH MEDIAL FORM +FB92 ARABIC LETTER GAF ISOLATED FORM +FB93 ARABIC LETTER GAF FINAL FORM +FB94 ARABIC LETTER GAF INITIAL FORM +FB95 ARABIC LETTER GAF MEDIAL FORM +FB96 ARABIC LETTER GUEH ISOLATED FORM +FB97 ARABIC LETTER GUEH FINAL FORM +FB98 ARABIC LETTER GUEH INITIAL FORM +FB99 ARABIC LETTER GUEH MEDIAL FORM +FB9A ARABIC LETTER NGOEH ISOLATED FORM +FB9B ARABIC LETTER NGOEH FINAL FORM +FB9C ARABIC LETTER NGOEH INITIAL FORM +FB9D ARABIC LETTER NGOEH MEDIAL FORM +FB9E ARABIC LETTER NOON GHUNNA ISOLATED FORM +FB9F ARABIC LETTER NOON GHUNNA FINAL FORM +FBA0 ARABIC LETTER RNOON ISOLATED FORM +FBA1 ARABIC LETTER RNOON FINAL FORM +FBA2 ARABIC LETTER RNOON INITIAL FORM +FBA3 ARABIC LETTER RNOON MEDIAL FORM +FBA4 ARABIC LETTER HEH WITH YEH ABOVE ISOLATED FORM +FBA5 ARABIC LETTER HEH WITH YEH ABOVE FINAL FORM +FBA6 ARABIC LETTER HEH GOAL ISOLATED FORM +FBA7 ARABIC LETTER HEH GOAL FINAL FORM +FBA8 ARABIC LETTER HEH GOAL INITIAL FORM +FBA9 ARABIC LETTER HEH GOAL MEDIAL FORM +FBAA ARABIC LETTER HEH DOACHASHMEE ISOLATED FORM +FBAB ARABIC LETTER HEH DOACHASHMEE FINAL FORM +FBAC ARABIC LETTER HEH DOACHASHMEE INITIAL FORM +FBAD ARABIC LETTER HEH DOACHASHMEE MEDIAL FORM +FBAE ARABIC LETTER YEH BARREE ISOLATED FORM +FBAF ARABIC LETTER YEH BARREE FINAL FORM +FBB0 ARABIC LETTER YEH BARREE WITH HAMZA ABOVE ISOLATED FORM +FBB1 ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM +FBD3 ARABIC LETTER NG ISOLATED FORM +FBD4 ARABIC LETTER NG FINAL FORM +FBD5 ARABIC LETTER NG INITIAL FORM +FBD6 ARABIC LETTER NG MEDIAL FORM +FBD7 ARABIC LETTER U ISOLATED FORM +FBD8 ARABIC LETTER U FINAL FORM +FBD9 ARABIC LETTER OE ISOLATED FORM +FBDA ARABIC LETTER OE FINAL FORM +FBDB ARABIC LETTER YU ISOLATED FORM +FBDC ARABIC LETTER YU FINAL FORM +FBDD ARABIC LETTER U WITH HAMZA ABOVE ISOLATED FORM +FBDE ARABIC LETTER VE ISOLATED FORM +FBDF ARABIC LETTER VE FINAL FORM +FBE0 ARABIC LETTER KIRGHIZ OE ISOLATED FORM +FBE1 ARABIC LETTER KIRGHIZ OE FINAL FORM +FBE2 ARABIC LETTER KIRGHIZ YU ISOLATED FORM +FBE3 ARABIC LETTER KIRGHIZ YU FINAL FORM +FBE4 ARABIC LETTER E ISOLATED FORM +FBE5 ARABIC LETTER E FINAL FORM +FBE6 ARABIC LETTER E INITIAL FORM +FBE7 ARABIC LETTER E MEDIAL FORM +FBE8 ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA INITIAL FORM +FBE9 ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MEDIAL FORM +FBEA ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF ISOLATED FORM +FBEB ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF FINAL FORM +FBEC ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE ISOLATED FORM +FBED ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE FINAL FORM +FBEE ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW ISOLATED FORM +FBEF ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW FINAL FORM +FBF0 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U ISOLATED FORM +FBF1 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U FINAL FORM +FBF2 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE ISOLATED FORM +FBF3 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE FINAL FORM +FBF4 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU ISOLATED FORM +FBF5 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU FINAL FORM +FBF6 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E ISOLATED FORM +FBF7 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E FINAL FORM +FBF8 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E INITIAL FORM +FBF9 ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM +FBFA ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM +FBFB ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM +FBFC ARABIC LETTER FARSI YEH ISOLATED FORM +FBFD ARABIC LETTER FARSI YEH FINAL FORM +FBFE ARABIC LETTER FARSI YEH INITIAL FORM +FBFF ARABIC LETTER FARSI YEH MEDIAL FORM +FC00 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM ISOLATED FORM +FC01 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH ISOLATED FORM +FC02 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM ISOLATED FORM +FC03 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM +FC04 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH ISOLATED FORM +FC05 ARABIC LIGATURE BEH WITH JEEM ISOLATED FORM +FC06 ARABIC LIGATURE BEH WITH HAH ISOLATED FORM +FC07 ARABIC LIGATURE BEH WITH KHAH ISOLATED FORM +FC08 ARABIC LIGATURE BEH WITH MEEM ISOLATED FORM +FC09 ARABIC LIGATURE BEH WITH ALEF MAKSURA ISOLATED FORM +FC0A ARABIC LIGATURE BEH WITH YEH ISOLATED FORM +FC0B ARABIC LIGATURE TEH WITH JEEM ISOLATED FORM +FC0C ARABIC LIGATURE TEH WITH HAH ISOLATED FORM +FC0D ARABIC LIGATURE TEH WITH KHAH ISOLATED FORM +FC0E ARABIC LIGATURE TEH WITH MEEM ISOLATED FORM +FC0F ARABIC LIGATURE TEH WITH ALEF MAKSURA ISOLATED FORM +FC10 ARABIC LIGATURE TEH WITH YEH ISOLATED FORM +FC11 ARABIC LIGATURE THEH WITH JEEM ISOLATED FORM +FC12 ARABIC LIGATURE THEH WITH MEEM ISOLATED FORM +FC13 ARABIC LIGATURE THEH WITH ALEF MAKSURA ISOLATED FORM +FC14 ARABIC LIGATURE THEH WITH YEH ISOLATED FORM +FC15 ARABIC LIGATURE JEEM WITH HAH ISOLATED FORM +FC16 ARABIC LIGATURE JEEM WITH MEEM ISOLATED FORM +FC17 ARABIC LIGATURE HAH WITH JEEM ISOLATED FORM +FC18 ARABIC LIGATURE HAH WITH MEEM ISOLATED FORM +FC19 ARABIC LIGATURE KHAH WITH JEEM ISOLATED FORM +FC1A ARABIC LIGATURE KHAH WITH HAH ISOLATED FORM +FC1B ARABIC LIGATURE KHAH WITH MEEM ISOLATED FORM +FC1C ARABIC LIGATURE SEEN WITH JEEM ISOLATED FORM +FC1D ARABIC LIGATURE SEEN WITH HAH ISOLATED FORM +FC1E ARABIC LIGATURE SEEN WITH KHAH ISOLATED FORM +FC1F ARABIC LIGATURE SEEN WITH MEEM ISOLATED FORM +FC20 ARABIC LIGATURE SAD WITH HAH ISOLATED FORM +FC21 ARABIC LIGATURE SAD WITH MEEM ISOLATED FORM +FC22 ARABIC LIGATURE DAD WITH JEEM ISOLATED FORM +FC23 ARABIC LIGATURE DAD WITH HAH ISOLATED FORM +FC24 ARABIC LIGATURE DAD WITH KHAH ISOLATED FORM +FC25 ARABIC LIGATURE DAD WITH MEEM ISOLATED FORM +FC26 ARABIC LIGATURE TAH WITH HAH ISOLATED FORM +FC27 ARABIC LIGATURE TAH WITH MEEM ISOLATED FORM +FC28 ARABIC LIGATURE ZAH WITH MEEM ISOLATED FORM +FC29 ARABIC LIGATURE AIN WITH JEEM ISOLATED FORM +FC2A ARABIC LIGATURE AIN WITH MEEM ISOLATED FORM +FC2B ARABIC LIGATURE GHAIN WITH JEEM ISOLATED FORM +FC2C ARABIC LIGATURE GHAIN WITH MEEM ISOLATED FORM +FC2D ARABIC LIGATURE FEH WITH JEEM ISOLATED FORM +FC2E ARABIC LIGATURE FEH WITH HAH ISOLATED FORM +FC2F ARABIC LIGATURE FEH WITH KHAH ISOLATED FORM +FC30 ARABIC LIGATURE FEH WITH MEEM ISOLATED FORM +FC31 ARABIC LIGATURE FEH WITH ALEF MAKSURA ISOLATED FORM +FC32 ARABIC LIGATURE FEH WITH YEH ISOLATED FORM +FC33 ARABIC LIGATURE QAF WITH HAH ISOLATED FORM +FC34 ARABIC LIGATURE QAF WITH MEEM ISOLATED FORM +FC35 ARABIC LIGATURE QAF WITH ALEF MAKSURA ISOLATED FORM +FC36 ARABIC LIGATURE QAF WITH YEH ISOLATED FORM +FC37 ARABIC LIGATURE KAF WITH ALEF ISOLATED FORM +FC38 ARABIC LIGATURE KAF WITH JEEM ISOLATED FORM +FC39 ARABIC LIGATURE KAF WITH HAH ISOLATED FORM +FC3A ARABIC LIGATURE KAF WITH KHAH ISOLATED FORM +FC3B ARABIC LIGATURE KAF WITH LAM ISOLATED FORM +FC3C ARABIC LIGATURE KAF WITH MEEM ISOLATED FORM +FC3D ARABIC LIGATURE KAF WITH ALEF MAKSURA ISOLATED FORM +FC3E ARABIC LIGATURE KAF WITH YEH ISOLATED FORM +FC3F ARABIC LIGATURE LAM WITH JEEM ISOLATED FORM +FC40 ARABIC LIGATURE LAM WITH HAH ISOLATED FORM +FC41 ARABIC LIGATURE LAM WITH KHAH ISOLATED FORM +FC42 ARABIC LIGATURE LAM WITH MEEM ISOLATED FORM +FC43 ARABIC LIGATURE LAM WITH ALEF MAKSURA ISOLATED FORM +FC44 ARABIC LIGATURE LAM WITH YEH ISOLATED FORM +FC45 ARABIC LIGATURE MEEM WITH JEEM ISOLATED FORM +FC46 ARABIC LIGATURE MEEM WITH HAH ISOLATED FORM +FC47 ARABIC LIGATURE MEEM WITH KHAH ISOLATED FORM +FC48 ARABIC LIGATURE MEEM WITH MEEM ISOLATED FORM +FC49 ARABIC LIGATURE MEEM WITH ALEF MAKSURA ISOLATED FORM +FC4A ARABIC LIGATURE MEEM WITH YEH ISOLATED FORM +FC4B ARABIC LIGATURE NOON WITH JEEM ISOLATED FORM +FC4C ARABIC LIGATURE NOON WITH HAH ISOLATED FORM +FC4D ARABIC LIGATURE NOON WITH KHAH ISOLATED FORM +FC4E ARABIC LIGATURE NOON WITH MEEM ISOLATED FORM +FC4F ARABIC LIGATURE NOON WITH ALEF MAKSURA ISOLATED FORM +FC50 ARABIC LIGATURE NOON WITH YEH ISOLATED FORM +FC51 ARABIC LIGATURE HEH WITH JEEM ISOLATED FORM +FC52 ARABIC LIGATURE HEH WITH MEEM ISOLATED FORM +FC53 ARABIC LIGATURE HEH WITH ALEF MAKSURA ISOLATED FORM +FC54 ARABIC LIGATURE HEH WITH YEH ISOLATED FORM +FC55 ARABIC LIGATURE YEH WITH JEEM ISOLATED FORM +FC56 ARABIC LIGATURE YEH WITH HAH ISOLATED FORM +FC57 ARABIC LIGATURE YEH WITH KHAH ISOLATED FORM +FC58 ARABIC LIGATURE YEH WITH MEEM ISOLATED FORM +FC59 ARABIC LIGATURE YEH WITH ALEF MAKSURA ISOLATED FORM +FC5A ARABIC LIGATURE YEH WITH YEH ISOLATED FORM +FC5B ARABIC LIGATURE THAL WITH SUPERSCRIPT ALEF ISOLATED FORM +FC5C ARABIC LIGATURE REH WITH SUPERSCRIPT ALEF ISOLATED FORM +FC5D ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF ISOLATED FORM +FC5E ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM +FC5F ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM +FC60 ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM +FC61 ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM +FC62 ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM +FC63 ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM +FC64 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH REH FINAL FORM +FC65 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ZAIN FINAL FORM +FC66 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM FINAL FORM +FC67 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH NOON FINAL FORM +FC68 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM +FC69 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH FINAL FORM +FC6A ARABIC LIGATURE BEH WITH REH FINAL FORM +FC6B ARABIC LIGATURE BEH WITH ZAIN FINAL FORM +FC6C ARABIC LIGATURE BEH WITH MEEM FINAL FORM +FC6D ARABIC LIGATURE BEH WITH NOON FINAL FORM +FC6E ARABIC LIGATURE BEH WITH ALEF MAKSURA FINAL FORM +FC6F ARABIC LIGATURE BEH WITH YEH FINAL FORM +FC70 ARABIC LIGATURE TEH WITH REH FINAL FORM +FC71 ARABIC LIGATURE TEH WITH ZAIN FINAL FORM +FC72 ARABIC LIGATURE TEH WITH MEEM FINAL FORM +FC73 ARABIC LIGATURE TEH WITH NOON FINAL FORM +FC74 ARABIC LIGATURE TEH WITH ALEF MAKSURA FINAL FORM +FC75 ARABIC LIGATURE TEH WITH YEH FINAL FORM +FC76 ARABIC LIGATURE THEH WITH REH FINAL FORM +FC77 ARABIC LIGATURE THEH WITH ZAIN FINAL FORM +FC78 ARABIC LIGATURE THEH WITH MEEM FINAL FORM +FC79 ARABIC LIGATURE THEH WITH NOON FINAL FORM +FC7A ARABIC LIGATURE THEH WITH ALEF MAKSURA FINAL FORM +FC7B ARABIC LIGATURE THEH WITH YEH FINAL FORM +FC7C ARABIC LIGATURE FEH WITH ALEF MAKSURA FINAL FORM +FC7D ARABIC LIGATURE FEH WITH YEH FINAL FORM +FC7E ARABIC LIGATURE QAF WITH ALEF MAKSURA FINAL FORM +FC7F ARABIC LIGATURE QAF WITH YEH FINAL FORM +FC80 ARABIC LIGATURE KAF WITH ALEF FINAL FORM +FC81 ARABIC LIGATURE KAF WITH LAM FINAL FORM +FC82 ARABIC LIGATURE KAF WITH MEEM FINAL FORM +FC83 ARABIC LIGATURE KAF WITH ALEF MAKSURA FINAL FORM +FC84 ARABIC LIGATURE KAF WITH YEH FINAL FORM +FC85 ARABIC LIGATURE LAM WITH MEEM FINAL FORM +FC86 ARABIC LIGATURE LAM WITH ALEF MAKSURA FINAL FORM +FC87 ARABIC LIGATURE LAM WITH YEH FINAL FORM +FC88 ARABIC LIGATURE MEEM WITH ALEF FINAL FORM +FC89 ARABIC LIGATURE MEEM WITH MEEM FINAL FORM +FC8A ARABIC LIGATURE NOON WITH REH FINAL FORM +FC8B ARABIC LIGATURE NOON WITH ZAIN FINAL FORM +FC8C ARABIC LIGATURE NOON WITH MEEM FINAL FORM +FC8D ARABIC LIGATURE NOON WITH NOON FINAL FORM +FC8E ARABIC LIGATURE NOON WITH ALEF MAKSURA FINAL FORM +FC8F ARABIC LIGATURE NOON WITH YEH FINAL FORM +FC90 ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF FINAL FORM +FC91 ARABIC LIGATURE YEH WITH REH FINAL FORM +FC92 ARABIC LIGATURE YEH WITH ZAIN FINAL FORM +FC93 ARABIC LIGATURE YEH WITH MEEM FINAL FORM +FC94 ARABIC LIGATURE YEH WITH NOON FINAL FORM +FC95 ARABIC LIGATURE YEH WITH ALEF MAKSURA FINAL FORM +FC96 ARABIC LIGATURE YEH WITH YEH FINAL FORM +FC97 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM INITIAL FORM +FC98 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH INITIAL FORM +FC99 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH KHAH INITIAL FORM +FC9A ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM INITIAL FORM +FC9B ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH INITIAL FORM +FC9C ARABIC LIGATURE BEH WITH JEEM INITIAL FORM +FC9D ARABIC LIGATURE BEH WITH HAH INITIAL FORM +FC9E ARABIC LIGATURE BEH WITH KHAH INITIAL FORM +FC9F ARABIC LIGATURE BEH WITH MEEM INITIAL FORM +FCA0 ARABIC LIGATURE BEH WITH HEH INITIAL FORM +FCA1 ARABIC LIGATURE TEH WITH JEEM INITIAL FORM +FCA2 ARABIC LIGATURE TEH WITH HAH INITIAL FORM +FCA3 ARABIC LIGATURE TEH WITH KHAH INITIAL FORM +FCA4 ARABIC LIGATURE TEH WITH MEEM INITIAL FORM +FCA5 ARABIC LIGATURE TEH WITH HEH INITIAL FORM +FCA6 ARABIC LIGATURE THEH WITH MEEM INITIAL FORM +FCA7 ARABIC LIGATURE JEEM WITH HAH INITIAL FORM +FCA8 ARABIC LIGATURE JEEM WITH MEEM INITIAL FORM +FCA9 ARABIC LIGATURE HAH WITH JEEM INITIAL FORM +FCAA ARABIC LIGATURE HAH WITH MEEM INITIAL FORM +FCAB ARABIC LIGATURE KHAH WITH JEEM INITIAL FORM +FCAC ARABIC LIGATURE KHAH WITH MEEM INITIAL FORM +FCAD ARABIC LIGATURE SEEN WITH JEEM INITIAL FORM +FCAE ARABIC LIGATURE SEEN WITH HAH INITIAL FORM +FCAF ARABIC LIGATURE SEEN WITH KHAH INITIAL FORM +FCB0 ARABIC LIGATURE SEEN WITH MEEM INITIAL FORM +FCB1 ARABIC LIGATURE SAD WITH HAH INITIAL FORM +FCB2 ARABIC LIGATURE SAD WITH KHAH INITIAL FORM +FCB3 ARABIC LIGATURE SAD WITH MEEM INITIAL FORM +FCB4 ARABIC LIGATURE DAD WITH JEEM INITIAL FORM +FCB5 ARABIC LIGATURE DAD WITH HAH INITIAL FORM +FCB6 ARABIC LIGATURE DAD WITH KHAH INITIAL FORM +FCB7 ARABIC LIGATURE DAD WITH MEEM INITIAL FORM +FCB8 ARABIC LIGATURE TAH WITH HAH INITIAL FORM +FCB9 ARABIC LIGATURE ZAH WITH MEEM INITIAL FORM +FCBA ARABIC LIGATURE AIN WITH JEEM INITIAL FORM +FCBB ARABIC LIGATURE AIN WITH MEEM INITIAL FORM +FCBC ARABIC LIGATURE GHAIN WITH JEEM INITIAL FORM +FCBD ARABIC LIGATURE GHAIN WITH MEEM INITIAL FORM +FCBE ARABIC LIGATURE FEH WITH JEEM INITIAL FORM +FCBF ARABIC LIGATURE FEH WITH HAH INITIAL FORM +FCC0 ARABIC LIGATURE FEH WITH KHAH INITIAL FORM +FCC1 ARABIC LIGATURE FEH WITH MEEM INITIAL FORM +FCC2 ARABIC LIGATURE QAF WITH HAH INITIAL FORM +FCC3 ARABIC LIGATURE QAF WITH MEEM INITIAL FORM +FCC4 ARABIC LIGATURE KAF WITH JEEM INITIAL FORM +FCC5 ARABIC LIGATURE KAF WITH HAH INITIAL FORM +FCC6 ARABIC LIGATURE KAF WITH KHAH INITIAL FORM +FCC7 ARABIC LIGATURE KAF WITH LAM INITIAL FORM +FCC8 ARABIC LIGATURE KAF WITH MEEM INITIAL FORM +FCC9 ARABIC LIGATURE LAM WITH JEEM INITIAL FORM +FCCA ARABIC LIGATURE LAM WITH HAH INITIAL FORM +FCCB ARABIC LIGATURE LAM WITH KHAH INITIAL FORM +FCCC ARABIC LIGATURE LAM WITH MEEM INITIAL FORM +FCCD ARABIC LIGATURE LAM WITH HEH INITIAL FORM +FCCE ARABIC LIGATURE MEEM WITH JEEM INITIAL FORM +FCCF ARABIC LIGATURE MEEM WITH HAH INITIAL FORM +FCD0 ARABIC LIGATURE MEEM WITH KHAH INITIAL FORM +FCD1 ARABIC LIGATURE MEEM WITH MEEM INITIAL FORM +FCD2 ARABIC LIGATURE NOON WITH JEEM INITIAL FORM +FCD3 ARABIC LIGATURE NOON WITH HAH INITIAL FORM +FCD4 ARABIC LIGATURE NOON WITH KHAH INITIAL FORM +FCD5 ARABIC LIGATURE NOON WITH MEEM INITIAL FORM +FCD6 ARABIC LIGATURE NOON WITH HEH INITIAL FORM +FCD7 ARABIC LIGATURE HEH WITH JEEM INITIAL FORM +FCD8 ARABIC LIGATURE HEH WITH MEEM INITIAL FORM +FCD9 ARABIC LIGATURE HEH WITH SUPERSCRIPT ALEF INITIAL FORM +FCDA ARABIC LIGATURE YEH WITH JEEM INITIAL FORM +FCDB ARABIC LIGATURE YEH WITH HAH INITIAL FORM +FCDC ARABIC LIGATURE YEH WITH KHAH INITIAL FORM +FCDD ARABIC LIGATURE YEH WITH MEEM INITIAL FORM +FCDE ARABIC LIGATURE YEH WITH HEH INITIAL FORM +FCDF ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM MEDIAL FORM +FCE0 ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH MEDIAL FORM +FCE1 ARABIC LIGATURE BEH WITH MEEM MEDIAL FORM +FCE2 ARABIC LIGATURE BEH WITH HEH MEDIAL FORM +FCE3 ARABIC LIGATURE TEH WITH MEEM MEDIAL FORM +FCE4 ARABIC LIGATURE TEH WITH HEH MEDIAL FORM +FCE5 ARABIC LIGATURE THEH WITH MEEM MEDIAL FORM +FCE6 ARABIC LIGATURE THEH WITH HEH MEDIAL FORM +FCE7 ARABIC LIGATURE SEEN WITH MEEM MEDIAL FORM +FCE8 ARABIC LIGATURE SEEN WITH HEH MEDIAL FORM +FCE9 ARABIC LIGATURE SHEEN WITH MEEM MEDIAL FORM +FCEA ARABIC LIGATURE SHEEN WITH HEH MEDIAL FORM +FCEB ARABIC LIGATURE KAF WITH LAM MEDIAL FORM +FCEC ARABIC LIGATURE KAF WITH MEEM MEDIAL FORM +FCED ARABIC LIGATURE LAM WITH MEEM MEDIAL FORM +FCEE ARABIC LIGATURE NOON WITH MEEM MEDIAL FORM +FCEF ARABIC LIGATURE NOON WITH HEH MEDIAL FORM +FCF0 ARABIC LIGATURE YEH WITH MEEM MEDIAL FORM +FCF1 ARABIC LIGATURE YEH WITH HEH MEDIAL FORM +FCF2 ARABIC LIGATURE SHADDA WITH FATHA MEDIAL FORM +FCF3 ARABIC LIGATURE SHADDA WITH DAMMA MEDIAL FORM +FCF4 ARABIC LIGATURE SHADDA WITH KASRA MEDIAL FORM +FCF5 ARABIC LIGATURE TAH WITH ALEF MAKSURA ISOLATED FORM +FCF6 ARABIC LIGATURE TAH WITH YEH ISOLATED FORM +FCF7 ARABIC LIGATURE AIN WITH ALEF MAKSURA ISOLATED FORM +FCF8 ARABIC LIGATURE AIN WITH YEH ISOLATED FORM +FCF9 ARABIC LIGATURE GHAIN WITH ALEF MAKSURA ISOLATED FORM +FCFA ARABIC LIGATURE GHAIN WITH YEH ISOLATED FORM +FCFB ARABIC LIGATURE SEEN WITH ALEF MAKSURA ISOLATED FORM +FCFC ARABIC LIGATURE SEEN WITH YEH ISOLATED FORM +FCFD ARABIC LIGATURE SHEEN WITH ALEF MAKSURA ISOLATED FORM +FCFE ARABIC LIGATURE SHEEN WITH YEH ISOLATED FORM +FCFF ARABIC LIGATURE HAH WITH ALEF MAKSURA ISOLATED FORM +FD00 ARABIC LIGATURE HAH WITH YEH ISOLATED FORM +FD01 ARABIC LIGATURE JEEM WITH ALEF MAKSURA ISOLATED FORM +FD02 ARABIC LIGATURE JEEM WITH YEH ISOLATED FORM +FD03 ARABIC LIGATURE KHAH WITH ALEF MAKSURA ISOLATED FORM +FD04 ARABIC LIGATURE KHAH WITH YEH ISOLATED FORM +FD05 ARABIC LIGATURE SAD WITH ALEF MAKSURA ISOLATED FORM +FD06 ARABIC LIGATURE SAD WITH YEH ISOLATED FORM +FD07 ARABIC LIGATURE DAD WITH ALEF MAKSURA ISOLATED FORM +FD08 ARABIC LIGATURE DAD WITH YEH ISOLATED FORM +FD09 ARABIC LIGATURE SHEEN WITH JEEM ISOLATED FORM +FD0A ARABIC LIGATURE SHEEN WITH HAH ISOLATED FORM +FD0B ARABIC LIGATURE SHEEN WITH KHAH ISOLATED FORM +FD0C ARABIC LIGATURE SHEEN WITH MEEM ISOLATED FORM +FD0D ARABIC LIGATURE SHEEN WITH REH ISOLATED FORM +FD0E ARABIC LIGATURE SEEN WITH REH ISOLATED FORM +FD0F ARABIC LIGATURE SAD WITH REH ISOLATED FORM +FD10 ARABIC LIGATURE DAD WITH REH ISOLATED FORM +FD11 ARABIC LIGATURE TAH WITH ALEF MAKSURA FINAL FORM +FD12 ARABIC LIGATURE TAH WITH YEH FINAL FORM +FD13 ARABIC LIGATURE AIN WITH ALEF MAKSURA FINAL FORM +FD14 ARABIC LIGATURE AIN WITH YEH FINAL FORM +FD15 ARABIC LIGATURE GHAIN WITH ALEF MAKSURA FINAL FORM +FD16 ARABIC LIGATURE GHAIN WITH YEH FINAL FORM +FD17 ARABIC LIGATURE SEEN WITH ALEF MAKSURA FINAL FORM +FD18 ARABIC LIGATURE SEEN WITH YEH FINAL FORM +FD19 ARABIC LIGATURE SHEEN WITH ALEF MAKSURA FINAL FORM +FD1A ARABIC LIGATURE SHEEN WITH YEH FINAL FORM +FD1B ARABIC LIGATURE HAH WITH ALEF MAKSURA FINAL FORM +FD1C ARABIC LIGATURE HAH WITH YEH FINAL FORM +FD1D ARABIC LIGATURE JEEM WITH ALEF MAKSURA FINAL FORM +FD1E ARABIC LIGATURE JEEM WITH YEH FINAL FORM +FD1F ARABIC LIGATURE KHAH WITH ALEF MAKSURA FINAL FORM +FD20 ARABIC LIGATURE KHAH WITH YEH FINAL FORM +FD21 ARABIC LIGATURE SAD WITH ALEF MAKSURA FINAL FORM +FD22 ARABIC LIGATURE SAD WITH YEH FINAL FORM +FD23 ARABIC LIGATURE DAD WITH ALEF MAKSURA FINAL FORM +FD24 ARABIC LIGATURE DAD WITH YEH FINAL FORM +FD25 ARABIC LIGATURE SHEEN WITH JEEM FINAL FORM +FD26 ARABIC LIGATURE SHEEN WITH HAH FINAL FORM +FD27 ARABIC LIGATURE SHEEN WITH KHAH FINAL FORM +FD28 ARABIC LIGATURE SHEEN WITH MEEM FINAL FORM +FD29 ARABIC LIGATURE SHEEN WITH REH FINAL FORM +FD2A ARABIC LIGATURE SEEN WITH REH FINAL FORM +FD2B ARABIC LIGATURE SAD WITH REH FINAL FORM +FD2C ARABIC LIGATURE DAD WITH REH FINAL FORM +FD2D ARABIC LIGATURE SHEEN WITH JEEM INITIAL FORM +FD2E ARABIC LIGATURE SHEEN WITH HAH INITIAL FORM +FD2F ARABIC LIGATURE SHEEN WITH KHAH INITIAL FORM +FD30 ARABIC LIGATURE SHEEN WITH MEEM INITIAL FORM +FD31 ARABIC LIGATURE SEEN WITH HEH INITIAL FORM +FD32 ARABIC LIGATURE SHEEN WITH HEH INITIAL FORM +FD33 ARABIC LIGATURE TAH WITH MEEM INITIAL FORM +FD34 ARABIC LIGATURE SEEN WITH JEEM MEDIAL FORM +FD35 ARABIC LIGATURE SEEN WITH HAH MEDIAL FORM +FD36 ARABIC LIGATURE SEEN WITH KHAH MEDIAL FORM +FD37 ARABIC LIGATURE SHEEN WITH JEEM MEDIAL FORM +FD38 ARABIC LIGATURE SHEEN WITH HAH MEDIAL FORM +FD39 ARABIC LIGATURE SHEEN WITH KHAH MEDIAL FORM +FD3A ARABIC LIGATURE TAH WITH MEEM MEDIAL FORM +FD3B ARABIC LIGATURE ZAH WITH MEEM MEDIAL FORM +FD3C ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM +FD3D ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM +FD3E ORNATE LEFT PARENTHESIS +FD3F ORNATE RIGHT PARENTHESIS +FD50 ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM +FD51 ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM +FD52 ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM +FD53 ARABIC LIGATURE TEH WITH HAH WITH MEEM INITIAL FORM +FD54 ARABIC LIGATURE TEH WITH KHAH WITH MEEM INITIAL FORM +FD55 ARABIC LIGATURE TEH WITH MEEM WITH JEEM INITIAL FORM +FD56 ARABIC LIGATURE TEH WITH MEEM WITH HAH INITIAL FORM +FD57 ARABIC LIGATURE TEH WITH MEEM WITH KHAH INITIAL FORM +FD58 ARABIC LIGATURE JEEM WITH MEEM WITH HAH FINAL FORM +FD59 ARABIC LIGATURE JEEM WITH MEEM WITH HAH INITIAL FORM +FD5A ARABIC LIGATURE HAH WITH MEEM WITH YEH FINAL FORM +FD5B ARABIC LIGATURE HAH WITH MEEM WITH ALEF MAKSURA FINAL FORM +FD5C ARABIC LIGATURE SEEN WITH HAH WITH JEEM INITIAL FORM +FD5D ARABIC LIGATURE SEEN WITH JEEM WITH HAH INITIAL FORM +FD5E ARABIC LIGATURE SEEN WITH JEEM WITH ALEF MAKSURA FINAL FORM +FD5F ARABIC LIGATURE SEEN WITH MEEM WITH HAH FINAL FORM +FD60 ARABIC LIGATURE SEEN WITH MEEM WITH HAH INITIAL FORM +FD61 ARABIC LIGATURE SEEN WITH MEEM WITH JEEM INITIAL FORM +FD62 ARABIC LIGATURE SEEN WITH MEEM WITH MEEM FINAL FORM +FD63 ARABIC LIGATURE SEEN WITH MEEM WITH MEEM INITIAL FORM +FD64 ARABIC LIGATURE SAD WITH HAH WITH HAH FINAL FORM +FD65 ARABIC LIGATURE SAD WITH HAH WITH HAH INITIAL FORM +FD66 ARABIC LIGATURE SAD WITH MEEM WITH MEEM FINAL FORM +FD67 ARABIC LIGATURE SHEEN WITH HAH WITH MEEM FINAL FORM +FD68 ARABIC LIGATURE SHEEN WITH HAH WITH MEEM INITIAL FORM +FD69 ARABIC LIGATURE SHEEN WITH JEEM WITH YEH FINAL FORM +FD6A ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH FINAL FORM +FD6B ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH INITIAL FORM +FD6C ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM FINAL FORM +FD6D ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM INITIAL FORM +FD6E ARABIC LIGATURE DAD WITH HAH WITH ALEF MAKSURA FINAL FORM +FD6F ARABIC LIGATURE DAD WITH KHAH WITH MEEM FINAL FORM +FD70 ARABIC LIGATURE DAD WITH KHAH WITH MEEM INITIAL FORM +FD71 ARABIC LIGATURE TAH WITH MEEM WITH HAH FINAL FORM +FD72 ARABIC LIGATURE TAH WITH MEEM WITH HAH INITIAL FORM +FD73 ARABIC LIGATURE TAH WITH MEEM WITH MEEM INITIAL FORM +FD74 ARABIC LIGATURE TAH WITH MEEM WITH YEH FINAL FORM +FD75 ARABIC LIGATURE AIN WITH JEEM WITH MEEM FINAL FORM +FD76 ARABIC LIGATURE AIN WITH MEEM WITH MEEM FINAL FORM +FD77 ARABIC LIGATURE AIN WITH MEEM WITH MEEM INITIAL FORM +FD78 ARABIC LIGATURE AIN WITH MEEM WITH ALEF MAKSURA FINAL FORM +FD79 ARABIC LIGATURE GHAIN WITH MEEM WITH MEEM FINAL FORM +FD7A ARABIC LIGATURE GHAIN WITH MEEM WITH YEH FINAL FORM +FD7B ARABIC LIGATURE GHAIN WITH MEEM WITH ALEF MAKSURA FINAL FORM +FD7C ARABIC LIGATURE FEH WITH KHAH WITH MEEM FINAL FORM +FD7D ARABIC LIGATURE FEH WITH KHAH WITH MEEM INITIAL FORM +FD7E ARABIC LIGATURE QAF WITH MEEM WITH HAH FINAL FORM +FD7F ARABIC LIGATURE QAF WITH MEEM WITH MEEM FINAL FORM +FD80 ARABIC LIGATURE LAM WITH HAH WITH MEEM FINAL FORM +FD81 ARABIC LIGATURE LAM WITH HAH WITH YEH FINAL FORM +FD82 ARABIC LIGATURE LAM WITH HAH WITH ALEF MAKSURA FINAL FORM +FD83 ARABIC LIGATURE LAM WITH JEEM WITH JEEM INITIAL FORM +FD84 ARABIC LIGATURE LAM WITH JEEM WITH JEEM FINAL FORM +FD85 ARABIC LIGATURE LAM WITH KHAH WITH MEEM FINAL FORM +FD86 ARABIC LIGATURE LAM WITH KHAH WITH MEEM INITIAL FORM +FD87 ARABIC LIGATURE LAM WITH MEEM WITH HAH FINAL FORM +FD88 ARABIC LIGATURE LAM WITH MEEM WITH HAH INITIAL FORM +FD89 ARABIC LIGATURE MEEM WITH HAH WITH JEEM INITIAL FORM +FD8A ARABIC LIGATURE MEEM WITH HAH WITH MEEM INITIAL FORM +FD8B ARABIC LIGATURE MEEM WITH HAH WITH YEH FINAL FORM +FD8C ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM +FD8D ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM +FD8E ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM +FD8F ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM +FD92 ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM +FD93 ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM +FD94 ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM +FD95 ARABIC LIGATURE NOON WITH HAH WITH MEEM INITIAL FORM +FD96 ARABIC LIGATURE NOON WITH HAH WITH ALEF MAKSURA FINAL FORM +FD97 ARABIC LIGATURE NOON WITH JEEM WITH MEEM FINAL FORM +FD98 ARABIC LIGATURE NOON WITH JEEM WITH MEEM INITIAL FORM +FD99 ARABIC LIGATURE NOON WITH JEEM WITH ALEF MAKSURA FINAL FORM +FD9A ARABIC LIGATURE NOON WITH MEEM WITH YEH FINAL FORM +FD9B ARABIC LIGATURE NOON WITH MEEM WITH ALEF MAKSURA FINAL FORM +FD9C ARABIC LIGATURE YEH WITH MEEM WITH MEEM FINAL FORM +FD9D ARABIC LIGATURE YEH WITH MEEM WITH MEEM INITIAL FORM +FD9E ARABIC LIGATURE BEH WITH KHAH WITH YEH FINAL FORM +FD9F ARABIC LIGATURE TEH WITH JEEM WITH YEH FINAL FORM +FDA0 ARABIC LIGATURE TEH WITH JEEM WITH ALEF MAKSURA FINAL FORM +FDA1 ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM +FDA2 ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM +FDA3 ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM +FDA4 ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM +FDA5 ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM +FDA6 ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM +FDA7 ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM +FDA8 ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM +FDA9 ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM +FDAA ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM +FDAB ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM +FDAC ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM +FDAD ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM +FDAE ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM +FDAF ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM +FDB0 ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM +FDB1 ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM +FDB2 ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM +FDB3 ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM +FDB4 ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM +FDB5 ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM +FDB6 ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM +FDB7 ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM +FDB8 ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM +FDB9 ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM +FDBA ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM +FDBB ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM +FDBC ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM +FDBD ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM +FDBE ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM +FDBF ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM +FDC0 ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM +FDC1 ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM +FDC2 ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM +FDC3 ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM +FDC4 ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM +FDC5 ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM +FDC6 ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM +FDC7 ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM +FDF0 ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM +FDF1 ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM +FDF2 ARABIC LIGATURE ALLAH ISOLATED FORM +FDF3 ARABIC LIGATURE AKBAR ISOLATED FORM +FDF4 ARABIC LIGATURE MOHAMMAD ISOLATED FORM +FDF5 ARABIC LIGATURE SALAM ISOLATED FORM +FDF6 ARABIC LIGATURE RASOUL ISOLATED FORM +FDF7 ARABIC LIGATURE ALAYHE ISOLATED FORM +FDF8 ARABIC LIGATURE WASALLAM ISOLATED FORM +FDF9 ARABIC LIGATURE SALLA ISOLATED FORM +FDFA ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM +FDFB ARABIC LIGATURE JALLAJALALOUHOU +FDFC RIAL SIGN +FE00 VARIATION SELECTOR-1 +FE01 VARIATION SELECTOR-2 +FE02 VARIATION SELECTOR-3 +FE03 VARIATION SELECTOR-4 +FE04 VARIATION SELECTOR-5 +FE05 VARIATION SELECTOR-6 +FE06 VARIATION SELECTOR-7 +FE07 VARIATION SELECTOR-8 +FE08 VARIATION SELECTOR-9 +FE09 VARIATION SELECTOR-10 +FE0A VARIATION SELECTOR-11 +FE0B VARIATION SELECTOR-12 +FE0C VARIATION SELECTOR-13 +FE0D VARIATION SELECTOR-14 +FE0E VARIATION SELECTOR-15 +FE0F VARIATION SELECTOR-16 +FE20 COMBINING LIGATURE LEFT HALF +FE21 COMBINING LIGATURE RIGHT HALF +FE22 COMBINING DOUBLE TILDE LEFT HALF +FE23 COMBINING DOUBLE TILDE RIGHT HALF +FE30 PRESENTATION FORM FOR VERTICAL TWO DOT LEADER +FE31 PRESENTATION FORM FOR VERTICAL EM DASH +FE32 PRESENTATION FORM FOR VERTICAL EN DASH +FE33 PRESENTATION FORM FOR VERTICAL LOW LINE +FE34 PRESENTATION FORM FOR VERTICAL WAVY LOW LINE +FE35 PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS +FE36 PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS +FE37 PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET +FE38 PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET +FE39 PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET +FE3A PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET +FE3B PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET +FE3C PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET +FE3D PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET +FE3E PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET +FE3F PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET +FE40 PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET +FE41 PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET +FE42 PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET +FE43 PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET +FE44 PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET +FE45 SESAME DOT +FE46 WHITE SESAME DOT +FE49 DASHED OVERLINE +FE4A CENTRELINE OVERLINE +FE4B WAVY OVERLINE +FE4C DOUBLE WAVY OVERLINE +FE4D DASHED LOW LINE +FE4E CENTRELINE LOW LINE +FE4F WAVY LOW LINE +FE50 SMALL COMMA +FE51 SMALL IDEOGRAPHIC COMMA +FE52 SMALL FULL STOP +FE54 SMALL SEMICOLON +FE55 SMALL COLON +FE56 SMALL QUESTION MARK +FE57 SMALL EXCLAMATION MARK +FE58 SMALL EM DASH +FE59 SMALL LEFT PARENTHESIS +FE5A SMALL RIGHT PARENTHESIS +FE5B SMALL LEFT CURLY BRACKET +FE5C SMALL RIGHT CURLY BRACKET +FE5D SMALL LEFT TORTOISE SHELL BRACKET +FE5E SMALL RIGHT TORTOISE SHELL BRACKET +FE5F SMALL NUMBER SIGN +FE60 SMALL AMPERSAND +FE61 SMALL ASTERISK +FE62 SMALL PLUS SIGN +FE63 SMALL HYPHEN-MINUS +FE64 SMALL LESS-THAN SIGN +FE65 SMALL GREATER-THAN SIGN +FE66 SMALL EQUALS SIGN +FE68 SMALL REVERSE SOLIDUS +FE69 SMALL DOLLAR SIGN +FE6A SMALL PERCENT SIGN +FE6B SMALL COMMERCIAL AT +FE70 ARABIC FATHATAN ISOLATED FORM +FE71 ARABIC TATWEEL WITH FATHATAN ABOVE +FE72 ARABIC DAMMATAN ISOLATED FORM +FE73 ARABIC TAIL FRAGMENT +FE74 ARABIC KASRATAN ISOLATED FORM +FE76 ARABIC FATHA ISOLATED FORM +FE77 ARABIC FATHA MEDIAL FORM +FE78 ARABIC DAMMA ISOLATED FORM +FE79 ARABIC DAMMA MEDIAL FORM +FE7A ARABIC KASRA ISOLATED FORM +FE7B ARABIC KASRA MEDIAL FORM +FE7C ARABIC SHADDA ISOLATED FORM +FE7D ARABIC SHADDA MEDIAL FORM +FE7E ARABIC SUKUN ISOLATED FORM +FE7F ARABIC SUKUN MEDIAL FORM +FE80 ARABIC LETTER HAMZA ISOLATED FORM +FE81 ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM +FE82 ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM +FE83 ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM +FE84 ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM +FE85 ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM +FE86 ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM +FE87 ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM +FE88 ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM +FE89 ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM +FE8A ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM +FE8B ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM +FE8C ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM +FE8D ARABIC LETTER ALEF ISOLATED FORM +FE8E ARABIC LETTER ALEF FINAL FORM +FE8F ARABIC LETTER BEH ISOLATED FORM +FE90 ARABIC LETTER BEH FINAL FORM +FE91 ARABIC LETTER BEH INITIAL FORM +FE92 ARABIC LETTER BEH MEDIAL FORM +FE93 ARABIC LETTER TEH MARBUTA ISOLATED FORM +FE94 ARABIC LETTER TEH MARBUTA FINAL FORM +FE95 ARABIC LETTER TEH ISOLATED FORM +FE96 ARABIC LETTER TEH FINAL FORM +FE97 ARABIC LETTER TEH INITIAL FORM +FE98 ARABIC LETTER TEH MEDIAL FORM +FE99 ARABIC LETTER THEH ISOLATED FORM +FE9A ARABIC LETTER THEH FINAL FORM +FE9B ARABIC LETTER THEH INITIAL FORM +FE9C ARABIC LETTER THEH MEDIAL FORM +FE9D ARABIC LETTER JEEM ISOLATED FORM +FE9E ARABIC LETTER JEEM FINAL FORM +FE9F ARABIC LETTER JEEM INITIAL FORM +FEA0 ARABIC LETTER JEEM MEDIAL FORM +FEA1 ARABIC LETTER HAH ISOLATED FORM +FEA2 ARABIC LETTER HAH FINAL FORM +FEA3 ARABIC LETTER HAH INITIAL FORM +FEA4 ARABIC LETTER HAH MEDIAL FORM +FEA5 ARABIC LETTER KHAH ISOLATED FORM +FEA6 ARABIC LETTER KHAH FINAL FORM +FEA7 ARABIC LETTER KHAH INITIAL FORM +FEA8 ARABIC LETTER KHAH MEDIAL FORM +FEA9 ARABIC LETTER DAL ISOLATED FORM +FEAA ARABIC LETTER DAL FINAL FORM +FEAB ARABIC LETTER THAL ISOLATED FORM +FEAC ARABIC LETTER THAL FINAL FORM +FEAD ARABIC LETTER REH ISOLATED FORM +FEAE ARABIC LETTER REH FINAL FORM +FEAF ARABIC LETTER ZAIN ISOLATED FORM +FEB0 ARABIC LETTER ZAIN FINAL FORM +FEB1 ARABIC LETTER SEEN ISOLATED FORM +FEB2 ARABIC LETTER SEEN FINAL FORM +FEB3 ARABIC LETTER SEEN INITIAL FORM +FEB4 ARABIC LETTER SEEN MEDIAL FORM +FEB5 ARABIC LETTER SHEEN ISOLATED FORM +FEB6 ARABIC LETTER SHEEN FINAL FORM +FEB7 ARABIC LETTER SHEEN INITIAL FORM +FEB8 ARABIC LETTER SHEEN MEDIAL FORM +FEB9 ARABIC LETTER SAD ISOLATED FORM +FEBA ARABIC LETTER SAD FINAL FORM +FEBB ARABIC LETTER SAD INITIAL FORM +FEBC ARABIC LETTER SAD MEDIAL FORM +FEBD ARABIC LETTER DAD ISOLATED FORM +FEBE ARABIC LETTER DAD FINAL FORM +FEBF ARABIC LETTER DAD INITIAL FORM +FEC0 ARABIC LETTER DAD MEDIAL FORM +FEC1 ARABIC LETTER TAH ISOLATED FORM +FEC2 ARABIC LETTER TAH FINAL FORM +FEC3 ARABIC LETTER TAH INITIAL FORM +FEC4 ARABIC LETTER TAH MEDIAL FORM +FEC5 ARABIC LETTER ZAH ISOLATED FORM +FEC6 ARABIC LETTER ZAH FINAL FORM +FEC7 ARABIC LETTER ZAH INITIAL FORM +FEC8 ARABIC LETTER ZAH MEDIAL FORM +FEC9 ARABIC LETTER AIN ISOLATED FORM +FECA ARABIC LETTER AIN FINAL FORM +FECB ARABIC LETTER AIN INITIAL FORM +FECC ARABIC LETTER AIN MEDIAL FORM +FECD ARABIC LETTER GHAIN ISOLATED FORM +FECE ARABIC LETTER GHAIN FINAL FORM +FECF ARABIC LETTER GHAIN INITIAL FORM +FED0 ARABIC LETTER GHAIN MEDIAL FORM +FED1 ARABIC LETTER FEH ISOLATED FORM +FED2 ARABIC LETTER FEH FINAL FORM +FED3 ARABIC LETTER FEH INITIAL FORM +FED4 ARABIC LETTER FEH MEDIAL FORM +FED5 ARABIC LETTER QAF ISOLATED FORM +FED6 ARABIC LETTER QAF FINAL FORM +FED7 ARABIC LETTER QAF INITIAL FORM +FED8 ARABIC LETTER QAF MEDIAL FORM +FED9 ARABIC LETTER KAF ISOLATED FORM +FEDA ARABIC LETTER KAF FINAL FORM +FEDB ARABIC LETTER KAF INITIAL FORM +FEDC ARABIC LETTER KAF MEDIAL FORM +FEDD ARABIC LETTER LAM ISOLATED FORM +FEDE ARABIC LETTER LAM FINAL FORM +FEDF ARABIC LETTER LAM INITIAL FORM +FEE0 ARABIC LETTER LAM MEDIAL FORM +FEE1 ARABIC LETTER MEEM ISOLATED FORM +FEE2 ARABIC LETTER MEEM FINAL FORM +FEE3 ARABIC LETTER MEEM INITIAL FORM +FEE4 ARABIC LETTER MEEM MEDIAL FORM +FEE5 ARABIC LETTER NOON ISOLATED FORM +FEE6 ARABIC LETTER NOON FINAL FORM +FEE7 ARABIC LETTER NOON INITIAL FORM +FEE8 ARABIC LETTER NOON MEDIAL FORM +FEE9 ARABIC LETTER HEH ISOLATED FORM +FEEA ARABIC LETTER HEH FINAL FORM +FEEB ARABIC LETTER HEH INITIAL FORM +FEEC ARABIC LETTER HEH MEDIAL FORM +FEED ARABIC LETTER WAW ISOLATED FORM +FEEE ARABIC LETTER WAW FINAL FORM +FEEF ARABIC LETTER ALEF MAKSURA ISOLATED FORM +FEF0 ARABIC LETTER ALEF MAKSURA FINAL FORM +FEF1 ARABIC LETTER YEH ISOLATED FORM +FEF2 ARABIC LETTER YEH FINAL FORM +FEF3 ARABIC LETTER YEH INITIAL FORM +FEF4 ARABIC LETTER YEH MEDIAL FORM +FEF5 ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM +FEF6 ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM +FEF7 ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM +FEF8 ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM +FEF9 ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM +FEFA ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM +FEFB ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM +FEFC ARABIC LIGATURE LAM WITH ALEF FINAL FORM +FEFF ZERO WIDTH NO-BREAK SPACE +FF01 FULLWIDTH EXCLAMATION MARK +FF02 FULLWIDTH QUOTATION MARK +FF03 FULLWIDTH NUMBER SIGN +FF04 FULLWIDTH DOLLAR SIGN +FF05 FULLWIDTH PERCENT SIGN +FF06 FULLWIDTH AMPERSAND +FF07 FULLWIDTH APOSTROPHE +FF08 FULLWIDTH LEFT PARENTHESIS +FF09 FULLWIDTH RIGHT PARENTHESIS +FF0A FULLWIDTH ASTERISK +FF0B FULLWIDTH PLUS SIGN +FF0C FULLWIDTH COMMA +FF0D FULLWIDTH HYPHEN-MINUS +FF0E FULLWIDTH FULL STOP +FF0F FULLWIDTH SOLIDUS +FF10 FULLWIDTH DIGIT ZERO +FF11 FULLWIDTH DIGIT ONE +FF12 FULLWIDTH DIGIT TWO +FF13 FULLWIDTH DIGIT THREE +FF14 FULLWIDTH DIGIT FOUR +FF15 FULLWIDTH DIGIT FIVE +FF16 FULLWIDTH DIGIT SIX +FF17 FULLWIDTH DIGIT SEVEN +FF18 FULLWIDTH DIGIT EIGHT +FF19 FULLWIDTH DIGIT NINE +FF1A FULLWIDTH COLON +FF1B FULLWIDTH SEMICOLON +FF1C FULLWIDTH LESS-THAN SIGN +FF1D FULLWIDTH EQUALS SIGN +FF1E FULLWIDTH GREATER-THAN SIGN +FF1F FULLWIDTH QUESTION MARK +FF20 FULLWIDTH COMMERCIAL AT +FF21 FULLWIDTH LATIN CAPITAL LETTER A +FF22 FULLWIDTH LATIN CAPITAL LETTER B +FF23 FULLWIDTH LATIN CAPITAL LETTER C +FF24 FULLWIDTH LATIN CAPITAL LETTER D +FF25 FULLWIDTH LATIN CAPITAL LETTER E +FF26 FULLWIDTH LATIN CAPITAL LETTER F +FF27 FULLWIDTH LATIN CAPITAL LETTER G +FF28 FULLWIDTH LATIN CAPITAL LETTER H +FF29 FULLWIDTH LATIN CAPITAL LETTER I +FF2A FULLWIDTH LATIN CAPITAL LETTER J +FF2B FULLWIDTH LATIN CAPITAL LETTER K +FF2C FULLWIDTH LATIN CAPITAL LETTER L +FF2D FULLWIDTH LATIN CAPITAL LETTER M +FF2E FULLWIDTH LATIN CAPITAL LETTER N +FF2F FULLWIDTH LATIN CAPITAL LETTER O +FF30 FULLWIDTH LATIN CAPITAL LETTER P +FF31 FULLWIDTH LATIN CAPITAL LETTER Q +FF32 FULLWIDTH LATIN CAPITAL LETTER R +FF33 FULLWIDTH LATIN CAPITAL LETTER S +FF34 FULLWIDTH LATIN CAPITAL LETTER T +FF35 FULLWIDTH LATIN CAPITAL LETTER U +FF36 FULLWIDTH LATIN CAPITAL LETTER V +FF37 FULLWIDTH LATIN CAPITAL LETTER W +FF38 FULLWIDTH LATIN CAPITAL LETTER X +FF39 FULLWIDTH LATIN CAPITAL LETTER Y +FF3A FULLWIDTH LATIN CAPITAL LETTER Z +FF3B FULLWIDTH LEFT SQUARE BRACKET +FF3C FULLWIDTH REVERSE SOLIDUS +FF3D FULLWIDTH RIGHT SQUARE BRACKET +FF3E FULLWIDTH CIRCUMFLEX ACCENT +FF3F FULLWIDTH LOW LINE +FF40 FULLWIDTH GRAVE ACCENT +FF41 FULLWIDTH LATIN SMALL LETTER A +FF42 FULLWIDTH LATIN SMALL LETTER B +FF43 FULLWIDTH LATIN SMALL LETTER C +FF44 FULLWIDTH LATIN SMALL LETTER D +FF45 FULLWIDTH LATIN SMALL LETTER E +FF46 FULLWIDTH LATIN SMALL LETTER F +FF47 FULLWIDTH LATIN SMALL LETTER G +FF48 FULLWIDTH LATIN SMALL LETTER H +FF49 FULLWIDTH LATIN SMALL LETTER I +FF4A FULLWIDTH LATIN SMALL LETTER J +FF4B FULLWIDTH LATIN SMALL LETTER K +FF4C FULLWIDTH LATIN SMALL LETTER L +FF4D FULLWIDTH LATIN SMALL LETTER M +FF4E FULLWIDTH LATIN SMALL LETTER N +FF4F FULLWIDTH LATIN SMALL LETTER O +FF50 FULLWIDTH LATIN SMALL LETTER P +FF51 FULLWIDTH LATIN SMALL LETTER Q +FF52 FULLWIDTH LATIN SMALL LETTER R +FF53 FULLWIDTH LATIN SMALL LETTER S +FF54 FULLWIDTH LATIN SMALL LETTER T +FF55 FULLWIDTH LATIN SMALL LETTER U +FF56 FULLWIDTH LATIN SMALL LETTER V +FF57 FULLWIDTH LATIN SMALL LETTER W +FF58 FULLWIDTH LATIN SMALL LETTER X +FF59 FULLWIDTH LATIN SMALL LETTER Y +FF5A FULLWIDTH LATIN SMALL LETTER Z +FF5B FULLWIDTH LEFT CURLY BRACKET +FF5C FULLWIDTH VERTICAL LINE +FF5D FULLWIDTH RIGHT CURLY BRACKET +FF5E FULLWIDTH TILDE +FF5F FULLWIDTH LEFT WHITE PARENTHESIS +FF60 FULLWIDTH RIGHT WHITE PARENTHESIS +FF61 HALFWIDTH IDEOGRAPHIC FULL STOP +FF62 HALFWIDTH LEFT CORNER BRACKET +FF63 HALFWIDTH RIGHT CORNER BRACKET +FF64 HALFWIDTH IDEOGRAPHIC COMMA +FF65 HALFWIDTH KATAKANA MIDDLE DOT +FF66 HALFWIDTH KATAKANA LETTER WO +FF67 HALFWIDTH KATAKANA LETTER SMALL A +FF68 HALFWIDTH KATAKANA LETTER SMALL I +FF69 HALFWIDTH KATAKANA LETTER SMALL U +FF6A HALFWIDTH KATAKANA LETTER SMALL E +FF6B HALFWIDTH KATAKANA LETTER SMALL O +FF6C HALFWIDTH KATAKANA LETTER SMALL YA +FF6D HALFWIDTH KATAKANA LETTER SMALL YU +FF6E HALFWIDTH KATAKANA LETTER SMALL YO +FF6F HALFWIDTH KATAKANA LETTER SMALL TU +FF70 HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK +FF71 HALFWIDTH KATAKANA LETTER A +FF72 HALFWIDTH KATAKANA LETTER I +FF73 HALFWIDTH KATAKANA LETTER U +FF74 HALFWIDTH KATAKANA LETTER E +FF75 HALFWIDTH KATAKANA LETTER O +FF76 HALFWIDTH KATAKANA LETTER KA +FF77 HALFWIDTH KATAKANA LETTER KI +FF78 HALFWIDTH KATAKANA LETTER KU +FF79 HALFWIDTH KATAKANA LETTER KE +FF7A HALFWIDTH KATAKANA LETTER KO +FF7B HALFWIDTH KATAKANA LETTER SA +FF7C HALFWIDTH KATAKANA LETTER SI +FF7D HALFWIDTH KATAKANA LETTER SU +FF7E HALFWIDTH KATAKANA LETTER SE +FF7F HALFWIDTH KATAKANA LETTER SO +FF80 HALFWIDTH KATAKANA LETTER TA +FF81 HALFWIDTH KATAKANA LETTER TI +FF82 HALFWIDTH KATAKANA LETTER TU +FF83 HALFWIDTH KATAKANA LETTER TE +FF84 HALFWIDTH KATAKANA LETTER TO +FF85 HALFWIDTH KATAKANA LETTER NA +FF86 HALFWIDTH KATAKANA LETTER NI +FF87 HALFWIDTH KATAKANA LETTER NU +FF88 HALFWIDTH KATAKANA LETTER NE +FF89 HALFWIDTH KATAKANA LETTER NO +FF8A HALFWIDTH KATAKANA LETTER HA +FF8B HALFWIDTH KATAKANA LETTER HI +FF8C HALFWIDTH KATAKANA LETTER HU +FF8D HALFWIDTH KATAKANA LETTER HE +FF8E HALFWIDTH KATAKANA LETTER HO +FF8F HALFWIDTH KATAKANA LETTER MA +FF90 HALFWIDTH KATAKANA LETTER MI +FF91 HALFWIDTH KATAKANA LETTER MU +FF92 HALFWIDTH KATAKANA LETTER ME +FF93 HALFWIDTH KATAKANA LETTER MO +FF94 HALFWIDTH KATAKANA LETTER YA +FF95 HALFWIDTH KATAKANA LETTER YU +FF96 HALFWIDTH KATAKANA LETTER YO +FF97 HALFWIDTH KATAKANA LETTER RA +FF98 HALFWIDTH KATAKANA LETTER RI +FF99 HALFWIDTH KATAKANA LETTER RU +FF9A HALFWIDTH KATAKANA LETTER RE +FF9B HALFWIDTH KATAKANA LETTER RO +FF9C HALFWIDTH KATAKANA LETTER WA +FF9D HALFWIDTH KATAKANA LETTER N +FF9E HALFWIDTH KATAKANA VOICED SOUND MARK +FF9F HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK +FFA0 HALFWIDTH HANGUL FILLER +FFA1 HALFWIDTH HANGUL LETTER KIYEOK +FFA2 HALFWIDTH HANGUL LETTER SSANGKIYEOK +FFA3 HALFWIDTH HANGUL LETTER KIYEOK-SIOS +FFA4 HALFWIDTH HANGUL LETTER NIEUN +FFA5 HALFWIDTH HANGUL LETTER NIEUN-CIEUC +FFA6 HALFWIDTH HANGUL LETTER NIEUN-HIEUH +FFA7 HALFWIDTH HANGUL LETTER TIKEUT +FFA8 HALFWIDTH HANGUL LETTER SSANGTIKEUT +FFA9 HALFWIDTH HANGUL LETTER RIEUL +FFAA HALFWIDTH HANGUL LETTER RIEUL-KIYEOK +FFAB HALFWIDTH HANGUL LETTER RIEUL-MIEUM +FFAC HALFWIDTH HANGUL LETTER RIEUL-PIEUP +FFAD HALFWIDTH HANGUL LETTER RIEUL-SIOS +FFAE HALFWIDTH HANGUL LETTER RIEUL-THIEUTH +FFAF HALFWIDTH HANGUL LETTER RIEUL-PHIEUPH +FFB0 HALFWIDTH HANGUL LETTER RIEUL-HIEUH +FFB1 HALFWIDTH HANGUL LETTER MIEUM +FFB2 HALFWIDTH HANGUL LETTER PIEUP +FFB3 HALFWIDTH HANGUL LETTER SSANGPIEUP +FFB4 HALFWIDTH HANGUL LETTER PIEUP-SIOS +FFB5 HALFWIDTH HANGUL LETTER SIOS +FFB6 HALFWIDTH HANGUL LETTER SSANGSIOS +FFB7 HALFWIDTH HANGUL LETTER IEUNG +FFB8 HALFWIDTH HANGUL LETTER CIEUC +FFB9 HALFWIDTH HANGUL LETTER SSANGCIEUC +FFBA HALFWIDTH HANGUL LETTER CHIEUCH +FFBB HALFWIDTH HANGUL LETTER KHIEUKH +FFBC HALFWIDTH HANGUL LETTER THIEUTH +FFBD HALFWIDTH HANGUL LETTER PHIEUPH +FFBE HALFWIDTH HANGUL LETTER HIEUH +FFC2 HALFWIDTH HANGUL LETTER A +FFC3 HALFWIDTH HANGUL LETTER AE +FFC4 HALFWIDTH HANGUL LETTER YA +FFC5 HALFWIDTH HANGUL LETTER YAE +FFC6 HALFWIDTH HANGUL LETTER EO +FFC7 HALFWIDTH HANGUL LETTER E +FFCA HALFWIDTH HANGUL LETTER YEO +FFCB HALFWIDTH HANGUL LETTER YE +FFCC HALFWIDTH HANGUL LETTER O +FFCD HALFWIDTH HANGUL LETTER WA +FFCE HALFWIDTH HANGUL LETTER WAE +FFCF HALFWIDTH HANGUL LETTER OE +FFD2 HALFWIDTH HANGUL LETTER YO +FFD3 HALFWIDTH HANGUL LETTER U +FFD4 HALFWIDTH HANGUL LETTER WEO +FFD5 HALFWIDTH HANGUL LETTER WE +FFD6 HALFWIDTH HANGUL LETTER WI +FFD7 HALFWIDTH HANGUL LETTER YU +FFDA HALFWIDTH HANGUL LETTER EU +FFDB HALFWIDTH HANGUL LETTER YI +FFDC HALFWIDTH HANGUL LETTER I +FFE0 FULLWIDTH CENT SIGN +FFE1 FULLWIDTH POUND SIGN +FFE2 FULLWIDTH NOT SIGN +FFE3 FULLWIDTH MACRON +FFE4 FULLWIDTH BROKEN BAR +FFE5 FULLWIDTH YEN SIGN +FFE6 FULLWIDTH WON SIGN +FFE8 HALFWIDTH FORMS LIGHT VERTICAL +FFE9 HALFWIDTH LEFTWARDS ARROW +FFEA HALFWIDTH UPWARDS ARROW +FFEB HALFWIDTH RIGHTWARDS ARROW +FFEC HALFWIDTH DOWNWARDS ARROW +FFED HALFWIDTH BLACK SQUARE +FFEE HALFWIDTH WHITE CIRCLE +FFF9 INTERLINEAR ANNOTATION ANCHOR +FFFA INTERLINEAR ANNOTATION SEPARATOR +FFFB INTERLINEAR ANNOTATION TERMINATOR +FFFC OBJECT REPLACEMENT CHARACTER +FFFD REPLACEMENT CHARACTER +10300 OLD ITALIC LETTER A +10301 OLD ITALIC LETTER BE +10302 OLD ITALIC LETTER KE +10303 OLD ITALIC LETTER DE +10304 OLD ITALIC LETTER E +10305 OLD ITALIC LETTER VE +10306 OLD ITALIC LETTER ZE +10307 OLD ITALIC LETTER HE +10308 OLD ITALIC LETTER THE +10309 OLD ITALIC LETTER I +1030A OLD ITALIC LETTER KA +1030B OLD ITALIC LETTER EL +1030C OLD ITALIC LETTER EM +1030D OLD ITALIC LETTER EN +1030E OLD ITALIC LETTER ESH +1030F OLD ITALIC LETTER O +10310 OLD ITALIC LETTER PE +10311 OLD ITALIC LETTER SHE +10312 OLD ITALIC LETTER KU +10313 OLD ITALIC LETTER ER +10314 OLD ITALIC LETTER ES +10315 OLD ITALIC LETTER TE +10316 OLD ITALIC LETTER U +10317 OLD ITALIC LETTER EKS +10318 OLD ITALIC LETTER PHE +10319 OLD ITALIC LETTER KHE +1031A OLD ITALIC LETTER EF +1031B OLD ITALIC LETTER ERS +1031C OLD ITALIC LETTER CHE +1031D OLD ITALIC LETTER II +1031E OLD ITALIC LETTER UU +10320 OLD ITALIC NUMERAL ONE +10321 OLD ITALIC NUMERAL FIVE +10322 OLD ITALIC NUMERAL TEN +10323 OLD ITALIC NUMERAL FIFTY +10330 GOTHIC LETTER AHSA +10331 GOTHIC LETTER BAIRKAN +10332 GOTHIC LETTER GIBA +10333 GOTHIC LETTER DAGS +10334 GOTHIC LETTER AIHVUS +10335 GOTHIC LETTER QAIRTHRA +10336 GOTHIC LETTER IUJA +10337 GOTHIC LETTER HAGL +10338 GOTHIC LETTER THIUTH +10339 GOTHIC LETTER EIS +1033A GOTHIC LETTER KUSMA +1033B GOTHIC LETTER LAGUS +1033C GOTHIC LETTER MANNA +1033D GOTHIC LETTER NAUTHS +1033E GOTHIC LETTER JER +1033F GOTHIC LETTER URUS +10340 GOTHIC LETTER PAIRTHRA +10341 GOTHIC LETTER NINETY +10342 GOTHIC LETTER RAIDA +10343 GOTHIC LETTER SAUIL +10344 GOTHIC LETTER TEIWS +10345 GOTHIC LETTER WINJA +10346 GOTHIC LETTER FAIHU +10347 GOTHIC LETTER IGGWS +10348 GOTHIC LETTER HWAIR +10349 GOTHIC LETTER OTHAL +1034A GOTHIC LETTER NINE HUNDRED +10400 DESERET CAPITAL LETTER LONG I +10401 DESERET CAPITAL LETTER LONG E +10402 DESERET CAPITAL LETTER LONG A +10403 DESERET CAPITAL LETTER LONG AH +10404 DESERET CAPITAL LETTER LONG O +10405 DESERET CAPITAL LETTER LONG OO +10406 DESERET CAPITAL LETTER SHORT I +10407 DESERET CAPITAL LETTER SHORT E +10408 DESERET CAPITAL LETTER SHORT A +10409 DESERET CAPITAL LETTER SHORT AH +1040A DESERET CAPITAL LETTER SHORT O +1040B DESERET CAPITAL LETTER SHORT OO +1040C DESERET CAPITAL LETTER AY +1040D DESERET CAPITAL LETTER OW +1040E DESERET CAPITAL LETTER WU +1040F DESERET CAPITAL LETTER YEE +10410 DESERET CAPITAL LETTER H +10411 DESERET CAPITAL LETTER PEE +10412 DESERET CAPITAL LETTER BEE +10413 DESERET CAPITAL LETTER TEE +10414 DESERET CAPITAL LETTER DEE +10415 DESERET CAPITAL LETTER CHEE +10416 DESERET CAPITAL LETTER JEE +10417 DESERET CAPITAL LETTER KAY +10418 DESERET CAPITAL LETTER GAY +10419 DESERET CAPITAL LETTER EF +1041A DESERET CAPITAL LETTER VEE +1041B DESERET CAPITAL LETTER ETH +1041C DESERET CAPITAL LETTER THEE +1041D DESERET CAPITAL LETTER ES +1041E DESERET CAPITAL LETTER ZEE +1041F DESERET CAPITAL LETTER ESH +10420 DESERET CAPITAL LETTER ZHEE +10421 DESERET CAPITAL LETTER ER +10422 DESERET CAPITAL LETTER EL +10423 DESERET CAPITAL LETTER EM +10424 DESERET CAPITAL LETTER EN +10425 DESERET CAPITAL LETTER ENG +10428 DESERET SMALL LETTER LONG I +10429 DESERET SMALL LETTER LONG E +1042A DESERET SMALL LETTER LONG A +1042B DESERET SMALL LETTER LONG AH +1042C DESERET SMALL LETTER LONG O +1042D DESERET SMALL LETTER LONG OO +1042E DESERET SMALL LETTER SHORT I +1042F DESERET SMALL LETTER SHORT E +10430 DESERET SMALL LETTER SHORT A +10431 DESERET SMALL LETTER SHORT AH +10432 DESERET SMALL LETTER SHORT O +10433 DESERET SMALL LETTER SHORT OO +10434 DESERET SMALL LETTER AY +10435 DESERET SMALL LETTER OW +10436 DESERET SMALL LETTER WU +10437 DESERET SMALL LETTER YEE +10438 DESERET SMALL LETTER H +10439 DESERET SMALL LETTER PEE +1043A DESERET SMALL LETTER BEE +1043B DESERET SMALL LETTER TEE +1043C DESERET SMALL LETTER DEE +1043D DESERET SMALL LETTER CHEE +1043E DESERET SMALL LETTER JEE +1043F DESERET SMALL LETTER KAY +10440 DESERET SMALL LETTER GAY +10441 DESERET SMALL LETTER EF +10442 DESERET SMALL LETTER VEE +10443 DESERET SMALL LETTER ETH +10444 DESERET SMALL LETTER THEE +10445 DESERET SMALL LETTER ES +10446 DESERET SMALL LETTER ZEE +10447 DESERET SMALL LETTER ESH +10448 DESERET SMALL LETTER ZHEE +10449 DESERET SMALL LETTER ER +1044A DESERET SMALL LETTER EL +1044B DESERET SMALL LETTER EM +1044C DESERET SMALL LETTER EN +1044D DESERET SMALL LETTER ENG +1D000 BYZANTINE MUSICAL SYMBOL PSILI +1D001 BYZANTINE MUSICAL SYMBOL DASEIA +1D002 BYZANTINE MUSICAL SYMBOL PERISPOMENI +1D003 BYZANTINE MUSICAL SYMBOL OXEIA EKFONITIKON +1D004 BYZANTINE MUSICAL SYMBOL OXEIA DIPLI +1D005 BYZANTINE MUSICAL SYMBOL VAREIA EKFONITIKON +1D006 BYZANTINE MUSICAL SYMBOL VAREIA DIPLI +1D007 BYZANTINE MUSICAL SYMBOL KATHISTI +1D008 BYZANTINE MUSICAL SYMBOL SYRMATIKI +1D009 BYZANTINE MUSICAL SYMBOL PARAKLITIKI +1D00A BYZANTINE MUSICAL SYMBOL YPOKRISIS +1D00B BYZANTINE MUSICAL SYMBOL YPOKRISIS DIPLI +1D00C BYZANTINE MUSICAL SYMBOL KREMASTI +1D00D BYZANTINE MUSICAL SYMBOL APESO EKFONITIKON +1D00E BYZANTINE MUSICAL SYMBOL EXO EKFONITIKON +1D00F BYZANTINE MUSICAL SYMBOL TELEIA +1D010 BYZANTINE MUSICAL SYMBOL KENTIMATA +1D011 BYZANTINE MUSICAL SYMBOL APOSTROFOS +1D012 BYZANTINE MUSICAL SYMBOL APOSTROFOS DIPLI +1D013 BYZANTINE MUSICAL SYMBOL SYNEVMA +1D014 BYZANTINE MUSICAL SYMBOL THITA +1D015 BYZANTINE MUSICAL SYMBOL OLIGON ARCHAION +1D016 BYZANTINE MUSICAL SYMBOL GORGON ARCHAION +1D017 BYZANTINE MUSICAL SYMBOL PSILON +1D018 BYZANTINE MUSICAL SYMBOL CHAMILON +1D019 BYZANTINE MUSICAL SYMBOL VATHY +1D01A BYZANTINE MUSICAL SYMBOL ISON ARCHAION +1D01B BYZANTINE MUSICAL SYMBOL KENTIMA ARCHAION +1D01C BYZANTINE MUSICAL SYMBOL KENTIMATA ARCHAION +1D01D BYZANTINE MUSICAL SYMBOL SAXIMATA +1D01E BYZANTINE MUSICAL SYMBOL PARICHON +1D01F BYZANTINE MUSICAL SYMBOL STAVROS APODEXIA +1D020 BYZANTINE MUSICAL SYMBOL OXEIAI ARCHAION +1D021 BYZANTINE MUSICAL SYMBOL VAREIAI ARCHAION +1D022 BYZANTINE MUSICAL SYMBOL APODERMA ARCHAION +1D023 BYZANTINE MUSICAL SYMBOL APOTHEMA +1D024 BYZANTINE MUSICAL SYMBOL KLASMA +1D025 BYZANTINE MUSICAL SYMBOL REVMA +1D026 BYZANTINE MUSICAL SYMBOL PIASMA ARCHAION +1D027 BYZANTINE MUSICAL SYMBOL TINAGMA +1D028 BYZANTINE MUSICAL SYMBOL ANATRICHISMA +1D029 BYZANTINE MUSICAL SYMBOL SEISMA +1D02A BYZANTINE MUSICAL SYMBOL SYNAGMA ARCHAION +1D02B BYZANTINE MUSICAL SYMBOL SYNAGMA META STAVROU +1D02C BYZANTINE MUSICAL SYMBOL OYRANISMA ARCHAION +1D02D BYZANTINE MUSICAL SYMBOL THEMA +1D02E BYZANTINE MUSICAL SYMBOL LEMOI +1D02F BYZANTINE MUSICAL SYMBOL DYO +1D030 BYZANTINE MUSICAL SYMBOL TRIA +1D031 BYZANTINE MUSICAL SYMBOL TESSERA +1D032 BYZANTINE MUSICAL SYMBOL KRATIMATA +1D033 BYZANTINE MUSICAL SYMBOL APESO EXO NEO +1D034 BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION +1D035 BYZANTINE MUSICAL SYMBOL IMIFTHORA +1D036 BYZANTINE MUSICAL SYMBOL TROMIKON ARCHAION +1D037 BYZANTINE MUSICAL SYMBOL KATAVA TROMIKON +1D038 BYZANTINE MUSICAL SYMBOL PELASTON +1D039 BYZANTINE MUSICAL SYMBOL PSIFISTON +1D03A BYZANTINE MUSICAL SYMBOL KONTEVMA +1D03B BYZANTINE MUSICAL SYMBOL CHOREVMA ARCHAION +1D03C BYZANTINE MUSICAL SYMBOL RAPISMA +1D03D BYZANTINE MUSICAL SYMBOL PARAKALESMA ARCHAION +1D03E BYZANTINE MUSICAL SYMBOL PARAKLITIKI ARCHAION +1D03F BYZANTINE MUSICAL SYMBOL ICHADIN +1D040 BYZANTINE MUSICAL SYMBOL NANA +1D041 BYZANTINE MUSICAL SYMBOL PETASMA +1D042 BYZANTINE MUSICAL SYMBOL KONTEVMA ALLO +1D043 BYZANTINE MUSICAL SYMBOL TROMIKON ALLO +1D044 BYZANTINE MUSICAL SYMBOL STRAGGISMATA +1D045 BYZANTINE MUSICAL SYMBOL GRONTHISMATA +1D046 BYZANTINE MUSICAL SYMBOL ISON NEO +1D047 BYZANTINE MUSICAL SYMBOL OLIGON NEO +1D048 BYZANTINE MUSICAL SYMBOL OXEIA NEO +1D049 BYZANTINE MUSICAL SYMBOL PETASTI +1D04A BYZANTINE MUSICAL SYMBOL KOUFISMA +1D04B BYZANTINE MUSICAL SYMBOL PETASTOKOUFISMA +1D04C BYZANTINE MUSICAL SYMBOL KRATIMOKOUFISMA +1D04D BYZANTINE MUSICAL SYMBOL PELASTON NEO +1D04E BYZANTINE MUSICAL SYMBOL KENTIMATA NEO ANO +1D04F BYZANTINE MUSICAL SYMBOL KENTIMA NEO ANO +1D050 BYZANTINE MUSICAL SYMBOL YPSILI +1D051 BYZANTINE MUSICAL SYMBOL APOSTROFOS NEO +1D052 BYZANTINE MUSICAL SYMBOL APOSTROFOI SYNDESMOS NEO +1D053 BYZANTINE MUSICAL SYMBOL YPORROI +1D054 BYZANTINE MUSICAL SYMBOL KRATIMOYPORROON +1D055 BYZANTINE MUSICAL SYMBOL ELAFRON +1D056 BYZANTINE MUSICAL SYMBOL CHAMILI +1D057 BYZANTINE MUSICAL SYMBOL MIKRON ISON +1D058 BYZANTINE MUSICAL SYMBOL VAREIA NEO +1D059 BYZANTINE MUSICAL SYMBOL PIASMA NEO +1D05A BYZANTINE MUSICAL SYMBOL PSIFISTON NEO +1D05B BYZANTINE MUSICAL SYMBOL OMALON +1D05C BYZANTINE MUSICAL SYMBOL ANTIKENOMA +1D05D BYZANTINE MUSICAL SYMBOL LYGISMA +1D05E BYZANTINE MUSICAL SYMBOL PARAKLITIKI NEO +1D05F BYZANTINE MUSICAL SYMBOL PARAKALESMA NEO +1D060 BYZANTINE MUSICAL SYMBOL ETERON PARAKALESMA +1D061 BYZANTINE MUSICAL SYMBOL KYLISMA +1D062 BYZANTINE MUSICAL SYMBOL ANTIKENOKYLISMA +1D063 BYZANTINE MUSICAL SYMBOL TROMIKON NEO +1D064 BYZANTINE MUSICAL SYMBOL EKSTREPTON +1D065 BYZANTINE MUSICAL SYMBOL SYNAGMA NEO +1D066 BYZANTINE MUSICAL SYMBOL SYRMA +1D067 BYZANTINE MUSICAL SYMBOL CHOREVMA NEO +1D068 BYZANTINE MUSICAL SYMBOL EPEGERMA +1D069 BYZANTINE MUSICAL SYMBOL SEISMA NEO +1D06A BYZANTINE MUSICAL SYMBOL XIRON KLASMA +1D06B BYZANTINE MUSICAL SYMBOL TROMIKOPSIFISTON +1D06C BYZANTINE MUSICAL SYMBOL PSIFISTOLYGISMA +1D06D BYZANTINE MUSICAL SYMBOL TROMIKOLYGISMA +1D06E BYZANTINE MUSICAL SYMBOL TROMIKOPARAKALESMA +1D06F BYZANTINE MUSICAL SYMBOL PSIFISTOPARAKALESMA +1D070 BYZANTINE MUSICAL SYMBOL TROMIKOSYNAGMA +1D071 BYZANTINE MUSICAL SYMBOL PSIFISTOSYNAGMA +1D072 BYZANTINE MUSICAL SYMBOL GORGOSYNTHETON +1D073 BYZANTINE MUSICAL SYMBOL ARGOSYNTHETON +1D074 BYZANTINE MUSICAL SYMBOL ETERON ARGOSYNTHETON +1D075 BYZANTINE MUSICAL SYMBOL OYRANISMA NEO +1D076 BYZANTINE MUSICAL SYMBOL THEMATISMOS ESO +1D077 BYZANTINE MUSICAL SYMBOL THEMATISMOS EXO +1D078 BYZANTINE MUSICAL SYMBOL THEMA APLOUN +1D079 BYZANTINE MUSICAL SYMBOL THES KAI APOTHES +1D07A BYZANTINE MUSICAL SYMBOL KATAVASMA +1D07B BYZANTINE MUSICAL SYMBOL ENDOFONON +1D07C BYZANTINE MUSICAL SYMBOL YFEN KATO +1D07D BYZANTINE MUSICAL SYMBOL YFEN ANO +1D07E BYZANTINE MUSICAL SYMBOL STAVROS +1D07F BYZANTINE MUSICAL SYMBOL KLASMA ANO +1D080 BYZANTINE MUSICAL SYMBOL DIPLI ARCHAION +1D081 BYZANTINE MUSICAL SYMBOL KRATIMA ARCHAION +1D082 BYZANTINE MUSICAL SYMBOL KRATIMA ALLO +1D083 BYZANTINE MUSICAL SYMBOL KRATIMA NEO +1D084 BYZANTINE MUSICAL SYMBOL APODERMA NEO +1D085 BYZANTINE MUSICAL SYMBOL APLI +1D086 BYZANTINE MUSICAL SYMBOL DIPLI +1D087 BYZANTINE MUSICAL SYMBOL TRIPLI +1D088 BYZANTINE MUSICAL SYMBOL TETRAPLI +1D089 BYZANTINE MUSICAL SYMBOL KORONIS +1D08A BYZANTINE MUSICAL SYMBOL LEIMMA ENOS CHRONOU +1D08B BYZANTINE MUSICAL SYMBOL LEIMMA DYO CHRONON +1D08C BYZANTINE MUSICAL SYMBOL LEIMMA TRION CHRONON +1D08D BYZANTINE MUSICAL SYMBOL LEIMMA TESSARON CHRONON +1D08E BYZANTINE MUSICAL SYMBOL LEIMMA IMISEOS CHRONOU +1D08F BYZANTINE MUSICAL SYMBOL GORGON NEO ANO +1D090 BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON ARISTERA +1D091 BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON DEXIA +1D092 BYZANTINE MUSICAL SYMBOL DIGORGON +1D093 BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA KATO +1D094 BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA ANO +1D095 BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON DEXIA +1D096 BYZANTINE MUSICAL SYMBOL TRIGORGON +1D097 BYZANTINE MUSICAL SYMBOL ARGON +1D098 BYZANTINE MUSICAL SYMBOL IMIDIARGON +1D099 BYZANTINE MUSICAL SYMBOL DIARGON +1D09A BYZANTINE MUSICAL SYMBOL AGOGI POLI ARGI +1D09B BYZANTINE MUSICAL SYMBOL AGOGI ARGOTERI +1D09C BYZANTINE MUSICAL SYMBOL AGOGI ARGI +1D09D BYZANTINE MUSICAL SYMBOL AGOGI METRIA +1D09E BYZANTINE MUSICAL SYMBOL AGOGI MESI +1D09F BYZANTINE MUSICAL SYMBOL AGOGI GORGI +1D0A0 BYZANTINE MUSICAL SYMBOL AGOGI GORGOTERI +1D0A1 BYZANTINE MUSICAL SYMBOL AGOGI POLI GORGI +1D0A2 BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOS ICHOS +1D0A3 BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI PROTOS ICHOS +1D0A4 BYZANTINE MUSICAL SYMBOL MARTYRIA DEYTEROS ICHOS +1D0A5 BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI DEYTEROS ICHOS +1D0A6 BYZANTINE MUSICAL SYMBOL MARTYRIA TRITOS ICHOS +1D0A7 BYZANTINE MUSICAL SYMBOL MARTYRIA TRIFONIAS +1D0A8 BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS ICHOS +1D0A9 BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS LEGETOS ICHOS +1D0AA BYZANTINE MUSICAL SYMBOL MARTYRIA LEGETOS ICHOS +1D0AB BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS ICHOS +1D0AC BYZANTINE MUSICAL SYMBOL ISAKIA TELOUS ICHIMATOS +1D0AD BYZANTINE MUSICAL SYMBOL APOSTROFOI TELOUS ICHIMATOS +1D0AE BYZANTINE MUSICAL SYMBOL FANEROSIS TETRAFONIAS +1D0AF BYZANTINE MUSICAL SYMBOL FANEROSIS MONOFONIAS +1D0B0 BYZANTINE MUSICAL SYMBOL FANEROSIS DIFONIAS +1D0B1 BYZANTINE MUSICAL SYMBOL MARTYRIA VARYS ICHOS +1D0B2 BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOVARYS ICHOS +1D0B3 BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS TETARTOS ICHOS +1D0B4 BYZANTINE MUSICAL SYMBOL GORTHMIKON N APLOUN +1D0B5 BYZANTINE MUSICAL SYMBOL GORTHMIKON N DIPLOUN +1D0B6 BYZANTINE MUSICAL SYMBOL ENARXIS KAI FTHORA VOU +1D0B7 BYZANTINE MUSICAL SYMBOL IMIFONON +1D0B8 BYZANTINE MUSICAL SYMBOL IMIFTHORON +1D0B9 BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION DEYTEROU ICHOU +1D0BA BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI PA +1D0BB BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NANA +1D0BC BYZANTINE MUSICAL SYMBOL FTHORA NAOS ICHOS +1D0BD BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI DI +1D0BE BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON DIATONON DI +1D0BF BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI KE +1D0C0 BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI ZO +1D0C1 BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI KATO +1D0C2 BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI ANO +1D0C3 BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA DIFONIAS +1D0C4 BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA MONOFONIAS +1D0C5 BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS +1D0C6 BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA SYNAFI +1D0C7 BYZANTINE MUSICAL SYMBOL FTHORA NENANO +1D0C8 BYZANTINE MUSICAL SYMBOL CHROA ZYGOS +1D0C9 BYZANTINE MUSICAL SYMBOL CHROA KLITON +1D0CA BYZANTINE MUSICAL SYMBOL CHROA SPATHI +1D0CB BYZANTINE MUSICAL SYMBOL FTHORA I YFESIS TETARTIMORION +1D0CC BYZANTINE MUSICAL SYMBOL FTHORA ENARMONIOS ANTIFONIA +1D0CD BYZANTINE MUSICAL SYMBOL YFESIS TRITIMORION +1D0CE BYZANTINE MUSICAL SYMBOL DIESIS TRITIMORION +1D0CF BYZANTINE MUSICAL SYMBOL DIESIS TETARTIMORION +1D0D0 BYZANTINE MUSICAL SYMBOL DIESIS APLI DYO DODEKATA +1D0D1 BYZANTINE MUSICAL SYMBOL DIESIS MONOGRAMMOS TESSERA DODEKATA +1D0D2 BYZANTINE MUSICAL SYMBOL DIESIS DIGRAMMOS EX DODEKATA +1D0D3 BYZANTINE MUSICAL SYMBOL DIESIS TRIGRAMMOS OKTO DODEKATA +1D0D4 BYZANTINE MUSICAL SYMBOL YFESIS APLI DYO DODEKATA +1D0D5 BYZANTINE MUSICAL SYMBOL YFESIS MONOGRAMMOS TESSERA DODEKATA +1D0D6 BYZANTINE MUSICAL SYMBOL YFESIS DIGRAMMOS EX DODEKATA +1D0D7 BYZANTINE MUSICAL SYMBOL YFESIS TRIGRAMMOS OKTO DODEKATA +1D0D8 BYZANTINE MUSICAL SYMBOL GENIKI DIESIS +1D0D9 BYZANTINE MUSICAL SYMBOL GENIKI YFESIS +1D0DA BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MIKRI +1D0DB BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MEGALI +1D0DC BYZANTINE MUSICAL SYMBOL DIASTOLI DIPLI +1D0DD BYZANTINE MUSICAL SYMBOL DIASTOLI THESEOS +1D0DE BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS +1D0DF BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS DISIMOU +1D0E0 BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TRISIMOU +1D0E1 BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TETRASIMOU +1D0E2 BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS +1D0E3 BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS DISIMOU +1D0E4 BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TRISIMOU +1D0E5 BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TETRASIMOU +1D0E6 BYZANTINE MUSICAL SYMBOL DIGRAMMA GG +1D0E7 BYZANTINE MUSICAL SYMBOL DIFTOGGOS OU +1D0E8 BYZANTINE MUSICAL SYMBOL STIGMA +1D0E9 BYZANTINE MUSICAL SYMBOL ARKTIKO PA +1D0EA BYZANTINE MUSICAL SYMBOL ARKTIKO VOU +1D0EB BYZANTINE MUSICAL SYMBOL ARKTIKO GA +1D0EC BYZANTINE MUSICAL SYMBOL ARKTIKO DI +1D0ED BYZANTINE MUSICAL SYMBOL ARKTIKO KE +1D0EE BYZANTINE MUSICAL SYMBOL ARKTIKO ZO +1D0EF BYZANTINE MUSICAL SYMBOL ARKTIKO NI +1D0F0 BYZANTINE MUSICAL SYMBOL KENTIMATA NEO MESO +1D0F1 BYZANTINE MUSICAL SYMBOL KENTIMA NEO MESO +1D0F2 BYZANTINE MUSICAL SYMBOL KENTIMATA NEO KATO +1D0F3 BYZANTINE MUSICAL SYMBOL KENTIMA NEO KATO +1D0F4 BYZANTINE MUSICAL SYMBOL KLASMA KATO +1D0F5 BYZANTINE MUSICAL SYMBOL GORGON NEO KATO +1D100 MUSICAL SYMBOL SINGLE BARLINE +1D101 MUSICAL SYMBOL DOUBLE BARLINE +1D102 MUSICAL SYMBOL FINAL BARLINE +1D103 MUSICAL SYMBOL REVERSE FINAL BARLINE +1D104 MUSICAL SYMBOL DASHED BARLINE +1D105 MUSICAL SYMBOL SHORT BARLINE +1D106 MUSICAL SYMBOL LEFT REPEAT SIGN +1D107 MUSICAL SYMBOL RIGHT REPEAT SIGN +1D108 MUSICAL SYMBOL REPEAT DOTS +1D109 MUSICAL SYMBOL DAL SEGNO +1D10A MUSICAL SYMBOL DA CAPO +1D10B MUSICAL SYMBOL SEGNO +1D10C MUSICAL SYMBOL CODA +1D10D MUSICAL SYMBOL REPEATED FIGURE-1 +1D10E MUSICAL SYMBOL REPEATED FIGURE-2 +1D10F MUSICAL SYMBOL REPEATED FIGURE-3 +1D110 MUSICAL SYMBOL FERMATA +1D111 MUSICAL SYMBOL FERMATA BELOW +1D112 MUSICAL SYMBOL BREATH MARK +1D113 MUSICAL SYMBOL CAESURA +1D114 MUSICAL SYMBOL BRACE +1D115 MUSICAL SYMBOL BRACKET +1D116 MUSICAL SYMBOL ONE-LINE STAFF +1D117 MUSICAL SYMBOL TWO-LINE STAFF +1D118 MUSICAL SYMBOL THREE-LINE STAFF +1D119 MUSICAL SYMBOL FOUR-LINE STAFF +1D11A MUSICAL SYMBOL FIVE-LINE STAFF +1D11B MUSICAL SYMBOL SIX-LINE STAFF +1D11C MUSICAL SYMBOL SIX-STRING FRETBOARD +1D11D MUSICAL SYMBOL FOUR-STRING FRETBOARD +1D11E MUSICAL SYMBOL G CLEF +1D11F MUSICAL SYMBOL G CLEF OTTAVA ALTA +1D120 MUSICAL SYMBOL G CLEF OTTAVA BASSA +1D121 MUSICAL SYMBOL C CLEF +1D122 MUSICAL SYMBOL F CLEF +1D123 MUSICAL SYMBOL F CLEF OTTAVA ALTA +1D124 MUSICAL SYMBOL F CLEF OTTAVA BASSA +1D125 MUSICAL SYMBOL DRUM CLEF-1 +1D126 MUSICAL SYMBOL DRUM CLEF-2 +1D12A MUSICAL SYMBOL DOUBLE SHARP +1D12B MUSICAL SYMBOL DOUBLE FLAT +1D12C MUSICAL SYMBOL FLAT UP +1D12D MUSICAL SYMBOL FLAT DOWN +1D12E MUSICAL SYMBOL NATURAL UP +1D12F MUSICAL SYMBOL NATURAL DOWN +1D130 MUSICAL SYMBOL SHARP UP +1D131 MUSICAL SYMBOL SHARP DOWN +1D132 MUSICAL SYMBOL QUARTER TONE SHARP +1D133 MUSICAL SYMBOL QUARTER TONE FLAT +1D134 MUSICAL SYMBOL COMMON TIME +1D135 MUSICAL SYMBOL CUT TIME +1D136 MUSICAL SYMBOL OTTAVA ALTA +1D137 MUSICAL SYMBOL OTTAVA BASSA +1D138 MUSICAL SYMBOL QUINDICESIMA ALTA +1D139 MUSICAL SYMBOL QUINDICESIMA BASSA +1D13A MUSICAL SYMBOL MULTI REST +1D13B MUSICAL SYMBOL WHOLE REST +1D13C MUSICAL SYMBOL HALF REST +1D13D MUSICAL SYMBOL QUARTER REST +1D13E MUSICAL SYMBOL EIGHTH REST +1D13F MUSICAL SYMBOL SIXTEENTH REST +1D140 MUSICAL SYMBOL THIRTY-SECOND REST +1D141 MUSICAL SYMBOL SIXTY-FOURTH REST +1D142 MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH REST +1D143 MUSICAL SYMBOL X NOTEHEAD +1D144 MUSICAL SYMBOL PLUS NOTEHEAD +1D145 MUSICAL SYMBOL CIRCLE X NOTEHEAD +1D146 MUSICAL SYMBOL SQUARE NOTEHEAD WHITE +1D147 MUSICAL SYMBOL SQUARE NOTEHEAD BLACK +1D148 MUSICAL SYMBOL TRIANGLE NOTEHEAD UP WHITE +1D149 MUSICAL SYMBOL TRIANGLE NOTEHEAD UP BLACK +1D14A MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT WHITE +1D14B MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT BLACK +1D14C MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT WHITE +1D14D MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT BLACK +1D14E MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN WHITE +1D14F MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN BLACK +1D150 MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT WHITE +1D151 MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT BLACK +1D152 MUSICAL SYMBOL MOON NOTEHEAD WHITE +1D153 MUSICAL SYMBOL MOON NOTEHEAD BLACK +1D154 MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN WHITE +1D155 MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN BLACK +1D156 MUSICAL SYMBOL PARENTHESIS NOTEHEAD +1D157 MUSICAL SYMBOL VOID NOTEHEAD +1D158 MUSICAL SYMBOL NOTEHEAD BLACK +1D159 MUSICAL SYMBOL NULL NOTEHEAD +1D15A MUSICAL SYMBOL CLUSTER NOTEHEAD WHITE +1D15B MUSICAL SYMBOL CLUSTER NOTEHEAD BLACK +1D15C MUSICAL SYMBOL BREVE +1D15D MUSICAL SYMBOL WHOLE NOTE +1D15E MUSICAL SYMBOL HALF NOTE +1D15F MUSICAL SYMBOL QUARTER NOTE +1D160 MUSICAL SYMBOL EIGHTH NOTE +1D161 MUSICAL SYMBOL SIXTEENTH NOTE +1D162 MUSICAL SYMBOL THIRTY-SECOND NOTE +1D163 MUSICAL SYMBOL SIXTY-FOURTH NOTE +1D164 MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE +1D165 MUSICAL SYMBOL COMBINING STEM +1D166 MUSICAL SYMBOL COMBINING SPRECHGESANG STEM +1D167 MUSICAL SYMBOL COMBINING TREMOLO-1 +1D168 MUSICAL SYMBOL COMBINING TREMOLO-2 +1D169 MUSICAL SYMBOL COMBINING TREMOLO-3 +1D16A MUSICAL SYMBOL FINGERED TREMOLO-1 +1D16B MUSICAL SYMBOL FINGERED TREMOLO-2 +1D16C MUSICAL SYMBOL FINGERED TREMOLO-3 +1D16D MUSICAL SYMBOL COMBINING AUGMENTATION DOT +1D16E MUSICAL SYMBOL COMBINING FLAG-1 +1D16F MUSICAL SYMBOL COMBINING FLAG-2 +1D170 MUSICAL SYMBOL COMBINING FLAG-3 +1D171 MUSICAL SYMBOL COMBINING FLAG-4 +1D172 MUSICAL SYMBOL COMBINING FLAG-5 +1D173 MUSICAL SYMBOL BEGIN BEAM +1D174 MUSICAL SYMBOL END BEAM +1D175 MUSICAL SYMBOL BEGIN TIE +1D176 MUSICAL SYMBOL END TIE +1D177 MUSICAL SYMBOL BEGIN SLUR +1D178 MUSICAL SYMBOL END SLUR +1D179 MUSICAL SYMBOL BEGIN PHRASE +1D17A MUSICAL SYMBOL END PHRASE +1D17B MUSICAL SYMBOL COMBINING ACCENT +1D17C MUSICAL SYMBOL COMBINING STACCATO +1D17D MUSICAL SYMBOL COMBINING TENUTO +1D17E MUSICAL SYMBOL COMBINING STACCATISSIMO +1D17F MUSICAL SYMBOL COMBINING MARCATO +1D180 MUSICAL SYMBOL COMBINING MARCATO-STACCATO +1D181 MUSICAL SYMBOL COMBINING ACCENT-STACCATO +1D182 MUSICAL SYMBOL COMBINING LOURE +1D183 MUSICAL SYMBOL ARPEGGIATO UP +1D184 MUSICAL SYMBOL ARPEGGIATO DOWN +1D185 MUSICAL SYMBOL COMBINING DOIT +1D186 MUSICAL SYMBOL COMBINING RIP +1D187 MUSICAL SYMBOL COMBINING FLIP +1D188 MUSICAL SYMBOL COMBINING SMEAR +1D189 MUSICAL SYMBOL COMBINING BEND +1D18A MUSICAL SYMBOL COMBINING DOUBLE TONGUE +1D18B MUSICAL SYMBOL COMBINING TRIPLE TONGUE +1D18C MUSICAL SYMBOL RINFORZANDO +1D18D MUSICAL SYMBOL SUBITO +1D18E MUSICAL SYMBOL Z +1D18F MUSICAL SYMBOL PIANO +1D190 MUSICAL SYMBOL MEZZO +1D191 MUSICAL SYMBOL FORTE +1D192 MUSICAL SYMBOL CRESCENDO +1D193 MUSICAL SYMBOL DECRESCENDO +1D194 MUSICAL SYMBOL GRACE NOTE SLASH +1D195 MUSICAL SYMBOL GRACE NOTE NO SLASH +1D196 MUSICAL SYMBOL TR +1D197 MUSICAL SYMBOL TURN +1D198 MUSICAL SYMBOL INVERTED TURN +1D199 MUSICAL SYMBOL TURN SLASH +1D19A MUSICAL SYMBOL TURN UP +1D19B MUSICAL SYMBOL ORNAMENT STROKE-1 +1D19C MUSICAL SYMBOL ORNAMENT STROKE-2 +1D19D MUSICAL SYMBOL ORNAMENT STROKE-3 +1D19E MUSICAL SYMBOL ORNAMENT STROKE-4 +1D19F MUSICAL SYMBOL ORNAMENT STROKE-5 +1D1A0 MUSICAL SYMBOL ORNAMENT STROKE-6 +1D1A1 MUSICAL SYMBOL ORNAMENT STROKE-7 +1D1A2 MUSICAL SYMBOL ORNAMENT STROKE-8 +1D1A3 MUSICAL SYMBOL ORNAMENT STROKE-9 +1D1A4 MUSICAL SYMBOL ORNAMENT STROKE-10 +1D1A5 MUSICAL SYMBOL ORNAMENT STROKE-11 +1D1A6 MUSICAL SYMBOL HAUPTSTIMME +1D1A7 MUSICAL SYMBOL NEBENSTIMME +1D1A8 MUSICAL SYMBOL END OF STIMME +1D1A9 MUSICAL SYMBOL DEGREE SLASH +1D1AA MUSICAL SYMBOL COMBINING DOWN BOW +1D1AB MUSICAL SYMBOL COMBINING UP BOW +1D1AC MUSICAL SYMBOL COMBINING HARMONIC +1D1AD MUSICAL SYMBOL COMBINING SNAP PIZZICATO +1D1AE MUSICAL SYMBOL PEDAL MARK +1D1AF MUSICAL SYMBOL PEDAL UP MARK +1D1B0 MUSICAL SYMBOL HALF PEDAL MARK +1D1B1 MUSICAL SYMBOL GLISSANDO UP +1D1B2 MUSICAL SYMBOL GLISSANDO DOWN +1D1B3 MUSICAL SYMBOL WITH FINGERNAILS +1D1B4 MUSICAL SYMBOL DAMP +1D1B5 MUSICAL SYMBOL DAMP ALL +1D1B6 MUSICAL SYMBOL MAXIMA +1D1B7 MUSICAL SYMBOL LONGA +1D1B8 MUSICAL SYMBOL BREVIS +1D1B9 MUSICAL SYMBOL SEMIBREVIS WHITE +1D1BA MUSICAL SYMBOL SEMIBREVIS BLACK +1D1BB MUSICAL SYMBOL MINIMA +1D1BC MUSICAL SYMBOL MINIMA BLACK +1D1BD MUSICAL SYMBOL SEMIMINIMA WHITE +1D1BE MUSICAL SYMBOL SEMIMINIMA BLACK +1D1BF MUSICAL SYMBOL FUSA WHITE +1D1C0 MUSICAL SYMBOL FUSA BLACK +1D1C1 MUSICAL SYMBOL LONGA PERFECTA REST +1D1C2 MUSICAL SYMBOL LONGA IMPERFECTA REST +1D1C3 MUSICAL SYMBOL BREVIS REST +1D1C4 MUSICAL SYMBOL SEMIBREVIS REST +1D1C5 MUSICAL SYMBOL MINIMA REST +1D1C6 MUSICAL SYMBOL SEMIMINIMA REST +1D1C7 MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA +1D1C8 MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE IMPERFECTA +1D1C9 MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA DIMINUTION-1 +1D1CA MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE PERFECTA +1D1CB MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA +1D1CC MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-1 +1D1CD MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-2 +1D1CE MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-3 +1D1CF MUSICAL SYMBOL CROIX +1D1D0 MUSICAL SYMBOL GREGORIAN C CLEF +1D1D1 MUSICAL SYMBOL GREGORIAN F CLEF +1D1D2 MUSICAL SYMBOL SQUARE B +1D1D3 MUSICAL SYMBOL VIRGA +1D1D4 MUSICAL SYMBOL PODATUS +1D1D5 MUSICAL SYMBOL CLIVIS +1D1D6 MUSICAL SYMBOL SCANDICUS +1D1D7 MUSICAL SYMBOL CLIMACUS +1D1D8 MUSICAL SYMBOL TORCULUS +1D1D9 MUSICAL SYMBOL PORRECTUS +1D1DA MUSICAL SYMBOL PORRECTUS FLEXUS +1D1DB MUSICAL SYMBOL SCANDICUS FLEXUS +1D1DC MUSICAL SYMBOL TORCULUS RESUPINUS +1D1DD MUSICAL SYMBOL PES SUBPUNCTIS +1D400 MATHEMATICAL BOLD CAPITAL A +1D401 MATHEMATICAL BOLD CAPITAL B +1D402 MATHEMATICAL BOLD CAPITAL C +1D403 MATHEMATICAL BOLD CAPITAL D +1D404 MATHEMATICAL BOLD CAPITAL E +1D405 MATHEMATICAL BOLD CAPITAL F +1D406 MATHEMATICAL BOLD CAPITAL G +1D407 MATHEMATICAL BOLD CAPITAL H +1D408 MATHEMATICAL BOLD CAPITAL I +1D409 MATHEMATICAL BOLD CAPITAL J +1D40A MATHEMATICAL BOLD CAPITAL K +1D40B MATHEMATICAL BOLD CAPITAL L +1D40C MATHEMATICAL BOLD CAPITAL M +1D40D MATHEMATICAL BOLD CAPITAL N +1D40E MATHEMATICAL BOLD CAPITAL O +1D40F MATHEMATICAL BOLD CAPITAL P +1D410 MATHEMATICAL BOLD CAPITAL Q +1D411 MATHEMATICAL BOLD CAPITAL R +1D412 MATHEMATICAL BOLD CAPITAL S +1D413 MATHEMATICAL BOLD CAPITAL T +1D414 MATHEMATICAL BOLD CAPITAL U +1D415 MATHEMATICAL BOLD CAPITAL V +1D416 MATHEMATICAL BOLD CAPITAL W +1D417 MATHEMATICAL BOLD CAPITAL X +1D418 MATHEMATICAL BOLD CAPITAL Y +1D419 MATHEMATICAL BOLD CAPITAL Z +1D41A MATHEMATICAL BOLD SMALL A +1D41B MATHEMATICAL BOLD SMALL B +1D41C MATHEMATICAL BOLD SMALL C +1D41D MATHEMATICAL BOLD SMALL D +1D41E MATHEMATICAL BOLD SMALL E +1D41F MATHEMATICAL BOLD SMALL F +1D420 MATHEMATICAL BOLD SMALL G +1D421 MATHEMATICAL BOLD SMALL H +1D422 MATHEMATICAL BOLD SMALL I +1D423 MATHEMATICAL BOLD SMALL J +1D424 MATHEMATICAL BOLD SMALL K +1D425 MATHEMATICAL BOLD SMALL L +1D426 MATHEMATICAL BOLD SMALL M +1D427 MATHEMATICAL BOLD SMALL N +1D428 MATHEMATICAL BOLD SMALL O +1D429 MATHEMATICAL BOLD SMALL P +1D42A MATHEMATICAL BOLD SMALL Q +1D42B MATHEMATICAL BOLD SMALL R +1D42C MATHEMATICAL BOLD SMALL S +1D42D MATHEMATICAL BOLD SMALL T +1D42E MATHEMATICAL BOLD SMALL U +1D42F MATHEMATICAL BOLD SMALL V +1D430 MATHEMATICAL BOLD SMALL W +1D431 MATHEMATICAL BOLD SMALL X +1D432 MATHEMATICAL BOLD SMALL Y +1D433 MATHEMATICAL BOLD SMALL Z +1D434 MATHEMATICAL ITALIC CAPITAL A +1D435 MATHEMATICAL ITALIC CAPITAL B +1D436 MATHEMATICAL ITALIC CAPITAL C +1D437 MATHEMATICAL ITALIC CAPITAL D +1D438 MATHEMATICAL ITALIC CAPITAL E +1D439 MATHEMATICAL ITALIC CAPITAL F +1D43A MATHEMATICAL ITALIC CAPITAL G +1D43B MATHEMATICAL ITALIC CAPITAL H +1D43C MATHEMATICAL ITALIC CAPITAL I +1D43D MATHEMATICAL ITALIC CAPITAL J +1D43E MATHEMATICAL ITALIC CAPITAL K +1D43F MATHEMATICAL ITALIC CAPITAL L +1D440 MATHEMATICAL ITALIC CAPITAL M +1D441 MATHEMATICAL ITALIC CAPITAL N +1D442 MATHEMATICAL ITALIC CAPITAL O +1D443 MATHEMATICAL ITALIC CAPITAL P +1D444 MATHEMATICAL ITALIC CAPITAL Q +1D445 MATHEMATICAL ITALIC CAPITAL R +1D446 MATHEMATICAL ITALIC CAPITAL S +1D447 MATHEMATICAL ITALIC CAPITAL T +1D448 MATHEMATICAL ITALIC CAPITAL U +1D449 MATHEMATICAL ITALIC CAPITAL V +1D44A MATHEMATICAL ITALIC CAPITAL W +1D44B MATHEMATICAL ITALIC CAPITAL X +1D44C MATHEMATICAL ITALIC CAPITAL Y +1D44D MATHEMATICAL ITALIC CAPITAL Z +1D44E MATHEMATICAL ITALIC SMALL A +1D44F MATHEMATICAL ITALIC SMALL B +1D450 MATHEMATICAL ITALIC SMALL C +1D451 MATHEMATICAL ITALIC SMALL D +1D452 MATHEMATICAL ITALIC SMALL E +1D453 MATHEMATICAL ITALIC SMALL F +1D454 MATHEMATICAL ITALIC SMALL G +1D456 MATHEMATICAL ITALIC SMALL I +1D457 MATHEMATICAL ITALIC SMALL J +1D458 MATHEMATICAL ITALIC SMALL K +1D459 MATHEMATICAL ITALIC SMALL L +1D45A MATHEMATICAL ITALIC SMALL M +1D45B MATHEMATICAL ITALIC SMALL N +1D45C MATHEMATICAL ITALIC SMALL O +1D45D MATHEMATICAL ITALIC SMALL P +1D45E MATHEMATICAL ITALIC SMALL Q +1D45F MATHEMATICAL ITALIC SMALL R +1D460 MATHEMATICAL ITALIC SMALL S +1D461 MATHEMATICAL ITALIC SMALL T +1D462 MATHEMATICAL ITALIC SMALL U +1D463 MATHEMATICAL ITALIC SMALL V +1D464 MATHEMATICAL ITALIC SMALL W +1D465 MATHEMATICAL ITALIC SMALL X +1D466 MATHEMATICAL ITALIC SMALL Y +1D467 MATHEMATICAL ITALIC SMALL Z +1D468 MATHEMATICAL BOLD ITALIC CAPITAL A +1D469 MATHEMATICAL BOLD ITALIC CAPITAL B +1D46A MATHEMATICAL BOLD ITALIC CAPITAL C +1D46B MATHEMATICAL BOLD ITALIC CAPITAL D +1D46C MATHEMATICAL BOLD ITALIC CAPITAL E +1D46D MATHEMATICAL BOLD ITALIC CAPITAL F +1D46E MATHEMATICAL BOLD ITALIC CAPITAL G +1D46F MATHEMATICAL BOLD ITALIC CAPITAL H +1D470 MATHEMATICAL BOLD ITALIC CAPITAL I +1D471 MATHEMATICAL BOLD ITALIC CAPITAL J +1D472 MATHEMATICAL BOLD ITALIC CAPITAL K +1D473 MATHEMATICAL BOLD ITALIC CAPITAL L +1D474 MATHEMATICAL BOLD ITALIC CAPITAL M +1D475 MATHEMATICAL BOLD ITALIC CAPITAL N +1D476 MATHEMATICAL BOLD ITALIC CAPITAL O +1D477 MATHEMATICAL BOLD ITALIC CAPITAL P +1D478 MATHEMATICAL BOLD ITALIC CAPITAL Q +1D479 MATHEMATICAL BOLD ITALIC CAPITAL R +1D47A MATHEMATICAL BOLD ITALIC CAPITAL S +1D47B MATHEMATICAL BOLD ITALIC CAPITAL T +1D47C MATHEMATICAL BOLD ITALIC CAPITAL U +1D47D MATHEMATICAL BOLD ITALIC CAPITAL V +1D47E MATHEMATICAL BOLD ITALIC CAPITAL W +1D47F MATHEMATICAL BOLD ITALIC CAPITAL X +1D480 MATHEMATICAL BOLD ITALIC CAPITAL Y +1D481 MATHEMATICAL BOLD ITALIC CAPITAL Z +1D482 MATHEMATICAL BOLD ITALIC SMALL A +1D483 MATHEMATICAL BOLD ITALIC SMALL B +1D484 MATHEMATICAL BOLD ITALIC SMALL C +1D485 MATHEMATICAL BOLD ITALIC SMALL D +1D486 MATHEMATICAL BOLD ITALIC SMALL E +1D487 MATHEMATICAL BOLD ITALIC SMALL F +1D488 MATHEMATICAL BOLD ITALIC SMALL G +1D489 MATHEMATICAL BOLD ITALIC SMALL H +1D48A MATHEMATICAL BOLD ITALIC SMALL I +1D48B MATHEMATICAL BOLD ITALIC SMALL J +1D48C MATHEMATICAL BOLD ITALIC SMALL K +1D48D MATHEMATICAL BOLD ITALIC SMALL L +1D48E MATHEMATICAL BOLD ITALIC SMALL M +1D48F MATHEMATICAL BOLD ITALIC SMALL N +1D490 MATHEMATICAL BOLD ITALIC SMALL O +1D491 MATHEMATICAL BOLD ITALIC SMALL P +1D492 MATHEMATICAL BOLD ITALIC SMALL Q +1D493 MATHEMATICAL BOLD ITALIC SMALL R +1D494 MATHEMATICAL BOLD ITALIC SMALL S +1D495 MATHEMATICAL BOLD ITALIC SMALL T +1D496 MATHEMATICAL BOLD ITALIC SMALL U +1D497 MATHEMATICAL BOLD ITALIC SMALL V +1D498 MATHEMATICAL BOLD ITALIC SMALL W +1D499 MATHEMATICAL BOLD ITALIC SMALL X +1D49A MATHEMATICAL BOLD ITALIC SMALL Y +1D49B MATHEMATICAL BOLD ITALIC SMALL Z +1D49C MATHEMATICAL SCRIPT CAPITAL A +1D49E MATHEMATICAL SCRIPT CAPITAL C +1D49F MATHEMATICAL SCRIPT CAPITAL D +1D4A2 MATHEMATICAL SCRIPT CAPITAL G +1D4A5 MATHEMATICAL SCRIPT CAPITAL J +1D4A6 MATHEMATICAL SCRIPT CAPITAL K +1D4A9 MATHEMATICAL SCRIPT CAPITAL N +1D4AA MATHEMATICAL SCRIPT CAPITAL O +1D4AB MATHEMATICAL SCRIPT CAPITAL P +1D4AC MATHEMATICAL SCRIPT CAPITAL Q +1D4AE MATHEMATICAL SCRIPT CAPITAL S +1D4AF MATHEMATICAL SCRIPT CAPITAL T +1D4B0 MATHEMATICAL SCRIPT CAPITAL U +1D4B1 MATHEMATICAL SCRIPT CAPITAL V +1D4B2 MATHEMATICAL SCRIPT CAPITAL W +1D4B3 MATHEMATICAL SCRIPT CAPITAL X +1D4B4 MATHEMATICAL SCRIPT CAPITAL Y +1D4B5 MATHEMATICAL SCRIPT CAPITAL Z +1D4B6 MATHEMATICAL SCRIPT SMALL A +1D4B7 MATHEMATICAL SCRIPT SMALL B +1D4B8 MATHEMATICAL SCRIPT SMALL C +1D4B9 MATHEMATICAL SCRIPT SMALL D +1D4BB MATHEMATICAL SCRIPT SMALL F +1D4BD MATHEMATICAL SCRIPT SMALL H +1D4BE MATHEMATICAL SCRIPT SMALL I +1D4BF MATHEMATICAL SCRIPT SMALL J +1D4C0 MATHEMATICAL SCRIPT SMALL K +1D4C2 MATHEMATICAL SCRIPT SMALL M +1D4C3 MATHEMATICAL SCRIPT SMALL N +1D4C5 MATHEMATICAL SCRIPT SMALL P +1D4C6 MATHEMATICAL SCRIPT SMALL Q +1D4C7 MATHEMATICAL SCRIPT SMALL R +1D4C8 MATHEMATICAL SCRIPT SMALL S +1D4C9 MATHEMATICAL SCRIPT SMALL T +1D4CA MATHEMATICAL SCRIPT SMALL U +1D4CB MATHEMATICAL SCRIPT SMALL V +1D4CC MATHEMATICAL SCRIPT SMALL W +1D4CD MATHEMATICAL SCRIPT SMALL X +1D4CE MATHEMATICAL SCRIPT SMALL Y +1D4CF MATHEMATICAL SCRIPT SMALL Z +1D4D0 MATHEMATICAL BOLD SCRIPT CAPITAL A +1D4D1 MATHEMATICAL BOLD SCRIPT CAPITAL B +1D4D2 MATHEMATICAL BOLD SCRIPT CAPITAL C +1D4D3 MATHEMATICAL BOLD SCRIPT CAPITAL D +1D4D4 MATHEMATICAL BOLD SCRIPT CAPITAL E +1D4D5 MATHEMATICAL BOLD SCRIPT CAPITAL F +1D4D6 MATHEMATICAL BOLD SCRIPT CAPITAL G +1D4D7 MATHEMATICAL BOLD SCRIPT CAPITAL H +1D4D8 MATHEMATICAL BOLD SCRIPT CAPITAL I +1D4D9 MATHEMATICAL BOLD SCRIPT CAPITAL J +1D4DA MATHEMATICAL BOLD SCRIPT CAPITAL K +1D4DB MATHEMATICAL BOLD SCRIPT CAPITAL L +1D4DC MATHEMATICAL BOLD SCRIPT CAPITAL M +1D4DD MATHEMATICAL BOLD SCRIPT CAPITAL N +1D4DE MATHEMATICAL BOLD SCRIPT CAPITAL O +1D4DF MATHEMATICAL BOLD SCRIPT CAPITAL P +1D4E0 MATHEMATICAL BOLD SCRIPT CAPITAL Q +1D4E1 MATHEMATICAL BOLD SCRIPT CAPITAL R +1D4E2 MATHEMATICAL BOLD SCRIPT CAPITAL S +1D4E3 MATHEMATICAL BOLD SCRIPT CAPITAL T +1D4E4 MATHEMATICAL BOLD SCRIPT CAPITAL U +1D4E5 MATHEMATICAL BOLD SCRIPT CAPITAL V +1D4E6 MATHEMATICAL BOLD SCRIPT CAPITAL W +1D4E7 MATHEMATICAL BOLD SCRIPT CAPITAL X +1D4E8 MATHEMATICAL BOLD SCRIPT CAPITAL Y +1D4E9 MATHEMATICAL BOLD SCRIPT CAPITAL Z +1D4EA MATHEMATICAL BOLD SCRIPT SMALL A +1D4EB MATHEMATICAL BOLD SCRIPT SMALL B +1D4EC MATHEMATICAL BOLD SCRIPT SMALL C +1D4ED MATHEMATICAL BOLD SCRIPT SMALL D +1D4EE MATHEMATICAL BOLD SCRIPT SMALL E +1D4EF MATHEMATICAL BOLD SCRIPT SMALL F +1D4F0 MATHEMATICAL BOLD SCRIPT SMALL G +1D4F1 MATHEMATICAL BOLD SCRIPT SMALL H +1D4F2 MATHEMATICAL BOLD SCRIPT SMALL I +1D4F3 MATHEMATICAL BOLD SCRIPT SMALL J +1D4F4 MATHEMATICAL BOLD SCRIPT SMALL K +1D4F5 MATHEMATICAL BOLD SCRIPT SMALL L +1D4F6 MATHEMATICAL BOLD SCRIPT SMALL M +1D4F7 MATHEMATICAL BOLD SCRIPT SMALL N +1D4F8 MATHEMATICAL BOLD SCRIPT SMALL O +1D4F9 MATHEMATICAL BOLD SCRIPT SMALL P +1D4FA MATHEMATICAL BOLD SCRIPT SMALL Q +1D4FB MATHEMATICAL BOLD SCRIPT SMALL R +1D4FC MATHEMATICAL BOLD SCRIPT SMALL S +1D4FD MATHEMATICAL BOLD SCRIPT SMALL T +1D4FE MATHEMATICAL BOLD SCRIPT SMALL U +1D4FF MATHEMATICAL BOLD SCRIPT SMALL V +1D500 MATHEMATICAL BOLD SCRIPT SMALL W +1D501 MATHEMATICAL BOLD SCRIPT SMALL X +1D502 MATHEMATICAL BOLD SCRIPT SMALL Y +1D503 MATHEMATICAL BOLD SCRIPT SMALL Z +1D504 MATHEMATICAL FRAKTUR CAPITAL A +1D505 MATHEMATICAL FRAKTUR CAPITAL B +1D507 MATHEMATICAL FRAKTUR CAPITAL D +1D508 MATHEMATICAL FRAKTUR CAPITAL E +1D509 MATHEMATICAL FRAKTUR CAPITAL F +1D50A MATHEMATICAL FRAKTUR CAPITAL G +1D50D MATHEMATICAL FRAKTUR CAPITAL J +1D50E MATHEMATICAL FRAKTUR CAPITAL K +1D50F MATHEMATICAL FRAKTUR CAPITAL L +1D510 MATHEMATICAL FRAKTUR CAPITAL M +1D511 MATHEMATICAL FRAKTUR CAPITAL N +1D512 MATHEMATICAL FRAKTUR CAPITAL O +1D513 MATHEMATICAL FRAKTUR CAPITAL P +1D514 MATHEMATICAL FRAKTUR CAPITAL Q +1D516 MATHEMATICAL FRAKTUR CAPITAL S +1D517 MATHEMATICAL FRAKTUR CAPITAL T +1D518 MATHEMATICAL FRAKTUR CAPITAL U +1D519 MATHEMATICAL FRAKTUR CAPITAL V +1D51A MATHEMATICAL FRAKTUR CAPITAL W +1D51B MATHEMATICAL FRAKTUR CAPITAL X +1D51C MATHEMATICAL FRAKTUR CAPITAL Y +1D51E MATHEMATICAL FRAKTUR SMALL A +1D51F MATHEMATICAL FRAKTUR SMALL B +1D520 MATHEMATICAL FRAKTUR SMALL C +1D521 MATHEMATICAL FRAKTUR SMALL D +1D522 MATHEMATICAL FRAKTUR SMALL E +1D523 MATHEMATICAL FRAKTUR SMALL F +1D524 MATHEMATICAL FRAKTUR SMALL G +1D525 MATHEMATICAL FRAKTUR SMALL H +1D526 MATHEMATICAL FRAKTUR SMALL I +1D527 MATHEMATICAL FRAKTUR SMALL J +1D528 MATHEMATICAL FRAKTUR SMALL K +1D529 MATHEMATICAL FRAKTUR SMALL L +1D52A MATHEMATICAL FRAKTUR SMALL M +1D52B MATHEMATICAL FRAKTUR SMALL N +1D52C MATHEMATICAL FRAKTUR SMALL O +1D52D MATHEMATICAL FRAKTUR SMALL P +1D52E MATHEMATICAL FRAKTUR SMALL Q +1D52F MATHEMATICAL FRAKTUR SMALL R +1D530 MATHEMATICAL FRAKTUR SMALL S +1D531 MATHEMATICAL FRAKTUR SMALL T +1D532 MATHEMATICAL FRAKTUR SMALL U +1D533 MATHEMATICAL FRAKTUR SMALL V +1D534 MATHEMATICAL FRAKTUR SMALL W +1D535 MATHEMATICAL FRAKTUR SMALL X +1D536 MATHEMATICAL FRAKTUR SMALL Y +1D537 MATHEMATICAL FRAKTUR SMALL Z +1D538 MATHEMATICAL DOUBLE-STRUCK CAPITAL A +1D539 MATHEMATICAL DOUBLE-STRUCK CAPITAL B +1D53B MATHEMATICAL DOUBLE-STRUCK CAPITAL D +1D53C MATHEMATICAL DOUBLE-STRUCK CAPITAL E +1D53D MATHEMATICAL DOUBLE-STRUCK CAPITAL F +1D53E MATHEMATICAL DOUBLE-STRUCK CAPITAL G +1D540 MATHEMATICAL DOUBLE-STRUCK CAPITAL I +1D541 MATHEMATICAL DOUBLE-STRUCK CAPITAL J +1D542 MATHEMATICAL DOUBLE-STRUCK CAPITAL K +1D543 MATHEMATICAL DOUBLE-STRUCK CAPITAL L +1D544 MATHEMATICAL DOUBLE-STRUCK CAPITAL M +1D546 MATHEMATICAL DOUBLE-STRUCK CAPITAL O +1D54A MATHEMATICAL DOUBLE-STRUCK CAPITAL S +1D54B MATHEMATICAL DOUBLE-STRUCK CAPITAL T +1D54C MATHEMATICAL DOUBLE-STRUCK CAPITAL U +1D54D MATHEMATICAL DOUBLE-STRUCK CAPITAL V +1D54E MATHEMATICAL DOUBLE-STRUCK CAPITAL W +1D54F MATHEMATICAL DOUBLE-STRUCK CAPITAL X +1D550 MATHEMATICAL DOUBLE-STRUCK CAPITAL Y +1D552 MATHEMATICAL DOUBLE-STRUCK SMALL A +1D553 MATHEMATICAL DOUBLE-STRUCK SMALL B +1D554 MATHEMATICAL DOUBLE-STRUCK SMALL C +1D555 MATHEMATICAL DOUBLE-STRUCK SMALL D +1D556 MATHEMATICAL DOUBLE-STRUCK SMALL E +1D557 MATHEMATICAL DOUBLE-STRUCK SMALL F +1D558 MATHEMATICAL DOUBLE-STRUCK SMALL G +1D559 MATHEMATICAL DOUBLE-STRUCK SMALL H +1D55A MATHEMATICAL DOUBLE-STRUCK SMALL I +1D55B MATHEMATICAL DOUBLE-STRUCK SMALL J +1D55C MATHEMATICAL DOUBLE-STRUCK SMALL K +1D55D MATHEMATICAL DOUBLE-STRUCK SMALL L +1D55E MATHEMATICAL DOUBLE-STRUCK SMALL M +1D55F MATHEMATICAL DOUBLE-STRUCK SMALL N +1D560 MATHEMATICAL DOUBLE-STRUCK SMALL O +1D561 MATHEMATICAL DOUBLE-STRUCK SMALL P +1D562 MATHEMATICAL DOUBLE-STRUCK SMALL Q +1D563 MATHEMATICAL DOUBLE-STRUCK SMALL R +1D564 MATHEMATICAL DOUBLE-STRUCK SMALL S +1D565 MATHEMATICAL DOUBLE-STRUCK SMALL T +1D566 MATHEMATICAL DOUBLE-STRUCK SMALL U +1D567 MATHEMATICAL DOUBLE-STRUCK SMALL V +1D568 MATHEMATICAL DOUBLE-STRUCK SMALL W +1D569 MATHEMATICAL DOUBLE-STRUCK SMALL X +1D56A MATHEMATICAL DOUBLE-STRUCK SMALL Y +1D56B MATHEMATICAL DOUBLE-STRUCK SMALL Z +1D56C MATHEMATICAL BOLD FRAKTUR CAPITAL A +1D56D MATHEMATICAL BOLD FRAKTUR CAPITAL B +1D56E MATHEMATICAL BOLD FRAKTUR CAPITAL C +1D56F MATHEMATICAL BOLD FRAKTUR CAPITAL D +1D570 MATHEMATICAL BOLD FRAKTUR CAPITAL E +1D571 MATHEMATICAL BOLD FRAKTUR CAPITAL F +1D572 MATHEMATICAL BOLD FRAKTUR CAPITAL G +1D573 MATHEMATICAL BOLD FRAKTUR CAPITAL H +1D574 MATHEMATICAL BOLD FRAKTUR CAPITAL I +1D575 MATHEMATICAL BOLD FRAKTUR CAPITAL J +1D576 MATHEMATICAL BOLD FRAKTUR CAPITAL K +1D577 MATHEMATICAL BOLD FRAKTUR CAPITAL L +1D578 MATHEMATICAL BOLD FRAKTUR CAPITAL M +1D579 MATHEMATICAL BOLD FRAKTUR CAPITAL N +1D57A MATHEMATICAL BOLD FRAKTUR CAPITAL O +1D57B MATHEMATICAL BOLD FRAKTUR CAPITAL P +1D57C MATHEMATICAL BOLD FRAKTUR CAPITAL Q +1D57D MATHEMATICAL BOLD FRAKTUR CAPITAL R +1D57E MATHEMATICAL BOLD FRAKTUR CAPITAL S +1D57F MATHEMATICAL BOLD FRAKTUR CAPITAL T +1D580 MATHEMATICAL BOLD FRAKTUR CAPITAL U +1D581 MATHEMATICAL BOLD FRAKTUR CAPITAL V +1D582 MATHEMATICAL BOLD FRAKTUR CAPITAL W +1D583 MATHEMATICAL BOLD FRAKTUR CAPITAL X +1D584 MATHEMATICAL BOLD FRAKTUR CAPITAL Y +1D585 MATHEMATICAL BOLD FRAKTUR CAPITAL Z +1D586 MATHEMATICAL BOLD FRAKTUR SMALL A +1D587 MATHEMATICAL BOLD FRAKTUR SMALL B +1D588 MATHEMATICAL BOLD FRAKTUR SMALL C +1D589 MATHEMATICAL BOLD FRAKTUR SMALL D +1D58A MATHEMATICAL BOLD FRAKTUR SMALL E +1D58B MATHEMATICAL BOLD FRAKTUR SMALL F +1D58C MATHEMATICAL BOLD FRAKTUR SMALL G +1D58D MATHEMATICAL BOLD FRAKTUR SMALL H +1D58E MATHEMATICAL BOLD FRAKTUR SMALL I +1D58F MATHEMATICAL BOLD FRAKTUR SMALL J +1D590 MATHEMATICAL BOLD FRAKTUR SMALL K +1D591 MATHEMATICAL BOLD FRAKTUR SMALL L +1D592 MATHEMATICAL BOLD FRAKTUR SMALL M +1D593 MATHEMATICAL BOLD FRAKTUR SMALL N +1D594 MATHEMATICAL BOLD FRAKTUR SMALL O +1D595 MATHEMATICAL BOLD FRAKTUR SMALL P +1D596 MATHEMATICAL BOLD FRAKTUR SMALL Q +1D597 MATHEMATICAL BOLD FRAKTUR SMALL R +1D598 MATHEMATICAL BOLD FRAKTUR SMALL S +1D599 MATHEMATICAL BOLD FRAKTUR SMALL T +1D59A MATHEMATICAL BOLD FRAKTUR SMALL U +1D59B MATHEMATICAL BOLD FRAKTUR SMALL V +1D59C MATHEMATICAL BOLD FRAKTUR SMALL W +1D59D MATHEMATICAL BOLD FRAKTUR SMALL X +1D59E MATHEMATICAL BOLD FRAKTUR SMALL Y +1D59F MATHEMATICAL BOLD FRAKTUR SMALL Z +1D5A0 MATHEMATICAL SANS-SERIF CAPITAL A +1D5A1 MATHEMATICAL SANS-SERIF CAPITAL B +1D5A2 MATHEMATICAL SANS-SERIF CAPITAL C +1D5A3 MATHEMATICAL SANS-SERIF CAPITAL D +1D5A4 MATHEMATICAL SANS-SERIF CAPITAL E +1D5A5 MATHEMATICAL SANS-SERIF CAPITAL F +1D5A6 MATHEMATICAL SANS-SERIF CAPITAL G +1D5A7 MATHEMATICAL SANS-SERIF CAPITAL H +1D5A8 MATHEMATICAL SANS-SERIF CAPITAL I +1D5A9 MATHEMATICAL SANS-SERIF CAPITAL J +1D5AA MATHEMATICAL SANS-SERIF CAPITAL K +1D5AB MATHEMATICAL SANS-SERIF CAPITAL L +1D5AC MATHEMATICAL SANS-SERIF CAPITAL M +1D5AD MATHEMATICAL SANS-SERIF CAPITAL N +1D5AE MATHEMATICAL SANS-SERIF CAPITAL O +1D5AF MATHEMATICAL SANS-SERIF CAPITAL P +1D5B0 MATHEMATICAL SANS-SERIF CAPITAL Q +1D5B1 MATHEMATICAL SANS-SERIF CAPITAL R +1D5B2 MATHEMATICAL SANS-SERIF CAPITAL S +1D5B3 MATHEMATICAL SANS-SERIF CAPITAL T +1D5B4 MATHEMATICAL SANS-SERIF CAPITAL U +1D5B5 MATHEMATICAL SANS-SERIF CAPITAL V +1D5B6 MATHEMATICAL SANS-SERIF CAPITAL W +1D5B7 MATHEMATICAL SANS-SERIF CAPITAL X +1D5B8 MATHEMATICAL SANS-SERIF CAPITAL Y +1D5B9 MATHEMATICAL SANS-SERIF CAPITAL Z +1D5BA MATHEMATICAL SANS-SERIF SMALL A +1D5BB MATHEMATICAL SANS-SERIF SMALL B +1D5BC MATHEMATICAL SANS-SERIF SMALL C +1D5BD MATHEMATICAL SANS-SERIF SMALL D +1D5BE MATHEMATICAL SANS-SERIF SMALL E +1D5BF MATHEMATICAL SANS-SERIF SMALL F +1D5C0 MATHEMATICAL SANS-SERIF SMALL G +1D5C1 MATHEMATICAL SANS-SERIF SMALL H +1D5C2 MATHEMATICAL SANS-SERIF SMALL I +1D5C3 MATHEMATICAL SANS-SERIF SMALL J +1D5C4 MATHEMATICAL SANS-SERIF SMALL K +1D5C5 MATHEMATICAL SANS-SERIF SMALL L +1D5C6 MATHEMATICAL SANS-SERIF SMALL M +1D5C7 MATHEMATICAL SANS-SERIF SMALL N +1D5C8 MATHEMATICAL SANS-SERIF SMALL O +1D5C9 MATHEMATICAL SANS-SERIF SMALL P +1D5CA MATHEMATICAL SANS-SERIF SMALL Q +1D5CB MATHEMATICAL SANS-SERIF SMALL R +1D5CC MATHEMATICAL SANS-SERIF SMALL S +1D5CD MATHEMATICAL SANS-SERIF SMALL T +1D5CE MATHEMATICAL SANS-SERIF SMALL U +1D5CF MATHEMATICAL SANS-SERIF SMALL V +1D5D0 MATHEMATICAL SANS-SERIF SMALL W +1D5D1 MATHEMATICAL SANS-SERIF SMALL X +1D5D2 MATHEMATICAL SANS-SERIF SMALL Y +1D5D3 MATHEMATICAL SANS-SERIF SMALL Z +1D5D4 MATHEMATICAL SANS-SERIF BOLD CAPITAL A +1D5D5 MATHEMATICAL SANS-SERIF BOLD CAPITAL B +1D5D6 MATHEMATICAL SANS-SERIF BOLD CAPITAL C +1D5D7 MATHEMATICAL SANS-SERIF BOLD CAPITAL D +1D5D8 MATHEMATICAL SANS-SERIF BOLD CAPITAL E +1D5D9 MATHEMATICAL SANS-SERIF BOLD CAPITAL F +1D5DA MATHEMATICAL SANS-SERIF BOLD CAPITAL G +1D5DB MATHEMATICAL SANS-SERIF BOLD CAPITAL H +1D5DC MATHEMATICAL SANS-SERIF BOLD CAPITAL I +1D5DD MATHEMATICAL SANS-SERIF BOLD CAPITAL J +1D5DE MATHEMATICAL SANS-SERIF BOLD CAPITAL K +1D5DF MATHEMATICAL SANS-SERIF BOLD CAPITAL L +1D5E0 MATHEMATICAL SANS-SERIF BOLD CAPITAL M +1D5E1 MATHEMATICAL SANS-SERIF BOLD CAPITAL N +1D5E2 MATHEMATICAL SANS-SERIF BOLD CAPITAL O +1D5E3 MATHEMATICAL SANS-SERIF BOLD CAPITAL P +1D5E4 MATHEMATICAL SANS-SERIF BOLD CAPITAL Q +1D5E5 MATHEMATICAL SANS-SERIF BOLD CAPITAL R +1D5E6 MATHEMATICAL SANS-SERIF BOLD CAPITAL S +1D5E7 MATHEMATICAL SANS-SERIF BOLD CAPITAL T +1D5E8 MATHEMATICAL SANS-SERIF BOLD CAPITAL U +1D5E9 MATHEMATICAL SANS-SERIF BOLD CAPITAL V +1D5EA MATHEMATICAL SANS-SERIF BOLD CAPITAL W +1D5EB MATHEMATICAL SANS-SERIF BOLD CAPITAL X +1D5EC MATHEMATICAL SANS-SERIF BOLD CAPITAL Y +1D5ED MATHEMATICAL SANS-SERIF BOLD CAPITAL Z +1D5EE MATHEMATICAL SANS-SERIF BOLD SMALL A +1D5EF MATHEMATICAL SANS-SERIF BOLD SMALL B +1D5F0 MATHEMATICAL SANS-SERIF BOLD SMALL C +1D5F1 MATHEMATICAL SANS-SERIF BOLD SMALL D +1D5F2 MATHEMATICAL SANS-SERIF BOLD SMALL E +1D5F3 MATHEMATICAL SANS-SERIF BOLD SMALL F +1D5F4 MATHEMATICAL SANS-SERIF BOLD SMALL G +1D5F5 MATHEMATICAL SANS-SERIF BOLD SMALL H +1D5F6 MATHEMATICAL SANS-SERIF BOLD SMALL I +1D5F7 MATHEMATICAL SANS-SERIF BOLD SMALL J +1D5F8 MATHEMATICAL SANS-SERIF BOLD SMALL K +1D5F9 MATHEMATICAL SANS-SERIF BOLD SMALL L +1D5FA MATHEMATICAL SANS-SERIF BOLD SMALL M +1D5FB MATHEMATICAL SANS-SERIF BOLD SMALL N +1D5FC MATHEMATICAL SANS-SERIF BOLD SMALL O +1D5FD MATHEMATICAL SANS-SERIF BOLD SMALL P +1D5FE MATHEMATICAL SANS-SERIF BOLD SMALL Q +1D5FF MATHEMATICAL SANS-SERIF BOLD SMALL R +1D600 MATHEMATICAL SANS-SERIF BOLD SMALL S +1D601 MATHEMATICAL SANS-SERIF BOLD SMALL T +1D602 MATHEMATICAL SANS-SERIF BOLD SMALL U +1D603 MATHEMATICAL SANS-SERIF BOLD SMALL V +1D604 MATHEMATICAL SANS-SERIF BOLD SMALL W +1D605 MATHEMATICAL SANS-SERIF BOLD SMALL X +1D606 MATHEMATICAL SANS-SERIF BOLD SMALL Y +1D607 MATHEMATICAL SANS-SERIF BOLD SMALL Z +1D608 MATHEMATICAL SANS-SERIF ITALIC CAPITAL A +1D609 MATHEMATICAL SANS-SERIF ITALIC CAPITAL B +1D60A MATHEMATICAL SANS-SERIF ITALIC CAPITAL C +1D60B MATHEMATICAL SANS-SERIF ITALIC CAPITAL D +1D60C MATHEMATICAL SANS-SERIF ITALIC CAPITAL E +1D60D MATHEMATICAL SANS-SERIF ITALIC CAPITAL F +1D60E MATHEMATICAL SANS-SERIF ITALIC CAPITAL G +1D60F MATHEMATICAL SANS-SERIF ITALIC CAPITAL H +1D610 MATHEMATICAL SANS-SERIF ITALIC CAPITAL I +1D611 MATHEMATICAL SANS-SERIF ITALIC CAPITAL J +1D612 MATHEMATICAL SANS-SERIF ITALIC CAPITAL K +1D613 MATHEMATICAL SANS-SERIF ITALIC CAPITAL L +1D614 MATHEMATICAL SANS-SERIF ITALIC CAPITAL M +1D615 MATHEMATICAL SANS-SERIF ITALIC CAPITAL N +1D616 MATHEMATICAL SANS-SERIF ITALIC CAPITAL O +1D617 MATHEMATICAL SANS-SERIF ITALIC CAPITAL P +1D618 MATHEMATICAL SANS-SERIF ITALIC CAPITAL Q +1D619 MATHEMATICAL SANS-SERIF ITALIC CAPITAL R +1D61A MATHEMATICAL SANS-SERIF ITALIC CAPITAL S +1D61B MATHEMATICAL SANS-SERIF ITALIC CAPITAL T +1D61C MATHEMATICAL SANS-SERIF ITALIC CAPITAL U +1D61D MATHEMATICAL SANS-SERIF ITALIC CAPITAL V +1D61E MATHEMATICAL SANS-SERIF ITALIC CAPITAL W +1D61F MATHEMATICAL SANS-SERIF ITALIC CAPITAL X +1D620 MATHEMATICAL SANS-SERIF ITALIC CAPITAL Y +1D621 MATHEMATICAL SANS-SERIF ITALIC CAPITAL Z +1D622 MATHEMATICAL SANS-SERIF ITALIC SMALL A +1D623 MATHEMATICAL SANS-SERIF ITALIC SMALL B +1D624 MATHEMATICAL SANS-SERIF ITALIC SMALL C +1D625 MATHEMATICAL SANS-SERIF ITALIC SMALL D +1D626 MATHEMATICAL SANS-SERIF ITALIC SMALL E +1D627 MATHEMATICAL SANS-SERIF ITALIC SMALL F +1D628 MATHEMATICAL SANS-SERIF ITALIC SMALL G +1D629 MATHEMATICAL SANS-SERIF ITALIC SMALL H +1D62A MATHEMATICAL SANS-SERIF ITALIC SMALL I +1D62B MATHEMATICAL SANS-SERIF ITALIC SMALL J +1D62C MATHEMATICAL SANS-SERIF ITALIC SMALL K +1D62D MATHEMATICAL SANS-SERIF ITALIC SMALL L +1D62E MATHEMATICAL SANS-SERIF ITALIC SMALL M +1D62F MATHEMATICAL SANS-SERIF ITALIC SMALL N +1D630 MATHEMATICAL SANS-SERIF ITALIC SMALL O +1D631 MATHEMATICAL SANS-SERIF ITALIC SMALL P +1D632 MATHEMATICAL SANS-SERIF ITALIC SMALL Q +1D633 MATHEMATICAL SANS-SERIF ITALIC SMALL R +1D634 MATHEMATICAL SANS-SERIF ITALIC SMALL S +1D635 MATHEMATICAL SANS-SERIF ITALIC SMALL T +1D636 MATHEMATICAL SANS-SERIF ITALIC SMALL U +1D637 MATHEMATICAL SANS-SERIF ITALIC SMALL V +1D638 MATHEMATICAL SANS-SERIF ITALIC SMALL W +1D639 MATHEMATICAL SANS-SERIF ITALIC SMALL X +1D63A MATHEMATICAL SANS-SERIF ITALIC SMALL Y +1D63B MATHEMATICAL SANS-SERIF ITALIC SMALL Z +1D63C MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL A +1D63D MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL B +1D63E MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL C +1D63F MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL D +1D640 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E +1D641 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL F +1D642 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL G +1D643 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL H +1D644 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL I +1D645 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL J +1D646 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL K +1D647 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL L +1D648 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL M +1D649 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL N +1D64A MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL O +1D64B MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL P +1D64C MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Q +1D64D MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL R +1D64E MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL S +1D64F MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL T +1D650 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL U +1D651 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL V +1D652 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL W +1D653 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL X +1D654 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Y +1D655 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Z +1D656 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A +1D657 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL B +1D658 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL C +1D659 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL D +1D65A MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E +1D65B MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL F +1D65C MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL G +1D65D MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL H +1D65E MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I +1D65F MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J +1D660 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL K +1D661 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL L +1D662 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL M +1D663 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL N +1D664 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL O +1D665 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL P +1D666 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Q +1D667 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL R +1D668 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL S +1D669 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL T +1D66A MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL U +1D66B MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL V +1D66C MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL W +1D66D MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL X +1D66E MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Y +1D66F MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z +1D670 MATHEMATICAL MONOSPACE CAPITAL A +1D671 MATHEMATICAL MONOSPACE CAPITAL B +1D672 MATHEMATICAL MONOSPACE CAPITAL C +1D673 MATHEMATICAL MONOSPACE CAPITAL D +1D674 MATHEMATICAL MONOSPACE CAPITAL E +1D675 MATHEMATICAL MONOSPACE CAPITAL F +1D676 MATHEMATICAL MONOSPACE CAPITAL G +1D677 MATHEMATICAL MONOSPACE CAPITAL H +1D678 MATHEMATICAL MONOSPACE CAPITAL I +1D679 MATHEMATICAL MONOSPACE CAPITAL J +1D67A MATHEMATICAL MONOSPACE CAPITAL K +1D67B MATHEMATICAL MONOSPACE CAPITAL L +1D67C MATHEMATICAL MONOSPACE CAPITAL M +1D67D MATHEMATICAL MONOSPACE CAPITAL N +1D67E MATHEMATICAL MONOSPACE CAPITAL O +1D67F MATHEMATICAL MONOSPACE CAPITAL P +1D680 MATHEMATICAL MONOSPACE CAPITAL Q +1D681 MATHEMATICAL MONOSPACE CAPITAL R +1D682 MATHEMATICAL MONOSPACE CAPITAL S +1D683 MATHEMATICAL MONOSPACE CAPITAL T +1D684 MATHEMATICAL MONOSPACE CAPITAL U +1D685 MATHEMATICAL MONOSPACE CAPITAL V +1D686 MATHEMATICAL MONOSPACE CAPITAL W +1D687 MATHEMATICAL MONOSPACE CAPITAL X +1D688 MATHEMATICAL MONOSPACE CAPITAL Y +1D689 MATHEMATICAL MONOSPACE CAPITAL Z +1D68A MATHEMATICAL MONOSPACE SMALL A +1D68B MATHEMATICAL MONOSPACE SMALL B +1D68C MATHEMATICAL MONOSPACE SMALL C +1D68D MATHEMATICAL MONOSPACE SMALL D +1D68E MATHEMATICAL MONOSPACE SMALL E +1D68F MATHEMATICAL MONOSPACE SMALL F +1D690 MATHEMATICAL MONOSPACE SMALL G +1D691 MATHEMATICAL MONOSPACE SMALL H +1D692 MATHEMATICAL MONOSPACE SMALL I +1D693 MATHEMATICAL MONOSPACE SMALL J +1D694 MATHEMATICAL MONOSPACE SMALL K +1D695 MATHEMATICAL MONOSPACE SMALL L +1D696 MATHEMATICAL MONOSPACE SMALL M +1D697 MATHEMATICAL MONOSPACE SMALL N +1D698 MATHEMATICAL MONOSPACE SMALL O +1D699 MATHEMATICAL MONOSPACE SMALL P +1D69A MATHEMATICAL MONOSPACE SMALL Q +1D69B MATHEMATICAL MONOSPACE SMALL R +1D69C MATHEMATICAL MONOSPACE SMALL S +1D69D MATHEMATICAL MONOSPACE SMALL T +1D69E MATHEMATICAL MONOSPACE SMALL U +1D69F MATHEMATICAL MONOSPACE SMALL V +1D6A0 MATHEMATICAL MONOSPACE SMALL W +1D6A1 MATHEMATICAL MONOSPACE SMALL X +1D6A2 MATHEMATICAL MONOSPACE SMALL Y +1D6A3 MATHEMATICAL MONOSPACE SMALL Z +1D6A8 MATHEMATICAL BOLD CAPITAL ALPHA +1D6A9 MATHEMATICAL BOLD CAPITAL BETA +1D6AA MATHEMATICAL BOLD CAPITAL GAMMA +1D6AB MATHEMATICAL BOLD CAPITAL DELTA +1D6AC MATHEMATICAL BOLD CAPITAL EPSILON +1D6AD MATHEMATICAL BOLD CAPITAL ZETA +1D6AE MATHEMATICAL BOLD CAPITAL ETA +1D6AF MATHEMATICAL BOLD CAPITAL THETA +1D6B0 MATHEMATICAL BOLD CAPITAL IOTA +1D6B1 MATHEMATICAL BOLD CAPITAL KAPPA +1D6B2 MATHEMATICAL BOLD CAPITAL LAMDA +1D6B3 MATHEMATICAL BOLD CAPITAL MU +1D6B4 MATHEMATICAL BOLD CAPITAL NU +1D6B5 MATHEMATICAL BOLD CAPITAL XI +1D6B6 MATHEMATICAL BOLD CAPITAL OMICRON +1D6B7 MATHEMATICAL BOLD CAPITAL PI +1D6B8 MATHEMATICAL BOLD CAPITAL RHO +1D6B9 MATHEMATICAL BOLD CAPITAL THETA SYMBOL +1D6BA MATHEMATICAL BOLD CAPITAL SIGMA +1D6BB MATHEMATICAL BOLD CAPITAL TAU +1D6BC MATHEMATICAL BOLD CAPITAL UPSILON +1D6BD MATHEMATICAL BOLD CAPITAL PHI +1D6BE MATHEMATICAL BOLD CAPITAL CHI +1D6BF MATHEMATICAL BOLD CAPITAL PSI +1D6C0 MATHEMATICAL BOLD CAPITAL OMEGA +1D6C1 MATHEMATICAL BOLD NABLA +1D6C2 MATHEMATICAL BOLD SMALL ALPHA +1D6C3 MATHEMATICAL BOLD SMALL BETA +1D6C4 MATHEMATICAL BOLD SMALL GAMMA +1D6C5 MATHEMATICAL BOLD SMALL DELTA +1D6C6 MATHEMATICAL BOLD SMALL EPSILON +1D6C7 MATHEMATICAL BOLD SMALL ZETA +1D6C8 MATHEMATICAL BOLD SMALL ETA +1D6C9 MATHEMATICAL BOLD SMALL THETA +1D6CA MATHEMATICAL BOLD SMALL IOTA +1D6CB MATHEMATICAL BOLD SMALL KAPPA +1D6CC MATHEMATICAL BOLD SMALL LAMDA +1D6CD MATHEMATICAL BOLD SMALL MU +1D6CE MATHEMATICAL BOLD SMALL NU +1D6CF MATHEMATICAL BOLD SMALL XI +1D6D0 MATHEMATICAL BOLD SMALL OMICRON +1D6D1 MATHEMATICAL BOLD SMALL PI +1D6D2 MATHEMATICAL BOLD SMALL RHO +1D6D3 MATHEMATICAL BOLD SMALL FINAL SIGMA +1D6D4 MATHEMATICAL BOLD SMALL SIGMA +1D6D5 MATHEMATICAL BOLD SMALL TAU +1D6D6 MATHEMATICAL BOLD SMALL UPSILON +1D6D7 MATHEMATICAL BOLD SMALL PHI +1D6D8 MATHEMATICAL BOLD SMALL CHI +1D6D9 MATHEMATICAL BOLD SMALL PSI +1D6DA MATHEMATICAL BOLD SMALL OMEGA +1D6DB MATHEMATICAL BOLD PARTIAL DIFFERENTIAL +1D6DC MATHEMATICAL BOLD EPSILON SYMBOL +1D6DD MATHEMATICAL BOLD THETA SYMBOL +1D6DE MATHEMATICAL BOLD KAPPA SYMBOL +1D6DF MATHEMATICAL BOLD PHI SYMBOL +1D6E0 MATHEMATICAL BOLD RHO SYMBOL +1D6E1 MATHEMATICAL BOLD PI SYMBOL +1D6E2 MATHEMATICAL ITALIC CAPITAL ALPHA +1D6E3 MATHEMATICAL ITALIC CAPITAL BETA +1D6E4 MATHEMATICAL ITALIC CAPITAL GAMMA +1D6E5 MATHEMATICAL ITALIC CAPITAL DELTA +1D6E6 MATHEMATICAL ITALIC CAPITAL EPSILON +1D6E7 MATHEMATICAL ITALIC CAPITAL ZETA +1D6E8 MATHEMATICAL ITALIC CAPITAL ETA +1D6E9 MATHEMATICAL ITALIC CAPITAL THETA +1D6EA MATHEMATICAL ITALIC CAPITAL IOTA +1D6EB MATHEMATICAL ITALIC CAPITAL KAPPA +1D6EC MATHEMATICAL ITALIC CAPITAL LAMDA +1D6ED MATHEMATICAL ITALIC CAPITAL MU +1D6EE MATHEMATICAL ITALIC CAPITAL NU +1D6EF MATHEMATICAL ITALIC CAPITAL XI +1D6F0 MATHEMATICAL ITALIC CAPITAL OMICRON +1D6F1 MATHEMATICAL ITALIC CAPITAL PI +1D6F2 MATHEMATICAL ITALIC CAPITAL RHO +1D6F3 MATHEMATICAL ITALIC CAPITAL THETA SYMBOL +1D6F4 MATHEMATICAL ITALIC CAPITAL SIGMA +1D6F5 MATHEMATICAL ITALIC CAPITAL TAU +1D6F6 MATHEMATICAL ITALIC CAPITAL UPSILON +1D6F7 MATHEMATICAL ITALIC CAPITAL PHI +1D6F8 MATHEMATICAL ITALIC CAPITAL CHI +1D6F9 MATHEMATICAL ITALIC CAPITAL PSI +1D6FA MATHEMATICAL ITALIC CAPITAL OMEGA +1D6FB MATHEMATICAL ITALIC NABLA +1D6FC MATHEMATICAL ITALIC SMALL ALPHA +1D6FD MATHEMATICAL ITALIC SMALL BETA +1D6FE MATHEMATICAL ITALIC SMALL GAMMA +1D6FF MATHEMATICAL ITALIC SMALL DELTA +1D700 MATHEMATICAL ITALIC SMALL EPSILON +1D701 MATHEMATICAL ITALIC SMALL ZETA +1D702 MATHEMATICAL ITALIC SMALL ETA +1D703 MATHEMATICAL ITALIC SMALL THETA +1D704 MATHEMATICAL ITALIC SMALL IOTA +1D705 MATHEMATICAL ITALIC SMALL KAPPA +1D706 MATHEMATICAL ITALIC SMALL LAMDA +1D707 MATHEMATICAL ITALIC SMALL MU +1D708 MATHEMATICAL ITALIC SMALL NU +1D709 MATHEMATICAL ITALIC SMALL XI +1D70A MATHEMATICAL ITALIC SMALL OMICRON +1D70B MATHEMATICAL ITALIC SMALL PI +1D70C MATHEMATICAL ITALIC SMALL RHO +1D70D MATHEMATICAL ITALIC SMALL FINAL SIGMA +1D70E MATHEMATICAL ITALIC SMALL SIGMA +1D70F MATHEMATICAL ITALIC SMALL TAU +1D710 MATHEMATICAL ITALIC SMALL UPSILON +1D711 MATHEMATICAL ITALIC SMALL PHI +1D712 MATHEMATICAL ITALIC SMALL CHI +1D713 MATHEMATICAL ITALIC SMALL PSI +1D714 MATHEMATICAL ITALIC SMALL OMEGA +1D715 MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL +1D716 MATHEMATICAL ITALIC EPSILON SYMBOL +1D717 MATHEMATICAL ITALIC THETA SYMBOL +1D718 MATHEMATICAL ITALIC KAPPA SYMBOL +1D719 MATHEMATICAL ITALIC PHI SYMBOL +1D71A MATHEMATICAL ITALIC RHO SYMBOL +1D71B MATHEMATICAL ITALIC PI SYMBOL +1D71C MATHEMATICAL BOLD ITALIC CAPITAL ALPHA +1D71D MATHEMATICAL BOLD ITALIC CAPITAL BETA +1D71E MATHEMATICAL BOLD ITALIC CAPITAL GAMMA +1D71F MATHEMATICAL BOLD ITALIC CAPITAL DELTA +1D720 MATHEMATICAL BOLD ITALIC CAPITAL EPSILON +1D721 MATHEMATICAL BOLD ITALIC CAPITAL ZETA +1D722 MATHEMATICAL BOLD ITALIC CAPITAL ETA +1D723 MATHEMATICAL BOLD ITALIC CAPITAL THETA +1D724 MATHEMATICAL BOLD ITALIC CAPITAL IOTA +1D725 MATHEMATICAL BOLD ITALIC CAPITAL KAPPA +1D726 MATHEMATICAL BOLD ITALIC CAPITAL LAMDA +1D727 MATHEMATICAL BOLD ITALIC CAPITAL MU +1D728 MATHEMATICAL BOLD ITALIC CAPITAL NU +1D729 MATHEMATICAL BOLD ITALIC CAPITAL XI +1D72A MATHEMATICAL BOLD ITALIC CAPITAL OMICRON +1D72B MATHEMATICAL BOLD ITALIC CAPITAL PI +1D72C MATHEMATICAL BOLD ITALIC CAPITAL RHO +1D72D MATHEMATICAL BOLD ITALIC CAPITAL THETA SYMBOL +1D72E MATHEMATICAL BOLD ITALIC CAPITAL SIGMA +1D72F MATHEMATICAL BOLD ITALIC CAPITAL TAU +1D730 MATHEMATICAL BOLD ITALIC CAPITAL UPSILON +1D731 MATHEMATICAL BOLD ITALIC CAPITAL PHI +1D732 MATHEMATICAL BOLD ITALIC CAPITAL CHI +1D733 MATHEMATICAL BOLD ITALIC CAPITAL PSI +1D734 MATHEMATICAL BOLD ITALIC CAPITAL OMEGA +1D735 MATHEMATICAL BOLD ITALIC NABLA +1D736 MATHEMATICAL BOLD ITALIC SMALL ALPHA +1D737 MATHEMATICAL BOLD ITALIC SMALL BETA +1D738 MATHEMATICAL BOLD ITALIC SMALL GAMMA +1D739 MATHEMATICAL BOLD ITALIC SMALL DELTA +1D73A MATHEMATICAL BOLD ITALIC SMALL EPSILON +1D73B MATHEMATICAL BOLD ITALIC SMALL ZETA +1D73C MATHEMATICAL BOLD ITALIC SMALL ETA +1D73D MATHEMATICAL BOLD ITALIC SMALL THETA +1D73E MATHEMATICAL BOLD ITALIC SMALL IOTA +1D73F MATHEMATICAL BOLD ITALIC SMALL KAPPA +1D740 MATHEMATICAL BOLD ITALIC SMALL LAMDA +1D741 MATHEMATICAL BOLD ITALIC SMALL MU +1D742 MATHEMATICAL BOLD ITALIC SMALL NU +1D743 MATHEMATICAL BOLD ITALIC SMALL XI +1D744 MATHEMATICAL BOLD ITALIC SMALL OMICRON +1D745 MATHEMATICAL BOLD ITALIC SMALL PI +1D746 MATHEMATICAL BOLD ITALIC SMALL RHO +1D747 MATHEMATICAL BOLD ITALIC SMALL FINAL SIGMA +1D748 MATHEMATICAL BOLD ITALIC SMALL SIGMA +1D749 MATHEMATICAL BOLD ITALIC SMALL TAU +1D74A MATHEMATICAL BOLD ITALIC SMALL UPSILON +1D74B MATHEMATICAL BOLD ITALIC SMALL PHI +1D74C MATHEMATICAL BOLD ITALIC SMALL CHI +1D74D MATHEMATICAL BOLD ITALIC SMALL PSI +1D74E MATHEMATICAL BOLD ITALIC SMALL OMEGA +1D74F MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL +1D750 MATHEMATICAL BOLD ITALIC EPSILON SYMBOL +1D751 MATHEMATICAL BOLD ITALIC THETA SYMBOL +1D752 MATHEMATICAL BOLD ITALIC KAPPA SYMBOL +1D753 MATHEMATICAL BOLD ITALIC PHI SYMBOL +1D754 MATHEMATICAL BOLD ITALIC RHO SYMBOL +1D755 MATHEMATICAL BOLD ITALIC PI SYMBOL +1D756 MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA +1D757 MATHEMATICAL SANS-SERIF BOLD CAPITAL BETA +1D758 MATHEMATICAL SANS-SERIF BOLD CAPITAL GAMMA +1D759 MATHEMATICAL SANS-SERIF BOLD CAPITAL DELTA +1D75A MATHEMATICAL SANS-SERIF BOLD CAPITAL EPSILON +1D75B MATHEMATICAL SANS-SERIF BOLD CAPITAL ZETA +1D75C MATHEMATICAL SANS-SERIF BOLD CAPITAL ETA +1D75D MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA +1D75E MATHEMATICAL SANS-SERIF BOLD CAPITAL IOTA +1D75F MATHEMATICAL SANS-SERIF BOLD CAPITAL KAPPA +1D760 MATHEMATICAL SANS-SERIF BOLD CAPITAL LAMDA +1D761 MATHEMATICAL SANS-SERIF BOLD CAPITAL MU +1D762 MATHEMATICAL SANS-SERIF BOLD CAPITAL NU +1D763 MATHEMATICAL SANS-SERIF BOLD CAPITAL XI +1D764 MATHEMATICAL SANS-SERIF BOLD CAPITAL OMICRON +1D765 MATHEMATICAL SANS-SERIF BOLD CAPITAL PI +1D766 MATHEMATICAL SANS-SERIF BOLD CAPITAL RHO +1D767 MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA SYMBOL +1D768 MATHEMATICAL SANS-SERIF BOLD CAPITAL SIGMA +1D769 MATHEMATICAL SANS-SERIF BOLD CAPITAL TAU +1D76A MATHEMATICAL SANS-SERIF BOLD CAPITAL UPSILON +1D76B MATHEMATICAL SANS-SERIF BOLD CAPITAL PHI +1D76C MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI +1D76D MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI +1D76E MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA +1D76F MATHEMATICAL SANS-SERIF BOLD NABLA +1D770 MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA +1D771 MATHEMATICAL SANS-SERIF BOLD SMALL BETA +1D772 MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA +1D773 MATHEMATICAL SANS-SERIF BOLD SMALL DELTA +1D774 MATHEMATICAL SANS-SERIF BOLD SMALL EPSILON +1D775 MATHEMATICAL SANS-SERIF BOLD SMALL ZETA +1D776 MATHEMATICAL SANS-SERIF BOLD SMALL ETA +1D777 MATHEMATICAL SANS-SERIF BOLD SMALL THETA +1D778 MATHEMATICAL SANS-SERIF BOLD SMALL IOTA +1D779 MATHEMATICAL SANS-SERIF BOLD SMALL KAPPA +1D77A MATHEMATICAL SANS-SERIF BOLD SMALL LAMDA +1D77B MATHEMATICAL SANS-SERIF BOLD SMALL MU +1D77C MATHEMATICAL SANS-SERIF BOLD SMALL NU +1D77D MATHEMATICAL SANS-SERIF BOLD SMALL XI +1D77E MATHEMATICAL SANS-SERIF BOLD SMALL OMICRON +1D77F MATHEMATICAL SANS-SERIF BOLD SMALL PI +1D780 MATHEMATICAL SANS-SERIF BOLD SMALL RHO +1D781 MATHEMATICAL SANS-SERIF BOLD SMALL FINAL SIGMA +1D782 MATHEMATICAL SANS-SERIF BOLD SMALL SIGMA +1D783 MATHEMATICAL SANS-SERIF BOLD SMALL TAU +1D784 MATHEMATICAL SANS-SERIF BOLD SMALL UPSILON +1D785 MATHEMATICAL SANS-SERIF BOLD SMALL PHI +1D786 MATHEMATICAL SANS-SERIF BOLD SMALL CHI +1D787 MATHEMATICAL SANS-SERIF BOLD SMALL PSI +1D788 MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA +1D789 MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL +1D78A MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL +1D78B MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL +1D78C MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL +1D78D MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL +1D78E MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL +1D78F MATHEMATICAL SANS-SERIF BOLD PI SYMBOL +1D790 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA +1D791 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA +1D792 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA +1D793 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL DELTA +1D794 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL EPSILON +1D795 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ZETA +1D796 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ETA +1D797 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA +1D798 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL IOTA +1D799 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL KAPPA +1D79A MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL LAMDA +1D79B MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL MU +1D79C MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL NU +1D79D MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL XI +1D79E MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMICRON +1D79F MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PI +1D7A0 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL RHO +1D7A1 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA SYMBOL +1D7A2 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL SIGMA +1D7A3 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL TAU +1D7A4 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL UPSILON +1D7A5 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PHI +1D7A6 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI +1D7A7 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI +1D7A8 MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA +1D7A9 MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA +1D7AA MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA +1D7AB MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA +1D7AC MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA +1D7AD MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL DELTA +1D7AE MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL EPSILON +1D7AF MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ZETA +1D7B0 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ETA +1D7B1 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL THETA +1D7B2 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL IOTA +1D7B3 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL KAPPA +1D7B4 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL LAMDA +1D7B5 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL MU +1D7B6 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL NU +1D7B7 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL XI +1D7B8 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMICRON +1D7B9 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PI +1D7BA MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL RHO +1D7BB MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL FINAL SIGMA +1D7BC MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL SIGMA +1D7BD MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL TAU +1D7BE MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL UPSILON +1D7BF MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PHI +1D7C0 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI +1D7C1 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI +1D7C2 MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA +1D7C3 MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL +1D7C4 MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL +1D7C5 MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL +1D7C6 MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL +1D7C7 MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL +1D7C8 MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL +1D7C9 MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL +1D7CE MATHEMATICAL BOLD DIGIT ZERO +1D7CF MATHEMATICAL BOLD DIGIT ONE +1D7D0 MATHEMATICAL BOLD DIGIT TWO +1D7D1 MATHEMATICAL BOLD DIGIT THREE +1D7D2 MATHEMATICAL BOLD DIGIT FOUR +1D7D3 MATHEMATICAL BOLD DIGIT FIVE +1D7D4 MATHEMATICAL BOLD DIGIT SIX +1D7D5 MATHEMATICAL BOLD DIGIT SEVEN +1D7D6 MATHEMATICAL BOLD DIGIT EIGHT +1D7D7 MATHEMATICAL BOLD DIGIT NINE +1D7D8 MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO +1D7D9 MATHEMATICAL DOUBLE-STRUCK DIGIT ONE +1D7DA MATHEMATICAL DOUBLE-STRUCK DIGIT TWO +1D7DB MATHEMATICAL DOUBLE-STRUCK DIGIT THREE +1D7DC MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR +1D7DD MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE +1D7DE MATHEMATICAL DOUBLE-STRUCK DIGIT SIX +1D7DF MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN +1D7E0 MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT +1D7E1 MATHEMATICAL DOUBLE-STRUCK DIGIT NINE +1D7E2 MATHEMATICAL SANS-SERIF DIGIT ZERO +1D7E3 MATHEMATICAL SANS-SERIF DIGIT ONE +1D7E4 MATHEMATICAL SANS-SERIF DIGIT TWO +1D7E5 MATHEMATICAL SANS-SERIF DIGIT THREE +1D7E6 MATHEMATICAL SANS-SERIF DIGIT FOUR +1D7E7 MATHEMATICAL SANS-SERIF DIGIT FIVE +1D7E8 MATHEMATICAL SANS-SERIF DIGIT SIX +1D7E9 MATHEMATICAL SANS-SERIF DIGIT SEVEN +1D7EA MATHEMATICAL SANS-SERIF DIGIT EIGHT +1D7EB MATHEMATICAL SANS-SERIF DIGIT NINE +1D7EC MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO +1D7ED MATHEMATICAL SANS-SERIF BOLD DIGIT ONE +1D7EE MATHEMATICAL SANS-SERIF BOLD DIGIT TWO +1D7EF MATHEMATICAL SANS-SERIF BOLD DIGIT THREE +1D7F0 MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR +1D7F1 MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE +1D7F2 MATHEMATICAL SANS-SERIF BOLD DIGIT SIX +1D7F3 MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN +1D7F4 MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT +1D7F5 MATHEMATICAL SANS-SERIF BOLD DIGIT NINE +1D7F6 MATHEMATICAL MONOSPACE DIGIT ZERO +1D7F7 MATHEMATICAL MONOSPACE DIGIT ONE +1D7F8 MATHEMATICAL MONOSPACE DIGIT TWO +1D7F9 MATHEMATICAL MONOSPACE DIGIT THREE +1D7FA MATHEMATICAL MONOSPACE DIGIT FOUR +1D7FB MATHEMATICAL MONOSPACE DIGIT FIVE +1D7FC MATHEMATICAL MONOSPACE DIGIT SIX +1D7FD MATHEMATICAL MONOSPACE DIGIT SEVEN +1D7FE MATHEMATICAL MONOSPACE DIGIT EIGHT +1D7FF MATHEMATICAL MONOSPACE DIGIT NINE +20000 2A6D6 CJK Ideograph Extension B +2F800 CJK COMPATIBILITY IDEOGRAPH-2F800 +2F801 CJK COMPATIBILITY IDEOGRAPH-2F801 +2F802 CJK COMPATIBILITY IDEOGRAPH-2F802 +2F803 CJK COMPATIBILITY IDEOGRAPH-2F803 +2F804 CJK COMPATIBILITY IDEOGRAPH-2F804 +2F805 CJK COMPATIBILITY IDEOGRAPH-2F805 +2F806 CJK COMPATIBILITY IDEOGRAPH-2F806 +2F807 CJK COMPATIBILITY IDEOGRAPH-2F807 +2F808 CJK COMPATIBILITY IDEOGRAPH-2F808 +2F809 CJK COMPATIBILITY IDEOGRAPH-2F809 +2F80A CJK COMPATIBILITY IDEOGRAPH-2F80A +2F80B CJK COMPATIBILITY IDEOGRAPH-2F80B +2F80C CJK COMPATIBILITY IDEOGRAPH-2F80C +2F80D CJK COMPATIBILITY IDEOGRAPH-2F80D +2F80E CJK COMPATIBILITY IDEOGRAPH-2F80E +2F80F CJK COMPATIBILITY IDEOGRAPH-2F80F +2F810 CJK COMPATIBILITY IDEOGRAPH-2F810 +2F811 CJK COMPATIBILITY IDEOGRAPH-2F811 +2F812 CJK COMPATIBILITY IDEOGRAPH-2F812 +2F813 CJK COMPATIBILITY IDEOGRAPH-2F813 +2F814 CJK COMPATIBILITY IDEOGRAPH-2F814 +2F815 CJK COMPATIBILITY IDEOGRAPH-2F815 +2F816 CJK COMPATIBILITY IDEOGRAPH-2F816 +2F817 CJK COMPATIBILITY IDEOGRAPH-2F817 +2F818 CJK COMPATIBILITY IDEOGRAPH-2F818 +2F819 CJK COMPATIBILITY IDEOGRAPH-2F819 +2F81A CJK COMPATIBILITY IDEOGRAPH-2F81A +2F81B CJK COMPATIBILITY IDEOGRAPH-2F81B +2F81C CJK COMPATIBILITY IDEOGRAPH-2F81C +2F81D CJK COMPATIBILITY IDEOGRAPH-2F81D +2F81E CJK COMPATIBILITY IDEOGRAPH-2F81E +2F81F CJK COMPATIBILITY IDEOGRAPH-2F81F +2F820 CJK COMPATIBILITY IDEOGRAPH-2F820 +2F821 CJK COMPATIBILITY IDEOGRAPH-2F821 +2F822 CJK COMPATIBILITY IDEOGRAPH-2F822 +2F823 CJK COMPATIBILITY IDEOGRAPH-2F823 +2F824 CJK COMPATIBILITY IDEOGRAPH-2F824 +2F825 CJK COMPATIBILITY IDEOGRAPH-2F825 +2F826 CJK COMPATIBILITY IDEOGRAPH-2F826 +2F827 CJK COMPATIBILITY IDEOGRAPH-2F827 +2F828 CJK COMPATIBILITY IDEOGRAPH-2F828 +2F829 CJK COMPATIBILITY IDEOGRAPH-2F829 +2F82A CJK COMPATIBILITY IDEOGRAPH-2F82A +2F82B CJK COMPATIBILITY IDEOGRAPH-2F82B +2F82C CJK COMPATIBILITY IDEOGRAPH-2F82C +2F82D CJK COMPATIBILITY IDEOGRAPH-2F82D +2F82E CJK COMPATIBILITY IDEOGRAPH-2F82E +2F82F CJK COMPATIBILITY IDEOGRAPH-2F82F +2F830 CJK COMPATIBILITY IDEOGRAPH-2F830 +2F831 CJK COMPATIBILITY IDEOGRAPH-2F831 +2F832 CJK COMPATIBILITY IDEOGRAPH-2F832 +2F833 CJK COMPATIBILITY IDEOGRAPH-2F833 +2F834 CJK COMPATIBILITY IDEOGRAPH-2F834 +2F835 CJK COMPATIBILITY IDEOGRAPH-2F835 +2F836 CJK COMPATIBILITY IDEOGRAPH-2F836 +2F837 CJK COMPATIBILITY IDEOGRAPH-2F837 +2F838 CJK COMPATIBILITY IDEOGRAPH-2F838 +2F839 CJK COMPATIBILITY IDEOGRAPH-2F839 +2F83A CJK COMPATIBILITY IDEOGRAPH-2F83A +2F83B CJK COMPATIBILITY IDEOGRAPH-2F83B +2F83C CJK COMPATIBILITY IDEOGRAPH-2F83C +2F83D CJK COMPATIBILITY IDEOGRAPH-2F83D +2F83E CJK COMPATIBILITY IDEOGRAPH-2F83E +2F83F CJK COMPATIBILITY IDEOGRAPH-2F83F +2F840 CJK COMPATIBILITY IDEOGRAPH-2F840 +2F841 CJK COMPATIBILITY IDEOGRAPH-2F841 +2F842 CJK COMPATIBILITY IDEOGRAPH-2F842 +2F843 CJK COMPATIBILITY IDEOGRAPH-2F843 +2F844 CJK COMPATIBILITY IDEOGRAPH-2F844 +2F845 CJK COMPATIBILITY IDEOGRAPH-2F845 +2F846 CJK COMPATIBILITY IDEOGRAPH-2F846 +2F847 CJK COMPATIBILITY IDEOGRAPH-2F847 +2F848 CJK COMPATIBILITY IDEOGRAPH-2F848 +2F849 CJK COMPATIBILITY IDEOGRAPH-2F849 +2F84A CJK COMPATIBILITY IDEOGRAPH-2F84A +2F84B CJK COMPATIBILITY IDEOGRAPH-2F84B +2F84C CJK COMPATIBILITY IDEOGRAPH-2F84C +2F84D CJK COMPATIBILITY IDEOGRAPH-2F84D +2F84E CJK COMPATIBILITY IDEOGRAPH-2F84E +2F84F CJK COMPATIBILITY IDEOGRAPH-2F84F +2F850 CJK COMPATIBILITY IDEOGRAPH-2F850 +2F851 CJK COMPATIBILITY IDEOGRAPH-2F851 +2F852 CJK COMPATIBILITY IDEOGRAPH-2F852 +2F853 CJK COMPATIBILITY IDEOGRAPH-2F853 +2F854 CJK COMPATIBILITY IDEOGRAPH-2F854 +2F855 CJK COMPATIBILITY IDEOGRAPH-2F855 +2F856 CJK COMPATIBILITY IDEOGRAPH-2F856 +2F857 CJK COMPATIBILITY IDEOGRAPH-2F857 +2F858 CJK COMPATIBILITY IDEOGRAPH-2F858 +2F859 CJK COMPATIBILITY IDEOGRAPH-2F859 +2F85A CJK COMPATIBILITY IDEOGRAPH-2F85A +2F85B CJK COMPATIBILITY IDEOGRAPH-2F85B +2F85C CJK COMPATIBILITY IDEOGRAPH-2F85C +2F85D CJK COMPATIBILITY IDEOGRAPH-2F85D +2F85E CJK COMPATIBILITY IDEOGRAPH-2F85E +2F85F CJK COMPATIBILITY IDEOGRAPH-2F85F +2F860 CJK COMPATIBILITY IDEOGRAPH-2F860 +2F861 CJK COMPATIBILITY IDEOGRAPH-2F861 +2F862 CJK COMPATIBILITY IDEOGRAPH-2F862 +2F863 CJK COMPATIBILITY IDEOGRAPH-2F863 +2F864 CJK COMPATIBILITY IDEOGRAPH-2F864 +2F865 CJK COMPATIBILITY IDEOGRAPH-2F865 +2F866 CJK COMPATIBILITY IDEOGRAPH-2F866 +2F867 CJK COMPATIBILITY IDEOGRAPH-2F867 +2F868 CJK COMPATIBILITY IDEOGRAPH-2F868 +2F869 CJK COMPATIBILITY IDEOGRAPH-2F869 +2F86A CJK COMPATIBILITY IDEOGRAPH-2F86A +2F86B CJK COMPATIBILITY IDEOGRAPH-2F86B +2F86C CJK COMPATIBILITY IDEOGRAPH-2F86C +2F86D CJK COMPATIBILITY IDEOGRAPH-2F86D +2F86E CJK COMPATIBILITY IDEOGRAPH-2F86E +2F86F CJK COMPATIBILITY IDEOGRAPH-2F86F +2F870 CJK COMPATIBILITY IDEOGRAPH-2F870 +2F871 CJK COMPATIBILITY IDEOGRAPH-2F871 +2F872 CJK COMPATIBILITY IDEOGRAPH-2F872 +2F873 CJK COMPATIBILITY IDEOGRAPH-2F873 +2F874 CJK COMPATIBILITY IDEOGRAPH-2F874 +2F875 CJK COMPATIBILITY IDEOGRAPH-2F875 +2F876 CJK COMPATIBILITY IDEOGRAPH-2F876 +2F877 CJK COMPATIBILITY IDEOGRAPH-2F877 +2F878 CJK COMPATIBILITY IDEOGRAPH-2F878 +2F879 CJK COMPATIBILITY IDEOGRAPH-2F879 +2F87A CJK COMPATIBILITY IDEOGRAPH-2F87A +2F87B CJK COMPATIBILITY IDEOGRAPH-2F87B +2F87C CJK COMPATIBILITY IDEOGRAPH-2F87C +2F87D CJK COMPATIBILITY IDEOGRAPH-2F87D +2F87E CJK COMPATIBILITY IDEOGRAPH-2F87E +2F87F CJK COMPATIBILITY IDEOGRAPH-2F87F +2F880 CJK COMPATIBILITY IDEOGRAPH-2F880 +2F881 CJK COMPATIBILITY IDEOGRAPH-2F881 +2F882 CJK COMPATIBILITY IDEOGRAPH-2F882 +2F883 CJK COMPATIBILITY IDEOGRAPH-2F883 +2F884 CJK COMPATIBILITY IDEOGRAPH-2F884 +2F885 CJK COMPATIBILITY IDEOGRAPH-2F885 +2F886 CJK COMPATIBILITY IDEOGRAPH-2F886 +2F887 CJK COMPATIBILITY IDEOGRAPH-2F887 +2F888 CJK COMPATIBILITY IDEOGRAPH-2F888 +2F889 CJK COMPATIBILITY IDEOGRAPH-2F889 +2F88A CJK COMPATIBILITY IDEOGRAPH-2F88A +2F88B CJK COMPATIBILITY IDEOGRAPH-2F88B +2F88C CJK COMPATIBILITY IDEOGRAPH-2F88C +2F88D CJK COMPATIBILITY IDEOGRAPH-2F88D +2F88E CJK COMPATIBILITY IDEOGRAPH-2F88E +2F88F CJK COMPATIBILITY IDEOGRAPH-2F88F +2F890 CJK COMPATIBILITY IDEOGRAPH-2F890 +2F891 CJK COMPATIBILITY IDEOGRAPH-2F891 +2F892 CJK COMPATIBILITY IDEOGRAPH-2F892 +2F893 CJK COMPATIBILITY IDEOGRAPH-2F893 +2F894 CJK COMPATIBILITY IDEOGRAPH-2F894 +2F895 CJK COMPATIBILITY IDEOGRAPH-2F895 +2F896 CJK COMPATIBILITY IDEOGRAPH-2F896 +2F897 CJK COMPATIBILITY IDEOGRAPH-2F897 +2F898 CJK COMPATIBILITY IDEOGRAPH-2F898 +2F899 CJK COMPATIBILITY IDEOGRAPH-2F899 +2F89A CJK COMPATIBILITY IDEOGRAPH-2F89A +2F89B CJK COMPATIBILITY IDEOGRAPH-2F89B +2F89C CJK COMPATIBILITY IDEOGRAPH-2F89C +2F89D CJK COMPATIBILITY IDEOGRAPH-2F89D +2F89E CJK COMPATIBILITY IDEOGRAPH-2F89E +2F89F CJK COMPATIBILITY IDEOGRAPH-2F89F +2F8A0 CJK COMPATIBILITY IDEOGRAPH-2F8A0 +2F8A1 CJK COMPATIBILITY IDEOGRAPH-2F8A1 +2F8A2 CJK COMPATIBILITY IDEOGRAPH-2F8A2 +2F8A3 CJK COMPATIBILITY IDEOGRAPH-2F8A3 +2F8A4 CJK COMPATIBILITY IDEOGRAPH-2F8A4 +2F8A5 CJK COMPATIBILITY IDEOGRAPH-2F8A5 +2F8A6 CJK COMPATIBILITY IDEOGRAPH-2F8A6 +2F8A7 CJK COMPATIBILITY IDEOGRAPH-2F8A7 +2F8A8 CJK COMPATIBILITY IDEOGRAPH-2F8A8 +2F8A9 CJK COMPATIBILITY IDEOGRAPH-2F8A9 +2F8AA CJK COMPATIBILITY IDEOGRAPH-2F8AA +2F8AB CJK COMPATIBILITY IDEOGRAPH-2F8AB +2F8AC CJK COMPATIBILITY IDEOGRAPH-2F8AC +2F8AD CJK COMPATIBILITY IDEOGRAPH-2F8AD +2F8AE CJK COMPATIBILITY IDEOGRAPH-2F8AE +2F8AF CJK COMPATIBILITY IDEOGRAPH-2F8AF +2F8B0 CJK COMPATIBILITY IDEOGRAPH-2F8B0 +2F8B1 CJK COMPATIBILITY IDEOGRAPH-2F8B1 +2F8B2 CJK COMPATIBILITY IDEOGRAPH-2F8B2 +2F8B3 CJK COMPATIBILITY IDEOGRAPH-2F8B3 +2F8B4 CJK COMPATIBILITY IDEOGRAPH-2F8B4 +2F8B5 CJK COMPATIBILITY IDEOGRAPH-2F8B5 +2F8B6 CJK COMPATIBILITY IDEOGRAPH-2F8B6 +2F8B7 CJK COMPATIBILITY IDEOGRAPH-2F8B7 +2F8B8 CJK COMPATIBILITY IDEOGRAPH-2F8B8 +2F8B9 CJK COMPATIBILITY IDEOGRAPH-2F8B9 +2F8BA CJK COMPATIBILITY IDEOGRAPH-2F8BA +2F8BB CJK COMPATIBILITY IDEOGRAPH-2F8BB +2F8BC CJK COMPATIBILITY IDEOGRAPH-2F8BC +2F8BD CJK COMPATIBILITY IDEOGRAPH-2F8BD +2F8BE CJK COMPATIBILITY IDEOGRAPH-2F8BE +2F8BF CJK COMPATIBILITY IDEOGRAPH-2F8BF +2F8C0 CJK COMPATIBILITY IDEOGRAPH-2F8C0 +2F8C1 CJK COMPATIBILITY IDEOGRAPH-2F8C1 +2F8C2 CJK COMPATIBILITY IDEOGRAPH-2F8C2 +2F8C3 CJK COMPATIBILITY IDEOGRAPH-2F8C3 +2F8C4 CJK COMPATIBILITY IDEOGRAPH-2F8C4 +2F8C5 CJK COMPATIBILITY IDEOGRAPH-2F8C5 +2F8C6 CJK COMPATIBILITY IDEOGRAPH-2F8C6 +2F8C7 CJK COMPATIBILITY IDEOGRAPH-2F8C7 +2F8C8 CJK COMPATIBILITY IDEOGRAPH-2F8C8 +2F8C9 CJK COMPATIBILITY IDEOGRAPH-2F8C9 +2F8CA CJK COMPATIBILITY IDEOGRAPH-2F8CA +2F8CB CJK COMPATIBILITY IDEOGRAPH-2F8CB +2F8CC CJK COMPATIBILITY IDEOGRAPH-2F8CC +2F8CD CJK COMPATIBILITY IDEOGRAPH-2F8CD +2F8CE CJK COMPATIBILITY IDEOGRAPH-2F8CE +2F8CF CJK COMPATIBILITY IDEOGRAPH-2F8CF +2F8D0 CJK COMPATIBILITY IDEOGRAPH-2F8D0 +2F8D1 CJK COMPATIBILITY IDEOGRAPH-2F8D1 +2F8D2 CJK COMPATIBILITY IDEOGRAPH-2F8D2 +2F8D3 CJK COMPATIBILITY IDEOGRAPH-2F8D3 +2F8D4 CJK COMPATIBILITY IDEOGRAPH-2F8D4 +2F8D5 CJK COMPATIBILITY IDEOGRAPH-2F8D5 +2F8D6 CJK COMPATIBILITY IDEOGRAPH-2F8D6 +2F8D7 CJK COMPATIBILITY IDEOGRAPH-2F8D7 +2F8D8 CJK COMPATIBILITY IDEOGRAPH-2F8D8 +2F8D9 CJK COMPATIBILITY IDEOGRAPH-2F8D9 +2F8DA CJK COMPATIBILITY IDEOGRAPH-2F8DA +2F8DB CJK COMPATIBILITY IDEOGRAPH-2F8DB +2F8DC CJK COMPATIBILITY IDEOGRAPH-2F8DC +2F8DD CJK COMPATIBILITY IDEOGRAPH-2F8DD +2F8DE CJK COMPATIBILITY IDEOGRAPH-2F8DE +2F8DF CJK COMPATIBILITY IDEOGRAPH-2F8DF +2F8E0 CJK COMPATIBILITY IDEOGRAPH-2F8E0 +2F8E1 CJK COMPATIBILITY IDEOGRAPH-2F8E1 +2F8E2 CJK COMPATIBILITY IDEOGRAPH-2F8E2 +2F8E3 CJK COMPATIBILITY IDEOGRAPH-2F8E3 +2F8E4 CJK COMPATIBILITY IDEOGRAPH-2F8E4 +2F8E5 CJK COMPATIBILITY IDEOGRAPH-2F8E5 +2F8E6 CJK COMPATIBILITY IDEOGRAPH-2F8E6 +2F8E7 CJK COMPATIBILITY IDEOGRAPH-2F8E7 +2F8E8 CJK COMPATIBILITY IDEOGRAPH-2F8E8 +2F8E9 CJK COMPATIBILITY IDEOGRAPH-2F8E9 +2F8EA CJK COMPATIBILITY IDEOGRAPH-2F8EA +2F8EB CJK COMPATIBILITY IDEOGRAPH-2F8EB +2F8EC CJK COMPATIBILITY IDEOGRAPH-2F8EC +2F8ED CJK COMPATIBILITY IDEOGRAPH-2F8ED +2F8EE CJK COMPATIBILITY IDEOGRAPH-2F8EE +2F8EF CJK COMPATIBILITY IDEOGRAPH-2F8EF +2F8F0 CJK COMPATIBILITY IDEOGRAPH-2F8F0 +2F8F1 CJK COMPATIBILITY IDEOGRAPH-2F8F1 +2F8F2 CJK COMPATIBILITY IDEOGRAPH-2F8F2 +2F8F3 CJK COMPATIBILITY IDEOGRAPH-2F8F3 +2F8F4 CJK COMPATIBILITY IDEOGRAPH-2F8F4 +2F8F5 CJK COMPATIBILITY IDEOGRAPH-2F8F5 +2F8F6 CJK COMPATIBILITY IDEOGRAPH-2F8F6 +2F8F7 CJK COMPATIBILITY IDEOGRAPH-2F8F7 +2F8F8 CJK COMPATIBILITY IDEOGRAPH-2F8F8 +2F8F9 CJK COMPATIBILITY IDEOGRAPH-2F8F9 +2F8FA CJK COMPATIBILITY IDEOGRAPH-2F8FA +2F8FB CJK COMPATIBILITY IDEOGRAPH-2F8FB +2F8FC CJK COMPATIBILITY IDEOGRAPH-2F8FC +2F8FD CJK COMPATIBILITY IDEOGRAPH-2F8FD +2F8FE CJK COMPATIBILITY IDEOGRAPH-2F8FE +2F8FF CJK COMPATIBILITY IDEOGRAPH-2F8FF +2F900 CJK COMPATIBILITY IDEOGRAPH-2F900 +2F901 CJK COMPATIBILITY IDEOGRAPH-2F901 +2F902 CJK COMPATIBILITY IDEOGRAPH-2F902 +2F903 CJK COMPATIBILITY IDEOGRAPH-2F903 +2F904 CJK COMPATIBILITY IDEOGRAPH-2F904 +2F905 CJK COMPATIBILITY IDEOGRAPH-2F905 +2F906 CJK COMPATIBILITY IDEOGRAPH-2F906 +2F907 CJK COMPATIBILITY IDEOGRAPH-2F907 +2F908 CJK COMPATIBILITY IDEOGRAPH-2F908 +2F909 CJK COMPATIBILITY IDEOGRAPH-2F909 +2F90A CJK COMPATIBILITY IDEOGRAPH-2F90A +2F90B CJK COMPATIBILITY IDEOGRAPH-2F90B +2F90C CJK COMPATIBILITY IDEOGRAPH-2F90C +2F90D CJK COMPATIBILITY IDEOGRAPH-2F90D +2F90E CJK COMPATIBILITY IDEOGRAPH-2F90E +2F90F CJK COMPATIBILITY IDEOGRAPH-2F90F +2F910 CJK COMPATIBILITY IDEOGRAPH-2F910 +2F911 CJK COMPATIBILITY IDEOGRAPH-2F911 +2F912 CJK COMPATIBILITY IDEOGRAPH-2F912 +2F913 CJK COMPATIBILITY IDEOGRAPH-2F913 +2F914 CJK COMPATIBILITY IDEOGRAPH-2F914 +2F915 CJK COMPATIBILITY IDEOGRAPH-2F915 +2F916 CJK COMPATIBILITY IDEOGRAPH-2F916 +2F917 CJK COMPATIBILITY IDEOGRAPH-2F917 +2F918 CJK COMPATIBILITY IDEOGRAPH-2F918 +2F919 CJK COMPATIBILITY IDEOGRAPH-2F919 +2F91A CJK COMPATIBILITY IDEOGRAPH-2F91A +2F91B CJK COMPATIBILITY IDEOGRAPH-2F91B +2F91C CJK COMPATIBILITY IDEOGRAPH-2F91C +2F91D CJK COMPATIBILITY IDEOGRAPH-2F91D +2F91E CJK COMPATIBILITY IDEOGRAPH-2F91E +2F91F CJK COMPATIBILITY IDEOGRAPH-2F91F +2F920 CJK COMPATIBILITY IDEOGRAPH-2F920 +2F921 CJK COMPATIBILITY IDEOGRAPH-2F921 +2F922 CJK COMPATIBILITY IDEOGRAPH-2F922 +2F923 CJK COMPATIBILITY IDEOGRAPH-2F923 +2F924 CJK COMPATIBILITY IDEOGRAPH-2F924 +2F925 CJK COMPATIBILITY IDEOGRAPH-2F925 +2F926 CJK COMPATIBILITY IDEOGRAPH-2F926 +2F927 CJK COMPATIBILITY IDEOGRAPH-2F927 +2F928 CJK COMPATIBILITY IDEOGRAPH-2F928 +2F929 CJK COMPATIBILITY IDEOGRAPH-2F929 +2F92A CJK COMPATIBILITY IDEOGRAPH-2F92A +2F92B CJK COMPATIBILITY IDEOGRAPH-2F92B +2F92C CJK COMPATIBILITY IDEOGRAPH-2F92C +2F92D CJK COMPATIBILITY IDEOGRAPH-2F92D +2F92E CJK COMPATIBILITY IDEOGRAPH-2F92E +2F92F CJK COMPATIBILITY IDEOGRAPH-2F92F +2F930 CJK COMPATIBILITY IDEOGRAPH-2F930 +2F931 CJK COMPATIBILITY IDEOGRAPH-2F931 +2F932 CJK COMPATIBILITY IDEOGRAPH-2F932 +2F933 CJK COMPATIBILITY IDEOGRAPH-2F933 +2F934 CJK COMPATIBILITY IDEOGRAPH-2F934 +2F935 CJK COMPATIBILITY IDEOGRAPH-2F935 +2F936 CJK COMPATIBILITY IDEOGRAPH-2F936 +2F937 CJK COMPATIBILITY IDEOGRAPH-2F937 +2F938 CJK COMPATIBILITY IDEOGRAPH-2F938 +2F939 CJK COMPATIBILITY IDEOGRAPH-2F939 +2F93A CJK COMPATIBILITY IDEOGRAPH-2F93A +2F93B CJK COMPATIBILITY IDEOGRAPH-2F93B +2F93C CJK COMPATIBILITY IDEOGRAPH-2F93C +2F93D CJK COMPATIBILITY IDEOGRAPH-2F93D +2F93E CJK COMPATIBILITY IDEOGRAPH-2F93E +2F93F CJK COMPATIBILITY IDEOGRAPH-2F93F +2F940 CJK COMPATIBILITY IDEOGRAPH-2F940 +2F941 CJK COMPATIBILITY IDEOGRAPH-2F941 +2F942 CJK COMPATIBILITY IDEOGRAPH-2F942 +2F943 CJK COMPATIBILITY IDEOGRAPH-2F943 +2F944 CJK COMPATIBILITY IDEOGRAPH-2F944 +2F945 CJK COMPATIBILITY IDEOGRAPH-2F945 +2F946 CJK COMPATIBILITY IDEOGRAPH-2F946 +2F947 CJK COMPATIBILITY IDEOGRAPH-2F947 +2F948 CJK COMPATIBILITY IDEOGRAPH-2F948 +2F949 CJK COMPATIBILITY IDEOGRAPH-2F949 +2F94A CJK COMPATIBILITY IDEOGRAPH-2F94A +2F94B CJK COMPATIBILITY IDEOGRAPH-2F94B +2F94C CJK COMPATIBILITY IDEOGRAPH-2F94C +2F94D CJK COMPATIBILITY IDEOGRAPH-2F94D +2F94E CJK COMPATIBILITY IDEOGRAPH-2F94E +2F94F CJK COMPATIBILITY IDEOGRAPH-2F94F +2F950 CJK COMPATIBILITY IDEOGRAPH-2F950 +2F951 CJK COMPATIBILITY IDEOGRAPH-2F951 +2F952 CJK COMPATIBILITY IDEOGRAPH-2F952 +2F953 CJK COMPATIBILITY IDEOGRAPH-2F953 +2F954 CJK COMPATIBILITY IDEOGRAPH-2F954 +2F955 CJK COMPATIBILITY IDEOGRAPH-2F955 +2F956 CJK COMPATIBILITY IDEOGRAPH-2F956 +2F957 CJK COMPATIBILITY IDEOGRAPH-2F957 +2F958 CJK COMPATIBILITY IDEOGRAPH-2F958 +2F959 CJK COMPATIBILITY IDEOGRAPH-2F959 +2F95A CJK COMPATIBILITY IDEOGRAPH-2F95A +2F95B CJK COMPATIBILITY IDEOGRAPH-2F95B +2F95C CJK COMPATIBILITY IDEOGRAPH-2F95C +2F95D CJK COMPATIBILITY IDEOGRAPH-2F95D +2F95E CJK COMPATIBILITY IDEOGRAPH-2F95E +2F95F CJK COMPATIBILITY IDEOGRAPH-2F95F +2F960 CJK COMPATIBILITY IDEOGRAPH-2F960 +2F961 CJK COMPATIBILITY IDEOGRAPH-2F961 +2F962 CJK COMPATIBILITY IDEOGRAPH-2F962 +2F963 CJK COMPATIBILITY IDEOGRAPH-2F963 +2F964 CJK COMPATIBILITY IDEOGRAPH-2F964 +2F965 CJK COMPATIBILITY IDEOGRAPH-2F965 +2F966 CJK COMPATIBILITY IDEOGRAPH-2F966 +2F967 CJK COMPATIBILITY IDEOGRAPH-2F967 +2F968 CJK COMPATIBILITY IDEOGRAPH-2F968 +2F969 CJK COMPATIBILITY IDEOGRAPH-2F969 +2F96A CJK COMPATIBILITY IDEOGRAPH-2F96A +2F96B CJK COMPATIBILITY IDEOGRAPH-2F96B +2F96C CJK COMPATIBILITY IDEOGRAPH-2F96C +2F96D CJK COMPATIBILITY IDEOGRAPH-2F96D +2F96E CJK COMPATIBILITY IDEOGRAPH-2F96E +2F96F CJK COMPATIBILITY IDEOGRAPH-2F96F +2F970 CJK COMPATIBILITY IDEOGRAPH-2F970 +2F971 CJK COMPATIBILITY IDEOGRAPH-2F971 +2F972 CJK COMPATIBILITY IDEOGRAPH-2F972 +2F973 CJK COMPATIBILITY IDEOGRAPH-2F973 +2F974 CJK COMPATIBILITY IDEOGRAPH-2F974 +2F975 CJK COMPATIBILITY IDEOGRAPH-2F975 +2F976 CJK COMPATIBILITY IDEOGRAPH-2F976 +2F977 CJK COMPATIBILITY IDEOGRAPH-2F977 +2F978 CJK COMPATIBILITY IDEOGRAPH-2F978 +2F979 CJK COMPATIBILITY IDEOGRAPH-2F979 +2F97A CJK COMPATIBILITY IDEOGRAPH-2F97A +2F97B CJK COMPATIBILITY IDEOGRAPH-2F97B +2F97C CJK COMPATIBILITY IDEOGRAPH-2F97C +2F97D CJK COMPATIBILITY IDEOGRAPH-2F97D +2F97E CJK COMPATIBILITY IDEOGRAPH-2F97E +2F97F CJK COMPATIBILITY IDEOGRAPH-2F97F +2F980 CJK COMPATIBILITY IDEOGRAPH-2F980 +2F981 CJK COMPATIBILITY IDEOGRAPH-2F981 +2F982 CJK COMPATIBILITY IDEOGRAPH-2F982 +2F983 CJK COMPATIBILITY IDEOGRAPH-2F983 +2F984 CJK COMPATIBILITY IDEOGRAPH-2F984 +2F985 CJK COMPATIBILITY IDEOGRAPH-2F985 +2F986 CJK COMPATIBILITY IDEOGRAPH-2F986 +2F987 CJK COMPATIBILITY IDEOGRAPH-2F987 +2F988 CJK COMPATIBILITY IDEOGRAPH-2F988 +2F989 CJK COMPATIBILITY IDEOGRAPH-2F989 +2F98A CJK COMPATIBILITY IDEOGRAPH-2F98A +2F98B CJK COMPATIBILITY IDEOGRAPH-2F98B +2F98C CJK COMPATIBILITY IDEOGRAPH-2F98C +2F98D CJK COMPATIBILITY IDEOGRAPH-2F98D +2F98E CJK COMPATIBILITY IDEOGRAPH-2F98E +2F98F CJK COMPATIBILITY IDEOGRAPH-2F98F +2F990 CJK COMPATIBILITY IDEOGRAPH-2F990 +2F991 CJK COMPATIBILITY IDEOGRAPH-2F991 +2F992 CJK COMPATIBILITY IDEOGRAPH-2F992 +2F993 CJK COMPATIBILITY IDEOGRAPH-2F993 +2F994 CJK COMPATIBILITY IDEOGRAPH-2F994 +2F995 CJK COMPATIBILITY IDEOGRAPH-2F995 +2F996 CJK COMPATIBILITY IDEOGRAPH-2F996 +2F997 CJK COMPATIBILITY IDEOGRAPH-2F997 +2F998 CJK COMPATIBILITY IDEOGRAPH-2F998 +2F999 CJK COMPATIBILITY IDEOGRAPH-2F999 +2F99A CJK COMPATIBILITY IDEOGRAPH-2F99A +2F99B CJK COMPATIBILITY IDEOGRAPH-2F99B +2F99C CJK COMPATIBILITY IDEOGRAPH-2F99C +2F99D CJK COMPATIBILITY IDEOGRAPH-2F99D +2F99E CJK COMPATIBILITY IDEOGRAPH-2F99E +2F99F CJK COMPATIBILITY IDEOGRAPH-2F99F +2F9A0 CJK COMPATIBILITY IDEOGRAPH-2F9A0 +2F9A1 CJK COMPATIBILITY IDEOGRAPH-2F9A1 +2F9A2 CJK COMPATIBILITY IDEOGRAPH-2F9A2 +2F9A3 CJK COMPATIBILITY IDEOGRAPH-2F9A3 +2F9A4 CJK COMPATIBILITY IDEOGRAPH-2F9A4 +2F9A5 CJK COMPATIBILITY IDEOGRAPH-2F9A5 +2F9A6 CJK COMPATIBILITY IDEOGRAPH-2F9A6 +2F9A7 CJK COMPATIBILITY IDEOGRAPH-2F9A7 +2F9A8 CJK COMPATIBILITY IDEOGRAPH-2F9A8 +2F9A9 CJK COMPATIBILITY IDEOGRAPH-2F9A9 +2F9AA CJK COMPATIBILITY IDEOGRAPH-2F9AA +2F9AB CJK COMPATIBILITY IDEOGRAPH-2F9AB +2F9AC CJK COMPATIBILITY IDEOGRAPH-2F9AC +2F9AD CJK COMPATIBILITY IDEOGRAPH-2F9AD +2F9AE CJK COMPATIBILITY IDEOGRAPH-2F9AE +2F9AF CJK COMPATIBILITY IDEOGRAPH-2F9AF +2F9B0 CJK COMPATIBILITY IDEOGRAPH-2F9B0 +2F9B1 CJK COMPATIBILITY IDEOGRAPH-2F9B1 +2F9B2 CJK COMPATIBILITY IDEOGRAPH-2F9B2 +2F9B3 CJK COMPATIBILITY IDEOGRAPH-2F9B3 +2F9B4 CJK COMPATIBILITY IDEOGRAPH-2F9B4 +2F9B5 CJK COMPATIBILITY IDEOGRAPH-2F9B5 +2F9B6 CJK COMPATIBILITY IDEOGRAPH-2F9B6 +2F9B7 CJK COMPATIBILITY IDEOGRAPH-2F9B7 +2F9B8 CJK COMPATIBILITY IDEOGRAPH-2F9B8 +2F9B9 CJK COMPATIBILITY IDEOGRAPH-2F9B9 +2F9BA CJK COMPATIBILITY IDEOGRAPH-2F9BA +2F9BB CJK COMPATIBILITY IDEOGRAPH-2F9BB +2F9BC CJK COMPATIBILITY IDEOGRAPH-2F9BC +2F9BD CJK COMPATIBILITY IDEOGRAPH-2F9BD +2F9BE CJK COMPATIBILITY IDEOGRAPH-2F9BE +2F9BF CJK COMPATIBILITY IDEOGRAPH-2F9BF +2F9C0 CJK COMPATIBILITY IDEOGRAPH-2F9C0 +2F9C1 CJK COMPATIBILITY IDEOGRAPH-2F9C1 +2F9C2 CJK COMPATIBILITY IDEOGRAPH-2F9C2 +2F9C3 CJK COMPATIBILITY IDEOGRAPH-2F9C3 +2F9C4 CJK COMPATIBILITY IDEOGRAPH-2F9C4 +2F9C5 CJK COMPATIBILITY IDEOGRAPH-2F9C5 +2F9C6 CJK COMPATIBILITY IDEOGRAPH-2F9C6 +2F9C7 CJK COMPATIBILITY IDEOGRAPH-2F9C7 +2F9C8 CJK COMPATIBILITY IDEOGRAPH-2F9C8 +2F9C9 CJK COMPATIBILITY IDEOGRAPH-2F9C9 +2F9CA CJK COMPATIBILITY IDEOGRAPH-2F9CA +2F9CB CJK COMPATIBILITY IDEOGRAPH-2F9CB +2F9CC CJK COMPATIBILITY IDEOGRAPH-2F9CC +2F9CD CJK COMPATIBILITY IDEOGRAPH-2F9CD +2F9CE CJK COMPATIBILITY IDEOGRAPH-2F9CE +2F9CF CJK COMPATIBILITY IDEOGRAPH-2F9CF +2F9D0 CJK COMPATIBILITY IDEOGRAPH-2F9D0 +2F9D1 CJK COMPATIBILITY IDEOGRAPH-2F9D1 +2F9D2 CJK COMPATIBILITY IDEOGRAPH-2F9D2 +2F9D3 CJK COMPATIBILITY IDEOGRAPH-2F9D3 +2F9D4 CJK COMPATIBILITY IDEOGRAPH-2F9D4 +2F9D5 CJK COMPATIBILITY IDEOGRAPH-2F9D5 +2F9D6 CJK COMPATIBILITY IDEOGRAPH-2F9D6 +2F9D7 CJK COMPATIBILITY IDEOGRAPH-2F9D7 +2F9D8 CJK COMPATIBILITY IDEOGRAPH-2F9D8 +2F9D9 CJK COMPATIBILITY IDEOGRAPH-2F9D9 +2F9DA CJK COMPATIBILITY IDEOGRAPH-2F9DA +2F9DB CJK COMPATIBILITY IDEOGRAPH-2F9DB +2F9DC CJK COMPATIBILITY IDEOGRAPH-2F9DC +2F9DD CJK COMPATIBILITY IDEOGRAPH-2F9DD +2F9DE CJK COMPATIBILITY IDEOGRAPH-2F9DE +2F9DF CJK COMPATIBILITY IDEOGRAPH-2F9DF +2F9E0 CJK COMPATIBILITY IDEOGRAPH-2F9E0 +2F9E1 CJK COMPATIBILITY IDEOGRAPH-2F9E1 +2F9E2 CJK COMPATIBILITY IDEOGRAPH-2F9E2 +2F9E3 CJK COMPATIBILITY IDEOGRAPH-2F9E3 +2F9E4 CJK COMPATIBILITY IDEOGRAPH-2F9E4 +2F9E5 CJK COMPATIBILITY IDEOGRAPH-2F9E5 +2F9E6 CJK COMPATIBILITY IDEOGRAPH-2F9E6 +2F9E7 CJK COMPATIBILITY IDEOGRAPH-2F9E7 +2F9E8 CJK COMPATIBILITY IDEOGRAPH-2F9E8 +2F9E9 CJK COMPATIBILITY IDEOGRAPH-2F9E9 +2F9EA CJK COMPATIBILITY IDEOGRAPH-2F9EA +2F9EB CJK COMPATIBILITY IDEOGRAPH-2F9EB +2F9EC CJK COMPATIBILITY IDEOGRAPH-2F9EC +2F9ED CJK COMPATIBILITY IDEOGRAPH-2F9ED +2F9EE CJK COMPATIBILITY IDEOGRAPH-2F9EE +2F9EF CJK COMPATIBILITY IDEOGRAPH-2F9EF +2F9F0 CJK COMPATIBILITY IDEOGRAPH-2F9F0 +2F9F1 CJK COMPATIBILITY IDEOGRAPH-2F9F1 +2F9F2 CJK COMPATIBILITY IDEOGRAPH-2F9F2 +2F9F3 CJK COMPATIBILITY IDEOGRAPH-2F9F3 +2F9F4 CJK COMPATIBILITY IDEOGRAPH-2F9F4 +2F9F5 CJK COMPATIBILITY IDEOGRAPH-2F9F5 +2F9F6 CJK COMPATIBILITY IDEOGRAPH-2F9F6 +2F9F7 CJK COMPATIBILITY IDEOGRAPH-2F9F7 +2F9F8 CJK COMPATIBILITY IDEOGRAPH-2F9F8 +2F9F9 CJK COMPATIBILITY IDEOGRAPH-2F9F9 +2F9FA CJK COMPATIBILITY IDEOGRAPH-2F9FA +2F9FB CJK COMPATIBILITY IDEOGRAPH-2F9FB +2F9FC CJK COMPATIBILITY IDEOGRAPH-2F9FC +2F9FD CJK COMPATIBILITY IDEOGRAPH-2F9FD +2F9FE CJK COMPATIBILITY IDEOGRAPH-2F9FE +2F9FF CJK COMPATIBILITY IDEOGRAPH-2F9FF +2FA00 CJK COMPATIBILITY IDEOGRAPH-2FA00 +2FA01 CJK COMPATIBILITY IDEOGRAPH-2FA01 +2FA02 CJK COMPATIBILITY IDEOGRAPH-2FA02 +2FA03 CJK COMPATIBILITY IDEOGRAPH-2FA03 +2FA04 CJK COMPATIBILITY IDEOGRAPH-2FA04 +2FA05 CJK COMPATIBILITY IDEOGRAPH-2FA05 +2FA06 CJK COMPATIBILITY IDEOGRAPH-2FA06 +2FA07 CJK COMPATIBILITY IDEOGRAPH-2FA07 +2FA08 CJK COMPATIBILITY IDEOGRAPH-2FA08 +2FA09 CJK COMPATIBILITY IDEOGRAPH-2FA09 +2FA0A CJK COMPATIBILITY IDEOGRAPH-2FA0A +2FA0B CJK COMPATIBILITY IDEOGRAPH-2FA0B +2FA0C CJK COMPATIBILITY IDEOGRAPH-2FA0C +2FA0D CJK COMPATIBILITY IDEOGRAPH-2FA0D +2FA0E CJK COMPATIBILITY IDEOGRAPH-2FA0E +2FA0F CJK COMPATIBILITY IDEOGRAPH-2FA0F +2FA10 CJK COMPATIBILITY IDEOGRAPH-2FA10 +2FA11 CJK COMPATIBILITY IDEOGRAPH-2FA11 +2FA12 CJK COMPATIBILITY IDEOGRAPH-2FA12 +2FA13 CJK COMPATIBILITY IDEOGRAPH-2FA13 +2FA14 CJK COMPATIBILITY IDEOGRAPH-2FA14 +2FA15 CJK COMPATIBILITY IDEOGRAPH-2FA15 +2FA16 CJK COMPATIBILITY IDEOGRAPH-2FA16 +2FA17 CJK COMPATIBILITY IDEOGRAPH-2FA17 +2FA18 CJK COMPATIBILITY IDEOGRAPH-2FA18 +2FA19 CJK COMPATIBILITY IDEOGRAPH-2FA19 +2FA1A CJK COMPATIBILITY IDEOGRAPH-2FA1A +2FA1B CJK COMPATIBILITY IDEOGRAPH-2FA1B +2FA1C CJK COMPATIBILITY IDEOGRAPH-2FA1C +2FA1D CJK COMPATIBILITY IDEOGRAPH-2FA1D +E0001 LANGUAGE TAG +E0020 TAG SPACE +E0021 TAG EXCLAMATION MARK +E0022 TAG QUOTATION MARK +E0023 TAG NUMBER SIGN +E0024 TAG DOLLAR SIGN +E0025 TAG PERCENT SIGN +E0026 TAG AMPERSAND +E0027 TAG APOSTROPHE +E0028 TAG LEFT PARENTHESIS +E0029 TAG RIGHT PARENTHESIS +E002A TAG ASTERISK +E002B TAG PLUS SIGN +E002C TAG COMMA +E002D TAG HYPHEN-MINUS +E002E TAG FULL STOP +E002F TAG SOLIDUS +E0030 TAG DIGIT ZERO +E0031 TAG DIGIT ONE +E0032 TAG DIGIT TWO +E0033 TAG DIGIT THREE +E0034 TAG DIGIT FOUR +E0035 TAG DIGIT FIVE +E0036 TAG DIGIT SIX +E0037 TAG DIGIT SEVEN +E0038 TAG DIGIT EIGHT +E0039 TAG DIGIT NINE +E003A TAG COLON +E003B TAG SEMICOLON +E003C TAG LESS-THAN SIGN +E003D TAG EQUALS SIGN +E003E TAG GREATER-THAN SIGN +E003F TAG QUESTION MARK +E0040 TAG COMMERCIAL AT +E0041 TAG LATIN CAPITAL LETTER A +E0042 TAG LATIN CAPITAL LETTER B +E0043 TAG LATIN CAPITAL LETTER C +E0044 TAG LATIN CAPITAL LETTER D +E0045 TAG LATIN CAPITAL LETTER E +E0046 TAG LATIN CAPITAL LETTER F +E0047 TAG LATIN CAPITAL LETTER G +E0048 TAG LATIN CAPITAL LETTER H +E0049 TAG LATIN CAPITAL LETTER I +E004A TAG LATIN CAPITAL LETTER J +E004B TAG LATIN CAPITAL LETTER K +E004C TAG LATIN CAPITAL LETTER L +E004D TAG LATIN CAPITAL LETTER M +E004E TAG LATIN CAPITAL LETTER N +E004F TAG LATIN CAPITAL LETTER O +E0050 TAG LATIN CAPITAL LETTER P +E0051 TAG LATIN CAPITAL LETTER Q +E0052 TAG LATIN CAPITAL LETTER R +E0053 TAG LATIN CAPITAL LETTER S +E0054 TAG LATIN CAPITAL LETTER T +E0055 TAG LATIN CAPITAL LETTER U +E0056 TAG LATIN CAPITAL LETTER V +E0057 TAG LATIN CAPITAL LETTER W +E0058 TAG LATIN CAPITAL LETTER X +E0059 TAG LATIN CAPITAL LETTER Y +E005A TAG LATIN CAPITAL LETTER Z +E005B TAG LEFT SQUARE BRACKET +E005C TAG REVERSE SOLIDUS +E005D TAG RIGHT SQUARE BRACKET +E005E TAG CIRCUMFLEX ACCENT +E005F TAG LOW LINE +E0060 TAG GRAVE ACCENT +E0061 TAG LATIN SMALL LETTER A +E0062 TAG LATIN SMALL LETTER B +E0063 TAG LATIN SMALL LETTER C +E0064 TAG LATIN SMALL LETTER D +E0065 TAG LATIN SMALL LETTER E +E0066 TAG LATIN SMALL LETTER F +E0067 TAG LATIN SMALL LETTER G +E0068 TAG LATIN SMALL LETTER H +E0069 TAG LATIN SMALL LETTER I +E006A TAG LATIN SMALL LETTER J +E006B TAG LATIN SMALL LETTER K +E006C TAG LATIN SMALL LETTER L +E006D TAG LATIN SMALL LETTER M +E006E TAG LATIN SMALL LETTER N +E006F TAG LATIN SMALL LETTER O +E0070 TAG LATIN SMALL LETTER P +E0071 TAG LATIN SMALL LETTER Q +E0072 TAG LATIN SMALL LETTER R +E0073 TAG LATIN SMALL LETTER S +E0074 TAG LATIN SMALL LETTER T +E0075 TAG LATIN SMALL LETTER U +E0076 TAG LATIN SMALL LETTER V +E0077 TAG LATIN SMALL LETTER W +E0078 TAG LATIN SMALL LETTER X +E0079 TAG LATIN SMALL LETTER Y +E007A TAG LATIN SMALL LETTER Z +E007B TAG LEFT CURLY BRACKET +E007C TAG VERTICAL LINE +E007D TAG RIGHT CURLY BRACKET +E007E TAG TILDE +E007F CANCEL TAG +F0000 FFFFD Plane 15 Private Use +100000 10FFFD Plane 16 Private Use +END diff --git a/Master/xemtex/perl/lib/unicore/Number.pl b/Master/xemtex/perl/lib/unicore/Number.pl new file mode 100644 index 00000000000..9bc4fd4663d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Number.pl @@ -0,0 +1,537 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0030 0 +0031 1 +0032 2 +0033 3 +0034 4 +0035 5 +0036 6 +0037 7 +0038 8 +0039 9 +00B2 2 +00B3 3 +00B9 1 +00BC 1/4 +00BD 1/2 +00BE 3/4 +0660 0 +0661 1 +0662 2 +0663 3 +0664 4 +0665 5 +0666 6 +0667 7 +0668 8 +0669 9 +06F0 0 +06F1 1 +06F2 2 +06F3 3 +06F4 4 +06F5 5 +06F6 6 +06F7 7 +06F8 8 +06F9 9 +0966 0 +0967 1 +0968 2 +0969 3 +096A 4 +096B 5 +096C 6 +096D 7 +096E 8 +096F 9 +09E6 0 +09E7 1 +09E8 2 +09E9 3 +09EA 4 +09EB 5 +09EC 6 +09ED 7 +09EE 8 +09EF 9 +09F4 1 +09F5 2 +09F6 3 +09F7 4 +09F9 16 +0A66 0 +0A67 1 +0A68 2 +0A69 3 +0A6A 4 +0A6B 5 +0A6C 6 +0A6D 7 +0A6E 8 +0A6F 9 +0AE6 0 +0AE7 1 +0AE8 2 +0AE9 3 +0AEA 4 +0AEB 5 +0AEC 6 +0AED 7 +0AEE 8 +0AEF 9 +0B66 0 +0B67 1 +0B68 2 +0B69 3 +0B6A 4 +0B6B 5 +0B6C 6 +0B6D 7 +0B6E 8 +0B6F 9 +0BE7 1 +0BE8 2 +0BE9 3 +0BEA 4 +0BEB 5 +0BEC 6 +0BED 7 +0BEE 8 +0BEF 9 +0BF0 10 +0BF1 100 +0BF2 1000 +0C66 0 +0C67 1 +0C68 2 +0C69 3 +0C6A 4 +0C6B 5 +0C6C 6 +0C6D 7 +0C6E 8 +0C6F 9 +0CE6 0 +0CE7 1 +0CE8 2 +0CE9 3 +0CEA 4 +0CEB 5 +0CEC 6 +0CED 7 +0CEE 8 +0CEF 9 +0D66 0 +0D67 1 +0D68 2 +0D69 3 +0D6A 4 +0D6B 5 +0D6C 6 +0D6D 7 +0D6E 8 +0D6F 9 +0E50 0 +0E51 1 +0E52 2 +0E53 3 +0E54 4 +0E55 5 +0E56 6 +0E57 7 +0E58 8 +0E59 9 +0ED0 0 +0ED1 1 +0ED2 2 +0ED3 3 +0ED4 4 +0ED5 5 +0ED6 6 +0ED7 7 +0ED8 8 +0ED9 9 +0F20 0 +0F21 1 +0F22 2 +0F23 3 +0F24 4 +0F25 5 +0F26 6 +0F27 7 +0F28 8 +0F29 9 +0F2A 1/2 +0F2B 3/2 +0F2C 5/2 +0F2D 7/2 +0F2E 9/2 +0F2F 11/2 +0F30 13/2 +0F31 15/2 +0F32 17/2 +0F33 -1/2 +1040 0 +1041 1 +1042 2 +1043 3 +1044 4 +1045 5 +1046 6 +1047 7 +1048 8 +1049 9 +1369 1 +136A 2 +136B 3 +136C 4 +136D 5 +136E 6 +136F 7 +1370 8 +1371 9 +1372 10 +1373 20 +1374 30 +1375 40 +1376 50 +1377 60 +1378 70 +1379 80 +137A 90 +137B 100 +137C 10000 +16EE 17 +16EF 18 +16F0 19 +17E0 0 +17E1 1 +17E2 2 +17E3 3 +17E4 4 +17E5 5 +17E6 6 +17E7 7 +17E8 8 +17E9 9 +1810 0 +1811 1 +1812 2 +1813 3 +1814 4 +1815 5 +1816 6 +1817 7 +1818 8 +1819 9 +2070 0 +2074 4 +2075 5 +2076 6 +2077 7 +2078 8 +2079 9 +2080 0 +2081 1 +2082 2 +2083 3 +2084 4 +2085 5 +2086 6 +2087 7 +2088 8 +2089 9 +2153 1/3 +2154 2/3 +2155 1/5 +2156 2/5 +2157 3/5 +2158 4/5 +2159 1/6 +215A 5/6 +215B 1/8 +215C 3/8 +215D 5/8 +215E 7/8 +215F 2160 1 +2161 2 +2162 3 +2163 4 +2164 5 +2165 6 +2166 7 +2167 8 +2168 9 +2169 10 +216A 11 +216B 12 +216C 50 +216D 100 +216E 500 +216F 1000 +2170 1 +2171 2 +2172 3 +2173 4 +2174 5 +2175 6 +2176 7 +2177 8 +2178 9 +2179 10 +217A 11 +217B 12 +217C 50 +217D 100 +217E 500 +217F 2180 1000 +2181 5000 +2182 10000 +2460 1 +2461 2 +2462 3 +2463 4 +2464 5 +2465 6 +2466 7 +2467 8 +2468 9 +2469 10 +246A 11 +246B 12 +246C 13 +246D 14 +246E 15 +246F 16 +2470 17 +2471 18 +2472 19 +2473 20 +2474 1 +2475 2 +2476 3 +2477 4 +2478 5 +2479 6 +247A 7 +247B 8 +247C 9 +247D 10 +247E 11 +247F 12 +2480 13 +2481 14 +2482 15 +2483 16 +2484 17 +2485 18 +2486 19 +2487 20 +2488 1 +2489 2 +248A 3 +248B 4 +248C 5 +248D 6 +248E 7 +248F 8 +2490 9 +2491 10 +2492 11 +2493 12 +2494 13 +2495 14 +2496 15 +2497 16 +2498 17 +2499 18 +249A 19 +249B 20 +24EA 0 +24EB 11 +24EC 12 +24ED 13 +24EE 14 +24EF 15 +24F0 16 +24F1 17 +24F2 18 +24F3 19 +24F4 20 +24F5 1 +24F6 2 +24F7 3 +24F8 4 +24F9 5 +24FA 6 +24FB 7 +24FC 8 +24FD 9 +24FE 10 +2776 1 +2777 2 +2778 3 +2779 4 +277A 5 +277B 6 +277C 7 +277D 8 +277E 9 +277F 10 +2780 1 +2781 2 +2782 3 +2783 4 +2784 5 +2785 6 +2786 7 +2787 8 +2788 9 +2789 10 +278A 1 +278B 2 +278C 3 +278D 4 +278E 5 +278F 6 +2790 7 +2791 8 +2792 9 +2793 10 +3007 0 +3021 1 +3022 2 +3023 3 +3024 4 +3025 5 +3026 6 +3027 7 +3028 8 +3029 9 +3038 10 +3039 20 +303A 30 +3192 1 +3193 2 +3194 3 +3195 4 +3220 1 +3221 2 +3222 3 +3223 4 +3224 5 +3225 6 +3226 7 +3227 8 +3228 9 +3229 10 +3251 21 +3252 22 +3253 23 +3254 24 +3255 25 +3256 26 +3257 27 +3258 28 +3259 29 +325A 30 +325B 31 +325C 32 +325D 33 +325E 34 +325F 35 +3280 1 +3281 2 +3282 3 +3283 4 +3284 5 +3285 6 +3286 7 +3287 8 +3288 9 +3289 10 +32B1 36 +32B2 37 +32B3 38 +32B4 39 +32B5 40 +32B6 41 +32B7 42 +32B8 43 +32B9 44 +32BA 45 +32BB 46 +32BC 47 +32BD 48 +32BE 49 +32BF 50 +FF10 0 +FF11 1 +FF12 2 +FF13 3 +FF14 4 +FF15 5 +FF16 6 +FF17 7 +FF18 8 +FF19 9 +10320 1 +10321 5 +10322 10 +10323 50 +1D7CE 0 +1D7CF 1 +1D7D0 2 +1D7D1 3 +1D7D2 4 +1D7D3 5 +1D7D4 6 +1D7D5 7 +1D7D6 8 +1D7D7 9 +1D7D8 0 +1D7D9 1 +1D7DA 2 +1D7DB 3 +1D7DC 4 +1D7DD 5 +1D7DE 6 +1D7DF 7 +1D7E0 8 +1D7E1 9 +1D7E2 0 +1D7E3 1 +1D7E4 2 +1D7E5 3 +1D7E6 4 +1D7E7 5 +1D7E8 6 +1D7E9 7 +1D7EA 8 +1D7EB 9 +1D7EC 0 +1D7ED 1 +1D7EE 2 +1D7EF 3 +1D7F0 4 +1D7F1 5 +1D7F2 6 +1D7F3 7 +1D7F4 8 +1D7F5 9 +1D7F6 0 +1D7F7 1 +1D7F8 2 +1D7F9 3 +1D7FA 4 +1D7FB 5 +1D7FC 6 +1D7FD 7 +1D7FE 8 +1D7FF 9 +END diff --git a/Master/xemtex/perl/lib/unicore/Scripts.pl b/Master/xemtex/perl/lib/unicore/Scripts.pl new file mode 100644 index 00000000000..4c99f029cc3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/Scripts.pl @@ -0,0 +1,371 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0041 005A LATIN +0061 007A LATIN +00AA LATIN +00B5 GREEK +00BA LATIN +00C0 00D6 LATIN +00D8 00F6 LATIN +00F8 0220 LATIN +0222 0233 LATIN +0250 02AD LATIN +02B0 02B8 LATIN +02E0 02E4 LATIN +0300 034F INHERITED +0360 036F INHERITED +037A GREEK +0386 GREEK +0388 038A GREEK +038C GREEK +038E 03A1 GREEK +03A3 03CE GREEK +03D0 03F5 GREEK +0400 0481 CYRILLIC +0483 0486 CYRILLIC +0488 0489 INHERITED +048A 04CE CYRILLIC +04D0 04F5 CYRILLIC +04F8 04F9 CYRILLIC +0500 050F CYRILLIC +0531 0556 ARMENIAN +0559 ARMENIAN +0561 0587 ARMENIAN +0591 05A1 INHERITED +05A3 05B9 INHERITED +05BB 05BD INHERITED +05BF INHERITED +05C1 05C2 INHERITED +05C4 INHERITED +05D0 05EA HEBREW +05F0 05F2 HEBREW +0621 063A ARABIC +0641 064A ARABIC +064B 0655 INHERITED +066E 066F ARABIC +0670 INHERITED +0671 06D3 ARABIC +06D5 ARABIC +06D6 06E4 INHERITED +06E5 06E6 ARABIC +06E7 06E8 INHERITED +06EA 06ED INHERITED +06FA 06FC ARABIC +0710 072C SYRIAC +0730 074A SYRIAC +0780 07B1 THAANA +0901 0903 DEVANAGARI +0905 0939 DEVANAGARI +093C 094D DEVANAGARI +0950 0954 DEVANAGARI +0958 0963 DEVANAGARI +0966 096F DEVANAGARI +0981 0983 BENGALI +0985 098C BENGALI +098F 0990 BENGALI +0993 09A8 BENGALI +09AA 09B0 BENGALI +09B2 BENGALI +09B6 09B9 BENGALI +09BC BENGALI +09BE 09C4 BENGALI +09C7 09C8 BENGALI +09CB 09CD BENGALI +09D7 BENGALI +09DC 09DD BENGALI +09DF 09E3 BENGALI +09E6 09F1 BENGALI +0A02 GURMUKHI +0A05 0A0A GURMUKHI +0A0F 0A10 GURMUKHI +0A13 0A28 GURMUKHI +0A2A 0A30 GURMUKHI +0A32 0A33 GURMUKHI +0A35 0A36 GURMUKHI +0A38 0A39 GURMUKHI +0A3C GURMUKHI +0A3E 0A42 GURMUKHI +0A47 0A48 GURMUKHI +0A4B 0A4D GURMUKHI +0A59 0A5C GURMUKHI +0A5E GURMUKHI +0A66 0A74 GURMUKHI +0A81 0A83 GUJARATI +0A85 0A8B GUJARATI +0A8D GUJARATI +0A8F 0A91 GUJARATI +0A93 0AA8 GUJARATI +0AAA 0AB0 GUJARATI +0AB2 0AB3 GUJARATI +0AB5 0AB9 GUJARATI +0ABC 0AC5 GUJARATI +0AC7 0AC9 GUJARATI +0ACB 0ACD GUJARATI +0AD0 GUJARATI +0AE0 GUJARATI +0AE6 0AEF GUJARATI +0B01 0B03 ORIYA +0B05 0B0C ORIYA +0B0F 0B10 ORIYA +0B13 0B28 ORIYA +0B2A 0B30 ORIYA +0B32 0B33 ORIYA +0B36 0B39 ORIYA +0B3C 0B43 ORIYA +0B47 0B48 ORIYA +0B4B 0B4D ORIYA +0B56 0B57 ORIYA +0B5C 0B5D ORIYA +0B5F 0B61 ORIYA +0B66 0B6F ORIYA +0B82 0B83 TAMIL +0B85 0B8A TAMIL +0B8E 0B90 TAMIL +0B92 0B95 TAMIL +0B99 0B9A TAMIL +0B9C TAMIL +0B9E 0B9F TAMIL +0BA3 0BA4 TAMIL +0BA8 0BAA TAMIL +0BAE 0BB5 TAMIL +0BB7 0BB9 TAMIL +0BBE 0BC2 TAMIL +0BC6 0BC8 TAMIL +0BCA 0BCD TAMIL +0BD7 TAMIL +0BE7 0BF2 TAMIL +0C01 0C03 TELUGU +0C05 0C0C TELUGU +0C0E 0C10 TELUGU +0C12 0C28 TELUGU +0C2A 0C33 TELUGU +0C35 0C39 TELUGU +0C3E 0C44 TELUGU +0C46 0C48 TELUGU +0C4A 0C4D TELUGU +0C55 0C56 TELUGU +0C60 0C61 TELUGU +0C66 0C6F TELUGU +0C82 0C83 KANNADA +0C85 0C8C KANNADA +0C8E 0C90 KANNADA +0C92 0CA8 KANNADA +0CAA 0CB3 KANNADA +0CB5 0CB9 KANNADA +0CBE 0CC4 KANNADA +0CC6 0CC8 KANNADA +0CCA 0CCD KANNADA +0CD5 0CD6 KANNADA +0CDE KANNADA +0CE0 0CE1 KANNADA +0CE6 0CEF KANNADA +0D02 0D03 MALAYALAM +0D05 0D0C MALAYALAM +0D0E 0D10 MALAYALAM +0D12 0D28 MALAYALAM +0D2A 0D39 MALAYALAM +0D3E 0D43 MALAYALAM +0D46 0D48 MALAYALAM +0D4A 0D4D MALAYALAM +0D57 MALAYALAM +0D60 0D61 MALAYALAM +0D66 0D6F MALAYALAM +0D82 0D83 SINHALA +0D85 0D96 SINHALA +0D9A 0DB1 SINHALA +0DB3 0DBB SINHALA +0DBD SINHALA +0DC0 0DC6 SINHALA +0DCA SINHALA +0DCF 0DD4 SINHALA +0DD6 SINHALA +0DD8 0DDF SINHALA +0DF2 0DF3 SINHALA +0E01 0E3A THAI +0E40 0E4E THAI +0E50 0E59 THAI +0E81 0E82 LAO +0E84 LAO +0E87 0E88 LAO +0E8A LAO +0E8D LAO +0E94 0E97 LAO +0E99 0E9F LAO +0EA1 0EA3 LAO +0EA5 LAO +0EA7 LAO +0EAA 0EAB LAO +0EAD 0EB9 LAO +0EBB 0EBD LAO +0EC0 0EC4 LAO +0EC6 LAO +0EC8 0ECD LAO +0ED0 0ED9 LAO +0EDC 0EDD LAO +0F00 TIBETAN +0F18 0F19 TIBETAN +0F20 0F33 TIBETAN +0F35 TIBETAN +0F37 TIBETAN +0F39 TIBETAN +0F40 0F47 TIBETAN +0F49 0F6A TIBETAN +0F71 0F84 TIBETAN +0F86 0F8B TIBETAN +0F90 0F97 TIBETAN +0F99 0FBC TIBETAN +0FC6 TIBETAN +1000 1021 MYANMAR +1023 1027 MYANMAR +1029 102A MYANMAR +102C 1032 MYANMAR +1036 1039 MYANMAR +1040 1049 MYANMAR +1050 1059 MYANMAR +10A0 10C5 GEORGIAN +10D0 10F8 GEORGIAN +1100 1159 HANGUL +115F 11A2 HANGUL +11A8 11F9 HANGUL +1200 1206 ETHIOPIC +1208 1246 ETHIOPIC +1248 ETHIOPIC +124A 124D ETHIOPIC +1250 1256 ETHIOPIC +1258 ETHIOPIC +125A 125D ETHIOPIC +1260 1286 ETHIOPIC +1288 ETHIOPIC +128A 128D ETHIOPIC +1290 12AE ETHIOPIC +12B0 ETHIOPIC +12B2 12B5 ETHIOPIC +12B8 12BE ETHIOPIC +12C0 ETHIOPIC +12C2 12C5 ETHIOPIC +12C8 12CE ETHIOPIC +12D0 12D6 ETHIOPIC +12D8 12EE ETHIOPIC +12F0 130E ETHIOPIC +1310 ETHIOPIC +1312 1315 ETHIOPIC +1318 131E ETHIOPIC +1320 1346 ETHIOPIC +1348 135A ETHIOPIC +1369 137C ETHIOPIC +13A0 13F4 CHEROKEE +1401 166C CANADIAN_ABORIGINAL +166F 1676 CANADIAN_ABORIGINAL +1681 169A OGHAM +16A0 16EA RUNIC +16EE 16F0 RUNIC +1700 170C TAGALOG +170E 1714 TAGALOG +1720 1734 HANUNOO +1740 1753 BUHID +1760 176C TAGBANWA +176E 1770 TAGBANWA +1772 1773 TAGBANWA +1780 17D3 KHMER +17E0 17E9 KHMER +180B 180D INHERITED +1810 1819 MONGOLIAN +1820 1877 MONGOLIAN +1880 18A9 MONGOLIAN +1E00 1E9B LATIN +1EA0 1EF9 LATIN +1F00 1F15 GREEK +1F18 1F1D GREEK +1F20 1F45 GREEK +1F48 1F4D GREEK +1F50 1F57 GREEK +1F59 GREEK +1F5B GREEK +1F5D GREEK +1F5F 1F7D GREEK +1F80 1FB4 GREEK +1FB6 1FBC GREEK +1FBE GREEK +1FC2 1FC4 GREEK +1FC6 1FCC GREEK +1FD0 1FD3 GREEK +1FD6 1FDB GREEK +1FE0 1FEC GREEK +1FF2 1FF4 GREEK +1FF6 1FFC GREEK +2071 LATIN +207F LATIN +20D0 20EA INHERITED +2126 GREEK +212A 212B LATIN +2E80 2E99 HAN +2E9B 2EF3 HAN +2F00 2FD5 HAN +3005 HAN +3007 HAN +3021 3029 HAN +302A 302F INHERITED +3038 303B HAN +3041 3096 HIRAGANA +3099 309A INHERITED +309D 309F HIRAGANA +30A1 30FA KATAKANA +30FD 30FF KATAKANA +3105 312C BOPOMOFO +3131 318E HANGUL +31A0 31B7 BOPOMOFO +31F0 31FF KATAKANA +3400 4DB5 HAN +4E00 9FA5 HAN +A000 A48C YI +A490 A4A1 YI +A4A4 A4B3 YI +A4B5 A4C0 YI +A4C2 A4C4 YI +A4C6 YI +AC00 D7A3 HANGUL +F900 FA2D HAN +FA30 FA6A HAN +FB00 FB06 LATIN +FB13 FB17 ARMENIAN +FB1D HEBREW +FB1E INHERITED +FB1F FB28 HEBREW +FB2A FB36 HEBREW +FB38 FB3C HEBREW +FB3E HEBREW +FB40 FB41 HEBREW +FB43 FB44 HEBREW +FB46 FB4F HEBREW +FB50 FBB1 ARABIC +FBD3 FD3D ARABIC +FD50 FD8F ARABIC +FD92 FDC7 ARABIC +FDF0 FDFB ARABIC +FE00 FE0F INHERITED +FE20 FE23 INHERITED +FE70 FE74 ARABIC +FE76 FEFC ARABIC +FF21 FF3A LATIN +FF41 FF5A LATIN +FF66 FF6F KATAKANA +FF71 FF9D KATAKANA +FFA0 FFBE HANGUL +FFC2 FFC7 HANGUL +FFCA FFCF HANGUL +FFD2 FFD7 HANGUL +FFDA FFDC HANGUL +10300 1031E OLD_ITALIC +10330 1034A GOTHIC +10400 10425 DESERET +10428 1044D DESERET +1D167 1D169 INHERITED +1D17B 1D182 INHERITED +1D185 1D18B INHERITED +1D1AA 1D1AD INHERITED +20000 2A6D6 HAN +2F800 2FA1D HAN +END diff --git a/Master/xemtex/perl/lib/unicore/To/Digit.pl b/Master/xemtex/perl/lib/unicore/To/Digit.pl new file mode 100644 index 00000000000..e5c0ff429ea --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/To/Digit.pl @@ -0,0 +1,274 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +return <<'END'; +0030 0 +0031 1 +0032 2 +0033 3 +0034 4 +0035 5 +0036 6 +0037 7 +0038 8 +0039 9 +00B2 2 +00B3 3 +00B9 1 +0660 0 +0661 1 +0662 2 +0663 3 +0664 4 +0665 5 +0666 6 +0667 7 +0668 8 +0669 9 +06F0 0 +06F1 1 +06F2 2 +06F3 3 +06F4 4 +06F5 5 +06F6 6 +06F7 7 +06F8 8 +06F9 9 +0966 0 +0967 1 +0968 2 +0969 3 +096A 4 +096B 5 +096C 6 +096D 7 +096E 8 +096F 9 +09E6 0 +09E7 1 +09E8 2 +09E9 3 +09EA 4 +09EB 5 +09EC 6 +09ED 7 +09EE 8 +09EF 9 +0A66 0 +0A67 1 +0A68 2 +0A69 3 +0A6A 4 +0A6B 5 +0A6C 6 +0A6D 7 +0A6E 8 +0A6F 9 +0AE6 0 +0AE7 1 +0AE8 2 +0AE9 3 +0AEA 4 +0AEB 5 +0AEC 6 +0AED 7 +0AEE 8 +0AEF 9 +0B66 0 +0B67 1 +0B68 2 +0B69 3 +0B6A 4 +0B6B 5 +0B6C 6 +0B6D 7 +0B6E 8 +0B6F 9 +0BE7 1 +0BE8 2 +0BE9 3 +0BEA 4 +0BEB 5 +0BEC 6 +0BED 7 +0BEE 8 +0BEF 9 +0C66 0 +0C67 1 +0C68 2 +0C69 3 +0C6A 4 +0C6B 5 +0C6C 6 +0C6D 7 +0C6E 8 +0C6F 9 +0CE6 0 +0CE7 1 +0CE8 2 +0CE9 3 +0CEA 4 +0CEB 5 +0CEC 6 +0CED 7 +0CEE 8 +0CEF 9 +0D66 0 +0D67 1 +0D68 2 +0D69 3 +0D6A 4 +0D6B 5 +0D6C 6 +0D6D 7 +0D6E 8 +0D6F 9 +0E50 0 +0E51 1 +0E52 2 +0E53 3 +0E54 4 +0E55 5 +0E56 6 +0E57 7 +0E58 8 +0E59 9 +0ED0 0 +0ED1 1 +0ED2 2 +0ED3 3 +0ED4 4 +0ED5 5 +0ED6 6 +0ED7 7 +0ED8 8 +0ED9 9 +0F20 0 +0F21 1 +0F22 2 +0F23 3 +0F24 4 +0F25 5 +0F26 6 +0F27 7 +0F28 8 +0F29 9 +1040 0 +1041 1 +1042 2 +1043 3 +1044 4 +1045 5 +1046 6 +1047 7 +1048 8 +1049 9 +1369 1 +136A 2 +136B 3 +136C 4 +136D 5 +136E 6 +136F 7 +1370 8 +1371 9 +17E0 0 +17E1 1 +17E2 2 +17E3 3 +17E4 4 +17E5 5 +17E6 6 +17E7 7 +17E8 8 +17E9 9 +1810 0 +1811 1 +1812 2 +1813 3 +1814 4 +1815 5 +1816 6 +1817 7 +1818 8 +1819 9 +2070 0 +2074 4 +2075 5 +2076 6 +2077 7 +2078 8 +2079 9 +2080 0 +2081 1 +2082 2 +2083 3 +2084 4 +2085 5 +2086 6 +2087 7 +2088 8 +2089 9 +FF10 0 +FF11 1 +FF12 2 +FF13 3 +FF14 4 +FF15 5 +FF16 6 +FF17 7 +FF18 8 +FF19 9 +1D7CE 0 +1D7CF 1 +1D7D0 2 +1D7D1 3 +1D7D2 4 +1D7D3 5 +1D7D4 6 +1D7D5 7 +1D7D6 8 +1D7D7 9 +1D7D8 0 +1D7D9 1 +1D7DA 2 +1D7DB 3 +1D7DC 4 +1D7DD 5 +1D7DE 6 +1D7DF 7 +1D7E0 8 +1D7E1 9 +1D7E2 0 +1D7E3 1 +1D7E4 2 +1D7E5 3 +1D7E6 4 +1D7E7 5 +1D7E8 6 +1D7E9 7 +1D7EA 8 +1D7EB 9 +1D7EC 0 +1D7ED 1 +1D7EE 2 +1D7EF 3 +1D7F0 4 +1D7F1 5 +1D7F2 6 +1D7F3 7 +1D7F4 8 +1D7F5 9 +1D7F6 0 +1D7F7 1 +1D7F8 2 +1D7F9 3 +1D7FA 4 +1D7FB 5 +1D7FC 6 +1D7FD 7 +1D7FE 8 +1D7FF 9 +END diff --git a/Master/xemtex/perl/lib/unicore/To/Fold.pl b/Master/xemtex/perl/lib/unicore/To/Fold.pl new file mode 100644 index 00000000000..2a355ad6a39 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/To/Fold.pl @@ -0,0 +1,849 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + + +%utf8::ToSpecFold = +( +'00DF' => "\x{0073}\x{0073}", +'0130' => "\x{0069}\x{0307}", +'0149' => "\x{02BC}\x{006E}", +'01F0' => "\x{006A}\x{030C}", +'0390' => "\x{03B9}\x{0308}\x{0301}", +'03B0' => "\x{03C5}\x{0308}\x{0301}", +'0587' => "\x{0565}\x{0582}", +'1E96' => "\x{0068}\x{0331}", +'1E97' => "\x{0074}\x{0308}", +'1E98' => "\x{0077}\x{030A}", +'1E99' => "\x{0079}\x{030A}", +'1E9A' => "\x{0061}\x{02BE}", +'1F50' => "\x{03C5}\x{0313}", +'1F52' => "\x{03C5}\x{0313}\x{0300}", +'1F54' => "\x{03C5}\x{0313}\x{0301}", +'1F56' => "\x{03C5}\x{0313}\x{0342}", +'1F80' => "\x{1F00}\x{03B9}", +'1F81' => "\x{1F01}\x{03B9}", +'1F82' => "\x{1F02}\x{03B9}", +'1F83' => "\x{1F03}\x{03B9}", +'1F84' => "\x{1F04}\x{03B9}", +'1F85' => "\x{1F05}\x{03B9}", +'1F86' => "\x{1F06}\x{03B9}", +'1F87' => "\x{1F07}\x{03B9}", +'1F88' => "\x{1F00}\x{03B9}", +'1F89' => "\x{1F01}\x{03B9}", +'1F8A' => "\x{1F02}\x{03B9}", +'1F8B' => "\x{1F03}\x{03B9}", +'1F8C' => "\x{1F04}\x{03B9}", +'1F8D' => "\x{1F05}\x{03B9}", +'1F8E' => "\x{1F06}\x{03B9}", +'1F8F' => "\x{1F07}\x{03B9}", +'1F90' => "\x{1F20}\x{03B9}", +'1F91' => "\x{1F21}\x{03B9}", +'1F92' => "\x{1F22}\x{03B9}", +'1F93' => "\x{1F23}\x{03B9}", +'1F94' => "\x{1F24}\x{03B9}", +'1F95' => "\x{1F25}\x{03B9}", +'1F96' => "\x{1F26}\x{03B9}", +'1F97' => "\x{1F27}\x{03B9}", +'1F98' => "\x{1F20}\x{03B9}", +'1F99' => "\x{1F21}\x{03B9}", +'1F9A' => "\x{1F22}\x{03B9}", +'1F9B' => "\x{1F23}\x{03B9}", +'1F9C' => "\x{1F24}\x{03B9}", +'1F9D' => "\x{1F25}\x{03B9}", +'1F9E' => "\x{1F26}\x{03B9}", +'1F9F' => "\x{1F27}\x{03B9}", +'1FA0' => "\x{1F60}\x{03B9}", +'1FA1' => "\x{1F61}\x{03B9}", +'1FA2' => "\x{1F62}\x{03B9}", +'1FA3' => "\x{1F63}\x{03B9}", +'1FA4' => "\x{1F64}\x{03B9}", +'1FA5' => "\x{1F65}\x{03B9}", +'1FA6' => "\x{1F66}\x{03B9}", +'1FA7' => "\x{1F67}\x{03B9}", +'1FA8' => "\x{1F60}\x{03B9}", +'1FA9' => "\x{1F61}\x{03B9}", +'1FAA' => "\x{1F62}\x{03B9}", +'1FAB' => "\x{1F63}\x{03B9}", +'1FAC' => "\x{1F64}\x{03B9}", +'1FAD' => "\x{1F65}\x{03B9}", +'1FAE' => "\x{1F66}\x{03B9}", +'1FAF' => "\x{1F67}\x{03B9}", +'1FB2' => "\x{1F70}\x{03B9}", +'1FB3' => "\x{03B1}\x{03B9}", +'1FB4' => "\x{03AC}\x{03B9}", +'1FB6' => "\x{03B1}\x{0342}", +'1FB7' => "\x{03B1}\x{0342}\x{03B9}", +'1FBC' => "\x{03B1}\x{03B9}", +'1FC2' => "\x{1F74}\x{03B9}", +'1FC3' => "\x{03B7}\x{03B9}", +'1FC4' => "\x{03AE}\x{03B9}", +'1FC6' => "\x{03B7}\x{0342}", +'1FC7' => "\x{03B7}\x{0342}\x{03B9}", +'1FCC' => "\x{03B7}\x{03B9}", +'1FD2' => "\x{03B9}\x{0308}\x{0300}", +'1FD3' => "\x{03B9}\x{0308}\x{0301}", +'1FD6' => "\x{03B9}\x{0342}", +'1FD7' => "\x{03B9}\x{0308}\x{0342}", +'1FE2' => "\x{03C5}\x{0308}\x{0300}", +'1FE3' => "\x{03C5}\x{0308}\x{0301}", +'1FE4' => "\x{03C1}\x{0313}", +'1FE6' => "\x{03C5}\x{0342}", +'1FE7' => "\x{03C5}\x{0308}\x{0342}", +'1FF2' => "\x{1F7C}\x{03B9}", +'1FF3' => "\x{03C9}\x{03B9}", +'1FF4' => "\x{03CE}\x{03B9}", +'1FF6' => "\x{03C9}\x{0342}", +'1FF7' => "\x{03C9}\x{0342}\x{03B9}", +'1FFC' => "\x{03C9}\x{03B9}", +'FB00' => "\x{0066}\x{0066}", +'FB01' => "\x{0066}\x{0069}", +'FB02' => "\x{0066}\x{006C}", +'FB03' => "\x{0066}\x{0066}\x{0069}", +'FB04' => "\x{0066}\x{0066}\x{006C}", +'FB05' => "\x{0073}\x{0074}", +'FB06' => "\x{0073}\x{0074}", +'FB13' => "\x{0574}\x{0576}", +'FB14' => "\x{0574}\x{0565}", +'FB15' => "\x{0574}\x{056B}", +'FB16' => "\x{057E}\x{0576}", +'FB17' => "\x{0574}\x{056D}", +); + +return <<'END'; +0041 0061 +0042 0062 +0043 0063 +0044 0064 +0045 0065 +0046 0066 +0047 0067 +0048 0068 +0049 0069 +004A 006A +004B 006B +004C 006C +004D 006D +004E 006E +004F 006F +0050 0070 +0051 0071 +0052 0072 +0053 0073 +0054 0074 +0055 0075 +0056 0076 +0057 0077 +0058 0078 +0059 0079 +005A 007A +00B5 03BC +00C0 00E0 +00C1 00E1 +00C2 00E2 +00C3 00E3 +00C4 00E4 +00C5 00E5 +00C6 00E6 +00C7 00E7 +00C8 00E8 +00C9 00E9 +00CA 00EA +00CB 00EB +00CC 00EC +00CD 00ED +00CE 00EE +00CF 00EF +00D0 00F0 +00D1 00F1 +00D2 00F2 +00D3 00F3 +00D4 00F4 +00D5 00F5 +00D6 00F6 +00D8 00F8 +00D9 00F9 +00DA 00FA +00DB 00FB +00DC 00FC +00DD 00FD +00DE 00FE +0100 0101 +0102 0103 +0104 0105 +0106 0107 +0108 0109 +010A 010B +010C 010D +010E 010F +0110 0111 +0112 0113 +0114 0115 +0116 0117 +0118 0119 +011A 011B +011C 011D +011E 011F +0120 0121 +0122 0123 +0124 0125 +0126 0127 +0128 0129 +012A 012B +012C 012D +012E 012F +0132 0133 +0134 0135 +0136 0137 +0139 013A +013B 013C +013D 013E +013F 0140 +0141 0142 +0143 0144 +0145 0146 +0147 0148 +014A 014B +014C 014D +014E 014F +0150 0151 +0152 0153 +0154 0155 +0156 0157 +0158 0159 +015A 015B +015C 015D +015E 015F +0160 0161 +0162 0163 +0164 0165 +0166 0167 +0168 0169 +016A 016B +016C 016D +016E 016F +0170 0171 +0172 0173 +0174 0175 +0176 0177 +0178 00FF +0179 017A +017B 017C +017D 017E +017F 0073 +0181 0253 +0182 0183 +0184 0185 +0186 0254 +0187 0188 +0189 0256 +018A 0257 +018B 018C +018E 01DD +018F 0259 +0190 025B +0191 0192 +0193 0260 +0194 0263 +0196 0269 +0197 0268 +0198 0199 +019C 026F +019D 0272 +019F 0275 +01A0 01A1 +01A2 01A3 +01A4 01A5 +01A6 0280 +01A7 01A8 +01A9 0283 +01AC 01AD +01AE 0288 +01AF 01B0 +01B1 028A +01B2 028B +01B3 01B4 +01B5 01B6 +01B7 0292 +01B8 01B9 +01BC 01BD +01C4 01C6 +01C5 01C6 +01C7 01C9 +01C8 01C9 +01CA 01CC +01CB 01CC +01CD 01CE +01CF 01D0 +01D1 01D2 +01D3 01D4 +01D5 01D6 +01D7 01D8 +01D9 01DA +01DB 01DC +01DE 01DF +01E0 01E1 +01E2 01E3 +01E4 01E5 +01E6 01E7 +01E8 01E9 +01EA 01EB +01EC 01ED +01EE 01EF +01F1 01F3 +01F2 01F3 +01F4 01F5 +01F6 0195 +01F7 01BF +01F8 01F9 +01FA 01FB +01FC 01FD +01FE 01FF +0200 0201 +0202 0203 +0204 0205 +0206 0207 +0208 0209 +020A 020B +020C 020D +020E 020F +0210 0211 +0212 0213 +0214 0215 +0216 0217 +0218 0219 +021A 021B +021C 021D +021E 021F +0220 019E +0222 0223 +0224 0225 +0226 0227 +0228 0229 +022A 022B +022C 022D +022E 022F +0230 0231 +0232 0233 +0345 03B9 +0386 03AC +0388 03AD +0389 03AE +038A 03AF +038C 03CC +038E 03CD +038F 03CE +0391 03B1 +0392 03B2 +0393 03B3 +0394 03B4 +0395 03B5 +0396 03B6 +0397 03B7 +0398 03B8 +0399 03B9 +039A 03BA +039B 03BB +039C 03BC +039D 03BD +039E 03BE +039F 03BF +03A0 03C0 +03A1 03C1 +03A3 03C3 +03A4 03C4 +03A5 03C5 +03A6 03C6 +03A7 03C7 +03A8 03C8 +03A9 03C9 +03AA 03CA +03AB 03CB +03C2 03C3 +03D0 03B2 +03D1 03B8 +03D5 03C6 +03D6 03C0 +03D8 03D9 +03DA 03DB +03DC 03DD +03DE 03DF +03E0 03E1 +03E2 03E3 +03E4 03E5 +03E6 03E7 +03E8 03E9 +03EA 03EB +03EC 03ED +03EE 03EF +03F0 03BA +03F1 03C1 +03F2 03C3 +03F4 03B8 +03F5 03B5 +0400 0450 +0401 0451 +0402 0452 +0403 0453 +0404 0454 +0405 0455 +0406 0456 +0407 0457 +0408 0458 +0409 0459 +040A 045A +040B 045B +040C 045C +040D 045D +040E 045E +040F 045F +0410 0430 +0411 0431 +0412 0432 +0413 0433 +0414 0434 +0415 0435 +0416 0436 +0417 0437 +0418 0438 +0419 0439 +041A 043A +041B 043B +041C 043C +041D 043D +041E 043E +041F 043F +0420 0440 +0421 0441 +0422 0442 +0423 0443 +0424 0444 +0425 0445 +0426 0446 +0427 0447 +0428 0448 +0429 0449 +042A 044A +042B 044B +042C 044C +042D 044D +042E 044E +042F 044F +0460 0461 +0462 0463 +0464 0465 +0466 0467 +0468 0469 +046A 046B +046C 046D +046E 046F +0470 0471 +0472 0473 +0474 0475 +0476 0477 +0478 0479 +047A 047B +047C 047D +047E 047F +0480 0481 +048A 048B +048C 048D +048E 048F +0490 0491 +0492 0493 +0494 0495 +0496 0497 +0498 0499 +049A 049B +049C 049D +049E 049F +04A0 04A1 +04A2 04A3 +04A4 04A5 +04A6 04A7 +04A8 04A9 +04AA 04AB +04AC 04AD +04AE 04AF +04B0 04B1 +04B2 04B3 +04B4 04B5 +04B6 04B7 +04B8 04B9 +04BA 04BB +04BC 04BD +04BE 04BF +04C1 04C2 +04C3 04C4 +04C5 04C6 +04C7 04C8 +04C9 04CA +04CB 04CC +04CD 04CE +04D0 04D1 +04D2 04D3 +04D4 04D5 +04D6 04D7 +04D8 04D9 +04DA 04DB +04DC 04DD +04DE 04DF +04E0 04E1 +04E2 04E3 +04E4 04E5 +04E6 04E7 +04E8 04E9 +04EA 04EB +04EC 04ED +04EE 04EF +04F0 04F1 +04F2 04F3 +04F4 04F5 +04F8 04F9 +0500 0501 +0502 0503 +0504 0505 +0506 0507 +0508 0509 +050A 050B +050C 050D +050E 050F +0531 0561 +0532 0562 +0533 0563 +0534 0564 +0535 0565 +0536 0566 +0537 0567 +0538 0568 +0539 0569 +053A 056A +053B 056B +053C 056C +053D 056D +053E 056E +053F 056F +0540 0570 +0541 0571 +0542 0572 +0543 0573 +0544 0574 +0545 0575 +0546 0576 +0547 0577 +0548 0578 +0549 0579 +054A 057A +054B 057B +054C 057C +054D 057D +054E 057E +054F 057F +0550 0580 +0551 0581 +0552 0582 +0553 0583 +0554 0584 +0555 0585 +0556 0586 +1E00 1E01 +1E02 1E03 +1E04 1E05 +1E06 1E07 +1E08 1E09 +1E0A 1E0B +1E0C 1E0D +1E0E 1E0F +1E10 1E11 +1E12 1E13 +1E14 1E15 +1E16 1E17 +1E18 1E19 +1E1A 1E1B +1E1C 1E1D +1E1E 1E1F +1E20 1E21 +1E22 1E23 +1E24 1E25 +1E26 1E27 +1E28 1E29 +1E2A 1E2B +1E2C 1E2D +1E2E 1E2F +1E30 1E31 +1E32 1E33 +1E34 1E35 +1E36 1E37 +1E38 1E39 +1E3A 1E3B +1E3C 1E3D +1E3E 1E3F +1E40 1E41 +1E42 1E43 +1E44 1E45 +1E46 1E47 +1E48 1E49 +1E4A 1E4B +1E4C 1E4D +1E4E 1E4F +1E50 1E51 +1E52 1E53 +1E54 1E55 +1E56 1E57 +1E58 1E59 +1E5A 1E5B +1E5C 1E5D +1E5E 1E5F +1E60 1E61 +1E62 1E63 +1E64 1E65 +1E66 1E67 +1E68 1E69 +1E6A 1E6B +1E6C 1E6D +1E6E 1E6F +1E70 1E71 +1E72 1E73 +1E74 1E75 +1E76 1E77 +1E78 1E79 +1E7A 1E7B +1E7C 1E7D +1E7E 1E7F +1E80 1E81 +1E82 1E83 +1E84 1E85 +1E86 1E87 +1E88 1E89 +1E8A 1E8B +1E8C 1E8D +1E8E 1E8F +1E90 1E91 +1E92 1E93 +1E94 1E95 +1E9B 1E61 +1EA0 1EA1 +1EA2 1EA3 +1EA4 1EA5 +1EA6 1EA7 +1EA8 1EA9 +1EAA 1EAB +1EAC 1EAD +1EAE 1EAF +1EB0 1EB1 +1EB2 1EB3 +1EB4 1EB5 +1EB6 1EB7 +1EB8 1EB9 +1EBA 1EBB +1EBC 1EBD +1EBE 1EBF +1EC0 1EC1 +1EC2 1EC3 +1EC4 1EC5 +1EC6 1EC7 +1EC8 1EC9 +1ECA 1ECB +1ECC 1ECD +1ECE 1ECF +1ED0 1ED1 +1ED2 1ED3 +1ED4 1ED5 +1ED6 1ED7 +1ED8 1ED9 +1EDA 1EDB +1EDC 1EDD +1EDE 1EDF +1EE0 1EE1 +1EE2 1EE3 +1EE4 1EE5 +1EE6 1EE7 +1EE8 1EE9 +1EEA 1EEB +1EEC 1EED +1EEE 1EEF +1EF0 1EF1 +1EF2 1EF3 +1EF4 1EF5 +1EF6 1EF7 +1EF8 1EF9 +1F08 1F00 +1F09 1F01 +1F0A 1F02 +1F0B 1F03 +1F0C 1F04 +1F0D 1F05 +1F0E 1F06 +1F0F 1F07 +1F18 1F10 +1F19 1F11 +1F1A 1F12 +1F1B 1F13 +1F1C 1F14 +1F1D 1F15 +1F28 1F20 +1F29 1F21 +1F2A 1F22 +1F2B 1F23 +1F2C 1F24 +1F2D 1F25 +1F2E 1F26 +1F2F 1F27 +1F38 1F30 +1F39 1F31 +1F3A 1F32 +1F3B 1F33 +1F3C 1F34 +1F3D 1F35 +1F3E 1F36 +1F3F 1F37 +1F48 1F40 +1F49 1F41 +1F4A 1F42 +1F4B 1F43 +1F4C 1F44 +1F4D 1F45 +1F59 1F51 +1F5B 1F53 +1F5D 1F55 +1F5F 1F57 +1F68 1F60 +1F69 1F61 +1F6A 1F62 +1F6B 1F63 +1F6C 1F64 +1F6D 1F65 +1F6E 1F66 +1F6F 1F67 +1FB8 1FB0 +1FB9 1FB1 +1FBA 1F70 +1FBB 1F71 +1FBE 03B9 +1FC8 1F72 +1FC9 1F73 +1FCA 1F74 +1FCB 1F75 +1FD8 1FD0 +1FD9 1FD1 +1FDA 1F76 +1FDB 1F77 +1FE8 1FE0 +1FE9 1FE1 +1FEA 1F7A +1FEB 1F7B +1FEC 1FE5 +1FF8 1F78 +1FF9 1F79 +1FFA 1F7C +1FFB 1F7D +2126 03C9 +212A 006B +212B 00E5 +2160 2170 +2161 2171 +2162 2172 +2163 2173 +2164 2174 +2165 2175 +2166 2176 +2167 2177 +2168 2178 +2169 2179 +216A 217A +216B 217B +216C 217C +216D 217D +216E 217E +216F 217F +24B6 24D0 +24B7 24D1 +24B8 24D2 +24B9 24D3 +24BA 24D4 +24BB 24D5 +24BC 24D6 +24BD 24D7 +24BE 24D8 +24BF 24D9 +24C0 24DA +24C1 24DB +24C2 24DC +24C3 24DD +24C4 24DE +24C5 24DF +24C6 24E0 +24C7 24E1 +24C8 24E2 +24C9 24E3 +24CA 24E4 +24CB 24E5 +24CC 24E6 +24CD 24E7 +24CE 24E8 +24CF 24E9 +FF21 FF41 +FF22 FF42 +FF23 FF43 +FF24 FF44 +FF25 FF45 +FF26 FF46 +FF27 FF47 +FF28 FF48 +FF29 FF49 +FF2A FF4A +FF2B FF4B +FF2C FF4C +FF2D FF4D +FF2E FF4E +FF2F FF4F +FF30 FF50 +FF31 FF51 +FF32 FF52 +FF33 FF53 +FF34 FF54 +FF35 FF55 +FF36 FF56 +FF37 FF57 +FF38 FF58 +FF39 FF59 +FF3A FF5A +10400 10428 +10401 10429 +10402 1042A +10403 1042B +10404 1042C +10405 1042D +10406 1042E +10407 1042F +10408 10430 +10409 10431 +1040A 10432 +1040B 10433 +1040C 10434 +1040D 10435 +1040E 10436 +1040F 10437 +10410 10438 +10411 10439 +10412 1043A +10413 1043B +10414 1043C +10415 1043D +10416 1043E +10417 1043F +10418 10440 +10419 10441 +1041A 10442 +1041B 10443 +1041C 10444 +1041D 10445 +1041E 10446 +1041F 10447 +10420 10448 +10421 10449 +10422 1044A +10423 1044B +10424 1044C +10425 1044D +END diff --git a/Master/xemtex/perl/lib/unicore/To/Lower.pl b/Master/xemtex/perl/lib/unicore/To/Lower.pl new file mode 100644 index 00000000000..cbb27214882 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/To/Lower.pl @@ -0,0 +1,760 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + + +%utf8::ToSpecLower = +( +'0130' => "\x{0069}\x{0307}", +'1F88' => "\x{1F80}", +'1F89' => "\x{1F81}", +'1F8A' => "\x{1F82}", +'1F8B' => "\x{1F83}", +'1F8C' => "\x{1F84}", +'1F8D' => "\x{1F85}", +'1F8E' => "\x{1F86}", +'1F8F' => "\x{1F87}", +'1F98' => "\x{1F90}", +'1F99' => "\x{1F91}", +'1F9A' => "\x{1F92}", +'1F9B' => "\x{1F93}", +'1F9C' => "\x{1F94}", +'1F9D' => "\x{1F95}", +'1F9E' => "\x{1F96}", +'1F9F' => "\x{1F97}", +'1FA8' => "\x{1FA0}", +'1FA9' => "\x{1FA1}", +'1FAA' => "\x{1FA2}", +'1FAB' => "\x{1FA3}", +'1FAC' => "\x{1FA4}", +'1FAD' => "\x{1FA5}", +'1FAE' => "\x{1FA6}", +'1FAF' => "\x{1FA7}", +'1FBC' => "\x{1FB3}", +'1FCC' => "\x{1FC3}", +'1FFC' => "\x{1FF3}", +); + +return <<'END'; +0041 0061 +0042 0062 +0043 0063 +0044 0064 +0045 0065 +0046 0066 +0047 0067 +0048 0068 +0049 0069 +004A 006A +004B 006B +004C 006C +004D 006D +004E 006E +004F 006F +0050 0070 +0051 0071 +0052 0072 +0053 0073 +0054 0074 +0055 0075 +0056 0076 +0057 0077 +0058 0078 +0059 0079 +005A 007A +00C0 00E0 +00C1 00E1 +00C2 00E2 +00C3 00E3 +00C4 00E4 +00C5 00E5 +00C6 00E6 +00C7 00E7 +00C8 00E8 +00C9 00E9 +00CA 00EA +00CB 00EB +00CC 00EC +00CD 00ED +00CE 00EE +00CF 00EF +00D0 00F0 +00D1 00F1 +00D2 00F2 +00D3 00F3 +00D4 00F4 +00D5 00F5 +00D6 00F6 +00D8 00F8 +00D9 00F9 +00DA 00FA +00DB 00FB +00DC 00FC +00DD 00FD +00DE 00FE +0100 0101 +0102 0103 +0104 0105 +0106 0107 +0108 0109 +010A 010B +010C 010D +010E 010F +0110 0111 +0112 0113 +0114 0115 +0116 0117 +0118 0119 +011A 011B +011C 011D +011E 011F +0120 0121 +0122 0123 +0124 0125 +0126 0127 +0128 0129 +012A 012B +012C 012D +012E 012F +0132 0133 +0134 0135 +0136 0137 +0139 013A +013B 013C +013D 013E +013F 0140 +0141 0142 +0143 0144 +0145 0146 +0147 0148 +014A 014B +014C 014D +014E 014F +0150 0151 +0152 0153 +0154 0155 +0156 0157 +0158 0159 +015A 015B +015C 015D +015E 015F +0160 0161 +0162 0163 +0164 0165 +0166 0167 +0168 0169 +016A 016B +016C 016D +016E 016F +0170 0171 +0172 0173 +0174 0175 +0176 0177 +0178 00FF +0179 017A +017B 017C +017D 017E +0181 0253 +0182 0183 +0184 0185 +0186 0254 +0187 0188 +0189 0256 +018A 0257 +018B 018C +018E 01DD +018F 0259 +0190 025B +0191 0192 +0193 0260 +0194 0263 +0196 0269 +0197 0268 +0198 0199 +019C 026F +019D 0272 +019F 0275 +01A0 01A1 +01A2 01A3 +01A4 01A5 +01A6 0280 +01A7 01A8 +01A9 0283 +01AC 01AD +01AE 0288 +01AF 01B0 +01B1 028A +01B2 028B +01B3 01B4 +01B5 01B6 +01B7 0292 +01B8 01B9 +01BC 01BD +01C4 01C6 +01C5 01C6 +01C7 01C9 +01C8 01C9 +01CA 01CC +01CB 01CC +01CD 01CE +01CF 01D0 +01D1 01D2 +01D3 01D4 +01D5 01D6 +01D7 01D8 +01D9 01DA +01DB 01DC +01DE 01DF +01E0 01E1 +01E2 01E3 +01E4 01E5 +01E6 01E7 +01E8 01E9 +01EA 01EB +01EC 01ED +01EE 01EF +01F1 01F3 +01F2 01F3 +01F4 01F5 +01F6 0195 +01F7 01BF +01F8 01F9 +01FA 01FB +01FC 01FD +01FE 01FF +0200 0201 +0202 0203 +0204 0205 +0206 0207 +0208 0209 +020A 020B +020C 020D +020E 020F +0210 0211 +0212 0213 +0214 0215 +0216 0217 +0218 0219 +021A 021B +021C 021D +021E 021F +0220 019E +0222 0223 +0224 0225 +0226 0227 +0228 0229 +022A 022B +022C 022D +022E 022F +0230 0231 +0232 0233 +0386 03AC +0388 03AD +0389 03AE +038A 03AF +038C 03CC +038E 03CD +038F 03CE +0391 03B1 +0392 03B2 +0393 03B3 +0394 03B4 +0395 03B5 +0396 03B6 +0397 03B7 +0398 03B8 +0399 03B9 +039A 03BA +039B 03BB +039C 03BC +039D 03BD +039E 03BE +039F 03BF +03A0 03C0 +03A1 03C1 +03A3 03C3 +03A4 03C4 +03A5 03C5 +03A6 03C6 +03A7 03C7 +03A8 03C8 +03A9 03C9 +03AA 03CA +03AB 03CB +03D8 03D9 +03DA 03DB +03DC 03DD +03DE 03DF +03E0 03E1 +03E2 03E3 +03E4 03E5 +03E6 03E7 +03E8 03E9 +03EA 03EB +03EC 03ED +03EE 03EF +03F4 03B8 +0400 0450 +0401 0451 +0402 0452 +0403 0453 +0404 0454 +0405 0455 +0406 0456 +0407 0457 +0408 0458 +0409 0459 +040A 045A +040B 045B +040C 045C +040D 045D +040E 045E +040F 045F +0410 0430 +0411 0431 +0412 0432 +0413 0433 +0414 0434 +0415 0435 +0416 0436 +0417 0437 +0418 0438 +0419 0439 +041A 043A +041B 043B +041C 043C +041D 043D +041E 043E +041F 043F +0420 0440 +0421 0441 +0422 0442 +0423 0443 +0424 0444 +0425 0445 +0426 0446 +0427 0447 +0428 0448 +0429 0449 +042A 044A +042B 044B +042C 044C +042D 044D +042E 044E +042F 044F +0460 0461 +0462 0463 +0464 0465 +0466 0467 +0468 0469 +046A 046B +046C 046D +046E 046F +0470 0471 +0472 0473 +0474 0475 +0476 0477 +0478 0479 +047A 047B +047C 047D +047E 047F +0480 0481 +048A 048B +048C 048D +048E 048F +0490 0491 +0492 0493 +0494 0495 +0496 0497 +0498 0499 +049A 049B +049C 049D +049E 049F +04A0 04A1 +04A2 04A3 +04A4 04A5 +04A6 04A7 +04A8 04A9 +04AA 04AB +04AC 04AD +04AE 04AF +04B0 04B1 +04B2 04B3 +04B4 04B5 +04B6 04B7 +04B8 04B9 +04BA 04BB +04BC 04BD +04BE 04BF +04C1 04C2 +04C3 04C4 +04C5 04C6 +04C7 04C8 +04C9 04CA +04CB 04CC +04CD 04CE +04D0 04D1 +04D2 04D3 +04D4 04D5 +04D6 04D7 +04D8 04D9 +04DA 04DB +04DC 04DD +04DE 04DF +04E0 04E1 +04E2 04E3 +04E4 04E5 +04E6 04E7 +04E8 04E9 +04EA 04EB +04EC 04ED +04EE 04EF +04F0 04F1 +04F2 04F3 +04F4 04F5 +04F8 04F9 +0500 0501 +0502 0503 +0504 0505 +0506 0507 +0508 0509 +050A 050B +050C 050D +050E 050F +0531 0561 +0532 0562 +0533 0563 +0534 0564 +0535 0565 +0536 0566 +0537 0567 +0538 0568 +0539 0569 +053A 056A +053B 056B +053C 056C +053D 056D +053E 056E +053F 056F +0540 0570 +0541 0571 +0542 0572 +0543 0573 +0544 0574 +0545 0575 +0546 0576 +0547 0577 +0548 0578 +0549 0579 +054A 057A +054B 057B +054C 057C +054D 057D +054E 057E +054F 057F +0550 0580 +0551 0581 +0552 0582 +0553 0583 +0554 0584 +0555 0585 +0556 0586 +1E00 1E01 +1E02 1E03 +1E04 1E05 +1E06 1E07 +1E08 1E09 +1E0A 1E0B +1E0C 1E0D +1E0E 1E0F +1E10 1E11 +1E12 1E13 +1E14 1E15 +1E16 1E17 +1E18 1E19 +1E1A 1E1B +1E1C 1E1D +1E1E 1E1F +1E20 1E21 +1E22 1E23 +1E24 1E25 +1E26 1E27 +1E28 1E29 +1E2A 1E2B +1E2C 1E2D +1E2E 1E2F +1E30 1E31 +1E32 1E33 +1E34 1E35 +1E36 1E37 +1E38 1E39 +1E3A 1E3B +1E3C 1E3D +1E3E 1E3F +1E40 1E41 +1E42 1E43 +1E44 1E45 +1E46 1E47 +1E48 1E49 +1E4A 1E4B +1E4C 1E4D +1E4E 1E4F +1E50 1E51 +1E52 1E53 +1E54 1E55 +1E56 1E57 +1E58 1E59 +1E5A 1E5B +1E5C 1E5D +1E5E 1E5F +1E60 1E61 +1E62 1E63 +1E64 1E65 +1E66 1E67 +1E68 1E69 +1E6A 1E6B +1E6C 1E6D +1E6E 1E6F +1E70 1E71 +1E72 1E73 +1E74 1E75 +1E76 1E77 +1E78 1E79 +1E7A 1E7B +1E7C 1E7D +1E7E 1E7F +1E80 1E81 +1E82 1E83 +1E84 1E85 +1E86 1E87 +1E88 1E89 +1E8A 1E8B +1E8C 1E8D +1E8E 1E8F +1E90 1E91 +1E92 1E93 +1E94 1E95 +1EA0 1EA1 +1EA2 1EA3 +1EA4 1EA5 +1EA6 1EA7 +1EA8 1EA9 +1EAA 1EAB +1EAC 1EAD +1EAE 1EAF +1EB0 1EB1 +1EB2 1EB3 +1EB4 1EB5 +1EB6 1EB7 +1EB8 1EB9 +1EBA 1EBB +1EBC 1EBD +1EBE 1EBF +1EC0 1EC1 +1EC2 1EC3 +1EC4 1EC5 +1EC6 1EC7 +1EC8 1EC9 +1ECA 1ECB +1ECC 1ECD +1ECE 1ECF +1ED0 1ED1 +1ED2 1ED3 +1ED4 1ED5 +1ED6 1ED7 +1ED8 1ED9 +1EDA 1EDB +1EDC 1EDD +1EDE 1EDF +1EE0 1EE1 +1EE2 1EE3 +1EE4 1EE5 +1EE6 1EE7 +1EE8 1EE9 +1EEA 1EEB +1EEC 1EED +1EEE 1EEF +1EF0 1EF1 +1EF2 1EF3 +1EF4 1EF5 +1EF6 1EF7 +1EF8 1EF9 +1F08 1F00 +1F09 1F01 +1F0A 1F02 +1F0B 1F03 +1F0C 1F04 +1F0D 1F05 +1F0E 1F06 +1F0F 1F07 +1F18 1F10 +1F19 1F11 +1F1A 1F12 +1F1B 1F13 +1F1C 1F14 +1F1D 1F15 +1F28 1F20 +1F29 1F21 +1F2A 1F22 +1F2B 1F23 +1F2C 1F24 +1F2D 1F25 +1F2E 1F26 +1F2F 1F27 +1F38 1F30 +1F39 1F31 +1F3A 1F32 +1F3B 1F33 +1F3C 1F34 +1F3D 1F35 +1F3E 1F36 +1F3F 1F37 +1F48 1F40 +1F49 1F41 +1F4A 1F42 +1F4B 1F43 +1F4C 1F44 +1F4D 1F45 +1F59 1F51 +1F5B 1F53 +1F5D 1F55 +1F5F 1F57 +1F68 1F60 +1F69 1F61 +1F6A 1F62 +1F6B 1F63 +1F6C 1F64 +1F6D 1F65 +1F6E 1F66 +1F6F 1F67 +1FB8 1FB0 +1FB9 1FB1 +1FBA 1F70 +1FBB 1F71 +1FC8 1F72 +1FC9 1F73 +1FCA 1F74 +1FCB 1F75 +1FD8 1FD0 +1FD9 1FD1 +1FDA 1F76 +1FDB 1F77 +1FE8 1FE0 +1FE9 1FE1 +1FEA 1F7A +1FEB 1F7B +1FEC 1FE5 +1FF8 1F78 +1FF9 1F79 +1FFA 1F7C +1FFB 1F7D +2126 03C9 +212A 006B +212B 00E5 +2160 2170 +2161 2171 +2162 2172 +2163 2173 +2164 2174 +2165 2175 +2166 2176 +2167 2177 +2168 2178 +2169 2179 +216A 217A +216B 217B +216C 217C +216D 217D +216E 217E +216F 217F +24B6 24D0 +24B7 24D1 +24B8 24D2 +24B9 24D3 +24BA 24D4 +24BB 24D5 +24BC 24D6 +24BD 24D7 +24BE 24D8 +24BF 24D9 +24C0 24DA +24C1 24DB +24C2 24DC +24C3 24DD +24C4 24DE +24C5 24DF +24C6 24E0 +24C7 24E1 +24C8 24E2 +24C9 24E3 +24CA 24E4 +24CB 24E5 +24CC 24E6 +24CD 24E7 +24CE 24E8 +24CF 24E9 +FF21 FF41 +FF22 FF42 +FF23 FF43 +FF24 FF44 +FF25 FF45 +FF26 FF46 +FF27 FF47 +FF28 FF48 +FF29 FF49 +FF2A FF4A +FF2B FF4B +FF2C FF4C +FF2D FF4D +FF2E FF4E +FF2F FF4F +FF30 FF50 +FF31 FF51 +FF32 FF52 +FF33 FF53 +FF34 FF54 +FF35 FF55 +FF36 FF56 +FF37 FF57 +FF38 FF58 +FF39 FF59 +FF3A FF5A +10400 10428 +10401 10429 +10402 1042A +10403 1042B +10404 1042C +10405 1042D +10406 1042E +10407 1042F +10408 10430 +10409 10431 +1040A 10432 +1040B 10433 +1040C 10434 +1040D 10435 +1040E 10436 +1040F 10437 +10410 10438 +10411 10439 +10412 1043A +10413 1043B +10414 1043C +10415 1043D +10416 1043E +10417 1043F +10418 10440 +10419 10441 +1041A 10442 +1041B 10443 +1041C 10444 +1041D 10445 +1041E 10446 +1041F 10447 +10420 10448 +10421 10449 +10422 1044A +10423 1044B +10424 1044C +10425 1044D +END diff --git a/Master/xemtex/perl/lib/unicore/To/Title.pl b/Master/xemtex/perl/lib/unicore/To/Title.pl new file mode 100644 index 00000000000..1cd9dc540f3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/To/Title.pl @@ -0,0 +1,818 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + + +%utf8::ToSpecTitle = +( +'00DF' => "\x{0053}\x{0073}", +'0149' => "\x{02BC}\x{004E}", +'01F0' => "\x{004A}\x{030C}", +'0390' => "\x{0399}\x{0308}\x{0301}", +'03B0' => "\x{03A5}\x{0308}\x{0301}", +'0587' => "\x{0535}\x{0582}", +'1E96' => "\x{0048}\x{0331}", +'1E97' => "\x{0054}\x{0308}", +'1E98' => "\x{0057}\x{030A}", +'1E99' => "\x{0059}\x{030A}", +'1E9A' => "\x{0041}\x{02BE}", +'1F50' => "\x{03A5}\x{0313}", +'1F52' => "\x{03A5}\x{0313}\x{0300}", +'1F54' => "\x{03A5}\x{0313}\x{0301}", +'1F56' => "\x{03A5}\x{0313}\x{0342}", +'1F80' => "\x{1F88}", +'1F81' => "\x{1F89}", +'1F82' => "\x{1F8A}", +'1F83' => "\x{1F8B}", +'1F84' => "\x{1F8C}", +'1F85' => "\x{1F8D}", +'1F86' => "\x{1F8E}", +'1F87' => "\x{1F8F}", +'1F90' => "\x{1F98}", +'1F91' => "\x{1F99}", +'1F92' => "\x{1F9A}", +'1F93' => "\x{1F9B}", +'1F94' => "\x{1F9C}", +'1F95' => "\x{1F9D}", +'1F96' => "\x{1F9E}", +'1F97' => "\x{1F9F}", +'1FA0' => "\x{1FA8}", +'1FA1' => "\x{1FA9}", +'1FA2' => "\x{1FAA}", +'1FA3' => "\x{1FAB}", +'1FA4' => "\x{1FAC}", +'1FA5' => "\x{1FAD}", +'1FA6' => "\x{1FAE}", +'1FA7' => "\x{1FAF}", +'1FB2' => "\x{1FBA}\x{0345}", +'1FB3' => "\x{1FBC}", +'1FB4' => "\x{0386}\x{0345}", +'1FB6' => "\x{0391}\x{0342}", +'1FB7' => "\x{0391}\x{0342}\x{0345}", +'1FC2' => "\x{1FCA}\x{0345}", +'1FC3' => "\x{1FCC}", +'1FC4' => "\x{0389}\x{0345}", +'1FC6' => "\x{0397}\x{0342}", +'1FC7' => "\x{0397}\x{0342}\x{0345}", +'1FD2' => "\x{0399}\x{0308}\x{0300}", +'1FD3' => "\x{0399}\x{0308}\x{0301}", +'1FD6' => "\x{0399}\x{0342}", +'1FD7' => "\x{0399}\x{0308}\x{0342}", +'1FE2' => "\x{03A5}\x{0308}\x{0300}", +'1FE3' => "\x{03A5}\x{0308}\x{0301}", +'1FE4' => "\x{03A1}\x{0313}", +'1FE6' => "\x{03A5}\x{0342}", +'1FE7' => "\x{03A5}\x{0308}\x{0342}", +'1FF2' => "\x{1FFA}\x{0345}", +'1FF3' => "\x{1FFC}", +'1FF4' => "\x{038F}\x{0345}", +'1FF6' => "\x{03A9}\x{0342}", +'1FF7' => "\x{03A9}\x{0342}\x{0345}", +'FB00' => "\x{0046}\x{0066}", +'FB01' => "\x{0046}\x{0069}", +'FB02' => "\x{0046}\x{006C}", +'FB03' => "\x{0046}\x{0066}\x{0069}", +'FB04' => "\x{0046}\x{0066}\x{006C}", +'FB05' => "\x{0053}\x{0074}", +'FB06' => "\x{0053}\x{0074}", +'FB13' => "\x{0544}\x{0576}", +'FB14' => "\x{0544}\x{0565}", +'FB15' => "\x{0544}\x{056B}", +'FB16' => "\x{054E}\x{0576}", +'FB17' => "\x{0544}\x{056D}", +); + +return <<'END'; +0061 0041 +0062 0042 +0063 0043 +0064 0044 +0065 0045 +0066 0046 +0067 0047 +0068 0048 +0069 0049 +006A 004A +006B 004B +006C 004C +006D 004D +006E 004E +006F 004F +0070 0050 +0071 0051 +0072 0052 +0073 0053 +0074 0054 +0075 0055 +0076 0056 +0077 0057 +0078 0058 +0079 0059 +007A 005A +00B5 039C +00E0 00C0 +00E1 00C1 +00E2 00C2 +00E3 00C3 +00E4 00C4 +00E5 00C5 +00E6 00C6 +00E7 00C7 +00E8 00C8 +00E9 00C9 +00EA 00CA +00EB 00CB +00EC 00CC +00ED 00CD +00EE 00CE +00EF 00CF +00F0 00D0 +00F1 00D1 +00F2 00D2 +00F3 00D3 +00F4 00D4 +00F5 00D5 +00F6 00D6 +00F8 00D8 +00F9 00D9 +00FA 00DA +00FB 00DB +00FC 00DC +00FD 00DD +00FE 00DE +00FF 0178 +0101 0100 +0103 0102 +0105 0104 +0107 0106 +0109 0108 +010B 010A +010D 010C +010F 010E +0111 0110 +0113 0112 +0115 0114 +0117 0116 +0119 0118 +011B 011A +011D 011C +011F 011E +0121 0120 +0123 0122 +0125 0124 +0127 0126 +0129 0128 +012B 012A +012D 012C +012F 012E +0131 0049 +0133 0132 +0135 0134 +0137 0136 +013A 0139 +013C 013B +013E 013D +0140 013F +0142 0141 +0144 0143 +0146 0145 +0148 0147 +014B 014A +014D 014C +014F 014E +0151 0150 +0153 0152 +0155 0154 +0157 0156 +0159 0158 +015B 015A +015D 015C +015F 015E +0161 0160 +0163 0162 +0165 0164 +0167 0166 +0169 0168 +016B 016A +016D 016C +016F 016E +0171 0170 +0173 0172 +0175 0174 +0177 0176 +017A 0179 +017C 017B +017E 017D +017F 0053 +0183 0182 +0185 0184 +0188 0187 +018C 018B +0192 0191 +0195 01F6 +0199 0198 +019E 0220 +01A1 01A0 +01A3 01A2 +01A5 01A4 +01A8 01A7 +01AD 01AC +01B0 01AF +01B4 01B3 +01B6 01B5 +01B9 01B8 +01BD 01BC +01BF 01F7 +01C4 01C5 +01C6 01C5 +01C7 01C8 +01C9 01C8 +01CA 01CB +01CC 01CB +01CE 01CD +01D0 01CF +01D2 01D1 +01D4 01D3 +01D6 01D5 +01D8 01D7 +01DA 01D9 +01DC 01DB +01DD 018E +01DF 01DE +01E1 01E0 +01E3 01E2 +01E5 01E4 +01E7 01E6 +01E9 01E8 +01EB 01EA +01ED 01EC +01EF 01EE +01F1 01F2 +01F3 01F2 +01F5 01F4 +01F9 01F8 +01FB 01FA +01FD 01FC +01FF 01FE +0201 0200 +0203 0202 +0205 0204 +0207 0206 +0209 0208 +020B 020A +020D 020C +020F 020E +0211 0210 +0213 0212 +0215 0214 +0217 0216 +0219 0218 +021B 021A +021D 021C +021F 021E +0223 0222 +0225 0224 +0227 0226 +0229 0228 +022B 022A +022D 022C +022F 022E +0231 0230 +0233 0232 +0253 0181 +0254 0186 +0256 0189 +0257 018A +0259 018F +025B 0190 +0260 0193 +0263 0194 +0268 0197 +0269 0196 +026F 019C +0272 019D +0275 019F +0280 01A6 +0283 01A9 +0288 01AE +028A 01B1 +028B 01B2 +0292 01B7 +0345 0399 +03AC 0386 +03AD 0388 +03AE 0389 +03AF 038A +03B1 0391 +03B2 0392 +03B3 0393 +03B4 0394 +03B5 0395 +03B6 0396 +03B7 0397 +03B8 0398 +03B9 0399 +03BA 039A +03BB 039B +03BC 039C +03BD 039D +03BE 039E +03BF 039F +03C0 03A0 +03C1 03A1 +03C2 03A3 +03C3 03A3 +03C4 03A4 +03C5 03A5 +03C6 03A6 +03C7 03A7 +03C8 03A8 +03C9 03A9 +03CA 03AA +03CB 03AB +03CC 038C +03CD 038E +03CE 038F +03D0 0392 +03D1 0398 +03D5 03A6 +03D6 03A0 +03D9 03D8 +03DB 03DA +03DD 03DC +03DF 03DE +03E1 03E0 +03E3 03E2 +03E5 03E4 +03E7 03E6 +03E9 03E8 +03EB 03EA +03ED 03EC +03EF 03EE +03F0 039A +03F1 03A1 +03F2 03A3 +03F5 0395 +0430 0410 +0431 0411 +0432 0412 +0433 0413 +0434 0414 +0435 0415 +0436 0416 +0437 0417 +0438 0418 +0439 0419 +043A 041A +043B 041B +043C 041C +043D 041D +043E 041E +043F 041F +0440 0420 +0441 0421 +0442 0422 +0443 0423 +0444 0424 +0445 0425 +0446 0426 +0447 0427 +0448 0428 +0449 0429 +044A 042A +044B 042B +044C 042C +044D 042D +044E 042E +044F 042F +0450 0400 +0451 0401 +0452 0402 +0453 0403 +0454 0404 +0455 0405 +0456 0406 +0457 0407 +0458 0408 +0459 0409 +045A 040A +045B 040B +045C 040C +045D 040D +045E 040E +045F 040F +0461 0460 +0463 0462 +0465 0464 +0467 0466 +0469 0468 +046B 046A +046D 046C +046F 046E +0471 0470 +0473 0472 +0475 0474 +0477 0476 +0479 0478 +047B 047A +047D 047C +047F 047E +0481 0480 +048B 048A +048D 048C +048F 048E +0491 0490 +0493 0492 +0495 0494 +0497 0496 +0499 0498 +049B 049A +049D 049C +049F 049E +04A1 04A0 +04A3 04A2 +04A5 04A4 +04A7 04A6 +04A9 04A8 +04AB 04AA +04AD 04AC +04AF 04AE +04B1 04B0 +04B3 04B2 +04B5 04B4 +04B7 04B6 +04B9 04B8 +04BB 04BA +04BD 04BC +04BF 04BE +04C2 04C1 +04C4 04C3 +04C6 04C5 +04C8 04C7 +04CA 04C9 +04CC 04CB +04CE 04CD +04D1 04D0 +04D3 04D2 +04D5 04D4 +04D7 04D6 +04D9 04D8 +04DB 04DA +04DD 04DC +04DF 04DE +04E1 04E0 +04E3 04E2 +04E5 04E4 +04E7 04E6 +04E9 04E8 +04EB 04EA +04ED 04EC +04EF 04EE +04F1 04F0 +04F3 04F2 +04F5 04F4 +04F9 04F8 +0501 0500 +0503 0502 +0505 0504 +0507 0506 +0509 0508 +050B 050A +050D 050C +050F 050E +0561 0531 +0562 0532 +0563 0533 +0564 0534 +0565 0535 +0566 0536 +0567 0537 +0568 0538 +0569 0539 +056A 053A +056B 053B +056C 053C +056D 053D +056E 053E +056F 053F +0570 0540 +0571 0541 +0572 0542 +0573 0543 +0574 0544 +0575 0545 +0576 0546 +0577 0547 +0578 0548 +0579 0549 +057A 054A +057B 054B +057C 054C +057D 054D +057E 054E +057F 054F +0580 0550 +0581 0551 +0582 0552 +0583 0553 +0584 0554 +0585 0555 +0586 0556 +1E01 1E00 +1E03 1E02 +1E05 1E04 +1E07 1E06 +1E09 1E08 +1E0B 1E0A +1E0D 1E0C +1E0F 1E0E +1E11 1E10 +1E13 1E12 +1E15 1E14 +1E17 1E16 +1E19 1E18 +1E1B 1E1A +1E1D 1E1C +1E1F 1E1E +1E21 1E20 +1E23 1E22 +1E25 1E24 +1E27 1E26 +1E29 1E28 +1E2B 1E2A +1E2D 1E2C +1E2F 1E2E +1E31 1E30 +1E33 1E32 +1E35 1E34 +1E37 1E36 +1E39 1E38 +1E3B 1E3A +1E3D 1E3C +1E3F 1E3E +1E41 1E40 +1E43 1E42 +1E45 1E44 +1E47 1E46 +1E49 1E48 +1E4B 1E4A +1E4D 1E4C +1E4F 1E4E +1E51 1E50 +1E53 1E52 +1E55 1E54 +1E57 1E56 +1E59 1E58 +1E5B 1E5A +1E5D 1E5C +1E5F 1E5E +1E61 1E60 +1E63 1E62 +1E65 1E64 +1E67 1E66 +1E69 1E68 +1E6B 1E6A +1E6D 1E6C +1E6F 1E6E +1E71 1E70 +1E73 1E72 +1E75 1E74 +1E77 1E76 +1E79 1E78 +1E7B 1E7A +1E7D 1E7C +1E7F 1E7E +1E81 1E80 +1E83 1E82 +1E85 1E84 +1E87 1E86 +1E89 1E88 +1E8B 1E8A +1E8D 1E8C +1E8F 1E8E +1E91 1E90 +1E93 1E92 +1E95 1E94 +1E9B 1E60 +1EA1 1EA0 +1EA3 1EA2 +1EA5 1EA4 +1EA7 1EA6 +1EA9 1EA8 +1EAB 1EAA +1EAD 1EAC +1EAF 1EAE +1EB1 1EB0 +1EB3 1EB2 +1EB5 1EB4 +1EB7 1EB6 +1EB9 1EB8 +1EBB 1EBA +1EBD 1EBC +1EBF 1EBE +1EC1 1EC0 +1EC3 1EC2 +1EC5 1EC4 +1EC7 1EC6 +1EC9 1EC8 +1ECB 1ECA +1ECD 1ECC +1ECF 1ECE +1ED1 1ED0 +1ED3 1ED2 +1ED5 1ED4 +1ED7 1ED6 +1ED9 1ED8 +1EDB 1EDA +1EDD 1EDC +1EDF 1EDE +1EE1 1EE0 +1EE3 1EE2 +1EE5 1EE4 +1EE7 1EE6 +1EE9 1EE8 +1EEB 1EEA +1EED 1EEC +1EEF 1EEE +1EF1 1EF0 +1EF3 1EF2 +1EF5 1EF4 +1EF7 1EF6 +1EF9 1EF8 +1F00 1F08 +1F01 1F09 +1F02 1F0A +1F03 1F0B +1F04 1F0C +1F05 1F0D +1F06 1F0E +1F07 1F0F +1F10 1F18 +1F11 1F19 +1F12 1F1A +1F13 1F1B +1F14 1F1C +1F15 1F1D +1F20 1F28 +1F21 1F29 +1F22 1F2A +1F23 1F2B +1F24 1F2C +1F25 1F2D +1F26 1F2E +1F27 1F2F +1F30 1F38 +1F31 1F39 +1F32 1F3A +1F33 1F3B +1F34 1F3C +1F35 1F3D +1F36 1F3E +1F37 1F3F +1F40 1F48 +1F41 1F49 +1F42 1F4A +1F43 1F4B +1F44 1F4C +1F45 1F4D +1F51 1F59 +1F53 1F5B +1F55 1F5D +1F57 1F5F +1F60 1F68 +1F61 1F69 +1F62 1F6A +1F63 1F6B +1F64 1F6C +1F65 1F6D +1F66 1F6E +1F67 1F6F +1F70 1FBA +1F71 1FBB +1F72 1FC8 +1F73 1FC9 +1F74 1FCA +1F75 1FCB +1F76 1FDA +1F77 1FDB +1F78 1FF8 +1F79 1FF9 +1F7A 1FEA +1F7B 1FEB +1F7C 1FFA +1F7D 1FFB +1FB0 1FB8 +1FB1 1FB9 +1FBE 0399 +1FD0 1FD8 +1FD1 1FD9 +1FE0 1FE8 +1FE1 1FE9 +1FE5 1FEC +2170 2160 +2171 2161 +2172 2162 +2173 2163 +2174 2164 +2175 2165 +2176 2166 +2177 2167 +2178 2168 +2179 2169 +217A 216A +217B 216B +217C 216C +217D 216D +217E 216E +217F 216F +24D0 24B6 +24D1 24B7 +24D2 24B8 +24D3 24B9 +24D4 24BA +24D5 24BB +24D6 24BC +24D7 24BD +24D8 24BE +24D9 24BF +24DA 24C0 +24DB 24C1 +24DC 24C2 +24DD 24C3 +24DE 24C4 +24DF 24C5 +24E0 24C6 +24E1 24C7 +24E2 24C8 +24E3 24C9 +24E4 24CA +24E5 24CB +24E6 24CC +24E7 24CD +24E8 24CE +24E9 24CF +FF41 FF21 +FF42 FF22 +FF43 FF23 +FF44 FF24 +FF45 FF25 +FF46 FF26 +FF47 FF27 +FF48 FF28 +FF49 FF29 +FF4A FF2A +FF4B FF2B +FF4C FF2C +FF4D FF2D +FF4E FF2E +FF4F FF2F +FF50 FF30 +FF51 FF31 +FF52 FF32 +FF53 FF33 +FF54 FF34 +FF55 FF35 +FF56 FF36 +FF57 FF37 +FF58 FF38 +FF59 FF39 +FF5A FF3A +10428 10400 +10429 10401 +1042A 10402 +1042B 10403 +1042C 10404 +1042D 10405 +1042E 10406 +1042F 10407 +10430 10408 +10431 10409 +10432 1040A +10433 1040B +10434 1040C +10435 1040D +10436 1040E +10437 1040F +10438 10410 +10439 10411 +1043A 10412 +1043B 10413 +1043C 10414 +1043D 10415 +1043E 10416 +1043F 10417 +10440 10418 +10441 10419 +10442 1041A +10443 1041B +10444 1041C +10445 1041D +10446 1041E +10447 1041F +10448 10420 +10449 10421 +1044A 10422 +1044B 10423 +1044C 10424 +1044D 10425 +END diff --git a/Master/xemtex/perl/lib/unicore/To/Upper.pl b/Master/xemtex/perl/lib/unicore/To/Upper.pl new file mode 100644 index 00000000000..0d1596f72d6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/To/Upper.pl @@ -0,0 +1,845 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + + +%utf8::ToSpecUpper = +( +'00DF' => "\x{0053}\x{0053}", +'0149' => "\x{02BC}\x{004E}", +'01F0' => "\x{004A}\x{030C}", +'0390' => "\x{0399}\x{0308}\x{0301}", +'03B0' => "\x{03A5}\x{0308}\x{0301}", +'0587' => "\x{0535}\x{0552}", +'1E96' => "\x{0048}\x{0331}", +'1E97' => "\x{0054}\x{0308}", +'1E98' => "\x{0057}\x{030A}", +'1E99' => "\x{0059}\x{030A}", +'1E9A' => "\x{0041}\x{02BE}", +'1F50' => "\x{03A5}\x{0313}", +'1F52' => "\x{03A5}\x{0313}\x{0300}", +'1F54' => "\x{03A5}\x{0313}\x{0301}", +'1F56' => "\x{03A5}\x{0313}\x{0342}", +'1F80' => "\x{1F08}\x{0399}", +'1F81' => "\x{1F09}\x{0399}", +'1F82' => "\x{1F0A}\x{0399}", +'1F83' => "\x{1F0B}\x{0399}", +'1F84' => "\x{1F0C}\x{0399}", +'1F85' => "\x{1F0D}\x{0399}", +'1F86' => "\x{1F0E}\x{0399}", +'1F87' => "\x{1F0F}\x{0399}", +'1F88' => "\x{1F08}\x{0399}", +'1F89' => "\x{1F09}\x{0399}", +'1F8A' => "\x{1F0A}\x{0399}", +'1F8B' => "\x{1F0B}\x{0399}", +'1F8C' => "\x{1F0C}\x{0399}", +'1F8D' => "\x{1F0D}\x{0399}", +'1F8E' => "\x{1F0E}\x{0399}", +'1F8F' => "\x{1F0F}\x{0399}", +'1F90' => "\x{1F28}\x{0399}", +'1F91' => "\x{1F29}\x{0399}", +'1F92' => "\x{1F2A}\x{0399}", +'1F93' => "\x{1F2B}\x{0399}", +'1F94' => "\x{1F2C}\x{0399}", +'1F95' => "\x{1F2D}\x{0399}", +'1F96' => "\x{1F2E}\x{0399}", +'1F97' => "\x{1F2F}\x{0399}", +'1F98' => "\x{1F28}\x{0399}", +'1F99' => "\x{1F29}\x{0399}", +'1F9A' => "\x{1F2A}\x{0399}", +'1F9B' => "\x{1F2B}\x{0399}", +'1F9C' => "\x{1F2C}\x{0399}", +'1F9D' => "\x{1F2D}\x{0399}", +'1F9E' => "\x{1F2E}\x{0399}", +'1F9F' => "\x{1F2F}\x{0399}", +'1FA0' => "\x{1F68}\x{0399}", +'1FA1' => "\x{1F69}\x{0399}", +'1FA2' => "\x{1F6A}\x{0399}", +'1FA3' => "\x{1F6B}\x{0399}", +'1FA4' => "\x{1F6C}\x{0399}", +'1FA5' => "\x{1F6D}\x{0399}", +'1FA6' => "\x{1F6E}\x{0399}", +'1FA7' => "\x{1F6F}\x{0399}", +'1FA8' => "\x{1F68}\x{0399}", +'1FA9' => "\x{1F69}\x{0399}", +'1FAA' => "\x{1F6A}\x{0399}", +'1FAB' => "\x{1F6B}\x{0399}", +'1FAC' => "\x{1F6C}\x{0399}", +'1FAD' => "\x{1F6D}\x{0399}", +'1FAE' => "\x{1F6E}\x{0399}", +'1FAF' => "\x{1F6F}\x{0399}", +'1FB2' => "\x{1FBA}\x{0399}", +'1FB3' => "\x{0391}\x{0399}", +'1FB4' => "\x{0386}\x{0399}", +'1FB6' => "\x{0391}\x{0342}", +'1FB7' => "\x{0391}\x{0342}\x{0399}", +'1FBC' => "\x{0391}\x{0399}", +'1FC2' => "\x{1FCA}\x{0399}", +'1FC3' => "\x{0397}\x{0399}", +'1FC4' => "\x{0389}\x{0399}", +'1FC6' => "\x{0397}\x{0342}", +'1FC7' => "\x{0397}\x{0342}\x{0399}", +'1FCC' => "\x{0397}\x{0399}", +'1FD2' => "\x{0399}\x{0308}\x{0300}", +'1FD3' => "\x{0399}\x{0308}\x{0301}", +'1FD6' => "\x{0399}\x{0342}", +'1FD7' => "\x{0399}\x{0308}\x{0342}", +'1FE2' => "\x{03A5}\x{0308}\x{0300}", +'1FE3' => "\x{03A5}\x{0308}\x{0301}", +'1FE4' => "\x{03A1}\x{0313}", +'1FE6' => "\x{03A5}\x{0342}", +'1FE7' => "\x{03A5}\x{0308}\x{0342}", +'1FF2' => "\x{1FFA}\x{0399}", +'1FF3' => "\x{03A9}\x{0399}", +'1FF4' => "\x{038F}\x{0399}", +'1FF6' => "\x{03A9}\x{0342}", +'1FF7' => "\x{03A9}\x{0342}\x{0399}", +'1FFC' => "\x{03A9}\x{0399}", +'FB00' => "\x{0046}\x{0046}", +'FB01' => "\x{0046}\x{0049}", +'FB02' => "\x{0046}\x{004C}", +'FB03' => "\x{0046}\x{0046}\x{0049}", +'FB04' => "\x{0046}\x{0046}\x{004C}", +'FB05' => "\x{0053}\x{0054}", +'FB06' => "\x{0053}\x{0054}", +'FB13' => "\x{0544}\x{0546}", +'FB14' => "\x{0544}\x{0535}", +'FB15' => "\x{0544}\x{053B}", +'FB16' => "\x{054E}\x{0546}", +'FB17' => "\x{0544}\x{053D}", +); + +return <<'END'; +0061 0041 +0062 0042 +0063 0043 +0064 0044 +0065 0045 +0066 0046 +0067 0047 +0068 0048 +0069 0049 +006A 004A +006B 004B +006C 004C +006D 004D +006E 004E +006F 004F +0070 0050 +0071 0051 +0072 0052 +0073 0053 +0074 0054 +0075 0055 +0076 0056 +0077 0057 +0078 0058 +0079 0059 +007A 005A +00B5 039C +00E0 00C0 +00E1 00C1 +00E2 00C2 +00E3 00C3 +00E4 00C4 +00E5 00C5 +00E6 00C6 +00E7 00C7 +00E8 00C8 +00E9 00C9 +00EA 00CA +00EB 00CB +00EC 00CC +00ED 00CD +00EE 00CE +00EF 00CF +00F0 00D0 +00F1 00D1 +00F2 00D2 +00F3 00D3 +00F4 00D4 +00F5 00D5 +00F6 00D6 +00F8 00D8 +00F9 00D9 +00FA 00DA +00FB 00DB +00FC 00DC +00FD 00DD +00FE 00DE +00FF 0178 +0101 0100 +0103 0102 +0105 0104 +0107 0106 +0109 0108 +010B 010A +010D 010C +010F 010E +0111 0110 +0113 0112 +0115 0114 +0117 0116 +0119 0118 +011B 011A +011D 011C +011F 011E +0121 0120 +0123 0122 +0125 0124 +0127 0126 +0129 0128 +012B 012A +012D 012C +012F 012E +0131 0049 +0133 0132 +0135 0134 +0137 0136 +013A 0139 +013C 013B +013E 013D +0140 013F +0142 0141 +0144 0143 +0146 0145 +0148 0147 +014B 014A +014D 014C +014F 014E +0151 0150 +0153 0152 +0155 0154 +0157 0156 +0159 0158 +015B 015A +015D 015C +015F 015E +0161 0160 +0163 0162 +0165 0164 +0167 0166 +0169 0168 +016B 016A +016D 016C +016F 016E +0171 0170 +0173 0172 +0175 0174 +0177 0176 +017A 0179 +017C 017B +017E 017D +017F 0053 +0183 0182 +0185 0184 +0188 0187 +018C 018B +0192 0191 +0195 01F6 +0199 0198 +019E 0220 +01A1 01A0 +01A3 01A2 +01A5 01A4 +01A8 01A7 +01AD 01AC +01B0 01AF +01B4 01B3 +01B6 01B5 +01B9 01B8 +01BD 01BC +01BF 01F7 +01C5 01C4 +01C6 01C4 +01C8 01C7 +01C9 01C7 +01CB 01CA +01CC 01CA +01CE 01CD +01D0 01CF +01D2 01D1 +01D4 01D3 +01D6 01D5 +01D8 01D7 +01DA 01D9 +01DC 01DB +01DD 018E +01DF 01DE +01E1 01E0 +01E3 01E2 +01E5 01E4 +01E7 01E6 +01E9 01E8 +01EB 01EA +01ED 01EC +01EF 01EE +01F2 01F1 +01F3 01F1 +01F5 01F4 +01F9 01F8 +01FB 01FA +01FD 01FC +01FF 01FE +0201 0200 +0203 0202 +0205 0204 +0207 0206 +0209 0208 +020B 020A +020D 020C +020F 020E +0211 0210 +0213 0212 +0215 0214 +0217 0216 +0219 0218 +021B 021A +021D 021C +021F 021E +0223 0222 +0225 0224 +0227 0226 +0229 0228 +022B 022A +022D 022C +022F 022E +0231 0230 +0233 0232 +0253 0181 +0254 0186 +0256 0189 +0257 018A +0259 018F +025B 0190 +0260 0193 +0263 0194 +0268 0197 +0269 0196 +026F 019C +0272 019D +0275 019F +0280 01A6 +0283 01A9 +0288 01AE +028A 01B1 +028B 01B2 +0292 01B7 +0345 0399 +03AC 0386 +03AD 0388 +03AE 0389 +03AF 038A +03B1 0391 +03B2 0392 +03B3 0393 +03B4 0394 +03B5 0395 +03B6 0396 +03B7 0397 +03B8 0398 +03B9 0399 +03BA 039A +03BB 039B +03BC 039C +03BD 039D +03BE 039E +03BF 039F +03C0 03A0 +03C1 03A1 +03C2 03A3 +03C3 03A3 +03C4 03A4 +03C5 03A5 +03C6 03A6 +03C7 03A7 +03C8 03A8 +03C9 03A9 +03CA 03AA +03CB 03AB +03CC 038C +03CD 038E +03CE 038F +03D0 0392 +03D1 0398 +03D5 03A6 +03D6 03A0 +03D9 03D8 +03DB 03DA +03DD 03DC +03DF 03DE +03E1 03E0 +03E3 03E2 +03E5 03E4 +03E7 03E6 +03E9 03E8 +03EB 03EA +03ED 03EC +03EF 03EE +03F0 039A +03F1 03A1 +03F2 03A3 +03F5 0395 +0430 0410 +0431 0411 +0432 0412 +0433 0413 +0434 0414 +0435 0415 +0436 0416 +0437 0417 +0438 0418 +0439 0419 +043A 041A +043B 041B +043C 041C +043D 041D +043E 041E +043F 041F +0440 0420 +0441 0421 +0442 0422 +0443 0423 +0444 0424 +0445 0425 +0446 0426 +0447 0427 +0448 0428 +0449 0429 +044A 042A +044B 042B +044C 042C +044D 042D +044E 042E +044F 042F +0450 0400 +0451 0401 +0452 0402 +0453 0403 +0454 0404 +0455 0405 +0456 0406 +0457 0407 +0458 0408 +0459 0409 +045A 040A +045B 040B +045C 040C +045D 040D +045E 040E +045F 040F +0461 0460 +0463 0462 +0465 0464 +0467 0466 +0469 0468 +046B 046A +046D 046C +046F 046E +0471 0470 +0473 0472 +0475 0474 +0477 0476 +0479 0478 +047B 047A +047D 047C +047F 047E +0481 0480 +048B 048A +048D 048C +048F 048E +0491 0490 +0493 0492 +0495 0494 +0497 0496 +0499 0498 +049B 049A +049D 049C +049F 049E +04A1 04A0 +04A3 04A2 +04A5 04A4 +04A7 04A6 +04A9 04A8 +04AB 04AA +04AD 04AC +04AF 04AE +04B1 04B0 +04B3 04B2 +04B5 04B4 +04B7 04B6 +04B9 04B8 +04BB 04BA +04BD 04BC +04BF 04BE +04C2 04C1 +04C4 04C3 +04C6 04C5 +04C8 04C7 +04CA 04C9 +04CC 04CB +04CE 04CD +04D1 04D0 +04D3 04D2 +04D5 04D4 +04D7 04D6 +04D9 04D8 +04DB 04DA +04DD 04DC +04DF 04DE +04E1 04E0 +04E3 04E2 +04E5 04E4 +04E7 04E6 +04E9 04E8 +04EB 04EA +04ED 04EC +04EF 04EE +04F1 04F0 +04F3 04F2 +04F5 04F4 +04F9 04F8 +0501 0500 +0503 0502 +0505 0504 +0507 0506 +0509 0508 +050B 050A +050D 050C +050F 050E +0561 0531 +0562 0532 +0563 0533 +0564 0534 +0565 0535 +0566 0536 +0567 0537 +0568 0538 +0569 0539 +056A 053A +056B 053B +056C 053C +056D 053D +056E 053E +056F 053F +0570 0540 +0571 0541 +0572 0542 +0573 0543 +0574 0544 +0575 0545 +0576 0546 +0577 0547 +0578 0548 +0579 0549 +057A 054A +057B 054B +057C 054C +057D 054D +057E 054E +057F 054F +0580 0550 +0581 0551 +0582 0552 +0583 0553 +0584 0554 +0585 0555 +0586 0556 +1E01 1E00 +1E03 1E02 +1E05 1E04 +1E07 1E06 +1E09 1E08 +1E0B 1E0A +1E0D 1E0C +1E0F 1E0E +1E11 1E10 +1E13 1E12 +1E15 1E14 +1E17 1E16 +1E19 1E18 +1E1B 1E1A +1E1D 1E1C +1E1F 1E1E +1E21 1E20 +1E23 1E22 +1E25 1E24 +1E27 1E26 +1E29 1E28 +1E2B 1E2A +1E2D 1E2C +1E2F 1E2E +1E31 1E30 +1E33 1E32 +1E35 1E34 +1E37 1E36 +1E39 1E38 +1E3B 1E3A +1E3D 1E3C +1E3F 1E3E +1E41 1E40 +1E43 1E42 +1E45 1E44 +1E47 1E46 +1E49 1E48 +1E4B 1E4A +1E4D 1E4C +1E4F 1E4E +1E51 1E50 +1E53 1E52 +1E55 1E54 +1E57 1E56 +1E59 1E58 +1E5B 1E5A +1E5D 1E5C +1E5F 1E5E +1E61 1E60 +1E63 1E62 +1E65 1E64 +1E67 1E66 +1E69 1E68 +1E6B 1E6A +1E6D 1E6C +1E6F 1E6E +1E71 1E70 +1E73 1E72 +1E75 1E74 +1E77 1E76 +1E79 1E78 +1E7B 1E7A +1E7D 1E7C +1E7F 1E7E +1E81 1E80 +1E83 1E82 +1E85 1E84 +1E87 1E86 +1E89 1E88 +1E8B 1E8A +1E8D 1E8C +1E8F 1E8E +1E91 1E90 +1E93 1E92 +1E95 1E94 +1E9B 1E60 +1EA1 1EA0 +1EA3 1EA2 +1EA5 1EA4 +1EA7 1EA6 +1EA9 1EA8 +1EAB 1EAA +1EAD 1EAC +1EAF 1EAE +1EB1 1EB0 +1EB3 1EB2 +1EB5 1EB4 +1EB7 1EB6 +1EB9 1EB8 +1EBB 1EBA +1EBD 1EBC +1EBF 1EBE +1EC1 1EC0 +1EC3 1EC2 +1EC5 1EC4 +1EC7 1EC6 +1EC9 1EC8 +1ECB 1ECA +1ECD 1ECC +1ECF 1ECE +1ED1 1ED0 +1ED3 1ED2 +1ED5 1ED4 +1ED7 1ED6 +1ED9 1ED8 +1EDB 1EDA +1EDD 1EDC +1EDF 1EDE +1EE1 1EE0 +1EE3 1EE2 +1EE5 1EE4 +1EE7 1EE6 +1EE9 1EE8 +1EEB 1EEA +1EED 1EEC +1EEF 1EEE +1EF1 1EF0 +1EF3 1EF2 +1EF5 1EF4 +1EF7 1EF6 +1EF9 1EF8 +1F00 1F08 +1F01 1F09 +1F02 1F0A +1F03 1F0B +1F04 1F0C +1F05 1F0D +1F06 1F0E +1F07 1F0F +1F10 1F18 +1F11 1F19 +1F12 1F1A +1F13 1F1B +1F14 1F1C +1F15 1F1D +1F20 1F28 +1F21 1F29 +1F22 1F2A +1F23 1F2B +1F24 1F2C +1F25 1F2D +1F26 1F2E +1F27 1F2F +1F30 1F38 +1F31 1F39 +1F32 1F3A +1F33 1F3B +1F34 1F3C +1F35 1F3D +1F36 1F3E +1F37 1F3F +1F40 1F48 +1F41 1F49 +1F42 1F4A +1F43 1F4B +1F44 1F4C +1F45 1F4D +1F51 1F59 +1F53 1F5B +1F55 1F5D +1F57 1F5F +1F60 1F68 +1F61 1F69 +1F62 1F6A +1F63 1F6B +1F64 1F6C +1F65 1F6D +1F66 1F6E +1F67 1F6F +1F70 1FBA +1F71 1FBB +1F72 1FC8 +1F73 1FC9 +1F74 1FCA +1F75 1FCB +1F76 1FDA +1F77 1FDB +1F78 1FF8 +1F79 1FF9 +1F7A 1FEA +1F7B 1FEB +1F7C 1FFA +1F7D 1FFB +1FB0 1FB8 +1FB1 1FB9 +1FBE 0399 +1FD0 1FD8 +1FD1 1FD9 +1FE0 1FE8 +1FE1 1FE9 +1FE5 1FEC +2170 2160 +2171 2161 +2172 2162 +2173 2163 +2174 2164 +2175 2165 +2176 2166 +2177 2167 +2178 2168 +2179 2169 +217A 216A +217B 216B +217C 216C +217D 216D +217E 216E +217F 216F +24D0 24B6 +24D1 24B7 +24D2 24B8 +24D3 24B9 +24D4 24BA +24D5 24BB +24D6 24BC +24D7 24BD +24D8 24BE +24D9 24BF +24DA 24C0 +24DB 24C1 +24DC 24C2 +24DD 24C3 +24DE 24C4 +24DF 24C5 +24E0 24C6 +24E1 24C7 +24E2 24C8 +24E3 24C9 +24E4 24CA +24E5 24CB +24E6 24CC +24E7 24CD +24E8 24CE +24E9 24CF +FF41 FF21 +FF42 FF22 +FF43 FF23 +FF44 FF24 +FF45 FF25 +FF46 FF26 +FF47 FF27 +FF48 FF28 +FF49 FF29 +FF4A FF2A +FF4B FF2B +FF4C FF2C +FF4D FF2D +FF4E FF2E +FF4F FF2F +FF50 FF30 +FF51 FF31 +FF52 FF32 +FF53 FF33 +FF54 FF34 +FF55 FF35 +FF56 FF36 +FF57 FF37 +FF58 FF38 +FF59 FF39 +FF5A FF3A +10428 10400 +10429 10401 +1042A 10402 +1042B 10403 +1042C 10404 +1042D 10405 +1042E 10406 +1042F 10407 +10430 10408 +10431 10409 +10432 1040A +10433 1040B +10434 1040C +10435 1040D +10436 1040E +10437 1040F +10438 10410 +10439 10411 +1043A 10412 +1043B 10413 +1043C 10414 +1043D 10415 +1043E 10416 +1043F 10417 +10440 10418 +10441 10419 +10442 1041A +10443 1041B +10444 1041C +10445 1041D +10446 1041E +10447 1041F +10448 10420 +10449 10421 +1044A 10422 +1044B 10423 +1044C 10424 +1044D 10425 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/ASCII.pl b/Master/xemtex/perl/lib/unicore/lib/ASCII.pl new file mode 100644 index 00000000000..42aa565bc1f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/ASCII.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{ASCII} +# +# Meaning: [[:ASCII:]] +# +return <<'END'; +0000 007F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Alnum.pl b/Master/xemtex/perl/lib/unicore/lib/Alnum.pl new file mode 100644 index 00000000000..0ec13c55c44 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Alnum.pl @@ -0,0 +1,423 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Alnum} +# +# Meaning: [[:Alnum:]] +# +return <<'END'; +0030 0039 +0041 005A +0061 007A +00AA +00B2 00B3 +00B5 +00B9 00BA +00BC 00BE +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +0300 034F +0360 036F +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +0483 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +05D0 05EA +05F0 05F2 +0621 063A +0640 0655 +0660 0669 +066E 06D3 +06D5 06DC +06DE 06E8 +06EA 06ED +06F0 06FC +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0963 +0966 096F +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09F1 +09F4 09F9 +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B6F +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E01 0E3A +0E40 0E4E +0E50 0E59 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 +0F18 0F19 +0F20 0F33 +0F35 +0F37 +0F39 +0F3E 0F47 +0F49 0F6A +0F71 0F84 +0F86 0F8B +0F90 0F97 +0F99 0FBC +0FC6 +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1049 +1050 1059 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1369 137C +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +16EE 16F0 +1700 170C +170E 1714 +1720 1734 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17D3 +17D7 +17DC +17E0 17E9 +180B 180D +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2070 2071 +2074 2079 +207F 2089 +20D0 20EA +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2153 2183 +2460 249B +24EA 24FE +2776 2793 +3005 3007 +3021 302F +3031 3035 +3038 303C +3041 3096 +3099 309A +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +3192 3195 +31A0 31B7 +31F0 31FF +3220 3229 +3251 325F +3280 3289 +32B1 32BF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE00 FE0F +FE20 FE23 +FE70 FE74 +FE76 FEFC +FF10 FF19 +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D165 1D169 +1D16D 1D172 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Alpha.pl b/Master/xemtex/perl/lib/unicore/lib/Alpha.pl new file mode 100644 index 00000000000..35b0e3280be --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Alpha.pl @@ -0,0 +1,390 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Alpha} +# +# Meaning: [[:Alpha:]] +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +0300 034F +0360 036F +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +0483 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +05D0 05EA +05F0 05F2 +0621 063A +0640 0655 +066E 06D3 +06D5 06DC +06DE 06E8 +06EA 06ED +06FA 06FC +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0963 +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09F0 09F1 +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A70 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E01 0E3A +0E40 0E4E +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0EDC 0EDD +0F00 +0F18 0F19 +0F35 +0F37 +0F39 +0F3E 0F47 +0F49 0F6A +0F71 0F84 +0F86 0F8B +0F90 0F97 +0F99 0FBC +0FC6 +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1050 1059 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +1700 170C +170E 1714 +1720 1734 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17D3 +17D7 +17DC +180B 180D +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2071 +207F +20D0 20EA +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +3005 3006 +302A 302F +3031 3035 +303B 303C +3041 3096 +3099 309A +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE00 FE0F +FE20 FE23 +FE70 FE74 +FE76 FEFC +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 10349 +10400 10425 +10428 1044D +1D165 1D169 +1D16D 1D172 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Alphabet.pl b/Master/xemtex/perl/lib/unicore/lib/Alphabet.pl new file mode 100644 index 00000000000..a909a31f000 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Alphabet.pl @@ -0,0 +1,372 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Alphabetic} (and fuzzy permutations) +# +# Meaning: [\p{L}\p{OtherAlphabetic}] +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +0345 +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +05B0 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +05D0 05EA +05F0 05F2 +0621 063A +0640 0655 +066E 06D3 +06D5 06DC +06E1 06E8 +06ED +06FA 06FC +0710 072C +0730 073F +0780 07B1 +0901 0903 +0905 0939 +093D 094C +0950 +0958 0963 +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BE 09C4 +09C7 09C8 +09CB 09CC +09D7 +09DC 09DD +09DF 09E3 +09F0 09F1 +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3E 0A42 +0A47 0A48 +0A4B 0A4C +0A59 0A5C +0A5E +0A70 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABD 0AC5 +0AC7 0AC9 +0ACB 0ACC +0AD0 +0AE0 +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3D 0B43 +0B47 0B48 +0B4B 0B4C +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCC +0BD7 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4C +0C55 0C56 +0C60 0C61 +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCC +0CD5 0CD6 +0CDE +0CE0 0CE1 +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4C +0D57 +0D60 0D61 +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E01 0E3A +0E40 0E46 +0E4D +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0ECD +0EDC 0EDD +0F00 +0F40 0F47 +0F49 0F6A +0F71 0F81 +0F88 0F8B +0F90 0F97 +0F99 0FBC +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 +1038 +1050 1059 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +16EE 16F0 +1700 170C +170E 1713 +1720 1733 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17C8 +17D7 +17DC +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2071 +207F +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2160 2183 +3005 3006 +3031 3035 +303B 303C +3041 3096 +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE70 FE74 +FE76 FEFC +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 1034A +10400 10425 +10428 1044D +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Any.pl b/Master/xemtex/perl/lib/unicore/lib/Any.pl new file mode 100644 index 00000000000..b30cb2fb7f2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Any.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Any} +# \p{Any} +# +# Meaning: [\x{0000}-\x{10FFFF}] +# +return <<'END'; +0000 10FFFF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Arabic.pl b/Master/xemtex/perl/lib/unicore/lib/Arabic.pl new file mode 100644 index 00000000000..ac5df6e8900 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Arabic.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Arabic} (and fuzzy permutations) +# +# Meaning: Script 'ARABIC' +# +return <<'END'; +0621 063A ARABIC +0641 064A ARABIC +066E 066F ARABIC +0671 06D3 ARABIC +06D5 ARABIC +06E5 06E6 ARABIC +06FA 06FC ARABIC +FB50 FBB1 ARABIC +FBD3 FD3D ARABIC +FD50 FD8F ARABIC +FD92 FDC7 ARABIC +FDF0 FDFB ARABIC +FE70 FE74 ARABIC +FE76 FEFC ARABIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Armenian.pl b/Master/xemtex/perl/lib/unicore/lib/Armenian.pl new file mode 100644 index 00000000000..6652079be3a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Armenian.pl @@ -0,0 +1,16 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Armenian} (and fuzzy permutations) +# +# Meaning: Script 'ARMENIAN' +# +return <<'END'; +0531 0556 ARMENIAN +0559 ARMENIAN +0561 0587 ARMENIAN +FB13 FB17 ARMENIAN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/AsciiHex.pl b/Master/xemtex/perl/lib/unicore/lib/AsciiHex.pl new file mode 100644 index 00000000000..24c43ee3771 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/AsciiHex.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{AsciiHexDigit} (and fuzzy permutations) +# +# Meaning: Extended property 'ASCII_Hex_Digit' +# +return <<'END'; +0030 0039 ASCII_Hex_Digit +0041 0046 ASCII_Hex_Digit +0061 0066 ASCII_Hex_Digit +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Assigned.pl b/Master/xemtex/perl/lib/unicore/lib/Assigned.pl new file mode 100644 index 00000000000..5bd9faffbd3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Assigned.pl @@ -0,0 +1,398 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Assigned} +# +# Meaning: All assigned code points +# +return <<'END'; +0000 0220 +0222 0233 +0250 02AD +02B0 02EE +0300 034F +0360 036F +0374 0375 +037A +037E +0384 038A +038C +038E 03A1 +03A3 03CE +03D0 03F6 +0400 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 055F +0561 0587 +0589 058A +0591 05A1 +05A3 05B9 +05BB 05C4 +05D0 05EA +05F0 05F4 +060C +061B +061F +0621 063A +0640 0655 +0660 06ED +06F0 06FE +0700 070D +070F 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0970 +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09FA +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B70 +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF4 +0E01 0E3A +0E3F 0E5B +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 0F47 +0F49 0F6A +0F71 0F8B +0F90 0F97 +0F99 0FBC +0FBE 0FCC +0FCF +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1059 +10A0 10C5 +10D0 10F8 +10FB +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1361 137C +13A0 13F4 +1401 1676 +1680 169C +16A0 16F0 +1700 170C +170E 1714 +1720 1736 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17DC +17E0 17E9 +1800 180E +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FC4 +1FC6 1FD3 +1FD6 1FDB +1FDD 1FEF +1FF2 1FF4 +1FF6 1FFE +2000 2052 +2057 +205F 2063 +206A 2071 +2074 208E +20A0 20B1 +20D0 20EA +2100 213A +213D 214B +2153 2183 +2190 23CE +2400 2426 +2440 244A +2460 24FE +2500 2613 +2616 2617 +2619 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2794 +2798 27AF +27B1 27BE +27D0 27EB +27F0 2AFF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3000 303F +3041 3096 +3099 30FF +3105 312C +3131 318E +3190 31B7 +31F0 321C +3220 3243 +3251 327B +327F 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +3400 4DB5 +4E00 9FA5 +A000 A48C +A490 A4C6 +AC00 D7A3 +D800 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3F +FD50 FD8F +FD92 FDC7 +FDF0 FDFC +FE00 FE0F +FE20 FE23 +FE30 FE46 +FE49 FE52 +FE54 FE66 +FE68 FE6B +FE70 FE74 +FE76 FEFC +FEFF +FF01 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +FFE0 FFE6 +FFE8 FFEE +FFF9 FFFD +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D000 1D0F5 +1D100 1D126 +1D12A 1D1DD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +E0001 +E0020 E007F +F0000 FFFFD +100000 10FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Bengali.pl b/Master/xemtex/perl/lib/unicore/lib/Bengali.pl new file mode 100644 index 00000000000..5d2b9db5849 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Bengali.pl @@ -0,0 +1,27 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Bengali} (and fuzzy permutations) +# +# Meaning: Script 'BENGALI' +# +return <<'END'; +0981 0983 BENGALI +0985 098C BENGALI +098F 0990 BENGALI +0993 09A8 BENGALI +09AA 09B0 BENGALI +09B2 BENGALI +09B6 09B9 BENGALI +09BC BENGALI +09BE 09C4 BENGALI +09C7 09C8 BENGALI +09CB 09CD BENGALI +09D7 BENGALI +09DC 09DD BENGALI +09DF 09E3 BENGALI +09E6 09F1 BENGALI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiAL.pl b/Master/xemtex/perl/lib/unicore/lib/BidiAL.pl new file mode 100644 index 00000000000..4149869f8bb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiAL.pl @@ -0,0 +1,33 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiAL} +# +# Meaning: Bi-directional category 'AL' +# +return <<'END'; +061B +061F +0621 063A +0640 064A +066D 066F +0671 06D5 +06DD +06E5 06E6 +06FA 06FE +0700 070D +0710 +0712 072C +0780 07A5 +07B1 +FB50 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFC +FE70 FE74 +FE76 FEFC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiAN.pl b/Master/xemtex/perl/lib/unicore/lib/BidiAN.pl new file mode 100644 index 00000000000..c5defcb1fb8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiAN.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiAN} +# +# Meaning: Bi-directional category 'AN' +# +return <<'END'; +0660 0669 +066B 066C +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiB.pl b/Master/xemtex/perl/lib/unicore/lib/BidiB.pl new file mode 100644 index 00000000000..85572fec078 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiB.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiB} +# +# Meaning: Bi-directional category 'B' +# +return <<'END'; +000A +000D +001C 001E +0085 +2029 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiBN.pl b/Master/xemtex/perl/lib/unicore/lib/BidiBN.pl new file mode 100644 index 00000000000..b810db1e76c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiBN.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiBN} +# +# Meaning: Bi-directional category 'BN' +# +return <<'END'; +0000 0008 +000E 001B +007F 0084 +0086 009F +070F +180E +200B 200D +2060 2063 +206A 206F +FEFF +FFF9 FFFB +1D173 1D17A +E0001 +E0020 E007F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiCS.pl b/Master/xemtex/perl/lib/unicore/lib/BidiCS.pl new file mode 100644 index 00000000000..7f17238b931 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiCS.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiCS} +# +# Meaning: Bi-directional category 'CS' +# +return <<'END'; +002C +002E +003A +00A0 +060C +FE50 +FE52 +FE55 +FF0C +FF0E +FF1A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiCont.pl b/Master/xemtex/perl/lib/unicore/lib/BidiCont.pl new file mode 100644 index 00000000000..070ad87ba82 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiCont.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiControl} (and fuzzy permutations) +# +# Meaning: Extended property 'Bidi_Control' +# +return <<'END'; +200E 200F Bidi_Control +202A 202E Bidi_Control +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiEN.pl b/Master/xemtex/perl/lib/unicore/lib/BidiEN.pl new file mode 100644 index 00000000000..24a291f864b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiEN.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiEN} +# +# Meaning: Bi-directional category 'EN' +# +return <<'END'; +0030 0039 +00B2 00B3 +00B9 +06F0 06F9 +2070 +2074 2079 +2080 2089 +2460 249B +24EA +FF10 FF19 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiES.pl b/Master/xemtex/perl/lib/unicore/lib/BidiES.pl new file mode 100644 index 00000000000..9810f8118df --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiES.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiES} +# +# Meaning: Bi-directional category 'ES' +# +return <<'END'; +002F +FF0F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiET.pl b/Master/xemtex/perl/lib/unicore/lib/BidiET.pl new file mode 100644 index 00000000000..234cf5ff590 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiET.pl @@ -0,0 +1,36 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiET} +# +# Meaning: Bi-directional category 'ET' +# +return <<'END'; +0023 0025 +002B +002D +00A2 00A5 +00B0 00B1 +066A +09F2 09F3 +0E3F +17DB +2030 2034 +207A 207B +208A 208B +20A0 20B1 +212E +2212 2213 +FB29 +FE5F +FE62 FE63 +FE69 FE6A +FF03 FF05 +FF0B +FF0D +FFE0 FFE1 +FFE5 FFE6 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiL.pl b/Master/xemtex/perl/lib/unicore/lib/BidiL.pl new file mode 100644 index 00000000000..f4033f28e46 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiL.pl @@ -0,0 +1,366 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiL} +# +# Meaning: Bi-directional category 'L' +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0482 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 055F +0561 0587 +0589 +0903 +0905 0939 +093D 0940 +0949 094C +0950 +0958 0961 +0964 0970 +0982 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BE 09C0 +09C7 09C8 +09CB 09CC +09D7 +09DC 09DD +09DF 09E1 +09E6 09F1 +09F4 09FA +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3E 0A40 +0A59 0A5C +0A5E +0A66 0A6F +0A72 0A74 +0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABD 0AC0 +0AC9 +0ACB 0ACC +0AD0 +0AE0 +0AE6 0AEF +0B02 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3D 0B3E +0B40 +0B47 0B48 +0B4B 0B4C +0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B70 +0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BBF +0BC1 0BC2 +0BC6 0BC8 +0BCA 0BCC +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C41 0C44 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE +0CC0 0CC4 +0CC7 0CC8 +0CCA 0CCB +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D40 +0D46 0D48 +0D4A 0D4C +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCF 0DD1 +0DD8 0DDF +0DF2 0DF4 +0E01 0E30 +0E32 0E33 +0E40 0E46 +0E4F 0E5B +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB0 +0EB2 0EB3 +0EBD +0EC0 0EC4 +0EC6 +0ED0 0ED9 +0EDC 0EDD +0F00 0F17 +0F1A 0F34 +0F36 +0F38 +0F3E 0F47 +0F49 0F6A +0F7F +0F85 +0F88 0F8B +0FBE 0FC5 +0FC7 0FCC +0FCF +1000 1021 +1023 1027 +1029 102A +102C +1031 +1038 +1040 1057 +10A0 10C5 +10D0 10F8 +10FB +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1361 137C +13A0 13F4 +1401 1676 +1681 169A +16A0 16F0 +1700 170C +170E 1711 +1720 1731 +1735 1736 +1740 1751 +1760 176C +176E 1770 +1780 17B6 +17BE 17C5 +17C7 17C8 +17D4 17DA +17DC +17E0 17E9 +1810 1819 +1820 1877 +1880 18A8 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +200E +2071 +207F +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2160 2183 +2336 237A +2395 +249C 24E9 +3005 3007 +3021 3029 +3031 3035 +3038 303C +3041 3096 +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +3190 31B7 +31F0 321C +3220 3243 +3260 327B +327F 32B0 +32C0 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +A000 A48C +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D000 1D0F5 +1D100 1D126 +1D12A 1D166 +1D16A 1D172 +1D183 1D184 +1D18C 1D1A9 +1D1AE 1D1DD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiLRE.pl b/Master/xemtex/perl/lib/unicore/lib/BidiLRE.pl new file mode 100644 index 00000000000..5070363fc5c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiLRE.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiLRE} +# +# Meaning: Bi-directional category 'LRE' +# +return <<'END'; +202A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiLRO.pl b/Master/xemtex/perl/lib/unicore/lib/BidiLRO.pl new file mode 100644 index 00000000000..52ea9600f38 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiLRO.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiLRO} +# +# Meaning: Bi-directional category 'LRO' +# +return <<'END'; +202D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiNSM.pl b/Master/xemtex/perl/lib/unicore/lib/BidiNSM.pl new file mode 100644 index 00000000000..7e2f4b10820 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiNSM.pl @@ -0,0 +1,115 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiNSM} +# +# Meaning: Bi-directional category 'NSM' +# +return <<'END'; +0300 034F +0360 036F +0483 0486 +0488 0489 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +064B 0655 +0670 +06D6 06DC +06DE 06E4 +06E7 06E8 +06EA 06ED +0711 +0730 074A +07A6 07B0 +0901 0902 +093C +0941 0948 +094D +0951 0954 +0962 0963 +0981 +09BC +09C1 09C4 +09CD +09E2 09E3 +0A02 +0A3C +0A41 0A42 +0A47 0A48 +0A4B 0A4D +0A70 0A71 +0A81 0A82 +0ABC +0AC1 0AC5 +0AC7 0AC8 +0ACD +0B01 +0B3C +0B3F +0B41 0B43 +0B4D +0B56 +0B82 +0BC0 +0BCD +0C3E 0C40 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0CBF +0CC6 +0CCC 0CCD +0D41 0D43 +0D4D +0DCA +0DD2 0DD4 +0DD6 +0E31 +0E34 0E3A +0E47 0E4E +0EB1 +0EB4 0EB9 +0EBB 0EBC +0EC8 0ECD +0F18 0F19 +0F35 +0F37 +0F39 +0F71 0F7E +0F80 0F84 +0F86 0F87 +0F90 0F97 +0F99 0FBC +0FC6 +102D 1030 +1032 +1036 1037 +1039 +1058 1059 +1712 1714 +1732 1734 +1752 1753 +1772 1773 +17B7 17BD +17C6 +17C9 17D3 +180B 180D +18A9 +20D0 20EA +302A 302F +3099 309A +FB1E +FE00 FE0F +FE20 FE23 +1D167 1D169 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiON.pl b/Master/xemtex/perl/lib/unicore/lib/BidiON.pl new file mode 100644 index 00000000000..7fe891ebad3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiON.pl @@ -0,0 +1,121 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiON} +# +# Meaning: Bi-directional category 'ON' +# +return <<'END'; +0021 0022 +0026 002A +003B 0040 +005B 0060 +007B 007E +00A1 +00A6 00A9 +00AB 00AF +00B4 +00B6 00B8 +00BB 00BF +00D7 +00F7 +02B9 02BA +02C2 02CF +02D2 02DF +02E5 02ED +0374 0375 +037E +0384 0385 +0387 +03F6 +058A +06E9 +0F3A 0F3D +169B 169C +1800 180A +1FBD +1FBF 1FC1 +1FCD 1FCF +1FDD 1FDF +1FED 1FEF +1FFD 1FFE +2010 2027 +2035 2052 +2057 +207C 207E +208C 208E +2100 2101 +2103 2106 +2108 2109 +2114 +2116 2118 +211E 2123 +2125 +2127 +2129 +2132 +213A +2140 2144 +214A 214B +2153 215F +2190 2211 +2214 2335 +237B 2394 +2396 23CE +2400 2426 +2440 244A +24EB 24FE +2500 2613 +2616 2617 +2619 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2794 +2798 27AF +27B1 27BE +27D0 27EB +27F0 2AFF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3001 3004 +3008 3020 +3030 +3036 3037 +303D 303F +309B 309C +30A0 +30FB +3251 325F +32B1 32BF +A490 A4C6 +FD3E FD3F +FE30 FE46 +FE49 FE4F +FE51 +FE54 +FE56 FE5E +FE60 FE61 +FE64 FE66 +FE68 +FE6B +FF01 FF02 +FF06 FF0A +FF1B FF20 +FF3B FF40 +FF5B FF65 +FFE2 FFE4 +FFE8 FFEE +FFFC FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiPDF.pl b/Master/xemtex/perl/lib/unicore/lib/BidiPDF.pl new file mode 100644 index 00000000000..ef251bd04ce --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiPDF.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiPDF} +# +# Meaning: Bi-directional category 'PDF' +# +return <<'END'; +202C +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiR.pl b/Master/xemtex/perl/lib/unicore/lib/BidiR.pl new file mode 100644 index 00000000000..4d62027f26b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiR.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiR} +# +# Meaning: Bi-directional category 'R' +# +return <<'END'; +05BE +05C0 +05C3 +05D0 05EA +05F0 05F4 +200F +FB1D +FB1F FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FB4F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiRLE.pl b/Master/xemtex/perl/lib/unicore/lib/BidiRLE.pl new file mode 100644 index 00000000000..dd2162396cc --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiRLE.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiRLE} +# +# Meaning: Bi-directional category 'RLE' +# +return <<'END'; +202B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiRLO.pl b/Master/xemtex/perl/lib/unicore/lib/BidiRLO.pl new file mode 100644 index 00000000000..244385588b6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiRLO.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiRLO} +# +# Meaning: Bi-directional category 'RLO' +# +return <<'END'; +202E +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiS.pl b/Master/xemtex/perl/lib/unicore/lib/BidiS.pl new file mode 100644 index 00000000000..27207fa5197 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiS.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiS} +# +# Meaning: Bi-directional category 'S' +# +return <<'END'; +0009 +000B +001F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/BidiWS.pl b/Master/xemtex/perl/lib/unicore/lib/BidiWS.pl new file mode 100644 index 00000000000..11896597aea --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/BidiWS.pl @@ -0,0 +1,20 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{BidiWS} +# +# Meaning: Bi-directional category 'WS' +# +return <<'END'; +000C +0020 +1680 +2000 200A +2028 +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Blank.pl b/Master/xemtex/perl/lib/unicore/lib/Blank.pl new file mode 100644 index 00000000000..96498cb22fe --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Blank.pl @@ -0,0 +1,20 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Blank} +# +# Meaning: [[:Blank:]] +# +return <<'END'; +0009 +0020 +00A0 +1680 +2000 200B +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Bopomofo.pl b/Master/xemtex/perl/lib/unicore/lib/Bopomofo.pl new file mode 100644 index 00000000000..525797c8b8d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Bopomofo.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Bopomofo} (and fuzzy permutations) +# +# Meaning: Script 'BOPOMOFO' +# +return <<'END'; +3105 312C BOPOMOFO +31A0 31B7 BOPOMOFO +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Buhid.pl b/Master/xemtex/perl/lib/unicore/lib/Buhid.pl new file mode 100644 index 00000000000..c1ad8f86d2d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Buhid.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Buhid} (and fuzzy permutations) +# +# Meaning: Script 'BUHID' +# +return <<'END'; +1740 1753 BUHID +END diff --git a/Master/xemtex/perl/lib/unicore/lib/C.pl b/Master/xemtex/perl/lib/unicore/lib/C.pl new file mode 100644 index 00000000000..bbe5b39e482 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/C.pl @@ -0,0 +1,400 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{C} +# \p{C} (and fuzzy permutations) +# +# Meaning: Major Category 'C' +# +return <<'END'; +0000 001F +007F 009F +0221 +0234 024F +02AE 02AF +02EF 02FF +0350 035F +0370 0373 +0376 0379 +037B 037D +037F 0383 +038B +038D +03A2 +03CF +03F7 03FF +0487 +04CF +04F6 04F7 +04FA 04FF +0510 0530 +0557 0558 +0560 +0588 +058B 0590 +05A2 +05BA +05C5 05CF +05EB 05EF +05F5 060B +060D 061A +061C 061E +0620 +063B 063F +0656 065F +06DD +06EE 06EF +06FF +070E 070F +072D 072F +074B 077F +07B2 0900 +0904 +093A 093B +094E 094F +0955 0957 +0971 0980 +0984 +098D 098E +0991 0992 +09A9 +09B1 +09B3 09B5 +09BA 09BB +09BD +09C5 09C6 +09C9 09CA +09CE 09D6 +09D8 09DB +09DE +09E4 09E5 +09FB 0A01 +0A03 0A04 +0A0B 0A0E +0A11 0A12 +0A29 +0A31 +0A34 +0A37 +0A3A 0A3B +0A3D +0A43 0A46 +0A49 0A4A +0A4E 0A58 +0A5D +0A5F 0A65 +0A75 0A80 +0A84 +0A8C +0A8E +0A92 +0AA9 +0AB1 +0AB4 +0ABA 0ABB +0AC6 +0ACA +0ACE 0ACF +0AD1 0ADF +0AE1 0AE5 +0AF0 0B00 +0B04 +0B0D 0B0E +0B11 0B12 +0B29 +0B31 +0B34 0B35 +0B3A 0B3B +0B44 0B46 +0B49 0B4A +0B4E 0B55 +0B58 0B5B +0B5E +0B62 0B65 +0B71 0B81 +0B84 +0B8B 0B8D +0B91 +0B96 0B98 +0B9B +0B9D +0BA0 0BA2 +0BA5 0BA7 +0BAB 0BAD +0BB6 +0BBA 0BBD +0BC3 0BC5 +0BC9 +0BCE 0BD6 +0BD8 0BE6 +0BF3 0C00 +0C04 +0C0D +0C11 +0C29 +0C34 +0C3A 0C3D +0C45 +0C49 +0C4E 0C54 +0C57 0C5F +0C62 0C65 +0C70 0C81 +0C84 +0C8D +0C91 +0CA9 +0CB4 +0CBA 0CBD +0CC5 +0CC9 +0CCE 0CD4 +0CD7 0CDD +0CDF +0CE2 0CE5 +0CF0 0D01 +0D04 +0D0D +0D11 +0D29 +0D3A 0D3D +0D44 0D45 +0D49 +0D4E 0D56 +0D58 0D5F +0D62 0D65 +0D70 0D81 +0D84 +0D97 0D99 +0DB2 +0DBC +0DBE 0DBF +0DC7 0DC9 +0DCB 0DCE +0DD5 +0DD7 +0DE0 0DF1 +0DF5 0E00 +0E3B 0E3E +0E5C 0E80 +0E83 +0E85 0E86 +0E89 +0E8B 0E8C +0E8E 0E93 +0E98 +0EA0 +0EA4 +0EA6 +0EA8 0EA9 +0EAC +0EBA +0EBE 0EBF +0EC5 +0EC7 +0ECE 0ECF +0EDA 0EDB +0EDE 0EFF +0F48 +0F6B 0F70 +0F8C 0F8F +0F98 +0FBD +0FCD 0FCE +0FD0 0FFF +1022 +1028 +102B +1033 1035 +103A 103F +105A 109F +10C6 10CF +10F9 10FA +10FC 10FF +115A 115E +11A3 11A7 +11FA 11FF +1207 +1247 +1249 +124E 124F +1257 +1259 +125E 125F +1287 +1289 +128E 128F +12AF +12B1 +12B6 12B7 +12BF +12C1 +12C6 12C7 +12CF +12D7 +12EF +130F +1311 +1316 1317 +131F +1347 +135B 1360 +137D 139F +13F5 1400 +1677 167F +169D 169F +16F1 16FF +170D +1715 171F +1737 173F +1754 175F +176D +1771 +1774 177F +17DD 17DF +17EA 17FF +180E 180F +181A 181F +1878 187F +18AA 1DFF +1E9C 1E9F +1EFA 1EFF +1F16 1F17 +1F1E 1F1F +1F46 1F47 +1F4E 1F4F +1F58 +1F5A +1F5C +1F5E +1F7E 1F7F +1FB5 +1FC5 +1FD4 1FD5 +1FDC +1FF0 1FF1 +1FF5 +1FFF +200C 200F +202A 202E +2053 2056 +2058 205E +2060 206F +2072 2073 +208F 209F +20B2 20CF +20EB 20FF +213B 213C +214C 2152 +2184 218F +23CF 23FF +2427 243F +244B 245F +24FF +2614 2615 +2618 +267E 267F +268A 2700 +2705 +270A 270B +2728 +274C +274E +2753 2755 +2757 +275F 2760 +2795 2797 +27B0 +27BF 27CF +27EC 27EF +2B00 2E7F +2E9A +2EF4 2EFF +2FD6 2FEF +2FFC 2FFF +3040 +3097 3098 +3100 3104 +312D 3130 +318F +31B8 31EF +321D 321F +3244 3250 +327C 327E +32CC 32CF +32FF +3377 337A +33DE 33DF +33FF +4DB6 4DFF +9FA6 9FFF +A48D A48F +A4C7 ABFF +D7A4 F8FF +FA2E FA2F +FA6B FAFF +FB07 FB12 +FB18 FB1C +FB37 +FB3D +FB3F +FB42 +FB45 +FBB2 FBD2 +FD40 FD4F +FD90 FD91 +FDC8 FDEF +FDFD FDFF +FE10 FE1F +FE24 FE2F +FE47 FE48 +FE53 +FE67 +FE6C FE6F +FE75 +FEFD FF00 +FFBF FFC1 +FFC8 FFC9 +FFD0 FFD1 +FFD8 FFD9 +FFDD FFDF +FFE7 +FFEF FFFB +FFFE 102FF +1031F +10324 1032F +1034B 103FF +10426 10427 +1044E 1CFFF +1D0F6 1D0FF +1D127 1D129 +1D173 1D17A +1D1DE 1D3FF +1D455 +1D49D +1D4A0 1D4A1 +1D4A3 1D4A4 +1D4A7 1D4A8 +1D4AD +1D4BA +1D4BC +1D4C1 +1D4C4 +1D506 +1D50B 1D50C +1D515 +1D51D +1D53A +1D53F +1D545 +1D547 1D549 +1D551 +1D6A4 1D6A7 +1D7CA 1D7CD +1D800 1FFFF +2A6D7 2F7FF +2FA1E 10FFFF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Canadian.pl b/Master/xemtex/perl/lib/unicore/lib/Canadian.pl new file mode 100644 index 00000000000..e4942b1d441 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Canadian.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{CanadianAboriginal} (and fuzzy permutations) +# +# Meaning: Script 'CANADIAN_ABORIGINAL' +# +return <<'END'; +1401 166C CANADIAN_ABORIGINAL +166F 1676 CANADIAN_ABORIGINAL +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Canon.pl b/Master/xemtex/perl/lib/unicore/lib/Canon.pl new file mode 100644 index 00000000000..4d30c4b3439 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Canon.pl @@ -0,0 +1,224 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Canon} +# +# Meaning: Decomposes to multiple characters +# +return <<'END'; +00C0 00C5 +00C7 00CF +00D1 00D6 +00D9 00DD +00E0 00E5 +00E7 00EF +00F1 00F6 +00F9 00FD +00FF 010F +0112 0125 +0128 0130 +0134 0137 +0139 013E +0143 0148 +014C 0151 +0154 0165 +0168 017E +01A0 01A1 +01AF 01B0 +01CD 01DC +01DE 01E3 +01E6 01F0 +01F4 01F5 +01F8 021B +021E 021F +0226 0233 +0340 0341 +0343 0344 +0374 +037E +0385 038A +038C +038E 0390 +03AA 03B0 +03CA 03CE +03D3 03D4 +0400 0401 +0403 +0407 +040C 040E +0419 +0439 +0450 0451 +0453 +0457 +045C 045E +0476 0477 +04C1 04C2 +04D0 04D3 +04D6 04D7 +04DA 04DF +04E2 04E7 +04EA 04F5 +04F8 04F9 +0622 0626 +06C0 +06C2 +06D3 +0929 +0931 +0934 +0958 095F +09CB 09CC +09DC 09DD +09DF +0A33 +0A36 +0A59 0A5B +0A5E +0B48 +0B4B 0B4C +0B5C 0B5D +0B94 +0BCA 0BCC +0C48 +0CC0 +0CC7 0CC8 +0CCA 0CCB +0D4A 0D4C +0DDA +0DDC 0DDE +0F43 +0F4D +0F52 +0F57 +0F5C +0F69 +0F73 +0F75 0F76 +0F78 +0F81 +0F93 +0F9D +0FA2 +0FA7 +0FAC +0FB9 +1026 +1E00 1E99 +1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC1 1FC4 +1FC6 1FD3 +1FD6 1FDB +1FDD 1FEF +1FF2 1FF4 +1FF6 1FFD +2000 2001 +2126 +212A 212B +219A 219B +21AE +21CD 21CF +2204 +2209 +220C +2224 +2226 +2241 +2244 +2247 +2249 +2260 +2262 +226D 2271 +2274 2275 +2278 2279 +2280 2281 +2284 2285 +2288 2289 +22AC 22AF +22E0 22E3 +22EA 22ED +2329 232A +2ADC +304C +304E +3050 +3052 +3054 +3056 +3058 +305A +305C +305E +3060 +3062 +3065 +3067 +3069 +3070 3071 +3073 3074 +3076 3077 +3079 307A +307C 307D +3094 +309E +30AC +30AE +30B0 +30B2 +30B4 +30B6 +30B8 +30BA +30BC +30BE +30C0 +30C2 +30C5 +30C7 +30C9 +30D0 30D1 +30D3 30D4 +30D6 30D7 +30D9 30DA +30DC 30DD +30F4 +30F7 30FA +30FE +F900 FA0D +FA10 +FA12 +FA15 FA1E +FA20 +FA22 +FA25 FA26 +FA2A FA2D +FA30 FA6A +FB1D +FB1F +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FB4E +1D15E 1D164 +1D1BB 1D1C0 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cc.pl b/Master/xemtex/perl/lib/unicore/lib/Cc.pl new file mode 100644 index 00000000000..34faf2eca8f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cc.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cc} +# \p{Cc} (and fuzzy permutations) +# +# Meaning: General Category 'Cc' +# +return <<'END'; +0000 001F +007F 009F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cf.pl b/Master/xemtex/perl/lib/unicore/lib/Cf.pl new file mode 100644 index 00000000000..9012824ee45 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cf.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cf} +# \p{Cf} (and fuzzy permutations) +# +# Meaning: General Category 'Cf' +# +return <<'END'; +06DD +070F +180E +200C 200F +202A 202E +2060 2063 +206A 206F +FEFF +FFF9 FFFB +1D173 1D17A +E0001 +E0020 E007F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cherokee.pl b/Master/xemtex/perl/lib/unicore/lib/Cherokee.pl new file mode 100644 index 00000000000..4844ef48799 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cherokee.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cherokee} (and fuzzy permutations) +# +# Meaning: Script 'CHEROKEE' +# +return <<'END'; +13A0 13F4 CHEROKEE +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cn.pl b/Master/xemtex/perl/lib/unicore/lib/Cn.pl new file mode 100644 index 00000000000..c080d192302 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cn.pl @@ -0,0 +1,399 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cn} +# \p{Cn} (and fuzzy permutations) +# +# Meaning: General Category 'Cn' [not functional in Perl] +# +return <<'END'; +0221 +0234 024F +02AE 02AF +02EF 02FF +0350 035F +0370 0373 +0376 0379 +037B 037D +037F 0383 +038B +038D +03A2 +03CF +03F7 03FF +0487 +04CF +04F6 04F7 +04FA 04FF +0510 0530 +0557 0558 +0560 +0588 +058B 0590 +05A2 +05BA +05C5 05CF +05EB 05EF +05F5 060B +060D 061A +061C 061E +0620 +063B 063F +0656 065F +06EE 06EF +06FF +070E +072D 072F +074B 077F +07B2 0900 +0904 +093A 093B +094E 094F +0955 0957 +0971 0980 +0984 +098D 098E +0991 0992 +09A9 +09B1 +09B3 09B5 +09BA 09BB +09BD +09C5 09C6 +09C9 09CA +09CE 09D6 +09D8 09DB +09DE +09E4 09E5 +09FB 0A01 +0A03 0A04 +0A0B 0A0E +0A11 0A12 +0A29 +0A31 +0A34 +0A37 +0A3A 0A3B +0A3D +0A43 0A46 +0A49 0A4A +0A4E 0A58 +0A5D +0A5F 0A65 +0A75 0A80 +0A84 +0A8C +0A8E +0A92 +0AA9 +0AB1 +0AB4 +0ABA 0ABB +0AC6 +0ACA +0ACE 0ACF +0AD1 0ADF +0AE1 0AE5 +0AF0 0B00 +0B04 +0B0D 0B0E +0B11 0B12 +0B29 +0B31 +0B34 0B35 +0B3A 0B3B +0B44 0B46 +0B49 0B4A +0B4E 0B55 +0B58 0B5B +0B5E +0B62 0B65 +0B71 0B81 +0B84 +0B8B 0B8D +0B91 +0B96 0B98 +0B9B +0B9D +0BA0 0BA2 +0BA5 0BA7 +0BAB 0BAD +0BB6 +0BBA 0BBD +0BC3 0BC5 +0BC9 +0BCE 0BD6 +0BD8 0BE6 +0BF3 0C00 +0C04 +0C0D +0C11 +0C29 +0C34 +0C3A 0C3D +0C45 +0C49 +0C4E 0C54 +0C57 0C5F +0C62 0C65 +0C70 0C81 +0C84 +0C8D +0C91 +0CA9 +0CB4 +0CBA 0CBD +0CC5 +0CC9 +0CCE 0CD4 +0CD7 0CDD +0CDF +0CE2 0CE5 +0CF0 0D01 +0D04 +0D0D +0D11 +0D29 +0D3A 0D3D +0D44 0D45 +0D49 +0D4E 0D56 +0D58 0D5F +0D62 0D65 +0D70 0D81 +0D84 +0D97 0D99 +0DB2 +0DBC +0DBE 0DBF +0DC7 0DC9 +0DCB 0DCE +0DD5 +0DD7 +0DE0 0DF1 +0DF5 0E00 +0E3B 0E3E +0E5C 0E80 +0E83 +0E85 0E86 +0E89 +0E8B 0E8C +0E8E 0E93 +0E98 +0EA0 +0EA4 +0EA6 +0EA8 0EA9 +0EAC +0EBA +0EBE 0EBF +0EC5 +0EC7 +0ECE 0ECF +0EDA 0EDB +0EDE 0EFF +0F48 +0F6B 0F70 +0F8C 0F8F +0F98 +0FBD +0FCD 0FCE +0FD0 0FFF +1022 +1028 +102B +1033 1035 +103A 103F +105A 109F +10C6 10CF +10F9 10FA +10FC 10FF +115A 115E +11A3 11A7 +11FA 11FF +1207 +1247 +1249 +124E 124F +1257 +1259 +125E 125F +1287 +1289 +128E 128F +12AF +12B1 +12B6 12B7 +12BF +12C1 +12C6 12C7 +12CF +12D7 +12EF +130F +1311 +1316 1317 +131F +1347 +135B 1360 +137D 139F +13F5 1400 +1677 167F +169D 169F +16F1 16FF +170D +1715 171F +1737 173F +1754 175F +176D +1771 +1774 177F +17DD 17DF +17EA 17FF +180F +181A 181F +1878 187F +18AA 1DFF +1E9C 1E9F +1EFA 1EFF +1F16 1F17 +1F1E 1F1F +1F46 1F47 +1F4E 1F4F +1F58 +1F5A +1F5C +1F5E +1F7E 1F7F +1FB5 +1FC5 +1FD4 1FD5 +1FDC +1FF0 1FF1 +1FF5 +1FFF +2053 2056 +2058 205E +2064 2069 +2072 2073 +208F 209F +20B2 20CF +20EB 20FF +213B 213C +214C 2152 +2184 218F +23CF 23FF +2427 243F +244B 245F +24FF +2614 2615 +2618 +267E 267F +268A 2700 +2705 +270A 270B +2728 +274C +274E +2753 2755 +2757 +275F 2760 +2795 2797 +27B0 +27BF 27CF +27EC 27EF +2B00 2E7F +2E9A +2EF4 2EFF +2FD6 2FEF +2FFC 2FFF +3040 +3097 3098 +3100 3104 +312D 3130 +318F +31B8 31EF +321D 321F +3244 3250 +327C 327E +32CC 32CF +32FF +3377 337A +33DE 33DF +33FF +4DB6 4DFF +9FA6 9FFF +A48D A48F +A4C7 ABFF +D7A4 D7FF +FA2E FA2F +FA6B FAFF +FB07 FB12 +FB18 FB1C +FB37 +FB3D +FB3F +FB42 +FB45 +FBB2 FBD2 +FD40 FD4F +FD90 FD91 +FDC8 FDEF +FDFD FDFF +FE10 FE1F +FE24 FE2F +FE47 FE48 +FE53 +FE67 +FE6C FE6F +FE75 +FEFD FEFE +FF00 +FFBF FFC1 +FFC8 FFC9 +FFD0 FFD1 +FFD8 FFD9 +FFDD FFDF +FFE7 +FFEF FFF8 +FFFE 102FF +1031F +10324 1032F +1034B 103FF +10426 10427 +1044E 1CFFF +1D0F6 1D0FF +1D127 1D129 +1D1DE 1D3FF +1D455 +1D49D +1D4A0 1D4A1 +1D4A3 1D4A4 +1D4A7 1D4A8 +1D4AD +1D4BA +1D4BC +1D4C1 +1D4C4 +1D506 +1D50B 1D50C +1D515 +1D51D +1D53A +1D53F +1D545 +1D547 1D549 +1D551 +1D6A4 1D6A7 +1D7CA 1D7CD +1D800 1FFFF +2A6D7 2F7FF +2FA1E E0000 +E0002 E001F +E0080 EFFFF +FFFFE FFFFF +10FFFE 10FFFF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cntrl.pl b/Master/xemtex/perl/lib/unicore/lib/Cntrl.pl new file mode 100644 index 00000000000..b794776699b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cntrl.pl @@ -0,0 +1,29 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cntrl} +# +# Meaning: [[:Cntrl:]] +# +return <<'END'; +0000 001F +007F 009F +06DD +070F +180E +200C 200F +202A 202E +2060 2063 +206A 206F +D800 F8FF +FEFF +FFF9 FFFB +1D173 1D17A +E0001 +E0020 E007F +F0000 FFFFD +100000 10FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Co.pl b/Master/xemtex/perl/lib/unicore/lib/Co.pl new file mode 100644 index 00000000000..1f1ad215689 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Co.pl @@ -0,0 +1,16 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Co} +# \p{Co} (and fuzzy permutations) +# +# Meaning: General Category 'Co' +# +return <<'END'; +E000 F8FF +F0000 FFFFD +100000 10FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Common.pl b/Master/xemtex/perl/lib/unicore/lib/Common.pl new file mode 100644 index 00000000000..677d38e8bf2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Common.pl @@ -0,0 +1,367 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Common} (and fuzzy permutations) +# +# Meaning: Pseudo-Script of codepoints not in other Unicode scripts +# +return <<'END'; +0000 0040 +005B 0060 +007B 00A9 +00AB 00B4 +00B6 00B9 +00BB 00BF +00D7 +00F7 +0221 +0234 024F +02AE 02AF +02B9 02DF +02E5 02FF +0350 035F +0370 0379 +037B 0385 +0387 +038B +038D +03A2 +03CF +03F6 03FF +0482 +0487 +04CF +04F6 04F7 +04FA 04FF +0510 0530 +0557 0558 +055A 0560 +0588 0590 +05A2 +05BA +05BE +05C0 +05C3 +05C5 05CF +05EB 05EF +05F3 0620 +063B 0640 +0656 066D +06D4 +06E9 +06EE 06F9 +06FD 070F +072D 072F +074B 077F +07B2 0900 +0904 +093A 093B +094E 094F +0955 0957 +0964 0965 +0970 0980 +0984 +098D 098E +0991 0992 +09A9 +09B1 +09B3 09B5 +09BA 09BB +09BD +09C5 09C6 +09C9 09CA +09CE 09D6 +09D8 09DB +09DE +09E4 09E5 +09F2 0A01 +0A03 0A04 +0A0B 0A0E +0A11 0A12 +0A29 +0A31 +0A34 +0A37 +0A3A 0A3B +0A3D +0A43 0A46 +0A49 0A4A +0A4E 0A58 +0A5D +0A5F 0A65 +0A75 0A80 +0A84 +0A8C +0A8E +0A92 +0AA9 +0AB1 +0AB4 +0ABA 0ABB +0AC6 +0ACA +0ACE 0ACF +0AD1 0ADF +0AE1 0AE5 +0AF0 0B00 +0B04 +0B0D 0B0E +0B11 0B12 +0B29 +0B31 +0B34 0B35 +0B3A 0B3B +0B44 0B46 +0B49 0B4A +0B4E 0B55 +0B58 0B5B +0B5E +0B62 0B65 +0B70 0B81 +0B84 +0B8B 0B8D +0B91 +0B96 0B98 +0B9B +0B9D +0BA0 0BA2 +0BA5 0BA7 +0BAB 0BAD +0BB6 +0BBA 0BBD +0BC3 0BC5 +0BC9 +0BCE 0BD6 +0BD8 0BE6 +0BF3 0C00 +0C04 +0C0D +0C11 +0C29 +0C34 +0C3A 0C3D +0C45 +0C49 +0C4E 0C54 +0C57 0C5F +0C62 0C65 +0C70 0C81 +0C84 +0C8D +0C91 +0CA9 +0CB4 +0CBA 0CBD +0CC5 +0CC9 +0CCE 0CD4 +0CD7 0CDD +0CDF +0CE2 0CE5 +0CF0 0D01 +0D04 +0D0D +0D11 +0D29 +0D3A 0D3D +0D44 0D45 +0D49 +0D4E 0D56 +0D58 0D5F +0D62 0D65 +0D70 0D81 +0D84 +0D97 0D99 +0DB2 +0DBC +0DBE 0DBF +0DC7 0DC9 +0DCB 0DCE +0DD5 +0DD7 +0DE0 0DF1 +0DF4 0E00 +0E3B 0E3F +0E4F +0E5A 0E80 +0E83 +0E85 0E86 +0E89 +0E8B 0E8C +0E8E 0E93 +0E98 +0EA0 +0EA4 +0EA6 +0EA8 0EA9 +0EAC +0EBA +0EBE 0EBF +0EC5 +0EC7 +0ECE 0ECF +0EDA 0EDB +0EDE 0EFF +0F01 0F17 +0F1A 0F1F +0F34 +0F36 +0F38 +0F3A 0F3F +0F48 +0F6B 0F70 +0F85 +0F8C 0F8F +0F98 +0FBD 0FC5 +0FC7 0FFF +1022 +1028 +102B +1033 1035 +103A 103F +104A 104F +105A 109F +10C6 10CF +10F9 10FF +115A 115E +11A3 11A7 +11FA 11FF +1207 +1247 +1249 +124E 124F +1257 +1259 +125E 125F +1287 +1289 +128E 128F +12AF +12B1 +12B6 12B7 +12BF +12C1 +12C6 12C7 +12CF +12D7 +12EF +130F +1311 +1316 1317 +131F +1347 +135B 1368 +137D 139F +13F5 1400 +166D 166E +1677 1680 +169B 169F +16EB 16ED +16F1 16FF +170D +1715 171F +1735 173F +1754 175F +176D +1771 +1774 177F +17D4 17DF +17EA 180A +180E 180F +181A 181F +1878 187F +18AA 1DFF +1E9C 1E9F +1EFA 1EFF +1F16 1F17 +1F1E 1F1F +1F46 1F47 +1F4E 1F4F +1F58 +1F5A +1F5C +1F5E +1F7E 1F7F +1FB5 +1FBD +1FBF 1FC1 +1FC5 +1FCD 1FCF +1FD4 1FD5 +1FDC 1FDF +1FED 1FF1 +1FF5 +1FFD 2070 +2072 207E +2080 20CF +20EB 2125 +2127 2129 +212C 2E7F +2E9A +2EF4 2EFF +2FD6 3004 +3006 +3008 3020 +3030 3037 +303C 3040 +3097 3098 +309B 309C +30A0 +30FB 30FC +3100 3104 +312D 3130 +318F 319F +31B8 31EF +3200 33FF +4DB6 4DFF +9FA6 9FFF +A48D A48F +A4A2 A4A3 +A4B4 +A4C1 +A4C5 +A4C7 ABFF +D7A4 F8FF +FA2E FA2F +FA6B FAFF +FB07 FB12 +FB18 FB1C +FB29 +FB37 +FB3D +FB3F +FB42 +FB45 +FBB2 FBD2 +FD3E FD4F +FD90 FD91 +FDC8 FDEF +FDFC FDFF +FE10 FE1F +FE24 FE6F +FE75 +FEFD FF20 +FF3B FF40 +FF5B FF65 +FF70 +FF9E FF9F +FFBF FFC1 +FFC8 FFC9 +FFD0 FFD1 +FFD8 FFD9 +FFDD 102FF +1031F 1032F +1034B 103FF +10426 10427 +1044E 1D166 +1D16A 1D17A +1D183 1D184 +1D18C 1D1A9 +1D1AE 1FFFF +2A6D7 2F7FF +2FA1E 10FFFF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Compat.pl b/Master/xemtex/perl/lib/unicore/lib/Compat.pl new file mode 100644 index 00000000000..12806f13605 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Compat.pl @@ -0,0 +1,143 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Compat} +# +# Meaning: Compatible with a more-basic character +# +return <<'END'; +00A0 +00A8 +00AA +00AF +00B2 00B5 +00B8 00BA +00BC 00BE +0132 0133 +013F 0140 +0149 +017F +01C4 01CC +01F1 01F3 +02B0 02B8 +02D8 02DD +02E0 02E4 +037A +0384 +03D0 03D2 +03D5 03D6 +03F0 03F2 +03F4 03F5 +0587 +0675 0678 +0E33 +0EB3 +0EDC 0EDD +0F0C +0F77 +0F79 +1E9A +1FBD +1FBF 1FC0 +1FFE +2002 200A +2011 +2017 +2024 2026 +202F +2033 2034 +2036 2037 +203C +203E +2047 2049 +2057 +205F +2070 2071 +2074 208E +20A8 +2100 2103 +2105 2107 +2109 2113 +2115 2116 +2119 211D +2120 2122 +2124 +2128 +212C 212D +212F 2131 +2133 2139 +213D 2140 +2145 2149 +2153 217F +222C 222D +222F 2230 +2460 24EA +2A0C +2A74 2A76 +2E9F +2EF3 +2F00 2FD5 +3000 +3036 +3038 303A +309B 309C +309F +30FF +3131 318E +3192 319F +3200 321C +3220 3243 +3251 327B +3280 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +FB00 FB06 +FB13 FB17 +FB20 FB29 +FB4F FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFC +FE30 FE44 +FE49 FE52 +FE54 FE66 +FE68 FE6B +FE70 FE72 +FE74 +FE76 FEFC +FF01 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +FFE0 FFE6 +FFE8 FFEE +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cs.pl b/Master/xemtex/perl/lib/unicore/lib/Cs.pl new file mode 100644 index 00000000000..4624d9da766 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cs.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cs} +# \p{Cs} (and fuzzy permutations) +# +# Meaning: General Category 'Cs' +# +return <<'END'; +D800 DFFF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Cyrillic.pl b/Master/xemtex/perl/lib/unicore/lib/Cyrillic.pl new file mode 100644 index 00000000000..690e2f7a9ef --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Cyrillic.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Cyrillic} (and fuzzy permutations) +# +# Meaning: Script 'CYRILLIC' +# +return <<'END'; +0400 0481 CYRILLIC +0483 0486 CYRILLIC +048A 04CE CYRILLIC +04D0 04F5 CYRILLIC +04F8 04F9 CYRILLIC +0500 050F CYRILLIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCcircle.pl b/Master/xemtex/perl/lib/unicore/lib/DCcircle.pl new file mode 100644 index 00000000000..b873609a4de --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCcircle.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCcircle} +# +# Meaning: Compatible with 'circle' +# +return <<'END'; +2460 2473 +24B6 24EA +3251 327B +3280 32BF +32D0 32FE +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCcompat.pl b/Master/xemtex/perl/lib/unicore/lib/DCcompat.pl new file mode 100644 index 00000000000..a35aaa9da3c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCcompat.pl @@ -0,0 +1,81 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCcompat} +# +# Meaning: Compatible with 'compat' +# +return <<'END'; +00A8 +00AF +00B4 00B5 +00B8 +0132 0133 +013F 0140 +0149 +017F +01C4 01CC +01F1 01F3 +02D8 02DD +037A +0384 +03D0 03D2 +03D5 03D6 +03F0 03F2 +03F4 03F5 +0587 +0675 0678 +0E33 +0EB3 +0EDC 0EDD +0F77 +0F79 +1E9A +1FBD +1FBF 1FC0 +1FFE +2002 2006 +2008 200A +2017 +2024 2026 +2033 2034 +2036 2037 +203C +203E +2047 2049 +2057 +205F +20A8 +2100 2101 +2103 +2105 2107 +2109 +2116 +2121 +2135 2138 +2160 217F +222C 222D +222F 2230 +2474 24B5 +2A0C +2A74 2A76 +2E9F +2EF3 +2F00 2FD5 +3036 +3038 303A +309B 309C +3131 318E +3200 321C +3220 3243 +32C0 32CB +3358 3370 +33E0 33FE +FB00 FB06 +FB13 FB17 +FB4F +FE49 FE4F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCfinal.pl b/Master/xemtex/perl/lib/unicore/lib/DCfinal.pl new file mode 100644 index 00000000000..d5fa53efe45 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCfinal.pl @@ -0,0 +1,125 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCfinal} +# +# Meaning: Compatible with 'final' +# +return <<'END'; +FB51 +FB53 +FB57 +FB5B +FB5F +FB63 +FB67 +FB6B +FB6F +FB73 +FB77 +FB7B +FB7F +FB83 +FB85 +FB87 +FB89 +FB8B +FB8D +FB8F +FB93 +FB97 +FB9B +FB9F +FBA1 +FBA5 +FBA7 +FBAB +FBAF +FBB1 +FBD4 +FBD8 +FBDA +FBDC +FBDF +FBE1 +FBE3 +FBE5 +FBEB +FBED +FBEF +FBF1 +FBF3 +FBF5 +FBF7 +FBFA +FBFD +FC64 FC96 +FD11 FD2C +FD3C +FD51 +FD58 +FD5A FD5B +FD5E FD5F +FD62 +FD64 +FD66 FD67 +FD69 FD6A +FD6C +FD6E FD6F +FD71 +FD74 FD76 +FD78 FD7C +FD7E FD82 +FD84 FD85 +FD87 +FD8B +FD96 FD97 +FD99 FD9C +FD9E FDB3 +FDB6 FDB7 +FDB9 +FDBB FDC2 +FDC6 FDC7 +FE82 +FE84 +FE86 +FE88 +FE8A +FE8E +FE90 +FE94 +FE96 +FE9A +FE9E +FEA2 +FEA6 +FEAA +FEAC +FEAE +FEB0 +FEB2 +FEB6 +FEBA +FEBE +FEC2 +FEC6 +FECA +FECE +FED2 +FED6 +FEDA +FEDE +FEE2 +FEE6 +FEEA +FEEE +FEF0 +FEF2 +FEF6 +FEF8 +FEFA +FEFC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCfont.pl b/Master/xemtex/perl/lib/unicore/lib/DCfont.pl new file mode 100644 index 00000000000..30b94d1aeb5 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCfont.pl @@ -0,0 +1,47 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCfont} +# +# Meaning: Compatible with 'font' +# +return <<'END'; +2102 +210A 2113 +2115 +2119 211D +2124 +2128 +212C 212D +212F 2131 +2133 2134 +2139 +213D 2140 +2145 2149 +FB20 FB29 +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCfracti.pl b/Master/xemtex/perl/lib/unicore/lib/DCfracti.pl new file mode 100644 index 00000000000..87b4247f476 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCfracti.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCfraction} +# +# Meaning: Compatible with 'fraction' +# +return <<'END'; +00BC 00BE +2153 215F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCinitia.pl b/Master/xemtex/perl/lib/unicore/lib/DCinitia.pl new file mode 100644 index 00000000000..b903eceef61 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCinitia.pl @@ -0,0 +1,87 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCinitial} +# +# Meaning: Compatible with 'initial' +# +return <<'END'; +FB54 +FB58 +FB5C +FB60 +FB64 +FB68 +FB6C +FB70 +FB74 +FB78 +FB7C +FB80 +FB90 +FB94 +FB98 +FB9C +FBA2 +FBA8 +FBAC +FBD5 +FBE6 +FBE8 +FBF8 +FBFB +FBFE +FC97 FCDE +FD2D FD33 +FD50 +FD52 FD57 +FD59 +FD5C FD5D +FD60 FD61 +FD63 +FD65 +FD68 +FD6B +FD6D +FD70 +FD72 FD73 +FD77 +FD7D +FD83 +FD86 +FD88 FD8A +FD8C FD8F +FD92 FD95 +FD98 +FD9D +FDB4 FDB5 +FDB8 +FDBA +FDC3 FDC5 +FE8B +FE91 +FE97 +FE9B +FE9F +FEA3 +FEA7 +FEB3 +FEB7 +FEBB +FEBF +FEC3 +FEC7 +FECB +FECF +FED3 +FED7 +FEDB +FEDF +FEE3 +FEE7 +FEEB +FEF3 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCisolat.pl b/Master/xemtex/perl/lib/unicore/lib/DCisolat.pl new file mode 100644 index 00000000000..d973ea495e2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCisolat.pl @@ -0,0 +1,110 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCisolated} +# +# Meaning: Compatible with 'isolated' +# +return <<'END'; +FB50 +FB52 +FB56 +FB5A +FB5E +FB62 +FB66 +FB6A +FB6E +FB72 +FB76 +FB7A +FB7E +FB82 +FB84 +FB86 +FB88 +FB8A +FB8C +FB8E +FB92 +FB96 +FB9A +FB9E +FBA0 +FBA4 +FBA6 +FBAA +FBAE +FBB0 +FBD3 +FBD7 +FBD9 +FBDB +FBDD FBDE +FBE0 +FBE2 +FBE4 +FBEA +FBEC +FBEE +FBF0 +FBF2 +FBF4 +FBF6 +FBF9 +FBFC +FC00 FC63 +FCF5 FD10 +FD3D +FDF0 FDFC +FE70 +FE72 +FE74 +FE76 +FE78 +FE7A +FE7C +FE7E +FE80 FE81 +FE83 +FE85 +FE87 +FE89 +FE8D +FE8F +FE93 +FE95 +FE99 +FE9D +FEA1 +FEA5 +FEA9 +FEAB +FEAD +FEAF +FEB1 +FEB5 +FEB9 +FEBD +FEC1 +FEC5 +FEC9 +FECD +FED1 +FED5 +FED9 +FEDD +FEE1 +FEE5 +FEE9 +FEED +FEEF +FEF1 +FEF5 +FEF7 +FEF9 +FEFB +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCmedial.pl b/Master/xemtex/perl/lib/unicore/lib/DCmedial.pl new file mode 100644 index 00000000000..8d15d90321d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCmedial.pl @@ -0,0 +1,66 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCmedial} +# +# Meaning: Compatible with 'medial' +# +return <<'END'; +FB55 +FB59 +FB5D +FB61 +FB65 +FB69 +FB6D +FB71 +FB75 +FB79 +FB7D +FB81 +FB91 +FB95 +FB99 +FB9D +FBA3 +FBA9 +FBAD +FBD6 +FBE7 +FBE9 +FBFF +FCDF FCF4 +FD34 FD3B +FE71 +FE77 +FE79 +FE7B +FE7D +FE7F +FE8C +FE92 +FE98 +FE9C +FEA0 +FEA4 +FEA8 +FEB4 +FEB8 +FEBC +FEC0 +FEC4 +FEC8 +FECC +FED0 +FED4 +FED8 +FEDC +FEE0 +FEE4 +FEE8 +FEEC +FEF4 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCnarrow.pl b/Master/xemtex/perl/lib/unicore/lib/DCnarrow.pl new file mode 100644 index 00000000000..33eca3ce359 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCnarrow.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCnarrow} +# +# Meaning: Compatible with 'narrow' +# +return <<'END'; +FF61 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +FFE8 FFEE +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCnoBrea.pl b/Master/xemtex/perl/lib/unicore/lib/DCnoBrea.pl new file mode 100644 index 00000000000..8cbaecd257a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCnoBrea.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCnoBreak} +# +# Meaning: Compatible with 'noBreak' +# +return <<'END'; +00A0 +0F0C +2007 +2011 +202F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCsmall.pl b/Master/xemtex/perl/lib/unicore/lib/DCsmall.pl new file mode 100644 index 00000000000..6606d7567fd --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCsmall.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCsmall} +# +# Meaning: Compatible with 'small' +# +return <<'END'; +FE50 FE52 +FE54 FE66 +FE68 FE6B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCsquare.pl b/Master/xemtex/perl/lib/unicore/lib/DCsquare.pl new file mode 100644 index 00000000000..28d4f64d7b6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCsquare.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCsquare} +# +# Meaning: Compatible with 'square' +# +return <<'END'; +3300 3357 +3371 3376 +337B 33DD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCsub.pl b/Master/xemtex/perl/lib/unicore/lib/DCsub.pl new file mode 100644 index 00000000000..df3daf6bb0a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCsub.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCsub} +# +# Meaning: Compatible with 'sub' +# +return <<'END'; +2080 208E +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCsuper.pl b/Master/xemtex/perl/lib/unicore/lib/DCsuper.pl new file mode 100644 index 00000000000..a11ac2dcb96 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCsuper.pl @@ -0,0 +1,22 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCsuper} +# +# Meaning: Compatible with 'super' +# +return <<'END'; +00AA +00B2 00B3 +00B9 00BA +02B0 02B8 +02E0 02E4 +2070 2071 +2074 207F +2120 +2122 +3192 319F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCvertic.pl b/Master/xemtex/perl/lib/unicore/lib/DCvertic.pl new file mode 100644 index 00000000000..d7928e562f3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCvertic.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCvertical} +# +# Meaning: Compatible with 'vertical' +# +return <<'END'; +309F +30FF +FE30 FE44 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/DCwide.pl b/Master/xemtex/perl/lib/unicore/lib/DCwide.pl new file mode 100644 index 00000000000..664c498d281 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/DCwide.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{DCwide} +# +# Meaning: Compatible with 'wide' +# +return <<'END'; +3000 +FF01 FF60 +FFE0 FFE6 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Dash.pl b/Master/xemtex/perl/lib/unicore/lib/Dash.pl new file mode 100644 index 00000000000..3d4dd59b7b0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Dash.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Dash} (and fuzzy permutations) +# +# Meaning: Extended property 'Dash' +# +return <<'END'; +002D Dash +00AD Dash +058A Dash +1806 Dash +2010 2015 Dash +207B Dash +208B Dash +2212 Dash +301C Dash +3030 Dash +FE31 FE32 Dash +FE58 Dash +FE63 Dash +FF0D Dash +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Deprecat.pl b/Master/xemtex/perl/lib/unicore/lib/Deprecat.pl new file mode 100644 index 00000000000..1866c6c2da6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Deprecat.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Deprecated} (and fuzzy permutations) +# +# Meaning: Extended property 'Deprecated' +# +return <<'END'; +0340 0341 Deprecated +206A 206F Deprecated +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Deseret.pl b/Master/xemtex/perl/lib/unicore/lib/Deseret.pl new file mode 100644 index 00000000000..20431e628f8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Deseret.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Deseret} (and fuzzy permutations) +# +# Meaning: Script 'DESERET' +# +return <<'END'; +10400 10425 DESERET +10428 1044D DESERET +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Devanaga.pl b/Master/xemtex/perl/lib/unicore/lib/Devanaga.pl new file mode 100644 index 00000000000..d35fc083127 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Devanaga.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Devanagari} (and fuzzy permutations) +# +# Meaning: Script 'DEVANAGARI' +# +return <<'END'; +0901 0903 DEVANAGARI +0905 0939 DEVANAGARI +093C 094D DEVANAGARI +0950 0954 DEVANAGARI +0958 0963 DEVANAGARI +0966 096F DEVANAGARI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Diacriti.pl b/Master/xemtex/perl/lib/unicore/lib/Diacriti.pl new file mode 100644 index 00000000000..e22111672b7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Diacriti.pl @@ -0,0 +1,89 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Diacritic} (and fuzzy permutations) +# +# Meaning: Extended property 'Diacritic' +# +return <<'END'; +005E Diacritic +0060 Diacritic +00A8 Diacritic +00AF Diacritic +00B4 Diacritic +00B7 00B8 Diacritic +02B0 02EE Diacritic +0300 034E Diacritic +0360 0362 Diacritic +0374 0375 Diacritic +037A Diacritic +0384 0385 Diacritic +0483 0486 Diacritic +0559 Diacritic +0591 05A1 Diacritic +05A3 05B9 Diacritic +05BB 05BD Diacritic +05BF Diacritic +05C1 05C2 Diacritic +05C4 Diacritic +064B 0652 Diacritic +06DF 06E0 Diacritic +06E5 06E6 Diacritic +06EA 06EC Diacritic +0730 074A Diacritic +07A6 07B0 Diacritic +093C Diacritic +094D Diacritic +0951 0954 Diacritic +09BC Diacritic +09CD Diacritic +0A3C Diacritic +0A4D Diacritic +0ABC Diacritic +0ACD Diacritic +0B3C Diacritic +0B4D Diacritic +0BCD Diacritic +0C4D Diacritic +0CCD Diacritic +0D4D Diacritic +0DCA Diacritic +0E47 0E4C Diacritic +0E4E Diacritic +0EC8 0ECC Diacritic +0F18 0F19 Diacritic +0F35 Diacritic +0F37 Diacritic +0F39 Diacritic +0F3E 0F3F Diacritic +0F82 0F84 Diacritic +0F86 0F87 Diacritic +0FC6 Diacritic +1037 Diacritic +1039 Diacritic +17C9 17D3 Diacritic +1FBD Diacritic +1FBF 1FC1 Diacritic +1FCD 1FCF Diacritic +1FDD 1FDF Diacritic +1FED 1FEF Diacritic +1FFD 1FFE Diacritic +302A 302F Diacritic +3099 309C Diacritic +30FC Diacritic +FB1E Diacritic +FE20 FE23 Diacritic +FF3E Diacritic +FF40 Diacritic +FF70 Diacritic +FF9E FF9F Diacritic +FFE3 Diacritic +1D167 1D169 Diacritic +1D16D 1D172 Diacritic +1D17B 1D182 Diacritic +1D185 1D18B Diacritic +1D1AA 1D1AD Diacritic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Digit.pl b/Master/xemtex/perl/lib/unicore/lib/Digit.pl new file mode 100644 index 00000000000..3a8c507ae73 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Digit.pl @@ -0,0 +1,33 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Digit} +# +# Meaning: [[:Digit:]] +# +return <<'END'; +0030 0039 +0660 0669 +06F0 06F9 +0966 096F +09E6 09EF +0A66 0A6F +0AE6 0AEF +0B66 0B6F +0BE7 0BEF +0C66 0C6F +0CE6 0CEF +0D66 0D6F +0E50 0E59 +0ED0 0ED9 +0F20 0F29 +1040 1049 +1369 1371 +17E0 17E9 +1810 1819 +FF10 FF19 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Ethiopic.pl b/Master/xemtex/perl/lib/unicore/lib/Ethiopic.pl new file mode 100644 index 00000000000..433d7d8e040 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Ethiopic.pl @@ -0,0 +1,38 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Ethiopic} (and fuzzy permutations) +# +# Meaning: Script 'ETHIOPIC' +# +return <<'END'; +1200 1206 ETHIOPIC +1208 1246 ETHIOPIC +1248 ETHIOPIC +124A 124D ETHIOPIC +1250 1256 ETHIOPIC +1258 ETHIOPIC +125A 125D ETHIOPIC +1260 1286 ETHIOPIC +1288 ETHIOPIC +128A 128D ETHIOPIC +1290 12AE ETHIOPIC +12B0 ETHIOPIC +12B2 12B5 ETHIOPIC +12B8 12BE ETHIOPIC +12C0 ETHIOPIC +12C2 12C5 ETHIOPIC +12C8 12CE ETHIOPIC +12D0 12D6 ETHIOPIC +12D8 12EE ETHIOPIC +12F0 130E ETHIOPIC +1310 ETHIOPIC +1312 1315 ETHIOPIC +1318 131E ETHIOPIC +1320 1346 ETHIOPIC +1348 135A ETHIOPIC +1369 137C ETHIOPIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Extender.pl b/Master/xemtex/perl/lib/unicore/lib/Extender.pl new file mode 100644 index 00000000000..dd0dab84ba9 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Extender.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Extender} (and fuzzy permutations) +# +# Meaning: Extended property 'Extender' +# +return <<'END'; +00B7 Extender +02D0 02D1 Extender +0640 Extender +0E46 Extender +0EC6 Extender +1843 Extender +3005 Extender +3031 3035 Extender +309D 309E Extender +30FC 30FE Extender +FF70 Extender +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Georgian.pl b/Master/xemtex/perl/lib/unicore/lib/Georgian.pl new file mode 100644 index 00000000000..cd56aaa56d0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Georgian.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Georgian} (and fuzzy permutations) +# +# Meaning: Script 'GEORGIAN' +# +return <<'END'; +10A0 10C5 GEORGIAN +10D0 10F8 GEORGIAN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Gothic.pl b/Master/xemtex/perl/lib/unicore/lib/Gothic.pl new file mode 100644 index 00000000000..321d7234fc6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Gothic.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Gothic} (and fuzzy permutations) +# +# Meaning: Script 'GOTHIC' +# +return <<'END'; +10330 1034A GOTHIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Graph.pl b/Master/xemtex/perl/lib/unicore/lib/Graph.pl new file mode 100644 index 00000000000..e3e98b518dc --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Graph.pl @@ -0,0 +1,398 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Graph} +# +# Meaning: [[:Graph:]] +# +return <<'END'; +0021 007E +00A1 0220 +0222 0233 +0250 02AD +02B0 02EE +0300 034F +0360 036F +0374 0375 +037A +037E +0384 038A +038C +038E 03A1 +03A3 03CE +03D0 03F6 +0400 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 055F +0561 0587 +0589 058A +0591 05A1 +05A3 05B9 +05BB 05C4 +05D0 05EA +05F0 05F4 +060C +061B +061F +0621 063A +0640 0655 +0660 06DC +06DE 06ED +06F0 06FE +0700 070D +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0970 +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09FA +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B70 +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF4 +0E01 0E3A +0E3F 0E5B +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 0F47 +0F49 0F6A +0F71 0F8B +0F90 0F97 +0F99 0FBC +0FBE 0FCC +0FCF +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1059 +10A0 10C5 +10D0 10F8 +10FB +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1361 137C +13A0 13F4 +1401 1676 +1681 169C +16A0 16F0 +1700 170C +170E 1714 +1720 1736 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17DC +17E0 17E9 +1800 180D +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FC4 +1FC6 1FD3 +1FD6 1FDB +1FDD 1FEF +1FF2 1FF4 +1FF6 1FFE +2010 2027 +2030 2052 +2057 +2070 2071 +2074 208E +20A0 20B1 +20D0 20EA +2100 213A +213D 214B +2153 2183 +2190 23CE +2400 2426 +2440 244A +2460 24FE +2500 2613 +2616 2617 +2619 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2794 +2798 27AF +27B1 27BE +27D0 27EB +27F0 2AFF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3001 303F +3041 3096 +3099 30FF +3105 312C +3131 318E +3190 31B7 +31F0 321C +3220 3243 +3251 327B +327F 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +3400 4DB5 +4E00 9FA5 +A000 A48C +A490 A4C6 +AC00 D7A3 +E000 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3F +FD50 FD8F +FD92 FDC7 +FDF0 FDFC +FE00 FE0F +FE20 FE23 +FE30 FE46 +FE49 FE52 +FE54 FE66 +FE68 FE6B +FE70 FE74 +FE76 FEFC +FF01 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +FFE0 FFE6 +FFE8 FFEE +FFFC FFFD +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D000 1D0F5 +1D100 1D126 +1D12A 1D172 +1D17B 1D1DD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +F0000 FFFFD +100000 10FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Grapheme.pl b/Master/xemtex/perl/lib/unicore/lib/Grapheme.pl new file mode 100644 index 00000000000..dc2183abb46 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Grapheme.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{GraphemeLink} (and fuzzy permutations) +# +# Meaning: Extended property 'Grapheme_Link' +# +return <<'END'; +094D Grapheme_Link +09CD Grapheme_Link +0A4D Grapheme_Link +0ACD Grapheme_Link +0B4D Grapheme_Link +0BCD Grapheme_Link +0C4D Grapheme_Link +0CCD Grapheme_Link +0D4D Grapheme_Link +0DCA Grapheme_Link +0E3A Grapheme_Link +1039 Grapheme_Link +17D2 Grapheme_Link +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Greek.pl b/Master/xemtex/perl/lib/unicore/lib/Greek.pl new file mode 100644 index 00000000000..76ad2ad6f76 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Greek.pl @@ -0,0 +1,40 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Greek} (and fuzzy permutations) +# +# Meaning: Script 'GREEK' +# +return <<'END'; +00B5 GREEK +037A GREEK +0386 GREEK +0388 038A GREEK +038C GREEK +038E 03A1 GREEK +03A3 03CE GREEK +03D0 03F5 GREEK +1F00 1F15 GREEK +1F18 1F1D GREEK +1F20 1F45 GREEK +1F48 1F4D GREEK +1F50 1F57 GREEK +1F59 GREEK +1F5B GREEK +1F5D GREEK +1F5F 1F7D GREEK +1F80 1FB4 GREEK +1FB6 1FBC GREEK +1FBE GREEK +1FC2 1FC4 GREEK +1FC6 1FCC GREEK +1FD0 1FD3 GREEK +1FD6 1FDB GREEK +1FE0 1FEC GREEK +1FF2 1FF4 GREEK +1FF6 1FFC GREEK +2126 GREEK +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Gujarati.pl b/Master/xemtex/perl/lib/unicore/lib/Gujarati.pl new file mode 100644 index 00000000000..aba2f31753b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Gujarati.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Gujarati} (and fuzzy permutations) +# +# Meaning: Script 'GUJARATI' +# +return <<'END'; +0A81 0A83 GUJARATI +0A85 0A8B GUJARATI +0A8D GUJARATI +0A8F 0A91 GUJARATI +0A93 0AA8 GUJARATI +0AAA 0AB0 GUJARATI +0AB2 0AB3 GUJARATI +0AB5 0AB9 GUJARATI +0ABC 0AC5 GUJARATI +0AC7 0AC9 GUJARATI +0ACB 0ACD GUJARATI +0AD0 GUJARATI +0AE0 GUJARATI +0AE6 0AEF GUJARATI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Gurmukhi.pl b/Master/xemtex/perl/lib/unicore/lib/Gurmukhi.pl new file mode 100644 index 00000000000..a56e9ae7218 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Gurmukhi.pl @@ -0,0 +1,27 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Gurmukhi} (and fuzzy permutations) +# +# Meaning: Script 'GURMUKHI' +# +return <<'END'; +0A02 GURMUKHI +0A05 0A0A GURMUKHI +0A0F 0A10 GURMUKHI +0A13 0A28 GURMUKHI +0A2A 0A30 GURMUKHI +0A32 0A33 GURMUKHI +0A35 0A36 GURMUKHI +0A38 0A39 GURMUKHI +0A3C GURMUKHI +0A3E 0A42 GURMUKHI +0A47 0A48 GURMUKHI +0A4B 0A4D GURMUKHI +0A59 0A5C GURMUKHI +0A5E GURMUKHI +0A66 0A74 GURMUKHI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Han.pl b/Master/xemtex/perl/lib/unicore/lib/Han.pl new file mode 100644 index 00000000000..903bbf2dfd2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Han.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Han} (and fuzzy permutations) +# +# Meaning: Script 'HAN' +# +return <<'END'; +2E80 2E99 HAN +2E9B 2EF3 HAN +2F00 2FD5 HAN +3005 HAN +3007 HAN +3021 3029 HAN +3038 303B HAN +3400 4DB5 HAN +4E00 9FA5 HAN +F900 FA2D HAN +FA30 FA6A HAN +20000 2A6D6 HAN +2F800 2FA1D HAN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Hangul.pl b/Master/xemtex/perl/lib/unicore/lib/Hangul.pl new file mode 100644 index 00000000000..afa24a06015 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Hangul.pl @@ -0,0 +1,22 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Hangul} (and fuzzy permutations) +# +# Meaning: Script 'HANGUL' +# +return <<'END'; +1100 1159 HANGUL +115F 11A2 HANGUL +11A8 11F9 HANGUL +3131 318E HANGUL +AC00 D7A3 HANGUL +FFA0 FFBE HANGUL +FFC2 FFC7 HANGUL +FFCA FFCF HANGUL +FFD2 FFD7 HANGUL +FFDA FFDC HANGUL +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Hanunoo.pl b/Master/xemtex/perl/lib/unicore/lib/Hanunoo.pl new file mode 100644 index 00000000000..077cc076c7f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Hanunoo.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Hanunoo} (and fuzzy permutations) +# +# Meaning: Script 'HANUNOO' +# +return <<'END'; +1720 1734 HANUNOO +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Hebrew.pl b/Master/xemtex/perl/lib/unicore/lib/Hebrew.pl new file mode 100644 index 00000000000..4ec1444cb6b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Hebrew.pl @@ -0,0 +1,22 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Hebrew} (and fuzzy permutations) +# +# Meaning: Script 'HEBREW' +# +return <<'END'; +05D0 05EA HEBREW +05F0 05F2 HEBREW +FB1D HEBREW +FB1F FB28 HEBREW +FB2A FB36 HEBREW +FB38 FB3C HEBREW +FB3E HEBREW +FB40 FB41 HEBREW +FB43 FB44 HEBREW +FB46 FB4F HEBREW +END diff --git a/Master/xemtex/perl/lib/unicore/lib/HexDigit.pl b/Master/xemtex/perl/lib/unicore/lib/HexDigit.pl new file mode 100644 index 00000000000..9bb0755a641 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/HexDigit.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{HexDigit} (and fuzzy permutations) +# +# Meaning: Extended property 'Hex_Digit' +# +return <<'END'; +0030 0039 Hex_Digit +0041 0046 Hex_Digit +0061 0066 Hex_Digit +FF10 FF19 Hex_Digit +FF21 FF26 Hex_Digit +FF41 FF46 Hex_Digit +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Hiragana.pl b/Master/xemtex/perl/lib/unicore/lib/Hiragana.pl new file mode 100644 index 00000000000..dddb82d74d8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Hiragana.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Hiragana} (and fuzzy permutations) +# +# Meaning: Script 'HIRAGANA' +# +return <<'END'; +3041 3096 HIRAGANA +309D 309F HIRAGANA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Hyphen.pl b/Master/xemtex/perl/lib/unicore/lib/Hyphen.pl new file mode 100644 index 00000000000..b1ca8d6c9a2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Hyphen.pl @@ -0,0 +1,21 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Hyphen} (and fuzzy permutations) +# +# Meaning: Extended property 'Hyphen' +# +return <<'END'; +002D Hyphen +00AD Hyphen +058A Hyphen +1806 Hyphen +2010 2011 Hyphen +30FB Hyphen +FE63 Hyphen +FF0D Hyphen +FF65 Hyphen +END diff --git a/Master/xemtex/perl/lib/unicore/lib/IdContin.pl b/Master/xemtex/perl/lib/unicore/lib/IdContin.pl new file mode 100644 index 00000000000..7de06495905 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/IdContin.pl @@ -0,0 +1,416 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{IdContinue} (and fuzzy permutations) +# +# Meaning: [\p{ID_Start}\p{Mn}\p{Mc}\p{Nd}\p{Pc}] +# +return <<'END'; +0030 0039 +0041 005A +005F +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +0300 034F +0360 036F +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +0483 0486 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +05D0 05EA +05F0 05F2 +0621 063A +0640 0655 +0660 0669 +066E 06D3 +06D5 06DC +06DF 06E8 +06EA 06ED +06F0 06FC +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0963 +0966 096F +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09F1 +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B6F +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BEF +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E01 0E3A +0E40 0E4E +0E50 0E59 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 +0F18 0F19 +0F20 0F29 +0F35 +0F37 +0F39 +0F3E 0F47 +0F49 0F6A +0F71 0F84 +0F86 0F8B +0F90 0F97 +0F99 0FBC +0FC6 +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1049 +1050 1059 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1369 1371 +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +16EE 16F0 +1700 170C +170E 1714 +1720 1734 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17D3 +17D7 +17DC +17E0 17E9 +180B 180D +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +203F 2040 +2071 +207F +20D0 20DC +20E1 +20E5 20EA +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2160 2183 +3005 3007 +3021 302F +3031 3035 +3038 303C +3041 3096 +3099 309A +309D 309F +30A1 30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE00 FE0F +FE20 FE23 +FE33 FE34 +FE4D FE4F +FE70 FE74 +FE76 FEFC +FF10 FF19 +FF21 FF3A +FF3F +FF41 FF5A +FF65 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 1034A +10400 10425 +10428 1044D +1D165 1D169 +1D16D 1D172 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/IdStart.pl b/Master/xemtex/perl/lib/unicore/lib/IdStart.pl new file mode 100644 index 00000000000..0772a752dd6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/IdStart.pl @@ -0,0 +1,321 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{IdStart} (and fuzzy permutations) +# +# Meaning: [\p{Ll}\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{Nl}] +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +05D0 05EA +05F0 05F2 +0621 063A +0640 064A +066E 066F +0671 06D3 +06D5 +06E5 06E6 +06FA 06FC +0710 +0712 072C +0780 07A5 +07B1 +0905 0939 +093D +0950 +0958 0961 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09DC 09DD +09DF 09E1 +09F0 09F1 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A59 0A5C +0A5E +0A72 0A74 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABD +0AD0 +0AE0 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3D +0B5C 0B5D +0B5F 0B61 +0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C60 0C61 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CDE +0CE0 0CE1 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D60 0D61 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0E01 0E30 +0E32 0E33 +0E40 0E46 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB0 +0EB2 0EB3 +0EBD +0EC0 0EC4 +0EC6 +0EDC 0EDD +0F00 +0F40 0F47 +0F49 0F6A +0F88 0F8B +1000 1021 +1023 1027 +1029 102A +1050 1055 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +16EE 16F0 +1700 170C +170E 1711 +1720 1731 +1740 1751 +1760 176C +176E 1770 +1780 17B3 +17D7 +17DC +1820 1877 +1880 18A8 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2071 +207F +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2160 2183 +3005 3007 +3021 3029 +3031 3035 +3038 303C +3041 3096 +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D +FB1F FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE70 FE74 +FE76 FEFC +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 1034A +10400 10425 +10428 1044D +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Ideograp.pl b/Master/xemtex/perl/lib/unicore/lib/Ideograp.pl new file mode 100644 index 00000000000..476d5cd700e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Ideograp.pl @@ -0,0 +1,20 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Ideographic} (and fuzzy permutations) +# +# Meaning: Extended property 'Ideographic' +# +return <<'END'; +3006 3007 Ideographic +3021 3029 Ideographic +3038 303A Ideographic +3400 4DB5 Ideographic +4E00 9FA5 Ideographic +F900 FA2D Ideographic +20000 2A6D6 Ideographic +2F800 2FA1D Ideographic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/IdsBinar.pl b/Master/xemtex/perl/lib/unicore/lib/IdsBinar.pl new file mode 100644 index 00000000000..d138d0a8d8c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/IdsBinar.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{IdsBinaryOperator} (and fuzzy permutations) +# +# Meaning: Extended property 'IDS_Binary_Operator' +# +return <<'END'; +2FF0 2FF1 IDS_Binary_Operator +2FF4 2FFB IDS_Binary_Operator +END diff --git a/Master/xemtex/perl/lib/unicore/lib/IdsTrina.pl b/Master/xemtex/perl/lib/unicore/lib/IdsTrina.pl new file mode 100644 index 00000000000..587606bad40 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/IdsTrina.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{IdsTrinaryOperator} (and fuzzy permutations) +# +# Meaning: Extended property 'IDS_Trinary_Operator' +# +return <<'END'; +2FF2 2FF3 IDS_Trinary_Operator +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InAlphab.pl b/Master/xemtex/perl/lib/unicore/lib/InAlphab.pl new file mode 100644 index 00000000000..2ecd85da4bb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InAlphab.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InAlphabeticPresentationForms} (and fuzzy permutations) +# +# Meaning: Block 'Alphabetic Presentation Forms' +# +return <<'END'; +FB00 FB4F Alphabetic Presentation Forms +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InArabi2.pl b/Master/xemtex/perl/lib/unicore/lib/InArabi2.pl new file mode 100644 index 00000000000..77e704b3dfe --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InArabi2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InArabicPresentationFormsB} (and fuzzy permutations) +# +# Meaning: Block 'Arabic Presentation Forms-B' +# +return <<'END'; +FE70 FEFF Arabic Presentation Forms-B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InArabi3.pl b/Master/xemtex/perl/lib/unicore/lib/InArabi3.pl new file mode 100644 index 00000000000..8ab3bb04a74 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InArabi3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InArabicPresentationFormsA} (and fuzzy permutations) +# +# Meaning: Block 'Arabic Presentation Forms-A' +# +return <<'END'; +FB50 FDFF Arabic Presentation Forms-A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InArabic.pl b/Master/xemtex/perl/lib/unicore/lib/InArabic.pl new file mode 100644 index 00000000000..ac250e86259 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InArabic.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InArabic} (and fuzzy permutations) +# +# Meaning: Block 'Arabic' +# +return <<'END'; +0600 06FF Arabic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InArmeni.pl b/Master/xemtex/perl/lib/unicore/lib/InArmeni.pl new file mode 100644 index 00000000000..62a07777423 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InArmeni.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InArmenian} (and fuzzy permutations) +# +# Meaning: Block 'Armenian' +# +return <<'END'; +0530 058F Armenian +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InArrows.pl b/Master/xemtex/perl/lib/unicore/lib/InArrows.pl new file mode 100644 index 00000000000..15f4c0bacef --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InArrows.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InArrows} (and fuzzy permutations) +# +# Meaning: Block 'Arrows' +# +return <<'END'; +2190 21FF Arrows +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBasicL.pl b/Master/xemtex/perl/lib/unicore/lib/InBasicL.pl new file mode 100644 index 00000000000..b15a479ffe2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBasicL.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBasicLatin} (and fuzzy permutations) +# +# Meaning: Block 'Basic Latin' +# +return <<'END'; +0000 007F Basic Latin +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBengal.pl b/Master/xemtex/perl/lib/unicore/lib/InBengal.pl new file mode 100644 index 00000000000..c20bf6cda0a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBengal.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBengali} (and fuzzy permutations) +# +# Meaning: Block 'Bengali' +# +return <<'END'; +0980 09FF Bengali +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBlockE.pl b/Master/xemtex/perl/lib/unicore/lib/InBlockE.pl new file mode 100644 index 00000000000..b301e9d358a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBlockE.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBlockElements} (and fuzzy permutations) +# +# Meaning: Block 'Block Elements' +# +return <<'END'; +2580 259F Block Elements +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBopom2.pl b/Master/xemtex/perl/lib/unicore/lib/InBopom2.pl new file mode 100644 index 00000000000..8320eb520d3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBopom2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBopomofoExtended} (and fuzzy permutations) +# +# Meaning: Block 'Bopomofo Extended' +# +return <<'END'; +31A0 31BF Bopomofo Extended +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBopomo.pl b/Master/xemtex/perl/lib/unicore/lib/InBopomo.pl new file mode 100644 index 00000000000..43edd7cc649 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBopomo.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBopomofo} (and fuzzy permutations) +# +# Meaning: Block 'Bopomofo' +# +return <<'END'; +3100 312F Bopomofo +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBoxDra.pl b/Master/xemtex/perl/lib/unicore/lib/InBoxDra.pl new file mode 100644 index 00000000000..4f3698f06bf --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBoxDra.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBoxDrawing} (and fuzzy permutations) +# +# Meaning: Block 'Box Drawing' +# +return <<'END'; +2500 257F Box Drawing +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBraill.pl b/Master/xemtex/perl/lib/unicore/lib/InBraill.pl new file mode 100644 index 00000000000..b03465e91be --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBraill.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBraillePatterns} (and fuzzy permutations) +# +# Meaning: Block 'Braille Patterns' +# +return <<'END'; +2800 28FF Braille Patterns +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InBuhid.pl b/Master/xemtex/perl/lib/unicore/lib/InBuhid.pl new file mode 100644 index 00000000000..f58c9c2df10 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InBuhid.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InBuhid} (and fuzzy permutations) +# +# Meaning: Block 'Buhid' +# +return <<'END'; +1740 175F Buhid +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InByzant.pl b/Master/xemtex/perl/lib/unicore/lib/InByzant.pl new file mode 100644 index 00000000000..a706086ceb1 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InByzant.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InByzantineMusicalSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Byzantine Musical Symbols' +# +return <<'END'; +1D000 1D0FF Byzantine Musical Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCherok.pl b/Master/xemtex/perl/lib/unicore/lib/InCherok.pl new file mode 100644 index 00000000000..089e3f684d6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCherok.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCherokee} (and fuzzy permutations) +# +# Meaning: Block 'Cherokee' +# +return <<'END'; +13A0 13FF Cherokee +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkCo2.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkCo2.pl new file mode 100644 index 00000000000..bf9af659c86 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkCo2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkCompatibilityForms} (and fuzzy permutations) +# +# Meaning: Block 'CJK Compatibility Forms' +# +return <<'END'; +FE30 FE4F CJK Compatibility Forms +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkCo3.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkCo3.pl new file mode 100644 index 00000000000..678c493885e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkCo3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkCompatibilityIdeographs} (and fuzzy permutations) +# +# Meaning: Block 'CJK Compatibility Ideographs' +# +return <<'END'; +F900 FAFF CJK Compatibility Ideographs +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkCo4.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkCo4.pl new file mode 100644 index 00000000000..05bde2e48d5 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkCo4.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkCompatibilityIdeographsSupplement} (and fuzzy permutations) +# +# Meaning: Block 'CJK Compatibility Ideographs Supplement' +# +return <<'END'; +2F800 2FA1F CJK Compatibility Ideographs Supplement +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkCom.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkCom.pl new file mode 100644 index 00000000000..76f7396a299 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkCom.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkCompatibility} (and fuzzy permutations) +# +# Meaning: Block 'CJK Compatibility' +# +return <<'END'; +3300 33FF CJK Compatibility +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkRad.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkRad.pl new file mode 100644 index 00000000000..46e7463cbff --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkRad.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkRadicalsSupplement} (and fuzzy permutations) +# +# Meaning: Block 'CJK Radicals Supplement' +# +return <<'END'; +2E80 2EFF CJK Radicals Supplement +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkSym.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkSym.pl new file mode 100644 index 00000000000..293608f8fbf --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkSym.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkSymbolsAndPunctuation} (and fuzzy permutations) +# +# Meaning: Block 'CJK Symbols and Punctuation' +# +return <<'END'; +3000 303F CJK Symbols and Punctuation +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkUn2.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkUn2.pl new file mode 100644 index 00000000000..2f8ce719449 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkUn2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkUnifiedIdeographsExtensionB} (and fuzzy permutations) +# +# Meaning: Block 'CJK Unified Ideographs Extension B' +# +return <<'END'; +20000 2A6DF CJK Unified Ideographs Extension B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkUn3.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkUn3.pl new file mode 100644 index 00000000000..3967c210621 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkUn3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkUnifiedIdeographsExtensionA} (and fuzzy permutations) +# +# Meaning: Block 'CJK Unified Ideographs Extension A' +# +return <<'END'; +3400 4DBF CJK Unified Ideographs Extension A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCjkUni.pl b/Master/xemtex/perl/lib/unicore/lib/InCjkUni.pl new file mode 100644 index 00000000000..62c36bf37cc --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCjkUni.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCjkUnifiedIdeographs} (and fuzzy permutations) +# +# Meaning: Block 'CJK Unified Ideographs' +# +return <<'END'; +4E00 9FFF CJK Unified Ideographs +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCombi2.pl b/Master/xemtex/perl/lib/unicore/lib/InCombi2.pl new file mode 100644 index 00000000000..f4169cfe7fc --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCombi2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCombiningDiacriticalMarks} (and fuzzy permutations) +# +# Meaning: Block 'Combining Diacritical Marks' +# +return <<'END'; +0300 036F Combining Diacritical Marks +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCombi3.pl b/Master/xemtex/perl/lib/unicore/lib/InCombi3.pl new file mode 100644 index 00000000000..7dde2138522 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCombi3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCombiningDiacriticalMarksForSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Combining Diacritical Marks for Symbols' +# +return <<'END'; +20D0 20FF Combining Diacritical Marks for Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCombin.pl b/Master/xemtex/perl/lib/unicore/lib/InCombin.pl new file mode 100644 index 00000000000..5e2670da706 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCombin.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCombiningHalfMarks} (and fuzzy permutations) +# +# Meaning: Block 'Combining Half Marks' +# +return <<'END'; +FE20 FE2F Combining Half Marks +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InContro.pl b/Master/xemtex/perl/lib/unicore/lib/InContro.pl new file mode 100644 index 00000000000..5460b22a1ee --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InContro.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InControlPictures} (and fuzzy permutations) +# +# Meaning: Block 'Control Pictures' +# +return <<'END'; +2400 243F Control Pictures +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCurren.pl b/Master/xemtex/perl/lib/unicore/lib/InCurren.pl new file mode 100644 index 00000000000..44182705cd9 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCurren.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCurrencySymbols} (and fuzzy permutations) +# +# Meaning: Block 'Currency Symbols' +# +return <<'END'; +20A0 20CF Currency Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCyril2.pl b/Master/xemtex/perl/lib/unicore/lib/InCyril2.pl new file mode 100644 index 00000000000..41f8f20712d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCyril2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCyrillicSupplementary} (and fuzzy permutations) +# +# Meaning: Block 'Cyrillic Supplementary' +# +return <<'END'; +0500 052F Cyrillic Supplementary +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InCyrill.pl b/Master/xemtex/perl/lib/unicore/lib/InCyrill.pl new file mode 100644 index 00000000000..9d6f53a96eb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InCyrill.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InCyrillic} (and fuzzy permutations) +# +# Meaning: Block 'Cyrillic' +# +return <<'END'; +0400 04FF Cyrillic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InDesere.pl b/Master/xemtex/perl/lib/unicore/lib/InDesere.pl new file mode 100644 index 00000000000..5e8b99f164f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InDesere.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InDeseret} (and fuzzy permutations) +# +# Meaning: Block 'Deseret' +# +return <<'END'; +10400 1044F Deseret +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InDevana.pl b/Master/xemtex/perl/lib/unicore/lib/InDevana.pl new file mode 100644 index 00000000000..eaaa7126905 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InDevana.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InDevanagari} (and fuzzy permutations) +# +# Meaning: Block 'Devanagari' +# +return <<'END'; +0900 097F Devanagari +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InDingba.pl b/Master/xemtex/perl/lib/unicore/lib/InDingba.pl new file mode 100644 index 00000000000..72eef3587a7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InDingba.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InDingbats} (and fuzzy permutations) +# +# Meaning: Block 'Dingbats' +# +return <<'END'; +2700 27BF Dingbats +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InEnclo2.pl b/Master/xemtex/perl/lib/unicore/lib/InEnclo2.pl new file mode 100644 index 00000000000..aadcbdb7d32 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InEnclo2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InEnclosedCjkLettersAndMonths} (and fuzzy permutations) +# +# Meaning: Block 'Enclosed CJK Letters and Months' +# +return <<'END'; +3200 32FF Enclosed CJK Letters and Months +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InEnclos.pl b/Master/xemtex/perl/lib/unicore/lib/InEnclos.pl new file mode 100644 index 00000000000..82c20de16f8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InEnclos.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InEnclosedAlphanumerics} (and fuzzy permutations) +# +# Meaning: Block 'Enclosed Alphanumerics' +# +return <<'END'; +2460 24FF Enclosed Alphanumerics +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InEthiop.pl b/Master/xemtex/perl/lib/unicore/lib/InEthiop.pl new file mode 100644 index 00000000000..fcb2053e44f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InEthiop.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InEthiopic} (and fuzzy permutations) +# +# Meaning: Block 'Ethiopic' +# +return <<'END'; +1200 137F Ethiopic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGenera.pl b/Master/xemtex/perl/lib/unicore/lib/InGenera.pl new file mode 100644 index 00000000000..2fd27a7b771 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGenera.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGeneralPunctuation} (and fuzzy permutations) +# +# Meaning: Block 'General Punctuation' +# +return <<'END'; +2000 206F General Punctuation +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGeomet.pl b/Master/xemtex/perl/lib/unicore/lib/InGeomet.pl new file mode 100644 index 00000000000..817dabc2b22 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGeomet.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGeometricShapes} (and fuzzy permutations) +# +# Meaning: Block 'Geometric Shapes' +# +return <<'END'; +25A0 25FF Geometric Shapes +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGeorgi.pl b/Master/xemtex/perl/lib/unicore/lib/InGeorgi.pl new file mode 100644 index 00000000000..7e965445909 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGeorgi.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGeorgian} (and fuzzy permutations) +# +# Meaning: Block 'Georgian' +# +return <<'END'; +10A0 10FF Georgian +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGothic.pl b/Master/xemtex/perl/lib/unicore/lib/InGothic.pl new file mode 100644 index 00000000000..552cba4f000 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGothic.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGothic} (and fuzzy permutations) +# +# Meaning: Block 'Gothic' +# +return <<'END'; +10330 1034F Gothic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGreek.pl b/Master/xemtex/perl/lib/unicore/lib/InGreek.pl new file mode 100644 index 00000000000..e932705c4ed --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGreek.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGreek} (and fuzzy permutations) +# +# Meaning: Block 'Greek' +# +return <<'END'; +0370 03FF Greek +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGreekA.pl b/Master/xemtex/perl/lib/unicore/lib/InGreekA.pl new file mode 100644 index 00000000000..d09fd3daf2e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGreekA.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGreekAndCoptic} (and fuzzy permutations) +# +# Meaning: Block 'Greek and Coptic' +# +return <<'END'; +0370 03FF Greek and Coptic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGreekE.pl b/Master/xemtex/perl/lib/unicore/lib/InGreekE.pl new file mode 100644 index 00000000000..06965f969d0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGreekE.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGreekExtended} (and fuzzy permutations) +# +# Meaning: Block 'Greek Extended' +# +return <<'END'; +1F00 1FFF Greek Extended +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGujara.pl b/Master/xemtex/perl/lib/unicore/lib/InGujara.pl new file mode 100644 index 00000000000..f0a8e4a6a29 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGujara.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGujarati} (and fuzzy permutations) +# +# Meaning: Block 'Gujarati' +# +return <<'END'; +0A80 0AFF Gujarati +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InGurmuk.pl b/Master/xemtex/perl/lib/unicore/lib/InGurmuk.pl new file mode 100644 index 00000000000..7023d05cfb7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InGurmuk.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InGurmukhi} (and fuzzy permutations) +# +# Meaning: Block 'Gurmukhi' +# +return <<'END'; +0A00 0A7F Gurmukhi +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHalfwi.pl b/Master/xemtex/perl/lib/unicore/lib/InHalfwi.pl new file mode 100644 index 00000000000..d543110b84f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHalfwi.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHalfwidthAndFullwidthForms} (and fuzzy permutations) +# +# Meaning: Block 'Halfwidth and Fullwidth Forms' +# +return <<'END'; +FF00 FFEF Halfwidth and Fullwidth Forms +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHangu2.pl b/Master/xemtex/perl/lib/unicore/lib/InHangu2.pl new file mode 100644 index 00000000000..e09ff114a18 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHangu2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHangulSyllables} (and fuzzy permutations) +# +# Meaning: Block 'Hangul Syllables' +# +return <<'END'; +AC00 D7AF Hangul Syllables +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHangu3.pl b/Master/xemtex/perl/lib/unicore/lib/InHangu3.pl new file mode 100644 index 00000000000..e256ea5dc95 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHangu3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHangulCompatibilityJamo} (and fuzzy permutations) +# +# Meaning: Block 'Hangul Compatibility Jamo' +# +return <<'END'; +3130 318F Hangul Compatibility Jamo +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHangul.pl b/Master/xemtex/perl/lib/unicore/lib/InHangul.pl new file mode 100644 index 00000000000..d0ef32e871d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHangul.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHangulJamo} (and fuzzy permutations) +# +# Meaning: Block 'Hangul Jamo' +# +return <<'END'; +1100 11FF Hangul Jamo +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHanuno.pl b/Master/xemtex/perl/lib/unicore/lib/InHanuno.pl new file mode 100644 index 00000000000..5ea90288d75 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHanuno.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHanunoo} (and fuzzy permutations) +# +# Meaning: Block 'Hanunoo' +# +return <<'END'; +1720 173F Hanunoo +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHebrew.pl b/Master/xemtex/perl/lib/unicore/lib/InHebrew.pl new file mode 100644 index 00000000000..14459f46876 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHebrew.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHebrew} (and fuzzy permutations) +# +# Meaning: Block 'Hebrew' +# +return <<'END'; +0590 05FF Hebrew +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHighPr.pl b/Master/xemtex/perl/lib/unicore/lib/InHighPr.pl new file mode 100644 index 00000000000..fd92248fa5f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHighPr.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHighPrivateUseSurrogates} (and fuzzy permutations) +# +# Meaning: Block 'High Private Use Surrogates' +# +return <<'END'; +DB80 DBFF High Private Use Surrogates +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHighSu.pl b/Master/xemtex/perl/lib/unicore/lib/InHighSu.pl new file mode 100644 index 00000000000..eec73b3cb35 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHighSu.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHighSurrogates} (and fuzzy permutations) +# +# Meaning: Block 'High Surrogates' +# +return <<'END'; +D800 DB7F High Surrogates +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InHiraga.pl b/Master/xemtex/perl/lib/unicore/lib/InHiraga.pl new file mode 100644 index 00000000000..2db67da347f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InHiraga.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InHiragana} (and fuzzy permutations) +# +# Meaning: Block 'Hiragana' +# +return <<'END'; +3040 309F Hiragana +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InIdeogr.pl b/Master/xemtex/perl/lib/unicore/lib/InIdeogr.pl new file mode 100644 index 00000000000..95f6229928e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InIdeogr.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InIdeographicDescriptionCharacters} (and fuzzy permutations) +# +# Meaning: Block 'Ideographic Description Characters' +# +return <<'END'; +2FF0 2FFF Ideographic Description Characters +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InIpaExt.pl b/Master/xemtex/perl/lib/unicore/lib/InIpaExt.pl new file mode 100644 index 00000000000..3280cb6ccf8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InIpaExt.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InIpaExtensions} (and fuzzy permutations) +# +# Meaning: Block 'IPA Extensions' +# +return <<'END'; +0250 02AF IPA Extensions +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKanbun.pl b/Master/xemtex/perl/lib/unicore/lib/InKanbun.pl new file mode 100644 index 00000000000..5dddfb381f9 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKanbun.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKanbun} (and fuzzy permutations) +# +# Meaning: Block 'Kanbun' +# +return <<'END'; +3190 319F Kanbun +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKangxi.pl b/Master/xemtex/perl/lib/unicore/lib/InKangxi.pl new file mode 100644 index 00000000000..49f334c2284 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKangxi.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKangxiRadicals} (and fuzzy permutations) +# +# Meaning: Block 'Kangxi Radicals' +# +return <<'END'; +2F00 2FDF Kangxi Radicals +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKannad.pl b/Master/xemtex/perl/lib/unicore/lib/InKannad.pl new file mode 100644 index 00000000000..418011cb128 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKannad.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKannada} (and fuzzy permutations) +# +# Meaning: Block 'Kannada' +# +return <<'END'; +0C80 0CFF Kannada +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKatak2.pl b/Master/xemtex/perl/lib/unicore/lib/InKatak2.pl new file mode 100644 index 00000000000..6ed8a84b8eb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKatak2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKatakanaPhoneticExtensions} (and fuzzy permutations) +# +# Meaning: Block 'Katakana Phonetic Extensions' +# +return <<'END'; +31F0 31FF Katakana Phonetic Extensions +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKataka.pl b/Master/xemtex/perl/lib/unicore/lib/InKataka.pl new file mode 100644 index 00000000000..5ef3ce010f8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKataka.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKatakana} (and fuzzy permutations) +# +# Meaning: Block 'Katakana' +# +return <<'END'; +30A0 30FF Katakana +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InKhmer.pl b/Master/xemtex/perl/lib/unicore/lib/InKhmer.pl new file mode 100644 index 00000000000..8c2efea0429 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InKhmer.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InKhmer} (and fuzzy permutations) +# +# Meaning: Block 'Khmer' +# +return <<'END'; +1780 17FF Khmer +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLao.pl b/Master/xemtex/perl/lib/unicore/lib/InLao.pl new file mode 100644 index 00000000000..eb96edca009 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLao.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLao} (and fuzzy permutations) +# +# Meaning: Block 'Lao' +# +return <<'END'; +0E80 0EFF Lao +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLatin1.pl b/Master/xemtex/perl/lib/unicore/lib/InLatin1.pl new file mode 100644 index 00000000000..52e4c71db85 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLatin1.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLatin1Supplement} (and fuzzy permutations) +# +# Meaning: Block 'Latin-1 Supplement' +# +return <<'END'; +0080 00FF Latin-1 Supplement +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLatin2.pl b/Master/xemtex/perl/lib/unicore/lib/InLatin2.pl new file mode 100644 index 00000000000..a5f0d22f95c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLatin2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLatinExtendedA} (and fuzzy permutations) +# +# Meaning: Block 'Latin Extended-A' +# +return <<'END'; +0100 017F Latin Extended-A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLatin3.pl b/Master/xemtex/perl/lib/unicore/lib/InLatin3.pl new file mode 100644 index 00000000000..8a53dc7f5f1 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLatin3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLatinExtendedAdditional} (and fuzzy permutations) +# +# Meaning: Block 'Latin Extended Additional' +# +return <<'END'; +1E00 1EFF Latin Extended Additional +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLatinE.pl b/Master/xemtex/perl/lib/unicore/lib/InLatinE.pl new file mode 100644 index 00000000000..3a81b6e3382 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLatinE.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLatinExtendedB} (and fuzzy permutations) +# +# Meaning: Block 'Latin Extended-B' +# +return <<'END'; +0180 024F Latin Extended-B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLetter.pl b/Master/xemtex/perl/lib/unicore/lib/InLetter.pl new file mode 100644 index 00000000000..d452812a3c5 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLetter.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLetterlikeSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Letterlike Symbols' +# +return <<'END'; +2100 214F Letterlike Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InLowSur.pl b/Master/xemtex/perl/lib/unicore/lib/InLowSur.pl new file mode 100644 index 00000000000..5be81e511e0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InLowSur.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InLowSurrogates} (and fuzzy permutations) +# +# Meaning: Block 'Low Surrogates' +# +return <<'END'; +DC00 DFFF Low Surrogates +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMalaya.pl b/Master/xemtex/perl/lib/unicore/lib/InMalaya.pl new file mode 100644 index 00000000000..ee91b9a2ead --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMalaya.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMalayalam} (and fuzzy permutations) +# +# Meaning: Block 'Malayalam' +# +return <<'END'; +0D00 0D7F Malayalam +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMathe2.pl b/Master/xemtex/perl/lib/unicore/lib/InMathe2.pl new file mode 100644 index 00000000000..aba54a670fd --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMathe2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMathematicalAlphanumericSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Mathematical Alphanumeric Symbols' +# +return <<'END'; +1D400 1D7FF Mathematical Alphanumeric Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMathem.pl b/Master/xemtex/perl/lib/unicore/lib/InMathem.pl new file mode 100644 index 00000000000..d037fec9547 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMathem.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMathematicalOperators} (and fuzzy permutations) +# +# Meaning: Block 'Mathematical Operators' +# +return <<'END'; +2200 22FF Mathematical Operators +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMisce2.pl b/Master/xemtex/perl/lib/unicore/lib/InMisce2.pl new file mode 100644 index 00000000000..fb9217a2bfd --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMisce2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMiscellaneousTechnical} (and fuzzy permutations) +# +# Meaning: Block 'Miscellaneous Technical' +# +return <<'END'; +2300 23FF Miscellaneous Technical +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMisce3.pl b/Master/xemtex/perl/lib/unicore/lib/InMisce3.pl new file mode 100644 index 00000000000..a273df5c133 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMisce3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMiscellaneousMathematicalSymbolsA} (and fuzzy permutations) +# +# Meaning: Block 'Miscellaneous Mathematical Symbols-A' +# +return <<'END'; +27C0 27EF Miscellaneous Mathematical Symbols-A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMisce4.pl b/Master/xemtex/perl/lib/unicore/lib/InMisce4.pl new file mode 100644 index 00000000000..1c8e240fca7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMisce4.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMiscellaneousMathematicalSymbolsB} (and fuzzy permutations) +# +# Meaning: Block 'Miscellaneous Mathematical Symbols-B' +# +return <<'END'; +2980 29FF Miscellaneous Mathematical Symbols-B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMiscel.pl b/Master/xemtex/perl/lib/unicore/lib/InMiscel.pl new file mode 100644 index 00000000000..f1668ea83c4 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMiscel.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMiscellaneousSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Miscellaneous Symbols' +# +return <<'END'; +2600 26FF Miscellaneous Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMongol.pl b/Master/xemtex/perl/lib/unicore/lib/InMongol.pl new file mode 100644 index 00000000000..e1771ec83c7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMongol.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMongolian} (and fuzzy permutations) +# +# Meaning: Block 'Mongolian' +# +return <<'END'; +1800 18AF Mongolian +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMusica.pl b/Master/xemtex/perl/lib/unicore/lib/InMusica.pl new file mode 100644 index 00000000000..74419bc98c8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMusica.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMusicalSymbols} (and fuzzy permutations) +# +# Meaning: Block 'Musical Symbols' +# +return <<'END'; +1D100 1D1FF Musical Symbols +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InMyanma.pl b/Master/xemtex/perl/lib/unicore/lib/InMyanma.pl new file mode 100644 index 00000000000..e00a9f29422 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InMyanma.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InMyanmar} (and fuzzy permutations) +# +# Meaning: Block 'Myanmar' +# +return <<'END'; +1000 109F Myanmar +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InNumber.pl b/Master/xemtex/perl/lib/unicore/lib/InNumber.pl new file mode 100644 index 00000000000..e1f219e98fa --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InNumber.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InNumberForms} (and fuzzy permutations) +# +# Meaning: Block 'Number Forms' +# +return <<'END'; +2150 218F Number Forms +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InOgham.pl b/Master/xemtex/perl/lib/unicore/lib/InOgham.pl new file mode 100644 index 00000000000..6336e02a379 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InOgham.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InOgham} (and fuzzy permutations) +# +# Meaning: Block 'Ogham' +# +return <<'END'; +1680 169F Ogham +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InOldIta.pl b/Master/xemtex/perl/lib/unicore/lib/InOldIta.pl new file mode 100644 index 00000000000..71b2acce1b6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InOldIta.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InOldItalic} (and fuzzy permutations) +# +# Meaning: Block 'Old Italic' +# +return <<'END'; +10300 1032F Old Italic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InOptica.pl b/Master/xemtex/perl/lib/unicore/lib/InOptica.pl new file mode 100644 index 00000000000..bc3f3eefe53 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InOptica.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InOpticalCharacterRecognition} (and fuzzy permutations) +# +# Meaning: Block 'Optical Character Recognition' +# +return <<'END'; +2440 245F Optical Character Recognition +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InOriya.pl b/Master/xemtex/perl/lib/unicore/lib/InOriya.pl new file mode 100644 index 00000000000..a8bc8aaa3f0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InOriya.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InOriya} (and fuzzy permutations) +# +# Meaning: Block 'Oriya' +# +return <<'END'; +0B00 0B7F Oriya +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InPrivat.pl b/Master/xemtex/perl/lib/unicore/lib/InPrivat.pl new file mode 100644 index 00000000000..a2b0d6bd4b7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InPrivat.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InPrivateUseArea} (and fuzzy permutations) +# +# Meaning: Block 'Private Use Area' +# +return <<'END'; +E000 F8FF Private Use Area +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InRunic.pl b/Master/xemtex/perl/lib/unicore/lib/InRunic.pl new file mode 100644 index 00000000000..b99e1fa44de --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InRunic.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InRunic} (and fuzzy permutations) +# +# Meaning: Block 'Runic' +# +return <<'END'; +16A0 16FF Runic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSinhal.pl b/Master/xemtex/perl/lib/unicore/lib/InSinhal.pl new file mode 100644 index 00000000000..b08f3885193 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSinhal.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSinhala} (and fuzzy permutations) +# +# Meaning: Block 'Sinhala' +# +return <<'END'; +0D80 0DFF Sinhala +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSmallF.pl b/Master/xemtex/perl/lib/unicore/lib/InSmallF.pl new file mode 100644 index 00000000000..7938a44c8db --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSmallF.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSmallFormVariants} (and fuzzy permutations) +# +# Meaning: Block 'Small Form Variants' +# +return <<'END'; +FE50 FE6F Small Form Variants +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSpacin.pl b/Master/xemtex/perl/lib/unicore/lib/InSpacin.pl new file mode 100644 index 00000000000..9a382598f4a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSpacin.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSpacingModifierLetters} (and fuzzy permutations) +# +# Meaning: Block 'Spacing Modifier Letters' +# +return <<'END'; +02B0 02FF Spacing Modifier Letters +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSpecia.pl b/Master/xemtex/perl/lib/unicore/lib/InSpecia.pl new file mode 100644 index 00000000000..7d7651a6e70 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSpecia.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSpecials} (and fuzzy permutations) +# +# Meaning: Block 'Specials' +# +return <<'END'; +FFF0 FFFF Specials +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSupers.pl b/Master/xemtex/perl/lib/unicore/lib/InSupers.pl new file mode 100644 index 00000000000..493f8170584 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSupers.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSuperscriptsAndSubscripts} (and fuzzy permutations) +# +# Meaning: Block 'Superscripts and Subscripts' +# +return <<'END'; +2070 209F Superscripts and Subscripts +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSuppl2.pl b/Master/xemtex/perl/lib/unicore/lib/InSuppl2.pl new file mode 100644 index 00000000000..6e9fb082d96 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSuppl2.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSupplementalArrowsA} (and fuzzy permutations) +# +# Meaning: Block 'Supplemental Arrows-A' +# +return <<'END'; +27F0 27FF Supplemental Arrows-A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSuppl3.pl b/Master/xemtex/perl/lib/unicore/lib/InSuppl3.pl new file mode 100644 index 00000000000..e4dc4791f9f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSuppl3.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSupplementaryPrivateUseAreaA} (and fuzzy permutations) +# +# Meaning: Block 'Supplementary Private Use Area-A' +# +return <<'END'; +F0000 FFFFF Supplementary Private Use Area-A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSuppl4.pl b/Master/xemtex/perl/lib/unicore/lib/InSuppl4.pl new file mode 100644 index 00000000000..5a080021c18 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSuppl4.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSupplementaryPrivateUseAreaB} (and fuzzy permutations) +# +# Meaning: Block 'Supplementary Private Use Area-B' +# +return <<'END'; +100000 10FFFF Supplementary Private Use Area-B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSuppl5.pl b/Master/xemtex/perl/lib/unicore/lib/InSuppl5.pl new file mode 100644 index 00000000000..89c08807612 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSuppl5.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSupplementalMathematicalOperators} (and fuzzy permutations) +# +# Meaning: Block 'Supplemental Mathematical Operators' +# +return <<'END'; +2A00 2AFF Supplemental Mathematical Operators +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSupple.pl b/Master/xemtex/perl/lib/unicore/lib/InSupple.pl new file mode 100644 index 00000000000..3fe71f2bd05 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSupple.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSupplementalArrowsB} (and fuzzy permutations) +# +# Meaning: Block 'Supplemental Arrows-B' +# +return <<'END'; +2900 297F Supplemental Arrows-B +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InSyriac.pl b/Master/xemtex/perl/lib/unicore/lib/InSyriac.pl new file mode 100644 index 00000000000..74f197037bd --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InSyriac.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InSyriac} (and fuzzy permutations) +# +# Meaning: Block 'Syriac' +# +return <<'END'; +0700 074F Syriac +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTagalo.pl b/Master/xemtex/perl/lib/unicore/lib/InTagalo.pl new file mode 100644 index 00000000000..55c8ca466b2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTagalo.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTagalog} (and fuzzy permutations) +# +# Meaning: Block 'Tagalog' +# +return <<'END'; +1700 171F Tagalog +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTagban.pl b/Master/xemtex/perl/lib/unicore/lib/InTagban.pl new file mode 100644 index 00000000000..9863a2e3c3f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTagban.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTagbanwa} (and fuzzy permutations) +# +# Meaning: Block 'Tagbanwa' +# +return <<'END'; +1760 177F Tagbanwa +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTags.pl b/Master/xemtex/perl/lib/unicore/lib/InTags.pl new file mode 100644 index 00000000000..4a6600e29c3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTags.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTags} (and fuzzy permutations) +# +# Meaning: Block 'Tags' +# +return <<'END'; +E0000 E007F Tags +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTamil.pl b/Master/xemtex/perl/lib/unicore/lib/InTamil.pl new file mode 100644 index 00000000000..20036caa54d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTamil.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTamil} (and fuzzy permutations) +# +# Meaning: Block 'Tamil' +# +return <<'END'; +0B80 0BFF Tamil +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTelugu.pl b/Master/xemtex/perl/lib/unicore/lib/InTelugu.pl new file mode 100644 index 00000000000..1027f933339 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTelugu.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTelugu} (and fuzzy permutations) +# +# Meaning: Block 'Telugu' +# +return <<'END'; +0C00 0C7F Telugu +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InThaana.pl b/Master/xemtex/perl/lib/unicore/lib/InThaana.pl new file mode 100644 index 00000000000..740d71bd28e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InThaana.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InThaana} (and fuzzy permutations) +# +# Meaning: Block 'Thaana' +# +return <<'END'; +0780 07BF Thaana +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InThai.pl b/Master/xemtex/perl/lib/unicore/lib/InThai.pl new file mode 100644 index 00000000000..db6a14581df --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InThai.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InThai} (and fuzzy permutations) +# +# Meaning: Block 'Thai' +# +return <<'END'; +0E00 0E7F Thai +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InTibeta.pl b/Master/xemtex/perl/lib/unicore/lib/InTibeta.pl new file mode 100644 index 00000000000..8fbe185461c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InTibeta.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InTibetan} (and fuzzy permutations) +# +# Meaning: Block 'Tibetan' +# +return <<'END'; +0F00 0FFF Tibetan +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InUnifie.pl b/Master/xemtex/perl/lib/unicore/lib/InUnifie.pl new file mode 100644 index 00000000000..50d46f18aa6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InUnifie.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InUnifiedCanadianAboriginalSyllabics} (and fuzzy permutations) +# +# Meaning: Block 'Unified Canadian Aboriginal Syllabics' +# +return <<'END'; +1400 167F Unified Canadian Aboriginal Syllabics +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InVariat.pl b/Master/xemtex/perl/lib/unicore/lib/InVariat.pl new file mode 100644 index 00000000000..1aa8c298b8c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InVariat.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InVariationSelectors} (and fuzzy permutations) +# +# Meaning: Block 'Variation Selectors' +# +return <<'END'; +FE00 FE0F Variation Selectors +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InYiRadi.pl b/Master/xemtex/perl/lib/unicore/lib/InYiRadi.pl new file mode 100644 index 00000000000..7b4265f725a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InYiRadi.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InYiRadicals} (and fuzzy permutations) +# +# Meaning: Block 'Yi Radicals' +# +return <<'END'; +A490 A4CF Yi Radicals +END diff --git a/Master/xemtex/perl/lib/unicore/lib/InYiSyll.pl b/Master/xemtex/perl/lib/unicore/lib/InYiSyll.pl new file mode 100644 index 00000000000..c33de835d36 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/InYiSyll.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{InYiSyllables} (and fuzzy permutations) +# +# Meaning: Block 'Yi Syllables' +# +return <<'END'; +A000 A48F Yi Syllables +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Inherite.pl b/Master/xemtex/perl/lib/unicore/lib/Inherite.pl new file mode 100644 index 00000000000..49d811268eb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Inherite.pl @@ -0,0 +1,37 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Inherited} (and fuzzy permutations) +# +# Meaning: Script 'INHERITED' +# +return <<'END'; +0300 034F INHERITED +0360 036F INHERITED +0488 0489 INHERITED +0591 05A1 INHERITED +05A3 05B9 INHERITED +05BB 05BD INHERITED +05BF INHERITED +05C1 05C2 INHERITED +05C4 INHERITED +064B 0655 INHERITED +0670 INHERITED +06D6 06E4 INHERITED +06E7 06E8 INHERITED +06EA 06ED INHERITED +180B 180D INHERITED +20D0 20EA INHERITED +302A 302F INHERITED +3099 309A INHERITED +FB1E INHERITED +FE00 FE0F INHERITED +FE20 FE23 INHERITED +1D167 1D169 INHERITED +1D17B 1D182 INHERITED +1D185 1D18B INHERITED +1D1AA 1D1AD INHERITED +END diff --git a/Master/xemtex/perl/lib/unicore/lib/JoinCont.pl b/Master/xemtex/perl/lib/unicore/lib/JoinCont.pl new file mode 100644 index 00000000000..be25b1afef6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/JoinCont.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{JoinControl} (and fuzzy permutations) +# +# Meaning: Extended property 'Join_Control' +# +return <<'END'; +200C 200D Join_Control +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Kannada.pl b/Master/xemtex/perl/lib/unicore/lib/Kannada.pl new file mode 100644 index 00000000000..7c9a8580180 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Kannada.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Kannada} (and fuzzy permutations) +# +# Meaning: Script 'KANNADA' +# +return <<'END'; +0C82 0C83 KANNADA +0C85 0C8C KANNADA +0C8E 0C90 KANNADA +0C92 0CA8 KANNADA +0CAA 0CB3 KANNADA +0CB5 0CB9 KANNADA +0CBE 0CC4 KANNADA +0CC6 0CC8 KANNADA +0CCA 0CCD KANNADA +0CD5 0CD6 KANNADA +0CDE KANNADA +0CE0 0CE1 KANNADA +0CE6 0CEF KANNADA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Katakana.pl b/Master/xemtex/perl/lib/unicore/lib/Katakana.pl new file mode 100644 index 00000000000..b6503508832 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Katakana.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Katakana} (and fuzzy permutations) +# +# Meaning: Script 'KATAKANA' +# +return <<'END'; +30A1 30FA KATAKANA +30FD 30FF KATAKANA +31F0 31FF KATAKANA +FF66 FF6F KATAKANA +FF71 FF9D KATAKANA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Khmer.pl b/Master/xemtex/perl/lib/unicore/lib/Khmer.pl new file mode 100644 index 00000000000..1e69e0039d0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Khmer.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Khmer} (and fuzzy permutations) +# +# Meaning: Script 'KHMER' +# +return <<'END'; +1780 17D3 KHMER +17E0 17E9 KHMER +END diff --git a/Master/xemtex/perl/lib/unicore/lib/L.pl b/Master/xemtex/perl/lib/unicore/lib/L.pl new file mode 100644 index 00000000000..5b17fe75891 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/L.pl @@ -0,0 +1,319 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{L} +# \p{L} (and fuzzy permutations) +# +# Meaning: Major Category 'L' +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +05D0 05EA +05F0 05F2 +0621 063A +0640 064A +066E 066F +0671 06D3 +06D5 +06E5 06E6 +06FA 06FC +0710 +0712 072C +0780 07A5 +07B1 +0905 0939 +093D +0950 +0958 0961 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09DC 09DD +09DF 09E1 +09F0 09F1 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A59 0A5C +0A5E +0A72 0A74 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABD +0AD0 +0AE0 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3D +0B5C 0B5D +0B5F 0B61 +0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C60 0C61 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CDE +0CE0 0CE1 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D60 0D61 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0E01 0E30 +0E32 0E33 +0E40 0E46 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB0 +0EB2 0EB3 +0EBD +0EC0 0EC4 +0EC6 +0EDC 0EDD +0F00 +0F40 0F47 +0F49 0F6A +0F88 0F8B +1000 1021 +1023 1027 +1029 102A +1050 1055 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +1700 170C +170E 1711 +1720 1731 +1740 1751 +1760 176C +176E 1770 +1780 17B3 +17D7 +17DC +1820 1877 +1880 18A8 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2071 +207F +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +3005 3006 +3031 3035 +303B 303C +3041 3096 +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D +FB1F FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE70 FE74 +FE76 FEFC +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 10349 +10400 10425 +10428 1044D +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/L_.pl b/Master/xemtex/perl/lib/unicore/lib/L_.pl new file mode 100644 index 00000000000..44afbeb5922 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/L_.pl @@ -0,0 +1,112 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{L&} +# +# Meaning: [\p{Ll}\p{Lu}\p{Lt}] +# +return <<'END'; +0041 005A +0061 007A +00AA +00B5 +00BA +00C0 00D6 +00D8 00F6 +00F8 01BA +01BC 01BF +01C4 0220 +0222 0233 +0250 02AD +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +048A 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0561 0587 +10A0 10C5 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2071 +207F +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2134 +2139 +213D 213F +2145 2149 +FB00 FB06 +FB13 FB17 +FF21 FF3A +FF41 FF5A +10400 10425 +10428 1044D +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lao.pl b/Master/xemtex/perl/lib/unicore/lib/Lao.pl new file mode 100644 index 00000000000..83bc60c59b3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lao.pl @@ -0,0 +1,30 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lao} (and fuzzy permutations) +# +# Meaning: Script 'LAO' +# +return <<'END'; +0E81 0E82 LAO +0E84 LAO +0E87 0E88 LAO +0E8A LAO +0E8D LAO +0E94 0E97 LAO +0E99 0E9F LAO +0EA1 0EA3 LAO +0EA5 LAO +0EA7 LAO +0EAA 0EAB LAO +0EAD 0EB9 LAO +0EBB 0EBD LAO +0EC0 0EC4 LAO +0EC6 LAO +0EC8 0ECD LAO +0ED0 0ED9 LAO +0EDC 0EDD LAO +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Latin.pl b/Master/xemtex/perl/lib/unicore/lib/Latin.pl new file mode 100644 index 00000000000..2b27d1c2233 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Latin.pl @@ -0,0 +1,31 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Latin} (and fuzzy permutations) +# +# Meaning: Script 'LATIN' +# +return <<'END'; +0041 005A LATIN +0061 007A LATIN +00AA LATIN +00BA LATIN +00C0 00D6 LATIN +00D8 00F6 LATIN +00F8 0220 LATIN +0222 0233 LATIN +0250 02AD LATIN +02B0 02B8 LATIN +02E0 02E4 LATIN +1E00 1E9B LATIN +1EA0 1EF9 LATIN +2071 LATIN +207F LATIN +212A 212B LATIN +FB00 FB06 LATIN +FF21 FF3A LATIN +FF41 FF5A LATIN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Ll.pl b/Master/xemtex/perl/lib/unicore/lib/Ll.pl new file mode 100644 index 00000000000..8655dfea53f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Ll.pl @@ -0,0 +1,433 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Ll} +# \p{Ll} (and fuzzy permutations) +# +# Meaning: General Category 'Ll' +# +return <<'END'; +0061 007A +00AA +00B5 +00BA +00DF 00F6 +00F8 00FF +0101 +0103 +0105 +0107 +0109 +010B +010D +010F +0111 +0113 +0115 +0117 +0119 +011B +011D +011F +0121 +0123 +0125 +0127 +0129 +012B +012D +012F +0131 +0133 +0135 +0137 0138 +013A +013C +013E +0140 +0142 +0144 +0146 +0148 0149 +014B +014D +014F +0151 +0153 +0155 +0157 +0159 +015B +015D +015F +0161 +0163 +0165 +0167 +0169 +016B +016D +016F +0171 +0173 +0175 +0177 +017A +017C +017E 0180 +0183 +0185 +0188 +018C 018D +0192 +0195 +0199 019B +019E +01A1 +01A3 +01A5 +01A8 +01AA 01AB +01AD +01B0 +01B4 +01B6 +01B9 01BA +01BD 01BF +01C6 +01C9 +01CC +01CE +01D0 +01D2 +01D4 +01D6 +01D8 +01DA +01DC 01DD +01DF +01E1 +01E3 +01E5 +01E7 +01E9 +01EB +01ED +01EF 01F0 +01F3 +01F5 +01F9 +01FB +01FD +01FF +0201 +0203 +0205 +0207 +0209 +020B +020D +020F +0211 +0213 +0215 +0217 +0219 +021B +021D +021F +0223 +0225 +0227 +0229 +022B +022D +022F +0231 +0233 +0250 02AD +0390 +03AC 03CE +03D0 03D1 +03D5 03D7 +03D9 +03DB +03DD +03DF +03E1 +03E3 +03E5 +03E7 +03E9 +03EB +03ED +03EF 03F3 +03F5 +0430 045F +0461 +0463 +0465 +0467 +0469 +046B +046D +046F +0471 +0473 +0475 +0477 +0479 +047B +047D +047F +0481 +048B +048D +048F +0491 +0493 +0495 +0497 +0499 +049B +049D +049F +04A1 +04A3 +04A5 +04A7 +04A9 +04AB +04AD +04AF +04B1 +04B3 +04B5 +04B7 +04B9 +04BB +04BD +04BF +04C2 +04C4 +04C6 +04C8 +04CA +04CC +04CE +04D1 +04D3 +04D5 +04D7 +04D9 +04DB +04DD +04DF +04E1 +04E3 +04E5 +04E7 +04E9 +04EB +04ED +04EF +04F1 +04F3 +04F5 +04F9 +0501 +0503 +0505 +0507 +0509 +050B +050D +050F +0561 0587 +1E01 +1E03 +1E05 +1E07 +1E09 +1E0B +1E0D +1E0F +1E11 +1E13 +1E15 +1E17 +1E19 +1E1B +1E1D +1E1F +1E21 +1E23 +1E25 +1E27 +1E29 +1E2B +1E2D +1E2F +1E31 +1E33 +1E35 +1E37 +1E39 +1E3B +1E3D +1E3F +1E41 +1E43 +1E45 +1E47 +1E49 +1E4B +1E4D +1E4F +1E51 +1E53 +1E55 +1E57 +1E59 +1E5B +1E5D +1E5F +1E61 +1E63 +1E65 +1E67 +1E69 +1E6B +1E6D +1E6F +1E71 +1E73 +1E75 +1E77 +1E79 +1E7B +1E7D +1E7F +1E81 +1E83 +1E85 +1E87 +1E89 +1E8B +1E8D +1E8F +1E91 +1E93 +1E95 1E9B +1EA1 +1EA3 +1EA5 +1EA7 +1EA9 +1EAB +1EAD +1EAF +1EB1 +1EB3 +1EB5 +1EB7 +1EB9 +1EBB +1EBD +1EBF +1EC1 +1EC3 +1EC5 +1EC7 +1EC9 +1ECB +1ECD +1ECF +1ED1 +1ED3 +1ED5 +1ED7 +1ED9 +1EDB +1EDD +1EDF +1EE1 +1EE3 +1EE5 +1EE7 +1EE9 +1EEB +1EED +1EEF +1EF1 +1EF3 +1EF5 +1EF7 +1EF9 +1F00 1F07 +1F10 1F15 +1F20 1F27 +1F30 1F37 +1F40 1F45 +1F50 1F57 +1F60 1F67 +1F70 1F7D +1F80 1F87 +1F90 1F97 +1FA0 1FA7 +1FB0 1FB4 +1FB6 1FB7 +1FBE +1FC2 1FC4 +1FC6 1FC7 +1FD0 1FD3 +1FD6 1FD7 +1FE0 1FE7 +1FF2 1FF4 +1FF6 1FF7 +2071 +207F +210A +210E 210F +2113 +212F +2134 +2139 +213D +2146 2149 +FB00 FB06 +FB13 FB17 +FF41 FF5A +10428 1044D +1D41A 1D433 +1D44E 1D454 +1D456 1D467 +1D482 1D49B +1D4B6 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D4CF +1D4EA 1D503 +1D51E 1D537 +1D552 1D56B +1D586 1D59F +1D5BA 1D5D3 +1D5EE 1D607 +1D622 1D63B +1D656 1D66F +1D68A 1D6A3 +1D6C2 1D6DA +1D6DC 1D6E1 +1D6FC 1D714 +1D716 1D71B +1D736 1D74E +1D750 1D755 +1D770 1D788 +1D78A 1D78F +1D7AA 1D7C2 +1D7C4 1D7C9 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lm.pl b/Master/xemtex/perl/lib/unicore/lib/Lm.pl new file mode 100644 index 00000000000..808193f0342 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lm.pl @@ -0,0 +1,33 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lm} +# \p{Lm} (and fuzzy permutations) +# +# Meaning: General Category 'Lm' +# +return <<'END'; +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +037A +0559 +0640 +06E5 06E6 +0E46 +0EC6 +17D7 +1843 +3005 +3031 3035 +303B +309D 309E +30FC 30FE +FF70 +FF9E FF9F +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lo.pl b/Master/xemtex/perl/lib/unicore/lib/Lo.pl new file mode 100644 index 00000000000..d5f161a0fa6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lo.pl @@ -0,0 +1,217 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lo} +# \p{Lo} (and fuzzy permutations) +# +# Meaning: General Category 'Lo' +# +return <<'END'; +01BB +01C0 01C3 +05D0 05EA +05F0 05F2 +0621 063A +0641 064A +066E 066F +0671 06D3 +06D5 +06FA 06FC +0710 +0712 072C +0780 07A5 +07B1 +0905 0939 +093D +0950 +0958 0961 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09DC 09DD +09DF 09E1 +09F0 09F1 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A59 0A5C +0A5E +0A72 0A74 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABD +0AD0 +0AE0 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3D +0B5C 0B5D +0B5F 0B61 +0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C60 0C61 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CDE +0CE0 0CE1 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D60 0D61 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0E01 0E30 +0E32 0E33 +0E40 0E45 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB0 +0EB2 0EB3 +0EBD +0EC0 0EC4 +0EDC 0EDD +0F00 +0F40 0F47 +0F49 0F6A +0F88 0F8B +1000 1021 +1023 1027 +1029 102A +1050 1055 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +1700 170C +170E 1711 +1720 1731 +1740 1751 +1760 176C +176E 1770 +1780 17B3 +17DC +1820 1842 +1844 1877 +1880 18A8 +2135 2138 +3006 +303C +3041 3096 +309F +30A1 30FA +30FF +3105 312C +3131 318E +31A0 31B7 +31F0 31FF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB1D +FB1F FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE70 FE74 +FE76 FEFC +FF66 FF6F +FF71 FF9D +FFA0 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10330 10349 +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/LogicalO.pl b/Master/xemtex/perl/lib/unicore/lib/LogicalO.pl new file mode 100644 index 00000000000..ae5ad73f603 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/LogicalO.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{LogicalOrderException} (and fuzzy permutations) +# +# Meaning: Extended property 'Logical_Order_Exception' +# +return <<'END'; +0E40 0E44 Logical_Order_Exception +0EC0 0EC4 Logical_Order_Exception +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lower.pl b/Master/xemtex/perl/lib/unicore/lib/Lower.pl new file mode 100644 index 00000000000..b9e16389f7c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lower.pl @@ -0,0 +1,432 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lower} +# +# Meaning: [[:Lower:]] +# +return <<'END'; +0061 007A +00AA +00B5 +00BA +00DF 00F6 +00F8 00FF +0101 +0103 +0105 +0107 +0109 +010B +010D +010F +0111 +0113 +0115 +0117 +0119 +011B +011D +011F +0121 +0123 +0125 +0127 +0129 +012B +012D +012F +0131 +0133 +0135 +0137 0138 +013A +013C +013E +0140 +0142 +0144 +0146 +0148 0149 +014B +014D +014F +0151 +0153 +0155 +0157 +0159 +015B +015D +015F +0161 +0163 +0165 +0167 +0169 +016B +016D +016F +0171 +0173 +0175 +0177 +017A +017C +017E 0180 +0183 +0185 +0188 +018C 018D +0192 +0195 +0199 019B +019E +01A1 +01A3 +01A5 +01A8 +01AA 01AB +01AD +01B0 +01B4 +01B6 +01B9 01BA +01BD 01BF +01C6 +01C9 +01CC +01CE +01D0 +01D2 +01D4 +01D6 +01D8 +01DA +01DC 01DD +01DF +01E1 +01E3 +01E5 +01E7 +01E9 +01EB +01ED +01EF 01F0 +01F3 +01F5 +01F9 +01FB +01FD +01FF +0201 +0203 +0205 +0207 +0209 +020B +020D +020F +0211 +0213 +0215 +0217 +0219 +021B +021D +021F +0223 +0225 +0227 +0229 +022B +022D +022F +0231 +0233 +0250 02AD +0390 +03AC 03CE +03D0 03D1 +03D5 03D7 +03D9 +03DB +03DD +03DF +03E1 +03E3 +03E5 +03E7 +03E9 +03EB +03ED +03EF 03F3 +03F5 +0430 045F +0461 +0463 +0465 +0467 +0469 +046B +046D +046F +0471 +0473 +0475 +0477 +0479 +047B +047D +047F +0481 +048B +048D +048F +0491 +0493 +0495 +0497 +0499 +049B +049D +049F +04A1 +04A3 +04A5 +04A7 +04A9 +04AB +04AD +04AF +04B1 +04B3 +04B5 +04B7 +04B9 +04BB +04BD +04BF +04C2 +04C4 +04C6 +04C8 +04CA +04CC +04CE +04D1 +04D3 +04D5 +04D7 +04D9 +04DB +04DD +04DF +04E1 +04E3 +04E5 +04E7 +04E9 +04EB +04ED +04EF +04F1 +04F3 +04F5 +04F9 +0501 +0503 +0505 +0507 +0509 +050B +050D +050F +0561 0587 +1E01 +1E03 +1E05 +1E07 +1E09 +1E0B +1E0D +1E0F +1E11 +1E13 +1E15 +1E17 +1E19 +1E1B +1E1D +1E1F +1E21 +1E23 +1E25 +1E27 +1E29 +1E2B +1E2D +1E2F +1E31 +1E33 +1E35 +1E37 +1E39 +1E3B +1E3D +1E3F +1E41 +1E43 +1E45 +1E47 +1E49 +1E4B +1E4D +1E4F +1E51 +1E53 +1E55 +1E57 +1E59 +1E5B +1E5D +1E5F +1E61 +1E63 +1E65 +1E67 +1E69 +1E6B +1E6D +1E6F +1E71 +1E73 +1E75 +1E77 +1E79 +1E7B +1E7D +1E7F +1E81 +1E83 +1E85 +1E87 +1E89 +1E8B +1E8D +1E8F +1E91 +1E93 +1E95 1E9B +1EA1 +1EA3 +1EA5 +1EA7 +1EA9 +1EAB +1EAD +1EAF +1EB1 +1EB3 +1EB5 +1EB7 +1EB9 +1EBB +1EBD +1EBF +1EC1 +1EC3 +1EC5 +1EC7 +1EC9 +1ECB +1ECD +1ECF +1ED1 +1ED3 +1ED5 +1ED7 +1ED9 +1EDB +1EDD +1EDF +1EE1 +1EE3 +1EE5 +1EE7 +1EE9 +1EEB +1EED +1EEF +1EF1 +1EF3 +1EF5 +1EF7 +1EF9 +1F00 1F07 +1F10 1F15 +1F20 1F27 +1F30 1F37 +1F40 1F45 +1F50 1F57 +1F60 1F67 +1F70 1F7D +1F80 1F87 +1F90 1F97 +1FA0 1FA7 +1FB0 1FB4 +1FB6 1FB7 +1FBE +1FC2 1FC4 +1FC6 1FC7 +1FD0 1FD3 +1FD6 1FD7 +1FE0 1FE7 +1FF2 1FF4 +1FF6 1FF7 +2071 +207F +210A +210E 210F +2113 +212F +2134 +2139 +213D +2146 2149 +FB00 FB06 +FB13 FB17 +FF41 FF5A +10428 1044D +1D41A 1D433 +1D44E 1D454 +1D456 1D467 +1D482 1D49B +1D4B6 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D4CF +1D4EA 1D503 +1D51E 1D537 +1D552 1D56B +1D586 1D59F +1D5BA 1D5D3 +1D5EE 1D607 +1D622 1D63B +1D656 1D66F +1D68A 1D6A3 +1D6C2 1D6DA +1D6DC 1D6E1 +1D6FC 1D714 +1D716 1D71B +1D736 1D74E +1D750 1D755 +1D770 1D788 +1D78A 1D78F +1D7AA 1D7C2 +1D7C4 1D7C9 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lowercas.pl b/Master/xemtex/perl/lib/unicore/lib/Lowercas.pl new file mode 100644 index 00000000000..07832e47ee7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lowercas.pl @@ -0,0 +1,439 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lowercase} (and fuzzy permutations) +# +# Meaning: [\p{Ll}\p{OtherLowercase}] +# +return <<'END'; +0061 007A +00AA +00B5 +00BA +00DF 00F6 +00F8 00FF +0101 +0103 +0105 +0107 +0109 +010B +010D +010F +0111 +0113 +0115 +0117 +0119 +011B +011D +011F +0121 +0123 +0125 +0127 +0129 +012B +012D +012F +0131 +0133 +0135 +0137 0138 +013A +013C +013E +0140 +0142 +0144 +0146 +0148 0149 +014B +014D +014F +0151 +0153 +0155 +0157 +0159 +015B +015D +015F +0161 +0163 +0165 +0167 +0169 +016B +016D +016F +0171 +0173 +0175 +0177 +017A +017C +017E 0180 +0183 +0185 +0188 +018C 018D +0192 +0195 +0199 019B +019E +01A1 +01A3 +01A5 +01A8 +01AA 01AB +01AD +01B0 +01B4 +01B6 +01B9 01BA +01BD 01BF +01C6 +01C9 +01CC +01CE +01D0 +01D2 +01D4 +01D6 +01D8 +01DA +01DC 01DD +01DF +01E1 +01E3 +01E5 +01E7 +01E9 +01EB +01ED +01EF 01F0 +01F3 +01F5 +01F9 +01FB +01FD +01FF +0201 +0203 +0205 +0207 +0209 +020B +020D +020F +0211 +0213 +0215 +0217 +0219 +021B +021D +021F +0223 +0225 +0227 +0229 +022B +022D +022F +0231 +0233 +0250 02AD +02B0 02B8 +02C0 02C1 +02E0 02E4 +0345 +037A +0390 +03AC 03CE +03D0 03D1 +03D5 03D7 +03D9 +03DB +03DD +03DF +03E1 +03E3 +03E5 +03E7 +03E9 +03EB +03ED +03EF 03F3 +03F5 +0430 045F +0461 +0463 +0465 +0467 +0469 +046B +046D +046F +0471 +0473 +0475 +0477 +0479 +047B +047D +047F +0481 +048B +048D +048F +0491 +0493 +0495 +0497 +0499 +049B +049D +049F +04A1 +04A3 +04A5 +04A7 +04A9 +04AB +04AD +04AF +04B1 +04B3 +04B5 +04B7 +04B9 +04BB +04BD +04BF +04C2 +04C4 +04C6 +04C8 +04CA +04CC +04CE +04D1 +04D3 +04D5 +04D7 +04D9 +04DB +04DD +04DF +04E1 +04E3 +04E5 +04E7 +04E9 +04EB +04ED +04EF +04F1 +04F3 +04F5 +04F9 +0501 +0503 +0505 +0507 +0509 +050B +050D +050F +0561 0587 +1E01 +1E03 +1E05 +1E07 +1E09 +1E0B +1E0D +1E0F +1E11 +1E13 +1E15 +1E17 +1E19 +1E1B +1E1D +1E1F +1E21 +1E23 +1E25 +1E27 +1E29 +1E2B +1E2D +1E2F +1E31 +1E33 +1E35 +1E37 +1E39 +1E3B +1E3D +1E3F +1E41 +1E43 +1E45 +1E47 +1E49 +1E4B +1E4D +1E4F +1E51 +1E53 +1E55 +1E57 +1E59 +1E5B +1E5D +1E5F +1E61 +1E63 +1E65 +1E67 +1E69 +1E6B +1E6D +1E6F +1E71 +1E73 +1E75 +1E77 +1E79 +1E7B +1E7D +1E7F +1E81 +1E83 +1E85 +1E87 +1E89 +1E8B +1E8D +1E8F +1E91 +1E93 +1E95 1E9B +1EA1 +1EA3 +1EA5 +1EA7 +1EA9 +1EAB +1EAD +1EAF +1EB1 +1EB3 +1EB5 +1EB7 +1EB9 +1EBB +1EBD +1EBF +1EC1 +1EC3 +1EC5 +1EC7 +1EC9 +1ECB +1ECD +1ECF +1ED1 +1ED3 +1ED5 +1ED7 +1ED9 +1EDB +1EDD +1EDF +1EE1 +1EE3 +1EE5 +1EE7 +1EE9 +1EEB +1EED +1EEF +1EF1 +1EF3 +1EF5 +1EF7 +1EF9 +1F00 1F07 +1F10 1F15 +1F20 1F27 +1F30 1F37 +1F40 1F45 +1F50 1F57 +1F60 1F67 +1F70 1F7D +1F80 1F87 +1F90 1F97 +1FA0 1FA7 +1FB0 1FB4 +1FB6 1FB7 +1FBE +1FC2 1FC4 +1FC6 1FC7 +1FD0 1FD3 +1FD6 1FD7 +1FE0 1FE7 +1FF2 1FF4 +1FF6 1FF7 +2071 +207F +210A +210E 210F +2113 +212F +2134 +2139 +213D +2146 2149 +2170 217F +24D0 24E9 +FB00 FB06 +FB13 FB17 +FF41 FF5A +10428 1044D +1D41A 1D433 +1D44E 1D454 +1D456 1D467 +1D482 1D49B +1D4B6 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D4CF +1D4EA 1D503 +1D51E 1D537 +1D552 1D56B +1D586 1D59F +1D5BA 1D5D3 +1D5EE 1D607 +1D622 1D63B +1D656 1D66F +1D68A 1D6A3 +1D6C2 1D6DA +1D6DC 1D6E1 +1D6FC 1D714 +1D716 1D71B +1D736 1D74E +1D750 1D755 +1D770 1D788 +1D78A 1D78F +1D7AA 1D7C2 +1D7C4 1D7C9 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lt.pl b/Master/xemtex/perl/lib/unicore/lib/Lt.pl new file mode 100644 index 00000000000..40f761a9c69 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lt.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lt} +# \p{Lt} (and fuzzy permutations) +# +# Meaning: General Category 'Lt' +# +return <<'END'; +01C5 +01C8 +01CB +01F2 +1F88 1F8F +1F98 1F9F +1FA8 1FAF +1FBC +1FCC +1FFC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Lu.pl b/Master/xemtex/perl/lib/unicore/lib/Lu.pl new file mode 100644 index 00000000000..1414b40d2f7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Lu.pl @@ -0,0 +1,432 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Lu} +# \p{Lu} (and fuzzy permutations) +# +# Meaning: General Category 'Lu' +# +return <<'END'; +0041 005A +00C0 00D6 +00D8 00DE +0100 +0102 +0104 +0106 +0108 +010A +010C +010E +0110 +0112 +0114 +0116 +0118 +011A +011C +011E +0120 +0122 +0124 +0126 +0128 +012A +012C +012E +0130 +0132 +0134 +0136 +0139 +013B +013D +013F +0141 +0143 +0145 +0147 +014A +014C +014E +0150 +0152 +0154 +0156 +0158 +015A +015C +015E +0160 +0162 +0164 +0166 +0168 +016A +016C +016E +0170 +0172 +0174 +0176 +0178 0179 +017B +017D +0181 0182 +0184 +0186 0187 +0189 018B +018E 0191 +0193 0194 +0196 0198 +019C 019D +019F 01A0 +01A2 +01A4 +01A6 01A7 +01A9 +01AC +01AE 01AF +01B1 01B3 +01B5 +01B7 01B8 +01BC +01C4 +01C7 +01CA +01CD +01CF +01D1 +01D3 +01D5 +01D7 +01D9 +01DB +01DE +01E0 +01E2 +01E4 +01E6 +01E8 +01EA +01EC +01EE +01F1 +01F4 +01F6 01F8 +01FA +01FC +01FE +0200 +0202 +0204 +0206 +0208 +020A +020C +020E +0210 +0212 +0214 +0216 +0218 +021A +021C +021E +0220 +0222 +0224 +0226 +0228 +022A +022C +022E +0230 +0232 +0386 +0388 038A +038C +038E 038F +0391 03A1 +03A3 03AB +03D2 03D4 +03D8 +03DA +03DC +03DE +03E0 +03E2 +03E4 +03E6 +03E8 +03EA +03EC +03EE +03F4 +0400 042F +0460 +0462 +0464 +0466 +0468 +046A +046C +046E +0470 +0472 +0474 +0476 +0478 +047A +047C +047E +0480 +048A +048C +048E +0490 +0492 +0494 +0496 +0498 +049A +049C +049E +04A0 +04A2 +04A4 +04A6 +04A8 +04AA +04AC +04AE +04B0 +04B2 +04B4 +04B6 +04B8 +04BA +04BC +04BE +04C0 04C1 +04C3 +04C5 +04C7 +04C9 +04CB +04CD +04D0 +04D2 +04D4 +04D6 +04D8 +04DA +04DC +04DE +04E0 +04E2 +04E4 +04E6 +04E8 +04EA +04EC +04EE +04F0 +04F2 +04F4 +04F8 +0500 +0502 +0504 +0506 +0508 +050A +050C +050E +0531 0556 +10A0 10C5 +1E00 +1E02 +1E04 +1E06 +1E08 +1E0A +1E0C +1E0E +1E10 +1E12 +1E14 +1E16 +1E18 +1E1A +1E1C +1E1E +1E20 +1E22 +1E24 +1E26 +1E28 +1E2A +1E2C +1E2E +1E30 +1E32 +1E34 +1E36 +1E38 +1E3A +1E3C +1E3E +1E40 +1E42 +1E44 +1E46 +1E48 +1E4A +1E4C +1E4E +1E50 +1E52 +1E54 +1E56 +1E58 +1E5A +1E5C +1E5E +1E60 +1E62 +1E64 +1E66 +1E68 +1E6A +1E6C +1E6E +1E70 +1E72 +1E74 +1E76 +1E78 +1E7A +1E7C +1E7E +1E80 +1E82 +1E84 +1E86 +1E88 +1E8A +1E8C +1E8E +1E90 +1E92 +1E94 +1EA0 +1EA2 +1EA4 +1EA6 +1EA8 +1EAA +1EAC +1EAE +1EB0 +1EB2 +1EB4 +1EB6 +1EB8 +1EBA +1EBC +1EBE +1EC0 +1EC2 +1EC4 +1EC6 +1EC8 +1ECA +1ECC +1ECE +1ED0 +1ED2 +1ED4 +1ED6 +1ED8 +1EDA +1EDC +1EDE +1EE0 +1EE2 +1EE4 +1EE6 +1EE8 +1EEA +1EEC +1EEE +1EF0 +1EF2 +1EF4 +1EF6 +1EF8 +1F08 1F0F +1F18 1F1D +1F28 1F2F +1F38 1F3F +1F48 1F4D +1F59 +1F5B +1F5D +1F5F +1F68 1F6F +1FB8 1FBB +1FC8 1FCB +1FD8 1FDB +1FE8 1FEC +1FF8 1FFB +2102 +2107 +210B 210D +2110 2112 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +2130 2131 +2133 +213E 213F +2145 +FF21 FF3A +10400 10425 +1D400 1D419 +1D434 1D44D +1D468 1D481 +1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B5 +1D4D0 1D4E9 +1D504 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D538 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D56C 1D585 +1D5A0 1D5B9 +1D5D4 1D5ED +1D608 1D621 +1D63C 1D655 +1D670 1D689 +1D6A8 1D6C0 +1D6E2 1D6FA +1D71C 1D734 +1D756 1D76E +1D790 1D7A8 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/M.pl b/Master/xemtex/perl/lib/unicore/lib/M.pl new file mode 100644 index 00000000000..cd78b82348e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/M.pl @@ -0,0 +1,125 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{M} +# \p{M} (and fuzzy permutations) +# +# Meaning: Major Category 'M' +# +return <<'END'; +0300 034F +0360 036F +0483 0486 +0488 0489 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +064B 0655 +0670 +06D6 06DC +06DE 06E4 +06E7 06E8 +06EA 06ED +0711 +0730 074A +07A6 07B0 +0901 0903 +093C +093E 094D +0951 0954 +0962 0963 +0981 0983 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09E2 09E3 +0A02 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A70 0A71 +0A81 0A83 +0ABC +0ABE 0AC5 +0AC7 0AC9 +0ACB 0ACD +0B01 0B03 +0B3C +0B3E 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B82 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0C01 0C03 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C82 0C83 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0D02 0D03 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D82 0D83 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E31 +0E34 0E3A +0E47 0E4E +0EB1 +0EB4 0EB9 +0EBB 0EBC +0EC8 0ECD +0F18 0F19 +0F35 +0F37 +0F39 +0F3E 0F3F +0F71 0F84 +0F86 0F87 +0F90 0F97 +0F99 0FBC +0FC6 +102C 1032 +1036 1039 +1056 1059 +1712 1714 +1732 1734 +1752 1753 +1772 1773 +17B4 17D3 +180B 180D +18A9 +20D0 20EA +302A 302F +3099 309A +FB1E +FE00 FE0F +FE20 FE23 +1D165 1D169 +1D16D 1D172 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Malayala.pl b/Master/xemtex/perl/lib/unicore/lib/Malayala.pl new file mode 100644 index 00000000000..eb1c7365e14 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Malayala.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Malayalam} (and fuzzy permutations) +# +# Meaning: Script 'MALAYALAM' +# +return <<'END'; +0D02 0D03 MALAYALAM +0D05 0D0C MALAYALAM +0D0E 0D10 MALAYALAM +0D12 0D28 MALAYALAM +0D2A 0D39 MALAYALAM +0D3E 0D43 MALAYALAM +0D46 0D48 MALAYALAM +0D4A 0D4D MALAYALAM +0D57 MALAYALAM +0D60 0D61 MALAYALAM +0D66 0D6F MALAYALAM +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Math.pl b/Master/xemtex/perl/lib/unicore/lib/Math.pl new file mode 100644 index 00000000000..a233c79f8fe --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Math.pl @@ -0,0 +1,101 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Math} (and fuzzy permutations) +# +# Meaning: [\p{Sm}\p{OtherMath}] +# +return <<'END'; +0028 002B +002D +002F +003C 003E +005B 005E +007B 007E +00AC +00B1 +00D7 +00F7 +03F6 +2016 +2032 2034 +2044 +2052 +207A 207E +208A 208E +20D0 20DC +20E1 +2102 +210A 2113 +2115 +2119 211D +2124 +2128 +212C 212D +212F 2131 +2133 2138 +2140 2144 +214B +2190 2194 +219A 219B +21A0 +21A3 +21A6 +21AE +21CE 21CF +21D2 +21D4 +21F4 22FF +2308 230B +2320 2321 +237C +239B 23B3 +25B7 +25C1 +25F8 25FF +266F +27D0 27E5 +27F0 27FF +2900 2982 +2999 29D7 +29DC 29FB +29FE 2AFF +FB29 +FE35 FE38 +FE59 FE5C +FE61 FE66 +FE68 +FF08 FF0B +FF0D +FF0F +FF1C FF1E +FF3B FF3E +FF5B FF5E +FFE2 +FFE9 FFEC +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Mc.pl b/Master/xemtex/perl/lib/unicore/lib/Mc.pl new file mode 100644 index 00000000000..cb4833a16e9 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Mc.pl @@ -0,0 +1,65 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Mc} +# \p{Mc} (and fuzzy permutations) +# +# Meaning: General Category 'Mc' +# +return <<'END'; +0903 +093E 0940 +0949 094C +0982 0983 +09BE 09C0 +09C7 09C8 +09CB 09CC +09D7 +0A3E 0A40 +0A83 +0ABE 0AC0 +0AC9 +0ACB 0ACC +0B02 0B03 +0B3E +0B40 +0B47 0B48 +0B4B 0B4C +0B57 +0BBE 0BBF +0BC1 0BC2 +0BC6 0BC8 +0BCA 0BCC +0BD7 +0C01 0C03 +0C41 0C44 +0C82 0C83 +0CBE +0CC0 0CC4 +0CC7 0CC8 +0CCA 0CCB +0CD5 0CD6 +0D02 0D03 +0D3E 0D40 +0D46 0D48 +0D4A 0D4C +0D57 +0D82 0D83 +0DCF 0DD1 +0DD8 0DDF +0DF2 0DF3 +0F3E 0F3F +0F7F +102C +1031 +1038 +1056 1057 +17B4 17B6 +17BE 17C5 +17C7 17C8 +1D165 1D166 +1D16D 1D172 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Me.pl b/Master/xemtex/perl/lib/unicore/lib/Me.pl new file mode 100644 index 00000000000..e8dc9d974e0 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Me.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Me} +# \p{Me} (and fuzzy permutations) +# +# Meaning: General Category 'Me' +# +return <<'END'; +0488 0489 +06DE +20DD 20E0 +20E2 20E4 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Mirrored.pl b/Master/xemtex/perl/lib/unicore/lib/Mirrored.pl new file mode 100644 index 00000000000..f7512515add --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Mirrored.pl @@ -0,0 +1,105 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Mirrored} +# +# Meaning: Mirrored in bidirectional text +# +return <<'END'; +0028 0029 +003C +003E +005B +005D +007B +007D +00AB +00BB +2039 203A +2045 2046 +207D 207E +208D 208E +2140 +2201 2204 +2208 220D +2211 +2215 2216 +221A 221D +221F 2222 +2224 +2226 +222B 2233 +2239 +223B 224C +2252 2255 +225F 2260 +2262 +2264 226B +226E 228C +228F 2292 +2298 +22A2 22A3 +22A6 22B8 +22BE 22BF +22C9 22CD +22D0 22D1 +22D6 22ED +22F0 22FF +2308 230B +2320 2321 +2329 232A +2768 2775 +27D3 27D6 +27DC 27DE +27E2 27EB +2983 2998 +299B 29AF +29B8 +29C0 29C5 +29C9 +29CE 29D2 +29D4 29D5 +29D8 29DC +29E1 +29E3 29E5 +29E8 29E9 +29F4 29F9 +29FC 29FD +2A0A 2A1C +2A1E 2A21 +2A24 +2A26 +2A29 +2A2B 2A2E +2A34 2A35 +2A3C 2A3E +2A57 2A58 +2A64 2A65 +2A6A 2A6D +2A6F 2A70 +2A73 2A74 +2A79 2AA3 +2AA6 2AAD +2AAF 2AD6 +2ADC +2ADE +2AE2 2AE6 +2AEC 2AEE +2AF3 +2AF7 2AFB +2AFD +3008 3011 +3014 301B +FF08 FF09 +FF1C +FF1E +FF3B +FF3D +FF5B +FF5D +FF5F FF60 +FF62 FF63 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Mn.pl b/Master/xemtex/perl/lib/unicore/lib/Mn.pl new file mode 100644 index 00000000000..481f1ed4915 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Mn.pl @@ -0,0 +1,117 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Mn} +# \p{Mn} (and fuzzy permutations) +# +# Meaning: General Category 'Mn' +# +return <<'END'; +0300 034F +0360 036F +0483 0486 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +064B 0655 +0670 +06D6 06DC +06DF 06E4 +06E7 06E8 +06EA 06ED +0711 +0730 074A +07A6 07B0 +0901 0902 +093C +0941 0948 +094D +0951 0954 +0962 0963 +0981 +09BC +09C1 09C4 +09CD +09E2 09E3 +0A02 +0A3C +0A41 0A42 +0A47 0A48 +0A4B 0A4D +0A70 0A71 +0A81 0A82 +0ABC +0AC1 0AC5 +0AC7 0AC8 +0ACD +0B01 +0B3C +0B3F +0B41 0B43 +0B4D +0B56 +0B82 +0BC0 +0BCD +0C3E 0C40 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0CBF +0CC6 +0CCC 0CCD +0D41 0D43 +0D4D +0DCA +0DD2 0DD4 +0DD6 +0E31 +0E34 0E3A +0E47 0E4E +0EB1 +0EB4 0EB9 +0EBB 0EBC +0EC8 0ECD +0F18 0F19 +0F35 +0F37 +0F39 +0F71 0F7E +0F80 0F84 +0F86 0F87 +0F90 0F97 +0F99 0FBC +0FC6 +102D 1030 +1032 +1036 1037 +1039 +1058 1059 +1712 1714 +1732 1734 +1752 1753 +1772 1773 +17B7 17BD +17C6 +17C9 17D3 +180B 180D +18A9 +20D0 20DC +20E1 +20E5 20EA +302A 302F +3099 309A +FB1E +FE00 FE0F +FE20 FE23 +1D167 1D169 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Mongolia.pl b/Master/xemtex/perl/lib/unicore/lib/Mongolia.pl new file mode 100644 index 00000000000..5cdc083e149 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Mongolia.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Mongolian} (and fuzzy permutations) +# +# Meaning: Script 'MONGOLIAN' +# +return <<'END'; +1810 1819 MONGOLIAN +1820 1877 MONGOLIAN +1880 18A9 MONGOLIAN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Myanmar.pl b/Master/xemtex/perl/lib/unicore/lib/Myanmar.pl new file mode 100644 index 00000000000..49385bbe0a2 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Myanmar.pl @@ -0,0 +1,19 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Myanmar} (and fuzzy permutations) +# +# Meaning: Script 'MYANMAR' +# +return <<'END'; +1000 1021 MYANMAR +1023 1027 MYANMAR +1029 102A MYANMAR +102C 1032 MYANMAR +1036 1039 MYANMAR +1040 1049 MYANMAR +1050 1059 MYANMAR +END diff --git a/Master/xemtex/perl/lib/unicore/lib/N.pl b/Master/xemtex/perl/lib/unicore/lib/N.pl new file mode 100644 index 00000000000..612b79f1f3d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/N.pl @@ -0,0 +1,56 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{N} +# \p{N} (and fuzzy permutations) +# +# Meaning: Major Category 'N' +# +return <<'END'; +0030 0039 +00B2 00B3 +00B9 +00BC 00BE +0660 0669 +06F0 06F9 +0966 096F +09E6 09EF +09F4 09F9 +0A66 0A6F +0AE6 0AEF +0B66 0B6F +0BE7 0BF2 +0C66 0C6F +0CE6 0CEF +0D66 0D6F +0E50 0E59 +0ED0 0ED9 +0F20 0F33 +1040 1049 +1369 137C +16EE 16F0 +17E0 17E9 +1810 1819 +2070 +2074 2079 +2080 2089 +2153 2183 +2460 249B +24EA 24FE +2776 2793 +3007 +3021 3029 +3038 303A +3192 3195 +3220 3229 +3251 325F +3280 3289 +32B1 32BF +FF10 FF19 +10320 10323 +1034A +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Nd.pl b/Master/xemtex/perl/lib/unicore/lib/Nd.pl new file mode 100644 index 00000000000..30cd8445dd1 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Nd.pl @@ -0,0 +1,34 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Nd} +# \p{Nd} (and fuzzy permutations) +# +# Meaning: General Category 'Nd' +# +return <<'END'; +0030 0039 +0660 0669 +06F0 06F9 +0966 096F +09E6 09EF +0A66 0A6F +0AE6 0AEF +0B66 0B6F +0BE7 0BEF +0C66 0C6F +0CE6 0CEF +0D66 0D6F +0E50 0E59 +0ED0 0ED9 +0F20 0F29 +1040 1049 +1369 1371 +17E0 17E9 +1810 1819 +FF10 FF19 +1D7CE 1D7FF +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Nl.pl b/Master/xemtex/perl/lib/unicore/lib/Nl.pl new file mode 100644 index 00000000000..14279d3030d --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Nl.pl @@ -0,0 +1,19 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Nl} +# \p{Nl} (and fuzzy permutations) +# +# Meaning: General Category 'Nl' +# +return <<'END'; +16EE 16F0 +2160 2183 +3007 +3021 3029 +3038 303A +1034A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/No.pl b/Master/xemtex/perl/lib/unicore/lib/No.pl new file mode 100644 index 00000000000..ede689d6a46 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/No.pl @@ -0,0 +1,33 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{No} +# \p{No} (and fuzzy permutations) +# +# Meaning: General Category 'No' +# +return <<'END'; +00B2 00B3 +00B9 +00BC 00BE +09F4 09F9 +0BF0 0BF2 +0F2A 0F33 +1372 137C +2070 +2074 2079 +2080 2089 +2153 215F +2460 249B +24EA 24FE +2776 2793 +3192 3195 +3220 3229 +3251 325F +3280 3289 +32B1 32BF +10320 10323 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Nonchara.pl b/Master/xemtex/perl/lib/unicore/lib/Nonchara.pl new file mode 100644 index 00000000000..adf874015e3 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Nonchara.pl @@ -0,0 +1,30 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{NoncharacterCodePoint} (and fuzzy permutations) +# +# Meaning: Extended property 'Noncharacter_Code_Point' +# +return <<'END'; +FDD0 FDEF Noncharacter_Code_Point +FFFE FFFF Noncharacter_Code_Point +1FFFE 1FFFF Noncharacter_Code_Point +2FFFE 2FFFF Noncharacter_Code_Point +3FFFE 3FFFF Noncharacter_Code_Point +4FFFE 4FFFF Noncharacter_Code_Point +5FFFE 5FFFF Noncharacter_Code_Point +6FFFE 6FFFF Noncharacter_Code_Point +7FFFE 7FFFF Noncharacter_Code_Point +8FFFE 8FFFF Noncharacter_Code_Point +9FFFE 9FFFF Noncharacter_Code_Point +AFFFE AFFFF Noncharacter_Code_Point +BFFFE BFFFF Noncharacter_Code_Point +CFFFE CFFFF Noncharacter_Code_Point +DFFFE DFFFF Noncharacter_Code_Point +EFFFE EFFFF Noncharacter_Code_Point +FFFFE FFFFF Noncharacter_Code_Point +10FFFE 10FFFF Noncharacter_Code_Point +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Ogham.pl b/Master/xemtex/perl/lib/unicore/lib/Ogham.pl new file mode 100644 index 00000000000..6b9538485b6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Ogham.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Ogham} (and fuzzy permutations) +# +# Meaning: Script 'OGHAM' +# +return <<'END'; +1681 169A OGHAM +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OldItali.pl b/Master/xemtex/perl/lib/unicore/lib/OldItali.pl new file mode 100644 index 00000000000..7fe3725c0e6 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OldItali.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OldItalic} (and fuzzy permutations) +# +# Meaning: Script 'OLD_ITALIC' +# +return <<'END'; +10300 1031E OLD_ITALIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Oriya.pl b/Master/xemtex/perl/lib/unicore/lib/Oriya.pl new file mode 100644 index 00000000000..2b599d6c08a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Oriya.pl @@ -0,0 +1,26 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Oriya} (and fuzzy permutations) +# +# Meaning: Script 'ORIYA' +# +return <<'END'; +0B01 0B03 ORIYA +0B05 0B0C ORIYA +0B0F 0B10 ORIYA +0B13 0B28 ORIYA +0B2A 0B30 ORIYA +0B32 0B33 ORIYA +0B36 0B39 ORIYA +0B3C 0B43 ORIYA +0B47 0B48 ORIYA +0B4B 0B4D ORIYA +0B56 0B57 ORIYA +0B5C 0B5D ORIYA +0B5F 0B61 ORIYA +0B66 0B6F ORIYA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherAlp.pl b/Master/xemtex/perl/lib/unicore/lib/OtherAlp.pl new file mode 100644 index 00000000000..97eda4888e5 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherAlp.pl @@ -0,0 +1,99 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherAlphabetic} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Alphabetic' +# +return <<'END'; +0345 Other_Alphabetic +05B0 05B9 Other_Alphabetic +05BB 05BD Other_Alphabetic +05BF Other_Alphabetic +05C1 05C2 Other_Alphabetic +05C4 Other_Alphabetic +064B 0655 Other_Alphabetic +0670 Other_Alphabetic +06D6 06DC Other_Alphabetic +06E1 06E4 Other_Alphabetic +06E7 06E8 Other_Alphabetic +06ED Other_Alphabetic +0711 Other_Alphabetic +0730 073F Other_Alphabetic +07A6 07B0 Other_Alphabetic +0901 0903 Other_Alphabetic +093E 094C Other_Alphabetic +0962 0963 Other_Alphabetic +0981 0983 Other_Alphabetic +09BE 09C4 Other_Alphabetic +09C7 09C8 Other_Alphabetic +09CB 09CC Other_Alphabetic +09D7 Other_Alphabetic +09E2 09E3 Other_Alphabetic +0A02 Other_Alphabetic +0A3E 0A42 Other_Alphabetic +0A47 0A48 Other_Alphabetic +0A4B 0A4C Other_Alphabetic +0A70 0A71 Other_Alphabetic +0A81 0A83 Other_Alphabetic +0ABE 0AC5 Other_Alphabetic +0AC7 0AC9 Other_Alphabetic +0ACB 0ACC Other_Alphabetic +0B01 0B03 Other_Alphabetic +0B3E 0B43 Other_Alphabetic +0B47 0B48 Other_Alphabetic +0B4B 0B4C Other_Alphabetic +0B56 0B57 Other_Alphabetic +0B82 Other_Alphabetic +0BBE 0BC2 Other_Alphabetic +0BC6 0BC8 Other_Alphabetic +0BCA 0BCC Other_Alphabetic +0BD7 Other_Alphabetic +0C01 0C03 Other_Alphabetic +0C3E 0C44 Other_Alphabetic +0C46 0C48 Other_Alphabetic +0C4A 0C4C Other_Alphabetic +0C55 0C56 Other_Alphabetic +0C82 0C83 Other_Alphabetic +0CBE 0CC4 Other_Alphabetic +0CC6 0CC8 Other_Alphabetic +0CCA 0CCC Other_Alphabetic +0CD5 0CD6 Other_Alphabetic +0D02 0D03 Other_Alphabetic +0D3E 0D43 Other_Alphabetic +0D46 0D48 Other_Alphabetic +0D4A 0D4C Other_Alphabetic +0D57 Other_Alphabetic +0D82 0D83 Other_Alphabetic +0DCF 0DD4 Other_Alphabetic +0DD6 Other_Alphabetic +0DD8 0DDF Other_Alphabetic +0DF2 0DF3 Other_Alphabetic +0E31 Other_Alphabetic +0E34 0E3A Other_Alphabetic +0E4D Other_Alphabetic +0EB1 Other_Alphabetic +0EB4 0EB9 Other_Alphabetic +0EBB 0EBC Other_Alphabetic +0ECD Other_Alphabetic +0F71 0F81 Other_Alphabetic +0F90 0F97 Other_Alphabetic +0F99 0FBC Other_Alphabetic +102C 1032 Other_Alphabetic +1036 Other_Alphabetic +1038 Other_Alphabetic +1056 1059 Other_Alphabetic +16EE 16F0 Other_Alphabetic +1712 1713 Other_Alphabetic +1732 1733 Other_Alphabetic +1752 1753 Other_Alphabetic +1772 1773 Other_Alphabetic +17B4 17C8 Other_Alphabetic +18A9 Other_Alphabetic +2160 2183 Other_Alphabetic +FB1E Other_Alphabetic +1034A Other_Alphabetic +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherDef.pl b/Master/xemtex/perl/lib/unicore/lib/OtherDef.pl new file mode 100644 index 00000000000..6bdd19449aa --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherDef.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherDefaultIgnorableCodePoint} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Default_Ignorable_Code_Point' +# +return <<'END'; +180B 180D Other_Default_Ignorable_Code_Point +2060 206F Other_Default_Ignorable_Code_Point +FE00 FE0F Other_Default_Ignorable_Code_Point +FFF0 FFFB Other_Default_Ignorable_Code_Point +E0000 E0FFF Other_Default_Ignorable_Code_Point +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherGra.pl b/Master/xemtex/perl/lib/unicore/lib/OtherGra.pl new file mode 100644 index 00000000000..7a927cdb456 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherGra.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherGraphemeExtend} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Grapheme_Extend' +# +return <<'END'; +FF9E FF9F Other_Grapheme_Extend +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherLow.pl b/Master/xemtex/perl/lib/unicore/lib/OtherLow.pl new file mode 100644 index 00000000000..ae844c9d62c --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherLow.pl @@ -0,0 +1,19 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherLowercase} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Lowercase' +# +return <<'END'; +02B0 02B8 Other_Lowercase +02C0 02C1 Other_Lowercase +02E0 02E4 Other_Lowercase +0345 Other_Lowercase +037A Other_Lowercase +2170 217F Other_Lowercase +24D0 24E9 Other_Lowercase +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherMat.pl b/Master/xemtex/perl/lib/unicore/lib/OtherMat.pl new file mode 100644 index 00000000000..1f9ad904090 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherMat.pl @@ -0,0 +1,76 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherMath} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Math' +# +return <<'END'; +0028 002A Other_Math +002D Other_Math +002F Other_Math +005B 005E Other_Math +007B Other_Math +007D Other_Math +2016 Other_Math +2032 2034 Other_Math +207D 207E Other_Math +208D 208E Other_Math +20D0 20DC Other_Math +20E1 Other_Math +2102 Other_Math +210A 2113 Other_Math +2115 Other_Math +2119 211D Other_Math +2124 Other_Math +2128 Other_Math +212C 212D Other_Math +212F 2131 Other_Math +2133 2138 Other_Math +FE35 FE38 Other_Math +FE59 FE5C Other_Math +FE61 Other_Math +FE63 Other_Math +FE68 Other_Math +FF08 FF0A Other_Math +FF0D Other_Math +FF0F Other_Math +FF3B FF3E Other_Math +FF5B Other_Math +FF5D Other_Math +1D400 1D454 Other_Math +1D456 1D49C Other_Math +1D49E 1D49F Other_Math +1D4A2 Other_Math +1D4A5 1D4A6 Other_Math +1D4A9 1D4AC Other_Math +1D4AE 1D4B9 Other_Math +1D4BB Other_Math +1D4BD 1D4C0 Other_Math +1D4C2 1D4C3 Other_Math +1D4C5 1D505 Other_Math +1D507 1D50A Other_Math +1D50D 1D514 Other_Math +1D516 1D51C Other_Math +1D51E 1D539 Other_Math +1D53B 1D53E Other_Math +1D540 1D544 Other_Math +1D546 Other_Math +1D54A 1D550 Other_Math +1D552 1D6A3 Other_Math +1D6A8 1D6C0 Other_Math +1D6C2 1D6DA Other_Math +1D6DC 1D6FA Other_Math +1D6FC 1D714 Other_Math +1D716 1D734 Other_Math +1D736 1D74E Other_Math +1D750 1D76E Other_Math +1D770 1D788 Other_Math +1D78A 1D7A8 Other_Math +1D7AA 1D7C2 Other_Math +1D7C4 1D7C9 Other_Math +1D7CE 1D7FF Other_Math +END diff --git a/Master/xemtex/perl/lib/unicore/lib/OtherUpp.pl b/Master/xemtex/perl/lib/unicore/lib/OtherUpp.pl new file mode 100644 index 00000000000..4ba30489926 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/OtherUpp.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{OtherUppercase} (and fuzzy permutations) +# +# Meaning: Extended property 'Other_Uppercase' +# +return <<'END'; +2160 216F Other_Uppercase +24B6 24CF Other_Uppercase +END diff --git a/Master/xemtex/perl/lib/unicore/lib/P.pl b/Master/xemtex/perl/lib/unicore/lib/P.pl new file mode 100644 index 00000000000..1302e8d8f9a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/P.pl @@ -0,0 +1,97 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{P} +# \p{P} (and fuzzy permutations) +# +# Meaning: Major Category 'P' +# +return <<'END'; +0021 0023 +0025 002A +002C 002F +003A 003B +003F 0040 +005B 005D +005F +007B +007D +00A1 +00AB +00AD +00B7 +00BB +00BF +037E +0387 +055A 055F +0589 058A +05BE +05C0 +05C3 +05F3 05F4 +060C +061B +061F +066A 066D +06D4 +0700 070D +0964 0965 +0970 +0DF4 +0E4F +0E5A 0E5B +0F04 0F12 +0F3A 0F3D +0F85 +104A 104F +10FB +1361 1368 +166D 166E +169B 169C +16EB 16ED +1735 1736 +17D4 17D6 +17D8 17DA +1800 180A +2010 2027 +2030 2043 +2045 2051 +2057 +207D 207E +208D 208E +2329 232A +23B4 23B6 +2768 2775 +27E6 27EB +2983 2998 +29D8 29DB +29FC 29FD +3001 3003 +3008 3011 +3014 301F +3030 +303D +30A0 +30FB +FD3E FD3F +FE30 FE46 +FE49 FE52 +FE54 FE61 +FE63 +FE68 +FE6A FE6B +FF01 FF03 +FF05 FF0A +FF0C FF0F +FF1A FF1B +FF1F FF20 +FF3B FF3D +FF3F +FF5B +FF5D +FF5F FF65 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Pc.pl b/Master/xemtex/perl/lib/unicore/lib/Pc.pl new file mode 100644 index 00000000000..2f087426846 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Pc.pl @@ -0,0 +1,20 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Pc} +# \p{Pc} (and fuzzy permutations) +# +# Meaning: General Category 'Pc' +# +return <<'END'; +005F +203F 2040 +30FB +FE33 FE34 +FE4D FE4F +FF3F +FF65 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Pd.pl b/Master/xemtex/perl/lib/unicore/lib/Pd.pl new file mode 100644 index 00000000000..e32f88fe509 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Pd.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Pd} +# \p{Pd} (and fuzzy permutations) +# +# Meaning: General Category 'Pd' +# +return <<'END'; +002D +00AD +058A +1806 +2010 2015 +301C +3030 +30A0 +FE31 FE32 +FE58 +FE63 +FF0D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Pe.pl b/Master/xemtex/perl/lib/unicore/lib/Pe.pl new file mode 100644 index 00000000000..5c7e3c8dbe9 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Pe.pl @@ -0,0 +1,75 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Pe} +# \p{Pe} (and fuzzy permutations) +# +# Meaning: General Category 'Pe' +# +return <<'END'; +0029 +005D +007D +0F3B +0F3D +169C +2046 +207E +208E +232A +23B5 +2769 +276B +276D +276F +2771 +2773 +2775 +27E7 +27E9 +27EB +2984 +2986 +2988 +298A +298C +298E +2990 +2992 +2994 +2996 +2998 +29D9 +29DB +29FD +3009 +300B +300D +300F +3011 +3015 +3017 +3019 +301B +301E 301F +FD3F +FE36 +FE38 +FE3A +FE3C +FE3E +FE40 +FE42 +FE44 +FE5A +FE5C +FE5E +FF09 +FF3D +FF5D +FF60 +FF63 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Pf.pl b/Master/xemtex/perl/lib/unicore/lib/Pf.pl new file mode 100644 index 00000000000..8e363d2a970 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Pf.pl @@ -0,0 +1,17 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Pf} +# \p{Pf} (and fuzzy permutations) +# +# Meaning: General Category 'Pf' +# +return <<'END'; +00BB +2019 +201D +203A +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Pi.pl b/Master/xemtex/perl/lib/unicore/lib/Pi.pl new file mode 100644 index 00000000000..c78bde1b9cb --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Pi.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Pi} +# \p{Pi} (and fuzzy permutations) +# +# Meaning: General Category 'Pi' +# +return <<'END'; +00AB +2018 +201B 201C +201F +2039 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Po.pl b/Master/xemtex/perl/lib/unicore/lib/Po.pl new file mode 100644 index 00000000000..963ce32a156 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Po.pl @@ -0,0 +1,83 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Po} +# \p{Po} (and fuzzy permutations) +# +# Meaning: General Category 'Po' +# +return <<'END'; +0021 0023 +0025 0027 +002A +002C +002E 002F +003A 003B +003F 0040 +005C +00A1 +00B7 +00BF +037E +0387 +055A 055F +0589 +05BE +05C0 +05C3 +05F3 05F4 +060C +061B +061F +066A 066D +06D4 +0700 070D +0964 0965 +0970 +0DF4 +0E4F +0E5A 0E5B +0F04 0F12 +0F85 +104A 104F +10FB +1361 1368 +166D 166E +16EB 16ED +1735 1736 +17D4 17D6 +17D8 17DA +1800 1805 +1807 180A +2016 2017 +2020 2027 +2030 2038 +203B 203E +2041 2043 +2047 2051 +2057 +23B6 +3001 3003 +303D +FE30 +FE45 FE46 +FE49 FE4C +FE50 FE52 +FE54 FE57 +FE5F FE61 +FE68 +FE6A FE6B +FF01 FF03 +FF05 FF07 +FF0A +FF0C +FF0E FF0F +FF1A FF1B +FF1F FF20 +FF3C +FF61 +FF64 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Print.pl b/Master/xemtex/perl/lib/unicore/lib/Print.pl new file mode 100644 index 00000000000..01ac6f10d41 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Print.pl @@ -0,0 +1,400 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Print} +# +# Meaning: [[:Print:]] +# +return <<'END'; +0020 007E +00A0 0220 +0222 0233 +0250 02AD +02B0 02EE +0300 034F +0360 036F +0374 0375 +037A +037E +0384 038A +038C +038E 03A1 +03A3 03CE +03D0 03F6 +0400 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 055F +0561 0587 +0589 058A +0591 05A1 +05A3 05B9 +05BB 05C4 +05D0 05EA +05F0 05F4 +060C +061B +061F +0621 063A +0640 0655 +0660 06DC +06DE 06ED +06F0 06FE +0700 070D +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0970 +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09FA +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B70 +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF4 +0E01 0E3A +0E3F 0E5B +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 0F47 +0F49 0F6A +0F71 0F8B +0F90 0F97 +0F99 0FBC +0FBE 0FCC +0FCF +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1059 +10A0 10C5 +10D0 10F8 +10FB +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1361 137C +13A0 13F4 +1401 1676 +1680 169C +16A0 16F0 +1700 170C +170E 1714 +1720 1736 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17DC +17E0 17E9 +1800 180D +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FC4 +1FC6 1FD3 +1FD6 1FDB +1FDD 1FEF +1FF2 1FF4 +1FF6 1FFE +2000 200B +2010 2027 +202F 2052 +2057 +205F +2070 2071 +2074 208E +20A0 20B1 +20D0 20EA +2100 213A +213D 214B +2153 2183 +2190 23CE +2400 2426 +2440 244A +2460 24FE +2500 2613 +2616 2617 +2619 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2794 +2798 27AF +27B1 27BE +27D0 27EB +27F0 2AFF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3000 303F +3041 3096 +3099 30FF +3105 312C +3131 318E +3190 31B7 +31F0 321C +3220 3243 +3251 327B +327F 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +3400 4DB5 +4E00 9FA5 +A000 A48C +A490 A4C6 +AC00 D7A3 +E000 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3F +FD50 FD8F +FD92 FDC7 +FDF0 FDFC +FE00 FE0F +FE20 FE23 +FE30 FE46 +FE49 FE52 +FE54 FE66 +FE68 FE6B +FE70 FE74 +FE76 FEFC +FF01 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +FFE0 FFE6 +FFE8 FFEE +FFFC FFFD +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D000 1D0F5 +1D100 1D126 +1D12A 1D172 +1D17B 1D1DD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +F0000 FFFFD +100000 10FFFD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Ps.pl b/Master/xemtex/perl/lib/unicore/lib/Ps.pl new file mode 100644 index 00000000000..0c0dd89a210 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Ps.pl @@ -0,0 +1,77 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Ps} +# \p{Ps} (and fuzzy permutations) +# +# Meaning: General Category 'Ps' +# +return <<'END'; +0028 +005B +007B +0F3A +0F3C +169B +201A +201E +2045 +207D +208D +2329 +23B4 +2768 +276A +276C +276E +2770 +2772 +2774 +27E6 +27E8 +27EA +2983 +2985 +2987 +2989 +298B +298D +298F +2991 +2993 +2995 +2997 +29D8 +29DA +29FC +3008 +300A +300C +300E +3010 +3014 +3016 +3018 +301A +301D +FD3E +FE35 +FE37 +FE39 +FE3B +FE3D +FE3F +FE41 +FE43 +FE59 +FE5B +FE5D +FF08 +FF3B +FF5B +FF5F +FF62 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Punct.pl b/Master/xemtex/perl/lib/unicore/lib/Punct.pl new file mode 100644 index 00000000000..ca68b6ab499 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Punct.pl @@ -0,0 +1,96 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Punct} +# +# Meaning: [[:Punct:]] +# +return <<'END'; +0021 0023 +0025 002A +002C 002F +003A 003B +003F 0040 +005B 005D +005F +007B +007D +00A1 +00AB +00AD +00B7 +00BB +00BF +037E +0387 +055A 055F +0589 058A +05BE +05C0 +05C3 +05F3 05F4 +060C +061B +061F +066A 066D +06D4 +0700 070D +0964 0965 +0970 +0DF4 +0E4F +0E5A 0E5B +0F04 0F12 +0F3A 0F3D +0F85 +104A 104F +10FB +1361 1368 +166D 166E +169B 169C +16EB 16ED +1735 1736 +17D4 17D6 +17D8 17DA +1800 180A +2010 2027 +2030 2043 +2045 2051 +2057 +207D 207E +208D 208E +2329 232A +23B4 23B6 +2768 2775 +27E6 27EB +2983 2998 +29D8 29DB +29FC 29FD +3001 3003 +3008 3011 +3014 301F +3030 +303D +30A0 +30FB +FD3E FD3F +FE30 FE46 +FE49 FE52 +FE54 FE61 +FE63 +FE68 +FE6A FE6B +FF01 FF03 +FF05 FF0A +FF0C FF0F +FF1A FF1B +FF1F FF20 +FF3B FF3D +FF3F +FF5B +FF5D +FF5F FF65 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Quotatio.pl b/Master/xemtex/perl/lib/unicore/lib/Quotatio.pl new file mode 100644 index 00000000000..802e85a1f52 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Quotatio.pl @@ -0,0 +1,24 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{QuotationMark} (and fuzzy permutations) +# +# Meaning: Extended property 'Quotation_Mark' +# +return <<'END'; +0022 Quotation_Mark +0027 Quotation_Mark +00AB Quotation_Mark +00BB Quotation_Mark +2018 201F Quotation_Mark +2039 203A Quotation_Mark +300C 300F Quotation_Mark +301D 301F Quotation_Mark +FE41 FE44 Quotation_Mark +FF02 Quotation_Mark +FF07 Quotation_Mark +FF62 FF63 Quotation_Mark +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Radical.pl b/Master/xemtex/perl/lib/unicore/lib/Radical.pl new file mode 100644 index 00000000000..2b87cfe7929 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Radical.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Radical} (and fuzzy permutations) +# +# Meaning: Extended property 'Radical' +# +return <<'END'; +2E80 2E99 Radical +2E9B 2EF3 Radical +2F00 2FD5 Radical +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Runic.pl b/Master/xemtex/perl/lib/unicore/lib/Runic.pl new file mode 100644 index 00000000000..01eef2b0964 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Runic.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Runic} (and fuzzy permutations) +# +# Meaning: Script 'RUNIC' +# +return <<'END'; +16A0 16EA RUNIC +16EE 16F0 RUNIC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/S.pl b/Master/xemtex/perl/lib/unicore/lib/S.pl new file mode 100644 index 00000000000..a1ceed0442b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/S.pl @@ -0,0 +1,159 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{S} +# \p{S} (and fuzzy permutations) +# +# Meaning: Major Category 'S' +# +return <<'END'; +0024 +002B +003C 003E +005E +0060 +007C +007E +00A2 00A9 +00AC +00AE 00B1 +00B4 +00B6 +00B8 +00D7 +00F7 +02B9 02BA +02C2 02CF +02D2 02DF +02E5 02ED +0374 0375 +0384 0385 +03F6 +0482 +06E9 +06FD 06FE +09F2 09F3 +09FA +0B70 +0E3F +0F01 0F03 +0F13 0F17 +0F1A 0F1F +0F34 +0F36 +0F38 +0FBE 0FC5 +0FC7 0FCC +0FCF +17DB +1FBD +1FBF 1FC1 +1FCD 1FCF +1FDD 1FDF +1FED 1FEF +1FFD 1FFE +2044 +2052 +207A 207C +208A 208C +20A0 20B1 +2100 2101 +2103 2106 +2108 2109 +2114 +2116 2118 +211E 2123 +2125 +2127 +2129 +212E +2132 +213A +2140 2144 +214A 214B +2190 2328 +232B 23B3 +23B7 23CE +2400 2426 +2440 244A +249C 24E9 +2500 2613 +2616 2617 +2619 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2767 +2794 +2798 27AF +27B1 27BE +27D0 27E5 +27F0 2982 +2999 29D7 +29DC 29FB +29FE 2AFF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3004 +3012 3013 +3020 +3036 3037 +303E 303F +309B 309C +3190 3191 +3196 319F +3200 321C +322A 3243 +3260 327B +327F +328A 32B0 +32C0 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +A490 A4C6 +FB29 +FDFC +FE62 +FE64 FE66 +FE69 +FF04 +FF0B +FF1C FF1E +FF3E +FF40 +FF5C +FF5E +FFE0 FFE6 +FFE8 FFEE +FFFC FFFD +1D000 1D0F5 +1D100 1D126 +1D12A 1D164 +1D16A 1D16C +1D183 1D184 +1D18C 1D1A9 +1D1AE 1D1DD +1D6C1 +1D6DB +1D6FB +1D715 +1D735 +1D74F +1D76F +1D789 +1D7A9 +1D7C3 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Sc.pl b/Master/xemtex/perl/lib/unicore/lib/Sc.pl new file mode 100644 index 00000000000..80d79b5d2f8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Sc.pl @@ -0,0 +1,24 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Sc} +# \p{Sc} (and fuzzy permutations) +# +# Meaning: General Category 'Sc' +# +return <<'END'; +0024 +00A2 00A5 +09F2 09F3 +0E3F +17DB +20A0 20B1 +FDFC +FE69 +FF04 +FFE0 FFE1 +FFE5 FFE6 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Sinhala.pl b/Master/xemtex/perl/lib/unicore/lib/Sinhala.pl new file mode 100644 index 00000000000..3288efe1fe7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Sinhala.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Sinhala} (and fuzzy permutations) +# +# Meaning: Script 'SINHALA' +# +return <<'END'; +0D82 0D83 SINHALA +0D85 0D96 SINHALA +0D9A 0DB1 SINHALA +0DB3 0DBB SINHALA +0DBD SINHALA +0DC0 0DC6 SINHALA +0DCA SINHALA +0DCF 0DD4 SINHALA +0DD6 SINHALA +0DD8 0DDF SINHALA +0DF2 0DF3 SINHALA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Sk.pl b/Master/xemtex/perl/lib/unicore/lib/Sk.pl new file mode 100644 index 00000000000..19ff8b02686 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Sk.pl @@ -0,0 +1,35 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Sk} +# \p{Sk} (and fuzzy permutations) +# +# Meaning: General Category 'Sk' +# +return <<'END'; +005E +0060 +00A8 +00AF +00B4 +00B8 +02B9 02BA +02C2 02CF +02D2 02DF +02E5 02ED +0374 0375 +0384 0385 +1FBD +1FBF 1FC1 +1FCD 1FCF +1FDD 1FDF +1FED 1FEF +1FFD 1FFE +309B 309C +FF3E +FF40 +FFE3 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Sm.pl b/Master/xemtex/perl/lib/unicore/lib/Sm.pl new file mode 100644 index 00000000000..8e55e4efe66 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Sm.pl @@ -0,0 +1,71 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Sm} +# \p{Sm} (and fuzzy permutations) +# +# Meaning: General Category 'Sm' +# +return <<'END'; +002B +003C 003E +007C +007E +00AC +00B1 +00D7 +00F7 +03F6 +2044 +2052 +207A 207C +208A 208C +2140 2144 +214B +2190 2194 +219A 219B +21A0 +21A3 +21A6 +21AE +21CE 21CF +21D2 +21D4 +21F4 22FF +2308 230B +2320 2321 +237C +239B 23B3 +25B7 +25C1 +25F8 25FF +266F +27D0 27E5 +27F0 27FF +2900 2982 +2999 29D7 +29DC 29FB +29FE 2AFF +FB29 +FE62 +FE64 FE66 +FF0B +FF1C FF1E +FF5C +FF5E +FFE2 +FFE9 FFEC +1D6C1 +1D6DB +1D6FB +1D715 +1D735 +1D74F +1D76F +1D789 +1D7A9 +1D7C3 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/So.pl b/Master/xemtex/perl/lib/unicore/lib/So.pl new file mode 100644 index 00000000000..1ef7acc99cf --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/So.pl @@ -0,0 +1,117 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{So} +# \p{So} (and fuzzy permutations) +# +# Meaning: General Category 'So' +# +return <<'END'; +00A6 00A7 +00A9 +00AE +00B0 +00B6 +0482 +06E9 +06FD 06FE +09FA +0B70 +0F01 0F03 +0F13 0F17 +0F1A 0F1F +0F34 +0F36 +0F38 +0FBE 0FC5 +0FC7 0FCC +0FCF +2100 2101 +2103 2106 +2108 2109 +2114 +2116 2118 +211E 2123 +2125 +2127 +2129 +212E +2132 +213A +214A +2195 2199 +219C 219F +21A1 21A2 +21A4 21A5 +21A7 21AD +21AF 21CD +21D0 21D1 +21D3 +21D5 21F3 +2300 2307 +230C 231F +2322 2328 +232B 237B +237D 239A +23B7 23CE +2400 2426 +2440 244A +249C 24E9 +2500 25B6 +25B8 25C0 +25C2 25F7 +2600 2613 +2616 2617 +2619 266E +2670 267D +2680 2689 +2701 2704 +2706 2709 +270C 2727 +2729 274B +274D +274F 2752 +2756 +2758 275E +2761 2767 +2794 +2798 27AF +27B1 27BE +2800 28FF +2E80 2E99 +2E9B 2EF3 +2F00 2FD5 +2FF0 2FFB +3004 +3012 3013 +3020 +3036 3037 +303E 303F +3190 3191 +3196 319F +3200 321C +322A 3243 +3260 327B +327F +328A 32B0 +32C0 32CB +32D0 32FE +3300 3376 +337B 33DD +33E0 33FE +A490 A4C6 +FFE4 +FFE8 +FFED FFEE +FFFC FFFD +1D000 1D0F5 +1D100 1D126 +1D12A 1D164 +1D16A 1D16C +1D183 1D184 +1D18C 1D1A9 +1D1AE 1D1DD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/SoftDott.pl b/Master/xemtex/perl/lib/unicore/lib/SoftDott.pl new file mode 100644 index 00000000000..b36e6756572 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/SoftDott.pl @@ -0,0 +1,19 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{SoftDotted} (and fuzzy permutations) +# +# Meaning: Extended property 'Soft_Dotted' +# +return <<'END'; +0069 006A Soft_Dotted +012F Soft_Dotted +0268 Soft_Dotted +0456 Soft_Dotted +0458 Soft_Dotted +1E2D Soft_Dotted +1ECB Soft_Dotted +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Space.pl b/Master/xemtex/perl/lib/unicore/lib/Space.pl new file mode 100644 index 00000000000..868c88c5449 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Space.pl @@ -0,0 +1,21 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Space} +# +# Meaning: [[:Space:]] +# +return <<'END'; +0009 000D +0020 +00A0 +1680 +2000 200B +2028 2029 +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/SpacePer.pl b/Master/xemtex/perl/lib/unicore/lib/SpacePer.pl new file mode 100644 index 00000000000..bf1cdcbbc15 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/SpacePer.pl @@ -0,0 +1,23 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{SpacePerl} +# +# Meaning: \s +# +return <<'END'; +0009 000A +000C 000D +0020 +0085 +00A0 +1680 +2000 200B +2028 2029 +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Syriac.pl b/Master/xemtex/perl/lib/unicore/lib/Syriac.pl new file mode 100644 index 00000000000..d78a76db792 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Syriac.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Syriac} (and fuzzy permutations) +# +# Meaning: Script 'SYRIAC' +# +return <<'END'; +0710 072C SYRIAC +0730 074A SYRIAC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Tagalog.pl b/Master/xemtex/perl/lib/unicore/lib/Tagalog.pl new file mode 100644 index 00000000000..78ab346469a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Tagalog.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Tagalog} (and fuzzy permutations) +# +# Meaning: Script 'TAGALOG' +# +return <<'END'; +1700 170C TAGALOG +170E 1714 TAGALOG +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Tagbanwa.pl b/Master/xemtex/perl/lib/unicore/lib/Tagbanwa.pl new file mode 100644 index 00000000000..a7ecbf2af6e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Tagbanwa.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Tagbanwa} (and fuzzy permutations) +# +# Meaning: Script 'TAGBANWA' +# +return <<'END'; +1760 176C TAGBANWA +176E 1770 TAGBANWA +1772 1773 TAGBANWA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Tamil.pl b/Master/xemtex/perl/lib/unicore/lib/Tamil.pl new file mode 100644 index 00000000000..b9777a33d5e --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Tamil.pl @@ -0,0 +1,28 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Tamil} (and fuzzy permutations) +# +# Meaning: Script 'TAMIL' +# +return <<'END'; +0B82 0B83 TAMIL +0B85 0B8A TAMIL +0B8E 0B90 TAMIL +0B92 0B95 TAMIL +0B99 0B9A TAMIL +0B9C TAMIL +0B9E 0B9F TAMIL +0BA3 0BA4 TAMIL +0BA8 0BAA TAMIL +0BAE 0BB5 TAMIL +0BB7 0BB9 TAMIL +0BBE 0BC2 TAMIL +0BC6 0BC8 TAMIL +0BCA 0BCD TAMIL +0BD7 TAMIL +0BE7 0BF2 TAMIL +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Telugu.pl b/Master/xemtex/perl/lib/unicore/lib/Telugu.pl new file mode 100644 index 00000000000..1c161eb9e57 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Telugu.pl @@ -0,0 +1,24 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Telugu} (and fuzzy permutations) +# +# Meaning: Script 'TELUGU' +# +return <<'END'; +0C01 0C03 TELUGU +0C05 0C0C TELUGU +0C0E 0C10 TELUGU +0C12 0C28 TELUGU +0C2A 0C33 TELUGU +0C35 0C39 TELUGU +0C3E 0C44 TELUGU +0C46 0C48 TELUGU +0C4A 0C4D TELUGU +0C55 0C56 TELUGU +0C60 0C61 TELUGU +0C66 0C6F TELUGU +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Terminal.pl b/Master/xemtex/perl/lib/unicore/lib/Terminal.pl new file mode 100644 index 00000000000..d7606867ce8 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Terminal.pl @@ -0,0 +1,48 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{TerminalPunctuation} (and fuzzy permutations) +# +# Meaning: Extended property 'Terminal_Punctuation' +# +return <<'END'; +0021 Terminal_Punctuation +002C Terminal_Punctuation +002E Terminal_Punctuation +003A 003B Terminal_Punctuation +003F Terminal_Punctuation +037E Terminal_Punctuation +0387 Terminal_Punctuation +0589 Terminal_Punctuation +060C Terminal_Punctuation +061B Terminal_Punctuation +061F Terminal_Punctuation +06D4 Terminal_Punctuation +0700 070A Terminal_Punctuation +070C Terminal_Punctuation +0964 0965 Terminal_Punctuation +0E5A 0E5B Terminal_Punctuation +104A 104B Terminal_Punctuation +1361 1368 Terminal_Punctuation +166D 166E Terminal_Punctuation +16EB 16ED Terminal_Punctuation +17D4 17D6 Terminal_Punctuation +17DA Terminal_Punctuation +1802 1805 Terminal_Punctuation +1808 1809 Terminal_Punctuation +203C 203D Terminal_Punctuation +2048 2049 Terminal_Punctuation +3001 3002 Terminal_Punctuation +FE50 FE52 Terminal_Punctuation +FE54 FE57 Terminal_Punctuation +FF01 Terminal_Punctuation +FF0C Terminal_Punctuation +FF0E Terminal_Punctuation +FF1A FF1B Terminal_Punctuation +FF1F Terminal_Punctuation +FF61 Terminal_Punctuation +FF64 Terminal_Punctuation +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Thaana.pl b/Master/xemtex/perl/lib/unicore/lib/Thaana.pl new file mode 100644 index 00000000000..9c2be21b40f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Thaana.pl @@ -0,0 +1,13 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Thaana} (and fuzzy permutations) +# +# Meaning: Script 'THAANA' +# +return <<'END'; +0780 07B1 THAANA +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Thai.pl b/Master/xemtex/perl/lib/unicore/lib/Thai.pl new file mode 100644 index 00000000000..b09ced7a7ac --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Thai.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Thai} (and fuzzy permutations) +# +# Meaning: Script 'THAI' +# +return <<'END'; +0E01 0E3A THAI +0E40 0E4E THAI +0E50 0E59 THAI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Tibetan.pl b/Master/xemtex/perl/lib/unicore/lib/Tibetan.pl new file mode 100644 index 00000000000..cdf7d5b2015 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Tibetan.pl @@ -0,0 +1,25 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Tibetan} (and fuzzy permutations) +# +# Meaning: Script 'TIBETAN' +# +return <<'END'; +0F00 TIBETAN +0F18 0F19 TIBETAN +0F20 0F33 TIBETAN +0F35 TIBETAN +0F37 TIBETAN +0F39 TIBETAN +0F40 0F47 TIBETAN +0F49 0F6A TIBETAN +0F71 0F84 TIBETAN +0F86 0F8B TIBETAN +0F90 0F97 TIBETAN +0F99 0FBC TIBETAN +0FC6 TIBETAN +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Title.pl b/Master/xemtex/perl/lib/unicore/lib/Title.pl new file mode 100644 index 00000000000..a1d03207447 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Title.pl @@ -0,0 +1,22 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Title} +# +# Meaning: [[:Title:]] +# +return <<'END'; +01C5 +01C8 +01CB +01F2 +1F88 1F8F +1F98 1F9F +1FA8 1FAF +1FBC +1FCC +1FFC +END diff --git a/Master/xemtex/perl/lib/unicore/lib/UnifiedI.pl b/Master/xemtex/perl/lib/unicore/lib/UnifiedI.pl new file mode 100644 index 00000000000..5e4019a7069 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/UnifiedI.pl @@ -0,0 +1,22 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{UnifiedIdeograph} (and fuzzy permutations) +# +# Meaning: Extended property 'Unified_Ideograph' +# +return <<'END'; +3400 4DB5 Unified_Ideograph +4E00 9FA5 Unified_Ideograph +FA0E FA0F Unified_Ideograph +FA11 Unified_Ideograph +FA13 FA14 Unified_Ideograph +FA1F Unified_Ideograph +FA21 Unified_Ideograph +FA23 FA24 Unified_Ideograph +FA27 FA29 Unified_Ideograph +20000 2A6D6 Unified_Ideograph +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Upper.pl b/Master/xemtex/perl/lib/unicore/lib/Upper.pl new file mode 100644 index 00000000000..d3350db9b94 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Upper.pl @@ -0,0 +1,431 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Upper} +# +# Meaning: [[:Upper:]] +# +return <<'END'; +0041 005A +00C0 00D6 +00D8 00DE +0100 +0102 +0104 +0106 +0108 +010A +010C +010E +0110 +0112 +0114 +0116 +0118 +011A +011C +011E +0120 +0122 +0124 +0126 +0128 +012A +012C +012E +0130 +0132 +0134 +0136 +0139 +013B +013D +013F +0141 +0143 +0145 +0147 +014A +014C +014E +0150 +0152 +0154 +0156 +0158 +015A +015C +015E +0160 +0162 +0164 +0166 +0168 +016A +016C +016E +0170 +0172 +0174 +0176 +0178 0179 +017B +017D +0181 0182 +0184 +0186 0187 +0189 018B +018E 0191 +0193 0194 +0196 0198 +019C 019D +019F 01A0 +01A2 +01A4 +01A6 01A7 +01A9 +01AC +01AE 01AF +01B1 01B3 +01B5 +01B7 01B8 +01BC +01C4 +01C7 +01CA +01CD +01CF +01D1 +01D3 +01D5 +01D7 +01D9 +01DB +01DE +01E0 +01E2 +01E4 +01E6 +01E8 +01EA +01EC +01EE +01F1 +01F4 +01F6 01F8 +01FA +01FC +01FE +0200 +0202 +0204 +0206 +0208 +020A +020C +020E +0210 +0212 +0214 +0216 +0218 +021A +021C +021E +0220 +0222 +0224 +0226 +0228 +022A +022C +022E +0230 +0232 +0386 +0388 038A +038C +038E 038F +0391 03A1 +03A3 03AB +03D2 03D4 +03D8 +03DA +03DC +03DE +03E0 +03E2 +03E4 +03E6 +03E8 +03EA +03EC +03EE +03F4 +0400 042F +0460 +0462 +0464 +0466 +0468 +046A +046C +046E +0470 +0472 +0474 +0476 +0478 +047A +047C +047E +0480 +048A +048C +048E +0490 +0492 +0494 +0496 +0498 +049A +049C +049E +04A0 +04A2 +04A4 +04A6 +04A8 +04AA +04AC +04AE +04B0 +04B2 +04B4 +04B6 +04B8 +04BA +04BC +04BE +04C0 04C1 +04C3 +04C5 +04C7 +04C9 +04CB +04CD +04D0 +04D2 +04D4 +04D6 +04D8 +04DA +04DC +04DE +04E0 +04E2 +04E4 +04E6 +04E8 +04EA +04EC +04EE +04F0 +04F2 +04F4 +04F8 +0500 +0502 +0504 +0506 +0508 +050A +050C +050E +0531 0556 +10A0 10C5 +1E00 +1E02 +1E04 +1E06 +1E08 +1E0A +1E0C +1E0E +1E10 +1E12 +1E14 +1E16 +1E18 +1E1A +1E1C +1E1E +1E20 +1E22 +1E24 +1E26 +1E28 +1E2A +1E2C +1E2E +1E30 +1E32 +1E34 +1E36 +1E38 +1E3A +1E3C +1E3E +1E40 +1E42 +1E44 +1E46 +1E48 +1E4A +1E4C +1E4E +1E50 +1E52 +1E54 +1E56 +1E58 +1E5A +1E5C +1E5E +1E60 +1E62 +1E64 +1E66 +1E68 +1E6A +1E6C +1E6E +1E70 +1E72 +1E74 +1E76 +1E78 +1E7A +1E7C +1E7E +1E80 +1E82 +1E84 +1E86 +1E88 +1E8A +1E8C +1E8E +1E90 +1E92 +1E94 +1EA0 +1EA2 +1EA4 +1EA6 +1EA8 +1EAA +1EAC +1EAE +1EB0 +1EB2 +1EB4 +1EB6 +1EB8 +1EBA +1EBC +1EBE +1EC0 +1EC2 +1EC4 +1EC6 +1EC8 +1ECA +1ECC +1ECE +1ED0 +1ED2 +1ED4 +1ED6 +1ED8 +1EDA +1EDC +1EDE +1EE0 +1EE2 +1EE4 +1EE6 +1EE8 +1EEA +1EEC +1EEE +1EF0 +1EF2 +1EF4 +1EF6 +1EF8 +1F08 1F0F +1F18 1F1D +1F28 1F2F +1F38 1F3F +1F48 1F4D +1F59 +1F5B +1F5D +1F5F +1F68 1F6F +1FB8 1FBB +1FC8 1FCB +1FD8 1FDB +1FE8 1FEC +1FF8 1FFB +2102 +2107 +210B 210D +2110 2112 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +2130 2131 +2133 +213E 213F +2145 +FF21 FF3A +10400 10425 +1D400 1D419 +1D434 1D44D +1D468 1D481 +1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B5 +1D4D0 1D4E9 +1D504 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D538 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D56C 1D585 +1D5A0 1D5B9 +1D5D4 1D5ED +1D608 1D621 +1D63C 1D655 +1D670 1D689 +1D6A8 1D6C0 +1D6E2 1D6FA +1D71C 1D734 +1D756 1D76E +1D790 1D7A8 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Uppercas.pl b/Master/xemtex/perl/lib/unicore/lib/Uppercas.pl new file mode 100644 index 00000000000..7f39ab9ee39 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Uppercas.pl @@ -0,0 +1,433 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Uppercase} (and fuzzy permutations) +# +# Meaning: [\p{Lu}\p{Other_Uppercase}] +# +return <<'END'; +0041 005A +00C0 00D6 +00D8 00DE +0100 +0102 +0104 +0106 +0108 +010A +010C +010E +0110 +0112 +0114 +0116 +0118 +011A +011C +011E +0120 +0122 +0124 +0126 +0128 +012A +012C +012E +0130 +0132 +0134 +0136 +0139 +013B +013D +013F +0141 +0143 +0145 +0147 +014A +014C +014E +0150 +0152 +0154 +0156 +0158 +015A +015C +015E +0160 +0162 +0164 +0166 +0168 +016A +016C +016E +0170 +0172 +0174 +0176 +0178 0179 +017B +017D +0181 0182 +0184 +0186 0187 +0189 018B +018E 0191 +0193 0194 +0196 0198 +019C 019D +019F 01A0 +01A2 +01A4 +01A6 01A7 +01A9 +01AC +01AE 01AF +01B1 01B3 +01B5 +01B7 01B8 +01BC +01C4 +01C7 +01CA +01CD +01CF +01D1 +01D3 +01D5 +01D7 +01D9 +01DB +01DE +01E0 +01E2 +01E4 +01E6 +01E8 +01EA +01EC +01EE +01F1 +01F4 +01F6 01F8 +01FA +01FC +01FE +0200 +0202 +0204 +0206 +0208 +020A +020C +020E +0210 +0212 +0214 +0216 +0218 +021A +021C +021E +0220 +0222 +0224 +0226 +0228 +022A +022C +022E +0230 +0232 +0386 +0388 038A +038C +038E 038F +0391 03A1 +03A3 03AB +03D2 03D4 +03D8 +03DA +03DC +03DE +03E0 +03E2 +03E4 +03E6 +03E8 +03EA +03EC +03EE +03F4 +0400 042F +0460 +0462 +0464 +0466 +0468 +046A +046C +046E +0470 +0472 +0474 +0476 +0478 +047A +047C +047E +0480 +048A +048C +048E +0490 +0492 +0494 +0496 +0498 +049A +049C +049E +04A0 +04A2 +04A4 +04A6 +04A8 +04AA +04AC +04AE +04B0 +04B2 +04B4 +04B6 +04B8 +04BA +04BC +04BE +04C0 04C1 +04C3 +04C5 +04C7 +04C9 +04CB +04CD +04D0 +04D2 +04D4 +04D6 +04D8 +04DA +04DC +04DE +04E0 +04E2 +04E4 +04E6 +04E8 +04EA +04EC +04EE +04F0 +04F2 +04F4 +04F8 +0500 +0502 +0504 +0506 +0508 +050A +050C +050E +0531 0556 +10A0 10C5 +1E00 +1E02 +1E04 +1E06 +1E08 +1E0A +1E0C +1E0E +1E10 +1E12 +1E14 +1E16 +1E18 +1E1A +1E1C +1E1E +1E20 +1E22 +1E24 +1E26 +1E28 +1E2A +1E2C +1E2E +1E30 +1E32 +1E34 +1E36 +1E38 +1E3A +1E3C +1E3E +1E40 +1E42 +1E44 +1E46 +1E48 +1E4A +1E4C +1E4E +1E50 +1E52 +1E54 +1E56 +1E58 +1E5A +1E5C +1E5E +1E60 +1E62 +1E64 +1E66 +1E68 +1E6A +1E6C +1E6E +1E70 +1E72 +1E74 +1E76 +1E78 +1E7A +1E7C +1E7E +1E80 +1E82 +1E84 +1E86 +1E88 +1E8A +1E8C +1E8E +1E90 +1E92 +1E94 +1EA0 +1EA2 +1EA4 +1EA6 +1EA8 +1EAA +1EAC +1EAE +1EB0 +1EB2 +1EB4 +1EB6 +1EB8 +1EBA +1EBC +1EBE +1EC0 +1EC2 +1EC4 +1EC6 +1EC8 +1ECA +1ECC +1ECE +1ED0 +1ED2 +1ED4 +1ED6 +1ED8 +1EDA +1EDC +1EDE +1EE0 +1EE2 +1EE4 +1EE6 +1EE8 +1EEA +1EEC +1EEE +1EF0 +1EF2 +1EF4 +1EF6 +1EF8 +1F08 1F0F +1F18 1F1D +1F28 1F2F +1F38 1F3F +1F48 1F4D +1F59 +1F5B +1F5D +1F5F +1F68 1F6F +1FB8 1FBB +1FC8 1FCB +1FD8 1FDB +1FE8 1FEC +1FF8 1FFB +2102 +2107 +210B 210D +2110 2112 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +2130 2131 +2133 +213E 213F +2145 +2160 216F +24B6 24CF +FF21 FF3A +10400 10425 +1D400 1D419 +1D434 1D44D +1D468 1D481 +1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B5 +1D4D0 1D4E9 +1D504 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D538 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D56C 1D585 +1D5A0 1D5B9 +1D5D4 1D5ED +1D608 1D621 +1D63C 1D655 +1D670 1D689 +1D6A8 1D6C0 +1D6E2 1D6FA +1D71C 1D734 +1D756 1D76E +1D790 1D7A8 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/WhiteSpa.pl b/Master/xemtex/perl/lib/unicore/lib/WhiteSpa.pl new file mode 100644 index 00000000000..8f05124ec30 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/WhiteSpa.pl @@ -0,0 +1,21 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{WhiteSpace} (and fuzzy permutations) +# +# Meaning: Extended property 'White_Space' +# +return <<'END'; +0009 000D White_Space +0020 White_Space +0085 White_Space +00A0 White_Space +1680 White_Space +2000 200A White_Space +2028 2029 White_Space +202F White_Space +3000 White_Space +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Word.pl b/Master/xemtex/perl/lib/unicore/lib/Word.pl new file mode 100644 index 00000000000..fcd8aa0f805 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Word.pl @@ -0,0 +1,424 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Word} +# +# Meaning: [[:Word:]] +# +return <<'END'; +0030 0039 +0041 005A +005F +0061 007A +00AA +00B2 00B3 +00B5 +00B9 00BA +00BC 00BE +00C0 00D6 +00D8 00F6 +00F8 0220 +0222 0233 +0250 02AD +02B0 02B8 +02BB 02C1 +02D0 02D1 +02E0 02E4 +02EE +0300 034F +0360 036F +037A +0386 +0388 038A +038C +038E 03A1 +03A3 03CE +03D0 03F5 +0400 0481 +0483 0486 +0488 04CE +04D0 04F5 +04F8 04F9 +0500 050F +0531 0556 +0559 +0561 0587 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +05D0 05EA +05F0 05F2 +0621 063A +0640 0655 +0660 0669 +066E 06D3 +06D5 06DC +06DE 06E8 +06EA 06ED +06F0 06FC +0710 072C +0730 074A +0780 07B1 +0901 0903 +0905 0939 +093C 094D +0950 0954 +0958 0963 +0966 096F +0981 0983 +0985 098C +098F 0990 +0993 09A8 +09AA 09B0 +09B2 +09B6 09B9 +09BC +09BE 09C4 +09C7 09C8 +09CB 09CD +09D7 +09DC 09DD +09DF 09E3 +09E6 09F1 +09F4 09F9 +0A02 +0A05 0A0A +0A0F 0A10 +0A13 0A28 +0A2A 0A30 +0A32 0A33 +0A35 0A36 +0A38 0A39 +0A3C +0A3E 0A42 +0A47 0A48 +0A4B 0A4D +0A59 0A5C +0A5E +0A66 0A74 +0A81 0A83 +0A85 0A8B +0A8D +0A8F 0A91 +0A93 0AA8 +0AAA 0AB0 +0AB2 0AB3 +0AB5 0AB9 +0ABC 0AC5 +0AC7 0AC9 +0ACB 0ACD +0AD0 +0AE0 +0AE6 0AEF +0B01 0B03 +0B05 0B0C +0B0F 0B10 +0B13 0B28 +0B2A 0B30 +0B32 0B33 +0B36 0B39 +0B3C 0B43 +0B47 0B48 +0B4B 0B4D +0B56 0B57 +0B5C 0B5D +0B5F 0B61 +0B66 0B6F +0B82 0B83 +0B85 0B8A +0B8E 0B90 +0B92 0B95 +0B99 0B9A +0B9C +0B9E 0B9F +0BA3 0BA4 +0BA8 0BAA +0BAE 0BB5 +0BB7 0BB9 +0BBE 0BC2 +0BC6 0BC8 +0BCA 0BCD +0BD7 +0BE7 0BF2 +0C01 0C03 +0C05 0C0C +0C0E 0C10 +0C12 0C28 +0C2A 0C33 +0C35 0C39 +0C3E 0C44 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0C60 0C61 +0C66 0C6F +0C82 0C83 +0C85 0C8C +0C8E 0C90 +0C92 0CA8 +0CAA 0CB3 +0CB5 0CB9 +0CBE 0CC4 +0CC6 0CC8 +0CCA 0CCD +0CD5 0CD6 +0CDE +0CE0 0CE1 +0CE6 0CEF +0D02 0D03 +0D05 0D0C +0D0E 0D10 +0D12 0D28 +0D2A 0D39 +0D3E 0D43 +0D46 0D48 +0D4A 0D4D +0D57 +0D60 0D61 +0D66 0D6F +0D82 0D83 +0D85 0D96 +0D9A 0DB1 +0DB3 0DBB +0DBD +0DC0 0DC6 +0DCA +0DCF 0DD4 +0DD6 +0DD8 0DDF +0DF2 0DF3 +0E01 0E3A +0E40 0E4E +0E50 0E59 +0E81 0E82 +0E84 +0E87 0E88 +0E8A +0E8D +0E94 0E97 +0E99 0E9F +0EA1 0EA3 +0EA5 +0EA7 +0EAA 0EAB +0EAD 0EB9 +0EBB 0EBD +0EC0 0EC4 +0EC6 +0EC8 0ECD +0ED0 0ED9 +0EDC 0EDD +0F00 +0F18 0F19 +0F20 0F33 +0F35 +0F37 +0F39 +0F3E 0F47 +0F49 0F6A +0F71 0F84 +0F86 0F8B +0F90 0F97 +0F99 0FBC +0FC6 +1000 1021 +1023 1027 +1029 102A +102C 1032 +1036 1039 +1040 1049 +1050 1059 +10A0 10C5 +10D0 10F8 +1100 1159 +115F 11A2 +11A8 11F9 +1200 1206 +1208 1246 +1248 +124A 124D +1250 1256 +1258 +125A 125D +1260 1286 +1288 +128A 128D +1290 12AE +12B0 +12B2 12B5 +12B8 12BE +12C0 +12C2 12C5 +12C8 12CE +12D0 12D6 +12D8 12EE +12F0 130E +1310 +1312 1315 +1318 131E +1320 1346 +1348 135A +1369 137C +13A0 13F4 +1401 166C +166F 1676 +1681 169A +16A0 16EA +16EE 16F0 +1700 170C +170E 1714 +1720 1734 +1740 1753 +1760 176C +176E 1770 +1772 1773 +1780 17D3 +17D7 +17DC +17E0 17E9 +180B 180D +1810 1819 +1820 1877 +1880 18A9 +1E00 1E9B +1EA0 1EF9 +1F00 1F15 +1F18 1F1D +1F20 1F45 +1F48 1F4D +1F50 1F57 +1F59 +1F5B +1F5D +1F5F 1F7D +1F80 1FB4 +1FB6 1FBC +1FBE +1FC2 1FC4 +1FC6 1FCC +1FD0 1FD3 +1FD6 1FDB +1FE0 1FEC +1FF2 1FF4 +1FF6 1FFC +2070 2071 +2074 2079 +207F 2089 +20D0 20EA +2102 +2107 +210A 2113 +2115 +2119 211D +2124 +2126 +2128 +212A 212D +212F 2131 +2133 2139 +213D 213F +2145 2149 +2153 2183 +2460 249B +24EA 24FE +2776 2793 +3005 3007 +3021 302F +3031 3035 +3038 303C +3041 3096 +3099 309A +309D 309F +30A1 30FA +30FC 30FF +3105 312C +3131 318E +3192 3195 +31A0 31B7 +31F0 31FF +3220 3229 +3251 325F +3280 3289 +32B1 32BF +3400 4DB5 +4E00 9FA5 +A000 A48C +AC00 D7A3 +F900 FA2D +FA30 FA6A +FB00 FB06 +FB13 FB17 +FB1D FB28 +FB2A FB36 +FB38 FB3C +FB3E +FB40 FB41 +FB43 FB44 +FB46 FBB1 +FBD3 FD3D +FD50 FD8F +FD92 FDC7 +FDF0 FDFB +FE00 FE0F +FE20 FE23 +FE70 FE74 +FE76 FEFC +FF10 FF19 +FF21 FF3A +FF41 FF5A +FF66 FFBE +FFC2 FFC7 +FFCA FFCF +FFD2 FFD7 +FFDA FFDC +10300 1031E +10320 10323 +10330 1034A +10400 10425 +10428 1044D +1D165 1D169 +1D16D 1D172 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +1D400 1D454 +1D456 1D49C +1D49E 1D49F +1D4A2 +1D4A5 1D4A6 +1D4A9 1D4AC +1D4AE 1D4B9 +1D4BB +1D4BD 1D4C0 +1D4C2 1D4C3 +1D4C5 1D505 +1D507 1D50A +1D50D 1D514 +1D516 1D51C +1D51E 1D539 +1D53B 1D53E +1D540 1D544 +1D546 +1D54A 1D550 +1D552 1D6A3 +1D6A8 1D6C0 +1D6C2 1D6DA +1D6DC 1D6FA +1D6FC 1D714 +1D716 1D734 +1D736 1D74E +1D750 1D76E +1D770 1D788 +1D78A 1D7A8 +1D7AA 1D7C2 +1D7C4 1D7C9 +1D7CE 1D7FF +20000 2A6D6 +2F800 2FA1D +END diff --git a/Master/xemtex/perl/lib/unicore/lib/XDigit.pl b/Master/xemtex/perl/lib/unicore/lib/XDigit.pl new file mode 100644 index 00000000000..6fe95d5c1ed --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/XDigit.pl @@ -0,0 +1,15 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{XDigit} +# +# Meaning: [[:XDigit:]] +# +return <<'END'; +0030 0039 +0041 0046 +0061 0066 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Yi.pl b/Master/xemtex/perl/lib/unicore/lib/Yi.pl new file mode 100644 index 00000000000..eb7131e801a --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Yi.pl @@ -0,0 +1,18 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Yi} (and fuzzy permutations) +# +# Meaning: Script 'YI' +# +return <<'END'; +A000 A48C YI +A490 A4A1 YI +A4A4 A4B3 YI +A4B5 A4C0 YI +A4C2 A4C4 YI +A4C6 YI +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Z.pl b/Master/xemtex/perl/lib/unicore/lib/Z.pl new file mode 100644 index 00000000000..751327e6922 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Z.pl @@ -0,0 +1,21 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Z} +# \p{Z} (and fuzzy permutations) +# +# Meaning: Major Category 'Z' +# +return <<'END'; +0020 +00A0 +1680 +2000 200B +2028 2029 +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Zl.pl b/Master/xemtex/perl/lib/unicore/lib/Zl.pl new file mode 100644 index 00000000000..db5580deb4f --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Zl.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Zl} +# \p{Zl} (and fuzzy permutations) +# +# Meaning: General Category 'Zl' +# +return <<'END'; +2028 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Zp.pl b/Master/xemtex/perl/lib/unicore/lib/Zp.pl new file mode 100644 index 00000000000..f7a4eb62a3b --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Zp.pl @@ -0,0 +1,14 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Zp} +# \p{Zp} (and fuzzy permutations) +# +# Meaning: General Category 'Zp' +# +return <<'END'; +2029 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/Zs.pl b/Master/xemtex/perl/lib/unicore/lib/Zs.pl new file mode 100644 index 00000000000..1c1b467a570 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/Zs.pl @@ -0,0 +1,20 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{Zs} +# \p{Zs} (and fuzzy permutations) +# +# Meaning: General Category 'Zs' +# +return <<'END'; +0020 +00A0 +1680 +2000 200B +202F +205F +3000 +END diff --git a/Master/xemtex/perl/lib/unicore/lib/_CanonDC.pl b/Master/xemtex/perl/lib/unicore/lib/_CanonDC.pl new file mode 100644 index 00000000000..3d627e7ed21 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/_CanonDC.pl @@ -0,0 +1,16 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{_CanonDCIJ} +# +# Meaning: (for internal casefolding use) +# +return <<'END'; +0069 006A +012F +1E2D +1ECB +END diff --git a/Master/xemtex/perl/lib/unicore/lib/_CaseIgn.pl b/Master/xemtex/perl/lib/unicore/lib/_CaseIgn.pl new file mode 100644 index 00000000000..dafa4a668f1 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/_CaseIgn.pl @@ -0,0 +1,118 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{_CaseIgnorable} +# +# Meaning: (for internal casefolding use) +# +return <<'END'; +00AD +0300 034F +0360 036F +0483 0486 +0591 05A1 +05A3 05B9 +05BB 05BD +05BF +05C1 05C2 +05C4 +064B 0655 +0670 +06D6 06DC +06DF 06E4 +06E7 06E8 +06EA 06ED +0711 +0730 074A +07A6 07B0 +0901 0902 +093C +0941 0948 +094D +0951 0954 +0962 0963 +0981 +09BC +09C1 09C4 +09CD +09E2 09E3 +0A02 +0A3C +0A41 0A42 +0A47 0A48 +0A4B 0A4D +0A70 0A71 +0A81 0A82 +0ABC +0AC1 0AC5 +0AC7 0AC8 +0ACD +0B01 +0B3C +0B3F +0B41 0B43 +0B4D +0B56 +0B82 +0BC0 +0BCD +0C3E 0C40 +0C46 0C48 +0C4A 0C4D +0C55 0C56 +0CBF +0CC6 +0CCC 0CCD +0D41 0D43 +0D4D +0DCA +0DD2 0DD4 +0DD6 +0E31 +0E34 0E3A +0E47 0E4E +0EB1 +0EB4 0EB9 +0EBB 0EBC +0EC8 0ECD +0F18 0F19 +0F35 +0F37 +0F39 +0F71 0F7E +0F80 0F84 +0F86 0F87 +0F90 0F97 +0F99 0FBC +0FC6 +102D 1030 +1032 +1036 1037 +1039 +1058 1059 +1712 1714 +1732 1734 +1752 1753 +1772 1773 +17B7 17BD +17C6 +17C9 17D3 +180B 180D +18A9 +2010 +20D0 20DC +20E1 +20E5 20EA +302A 302F +3099 309A +FB1E +FE00 FE0F +FE20 FE23 +1D167 1D169 +1D17B 1D182 +1D185 1D18B +1D1AA 1D1AD +END diff --git a/Master/xemtex/perl/lib/unicore/lib/_CombAbo.pl b/Master/xemtex/perl/lib/unicore/lib/_CombAbo.pl new file mode 100644 index 00000000000..de2c8e46ab7 --- /dev/null +++ b/Master/xemtex/perl/lib/unicore/lib/_CombAbo.pl @@ -0,0 +1,54 @@ +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by ./mktables from e.g. UnicodeData.txt. +# Any changes made here will be lost! + +# +# This file supports: +# \p{_CombAbove} +# +# Meaning: (for internal casefolding use) +# +return <<'END'; +0300 0314 +033D 0344 +0346 +034A 034C +0363 036F +0483 0486 +0592 0595 +0597 0599 +059C 05A1 +05A8 05A9 +05AB 05AC +05AF +05C4 +0653 0654 +06D6 06DC +06DF 06E2 +06E4 +06E7 06E8 +06EB 06EC +0730 +0732 0733 +0735 0736 +073A +073D +073F 0741 +0743 +0745 +0747 +0749 074A +0951 +0953 0954 +0F82 0F83 +0F86 0F87 +20D0 20D1 +20D4 20D7 +20DB 20DC +20E1 +20E7 +20E9 +FE20 FE23 +1D185 1D189 +1D1AA 1D1AD +END diff --git a/Master/xemtex/perl/lib/utf8.pm b/Master/xemtex/perl/lib/utf8.pm new file mode 100644 index 00000000000..5a37aecba87 --- /dev/null +++ b/Master/xemtex/perl/lib/utf8.pm @@ -0,0 +1,152 @@ +package utf8; + +$utf8::hint_bits = 0x00800000; + +our $VERSION = '1.00'; + +sub import { + $^H |= $utf8::hint_bits; + $enc{caller()} = $_[1] if $_[1]; +} + +sub unimport { + $^H &= ~$utf8::hint_bits; +} + +sub AUTOLOAD { + require "utf8_heavy.pl"; + goto &$AUTOLOAD if defined &$AUTOLOAD; + Carp::croak("Undefined subroutine $AUTOLOAD called"); +} + +1; +__END__ + +=head1 NAME + +utf8 - Perl pragma to enable/disable UTF-8 (or UTF-EBCDIC) in source code + +=head1 SYNOPSIS + + use utf8; + no utf8; + +=head1 DESCRIPTION + +The C<use utf8> pragma tells the Perl parser to allow UTF-8 in the +program text in the current lexical scope (allow UTF-EBCDIC on EBCDIC based +platforms). The C<no utf8> pragma tells Perl to switch back to treating +the source text as literal bytes in the current lexical scope. + +This pragma is primarily a compatibility device. Perl versions +earlier than 5.6 allowed arbitrary bytes in source code, whereas +in future we would like to standardize on the UTF-8 encoding for +source text. Until UTF-8 becomes the default format for source +text, this pragma should be used to recognize UTF-8 in the source. +When UTF-8 becomes the standard source format, this pragma will +effectively become a no-op. For convenience in what follows the +term I<UTF-X> is used to refer to UTF-8 on ASCII and ISO Latin based +platforms and UTF-EBCDIC on EBCDIC based platforms. + +Enabling the C<utf8> pragma has the following effect: + +=over 4 + +=item * + +Bytes in the source text that have their high-bit set will be treated +as being part of a literal UTF-8 character. This includes most +literals such as identifier names, string constants, and constant +regular expression patterns. + +On EBCDIC platforms characters in the Latin 1 character set are +treated as being part of a literal UTF-EBCDIC character. + +=back + +Note that if you have bytes with the eighth bit on in your script +(for example embedded Latin-1 in your string literals), C<use utf8> +will be unhappy since the bytes are most probably not well-formed +UTF-8. If you want to have such bytes and use utf8, you can disable +utf8 until the end the block (or file, if at top level) by C<no utf8;>. + +=head2 Utility functions + +The following functions are defined in the C<utf8::> package by the perl core. + +=over 4 + +=item * $num_octets = utf8::upgrade($string); + +Converts (in-place) internal representation of string to Perl's internal +I<UTF-X> form. Returns the number of octets necessary to represent +the string as I<UTF-X>. Can be used to make sure that the +UTF-8 flag is on, so that C<\w> or C<lc()> work as expected on strings +containing characters in the range 0x80-0xFF. Note that this should +not be used to convert +a legacy byte encoding to Unicode: use Encode for that. Affected +by the encoding pragma. + +=item * utf8::downgrade($string[, FAIL_OK]) + +Converts (in-place) internal representation of string to be un-encoded +bytes. Returns true on success. On failure dies or, if the value of +FAIL_OK is true, returns false. Can be used to make sure that the +UTF-8 flag is off, e.g. when you want to make sure that the substr() +or length() function works with the usually faster byte algorithm. +Note that this should not be used to convert Unicode back to a legacy +byte encoding: use Encode for that. B<Not> affected by the encoding +pragma. + +=item * utf8::encode($string) + +Converts (in-place) I<$string> from logical characters to octet +sequence representing it in Perl's I<UTF-X> encoding. Same as +Encode::encode_utf8(). Note that this should not be used to convert +a legacy byte encoding to Unicode: use Encode for that. + +=item * $flag = utf8::decode($string) + +Attempts to convert I<$string> in-place from Perl's I<UTF-X> encoding +into logical characters. Same as Encode::decode_utf8(). Note that this +should not be used to convert Unicode back to a legacy byte encoding: +use Encode for that. + +=item * $flag = utf8::valid(STRING) + +[INTERNAL] Test whether STRING is in a consistent state. Will return +true if string is held as bytes, or is well-formed UTF-8 and has the +UTF-8 flag on. Main reason for this routine is to allow Perl's +testsuite to check that operations have left strings in a consistent +state. + +=back + +C<utf8::encode> is like C<utf8::upgrade>, but the UTF8 flag is +cleared. See L<perlunicode> for more on the UTF8 flag and the C API +functions C<sv_utf8_upgrade>, C<sv_utf8_downgrade>, C<sv_utf8_encode>, +and C<sv_utf8_decode>, which are wrapped by the Perl functions +C<utf8::upgrade>, C<utf8::downgrade>, C<utf8::encode> and +C<utf8::decode>. Note that in the Perl 5.8.0 implementation the +functions utf8::valid, utf8::encode, utf8::decode, utf8::upgrade, +and utf8::downgrade are always available, without a C<require utf8> +statement-- this may change in future releases. + +=head1 BUGS + +One can have Unicode in identifier names, but not in package/class or +subroutine names. While some limited functionality towards this does +exist as of Perl 5.8.0, that is more accidental than designed; use of +Unicode for the said purposes is unsupported. + +One reason of this unfinishedness is its (currently) inherent +unportability: since both package names and subroutine names may need +to be mapped to file and directory names, the Unicode capability of +the filesystem becomes important-- and there unfortunately aren't +portable answers. + +=head1 SEE ALSO + +L<perlunicode>, L<bytes> + +=cut diff --git a/Master/xemtex/perl/lib/utf8_heavy.pl b/Master/xemtex/perl/lib/utf8_heavy.pl new file mode 100644 index 00000000000..1839d2144f1 --- /dev/null +++ b/Master/xemtex/perl/lib/utf8_heavy.pl @@ -0,0 +1,344 @@ +package utf8; +use strict; +use warnings; + +sub DEBUG () { 0 } + +sub DESTROY {} + +my %Cache; + +sub croak { require Carp; Carp::croak(@_) } + +## +## "SWASH" == "SWATCH HASH". A "swatch" is a swatch of the Unicode landscape +## + +sub SWASHNEW { + my ($class, $type, $list, $minbits, $none) = @_; + local $^D = 0 if $^D; + + print STDERR "SWASHNEW @_\n" if DEBUG; + + ## + ## Get the list of codepoints for the type. + ## Called from utf8.c + ## + ## Given a $type, our goal is to fill $list with the set of codepoint + ## ranges. + ## + ## To make the parsing of $type clear, this code takes the a rather + ## unorthadox approach of last'ing out of the block once we have the + ## info we need. Were this to be a subroutine, the 'last' would just + ## be a 'return'. + ## + my $file; ## file to load data from, and also part of the %Cache key. + my $ListSorted = 0; + + if ($type) + { + $type =~ s/^\s+//; + $type =~ s/\s+$//; + + print "type = $type\n" if DEBUG; + + GETFILE: + { + ## + ## 'Is' is always optional, so if it's there, remove it. + ## Same with 'Category=' and 'Script='. + ## + ## 'Block=' is replaced by 'In'. + ## + $type =~ s/^Is(?:\s+|[-_])?//i + or + $type =~ s/^Category\s*=\s*//i + or + $type =~ s/^Script\s*=\s*//i + or + $type =~ s/^Block\s*=\s*/In/i; + + ## + ## See if it's in the direct mapping table. + ## + require "unicore/Exact.pl"; + if (my $base = $utf8::Exact{$type}) { + $file = "unicore/lib/$base.pl"; + last GETFILE; + } + + ## + ## If not there exactly, try the canonical form. The canonical + ## form is lowercased, with any separators (\s+|[-_]) removed. + ## + my $canonical = lc $type; + $canonical =~ s/(?<=[a-z\d])(?:\s+|[-_])(?=[a-z\d])//g; + print "canonical = $canonical\n" if DEBUG; + + require "unicore/Canonical.pl"; + if (my $base = $utf8::Canonical{$canonical}) { + $file = "unicore/lib/$base.pl"; + last GETFILE; + } + + ## + ## It could be a user-defined property. + ## + + if ($type =~ /^I[ns](\w+)$/) { + my @caller = caller(1); + + if (defined $caller[0]) { + my $prop = $caller[0] . "::" . $type; + + if (exists &{$prop}) { + no strict 'refs'; + + $list = &{$prop}; + last GETFILE; + } + } + } + + ## + ## Last attempt -- see if it's a "To" name (e.g. "ToLower") + ## + if ($type =~ /^To([A-Z][A-Za-z]+)$/) + { + $file = "unicore/To/$1.pl"; + ## would like to test to see if $file actually exists.... + last GETFILE; + } + + ## + ## If we reach this line, it's because we couldn't figure + ## out what to do with $type. Ouch. + ## + + return $type; + } + + if (defined $file) { + print "found it (file='$file')\n" if DEBUG; + + ## + ## If we reach here, it was due to a 'last GETFILE' above + ## (exception: user-defined properties), so we + ## have a filename, so now we load it if we haven't already. + ## If we have, return the cached results. The cache key is the + ## file to load. + ## + if ($Cache{$file} and ref($Cache{$file}) eq $class) + { + print "Returning cached '$file' for \\p{$type}\n" if DEBUG; + return $Cache{$class, $file}; + } + + $list = do $file; + } + + $ListSorted = 1; ## we know that these lists are sorted + } + + my $extras; + my $bits; + + my $ORIG = $list; + if ($list) { + my @tmp = split(/^/m, $list); + my %seen; + no warnings; + $extras = join '', grep /^[^0-9a-fA-F]/, @tmp; + $list = join '', + sort { hex $a <=> hex $b } + grep {/^([0-9a-fA-F]+)/ and not $seen{$1}++} @tmp; # XXX doesn't do ranges right + } + + if ($none) { + my $hextra = sprintf "%04x", $none + 1; + $list =~ s/\tXXXX$/\t$hextra/mg; + } + + if ($minbits < 32) { + my $top = 0; + while ($list =~ /^([0-9a-fA-F]+)(?:\t([0-9a-fA-F]+)?)(?:\t([0-9a-fA-F]+))?/mg) { + my $min = hex $1; + my $max = hex(defined $2 ? $2 : $1); + my $val = hex(defined $3 ? $3 : ""); + $val += $max - $min if defined $3; + $top = $val if $val > $top; + } + $bits = + $top > 0xffff ? 32 : + $top > 0xff ? 16 : + $top > 1 ? 8 : 1 + } + $bits = $minbits if $bits < $minbits; + + my @extras; + for my $x ($extras) { + pos $x = 0; + while ($x =~ /^([^0-9a-fA-F\n])(.*)/mg) { + my $char = $1; + my $name = $2; + print STDERR "$1 => $2\n" if DEBUG; + if ($char =~ /[-+!]/) { + my ($c,$t) = split(/::/, $name, 2); # bogus use of ::, really + my $subobj; + if ($c eq 'utf8') { + $subobj = $c->SWASHNEW($t, "", 0, 0, 0); + } + elsif ($c =~ /^([0-9a-fA-F]+)/) { + $subobj = utf8->SWASHNEW("", $c, 0, 0, 0); + } + return $subobj unless ref $subobj; + push @extras, $name => $subobj; + $bits = $subobj->{BITS} if $bits < $subobj->{BITS}; + } + } + } + + print STDERR "CLASS = $class, TYPE => $type, BITS => $bits, NONE => $none\nEXTRAS =>\n$extras\nLIST =>\n$list\n" if DEBUG; + + my $SWASH = bless { + TYPE => $type, + BITS => $bits, + EXTRAS => $extras, + LIST => $list, + NONE => $none, + @extras, + } => $class; + + if ($file) { + $Cache{$class, $file} = $SWASH; + } + + return $SWASH; +} + +# NOTE: utf8.c:swash_init() assumes entries are never modified once generated. + +sub SWASHGET { + # See utf8.c:Perl_swash_fetch for problems with this interface. + my ($self, $start, $len) = @_; + local $^D = 0 if $^D; + my $type = $self->{TYPE}; + my $bits = $self->{BITS}; + my $none = $self->{NONE}; + print STDERR "SWASHGET @_ [$type/$bits/$none]\n" if DEBUG; + my $end = $start + $len; + my $swatch = ""; + my $key; + vec($swatch, $len - 1, $bits) = 0; # Extend to correct length. + if ($none) { + for $key (0 .. $len - 1) { vec($swatch, $key, $bits) = $none } + } + + for ($self->{LIST}) { + pos $_ = 0; + if ($bits > 1) { + LINE: + while (/^([0-9a-fA-F]+)(?:\t([0-9a-fA-F]+)?)(?:\t([0-9a-fA-F]+))?/mg) { + my $min = hex $1; + my $max = (defined $2 ? hex $2 : $min); + my $val = hex $3; + next if $max < $start; + print "$min $max $val\n" if DEBUG; + if ($none) { + if ($min < $start) { + $val += $start - $min if $val < $none; + $min = $start; + } + for ($key = $min; $key <= $max; $key++) { + last LINE if $key >= $end; + print STDERR "$key => $val\n" if DEBUG; + vec($swatch, $key - $start, $bits) = $val; + ++$val if $val < $none; + } + } + else { + if ($min < $start) { + $val += $start - $min; + $min = $start; + } + for ($key = $min; $key <= $max; $key++, $val++) { + last LINE if $key >= $end; + print STDERR "$key => $val\n" if DEBUG; + vec($swatch, $key - $start, $bits) = $val; + } + } + } + } + else { + LINE: + while (/^([0-9a-fA-F]+)(?:[ \t]+([0-9a-fA-F]+))?/mg) { + my $min = hex $1; + my $max = (defined $2 ? hex $2 : $min); + next if $max < $start; + if ($min < $start) { + $min = $start; + } + for ($key = $min; $key <= $max; $key++) { + last LINE if $key >= $end; + print STDERR "$key => 1\n" if DEBUG; + vec($swatch, $key - $start, 1) = 1; + } + } + } + } + for my $x ($self->{EXTRAS}) { + pos $x = 0; + while ($x =~ /^([-+!])(.*)/mg) { + my $char = $1; + my $name = $2; + print STDERR "INDIRECT $1 $2\n" if DEBUG; + my $otherbits = $self->{$name}->{BITS}; + croak("SWASHGET size mismatch") if $bits < $otherbits; + my $other = $self->{$name}->SWASHGET($start, $len); + if ($char eq '+') { + if ($bits == 1 and $otherbits == 1) { + $swatch |= $other; + } + else { + for ($key = 0; $key < $len; $key++) { + vec($swatch, $key, $bits) = vec($other, $key, $otherbits); + } + } + } + elsif ($char eq '!') { + if ($bits == 1 and $otherbits == 1) { + $swatch |= ~$other; + } + else { + for ($key = 0; $key < $len; $key++) { + if (!vec($other, $key, $otherbits)) { + vec($swatch, $key, $bits) = 1; + } + } + } + } + elsif ($char eq '-') { + if ($bits == 1 and $otherbits == 1) { + $swatch &= ~$other; + } + else { + for ($key = 0; $key < $len; $key++) { + if (vec($other, $key, $otherbits)) { + vec($swatch, $key, $bits) = 0; + } + } + } + } + } + } + if (DEBUG) { + print STDERR "CELLS "; + for ($key = 0; $key < $len; $key++) { + print STDERR vec($swatch, $key, $bits), " "; + } + print STDERR "\n"; + } + $swatch; +} + +1; diff --git a/Master/xemtex/perl/lib/vars.pm b/Master/xemtex/perl/lib/vars.pm new file mode 100644 index 00000000000..a0151b84030 --- /dev/null +++ b/Master/xemtex/perl/lib/vars.pm @@ -0,0 +1,82 @@ +package vars; + +use 5.006; + +our $VERSION = '1.01'; + +use warnings::register; +use strict qw(vars subs); + +sub import { + my $callpack = caller; + my ($pack, @imports) = @_; + my ($sym, $ch); + foreach (@imports) { + if (($ch, $sym) = /^([\$\@\%\*\&])(.+)/) { + if ($sym =~ /\W/) { + # time for a more-detailed check-up + if ($sym =~ /^\w+[[{].*[]}]$/) { + require Carp; + Carp::croak("Can't declare individual elements of hash or array"); + } elsif (warnings::enabled() and length($sym) == 1 and $sym !~ tr/a-zA-Z//) { + warnings::warn("No need to declare built-in vars"); + } elsif (($^H &= strict::bits('vars'))) { + require Carp; + Carp::croak("'$_' is not a valid variable name under strict vars"); + } + } + $sym = "${callpack}::$sym" unless $sym =~ /::/; + *$sym = + ( $ch eq "\$" ? \$$sym + : $ch eq "\@" ? \@$sym + : $ch eq "\%" ? \%$sym + : $ch eq "\*" ? \*$sym + : $ch eq "\&" ? \&$sym + : do { + require Carp; + Carp::croak("'$_' is not a valid variable name"); + }); + } else { + require Carp; + Carp::croak("'$_' is not a valid variable name"); + } + } +}; + +1; +__END__ + +=head1 NAME + +vars - Perl pragma to predeclare global variable names (obsolete) + +=head1 SYNOPSIS + + use vars qw($frob @mung %seen); + +=head1 DESCRIPTION + +NOTE: For variables in the current package, the functionality provided +by this pragma has been superseded by C<our> declarations, available +in Perl v5.6.0 or later. See L<perlfunc/our>. + +This will predeclare all the variables whose names are +in the list, allowing you to use them under "use strict", and +disabling any typo warnings. + +Unlike pragmas that affect the C<$^H> hints variable, the C<use vars> and +C<use subs> declarations are not BLOCK-scoped. They are thus effective +for the entire file in which they appear. You may not rescind such +declarations with C<no vars> or C<no subs>. + +Packages such as the B<AutoLoader> and B<SelfLoader> that delay +loading of subroutines within packages can create problems with +package lexicals defined using C<my()>. While the B<vars> pragma +cannot duplicate the effect of package lexicals (total transparency +outside of the package), it can act as an acceptable substitute by +pre-declaring global symbols, ensuring their availability to the +later-loaded routines. + +See L<perlmodlib/Pragmatic Modules>. + +=cut diff --git a/Master/xemtex/perl/lib/warnings.pm b/Master/xemtex/perl/lib/warnings.pm new file mode 100644 index 00000000000..8aa77482b20 --- /dev/null +++ b/Master/xemtex/perl/lib/warnings.pm @@ -0,0 +1,489 @@ + +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file was created by warnings.pl +# Any changes made here will be lost. +# + +package warnings; + +our $VERSION = '1.00'; + +=head1 NAME + +warnings - Perl pragma to control optional warnings + +=head1 SYNOPSIS + + use warnings; + no warnings; + + use warnings "all"; + no warnings "all"; + + use warnings::register; + if (warnings::enabled()) { + warnings::warn("some warning"); + } + + if (warnings::enabled("void")) { + warnings::warn("void", "some warning"); + } + + if (warnings::enabled($object)) { + warnings::warn($object, "some warning"); + } + + warnings::warnif("some warning"); + warnings::warnif("void", "some warning"); + warnings::warnif($object, "some warning"); + +=head1 DESCRIPTION + +If no import list is supplied, all possible warnings are either enabled +or disabled. + +A number of functions are provided to assist module authors. + +=over 4 + +=item use warnings::register + +Creates a new warnings category with the same name as the package where +the call to the pragma is used. + +=item warnings::enabled() + +Use the warnings category with the same name as the current package. + +Return TRUE if that warnings category is enabled in the calling module. +Otherwise returns FALSE. + +=item warnings::enabled($category) + +Return TRUE if the warnings category, C<$category>, is enabled in the +calling module. +Otherwise returns FALSE. + +=item warnings::enabled($object) + +Use the name of the class for the object reference, C<$object>, as the +warnings category. + +Return TRUE if that warnings category is enabled in the first scope +where the object is used. +Otherwise returns FALSE. + +=item warnings::warn($message) + +Print C<$message> to STDERR. + +Use the warnings category with the same name as the current package. + +If that warnings category has been set to "FATAL" in the calling module +then die. Otherwise return. + +=item warnings::warn($category, $message) + +Print C<$message> to STDERR. + +If the warnings category, C<$category>, has been set to "FATAL" in the +calling module then die. Otherwise return. + +=item warnings::warn($object, $message) + +Print C<$message> to STDERR. + +Use the name of the class for the object reference, C<$object>, as the +warnings category. + +If that warnings category has been set to "FATAL" in the scope where C<$object> +is first used then die. Otherwise return. + + +=item warnings::warnif($message) + +Equivalent to: + + if (warnings::enabled()) + { warnings::warn($message) } + +=item warnings::warnif($category, $message) + +Equivalent to: + + if (warnings::enabled($category)) + { warnings::warn($category, $message) } + +=item warnings::warnif($object, $message) + +Equivalent to: + + if (warnings::enabled($object)) + { warnings::warn($object, $message) } + +=back + +See L<perlmodlib/Pragmatic Modules> and L<perllexwarn>. + +=cut + +use Carp ; + +%Offsets = ( + + # Warnings Categories added in Perl 5.008 + + 'all' => 0, + 'closure' => 2, + 'deprecated' => 4, + 'exiting' => 6, + 'glob' => 8, + 'io' => 10, + 'closed' => 12, + 'exec' => 14, + 'layer' => 16, + 'newline' => 18, + 'pipe' => 20, + 'unopened' => 22, + 'misc' => 24, + 'numeric' => 26, + 'once' => 28, + 'overflow' => 30, + 'pack' => 32, + 'portable' => 34, + 'recursion' => 36, + 'redefine' => 38, + 'regexp' => 40, + 'severe' => 42, + 'debugging' => 44, + 'inplace' => 46, + 'internal' => 48, + 'malloc' => 50, + 'signal' => 52, + 'substr' => 54, + 'syntax' => 56, + 'ambiguous' => 58, + 'bareword' => 60, + 'digit' => 62, + 'parenthesis' => 64, + 'precedence' => 66, + 'printf' => 68, + 'prototype' => 70, + 'qw' => 72, + 'reserved' => 74, + 'semicolon' => 76, + 'taint' => 78, + 'threads' => 80, + 'uninitialized' => 82, + 'unpack' => 84, + 'untie' => 86, + 'utf8' => 88, + 'void' => 90, + 'y2k' => 92, + ); + +%Bits = ( + 'all' => "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15", # [0..46] + 'ambiguous' => "\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00", # [29] + 'bareword' => "\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00", # [30] + 'closed' => "\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [6] + 'closure' => "\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [1] + 'debugging' => "\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00", # [22] + 'deprecated' => "\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [2] + 'digit' => "\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00", # [31] + 'exec' => "\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [7] + 'exiting' => "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [3] + 'glob' => "\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [4] + 'inplace' => "\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00", # [23] + 'internal' => "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00", # [24] + 'io' => "\x00\x54\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [5..11] + 'layer' => "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [8] + 'malloc' => "\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00", # [25] + 'misc' => "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00", # [12] + 'newline' => "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [9] + 'numeric' => "\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00", # [13] + 'once' => "\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00", # [14] + 'overflow' => "\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00", # [15] + 'pack' => "\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00", # [16] + 'parenthesis' => "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00", # [32] + 'pipe' => "\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [10] + 'portable' => "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00", # [17] + 'precedence' => "\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00", # [33] + 'printf' => "\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00", # [34] + 'prototype' => "\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00", # [35] + 'qw' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00", # [36] + 'recursion' => "\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00", # [18] + 'redefine' => "\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00", # [19] + 'regexp' => "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00", # [20] + 'reserved' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00", # [37] + 'semicolon' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00", # [38] + 'severe' => "\x00\x00\x00\x00\x00\x54\x05\x00\x00\x00\x00\x00", # [21..25] + 'signal' => "\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00", # [26] + 'substr' => "\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00", # [27] + 'syntax' => "\x00\x00\x00\x00\x00\x00\x00\x55\x55\x15\x00\x00", # [28..38] + 'taint' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00", # [39] + 'threads' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00", # [40] + 'uninitialized' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00", # [41] + 'unopened' => "\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [11] + 'unpack' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00", # [42] + 'untie' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00", # [43] + 'utf8' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", # [44] + 'void' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04", # [45] + 'y2k' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10", # [46] + ); + +%DeadBits = ( + 'all' => "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\x2a", # [0..46] + 'ambiguous' => "\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00", # [29] + 'bareword' => "\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00", # [30] + 'closed' => "\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [6] + 'closure' => "\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [1] + 'debugging' => "\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00", # [22] + 'deprecated' => "\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [2] + 'digit' => "\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00", # [31] + 'exec' => "\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [7] + 'exiting' => "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [3] + 'glob' => "\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [4] + 'inplace' => "\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00", # [23] + 'internal' => "\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00", # [24] + 'io' => "\x00\xa8\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [5..11] + 'layer' => "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [8] + 'malloc' => "\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00", # [25] + 'misc' => "\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00", # [12] + 'newline' => "\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [9] + 'numeric' => "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00", # [13] + 'once' => "\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00", # [14] + 'overflow' => "\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00", # [15] + 'pack' => "\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00", # [16] + 'parenthesis' => "\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00", # [32] + 'pipe' => "\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [10] + 'portable' => "\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00", # [17] + 'precedence' => "\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00", # [33] + 'printf' => "\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00", # [34] + 'prototype' => "\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00", # [35] + 'qw' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00", # [36] + 'recursion' => "\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00", # [18] + 'redefine' => "\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00", # [19] + 'regexp' => "\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00", # [20] + 'reserved' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00", # [37] + 'semicolon' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00", # [38] + 'severe' => "\x00\x00\x00\x00\x00\xa8\x0a\x00\x00\x00\x00\x00", # [21..25] + 'signal' => "\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00", # [26] + 'substr' => "\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00", # [27] + 'syntax' => "\x00\x00\x00\x00\x00\x00\x00\xaa\xaa\x2a\x00\x00", # [28..38] + 'taint' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00", # [39] + 'threads' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00", # [40] + 'uninitialized' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00", # [41] + 'unopened' => "\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [11] + 'unpack' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00", # [42] + 'untie' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00", # [43] + 'utf8' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02", # [44] + 'void' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08", # [45] + 'y2k' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20", # [46] + ); + +$NONE = "\0\0\0\0\0\0\0\0\0\0\0\0"; +$LAST_BIT = 94 ; +$BYTES = 12 ; + +$All = "" ; vec($All, $Offsets{'all'}, 2) = 3 ; + +sub Croaker +{ + delete $Carp::CarpInternal{'warnings'}; + croak @_ ; +} + +sub bits +{ + # called from B::Deparse.pm + + push @_, 'all' unless @_; + + my $mask; + my $catmask ; + my $fatal = 0 ; + my $no_fatal = 0 ; + + foreach my $word ( @_ ) { + if ($word eq 'FATAL') { + $fatal = 1; + $no_fatal = 0; + } + elsif ($word eq 'NONFATAL') { + $fatal = 0; + $no_fatal = 1; + } + elsif ($catmask = $Bits{$word}) { + $mask |= $catmask ; + $mask |= $DeadBits{$word} if $fatal ; + $mask &= ~($DeadBits{$word}|$All) if $no_fatal ; + } + else + { Croaker("Unknown warnings category '$word'")} + } + + return $mask ; +} + +sub import +{ + shift; + + my $catmask ; + my $fatal = 0 ; + my $no_fatal = 0 ; + + my $mask = ${^WARNING_BITS} ; + + if (vec($mask, $Offsets{'all'}, 1)) { + $mask |= $Bits{'all'} ; + $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1); + } + + push @_, 'all' unless @_; + + foreach my $word ( @_ ) { + if ($word eq 'FATAL') { + $fatal = 1; + $no_fatal = 0; + } + elsif ($word eq 'NONFATAL') { + $fatal = 0; + $no_fatal = 1; + } + elsif ($catmask = $Bits{$word}) { + $mask |= $catmask ; + $mask |= $DeadBits{$word} if $fatal ; + $mask &= ~($DeadBits{$word}|$All) if $no_fatal ; + } + else + { Croaker("Unknown warnings category '$word'")} + } + + ${^WARNING_BITS} = $mask ; +} + +sub unimport +{ + shift; + + my $catmask ; + my $mask = ${^WARNING_BITS} ; + + if (vec($mask, $Offsets{'all'}, 1)) { + $mask |= $Bits{'all'} ; + $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1); + } + + push @_, 'all' unless @_; + + foreach my $word ( @_ ) { + if ($word eq 'FATAL') { + next; + } + elsif ($catmask = $Bits{$word}) { + $mask &= ~($catmask | $DeadBits{$word} | $All); + } + else + { Croaker("Unknown warnings category '$word'")} + } + + ${^WARNING_BITS} = $mask ; +} + +sub __chk +{ + my $category ; + my $offset ; + my $isobj = 0 ; + + if (@_) { + # check the category supplied. + $category = shift ; + if (ref $category) { + Croaker ("not an object") + if $category !~ /^([^=]+)=/ ; + $category = $1 ; + $isobj = 1 ; + } + $offset = $Offsets{$category}; + Croaker("Unknown warnings category '$category'") + unless defined $offset; + } + else { + $category = (caller(1))[0] ; + $offset = $Offsets{$category}; + Croaker("package '$category' not registered for warnings") + unless defined $offset ; + } + + my $this_pkg = (caller(1))[0] ; + my $i = 2 ; + my $pkg ; + + if ($isobj) { + while (do { { package DB; $pkg = (caller($i++))[0] } } ) { + last unless @DB::args && $DB::args[0] =~ /^$category=/ ; + } + $i -= 2 ; + } + else { + for ($i = 2 ; $pkg = (caller($i))[0] ; ++ $i) { + last if $pkg ne $this_pkg ; + } + $i = 2 + if !$pkg || $pkg eq $this_pkg ; + } + + my $callers_bitmask = (caller($i))[9] ; + return ($callers_bitmask, $offset, $i) ; +} + +sub enabled +{ + Croaker("Usage: warnings::enabled([category])") + unless @_ == 1 || @_ == 0 ; + + my ($callers_bitmask, $offset, $i) = __chk(@_) ; + + return 0 unless defined $callers_bitmask ; + return vec($callers_bitmask, $offset, 1) || + vec($callers_bitmask, $Offsets{'all'}, 1) ; +} + + +sub warn +{ + Croaker("Usage: warnings::warn([category,] 'message')") + unless @_ == 2 || @_ == 1 ; + + my $message = pop ; + my ($callers_bitmask, $offset, $i) = __chk(@_) ; + croak($message) + if vec($callers_bitmask, $offset+1, 1) || + vec($callers_bitmask, $Offsets{'all'}+1, 1) ; + carp($message) ; +} + +sub warnif +{ + Croaker("Usage: warnings::warnif([category,] 'message')") + unless @_ == 2 || @_ == 1 ; + + my $message = pop ; + my ($callers_bitmask, $offset, $i) = __chk(@_) ; + + return + unless defined $callers_bitmask && + (vec($callers_bitmask, $offset, 1) || + vec($callers_bitmask, $Offsets{'all'}, 1)) ; + + croak($message) + if vec($callers_bitmask, $offset+1, 1) || + vec($callers_bitmask, $Offsets{'all'}+1, 1) ; + + carp($message) ; +} + +1; diff --git a/Master/xemtex/perl/lib/warnings/register.pm b/Master/xemtex/perl/lib/warnings/register.pm new file mode 100644 index 00000000000..c5dc1999a03 --- /dev/null +++ b/Master/xemtex/perl/lib/warnings/register.pm @@ -0,0 +1,51 @@ +package warnings::register ; + +our $VERSION = '1.00'; + +=pod + +=head1 NAME + +warnings::register - warnings import function + +=head1 SYNOPSIS + + use warnings::register ; + +=head1 DESCRIPTION + +Create a warnings category with the same name as the current package. + +See L<perlmodlib/Pragmatic Modules> and L<perllexwarn>. + + +=cut + +require warnings ; + +sub mkMask +{ + my ($bit) = @_ ; + my $mask = "" ; + + vec($mask, $bit, 1) = 1 ; + return $mask ; +} + +sub import +{ + shift ; + my $package = (caller(0))[0] ; + if (! defined $warnings::Bits{$package}) { + $warnings::Bits{$package} = mkMask($warnings::LAST_BIT) ; + vec($warnings::Bits{'all'}, $warnings::LAST_BIT, 1) = 1 ; + $warnings::Offsets{$package} = $warnings::LAST_BIT ++ ; + foreach my $k (keys %warnings::Bits) { + vec($warnings::Bits{$k}, $warnings::LAST_BIT, 1) = 0 ; + } + $warnings::DeadBits{$package} = mkMask($warnings::LAST_BIT); + vec($warnings::DeadBits{'all'}, $warnings::LAST_BIT++, 1) = 1 ; + } +} + +1 ; |