From 577ed4095383ef5284225d45709e6b5f0598a064 Mon Sep 17 00:00:00 2001
From: behdad <behdad>
Date: Mon, 3 May 2004 05:17:48 +0000
Subject: Initial revision

---
 C++autodoc       |  292 ++++
 CHANGES          |  127 ++
 ChangeLog        |   29 +
 Configure        | 4822 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 FAQ              |  204 +++
 INSTALL          |   74 +
 MANIFEST         |   64 +
 Makefile.SH      |  172 ++
 README           |  112 ++
 autodoc.c        |  554 +++++++
 c2man.c          |  928 +++++++++++
 c2man.h          |  284 ++++
 c2man.man        |  906 ++++++++++
 catalog          |   44 +
 config_h.SH      |  353 ++++
 confmagic.h      |   27 +
 ctype_ex.h       |   38 +
 eg/boxcomment.c  |   41 +
 eg/ccomment.h    |   41 +
 eg/commentaft.c  |    1 +
 eg/cppcomment.h  |   32 +
 eg/dash.h        |    2 +
 eg/ellipsis.c    |   15 +
 eg/grouped.c     |   23 +
 eg/multidecl.c   |    3 +
 eg/namedash.h    |    9 +
 eg/oldstyle.c    |   24 +
 eg/retdecl.c     |   10 +
 eg/returnerr.h   |   16 +
 eg/returnlist.h  |   16 +
 eg/sections.c    |   17 +
 eg/simplesect.c  |   13 +
 eg/surround.c    |    6 +
 eg/underscore.h  |   21 +
 eg/variable.c    |    5 +
 enum.c           |  179 ++
 enum.h           |   41 +
 example.h        |   18 +
 fixexamp.in      |   60 +
 flatten.SH       |   51 +
 grammar.y        |  947 +++++++++++
 html.c           |  453 +++++
 latex.c          |  356 ++++
 lex.l            |  621 +++++++
 libc/COPYING     |  339 ++++
 libc/README.libc |   10 +
 libc/alloca.c    |  186 +++
 libc/getopt.c    |  735 +++++++++
 libc/getopt.h    |  129 ++
 libc/getopt1.c   |  176 ++
 manpage.c        | 1347 +++++++++++++++
 manpage.h        |   64 +
 nroff.c          |  424 +++++
 output.h         |  149 ++
 patchlevel.h     |    2 +
 semantic.c       |  732 +++++++++
 semantic.h       |  121 ++
 strappend.c      |   64 +
 strappend.h      |    6 +
 strconcat.c      |   74 +
 strconcat.h      |    6 +
 string.c         |   82 +
 symbol.c         |  119 ++
 symbol.h         |   41 +
 texinfo.c        |  465 ++++++
 65 files changed, 17322 insertions(+)
 create mode 100644 C++autodoc
 create mode 100644 CHANGES
 create mode 100644 ChangeLog
 create mode 100755 Configure
 create mode 100644 FAQ
 create mode 100644 INSTALL
 create mode 100644 MANIFEST
 create mode 100755 Makefile.SH
 create mode 100644 README
 create mode 100644 autodoc.c
 create mode 100644 c2man.c
 create mode 100644 c2man.h
 create mode 100644 c2man.man
 create mode 100644 catalog
 create mode 100644 config_h.SH
 create mode 100644 confmagic.h
 create mode 100644 ctype_ex.h
 create mode 100644 eg/boxcomment.c
 create mode 100644 eg/ccomment.h
 create mode 100644 eg/commentaft.c
 create mode 100644 eg/cppcomment.h
 create mode 100644 eg/dash.h
 create mode 100644 eg/ellipsis.c
 create mode 100644 eg/grouped.c
 create mode 100644 eg/multidecl.c
 create mode 100644 eg/namedash.h
 create mode 100644 eg/oldstyle.c
 create mode 100644 eg/retdecl.c
 create mode 100644 eg/returnerr.h
 create mode 100644 eg/returnlist.h
 create mode 100644 eg/sections.c
 create mode 100644 eg/simplesect.c
 create mode 100644 eg/surround.c
 create mode 100644 eg/underscore.h
 create mode 100644 eg/variable.c
 create mode 100644 enum.c
 create mode 100644 enum.h
 create mode 100644 example.h
 create mode 100644 fixexamp.in
 create mode 100644 flatten.SH
 create mode 100644 grammar.y
 create mode 100644 html.c
 create mode 100644 latex.c
 create mode 100644 lex.l
 create mode 100644 libc/COPYING
 create mode 100644 libc/README.libc
 create mode 100644 libc/alloca.c
 create mode 100644 libc/getopt.c
 create mode 100644 libc/getopt.h
 create mode 100644 libc/getopt1.c
 create mode 100644 manpage.c
 create mode 100644 manpage.h
 create mode 100644 nroff.c
 create mode 100644 output.h
 create mode 100644 patchlevel.h
 create mode 100644 semantic.c
 create mode 100644 semantic.h
 create mode 100644 strappend.c
 create mode 100644 strappend.h
 create mode 100644 strconcat.c
 create mode 100644 strconcat.h
 create mode 100644 string.c
 create mode 100644 symbol.c
 create mode 100644 symbol.h
 create mode 100644 texinfo.c

diff --git a/C++autodoc b/C++autodoc
new file mode 100644
index 0000000..468f1dd
--- /dev/null
+++ b/C++autodoc
@@ -0,0 +1,292 @@
+From greyham Thu Oct 28 18:42:35 1993
+Newsgroups: comp.lang.c++,comp.programming.literate
+Subject: An Automatic C++ documentation compilation project.
+Summary: Anyone willing to add C++ support to c2man?
+Keywords: c2man, C, C++, Literate Programming, Documentation
+
+Copyright 1993, 1994 by Graham Stoney.
+This may be freely redistributed or quoted, so long as it's attributed to me.
+
+Writing and maintaining documentation has often been a thorn in the side of the
+Software Engineer and Programmer. After spending a great deal of time and
+effort writing documentation about a program or software system, the code
+invariably changes, quickly rendering the documentation out of date. The
+documentation becomes misleading, gets neglected, and quickly becomes useless.
+
+"Literate Programming" is one approach to solving this problem. It effectively
+introduces a whole new (typesetting) language, requires a quite radical shift
+on the part of the "non-literate" programmer and still requires a good deal of
+effort on the part of the programmer[1].
+
+I'd like to suggest a different approach which lies considerably closer to
+more traditional programming practices, and can offer quite immediate benefits
+when functional interface documentation is the main documentation required.
+
+The primary philosophy here is to use the programming language as far as
+possible to express the programmer's intentions, and to use comments only when
+the programming language is not sufficiently expressive. A comment can then
+become part of the language grammar which is recognised by a "documentation
+compiler". This tool parses a superset of the programming language and can
+automatically generate documentation in human-readable form by associating the
+programmer's comments with the objects in the code by their context.
+
+Whilst the idea of extracting documentation from comments in source code is by
+no means new, the difference here is that the comments actually form part of
+the grammar of the language recognised by the documentation compiler[2].
+
+Comments should not repeat information that is already represented in the
+program code; for instance, a comment describing a function argument should not
+repeat the name and type of that argument (since that information has already
+been included, for the compiler), but should appear near the argument.
+
+For example, in C, the programmer should write this:
+
+	/* include an example in the article */
+	enum Result example(int page	/* page it appears on */);
+
+Rather than this:
+
+	/* include an example in the article
+	 *
+	 * PARAMETERS:
+	 *	int page	page it appears on
+	 *
+	 * RETURNS:
+	 *	RESULT_YES		The readers agreed
+	 *	RESULT_NO		The readers disagreed
+	 *	RESULT_YOURE_JOKING	The readers disagreed strongly
+	 *	RESULT_BLANK_LOOKS	The readers didn't understand
+	 */
+	enum Result example(int page);
+
+
+Also in this example, the documentation compiler knows the possible enumerated
+values that the function can return (as does the "real" compiler), so it is
+unnecessary for the programmer to restate them. The comments need simply be
+included in the definition for "enum Result" for the "RETURNS" information to
+be generated automatically:
+
+    enum Result {
+	RESULT_YES,		/* The readers agreed */
+	RESULT_NO,		/* The readers disagreed */
+	RESULT_YOURE_JOKING,	/* The readers disagreed strongly */
+	RESULT_BLANK_LOOKS	/* The readers didn't understand */
+    };
+
+Critics have suggested that the latter style in the example is easier to read
+for someone wishing to call the function in question. Of course, this is a
+style question which depends on each person's tastes; but the criticism is tied
+to the notion that the source code needs to look "beautiful" because it is the
+primary reference for someone wishing to use that function. This becomes much
+less significant once documentation is available which is known to _always_ be
+up to date. Of course, the latter style takes longer to write and maintain,
+and can become out of date should the name or type of the parameter be
+changed, yet the comment get neglected.
+
+I have implemented one such documentation compiler for the C language called
+"c2man", which is freely available[3]. The response from users has been
+extremely encouraging; I suspect this is partly because of the wide variety of
+styles of comment placement that are recognised: it often correctly recognises
+comments that weren't written with c2man in mind at all. While it's use is
+focused solely on functional interface documentation and it doesn't have
+anywhere near the power of a full Literate Programming system, the focus is on
+reducing the effort required by the programmer to the absolute minimum, and
+seeing how much documentation we can get essentially "for free".
+
+Many people have requested C++ support be added to c2man, and I suspect that
+this philosophy would be even more suitable and powerful for documenting
+interfaces to C++ classes automatically.
+
+Here is an example of how I envisage this philosophy would work when applied to
+C++. It's interesting to note that this code was written a couple of years ago
+exactly as you see it here, without the idea of generating documentation from
+it in mind at all:
+
+
+    // generic Timer class
+    class Timer
+    {
+    private:
+	static int numactive;	// number of constructed timers.
+	static Timer *first;	// first one in list.
+	Timer *next;		// next one in linked list.
+	Time ticksdiff;		// ticks we take to expire once at front.
+
+	enum
+	{
+		INACTIVE,	// timer is not in chain.
+		STARTED,	// one-shot
+		RUNNING		// continuous.
+	} state;
+
+	// original interrupt vector value.
+	static void interrupt (far *old_vector)(...);
+
+	void (*timeout_function)(int);	// function called when we time out
+	int timeout_parameter;		// gets passed to timeout_function
+	Time duration;			// timer length (ticks)
+
+	static void interrupt far tick(...);	// clock tick routine.
+
+	void insert();	// add into active chain.
+	void remove();	// remove from active chain.
+	void set(Time milliseconds);	// set duration from ms.
+
+    public:
+	// constructor
+	Timer(Time time=0,		// milliseconds
+	      void (*function)(int)=0,	// called at timeout
+	      int param=-1);		// param for function
+
+	// destructor
+	~Timer();
+
+	// start (or restart) a timer running.
+	void Start();
+	void Start(Time duration);	// how long to run for
+
+	// start a timer running continuous.
+	void Run();
+
+	// stop a timer.
+	void Stop();
+
+	// is a timer active?
+	boolean Active() const { return state != INACTIVE; };
+    };
+
+
+Processing this class declaration could generate the following automatically:
+
+    NAME
+	    Timer - generic timer class
+    
+    SYNOPSIS
+	    class Timer
+	    {
+	    public:
+		    Timer(Time time=0,
+			    void (*function)(int)=0,
+			    int param=-1);
+		    ~Timer();
+		    void Start();
+		    void Start(Time duration);
+		    void Run();
+		    void Stop();
+		    boolean Active() const;
+	    };
+    
+    PARAMETERS
+	Time time
+	    Milliseconds
+    
+	void (*function)(int)
+	    called at timeout.
+    
+	int param
+	    Param for function.
+    
+	Time duration
+	    How long to run for.
+    
+    DESCRIPTION
+	Timer
+	    Constructor
+    
+	~Timer
+	    Destructor
+    
+	Start
+	    Start (or restart) a timer running.
+    
+	Run
+	    Start a timer running continuous.
+    
+	Stop
+	    Stop a timer.
+    
+	Active
+	    Is a timer active?.
+
+
+It should also be possible to extract this information from the implementation
+of the class (rather than the declaration), if that's where the user prefers to
+put the comments describing each member function and their parameters.
+
+The ideal tool should:
+1. Avoid imposing a style on the programmer.
+2. Work out section names (NAME, SYNOPSIS etc) without the programmer having
+   to specify them explicitly.
+3. Handle C++ and C style code equally well.
+4. Not require the programmer to restate information which is already expressed
+   in the syntax of the programming language.
+5. Work reasonably well with existing code.
+6. Flatten the class hierarchy so that the documentation for each class
+   includes virtually everything the user needs to know about it.
+
+A number of tools already exist which attempt to tackle this problem, such as
+class2man, genman, classdoc and docclass.  They vary in sophistication,
+utility, and the demands they place on the programmer; however, none as yet
+meet all the criteria set out above, and no one tool will suit the tastes of
+all programmers.
+
+Pouring lots of effort into a really ``smart'' documentation generator makes
+sense because once it's done, you get a payback for every document you
+generate. Every little feature added to the documentation generator to make
+things easier for the programmer pays off multiple times, and minimising the
+effort required by the programmer is the key.
+
+The logical starting point would be to graft Jim Roskind's C++ grammar[4] into
+c2man, modifying it to recognise comments in the relevant places, and adding
+all the necessary structures to hold the information from the parser that will
+get included in the output.  Very little functional change should be needed in
+the lexer, which already recognises C++ comments.
+
+Unfortunately, at present I do not have sufficient spare time to make the
+additions to c2man required to support C++. It would be a great contribution to
+the C++ community, not to mention the documentation time saved by themselves,
+for someone involved in C++ work to add this support and release the result[5].
+
+If you work with a team developing C++ code, please consider having one of your
+developers on a ``Usenet Sabbatical'' to extend this philosophy to C++, and
+start reaping the benefits in documentation time savings.
+
+It could also make an ideal Computer Science student compiler project.
+
+Please contact me via E-mail if you are interested in undertaking such a
+project.
+
+
+Graham Stoney
+greyham@research.canon.com.au
+
+Footnotes:
+1. Advocates of Literate Programming would argue that Literate Programming is
+   much more than snazzy documents and that it encourages this extra effort to
+   focus early on in the design of the software, which pays off later.
+
+2. To get a better idea, see the file grammar.y in the c2man distribution.
+
+3. c2man has been posted to comp.sources.misc. It should be available from:
+location:	ftp from any comp.sources.misc archive, in volume42
+		(the version in the comp.sources.reviewed archive is obsolete)
+		ftp /pub/Unix/Util/c2man-2.0.*.tar.gz from dnpap.et.tudelft.nl
+    Australia:	ftp /usenet/comp.sources.misc/volume42/c2man-2.0/*
+		from archie.au
+    N.America:	ftp /usenet/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.wustl.edu
+    Europe:	ftp /News/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.irisa.fr
+    Japan:	ftp /pub/NetNews/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.iij.ad.jp
+    Patches:	ftp pub/netnews/sources.bugs/volume93/sep/c2man* from lth.se
+
+4. Jim Roskind's yaccable C++ grammar is available via ftp from
+   ics.uci.edu in the ftp/pub directory as:
+
+        c++grammar2.0.tar.Z 
+        byacc1.8.tar.Z
+
+5. c2man's copyright requires that all derivative works remain freely
+   available.
+
diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..01fbeea
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,127 @@
+Version 1.1:
+	This was the first release, so there were no changes yet.
+
+Version 1.2:
+	The README in 1.1 incorrectly stated that c2man was public domain. It
+	is in fact copyright, but freely redistributable. See the updated
+	README for details.
+
+	You can use flex instead of lex now.
+
+	Comments on parameters in old-style function definitions work OK now.
+
+	Generates man pages for global variables (with -v) as well as
+	functions.
+
+	Major mods to parser to support comments at the end of lines; this
+	makes it much more tolerant about comment placement.
+
+	c2man will now parse its own source!. The manual pages it generates are
+	pretty bad since the comments haven't been strategically placed, but
+	it's better than you might expect without trying.
+
+	Rewrote a lot of the manual page to make it comprehensible.
+
+Version 1.3:
+	Ignores all comments in included files, except those in enum
+	specifications; this should virtually eliminate trouble with errors in
+	files you may have no control over, like system headers.
+
+	Add "-o -" functionality to write manual pages to stdout.
+
+	Run /lib/cpp when reading from stdin too.
+
+	Rewrite comment parsing to be neater & easier to modify.
+
+	Replace -DSYSV option with its inverse -DBSD so ANSI string functions
+	are used by default.
+
+	enum tag/description spacing in output varies automatically.
+
+	Sprinkle output heavily with Bold for troff.
+
+Version 1.4:
+	Recognise that an end-of-line comment after a function definition or
+	declaration applies to the last parameter of a function, so we handle:
+
+	    /* try to do something that requires 2 parameters */
+	    int try(int a,	/* description of first parameter */
+		    int b);	/* description of second parameter */
+
+	Fix comment lexing problem that sometimes rejected the '# ...' lines
+	that cpp generates on the line immediately after a comment.
+
+	Don't capitalise n/troff dot commands.
+
+	make -V option act verbosely.
+
+	By popular demand, added -G option to group manual pages from the
+	same file together, ala ctype(3).
+
+	Output function prototype on a single line for all functions with one
+	or less parameters (ignoring -f...).
+
+Version 1.5:
+	Recognise end-of-line comments after K&R style function parameters.
+
+	Specify C-preprocessor command in Makefile and add -P option to specify
+	a different preprocessor at runtime.
+
+	Add -g option like -G, but read the terse description from the file.
+
+	Don't disable nroff line filling in SYNOPSIS section so very long lines
+	still get broken.
+
+	Require a white-space after a period before capitalising the next
+	letter. i.e. Don't damage "i.e.".
+
+Version 1.6:
+	Don't reduce pointer-to-pointers down to a single indirection level;
+	eg: "char **argv" got output as "char *argv". Ugh!.
+
+Version 1.7:
+	Don't try to free a string constant right at the very end!.
+
+	Rename old -i option to -H, and add new -i option so user can specify
+	extra #include lines for the SYNOPSIS section, and prerequisites for .h
+	file compilation.
+
+	Work around Sun acc -E problem where .h files were ignored.
+
+	Semantic change: multiple input files all get cross-referenced in the
+	SEE ALSO section (or grouped together if -g or -G).
+
+Version 1.8:
+	Add -lPW I'd dropped from HPUX configuration.
+	
+	Fix multiple -i arguments appearing on the one line.
+
+Version 1.9:
+	Fix silly missing fprintf arguments in c2man.c
+
+	Ignore trailing spaces after a comment at the end of a line.
+
+	Don't error on "typedef int NewType; NewType a;"
+
+	-Ssection option added by jerry@kesa24.kesa.com (Jerry E. Dunmire).
+
+Version 1.10:
+	Accept comments around a final ellipsis parameter.
+
+	Make parameter declarations in the prototype and the PARAMETERS section
+	identical.
+
+Version 2.0:
+	Major modifications to use Configure for easy installation.
+
+	Many, many portability fixes; converted to K&R 1 C.
+
+	Accept stdin even if preprocessor doesn't.
+
+	Don't error on:		int fred() {
+				} /* fred */
+
+	Allow extra manual page sections not recognized by c2man.
+
+From version 2.0 onwards, the change log for each patch is contained in the
+top of the patch itself.  This file is no longer updated.
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..0dc65b1
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,29 @@
+Wed Apr 24 12:08:09 EST 1996   Graham Stoney <greyham@research.canon.com.au>
+
+. Description:
+
+	-k doesn't take an option, reported by J.Thompson@swansea.ac.uk.
+
+	Add Marco Nijdam to the awards list.
+
+	Handle RETURNS comment next to declarator, from Marco Nijdam.
+	Also add an example of its usage in the eg directory.
+
+	Allow spaces in a section heading, from Marco Nijdam.
+
+	Make #include more flexible, from Steven E. Haehn.
+
+	Handle comments boxed with ---- and =====. 
+
+	Update the README a bit.
+
+	Add ChangeLog file, to track changes.
+
+	Update my E-mail address.
+	The '.oz.au' in my address has now officially changed to '.com.au',
+	although the old address will continue to work indefinitely.
+
+	Fix a couple of minor manual page things.
+
+	Update the Free Compilers Catalog entry.
+
diff --git a/Configure b/Configure
new file mode 100755
index 0000000..87e16cd
--- /dev/null
+++ b/Configure
@@ -0,0 +1,4822 @@
+#! /bin/sh
+#
+# If these # comments don't work, trim them. Don't worry about any other
+# shell scripts, Configure will trim # comments from them for you.
+#
+# (If you are trying to port this package to a machine without sh,
+# I would suggest you have a look at the prototypical config_h.SH file
+# and edit it to reflect your system. Some packages may include samples
+# of config.h for certain machines, so you might look for one of those.)
+#
+# Yes, you may rip this off to use in other distribution packages. This
+# script belongs to the public domain and cannot be copyrighted.
+#
+# (Note: this Configure script was generated automatically. Rather than
+# working with this copy of Configure, you may wish to get metaconfig.
+# The dist-3.0 package (which contains metaconfig) was posted in
+# comp.sources.misc and is available on CPAN under authors/id/RAM so
+# you may fetch it yourself from your nearest archive site.)
+#
+
+# $Id: Configure,v 1.1 2004-05-03 05:17:48 behdad Exp $
+#
+# Generated on Thu Feb 19 19:32:00 CST 2004 [metaconfig 3.0 PL70]
+
+cat >/tmp/c1$$ <<EOF
+ARGGGHHHH!!!!!
+
+SCO csh still thinks true is false.  Write to SCO today and tell them that next
+year Configure ought to "rm /bin/csh" unless they fix their blasted shell. :-)
+
+(Actually, Configure ought to just patch csh in place.  Hmm.  Hmmmmm.  All
+we'd have to do is go in and swap the && and || tokens, wherever they are.)
+
+[End of diatribe. We now return you to your regularly scheduled programming...]
+EOF
+cat >/tmp/c2$$ <<EOF
+
+OOPS!  You naughty creature!  You didn't run Configure with sh!
+I will attempt to remedy the situation by running sh for you...
+EOF
+
+true || cat /tmp/c1$$ /tmp/c2$$
+true || exec sh $0 $argv:q
+
+(exit $?0) || cat /tmp/c2$$
+(exit $?0) || exec sh $0 $argv:q
+rm -f /tmp/c1$$ /tmp/c2$$
+
+: compute my invocation name
+me=$0
+case "$0" in
+*/*)
+	me=`echo $0 | sed -e 's!.*/\(.*\)!\1!' 2>/dev/null`
+	test "$me" || me=$0
+	;;
+esac
+
+: Proper PATH separator
+p_=:
+: On OS/2 this directory should exist if this is not floppy only system :-]
+if test -d c:/.; then
+	p_=\;
+	PATH=`cmd /c "echo %PATH%" | tr '\\\\' / `
+	OS2_SHELL=`cmd /c "echo %OS2_SHELL%" | tr '\\\\' / | tr '[A-Z]' '[a-z]'`
+fi
+
+: Proper PATH setting
+paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin'
+paths="$paths /opt/bin /opt/local/bin /opt/local /opt/lbin"
+paths="$paths /usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin"
+paths="$paths /opt/gnu/bin /opt/new /opt/new/bin /opt/nbin"
+paths="$paths /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb"
+paths="$paths /bsd4.3/usr/bin /usr/bsd /bsd43/bin /usr/ccs/bin"
+paths="$paths /etc /usr/lib /usr/ucblib /lib /usr/ccs/lib"
+paths="$paths /sbin /usr/sbin /usr/libexec"
+
+for p in $paths
+do
+	case "$p_$PATH$p_" in
+	*$p_$p$p_*) ;;
+	*) test -d $p && PATH=$PATH$p_$p ;;
+	esac
+done
+
+PATH=.$p_$PATH
+export PATH
+
+: shall we be using ksh?
+inksh=''
+needksh=''
+avoidksh=''
+newsh=/bin/ksh
+changesh=''
+if (PATH=.; alias -x) >/dev/null 2>&1; then
+		inksh=true
+fi
+if test -f /hp-ux -a -f /bin/ksh; then
+	needksh='to avoid sh bug in "here document" expansion'
+fi
+if test -d /usr/lpp -a -f /usr/bin/bsh -a -f /usr/bin/uname; then
+	if test X`/usr/bin/uname -v` = X4; then
+		avoidksh="to avoid AIX 4's /bin/sh"
+		newsh=/usr/bin/bsh
+	fi
+fi
+case "$inksh/$needksh" in
+/[a-z]*)
+		unset ENV
+		changesh=true
+		reason="$needksh"
+	;;
+esac
+case "$inksh/$avoidksh" in
+true/[a-z]*)
+	changesh=true
+	reason="$avoidksh"
+	;;
+esac
+case "$inksh/$needksh-$avoidksh-" in
+true/--)
+		cat <<EOM
+(I see you are using the Korn shell.  Some ksh's blow up on $me,
+mainly on older exotic systems.  If yours does, try the Bourne shell instead.)
+EOM
+	;;
+esac
+case "$changesh" in
+true)
+	echo "(Feeding myself to $newsh $reason.)"
+	case "$0" in
+	Configure|*/Configure) exec $newsh $0 "$@";;
+	*) exec $newsh Configure "$@";;
+	esac
+	;;
+esac
+
+: Configure runs within the UU subdirectory
+test -d UU || mkdir UU
+unset CDPATH
+cd UU && rm -f ./*
+
+d_bsd=''
+d_eunice=''
+d_xenix=''
+eunicefix=''
+Mcc=''
+ar=''
+awk=''
+bash=''
+bison=''
+byacc=''
+cat=''
+chgrp=''
+chmod=''
+chown=''
+comm=''
+compress=''
+cp=''
+cpio=''
+cpp=''
+csh=''
+date=''
+echo=''
+egrep=''
+emacs=''
+expr=''
+find=''
+flex=''
+gcc=''
+grep=''
+gzip=''
+inews=''
+ksh=''
+less=''
+line=''
+lint=''
+ln=''
+lp=''
+lpr=''
+ls=''
+mail=''
+mailx=''
+make=''
+mkdir=''
+more=''
+mv=''
+nroff=''
+perl=''
+pg=''
+pmake=''
+pr=''
+rm=''
+rmail=''
+sed=''
+sendmail=''
+shar=''
+sleep=''
+smail=''
+sort=''
+submit=''
+tail=''
+tar=''
+tbl=''
+test=''
+touch=''
+tr=''
+troff=''
+uname=''
+uniq=''
+uuname=''
+vi=''
+zcat=''
+zip=''
+hint=''
+myuname=''
+osname=''
+osvers=''
+Author=''
+Date=''
+Header=''
+Id=''
+Locker=''
+Log=''
+RCSfile=''
+Revision=''
+Source=''
+State=''
+archobjs=''
+firstmakefile=''
+afs=''
+bin=''
+binexp=''
+installbin=''
+cc=''
+gccversion=''
+ccflags=''
+cppflags=''
+ldflags=''
+lkflags=''
+locincpth=''
+optimize=''
+cf_by=''
+cf_time=''
+contains=''
+cppfilecom=''
+cppstdinflags=''
+d_cppcanstdin=''
+d_cppignhdrs=''
+cpplast=''
+cppminus=''
+cpprun=''
+cppstdin=''
+d_access=''
+d_attribut=''
+d_const=''
+d_flexfnam=''
+d_gnulibc=''
+d_link=''
+d_open3=''
+d_portable=''
+d_index=''
+d_strchr=''
+d_strftime=''
+d_strstr=''
+d_symlink=''
+d_time=''
+timetype=''
+d_voidsig=''
+signal_t=''
+d_volatile=''
+h_fcntl=''
+h_sysfile=''
+i_fcntl=''
+i_stddef=''
+i_stdlib=''
+i_string=''
+strings=''
+i_sysfile=''
+i_systypes=''
+i_systime=''
+i_systimek=''
+i_time=''
+timeincl=''
+i_unistd=''
+i_stdarg=''
+i_varargs=''
+i_varhdr=''
+lex=''
+lexflags=''
+libc=''
+glibpth=''
+libpth=''
+loclibpth=''
+plibpth=''
+xlibpth=''
+libs=''
+libyacc=''
+lns=''
+installmansrc=''
+manext=''
+mansrc=''
+mansrcexp=''
+mkdep=''
+c=''
+n=''
+package=''
+spackage=''
+prefix=''
+prefixexp=''
+installprivlib=''
+privlib=''
+privlibexp=''
+prototype=''
+sh=''
+so=''
+sharpbang=''
+shsharp=''
+spitshell=''
+src=''
+startsh=''
+sysman=''
+nm_opt=''
+nm_so_opt=''
+runnm=''
+usenm=''
+incpath=''
+mips=''
+mips_type=''
+usrinc=''
+vaproto=''
+defvoidused=''
+voidflags=''
+warnflags=''
+yacc=''
+yaccflags=''
+CONFIG=''
+
+define='define'
+undef='undef'
+smallmach='pdp11 i8086 z8000 i80286 iAPX286'
+rmlist=''
+
+: We must find out about Eunice early
+eunicefix=':'
+if test -f /etc/unixtovms; then
+	eunicefix=/etc/unixtovms
+fi
+if test -f /etc/unixtovms.exe; then
+	eunicefix=/etc/unixtovms.exe
+fi
+
+: No trailing extension on UNIX executables
+_exe='' 
+: Extra object files, if any, needed on this platform.
+archobjs=''
+gccversion=''
+: Possible local include directories to search.
+: Set locincpth to "" in a hint file to defeat local include searches.
+locincpth="/usr/local/include /opt/local/include /usr/gnu/include"
+locincpth="$locincpth /opt/gnu/include /usr/GNU/include /opt/GNU/include"
+:
+: no include file wanted by default
+inclwanted=''
+
+i_sysselct=''
+: change the next line if compiling for Xenix/286 on Xenix/386
+xlibpth='/usr/lib/386 /lib/386'
+
+: Possible local library directories to search.
+loclibpth="/usr/local/lib /opt/local/lib /usr/gnu/lib"
+loclibpth="$loclibpth /opt/gnu/lib /usr/GNU/lib /opt/GNU/lib"
+
+: general looking path for locating libraries
+glibpth="/shlib /usr/shlib /lib/pa1.1 /usr/lib/large"
+glibpth="$glibpth /lib /usr/lib $xlibpth"
+glibpth="$glibpth /lib/large /usr/lib/small /lib/small"
+glibpth="$glibpth /usr/ccs/lib /usr/ucblib /usr/local/lib"
+
+: Private path used by Configure to find libraries.  Its value
+: is prepended to libpth. This variable takes care of special
+: machines, like the mips.  Usually, it should be empty.
+plibpth=''
+
+: default library list
+libswanted=''
+large=''
+: full support for void wanted by default
+defvoidused=15
+
+
+: Find the basic shell for Bourne shell scripts
+case "$sh" in
+'')
+	case "$SYSTYPE" in
+	*bsd*|sys5*) xxx="/$SYSTYPE/bin/sh";;
+	*) xxx='/bin/sh';;
+	esac
+	if test -f "$xxx"; then
+		sh="$xxx"
+	else
+		: Build up a list and do a single loop so we can 'break' out.
+		pth=`echo $PATH | sed -e "s/$p_/ /g"`
+		for xxx in sh bash ksh pdksh ash; do
+			for p in $pth; do
+				try="$try ${p}/${xxx}"
+			done
+		done
+		for xxx in $try; do
+			if test -f "$xxx"; then
+				sh="$xxx";
+				break
+			elif test -f "$xxx.exe"; then
+				sh="$xxx";
+				break
+			fi
+		done
+	fi
+	;;
+esac
+
+case "$sh" in
+'')	cat <<EOM >&2
+$me:  Fatal Error:  I can't find a Bourne Shell anywhere.  
+
+Usually it's in /bin/sh.  How did you even get this far?
+Please contact me (Manoj Srivastava) at srivasta@debian.org and 
+we'll try to straighten this all out.
+EOM
+	exit 1
+	;;
+esac
+
+: see if sh knows # comments
+if `$sh -c '#' >/dev/null 2>&1`; then
+	shsharp=true
+	spitshell=cat
+	xcat=/bin/cat
+	test -f $xcat || xcat=/usr/bin/cat
+	echo "#!$xcat" >try
+	$eunicefix try
+	chmod +x try
+	./try > today
+	if test -s today; then
+		sharpbang='#!'
+	else
+		echo "#! $xcat" > try
+		$eunicefix try
+		chmod +x try
+		./try > today
+		if test -s today; then
+			sharpbang='#! '
+		else
+			sharpbang=': use '
+		fi
+	fi
+else
+	echo " "
+	echo "Your $sh doesn't grok # comments--I will strip them later on."
+	shsharp=false
+	cd ..
+	echo "exec grep -v '^[ 	]*#'" >spitshell
+	chmod +x spitshell
+	$eunicefix spitshell
+	spitshell=`pwd`/spitshell
+	cd UU
+	echo "I presume that if # doesn't work, #! won't work either!"
+	sharpbang=': use '
+fi
+rm -f try today
+
+: figure out how to guarantee sh startup
+case "$startsh" in
+'') startsh=${sharpbang}${sh} ;;
+*)
+esac
+cat >try <<EOSS
+$startsh
+set abc
+test "$?abc" != 1
+EOSS
+
+chmod +x try
+$eunicefix try
+if ./try; then
+	: echo "Yup, it does."
+else
+	echo "Hmm... '$startsh' does not guarantee sh startup..."
+	echo "You may have to fix up the shell scripts to make sure $sh runs them."
+fi
+rm -f try
+
+: produce awk script to parse command line options
+cat >options.awk <<'EOF'
+BEGIN {
+	optstr = "dD:eEf:hKOrsSU:V";	# getopt-style specification
+
+	len = length(optstr);
+	for (i = 1; i <= len; i++) {
+		c = substr(optstr, i, 1);
+		if (i < len) a = substr(optstr, i + 1, 1); else a = "";
+		if (a == ":") {
+			arg[c] = 1;
+			i++;
+		}
+		opt[c] = 1;
+	}
+}
+{
+	expect = 0;
+	str = $0;
+	if (substr(str, 1, 1) != "-") {
+		printf("'%s'\n", str);
+		next;
+	}
+	len = length($0);
+	for (i = 2; i <= len; i++) {
+		c = substr(str, i, 1);
+		if (!opt[c]) {
+			printf("-%s\n", substr(str, i));
+			next;
+		}
+		printf("-%s\n", c);
+		if (arg[c]) {
+			if (i < len)
+				printf("'%s'\n", substr(str, i + 1));
+			else
+				expect = 1;
+			next;
+		}
+	}
+}
+END {
+	if (expect)
+		print "?";
+}
+EOF
+
+: process the command line options
+set X `for arg in "$@"; do echo "X$arg"; done |
+	sed -e s/X// | awk -f options.awk`
+eval "set $*"
+shift
+rm -f options.awk
+
+: set up default values
+fastread=''
+reuseval=false
+config_sh=''
+alldone=''
+error=''
+silent=''
+extractsh=''
+override=''
+knowitall=''
+rm -f optdef.sh
+cat >optdef.sh <<EOS
+$startsh
+EOS
+
+
+: option parsing
+while test $# -gt 0; do
+	case "$1" in
+	-d) shift; fastread=yes;;
+	-e) shift; alldone=cont;;
+	-f)
+		shift
+		cd ..
+		if test -r "$1"; then
+			config_sh="$1"
+		else
+			echo "$me: cannot read config file $1." >&2
+			error=true
+		fi
+		cd UU
+		shift;;
+	-h) shift; error=true;;
+	-r) shift; reuseval=true;;
+	-s) shift; silent=true; realsilent=true;;
+	-E) shift; alldone=exit;;
+	-K) shift; knowitall=true;;
+	-O) shift; override=true;;
+	-S) shift; silent=true; extractsh=true;;
+	-D)
+		shift
+		case "$1" in
+		*=)
+			echo "$me: use '-U symbol=', not '-D symbol='." >&2
+			echo "$me: ignoring -D $1" >&2
+			;;
+		*=*) echo "$1" | \
+				sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;;
+		*) echo "$1='define'" >> optdef.sh;;
+		esac
+		shift
+		;;
+	-U)
+		shift
+		case "$1" in
+		*=) echo "$1" >> optdef.sh;;
+		*=*)
+			echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2
+			echo "$me: ignoring -U $1" >&2
+			;;
+		*) echo "$1='undef'" >> optdef.sh;;
+		esac
+		shift
+		;;
+	-V) echo "$me generated by metaconfig 3.0 PL70." >&2
+		exit 0;;
+	--) break;;
+	-*) echo "$me: unknown option $1" >&2; shift; error=true;;
+	*) break;;
+	esac
+done
+
+case "$error" in
+true)
+	cat >&2 <<EOM
+Usage: $me [-dehrsEKOSV] [-f config.sh] [-D symbol] [-D symbol=value]
+                 [-U symbol] [-U symbol=]
+  -d : use defaults for all answers.
+  -e : go on without questioning past the production of config.sh.
+  -f : specify an alternate default configuration file.
+  -h : print this help message and exit (with an error status).
+  -r : reuse C symbols value if possible (skips costly nm extraction).
+  -s : silent mode, only echoes questions and essential information.
+  -D : define symbol to have some value:
+         -D symbol         symbol gets the value 'define'
+         -D symbol=value   symbol gets the value 'value'
+  -E : stop at the end of questions, after having produced config.sh.
+  -K : do not use unless you know what you are doing.
+  -O : let -D and -U override definitions from loaded configuration file.
+  -S : perform variable substitutions on all .SH files (can mix with -f)
+  -U : undefine symbol:
+         -U symbol    symbol gets the value 'undef'
+         -U symbol=   symbol gets completely empty
+  -V : print version number and exit (with a zero status).
+EOM
+	exit 1
+	;;
+esac
+
+: Sanity checks
+case "$fastread$alldone" in
+yescont|yesexit) ;;
+*)
+	if test ! -t 0; then
+		echo "Say 'sh Configure', not 'sh <Configure'"
+		exit 1
+	fi
+	;;
+esac
+
+exec 4>&1
+case "$silent" in
+true) exec 1>/dev/null;;
+esac
+
+: run the defines and the undefines, if any, but leave the file out there...
+touch optdef.sh
+. ./optdef.sh
+
+: set package name
+package=c2man
+first=`echo $package | sed -e 's/^\(.\).*/\1/'`
+last=`echo $package | sed -e 's/^.\(.*\)/\1/'`
+case "`echo AbyZ | tr '[:lower:]' '[:upper:]' 2>/dev/null`" in
+ABYZ) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;;
+*) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;;
+esac
+
+: Some greps do not return status, grrr.
+echo "grimblepritz" >grimble
+if grep blurfldyick grimble >/dev/null 2>&1 ; then
+	contains=contains
+elif grep grimblepritz grimble >/dev/null 2>&1 ; then
+	contains=grep
+else
+	contains=contains
+fi
+rm -f grimble
+: the following should work in any shell
+case "$contains" in
+contains*)
+	echo " "
+	echo "AGH!  Grep doesn't return a status.  Attempting remedial action."
+	cat >contains <<'EOSS'
+grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp
+EOSS
+chmod +x contains
+esac
+
+: first determine how to suppress newline on echo command
+echo " "
+echo "Checking echo to see how to suppress newlines..."
+(echo "hi there\c" ; echo " ") >.echotmp
+if $contains c .echotmp >/dev/null 2>&1 ; then
+	echo "...using -n."
+	n='-n'
+	c=''
+else
+	cat <<'EOM'
+...using \c
+EOM
+	n=''
+	c='\c'
+fi
+echo $n "The star should be here-->$c"
+echo '*'
+rm -f .echotmp
+
+: compute the number of columns on the terminal for proper question formatting
+case "$COLUMNS" in
+'') COLUMNS='80';;
+esac
+
+: set up the echo used in my read
+myecho="case \"\$xxxm\" in
+'') echo $n \"\$rp $c\" >&4;;
+*) case \"\$rp\" in
+	'') echo $n \"[\$xxxm] $c\";;
+	*)
+		if test \`echo \"\$rp [\$xxxm]  \" | wc -c\` -ge $COLUMNS; then
+			echo \"\$rp\" >&4
+			echo $n \"[\$xxxm] $c\" >&4
+		else
+			echo $n \"\$rp [\$xxxm] $c\" >&4
+		fi
+		;;
+	esac;;
+esac"
+
+: now set up to do reads with possible shell escape and default assignment
+cat <<EOSC >myread
+$startsh
+xxxm=\$dflt
+$myecho
+ans='!'
+case "\$fastread" in
+yes) case "\$dflt" in
+	'') ;;
+	*) ans='';
+		case "\$silent-\$rp" in
+		true-) ;;
+		*) echo " " >&4;;
+		esac;;
+	esac;;
+*) case "\$silent" in
+	true) case "\$rp" in
+		'') ans='';;
+		esac;;
+	esac;;
+esac
+while expr "X\$ans" : "X!" >/dev/null; do
+	read answ
+	set x \$xxxm
+	shift
+	aok=''; eval "ans=\\"\$answ\\"" && aok=y
+	case  "\$answ" in
+	"!")
+		sh 1>&4
+		echo " "
+		$myecho
+		;;
+	!*)
+		set x \`expr "X\$ans" : "X!\(.*\)\$"\`
+		shift
+		sh 1>&4 -c "\$*"
+		echo " "
+		$myecho
+		;;
+	"\$ans")
+		case "\$ans" in
+		\\&*)
+			set x \`expr "X\$ans" : "X&\(.*\)\$"\`
+			shift
+			case "\$1" in
+			-d)
+				fastread=yes
+				echo "(OK, I'll run with -d after this question.)" >&4
+				;;
+			-*)
+				echo "*** Sorry, \$1 not supported yet." >&4
+				;;
+			esac
+			$myecho
+			ans=!
+			;;
+		esac;;
+	*)
+		case "\$aok" in
+		y)
+			echo "*** Substitution done -- please confirm."
+			xxxm="\$ans"
+			ans=\`echo $n "\$ans$c" | tr '\012' ' '\`
+			xxxm="\$ans"
+			ans=!
+			;;
+		*)
+			echo "*** Error -- try again."
+			ans=!
+			;;
+		esac
+		$myecho
+		;;
+	esac
+	case "\$ans\$xxxm\$nostick" in
+	'')
+		ans=!
+		$myecho
+		;;
+	esac
+done
+case "\$ans" in
+'') ans="\$xxxm";;
+esac
+EOSC
+
+: Find the path to the source tree
+case "$src" in
+'') src=`echo $0 | sed -e 's%/[^/][^/]*$%%'`;;
+esac
+case "$src" in
+'')
+	src=.
+	rsrc=..
+	;;
+/*) rsrc="$src/..";;
+*) rsrc="../$src";;
+esac
+if test -f $rsrc/Configure && \
+	$contains "^package=$package" $rsrc/Configure >/dev/null 2>&1
+then
+   : found it, so we are ok.
+else
+	rsrc=''
+	for src in . .. ../.. ../../.. ../../../..; do
+		if test -f ../$src/Configure && \
+			$contains "^package=$package" ../$src/Configure >/dev/null 2>&1
+		then
+			rsrc=../$src
+			break
+		fi
+	done
+fi
+case "$rsrc" in
+'')
+	echo " "
+	dflt=
+	rp="Directory where sources for $package are located?"
+	. ./myread
+	src="$ans"
+	rsrc="$src"
+	if test -f $rsrc/Configure && \
+		$contains "^package=$package" $rsrc/Configure >/dev/null 2>&1
+	then
+		echo "Ok, I've found them under $src"
+	else
+		echo "Sorry, I can't seem to be able to locate $package sources." >&4
+		exit 1
+	fi
+	;;
+../.) ;;
+*)
+	echo " "
+	echo "Sources for $package found in $src" >&4
+	;;
+esac
+
+: script used to extract .SH files with variable substitutions
+cat >extract <<'EOS'
+CONFIG=true
+echo "Doing variable substitutions on .SH files..."
+if test -f $src/MANIFEST; then
+	set x `awk '{print $1}' <$src/MANIFEST | grep '\.SH'`
+else
+	echo "(Looking for .SH files under the source directory.)"
+	set x `(cd $src; find . -name "*.SH" -print)`
+fi
+shift
+case $# in
+0) set x `(cd $src; echo *.SH)`; shift;;
+esac
+if test ! -f $src/$1; then
+	shift
+fi
+mkdir_p='
+name=$1;
+create="";
+while test $name; do
+	if test ! -d "$name"; then
+		create="$name $create";
+		name=`echo $name | sed -e "s|^[^/]*$||"`;
+		name=`echo $name | sed -e "s|\(.*\)/.*|\1|"`;
+	else
+		name="";
+	fi;
+done;
+for file in $create; do
+	mkdir $file;
+done
+'
+for file in $*; do
+	case "$src" in
+	".")
+		case "$file" in
+		*/*)
+			dir=`expr X$file : 'X\(.*\)/'`
+			file=`expr X$file : 'X.*/\(.*\)'`
+			(cd $dir && . ./$file)
+			;;
+		*)
+			. ./$file
+			;;
+		esac
+		;;
+	*)
+		case "$file" in
+		*/*)
+			dir=`expr X$file : 'X\(.*\)/'`
+			file=`expr X$file : 'X.*/\(.*\)'`
+			(set x $dir; shift; eval $mkdir_p)
+			sh <$src/$dir/$file
+			;;
+		*)
+			sh <$src/$file
+			;;
+		esac
+		;;
+	esac
+done
+if test -f $src/config_h.SH; then
+	if test ! -f config.h; then
+	: oops, they left it out of MANIFEST, probably, so do it anyway.
+	. $src/config_h.SH
+	fi
+fi
+EOS
+
+: extract files and exit if asked to do so
+case "$extractsh" in
+true)
+	case "$realsilent" in
+	true) ;;
+	*) exec 1>&4;;
+	esac
+	case "$config_sh" in
+	'') config_sh='config.sh'; config="$rsrc/config.sh";;
+	/*) config="$config_sh";;
+	*) config="$rsrc/$config_sh";;
+	esac
+	echo " "
+	echo "Fetching answers from $config_sh..."
+	. $config
+	test "$override" && . ./optdef.sh
+	echo " "
+	cd ..
+	. UU/extract
+	rm -rf UU
+	echo "Done."
+	exit 0
+	;;
+esac
+
+: Eunice requires " " instead of "", can you believe it
+echo " "
+: Here we go...
+echo "Beginning of configuration questions for $package."
+
+trap 'echo " "; test -d ../UU && rm -rf X $rmlist; exit 1' 1 2 3 15
+
+: Now test for existence of everything in MANIFEST
+echo " "
+if test -f $rsrc/MANIFEST; then
+	echo "First let's make sure your kit is complete.  Checking..." >&4
+	awk '$1 !~ /PACK[A-Z]+/ {print $1}' $rsrc/MANIFEST | split -l -50
+	rm -f missing
+	tmppwd=`pwd`
+	for filelist in x??; do
+		(cd $rsrc; ls `cat $tmppwd/$filelist` >/dev/null 2>>$tmppwd/missing)
+	done
+	if test -s missing; then
+		cat missing >&4
+		cat >&4 <<'EOM'
+
+THIS PACKAGE SEEMS TO BE INCOMPLETE.
+
+You have the option of continuing the configuration process, despite the
+distinct possibility that your kit is damaged, by typing 'y'es.  If you
+do, don't blame me if something goes wrong.  I advise you to type 'n'o
+and contact the author (srivasta@debian.org).
+
+EOM
+		echo $n "Continue? [n] $c" >&4
+		read ans
+		case "$ans" in
+		y*)
+			echo "Continuing..." >&4
+			rm -f missing
+			;;
+		*)
+			echo "ABORTING..." >&4
+			kill $$
+			;;
+		esac
+	else
+		echo "Looks good..."
+	fi
+else
+	echo "There is no MANIFEST file.  I hope your kit is complete !"
+fi
+rm -f missing x??
+
+: create .config dir to save info across Configure sessions
+test -d ../.config || mkdir ../.config
+cat >../.config/README <<EOF
+This directory created by Configure to save information that should
+persist across sessions for $package.
+
+You may safely delete it if you wish.
+EOF
+
+: general instructions
+needman=true
+firsttime=true
+user=`(logname) 2>/dev/null`
+case "$user" in
+'') user=`whoami 2>&1`;;
+esac
+if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then
+	firsttime=false
+	echo " "
+	rp='Would you like to see the instructions?'
+	dflt=n
+	. ./myread
+	case "$ans" in
+	[yY]*) ;;
+	*) needman=false;;
+	esac
+fi
+if $needman; then
+	cat <<EOH
+ 
+This installation shell script will examine your system and ask you questions
+to determine how the c2man package should be installed. If you get
+stuck on a question, you may use a ! shell escape to start a subshell or
+execute a command.  Many of the questions will have default answers in square
+brackets; typing carriage return will give you the default.
+
+On some of the questions which ask for file or directory names you are allowed
+to use the ~name construct to specify the login directory belonging to "name",
+even if you don't have a shell which knows about that.  Questions where this is
+allowed will be marked "(~name ok)".
+
+EOH
+	rp=''
+	dflt='Type carriage return to continue'
+	. ./myread
+	cat <<'EOH'
+
+The prompter used in this script allows you to use shell variables and
+backticks in your answers.  You may use $1, $2, etc...  to refer to the words
+in the default answer, as if the default line was a set of arguments given to a
+script shell.  This means you may also use $* to repeat the whole default line,
+so you do not have to re-type everything to add something to the default.
+
+Everytime there is a substitution, you will have to confirm.  If there is an
+error (e.g. an unmatched backtick), the default answer will remain unchanged
+and you will be prompted again.
+
+If you are in a hurry, you may run 'Configure -d'.  This will bypass nearly all
+the questions and use the computed defaults (or the previous answers if there
+was already a config.sh file). Type 'Configure -h' for a list of options.
+You may also start interactively and then answer '& -d' at any prompt to turn
+on the non-interactive behaviour for the remaining of the execution.
+
+EOH
+	. ./myread
+	cat <<EOH
+
+Much effort has been expended to ensure that this shell script will run on any
+Unix system.  If despite that it blows up on yours, your best bet is to edit
+Configure and run it again.  If you can't run Configure for some reason,
+you'll have to generate a config.sh file by hand.  Whatever problems you
+have, let me (srivasta@debian.org) know how I blew it.
+
+This installation script affects things in two ways:
+
+1) it may do direct variable substitutions on some of the files included
+   in this kit.
+2) it builds a config.h file for inclusion in C programs.  You may edit
+   any of these files as the need arises after running this script.
+
+If you make a mistake on a question, there is no easy way to back up to it
+currently.  The easiest thing to do is to edit config.sh and rerun all the SH
+files.  Configure will offer to let you do this before it runs the SH files.
+
+EOH
+	dflt='Type carriage return to continue'
+	. ./myread
+	case "$firsttime" in
+	true) echo $user >>../.config/instruct;;
+	esac
+fi
+
+: find out where common programs are
+echo " "
+echo "Locating common programs..." >&4
+cat <<EOSC >loc
+$startsh
+case \$# in
+0) exit 1;;
+esac
+thing=\$1
+shift
+dflt=\$1
+shift
+for dir in \$*; do
+	case "\$thing" in
+	.)
+	if test -d \$dir/\$thing; then
+		echo \$dir
+		exit 0
+	fi
+	;;
+	*)
+	for thisthing in \$dir/\$thing; do
+		: just loop through to pick last item
+	done
+	if test -f \$thisthing; then
+		echo \$thisthing
+		exit 0
+	elif test -f \$dir/\$thing.exe; then
+		: on Eunice apparently
+		echo \$dir/\$thing
+		exit 0
+	fi
+	;;
+	esac
+done
+echo \$dflt
+exit 1
+EOSC
+chmod +x loc
+$eunicefix loc
+loclist="
+awk
+cat
+cp
+echo
+expr
+grep
+mv
+rm
+sed
+sort
+touch
+tr
+uniq
+"
+trylist="
+Mcc
+bison
+byacc
+cpp
+date
+flex
+ln
+nroff
+test
+uname
+"
+pth=`echo $PATH | sed -e "s/$p_/ /g"`
+pth="$pth /lib /usr/lib"
+for file in $loclist; do
+	eval xxx=\$$file
+	case "$xxx" in
+	/*|?:[\\/]*)
+		if test -f "$xxx"; then
+			: ok
+		else
+			echo "WARNING: no $xxx -- ignoring your setting for $file." >&4
+			xxx=`./loc $file $file $pth`
+		fi
+		;;
+	'') xxx=`./loc $file $file $pth`;;
+	*) xxx=`./loc $xxx $xxx $pth`;;
+	esac
+	eval $file=$xxx
+	eval _$file=$xxx
+	case "$xxx" in
+	/*)
+		echo $file is in $xxx.
+		;;
+	?:[\\/]*)
+		echo $file is in $xxx.
+		;;
+	*)
+		echo "I don't know where '$file' is, and my life depends on it." >&4
+		echo "Go find a public domain implementation or fix your PATH setting!" >&4
+		exit 1
+		;;
+	esac
+done
+echo " "
+echo "Don't worry if any of the following aren't found..."
+say=offhand
+for file in $trylist; do
+	eval xxx=\$$file
+	case "$xxx" in
+	/*|?:[\\/]*)
+		if test -f "$xxx"; then
+			: ok
+		else
+			echo "WARNING: no $xxx -- ignoring your setting for $file." >&4
+			xxx=`./loc $file $file $pth`
+		fi
+		;;
+	'') xxx=`./loc $file $file $pth`;;
+	*) xxx=`./loc $xxx $xxx $pth`;;
+	esac
+	eval $file=$xxx
+	eval _$file=$xxx
+	case "$xxx" in
+	/*)
+		echo $file is in $xxx.
+		;;
+	?:[\\/]*)
+		echo $file is in $xxx.
+		;;
+	*)
+		echo "I don't see $file out there, $say."
+		say=either
+		;;
+	esac
+done
+case "$egrep" in
+egrep)
+	echo "Substituting grep for egrep."
+	egrep=$grep
+	;;
+esac
+case "$ln" in
+ln)
+	echo "Substituting cp for ln."
+	ln=$cp
+	;;
+esac
+case "$test" in
+test)
+	echo "Hopefully test is built into your sh."
+	;;
+*)
+	if `sh -c "PATH= test true" >/dev/null 2>&1`; then
+		echo "Using the test built into your sh."
+		test=test
+		_test=test
+	fi
+	;;
+esac
+case "$echo" in
+echo)
+	echo "Hopefully echo is built into your sh."
+	;;
+'') ;;
+*)
+	echo " "
+echo "Checking compatibility between $echo and builtin echo (if any)..." >&4
+	$echo $n "hi there$c" >foo1
+	echo $n "hi there$c" >foo2
+	if cmp foo1 foo2 >/dev/null 2>&1; then
+		echo "They are compatible.  In fact, they may be identical."
+	else
+		case "$n" in
+		'-n') n='' c='\c';;
+		*) n='-n' c='';;
+		esac
+		cat <<FOO
+They are not compatible!  You are probably running ksh on a non-USG system.
+I'll have to use $echo instead of the builtin, since Bourne shell doesn't
+have echo built in and we may have to run some Bourne shell scripts.  That
+means I'll have to use '$n$c' to suppress newlines now.  Life is ridiculous.
+
+FOO
+		$echo $n "The star should be here-->$c"
+		$echo "*"
+	fi
+	$rm -f foo1 foo2
+	;;
+esac
+
+: determine whether symbolic links are supported
+echo " "
+$touch blurfl
+if $ln -s blurfl sym > /dev/null 2>&1 ; then
+	echo "Symbolic links are supported." >&4
+	lns="$ln -s"
+else
+	echo "Symbolic links are NOT supported." >&4
+	lns="$ln"
+fi
+$rm -f blurfl sym
+
+: see whether [:lower:] and [:upper:] are supported character classes
+echo " "
+up='[A-Z]'
+low='[a-z]'
+case "`echo AbyZ | $tr '[:lower:]' '[:upper:]' 2>/dev/null`" in
+ABYZ)
+	echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4
+	up='[:upper:]'
+	low='[:lower:]'
+	;;
+*)
+	echo "Your tr only supports [a-z] and [A-Z] to convert case." >&4
+	;;
+esac
+: set up the translation script tr, must be called with ./tr of course
+cat >tr <<EOSC
+$startsh
+case "\$1\$2" in
+'[A-Z][a-z]') exec $tr '$up' '$low';;
+'[a-z][A-Z]') exec $tr '$low' '$up';;
+esac
+exec $tr "\$@"
+EOSC
+chmod +x tr
+$eunicefix tr
+
+: Try to determine whether config.sh was made on this system
+case "$config_sh" in
+'')
+myuname=`( ($uname -a) 2>/dev/null || hostname) 2>&1`
+myuname=`echo $myuname | $sed -e 's/^[^=]*=//' -e 's/\///g' | \
+	./tr '[A-Z]' '[a-z]' | tr '\012' ' '`
+newmyuname="$myuname"
+dflt=n
+case "$knowitall" in
+'')
+	if test -f ../config.sh; then
+		if $contains myuname= ../config.sh >/dev/null 2>&1; then
+			eval "`grep myuname= ../config.sh`"
+		fi
+		if test "X$myuname" = "X$newmyuname"; then
+			dflt=y
+		fi
+	fi
+	;;
+*) dflt=y;;
+esac
+
+: Get old answers, if there is a config file out there
+hint=default
+hintfile=''
+if test -f ../config.sh; then
+	echo " "
+	rp="I see a config.sh file.  Shall I use it to set the defaults?"
+	. ./myread
+	case "$ans" in
+	n*|N*) echo "OK, I'll ignore it.";;
+	*)  echo "Fetching default answers from your old config.sh file..." >&4
+		tmp_n="$n"
+		tmp_c="$c"
+		. ../config.sh
+		cp ../config.sh .
+		n="$tmp_n"
+		c="$tmp_c"
+		hint=previous
+		;;
+	esac
+fi
+;;
+*)
+	echo " "
+	echo "Fetching default answers from $config_sh..." >&4
+	tmp_n="$n"
+	tmp_c="$c"
+	cd ..
+	cp $config_sh config.sh 2>/dev/null
+	chmod +w config.sh
+	. ./config.sh
+	cd UU
+	cp ../config.sh .
+	n="$tmp_n"
+	c="$tmp_c"
+	hint=previous
+	;;
+esac
+test "$override" && . ./optdef.sh
+myuname="$newmyuname"
+
+: Restore computed paths
+for file in $loclist $trylist; do
+	eval $file="\$_$file"
+done
+
+: who configured the system
+cf_time=`$date 2>&1`
+cf_by=`(logname) 2>/dev/null`
+case "$cf_by" in
+"")
+	cf_by=`(whoami) 2>/dev/null`
+	case "$cf_by" in
+	"") cf_by=unknown ;;
+	esac ;;
+esac
+
+: decide how portable to be
+case "$d_portable" in
+"$define") dflt=y;;
+*)	dflt=n;;
+esac
+$cat <<'EOH'
+ 
+I can set things up so that your shell scripts and binaries are more portable,
+at what may be a noticable cost in performance.  In particular, if you
+ask to be portable, the following happens:
+
+     1) Shell scripts will rely on the PATH variable rather than using
+	the paths derived above.
+     2) ~username interpretations will be done at run time rather than
+	by Configure.
+
+EOH
+rp="Do you expect to run these scripts and binaries on multiple machines?"
+. ./myread
+case "$ans" in
+	y*) d_portable="$define"
+	;;
+	*)  d_portable="$undef" ;;
+esac
+
+: set up shell script to do ~ expansion
+cat >filexp <<EOSS
+$startsh
+: expand filename
+case "\$1" in
+ ~/*|~)
+	echo \$1 | $sed "s|~|\${HOME-\$LOGDIR}|"
+	;;
+ ~*)
+	if $test -f /bin/csh; then
+		/bin/csh -f -c "glob \$1"
+		failed=\$?
+		echo ""
+		exit \$failed
+	else
+		name=\`$expr x\$1 : '..\([^/]*\)'\`
+		dir=\`$sed -n -e "/^\${name}:/{s/^[^:]*:[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\).*"'\$'"/\1/" -e p -e q -e '}' </etc/passwd\`
+		if $test ! -d "\$dir"; then
+			me=\`basename \$0\`
+			echo "\$me: can't locate home directory for: \$name" >&2
+			exit 1
+		fi
+		case "\$1" in
+		*/*)
+			echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\`
+			;;
+		*)
+			echo \$dir
+			;;
+		esac
+	fi
+	;;
+*)
+	echo \$1
+	;;
+esac
+EOSS
+chmod +x filexp
+$eunicefix filexp
+
+: now set up to get a file name
+cat <<EOS >getfile
+$startsh
+EOS
+cat <<'EOSC' >>getfile
+tilde=''
+fullpath=''
+already=''
+skip=''
+none_ok=''
+exp_file=''
+nopath_ok=''
+orig_rp="$rp"
+orig_dflt="$dflt"
+
+case "$fn" in
+*\(*)
+	expr $fn : '.*(\(.*\)).*' | tr ',' '\012' >getfile.ok
+	fn=`echo $fn | sed 's/(.*)//'`
+	;;
+esac
+
+case "$fn" in
+*:*)
+	loc_file=`expr $fn : '.*:\(.*\)'`
+	fn=`expr $fn : '\(.*\):.*'`
+	;;
+esac
+
+case "$fn" in
+*~*) tilde=true;;
+esac
+case "$fn" in
+*/*) fullpath=true;;
+esac
+case "$fn" in
+*+*) skip=true;;
+esac
+case "$fn" in
+*n*) none_ok=true;;
+esac
+case "$fn" in
+*e*) exp_file=true;;
+esac
+case "$fn" in
+*p*) nopath_ok=true;;
+esac
+
+case "$fn" in
+*f*) type='File';;
+*d*) type='Directory';;
+*l*) type='Locate';;
+esac
+
+what="$type"
+case "$what" in
+Locate) what='File';;
+esac
+
+case "$exp_file" in
+'')
+	case "$d_portable" in
+	"$define") ;;
+	*) exp_file=true;;
+	esac
+	;;
+esac
+
+cd ..
+while test "$type"; do
+	redo=''
+	rp="$orig_rp"
+	dflt="$orig_dflt"
+	case "$tilde" in
+	true) rp="$rp (~name ok)";;
+	esac
+	. UU/myread
+	if test -f UU/getfile.ok && \
+		$contains "^$ans\$" UU/getfile.ok >/dev/null 2>&1
+	then
+		value="$ans"
+		ansexp="$ans"
+		break
+	fi
+	case "$ans" in
+	none)
+		value=''
+		ansexp=''
+		case "$none_ok" in
+		true) type='';;
+		esac
+		;;
+	*)
+		case "$tilde" in
+		'') value="$ans"
+			ansexp="$ans";;
+		*)
+			value=`UU/filexp $ans`
+			case $? in
+			0)
+				if test "$ans" != "$value"; then
+					echo "(That expands to $value on this system.)"
+				fi
+				;;
+			*) value="$ans";;
+			esac
+			ansexp="$value"
+			case "$exp_file" in
+			'') value="$ans";;
+			esac
+			;;
+		esac
+		case "$fullpath" in
+		true)
+			case "$ansexp" in
+			/*) value="$ansexp" ;;
+			*)
+				redo=true
+				case "$already" in
+				true)
+				echo "I shall only accept a full path name, as in /bin/ls." >&4
+				echo "Use a ! shell escape if you wish to check pathnames." >&4
+					;;
+				*)
+				echo "Please give a full path name, starting with slash." >&4
+					case "$tilde" in
+					true)
+				echo "Note that using ~name is ok provided it expands well." >&4
+						already=true
+						;;
+					esac
+				esac
+				;;
+			esac
+			;;
+		esac
+		case "$redo" in
+		'')
+			case "$type" in
+			File)
+				if test -f "$ansexp"; then
+					type=''
+				elif test -r "$ansexp" || (test -h "$ansexp") >/dev/null 2>&1
+				then
+					echo "($value is not a plain file, but that's ok.)"
+					type=''
+				fi
+				;;
+			Directory)
+				if test -d "$ansexp"; then
+					type=''
+				fi
+				;;
+			Locate)
+				if test -d "$ansexp"; then
+					echo "(Looking for $loc_file in directory $value.)"
+					value="$value/$loc_file"
+					ansexp="$ansexp/$loc_file"
+				fi
+				if test -f "$ansexp"; then
+					type=''
+				fi
+				case "$nopath_ok" in
+				true)	case "$value" in
+					*/*) ;;
+					*)	echo "Assuming $value will be in people's path."
+						type=''
+						;;
+					esac
+					;;
+				esac
+				;;
+			esac
+
+			case "$skip" in
+			true) type='';
+			esac
+
+			case "$type" in
+			'') ;;
+			*)
+				if test "$fastread" = yes; then
+					dflt=y
+				else
+					dflt=n
+				fi
+				rp="$what $value doesn't exist.  Use that name anyway?"
+				. UU/myread
+				dflt=''
+				case "$ans" in
+				y*) type='';;
+				*) echo " ";;
+				esac
+				;;
+			esac
+			;;
+		esac
+		;;
+	esac
+done
+cd UU
+ans="$value"
+rp="$orig_rp"
+dflt="$orig_dflt"
+rm -f getfile.ok
+EOSC
+
+: determine root of directory hierarchy where package will be installed.
+case "$prefix" in
+'')
+	dflt=`./loc . /usr/local /usr/local /local /opt /usr`
+	;;
+*)
+	dflt="$prefix"
+	;;
+esac
+$cat <<EOM
+
+By default, $package will be installed in $dflt/bin, manual
+pages under $dflt/man, etc..., i.e. with $dflt as prefix for
+all installation directories. Typically set to /usr/local, but you
+may choose /usr if you wish to install $package among your system
+binaries. If you wish to have binaries under /bin but manual pages
+under /usr/local/man, that's ok: you will be prompted separately
+for each of the installation directories, the prefix being only used
+to set the defaults.
+
+EOM
+fn=d~
+rp='Installation prefix to use?'
+. ./getfile
+oldprefix=''
+case "$prefix" in
+'') ;;
+*)
+	case "$ans" in
+	"$prefix") ;;
+	*) oldprefix="$prefix";;
+	esac
+	;;
+esac
+prefix="$ans"
+prefixexp="$ansexp"
+
+: set the prefixit variable, to compute a suitable default value
+prefixit='case "$3" in
+""|none)
+	case "$oldprefix" in
+	"") eval "$1=\"\$$2\"";;
+	*)
+		case "$3" in
+		"") eval "$1=";;
+		none)
+			eval "tp=\"\$$2\"";
+			case "$tp" in
+			""|" ") eval "$1=\"\$$2\"";;
+			*) eval "$1=";;
+			esac;;
+		esac;;
+	esac;;
+*)
+	eval "tp=\"$oldprefix-\$$2-\""; eval "tp=\"$tp\"";
+	case "$tp" in
+	--|/*--|\~*--) eval "$1=\"$prefix/$3\"";;
+	/*-$oldprefix/*|\~*-$oldprefix/*)
+		eval "$1=\`echo \$$2 | sed \"s,^$oldprefix,$prefix,\"\`";;
+	*) eval "$1=\"\$$2\"";;
+	esac;;
+esac'
+
+: is AFS running?
+echo " "
+case "$afs" in
+$define|true)	afs=true ;;
+$undef|false)	afs=false ;;
+*)	if test -d /afs; then
+		afs=true
+	else
+		afs=false
+	fi
+	;;
+esac
+if $afs; then
+	echo "AFS may be running... I'll be extra cautious then..." >&4
+else
+	echo "AFS does not seem to be running..." >&4
+fi
+
+: determine where public executables go
+echo " "
+set dflt bin bin
+eval $prefixit
+fn=d~
+rp='Pathname where the public executables will reside?'
+. ./getfile
+if $test "X$ansexp" != "X$binexp"; then
+	installbin=''
+fi
+bin="$ans"
+binexp="$ansexp"
+if $afs; then
+	$cat <<EOM
+
+Since you are running AFS, I need to distinguish the directory in which
+executables reside from the directory in which they are installed (and from
+which they are presumably copied to the former directory by occult means).
+
+EOM
+	case "$installbin" in
+	'') dflt=`echo $binexp | sed 's#^/afs/#/afs/.#'`;;
+	*) dflt="$installbin";;
+	esac
+	fn=de~
+	rp='Where will public executables be installed?'
+	. ./getfile
+	installbin="$ans"
+else
+	installbin="$binexp"
+fi
+
+: determine where private executables go
+set dflt privlib lib/$package
+eval $prefixit
+$cat <<EOM
+
+There are some auxiliary files for $package that need to be put into a
+private library directory that is accessible by everyone.
+
+EOM
+fn=d~+
+rp='Pathname where the private library files will reside?'
+. ./getfile
+if $test "X$privlibexp" != "X$ansexp"; then
+	installprivlib=''
+fi
+privlib="$ans"
+privlibexp="$ansexp"
+if $afs; then
+	$cat <<EOM
+
+Since you are running AFS, I need to distinguish the directory in which
+private files reside from the directory in which they are installed (and from
+which they are presumably copied to the former directory by occult means).
+
+EOM
+	case "$installprivlib" in
+	'') dflt=`echo $privlibexp | sed 's#^/afs/#/afs/.#'`;;
+	*) dflt="$installprivlib";;
+	esac
+	fn=de~
+	rp='Where will private files be installed?'
+	. ./getfile
+	installprivlib="$ans"
+else
+	installprivlib="$privlibexp"
+fi
+
+: determine where manual pages are on this system
+echo " "
+case "$sysman" in
+'') 
+	syspath='/usr/man/man1 /usr/man/mann /usr/man/manl /usr/man/local/man1'
+	syspath="$syspath /usr/man/u_man/man1 /usr/share/man/man1"
+	syspath="$syspath /usr/catman/u_man/man1 /usr/man/l_man/man1"
+	syspath="$syspath /usr/local/man/u_man/man1 /usr/local/man/l_man/man1"
+	syspath="$syspath /usr/man/man.L /local/man/man1 /usr/local/man/man1"
+	sysman=`./loc . /usr/man/man1 $syspath`
+	;;
+esac
+if $test -d "$sysman"; then
+	echo "System manual is in $sysman." >&4
+else
+	echo "Could not find manual pages in source form." >&4
+fi
+
+: set the prefixup variable, to restore leading tilda escape
+prefixup='case "$prefixexp" in
+"$prefix") ;;
+*) eval "$1=\`echo \$$1 | sed \"s,^$prefixexp,$prefix,\"\`";;
+esac'
+
+: determine where manual pages go
+set mansrc mansrc none
+eval $prefixit
+$cat <<EOM
+
+$spackage has manual pages available in source form.
+EOM
+case "$nroff" in
+nroff)
+	echo "However, you don't have nroff, so they're probably useless to you."
+	case "$mansrc" in
+	'') mansrc="none";;
+	esac;;
+esac
+echo "If you don't want the manual sources installed, answer 'none'."
+case "$mansrc" in
+'')
+	lookpath="$prefixexp/man/man1 $prefixexp/man/u_man/man1"
+	lookpath="$lookpath $prefixexp/man/l_man/man1"
+	lookpath="$lookpath /usr/local/man/man1 /opt/man/man1 /usr/man/manl"
+	lookpath="$lookpath /usr/man/local/man1 /usr/man/l_man/man1"
+	lookpath="$lookpath /usr/local/man/u_man/man1 /usr/local/man/l_man/man1"
+	lookpath="$lookpath /usr/man/man.L"
+	mansrc=`./loc . $prefixexp/man/man1 $lookpath`
+	if $test -d "$mansrc"; then
+		dflt="$mansrc"
+	else
+		dflt="$sysman"
+	fi
+	set dflt
+	eval $prefixup
+	;;
+' ') dflt=none;;
+*)  dflt="$mansrc"
+	;;
+esac
+echo " "
+fn=dn~
+rp='Where do the manual pages (source) go?'
+. ./getfile
+if test "X$mansrcexp" != "X$ansexp"; then
+	installmansrc=''
+fi
+mansrc="$ans"
+mansrcexp="$ansexp"
+case "$mansrc" in
+'') mansrc=' '
+	installmansrc='';;
+esac
+if $afs && $test "$mansrc"; then
+	$cat <<EOM
+
+Since you are running AFS, I need to distinguish the directory in which
+manual pages reside from the directory in which they are installed (and from
+which they are presumably copied to the former directory by occult means).
+
+EOM
+	case "$installmansrc" in
+	'') dflt=`echo $mansrcexp | sed 's#^/afs/#/afs/.#'`;;
+	*) dflt="$installmansrc";;
+	esac
+	fn=de~
+	rp='Where will man pages be installed?'
+	. ./getfile
+	installmansrc="$ans"
+else
+	installmansrc="$mansrcexp"
+fi
+
+case "$mansrc" in
+' ') manext='0';;
+*l) manext=l;;
+*n) manext=n;;
+*o) manext=l;;
+*p) manext=n;;
+*C) manext=C;;
+*L) manext=L;;
+*L1) manext=L1;;
+*) manext=1;;
+esac
+
+: make some quick guesses about what we are up against
+echo " "
+$echo $n "Hmm...  $c"
+echo exit 1 >bsd
+echo exit 1 >usg
+echo exit 1 >v7
+echo exit 1 >osf1
+echo exit 1 >eunice
+echo exit 1 >xenix
+echo exit 1 >venix
+echo exit 1 >os2
+d_bsd="$undef"
+$cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null
+if test -f /osf_boot || $contains 'OSF/1' /usr/include/ctype.h >/dev/null 2>&1
+then
+	echo "Looks kind of like an OSF/1 system, but we'll see..."
+	echo exit 0 >osf1
+elif test `echo abc | tr a-z A-Z` = Abc ; then
+	xxx=`./loc addbib blurfl $pth`
+	if $test -f $xxx; then
+	echo "Looks kind of like a USG system with BSD features, but we'll see..."
+		echo exit 0 >bsd
+		echo exit 0 >usg
+	else
+		if $contains SIGTSTP foo >/dev/null 2>&1 ; then
+			echo "Looks kind of like an extended USG system, but we'll see..."
+		else
+			echo "Looks kind of like a USG system, but we'll see..."
+		fi
+		echo exit 0 >usg
+	fi
+elif $contains SIGTSTP foo >/dev/null 2>&1 ; then
+	echo "Looks kind of like a BSD system, but we'll see..."
+	d_bsd="$define"
+	echo exit 0 >bsd
+else
+	echo "Looks kind of like a Version 7 system, but we'll see..."
+	echo exit 0 >v7
+fi
+case "$eunicefix" in
+*unixtovms*)
+	$cat <<'EOI'
+There is, however, a strange, musty smell in the air that reminds me of
+something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit.
+EOI
+	echo exit 0 >eunice
+	d_eunice="$define"
+: it so happens the Eunice I know will not run shell scripts in Unix format
+	;;
+*)
+	echo " "
+	echo "Congratulations.  You aren't running Eunice."
+	d_eunice="$undef"
+	;;
+esac
+case "$p_" in
+:) ;;
+*)
+	$cat <<'EOI'
+I have the feeling something is not exactly right, however...don't tell me...
+lemme think...does HAL ring a bell?...no, of course, you're only running OS/2!
+EOI
+	echo exit 0 >os2
+	;;
+esac
+if test -f /xenix; then
+	echo "Actually, this looks more like a XENIX system..."
+	echo exit 0 >xenix
+	d_xenix="$define"
+else
+	echo " "
+	echo "It's not Xenix..."
+	d_xenix="$undef"
+fi
+chmod +x xenix
+$eunicefix xenix
+if test -f /venix; then
+	echo "Actually, this looks more like a VENIX system..."
+	echo exit 0 >venix
+else
+	echo " "
+	if ./xenix; then
+		: null
+	else
+		echo "Nor is it Venix..."
+	fi
+fi
+chmod +x bsd usg v7 osf1 eunice xenix venix os2
+$eunicefix bsd usg v7 osf1 eunice xenix venix os2
+$rm -f foo
+
+: see if we need a special compiler
+echo " "
+if ./usg; then
+	case "$cc" in
+	'') case "$Mcc" in
+		/*) dflt='Mcc';;
+		*) case "$large" in
+			-M*) dflt='cc';;
+			*)	if $contains '\-M' $sysman/cc.1 >/dev/null 2>&1 ; then
+					if $contains '\-M' $sysman/cpp.1 >/dev/null 2>&1; then
+						dflt='cc'
+					else
+						dflt='cc -M'
+					fi
+				else
+					dflt='cc'
+				fi;;
+			esac;;
+		esac;;
+	*)  dflt="$cc";;
+	esac
+	$cat <<'EOM'
+On some systems the default C compiler will not resolve multiple global
+references that happen to have the same name.  On some such systems the "Mcc"
+command may be used to force these to be resolved.  On other systems a "cc -M"
+command is required.  (Note that the -M flag on other systems indicates a
+memory model to use!) If you have the Gnu C compiler, you might wish to use
+that instead.
+
+EOM
+	rp="What command will force resolution on this system?"
+	. ./myread
+	cc="$ans"
+else
+	case "$cc" in
+	'') dflt=cc;;
+	*) dflt="$cc";;
+	esac
+	rp="Use which C compiler?"
+	. ./myread
+	cc="$ans"
+fi
+echo " "
+echo "Checking for GNU cc in disguise and/or its version number..." >&4
+$cat >gccvers.c <<EOM
+#include <stdio.h>
+int main() {
+#ifdef __GNUC__
+#ifdef __VERSION__
+	printf("%s\n", __VERSION__);
+#else
+	printf("%s\n", "1");
+#endif
+#endif
+	exit(0);
+}
+EOM
+if $cc -o gccvers gccvers.c >/dev/null 2>&1; then
+	gccversion=`./gccvers`
+	case "$gccversion" in
+	'') echo "You are not using GNU cc." ;;
+	*)  echo "You are using GNU cc $gccversion." ;;
+	esac
+else
+	echo " "
+	echo "*** WHOA THERE!!! ***" >&4
+	echo "    Your C compiler \"$cc\" doesn't seem to be working!" >&4
+	case "$knowitall" in
+	'')
+	echo "    You'd better start hunting for one and let me know about it." >&4
+		exit 1
+		;;
+	esac
+fi
+$rm -f gccvers*
+case "$gccversion" in
+1*) cpp=`./loc gcc-cpp $cpp $pth` ;;
+esac
+
+: What should the include directory be ?
+echo " "
+$echo $n "Hmm...  $c"
+dflt='/usr/include'
+incpath=''
+mips_type=''
+if $test -f /bin/mips && /bin/mips; then
+	echo "Looks like a MIPS system..."
+	$cat >usr.c <<'EOCP'
+#ifdef SYSTYPE_BSD43
+/bsd43
+#endif
+EOCP
+	if $cc -E usr.c > usr.out && $contains / usr.out >/dev/null 2>&1; then
+		dflt='/bsd43/usr/include'
+		incpath='/bsd43'
+		mips_type='BSD 4.3'
+	else
+		mips_type='System V'
+	fi
+	$rm -f usr.c usr.out
+	echo "and you're compiling with the $mips_type compiler and libraries."
+	xxx_prompt=y
+	echo "exit 0" >mips
+else
+	echo "Doesn't look like a MIPS system."
+	xxx_prompt=n
+	echo "exit 1" >mips
+fi
+chmod +x mips
+$eunicefix mips
+case "$usrinc" in
+'') ;;
+*) dflt="$usrinc";;
+esac
+case "$xxx_prompt" in
+y)	fn=d/
+	echo " "
+	rp='Where are the include files you want to use?'
+	. ./getfile
+	usrinc="$ans"
+	;;
+*)	usrinc="$dflt"
+	;;
+esac
+
+: see how we invoke the C preprocessor
+echo " "
+echo "Now, how can we feed standard input to your C preprocessor..." >&4
+cat <<'EOT' >testcpp.c
+#define ABC abc
+#define XYZ xyz
+ABC.XYZ
+EOT
+cd ..
+echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin
+chmod 755 cppstdin
+wrapper=`pwd`/cppstdin
+ok='false'
+cd UU
+
+if $test "X$cppstdin" != "X" && \
+	$cppstdin $cppminus <testcpp.c >testcpp.out 2>&1 && \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1
+then
+	echo "You used to use $cppstdin $cppminus so we'll use that again."
+	case "$cpprun" in
+	'') echo "But let's see if we can live without a wrapper..." ;;
+	*)
+		if $cpprun $cpplast <testcpp.c >testcpp.out 2>&1 && \
+			$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1
+		then
+			echo "(And we'll use $cpprun $cpplast to preprocess directly.)"
+			ok='true'
+		else
+			echo "(However, $cpprun $cpplast does not work, let's see...)"
+		fi
+		;;
+	esac
+else
+	case "$cppstdin" in
+	'') ;;
+	*)
+		echo "Good old $cppstdin $cppminus does not seem to be of any help..."
+		;;
+	esac
+fi
+
+if $ok; then
+	: nothing
+elif echo 'Maybe "'"$cc"' -E" will work...'; \
+	$cc -E <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "Yup, it does."
+	x_cpp="$cc -E"
+	x_minus='';
+elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \
+	$cc -E - <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "Yup, it does."
+	x_cpp="$cc -E"
+	x_minus='-';
+elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \
+	$cc -P <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "Yipee, that works!"
+	x_cpp="$cc -P"
+	x_minus='';
+elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \
+	$cc -P - <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "At long last!"
+	x_cpp="$cc -P"
+	x_minus='-';
+elif echo 'No such luck, maybe "'$cpp'" will work...'; \
+	$cpp <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "It works!"
+	x_cpp="$cpp"
+	x_minus='';
+elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \
+	$cpp - <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	echo "Hooray, it works!  I was beginning to wonder."
+	x_cpp="$cpp"
+	x_minus='-';
+elif echo 'Uh-uh.  Time to get fancy.  Trying a wrapper...'; \
+	$wrapper <testcpp.c >testcpp.out 2>&1; \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+	x_cpp="$wrapper"
+	x_minus=''
+	echo "Eureka!"
+else
+	dflt=''
+	rp="No dice.  I can't find a C preprocessor.  Name one:"
+	. ./myread
+	x_cpp="$ans"
+	x_minus=''
+	$x_cpp <testcpp.c >testcpp.out 2>&1
+	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then
+		echo "OK, that will do." >&4
+	else
+echo "Sorry, I can't get that to work.  Go find one and rerun Configure." >&4
+		exit 1
+	fi
+fi
+
+case "$ok" in
+false)
+	cppstdin="$x_cpp"
+	cppminus="$x_minus"
+	cpprun="$x_cpp"
+	cpplast="$x_minus"
+	set X $x_cpp
+	shift
+	case "$1" in
+	"$cpp")
+		echo "Perhaps can we force $cc -E using a wrapper..."
+		if $wrapper <testcpp.c >testcpp.out 2>&1; \
+			$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1
+		then
+			echo "Yup, we can."
+			cppstdin="$wrapper"
+			cppminus='';
+		else
+			echo "Nope, we'll have to live without it..."
+		fi
+		;;
+	esac
+	case "$cpprun" in
+	"$wrapper")
+		cpprun=''
+		cpplast=''
+		;;
+	esac
+	;;
+esac
+
+case "$cppstdin" in
+"$wrapper") ;;
+*) $rm -f $wrapper;;
+esac
+$rm -f testcpp.c testcpp.out
+
+: Set private lib path
+case "$plibpth" in
+'') if ./mips; then
+		plibpth="$incpath/usr/lib /usr/local/lib /usr/ccs/lib"
+	fi;;
+esac
+case "$libpth" in
+' ') dlist='';;
+'') dlist="$loclibpth $plibpth $glibpth";;
+*) dlist="$libpth";;
+esac
+
+: Now check and see which directories actually exist, avoiding duplicates
+libpth=''
+for xxx in $dlist
+do
+    if $test -d $xxx; then
+		case " $libpth " in
+		*" $xxx "*) ;;
+		*) libpth="$libpth $xxx";;
+		esac
+    fi
+done
+$cat <<'EOM'
+
+Some systems have incompatible or broken versions of libraries.  Among
+the directories listed in the question below, please remove any you
+know not to be holding relevant libraries, and add any that are needed.
+Say "none" for none.
+
+EOM
+case "$libpth" in
+'') dflt='none';;
+*)
+	set X $libpth
+	shift
+	dflt=${1+"$@"}
+	;;
+esac
+rp="Directories to use for library searches?"
+. ./myread
+case "$ans" in
+none) libpth=' ';;
+*) libpth="$ans";;
+esac
+
+: determine optimize, if desired, or use for debug flag also
+case "$optimize" in
+' ') dflt='none';;
+'') dflt='-O';;
+*) dflt="$optimize";;
+esac
+$cat <<EOH
+
+Some C compilers have problems with their optimizers.  By default, $package
+compiles with the -O flag to use the optimizer.  Alternately, you might want
+to use the symbolic debugger, which uses the -g flag (on traditional Unix
+systems).  Either flag can be specified here.  To use neither flag, specify
+the word "none".
+
+EOH
+rp="What optimizer/debugger flag should be used?"
+. ./myread
+optimize="$ans"
+case "$optimize" in
+'none') optimize=" ";;
+esac
+
+dflt=''
+: We will not override a previous value, but we might want to
+: augment a hint file
+case "$hint" in
+none|recommended)
+	case "$gccversion" in
+	1*) dflt='-fpcc-struct-return' ;;
+	esac
+	case "$optimize" in
+	*-g*) dflt="$dflt -DDEBUGGING";;
+	esac
+	case "$gccversion" in
+	2*) if test -d /etc/conf/kconfig.d &&
+			$contains _POSIX_VERSION $usrinc/sys/unistd.h >/dev/null 2>&1
+		then
+			dflt="$dflt -posix"
+		fi
+		;;
+	esac
+	;;
+esac
+
+case "$mips_type" in
+*BSD*|'') inclwanted="$locincpth $usrinc";;
+*) inclwanted="$locincpth $inclwanted $usrinc/bsd";;
+esac
+for thisincl in $inclwanted; do
+	if $test -d $thisincl; then
+		if $test x$thisincl != x$usrinc; then
+			case "$dflt" in
+			*$thisincl*);;
+			*) dflt="$dflt -I$thisincl";;
+			esac
+		fi
+	fi
+done
+
+inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then
+	xxx=true;
+elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then
+	xxx=true;
+else
+	xxx=false;
+fi;
+if $xxx; then
+	case "$dflt" in
+	*$2*);;
+	*) dflt="$dflt -D$2";;
+	esac;
+fi'
+
+if ./osf1; then
+	set signal.h __LANGUAGE_C__; eval $inctest
+else
+	set signal.h LANGUAGE_C; eval $inctest
+fi
+
+case "$hint" in
+none|recommended) dflt="$ccflags $dflt" ;;
+*) dflt="$ccflags";;
+esac
+
+case "$dflt" in
+''|' ') dflt=none;;
+esac
+$cat <<EOH
+
+Your C compiler may want other flags.  For this question you should include
+-I/whatever and -DWHATEVER flags and any other flags used by the C compiler,
+but you should NOT include libraries or ld flags like -lwhatever.  If you
+want $package to honor its debug switch, you should include -DDEBUG here.
+
+To use no flags, specify the word "none".
+
+EOH
+set X $dflt
+shift
+dflt=${1+"$@"}
+rp="Any additional cc flags?"
+. ./myread
+case "$ans" in
+none) ccflags='';;
+*) ccflags="$ans";;
+esac
+
+: the following weeds options from ccflags that are of no interest to cpp
+cppflags="$ccflags"
+case "$gccversion" in
+1*) cppflags="$cppflags -D__GNUC__"
+esac
+case "$mips_type" in
+'');;
+*BSD*) cppflags="$cppflags -DSYSTYPE_BSD43";;
+esac
+case "$cppflags" in
+'');;
+*)
+	echo " "
+	echo "Let me guess what the preprocessor flags are..." >&4
+	set X $cppflags
+	shift
+	cppflags=''
+	$cat >cpp.c <<'EOM'
+#define BLURFL foo
+
+BLURFL xx LFRULB
+EOM
+	previous=''
+	for flag in $*
+	do
+		case "$flag" in
+		-*) ftry="$flag";;
+		*) ftry="$previous $flag";;
+		esac
+		if $cppstdin -DLFRULB=bar $ftry $cppminus <cpp.c \
+			>cpp1.out 2>/dev/null && \
+			$cpprun -DLFRULB=bar $ftry $cpplast <cpp.c \
+			>cpp2.out 2>/dev/null && \
+			$contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \
+			$contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1
+		then
+			cppflags="$cppflags $ftry"
+			previous=''
+		else
+			previous="$flag"
+		fi
+	done
+	set X $cppflags
+	shift
+	cppflags=${1+"$@"}
+	case "$cppflags" in
+	*-*)  echo "They appear to be: $cppflags";;
+	esac
+	$rm -f cpp.c cpp?.out
+	;;
+esac
+
+: flags used in final linking phase
+case "$ldflags" in
+'') if ./venix; then
+		dflt='-i -z'
+	else
+		dflt=''
+	fi
+	case "$ccflags" in
+	*-posix*) dflt="$dflt -posix" ;;
+	esac
+	;;
+*) dflt="$ldflags";;
+esac
+
+: Try to guess additional flags to pick up local libraries.
+for thislibdir in $libpth; do
+	case " $loclibpth " in
+	*" $thislibdir "*)
+		case "$dflt " in 
+		*"-L$thislibdir "*) ;;
+		*)  dflt="$dflt -L$thislibdir" ;;
+		esac
+		;;
+	esac
+done
+
+case "$dflt" in
+'') dflt='none' ;;
+esac
+
+$cat <<EOH
+
+Your C linker may need flags.  For this question you should
+include -L/whatever and any other flags used by the C linker, but you
+should NOT include libraries like -lwhatever.
+
+Make sure you include the appropriate -L/path flags if your C linker
+does not normally search all of the directories you specified above,
+namely
+	$libpth
+To use no flags, specify the word "none".
+
+EOH
+
+rp="Any additional ld flags (NOT including libraries)?"
+. ./myread
+case "$ans" in
+none) ldflags='';;
+*) ldflags="$ans";;
+esac
+rmlist="$rmlist pdp11"
+
+: coherency check
+echo " "
+echo "Checking your choice of C compiler and flags for coherency..." >&4
+set X $cc $optimize $ccflags $ldflags try.c -o try
+shift
+$cat >try.msg <<EOM
+I've tried to compile and run a simple program with:
+
+	$*
+	./try
+
+and I got the following output:
+
+EOM
+$cat > try.c <<'EOF'
+#include <stdio.h>
+main() { exit(0); }
+EOF
+dflt=y
+if sh -c "$cc $optimize $ccflags try.c -o try $ldflags" >>try.msg 2>&1; then
+	if sh -c './try' >>try.msg 2>&1; then
+		dflt=n
+	else
+		echo "The program compiled OK, but exited with status $?." >>try.msg
+		rp="You have a problem.  Shall I abort Configure"
+		dflt=y
+	fi
+else
+	echo "I can't compile the test program." >>try.msg
+	rp="You have a BIG problem.  Shall I abort Configure"
+	dflt=y
+fi
+case "$dflt" in
+y)
+	$cat try.msg
+	case "$knowitall" in
+	'')
+		echo "(The supplied flags might be incorrect with this C compiler.)"
+		;;
+	*) dflt=n;;
+	esac
+	echo " "
+	. ./myread
+	case "$ans" in
+	n*|N*) ;;
+	*)	echo "Ok.  Stopping Configure." >&4
+		exit 1
+		;;
+	esac
+	;;
+n) echo "OK, that should do.";;
+esac
+$rm -f try try.* core
+
+: Initialize h_fcntl
+h_fcntl=false
+
+: Initialize h_sysfile
+h_sysfile=false
+
+: compute shared library extension
+case "$so" in
+'')
+	if xxx=`./loc libc.sl X $libpth`; $test -f "$xxx"; then
+		dflt='sl'
+	else
+		dflt='so'
+	fi
+	;;
+*) dflt="$so";;
+esac
+$cat <<EOM
+
+On some systems, shared libraries may be available.  Answer 'none' if
+you want to suppress searching of shared libraries for the remaining
+of this configuration.
+
+EOM
+rp='What is the file extension used for shared libraries?'
+. ./myread
+so="$ans"
+
+: Define several unixisms.
+: Hints files or command line option can be used to override them.
+case "$_a" in
+'') _a='.a';;
+esac
+case "$_o" in
+'') _o='.o';;
+esac
+
+: Looking for optional libraries
+echo " "
+echo "Checking for optional libraries..." >&4
+case "$libs" in
+' '|'') dflt='';;
+*) dflt="$libs";;
+esac
+case "$libswanted" in
+'') libswanted='c_s';;
+esac
+for thislib in $libswanted; do
+	
+	if xxx=`./loc lib$thislib.$so.[0-9]'*' X $libpth`; $test -f "$xxx"; then
+		echo "Found -l$thislib (shared)."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l$thislib";;
+		esac
+	elif xxx=`./loc lib$thislib.$so X $libpth` ; $test -f "$xxx"; then
+		echo "Found -l$thislib (shared)."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l$thislib";;
+		esac
+	elif xxx=`./loc lib$thislib$_a X $libpth`; $test -f "$xxx"; then
+		echo "Found -l$thislib."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l$thislib";;
+		esac
+	elif xxx=`./loc $thislib$_a X $libpth`; $test -f "$xxx"; then
+		echo "Found -l$thislib."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l$thislib";;
+		esac
+	elif xxx=`./loc lib${thislib}_s$_a X $libpth`; $test -f "$xxx"; then
+		echo "Found -l${thislib}_s."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l${thislib}_s";;
+		esac
+	elif xxx=`./loc Slib$thislib$_a X $xlibpth`; $test -f "$xxx"; then
+		echo "Found -l$thislib."
+		case " $dflt " in
+		*"-l$thislib "*);;
+		*) dflt="$dflt -l$thislib";;
+		esac
+	else
+		echo "No -l$thislib."
+	fi
+done
+set X $dflt
+shift
+dflt="$*"
+case "$libs" in
+'') dflt="$dflt";;
+*) dflt="$libs";;
+esac
+case "$dflt" in
+' '|'') dflt='none';;
+esac
+
+$cat <<EOM
+ 
+Some versions of Unix support shared libraries, which make executables smaller
+but make load time slightly longer.
+
+On some systems, mostly System V Release 3's, the shared library is included
+by putting the option "-lc_s" as the last thing on the cc command line when
+linking.  Other systems use shared libraries by default.  There may be other
+libraries needed to compile $package on your machine as well.  If your system
+needs the "-lc_s" option, include it here.  Include any other special libraries
+here as well.  Say "none" for none.
+EOM
+
+echo " "
+rp="Any additional libraries?"
+. ./myread
+case "$ans" in
+none) libs=' ';;
+*) libs="$ans";;
+esac
+
+: set up the script used to warn in case of inconsistency
+cat <<EOS >whoa
+$startsh
+EOS
+cat <<'EOSC' >>whoa
+dflt=y
+echo " "
+echo "*** WHOA THERE!!! ***" >&4
+echo "    The $hint value for \$$var on this machine was \"$was\"!" >&4
+rp="    Keep the $hint value?"
+. ./myread
+case "$ans" in
+y) td=$was; tu=$was;;
+esac
+EOSC
+
+: function used to set $1 to $val
+setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef;
+case "$val$was" in
+$define$undef) . ./whoa; eval "$var=\$td";;
+$undef$define) . ./whoa; eval "$var=\$tu";;
+*) eval "$var=$val";;
+esac'
+
+echo " "
+echo "Checking for GNU C Library..." >&4
+cat >gnulibc.c <<EOM
+int
+main()
+{
+	return __libc_main();
+}
+EOM
+if $cc $ccflags $ldflags -o gnulibc gnulibc.c $libs >/dev/null 2>&1 && \
+  ./gnulibc | $contains '^GNU C Library' >/dev/null 2>&1; then
+	val="$define"
+	echo "You are using the GNU C Library"
+else
+	val="$undef"
+	echo "You are not using the GNU C Library"
+fi
+$rm -f gnulibc*
+set d_gnulibc
+eval $setvar
+
+: see if nm is to be used to determine whether a symbol is defined or not
+case "$usenm" in
+'')
+	case "$d_gnulibc" in
+	$define)
+		dflt=n
+		;;
+	*)
+		dflt=`egrep 'inlibc|csym' ../Configure | wc -l 2>/dev/null`
+		if $test $dflt -gt 20; then
+			dflt=y
+		else
+			dflt=n
+		fi
+		;;
+	esac
+	;;
+*)
+	case "$usenm" in
+	true) dflt=y;;
+	*) dflt=n;;
+	esac
+	;;
+esac
+$cat <<EOM
+
+I can use 'nm' to extract the symbols from your C libraries. This is a time
+consuming task which may generate huge output on the disk (up to 3 megabytes)
+but that should make the symbols extraction faster. The alternative is to skip
+the 'nm' extraction part and to compile a small test program instead to
+determine whether each symbol is present. If you have a fast C compiler and/or
+if your 'nm' output cannot be parsed, this may be the best solution.
+You shouldn't let me use 'nm' if you have the GNU C Library.
+
+EOM
+rp='Shall I use nm to extract C symbols from the libraries?'
+. ./myread
+case "$ans" in
+n|N) usenm=false;;
+*) usenm=true;;
+esac
+
+runnm=$usenm
+case "$reuseval" in
+true) runnm=false;;
+esac
+
+: nm options which may be necessary
+case "$nm_opt" in
+'') if $test -f /mach_boot; then
+		nm_opt=''
+	elif $test -d /usr/ccs/lib; then
+		nm_opt='-p'
+	elif $test -f /dgux; then
+		nm_opt='-p'
+	else
+		nm_opt=''
+	fi;;
+esac
+
+: nm options which may be necessary for shared libraries but illegal
+: for archive libraries.  Thank you, Linux.
+case "$nm_so_opt" in
+'')	case "$myuname" in
+	*linux*)
+		if nm --help | $grep 'dynamic' > /dev/null 2>&1; then
+			nm_so_opt='--dynamic'
+		fi
+		;;
+	esac
+	;;
+esac
+
+case "$runnm" in
+true)
+: get list of predefined functions in a handy place
+echo " "
+case "$libc" in
+'') libc=unknown
+	case "$libs" in
+	*-lc_s*) libc=`./loc libc_s$_a $libc $libpth`
+	esac
+	;;
+esac
+libnames='';
+case "$libs" in
+'') ;;
+*)  for thislib in $libs; do
+	case "$thislib" in
+	-lc|-lc_s)
+		: Handle C library specially below.
+		;;
+	-l*)
+		thislib=`echo $thislib | $sed -e 's/^-l//'`
+		if try=`./loc lib$thislib.$so.'*' X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc lib$thislib.$so X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc lib$thislib$_a X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc $thislib$_a X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc lib$thislib X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc $thislib X $libpth`; $test -f "$try"; then
+			:
+		elif try=`./loc Slib$thislib$_a X $xlibpth`; $test -f "$try"; then
+			:
+		else
+			try=''
+		fi
+		libnames="$libnames $try"
+		;;
+	*) libnames="$libnames $thislib" ;;
+	esac
+	done
+	;;
+esac
+xxx=normal
+case "$libc" in
+unknown)
+	set /lib/libc.$so
+	for xxx in $libpth; do
+		$test -r $1 || set $xxx/libc.$so
+		$test -r $1 || \
+			set `echo blurfl; echo /usr/lib/libc.$so.[0-9]* | \
+			tr ' ' '\012' | egrep -v '\.[A-Za-z]*$' | $sed -e '
+				h
+				s/[0-9][0-9]*/0000&/g
+				s/0*\([0-9][0-9][0-9][0-9][0-9]\)/\1/g
+				G
+				s/\n/ /' | \
+			 sort | $sed -e 's/^.* //'`
+		eval set \$$#
+	done
+	$test -r $1 || set /usr/ccs/lib/libc.$so
+	$test -r $1 || set /lib/libsys_s$_a
+	;;
+*)
+	set blurfl
+	;;
+esac
+if $test -r "$1"; then
+	echo "Your (shared) C library seems to be in $1."
+	libc="$1"
+elif $test -r /lib/libc && $test -r /lib/clib; then
+	echo "Your C library seems to be in both /lib/clib and /lib/libc."
+	xxx=apollo
+	libc='/lib/clib /lib/libc'
+	if $test -r /lib/syslib; then
+		echo "(Your math library is in /lib/syslib.)"
+		libc="$libc /lib/syslib"
+	fi
+elif $test -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then
+	echo "Your C library seems to be in $libc, as you said before."
+elif $test -r $incpath/usr/lib/libc$_a; then
+	libc=$incpath/usr/lib/libc$_a;
+	echo "Your C library seems to be in $libc.  That's fine."
+elif $test -r /lib/libc$_a; then
+	libc=/lib/libc$_a;
+	echo "Your C library seems to be in $libc.  You're normal."
+else
+	if tans=`./loc libc$_a blurfl/dyick $libpth`; $test -r "$tans"; then
+		:
+	elif tans=`./loc libc blurfl/dyick $libpth`; $test -r "$tans"; then
+		libnames="$libnames "`./loc clib blurfl/dyick $libpth`
+	elif tans=`./loc clib blurfl/dyick $libpth`; $test -r "$tans"; then
+		:
+	elif tans=`./loc Slibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then
+		:
+	elif tans=`./loc Mlibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then
+		:
+	else
+		tans=`./loc Llibc$_a blurfl/dyick $xlibpth`
+	fi
+	if $test -r "$tans"; then
+		echo "Your C library seems to be in $tans, of all places."
+		libc=$tans
+	else
+		libc='blurfl'
+	fi
+fi
+if $test $xxx = apollo -o -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then
+	dflt="$libc"
+	cat <<EOM
+
+If the guess above is wrong (which it might be if you're using a strange
+compiler, or your machine supports multiple models), you can override it here.
+
+EOM
+else
+	dflt=''
+	echo $libpth | tr ' ' '\012' | sort | uniq > libpath
+	cat >&4 <<EOM
+I can't seem to find your C library.  I've looked in the following places:
+
+EOM
+	$sed 's/^/	/' libpath
+	cat <<EOM
+
+None of these seems to contain your C library. I need to get its name...
+
+EOM
+fi
+fn=f
+rp='Where is your C library?'
+. ./getfile
+libc="$ans"
+
+echo " "
+echo $libc $libnames | tr ' ' '\012' | sort | uniq > libnames
+set X `cat libnames`
+shift
+xxx=files
+case $# in 1) xxx=file; esac
+echo "Extracting names from the following $xxx for later perusal:" >&4
+echo " "
+$sed 's/^/	/' libnames >&4
+echo " "
+$echo $n "This may take a while...$c" >&4
+
+for file in $*; do
+	case $file in
+	*$so*) nm $nm_so_opt $nm_opt $file 2>/dev/null;;
+	*) nm $nm_opt $file 2>/dev/null;;
+	esac
+done >libc.tmp
+
+$echo $n ".$c"
+$grep fprintf libc.tmp > libc.ptf
+xscan='eval "<libc.ptf $com >libc.list"; $echo $n ".$c" >&4'
+xrun='eval "<libc.tmp $com >libc.list"; echo "done" >&4'
+xxx='[ADTSIW]'
+if com="$sed -n -e 's/__IO//' -e 's/^.* $xxx  *_[_.]*//p' -e 's/^.* $xxx  *//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$grep '|' | $sed -n -e '/|COMMON/d' -e '/|DATA/d' \
+				-e '/ file/d' -e 's/^\([^ 	]*\).*/\1/p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^__//' -e '/|Undef/d' -e '/|Proc/s/ .*//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e '/Def. Text/s/.* \([^ ]*\)\$/\1/p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/^[-0-9a-f ]*_\(.*\)=.*/\1/p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+elif com="$sed -n -e 's/.*\.text n\ \ \ \.//p'";\
+	eval $xscan;\
+	$contains '^fprintf$' libc.list >/dev/null 2>&1; then
+		eval $xrun
+else
+	nm -p $* 2>/dev/null >libc.tmp
+	$grep fprintf libc.tmp > libc.ptf
+	if com="$sed -n -e 's/^.* [ADTSIW]  *_[_.]*//p' -e 's/^.* [ADTSIW] //p'";\
+		eval $xscan; $contains '^fprintf$' libc.list >/dev/null 2>&1
+	then
+		nm_opt='-p'
+		eval $xrun
+	else
+		echo " "
+		echo "nm didn't seem to work right. Trying ar instead..." >&4
+		com=''
+		if ar t $libc > libc.tmp; then
+			for thisname in $libnames; do
+				ar t $thisname >>libc.tmp
+			done
+			$sed -e "s/\\$_o\$//" < libc.tmp > libc.list
+			echo "Ok." >&4
+		else
+			echo "ar didn't seem to work right." >&4
+			echo "Maybe this is a Cray...trying bld instead..." >&4
+			if bld t $libc | $sed -e 's/.*\///' -e "s/\\$_o:.*\$//" > libc.list
+			then
+				for thisname in $libnames; do
+					bld t $libnames | \
+					$sed -e 's/.*\///' -e "s/\\$_o:.*\$//" >>libc.list
+					ar t $thisname >>libc.tmp
+				done
+				echo "Ok." >&4
+			else
+				echo "That didn't work either.  Giving up." >&4
+				exit 1
+			fi
+		fi
+	fi
+fi
+nm_extract="$com"
+if $test -f /lib/syscalls.exp; then
+	echo " "
+	echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." >&4
+	$sed -n 's/^\([^ 	]*\)[ 	]*syscall$/\1/p' /lib/syscalls.exp >>libc.list
+fi
+;;
+esac
+$rm -f libnames libpath
+
+: is a C symbol defined?
+csym='tlook=$1;
+case "$3" in
+-v) tf=libc.tmp; tc=""; tdc="";;
+-a) tf=libc.tmp; tc="[0]"; tdc="[]";;
+*) tlook="^$1\$"; tf=libc.list; tc="()"; tdc="()";;
+esac;
+tx=yes;
+case "$reuseval-$4" in
+true-) ;;
+true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;;
+esac;
+case "$tx" in
+yes)
+	case "$runnm" in
+	true)
+		if $contains $tlook $tf >/dev/null 2>&1;
+		then tval=true;
+		else tval=false;
+		fi;;
+	*)
+		echo "main() { extern short $1$tdc; printf(\"%hd\", $1$tc); }" > t.c;
+		if $cc $ccflags $ldflags -o t t.c $libs >/dev/null 2>&1;
+		then tval=true;
+		else tval=false;
+		fi;
+		$rm -f t t.c;;
+	esac;;
+*)
+	case "$tval" in
+	$define) tval=true;;
+	*) tval=false;;
+	esac;;
+esac;
+eval "$2=$tval"'
+
+: define an is-in-libc? function
+inlibc='echo " "; td=$define; tu=$undef;
+sym=$1; var=$2; eval "was=\$$2";
+tx=yes;
+case "$reuseval$was" in
+true) ;;
+true*) tx=no;;
+esac;
+case "$tx" in
+yes)
+	set $sym tres -f;
+	eval $csym;
+	case "$tres" in
+	true)
+		echo "$sym() found." >&4;
+		case "$was" in $undef) . ./whoa; esac; eval "$var=\$td";;
+	*)
+		echo "$sym() NOT found." >&4;
+		case "$was" in $define) . ./whoa; esac; eval "$var=\$tu";;
+	esac;;
+*)
+	case "$was" in
+	$define) echo "$sym() found." >&4;;
+	*) echo "$sym() NOT found." >&4;;
+	esac;;
+esac'
+
+: determine filename position in cpp output
+echo " "
+echo "Computing filename position in cpp output for #include directives..." >&4
+echo '#include <stdio.h>' > foo.c
+$cat >fieldn <<EOF
+$startsh
+$cppstdin $cppflags $cppminus <foo.c 2>/dev/null | \
+$grep '^[ 	]*#.*stdio\.h' | \
+while read cline; do
+	pos=1
+	set \$cline
+	while $test \$# -gt 0; do
+		if $test -r \`echo \$1 | $tr -d '"'\`; then
+			echo "\$pos"
+			exit 0
+		fi
+		shift
+		pos=\`expr \$pos + 1\`
+	done
+done
+EOF
+chmod +x fieldn
+fieldn=`./fieldn`
+$rm -f foo.c fieldn
+case $fieldn in
+'') pos='???';;
+1) pos=first;;
+2) pos=second;;
+3) pos=third;;
+*) pos="${fieldn}th";;
+esac
+echo "Your cpp writes the filename in the $pos field of the line."
+
+: locate header file
+$cat >findhdr <<EOF
+$startsh
+wanted=\$1
+name=''
+if test -f $usrinc/\$wanted; then
+	echo "$usrinc/\$wanted"
+	exit 0
+fi
+awkprg='{ print \$$fieldn }'
+echo "#include <\$wanted>" > foo\$\$.c
+$cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \
+$grep "^[ 	]*#.*\$wanted" | \
+while read cline; do
+	name=\`echo \$cline | $awk "\$awkprg" | $tr -d '"'\`
+	case "\$name" in
+	*/\$wanted) echo "\$name"; exit 0;;
+	*) name='';;
+	esac;
+done;
+$rm -f foo\$\$.c;
+case "\$name" in
+'') exit 1;;
+esac
+EOF
+chmod +x findhdr
+
+: access call always available on UNIX
+set access d_access
+eval $inlibc
+
+: locate the flags for 'access()'
+case "$d_access" in
+"$define")
+	echo " "
+	$cat >access.c <<'EOCP'
+#include <sys/types.h>
+#ifdef I_FCNTL
+#include <fcntl.h>
+#endif
+#ifdef I_SYS_FILE
+#include <sys/file.h>
+#endif
+#ifdef I_UNISTD
+#include <unistd.h>
+#endif
+main() {
+	exit(R_OK);
+}
+EOCP
+	: check sys/file.h first, no particular reason here
+	if $test `./findhdr sys/file.h` && \
+		$cc $cppflags -DI_SYS_FILE access.c -o access >/dev/null 2>&1 ; then
+		h_sysfile=true;
+		echo "<sys/file.h> defines the *_OK access constants." >&4
+	elif $test `./findhdr fcntl.h` && \
+		$cc $cppflags -DI_FCNTL access.c -o access >/dev/null 2>&1 ; then
+		h_fcntl=true;
+		echo "<fcntl.h> defines the *_OK access constants." >&4
+	elif $test `./findhdr unistd.h` && \
+		$cc $cppflags -DI_UNISTD access.c -o access >/dev/null 2>&1 ; then
+		echo "<unistd.h> defines the *_OK access constants." >&4
+	else
+		echo "I can't find the four *_OK access constants--I'll use mine." >&4
+	fi
+	;;
+esac
+$rm -f access*
+
+: Look for GNU-cc style attribute checking
+echo " "
+echo "Checking whether your compiler can handle __attribute__ ..." >&4
+$cat >attrib.c <<'EOCP'
+#include <stdio.h>
+void croak (char* pat,...) __attribute__((format(printf,1,2),noreturn));
+EOCP
+if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then
+	if $contains 'warning' attrib.out >/dev/null 2>&1; then
+		echo "Your C compiler doesn't fully support __attribute__."
+		val="$undef"
+	else
+		echo "Your C compiler supports __attribute__."
+		val="$define"
+	fi
+else
+	echo "Your C compiler doesn't seem to understand __attribute__ at all."
+	val="$undef"
+fi
+set d_attribut
+eval $setvar
+$rm -f attrib*
+
+: check for const keyword
+echo " "
+echo 'Checking to see if your C compiler knows about "const"...' >&4
+$cat >const.c <<'EOCP'
+typedef struct spug { int drokk; } spug;
+main()
+{
+	const char *foo;
+	const spug y;
+}
+EOCP
+if $cc -c $ccflags const.c >/dev/null 2>&1 ; then
+	val="$define"
+	echo "Yup, it does."
+else
+	val="$undef"
+	echo "Nope, it doesn't."
+fi
+set d_const
+eval $setvar
+
+: see how we invoke the C preprocessor
+$cat <<EOM
+
+$package needs to be able to preprocess its input files in a mode which
+preserves comments, which is often not the default behaviour.  It should run
+the C preprocessor you will use when compiling your own source code, which
+should be ISO/ANSI C compliant if you want $package to handle the latest
+standard C.  I will try to guess, but I might guess wrongly because it is not
+necessarily the same preprocessor used to build $package.
+
+EOM
+$cat <<'EOT' >testcpp.c
+#define ABC abc
+#define XYZ xyz
+ABC.XYZ
+/* comment */
+EOT
+:
+if $test "X$cppfilecom" != "X" && \
+	$cppfilecom testcpp.c </dev/null >testcpp.out 2>/dev/null && \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "You used to use $cppfilecom so we'll use that again."
+elif echo 'Maybe "'$cc' -E -C" will work...' && \
+	$cc -E -C testcpp.c </dev/null >testcpp.out 2>/dev/null && \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "It works!"
+	cppfilecom="$cc -E -C"
+elif echo 'Nope...maybe "'"$cc"' -P -C" will work...' && \
+	$cc -P -C testcpp.c </dev/null >testcpp.out 2>/dev/null && \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "Yup, that does."
+	cppfilecom="$cc -P -C"
+elif echo 'No such luck, maybe "'"$cpp"' -C" will work...' && \
+	$cpp -C testcpp.c </dev/null >testcpp.out 2>/dev/null && \
+	$contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "Yup, it does."
+	cppfilecom="$cpp -C"
+else
+	cppfilecom=''
+	$cat <<'EOM'
+I can't find a C preprocessor that will preserve comments. Please name one.
+EOM
+fi
+:
+dflt="$cppfilecom"
+cont=true
+while $test "$cont" ; do
+	echo " "
+	rp="How should $package run your preprocessor preserving comments?"
+	. ./myread
+	cppfilecom="$ans"
+	$cppfilecom testcpp.c >testcpp.out 2>&1
+	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+		$contains comment testcpp.out >/dev/null 2>&1
+	then
+		echo "OK, that will do."
+		cont=''
+	else
+		echo "Sorry, I can't get that to work."
+	fi
+done
+
+: Now see if it ignores header files.
+cp testcpp.c testcpp.h
+$cppfilecom testcpp.h >testcpp.out 2>&1
+if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "Terrific; it processes .h files passed on the command line too."
+	val="$undef"
+else
+	echo "It ignores .h files on the command line; pity."
+	val="$define"
+fi
+set d_cppignhdrs
+eval $setvar
+
+: Now see how to send stdin to it.
+echo " "
+cp testcpp.c testcpp.h
+$cppfilecom <testcpp.h >testcpp.out 2>&1
+if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+	$contains comment testcpp.out >/dev/null 2>&1
+then
+	echo "Great; and it will read stdin if passed no arguments."
+	val="$define"
+	cppstdinflags=''
+else
+	$cppfilecom - <testcpp.h >testcpp.out 2>&1
+	if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+		$contains comment testcpp.out >/dev/null 2>&1
+	then
+		echo "Great; and it can read stdin by passing it '-'."
+		val="$define"
+		cppstdinflags='-'
+	else
+		$cat <<FOO
+Unfortunately, I can't find an easy way to get that preprocessor to read from
+standard input. Do you know any flags I can pass it to get it to do so?
+If that preprocessor can't read directly form standard input, answer 'none'.
+
+FOO
+	val='dunno'
+	while $test "$val" = "dunno"; do
+		rp='Flags to get preprocessor to read stdin?'
+		dflt='none'
+		. ./myread
+		if $test $ans = 'none'; then
+			echo "Oh well, if $package wants it done, it will do it for itself."
+			val="$undef"
+		else
+			$cppfilecom $ans <testcpp.h >testcpp.out 2>&1
+			if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \
+				$contains comment testcpp.out >/dev/null 2>&1
+			then
+				echo "Good; that works fine."
+				val="$define"
+				cppstdinflags="$ans"
+			else
+				echo "Sorry, I couldn't get that to work."
+			fi
+		fi
+	done
+	fi
+fi
+set d_cppcanstdin
+eval $setvar
+
+: cleanup cpp test files anyway
+$rm -f testcpp.*
+
+: see if we can have long filenames
+echo " "
+rmlist="$rmlist /tmp/cf$$"
+$test -d /tmp/cf$$ || mkdir /tmp/cf$$
+first=123456789abcdef
+second=/tmp/cf$$/$first
+$rm -f $first $second
+if (echo hi >$first) 2>/dev/null; then
+	if $test -f 123456789abcde; then
+		echo 'You cannot have filenames longer than 14 characters.  Sigh.' >&4
+		val="$undef"
+	else
+		if (echo hi >$second) 2>/dev/null; then
+			if $test -f /tmp/cf$$/123456789abcde; then
+				$cat <<'EOM'
+That's peculiar... You can have filenames longer than 14 characters, but only
+on some of the filesystems.  Maybe you are using NFS.  Anyway, to avoid problems
+I shall consider your system cannot support long filenames at all.
+EOM
+				val="$undef"
+			else
+				echo 'You can have filenames longer than 14 characters.' >&4
+				val="$define"
+			fi
+		else
+			$cat <<'EOM'
+How confusing! Some of your filesystems are sane enough to allow filenames
+longer than 14 characters but some others like /tmp can't even think about them.
+So, for now on, I shall assume your kernel does not allow them at all.
+EOM
+			val="$undef"
+		fi
+	fi
+else
+	$cat <<'EOM'
+You can't have filenames longer than 14 chars.  You can't even think about them!
+EOM
+	val="$undef"
+fi 
+set d_flexfnam
+eval $setvar
+$rm -rf /tmp/cf$$ 123456789abcde*
+
+: see which of string.h or strings.h is needed
+echo " "
+strings=`./findhdr string.h`
+if $test "$strings" && $test -r "$strings"; then
+	echo "Using <string.h> instead of <strings.h>." >&4
+	val="$define"
+else
+	val="$undef"
+	strings=`./findhdr strings.h`
+	if $test "$strings" && $test -r "$strings"; then
+		echo "Using <strings.h> instead of <string.h>." >&4
+	else
+		echo "No string header found -- You'll surely have problems." >&4
+	fi
+fi
+set i_string
+eval $setvar
+case "$i_string" in
+"$undef") strings=`./findhdr strings.h`;;
+*)	  strings=`./findhdr string.h`;;
+esac
+
+: index or strchr
+echo " "
+if set index val -f; eval $csym; $val; then
+	if set strchr val -f d_strchr; eval $csym; $val; then
+		if $contains strchr "$strings" >/dev/null 2>&1 ; then
+			val="$define"
+			vali="$undef"
+			echo "strchr() found." >&4
+		else
+			val="$undef"
+			vali="$define"
+			echo "index() found." >&4
+		fi
+	else
+		val="$undef"
+		vali="$define"
+		echo "index() found." >&4
+	fi
+else
+	if set strchr val -f d_strchr; eval $csym; $val; then
+		val="$define"
+		vali="$undef"
+		echo "strchr() found." >&4
+	else
+		echo "No index() or strchr() found!" >&4
+		val="$undef"
+		vali="$undef"
+	fi
+fi
+set d_strchr; eval $setvar
+val="$vali"
+set d_index; eval $setvar
+
+: see if link exists
+set link d_link
+eval $inlibc
+
+: Locate the flags for 'open()'
+echo " "
+$cat >open3.c <<'EOCP'
+#include <sys/types.h>
+#ifdef I_FCNTL
+#include <fcntl.h>
+#endif
+#ifdef I_SYS_FILE
+#include <sys/file.h>
+#endif
+main() {
+	if(O_RDONLY);
+#ifdef O_TRUNC
+	exit(0);
+#else
+	exit(1);
+#endif
+}
+EOCP
+: check sys/file.h first to get FREAD on Sun
+if $test `./findhdr sys/file.h` && \
+		$cc $cppflags "-DI_SYS_FILE" open3.c -o open3 >/dev/null 2>&1 ; then
+	h_sysfile=true;
+	echo "<sys/file.h> defines the O_* constants..." >&4
+	if ./open3; then
+		echo "and you have the 3 argument form of open()." >&4
+		val="$define"
+	else
+		echo "but not the 3 argument form of open().  Oh, well." >&4
+		val="$undef"
+	fi
+elif $test `./findhdr fcntl.h` && \
+		$cc "-DI_FCNTL" open3.c -o open3 >/dev/null 2>&1 ; then
+	h_fcntl=true;
+	echo "<fcntl.h> defines the O_* constants..." >&4
+	if ./open3; then
+		echo "and you have the 3 argument form of open()." >&4
+		val="$define"
+	else
+		echo "but not the 3 argument form of open().  Oh, well." >&4
+		val="$undef"
+	fi
+else
+	val="$undef"
+	echo "I can't find the O_* constant definitions!  You got problems." >&4
+fi
+set d_open3
+eval $setvar
+$rm -f open3*
+
+: see if strftime exists
+set strftime d_strftime
+eval $inlibc
+
+: see if strstr exists
+set strstr d_strstr
+eval $inlibc
+
+: see if symlink exists
+set symlink d_symlink
+eval $inlibc
+
+: check for volatile keyword
+echo " "
+echo 'Checking to see if your C compiler knows about "volatile"...' >&4
+$cat >try.c <<'EOCP'
+main()
+{
+	typedef struct _goo_struct goo_struct;
+	goo_struct * volatile goo = ((goo_struct *)0);
+	struct _goo_struct {
+		long long_int;
+		int reg_int;
+		char char_var;
+	};
+	typedef unsigned short foo_t;
+	char *volatile foo;
+	volatile int bar;
+	volatile foo_t blech;
+	foo = foo;
+}
+EOCP
+if $cc -c $ccflags try.c >/dev/null 2>&1 ; then
+	val="$define"
+	echo "Yup, it does."
+else
+	val="$undef"
+	echo "Nope, it doesn't."
+fi
+set d_volatile
+eval $setvar
+$rm -f try.*
+
+: preserve RCS keywords in files with variable substitution, grrr
+Id='$Id'
+
+: check for void type
+echo " "
+echo "Checking to see how well your C compiler groks the void type..." >&4
+echo " "
+$cat >&4 <<EOM
+  Support flag bits are:
+    1: basic void declarations.
+    2: arrays of pointers to functions returning void.
+    4: operations between pointers to and addresses of void functions.
+    8: generic void pointers.
+EOM
+echo " "
+case "$voidflags" in
+'')
+	$cat >try.c <<'EOCP'
+#if TRY & 1
+void sub() {
+#else
+sub() {
+#endif
+	extern void moo();	/* function returning void */
+	void (*goo)();		/* ptr to func returning void */
+#if TRY & 8
+	void *hue;		/* generic ptr */
+#endif
+#if TRY & 2
+	void (*foo[10])();
+#endif
+
+#if TRY & 4
+	if(goo == moo) {
+		exit(0);
+	}
+#endif
+	exit(0);
+}
+main() { sub(); }
+EOCP
+	if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then
+		voidflags=$defvoidused
+	echo "It appears to support void to the level $package wants ($defvoidused)."
+		if $contains warning .out >/dev/null 2>&1; then
+			echo "However, you might get some warnings that look like this:"
+			$cat .out
+		fi
+	else
+echo "Hmm, your compiler has some difficulty with void. Checking further..." >&4
+		if $cc $ccflags -c -DTRY=1 try.c >/dev/null 2>&1; then
+			echo "It supports 1..."
+			if $cc $ccflags -c -DTRY=3 try.c >/dev/null 2>&1; then
+				echo "It also supports 2..."
+				if $cc $ccflags -c -DTRY=7 try.c >/dev/null 2>&1; then
+					voidflags=7
+					echo "And it supports 4 but not 8 definitely."
+				else
+					echo "It doesn't support 4..."
+					if $cc $ccflags -c -DTRY=11 try.c >/dev/null 2>&1; then
+						voidflags=11
+						echo "But it supports 8."
+					else
+						voidflags=3
+						echo "Neither does it support 8."
+					fi
+				fi
+			else
+				echo "It does not support 2..."
+				if $cc $ccflags -c -DTRY=13 try.c >/dev/null 2>&1; then
+					voidflags=13
+					echo "But it supports 4 and 8."
+				else
+					if $cc $ccflags -c -DTRY=5 try.c >/dev/null 2>&1; then
+						voidflags=5
+						echo "And it supports 4 but has not heard about 8."
+					else
+						echo "However it supports 8 but not 4."
+					fi
+				fi
+			fi
+		else
+			echo "There is no support at all for void."
+			voidflags=0
+		fi
+	fi
+esac
+case "$voidflags" in
+"$defvoidused") ;;
+*)
+	dflt="$voidflags";
+	rp="Your void support flags add up to what?"
+	. ./myread
+	voidflags="$ans"
+	;;
+esac
+$rm -f try.* .out
+
+: determine lexical analyser generator
+case "$lex" in
+'')
+	dflt=lex;;
+*)
+	dflt="$lex";;
+esac
+echo " "
+if $test -f "$flex"; then
+	rp='Which lexical analyser generator (lex or flex) shall I use?'
+else
+	rp='Which lexical analyser generator shall I use?'
+fi
+. ./myread
+lex="$ans"
+
+: if using lex this will normally be useless, but flex frequently takes args
+echo " "
+case "$lexflags" in
+'') dflt='none';;
+*) dflt="$lexflags";;
+esac
+rp="What flags should be given to $lex?"
+. ./myread
+case "$ans" in
+none) lexflags='';;
+*) lexflags="$ans";;
+esac
+
+: determine compiler compiler
+case "$yacc" in
+'')
+	dflt=yacc;;
+*)
+	dflt="$yacc";;
+esac
+echo " "
+comp='yacc'
+if $test -f "$byacc"; then
+	dflt="$byacc"
+	comp="byacc or $comp"
+fi
+if $test -f "$bison"; then
+	comp="$comp or bison -y"
+fi
+rp="Which compiler compiler ($comp) shall I use?"
+. ./myread
+yacc="$ans"
+case "$yacc" in
+*bis*)
+	case "$yacc" in
+	*-y*) ;;
+	*)
+		yacc="$yacc -y"
+		echo "(Adding -y option to bison to get yacc-compatible behaviour.)"
+		;;
+	esac
+	;;
+esac
+
+: see if we need extra yacc flags
+dflt="$yaccflags"
+case "$dflt" in
+'') dflt=none;;
+esac
+$cat <<EOH
+
+Your yacc program may need extra flags to normally process the parser sources.
+Do NOT specify any -d or -v flags here, since those are explicitely known
+by the various Makefiles. However, if your machine has strange/undocumented
+options (like -Sr# on SCO to specify the maximum number of grammar rules), then
+please add them here.  To use no flags, specify the word "none".
+
+EOH
+rp="Any additional yacc flags?"
+. ./myread
+case "$ans" in
+none) yaccflags='';;
+*) yaccflags="$ans";;
+esac
+
+: see if we should include -ly
+echo " "
+case "$yacc" in
+*byacc*)
+	echo "You are using byacc, so I won't look for a yacc library." >&4
+	libyacc=''
+	;;
+*yacc)
+	xxx=`./loc liby$_a x $libpth`
+	case "$xxx" in
+	x)
+		echo "No yacc library found." >&4
+		libyacc=''
+		;;
+	*)
+		echo "yacc library found in $xxx." >&4
+		libyacc="$xxx"
+		;;
+	esac
+	;;
+*bison*)
+	echo "You are using bison, so I won't look for a yacc library." >&4
+	libyacc=''
+	;;
+*)
+echo "You don't seem to have yacc, so I won't look for the yacc library." >&4
+	libyacc=''
+	;;
+esac
+
+: find out how to generate dependencies
+echo " "
+echo "Checking how to generate makefile dependencies on your machine..." >&4
+toplev=`cd ..;pwd`
+$cat >dep.c <<'EOCP'
+#include "dep.h"
+EOCP
+$cat >dep.h <<'EOCP'
+
+EOCP
+takeflags='flags=""
+case "$@" in
+*--*)
+	for arg
+	do
+		shift
+		case "$arg" in
+		--) break;;
+		*) flags="$flags $arg";;
+		esac
+	done;;
+esac'
+case "$mkdep" in
+'')
+	;;
+*)
+	if test -x "$mkdep" &&
+		$mkdep dep.c >dep.out 2>/dev/null &&
+		$contains "dep$_o:.*dep\.h" dep.out >/dev/null 2>&1
+	then
+		echo "$mkdep works."
+	else
+		mkdep=
+	fi
+esac
+
+case "$mkdep" in
+'')
+	$spitshell > ../mkdep <<EOM
+$startsh
+$takeflags
+for srcfile
+do
+	$cpp -M -I. $cppflags \$flags \$srcfile 2>/dev/null
+done
+exit 0
+EOM
+	mkdep=$toplev/mkdep
+	chmod +x $mkdep
+	$eunicefix $mkdep
+	if $mkdep dep.c >dep.out 2>/dev/null &&
+		$contains "dep$_o:.*dep\.h" dep.out >/dev/null 2>&1
+	then
+		echo "Looks like we can use $cpp -M."
+	else
+		mkdep=
+	fi
+	;;
+esac
+
+case "$mkdep" in
+'')
+	$spitshell > ../mkdep <<EOM
+$startsh
+$takeflags
+for srcfile
+do
+	$cc -MM -I. $cppflags \$flags \$srcfile 2>/dev/null
+done
+exit 0
+EOM
+	mkdep=$toplev/mkdep
+	chmod +x $mkdep
+	$eunicefix $mkdep
+	if $mkdep dep.c >dep.out 2>/dev/null &&
+		$contains "dep$_o: dep.h" dep.out >/dev/null 2>&1
+	then
+		echo "Looks like we can use $cc -MM."
+	else
+		mkdep=
+	fi
+	;;
+esac
+
+case "$mkdep" in
+'')
+	$spitshell >../mkdep <<EOS
+$startsh
+$takeflags
+for srcfile
+do
+	case "\$srcfile" in
+	*.c) c='.c';;
+	*.y) c='.y';;
+	*.l) c='.l';;
+	esac
+	filebase=\`basename \$srcfile \$c\`
+	<\$srcfile $cpp $cppminus $cppflags -I. \$flags 2>/dev/null | \\
+	$sed -e '/^# *[0-9]/!d' \\
+		-e 's/^.*"\(.*\)".*\$/'\$filebase'$_o: \1/' \\
+		-e 's|: \./|: |' \\
+		-e 's|: *$|: '\$srcfile'|' | \\
+	$grep -v '^#' | $sort | $uniq
+done
+exit 0
+EOS
+	mkdep=$toplev/mkdep
+	chmod +x $mkdep
+	$eunicefix $mkdep
+	if $mkdep dep.c >dep.out 2>/dev/null &&
+		$contains "dep$_o:.*dep\.h" dep.out >/dev/null 2>&1
+	then
+		echo "A shell script using $cpp does the trick."
+	else
+		echo "$cpp doesn't seem to be any use at all."
+		$spitshell >../mkdep <<EOS
+$startsh
+$takeflags
+files="\$@"
+set X \$flags
+shift
+inc='.'
+while test \$# -gt 0
+do
+	case "\$1" in
+	-I) 
+		shift
+		inc="\$inc:\$1"
+		;;
+	-I*)
+		dir=\`echo \$1 | sed -e 's/^-I//'\`
+		inc="\$inc:\$dir"
+		;;
+	esac
+	shift
+done
+set X \$files
+shift
+trap "$rm -f /tmp/mkdep\$\$; exit 1" 1 2 3 15
+for srcfile
+do
+	case "\$srcfile" in
+	*.c) c='.c';;
+	*.y) c='.y';;
+	*.l) c='.l';;
+	esac
+	filebase=\`basename \$srcfile \$c\`
+	echo \$filebase$_o: \$srcfile
+	$grep '^#[  ]*include' \$srcfile /dev/null | \
+	$sed -n -e 's/#[   ]*include[  ]*//' \\
+		-e '/<\(.*\)>/ d' \\
+		-e 's/:[^"]*"\([^"]*\)".*/: \1/' \\
+		-e "s/\\.c:/$_o:/p" > /tmp/mkdep\$\$
+	IFS=': '
+	while read file dep; do
+		for dir in \$inc; do
+			if $test -f "\$dir/\$dep"; then
+				dep="\$dir/\$dep"
+				break
+			fi
+		done
+		echo "\$file: \$dep" | $sed -e 's,: \./,: ,'
+	done </tmp/mkdep\$\$
+	IFS=' '
+	$rm -f /tmp/mkdep\$\$
+done
+exit 0
+EOS
+		mkdep=$toplev/mkdep
+		chmod +x $mkdep
+		$eunicefix $mkdep
+		if $mkdep dep.c >dep.out 2>/dev/null &&
+			$contains "dep$_o:.*dep\.h" dep.out >/dev/null 2>&1
+		then
+			cat << EOM
+
+I can use a script with grep instead, but it will make some incorrect
+dependencies, since it doesn't understand about conditional compilation.
+Moreover, some dependencies may be missing, because scanning won't be
+a recursive process.
+If you have a program which generates makefile dependencies, you may want
+to use it.  If not, you can use the script and edit the Makefile by hand
+if you need to.
+EOM
+		else
+			mkdep=
+			cat << EOM
+
+I can't seem to generate makefile dependencies at all!  Perhaps you have a
+program that does?  If you don't, you might look at the mkdep script to
+see if you can create one which works.
+EOM
+		fi
+	fi
+esac
+dflt="$mkdep"
+fn=f~/
+rp="Name of program to make makefile dependencies?"
+. ./getfile
+mkdep="$ans"
+$rm -f dep.c dep.h dep$_o dep.out
+
+: Cruising for prototypes
+echo " "
+echo "Checking out function prototypes..." >&4
+$cat >prototype.c <<'EOCP'
+main(int argc, char *argv[]) {
+	exit(0);}
+EOCP
+if $cc $ccflags -c prototype.c >prototype.out 2>&1 ; then
+	echo "Your C compiler appears to support function prototypes."
+	val="$define"
+else
+	echo "Your C compiler doesn't seem to understand function prototypes."
+	val="$undef"
+fi
+set prototype
+eval $setvar
+$rm -f prototype*
+
+: see if signal is declared as pointer to function returning int or void
+echo " "
+xxx=`./findhdr signal.h`
+$test "$xxx" && $cppstdin $cppminus $cppflags < $xxx >$$.tmp 2>/dev/null
+if $contains 'int.*\*[ 	]*signal' $$.tmp >/dev/null 2>&1 ; then
+	echo "You have int (*signal())() instead of void." >&4
+	val="$undef"
+elif $contains 'void.*\*[ 	]*signal' $$.tmp >/dev/null 2>&1 ; then
+	echo "You have void (*signal())() instead of int." >&4
+	val="$define"
+elif $contains 'extern[ 	]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then
+	echo "You have int (*signal())() instead of void." >&4
+	val="$undef"
+else
+	case "$d_voidsig" in
+	'')
+	echo "I can't determine whether signal handler returns void or int..." >&4
+		dflt=void
+		rp="What type does your signal handler return?"
+		. ./myread
+		case "$ans" in
+		v*) val="$define";;
+		*) val="$undef";;
+		esac;;
+	"$define")
+		echo "As you already told me, signal handler returns void." >&4;;
+	*)
+		echo "As you already told me, signal handler returns int." >&4;;
+	esac
+fi
+set d_voidsig
+eval $setvar
+case "$d_voidsig" in
+"$define") signal_t="void";;
+*) signal_t="int";;
+esac
+$rm -f $$.tmp
+
+: define an is-a-typedef? function
+typedef='type=$1; var=$2; def=$3; shift; shift; shift; inclist=$@;
+case "$inclist" in
+"") inclist="sys/types.h";;
+esac;
+eval "varval=\$$var";
+case "$varval" in
+"")
+	$rm -f temp.c;
+	for inc in $inclist; do
+		echo "#include <$inc>" >>temp.c;
+	done;
+	$cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null;
+	if $contains $type temp.E >/dev/null 2>&1; then
+		eval "$var=\$type";
+	else
+		eval "$var=\$def";
+	fi;
+	$rm -f temp.?;;
+*) eval "$var=\$varval";;
+esac'
+
+: see if time exists
+echo " "
+if set time val -f d_time; eval $csym; $val; then
+	echo 'time() found.' >&4
+	val="$define"
+	set time_t timetype long stdio.h sys/types.h
+	eval $typedef
+	dflt="$timetype"
+	echo " "
+	rp="What type is returned by time() on this system?"
+	. ./myread
+	timetype="$ans"
+else
+	echo 'time() not found, hope that will do.' >&4
+	val="$undef"
+	timetype='int';
+fi
+set d_time
+eval $setvar
+
+: see if stdarg is available
+echo " "
+if $test `./findhdr stdarg.h`; then
+	echo "<stdarg.h> found." >&4
+	valstd="$define"
+else
+	echo "<stdarg.h> NOT found." >&4
+	valstd="$undef"
+fi
+
+: see if varags is available
+echo " "
+if $test `./findhdr varargs.h`; then
+	echo "<varargs.h> found." >&4
+else
+	echo "<varargs.h> NOT found, but that's ok (I hope)." >&4
+fi
+
+: set up the varargs testing programs
+$cat > varargs.c <<EOP
+#ifdef I_STDARG
+#include <stdarg.h>
+#endif
+#ifdef I_VARARGS
+#include <varargs.h>
+#endif
+
+#ifdef I_STDARG
+int f(char *p, ...)
+#else
+int f(va_alist)
+va_dcl
+#endif
+{
+	va_list ap;
+#ifndef I_STDARG
+	char *p;
+#endif
+#ifdef I_STDARG
+	va_start(ap,p);
+#else
+	va_start(ap);
+	p = va_arg(ap, char *);
+#endif
+	va_end(ap);
+}
+EOP
+$cat > varargs <<EOP
+$startsh
+if $cc -c $ccflags -D\$1 varargs.c >/dev/null 2>&1; then
+	echo "true"
+else
+	echo "false"
+fi
+$rm -f varargs$_o
+EOP
+chmod +x varargs
+
+: now check which varargs header should be included
+echo " "
+i_varhdr=''
+case "$valstd" in
+"$define")
+	if `./varargs I_STDARG`; then
+		val='stdarg.h'
+	elif `./varargs I_VARARGS`; then
+		val='varargs.h'
+	fi
+	;;
+*)
+	if `./varargs I_VARARGS`; then
+		val='varargs.h'
+	fi
+	;;
+esac
+case "$val" in
+'')
+echo "I could not find the definition for va_dcl... You have problems..." >&4
+	val="$undef"; set i_stdarg; eval $setvar
+	val="$undef"; set i_varargs; eval $setvar
+	;;
+*) 
+	set i_varhdr
+	eval $setvar
+	case "$i_varhdr" in
+	stdarg.h)
+		val="$define"; set i_stdarg; eval $setvar
+		val="$undef"; set i_varargs; eval $setvar
+		;;
+	varargs.h)
+		val="$undef"; set i_stdarg; eval $setvar
+		val="$define"; set i_varargs; eval $setvar
+		;;
+	esac
+	echo "We'll include <$i_varhdr> to get va_dcl definition." >&4;;
+esac
+$rm -f varargs*
+
+: see if prototypes support variable argument declarations
+echo " "
+case "$prototype$i_stdarg" in
+$define$define)
+	echo "It appears we'll be able to prototype varargs functions." >&4
+	val="$define"
+	;;
+*)
+	echo "Too bad... We won't be using prototyped varargs functions..." >&4
+	val="$undef"
+	;;
+esac
+set vaproto
+eval $setvar
+
+$cat <<EOH
+
+You may wish to compile with extra compiler warnings enabled.
+Note that doing so enhances your chance of receiving your free set of steak
+knives, particularly if you find any bugs and report them.
+If you don't want extra warnings, answer "none".
+  
+EOH
+case "$warnflags" in
+'') case "$cc" in
+	*gcc*)
+		dflt="-Wall -Wno-comment"
+		if $contains 'fprintf' `./findhdr stdio.h` >/dev/null 2>&1; then
+			:
+		else
+			dflt="$dflt -Wno-implicit"
+		fi
+		;;
+	*) dflt="none";;
+	esac
+	;;
+' ') dflt="none";;
+*) dflt="$warnflags";;
+esac
+
+rp="Any $cc flags to enable warnings?"
+. ./myread
+case "$ans" in
+none) warnflags=' ';;
+*) warnflags="$ans";;
+esac
+
+: define an alternate in-header-list? function
+inhdr='echo " "; td=$define; tu=$undef; yyy=$@;
+cont=true; xxf="echo \"<\$1> found.\" >&4";
+case $# in 2) xxnf="echo \"<\$1> NOT found.\" >&4";;
+*) xxnf="echo \"<\$1> NOT found, ...\" >&4";;
+esac;
+case $# in 4) instead=instead;; *) instead="at last";; esac;
+while $test "$cont"; do
+	xxx=`./findhdr $1`
+	var=$2; eval "was=\$$2";
+	if $test "$xxx" && $test -r "$xxx";
+	then eval $xxf;
+	eval "case \"\$$var\" in $undef) . ./whoa; esac"; eval "$var=\$td";
+		cont="";
+	else eval $xxnf;
+	eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu"; fi;
+	set $yyy; shift; shift; yyy=$@;
+	case $# in 0) cont="";;
+	2) xxf="echo \"but I found <\$1> $instead.\" >&4";
+		xxnf="echo \"and I did not find <\$1> either.\" >&4";;
+	*) xxf="echo \"but I found <\$1\> instead.\" >&4";
+		xxnf="echo \"there is no <\$1>, ...\" >&4";;
+	esac;
+done;
+while $test "$yyy";
+do set $yyy; var=$2; eval "was=\$$2";
+	eval "case \"\$$var\" in $define) . ./whoa; esac"; eval "$var=\$tu";
+	set $yyy; shift; shift; yyy=$@;
+done'
+
+: see if this is a sys/file.h system
+val=''
+set sys/file.h val
+eval $inhdr
+
+: do we need to include sys/file.h ?
+case "$val" in
+"$define")
+	echo " "
+	if $h_sysfile; then
+		val="$define"
+		echo "We'll be including <sys/file.h>." >&4
+	else
+		val="$undef"
+		echo "We won't be including <sys/file.h>." >&4
+	fi
+	;;
+*)
+	h_sysfile=false
+	;;
+esac
+set i_sysfile
+eval $setvar
+
+: see if fcntl.h is there
+val=''
+set fcntl.h val
+eval $inhdr
+
+: see if we can include fcntl.h
+case "$val" in
+"$define")
+	echo " "
+	if $h_fcntl; then
+		val="$define"
+		echo "We'll be including <fcntl.h>." >&4
+	else
+		val="$undef"
+		if $h_sysfile; then
+	echo "We don't need to include <fcntl.h> if we include <sys/file.h>." >&4
+		else
+			echo "We won't be including <fcntl.h>." >&4
+		fi
+	fi
+	;;
+*)
+	h_fcntl=false
+	val="$undef"
+	;;
+esac
+set i_fcntl
+eval $setvar
+
+: see if stddef is available
+set stddef.h i_stddef
+eval $inhdr
+
+: see if stdlib is available
+set stdlib.h i_stdlib
+eval $inhdr
+
+: see if we should include time.h, sys/time.h, or both
+echo " "
+echo "Testing to see if we should include <time.h>, <sys/time.h> or both." >&4
+$echo $n "I'm now running the test program...$c"
+$cat >try.c <<'EOCP'
+#include <sys/types.h>
+#ifdef I_TIME
+#include <time.h>
+#endif
+#ifdef I_SYSTIME
+#ifdef SYSTIMEKERNEL
+#define KERNEL
+#endif
+#include <sys/time.h>
+#endif
+#ifdef I_SYSSELECT
+#include <sys/select.h>
+#endif
+main()
+{
+	struct tm foo;
+#ifdef S_TIMEVAL
+	struct timeval bar;
+#endif
+#ifdef S_TIMEZONE
+	struct timezone tzp;
+#endif
+	if (foo.tm_sec == foo.tm_sec)
+		exit(0);
+#ifdef S_TIMEVAL
+	if (bar.tv_sec == bar.tv_sec)
+		exit(0);
+#endif
+	exit(1);
+}
+EOCP
+flags=''
+s_timezone=''
+sysselect=''
+for s_timeval in '-DS_TIMEVAL' ''; do
+for i_systimek in '' '-DSYSTIMEKERNEL'; do
+for i_time in '' '-DI_TIME'; do
+for i_systime in '-DI_SYSTIME' ''; do
+	case "$flags" in
+	'') $echo $n ".$c"
+		if $cc $ccflags \
+		$i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone \
+		try.c -o try >/dev/null 2>&1 ; then
+			set X $i_time $i_systime $i_systimek $sysselect $s_timeval
+			shift
+			flags="$*"
+			echo " "
+			$echo $n "Succeeded with $flags$c"
+		fi
+		;;
+	esac
+done
+done
+done
+done
+timeincl=''
+echo " "
+case "$flags" in
+*SYSTIMEKERNEL*) i_systimek="$define"
+	timeincl=`./findhdr sys/time.h`
+	echo "We'll include <sys/time.h> with KERNEL defined." >&4;;
+*) i_systimek="$undef";;
+esac
+case "$flags" in
+*I_TIME*) i_time="$define"
+	timeincl=`./findhdr time.h`" $timeincl"
+	echo "We'll include <time.h>." >&4;;
+*) i_time="$undef";;
+esac
+case "$flags" in
+*I_SYSTIME*) i_systime="$define"
+	timeincl=`./findhdr sys/time.h`" $timeincl"
+	echo "We'll include <sys/time.h>." >&4;;
+*) i_systime="$undef";;
+esac
+$rm -f try.c try
+
+: see if sys/types.h has to be included
+set sys/types.h i_systypes
+eval $inhdr
+
+: see if this is a unistd.h system
+set unistd.h i_unistd
+eval $inhdr
+
+: end of configuration questions
+echo " "
+echo "End of configuration questions."
+echo " "
+
+: back to where it started
+if test -d ../UU; then
+	cd ..
+fi
+
+: configuration may be patched via a 'config.over' file
+if $test -f config.over; then
+	echo " "
+	dflt=y
+	rp='I see a config.over file.  Do you wish to load it?'
+	. UU/myread
+	case "$ans" in
+	n*) echo "OK, I'll ignore it.";;
+	*)	. ./config.over
+		echo "Configuration override changes have been loaded."
+		;;
+	esac
+fi
+
+: in case they want portability, strip down executable paths
+case "$d_portable" in
+"$define")
+	echo " "
+	echo "Stripping down executable paths..." >&4
+	for file in $loclist $trylist; do
+		eval $file="\$file"
+	done
+	;;
+esac
+
+: create config.sh file
+echo " "
+echo "Creating config.sh..." >&4
+$spitshell <<EOT >config.sh
+$startsh
+#
+# This file was produced by running the Configure script. It holds all the
+# definitions figured out by Configure. Should you modify one of these values,
+# do not forget to propagate your changes by running "Configure -der". You may
+# instead choose to run each of the .SH files by yourself, or "Configure -S".
+#
+
+# Package name      : $package
+# Source directory  : $src
+# Configuration time: $cf_time
+# Configured by     : $cf_by
+# Target system     : $myuname
+
+Author='$Author'
+Date='$Date'
+Header='$Header'
+Id='$Id'
+Locker='$Locker'
+Log='$Log'
+Mcc='$Mcc'
+RCSfile='$RCSfile'
+Revision='$Revision'
+Source='$Source'
+State='$State'
+afs='$afs'
+ar='$ar'
+archobjs='$archobjs'
+awk='$awk'
+bash='$bash'
+bin='$bin'
+binexp='$binexp'
+bison='$bison'
+byacc='$byacc'
+c='$c'
+cat='$cat'
+cc='$cc'
+ccflags='$ccflags'
+cf_by='$cf_by'
+cf_time='$cf_time'
+chgrp='$chgrp'
+chmod='$chmod'
+chown='$chown'
+comm='$comm'
+compress='$compress'
+contains='$contains'
+cp='$cp'
+cpio='$cpio'
+cpp='$cpp'
+cppfilecom='$cppfilecom'
+cppflags='$cppflags'
+cpplast='$cpplast'
+cppminus='$cppminus'
+cpprun='$cpprun'
+cppstdin='$cppstdin'
+cppstdinflags='$cppstdinflags'
+csh='$csh'
+d_access='$d_access'
+d_attribut='$d_attribut'
+d_bsd='$d_bsd'
+d_const='$d_const'
+d_cppcanstdin='$d_cppcanstdin'
+d_cppignhdrs='$d_cppignhdrs'
+d_eunice='$d_eunice'
+d_flexfnam='$d_flexfnam'
+d_gnulibc='$d_gnulibc'
+d_index='$d_index'
+d_link='$d_link'
+d_open3='$d_open3'
+d_portable='$d_portable'
+d_strchr='$d_strchr'
+d_strftime='$d_strftime'
+d_strstr='$d_strstr'
+d_symlink='$d_symlink'
+d_time='$d_time'
+d_voidsig='$d_voidsig'
+d_volatile='$d_volatile'
+d_xenix='$d_xenix'
+date='$date'
+defvoidused='$defvoidused'
+echo='$echo'
+egrep='$egrep'
+emacs='$emacs'
+eunicefix='$eunicefix'
+expr='$expr'
+find='$find'
+firstmakefile='$firstmakefile'
+flex='$flex'
+gcc='$gcc'
+gccversion='$gccversion'
+glibpth='$glibpth'
+grep='$grep'
+gzip='$gzip'
+h_fcntl='$h_fcntl'
+h_sysfile='$h_sysfile'
+hint='$hint'
+i_fcntl='$i_fcntl'
+i_stdarg='$i_stdarg'
+i_stddef='$i_stddef'
+i_stdlib='$i_stdlib'
+i_string='$i_string'
+i_sysfile='$i_sysfile'
+i_systime='$i_systime'
+i_systimek='$i_systimek'
+i_systypes='$i_systypes'
+i_time='$i_time'
+i_unistd='$i_unistd'
+i_varargs='$i_varargs'
+i_varhdr='$i_varhdr'
+incpath='$incpath'
+inews='$inews'
+installbin='$installbin'
+installmansrc='$installmansrc'
+installprivlib='$installprivlib'
+ksh='$ksh'
+ldflags='$ldflags'
+less='$less'
+lex='$lex'
+lexflags='$lexflags'
+libc='$libc'
+libpth='$libpth'
+libs='$libs'
+libyacc='$libyacc'
+line='$line'
+lint='$lint'
+lkflags='$lkflags'
+ln='$ln'
+lns='$lns'
+locincpth='$locincpth'
+loclibpth='$loclibpth'
+lp='$lp'
+lpr='$lpr'
+ls='$ls'
+mail='$mail'
+mailx='$mailx'
+make='$make'
+manext='$manext'
+mansrc='$mansrc'
+mansrcexp='$mansrcexp'
+mips='$mips'
+mips_type='$mips_type'
+mkdep='$mkdep'
+mkdir='$mkdir'
+more='$more'
+mv='$mv'
+myuname='$myuname'
+n='$n'
+nm_opt='$nm_opt'
+nm_so_opt='$nm_so_opt'
+nroff='$nroff'
+optimize='$optimize'
+osname='$osname'
+osvers='$osvers'
+package='$package'
+perl='$perl'
+pg='$pg'
+plibpth='$plibpth'
+pmake='$pmake'
+pr='$pr'
+prefix='$prefix'
+prefixexp='$prefixexp'
+privlib='$privlib'
+privlibexp='$privlibexp'
+prototype='$prototype'
+rm='$rm'
+rmail='$rmail'
+runnm='$runnm'
+sed='$sed'
+sendmail='$sendmail'
+sh='$sh'
+shar='$shar'
+sharpbang='$sharpbang'
+shsharp='$shsharp'
+signal_t='$signal_t'
+sleep='$sleep'
+smail='$smail'
+so='$so'
+sort='$sort'
+spackage='$spackage'
+spitshell='$spitshell'
+src='$src'
+startsh='$startsh'
+strings='$strings'
+submit='$submit'
+sysman='$sysman'
+tail='$tail'
+tar='$tar'
+tbl='$tbl'
+test='$test'
+timeincl='$timeincl'
+timetype='$timetype'
+touch='$touch'
+tr='$tr'
+troff='$troff'
+uname='$uname'
+uniq='$uniq'
+usenm='$usenm'
+usrinc='$usrinc'
+uuname='$uuname'
+vaproto='$vaproto'
+vi='$vi'
+voidflags='$voidflags'
+warnflags='$warnflags'
+xlibpth='$xlibpth'
+yacc='$yacc'
+yaccflags='$yaccflags'
+zcat='$zcat'
+zip='$zip'
+EOT
+
+: add special variables
+$test -f $src/patchlevel.h && \
+awk '/^#define/ {printf "%s=%s\n",$2,$3}' $src/patchlevel.h >>config.sh
+echo "CONFIG=true" >>config.sh
+
+: propagate old symbols
+if $test -f UU/config.sh; then
+	<UU/config.sh sort | uniq >UU/oldconfig.sh
+	sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' config.sh config.sh UU/oldconfig.sh |\
+	sort | uniq -u >UU/oldsyms
+	set X `cat UU/oldsyms`
+	shift
+	case $# in
+	0) ;;
+	*)
+		cat <<EOM
+Hmm...You had some extra variables I don't know about...I'll try to keep 'em...
+EOM
+		echo "# Variables propagated from previous config.sh file." >>config.sh
+		for sym in `cat UU/oldsyms`; do
+			echo "    Propagating $hint variable "'$'"$sym..."
+			eval 'tmp="$'"${sym}"'"'
+			echo "$tmp" | \
+				sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh
+		done
+		;;
+	esac
+fi
+
+: Finish up by extracting the .SH files
+case "$alldone" in
+exit)
+	$rm -rf UU
+	echo "Done."
+	exit 0
+	;;
+cont)
+	;;
+'')
+	dflt=''
+	nostick=true
+	$cat <<EOM
+
+If you'd like to make any changes to the config.sh file before I begin
+to configure things, do it as a shell escape now (e.g. !vi config.sh).
+
+EOM
+	rp="Press return or use a shell escape to edit config.sh:"
+	. UU/myread
+	nostick=''
+	case "$ans" in
+	'') ;;
+	*) : in case they cannot read
+		sh 1>&4 -c "$ans";;
+	esac
+	;;
+esac
+
+: if this fails, just run all the .SH files by hand
+. ./config.sh
+
+echo " "
+exec 1>&4
+. ./UU/extract
+
+if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then
+	dflt=y
+	case "$silent" in
+	true) ;;
+	*)
+		$cat <<EOM
+
+Now you need to generate make dependencies by running "make depend".
+You might prefer to run it in background: "make depend > makedepend.out &"
+It can take a while, so you might not want to run it right now.
+
+EOM
+		;;
+	esac
+	rp="Run make depend now?"
+	. UU/myread
+	case "$ans" in
+	y*)
+		make depend && echo "Now you must run a make."
+		;;
+	*)
+		echo "You must run 'make depend' then 'make'."
+		;;
+	esac
+elif test -f [Mm]akefile; then
+	echo " "
+	echo "Now you must run a make."
+else
+	echo "Done."
+fi
+
+$rm -f kit*isdone ark*isdone
+$rm -rf UU
+
+: End of Configure
+
diff --git a/FAQ b/FAQ
new file mode 100644
index 0000000..8abf1d3
--- /dev/null
+++ b/FAQ
@@ -0,0 +1,204 @@
+Frequently Asked Questions about c2man
+--------------------------------------
+By Graham Stoney (greyham@research.canon.com.au)
+Last-modified: $Date: 2004-05-03 05:17:49 $
+
+Q. Where can I get an up-to-date already patched copy of c2man?
+
+A. You can usually get the latest version via ftp:
+	ftp /pub/Unix/Util/c2man-2.0.*.tar.gz from dnpap.et.tudelft.nl
+
+   Many thanks to Richard Kooijman <R.Kooijman@et.tudelft.nl> for providing
+   the ftp site, and keeping it up to date.  The very latest version probably
+   won't be available until a short time after each patch is issued, since
+   we're relying on Richard's kindness to apply the patches and keep the tar
+   file up to date manually.
+
+   You can also retrieve the latest version via the author's mail server, by
+   mailing to greyham@research.canon.com.au with a message like:
+
+	Subject: Command
+	@PACK shar
+	@SH maildist - c2man 2.0
+
+   In reply, you can expect on the order of 9 or so mail messages, each around
+   55 K long.  You'll also have the extra hassle of unpacking it.  Detailed
+   instructions on using the mail server can be obtained by mailing to the
+   same with address a message like:
+
+        Subject: Command
+        @SH mailhelp -
+
+   It should also be available in your local comp.sources.misc archive.  The
+   versions in the alt.sources and comp.sources.reviewed archives are
+   obsolete.  One day soon I'll be able to put it up for ftp here directly.
+
+
+Q. How do I remove myself from the c2man discussion list?
+
+A. You should have received instructions on how to do this when you joined the
+   list.  It's always wise to save a copy of the instructions you receive when
+   you join a mailing list, so that you can refer to them in future when you
+   wish to leave.
+
+   To remove yourself from the c2man discussion list, send E-mail to:
+        listserv@research.canon.com.au
+
+   With the message:
+	Subject:
+	unsubscribe c2man
+
+   You should also be able to unsubscribe be running Configure again, and
+   asking it to unsubscribe you when it asks if you wish to subscribe to, or
+   unsubscribe from the mailing list.
+
+   Note that the discussion list and the automatic patch notification/update
+   list are completely independant.
+
+
+Q. How do I remove myself from the c2man automatic patch notification/update
+   list?
+
+A. If you don't wish to receive future notification or mailing of new patches,
+   you need to send a message to the author's personal mail server.  In other
+   words, you send E-mail to:
+	greyham@research.canon.com.au
+
+   With the message:
+	Subject: Command
+	@SH package - c2man
+
+   You can also achieve the same effect by running Configure and asking that
+   future patches not be sent to you.  You may also alter your notification
+   vs update preference via Configure.
+
+
+Q. Can c2man handle C++?  Is anyone working on a version that can?
+
+A. No, it can't handle C++, although there are other tools that do a similar
+   job for C++.  A few people have expressed interest, but I don't know of
+   anyone who is actively working on it.  If you look in the file C++autodoc in
+   the distribution, you'll get all the gory details.  This file is always kept
+   up-to-date with the current state of play.
+
+
+Q. How do I apply the official patches to c2man?
+
+A. You need the patch program, by Larry Wall.  Chances are that it's already
+   installed on your system; if not, you could ask your system administrator
+   about getting it, or search for it using archie if you know how.  Once
+   you've got it, follow the instructions in each of the patch headers.  For
+   example, patch 10 says:
+
+    Fix:    From rn, say "| patch -p -N -d DIR", where DIR is your c2man source
+	    directory.  Outside of rn, say "cd DIR; patch -p -N <thisarticle".
+	    If you don't have the patch program, apply the following by hand,
+	    or get patch (version 2.0, latest patchlevel).
+    
+   In other words, 'cd' to your c2man directory and type:
+	    patch -p -N < patch10
+
+   That should feed the patch into the patch program, which will apply it.  You
+   also need to take care to follow the "After Patching" instructions in each
+   patch, and repeat this procedure for each patch.  In general, you can apply
+   all the patches without having to re-run Configure after every patch set,
+   although you must run Configure after patch30, because it renames a few
+   files.  You can apply patches 10 through 30 without having to run Configure
+   though.  The "After patching" instructions assume that you apply patches as
+   they are issued; you don't generally have to do them multiple times if
+   you're applying a whole group of patch sets.
+
+
+Q. Can c2man document structure fields automatically, like it does for enums?
+
+A. In short, No.
+
+   This is a very logical extension; so much so in fact that I'd say it's
+   absence in the current version is a real deficiency.  I'm not sure if you
+   always want the structure contents listed in the manual page for the
+   functions that use the type though, since some interfaces use "opaque"
+   types, where the structure contents is deliberately hidden from the user;
+   eg: the stdio FILE type.  My thoughts were to generate a separate manual
+   page for each struct or type definition, with perhaps an option to include
+   the info in all the functional manual pages using that type, as now happens
+   with enum types now.
+   
+   Adding struct support to the current grammar should be fairly easy; mainly
+   by copying what it does with enum's; and it would certainly be very
+   worthwhile.  I'd encourage anyone who'd like to see greater functionality in
+   c2man to feel free to add it in, and send me the diffs.
+
+   Sorry, this doesn't work at present.  It's probably the most serious
+   omission from the program; lots of people have asked about this.  At
+   present, I don't know when it's likely to be fixed.  I might suddenly get
+   really keen one day and do it -- otherwise, someone else will have to
+   implement it and send me the diffs.  It shouldn't be too hard, but it's a
+   matter of making it a priority and getting around to actually doing it...
+
+
+Q. Why do my functions using ``FILE *'' get documented with this weird
+   ``struct _iobuf'' type?
+
+A. Unfortunately, many systems use a #define for ``FILE'' in stdio.h to rename
+   it to ``struct _iobuf'', rather than using a typedef.  Since c2man sees the
+   output of the pre-processor, ``FILE'' is long gone before it reads the
+   code, and so the documentation that it generates is misleading.
+
+   Some stdio.h's perform this #define conditionally, so it may be possible to
+   pass certain -D flags to c2man which will cause stdio.h to use a typedef
+   instead, although this will be very system-dependant.
+
+   I don't know of a really good solution to this problem, but I'd be
+   interested to hear if anyone has one.
+
+
+Q. How can I get c2man recognise and document #defines?
+
+A. c2man doesn't recognise #defines at all, but you can rewrite it as an enum.
+   You do need to be able to change the type passed to an enum though, to get
+   c2man to recognise that it's what's being passed.  C is very loose with its
+   enums, so it's still just as flexible as the #define case, and the types
+   look more self-documenting in the code too:
+
+	enum Bits
+	{
+		BIT0 = 1,       /* The first bit */
+		BIT1 = 2,       /* The next bit */
+		BIT2 = 4        /* The last bit */
+	};
+	
+	/* set the bits! */
+	void set_bits( enum Bits bits );
+	
+   Gives you:
+	
+	set_bits(3)         UNIX Programmer's Manual          set_bits(3)
+	
+	NAME
+		set_bits - set the bits!
+	
+	SYNOPSIS
+		#include <set_bits.h>
+	
+		void set_bits(enum Bits bits);
+	
+	PARAMETERS
+		enum Bits bits
+		    Possible values for an enum Bits are as follows:
+		    BIT0  The first bit.
+		    BIT1  The next bit.
+		    BIT2  The last bit.
+	
+	DESCRIPTION
+		Set the bits!.
+
+
+Q. But what if my function returns an errno-like code which can take many
+   values, but I'd like the documentation to list only those that the function
+   in question can actually generate?
+
+A. c2man makes a crude attempt at identifying token/value lists in the RETURNS
+   section from the comment describing the function.  If the first thing on a
+   line in the RETURNS section is a single token followed a ':' or TAB
+   character, c2man interprets it as a token list and attempts to format it
+   accordingly.  Have a look at the file "eg/reterrno.h" for an exmple.
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..3f4622a
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,74 @@
+INSTALLING c2man:
+
+1. For OS/2 and MSDOS, see the README.pc file in the pc directory.
+
+   For all flavours of Unix, run Configure and answer the questions.
+   Most of the time the default answers should do the trick, but here's some
+   tips; If you're using...
+
+ANSI-C:	Don't put the compiler in strict ISO/ANSI mode, since c2man uses a few
+	UNIX-isms that may disappear from your header files if you do that
+	(eg: popen). Don't use -ansi on gcc for example.
+
+gcc:	Do yourself a favour and use the latest version of gcc (>= 2.3.3).
+	If you use -Wall, also use -Wno-implicit if your system header files
+	don't declare basic stuff like fprintf in stdio.h (SunOS Release 4.1.2
+	for example!).
+
+bison:	If you get link errors reporting `alloca' as undefined, try specifying
+	-lPW when Configure asks `Any additional libraries?'.
+
+flex:	You may need to specify -lfl when asked `Any additional libraries?'.
+	Flex versions 2.3 and older will cause c2man to hang if it encounters
+	an 8 bit character in the input file.  If you require 8-bit character
+	support, use the flex flag '-8' (this is the default for flex 2.4).
+
+Sun:	Sun yacc outputs old prototypes for malloc and free (says they return
+	char * instead of void *), which conflict with the correct ones flex 2.3
+	generates if you use gcc. To make matters worse, gcc 2.2 errors on the
+	old prototypes even if you don't use flex. Use bison instead, or just
+	delete the incorrect prototypes on the first line of y.tab.c when the
+	make errors. If you use gcc 2.2, just upgrade your gcc.
+
+HPUX:	When using cc, don't specify -Aa.  Adding -D_HPUX_SOURCE may help too.
+	If you use the optional c89 compiler instead of standard cc, specify
+	-D_INCLUDE_POSIX_SOURCE -D_INCLUDE_XOPEN_SOURCE as your compiler flags.
+
+dbmalloc:
+	Specify a compiler flag of -DDBMALLOC (and optimization -g if you like)
+	and a library of -ldbmalloc for maximum checking. Don't use dbmalloc
+	with gcc and flex, or y.tab.c will fail to build; just use lex instead.
+	Don't use the shared version of your C library (eg: -lc_s), as
+	Configure will by default, lest you get multiply defined symbols.
+
+Interactive Unix 2.2:
+	If you use gcc (which requires -posix) ignore the warnings about
+	popen/pclose not being defined - apparently they aren't in POSIX.
+
+NeXT:	In NeXTstep 3.1 and greater, `cc -C -E' is broken; tell Configure to
+	run the preprocessor as `/lib/cpp -C' or `cc -C -E -traditional-cpp'.
+	On NeXTstep 3.2, don't link with -lposix.  It's busted.  Sigh.
+
+Otherwise, If you get any errors or warnings, please report them to me (with
+fixes if possible!). Don't worry too much about warnings from y.tab.c or
+lex.yy.c though, since they're generally at the mercy of your yacc & lex.
+
+2. run make depend, if you didn't do it at the end of Configure.
+
+3. run make
+
+4. format (and read) the manual page in c2man.1.
+   The examples in it are automatically generated, so check that it looks OK.
+
+5. Optionally, run "make test > /dev/null" if you don't want to wade though
+   heaps of output, or "make test | nroff -man | more" if you do. This runs
+   c2man over the examples, and on its own source. The test is assumed to pass
+   if it doesn't error or dump core.
+
+   If the preprocessor you told Configure that c2man is to use is different to
+   the one used to when compiling c2man itself, the test may fail because the
+   definitions in config.h may not match the preprocessor c2man will run
+   during the test and in normal use.
+
+6. As root, do "make install". This will install the c2man binary, the example
+   files and the manual page.
diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..cb3907e
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,64 @@
+README		Start here.
+ChangeLog	Log of recent changes.
+INSTALL		How to install it.
+FAQ		Frequently Asked Questions about c2man, with Answers.
+C++autodoc	An article describing how C++ support could be added.
+MANIFEST	This list of all files in the package.
+Configure	Automated installation script.
+c2man.man	Source for the manual pages; needs flattening.
+Makefile.SH	Produces Makefile.
+catalog		Free Compilers Catalog entry for c2man.
+example.h	First example header file for the manual page.
+ctype_ex.h	Second example header file for the manual page.
+flatten.SH	Produces sed script to flatten c2man.1 for installation.
+fixexamp.in	Commented sed script to format man page examples.
+lex.l		Lexical analyser.
+grammar.y	Parser.
+config_h.SH	Produces config.h, the portability header.
+patchlevel.h	The current patch level.
+confmagic.h	Further portability magic brought to you by metaconfig.
+c2man.h		Source code...
+semantic.h
+symbol.h
+strconcat.h
+manpage.h
+enum.h
+c2man.c
+semantic.c
+string.c
+symbol.c
+strconcat.c
+manpage.c
+enum.c
+strappend.c 
+strappend.h
+output.h	Format-independant interface to backends.
+nroff.c		Backend for nroff output.
+texinfo.c	Backend for texinfo output.
+latex.c		Backend for LaTeX output.
+html.c		Backend for HTML output.
+autodoc.c	Backend for AutoDoc output.
+libc/README.libc Info about library routines which may help.
+libc/COPYING	GPL to cover the GNU-derived library routines.
+libc/getopt.c	getopt support for OS/2, MSDOS & VMS.
+libc/getopt.h	...
+libc/getopt1.c	...
+libc/alloca.c	Portable alloca() routine.
+eg/boxcomment.c	Example input files...
+eg/ccomment.h
+eg/commentaft.c
+eg/cppcomment.h
+eg/dash.h
+eg/ellipsis.c
+eg/grouped.c
+eg/multidecl.c
+eg/namedash.h
+eg/oldstyle.c
+eg/returnerr.h
+eg/returnlist.h
+eg/sections.c
+eg/simplesect.c
+eg/surround.c
+eg/underscore.h
+eg/variable.c
+eg/retdecl.c 
diff --git a/Makefile.SH b/Makefile.SH
new file mode 100755
index 0000000..5f427cd
--- /dev/null
+++ b/Makefile.SH
@@ -0,0 +1,172 @@
+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
+: This forces SH files to create target in same directory as SH file.
+: This is so that make depend always knows where to find SH derivatives.
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+echo "Extracting Makefile (with variable substitutions)"
+: This section of the file will have variable substitutions done on it.
+: Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
+: Protect any dollar signs and backticks that you do not want interpreted
+: by putting a backslash in front.  You may delete these comments.
+$spitshell >Makefile <<!GROK!THIS!
+# $Id: Makefile.SH,v 1.1 2004-05-03 05:17:48 behdad Exp $
+#
+# UNIX makefile for manual page generator
+# Note: any changes made here will be lost next time Configure is run!.
+
+CC=$cc $optimize
+YACC=$yacc $yaccflags
+LEX=$lex $lexflags
+SED=$sed
+CAT=$cat
+RM=$rm
+MV=$mv
+CP=$cp
+ECHO=$echo
+MKDEP=$mkdep
+
+# where we get installed
+bin=$binexp
+privlib=$installprivlib
+
+mansrc=$mansrc
+manext=$manext
+CFLAGS=$ccflags
+WARNFLAGS=$warnflags
+LDFLAGS=$ldflags
+LIBS=$libs $liblex $libyacc
+!GROK!THIS!
+
+: In the following dollars and backticks do not need the extra backslash.
+$spitshell >>Makefile <<'!NO!SUBS!'
+
+# As Larry said, "Grrrr"
+SHELL=/bin/sh
+
+OSOURCES =	config.h c2man.h semantic.h symbol.h strconcat.h \
+		strappend.h manpage.h enum.h output.h lex.l grammar.y
+DCSOURCES =	c2man.c semantic.c string.c symbol.c strconcat.c \
+		strappend.c manpage.c enum.c nroff.c texinfo.c latex.c html.c \
+		autodoc.c
+SOURCES =	$(OSOURCES) $(DCSOURCES)
+CSOURCES =	$(DCSOURCES) y.tab.c
+OBJECTS =	c2man.o semantic.o string.o symbol.o y.tab.o strconcat.o \
+		strappend.o manpage.o enum.o nroff.o texinfo.o latex.o html.o \
+		autodoc.o
+GENERATED =	c2man example.inc ctype_ex.inc y.tab.c lex.yy.c y.output \
+		fixexamp.sed flatten.sed
+
+
+all: c2man c2man.1
+
+install: all
+	$(CP) c2man $(bin)
+	$(CP) c2man.1 $(mansrc)/c2man.$(manext)
+	-mkdir $(privlib)
+	chmod 755 $(privlib)
+	-mkdir $(privlib)/eg
+	chmod 755 $(privlib)/eg
+	$(CP) eg/*.[chly] $(privlib)/eg
+	chmod 755 $(privlib)/eg/*
+
+uninstall:
+	$(RM) -f $(bin)/c2man $(mansrc)/c2man.$(manext)
+	$(RM) -f $(privlib)/eg/*
+	rmdir $(privlib)/eg
+	rmdir $(privlib)
+
+c2man: $(OBJECTS)
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LIBS)
+
+c2man.1: c2man.man c2man example.inc ctype_ex.inc flatten.sed
+	$(SED) -f flatten.sed < c2man.man > c2man.1
+
+.c.o:
+	$(CC) $(CFLAGS) $(WARNFLAGS) -c $<
+
+y.tab.c: grammar.y
+	@$(ECHO) Expect 61 shift/reduce conflicts.
+	$(YACC) grammar.y
+
+# don't compile y.tab.c with all warnings; yacc/bison are not up to it.
+y.tab.o: y.tab.c lex.yy.c
+	$(CC) $(CFLAGS) -c y.tab.c
+
+lex.yy.c: lex.l
+	$(LEX) -n lex.l
+
+example.inc: c2man example.h fixexamp.sed
+	./c2man -o- example.h | $(SED) -f fixexamp.sed >example.inc
+
+ctype_ex.inc: c2man ctype_ex.h fixexamp.sed
+	./c2man -o- -g ctype_ex.h | $(SED) -f fixexamp.sed >ctype_ex.inc
+
+fixexamp.sed: fixexamp.in
+	$(SED) -e '/^#/d' fixexamp.in > fixexamp.sed
+
+flatten.sed: flatten.SH config.sh
+	sh flatten.SH
+
+Makefile: Makefile.SH config.sh
+	sh Makefile.SH
+
+config.h: config_h.SH config.sh
+	sh config_h.SH
+
+TAGS: $(SOURCES)
+	etags -t $(SOURCES)
+
+clean:
+	$(RM) -f *.o *.s *.bak *~ *.log $(GENERATED) core
+
+distclean realclean: clean
+	$(RM) -f Makefile config.sh mkdep c2man.kit?
+
+lint:
+	lint -b $(CFLAGS) $(CSOURCES)
+
+print:
+	cpr $(SOURCES) | lpr -J'c2man'
+
+test: c2man
+	@echo "Running c2man over the examples..." 1>&2
+	@for file in eg/*.[chly]; do ./c2man -v -o- $$file; done
+	@echo "Running c2man over its own source code..." 1>&2
+	@for file in $(DCSOURCES); do ./c2man -v -o- $$file; done
+	@echo "Hmmm, test seemed to go OK." 1>&2
+
+depend:
+	$(SED) -e '1,/^# DO NOT/!d' < Makefile > Makefile.new
+	$(MKDEP) $(DCSOURCES) >> Makefile.new
+	- test ! -f y.tab.c -o ! -f lex.yy.c || $(MKDEP) y.tab.c >> Makefile.new
+	$(MV) -f Makefile.new Makefile
+
+# y.tab.c dependancies updated manually since it won't exist yet when make
+# depend is first run.
+y.tab.o: c2man.h
+y.tab.o: config.h
+y.tab.o: confmagic.h
+y.tab.o: enum.h
+y.tab.o: manpage.h
+y.tab.o: semantic.h
+y.tab.o: strappend.h
+y.tab.o: strconcat.h
+y.tab.o: symbol.h
+
+# DO NOT DELETE THIS LINE! make depend DEPENDS ON IT!
+c2man.o:
+	@echo "You must run a make depend first."; exit 1
+!NO!SUBS!
+chmod 755 Makefile
+$eunicefix Makefile
diff --git a/README b/README
new file mode 100644
index 0000000..a42e054
--- /dev/null
+++ b/README
@@ -0,0 +1,112 @@
+
+				c2man, Version 2
+				by Graham Stoney
+
+			    Copyright (c) 1992-1996
+		 Canon Information Systems Research Australia
+			      All rights reserved.
+
+C2man is an automatic documentation tool that extracts comments from C source
+code to generate functional interface documentation in the same format as
+sections 2 & 3 of the Unix Programmer's Manual. It requires minimal effort from
+the programmer by looking for comments in the usual places near the objects
+they document, rather than imposing a rigid function-comment syntax or
+requiring that the programmer learn and use a typesetting language.  Acceptable
+documentation can often be generated from existing code with no modifications.
+
+The program can generate nroff/troff -man, TeXinfo, LaTeX or HTML output
+directly, and should run on virtually any Unix-like system, OS/2, VMS, MSDOS or
+Amiga systems.
+
+You will need lex or flex, plus yacc or bison, and a C compiler (traditional
+K&R 1 or ISO/ANSI will do) to build the program. You'll also need a text
+formatter to format its output.
+
+This version of c2man is copyright, but may be freely redistributed and modified
+so long as:
+
+1. The names of all contributing authors remain on the documentation,
+2. All derivative works are clearly documented as such,
+3. All derivative works remain freely redistributable under the same conditions.
+
+As such, there is no warranty.
+
+The manual page includes some automatically generated examples, which will be
+missing if you try to read it before doing a make.  Running make will generate
+the complete manual page, which you can then copy around freely.
+
+c2man does not currently support C++, but if you think this would be worth
+while, look in the file "C++autodoc" for information on how I envisage C++
+support could be added, and get ready to volunteer.  Note that this isn't
+related to the Commodore Amiga AutoDoc backend; the name's just a coincidence.
+
+The file "FAQ" in the c2man distribution contains answers to a number of
+Frequently Asked Questions about c2man.
+
+By popular demand, there are a few trivial examples of different comment
+styles in the "eg" directory.  I'm open to submissions from users too.
+
+
+There is a mailing list for c2man users; it is very low volume and has a very
+low noise content.  This is the preferred place to ask questions about the
+program and discuss modifications and additions with the author and other
+users, but please check in the file "FAQ" first before asking questions on the
+list, in case I've already answered it.  You are encouraged to join by sending
+mail with no Subject: line to <listserv@research.canon.com.au> containing:
+
+	SUBSCRIBE c2man Your name
+
+Where `Your name' should be replaced with your real name.
+Messages for distribution to everyone on the list should be sent to:
+<c2man@research.canon.com.au>.
+
+
+The time I have available for c2man support is rather limited, but if it lacks
+any features you require, feel free to Email me (preferably to the mailing list
+address above) asking about it.  Unless you request otherwise, I will probably
+cc: to the list replies to any questions that I get mailed, to save me
+answering them again for other people.  I encourage you to go ahead and make
+any changes you like and send me the diffs for inclusion in the next patch, but
+it's a good idea to ask first in case someone already has the feature you want
+in the works.  In order for me to integrate your changes, they need to be
+reasonably "clean", and you'll need to update manual page as appropriate.
+
+Please try to remember to include the c2man version number in any bug reports.
+You can find it by running: c2man -V /dev/null
+
+If you'd like to be notified automatically about new releases and patches,
+answer yes to the Configure question about sending mail to the author.
+
+
+Special thanks for their direct and indirect contributions to c2man go to:
+    Larry Wall, Raphael Manfredi, Harlan Stenn and the "dist" team, for writing
+    various bits of metaconfig, which generated the Configure script.
+
+    Darrel Hankerson for the OS/2 and MSDOS ports.
+    Rick Flower for the VMS port.
+    Stefan Ruppert for the Amiga port, and AutoDoc backend.
+
+    Richard Kooijman for the LaTeX backend, and for fixing the TeXinfo backend.
+    Diab Jerius too, for more work on the TeXinfo backend.
+    Frank P.J. Ooms for the HTML backend.
+
+    Vern Paxson for his suggestions on how to handle comment lexing better.
+
+Thanks to the following people for suggestions & bug fixes is long overdue:
+    Peter (P.) Barszczewski, Carlo Tarantola, Dennis Allison,
+    Philip Yzarn de Louraille, Jerry Lieberthal, Mats Ohrman, Stefan Zimmermann,
+    Dolf Grunbauer, Lele Gaifax, Carl R. Crawford, Jhon Honce, Chris Borchert,
+    Jerry E. Dunmire, Marty Leisner, Dan Forrest, Ken Weinert, Ken Poppleton,
+    Michael Hamilton, Thomas E. Dickey, Marco Nijdam.
+
+Finally, c2man owes a huge debt to the public domain program cproto, by
+Chin Huang, from which the original code was derived.
+
+(Hmmm.  This is beginning to sound like an Academy Awards night...)
+
+
+See the file "INSTALL" for Unix installation instructions.
+
+
+Graham Stoney					  greyham@research.canon.com.au
+Mailing List for general c2man Questions & Answers  c2man@research.canon.com.au
diff --git a/autodoc.c b/autodoc.c
new file mode 100644
index 0000000..0291fc2
--- /dev/null
+++ b/autodoc.c
@@ -0,0 +1,554 @@
+/*
+** $PROJECT:
+**
+** $VER: autodoc.c 2.2 (25.01.95)
+**
+** by
+**
+** Stefan Ruppert , Windthorststra_e 5 , 65439 Flvrsheim , GERMANY
+**
+** (C) Copyright 1995
+** All Rights Reserved !
+**
+** $HISTORY:
+**
+** 25.01.95 : 002.002 : changed to patchlevel 33
+** 22.01.95 : 000.001 : initial
+*/
+
+#include "c2man.h"
+#include "manpage.h"
+#include "output.h"
+#include <ctype.h>
+
+#ifdef DEBUG
+#define D(x)  x
+#else
+#define D(x)
+#endif
+
+#define MAX_TAG      10
+
+static const int linelength   = 79;
+static const int tablength    =  4;
+static const int indentlength =  4;
+
+static int indent      = 4;
+static int list_indent = 0;
+static int column      = 0;
+static int newline     = FALSE;
+static int breakline   = FALSE;
+static int see_also    = FALSE;
+static int fileend     = FALSE;
+static int acttable    = -1;
+static int tablemaxtag[MAX_TAG];
+
+void autodoc_format(text)
+const char *text;
+{
+    if(see_also)
+    {
+       if(column + ((text) ? strlen(text) + 2 : 1) > linelength)
+       {
+           putchar('\n');
+           newline = TRUE;
+       }
+    }
+
+    if(newline)
+    {
+       int i;
+       column = i = indent + list_indent;
+       for(; i ; i--)
+          putchar(' ');
+       newline = FALSE;
+    }
+}
+
+void autodoc_text(text)
+const char *text;
+{
+    int br = 1;
+    autodoc_format(text);
+
+    if(!see_also || (br = strcmp(text,",\n")))
+    {
+        if(see_also < 2)
+        {
+           put_string(text);
+           column += strlen(text);
+        }
+    } else if(!br)
+    {
+        column += 2;
+        put_string(", ");
+    }
+}
+
+void autodoc_char(c)
+const int c;
+{
+    if(c != '\f')
+    {
+       autodoc_format(NULL);
+
+       if(c == '\t')
+       {
+          int i = tablength - (column % tablength);
+          column += i;
+          for(; i ; i--)
+             putchar(' ');
+       } else
+       {
+          if(see_also)
+          {
+             if(c == '(')
+                 see_also++;
+             else if(c == ')')
+                 see_also--;
+          }
+
+          putchar(c);
+          column++;
+       }
+
+       if((newline = (c == '\n')))
+           column = 0;
+   }
+}
+
+void autodoc_comment() { }
+
+void autodoc_header(firstpage, input_files, grouped, name, terse, section)
+ManualPage *firstpage;
+int input_files;
+boolean grouped;
+const char *name;
+const char *terse;
+const char *section;
+{
+    const char *basename = strrchr(firstpage->sourcefile, '/');
+    int len;
+    int spc;
+
+    fileend = FALSE;
+
+    if(basename && *basename == '/')
+        basename++;
+
+    len =  ((basename) ? strlen(basename) + 1 : 0) + strlen(name);
+    spc  = linelength - 2 * len;
+
+    see_also = FALSE;
+
+    if(basename)
+    {
+       autodoc_text(basename);
+       autodoc_char('/');
+    }
+    autodoc_text(name);
+
+    if(spc > 0)
+    {
+      while(spc)
+      {
+         autodoc_char(' ');
+         spc--;
+      }
+       if(basename)
+       {
+          autodoc_text(basename);
+          autodoc_char('/');
+       }
+       autodoc_text(name);
+    } else
+    {
+       const char *ptr = name;
+       len = linelength - 1 - len;
+
+       while(len)
+       {
+          if(basename && *basename)
+          {
+             autodoc_char(*basename);
+             basename++;
+          } else
+          {
+             if(ptr == name && basename)
+                autodoc_char('/');
+             else
+             {
+                autodoc_char(*ptr);
+                ptr++;
+             }
+          }
+          len--;
+       }
+    }
+
+    put_string("\n");
+}
+
+void autodoc_dash()       { put_string("-"); }
+
+void autodoc_section(name)
+const char *name;
+{
+    D((fprintf(stderr,"section : %s\n",name)));
+    newline = FALSE;
+    see_also = FALSE;
+    put_string("\n");
+    if(!strcmp(name,"DESCRIPTION"))
+       name = "FUNCTION";
+    else if(!strcmp(name,"PARAMETERS"))
+       name = "INPUTS";
+    else if(!strcmp(name,"RETURNS"))
+       name = "RESULT";
+    else if(!strcmp(name,"SEE ALSO"))
+       see_also = TRUE;
+
+    put_string("    ");
+    autodoc_text(name);
+    indent = 8;
+    list_indent = 0;
+    autodoc_char('\n');
+}
+
+void autodoc_sub_section(name)
+const char *name;
+{
+    autodoc_text(name);
+    indent = 12;
+}
+
+void autodoc_break_line()
+{
+   breakline = TRUE;
+}
+
+void autodoc_blank_line()
+{
+    autodoc_char('\n');
+}
+
+void autodoc_code_start() {  }
+void autodoc_code_end()   {  }
+
+void autodoc_code(text)
+const char *text;
+{
+    autodoc_text(text);
+}
+
+void autodoc_tag_entry_start()
+{
+    if(list_indent > 0)
+    {
+        autodoc_char('\n');
+        list_indent -= indentlength;
+    }
+}
+void autodoc_tag_entry_start_extra()
+{
+    if(list_indent > 0)
+    {
+        autodoc_char('\n');
+        list_indent -= indentlength;
+    }
+}
+void autodoc_tag_entry_end()
+{
+   list_indent += indentlength;
+   autodoc_char('\n');
+}
+void autodoc_tag_entry_end_extra(text)
+const char *text;
+{
+    put_string("\" \"\t(");
+    autodoc_text(text);
+    put_string(")\"\n");
+    list_indent += indentlength;
+}
+        
+void autodoc_table_start(longestag)
+const char *longestag;
+{
+   if(acttable < MAX_TAG - 1)
+   {
+      acttable++;
+      tablemaxtag[acttable] = strlen(longestag);
+   }
+
+   indent += indentlength;
+   newline = TRUE;
+}
+
+void autodoc_table_entry(name, description)
+const char *name;
+const char *description;
+{
+    int i = tablemaxtag[acttable] - strlen(name) + 1;
+
+    autodoc_code(name);
+    while(i > 0)
+    {
+       putchar(' ');
+       i--;
+    }
+    putchar('-');
+    putchar(' ');
+
+    if (description)
+        output_comment(description);
+    else
+        autodoc_char('\n');
+}
+
+void autodoc_table_end()
+{
+    if(acttable > -1)
+      acttable--;
+
+    autodoc_char('\n');
+    indent -= indentlength;
+    if(list_indent > 0)
+       list_indent -= indentlength;
+}
+
+void autodoc_indent()
+{
+    int i;
+    for(i = indent + list_indent; i ; i--)
+       autodoc_char(' ');
+}
+
+void autodoc_list_start()
+{
+   indent += indentlength;
+   newline = TRUE;
+}
+
+void autodoc_list_entry(name)
+const char *name;
+{
+    autodoc_code(name);
+}
+
+void autodoc_list_separator() { put_string(" ,"); }
+void autodoc_list_end()   { autodoc_char('\n'); autodoc_table_end(); }
+
+void autodoc_include(filename)
+const char *filename;
+{
+
+}
+
+void autodoc_terse_sep()
+{
+    autodoc_char(' ');
+    autodoc_dash();
+    autodoc_char(' ');
+}
+
+void autodoc_name(name)
+const char *name;
+{
+   if(name)
+      autodoc_text(name);
+   else
+      autodoc_section("NAME");
+}
+
+void autodoc_file_end()
+{
+   if(!fileend)
+      putchar('\f');
+   fileend = TRUE;
+   newline = FALSE;
+}
+
+/* ideally, this should be made aware of embedded autodoc commands */
+void autodoc_description(text)
+const char *text;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    boolean new_line = TRUE;
+    
+    /* correct punctuation a bit as it goes out */
+    for (;*text;text++)
+    {
+	int c = *text;
+
+	if (new_line && (c == '-' || c == '*'))
+	{
+	    output->break_line();
+	    state = CAPITALISE;
+	}
+	else if (c == '.')
+	    state = PERIOD;
+	else if (isspace(c) && state == PERIOD)
+	    state = CAPITALISE;
+	else if (isalnum(c))
+	{   
+	    if (islower(c) && state == CAPITALISE)	c = toupper(c);
+	    state = TEXT;
+	}
+           
+	output->character(c);
+	new_line = c == '\n';
+    }
+
+    /* do a full stop if there wasn't one */
+    if (state == TEXT)	output->character('.');
+}
+
+/* ideally, this should be made aware of embedded autodoc commands */
+void
+autodoc_returns(comment)
+const char *comment;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    char lastchar = '\n';
+    boolean tag_list_started = FALSE;
+
+    /* for each line... */
+    while (*comment)
+    {
+	boolean tagged = FALSE;
+
+	{
+	    const char *c = comment;
+
+	    /* search along until the end of a word */
+	    while (*c && *c != ':' && !isspace(*c))
+		c++;
+
+	    /* skip all spaces or tabs after the first word */
+	    while (*c && *c != '\n')
+	    {
+		if (*c == '\t' || *c == ':')
+		{
+		    tagged = TRUE;
+		    break;
+		}
+		else if (!isspace(*c))
+		    break;
+
+		c++;
+	    }
+	}
+
+	/* is it tagged?; explicitly reject dot commands */
+	if (tagged)
+	{
+	    /* output lingering newline if necessary */
+	    if (lastchar != '\n')
+	    {
+		if (state == TEXT && !ispunct(lastchar))	output->character('.');
+		output->character(lastchar = '\n');
+	    }
+
+	    if (!tag_list_started)
+	    {
+		output->tag_list_start();
+		tag_list_started = TRUE;
+	    }
+
+	    /* output the taggy bit */
+	    output->tag_entry_start();
+	    while (*comment && *comment != ':' && !isspace(*comment))
+		output->character(*comment++);
+	    output->tag_entry_end();
+
+	    /* skip any extra tabs or spaces */
+	    while (*comment == ':' || (isspace(*comment) && *comment != '\n'))
+		comment++;
+
+	    state = CAPITALISE;
+	}
+
+	/* terminate the previous line if necessary */
+	if (lastchar != '\n')	output->character(lastchar = '\n');
+
+	/* correct punctuation a bit as the line goes out */
+	for (;*comment && *comment != '\n'; comment++)
+	{
+	    char c = *comment;
+
+	    if (c == '.')
+		state = PERIOD;
+	    else if (isspace(c) && state == PERIOD)
+		state = CAPITALISE;
+	    else if (isalnum(c))
+	    {   
+		if (islower(c) && state == CAPITALISE && fixup_comments)
+		    c = toupper(c);
+		state = TEXT;
+	    }
+
+	    output->character(lastchar = c);
+	}
+
+	/* if it ended in punctuation, just output the nl straight away. */
+	if (ispunct(lastchar))
+	{
+	    if (lastchar == '.')	state = CAPITALISE;
+	    output->character(lastchar = '\n');
+	}
+
+	if (*comment)	comment++;
+    }
+
+    /* output lingering newline if necessary */
+    if (lastchar != '\n')
+    {
+	if (state == TEXT && !ispunct(lastchar) && fixup_comments)
+	    output->character('.');
+	output->character('\n');
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+
+struct Output autodoc_output =
+{
+    autodoc_comment,
+    autodoc_header,
+    autodoc_dash,
+    autodoc_section,
+    autodoc_sub_section,
+    autodoc_break_line,
+    autodoc_blank_line,
+    autodoc_code_start,
+    autodoc_code_end,
+    autodoc_code,
+    dummy,              /* autodoc_tag_list_start */
+    dummy,              /* autodoc_tag_list_end */
+    autodoc_tag_entry_start,
+    autodoc_tag_entry_start_extra,
+    autodoc_tag_entry_end,
+    autodoc_tag_entry_end_extra,
+    autodoc_table_start,
+    autodoc_table_entry,
+    autodoc_table_end,
+    autodoc_indent,
+    autodoc_list_start,
+    autodoc_code,         /* autodoc_list_entry */
+    autodoc_list_separator,
+    autodoc_list_end,
+    autodoc_include,
+    autodoc_file_end,      /* autodoc_file_end */
+    autodoc_text,
+    autodoc_char,
+    NULL,                  /* autodoc_parse_option */
+    dummy,                 /* autodoc_print_options */
+    autodoc_name,
+    autodoc_terse_sep,
+    autodoc_text,          /* autodoc_reference */
+    autodoc_text,          /* autodoc_emphasized */
+    autodoc_description,
+    autodoc_returns
+};
+
diff --git a/c2man.c b/c2man.c
new file mode 100644
index 0000000..0250d11
--- /dev/null
+++ b/c2man.c
@@ -0,0 +1,928 @@
+/* $Id: c2man.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * C Manual page generator.
+ * Reads C source code and outputs manual pages.
+ */
+#include <ctype.h>
+#include <errno.h>
+
+#include "c2man.h"
+#include "enum.h"
+#include "strconcat.h"
+#include "strappend.h"
+#include "manpage.h"
+#include "output.h"
+#include "patchlevel.h"
+
+#ifdef I_FCNTL
+#include <fcntl.h>
+#endif
+
+#ifdef I_SYS_FILE
+#include <sys/file.h>
+#endif
+
+#include <sys/stat.h>
+#include <signal.h>
+
+/* getopt declarations */
+extern int getopt();
+extern char *optarg;
+extern int optind;
+
+/* lex declarations */
+extern FILE *yyin;	/* lex input stream */
+
+/* Name of the program */
+const char *progname = "c2man";
+
+/* Program options */
+
+/* TRUE if static declarations are also output. */
+boolean static_out = FALSE;
+
+/* TRUE if variable declarations are output. */
+boolean variables_out = FALSE;
+
+/* TRUE if formal parameter promotion is enabled. */
+boolean promote_param = TRUE;
+
+/* String output before prototype declaration specifiers */
+const char *decl_spec_prefix = "";
+
+/* String output before prototype declarator */
+const char *declarator_prefix = " ";
+
+/* String output after prototype declarator */
+const char *declarator_suffix = "\n";
+
+/* String output before the first parameter in a function prototype */
+const char *first_param_prefix = "\n\t";
+
+/* String output before each subsequent parameter in a function prototype */
+const char *middle_param_prefix = "\n\t";
+
+/* String output after the last parameter in a function prototype */
+const char *last_param_suffix = "\n";
+
+/* Directory to write output files in */
+char *output_dir = NULL;
+
+/* Name of the manual */
+char *manual_name = NULL;
+
+/* Section for manual page */
+const char *manual_section = NULL;
+
+/* prefix for generated #include lines */
+char *header_prefix = NULL;
+
+/* list of include file specified by user */
+IncludeFile *first_include;
+static IncludeFile **last_next_include = &first_include;
+
+/* list of excluded sections specified by user */
+ExcludeSection *first_excluded_section;
+static ExcludeSection **last_next_excluded_section = &first_excluded_section;
+
+/* TRUE if c2man should attempt to fixup comment sections */
+boolean fixup_comments = TRUE;
+
+/* do we group related stuff into one file? */
+boolean group_together;
+
+/* was terse description read from file or command line option? */
+boolean terse_specified;
+
+/* terse description when grouped together */
+char *group_terse = NULL;
+
+/* should we always document parameters, even if it's only "Not Documented" */
+boolean always_document_params = TRUE;
+
+/* look for a function def comment at the start of the function body */
+boolean look_at_body_start = FALSE;
+
+/* only look for a function def comment at the start of the function body */
+boolean body_start_only = FALSE;
+
+/* default output info for each object type */
+struct Output_Object_Info output_object[_OBJECT_NUM] =
+{
+#if 0
+    {'c', "class"},
+    {'s', "struct"},
+    {'e', "enum"},
+    {'t', "typedef"},
+#endif
+    {'f', "function"},
+    {'v', "variable"},
+    {'F', "static function"},
+    {'V', "static variable"}
+};
+
+/* Include file directories */
+#ifdef MSDOS
+int num_inc_dir = 1;
+const char *inc_dir[MAX_INC_DIR] = { ".\\" };
+#else
+#ifdef AMIGA
+int num_inc_dir = 1;
+const char *inc_dir[MAX_INC_DIR] = { "include:" };
+#else
+int num_inc_dir = 2;
+const char *inc_dir[MAX_INC_DIR] = { "./", "/usr/include/" };
+#endif
+#endif
+
+/* total number of errors encountered */
+int errors;
+
+/* name of the base file being processed; NULL = stdin */
+const char *basefile;
+Time_t basetime;	/* modification time of base file */
+boolean inbasefile;	/* are we parsing in that base file? */
+
+/* is the base file a header file? */
+boolean header_file;
+
+#ifdef AMIGA
+struct Output *output = &autodoc_output;
+const char *default_section = "doc";
+#else
+/* use nroff output by default */
+struct Output *output = &nroff_output;
+const char *default_section = "3";
+#endif
+
+/* should we generate the output file named after the input file? */
+boolean use_input_name = FALSE;
+
+/* should we generate embeddable files? */
+boolean make_embeddable = FALSE;
+
+#define USE_CPP
+#ifdef USE_CPP
+const char *cpp_cmd = CPP_FILE_COM;
+#if defined(MSDOS)
+#include "popen.h"
+#define popen(c,m)	os_popen(c,m)
+#define pclose(f)	os_pclose(f)
+#else
+#if defined (_MSC_VER)
+#define popen(c,m)	_popen(c,m)
+#define pclose(f)	_pclose(f)
+#endif
+#endif
+#endif
+
+boolean verbose = FALSE;
+
+/* can cpp read standard input? */
+static boolean cppcanstdin
+#ifdef CPP_CAN_STDIN
+			    = 1
+#endif
+;
+/* does cpp ignore header files */
+static boolean cppignhdrs
+#ifdef CPP_IGN_HDRS
+			    = 1
+#endif
+;
+
+/* nifty little function for handling I/O errors */
+void my_perror(action, filename)
+const char *action, *filename;
+{
+    int err = errno;
+    fprintf(stderr,"%s: %s ", progname, action);
+    errno = err;
+    perror(filename);
+}
+
+/* write the #include lines as specified by the user */
+void print_includes(f)
+FILE *f;
+{
+    IncludeFile *incfile;
+    
+    for (incfile = first_include; incfile; incfile=incfile->next)
+    {
+	char *name = incfile->name;
+	boolean surrounded = *name == '"' || *name == '<';
+	
+	fputs("#include ", f);
+	if (!surrounded)	fputc('<',f);
+	fputs(name, f);
+	if (!surrounded)	fputc('>',f);
+	fputc('\n',f);
+    }
+}
+
+void outmem()
+{
+    fprintf(stderr,"%s: Out of memory!\n", progname);
+    exit(1);
+}
+
+#ifndef DBMALLOC
+void *safe_malloc(size)
+size_t size;
+{
+    void *mem;
+
+    if ((mem = (void *)malloc(size)) == NULL)
+	outmem();
+
+    return mem;
+}
+#endif
+
+/* Replace any character escape sequences in a string with the actual
+ * characters.  Return a pointer to malloc'ed memory containing the result.
+ * This function knows only a few escape sequences.
+ */
+static char *
+escape_string (src)
+char *src;
+{
+    char *result, *get, *put;
+
+    result = strduplicate(src);
+    put = result;
+    get = src;
+    while (*get != '\0') {
+	if (*get == '\\') {
+	    switch (*(++get)) {
+	    case 'n':
+		*put++ = '\n';
+		++get;
+		break;
+	    case 't':
+		*put++ = '\t';
+		++get;
+		break;
+	    default:
+		if (*get != '\0')
+		    *put++ = *get++;
+	    }
+	} else {
+	    *put++ = *get++;
+	}
+    }
+    *put = *get;
+    return result;
+}
+
+/* Output usage message and exit.
+ */
+static void
+usage ()
+{
+    int i;
+
+    fprintf(stderr, "usage: %s [ option ... ] [ file ... ]\n", progname);
+    fputs(" -o directory\twrite output files in directory\n",stderr);
+    fputs(" -p\t\tdisable prototype promotion\n", stderr);
+    fputs(" -s\t\toutput static declarations\n", stderr);
+    fputs(" -v\t\toutput variable declarations\n", stderr);
+    fputs(" -k\t\tdon't attempt to fixup comments\n", stderr);
+    fputs(" -b\t\tlook for descriptions at top of function bodies\n", stderr);
+    fputs(" -B\t\tonly look for descriptions by applying -b\n", stderr);
+    fputc('\n', stderr);
+    fputs(" -i incfile\n", stderr);
+    fputs(" -i \"incfile\"\n", stderr);
+    fputs(" -i <incfile>\tadd #include for incfile to SYNOPSIS\n",
+								    stderr);
+    fputc('\n', stderr);
+    fputs(" -H prefix\tspecify prefix for #include in SYNOPSIS\n", stderr);
+    fputc('\n', stderr);
+    fputs(" -g\n", stderr);
+    fputs(" -G terse\tgroup info from each file into a single page\n",
+								    stderr);
+    fputs(" -e\t\tmake embeddable files\n", stderr);
+    fputc('\n', stderr);
+    fputs(" -l ", stderr);
+#ifdef HAS_LINK
+    fputs("h|", stderr);
+#endif
+#ifdef HAS_SYMLINK
+    fputs("s|", stderr);
+#endif
+    fputs("f|n|r\t", stderr);
+    fputs("linking for grouped pages: ", stderr);
+#ifdef HAS_LINK
+                  fputs("hard, ", stderr);
+#endif
+#ifdef HAS_SYMLINK
+					fputs("soft, ", stderr);
+#endif
+					fputs("file, none or remove\n", stderr);
+    fputs(" -n\t\tName output file after input source file\n", stderr);
+    fputs(" -L\t\tLazy: Be silent about undocumented parameters\n",
+                                                                    stderr);
+
+    fputs(" -T n|l|h|t|a[,options]\tselect typesetting output format: nroff, LaTeX, HTML ,TeXinfo or AutoDoc\n",
+                                                                    stderr);
+    nroff_output.print_options();
+    latex_output.print_options();
+    html_output.print_options();
+    texinfo_output.print_options();
+    autodoc_output.print_options();
+
+    fputs(" -M name\tset name of the manual in which the page goes\n",
+								    stderr);
+    fputs(" -x section\texclude section from ouput\n", stderr);
+    fputc('\n', stderr);
+    fputs(" -D name[=value]\n", stderr);
+    fputs(" -U name\n", stderr);
+    fputs(" -I directory\tC preprocessor options\n", stderr);
+    fputc('\n', stderr);
+    fputs(" -F template\tset prototype template in the form ", stderr);
+				    fputs("\"int f (a, b)\"\n",stderr);
+    fputs(" -P preprocessor\tAlternate C preprocessor ", stderr);
+				    fputs("(e.g., \"gcc -E -C\")\n", stderr);
+    fputs(" -V\t\tbe verbose and print version information\n", stderr);
+    fputs(" -S section\tset the section for the manual page (default = 3)\n",
+								    stderr);
+    fputs(" -O ", stderr);
+    for (i = 0; i < _OBJECT_NUM; i++)
+	fputc(output_object[i].flag, stderr);
+    fputs("[subdir][.ext]", stderr);
+    fputs("\tOutput control over different object types:\n\t\t", stderr);
+    for (i = 0; i < _OBJECT_NUM; i++)
+    {
+	fputs(output_object[i].name, stderr);
+	if (i <= _OBJECT_NUM - 2)
+	    fprintf(stderr,i == _OBJECT_NUM-2 ? " or " : ", ");
+    }
+    fputs(".\n", stderr);
+    exit(1);
+}
+
+/* name of the temporary file; kept here so we can blast it if hit with ctrl-C
+ */
+static char temp_name[20];
+Signal_t (*old_interrupt_handler)();
+
+/* ctrl-C signal handler for use when we have a temporary file */
+static Signal_t interrupt_handler(sig)
+int sig;
+{
+    unlink(temp_name);
+    exit(128 + sig);
+}
+
+/* open a unique temporary file.
+ * To be universally accepted by cpp's, the file's name must end in .c; so we
+ * can't use mktemp, tmpnam or tmpfile.
+ * returns an open stream & sets ret_name to the name.
+ */
+FILE *open_temp_file()
+{
+    int fd;
+    long n = getpid();
+    FILE *tempf;
+    boolean remove_temp_file();
+
+    /* keep generating new names until we hit one that does not exist */
+    do
+    {
+	/* ideally we'd like to put the temporary file in /tmp, but it must go
+	 * in the current directory because when cpp processes a #include, it
+	 * looks in the same directory as the file doing the include; so if we
+	 * use /tmp/blah.c to fake reading fred.h via `#include "fred.h"', cpp
+	 * will look for /tmp/fred.h, and fail.
+	 */
+	sprintf(temp_name,"c2man%ld.c",n++ % 1000000);
+    }
+    while((fd =
+#ifdef HAS_OPEN3
+	open(temp_name,O_WRONLY|O_CREAT|O_EXCL,0666)
+#else
+	creat(temp_name,O_EXCL|0666)		/* do it the old way */
+#endif
+						) == -1
+							&& errno == EEXIST);
+
+    /* install interrupt handler to remove the temporary file */
+    old_interrupt_handler = signal(SIGINT, interrupt_handler);
+
+    /* convert it to a stream */
+    if ((fd == -1 && errno != EEXIST) || (tempf = fdopen(fd, "w")) == NULL)
+    {
+	my_perror("error fdopening temp file",temp_name);
+	remove_temp_file();
+	return NULL;
+    }
+
+    return tempf;
+}
+
+/* remove the temporary file & restore ctrl-C handler.
+ * returns FALSE in the event of failure.
+ */
+boolean remove_temp_file()
+{
+    int ok = unlink(temp_name) == 0;    /* this should always succeed */
+    signal(SIGINT, old_interrupt_handler);
+    return ok;
+}
+
+/* process the specified source file through the pre-processor.
+ * This is a lower level routine called by both process_stdin and process_file
+ * to actually get the work done once any required temporary files have been
+ * generated.
+ */
+int process_file_directly(base_cpp_cmd, name)
+const char *base_cpp_cmd;
+const char *name;
+{
+    char *full_cpp_cmd;
+
+#ifdef DEBUG
+    fprintf(stderr,"process_file_directly: %s, %s\n", base_cpp_cmd, name);
+#endif
+
+#ifdef USE_CPP
+    full_cpp_cmd = strconcat(base_cpp_cmd, " ", name, NULLCP);
+    if (verbose)
+	fprintf(stderr,"%s: running `%s'\n", progname, full_cpp_cmd);
+
+    if ((yyin = popen(full_cpp_cmd, "r")) == NULL) {
+	my_perror("error running", base_cpp_cmd);
+	free(full_cpp_cmd);
+	return 0;
+    }
+#else
+    if (verbose)	fprintf(stderr,"%s: reading %s\n", progname, name);
+    if (name && freopen(name, "r", yyin) == NULL)
+    {
+	my_perror("cannot open", name);
+	return 0;
+    }
+#endif
+
+    parse_file(name);
+
+#ifdef USE_CPP
+    free(full_cpp_cmd);
+    if (pclose(yyin) & 0xFF00)
+	return 0;
+#else
+    if (fclose(yyin))
+    {
+	my_perror("error closing", name);
+	return 0;
+    }
+#endif
+
+    return !errors;
+}
+
+/* process a specified file */
+int process_file(base_cpp_cmd, name)
+const char *base_cpp_cmd;
+const char *name;
+{
+    char *period;
+    struct stat statbuf;
+    
+#ifdef DEBUG
+    fprintf(stderr,"process_file: %s, %s\n", base_cpp_cmd, name);
+#endif
+    basefile = name;
+    header_file = (period = strrchr(name,'.')) &&
+					(period[1] == 'h' || period[1] == 'H');
+
+    /* use the file's date as the date in the manual page */
+    if (stat(name,&statbuf) != 0)
+    {
+	my_perror("can't stat", name);
+	return 0;
+    }
+    basetime = statbuf.st_mtime;
+
+    /* should we do this via a temporary file?
+     * Only if it's a header file and either CPP ignores them, or the user
+     * has specified files to include.
+     *
+     * For HP/Apollo (SR10.3, CC 6.8), we must always use a temporary file,
+     * because its compiler recognizes the special macro "__attribute(p)",
+     * which we cannot redefine in the command line because it has parameters.
+     */
+#ifndef apollo
+    if (header_file && (cppignhdrs || first_include))
+#endif
+    {
+	FILE *tempf;
+	int ret;
+
+	if (verbose)
+	    fprintf(stderr, "%s: preprocessing via temporary file\n", progname);
+
+	if ((tempf = open_temp_file()) == NULL)
+	    return 0;
+
+	print_includes(tempf);
+	if (verbose)	print_includes(stderr);
+
+#ifdef apollo
+	fprintf(tempf,"#define __attribute(p)\n", basefile);
+#endif
+	fprintf(tempf,"#include \"%s\"\n", basefile);
+	if (verbose)	fprintf(stderr,"#include \"%s\"\n", basefile);
+
+	if (fclose(tempf) == EOF)
+	{
+	    my_perror("error closing temp file", temp_name);
+	    remove_temp_file();
+	    return 0;
+	}
+
+	/* since we're using a temporary file, it's not the base file */
+	inbasefile = 0;
+	ret = process_file_directly(base_cpp_cmd, temp_name);
+	remove_temp_file();
+	return ret;
+    }
+
+    /* otherwise, process it directly */
+    inbasefile = 1;
+
+    return process_file_directly(base_cpp_cmd,name);
+}
+
+/* process the thing on the standard input */
+int process_stdin(base_cpp_cmd)
+const char *base_cpp_cmd;
+{
+    if (isatty(fileno(stdin)))
+	fprintf(stderr,"%s: reading standard input\n", progname);
+
+    header_file = 0;	/* assume it's not since it's from stdin */
+    basefile = NULL;
+
+    /* use the current date in the man page */
+    basetime = time((Time_t *)NULL);
+
+    inbasefile = 1;		/* reading stdin, we start in the base file */
+
+    /* always use a temp file if the preprocessor can't read stdin, otherwise
+     * only use one if the user specified files for inclusion.
+     */
+    if (!cppcanstdin || first_include)	/* did user specify include files? */
+    {
+    	FILE *tempf;
+	int c, ret;
+
+	if (verbose)
+	    fprintf(stderr,"%s: reading stdin to a temporary file\n", progname);
+
+	if ((tempf = open_temp_file()) == NULL)
+	    return 0;
+
+	print_includes(tempf);
+	if (verbose)	print_includes(stderr);
+	fprintf(tempf,"#line 1 \"stdin\"\n");
+
+	while ((c = getchar()) != EOF)
+	    putc(c,tempf);
+
+	if (fclose(tempf) == EOF)
+	{
+	    my_perror("error closing temp file", temp_name);
+	    remove_temp_file();
+	    return 0;
+	}
+	ret = process_file_directly(base_cpp_cmd, temp_name);
+	remove_temp_file();
+	return ret;
+    }
+    else
+    {
+	char *full_cpp_cmd = strconcat(base_cpp_cmd," ", CPP_STDIN_FLAGS,
+								   NULLCP);
+    
+	if (verbose)
+	    fprintf(stderr,"%s: running `%s'\n", progname, full_cpp_cmd);
+    
+	if ((yyin = popen(full_cpp_cmd, "r")) == NULL) {
+	    my_perror("error running", full_cpp_cmd);
+	    return 0;
+	}
+    
+	parse_file(basefile);
+    
+	free(full_cpp_cmd);
+	if (pclose(yyin) & 0xFF00)
+	    return 0;
+    
+	return !errors;
+    }
+}
+
+int
+main (argc, argv)
+int argc;
+char **argv;
+{
+    int i, c, ok = 0;
+    char *s, cbuf[2];
+    const char *base_cpp_cmd;
+    IncludeFile *includefile;
+    ExcludeSection *excludesection;
+    char *cpp_opts;
+#ifdef HAS_LINK
+    enum LinkType link_type = LINK_HARD;	/* for -g/G */
+#else
+    enum LinkType link_type = LINK_FILE;
+#endif
+
+#ifdef YYDEBUG
+    extern int yydebug;
+#endif
+
+    /* initialise CPP options with -D__C2MAN__ */
+    cbuf[0] = VERSION + '0';
+    cbuf[1] = '\0';
+#ifdef VMS
+    cpp_opts = strconcat("-\"D__C2MAN__=", cbuf, "\"",NULLCP);
+#else
+    cpp_opts = strconcat("-D__C2MAN__=", cbuf, NULLCP);
+#ifdef NeXT
+    cpp_opts = strappend(cpp_opts, " -D_NEXT_SOURCE", NULLCP);
+#endif /* !NeXT */
+#endif /* !VMS  */
+
+    /* Scan command line options. */
+    while ((c = getopt(argc, argv, "P:D:F:I:psU:Vvo:eM:H:G:gi:x:S:l:LT:nO:kbB"))
+								    != EOF)
+    {
+	switch (c) {
+	case 'I':
+	case 'D':
+	case 'U':
+	    cbuf[0] = c; cbuf[1] = '\0';
+	    if (cpp_opts)
+		cpp_opts = strappend(cpp_opts," -",cbuf,optarg,NULLCP);
+	    else
+		cpp_opts = strconcat("-",cbuf,optarg,NULLCP);
+	    break;
+	case 'P':
+	    cpp_cmd = optarg;
+
+	    /* with no better info to go on, we have to assume that this
+	     * preprocessor is minimally capable.
+	     */
+	    cppcanstdin = 0;
+	    cppignhdrs = 1;
+	    break;
+	case 'G':
+	    group_terse = optarg;
+	    terse_specified = TRUE;
+	    /* FALLTHROUGH */
+	case 'g':
+	    group_together = TRUE;
+	    break;
+	case 'F':
+	    s = escape_string(optarg);
+
+	    decl_spec_prefix = s;
+	    while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+	    *s++ = '\0';
+	    while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+
+	    declarator_prefix = s;
+	    while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+	    *s++ = '\0';
+	    while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+
+	    declarator_suffix = s;
+	    while (*s != '\0' && *s != '(') ++s;
+	    if (*s == '\0') usage();
+	    *s++ = '\0';
+
+	    first_param_prefix = s;
+	    while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+	    *s++ = '\0';
+	    while (*s != '\0' && *s != ',') ++s;
+	    if (*s == '\0') usage();
+
+	    middle_param_prefix = ++s;
+	    while (*s != '\0' && isascii(*s) && !isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+	    *s++ = '\0';
+	    while (*s != '\0' && isascii(*s) && isalnum(*s)) ++s;
+	    if (*s == '\0') usage();
+
+	    last_param_suffix = s;
+	    while (*s != '\0' && *s != ')') ++s;
+	    *s = '\0';
+
+	    break;
+	case 'p':
+	    promote_param = FALSE;
+	    break;
+	case 's':
+	    static_out = TRUE;
+	    break;
+	case 'V':
+	    verbose = TRUE;
+	    fprintf(stderr, "%s: Version %d, Patchlevel %d\n",
+					progname, VERSION, PATCHLEVEL);
+	    break;
+	case 'v':
+	    variables_out = TRUE;
+	    break;
+	case 'k':
+	    fixup_comments = FALSE;
+	    break;
+	case 'o':
+	    output_dir = optarg;
+	    break;
+	case 'M':
+	    manual_name = optarg;
+	    break;
+	case 'H':
+	    header_prefix = optarg;
+	    break;
+	case 'i':
+	    *last_next_include = includefile =
+			    (IncludeFile *)safe_malloc(sizeof *includefile);
+	    includefile->name = optarg;
+	    includefile->next = NULL;
+	    last_next_include = &includefile->next;
+	    break;
+	case 'x':
+	    *last_next_excluded_section = excludesection =
+			    (ExcludeSection *)safe_malloc(sizeof *excludesection);
+	    excludesection->name = optarg;
+	    excludesection->next = NULL;
+	    last_next_excluded_section = &excludesection->next;
+	    break;
+	case 'S':
+	    manual_section = optarg;
+	    break;
+	case 'l':
+	    switch(optarg[0])
+	    {
+#ifdef HAS_LINK
+	    case 'h':	link_type = LINK_HARD;	break;
+#endif
+#ifdef HAS_SYMLINK
+	    case 's':	link_type = LINK_SOFT;	break;
+#endif
+	    case 'f':	link_type = LINK_FILE;	break;
+	    case 'n':	link_type = LINK_NONE;	break;
+	    case 'r':	link_type = LINK_REMOVE;break;
+	    default:	usage();
+	    }
+	    break;
+	case 'e':
+	    make_embeddable = TRUE;
+	    break;
+	case 'n':
+	    use_input_name = TRUE;
+	    break;
+	case 'L':
+	    always_document_params = FALSE;
+	    break;
+	case 'T':
+	    switch(optarg[0])
+	    {
+	    case 'n':	output = &nroff_output;	default_section = "3";
+			break;
+	    case 'l':	output = &latex_output;	default_section = "tex";
+			break;
+	    case 't':	output = &texinfo_output; default_section = "texi";
+			break;
+	    case 'h':	output = &html_output; default_section = "html";
+			break;
+            case 'a':   output = &autodoc_output; default_section = "doc";
+                        break;
+	    default:	usage();
+	    }
+	    s = strtok(&optarg[1], ",");
+	    if (s && *output->parse_option == NULL) usage();
+	    while(s)
+	    {
+	      if (output->parse_option(s)) usage();
+	      s = strtok(NULL, ",");
+	    }
+	    break;
+	case 'O':
+	    for (i = 0; i < _OBJECT_NUM; i++)
+		if (output_object[i].flag == optarg[0])
+		    break;
+
+	    if (i == _OBJECT_NUM)
+	    {
+		fprintf(stderr,"%s: -O option must specify one of:\n\t",
+								progname);
+		for (i = 0; i < _OBJECT_NUM; i++)
+		{
+		    fprintf(stderr,"%c (%s)", output_object[i].flag,
+			output_object[i].name);
+		    if (i <= _OBJECT_NUM - 2)
+			fprintf(stderr,i == _OBJECT_NUM-2 ? " or " : ", ");
+		}
+		fprintf(stderr, ".\n");
+		exit(1);
+	    }
+
+	    if ((s = strchr(++optarg,'.')))	/* look for an extension */
+	    {
+		output_object[i].subdir = alloc_string(optarg, s);
+		output_object[i].extension = strduplicate(s+1);
+	    }
+	    else
+		output_object[i].subdir = strduplicate(optarg);
+
+	    break;
+	case 'b':
+            look_at_body_start = TRUE;
+            break;
+	case 'B':
+	    body_start_only = TRUE;
+            look_at_body_start = TRUE;
+            break;
+	case '?':
+	default:
+	    usage();
+	}
+    }
+
+    /* make sure we have a manual section */
+    if (manual_section == NULL)	manual_section = default_section;
+
+#ifdef MALLOC_DEBUG
+    getchar();	/* wait so we can start up NeXT MallocDebug tool */
+#endif
+#ifdef YYDEBUG
+    yydebug = 1;
+#endif
+
+    if (cpp_opts)
+    {
+	base_cpp_cmd = strconcat(cpp_cmd, " ", cpp_opts, NULLCP);
+	free(cpp_opts);
+    }
+    else
+	base_cpp_cmd = cpp_cmd;
+
+    if (optind == argc) {
+	if (use_input_name)
+	{
+	    fprintf(stderr,"%s: %s\n", progname,
+		"cannot name output after input file if there isn't one!");
+	    usage();
+	}
+	ok = process_stdin(base_cpp_cmd);
+    }    
+    else
+	for (i = optind; i < argc; ++i)
+	    if (!(ok = process_file(base_cpp_cmd,argv[i])))	break;
+
+    if (ok && firstpage)
+	output_manual_pages(firstpage,argc - optind, link_type);
+    free_manual_pages(firstpage);
+    destroy_enum_lists();
+
+    if (cpp_opts)	free((char *)base_cpp_cmd);
+
+    for (includefile = first_include; includefile;)
+    {
+	IncludeFile *next = includefile->next;
+	free(includefile);
+	includefile = next;
+    }
+
+    for (excludesection = first_excluded_section; excludesection;)
+    {
+	ExcludeSection *next = excludesection->next;
+	free(excludesection);
+	excludesection = next;
+    }
+
+    for (i = 0; i < _OBJECT_NUM; i++)
+    {
+	safe_free(output_object[i].subdir);
+	safe_free(output_object[i].extension);
+    }
+
+#ifdef DBMALLOC
+    malloc_dump(2);
+    malloc_chain_check(1);
+#endif
+#ifdef MALLOC_DEBUG
+    sleep(1000000);
+#endif
+    return !ok;
+}
diff --git a/c2man.h b/c2man.h
new file mode 100644
index 0000000..d26ec71
--- /dev/null
+++ b/c2man.h
@@ -0,0 +1,284 @@
+/* $Id: c2man.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * Definitions for C language manual page generator
+ */
+#ifndef _C2MAN_H
+#define _C2MAN_H
+
+#include "config.h"
+#include "symbol.h"
+
+#ifdef I_SYS_TYPES
+#include <sys/types.h>
+#endif
+
+#ifdef I_STDLIB
+#include <stdlib.h>
+#endif
+
+#ifdef I_STRING
+#include <string.h>
+#else
+#include <strings.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef I_UNISTD
+#include <unistd.h>
+#endif
+
+#ifdef I_STDDEF
+#include <stddef.h>
+#endif
+
+#ifdef I_TIME
+#include <time.h>
+#endif
+#ifdef I_SYS_TIME
+#include <sys/time.h>
+#endif
+
+#ifdef NeXT
+#include <libc.h>
+#undef ECHO	/* lex generates ECHO */
+#endif
+
+#ifdef DBMALLOC
+#include </usr/local/debug_include/malloc.h>
+#endif
+
+#include "confmagic.h"
+
+/* number of spaces in a tab */
+#define NUM_TAB_SPACES 4
+
+/* maximum include file nesting */
+#define MAX_INC_DEPTH 15
+
+/* maximum number of include directories */
+#define MAX_INC_DIR 15
+
+/* maximum number of characters in a text buffer */
+#define MAX_TEXT_LENGTH	256
+
+/* Boolean type */
+typedef int boolean;
+#ifndef TRUE
+#define FALSE	0
+#define TRUE	1
+#endif
+
+/* NULL char *, useful for passing NULL to functions wanting a char * */
+#define NULLCP	((char *)0)
+
+/* This is a list of function parameters. */
+typedef struct _parameter_list {
+    struct _parameter	*first;	/* pointer to first parameter in list */
+    struct _parameter	*last;  /* pointer to last parameter in list */  
+} ParameterList;
+
+/* Declaration specifier flags */
+#define DS_NONE 	0	/* default */
+#define DS_EXTERN	1	/* contains "extern" specifier */
+#define DS_STATIC	2	/* contains "static" specifier */
+#define DS_CHAR 	4	/* contains "char" type specifier */
+#define DS_SHORT	8	/* contains "short" type specifier */
+#define DS_FLOAT	16	/* contains "float" type specifier */
+#define DS_JUNK 	32	/* we're not interested in this declaration */
+#define DS_INLINE	64	/* makes static look interesting */
+
+/* This structure stores information about a declaration specifier. */
+typedef struct _decl_spec {
+    unsigned short	flags;	/* flags defined above */
+    char		*text;	/* source text */
+    struct _enumerator_list *enum_list;	/* associated enum (if any) */
+} DeclSpec;
+
+/* Styles of declaration/definition */
+typedef enum {
+    DECL_SIMPLE,	/* simple declaration */
+    DECL_COMPOUND,	/* compound declaration */
+    DECL_FUNCTION,	/* function declaration (prototype) */
+    DECL_FUNCDEF	/* an actual function definition */
+} DeclType;
+
+/* This structure stores information about a declarator. */
+typedef struct _declarator {
+    char		*name;		/* name of variable or function */
+    char		*text;		/* source text */
+    DeclType		type;		/* style of function declaration */
+    ParameterList	params;		/* function parameters */
+    char 		*comment;	/* description of param or variable */
+    char 		*retcomment;	/* description of return value */
+    struct _declarator 	*head;		/* head function declarator */
+    struct _declarator 	*func_stack;	/* stack of function declarators */
+    struct _declarator	*next;		/* next declarator in list */
+} Declarator;
+
+/* This is a list of declarators. */
+typedef struct _declarator_list {
+    Declarator		*first;	/* pointer to first declarator in list */
+    Declarator		*last;  /* pointer to last declarator in list */  
+} DeclaratorList;
+
+/* This structure stores information about a declaration. */
+typedef struct _declaration {
+    DeclSpec		decl_spec;
+    DeclaratorList	decl_list;
+} Declaration;
+
+/* this structure store information about an enumerator */
+typedef struct _enumerator {
+    char *name;			/* name of enum entry */
+    char *comment;		/* description of entry */
+    char *group_comment;	/* general descr. for next few enums in list */
+    struct _enumerator *next;	/* next enumerator in list */
+} Enumerator;
+
+/* This is a list of enumerators. */
+typedef struct _enumerator_list {
+    Enumerator		*first;	/* pointer to first enumerator in list */
+    Enumerator		*last;  /* pointer to last enumerator in list */
+    struct _enumerator_list *next;	/* next list in a list-of-lists */
+} EnumeratorList;
+
+
+/* This structure stores information about a function parameter. */
+typedef struct _parameter {
+    DeclSpec		decl_spec;
+    Declarator		*declarator;
+    boolean		suppress;	/* don't print in grouped page */
+    boolean		duplicate;	/* mention fn in grouped page */
+    struct _parameter	*next;		/* next parameter in list */
+} Parameter;
+
+/* this is an identifier, with surrounding comments (if any) */
+typedef struct _identifier {
+    char *name;
+    char *comment_before, *comment_after;
+} Identifier;
+
+/* parser stack entry type */
+typedef union {
+    char		*text;
+    DeclSpec		decl_spec;
+    Parameter		parameter;
+    ParameterList	param_list;
+    Declarator		*declarator;
+    DeclaratorList	decl_list;
+    Declaration		declaration;
+    Enumerator		enumerator;
+    EnumeratorList	*enum_list;
+    Identifier		identifier;
+    boolean		boolean;
+} yystype;
+
+/* include files specified by user */
+typedef struct _includefile
+{
+    char *name;
+    struct _includefile *next;
+} IncludeFile;
+
+/* output object types */
+enum Output_Object
+{
+#if 0	/* C++ stuff */
+    OBJECT_CLASS,
+    OBJECT_STRUCT,
+    OBJECT_ENUM,
+    OBJECT_TYPEDEF,
+#endif
+    OBJECT_FUNCTION,
+    OBJECT_VARIABLE,
+    OBJECT_STATIC_FUNCTION,
+    OBJECT_STATIC_VARIABLE,
+    _OBJECT_NUM
+};
+
+struct Output_Object_Info
+{
+    char flag;		/* -O flag used to set it */
+    char *name;		/* descriptive name for usage() */
+    char *extension;	/* file extension */
+    char *subdir;	/* subdirectory */
+};
+
+/* list of sections to exclude */
+typedef struct ExcludeSection
+{
+  char *name;
+  struct ExcludeSection *next;
+} ExcludeSection;
+
+#define YYSTYPE yystype
+
+/* Program options */
+extern boolean static_out;
+extern boolean variables_out;
+extern boolean promote_param;
+extern boolean look_at_body_start;
+extern boolean body_start_only;
+extern const char *decl_spec_prefix, *declarator_prefix, *declarator_suffix;
+extern const char *first_param_prefix, *middle_param_prefix, *last_param_suffix;
+extern int num_inc_dir;
+extern const char *inc_dir[];
+extern char *manual_name;
+extern const char *progname;
+extern char *header_prefix;
+extern IncludeFile *first_include;
+extern ExcludeSection *first_excluded_section;
+
+extern boolean fixup_comments;
+
+extern char *group_terse;
+extern boolean group_together;
+extern boolean terse_specified;
+extern boolean always_document_params;
+
+extern char *output_dir;
+
+/* Global declarations */
+extern int line_num;
+extern const char *basefile;
+extern Time_t basetime;
+extern boolean inbasefile;
+extern boolean header_file;
+extern SymbolTable *typedef_names;
+extern void output_error();
+extern void parse_file _((const char *start_file));
+extern int errors;
+extern const char *manual_section;
+extern boolean use_input_name;
+extern boolean make_embeddable;
+extern struct Output_Object_Info output_object[_OBJECT_NUM];
+
+
+
+/* Output a string to standard output. */
+#define put_string(s)	fputs(s, stdout)
+
+/* a malloc that handles errors, and a free that handles NULL */
+#ifndef DBMALLOC
+void *safe_malloc _((size_t size));
+#else
+/* use macro so dbmalloc tells us where safe_malloc is called from */
+#define safe_malloc(s)	malloc(s)
+#endif
+#define safe_free(p)	do { if (p) free(p); p = NULL; } while(0)
+
+void outmem();
+void print_includes _((FILE *f));/* write #include lines */
+
+void yyerror _V((const char *fmt, ...));
+
+char *strduplicate _((const char *s));
+int strncmpi _((const char *s1, const char *s2, size_t n));
+char *strtoupper _((char *s));
+
+void my_perror _((const char *action, const char *filename));
+
+char *alloc_string _((const char *start, const char *end));
+
+#endif
diff --git a/c2man.man b/c2man.man
new file mode 100644
index 0000000..ad0d20e
--- /dev/null
+++ b/c2man.man
@@ -0,0 +1,906 @@
+.\" $Id: c2man.man,v 1.1 2004-05-03 05:17:49 behdad Exp $
+.de EX          \"Begin example
+.br
+.if \\$1 .ne \\$1
+.if !"\\$2"" \{
+.if n .sp 1
+.if t .sp .5
+\\$2
+\}
+.if n .sp 1
+.if t .sp .5
+.nf
+.cs R 24
+.vs \n(.vu-2p
+.in +.5i
+..
+.de EE		\"End example
+.br
+.vs \n(.vu+2p
+.cs R
+.fi
+.in -.5i
+.if n .sp 1
+.if t .sp .5
+..
+.de CS		\"Begin shell command
+.br
+.if n .sp 1
+.if t .sp .5
+.in +.5i
+%
+.ft B
+..
+.de CE		\"End shell command
+.br
+.ft R
+.in -.5i
+.if n .sp 1
+.if t .sp .5
+..
+.de CD		\"Shell command
+.CS
+\\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9
+.CE
+..
+.\"	The IF & IE macros cannot be combined due to flatten.sed
+.de IF		\"Begin Include a source file
+.br
+.if n .sp 1
+.if t .sp .5
+.ne 10
+.nf
+.cs R 24
+.vs \n(.vu-2p
+.RS 0.25in
+..
+.de IE		\"End Include a source file
+.br
+.RE
+.if n .sp 1
+.if t .sp .5
+.vs \n(.vu+2p
+.cs R
+.fi
+..
+.\"	The OF & OE macros cannot be combined due to flatten.sed
+.de OF		\"Begin Include a fixed nroff output file
+.br
+.if n .sp 1
+.if t .sp .5
+.ne 10
+.nf
+.RS 0.25in
+..
+.de OE		\"End Include a fixed nroff output file
+.br
+.RE
+.if n .sp 1
+.if t .sp .5
+.fi
+..
+.de NA          \"Begin name and Email address stuff
+.br
+.if \\$1 .ne \\$1
+.if !"\\$2"" \{
+.if n .sp 1
+.if t .sp .5
+\\$2
+\}
+.if n .sp 1
+.if t .sp .5
+.nf
+.in +.5i
+..
+.de NE		\"End name
+.fi
+.in -.5i
+.if n .sp 1
+.if t .sp .5
+..
+.TH C2MAN 1 "March 2, 1995"
+.BY "CISRA"
+.SH NAME
+c2man \- generate manual pages from C source code
+.SH SYNOPSIS
+.B c2man
+[ 
+.I option \fP...\fI
+] [
+.I file \fP...\fI
+]
+.SH DESCRIPTION
+.B c2man
+reads C source code files in which comments have been strategically placed,
+and outputs manual page(s) documenting each function defined or declared (via
+a prototype), and optionally each variable with global scope.
+Function definitions and declarations may be in the old style or ISO/ANSI style.
+If no
+.I file
+argument is given,
+.B c2man
+takes its input from the standard input.
+.PP
+If a
+.B .h
+file is written as a formal interface description when preparing an
+interface spec,
+.B c2man
+can generate all the manual pages required for the spec at one fell swoop,
+and then keep them up to date automatically as the interface changes.
+.PP
+Since
+.B c2man
+will accept either function definitions or prototypes, it can be used on
+either
+.B .c
+or
+.B .h
+files.
+If the input is a
+.B header
+file, any files specified by
+.B \-i
+options are
+assumed to be prerequisites, and get parsed before the input file.
+(Any file whose extension begins with
+.RB `` h '',
+matched case-insensitively,
+is considered a
+.B header
+file.)
+.PP
+This is potentially a huge win for most programmers that just love documenting
+their functions, and updating the documentation every time it changes.
+Here's an example, named example.h:
+.IF
+.so example.h
+.IE
+.PP
+When:
+.CD c2man example.h
+is run,
+this produces a file named
+.B dowork.3
+which can be processed by man(1) or used as:
+.CD "nroff -man dowork.3"
+to produce:
+.OF
+.ne 34
+.so example.inc
+.OE
+.SS "Output Generation"
+By default, a separate output file is generated for each global identifier
+(i.e. function or variable) documented by c2man.
+.PP
+Much of
+.BR c2man 's
+information is extracted from the comment placed immediately before the
+declaration/definition of the identifier being documented; this comment
+is taken to describe the identifier and
+.B must
+be present, or the identifier will be ignored entirely.
+In the case of a variable declaration/definition, this comment may instead be
+placed after it starting on the same line.
+.PP
+Global variables are not documented, unless the
+.B \-v
+option is used.
+.PP
+Identifiers declared
+.B static
+are ignored by default unless the file is a
+.B header
+file (which is most useful with
+.B inline
+functions) or the
+.B -s
+option is used.
+.PP
+Declarations with the
+.B extern
+keyword are ignored unless they appear in a
+.B header
+file; note that this does not include function definitions.
+.SS "Sections Generated Automatically"
+Each manual page starts with a
+.B NAME
+section, listing the name(s) of the identifier(s) documented, along with a
+terse description.
+By default, this description is the first line or sentence of the
+comment describing the identifier.
+With the
+.B \-g
+option, it is found after the first dash
+.RB ( \- )
+in the first comment of the file, and the
+.B \-G
+option specifies it explicitly.
+.PP
+The
+.B SYNOPSIS
+section
+begins with an
+.B #include
+line
+if the source file is a
+.BR header .
+After this is an external declaration for the
+identifier(s) being documented.
+.PP
+Information in the
+.B PARAMETERS
+section is gleaned from the comments immediately before or after each
+parameter declaration. A comment after a parameter can follow the comma that
+separates that parameter from the next, if the comment starts on the same line
+and is the only remaining thing on that line. Leading underscores in a
+parameter name are stripped when printed in the manual page.
+.PP
+If the manual page is for a group of functions (ie:
+.B \-g
+or
+.B \-G
+options),
+identical parameters (in both name and type) common to more than one function
+are described only once if only one has a comment (as in the ctype Xexample below).
+.PP
+If a parameter is an
+.B enumerated
+.BR type ,
+all the possible values it can take are output, along with their descriptions.
+These descriptions are gleaned from the comments surrounding the
+.B enum
+identifiers where the type was defined.
+Comments describing
+.B enum
+identifiers are placed in a similar manner to those that describe function
+parameters.
+.B enum
+identifiers that begin with an underscore are ignored, which is useful for
+padding or
+.I _NUMBER_OF_...
+values which aren't normally used by someone calling
+the function.
+If none of the identifiers in an enumerated type has a comment,
+.B c2man
+will bunch them together to save space.
+.PP
+The
+.B DESCRIPTION
+section contains everything
+after the first line or sentence
+of the comment describing the identifier,
+up until the word
+.RB `` returns ''
+at the start of a line, matched case-insensitively and optionally followed by
+a colon
+.RB ( : ).
+In the case of a variable of
+.B enumerated
+.BR type ,
+it will also list all the values it can hold.
+.PP
+The
+.B RETURNS
+section contains anything after that. Any of these lines that begin with a
+single word followed by a colon or a tab generate tagged paragraphs so that
+lists of possible return values and error codes look neat.
+If the function is void, don't put anything like "Returns: nothing" in
+the comment, since it's a waste of space. If the identifier is a function
+returning an
+.B enumerated
+.BR type ,
+its possible values will be listed here.
+.PP
+The
+.B RETURNS
+section is also added if there is a comment after the function return type.
+.EX 5 "For example:"
+/* Sample function */
+char *			/* NULL if failed string otherwise */
+sample_function()
+{
+}
+.EE
+The
+.B RETURNS
+section will contain the full contents of the comment (stripping the optional
+leading asterisk). It is not possible to use both methods to specify a
+description for the return value. In that case the comment after the
+return type supersedes whatever was specified for the return value in
+the comment above the function.
+.PP
+Finally, a
+.B "SEE ALSO"
+section is generated, referencing all the other manual pages generated, if any.
+.PP
+The
+.BR RETURNS ,
+.B PARAMETERS
+and
+.B "SEE ALSO"
+sections are omitted entirely if they aren't needed.
+.SS "Comment Style and Placement"
+Both
+.B C
+and
+.B C++
+style comments are recognized,
+with seperate consecutive single-line comments coalesced into a single block.
+When looking at comments,
+.B c2man
+ignores everything before the first alpha-numeric character. After that, it
+ignores leading white-space, leading asterisks and leading slashes
+on all subsequent
+lines, and ignores all trailing lines thus rendered blank. If that leaves
+nothing, the comment is ignored entirely.
+This makes it very flexible in supporting popular comment boxing.
+.PP
+Comments can be placed with considerable flexibility so that most commenting
+styles are supported.
+.EX 13 "The following variations of the enum definition in the \fBdowork.h\fR\
+ example are all equivalent:"
+/* commas after the comments. */
+enum Place
+{
+    HOME       /* Home, Sweet Home */,
+    WORK       /* where I spend lots of time */,
+    MOVIES     /* Saturday nights mainly */,
+    CITY       /* New York, New York */,
+    COUNTRY    /* Bob's Country Bunker */
+};
+.EE
+.EX 16
+/* the comment needn't go on the same line,
+ * if the comma goes after the comment.
+ */
+enum Place
+{
+    HOME
+    	/* Home, Sweet Home */,
+    WORK
+    	/* where I spend lots of time */,
+    MOVIES
+    	/* Saturday nights mainly */,
+    CITY
+    	/* New York, New York */,
+    COUNTRY
+    	/* Bob's Country Bunker */
+};
+.EE
+.EX 14
+/* the comment can go before it too. */
+enum Place
+{
+    /* Home, Sweet Home */
+    HOME,
+    /* where I spend lots of time */
+    WORK,
+    /* Saturday nights mainly */
+    MOVIES,
+    /* New York, New York */
+    CITY,
+    /* Bob's Country Bunker */
+    COUNTRY
+};
+.EE
+But the following example is
+.B NOT
+equivalent because the commas are between the identifier and the its
+associated comment, and the comment is on a different line.
+Each comment actually applies to the wrong identifier, so this will result in
+very misleading output.
+.EX 16 "Don't do this:"
+enum Place
+{
+    HOME,
+    	/* Home, Sweet Home */
+    WORK,
+    	/* where I spend lots of time */
+    MOVIES,
+    	/* Saturday nights mainly */
+    CITY,
+    	/* New York, New York */
+    COUNTRY
+    	/* Bob's Country Bunker */
+};
+.EE
+.PP
+Since enum identifiers sometimes fall into logical groups, a comment before
+such an identifier will be taken to apply to the next few in the list,
+provided that the comments describing each individual identifier
+are placed after them. Also, there must be a blank line separating the comment
+describing the next logical group and the comment at the end of the previous
+line, or the two will be coalesced and incorrectly treated as a single comment
+for the previous enumerator.
+.EX 17 "In other words, you can go:"
+/* include logical grouping comments. */
+enum Place
+{
+    /* These take up most of the week */
+    HOME,      /* Home, Sweet Home */
+    WORK,      /* where I spend lots of time */
+
+    /* More for special occasions */
+    MOVIES,     /* Saturday nights mainly */
+    CITY,      /* New York, New York */
+
+    /* The real favourite */
+    COUNTRY    /* Bob's Country Bunker */
+};
+.EE
+.PP
+That may all sound a bit complex, but the upshot is that
+.B c2man
+will usually know which identifier a comment is associated with, unless you do
+something truly bizarre.
+.SS "Processing of Comment Contents"
+Basic punctuation and capitalisation corrections are made in each section for
+neatness, and the typesetting program used to process the output will generally
+reformat line breaks according to the width of the output device. Blank lines
+in a comment will be preserved, and lines starting with a dash
+.RB ( \- ),
+an asterisk
+.RB ( * ),
+or a numbered point 
+.RB ( (n) ,
+.B n)
+.RB or\  n. ), 
+will cause a line break, allowing simple bulleted or numbered lists.
+.PP
+Typesetter specific commands may be included for more complex processing,
+although this isn't recommended since it ties you to a particular typesetter.
+.SS "Grouped Manual Pages"
+Simple, closely related objects can be grouped together onto a single page with the
+.B \-g
+or
+.B \-G
+options. By default, this results in a single output file with multiple links
+so that it can be accessed by the name of the input file, or of any identifier
+documented.
+For example, if ctype.h contains:
+.IF
+.so ctype_ex.h
+.IE
+.PP
+then using:
+.CD c2man -g ctype.h
+yields:
+.OF
+.so ctype_ex.inc
+.OE
+.SS "Extra Sections"
+Additional sections not otherwise recognized by
+.B c2man
+can be included in the manual page by including them in the comment
+describing the identifier.
+A section heading is preceded in the comment by an empty line (after
+removal of leading asterisks), and is the only word on it's line, or is
+a word followed by a colon
+.RB ( : ),
+or is a line ending with a colon, so section names with spaces are allowed,
+like "Return value:".
+.P
+Section heading names are capitalized, and the names
+.BR DESCRIPTION ,
+.B RETURNS
+and
+.B NAME
+are recognized specially so you can name them explicitly if you like.
+.BR FUNCTION ,
+.B PROCEDURE
+and
+.B ROUTINE
+are also recognised, and treated identically to
+.BR NAME .
+.EX 9 "For example:"
+/*
+ * Have a quick puff.
+ * 
+ * Warning: Smoking causes lung cancer
+ */
+void go_for_a_smoke();
+.EE
+Generates a manual page with a
+.B WARNING
+section.
+.EE
+.SH OPTIONS
+.TP
+.BI \-o dir
+Write generated files into directory
+.B dir
+rather than the current directory.
+If
+.B dir
+is specified as
+.BR \- ,
+generated pages are written to the standard output, separated by form-feeds.
+.TP
+.B \-v
+Also output declarations for variables defined in the file.
+.TP
+.B \-s
+Output manual pages for all
+.B static
+identifiers.
+.TP
+.B \-g
+Group all the info generated together into a single
+page (ala ctype(3)), reading the single-line terse description for the
+.B NAME
+section from the line of the first comment in the file.
+If this first line contains a dash
+.RB ( \- )
+surrounded by whitespace, the terse description is taken starting after the
+dash.
+If multiple files are specified,
+the first such suitable comment encountered is used. A link to
+the output file is made for each identifier documented, according to the
+.B \-l
+option.
+.TP
+.BI \-G terse
+Like
+.BR \-g ,
+but using the specified terse description rather than reading it from the
+file.
+.TP
+.B \-k
+Don't attempt to fix up capitalization and punctuation.
+.TP
+.B \-b
+If a function lacks a preceding comment, look for one immediately following
+the curly-brace at the top of the function body.  
+The comment must appear before anything else.
+.TP
+.B \-B
+Apply 
+.B \-b 
+strictly.  Only look for the description of a function at
+the top of its body.
+.TP
+.B \-l h|s|f|n|r
+Select how the output for a grouped manual page is linked to files named after
+all identifiers documented on the page.
+Hard link
+.RB ( h )
+is the default, as it uses the least space.
+Soft link
+.RB ( s ),
+where supported, allows a
+.BR find (1)
+command with
+.RB `` "\-type f" ''
+to easily skip the duplicated pages.
+Separate file
+.RB ( f )
+containing a file include
+directive is the traditional
+.SM UNIX
+method.
+No link
+.RB ( n )
+is useful for generating printed documentation without duplicated pages; only
+a single file, named according to the
+.B \-n
+option, is generated.
+Remove
+.RB ( r )
+is like No link, but also removes any previously generated links/files named
+after the identifiers documented. Useful for cleaning up after accidents with
+the other link options.
+.sp
+In all cases, any existing links will be removed before being rewritten.
+.TP
+.B \-n
+Name the documentation output file after the input file.
+When generating grouped manual pages, this will be the file to which others
+are linked. 
+For non-grouped manual pages, if documentation for more than one
+identifier is generated, information about the last identifier will overwrite
+information about all the previous ones.
+.PP
+.BI \-i file
+.PP
+\fB\-i\fI\{"file"\}
+.TP
+.BI \-i <file>
+Insert a
+.B #include
+line referencing the specified file in the
+.B SYNOPSIS
+section, using the ``<file>'' form by default.
+Any number of
+.B \-i
+options may be specified to build up a list of prerequisites.
+If using the second form, you may need to quote the quotation marks, lest they
+get removed by the shell.
+.TP
+.BI \-x sectionname
+Exclude
+.I sectionname
+from the generated manpages.  This option may be repeated to exclude a number
+of sections.
+.TP
+.BI \-H header-path
+Prepend
+.B header-path
+to the name of the
+.B header
+file when an
+.B #include
+line is automatically generated in the
+.B SYNOPSIS
+section.
+.TP
+.BI \-L
+Lazy option: Only list parameters in the
+.B PARAMETERS
+section if they are documented by a comment in the source. By default,
+parameters with no comment are described as ``Not Documented.'', to encourage
+the programmer to comment them.
+.TP
+.BI \-Tn|l|t|h|a[, options ]
+Set the output typesetting language as well as language specific
+options.
+.I options
+is a comma delimited list of options.
+.B Nroff
+.RB ( n )
+is the default, 
+.B LaTeX
+.RB ( l )
+,
+.B Texinfo
+.RB ( t )
+,
+.B HTML
+.RB ( h )
+, or
+.B AutoDoc
+.RB ( a ).
+.B Texinfo
+specific options are 
+.BR s ,
+.BR t ,
+.BR n ,
+and
+.BR C .
+
+In 
+.B Texinfo
+mode, each section is normally coded as a ``heading'' rather than a
+``section''.  This prevents the section name from appearing in the
+table of contents.  If the option
+.B t
+is given, the name of the manpage is used for the title of the
+.B NAME
+section, and is encoded as a ``section'', placing it in
+the table of contents.  Subsequent sections are encoded as ``headings''.  
+.B Texinfo
+supports multiple levels of headings; the desired level may be
+specified via the 
+.BI s n
+option, where
+.I n
+starts at 0 for the ``chapter level'' and works down.  A
+top level node is created for the manpage, except when in embedded
+mode
+(the 
+.B c2man \-e
+option).  If the 
+.B n
+option is specified, a node is created in embedded mode, but
+without Up, Previous, or Next pointers;  these must be filled in
+.BR ( Texinfo
+mode in 
+.B emacs
+does a good job of it).  The
+.B C
+option capitalizes the section titles.  Usually they are printed
+as specified (which is usually upper case).
+.TP
+.BI \-e
+Prepares the output so it can be embedded in texts of the output typesetting
+language.
+.TP
+.BI \-M name
+Set the name of the manual in which the page will go.
+.TP
+.BI \-S section
+Set the default manual section, used as the extension on the output files.
+.I section
+defaults to ``3'' for
+.BR nroff ,
+``texi'' for
+.B Texinfo ,
+``html'' for
+.B HTML
+and ``tex'' for
+.B LaTeX
+output, as specified via the
+.B \-T
+option.
+This setting can be overridden by the
+.BI \-O? .ext
+options for finer control.
+.TP
+.BI \-Of|v|F|V[ subdir ][. ext ]
+Provides for finer control of the output files, allowing a different output
+subdirectory and extension to be specified for these different classes of
+objects:
+functions
+.RB ( f ),
+variables
+.RB ( v ),
+static functions
+.RB ( F )
+and static variables
+.RB ( V ).
+.sp
+If
+.I subdir
+is specified, the selected class of output will be written in that
+subdirectory under the directory given by the
+.B \-o
+option if specified, otherwise under the current directory.
+.sp
+If
+.I .ext
+is specified, it will be used as the extension on the output files of the
+selected class, instead of the default based on the
+.B \-S
+option (if specified), or the typesetting output format specified by the
+.B \-T
+option.
+.sp
+For example, the following command will generate
+.BR nroff (1)
+style output under the /usr/local/man hierarchy, documenting functions in
+section 3 (/usr/local/man/man3/*.3), global variables in section 3v
+(/usr/local/man/man3/*.3v), static functions in section 9
+(/usr/local/man/man9/*.9) and
+static variables in section 9v (/usr/local/man/man9/*.9v):
+.CD c2man -o/usr/local/man -v -s -Ofman3.3 -Ovman3.3v -OFman9.9 -OVman9.9v input.c
+The
+.B \-O
+options will have no effect if
+.B \-o-
+is used to write to standard output, and
+.BR \-Ov ,
+.B \-OF
+and
+.B \-OV
+will have no effect unless their classes of output are enabled via the
+appropriate
+.B \-v
+and
+.B \-s
+options.
+.TP
+.BI \-F template
+Set the format used to output the prototype for functions with more than 1
+parameter
+in each manual page;
+functions with zero or 1 parameters are always output as one line.
+The format is specified by a template in the form
+.EX
+" int f ( a, b )"
+.EE
+but you may replace each space in this string with any number of
+whitespace characters.
+For example, the option
+.EX
+-F"int f(\\n\\ta,\\n\\tb\\n\\t)"
+.EE
+.EX 5 "will produce:"
+int main(
+        int argc,
+        char *argv[]
+        )
+.EE
+.EX 5 "The default output format is:"
+int main
+(
+        int argc,
+        char *argv[]
+);
+.EE
+.TP
+.BI \-P preprocessor
+Run a different C preprocessor than normal (use
+.B \-V
+to determine the configured default).
+You must include any options required to prevent it from stripping comments,
+which is normally the default preprocessor behaviour.
+For example, to use
+.BR gcc 's
+cpp instead:
+.CD c2man -P \{"gcc -E -C"\}
+.TP
+.BI \-D name[=value]
+This option is passed through to the preprocessor and is used to define 
+symbols for use with conditionals such as
+.I #ifdef.
+.TP
+.BI \-U name
+This option is passed through to the preprocessor and is used to remove
+any definitions of this symbol.
+.TP
+.BI \-I directory
+This option is passed through to the preprocessor and is used to specify
+a directory to search for files that are referenced with 
+.I #include.
+.TP
+.B \-V
+Print version information and cpp parameters.
+.SH FILES
+.TP
+$(privlib)/eg/*.[ch]
+A few example input files, showing different commenting styles.
+.SH "SEE ALSO"
+man(1),
+apropos(1),
+catman(8),
+cproto(1),
+cc(1),
+cpp(1)
+.SH DIAGNOSTICS
+.BR c2man 's
+error messages are not very helpful, so make sure your code compiles before
+trying
+.BR c2man .
+If the code compiles OK but
+.B c2man
+rejects it, it may be because a comment is in a position
+.B c2man
+does not accept, or you are using a compiler extension not strictly conforming
+to standard C.
+.B c2man
+defines the preprocessor symbol
+.B __C2MAN__
+with its major version number
+to allow you to work around such problems by surrounding them with
+.BR "#ifndef __C2MAN__" .
+.PP
+An error at the very end of a function may indicate that the comments at the
+beginning are badly placed.
+.SH HISTORY
+.B c2man
+was originally written by:
+.NA 4
+Graham Stoney
+Canon Information Systems Research Australia
+greyham@research.canon.com.au
+(please send bug reports here)
+.NE
+Many thanks are due to the many other Internet contributors since then, and to
+Chin Huang, the author of
+.B cproto
+from which it was originally derived.
+.SH BUGS
+The
+.B \-F
+option only interprets the following
+character escape sequences:
+.EX 2
+\\n	newline
+\\t	tab
+.EE
+.PP
+A comment before a preprocessor directive will be considered to apply
+to the identifier that immediately follows, if it has no
+comment of its own.
+This is because the preprocessor directive gets removed by cpp before
+c2man looks at it.
+.PP
+Comments aren't legal in some of the more obscure places that they are in C.
+.PP
+Heavy use of
+.B #define
+in a program may yield somewhat obscure manual pages.
+.PP
+.BR c2man 's
+output backends may not be entirely consistent, but then users of
+different formatters tend to have different tastes.
diff --git a/catalog b/catalog
new file mode 100644
index 0000000..42ec395
--- /dev/null
+++ b/catalog
@@ -0,0 +1,44 @@
+language:	C, nroff, texinfo, latex, html, autodoc
+package:	c2man
+version:	2.0 patchlevel 40
+parts:		documentation generator (C -> nroff -man, -> texinfo, -> latex,
+		-> html, -> autodoc)
+author:		Graham Stoney <greyham@research.canon.com.au>
+location:	ftp from any comp.sources.misc archive, in volume42
+		(the version in the comp.sources.reviewed archive is obsolete)
+		ftp /pub/Unix/Util/c2man-2.0.*.tar.gz from dnpap.et.tudelft.nl
+    Australia:	ftp /usenet/comp.sources.misc/volume42/c2man-2.0/*
+		from archie.au
+    N.America:	ftp /usenet/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.wustl.edu
+    Europe:	ftp /News/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.irisa.fr
+    Japan:	ftp /pub/NetNews/comp.sources.misc/volume42/c2man-2.0/*
+		from ftp.iij.ad.jp
+    Patches:	ftp pub/netnews/sources.bugs/volume93/sep/c2man* from lth.se
+description:	c2man is an automatic documentation tool that extracts comments
+		from C source code to generate functional interface
+		documentation in the same format as sections 2 & 3 of the Unix
+		Programmer's Manual. It requires minimal effort from the
+		programmer by looking for comments in the usual places near the
+		objects they document, rather than imposing a rigid
+		function-comment syntax or requiring that the programmer learn
+		and use a typesetting language. Acceptable documentation can
+		often be generated from existing code with no modifications.
+conformance:    supports both K&R and ISO/ANSI C coding styles
+features:	+ generates output in nroff -man, TeXinfo, LaTeX or HTML format
+		+ handles comments as part of the language grammar
+		+ automagically documents enum parameter & return values
+		+ handles C (/* */) and C++ (//) style comments
+		- doesn't handle C++ grammar (yet)
+requires:	yacc/byacc/bison, lex/flex, and nroff/groff/texinfo/LaTeX.
+ports:		Unix, OS/2, MSDOS, VMS, Amiga.
+portability:	very high for unix, via Configure
+status:		actively developed; contributions by users are encouraged.
+discussion:	via a mailing list: send "subscribe c2man <Your Name>" (in the
+		message body) to listserv@research.canon.com.au
+help:		from the author and other users on the mailing list:
+		c2man@research.canon.com.au
+announcements:	patches appear first in comp.sources.bugs, and then in
+		comp.sources.misc.
+updated:	1996/03/21
diff --git a/config_h.SH b/config_h.SH
new file mode 100644
index 0000000..cf2fa77
--- /dev/null
+++ b/config_h.SH
@@ -0,0 +1,353 @@
+case $CONFIG in
+'')
+	if test -f config.sh; then TOP=.;
+	elif test -f ../config.sh; then TOP=..;
+	elif test -f ../../config.sh; then TOP=../..;
+	elif test -f ../../../config.sh; then TOP=../../..;
+	elif test -f ../../../../config.sh; then TOP=../../../..;
+	else
+		echo "Can't find config.sh."; exit 1
+	fi
+	. $TOP/config.sh
+	;;
+esac
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+echo "Extracting config.h (with variable substitutions)"
+sed <<!GROK!THIS! >config.h -e 's!^#undef\(.*/\)\*!/\*#define\1 \*!' -e 's!^#un-def!#undef!'
+/*
+ * 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.
+ *
+ * \$Id: config_h.SH,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ */
+
+/*
+ * Package name      : $package
+ * Source directory  : $src
+ * Configuration time: $cf_time
+ * Configured by     : $cf_by
+ * Target system     : $myuname
+ */
+
+#ifndef _config_h_
+#define _config_h_
+
+/* VMS:
+ *	This symbol, if defined, indicates that the program is running under
+ *	VMS.  It is currently only set in conjunction with the EUNICE symbol.
+ */
+/* BSD:
+ *	This symbol, if defined, indicates that the program is running under
+ *	a BSD system.
+ */
+#$d_eunice VMS		/**/
+#$d_bsd BSD		/**/
+
+/* CPP_FILE_COM:
+ *	This symbol contains the first part of the string which will invoke
+ *	the C preprocessor a file and produce to standard output, preserving
+ *	comments. Typical value of "cc -E -C" or "/lib/cpp -C".
+ */
+/* CPP_STDIN_FLAGS:
+ *	This variable contains any flags necessary to get CPP_FILE_COM to
+ *	read from the standard input.
+ */
+/* CPP_IGN_HDRS:
+ *	This symbol is defined if CPP_FILE_COM ignores *.h files.
+ */
+/* CPP_CAN_STDIN:
+ *	This symbol is defined if CPP_FILE_COM can read standard input
+ *	directly.
+ */
+#define CPP_FILE_COM "$cppfilecom"
+#define CPP_STDIN_FLAGS "$cppstdinflags"
+#$d_cppignhdrs CPP_IGN_HDRS		/* does CPP ignore .h files? */
+#$d_cppcanstdin CPP_CAN_STDIN 	/* can CPP read stdin directly? */
+
+/* HAS_ACCESS:
+ *	This manifest constant lets the C program know that the access()
+ *	system call is available to check for accessibility using real UID/GID.
+ *	(always present on UNIX.)
+ */
+#$d_access HAS_ACCESS		/**/
+
+/* HASATTRIBUTE:
+ *	This symbol indicates the C compiler can check for function attributes,
+ *	such as printf formats. This is normally only supported by GNU cc.
+ */
+#$d_attribut HASATTRIBUTE 	/**/
+#ifndef HASATTRIBUTE
+#define __attribute__(_arg_)
+#endif
+
+/* HASCONST:
+ *	This symbol, if defined, indicates that this C compiler knows about
+ *	the const type. There is no need to actually test for that symbol
+ *	within your programs. The mere use of the "const" keyword will
+ *	trigger the necessary tests.
+ */
+#$d_const HASCONST	/**/
+#ifndef HASCONST
+#define const
+#endif
+
+/* FLEXFILENAMES:
+ *	This symbol, if defined, indicates that the system supports filenames
+ *	longer than 14 characters.
+ */
+#$d_flexfnam	FLEXFILENAMES		/**/
+
+/* HAS_LINK:
+ *	This symbol, if defined, indicates that the link routine is
+ *	available to create hard links.
+ */
+#$d_link HAS_LINK	/**/
+
+/* HAS_OPEN3:
+ *	This manifest constant lets the C program know that the three
+ *	argument form of open(2) is available.
+ */
+#$d_open3 HAS_OPEN3		/**/
+
+/* HAS_STRCHR:
+ *	This symbol is defined to indicate that the strchr()/strrchr()
+ *	functions are available for string searching. If not, try the
+ *	index()/rindex() pair.
+ */
+/* HAS_INDEX:
+ *	This symbol is defined to indicate that the index()/rindex()
+ *	functions are available for string searching.
+ */
+#$d_strchr HAS_STRCHR	/**/
+#$d_index HAS_INDEX	/**/
+
+/* HAS_STRFTIME:
+ *	This symbol, if defined, indicates that the strftime routine is
+ *	available to format locale-specific times.
+ */
+#$d_strftime HAS_STRFTIME	/**/
+
+/* HAS_STRSTR:
+ *	This symbol, if defined, indicates that the strstr routine is
+ *	available to find substrings.
+ */
+#$d_strstr HAS_STRSTR	/**/
+
+/* HAS_SYMLINK:
+ *	This symbol, if defined, indicates that the symlink routine is available
+ *	to create symbolic links.
+ */
+#$d_symlink HAS_SYMLINK	/**/
+
+/* Time_t:
+ *	This symbol holds the type returned by time(). It can be long,
+ *	or time_t on BSD sites (in which case <sys/types.h> should be
+ *	included).
+ */
+#define Time_t $timetype		/* Time type */
+
+/* Signal_t:
+ *	This symbol's value is either "void" or "int", corresponding to the
+ *	appropriate return type of a signal handler.  Thus, you can declare
+ *	a signal handler using "Signal_t (*handler)()", and define the
+ *	handler using "Signal_t handler(sig)".
+ */
+#define Signal_t $signal_t	/* Signal handler's return type */
+
+/* HASVOLATILE:
+ *	This symbol, if defined, indicates that this C compiler knows about
+ *	the volatile declaration.
+ */
+#$d_volatile	HASVOLATILE	/**/
+#ifndef HASVOLATILE
+#define volatile
+#endif
+
+/* I_FCNTL:
+ *	This manifest constant tells the C program to include <fcntl.h>.
+ */
+#$i_fcntl I_FCNTL	/**/
+
+/* I_STDDEF:
+ *	This symbol, if defined, indicates that <stddef.h> exists and should
+ *	be included.
+ */
+#$i_stddef I_STDDEF	/**/
+
+/* I_STDLIB:
+ *	This symbol, if defined, indicates that <stdlib.h> exists and should
+ *	be included.
+ */
+#$i_stdlib I_STDLIB		/**/
+
+/* I_STRING:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <string.h> (USG systems) instead of <strings.h> (BSD systems).
+ */
+#$i_string I_STRING		/**/
+
+/* I_SYS_FILE:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/file.h> to get definition of R_OK and friends.
+ */
+#$i_sysfile I_SYS_FILE		/**/
+
+/* I_SYS_TYPES:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/types.h>.
+ */
+#$i_systypes	I_SYS_TYPES		/**/
+
+/* I_TIME:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <time.h>.
+ */
+/* I_SYS_TIME:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <sys/time.h>.
+ */
+#$i_time I_TIME		/**/
+#$i_systime I_SYS_TIME		/**/
+
+/* I_UNISTD:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <unistd.h>.
+ */
+#$i_unistd I_UNISTD		/**/
+
+/* I_STDARG:
+ *	This symbol, if defined, indicates that <stdarg.h> exists and should
+ *	be included.
+ */
+/* I_VARARGS:
+ *	This symbol, if defined, indicates to the C program that it should
+ *	include <varargs.h>.
+ */
+#$i_stdarg I_STDARG		/**/
+#$i_varargs I_VARARGS	/**/
+
+/* CAN_PROTOTYPE:
+ *	If defined, this macro indicates that the C compiler can handle
+ *	function prototypes.
+ */
+/* DOTS:
+ *	This macro is used to specify the ... in function prototypes which
+ *	have arbitrary additional arguments.
+ */
+/* NXT_ARG:
+ *	This macro is used to separate arguments in the declared argument list.
+ */
+/* P_FUNC:
+ *	This macro is used to declare "private" (static) functions.
+ *	It takes three arguments: the function type and name, a parenthesized
+ *	traditional (comma separated) argument list, and the declared argument
+ *	list (in which arguments are separated with NXT_ARG, and additional
+ *	arbitrary arguments are specified with DOTS).  For example:
+ *
+ *		P_FUNC(int foo, (bar, baz), int bar NXT_ARG char *baz[])
+ */
+/* P_FUNC_VOID:
+ *	This macro is used to declare "private" (static) functions that have
+ *	no arguments.  The macro takes one argument: the function type and name.
+ *	For example:
+ *
+ *		P_FUNC_VOID(int subr)
+ */
+/* V_FUNC:
+ *	This macro is used to declare "public" (non-static) functions.
+ *	It takes three arguments: the function type and name, a parenthesized
+ *	traditional (comma separated) argument list, and the declared argument
+ *	list (in which arguments are separated with NXT_ARG, and additional
+ *	arbitrary arguments are specified with DOTS).  For example:
+ *
+ *		V_FUNC(int main, (argc, argv), int argc NXT_ARG char *argv[])
+ */
+/* V_FUNC_VOID:
+ *	This macro is used to declare "public" (non-static) functions that have
+ *	no arguments.  The macro takes one argument: the function type and name.
+ *	For example:
+ *
+ *		V_FUNC_VOID(int fork)
+ */
+/* _:
+ *	This macro is used to declare function parameters for folks who want
+ *	to make declarations with prototypes using a different style than
+ *	the above macros.  Use double parentheses.  For example:
+ *
+ *		int main _((int argc, char *argv[]));
+ */
+#$prototype	CAN_PROTOTYPE	/**/
+#ifdef CAN_PROTOTYPE
+#define	NXT_ARG ,
+#define	DOTS , ...
+#define	V_FUNC(name, arglist, args)name(args)
+#define	P_FUNC(name, arglist, args)static name(args)
+#define	V_FUNC_VOID(name)name(void)
+#define	P_FUNC_VOID(name)static name(void)
+#define	_(args) args
+#else
+#define	NXT_ARG ;
+#define	DOTS
+#define	V_FUNC(name, arglist, args)name arglist args;
+#define	P_FUNC(name, arglist, args)static name arglist args;
+#define	V_FUNC_VOID(name)name()
+#define	P_FUNC_VOID(name)static name()
+#define	_(args) ()
+#endif
+
+/* CAN_VAPROTO:
+ *	This variable is defined on systems supporting prototype declaration
+ *	of functions with a variable number of arguments.
+ */
+/* _V:
+ *	This macro is used to declare function parameters in prototypes for
+ *	functions with a variable number of parameters. Use double parentheses.
+ *	For example:
+ *
+ *		int printf _V((char *fmt, ...));
+ *
+ *	Remember to use the plain simple _() macro when declaring a function
+ *	with no variable number of arguments, since it might be possible to
+ *	have a non-effect _V() macro and still get prototypes via _().
+ */
+#$vaproto CAN_VAPROTO	/**/
+#ifdef CAN_VAPROTO
+#define	_V(args) args
+#else
+#define	_V(args) ()
+#endif
+
+/* VOIDFLAGS:
+ *	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
+ *	    8 = suports declaration of generic void pointers
+ *
+ *	The package designer should define VOIDUSED to indicate the requirements
+ *	of the package.  This can be done either by #defining VOIDUSED before
+ *	including config.h, or by defining defvoidused in Myinit.U.  If the
+ *	latter approach is taken, only those flags will be tested.  If the
+ *	level of void support necessary is not present, defines void to int.
+ */
+#ifndef VOIDUSED
+#define VOIDUSED $defvoidused
+#endif
+#define VOIDFLAGS $voidflags
+#if (VOIDFLAGS & VOIDUSED) != VOIDUSED
+#define void int		/* is void to be avoided? */
+#define M_VOID			/* Xenix strikes again */
+#endif
+
+#endif
+!GROK!THIS!
diff --git a/confmagic.h b/confmagic.h
new file mode 100644
index 0000000..5cf0a4a
--- /dev/null
+++ b/confmagic.h
@@ -0,0 +1,27 @@
+/*
+ * This file was produced by running metaconfig and is intended to be included
+ * after config.h and after all the other needed includes have been dealt with.
+ *
+ * This file may be empty, and should not be edited. Rerun metaconfig instead.
+ * If you wish to get rid of this magic, remove this file and rerun metaconfig
+ * without the -M option.
+ *
+ *  $Id: confmagic.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ */
+
+#ifndef _confmagic_h_
+#define _confmagic_h_
+
+#ifndef HAS_INDEX
+#ifndef index
+#define index strchr
+#endif
+#endif
+
+#ifndef HAS_INDEX
+#ifndef rindex
+#define rindex strrchr
+#endif
+#endif
+
+#endif
diff --git a/ctype_ex.h b/ctype_ex.h
new file mode 100644
index 0000000..5719a7f
--- /dev/null
+++ b/ctype_ex.h
@@ -0,0 +1,38 @@
+/* ctype.h - character classification functions */
+
+/* character is alphanumeric
+ * returns 0 if the character doesn't fit the
+ * classification; non-zero (but not necessarily 1)
+ * if it does.
+ */
+inline int isalnum(int c	/* the character to classify */);
+
+/* character is a letter */
+inline int isalpha(int c);
+
+/* character is a control character */
+inline int iscntrl(int c);
+
+/* character is a digit */
+inline int isdigit(int c);
+
+/* character is a graphic */
+inline int isgraph(int c);
+
+/* character is a lower case letter */
+inline int islower(int c);
+
+/* character is printable */
+inline int isprint(int c);
+
+/* character is punctuation */
+inline int ispunct(int c);
+
+/* character is a a form of whitespace */
+inline int isspace(int c);
+
+/* character is an upper case letter */
+inline int isupper(int c);
+
+/* character is a hexadecimal digit */
+inline int isxdigit(int c);
diff --git a/eg/boxcomment.c b/eg/boxcomment.c
new file mode 100644
index 0000000..f5f0379
--- /dev/null
+++ b/eg/boxcomment.c
@@ -0,0 +1,41 @@
+/***************************************************************************
+ * C style box comment.
+ *
+ * This function has a very pretty C style box comment.
+ ***************************************************************************/
+void boxcomm_c1(void);
+
+/***************************************************************************
+/ Fancier C style box comment.
+/
+/ This function has a very pretty C style box comment.
+/***************************************************************************/
+void boxcomm_c2(void);
+
+/***************************************************************************
+/*** Even Fancier C style box comment.
+/***
+/*** This function has a very pretty C style box comment.
+/***************************************************************************/
+void boxcomm_c3(void);
+
+/*-------------------------------------------------------------------------
+ * C style box comment.
+ *
+ * This function has a dashed C style box comment.
+ *-------------------------------------------------------------------------*/
+void boxcomm_c4(void);
+
+////////////////////////////////////////////////////////////////////////////
+// C++ style box comment.
+//
+// This function has a very pretty C++ style box comment.
+////////////////////////////////////////////////////////////////////////////
+void boxcomm_cpp1(void);
+
+////////////////////////////////////////////////////////////////////////////
+//// Fancier C++ style box comment.
+////
+//// This function has a very pretty C++ style box comment.
+////////////////////////////////////////////////////////////////////////////
+void boxcomm_cpp2(void);
diff --git a/eg/ccomment.h b/eg/ccomment.h
new file mode 100644
index 0000000..86bb7cd
--- /dev/null
+++ b/eg/ccomment.h
@@ -0,0 +1,41 @@
+/*
+** function starting with a C comment
+*/
+void ccomment(
+	/* single line before */
+	int single_before,
+
+	/*
+	 * multiple
+	 * lines before
+	 */
+	int multiple_before,
+
+	int end_of_line,	/* end of the line */
+
+	int multiple_eol,	/*
+				 * multiple lines
+				 * starting at
+				 * the EOL
+				 */
+
+	int single_eol_before_comma	/* end of line, but before comma */,
+
+	int multiple_eol_before_comma	/*
+					 * multiple lines after, at the EOL and
+					 * before comma.
+					 * can't imagine anyone coding this.
+					 */,
+
+	int single_after
+	/* single line after */
+	,
+
+	int multiple_after
+	/*
+	 * multiple lines
+	 * after.
+	 * can't imagine anyone coding like this.
+	 */
+);
+
diff --git a/eg/commentaft.c b/eg/commentaft.c
new file mode 100644
index 0000000..29e86d8
--- /dev/null
+++ b/eg/commentaft.c
@@ -0,0 +1 @@
+int commentafter;	/* you'll need -v to get this documented */
diff --git a/eg/cppcomment.h b/eg/cppcomment.h
new file mode 100644
index 0000000..2f4ff90
--- /dev/null
+++ b/eg/cppcomment.h
@@ -0,0 +1,32 @@
+//
+// function starting with a C++ comment
+//
+void cppcomment(
+	// single line before
+	int single_before,
+
+	//
+	// multiple
+	// lines before
+	//
+	int multiple_before,
+
+	int end_of_line,	// end of the line
+
+	int multiple_eol,	//
+				// multiple lines
+				// starting at
+				// the EOL
+				//
+
+	int single_after
+	// single line after
+	,
+	int multiple_after
+	//
+	// multiple lines
+	// after.
+	// cant imagine anyone coding like this.
+	//
+);
+
diff --git a/eg/dash.h b/eg/dash.h
new file mode 100644
index 0000000..bc3502b
--- /dev/null
+++ b/eg/dash.h
@@ -0,0 +1,2 @@
+/* dash - comment with a dash. */
+int dash(int x);
diff --git a/eg/ellipsis.c b/eg/ellipsis.c
new file mode 100644
index 0000000..0842f6a
--- /dev/null
+++ b/eg/ellipsis.c
@@ -0,0 +1,15 @@
+int             pr(int,...);
+
+void            main(void)
+{
+    pr(3, 'a', 'b', 'c');
+}
+
+/* ellipsis test function */
+int             pr(
+	int nitems,		/* number of items */
+	...			/* items */
+)
+{
+    /* blah, blah, blah, blah, blah! */
+}
diff --git a/eg/grouped.c b/eg/grouped.c
new file mode 100644
index 0000000..05f3a27
--- /dev/null
+++ b/eg/grouped.c
@@ -0,0 +1,23 @@
+/*
+ * grouped functions
+ *
+ */
+
+/* my grouped1 does something weird */
+grouped1(a,b)
+int a;	/* the a parameter */
+char b; /* the b parameter */
+{
+
+	/* do nothing */
+	return(1);
+}
+/* my grouped2 does also something weird */
+grouped2(a,b)
+int a;	/* the a parameter */
+char *b;/* the b parameter */
+{
+
+	/* do nothing */
+	return(1);
+}
diff --git a/eg/multidecl.c b/eg/multidecl.c
new file mode 100644
index 0000000..70ffa3f
--- /dev/null
+++ b/eg/multidecl.c
@@ -0,0 +1,3 @@
+int multidecl1,	/* the first one */
+    multidecl2,	/* the second one */
+    multidecl3;	/* the last one */
diff --git a/eg/namedash.h b/eg/namedash.h
new file mode 100644
index 0000000..6d05848
--- /dev/null
+++ b/eg/namedash.h
@@ -0,0 +1,9 @@
+/*
+ * NAME
+ *	namedash - name section with dash.
+ *
+ * DESCRIPTION
+ *	This function goes way over the top and includes a NAME section that
+ *	has a dash in it.
+ */
+int namedash();
diff --git a/eg/oldstyle.c b/eg/oldstyle.c
new file mode 100644
index 0000000..ec4bb8b
--- /dev/null
+++ b/eg/oldstyle.c
@@ -0,0 +1,24 @@
+/*
+** old-style function starting with a C comment
+*/
+void oldstyle(single_before, multiple_before, end_of_line, multiple_eol)
+
+/* single line before */
+int single_before;
+
+/*
+ * multiple
+ * lines before
+ */
+int multiple_before;
+
+int end_of_line;	/* end of the line */
+
+int multiple_eol;	/*
+			 * multiple lines
+			 * starting at
+			 * the EOL
+			 */
+{
+	/* blah, blah, blah, blah, blah! */
+}
diff --git a/eg/retdecl.c b/eg/retdecl.c
new file mode 100644
index 0000000..6675c8d
--- /dev/null
+++ b/eg/retdecl.c
@@ -0,0 +1,10 @@
+/* return near the declarator
+ * This is an example of embedding the `returns' information in near the
+ * declarator in a function declaration.
+ */
+char *			/* a string, or NULL if it failed */
+retdecl()
+{
+    /* reference implementation that barely meets the interface spec */
+    return NULL;
+}
diff --git a/eg/returnerr.h b/eg/returnerr.h
new file mode 100644
index 0000000..2292585
--- /dev/null
+++ b/eg/returnerr.h
@@ -0,0 +1,16 @@
+/*
+ * Do an operating system operation
+ * This is an example of a function which performs some sort of operating
+ * system operation, returning an errno-like indication of its success or
+ * failure.  We'd like the documentation to list all the possible failure
+ * indications that this function can return, which is only a tiny subset of
+ * all the possible errno values.  Hence, we don't define it as returning an
+ * enum of some sort, since that would cause c2man to list every possible value
+ * that type can have.
+ * Returns an indication of success or failure, as follows:
+ *	EOK: Success
+ *	EIO: I/O error
+ *	ENOMEM: Out of memory
+ *	EIEIO: Old Macdonald error
+ */
+int reterrno();
diff --git a/eg/returnlist.h b/eg/returnlist.h
new file mode 100644
index 0000000..819f652
--- /dev/null
+++ b/eg/returnlist.h
@@ -0,0 +1,16 @@
+/* generate a lot of silly values
+ * Returns: Quite a number of things, as follows:
+ *	0	nothing
+ *	1	something small
+ *	2	a little larger
+ *	3	done in triplicate
+ *	4	getting larger
+ *	5	quintuplets
+ *	6	that'll do now, although I think this one is going to get
+ *		very long and even cover multiple lines. let's just hope that
+ *		it gets it right, including the capitalisation. maybe this is
+ *		not a super thorough test, so including some
+ * .B bold
+ *		stuff might help
+ */
+int returnlist();
diff --git a/eg/sections.c b/eg/sections.c
new file mode 100644
index 0000000..8a84a00
--- /dev/null
+++ b/eg/sections.c
@@ -0,0 +1,17 @@
+/*
+ * NAME
+ *	sections - multisection function comment.
+ *
+ * DESCRIPTION
+ *	Only a mental cripple would be as verbose as this.
+ *
+ * WARNING
+ *	Now here's a legitimate excuse for it.
+ */
+int sections(
+	int fred,	/* Mary's boyfriend */
+	int world	/* real crazy */
+)
+{
+	what the heck, all this stuff just gets ignored
+}
diff --git a/eg/simplesect.c b/eg/simplesect.c
new file mode 100644
index 0000000..8d6f4ed
--- /dev/null
+++ b/eg/simplesect.c
@@ -0,0 +1,13 @@
+/*
+ * calculate some sections.
+ * Note: this becomes the description.
+ *
+ * Warning: This becomes a section.
+ */
+int simplesect(
+	int fred,	/* Mary's boyfriend */
+	int world	/* real crazy */
+)
+{
+	what the heck, all this stuff just gets ignored
+}
diff --git a/eg/surround.c b/eg/surround.c
new file mode 100644
index 0000000..e050056
--- /dev/null
+++ b/eg/surround.c
@@ -0,0 +1,6 @@
+/* surrounded by comments.
+ * this is the first one, and only it should be output.
+ *
+ * note: you'll need -v to get output from this.
+ */
+int surround;	/* this should NOT be output. */
diff --git a/eg/underscore.h b/eg/underscore.h
new file mode 100644
index 0000000..e57e6d5
--- /dev/null
+++ b/eg/underscore.h
@@ -0,0 +1,21 @@
+/* parameter names have underscores
+ * the underscores get removed in the documentation
+ */
+void underscore(
+    /* an int */
+    int __x,
+
+    /* a pointer to an int */
+    int *__y,
+
+    /* another pointer to an int, funnily enough */
+    int _z[],
+
+    /* a char, with a strange bit legal name */
+    char _,
+
+    /* an anonymous double */
+    double,
+
+    /* pointer to a function */
+    float (*__funcptr)(int *__a1, char __a2[]));
diff --git a/eg/variable.c b/eg/variable.c
new file mode 100644
index 0000000..a788e82
--- /dev/null
+++ b/eg/variable.c
@@ -0,0 +1,5 @@
+/* a variable, not a function.
+ *
+ * Note: you'll need to use -v to get this to work.
+ */
+int variable;
diff --git a/enum.c b/enum.c
new file mode 100644
index 0000000..fd6c1ac
--- /dev/null
+++ b/enum.c
@@ -0,0 +1,179 @@
+/* $Id: enum.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * enumerator operations
+ */
+#include "c2man.h"
+#include "strconcat.h"
+#include "enum.h"
+#include "manpage.h"
+
+SymbolTable *enum_table;	/* enum symbol table */
+
+/* we have to keep a list of EnumeratorLists because:
+ * - unnamed EnumeratorLists can't go in the symbol table.
+ * - a single EnumeratorList can be typedef'ed or enum'ed to more than one
+ *   symbol, in which case it is referenced from the typedef_table or
+ *   enum_table repectively more than once.
+ */
+EnumeratorList *first_list = NULL, **last_next_list = &first_list;
+
+/* Initialize a list of enumerators.*/
+EnumeratorList *
+new_enumerator_list (enumerator)
+     Enumerator *enumerator;
+{
+    Enumerator *p;
+    EnumeratorList *list;
+    
+    list = (EnumeratorList *)safe_malloc(sizeof *list);
+    *last_next_list = list;
+    last_next_list = &list->next;
+    list->next = NULL;
+    
+    p = (Enumerator *)safe_malloc(sizeof(Enumerator));
+    *p = *enumerator;
+    
+    list->first = list->last = p;
+    p->next = NULL;
+    return list;
+}
+
+/* Add the enumerator to the list. */
+void
+add_enumerator_list (list, enumerator)
+     EnumeratorList *list;
+     Enumerator *enumerator;
+{
+    Enumerator *p;
+
+    p = (Enumerator *)safe_malloc((unsigned)sizeof(Enumerator));
+    *p = *enumerator;
+
+    list->last->next = p;
+    list->last = p;
+    p->next = NULL;
+}
+
+/* Free storage used by the elements in the enumerator list. */
+void
+free_enumerator_list (enumerator_list)
+     EnumeratorList *enumerator_list;
+{
+    Enumerator *p, *next;
+
+    p = enumerator_list->first;
+    while (p != NULL) {
+	next = p->next;
+	free_enumerator(p);
+	free(p);
+	p = next;
+    }
+}
+
+
+void
+new_enumerator(e, name, comment_before, comment_after)
+     Enumerator *e;
+     char *name;
+     char *comment_before;
+     char *comment_after;
+{
+    e-> name = name;
+    e-> comment = comment_after ? comment_after : comment_before;
+    e-> group_comment = comment_before && comment_after ? comment_before : NULL;
+}
+
+/* Free the storage used by the enumerator.*/
+void
+free_enumerator (param)
+     Enumerator *param;
+{
+    free(param->name);
+    safe_free(param->comment);
+    safe_free(param->group_comment);
+}
+
+/* add a comment to the last enumerator in the list */
+int
+comment_last_enumerator(list, comment)
+     EnumeratorList *list;
+     char *comment;
+{
+    if (list->last->comment)
+    {
+	if (list->last->group_comment)
+	{
+	    enumerator_error(list->last->name);
+	    free(comment);
+	    return 0;
+	}
+
+	list->last->group_comment = list->last->comment;
+    }
+
+    list->last->comment = comment;
+    return 1;
+}
+
+/* enum namespace management */
+void add_enum_symbol(name, enum_list)
+     char *name;
+     EnumeratorList *enum_list;
+{
+    Symbol *entry = new_symbol(enum_table, name, DS_NONE);
+    
+    if (entry)
+    {
+	entry->value.enum_list = enum_list;
+	entry->valtype = SYMVAL_ENUM;
+    }
+}
+
+/* look for the Enumerator list associated with the symbol */
+EnumeratorList *find_enum_symbol(name)
+     char *name;
+{
+    Symbol *entry = find_symbol(enum_table, name);
+    
+    if (entry)
+    	return entry->value.enum_list;
+    else
+    	return NULL;
+}
+
+void destroy_enum_lists()
+{
+    EnumeratorList *list, *next;
+    
+    /* free all the enumerator lists */
+    for (list = first_list; list; list = next)
+    {
+	next = list->next;
+	free_enumerator_list(list);
+	free(list);
+    }
+}
+
+/* create new typedef symbols */
+void new_typedef_symbols(decl_spec, decl_list)
+     DeclSpec *decl_spec;
+     DeclaratorList *decl_list;
+{
+    Declarator *d;
+    
+    for (d = decl_list->first; d; d = d-> next)
+    {
+	Symbol *s = new_symbol(typedef_names, d->name, DS_NONE);
+	
+	if (s && decl_spec->enum_list)
+	{
+	    s->value.enum_list = decl_spec->enum_list;
+	    s->valtype = SYMVAL_ENUM;
+	}
+    }
+}
+
+void enumerator_error(name)
+     char *name;
+{
+    yyerror("enumerator '%s' has multiple comments", name);
+}
diff --git a/enum.h b/enum.h
new file mode 100644
index 0000000..3e6606e
--- /dev/null
+++ b/enum.h
@@ -0,0 +1,41 @@
+/* $Id: enum.h,v 1.1 2004-05-03 05:17:48 behdad Exp $ */
+#include "config.h"
+
+extern SymbolTable *enum_table;	/* enum symbol table */
+
+/* Initialize a list of enumerators.*/
+EnumeratorList *
+new_enumerator_list _((Enumerator *enumerator));
+
+/* Add the enumerator to the list. */
+void
+add_enumerator_list _((EnumeratorList *list,   Enumerator *enumerator));
+
+/* Free storage used by the elements in the enumerator list. */
+void
+free_enumerator_list _((EnumeratorList *enumerator_list));
+
+void
+new_enumerator _((Enumerator *e, char *name,
+		char *comment_before, char *comment_after));
+
+/* Free the storage used by the enumerator.*/
+void
+free_enumerator _((Enumerator *param));
+
+/* add a comment to the last enumeralor in the list */
+int
+comment_last_enumerator _((EnumeratorList *enum_list, char *comment));
+
+/* enum namespace management */
+void add_enum_symbol _((char *name, EnumeratorList *first_enum));
+
+/* look for the first enumerator associated with the symbol */
+EnumeratorList *find_enum_symbol _((char *name));
+
+void destroy_enum_lists();
+
+/* create new typedef symbols */
+void new_typedef_symbols _((DeclSpec *decl_spec, DeclaratorList *decl_list));
+
+void enumerator_error _((char *name));
diff --git a/example.h b/example.h
new file mode 100644
index 0000000..61ac8d5
--- /dev/null
+++ b/example.h
@@ -0,0 +1,18 @@
+enum Place
+{
+    HOME,      /* Home, Sweet Home */
+    WORK,      /* where I spend lots of time */
+    MOVIES,    /* Saturday nights mainly */
+    CITY,      /* New York, New York */
+    COUNTRY    /* Bob's Country Bunker */
+};
+
+/*
+ * do some useful work for a change.
+ * This function will actually get some productive
+ * work done, if you are really lucky.
+ * returns the number of milliseconds in a second.
+ */
+int dowork(int count,        /* how much work to do */
+           enum Place where, /* where to do the work */
+           long fiveoclock   /* when to knock off */);
diff --git a/fixexamp.in b/fixexamp.in
new file mode 100644
index 0000000..7131705
--- /dev/null
+++ b/fixexamp.in
@@ -0,0 +1,60 @@
+# $Id: fixexamp.in,v 1.1 2004-05-03 05:17:49 behdad Exp $
+# Fix up c2man output for inclusion of examples in the c2man manual page.
+# This file gets processed to remove comments because some sed's can't handle
+# them. Can you believe it?.
+
+# The double backslashes in variable interpolations are because sed consumes
+# one, not because we're defining macros here (we aren't).
+
+# special hack: rename ctype_ex to ctype just to make that example neat.
+s/ctype_ex/ctype/
+
+# replace the .TH line with a title line.
+# we only alter the title length just as the title line is output so an example
+# that goes over a page break doesn't damage the real manual page's header.
+# Also, calculate and remember the shortened line length: groff doesn't reset
+# .ll in .SH & .TP macros, so we use an absolute value later rather than
+# relative changes.
+/^\.TH /{
+s/^\.TH "\([^"]*\)" \([^ ]*\) .*/.ds [H \1\\|(\\|\2\\|)/
+a\
+.ds [D UNIX Programmer's Manual\
+.po +1i\
+.lt -1.5i\
+.tl @\\*([H@\\*([D@\\*([H@\
+.lt +1.5i\
+.po -1i\
+.RS +1i\
+.nr CL \\n(.l-0.5i
+}
+
+# surround all the .SH and .SS lines with page offset indents
+# the .ne line will force a page break before the .po is evaluated, in the case
+# where a .SH in an example is at the very bottom of the page. Otherwise the .SH
+# could cause the break, resulting in the wrong .po setting for the new page's
+# title line.
+/^\.S[SH] /{
+i\
+.br\
+.ne 3\
+.RE\
+.po +1i
+a\
+.po -1i\
+.RS +1i\
+.ll \\n(CLu
+}
+
+# handle tagged paragraphs; .TP retains .RS setting, but resets .ll
+# since the parameter to .TP is on the next line, we read the next line in first
+/^.TP/{
+n
+a\
+.ll \\n(CLu
+}
+
+# up the line length again at the end of the example file
+$a\
+.ll \\n(CLu+0.5i\
+.RE
+
diff --git a/flatten.SH b/flatten.SH
new file mode 100644
index 0000000..4dafdc3
--- /dev/null
+++ b/flatten.SH
@@ -0,0 +1,51 @@
+case $CONFIG in
+'')
+	if test -f config.sh; then TOP=.;
+	elif test -f ../config.sh; then TOP=..;
+	elif test -f ../../config.sh; then TOP=../..;
+	elif test -f ../../../config.sh; then TOP=../../..;
+	elif test -f ../../../../config.sh; then TOP=../../../..;
+	else
+		echo "Can't find config.sh."; exit 1
+	fi
+	. $TOP/config.sh
+	;;
+esac
+: This forces SH files to create target in same directory as SH file.
+: This is so that make depend always knows where to find SH derivatives.
+case "$0" in
+*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
+esac
+echo "Extracting flatten.sed (with variable substitutions)"
+: This section of the file will have variable substitutions done on it.
+: Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!.
+: Protect any dollar signs and backticks that you do not want interpreted
+: by putting a backslash in front.  You may delete these comments.
+$spitshell >flatten.sed <<!GROK!THIS!
+s!\$(privlib)!$privlib!
+!GROK!THIS!
+
+: In the following dollars and backticks do not need the extra backslash.
+$spitshell >>flatten.sed <<'!NO!SUBS!'
+/^.so *example.h$/{
+r example.h
+d
+}
+
+/^.so *example.inc$/{
+r example.inc
+d
+}
+
+/^.so *ctype_ex.h$/{
+r ctype_ex.h
+d
+}
+
+/^.so *ctype_ex.inc$/{
+r ctype_ex.inc
+d
+}
+!NO!SUBS!
+chmod 755 flatten.sed
+$eunicefix flatten.sed
diff --git a/grammar.y b/grammar.y
new file mode 100644
index 0000000..9721dbe
--- /dev/null
+++ b/grammar.y
@@ -0,0 +1,947 @@
+/* $Id: grammar.y,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * yacc grammar for C manual page generator
+ * This was derived from the grammar given in Appendix A of
+ * "The C Programming Language" by Kernighan and Ritchie.
+ */
+
+/* identifiers that are not reserved words */
+%token T_IDENTIFIER T_TYPEDEF_NAME
+
+/* storage class */
+%token T_AUTO T_EXTERN T_REGISTER T_STATIC T_TYPEDEF
+/* This keyword included for compatibility with C++. */
+%token T_INLINE
+
+/* type specifiers */
+%token T_CHAR T_DOUBLE T_FLOAT T_INT T_VOID
+%token T_LONG T_SHORT T_SIGNED T_UNSIGNED
+%token T_ENUM T_STRUCT T_UNION
+
+/* type qualifiers */
+%token T_CONST T_VOLATILE
+/* These keywords included for compatibility with MSDOS C compilers. */
+%token T_CDECL T_FAR T_HUGE T_INTERRUPT T_NEAR T_PASCAL
+
+/* paired braces and everything between them: { ... } */
+%token T_BRACES
+
+/* paired square brackets and everything between them: [ ... ] */
+%token T_BRACKETS
+
+/* three periods */
+%token T_ELLIPSIS
+
+/* equal sign followed by constant expression or stuff between braces */
+%token T_INITIALIZER
+
+/* string literal */
+%token T_STRING_LITERAL
+
+/* text inside a regular comment, and one at the end of a non-empty line */
+%token T_COMMENT T_EOLCOMMENT
+
+%type <declaration> declaration
+%type <parameter> function_definition
+%type <decl_spec> declaration_specifiers declaration_specifier
+%type <decl_spec> storage_class type_specifier type_qualifier
+%type <decl_spec> struct_or_union_specifier enum_specifier
+%type <decl_list> declarator_list init_declarator_list
+%type <declarator> init_declarator declarator direct_declarator
+%type <declarator> parameter_declarator abstract_parameter_declarator
+%type <declarator> abstract_declarator direct_abstract_declarator
+%type <param_list> parameter_type_list parameter_list
+%type <parameter> parameter_declaration
+%type <param_list> opt_identifier_list identifier_list
+%type <enumerator> enumerator
+%type <enum_list> enumerator_list
+%type <identifier> identifier
+%type <text> struct_or_union
+%type <text> pointer type_qualifier_list
+%type <text> opt_comment opt_eolcomment
+%type <text> any_id T_IDENTIFIER T_TYPEDEF_NAME
+%type <text> T_BRACKETS
+%type <text> T_COMMENT T_EOLCOMMENT T_STRING_LITERAL
+
+%{
+#include "c2man.h"
+#include "semantic.h"
+#include "strconcat.h"
+#include "strappend.h"
+#include "manpage.h"
+#include "enum.h"
+
+#ifdef I_STDARG
+#include <stdarg.h>
+#endif
+#ifdef I_VARARGS
+#include <varargs.h>
+#endif
+
+int yylex();
+
+#define YYMAXDEPTH 150
+
+/* where are we up to scanning through an enum? */
+static enum { NOENUM, KEYWORD, BRACES } enum_state = NOENUM;
+
+/* Pointer to parameter list for the current function definition. */
+static ParameterList *func_params;
+
+/* Table of typedef names */
+SymbolTable *typedef_names;
+
+boolean first_comment;	/* are we still looking for the first comment? */
+static char *body_comment = NULL;/* last comment found at start of func body */
+%}
+%%
+
+program
+	: /* empty */
+	| translation_unit
+	;
+
+translation_unit
+	: external_declaration
+	| translation_unit external_declaration
+	;
+
+external_declaration
+	: declaration opt_eolcomment
+	{
+	    remember_declarations(NULL, &$1.decl_spec, &$1.decl_list, $2);
+	}
+	| T_COMMENT declaration opt_eolcomment
+	{
+	    remember_declarations($1, &$2.decl_spec, &$2.decl_list, $3);
+	}
+	| function_definition opt_eolcomment
+	{
+	    if (look_at_body_start && body_comment) {	
+				/* Use the body comment */
+	      new_manual_page(body_comment,&$1.decl_spec,$1.declarator);
+	      body_comment = NULL; /* Prevent it being free'ed */
+	    } else {
+	      free_declarator($1.declarator);
+	      free_decl_spec(&$1.decl_spec);
+	    }
+	}
+	| T_COMMENT function_definition opt_eolcomment
+	{
+	    if (body_start_only) {
+	      if (body_comment) {
+		new_manual_page(body_comment,&$2.decl_spec,$2.declarator);
+		body_comment = NULL; /* Prevent it being free'ed */
+	      } else {
+		free_declarator($2.declarator);
+		free_decl_spec(&$2.decl_spec);
+		safe_free($1);
+	      }      
+	    } else {
+	      new_manual_page($1,&$2.decl_spec,$2.declarator);
+	    }
+	    safe_free($3);
+	}
+	| function_definition ';' opt_eolcomment
+	{
+	    if (look_at_body_start && body_comment) {
+	      new_manual_page(body_comment,&$1.decl_spec,$1.declarator);
+	      body_comment = NULL; /* Prevent it being free'ed */
+	    } else {
+	      free_declarator($1.declarator);
+	      free_decl_spec(&$1.decl_spec);
+	    }
+	    safe_free($3);
+	}
+	| T_COMMENT function_definition ';' opt_eolcomment
+	{
+	    if (body_start_only) {
+	      if (body_comment) {
+		new_manual_page(body_comment,&$2.decl_spec,$2.declarator);
+		body_comment = NULL; /* Prevent it being free'ed */
+	      } else {
+		free_declarator($2.declarator);
+		free_decl_spec(&$2.decl_spec);
+		safe_free($1);
+	      }      
+	    } else {
+	      new_manual_page($1,&$2.decl_spec,$2.declarator);
+	    }
+	    safe_free($4);
+	}
+	| linkage_specification
+	| T_COMMENT T_EOLCOMMENT
+	{
+	    free($1);
+	    free($2);
+	}
+	| T_COMMENT
+	{
+	    if (inbasefile && first_comment)
+	    {
+		remember_terse($1);
+		first_comment = FALSE;
+	    }
+	    free($1);
+	}
+	| T_EOLCOMMENT
+	{
+	    free($1);
+	}
+	| error ';'
+	{
+	    yyerrok;
+	}
+	;
+
+linkage_specification
+	: T_EXTERN T_STRING_LITERAL T_BRACES
+	{
+	    /* Provide an empty action here so bison will not complain about
+	     * incompatible types in the default action it normally would
+	     * have generated.
+	     */
+	}
+	| T_EXTERN T_STRING_LITERAL declaration
+	{
+	    /* empty */
+	}
+	;
+
+function_definition
+	: declaration_specifiers declarator opt_eolcomment
+	{
+	    if ($2->type != DECL_FUNCTION) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &($2->head->params);
+            if ($3)	comment_last_parameter(&$2->head->params, $3);
+	}
+	  opt_declaration_list T_BRACES
+	{
+	    func_params = NULL;
+	    $2->type = DECL_FUNCDEF;
+
+	    $$.decl_spec = $1;
+	    $$.declarator = $2;
+	}
+	| declarator opt_eolcomment
+	{
+	    if ($1->type != DECL_FUNCTION) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &($1->head->params);
+            if ($2)	comment_last_parameter(&$1->head->params, $2);
+	}
+	  opt_declaration_list T_BRACES
+	{
+	    DeclSpec	decl_spec;
+
+	    func_params = NULL;
+	    $1->type = DECL_FUNCDEF;
+
+	    new_decl_spec(&$$.decl_spec, "int", DS_NONE);
+	    $$.declarator = $1;
+	}
+	;
+
+declaration
+	: declaration_specifiers ';'
+	{
+	    $$.decl_spec = $1;
+	    $$.decl_list.first = NULL;
+	}
+	| declaration_specifiers init_declarator_list ';'
+	{
+	    $$.decl_spec = $1;
+	    $$.decl_list = $2;
+	}
+	| T_TYPEDEF declaration_specifiers declarator_list ';'
+	{
+	    new_typedef_symbols(&$2,&$3);
+	    $$.decl_spec = $2;
+	    $$.decl_list = $3;
+	}
+	;
+
+declarator_list
+	: declarator
+	{
+	    new_decl_list(&$$, $1);
+	}
+        | declarator_list ',' opt_eolcomment declarator
+        {
+            if ($3)	comment_last_decl(&$1, $3);
+            add_decl_list(&$$, &$1, $4);
+        }
+        | declarator_list opt_eolcomment
+        {
+            $$ = $1;
+            if ($2)	comment_last_decl(&$1, $2);
+        }
+	;
+
+opt_declaration_list
+	: /* empty */
+	| declaration_list
+	| declaration_list T_ELLIPSIS
+	;
+
+declaration_list
+	: opt_comment declaration opt_eolcomment
+	{
+	    set_param_types(func_params, &$2.decl_spec, &$2.decl_list, $1, $3);
+	}
+	| declaration_list opt_comment declaration opt_eolcomment
+	{
+	    set_param_types(func_params, &$3.decl_spec, &$3.decl_list, $2, $4);
+	}
+	;
+
+declaration_specifiers
+	: declaration_specifier
+	| declaration_specifiers declaration_specifier
+	{
+	    join_decl_specs(&$$, &$1, &$2);
+	}
+	;
+
+declaration_specifier
+	: storage_class
+	| type_specifier
+	| type_qualifier
+	;
+
+storage_class
+	: T_AUTO
+	{
+	    new_decl_spec(&$$, "auto", DS_NONE);
+	}
+	| T_EXTERN
+	{
+	    new_decl_spec(&$$, "extern", DS_EXTERN);
+	}
+	| T_REGISTER
+	{
+	    new_decl_spec(&$$, "register", DS_NONE);
+	}
+	| T_STATIC
+	{
+	    new_decl_spec(&$$, "static", DS_STATIC);
+	}
+	| T_INLINE
+	{
+	    new_decl_spec(&$$, "inline", DS_INLINE);
+	}
+	;
+
+type_specifier
+	: T_CHAR
+	{
+	    new_decl_spec(&$$, "char", DS_CHAR);
+	}
+	| T_DOUBLE
+	{
+	    new_decl_spec(&$$, "double", DS_NONE);
+	}
+	| T_FLOAT
+	{
+	    new_decl_spec(&$$, "float", DS_FLOAT);
+	}
+	| T_INT
+	{
+	    new_decl_spec(&$$, "int", DS_NONE);
+	}
+	| T_LONG
+	{
+	    new_decl_spec(&$$, "long", DS_NONE);
+	}
+	| T_SHORT
+	{
+	    new_decl_spec(&$$, "short", DS_SHORT);
+	}
+	| T_SIGNED
+	{
+	    new_decl_spec(&$$, "signed", DS_NONE);
+	}
+	| T_UNSIGNED
+	{
+	    new_decl_spec(&$$, "unsigned", DS_NONE);
+	}
+	| T_VOID
+	{
+	    new_decl_spec(&$$, "void", DS_NONE);
+	}
+	| struct_or_union_specifier
+	| enum_specifier
+	| T_TYPEDEF_NAME
+	{
+	    Symbol *s = find_symbol(typedef_names, $1);
+	   
+	    new_enum_decl_spec(&$$, $1, s->flags,
+		s->valtype == SYMVAL_ENUM ? s->value.enum_list
+					  : (EnumeratorList *)NULL);
+	}
+	;
+
+type_qualifier
+	: T_CONST
+	{
+	    new_decl_spec(&$$, "const", DS_NONE);
+	}
+	| T_VOLATILE
+	{
+	    new_decl_spec(&$$, "volatile", DS_NONE);
+	}
+	| T_CDECL
+	{
+	    new_decl_spec(&$$, "cdecl", DS_NONE);
+	}
+	| T_INTERRUPT
+	{
+	    new_decl_spec(&$$, "interrupt", DS_NONE);
+	}
+	| T_FAR
+	{
+	    new_decl_spec(&$$, "far", DS_NONE);
+	}
+	| T_HUGE
+	{
+	    new_decl_spec(&$$, "huge", DS_NONE);
+	}
+	| T_NEAR
+	{
+	    new_decl_spec(&$$, "near", DS_NONE);
+	}
+	| T_PASCAL
+	{
+	    new_decl_spec(&$$, "pascal", DS_NONE);
+	}
+	;
+
+struct_or_union_specifier
+	: struct_or_union any_id T_BRACES
+	{
+	    dyn_decl_spec(&$$, strconcat($1, " ",$2," {}",NULLCP), DS_NONE);
+	    free($2);
+	}
+	| struct_or_union T_BRACES
+	{
+	    dyn_decl_spec(&$$, strconcat($1," {}",NULLCP), DS_NONE);
+	}
+	| struct_or_union any_id
+	{
+	    dyn_decl_spec(&$$, strconcat($1, " ",$2,NULLCP), DS_NONE);
+	    free($2);
+	}
+	;
+
+struct_or_union
+	: T_STRUCT
+	{
+	    $$ = "struct";
+	}
+	| T_UNION
+	{
+	    $$ = "union";
+	}
+	;
+
+init_declarator_list
+	: init_declarator
+	{
+	    new_decl_list(&$$, $1);
+	}
+        | init_declarator_list ',' opt_eolcomment init_declarator
+        {
+            if ($3)	comment_last_decl(&$1, $3);
+            add_decl_list(&$$, &$1, $4);
+        }
+        | init_declarator_list opt_eolcomment
+        {
+            $$ = $1;
+            if ($2)	comment_last_decl(&$1, $2);
+        }
+	;
+
+init_declarator
+	: declarator
+	| declarator T_INITIALIZER
+	;
+
+enum_specifier
+	: T_ENUM any_id '{' opt_eolcomment enumerator_list '}'
+	{
+	    add_enum_symbol($2, $5);
+	    new_enum_decl_spec(&$$, strconcat("enum ",$2," {}",NULLCP),
+		   DS_NONE, $5);
+	    free($2);
+	    safe_free($4);
+	    enum_state = NOENUM;
+	}
+	| T_ENUM '{' opt_eolcomment enumerator_list '}'
+	{
+	    new_enum_decl_spec(&$$, strduplicate("enum {}"), DS_NONE, $4);
+	    safe_free($3);
+	    enum_state = NOENUM;
+	}
+	| T_ENUM any_id
+	{
+	    new_enum_decl_spec(&$$, strconcat("enum ",$2,NULLCP), DS_NONE,
+	    	find_enum_symbol($2));
+	    free($2);
+	    enum_state = NOENUM;
+	}
+	;
+
+enumerator_list
+	: enumerator
+	{
+	    $$ = new_enumerator_list(&$1);
+	}
+	| enumerator_list ',' opt_eolcomment enumerator
+	{
+	    $$ = $1;
+	    if ($3)	comment_last_enumerator($$, $3);
+	    add_enumerator_list($$, &$4);
+	}
+	| enumerator_list opt_eolcomment
+	{
+	    $$ = $1;
+	    if ($2)	comment_last_enumerator($$, $2);
+	}
+	| enumerator_list ',' opt_eolcomment
+	{
+	    $$ = $1;
+	    if ($3)     comment_last_enumerator($$, $3);
+	}
+	;
+	
+enumerator
+	: identifier
+	{
+	    new_enumerator(&$$,$1.name,$1.comment_before,$1.comment_after);
+	}
+	;
+	
+any_id
+	: T_IDENTIFIER
+	| T_TYPEDEF_NAME
+	| any_id T_COMMENT
+	{
+	    $$ = $1;
+	    free($2);
+	}
+	| any_id T_EOLCOMMENT
+	{
+	    $$ = $1;
+	    free($2);
+	}
+	;
+
+declarator
+	: pointer T_EOLCOMMENT direct_declarator
+	{
+	    char *newtext = strappend($1,$3->text,NULLCP);
+	    free($3->text);
+	    $$ = $3;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	    $$->retcomment = $2;
+	}
+	| pointer direct_declarator
+	{
+	    char *newtext = strappend($1,$2->text,NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	}
+	| T_EOLCOMMENT direct_declarator
+	{
+	    $$ = $2;
+	    $$->retcomment = $1;
+	}
+	| direct_declarator
+	{
+	    $$ = $1;
+	}
+	;
+
+parameter_declarator
+	: pointer direct_declarator
+	{
+	    char *newtext = strappend($1,$2->text,NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	}
+	| direct_declarator
+	{
+	    $$ = $1;
+	}
+	;
+
+direct_declarator
+	: T_IDENTIFIER
+	{
+	    $$ = new_declarator($1, strduplicate($1));
+	}
+	| '(' declarator ')'
+	{
+	    char *newtext = strconcat("(",$2->text,")",NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	}
+	| direct_declarator T_BRACKETS
+	{
+	    $$ = $1;
+	    $$->text = strappend($1->text,$2,NULLCP);
+	    free($2);
+	}
+	| direct_declarator '(' parameter_type_list ')'
+	{
+	    $$ = new_declarator(strduplicate("%s()"), strduplicate($1->name));
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->type = ($1->type == DECL_SIMPLE) ? DECL_FUNCTION : $1->type;
+	}
+	| direct_declarator '(' opt_identifier_list ')'
+	{
+	    $$ = new_declarator(strduplicate("%s()"), strduplicate($1->name));
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->type = ($1->type == DECL_SIMPLE) ? DECL_FUNCTION : $1->type;
+	}
+	;
+
+pointer
+	: '*' type_qualifier_list
+	{
+	    $$ = strconcat("*",$2, NULLCP);
+	    safe_free($2);
+	}
+	| '*' type_qualifier_list pointer
+	{
+	    $$ = $2 ? strconcat("*",$2, $3, NULLCP)
+		    : strconcat("*", $3, NULLCP);
+	    safe_free($2);
+	    free($3);
+	}
+	;
+
+type_qualifier_list
+	: /* empty */
+	{
+	    $$ = NULL;
+	}
+	| type_qualifier_list type_qualifier
+	{
+	    $$ = $1 ? strconcat($1," ",$2.text," ",NULLCP)
+		    : strconcat($2.text," ",NULLCP);
+	    safe_free($1);
+	    free_decl_spec(&$2);
+	}
+	;
+
+parameter_type_list
+	: parameter_list opt_eolcomment
+	{
+	    $$ = $1;
+	    if ($2)	comment_last_parameter(&$1, $2);
+	}
+	| parameter_list ',' opt_eolcomment
+		opt_comment T_ELLIPSIS opt_comment opt_eolcomment
+	{
+	    Identifier ellipsis;
+
+	    if ($3)	comment_last_parameter(&$1, $3);
+	    ellipsis.name = strduplicate("...");
+
+	    if ($4 && $6 && $7)
+	    {
+		yyerror("ellipsis parameter has multiple comments");
+		free($7);
+		free($6);
+		free($4);
+		ellipsis.comment_before = ellipsis.comment_after = NULL;
+	    }
+	    else
+	    {
+		ellipsis.comment_before = $4;
+		ellipsis.comment_after = $6 ? $6 : $7;
+	    }
+
+	    add_ident_list(&$$, &$1, &ellipsis);
+	}
+	;
+
+parameter_list
+	: parameter_declaration
+	{
+	    new_param_list(&$$, &$1);
+	}
+	| parameter_list ',' opt_eolcomment parameter_declaration
+	{
+	    if ($3)	comment_last_parameter(&$1, $3);
+	    add_param_list(&$$, &$1, &$4);
+	}
+	;
+
+parameter_declaration
+	: opt_comment declaration_specifiers parameter_declarator opt_comment
+	{
+	    new_parameter(&$$, &$2, $3, $1, $4);
+	}
+	| opt_comment declaration_specifiers abstract_parameter_declarator opt_comment
+	{
+	    new_parameter(&$$, &$2, $3, $1, $4);
+	}
+	| opt_comment declaration_specifiers opt_comment
+	{
+	    new_parameter(&$$, &$2, (Declarator *)NULL, $1, $3);
+	}
+	;
+
+opt_identifier_list
+	: /* empty */
+	{
+	    new_ident_list(&$$);
+	}
+	| identifier_list opt_eolcomment
+	{
+	    $$ = $1;
+	    if ($2)	comment_last_parameter(&$1, $2);
+	}
+	;
+
+identifier_list
+	: identifier
+	{
+	    new_ident_list(&$$);
+	    add_ident_list(&$$, &$$, &$1);
+	}
+	| identifier_list ',' opt_eolcomment identifier
+	{
+	    if ($3)	comment_last_parameter(&$1, $3);
+	    add_ident_list(&$$, &$1, &$4);
+	}
+	;
+
+identifier
+	: opt_comment T_IDENTIFIER opt_comment
+	{
+	    $$.comment_before = $1;
+	    $$.comment_after = $3;
+	    $$.name = $2;
+	}
+	
+abstract_declarator
+	: pointer
+	{
+	    $$ = new_declarator($1, NULLCP);
+	}
+	| pointer T_EOLCOMMENT direct_abstract_declarator
+	{
+	    char *newtext = strappend($1,$3->text,NULLCP);
+	    free($3->text);
+	    $$ = $3;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	    $$->retcomment = $2;
+	}
+	| pointer direct_abstract_declarator
+	{
+	    char *newtext = strappend($1,$2->text,NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	}
+	| T_EOLCOMMENT direct_abstract_declarator
+	{
+	    $$ = $2;
+	    $$->retcomment = $1;
+	}
+	| direct_abstract_declarator
+	{
+	    $$ = $1;
+	}
+	;
+
+abstract_parameter_declarator
+	: pointer
+	{
+	    $$ = new_declarator($1, NULLCP);
+	}
+	| pointer direct_abstract_declarator
+	{
+	    char *newtext = strappend($1,$2->text,NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	    if ($$->type == DECL_SIMPLE)
+		$$->type = DECL_COMPOUND;
+	}
+	| direct_abstract_declarator
+	{
+	    $$ = $1;
+	}
+	;
+
+direct_abstract_declarator
+	: '(' abstract_declarator ')'
+	{
+	    char *newtext = strconcat("(",$2->text,")",NULLCP);
+	    free($2->text);
+	    $$ = $2;
+	    $$->text = newtext;
+	}
+	| direct_abstract_declarator T_BRACKETS
+	{
+	    $$ = $1;
+	    $$->text = strappend($1->text,$2,NULLCP);
+	    free($2);
+	}
+	| T_BRACKETS
+	{
+	    $$ = new_declarator($1, NULLCP);
+	}
+	| direct_abstract_declarator '(' parameter_type_list ')'
+	{
+	    $$ = new_declarator(strduplicate("%s()"), NULLCP);
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->type = ($1->type == DECL_SIMPLE) ? DECL_FUNCTION : $1->type;
+	}
+	| direct_abstract_declarator '(' ')'
+	{
+	    $$ = new_declarator(strduplicate("%s()"), NULLCP);
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->type = ($1->type == DECL_SIMPLE) ? DECL_FUNCTION : $1->type;
+	}
+	| '(' parameter_type_list ')'
+	{
+	    Declarator *d;
+	    
+	    d = new_declarator(NULL, NULL);
+	    $$ = new_declarator(strduplicate("%s()"), NULLCP);
+	    $$->params = $2;
+	    $$->func_stack = d;
+	    $$->head = $$;
+	}
+	| '(' ')'
+	{
+	    Declarator *d;
+	    
+	    d = new_declarator(NULL, NULL);
+	    $$ = new_declarator(strduplicate("%s()"), NULLCP);
+	    $$->func_stack = d;
+	    $$->head = $$;
+	}
+	;
+
+opt_comment
+	: /* empty */
+	{
+	    $$ = NULL;
+	}
+	| T_COMMENT
+	;
+
+opt_eolcomment
+	: /* empty */
+	{
+	    $$ = NULL;
+	}
+	| T_EOLCOMMENT
+	;
+
+%%
+#ifdef MSDOS
+#include "lex_yy.c"
+#else
+#ifdef VMS
+#include "lexyy.c"
+#else
+#include "lex.yy.c"
+#endif /* !VMS   */
+#endif /* !MSDOS */
+
+#ifdef I_STDARG
+void yyerror(const char *format, ...)
+#else
+void yyerror(va_alist)
+    va_dcl
+#endif
+{
+#ifndef I_STDARG
+    const char *format;
+#endif
+    va_list args;
+
+    output_error();
+
+#ifdef I_STDARG
+    va_start(args, format);
+#else
+    va_start(args);
+    format = va_arg(args, char *);
+#endif
+
+    vfprintf(stderr, format, args);
+    va_end(args);
+    putc('.',stderr);
+    putc('\n',stderr);
+}
+
+void
+parse_file (start_file)
+const char *start_file;
+{
+    const char *s;
+#ifdef FLEX_SCANNER
+    static boolean restart = FALSE;
+#endif
+
+    cur_file = start_file ? strduplicate(start_file) : NULL;
+
+    if (basefile && strlen(basefile) > 2) {
+	s = basefile + strlen(basefile) - 2;
+	if (strcmp(s, ".l") == 0 || strcmp(s, ".y") == 0)
+	    BEGIN LEXYACC;
+    }
+
+    typedef_names = create_symbol_table();
+    enum_table = create_symbol_table();
+
+    line_num = 1;
+    ly_count = 0;
+    first_comment = group_together && !terse_specified;
+
+    /* flex needs a yyrestart before every file but the first */
+#ifdef FLEX_SCANNER
+    if (restart)	yyrestart(yyin);
+    restart = TRUE;
+#endif
+
+    yyparse();
+
+    destroy_symbol_table(enum_table);
+    destroy_symbol_table(typedef_names);
+
+    safe_free(cur_file);
+}
diff --git a/html.c b/html.c
new file mode 100644
index 0000000..4fc4112
--- /dev/null
+++ b/html.c
@@ -0,0 +1,453 @@
+/* $Id: html.c,v 1.1 2004-05-03 05:17:49 behdad Exp $
+ * functions for html style output.
+ */
+#include "c2man.h"
+#include "manpage.h"
+#include "output.h"
+#include <ctype.h>
+
+static int html_in_code = 0;
+
+void html_terse_sep();
+void html_description _((const char *text));
+
+void html_char(c)
+const int c;
+{
+  switch (c)
+  {
+  case '<':
+    put_string("&lt;");
+    break;
+  case '>':
+    put_string("&gt;");
+    break;
+  case '&':
+    put_string("&amp;");
+    break;
+  case '"':
+    put_string("&quot;");
+    break;
+  default:
+    putchar(c);
+    break;
+  }
+}
+
+void html_text(text)
+const char *text;
+{
+  while(*text)
+  {
+    html_char(*text++);
+  }
+}
+
+
+void html_comment()
+{
+  put_string("<!");
+}
+
+void html_header(firstpage, input_files, grouped, name, terse, section)
+   ManualPage         *firstpage;
+   int                 input_files;
+   boolean             grouped;
+   const char         *name;
+   const char         *terse;
+   const char         *section;
+{
+
+  output_warning();
+  put_string("<header>\n");
+  put_string("<title>");
+  html_text(name);
+  html_terse_sep();
+  html_text(terse);
+  put_string("</title>\n");
+  put_string("</header>\n");
+  put_string("<body>\n");
+}
+
+void html_file_end()
+{
+  put_string("\n</body>\n");
+}
+
+void html_dash()
+{
+  put_string("-");
+}
+
+void html_section(name)
+const char         *name;
+{
+  put_string("<h1>");
+  html_text(name);
+  put_string("</h1>\n");
+}
+
+void html_sub_section(name)
+const char *name;
+{
+  put_string("<h2>");
+  html_text(name);
+  put_string("</h2>");
+}
+
+void html_break_line()
+{
+  if (!html_in_code)
+  {
+    put_string("<br>\n");
+  }
+}
+
+void html_blank_line()
+{
+  if (!html_in_code)
+  {
+    put_string("<p>\n");
+  }
+  else
+  {
+    putchar('\n');
+  }
+}
+
+void html_code_start()
+{
+  put_string("<pre>");
+  html_in_code = 1;
+}
+
+void html_code_end()
+{
+  put_string("</pre>\n");
+  html_in_code = 0;
+}
+
+void html_code(text)
+const char *text;
+{
+  html_code_start();
+  html_text(text);
+  html_code_end();
+}
+
+void html_tag_list_start()
+{
+  put_string("<dl>");
+}
+
+void html_tag_list_end()
+{
+  put_string("</dl>\n");
+}
+
+void html_tag_entry_start()
+{   
+  put_string("<dt>\n");
+}   
+    
+void html_tag_entry_start_extra()
+{   
+  put_string("<dt>\n");
+}   
+    
+void html_tag_entry_end()
+{
+  put_string("<dd>\n");
+}
+
+void html_tag_entry_end_extra(text)
+const char *text;
+{
+  put_string(" <em>");
+  put_string(text);
+  put_string("</em>)");
+  put_string("<dd>\n");
+}
+
+void html_table_start(longestag)
+const char *longestag;
+{
+  put_string("<ul>");
+}
+
+void html_table_entry(name, description)
+const char         *name;
+const char         *description;
+{
+  put_string("<li>");
+  html_text(name);
+  if (description)
+  {
+    html_terse_sep();
+    html_description(description);
+  }
+  put_string("<p>\n");
+}
+
+void html_table_end()
+{
+  put_string("</ul>");
+}
+
+void html_indent()
+{
+  put_string("\t");
+}
+
+void html_list_start()
+{
+  put_string("<ul>");
+}
+
+
+void html_list_end()
+{
+  put_string("</ul>");
+}
+
+void html_list_entry(name)
+const char *name;
+{
+  put_string("<li>");
+  put_string(name);
+  put_string("\n");
+}
+
+void html_list_separator()
+{
+  put_string(",\n");
+}
+
+void html_include(filename)
+const char *filename;
+{
+  printf(".so %s\n", filename);
+}
+
+void html_name(name)
+const char *name;
+{
+  if (name)
+    html_text(name);
+  else
+    html_section("NAME");
+}
+
+void html_terse_sep()
+{
+  html_char(' ');
+  html_dash();
+  html_char(' ');
+}
+
+void html_reference(name)
+const char *name;
+{
+  put_string("<a href=");
+  put_string(name);
+  put_string(".html>");
+  put_string(name);
+  put_string("</a>\n");
+}  
+
+void html_emphasized(text)
+const char *text;
+{
+  put_string("<em>");
+  put_string(text);
+  put_string("</em>");
+}
+
+/* ideally, this should be made aware of embedded html commands */
+void html_description(text)
+const char *text;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    boolean new_line = TRUE;
+    
+    /* correct punctuation a bit as it goes out */
+    for (;*text;text++)
+    {
+	int c = *text;
+
+	if (new_line && (c == '-' || c == '*' || c == '\n' ||
+							    is_numbered(text)))
+	{
+	    output->break_line();
+	    state = CAPITALISE;
+	}
+	else if (new_line && c == '\n') {  /* Two newlines - Paragraph break */
+	    output->blank_line();
+	}
+	else if (c == '.')
+	    state = PERIOD;
+	else if (isspace(c) && state == PERIOD)
+	    state = CAPITALISE;
+	else if (isalnum(c))
+	{   
+	    if (islower(c) && state == CAPITALISE)	c = toupper(c);
+	    state = TEXT;
+	}
+           
+	output->character(c);
+	new_line = c == '\n';
+    }
+
+    /* do a full stop if there wasn't one */
+    if (state == TEXT)	output->character('.');
+}
+
+/* ideally, this should be made aware of embedded html commands */
+void
+html_returns(comment)
+const char *comment;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    char lastchar = '\n';
+    boolean tag_list_started = FALSE;
+
+    /* for each line... */
+    while (*comment)
+    {
+	boolean tagged = FALSE;
+
+	{
+	    const char *c = comment;
+
+	    /* search along until the end of a word */
+	    while (*c && *c != ':' && !isspace(*c))
+		c++;
+
+	    /* skip all spaces or tabs after the first word */
+	    while (*c && *c != '\n')
+	    {
+		if (*c == '\t' || *c == ':')
+		{
+		    tagged = TRUE;
+		    break;
+		}
+		else if (!isspace(*c))
+		    break;
+
+		c++;
+	    }
+	}
+
+	/* is it tagged?; explicitly reject dot commands */
+	if (tagged)
+	{
+	    /* output lingering newline if necessary */
+	    if (lastchar != '\n')
+	    {
+		if (state == TEXT && !ispunct(lastchar))	output->character('.');
+		output->character(lastchar = '\n');
+	    }
+
+	    if (!tag_list_started)
+	    {
+		output->tag_list_start();
+		tag_list_started = TRUE;
+	    }
+
+	    /* output the taggy bit */
+	    output->tag_entry_start();
+	    while (*comment && *comment != ':' && !isspace(*comment))
+		output->character(*comment++);
+	    output->tag_entry_end();
+
+	    /* skip any extra tabs or spaces */
+	    while (*comment == ':' || (isspace(*comment) && *comment != '\n'))
+		comment++;
+
+	    state = CAPITALISE;
+	}
+
+	/* terminate the previous line if necessary */
+	if (lastchar != '\n')	output->character(lastchar = '\n');
+
+	/* correct punctuation a bit as the line goes out */
+	for (;*comment && *comment != '\n'; comment++)
+	{
+	    char c = *comment;
+
+	    if (c == '.')
+		state = PERIOD;
+	    else if (isspace(c) && state == PERIOD)
+		state = CAPITALISE;
+	    else if (isalnum(c))
+	    {   
+		if (islower(c) && state == CAPITALISE && fixup_comments)
+		    c = toupper(c);
+		state = TEXT;
+	    }
+
+	    output->character(lastchar = c);
+	}
+
+	/* if it ended in punctuation, just output the nl straight away. */
+	if (ispunct(lastchar))
+	{
+	    if (lastchar == '.')	state = CAPITALISE;
+	    output->character(lastchar = '\n');
+	}
+
+	if (*comment)	comment++;
+    }
+
+    /* output lingering newline if necessary */
+    if (lastchar != '\n')
+    {
+	if (state == TEXT && !ispunct(lastchar) && fixup_comments)
+	    output->character('.');
+	output->character('\n');
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+
+struct Output       html_output =
+{
+  html_comment,
+  html_header,
+  html_dash,
+  html_section,
+  html_sub_section,
+  html_break_line,
+  html_blank_line,
+  html_code_start,
+  html_code_end,
+  html_code,
+  html_tag_list_start,
+  html_tag_list_end,
+  html_tag_entry_start,
+  html_tag_entry_start_extra,
+  html_tag_entry_end,
+  html_tag_entry_end_extra,
+  html_table_start,
+  html_table_entry,
+  html_table_end,
+  html_indent,
+  html_list_start,
+  html_list_entry,
+  html_list_separator,
+  html_list_end,
+  html_include,
+  html_file_end,
+  html_text,
+  html_char,
+  NULL,				/* html_parse_option */
+  dummy,			/* html_print_options */
+  html_name,
+  html_terse_sep,
+  html_reference,      
+  html_emphasized,
+  html_description,
+  html_returns
+  };
diff --git a/latex.c b/latex.c
new file mode 100644
index 0000000..ace199c
--- /dev/null
+++ b/latex.c
@@ -0,0 +1,356 @@
+/* $Id: latex.c,v 1.1 2004-05-03 05:17:49 behdad Exp $
+ * functions for LaTeX style output.
+ */
+#include "c2man.h"
+#include "manpage.h"
+#include "output.h"
+#include <ctype.h>
+
+static boolean verbatim = FALSE;	/* skip quoting in verbatim section */
+
+void latex_char(c)
+const int c;
+{
+    int i;
+
+    switch (c)
+    {
+    case '$':
+    case '#':
+    case '&':
+    case '^':
+    case '_':
+	if (!verbatim)
+	    putchar('\\');
+	putchar(c);
+	break;
+    case '>':
+    case '<':
+	if (!verbatim)
+	    putchar('$');
+	putchar(c);
+	if (!verbatim)
+	    putchar('$');
+	break;
+    case '\t':
+	for (i = 0; i < NUM_TAB_SPACES; i++)
+	    putchar(' ');
+	break;
+    default:
+	putchar(c);
+	break;
+    }
+}
+
+void latex_text(text)
+const char *text;
+{
+    while(*text)
+	latex_char(*text++);
+}
+
+void latex_comment() { put_string("% "); }
+
+void latex_header(firstpage, input_files, grouped, name, terse, section)
+ManualPage *firstpage;
+int input_files;
+boolean grouped;
+const char *name;
+const char *terse;
+const char *section;
+{
+    if (make_embeddable) return;
+
+    put_string("\\documentstyle{article}\n");
+    output_warning();
+	put_string("\\begin{document}\n");
+}
+
+void latex_dash()	{ put_string("---"); }
+
+void latex_section(name)
+const char *name;
+{
+    put_string("\\section*{");
+    latex_text(name);
+    put_string("}\n");
+}
+
+void latex_sub_section(name)
+const char *name;
+{
+    put_string("\\subsection*{");
+    latex_text(name);
+    put_string("}\n");
+}
+
+void latex_break_line() { /* put_string("\\newline\n"); */ }
+void latex_blank_line() { put_string("\n"); }
+
+void latex_code_start() { put_string("\\begin{verbatim}\n"); verbatim = TRUE; }
+void latex_code_end()	{ put_string("\\end{verbatim}\n"); verbatim = FALSE; }
+
+void latex_code(text)
+const char *text;
+{
+    put_string("\\verb`");
+    put_string(text);
+    put_string("`");
+}
+
+void latex_tag_list_start()	{ put_string("\\begin{description}\n"); }
+void latex_tag_entry_start()	{ put_string("\\item["); }
+void latex_tag_entry_end()	{ put_string("]\\hfill\\newline\n"); }
+void latex_tag_entry_end_extra(text)
+const char *text;
+{
+    put_string("(");
+    latex_text(text);
+    put_string(")");
+	latex_tag_entry_end();
+}
+void latex_tag_list_end()	{ put_string("\\end{description}\n"); }
+	
+void latex_table_start(longestag)
+const char *longestag;
+{ put_string("\\begin{description}\n"); }
+
+void latex_table_entry(name, description)
+const char *name;
+const char *description;
+{
+    put_string("\\item[");
+    latex_text(name);
+    put_string("]\n");
+    if (description)
+	output_comment(description);
+    else
+	latex_char('\n');
+}
+
+void latex_table_end()	{ put_string("\\end{description}\n"); }
+
+void latex_list_entry(text)
+const char *text;
+{
+    latex_text(text);
+}
+void latex_list_separator() { put_string(",\n"); }
+void latex_list_end()	{ latex_char('\n'); }
+
+void latex_include(filename)
+const char *filename;
+{
+	put_string("\\include{");
+	latex_text(filename);
+	put_string("}\n");
+}
+
+void latex_file_end() { put_string("\\end{document}\n"); }
+
+void latex_name(name)
+const char *name;
+{
+    if (name) latex_text(name);
+    else      latex_section("NAME");
+}
+
+void latex_terse_sep()
+{
+    latex_char(' ');
+    latex_dash();
+    latex_char(' ');
+}
+
+void latex_reference(text)
+const char *text;
+{
+    latex_text(text);
+    latex_char('(');
+    latex_text(manual_section);
+    latex_char(')');
+}
+
+/* ideally, this should be made aware of embedded latex commands */
+void latex_description(text)
+const char *text;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    boolean new_line = TRUE;
+    
+    /* correct punctuation a bit as it goes out */
+    for (;*text;text++)
+    {
+	int c = *text;
+
+	if (new_line && (c == '-' || c == '*'))
+	{
+	    output->break_line();
+	    state = CAPITALISE;
+	}
+	else if (c == '.')
+	    state = PERIOD;
+	else if (isspace(c) && state == PERIOD)
+	    state = CAPITALISE;
+	else if (isalnum(c))
+	{   
+	    if (islower(c) && state == CAPITALISE)	c = toupper(c);
+	    state = TEXT;
+	}
+           
+	output->character(c);
+	new_line = c == '\n';
+    }
+
+    /* do a full stop if there wasn't one */
+    if (state == TEXT)	output->character('.');
+}
+
+/* ideally, this should be made aware of embedded latex commands */
+void
+latex_returns(comment)
+const char *comment;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    char lastchar = '\n';
+    boolean tag_list_started = FALSE;
+
+    /* for each line... */
+    while (*comment)
+    {
+	boolean tagged = FALSE;
+
+	{
+	    const char *c = comment;
+
+	    /* search along until the end of a word */
+	    while (*c && *c != ':' && !isspace(*c))
+		c++;
+
+	    /* skip all spaces or tabs after the first word */
+	    while (*c && *c != '\n')
+	    {
+		if (*c == '\t' || *c == ':')
+		{
+		    tagged = TRUE;
+		    break;
+		}
+		else if (!isspace(*c))
+		    break;
+
+		c++;
+	    }
+	}
+
+	/* is it tagged?; explicitly reject dot commands */
+	if (tagged)
+	{
+	    /* output lingering newline if necessary */
+	    if (lastchar != '\n')
+	    {
+		if (state == TEXT && !ispunct(lastchar))	output->character('.');
+		output->character(lastchar = '\n');
+	    }
+
+	    if (!tag_list_started)
+	    {
+		output->tag_list_start();
+		tag_list_started = TRUE;
+	    }
+
+	    /* output the taggy bit */
+	    output->tag_entry_start();
+	    while (*comment && *comment != ':' && !isspace(*comment))
+		output->character(*comment++);
+	    output->tag_entry_end();
+
+	    /* skip any extra tabs or spaces */
+	    while (*comment == ':' || (isspace(*comment) && *comment != '\n'))
+		comment++;
+
+	    state = CAPITALISE;
+	}
+
+	/* terminate the previous line if necessary */
+	if (lastchar != '\n')	output->character(lastchar = '\n');
+
+	/* correct punctuation a bit as the line goes out */
+	for (;*comment && *comment != '\n'; comment++)
+	{
+	    char c = *comment;
+
+	    if (c == '.')
+		state = PERIOD;
+	    else if (isspace(c) && state == PERIOD)
+		state = CAPITALISE;
+	    else if (isalnum(c))
+	    {   
+		if (islower(c) && state == CAPITALISE && fixup_comments)
+		    c = toupper(c);
+		state = TEXT;
+	    }
+
+	    output->character(lastchar = c);
+	}
+
+	/* if it ended in punctuation, just output the nl straight away. */
+	if (ispunct(lastchar))
+	{
+	    if (lastchar == '.')	state = CAPITALISE;
+	    output->character(lastchar = '\n');
+	}
+
+	if (*comment)	comment++;
+    }
+
+    /* output lingering newline if necessary */
+    if (lastchar != '\n')
+    {
+	if (state == TEXT && !ispunct(lastchar) && fixup_comments)
+	    output->character('.');
+	output->character('\n');
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+struct Output latex_output =
+{
+    latex_comment,
+    latex_header,
+    latex_dash,
+    latex_section,
+    latex_sub_section,
+    latex_break_line,
+    latex_blank_line,
+    latex_code_start,
+    latex_code_end,
+    latex_code,
+    latex_tag_list_start,
+    latex_tag_list_end,
+    latex_tag_entry_start,
+    latex_tag_entry_start,	/* entry_start_extra */
+    latex_tag_entry_end,
+    latex_tag_entry_end_extra,
+    latex_table_start,
+    latex_table_entry,
+    latex_table_end,
+    dummy,		/* latex_indent */
+    dummy,		/* latex_list_start */
+    latex_list_entry,
+    latex_list_separator,
+    latex_list_end,
+    latex_include,
+    latex_file_end,
+    latex_text,
+    latex_char,
+    NULL,		/* latex_parse_option */
+    dummy,		/* latex_print_option */
+    latex_name,
+    latex_terse_sep,
+    latex_reference,
+    latex_text,
+    latex_description,
+    latex_returns
+};
diff --git a/lex.l b/lex.l
new file mode 100644
index 0000000..ec99c22
--- /dev/null
+++ b/lex.l
@@ -0,0 +1,621 @@
+%{
+/* $Id: lex.l,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * C manual page generator
+ * Lexical analyzer specification
+ */
+
+#include <ctype.h>
+
+extern boolean inbasefile;  /* Steven Haehn  Mar 19, 1996 */
+
+static char *cur_file;			/* current file name (malloced) */
+int line_num = 1;		/* current line number in file */
+static int curly = 0;		/* number of curly brace nesting levels */
+static int square = 0;		/* number of square bracket nesting levels */
+static int ly_count = 0;	/* number of occurrences of %% */
+static int embedded = 0;	/* flag for embedded compiler directives */
+
+/* temporary string buffer */
+static char buf[MAX_TEXT_LENGTH];
+
+#define DYNBUF_ALLOC	240	/* size of increment of dynamic buf */
+static char *dynbuf;		/* start of dynamic buf */
+static int dynbuf_size;		/* number of bytes allocated */
+static int dynbuf_current;	/* current end of buffer */
+
+static boolean comment_ateol;	/* does comment start & end at end of a line? */
+static boolean comment_remember;/* remember contents of current comment? */
+static boolean comment_caller;	/* state we were in before */
+static boolean body_start = FALSE; /* At the start of a function body */ 
+
+typedef struct {
+#ifdef FLEX_SCANNER
+    YY_BUFFER_STATE buffer;
+#else
+    FILE *fp;
+#endif
+    char *file;
+    int line_num;
+} IncludeStack;
+
+static int inc_depth = 0;			/* include nesting level */
+static IncludeStack inc_stack[MAX_INC_DEPTH];	/* stack of included files */
+
+static void update_line_num _((void));
+static void do_include _((char *filename, int sysinc));
+static void new_dynbuf();
+static void add_dynbuf _((int c));
+static char *return_dynbuf();
+static void get_cpp_directive();
+static boolean process_line_directive _((const char *new_file));
+
+/*
+ * The initial comment processing is done primarily by the rather complex lex
+ * rules in the various comment start states, the main functions being removal
+ * of leading *'s, /'s and whitespace on a line, the removal of trailing
+ * whitespace on a line, and the coalescing of separate comments on adjacent
+ * lines.  The remaining bits of textual content are collected by the following
+ * functions, which simply strip leading and trailing blank lines.
+ */
+void start_comment _((boolean ateol));
+int end_comment _((boolean ateol));
+void add_comment _((const char *s));
+void newline_comment _((void));
+
+static int comment_newlines;	/* number of newlines hit in comment */
+static boolean comment_started;	/* have preceding empty lines been skipped */
+
+#ifdef FLEX_SCANNER	/* flex uses YY_START instead of YYSTATE */
+#define YYSTATE	YY_START
+#ifndef YY_START	/* flex 2.3.8 & before didn't support it at all */
+#define YY_START ((yy_start - 1) / 2)
+#endif
+#endif
+
+#undef yywrap	/* for flex */
+
+/* SKIP		skipping value assignment in an enum */
+%}
+
+WS		[ \t]
+WLF		[ \t\n\f]*
+LETTER		[A-Za-z_]
+DIGIT		[0-9]
+ID		{LETTER}({LETTER}|{DIGIT})*
+STRING		\"(\\.|\\\n|[^"\\])*\"
+QUOTED		({STRING}|\'(\\\'|[^'\n])*\'|\\.)
+
+%p 5000
+%e 2000
+%s CPP1 INIT1 INIT2 CURLY SQUARE LEXYACC SKIP COMMENT COMMLINE CPPCOMMENT EMBEDDED
+%%
+
+
+<LEXYACC>^"%%"		{
+			    if (++ly_count >= 2)
+				BEGIN INITIAL;
+			}
+<LEXYACC>^"%{"		BEGIN INITIAL;
+<LEXYACC>{QUOTED}	update_line_num();
+<LEXYACC>.		;
+<INITIAL>^"%}"		BEGIN LEXYACC;
+
+<INITIAL>^{WS}*#{WS}*	BEGIN CPP1;
+
+<CPP1>define{WS}+{ID}	{
+			    sscanf(yytext, "define %s", buf);
+			    get_cpp_directive();
+			    new_symbol(typedef_names, buf, DS_EXTERN);
+			}
+
+<CPP1>include{WS}*\"[^"]+\"     {
+			    sscanf(yytext, "include \"%[^\"]\"", buf);
+			    get_cpp_directive();
+			    do_include(buf, FALSE);
+			}
+<CPP1>include{WS}*\<[^>]+\>	{
+			    sscanf(yytext, "include <%[^>]>", buf);
+			    get_cpp_directive();
+			    do_include(buf, TRUE);
+			}
+
+<CPP1>line{WS}+[0-9]+{WS}+\".*$  {
+			    sscanf(yytext, "line %d \"%[^\"]\"",
+				    &line_num, buf);
+			    --line_num;
+			    BEGIN INITIAL;
+
+			    if (process_line_directive(buf))
+			        inbasefile = yylval.boolean;
+			}
+<CPP1>[0-9]+{WS}+\".*$	{
+			    sscanf(yytext, "%d \"%[^\"]\"", &line_num, buf);
+			    --line_num;
+			    BEGIN INITIAL;
+
+			    if (process_line_directive(buf))
+			        inbasefile = yylval.boolean;
+			}
+<CPP1>[0-9]+.*$		{
+			    sscanf(yytext, "%d ", &line_num);
+			    --line_num;
+			    BEGIN INITIAL;
+			}
+
+<CPP1>.			get_cpp_directive();
+
+<INITIAL>"("		return '(';
+<INITIAL>")"		return ')';
+<INITIAL>"*"		return '*';
+<INITIAL,SKIP>","	{
+			    BEGIN INITIAL;	/* stop skipping */
+			    return ',';
+			}
+<INITIAL>";"		return ';';
+<INITIAL>"..."		return T_ELLIPSIS;
+<INITIAL>{STRING}	{ update_line_num(); return T_STRING_LITERAL; }
+
+<INITIAL>auto		return T_AUTO;
+<INITIAL>extern		return T_EXTERN;
+<INITIAL>register	return T_REGISTER;
+<INITIAL>static		return T_STATIC;
+<INITIAL>typedef	return T_TYPEDEF;
+<INITIAL>char		return T_CHAR;
+<INITIAL>double		return T_DOUBLE;
+<INITIAL>float		return T_FLOAT;
+<INITIAL>int		return T_INT;
+<INITIAL>void		return T_VOID;
+<INITIAL>long		return T_LONG;
+<INITIAL>short		return T_SHORT;
+<INITIAL>signed		return T_SIGNED;
+<INITIAL>__signed__	return T_SIGNED;
+<INITIAL>__signed	return T_SIGNED;
+<INITIAL>unsigned	return T_UNSIGNED;
+<INITIAL>enum		{ enum_state = KEYWORD; return T_ENUM; }
+<INITIAL>struct		return T_STRUCT;
+<INITIAL>union		return T_UNION;
+<INITIAL>const		return T_CONST;
+<INITIAL>__const__	return T_CONST;
+<INITIAL>__const	return T_CONST;
+<INITIAL>volatile	return T_VOLATILE;
+<INITIAL>__volatile__	return T_VOLATILE;
+<INITIAL>__volatile	return T_VOLATILE;
+<INITIAL>inline		return T_INLINE;
+<INITIAL>__inline__	return T_INLINE;
+<INITIAL>__inline	return T_INLINE;
+<INITIAL>cdecl		return T_CDECL;
+<INITIAL>far		return T_FAR;
+<INITIAL>huge		return T_HUGE;
+<INITIAL>interrupt	return T_INTERRUPT;
+<INITIAL>near		return T_NEAR;
+<INITIAL>pascal		return T_PASCAL;
+<INITIAL>__extension__	;
+
+<INITIAL>__attribute__	{
+			    BEGIN EMBEDDED;
+			}
+<EMBEDDED>"("		++embedded;
+<EMBEDDED>")"		{
+			    if (--embedded == 0)
+				BEGIN INITIAL;
+			}
+<EMBEDDED>{ID}|","|{DIGIT}+|{WS} ;
+<EMBEDDED>{QUOTED}	update_line_num();
+
+<INITIAL>{ID}		{
+			    if (enum_state == BRACES)	BEGIN SKIP;
+			    yylval.text = strduplicate(yytext);
+			    if (is_typedef_name(yytext))
+				return T_TYPEDEF_NAME;
+			    else
+				return T_IDENTIFIER;
+			}
+
+<INITIAL>"="		BEGIN INIT1;
+<INIT1>"{"		{ curly = 1; BEGIN INIT2; }
+<INIT1>[,;]		{
+			    unput(yytext[yyleng-1]);
+			    BEGIN INITIAL;
+			    return T_INITIALIZER;
+			}
+<INIT1>{QUOTED}		update_line_num();
+<INIT1>.		;
+
+<INIT2>"{"		++curly;
+<INIT2>"}"		{
+			    if (--curly == 0) {
+				BEGIN INITIAL;
+				return T_INITIALIZER;
+			    }
+			}
+<INIT2>{QUOTED}		update_line_num();
+<INIT2>.		;
+
+<INITIAL,SKIP>"{"	{
+			    if (enum_state == KEYWORD)
+			    {
+				enum_state = BRACES;
+				return '{';
+			    }
+			    else
+			    {
+				curly = 1;
+				BEGIN CURLY;
+				body_start = TRUE; /* Look for first comment
+						    * in the func body.
+						    */
+				safe_free(body_comment);
+				body_comment = NULL;
+			    }
+			}
+<INITIAL,SKIP>"}"	{
+ 			    BEGIN INITIAL;	/* stop skipping */
+			    return '}';
+			}
+
+<CURLY>"{"		++curly;
+<CURLY>"}"		{
+			    if (--curly == 0) {
+				BEGIN INITIAL;
+				return T_BRACES;
+			    }
+			}
+<CURLY,SKIP>{QUOTED}	update_line_num();
+<CURLY,SKIP>.		body_start = FALSE;
+
+<INITIAL>"["		{
+			  new_dynbuf(); add_dynbuf(yytext[0]);
+			  square = 1; BEGIN SQUARE;
+			}
+<SQUARE>"["		{ ++square; add_dynbuf(yytext[0]); }
+<SQUARE>"]"		{
+			    add_dynbuf(yytext[0]);
+			    if (--square == 0) {
+				BEGIN INITIAL;
+				yylval.text = return_dynbuf();
+				return T_BRACKETS;
+			    }
+			}
+<SQUARE>{QUOTED}|.	{
+			    int i;
+			    for (i = 0; i < yyleng; ++i)
+			    {
+				if (yytext[i] == '\n') ++line_num;
+				add_dynbuf(yytext[i]);
+			    }
+			}
+
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>^{WS}*"/*"[*=-]*{WS}+	{
+				comment_caller = YYSTATE;
+				start_comment(FALSE);
+				BEGIN COMMENT; }
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>^{WS}*"/*"[*=-]*[^/]	{
+				yyless(yyleng-1);
+				comment_caller = YYSTATE;
+				start_comment(FALSE);
+				BEGIN COMMENT; }
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>"/*"[*=-]*{WS}+		{
+				comment_caller = YYSTATE;
+				start_comment(TRUE);
+				BEGIN COMMENT; }
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>"/*"[*=-]*[^/]		{
+				yyless(yyleng-1);
+				comment_caller = YYSTATE;
+				start_comment(TRUE);
+				BEGIN COMMENT; }
+<COMMLINE>^{WS}*"/"+{WS}*	|
+<COMMLINE>^{WS}*"/"*"*"*{WS}+	BEGIN COMMENT;
+<COMMLINE>^{WS}*"/"*"*"*[^/]	{ yyless(yyleng-1); BEGIN COMMENT; }
+<COMMLINE>.			{ yyless(0); BEGIN COMMENT; }
+<COMMLINE>\n			newline_comment();
+<COMMENT>{WS}*"*"+"/"{WS}*\n{WS}*"/*""*"*{WS}+	newline_comment();
+<COMMENT>{WS}*"*"+"/"{WS}*\n{WS}*"/*""*"*[^/]	{
+				yyless(yyleng-1); newline_comment(); }
+<COMMENT>{WS}*[*=-]*"*/"{WS}*$	{ int ret = end_comment(TRUE);
+				  BEGIN comment_caller;
+				  if (ret)	return ret; }
+<COMMENT>{WS}*[*=-]*"*/"	{ int ret = end_comment(FALSE);
+				  BEGIN comment_caller;
+				  if (ret)	return ret; }
+<COMMENT>[^*\n \t]*		|
+<COMMENT>{WS}*			|
+<COMMENT>"*"+[^*/\n]*		add_comment(yytext);
+<COMMENT>{WS}*\n		{ newline_comment(); BEGIN COMMLINE; }
+
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>^{WS}*"//"[/*=-]*{WS}*	{
+				comment_caller = YYSTATE;
+				start_comment(FALSE);
+				BEGIN CPPCOMMENT; }
+<INITIAL,INIT1,INIT2,CURLY,SQUARE,LEXYACC,SKIP,EMBEDDED>"//"[/*=-]*{WS}*		{
+				comment_caller = YYSTATE;
+				start_comment(TRUE);
+				BEGIN CPPCOMMENT; }
+<CPPCOMMENT>.*			add_comment(yytext);
+<CPPCOMMENT>\n{WS}*"//"[/*=-]*{WS}*	newline_comment();
+<CPPCOMMENT>\n			{ int ret = end_comment(TRUE);
+				  ++line_num;
+				  BEGIN comment_caller;
+				  if (ret)	return ret; }
+
+[ \t\f]+		;
+\n			++line_num;
+
+.			{
+			    output_error();
+			    fprintf(stderr, "bad character '%c'\n", yytext[0]);
+			}
+%%
+
+/* If the matched text contains any new line characters, then update the
+ * current line number.
+ */
+static void
+update_line_num ()
+{
+    const char *p = (const char *)yytext;
+    while (*p != '\0') {
+	if (*p++ == '\n')
+	    line_num++;
+    }
+}
+
+void start_comment(ateol)
+boolean ateol;	/* does comment start at end of an existing line? */
+{
+    comment_remember =	(look_at_body_start && body_start) ||
+		    ((comment_caller == INITIAL || comment_caller == SKIP) &&
+			(inbasefile || enum_state == BRACES));
+
+    if (comment_remember)
+    {
+	comment_ateol = ateol;
+	comment_newlines = 0;
+	comment_started = FALSE;
+	new_dynbuf();
+    }
+}
+
+int end_comment(ateol)
+boolean ateol;	/* does comment end at end of line? */
+{
+    if (comment_remember)
+    {
+	if (!ateol)	comment_ateol = FALSE;
+	yylval.text = return_dynbuf();
+	if (yylval.text[0] == '\0' ||
+	    /* ignore lint directives entirely */
+	    strcmp("EMPTY",       yylval.text) == 0 ||
+	    strcmp("FALLTHROUGH", yylval.text) == 0 ||
+	    strcmp("FALLTHRU",    yylval.text) == 0 ||
+	    strcmp("LINTED",      yylval.text) == 0 ||
+	    strcmp("LINTLIBRARY", yylval.text) == 0 ||
+	    strcmp("LINTSTDLIB",  yylval.text) == 0 ||
+	    strcmp("NOTDEFINED",  yylval.text) == 0 ||
+	    strcmp("NOTREACHED",  yylval.text) == 0 ||
+	    strcmp("NOTUSED",     yylval.text) == 0 ||
+	    strncmp("ARGSUSED",   yylval.text,  8) == 0 ||
+	    strncmp("PRINTFLIKE", yylval.text, 10) == 0 ||
+	    strncmp("SCANFLIKE",  yylval.text,  9) == 0 ||
+	    strncmp("VARARGS",    yylval.text,  7) == 0)
+	{
+	    free(yylval.text);
+	    return 0;
+	}
+	if (body_start) {	/* first comment at start of func body */
+	  safe_free(body_comment);
+	  body_comment = yylval.text;
+	  body_start = FALSE;
+	  return 0;
+	}
+#ifdef DEBUG
+	fprintf(stderr,"`%s'\n", yylval.text);
+#endif
+	return comment_ateol ? T_EOLCOMMENT : T_COMMENT;
+    }
+    return 0;
+}
+
+/* add a newline to the comment, deferring to remove trailing ones */
+void newline_comment()
+{
+    ++line_num;
+
+    if (!comment_remember || !comment_started)	return;
+
+    comment_newlines++;
+}
+
+/* add some true text to the comment */
+void add_comment(s)
+const char *s;
+{
+#ifdef DEBUG
+    fprintf(stderr,"`%s'\n", s);
+#endif
+    if (!comment_remember)	return;
+
+    comment_started = TRUE;
+
+    while (comment_newlines)
+    {
+	add_dynbuf('\n');
+	comment_newlines--;
+    }
+
+    while(*s)
+	add_dynbuf(*s++);
+}
+
+/* Scan rest of preprocessor statement.
+ */
+static void
+get_cpp_directive ()
+{
+    int c, lastc = '\0';
+
+    while ((c = input()) > 0) {
+	switch (c) {
+	case '\n':
+	    if (lastc != '\\') {
+		unput(c);
+		BEGIN INITIAL;
+		return;
+	    }
+	    line_num++;
+	    break;
+	case '*':
+	    if (lastc == '/')
+	    {
+		/* might be able to attach comments to #defines one day */
+		comment_caller = YYSTATE;
+		start_comment(TRUE);
+		BEGIN COMMENT;
+	    }
+	    break;
+	case '/':
+	    if (lastc == '/')
+	    {
+		/* might be able to attach comments to #defines one day */
+		comment_caller = YYSTATE;
+		start_comment(TRUE);
+		BEGIN CPPCOMMENT;
+	    }
+	    break;
+	}
+	lastc = c;
+    }
+}
+
+/* Process include directive.
+ */
+static void
+do_include (filename, sysinc)
+char *filename;		/* file name */
+int sysinc;		/* 1 = do not search current directory */
+{
+    char path[MAX_TEXT_LENGTH];
+    int i;
+    FILE *fp;
+    IncludeStack *sp;
+
+    if (inc_depth >= MAX_INC_DEPTH) {
+	output_error();
+	fprintf(stderr, "includes too deeply nested\n");
+	return;
+    }
+
+    for (i = sysinc != 0; i < num_inc_dir; ++i) {
+	 strcpy(path, inc_dir[i]);
+	 strcat(path, filename);
+	 if ((fp = fopen(path, "r")) != NULL) {
+	     sp = inc_stack + inc_depth;
+	     sp->file = cur_file;
+	     sp->line_num = line_num;
+#ifdef FLEX_SCANNER
+	     sp->buffer = YY_CURRENT_BUFFER;
+	     yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
+#else
+	     sp->fp = yyin;
+	     yyin = fp;
+#endif
+	     ++inc_depth;
+	     cur_file = strduplicate(filename);
+	     line_num = 0;
+	     return;
+	 }
+    }
+}
+
+/* returns TRUE if the basefile status has changed */
+static boolean process_line_directive(new_file)
+const char *new_file;
+{
+    boolean new_stdin;
+
+    /* strip leading ./ that Sun acc prepends */
+    if (!strncmp(new_file,"./",2))
+	new_file += 2;
+
+    new_stdin = new_file[0] == '\0' || !strcmp(new_file,"stdin");
+
+    /* return BASEFILE token only when file changes */
+    if ((cur_file == NULL && !new_stdin) ||
+	(cur_file != NULL &&strcmp(cur_file, new_file)))
+    {
+	safe_free(cur_file);
+	cur_file = new_stdin ? NULL : strduplicate(new_file);
+	yylval.boolean = basefile ? !strcmp(cur_file,basefile) :
+				    cur_file == basefile;
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/* When the end of the current input file is reached, pop any
+ * nested includes.
+ */
+int
+yywrap ()
+{
+    IncludeStack *sp;
+
+    if (inc_depth > 0) {
+	--inc_depth;
+	sp = inc_stack + inc_depth;
+	fclose(yyin);
+#ifdef FLEX_SCANNER
+	yy_delete_buffer(YY_CURRENT_BUFFER);
+	yy_switch_to_buffer(sp->buffer);
+#else
+	yyin = sp->fp;
+#endif
+	safe_free(cur_file);
+	cur_file = sp->file;
+	line_num = sp->line_num + 1;
+	return 0;
+    } else {
+	return 1;
+    }
+}
+
+
+static void new_dynbuf()
+{
+    if ((dynbuf = malloc(dynbuf_size = DYNBUF_ALLOC)) == 0)
+	outmem();
+	
+    dynbuf_current = 0;
+}
+
+static void add_dynbuf(c)
+int c;
+{
+    if (dynbuf_current == dynbuf_size &&
+	((dynbuf = realloc(dynbuf,dynbuf_size += DYNBUF_ALLOC)) == 0))
+	    outmem();
+	
+    dynbuf[dynbuf_current++] = c;
+}
+
+static char *return_dynbuf()
+{
+    add_dynbuf('\0');
+
+    /* chop it back to size */
+    if ((dynbuf = realloc(dynbuf,dynbuf_current)) == 0)
+	outmem();
+
+    return dynbuf;	
+}
+
+/* Output an error message along with the current line number in the
+ * source file.
+ */
+void
+output_error ()
+{
+    errors++;
+    fprintf(stderr, "%s:%d: ", cur_file ? cur_file : "stdin", line_num);
+    fprintf(stderr, "\n(%s) ", yytext);
+}
diff --git a/libc/COPYING b/libc/COPYING
new file mode 100644
index 0000000..a43ea21
--- /dev/null
+++ b/libc/COPYING
@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                          675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/libc/README.libc b/libc/README.libc
new file mode 100644
index 0000000..0f0260d
--- /dev/null
+++ b/libc/README.libc
@@ -0,0 +1,10 @@
+This directory contains sources for library routines which some users have
+found to be missing on their machines.
+
+Since some of this code is covered by the GNU General Public License, a copy
+is included in the file COPYING.  Note that only those files in the c2man
+distribution which explicitly state that they fall under the terms of this
+license actually do so.
+
+The getopt routines (needed for MSC on the PC, and for VMS) are adapted from
+the GNU versions.
diff --git a/libc/alloca.c b/libc/alloca.c
new file mode 100644
index 0000000..9e6a3a2
--- /dev/null
+++ b/libc/alloca.c
@@ -0,0 +1,186 @@
+/*
+	alloca -- (mostly) portable public-domain implementation -- D A Gwyn
+
+	This implementation of the PWB library alloca() function,
+	which is used to allocate space off the run-time stack so
+	that it is automatically reclaimed upon procedure exit, 
+	was inspired by discussions with J. Q. Johnson of Cornell.
+
+	It should work under any C implementation that uses an
+	actual procedure stack (as opposed to a linked list of
+	frames).  There are some preprocessor constants that can
+	be defined when compiling for your specific system, for
+	improved efficiency; however, the defaults should be okay.
+
+	The general concept of this implementation is to keep
+	track of all alloca()-allocated blocks, and reclaim any
+	that are found to be deeper in the stack than the current
+	invocation.  This heuristic does not reclaim storage as
+	soon as it becomes invalid, but it will do so eventually.
+
+	As a special case, alloca(0) reclaims storage without
+	allocating any.  It is a good idea to use alloca(0) in
+	your main control loop, etc. to force garbage collection.
+*/
+#ifndef lint
+static char	SCCSid[] = "@(#)alloca.c	1.1";	/* for the "what" utility */
+#endif
+
+#ifdef emacs
+#include "config.h"
+#ifdef static
+/* actually, only want this if static is defined as ""
+   -- this is for usg, in which emacs must undefine static
+   in order to make unexec workable
+   */
+#ifndef STACK_DIRECTION
+you
+lose
+-- must know STACK_DIRECTION at compile-time
+#endif /* STACK_DIRECTION undefined */
+#endif static
+#endif emacs
+
+#ifdef X3J11
+typedef void	*pointer;		/* generic pointer type */
+#else
+typedef char	*pointer;		/* generic pointer type */
+#endif
+
+#define	NULL	0			/* null pointer constant */
+
+extern void	free();
+extern pointer	malloc();
+
+/*
+	Define STACK_DIRECTION if you know the direction of stack
+	growth for your system; otherwise it will be automatically
+	deduced at run-time.
+
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown
+*/
+
+#ifndef STACK_DIRECTION
+#define	STACK_DIRECTION	0		/* direction unknown */
+#endif
+
+#if STACK_DIRECTION != 0
+
+#define	STACK_DIR	STACK_DIRECTION	/* known at compile-time */
+
+#else	/* STACK_DIRECTION == 0; need run-time code */
+
+static int	stack_dir;		/* 1 or -1 once known */
+#define	STACK_DIR	stack_dir
+
+static void
+find_stack_direction (/* void */)
+{
+  static char	*addr = NULL;	/* address of first
+				   `dummy', once known */
+  auto char	dummy;		/* to get stack address */
+
+  if (addr == NULL)
+    {				/* initial entry */
+      addr = &dummy;
+
+      find_stack_direction ();	/* recurse once */
+    }
+  else				/* second entry */
+    if (&dummy > addr)
+      stack_dir = 1;		/* stack grew upward */
+    else
+      stack_dir = -1;		/* stack grew downward */
+}
+
+#endif	/* STACK_DIRECTION == 0 */
+
+/*
+	An "alloca header" is used to:
+	(a) chain together all alloca()ed blocks;
+	(b) keep track of stack depth.
+
+	It is very important that sizeof(header) agree with malloc()
+	alignment chunk size.  The following default should work okay.
+*/
+
+#ifndef	ALIGN_SIZE
+#define	ALIGN_SIZE	sizeof(double)
+#endif
+
+typedef union hdr
+{
+  char	align[ALIGN_SIZE];	/* to force sizeof(header) */
+  struct
+    {
+      union hdr *next;		/* for chaining headers */
+      char *deep;		/* for stack depth measure */
+    } h;
+} header;
+
+/*
+	alloca( size ) returns a pointer to at least `size' bytes of
+	storage which will be automatically reclaimed upon exit from
+	the procedure that called alloca().  Originally, this space
+	was supposed to be taken from the current stack frame of the
+	caller, but that method cannot be made to work for some
+	implementations of C, for example under Gould's UTX/32.
+*/
+
+static header *last_alloca_header = NULL; /* -> last alloca header */
+
+pointer
+alloca (size)			/* returns pointer to storage */
+     unsigned	size;		/* # bytes to allocate */
+{
+  auto char	probe;		/* probes stack depth: */
+  register char	*depth = &probe;
+
+#if STACK_DIRECTION == 0
+  if (STACK_DIR == 0)		/* unknown growth direction */
+    find_stack_direction ();
+#endif
+
+				/* Reclaim garbage, defined as all alloca()ed storage that
+				   was allocated from deeper in the stack than currently. */
+
+  {
+    register header	*hp;	/* traverses linked list */
+
+    for (hp = last_alloca_header; hp != NULL;)
+      if (STACK_DIR > 0 && hp->h.deep > depth
+	  || STACK_DIR < 0 && hp->h.deep < depth)
+	{
+	  register header	*np = hp->h.next;
+
+	  free ((pointer) hp);	/* collect garbage */
+
+	  hp = np;		/* -> next header */
+	}
+      else
+	break;			/* rest are not deeper */
+
+    last_alloca_header = hp;	/* -> last valid storage */
+  }
+
+  if (size == 0)
+    return NULL;		/* no allocation required */
+
+  /* Allocate combined header + user data storage. */
+
+  {
+    register pointer	new = malloc (sizeof (header) + size);
+    /* address of header */
+
+    ((header *)new)->h.next = last_alloca_header;
+    ((header *)new)->h.deep = depth;
+
+    last_alloca_header = (header *)new;
+
+    /* User storage begins just after header. */
+
+    return (pointer)((char *)new + sizeof(header));
+  }
+}
diff --git a/libc/getopt.c b/libc/getopt.c
new file mode 100644
index 0000000..479d4cc
--- /dev/null
+++ b/libc/getopt.c
@@ -0,0 +1,735 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
+   	Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* NOTE!!!  AIX requires this to be the first thing in the file.
+   Do not put ANYTHING before it!  */
+#if !defined (__GNUC__) && defined (_AIX)
+ #pragma alloca
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef __GNUC__
+#define alloca __builtin_alloca
+#else /* not __GNUC__ */
+#if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__))))
+#include <alloca.h>
+#else
+#ifdef _MSC_VER
+#include <malloc.h>
+#else
+#ifndef _AIX
+char *alloca ();
+#endif
+#endif
+#endif /* alloca.h */
+#endif /* not __GNUC__ */
+
+#if !__STDC__ && !defined(const) && IN_GCC
+#define const
+#endif
+
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.  */
+#ifndef _NO_PROTO
+#define _NO_PROTO
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+#undef	alloca
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+#include <stdlib.h>
+#else	/* Not GNU C library.  */
+#define	__alloca	alloca
+#endif	/* GNU C library.  */
+
+/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
+   long-named option.  Because this is not POSIX.2 compliant, it is
+   being phased out.  */
+/* #define GETOPT_COMPAT */
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg = 0;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* XXX 1003.2 says this must be 1 before any call.  */
+int optind = 0;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define	my_index	strchr
+#define	my_bcopy(src, dst, n)	memcpy ((dst), (src), (n))
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *getenv ();
+
+static char *
+my_index (str, chr)
+     const char *str;
+     int chr;
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+static void
+my_bcopy (from, to, size)
+     const char *from;
+     char *to;
+     int size;
+{
+  int i;
+  for (i = 0; i < size; i++)
+    to[i] = from[i];
+}
+#endif				/* GNU C library.  */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
+  char **temp = (char **) __alloca (nonopts_size);
+
+  /* Interchange the two blocks of data in ARGV.  */
+
+  my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size);
+  my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt],
+	    (optind - last_nonopt) * sizeof (char *));
+  my_bcopy ((char *) temp,
+	    (char *) &argv[first_nonopt + optind - last_nonopt],
+	    nonopts_size);
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns `EOF'.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct option *longopts;
+     int *longind;
+     int long_only;
+{
+  int option_index;
+
+  optarg = 0;
+
+  /* Initialize the internal data when the first call is made.
+     Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  if (optind == 0)
+    {
+      first_nonopt = last_nonopt = optind = 1;
+
+      nextchar = NULL;
+
+      /* Determine how to handle the ordering of options and nonoptions.  */
+
+      if (optstring[0] == '-')
+	{
+	  ordering = RETURN_IN_ORDER;
+	  ++optstring;
+	}
+      else if (optstring[0] == '+')
+	{
+	  ordering = REQUIRE_ORDER;
+	  ++optstring;
+	}
+      else if (getenv ("POSIXLY_CORRECT") != NULL)
+	ordering = REQUIRE_ORDER;
+      else
+	ordering = PERMUTE;
+    }
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Now skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc
+		 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#ifdef GETOPT_COMPAT
+		 && (longopts == NULL
+		     || argv[optind][0] != '+' || argv[optind][1] == '\0')
+#endif				/* GETOPT_COMPAT */
+		 )
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* Special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return EOF;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
+#ifdef GETOPT_COMPAT
+	  && (longopts == NULL
+	      || argv[optind][0] != '+' || argv[optind][1] == '\0')
+#endif				/* GETOPT_COMPAT */
+	  )
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return EOF;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Start decoding its characters.  */
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  if (longopts != NULL
+      && ((argv[optind][0] == '-'
+	   && (argv[optind][1] == '-' || long_only))
+#ifdef GETOPT_COMPAT
+	  || argv[optind][0] == '+'
+#endif				/* GETOPT_COMPAT */
+	  ))
+    {
+      const struct option *p;
+      char *s = nextchar;
+      int exact = 0;
+      int ambig = 0;
+      const struct option *pfound = NULL;
+      int indfound;
+
+      while (*s && *s != '=')
+	s++;
+
+      /* Test all options for either exact match or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name;
+	   p++, option_index++)
+	if (!strncmp (p->name, nextchar, s - nextchar))
+	  {
+	    if (s - nextchar == strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.  */
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (opterr)
+	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*s)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.  */
+	      if (pfound->has_arg)
+		optarg = s + 1;
+	      else
+		{
+		  if (opterr)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 "%s: option `--%s' doesn't allow an argument\n",
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+			     "%s: option `%c%s' doesn't allow an argument\n",
+			     argv[0], argv[optind - 1][0], pfound->name);
+		    }
+		  nextchar += strlen (nextchar);
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (opterr)
+		    fprintf (stderr, "%s: option `%s' requires an argument\n",
+			     argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+#ifdef GETOPT_COMPAT
+	  || argv[optind][0] == '+'
+#endif				/* GETOPT_COMPAT */
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (opterr)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, "%s: unrecognized option `--%s'\n",
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (opterr)
+	  {
+#if 0
+	    if (c < 040 || c >= 0177)
+	      fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
+		       argv[0], c);
+	    else
+	      fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
+#else
+	    /* 1003.2 specifies the format of this message.  */
+	    fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
+#endif
+	  }
+	optopt = c;
+	return '?';
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = 0;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (opterr)
+		  {
+#if 0
+		    fprintf (stderr, "%s: option `-%c' requires an argument\n",
+			     argv[0], c);
+#else
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr, "%s: option requires an argument -- %c\n",
+			     argv[0], c);
+#endif
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
+}
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+
+      c = getopt (argc, argv, "abc:d:0123456789");
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */
diff --git a/libc/getopt.h b/libc/getopt.h
new file mode 100644
index 0000000..45541f5
--- /dev/null
+++ b/libc/getopt.h
@@ -0,0 +1,129 @@
+/* Declarations for getopt.
+   Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _GETOPT_H
+#define _GETOPT_H 1
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int optopt;
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument 	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+#if	__STDC__
+  const char *name;
+#else
+  char *name;
+#endif
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'.  */
+
+#define	no_argument		0
+#define required_argument	1
+#define optional_argument	2
+
+#if __STDC__
+#if defined(__GNU_LIBRARY__)
+/* Many other libraries have conflicting prototypes for getopt, with
+   differences in the consts, in stdlib.h.  To avoid compilation
+   errors, only prototype getopt for the GNU C library.  */
+extern int getopt (int argc, char *const *argv, const char *shortopts);
+#else /* not __GNU_LIBRARY__ */
+extern int getopt ();
+#endif /* not __GNU_LIBRARY__ */
+extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+		        const struct option *longopts, int *longind);
+extern int getopt_long_only (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind,
+			     int long_only);
+#else /* not __STDC__ */
+extern int getopt ();
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+#endif /* not __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _GETOPT_H */
diff --git a/libc/getopt1.c b/libc/getopt1.c
new file mode 100644
index 0000000..a32615c
--- /dev/null
+++ b/libc/getopt1.c
@@ -0,0 +1,176 @@
+/* getopt_long and getopt_long_only entry points for GNU getopt.
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
+	Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 2, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "getopt.h"
+
+#if !__STDC__ && !defined(const) && IN_GCC
+#define const
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef __GNU_LIBRARY__
+#include <stdlib.h>
+#else
+char *getenv ();
+#endif
+
+#ifndef	NULL
+#define NULL 0
+#endif
+
+int
+getopt_long (argc, argv, options, long_options, opt_index)
+     int argc;
+     char *const *argv;
+     const char *options;
+     const struct option *long_options;
+     int *opt_index;
+{
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* Like getopt_long, but '-' as well as '--' can indicate a long option.
+   If an option that starts with '-' (not '--') doesn't match a long option,
+   but does match a short option, it is parsed as a short option
+   instead.  */
+
+int
+getopt_long_only (argc, argv, options, long_options, opt_index)
+     int argc;
+     char *const *argv;
+     const char *options;
+     const struct option *long_options;
+     int *opt_index;
+{
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+}
+
+
+#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+      int option_index = 0;
+      static struct option long_options[] =
+      {
+	{"add", 1, 0, 0},
+	{"append", 0, 0, 0},
+	{"delete", 1, 0, 0},
+	{"verbose", 0, 0, 0},
+	{"create", 0, 0, 0},
+	{"file", 1, 0, 0},
+	{0, 0, 0, 0}
+      };
+
+      c = getopt_long (argc, argv, "abc:d:0123456789",
+		       long_options, &option_index);
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case 0:
+	  printf ("option %s", long_options[option_index].name);
+	  if (optarg)
+	    printf (" with arg %s", optarg);
+	  printf ("\n");
+	  break;
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_optind != 0 && digit_optind != this_option_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_optind = this_option_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", optarg);
+	  break;
+
+	case 'd':
+	  printf ("option d with value `%s'\n", optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+	printf ("%s ", argv[optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */
diff --git a/manpage.c b/manpage.c
new file mode 100644
index 0000000..8f6c047
--- /dev/null
+++ b/manpage.c
@@ -0,0 +1,1347 @@
+/* $Id: manpage.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * stuff to do with manual page outputing
+ */
+
+/*
+ * This file has been modified by Manoj Srivastava <srivasta@debian.org>
+ * to incorporate a patch that was also submitted to the author. The change
+ * shall be incorporated upstream in due course.
+ */ 
+
+#include "c2man.h"
+
+#include <errno.h>
+#include <ctype.h>
+
+#include "manpage.h"
+#include "strconcat.h"
+#include "strappend.h"
+#include "semantic.h"
+#include "output.h"
+
+#ifdef I_SYS_FILE
+#include <sys/file.h>
+#endif
+
+/* list of manual pages */
+ManualPage *firstpage = NULL;
+ManualPage **lastpagenext = &firstpage;
+
+void dummy() {}
+
+void
+new_manual_page(comment, decl_spec, declarator)
+     char *comment;
+     DeclSpec *decl_spec;
+     Declarator *declarator;
+{
+    ManualPage *newpage;
+
+    /* check that we really want a man page for this */
+    if ((!comment) ||
+	!inbasefile ||
+	(!variables_out && !is_function_declarator(declarator)) ||
+	(decl_spec->flags & DS_JUNK) ||
+	(!static_out && (decl_spec->flags & DS_STATIC) && !header_file) ||
+
+	/* only document extern stuff if it's in a header file, or includes a
+	 * function definition.
+	 */
+	((decl_spec->flags & DS_EXTERN) && !header_file &&
+				    declarator->type != DECL_FUNCDEF))
+    {
+	free_decl_spec(decl_spec);
+	free_declarator(declarator);
+	safe_free(comment);
+	return;
+    }
+    
+    declarator->comment = comment;
+    
+    newpage = (ManualPage *)safe_malloc(sizeof *newpage);
+    newpage->decl_spec = (DeclSpec *)safe_malloc(sizeof *newpage->decl_spec);
+    newpage->declarator = declarator;
+
+    *newpage->decl_spec = *decl_spec;
+    newpage->sourcefile = strduplicate(basefile);
+    newpage->sourcetime = basetime;
+
+    *lastpagenext = newpage;
+    newpage->next = NULL;
+    lastpagenext = &newpage->next;
+}
+
+void free_manual_page(page)
+     ManualPage *page;
+{
+    free_decl_spec(page->decl_spec);
+    free(page->decl_spec);
+    free_declarator(page->declarator);
+    safe_free(page->sourcefile);
+}
+
+/* free the list of manual pages */
+void free_manual_pages(first)
+     ManualPage *first;
+{
+    ManualPage *page, *next;
+
+    /* free any terse description read from the file */
+    if (group_terse && !terse_specified)
+    {
+    	free(group_terse);
+	group_terse = NULL;
+    }
+    
+    for (page = first;page;page = next)
+    {
+	next = page->next;
+	free_manual_page(page);
+	free(page);
+    }
+}
+
+/* allocate a substring starting at start, ending at end (NOT including *end) */
+char *alloc_string(start, end)
+     const char *start;
+     const char *end;
+{
+    int len = end - start;
+    char *ret;
+    if (len == 0)	return NULL;
+    
+    ret = (char *)safe_malloc((size_t)len+1);
+
+    strncpy(ret,start,len);
+    ret[len] = '\0';
+
+    return ret; 
+}
+
+/* remember the terse description from the first comment in a file */
+void remember_terse(comment)
+     char *comment;
+{
+    char *c, *d;
+    
+    enum { STUFF, LEADSPACE, DASH, TRAILSPACE, FOUND } state = STUFF;
+
+    /* if we've found a terse comment in a previous file, or one was
+     * specified on the command line, forget it.
+     */
+    if (group_terse)	return;
+
+    /* look for a whitespace surrounded sequence of dashes to skip */
+    for (c = comment;*c && state != FOUND;c++)
+    {
+	switch (state)
+	{
+	case STUFF:	if (isspace(*c))	state = LEADSPACE;
+			break;
+	case LEADSPACE:	if (*c == '-')		state = DASH;
+			else if (!isspace(*c))	state = STUFF;
+			break;
+	case DASH:	if (isspace(*c))	state = TRAILSPACE;
+			else if (*c != '-')	state = STUFF;
+			break;
+	case TRAILSPACE:if (!isspace(*c))	{ c--; state = FOUND; }
+			break;
+	case FOUND:	break;
+	}
+    }
+
+    /* if no dashes were found, go back to the start */
+    if (state != FOUND)	c = comment;
+
+    d = c + 1;
+    
+    while (*d && *d != '\n')
+	d++;
+
+    group_terse = alloc_string(c,d);
+}
+
+/* output a comment in man page form, followed by a newline */
+void
+output_comment(comment)
+const char *comment;
+{
+    if (!comment || !comment[0])
+	output->text("Not Documented.");
+    else if (fixup_comments)
+	output->description(comment);
+    else
+	output->text(comment);
+
+    output->character('\n');
+}
+
+/* output the phrase "a[n] <type name>" */
+void output_conjunction(text)
+char *text;
+{
+    output->character('a');
+    if (strchr("aAeEiIoOuU",text[0]))	output->character('n');
+    output->character(' ');
+    output->code(text);
+}
+
+/* output the description for an identifier; be it return value or param */
+static void output_identifier_description(comment, outfunc,
+						    decl_spec, declarator)
+    const char *comment;		/* comment for this identifier */
+    void (*outfunc) _((const char *));	/* function to output comment */
+    const DeclSpec *decl_spec;
+    const Declarator *declarator;
+{
+    /* one day, this may document the contents of structures too */
+
+    /* output list of possible enum values, if any */
+    if (decl_spec->enum_list)
+    {
+	int maxtaglen = 0;
+	char *longestag = NULL;
+	int descriptions = 0;
+	int entries = 0;
+	Enumerator *e;
+	int is_first = 1;
+	boolean started = FALSE;
+	
+	/* don't output the "Not Doc." message for enums */
+	if (comment)
+	{
+	    (*outfunc)(comment);
+	    output->blank_line();
+	}
+	
+	/* see if any have descriptions */
+	for (e = decl_spec->enum_list->first; e; e = e->next)
+	    if (e->name[0] != '_')
+	    {
+		int taglen = strlen(e->name);
+		if (taglen > maxtaglen)
+		{
+		    maxtaglen = taglen;
+		    longestag = e->name;
+		}
+		if (e->comment)	descriptions = 1;
+		entries++;
+	    }
+
+	/* if there are a lot of them, the list may be automatically generated,
+	 * and probably isn't wanted in every manual page.
+	 */
+	if (entries > 20)
+	{
+	    char entries_s[15];
+	    sprintf(entries_s, "%d", entries);
+	    output->text("Since there are ");
+	    output->text(entries_s);
+	    output->text(" possible values for ");
+	    output_conjunction(decl_spec->text);
+	    output->text(", they are not all listed here.\n");
+	}
+	else if (entries > 0)   /* skip the pathological case */
+	{
+	    /* the number of possibilities is reasonable; list them all */
+	    output->text("Possible values for ");
+	    output_conjunction(decl_spec->text);
+	    output->text(" are as follows:\n");
+    
+	    for (e = decl_spec->enum_list->first; e; e = e->next)
+	    {
+		/* don't print names with a leading underscore! */
+		if (e->name[0] == '_')	continue;
+		
+		if (e->group_comment)
+		{
+		    /* break out of table mode for the group comment */
+		    if (started)
+		    {
+			if (descriptions)
+			    output->table_end();
+			else
+			    output->list_end();
+			started = FALSE;
+		    }
+		    output->indent();
+		    output_comment(e->group_comment);
+		}
+    
+		if (!started)
+		{
+		    if (descriptions)
+			output->table_start(longestag);
+		    else
+			output->list_start();
+		    started = TRUE;
+		}
+    
+		if (descriptions)
+		    output->table_entry(e->name, e->comment);
+		else
+		{
+		    if (!is_first)
+			output->list_separator();
+		    is_first = 0;
+		    output->list_entry(e->name);
+		}
+	    }
+    
+	    if (started)
+	    {
+		if (descriptions)
+		    output->table_end();
+		else
+		    output->list_end();
+	    }
+	}
+    } 
+    else
+	(*outfunc)(comment);
+}
+
+/* is there automatic documentation here? */
+static boolean auto_documented(page)
+const ManualPage *page;
+{
+    /* one day we may handle structs too */
+    return
+	page->decl_spec->enum_list != NULL;    /* enums are self-documenting. */
+}
+
+/* decide if a manual page needs a RETURNS section.
+ * If this is true, then output_identifier_description must be able to generate
+ * sensible output for it.
+ */
+static boolean needs_returns_section(page)
+const ManualPage *page;
+{
+    return 
+	(page->returns && page->returns[0]) ||
+	(auto_documented(page) && is_function_declarator(page->declarator));
+}
+
+/* does this declarator have documented parameters? */
+boolean has_documented_parameters(d)
+const Declarator *d;
+{
+    if (has_parameters(d))
+    {
+	Parameter *p;
+
+	for (p = d->head->params.first; p != NULL; p = p->next)
+	    if (p->declarator->comment || always_document_params)
+		return TRUE;
+    }
+    return FALSE;
+}
+
+/* Output the list of function parameter descriptions.
+ */
+void
+output_parameter_descriptions (params, function)
+ParameterList *params;
+char *function;
+{
+    Parameter *p;
+    boolean tag_list_started = FALSE;
+
+    for (p = params->first; p != NULL; p = p->next)
+    {
+	if (p->suppress ||
+	    (!always_document_params && p->declarator->comment == NULL))
+		continue;
+
+	if (!tag_list_started)
+	{
+	  output->tag_list_start();
+	  tag_list_started = TRUE;
+	}
+
+	if (p->duplicate)
+	    output->tag_entry_start_extra();
+	else
+	    output->tag_entry_start();
+
+	output_parameter(p);
+
+	/* include function name if it's a duplicate */
+	if (p->duplicate)
+	    output->tag_entry_end_extra(function);
+	else
+	    output->tag_entry_end();
+
+	output_identifier_description(p->declarator->comment, output_comment,
+						&p->decl_spec, p->declarator);
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+/* split out the 'Returns:' section of a function comment */
+boolean
+split_returns_comment(comment, description, returns)
+     char *comment;
+     char **description;
+     char **returns;
+{
+    char *retstart;
+
+    for (retstart = comment;
+	 retstart;
+	 retstart = strchr(retstart,'\n'))
+    {
+	if (*retstart == '\n')	retstart++;	/* skip the newline */
+
+	if (!strncmpi(retstart, "returns",(size_t)7))
+	{	    
+	    char *descend = retstart - 2;	/* back before newline */
+
+	    /* go back to the end of the description in case there were
+	     * linefeeds before the returns.
+	     */
+	    while (descend > comment && isspace(*descend))
+		descend--;
+
+	    *description =
+		descend > comment ? alloc_string(comment,descend+1) : NULL;
+
+	    retstart += 7;
+		
+	    while (*retstart == ':' || isspace(*retstart))
+		retstart++;
+
+	    if (*retstart)
+		*returns = strduplicate(retstart);
+	    else
+	    	*returns = NULL;
+	    return TRUE;
+	}
+    }
+
+    *description = comment;
+    *returns = NULL;
+    return FALSE;
+}
+
+/* skip to past the dash on the first line, if there is one
+ * The dash must be surrounded by whitespace, so hyphens are not skipped.
+ */
+const char *skipdash(c)
+const char *c;
+{
+    const char *d;
+
+    /* ignore anything on the first line, up to a dash (if any) */
+    for (d = c + 1; *d && *d != '\n' && *d != '-'; d++)
+	;
+
+    if (isspace(d[-1]) && d[0] == '-' && isspace(d[1]))
+    {
+	do
+	    d++;
+	while (*d && *d != '\n' && isspace(*d));
+
+	if (*d && *d != '\n')	c = d;
+    }
+    return c;
+}
+
+/* split the function comment into manual page format.
+ * returns TRUE if the DESCRIPTION field was explicit.
+ */
+boolean
+split_function_comment(comment, identifier_name,
+				    terse, description, returns, extra_sections)
+    const char *comment;
+    const char *identifier_name;
+     char **terse;
+     char **description;
+     char **returns;
+     Section **extra_sections;
+{
+    const char *c, *start_text = NULL, *end_text = NULL;
+    char **put_ptr = NULL;
+    Section *first_section, **lastnextsection = &first_section;
+    boolean explicit_description = FALSE;
+    boolean lastblank = TRUE;
+    boolean skip_dash = FALSE;
+    
+    *description = *returns = NULL;
+    if (terse)	*terse = NULL;
+
+    /* for each line... */
+    for (c = comment; *c;)
+    {
+	const char *start_line = c;
+	boolean section_heading;
+	/* remember if it's a blank line */
+	if (*c == '\n')
+	{
+	    lastblank = TRUE;
+	    c++;
+	    continue;
+	}
+
+	/* if the last one was blank, perhaps this one is a section heading
+	 */
+	if (lastblank)
+	{
+	    boolean need_colon = FALSE;
+
+	    /* see if we've found the start of a SECTION */
+	    while (isalnum(*c) || *c == ' ' || *c == '/')
+	    {
+		if (isspace(*c)) need_colon = TRUE;
+		c++;
+	    }
+    
+	    section_heading = (!need_colon && *c == '\n') ||
+			(*c == ':' && (!need_colon || *(c+1) == '\n')) ||
+			(!need_colon && *c == '\0' && start_line == comment);
+	}
+	else
+	    section_heading = FALSE;
+
+	lastblank = FALSE;	/* this one's not blank; for next time */
+
+	if (section_heading)
+	{
+	    size_t section_len = c - start_line; /* length of section name */
+
+	    /* yes, we've found a SECTION; store the previous one (if any) */
+	    if (put_ptr && start_text)
+	    {
+		if (skip_dash)	start_text = skipdash(start_text);
+		*put_ptr = alloc_string(start_text,end_text);
+	    }
+
+	    skip_dash = FALSE;
+
+	    /* check for comments that start with the name of the identifier */
+	    if (start_line == comment &&
+		!strncmp(start_line, identifier_name, section_len))
+	    {
+		put_ptr = description;
+	    }
+
+	    /* only accept NAME if not grouped */
+	    else if (terse && 
+		     (!strncmpi(start_line,"NAME", section_len) ||
+		      !strncmpi(start_line,"FUNCTION", section_len) ||
+		      !strncmpi(start_line,"PROCEDURE", section_len) ||
+		      !strncmpi(start_line,"ROUTINE", section_len))
+		     )
+
+	    {
+		put_ptr = terse;
+		skip_dash = TRUE;
+	    }
+	    else if (!strncmpi(start_line,"DESCRIPTION", section_len))
+	    {
+		explicit_description = TRUE;
+		put_ptr = description;
+	    }
+	    else if (!strncmpi(start_line,"RETURNS", section_len))
+	    {
+		put_ptr = returns;
+	    }
+	    else
+	    {
+		/* allocate a new section */
+		Section *new_section =
+				(Section *)safe_malloc(sizeof *new_section);
+
+		*lastnextsection = new_section;
+		lastnextsection = &new_section->next;
+
+		new_section->name = alloc_string(start_line,c);
+		strtoupper(new_section->name);
+		new_section->text = NULL;
+		new_section->been_output = FALSE; /* not been output yet */
+		put_ptr = &new_section->text;
+	    }
+
+	    /* defer decision about where text starts till we find some */
+	    start_text = NULL;
+
+	    if (*c == ':')	/* skip the terminating : */
+	    {
+		c++;
+
+		/* skip forward to the start of the text */
+		while (*c && *c != '\n' && isspace(*c))
+		    c++;
+
+		/* if we find the text here, then we've got it */
+		if (*c && *c != '\n')
+		    start_text = c;
+	    }
+	}
+	else
+	{
+	    /* are we looking at the top of the function comment? */
+	    if (start_line == comment)
+	    {
+		/* only look for terse comment if not grouped together */
+		if (terse)
+		{
+		    const char *endterse, *afterdash = skipdash(start_line);
+
+		    /* find the end of the terse comment */
+		    while (*c && *c != '\n')
+		     {
+			c++;
+		       /* '.' ends terse description only if it ends sentence */
+		       if (*(c-1)=='.' && *c && isspace(*c))
+                         break;
+		     }
+
+		    endterse = c;
+		    *terse = alloc_string(
+			afterdash < endterse ? afterdash : start_line,
+			endterse);
+
+		    /* skip it if it's a ., and any trailing spaces */
+		    if (*c == '.')
+			do c++; while (*c && *c != '\n' && isspace(*c));
+
+		    start_text = NULL;	/* look for it */
+
+		    if (*c && *c != '\n')
+			/* actually, it's a description, starting here */
+			start_text = c;
+		}
+		/* must be a description starting at the beginning of the line.
+		 */
+		else
+		    start_text = start_line;
+
+		put_ptr = description;
+	    }
+	    else
+		/* have we just located the first real text in a section? */
+		if (put_ptr && !start_text)	start_text = start_line;
+	}
+
+	/* skip the line */
+	if (*c && *c != '\n')
+	    while (*c && *c != '\n')	c++;
+
+	end_text = c;	/* so far, the text ends at the end of this line */
+	if (*c)	c++;
+    }
+
+    /* store the last one */
+    if (put_ptr && start_text)
+    {
+	if (skip_dash)	start_text = skipdash(start_text);
+	*put_ptr = alloc_string(start_text,end_text);
+    }
+
+    /* terminate (or nuke) section list */
+    *lastnextsection = NULL;
+
+    *extra_sections = first_section;
+
+    return explicit_description;
+}
+
+/* see if two parameters are declared identically */
+boolean params_identical(first, second)
+     Parameter *first;
+     Parameter *second;
+{
+    return
+	first->decl_spec.flags == second->decl_spec.flags &&
+
+	/* there may be no decl_spec.text if it's an ellipsis arg */
+	((!first->decl_spec.text && !second->decl_spec.text) ||
+	 (first->decl_spec.text && second->decl_spec.text &&
+	  !strcmp(first->decl_spec.text, second->decl_spec.text))) &&
+
+	((!first->declarator->text && !second->declarator->text) ||
+	 (first->declarator->text && second->declarator->text &&
+	  !strcmp(first->declarator->text, second->declarator->text)));
+}
+
+/* search all the parameters in this grouped manual page for redundancies */
+boolean mark_duplicate_parameters(firstpage)
+     ManualPage *firstpage;
+{
+    Parameter *param;
+    boolean any = FALSE;
+    ManualPage *page;
+
+    for (page = firstpage; page; page = page->next)
+    {
+	if (has_parameters(page->declarator))
+	for (param = page->declarator->head->params.first; param;
+							param = param->next)
+	{
+	    ManualPage *otherpage;
+	    Parameter *otherparam;
+	    
+	    if (always_document_params || param->declarator->comment)
+		any = TRUE;
+
+	    for (otherpage = page->next; otherpage;
+						otherpage = otherpage->next)
+	    {
+		if (has_parameters(otherpage->declarator))
+		for (otherparam = otherpage->declarator->head->params.first;
+		     otherparam;
+		     otherparam = otherparam->next)
+		{
+		    /* do these two look the same? */
+		    if (params_identical(param, otherparam))
+		    {
+			/* order is important for bit positions */
+			enum { NEITHER, US, THEM, BOTH } has_comm = NEITHER;
+			
+			/* work out who has the comment */
+			if (param->declarator->comment)	has_comm |= US;
+			if (otherparam->declarator->comment) has_comm |= THEM;
+
+			switch(has_comm)
+			{
+			case NEITHER:
+			case US:
+			    otherparam->suppress = TRUE;
+			    break;
+			case THEM:
+			    param->suppress = TRUE;
+			    break;
+			case BOTH:
+			    if (!strcmp(param->declarator->comment,
+					    otherparam->declarator->comment))
+				otherparam->suppress = TRUE;
+			    else
+			    {
+				param->duplicate = TRUE;
+				otherparam->duplicate = TRUE;
+			    }
+			    break;
+			}
+		    }
+		}
+	    }
+	}
+    }
+    return any;
+}
+
+/* output a formatting string so that it works with filling on */
+void output_format_string(fmt)
+const char *fmt;
+{
+    while (*fmt)
+    {
+	output->character(*fmt);
+
+	if (*fmt++ == '\n')
+	    output->break_line();	/* break the line */
+    }
+}
+
+/* write the warning for the header */
+void output_warning()
+{
+    output->comment();
+    output->text("WARNING! THIS FILE WAS GENERATED AUTOMATICALLY BY ");
+    output->text(progname);
+    output->text("!\n");
+    output->comment();
+    output->text("DO NOT EDIT! CHANGES MADE TO THIS FILE WILL BE LOST!\n");
+}
+
+void output_includes()
+{
+    IncludeFile *incfile;
+    
+    for (incfile = first_include; incfile; incfile=incfile->next)
+    {
+	char *name = incfile->name;
+	boolean surrounded = *name == '"' || *name == '<';
+	
+	output->text("#include ");
+	if (!surrounded)	output->character('<');
+	output->text(name);
+	if (!surrounded)	output->character('>');
+	output->text("\n");
+	output->break_line();
+	}
+}
+
+int exclude_section(section)
+const char *section;
+{
+    ExcludeSection *exclude;
+
+    for (exclude = first_excluded_section ; exclude ; exclude = exclude->next)
+	if (!strcmp(section, exclude->name)) return 1;
+
+    return 0;
+}
+
+
+/* Writes the entire contents of the manual page specified by basepage. */
+void
+output_manpage(firstpage, basepage, input_files, title, section)
+    /* the first page in the list of all manual pages.  This is used to build
+     * the SEE ALSO section of related pages when group_together is false.
+     */
+    ManualPage *firstpage;
+
+    /* the base page from which the output manual page will be generated.  if
+     * group_together indicates that the user wanted grouped pages, basepage
+     * will always be the same as firstpage, and all the ManualPage's in the
+     * list will be grouped together into the one output page.
+     */
+    ManualPage *basepage;
+
+    int input_files;
+    const char *title;
+    const char *section;
+{
+    ManualPage *page;
+    boolean need_returns;
+    char *terseout, *terse = NULL;
+    boolean exclude_description = exclude_section("DESCRIPTION");
+
+    /* check if there's more than one page in the group */
+    boolean grouped = group_together && firstpage->next;
+
+    /* split up all the function comments for this page */
+    for (page = basepage; page; page = page->next)
+    {
+	boolean explicit_description =
+	    split_function_comment(page->declarator->comment,
+		page->declarator->name,
+		group_together ? (char **)NULL : &terse,
+		&page->description,&page->returns,&page->first_section);
+
+	/* we may need to look harder if RETURNS wasn't easy to find in the
+	 * function comment.
+	 */
+	if (page->returns == NULL)
+	{
+	    /* if there was a retcomment supplied by the declarator, use it if
+	     * we couldn't split anything from the function comment.
+	     */
+	    if (page->declarator->retcomment)
+	    {
+		page->returns = page->declarator->retcomment;
+
+		/* page->returns now owns the string */
+		page->declarator->retcomment = NULL;
+	    }
+	    else
+		/* if there wasn't a RETURNS section, and the DESCRIPTION field
+		 * was not explicit, see if we can split one out of the
+		 * description field.
+		 */
+		if (!explicit_description)
+		{
+		    char *newdesc;
+		    if (split_returns_comment(page->description, &newdesc,
+							    &page->returns))
+		    {
+			free(page->description);
+			page->description = newdesc;
+		    }
+		}
+	}
+
+	if (!group_together)	break;
+    }
+
+    /* work out what we'll actually print as a terse description */
+    terseout = group_terse ? group_terse : (terse ? terse : "Not Described");
+
+    output->header(basepage, input_files, grouped,
+		title ? title : basepage->declarator->name, terseout, section);
+    
+    output->name(NULL);
+    /* output the names of all the stuff documented on this page */
+    for (page = basepage; page; page = page->next)
+    {
+	output->name(page->declarator->name);
+
+	if (!group_together)	break;
+
+	if (page->next)	output->text(",\n");
+    }
+
+    output->terse_sep();
+    output->text(terseout);
+    output->character('\n');
+    
+    if (!exclude_section("SYNOPSIS"))
+    {
+	output->section("SYNOPSIS");
+
+	output->code_start();
+    
+	/* list the include files the user asked us to */
+	output_includes();
+
+	/* if it's a header file, say to #include it */
+	if (header_file)
+	{
+	    output->text("#include <");
+	    if (header_prefix)
+	    {
+		output->text(header_prefix);
+		output->character('/');
+	    }
+	    output->text(basefile);
+	    output->text(">\n");
+	}
+
+	/* can't just use .PP; that may reset our font */
+	if (first_include || header_file)	output->blank_line();
+
+	for (page = basepage; page; page = page->next)
+	{
+	    output_format_string(decl_spec_prefix);
+
+	    /* make sure variables are prefixed extern */
+	    if (!(page->decl_spec->flags & DS_STATIC) &&
+		!is_function_declarator(page->declarator) &&
+		!strstr(page->decl_spec->text, "extern"))
+		output->text("extern ");
+
+	    output_decl_spec(page->decl_spec);
+	    output_format_string(declarator_prefix);
+
+	    /* format it nicely if there's more than one parameter */
+	    output_declarator(page->declarator, 
+		page->declarator->head->params.first !=
+		page->declarator->head->params.last);
+
+	    output->text(";\n");
+    
+	    if (!grouped)	break;
+	    if (page->next)	output->blank_line();
+	}
+
+	output->code_end();
+    }
+
+    /* only output paramaters if there actually are some,
+     * not including merely (void)
+     */
+    if (!exclude_section("PARAMETERS") &&
+	    ((grouped && mark_duplicate_parameters(basepage)) ||
+	     (!grouped && has_documented_parameters(basepage->declarator))))
+    {
+	output->section("PARAMETERS");
+
+	for (page = basepage; page; page = page->next)
+	{
+	    if (has_parameters(page->declarator))
+		output_parameter_descriptions(&page->declarator->head->params,
+						    page->declarator->name);
+	    if (!grouped)	break;	/* only do first page */
+	}
+    }
+
+    if (!exclude_description)
+	output->section("DESCRIPTION");
+
+    if (grouped)
+    {
+	need_returns = FALSE;
+	for (page = basepage; page; page = page->next)
+	{
+	    if (needs_returns_section(page))	need_returns = TRUE;
+
+	    if (!exclude_description)
+	    {
+		/* enum variables are documented in DESCRIPTION */
+		if (auto_documented(page) &&
+				    !is_function_declarator(page->declarator))
+		{
+		    output->sub_section(page->declarator->name);
+		    output_identifier_description(page->description,
+			output_comment, page->decl_spec, page->declarator);
+		}
+		else if (page->description)
+		{
+		    output->sub_section(page->declarator->name);
+		    output_comment(page->description);
+		}
+	    }
+
+	    safe_free(page->description);
+	}
+    }
+    else
+    {
+	need_returns = needs_returns_section(basepage);
+
+	if (!exclude_description)
+	{
+	    const char *descr = basepage->description
+					? basepage->description : terseout;
+
+	    if (auto_documented(page) &&
+				    !is_function_declarator(page->declarator))
+		output_identifier_description(descr, output_comment,
+					    page->decl_spec, page->declarator);
+	    else
+		output_comment(descr);
+	}
+
+	safe_free(basepage->description);
+    }
+
+    /* terse can now never be a static string */
+    safe_free(terse);
+
+    if (need_returns && !exclude_section("RETURNS"))
+    {
+	output->section("RETURNS");
+
+	for (page = basepage; page; page = page->next)
+	{
+	    if (needs_returns_section(page))
+	    {
+		if (grouped) output->sub_section(page->declarator->name);
+
+		output_identifier_description(page->returns, output->returns,
+					    page->decl_spec, page->declarator);
+		safe_free(page->returns);
+	    }
+
+	    if (!grouped)	break;
+	}
+    }
+
+    /* output any other sections */
+    for (page = basepage; page; page = page->next)
+    {
+	Section *section, *next;
+
+	for (section = page->first_section; section; section = next)
+	{
+	    next = section->next;
+
+	    if (!section->been_output && section->text &&
+		strncmpi(section->text,"none",4) &&
+		 !exclude_section(section->name))
+	    {
+		output->section(section->name);
+		if (grouped) output->sub_section(page->declarator->name);
+		output_comment(section->text);
+		section->been_output = TRUE;
+    
+		if (grouped && page->next)
+		{
+		    ManualPage *other_page = page->next;
+    
+		    /* look through all the other pages for matching sections */
+		    for (; other_page; other_page = other_page->next)
+		    {
+			Section *other_section = other_page->first_section;
+			for (;other_section; other_section =
+							    other_section->next)
+			{
+			    if (other_section->been_output ||
+				strcmp(other_section->name, section->name))
+				continue;
+    
+			    output->sub_section(other_page->declarator->name);
+			    output_comment(other_section->text);
+			    other_section->been_output = TRUE;
+			}
+		    }
+		}
+	    }
+
+
+	    /* free this section */
+	    free(section->name);
+	    safe_free(section->text);
+	    free(section);
+	}
+
+	if (!grouped)	break;
+    }
+
+    /* only output SEE ALSO if not grouped */
+    if (!group_together)
+    {
+	ManualPage *also;
+
+	/* add the SEE ALSO section */
+	/* look for any other functions to refer to */
+	for (also = firstpage; also && also == basepage; also = also->next)
+		;
+	
+	if (also && !exclude_section("SEE ALSO"))	/* did we find at least one? */
+	{
+	    int isfirst = 1;
+
+	    output->section("SEE ALSO");
+	    
+	    for (also = firstpage; also; also = also->next)
+	    {
+		if (also == basepage)	continue;
+		
+		if (!isfirst)
+		    output->text(",\n");
+		else
+		    isfirst = 0;
+		    
+		output->reference(also->declarator->name);
+	    }
+	
+	    output->character('\n');
+	}
+    }
+
+    if (!make_embeddable)
+	output->file_end();
+}
+
+
+/* generate output filename based on a string */
+char *page_file_name(based_on, object_type, extension)
+    /* string to base the name on; this will be the name of an identifier or
+     * the base of the input file name.
+     */
+    const char *based_on;
+    enum Output_Object object_type;	/* class of object documented */
+    const char *extension;		/* file extension to use */
+{
+    char *filename;
+    const char *subdir = output_object[object_type].subdir;
+
+#ifndef FLEXFILENAMES
+    char *basename;
+    int chopoff = 14 - strlen(extension) - 1;
+
+    basename = strduplicate(based_on);
+    if (strlen(basename) > chopoff)
+	basename[chopoff] = '\0';
+#else
+    const char *basename = based_on;
+#endif
+
+    filename = strduplicate(output_dir);
+
+    if (subdir)
+    {
+	if (filename)	filename = strappend(filename, "/", NULLCP);
+	filename = strappend(filename, subdir, NULLCP);
+    }
+
+    if (filename)	filename = strappend(filename, "/", NULLCP);
+    filename = strappend(filename, basename,".",extension, NULLCP);
+
+#ifndef FLEXFILENAMES
+    free(basename);
+#endif
+    return filename;
+}
+
+/* determine the output page type from a declaration */
+enum Output_Object page_output_type(decl_spec, declarator)
+const DeclSpec *decl_spec;
+const Declarator *declarator;
+{
+    boolean is_static = decl_spec->flags & DS_STATIC;
+    return is_function_declarator(declarator)
+	? (is_static ? OBJECT_STATIC_FUNCTION : OBJECT_FUNCTION)
+	: (is_static ? OBJECT_STATIC_VARIABLE : OBJECT_VARIABLE);
+}
+
+/* determine the extension/section from an output type */
+const char *page_manual_section(output_type)
+enum Output_Object output_type;
+{
+    return	output_object[output_type].extension ?
+		output_object[output_type].extension : manual_section;
+}
+
+/* remove an existing file, if it exists & we have write permission to it */
+int remove_old_file(name)
+const char *name;
+{
+#ifdef HAS_ACCESS
+    /* check that we have write premission before blasting it */
+    if (access(name,W_OK) == -1)
+    {
+	if (errno != ENOENT)
+	{
+	    my_perror("can't access output file", name);
+	    return FALSE;
+	}
+     }
+    else
+#endif
+    {
+	/* if it exists, blast it */
+	if (unlink(name) == -1 && errno != ENOENT)
+	{
+	    my_perror("error unlinking old link file", name);
+	    return FALSE;
+	}
+    }
+    return TRUE;
+}
+
+/* output all the manual pages in a list */
+void output_manual_pages(first, input_files, link_type)
+    ManualPage *first;
+    int input_files;	/* number of different input files */
+    enum LinkType link_type;	/* how grouped pages will be linked */
+{
+    ManualPage *page;
+    int tostdout = output_dir && !strcmp(output_dir,"-");
+
+    char *filename = NULL;
+
+    /* output each page, in turn */
+    for (page = first; page; page = page->next)
+    {
+	char *input_file_base = NULL;
+	enum Output_Object output_type =
+			page_output_type(page->decl_spec, page->declarator);
+
+	/* the manual name is used as the output file extension, and also in
+	 * the nroff output header.
+	 */
+	const char *section = page_manual_section(output_type);
+
+	/* work out the base name of the file this was generated from */
+	if (page->sourcefile)
+	{
+	    const char *base = strrchr(firstpage->sourcefile, '/');
+	    const char *last;
+    
+	    /* use the file name as the manual page title */
+	    if (base == NULL)
+		base = firstpage->sourcefile;
+	    else
+		base++;
+	    last = strrchr(base, '.');
+	    if (last == NULL)
+		last = base + strlen(base);
+    
+	    input_file_base = alloc_string(base, last);
+	}
+
+	if (!tostdout)
+	{
+	    safe_free(filename);	/* free previous, if any */
+	    filename = page_file_name(
+		use_input_name && input_file_base
+				? input_file_base : page->declarator->name,
+		output_type, section);
+	    fprintf(stderr,"generating: %s\n",filename);
+
+	    /* a previous run may have left links, so nuke old file first */
+	    if (!remove_old_file(filename))	exit(1);
+
+	    if (freopen(filename, "w", stdout) == NULL)
+	    {
+		my_perror("error opening output file", filename);
+		free(filename);
+		exit(1);
+	    }
+	}
+
+	/* do the page itself */
+	output_manpage(first, page, input_files,
+	    group_together && input_file_base ? input_file_base
+					      : page->declarator->name,
+	    group_together ? manual_section : section);
+
+	safe_free(input_file_base);
+
+	/* don't continue if grouped, because all info went into this page */
+	if (group_together)		break;
+
+	if (tostdout &&	page->next)	output->character('\f');
+    }
+
+    /* close the last output file if there was one */
+    if (!tostdout && fclose(stdout) == EOF)
+    {
+	my_perror("error linking closing file", filename);
+	exit(1);
+    }
+
+    /* if pages are grouped, just link the rest to the first */
+    if (group_together && !tostdout && link_type != LINK_NONE)
+    {
+	for (page=use_input_name && first->sourcefile ? first : first->next;
+						    page; page = page->next)
+	{
+	    enum Output_Object output_type =
+			page_output_type(page->decl_spec, page->declarator);
+	    const char *extension = page_manual_section(output_type);
+	    char *linkname = page_file_name(page->declarator->name,
+							output_type, extension);
+	    int result = 0;
+
+	    /* we may have a function with the same name as the sourcefile */
+	    if (!strcmp(filename, linkname))
+	    {
+		free(linkname);
+		continue;
+	    }
+			
+	    fprintf(stderr,"%s: %s\n",
+		link_type == LINK_REMOVE ? "removing" : "linking", linkname);
+
+	    /* always nuke old output file, since it may be linked to the one
+	     * we've just generated, so LINK_FILE may trash it.
+	     */
+	    if (!remove_old_file(linkname))	exit(1);
+
+	    switch(link_type)
+	    {
+#ifdef HAS_LINK
+	    case LINK_HARD:
+		result = link(filename, linkname);
+		break;
+#endif
+#ifdef HAS_SYMLINK
+	    case LINK_SOFT:
+		result = symlink(filename, linkname);
+		break;
+#endif
+	    case LINK_FILE:
+		if (freopen(linkname, "w", stdout) == NULL)
+		{
+		    result = -1;
+		    break;
+		}
+		output_warning();
+		output->include(filename);
+		if (fclose(stdout) == EOF)
+		    result = -1;
+		break;
+	    case LINK_NONE:
+	    case LINK_REMOVE:
+		break;
+	    }
+
+	    /* check it went OK */
+	    if (result == -1)
+	    {
+		my_perror("error linking output file", linkname);
+		exit(1);
+	    }
+	    free(linkname);
+	}
+    }
+
+    safe_free(filename);
+}
diff --git a/manpage.h b/manpage.h
new file mode 100644
index 0000000..8fdcb09
--- /dev/null
+++ b/manpage.h
@@ -0,0 +1,64 @@
+/* $Id: manpage.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * stuff to do with manual page outputing
+ */
+#ifndef MANPAGE_H
+#define MANPAGE_H
+
+#include "c2man.h"
+
+typedef struct Section Section;
+struct Section
+{
+    Section *next;
+    char *name;
+    char *text;
+    boolean been_output;
+};
+
+typedef struct ManualPage ManualPage;
+struct ManualPage
+{
+    DeclSpec *decl_spec;
+    Declarator *declarator;
+    ManualPage *next;
+    Section *first_section;
+    char *description;
+    char *returns;
+    char *sourcefile;
+    Time_t sourcetime;
+};
+
+enum LinkType
+{
+#ifdef HAS_LINK
+    LINK_HARD,	/* filesystem hard link */
+#endif
+#ifdef HAS_SYMLINK
+    LINK_SOFT,	/* filesystem soft link */
+#endif
+    LINK_FILE,	/* nroff file with .so directive */
+    LINK_NONE,	/* don't create extra links for it */
+    LINK_REMOVE	/* don't create extra links & remove existing ones */
+};
+
+/* list of manual pages */
+extern ManualPage *firstpage;
+
+void
+new_manual_page _((char *comment, DeclSpec *decl_spec, Declarator *declarator));
+
+/* remember the terse description from the first comment in a file */
+void remember_terse _((char *comment));
+
+void output_manual_pages _((ManualPage *first, int num_input_files,
+    enum LinkType link_type));
+
+void free_manual_pages _((ManualPage *first));
+
+void output_format_string _((const char *fmt));
+
+void output_warning _((void));
+
+void output_comment _((const char *comment));
+
+#endif
diff --git a/nroff.c b/nroff.c
new file mode 100644
index 0000000..174d8b4
--- /dev/null
+++ b/nroff.c
@@ -0,0 +1,424 @@
+/* $Id: nroff.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * functions for nroff style output.
+ */
+#include "c2man.h"
+#include "manpage.h"
+#include "output.h"
+#include "semantic.h"
+#include <ctype.h>
+
+void nroff_text(text)
+const char *text;
+{
+    put_string(text);
+}
+
+void nroff_char(c)
+const int c;
+{
+    putchar(c);
+}
+
+void nroff_comment() { put_string(".\\\" "); }
+
+void nroff_header(firstpage, input_files, grouped, name, terse, section)
+ManualPage *firstpage;
+int input_files;
+boolean grouped;
+const char *name;
+const char *terse;
+const char *section;
+{
+#ifdef HAS_STRFTIME
+    char month[20];
+#else
+    char *month;
+    static char *month_list[] =
+    { "January", "February", "March", "April", "May", "June",
+      "July", "August", "September", "October", "November", "December" };
+#endif
+    Time_t raw_time;
+    struct tm *filetime;
+    
+    if (make_embeddable) return;
+
+    output_warning();
+    put_string(".TH \"");
+
+    /* if lots of files contributed, use the current time; otherwise use the
+     * time of the source file they came from.
+     */
+    raw_time = (grouped && input_files > 1) ? time((Time_t *)NULL)
+					    : firstpage->sourcetime;
+
+    filetime = localtime(&raw_time);
+
+#ifdef HAS_STRFTIME
+    /* generate the date format string */
+    strftime(month, sizeof month,"%B",filetime);
+#else
+    month = month_list[filetime->tm_mon];
+#endif
+
+    nroff_text(name);
+
+    printf("\" %s \"%d %s %d\"",
+		section,filetime->tm_mday,month,filetime->tm_year+1900);
+
+/* I have conflicting info about how the .TH macro works.... */
+#ifdef HENRYS_TH /* As per Henry Spencer's "How to write a manual page" */
+    if (manual_name) printf(" \"%s\"", manual_name);
+    put_string("\n.BY");    
+#endif
+    printf(" \"%s",progname);
+    if ((input_files <= 1 || !grouped) && firstpage->sourcefile)
+    {
+	const char *basename = strrchr(firstpage->sourcefile, '/');
+	if (basename == NULL)
+	    basename = firstpage->sourcefile;
+	else
+	    basename++;
+	printf(" %s", basename);
+    }
+#ifndef HENRYS_TH
+    if (manual_name) printf("\" \"%s", manual_name);
+#endif
+    put_string("\"\n");    
+
+#ifdef NeXT
+    /* define our own .SS on packages (such as NeXT's) where it doesn't move
+     * left a little. Sorry, awf doesn't support .SS.
+     */
+    put_string(".de SS\n.}X .25i \"\" \"\"\n.nr )E 2\n");
+    put_string("\\&\\\\$1\n.br\n..\n");
+#endif
+}
+
+void nroff_dash()	{ put_string("\\-"); }
+
+void nroff_section(name)
+const char *name;
+{
+    put_string(".SH \"");
+    nroff_text(name);
+    put_string("\"\n");
+}
+
+void nroff_sub_section(name)
+const char *name;
+{
+    put_string(".SS \"");
+    nroff_text(name);
+    put_string("\"\n");
+}
+
+void nroff_break_line()	{ put_string(".br\n"); }
+void nroff_blank_line() { put_string(".sp\n"); }
+
+void nroff_code_start() { put_string(".ft B\n"); }
+void nroff_code_end()	{ put_string(".ft R\n"); }
+
+void nroff_code(text)
+const char *text;
+{
+    put_string("\\fB");
+    nroff_text(text);
+    put_string("\\fR");
+}
+
+void nroff_tag_entry_start()		{ put_string(".TP\n.B \""); }
+void nroff_tag_entry_start_extra()	{ put_string(".TP\n.BR \""); }
+void nroff_tag_entry_end()		{ put_string("\"\n"); }
+void nroff_tag_entry_end_extra(text)
+const char *text;
+{
+    put_string("\" \"\t(");
+    nroff_text(text);
+    put_string(")\"\n");
+}
+	
+void nroff_table_start(longestag)
+const char *longestag;
+{
+    void nroff_list_start();
+    nroff_list_start();
+
+    /* We measure the length of the longest tag in the table by changing to the
+     * code font, taking it's width with \w'string' and adding a little for
+     * the space between the tag and description.  This gets stored in the TL
+     * number register, where the nroff_table_entry can find it.
+     * This isn't foolproof, because a shorter tag may be longer if it contains
+     * wider characters, but the extra space gives a little head room anyway.
+     */
+    nroff_code_start();
+    printf(".nr TL \\w'%s'u+0.2i\n", longestag);
+    nroff_code_end();
+}
+
+void nroff_table_entry(name, description)
+const char *name;
+const char *description;
+{
+    put_string(".TP \\n(TLu\n");
+
+    nroff_code(name);
+    nroff_char('\n');
+    if (description)
+	output_comment(description);
+    else
+	nroff_char('\n');
+}
+
+void nroff_table_end()	{ put_string(".RE\n.PD\n"); }
+
+void nroff_indent()	{ put_string(".IP\n"); }
+
+void nroff_list_start() { put_string(".RS 0.75in\n.PD 0\n"); }
+
+void nroff_list_entry(name)
+const char *name;
+{
+    nroff_code(name);
+}
+
+void nroff_list_separator() { put_string(",\n"); }
+void nroff_list_end()	{ nroff_char('\n'); nroff_table_end(); }
+
+void nroff_include(filename)
+const char *filename;
+{
+    printf(".so %s\n", filename);
+}
+
+void nroff_name(name)
+const char *name;
+{
+    if (name) nroff_text(name);
+    else      nroff_section("NAME");
+}
+
+void nroff_terse_sep()
+{
+    nroff_char(' ');
+    nroff_dash();
+    nroff_char(' ');
+}
+
+void nroff_emphasized(text)
+const char *text;
+{
+    put_string("\\fI");
+    nroff_text(text);
+    put_string("\\fR");
+}
+
+void nroff_reference(text)
+const char *text;
+{
+    nroff_text(text);
+    nroff_char('(');
+    nroff_text(manual_section);
+    nroff_char(')');
+}
+
+void nroff_description(text)
+const char *text;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    boolean new_line = TRUE;
+    boolean dot_command = FALSE;
+    
+    /* correct punctuation a bit as it goes out */
+    for (;*text;text++)
+    {
+	int c = *text;
+
+	if (dot_command)
+	{
+	    if (c == '\n')	dot_command = FALSE;
+	}
+	else if (new_line && c == '.')
+	    dot_command = TRUE;
+	else if (new_line && (c == '-' || c == '*' || is_numbered(text)))
+	{
+	    output->break_line();
+	    state = CAPITALISE;
+	}
+	else if (c == '.')
+	    state = PERIOD;
+	else if (isspace(c) && state == PERIOD)
+	    state = CAPITALISE;
+	else if (isalnum(c))
+	{   
+	    if (islower(c) && state == CAPITALISE)	c = toupper(c);
+	    state = TEXT;
+	}
+           
+	output->character(c);
+	new_line = c == '\n';
+    }
+
+    /* do a full stop if there wasn't one */
+    if (!dot_command && state == TEXT)	output->character('.');
+}
+
+void
+nroff_returns(comment)
+const char *comment;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    char lastchar = '\n';
+    boolean tag_list_started = FALSE;
+
+    /* for each line... */
+    while (*comment)
+    {
+	boolean tagged = FALSE;
+
+	/* explicitly reject dot commands */
+	if (*comment && *comment != '.')
+	{
+	    const char *c = comment;
+
+	    /* search along until the end of a word */
+	    while (*c && *c != ':' && !isspace(*c))
+		c++;
+
+	    /* skip all spaces or tabs after the first word */
+	    while (*c && *c != '\n')
+	    {
+		if (*c == '\t' || *c == ':')
+		{
+		    tagged = TRUE;
+		    break;
+		}
+		else if (!isspace(*c))
+		    break;
+
+		c++;
+	    }
+	}
+
+	/* is it tagged?; explicitly reject dot commands */
+	if (tagged)
+	{
+	    /* output lingering newline if necessary */
+	    if (lastchar != '\n')
+	    {
+		if (state == TEXT && !ispunct(lastchar))	output->character('.');
+		output->character(lastchar = '\n');
+	    }
+
+	    if (!tag_list_started)
+	    {
+		output->tag_list_start();
+		tag_list_started = TRUE;
+	    }
+
+	    /* output the taggy bit */
+	    output->tag_entry_start();
+	    while (*comment && *comment != ':' && !isspace(*comment))
+		output->character(*comment++);
+	    output->tag_entry_end();
+
+	    /* skip any extra tabs or spaces */
+	    while (*comment == ':' || (isspace(*comment) && *comment != '\n'))
+		comment++;
+
+	    state = CAPITALISE;
+	}
+
+	/* terminate the previous line if necessary */
+	if (lastchar != '\n')	output->character(lastchar = '\n');
+
+	/* dot commands go out unaltered */
+	if (*comment == '.')
+	{
+	    for (;*comment && *comment != '\n'; comment++)
+		output->character(*comment);
+	    output->character('\n');
+	}
+	else
+	{
+	    /* correct punctuation a bit as the line goes out */
+	    for (;*comment && *comment != '\n'; comment++)
+	    {
+		char c = *comment;
+
+		if (c == '.')
+		    state = PERIOD;
+		else if (isspace(c) && state == PERIOD)
+		    state = CAPITALISE;
+		else if (isalnum(c))
+		{   
+		    if (islower(c) && state == CAPITALISE && fixup_comments)
+			c = toupper(c);
+		    state = TEXT;
+		}
+
+		output->character(lastchar = c);
+	    }
+
+	    /* if it ended in punctuation, just output the nl straight away. */
+	    if (ispunct(lastchar))
+	    {
+		if (lastchar == '.')	state = CAPITALISE;
+		output->character(lastchar = '\n');
+	    }
+	}
+
+	if (*comment)	comment++;
+    }
+
+    /* output lingering newline if necessary */
+    if (lastchar != '\n')
+    {
+	if (state == TEXT && !ispunct(lastchar) && fixup_comments)
+	    output->character('.');
+	output->character('\n');
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+
+struct Output nroff_output =
+{
+    nroff_comment,
+    nroff_header,
+    nroff_dash,
+    nroff_section,
+    nroff_sub_section,
+    nroff_break_line,
+    nroff_blank_line,
+    nroff_code_start,
+    nroff_code_end,
+    nroff_code,
+    dummy,		/* nroff_tag_list_start */
+    dummy,		/* nroff_tag_list_end */
+    nroff_tag_entry_start,
+    nroff_tag_entry_start_extra,
+    nroff_tag_entry_end,
+    nroff_tag_entry_end_extra,
+    nroff_table_start,
+    nroff_table_entry,
+    nroff_table_end,
+    nroff_indent,
+    nroff_list_start,
+    nroff_code,		/* nroff_list_entry */
+    nroff_list_separator,
+    nroff_list_end,
+    nroff_include,
+    dummy,       /* nroff_file_end */
+    nroff_text,
+    nroff_char,
+    NULL,	/* nroff_parse_option */
+    dummy,	/* nroff_print_options */
+    nroff_name,
+    nroff_terse_sep,
+    nroff_reference,
+    nroff_emphasized,
+    nroff_description,
+    nroff_returns
+};
diff --git a/output.h b/output.h
new file mode 100644
index 0000000..a968401
--- /dev/null
+++ b/output.h
@@ -0,0 +1,149 @@
+/* $Id: output.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * format-independant output interface.
+ */
+#ifndef OUTPUT_H
+#define OUTPUT_H
+
+/* To add a new output format:
+ * 1. Add the new -Tx suboption to the manual page.
+ * 2. Add handling for the new suboption to c2man.c, including the default
+ *    output file extension.
+ * 3. Copy nroff.c to xxx.c and change the xxx_... output functions and the
+ *    pointers in the xxx_output structure so the new xxx_output object
+ *    generates the correct output constructs. Try to do this without modifying
+ *    manpage.c if possible; add new output functions only if necessary.
+ * 4. Add the new xxx_output structure to the declaration of output structures
+ *    at the end of this file.
+ */
+
+/* Output object defines what type of output is being generated.
+ * This contains pointers to functions that generate each type of output
+ * construct.
+ */
+struct Output
+{
+    /* comment until the end of the line */
+    void (*comment) _((void));
+
+    /* header and introduction to the file */
+    void (*header) _((ManualPage *firstpage, int input_files, boolean grouped,
+		    const char *name, const char *terse, const char *section));
+    
+    /* a dash */
+    void (*dash) _((void));
+    
+    /* start of a main section */
+    void (*section) _((const char *name));
+
+    /* start of a sub section */
+    void (*sub_section) _((const char * name));
+
+    /* break the current line here */
+    void (*break_line) _((void));
+
+    /* a blank line */
+    void (*blank_line) _((void));
+
+    /* switch into the mode to include declarations like in program code */
+    void (*code_start) _((void));
+
+    /* switch back from code mode to normal */
+    void (*code_end) _((void));
+    
+    /* output a single string in code font */
+    void (*code) _((const char *text));
+
+    /* start a list of tagged paragraphs */
+    void (*tag_list_start) _((void));
+
+    /* end a list of tagged paragraph */
+    void (*tag_list_end) _((void));
+
+    /* start a tagged paragraph: the tag should go straight after this */
+    void (*tag_entry_start) _((void));
+
+    /* start a tagged paragraph that has an extra non-code bit at the end
+     * of the tag: the tag should go straight after this
+     */
+    void (*tag_entry_start_extra) _((void));
+
+    /* end the tag on a tagged paragraph */
+    void (*tag_entry_end) _((void));
+
+    /* end the tag on a tagged paragraph with an extra non-code bit at the end
+     * of the tag.
+     */
+    void (*tag_entry_end_extra) _((const char *text));
+
+    /* start a name/value pair table */
+    void (*table_start) _((const char *longestag));
+
+    /* an entry in the name/value pair table */
+    void (*table_entry) _((const char *name, const char * description));
+    
+    /* end the name/value pair table */
+    void (*table_end) _((void));
+
+    /* an indented paragraph */
+    void (*indent) _((void));
+
+    /* start a list */
+    void (*list_start) _((void));
+
+    /* an entry in the list */
+    void (*list_entry) _((const char *name));
+
+    /* the seperator between one entry in a list and the next */
+    void (*list_separator) _((void));
+
+    /* end the list */
+    void (*list_end) _((void));
+
+    /* include another file in the output */
+    void (*include) _((const char *filename));
+
+    /* end the file */
+    void (*file_end) _((void));
+
+    /* output string, quoted to protect against formatter controls */
+    void (*text) _((const char *text));
+
+    /* output char, quoted to protect against formatter controls */
+    void (*character) _((const int c));
+
+    /* parse formatter specific option. set to NULL if not available */
+    int	 (*parse_option) _((const char *option));
+
+    /* print formatter specific options to stderr. */
+    void (*print_options) _((void));
+
+    /* output NAME section header and section names */
+    void (*name) _((const char *name));
+
+    /* output separators between section name and terse description */
+    void (*terse_sep) _((void));
+
+    /* output string, making it a hypertext reference */
+    void (*reference) _((const char *text));
+
+    /* output string, displaying it emphasized (usually italic) */
+    void (*emphasized) _((const char *text));
+
+    /* output description, fixing punctuation but leaving formatter commands */
+    void (*description) _((const char *text));
+
+    /* output returns text, fixing punct. but leaving formatter commands */
+    void (*returns) _((const char *text));
+};
+
+/* pointer to the relevant output structure */
+extern struct Output *output;
+
+/* output structures for all formats we support */
+extern struct Output nroff_output, texinfo_output, latex_output, html_output,
+    autodoc_output;
+
+/* dummy routine which does nothing */
+void dummy _((void));
+
+#endif
diff --git a/patchlevel.h b/patchlevel.h
new file mode 100644
index 0000000..2d23afc
--- /dev/null
+++ b/patchlevel.h
@@ -0,0 +1,2 @@
+#define VERSION 2
+#define PATCHLEVEL 41
diff --git a/semantic.c b/semantic.c
new file mode 100644
index 0000000..1dac9b5
--- /dev/null
+++ b/semantic.c
@@ -0,0 +1,732 @@
+/* $Id: semantic.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * C manual page generator
+ * These routines implement the semantic actions executed by the yacc parser.
+ */
+#include "c2man.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include "semantic.h"
+#include "enum.h"
+#include "manpage.h"
+#include "strconcat.h"
+#include "output.h"
+
+/* Return TRUE if the given identifier is really a typedef name.
+ * Search the symbol table for the identifier.
+ */
+boolean
+is_typedef_name (name)
+char *name;
+{
+    return (boolean)(find_symbol(typedef_names, name) != NULL);
+}
+
+/* Initialize a new declaration specifier part.
+ */
+void
+new_decl_spec (decl_spec, text, flags)
+DeclSpec *decl_spec;
+char *text;
+int flags;
+{
+    decl_spec->text = text ? strduplicate(text) : NULL;
+    decl_spec->flags = flags;
+    decl_spec->enum_list = NULL;
+}
+
+/* Free storage used by a declaration specifier part.
+ */
+void
+free_decl_spec (decl_spec)
+DeclSpec *decl_spec;
+{
+    safe_free(decl_spec->text);	/* could be an ellipsis you know */
+}
+
+/* Initialize a new declaration specifier part, including an enum part.
+ */
+void
+new_enum_decl_spec (decl_spec, text, flags, enum_list)
+DeclSpec *decl_spec;
+char *text;
+int flags;
+EnumeratorList *enum_list;
+{
+    decl_spec->text = text;
+    decl_spec->flags = flags;
+    decl_spec->enum_list = enum_list;
+}
+
+/* Initialize a new declaration specifier part, but don't strdup the text. */
+void
+dyn_decl_spec (decl_spec, text, flags)
+DeclSpec *decl_spec;
+char *text;
+unsigned int flags;
+{
+    decl_spec->text = text;
+    decl_spec->flags = flags;
+    decl_spec->enum_list = NULL;
+}
+
+/* Append two declaration specifier parts together.
+ */
+void
+join_decl_specs (result, a, b)
+DeclSpec *result, *a, *b;
+{
+    if (a->text)
+    {
+	if (b->text)
+	{
+	    result->text = strconcat(a->text, " ", b->text, NULLCP);
+	    free(a->text);
+	    free(b->text);
+	}
+	else
+	    result->text = a->text;
+    }
+    else
+	result->text = b->text;
+    
+    result->flags = a->flags | b->flags;
+    
+    /* only one of the decl specs should have an enum list! */
+    result->enum_list = a->enum_list ? a->enum_list : b->enum_list;
+}
+
+/* Allocate and initialize a declarator. */
+Declarator *
+new_declarator (text, name)
+char *name, *text;
+{
+    Declarator *d;
+
+    d = (Declarator *)safe_malloc(sizeof(Declarator));
+    d->text = text;
+    d->name = name;
+    d->type = DECL_SIMPLE;
+    d->comment = NULL;
+    d->retcomment = NULL;
+    new_ident_list(&d->params);
+    d->head = d;
+    d->func_stack = NULL;
+    return d;
+}
+
+/* Free storage used by a declarator.
+ */
+void
+free_declarator (d)
+Declarator *d;
+{
+#ifdef DEBUG
+    fprintf(stderr,"free_declarator: decl = %lx, name = %s, text = %s\n",
+	(long)d, d->name?d->name:"NULL", d->text?d->text:"NULL");
+#endif
+    safe_free(d->name);	/* could be an ellipsis (ie: no name) */
+    safe_free(d->text);	/* ellipsis is marked by no text too */
+    safe_free(d->comment);
+    safe_free(d->retcomment);
+    free_param_list(&(d->params));
+    if (d->func_stack != NULL)
+	free_declarator(d->func_stack);
+    free(d);
+}
+
+/* add a comment to the last declarator in the list */
+int
+comment_last_decl(list, comment)
+DeclaratorList *list;
+char *comment;
+{
+    if (list->last->comment)
+    {
+	declarator_error(list->last);
+	free(comment);
+	return 0;
+    }
+    else
+	list->last->comment = comment;
+    return 1;
+}
+
+/* Initialize a declarator list and add the given declarator to it.
+ */
+void
+new_decl_list (decl_list, declarator)
+DeclaratorList *decl_list;
+Declarator *declarator;
+{
+    decl_list->first = decl_list->last = declarator;
+    declarator->next = NULL;
+}
+
+/* Free storage used by the declarators in the declarator list.
+ */
+void
+free_decl_list (decl_list)
+DeclaratorList *decl_list;
+{
+    Declarator *d, *next;
+#ifdef DEBUG
+    fprintf(stderr,"free_decl_list: decl_list = %lx, first = %lx\n",
+    	(long)decl_list, (long)decl_list->first);
+#endif
+    d = decl_list->first;
+    while (d != NULL) {
+	next = d->next;
+	free_declarator(d);
+	d = next;
+    }
+}
+
+/* Add the declarator to the declarator list.
+ */
+void
+add_decl_list (to, from, declarator)
+DeclaratorList *to, *from;
+Declarator *declarator;
+{
+    to->first = from->first;
+    from->last->next = declarator;
+    to->last = declarator;
+    to->last->next = NULL;
+}
+
+/* Initialize the parameter structure.
+ */
+void
+new_parameter (param, decl_spec, declarator, comment_before, comment_after)
+Parameter *param;		/* pointer to structure to be initialized */
+DeclSpec *decl_spec;		/* declaration specifier structure */
+Declarator *declarator;		/* declarator structure */
+char *comment_before;		/* comment before the param */
+char *comment_after;		/* comment after the param */
+{
+
+    if (decl_spec == NULL) {
+	new_decl_spec(&(param->decl_spec), NULLCP, DS_JUNK);
+    } else {
+	param->decl_spec = *decl_spec;
+    }
+
+    if (declarator == NULL) {
+	declarator = new_declarator(NULLCP, NULLCP);
+    }
+    param->declarator = declarator;
+
+    if (comment_before && comment_after)
+    {
+	parameter_error(param);
+	free(comment_after);	/* comment_before will go in Parameter */
+    }
+
+    param->declarator->comment =
+			comment_before ? comment_before : comment_after;
+    param->suppress = FALSE;
+    param->duplicate = FALSE;
+}
+
+/* Free the storage used by the parameter.
+ */
+void
+free_parameter (param)
+Parameter *param;
+{
+    free_decl_spec(&(param->decl_spec));
+    free_declarator(param->declarator);
+}
+
+/* add a comment to the last parameter in the list */
+int
+comment_last_parameter(list, comment)
+ParameterList *list;
+char *comment;
+{
+    if (list->last == NULL)
+    {
+	yyerror("comment '%s' applies to non-existent parameter", comment);
+	free(comment);
+	return 0;
+    }
+
+    if (list->last->declarator->comment)
+    {
+	parameter_error(list->last);
+	free(comment);
+	return 0;
+    }
+    else
+	list->last->declarator->comment = comment;
+    return 1;
+}
+
+/* Initialize a list of function parameters.
+ */
+void
+new_param_list (param_list, param)
+ParameterList *param_list;
+Parameter *param;
+{
+    Parameter *p;
+
+    p = (Parameter *)safe_malloc((unsigned)sizeof(Parameter));
+    *p = *param;
+    
+    param_list->first = param_list->last = p;
+    p->next = NULL;
+}
+
+/* Free storage used by the elements in the function parameter list.
+ */
+void
+free_param_list (param_list)
+ParameterList *param_list;
+{
+    Parameter *p, *next;
+
+    p = param_list->first;
+    while (p != NULL) {
+	next = p->next;
+	free_parameter(p);
+	free(p);
+	p = next;
+    }
+}
+
+/* Add the function parameter declaration to the list.
+ */
+void
+add_param_list (to, from, param)
+ParameterList *to, *from;
+Parameter *param;
+{
+    Parameter *p;
+
+    p = (Parameter *)safe_malloc((unsigned)sizeof(Parameter));
+    *p = *param;
+
+    to->first = from->first;
+    from->last->next = p;
+    to->last = p;
+    p->next = NULL;
+}
+
+/* Initialize an empty list of function parameter names.
+ */
+void
+new_ident_list (param_list)
+ParameterList *param_list;
+{
+    param_list->first = param_list->last = NULL;
+}
+
+/* Add an item to the list of function parameter declarations but set only
+ * the parameter name field and the comments.
+ */
+void
+add_ident_list (to, from, ident)
+ParameterList *to, *from;
+Identifier *ident;
+{
+    Parameter *p;
+    Declarator *declarator;
+
+    p = (Parameter *)safe_malloc(sizeof(Parameter));
+    declarator = new_declarator(ident->name, strduplicate(ident->name));
+    new_parameter(p, (DeclSpec *)NULL, declarator, ident->comment_before,
+						    ident->comment_after);
+
+    to->first = from->first;
+    if (to->first == NULL) {
+	to->first = p;
+    } else {
+	from->last->next = p;
+    }
+    to->last = p;
+    p->next = NULL;
+}
+
+/* Search the list of parameters for a matching parameter name.
+ * Return a pointer to the matching parameter or NULL if not found.
+ */
+static Parameter *
+search_parameter_list (params, name)
+ParameterList *params;
+char *name;
+{
+    Parameter *p;
+
+    for (p = params->first; p != NULL; p = p->next) {
+	if (p->declarator->name && strcmp(p->declarator->name, name) == 0)
+	    return p;
+    }
+    return (Parameter *)NULL;
+}
+
+/* This routine is called to generate function prototypes from traditional
+ * style function definitions.  For each parameter name in the declarator
+ * list, find the matching parameter name in the parameter list and set
+ * that parameter's declaration specifier.
+ * This is also where we promote formal parameters.  Parameters of type
+ * "char", "unsigned char", "short", or "unsigned short" get promoted to
+ * "int".  Parameters of type "float" are promoted to "double".
+ */
+void
+set_param_types (params, decl_spec, declarators, comment, eolcomment)
+ParameterList *params;
+DeclSpec *decl_spec;
+DeclaratorList *declarators;
+char *comment;
+char *eolcomment;
+{
+    Declarator *d;
+    Parameter *p;
+
+    if (comment && eolcomment)
+    {
+	yyerror("parameter declaration has multiple comments");
+	return;
+    }
+
+    if (!comment)	comment = eolcomment;
+    
+    for (d = declarators->first; d != NULL; d = d->next) {
+	/* Search the parameter list for a matching name. */
+	if ((p = search_parameter_list(params, d->name)) == NULL) {
+	    output_error();
+	    fprintf(stderr, "declared argument \"%s\" is missing\n", d->name);
+	} else {
+	    char *decl_spec_text = decl_spec->text;
+	    if (promote_param && strcmp(d->text, d->name) == 0) {
+		if (decl_spec->flags & (DS_CHAR | DS_SHORT))
+		    decl_spec_text = "int";
+		else if (decl_spec->flags & DS_FLOAT)
+		    decl_spec_text = "double";
+	    }
+	    safe_free(p->decl_spec.text);   /* there shouldn't be one, but...*/
+	    p->decl_spec.text = strduplicate(decl_spec_text);
+	    if (p->decl_spec.flags != decl_spec->flags)
+	    {
+		if (p->decl_spec.flags & DS_JUNK)
+		    p->decl_spec.flags = decl_spec->flags;
+		else
+		    parameter_error(p);
+	    }
+	    if (p->decl_spec.enum_list != decl_spec->enum_list)
+	    {
+		if (p->decl_spec.enum_list == NULL)
+		    p->decl_spec.enum_list = decl_spec->enum_list;
+		else
+		    parameter_error(p);
+	    }
+
+	    free_declarator(p->declarator);
+	    p->declarator = d;
+
+	    if (comment)
+	    {
+		if (p->declarator->comment)
+		    parameter_error(p);
+		else
+		    p->declarator->comment = strduplicate(comment);
+	    }
+	}
+    }
+
+    free_decl_spec(decl_spec);
+    safe_free(comment);
+}
+
+/* Output a declaration specifier for an external declaration.
+ */
+void
+output_decl_spec (decl_spec)
+DeclSpec *decl_spec;
+{
+    output->text(decl_spec->text);
+}
+
+static void
+output_parameters _((Declarator *d, boolean format));
+
+/* does a function have any parameters?
+ * This accounts for both fn() and fn(void)
+ */
+boolean has_parameters(d)
+const Declarator *d;
+{
+    Parameter *first = d->head->params.first;
+
+    return (first != NULL &&
+	   (first->declarator->text != NULL ||
+	    strcmp(first->decl_spec.text, "void")));
+}
+
+/* output a declarator name, stripping leading underscores if necessary */
+void output_decl_text(text, keep_underscores)
+char *text;
+boolean keep_underscores;
+{
+    if (!keep_underscores)
+    {
+	/* skip leading stuff before the actual name */
+	while (*text && *text != '_' && !isalnum(*text))
+	    output->character(*text++);
+	while (text[0] == '_' && text[1])	text++;
+    }
+    output->text(text);
+}
+
+/* Output a function declarator.
+ */
+static void
+output_func_declarator (declarator, format)
+Declarator *declarator;
+boolean format;
+{
+    char *s, *t, *decl_text;
+
+    /* Output declarator text before function declarator place holder. */
+    if ((s = strstr(declarator->text, "%s")) == NULL)
+	return;
+    *s = '\0';
+    output->text(declarator->text);
+
+    /* Substitute place holder with function declarator. */
+    if (!is_function_declarator(declarator->func_stack)) {
+
+	decl_text = declarator->func_stack->text;
+	if (declarator->name == NULL || declarator->name[0] == '\0') {
+	    output->text(decl_text);
+	} else {
+
+	    /* Output the declarator text before the declarator name. */
+	    if ((t = strstr(decl_text, declarator->name)) == NULL)
+		return;
+	    *t = '\0';
+	    output->text(decl_text);
+	    *t = declarator->name[0];
+
+	    if (format && strcmp(declarator_prefix, " ") != 0)
+		output_format_string(declarator_prefix);
+
+	    /* Output the declarator name. */
+	    output_decl_text(declarator->name, format);
+
+	    /* Output the remaining declarator text. */
+	    output->text(t + strlen(declarator->name));
+
+	    /* Output the declarator suffix. */
+	    if (format) output_format_string(declarator_suffix);
+	}
+    } else {
+	output_func_declarator(declarator->func_stack,format);
+    }
+    *s = '%';
+    s += 2;
+
+    /* Output declarator text up to but before parameters place holder. */
+    if ((t = strstr(s, "()")) == NULL)
+	return;
+    *t = '\0';
+    output->text(s);
+
+    /* Substitute place holder with function parameters. */
+    output->character(*t++ = '(');
+    output_parameters(declarator, format);
+    output->text(t);
+}
+
+/* Output a declarator.
+ */
+void
+output_declarator (d, format)
+Declarator *d;
+boolean format;
+{
+    if (d->func_stack) {
+	output_func_declarator(d, format);
+    } else {
+	output_decl_text(d->text, format);
+    }
+}
+
+/* Output a function parameter.
+ */
+void
+output_parameter (p)
+Parameter *p;
+{
+    if (p->decl_spec.text)
+	output->text(p->decl_spec.text);
+    else
+    /* Check for parameter names with no declaration specifiers.  This
+     * happens when a parameter name appears in the identifier list of a
+     * function definition but does not appear in the parameter declaration
+     * part.  The default type in this cause is "int".
+     */
+    if (p->declarator->text && strcmp(p->declarator->text, "...") != 0)
+	output->text("int ");
+
+    /* not all parameters must have declarators: might be a prototype */
+    if (p->declarator->text) {
+	if (p->decl_spec.text)
+	    output->character(' ');
+	/* don't format parameters; keep it all on one line */
+	output_declarator(p->declarator, FALSE);
+    }
+}
+
+/* Output the list of function parameters.
+ */
+static void
+output_parameters (d, format)
+Declarator *d;
+boolean format;
+{
+    if (has_parameters(d)) {
+        Parameter *p = d->params.first;
+	if (format) output_format_string(first_param_prefix);
+	output_parameter(p);
+	p = p->next;
+	while (p != NULL) {
+	    output->character(',');
+	    if (format) output_format_string(middle_param_prefix);
+	    output_parameter(p);
+	    p = p->next;
+	}
+	if (format) output_format_string(last_param_suffix);
+    }
+    else
+	output->text("void");
+}
+
+/* remember variable and function declarations. */
+int
+remember_declarations (comment, decl_spec, decl_list, eolcomment)
+char *comment;			/* comment before */
+DeclSpec *decl_spec;		/* declaration specifier */
+DeclaratorList *decl_list;	/* list of declared variables */
+char *eolcomment;		/* eol comment after */
+{
+    Declarator *d, *next;
+    int ret = 1;
+    
+    /* attach EOL comment to last one in list */
+    if (eolcomment)
+    {
+	Declarator *attach;
+
+	/* if it's a function, attach it to the last parameter */
+	if (is_function_declarator(decl_list->last) &&
+	    decl_list->last->head->params.last)
+	    attach = decl_list->last->head->params.last->declarator;
+	else
+	    attach = decl_list->last;
+	    
+	if (attach->comment)
+	{
+	    declarator_error(attach);
+	    free(eolcomment);
+	    ret = 0;
+	}
+	else
+	    attach->comment = eolcomment;
+    }
+    
+    /* special case of a single declarator handled efficiently */
+    if (decl_list->first && decl_list->first->next == NULL)
+    {
+	d = decl_list->first;
+	/* free the declarator comment if it isn't going to get used */
+	if (comment)
+	    safe_free(d->comment);
+	else
+	    comment = d->comment;
+
+	/* and nuke it from the declarator so free_declarator won't free it
+	 * (since safe_free will do that) if new_manual_page decides to throw
+	 * it away.
+	 */
+	d->comment = NULL;
+
+	new_manual_page(comment, decl_spec, d);
+    }
+    else
+    {
+	for (d = decl_list->first; d != NULL; d = next)
+	{
+	    DeclSpec spec_copy;
+	    char *comment_copy;
+
+	    next = d->next;
+#ifdef DEBUG
+	    fprintf(stderr,
+		"remember_declarations: text=%s name=%s\ncomment: %s\n",
+	    	d->text,d->name, comment ? comment : "NULL");
+#endif
+	    spec_copy = *decl_spec;
+	    spec_copy.text = strduplicate(decl_spec->text);
+	    comment_copy = d->comment ? d->comment :
+				    (comment ? strduplicate(comment) : NULL);
+	    d->comment = NULL;
+	    new_manual_page(comment_copy, &spec_copy,d);
+	}
+
+	/* free 'em up */
+	free_decl_spec(decl_spec);
+	safe_free(comment);
+    }
+
+    return ret;
+}
+
+void parameter_error(param)
+Parameter *param;
+{
+    yyerror("parameter '%s' has multiple comments", param->declarator->name);
+}
+
+void declarator_error(decl)
+Declarator *decl;
+{
+    yyerror("declarator '%s' has multiple comments", decl->name);
+}
+
+/* is a declarator for a function? (as opposed to a variable) */
+boolean is_function_declarator(decl)
+const Declarator *decl;
+{
+    return decl->type == DECL_FUNCTION || decl->type == DECL_FUNCDEF;
+}
+
+/* is a comment a start of a numbered list item */
+boolean is_numbered(text)
+const char *text;
+{
+  char *next = NULL;
+
+  if (*text == '(') {
+    ++text;
+    errno = 0;
+    strtol(text, &next, 0);
+    if (errno) 
+      return FALSE;
+    if (*next == ')') 
+      return TRUE;
+  }
+  else {
+    errno = 0;
+    strtol(text, &next, 0);
+    if (errno) 
+      return FALSE;
+    if (*next == '.' || *next == ')') 
+      return TRUE;
+  }
+  return FALSE ;
+}
+
diff --git a/semantic.h b/semantic.h
new file mode 100644
index 0000000..6518dd4
--- /dev/null
+++ b/semantic.h
@@ -0,0 +1,121 @@
+/* $Id: semantic.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * Declarations for semantic action routines
+ */
+#include "config.h"
+
+extern boolean is_typedef_name _((
+	char *name
+	));
+void
+new_decl_spec _((
+DeclSpec *decl_spec,
+char *text,
+int flags));
+
+extern void join_decl_specs _((
+	DeclSpec *result,
+	DeclSpec *a,
+	DeclSpec *b
+	));
+extern void free_decl_spec _((
+	DeclSpec *decl_spec
+	));
+void
+new_parameter _((
+Parameter *param,		/* pointer to structure to be initialized */
+DeclSpec *decl_spec,		/* declaration specifier structure */
+Declarator *declarator,		/* declarator structure */
+char *comment_before,		/* comment before the param */
+char *comment_after));		/* comment after the param */
+
+extern void free_parameter _((
+	Parameter *param
+	));
+
+/* add a comment to the last parameter in the list */
+int
+comment_last_parameter _((ParameterList *list, char *comment));
+
+extern void new_param_list _((
+	ParameterList *param_list,
+	Parameter *param
+	));
+
+extern void add_param_list _((
+	ParameterList *to,
+	ParameterList *from,
+	Parameter *param
+	));
+extern void free_param_list _((
+	ParameterList *param_list
+	));
+extern void new_ident_list _((
+	ParameterList *param_list
+	));
+extern void add_ident_list _((
+	ParameterList *to,
+	ParameterList *from,
+	Identifier *ident
+	));
+extern Declarator * new_declarator _((
+	char *text,
+	char *name
+	));
+extern void free_declarator _((
+	Declarator *d
+	));
+extern void new_decl_list _((
+	DeclaratorList *decl_list,
+	Declarator *declarator
+	));
+extern void add_decl_list _((
+	DeclaratorList *to,
+	DeclaratorList *from,
+	Declarator *declarator
+	));
+extern void free_decl_list _((
+	DeclaratorList *decl_list
+	));
+extern void set_param_types _((
+	ParameterList *params,
+	DeclSpec *decl_spec,
+	DeclaratorList *declarators,
+	char *comment,
+	char *eolcomment
+	));
+
+/* Output a function parameter.*/
+void output_parameter _((Parameter *p));
+
+int
+remember_declarations _((
+char *comment,			/* comment associated */
+DeclSpec *decl_spec,		/* declaration specifier */
+DeclaratorList *decl_list,	/* list of declared variables */
+char *eolcomment));		/* eol comment after */
+
+void
+dyn_decl_spec _((
+DeclSpec *decl_spec,
+char *text,
+unsigned int flags));
+
+void
+new_enum_decl_spec _((
+DeclSpec *decl_spec,
+char *text,
+int flags,
+EnumeratorList *enum_list));
+
+void
+output_decl_spec _((DeclSpec *decl_spec));
+
+void
+output_declarator _((Declarator *d, boolean format));
+
+void parameter_error _((Parameter *param));
+void declarator_error _((Declarator *decl));
+
+boolean has_parameters _((const Declarator *d));
+boolean is_function_declarator _((const Declarator *d));
diff --git a/strappend.c b/strappend.c
new file mode 100644
index 0000000..c8cc997
--- /dev/null
+++ b/strappend.c
@@ -0,0 +1,64 @@
+/* $Id: strappend.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ */
+#include "c2man.h"
+#include "strappend.h"
+
+#ifdef I_STDARG
+#include <stdarg.h>
+#endif
+#ifdef I_VARARGS
+#include <varargs.h>
+#endif
+
+extern void outmem();
+
+/*
+ * append a list of strings to another, storing them in a malloc'ed region.
+ * The first string may be NULL, in which case the rest are simply concatenated.
+ */
+#ifdef I_STDARG
+char *strappend(char *first, ...)
+#else
+char *strappend(va_alist)
+    va_dcl
+#endif
+{
+    size_t totallen;
+    va_list argp;
+    char *s, *retstring;
+#ifndef I_STDARG
+    char *first;
+#endif    
+    /* add up the total length */
+#ifdef I_STDARG
+    va_start(argp,first);
+#else
+    va_start(argp);
+    first = va_arg(argp, char *);
+#endif
+    totallen = first ? strlen(first) : 0;
+    while ((s = va_arg(argp,char *)) != NULL)
+	totallen += strlen(s);
+    va_end(argp);
+    
+    /* malloc the memory */
+    totallen++;	/* add space for the nul terminator */
+    if ((retstring = first ? realloc(first,totallen) : malloc(totallen)) == 0)
+	outmem();
+
+    if (first == NULL)	*retstring = '\0';
+
+#ifdef I_STDARG
+    va_start(argp,first);
+#else
+    va_start(argp);
+    first = va_arg(argp, char *);	/* skip the first arg */
+#endif
+
+    while ((s = va_arg(argp,char *)) != NULL)
+	strcat(retstring,s);
+
+    va_end(argp);
+
+    return retstring;
+}
diff --git a/strappend.h b/strappend.h
new file mode 100644
index 0000000..585df68
--- /dev/null
+++ b/strappend.h
@@ -0,0 +1,6 @@
+/* $Id: strappend.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * concatenate a list of strings, storing them in a malloc'ed region
+ */
+#include "config.h"
+
+char *strappend _V((char *first, ...));
diff --git a/strconcat.c b/strconcat.c
new file mode 100644
index 0000000..c9caff6
--- /dev/null
+++ b/strconcat.c
@@ -0,0 +1,74 @@
+/* $Id: strconcat.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * concatenate a list of strings, storing them in a malloc'ed region
+ */
+#include "c2man.h"
+#include "strconcat.h"
+
+#ifdef I_STDARG
+#include <stdarg.h>
+#endif
+#ifdef I_VARARGS
+#include <varargs.h>
+#endif
+
+extern void outmem();
+
+#ifdef I_STDARG
+char *strconcat(const char *first, ...)
+#else
+char *strconcat(va_alist)
+    va_dcl
+#endif
+{
+    size_t totallen;
+    va_list argp;
+    char *s, *retstring;
+#ifndef I_STDARG
+    char *first;
+#endif    
+    /* add up the total length */
+#ifdef I_STDARG
+    va_start(argp,first);
+#else
+    va_start(argp);
+    first = va_arg(argp, char *);
+#endif
+#ifdef DEBUG
+    fprintf(stderr,"strconcat: \"%s\"",first);
+#endif
+    totallen = strlen(first);
+    while ((s = va_arg(argp,char *)) != NULL)
+    {
+	totallen += strlen(s);
+#ifdef DEBUG
+	fprintf(stderr,",\"%s\"",s);
+#endif
+    }
+#ifdef DEBUG
+    fprintf(stderr,"\nstrlen = %ld\n",(long)totallen);
+#endif
+    va_end(argp);
+    
+    /* malloc the memory */
+    if ((retstring = malloc(totallen + 1)) == 0)
+	outmem();
+	
+#ifdef I_STDARG
+    va_start(argp,first);
+#else
+    va_start(argp);
+    first = va_arg(argp, char *);
+#endif
+    /* copy the stuff in */
+    strcpy(retstring,first);
+
+    while ((s = va_arg(argp,char *)) != NULL)
+	strcat(retstring,s);
+
+    va_end(argp);
+
+#ifdef DEBUG
+    fprintf(stderr,"strconcat returns \"%s\"\n",retstring);
+#endif
+    return retstring;
+}
diff --git a/strconcat.h b/strconcat.h
new file mode 100644
index 0000000..021d451
--- /dev/null
+++ b/strconcat.h
@@ -0,0 +1,6 @@
+/* $Id: strconcat.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * concatenate a list of strings, storing them in a malloc'ed region
+ */
+#include "config.h"
+
+char *strconcat _V((const char *first, ...));
diff --git a/string.c b/string.c
new file mode 100644
index 0000000..5af082b
--- /dev/null
+++ b/string.c
@@ -0,0 +1,82 @@
+/* $Id: string.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * Some string handling routines
+ */
+#include "c2man.h"
+#include <ctype.h>
+
+/* Copy the string into an allocated memory block.
+ * Return a pointer to the copy.
+ */
+char *
+strduplicate (s)
+const char *s;	/* The string to copy. May be NULL */
+{
+    char *dest;
+
+    if (!s)	return NULL;
+    
+    if ((dest = malloc((unsigned)(strlen(s)+1))) == NULL)
+	outmem();
+
+    strcpy(dest, s);
+    return dest;
+}
+
+#ifndef HAS_STRSTR
+
+/* Return a pointer to the first occurence of the substring 
+ * within the string, or NULL if not found.
+ */
+char *
+strstr (src, key)
+const char *src, *key;
+{
+    char *s;
+    int keylen;
+
+    keylen = strlen(key);
+    s = strchr(src, *key);
+    while (s != NULL) {
+	if (strncmp(s, key, keylen) == 0)
+	    return s;
+	s = strchr(s+1, *key);
+    }
+    return NULL;
+}
+
+#endif
+
+/* compare two strings case insensitively, for up to n chars */
+int strncmpi(s1, s2, n)
+const char *s1, *s2;
+size_t n;
+{
+    while(n--)
+    {
+	char c1 = *s1, c2 = *s2;
+
+	if (c1 == '\0' && c2 == '\0')	break;
+
+	if (isalpha(c1) && isupper(c1))	c1 = tolower(c1);
+	if (isalpha(c2) && isupper(c2))	c2 = tolower(c2);
+
+	if (c1 < c2)	return -1;
+	if (c1 > c2)	return 1;
+	s1++; s2++;
+    }
+    return 0;
+}
+
+/* convert string to upper case */
+char *strtoupper(in)
+char *in;
+{
+    char *s;
+
+    for (s = in; *s; s++)
+    {
+	if (islower(*s))	*s = toupper(*s);
+    }
+    return in;
+}
diff --git a/symbol.c b/symbol.c
new file mode 100644
index 0000000..85be039
--- /dev/null
+++ b/symbol.c
@@ -0,0 +1,119 @@
+/* $Id: symbol.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * Symbol table maintenance. Implements an abstract data type called
+ * the symbol table.
+ */
+#include "c2man.h"
+#include "symbol.h"
+
+/* Create a symbol table.
+ * Return a pointer to the symbol table or NULL if an error occurs.
+ */
+SymbolTable *
+create_symbol_table ()
+{
+    SymbolTable *symtab;
+    int i;
+
+    symtab = (SymbolTable *)safe_malloc(sizeof(SymbolTable));
+
+    for (i = 0; i < SYM_MAX_HASH; ++i)
+	symtab->bucket[i] = NULL;
+
+    return symtab;
+}
+
+
+/* Free the memory allocated to the symbol table.
+ */
+void
+destroy_symbol_table (symtab)
+SymbolTable *symtab;
+{
+    int i;
+    Symbol *sym, *next;
+
+    for (i = 0; i < SYM_MAX_HASH; ++i) {
+	sym = symtab->bucket[i];
+	while (sym != NULL) {
+	    next = sym->next;
+	    free(sym->name);
+	    free(sym);
+	    sym = next;
+	}
+    }
+    free(symtab);
+}
+
+
+/* This is a simple hash function mapping a symbol name to a hash bucket. */
+
+static unsigned int
+hash (name)
+char *name;
+{
+    char *s;
+    unsigned int h;
+
+    h = 0;
+    s = name;
+    while (*s != '\0')
+	h = (h << 1) ^ *s++;
+    return h % SYM_MAX_HASH;
+}
+
+
+/* Search the list of symbols <list> for the symbol <name>.
+ * Return a pointer to the symbol or NULL if not found.
+ */
+static Symbol *
+search_symbol_list (list, name)
+Symbol *list;
+char *name;
+{
+    Symbol *sym;
+
+    for (sym = list; sym != NULL; sym = sym->next) {
+	if (strcmp(sym->name, name) == 0)
+	    return sym;
+    }
+    return NULL;
+}
+
+
+/* Look for symbol <name> in symbol table <symtab>.
+ * Return a pointer to the symbol or NULL if not found.
+ */
+Symbol *
+find_symbol (symtab, name)
+SymbolTable *symtab;
+char *name;
+{
+    return search_symbol_list(symtab->bucket[hash(name)], name);
+}
+
+
+/* If the symbol <name> does not already exist in symbol table <symtab>,
+ * then add the symbol to the symbol table.
+ * Return a pointer to the symbol or NULL on an error.
+ */
+Symbol *
+new_symbol (symtab, name, flags)
+SymbolTable *symtab;	/* symbol table */
+char *name;		/* symbol name */
+int flags;		/* symbol attributes */
+{
+    Symbol *sym;
+    int i;
+
+    if ((sym = find_symbol(symtab, name)) == NULL) {
+	sym = (Symbol *)safe_malloc(sizeof(Symbol));
+	sym->name = strduplicate(name);
+	sym->flags = flags;
+	sym->valtype = SYMVAL_NONE;
+	i = hash(name);
+	sym->next = symtab->bucket[i];
+	symtab->bucket[i] = sym;
+    }
+    return sym;
+}
diff --git a/symbol.h b/symbol.h
new file mode 100644
index 0000000..2ce0f5f
--- /dev/null
+++ b/symbol.h
@@ -0,0 +1,41 @@
+/* $Id: symbol.h,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ *
+ * Definitions for a symbol table
+ */
+#include "config.h"
+
+#ifndef _SYMBOL_H
+#define _SYMBOL_H
+
+typedef struct _symbol {
+    struct _symbol *next;	/* next symbol in list */
+    char *name;			/* name of symbol */
+    unsigned short flags;	/* symbol attributes */
+
+	enum { SYMVAL_NONE, SYMVAL_ENUM } valtype;
+	
+	union {
+	    struct _enumerator_list *enum_list;
+	} value;
+} Symbol;
+
+/* The hash table length should be a prime number. */
+#define SYM_MAX_HASH 251
+
+typedef struct _symbol_table {
+	Symbol *bucket[SYM_MAX_HASH];	/* hash buckets */
+} SymbolTable;
+
+/* Create symbol table */
+extern SymbolTable *create_symbol_table();
+
+/* destroy symbol table */
+extern void destroy_symbol_table _((SymbolTable *symtab));
+
+/* Lookup symbol name */
+extern Symbol *find_symbol _((SymbolTable *symtab, char *name));
+
+/* Define new symbol */
+extern Symbol *new_symbol _((SymbolTable *symtab, char *name, int flags));
+
+#endif
diff --git a/texinfo.c b/texinfo.c
new file mode 100644
index 0000000..1b464b6
--- /dev/null
+++ b/texinfo.c
@@ -0,0 +1,465 @@
+/* $Id: texinfo.c,v 1.1 2004-05-03 05:17:48 behdad Exp $
+ * functions for texinfo style output.
+ */
+#include "c2man.h"
+#include "manpage.h"
+#include "output.h"
+#include <ctype.h>
+
+static char *heading_not_in_contents[] =
+	 {"@chapheading ", "@heading ", "@subheading ", "@subsubheading "};
+static char *heading_in_contents[] =
+	 {"@chapter ", "@section ", "@subsection ", "@subsubsection "};
+
+#define n_levels  (sizeof(heading_not_in_contents) / sizeof(char *))
+
+#define level(n) ((n) >= n_levels ? n_levels - 1 : (n))
+
+/* section level for man page entry */
+static int top_level = 1;
+
+/* always output node for manpage, even if embedded */
+static int embed_node_info = 0;
+
+/* use title as name of section, rather than "NAME" */
+static int title_name = 0;
+
+/* the section title, filled in by texinfo_header */
+static const char *title = "INTERNAL ERROR, BOGUS TITLE DUDE!";
+
+/* do section titles get capitalized? */
+static int capitalize_sections = 0;
+
+void texinfo_char(c)
+const int c;
+{
+    int i;
+
+    switch(c)
+    {
+    case '\t':
+	for (i = 0; i < NUM_TAB_SPACES; i++)
+	    putchar(' ');
+	break;
+    default:
+    	putchar(c);
+	break;
+    }
+}
+
+void texinfo_text(text)
+const char *text;
+{
+    while (*text)
+	texinfo_char(*text++);
+}
+
+void put_section(text)
+const char *text;
+{
+
+   if (capitalize_sections)
+   {
+     int first_letter = 1;
+
+     for ( ; *text ; text++)
+     {
+       texinfo_char(first_letter ? toupper(*text) : tolower(*text));
+       first_letter = isspace(*text);
+     }
+   }
+   else
+     texinfo_text(text);
+}
+
+void texinfo_comment() { put_string("@c "); }
+
+void texinfo_header(firstpage, input_files, grouped, name, terse, section)
+ManualPage *firstpage;
+int input_files;
+boolean grouped;
+const char *name;
+const char *terse;
+const char *section;
+{
+    if (! make_embeddable)
+    {
+	put_string("\\input texinfo @c -*-texinfo-*-\n");
+	output_warning();
+	put_string("@c %**start of header\n");
+	put_string("@setfilename ");
+	texinfo_text(name);
+	put_string(".info\n@settitle ");
+	texinfo_text(name);
+	putchar('\n');
+	put_string("@c %**end of header\n");
+
+	put_string("@node Top, ");
+	texinfo_text(name);
+	put_string(", (dir), (dir)\n");
+    }
+
+    if (! make_embeddable || embed_node_info)
+    {
+      put_string("@node ");
+      texinfo_text(name);
+      put_string(", (dir), Top, (dir)\n");
+    }
+
+    title = name;
+}
+
+void texinfo_dash()	{ put_string("---"); }
+
+void texinfo_section(name)
+const char *name;
+{
+    put_string(heading_not_in_contents[level(top_level)]);
+    put_section(name);
+    putchar('\n');
+    put_string("@noindent\n");
+}
+
+void texinfo_section_in_contents(name)
+const char *name;
+{
+    put_string(heading_in_contents[level(top_level)]);
+    put_section(name);
+    putchar('\n');
+    put_string("@noindent\n");
+}
+
+void texinfo_sub_section(name)
+const char *name;
+{
+    put_string(heading_not_in_contents[level(top_level+1)]);
+    put_section(name);
+    putchar('\n');
+    put_string("@noindent\n");
+}
+
+void texinfo_break_line() { /* put_string("@*\n"); */ }
+void texinfo_blank_line() { put_string("@sp 1\n"); }
+
+void texinfo_code_start() { put_string("@example\n"); }
+void texinfo_code_end()	{ put_string("@end example\n"); }
+
+void texinfo_code(text)
+const char *text;
+{
+    put_string("@code{");
+    texinfo_text(text);
+    put_string("}");
+}
+
+void texinfo_tag_list_start()	{ put_string("@quotation\n@table @code\n"); }
+void texinfo_tag_entry_start()	{ put_string("@item "); }
+void texinfo_tag_entry_end()	{ putchar('\n'); }
+
+void texinfo_tag_entry_end_extra(text)
+const char *text;
+{
+    putchar('(');
+    texinfo_text(text);
+    putchar(')');
+    texinfo_tag_entry_end();
+}
+void texinfo_tag_list_end()	{ put_string("@end table\n@end quotation\n"); }
+	
+void texinfo_table_start(longestag)
+const char *longestag;
+{ put_string("@quotation\n@table @code\n"); }
+
+void texinfo_table_entry(name, description)
+const char *name;
+const char *description;
+{
+    put_string("@item ");
+    texinfo_text(name);
+    putchar('\n');
+    if (description)
+	output_comment(description);
+    else
+	putchar('\n');
+}
+
+void texinfo_table_end()	{ put_string("@end table\n@end quotation\n"); }
+
+void texinfo_list_start()	{ }
+void texinfo_list_entry(text)
+const char *text;
+{
+    texinfo_code(text);
+}
+void texinfo_list_separator() { put_string(",\n"); }
+void texinfo_list_end()	{ putchar('\n'); }
+
+void texinfo_include(filename)
+const char *filename;
+{
+	put_string("@include ");
+	texinfo_text(filename);
+	put_string("\n");
+}
+
+void texinfo_file_end() { put_string("@bye\n"); }
+
+static first_name = 1;
+void texinfo_name(name)
+const char *name;
+{
+    if (name)
+    {
+	if (!first_name || !title_name || strcmp(title,name))
+	   texinfo_text(name);
+	first_name = 0;
+    }
+    else
+    {
+	first_name = 1;
+	if (title_name)
+	{
+	    /* don't muck around with capitalization of title */
+	    int capitalize_sections_save = capitalize_sections;
+	    capitalize_sections = 0;
+
+	    texinfo_section_in_contents(title);
+	    capitalize_sections = capitalize_sections_save;
+	}
+	else
+	    texinfo_section("NAME");
+    }
+}
+
+void texinfo_terse_sep()
+{
+    if (!title_name || group_together)
+    {
+	texinfo_char(' ');
+	texinfo_dash();
+	texinfo_char(' ');
+    }
+}
+
+void texinfo_reference(text)
+const char *text;
+{
+    texinfo_text(text);
+    texinfo_char('(');
+    texinfo_text(manual_section);
+    texinfo_char(')');
+}
+
+/* ideally, this should be made aware of embedded texinfo commands */
+void texinfo_description(text)
+const char *text;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    boolean new_line = TRUE;
+    
+    /* correct punctuation a bit as it goes out */
+    for (;*text;text++)
+    {
+	int c = *text;
+
+	if (new_line && (c == '-' || c == '*' || is_numbered(text)))
+	{
+	    output->break_line();
+	    state = CAPITALISE;
+	}
+	else if (c == '.')
+	    state = PERIOD;
+	else if (isspace(c) && state == PERIOD)
+	    state = CAPITALISE;
+	else if (isalnum(c))
+	{   
+	    if (islower(c) && state == CAPITALISE)	c = toupper(c);
+	    state = TEXT;
+	}
+           
+	output->character(c);
+	new_line = c == '\n';
+    }
+
+    /* do a full stop if there wasn't one */
+    if (state == TEXT)	output->character('.');
+}
+
+/* ideally, this should be made aware of embedded texinfo commands */
+void
+texinfo_returns(comment)
+const char *comment;
+{
+    enum { TEXT, PERIOD, CAPITALISE } state = CAPITALISE;
+    char lastchar = '\n';
+    boolean tag_list_started = FALSE;
+
+    /* for each line... */
+    while (*comment)
+    {
+	boolean tagged = FALSE;
+
+	{
+	    const char *c = comment;
+
+	    /* search along until the end of a word */
+	    while (*c && *c != ':' && !isspace(*c))
+		c++;
+
+	    /* skip all spaces or tabs after the first word */
+	    while (*c && *c != '\n')
+	    {
+		if (*c == '\t' || *c == ':')
+		{
+		    tagged = TRUE;
+		    break;
+		}
+		else if (!isspace(*c))
+		    break;
+
+		c++;
+	    }
+	}
+
+	/* is it tagged?; explicitly reject dot commands */
+	if (tagged)
+	{
+	    /* output lingering newline if necessary */
+	    if (lastchar != '\n')
+	    {
+		if (state == TEXT && !ispunct(lastchar))	output->character('.');
+		output->character(lastchar = '\n');
+	    }
+
+	    if (!tag_list_started)
+	    {
+		output->tag_list_start();
+		tag_list_started = TRUE;
+	    }
+
+	    /* output the taggy bit */
+	    output->tag_entry_start();
+	    while (*comment && *comment != ':' && !isspace(*comment))
+		output->character(*comment++);
+	    output->tag_entry_end();
+
+	    /* skip any extra tabs or spaces */
+	    while (*comment == ':' || (isspace(*comment) && *comment != '\n'))
+		comment++;
+
+	    state = CAPITALISE;
+	}
+
+	/* terminate the previous line if necessary */
+	if (lastchar != '\n')	output->character(lastchar = '\n');
+
+	/* correct punctuation a bit as the line goes out */
+	for (;*comment && *comment != '\n'; comment++)
+	{
+	    char c = *comment;
+
+	    if (c == '.')
+		state = PERIOD;
+	    else if (isspace(c) && state == PERIOD)
+		state = CAPITALISE;
+	    else if (isalnum(c))
+	    {   
+		if (islower(c) && state == CAPITALISE && fixup_comments)
+		    c = toupper(c);
+		state = TEXT;
+	    }
+
+	    output->character(lastchar = c);
+	}
+
+	/* if it ended in punctuation, just output the nl straight away. */
+	if (ispunct(lastchar))
+	{
+	    if (lastchar == '.')	state = CAPITALISE;
+	    output->character(lastchar = '\n');
+	}
+
+	if (*comment)	comment++;
+    }
+
+    /* output lingering newline if necessary */
+    if (lastchar != '\n')
+    {
+	if (state == TEXT && !ispunct(lastchar) && fixup_comments)
+	    output->character('.');
+	output->character('\n');
+    }
+
+    if (tag_list_started)
+	output->tag_list_end();
+}
+
+
+int texinfo_parse_option(option)
+const char *option;
+{
+    if	    (option[0] == 't')
+	title_name = 1;
+    else if (option[0] == 'n')
+	embed_node_info = 1;
+    else if (option[0] == 's')
+    {
+	top_level = atoi(&option[1]);
+	if (top_level < 0) return 1;
+    }
+    else if (option[0] == 'C')
+	capitalize_sections = 1;
+    else return 1;
+
+    return 0;
+}
+
+void texinfo_print_options()
+{
+    fputs("\ttexinfo options:\n", stderr);
+    fputs("\tt\tuse manpage title as NAME title\n", stderr);
+    fputs("\tn\toutput node info if embedded output\n", stderr);
+    fputs("\ts<n>\tset top heading level to <n>\n", stderr);
+    fputs("\tC\tcaptialize section titles\n", stderr);
+}
+
+
+struct Output texinfo_output =
+{
+    texinfo_comment,
+    texinfo_header,
+    texinfo_dash,
+    texinfo_section,
+    texinfo_sub_section,
+    texinfo_break_line,
+    texinfo_blank_line,
+    texinfo_code_start,
+    texinfo_code_end,
+    texinfo_code,
+    texinfo_tag_list_start,
+    texinfo_tag_list_end,
+    texinfo_tag_entry_start,
+    texinfo_tag_entry_start,	/* entry_start_extra */
+    texinfo_tag_entry_end,
+    texinfo_tag_entry_end_extra,
+    texinfo_table_start,
+    texinfo_table_entry,
+    texinfo_table_end,
+    dummy,		/* texinfo_indent */
+    texinfo_list_start,
+    texinfo_list_entry,
+    texinfo_list_separator,
+    texinfo_list_end,
+    texinfo_include,
+    texinfo_file_end,
+    texinfo_text,
+    texinfo_char,
+    texinfo_parse_option,
+    texinfo_print_options,
+    texinfo_name,
+    texinfo_terse_sep,
+    texinfo_reference,
+    texinfo_text,
+    texinfo_description,
+    texinfo_returns
+};
-- 
cgit v1.2.3