Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/unix/volume3/ff/part01

Internet Message Format | 1986-11-30 | 32.3 KB

Subject: ff: fast text formatter (part 1 of 2)
Newsgroups: mod.sources
Approved: [e-mail]

Mod.sources:  Volume 3, Issue 51
Submitted by: decvax!wanginst!perlman

                 ff: A Fast Text Formatter

Here is ff, a fast text  formatter.  It fills a gap  between
the fmt program in Berkeley UNIX and systems like nroff.  ff
is sort  of an  inside-out  nroff.   There are  no  commands
inside a file, but the common options like line width,  line
spacing, indentation,  pagination,  etc., are  command  line
options.  ff is a general  utility that lets you throw  away
most uses of programs like pr, expand, and especially fmt.

There are  a lot  of options  for ff--some  would argue  too
many--but they are necessary  to provide the  functionality.
I make shell scripts that encode most of my needs.  Here  is
the shell script I  am using to  format these paragraphs  (I
have the filter bound to a function key; I go to the top  of
the paragraph and type PF1).
    exec ff -w 60 -j -B "     '*.@|" $*
I have  scripts  for  centering  regions  and  for  indented
paragraphs.   These  and  a  nice  one  for  making  program
listings are listed in the manual entry.  emacs users  might
find the centering  option useful, even  though many of  the
other functions are built in to  emacs.  vi users will  find
ff and option-variants on it much more useful.

ff really is fast--roughly  twice the speed  as fmt for  the
formats fmt  supports.   For paginating  text, ff  is  about
twice as fast as  pr.  The tab  expansion options on ff  are
comparable to  those of  the  expand program,  but ff  is  a
little slower than expand  on expanding tabs--it simply  has
too many concerns that expand can ignore.  Still, ff is fast
enough to bind  to keys in  emacs or vi  to filter  regions,
making vi a passable wysiwyg editor.  One reason for this is
extensive profiling and  optimization, some  by my  students
for a programming efficiency assignment.

#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
#    ff.1
#    ff.test
#    makefile
#    number.c
#    filter.c
#    getopt.c
# This archive created: Wed Nov 13 19:27:58 1985
# By:    Gary Perlman (Wang Institute, Tyngsboro, MA 01879 USA)
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'ff.1'" '(6812 characters)'
if test -f 'ff.1'
then
    echo shar: "will not over-write existing file 'ff.1'"
else
sed 's/^    X//' << \SHAR_EOF > 'ff.1'
    X.TH FF 1 "August 10, 1985" "Wang Institute" "UNIX User's Manual"
    X.\" $Compile: iroff -man.new %f
    X.SH NAME
    Xff \- fast text formatter
    X.SH USAGE
    X.B ff
    X[options] [-] [files]
    X.SH DESCRIPTION
    X.I ff
    Xis a simple text formatter for flexible uniform formatting of
    Xinput files.
    XProgram options are used to control formatting.
    XThis is in contrast to text formatters like
    X.I nroff (1)
    Xthat require special format requests to be part of their input files.
    XBesides avoiding cryptic format requests in text,
    X.I ff
    Xis considerably faster than traditional formatters like
    X.I nroff (1)
    Xand even simple formatters like
    X.I fmt (1).
    X.PP
    XThe most complicated concept with
    X.I ff
    Xis that of a line break.
    XA line break causes an interruption in the filling
    X(evening out of the text lines).
    XLine breaks occur when special characters are seen at the beginnings
    Xof lines, or when all lines are broken.
    XBy default, any non-alphanumeric character will cause a break,
    Xbut this can be controlled with the
    X.B -B
    Xoption.
    XA blank line always causes a break.
    X.SH OPTIONS
    XThere are many, many options to allow control of
    Xindentation, line width, line spacing, filling,
    Xpagination with headers and footers,
    Xline numbering, right justification,
    Xand perhaps some other things.
    XThey have extensive type and range checking
    Xthat produces diagnostic error messages,
    Xso warnings of obviously wrong options will not be discussed here.
    XIn general, options that imply the use of others
    Xwork the way they should; if the page size is set,
    Xthen pagination is automatically assumed.
    XSome combinations of options give impressive, even artistic, effects.
    XMaking a small text file and playing with it is the easiest
    Xway to learn how the options interact.
    X.de OP
    X.TP
    X.B -\\$1 \\$2
    X..
    X.OP b
    XBreak all lines of text.
    XThat is, don't even-out lines by filling.
    XBy default, text lines are filled.
    X.OP B breakchars
    XChange the set of characters that cause line breaks at the start of lines to
    X.I breakchars.
    XBy default, any characters but letters and numbers cause a break.
    XA good choice for break characters might be "*-+" and TABS
    Xthat might be used for lists.
    X.OP c
    XCenter all lines of text.
    XThis option stops all filling of text.
    X.OP d
    XDelete white space at the beginning and end of lines.
    XThis option is useful to help un-format text to be re-formatted.
    X.OP D
    XDelete empty input lines.
    XAn input line is empty if it has no characters,
    Xnot even invisible character like tabs or spaces.
    XThis option can be combined with the option to remove white space
    Xto delete visibly blank lines.
    X.OP f footer
    XSet the page footer to the string
    X.I footer.
    XThis can be any string,
    Xbut if the first character is not a letter or a digit,
    Xbut a punctuation character like /,
    Xthen that character separates the left,
    Xcenter, and right fields of a title.
    XFor example, the title
    X.ce
    X"/ff: fast formatter//1985/"
    Xwould have "ff: fast formatter" as a left justified field
    Xand 1985 as a right justified field on each page.
    XNote that there is no middle field in this example,
    Xbut there could have been, between the two consecutive /'s.
    XThere are two special characters, % and *,
    Xthat respectively are variables for the page number
    Xand the input file name.
    XThe default page footer is blank.
    X.OP F footersize
    XSet the number of blank lines at the bottom of the page.
    XThe footer, if any, is placed in the middle of the space,
    Xwhich by default, is five lines.
    XIf
    X.I footersize
    Xis 0, no footer will be printed.
    X.OP h header
    XSet the page header.
    XSee the description of three-part titles for the
    X.B -f footer
    Xoption.
    XThe default page header is
    X.ce
    X"|File: *||Page: %|".
    X.OP H headersize
    XSee the description of the footer size.
    X.OP i indent
    XSet the indentation of the text to
    X.I indent
    Xspaces.
    XNote that this effectively reduces the usable width of the page.
    X.OP I tempindent
    XSet the temporary indent.
    XThis causes filled text found immediately after a break to
    Xbe indented for one line.
    XIt is useful for indenting the first lines of paragraphs.
    XIf
    X.I tempindent
    Xis negative,
    Xthe the temporary indent will be relative to the current
    X.I indent
    Xvalue.
    XIf the
    X.I tempindent
    Xvalue is more negative than the
    X.I indent
    Xvalue is positive,
    X.I ff
    Xwill automatically increase
    X.I indent.
    X.OP j
    XJustify the text.
    XThat is, even the right margin by inserting spaces in the line.
    XOnly filled text can be justified.
    X.OP n
    XNumber all output lines produced by the input text.
    XLines from multiple line spacing or pagination will not
    Xbe numbered.
    X.OP N numberwidth
    XSet the width of the line numbers.
    XThe default is to take up 4 spaces.
    XNote that this effectively reduces the usable part of the page.
    X.OP p
    XPaginate the output.
    XSee the options for page header and footer control.
    X.OP P pagesize
    XSet the number of lines in a page to
    X.I pagesize.
    XBy default, the standard 66 line page is assumed.
    X.OP s spacing
    XSet the line spacing.
    XBy default, text is single spaced (\fIspacing\fR equals 1).
    X.OP t tab
    XSet individual absolute and relative tab stops.
    XThese values tell the formatter
    Xwhere to put the text (from an unfilled line)
    Xthat follows a tab character.
    XEach tab stop is supplied with its own
    X.B -t
    Xoption; there is no way to bundle them.
    X.I tab
    Xvalues can be integers without a plus sign.
    XThese are \fIabsolute\fR tab settings;
    Xthe tabs go to that position.
    XThe values must increase monotonically.
    XIf a
    X.I tab
    Xvalue is preceded by a plus sign,
    Xthen it is interpreted \fIrelative\fR to the previous tab setting.
    XFor example, a tab setting of 40 followed by one of +20
    Xwill set the second tab stop to 60.
    X.OP T tabs
    XSet tab stops to every
    X.I tabs
    Xspaces.
    XIt is useful to get equally spaced tabs.
    XThis option cannot be used with the other tab setting option.
    X.OP u
    XPrint All Input Text As Initial Upper-Case Titles,
    XLike This Sentence.
    XThis option goes well with the one for centering lines.
    X.OP U
    XPrint a usage summary of all the options and stop.
    X.OP w width
    XSet the page width.
    XBy default, the page width is 72 characters.
    XNote that the usable line length is sometimes less
    Xthan the page width.
    XIf line numbering or indentation is requested,
    Xthese subtract from the line length.
    X.SH EXAMPLES
    XSome of these examples can make shell scripts or aliases.
    X.nf
    X.ta .5i
    X.sp
    XCentered Titles: title
    X    ff -dcu $*
    XDouble Spaced Unfilled Paginated indented (for editing): draft
    X    ff -s 2 -b -p -f "`date`" -i 8 $*
    XProgram Listing: cpr
    X    H="@        Dir: `pwd`@@File: *@"
    X    F="@        $NAME@`date`@Page %@"
    X    ff -b -N 8 -H 3 -h "$H" -F 3 -f "$F" -T 4 -w 79 -i 2 $*
    XReformat Paragraphed Text: nr
    X    ff -jd -I 5 -i 10 -w 65 -B "TAB SP'*.@" $*
    X.fi
    X.SH DIAGNOSTICS
    XSome options are incompatible with others.
    XFor example, centered text cannot be right-justified.
    X.I ff
    Xwill not allow inconsistent combinations of options.
    X.SH "SEE ALSO"
    Xfmt(1), nroff(1), scribe(1w)
    X.SH AUTHOR
    XGary Perlman (with help from many students)
    X.SH STATUS
    XPretty well tested.
SHAR_EOF
if test 6812 -ne "`wc -c < 'ff.1'`"
then
    echo shar: "error transmitting 'ff.1'" '(should have been 6812 characters)'
fi
fi
echo shar: "extracting 'ff.test'" '(7703 characters)'
if test -f 'ff.test'
then
    echo shar: "will not over-write existing file 'ff.test'"
else
sed 's/^    X//' << \SHAR_EOF > 'ff.test'
    X#! /usr/local/bin/ksh
    X# test script for ff fast text formatter
    X
    XPATH=$PATH:/tmp
    Xdelim="-------------- "
    Xtrap "rm -f /tmp/linelength fourcol ff.in; exit 1" 2
    X
    X# Define utility functions
    Xfunction runcom
    X    {
    X    echo "$delim($1):" "$2"
    X    shift
    X    echo $* | sh
    X    }
    Xfunction newtest
    X    {
    X    echo
    X    echo $1
    X    echo ===============================================
    X    }
    X# the following must be available to the Bourne shell
    Xecho "dm '#INPUT'" > /tmp/linelength
    Xchmod +x /tmp/linelength
    X
    X# create utility files
    Xcat << \EOF > fourcol
    Xa    b    c    d
    X    w    x    y    z
    XEOF
    Xcat << \EOF > ff.in
    XThe rain in Spain falls mainly in the plains.
    XShe sells sea shells on the sea shore.
    XPeter piper picked a peck of pickled peppers.
    XThe quick red fox jumped over the lazy brown dog.
    XA stitch in time saves nine.
    XNow is the time for all good men to come to the aid of the party.
    XAnd now a word from our sponsor...
    X
    XThe rain in Spain falls mainly in the plains.  She sells sea
    Xshells on  the sea  shore.   Peter piper  picked a  peck  of
    Xpickled peppers.   The quick  red fox jumped  over the  lazy
    Xbrown dog.  A stitch  in time saves nine.   Now is the  time
    Xfor all good men to come to the aid of the party.  And now a
    Xword from our sponsor...
    XEOF
    X
    Xnewtest "WIDTH WIDTH WIDTH WIDTH WIDTH WIDTH WIDTH WIDTH"
    Xruncom "width of 1"                  "ff -w 1 ff.in | linelength"
    Xruncom "width of 20"                 "ff -w 20 ff.in | linelength"
    Xruncom "width of 60"                 "ff -w 60 ff.in | linelength"
    X
    Xnewtest "JUSTIFY JUSTIFY JUSTIFY JUSTIFY JUSTIFY JUSTIFY JUSTIFY"
    Xruncom "justify text"                    "ff -j ff.in"
    Xruncom "justify with width = 30"         "ff -w 30 -j ff.in | linelength"
    Xruncom "justify with indent and temp indent"  "ff -j -i 20 -I 5 ff.in | linelength"
    X
    Xnewtest "ALLTABS ALLTABS ALLTABS ALLTABS ALLTABS ALLTABS"
    Xruncom "tabs set at 1"          "ff -T 1 -b fourcol"
    Xruncom "tabs set at 10"         "ff -T 10 -b fourcol"
    Xruncom "tabs set at 100"        "ff -T 100 -b fourcol"
    X
    Xnewtest "TABS TABS TABS TABS TABS TABS TABS TABS TABS TABS"
    Xruncom "decreasing values"      "ff -t 10 -t 11 -t 10"
    Xruncom "non increasing values"  "ff -t 10 -t 11 -t 11"
    Xruncom "1 too many values"      "ff -t 1 -t 2 -t 3 -t 4 -t 5 -t 6 -t 7 -t 8 -t 9 -t 10 -t 11 -t 12 -t 13 -t 14 -t 15 -t 16 -t 17 -t 18 -t 19 -t 20 -t 21"
    Xruncom "max number of values - exits from unknown option" "ff -t 1 -t 2 -t 3 -t 4 -t 5 -t 6 -t 7 -t 8 -t 9 -t 10 -t 11 -t 12 -t 13 -t 14 -t 15 -t 16 -t 17 -t 18 -t 19 -t 20 -z"
    Xruncom "huge tab value"         "ff -t 300"
    Xruncom "tab value at extreme"   "ff -t 255 fourcol"
    Xruncom "indented ff -U table"   "ff -U | ff -t 20"
    Xruncom "all plussed values" "ff -t +55 -t +15 fourcol"
    Xruncom "more tabs than tabstops" "ff -t 10 -t +15 fourcol"
    X
    Xnewtest "UPPER CASE TITLE UPPER CASE TITLE UPPER CASE TITLE"
    Xruncom "all titles"              "ff -u ff.in"
    Xruncom "centered titles"         "ff -cu ff.in"
    X
    Xnewtest "SPACING SPACING SPACING SPACING SPACING SPACING SPACING"
    Xruncom "24 lines spacing of 10 lines - 217 lines" "series 1 10 | ff -bs 24 | wc"
    X
    Xnewtest "NUMWIDTH NUMWIDTH NUMWIDTH NUMWIDTH NUMWIDTH NUMWIDTH"
    Xruncom "1 value"                 "ff -N 1 ff.in"
    Xruncom "numwidth = 10"           "ff -N 10 ff.in"
    Xruncom "numwidth 20 centered"    "ff -N 20 -c ff.in"
    Xruncom "numwidth=10 indent=10 width=50 tindent=-5 justified" "ff -N 10 -i 10 -w 50 -I -5 -j ff.in"
    X
    Xnewtest "NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER NUMBER"
    Xruncom "number zero lines"       "ff -n /dev/null"
    Xruncom "number centered lines"   "ff -n -c ff.in"
    Xruncom "number 4 spaced broken lines" "ff -s 4 -n ff.in"
    Xruncom "number 3 spaced lines on 23 line pages" "series 1 200 | ff -n -s 3 -b -P 23 | wc"
    X
    Xnewtest "TINDENT TINDENT TINDENT TINDENT TINDENT TINDENT TINDENT"
    Xruncom "temp indent 5"                   "ff -I 5 ff.in"
    Xruncom "negative temp indent will automatically bump -i option" "ff -I -5 ff.in"
    Xruncom "negative temp indent less than -i option" "ff -I -5 -i 10 ff.in"
    X
    Xnewtest "INDENT INDENT INDENT INDENT INDENT INDENT INDENT INDENT"
    Xruncom "indent 10"                  "ff -i 10 ff.in"
    Xruncom "indent 50"                  "ff -i 50 ff.in"
    X#runcom "indent 300 - does not crash but is really tedious" "ff -i 300 ff.in"
    X
    Xnewtest "HEADSIZE HEADSIZE HEADSIZE HEADSIZE HEADSIZE HEADSIZE"
    Xruncom "1 header size"              "ff -H 1 ff.in | wc"
    Xruncom "100 header size"            "ff -h 'Huge header!!' -H 100 ff.in | wc"
    Xnewtest "tricky part can come with even and odd sizes"
    Xruncom "20 header w/out -p option"  "ff -H 20 ff.in | wc"
    Xruncom "odd header size = 19"       "ff -H 19 ff.in | wc"
    X
    Xnewtest "HEADER HEADER HEADER HEADER HEADER HEADER HEADER"
    Xruncom "nice header"                'ff -h "@$NAME on $TERM@@`date`" ff.in'
    X
    Xnewtest "FOOTSIZE FOOTSIZE FOOTSIZE FOOTSIZE FOOTSIZE FOOTSIZE"
    Xruncom "1 foot size"                'ff -F 0 -f "Howdy $NAME" ff.in | wc'
    Xruncom "zero foot size without -p"  "ff -F 0 ff.in"
    Xruncom "20 foot size"               'ff -F 20 -f "Howdy $NAME" ff.in | wc'
    Xruncom "19 foot size"               'ff -F 19 -f "Howdy $NAME" ff.in | wc'
    X
    Xnewtest "FOOTER FOOTER FOOTER FOOTER FOOTER FOOTER FOOTER"
    Xruncom "nice threepart"             'ff -f "@`date`@$NAME@File * Page %@" ff.in'
    X
    Xnewtest "DELETE DELETE DELETE DELETE DELETE DELETE DELETE"
    Xruncom "delete blank lines - not really blank" "ff -D ff.in"
    Xruncom "delete blank chars - breaking all lines" "ff -bd ff.in | diff ff.in -"
    Xruncom "delete chars then lines"    "ff -Dd ff.in"
    X
    Xnewtest "BREAKCHARS BREAKCHARS BREAKCHARS BREAKCHARS"
    Xruncom "null break chars"            'ff -B "" ff.in'
    Xruncom "break on T"                  "ff -B T ff.in"
    X
    Xnewtest "PAGELENGTH PAGELENGTH PAGELENGTH PAGELENGTH PAGELENGTH"
    Xruncom "0dd page length of 19 should imply -p option" "ff -P 19 ff.in | wc"
    Xruncom "ridiculously small page length" "ff -P 1 ff.in | wc"
    X
    Xnewtest "PAGINATE PAGINATE PAGINATE PAGINATE PAGINATE PAGINATE"
    Xruncom "paginate"                    "ff -p ff.in | wc"
    X
    Xnewtest "BREAK BREAK BREAK BREAK BREAK BREAK BREAK BREAK"
    Xruncom "break lines + check with diff" "ff -b ff.in | diff - ff.in"
    X
    Xnewtest "CENTER CENTER CENTER CENTER CENTER CENTER CENTER "
    Xruncom "center all lines"            "ff -c ff.in"
    Xruncom "center on lines 50 wide"     "ff -c -w 50 ff.in"
    Xruncom "center on lines 1 wide"      "ff -c -w 1 ff.in"
    X
    Xnewtest "BASIC BASIC BASIC BASIC BASIC BASIC BASIC BASIC "
    Xruncom "no options from stdin"       "ff < ff.in"
    Xruncom "no options from stdin -"     "ff - < ff.in"
    Xruncom "no options from ff.in"       "ff ff.in"
    Xruncom "three times: ff.in - ff.in"  "ff ff.in - ff.in < ff.in"
    Xruncom "usage menu"                  "ff -U"
    X
    Xnewtest "BAD OPTIONS BAD OPTIONS BAD OPTIONS BAD OPTIONS"
    Xruncom "bad option"                  "ff -z"
    Xruncom "bad file"                    "ff howdy pal"
    Xruncom "too many calls to stdin"     "ff - - - < ff.in"
    X
    Xnewtest "PARSER PARSER PARSER PARSER PARSER PARSER PARSER PARSER"
    X
    Xnewtest "CHECK OPTIONS CHECK OPTIONS CHECK OPTIONS CHECK OPTIONS"
    Xruncom "center iff no justify"       "ff -cj ff.in"
    Xruncom "break lines iff no justify"  "ff -bj ff.in"
    Xruncom "justify iff not center"          "ff -cj"
    Xruncom "justify iff not breaklines"      "ff -bj"
    Xruncom "justify iff not tabs"            "ff -t 5 -j"
    X
    Xnewtest "NUMBER OPTIONS NUMBER OPTIONS NUMBER OPTIONS NUMBER OPTIONS"
    Xfor numopt in P w T t s N i I H F P
    Xdo
    X    runcom "Missing Value"               "ff -$numopt < ff.in"
    X    runcom "Bad Type Value"              "ff -$numopt foo < ff.in"
    X    runcom "Zero Integer"                "ff -$numopt 0 < ff.in"
    X    runcom "Negative Integer"            "ff -$numopt -1 < ff.in"
    Xdone
    X
    Xnewtest "MISSING ARGS MISSING ARGS MISSING ARGS MISSING ARGS"
    Xfor argopt in h f B
    Xdo
    X    runcom "Missing Value"               "ff -$argopt < ff.in"
    Xdone
SHAR_EOF
if test 7703 -ne "`wc -c < 'ff.test'`"
then
    echo shar: "error transmitting 'ff.test'" '(should have been 7703 characters)'
fi
chmod +x 'ff.test'
fi
echo shar: "extracting 'makefile'" '(1056 characters)'
if test -f 'makefile'
then
    echo shar: "will not over-write existing file 'makefile'"
else
sed 's/^    X//' << \SHAR_EOF > 'makefile'
    XMAIN=ff
    XSRCS=number.c filter.c getopt.c
    XOBJS=number.o filter.o getopt.o
    XDOCS=ff.1 ff.test
    XLIBS=
    XDESTDIR=.
    XCFLAGS=-O
    XTEXT=$(HDRS) $(SRCS)
    X
    XLINT  =/usr/bin/lint -hp
    XPR    =cpr
    XSPELL =sp
    XSHAR  =shar -a
    XRCS   =ci -l
    XCC    =/bin/cc
    X
    X$(MAIN): $(MAIN).o $(OBJS)
    X    $(CC) $(CFLAGS) -o $@ $@.o $(OBJS)
    X
    Xinstall: $(MAIN)
    X    cp -i $(MAIN) $(DESTDIR)/$(MAIN)
    X
    Xprint:
    X    @$(PR) $(MAIN).c
    X
    Xlint:
    X    $(LINT) $(TEXT) $(MAIN).c
    X
    Xspell:
    X    seec -cqe $(MAIN).c | $(SPELL)
    X
    Xtest:
    X    $(MAIN).test
    X
    Xarchive: $(DOCS) [Mm]akefile $(TEXT) $(MAIN).c
    X    @$(SHAR) $(DOCS) [Mm]akefile $(TEXT) > archive.1
    X    @$(SHAR) $(MAIN).c > archive.2
    X
    Xclean:
    X    rm -f *.o core a.out mon.out gmon.out scmon.out
    X
    Xgprof:
    X    make CFLAGS="$(CFLAGS) -pg"
    Xscprof:
    X    make CFLAGS="$(CFLAGS) -p" CC=sc
    X
    Xxref: cscope.out
    X    ccall -dr > xref.r
    X    ccall -a > xref.a
    X    touch xref
    Xcscope.out: $(MAIN).c
    X    cscope $(MAIN).c
    X
    Xstyle: style.out
    Xstyle.out:
    X    cstyle $(MAIN).c > style.out
    X
    Xrcs: RCS
    X    $(RCS) $(TEXT) $(MAIN).c
    XRCS: $(TEXT) $(MAIN).c
    X
    X$(MAIN).1: $(MAIN).c
    X    @seec -t MANUAL $(MAIN).c > $(MAIN).1
    X
    X.PRECIOUS: $(TEXT) $(DOCS) $(MAIN).c
SHAR_EOF
if test 1056 -ne "`wc -c < 'makefile'`"
then
    echo shar: "error transmitting 'makefile'" '(should have been 1056 characters)'
fi
fi
echo shar: "extracting 'number.c'" '(4039 characters)'
if test -f 'number.c'
then
    echo shar: "will not over-write existing file 'number.c'"
else
sed 's/^    X//' << \SHAR_EOF > 'number.c'
    X/* Copyright (c) 1982, 1985 Gary Perlman */
    X/* Copies can be made if not for material gain */
    X
    X/*
    X    number: report if a string is a UNIX formatted number
    X
    X    notes:
    X        a number in UNIX is one that can be converted from
    X        a string to an integer or real with no loss of information
    X            due to bad format
    X        all numbers can be surrounded by whitespace
    X        an integer has an optional minus sign, followed by digits
    X        a real number has an optional minus sign followed by digits
    X        if a string has a decimal point, followed by zeros, it is real, not int
    X
    X    value:
    X        1 is string is an integer [-] 0-9+
    X        2 is string is a real number (as seen by atof)
    X        0 for non-numbers
    X
    X    compilation flags:
    X        -DSTANDALONE    includes test main program
    X        $Compile: cc -DSTANDALONE -O -o %F %f
    X
    X    deficiencies:
    X        does not check to see if significant digits will be ignored
    X
    X    author:
    X        Gary Perlman
    X
    X    date:
    X        Wed May 22 13:30:40 EDT 1985
    X        Sun Sep  1 14:53:51 EDT 1985 (modified test module)
    X
    X*/
    X#include <ctype.h>
    X
    X#ifndef lint
    Xstatic char sccsfid[] = "@(#) number.c 5.2 (unix|stat) 9/1/85";
    X#endif
    X
    X#define    IS_NOT      0            /* not a number */
    X#define    IS_INT      1            /* an integer */
    X#define    IS_REAL     2            /* a real number */
    X
    X#define    EOS         '\0'
    X
    X/*LINTLIBRARY*/
    X
    Xnumber (string)
    Xchar    *string;                 /* the string to be tested */
    X    {
    X    int     answer = IS_INT;     /* start by assuming it is an integer */
    X    int     before = 0;          /* anything before the decimal? */
    X    int     after = 0;           /* anything after the decimal? */
    X    while (isspace (*string))    /* skip over blank space */
    X        string++;
    X    if (*string == EOS)          /* empty string not allowed */
    X        return (IS_NOT);
    X    if (*string == '+' || *string == '-') /* old atoi didn't allow '+' */
    X        {
    X        string++;
    X        if (!isdigit (*string) && *string != '.')
    X            return (IS_NOT);
    X        }
    X    if (isdigit (*string))       /* note that there was a digit before . */
    X        {
    X        before = 1;
    X        while (isdigit (*string))
    X            string++;
    X        }
    X    if (*string == '.')          /* found a decimal point, parse for real */
    X        {
    X        answer = IS_REAL;
    X        string++;
    X        if (isdigit (*string))   /* note that there was a digit after . */
    X            {
    X            after = 1;
    X            while (isdigit (*string))
    X                string++;
    X            }
    X        }
    X    if (!before && !after)       /* must be digit somewhere */
    X        return (IS_NOT);
    X    if (*string == 'E' || *string == 'e') /* exponent */
    X        {
    X        answer = IS_REAL;
    X        string++;
    X        if (*string == '+' || *string == '-') /* optional sign */
    X            string++;
    X        if (!isdigit (*string))  /* missing exponent */
    X            return (IS_NOT);
    X        while (isdigit (*string))
    X            string++;
    X        }
    X    while (isspace (*string))    /* skip optional spaces */
    X        string++;
    X    /* should now have exhausted the input string */
    X    return (*string == EOS ? answer : IS_NOT);
    X    }
    X
    X#ifdef STANDALONE
    X
    X#include <stdio.h>
    X/*
    X    exits with status = the number of args not numerical
    X    Shell Example:
    X        if number -i $*
    X        then
    X            echo processing $*
    X        else
    X            echo $0: arguments must be integers
    X        fi
    X    Options:
    X        -i  arguments must be integer
    X        -n  arguments must be non-negative
    X*/
    Xint     NoNegative;   /* do the values have to be non-negative? */
    Xint     Integer;      /* do the values have to be integers? */
    X
    Xstatic
    Xint
    Xinitial (argc, argv) char **argv;
    X    {
    X    extern    char    *optarg;
    X    extern    int     optind;
    X    int     errflg = 0;
    X    int     C;
    X    char    *optstring = "in";
    X    char    *usage = "[-in] string ...";
    X    while ((C = getopt (argc, argv, optstring)) != EOF)
    X        switch (C)
    X            {
    X            case 'i': Integer = 1; break;
    X            case 'n': NoNegative = 1; break;
    X            default: errflg++; break;
    X            }
    X    if (errflg)
    X        {
    X        fprintf (stderr, "Usage: %s %s\n", argv[0], usage);
    X        exit (1);
    X        }
    X    return (optind);
    X    }
    X
    Xmain (argc, argv) char **argv;
    X    {
    X    int     status = 0;
    X    int     arg = initial (argc, argv);
    X    char    *string;
    X    while (arg < argc)
    X        {
    X        string = argv[arg++];
    X        if (NoNegative && *string == '-') status++;
    X        else switch (number (string))
    X            {
    X            case IS_NOT:  status++; break;
    X            case IS_REAL: if (Integer) status++; break;
    X            case IS_INT:  break;
    X            default: /* CAN'T HAPPEN */ break;
    X            }
    X        }
    X    exit (status);
    X    }
    X
    X#endif
SHAR_EOF
if test 4039 -ne "`wc -c < 'number.c'`"
then
    echo shar: "error transmitting 'number.c'" '(should have been 4039 characters)'
fi
fi
echo shar: "extracting 'filter.c'" '(4306 characters)'
if test -f 'filter.c'
then
    echo shar: "will not over-write existing file 'filter.c'"
else
sed 's/^    X//' << \SHAR_EOF > 'filter.c'
    X/*
    X    Function:    filter "Filter Command Line Files In Classic UNIX Style"
    X    Created:     Sat Aug 10 21:57:12 EDT 1985
    X    By:          Gary Perlman (Wang Institute, Tyngsboro, MA 01879 USA)
    X    Compilation: nothing unusual
    X    Tester:      $Compile: cc -DSTANDALONE -o filter %f
    X    Preconditions:
    X        The index of the first file operand has been determined.
    X    Postconditions:
    X        All files have been opened, processed, and closed.
    X    Returns:
    X        The return status (non-zero is bad) depends on the accessibility
    X        of files, the ability to open them, and the return statuses of
    X        the called function.
    X    Exceptions:
    X        If any file cannot be accessed, then none will be processed.
    X        During processing, if something goes wrong (a file that could
    X        be accessed cannot be opened, or the file processor returns a
    X        non-zero status), processing continues.
    X    Notes:
    X        "-" is the conventional name for the standard input.
    X            It can only be read once.
    X        Fputs and putc are used to print error messages to avoid
    X            loading fat fprintf just because filter used it.
    X*/
    X
    X
    X#include <stdio.h>
    X
    X#ifdef STANDALONE
    X
    Xint
    Xcat (file, ioptr)
    Xchar    *file;
    Xregister    FILE    *ioptr;
    X    {
    X    register    int     C;
    X    while ((C = getc (ioptr)) != EOF)
    X        putchar (C);
    X    return (0);
    X    }
    X
    Xmain (argc, argv) char **argv;
    X    {
    X    int     cat ();
    X
    X    if (filter (argc, argv, 1, cat))
    X        {
    X        putc ('\007', stderr); /* UNIX friendly error message */
    X        exit (1);
    X        }
    X    exit (0);
    X    }
    X
    X#endif STANDALONE
    X
    X
    X/* LINTLIBRARY */
    Xstatic
    Xvoid
    Xerrmsg (pgm, file, errorno, dflt)
    Xchar    *pgm;       /* name of the program running */
    Xchar    *file;      /* file operand to be mentioned (if any) */
    Xint     errorno;    /* system errno or some bad value */
    Xchar    *dflt;      /* default message for bad error numbers */
    X    {
    X    extern    char *sys_errlist[];  /* list of error messages */
    X    extern    int sys_nerr;         /* number of error messages */
    X
    X    fputs (pgm, stderr);
    X    putc (':', stderr);
    X    putc (' ', stderr);
    X    if (errorno > 0 && errorno < sys_nerr)
    X        fputs (sys_errlist[errorno], stderr);
    X    else
    X        fputs (dflt, stderr);
    X    if (file)
    X        {
    X        putc (' ', stderr);
    X        putc ('\'', stderr);
    X        fputs (file, stderr);
    X        putc ('\'', stderr);
    X        }
    X    putc ('\n', stderr);
    X    }
    X
    X
    X#define    isstdin(file) (file[0] == '-' && file[1] == '\0')
    X
    Xint
    Xfilter (argc, argv, curarg, process)
    Xint     argc;          /* real number of command line args */
    Xchar    **argv;        /* command line argument pointer */
    Xint     curarg;        /* first argv to filter */
    Xint     (*process) (); /* status process (char *name, FILE *ioptr) */
    X    {
    X    int     status = 0;         /* return status of this function */
    X    int     arg;                /* loop index variable */
    X    char    *file;              /* name of the current file */
    X    char    *pgm = argv[0];     /* name of the program */
    X    FILE    *ioptr;             /* file pointer for opening */
    X    int     countstdin = 0;     /* number of times stdin is processed */
    X    extern    int errno;          /* system error number */
    X
    X    if (curarg == argc)
    X        status += ((*process) ("-", stdin));
    X    else
    X        {
    X        /* first check to make sure all files can be opened to read */
    X        for (arg = curarg; arg < argc; arg++)
    X            {
    X            file = argv[arg];
    X            if (isstdin (file))
    X                countstdin++;
    X            else if (access (file, 4))
    X                {
    X                errmsg (pgm, file, errno, "Can't access file");
    X                status++;
    X                }
    X            }
    X        if (countstdin > 1)
    X            {
    X            errmsg (pgm, NULL, -1, "Can only read standard input once");
    X            status++;
    X            }
    X        if (status == 0)
    X            for (arg = curarg; arg < argc; arg++)
    X                {
    X                file = argv[arg];
    X                if (isstdin (file))
    X                    status += ((*process) (file, stdin) != 0);
    X                else if (ioptr = fopen (file, "r"))
    X                    {
    X                    status += ((*process) (file, ioptr) != 0);
    X                    (void) fclose (ioptr);
    X                    }
    X                else
    X                    {
    X                    errmsg (pgm, file, errno, "Can't open file");
    X                    status++;
    X                    }
    X                }
    X        }
    X    return (status);
    X    }
    X
    X/*NOTES
    X    Some modifications might be useful but unpopular:
    X        If there is piped input (!isatty (fileno (stdin))),
    X        and the standard input is not read,
    X        then some information may be ignored,
    X        so a warning should be printed.
    X        Unfortunately, this would break things like vi filters.
    X
    X        If there is not piped input,
    X        and the standard input is being read from the keyboard,
    X        then prompt the user for input with something like:
    X            pgm: reading input from terminal
    X        This would avoid the problem of people forgetting to supply
    X        an input redirection.
    X*/
SHAR_EOF
if test 4306 -ne "`wc -c < 'filter.c'`"
then
    echo shar: "error transmitting 'filter.c'" '(should have been 4306 characters)'
fi
fi
echo shar: "extracting 'getopt.c'" '(3008 characters)'
if test -f 'getopt.c'
then
    echo shar: "will not over-write existing file 'getopt.c'"
else
sed 's/^    X//' << \SHAR_EOF > 'getopt.c'
    X/*
    X    I got this off net.sources from Henry Spencer.
    X    It is a public domain getopt(3) like in System V.
    X    I have made the following modifications:
    X
    X    index(s,c) was added because too many people could
    X    not compile getopt without it.
    X
    X    A test main program was added, ifdeffed by STANDALONE.
    X    This main program is a public domain implementation
    X    of the getopt(1) program like in System V.  The getopt
    X    program can be used to standardize shell option handling.
    X        e.g.  cc -DSTANDALONE getopt.c -o getopt
    X*/
    X#include <stdio.h>
    X
    X#ifndef lint
    Xstatic    char    sccsfid[] = "@(#) getopt.c 5.0 (UTZoo) 1985";
    X#endif
    X
    X#define    ARGCH    (int)':'
    X#define BADCH     (int)'?'
    X#define EMSG     ""
    X#define    ENDARGS  "--"
    X
    X/* this is included because index is not on some UNIX systems */
    Xstatic
    Xchar *
    Xindex (s, c)
    Xregister    char    *s;
    Xregister    int     c;
    X    {
    X    while (*s)
    X        if (c == *s) return (s);
    X        else s++;
    X    return (NULL);
    X    }
    X
    X/*
    X * get option letter from argument vector
    X */
    Xint    opterr = 1,        /* useless, never set or used */
    X    optind = 1,        /* index into parent argv vector */
    X    optopt;            /* character checked for validity */
    Xchar    *optarg;        /* argument associated with option */
    X
    X#define tell(s)    fputs(*nargv,stderr);fputs(s,stderr); \
    X        fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);
    X
    X
    Xgetopt(nargc,nargv,ostr)
    Xint    nargc;
    Xchar    **nargv,
    X    *ostr;
    X{
    X    static char    *place = EMSG;    /* option letter processing */
    X    register char    *oli;        /* option letter list index */
    X    char    *index();
    X
    X    if(!*place) {            /* update scanning pointer */
    X        if(optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) return(EOF);
    X        if (*place == '-') {    /* found "--" */
    X            ++optind;
    X            return(EOF);
    X        }
    X    }                /* option letter okay? */
    X    if ((optopt = (int)*place++) == ARGCH || !(oli = index(ostr,optopt))) {
    X        if(!*place) ++optind;
    X        tell(": illegal option -- ");
    X    }
    X    if (*++oli != ARGCH) {        /* don't need argument */
    X        optarg = NULL;
    X        if (!*place) ++optind;
    X    }
    X    else {                /* need an argument */
    X        if (*place) optarg = place;    /* no white space */
    X        else if (nargc <= ++optind) {    /* no arg */
    X            place = EMSG;
    X            tell(": option requires an argument -- ");
    X        }
    X         else optarg = nargv[optind];    /* white space */
    X        place = EMSG;
    X        ++optind;
    X    }
    X    return(optopt);            /* dump back option letter */
    X}
    X
    X
    X#ifdef STANDALONE
    X
    X#ifndef lint
    Xstatic    char    sccspid[] = "@(#) getopt.c 5.1 (WangInst) 6/15/85";
    X#endif
    X
    Xmain (argc, argv) char **argv;
    X    {
    X    char    *optstring = argv[1];
    X    char    *argv0 = argv[0];
    X    extern    int     optind;
    X    extern    char    *optarg;
    X    int     opterr = 0;
    X    int     C;
    X    char    *opi;
    X    if (argc == 1)
    X        {
    X        fprintf (stderr, "Usage: %s optstring args\n", argv0);
    X        exit (1);
    X        }
    X    argv++;
    X    argc--;
    X    argv[0] = argv0;
    X    while ((C = getopt (argc, argv, optstring)) != EOF)
    X        {
    X        if (C == BADCH) opterr++;
    X        printf ("-%c ", C);
    X        opi = index (optstring, C);
    X        if (opi && opi[1] == ARGCH)
    X            if (optarg)
    X                printf ("\"%s\" ", optarg);
    X            else opterr++;
    X        }
    X    printf ("%s", ENDARGS);
    X    while (optind < argc)
    X        printf (" \"%s\"", argv[optind++]);
    X    putchar ('\n');
    X    exit (opterr);
    X    }
    X
    X#endif
SHAR_EOF
if test 3008 -ne "`wc -c < 'getopt.c'`"
then
    echo shar: "error transmitting 'getopt.c'" '(should have been 3008 characters)'
fi
fi
exit 0
#    End of shell archive