New port:

Perl with Japanese language support, AKA jperl.
Submitted by:	sanpei@yy.cs.keio.ac.jp
(Closing PR #2456.)

4 files changed, 1196 insertions, 0 deletions

diff --git a/japanese/perl5/files/patch-aa b/japanese/perl5/files/patch-aa
new file mode 100644
index 000000000000..e17501b21092
--- /dev/null
+++ b/japanese/perl5/files/patch-aa
@@ -0,0 +1,29 @@
+--- Configure.orig	Sat Jan 11 15:16:14 1997
++++ Configure	Sat Jan 11 15:22:42 1997
+@@ -85,11 +85,12 @@
+ PATH=.$p_$PATH
+ export PATH
+ 
+-: Sanity checks
+-if test ! -t 0; then
+-	echo "Say 'sh $me', not 'sh <$me'"
+-	exit 1
+-fi
++#: Sanity checks (Disabled for FreeBSD build - users coming here [ws]ould
++#                 know what they are doing anyway) ;-) MarkM
++#if test ! -t 0; then
++#	echo "Say 'sh $me', not 'sh <$me'"
++#	exit 1
++#fi
+ 
+ : On HP-UX, large Configure scripts may exercise a bug in /bin/sh
+ if test -f /hp-ux -a -f /bin/ksh; then
+@@ -709,7 +710,7 @@
+ : List of libraries we want.
+ libswanted='net socket inet nsl nm ndbm gdbm dbm db malloc dl'
+ libswanted="$libswanted dld ld sun m c cposix posix ndir dir crypt"
+-libswanted="$libswanted ucb bsd BSD PW x"
++libswanted="$libswanted ucb bsd BSD PW x xpg4"
+ : We probably want to search /usr/shlib before most other libraries.
+ : This is only used by the lib/ExtUtils/MakeMaker.pm routine extliblist.
+ glibpth=`echo " $glibpth " | sed -e 's! /usr/shlib ! !'`
diff --git a/japanese/perl5/files/patch-ac b/japanese/perl5/files/patch-ac
new file mode 100644
index 000000000000..451a47418899
--- /dev/null
+++ b/japanese/perl5/files/patch-ac
@@ -0,0 +1,1077 @@
+--- ./pod/perltrap.pod.orig	Tue Jan 30 20:23:50 1996
++++ ./pod/perltrap.pod	Sun Jul 14 17:33:46 1996
+@@ -172,7 +172,7 @@
+ 
+ =item *
+ 
+-printf() does not implement the "*" format for interpolating
++C<printf()> does not implement the "*" format for interpolating
+ field widths, but it's trivial to use interpolation of double-quoted
+ strings to achieve the same effect.
+ 
+@@ -318,7 +318,7 @@
+ 
+ =item *
+ 
+-Use my() for local variables whenever you can get away with 
++Use C<my()> for local variables whenever you can get away with 
+ it (but see L<perlform> for where you can't).  
+ Using local() actually gives a local value to a global 
+ variable, which leaves you open to unforeseen side-effects
+@@ -332,75 +332,540 @@
+ 
+ =back
+ 
+-=head2 Perl4 Traps
+ 
+-Penitent Perl 4 Programmers should take note of the following
+-incompatible changes that occurred between release 4 and release 5:
++=head2 Perl4 to Perl5  Traps
++
++Practicing Perl4 Programmers should take note of the following 
++Perl4-to-Perl5 specific traps.
++
++They're crudely ordered according to the following list:
+ 
+ =over 4
+ 
+-=item *
++=item Discontinuance, Depracation, and BugFix traps
+ 
+-C<@> now always interpolates an array in double-quotish strings.  Some programs
+-may now need to use backslash to protect any C<@> that shouldn't interpolate.
++=item Parsing Traps
+ 
+-=item *
++=item Numerical Traps
+ 
+-Barewords that used to look like strings to Perl will now look like subroutine
+-calls if a subroutine by that name is defined before the compiler sees them.
+-For example:
++=item General data type traps
+ 
+-    sub SeeYa { die "Hasta la vista, baby!" }
+-    $SIG{'QUIT'} = SeeYa;
++=item Context Traps - scalar, list contexts
+ 
+-In Perl 4, that set the signal handler; in Perl 5, it actually calls the
+-function!  You may use the B<-w> switch to find such places.
++=item Precedence Traps
+ 
+-=item *
++=item General Regular Expression Traps using s///, etc.
+ 
+-Symbols starting with C<_> are no longer forced into package C<main>, except
+-for $_ itself (and @_, etc.).
++=item Subroutine, Signal, Sorting Traps
+ 
+-=item *
++=item OS Traps
++
++=item Unclassified Traps
++
++=back
++
++If you find an example of a conversion trap that is not listed here,
++please submit it to Bill Middleton F<wjm@best.com> for inclusion.
++Also note that at least some of these can be caught with C<-w>.
++
++=head2 Discontinuance, Depracation, and BugFix traps
++
++Anything that has been discontinued, depracated, or fixed as
++a bug from perl4.  
++
++=over 4
++
++=item * Discontinuance 
++
++Symbols starting with "_" are no longer forced into package main, except
++for C<$_> itself (and C<@_>, etc.).
++
++    package test;
++    $_legacy = 1;
++
++    package main;
++    print "\$_legacy is ",$_legacy,"\n";
++ 
++    # perl4 prints: $_legacy is 1
++    # perl5 prints: $_legacy is
++
++=item * Depracation 
+ 
+ Double-colon is now a valid package separator in an identifier.  Thus these
+-behave differently in perl4 vs. perl5:
++behave differently in perl4 vs. perl5, since the packages dont exist.
+ 
+-    print "$a::$b::$c\n";
++    $a=1;$b=2;$c=3;$var=4;
++    print "$a::$b::$c ";
+     print "$var::abc::xyz\n";
++ 
++    # perl4 prints: 1::2::3 4::abc::xyz
++    # perl5 prints: 3
+ 
+-=item *
++Given that C<::> is now the preferred package delimiter, it is debatable
++whether this should be classed as a bug or not.
++(The older package delimiter, ' ,is used here)
+ 
+-C<s'$lhs'$rhs'> now does no interpolation on either side.  It used to
+-interpolate C<$lhs> but not C<$rhs>.
++    $x = 10 ;
++    print "x=${'x}\n" ;
++ 
++    # perl4 prints: x=10
++    # perl5 prints: Can't find string terminator "'" anywhere before EOF
+ 
+-=item *
++Also see precedence traps, for parsing C<$:>. 
+ 
+-The second and third arguments of splice() are now evaluated in scalar
+-context (as the book says) rather than list context.
++=item * BugFix
+ 
+-=item *
++The second and third arguments of C<splice()> are now evaluated in scalar
++context (as the Camel says) rather than list context.
++    
++    sub sub1{return(0,2) }          # return a 2-elem array
++    sub sub2{ return(1,2,3)}        # return a 3-elem array
++    @a1 = ("a","b","c","d","e"); 
++    @a2 = splice(@a1,&sub1,&sub2);
++    print join(' ',@a2),"\n";
++ 
++    # perl4 prints: a b
++    # perl5 prints: c d e 
+ 
+-These are now semantic errors because of precedence:
++=item * Discontinuance 
+ 
+-    shift @list + 20;	
+-    $n = keys %map + 20; 
++You can't do a C<goto> into a block that is optimized away.  Darn.
+ 
+-Because if that were to work, then this couldn't:
++    goto marker1;
+ 
+-    sleep $dormancy + 20;
++    for(1){         
++    marker1:
++        print "Here I is!\n";
++    } 
++ 
++    # perl4 prints: Here I is!
++    # perl5 dumps core (SEGV)
+ 
+-=item *
++=item * Discontinuance 
++
++It is no longer syntactically legal to use whitespace as the name
++of a variable, or as a delimiter for any kind of quote construct.
++Double darn. 
++
++    $a = ("foo bar");
++    $b = q baz ;
++    print "a is $a, b is $b\n";
++ 
++    # perl4 prints: a is foo bar, b is baz
++    # perl5 errors: Bare word found where operator expected
++    
++=item * Discontinuance
++
++The archaic while/if BLOCK BLOCK syntax is no longer supported.
++
++    if { 1 } {
++        print "True!";
++    }
++    else {
++        print "False!";
++    }
++ 
++    # perl4 prints: True!
++    # perl5 errors: syntax error at test.pl line 1, near "if {"
++
++=item * BugFix
++
++The C<**> operator now binds more tightly than unary minus.
++It was documented to work this way before, but didn't.
++
++    print -4**2,"\n";
++ 
++    # perl4 prints: 16
++    # perl5 prints: -16
++
++=item * Discontinuance 
++
++The meaning of C<foreach{}> has changed slightly when it is iterating over a
++list which is not an array.  This used to assign the list to a
++temporary array, but no longer does so (for efficiency).  This means
++that you'll now be iterating over the actual values, not over copies of
++the values.  Modifications to the loop variable can change the original
++values.
++
++    @list = ('ab','abc','bcd','def');
++    foreach $var (grep(/ab/,@list)){
++        $var = 1;
++    }
++    print (join(':',@list));
++ 
++    # perl4 prints: ab:abc:bcd:def
++    # perl5 prints: 1:1:bcd:def
++
++To retain Perl4 semantics you need to assign your list
++explicitly to a temporary array and then iterate over that.  For 
++example, you might need to change
++
++    foreach $var (grep(/ab/,@list)){
++
++to
++
++    foreach $var (@tmp = grep(/ab/,@list)){
++
++Otherwise changing $var will clobber the values of @list.  (This most often
++happens when you use C<$_> for the loop variable, and call subroutines in
++the loop that don't properly localize C<$_>.)
++
++=item * Depracation
++
++Some error messages will be different.
++
++=item * Discontinuance 
++
++Some bugs may have been inadvertently removed.  :-)
++
++=back
++
++=head2 Parsing Traps
++
++Perl4-to-Perl5 traps from having to do with parsing.
++
++=over 4
++
++=item * Parsing
++
++Note the space between . and =
++
++    $string . = "more string";
++    print $string;
++ 
++    # perl4 prints: more string
++    # perl5 prints: syntax error at - line 1, near ". ="
++
++=item * Parsing
++
++Better parsing in perl 5
++
++    sub foo {}
++    &foo
++    print("hello, world\n");
++ 
++    # perl4 prints: hello, world
++    # perl5 prints: syntax error
++
++=item * Parsing
++
++"if it looks like a function, it is a function" rule.
++
++  print
++    ($foo == 1) ? "is one\n" : "is zero\n";
++ 
++    # perl4 prints: is zero
++    # perl5 warns: "Useless use of a constant in void context" if using -w
++
++=back
++
++=head2 Numerical Traps
++
++Perl4-to-Perl5 traps having to do with numerical operators,
++operands, or output from same.
++
++=over 5
++
++=item * Numerical
++
++Formatted output and significant digits
++
++    print 7.373504 - 0, "\n";
++    printf "%20.18f\n", 7.373504 - 0; 
++ 
++    # Perl4 prints:
++    7.375039999999996141
++    7.37503999999999614
++ 
++    # Perl5 prints:
++    7.373504
++    7.37503999999999614
++
++=item * Numerical
++
++Large integer trap with autoincrement
++
++    $a = $b = 2147483647;
++    print "$a   $b\n";
++    $a += 1;
++    $b++;
++    print "$a   $b\n";
++ 
++    # perl4 prints:
++    2147483647   2147483647
++    2147483648   2147483648
++ 
++    # perl5 prints:
++    2147483647   2147483647
++    2147483648   -2147483648
++
++=item * Numerical  
++
++Assignment of return values from numeric equality tests
++does not work in perl5 when the test evaluates to false (0).
++Logical tests now return an null, instead of 0
++ 
++    $p = ($test == 1);
++    print $p,"\n";
++  
++    # perl4 prints: 0
++    # perl5 prints:
++
++Also see the L<General Regular Expression Traps> tests for another example 
++of this new feature...
++
++=back
++
++=head2 General data type traps
++
++Perl4-to-Perl5 traps involving most data-types, and their usage
++within certain expressions and/or context.
++
++=over 5
++
++=item * (Arrays)
++
++Negative array subscripts now count from the end of the array.
++
++    @a = (1, 2, 3, 4, 5);
++    print "The third element of the array is $a[3] also expressed as $a[-2] \n";
++  
++    # perl4 prints: The third element of the array is 4 also expressed as
++    # perl5 prints: The third element of the array is 4 also expressed as 4
++
++=item * (Arrays)
++
++Setting C<$#array> lower now discards array elements, and makes them
++impossible to recover.
++
++    @a = (a,b,c,d,e); 
++    print "Before: ",join('',@a);
++    $#a =1; 
++    print ", After: ",join('',@a);
++    $#a =3;
++    print ", Recovered: ",join('',@a),"\n";
++  
++    # perl4 prints: Before: abcde, After: ab, Recovered: abcd
++    # perl5 prints: Before: abcde, After: ab, Recovered: ab
++
++=item * (Hashes)
++
++Hashes get defined before use
++
++    local($s,@a,%h); 
++    die "scalar \$s defined" if defined($s);
++    die "array \@a defined" if defined(@a);
++    die "hash \%h defined" if defined(%h);
++ 
++    # perl4 prints:
++    # perl5 dies: hash %h defined
++
++=item * (Globs)
++
++glob assignment from variable to variable will fail if the assigned
++variable is localized subsequent to the assignment
++
++    @a = ("This is Perl 4");
++    *b = *a;
++    local(@a);
++    print @b,"\n";
++ 
++    # perl4 prints: This is Perl 4
++    # perl5 prints:
++ 
++    # Another example
++ 
++    *fred = *barney; # fred is aliased to barney
++    @barney = (1, 2, 4);
++    # @fred;
++    print "@fred";  # should print "1, 2, 4"
++ 
++    # perl4 prints: 1 2 4
++    # perl5 prints: Literal @fred now requires backslash 
++ 
++=item * (Scalar String)
++
++Changes in unary negation (of strings)
++This change effects both the return value and what it
++does to auto(magic)increment.
++
++    $x = "aaa";
++    print ++$x," : ";
++    print -$x," : ";
++    print ++$x,"\n";
++ 
++    # perl4 prints: aab : -0 : 1
++    # perl5 prints: aab : -aab : aac
++
++=item * (Constants)
++
++perl 4 lets you modify constants:
++
++    $foo = "x";
++    &mod($foo);
++    for ($x = 0; $x < 3; $x++) {
++        &mod("a");
++    }
++    sub mod {
++        print "before: $_[0]";
++        $_[0] = "m";
++        print "  after: $_[0]\n";
++    }
++ 
++    # perl4:
++    # before: x  after: m
++    # before: a  after: m
++    # before: m  after: m
++    # before: m  after: m
++ 
++    # Perl5:
++    # before: x  after: m
++    # Modification of a read-only value attempted at foo.pl line 12.
++    # before: a
++
++=item * (Scalars)
++
++The behavior is slightly different for:
++
++    print "$x", defined $x
++  
++    # perl 4: 1
++    # perl 5: <no output, $x is not called into existence>
++
++=item * (Variable Suicide)
++
++Variable suicide behavior is more consistent under Perl 5.
++Perl5 exhibits the same behavior for associative arrays and scalars,
++that perl4 exhibits only for scalars.
++
++    $aGlobal{ "aKey" } = "global value";
++    print "MAIN:", $aGlobal{"aKey"}, "\n";
++    $GlobalLevel = 0;
++    &test( *aGlobal );
++
++    sub test {
++        local( *theArgument ) = @_;
++        local( %aNewLocal ); # perl 4 != 5.001l,m
++        $aNewLocal{"aKey"} = "this should never appear";  
++        print "SUB: ", $theArgument{"aKey"}, "\n";
++        $aNewLocal{"aKey"} = "level $GlobalLevel";   # what should print
++        $GlobalLevel++;
++        if( $GlobalLevel<4 ) {
++            &test( *aNewLocal );
++        }
++    }
++ 
++    # Perl4:
++    # MAIN:global value
++    # SUB: global value
++    # SUB: level 0
++    # SUB: level 1
++    # SUB: level 2
++ 
++    # Perl5:
++    # MAIN:global value
++    # SUB: global value
++    # SUB: this should never appear
++    # SUB: this should never appear
++    # SUB: this should never appear
++
++=back 
++
++=head2 Context Traps - scalar, list contexts
++
++=over 5
++
++=item * (list context)
++
++The elements of argument lists for formats are now evaluated in list
++context.  This means you can interpolate list values now.
++
++    @fmt = ("foo","bar","baz");
++    format STDOUT=
++    @<<<<< @||||| @>>>>>
++    @fmt;
++    .
++    write;  
++ 
++    # perl4 errors:  Please use commas to separate fields in file
++    # perl5 prints: foo     bar      baz
++
++=item * (scalar context)
++
++The C<caller()> function now returns a false value in a scalar context 
++if there is no caller.  This lets library files determine if they're 
++being required.
++
++    caller() ? (print "You rang?\n") : (print "Got a 0\n");
++  
++    # perl4 errors: There is no caller
++    # perl5 prints: Got a 0
++ 
++=item * (scalar context)
++
++The comma operator in a scalar context is now guaranteed to give a
++scalar context to its arguments.
++
++    @y= ('a','b','c');
++    $x = (1, 2, @y);
++    print "x = $x\n";
++ 
++    # Perl4 prints:  x = c   # Thinks list context interpolates list
++    # Perl5 prints:  x = 3   # Knows scalar uses length of list
++
++=item * (list, builtin)
++
++C<sprintf()> funkiness (array argument converted to scalar array count)
++This test could be added to t/op/sprintf.t
++
++    @z = ('%s%s', 'foo', 'bar');
++    $x = sprintf(@z);
++    if ($x eq 'foobar') {print "ok 2\n";} else {print "not ok 2 '$x'\n";}
++ 
++    # perl4 prints: ok 2
++    # perl5 prints: not ok 2
++
++C<printf()> works fine, though:
++
++    printf STDOUT (@z);
++    print "\n"; 
++ 
++    # perl4 prints: foobar
++    # perl5 prints: foobar
++
++Probably a bug.
++
++=back
++
++=head2 Precedence Traps
++
++Perl4-to-Perl5 traps involving precedence order.
++
++=item * 
++
++These are now semantic errors because of precedence:
++
++    @list = (1,2,3,4,5);
++    %map = ("a",1,"b",2,"c",3,"d",4);
++    $n = shift @list + 2;   # first item in list plus 2
++    print "n is $n, ";
++    $m = keys %map + 2;     # number of items in hash plus 2
++    print "m is $m\n";
++ 
++    # perl4 prints: n is 3, m is 6
++    # perl5 errors and fails to compile
++
++=item * Precedence
+ 
+ The precedence of assignment operators is now the same as the precedence
+ of assignment.  Perl 4 mistakenly gave them the precedence of the associated
+ operator.  So you now must parenthesize them in expressions like
+-
++       
+     /foo/ ? ($a += 2) : ($a -= 2);
+-
++    
+ Otherwise
+ 
+-    /foo/ ? $a += 2 : $a -= 2;
++    /foo/ ? $a += 2 : $a -= 2
+ 
+ would be erroneously parsed as
+ 
+@@ -408,115 +873,418 @@
+ 
+ On the other hand,
+ 
+-    $a += /foo/ ? 1 : 2;
++    $a += /foo/ ? 1 : 2; 
+ 
+ now works as a C programmer would expect.
+ 
+-=item *
++=item * Precedence
+ 
+-C<open FOO || die> is now incorrect.  You need parens around the filehandle.
+-While temporarily supported, using such a construct will 
+-generate a non-fatal (but non-suppressible) warning.
++    open FOO || die;
+ 
+-=item *
++is now incorrect.  You need parens around the filehandle.
++Otherwise, perl5 leaves the statement as it's default precedence:
+ 
+-The elements of argument lists for formats are now evaluated in list
+-context.  This means you can interpolate list values now.
++    open(FOO || die);
++ 
++    # perl4 opens or dies
++    # perl5 errors: Precedence problem: open FOO should be open(FOO)
+ 
+-=item *
++=item * Precedence
+ 
+-You can't do a C<goto> into a block that is optimized away.  Darn.
++perl4 gives the special variable, C<$:> precedence, where perl5
++treats C<$::> as main C<package>
+ 
+-=item *
++    $a = "x"; print "$::a"  
++     
++    # perl 4 prints: -:a
++    # perl 5 prints: x
++    
++=item * Precedence
+ 
+-It is no longer syntactically legal to use whitespace as the name
+-of a variable, or as a delimiter for any kind of quote construct.
+-Double darn.
++concatatination precedence over filetest operator?  
+ 
+-=item *
++    -e $foo .= "q" 
++  
++    # perl4 prints: no output
++    # perl5 prints: Can't modify -e in concatenation
+ 
+-The caller() function now returns a false value in a scalar context if there
+-is no caller.  This lets library files determine if they're being required.
++=back
+ 
+-=item *
++=head2 General Regular Expression Traps using s///, etc.
++
++All types of RE traps.
++
++=over 5
++
++=item * Regular Expression
++
++C<s'$lhs'$rhs'> now does no interpolation on either side.  It used to
++interpolate C<$lhs> but not C<$rhs>.  (And still does not match a literal 
++'$' in string)
++
++    $a=1;$b=2;
++    $string = '1 2 $a $b';
++    $string =~ s'$a'$b';
++    print $string,"\n";
++ 
++    # perl4 prints: $b 2 $a $b
++    # perl5 prints: 1 2 $a $b
++
++=item * Regular Expression
+ 
+ C<m//g> now attaches its state to the searched string rather than the
+-regular expression.
++regular expression.  (Once the scope of a block is left for the sub, the
++state of the searched string is lost)
+ 
+-=item *
++    $_ = "ababab";
++    while(m/ab/g){
++        &doit("blah");
++    }
++    sub doit{local($_) = shift; print "Got $_ "}
++ 
++    # perl4 prints: blah blah blah
++    # perl5 prints: infinite loop blah...
+ 
+-C<reverse> is no longer allowed as the name of a sort subroutine.
++=item * Regular Expression
+ 
+-=item *
++If no parentheses are used in a match, Perl4 sets C<$+> to
++the whole match, just like C<$&>. Perl5 does not.
+ 
+-B<taintperl> is no longer a separate executable.  There is now a B<-T>
+-switch to turn on tainting when it isn't turned on automatically.
++    "abcdef" =~ /b.*e/;
++    print "\$+ = $+\n";
++ 
++    # perl4 prints: bcde
++    # perl5 prints:
+ 
+-=item *
++=item * Regular Expression
+ 
+-Double-quoted strings may no longer end with an unescaped C<$> or C<@>.
++substitution now returns the null string if it fails
+ 
+-=item *
++    $string = "test";
++    $value = ($string =~ s/foo//);
++    print $value, "\n";
++ 
++    # perl4 prints: 0
++    # perl5 prints:
+ 
+-The archaic C<while/if> BLOCK BLOCK syntax is no longer supported.
++Also see L<Numerical Traps> for another example of this new feature.
+ 
++=item * Regular Expression
+ 
+-=item *
++C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no 
++backtick expansion
+ 
+-Negative array subscripts now count from the end of the array.
++    $string = "";
++    $string =~ s`^`hostname`;
++    print $string, "\n";
++ 
++    # perl4 prints: <the local hostname>
++    # perl5 prints: hostname
+ 
+-=item *
++=item * Regular Expression
+ 
+-The comma operator in a scalar context is now guaranteed to give a
+-scalar context to its arguments.
++Stricter parsing of variables used in regular expressions
+ 
+-=item *
++    s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
++ 
++    # perl4: compiles w/o error
++    # perl5: with Scalar found where operator expected ..., near "$opt$plus"
+ 
+-The C<**> operator now binds more tightly than unary minus.  
+-It was documented to work this way before, but didn't.
++an added component of this example, apparantly from the same script, is
++the actual value of the s'd string after the substitution.
++C<[$opt]> is a character class in perl4 and an array subscript in perl5
+ 
+-=item *
++    $grpc = 'a'; 
++    $opt  = 'r';
++    $_ = 'bar';
++    s/^([^$grpc]*$grpc[$opt]?)/foo/;
++    print ;
++ 
++    # perl4 prints: foo
++    # perl5 prints: foobar
+ 
+-Setting C<$#array> lower now discards array elements.
++=item * Regular Expression
+ 
+-=item *
++Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched
++repeatedly, like C</x/> or C<m!x!>.
+ 
+-delete() is not guaranteed to return the old value for tie()d arrays,
+-since this capability may be onerous for some modules to implement.
++    $test = "once";
++    sub match { $test =~ m?once?; }
++    &match();
++    if( &match() ) {
++        # m?x? matches more then once
++        print "perl4\n";
++    } else { 
++        # m?x? matches only once
++        print "perl5\n"; 
++    }
++ 
++    # perl4 prints: perl4
++    # perl5 prints: perl5
+ 
+-=item *
++
++=back
++
++=head2 Subroutine, Signal, Sorting Traps
++
++The general group of Perl4-to-Perl5 traps having to do with
++Signals, Sorting, and their related subroutines, as well as
++general subroutine traps.  Includes some OS-Specific traps.
++
++=over 5
++
++=item * (Signals)
++
++Barewords that used to look like strings to Perl will now look like subroutine
++calls if a subroutine by that name is defined before the compiler sees them.
++
++    sub SeeYa { warn"Hasta la vista, baby!" }
++    $SIG{'TERM'} = SeeYa;
++    print "SIGTERM is now $SIG{'TERM'}\n";
++ 
++    # perl4 prints: SIGTERM is main'SeeYa
++    # perl5 prints: SIGTERM is now main::1
++
++Use -w to catch this one
++
++=item * (Sort Subroutine)
++
++reverse is no longer allowed as the name of a sort subroutine.
++
++    sub reverse{ print "yup "; $a <=> $b }
++    print sort reverse a,b,c;  
++ 
++    # perl4 prints: yup yup yup yup abc
++    # perl5 prints: abc 
++
++=back
++
++=head2 OS Traps
++
++=over 5
++
++=item * (SysV)
++
++Under HPUX, and some other SysV OS's, one had to reset any signal handler, 
++within  the signal handler function, each time a signal was handled with 
++perl4.  With perl5, the reset is now done correctly.  Any code relying 
++on the handler _not_ being reset will have to be reworked.
++
++5.002 and beyond uses sigaction() under SysV
++
++    sub gotit {
++        print "Got @_... "; 
++    }  
++    $SIG{'INT'} = 'gotit';
++   
++    $| = 1;
++    $pid = fork;
++    if ($pid) {
++        kill('INT', $pid);
++        sleep(1);
++        kill('INT', $pid);
++    } else { 
++        while (1) {sleep(10);}
++    } 
++ 
++    # perl4 (HPUX) prints: Got INT...
++    # perl5 (HPUX) prints: Got INT... Got INT...
++
++=item * (SysV)
++
++Under SysV OS's, C<seek()> on a file opened to append C<E<gt>E<gt>> now does 
++the right thing w.r.t. the fopen() man page. e.g. - When a file is opened
++for append,  it  is  impossible to overwrite information already in
++the file.
++
++    open(TEST,">>seek.test");
++    $start = tell TEST ;  
++    foreach(1 .. 9){
++        print TEST "$_ ";
++    }
++    $end = tell TEST ;
++    seek(TEST,$start,0);
++    print TEST "18 characters here";
++ 
++    # perl4 (solaris) seek.test has: 18 characters here
++    # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here
++
++
++
++=back
++
++=head2 Interpolation Traps
++
++=over 5
++
++=item * Interpolation
++
++@ now always interpolates an array in double-quotish strings.
++
++    print "To: someone@somewhere.com\n"; 
++ 
++    # perl4 prints: To:someone@somewhere.com
++    # perl5 errors : Literal @somewhere now requires backslash
++
++=item * Interpolation
++
++Perl4-to-Perl5 traps having to do with how things get interpolated
++within certain expressions, statements, contexts, or whatever.
++
++Double-quoted strings may no longer end with an unescaped $ or @.
++
++    $foo = "foo$";
++    $bar = "bar@";
++    print "foo is $foo, bar is $bar\n";
++     
++    # perl4 prints: foo is foo$, bar is bar@
++    # perl5 errors: Final $ should be \$ or $name
++
++Note: perl5 DOES NOT error on the terminating @ in $bar
++
++=item * Interpolation
+ 
+ The construct "this is $$x" used to interpolate the pid at that
+-point, but now tries to dereference $x.  C<$$> by itself still
++point, but now apparantly tries to dereference C<$x>.  C<$$> by itself still
+ works fine, however.
+ 
+-=item *
++    print "this is $$x\n";
+ 
+-The meaning of foreach has changed slightly when it is iterating over a
+-list which is not an array.  This used to assign the list to a
+-temporary array, but no longer does so (for efficiency).  This means
+-that you'll now be iterating over the actual values, not over copies of
+-the values.  Modifications to the loop variable can change the original
+-values.  To retain Perl 4 semantics you need to assign your list
+-explicitly to a temporary array and then iterate over that.  For
+-example, you might need to change
++    # perl4 prints: this is XXXx   (XXX is the current pid)
++    # perl5 prints: this is
+ 
+-    foreach $var (grep /x/, @list) { ... }
++=item * Interpolation
++
++Creation of hashes on the fly with C<eval "EXPR"> now requires either both 
++C<$>'s to be protected in the specification of the hash name, or both curlies 
++to be protected.  If both curlies are protected, the result will be compatible
++with perl4 and perl5.  This is a very common practice, and should be changed
++to use the block form of C<eval{}>  if possible.
++
++    $hashname = "foobar";
++    $key = "baz";
++    $value = 1234;
++    eval "\$$hashname{'$key'} = q|$value|";
++    (defined($foobar{'baz'})) ?  (print "Yup") : (print "Nope");
++
++    # perl4 prints: Yup
++    # perl5 prints: Nope
++
++Changing
++
++    eval "\$$hashname{'$key'} = q|$value|";
+ 
+ to
+ 
+-    foreach $var (my @tmp = grep /x/, @list) { ... }
++    eval "\$\$hashname{'$key'} = q|$value|";
+ 
+-Otherwise changing C<$var> will clobber the values of @list.  (This most often
+-happens when you use C<$_> for the loop variable, and call subroutines in
+-the loop that don't properly localize C<$_>.)
++causes the following result:
+ 
+-=item *
++    # perl4 prints: Nope
++    # perl5 prints: Yup
+ 
+-Some error messages will be different.
++or, changing to
+ 
+-=item *
++    eval "\$$hashname\{'$key'\} = q|$value|";
+ 
+-Some bugs may have been inadvertently removed.
++causes the following result:
++
++    # perl4 prints: Yup
++    # perl5 prints: Yup
++    # and is compatible for both versions
++
++
++=item * Interpolation
++
++perl4 programs which unconsciously rely on the bugs in earlier perl versions.
++
++    perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"'
++     
++    # perl4 prints: This is not perl5
++    # perl5 prints: This is perl5
++
++=item * Interpolation
++
++You also have to be careful about array references.  
++
++    print "$foo{"
++
++    perl 4 prints: {
++    perl 5 prints: syntax error
++
++=item * Interpolation
++
++Similarly, watch out for:
++
++    $foo = "array";
++    print "\$$foo{bar}\n";
++  
++    # perl4 prints: $array{bar}
++    # perl5 prints: $
++
++Perl 5 is looking for C<$array{bar}> which doesn't exist, but perl 4 is
++happy just to expand $foo to "array" by itself.  Watch out for this
++especially in C<eval>'s.
++
++=item * Interpolation
++
++C<qq()> string passed to C<eval>
++
++    eval qq(
++        foreach \$y (keys %\$x\) {
++            \$count++;
++        }
++    );
++  
++    # perl4 runs this ok
++    # perl5 prints: Can't find string terminator ")" 
++
++=back
++
++=head2 Unclassified Traps
++
++Everything else.
++
++=over 5
++
++=item * Unclassified
++
++Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
++may cause the same script, run under perl5, to fail.  The build of perl5
++must have been linked with the same dbm/ndbm as the default for C<dbmopen()>
++to function properly without C<tie>'ing to an extension dbm implementation.
++
++    dbmopen (%dbm, "file", undef);
++    print "ok\n";
++
++    # perl4 prints: ok
++    # perl5 prints: ok (IFF linked with -ldbm or -lndbm)
++
++=item * Unclassified
++
++C<require>/C<do> trap using returned value
++
++If the file doit.pl has:
++
++    sub foo {
++        $rc = do "./do.pl";
++        return 8;
++    } 
++    print &foo, "\n";
++
++And the do.pl file has the following single line:
++
++    return 3;
++
++Running doit.pl gives the following:
++
++    # perl 4 prints: 3 (aborts the subroutine early)
++    # perl 5 prints: 8 
++
++Same behavior if you replace C<do> with C<require>.
+ 
+ =back
++
++As always, if any of these are ever officially declared as bugs, 
++they'll be fixed and removed.
++
diff --git a/japanese/perl5/files/patch-ad b/japanese/perl5/files/patch-ad
new file mode 100644
index 000000000000..dacef7ef6def
--- /dev/null
+++ b/japanese/perl5/files/patch-ad
@@ -0,0 +1,44 @@
+--- hints/freebsd.sh.orig	Mon Feb 12 21:52:51 1996
++++ hints/freebsd.sh	Wed Oct 23 18:00:16 1996
+@@ -43,16 +43,39 @@
+ 	d_setruid='undef'
+ 	;;
+ #
+-# Trying to cover 2.0.5, 2.1-current and future 2.1
++# Trying to cover 2.0.5, 2.1-current and future 2.1/2.2
+ # It does not covert all 2.1-current versions as the output of uname
+ # changed a few times.
+ #
++# Even though seteuid/setegid are available, they've been turned off
++# because perl isn't coded with saved set[ug]id variables in mind.
++# In addition, a small patch is requried to suidperl to avoid a security
++# problem with FreeBSD.
++#
+ 2.0.5*|2.0-built*|2.1*)
+  	usevfork='true'
++	d_dosuid='define'
++	d_setregid='define'
++	d_setreuid='define'
++	d_setegid='undef'
++	d_seteuid='undef'
++	;;
++#
++# 2.2 and above have phkmalloc(3).
++2.2*)
++ 	usevfork='true'
++	usemymalloc='n'
++	d_dosuid='define'
++	d_setregid='define'
++	d_setreuid='define'
++	d_setegid='undef'
++	d_seteuid='undef'
+ 	;;
+ #
+-# Guesses at what will be needed after 2.1
++# Guesses at what will be needed after 2.2
+ *)	usevfork='true'
++	usemymalloc='n'
++	d_dosuid='define'
+ 	;;
+ esac
+ 
diff --git a/japanese/perl5/files/patch-ae b/japanese/perl5/files/patch-ae
new file mode 100644
index 000000000000..def0493a1c27
--- /dev/null
+++ b/japanese/perl5/files/patch-ae
@@ -0,0 +1,46 @@
+*** installperl.orig	Mon Jun 24 22:08:25 1996
+--- installperl	Wed Jun 26 22:21:05 1996
+***************
+*** 89,95 ****
+  &safe_unlink("$installbin/sperl$ver$exe_ext");
+  if ($d_dosuid) {
+      &cmd("cp suidperl$exe_ext $installbin/sperl$ver$exe_ext");
+!     &chmod(04711, "$installbin/sperl$ver$exe_ext");
+  }
+  
+  exit 0 if $versiononly;
+--- 89,95 ----
+  &safe_unlink("$installbin/sperl$ver$exe_ext");
+  if ($d_dosuid) {
+      &cmd("cp suidperl$exe_ext $installbin/sperl$ver$exe_ext");
+!     &chmod(04111, "$installbin/sperl$ver$exe_ext");
+  }
+  
+  exit 0 if $versiononly;
+***************
+*** 203,212 ****
+  	      ((readlink "$mainperldir/perl$exe_ext") eq "$binexp/perl$exe_ext"));
+      }
+      if ((! $mainperl_is_instperl) &&
+! 	(&yn("Many scripts expect perl to be installed as " .
+! 	     "$mainperldir/perl.\n" . 
+! 	     "Do you wish to have $mainperldir/perl be the same as\n" .
+! 	     "$binexp/perl? [y] ")))
+      {	
+  	unlink("$mainperldir/perl$exe_ext");
+  	eval 'link("$installbin/perl$exe_ext", "$mainperldir/perl$exe_ext")' ||
+--- 203,216 ----
+  	      ((readlink "$mainperldir/perl$exe_ext") eq "$binexp/perl$exe_ext"));
+      }
+      if ((! $mainperl_is_instperl) &&
+! 	0)
+! #	Disable Perl5 from 'taking' over from the system Perl.
+! #	(nasty hack, but it is only for the FreeBSD build, so WTH.
+! #
+! #	(&yn("Many scripts expect perl to be installed as " .
+! #	     "$mainperldir/perl.\n" . 
+! #	     "Do you wish to have $mainperldir/perl be the same as\n" .
+! #	     "$binexp/perl? [y] ")))
+      {	
+  	unlink("$mainperldir/perl$exe_ext");
+  	eval 'link("$installbin/perl$exe_ext", "$mainperldir/perl$exe_ext")' ||