diff -u --new-file --recursive perl-4.036.orig/Makefile perl-4.036/Makefile
--- perl-4.036.orig/Makefile	Wed Dec 31 18:00:00 1969
+++ perl-4.036/Makefile	Tue Jan 17 21:16:27 1995
@@ -0,0 +1,336 @@
+# : Makefile.SH,v 4063Revision: 4.0.1.4 4063Date: 92/06/08 11:40:43 $
+#
+# $Log:	Makefile.SH,v $
+# Revision 4.0.1.4  92/06/08  11:40:43  lwall
+# patch20: cray didn't give enough memory to /bin/sh
+# patch20: various and sundry fixes
+# 
+# Revision 4.0.1.3  91/11/05  15:48:11  lwall
+# patch11: saberized perl
+# patch11: added support for dbz
+# 
+# Revision 4.0.1.2  91/06/07  10:14:43  lwall
+# patch4: cflags now emits entire cc command except for the filename
+# patch4: alternate make programs are now semi-supported
+# patch4: uperl.o no longer tries to link in libraries prematurely
+# patch4: installperl now installs x2p stuff too
+# 
+# Revision 4.0.1.1  91/04/11  17:30:39  lwall
+# patch1: C flags are now settable on a per-file basis
+# 
+# Revision 4.0  91/03/20  00:58:54  lwall
+# 4.0 baseline.
+# 
+# 
+
+CC = gcc
+YACC = bison -y
+bin = /usr/bin
+scriptdir = /usr/bin
+privlib = /usr/lib/perl4
+mansrc = /usr/man/man1
+manext = 1
+LDFLAGS = -s
+CLDFLAGS = -s
+SMALL = 
+LARGE =  
+mallocsrc = 
+mallocobj = 
+SLN = ln -s
+RMS = rm -f
+
+libs = -ldbm -lm 
+
+public = perl taintperl 
+
+shellflags = 
+
+# To use an alternate make, set  in config.sh.
+MAKE = make
+
+
+CCCMD = `sh $(shellflags) cflags $@`
+
+private = 
+
+scripts = h2ph
+
+manpages = perl.man h2ph.man
+
+util =
+
+sh = Makefile.SH makedepend.SH h2ph.SH
+
+h1 = EXTERN.h INTERN.h arg.h array.h cmd.h config.h form.h handy.h
+h2 = hash.h perl.h regcomp.h regexp.h spat.h stab.h str.h util.h
+
+h = $(h1) $(h2)
+
+c1 = array.c cmd.c cons.c consarg.c doarg.c doio.c dolist.c dump.c
+c2 = eval.c form.c hash.c $(mallocsrc) perl.c regcomp.c regexec.c
+c3 = stab.c str.c toke.c util.c usersub.c
+
+c = $(c1) $(c2) $(c3)
+
+s1 = array.c cmd.c cons.c consarg.c doarg.c doio.c dolist.c dump.c
+s2 = eval.c form.c hash.c perl.c regcomp.c regexec.c
+s3 = stab.c str.c toke.c util.c usersub.c perly.c
+
+saber = $(s1) $(s2) $(s3)
+
+obj1 = array.o cmd.o cons.o consarg.o doarg.o doio.o dolist.o dump.o
+obj2 = eval.o form.o $(mallocobj) perl.o regcomp.o regexec.o
+obj3 = stab.o str.o toke.o util.o
+
+obj = $(obj1) $(obj2) $(obj3)
+
+tobj1 = tarray.o tcmd.o tcons.o tconsarg.o tdoarg.o tdoio.o tdolist.o tdump.o
+tobj2 = teval.o tform.o thash.o $(mallocobj) tregcomp.o tregexec.o
+tobj3 = tstab.o tstr.o ttoke.o tutil.o
+
+tobj = $(tobj1) $(tobj2) $(tobj3)
+
+lintflags = -hbvxac
+
+addedbyconf = Makefile.old bsd eunice filexp loc pdp11 usg v7
+
+# grrr
+SHELL = /bin/sh
+
+.c.o:
+	$(CCCMD) $*.c
+
+all: $(public) $(private) $(util) uperl.o $(scripts)
+	cd x2p; $(MAKE) all
+	touch all
+
+# This is the standard version that contains no "taint" checks and is
+# used for all scripts that aren't set-id or running under something set-id.
+# The $& notation is tells Sequent machines that it can do a parallel make,
+# and is harmless otherwise.
+
+perl: $& perly.o $(obj) hash.o usersub.o
+	$(CC) $(LARGE) $(CLDFLAGS) $(obj) hash.o perly.o usersub.o $(libs) -o perl
+
+# This command assumes that /usr/include/dbz.h and /usr/lib/dbz.o exist.
+
+dbzperl: $& perly.o $(obj) zhash.o usersub.o
+	$(CC) $(LARGE) $(CLDFLAGS) $(obj) zhash.o /usr/lib/dbz.o perly.o usersub.o $(libs) -o dbzperl
+
+zhash.o: hash.c $(h)
+	$(RMS) zhash.c
+	$(SLN) hash.c zhash.c
+	$(CCCMD) -DWANT_DBZ zhash.c
+	$(RMS) zhash.c
+
+uperl.o: $& perly.o $(obj) hash.o
+	-ld $(LARGE) $(LDFLAGS) -r $(obj) hash.o perly.o -o uperl.o
+
+saber: $(saber)
+	# load $(saber)
+	# load /lib/libm.a
+
+# This version, if specified in Configure, does ONLY those scripts which need
+# set-id emulation.  Suidperl must be setuid root.  It contains the "taint"
+# checks as well as the special code to validate that the script in question
+# has been invoked correctly.
+
+suidperl: $& tperly.o sperl.o $(tobj) usersub.o
+	$(CC) $(LARGE) $(CLDFLAGS) sperl.o $(tobj) tperly.o usersub.o $(libs) \
+	    -o suidperl
+
+# This version interprets scripts that are already set-id either via a wrapper
+# or through the kernel allowing set-id scripts (bad idea).  Taintperl must
+# NOT be setuid to root or anything else.  The only difference between it
+# and normal perl is the presence of the "taint" checks.
+
+taintperl: $& tperly.o tperl.o $(tobj) usersub.o
+	$(CC) $(LARGE) $(CLDFLAGS) tperl.o $(tobj) tperly.o usersub.o $(libs) \
+	    -o taintperl
+
+# Replicating all this junk is yucky, but I don't see a portable way to fix it.
+
+tperly.o: perly.c perly.h $(h)
+	$(RMS) tperly.c
+	$(SLN) perly.c tperly.c
+	$(CCCMD) -DTAINT tperly.c
+	$(RMS) tperly.c
+
+tperl.o: perl.c perly.h patchlevel.h perl.h $(h)
+	$(RMS) tperl.c
+	$(SLN) perl.c tperl.c
+	$(CCCMD) -DTAINT tperl.c
+	$(RMS) tperl.c
+
+sperl.o: perl.c perly.h patchlevel.h $(h)
+	$(RMS) sperl.c
+	$(SLN) perl.c sperl.c
+	$(CCCMD) -DTAINT -DIAMSUID sperl.c
+	$(RMS) sperl.c
+
+tarray.o: array.c $(h)
+	$(RMS) tarray.c
+	$(SLN) array.c tarray.c
+	$(CCCMD) -DTAINT tarray.c
+	$(RMS) tarray.c
+
+tcmd.o: cmd.c $(h)
+	$(RMS) tcmd.c
+	$(SLN) cmd.c tcmd.c
+	$(CCCMD) -DTAINT tcmd.c
+	$(RMS) tcmd.c
+
+tcons.o: cons.c $(h) perly.h
+	$(RMS) tcons.c
+	$(SLN) cons.c tcons.c
+	$(CCCMD) -DTAINT tcons.c
+	$(RMS) tcons.c
+
+tconsarg.o: consarg.c $(h)
+	$(RMS) tconsarg.c
+	$(SLN) consarg.c tconsarg.c
+	$(CCCMD) -DTAINT tconsarg.c
+	$(RMS) tconsarg.c
+
+tdoarg.o: doarg.c $(h)
+	$(RMS) tdoarg.c
+	$(SLN) doarg.c tdoarg.c
+	$(CCCMD) -DTAINT tdoarg.c
+	$(RMS) tdoarg.c
+
+tdoio.o: doio.c $(h)
+	$(RMS) tdoio.c
+	$(SLN) doio.c tdoio.c
+	$(CCCMD) -DTAINT tdoio.c
+	$(RMS) tdoio.c
+
+tdolist.o: dolist.c $(h)
+	$(RMS) tdolist.c
+	$(SLN) dolist.c tdolist.c
+	$(CCCMD) -DTAINT tdolist.c
+	$(RMS) tdolist.c
+
+tdump.o: dump.c $(h)
+	$(RMS) tdump.c
+	$(SLN) dump.c tdump.c
+	$(CCCMD) -DTAINT tdump.c
+	$(RMS) tdump.c
+
+teval.o: eval.c $(h)
+	$(RMS) teval.c
+	$(SLN) eval.c teval.c
+	$(CCCMD) -DTAINT teval.c
+	$(RMS) teval.c
+
+tform.o: form.c $(h)
+	$(RMS) tform.c
+	$(SLN) form.c tform.c
+	$(CCCMD) -DTAINT tform.c
+	$(RMS) tform.c
+
+thash.o: hash.c $(h)
+	$(RMS) thash.c
+	$(SLN) hash.c thash.c
+	$(CCCMD) -DTAINT thash.c
+	$(RMS) thash.c
+
+tregcomp.o: regcomp.c $(h)
+	$(RMS) tregcomp.c
+	$(SLN) regcomp.c tregcomp.c
+	$(CCCMD) -DTAINT tregcomp.c
+	$(RMS) tregcomp.c
+
+tregexec.o: regexec.c $(h)
+	$(RMS) tregexec.c
+	$(SLN) regexec.c tregexec.c
+	$(CCCMD) -DTAINT tregexec.c
+	$(RMS) tregexec.c
+
+tstab.o: stab.c $(h)
+	$(RMS) tstab.c
+	$(SLN) stab.c tstab.c
+	$(CCCMD) -DTAINT tstab.c
+	$(RMS) tstab.c
+
+tstr.o: str.c $(h) perly.h
+	$(RMS) tstr.c
+	$(SLN) str.c tstr.c
+	$(CCCMD) -DTAINT tstr.c
+	$(RMS) tstr.c
+
+ttoke.o: toke.c $(h) perly.h
+	$(RMS) ttoke.c
+	$(SLN) toke.c ttoke.c
+	$(CCCMD) -DTAINT ttoke.c
+	$(RMS) ttoke.c
+
+tutil.o: util.c $(h)
+	$(RMS) tutil.c
+	$(SLN) util.c tutil.c
+	$(CCCMD) -DTAINT tutil.c
+	$(RMS) tutil.c
+
+perly.h: perly.c
+	@ echo Dummy dependency for dumb parallel make
+	touch perly.h
+
+perly.c: perly.y perly.fixer
+	@ \
+case "$(YACC)" in \
+    *bison*) echo 'Expect' 25 shift/reduce and 59 reduce/reduce conflicts;; \
+    *) echo 'Expect' 27 shift/reduce and 57 reduce/reduce conflicts;; \
+esac
+	$(YACC) -d perly.y
+	sh $(shellflags) ./perly.fixer y.tab.c perly.c
+	mv y.tab.h perly.h
+	echo 'extern YYSTYPE yylval;' >>perly.h
+
+perly.o: perly.c perly.h $(h)
+	$(CCCMD) perly.c
+
+install: all
+	./perl installperl
+
+clean:
+	rm -f *.o all perl taintperl suidperl perly.c
+	cd x2p; $(MAKE) clean
+
+realclean: clean
+	cd x2p; $(MAKE) realclean
+	rm -f *.orig */*.orig *~ */*~ core $(addedbyconf) h2ph h2ph.man
+	rm -f perly.c perly.h t/perl Makefile config.h makedepend makedir
+	rm -f makefile x2p/Makefile x2p/makefile cflags x2p/cflags
+	rm -f c2ph pstruct
+
+# The following lint has practically everything turned on.  Unfortunately,
+# you have to wade through a lot of mumbo jumbo that can't be suppressed.
+# If the source file has a /*NOSTRICT*/ somewhere, ignore the lint message
+# for that spot.
+
+lint: perly.c $(c)
+	lint $(lintflags) $(defs) perly.c $(c) > perl.fuzz
+
+depend: makedepend
+	- test -f perly.h || cp /dev/null perly.h
+	./makedepend
+	- test -s perly.h || /bin/rm -f perly.h
+	cd x2p; $(MAKE) depend
+
+test: perl
+	- cd t && chmod +x TEST */*.t
+	- cd t && (rm -f perl; $(SLN) ../perl perl) && ./perl TEST </dev/tty
+
+clist:
+	echo $(c) | tr ' ' '\012' >.clist
+
+hlist:
+	echo $(h) | tr ' ' '\012' >.hlist
+
+shlist:
+	echo $(sh) | tr ' ' '\012' >.shlist
+
+# AUTOMATICALLY GENERATED MAKE DEPENDENCIES--PUT NOTHING BELOW THIS LINE
+$(obj) hash.o:
+	@ echo "You haven't done a "'"make depend" yet!'; exit 1
+makedepend: makedepend.SH
+	/bin/sh $(shellflags) makedepend.SH
diff -u --new-file --recursive perl-4.036.orig/c2ph perl-4.036/c2ph
--- perl-4.036.orig/c2ph	Wed Dec 31 18:00:00 1969
+++ perl-4.036/c2ph	Tue Jan 17 21:16:27 1995
@@ -0,0 +1,1071 @@
+#!/usr/bin/perl
+#
+#
+#   c2ph (aka pstruct)
+#   Tom Christiansen, <tchrist@convex.com>
+#   
+#   As pstruct, dump C structures as generated from 'cc -g -S' stabs.
+#   As c2ph, do this PLUS generate perl code for getting at the structures.
+#
+#   See the usage message for more.  If this isn't enough, read the code.
+#
+
+$RCSID = '$RCSfile: c2ph.SH,v $$Revision: 4.0.1.2 $$Date: 92/06/08 11:56:08 $';
+
+
+######################################################################
+
+# some handy data definitions.   many of these can be reset later.
+
+$bitorder = 'b';  # ascending; set to B for descending bit fields
+
+%intrinsics = 
+%template = (
+    'char', 			'c',
+    'unsigned char', 		'C',
+    'short',			's',
+    'short int',		's',
+    'unsigned short',		'S',
+    'unsigned short int',	'S',
+    'short unsigned int',	'S',
+    'int',			'i',
+    'unsigned int',		'I',
+    'long',			'l',
+    'long int',			'l',
+    'unsigned long',		'L',
+    'unsigned long',		'L',
+    'long unsigned int',	'L',
+    'unsigned long int',	'L',
+    'long long',		'q',
+    'long long int',		'q',
+    'unsigned long long',	'Q',
+    'unsigned long long int',	'Q',
+    'float',			'f',
+    'double',			'd',
+    'pointer',			'p',
+    'null',			'x',
+    'neganull',			'X',
+    'bit',			$bitorder,
+); 
+
+&buildscrunchlist;
+delete $intrinsics{'neganull'};
+delete $intrinsics{'bit'};
+delete $intrinsics{'null'};
+
+# use -s to recompute sizes
+%sizeof = (
+    'char', 			'1',
+    'unsigned char', 		'1',
+    'short',			'2',
+    'short int',		'2',
+    'unsigned short',		'2',
+    'unsigned short int',	'2',
+    'short unsigned int',	'2',
+    'int',			'4',
+    'unsigned int',		'4',
+    'long',			'4',
+    'long int',			'4',
+    'unsigned long',		'4',
+    'unsigned long int',	'4',
+    'long unsigned int',	'4',
+    'long long',		'8',
+    'long long int',		'8',
+    'unsigned long long',	'8',
+    'unsigned long long int',	'8',
+    'float',			'4',
+    'double',			'8',
+    'pointer',			'4',
+);
+
+($type_width, $member_width, $offset_width, $size_width) = (20, 20, 6, 5);
+
+($offset_fmt, $size_fmt) = ('d', 'd');
+
+$indent = 2;
+
+$CC = 'cc';
+$CFLAGS = '-g -S';
+$DEFINES = '';
+
+$perl++ if $0 =~ m#/?c2ph$#;
+
+require 'getopts.pl';
+
+eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
+
+&Getopts('aixdpvtnws:') || &usage(0);
+
+$opt_d && $debug++;
+$opt_t && $trace++;
+$opt_p && $perl++;
+$opt_v && $verbose++;
+$opt_n && ($perl = 0);
+
+if ($opt_w) {
+    ($type_width, $member_width, $offset_width) = (45, 35, 8);
+} 
+if ($opt_x) {
+    ($offset_fmt, $offset_width, $size_fmt, $size_width) = ( 'x', '08', 'x', 04 );
+}
+
+eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
+
+sub PLUMBER {
+    select(STDERR);
+    print "oops, apperent pager foulup\n";
+    $isatty++;
+    &usage(1);
+} 
+
+sub usage {
+    local($oops) = @_;
+    unless (-t STDOUT) {
+	select(STDERR);
+    } elsif (!$oops) {
+	$isatty++;
+	$| = 1;
+	print "hit <RETURN> for further explanation: ";
+	<STDIN>;
+	open (PIPE, "|". ($ENV{PAGER} || 'more'));
+	$SIG{PIPE} = PLUMBER;
+	select(PIPE);
+    } 
+
+    print "usage: $0 [-dpnP] [var=val] [files ...]\n";
+
+    exit unless $isatty;
+
+    print <<EOF;
+
+Options:
+
+-w	wide; short for: type_width=45 member_width=35 offset_width=8
+-x	hex; short for:  offset_fmt=x offset_width=08 size_fmt=x size_width=04
+
+-n  	do not generate perl code  (default when invoked as pstruct)
+-p  	generate perl code         (default when invoked as c2ph)
+-v	generate perl code, with C decls as comments
+
+-i	do NOT recompute sizes for intrinsic datatypes
+-a	dump information on intrinsics also
+
+-t 	trace execution
+-d	spew reams of debugging output
+
+-slist  give comma-separated list a structures to dump
+
+
+Var Name        Default Value    Meaning
+
+EOF
+
+    &defvar('CC', 'which_compiler to call');
+    &defvar('CFLAGS', 'how to generate *.s files with stabs');
+    &defvar('DEFINES','any extra cflags or cpp defines, like -I, -D, -U');
+
+    print "\n";
+
+    &defvar('type_width', 'width of type field   (column 1)');
+    &defvar('member_width', 'width of member field (column 2)');
+    &defvar('offset_width', 'width of offset field (column 3)');
+    &defvar('size_width', 'width of size field   (column 4)');
+
+    print "\n";
+
+    &defvar('offset_fmt', 'sprintf format type for offset');
+    &defvar('size_fmt', 'sprintf format type for size');
+
+    print "\n";
+
+    &defvar('indent', 'how far to indent each nesting level');
+
+   print <<'EOF';
+
+    If any *.[ch] files are given, these will be catted together into
+    a temporary *.c file and sent through:
+	    $CC $CFLAGS $DEFINES 
+    and the resulting *.s groped for stab information.  If no files are
+    supplied, then stdin is read directly with the assumption that it
+    contains stab information.  All other liens will be ignored.  At
+    most one *.s file should be supplied.
+
+EOF
+    close PIPE;
+    exit 1;
+} 
+
+sub defvar {
+    local($var, $msg) = @_;
+    printf "%-16s%-15s  %s\n", $var, eval "\$$var", $msg;
+} 
+
+$recurse = 1;
+
+if (@ARGV) {
+    if (grep(!/\.[csh]$/,@ARGV)) {
+	warn "Only *.[csh] files expected!\n";
+	&usage;
+    } 
+    elsif (grep(/\.s$/,@ARGV)) {
+	if (@ARGV > 1) { 
+	    warn "Only one *.s file allowed!\n";
+	    &usage;
+	}
+    } 
+    elsif (@ARGV == 1 && $ARGV[0] =~ /\.c$/) {
+	local($dir, $file) = $ARGV[0] =~ m#(.*/)?(.*)$#;
+	$chdir = "cd $dir; " if $dir;
+	&system("$chdir$CC $CFLAGS $DEFINES $file") && exit 1;
+	$ARGV[0] =~ s/\.c$/.s/;
+    } 
+    else {
+	$TMP = "/tmp/c2ph.$$.c";
+	&system("cat @ARGV > $TMP") && exit 1;
+	&system("cd /tmp; $CC $CFLAGS $DEFINES $TMP") && exit 1;
+	unlink $TMP;
+	$TMP =~ s/\.c$/.s/;
+	@ARGV = ($TMP);
+    } 
+}
+
+if ($opt_s) {
+    for (split(/[\s,]+/, $opt_s)) {
+	$interested{$_}++;
+    } 
+} 
+
+
+$| = 1 if $debug;
+
+main: {
+
+    if ($trace) {
+	if (-t && !@ARGV) { 
+	    print STDERR "reading from your keyboard: ";
+	} else {
+	    print STDERR "reading from " . (@ARGV ? "@ARGV" : "<STDIN>").": ";
+	}
+    }
+
+STAB: while (<>) {
+	if ($trace && !($. % 10)) {
+	    $lineno = $..'';
+	    print STDERR $lineno, "\b" x length($lineno);
+	} 
+	next unless /^\s*\.stabs\s+/;
+	$line = $_;
+	s/^\s*\.stabs\s+//; 
+	&stab; 
+    }
+    print STDERR "$.\n" if $trace;
+    unlink $TMP if $TMP;
+
+    &compute_intrinsics if $perl && !$opt_i;
+
+    print STDERR "resolving types\n" if $trace;
+
+    &resolve_types;
+    &adjust_start_addrs;
+
+    $sum = 2 + $type_width + $member_width;
+    $pmask1 = "%-${type_width}s %-${member_width}s"; 
+    $pmask2 = "%-${sum}s %${offset_width}${offset_fmt}%s %${size_width}${size_fmt}%s";
+
+    if ($perl) {
+	# resolve template -- should be in stab define order, but even this isn't enough.
+	print STDERR "\nbuilding type templates: " if $trace;
+	for $i (reverse 0..$#type) {
+	    next unless defined($name = $type[$i]);
+	    next unless defined $struct{$name};
+	    $build_recursed = 0;
+	    &build_template($name) unless defined $template{&psou($name)} ||
+					$opt_s && !$interested{$name};
+	} 
+	print STDERR "\n\n" if $trace;
+    }
+
+    print STDERR "dumping structs: " if $trace;
+
+
+    foreach $name (sort keys %struct) {
+	next if $opt_s && !$interested{$name};
+	print STDERR "$name " if $trace;
+
+	undef @sizeof;
+	undef @typedef;
+	undef @offsetof;
+	undef @indices;
+	undef @typeof;
+
+	$mname = &munge($name);
+
+	$fname = &psou($name);
+
+	print "# " if $perl && $verbose;
+	$pcode = '';
+	print "$fname {\n" if !$perl || $verbose; 
+	$template{$fname} = &scrunch($template{$fname}) if $perl;
+	&pstruct($name,$name,0); 
+	print "# " if $perl && $verbose;
+	print "}\n" if !$perl || $verbose; 
+	print "\n" if $perl && $verbose;
+
+	if ($perl) {
+	    print "$pcode";
+
+	    printf("\nsub %-32s { %4d; }\n\n", "${mname}'struct", $countof{$name});
+
+	    print <<EOF;
+sub ${mname}'typedef { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}'index 
+	? \$${mname}'typedef[\$${mname}'index] 
+	: \$${mname}'typedef;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'sizeof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}'index 
+	? \$${mname}'sizeof[\$${mname}'index] 
+	: \$${mname}'sizeof;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'offsetof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}index 
+	? \$${mname}'offsetof[\$${mname}'index] 
+	: \$${mname}'sizeof;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'typeof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}index 
+	? \$${mname}'typeof[\$${mname}'index] 
+	: '$name';
+}
+EOF
+    
+
+	    print "\$${mname}'typedef = '" . &scrunch($template{$fname}) 
+		. "';\n";
+
+	    print "\$${mname}'sizeof = $sizeof{$name};\n\n";
+
+
+	    print "\@${mname}'indices = (", &squishseq(@indices), ");\n";
+
+	    print "\n";
+
+	    print "\@${mname}'typedef[\@${mname}'indices] = (",
+			join("\n\t", '', @typedef), "\n    );\n\n";
+	    print "\@${mname}'sizeof[\@${mname}'indices] = (",
+			join("\n\t", '', @sizeof), "\n    );\n\n";
+	    print "\@${mname}'offsetof[\@${mname}'indices] = (",
+			join("\n\t", '', @offsetof), "\n    );\n\n";
+	    print "\@${mname}'typeof[\@${mname}'indices] = (",
+			join("\n\t", '', @typeof), "\n    );\n\n";
+
+	    $template_printed{$fname}++;
+	    $size_printed{$fname}++;
+	} 
+	print "\n";
+    }
+
+    print STDERR "\n" if $trace;
+
+    unless ($perl && $opt_a) { 
+	print "\n1;\n";
+	exit;
+    }
+
+
+
+    foreach $name (sort bysizevalue keys %intrinsics) {
+	next if $size_printed{$name};
+	print '$',&munge($name),"'sizeof = ", $sizeof{$name}, ";\n";
+    }
+
+    print "\n";
+
+    sub bysizevalue { $sizeof{$a} <=> $sizeof{$b}; }
+
+
+    foreach $name (sort keys %intrinsics) {
+	print '$',&munge($name),"'typedef = '", $template{$name}, "';\n";
+    }
+
+    print "\n1;\n";
+	
+    exit;
+}
+
+########################################################################################
+
+
+sub stab {
+    next unless /:[\$\w]+(\(\d+,\d+\))?=[\*\$\w]+/;  # (\d+,\d+) is for sun
+    s/"// 						|| next;
+    s/",([x\d]+),([x\d]+),([x\d]+),.*// 		|| next;
+
+    next if /^\s*$/;
+
+    $size = $3 if $3;
+
+
+    $line = $_;
+
+    if (($name, $pdecl) = /^([\$ \w]+):[tT]((\d+)(=[rufs*](\d+))+)$/) {
+	print "$name is a typedef for some funky pointers: $pdecl\n" if $debug;
+	&pdecl($pdecl);
+	next;
+    }
+
+
+
+    if (/(([ \w]+):t(\d+|\(\d+,\d+\)))=r?(\d+|\(\d+,\d+\))(;\d+;\d+;)?/) {  
+	local($ident) = $2;
+	push(@intrinsics, $ident);
+	$typeno = &typeno($3);
+	$type[$typeno] = $ident;
+	print STDERR "intrinsic $ident in new type $typeno\n" if $debug; 
+	next;
+    }
+
+    if (($name, $typeordef, $typeno, $extra, $struct, $_) 
+	= /^([\$ \w]+):([ustT])(\d+|\(\d+,\d+\))(=[rufs*](\d+))?(.*)$/) 
+    {
+	$typeno = &typeno($typeno);  # sun foolery
+    } 
+    elsif (/^[\$\w]+:/) {
+	next; # variable
+    }
+    else { 
+	warn "can't grok stab: <$_> in: $line " if $_;
+	next;
+    } 
+
+    #warn "got size $size for $name\n";
+    $sizeof{$name} = $size if $size;
+
+    s/;[-\d]*;[-\d]*;$//;  # we don't care about ranges
+
+    $typenos{$name} = $typeno;
+
+    unless (defined $type[$typeno]) {
+	&panic("type 0??") unless $typeno;
+	$type[$typeno] = $name unless defined $type[$typeno];
+	printf "new type $typeno is $name" if $debug;
+	if ($extra =~ /\*/ && defined $type[$struct]) {
+	    print ", a typedef for a pointer to " , $type[$struct] if $debug;
+	}
+    } else {
+	printf "%s is type %d", $name, $typeno if $debug;
+	print ", a typedef for " , $type[$typeno] if $debug;
+    } 
+    print "\n" if $debug;
+    #next unless $extra =~ /[su*]/;
+
+    #$type[$struct] = $name;
+
+    if ($extra =~ /[us*]/) {
+	&sou($name, $extra);
+	$_ = &sdecl($name, $_, 0);
+    }
+    elsif (/^=ar/) {
+	print "it's a bare array typedef -- that's pretty sick\n" if $debug;
+	$_ = "$typeno$_";
+	$scripts = '';
+	$_ = &adecl($_,1);
+
+    }
+    elsif (s/((\w+):t(\d+|\(\d+,\d+\)))?=r?(;\d+;\d+;)?//) {  # the ?'s are for gcc
+	push(@intrinsics, $2);
+	$typeno = &typeno($3);
+	$type[$typeno] = $2;
+	print STDERR "intrinsic $2 in new type $typeno\n" if $debug; 
+    }
+    elsif (s/^=e//) { # blessed by thy compiler; mine won't do this
+	&edecl;
+    } 
+    else {
+	warn "Funny remainder for $name on line $_ left in $line " if $_;
+    } 
+}
+
+sub typeno {  # sun thinks types are (0,27) instead of just 27
+    local($_) = @_;
+    s/\(\d+,(\d+)\)/$1/;
+    $_;
+} 
+
+sub pstruct {
+    local($what,$prefix,$base) = @_; 
+    local($field, $fieldname, $typeno, $count, $offset, $entry); 
+    local($fieldtype);
+    local($type, $tname); 
+    local($mytype, $mycount, $entry2);
+    local($struct_count) = 0;
+    local($pad, $revpad, $length, $prepad, $lastoffset, $lastlength, $fmt);
+    local($bits,$bytes);
+    local($template);
+
+
+    local($mname) = &munge($name);
+
+    sub munge { 
+	local($_) = @_;
+	s/[\s\$\.]/_/g;
+	$_;
+    }
+
+    local($sname) = &psou($what);
+
+    $nesting++;
+
+    for $field (split(/;/, $struct{$what})) {
+	$pad = $prepad = 0;
+	$entry = ''; 
+	($fieldname, $typeno, $count, $offset, $length) = split(/,/, $field); 
+
+	$type = $type[$typeno];
+
+	$type =~ /([^[]*)(\[.*\])?/;
+	$mytype = $1;
+	$count .= $2;
+	$fieldtype = &psou($mytype);
+
+	local($fname) = &psou($name);
+
+	if ($build_templates) {
+
+	    $pad = ($offset - ($lastoffset + $lastlength))/8 
+		if defined $lastoffset;
+
+	    if (! $finished_template{$sname}) {
+		if ($isaunion{$what}) {
+		    $template{$sname} .= 'X' x $revpad . ' '    if $revpad;
+		} else {
+		    $template{$sname} .= 'x' x $pad    . ' '    if $pad;
+		}
+	    }
+
+	    $template = &fetch_template($type) x 
+			    ($count ? &scripts2count($count) : 1);
+
+	    if (! $finished_template{$sname}) {
+		$template{$sname} .= $template;
+	    }
+
+	    $revpad = $length/8 if $isaunion{$what};
+
+	    ($lastoffset, $lastlength) = ($offset, $length);
+
+	} else { 
+	    print '# ' if $perl && $verbose;
+	    $entry = sprintf($pmask1,
+			' ' x ($nesting * $indent) . $fieldtype,
+			"$prefix.$fieldname" . $count); 
+
+	    $entry =~ s/(\*+)( )/$2$1/; 
+
+	    printf $pmask2,
+		    $entry,
+		    ($base+$offset)/8,
+		    ($bits = ($base+$offset)%8) ? ".$bits" : "  ",
+		    $length/8,
+		    ($bits = $length % 8) ? ".$bits": ""
+			if !$perl || $verbose;
+
+
+	    if ($perl && $nesting == 1) {
+		$template = &scrunch(&fetch_template($type) x 
+				($count ? &scripts2count($count) : 1));
+		push(@sizeof, int($length/8) .",\t# $fieldname");
+		push(@offsetof, int($offset/8) .",\t# $fieldname");
+		push(@typedef, "'$template', \t# $fieldname");
+		$type =~ s/(struct|union) //;
+		push(@typeof, "'$type" . ($count ? $count : '') .
+		    "',\t# $fieldname");
+	    }
+
+	    print '  ', ' ' x $indent x $nesting, $template
+				if $perl && $verbose;
+
+	    print "\n" if !$perl || $verbose;
+
+	}    
+	if ($perl) {
+	    local($mycount) = defined $struct{$mytype} ? $countof{$mytype} : 1;
+	    $mycount *= &scripts2count($count) if $count;
+	    if ($nesting==1 && !$build_templates) {
+		$pcode .= sprintf("sub %-32s { %4d; }\n", 
+			"${mname}'${fieldname}", $struct_count);
+		push(@indices, $struct_count);
+	    }
+	    $struct_count += $mycount;
+	} 
+
+
+	&pstruct($type, "$prefix.$fieldname", $base+$offset) 
+		if $recurse && defined $struct{$type}; 
+    }
+
+    $countof{$what} = $struct_count unless defined $countof{$whati};
+
+    $template{$sname} .= '$' if $build_templates;
+    $finished_template{$sname}++;
+
+    if ($build_templates && !defined $sizeof{$name}) {
+	local($fmt) = &scrunch($template{$sname});
+	print STDERR "no size for $name, punting with $fmt..." if $debug;
+	eval '$sizeof{$name} = length(pack($fmt, ()))';
+	if ($@) {
+	    chop $@;
+	    warn "couldn't get size for \$name: $@";
+	} else {
+	    print STDERR $sizeof{$name}, "\n" if $debUg;
+	}
+    } 
+
+    --$nesting;
+}
+
+
+sub psize {
+    local($me) = @_; 
+    local($amstruct) = $struct{$me} ?  'struct ' : '';
+
+    print '$sizeof{\'', $amstruct, $me, '\'} = '; 
+    printf "%d;\n", $sizeof{$me}; 
+}
+
+sub pdecl {
+    local($pdecl) = @_;
+    local(@pdecls);
+    local($tname);
+
+    warn "pdecl: $pdecl\n" if $debug;
+
+    $pdecl =~ s/\(\d+,(\d+)\)/$1/g;
+    $pdecl =~ s/\*//g; 
+    @pdecls = split(/=/, $pdecl); 
+    $typeno = $pdecls[0];
+    $tname = pop @pdecls;
+
+    if ($tname =~ s/^f//) { $tname = "$tname&"; } 
+    #else { $tname = "$tname*"; } 
+
+    for (reverse @pdecls) {
+	$tname  .= s/^f// ? "&" : "*"; 
+	#$tname =~ s/^f(.*)/$1&/;
+	print "type[$_] is $tname\n" if $debug;
+	$type[$_] = $tname unless defined $type[$_];
+    } 
+}
+
+
+
+sub adecl {
+    ($arraytype, $unknown, $lower, $upper) = ();
+    #local($typeno);
+    # global $typeno, @type
+    local($_, $typedef) = @_;
+
+    while (s/^((\d+)=)?ar(\d+);//) {
+	($arraytype, $unknown) = ($2, $3); 
+	if (s/^(\d+);(\d+);//) {
+	    ($lower, $upper) = ($1, $2); 
+	    $scripts .= '[' .  ($upper+1) . ']'; 
+	} else {
+	    warn "can't find array bounds: $_"; 
+	} 
+    }
+    if (s/^([\d*f=]*),(\d+),(\d+);//) {
+	($start, $length) = ($2, $3); 
+	local($whatis) = $1;
+	if ($whatis =~ /^(\d+)=/) {
+	    $typeno = $1;
+	    &pdecl($whatis);
+	} else {
+	    $typeno = $whatis;
+	}
+    } elsif (s/^(\d+)(=[*suf]\d*)//) {
+	local($whatis) = $2; 
+
+	if ($whatis =~ /[f*]/) {
+	    &pdecl($whatis); 
+	} elsif ($whatis =~ /[su]/) {  # 
+	    print "$prefix.$fieldname is an array$scripts anon structs; disgusting\n" 
+		if $debug;
+	    #$type[$typeno] = $name unless defined $type[$typeno];
+	    ##printf "new type $typeno is $name" if $debug;
+	    $typeno = $1;
+	    $type[$typeno] = "$prefix.$fieldname";
+	    local($name) = $type[$typeno];
+	    &sou($name, $whatis);
+	    $_ = &sdecl($name, $_, $start+$offset);
+	    1;
+	    $start = $start{$name};
+	    $offset = $sizeof{$name};
+	    $length = $offset;
+	} else {
+	    warn "what's this? $whatis in $line ";
+	} 
+    } elsif (/^\d+$/) {
+	$typeno = $_;
+    } else {
+	warn "bad array stab: $_ in $line ";
+	next STAB;
+    } 
+    #local($wasdef) = defined($type[$typeno]) && $debug;
+    #if ($typedef) { 
+	#print "redefining $type[$typeno] to " if $wasdef;
+	#$type[$typeno] = "$whatis$scripts"; # unless defined $type[$typeno];
+	#print "$type[$typeno]\n" if $wasdef;
+    #} else {
+	#$type[$arraytype] = $type[$typeno] unless defined $type[$arraytype];
+    #}
+    $type[$arraytype] = "$type[$typeno]$scripts" if defined $type[$typeno];
+    print "type[$arraytype] is $type[$arraytype]\n" if $debug;
+    print "$prefix.$fieldname is an array of $type[$arraytype]\n" if $debug;
+    $_;
+}
+
+
+
+sub sdecl {
+    local($prefix, $_, $offset) = @_;
+
+    local($fieldname, $scripts, $type, $arraytype, $unknown,
+    $whatis, $pdecl, $upper,$lower, $start,$length) = ();
+    local($typeno,$sou);
+
+
+SFIELD:
+    while (/^([^;]+);/) {
+	$scripts = '';
+	warn "sdecl $_\n" if $debug;
+	if (s/^([\$\w]+)://) { 
+	    $fieldname = $1;
+	} elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { # 
+	    $typeno = &typeno($1);
+	    $type[$typeno] = "$prefix.$fieldname";
+	    local($name) = "$prefix.$fieldname";
+	    &sou($name,$2);
+	    $_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
+	    $start = $start{$name};
+	    $offset += $sizeof{$name};
+	    #print "done with anon, start is $start, offset is $offset\n";
+	    #next SFIELD;
+	} else  {
+	    warn "weird field $_ of $line" if $debug;
+	    next STAB;
+	    #$fieldname = &gensym;
+	    #$_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
+	}
+
+	if (/^\d+=ar/) {
+	    $_ = &adecl($_);
+	}
+	elsif (s/^(\d+|\(\d+,\d+\))?,(\d+),(\d+);//) {
+	    ($start, $length) =  ($2, $3); 
+	    &panic("no length?") unless $length;
+	    $typeno = &typeno($1) if $1;
+	}
+	elsif (s/^((\d+|\(\d+,\d+\))(=[*f](\d+|\(\d+,\d+\)))+),(\d+),(\d+);//) {
+	    ($pdecl, $start, $length) =  ($1,$5,$6); 
+	    &pdecl($pdecl); 
+	}
+	elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { # the dratted anon struct
+	    ($typeno, $sou) = ($1, $2);
+	    $typeno = &typeno($typeno);
+	    if (defined($type[$typeno])) {
+		warn "now how did we get type $1 in $fieldname of $line?";
+	    } else {
+		print "anon type $typeno is $prefix.$fieldname\n" if $debug;
+		$type[$typeno] = "$prefix.$fieldname" unless defined $type[$typeno];
+	    };
+	    local($name) = "$prefix.$fieldname";
+	    &sou($name,$sou);
+	    print "anon ".($isastruct{$name}) ? "struct":"union"." for $prefix.$fieldname\n" if $debug;
+	    $type[$typeno] = "$prefix.$fieldname";
+	    $_ = &sdecl("$prefix.$fieldname", $_, $start+$offset); 
+	    $start = $start{$name};
+	    $length = $sizeof{$name};
+	}
+	else {
+	    warn "can't grok stab for $name ($_) in line $line "; 
+	    next STAB; 
+	}
+
+	&panic("no length for $prefix.$fieldname") unless $length;
+	$struct{$name} .= join(',', $fieldname, $typeno, $scripts, $start, $length) . ';';
+    }
+    if (s/;\d*,(\d+),(\d+);//) {
+	local($start, $size) = ($1, $2); 
+	$sizeof{$prefix} = $size;
+	print "start of $prefix is $start, size of $sizeof{$prefix}\n" if $debug; 
+	$start{$prefix} = $start; 
+    } 
+    $_;
+}
+
+sub edecl {
+    s/;$//;
+    $enum{$name} = $_;
+    $_ = '';
+} 
+
+sub resolve_types {
+    local($sou);
+    for $i (0 .. $#type) {
+	next unless defined $type[$i];
+	$_ = $type[$i];
+	unless (/\d/) {
+	    print "type[$i] $type[$i]\n" if $debug;
+	    next;
+	}
+	print "type[$i] $_ ==> " if $debug;
+	s/^(\d+)(\**)\&\*(\**)/"$2($3".&type($1) . ')()'/e;
+	s/^(\d+)\&/&type($1)/e; 
+	s/^(\d+)/&type($1)/e; 
+	s/(\*+)([^*]+)(\*+)/$1$3$2/;
+	s/\((\*+)(\w+)(\*+)\)/$3($1$2)/;
+	s/^(\d+)([\*\[].*)/&type($1).$2/e;
+	#s/(\d+)(\*|(\[[\[\]\d\*]+]\])+)/&type($1).$2/ge;
+	$type[$i] = $_;
+	print "$_\n" if $debug;
+    }
+}
+sub type { &psou($type[$_[0]] || "<UNDEFINED>"); } 
+
+sub adjust_start_addrs {
+    for (sort keys %start) {
+	($basename = $_) =~ s/\.[^.]+$//;
+	$start{$_} += $start{$basename};
+	print "start: $_ @ $start{$_}\n" if $debug;
+    }
+}
+
+sub sou {
+    local($what, $_) = @_;
+    /u/ && $isaunion{$what}++;
+    /s/ && $isastruct{$what}++;
+}
+
+sub psou {
+    local($what) = @_;
+    local($prefix) = '';
+    if ($isaunion{$what})  {
+	$prefix = 'union ';
+    } elsif ($isastruct{$what})  {
+	$prefix = 'struct ';
+    }
+    $prefix . $what;
+}
+
+sub scrunch {
+    local($_) = @_;
+
+    study;
+
+    s/\$//g;
+    s/  / /g;
+    1 while s/(\w) \1/$1$1/g;
+
+    # i wanna say this, but perl resists my efforts:
+    #	   s/(\w)(\1+)/$2 . length($1)/ge;
+
+    &quick_scrunch;
+
+    s/ $//;
+
+    $_;
+}
+
+sub buildscrunchlist {
+    $scrunch_code = "sub quick_scrunch {\n";
+    for (values %intrinsics) {
+        $scrunch_code .= "\ts/($_{2,})/'$_' . length(\$1)/ge;\n";
+    } 
+    $scrunch_code .= "}\n";
+    print "$scrunch_code" if $debug;
+    eval $scrunch_code;
+    &panic("can't eval scrunch_code $@ \nscrunch_code") if $@;
+} 
+
+sub fetch_template {
+    local($mytype) = @_;
+    local($fmt);
+    local($count) = 1;
+
+    &panic("why do you care?") unless $perl;
+
+    if ($mytype =~ s/(\[\d+\])+$//) {
+	$count .= $1;
+    } 
+
+    if ($mytype =~ /\*/) {
+	$fmt = $template{'pointer'};
+    } 
+    elsif (defined $template{$mytype}) {
+	$fmt = $template{$mytype};
+    } 
+    elsif (defined $struct{$mytype}) {
+	if (!defined $template{&psou($mytype)}) {
+	    &build_template($mytype) unless $mytype eq $name;
+	} 
+	elsif ($template{&psou($mytype)} !~ /\$$/) {
+	    #warn "incomplete template for $mytype\n";
+	} 
+	$fmt = $template{&psou($mytype)} || '?';
+    } 
+    else {
+	warn "unknown fmt for $mytype\n";
+	$fmt = '?';
+    } 
+
+    $fmt x $count . ' ';
+}
+
+sub compute_intrinsics {
+    local($TMP) = "/tmp/c2ph-i.$$.c";
+    open (TMP, ">$TMP") || die "can't open $TMP: $!";
+    select(TMP);
+
+    print STDERR "computing intrinsic sizes: " if $trace;
+
+    undef %intrinsics;
+
+    print <<'EOF';
+main() {
+    char *mask = "%d %s\n";
+EOF
+
+    for $type (@intrinsics) {
+	next if $type eq 'void';
+	print <<"EOF";
+    printf(mask,sizeof($type), "$type");
+EOF
+    } 
+
+    print <<'EOF';
+    printf(mask,sizeof(char *), "pointer");
+    exit(0);
+}
+EOF
+    close TMP;
+
+    select(STDOUT);
+    open(PIPE, "cd /tmp && $CC $TMP && /tmp/a.out|");
+    while (<PIPE>) {
+	chop;
+	split(' ',$_,2);;
+	print "intrinsic $_[1] is size $_[0]\n" if $debug;
+	$sizeof{$_[1]} = $_[0];
+	$intrinsics{$_[1]} = $template{$_[0]};
+    } 
+    close(PIPE) || die "couldn't read intrinsics!";
+    unlink($TMP, '/tmp/a.out');
+    print STDERR "done\n" if $trace;
+} 
+
+sub scripts2count {
+    local($_) = @_;
+
+    s/^\[//;
+    s/\]$//;
+    s/\]\[/*/g;
+    $_ = eval;
+    &panic("$_: $@") if $@;
+    $_;
+}
+
+sub system {
+    print STDERR "@_\n" if $trace;
+    system @_;
+} 
+
+sub build_template { 
+    local($name) = @_;
+
+    &panic("already got a template for $name") if defined $template{$name};
+
+    local($build_templates) = 1;
+
+    local($lparen) = '(' x $build_recursed;
+    local($rparen) = ')' x $build_recursed;
+
+    print STDERR "$lparen$name$rparen " if $trace;
+    $build_recursed++;
+    &pstruct($name,$name,0);
+    print STDERR "TEMPLATE for $name is ", $template{&psou($name)}, "\n" if $debug;
+    --$build_recursed;
+}
+
+
+sub panic {
+
+    select(STDERR);
+
+    print "\npanic: @_\n";
+
+    exit 1 if $] <= 4.003;  # caller broken
+
+    local($i,$_);
+    local($p,$f,$l,$s,$h,$a,@a,@sub);
+    for ($i = 0; ($p,$f,$l,$s,$h,$w) = caller($i); $i++) {
+	@a = @DB'args;
+	for (@a) {
+	    if (/^StB\000/ && length($_) == length($_main{'_main'})) {
+		$_ = sprintf("%s",$_);
+	    }
+	    else {
+		s/'/\\'/g;
+		s/([^\0]*)/'$1'/ unless /^-?[\d.]+$/;
+		s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
+		s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
+	    }
+	}
+	$w = $w ? '@ = ' : '$ = ';
+	$a = $h ? '(' . join(', ', @a) . ')' : '';
+	push(@sub, "$w&$s$a from file $f line $l\n");
+	last if $signal;
+    }
+    for ($i=0; $i <= $#sub; $i++) {
+	last if $signal;
+	print $sub[$i];
+    }
+    exit 1;
+} 
+
+sub squishseq {
+    local($num);
+    local($last) = -1e8;
+    local($string);
+    local($seq) = '..';
+
+    while (defined($num = shift)) {
+        if ($num == ($last + 1)) {
+            $string .= $seq unless $inseq++;
+            $last = $num;
+            next;
+        } elsif ($inseq) {
+            $string .= $last unless $last == -1e8;
+        }
+
+        $string .= ',' if defined $string;
+        $string .= $num;
+        $last = $num;
+        $inseq = 0;
+    }
+    $string .= $last if $inseq && $last != -e18;
+    $string;
+}
diff -u --new-file --recursive perl-4.036.orig/cflags perl-4.036/cflags
--- perl-4.036.orig/cflags	Wed Dec 31 18:00:00 1969
+++ perl-4.036/cflags	Tue Jan 17 21:16:27 1995
@@ -0,0 +1,91 @@
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+case $CONFIG in
+'')
+    if test ! -f config.sh; then
+	ln ../config.sh . || \
+	ln ../../config.sh . || \
+	ln ../../../config.sh . || \
+	(echo "Can't find config.sh."; exit 1)
+    fi 2>/dev/null
+    . ./config.sh
+    ;;
+esac
+
+also=': '
+case $# in
+1) also='echo 1>&2 "	  CCCMD = "'
+esac
+
+case $# in
+0) set *.c; echo "The current C flags are:" ;;
+esac
+
+set `echo "$* " | sed 's/\.[oc] / /g'`
+
+for file do
+
+    case "$#" in
+    1) ;;
+    *) echo $n "    $file.c	$c" ;;
+    esac
+
+    : allow variables like toke_cflags to be evaluated
+
+    eval 'eval ${'"${file}_cflags"'-""}'
+
+    : or customize here
+
+    case "$file" in
+    array) ;;
+    cmd) ;;
+    cons) ;;
+    consarg) ;;
+    doarg) ;;
+    doio) ;;
+    dolist) ;;
+    dump) ;;
+    eval) ;;
+    form) ;;
+    hash) ;;
+    malloc) ;;
+    perl) ;;
+    perly) ;;
+    regcomp) ;;
+    regexec) ;;
+    stab) ;;
+    str) ;;
+    toke) ;;
+    usersub) ;;
+    util) ;;
+    tarray) ;;
+    tcmd) ;;
+    tcons) ;;
+    tconsarg) ;;
+    tdoarg) ;;
+    tdoio) ;;
+    tdolist) ;;
+    tdump) ;;
+    teval) ;;
+    tform) ;;
+    thash) ;;
+    tmalloc) ;;
+    tperl) ;;
+    tperly) ;;
+    tregcomp) ;;
+    tregexec) ;;
+    tstab) ;;
+    tstr) ;;
+    ttoke) ;;
+    tusersub) ;;
+    tutil) ;;
+    *) ;;
+    esac
+
+    echo "$cc -c $ccflags $optimize $large $split"
+    eval "$also "'"$cc -c $ccflags $optimize $large $split"'
+
+    . ./config.sh
+
+done
diff -u --new-file --recursive perl-4.036.orig/config.h perl-4.036/config.h
--- perl-4.036.orig/config.h	Wed Dec 31 18:00:00 1969
+++ perl-4.036/config.h	Tue Jan 17 21:16:28 1995
@@ -0,0 +1,892 @@
+#ifndef config_h
+#define config_h
+/* config.h
+ * This file was produced by running the config.h.SH script, which
+ * gets its values from config.sh, which is generally produced by
+ * running Configure.
+ *
+ * Feel free to modify any of this as the need arises.  Note, however,
+ * that running config.h.SH again will wipe out any changes you've made.
+ * For a more permanent change edit config.sh and rerun config.h.SH.
+ */
+ /*SUPPRESS 460*/
+
+
+/* EUNICE
+ *	This symbol, if defined, indicates that the program is being compiled
+ *	under the EUNICE package under VMS.  The program will need to handle
+ *	things like files that don't go away the first time you unlink them,
+ *	due to version numbering.  It will also need to compensate for lack
+ *	of a respectable link() command.
+ */
+/* VMS
+ *	This symbol, if defined, indicates that the program is running under
+ *	VMS.  It is currently only set in conjunction with the EUNICE symbol.
+ */
+/*#undef	EUNICE		/**/
+/*#undef	VMS		/**/
+
+/* LOC_SED
+ *     This symbol holds the complete pathname to the sed program.
+ */
+#define LOC_SED "/usr/bin/sed"             /**/
+
+/* ALIGNBYTES
+ *	This symbol contains the number of bytes required to align a double.
+ *	Usual values are 2, 4, and 8.
+ */
+#define ALIGNBYTES 4		/**/
+
+/* BIN
+ *	This symbol holds the name of the directory in which the user wants
+ *	to keep publicly executable images for the package in question.  It
+ *	is most often a local directory such as /usr/local/bin.
+ */
+#define BIN "/usr/bin"             /**/
+
+/* BYTEORDER
+ *	This symbol contains an encoding of the order of bytes in a long.
+ *	Usual values (in hex) are 0x1234, 0x4321, 0x2143, 0x3412...
+ */
+#define BYTEORDER 0x1234		/**/
+
+/* CPPSTDIN
+ *	This symbol contains the first part of the string which will invoke
+ *	the C preprocessor on the standard input and produce to standard
+ *	output.	 Typical value of "cc -E" or "/lib/cpp".
+ */
+/* CPPMINUS
+ *	This symbol contains the second part of the string which will invoke
+ *	the C preprocessor on the standard input and produce to standard
+ *	output.  This symbol will have the value "-" if CPPSTDIN needs a minus
+ *	to specify standard input, otherwise the value is "".
+ */
+#define CPPSTDIN "cppstdin"
+#define CPPMINUS ""
+
+/* HAS_BCMP
+ *	This symbol, if defined, indicates that the bcmp routine is available
+ *	to compare blocks of memory.  If undefined, use memcmp.  If that's
+ *	not available, roll your own.
+ */
+#define	HAS_BCMP		/**/
+
+/* HAS_BCOPY
+ *	This symbol, if defined, indicates that the bcopy routine is available
+ *	to copy blocks of memory.  Otherwise you should probably use memcpy().
+ *	If neither is defined, roll your own.
+ */
+/* SAFE_BCOPY
+ *	This symbol, if defined, indicates that the bcopy routine is available
+ *	to copy potentially overlapping copy blocks of bcopy.  Otherwise you
+ *	should probably use memmove() or memcpy().  If neither is defined,
+ *	roll your own.
+ */
+#define	HAS_BCOPY		/**/
+#define	SAFE_BCOPY		/**/
+
+/* HAS_BZERO
+ *	This symbol, if defined, indicates that the bzero routine is available
+ *	to zero blocks of memory.  Otherwise you should probably use memset()
+ *	or roll your own.
+ */
+#define	HAS_BZERO		/**/
+
+/* CASTNEGFLOAT
+ *	This symbol, if defined, indicates that this C compiler knows how to
+ *	cast negative or large floating point numbers to unsigned longs, ints
+ *	and shorts.
+ */
+/* CASTFLAGS
+ *	This symbol contains flags that say what difficulties the compiler
+ *	has casting odd floating values to unsigned long:
+ *		1 = couldn't cast < 0
+ *		2 = couldn't cast >= 0x80000000
+ */
+#define	CASTNEGFLOAT	/**/
+#define	CASTFLAGS 0	/**/
+
+/* CHARSPRINTF
+ *	This symbol is defined if this system declares "char *sprintf()" in
+ *	stdio.h.  The trend seems to be to declare it as "int sprintf()".  It
+ *	is up to the package author to declare sprintf correctly based on the
+ *	symbol.
+ */
+/*#undef	CHARSPRINTF 	/**/
+
+/* HAS_CHSIZE
+ *	This symbol, if defined, indicates that the chsize routine is available
+ *	to truncate files.  You might need a -lx to get this routine.
+ */
+/*#undef	HAS_CHSIZE		/**/
+
+/* HAS_CRYPT
+ *	This symbol, if defined, indicates that the crypt routine is available
+ *	to encrypt passwords and the like.
+ */
+#define	HAS_CRYPT		/**/
+
+/* CSH
+ *	This symbol, if defined, indicates that the C-shell exists.
+ *	If defined, contains the full pathname of csh.
+ */
+#define CSH "/bin/csh"		/**/
+
+/* DOSUID
+ *	This symbol, if defined, indicates that the C program should
+ *	check the script that it is executing for setuid/setgid bits, and
+ *	attempt to emulate setuid/setgid on systems that have disabled
+ *	setuid #! scripts because the kernel can't do it securely.
+ *	It is up to the package designer to make sure that this emulation
+ *	is done securely.  Among other things, it should do an fstat on
+ *	the script it just opened to make sure it really is a setuid/setgid
+ *	script, it should make sure the arguments passed correspond exactly
+ *	to the argument on the #! line, and it should not trust any
+ *	subprocesses to which it must pass the filename rather than the
+ *	file descriptor of the script to be executed.
+ */
+/*#undef DOSUID		/**/
+
+/* HAS_DUP2
+ *	This symbol, if defined, indicates that the dup2 routine is available
+ *	to dup file descriptors.  Otherwise you should use dup().
+ */
+#define	HAS_DUP2		/**/
+
+/* HAS_FCHMOD
+ *	This symbol, if defined, indicates that the fchmod routine is available
+ *	to change mode of opened files.  If unavailable, use chmod().
+ */
+#define	HAS_FCHMOD		/**/
+
+/* HAS_FCHOWN
+ *	This symbol, if defined, indicates that the fchown routine is available
+ *	to change ownership of opened files.  If unavailable, use chown().
+ */
+#define	HAS_FCHOWN		/**/
+
+/* HAS_FCNTL
+ *	This symbol, if defined, indicates to the C program that
+ *	the fcntl() function exists.
+ */
+#define	HAS_FCNTL		/**/
+
+/* FLEXFILENAMES
+ *	This symbol, if defined, indicates that the system supports filenames
+ *	longer than 14 characters.
+ */
+#define	FLEXFILENAMES		/**/
+
+/* HAS_FLOCK
+ *	This symbol, if defined, indicates that the flock() routine is
+ *	available to do file locking.
+ */
+#define	HAS_FLOCK		/**/
+
+/* HAS_GETGROUPS
+ *	This symbol, if defined, indicates that the getgroups() routine is
+ *	available to get the list of process groups.  If unavailable, multiple
+ *	groups are probably not supported.
+ */
+/*#undef	HAS_GETGROUPS		/**/
+
+/* HAS_GETHOSTENT
+ *	This symbol, if defined, indicates that the gethostent() routine is
+ *	available to lookup host names in some data base or other.
+ */
+/*#undef	HAS_GETHOSTENT		/**/
+
+/* HAS_GETPGRP
+ *	This symbol, if defined, indicates that the getpgrp() routine is
+ *	available to get the current process group.
+ */
+#define	HAS_GETPGRP		/**/
+
+/* HAS_GETPGRP2
+ *	This symbol, if defined, indicates that the getpgrp2() (as in DG/UX)
+ *	routine is available to get the current process group.
+ */
+/*#undef	HAS_GETPGRP2		/**/
+
+/* HAS_GETPRIORITY
+ *	This symbol, if defined, indicates that the getpriority() routine is
+ *	available to get a process's priority.
+ */
+/*#undef	HAS_GETPRIORITY		/**/
+
+/* HAS_HTONS
+ *	This symbol, if defined, indicates that the htons routine (and friends)
+ *	are available to do network order byte swapping.
+ */
+/* HAS_HTONL
+ *	This symbol, if defined, indicates that the htonl routine (and friends)
+ *	are available to do network order byte swapping.
+ */
+/* HAS_NTOHS
+ *	This symbol, if defined, indicates that the ntohs routine (and friends)
+ *	are available to do network order byte swapping.
+ */
+/* HAS_NTOHL
+ *	This symbol, if defined, indicates that the ntohl routine (and friends)
+ *	are available to do network order byte swapping.
+ */
+/*#undef	HAS_HTONS	/**/
+/*#undef	HAS_HTONL	/**/
+/*#undef	HAS_NTOHS	/**/
+/*#undef	HAS_NTOHL	/**/
+
+/* index
+ *	This preprocessor symbol is defined, along with rindex, if the system
+ *	uses the strchr and strrchr routines instead.
+ */
+/* rindex
+ *	This preprocessor symbol is defined, along with index, if the system
+ *	uses the strchr and strrchr routines instead.
+ */
+/*#undef	index strchr	/* cultural */
+/*#undef	rindex strrchr	/*  differences? */
+
+/* HAS_ISASCII
+ *	This symbol, if defined, indicates that the isascii routine is available
+ *	to test characters for asciiness.
+ */
+/*#undef	HAS_ISASCII		/**/
+
+/* HAS_KILLPG
+ *	This symbol, if defined, indicates that the killpg routine is available
+ *	to kill process groups.  If unavailable, you probably should use kill
+ *	with a negative process number.
+ */
+#define	HAS_KILLPG		/**/
+
+/* HAS_LSTAT
+ *	This symbol, if defined, indicates that the lstat() routine is
+ *	available to stat symbolic links.
+ */
+#define	HAS_LSTAT		/**/
+
+/* HAS_MEMCMP
+ *	This symbol, if defined, indicates that the memcmp routine is available
+ *	to compare blocks of memory.  If undefined, roll your own.
+ */
+#define	HAS_MEMCMP		/**/
+
+/* HAS_MEMCPY
+ *	This symbol, if defined, indicates that the memcpy routine is available
+ *	to copy blocks of memory.  Otherwise you should probably use bcopy().
+ *	If neither is defined, roll your own.
+ */
+/* SAFE_MEMCPY
+ *	This symbol, if defined, indicates that the memcpy routine is available
+ *	to copy potentially overlapping copy blocks of memory.  Otherwise you
+ *	should probably use memmove() or bcopy().  If neither is defined,
+ *	roll your own.
+ */
+#define	HAS_MEMCPY		/**/
+/*#undef	SAFE_MEMCPY		/**/
+
+/* HAS_MEMMOVE
+ *	This symbol, if defined, indicates that the memmove routine is available
+ *	to move potentially overlapping blocks of memory.  Otherwise you
+ *	should use bcopy() or roll your own.
+ */
+#define	HAS_MEMMOVE		/**/
+
+/* HAS_MEMSET
+ *	This symbol, if defined, indicates that the memset routine is available
+ *	to set a block of memory to a character.  If undefined, roll your own.
+ */
+#define	HAS_MEMSET		/**/
+
+/* HAS_MKDIR
+ *	This symbol, if defined, indicates that the mkdir routine is available
+ *	to create directories.  Otherwise you should fork off a new process to
+ *	exec /bin/mkdir.
+ */
+#define	HAS_MKDIR		/**/
+
+/* HAS_MSG
+ *	This symbol, if defined, indicates that the entire msg*(2) library is
+ *	supported.
+ */
+#define	HAS_MSG		/**/
+
+/* HAS_MSGCTL
+ *	This symbol, if defined, indicates that the msgctl() routine is
+ *	available to control message passing.
+ */
+#define	HAS_MSGCTL		/**/
+
+/* HAS_MSGGET
+ *	This symbol, if defined, indicates that the msgget() routine is
+ *	available to get messages.
+ */
+#define	HAS_MSGGET		/**/
+
+/* HAS_MSGRCV
+ *	This symbol, if defined, indicates that the msgrcv() routine is
+ *	available to receive messages.
+ */
+#define	HAS_MSGRCV		/**/
+
+/* HAS_MSGSND
+ *	This symbol, if defined, indicates that the msgsnd() routine is
+ *	available to send messages.
+ */
+#define	HAS_MSGSND		/**/
+
+/* HAS_NDBM
+ *	This symbol, if defined, indicates that ndbm.h exists and should
+ *	be included.
+ */
+#define	HAS_NDBM		/**/
+
+/* HAS_ODBM
+ *	This symbol, if defined, indicates that dbm.h exists and should
+ *	be included.
+ */
+#define	HAS_ODBM		/**/
+
+/* HAS_OPEN3
+ *	This manifest constant lets the C program know that the three
+ *	argument form of open(2) is available.
+ */
+#define	HAS_OPEN3		/**/
+
+/* HAS_READDIR
+ *	This symbol, if defined, indicates that the readdir routine is available
+ *	from the C library to read directories.
+ */
+#define	HAS_READDIR		/**/
+
+/* HAS_RENAME
+ *	This symbol, if defined, indicates that the rename routine is available
+ *	to rename files.  Otherwise you should do the unlink(), link(), unlink()
+ *	trick.
+ */
+#define	HAS_RENAME		/**/
+
+/* HAS_REWINDDIR
+ *	This symbol, if defined, indicates that the rewindir routine is
+ *	available to rewind directories.
+ */
+#define	HAS_REWINDDIR		/**/
+
+/* HAS_RMDIR
+ *	This symbol, if defined, indicates that the rmdir routine is available
+ *	to remove directories.  Otherwise you should fork off a new process to
+ *	exec /bin/rmdir.
+ */
+#define	HAS_RMDIR		/**/
+
+/* HAS_SEEKDIR
+ *	This symbol, if defined, indicates that the seekdir routine is
+ *	available to seek into directories.
+ */
+#define	HAS_SEEKDIR		/**/
+
+/* HAS_SELECT
+ *	This symbol, if defined, indicates that the select() subroutine
+ *	exists.
+ */
+#define	HAS_SELECT	/**/
+
+/* HAS_SEM
+ *	This symbol, if defined, indicates that the entire sem*(2) library is
+ *	supported.
+ */
+#define	HAS_SEM		/**/
+
+/* HAS_SEMCTL
+ *	This symbol, if defined, indicates that the semctl() routine is
+ *	available to control semaphores.
+ */
+#define	HAS_SEMCTL		/**/
+
+/* HAS_SEMGET
+ *	This symbol, if defined, indicates that the semget() routine is
+ *	available to get semaphores ids.
+ */
+#define	HAS_SEMGET		/**/
+
+/* HAS_SEMOP
+ *	This symbol, if defined, indicates that the semop() routine is
+ *	available to perform semaphore operations.
+ */
+#define	HAS_SEMOP		/**/
+
+/* HAS_SETEGID
+ *	This symbol, if defined, indicates that the setegid routine is available
+ *	to change the effective gid of the current program.
+ */
+#define	HAS_SETEGID		/**/
+
+/* HAS_SETEUID
+ *	This symbol, if defined, indicates that the seteuid routine is available
+ *	to change the effective uid of the current program.
+ */
+#define	HAS_SETEUID		/**/
+
+/* HAS_SETPGRP
+ *	This symbol, if defined, indicates that the setpgrp() routine is
+ *	available to set the current process group.
+ */
+#define	HAS_SETPGRP		/**/
+
+/* HAS_SETPGRP2
+ *	This symbol, if defined, indicates that the setpgrp2() (as in DG/UX)
+ *	routine is available to set the current process group.
+ */
+/*#undef	HAS_SETPGRP2		/**/
+
+/* HAS_SETPRIORITY
+ *	This symbol, if defined, indicates that the setpriority() routine is
+ *	available to set a process's priority.
+ */
+/*#undef	HAS_SETPRIORITY		/**/
+
+/* HAS_SETREGID
+ *	This symbol, if defined, indicates that the setregid routine is
+ *	available to change the real and effective gid of the current program.
+ */
+/* HAS_SETRESGID
+ *	This symbol, if defined, indicates that the setresgid routine is
+ *	available to change the real, effective and saved gid of the current
+ *	program.
+ */
+#define	HAS_SETREGID		/**/
+/*#undef	HAS_SETRESGID		/**/
+
+/* HAS_SETREUID
+ *	This symbol, if defined, indicates that the setreuid routine is
+ *	available to change the real and effective uid of the current program.
+ */
+/* HAS_SETRESUID
+ *	This symbol, if defined, indicates that the setresuid routine is
+ *	available to change the real, effective and saved uid of the current
+ *	program.
+ */
+#define	HAS_SETREUID		/**/
+/*#undef	HAS_SETRESUID		/**/
+
+/* HAS_SETRGID
+ *	This symbol, if defined, indicates that the setrgid routine is available
+ *	to change the real gid of the current program.
+ */
+/*#undef	HAS_SETRGID		/**/
+
+/* HAS_SETRUID
+ *	This symbol, if defined, indicates that the setruid routine is available
+ *	to change the real uid of the current program.
+ */
+/*#undef	HAS_SETRUID		/**/
+
+/* HAS_SHM
+ *	This symbol, if defined, indicates that the entire shm*(2) library is
+ *	supported.
+ */
+#define	HAS_SHM		/**/
+
+/* HAS_SHMAT
+ *	This symbol, if defined, indicates that the shmat() routine is
+ *	available to attach a shared memory segment.
+ */
+/* VOID_SHMAT
+ *	This symbol, if defined, indicates that the shmat() routine
+ *	returns a pointer of type void*.
+ */
+#define	HAS_SHMAT		/**/
+
+/*#undef	VOIDSHMAT		/**/
+
+/* HAS_SHMCTL
+ *	This symbol, if defined, indicates that the shmctl() routine is
+ *	available to control a shared memory segment.
+ */
+#define	HAS_SHMCTL		/**/
+
+/* HAS_SHMDT
+ *	This symbol, if defined, indicates that the shmdt() routine is
+ *	available to detach a shared memory segment.
+ */
+#define	HAS_SHMDT		/**/
+
+/* HAS_SHMGET
+ *	This symbol, if defined, indicates that the shmget() routine is
+ *	available to get a shared memory segment id.
+ */
+#define	HAS_SHMGET		/**/
+
+/* HAS_SOCKET
+ *	This symbol, if defined, indicates that the BSD socket interface is
+ *	supported.
+ */
+/* HAS_SOCKETPAIR
+ *	This symbol, if defined, indicates that the BSD socketpair call is
+ *	supported.
+ */
+/* OLDSOCKET
+ *	This symbol, if defined, indicates that the 4.1c BSD socket interface
+ *	is supported instead of the 4.2/4.3 BSD socket interface.
+ */
+#define	HAS_SOCKET		/**/
+
+#define	HAS_SOCKETPAIR	/**/
+
+/*#undef	OLDSOCKET	/**/
+
+/* STATBLOCKS
+ *	This symbol is defined if this system has a stat structure declaring
+ *	st_blksize and st_blocks.
+ */
+#define	STATBLOCKS 	/**/
+
+/* STDSTDIO
+ *	This symbol is defined if this system has a FILE structure declaring
+ *	_ptr and _cnt in stdio.h.
+ */
+/*#undef	STDSTDIO 	/**/
+
+/* STRUCTCOPY
+ *	This symbol, if defined, indicates that this C compiler knows how
+ *	to copy structures.  If undefined, you'll need to use a block copy
+ *	routine of some sort instead.
+ */
+#define	STRUCTCOPY	/**/
+
+/* HAS_STRERROR
+ *	This symbol, if defined, indicates that the strerror() routine is
+ *	available to translate error numbers to strings.
+ */
+#define	HAS_STRERROR		/**/
+
+/* HAS_SYMLINK
+ *	This symbol, if defined, indicates that the symlink routine is available
+ *	to create symbolic links.
+ */
+#define	HAS_SYMLINK		/**/
+
+/* HAS_SYSCALL
+ *	This symbol, if defined, indicates that the syscall routine is available
+ *	to call arbitrary system calls.  If undefined, that's tough.
+ */
+#define	HAS_SYSCALL		/**/
+
+/* HAS_TELLDIR
+ *	This symbol, if defined, indicates that the telldir routine is
+ *	available to tell your location in directories.
+ */
+#define	HAS_TELLDIR		/**/
+
+/* HAS_TRUNCATE
+ *	This symbol, if defined, indicates that the truncate routine is
+ *	available to truncate files.
+ */
+#define	HAS_TRUNCATE		/**/
+
+/* HAS_VFORK
+ *	This symbol, if defined, indicates that vfork() exists.
+ */
+#define	HAS_VFORK	/**/
+
+/* VOIDSIG
+ *	This symbol is defined if this system declares "void (*signal())()" in
+ *	signal.h.  The old way was to declare it as "int (*signal())()".  It
+ *	is up to the package author to declare things correctly based on the
+ *	symbol.
+ */
+/* TO_SIGNAL
+ *	This symbol's value is either "void" or "int", corresponding to the
+ *	appropriate return "type" of a signal handler.  Thus, one can declare
+ *	a signal handler using "TO_SIGNAL (*handler())()", and define the
+ *	handler using "TO_SIGNAL handler(sig)".
+ */
+#define	VOIDSIG 	/**/
+#define	TO_SIGNAL	int 	/**/
+
+/* HASVOLATILE
+ *	This symbol, if defined, indicates that this C compiler knows about
+ *	the volatile declaration.
+ */
+#define	HASVOLATILE	/**/
+
+/* HAS_VPRINTF
+ *	This symbol, if defined, indicates that the vprintf routine is available
+ *	to printf with a pointer to an argument list.  If unavailable, you
+ *	may need to write your own, probably in terms of _doprnt().
+ */
+/* CHARVSPRINTF
+ *	This symbol is defined if this system has vsprintf() returning type
+ *	(char*).  The trend seems to be to declare it as "int vsprintf()".  It
+ *	is up to the package author to declare vsprintf correctly based on the
+ *	symbol.
+ */
+#define	HAS_VPRINTF	/**/
+/*#undef	CHARVSPRINTF 	/**/
+
+/* HAS_WAIT4
+ *	This symbol, if defined, indicates that wait4() exists.
+ */
+#define	HAS_WAIT4	/**/
+
+/* HAS_WAITPID
+ *	This symbol, if defined, indicates that waitpid() exists.
+ */
+#define	HAS_WAITPID	/**/
+
+/* GIDTYPE
+ *	This symbol has a value like gid_t, int, ushort, or whatever type is
+ *	used to declare group ids in the kernel.
+ */
+#define GIDTYPE unsigned short		/**/
+
+/* GROUPSTYPE
+ *	This symbol has a value like gid_t, int, ushort, or whatever type is
+ *	used in the return value of getgroups().
+ */
+#define GROUPSTYPE unsigned short		/**/
+
+/* I_FCNTL
+ *	This manifest constant tells the C program to include <fcntl.h>.
+ */
+/*#undef	I_FCNTL	/**/
+
+/* I_GDBM
+ *	This symbol, if defined, indicates that gdbm.h exists and should
+ *	be included.
+ */
+#define	I_GDBM		/**/
+
+/* I_GRP
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include grp.h.
+ */
+#define	I_GRP		/**/
+
+/* I_NETINET_IN
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include netinet/in.h.
+ */
+/* I_SYS_IN
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include sys/in.h.
+ */
+#define	I_NETINET_IN		/**/
+/*#undef	I_SYS_IN		/**/
+
+/* I_PWD
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include pwd.h.
+ */
+/* PWQUOTA
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_quota.
+ */
+/* PWAGE
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_age.
+ */
+/* PWCHANGE
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_change.
+ */
+/* PWCLASS
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_class.
+ */
+/* PWEXPIRE
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_expire.
+ */
+/* PWCOMMENT
+ *	This symbol, if defined, indicates to the C program that struct passwd
+ *	contains pw_comment.
+ */
+#define	I_PWD		/**/
+/*#undef	PWQUOTA		/**/
+/*#undef	PWAGE		/**/
+/*#undef	PWCHANGE	/**/
+/*#undef	PWCLASS		/**/
+/*#undef	PWEXPIRE	/**/
+/*#undef	PWCOMMENT	/**/
+
+/* I_SYS_FILE
+ *	This manifest constant tells the C program to include <sys/file.h>.
+ */
+#define	I_SYS_FILE	/**/
+
+/* I_SYSIOCTL
+ *	This symbol, if defined, indicates that sys/ioctl.h exists and should
+ *	be included.
+ */
+#define	I_SYSIOCTL		/**/
+
+/* I_TIME
+ *	This symbol is defined if the program should include <time.h>.
+ */
+/* I_SYS_TIME
+ *	This symbol is defined if the program should include <sys/time.h>.
+ */
+/* SYSTIMEKERNEL
+ *	This symbol is defined if the program should include <sys/time.h>
+ *	with KERNEL defined.
+ */
+/* I_SYS_SELECT
+ *	This symbol is defined if the program should include <sys/select.h>.
+ */
+/*#undef	I_TIME	 	/**/
+#define	I_SYS_TIME 	/**/
+/*#undef	SYSTIMEKERNEL 	/**/
+/*#undef	I_SYS_SELECT 	/**/
+
+/* I_UTIME
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include utime.h.
+ */
+#define	I_UTIME		/**/
+
+/* I_VARARGS
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include varargs.h.
+ */
+/*#undef	I_VARARGS		/**/
+
+/* I_VFORK
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include vfork.h.
+ */
+/*#undef	I_VFORK		/**/
+
+/* INTSIZE
+ *	This symbol contains the size of an int, so that the C preprocessor
+ *	can make decisions based on it.
+ */
+#define INTSIZE 4		/**/
+
+/* I_DIRENT
+ *	This symbol, if defined, indicates that the program should use the
+ *	P1003-style directory routines, and include <dirent.h>.
+ */
+/* I_SYS_DIR
+ *	This symbol, if defined, indicates that the program should use the
+ *	directory functions by including <sys/dir.h>.
+ */
+/* I_NDIR
+ *	This symbol, if defined, indicates that the program should include the
+ *	system's version of ndir.h, rather than the one with this package.
+ */
+/* I_SYS_NDIR
+ *	This symbol, if defined, indicates that the program should include the
+ *	system's version of sys/ndir.h, rather than the one with this package.
+ */
+/* I_MY_DIR
+ *	This symbol, if defined, indicates that the program should compile
+ *	the ndir.c code provided with the package.
+ */
+/* DIRNAMLEN
+ *	This symbol, if defined, indicates to the C program that the length
+ *	of directory entry names is provided by a d_namlen field.  Otherwise
+ *	you need to do strlen() on the d_name field.
+ */
+#define	I_DIRENT	/**/
+/*#undef	I_SYS_DIR	/**/
+/*#undef	I_NDIR		/**/
+/*#undef	I_SYS_NDIR	/**/
+/*#undef	I_MY_DIR	/**/
+#define	DIRNAMLEN	/**/
+
+/* MYMALLOC
+ *	This symbol, if defined, indicates that we're using our own malloc.
+ */
+/* MALLOCPTRTYPE
+ *	This symbol defines the kind of ptr returned by malloc and realloc.
+ */
+/*#undef MYMALLOC			/**/
+
+#define MALLOCPTRTYPE void         /**/
+
+
+/* RANDBITS
+ *	This symbol contains the number of bits of random number the rand()
+ *	function produces.  Usual values are 15, 16, and 31.
+ */
+#define RANDBITS 31		/**/
+
+/* SCRIPTDIR
+ *	This symbol holds the name of the directory in which the user wants
+ *	to keep publicly executable scripts for the package in question.  It
+ *	is often a directory that is mounted across diverse architectures.
+ */
+#define SCRIPTDIR "/usr/bin"             /**/
+
+/* SIG_NAME
+ *	This symbol contains an list of signal names in order.
+ */
+#define SIG_NAME "ZERO","HUP","INT","QUIT","ILL","TRAP","IOT","BUS","FPE","KILL","USR1","SEGV","USR2","PIPE","ALRM","TERM","STKFLT","CHLD","CONT","STOP","TSTP","TTIN","TTOU","URG","XCPU","XFSZ","VTALRM","PROF","WINCH","LOST","PWR","UNUSED"		/**/
+
+/* STDCHAR
+ *	This symbol is defined to be the type of char used in stdio.h.
+ *	It has the values "unsigned char" or "char".
+ */
+#define STDCHAR char	/**/
+
+/* UIDTYPE
+ *	This symbol has a value like uid_t, int, ushort, or whatever type is
+ *	used to declare user ids in the kernel.
+ */
+#define UIDTYPE unsigned short		/**/
+
+/* VOIDHAVE
+ *	This symbol indicates how much support of the void type is given by this
+ *	compiler.  What various bits mean:
+ *
+ *	    1 = supports declaration of void
+ *	    2 = supports arrays of pointers to functions returning void
+ *	    4 = supports comparisons between pointers to void functions and
+ *		    addresses of void functions
+ *
+ *	The package designer should define VOIDWANT to indicate the requirements
+ *	of the package.  This can be done either by #defining VOIDWANT before
+ *	including config.h, or by defining voidwant in Myinit.U.  If the level
+ *	of void support necessary is not present, config.h defines void to "int",
+ *	VOID to the empty string, and VOIDP to "char *".
+ */
+/* void
+ *	This symbol is used for void casts.  On implementations which support
+ *	void appropriately, its value is "void".  Otherwise, its value maps
+ *	to "int".
+ */
+/* VOID
+ *	This symbol's value is "void" if the implementation supports void
+ *	appropriately.  Otherwise, its value is the empty string.  The primary
+ *	use of this symbol is in specifying void parameter lists for function
+ *	prototypes.
+ */
+/* VOIDP
+ *	This symbol is used for casting generic pointers.  On implementations
+ *	which support void appropriately, its value is "void *".  Otherwise,
+ *	its value is "char *".
+ */
+#ifndef VOIDWANT
+#define VOIDWANT 7
+#endif
+#define VOIDHAVE 7
+#if (VOIDHAVE & VOIDWANT) != VOIDWANT
+#define void int		/* is void to be avoided? */
+#define VOID
+#define VOIDP (char *)
+#define M_VOID		/* Xenix strikes again */
+#else
+#define VOID void
+#define VOIDP (void *)
+#endif
+
+/* PRIVLIB
+ *	This symbol contains the name of the private library for this package.
+ *	The library is private in the sense that it needn't be in anyone's
+ *	execution path, but it should be accessible by the world.  The program
+ *	should be prepared to do ~ expansion.
+ */
+#define PRIVLIB "/usr/lib/perl4"		/**/
+
+#endif
diff -u --new-file --recursive perl-4.036.orig/config.sh perl-4.036/config.sh
--- perl-4.036.orig/config.sh	Wed Dec 31 18:00:00 1969
+++ perl-4.036/config.sh	Tue Jan 17 21:16:24 1995
@@ -0,0 +1,268 @@
+#!/bin/sh
+# config.sh
+# This file was produced by running the Configure script.
+d_eunice='undef'
+define='define'
+eunicefix=':'
+loclist='
+cat
+cp
+echo
+expr
+grep
+mkdir
+mv
+rm
+sed
+sort
+tr
+uniq
+'
+expr='/usr/bin/expr'
+sed='/usr/bin/sed'
+echo='/bin/echo'
+cat='/bin/cat'
+rm='/bin/rm'
+mv='/bin/mv'
+cp='/bin/cp'
+tail=''
+tr='/usr/bin/tr'
+mkdir='/bin/mkdir'
+sort='/usr/bin/sort'
+uniq='/usr/bin/uniq'
+grep='/usr/bin/grep'
+trylist='
+Mcc
+bison
+cpp
+csh
+egrep
+line
+nroff
+perl
+test
+uname
+yacc
+'
+test='test'
+inews=''
+egrep='/usr/bin/egrep'
+more=''
+pg=''
+Mcc='Mcc'
+vi=''
+mailx=''
+mail=''
+cpp='/lib/cpp'
+perl='/usr/bin/perl'
+emacs=''
+ls=''
+rmail=''
+sendmail=''
+shar=''
+smail=''
+tbl=''
+troff=''
+nroff='groff'
+uname='/bin/uname'
+uuname=''
+line='line'
+chgrp=''
+chmod=''
+lint=''
+sleep=''
+pr=''
+tar=''
+ln=''
+lpr=''
+lp=''
+touch=''
+make=''
+date=''
+csh='/bin/csh'
+bash=''
+ksh=''
+lex=''
+flex=''
+bison='/usr/bin/bison'
+Log='$Log'
+Header='$Header'
+Id='$Id'
+lastuname='Linux fuzzy 1.1.82 #2 Mon Jan 16 10:30:09 EST 1995 i486'
+alignbytes='4'
+bin='/usr/bin'
+installbin='/usr/bin'
+byteorder='1234'
+contains='grep'
+cppstdin='cppstdin'
+cppminus=''
+d_bcmp='define'
+d_bcopy='define'
+d_safebcpy='define'
+d_bzero='define'
+d_castneg='define'
+castflags='0'
+d_charsprf='undef'
+d_chsize='undef'
+d_crypt='define'
+cryptlib=''
+d_csh='define'
+d_dosuid='undef'
+d_dup2='define'
+d_fchmod='define'
+d_fchown='define'
+d_fcntl='define'
+d_flexfnam='define'
+d_flock='define'
+d_getgrps='undef'
+d_gethent='undef'
+d_getpgrp='define'
+d_getpgrp2='undef'
+d_getprior='undef'
+d_htonl='undef'
+d_index='undef'
+d_isascii='undef'
+d_killpg='define'
+d_lstat='define'
+d_memcmp='define'
+d_memcpy='define'
+d_safemcpy='undef'
+d_memmove='define'
+d_memset='define'
+d_mkdir='define'
+d_msg='define'
+d_msgctl='define'
+d_msgget='define'
+d_msgrcv='define'
+d_msgsnd='define'
+d_ndbm='define'
+d_odbm='define'
+d_open3='define'
+d_readdir='define'
+d_rename='define'
+d_rewindir='define'
+d_rmdir='define'
+d_seekdir='define'
+d_select='define'
+d_sem='define'
+d_semctl='define'
+d_semget='define'
+d_semop='define'
+d_setegid='define'
+d_seteuid='define'
+d_setpgrp='define'
+d_setpgrp2='undef'
+d_setprior='undef'
+d_setregid='define'
+d_setresgid='undef'
+d_setreuid='define'
+d_setresuid='undef'
+d_setrgid='undef'
+d_setruid='undef'
+d_shm='define'
+d_shmat='define'
+d_voidshmat='undef'
+d_shmctl='define'
+d_shmdt='define'
+d_shmget='define'
+d_socket='define'
+d_sockpair='define'
+d_oldsock='undef'
+socketlib=''
+d_statblks='define'
+d_stdstdio='undef'
+d_strctcpy='define'
+d_strerror='define'
+d_symlink='define'
+d_syscall='define'
+d_telldir='define'
+d_truncate='define'
+d_vfork='define'
+d_voidsig='define'
+d_tosignal='int'
+d_volatile='define'
+d_vprintf='define'
+d_charvspr='undef'
+d_wait4='define'
+d_waitpid='define'
+gidtype='unsigned short'
+groupstype='unsigned short'
+i_fcntl='undef'
+i_gdbm='define'
+i_grp='define'
+i_niin='define'
+i_sysin='undef'
+i_pwd='define'
+d_pwquota='undef'
+d_pwage='undef'
+d_pwchange='undef'
+d_pwclass='undef'
+d_pwexpire='undef'
+d_pwcomment='undef'
+i_sys_file='define'
+i_sysioctl='define'
+i_time='undef'
+i_sys_time='define'
+i_sys_select='undef'
+d_systimekernel='undef'
+i_utime='define'
+i_varargs='undef'
+i_vfork='undef'
+intsize='4'
+libc='/usr/lib/libc.a'
+nm_opts=''
+libndir=''
+i_my_dir='undef'
+i_ndir='undef'
+i_sys_ndir='undef'
+i_dirent='define'
+i_sys_dir='undef'
+d_dirnamlen='define'
+ndirc=''
+ndiro=''
+mallocsrc=''
+mallocobj=''
+d_mymalloc='undef'
+mallocptrtype='void'
+mansrc='/usr/man/man1'
+manext='1'
+models='none'
+split=''
+small=''
+medium=''
+large=''
+huge=''
+optimize='-O2'
+ccflags=''
+cppflags=''
+ldflags='-s'
+cc='gcc'
+nativegcc='define'
+libs='-ldbm -lm'
+n='-n'
+c=''
+package='perl(linux-36LA)'
+randbits='31'
+scriptdir='/usr/bin'
+installscr='/usr/bin'
+sig_name='ZERO HUP INT QUIT ILL TRAP IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH LOST PWR UNUSED'
+spitshell='cat'
+shsharp='true'
+sharpbang='#!'
+startsh='#!/bin/sh'
+stdchar='char'
+uidtype='unsigned short'
+usrinclude='/usr/include'
+inclPath=''
+void=''
+voidhave='7'
+voidwant='7'
+w_localtim='1'
+w_s_timevl='1'
+w_s_tm='1'
+yacc='bison -y'
+lib=''
+privlib='/usr/lib/perl4'
+installprivlib='/usr/lib/perl4'
+PATCHLEVEL=36
+CONFIG=true
diff -u --new-file --recursive perl-4.036.orig/cppstdin perl-4.036/cppstdin
--- perl-4.036.orig/cppstdin	Wed Dec 31 18:00:00 1969
+++ perl-4.036/cppstdin	Tue Jan 17 21:15:05 1995
@@ -0,0 +1 @@
+cat >.$$.c; gcc -E ${1+"$@"} .$$.c; rm .$$.c
diff -u --new-file --recursive perl-4.036.orig/h2ph perl-4.036/h2ph
--- perl-4.036.orig/h2ph	Wed Dec 31 18:00:00 1969
+++ perl-4.036/h2ph	Tue Jan 17 21:16:29 1995
@@ -0,0 +1,253 @@
+#!/usr/bin/perl
+'di';
+'ig00';
+
+$perlincl = '/usr/lib/perl4';
+
+chdir '/usr/include' || die "Can't cd /usr/include";
+
+@isatype = split(' ',<<END);
+	char	uchar	u_char
+	short	ushort	u_short
+	int	uint	u_int
+	long	ulong	u_long
+	FILE
+END
+
+@isatype{@isatype} = (1) x @isatype;
+
+@ARGV = ('-') unless @ARGV;
+
+foreach $file (@ARGV) {
+    if ($file eq '-') {
+	open(IN, "-");
+	open(OUT, ">-");
+    }
+    else {
+	($outfile = $file) =~ s/\.h$/.ph/ || next;
+	print "$file -> $outfile\n";
+	if ($file =~ m|^(.*)/|) {
+	    $dir = $1;
+	    if (!-d "$perlincl/$dir") {
+		mkdir("$perlincl/$dir",0777);
+	    }
+	}
+	open(IN,"$file") || ((warn "Can't open $file: $!\n"),next);
+	open(OUT,">$perlincl/$outfile") || die "Can't create $outfile: $!\n";
+    }
+    while (<IN>) {
+	chop;
+	while (/\\$/) {
+	    chop;
+	    $_ .= <IN>;
+	    chop;
+	}
+	if (s:/\*:\200:g) {
+	    s:\*/:\201:g;
+	    s/\200[^\201]*\201//g;	# delete single line comments
+	    if (s/\200.*//) {		# begin multi-line comment?
+		$_ .= '/*';
+		$_ .= <IN>;
+		redo;
+	    }
+	}
+	if (s/^#\s*//) {
+	    if (s/^define\s+(\w+)//) {
+		$name = $1;
+		$new = '';
+		s/\s+$//;
+		if (s/^\(([\w,\s]*)\)//) {
+		    $args = $1;
+		    if ($args ne '') {
+			foreach $arg (split(/,\s*/,$args)) {
+			    $arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;
+			    $curargs{$arg} = 1;
+			}
+			$args =~ s/\b(\w)/\$$1/g;
+			$args = "local($args) = \@_;\n$t    ";
+		    }
+		    s/^\s+//;
+		    do expr();
+		    $new =~ s/(["\\])/\\$1/g;
+		    if ($t ne '') {
+			$new =~ s/(['\\])/\\$1/g;
+			print OUT $t,
+			  "eval 'sub $name {\n$t    ${args}eval \"$new\";\n$t}';\n";
+		    }
+		    else {
+			print OUT "sub $name {\n    ${args}eval \"$new\";\n}\n";
+		    }
+		    %curargs = ();
+		}
+		else {
+		    s/^\s+//;
+		    do expr();
+		    $new = 1 if $new eq '';
+		    if ($t ne '') {
+			$new =~ s/(['\\])/\\$1/g;
+			print OUT $t,"eval 'sub $name {",$new,";}';\n";
+		    }
+		    else {
+			print OUT $t,"sub $name {",$new,";}\n";
+		    }
+		}
+	    }
+	    elsif (/^include\s+<(.*)>/) {
+		($incl = $1) =~ s/\.h$/.ph/;
+		print OUT $t,"require '$incl';\n";
+	    }
+	    elsif (/^ifdef\s+(\w+)/) {
+		print OUT $t,"if (defined &$1) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^ifndef\s+(\w+)/) {
+		print OUT $t,"if (!defined &$1) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (s/^if\s+//) {
+		$new = '';
+		do expr();
+		print OUT $t,"if ($new) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (s/^elif\s+//) {
+		$new = '';
+		do expr();
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n${t}elsif ($new) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^else/) {
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n${t}else {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^endif/) {
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n";
+	    }
+	}
+    }
+    print OUT "1;\n";
+}
+
+sub expr {
+    while ($_ ne '') {
+	s/^(\s+)//		&& do {$new .= ' '; next;};
+	s/^(0x[0-9a-fA-F]+)//	&& do {$new .= $1; next;};
+	s/^(\d+)//		&& do {$new .= $1; next;};
+	s/^("(\\"|[^"])*")//	&& do {$new .= $1; next;};
+	s/^'((\\"|[^"])*)'//	&& do {
+	    if ($curargs{$1}) {
+		$new .= "ord('\$$1')";
+	    }
+	    else {
+		$new .= "ord('$1')";
+	    }
+	    next;
+	};
+	s/^sizeof\s*\(([^)]+)\)/{$1}/ && do {
+	    $new .= '$sizeof';
+	    next;
+	};
+	s/^([_a-zA-Z]\w*)//	&& do {
+	    $id = $1;
+	    if ($id eq 'struct') {
+		s/^\s+(\w+)//;
+		$id .= ' ' . $1;
+		$isatype{$id} = 1;
+	    }
+	    elsif ($id eq 'unsigned') {
+		s/^\s+(\w+)//;
+		$id .= ' ' . $1;
+		$isatype{$id} = 1;
+	    }
+	    if ($curargs{$id}) {
+		$new .= '$' . $id;
+	    }
+	    elsif ($id eq 'defined') {
+		$new .= 'defined';
+	    }
+	    elsif (/^\(/) {
+		s/^\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i;	# cheat
+		$new .= " &$id";
+	    }
+	    elsif ($isatype{$id}) {
+		if ($new =~ /{\s*$/) {
+		    $new .= "'$id'";
+		}
+		elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {
+		    $new =~ s/\(\s*$//;
+		    s/^[\s*]*\)//;
+		}
+		else {
+		    $new .= $id;
+		}
+	    }
+	    else {
+		$new .= ' &' . $id;
+	    }
+	    next;
+	};
+	s/^(.)//			&& do {$new .= $1; next;};
+    }
+}
+##############################################################################
+
+	# These next few lines are legal in both Perl and nroff.
+
+.00;			# finish .ig
+ 
+'di			\" finish diversion--previous line must be blank
+.nr nl 0-1		\" fake up transition to first page again
+.nr % 0			\" start at page 1
+'; __END__ ############# From here on it's a standard manual page ############
+.TH H2PH 1 "August 8, 1990"
+.AT 3
+.SH NAME
+h2ph \- convert .h C header files to .ph Perl header files
+.SH SYNOPSIS
+.B h2ph [headerfiles]
+.SH DESCRIPTION
+.I h2ph
+converts any C header files specified to the corresponding Perl header file
+format.
+It is most easily run while in /usr/include:
+.nf
+
+	cd /usr/include; h2ph * sys/*
+
+.fi
+If run with no arguments, filters standard input to standard output.
+.SH ENVIRONMENT
+No environment variables are used.
+.SH FILES
+/usr/include/*.h
+.br
+/usr/include/sys/*.h
+.br
+etc.
+.SH AUTHOR
+Larry Wall
+.SH "SEE ALSO"
+perl(1)
+.SH DIAGNOSTICS
+The usual warnings if it can't read or write the files involved.
+.SH BUGS
+Doesn't construct the %sizeof array for you.
+.PP
+It doesn't handle all C constructs, but it does attempt to isolate
+definitions inside evals so that you can get at the definitions
+that it can translate.
+.PP
+It's only intended as a rough tool.
+You may need to dicker with the files produced.
+.ex
diff -u --new-file --recursive perl-4.036.orig/h2ph.man perl-4.036/h2ph.man
--- perl-4.036.orig/h2ph.man	Wed Dec 31 18:00:00 1969
+++ perl-4.036/h2ph.man	Tue Jan 17 21:16:29 1995
@@ -0,0 +1,253 @@
+#!/usr/bin/perl
+'di';
+'ig00';
+
+$perlincl = '/usr/lib/perl4';
+
+chdir '/usr/include' || die "Can't cd /usr/include";
+
+@isatype = split(' ',<<END);
+	char	uchar	u_char
+	short	ushort	u_short
+	int	uint	u_int
+	long	ulong	u_long
+	FILE
+END
+
+@isatype{@isatype} = (1) x @isatype;
+
+@ARGV = ('-') unless @ARGV;
+
+foreach $file (@ARGV) {
+    if ($file eq '-') {
+	open(IN, "-");
+	open(OUT, ">-");
+    }
+    else {
+	($outfile = $file) =~ s/\.h$/.ph/ || next;
+	print "$file -> $outfile\n";
+	if ($file =~ m|^(.*)/|) {
+	    $dir = $1;
+	    if (!-d "$perlincl/$dir") {
+		mkdir("$perlincl/$dir",0777);
+	    }
+	}
+	open(IN,"$file") || ((warn "Can't open $file: $!\n"),next);
+	open(OUT,">$perlincl/$outfile") || die "Can't create $outfile: $!\n";
+    }
+    while (<IN>) {
+	chop;
+	while (/\\$/) {
+	    chop;
+	    $_ .= <IN>;
+	    chop;
+	}
+	if (s:/\*:\200:g) {
+	    s:\*/:\201:g;
+	    s/\200[^\201]*\201//g;	# delete single line comments
+	    if (s/\200.*//) {		# begin multi-line comment?
+		$_ .= '/*';
+		$_ .= <IN>;
+		redo;
+	    }
+	}
+	if (s/^#\s*//) {
+	    if (s/^define\s+(\w+)//) {
+		$name = $1;
+		$new = '';
+		s/\s+$//;
+		if (s/^\(([\w,\s]*)\)//) {
+		    $args = $1;
+		    if ($args ne '') {
+			foreach $arg (split(/,\s*/,$args)) {
+			    $arg =~ s/^\s*([^\s].*[^\s])\s*$/$1/;
+			    $curargs{$arg} = 1;
+			}
+			$args =~ s/\b(\w)/\$$1/g;
+			$args = "local($args) = \@_;\n$t    ";
+		    }
+		    s/^\s+//;
+		    do expr();
+		    $new =~ s/(["\\])/\\$1/g;
+		    if ($t ne '') {
+			$new =~ s/(['\\])/\\$1/g;
+			print OUT $t,
+			  "eval 'sub $name {\n$t    ${args}eval \"$new\";\n$t}';\n";
+		    }
+		    else {
+			print OUT "sub $name {\n    ${args}eval \"$new\";\n}\n";
+		    }
+		    %curargs = ();
+		}
+		else {
+		    s/^\s+//;
+		    do expr();
+		    $new = 1 if $new eq '';
+		    if ($t ne '') {
+			$new =~ s/(['\\])/\\$1/g;
+			print OUT $t,"eval 'sub $name {",$new,";}';\n";
+		    }
+		    else {
+			print OUT $t,"sub $name {",$new,";}\n";
+		    }
+		}
+	    }
+	    elsif (/^include\s+<(.*)>/) {
+		($incl = $1) =~ s/\.h$/.ph/;
+		print OUT $t,"require '$incl';\n";
+	    }
+	    elsif (/^ifdef\s+(\w+)/) {
+		print OUT $t,"if (defined &$1) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^ifndef\s+(\w+)/) {
+		print OUT $t,"if (!defined &$1) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (s/^if\s+//) {
+		$new = '';
+		do expr();
+		print OUT $t,"if ($new) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (s/^elif\s+//) {
+		$new = '';
+		do expr();
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n${t}elsif ($new) {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^else/) {
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n${t}else {\n";
+		$tab += 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+	    }
+	    elsif (/^endif/) {
+		$tab -= 4;
+		$t = "\t" x ($tab / 8) . ' ' x ($tab % 8);
+		print OUT $t,"}\n";
+	    }
+	}
+    }
+    print OUT "1;\n";
+}
+
+sub expr {
+    while ($_ ne '') {
+	s/^(\s+)//		&& do {$new .= ' '; next;};
+	s/^(0x[0-9a-fA-F]+)//	&& do {$new .= $1; next;};
+	s/^(\d+)//		&& do {$new .= $1; next;};
+	s/^("(\\"|[^"])*")//	&& do {$new .= $1; next;};
+	s/^'((\\"|[^"])*)'//	&& do {
+	    if ($curargs{$1}) {
+		$new .= "ord('\$$1')";
+	    }
+	    else {
+		$new .= "ord('$1')";
+	    }
+	    next;
+	};
+	s/^sizeof\s*\(([^)]+)\)/{$1}/ && do {
+	    $new .= '$sizeof';
+	    next;
+	};
+	s/^([_a-zA-Z]\w*)//	&& do {
+	    $id = $1;
+	    if ($id eq 'struct') {
+		s/^\s+(\w+)//;
+		$id .= ' ' . $1;
+		$isatype{$id} = 1;
+	    }
+	    elsif ($id eq 'unsigned') {
+		s/^\s+(\w+)//;
+		$id .= ' ' . $1;
+		$isatype{$id} = 1;
+	    }
+	    if ($curargs{$id}) {
+		$new .= '$' . $id;
+	    }
+	    elsif ($id eq 'defined') {
+		$new .= 'defined';
+	    }
+	    elsif (/^\(/) {
+		s/^\((\w),/("$1",/ if $id =~ /^_IO[WR]*$/i;	# cheat
+		$new .= " &$id";
+	    }
+	    elsif ($isatype{$id}) {
+		if ($new =~ /{\s*$/) {
+		    $new .= "'$id'";
+		}
+		elsif ($new =~ /\(\s*$/ && /^[\s*]*\)/) {
+		    $new =~ s/\(\s*$//;
+		    s/^[\s*]*\)//;
+		}
+		else {
+		    $new .= $id;
+		}
+	    }
+	    else {
+		$new .= ' &' . $id;
+	    }
+	    next;
+	};
+	s/^(.)//			&& do {$new .= $1; next;};
+    }
+}
+##############################################################################
+
+	# These next few lines are legal in both Perl and nroff.
+
+.00;			# finish .ig
+ 
+'di			\" finish diversion--previous line must be blank
+.nr nl 0-1		\" fake up transition to first page again
+.nr % 0			\" start at page 1
+'; __END__ ############# From here on it's a standard manual page ############
+.TH H2PH 1 "August 8, 1990"
+.AT 3
+.SH NAME
+h2ph \- convert .h C header files to .ph Perl header files
+.SH SYNOPSIS
+.B h2ph [headerfiles]
+.SH DESCRIPTION
+.I h2ph
+converts any C header files specified to the corresponding Perl header file
+format.
+It is most easily run while in /usr/include:
+.nf
+
+	cd /usr/include; h2ph * sys/*
+
+.fi
+If run with no arguments, filters standard input to standard output.
+.SH ENVIRONMENT
+No environment variables are used.
+.SH FILES
+/usr/include/*.h
+.br
+/usr/include/sys/*.h
+.br
+etc.
+.SH AUTHOR
+Larry Wall
+.SH "SEE ALSO"
+perl(1)
+.SH DIAGNOSTICS
+The usual warnings if it can't read or write the files involved.
+.SH BUGS
+Doesn't construct the %sizeof array for you.
+.PP
+It doesn't handle all C constructs, but it does attempt to isolate
+definitions inside evals so that you can get at the definitions
+that it can translate.
+.PP
+It's only intended as a rough tool.
+You may need to dicker with the files produced.
+.ex
diff -u --new-file --recursive perl-4.036.orig/makedepend perl-4.036/makedepend
--- perl-4.036.orig/makedepend	Wed Dec 31 18:00:00 1969
+++ perl-4.036/makedepend	Tue Jan 17 21:16:29 1995
@@ -0,0 +1,147 @@
+#!/bin/sh
+# : makedepend.SH,v 4063Revision: 4.0.1.4 4063Date: 92/06/08 13:51:24 $
+#
+# $Log:	makedepend.SH,v $
+# Revision 4.0.1.4  92/06/08  13:51:24  lwall
+# patch20: various and sundry fixes
+# 
+# Revision 4.0.1.3  91/11/05  17:56:33  lwall
+# patch11: various portability fixes
+# 
+# Revision 4.0.1.2  91/06/07  15:40:06  lwall
+# patch4: fixed cppstdin to run in the right directory
+# 
+# Revision 4.0.1.1  91/06/07  11:20:06  lwall
+# patch4: Makefile is no longer self-modifying code under makedepend
+# 
+# Revision 4.0  91/03/20  01:27:04  lwall
+# 4.0 baseline.
+# 
+# 
+
+export PATH || (echo "OOPS, this isn't sh.  Desperation time.  I will feed myself to sh."; sh $0; kill $$)
+
+cat='/bin/cat'
+cppflags=''
+cp='/bin/cp'
+cppstdin='cppstdin'
+cppminus=''
+echo='/bin/echo'
+egrep='/usr/bin/egrep'
+expr='/usr/bin/expr'
+mv='/bin/mv'
+rm='/bin/rm'
+sed='/usr/bin/sed'
+sort='/usr/bin/sort'
+test='test'
+tr='/usr/bin/tr'
+uniq='/usr/bin/uniq'
+
+PATH="$PATH:."
+export PATH
+
+$cat /dev/null >.deptmp
+$rm -f *.c.c c/*.c.c
+if test -f Makefile; then
+    cp Makefile makefile
+fi
+mf=makefile
+if test -f $mf; then
+    defrule=`<$mf sed -n		\
+	-e '/^\.c\.o:.*;/{'		\
+	-e    's/\$\*\.c//'		\
+	-e    's/^[^;]*;[	 ]*//p'	\
+	-e    q				\
+	-e '}'				\
+	-e '/^\.c\.o: *$/{'		\
+	-e    N				\
+	-e    's/\$\*\.c//'		\
+	-e    's/^.*\n[	 ]*//p'		\
+	-e    q				\
+	-e '}'`
+fi
+case "$defrule" in
+'') defrule='$(CC) -c $(CFLAGS)' ;;
+esac
+
+make clist || ($echo "Searching for .c files..."; \
+	$echo *.c | $tr ' ' '\012' | $egrep -v '\*' >.clist)
+for file in `$cat .clist`; do
+# for file in `cat /dev/null`; do
+    case "$file" in
+    *.c) filebase=`basename $file .c` ;;
+    *.y) filebase=`basename $file .y` ;;
+    esac
+    case "$file" in
+    */*) finc="-I`echo $file | sed 's#/[^/]*$##`" ;;
+    *)   finc= ;;
+    esac
+    $echo "Finding dependencies for $filebase.o."
+    ( $echo "#line 1 \"$file\""; \
+      $sed -n <$file \
+	-e "/^${filebase}_init(/q" \
+	-e '/^#/{' \
+	-e 's|/\*.*$||' \
+	-e 's|\\$||' \
+	-e p \
+	-e '}' ) >$file.c
+    $cppstdin $finc -I/usr/local/include -I. $cppflags $cppminus <$file.c |
+    $sed \
+	-e 's#\.[0-9][0-9]*\.c#'"$file.c#" \
+	-e 's/^[	 ]*#[	 ]*line/#/' \
+	-e '/^# *[0-9][0-9]* *[".\/]/!d' \
+	-e 's/^.*"\(.*\)".*$/'$filebase'.o: \1/' \
+	-e 's/^# *[0-9][0-9]* \(.*\)$/'$filebase'.o: \1/' \
+	-e 's|: \./|: |' \
+	-e 's|\.c\.c|.c|' | \
+    $uniq | $sort | $uniq >> .deptmp
+done
+
+$sed <$mf >$mf.new -e '1,/^# AUTOMATICALLY/!d'
+
+make shlist || ($echo "Searching for .SH files..."; \
+	$echo *.SH | $tr ' ' '\012' | $egrep -v '\*' >.shlist)
+if $test -s .deptmp; then
+    for file in `cat .shlist`; do
+	$echo `$expr X$file : 'X\(.*\).SH'`: $file config.sh \; \
+	    /bin/sh $file >> .deptmp
+    done
+    $echo "Updating $mf..."
+    $echo "# If this runs make out of memory, delete /usr/include lines." \
+	>> $mf.new
+    $sed 's|^\(.*\.o:\) *\(.*/.*\.c\) *$|\1 \2; '"$defrule \2|" .deptmp \
+       >>$mf.new
+else
+    make hlist || ($echo "Searching for .h files..."; \
+	$echo *.h | $tr ' ' '\012' | $egrep -v '\*' >.hlist)
+    $echo "You don't seem to have a proper C preprocessor.  Using grep instead."
+    $egrep '^#include ' `cat .clist` `cat .hlist`  >.deptmp
+    $echo "Updating $mf..."
+    <.clist $sed -n							\
+	-e '/\//{'							\
+	-e   's|^\(.*\)/\(.*\)\.c|\2.o: \1/\2.c; '"$defrule \1/\2.c|p"	\
+	-e   d								\
+	-e '}'								\
+	-e 's|^\(.*\)\.c|\1.o: \1.c|p' >> $mf.new
+    <.hlist $sed -n 's|\(.*/\)\(.*\)|s= \2= \1\2=|p' >.hsed
+    <.deptmp $sed -n 's|c:#include "\(.*\)".*$|o: \1|p' | \
+       $sed 's|^[^;]*/||' | \
+       $sed -f .hsed >> $mf.new
+    <.deptmp $sed -n 's|c:#include <\(.*\)>.*$|o: /usr/include/\1|p' \
+       >> $mf.new
+    <.deptmp $sed -n 's|h:#include "\(.*\)".*$|h: \1|p' | \
+       $sed -f .hsed >> $mf.new
+    <.deptmp $sed -n 's|h:#include <\(.*\)>.*$|h: /usr/include/\1|p' \
+       >> $mf.new
+    for file in `$cat .shlist`; do
+	$echo `$expr X$file : 'X\(.*\).SH'`: $file config.sh \; \
+	    /bin/sh $file >> $mf.new
+    done
+fi
+$rm -f $mf.old
+$cp $mf $mf.old
+$cp $mf.new $mf
+$rm $mf.new
+$echo "# WARNING: Put nothing here or make depend will gobble it up!" >> $mf
+$rm -f .deptmp `sed 's/\.c/.c.c/' .clist` .shlist .clist .hlist .hsed
+
diff -u --new-file --recursive perl-4.036.orig/makedir perl-4.036/makedir
--- perl-4.036.orig/makedir	Wed Dec 31 18:00:00 1969
+++ perl-4.036/makedir	Tue Jan 17 21:16:29 1995
@@ -0,0 +1,56 @@
+#!/bin/sh
+# : makedir.SH,v 4063Revision: 4.0.1.1 4063Date: 92/06/08 14:24:55 $
+# 
+# $Log:	makedir.SH,v $
+# Revision 4.0.1.1  92/06/08  14:24:55  lwall
+# patch20: SH files didn't work well with symbolic links
+# 
+# Revision 4.0  91/03/20  01:27:13  lwall
+# 4.0 baseline.
+# 
+# 
+
+export PATH || (echo "OOPS, this isn't sh.  Desperation time.  I will feed myself to sh."; sh $0; kill $$)
+
+case $# in
+  0)
+    /bin/echo "makedir pathname filenameflag"
+    exit 1
+    ;;
+esac
+
+: guarantee one slash before 1st component
+case $1 in
+  /*) ;;
+  *)  set ./$1 $2 ;;
+esac
+
+: strip last component if it is to be a filename
+case X$2 in
+  X1) set `/bin/echo $1 | /usr/bin/sed 's:\(.*\)/[^/]*$:\1:'` ;;
+  *)  set $1 ;;
+esac
+
+: return reasonable status if nothing to be created
+if test -d "$1" ; then
+    exit 0
+fi
+
+list=''
+while true ; do
+    case $1 in
+    */*)
+	list="$1 $list"
+	set `echo $1 | /usr/bin/sed 's:\(.*\)/:\1 :'`
+	;;
+    *)
+	break
+	;;
+    esac
+done
+
+set $list
+
+for dir do
+    /bin/mkdir $dir >/dev/null 2>&1
+done
diff -u --new-file --recursive perl-4.036.orig/pstruct perl-4.036/pstruct
--- perl-4.036.orig/pstruct	Wed Dec 31 18:00:00 1969
+++ perl-4.036/pstruct	Tue Jan 17 21:16:27 1995
@@ -0,0 +1,1071 @@
+#!/usr/bin/perl
+#
+#
+#   c2ph (aka pstruct)
+#   Tom Christiansen, <tchrist@convex.com>
+#   
+#   As pstruct, dump C structures as generated from 'cc -g -S' stabs.
+#   As c2ph, do this PLUS generate perl code for getting at the structures.
+#
+#   See the usage message for more.  If this isn't enough, read the code.
+#
+
+$RCSID = '$RCSfile: c2ph.SH,v $$Revision: 4.0.1.2 $$Date: 92/06/08 11:56:08 $';
+
+
+######################################################################
+
+# some handy data definitions.   many of these can be reset later.
+
+$bitorder = 'b';  # ascending; set to B for descending bit fields
+
+%intrinsics = 
+%template = (
+    'char', 			'c',
+    'unsigned char', 		'C',
+    'short',			's',
+    'short int',		's',
+    'unsigned short',		'S',
+    'unsigned short int',	'S',
+    'short unsigned int',	'S',
+    'int',			'i',
+    'unsigned int',		'I',
+    'long',			'l',
+    'long int',			'l',
+    'unsigned long',		'L',
+    'unsigned long',		'L',
+    'long unsigned int',	'L',
+    'unsigned long int',	'L',
+    'long long',		'q',
+    'long long int',		'q',
+    'unsigned long long',	'Q',
+    'unsigned long long int',	'Q',
+    'float',			'f',
+    'double',			'd',
+    'pointer',			'p',
+    'null',			'x',
+    'neganull',			'X',
+    'bit',			$bitorder,
+); 
+
+&buildscrunchlist;
+delete $intrinsics{'neganull'};
+delete $intrinsics{'bit'};
+delete $intrinsics{'null'};
+
+# use -s to recompute sizes
+%sizeof = (
+    'char', 			'1',
+    'unsigned char', 		'1',
+    'short',			'2',
+    'short int',		'2',
+    'unsigned short',		'2',
+    'unsigned short int',	'2',
+    'short unsigned int',	'2',
+    'int',			'4',
+    'unsigned int',		'4',
+    'long',			'4',
+    'long int',			'4',
+    'unsigned long',		'4',
+    'unsigned long int',	'4',
+    'long unsigned int',	'4',
+    'long long',		'8',
+    'long long int',		'8',
+    'unsigned long long',	'8',
+    'unsigned long long int',	'8',
+    'float',			'4',
+    'double',			'8',
+    'pointer',			'4',
+);
+
+($type_width, $member_width, $offset_width, $size_width) = (20, 20, 6, 5);
+
+($offset_fmt, $size_fmt) = ('d', 'd');
+
+$indent = 2;
+
+$CC = 'cc';
+$CFLAGS = '-g -S';
+$DEFINES = '';
+
+$perl++ if $0 =~ m#/?c2ph$#;
+
+require 'getopts.pl';
+
+eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
+
+&Getopts('aixdpvtnws:') || &usage(0);
+
+$opt_d && $debug++;
+$opt_t && $trace++;
+$opt_p && $perl++;
+$opt_v && $verbose++;
+$opt_n && ($perl = 0);
+
+if ($opt_w) {
+    ($type_width, $member_width, $offset_width) = (45, 35, 8);
+} 
+if ($opt_x) {
+    ($offset_fmt, $offset_width, $size_fmt, $size_width) = ( 'x', '08', 'x', 04 );
+}
+
+eval '$'.$1.'$2;' while $ARGV[0] =~ /^([A-Za-z_]+=)(.*)/ && shift;
+
+sub PLUMBER {
+    select(STDERR);
+    print "oops, apperent pager foulup\n";
+    $isatty++;
+    &usage(1);
+} 
+
+sub usage {
+    local($oops) = @_;
+    unless (-t STDOUT) {
+	select(STDERR);
+    } elsif (!$oops) {
+	$isatty++;
+	$| = 1;
+	print "hit <RETURN> for further explanation: ";
+	<STDIN>;
+	open (PIPE, "|". ($ENV{PAGER} || 'more'));
+	$SIG{PIPE} = PLUMBER;
+	select(PIPE);
+    } 
+
+    print "usage: $0 [-dpnP] [var=val] [files ...]\n";
+
+    exit unless $isatty;
+
+    print <<EOF;
+
+Options:
+
+-w	wide; short for: type_width=45 member_width=35 offset_width=8
+-x	hex; short for:  offset_fmt=x offset_width=08 size_fmt=x size_width=04
+
+-n  	do not generate perl code  (default when invoked as pstruct)
+-p  	generate perl code         (default when invoked as c2ph)
+-v	generate perl code, with C decls as comments
+
+-i	do NOT recompute sizes for intrinsic datatypes
+-a	dump information on intrinsics also
+
+-t 	trace execution
+-d	spew reams of debugging output
+
+-slist  give comma-separated list a structures to dump
+
+
+Var Name        Default Value    Meaning
+
+EOF
+
+    &defvar('CC', 'which_compiler to call');
+    &defvar('CFLAGS', 'how to generate *.s files with stabs');
+    &defvar('DEFINES','any extra cflags or cpp defines, like -I, -D, -U');
+
+    print "\n";
+
+    &defvar('type_width', 'width of type field   (column 1)');
+    &defvar('member_width', 'width of member field (column 2)');
+    &defvar('offset_width', 'width of offset field (column 3)');
+    &defvar('size_width', 'width of size field   (column 4)');
+
+    print "\n";
+
+    &defvar('offset_fmt', 'sprintf format type for offset');
+    &defvar('size_fmt', 'sprintf format type for size');
+
+    print "\n";
+
+    &defvar('indent', 'how far to indent each nesting level');
+
+   print <<'EOF';
+
+    If any *.[ch] files are given, these will be catted together into
+    a temporary *.c file and sent through:
+	    $CC $CFLAGS $DEFINES 
+    and the resulting *.s groped for stab information.  If no files are
+    supplied, then stdin is read directly with the assumption that it
+    contains stab information.  All other liens will be ignored.  At
+    most one *.s file should be supplied.
+
+EOF
+    close PIPE;
+    exit 1;
+} 
+
+sub defvar {
+    local($var, $msg) = @_;
+    printf "%-16s%-15s  %s\n", $var, eval "\$$var", $msg;
+} 
+
+$recurse = 1;
+
+if (@ARGV) {
+    if (grep(!/\.[csh]$/,@ARGV)) {
+	warn "Only *.[csh] files expected!\n";
+	&usage;
+    } 
+    elsif (grep(/\.s$/,@ARGV)) {
+	if (@ARGV > 1) { 
+	    warn "Only one *.s file allowed!\n";
+	    &usage;
+	}
+    } 
+    elsif (@ARGV == 1 && $ARGV[0] =~ /\.c$/) {
+	local($dir, $file) = $ARGV[0] =~ m#(.*/)?(.*)$#;
+	$chdir = "cd $dir; " if $dir;
+	&system("$chdir$CC $CFLAGS $DEFINES $file") && exit 1;
+	$ARGV[0] =~ s/\.c$/.s/;
+    } 
+    else {
+	$TMP = "/tmp/c2ph.$$.c";
+	&system("cat @ARGV > $TMP") && exit 1;
+	&system("cd /tmp; $CC $CFLAGS $DEFINES $TMP") && exit 1;
+	unlink $TMP;
+	$TMP =~ s/\.c$/.s/;
+	@ARGV = ($TMP);
+    } 
+}
+
+if ($opt_s) {
+    for (split(/[\s,]+/, $opt_s)) {
+	$interested{$_}++;
+    } 
+} 
+
+
+$| = 1 if $debug;
+
+main: {
+
+    if ($trace) {
+	if (-t && !@ARGV) { 
+	    print STDERR "reading from your keyboard: ";
+	} else {
+	    print STDERR "reading from " . (@ARGV ? "@ARGV" : "<STDIN>").": ";
+	}
+    }
+
+STAB: while (<>) {
+	if ($trace && !($. % 10)) {
+	    $lineno = $..'';
+	    print STDERR $lineno, "\b" x length($lineno);
+	} 
+	next unless /^\s*\.stabs\s+/;
+	$line = $_;
+	s/^\s*\.stabs\s+//; 
+	&stab; 
+    }
+    print STDERR "$.\n" if $trace;
+    unlink $TMP if $TMP;
+
+    &compute_intrinsics if $perl && !$opt_i;
+
+    print STDERR "resolving types\n" if $trace;
+
+    &resolve_types;
+    &adjust_start_addrs;
+
+    $sum = 2 + $type_width + $member_width;
+    $pmask1 = "%-${type_width}s %-${member_width}s"; 
+    $pmask2 = "%-${sum}s %${offset_width}${offset_fmt}%s %${size_width}${size_fmt}%s";
+
+    if ($perl) {
+	# resolve template -- should be in stab define order, but even this isn't enough.
+	print STDERR "\nbuilding type templates: " if $trace;
+	for $i (reverse 0..$#type) {
+	    next unless defined($name = $type[$i]);
+	    next unless defined $struct{$name};
+	    $build_recursed = 0;
+	    &build_template($name) unless defined $template{&psou($name)} ||
+					$opt_s && !$interested{$name};
+	} 
+	print STDERR "\n\n" if $trace;
+    }
+
+    print STDERR "dumping structs: " if $trace;
+
+
+    foreach $name (sort keys %struct) {
+	next if $opt_s && !$interested{$name};
+	print STDERR "$name " if $trace;
+
+	undef @sizeof;
+	undef @typedef;
+	undef @offsetof;
+	undef @indices;
+	undef @typeof;
+
+	$mname = &munge($name);
+
+	$fname = &psou($name);
+
+	print "# " if $perl && $verbose;
+	$pcode = '';
+	print "$fname {\n" if !$perl || $verbose; 
+	$template{$fname} = &scrunch($template{$fname}) if $perl;
+	&pstruct($name,$name,0); 
+	print "# " if $perl && $verbose;
+	print "}\n" if !$perl || $verbose; 
+	print "\n" if $perl && $verbose;
+
+	if ($perl) {
+	    print "$pcode";
+
+	    printf("\nsub %-32s { %4d; }\n\n", "${mname}'struct", $countof{$name});
+
+	    print <<EOF;
+sub ${mname}'typedef { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}'index 
+	? \$${mname}'typedef[\$${mname}'index] 
+	: \$${mname}'typedef;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'sizeof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}'index 
+	? \$${mname}'sizeof[\$${mname}'index] 
+	: \$${mname}'sizeof;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'offsetof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}index 
+	? \$${mname}'offsetof[\$${mname}'index] 
+	: \$${mname}'sizeof;
+}
+EOF
+
+	    print <<EOF;
+sub ${mname}'typeof { 
+    local(\$${mname}'index) = shift;
+    defined \$${mname}index 
+	? \$${mname}'typeof[\$${mname}'index] 
+	: '$name';
+}
+EOF
+    
+
+	    print "\$${mname}'typedef = '" . &scrunch($template{$fname}) 
+		. "';\n";
+
+	    print "\$${mname}'sizeof = $sizeof{$name};\n\n";
+
+
+	    print "\@${mname}'indices = (", &squishseq(@indices), ");\n";
+
+	    print "\n";
+
+	    print "\@${mname}'typedef[\@${mname}'indices] = (",
+			join("\n\t", '', @typedef), "\n    );\n\n";
+	    print "\@${mname}'sizeof[\@${mname}'indices] = (",
+			join("\n\t", '', @sizeof), "\n    );\n\n";
+	    print "\@${mname}'offsetof[\@${mname}'indices] = (",
+			join("\n\t", '', @offsetof), "\n    );\n\n";
+	    print "\@${mname}'typeof[\@${mname}'indices] = (",
+			join("\n\t", '', @typeof), "\n    );\n\n";
+
+	    $template_printed{$fname}++;
+	    $size_printed{$fname}++;
+	} 
+	print "\n";
+    }
+
+    print STDERR "\n" if $trace;
+
+    unless ($perl && $opt_a) { 
+	print "\n1;\n";
+	exit;
+    }
+
+
+
+    foreach $name (sort bysizevalue keys %intrinsics) {
+	next if $size_printed{$name};
+	print '$',&munge($name),"'sizeof = ", $sizeof{$name}, ";\n";
+    }
+
+    print "\n";
+
+    sub bysizevalue { $sizeof{$a} <=> $sizeof{$b}; }
+
+
+    foreach $name (sort keys %intrinsics) {
+	print '$',&munge($name),"'typedef = '", $template{$name}, "';\n";
+    }
+
+    print "\n1;\n";
+	
+    exit;
+}
+
+########################################################################################
+
+
+sub stab {
+    next unless /:[\$\w]+(\(\d+,\d+\))?=[\*\$\w]+/;  # (\d+,\d+) is for sun
+    s/"// 						|| next;
+    s/",([x\d]+),([x\d]+),([x\d]+),.*// 		|| next;
+
+    next if /^\s*$/;
+
+    $size = $3 if $3;
+
+
+    $line = $_;
+
+    if (($name, $pdecl) = /^([\$ \w]+):[tT]((\d+)(=[rufs*](\d+))+)$/) {
+	print "$name is a typedef for some funky pointers: $pdecl\n" if $debug;
+	&pdecl($pdecl);
+	next;
+    }
+
+
+
+    if (/(([ \w]+):t(\d+|\(\d+,\d+\)))=r?(\d+|\(\d+,\d+\))(;\d+;\d+;)?/) {  
+	local($ident) = $2;
+	push(@intrinsics, $ident);
+	$typeno = &typeno($3);
+	$type[$typeno] = $ident;
+	print STDERR "intrinsic $ident in new type $typeno\n" if $debug; 
+	next;
+    }
+
+    if (($name, $typeordef, $typeno, $extra, $struct, $_) 
+	= /^([\$ \w]+):([ustT])(\d+|\(\d+,\d+\))(=[rufs*](\d+))?(.*)$/) 
+    {
+	$typeno = &typeno($typeno);  # sun foolery
+    } 
+    elsif (/^[\$\w]+:/) {
+	next; # variable
+    }
+    else { 
+	warn "can't grok stab: <$_> in: $line " if $_;
+	next;
+    } 
+
+    #warn "got size $size for $name\n";
+    $sizeof{$name} = $size if $size;
+
+    s/;[-\d]*;[-\d]*;$//;  # we don't care about ranges
+
+    $typenos{$name} = $typeno;
+
+    unless (defined $type[$typeno]) {
+	&panic("type 0??") unless $typeno;
+	$type[$typeno] = $name unless defined $type[$typeno];
+	printf "new type $typeno is $name" if $debug;
+	if ($extra =~ /\*/ && defined $type[$struct]) {
+	    print ", a typedef for a pointer to " , $type[$struct] if $debug;
+	}
+    } else {
+	printf "%s is type %d", $name, $typeno if $debug;
+	print ", a typedef for " , $type[$typeno] if $debug;
+    } 
+    print "\n" if $debug;
+    #next unless $extra =~ /[su*]/;
+
+    #$type[$struct] = $name;
+
+    if ($extra =~ /[us*]/) {
+	&sou($name, $extra);
+	$_ = &sdecl($name, $_, 0);
+    }
+    elsif (/^=ar/) {
+	print "it's a bare array typedef -- that's pretty sick\n" if $debug;
+	$_ = "$typeno$_";
+	$scripts = '';
+	$_ = &adecl($_,1);
+
+    }
+    elsif (s/((\w+):t(\d+|\(\d+,\d+\)))?=r?(;\d+;\d+;)?//) {  # the ?'s are for gcc
+	push(@intrinsics, $2);
+	$typeno = &typeno($3);
+	$type[$typeno] = $2;
+	print STDERR "intrinsic $2 in new type $typeno\n" if $debug; 
+    }
+    elsif (s/^=e//) { # blessed by thy compiler; mine won't do this
+	&edecl;
+    } 
+    else {
+	warn "Funny remainder for $name on line $_ left in $line " if $_;
+    } 
+}
+
+sub typeno {  # sun thinks types are (0,27) instead of just 27
+    local($_) = @_;
+    s/\(\d+,(\d+)\)/$1/;
+    $_;
+} 
+
+sub pstruct {
+    local($what,$prefix,$base) = @_; 
+    local($field, $fieldname, $typeno, $count, $offset, $entry); 
+    local($fieldtype);
+    local($type, $tname); 
+    local($mytype, $mycount, $entry2);
+    local($struct_count) = 0;
+    local($pad, $revpad, $length, $prepad, $lastoffset, $lastlength, $fmt);
+    local($bits,$bytes);
+    local($template);
+
+
+    local($mname) = &munge($name);
+
+    sub munge { 
+	local($_) = @_;
+	s/[\s\$\.]/_/g;
+	$_;
+    }
+
+    local($sname) = &psou($what);
+
+    $nesting++;
+
+    for $field (split(/;/, $struct{$what})) {
+	$pad = $prepad = 0;
+	$entry = ''; 
+	($fieldname, $typeno, $count, $offset, $length) = split(/,/, $field); 
+
+	$type = $type[$typeno];
+
+	$type =~ /([^[]*)(\[.*\])?/;
+	$mytype = $1;
+	$count .= $2;
+	$fieldtype = &psou($mytype);
+
+	local($fname) = &psou($name);
+
+	if ($build_templates) {
+
+	    $pad = ($offset - ($lastoffset + $lastlength))/8 
+		if defined $lastoffset;
+
+	    if (! $finished_template{$sname}) {
+		if ($isaunion{$what}) {
+		    $template{$sname} .= 'X' x $revpad . ' '    if $revpad;
+		} else {
+		    $template{$sname} .= 'x' x $pad    . ' '    if $pad;
+		}
+	    }
+
+	    $template = &fetch_template($type) x 
+			    ($count ? &scripts2count($count) : 1);
+
+	    if (! $finished_template{$sname}) {
+		$template{$sname} .= $template;
+	    }
+
+	    $revpad = $length/8 if $isaunion{$what};
+
+	    ($lastoffset, $lastlength) = ($offset, $length);
+
+	} else { 
+	    print '# ' if $perl && $verbose;
+	    $entry = sprintf($pmask1,
+			' ' x ($nesting * $indent) . $fieldtype,
+			"$prefix.$fieldname" . $count); 
+
+	    $entry =~ s/(\*+)( )/$2$1/; 
+
+	    printf $pmask2,
+		    $entry,
+		    ($base+$offset)/8,
+		    ($bits = ($base+$offset)%8) ? ".$bits" : "  ",
+		    $length/8,
+		    ($bits = $length % 8) ? ".$bits": ""
+			if !$perl || $verbose;
+
+
+	    if ($perl && $nesting == 1) {
+		$template = &scrunch(&fetch_template($type) x 
+				($count ? &scripts2count($count) : 1));
+		push(@sizeof, int($length/8) .",\t# $fieldname");
+		push(@offsetof, int($offset/8) .",\t# $fieldname");
+		push(@typedef, "'$template', \t# $fieldname");
+		$type =~ s/(struct|union) //;
+		push(@typeof, "'$type" . ($count ? $count : '') .
+		    "',\t# $fieldname");
+	    }
+
+	    print '  ', ' ' x $indent x $nesting, $template
+				if $perl && $verbose;
+
+	    print "\n" if !$perl || $verbose;
+
+	}    
+	if ($perl) {
+	    local($mycount) = defined $struct{$mytype} ? $countof{$mytype} : 1;
+	    $mycount *= &scripts2count($count) if $count;
+	    if ($nesting==1 && !$build_templates) {
+		$pcode .= sprintf("sub %-32s { %4d; }\n", 
+			"${mname}'${fieldname}", $struct_count);
+		push(@indices, $struct_count);
+	    }
+	    $struct_count += $mycount;
+	} 
+
+
+	&pstruct($type, "$prefix.$fieldname", $base+$offset) 
+		if $recurse && defined $struct{$type}; 
+    }
+
+    $countof{$what} = $struct_count unless defined $countof{$whati};
+
+    $template{$sname} .= '$' if $build_templates;
+    $finished_template{$sname}++;
+
+    if ($build_templates && !defined $sizeof{$name}) {
+	local($fmt) = &scrunch($template{$sname});
+	print STDERR "no size for $name, punting with $fmt..." if $debug;
+	eval '$sizeof{$name} = length(pack($fmt, ()))';
+	if ($@) {
+	    chop $@;
+	    warn "couldn't get size for \$name: $@";
+	} else {
+	    print STDERR $sizeof{$name}, "\n" if $debUg;
+	}
+    } 
+
+    --$nesting;
+}
+
+
+sub psize {
+    local($me) = @_; 
+    local($amstruct) = $struct{$me} ?  'struct ' : '';
+
+    print '$sizeof{\'', $amstruct, $me, '\'} = '; 
+    printf "%d;\n", $sizeof{$me}; 
+}
+
+sub pdecl {
+    local($pdecl) = @_;
+    local(@pdecls);
+    local($tname);
+
+    warn "pdecl: $pdecl\n" if $debug;
+
+    $pdecl =~ s/\(\d+,(\d+)\)/$1/g;
+    $pdecl =~ s/\*//g; 
+    @pdecls = split(/=/, $pdecl); 
+    $typeno = $pdecls[0];
+    $tname = pop @pdecls;
+
+    if ($tname =~ s/^f//) { $tname = "$tname&"; } 
+    #else { $tname = "$tname*"; } 
+
+    for (reverse @pdecls) {
+	$tname  .= s/^f// ? "&" : "*"; 
+	#$tname =~ s/^f(.*)/$1&/;
+	print "type[$_] is $tname\n" if $debug;
+	$type[$_] = $tname unless defined $type[$_];
+    } 
+}
+
+
+
+sub adecl {
+    ($arraytype, $unknown, $lower, $upper) = ();
+    #local($typeno);
+    # global $typeno, @type
+    local($_, $typedef) = @_;
+
+    while (s/^((\d+)=)?ar(\d+);//) {
+	($arraytype, $unknown) = ($2, $3); 
+	if (s/^(\d+);(\d+);//) {
+	    ($lower, $upper) = ($1, $2); 
+	    $scripts .= '[' .  ($upper+1) . ']'; 
+	} else {
+	    warn "can't find array bounds: $_"; 
+	} 
+    }
+    if (s/^([\d*f=]*),(\d+),(\d+);//) {
+	($start, $length) = ($2, $3); 
+	local($whatis) = $1;
+	if ($whatis =~ /^(\d+)=/) {
+	    $typeno = $1;
+	    &pdecl($whatis);
+	} else {
+	    $typeno = $whatis;
+	}
+    } elsif (s/^(\d+)(=[*suf]\d*)//) {
+	local($whatis) = $2; 
+
+	if ($whatis =~ /[f*]/) {
+	    &pdecl($whatis); 
+	} elsif ($whatis =~ /[su]/) {  # 
+	    print "$prefix.$fieldname is an array$scripts anon structs; disgusting\n" 
+		if $debug;
+	    #$type[$typeno] = $name unless defined $type[$typeno];
+	    ##printf "new type $typeno is $name" if $debug;
+	    $typeno = $1;
+	    $type[$typeno] = "$prefix.$fieldname";
+	    local($name) = $type[$typeno];
+	    &sou($name, $whatis);
+	    $_ = &sdecl($name, $_, $start+$offset);
+	    1;
+	    $start = $start{$name};
+	    $offset = $sizeof{$name};
+	    $length = $offset;
+	} else {
+	    warn "what's this? $whatis in $line ";
+	} 
+    } elsif (/^\d+$/) {
+	$typeno = $_;
+    } else {
+	warn "bad array stab: $_ in $line ";
+	next STAB;
+    } 
+    #local($wasdef) = defined($type[$typeno]) && $debug;
+    #if ($typedef) { 
+	#print "redefining $type[$typeno] to " if $wasdef;
+	#$type[$typeno] = "$whatis$scripts"; # unless defined $type[$typeno];
+	#print "$type[$typeno]\n" if $wasdef;
+    #} else {
+	#$type[$arraytype] = $type[$typeno] unless defined $type[$arraytype];
+    #}
+    $type[$arraytype] = "$type[$typeno]$scripts" if defined $type[$typeno];
+    print "type[$arraytype] is $type[$arraytype]\n" if $debug;
+    print "$prefix.$fieldname is an array of $type[$arraytype]\n" if $debug;
+    $_;
+}
+
+
+
+sub sdecl {
+    local($prefix, $_, $offset) = @_;
+
+    local($fieldname, $scripts, $type, $arraytype, $unknown,
+    $whatis, $pdecl, $upper,$lower, $start,$length) = ();
+    local($typeno,$sou);
+
+
+SFIELD:
+    while (/^([^;]+);/) {
+	$scripts = '';
+	warn "sdecl $_\n" if $debug;
+	if (s/^([\$\w]+)://) { 
+	    $fieldname = $1;
+	} elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { # 
+	    $typeno = &typeno($1);
+	    $type[$typeno] = "$prefix.$fieldname";
+	    local($name) = "$prefix.$fieldname";
+	    &sou($name,$2);
+	    $_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
+	    $start = $start{$name};
+	    $offset += $sizeof{$name};
+	    #print "done with anon, start is $start, offset is $offset\n";
+	    #next SFIELD;
+	} else  {
+	    warn "weird field $_ of $line" if $debug;
+	    next STAB;
+	    #$fieldname = &gensym;
+	    #$_ = &sdecl("$prefix.$fieldname", $_, $start+$offset);
+	}
+
+	if (/^\d+=ar/) {
+	    $_ = &adecl($_);
+	}
+	elsif (s/^(\d+|\(\d+,\d+\))?,(\d+),(\d+);//) {
+	    ($start, $length) =  ($2, $3); 
+	    &panic("no length?") unless $length;
+	    $typeno = &typeno($1) if $1;
+	}
+	elsif (s/^((\d+|\(\d+,\d+\))(=[*f](\d+|\(\d+,\d+\)))+),(\d+),(\d+);//) {
+	    ($pdecl, $start, $length) =  ($1,$5,$6); 
+	    &pdecl($pdecl); 
+	}
+	elsif (s/(\d+)=([us])(\d+|\(\d+,\d+\))//) { # the dratted anon struct
+	    ($typeno, $sou) = ($1, $2);
+	    $typeno = &typeno($typeno);
+	    if (defined($type[$typeno])) {
+		warn "now how did we get type $1 in $fieldname of $line?";
+	    } else {
+		print "anon type $typeno is $prefix.$fieldname\n" if $debug;
+		$type[$typeno] = "$prefix.$fieldname" unless defined $type[$typeno];
+	    };
+	    local($name) = "$prefix.$fieldname";
+	    &sou($name,$sou);
+	    print "anon ".($isastruct{$name}) ? "struct":"union"." for $prefix.$fieldname\n" if $debug;
+	    $type[$typeno] = "$prefix.$fieldname";
+	    $_ = &sdecl("$prefix.$fieldname", $_, $start+$offset); 
+	    $start = $start{$name};
+	    $length = $sizeof{$name};
+	}
+	else {
+	    warn "can't grok stab for $name ($_) in line $line "; 
+	    next STAB; 
+	}
+
+	&panic("no length for $prefix.$fieldname") unless $length;
+	$struct{$name} .= join(',', $fieldname, $typeno, $scripts, $start, $length) . ';';
+    }
+    if (s/;\d*,(\d+),(\d+);//) {
+	local($start, $size) = ($1, $2); 
+	$sizeof{$prefix} = $size;
+	print "start of $prefix is $start, size of $sizeof{$prefix}\n" if $debug; 
+	$start{$prefix} = $start; 
+    } 
+    $_;
+}
+
+sub edecl {
+    s/;$//;
+    $enum{$name} = $_;
+    $_ = '';
+} 
+
+sub resolve_types {
+    local($sou);
+    for $i (0 .. $#type) {
+	next unless defined $type[$i];
+	$_ = $type[$i];
+	unless (/\d/) {
+	    print "type[$i] $type[$i]\n" if $debug;
+	    next;
+	}
+	print "type[$i] $_ ==> " if $debug;
+	s/^(\d+)(\**)\&\*(\**)/"$2($3".&type($1) . ')()'/e;
+	s/^(\d+)\&/&type($1)/e; 
+	s/^(\d+)/&type($1)/e; 
+	s/(\*+)([^*]+)(\*+)/$1$3$2/;
+	s/\((\*+)(\w+)(\*+)\)/$3($1$2)/;
+	s/^(\d+)([\*\[].*)/&type($1).$2/e;
+	#s/(\d+)(\*|(\[[\[\]\d\*]+]\])+)/&type($1).$2/ge;
+	$type[$i] = $_;
+	print "$_\n" if $debug;
+    }
+}
+sub type { &psou($type[$_[0]] || "<UNDEFINED>"); } 
+
+sub adjust_start_addrs {
+    for (sort keys %start) {
+	($basename = $_) =~ s/\.[^.]+$//;
+	$start{$_} += $start{$basename};
+	print "start: $_ @ $start{$_}\n" if $debug;
+    }
+}
+
+sub sou {
+    local($what, $_) = @_;
+    /u/ && $isaunion{$what}++;
+    /s/ && $isastruct{$what}++;
+}
+
+sub psou {
+    local($what) = @_;
+    local($prefix) = '';
+    if ($isaunion{$what})  {
+	$prefix = 'union ';
+    } elsif ($isastruct{$what})  {
+	$prefix = 'struct ';
+    }
+    $prefix . $what;
+}
+
+sub scrunch {
+    local($_) = @_;
+
+    study;
+
+    s/\$//g;
+    s/  / /g;
+    1 while s/(\w) \1/$1$1/g;
+
+    # i wanna say this, but perl resists my efforts:
+    #	   s/(\w)(\1+)/$2 . length($1)/ge;
+
+    &quick_scrunch;
+
+    s/ $//;
+
+    $_;
+}
+
+sub buildscrunchlist {
+    $scrunch_code = "sub quick_scrunch {\n";
+    for (values %intrinsics) {
+        $scrunch_code .= "\ts/($_{2,})/'$_' . length(\$1)/ge;\n";
+    } 
+    $scrunch_code .= "}\n";
+    print "$scrunch_code" if $debug;
+    eval $scrunch_code;
+    &panic("can't eval scrunch_code $@ \nscrunch_code") if $@;
+} 
+
+sub fetch_template {
+    local($mytype) = @_;
+    local($fmt);
+    local($count) = 1;
+
+    &panic("why do you care?") unless $perl;
+
+    if ($mytype =~ s/(\[\d+\])+$//) {
+	$count .= $1;
+    } 
+
+    if ($mytype =~ /\*/) {
+	$fmt = $template{'pointer'};
+    } 
+    elsif (defined $template{$mytype}) {
+	$fmt = $template{$mytype};
+    } 
+    elsif (defined $struct{$mytype}) {
+	if (!defined $template{&psou($mytype)}) {
+	    &build_template($mytype) unless $mytype eq $name;
+	} 
+	elsif ($template{&psou($mytype)} !~ /\$$/) {
+	    #warn "incomplete template for $mytype\n";
+	} 
+	$fmt = $template{&psou($mytype)} || '?';
+    } 
+    else {
+	warn "unknown fmt for $mytype\n";
+	$fmt = '?';
+    } 
+
+    $fmt x $count . ' ';
+}
+
+sub compute_intrinsics {
+    local($TMP) = "/tmp/c2ph-i.$$.c";
+    open (TMP, ">$TMP") || die "can't open $TMP: $!";
+    select(TMP);
+
+    print STDERR "computing intrinsic sizes: " if $trace;
+
+    undef %intrinsics;
+
+    print <<'EOF';
+main() {
+    char *mask = "%d %s\n";
+EOF
+
+    for $type (@intrinsics) {
+	next if $type eq 'void';
+	print <<"EOF";
+    printf(mask,sizeof($type), "$type");
+EOF
+    } 
+
+    print <<'EOF';
+    printf(mask,sizeof(char *), "pointer");
+    exit(0);
+}
+EOF
+    close TMP;
+
+    select(STDOUT);
+    open(PIPE, "cd /tmp && $CC $TMP && /tmp/a.out|");
+    while (<PIPE>) {
+	chop;
+	split(' ',$_,2);;
+	print "intrinsic $_[1] is size $_[0]\n" if $debug;
+	$sizeof{$_[1]} = $_[0];
+	$intrinsics{$_[1]} = $template{$_[0]};
+    } 
+    close(PIPE) || die "couldn't read intrinsics!";
+    unlink($TMP, '/tmp/a.out');
+    print STDERR "done\n" if $trace;
+} 
+
+sub scripts2count {
+    local($_) = @_;
+
+    s/^\[//;
+    s/\]$//;
+    s/\]\[/*/g;
+    $_ = eval;
+    &panic("$_: $@") if $@;
+    $_;
+}
+
+sub system {
+    print STDERR "@_\n" if $trace;
+    system @_;
+} 
+
+sub build_template { 
+    local($name) = @_;
+
+    &panic("already got a template for $name") if defined $template{$name};
+
+    local($build_templates) = 1;
+
+    local($lparen) = '(' x $build_recursed;
+    local($rparen) = ')' x $build_recursed;
+
+    print STDERR "$lparen$name$rparen " if $trace;
+    $build_recursed++;
+    &pstruct($name,$name,0);
+    print STDERR "TEMPLATE for $name is ", $template{&psou($name)}, "\n" if $debug;
+    --$build_recursed;
+}
+
+
+sub panic {
+
+    select(STDERR);
+
+    print "\npanic: @_\n";
+
+    exit 1 if $] <= 4.003;  # caller broken
+
+    local($i,$_);
+    local($p,$f,$l,$s,$h,$a,@a,@sub);
+    for ($i = 0; ($p,$f,$l,$s,$h,$w) = caller($i); $i++) {
+	@a = @DB'args;
+	for (@a) {
+	    if (/^StB\000/ && length($_) == length($_main{'_main'})) {
+		$_ = sprintf("%s",$_);
+	    }
+	    else {
+		s/'/\\'/g;
+		s/([^\0]*)/'$1'/ unless /^-?[\d.]+$/;
+		s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
+		s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
+	    }
+	}
+	$w = $w ? '@ = ' : '$ = ';
+	$a = $h ? '(' . join(', ', @a) . ')' : '';
+	push(@sub, "$w&$s$a from file $f line $l\n");
+	last if $signal;
+    }
+    for ($i=0; $i <= $#sub; $i++) {
+	last if $signal;
+	print $sub[$i];
+    }
+    exit 1;
+} 
+
+sub squishseq {
+    local($num);
+    local($last) = -1e8;
+    local($string);
+    local($seq) = '..';
+
+    while (defined($num = shift)) {
+        if ($num == ($last + 1)) {
+            $string .= $seq unless $inseq++;
+            $last = $num;
+            next;
+        } elsif ($inseq) {
+            $string .= $last unless $last == -1e8;
+        }
+
+        $string .= ',' if defined $string;
+        $string .= $num;
+        $last = $num;
+        $inseq = 0;
+    }
+    $string .= $last if $inseq && $last != -e18;
+    $string;
+}
diff -u --new-file --recursive perl-4.036.orig/x2p/Makefile perl-4.036/x2p/Makefile
--- perl-4.036.orig/x2p/Makefile	Wed Dec 31 18:00:00 1969
+++ perl-4.036/x2p/Makefile	Tue Jan 17 21:16:30 1995
@@ -0,0 +1,130 @@
+# : Makefile.SH,v 4063Revision: 4.0.1.3 4063Date: 92/06/08 16:11:32 $
+#
+# $Log:	Makefile.SH,v $
+# Revision 4.0.1.3  92/06/08  16:11:32  lwall
+# patch20: SH files didn't work well with symbolic links
+# patch20: cray didn't give enough memory to /bin/sh
+# patch20: makefiles now display new shift/reduce expectations
+# 
+# Revision 4.0.1.2  91/11/05  19:19:04  lwall
+# patch11: random cleanup
+# 
+# Revision 4.0.1.1  91/06/07  12:12:14  lwall
+# patch4: cflags now emits entire cc command except for the filename
+# 
+# Revision 4.0  91/03/20  01:57:03  lwall
+# 4.0 baseline.
+# 
+# 
+
+CC = gcc
+YACC = bison -y
+bin = /usr/bin
+lib = 
+mansrc = /usr/man/man1
+manext = 1
+LDFLAGS = -s
+SMALL = 
+LARGE =  
+mallocsrc = 
+mallocobj = 
+shellflags = 
+
+libs = -ldbm -lm
+
+CCCMD = `sh $(shellflags) cflags $@`
+
+public = a2p s2p find2perl
+
+private = 
+
+manpages = a2p.man s2p.man
+
+util =
+
+sh = Makefile.SH makedepend.SH
+
+h = EXTERN.h INTERN.h ../config.h handy.h hash.h a2p.h str.h util.h
+
+c = hash.c $(mallocsrc) str.c util.c walk.c
+
+obj = hash.o $(mallocobj) str.o util.o walk.o
+
+lintflags = -phbvxac
+
+addedbyconf = Makefile.old bsd eunice filexp loc pdp11 usg v7
+
+# grrr
+SHELL = /bin/sh
+
+.c.o:
+	$(CCCMD) $*.c
+
+all: $(public) $(private) $(util)
+	touch all
+
+a2p: $(obj) a2p.o
+	$(CC) $(LDFLAGS) $(obj) a2p.o $(libs) -o a2p
+
+a2p.c: a2p.y
+	@ echo Expect 231 shift/reduce conflicts...
+	$(YACC) a2p.y
+	mv y.tab.c a2p.c
+
+a2p.o: a2p.c a2py.c a2p.h EXTERN.h util.h INTERN.h handy.h ../config.h str.h hash.h
+	$(CCCMD) $(LARGE) a2p.c
+
+install: a2p s2p
+# won't work with csh
+	export PATH || exit 1
+	- mv $(bin)/a2p $(bin)/a2p.old 2>/dev/null
+	- mv $(bin)/s2p $(bin)/s2p.old 2>/dev/null
+	- if test `pwd` != $(bin); then cp $(public) $(bin); fi
+	cd $(bin); \
+for pub in $(public); do \
+chmod +x `basename $$pub`; \
+done
+	- if test `pwd` != $(mansrc); then \
+for page in $(manpages); do \
+cp $$page $(mansrc)/`basename $$page .man`.$(manext); \
+done; \
+fi
+
+clean:
+	rm -f a2p *.o a2p.c
+
+realclean: clean
+	rm -f *.orig */*.orig core $(addedbyconf) a2p.c s2p find2perl all cflags
+
+# The following lint has practically everything turned on.  Unfortunately,
+# you have to wade through a lot of mumbo jumbo that can't be suppressed.
+# If the source file has a /*NOSTRICT*/ somewhere, ignore the lint message
+# for that spot.
+
+lint:
+	lint $(lintflags) $(defs) $(c) > a2p.fuzz
+
+depend: $(mallocsrc) ../makedepend
+	../makedepend
+
+clist:
+	echo $(c) | tr ' ' '\012' >.clist
+
+hlist:
+	echo $(h) | tr ' ' '\012' >.hlist
+
+shlist:
+	echo $(sh) | tr ' ' '\012' >.shlist
+
+config.sh: ../config.sh
+	rm -f config.sh
+	ln ../config.sh .
+
+malloc.c: ../malloc.c
+	sed 's/"perl.h"/"..\/perl.h"/' ../malloc.c >malloc.c
+
+# AUTOMATICALLY GENERATED MAKE DEPENDENCIES--PUT NOTHING BELOW THIS LINE
+$(obj):
+	@ echo "You haven't done a "'"make depend" yet!'; exit 1
+makedepend: makedepend.SH
+	/bin/sh $(shellflags) makedepend.SH
diff -u --new-file --recursive perl-4.036.orig/x2p/cflags perl-4.036/x2p/cflags
--- perl-4.036.orig/x2p/cflags	Wed Dec 31 18:00:00 1969
+++ perl-4.036/x2p/cflags	Tue Jan 17 21:16:30 1995
@@ -0,0 +1,55 @@
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+case $CONFIG in
+'')
+    if test ! -f config.sh; then
+	ln ../config.sh . || \
+	ln ../../config.sh . || \
+	ln ../../../config.sh . || \
+	(echo "Can't find config.sh."; exit 1)
+    fi 2>/dev/null
+    . ./config.sh
+    ;;
+esac
+
+also=': '
+case $# in
+1) also='echo 1>&2 "	  CCCMD = "'
+esac
+
+case $# in
+0) set *.c; echo "The current C flags are:" ;;
+esac
+
+set `echo "$* " | sed 's/\.[oc] / /g'`
+
+for file do
+
+    case "$#" in
+    1) ;;
+    *) echo $n "    $file.c	$c" ;;
+    esac
+
+    : allow variables like str_cflags to be evaluated
+
+    eval 'eval ${'"${file}_cflags"'-""}'
+
+    : or customize here
+
+    case "$file" in
+    a2p) ;;
+    a2py) ;;
+    hash) ;;
+    str) ;;
+    util) ;;
+    walk) ;;
+    *) ;;
+    esac
+
+    echo "$cc -c $ccflags $optimize $large $split"
+    eval "$also "'"$cc -c $ccflags $optimize $large $split"'
+
+    . ./config.sh
+
+done
diff -u --new-file --recursive perl-4.036.orig/x2p/cppstdin perl-4.036/x2p/cppstdin
--- perl-4.036.orig/x2p/cppstdin	Wed Dec 31 18:00:00 1969
+++ perl-4.036/x2p/cppstdin	Tue Jan 17 21:16:26 1995
@@ -0,0 +1 @@
+cat >.$$.c; gcc -E ${1+"$@"} .$$.c; rm .$$.c
diff -u --new-file --recursive perl-4.036.orig/x2p/find2perl perl-4.036/x2p/find2perl
--- perl-4.036.orig/x2p/find2perl	Wed Dec 31 18:00:00 1969
+++ perl-4.036/x2p/find2perl	Tue Jan 17 21:16:31 1995
@@ -0,0 +1,568 @@
+#!/usr/bin/perl
+
+eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
+	if $running_under_some_shell;
+
+$bin = "/usr/bin";
+
+
+while ($ARGV[0] =~ /^[^-!(]/) {
+    push(@roots, shift);
+}
+@roots = ('.') unless @roots;
+for (@roots) { $_ = &quote($_); }
+$roots = join(',', @roots);
+
+$indent = 1;
+
+while (@ARGV) {
+    $_ = shift;
+    s/^-// || /^[()!]/ || die "Unrecognized switch: $_\n";
+    if ($_ eq '(') {
+	$out .= &tab . "(\n";
+	$indent++;
+	next;
+    }
+    elsif ($_ eq ')') {
+	$indent--;
+	$out .= &tab . ")";
+    }
+    elsif ($_ eq '!') {
+	$out .= &tab . "!";
+	next;
+    }
+    elsif ($_ eq 'name') {
+	$out .= &tab;
+	$pat = &fileglob_to_re(shift);
+	$out .= '/' . $pat . "/";
+    }
+    elsif ($_ eq 'perm') {
+	$onum = shift;
+	die "Malformed -perm argument: $onum\n" unless $onum =~ /^-?[0-7]+$/;
+	if ($onum =~ s/^-//) {
+	    $onum = '0' . sprintf("%o", oct($onum) & 017777);	# s/b 07777 ?
+	    $out .= &tab . "((\$mode & $onum) == $onum)";
+	}
+	else {
+	    $onum = '0' . $onum unless $onum =~ /^0/;
+	    $out .= &tab . "((\$mode & 0777) == $onum)";
+	}
+    }
+    elsif ($_ eq 'type') {
+	($filetest = shift) =~ tr/s/S/;
+	$out .= &tab . "-$filetest _";
+    }
+    elsif ($_ eq 'print') {
+	$out .= &tab . 'print("$name\n")';
+    }
+    elsif ($_ eq 'print0') {
+	$out .= &tab . 'print("$name\0")';
+    }
+    elsif ($_ eq 'fstype') {
+	$out .= &tab;
+	$type = shift;
+	if ($type eq 'nfs')
+	    { $out .= '$dev < 0'; }
+	else
+	    { $out .= '$dev >= 0'; }
+    }
+    elsif ($_ eq 'user') {
+	$uname = shift;
+	$out .= &tab . "\$uid == \$uid{'$uname'}";
+	$inituser++;
+    }
+    elsif ($_ eq 'group') {
+	$gname = shift;
+	$out .= &tab . "\$gid == \$gid{'$gname'}";
+	$initgroup++;
+    }
+    elsif ($_ eq 'nouser') {
+	$out .= &tab . '!defined $uid{$uid}';
+	$inituser++;
+    }
+    elsif ($_ eq 'nogroup') {
+	$out .= &tab . '!defined $gid{$gid}';
+	$initgroup++;
+    }
+    elsif ($_ eq 'links') {
+	$out .= &tab . '$nlink ' . &n(shift);
+    }
+    elsif ($_ eq 'inum') {
+	$out .= &tab . '$ino ' . &n(shift);
+    }
+    elsif ($_ eq 'size') {
+	$out .= &tab . 'int((-s _ + 511) / 512) ' . &n(shift);
+    }
+    elsif ($_ eq 'atime') {
+	$out .= &tab . 'int(-A _) ' . &n(shift);
+    }
+    elsif ($_ eq 'mtime') {
+	$out .= &tab . 'int(-M _) ' . &n(shift);
+    }
+    elsif ($_ eq 'ctime') {
+	$out .= &tab . 'int(-C _) ' . &n(shift);
+    }
+    elsif ($_ eq 'exec') {
+	for (@cmd = (); @ARGV && $ARGV[0] ne ';'; push(@cmd,shift)) { }
+	shift;
+	$_ = "@cmd";
+	if (m#^(/bin/)?rm -f {}$#) {
+	    if (!@ARGV) {
+		$out .= &tab . 'unlink($_)';
+	    }
+	    else {
+		$out .= &tab . '(unlink($_) || 1)';
+	    }
+	}
+	elsif (m#^(/bin/)?rm {}$#) {
+	    $out .= &tab . '(unlink($_) || warn "$name: $!\n")';
+	}
+	else {
+	    for (@cmd) { s/'/\\'/g; }
+	    $" = "','";
+	    $out .= &tab . "&exec(0, '@cmd')";
+	    $" = ' ';
+	    $initexec++;
+	}
+    }
+    elsif ($_ eq 'ok') {
+	for (@cmd = (); @ARGV && $ARGV[0] ne ';'; push(@cmd,shift)) { }
+	shift;
+	for (@cmd) { s/'/\\'/g; }
+	$" = "','";
+	$out .= &tab . "&exec(1, '@cmd')";
+	$" = ' ';
+	$initexec++;
+    }
+    elsif ($_ eq 'prune') {
+	$out .= &tab . '($prune = 1)';
+    }
+    elsif ($_ eq 'xdev') {
+	$out .= &tab . '(($prune |= ($dev != $topdev)),1)';
+    }
+    elsif ($_ eq 'newer') {
+	$out .= &tab;
+	$file = shift;
+	$newername = 'AGE_OF' . $file;
+	$newername =~ s/[^\w]/_/g;
+	$newername = '$' . $newername;
+	$out .= "-M _ < $newername";
+	$initnewer .= "$newername = -M " . &quote($file) . ";\n";
+    }
+    elsif ($_ eq 'eval') {
+	$prog = &quote(shift);
+	$out .= &tab . "eval $prog";
+    }
+    elsif ($_ eq 'depth') {
+	$depth++;
+	next;
+    }
+    elsif ($_ eq 'ls') {
+	$out .= &tab . "&ls";
+	$initls++;
+    }
+    elsif ($_ eq 'tar') {
+	$out .= &tab;
+	die "-tar must have a filename argument\n" unless @ARGV;
+	$file = shift;
+	$fh = 'FH' . $file;
+	$fh =~ s/[^\w]/_/g;
+	$out .= "&tar($fh)";
+	$file = '>' . $file;
+	$initfile .= "open($fh, " . &quote($file) .
+	  qq{) || die "Can't open $fh: \$!\\n";\n};
+	$inittar++;
+	$flushall = "\n&tflushall;\n";
+    }
+    elsif (/^n?cpio$/) {
+	$depth++;
+	$out .= &tab;
+	die "-$_ must have a filename argument\n" unless @ARGV;
+	$file = shift;
+	$fh = 'FH' . $file;
+	$fh =~ s/[^\w]/_/g;
+	$out .= "&cpio('" . substr($_,0,1) . "', $fh)";
+	$file = '>' . $file;
+	$initfile .= "open($fh, " . &quote($file) .
+	  qq{) || die "Can't open $fh: \$!\\n";\n};
+	$initcpio++;
+	$flushall = "\n&flushall;\n";
+    }
+    else {
+	die "Unrecognized switch: -$_\n";
+    }
+    if (@ARGV) {
+	if ($ARGV[0] eq '-o') {
+	    { local($statdone) = 1; $out .= "\n" . &tab . "||\n"; }
+	    $statdone = 0 if $indent == 1 && $delayedstat;
+	    $saw_or++;
+	    shift;
+	}
+	else {
+	    $out .= " &&" unless $ARGV[0] eq ')';
+	    $out .= "\n";
+	    shift if $ARGV[0] eq '-a';
+	}
+    }
+}
+
+print <<"END";
+#!$bin/perl
+
+eval 'exec $bin/perl -S \$0 \${1+"\$@"}'
+	if \$running_under_some_shell;
+
+END
+
+if ($initls) {
+    print <<'END';
+@rwx = ('---','--x','-w-','-wx','r--','r-x','rw-','rwx');
+@moname = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);
+
+END
+}
+
+if ($inituser || $initls) {
+    print 'while (($name, $pw, $uid) = getpwent) {', "\n";
+    print '    $uid{$name} = $uid{$uid} = $uid;', "\n" if $inituser;
+    print '    $user{$uid} = $name unless $user{$uid};', "\n" if $initls;
+    print "}\n\n";
+}
+
+if ($initgroup || $initls) {
+    print 'while (($name, $pw, $gid) = getgrent) {', "\n";
+    print '    $gid{$name} = $gid{$gid} = $gid;', "\n" if $initgroup;
+    print '    $group{$gid} = $name unless $group{$gid};', "\n" if $initls;
+    print "}\n\n";
+}
+
+print $initnewer, "\n" if $initnewer;
+
+print $initfile, "\n" if $initfile;
+
+$find = $depth ? "finddepth" : "find";
+print <<"END";
+require "$find.pl";
+
+# Traverse desired filesystems
+
+&$find($roots);
+$flushall
+exit;
+
+sub wanted {
+$out;
+}
+
+END
+
+if ($initexec) {
+    print <<'END';
+sub exec {
+    local($ok, @cmd) = @_;
+    foreach $word (@cmd) {
+	$word =~ s#{}#$name#g;
+    }
+    if ($ok) {
+	local($old) = select(STDOUT);
+	$| = 1;
+	print "@cmd";
+	select($old);
+	return 0 unless <STDIN> =~ /^y/;
+    }
+    chdir $cwd;		# sigh
+    system @cmd;
+    chdir $dir;
+    return !$?;
+}
+
+END
+}
+
+if ($initls) {
+    print <<'END';
+sub ls {
+    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$sizemm,
+      $atime,$mtime,$ctime,$blksize,$blocks) = lstat(_);
+
+    $pname = $name;
+
+    if (defined $blocks) {
+	$blocks = int(($blocks + 1) / 2);
+    }
+    else {
+	$blocks = int(($size + 1023) / 1024);
+    }
+
+    if    (-f _) { $perms = '-'; }
+    elsif (-d _) { $perms = 'd'; }
+    elsif (-c _) { $perms = 'c'; $sizemm = &sizemm; }
+    elsif (-b _) { $perms = 'b'; $sizemm = &sizemm; }
+    elsif (-p _) { $perms = 'p'; }
+    elsif (-S _) { $perms = 's'; }
+    else         { $perms = 'l'; $pname .= ' -> ' . readlink($_); }
+
+    $tmpmode = $mode;
+    $tmp = $rwx[$tmpmode & 7];
+    $tmpmode >>= 3;
+    $tmp = $rwx[$tmpmode & 7] . $tmp;
+    $tmpmode >>= 3;
+    $tmp = $rwx[$tmpmode & 7] . $tmp;
+    substr($tmp,2,1) =~ tr/-x/Ss/ if -u _;
+    substr($tmp,5,1) =~ tr/-x/Ss/ if -g _;
+    substr($tmp,8,1) =~ tr/-x/Tt/ if -k _;
+    $perms .= $tmp;
+
+    $user = $user{$uid} || $uid;
+    $group = $group{$gid} || $gid;
+
+    ($sec,$min,$hour,$mday,$mon,$year) = localtime($mtime);
+    $moname = $moname[$mon];
+    if (-M _ > 365.25 / 2) {
+	$timeyear = '19' . $year;
+    }
+    else {
+	$timeyear = sprintf("%02d:%02d", $hour, $min);
+    }
+
+    printf "%5lu %4ld %-10s %2d %-8s %-8s %8s %s %2d %5s %s\n",
+	    $ino,
+		 $blocks,
+		      $perms,
+			    $nlink,
+				$user,
+				     $group,
+					  $sizemm,
+					      $moname,
+						 $mday,
+						     $timeyear,
+							 $pname;
+    1;
+}
+
+sub sizemm {
+    sprintf("%3d, %3d", ($rdev >> 8) & 255, $rdev & 255);
+}
+
+END
+}
+
+if ($initcpio) {
+print <<'END';
+sub cpio {
+    local($nc,$fh) = @_;
+    local($text);
+
+    if ($name eq 'TRAILER!!!') {
+	$text = '';
+	$size = 0;
+    }
+    else {
+	($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+	  $atime,$mtime,$ctime,$blksize,$blocks) = lstat(_);
+	if (-f _) {
+	    open(IN, "./$_\0") || do {
+		warn "Couldn't open $name: $!\n";
+		return;
+	    };
+	}
+	else {
+	    $text = readlink($_);
+	    $size = 0 unless defined $text;
+	}
+    }
+
+    ($nm = $name) =~ s#^\./##;
+    $nc{$fh} = $nc;
+    if ($nc eq 'n') {
+	$cpout{$fh} .=
+	  sprintf("%06o%06o%06o%06o%06o%06o%06o%06o%011lo%06o%011lo%s\0",
+	    070707,
+	    $dev & 0777777,
+	    $ino & 0777777,
+	    $mode & 0777777,
+	    $uid & 0777777,
+	    $gid & 0777777,
+	    $nlink & 0777777,
+	    $rdev & 0177777,
+	    $mtime,
+	    length($nm)+1,
+	    $size,
+	    $nm);
+    }
+    else {
+	$cpout{$fh} .= "\0" if length($cpout{$fh}) & 1;
+	$cpout{$fh} .= pack("SSSSSSSSLSLa*",
+	    070707, $dev, $ino, $mode, $uid, $gid, $nlink, $rdev, $mtime,
+	    length($nm)+1, $size, $nm . (length($nm) & 1 ? "\0" : "\0\0"));
+    }
+    if ($text ne '') {
+	$cpout{$fh} .= $text;
+    }
+    elsif ($size) {
+	&flush($fh) while ($l = length($cpout{$fh})) >= 5120;
+	while (sysread(IN, $cpout{$fh}, 5120 - $l, $l)) {
+	    &flush($fh);
+	    $l = length($cpout{$fh});
+	}
+    }
+    close IN;
+}
+
+sub flush {
+    local($fh) = @_;
+
+    while (length($cpout{$fh}) >= 5120) {
+	syswrite($fh,$cpout{$fh},5120);
+	++$blocks{$fh};
+	substr($cpout{$fh}, 0, 5120) = '';
+    }
+}
+
+sub flushall {
+    $name = 'TRAILER!!!';
+    foreach $fh (keys %cpout) {
+	&cpio($nc{$fh},$fh);
+	$cpout{$fh} .= "0" x (5120 - length($cpout{$fh}));
+	&flush($fh);
+	print $blocks{$fh} * 10, " blocks\n";
+    }
+}
+
+END
+}
+
+if ($inittar) {
+print <<'END';
+sub tar {
+    local($fh) = @_;
+    local($linkname,$header,$l,$slop);
+    local($linkflag) = "\0";
+
+    ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+      $atime,$mtime,$ctime,$blksize,$blocks) = lstat(_);
+    $nm = $name;
+    if ($nlink > 1) {
+	if ($linkname = $linkseen{$fh,$dev,$ino}) {
+	    $linkflag = 1;
+	}
+	else {
+	    $linkseen{$fh,$dev,$ino} = $nm;
+	}
+    }
+    if (-f _) {
+	open(IN, "./$_\0") || do {
+	    warn "Couldn't open $name: $!\n";
+	    return;
+	};
+	$size = 0 if $linkflag ne "\0";
+    }
+    else {
+	$linkname = readlink($_);
+	$linkflag = 2 if defined $linkname;
+	$nm .= '/' if -d _;
+	$size = 0;
+    }
+
+    $header = pack("a100a8a8a8a12a12a8a1a100",
+	$nm,
+	sprintf("%6o ", $mode & 0777),
+	sprintf("%6o ", $uid & 0777777),
+	sprintf("%6o ", $gid & 0777777),
+	sprintf("%11o ", $size),
+	sprintf("%11o ", $mtime),
+	"        ",
+	$linkflag,
+	$linkname);
+    $l = length($header) % 512;
+    substr($header, 148, 6) = sprintf("%6o", unpack("%16C*", $header));
+    substr($header, 154, 1) = "\0";  # blech
+    $tarout{$fh} .= $header;
+    $tarout{$fh} .= "\0" x (512 - $l) if $l;
+    if ($size) {
+	&tflush($fh) while ($l = length($tarout{$fh})) >= 10240;
+	while (sysread(IN, $tarout{$fh}, 10240 - $l, $l)) {
+	    $slop = length($tarout{$fh}) % 512;
+	    $tarout{$fh} .= "\0" x (512 - $slop) if $slop;
+	    &tflush($fh);
+	    $l = length($tarout{$fh});
+	}
+    }
+    close IN;
+}
+
+sub tflush {
+    local($fh) = @_;
+
+    while (length($tarout{$fh}) >= 10240) {
+	syswrite($fh,$tarout{$fh},10240);
+	++$blocks{$fh};
+	substr($tarout{$fh}, 0, 10240) = '';
+    }
+}
+
+sub tflushall {
+    local($len);
+
+    foreach $fh (keys %tarout) {
+	$len = 10240 - length($tarout{$fh});
+	$len += 10240 if $len < 1024;
+	$tarout{$fh} .= "\0" x $len;
+	&tflush($fh);
+    }
+}
+
+END
+}
+
+exit;
+
+############################################################################
+
+sub tab {
+    local($tabstring);
+
+    $tabstring = "\t" x ($indent / 2) . ' ' x ($indent % 2 * 4);
+    if (!$statdone) {
+	if ($_ =~ /^(name|print|prune|exec|ok|\(|\))/) {
+	    $delayedstat++;
+	}
+	else {
+	    if ($saw_or) {
+		$tabstring .= <<'ENDOFSTAT' . $tabstring;
+($nlink || (($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_))) &&
+ENDOFSTAT
+	    }
+	    else {
+		$tabstring .= <<'ENDOFSTAT' . $tabstring;
+(($dev,$ino,$mode,$nlink,$uid,$gid) = lstat($_)) &&
+ENDOFSTAT
+	    }
+	    $statdone = 1;
+	}
+    }
+    $tabstring =~ s/^\s+/ / if $out =~ /!$/;
+    $tabstring;
+}
+
+sub fileglob_to_re {
+    local($tmp) = @_;
+
+    $tmp =~ s/([.^\$()])/\\$1/g;
+    $tmp =~ s/([?*])/.$1/g;
+    "^$tmp$";
+}
+
+sub n {
+    local($n) = @_;
+
+    $n =~ s/^-/< / || $n =~ s/^\+/> / || $n =~ s/^/== /;
+    $n =~ s/ 0*(\d)/ $1/;
+    $n;
+}
+
+sub quote {
+    local($string) = @_;
+    $string =~ s/'/\\'/;
+    "'$string'";
+}
diff -u --new-file --recursive perl-4.036.orig/x2p/s2p perl-4.036/x2p/s2p
--- perl-4.036.orig/x2p/s2p	Wed Dec 31 18:00:00 1969
+++ perl-4.036/x2p/s2p	Tue Jan 17 21:16:31 1995
@@ -0,0 +1,758 @@
+#!/usr/bin/perl
+
+eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
+	if $running_under_some_shell;
+
+$bin = '/usr/bin';
+
+# $RCSfile: s2p.SH,v $$Revision: 4.0.1.2 $$Date: 92/06/08 17:26:31 $
+#
+# $Log:	s2p.SH,v $
+# Revision 4.0.1.2  92/06/08  17:26:31  lwall
+# patch20: s2p didn't output portable startup code
+# patch20: added ... as variant on ..
+# patch20: s2p didn't translate s/pat/\&/ or s/pat/\$/ or s/pat/\\1/ right
+# 
+# Revision 4.0.1.1  91/06/07  12:19:18  lwall
+# patch4: s2p now handles embedded newlines better and optimizes common idioms
+# 
+# Revision 4.0  91/03/20  01:57:59  lwall
+# 4.0 baseline.
+# 
+#
+
+$indent = 4;
+$shiftwidth = 4;
+$l = '{'; $r = '}';
+
+while ($ARGV[0] =~ /^-/) {
+    $_ = shift;
+  last if /^--/;
+    if (/^-D/) {
+	$debug++;
+	open(BODY,'>-');
+	next;
+    }
+    if (/^-n/) {
+	$assumen++;
+	next;
+    }
+    if (/^-p/) {
+	$assumep++;
+	next;
+    }
+    die "I don't recognize this switch: $_\n";
+}
+
+unless ($debug) {
+    open(BODY,">/tmp/sperl$$") ||
+      &Die("Can't open temp file: $!\n");
+}
+
+if (!$assumen && !$assumep) {
+    print BODY &q(<<'EOT');
+:	while ($ARGV[0] =~ /^-/) {
+:	    $_ = shift;
+:	  last if /^--/;
+:	    if (/^-n/) {
+:		$nflag++;
+:		next;
+:	    }
+:	    die "I don't recognize this switch: $_\\n";
+:	}
+:	
+EOT
+}
+
+print BODY &q(<<'EOT');
+:	#ifdef PRINTIT
+:	#ifdef ASSUMEP
+:	$printit++;
+:	#else
+:	$printit++ unless $nflag;
+:	#endif
+:	#endif
+:	<><>
+:	$\ = "\n";		# automatically add newline on print
+:	<><>
+:	#ifdef TOPLABEL
+:	LINE:
+:	while (chop($_ = <>)) {
+:	#else
+:	LINE:
+:	while (<>) {
+:	    chop;
+:	#endif
+EOT
+
+LINE:
+while (<>) {
+
+    # Wipe out surrounding whitespace.
+
+    s/[ \t]*(.*)\n$/$1/;
+
+    # Perhaps it's a label/comment.
+
+    if (/^:/) {
+	s/^:[ \t]*//;
+	$label = &make_label($_);
+	if ($. == 1) {
+	    $toplabel = $label;
+	    if (/^(top|(re)?start|redo|begin(ning)|again|input)$/i) {
+		$_ = <>;
+		redo LINE; # Never referenced, so delete it if not a comment.
+	    }
+	}
+	$_ = "$label:";
+	if ($lastlinewaslabel++) {
+	    $indent += 4;
+	    print BODY &tab, ";\n";
+	    $indent -= 4;
+	}
+	if ($indent >= 2) {
+	    $indent -= 2;
+	    $indmod = 2;
+	}
+	next;
+    } else {
+	$lastlinewaslabel = '';
+    }
+
+    # Look for one or two address clauses
+
+    $addr1 = '';
+    $addr2 = '';
+    if (s/^([0-9]+)//) {
+	$addr1 = "$1";
+	$addr1 = "\$. == $addr1" unless /^,/;
+    }
+    elsif (s/^\$//) {
+	$addr1 = 'eof()';
+    }
+    elsif (s|^/||) {
+	$addr1 = &fetchpat('/');
+    }
+    if (s/^,//) {
+	if (s/^([0-9]+)//) {
+	    $addr2 = "$1";
+	} elsif (s/^\$//) {
+	    $addr2 = "eof()";
+	} elsif (s|^/||) {
+	    $addr2 = &fetchpat('/');
+	} else {
+	    &Die("Invalid second address at line $.\n");
+	}
+	if ($addr2 =~ /^\d+$/) {
+	    $addr1 .= "..$addr2";
+	}
+	else {
+	    $addr1 .= "...$addr2";
+	}
+    }
+
+    # Now we check for metacommands {, }, and ! and worry
+    # about indentation.
+
+    s/^[ \t]+//;
+    # a { to keep vi happy
+    if ($_ eq '}') {
+	$indent -= 4;
+	next;
+    }
+    if (s/^!//) {
+	$if = 'unless';
+	$else = "$r else $l\n";
+    } else {
+	$if = 'if';
+	$else = '';
+    }
+    if (s/^{//) {	# a } to keep vi happy
+	$indmod = 4;
+	$redo = $_;
+	$_ = '';
+	$rmaybe = '';
+    } else {
+	$rmaybe = "\n$r";
+	if ($addr2 || $addr1) {
+	    $space = ' ' x $shiftwidth;
+	} else {
+	    $space = '';
+	}
+	$_ = &transmogrify();
+    }
+
+    # See if we can optimize to modifier form.
+
+    if ($addr1) {
+	if ($_ !~ /[\n{}]/ && $rmaybe && !$change &&
+	  $_ !~ / if / && $_ !~ / unless /) {
+	    s/;$/ $if $addr1;/;
+	    $_ = substr($_,$shiftwidth,1000);
+	} else {
+	    $_ = "$if ($addr1) $l\n$change$_$rmaybe";
+	}
+	$change = '';
+	next LINE;
+    }
+} continue {
+    @lines = split(/\n/,$_);
+    for (@lines) {
+	unless (s/^ *<<--//) {
+	    print BODY &tab;
+	}
+	print BODY $_, "\n";
+    }
+    $indent += $indmod;
+    $indmod = 0;
+    if ($redo) {
+	$_ = $redo;
+	$redo = '';
+	redo LINE;
+    }
+}
+if ($lastlinewaslabel++) {
+    $indent += 4;
+    print BODY &tab, ";\n";
+    $indent -= 4;
+}
+
+if ($appendseen || $tseen || !$assumen) {
+    $printit++ if $dseen || (!$assumen && !$assumep);
+    print BODY &q(<<'EOT');
+:	#ifdef SAWNEXT
+:	}
+:	continue {
+:	#endif
+:	#ifdef PRINTIT
+:	#ifdef DSEEN
+:	#ifdef ASSUMEP
+:	    print if $printit++;
+:	#else
+:	    if ($printit)
+:		{ print; }
+:	    else
+:		{ $printit++ unless $nflag; }
+:	#endif
+:	#else
+:	    print if $printit;
+:	#endif
+:	#else
+:	    print;
+:	#endif
+:	#ifdef TSEEN
+:	    $tflag = 0;
+:	#endif
+:	#ifdef APPENDSEEN
+:	    if ($atext) { chop $atext; print $atext; $atext = ''; }
+:	#endif
+EOT
+
+print BODY &q(<<'EOT');
+:	}
+EOT
+}
+
+close BODY;
+
+unless ($debug) {
+    open(HEAD,">/tmp/sperl2$$.c")
+      || &Die("Can't open temp file 2: $!\n");
+    print HEAD "#define PRINTIT\n"	if $printit;
+    print HEAD "#define APPENDSEEN\n"	if $appendseen;
+    print HEAD "#define TSEEN\n"	if $tseen;
+    print HEAD "#define DSEEN\n"	if $dseen;
+    print HEAD "#define ASSUMEN\n"	if $assumen;
+    print HEAD "#define ASSUMEP\n"	if $assumep;
+    print HEAD "#define TOPLABEL\n"	if $toplabel;
+    print HEAD "#define SAWNEXT\n"	if $sawnext;
+    if ($opens) {print HEAD "$opens\n";}
+    open(BODY,"/tmp/sperl$$")
+      || &Die("Can't reopen temp file: $!\n");
+    while (<BODY>) {
+	print HEAD $_;
+    }
+    close HEAD;
+
+    print &q(<<"EOT");
+:	#!$bin/perl
+:	eval 'exec $bin/perl -S \$0 \${1+"\$@"}'
+:		if \$running_under_some_shell;
+:	
+EOT
+    open(BODY,"cc -E /tmp/sperl2$$.c |") ||
+	&Die("Can't reopen temp file: $!\n");
+    while (<BODY>) {
+	/^# [0-9]/ && next;
+	/^[ \t]*$/ && next;
+	s/^<><>//;
+	print;
+    }
+}
+
+&Cleanup;
+exit;
+
+sub Cleanup {
+    chdir "/tmp";
+    unlink "sperl$$", "sperl2$$", "sperl2$$.c";
+}
+sub Die {
+    &Cleanup;
+    die $_[0];
+}
+sub tab {
+    "\t" x ($indent / 8) . ' ' x ($indent % 8);
+}
+sub make_filehandle {
+    local($_) = $_[0];
+    local($fname) = $_;
+    if (!$seen{$fname}) {
+	$_ = "FH_" . $_ if /^\d/;
+	s/[^a-zA-Z0-9]/_/g;
+	s/^_*//;
+	$_ = "\U$_";
+	if ($fhseen{$_}) {
+	    for ($tmp = "a"; $fhseen{"$_$tmp"}; $a++) {}
+	    $_ .= $tmp;
+	}
+	$fhseen{$_} = 1;
+	$opens .= &q(<<"EOT");
+:	open($_, '>$fname') || die "Can't create $fname: \$!";
+EOT
+	$seen{$fname} = $_;
+    }
+    $seen{$fname};
+}
+
+sub make_label {
+    local($label) = @_;
+    $label =~ s/[^a-zA-Z0-9]/_/g;
+    if ($label =~ /^[0-9_]/) { $label = 'L' . $label; }
+    $label = substr($label,0,8);
+
+    # Could be a reserved word, so capitalize it.
+    substr($label,0,1) =~ y/a-z/A-Z/
+      if $label =~ /^[a-z]/;
+
+    $label;
+}
+
+sub transmogrify {
+    {	# case
+	if (/^d/) {
+	    $dseen++;
+	    chop($_ = &q(<<'EOT'));
+:	<<--#ifdef PRINTIT
+:	$printit = 0;
+:	<<--#endif
+:	next LINE;
+EOT
+	    $sawnext++;
+	    next;
+	}
+
+	if (/^n/) {
+	    chop($_ = &q(<<'EOT'));
+:	<<--#ifdef PRINTIT
+:	<<--#ifdef DSEEN
+:	<<--#ifdef ASSUMEP
+:	print if $printit++;
+:	<<--#else
+:	if ($printit)
+:	    { print; }
+:	else
+:	    { $printit++ unless $nflag; }
+:	<<--#endif
+:	<<--#else
+:	print if $printit;
+:	<<--#endif
+:	<<--#else
+:	print;
+:	<<--#endif
+:	<<--#ifdef APPENDSEEN
+:	if ($atext) {chop $atext; print $atext; $atext = '';}
+:	<<--#endif
+:	$_ = <>;
+:	chop;
+:	<<--#ifdef TSEEN
+:	$tflag = 0;
+:	<<--#endif
+EOT
+	    next;
+	}
+
+	if (/^a/) {
+	    $appendseen++;
+	    $command = $space . "\$atext .= <<'End_Of_Text';\n<<--";
+	    $lastline = 0;
+	    while (<>) {
+		s/^[ \t]*//;
+		s/^[\\]//;
+		unless (s|\\$||) { $lastline = 1;}
+		s/^([ \t]*\n)/<><>$1/;
+		$command .= $_;
+		$command .= '<<--';
+		last if $lastline;
+	    }
+	    $_ = $command . "End_Of_Text";
+	    last;
+	}
+
+	if (/^[ic]/) {
+	    if (/^c/) { $change = 1; }
+	    $addr1 = 1 if $addr1 eq '';
+	    $addr1 = '$iter = (' . $addr1 . ')';
+	    $command = $space .
+	      "    if (\$iter == 1) { print <<'End_Of_Text'; }\n<<--";
+	    $lastline = 0;
+	    while (<>) {
+		s/^[ \t]*//;
+		s/^[\\]//;
+		unless (s/\\$//) { $lastline = 1;}
+		s/'/\\'/g;
+		s/^([ \t]*\n)/<><>$1/;
+		$command .= $_;
+		$command .= '<<--';
+		last if $lastline;
+	    }
+	    $_ = $command . "End_Of_Text";
+	    if ($change) {
+		$dseen++;
+		$change = "$_\n";
+		chop($_ = &q(<<"EOT"));
+:	<<--#ifdef PRINTIT
+:	$space\$printit = 0;
+:	<<--#endif
+:	${space}next LINE;
+EOT
+		$sawnext++;
+	    }
+	    last;
+	}
+
+	if (/^s/) {
+	    $delim = substr($_,1,1);
+	    $len = length($_);
+	    $repl = $end = 0;
+	    $inbracket = 0;
+	    for ($i = 2; $i < $len; $i++) {
+		$c = substr($_,$i,1);
+		if ($c eq $delim) {
+		    if ($inbracket) {
+			substr($_, $i, 0) = '\\';
+			$i++;
+			$len++;
+		    }
+		    else {
+			if ($repl) {
+			    $end = $i;
+			    last;
+			} else {
+			    $repl = $i;
+			}
+		    }
+		}
+		elsif ($c eq '\\') {
+		    $i++;
+		    if ($i >= $len) {
+			$_ .= 'n';
+			$_ .= <>;
+			$len = length($_);
+			$_ = substr($_,0,--$len);
+		    }
+		    elsif (substr($_,$i,1) =~ /^[n]$/) {
+			;
+		    }
+		    elsif (!$repl &&
+		      substr($_,$i,1) =~ /^[(){}\w]$/) {
+			$i--;
+			$len--;
+			substr($_, $i, 1) = '';
+		    }
+		    elsif (!$repl &&
+		      substr($_,$i,1) =~ /^[<>]$/) {
+			substr($_,$i,1) = 'b';
+		    }
+		    elsif ($repl && substr($_,$i,1) =~ /^\d$/) {
+			substr($_,$i-1,1) = '$';
+		    }
+		}
+		elsif ($c eq '&' && $repl) {
+		    substr($_, $i, 0) = '$';
+		    $i++;
+		    $len++;
+		}
+		elsif ($c eq '$' && $repl) {
+		    substr($_, $i, 0) = '\\';
+		    $i++;
+		    $len++;
+		}
+		elsif ($c eq '[' && !$repl) {
+		    $i++ if substr($_,$i,1) eq '^';
+		    $i++ if substr($_,$i,1) eq ']';
+		    $inbracket = 1;
+		}
+		elsif ($c eq ']') {
+		    $inbracket = 0;
+		}
+		elsif ($c eq "\t") {
+		    substr($_, $i, 1) = '\\t';
+		    $i++;
+		    $len++;
+		}
+		elsif (!$repl && index("()+",$c) >= 0) {
+		    substr($_, $i, 0) = '\\';
+		    $i++;
+		    $len++;
+		}
+	    }
+	    &Die("Malformed substitution at line $.\n")
+	      unless $end;
+	    $pat = substr($_, 0, $repl + 1);
+	    $repl = substr($_, $repl+1, $end-$repl-1);
+	    $end = substr($_, $end + 1, 1000);
+	    &simplify($pat);
+	    $dol = '$';
+	    $subst = "$pat$repl$delim";
+	    $cmd = '';
+	    while ($end) {
+		if ($end =~ s/^g//) {
+		    $subst .= 'g';
+		    next;
+		}
+		if ($end =~ s/^p//) {
+		    $cmd .= ' && (print)';
+		    next;
+		}
+		if ($end =~ s/^w[ \t]*//) {
+		    $fh = &make_filehandle($end);
+		    $cmd .= " && (print $fh \$_)";
+		    $end = '';
+		    next;
+		}
+		&Die("Unrecognized substitution command".
+		  "($end) at line $.\n");
+	    }
+	    chop ($_ = &q(<<"EOT"));
+:	<<--#ifdef TSEEN
+:	$subst && \$tflag++$cmd;
+:	<<--#else
+:	$subst$cmd;
+:	<<--#endif
+EOT
+	    next;
+	}
+
+	if (/^p/) {
+	    $_ = 'print;';
+	    next;
+	}
+
+	if (/^w/) {
+	    s/^w[ \t]*//;
+	    $fh = &make_filehandle($_);
+	    $_ = "print $fh \$_;";
+	    next;
+	}
+
+	if (/^r/) {
+	    $appendseen++;
+	    s/^r[ \t]*//;
+	    $file = $_;
+	    $_ = "\$atext .= `cat $file 2>/dev/null`;";
+	    next;
+	}
+
+	if (/^P/) {
+	    $_ = 'print $1 if /^(.*)/;';
+	    next;
+	}
+
+	if (/^D/) {
+	    chop($_ = &q(<<'EOT'));
+:	s/^.*\n?//;
+:	redo LINE if $_;
+:	next LINE;
+EOT
+	    $sawnext++;
+	    next;
+	}
+
+	if (/^N/) {
+	    chop($_ = &q(<<'EOT'));
+:	$_ .= "\n";
+:	$len1 = length;
+:	$_ .= <>;
+:	chop if $len1 < length;
+:	<<--#ifdef TSEEN
+:	$tflag = 0;
+:	<<--#endif
+EOT
+	    next;
+	}
+
+	if (/^h/) {
+	    $_ = '$hold = $_;';
+	    next;
+	}
+
+	if (/^H/) {
+	    $_ = '$hold .= "\n"; $hold .= $_;';
+	    next;
+	}
+
+	if (/^g/) {
+	    $_ = '$_ = $hold;';
+	    next;
+	}
+
+	if (/^G/) {
+	    $_ = '$_ .= "\n"; $_ .= $hold;';
+	    next;
+	}
+
+	if (/^x/) {
+	    $_ = '($_, $hold) = ($hold, $_);';
+	    next;
+	}
+
+	if (/^b$/) {
+	    $_ = 'next LINE;';
+	    $sawnext++;
+	    next;
+	}
+
+	if (/^b/) {
+	    s/^b[ \t]*//;
+	    $lab = &make_label($_);
+	    if ($lab eq $toplabel) {
+		$_ = 'redo LINE;';
+	    } else {
+		$_ = "goto $lab;";
+	    }
+	    next;
+	}
+
+	if (/^t$/) {
+	    $_ = 'next LINE if $tflag;';
+	    $sawnext++;
+	    $tseen++;
+	    next;
+	}
+
+	if (/^t/) {
+	    s/^t[ \t]*//;
+	    $lab = &make_label($_);
+	    $_ = q/if ($tflag) {$tflag = 0; /;
+	    if ($lab eq $toplabel) {
+		$_ .= 'redo LINE;}';
+	    } else {
+		$_ .= "goto $lab;}";
+	    }
+	    $tseen++;
+	    next;
+	}
+
+	if (/^y/) {
+	    s/abcdefghijklmnopqrstuvwxyz/a-z/g;
+	    s/ABCDEFGHIJKLMNOPQRSTUVWXYZ/A-Z/g;
+	    s/abcdef/a-f/g;
+	    s/ABCDEF/A-F/g;
+	    s/0123456789/0-9/g;
+	    s/01234567/0-7/g;
+	    $_ .= ';';
+	}
+
+	if (/^=/) {
+	    $_ = 'print $.;';
+	    next;
+	}
+
+	if (/^q/) {
+	    chop($_ = &q(<<'EOT'));
+:	close(ARGV);
+:	@ARGV = ();
+:	next LINE;
+EOT
+	    $sawnext++;
+	    next;
+	}
+    } continue {
+	if ($space) {
+	    s/^/$space/;
+	    s/(\n)(.)/$1$space$2/g;
+	}
+	last;
+    }
+    $_;
+}
+
+sub fetchpat {
+    local($outer) = @_;
+    local($addr) = $outer;
+    local($inbracket);
+    local($prefix,$delim,$ch);
+
+    # Process pattern one potential delimiter at a time.
+
+    DELIM: while (s#^([^\]+(|)[\\/]*)([]+(|)[\\/])##) {
+	$prefix = $1;
+	$delim = $2;
+	if ($delim eq '\\') {
+	    s/(.)//;
+	    $ch = $1;
+	    $delim = '' if $ch =~ /^[(){}A-Za-mo-z]$/;
+	    $ch = 'b' if $ch =~ /^[<>]$/;
+	    $delim .= $ch;
+	}
+	elsif ($delim eq '[') {
+	    $inbracket = 1;
+	    s/^\^// && ($delim .= '^');
+	    s/^]// && ($delim .= ']');
+	}
+	elsif ($delim eq ']') {
+	    $inbracket = 0;
+	}
+	elsif ($inbracket || $delim ne $outer) {
+	    $delim = '\\' . $delim;
+	}
+	$addr .= $prefix;
+	$addr .= $delim;
+	if ($delim eq $outer && !$inbracket) {
+	    last DELIM;
+	}
+    }
+    $addr =~ s/\t/\\t/g;
+    &simplify($addr);
+    $addr;
+}
+
+sub q {
+    local($string) = @_;
+    local($*) = 1;
+    $string =~ s/^:\t?//g;
+    $string;
+}
+
+sub simplify {
+    $_[0] =~ s/_a-za-z0-9/\\w/ig;
+    $_[0] =~ s/a-z_a-z0-9/\\w/ig;
+    $_[0] =~ s/a-za-z_0-9/\\w/ig;
+    $_[0] =~ s/a-za-z0-9_/\\w/ig;
+    $_[0] =~ s/_0-9a-za-z/\\w/ig;
+    $_[0] =~ s/0-9_a-za-z/\\w/ig;
+    $_[0] =~ s/0-9a-z_a-z/\\w/ig;
+    $_[0] =~ s/0-9a-za-z_/\\w/ig;
+    $_[0] =~ s/\[\\w\]/\\w/g;
+    $_[0] =~ s/\[^\\w\]/\\W/g;
+    $_[0] =~ s/\[0-9\]/\\d/g;
+    $_[0] =~ s/\[^0-9\]/\\D/g;
+    $_[0] =~ s/\\d\\d\*/\\d+/g;
+    $_[0] =~ s/\\D\\D\*/\\D+/g;
+    $_[0] =~ s/\\w\\w\*/\\w+/g;
+    $_[0] =~ s/\\t\\t\*/\\t+/g;
+    $_[0] =~ s/(\[.[^]]*\])\1\*/$1+/g;
+    $_[0] =~ s/([\w\s!@#%^&-=,:;'"])\1\*/$1+/g;
+}
+
