Vendor import Perl 5.6.1

svn path=/vendor/perl5/dist/; revision=92444

contrib/perl5/Porting/repository.pod

@@ -0,0 +1,327 @@
+=head1 NAME
+
+repository - Using the Perl repository
+
+This document describes what a Perl Porter needs to do
+to start using the Perl repository.
+
+=head1 Prerequisites
+
+You'll need to get hold of the following software.
+
+=over 4
+
+=item Perforce
+
+Download a perforce client from:
+
+   http://www.perforce.com/perforce/loadprog.html
+
+You'll probably also want to look at:
+
+   http://www.perforce.com/perforce/technical.html
+
+where you can look at or download its documentation.
+
+=item ssh
+
+If you don't already have access to an ssh client, then look at its
+home site C<http://www.cs.hut.fi/ssh> which mentions ftp sites from
+which it's available. You only need to build the client parts (ssh
+and ssh-keygen should suffice).
+
+=back
+
+=head1 Creating an SSH Key Pair
+
+If you already use ssh and want to use the same key pair for perl
+repository access then you can skip the rest of this section.
+Otherwise, generate an ssh key pair for use with the repository
+by typing the command
+
+    ssh-keygen
+
+After generating a key pair and testing it, ssh-keygen will ask you
+to enter a filename in which to save the key. The default it offers
+will be the file F<~/.ssh/identity> which is suitable unless you
+particularly want to keep separate ssh identities for some reason.
+If so, you could save the perl repository private key in the file
+F<~/.ssh/perl>, for example, but I will use the standard filename
+in the remainder of the examples of this document.
+
+After typing in the filename, it will prompt you to type in a
+passphrase. The private key will itself be encrypted so that it is
+usable only when that passphrase is typed. (When using ssh, you will
+be prompted when it requires a pass phrase to unlock a private key.)
+If you provide a blank passphrase then no passphrase will be needed
+to unlock the key and, as a consequence, anyone who gains access to
+the key file gains access to accounts protected with that key
+(barring additional configuration to restrict access by IP address).
+
+When you have typed the passphrase in twice, ssh-keygen will confirm
+where it has saved the private key (in the filename you gave and
+with permissions set to be only readable by you), what your public
+key is (don't worry: you don't need to memorise it) and where it
+has saved the corresponding public key. The public key is saved in
+a filename corresponding to your private key's filename but with
+".pub" appended, usually F<~/.ssh/identity.pub>. That public key
+can be (but need not be) world readable. It is not used by your
+own system at all.
+
+=head1 Notifying the Repository Keeper
+
+Mail the contents of that public key file to the keeper of the perl
+repository (see L</Contact Information> below).
+When the key is added to the repository host's configuration file,
+you will be able to connect to it with ssh by using the corresponding
+private key file (after unlocking it with your chosen passphrase).
+
+=head1 Connecting to the Repository
+
+Connections to the repository are made by using ssh to provide a
+TCP "tunnel" rather than by using ssh to login to or invoke any
+ordinary commands on the repository. When you want to start a
+session using the repository, use the command
+
+    ssh -l perlrep -f -q -x -L 1666:127.0.0.1:1666 sickle.activestate.com 
+foo
+
+If you are not using the default filename of F<~/.ssh/identity>
+to hold your perl repository private key then you'll need to add
+the option B<-i filename> to tell ssh where it is. Unless you chose
+a blank passphrase for that private key, ssh will prompt you for the
+passphrase to unlock that key. Then ssh will fork and put itself
+in the background, returning you (silently) to your shell prompt.
+The tunnel for repository access is now ready for use.
+
+For the sake of completeness (and for the case where the chosen
+port of 1666 is already in use on your machine), I'll briefly
+describe what all those ssh arguments are for.
+
+=over 4
+
+=item B<-l perl>
+
+Use a remote username of perl. The account on the repository which
+provides the end-point of the ssh tunnel is named "perl".
+
+=item B<-f>
+
+Tells ssh to fork and remain running in the background. Since ssh
+is only being used for its tunnelling capabilities, the command
+that ssh runs never does any I/O and can sit silently in the
+background.
+
+=item B<-q>
+
+Tells ssh to be quiet. Without this option, ssh will output a
+message each time you use a p4 command (since each p4 command
+tunnels over the ssh connection to reach the repository).
+
+=item B<-x>
+
+Tells ssh not to bother to set up a tunnel for X11 connections.
+The repository doesn't allow this anyway.
+
+=item B<-L 1666:127.0.0.1:1666>
+
+This is the important option. It tells ssh to listen out for
+connections made to port 1666 on your local machine. When such
+a connection is made, the ssh client tells the remote side
+(the corresponding ssh daemon on the repository) to make a
+connection to IP address 127.0.0.1, port 1666. Data flowing
+along that connection is tunnelled over the ssh connection
+(encrypted). The perforce daemon running on the repository
+only accepts connections from localhost and that is exactly
+where ssh-tunnelled connections appear to come from.
+
+If port 1666 is already in use on your machine then you can
+choose any non-privileged port (a number between 1024 and 65535)
+which happens to be free on your machine. It's the first of the
+three colon separated values that you should change. Picking
+port 2345 would mean changing the option to
+B<-L 2345:127.0.0.1:1666>. Whatever port number you choose should
+be used for the value of the P4PORT environment variable (q.v.).
+
+=item sickle.activestate.com
+
+This is the canonical IP name of the host on which the perl
+repository runs. Its IP number is 199.60.48.20.
+
+=item foo
+
+This is a dummy place holder argument. Without an argument
+here, ssh will try to perform an interactive login to the
+repository which is not allowed. Ordinarily, this argument
+is for the one-off command which is to be executed on the
+remote host. However, the repository's ssh configuration
+file uses the "command=" option to force a particular
+command to run so the actual value of the argument is
+ignored. The command that's actually run merely pauses and
+waits for the ssh connection to drop, then exits.
+
+=back
+
+=head1 Problems
+
+You should normally get a prompt that asks for the passphrase
+for your RSA key when you connect with the ssh command shown
+above.  If you see a prompt that looks like:
+
+    perlrep@sickle.activestate.com's password:
+
+Then you either don't have a ~/.ssh/identity file corresponding
+to your public key, or your ~/.ssh/identity file is not readable.
+Fix the problem and try again.
+
+=head1 Using the Perforce Client
+
+Remember to read the documentation for Perforce. You need
+to make sure that three environment variable are set
+correctly before using the p4 client with the perl repository.
+
+=over 4
+
+=item P4PORT
+
+Set this to localhost:1666 (the port for your ssh client to listen on)
+unless that port is already in use on your host. If it is, see
+the section above on the B<-L 1666:127.0.0.1:1666> option to ssh.
+
+=item P4CLIENT
+
+The value of this is the name by which Perforce knows your
+host's workspace. You need to pick a name (for example, your
+hostname unless that clashes with someone else's client name)
+when you first start using the perl repository and then
+stick with it. If you connect from multiple hosts (with
+different workspaces) then maybe you could have multiple
+clients. There is a licence limit on the number of perforce
+clients which can be created. Although we have been told that
+Perforce will raise our licence limits within reason, it's
+probably best not to use additional clients unless needed.
+
+Note that perforce only needs the client name so that it can
+find the directory under which your client files are stored.
+If you have multiple hosts sharing the same directory structure
+via NFS then only one client name is necessary.
+
+The C<p4 clients> command lists all currently known clients.
+
+=item P4USER
+
+This is the username by which perforce knows you. Use your
+username if you have a well known or obvious one or else pick
+a new one which other perl5-porters will recognise. There is
+a licence limit on the number of these usernames. Perforce
+doesn't enforce security between usernames. If you set P4USER
+to be somebody else's username then perforce will believe you
+completely with regard to access control, logging and so on.
+
+The C<p4 users> command lists all currently known users.
+
+=back
+
+Once these three environment variables are set, you can use the
+perforce p4 client exactly as described in its documentation.
+After setting these variables and connecting to the repository
+for the first time, you should use the C<p4 user> and
+C<p4 client> commands to tell perforce the details of your
+new username and your new client workspace specifications.
+
+=head1 Ending a Repository Session
+
+When you have finished a session using the repository, you
+should kill off the ssh client process to break the tunnel.
+Since ssh forked itself into the background, you'll need to use
+something like ps with the appropriate options to find the ssh
+process and then kill it manually. The default signal of
+SIGTERM is fine.
+
+=head1 Overview of the Repository
+
+Please read at least the introductory sections of the Perforce
+User Guide (and perhaps the Quick Start Guide as well) before
+reading this section.
+
+Every repository user typically "owns" a "branch" of the mainline
+code in the repository.  They hold the "pumpkin" for things in this
+area, and are usually the only user who will modify files there.
+This is not strictly enforced in order to allow the flexibility
+of other users stealing the pumpkin for short periods with the
+owner's permission.
+
+Here is the current structure of the repository:
+
+    /----+-----perl                  - Mainline development (bleadperl)
+         +-----cfgperl               - Configure Pumpkin's Perl
+         +-----vmsperl               - VMS Pumpkin's Perl
+         +-----maint-5.004------perl - Maintainance branches
+         +-----maint-5.005------perl
+         +-----maint-5.6------perl
+
+Perforce uses a branching model that simply tracks relationships
+between files.  It does not care about directories at all, so
+any file can be a branch of any other file--the fully qualified
+depot path name (of the form //depot/foo/bar.c) uniquely determines
+a file for the purpose of establishing branching relationships.
+Since a branch usually involves hundreds of files, such relationships
+are typically specified en masse using a branch map (try `p4 help branch`).
+`p4 branches` lists the existing branches that have been set up.
+`p4 branch -o branchname` can be used to view the map for a particular
+branch, if you want to determine the ancestor for a particular set of
+files.
+
+The mainline (aka "trunk") code in the Perl repository is under
+"//depot/perl/...".  Most branches typically map its entire
+contents under a directory that goes by the same name as the branch
+name.  Thus the contents of the cfgperl branch are to be found
+in //depot/cfgperl.
+
+Run `p4 client` to specify how the repository contents should map to
+your local disk.  Most users will typically have a client map that
+includes at least their entire branch and the contents of the mainline.
+
+Run `p4 changes -l -m10` to check on the activity in the repository.
+//depot/perl/Porting/genlog is useful to get an annotated changelog
+that shows files and branches.  You can use this listing to determine
+if there are any changes in the mainline that you need to merge into
+your own branch.  A typical merging session looks like this:
+
+    % cd ~/p4view/cfgperl
+    % p4 integrate -b cfgperl    # to bring parent changes into cfgperl
+    % p4 resolve -a ./...        # auto merge the changes
+    % p4 resolve ./...           # manual merge conflicting changes
+    % p4 submit ./...            # check in
+
+If the owner of the mainline wants to bring the changes in cfgperl
+back into the mainline, they do:
+
+    % p4 integrate -r -b cfgperl
+    ...
+
+Generating a patch for change#42 is done as follows:
+
+    % p4 describe -du 42 | p4desc | p4d2p > change-42.patch
+
+p4desc and p4d2p are to be found in //depot/perl/Porting/.
+
+=head1 Contact Information
+
+The mail alias <perl-repository-keepers@perl.org> can be used to reach
+all current users of the repository.
+
+The repository keeper is currently Gurusamy Sarathy
+<gsar@activestate.com>.
+
+=head1 AUTHORS
+
+Malcolm Beattie, mbeattie@sable.ox.ac.uk, 24 June 1997.
+
+Gurusamy Sarathy, gsar@activestate.com, 8 May 1999.
+
+Slightly updated by Simon Cozens, simon@brecon.co.uk, 3 July 2000
+
+=cut
+
+

contrib/perl5/ext/B/B/Concise.pm

@@ -0,0 +1,823 @@
+package B::Concise;
+# Copyright (C) 2000, 2001 Stephen McCamant. All rights reserved.
+# This program is free software; you can redistribute and/or modify it
+# under the same terms as Perl itself.
+
+our $VERSION = "0.51";
+use strict;
+use B qw(class ppname main_start main_root main_cv cstring svref_2object
+	 SVf_IOK SVf_NOK SVf_POK OPf_KIDS);
+
+my %style = 
+  ("terse" =>
+   ["(?(#label =>\n)?)(*(    )*)#class (#addr) #name (?([#targ])?) "
+    . "#svclass~(?((#svaddr))?)~#svval~(?(label \"#coplabel\")?)\n",
+    "(*(    )*)goto #class (#addr)\n",
+    "#class pp_#name"],
+   "concise" =>
+   ["#hyphseq2 (*(   (x( ;)x))*)<#classsym> "
+    . "#exname#arg(?([#targarglife])?)~#flags(?(/#private)?)(x(;~->#next)x)\n",
+    "  (*(    )*)     goto #seq\n",
+    "(?(<#seq>)?)#exname#arg(?([#targarglife])?)"],
+   "linenoise" =>
+   ["(x(;(*( )*))x)#noise#arg(?([#targarg])?)(x( ;\n)x)",
+    "gt_#seq ",
+    "(?(#seq)?)#noise#arg(?([#targarg])?)"],
+   "debug" =>
+   ["#class (#addr)\n\top_next\t\t#nextaddr\n\top_sibling\t#sibaddr\n\t"
+    . "op_ppaddr\tPL_ppaddr[OP_#NAME]\n\top_type\t\t#typenum\n\top_seq\t\t"
+    . "#seqnum\n\top_flags\t#flagval\n\top_private\t#privval\n"
+    . "(?(\top_first\t#firstaddr\n)?)(?(\top_last\t\t#lastaddr\n)?)"
+    . "(?(\top_sv\t\t#svaddr\n)?)",
+    "    GOTO #addr\n",
+    "#addr"],
+   "env" => [$ENV{B_CONCISE_FORMAT}, $ENV{B_CONCISE_GOTO_FORMAT},
+	     $ENV{B_CONCISE_TREE_FORMAT}],
+  );
+
+my($format, $gotofmt, $treefmt);
+my $curcv;
+my($seq_base, $cop_seq_base);
+
+sub concise_cv {
+    my ($order, $cvref) = @_;
+    my $cv = svref_2object($cvref);
+    $curcv = $cv;
+    if ($order eq "exec") {
+	walk_exec($cv->START);
+    } elsif ($order eq "basic") {
+	walk_topdown($cv->ROOT, sub { $_[0]->concise($_[1]) }, 0);
+    } else {
+	print tree($cv->ROOT, 0)
+    }
+}
+
+my $start_sym = "\e(0"; # "\cN" sometimes also works
+my $end_sym   = "\e(B"; # "\cO" respectively
+
+my @tree_decorations = 
+  (["  ", "--", "+-", "|-", "| ", "`-", "-", 1],
+   [" ", "-", "+", "+", "|", "`", "", 0],
+   ["  ", map("$start_sym$_$end_sym", "qq", "wq", "tq", "x ", "mq", "q"), 1],
+   [" ", map("$start_sym$_$end_sym", "q", "w", "t", "x", "m"), "", 0],
+  );
+my $tree_style = 0;
+
+my $base = 36;
+my $big_endian = 1;
+
+my $order = "basic";
+
+sub compile {
+    my @options = grep(/^-/, @_);
+    my @args = grep(!/^-/, @_);
+    my $do_main = 0;
+    ($format, $gotofmt, $treefmt) = @{$style{"concise"}};
+    for my $o (@options) {
+	if ($o eq "-basic") {
+	    $order = "basic";
+	} elsif ($o eq "-exec") {
+	    $order = "exec";
+	} elsif ($o eq "-tree") {
+	    $order = "tree";
+	} elsif ($o eq "-compact") {
+	    $tree_style |= 1;
+	} elsif ($o eq "-loose") {
+	    $tree_style &= ~1;
+	} elsif ($o eq "-vt") {
+	    $tree_style |= 2;
+	} elsif ($o eq "-ascii") {
+	    $tree_style &= ~2;
+	} elsif ($o eq "-main") {
+	    $do_main = 1;
+	} elsif ($o =~ /^-base(\d+)$/) {
+	    $base = $1;
+	} elsif ($o eq "-bigendian") {
+	    $big_endian = 1;
+	} elsif ($o eq "-littleendian") {
+	    $big_endian = 0;
+	} elsif (exists $style{substr($o, 1)}) {
+	    ($format, $gotofmt, $treefmt) = @{$style{substr($o, 1)}};
+	} else {
+	    warn "Option $o unrecognized";
+	}
+    }
+    if (@args) {
+	return sub {
+	    for my $objname (@args) {
+		$objname = "main::" . $objname unless $objname =~ /::/;
+		eval "concise_cv(\$order, \\&$objname)";
+		die "concise_cv($order, \\&$objname) failed: $@" if $@;
+	    }
+	}
+    }
+    if (!@args or $do_main) {
+	if ($order eq "exec") {
+	    return sub { return if class(main_start) eq "NULL";
+			 $curcv = main_cv;
+			 walk_exec(main_start) }
+	} elsif ($order eq "tree") {
+	    return sub { return if class(main_root) eq "NULL";
+			 $curcv = main_cv;
+			 print tree(main_root, 0) }
+	} elsif ($order eq "basic") {
+	    return sub { return if class(main_root) eq "NULL";
+			 $curcv = main_cv;
+			 walk_topdown(main_root,
+				      sub { $_[0]->concise($_[1]) }, 0); }
+	}
+    }
+}
+
+my %labels;
+my $lastnext;
+
+my %opclass = ('OP' => "0", 'UNOP' => "1", 'BINOP' => "2", 'LOGOP' => "|",
+	       'LISTOP' => "@", 'PMOP' => "/", 'SVOP' => "\$", 'GVOP' => "*",
+	       'PVOP' => '"', 'LOOP' => "{", 'COP' => ";");
+
+my @linenoise =
+  qw'#  () sc (  @? 1  $* gv *{ m$ m@ m% m? p/ *$ $  $# & a& pt \\ s\\ rf bl
+     `  *? <> ?? ?/ r/ c/ // qr s/ /c y/ =  @= C  sC Cp sp df un BM po +1 +I
+     -1 -I 1+ I+ 1- I- ** *  i* /  i/ %$ i% x  +  i+ -  i- .  "  << >> <  i<
+     >  i> <= i, >= i. == i= != i! <? i? s< s> s, s. s= s! s? b& b^ b| -0 -i
+     !  ~  a2 si cs rd sr e^ lg sq in %x %o ab le ss ve ix ri sf FL od ch cy
+     uf lf uc lc qm @  [f [  @[ eh vl ky dl ex %  ${ @{ uk pk st jn )  )[ a@
+     a% sl +] -] [- [+ so rv GS GW MS MW .. f. .f && || ^^ ?: &= |= -> s{ s}
+     v} ca wa di rs ;; ;  ;d }{ {  }  {} f{ it {l l} rt }l }n }r dm }g }e ^o
+     ^c ^| ^# um bm t~ u~ ~d DB db ^s se ^g ^r {w }w pf pr ^O ^K ^R ^W ^d ^v
+     ^e ^t ^k t. fc ic fl .s .p .b .c .l .a .h g1 s1 g2 s2 ?. l? -R -W -X -r
+     -w -x -e -o -O -z -s -M -A -C -S -c -b -f -d -p -l -u -g -k -t -T -B cd
+     co cr u. cm ut r. l@ s@ r@ mD uD oD rD tD sD wD cD f$ w$ p$ sh e$ k$ g3
+     g4 s4 g5 s5 T@ C@ L@ G@ A@ S@ Hg Hc Hr Hw Mg Mc Ms Mr Sg Sc So rq do {e
+     e} {t t} g6 G6 6e g7 G7 7e g8 G8 8e g9 G9 9e 6s 7s 8s 9s 6E 7E 8E 9E Pn
+     Pu GP SP EP Gn Gg GG SG EG g0 c$ lk t$ ;s n>';
+
+my $chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+sub op_flags {
+    my($x) = @_;
+    my(@v);
+    push @v, "v" if ($x & 3) == 1;
+    push @v, "s" if ($x & 3) == 2;
+    push @v, "l" if ($x & 3) == 3;
+    push @v, "K" if $x & 4;
+    push @v, "P" if $x & 8;
+    push @v, "R" if $x & 16;
+    push @v, "M" if $x & 32;
+    push @v, "S" if $x & 64;
+    push @v, "*" if $x & 128;
+    return join("", @v);
+}
+
+sub base_n {
+    my $x = shift;
+    return "-" . base_n(-$x) if $x < 0;
+    my $str = "";
+    do { $str .= substr($chars, $x % $base, 1) } while $x = int($x / $base);
+    $str = reverse $str if $big_endian;
+    return $str;
+}
+
+sub seq { return $_[0]->seq ? base_n($_[0]->seq - $seq_base) : "-" }
+
+sub walk_topdown {
+    my($op, $sub, $level) = @_;
+    $sub->($op, $level);
+    if ($op->flags & OPf_KIDS) {
+	for (my $kid = $op->first; $$kid; $kid = $kid->sibling) {
+	    walk_topdown($kid, $sub, $level + 1);
+	}
+    }
+    if (class($op) eq "PMOP" and $ {$op->pmreplroot}
+	and $op->pmreplroot->isa("B::OP")) {
+	walk_topdown($op->pmreplroot, $sub, $level + 1);
+    }
+}
+
+sub walklines {
+    my($ar, $level) = @_;
+    for my $l (@$ar) {
+	if (ref($l) eq "ARRAY") {
+	    walklines($l, $level + 1);
+	} else {
+	    $l->concise($level);
+	}
+    }
+}
+
+sub walk_exec {
+    my($top, $level) = @_;
+    my %opsseen;
+    my @lines;
+    my @todo = ([$top, \@lines]);
+    while (@todo and my($op, $targ) = @{shift @todo}) {
+	for (; $$op; $op = $op->next) {
+	    last if $opsseen{$$op}++;
+	    push @$targ, $op;
+	    my $name = $op->name;
+	    if ($name
+		=~ /^(or|and|(map|grep)while|entertry|range|cond_expr)$/) {
+		my $ar = [];
+		push @$targ, $ar;
+		push @todo, [$op->other, $ar];
+	    } elsif ($name eq "subst" and $ {$op->pmreplstart}) {
+		my $ar = [];
+		push @$targ, $ar;
+		push @todo, [$op->pmreplstart, $ar];
+	    } elsif ($name =~ /^enter(loop|iter)$/) {
+		$labels{$op->nextop->seq} = "NEXT";
+		$labels{$op->lastop->seq} = "LAST";
+		$labels{$op->redoop->seq} = "REDO";		
+	    }
+	}
+    }
+    walklines(\@lines, 0);
+}
+
+sub fmt_line {
+    my($hr, $fmt, $level) = @_;
+    my $text = $fmt;
+    $text =~ s/\(\?\(([^\#]*?)\#(\w+)([^\#]*?)\)\?\)/
+      $hr->{$2} ? $1.$hr->{$2}.$3 : ""/eg;
+    $text =~ s/\(x\((.*?);(.*?)\)x\)/$order eq "exec" ? $1 : $2/egs;
+    $text =~ s/\(\*\(([^;]*?)\)\*\)/$1 x $level/egs;
+    $text =~ s/\(\*\((.*?);(.*?)\)\*\)/$1 x ($level - 1) . $2 x ($level>0)/egs;
+    $text =~ s/#([a-zA-Z]+)(\d+)/sprintf("%-$2s", $hr->{$1})/eg;
+    $text =~ s/#([a-zA-Z]+)/$hr->{$1}/eg;
+    $text =~ s/[ \t]*~+[ \t]*/ /g;
+    return $text;
+}
+
+my %priv;
+$priv{$_}{128} = "LVINTRO"
+  for ("pos", "substr", "vec", "threadsv", "gvsv", "rv2sv", "rv2hv", "rv2gv",
+       "rv2av", "rv2arylen", "aelem", "helem", "aslice", "hslice", "padsv",
+       "padav", "padhv");
+$priv{$_}{64} = "REFC" for ("leave", "leavesub", "leavesublv", "leavewrite");
+$priv{"aassign"}{64} = "COMMON";
+$priv{"aassign"}{32} = "PHASH";
+$priv{"sassign"}{64} = "BKWARD";
+$priv{$_}{64} = "RTIME" for ("match", "subst", "substcont");
+@{$priv{"trans"}}{1,2,4,8,16,64} = ("<UTF", ">UTF", "IDENT", "SQUASH", "DEL",
+				    "COMPL", "GROWS");
+$priv{"repeat"}{64} = "DOLIST";
+$priv{"leaveloop"}{64} = "CONT";
+@{$priv{$_}}{32,64,96} = ("DREFAV", "DREFHV", "DREFSV")
+  for ("entersub", map("rv2${_}v", "a", "s", "h", "g"), "aelem", "helem");
+$priv{"entersub"}{16} = "DBG";
+$priv{"entersub"}{32} = "TARG";
+@{$priv{$_}}{4,8,128} = ("INARGS","AMPER","NO()") for ("entersub", "rv2cv");
+$priv{"gv"}{32} = "EARLYCV";
+$priv{"aelem"}{16} = $priv{"helem"}{16} = "LVDEFER";
+$priv{$_}{16} = "OURINTR" for ("gvsv", "rv2sv", "rv2av", "rv2hv", "r2gv");
+$priv{$_}{16} = "TARGMY"
+  for (map(($_,"s$_"),"chop", "chomp"),
+       map(($_,"i_$_"), "postinc", "postdec", "multiply", "divide", "modulo",
+	   "add", "subtract", "negate"), "pow", "concat", "stringify",
+       "left_shift", "right_shift", "bit_and", "bit_xor", "bit_or",
+       "complement", "atan2", "sin", "cos", "rand", "exp", "log", "sqrt",
+       "int", "hex", "oct", "abs", "length", "index", "rindex", "sprintf",
+       "ord", "chr", "crypt", "quotemeta", "join", "push", "unshift", "flock",
+       "chdir", "chown", "chroot", "unlink", "chmod", "utime", "rename",
+       "link", "symlink", "mkdir", "rmdir", "wait", "waitpid", "system",
+       "exec", "kill", "getppid", "getpgrp", "setpgrp", "getpriority",
+       "setpriority", "time", "sleep");
+@{$priv{"const"}}{8,16,32,64,128} = ("STRICT","ENTERED", "$[", "BARE", "WARN");
+$priv{"flip"}{64} = $priv{"flop"}{64} = "LINENUM";
+$priv{"list"}{64} = "GUESSED";
+$priv{"delete"}{64} = "SLICE";
+$priv{"exists"}{64} = "SUB";
+$priv{$_}{64} = "LOCALE"
+  for ("sort", "prtf", "sprintf", "slt", "sle", "seq", "sne", "sgt", "sge",
+       "scmp", "lc", "uc", "lcfirst", "ucfirst");
+@{$priv{"sort"}}{1,2,4} = ("NUM", "INT", "REV");
+$priv{"threadsv"}{64} = "SVREFd";
+$priv{$_}{16} = "INBIN" for ("open", "backtick");
+$priv{$_}{32} = "INCR" for ("open", "backtick");
+$priv{$_}{64} = "OUTBIN" for ("open", "backtick");
+$priv{$_}{128} = "OUTCR" for ("open", "backtick");
+$priv{"exit"}{128} = "VMS";
+
+sub private_flags {
+    my($name, $x) = @_;
+    my @s;
+    for my $flag (128, 96, 64, 32, 16, 8, 4, 2, 1) {
+	if ($priv{$name}{$flag} and $x & $flag and $x >= $flag) {
+	    $x -= $flag;
+	    push @s, $priv{$name}{$flag};
+	}
+    }
+    push @s, $x if $x;
+    return join(",", @s);
+}
+
+sub concise_op {
+    my ($op, $level, $format) = @_;
+    my %h;
+    $h{exname} = $h{name} = $op->name;
+    $h{NAME} = uc $h{name};
+    $h{class} = class($op);
+    $h{extarg} = $h{targ} = $op->targ;
+    $h{extarg} = "" unless $h{extarg};
+    if ($h{name} eq "null" and $h{targ}) {
+	$h{exname} = "ex-" . substr(ppname($h{targ}), 3);
+	$h{extarg} = "";
+    } elsif ($h{targ}) {
+	my $padname = (($curcv->PADLIST->ARRAY)[0]->ARRAY)[$h{targ}];
+	if (defined $padname and class($padname) ne "SPECIAL") {
+	    $h{targarg}  = $padname->PVX;
+	    my $intro = $padname->NVX - $cop_seq_base;
+	    my $finish = int($padname->IVX) - $cop_seq_base;
+	    $finish = "end" if $finish == 999999999 - $cop_seq_base;
+	    $h{targarglife} = "$h{targarg}:$intro,$finish";
+	} else {
+	    $h{targarglife} = $h{targarg} = "t" . $h{targ};
+	}
+    }
+    $h{arg} = "";
+    $h{svclass} = $h{svaddr} = $h{svval} = "";
+    if ($h{class} eq "PMOP") {
+	my $precomp = $op->precomp;
+	$precomp = defined($precomp) ? "/$precomp/" : "";
+	my $pmreplroot = $op->pmreplroot;
+	my ($pmreplroot, $pmreplstart);
+	if ($ {$pmreplroot = $op->pmreplroot} && $pmreplroot->isa("B::GV")) {
+	    # with C<@stash_array = split(/pat/, str);>,
+	    #  *stash_array is stored in pmreplroot.
+	    $h{arg} = "($precomp => \@" . $pmreplroot->NAME . ")";
+	} elsif ($ {$op->pmreplstart}) {
+	    undef $lastnext;
+	    $pmreplstart = "replstart->" . seq($op->pmreplstart);
+	    $h{arg} = "(" . join(" ", $precomp, $pmreplstart) . ")";
+	} else {
+	    $h{arg} = "($precomp)";
+	}
+    } elsif ($h{class} eq "PVOP" and $h{name} ne "trans") {
+	$h{arg} = '("' . $op->pv . '")';
+	$h{svval} = '"' . $op->pv . '"';
+    } elsif ($h{class} eq "COP") {
+	my $label = $op->label;
+	$h{coplabel} = $label;
+	$label = $label ? "$label: " : "";
+	my $loc = $op->file;
+	$loc =~ s[.*/][];
+	$loc .= ":" . $op->line;
+	my($stash, $cseq) = ($op->stash->NAME, $op->cop_seq - $cop_seq_base);
+	my $arybase = $op->arybase;
+	$arybase = $arybase ? ' $[=' . $arybase : "";
+	$h{arg} = "($label$stash $cseq $loc$arybase)";
+    } elsif ($h{class} eq "LOOP") {
+	$h{arg} = "(next->" . seq($op->nextop) . " last->" . seq($op->lastop)
+	  . " redo->" . seq($op->redoop) . ")";
+    } elsif ($h{class} eq "LOGOP") {
+	undef $lastnext;
+	$h{arg} = "(other->" . seq($op->other) . ")";
+    } elsif ($h{class} eq "SVOP") {
+	my $sv = $op->sv;
+	$h{svclass} = class($sv);
+	$h{svaddr} = sprintf("%#x", $$sv);
+	if ($h{svclass} eq "GV") {
+	    my $gv = $sv;
+	    my $stash = $gv->STASH->NAME;
+	    if ($stash eq "main") {
+		$stash = "";
+	    } else {
+		$stash = $stash . "::";
+	    }
+	    $h{arg} = "(*$stash" . $gv->SAFENAME . ")";
+	    $h{svval} = "*$stash" . $gv->SAFENAME;
+	} else {
+	    while (class($sv) eq "RV") {
+		$h{svval} .= "\\";
+		$sv = $sv->RV;
+	    }
+	    if (class($sv) eq "SPECIAL") {
+		$h{svval} = ["Null", "sv_undef", "sv_yes", "sv_no"]->[$$sv];
+	    } elsif ($sv->FLAGS & SVf_NOK) {
+		$h{svval} = $sv->NV;
+	    } elsif ($sv->FLAGS & SVf_IOK) {
+		$h{svval} = $sv->IV;
+	    } elsif ($sv->FLAGS & SVf_POK) {
+		$h{svval} = cstring($sv->PV);
+	    }
+	    $h{arg} = "($h{svclass} $h{svval})";
+	}
+    }
+    $h{seq} = $h{hyphseq} = seq($op);
+    $h{seq} = "" if $h{seq} eq "-";
+    $h{seqnum} = $op->seq;
+    $h{next} = $op->next;
+    $h{next} = (class($h{next}) eq "NULL") ? "(end)" : seq($h{next});
+    $h{nextaddr} = sprintf("%#x", $ {$op->next});
+    $h{sibaddr} = sprintf("%#x", $ {$op->sibling});
+    $h{firstaddr} = sprintf("%#x", $ {$op->first}) if $op->can("first");
+    $h{lastaddr} = sprintf("%#x", $ {$op->last}) if $op->can("last");
+
+    $h{classsym} = $opclass{$h{class}};
+    $h{flagval} = $op->flags;
+    $h{flags} = op_flags($op->flags);
+    $h{privval} = $op->private;
+    $h{private} = private_flags($h{name}, $op->private);
+    $h{addr} = sprintf("%#x", $$op);
+    $h{label} = $labels{$op->seq};
+    $h{typenum} = $op->type;
+    $h{noise} = $linenoise[$op->type];
+    return fmt_line(\%h, $format, $level);
+}
+
+sub B::OP::concise {
+    my($op, $level) = @_;
+    if ($order eq "exec" and $lastnext and $$lastnext != $$op) {
+	my $h = {"seq" => seq($lastnext), "class" => class($lastnext),
+		 "addr" => sprintf("%#x", $$lastnext)};
+	print fmt_line($h, $gotofmt, $level+1);
+    }
+    $lastnext = $op->next;
+    print concise_op($op, $level, $format);
+}
+
+sub tree {
+    my $op = shift;
+    my $level = shift;
+    my $style = $tree_decorations[$tree_style];
+    my($space, $single, $kids, $kid, $nokid, $last, $lead, $size) = @$style;
+    my $name = concise_op($op, $level, $treefmt);
+    if (not $op->flags & OPf_KIDS) {
+	return $name . "\n";
+    }
+    my @lines;
+    for (my $kid = $op->first; $$kid; $kid = $kid->sibling) {
+	push @lines, tree($kid, $level+1);
+    }
+    my $i;
+    for ($i = $#lines; substr($lines[$i], 0, 1) eq " "; $i--) {
+	$lines[$i] = $space . $lines[$i];
+    }
+    if ($i > 0) {
+	$lines[$i] = $last . $lines[$i];
+	while ($i-- > 1) {
+	    if (substr($lines[$i], 0, 1) eq " ") {
+		$lines[$i] = $nokid . $lines[$i];
+	    } else {
+		$lines[$i] = $kid . $lines[$i];		
+	    }
+	}
+	$lines[$i] = $kids . $lines[$i];
+    } else {
+	$lines[0] = $single . $lines[0];
+    }
+    return("$name$lead" . shift @lines,
+           map(" " x (length($name)+$size) . $_, @lines));
+}
+
+# This is a bit of a hack; the 2 and 15 were determined empirically.
+# These need to stay the last things in the module.
+$cop_seq_base = svref_2object(eval 'sub{0;}')->START->cop_seq + 2;
+$seq_base = svref_2object(eval 'sub{}')->START->seq + 15;
+
+1;
+
+__END__
+
+=head1 NAME
+
+B::Concise - Walk Perl syntax tree, printing concise info about ops
+
+=head1 SYNOPSIS
+
+    perl -MO=Concise[,OPTIONS] foo.pl
+
+=head1 DESCRIPTION
+
+This compiler backend prints the internal OPs of a Perl program's syntax
+tree in one of several space-efficient text formats suitable for debugging
+the inner workings of perl or other compiler backends. It can print OPs in
+the order they appear in the OP tree, in the order they will execute, or
+in a text approximation to their tree structure, and the format of the
+information displyed is customizable. Its function is similar to that of
+perl's B<-Dx> debugging flag or the B<B::Terse> module, but it is more
+sophisticated and flexible.
+
+=head1 OPTIONS
+
+Arguments that don't start with a hyphen are taken to be the names of
+subroutines to print the OPs of; if no such functions are specified, the
+main body of the program (outside any subroutines, and not including use'd
+or require'd files) is printed.
+
+=over 4
+
+=item B<-basic>
+
+Print OPs in the order they appear in the OP tree (a preorder
+traversal, starting at the root). The indentation of each OP shows its
+level in the tree.  This mode is the default, so the flag is included
+simply for completeness.
+
+=item B<-exec>
+
+Print OPs in the order they would normally execute (for the majority
+of constructs this is a postorder traversal of the tree, ending at the
+root). In most cases the OP that usually follows a given OP will
+appear directly below it; alternate paths are shown by indentation. In
+cases like loops when control jumps out of a linear path, a 'goto'
+line is generated.
+
+=item B<-tree>
+
+Print OPs in a text approximation of a tree, with the root of the tree
+at the left and 'left-to-right' order of children transformed into
+'top-to-bottom'. Because this mode grows both to the right and down,
+it isn't suitable for large programs (unless you have a very wide
+terminal).
+
+=item B<-compact>
+
+Use a tree format in which the minimum amount of space is used for the
+lines connecting nodes (one character in most cases). This squeezes out
+a few precious columns of screen real estate.
+
+=item B<-loose>
+
+Use a tree format that uses longer edges to separate OP nodes. This format
+tends to look better than the compact one, especially in ASCII, and is
+the default.
+
+=item B<-vt>
+
+Use tree connecting characters drawn from the VT100 line-drawing set.
+This looks better if your terminal supports it.
+
+=item B<-ascii>
+
+Draw the tree with standard ASCII characters like C<+> and C<|>. These don't
+look as clean as the VT100 characters, but they'll work with almost any
+terminal (or the horizontal scrolling mode of less(1)) and are suitable
+for text documentation or email. This is the default.
+
+=item B<-main>
+
+Include the main program in the output, even if subroutines were also
+specified.
+
+=item B<-base>I<n>
+
+Print OP sequence numbers in base I<n>. If I<n> is greater than 10, the
+digit for 11 will be 'a', and so on. If I<n> is greater than 36, the digit
+for 37 will be 'A', and so on until 62. Values greater than 62 are not
+currently supported. The default is 36.
+
+=item B<-bigendian>
+
+Print sequence numbers with the most significant digit first. This is the
+usual convention for Arabic numerals, and the default.
+
+=item B<-littleendian>
+
+Print seqence numbers with the least significant digit first.
+
+=item B<-concise>
+
+Use the author's favorite set of formatting conventions. This is the
+default, of course.
+
+=item B<-terse>
+
+Use formatting conventions that emulate the ouput of B<B::Terse>. The
+basic mode is almost indistinguishable from the real B<B::Terse>, and the
+exec mode looks very similar, but is in a more logical order and lacks
+curly brackets. B<B::Terse> doesn't have a tree mode, so the tree mode
+is only vaguely reminiscient of B<B::Terse>.
+
+=item B<-linenoise>
+
+Use formatting conventions in which the name of each OP, rather than being
+written out in full, is represented by a one- or two-character abbreviation.
+This is mainly a joke.
+
+=item B<-debug>
+
+Use formatting conventions reminiscient of B<B::Debug>; these aren't
+very concise at all.
+
+=item B<-env>
+
+Use formatting conventions read from the environment variables
+C<B_CONCISE_FORMAT>, C<B_CONCISE_GOTO_FORMAT>, and C<B_CONCISE_TREE_FORMAT>.
+
+=back
+
+=head1 FORMATTING SPECIFICATIONS
+
+For each general style ('concise', 'terse', 'linenoise', etc.) there are
+three specifications: one of how OPs should appear in the basic or exec
+modes, one of how 'goto' lines should appear (these occur in the exec
+mode only), and one of how nodes should appear in tree mode. Each has the
+same format, described below. Any text that doesn't match a special
+pattern is copied verbatim.
+
+=over 4
+
+=item B<(x(>I<exec_text>B<;>I<basic_text>B<)x)>
+
+Generates I<exec_text> in exec mode, or I<basic_text> in basic mode.
+
+=item B<(*(>I<text>B<)*)>
+
+Generates one copy of I<text> for each indentation level.
+
+=item B<(*(>I<text1>B<;>I<text2>B<)*)>
+
+Generates one fewer copies of I<text1> than the indentation level, followed
+by one copy of I<text2> if the indentation level is more than 0.
+
+=item B<(?(>I<text1>B<#>I<var>I<Text2>B<)?)>
+
+If the value of I<var> is true (not empty or zero), generates the
+value of I<var> surrounded by I<text1> and I<Text2>, otherwise
+nothing.
+
+=item B<#>I<var>
+
+Generates the value of the variable I<var>.
+
+=item B<#>I<var>I<N>
+
+Generates the value of I<var>, left jutified to fill I<N> spaces.
+
+=item B<~>
+
+Any number of tildes and surrounding whitespace will be collapsed to
+a single space.
+
+=back
+
+The following variables are recognized:
+
+=over 4
+
+=item B<#addr>
+
+The address of the OP, in hexidecimal.
+
+=item B<#arg>
+
+The OP-specific information of the OP (such as the SV for an SVOP, the
+non-local exit pointers for a LOOP, etc.) enclosed in paretheses.
+
+=item B<#class>
+
+The B-determined class of the OP, in all caps.
+
+=item B<#classym>
+
+A single symbol abbreviating the class of the OP.
+
+=item B<#coplabel>
+
+The label of the statement or block the OP is the start of, if any.
+
+=item B<#exname>
+
+The name of the OP, or 'ex-foo' if the OP is a null that used to be a foo.
+
+=item B<#extarg>
+
+The target of the OP, or nothing for a nulled OP.
+
+=item B<#firstaddr>
+
+The address of the OP's first child, in hexidecimal.
+
+=item B<#flags>
+
+The OP's flags, abbreviated as a series of symbols.
+
+=item B<#flagval>
+
+The numeric value of the OP's flags.
+
+=item B<#hyphenseq>
+
+The sequence number of the OP, or a hyphen if it doesn't have one.
+
+=item B<#label>
+
+'NEXT', 'LAST', or 'REDO' if the OP is a target of one of those in exec
+mode, or empty otherwise.
+
+=item B<#lastaddr>
+
+The address of the OP's last child, in hexidecimal.
+
+=item B<#name>
+
+The OP's name.
+
+=item B<#NAME>
+
+The OP's name, in all caps.
+
+=item B<#next>
+
+The sequence number of the OP's next OP.
+
+=item B<#nextaddr>
+
+The address of the OP's next OP, in hexidecimal.
+
+=item B<#noise>
+
+The two-character abbreviation for the OP's name.
+
+=item B<#private>
+
+The OP's private flags, rendered with abbreviated names if possible.
+
+=item B<#privval>
+
+The numeric value of the OP's private flags.
+
+=item B<#seq>
+
+The sequence number of the OP.
+
+=item B<#seqnum>
+
+The real sequence number of the OP, as a regular number and not adjusted
+to be relative to the start of the real program. (This will generally be
+a fairly large number because all of B<B::Concise> is compiled before
+your program is).
+
+=item B<#sibaddr>
+
+The address of the OP's next youngest sibling, in hexidecimal.
+
+=item B<#svaddr>
+
+The address of the OP's SV, if it has an SV, in hexidecimal.
+
+=item B<#svclass>
+
+The class of the OP's SV, if it has one, in all caps (e.g., 'IV').
+
+=item B<#svval>
+
+The value of the OP's SV, if it has one, in a short human-readable format.
+
+=item B<#targ>
+
+The numeric value of the OP's targ.
+
+=item B<#targarg>
+
+The name of the variable the OP's targ refers to, if any, otherwise the
+letter t followed by the OP's targ in decimal.
+
+=item B<#targarglife>
+
+Same as B<#targarg>, but followed by the COP sequence numbers that delimit
+the variable's lifetime (or 'end' for a variable in an open scope) for a
+variable.
+
+=item B<#typenum>
+
+The numeric value of the OP's type, in decimal.
+
+=back
+
+=head1 ABBREVIATIONS
+
+=head2 OP flags abbreviations
+
+    v      OPf_WANT_VOID    Want nothing (void context)
+    s      OPf_WANT_SCALAR  Want single value (scalar context)
+    l      OPf_WANT_LIST    Want list of any length (list context)
+    K      OPf_KIDS         There is a firstborn child.
+    P      OPf_PARENS       This operator was parenthesized.
+                             (Or block needs explicit scope entry.)
+    R      OPf_REF          Certified reference.
+                             (Return container, not containee).
+    M      OPf_MOD          Will modify (lvalue).
+    S      OPf_STACKED      Some arg is arriving on the stack.
+    *      OPf_SPECIAL      Do something weird for this op (see op.h)
+
+=head2 OP class abbreviations
+
+    0      OP (aka BASEOP)  An OP with no children
+    1      UNOP             An OP with one child
+    2      BINOP            An OP with two children
+    |      LOGOP            A control branch OP
+    @      LISTOP           An OP that could have lots of children
+    /      PMOP             An OP with a regular expression
+    $      SVOP             An OP with an SV
+    "      PVOP             An OP with a string
+    {      LOOP             An OP that holds pointers for a loop
+    ;      COP              An OP that marks the start of a statement
+
+=head1 AUTHOR
+
+Stephen McCamant, C<smcc@CSUA.Berkeley.EDU>
+
+=cut

contrib/perl5/ext/DynaLoader/dl_dllload.xs

@@ -0,0 +1,189 @@
+/* dl_dllload.xs
+ *
+ * Platform:	OS/390, possibly others that use dllload(),dllfree() (VM/ESA?).
+ * Authors:	John Goodyear && Peter Prymmer
+ * Created:     28 October 2000
+ * Modified:
+ * 16 January 2001 - based loosely on dl_dlopen.xs.
+ */
+ 
+/* Porting notes:
+
+   OS/390 Dynamic Loading functions: 
+
+   dllload
+   -------
+     dllhandle * dllload(const char *dllName)
+
+     This function takes the name of a dynamic object file and returns
+     a descriptor which can be used by dlllqueryfn() and/or dllqueryvar() 
+     later.  If dllName contains a slash, it is used to locate the dll.
+     If not then the LIBPATH environment variable is used to
+     search for the requested dll (at least within the HFS).
+     It returns NULL on error and sets errno.
+
+   dllfree
+   -------
+     int dllfree(dllhandle *handle);
+
+     dllfree() decrements the load count for the dll and frees
+     it if the count is 0.  It returns zero on success, and 
+     non-zero on failure.
+
+   dllqueryfn && dllqueryvar
+   -------------------------
+     void (* dllqueryfn(dllhandle *handle, const char *function))();
+     void * dllqueryvar(dllhandle *handle, const char *symbol);
+
+     dllqueryfn() takes the handle returned from dllload() and the name 
+     of a function to get the address of.  If the function was found 
+     a pointer is returned, otherwise NULL is returned.
+
+     dllqueryvar() takes the handle returned from dllload() and the name 
+     of a symbol to get the address of.  If the variable was found a 
+     pointer is returned, otherwise NULL is returned.
+
+     The XS dl_find_symbol() first calls dllqueryfn().  If it fails
+     dlqueryvar() is then called.
+
+   strerror
+   --------
+     char * strerror(int errno)
+
+     Returns a null-terminated string which describes the last error
+     that occurred with other functions (not necessarily unique to
+     dll loading).
+
+   Return Types
+   ============
+   In this implementation the two functions, dl_load_file() &&
+   dl_find_symbol(), return (void *).  This is primarily because the 
+   dlopen() && dlsym() style dynamic linker calls return (void *).
+   We suspect that casting to (void *) may be easier than teaching XS
+   typemaps about the (dllhandle *) type.
+
+   Dealing with Error Messages
+   ===========================
+   In order to make the handling of dynamic linking errors as generic as
+   possible you should store any error messages associated with your
+   implementation with the StoreError function.
+
+   In the case of OS/390 the function strerror(errno) returns the error 
+   message associated with the last dynamic link error.  As the S/390 
+   dynamic linker functions dllload() && dllqueryvar() both return NULL 
+   on error every call to an S/390 dynamic link routine is coded 
+   like this:
+
+	RETVAL = dllload(filename) ;
+	if (RETVAL == NULL)
+	    SaveError("%s",strerror(errno)) ;
+
+   Note that SaveError() takes a printf format string. Use a "%s" as
+   the first parameter if the error may contain any % characters.
+
+   Other comments within the dl_dlopen.xs file may be helpful as well.
+*/
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include <dll.h>	/* the dynamic linker include file for S/390 */
+#include <errno.h>	/* strerror() and friends */
+
+#include "dlutils.c"	/* SaveError() etc */
+
+static void
+dl_private_init(pTHX)
+{
+    (void)dl_generic_private_init(aTHX);
+}
+
+MODULE = DynaLoader	PACKAGE = DynaLoader
+
+BOOT:
+    (void)dl_private_init(aTHX);
+
+
+void *
+dl_load_file(filename, flags=0)
+    char *	filename
+    int		flags
+  PREINIT:
+    int mode = 0;
+  CODE:
+{
+    DLDEBUG(1,PerlIO_printf(Perl_debug_log, "dl_load_file(%s,%x):\n", filename,flags));
+    /* add a (void *) dllload(filename) ; cast if needed */
+    RETVAL = dllload(filename) ;
+    DLDEBUG(2,PerlIO_printf(Perl_debug_log, " libref=%lx\n", (unsigned long) RETVAL));
+    ST(0) = sv_newmortal() ;
+    if (RETVAL == NULL)
+	SaveError(aTHX_ "%s",strerror(errno)) ;
+    else
+	sv_setiv( ST(0), PTR2IV(RETVAL));
+}
+
+
+int
+dl_unload_file(libref)
+    void *	libref
+  CODE:
+    DLDEBUG(1,PerlIO_printf(Perl_debug_log, "dl_unload_file(%lx):\n", PTR2ul(libref)));
+    /* RETVAL = (dllfree((dllhandle *)libref) == 0 ? 1 : 0); */
+    RETVAL = (dllfree(libref) == 0 ? 1 : 0);
+    if (!RETVAL)
+        SaveError(aTHX_ "%s", strerror(errno)) ;
+    DLDEBUG(2,PerlIO_printf(Perl_debug_log, " retval = %d\n", RETVAL));
+  OUTPUT:
+    RETVAL
+
+
+void *
+dl_find_symbol(libhandle, symbolname)
+    void *	libhandle
+    char *	symbolname
+    CODE:
+    DLDEBUG(2, PerlIO_printf(Perl_debug_log,
+			     "dl_find_symbol(handle=%lx, symbol=%s)\n",
+			     (unsigned long) libhandle, symbolname));
+    if((RETVAL = (void*)dllqueryfn(libhandle, symbolname)) == NULL)
+    RETVAL = dllqueryvar(libhandle, symbolname);
+    DLDEBUG(2, PerlIO_printf(Perl_debug_log,
+			     "  symbolref = %lx\n", (unsigned long) RETVAL));
+    ST(0) = sv_newmortal() ;
+    if (RETVAL == NULL)
+	SaveError(aTHX_ "%s",strerror(errno)) ;
+    else
+	sv_setiv( ST(0), PTR2IV(RETVAL));
+
+
+void
+dl_undef_symbols()
+    PPCODE:
+
+
+
+# These functions should not need changing on any platform:
+
+void
+dl_install_xsub(perl_name, symref, filename="$Package")
+    char *		perl_name
+    void *		symref 
+    char *		filename
+    CODE:
+    DLDEBUG(2,PerlIO_printf(Perl_debug_log, "dl_install_xsub(name=%s, symref=%lx)\n",
+		perl_name, (unsigned long) symref));
+    ST(0) = sv_2mortal(newRV((SV*)newXS(perl_name,
+					(void(*)(pTHX_ CV *))symref,
+					filename)));
+
+
+char *
+dl_error()
+    CODE:
+    RETVAL = LastError ;
+    OUTPUT:
+    RETVAL
+
+# end.

contrib/perl5/ext/DynaLoader/dl_mac.xs

@@ -0,0 +1,137 @@
+/* dl_mac.xs
+ * 
+ * Platform:	Macintosh CFM
+ * Author:	Matthias Neeracher <neeri@iis.ee.ethz.ch>
+ *		Adapted from dl_dlopen.xs reference implementation by
+ *              Paul Marquess (pmarquess@bfsec.bt.co.uk)
+ * $Log: dl_mac.xs,v $
+ * Revision 1.3  1998/04/07 01:47:24  neeri
+ * MacPerl 5.2.0r4b1
+ *
+ * Revision 1.2  1997/08/08 16:39:18  neeri
+ * MacPerl 5.1.4b1 + time() fix
+ *
+ * Revision 1.1  1997/04/07 20:48:23  neeri
+ * Synchronized with MacPerl 5.1.4a1
+ *
+ */
+
+#define MAC_CONTEXT
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include <CodeFragments.h>
+
+
+#include "dlutils.c"	/* SaveError() etc	*/
+
+typedef CFragConnectionID ConnectionID;
+
+static ConnectionID **	connections;
+
+static void terminate(void)
+{
+    int size = GetHandleSize((Handle) connections) / sizeof(ConnectionID);
+    HLock((Handle) connections);
+    while (size)
+    	CloseConnection(*connections + --size);
+    DisposeHandle((Handle) connections);
+    connections = nil;
+}
+
+static void
+dl_private_init(pTHX)
+{
+    (void)dl_generic_private_init(aTHX);
+}
+
+MODULE = DynaLoader	PACKAGE = DynaLoader
+
+BOOT:
+    (void)dl_private_init(aTHX);
+
+
+ConnectionID
+dl_load_file(filename, flags=0)
+    char *		filename
+    int			flags
+    PREINIT:
+    OSErr		err;
+    FSSpec		spec;
+    ConnectionID	connID;
+    Ptr			mainAddr;
+    Str255		errName;
+    CODE:
+    DLDEBUG(1,PerlIO_printf(Perl_debug_log,"dl_load_file(%s):\n", filename));
+    err = GUSIPath2FSp(filename, &spec);
+    if (!err)
+    	err = 
+	    GetDiskFragment(
+	    	&spec, 0, 0, spec.name, kLoadCFrag, &connID, &mainAddr, errName);
+    if (!err) {
+    	if (!connections) {
+	    connections = (ConnectionID **)NewHandle(0);
+	    atexit(terminate);
+    	}
+        PtrAndHand((Ptr) &connID, (Handle) connections, sizeof(ConnectionID));
+    	RETVAL = connID;
+    } else
+    	RETVAL = (ConnectionID) 0;
+    DLDEBUG(2,PerlIO_printf(Perl_debug_log," libref=%d\n", RETVAL));
+    ST(0) = sv_newmortal() ;
+    if (err)
+    	SaveError(aTHX_ "DynaLoader error [%d, %#s]", err, errName) ;
+    else
+    	sv_setiv( ST(0), (IV)RETVAL);
+
+void *
+dl_find_symbol(connID, symbol)
+    ConnectionID	connID
+    Str255		symbol
+    CODE:
+    {
+    	OSErr		    err;
+    	Ptr		    symAddr;
+    	CFragSymbolClass    symClass;
+    	DLDEBUG(2,PerlIO_printf(Perl_debug_log,"dl_find_symbol(handle=%x, symbol=%#s)\n",
+	    connID, symbol));
+   	err = FindSymbol(connID, symbol, &symAddr, &symClass);
+    	if (err)
+    	    symAddr = (Ptr) 0;
+    	RETVAL = (void *) symAddr;
+    	DLDEBUG(2,PerlIO_printf(Perl_debug_log,"  symbolref = %x\n", RETVAL));
+    	ST(0) = sv_newmortal() ;
+    	if (err)
+	    SaveError(aTHX_ "DynaLoader error [%d]!", err) ;
+    	else
+	    sv_setiv( ST(0), (IV)RETVAL);
+    }
+
+void
+dl_undef_symbols()
+    PPCODE:
+
+
+
+# These functions should not need changing on any platform:
+
+void
+dl_install_xsub(perl_name, symref, filename="$Package")
+    char *		perl_name
+    void *		symref 
+    char *		filename
+    CODE:
+    DLDEBUG(2,PerlIO_printf(Perl_debug_log,"dl_install_xsub(name=%s, symref=%x)\n",
+		perl_name, symref));
+    ST(0)=sv_2mortal(newRV((SV*)newXS(perl_name, (void(*)())symref, filename)));
+
+
+char *
+dl_error()
+    CODE:
+    RETVAL = LastError ;
+    OUTPUT:
+    RETVAL
+
+# end.

contrib/perl5/ext/DynaLoader/hints/netbsd.pl

@@ -0,0 +1,3 @@
+# XXX Configure test needed?
+# Some NetBSDs seem to have a dlopen() that won't accept relative paths
+$self->{CCFLAGS} = $Config{ccflags} . ' -DDLOPEN_WONT_DO_RELATIVE_PATHS';

contrib/perl5/ext/POSIX/hints/svr4.pl

@@ -0,0 +1,12 @@
+# NCR MP-RAS.  Thanks to Doug Hendricks for this info.
+# Configure sets osname=svr4.0, osvers=3.0, archname='3441-svr4.0'
+# This system needs to explicitly link against -lmw to pull in some
+# symbols such as _mwoflocheckl and possibly others.
+#  A. Dougherty  Thu Dec  7 11:55:28 EST 2000
+if ($Config{'archname'} =~ /3441-svr4/) {
+    $self->{LIBS} = ['-lm -posix -lcposix -lmw'];
+}
+# Not sure what OS this one is.
+elsif ($Config{archname} =~ /RM\d\d\d-svr4/) {
+    $self->{LIBS} = ['-lm -lc -lposix -lcposix'];
+}

contrib/perl5/ext/re/hints/aix.pl

@@ -0,0 +1,22 @@
+# Add explicit link to deb.o to pick up .Perl_deb symbol which is not
+# mentioned in perl.exp for earlier cc (xlc) versions in at least
+# non DEBUGGING builds
+#  Peter Prymmer <pvhp@best.com>
+
+use Config;
+
+if ($^O eq 'aix' && defined($Config{'ccversion'}) && 
+    ( $Config{'ccversion'} =~ /^3\.\d/
+      # needed for at least these versions:
+      # $Config{'ccversion'} eq '3.6.6.0' 
+      # $Config{'ccversion'} eq '3.6.4.0' 
+      # $Config{'ccversion'} eq '3.1.4.0'  AIX 4.2
+      # $Config{'ccversion'} eq '3.1.4.10' AIX 4.2
+      # $Config{'ccversion'} eq '3.1.3.3' 
+      ||
+      $Config{'ccversion'} =~ /^4\.4\.0\.[0-3]/
+    )
+   ) {
+    $self->{OBJECT} .= ' ../../deb$(OBJ_EXT)';
+}
+

contrib/perl5/hints/nonstopux.sh

@@ -0,0 +1,17 @@
+# tom_bates@att.net
+# mips-compaq-nonstopux
+
+. $src/hints/svr4.sh
+
+case "$cc" in
+        *gcc*)
+                ccflags='-fno-strict-aliasing'
+                lddlflags='-shared'
+                ldflags=''
+		;;
+        *)
+                cc="cc -Xa -Olimit 4096"
+                malloctype="void *"
+		;;
+esac
+

contrib/perl5/lib/File/Spec/Epoc.pm

@@ -0,0 +1,378 @@
+package File::Spec::Epoc;
+
+use strict;
+use Cwd;
+use vars qw(@ISA);
+require File::Spec::Unix;
+@ISA = qw(File::Spec::Unix);
+
+=head1 NAME
+
+File::Spec::Epoc - methods for Epoc file specs
+
+=head1 SYNOPSIS
+
+ require File::Spec::Epoc; # 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.
+
+This package is still work in progress ;-)
+o.flebbe@gmx.de
+
+
+=over
+
+=item devnull
+
+Returns a string representation of the null device.
+
+=cut
+
+sub devnull {
+    return "nul:";
+}
+
+=item tmpdir
+
+Returns a string representation of a temporay directory:
+
+=cut
+
+my $tmpdir;
+sub tmpdir {
+    return "C:/System/temp";
+}
+
+sub case_tolerant {
+    return 1;
+}
+
+sub file_name_is_absolute {
+    my ($self,$file) = @_;
+    return scalar($file =~ m{^([a-z?]:)?[\\/]}is);
+}
+
+=item path
+
+Takes no argument, returns the environment variable PATH as an array. Since
+there is no search path supported, it returns undef, sorry.
+
+=cut
+sub path {
+    return undef;
+}
+
+=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 unless($^O eq 'cygwin');     # xx////xx  -> xx/xx
+    $path =~ s|(/\.)+/|/|g;                        # xx/././xx -> xx/xx
+    $path =~ s|^(\./)+||s unless $path eq "./";    # ./xx      -> xx
+    $path =~ s|^/(\.\./)+|/|s;                     # /../../xx -> xx
+    $path =~ s|/\z|| unless $path eq "/";          # 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 /.
+
+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)?)? )
+                (.*)
+             }xs;
+        $volume    = $1;
+        $directory = $2;
+        $file      = $3;
+    }
+
+    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, 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| ) {
+        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@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@s &&
+         $volume =~ m@[^\\/]\z@      &&
+         $file   =~ m@[^\\/]@
+       ) {
+        $volume =~ m@([\\/])@ ;
+        my $sep = $1 ? $1 : '\\' ;
+        $volume .= $sep ;
+    }
+
+    $volume .= $file ;
+
+    return $volume ;
+}
+
+
+=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( $destination ) ;
+    $rel_path = File::Spec->abs2rel( $destination, $base ) ;
+
+If $base is not present or '', then L</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()>.
+
+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()>.
+
+Based on code written by Shigio Yamaguchi.
+
+No checks against the filesystem are made. 
+
+=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 ( ! $self->file_name_is_absolute( $base ) ) {
+        $base = $self->rel2abs( $base ) ;
+    }
+    elsif ( !defined( $base ) || $base eq '' ) {
+        $base = cwd() ;
+    }
+    else {
+        $base = $self->canonpath( $base ) ;
+    }
+
+    # Split up paths
+    my ( $path_volume, $path_directories, $path_file ) =
+        $self->splitpath( $path, 1 ) ;
+
+    my ( undef, $base_directories, undef ) =
+        $self->splitpath( $base, 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" ;
+    }
+
+    # It makes no sense to add a relative path to a UNC volume
+    $path_volume = '' unless $path_volume =~ m{^[A-Z]:}is ;
+
+    return $self->canonpath( 
+        $self->catpath($path_volume, $path_directories, $path_file ) 
+    ) ;
+}
+
+=item rel2abs
+
+Converts a relative path to an absolute path. 
+
+    $abs_path = File::Spec->rel2abs( $destination ) ;
+    $abs_path = File::Spec->rel2abs( $destination, $base ) ;
+
+If $base is not present or '', then L<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()>.
+
+Assumes that both paths are on the $base volume, and ignores the 
+$destination 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()>.
+
+Based on code written by Shigio Yamaguchi.
+
+No checks against the filesystem are made. 
+
+=cut
+
+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 ( undef, $path_directories, $path_file ) =
+            $self->splitpath( $path, 1 ) ;
+
+        my ( $base_volume, $base_directories, undef ) =
+            $self->splitpath( $base, 1 ) ;
+
+        $path = $self->catpath( 
+            $base_volume, 
+            $self->catdir( $base_directories, $path_directories ), 
+            $path_file
+        ) ;
+    }
+
+    return $self->canonpath( $path ) ;
+}
+
+=back
+
+=head1 SEE ALSO
+
+L<File::Spec>
+
+=cut
+
+1;

contrib/perl5/lib/Pod/Text/Overstrike.pm

@@ -0,0 +1,160 @@
+# Pod::Text::Overstrike -- Convert POD data to formatted overstrike text
+# $Id: Overstrike.pm,v 1.1 2000/12/25 12:51:23 eagle Exp $
+#
+# Created by Joe Smith <Joe.Smith@inwap.com> 30-Nov-2000
+#   (based on Pod::Text::Color by Russ Allbery <rra@stanford.edu>)
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the same terms as Perl itself.
+#
+# This was written because the output from:
+#
+#     pod2text Text.pm > plain.txt; less plain.txt
+#
+# is not as rich as the output from
+#
+#     pod2man Text.pm | nroff -man > fancy.txt; less fancy.txt
+#
+# and because both Pod::Text::Color and Pod::Text::Termcap are not device
+# independent.
+
+############################################################################
+# Modules and declarations
+############################################################################
+
+package Pod::Text::Overstrike;
+
+require 5.004;
+
+use Pod::Text ();
+
+use strict;
+use vars qw(@ISA $VERSION);
+
+@ISA = qw(Pod::Text);
+
+# Don't use the CVS revision as the version, since this module is also in
+# Perl core and too many things could munge CVS magic revision strings.
+# This number should ideally be the same as the CVS revision in podlators,
+# however.
+$VERSION = 1.01;
+
+
+############################################################################
+# Overrides
+############################################################################
+
+# Make level one headings bold, overridding any existing formatting.
+sub cmd_head1 {
+    my $self = shift;
+    local $_ = shift;
+    s/\s+$//;
+    s/(.)\cH\1//g;
+    s/_\cH//g;
+    s/(.)/$1\b$1/g;
+    $self->SUPER::cmd_head1 ($_);
+}
+
+# Make level two headings bold, overriding any existing formatting.
+sub cmd_head2 {
+    my $self = shift;
+    local $_ = shift;
+    s/\s+$//;
+    s/(.)\cH\1//g;
+    s/_\cH//g;
+    s/(.)/$1\b$1/g;
+    $self->SUPER::cmd_head2 ($_);
+}
+
+# Make level three headings underscored, overriding any existing formatting.
+sub cmd_head3 {
+    my $self = shift;
+    local $_ = shift;
+    s/\s+$//;
+    s/(.)\cH\1//g;
+    s/_\cH//g;
+    s/(.)/_\b$1/g;
+    $self->SUPER::cmd_head3 ($_);
+}
+
+# Fix the various interior sequences.
+sub seq_b { local $_ = $_[1]; s/(.)\cH\1//g; s/_\cH//g; s/(.)/$1\b$1/g; $_ }
+sub seq_f { local $_ = $_[1]; s/(.)\cH\1//g; s/_\cH//g; s/(.)/_\b$1/g; $_ }
+sub seq_i { local $_ = $_[1]; s/(.)\cH\1//g; s/_\cH//g; s/(.)/_\b$1/g; $_ }
+
+# We unfortunately have to override the wrapping code here, since the normal
+# wrapping code gets really confused by all the escape sequences.
+sub wrap {
+    my $self = shift;
+    local $_ = shift;
+    my $output = '';
+    my $spaces = ' ' x $$self{MARGIN};
+    my $width = $$self{width} - $$self{MARGIN};
+    while (length > $width) {
+        if (s/^((?:(?:[^\n]\cH)?[^\n]){0,$width})\s+//
+            || s/^((?:(?:[^\n]\cH)?[^\n]){$width})//) {
+            $output .= $spaces . $1 . "\n";
+        } else {
+            last;
+        }
+    }
+    $output .= $spaces . $_;
+    $output =~ s/\s+$/\n\n/;
+    $output;
+}
+
+############################################################################
+# Module return value and documentation
+############################################################################
+
+1;
+__END__
+
+=head1 NAME
+
+Pod::Text::Overstrike - Convert POD data to formatted overstrike text
+
+=head1 SYNOPSIS
+
+    use Pod::Text::Overstrike;
+    my $parser = Pod::Text::Overstrike->new (sentence => 0, width => 78);
+
+    # Read POD from STDIN and write to STDOUT.
+    $parser->parse_from_filehandle;
+
+    # Read POD from file.pod and write to file.txt.
+    $parser->parse_from_file ('file.pod', 'file.txt');
+
+=head1 DESCRIPTION
+
+Pod::Text::Overstrike is a simple subclass of Pod::Text that highlights
+output text using overstrike sequences, in a manner similar to nroff.
+Characters in bold text are overstruck (character, backspace, character) and
+characters in underlined text are converted to overstruck underscores
+(underscore, backspace, character).  This format was originally designed for
+hardcopy terminals and/or lineprinters, yet is readable on softcopy (CRT)
+terminals.
+
+Overstruck text is best viewed by page-at-a-time programs that take
+advantage of the terminal's B<stand-out> and I<underline> capabilities, such
+as the less program on Unix.
+
+Apart from the overstrike, it in all ways functions like Pod::Text.  See
+L<Pod::Text> for details and available options.
+
+=head1 BUGS
+
+Currently, the outermost formatting instruction wins, so for example
+underlined text inside a region of bold text is displayed as simply bold.
+There may be some better approach possible.
+
+=head1 SEE ALSO
+
+L<Pod::Text|Pod::Text>, L<Pod::Parser|Pod::Parser>
+
+=head1 AUTHOR
+
+Joe Smith E<lt>Joe.Smith@inwap.comE<gt>, using the framework created by Russ
+Allbery E<lt>rra@stanford.eduE<gt>.
+
+=cut

contrib/perl5/lib/Win32.pod

@@ -0,0 +1,287 @@
+=head1 NAME
+
+Win32 - Interfaces to some Win32 API Functions
+
+=head1 DESCRIPTION
+
+Perl on Win32 contains several functions to access Win32 APIs. Some
+are included in Perl itself (on Win32) and some are only available
+after explicitly requesting the Win32 module with:
+
+	use Win32;
+
+The builtin functions are marked as [CORE] and the other ones
+as [EXT] in the following alphabetical listing. The C<Win32> module
+is not part of the Perl source distribution; it is distributed in
+the libwin32 bundle of Win32::* modules on CPAN. The module is
+already preinstalled in binary distributions like ActivePerl.
+
+=head2 Alphabetical Listing of Win32 Functions
+
+=over
+
+=item Win32::AbortSystemShutdown(MACHINE)
+
+[EXT] Aborts a system shutdown (started by the
+InitiateSystemShutdown function) on the specified MACHINE.
+
+=item Win32::BuildNumber()
+
+[CORE] Returns the ActivePerl build number. This function is
+only available in the ActivePerl binary distribution.
+
+=item Win32::CopyFile(FROM, TO, OVERWRITE)
+
+[CORE] The Win32::CopyFile() function copies an existing file to a new
+file. All file information like creation time and file attributes will
+be copied to the new file. However it will B<not> copy the security
+information. If the destination file already exists it will only be
+overwritten when the OVERWRITE parameter is true. But even this will
+not overwrite a read-only file; you have to unlink() it first
+yourself.
+
+=item Win32::DomainName()
+
+[CORE] Returns the name of the Microsoft Network domain that the
+owner of the current perl process is logged into.  This function does
+B<not> work on Windows 9x.
+
+=item Win32::ExpandEnvironmentStrings(STRING)
+
+[EXT] Takes STRING and replaces all referenced environment variable
+names with their defined values. References to environment variables
+take the form C<%VariableName%>. Case is ignored when looking up the
+VariableName in the environment. If the variable is not found then the
+original C<%VariableName%> text is retained.  Has the same effect
+as the following:
+
+	$string =~ s/%([^%]*)%/$ENV{$1} || "%$1%"/eg
+
+=item Win32::FormatMessage(ERRORCODE)
+
+[CORE] Converts the supplied Win32 error number (e.g. returned by
+Win32::GetLastError()) to a descriptive string.  Analogous to the
+perror() standard-C library function.  Note that C<$^E> used
+in a string context has much the same effect.
+
+	C:\> perl -e "$^E = 26; print $^E;"
+	The specified disk or diskette cannot be accessed
+
+=item Win32::FsType()
+
+[CORE] Returns the name of the filesystem of the currently active
+drive (like 'FAT' or 'NTFS'). In list context it returns three values:
+(FSTYPE, FLAGS, MAXCOMPLEN). FSTYPE is the filesystem type as
+before. FLAGS is a combination of values of the following table:
+
+	0x00000001  supports case-sensitive filenames
+	0x00000002  preserves the case of filenames
+	0x00000004  supports Unicode in filenames
+	0x00000008  preserves and enforces ACLs
+	0x00000010  supports file-based compression
+	0x00000020  supports disk quotas
+	0x00000040  supports sparse files
+	0x00000080  supports reparse points
+	0x00000100  supports remote storage
+	0x00008000  is a compressed volume (e.g. DoubleSpace)
+	0x00010000  supports object identifiers
+	0x00020000  supports the Encrypted File System (EFS)
+
+MAXCOMPLEN is the maximum length of a filename component (the part
+between two backslashes) on this file system.
+
+=item Win32::FreeLibrary(HANDLE)
+
+[EXT] Unloads a previously loaded dynamic-link library. The HANDLE is
+no longer valid after this call. See L<LoadLibrary|Win32::LoadLibrary(LIBNAME)>
+for information on dynamically loading a library.
+
+=item Win32::GetArchName()
+
+[EXT] Use of this function is deprecated. It is equivalent with
+$ENV{PROCESSOR_ARCHITECTURE}. This might not work on Win9X.
+
+=item Win32::GetChipName()
+
+[EXT] Returns the processor type: 386, 486 or 586 for Intel processors,
+21064 for the Alpha chip.
+
+=item Win32::GetCwd()
+
+[CORE] Returns the current active drive and directory. This function
+does not return a UNC path, since the functionality required for such
+a feature is not available under Windows 95.
+
+=item Win32::GetFullPathName(FILENAME)
+
+[CORE] GetFullPathName combines the FILENAME with the current drive
+and directory name and returns a fully qualified (aka, absolute)
+path name. In list context it returns two elements: (PATH, FILE) where
+PATH is the complete pathname component (including trailing backslash)
+and FILE is just the filename part.  Note that no attempt is made to
+convert 8.3 components in the supplied FILENAME to longnames or
+vice-versa.  Compare with Win32::GetShortPathName and
+Win32::GetLongPathName.  
+
+This function has been added for Perl 5.6.
+
+=item Win32::GetLastError()
+
+[CORE] Returns the last error value generated by a call to a Win32 API
+function.  Note that C<$^E> used in a numeric context amounts to the
+same value.
+
+=item Win32::GetLongPathName(PATHNAME)
+
+[CORE] Returns a representation of PATHNAME composed of longname
+components (if any).  The result may not necessarily be longer
+than PATHNAME.  No attempt is made to convert PATHNAME to the
+absolute path.  Compare with Win32::GetShortPathName and
+Win32::GetFullPathName.
+
+This function has been added for Perl 5.6.
+
+=item Win32::GetNextAvailDrive()
+
+[CORE] Returns a string in the form of "<d>:" where <d> is the first
+available drive letter.
+
+=item Win32::GetOSVersion()
+
+[CORE] Returns the array (STRING, MAJOR, MINOR, BUILD, ID), where
+the elements are, respectively: An arbitrary descriptive string, the
+major version number of the operating system, the minor version
+number, the build number, and a digit indicating the actual operating
+system. For ID, the values are 0 for Win32s, 1 for Windows 9X and 2
+for Windows NT. In scalar context it returns just the ID.
+
+=item Win32::GetShortPathName(PATHNAME)
+
+[CORE] Returns a representation of PATHNAME composed only of
+short (8.3) path components.  The result may not necessarily be
+shorter than PATHNAME.  Compare with Win32::GetFullPathName and
+Win32::GetLongPathName.
+
+=item Win32::GetProcAddress(INSTANCE, PROCNAME)
+
+[EXT] Returns the address of a function inside a loaded library. The
+information about what you can do with this address has been lost in
+the mist of time. Use the Win32::API module instead of this deprecated
+function.
+
+=item Win32::GetTickCount()
+
+[CORE] Returns the number of milliseconds elapsed since the last
+system boot. Resolution is limited to system timer ticks (about 10ms
+on WinNT and 55ms on Win9X).
+
+=item Win32::InitiateSystemShutdown
+
+(MACHINE, MESSAGE, TIMEOUT, FORCECLOSE, REBOOT)
+
+[EXT] Shutsdown the specified MACHINE, notifying users with the
+supplied MESSAGE, within the specified TIMEOUT interval. Forces
+closing of all documents without prompting the user if FORCECLOSE is
+true, and reboots the machine if REBOOT is true. This function works
+only on WinNT.
+
+=item Win32::IsWinNT()
+
+[CORE] Returns non zero if the Win32 subsystem is Windows NT.
+
+=item Win32::IsWin95()
+
+[CORE] Returns non zero if the Win32 subsystem is Windows 95.
+
+=item Win32::LoadLibrary(LIBNAME)
+
+[EXT] Loads a dynamic link library into memory and returns its module
+handle. This handle can be used with Win32::GetProcAddress and
+Win32::FreeLibrary. This function is deprecated. Use the Win32::API
+module instead.
+
+=item Win32::LoginName()
+
+[CORE] Returns the username of the owner of the current perl process.
+
+=item Win32::LookupAccountName(SYSTEM, ACCOUNT, DOMAIN, SID, SIDTYPE)
+
+[EXT] Looks up ACCOUNT on SYSTEM and returns the domain name the SID and
+the SID type.
+
+=item Win32::LookupAccountSID(SYSTEM, SID, ACCOUNT, DOMAIN, SIDTYPE)
+
+[EXT] Looks up SID on SYSTEM and returns the account name, domain name,
+and the SID type.
+
+=item Win32::MsgBox(MESSAGE [, FLAGS [, TITLE]])
+
+[EXT] Create a dialogbox containing MESSAGE. FLAGS specifies the
+required icon and buttons according to the following table:
+
+	0 = OK
+	1 = OK and Cancel
+	2 = Abort, Retry, and Ignore
+	3 = Yes, No and Cancel
+	4 = Yes and No
+	5 = Retry and Cancel
+
+	MB_ICONSTOP          "X" in a red circle
+	MB_ICONQUESTION      question mark in a bubble
+	MB_ICONEXCLAMATION   exclamation mark in a yellow triangle
+	MB_ICONINFORMATION   "i" in a bubble
+
+TITLE specifies an optional window title. The default is "Perl".
+
+The function returns the menu id of the selected push button:
+
+	0  Error
+
+	1  OK
+	2  Cancel
+	3  Abort
+	4  Retry
+	5  Ignore
+	6  Yes
+	7  No
+
+=item Win32::NodeName()
+
+[CORE] Returns the Microsoft Network node-name of the current machine.
+
+=item Win32::RegisterServer(LIBRARYNAME)
+
+[EXT] Loads the DLL LIBRARYNAME and calls the function DllRegisterServer.
+
+=item Win32::SetCwd(NEWDIRECTORY)
+
+[CORE] Sets the current active drive and directory. This function does not
+work with UNC paths, since the functionality required to required for
+such a feature is not available under Windows 95.
+
+=item Win32::SetLastError(ERROR)
+
+[CORE] Sets the value of the last error encountered to ERROR. This is
+that value that will be returned by the Win32::GetLastError()
+function. This functions has been added for Perl 5.6.
+
+=item Win32::Sleep(TIME)
+
+[CORE] Pauses for TIME milliseconds. The timeslices are made available
+to other processes and threads.
+
+=item Win32::Spawn(COMMAND, ARGS, PID)
+
+[CORE] Spawns a new process using the supplied COMMAND, passing in
+arguments in the string ARGS. The pid of the new process is stored in
+PID. This function is deprecated. Please use the Win32::Process module
+instead.
+
+=item Win32::UnregisterServer(LIBRARYNAME)
+
+[EXT] Loads the DLL LIBRARYNAME and calls the function
+DllUnregisterServer.
+
+=back
+
+=cut

contrib/perl5/lib/unicode/BidiMirr.txt

@@ -0,0 +1,238 @@
+# BidiMirroring-1.txt
+# 
+# This file is an informative supplement to the UnicodeData file. It
+# lists characters that have the mirrored property
+# where there is another Unicode character that typically has a glyph
+# that is the mirror image of the original character's glyph.
+# The repertoire covered by the file is Unicode 3.0.1.
+# 
+# The file contains a list of lines with mappings from one code point
+# to another one for character-based mirroring.
+# Note that for "real" mirroring, a rendering engine needs to select
+# appropriate alternative glyphs, and that many Unicode characters do not
+# have a mirror-image Unicode character.
+# 
+# Each mapping line contains two fields, separated by a semicolon (';').
+# Each of the two fields contains a code point represented as a
+# variable-length hexadecimal value with 4 to 6 digits.
+# A comment indicates where the characters are "BEST FIT" mirroring.
+# 
+# Code points with the "mirrored" property but no appropriate mirrors are
+# listed as comments at the end of the file.
+# 
+# For information on bidi mirroring, see UTR #21: Bidirectional Algorithm,
+# at http://www.unicode.org/unicode/reports/tr9/
+# 
+# Please address any comments to <errata@unicode.org>.
+# Note that this is an archival address: messages will be checked,
+# but do not expect an immediate response.
+# 
+# This file was originally created by Markus Scherer
+# 
+# ############################################################
+
+0028; 0029 # LEFT PARENTHESIS
+0029; 0028 # RIGHT PARENTHESIS
+003C; 003E # LESS-THAN SIGN
+003E; 003C # GREATER-THAN SIGN
+005B; 005D # LEFT SQUARE BRACKET
+005D; 005B # RIGHT SQUARE BRACKET
+007B; 007D # LEFT CURLY BRACKET
+007D; 007B # RIGHT CURLY BRACKET
+00AB; 00BB # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BB; 00AB # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+2039; 203A # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+203A; 2039 # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+2045; 2046 # LEFT SQUARE BRACKET WITH QUILL
+2046; 2045 # RIGHT SQUARE BRACKET WITH QUILL
+207D; 207E # SUPERSCRIPT LEFT PARENTHESIS
+207E; 207D # SUPERSCRIPT RIGHT PARENTHESIS
+208D; 208E # SUBSCRIPT LEFT PARENTHESIS
+208E; 208D # SUBSCRIPT RIGHT PARENTHESIS
+2208; 220B # ELEMENT OF
+2209; 220C # NOT AN ELEMENT OF
+220A; 220D # SMALL ELEMENT OF
+220B; 2208 # CONTAINS AS MEMBER
+220C; 2209 # DOES NOT CONTAIN AS MEMBER
+220D; 220A # SMALL CONTAINS AS MEMBER
+223C; 223D # TILDE OPERATOR
+223D; 223C # REVERSED TILDE
+2243; 22CD # ASYMPTOTICALLY EQUAL TO
+2252; 2253 # APPROXIMATELY EQUAL TO OR THE IMAGE OF
+2253; 2252 # IMAGE OF OR APPROXIMATELY EQUAL TO
+2254; 2255 # COLON EQUALS
+2255; 2254 # EQUALS COLON
+2264; 2265 # LESS-THAN OR EQUAL TO
+2265; 2264 # GREATER-THAN OR EQUAL TO
+2266; 2267 # LESS-THAN OVER EQUAL TO
+2267; 2266 # GREATER-THAN OVER EQUAL TO
+2268; 2269 # [BEST FIT] LESS-THAN BUT NOT EQUAL TO
+2269; 2268 # [BEST FIT] GREATER-THAN BUT NOT EQUAL TO
+226A; 226B # MUCH LESS-THAN
+226B; 226A # MUCH GREATER-THAN
+226E; 226F # [BEST FIT] NOT LESS-THAN
+226F; 226E # [BEST FIT] NOT GREATER-THAN
+2270; 2271 # [BEST FIT] NEITHER LESS-THAN NOR EQUAL TO
+2271; 2270 # [BEST FIT] NEITHER GREATER-THAN NOR EQUAL TO
+2272; 2273 # [BEST FIT] LESS-THAN OR EQUIVALENT TO
+2273; 2272 # [BEST FIT] GREATER-THAN OR EQUIVALENT TO
+2274; 2275 # [BEST FIT] NEITHER LESS-THAN NOR EQUIVALENT TO
+2275; 2274 # [BEST FIT] NEITHER GREATER-THAN NOR EQUIVALENT TO
+2276; 2277 # LESS-THAN OR GREATER-THAN
+2277; 2276 # GREATER-THAN OR LESS-THAN
+2278; 2279 # NEITHER LESS-THAN NOR GREATER-THAN
+2279; 2278 # NEITHER GREATER-THAN NOR LESS-THAN
+227A; 227B # PRECEDES
+227B; 227A # SUCCEEDS
+227C; 227D # PRECEDES OR EQUAL TO
+227D; 227C # SUCCEEDS OR EQUAL TO
+227E; 227F # [BEST FIT] PRECEDES OR EQUIVALENT TO
+227F; 227E # [BEST FIT] SUCCEEDS OR EQUIVALENT TO
+2280; 2281 # [BEST FIT] DOES NOT PRECEDE
+2281; 2280 # [BEST FIT] DOES NOT SUCCEED
+2282; 2283 # SUBSET OF
+2283; 2282 # SUPERSET OF
+2284; 2285 # [BEST FIT] NOT A SUBSET OF
+2285; 2284 # [BEST FIT] NOT A SUPERSET OF
+2286; 2287 # SUBSET OF OR EQUAL TO
+2287; 2286 # SUPERSET OF OR EQUAL TO
+2288; 2289 # [BEST FIT] NEITHER A SUBSET OF NOR EQUAL TO
+2289; 2288 # [BEST FIT] NEITHER A SUPERSET OF NOR EQUAL TO
+228A; 228B # [BEST FIT] SUBSET OF WITH NOT EQUAL TO
+228B; 228A # [BEST FIT] SUPERSET OF WITH NOT EQUAL TO
+228F; 2290 # SQUARE IMAGE OF
+2290; 228F # SQUARE ORIGINAL OF
+2291; 2292 # SQUARE IMAGE OF OR EQUAL TO
+2292; 2291 # SQUARE ORIGINAL OF OR EQUAL TO
+22A2; 22A3 # RIGHT TACK
+22A3; 22A2 # LEFT TACK
+22B0; 22B1 # PRECEDES UNDER RELATION
+22B1; 22B0 # SUCCEEDS UNDER RELATION
+22B2; 22B3 # NORMAL SUBGROUP OF
+22B3; 22B2 # CONTAINS AS NORMAL SUBGROUP
+22B4; 22B5 # NORMAL SUBGROUP OF OR EQUAL TO
+22B5; 22B4 # CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
+22B6; 22B7 # ORIGINAL OF
+22B7; 22B6 # IMAGE OF
+22C9; 22CA # LEFT NORMAL FACTOR SEMIDIRECT PRODUCT
+22CA; 22C9 # RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT
+22CB; 22CC # LEFT SEMIDIRECT PRODUCT
+22CC; 22CB # RIGHT SEMIDIRECT PRODUCT
+22CD; 2243 # REVERSED TILDE EQUALS
+22D0; 22D1 # DOUBLE SUBSET
+22D1; 22D0 # DOUBLE SUPERSET
+22D6; 22D7 # LESS-THAN WITH DOT
+22D7; 22D6 # GREATER-THAN WITH DOT
+22D8; 22D9 # VERY MUCH LESS-THAN
+22D9; 22D8 # VERY MUCH GREATER-THAN
+22DA; 22DB # LESS-THAN EQUAL TO OR GREATER-THAN
+22DB; 22DA # GREATER-THAN EQUAL TO OR LESS-THAN
+22DC; 22DD # EQUAL TO OR LESS-THAN
+22DD; 22DC # EQUAL TO OR GREATER-THAN
+22DE; 22DF # EQUAL TO OR PRECEDES
+22DF; 22DE # EQUAL TO OR SUCCEEDS
+22E0; 22E1 # [BEST FIT] DOES NOT PRECEDE OR EQUAL
+22E1; 22E0 # [BEST FIT] DOES NOT SUCCEED OR EQUAL
+22E2; 22E3 # [BEST FIT] NOT SQUARE IMAGE OF OR EQUAL TO
+22E3; 22E2 # [BEST FIT] NOT SQUARE ORIGINAL OF OR EQUAL TO
+22E4; 22E5 # [BEST FIT] SQUARE IMAGE OF OR NOT EQUAL TO
+22E5; 22E4 # [BEST FIT] SQUARE ORIGINAL OF OR NOT EQUAL TO
+22E6; 22E7 # [BEST FIT] LESS-THAN BUT NOT EQUIVALENT TO
+22E7; 22E6 # [BEST FIT] GREATER-THAN BUT NOT EQUIVALENT TO
+22E8; 22E9 # [BEST FIT] PRECEDES BUT NOT EQUIVALENT TO
+22E9; 22E8 # [BEST FIT] SUCCEEDS BUT NOT EQUIVALENT TO
+22EA; 22EB # [BEST FIT] NOT NORMAL SUBGROUP OF
+22EB; 22EA # [BEST FIT] DOES NOT CONTAIN AS NORMAL SUBGROUP
+22EC; 22ED # [BEST FIT] NOT NORMAL SUBGROUP OF OR EQUAL TO
+22ED; 22EC # [BEST FIT] DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
+22F0; 22F1 # UP RIGHT DIAGONAL ELLIPSIS
+22F1; 22F0 # DOWN RIGHT DIAGONAL ELLIPSIS
+2308; 2309 # LEFT CEILING
+2309; 2308 # RIGHT CEILING
+230A; 230B # LEFT FLOOR
+230B; 230A # RIGHT FLOOR
+2329; 232A # LEFT-POINTING ANGLE BRACKET
+232A; 2329 # RIGHT-POINTING ANGLE BRACKET
+3008; 3009 # LEFT ANGLE BRACKET
+3009; 3008 # RIGHT ANGLE BRACKET
+300A; 300B # LEFT DOUBLE ANGLE BRACKET
+300B; 300A # RIGHT DOUBLE ANGLE BRACKET
+300C; 300D # [BEST FIT] LEFT CORNER BRACKET
+300D; 300C # [BEST FIT] RIGHT CORNER BRACKET
+300E; 300F # [BEST FIT] LEFT WHITE CORNER BRACKET
+300F; 300E # [BEST FIT] RIGHT WHITE CORNER BRACKET
+3010; 3011 # LEFT BLACK LENTICULAR BRACKET
+3011; 3010 # RIGHT BLACK LENTICULAR BRACKET
+3014; 3015 # [BEST FIT] LEFT TORTOISE SHELL BRACKET
+3015; 3014 # [BEST FIT] RIGHT TORTOISE SHELL BRACKET
+3016; 3017 # LEFT WHITE LENTICULAR BRACKET
+3017; 3016 # RIGHT WHITE LENTICULAR BRACKET
+3018; 3019 # LEFT WHITE TORTOISE SHELL BRACKET
+3019; 3018 # RIGHT WHITE TORTOISE SHELL BRACKET
+301A; 301B # LEFT WHITE SQUARE BRACKET
+301B; 301A # RIGHT WHITE SQUARE BRACKET
+
+# The following characters have no appropriate mirroring character
+
+# 2201; COMPLEMENT
+# 2202; PARTIAL DIFFERENTIAL
+# 2203; THERE EXISTS
+# 2204; THERE DOES NOT EXIST
+# 2211; N-ARY SUMMATION
+# 2215; DIVISION SLASH
+# 2216; SET MINUS
+# 221A; SQUARE ROOT
+# 221B; CUBE ROOT
+# 221C; FOURTH ROOT
+# 221D; PROPORTIONAL TO
+# 221F; RIGHT ANGLE
+# 2220; ANGLE
+# 2221; MEASURED ANGLE
+# 2222; SPHERICAL ANGLE
+# 2224; DOES NOT DIVIDE
+# 2226; NOT PARALLEL TO
+# 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
+# 2239; EXCESS
+# 223B; HOMOTHETIC
+# 223E; INVERTED LAZY S
+# 223F; SINE WAVE
+# 2240; WREATH PRODUCT
+# 2241; NOT TILDE
+# 2242; MINUS TILDE
+# 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
+# 225F; QUESTIONED EQUAL TO
+# 2260; NOT EQUAL TO
+# 2262; NOT IDENTICAL TO
+# 228C; MULTISET
+# 2298; CIRCLED DIVISION SLASH
+# 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
+# 22B8; MULTIMAP
+# 22BE; RIGHT ANGLE WITH ARC
+# 22BF; RIGHT TRIANGLE
+# 2320; TOP HALF INTEGRAL
+# 2321; BOTTOM HALF INTEGRAL

contrib/perl5/lib/unicode/CaseFold.txt

@@ -0,0 +1,821 @@
+# CaseFolding-2.txt
+#
+# Case Folding Properties
+#
+# This file is a supplement to the UnicodeData file.
+# It provides a case folding mapping generated from the Unicode Character Database.
+# If all characters are mapped according to this mapping, then
+# case differences (according to UnicodeData.txt and SpecialCasing.txt)
+# are eliminated.
+#
+# For information on case folding, see 
+# UTR #21 Case Mappings, at http://www.unicode.org/unicode/reports/tr21/
+#
+# These are informative character properties.
+#
+# Send comments to mark@unicode.org
+#
+# ================================================================================
+# Format
+# ================================================================================
+# The entries in this file are in the following machine-readable format:
+#
+# <code>; <status>; <mapping>; # <name>
+#
+# The status is:
+#   L (for Lowercase) if the case mapping matches the standard 1-1 lowercase mapping
+#   E (for exception) if it does not.
+#
+# The mapping may consist of multiple characters.
+# If so, they are separated by spaces.
+#
+# =================================================================
+
+0041; L; 0061;	#LATIN CAPITAL LETTER A
+0042; L; 0062;	#LATIN CAPITAL LETTER B
+0043; L; 0063;	#LATIN CAPITAL LETTER C
+0044; L; 0064;	#LATIN CAPITAL LETTER D
+0045; L; 0065;	#LATIN CAPITAL LETTER E
+0046; L; 0066;	#LATIN CAPITAL LETTER F
+0047; L; 0067;	#LATIN CAPITAL LETTER G
+0048; L; 0068;	#LATIN CAPITAL LETTER H
+0049; L; 0069;	#LATIN CAPITAL LETTER I
+004A; L; 006A;	#LATIN CAPITAL LETTER J
+004B; L; 006B;	#LATIN CAPITAL LETTER K
+004C; L; 006C;	#LATIN CAPITAL LETTER L
+004D; L; 006D;	#LATIN CAPITAL LETTER M
+004E; L; 006E;	#LATIN CAPITAL LETTER N
+004F; L; 006F;	#LATIN CAPITAL LETTER O
+0050; L; 0070;	#LATIN CAPITAL LETTER P
+0051; L; 0071;	#LATIN CAPITAL LETTER Q
+0052; L; 0072;	#LATIN CAPITAL LETTER R
+0053; L; 0073;	#LATIN CAPITAL LETTER S
+0054; L; 0074;	#LATIN CAPITAL LETTER T
+0055; L; 0075;	#LATIN CAPITAL LETTER U
+0056; L; 0076;	#LATIN CAPITAL LETTER V
+0057; L; 0077;	#LATIN CAPITAL LETTER W
+0058; L; 0078;	#LATIN CAPITAL LETTER X
+0059; L; 0079;	#LATIN CAPITAL LETTER Y
+005A; L; 007A;	#LATIN CAPITAL LETTER Z
+00B5; E; 03BC;	#MICRO SIGN
+00C0; L; 00E0;	#LATIN CAPITAL LETTER A WITH GRAVE
+00C1; L; 00E1;	#LATIN CAPITAL LETTER A WITH ACUTE
+00C2; L; 00E2;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+00C3; L; 00E3;	#LATIN CAPITAL LETTER A WITH TILDE
+00C4; L; 00E4;	#LATIN CAPITAL LETTER A WITH DIAERESIS
+00C5; L; 00E5;	#LATIN CAPITAL LETTER A WITH RING ABOVE
+00C6; L; 00E6;	#LATIN CAPITAL LETTER AE
+00C7; L; 00E7;	#LATIN CAPITAL LETTER C WITH CEDILLA
+00C8; L; 00E8;	#LATIN CAPITAL LETTER E WITH GRAVE
+00C9; L; 00E9;	#LATIN CAPITAL LETTER E WITH ACUTE
+00CA; L; 00EA;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+00CB; L; 00EB;	#LATIN CAPITAL LETTER E WITH DIAERESIS
+00CC; L; 00EC;	#LATIN CAPITAL LETTER I WITH GRAVE
+00CD; L; 00ED;	#LATIN CAPITAL LETTER I WITH ACUTE
+00CE; L; 00EE;	#LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+00CF; L; 00EF;	#LATIN CAPITAL LETTER I WITH DIAERESIS
+00D0; L; 00F0;	#LATIN CAPITAL LETTER ETH
+00D1; L; 00F1;	#LATIN CAPITAL LETTER N WITH TILDE
+00D2; L; 00F2;	#LATIN CAPITAL LETTER O WITH GRAVE
+00D3; L; 00F3;	#LATIN CAPITAL LETTER O WITH ACUTE
+00D4; L; 00F4;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+00D5; L; 00F5;	#LATIN CAPITAL LETTER O WITH TILDE
+00D6; L; 00F6;	#LATIN CAPITAL LETTER O WITH DIAERESIS
+00D8; L; 00F8;	#LATIN CAPITAL LETTER O WITH STROKE
+00D9; L; 00F9;	#LATIN CAPITAL LETTER U WITH GRAVE
+00DA; L; 00FA;	#LATIN CAPITAL LETTER U WITH ACUTE
+00DB; L; 00FB;	#LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+00DC; L; 00FC;	#LATIN CAPITAL LETTER U WITH DIAERESIS
+00DD; L; 00FD;	#LATIN CAPITAL LETTER Y WITH ACUTE
+00DE; L; 00FE;	#LATIN CAPITAL LETTER THORN
+00DF; E; 0073 0073;	#LATIN SMALL LETTER SHARP S
+0100; L; 0101;	#LATIN CAPITAL LETTER A WITH MACRON
+0102; L; 0103;	#LATIN CAPITAL LETTER A WITH BREVE
+0104; L; 0105;	#LATIN CAPITAL LETTER A WITH OGONEK
+0106; L; 0107;	#LATIN CAPITAL LETTER C WITH ACUTE
+0108; L; 0109;	#LATIN CAPITAL LETTER C WITH CIRCUMFLEX
+010A; L; 010B;	#LATIN CAPITAL LETTER C WITH DOT ABOVE
+010C; L; 010D;	#LATIN CAPITAL LETTER C WITH CARON
+010E; L; 010F;	#LATIN CAPITAL LETTER D WITH CARON
+0110; L; 0111;	#LATIN CAPITAL LETTER D WITH STROKE
+0112; L; 0113;	#LATIN CAPITAL LETTER E WITH MACRON
+0114; L; 0115;	#LATIN CAPITAL LETTER E WITH BREVE
+0116; L; 0117;	#LATIN CAPITAL LETTER E WITH DOT ABOVE
+0118; L; 0119;	#LATIN CAPITAL LETTER E WITH OGONEK
+011A; L; 011B;	#LATIN CAPITAL LETTER E WITH CARON
+011C; L; 011D;	#LATIN CAPITAL LETTER G WITH CIRCUMFLEX
+011E; L; 011F;	#LATIN CAPITAL LETTER G WITH BREVE
+0120; L; 0121;	#LATIN CAPITAL LETTER G WITH DOT ABOVE
+0122; L; 0123;	#LATIN CAPITAL LETTER G WITH CEDILLA
+0124; L; 0125;	#LATIN CAPITAL LETTER H WITH CIRCUMFLEX
+0126; L; 0127;	#LATIN CAPITAL LETTER H WITH STROKE
+0128; L; 0129;	#LATIN CAPITAL LETTER I WITH TILDE
+012A; L; 012B;	#LATIN CAPITAL LETTER I WITH MACRON
+012C; L; 012D;	#LATIN CAPITAL LETTER I WITH BREVE
+012E; L; 012F;	#LATIN CAPITAL LETTER I WITH OGONEK
+0130; L; 0069;	#LATIN CAPITAL LETTER I WITH DOT ABOVE
+0131; E; 0069;	#LATIN SMALL LETTER DOTLESS I
+0132; L; 0133;	#LATIN CAPITAL LIGATURE IJ
+0134; L; 0135;	#LATIN CAPITAL LETTER J WITH CIRCUMFLEX
+0136; L; 0137;	#LATIN CAPITAL LETTER K WITH CEDILLA
+0139; L; 013A;	#LATIN CAPITAL LETTER L WITH ACUTE
+013B; L; 013C;	#LATIN CAPITAL LETTER L WITH CEDILLA
+013D; L; 013E;	#LATIN CAPITAL LETTER L WITH CARON
+013F; L; 0140;	#LATIN CAPITAL LETTER L WITH MIDDLE DOT
+0141; L; 0142;	#LATIN CAPITAL LETTER L WITH STROKE
+0143; L; 0144;	#LATIN CAPITAL LETTER N WITH ACUTE
+0145; L; 0146;	#LATIN CAPITAL LETTER N WITH CEDILLA
+0147; L; 0148;	#LATIN CAPITAL LETTER N WITH CARON
+0149; E; 02BC 006E;	#LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+014A; L; 014B;	#LATIN CAPITAL LETTER ENG
+014C; L; 014D;	#LATIN CAPITAL LETTER O WITH MACRON
+014E; L; 014F;	#LATIN CAPITAL LETTER O WITH BREVE
+0150; L; 0151;	#LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
+0152; L; 0153;	#LATIN CAPITAL LIGATURE OE
+0154; L; 0155;	#LATIN CAPITAL LETTER R WITH ACUTE
+0156; L; 0157;	#LATIN CAPITAL LETTER R WITH CEDILLA
+0158; L; 0159;	#LATIN CAPITAL LETTER R WITH CARON
+015A; L; 015B;	#LATIN CAPITAL LETTER S WITH ACUTE
+015C; L; 015D;	#LATIN CAPITAL LETTER S WITH CIRCUMFLEX
+015E; L; 015F;	#LATIN CAPITAL LETTER S WITH CEDILLA
+0160; L; 0161;	#LATIN CAPITAL LETTER S WITH CARON
+0162; L; 0163;	#LATIN CAPITAL LETTER T WITH CEDILLA
+0164; L; 0165;	#LATIN CAPITAL LETTER T WITH CARON
+0166; L; 0167;	#LATIN CAPITAL LETTER T WITH STROKE
+0168; L; 0169;	#LATIN CAPITAL LETTER U WITH TILDE
+016A; L; 016B;	#LATIN CAPITAL LETTER U WITH MACRON
+016C; L; 016D;	#LATIN CAPITAL LETTER U WITH BREVE
+016E; L; 016F;	#LATIN CAPITAL LETTER U WITH RING ABOVE
+0170; L; 0171;	#LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
+0172; L; 0173;	#LATIN CAPITAL LETTER U WITH OGONEK
+0174; L; 0175;	#LATIN CAPITAL LETTER W WITH CIRCUMFLEX
+0176; L; 0177;	#LATIN CAPITAL LETTER Y WITH CIRCUMFLEX
+0178; L; 00FF;	#LATIN CAPITAL LETTER Y WITH DIAERESIS
+0179; L; 017A;	#LATIN CAPITAL LETTER Z WITH ACUTE
+017B; L; 017C;	#LATIN CAPITAL LETTER Z WITH DOT ABOVE
+017D; L; 017E;	#LATIN CAPITAL LETTER Z WITH CARON
+017F; E; 0073;	#LATIN SMALL LETTER LONG S
+0181; L; 0253;	#LATIN CAPITAL LETTER B WITH HOOK
+0182; L; 0183;	#LATIN CAPITAL LETTER B WITH TOPBAR
+0184; L; 0185;	#LATIN CAPITAL LETTER TONE SIX
+0186; L; 0254;	#LATIN CAPITAL LETTER OPEN O
+0187; L; 0188;	#LATIN CAPITAL LETTER C WITH HOOK
+0189; L; 0256;	#LATIN CAPITAL LETTER AFRICAN D
+018A; L; 0257;	#LATIN CAPITAL LETTER D WITH HOOK
+018B; L; 018C;	#LATIN CAPITAL LETTER D WITH TOPBAR
+018E; L; 01DD;	#LATIN CAPITAL LETTER REVERSED E
+018F; L; 0259;	#LATIN CAPITAL LETTER SCHWA
+0190; L; 025B;	#LATIN CAPITAL LETTER OPEN E
+0191; L; 0192;	#LATIN CAPITAL LETTER F WITH HOOK
+0193; L; 0260;	#LATIN CAPITAL LETTER G WITH HOOK
+0194; L; 0263;	#LATIN CAPITAL LETTER GAMMA
+0196; L; 0269;	#LATIN CAPITAL LETTER IOTA
+0197; L; 0268;	#LATIN CAPITAL LETTER I WITH STROKE
+0198; L; 0199;	#LATIN CAPITAL LETTER K WITH HOOK
+019C; L; 026F;	#LATIN CAPITAL LETTER TURNED M
+019D; L; 0272;	#LATIN CAPITAL LETTER N WITH LEFT HOOK
+019F; L; 0275;	#LATIN CAPITAL LETTER O WITH MIDDLE TILDE
+01A0; L; 01A1;	#LATIN CAPITAL LETTER O WITH HORN
+01A2; L; 01A3;	#LATIN CAPITAL LETTER OI
+01A4; L; 01A5;	#LATIN CAPITAL LETTER P WITH HOOK
+01A6; L; 0280;	#LATIN LETTER YR
+01A7; L; 01A8;	#LATIN CAPITAL LETTER TONE TWO
+01A9; L; 0283;	#LATIN CAPITAL LETTER ESH
+01AC; L; 01AD;	#LATIN CAPITAL LETTER T WITH HOOK
+01AE; L; 0288;	#LATIN CAPITAL LETTER T WITH RETROFLEX HOOK
+01AF; L; 01B0;	#LATIN CAPITAL LETTER U WITH HORN
+01B1; L; 028A;	#LATIN CAPITAL LETTER UPSILON
+01B2; L; 028B;	#LATIN CAPITAL LETTER V WITH HOOK
+01B3; L; 01B4;	#LATIN CAPITAL LETTER Y WITH HOOK
+01B5; L; 01B6;	#LATIN CAPITAL LETTER Z WITH STROKE
+01B7; L; 0292;	#LATIN CAPITAL LETTER EZH
+01B8; L; 01B9;	#LATIN CAPITAL LETTER EZH REVERSED
+01BC; L; 01BD;	#LATIN CAPITAL LETTER TONE FIVE
+01C4; L; 01C6;	#LATIN CAPITAL LETTER DZ WITH CARON
+01C5; L; 01C6;	#LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
+01C7; L; 01C9;	#LATIN CAPITAL LETTER LJ
+01C8; L; 01C9;	#LATIN CAPITAL LETTER L WITH SMALL LETTER J
+01CA; L; 01CC;	#LATIN CAPITAL LETTER NJ
+01CB; L; 01CC;	#LATIN CAPITAL LETTER N WITH SMALL LETTER J
+01CD; L; 01CE;	#LATIN CAPITAL LETTER A WITH CARON
+01CF; L; 01D0;	#LATIN CAPITAL LETTER I WITH CARON
+01D1; L; 01D2;	#LATIN CAPITAL LETTER O WITH CARON
+01D3; L; 01D4;	#LATIN CAPITAL LETTER U WITH CARON
+01D5; L; 01D6;	#LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON
+01D7; L; 01D8;	#LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE
+01D9; L; 01DA;	#LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON
+01DB; L; 01DC;	#LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE
+01DE; L; 01DF;	#LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON
+01E0; L; 01E1;	#LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON
+01E2; L; 01E3;	#LATIN CAPITAL LETTER AE WITH MACRON
+01E4; L; 01E5;	#LATIN CAPITAL LETTER G WITH STROKE
+01E6; L; 01E7;	#LATIN CAPITAL LETTER G WITH CARON
+01E8; L; 01E9;	#LATIN CAPITAL LETTER K WITH CARON
+01EA; L; 01EB;	#LATIN CAPITAL LETTER O WITH OGONEK
+01EC; L; 01ED;	#LATIN CAPITAL LETTER O WITH OGONEK AND MACRON
+01EE; L; 01EF;	#LATIN CAPITAL LETTER EZH WITH CARON
+01F0; E; 006A 030C;	#LATIN SMALL LETTER J WITH CARON
+01F1; L; 01F3;	#LATIN CAPITAL LETTER DZ
+01F2; L; 01F3;	#LATIN CAPITAL LETTER D WITH SMALL LETTER Z
+01F4; L; 01F5;	#LATIN CAPITAL LETTER G WITH ACUTE
+01F6; L; 0195;	#LATIN CAPITAL LETTER HWAIR
+01F7; L; 01BF;	#LATIN CAPITAL LETTER WYNN
+01F8; L; 01F9;	#LATIN CAPITAL LETTER N WITH GRAVE
+01FA; L; 01FB;	#LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE
+01FC; L; 01FD;	#LATIN CAPITAL LETTER AE WITH ACUTE
+01FE; L; 01FF;	#LATIN CAPITAL LETTER O WITH STROKE AND ACUTE
+0200; L; 0201;	#LATIN CAPITAL LETTER A WITH DOUBLE GRAVE
+0202; L; 0203;	#LATIN CAPITAL LETTER A WITH INVERTED BREVE
+0204; L; 0205;	#LATIN CAPITAL LETTER E WITH DOUBLE GRAVE
+0206; L; 0207;	#LATIN CAPITAL LETTER E WITH INVERTED BREVE
+0208; L; 0209;	#LATIN CAPITAL LETTER I WITH DOUBLE GRAVE
+020A; L; 020B;	#LATIN CAPITAL LETTER I WITH INVERTED BREVE
+020C; L; 020D;	#LATIN CAPITAL LETTER O WITH DOUBLE GRAVE
+020E; L; 020F;	#LATIN CAPITAL LETTER O WITH INVERTED BREVE
+0210; L; 0211;	#LATIN CAPITAL LETTER R WITH DOUBLE GRAVE
+0212; L; 0213;	#LATIN CAPITAL LETTER R WITH INVERTED BREVE
+0214; L; 0215;	#LATIN CAPITAL LETTER U WITH DOUBLE GRAVE
+0216; L; 0217;	#LATIN CAPITAL LETTER U WITH INVERTED BREVE
+0218; L; 0219;	#LATIN CAPITAL LETTER S WITH COMMA BELOW
+021A; L; 021B;	#LATIN CAPITAL LETTER T WITH COMMA BELOW
+021C; L; 021D;	#LATIN CAPITAL LETTER YOGH
+021E; L; 021F;	#LATIN CAPITAL LETTER H WITH CARON
+0222; L; 0223;	#LATIN CAPITAL LETTER OU
+0224; L; 0225;	#LATIN CAPITAL LETTER Z WITH HOOK
+0226; L; 0227;	#LATIN CAPITAL LETTER A WITH DOT ABOVE
+0228; L; 0229;	#LATIN CAPITAL LETTER E WITH CEDILLA
+022A; L; 022B;	#LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON
+022C; L; 022D;	#LATIN CAPITAL LETTER O WITH TILDE AND MACRON
+022E; L; 022F;	#LATIN CAPITAL LETTER O WITH DOT ABOVE
+0230; L; 0231;	#LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON
+0232; L; 0233;	#LATIN CAPITAL LETTER Y WITH MACRON
+0345; E; 03B9;	#COMBINING GREEK YPOGEGRAMMENI
+0386; L; 03AC;	#GREEK CAPITAL LETTER ALPHA WITH TONOS
+0388; L; 03AD;	#GREEK CAPITAL LETTER EPSILON WITH TONOS
+0389; L; 03AE;	#GREEK CAPITAL LETTER ETA WITH TONOS
+038A; L; 03AF;	#GREEK CAPITAL LETTER IOTA WITH TONOS
+038C; L; 03CC;	#GREEK CAPITAL LETTER OMICRON WITH TONOS
+038E; L; 03CD;	#GREEK CAPITAL LETTER UPSILON WITH TONOS
+038F; L; 03CE;	#GREEK CAPITAL LETTER OMEGA WITH TONOS
+0390; E; 03B9 0308 0301;	#GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+0391; L; 03B1;	#GREEK CAPITAL LETTER ALPHA
+0392; L; 03B2;	#GREEK CAPITAL LETTER BETA
+0393; L; 03B3;	#GREEK CAPITAL LETTER GAMMA
+0394; L; 03B4;	#GREEK CAPITAL LETTER DELTA
+0395; L; 03B5;	#GREEK CAPITAL LETTER EPSILON
+0396; L; 03B6;	#GREEK CAPITAL LETTER ZETA
+0397; L; 03B7;	#GREEK CAPITAL LETTER ETA
+0398; L; 03B8;	#GREEK CAPITAL LETTER THETA
+0399; L; 03B9;	#GREEK CAPITAL LETTER IOTA
+039A; L; 03BA;	#GREEK CAPITAL LETTER KAPPA
+039B; L; 03BB;	#GREEK CAPITAL LETTER LAMDA
+039C; L; 03BC;	#GREEK CAPITAL LETTER MU
+039D; L; 03BD;	#GREEK CAPITAL LETTER NU
+039E; L; 03BE;	#GREEK CAPITAL LETTER XI
+039F; L; 03BF;	#GREEK CAPITAL LETTER OMICRON
+03A0; L; 03C0;	#GREEK CAPITAL LETTER PI
+03A1; L; 03C1;	#GREEK CAPITAL LETTER RHO
+03A3; E; 03C2;	#GREEK CAPITAL LETTER SIGMA
+03A4; L; 03C4;	#GREEK CAPITAL LETTER TAU
+03A5; L; 03C5;	#GREEK CAPITAL LETTER UPSILON
+03A6; L; 03C6;	#GREEK CAPITAL LETTER PHI
+03A7; L; 03C7;	#GREEK CAPITAL LETTER CHI
+03A8; L; 03C8;	#GREEK CAPITAL LETTER PSI
+03A9; L; 03C9;	#GREEK CAPITAL LETTER OMEGA
+03AA; L; 03CA;	#GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+03AB; L; 03CB;	#GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+03B0; E; 03C5 0308 0301;	#GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+03C2; L; 03C2;	#GREEK SMALL LETTER FINAL SIGMA
+03C3; E; 03C2;	#GREEK SMALL LETTER SIGMA
+03D0; E; 03B2;	#GREEK BETA SYMBOL
+03D1; E; 03B8;	#GREEK THETA SYMBOL
+03D5; E; 03C6;	#GREEK PHI SYMBOL
+03D6; E; 03C0;	#GREEK PI SYMBOL
+03DA; L; 03DB;	#GREEK LETTER STIGMA
+03DC; L; 03DD;	#GREEK LETTER DIGAMMA
+03DE; L; 03DF;	#GREEK LETTER KOPPA
+03E0; L; 03E1;	#GREEK LETTER SAMPI
+03E2; L; 03E3;	#COPTIC CAPITAL LETTER SHEI
+03E4; L; 03E5;	#COPTIC CAPITAL LETTER FEI
+03E6; L; 03E7;	#COPTIC CAPITAL LETTER KHEI
+03E8; L; 03E9;	#COPTIC CAPITAL LETTER HORI
+03EA; L; 03EB;	#COPTIC CAPITAL LETTER GANGIA
+03EC; L; 03ED;	#COPTIC CAPITAL LETTER SHIMA
+03EE; L; 03EF;	#COPTIC CAPITAL LETTER DEI
+03F0; E; 03BA;	#GREEK KAPPA SYMBOL
+03F1; E; 03C1;	#GREEK RHO SYMBOL
+03F2; E; 03C2;	#GREEK LUNATE SIGMA SYMBOL
+0400; L; 0450;	#CYRILLIC CAPITAL LETTER IE WITH GRAVE
+0401; L; 0451;	#CYRILLIC CAPITAL LETTER IO
+0402; L; 0452;	#CYRILLIC CAPITAL LETTER DJE
+0403; L; 0453;	#CYRILLIC CAPITAL LETTER GJE
+0404; L; 0454;	#CYRILLIC CAPITAL LETTER UKRAINIAN IE
+0405; L; 0455;	#CYRILLIC CAPITAL LETTER DZE
+0406; L; 0456;	#CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
+0407; L; 0457;	#CYRILLIC CAPITAL LETTER YI
+0408; L; 0458;	#CYRILLIC CAPITAL LETTER JE
+0409; L; 0459;	#CYRILLIC CAPITAL LETTER LJE
+040A; L; 045A;	#CYRILLIC CAPITAL LETTER NJE
+040B; L; 045B;	#CYRILLIC CAPITAL LETTER TSHE
+040C; L; 045C;	#CYRILLIC CAPITAL LETTER KJE
+040D; L; 045D;	#CYRILLIC CAPITAL LETTER I WITH GRAVE
+040E; L; 045E;	#CYRILLIC CAPITAL LETTER SHORT U
+040F; L; 045F;	#CYRILLIC CAPITAL LETTER DZHE
+0410; L; 0430;	#CYRILLIC CAPITAL LETTER A
+0411; L; 0431;	#CYRILLIC CAPITAL LETTER BE
+0412; L; 0432;	#CYRILLIC CAPITAL LETTER VE
+0413; L; 0433;	#CYRILLIC CAPITAL LETTER GHE
+0414; L; 0434;	#CYRILLIC CAPITAL LETTER DE
+0415; L; 0435;	#CYRILLIC CAPITAL LETTER IE
+0416; L; 0436;	#CYRILLIC CAPITAL LETTER ZHE
+0417; L; 0437;	#CYRILLIC CAPITAL LETTER ZE
+0418; L; 0438;	#CYRILLIC CAPITAL LETTER I
+0419; L; 0439;	#CYRILLIC CAPITAL LETTER SHORT I
+041A; L; 043A;	#CYRILLIC CAPITAL LETTER KA
+041B; L; 043B;	#CYRILLIC CAPITAL LETTER EL
+041C; L; 043C;	#CYRILLIC CAPITAL LETTER EM
+041D; L; 043D;	#CYRILLIC CAPITAL LETTER EN
+041E; L; 043E;	#CYRILLIC CAPITAL LETTER O
+041F; L; 043F;	#CYRILLIC CAPITAL LETTER PE
+0420; L; 0440;	#CYRILLIC CAPITAL LETTER ER
+0421; L; 0441;	#CYRILLIC CAPITAL LETTER ES
+0422; L; 0442;	#CYRILLIC CAPITAL LETTER TE
+0423; L; 0443;	#CYRILLIC CAPITAL LETTER U
+0424; L; 0444;	#CYRILLIC CAPITAL LETTER EF
+0425; L; 0445;	#CYRILLIC CAPITAL LETTER HA
+0426; L; 0446;	#CYRILLIC CAPITAL LETTER TSE
+0427; L; 0447;	#CYRILLIC CAPITAL LETTER CHE
+0428; L; 0448;	#CYRILLIC CAPITAL LETTER SHA
+0429; L; 0449;	#CYRILLIC CAPITAL LETTER SHCHA
+042A; L; 044A;	#CYRILLIC CAPITAL LETTER HARD SIGN
+042B; L; 044B;	#CYRILLIC CAPITAL LETTER YERU
+042C; L; 044C;	#CYRILLIC CAPITAL LETTER SOFT SIGN
+042D; L; 044D;	#CYRILLIC CAPITAL LETTER E
+042E; L; 044E;	#CYRILLIC CAPITAL LETTER YU
+042F; L; 044F;	#CYRILLIC CAPITAL LETTER YA
+0460; L; 0461;	#CYRILLIC CAPITAL LETTER OMEGA
+0462; L; 0463;	#CYRILLIC CAPITAL LETTER YAT
+0464; L; 0465;	#CYRILLIC CAPITAL LETTER IOTIFIED E
+0466; L; 0467;	#CYRILLIC CAPITAL LETTER LITTLE YUS
+0468; L; 0469;	#CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS
+046A; L; 046B;	#CYRILLIC CAPITAL LETTER BIG YUS
+046C; L; 046D;	#CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS
+046E; L; 046F;	#CYRILLIC CAPITAL LETTER KSI
+0470; L; 0471;	#CYRILLIC CAPITAL LETTER PSI
+0472; L; 0473;	#CYRILLIC CAPITAL LETTER FITA
+0474; L; 0475;	#CYRILLIC CAPITAL LETTER IZHITSA
+0476; L; 0477;	#CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT
+0478; L; 0479;	#CYRILLIC CAPITAL LETTER UK
+047A; L; 047B;	#CYRILLIC CAPITAL LETTER ROUND OMEGA
+047C; L; 047D;	#CYRILLIC CAPITAL LETTER OMEGA WITH TITLO
+047E; L; 047F;	#CYRILLIC CAPITAL LETTER OT
+0480; L; 0481;	#CYRILLIC CAPITAL LETTER KOPPA
+048C; L; 048D;	#CYRILLIC CAPITAL LETTER SEMISOFT SIGN
+048E; L; 048F;	#CYRILLIC CAPITAL LETTER ER WITH TICK
+0490; L; 0491;	#CYRILLIC CAPITAL LETTER GHE WITH UPTURN
+0492; L; 0493;	#CYRILLIC CAPITAL LETTER GHE WITH STROKE
+0494; L; 0495;	#CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK
+0496; L; 0497;	#CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER
+0498; L; 0499;	#CYRILLIC CAPITAL LETTER ZE WITH DESCENDER
+049A; L; 049B;	#CYRILLIC CAPITAL LETTER KA WITH DESCENDER
+049C; L; 049D;	#CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE
+049E; L; 049F;	#CYRILLIC CAPITAL LETTER KA WITH STROKE
+04A0; L; 04A1;	#CYRILLIC CAPITAL LETTER BASHKIR KA
+04A2; L; 04A3;	#CYRILLIC CAPITAL LETTER EN WITH DESCENDER
+04A4; L; 04A5;	#CYRILLIC CAPITAL LIGATURE EN GHE
+04A6; L; 04A7;	#CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK
+04A8; L; 04A9;	#CYRILLIC CAPITAL LETTER ABKHASIAN HA
+04AA; L; 04AB;	#CYRILLIC CAPITAL LETTER ES WITH DESCENDER
+04AC; L; 04AD;	#CYRILLIC CAPITAL LETTER TE WITH DESCENDER
+04AE; L; 04AF;	#CYRILLIC CAPITAL LETTER STRAIGHT U
+04B0; L; 04B1;	#CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE
+04B2; L; 04B3;	#CYRILLIC CAPITAL LETTER HA WITH DESCENDER
+04B4; L; 04B5;	#CYRILLIC CAPITAL LIGATURE TE TSE
+04B6; L; 04B7;	#CYRILLIC CAPITAL LETTER CHE WITH DESCENDER
+04B8; L; 04B9;	#CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE
+04BA; L; 04BB;	#CYRILLIC CAPITAL LETTER SHHA
+04BC; L; 04BD;	#CYRILLIC CAPITAL LETTER ABKHASIAN CHE
+04BE; L; 04BF;	#CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER
+04C1; L; 04C2;	#CYRILLIC CAPITAL LETTER ZHE WITH BREVE
+04C3; L; 04C4;	#CYRILLIC CAPITAL LETTER KA WITH HOOK
+04C7; L; 04C8;	#CYRILLIC CAPITAL LETTER EN WITH HOOK
+04CB; L; 04CC;	#CYRILLIC CAPITAL LETTER KHAKASSIAN CHE
+04D0; L; 04D1;	#CYRILLIC CAPITAL LETTER A WITH BREVE
+04D2; L; 04D3;	#CYRILLIC CAPITAL LETTER A WITH DIAERESIS
+04D4; L; 04D5;	#CYRILLIC CAPITAL LIGATURE A IE
+04D6; L; 04D7;	#CYRILLIC CAPITAL LETTER IE WITH BREVE
+04D8; L; 04D9;	#CYRILLIC CAPITAL LETTER SCHWA
+04DA; L; 04DB;	#CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS
+04DC; L; 04DD;	#CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS
+04DE; L; 04DF;	#CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS
+04E0; L; 04E1;	#CYRILLIC CAPITAL LETTER ABKHASIAN DZE
+04E2; L; 04E3;	#CYRILLIC CAPITAL LETTER I WITH MACRON
+04E4; L; 04E5;	#CYRILLIC CAPITAL LETTER I WITH DIAERESIS
+04E6; L; 04E7;	#CYRILLIC CAPITAL LETTER O WITH DIAERESIS
+04E8; L; 04E9;	#CYRILLIC CAPITAL LETTER BARRED O
+04EA; L; 04EB;	#CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS
+04EC; L; 04ED;	#CYRILLIC CAPITAL LETTER E WITH DIAERESIS
+04EE; L; 04EF;	#CYRILLIC CAPITAL LETTER U WITH MACRON
+04F0; L; 04F1;	#CYRILLIC CAPITAL LETTER U WITH DIAERESIS
+04F2; L; 04F3;	#CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE
+04F4; L; 04F5;	#CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS
+04F8; L; 04F9;	#CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS
+0531; L; 0561;	#ARMENIAN CAPITAL LETTER AYB
+0532; L; 0562;	#ARMENIAN CAPITAL LETTER BEN
+0533; L; 0563;	#ARMENIAN CAPITAL LETTER GIM
+0534; L; 0564;	#ARMENIAN CAPITAL LETTER DA
+0535; L; 0565;	#ARMENIAN CAPITAL LETTER ECH
+0536; L; 0566;	#ARMENIAN CAPITAL LETTER ZA
+0537; L; 0567;	#ARMENIAN CAPITAL LETTER EH
+0538; L; 0568;	#ARMENIAN CAPITAL LETTER ET
+0539; L; 0569;	#ARMENIAN CAPITAL LETTER TO
+053A; L; 056A;	#ARMENIAN CAPITAL LETTER ZHE
+053B; L; 056B;	#ARMENIAN CAPITAL LETTER INI
+053C; L; 056C;	#ARMENIAN CAPITAL LETTER LIWN
+053D; L; 056D;	#ARMENIAN CAPITAL LETTER XEH
+053E; L; 056E;	#ARMENIAN CAPITAL LETTER CA
+053F; L; 056F;	#ARMENIAN CAPITAL LETTER KEN
+0540; L; 0570;	#ARMENIAN CAPITAL LETTER HO
+0541; L; 0571;	#ARMENIAN CAPITAL LETTER JA
+0542; L; 0572;	#ARMENIAN CAPITAL LETTER GHAD
+0543; L; 0573;	#ARMENIAN CAPITAL LETTER CHEH
+0544; L; 0574;	#ARMENIAN CAPITAL LETTER MEN
+0545; L; 0575;	#ARMENIAN CAPITAL LETTER YI
+0546; L; 0576;	#ARMENIAN CAPITAL LETTER NOW
+0547; L; 0577;	#ARMENIAN CAPITAL LETTER SHA
+0548; L; 0578;	#ARMENIAN CAPITAL LETTER VO
+0549; L; 0579;	#ARMENIAN CAPITAL LETTER CHA
+054A; L; 057A;	#ARMENIAN CAPITAL LETTER PEH
+054B; L; 057B;	#ARMENIAN CAPITAL LETTER JHEH
+054C; L; 057C;	#ARMENIAN CAPITAL LETTER RA
+054D; L; 057D;	#ARMENIAN CAPITAL LETTER SEH
+054E; L; 057E;	#ARMENIAN CAPITAL LETTER VEW
+054F; L; 057F;	#ARMENIAN CAPITAL LETTER TIWN
+0550; L; 0580;	#ARMENIAN CAPITAL LETTER REH
+0551; L; 0581;	#ARMENIAN CAPITAL LETTER CO
+0552; L; 0582;	#ARMENIAN CAPITAL LETTER YIWN
+0553; L; 0583;	#ARMENIAN CAPITAL LETTER PIWR
+0554; L; 0584;	#ARMENIAN CAPITAL LETTER KEH
+0555; L; 0585;	#ARMENIAN CAPITAL LETTER OH
+0556; L; 0586;	#ARMENIAN CAPITAL LETTER FEH
+0587; E; 0565 0582;	#ARMENIAN SMALL LIGATURE ECH YIWN
+1E00; L; 1E01;	#LATIN CAPITAL LETTER A WITH RING BELOW
+1E02; L; 1E03;	#LATIN CAPITAL LETTER B WITH DOT ABOVE
+1E04; L; 1E05;	#LATIN CAPITAL LETTER B WITH DOT BELOW
+1E06; L; 1E07;	#LATIN CAPITAL LETTER B WITH LINE BELOW
+1E08; L; 1E09;	#LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE
+1E0A; L; 1E0B;	#LATIN CAPITAL LETTER D WITH DOT ABOVE
+1E0C; L; 1E0D;	#LATIN CAPITAL LETTER D WITH DOT BELOW
+1E0E; L; 1E0F;	#LATIN CAPITAL LETTER D WITH LINE BELOW
+1E10; L; 1E11;	#LATIN CAPITAL LETTER D WITH CEDILLA
+1E12; L; 1E13;	#LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW
+1E14; L; 1E15;	#LATIN CAPITAL LETTER E WITH MACRON AND GRAVE
+1E16; L; 1E17;	#LATIN CAPITAL LETTER E WITH MACRON AND ACUTE
+1E18; L; 1E19;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW
+1E1A; L; 1E1B;	#LATIN CAPITAL LETTER E WITH TILDE BELOW
+1E1C; L; 1E1D;	#LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE
+1E1E; L; 1E1F;	#LATIN CAPITAL LETTER F WITH DOT ABOVE
+1E20; L; 1E21;	#LATIN CAPITAL LETTER G WITH MACRON
+1E22; L; 1E23;	#LATIN CAPITAL LETTER H WITH DOT ABOVE
+1E24; L; 1E25;	#LATIN CAPITAL LETTER H WITH DOT BELOW
+1E26; L; 1E27;	#LATIN CAPITAL LETTER H WITH DIAERESIS
+1E28; L; 1E29;	#LATIN CAPITAL LETTER H WITH CEDILLA
+1E2A; L; 1E2B;	#LATIN CAPITAL LETTER H WITH BREVE BELOW
+1E2C; L; 1E2D;	#LATIN CAPITAL LETTER I WITH TILDE BELOW
+1E2E; L; 1E2F;	#LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE
+1E30; L; 1E31;	#LATIN CAPITAL LETTER K WITH ACUTE
+1E32; L; 1E33;	#LATIN CAPITAL LETTER K WITH DOT BELOW
+1E34; L; 1E35;	#LATIN CAPITAL LETTER K WITH LINE BELOW
+1E36; L; 1E37;	#LATIN CAPITAL LETTER L WITH DOT BELOW
+1E38; L; 1E39;	#LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON
+1E3A; L; 1E3B;	#LATIN CAPITAL LETTER L WITH LINE BELOW
+1E3C; L; 1E3D;	#LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW
+1E3E; L; 1E3F;	#LATIN CAPITAL LETTER M WITH ACUTE
+1E40; L; 1E41;	#LATIN CAPITAL LETTER M WITH DOT ABOVE
+1E42; L; 1E43;	#LATIN CAPITAL LETTER M WITH DOT BELOW
+1E44; L; 1E45;	#LATIN CAPITAL LETTER N WITH DOT ABOVE
+1E46; L; 1E47;	#LATIN CAPITAL LETTER N WITH DOT BELOW
+1E48; L; 1E49;	#LATIN CAPITAL LETTER N WITH LINE BELOW
+1E4A; L; 1E4B;	#LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW
+1E4C; L; 1E4D;	#LATIN CAPITAL LETTER O WITH TILDE AND ACUTE
+1E4E; L; 1E4F;	#LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS
+1E50; L; 1E51;	#LATIN CAPITAL LETTER O WITH MACRON AND GRAVE
+1E52; L; 1E53;	#LATIN CAPITAL LETTER O WITH MACRON AND ACUTE
+1E54; L; 1E55;	#LATIN CAPITAL LETTER P WITH ACUTE
+1E56; L; 1E57;	#LATIN CAPITAL LETTER P WITH DOT ABOVE
+1E58; L; 1E59;	#LATIN CAPITAL LETTER R WITH DOT ABOVE
+1E5A; L; 1E5B;	#LATIN CAPITAL LETTER R WITH DOT BELOW
+1E5C; L; 1E5D;	#LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON
+1E5E; L; 1E5F;	#LATIN CAPITAL LETTER R WITH LINE BELOW
+1E60; L; 1E61;	#LATIN CAPITAL LETTER S WITH DOT ABOVE
+1E62; L; 1E63;	#LATIN CAPITAL LETTER S WITH DOT BELOW
+1E64; L; 1E65;	#LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE
+1E66; L; 1E67;	#LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE
+1E68; L; 1E69;	#LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE
+1E6A; L; 1E6B;	#LATIN CAPITAL LETTER T WITH DOT ABOVE
+1E6C; L; 1E6D;	#LATIN CAPITAL LETTER T WITH DOT BELOW
+1E6E; L; 1E6F;	#LATIN CAPITAL LETTER T WITH LINE BELOW
+1E70; L; 1E71;	#LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW
+1E72; L; 1E73;	#LATIN CAPITAL LETTER U WITH DIAERESIS BELOW
+1E74; L; 1E75;	#LATIN CAPITAL LETTER U WITH TILDE BELOW
+1E76; L; 1E77;	#LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW
+1E78; L; 1E79;	#LATIN CAPITAL LETTER U WITH TILDE AND ACUTE
+1E7A; L; 1E7B;	#LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS
+1E7C; L; 1E7D;	#LATIN CAPITAL LETTER V WITH TILDE
+1E7E; L; 1E7F;	#LATIN CAPITAL LETTER V WITH DOT BELOW
+1E80; L; 1E81;	#LATIN CAPITAL LETTER W WITH GRAVE
+1E82; L; 1E83;	#LATIN CAPITAL LETTER W WITH ACUTE
+1E84; L; 1E85;	#LATIN CAPITAL LETTER W WITH DIAERESIS
+1E86; L; 1E87;	#LATIN CAPITAL LETTER W WITH DOT ABOVE
+1E88; L; 1E89;	#LATIN CAPITAL LETTER W WITH DOT BELOW
+1E8A; L; 1E8B;	#LATIN CAPITAL LETTER X WITH DOT ABOVE
+1E8C; L; 1E8D;	#LATIN CAPITAL LETTER X WITH DIAERESIS
+1E8E; L; 1E8F;	#LATIN CAPITAL LETTER Y WITH DOT ABOVE
+1E90; L; 1E91;	#LATIN CAPITAL LETTER Z WITH CIRCUMFLEX
+1E92; L; 1E93;	#LATIN CAPITAL LETTER Z WITH DOT BELOW
+1E94; L; 1E95;	#LATIN CAPITAL LETTER Z WITH LINE BELOW
+1E96; E; 0068 0331;	#LATIN SMALL LETTER H WITH LINE BELOW
+1E97; E; 0074 0308;	#LATIN SMALL LETTER T WITH DIAERESIS
+1E98; E; 0077 030A;	#LATIN SMALL LETTER W WITH RING ABOVE
+1E99; E; 0079 030A;	#LATIN SMALL LETTER Y WITH RING ABOVE
+1E9A; E; 0061 02BE;	#LATIN SMALL LETTER A WITH RIGHT HALF RING
+1E9B; E; 1E61;	#LATIN SMALL LETTER LONG S WITH DOT ABOVE
+1EA0; L; 1EA1;	#LATIN CAPITAL LETTER A WITH DOT BELOW
+1EA2; L; 1EA3;	#LATIN CAPITAL LETTER A WITH HOOK ABOVE
+1EA4; L; 1EA5;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE
+1EA6; L; 1EA7;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE
+1EA8; L; 1EA9;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE
+1EAA; L; 1EAB;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE
+1EAC; L; 1EAD;	#LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW
+1EAE; L; 1EAF;	#LATIN CAPITAL LETTER A WITH BREVE AND ACUTE
+1EB0; L; 1EB1;	#LATIN CAPITAL LETTER A WITH BREVE AND GRAVE
+1EB2; L; 1EB3;	#LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE
+1EB4; L; 1EB5;	#LATIN CAPITAL LETTER A WITH BREVE AND TILDE
+1EB6; L; 1EB7;	#LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW
+1EB8; L; 1EB9;	#LATIN CAPITAL LETTER E WITH DOT BELOW
+1EBA; L; 1EBB;	#LATIN CAPITAL LETTER E WITH HOOK ABOVE
+1EBC; L; 1EBD;	#LATIN CAPITAL LETTER E WITH TILDE
+1EBE; L; 1EBF;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE
+1EC0; L; 1EC1;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE
+1EC2; L; 1EC3;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE
+1EC4; L; 1EC5;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE
+1EC6; L; 1EC7;	#LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW
+1EC8; L; 1EC9;	#LATIN CAPITAL LETTER I WITH HOOK ABOVE
+1ECA; L; 1ECB;	#LATIN CAPITAL LETTER I WITH DOT BELOW
+1ECC; L; 1ECD;	#LATIN CAPITAL LETTER O WITH DOT BELOW
+1ECE; L; 1ECF;	#LATIN CAPITAL LETTER O WITH HOOK ABOVE
+1ED0; L; 1ED1;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE
+1ED2; L; 1ED3;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE
+1ED4; L; 1ED5;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE
+1ED6; L; 1ED7;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE
+1ED8; L; 1ED9;	#LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW
+1EDA; L; 1EDB;	#LATIN CAPITAL LETTER O WITH HORN AND ACUTE
+1EDC; L; 1EDD;	#LATIN CAPITAL LETTER O WITH HORN AND GRAVE
+1EDE; L; 1EDF;	#LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE
+1EE0; L; 1EE1;	#LATIN CAPITAL LETTER O WITH HORN AND TILDE
+1EE2; L; 1EE3;	#LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW
+1EE4; L; 1EE5;	#LATIN CAPITAL LETTER U WITH DOT BELOW
+1EE6; L; 1EE7;	#LATIN CAPITAL LETTER U WITH HOOK ABOVE
+1EE8; L; 1EE9;	#LATIN CAPITAL LETTER U WITH HORN AND ACUTE
+1EEA; L; 1EEB;	#LATIN CAPITAL LETTER U WITH HORN AND GRAVE
+1EEC; L; 1EED;	#LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE
+1EEE; L; 1EEF;	#LATIN CAPITAL LETTER U WITH HORN AND TILDE
+1EF0; L; 1EF1;	#LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW
+1EF2; L; 1EF3;	#LATIN CAPITAL LETTER Y WITH GRAVE
+1EF4; L; 1EF5;	#LATIN CAPITAL LETTER Y WITH DOT BELOW
+1EF6; L; 1EF7;	#LATIN CAPITAL LETTER Y WITH HOOK ABOVE
+1EF8; L; 1EF9;	#LATIN CAPITAL LETTER Y WITH TILDE
+1F08; L; 1F00;	#GREEK CAPITAL LETTER ALPHA WITH PSILI
+1F09; L; 1F01;	#GREEK CAPITAL LETTER ALPHA WITH DASIA
+1F0A; L; 1F02;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA
+1F0B; L; 1F03;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA
+1F0C; L; 1F04;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA
+1F0D; L; 1F05;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA
+1F0E; L; 1F06;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI
+1F0F; L; 1F07;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI
+1F18; L; 1F10;	#GREEK CAPITAL LETTER EPSILON WITH PSILI
+1F19; L; 1F11;	#GREEK CAPITAL LETTER EPSILON WITH DASIA
+1F1A; L; 1F12;	#GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA
+1F1B; L; 1F13;	#GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA
+1F1C; L; 1F14;	#GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA
+1F1D; L; 1F15;	#GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
+1F28; L; 1F20;	#GREEK CAPITAL LETTER ETA WITH PSILI
+1F29; L; 1F21;	#GREEK CAPITAL LETTER ETA WITH DASIA
+1F2A; L; 1F22;	#GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA
+1F2B; L; 1F23;	#GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA
+1F2C; L; 1F24;	#GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA
+1F2D; L; 1F25;	#GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA
+1F2E; L; 1F26;	#GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI
+1F2F; L; 1F27;	#GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI
+1F38; L; 1F30;	#GREEK CAPITAL LETTER IOTA WITH PSILI
+1F39; L; 1F31;	#GREEK CAPITAL LETTER IOTA WITH DASIA
+1F3A; L; 1F32;	#GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA
+1F3B; L; 1F33;	#GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA
+1F3C; L; 1F34;	#GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA
+1F3D; L; 1F35;	#GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA
+1F3E; L; 1F36;	#GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI
+1F3F; L; 1F37;	#GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI
+1F48; L; 1F40;	#GREEK CAPITAL LETTER OMICRON WITH PSILI
+1F49; L; 1F41;	#GREEK CAPITAL LETTER OMICRON WITH DASIA
+1F4A; L; 1F42;	#GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA
+1F4B; L; 1F43;	#GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA
+1F4C; L; 1F44;	#GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA
+1F4D; L; 1F45;	#GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
+1F50; E; 03C5 0313;	#GREEK SMALL LETTER UPSILON WITH PSILI
+1F52; E; 03C5 0313 0300;	#GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA
+1F54; E; 03C5 0313 0301;	#GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA
+1F56; E; 03C5 0313 0342;	#GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI
+1F59; L; 1F51;	#GREEK CAPITAL LETTER UPSILON WITH DASIA
+1F5B; L; 1F53;	#GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
+1F5D; L; 1F55;	#GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
+1F5F; L; 1F57;	#GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI
+1F68; L; 1F60;	#GREEK CAPITAL LETTER OMEGA WITH PSILI
+1F69; L; 1F61;	#GREEK CAPITAL LETTER OMEGA WITH DASIA
+1F6A; L; 1F62;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA
+1F6B; L; 1F63;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA
+1F6C; L; 1F64;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA
+1F6D; L; 1F65;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA
+1F6E; L; 1F66;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI
+1F6F; L; 1F67;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI
+1F80; E; 1F00 03B9;	#GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
+1F81; E; 1F01 03B9;	#GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
+1F82; E; 1F02 03B9;	#GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F83; E; 1F03 03B9;	#GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F84; E; 1F04 03B9;	#GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F85; E; 1F05 03B9;	#GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F86; E; 1F06 03B9;	#GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F87; E; 1F07 03B9;	#GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F88; E; 1F00 03B9;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
+1F89; E; 1F01 03B9;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
+1F8A; E; 1F02 03B9;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F8B; E; 1F03 03B9;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F8C; E; 1F04 03B9;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F8D; E; 1F05 03B9;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F8E; E; 1F06 03B9;	#GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F8F; E; 1F07 03B9;	#GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1F90; E; 1F20 03B9;	#GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI
+1F91; E; 1F21 03B9;	#GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI
+1F92; E; 1F22 03B9;	#GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1F93; E; 1F23 03B9;	#GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1F94; E; 1F24 03B9;	#GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1F95; E; 1F25 03B9;	#GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1F96; E; 1F26 03B9;	#GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1F97; E; 1F27 03B9;	#GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1F98; E; 1F20 03B9;	#GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
+1F99; E; 1F21 03B9;	#GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
+1F9A; E; 1F22 03B9;	#GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1F9B; E; 1F23 03B9;	#GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1F9C; E; 1F24 03B9;	#GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1F9D; E; 1F25 03B9;	#GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1F9E; E; 1F26 03B9;	#GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1F9F; E; 1F27 03B9;	#GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FA0; E; 1F60 03B9;	#GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI
+1FA1; E; 1F61 03B9;	#GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI
+1FA2; E; 1F62 03B9;	#GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI
+1FA3; E; 1F63 03B9;	#GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI
+1FA4; E; 1F64 03B9;	#GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI
+1FA5; E; 1F65 03B9;	#GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI
+1FA6; E; 1F66 03B9;	#GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
+1FA7; E; 1F67 03B9;	#GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
+1FA8; E; 1F60 03B9;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
+1FA9; E; 1F61 03B9;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
+1FAA; E; 1F62 03B9;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
+1FAB; E; 1F63 03B9;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
+1FAC; E; 1F64 03B9;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
+1FAD; E; 1F65 03B9;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
+1FAE; E; 1F66 03B9;	#GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
+1FAF; E; 1F67 03B9;	#GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
+1FB2; E; 1F70 03B9;	#GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
+1FB3; E; 03B1 03B9;	#GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI
+1FB4; E; 03AC 03B9;	#GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FB6; E; 03B1 0342;	#GREEK SMALL LETTER ALPHA WITH PERISPOMENI
+1FB7; E; 03B1 0342 03B9;	#GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FB8; L; 1FB0;	#GREEK CAPITAL LETTER ALPHA WITH VRACHY
+1FB9; L; 1FB1;	#GREEK CAPITAL LETTER ALPHA WITH MACRON
+1FBA; L; 1F70;	#GREEK CAPITAL LETTER ALPHA WITH VARIA
+1FBB; L; 1F71;	#GREEK CAPITAL LETTER ALPHA WITH OXIA
+1FBC; E; 03B1 03B9;	#GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FBE; E; 03B9;	#GREEK PROSGEGRAMMENI
+1FC2; E; 1F74 03B9;	#GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI
+1FC3; E; 03B7 03B9;	#GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI
+1FC4; E; 03AE 03B9;	#GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FC6; E; 03B7 0342;	#GREEK SMALL LETTER ETA WITH PERISPOMENI
+1FC7; E; 03B7 0342 03B9;	#GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FC8; L; 1F72;	#GREEK CAPITAL LETTER EPSILON WITH VARIA
+1FC9; L; 1F73;	#GREEK CAPITAL LETTER EPSILON WITH OXIA
+1FCA; L; 1F74;	#GREEK CAPITAL LETTER ETA WITH VARIA
+1FCB; L; 1F75;	#GREEK CAPITAL LETTER ETA WITH OXIA
+1FCC; E; 03B7 03B9;	#GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FD2; E; 03B9 0308 0300;	#GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
+1FD3; E; 03B9 0308 0301;	#GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD6; E; 03B9 0342;	#GREEK SMALL LETTER IOTA WITH PERISPOMENI
+1FD7; E; 03B9 0308 0342;	#GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI
+1FD8; L; 1FD0;	#GREEK CAPITAL LETTER IOTA WITH VRACHY
+1FD9; L; 1FD1;	#GREEK CAPITAL LETTER IOTA WITH MACRON
+1FDA; L; 1F76;	#GREEK CAPITAL LETTER IOTA WITH VARIA
+1FDB; L; 1F77;	#GREEK CAPITAL LETTER IOTA WITH OXIA
+1FE2; E; 03C5 0308 0300;	#GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
+1FE3; E; 03C5 0308 0301;	#GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
+1FE4; E; 03C1 0313;	#GREEK SMALL LETTER RHO WITH PSILI
+1FE6; E; 03C5 0342;	#GREEK SMALL LETTER UPSILON WITH PERISPOMENI
+1FE7; E; 03C5 0308 0342;	#GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
+1FE8; L; 1FE0;	#GREEK CAPITAL LETTER UPSILON WITH VRACHY
+1FE9; L; 1FE1;	#GREEK CAPITAL LETTER UPSILON WITH MACRON
+1FEA; L; 1F7A;	#GREEK CAPITAL LETTER UPSILON WITH VARIA
+1FEB; L; 1F7B;	#GREEK CAPITAL LETTER UPSILON WITH OXIA
+1FEC; L; 1FE5;	#GREEK CAPITAL LETTER RHO WITH DASIA
+1FF2; E; 1F7C 03B9;	#GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
+1FF3; E; 03C9 03B9;	#GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
+1FF4; E; 03CE 03B9;	#GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+1FF6; E; 03C9 0342;	#GREEK SMALL LETTER OMEGA WITH PERISPOMENI
+1FF7; E; 03C9 0342 03B9;	#GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
+1FF8; L; 1F78;	#GREEK CAPITAL LETTER OMICRON WITH VARIA
+1FF9; L; 1F79;	#GREEK CAPITAL LETTER OMICRON WITH OXIA
+1FFA; L; 1F7C;	#GREEK CAPITAL LETTER OMEGA WITH VARIA
+1FFB; L; 1F7D;	#GREEK CAPITAL LETTER OMEGA WITH OXIA
+1FFC; E; 03C9 03B9;	#GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+2126; L; 03C9;	#OHM SIGN
+212A; L; 006B;	#KELVIN SIGN
+212B; L; 00E5;	#ANGSTROM SIGN
+2160; L; 2170;	#ROMAN NUMERAL ONE
+2161; L; 2171;	#ROMAN NUMERAL TWO
+2162; L; 2172;	#ROMAN NUMERAL THREE
+2163; L; 2173;	#ROMAN NUMERAL FOUR
+2164; L; 2174;	#ROMAN NUMERAL FIVE
+2165; L; 2175;	#ROMAN NUMERAL SIX
+2166; L; 2176;	#ROMAN NUMERAL SEVEN
+2167; L; 2177;	#ROMAN NUMERAL EIGHT
+2168; L; 2178;	#ROMAN NUMERAL NINE
+2169; L; 2179;	#ROMAN NUMERAL TEN
+216A; L; 217A;	#ROMAN NUMERAL ELEVEN
+216B; L; 217B;	#ROMAN NUMERAL TWELVE
+216C; L; 217C;	#ROMAN NUMERAL FIFTY
+216D; L; 217D;	#ROMAN NUMERAL ONE HUNDRED
+216E; L; 217E;	#ROMAN NUMERAL FIVE HUNDRED
+216F; L; 217F;	#ROMAN NUMERAL ONE THOUSAND
+24B6; L; 24D0;	#CIRCLED LATIN CAPITAL LETTER A
+24B7; L; 24D1;	#CIRCLED LATIN CAPITAL LETTER B
+24B8; L; 24D2;	#CIRCLED LATIN CAPITAL LETTER C
+24B9; L; 24D3;	#CIRCLED LATIN CAPITAL LETTER D
+24BA; L; 24D4;	#CIRCLED LATIN CAPITAL LETTER E
+24BB; L; 24D5;	#CIRCLED LATIN CAPITAL LETTER F
+24BC; L; 24D6;	#CIRCLED LATIN CAPITAL LETTER G
+24BD; L; 24D7;	#CIRCLED LATIN CAPITAL LETTER H
+24BE; L; 24D8;	#CIRCLED LATIN CAPITAL LETTER I
+24BF; L; 24D9;	#CIRCLED LATIN CAPITAL LETTER J
+24C0; L; 24DA;	#CIRCLED LATIN CAPITAL LETTER K
+24C1; L; 24DB;	#CIRCLED LATIN CAPITAL LETTER L
+24C2; L; 24DC;	#CIRCLED LATIN CAPITAL LETTER M
+24C3; L; 24DD;	#CIRCLED LATIN CAPITAL LETTER N
+24C4; L; 24DE;	#CIRCLED LATIN CAPITAL LETTER O
+24C5; L; 24DF;	#CIRCLED LATIN CAPITAL LETTER P
+24C6; L; 24E0;	#CIRCLED LATIN CAPITAL LETTER Q
+24C7; L; 24E1;	#CIRCLED LATIN CAPITAL LETTER R
+24C8; L; 24E2;	#CIRCLED LATIN CAPITAL LETTER S
+24C9; L; 24E3;	#CIRCLED LATIN CAPITAL LETTER T
+24CA; L; 24E4;	#CIRCLED LATIN CAPITAL LETTER U
+24CB; L; 24E5;	#CIRCLED LATIN CAPITAL LETTER V
+24CC; L; 24E6;	#CIRCLED LATIN CAPITAL LETTER W
+24CD; L; 24E7;	#CIRCLED LATIN CAPITAL LETTER X
+24CE; L; 24E8;	#CIRCLED LATIN CAPITAL LETTER Y
+24CF; L; 24E9;	#CIRCLED LATIN CAPITAL LETTER Z
+FB00; E; 0066 0066;	#LATIN SMALL LIGATURE FF
+FB01; E; 0066 0069;	#LATIN SMALL LIGATURE FI
+FB02; E; 0066 006C;	#LATIN SMALL LIGATURE FL
+FB03; E; 0066 0066 0069;	#LATIN SMALL LIGATURE FFI
+FB04; E; 0066 0066 006C;	#LATIN SMALL LIGATURE FFL
+FB05; E; 0073 0074;	#LATIN SMALL LIGATURE LONG S T
+FB06; E; 0073 0074;	#LATIN SMALL LIGATURE ST
+FB13; E; 0574 0576;	#ARMENIAN SMALL LIGATURE MEN NOW
+FB14; E; 0574 0565;	#ARMENIAN SMALL LIGATURE MEN ECH
+FB15; E; 0574 056B;	#ARMENIAN SMALL LIGATURE MEN INI
+FB16; E; 057E 0576;	#ARMENIAN SMALL LIGATURE VEW NOW
+FB17; E; 0574 056D;	#ARMENIAN SMALL LIGATURE MEN XEH
+FF21; L; FF41;	#FULLWIDTH LATIN CAPITAL LETTER A
+FF22; L; FF42;	#FULLWIDTH LATIN CAPITAL LETTER B
+FF23; L; FF43;	#FULLWIDTH LATIN CAPITAL LETTER C
+FF24; L; FF44;	#FULLWIDTH LATIN CAPITAL LETTER D
+FF25; L; FF45;	#FULLWIDTH LATIN CAPITAL LETTER E
+FF26; L; FF46;	#FULLWIDTH LATIN CAPITAL LETTER F
+FF27; L; FF47;	#FULLWIDTH LATIN CAPITAL LETTER G
+FF28; L; FF48;	#FULLWIDTH LATIN CAPITAL LETTER H
+FF29; L; FF49;	#FULLWIDTH LATIN CAPITAL LETTER I
+FF2A; L; FF4A;	#FULLWIDTH LATIN CAPITAL LETTER J
+FF2B; L; FF4B;	#FULLWIDTH LATIN CAPITAL LETTER K
+FF2C; L; FF4C;	#FULLWIDTH LATIN CAPITAL LETTER L
+FF2D; L; FF4D;	#FULLWIDTH LATIN CAPITAL LETTER M
+FF2E; L; FF4E;	#FULLWIDTH LATIN CAPITAL LETTER N
+FF2F; L; FF4F;	#FULLWIDTH LATIN CAPITAL LETTER O
+FF30; L; FF50;	#FULLWIDTH LATIN CAPITAL LETTER P
+FF31; L; FF51;	#FULLWIDTH LATIN CAPITAL LETTER Q
+FF32; L; FF52;	#FULLWIDTH LATIN CAPITAL LETTER R
+FF33; L; FF53;	#FULLWIDTH LATIN CAPITAL LETTER S
+FF34; L; FF54;	#FULLWIDTH LATIN CAPITAL LETTER T
+FF35; L; FF55;	#FULLWIDTH LATIN CAPITAL LETTER U
+FF36; L; FF56;	#FULLWIDTH LATIN CAPITAL LETTER V
+FF37; L; FF57;	#FULLWIDTH LATIN CAPITAL LETTER W
+FF38; L; FF58;	#FULLWIDTH LATIN CAPITAL LETTER X
+FF39; L; FF59;	#FULLWIDTH LATIN CAPITAL LETTER Y
+FF3A; L; FF5A;	#FULLWIDTH LATIN CAPITAL LETTER Z
+
+

contrib/perl5/lib/unicode/Is/BidiAL.pl

@@ -0,0 +1,25 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+061b	
+061f	
+0621	063a
+0640	064a
+066d	
+0671	06d5
+06e5	06e6
+06fa	06fe
+0700	070d
+0710	
+0712	072c
+0780	07a5
+fb50	fbb1
+fbd3	fd3d
+fd50	fd8f
+fd92	fdc7
+fdf0	fdfb
+fe70	fe72
+fe74	
+fe76	fefc
+END

contrib/perl5/lib/unicode/Is/BidiBN.pl

@@ -0,0 +1,15 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0000	0008
+000e	001b
+007f	0084
+0086	009f
+070f	
+180b	180e
+200b	200d
+206a	206f
+feff	
+fff9	fffb
+END

contrib/perl5/lib/unicode/Is/BidiLRE.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+202a	
+END

contrib/perl5/lib/unicode/Is/BidiLRO.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+202d	
+END

contrib/perl5/lib/unicode/Is/BidiNSM.pl

@@ -0,0 +1,97 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0300	034e
+0360	0362
+0483	0486
+0488	0489
+0591	05a1
+05a3	05b9
+05bb	05bd
+05bf	
+05c1	05c2
+05c4	
+064b	0655
+0670	
+06d6	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
+17b7	17bd
+17c6	
+17c9	17d3
+18a9	
+20d0	20e3
+302a	302f
+3099	309a
+fb1e	
+fe20	fe23
+END

contrib/perl5/lib/unicode/Is/BidiPDF.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+202c	
+END

contrib/perl5/lib/unicode/Is/BidiRLE.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+202b	
+END

contrib/perl5/lib/unicode/Is/BidiRLO.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+202e	
+END

contrib/perl5/lib/unicode/Is/Blank.pl

@@ -0,0 +1,12 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0009	
+0020	
+00a0	
+1680	
+2000	200b
+202f	
+3000	
+END

contrib/perl5/lib/unicode/Is/Cf.pl

@@ -0,0 +1,12 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+070f	
+180b	180e
+200c	200f
+202a	202e
+206a	206f
+feff	
+fff9	fffb
+END

contrib/perl5/lib/unicode/Is/Cs.pl

@@ -0,0 +1,8 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+d800	db7f
+db80	dbff
+dc00	dfff
+END

contrib/perl5/lib/unicode/Is/DCfraction.pl

@@ -0,0 +1,7 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+00bc	00be
+2153	215f
+END

contrib/perl5/lib/unicode/Is/DCmedial.pl

@@ -0,0 +1,59 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+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

contrib/perl5/lib/unicode/Is/LbrkAI.pl

@@ -0,0 +1,139 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+00a1	
+00a7	00a8
+00aa	
+00b2	00b3
+00b6	00ba
+00bc	00bf
+00c6	
+00d0	
+00d7	00d8
+00de	00e1
+00e6	
+00e8	00ea
+00ec	00ed
+00f0	
+00f2	00f3
+00f7	00fa
+00fc	
+00fe	
+0101	
+0111	
+0113	
+011b	
+0126	0127
+012b	
+0131	0133
+0138	
+013f	0142
+0144	
+0148	014a
+014d	
+0152	0153
+0166	0167
+016b	
+01ce	
+01d0	
+01d2	
+01d4	
+01d6	
+01d8	
+01da	
+01dc	
+0251	
+0261	
+02c7	
+02c9	02cb
+02cd	
+02d0	
+02d8	02db
+02dd	
+0391	03a1
+03a3	03a9
+03b1	03c1
+03c3	03c9
+0401	
+0410	044f
+0451	
+2016	
+2020	2021
+203b	
+2074	
+207f	
+2081	2084
+2105	
+2113	
+2121	2122
+212b	
+2154	2155
+215b	
+215e	
+2160	216b
+2170	2179
+2190	2199
+21d2	
+21d4	
+2200	
+2202	2203
+2207	2208
+220b	
+220f	
+2211	
+2215	
+221a	
+221d	2220
+2223	
+2225	
+2227	222c
+222e	
+2234	2237
+223c	223d
+2248	
+224c	
+2252	
+2260	2261
+2264	2267
+226a	226b
+226e	226f
+2282	2283
+2286	2287
+2295	
+2299	
+22a5	
+22bf	
+2312	
+2460	24bf
+24d0	24e9
+2500	254b
+2550	2574
+2580	258f
+2592	2595
+25a0	25a1
+25a3	25a9
+25b2	25b3
+25b6	25b7
+25bc	25bd
+25c0	25c1
+25c6	25c7
+25cb	
+25ce	25d1
+25e2	25e5
+25ef	
+2605	2606
+2609	
+260e	260f
+261c	
+261e	
+2640	
+2642	
+2660	2661
+2663	2665
+2667	266a
+266c	266d
+266f	
+e000	f8ff
+fffd	
+END

contrib/perl5/lib/unicode/Is/LbrkAL.pl

@@ -0,0 +1,387 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0023	
+0026	
+002a	
+003c	003e
+0040	005a
+005e	007a
+007e	
+00a6	
+00a9	
+00ac	
+00ae	00af
+00b5	
+00c0	00c5
+00c7	00cf
+00d1	00d6
+00d9	00dd
+00e2	00e5
+00e7	
+00eb	
+00ee	00ef
+00f1	
+00f4	00f6
+00fb	
+00fd	
+00ff	0100
+0102	0110
+0112	
+0114	011a
+011c	0125
+0128	012a
+012c	0130
+0134	0137
+0139	013e
+0143	
+0145	0147
+014b	014c
+014e	0151
+0154	0165
+0168	016a
+016c	01cd
+01cf	
+01d1	
+01d3	
+01d5	
+01d7	
+01d9	
+01db	
+01dd	021f
+0222	0233
+0250	
+0252	0260
+0262	02ad
+02b0	02c6
+02ce	02cf
+02d1	02d7
+02dc	
+02de	02ee
+0374	0375
+037a	
+037e	
+0384	038a
+038c	
+038e	0390
+03aa	03b0
+03c2	
+03ca	03ce
+03d0	03d7
+03da	03f3
+0400	
+0402	040f
+0450	
+0452	0482
+048c	04c4
+04c7	04c8
+04cb	04cc
+04d0	04f5
+04f8	04f9
+0531	0556
+0559	055f
+0561	0587
+05be	
+05c0	
+05c3	
+05d0	05ea
+05f0	05f4
+060c	
+061b	
+061f	
+0621	063a
+0640	064a
+066a	066d
+0671	06d5
+06e5	06e6
+06e9	
+06fa	06fe
+0700	070d
+0710	
+0712	072c
+0780	07a5
+0905	0939
+093d	
+0950	
+0958	0961
+0964	0965
+0970	
+0985	098c
+098f	0990
+0993	09a8
+09aa	09b0
+09b2	
+09b6	09b9
+09dc	09dd
+09df	09e1
+09f0	09f1
+09f4	09fa
+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
+0b70	
+0b85	0b8a
+0b8e	0b90
+0b92	0b95
+0b99	0b9a
+0b9c	
+0b9e	0b9f
+0ba3	0ba4
+0ba8	0baa
+0bae	0bb5
+0bb7	0bb9
+0bf0	0bf2
+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
+0df4	
+0e4f	
+0f00	0f0a
+0f0d	0f17
+0f1a	0f1f
+0f2a	0f34
+0f36	
+0f38	
+0f40	0f47
+0f49	0f6a
+0f85	
+0f88	0f8b
+0fbe	0fc5
+0fc7	0fcc
+0fcf	
+104a	104f
+10a0	10c5
+10d0	10f6
+10fb	
+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
+1362	1368
+1372	137c
+13a0	13f4
+1401	1676
+1681	169a
+16a0	16f0
+17dc	
+1800	1805
+1807	180a
+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	1fc4
+1fc6	1fd3
+1fd6	1fdb
+1fdd	1fef
+1ff2	1ff4
+1ff6	1ffe
+2015	
+2017	
+2022	2023
+2038	
+203d	2043
+2048	204d
+2070	
+2075	207c
+2080	
+2085	208c
+2100	2102
+2104	
+2106	2108
+210a	2112
+2114	2115
+2117	2120
+2123	2125
+2127	212a
+212c	213a
+2153	
+2156	215a
+215c	215d
+215f	
+216c	216f
+217a	2183
+219a	21d1
+21d3	
+21d5	21f3
+2201	
+2204	2206
+2209	220a
+220c	220e
+2210	
+2214	
+2216	2219
+221b	221c
+2221	2222
+2224	
+2226	
+222d	
+222f	2233
+2238	223b
+223e	2247
+2249	224b
+224d	2251
+2253	225f
+2262	2263
+2268	2269
+226c	226d
+2270	2281
+2284	2285
+2288	2294
+2296	2298
+229a	22a4
+22a6	22be
+22c0	22f1
+2300	2311
+2313	2328
+232b	237b
+237d	239a
+2400	2426
+2440	244a
+24c0	24cf
+24ea	
+254c	254f
+2575	257f
+2590	2591
+25a2	
+25aa	25b1
+25b4	25b5
+25b8	25bb
+25be	25bf
+25c2	25c5
+25c8	25ca
+25cc	25cd
+25d2	25e1
+25e6	25ee
+25f0	25f7
+2600	2604
+2607	2608
+260a	260d
+2610	2613
+2619	261b
+261d	
+261f	263f
+2641	
+2643	265f
+2662	
+2666	
+266b	
+266e	
+2670	2671
+2701	2704
+2706	2709
+270c	2727
+2729	274b
+274d	
+274f	2752
+2756	
+2758	275e
+2761	2767
+2776	2794
+2798	27af
+27b1	27be
+2800	28ff
+fb00	fb06
+fb13	fb17
+fb1d	
+fb1f	fb36
+fb38	fb3c
+fb3e	
+fb40	fb41
+fb43	fb44
+fb46	fbb1
+fbd3	fd3d
+fd50	fd8f
+fd92	fdc7
+fdf0	fdfb
+fe6b	
+fe70	fe72
+fe74	
+fe76	fefc
+ff66	
+ff71	ff9d
+ffa0	ffbe
+ffc2	ffc7
+ffca	ffcf
+ffd2	ffd7
+ffda	ffdc
+ffe8	ffee
+END

contrib/perl5/lib/unicode/Is/LbrkB2.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+2014	
+END

contrib/perl5/lib/unicode/Is/LbrkBA.pl

@@ -0,0 +1,19 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0009	
+007c	
+00ad	
+00b4	
+058a	
+0f0b	
+1361	
+1680	
+17d5	
+2000	2006
+2008	200a
+2010	
+2012	2013
+2027	
+END

contrib/perl5/lib/unicode/Is/LbrkBB.pl

@@ -0,0 +1,8 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+02c8	
+02cc	
+1806	
+END

contrib/perl5/lib/unicode/Is/LbrkBK.pl

@@ -0,0 +1,7 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+000c	
+2028	2029
+END

contrib/perl5/lib/unicode/Is/LbrkCB.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+fffc	
+END

contrib/perl5/lib/unicode/Is/LbrkCL.pl

@@ -0,0 +1,47 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0029	
+005d	
+007d	
+0f3b	
+0f3d	
+169c	
+2046	
+207e	
+208e	
+232a	
+3001	3002
+3009	
+300b	
+300d	
+300f	
+3011	
+3015	
+3017	
+3019	
+301b	
+301e	301f
+fd3f	
+fe36	
+fe38	
+fe3a	
+fe3c	
+fe3e	
+fe40	
+fe42	
+fe44	
+fe50	
+fe52	
+fe5a	
+fe5c	
+fe5e	
+ff09	
+ff0c	
+ff0e	
+ff3d	
+ff5d	
+ff61	
+ff63	ff64
+END

contrib/perl5/lib/unicode/Is/LbrkCM.pl

@@ -0,0 +1,117 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0000	0008
+000b	
+000e	001f
+007f	009f
+0300	034e
+0360	0362
+0483	0486
+0488	0489
+0591	05a1
+05a3	05b9
+05bb	05bd
+05bf	
+05c1	05c2
+05c4	
+064b	0655
+0670	
+06d6	06e4
+06e7	06e8
+06ea	06ed
+070f	
+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	0b83
+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
+1160	11a2
+11a8	11f9
+17b4	17d3
+180b	180e
+18a9	
+200c	200f
+202a	202e
+206a	206f
+20d0	20e3
+302a	302f
+3099	309a
+fb1e	
+fe20	fe23
+fff9	fffb
+END

contrib/perl5/lib/unicode/Is/LbrkCR.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+000d	
+END

contrib/perl5/lib/unicode/Is/LbrkEX.pl

@@ -0,0 +1,10 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0021	
+003f	
+fe56	fe57
+ff01	
+ff1f	
+END

contrib/perl5/lib/unicode/Is/LbrkGL.pl

@@ -0,0 +1,11 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+00a0	
+0f0c	
+2007	
+2011	
+202f	
+feff	
+END

contrib/perl5/lib/unicode/Is/LbrkHY.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+002d	
+END

contrib/perl5/lib/unicode/Is/LbrkID.pl

@@ -0,0 +1,81 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1100	1159
+115f	
+2e80	2e99
+2e9b	2ef3
+2f00	2fd5
+2ff0	2ffb
+3000	
+3003	3004
+3006	3007
+3012	3013
+3020	3029
+3030	303a
+303e	303f
+3042	
+3044	
+3046	
+3048	
+304a	3062
+3064	3082
+3084	
+3086	
+3088	308d
+308f	3094
+30a2	
+30a4	
+30a6	
+30a8	
+30aa	30c2
+30c4	30e2
+30e4	
+30e6	
+30e8	30ed
+30ef	30f4
+30f7	30fa
+30fc	
+30fe	
+3105	312c
+3131	318e
+3190	31b7
+3200	321c
+3220	3243
+3260	327b
+327f	32b0
+32c0	32cb
+32d0	32fe
+3300	3376
+337b	33dd
+33e0	33fe
+3400	4db5
+4e00	9fa5
+a000	a48c
+a490	a4a1
+a4a4	a4b3
+a4b5	a4c0
+a4c2	a4c4
+a4c6	
+ac00	d7a3
+f900	fa2d
+fe30	fe34
+fe49	fe4f
+fe51	
+fe58	
+fe5f	fe66
+fe68	
+ff02	ff03
+ff06	ff07
+ff0a	ff0b
+ff0d	
+ff0f	ff19
+ff1c	ff1e
+ff20	ff3a
+ff3c	
+ff3e	ff5a
+ff5c	
+ff5e	
+ffe2	ffe4
+END

contrib/perl5/lib/unicode/Is/LbrkIN.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+2024	2026
+END

contrib/perl5/lib/unicode/Is/LbrkIS.pl

@@ -0,0 +1,9 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+002c	
+002e	
+003a	003b
+0589	
+END

contrib/perl5/lib/unicode/Is/LbrkLF.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+000a	
+END

contrib/perl5/lib/unicode/Is/LbrkNS.pl

@@ -0,0 +1,41 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0e5a	0e5b
+17d4	
+17d6	17da
+203c	
+2044	
+3005	
+301c	
+3041	
+3043	
+3045	
+3047	
+3049	
+3063	
+3083	
+3085	
+3087	
+308e	
+309b	309e
+30a1	
+30a3	
+30a5	
+30a7	
+30a9	
+30c3	
+30e3	
+30e5	
+30e7	
+30ee	
+30f5	30f6
+30fb	
+30fd	
+fe54	fe55
+ff1a	ff1b
+ff65	
+ff67	ff70
+ff9e	ff9f
+END

contrib/perl5/lib/unicode/Is/LbrkNU.pl

@@ -0,0 +1,24 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+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
+END

contrib/perl5/lib/unicode/Is/LbrkOP.pl

@@ -0,0 +1,43 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0028	
+005b	
+007b	
+0f3a	
+0f3c	
+169b	
+201a	
+201e	
+2045	
+207d	
+208d	
+2329	
+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	
+ff62	
+END

contrib/perl5/lib/unicode/Is/LbrkPO.pl

@@ -0,0 +1,16 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0025	
+00a2	
+00b0	
+2030	2037
+20a7	
+2103	
+2109	
+2126	
+fe6a	
+ff05	
+ffe0	
+END

contrib/perl5/lib/unicode/Is/LbrkPR.pl

@@ -0,0 +1,21 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0024	
+002b	
+005c	
+00a3	00a5
+00b1	
+09f2	09f3
+0e3f	
+17db	
+20a0	20a6
+20a8	20af
+2116	
+2212	2213
+fe69	
+ff04	
+ffe1	
+ffe5	ffe6
+END

contrib/perl5/lib/unicode/Is/LbrkQU.pl

@@ -0,0 +1,13 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0022	
+0027	
+00ab	
+00bb	
+2018	2019
+201b	201d
+201f	
+2039	203a
+END

contrib/perl5/lib/unicode/Is/LbrkSA.pl

@@ -0,0 +1,30 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+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
+1000	1021
+1023	1027
+1029	102a
+1050	1055
+1780	17b3
+END

contrib/perl5/lib/unicode/Is/LbrkSG.pl

@@ -0,0 +1,8 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+d800	db7f
+db80	dbff
+dc00	dfff
+END

contrib/perl5/lib/unicode/Is/LbrkSP.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0020	
+END

contrib/perl5/lib/unicode/Is/LbrkSY.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+002f	
+END

contrib/perl5/lib/unicode/Is/LbrkXX.pl

@@ -0,0 +1,5 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+END

contrib/perl5/lib/unicode/Is/LbrkZW.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+200b	
+END

contrib/perl5/lib/unicode/Is/Me.pl

@@ -0,0 +1,9 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0488	0489
+06dd	06de
+20dd	20e0
+20e2	20e3
+END

contrib/perl5/lib/unicode/Is/Nl.pl

@@ -0,0 +1,9 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+2160	2183
+3007	
+3021	3029
+3038	303a
+END

contrib/perl5/lib/unicode/Is/Pc.pl

@@ -0,0 +1,12 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+005f	
+203f	2040
+30fb	
+fe33	fe34
+fe4d	fe4f
+ff3f	
+ff65	
+END

contrib/perl5/lib/unicode/Is/Pf.pl

@@ -0,0 +1,9 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+00bb	
+2019	
+201d	
+203a	
+END

contrib/perl5/lib/unicode/Is/Pi.pl

@@ -0,0 +1,10 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+00ab	
+2018	
+201b	201c
+201f	
+2039	
+END

contrib/perl5/lib/unicode/Is/Sk.pl

@@ -0,0 +1,27 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+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

contrib/perl5/lib/unicode/Is/SpacePerl.pl

@@ -0,0 +1,14 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+0009	000a
+000c	000d
+0020	
+00a0	
+1680	
+2000	200b
+2028	2029
+202f	
+3000	
+END

contrib/perl5/lib/unicode/Is/SylAA.pl

@@ -0,0 +1,25 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+140b	
+1439	
+1456	
+1473	
+1491	
+14ab	
+14c8	
+14db	
+14f5	
+1516	
+152e	
+154c	
+155a	
+1567	
+157a	
+1584	
+1594	
+15a5	
+15ad	
+1676	
+END

contrib/perl5/lib/unicode/Is/SylAAI.pl

@@ -0,0 +1,19 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1402	
+1430	
+144d	
+146c	
+148a	
+14a4	
+14c1	
+14d4	
+14ee	
+1527	
+1545	
+1554	
+157e	
+158e	
+END

contrib/perl5/lib/unicode/Is/SylAI.pl

@@ -0,0 +1,7 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+141c	
+166f	1670
+END

contrib/perl5/lib/unicode/Is/SylEE.pl

@@ -0,0 +1,34 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1408	
+1436	
+1453	
+15c7	
+15cd	
+15d3	
+15df	
+15e5	
+15eb	
+15f2	
+15f8	
+15fe	
+1605	
+160b	
+1611	
+1618	
+161f	
+1625	
+162b	
+1631	
+1637	
+163d	
+1643	
+164b	
+1651	
+1657	
+165e	
+1664	
+166a	
+END

contrib/perl5/lib/unicode/Is/SylII.pl

@@ -0,0 +1,25 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1404	
+1432	
+144f	
+146e	
+148c	
+14a6	
+14c3	
+14d6	
+14f0	
+1512	
+1529	
+1547	
+1556	
+1562	1563
+1576	
+1580	
+1590	
+15a1	
+15a9	
+1672	
+END

contrib/perl5/lib/unicode/Is/SylN.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+3093	
+END

contrib/perl5/lib/unicode/Is/SylOO.pl

@@ -0,0 +1,25 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1406	1407
+1434	1435
+1451	1452
+1470	1471
+148e	148f
+14a8	14a9
+14c5	14c6
+14d8	14d9
+14f2	14f3
+1514	
+152b	152c
+1549	
+1558	
+1565	
+1578	
+1582	
+1592	
+15a3	
+15ab	
+1674	
+END

contrib/perl5/lib/unicode/Is/SylWAA.pl

@@ -0,0 +1,19 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1419	141b
+1446	1448
+1463	1465
+1480	1482
+149e	14a0
+14b8	14ba
+14cd	14cf
+14e8	14e9
+1502	1504
+1523	1524
+153b	153d
+154e	154f
+155b	155c
+1568	1569
+END

contrib/perl5/lib/unicode/Is/SylWEE.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+15d9	
+END

contrib/perl5/lib/unicode/Is/SylWII.pl

@@ -0,0 +1,15 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1410	1411
+143e	143f
+145b	145c
+1478	1479
+1496	1497
+14b0	14b1
+14e0	14e1
+14fa	14fb
+151b	151c
+1533	1534
+END

contrib/perl5/lib/unicode/Is/SylWO.pl

@@ -0,0 +1,16 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1412	1413
+1440	1441
+145d	145e
+147a	147b
+1498	1499
+14b2	14b3
+14e2	14e3
+14fc	14fd
+151d	151e
+1535	1536
+15d7	
+END

contrib/perl5/lib/unicode/Is/SylWOO.pl

@@ -0,0 +1,15 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+1414	1416
+1442	1443
+145f	1460
+147c	147d
+149a	149b
+14b4	14b5
+14e4	14e5
+14fe	14ff
+151f	1520
+1537	1538
+END

contrib/perl5/lib/unicode/Is/SylWU.pl

@@ -0,0 +1,6 @@
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!! 
+# This file is built by mktables.PL from e.g. Unicode.301.
+# Any changes made here will be lost!
+return <<'END';
+15d6	
+END

contrib/perl5/lib/unicode/README.perl

@@ -0,0 +1,37 @@
+The *.txt files were copied 30 Aug 2000 from
+
+	http://www.unicode.org/Public/UNIDATA/
+
+and most of them were renamed to better fit 8.3 filename limitations,
+by which the Perl distribution tries to live.
+
+	www.unicode.org			Perl distribution
+
+	ArabicShaping.txt		ArabShap.txt
+	BidiMirroring.txt		BidiMirr.txt
+	Blocks.txt			Blocks.txt
+	CaseFolding.txt			CaseFold.txt
+	CompositionExclusions.txt	CompExcl.txt
+	EastAsianWidth.txt		EAWidth.txt	(0)
+	Index.txt			Index.txt
+	Jamo.txt			Jamo.txt
+	LineBreak.txt			LineBrk.txt	(0)
+	NamesList.html			NamesList.html	(0)
+	NamesList.txt			Names.txt
+	PropList.txt			PropList.txt
+	ReadMe.txt			ReadMe.txt
+	SpecialCasing.txt		SpecCase.txt
+	UnicodeCharacterDatabase.html	UCD301.html
+	UnicodeData.html		UCDFF301.html
+	UnicodeData.txt			Unicode.301
+
+The two big files, NormalizationTest.txt (1.7MB) and Unihan.txt (15.8MB)
+were not copied for space considerations.  The files marked with (0) had
+not been updated since Unicode 3.0.0 (10 Sep 1999)
+
+The *.pl files are generated from these files by the 'mktables.PL' script.
+
+While the files have been renamed the links in the html files haven't.
+
+-- 
+jhi@iki.fi

contrib/perl5/lib/unicode/UCD301.html

@@ -0,0 +1,201 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+
+       "http://www.w3.org/TR/REC-html40/loose.dtd"> 
+
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+<meta http-equiv="Content-Language" content="en-us">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<link rel="stylesheet" href="http://www.unicode.org/unicode.css" type="text/css">
+<title>Unicode Character Database</title>
+</head>
+
+<body>
+
+<h1>UNICODE CHARACTER DATABASE<br>
+Version 3.0.1</h1>
+<table border="1" cellspacing="2" cellpadding="0" height="87" width="100%">
+  <tr>
+    <td valign="TOP" width="144">Revision</td>
+    <td valign="TOP">3.0.1</td>
+  </tr>
+  <tr>
+    <td valign="TOP" width="144">Authors</td>
+    <td valign="TOP">Mark Davis and Ken Whistler</td>
+  </tr>
+  <tr>
+    <td valign="TOP" width="144">Date</td>
+    <td valign="TOP">2000-08-17</td>
+  </tr>
+  <tr>
+    <td valign="TOP" width="144">This Version</td>
+    <td valign="TOP"><a
+      href="http://www.unicode.org/Public/3.0-Update1/UnicodeCharacterDatabase-3.0.1.html">http://www.unicode.org/Public/3.0-Update1/UnicodeCharacterDatabase-3.0.1.html</a></td>
+  </tr>
+  <tr>
+    <td valign="TOP" width="144">Previous Version</td>
+    <td valign="TOP"><a
+      href="http://www.unicode.org/Public/3.0-Update/UnicodeCharacterDatabase-3.0.0.html">http://www.unicode.org/Public/3.0-Update/UnicodeCharacterDatabase-3.0.0.html</a></td>
+  </tr>
+  <tr>
+    <td valign="TOP" width="144">Latest Version</td>
+    <td valign="TOP"><a
+      href="http://www.unicode.org/Public/UNIDATA/UnicodeCharacterDatabase.html">http://www.unicode.org/Public/UNIDATA/UnicodeCharacterDatabase.html</a></td>
+  </tr>
+</table>
+<p align="center">Copyright © 1995-2000 Unicode, Inc. All Rights reserved.</p>
+<h2>Disclaimer</h2>
+<p>The Unicode Character Database is provided as is by Unicode, Inc. No claims 
+are made as to fitness for any particular purpose. No warranties of any kind are 
+expressed or implied. The recipient agrees to determine applicability of 
+information provided. If this file has been purchased on magnetic or optical 
+media from Unicode, Inc., the sole remedy for any claim will be exchange of 
+defective media within 90 days of receipt.</p>
+<p>This disclaimer is applicable for all other data files accompanying the 
+Unicode Character Database, some of which have been compiled by the Unicode 
+Consortium, and some of which have been supplied by other sources.</p>
+<h2>Limitations on Rights to Redistribute This Data</h2>
+<p>Recipient is granted the right to make copies in any form for internal 
+distribution and to freely use the information supplied in the creation of 
+products supporting the Unicode<sup>TM</sup> Standard. The files in the Unicode 
+Character Database can be redistributed to third parties or other organizations 
+(whether for profit or not) as long as this notice and the disclaimer notice are 
+retained. Information can be extracted from these files and used in 
+documentation or programs, as long as there is an accompanying notice indicating 
+the source.</p>
+<h2>Introduction</h2>
+<p>The Unicode Character Database is a set of files that define the Unicode 
+character properties and internal mappings. For more information about character 
+properties and mappings, see <i><a
+href="http://www.unicode.org/unicode/uni2book/u2.html">The Unicode Standard</a></i>.</p>
+<p>The Unicode Character Database has been updated to reflect Version 3.0 of the 
+Unicode Standard, with many characters added to those published in Version 2.0. 
+A number of corrections have also been made to case mappings or other errors in 
+the database noted since the publication of Version 2.0. Normative bidirectional 
+properties have also been modified to reflect decisions of the Unicode Technical 
+Committee.</p>
+<p>For more information on versions of the Unicode Standard and how to reference 
+them, see <a href="http://www.unicode.org/unicode/standard/versions/">http://www.unicode.org/unicode/standard/versions/</a>.</p>
+<h2>Conformance</h2>
+<p>Character properties may be either normative or informative. <i>Normative</i> 
+means that implementations that claim conformance to the Unicode Standard (at a 
+particular version) and which make use of a particular property or field must 
+follow the specifications of the standard for that property or field in order to 
+be conformant. The term <i>normative</i> when applied to a property or field of 
+the Unicode Character Database, does <i>not</i> mean that the value of that 
+field will never change. Corrections and extensions to the standard in the 
+future may require minor changes to normative values, even though the Unicode 
+Technical Committee strives to minimize such changes. An<i> informative </i>property 
+or field is strongly recommended, but a conformant implementation is free to use 
+or change such values as it may require while still being conformant to the 
+standard. Particular implementations may choose to override the properties and 
+mappings that are not normative. In that case, it is up to the implementer to 
+establish a protocol to convey that information.</p>
+<h2>Files</h2>
+<p>The following summarizes the files in the Unicode Character Database. &nbsp;For 
+more information about these files, see the referenced technical report(s) or 
+section of Unicode Standard, Version 3.0.</p>
+<p><b>UnicodeData.txt (Chapter 4, <a
+href="http://www.unicode.org/unicode/reports/tr21/">UTR #21: Case Mappings</a>, <a
+href="http://www.unicode.org/unicode/reports/tr15/">UAX #15 Unicode Normalization 
+Forms</a>)</b>
+<ul>
+  <li>The main file in the Unicode Character Database.</li>
+  <li>For detailed information on the format, see <a href="UnicodeData.html">UnicodeData.html</a>. 
+    This file also characterizes which properties are normative and which are 
+    informative.</li>
+</ul>
+<p><b>PropList.txt (Chapter 4)</b>
+<ul>
+  <li>Additional informative properties list: <i>Alphabetic, Ideographic,</i> 
+    and <i>Mathematical</i>, among others.</li>
+</ul>
+<p><b>SpecialCasing.txt (Chapter 4, <a
+href="http://www.unicode.org/unicode/reports/tr21/">UTR #21: Case Mappings</a>)</b>
+<ul>
+  <li>List of informative special casing properties, including one-to-many 
+    mappings such as SHARP S =&gt; &quot;SS&quot;, and locale-specific mappings, 
+    such as for Turkish <i>dotless i</i>.</li>
+</ul>
+<p><b>Blocks.txt (Chapter 14)</b>
+<ul>
+  <li>List of normative block names.</li>
+</ul>
+<p><b>Jamo.txt (Chapter 4)</b>
+<ul>
+  <li>List of normative Jamo short names, used in deriving HANGUL SYLLABLE names 
+    algorithmically.</li>
+</ul>
+<p><b>ArabicShaping.txt (Section 8.2)</b>
+<ul>
+  <li>Basic Arabic and Syriac character shaping properties, such as initial, 
+    medial and final shapes. These properties are normative for minimal shaping 
+    of Arabic and Syriac.</li>
+</ul>
+<p><b>NamesList.txt (Chapter 14)</b>
+<ul>
+  <li>This file duplicates some of the material in the UnicodeData file, and 
+    adds informative annotations uses in the character charts, as printed in the 
+    Unicode Standard.</li>
+  <li><b>Note: </b>The information in NamesList.txt and Index.txt files matches 
+    the appropriate version of the book. Changes in the Unicode Character 
+    Database since then may not be reflected in these files, since they are 
+    primarily of archival interest.</li>
+</ul>
+<p><b>Index.txt (Chapter 14)</b>
+<ul>
+  <li>Informative index to Unicode characters, as printed in the Unicode 
+    Standard</li>
+  <li><b>Note: </b>The information in NamesList.txt and Index.txt files matches 
+    the appropriate version of the book. Changes in the Unicode Character 
+    Database since then may not be reflected in these files, since they are 
+    primarily of archival interest.</li>
+</ul>
+<p><b>CompositionExclusions.txt (<a
+href="http://www.unicode.org/unicode/reports/tr15/">UAX #15 Unicode Normalization 
+Forms</a>)</b>
+<ul>
+  <li>Normative properties for normalization.</li>
+</ul>
+<p><b>LineBreak.txt (<a href="http://www.unicode.org/unicode/reports/tr14/">UAX 
+#14: Line Breaking Properties</a>)</b>
+<ul>
+  <li>Normative and informative properties for line breaking. To see which 
+    properties are informative and which are normative, consult UAX #14.</li>
+</ul>
+<p><b>EastAsianWidth.txt (<a href="http://www.unicode.org/unicode/reports/tr11/">UAX 
+#11: East Asian Character Width</a>)</b>
+<ul>
+  <li>Informative properties for determining the choice of wide vs. narrow 
+    glyphs in East Asian contexts.</li>
+</ul>
+<p><b>BidiMirroring.txt</b><b> (<a
+href="http://www.unicode.org/unicode/reports/tr9/">UAX #9:&nbsp;The 
+Bidirectional Algorithm</a>)</b></p>
+<ul>
+  <li>Informative properties for substituting characters in an implementation of 
+    bidirectional mirroring.</li>
+</ul>
+<p><b>CaseFolding.txt (<a href="http://www.unicode.org/unicode/reports/tr21/">UTR 
+#21: Case Mappings</a>)</b></p>
+<ul>
+  <li>Informative file mapping characters to their case-folded form.</li>
+</ul>
+<p><b>NormalizationTest.txt (<a
+href="http://www.unicode.org/unicode/reports/tr15/">UAX #15 Unicode Normalization 
+Forms</a>)</b></p>
+<ul>
+  <li>Normative test file for conformance to Unicode Normalization Forms.</li>
+</ul>
+<p><b>diffXvY.txt</b>
+<ul>
+  <li>Mechanically-generated informative files containing accumulated 
+    differences between successive versions of UnicodeData.txt</li>
+</ul>
+
+</body>
+
+</html>

contrib/perl5/pod/Makefile.SH

@@ -0,0 +1,167 @@
+case $CONFIG in
+'')
+	if test -f config.sh; then TOP=.;
+	elif test -f ../config.sh; then TOP=..;
+	elif test -f ../../config.sh; then TOP=../..;
+	elif test -f ../../../config.sh; then TOP=../../..;
+	elif test -f ../../../../config.sh; then TOP=../../../..;
+	else
+		echo "Can't find config.sh."; exit 1
+	fi
+	. $TOP/config.sh
+	;;
+esac
+: This forces SH files to create target in same directory as SH file.
+: This is so that make depend always knows where to find SH derivatives.
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+
+if test -d pod; then
+  cd pod || exit 1
+fi
+POD=`echo *.pod`
+MAN=`echo $POD|sed 's/\.pod/\.man/g'`
+HTML=`echo $POD|sed 's/perltoc.pod//'|sed 's/\.pod/\.html/g'`
+TEX=`echo $POD|sed 's/\.pod/\.tex/g'`
+
+echo "Extracting pod/Makefile (with variable substitutions)"
+: This section of the file will have variable substitutions done on it.
+: Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
+: Protect any dollar signs and backticks that you do not want interpreted
+: by putting a backslash in front.  You may delete these comments.
+
+$spitshell >Makefile <<!GROK!THIS!
+# pod/Makefile
+# This file is derived from pod/Makefile.SH.  Any changes made here will
+# be lost the next time you run Configure.
+
+POD = $POD
+
+MAN = $MAN
+
+# no perltoc.html
+HTML = $HTML
+
+TEX  = $TEX  
+
+!GROK!THIS!
+
+## In the following dollars and backticks do not need the extra backslash.
+$spitshell >>Makefile <<'!NO!SUBS!'
+
+CONVERTERS = pod2html pod2latex pod2man pod2text checkpods \
+		pod2usage podchecker podselect
+
+HTMLROOT = /	# Change this to fix cross-references in HTML
+POD2HTML = pod2html \
+	    --htmlroot=$(HTMLROOT) \
+	    --podroot=.. --podpath=pod:lib:ext:vms \
+	    --libpods=perlfunc:perlguts:perlvar:perlrun:perlop
+
+PERL = ../miniperl
+PERLILIB = $(PERL) -I../lib
+REALPERL = ../perl
+
+all: $(CONVERTERS) man
+
+converters: $(CONVERTERS)
+
+regen_pods: perlmodlib.pod toc
+
+buildtoc:	buildtoc.PL perl.pod ../MANIFEST
+	$(PERLILIB) buildtoc.PL
+
+perltoc.pod:	buildtoc
+
+man:	pod2man $(MAN)
+
+html:	pod2html $(HTML)
+
+tex:	pod2latex $(TEX)
+
+toc:	buildtoc
+	$(PERLILIB) buildtoc
+
+.SUFFIXES: .pm .pod
+
+.SUFFIXES: .man
+
+.pm.man:     pod2man
+	$(PERL) -I../lib pod2man $*.pm >$*.man
+
+.pod.man:     pod2man
+	$(PERL) -I../lib pod2man $*.pod >$*.man
+
+.SUFFIXES: .html
+
+.pm.html:    pod2html
+	$(PERL) -I../lib $(POD2HTML) --infile=$*.pm --outfile=$*.html
+
+.pod.html:    pod2html
+	$(PERL) -I../lib $(POD2HTML) --infile=$*.pod --outfile=$*.html
+
+.SUFFIXES: .tex
+
+.pm.tex: pod2latex
+	$(PERL) -I../lib pod2latex $*.pm
+
+.pod.tex: pod2latex
+	$(PERL) -I../lib pod2latex $*.pod
+
+clean:
+	rm -f $(MAN)
+	rm -f $(HTML)
+	rm -f $(TEX)
+	rm -f pod2html-*cache
+	rm -f *.aux *.log *.exe
+
+realclean:	clean
+	rm -f $(CONVERTERS)
+
+distclean:	realclean
+
+veryclean:	distclean
+	-rm -f *~ *.orig
+
+check:	checkpods
+	@echo "checking..."; \
+	$(PERL) -I../lib checkpods $(POD)
+
+# Dependencies.
+pod2latex:	pod2latex.PL ../lib/Config.pm
+	$(PERL) -I../lib pod2latex.PL
+
+pod2html:	pod2html.PL ../lib/Config.pm
+	$(PERL) -I ../lib pod2html.PL
+
+pod2man:	pod2man.PL ../lib/Config.pm
+	$(PERL) -I ../lib pod2man.PL
+
+pod2text:	pod2text.PL ../lib/Config.pm
+	$(PERL) -I ../lib pod2text.PL
+
+checkpods:	checkpods.PL ../lib/Config.pm
+	$(PERL) -I ../lib checkpods.PL
+
+pod2usage:	pod2usage.PL ../lib/Config.pm
+	$(PERL) -I ../lib pod2usage.PL
+
+podchecker:	podchecker.PL ../lib/Config.pm
+	$(PERL) -I ../lib podchecker.PL
+
+podselect:	podselect.PL ../lib/Config.pm
+	$(PERL) -I ../lib podselect.PL
+
+perlmodlib.pod:	$(PERL) perlmodlib.PL ../mv-if-diff
+	rm -f perlmodlib.tmp
+	$(PERL) -I ../lib perlmodlib.PL
+	sh ../mv-if-diff perlmodlib.tmp perlmodlib.pod
+
+compile: all
+	$(REALPERL) -I../lib ../utils/perlcc -o pod2latex.exe pod2latex -log ../compilelog
+	$(REALPERL) -I../lib ../utils/perlcc -o pod2man.exe pod2man -log ../compilelog
+	$(REALPERL) -I../lib ../utils/perlcc -o pod2text.exe pod2text -log ../compilelog
+	$(REALPERL) -I../lib ../utils/perlcc -o checkpods.exe checkpods -log ../compilelog
+
+!NO!SUBS!

contrib/perl5/pod/buildtoc.PL

@@ -0,0 +1,492 @@
+#!/usr/local/bin/perl
+
+use Config;
+use File::Basename qw(&basename &dirname);
+use Cwd;
+
+# List explicitly here the variables you want Configure to
+# generate.  Metaconfig only looks for shell variables, so you
+# have to mention them as if they were shell variables, not
+# %Config entries.  Thus you write
+#  $startperl
+# to ensure Configure will look for $Config{startperl}.
+
+# This forces PL files to create target in same directory as PL file.
+# This is so that make depend always knows where to find PL derivatives.
+$origdir = cwd;
+chdir(dirname($0));
+($file = basename($0)) =~ s/\.PL$//;
+$file =~ s/\.pl$// if ($^O eq 'os2' or $^O eq 'dos');  # "case-forgiving"
+$file =~ s/\.pl$/.com/ if ($^O eq 'VMS');              # "case-forgiving"
+
+open OUT,">$file" or die "Can't create $file: $!";
+
+print "Extracting $file (with variable substitutions)\n";
+
+# In this section, perl variables will be expanded during extraction.
+# You can use $Config{...} to use Configure variables.
+
+print OUT <<"!GROK!THIS!";
+$Config{'startperl'}
+    eval 'exec perl -S \$0 "\$@"'
+        if 0;
+!GROK!THIS!
+
+# In the following, perl variables are not expanded during extraction.
+
+print OUT <<'!NO!SUBS!';
+
+#
+# buildtoc
+#
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
+# This file is autogenerated by buildtoc.PL.
+# Edit that file and run it to effect changes.
+#
+# Builds perltoc.pod and sanity checks the list of pods against all
+# of the MANIFEST, perl.pod, and ourselves.
+#
+
+use File::Find;
+use Cwd;
+use Text::Wrap;
+
+@PODS = glob("*.pod");
+
+sub output ($);
+
+if (-d "pod") {
+  die "$0: failed to chdir('pod'): $!\n" unless chdir("pod");
+}
+
+@pods = qw(
+    perl
+    perlfaq
+    perltoc
+    perlbook
+
+    perlsyn
+    perldata
+    perlop
+    perlsub
+    perlfunc
+    perlreftut
+    perldsc
+    perlrequick
+    perlpod
+    perlstyle
+    perltrap
+
+    perlrun
+    perldiag
+    perllexwarn
+    perldebtut
+    perldebug
+
+    perlvar
+    perllol
+    perlopentut
+    perlretut
+
+    perlre
+    perlref
+
+    perlform
+
+    perlboot
+    perltoot
+    perltootc
+    perlobj
+    perlbot
+    perltie
+
+    perlipc
+    perlfork
+    perlnumber
+    perlthrtut
+
+    perlport
+    perllocale
+    perlunicode
+    perlebcdic
+
+    perlsec
+
+    perlmod
+    perlmodlib
+    perlmodinstall
+    perlnewmod
+
+    perlfaq1            
+    perlfaq2            
+    perlfaq3            
+    perlfaq4            
+    perlfaq5            
+    perlfaq6            
+    perlfaq7            
+    perlfaq8            
+    perlfaq9            
+
+    perlcompile        
+
+    perlembed          
+    perldebguts         
+    perlxstut           
+    perlxs              
+    perlclib            
+    perlguts            
+    perlcall            
+    perlutil            
+    perlfilter          
+    perldbmfilter       
+    perlapi             
+    perlintern          
+    perlapio            
+    perltodo            
+    perlhack            
+
+    perlhist           
+    perldelta           
+    perl5005delta       
+    perl5004delta       
+
+    perlaix
+    perlamiga          
+    perlbs2000
+    perlcygwin          
+    perldos             
+    perlepoc             
+    perlhpux            
+    perlmachten         
+    perlmacos
+    perlmpeix         
+    perlos2             
+    perlos390           
+    perlsolaris
+    perlvmesa             
+    perlvms             
+    perlvos             
+    perlwin32           
+	  );
+
+@ARCHPODS = qw(
+    perlaix	
+    perlamiga          
+    perlbs2000
+    perlcygwin          
+    perldos             
+    perlepoc             
+    perlhpux            
+    perlmachten         
+    perlmacos
+    perlmpeix
+    perlos2             
+    perlos390           
+    perlsolaris
+    perlvmesa             
+    perlvms             
+    perlvos             
+    perlwin32           
+          );
+for (@ARCHPODS) { s/$/.pod/ }
+@ARCHPODS{@ARCHPODS} = ();
+
+for (@pods) { s/$/.pod/ }
+@pods{@pods} = ();
+@PODS{@PODS} = ();
+
+open(MANI, "../MANIFEST") || die "$0: opening ../MANIFEST failed: $!";
+while (<MANI>) {
+  if (m!^pod/([^.]+\.pod)\s+!i) {
+     push @MANIPODS, $1;
+  }
+}
+close(MANI);
+@MANIPODS{@MANIPODS} = ();
+
+open(PERLPOD, "perl.pod") || die "$0: opening perl.pod failed: $!\n";
+while (<PERLPOD>) {
+  if (/^For ease of access, /../^\(If you're intending /) {
+	if (/^\s+(perl\S*)\s+\w/) {
+		push @PERLPODS, "$1.pod";
+	}
+  }
+}
+close(PERLPOD);
+die "$0: could not find the pod listing of perl.pod\n"
+  unless @PERLPODS;
+@PERLPODS{@PERLPODS} = ();
+
+# Cross-check against ourselves
+# Cross-check against the MANIFEST
+# Cross-check against the perl.pod
+
+foreach my $i (sort keys %PODS) {
+  warn "$0: $i exists but is unknown by buildtoc\n"
+	unless exists $pods{$i};
+  warn "$0: $i exists but is unknown by ../MANIFEST\n"
+	if !exists $MANIPODS{$i} && !exists $ARCHPODS{$i};
+  warn "$0: $i exists but is unknown by perl.pod\n"
+	unless exists $PERLPODS{$i};
+}
+foreach my $i (sort keys %pods) {
+  warn "$0: $i is known by buildtoc but does not exist\n"
+	unless exists $PODS{$i};
+}
+foreach my $i (sort keys %MANIPODS) {
+  warn "$0: $i is known by ../MANIFEST but does not exist\n"
+	unless exists $PODS{$i};
+}
+foreach my $i (sort keys %PERLPODS) {
+  warn "$0: $i is known by perl.pod but does not exist\n"
+	unless exists $PODS{$i};
+}
+
+# We are ready to rock.
+open(OUT, ">perltoc.pod") || die "$0: creating perltoc.pod failed: $!";
+
+$/ = '';
+@ARGV = @pods;
+
+($_= <<EOPOD2B) =~ s/^\t//gm && output($_);
+
+	=head1 NAME
+
+	perltoc - perl documentation table of contents
+
+	=head1 DESCRIPTION
+
+	This page provides a brief table of contents for the rest of the Perl
+	documentation set.  It is meant to be scanned quickly or grepped
+	through to locate the proper section you're looking for.
+
+	=head1 BASIC DOCUMENTATION
+
+EOPOD2B
+#' make emacs happy
+
+podset(@pods);
+
+find \&getpods => qw(../lib ../ext);
+
+sub getpods {
+    if (/\.p(od|m)$/) {
+	# Skip .pm files that have corresponding .pod files, and Functions.pm.
+	return if /(.*)\.pm$/ && -f "$1.pod";
+	my $file = $File::Find::name;
+	return if $file eq '../lib/Pod/Functions.pm'; # Used only by pod itself
+
+	die "tut $name" if $file =~ /TUT/;
+	unless (open (F, "< $_\0")) {
+	    warn "bogus <$file>: $!";
+	    system "ls", "-l", $file;
+	}
+	else {
+	    my $line;
+	    while ($line = <F>) {
+		if ($line =~ /^=head1\s+NAME\b/) {
+		    push @modpods, $file;
+		    #warn "GOOD $file\n";
+		    return;
+		}
+	    }
+	    warn "$0: $file: cannot find =head1 NAME\n";
+	}
+    }
+}
+
+die "no pods" unless @modpods;
+
+for (@modpods) {
+    #($name) = /(\w+)\.p(m|od)$/;
+    $name = path2modname($_);
+    if ($name =~ /^[a-z]/) {
+	push @pragmata, $_;
+    } else {
+	if ($done{$name}++) {
+	    # warn "already did $_\n";
+	    next;
+	}
+	push @modules, $_;
+	push @modname, $name;
+    }
+}
+
+($_= <<EOPOD2B) =~ s/^\t//gm && output($_);
+
+
+
+	=head1 PRAGMA DOCUMENTATION
+
+EOPOD2B
+
+podset(sort @pragmata);
+
+($_= <<EOPOD2B) =~ s/^\t//gm && output($_);
+
+
+
+	=head1 MODULE DOCUMENTATION
+
+EOPOD2B
+
+podset( @modules[ sort { $modname[$a] cmp $modname[$b] } 0 .. $#modules ] );
+
+($_= <<EOPOD2B) =~ s/^\t//gm;
+
+
+	=head1 AUXILIARY DOCUMENTATION
+
+	Here should be listed all the extra programs' documentation, but they
+	don't all have manual pages yet:
+
+	=over 4
+
+	=item a2p
+
+	=item s2p
+
+	=item find2perl
+
+	=item h2ph
+
+	=item c2ph
+
+	=item h2xs
+
+	=item xsubpp
+
+	=item pod2man
+
+	=item wrapsuid
+
+	=back
+
+	=head1 AUTHOR
+
+	Larry Wall <F<larry\@wall.org>>, with the help of oodles
+	of other folks.
+
+
+EOPOD2B
+output $_;
+output "\n";                    # flush $LINE
+exit;
+
+sub podset {
+    local @ARGV = @_;
+
+    while(<>) {
+	if (s/^=head1 (NAME)\s*/=head2 /) {
+	    $pod = path2modname($ARGV);
+	    unhead1();
+	    output "\n \n\n=head2 ";
+	    $_ = <>;
+	    if ( /^\s*$pod\b/ ) {
+		s/$pod\.pm/$pod/;       # '.pm' in NAME !?
+		output $_;
+	    } else {
+		s/^/$pod, /;
+		output $_;
+	    }
+	    next;
+	}
+	if (s/^=head1 (.*)/=item $1/) {
+	    unhead2();
+	    output "=over 4\n\n" unless $inhead1;
+	    $inhead1 = 1;
+	    output $_; nl(); next;
+	}
+	if (s/^=head2 (.*)/=item $1/) {
+	    unitem();
+	    output "=over 4\n\n" unless $inhead2;
+	    $inhead2 = 1;
+	    output $_; nl(); next;
+	}
+	if (s/^=item ([^=].*)/$1/) {
+	    next if $pod eq 'perldiag';
+	    s/^\s*\*\s*$// && next;
+	    s/^\s*\*\s*//;
+	    s/\n/ /g;
+	    s/\s+$//;
+	    next if /^[\d.]+$/;
+	    next if $pod eq 'perlmodlib' && /^ftp:/;
+	    ##print "=over 4\n\n" unless $initem;
+	    output ", " if $initem;
+	    $initem = 1;
+	    s/\.$//;
+	    s/^-X\b/-I<X>/;
+	    output $_; next;
+	}
+	if (s/^=cut\s*\n//) {
+	    unhead1();
+	    next;
+	}
+    }
+}
+
+sub path2modname {
+    local $_ = shift;
+    s/\.p(m|od)$//;
+    s-.*?/(lib|ext)/--;
+    s-/-::-g;
+    s/(\w+)::\1/$1/;
+    return $_;
+}
+
+sub unhead1 {
+    unhead2();
+    if ($inhead1) {
+	output "\n\n=back\n\n";
+    }
+    $inhead1 = 0;
+}
+
+sub unhead2 {
+    unitem();
+    if ($inhead2) {
+	output "\n\n=back\n\n";
+    }
+    $inhead2 = 0;
+}
+
+sub unitem {
+    if ($initem) {
+	output "\n\n";
+	##print "\n\n=back\n\n";
+    }
+    $initem = 0;
+}
+
+sub nl {
+    output "\n";
+}
+
+my $NEWLINE;	# how many newlines have we seen recently
+my $LINE;	# what remains to be printed
+
+sub output ($) {
+    for (split /(\n)/, shift) {
+	if ($_ eq "\n") {
+	    if ($LINE) {
+		print OUT wrap('', '', $LINE);
+		$LINE = '';
+	    }
+	    if ($NEWLINE < 2) {
+		print OUT;
+		$NEWLINE++;
+	    }
+	}
+	elsif (/\S/ && length) {
+	    $LINE .= $_;
+	    $NEWLINE = 0;
+	}
+    }
+}
+
+!NO!SUBS!
+
+close OUT or die "Can't close $file: $!";
+chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
+exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
+chdir $origdir;

contrib/perl5/pod/perlclib.pod

@@ -0,0 +1,197 @@
+=head1 NAME
+
+perlclib - Internal replacements for standard C library functions
+
+=head1 DESCRIPTION
+
+One thing Perl porters should note is that F<perl> doesn't tend to use that
+much of the C standard library internally; you'll see very little use of, 
+for example, the F<ctype.h> functions in there. This is because Perl
+tends to reimplement or abstract standard library functions, so that we
+know exactly how they're going to operate.
+
+This is a reference card for people who are familiar with the C library
+and who want to do things the Perl way; to tell them which functions
+they ought to use instead of the more normal C functions. 
+
+=head2 Conventions
+
+In the following tables:
+
+=over 3
+
+=item C<t>
+
+is a type.
+
+=item C<p>
+
+is a pointer.
+
+=item C<n>
+
+is a number.
+
+=item C<s>
+
+is a string.
+
+=back
+
+C<sv>, C<av>, C<hv>, etc. represent variables of their respective types.
+
+=head2 File Operations
+
+Instead of the F<stdio.h> functions, you should use the Perl abstraction
+layer. Instead of C<FILE*> types, you need to be handling C<PerlIO*>
+types.  Don't forget that with the new PerlIO layered I/O abstraction 
+C<FILE*> types may not even be available. See also the C<perlapio>
+documentation for more information about the following functions:
+
+    Instead Of:                 Use:
+
+    stdin                       PerlIO_stdin()
+    stdout                      PerlIO_stdout()
+    stderr                      PerlIO_stderr()
+
+    fopen(fn, mode)             PerlIO_open(fn, mode)
+    freopen(fn, mode, stream)   PerlIO_reopen(fn, mode, perlio) (Deprecated)
+    fflush(stream)              PerlIO_flush(perlio)
+    fclose(stream)              PerlIO_close(perlio)
+
+=head2 File Input and Output
+
+    Instead Of:                 Use:
+
+    fprintf(stream, fmt, ...)   PerlIO_printf(perlio, fmt, ...)
+
+    [f]getc(stream)             PerlIO_getc(perlio)
+    [f]putc(stream, n)          PerlIO_putc(perlio, n)
+    ungetc(n, stream)           PerlIO_ungetc(perlio, n)
+
+Note that the PerlIO equivalents of C<fread> and C<fwrite> are slightly
+different from their C library counterparts:
+
+    fread(p, size, n, stream)   PerlIO_read(perlio, buf, numbytes)
+    fwrite(p, size, n, stream)  PerlIO_write(perlio, buf, numbytes)
+
+    fputs(s, stream)            PerlIO_puts(perlio, s)
+
+There is no equivalent to C<fgets>; one should use C<sv_gets> instead:
+
+    fgets(s, n, stream)         sv_gets(sv, perlio, append)
+
+=head2 File Positioning
+
+    Instead Of:                 Use:
+
+    feof(stream)                PerlIO_eof(perlio)
+    fseek(stream, n, whence)    PerlIO_seek(perlio, n, whence)
+    rewind(stream)              PerlIO_rewind(perlio)
+
+    fgetpos(stream, p)          PerlIO_getpos(perlio, sv)
+    fsetpos(stream, p)          PerlIO_setpos(perlio, sv)
+
+    ferror(stream)              PerlIO_error(perlio)
+    clearerr(stream)            PerlIO_clearerr(perlio)
+
+=head2 Memory Management and String Handling
+
+    Instead Of:                 Use:
+
+    t* p = malloc(n)            New(id, p, n, t)
+    t* p = calloc(n, s)         Newz(id, p, n, t)
+    p = realloc(p, n)           Renew(p, n, t)
+    memcpy(dst, src, n)         Copy(src, dst, n, t)
+    memmove(dst, src, n)        Move(src, dst, n, t)
+    memcpy/*(struct foo *)      StructCopy(src, dst, t)
+    free(p)                     Safefree(p)
+
+    strdup(p)                   savepv(p)
+    strndup(p, n)               savepvn(p, n) (Hey, strndup doesn't exist!)
+
+    strstr(big, little)         instr(big, little)
+    strcmp(s1, s2)              strLE(s1, s2) / strEQ(s1, s2) / strGT(s1,s2)
+    strncmp(s1, s2, n)          strnNE(s1, s2, n) / strnEQ(s1, s2, n)
+
+Notice the different order of arguments to C<Copy> and C<Move> than used
+in C<memcpy> and C<memmove>.
+
+Most of the time, though, you'll want to be dealing with SVs internally
+instead of raw C<char *> strings:
+
+    strlen(s)                   sv_len(sv)
+    strcpy(dt, src)             sv_setpv(sv, s)
+    strncpy(dt, src, n)         sv_setpvn(sv, s, n)
+    strcat(dt, src)             sv_catpv(sv, s)
+    strncat(dt, src)            sv_catpvn(sv, s)
+    sprintf(s, fmt, ...)        sv_setpvf(sv, fmt, ...)
+
+Note also the existence of C<sv_catpvf> and C<sv_catpvfn>, combining
+concatenation with formatting.
+
+=head2 Character Class Tests
+
+There are two types of character class tests that Perl implements: one
+type deals in C<char>s and are thus B<not> Unicode aware (and hence
+deprecated unless you B<know> you should use them) and the other type
+deal in C<UV>s and know about Unicode properties. In the following
+table, C<c> is a C<char>, and C<u> is a Unicode codepoint.
+
+    Instead Of:                 Use:            But better use:
+
+    isalnum(c)                  isALNUM(c)      isALNUM_uni(u)
+    isalpha(c)                  isALPHA(c)      isALPHA_uni(u)
+    iscntrl(c)                  isCNTRL(c)      isCNTRL_uni(u)
+    isdigit(c)                  isDIGIT(c)      isDIGIT_uni(u)
+    isgraph(c)                  isGRAPH(c)      isGRAPH_uni(u)
+    islower(c)                  isLOWER(c)      isLOWER_uni(u)
+    isprint(c)                  isPRINT(c)      isPRINT_uni(u)
+    ispunct(c)                  isPUNCT(c)      isPUNCT_uni(u)
+    isspace(c)                  isSPACE(c)      isSPACE_uni(u)
+    isupper(c)                  isUPPER(c)      isUPPER_uni(u)
+    isxdigit(c)                 isXDIGIT(c)     isXDIGIT_uni(u)
+
+    tolower(c)                  toLOWER(c)      toLOWER_uni(u)
+    toupper(c)                  toUPPER(c)      toUPPER_uni(u)
+
+=head2 F<stdlib.h> functions
+
+    Instead Of:                 Use: 
+
+    atof(s)                     Atof(s)
+    atol(s)                     Atol(s)
+    strtod(s, *p)               Nothing.  Just don't use it.
+    strtol(s, *p, n)            Strtol(s, *p, n)
+    strtoul(s, *p, n)           Strtoul(s, *p, n)
+
+Notice also the C<scan_bin>, C<scan_hex>, and C<scan_oct> functions in
+F<util.c> for converting strings representing numbers in the respective
+bases into C<NV>s.
+
+In theory C<Strtol> and C<Strtoul> may not be defined if the machine perl is
+built on doesn't actually have strtol and strtoul. But as those 2
+functions are part of the 1989 ANSI C spec we suspect you'll find them
+everywhere by now.
+
+    int rand()                  double Drand01()
+    srand(n)                    { seedDrand01((Rand_seed_t)n); 
+                                  PL_srand_called = TRUE; }
+
+    exit(n)                     my_exit(n)
+    system(s)                   Don't. Look at pp_system or use my_popen
+
+    getenv(s)                   PerlEnv_getenv(s)
+    setenv(s, val)              my_putenv(s, val)
+
+=head2 Miscellaneous functions
+
+You should not even B<want> to use F<setjmp.h> functions, but if you
+think you do, use the C<JMPENV> stack in F<scope.h> instead.
+
+For C<signal>/C<sigaction>, use C<rsignal(signo, handler)>.
+
+=head1 SEE ALSO
+
+C<perlapi>, C<perlapio>, C<perlguts>
+

contrib/perl5/pod/perldebtut.pod

@@ -0,0 +1,721 @@
+=head1 NAME
+
+perldebtut - Perl debugging tutorial
+
+=head1 DESCRIPTION
+
+A (very) lightweight introduction in the use of the perl debugger, and a
+pointer to existing, deeper sources of information on the subject of debugging
+perl programs.  
+
+There's an extraordinary number of people out there who don't appear to know
+anything about using the perl debugger, though they use the language every
+day.  
+This is for them.  
+
+
+=head1 use strict
+
+First of all, there's a few things you can do to make your life a lot more
+straightforward when it comes to debugging perl programs, without using the
+debugger at all.  To demonstrate, here's a simple script with a problem:
+
+	#!/usr/bin/perl
+
+	$var1 = 'Hello World'; # always wanted to do that :-)
+	$var2 = "$varl\n";
+
+	print $var2; 
+	exit;
+
+While this compiles and runs happily, it probably won't do what's expected,
+namely it doesn't print "Hello World\n" at all;  It will on the other hand do
+exactly what it was told to do, computers being a bit that way inclined.  That
+is, it will print out a newline character, and you'll get what looks like a
+blank line.  It looks like there's 2 variables when (because of the typo)
+there's really 3:
+
+	$var1 = 'Hello World'
+	$varl = undef
+	$var2 = "\n"
+
+To catch this kind of problem, we can force each variable to be declared
+before use by pulling in the strict module, by putting 'use strict;' after the
+first line of the script.
+
+Now when you run it, perl complains about the 3 undeclared variables and we
+get four error messages because one variable is referenced twice:
+
+ Global symbol "$var1" requires explicit package name at ./t1 line 4.
+ Global symbol "$var2" requires explicit package name at ./t1 line 5.
+ Global symbol "$varl" requires explicit package name at ./t1 line 5.
+ Global symbol "$var2" requires explicit package name at ./t1 line 7.
+ Execution of ./hello aborted due to compilation errors.     
+
+Luvverly! and to fix this we declare all variables explicitly and now our
+script looks like this:	
+
+	#!/usr/bin/perl
+	use strict;
+
+	my $var1 = 'Hello World';
+	my $varl = '';
+	my $var2 = "$varl\n";
+
+	print $var2; 
+	exit;
+
+We then do (always a good idea) a syntax check before we try to run it again:
+
+	> perl -c hello
+	hello syntax OK 
+
+And now when we run it, we get "\n" still, but at least we know why.  Just
+getting this script to compile has exposed the '$varl' (with the letter 'l)
+variable, and simply changing $varl to $var1 solves the problem.
+
+
+=head1 Looking at data and -w and w
+
+Ok, but how about when you want to really see your data, what's in that
+dynamic variable, just before using it?
+
+	#!/usr/bin/perl 
+	use strict;
+
+	my $key = 'welcome';
+	my %data = (
+		'this' => qw(that), 
+		'tom' => qw(and jerry),
+		'welcome' => q(Hello World),
+		'zip' => q(welcome),
+	);
+	my @data = keys %data;
+
+	print "$data{$key}\n";
+	exit;                               
+
+Looks OK, after it's been through the syntax check (perl -c scriptname), we
+run it and all we get is a blank line again!  Hmmmm.
+
+One common debugging approach here, would be to liberally sprinkle a few print
+statements, to add a check just before we print out our data, and another just
+after:
+
+	print "All OK\n" if grep($key, keys %data);
+	print "$data{$key}\n";
+	print "done: '$data{$key}'\n";
+
+And try again:
+
+	> perl data
+	All OK     
+
+	done: ''
+
+After much staring at the same piece of code and not seeing the wood for the
+trees for some time, we get a cup of coffee and try another approach.  That
+is, we bring in the cavalry by giving perl the 'B<-d>' switch on the command
+line:
+
+	> perl -d data 
+	Default die handler restored.
+
+	Loading DB routines from perl5db.pl version 1.07
+	Editor support available.
+
+	Enter h or `h h' for help, or `man perldebug' for more help.
+
+	main::(./data:4):     my $key = 'welcome';   
+
+Now, what we've done here is to launch the built-in perl debugger on our
+script.  It's stopped at the first line of executable code and is waiting for
+input.
+
+Before we go any further, you'll want to know how to quit the debugger: use
+just the letter 'B<q>', not the words 'quit' or 'exit':
+
+	DB<1> q
+	>
+
+That's it, you're back on home turf again.
+
+
+=head1 help
+
+Fire the debugger up again on your script and we'll look at the help menu. 
+There's a couple of ways of calling help: a simple 'B<h>' will get you a long
+scrolled list of help, 'B<|h>' (pipe-h) will pipe the help through your pager
+('more' or 'less' probably), and finally, 'B<h h>' (h-space-h) will give you a
+helpful mini-screen snapshot:
+
+ DB<1> h h
+ List/search source lines:               Control script execution:
+ l [ln|sub]  List source code            T           Stack trace
+ - or .      List previous/current line  s [expr]    Single step [in expr]
+ w [line]    List around line            n [expr]    Next, steps over subs
+ f filename  View source in file         <CR/Enter>  Repeat last n or s
+ /pattern/ ?patt?   Search forw/backw    r           Return from subroutine
+ v           Show versions of modules    c [ln|sub]  Continue until position
+ Debugger controls:                        L           List
+break/watch/actions
+ O [...]     Set debugger options        t [expr]    Toggle trace [trace expr]
+ <[<]|{[{]|>[>] [cmd] Do pre/post-prompt b [ln|event|sub] [cnd] Set breakpoint
+ ! [N|pat]   Redo a previous command     d [ln] or D Delete a/all breakpoints
+ H [-num]    Display last num commands   a [ln] cmd  Do cmd before line
+ = [a val]   Define/list an alias        W expr      Add a watch expression
+ h [db_cmd]  Get help on command         A or W      Delete all actions/watch
+ |[|]db_cmd  Send output to pager        ![!] syscmd Run cmd in a subprocess
+ q or ^D     Quit                        R           Attempt a restart
+ Data Examination:       expr     Execute perl code, also see: s,n,t expr
+ x|m expr      Evals expr in list context, dumps the result or lists methods.
+ p expr        Print expression (uses script's current package).
+ S [[!]pat]    List subroutine names [not] matching pattern
+ V [Pk [Vars]] List Variables in Package.  Vars can be ~pattern or !pattern.
+ X [Vars]      Same as "V current_package [Vars]".
+ For more help, type h cmd_letter, or run man perldebug for all docs.       
+
+More confusing options than you can shake a big stick at!  It's not as bad as
+it looks and it's very useful to know more about all of it, and fun too!
+
+There's a couple of useful ones to know about straight away.  You wouldn't
+think we're using any libraries at all at the moment, but 'B<v>' will show
+which modules are currently loaded, by the debugger as well your script. 
+'B<V>' and 'B<X>' show variables in the program by package scope and can be
+constrained by pattern.  'B<m>' shows methods and 'B<S>' shows all subroutines
+(by pattern):
+
+	DB<2>S str 
+	dumpvar::stringify
+	strict::bits
+	strict::import
+	strict::unimport  
+
+Using 'X' and cousins requires you not to use the type identifiers ($@%), just
+the 'name':
+
+	DM<3>X ~err
+	FileHandle(stderr) => fileno(2)    
+
+Remember we're in our tiny program with a problem, we should have a look at
+where we are, and what our data looks like. First of all let's have a window
+on our present position (the first line of code in this case), via the letter
+'B<w>':
+
+	DB<4> w
+	1       #!/usr/bin/perl
+	2:      use strict;
+	3
+	4==>    my $key = 'welcome';
+	5:      my %data = (
+	6               'this' => qw(that),
+	7               'tom' => qw(and jerry),
+	8               'welcome' => q(Hello World),
+	9               'zip' => q(welcome),
+	10      );                                 
+
+At line number 4 is a helpful pointer, that tells you where you are now.  To
+see more code, type 'w' again:
+
+	DB<4> w
+	8               'welcome' => q(Hello World),
+	9               'zip' => q(welcome),
+	10      );
+	11:     my @data = keys %data;
+	12:     print "All OK\n" if grep($key, keys %data);
+	13:     print "$data{$key}\n";
+	14:     print "done: '$data{$key}'\n";
+	15:     exit;      
+
+And if you wanted to list line 5 again, type 'l 5', (note the space):
+
+	DB<4> l 5
+	5:      my %data = (
+
+In this case, there's not much to see, but of course normally there's pages of
+stuff to wade through, and 'l' can be very useful.  To reset your view to the
+line we're about to execute, type a lone period '.':
+
+	DB<5> .
+	main::(./data_a:4):     my $key = 'welcome';  
+
+The line shown is the one that is about to be executed B<next>, it hasn't
+happened yet.  So while we can print a variable with the letter 'B<p>', at
+this point all we'd get is an empty (undefined) value back.  What we need to
+do is to step through the next executable statement with an 'B<s>':
+
+	DB<6> s
+	main::(./data_a:5):     my %data = (
+	main::(./data_a:6):             'this' => qw(that),
+	main::(./data_a:7):             'tom' => qw(and jerry),
+	main::(./data_a:8):             'welcome' => q(Hello World),
+	main::(./data_a:9):             'zip' => q(welcome),
+	main::(./data_a:10):    );   
+
+Now we can have a look at that first ($key) variable:
+
+	DB<7> p $key 
+	welcome 
+
+line 13 is where the action is, so let's continue down to there via the letter
+'B<c>', which by the way, inserts a 'one-time-only' breakpoint at the given
+line or sub routine:
+
+	DB<8> c 13
+	All OK
+	main::(./data_a:13):    print "$data{$key}\n";
+
+We've gone past our check (where 'All OK' was printed) and have stopped just
+before the meat of our task.  We could try to print out a couple of variables
+to see what is happening:
+
+	DB<9> p $data{$key}
+
+Not much in there, lets have a look at our hash:
+
+	DB<10> p %data
+	Hello Worldziptomandwelcomejerrywelcomethisthat 
+
+	DB<11> p keys %data
+	Hello Worldtomwelcomejerrythis  
+
+Well, this isn't very easy to read, and using the helpful manual (B<h h>), the
+'B<x>' command looks promising:
+
+	DB<12> x %data
+	0  'Hello World'
+	1  'zip'
+	2  'tom'
+	3  'and'
+	4  'welcome'
+	5  undef
+	6  'jerry'
+	7  'welcome'
+	8  'this'
+	9  'that'     
+
+That's not much help, a couple of welcomes in there, but no indication of
+which are keys, and which are values, it's just a listed array dump and, in
+this case, not particularly helpful.  The trick here, is to use a B<reference>
+to the data structure:
+
+	DB<13> x \%data
+	0  HASH(0x8194bc4)
+	   'Hello World' => 'zip'
+	   'jerry' => 'welcome'
+	   'this' => 'that'
+	   'tom' => 'and'
+	   'welcome' => undef  
+
+The reference is truly dumped and we can finally see what we're dealing with. 
+Our quoting was perfectly valid but wrong for our purposes, with 'and jerry'
+being treated as 2 separate words rather than a phrase, thus throwing the
+evenly paired hash structure out of alignment.
+
+The 'B<-w>' switch would have told us about this, had we used it at the start,
+and saved us a lot of trouble: 
+
+	> perl -w data
+	Odd number of elements in hash assignment at ./data line 5.    
+
+We fix our quoting: 'tom' => q(and jerry), and run it again, this time we get
+our expected output:
+
+	> perl -w data
+	Hello World
+
+
+While we're here, take a closer look at the 'B<x>' command, it's really useful
+and will merrily dump out nested references, complete objects, partial objects
+- just about whatever you throw at it:
+
+Let's make a quick object and x-plode it, first we'll start the the debugger:
+it wants some form of input from STDIN, so we give it something non-commital,
+a zero:
+
+	> perl -de 0
+	Default die handler restored.
+
+	Loading DB routines from perl5db.pl version 1.07
+	Editor support available.
+
+	Enter h or `h h' for help, or `man perldebug' for more help.
+
+	main::(-e:1):   0                       
+
+Now build an on-the-fly object over a couple of lines (note the backslash):
+
+	DB<1> $obj = bless({'unique_id'=>'123', 'attr'=> \
+	cont: 	{'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
+
+And let's have a look at it:
+
+  	DB<2> x $obj
+	0  MY_class=HASH(0x828ad98)
+   		'attr' => HASH(0x828ad68)
+      	'col' => 'black'
+      	'things' => ARRAY(0x828abb8)
+         	0  'this'
+         	1  'that'
+         	2  'etc'
+   		'unique_id' => 123       
+  	DB<3>
+
+Useful, huh?  You can eval nearly anything in there, and experiment with bits
+of code or regexes until the cows come home:
+
+	DB<3> @data = qw(this that the other atheism leather theory scythe)
+
+	DB<4> p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
+	atheism
+	leather
+	other
+	scythe
+	the
+	theory  
+	saw -> 6
+
+If you want to see the command History, type an 'B<H>':
+
+	DB<5> H
+	4: p 'saw -> '.($cnt += map { print "\t:\t$_\n" } grep(/the/, sort @data))
+	3: @data = qw(this that the other atheism leather theory scythe)
+	2: x $obj
+	1: $obj = bless({'unique_id'=>'123', 'attr'=>
+	{'col' => 'black', 'things' => [qw(this that etc)]}}, 'MY_class')
+	DB<5>
+
+And if you want to repeat any previous command, use the exclamation: 'B<!>':
+
+	DB<5> !4
+	p 'saw -> '.($cnt += map { print "$_\n" } grep(/the/, sort @data))
+	atheism
+	leather
+	other
+	scythe
+	the
+	theory  
+	saw -> 12
+
+For more on references see L<perlref> and L<perlreftut>
+
+
+=head1 Stepping through code
+
+Here's a simple program which converts between Celsius and Fahrenheit, it too
+has a problem:
+
+	#!/usr/bin/perl -w
+	use strict;
+
+	my $arg = $ARGV[0] || '-c20';
+
+	if ($arg =~ /^\-(c|f)((\-|\+)*\d+(\.\d+)*)$/) {
+		my ($deg, $num) = ($1, $2);
+		my ($in, $out) = ($num, $num);
+		if ($deg eq 'c') {
+			$deg = 'f';
+			$out = &c2f($num);
+		} else {
+			$deg = 'c';
+			$out = &f2c($num);
+		}
+		$out = sprintf('%0.2f', $out);
+		$out =~ s/^((\-|\+)*\d+)\.0+$/$1/;
+		print "$out $deg\n";
+	} else {
+		print "Usage: $0 -[c|f] num\n";
+	}
+	exit;
+
+	sub f2c {
+		my $f = shift;
+		my $c = 5 * $f - 32 / 9;
+		return $c;
+	}
+
+	sub c2f {
+		my $c = shift;
+		my $f = 9 * $c / 5 + 32;
+		return $f;
+	}
+
+
+For some reason, the Fahrenheit to Celsius conversion fails to return the
+expected output.  This is what it does:
+
+	> temp -c0.72
+	33.30 f
+
+	> temp -f33.3
+	162.94 c
+
+Not very consistent!  We'll set a breakpoint in the code manually and run it
+under the debugger to see what's going on.  A breakpoint is a flag, to which
+the debugger will run without interruption, when it reaches the breakpoint, it
+will stop execution and offer a prompt for further interaction.  In normal
+use, these debugger commands are completely ignored, and they are safe - if a
+little messy, to leave in production code.
+
+	my ($in, $out) = ($num, $num);
+	$DB::single=2; # insert at line 9!
+	if ($deg eq 'c') 
+		...
+
+	> perl -d temp -f33.3
+	Default die handler restored.
+
+	Loading DB routines from perl5db.pl version 1.07
+	Editor support available.
+
+	Enter h or `h h' for help, or `man perldebug' for more help.
+
+	main::(temp:4): my $arg = $ARGV[0] || '-c100';     
+
+We'll simply continue down to our pre-set breakpoint with a 'B<c>':
+
+  	DB<1> c
+	main::(temp:10):                if ($deg eq 'c') {   
+
+Followed by a window command to see where we are:
+
+	DB<1> w
+	7:              my ($deg, $num) = ($1, $2);
+	8:              my ($in, $out) = ($num, $num);
+	9:              $DB::single=2;
+	10==>           if ($deg eq 'c') {
+	11:                     $deg = 'f';
+	12:                     $out = &c2f($num);
+	13              } else {
+	14:                     $deg = 'c';
+	15:                     $out = &f2c($num);
+	16              }                             
+
+And a print to show what values we're currently using:
+
+	DB<1> p $deg, $num
+	f33.3
+
+We can put another break point on any line beginning with a colon, we'll use
+line 17 as that's just as we come out of the subroutine, and we'd like to
+pause there later on:
+
+	DB<2> b 17
+
+There's no feedback from this, but you can see what breakpoints are set by
+using the list 'L' command:
+
+	DB<3> L
+	temp:
+ 		17:            print "$out $deg\n";
+   		break if (1)     
+
+Note that to delete a breakpoint you use 'd' or 'D'.
+
+Now we'll continue down into our subroutine, this time rather than by line
+number, we'll use the subroutine name, followed by the now familiar 'w':
+
+	DB<3> c f2c
+	main::f2c(temp:30):             my $f = shift;  
+
+	DB<4> w
+	24:     exit;
+	25
+	26      sub f2c {
+	27==>           my $f = shift;
+	28:             my $c = 5 * $f - 32 / 9; 
+	29:             return $c;
+	30      }
+	31
+	32      sub c2f {
+	33:             my $c = shift;   
+
+
+Note that if there was a subroutine call between us and line 29, and we wanted
+to B<single-step> through it, we could use the 'B<s>' command, and to step
+over it we would use 'B<n>' which would execute the sub, but not descend into
+it for inspection.  In this case though, we simply continue down to line 29:
+
+	DB<4> c 29  
+	main::f2c(temp:29):             return $c;
+
+And have a look at the return value:
+
+	DB<5> p $c
+	162.944444444444
+
+This is not the right answer at all, but the sum looks correct.  I wonder if
+it's anything to do with operator precedence?  We'll try a couple of other
+possibilities with our sum:
+
+	DB<6> p (5 * $f - 32 / 9)
+	162.944444444444
+
+	DB<7> p 5 * $f - (32 / 9) 
+	162.944444444444
+
+	DB<8> p (5 * $f) - 32 / 9
+	162.944444444444
+
+	DB<9> p 5 * ($f - 32) / 9
+	0.722222222222221
+
+:-) that's more like it!  Ok, now we can set our return variable and we'll
+return out of the sub with an 'r':
+
+	DB<10> $c = 5 * ($f - 32) / 9
+
+	DB<11> r
+	scalar context return from main::f2c: 0.722222222222221
+
+Looks good, let's just continue off the end of the script:
+
+	DB<12> c
+	0.72 c 
+	Debugged program terminated.  Use q to quit or R to restart,
+  	use O inhibit_exit to avoid stopping after program termination,
+  	h q, h R or h O to get additional info.   
+
+A quick fix to the offending line (insert the missing parentheses) in the
+actual program and we're finished.
+
+
+=head1 Placeholder for a, w, t, T
+
+Actions, watch variables, stack traces etc.: on the TODO list.
+
+	a 
+
+	W 
+
+	t 
+
+	T
+
+
+=head1 REGULAR EXPRESSIONS
+
+Ever wanted to know what a regex looked like?  You'll need perl compiled with
+the DEBUGGING flag for this one:
+
+	> perl -Dr -e '/^pe(a)*rl$/i'
+	Compiling REx `^pe(a)*rl$'
+	size 17 first at 2
+	rarest char
+	 at 0
+	   1: BOL(2)
+	   2: EXACTF <pe>(4)
+	   4: CURLYN[1] {0,32767}(14)
+	   6:   NOTHING(8)
+	   8:   EXACTF <a>(0)
+	  12:   WHILEM(0)
+	  13: NOTHING(14)
+	  14: EXACTF <rl>(16)
+	  16: EOL(17)
+	  17: END(0)
+	floating `'$ at 4..2147483647 (checking floating) stclass `EXACTF <pe>'
+anchored(BOL) minlen 4
+	Omitting $` $& $' support.
+
+	EXECUTING...
+
+	Freeing REx: `^pe(a)*rl$'  
+
+Did you really want to know? :-)
+For more gory details on getting regular expressions to work, have a look at
+L<perlre>, L<perlretut>, and to decode the mysterious labels (BOL and CURLYN,
+etc. above), see L<perldebguts>.
+
+
+=head1 OUTPUT TIPS
+
+To get all the output from your error log, and not miss any messages via
+helpful operating system buffering, insert a line like this, at the start of
+your script:
+
+	$|=1;	
+
+To watch the tail of a dynamically growing logfile, (from the command line):
+
+	tail -f $error_log
+
+Wrapping all die calls in a handler routine can be useful to see how, and from
+where, they're being called, L<perlvar> has more information:
+
+	BEGIN { $SIG{__DIE__} = sub { require Carp; Carp::confess(@_) } }
+
+Various useful techniques for the redirection of STDOUT and STDERR filehandles
+are explained in L<perlopentut> and L<perlfaq8>.
+
+
+=head1 CGI
+
+Just a quick hint here for all those CGI programmers who can't figure out how
+on earth to get past that 'waiting for input' prompt, when running their CGI
+script from the command-line, try something like this:
+
+	> perl -d my_cgi.pl -nodebug 
+
+Of course L<CGI> and L<perlfaq9> will tell you more.
+
+
+=head1 GUIs
+
+The command line interface is tightly integrated with an B<emacs> extension
+and there's a B<vi> interface too.  
+
+You don't have to do this all on the command line, though, there are a few GUI
+options out there.  The nice thing about these is you can wave a mouse over a
+variable and a dump of it's data will appear in an appropriate window, or in a
+popup balloon, no more tiresome typing of 'x $varname' :-)
+
+In particular have a hunt around for the following:
+
+B<ptkdb> perlTK based wrapper for the built-in debugger
+
+B<ddd> data display debugger
+
+B<PerlDevKit> and B<PerlBuilder> are NT specific
+
+NB. (more info on these and others would be appreciated).
+
+
+=head1 SUMMARY
+
+We've seen how to encourage good coding practices with B<use strict> and
+B<-w>.  We can run the perl debugger B<perl -d scriptname> to inspect your
+data from within the perl debugger with the B<p> and B<x> commands.  You can
+walk through your code, set breakpoints with B<b> and step through that code
+with B<s> or B<n>, continue with B<c> and return from a sub with B<r>.  Fairly
+intuitive stuff when you get down to it.  
+
+There is of course lots more to find out about, this has just scratched the
+surface.  The best way to learn more is to use perldoc to find out more about
+the language, to read the on-line help (L<perldebug> is probably the next
+place to go), and of course, experiment.  
+
+
+=head1 SEE ALSO
+
+L<perldebug>, 
+L<perldebguts>, 
+L<perldiag>,
+L<dprofpp>,
+L<perlrun>
+
+
+=head1 AUTHOR
+
+Richard Foley <richard@rfi.net> Copyright (c) 2000
+
+
+=head1 CONTRIBUTORS
+
+Various people have made helpful suggestions and contributions, in particular:
+
+Ronald J Kimball <rjk@linguist.dartmouth.edu>
+
+Hugo van der Sanden <hv@crypt0.demon.co.uk>
+
+Peter Scott <Peter@PSDT.com>
+

contrib/perl5/pod/perlnewmod.pod

@@ -0,0 +1,282 @@
+=head1 NAME
+
+perlnewmod - preparing a new module for distribution
+
+=head1 DESCRIPTION
+
+This document gives you some suggestions about how to go about writing
+Perl modules, preparing them for distribution, and making them available
+via CPAN.
+
+One of the things that makes Perl really powerful is the fact that Perl
+hackers tend to want to share the solutions to problems they've faced,
+so you and I don't have to battle with the same problem again.
+
+The main way they do this is by abstracting the solution into a Perl
+module. If you don't know what one of these is, the rest of this
+document isn't going to be much use to you. You're also missing out on
+an awful lot of useful code; consider having a look at L<perlmod>,
+L<perlmodlib> and L<perlmodinstall> before coming back here.
+
+When you've found that there isn't a module available for what you're
+trying to do, and you've had to write the code yourself, consider
+packaging up the solution into a module and uploading it to CPAN so that
+others can benefit.
+
+=head2 Warning
+
+We're going to primarily concentrate on Perl-only modules here, rather
+than XS modules. XS modules serve a rather different purpose, and
+you should consider different things before distributing them - the
+popularity of the library you are gluing, the portability to other
+operating systems, and so on. However, the notes on preparing the Perl
+side of the module and packaging and distributing it will apply equally
+well to an XS module as a pure-Perl one.
+
+=head2 What should I make into a module?
+
+You should make a module out of any code that you think is going to be
+useful to others. Anything that's likely to fill a hole in the communal
+library and which someone else can slot directly into their program. Any
+part of your code which you can isolate and extract and plug into
+something else is a likely candidate.
+
+Let's take an example. Suppose you're reading in data from a local
+format into a hash-of-hashes in Perl, turning that into a tree, walking
+the tree and then piping each node to an Acme Transmogrifier Server.
+
+Now, quite a few people have the Acme Transmogrifier, and you've had to
+write something to talk the protocol from scratch - you'd almost
+certainly want to make that into a module. The level at which you pitch
+it is up to you: you might want protocol-level modules analogous to
+L<Net::SMTP|Net::SMTP> which then talk to higher level modules analogous
+to L<Mail::Send|Mail::Send>. The choice is yours, but you do want to get
+a module out for that server protocol.
+
+Nobody else on the planet is going to talk your local data format, so we
+can ignore that. But what about the thing in the middle? Building tree
+structures from Perl variables and then traversing them is a nice,
+general problem, and if nobody's already written a module that does
+that, you might want to modularise that code too.
+
+So hopefully you've now got a few ideas about what's good to modularise.
+Let's now see how it's done.
+
+=head2 Step-by-step: Preparing the ground
+
+Before we even start scraping out the code, there are a few things we'll
+want to do in advance.
+
+=over 3
+
+=item Look around
+
+Dig into a bunch of modules to see how they're written. I'd suggest
+starting with L<Text::Tabs|Text::Tabs>, since it's in the standard
+library and is nice and simple, and then looking at something like
+L<Time::Zone|Time::Zone>, L<File::Copy|File::Copy> and then some of the
+C<Mail::*> modules if you're planning on writing object oriented code.
+
+These should give you an overall feel for how modules are laid out and
+written.
+
+=item Check it's new
+
+There are a lot of modules on CPAN, and it's easy to miss one that's
+similar to what you're planning on contributing. Have a good plough
+through the modules list and the F<by-module> directories, and make sure
+you're not the one reinventing the wheel!
+
+=item Discuss the need
+
+You might love it. You might feel that everyone else needs it. But there
+might not actually be any real demand for it out there. If you're unsure
+about the demand you're module will have, consider sending out feelers
+on the C<comp.lang.perl.modules> newsgroup, or as a last resort, ask the
+modules list at C<modules@perl.org>. Remember that this is a closed list
+with a very long turn-around time - be prepared to wait a good while for
+a response from them.
+
+=item Choose a name
+
+Perl modules included on CPAN have a naming hierarchy you should try to
+fit in with. See L<perlmodlib> for more details on how this works, and
+browse around CPAN and the modules list to get a feel of it. At the very
+least, remember this: modules should be title capitalised, (This::Thing)
+fit in with a category, and explain their purpose succinctly.
+
+=item Check again
+
+While you're doing that, make really sure you haven't missed a module
+similar to the one you're about to write.
+
+When you've got your name sorted out and you're sure that your module is
+wanted and not currently available, it's time to start coding.
+
+=back
+
+=head2 Step-by-step: Making the module
+
+=over 3
+
+=item Start with F<h2xs>
+
+Originally a utility to convert C header files into XS modules,
+L<h2xs|h2xs> has become a useful utility for churning out skeletons for
+Perl-only modules as well. If you don't want to use the
+L<Autoloader|Autoloader> which splits up big modules into smaller
+subroutine-sized chunks, you'll say something like this:
+
+    h2xs -AX -n Net::Acme
+
+The C<-A> omits the Autoloader code, C<-X> omits XS elements, and C<-n>
+specifies the name of the module.
+
+=item Use L<strict|strict> and L<warnings|warnings>
+
+A module's code has to be warning and strict-clean, since you can't
+guarantee the conditions that it'll be used under. Besides, you wouldn't
+want to distribute code that wasn't warning or strict-clean anyway,
+right?
+
+=item Use L<Carp|Carp>
+
+The L<Carp|Carp> module allows you to present your error messages from
+the caller's perspective; this gives you a way to signal a problem with
+the caller and not your module. For instance, if you say this:
+
+    warn "No hostname given";
+
+the user will see something like this:
+
+    No hostname given at /usr/local/lib/perl5/site_perl/5.6.0/Net/Acme.pm
+    line 123.
+
+which looks like your module is doing something wrong. Instead, you want
+to put the blame on the user, and say this:
+
+    No hostname given at bad_code, line 10.
+
+You do this by using L<Carp|Carp> and replacing your C<warn>s with
+C<carp>s. If you need to C<die>, say C<croak> instead. However, keep
+C<warn> and C<die> in place for your sanity checks - where it really is
+your module at fault.
+
+=item Use L<Exporter|Exporter> - wisely!
+
+C<h2xs> provides stubs for L<Exporter|Exporter>, which gives you a
+standard way of exporting symbols and subroutines from your module into
+the caller's namespace. For instance, saying C<use Net::Acme qw(&frob)>
+would import the C<frob> subroutine.
+
+The package variable C<@EXPORT> will determine which symbols will get
+exported when the caller simply says C<use Net::Acme> - you will hardly
+ever want to put anything in there. C<@EXPORT_OK>, on the other hand,
+specifies which symbols you're willing to export. If you do want to
+export a bunch of symbols, use the C<%EXPORT_TAGS> and define a standard
+export set - look at L<Exporter> for more details.
+
+=item Use L<plain old documentation|perlpod>
+
+The work isn't over until the paperwork is done, and you're going to
+need to put in some time writing some documentation for your module.
+C<h2xs> will provide a stub for you to fill in; if you're not sure about
+the format, look at L<perlpod> for an introduction. Provide a good
+synopsis of how your module is used in code, a description, and then
+notes on the syntax and function of the individual subroutines or
+methods. Use Perl comments for developer notes and POD for end-user
+notes.
+
+=item Write tests
+
+You're encouraged to create self-tests for your module to ensure it's
+working as intended on the myriad platforms Perl supports; if you upload
+your module to CPAN, a host of testers will build your module and send
+you the results of the tests. Again, C<h2xs> provides a test framework
+which you can extend - you should do something more than just checking
+your module will compile.
+
+=item Write the README
+
+If you're uploading to CPAN, the automated gremlins will extract the
+README file and place that in your CPAN directory. It'll also appear in
+the main F<by-module> and F<by-category> directories if you make it onto
+the modules list. It's a good idea to put here what the module actually
+does in detail, and the user-visible changes since the last release.
+
+=back
+
+=head2 Step-by-step: Distributing your module
+
+=over 3
+
+=item Get a CPAN user ID
+
+Every developer publishing modules on CPAN needs a CPAN ID. See the
+instructions at C<http://www.cpan.org/modules/04pause.html> (or
+equivalent on your nearest mirror) to find out how to do this.
+
+=item C<perl Makefile.PL; make test; make dist>
+
+Once again, C<h2xs> has done all the work for you. It produces the
+standard C<Makefile.PL> you'll have seen when you downloaded and
+installs modules, and this produces a Makefile with a C<dist> target.
+
+Once you've ensured that your module passes its own tests - always a
+good thing to make sure - you can C<make dist>, and the Makefile will
+hopefully produce you a nice tarball of your module, ready for upload.
+
+=item Upload the tarball
+
+The email you got when you received your CPAN ID will tell you how to
+log in to PAUSE, the Perl Authors Upload SErver. From the menus there,
+you can upload your module to CPAN.
+
+=item Announce to the modules list
+
+Once uploaded, it'll sit unnoticed in your author directory. If you want
+it connected to the rest of the CPAN, you'll need to tell the modules
+list about it. The best way to do this is to email them a line in the
+style of the modules list, like this:
+
+    Net::Acme bdpO  Interface to Acme Frobnicator servers         FOOBAR
+    ^         ^^^^  ^                                             ^
+    |         ||||  Module description                            Your ID
+    |         ||||
+    |         |||\- Interface: (O)OP, (r)eferences, (h)ybrid, (f)unctions
+    |         |||
+    |         ||\-- Language: (p)ure Perl, C(+)+, (h)ybrid, (C), (o)ther
+    |         ||
+    Module    |\--- Support: (d)eveloper, (m)ailing list, (u)senet, (n)one
+    Name      |
+              \---- Maturity: (i)dea, (c)onstructions, (a)lpha, (b)eta,
+                              (R)eleased, (M)ature, (S)tandard
+
+plus a description of the module and why you think it should be
+included. If you hear nothing back, that means your module will
+probably appear on the modules list at the next update. Don't try
+subscribing to C<modules@perl.org>; it's not another mailing list. Just
+have patience.
+
+=item Announce to clpa
+
+If you have a burning desire to tell the world about your release, post
+an announcement to the moderated C<comp.lang.perl.announce> newsgroup.
+
+=item Fix bugs!
+
+Once you start accumulating users, they'll send you bug reports. If
+you're lucky, they'll even send you patches. Welcome to the joys of
+maintaining a software project...
+
+=back
+
+=head1 AUTHOR
+
+Simon Cozens, C<simon@cpan.org>
+
+=head1 SEE ALSO
+
+L<perlmod>, L<perlmodlib>, L<perlmodinstall>, L<h2xs>, L<strict>,
+L<Carp>, L<Exporter>, L<perlpod>, L<Test>, L<ExtUtils::MakeMaker>,
+http://www.cpan.org/

contrib/perl5/pod/perlrequick.pod

@@ -0,0 +1,503 @@
+=head1 NAME
+
+perlrequick - Perl regular expressions quick start
+
+=head1 DESCRIPTION
+
+This page covers the very basics of understanding, creating and
+using regular expressions ('regexes') in Perl.
+
+
+=head1 The Guide
+
+=head2 Simple word matching
+
+The simplest regex is simply a word, or more generally, a string of
+characters.  A regex consisting of a word matches any string that
+contains that word:
+
+    "Hello World" =~ /World/;  # matches
+
+In this statement, C<World> is a regex and the C<//> enclosing
+C</World/> tells perl to search a string for a match.  The operator
+C<=~> associates the string with the regex match and produces a true
+value if the regex matched, or false if the regex did not match.  In
+our case, C<World> matches the second word in C<"Hello World">, so the
+expression is true.  This idea has several variations.
+
+Expressions like this are useful in conditionals:
+
+    print "It matches\n" if "Hello World" =~ /World/;
+
+The sense of the match can be reversed by using C<!~> operator:
+
+    print "It doesn't match\n" if "Hello World" !~ /World/;
+
+The literal string in the regex can be replaced by a variable:
+
+    $greeting = "World";
+    print "It matches\n" if "Hello World" =~ /$greeting/;
+
+If you're matching against C<$_>, the C<$_ =~> part can be omitted:
+
+    $_ = "Hello World";
+    print "It matches\n" if /World/;
+
+Finally, the C<//> default delimiters for a match can be changed to
+arbitrary delimiters by putting an C<'m'> out front:
+
+    "Hello World" =~ m!World!;   # matches, delimited by '!'
+    "Hello World" =~ m{World};   # matches, note the matching '{}'
+    "/usr/bin/perl" =~ m"/perl"; # matches after '/usr/bin',
+                                 # '/' becomes an ordinary char
+
+Regexes must match a part of the string I<exactly> in order for the
+statement to be true:
+
+    "Hello World" =~ /world/;  # doesn't match, case sensitive
+    "Hello World" =~ /o W/;    # matches, ' ' is an ordinary char
+    "Hello World" =~ /World /; # doesn't match, no ' ' at end
+
+perl will always match at the earliest possible point in the string:
+
+    "Hello World" =~ /o/;       # matches 'o' in 'Hello'
+    "That hat is red" =~ /hat/; # matches 'hat' in 'That'
+
+Not all characters can be used 'as is' in a match.  Some characters,
+called B<metacharacters>, are reserved for use in regex notation.
+The metacharacters are
+
+    {}[]()^$.|*+?\
+
+A metacharacter can be matched by putting a backslash before it:
+
+    "2+2=4" =~ /2+2/;    # doesn't match, + is a metacharacter
+    "2+2=4" =~ /2\+2/;   # matches, \+ is treated like an ordinary +
+    'C:\WIN32' =~ /C:\\WIN/;                       # matches
+    "/usr/bin/perl" =~ /\/usr\/local\/bin\/perl/;  # matches
+
+In the last regex, the forward slash C<'/'> is also backslashed,
+because it is used to delimit the regex.
+
+Non-printable ASCII characters are represented by B<escape sequences>.
+Common examples are C<\t> for a tab, C<\n> for a newline, and C<\r>
+for a carriage return.  Arbitrary bytes are represented by octal
+escape sequences, e.g., C<\033>, or hexadecimal escape sequences,
+e.g., C<\x1B>:
+
+    "1000\t2000" =~ m(0\t2)        # matches
+    "cat"        =~ /\143\x61\x74/ # matches, but a weird way to spell cat
+
+Regexes are treated mostly as double quoted strings, so variable
+substitution works:
+
+    $foo = 'house';
+    'cathouse' =~ /cat$foo/;   # matches
+    'housecat' =~ /${foo}cat/; # matches
+
+With all of the regexes above, if the regex matched anywhere in the
+string, it was considered a match.  To specify I<where> it should
+match, we would use the B<anchor> metacharacters C<^> and C<$>.  The
+anchor C<^> means match at the beginning of the string and the anchor
+C<$> means match at the end of the string, or before a newline at the
+end of the string.  Some examples:
+
+    "housekeeper" =~ /keeper/;         # matches
+    "housekeeper" =~ /^keeper/;        # doesn't match
+    "housekeeper" =~ /keeper$/;        # matches
+    "housekeeper\n" =~ /keeper$/;      # matches
+    "housekeeper" =~ /^housekeeper$/;  # matches
+
+=head2 Using character classes
+
+A B<character class> allows a set of possible characters, rather than
+just a single character, to match at a particular point in a regex.
+Character classes are denoted by brackets C<[...]>, with the set of
+characters to be possibly matched inside.  Here are some examples:
+
+    /cat/;            # matches 'cat'
+    /[bcr]at/;        # matches 'bat', 'cat', or 'rat'
+    "abc" =~ /[cab]/; # matches 'a'
+
+In the last statement, even though C<'c'> is the first character in
+the class, the earliest point at which the regex can match is C<'a'>.
+
+    /[yY][eE][sS]/; # match 'yes' in a case-insensitive way
+                    # 'yes', 'Yes', 'YES', etc.
+    /yes/i;         # also match 'yes' in a case-insensitive way
+
+The last example shows a match with an C<'i'> B<modifier>, which makes
+the match case-insensitive.
+
+Character classes also have ordinary and special characters, but the
+sets of ordinary and special characters inside a character class are
+different than those outside a character class.  The special
+characters for a character class are C<-]\^$> and are matched using an
+escape:
+
+   /[\]c]def/; # matches ']def' or 'cdef'
+   $x = 'bcr';
+   /[$x]at/;   # matches 'bat, 'cat', or 'rat'
+   /[\$x]at/;  # matches '$at' or 'xat'
+   /[\\$x]at/; # matches '\at', 'bat, 'cat', or 'rat'
+
+The special character C<'-'> acts as a range operator within character
+classes, so that the unwieldy C<[0123456789]> and C<[abc...xyz]>
+become the svelte C<[0-9]> and C<[a-z]>:
+
+    /item[0-9]/;  # matches 'item0' or ... or 'item9'
+    /[0-9a-fA-F]/;  # matches a hexadecimal digit
+
+If C<'-'> is the first or last character in a character class, it is
+treated as an ordinary character.
+
+The special character C<^> in the first position of a character class
+denotes a B<negated character class>, which matches any character but
+those in the brackets.  Both C<[...]> and C<[^...]> must match a
+character, or the match fails.  Then
+
+    /[^a]at/;  # doesn't match 'aat' or 'at', but matches
+               # all other 'bat', 'cat, '0at', '%at', etc.
+    /[^0-9]/;  # matches a non-numeric character
+    /[a^]at/;  # matches 'aat' or '^at'; here '^' is ordinary
+
+Perl has several abbreviations for common character classes:
+
+=over 4
+
+=item *
+
+\d is a digit and represents [0-9]
+
+=item *
+
+\s is a whitespace character and represents [\ \t\r\n\f]
+
+=item *
+
+\w is a word character (alphanumeric or _) and represents [0-9a-zA-Z_]
+
+=item *
+
+\D is a negated \d; it represents any character but a digit [^0-9]
+
+=item *
+
+\S is a negated \s; it represents any non-whitespace character [^\s]
+
+=item *
+
+\W is a negated \w; it represents any non-word character [^\w]
+
+=item *
+
+The period '.' matches any character but "\n"
+
+=back
+
+The C<\d\s\w\D\S\W> abbreviations can be used both inside and outside
+of character classes.  Here are some in use:
+
+    /\d\d:\d\d:\d\d/; # matches a hh:mm:ss time format
+    /[\d\s]/;         # matches any digit or whitespace character
+    /\w\W\w/;         # matches a word char, followed by a
+                      # non-word char, followed by a word char
+    /..rt/;           # matches any two chars, followed by 'rt'
+    /end\./;          # matches 'end.'
+    /end[.]/;         # same thing, matches 'end.'
+
+The S<B<word anchor> > C<\b> matches a boundary between a word
+character and a non-word character C<\w\W> or C<\W\w>:
+
+    $x = "Housecat catenates house and cat";
+    $x =~ /\bcat/;  # matches cat in 'catenates'
+    $x =~ /cat\b/;  # matches cat in 'housecat'
+    $x =~ /\bcat\b/;  # matches 'cat' at end of string
+
+In the last example, the end of the string is considered a word
+boundary.
+
+=head2 Matching this or that
+
+We can match match different character strings with the B<alternation>
+metacharacter C<'|'>.  To match C<dog> or C<cat>, we form the regex
+C<dog|cat>.  As before, perl will try to match the regex at the
+earliest possible point in the string.  At each character position,
+perl will first try to match the the first alternative, C<dog>.  If
+C<dog> doesn't match, perl will then try the next alternative, C<cat>.
+If C<cat> doesn't match either, then the match fails and perl moves to
+the next position in the string.  Some examples:
+
+    "cats and dogs" =~ /cat|dog|bird/;  # matches "cat"
+    "cats and dogs" =~ /dog|cat|bird/;  # matches "cat"
+
+Even though C<dog> is the first alternative in the second regex,
+C<cat> is able to match earlier in the string.
+
+    "cats"          =~ /c|ca|cat|cats/; # matches "c"
+    "cats"          =~ /cats|cat|ca|c/; # matches "cats"
+
+At a given character position, the first alternative that allows the
+regex match to succeed wil be the one that matches. Here, all the
+alternatives match at the first string position, so th first matches.
+
+=head2 Grouping things and hierarchical matching
+
+The B<grouping> metacharacters C<()> allow a part of a regex to be
+treated as a single unit.  Parts of a regex are grouped by enclosing
+them in parentheses.  The regex C<house(cat|keeper)> means match
+C<house> followed by either C<cat> or C<keeper>.  Some more examples
+are
+
+    /(a|b)b/;    # matches 'ab' or 'bb'
+    /(^a|b)c/;   # matches 'ac' at start of string or 'bc' anywhere
+
+    /house(cat|)/;  # matches either 'housecat' or 'house'
+    /house(cat(s|)|)/;  # matches either 'housecats' or 'housecat' or
+                        # 'house'.  Note groups can be nested.
+
+    "20" =~ /(19|20|)\d\d/;  # matches the null alternative '()\d\d',
+                             # because '20\d\d' can't match
+
+=head2 Extracting matches
+
+The grouping metacharacters C<()> also allow the extraction of the
+parts of a string that matched.  For each grouping, the part that
+matched inside goes into the special variables C<$1>, C<$2>, etc.
+They can be used just as ordinary variables:
+
+    # extract hours, minutes, seconds
+    $time =~ /(\d\d):(\d\d):(\d\d)/;  # match hh:mm:ss format
+    $hours = $1;
+    $minutes = $2;
+    $seconds = $3;
+
+In list context, a match C</regex/> with groupings will return the
+list of matched values C<($1,$2,...)>.  So we could rewrite it as
+
+    ($hours, $minutes, $second) = ($time =~ /(\d\d):(\d\d):(\d\d)/);
+
+If the groupings in a regex are nested, C<$1> gets the group with the
+leftmost opening parenthesis, C<$2> the next opening parenthesis,
+etc.  For example, here is a complex regex and the matching variables
+indicated below it:
+
+    /(ab(cd|ef)((gi)|j))/;
+     1  2      34
+
+Associated with the matching variables C<$1>, C<$2>, ... are
+the B<backreferences> C<\1>, C<\2>, ...  Backreferences are
+matching variables that can be used I<inside> a regex:
+
+    /(\w\w\w)\s\1/; # find sequences like 'the the' in string
+
+C<$1>, C<$2>, ... should only be used outside of a regex, and C<\1>,
+C<\2>, ... only inside a regex.
+
+=head2 Matching repetitions
+
+The B<quantifier> metacharacters C<?>, C<*>, C<+>, and C<{}> allow us
+to determine the number of repeats of a portion of a regex we
+consider to be a match.  Quantifiers are put immediately after the
+character, character class, or grouping that we want to specify.  They
+have the following meanings:
+
+=over 4
+
+=item *
+
+C<a?> = match 'a' 1 or 0 times
+
+=item *
+
+C<a*> = match 'a' 0 or more times, i.e., any number of times
+
+=item *
+
+C<a+> = match 'a' 1 or more times, i.e., at least once
+
+=item *
+
+C<a{n,m}> = match at least C<n> times, but not more than C<m>
+times.
+
+=item *
+
+C<a{n,}> = match at least C<n> or more times
+
+=item *
+
+C<a{n}> = match exactly C<n> times
+
+=back
+
+Here are some examples:
+
+    /[a-z]+\s+\d*/;  # match a lowercase word, at least some space, and
+                     # any number of digits
+    /(\w+)\s+\1/;    # match doubled words of arbitrary length
+    $year =~ /\d{2,4}/;  # make sure year is at least 2 but not more
+                         # than 4 digits
+    $year =~ /\d{4}|\d{2}/;    # better match; throw out 3 digit dates
+
+These quantifiers will try to match as much of the string as possible,
+while still allowing the regex to match.  So we have
+
+    $x = 'the cat in the hat';
+    $x =~ /^(.*)(at)(.*)$/; # matches,
+                            # $1 = 'the cat in the h'
+                            # $2 = 'at'
+                            # $3 = ''   (0 matches)
+
+The first quantifier C<.*> grabs as much of the string as possible
+while still having the regex match. The second quantifier C<.*> has
+no string left to it, so it matches 0 times.
+
+=head2 More matching
+
+There are a few more things you might want to know about matching
+operators.  In the code
+
+    $pattern = 'Seuss';
+    while (<>) {
+        print if /$pattern/;
+    }
+
+perl has to re-evaluate C<$pattern> each time through the loop.  If
+C<$pattern> won't be changing, use the C<//o> modifier, to only
+perform variable substitutions once.  If you don't want any
+substitutions at all, use the special delimiter C<m''>:
+
+    $pattern = 'Seuss';
+    m'$pattern'; # matches '$pattern', not 'Seuss'
+
+The global modifier C<//g> allows the matching operator to match
+within a string as many times as possible.  In scalar context,
+successive matches against a string will have C<//g> jump from match
+to match, keeping track of position in the string as it goes along.
+You can get or set the position with the C<pos()> function.
+For example,
+
+    $x = "cat dog house"; # 3 words
+    while ($x =~ /(\w+)/g) {
+        print "Word is $1, ends at position ", pos $x, "\n";
+    }
+
+prints
+
+    Word is cat, ends at position 3
+    Word is dog, ends at position 7
+    Word is house, ends at position 13
+
+A failed match or changing the target string resets the position.  If
+you don't want the position reset after failure to match, add the
+C<//c>, as in C</regex/gc>.
+
+In list context, C<//g> returns a list of matched groupings, or if
+there are no groupings, a list of matches to the whole regex.  So
+
+    @words = ($x =~ /(\w+)/g);  # matches,
+                                # $word[0] = 'cat'
+                                # $word[1] = 'dog'
+                                # $word[2] = 'house'
+
+=head2 Search and replace
+
+Search and replace is performed using C<s/regex/replacement/modifiers>.
+The C<replacement> is a Perl double quoted string that replaces in the
+string whatever is matched with the C<regex>.  The operator C<=~> is
+also used here to associate a string with C<s///>.  If matching
+against C<$_>, the S<C<$_ =~> > can be dropped.  If there is a match,
+C<s///> returns the number of substitutions made, otherwise it returns
+false.  Here are a few examples:
+
+    $x = "Time to feed the cat!";
+    $x =~ s/cat/hacker/;   # $x contains "Time to feed the hacker!"
+    $y = "'quoted words'";
+    $y =~ s/^'(.*)'$/$1/;  # strip single quotes,
+                           # $y contains "quoted words"
+
+With the C<s///> operator, the matched variables C<$1>, C<$2>, etc.
+are immediately available for use in the replacement expression. With
+the global modifier, C<s///g> will search and replace all occurrences
+of the regex in the string:
+
+    $x = "I batted 4 for 4";
+    $x =~ s/4/four/;   # $x contains "I batted four for 4"
+    $x = "I batted 4 for 4";
+    $x =~ s/4/four/g;  # $x contains "I batted four for four"
+
+The evaluation modifier C<s///e> wraps an C<eval{...}> around the
+replacement string and the evaluated result is substituted for the
+matched substring.  Some examples:
+
+    # reverse all the words in a string
+    $x = "the cat in the hat";
+    $x =~ s/(\w+)/reverse $1/ge;   # $x contains "eht tac ni eht tah"
+
+    # convert percentage to decimal
+    $x = "A 39% hit rate";
+    $x =~ s!(\d+)%!$1/100!e;       # $x contains "A 0.39 hit rate"
+
+The last example shows that C<s///> can use other delimiters, such as
+C<s!!!> and C<s{}{}>, and even C<s{}//>.  If single quotes are used
+C<s'''>, then the regex and replacement are treated as single quoted
+strings.
+
+=head2 The split operator
+
+C<split /regex/, string> splits C<string> into a list of substrings
+and returns that list.  The regex determines the character sequence
+that C<string> is split with respect to.  For example, to split a
+string into words, use
+
+    $x = "Calvin and Hobbes";
+    @word = split /\s+/, $x;  # $word[0] = 'Calvin'
+                              # $word[1] = 'and'
+                              # $word[2] = 'Hobbes'
+
+To extract a comma-delimited list of numbers, use
+
+    $x = "1.618,2.718,   3.142";
+    @const = split /,\s*/, $x;  # $const[0] = '1.618'
+                                # $const[1] = '2.718'
+                                # $const[2] = '3.142'
+
+If the empty regex C<//> is used, the string is split into individual
+characters.  If the regex has groupings, then list produced contains
+the matched substrings from the groupings as well:
+
+    $x = "/usr/bin";
+    @parts = split m!(/)!, $x;  # $parts[0] = ''
+                                # $parts[1] = '/'
+                                # $parts[2] = 'usr'
+                                # $parts[3] = '/'
+                                # $parts[4] = 'bin'
+
+Since the first character of $x matched the regex, C<split> prepended
+an empty initial element to the list.
+
+=head1 BUGS
+
+None.
+
+=head1 SEE ALSO
+
+This is just a quick start guide.  For a more in-depth tutorial on
+regexes, see L<perlretut> and for the reference page, see L<perlre>.
+
+=head1 AUTHOR AND COPYRIGHT
+
+Copyright (c) 2000 Mark Kvale
+All rights reserved.
+
+This document may be distributed under the same terms as Perl itself.
+
+=head2 Acknowledgments
+
+The author would like to thank Mark-Jason Dominus, Tom Christiansen,
+Ilya Zakharevich, Brad Hughes, and Mike Giroux for all their helpful
+comments.
+
+=cut
+

contrib/perl5/pod/perlutil.pod

@@ -0,0 +1,185 @@
+=head1 NAME
+
+perlutil - utilities packaged with the Perl distribution
+
+=head1 DESCRIPTION
+
+Along with the Perl interpreter itself, the Perl distribution installs a
+range of utilities on your system. There are also several utilities
+which are used by the Perl distribution itself as part of the install
+process. This document exists to list all of these utilities, explain
+what they are for and provide pointers to each module's documentation,
+if appropriate.
+
+=head2 DOCUMENTATION
+
+=over 3
+
+=item L<perldoc|perldoc>
+
+The main interface to Perl's documentation is C<perldoc>, although
+if you're reading this, it's more than likely that you've already found
+it. F<perldoc> will extract and format the documentation from any file
+in the current directory, any Perl module installed on the system, or
+any of the standard documentation pages, such as this one. Use 
+C<perldoc E<lt>nameE<gt>> to get information on any of the utilities
+described in this document.
+
+=item L<pod2man|pod2man> and L<pod2text|pod2text>
+
+If it's run from a terminal, F<perldoc> will usually call F<pod2man> to
+translate POD (Plain Old Documentation - see L<perlpod> for an
+explanation) into a man page, and then run F<man> to display it; if
+F<man> isn't available, F<pod2text> will be used instead and the output
+piped through your favourite pager.
+
+=item L<pod2html|pod2html> and L<pod2latex|pod2latex>
+
+As well as these two, there are two other converters: F<pod2html> will
+produce HTML pages from POD, and F<pod2latex>, which produces LaTeX
+files.
+
+=item L<pod2usage|pod2usage>
+
+If you just want to know how to use the utilities described here,
+F<pod2usage> will just extract the "USAGE" section; some of
+the utilities will automatically call F<pod2usage> on themselves when
+you call them with C<-help>.
+
+=item L<podselect|podselect>
+
+F<pod2usage> is a special case of F<podselect>, a utility to extract
+named sections from documents written in POD. For instance, while
+utilities have "USAGE" sections, Perl modules usually have "SYNOPSIS"
+sections: C<podselect -s "SYNOPSIS" ...> will extract this section for
+a given file.
+
+=item L<podchecker|podchecker>
+
+If you're writing your own documentation in POD, the F<podchecker>
+utility will look for errors in your markup.
+
+=item L<splain|splain>
+
+F<splain> is an interface to L<perldiag> - paste in your error message
+to it, and it'll explain it for you.
+
+=item L<roffitall|roffitall>
+
+The C<roffitall> utility is not installed on your system but lives in
+the F<pod/> directory of your Perl source kit; it converts all the
+documentation from the distribution to F<*roff> format, and produces a
+typeset PostScript or text file of the whole lot.
+
+=back
+
+=head2 CONVERTORS
+
+To help you convert legacy programs to Perl, we've included three
+conversion filters:
+
+=over 3
+
+=item L<a2p|a2p>
+
+F<a2p> converts F<awk> scripts to Perl programs; for example, C<a2p -F:>
+on the simple F<awk> script C<{print $2}> will produce a Perl program
+based around this code:
+
+    while (<>) {
+        ($Fld1,$Fld2) = split(/[:\n]/, $_, 9999);
+        print $Fld2;
+    }
+
+=item L<s2p|s2p>
+
+Similarly, F<s2p> converts F<sed> scripts to Perl programs. F<s2p> run
+on C<s/foo/bar> will produce a Perl program based around this:
+
+    while (<>) {
+        chomp;
+        s/foo/bar/g;
+        print if $printit;
+    }
+
+=item L<find2perl|find2perl>
+
+Finally, F<find2perl> translates C<find> commands to Perl equivalents which 
+use the L<File::Find|File::Find> module. As an example, 
+C<find2perl . -user root -perm 4000 -print> produces the following callback
+subroutine for C<File::Find>:
+
+    sub wanted {
+        my ($dev,$ino,$mode,$nlink,$uid,$gid);
+        (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_)) &&
+        $uid == $uid{'root'}) &&
+        (($mode & 0777) == 04000);
+        print("$name\n");
+    }
+
+=back
+
+As well as these filters for converting other languages, the
+L<pl2pm|pl2pm> utility will help you convert old-style Perl 4 libraries to 
+new-style Perl5 modules.
+
+=head2 Development
+
+There are a set of utilities which help you in developing Perl programs, 
+and in particular, extending Perl with C.
+
+=over 3
+
+=item L<perlbug|perlbug>
+
+F<perlbug> is the recommended way to report bugs in the perl interpreter
+itself or any of the standard library modules back to the developers;
+please read through the documentation for F<perlbug> thoroughly before
+using it to submit a bug report.
+
+=item L<h2ph|h2ph>
+
+Back before Perl had the XS system for connecting with C libraries,
+programmers used to get library constants by reading through the C
+header files. You may still see C<require 'syscall.ph'> or similar
+around - the F<.ph> file should be created by running F<h2ph> on the
+corresponding F<.h> file. See the F<h2ph> documentation for more on how
+to convert a whole bunch of header files at ones.
+
+=item L<c2ph|c2ph> and L<pstruct|pstruct>
+
+F<c2ph> and F<pstruct>, which are actually the same program but behave
+differently depending on how they are called, provide another way of
+getting at C with Perl - they'll convert C structures and union declarations
+to Perl code. This is deprecated in favour of F<h2xs> these days.
+
+=item L<h2xs|h2xs>
+
+F<h2xs> converts C header files into XS modules, and will try and write
+as much glue between C libraries and Perl modules as it can. It's also
+very useful for creating skeletons of pure Perl modules.
+
+=item L<dprofpp|dprofpp>
+
+Perl comes with a profiler, the F<Devel::Dprof> module. The
+F<dprofpp> utility analyzes the output of this profiler and tells you
+which subroutines are taking up the most run time. See L<Devel::Dprof>
+for more information.
+
+=item L<perlcc|perlcc>
+
+F<perlcc> is the interface to the experimental Perl compiler suite.
+
+=back
+
+=head2 SEE ALSO
+
+L<perldoc|perldoc>, L<pod2man|pod2man>, L<perlpod>,
+L<pod2html|pod2html>, L<pod2usage|pod2usage>, L<podselect|podselect>,
+L<podchecker|podchecker>, L<splain|splain>, L<perldiag>,
+L<roffitall|roffitall>, L<a2p|a2p>, L<s2p|s2p>, L<find2perl|find2perl>,
+L<File::Find|File::Find>, L<pl2pm|pl2pm>, L<perlbug|perlbug>,
+L<h2ph|h2ph>, L<c2ph|c2ph>, L<h2xs|h2xs>, L<dprofpp|dprofpp>,
+L<Devel::Dprof>, L<perlcc|perlcc>
+
+=cut

contrib/perl5/t/lib/b.t

@@ -0,0 +1,163 @@
+#!./perl
+
+BEGIN {
+    chdir 't' if -d 't';
+    if ($^O eq 'MacOS') { 
+	@INC = qw(: ::lib ::macos:lib); 
+    } else { 
+	@INC = '.'; 
+	push @INC, '../lib'; 
+    }
+}
+
+$|  = 1;
+use warnings;
+use strict;
+use Config;
+
+print "1..15\n";
+
+my $test = 1;
+
+sub ok { print "ok $test\n"; $test++ }
+
+use B::Deparse;
+my $deparse = B::Deparse->new() or print "not ";
+ok;
+
+print "not " if "{\n    1;\n}" ne $deparse->coderef2text(sub {1});
+ok;
+
+print "not " if "{\n    '???';\n    2;\n}" ne
+                    $deparse->coderef2text(sub {1;2});
+ok;
+
+print "not " if "{\n    \$test /= 2 if ++\$test;\n}" ne
+                    $deparse->coderef2text(sub {++$test and $test/=2;});
+ok;
+{
+my $a = <<'EOF';
+{
+    $test = sub : lvalue {
+        my $x;
+    }
+    ;
+}
+EOF
+chomp $a;
+print "not " if $deparse->coderef2text(sub{$test = sub : lvalue{my $x}}) ne $a;
+ok;
+
+$a =~ s/lvalue/method/;
+print "not " if $deparse->coderef2text(sub{$test = sub : method{my $x}}) ne $a;
+ok;
+
+$a =~ s/method/locked method/;
+print "not " if $deparse->coderef2text(sub{$test = sub : method locked {my $x}})
+                                     ne $a;
+ok;
+}
+
+my $a;
+my $Is_VMS = $^O eq 'VMS';
+my $Is_MacOS = $^O eq 'MacOS';
+
+my $path = join " ", map { qq["-I$_"] } @INC;
+my $redir = $Is_MacOS ? "" : "2>&1";
+
+$a = `$^X $path "-MO=Deparse" -anle 1 $redir`;
+$a =~ s/-e syntax OK\n//g;
+$a =~ s{\\340\\242}{\\s} if (ord("\\") == 224); # EBCDIC, cp 1047 or 037
+$a =~ s{\\274\\242}{\\s} if (ord("\\") == 188); # $^O eq 'posix-bc'
+$b = <<'EOF';
+
+LINE: while (defined($_ = <ARGV>)) {
+    chomp $_;
+    @F = split(/\s+/, $_, 0);
+    '???';
+}
+
+EOF
+print "# [$a]\n\# vs\n# [$b]\nnot " if $a ne $b;
+ok;
+
+#6
+$a = `$^X $path "-MO=Debug" -e 1 $redir`;
+print "not " unless $a =~
+/\bLISTOP\b.*\bOP\b.*\bCOP\b.*\bOP\b/s;
+ok;
+
+#7
+$a = `$^X $path "-MO=Terse" -e 1 $redir`;
+print "not " unless $a =~
+/\bLISTOP\b.*leave.*\n    OP\b.*enter.*\n    COP\b.*nextstate.*\n    OP\b.*null/s;
+ok;
+
+$a = `$^X $path "-MO=Terse" -ane "s/foo/bar/" $redir`;
+$a =~ s/\(0x[^)]+\)//g;
+$a =~ s/\[[^\]]+\]//g;
+$a =~ s/-e syntax OK//;
+$a =~ s/[^a-z ]+//g;
+$a =~ s/\s+/ /g;
+$a =~ s/\b(s|foo|bar|ullsv)\b\s?//g;
+$a =~ s/^\s+//;
+$a =~ s/\s+$//;
+my $is_thread = $Config{use5005threads} && $Config{use5005threads} eq 'define';
+if ($is_thread) {
+    $b=<<EOF;
+leave enter nextstate label leaveloop enterloop null and defined null
+threadsv readline gv lineseq nextstate aassign null pushmark split pushre
+threadsv const null pushmark rvav gv nextstate subst const unstack nextstate
+EOF
+} else {
+    $b=<<EOF;
+leave enter nextstate label leaveloop enterloop null and defined null
+null gvsv readline gv lineseq nextstate aassign null pushmark split pushre
+null gvsv const null pushmark rvav gv nextstate subst const unstack nextstate
+EOF
+}
+$b=~s/\n/ /g;$b=~s/\s+/ /g;
+$b =~ s/\s+$//;
+print "# [$a]\n# vs\n# [$b]\nnot " if $a ne $b;
+ok;
+
+chomp($a = `$^X $path "-MB::Stash" "-Mwarnings" -e1`);
+$a = join ',', sort split /,/, $a;
+$a =~ s/-uWin32,// if $^O eq 'MSWin32';
+$a =~ s/-u(Cwd|File|File::Copy|OS2),//g if $^O eq 'os2';
+$a =~ s/-uCwd,// if $^O eq 'cygwin';
+if ($Config{static_ext} eq ' ') {
+  $b = '-uCarp,-uCarp::Heavy,-uDB,-uExporter,-uExporter::Heavy,-uattributes,'
+     . '-umain,-uwarnings';
+  if (ord('A') == 193) { # EBCDIC sort order is qw(a A) not qw(A a)
+      $b = join ',', sort split /,/, $b;
+  }
+  print "# [$a] vs [$b]\nnot " if $a ne $b;
+  ok;
+} else {
+  print "ok $test # skipped: one or more static extensions\n"; $test++;
+}
+
+if ($is_thread) {
+    print "# use5005threads: test $test skipped\n";
+} else {
+    $a = `$^X $path "-MO=Showlex" -e "my %one" $redir`;
+    if (ord('A') != 193) { # ASCIIish
+        print "# [$a]\nnot " unless $a =~ /sv_undef.*PVNV.*%one.*sv_undef.*HV/s;
+    } 
+    else { # EBCDICish C<1: PVNV (0x1a7ede34) "%\226\225\205">
+        print "# [$a]\nnot " unless $a =~ /sv_undef.*PVNV.*%\\[0-9].*sv_undef.*HV/s;
+    }
+}
+ok;
+
+# Bug 20001204.07
+{
+my $foo = $deparse->coderef2text(sub { { 234; }});
+# Constants don't get optimised here.
+print "not " unless $foo =~ /{.*{.*234;.*}.*}/sm;
+ok;
+$foo = $deparse->coderef2text(sub { { 234; } continue { 123; } });
+print "not " unless $foo =~ /{.*{.*234;.*}.*continue.*{.*123.*}/sm; 
+ok;
+}

contrib/perl5/t/lib/cgi-esc.t

@@ -0,0 +1,56 @@
+#!/usr/local/bin/perl -w
+
+BEGIN {
+    chdir('t') if -d 't';
+    @INC = '../lib';
+}
+
+# Test ability to escape() and unescape() punctuation characters
+# except for qw(- . _).
+######################### We start with some black magic to print on failure.
+use lib '../blib/lib','../blib/arch';
+
+BEGIN {$| = 1; print "1..59\n"; }
+END {print "not ok 1\n" unless $loaded;}
+use Config;
+use CGI::Util qw(escape unescape);
+$loaded = 1;
+print "ok 1\n";
+
+######################### End of black magic.
+
+# util
+sub test {
+    local($^W) = 0;
+    my($num, $true,$msg) = @_;
+    print($true ? "ok $num\n" : "not ok $num $msg\n");
+}
+
+# ASCII order, ASCII codepoints, ASCII repertoire
+
+my %punct = (
+    ' ' => '20',  '!' => '21',  '"' => '22',  '#' =>  '23', 
+    '$' => '24',  '%' => '25',  '&' => '26',  '\'' => '27', 
+    '(' => '28',  ')' => '29',  '*' => '2A',  '+' =>  '2B', 
+    ',' => '2C',                              '/' =>  '2F',  # '-' => '2D',  '.' => '2E' 
+    ':' => '3A',  ';' => '3B',  '<' => '3C',  '=' =>  '3D', 
+    '>' => '3E',  '?' => '3F',  '[' => '5B',  '\\' => '5C', 
+    ']' => '5D',  '^' => '5E',                '`' =>  '60',  # '_' => '5F',
+    '{' => '7B',  '|' => '7C',  '}' => '7D',  '~' =>  '7E', 
+         );
+
+# The sort order may not be ASCII on EBCDIC machines:
+
+my $i = 1;
+
+foreach(sort(keys(%punct))) { 
+    $i++;
+    my $escape = "AbC\%$punct{$_}dEF";
+    my $cgi_escape = escape("AbC$_" . "dEF");
+    test($i, $escape eq $cgi_escape , "# $escape ne $cgi_escape");
+    $i++;
+    my $unescape = "AbC$_" . "dEF";
+    my $cgi_unescape = unescape("AbC\%$punct{$_}dEF");
+    test($i, $unescape eq $cgi_unescape , "# $unescape ne $cgi_unescape");
+}
+

contrib/perl5/t/lib/cgi-pretty.t

@@ -0,0 +1,41 @@
+#!/usr/local/bin/perl -w
+
+BEGIN {
+    chdir('t') if -d 't';
+    @INC = '../lib';
+}
+
+# Test ability to retrieve HTTP request info
+######################### We start with some black magic to print on failure.
+use lib '../blib/lib','../blib/arch';
+
+BEGIN {$| = 1; print "1..5\n"; }
+END {print "not ok 1\n" unless $loaded;}
+use CGI::Pretty (':standard','-no_debug','*h3','start_table');
+$loaded = 1;
+print "ok 1\n";
+
+######################### End of black magic.
+
+# util
+sub test {
+    local($^W) = 0;
+    my($num, $true,$msg) = @_;
+    print($true ? "ok $num\n" : "not ok $num $msg\n");
+}
+
+# all the automatic tags
+test(2,h1() eq '<h1>',"single tag");
+test(3,ol(li('fred'),li('ethel')) eq "<ol>\n\t<li>\n\t\tfred\n\t</li>\n\t <li>\n\t\tethel\n\t</li>\n</ol>\n","basic indentation");
+test(4,p('hi',pre('there'),'frog') eq 
+'<p>
+	hi <pre>there</pre>
+	 frog
+</p>
+',"<pre> tags");
+test(5,p('hi',a({-href=>'frog'},'there'),'frog') eq 
+'<p>
+	hi <a href="frog">there</a>
+	 frog
+</p>
+',"as-is");

contrib/perl5/t/lib/class-struct.t

@@ -0,0 +1,66 @@
+#!./perl -w
+
+BEGIN {
+	chdir 't' if -d 't';
+	@INC = '../lib';
+}
+
+print "1..8\n";
+
+package aClass;
+
+sub new { bless {}, shift }
+
+sub meth { 42 }
+
+package MyObj;
+
+use Class::Struct;
+use Class::Struct 'struct'; # test out both forms
+
+use Class::Struct SomeClass => { SomeElem => '$' };
+
+struct( s => '$', a => '@', h => '%', c => 'aClass' );
+
+my $obj = MyObj->new;
+
+$obj->s('foo');
+
+print "not " unless $obj->s() eq 'foo';
+print "ok 1\n";
+
+my $arf = $obj->a;
+
+print "not " unless ref $arf eq 'ARRAY';
+print "ok 2\n";
+
+$obj->a(2, 'secundus');
+
+print "not " unless $obj->a(2) eq 'secundus';
+print "ok 3\n";
+
+my $hrf = $obj->h;
+
+print "not " unless ref $hrf eq 'HASH';
+print "ok 4\n";
+
+$obj->h('x', 10);
+
+print "not " unless $obj->h('x') == 10;
+print "ok 5\n";
+
+my $orf = $obj->c;
+
+print "not " unless ref $orf eq 'aClass';
+print "ok 6\n";
+
+print "not " unless $obj->c->meth() == 42;
+print "ok 7\n";
+
+my $obk = SomeClass->new();
+
+$obk->SomeElem(123);
+
+print "not " unless $obk->SomeElem() == 123;
+print "ok 8\n";
+

contrib/perl5/t/lib/ftmp-mktemp.t

@@ -0,0 +1,114 @@
+#!/usr/bin/perl -w
+
+# Test for mktemp family of commands in File::Temp
+# Use STANDARD safe level for these tests
+
+BEGIN {
+	chdir 't' if -d 't';
+	@INC = '../lib';
+	require Test; import Test;
+	plan(tests => 9);
+}
+
+use strict;
+
+use File::Spec;
+use File::Path;
+use File::Temp qw/ :mktemp unlink0 /;
+
+ok(1);
+
+# MKSTEMP - test
+
+# Create file in temp directory
+my $template = File::Spec->catfile(File::Spec->tmpdir, 'wowserXXXX');
+
+(my $fh, $template) = mkstemp($template);
+
+print "# MKSTEMP: FH is $fh File is $template fileno=".fileno($fh)."\n";
+# Check if the file exists
+ok( (-e $template) );
+
+# Autoflush
+$fh->autoflush(1) if $] >= 5.006;
+
+# Try printing something to the file
+my $string = "woohoo\n";
+print $fh $string;
+
+# rewind the file
+ok(seek( $fh, 0, 0));
+
+# Read from the file
+my $line = <$fh>;
+
+# compare with previous string
+ok($string, $line);
+
+# Tidy up
+# This test fails on Windows NT since it seems that the size returned by 
+# stat(filehandle) does not always equal the size of the stat(filename)
+# This must be due to caching. In particular this test writes 7 bytes
+# to the file which are not recognised by stat(filename)
+# Simply waiting 3 seconds seems to be enough for the system to update
+
+if ($^O eq 'MSWin32') {
+  sleep 3;
+}
+my $status = unlink0($fh, $template);
+if ($status) {
+  ok( $status );
+} else {
+  skip("Skip test failed probably due to \$TMPDIR being on NFS",1);
+}
+
+# MKSTEMPS
+# File with suffix. This is created in the current directory so
+# may be problematic on NFS
+
+$template = "suffixXXXXXX";
+my $suffix = ".dat";
+
+($fh, my $fname) = mkstemps($template, $suffix);
+
+print "# MKSTEMPS: File is $template -> $fname fileno=".fileno($fh)."\n";
+# Check if the file exists
+ok( (-e $fname) );
+
+# This fails if you are running on NFS
+# If this test fails simply skip it rather than doing a hard failure
+$status = unlink0($fh, $fname);
+
+if ($status) {
+  ok($status);
+} else {
+  skip("Skip test failed probably due to cwd being on NFS",1)
+}
+
+# MKDTEMP
+# Temp directory
+
+$template = File::Spec->catdir(File::Spec->tmpdir, 'tmpdirXXXXXX');
+
+my $tmpdir = mkdtemp($template);
+
+print "# MKDTEMP: Name is $tmpdir from template $template\n";
+
+ok( (-d $tmpdir ) );
+
+# Need to tidy up after myself
+rmtree($tmpdir);
+
+# MKTEMP
+# Just a filename, not opened
+
+$template = File::Spec->catfile(File::Spec->tmpdir, 'mytestXXXXXX');
+
+my $tmpfile = mktemp($template);
+
+print "# MKTEMP: Tempfile is $template -> $tmpfile\n";
+
+# Okay if template no longer has XXXXX in
+
+
+ok( ($tmpfile !~ /XXXXX$/) );

contrib/perl5/t/lib/ftmp-posix.t

@@ -0,0 +1,81 @@
+#!/usr/bin/perl -w
+# Test for File::Temp - POSIX functions
+
+BEGIN {
+	chdir 't' if -d 't';
+	@INC = '../lib';
+	require Test; import Test;
+	plan(tests => 7);
+}
+
+use strict;
+
+use File::Temp qw/ :POSIX unlink0 /;
+ok(1);
+
+# TMPNAM - scalar
+
+print "# TMPNAM: in a scalar context: \n";
+my $tmpnam = tmpnam();
+
+# simply check that the file does not exist
+# Not a 100% water tight test though if another program 
+# has managed to create one in the meantime.
+ok( !(-e $tmpnam ));
+
+print "# TMPNAM file name: $tmpnam\n";
+
+# TMPNAM list context
+# Not strict posix behaviour
+(my $fh, $tmpnam) = tmpnam();
+
+print "# TMPNAM: in list context: $fh $tmpnam\n";
+
+# File is opened - make sure it exists
+ok( (-e $tmpnam ));
+
+# Unlink it - a possible NFS issue again if TMPDIR is not a local disk
+my $status = unlink0($fh, $tmpnam);
+if ($status) {
+  ok( $status );
+} else {
+  skip("Skip test failed probably due to \$TMPDIR being on NFS",1);
+}
+
+# TMPFILE
+
+$fh = tmpfile();
+
+if (defined $fh) {
+  ok( $fh );
+  print "# TMPFILE: tmpfile got FH $fh\n";
+
+  $fh->autoflush(1) if $] >= 5.006;
+
+  # print something to it
+  my $original = "Hello a test\n";
+  print "# TMPFILE: Wrote line: $original";
+  print $fh $original
+    or die "Error printing to tempfile\n";
+
+  # rewind it
+  ok( seek($fh,0,0) );
+
+  # Read from it
+  my $line = <$fh>;
+
+  print "# TMPFILE: Read line: $line";
+  ok( $original, $line);
+
+  close($fh);
+
+} else {
+  # Skip all the remaining tests
+  foreach (1..3) {
+    skip("Skip test failed probably due to \$TMPDIR being on NFS",1);
+  }
+}
+
+
+
+

contrib/perl5/t/lib/ftmp-security.t

@@ -0,0 +1,140 @@
+#!/usr/bin/perl -w
+# Test for File::Temp - Security levels
+
+# Some of the security checking will not work on all platforms
+# Test a simple open in the cwd and tmpdir foreach of the
+# security levels
+
+BEGIN {
+	chdir 't' if -d 't';
+	@INC = '../lib';
+	require Test; import Test;
+	plan(tests => 13);
+}
+
+use strict;
+use File::Spec;
+
+# Set up END block - this needs to happen before we load
+# File::Temp since this END block must be evaluated after the
+# END block configured by File::Temp
+my @files; # list of files to remove
+END { foreach (@files) { ok( !(-e $_) )} }
+
+use File::Temp qw/ tempfile unlink0 /;
+ok(1);
+
+# The high security tests must currently be skipped on some platforms
+my $skipplat = ( (
+		  # No sticky bits.
+		  $^O eq 'MSWin32' || $^O eq 'os2' || $^O eq 'dos'
+		  ) ? 1 : 0 );
+
+# Can not run high security tests in perls before 5.6.0
+my $skipperl  = ($] < 5.006 ? 1 : 0 );
+
+# Determine whether we need to skip things and why
+my $skip = 0;
+if ($skipplat) {
+  $skip = "Skip Not supported on this platform";
+} elsif ($skipperl) {
+  $skip = "Skip Perl version must be v5.6.0 for these tests";
+
+}
+
+print "# We will be skipping some tests : $skip\n" if $skip;
+
+# start off with basic checking
+
+File::Temp->safe_level( File::Temp::STANDARD );
+
+print "# Testing with STANDARD security...\n";
+
+&test_security(0);
+
+# Try medium
+
+File::Temp->safe_level( File::Temp::MEDIUM )
+  unless $skip;
+
+print "# Testing with MEDIUM security...\n";
+
+# Now we need to start skipping tests
+&test_security($skip);
+
+# Try HIGH
+
+File::Temp->safe_level( File::Temp::HIGH )
+  unless $skip;
+
+print "# Testing with HIGH security...\n";
+
+&test_security($skip);
+
+exit;
+
+# Subroutine to open two temporary files.
+# one is opened in the current dir and the other in the temp dir
+
+sub test_security {
+
+  # Read in the skip flag
+  my $skip = shift;
+
+  # If we are skipping we need to simply fake the correct number
+  # of tests -- we dont use skip since the tempfile() commands will
+  # fail with MEDIUM/HIGH security before the skip() command would be run
+  if ($skip) {
+
+    skip($skip,1);
+    skip($skip,1);
+
+    # plus we need an end block so the tests come out in the right order
+    eval q{ END { skip($skip,1); skip($skip,1)  } 1; } || die;
+
+    return;
+  }
+
+  # Create the tempfile
+  my $template = "tmpXXXXX";
+  my ($fh1, $fname1) = eval { tempfile ( $template, 
+				  DIR => File::Spec->tmpdir,
+				  UNLINK => 1,
+				);
+			    };
+
+  if (defined $fname1) {
+      print "# fname1 = $fname1\n";
+      ok( (-e $fname1) );
+      push(@files, $fname1); # store for end block
+  } elsif (File::Temp->safe_level() != File::Temp::STANDARD) {
+      my $skip2 = "Skip system possibly insecure, see INSTALL, section 'make test'";
+      skip($skip2, 1);
+      # plus we need an end block so the tests come out in the right order
+      eval q{ END { skip($skip2,1); } 1; } || die;
+  } else {
+      ok(0);
+  }
+
+  # Explicitly 
+  if ( $< < File::Temp->top_system_uid() ){
+      skip("Skip Test inappropriate for root", 1);
+      eval q{ END { skip($skip,1); } 1; } || die;
+      return;
+  }
+  my ($fh2, $fname2) = eval { tempfile ($template,  UNLINK => 1 ); };
+  if (defined $fname2) {
+      print "# fname2 = $fname2\n";
+      ok( (-e $fname2) );
+      push(@files, $fname2); # store for end block
+      close($fh2);
+  } elsif (File::Temp->safe_level() != File::Temp::STANDARD) {
+      my $skip2 = "Skip system possibly insecure, see INSTALL, section 'make test'";
+      skip($skip2, 1);
+      # plus we need an end block so the tests come out in the right order
+      eval q{ END { skip($skip2,1); } 1; } || die;
+  } else {
+      ok(0);
+  }
+
+}

contrib/perl5/t/lib/ftmp-tempfile.t

@@ -0,0 +1,145 @@
+#!/usr/local/bin/perl -w
+# Test for File::Temp - tempfile function
+
+BEGIN {
+	chdir 't' if -d 't';
+	@INC = '../lib';
+	require Test; import Test;
+	plan(tests => 20);
+}
+
+use strict;
+use File::Spec;
+
+# Will need to check that all files were unlinked correctly
+# Set up an END block here to do it
+
+# Arrays containing list of dirs/files to test
+my (@files, @dirs, @still_there);
+
+# And a test for files that should still be around
+# These are tidied up
+END {
+  foreach (@still_there) {
+    ok( -f $_ );
+    ok( unlink( $_ ) );
+    ok( !(-f $_) );
+  }
+}
+
+# Loop over an array hoping that the files dont exist
+END { foreach (@files) { ok( !(-e $_) )} }
+
+# And a test for directories
+END { foreach (@dirs)  { ok( !(-d $_) )} }
+
+# Need to make sure that the END blocks are setup before
+# the ones that File::Temp configures since END blocks are evaluated
+# in revers order and we need to check the files *after* File::Temp
+# removes them
+use File::Temp qw/ tempfile tempdir/;
+
+# Now we start the tests properly
+ok(1);
+
+
+# Tempfile
+# Open tempfile in some directory, unlink at end
+my ($fh, $tempfile) = tempfile(
+			       UNLINK => 1,
+			       SUFFIX => '.txt',
+			      );
+
+ok( (-f $tempfile) );
+# Should still be around after closing
+ok( close( $fh ) ); 
+ok( (-f $tempfile) );
+# Check again at exit
+push(@files, $tempfile);
+
+# TEMPDIR test
+# Create temp directory in current dir
+my $template = 'tmpdirXXXXXX';
+print "# Template: $template\n";
+my $tempdir = tempdir( $template ,
+		       DIR => File::Spec->curdir,
+		       CLEANUP => 1,
+		     );
+
+print "# TEMPDIR: $tempdir\n";
+
+ok( (-d $tempdir) );
+push(@dirs, $tempdir);
+
+# Create file in the temp dir
+($fh, $tempfile) = tempfile(
+			    DIR => $tempdir,
+			    UNLINK => 1,
+			    SUFFIX => '.dat',
+			   );
+
+print "# TEMPFILE: Created $tempfile\n";
+
+ok( (-f $tempfile));
+push(@files, $tempfile);
+
+# Test tempfile
+# ..and again
+($fh, $tempfile) = tempfile(
+			    DIR => $tempdir,
+			   );
+
+
+ok( (-f $tempfile ));
+push(@files, $tempfile);
+
+print "# TEMPFILE: Created $tempfile\n";
+
+# and another (with template)
+
+($fh, $tempfile) = tempfile( 'helloXXXXXXX',
+			    DIR => $tempdir,
+			    UNLINK => 1,
+			    SUFFIX => '.dat',
+			   );
+
+print "# TEMPFILE: Created $tempfile\n";
+
+ok( (-f $tempfile) );
+push(@files, $tempfile);
+
+
+# Create a temporary file that should stay around after
+# it has been closed
+($fh, $tempfile) = tempfile( 'permXXXXXXX', UNLINK => 0 );
+print "# TEMPFILE: Created $tempfile\n";
+ok( -f $tempfile );
+ok( close( $fh ) );
+push( @still_there, $tempfile); # check at END
+
+# Would like to create a temp file and just retrieve the handle
+# but the test is problematic since:
+#  - We dont know the filename so we cant check that it is tidied
+#    correctly
+#  - The unlink0 required on unix for tempfile creation will fail
+#    on NFS
+# Try to do what we can.
+# Tempfile croaks on error so we need an eval
+$fh = eval { tempfile( 'ftmpXXXXX', DIR => File::Spec->tmpdir ) };
+
+if ($fh) {
+
+  # print something to it to make sure something is there
+  ok( print $fh "Test\n" );
+
+  # Close it - can not check it is gone since we dont know the name
+  ok( close($fh) );
+
+} else {
+  skip "Skip Failed probably due to NFS", 1;
+  skip "Skip Failed probably due to NFS", 1;
+}
+
+# Now END block will execute to test the removal of directories
+print "# End of tests. Execute END blocks\n";
+