Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume42/c2man-2.0/part05

Internet Message Format | 1994-05-06 | 50KB

From: [e-mail] (Graham Stoney)
Newsgroups: comp.sources.misc
Subject: v42i059:  c2man-2.0 - automatic C documentation generator, Part05/09
Date: 25 Apr 1994 22:30:56 -0500
Organization: Canon Information Systems Research Australia
Sender: [e-mail]
Approved: [e-mail]
Message-ID: <2pi1tg$[e-mail]>
References: <csm-v42i055=[e-mail]>
Summary: a complete posting of the latest c2man: version 2.0 patchlevel 27
X-Md4-Signature: 723f2058a5c92d388d09119a195db630

Submitted-by: [e-mail] (Graham Stoney)
Posting-number: Volume 42, Issue 59
Archive-name: c2man-2.0/part05
Environment: UNIX, DOS, OS/2, lex, yacc

#! /bin/sh
#
# This is c2man version 2.0 at patchlevel 27.
# Make a new directory for the c2man sources, cd to it, and run kits 1 up
# to 9 through sh.  When all 9 kits have been run, read README.
#
echo " "
cat <<EOM
This is c2man 2.0 at patchlevel 27, kit 5 (of 9):
If this shell archive is complete, the line "End of kit 5 (of 9)"
will echo at the end.
EOM
export PATH || (echo "Please use sh to unpack this archive." ; kill $$)
mkdir eg pc 2>/dev/null
echo Extracting c2man.1
sed >c2man.1 <<'!STUFFY!FUNK!' -e 's/X//'
X.\" $Id: c2man.1,v 2.0.1.36 1994/01/13 05:20:40 greyham Exp $
X.de EX          \"Begin example
X.br
X.if \\$1 .ne \\$1
X.if !"\\$2"" \{
X.if n .sp 1
X.if t .sp .5
X\\$2
X\}
X.if n .sp 1
X.if t .sp .5
X.nf
X.in +.5i
X..
X.de EE        \"End example
X.fi
X.in -.5i
X.if n .sp 1
X.if t .sp .5
X..
X.de CS        \"Begin shell command
X.br
X.if n .sp 1
X.if t .sp .5
X.in +.5i
X%
X.ft B
X..
X.de CE        \"End shell command
X.br
X.ft R
X.in -.5i
X.if n .sp 1
X.if t .sp .5
X..
X.de CD        \"Shell command
X.CS
X\\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9
X.CE
X..
X.\"    The IF & IE macros cannot be combined due to flatten.sed
X.de IF        \"Begin Include a file
X.if n .sp 1
X.if t .sp .5
X.ne 10
X.nf
X.RS 0.25in
X..
X.de IE        \"End Include a file
X.RE
X.if n .sp 1
X.if t .sp .5
X.fi
X..
X.TH C2MAN 1 "January 12, 1994"
X.BY "CISRA"
X.SH NAME
Xc2man \- generate manual pages from C source code
X.SH SYNOPSIS
X.B c2man
X[
X.I option \fP...\fI
X] [
X.I file \fP...\fI
X]
X.SH DESCRIPTION
X.B c2man
Xreads C source code files in which comments have been strategically placed,
Xand outputs manual page(s) documenting each function defined or declared (via
Xa prototype), and optionally each variable with global scope.
XFunction definitions and declarations may be in the old style or ISO/ANSI style.
XIf no
X.I file
Xargument is given,
X.B c2man
Xtakes its input from the standard input.
X.PP
XIf a
X.B .h
Xfile is written as a formal interface description when preparing an
Xinterface spec,
X.B c2man
Xcan generate all the manual pages required for the spec at one fell swoop,
Xand then keep them up to date automatically as the interface changes.
X.PP
XSince
X.B c2man
Xwill accept either function definitions or prototypes, it can be used on
Xeither
X.B .c
Xor
X.B .h
Xfiles.
XIf the input is a
X.B header
Xfile, any files specified by
X.B \-i
Xoptions are
Xassumed to be prerequisites, and get parsed before the input file.
X(Any file whose extension begins with
X.RB `` h '',
Xmatched case-insensitively,
Xis considered a
X.B header
Xfile.)
X.PP
XThis is potentially a huge win for most programmers that just love documenting
Xtheir functions, and updating the documentation every time it changes.
XHere's an example, named example.h:
X.IF
X.so example.h
X.IE
X.PP
XWhen:
X.CD c2man example.h
Xis run,
Xthis produces a file named
X.B dowork.3
Xwhich can be processed by man(1) or used as:
X.CD "nroff -man dowork.3"
Xto produce:
X.IF
X.ne 34
X.so example.inc
X.IE
X.SS "Output Generation"
XBy default, a separate output file is generated for each global identifier
X(i.e. function or variable) documented by c2man.
X.PP
XMuch of
X.BR c2man 's
Xinformation is extracted from the comment placed immediately before the
Xdeclaration/definition of the identifier being documented; this comment
Xis taken to describe the identifier and
X.B must
Xbe present, or the identifier will be ignored entirely.
XIn the case of a variable declaration/definition, this comment may instead be
Xplaced after it starting on the same line.
X.PP
XGlobal variables are not documented, unless the
X.B \-v
Xoption is used.
X.PP
XIdentifiers declared
X.B static
Xare ignored by default unless the file is a
X.B header
Xfile (which is most useful with
X.B inline
Xfunctions) or the
X.B -s
Xoption is used.
X.PP
XDeclarations with the
X.B extern
Xkeyword are ignored unless they appear in a
X.B header
Xfile; note that this does not include function definitions.
X.SS "Sections Generated Automatically"
XEach manual page starts with a
X.B NAME
Xsection, listing the name(s) of the identifier(s) documented, along with a
Xterse description.
XBy default, this description is the first line or sentence of the
Xcomment describing the identifier.
XWith the
X.B \-g
Xoption, it is found after the first dash
X.RB ( \- )
Xin the first comment of the file, and the
X.B \-G
Xoption specifies it explicitly.
X.PP
XThe
X.B SYNOPSIS
Xsection
Xbegins with an
X.B #include
Xline
Xif the source file is a
X.BR header .
XAfter this is an external declaration for the
Xidentifier(s) being documented.
X.PP
XInformation in the
X.B PARAMETERS
Xsection is gleaned from the comments immediately before or after each
Xparameter declaration. A comment after a parameter can follow the comma that
Xseparates that parameter from the next, if the comment starts on the same line
Xand is the only remaining thing on that line. Leading underscores in a
Xparameter name are stripped when printed in the manual page.
X.PP
XIf the manual page is for a group of functions (ie:
X.B \-g
Xor
X.B \-G
Xoptions),
Xidentical parameters (in both name and type) common to more than one function
Xare described only once if only one has a comment (as in the ctype
Xexample below).
X.PP
XIf a parameter is an
X.B enumerated
X.BR type ,
Xall the possible values it can take are output, along with their descriptions.
XThese descriptions are gleaned from the comments surrounding the
X.B enum
Xidentifiers where the type was defined.
XComments describing
X.B enum
Xidentifiers are placed in a similar manner to those that describe function
Xparameters.
X.B enum
Xidentifiers that begin with an underscore are ignored, which is useful for
Xpadding or
X.I _NUMBER_OF_...
Xvalues which aren't normally used by someone calling
Xthe function.
XIf none of the identifiers in an enumerated type has a comment,
X.B c2man
Xwill bunch them together to save space.
X.PP
XThe
X.B DESCRIPTION
Xsection contains everything
Xafter the first line or sentence
Xof the comment describing the identifier,
Xup until the word
X.RB `` returns ''
Xat the start of a line, matched case-insensitively and optionally followed by
Xa colon
X.RB ( : ).
XIn the case of a variable of
X.B enumerated
X.BR type ,
Xit will also list all the values it can hold.
X.PP
XThe
X.B RETURNS
Xsection contains anything after that. Any of these lines that begin with a
Xsingle word followed by a colon or a tab generate tagged paragraphs so that
Xlists of possible return values and error codes look neat.
XIf the function is void, don't put anything like "Returns: nothing" in
Xthe comment, since it's a waste of space. If the identifier is a function
Xreturning an
X.B enumerated
X.BR type ,
Xits possible values will be listed here.
X.PP
XFinally, a
X.B "SEE ALSO"
Xsection is generated, referencing all the other manual pages generated, if any.
X.PP
XThe
X.BR RETURNS ,
X.B PARAMETERS
Xand
X.B "SEE ALSO"
Xsections are omitted entirely if they aren't needed.
X.SS "Processing of Comment Contents"
XBasic punctuation and capitalisation corrections are made in each section for
Xneatness, and the typesetting program used to process the output will generally
Xreformat line breaks according to the width of the output device. Blank lines
Xin a comment will be preserved, and lines starting with a character that is
Xneither alphanumeric nor a single nor double quote will cause a line break,
Xallowing simple bulleted lists.
X.PP
XTypesetter specific commands may be included for more complex processing.
X.SS "Comment Style and Placement"
XBoth
X.B C
Xand
X.B C++
Xstyle comments are recognized,
Xwith seperate consecutive single-line comments coalesced into a single block.
XWhen looking at comments,
X.B c2man
Xignores everything before the first alpha-numeric character. After that, it
Xignores leading white-space, leading asterisks and leading slashes
Xon all subsequent
Xlines, and ignores all trailing lines thus rendered blank. If that leaves
Xnothing, the comment is ignored entirely.
XThis makes it very flexible in supporting popular comment boxing.
X.PP
XComments can be placed with considerable flexibility so that most commenting
Xstyles are supported.
X.EX 13 "The following variations of the enum definition in the \fBdowork.h\fR\
X example are all equivalent:"
X/* commas after the comments. */
Xenum Place
X{
X    HOME       /* Home, Sweet Home */,
X    WORK       /* where I spend lots of time */,
X    MOVIES     /* Saturday nights mainly */,
X    CITY       /* New York, New York */,
X    COUNTRY    /* Bob's Country Bunker */
X};
X.EE
X.EX 16
X/* the comment needn't go on the same line,
X * if the comma goes after the comment.
X */
Xenum Place
X{
X    HOME
X        /* Home, Sweet Home */,
X    WORK
X        /* where I spend lots of time */,
X    MOVIES
X        /* Saturday nights mainly */,
X    CITY
X        /* New York, New York */,
X    COUNTRY
X        /* Bob's Country Bunker */
X};
X.EE
X.EX 14
X/* the comment can go before it too. */
Xenum Place
X{
X    /* Home, Sweet Home */
X    HOME,
X    /* where I spend lots of time */
X    WORK,
X    /* Saturday nights mainly */
X    MOVIES,
X    /* New York, New York */
X    CITY,
X    /* Bob's Country Bunker */
X    COUNTRY
X};
X.EE
XBut the following example is
X.B NOT
Xequivalent because the commas are between the identifier and the its
Xassociated comment, and the comment is on a different line.
XEach comment actually applies to the wrong identifier, so this will result in
Xvery misleading output.
X.EX 16 "Don't do this:"
Xenum Place
X{
X    HOME,
X        /* Home, Sweet Home */
X    WORK,
X        /* where I spend lots of time */
X    MOVIES,
X        /* Saturday nights mainly */
X    CITY,
X        /* New York, New York */
X    COUNTRY
X        /* Bob's Country Bunker */
X};
X.EE
X.PP
XSince enum identifiers sometimes fall into logical groups, a comment before
Xsuch an identifier will be taken to apply to the next few in the list,
Xprovided that the comments describing each individual identifier
Xare placed after them. Also, there must be a blank line separating the comment
Xdescribing the next logical group and the comment at the end of the previous
Xline, or the two will be coalesced and incorrectly treated as a single comment
Xfor the previous enumerator.
X.EX 17 "In other words, you can go:"
X/* include logical grouping comments. */
Xenum Place
X{
X    /* These take up most of the week */
X    HOME,      /* Home, Sweet Home */
X    WORK,      /* where I spend lots of time */
X
X    /* More for special occasions */
X    MOVIES,     /* Saturday nights mainly */
X    CITY,      /* New York, New York */
X
X    /* The real favourite */
X    COUNTRY    /* Bob's Country Bunker */
X};
X.EE
X.PP
XThat may all sound a bit complex, but the upshot is that
X.B c2man
Xwill usually know which identifier a comment is associated with, unless you do
Xsomething truly bizarre.
X.SS "Grouped Manual Pages"
XSimple, closely related objects can be grouped together onto a single page with the
X.B \-g
Xor
X.B \-G
Xoptions. By default, this results in a single output file with multiple links
Xso that it can be accessed by the name of the input file, or of any identifier
Xdocumented.
XFor example, if ctype.h contains:
X.IF
X.so ctype_ex.h
X.IE
X.PP
Xthen using:
X.CD c2man -g ctype.h
Xyields:
X.IF
X.so ctype_ex.inc
X.IE
X.SS "Extra Sections"
XAdditional sections not otherwise recognized by
X.B c2man
Xcan be included in the manual page by including them in the comment
Xdescribing the identifier.
XA section heading is preceded in the comment by an empty line (after
Xremoval of leading asterisks), and is the only word on it's line, or is followed
Xby a colon
X.RB ( : ).
XSection heading names are capitalized, and the names
X.BR DESCRIPTION ,
X.B RETURNS
Xand
X.B NAME
Xare recognized specially so you can name them explicitly if you like.
X.BR FUNCTION ,
X.B PROCEDURE
Xand
X.B ROUTINE
Xare also recognised, and treated identically to
X.BR NAME .
X.EX 9 "For example:"
X/*
X * Have a quick puff.
X *
X * Warning: Smoking causes lung cancer
X */
Xvoid go_for_a_smoke();
X.EE
XGenerates a manual page with a
X.B WARNING
Xsection.
X.EE
X.SH OPTIONS
X.TP
X.BI \-o dir
XWrite generated files into directory
X.B dir
Xrather than the current directory.
XIf
X.B dir
Xis specified as
X.BR \- ,
Xgenerated pages are written to the standard output, separated by form-feeds.
X.TP
X.B \-v
XAlso output declarations for variables defined in the file.
X.TP
X.B \-s
XOutput manual pages for all
X.B static
Xidentifiers.
X.TP
X.B \-g
XGroup all the info generated together into a single
Xpage (ala ctype(3)), reading the single-line terse description for the
X.B NAME
Xsection from the line of the first comment in the file.
XIf this first line contains a dash
X.RB ( \- )
Xsurrounded by whitespace, the terse description is taken starting after the
Xdash.
XIf multiple files are specified,
Xthe first such suitable comment encountered is used. A link to
Xthe output file is made for each identifier documented, according to the
X.B \-l
Xoption.
X.TP
X.BI \-G terse
XLike
X.BR \-g ,
Xbut using the specified terse description rather than reading it from the
Xfile.
X.TP
X.B \-l h|s|f|n|r
XSelect how the output for a grouped manual page is linked to files named after
Xall identifiers documented on the page.
XHard link
X.RB ( h )
Xis the default, as it uses the least space.
XSoft link
X.RB ( s ),
Xwhere supported, allows a
X.BR find (1)
Xcommand with
X.RB `` "\-type f" ''
Xto easily skip the duplicated pages.
XSeparate file
X.RB ( f )
Xcontaining a file include
Xdirective is the traditional
X.SM UNIX
Xmethod.
XNo link
X.RB ( n )
Xis useful for generating printed documentation without duplicated pages; only
Xa single file, named according to the
X.B \-n
Xoption, is generated.
XRemove
X.RB ( r )
Xis like No link, but also removes any previously generated links/files named
Xafter the identifiers documented. Useful for cleaning up after accidents with
Xthe other link options.
X.sp
XIn all cases, any existing links will be removed before being rewritten.
X.TP
X.B \-n
XName the documentation output file after the input file.
XWhen generating grouped manual pages, this will be the file to which others
Xare linked.
XFor non-grouped manual pages, if documentation for more than one
Xidentifier is generated, information about the last identifier will overwrite
Xinformation about all the previous ones.
X.PP
X.BI \-i file
X.PP
X\fB\-i\fI\{"file"\}
X.TP
X.BI \-i <file>
XInsert a
X.B #include
Xline referencing the specified file in the
X.B SYNOPSIS
Xsection, using the ``<file>'' form by default.
XAny number of
X.B \-i
Xoptions may be specified to build up a list of prerequisites.
XIf using the second form, you may need to quote the quotation marks, lest they
Xget removed by the shell.
X.TP
X.BI \-H header-path
XPrepend
X.B header-path
Xto the name of the
X.B header
Xfile when an
X.B #include
Xline is automatically generated in the
X.B SYNOPSIS
Xsection.
X.TP
X.BI \-L
XLazy option: Only list parameters in the
X.B PARAMETERS
Xsection if they are documented by a comment in the source. By default,
Xparameters with no comment are described as ``Not Documented.'', to encourage
Xthe programmer to comment them.
X.TP
X.B \-T n|l|t
XSet the output typesetting language.
X.B Nroff
X.RB ( n )
Xis the default,
X.B LaTeX
X.RB ( l )
X, or
X.B texinfo
X.RB ( t ).
X.TP
X.BI \-e
XPrepares the output so it can be embedded in texts of the output typesetting
Xlanguage.
X.TP
X.BI \-M name
XSet the name of the manual in which the page will go.
X.TP
X.BI \-S section
XSet the default manual section, used as the extension on the output files.
X.I section
Xdefaults to ``3'' for
X.BR nroff ,
X``texi'' for
X.B TeXinfo
Xand ``tex'' for
X.B LaTeX
Xoutput, as specified via the
X.B \-T
Xoption.
XThis setting can be overridden by the
X.BI \-O? .ext
Xoptions for finer control.
X.TP
X.BI \-Of|v|F|V[ subdir ][. ext ]
XProvides for finer control of the output files, allowing a different output
Xsubdirectory and extension to be specified for these different classes of
Xobjects:
Xfunctions
X.RB ( f ),
Xvariables
X.RB ( v ),
Xstatic functions
X.RB ( F )
Xand static variables
X.RB ( V ).
X.sp
XIf
X.I subdir
Xis specified, the selected class of output will be written in that
Xsubdirectory under the directory given by the
X.B \-o
Xoption if specified, otherwise under the current directory.
X.sp
XIf
X.I .ext
Xis specified, it will be used as the extension on the output files of the
Xselected class, instead of the default based on the
X.B \-S
Xoption (if specified), or the typesetting output format specified by the
X.B \-T
Xoption.
X.sp
XFor example, the following command will generate
X.BR nroff (1)
Xstyle output under the /usr/local/man hierarchy, documenting functions in
Xsection 3 (/usr/local/man/man3/*.3), global variables in section 3v
X(/usr/local/man/man3/*.3v), static functions in section 9
X(/usr/local/man/man9/*.9) and
Xstatic variables in section 9v (/usr/local/man/man9/*.9v):
X.CD c2man -o/usr/local/man -v -s -Ofman3.3 -Ovman3.3v -OFman9.9 -OVman9.9v input.c
XThe
X.B \-O
Xoptions will have no effect if
X.B \-o-
Xis used to write to standard output, and
X.BR \-Ov ,
X.B \-OF
Xand
X.B \-OV
Xwill have no effect unless their classes of output are enabled via the
Xappropriate
X.B \-v
Xand
X.B \-s
Xoptions.
X.TP
X.BI \-F template
XSet the format used to output the prototype for functions with more than 1
Xparameter
Xin each manual page;
Xfunctions with zero or 1 parameters are always output as one line.
XThe format is specified by a template in the form
X.EX
X" int f ( a, b )"
X.EE
Xbut you may replace each space in this string with any number of
Xwhitespace characters.
XFor example, the option
X.EX
X-F"int f(\\n\\ta,\\n\\tb\\n\\t)"
X.EE
X.EX 5 "will produce:"
Xint main(
X        int argc,
X        char *argv[]
X        )
X.EE
X.EX 5 "The default output format is:"
Xint main
X(
X        int argc,
X        char *argv[]
X);
X.EE
X.TP
X.BI \-P preprocessor
XRun a different C preprocessor than normal (use
X.B \-V
Xto determine the configured default).
XYou must include any options required to prevent it from stripping comments,
Xwhich is normally the default preprocessor behaviour.
XFor example, to use
X.BR gcc 's
Xcpp instead:
X.CD c2man -P \{"gcc -E -C"\}
X.TP
X.BI \-D name[=value]
XThis option is passed through to the preprocessor and is used to define
Xsymbols for use with conditionals such as
X.I #ifdef.
X.TP
X.BI \-U name
XThis option is passed through to the preprocessor and is used to remove
Xany definitions of this symbol.
X.TP
X.BI \-I directory
XThis option is passed through to the preprocessor and is used to specify
Xa directory to search for files that are referenced with
X.I #include.
X.TP
X.B \-V
XPrint version information and cpp parameters.
X.SH FILES
X.TP
X$(privlib)/eg/*.[ch]
XA few example input files, showing different commenting styles.
X.SH "SEE ALSO"
Xman(1),
Xapropos(1),
Xcatman(8),
Xcproto(1),
Xcc(1),
Xcpp(1)
X.SH DIAGNOSTICS
X.BR c2man 's
Xerror messages are not very helpful. Make sure your code compiles before
Xtrying
X.BR c2man .
XIf the code compiles OK but
X.B c2man
Xrejects it, it may be because a comment is in a position
X.B c2man
Xdoes not accept, or you are using a compiler extension not strictly conforming
Xto standard C.
X.B c2man
Xdefines the preprocessor symbol
X.B __C2MAN__
Xwith its major version number
Xto allow you to work around such problems by surrounding them with
X.BR "#ifndef __C2MAN__" .
X.PP
XAn error at the very end of a function may indicate that the comments at the
Xbeginning are badly placed.
X.SH HISTORY
X.B c2man
Xwas written by:
X.EX 4
XGraham Stoney
XCanon Information Systems Research Australia
[e-mail]
X(please send bug reports here)
X.EE
Xbut was heavily derived from
X.B cproto
Xwritten by:
X.EX 2
XChin Huang
[e-mail]
X.EE
X.SH BUGS
XThe
X.B \-F
Xoption only interprets the following
Xcharacter escape sequences:
X.EX 2
X\\n    newline
X\\t    tab
X.EE
X.PP
XA comment before a preprocessor directive will be considered to apply
Xto the identifier that immediately follows, if it has no
Xcomment of its own.
XThis is because the preprocessor directive gets removed by cpp before
Xc2man looks at it.
X.PP
XComments aren't legal in some of the more obscure places that they are in C.
X.PP
XHeavy use of
X.B #define
Xin a program may yield somewhat obscure manual pages.
!STUFFY!FUNK!
echo Extracting pc/COPYING
sed >pc/COPYING <<'!STUFFY!FUNK!' -e 's/X//'
X            GNU GENERAL PUBLIC LICENSE
X               Version 2, June 1991
X
X Copyright (C) 1989, 1991 Free Software Foundation, Inc.
X                          675 Mass Ave, Cambridge, MA 02139, USA
X Everyone is permitted to copy and distribute verbatim copies
X of this license document, but changing it is not allowed.
X
X                Preamble
X
X  The licenses for most software are designed to take away your
Xfreedom to share and change it.  By contrast, the GNU General Public
XLicense is intended to guarantee your freedom to share and change free
Xsoftware--to make sure the software is free for all its users.  This
XGeneral Public License applies to most of the Free Software
XFoundation's software and to any other program whose authors commit to
Xusing it.  (Some other Free Software Foundation software is covered by
Xthe GNU Library General Public License instead.)  You can apply it to
Xyour programs, too.
X
X  When we speak of free software, we are referring to freedom, not
Xprice.  Our General Public Licenses are designed to make sure that you
Xhave the freedom to distribute copies of free software (and charge for
Xthis service if you wish), that you receive source code or can get it
Xif you want it, that you can change the software or use pieces of it
Xin new free programs; and that you know you can do these things.
X
X  To protect your rights, we need to make restrictions that forbid
Xanyone to deny you these rights or to ask you to surrender the rights.
XThese restrictions translate to certain responsibilities for you if you
Xdistribute copies of the software, or if you modify it.
X
X  For example, if you distribute copies of such a program, whether
Xgratis or for a fee, you must give the recipients all the rights that
Xyou have.  You must make sure that they, too, receive or can get the
Xsource code.  And you must show them these terms so they know their
Xrights.
X
X  We protect your rights with two steps: (1) copyright the software, and
X(2) offer you this license which gives you legal permission to copy,
Xdistribute and/or modify the software.
X
X  Also, for each author's protection and ours, we want to make certain
Xthat everyone understands that there is no warranty for this free
Xsoftware.  If the software is modified by someone else and passed on, we
Xwant its recipients to know that what they have is not the original, so
Xthat any problems introduced by others will not reflect on the original
Xauthors' reputations.
X
X  Finally, any free program is threatened constantly by software
Xpatents.  We wish to avoid the danger that redistributors of a free
Xprogram will individually obtain patent licenses, in effect making the
Xprogram proprietary.  To prevent this, we have made it clear that any
Xpatent must be licensed for everyone's free use or not licensed at all.
X
X  The precise terms and conditions for copying, distribution and
Xmodification follow.
X
X            GNU GENERAL PUBLIC LICENSE
X   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
X
X  0. This License applies to any program or other work which contains
Xa notice placed by the copyright holder saying it may be distributed
Xunder the terms of this General Public License.  The "Program", below,
Xrefers to any such program or work, and a "work based on the Program"
Xmeans either the Program or any derivative work under copyright law:
Xthat is to say, a work containing the Program or a portion of it,
Xeither verbatim or with modifications and/or translated into another
Xlanguage.  (Hereinafter, translation is included without limitation in
Xthe term "modification".)  Each licensee is addressed as "you".
X
XActivities other than copying, distribution and modification are not
Xcovered by this License; they are outside its scope.  The act of
Xrunning the Program is not restricted, and the output from the Program
Xis covered only if its contents constitute a work based on the
XProgram (independent of having been made by running the Program).
XWhether that is true depends on what the Program does.
X
X  1. You may copy and distribute verbatim copies of the Program's
Xsource code as you receive it, in any medium, provided that you
Xconspicuously and appropriately publish on each copy an appropriate
Xcopyright notice and disclaimer of warranty; keep intact all the
Xnotices that refer to this License and to the absence of any warranty;
Xand give any other recipients of the Program a copy of this License
Xalong with the Program.
X
XYou may charge a fee for the physical act of transferring a copy, and
Xyou may at your option offer warranty protection in exchange for a fee.
X
X  2. You may modify your copy or copies of the Program or any portion
Xof it, thus forming a work based on the Program, and copy and
Xdistribute such modifications or work under the terms of Section 1
Xabove, provided that you also meet all of these conditions:
X
X    a) You must cause the modified files to carry prominent notices
X    stating that you changed the files and the date of any change.
X
X    b) You must cause any work that you distribute or publish, that in
X    whole or in part contains or is derived from the Program or any
X    part thereof, to be licensed as a whole at no charge to all third
X    parties under the terms of this License.
X
X    c) If the modified program normally reads commands interactively
X    when run, you must cause it, when started running for such
X    interactive use in the most ordinary way, to print or display an
X    announcement including an appropriate copyright notice and a
X    notice that there is no warranty (or else, saying that you provide
X    a warranty) and that users may redistribute the program under
X    these conditions, and telling the user how to view a copy of this
X    License.  (Exception: if the Program itself is interactive but
X    does not normally print such an announcement, your work based on
X    the Program is not required to print an announcement.)
X
XThese requirements apply to the modified work as a whole.  If
Xidentifiable sections of that work are not derived from the Program,
Xand can be reasonably considered independent and separate works in
Xthemselves, then this License, and its terms, do not apply to those
Xsections when you distribute them as separate works.  But when you
Xdistribute the same sections as part of a whole which is a work based
Xon the Program, the distribution of the whole must be on the terms of
Xthis License, whose permissions for other licensees extend to the
Xentire whole, and thus to each and every part regardless of who wrote it.
X
XThus, it is not the intent of this section to claim rights or contest
Xyour rights to work written entirely by you; rather, the intent is to
Xexercise the right to control the distribution of derivative or
Xcollective works based on the Program.
X
XIn addition, mere aggregation of another work not based on the Program
Xwith the Program (or with a work based on the Program) on a volume of
Xa storage or distribution medium does not bring the other work under
Xthe scope of this License.
X
X  3. You may copy and distribute the Program (or a work based on it,
Xunder Section 2) in object code or executable form under the terms of
XSections 1 and 2 above provided that you also do one of the following:
X
X    a) Accompany it with the complete corresponding machine-readable
X    source code, which must be distributed under the terms of Sections
X    1 and 2 above on a medium customarily used for software interchange; or,
X
X    b) Accompany it with a written offer, valid for at least three
X    years, to give any third party, for a charge no more than your
X    cost of physically performing source distribution, a complete
X    machine-readable copy of the corresponding source code, to be
X    distributed under the terms of Sections 1 and 2 above on a medium
X    customarily used for software interchange; or,
X
X    c) Accompany it with the information you received as to the offer
X    to distribute corresponding source code.  (This alternative is
X    allowed only for noncommercial distribution and only if you
X    received the program in object code or executable form with such
X    an offer, in accord with Subsection b above.)
X
XThe source code for a work means the preferred form of the work for
Xmaking modifications to it.  For an executable work, complete source
Xcode means all the source code for all modules it contains, plus any
Xassociated interface definition files, plus the scripts used to
Xcontrol compilation and installation of the executable.  However, as a
Xspecial exception, the source code distributed need not include
Xanything that is normally distributed (in either source or binary
Xform) with the major components (compiler, kernel, and so on) of the
Xoperating system on which the executable runs, unless that component
Xitself accompanies the executable.
X
XIf distribution of executable or object code is made by offering
Xaccess to copy from a designated place, then offering equivalent
Xaccess to copy the source code from the same place counts as
Xdistribution of the source code, even though third parties are not
Xcompelled to copy the source along with the object code.
X
X  4. You may not copy, modify, sublicense, or distribute the Program
Xexcept as expressly provided under this License.  Any attempt
Xotherwise to copy, modify, sublicense or distribute the Program is
Xvoid, and will automatically terminate your rights under this License.
XHowever, parties who have received copies, or rights, from you under
Xthis License will not have their licenses terminated so long as such
Xparties remain in full compliance.
X
X  5. You are not required to accept this License, since you have not
Xsigned it.  However, nothing else grants you permission to modify or
Xdistribute the Program or its derivative works.  These actions are
Xprohibited by law if you do not accept this License.  Therefore, by
Xmodifying or distributing the Program (or any work based on the
XProgram), you indicate your acceptance of this License to do so, and
Xall its terms and conditions for copying, distributing or modifying
Xthe Program or works based on it.
X
X  6. Each time you redistribute the Program (or any work based on the
XProgram), the recipient automatically receives a license from the
Xoriginal licensor to copy, distribute or modify the Program subject to
Xthese terms and conditions.  You may not impose any further
Xrestrictions on the recipients' exercise of the rights granted herein.
XYou are not responsible for enforcing compliance by third parties to
Xthis License.
X
X  7. If, as a consequence of a court judgment or allegation of patent
Xinfringement or for any other reason (not limited to patent issues),
Xconditions are imposed on you (whether by court order, agreement or
Xotherwise) that contradict the conditions of this License, they do not
Xexcuse you from the conditions of this License.  If you cannot
Xdistribute so as to satisfy simultaneously your obligations under this
XLicense and any other pertinent obligations, then as a consequence you
Xmay not distribute the Program at all.  For example, if a patent
Xlicense would not permit royalty-free redistribution of the Program by
Xall those who receive copies directly or indirectly through you, then
Xthe only way you could satisfy both it and this License would be to
Xrefrain entirely from distribution of the Program.
X
XIf any portion of this section is held invalid or unenforceable under
Xany particular circumstance, the balance of the section is intended to
Xapply and the section as a whole is intended to apply in other
Xcircumstances.
X
XIt is not the purpose of this section to induce you to infringe any
Xpatents or other property right claims or to contest validity of any
Xsuch claims; this section has the sole purpose of protecting the
Xintegrity of the free software distribution system, which is
Ximplemented by public license practices.  Many people have made
Xgenerous contributions to the wide range of software distributed
Xthrough that system in reliance on consistent application of that
Xsystem; it is up to the author/donor to decide if he or she is willing
Xto distribute software through any other system and a licensee cannot
Ximpose that choice.
X
XThis section is intended to make thoroughly clear what is believed to
Xbe a consequence of the rest of this License.
X
X  8. If the distribution and/or use of the Program is restricted in
Xcertain countries either by patents or by copyrighted interfaces, the
Xoriginal copyright holder who places the Program under this License
Xmay add an explicit geographical distribution limitation excluding
Xthose countries, so that distribution is permitted only in or among
Xcountries not thus excluded.  In such case, this License incorporates
Xthe limitation as if written in the body of this License.
X
X  9. The Free Software Foundation may publish revised and/or new versions
Xof the General Public License from time to time.  Such new versions will
Xbe similar in spirit to the present version, but may differ in detail to
Xaddress new problems or concerns.
X
XEach version is given a distinguishing version number.  If the Program
Xspecifies a version number of this License which applies to it and "any
Xlater version", you have the option of following the terms and conditions
Xeither of that version or of any later version published by the Free
XSoftware Foundation.  If the Program does not specify a version number of
Xthis License, you may choose any version ever published by the Free Software
XFoundation.
X
X  10. If you wish to incorporate parts of the Program into other free
Xprograms whose distribution conditions are different, write to the author
Xto ask for permission.  For software which is copyrighted by the Free
XSoftware Foundation, write to the Free Software Foundation; we sometimes
Xmake exceptions for this.  Our decision will be guided by the two goals
Xof preserving the free status of all derivatives of our free software and
Xof promoting the sharing and reuse of software generally.
X
X                NO WARRANTY
X
X  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
XFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
XOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
XPROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
XOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
XMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
XTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
XPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
XREPAIR OR CORRECTION.
X
X  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
XWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
XREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
XINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
XOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
XTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
XYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
XPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
XPOSSIBILITY OF SUCH DAMAGES.
X
X             END OF TERMS AND CONDITIONS
X
X    Appendix: How to Apply These Terms to Your New Programs
X
X  If you develop a new program, and you want it to be of the greatest
Xpossible use to the public, the best way to achieve this is to make it
Xfree software which everyone can redistribute and change under these terms.
X
X  To do so, attach the following notices to the program.  It is safest
Xto attach them to the start of each source file to most effectively
Xconvey the exclusion of warranty; and each file should have at least
Xthe "copyright" line and a pointer to where the full notice is found.
X
X    <one line to give the program's name and a brief idea of what it does.>
X    Copyright (C) 19yy  <name of author>
X
X    This program is free software; you can redistribute it and/or modify
X    it under the terms of the GNU General Public License as published by
X    the Free Software Foundation; either version 2 of the License, or
X    (at your option) any later version.
X
X    This program is distributed in the hope that it will be useful,
X    but WITHOUT ANY WARRANTY; without even the implied warranty of
X    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
X    GNU General Public License for more details.
X
X    You should have received a copy of the GNU General Public License
X    along with this program; if not, write to the Free Software
X    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
X
XAlso add information on how to contact you by electronic and paper mail.
X
XIf the program is interactive, make it output a short notice like this
Xwhen it starts in an interactive mode:
X
X    Gnomovision version 69, Copyright (C) 19yy name of author
X    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
X    This is free software, and you are welcome to redistribute it
X    under certain conditions; type `show c' for details.
X
XThe hypothetical commands `show w' and `show c' should show the appropriate
Xparts of the General Public License.  Of course, the commands you use may
Xbe called something other than `show w' and `show c'; they could even be
Xmouse-clicks or menu items--whatever suits your program.
X
XYou should also get your employer (if you work as a programmer) or your
Xschool, if any, to sign a "copyright disclaimer" for the program, if
Xnecessary.  Here is a sample; alter the names:
X
X  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
X  `Gnomovision' (which makes passes at compilers) written by James Hacker.
X
X  <signature of Ty Coon>, 1 April 1989
X  Ty Coon, President of Vice
X
XThis General Public License does not permit incorporating your program into
Xproprietary programs.  If your program is a subroutine library, you may
Xconsider it more useful to permit linking proprietary applications with the
Xlibrary.  If this is what you want to do, use the GNU Library General
XPublic License instead of this License.
!STUFFY!FUNK!
echo Extracting pc/config.h
sed >pc/config.h <<'!STUFFY!FUNK!' -e 's/X//'
X/*
X * This file was produced by running the config_h.SH script, which
X * gets its values from config.sh, which is generally produced by
X * running Configure.
X *
X * Feel free to modify any of this as the need arises.  Note, however,
X * that running config.h.SH again will wipe out any changes you've made.
X * For a more permanent change edit config.sh and rerun config.h.SH.
X *
X * $Id: config.h,v 2.0.1.3 1993/09/15 03:53:49 greyham Exp $
X */
X
X/* Configuration time: Sun Aug 22 08:23:18 CDT 1993
X * Configured by: hankedr
X * Target system: SunOS lab1 4.1.2 2 sun4c
X */
X
X#ifndef _config_h_
X#define _config_h_
X
X/* HAS_ACCESS:
X *    This manifest constant lets the C program know that the access()
X *    system call is available to check for accessibility using real UID/GID.
X *    (always present on UNIX.)
X */
X#define HAS_ACCESS        /**/
X
X/* HASCONST :
X *    This symbol, if defined, indicates that this C compiler knows about
X *    the const type. There is no need to actually test for that symbol
X *    within your programs. The mere use of the "const" keyword will
X *    trigger the necessary tests.
X */
X#define HASCONST    /**/
X#ifndef HASCONST
X#define const
X#endif
X
X/* FLEXFILENAMES:
X *    This symbol, if defined, indicates that the system supports filenames
X *    longer than 14 characters.
X */
X#define    FLEXFILENAMES        /**/
X
X/* HAS_OPEN3
X *    This manifest constant lets the C program know that the three
X *    argument form of open(2) is available.
X */
X#define HAS_OPEN3        /**/
X
X/* HAS_STRCHR:
X *    This symbol is defined to indicate that the strchr()/strrchr()
X *    functions are available for string searching. If not, try the
X *    index()/rindex() pair.
X */
X#define HAS_STRCHR    /**/
X
X/* HAS_STRFTIME:
X *    This symbol, if defined, indicates that the strftime routine is
X *    available to format locale-specific times.
X */
X#define HAS_STRFTIME    /**/
X
X/* HAS_STRSTR
X *    This symbol, if defined, indicates that the strstr routine is
X *    available to find substrings.
X */
X#define HAS_STRSTR    /**/
X
X/* HAS_LINK
X *    This symbol, if defined, indicates that the link routine is available
X *    to create hard links. OS/2 and DOS stupidity.
X/*#define HAS_LINK      /**/
X
X/* HAS_SYMLINK
X *    This symbol, if defined, indicates that the symlink routine is available
X *    to create symbolic links.
X */
X/*#define HAS_SYMLINK    /**/
X
X/* Time_t
X *    This symbol holds the type returned by time(). It can be long,
X *    or time_t on BSD sites (in which case <sys/types.h> should be
X *    included).
X */
X#define Time_t long        /* Time type */
X
X/* HASVOLATILE :
X *    This symbol, if defined, indicates that this C compiler knows about
X *    the volatile declaration.
X */
X#define    HASVOLATILE    /**/
X#ifndef HASVOLATILE
X#define volatile
X#endif
X
X/* I_FCNTL
X *    This manifest constant tells the C program to include <fcntl.h>.
X */
X#define I_FCNTL    /**/
X
X/* I_STDARG:
X *    This symbol, if defined, indicates that <stdarg.h> exists and should
X *    be included.
X */
X#define I_STDARG        /**/
X
X/* I_STDDEF:
X *    This symbol, if defined, indicates that <stddef.h> exists and should
X *    be included.
X */
X#define I_STDDEF    /**/
X
X/* I_STDLIB:
X *    This symbol, if defined, indicates that <stdlib.h> exists and should
X *    be included.
X */
X#define I_STDLIB        /**/
X
X/* I_STRING:
X *    This symbol, if defined, indicates to the C program that it should
X *    include <string.h> (USG systems) instead of <strings.h> (BSD systems).
X */
X#define I_STRING        /**/
X
X/* I_SYS_FILE
X *    This symbol, if defined, indicates to the C program that it should
X *    include <sys/file.h> to get definition of R_OK and friends.
X */
X#ifdef _MSC_VER
X#define W_OK 2
X#else
X#define I_SYS_FILE        /**/
X#endif
X
X/* I_SYS_TYPES
X *    This symbol, if defined, indicates to the C program that it should
X *    include <sys/types.h>.
X */
X#define    I_SYS_TYPES        /**/
X
X/* I_TIME
X *    This symbol, if defined, indicates to the C program that it should
X *    include <time.h>.
X */
X/* I_SYS_TIME
X *    This symbol, if defined, indicates to the C program that it should
X *    include <sys/time.h>.
X */
X#define I_TIME        /**/
X/*#define I_SYS_TIME        /**/
X
X/* I_UNISTD:
X *    This symbol, if defined, indicates to the C program that it should
X *    include <unistd.h>.
X */
X/*#define    I_UNISTD        /**/
X
X/* I_VARARGS:
X *    This symbol, if defined, indicates to the C program that it should
X *    include <varargs.h>.
X */
X/*#define I_VARARGS        /**/
X
X/* CAN_PROTOTYPE :
X *    If defined, this macro indicates that the C compiler can handle
X *    function prototypes.
X */
X/* DOTS :
X *    This macro is used to specify the ... in function prototypes which
X *    have arbitrary additional arguments.
X */
X/* NXT_ARG :
X *    This macro is used to separate arguments in the declared argument list.
X */
X/* P_FUNC :
X *    This macro is used to declare "private" (static) functions.
X *    It takes three arguments: the function type and name, a parenthesized
X *    traditional (comma separated) argument list, and the declared argument
X *    list (in which arguments are separated with NXT_ARG, and additional
X *    arbitrary arguments are specified with DOTS).  For example:
X *
X *        P_FUNC(int foo, (bar, baz), int bar NXT_ARG char *baz[])
X */
X/* P_FUNC_VOID :
X *    This macro is used to declare "private" (static) functions that have
X *    no arguments.  The macro takes one argument: the function type and name.
X *    For example:
X *
X *        P_FUNC_VOID(int subr)
X */
X/* V_FUNC :
X *    This macro is used to declare "public" (non-static) functions.
X *    It takes three arguments: the function type and name, a parenthesized
X *    traditional (comma separated) argument list, and the declared argument
X *    list (in which arguments are separated with NXT_ARG, and additional
X *    arbitrary arguments are specified with DOTS).  For example:
X *
X *        V_FUNC(int main, (argc, argv), int argc NXT_ARG char *argv[])
X */
X/* V_FUNC_VOID :
X *    This macro is used to declare "public" (non-static) functions that have
X *    no arguments.  The macro takes one argument: the function type and name.
X *    For example:
X *
X *        V_FUNC_VOID(int fork)
X */
X/* _
X *    This macro is used to declare function parameters for folks who want
X *    to make declarations with prototypes using a different style than
X *    the above macros.  Use double parentheses.  For example:
X *
X *        int main _((int argc, char *argv[]));
X */
X#define    CAN_PROTOTYPE    /**/
X#ifdef CAN_PROTOTYPE
X#define    NXT_ARG ,
X#define    DOTS , ...
X#define    V_FUNC(name, arglist, args)name(args)
X#define    P_FUNC(name, arglist, args)static name(args)
X#define    V_FUNC_VOID(name)name(VOID)
X#define    P_FUNC_VOID(name)static name(VOID)
X#define    _(args) args
X#else
X#define    NXT_ARG ;
X#define    DOTS
X#define    V_FUNC(name, arglist, args)name arglist args;
X#define    P_FUNC(name, arglist, args)static name arglist args;
X#define    V_FUNC_VOID(name)name()
X#define    P_FUNC_VOID(name)static name()
X#define    _(args) ()
X#endif
X
X/* CAN_VAPROTO :
X *    This variable is defined on systems supporting prototype declaration
X *    of functions with a variable number of arguments.
X */
X/* _V :
X *    This macro is used to declare function parameters in prototypes for
X *    functions with a variable number of parameters. Use double parentheses.
X *    For example:
X *
X *        int printf _V((char *fmt, ...));
X *
X *    Remember to use the plain simple _() macro when declaring a function
X *    with no variable number of arguments, since it might be possible to
X *    have a non-effect _V() macro and still get prototypes via _().
X */
X#define CAN_VAPROTO    /**/
X#ifdef CAN_VAPROTO
X#define    _V(args) args
X#else
X#define    _V(args) ()
X#endif
X
X/* VOIDFLAGS :
X *    This symbol indicates how much support of the void type is given by this
X *    compiler.  What various bits mean:
X *
X *        1 = supports declaration of void
X *        2 = supports arrays of pointers to functions returning void
X *        4 = supports comparisons between pointers to void functions and
X *            addresses of void functions
X *        8 = suports declaration of generic void pointers
X *
X *    The package designer should define VOIDUSED to indicate the requirements
X *    of the package.  This can be done either by #defining VOIDUSED before
X *    including config.h, or by defining defvoidused in Myinit.U.  If the
X *    latter approach is taken, only those flags will be tested.  If the
X *    level of void support necessary is not present, defines void to int.
X */
X#ifndef VOIDUSED
X#define VOIDUSED 9
X#endif
X#define VOIDFLAGS 9
X#if (VOIDFLAGS & VOIDUSED) != VOIDUSED
X#define void int        /* is void to be avoided? */
X#define M_VOID            /* Xenix strikes again */
X#endif
X
X/* CPP_FILE_COM
X *    This symbol contains the first part of the string which will invoke
X *    the C preprocessor a file and produce to standard output, preserving
X *    comments. Typical value of "cc -E -C" or "/lib/cpp -C".
X */
X/* CPP_STDIN_FLAGS
X *    This variable contains any flags necessary to get CPP_FILE_COM to
X *    read from the standard input.
X */
X/* CPP_IGN_HDRS
X *    This symbol is defined if CPP_FILE_COM ignores *.h files.
X */
X/* CPP_CAN_STDIN
X *    This symbol is defined if CPP_FILE_COM can read standard input
X *    directly.
X */
X#ifdef _MSC_VER
X#define CPP_FILE_COM "cl -nologo -E -C"
X#else
X#define CPP_FILE_COM "gcc -E -C"
X#endif
X#define CPP_STDIN_FLAGS ""
X/*#define CPP_IGN_HDRS        /* does CPP ignore .h files? */
X/*#define CPP_CAN_STDIN     /* can CPP read stdin directly? */
X
X#endif
!STUFFY!FUNK!
echo Extracting eg/returnlist.h
sed >eg/returnlist.h <<'!STUFFY!FUNK!' -e 's/X//'
X/* generate a lot of silly values
X * Returns: Quite a number of things, as follows:
X *    0    nothing
X *    1    something small
X *    2    a little larger
X *    3    done in triplicate
X *    4    getting larger
X *    5    quintuplets
X *    6    that'll do now, although I think this one is going to get
X *        very long and even cover multiple lines. let's just hope that
X *        it gets it right, including the capitalisation. maybe this is
X *        not a super thorough test, so including some
X * .B bold
X *        stuff might help
X */
Xint returnlist();
!STUFFY!FUNK!
echo "End of kit 5 (of 9)"
echo " "
cat /dev/null >kit5isdone
run=''
config=''
for iskit in 1 2 3 4 5 6 7 8 9; do
    if test -f kit${iskit}isdone; then
        run="$run $iskit"
    else
        todo="$todo $iskit"
    fi
done
case $todo in
    '')
        echo "You have run all your kits."
        if test -f PACKNOTES; then
            sh PACKNOTES
        else
            echo "You have to rebuild split files by hand (see PACKLIST)."
        fi
        echo "Please read README and then type Configure."
        chmod 755 Configure
        rm -f kit*isdone
        ;;
    *)  echo "You have run$run."
        echo "You still need to run$todo."
        ;;
esac
: Someone might mail this, so exit before signature...
exit 0
--
Graham Stoney, Hardware/Software Engineer
Canon Information Systems Research Australia
Ph: + 61 2 805 2909    Fax: + 61 2 805 2929

exit 0 # Just in case...