aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/extras/rman
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/extras/rman')
-rw-r--r--nx-X11/extras/rman/ANNOUNCE-rman78
-rw-r--r--nx-X11/extras/rman/CHANGES118
-rw-r--r--nx-X11/extras/rman/MANIFEST25
-rw-r--r--nx-X11/extras/rman/Makefile160
-rw-r--r--nx-X11/extras/rman/README-rman.txt52
-rw-r--r--nx-X11/extras/rman/contrib/README-contrib144
-rw-r--r--nx-X11/extras/rman/contrib/authried.txt36
-rw-r--r--nx-X11/extras/rman/contrib/bennett.txt371
-rw-r--r--nx-X11/extras/rman/contrib/gzip.patch46
-rw-r--r--nx-X11/extras/rman/contrib/hman.cgi7
-rw-r--r--nx-X11/extras/rman/contrib/hman.ksh9
-rw-r--r--nx-X11/extras/rman/contrib/hman.pl261
-rw-r--r--nx-X11/extras/rman/contrib/http-rman.c200
-rw-r--r--nx-X11/extras/rman/contrib/http-rman.html21
-rw-r--r--nx-X11/extras/rman/contrib/lewis.pl17
-rw-r--r--nx-X11/extras/rman/contrib/man2html108
-rw-r--r--nx-X11/extras/rman/contrib/rman_html_split324
-rw-r--r--nx-X11/extras/rman/contrib/rman_html_split.171
-rw-r--r--nx-X11/extras/rman/contrib/sco-wrapper.sh6
-rw-r--r--nx-X11/extras/rman/contrib/sutter.txt155
-rw-r--r--nx-X11/extras/rman/contrib/youki.pl195
-rw-r--r--nx-X11/extras/rman/getopt.c80
-rw-r--r--nx-X11/extras/rman/rman.1273
-rw-r--r--nx-X11/extras/rman/rman.c4974
-rw-r--r--nx-X11/extras/rman/rman.html342
25 files changed, 8073 insertions, 0 deletions
diff --git a/nx-X11/extras/rman/ANNOUNCE-rman b/nx-X11/extras/rman/ANNOUNCE-rman
new file mode 100644
index 000000000..209b843a9
--- /dev/null
+++ b/nx-X11/extras/rman/ANNOUNCE-rman
@@ -0,0 +1,78 @@
+======================================================================
+
+PolyglotMan (nee RosettaMan) is a filter for UNIX manual pages. It
+takes as input man pages for a variety of UNIX flavors and produces as
+output a variety of file formats. Currently PolyglotMan accepts man
+pages from the following flavors of UNIX: Hewlett-Packard HP-UX, AT&T
+System V, SunOS, Sun Solaris, OSF/1, DEC Ultrix, SGI IRIX, Linux, SCO,
+FreeBSD; and produces output for the following formats: printable
+ASCII only (stripping page headers and footers), section and
+subsection headers only, TkMan, [tn]roff, RTF, SGML (soon--I finally
+found a DTD), HTML, MIME, LaTeX, LaTeX 2e, Perl 5's pod. Previously
+<I>PolyglotMan</I> required pages to be formatted by nroff prior to
+its processing; with version 3.0, it prefers [tn]roff source and
+usually can produce results that are better yet.
+
+PolyglotMan improves upon other man page filters in several ways: (1) its
+analysis recognizes the structural pieces of man pages, enabling high
+quality output, (2) its modular structure permits easy augmentation of
+output formats, (3) it accepts man pages formatted with the variant
+macros of many different flavors of UNIX, and (4) it doesn't require
+modification of or cooperation with any other program.
+
+PolyglotMan is a rewrite of TkMan's man page filter, called bs2tk. (If
+you haven't heard about TkMan, a hypertext man page browser, you
+should grab it via anonymous ftp from ftp.cs.berkeley.edu:
+/ucb/people/phelps/tkman.tar.Z.) Whereas bs2tk generated output only for
+TkMan, PolyglotMan generalizes the process so that the analysis can be
+leveraged to new output formats. A single analysis engine recognizes
+section heads, subsection heads, body text, lists, references to other
+man pages, boldface, italics, bold italics, special characters (like
+bullets), tables (to a degree) and strips out page headers and
+footers. The engine sends signals to the selected output functions so
+that an enhancement in the engine improves the quality of output of
+all of them. Output format functions are easy to add, and thus far
+average about about 75 lines of C code each.
+
+A note for HTML consumers: This filter does real (heuristic) parsing--
+no <PRE>! Man page references are turned into hypertext links. The files
+<URL:ftp://ftp.cs.berkeley.edu/ucb/people/phelps/tcltk/sgi-ls.1.html>
+and <URL:ftp://ftp.cs.berkeley.edu/ucb/people/phelps/tcltk/ksh.1.html>
+are examples of the quality of output produced entirely automatically
+(no retouching) by PolyglotMan. These translations were produced by
+PolyglotMan starting with the [tn]roff source (again no retouching).
+Several people have extended World Wide Web servers to format man pages
+on the fly. Check the README file in the contrib directory for a list.
+
+
+CHANGES in 3.0
+
+* [tn]roff source preferred for superior results, when roff macros are
+ sufficiently recognized. Autodetection of source or formatted input.
+* New software license that makes it free for any use
+
+
+CHANGES in 2.5
+
+* SGML output format that adheres to Davenport DocBook v2.3 DTD
+ (NOT READY IN CURRENT VERSION!)
+* MIME output format, for e-mail and Emacs 19.29's enriched mode
+ (Neal Becker)
+* port to Macintosh by Matthias Neeracher
+* list of valid volume names can be given as a parameter (Dag Nygren)
+* updated to LaTeX2e (H. Palme)
+* debugging scaffolding erected (at the end of software's development cycle!)
+
+
+CHANGES in 2.2
+
+* when in SEE ALSO, hyphens would confuse man page-reference finder,
+ so re-linebreak if necessary to eliminate them (!) (Greg Earle & Uri Guttman)
+
+
+CHANGES in 2.1
+
+* gets() replaced by custom code. gets() deprecated since it reads until \0,
+ introducing security problems. (Robert Withrow)
+
+* TkMan module revised for Tk 4.0
diff --git a/nx-X11/extras/rman/CHANGES b/nx-X11/extras/rman/CHANGES
new file mode 100644
index 000000000..9118abad7
--- /dev/null
+++ b/nx-X11/extras/rman/CHANGES
@@ -0,0 +1,118 @@
+1993
+ 1 Apr as bs2tk posted to comp.lang.tcl (126 lines)
+ 2 bullets, change bars, copyright symbol
+ 5 boldface, other SGI nicks
+ 7 skip unrecognized escape codes
+10 small caps
+13 underscores considered uppercase so show up in default small caps font
+ screen out Ultrix junk (code getting pretty tangled now)
+14 until Tk text has better tab support, replace tabs by spaces until get to next tab stop (for Ultrix); -t gives tabstop spacing
+20 Solaris support (Larry Tsui)
+ 3 Jun section subheading parsing (Per-Erik Martin)
+28 hyphenated man pages in SEE ALSO show up correctly in Links (Mike Steele)
+13 Jul under FILES, fully qualified path names are added to Links, but this taken out immediately because not useful
+14 option to keep changebars on right (Warren Jessop)
+ 5 Aug search for header, footer dynamically--no need to edit or search large list of patterns
+11 -m kicks in man page formatting beyond nroff backspace kludges
+27 handle double digit numbers better by trying again relative to end of line
+19 Sep -T gives Tk extras (otherwise ASCII only)
+ -H gives headers only (implies -T off)
+10 Oct -r reverse compiles to [tn]roff source (as Geoff Collyer's nam and fontch, but leveraging existing analysis so only addition of ~60 lines) (The code is device-driver obscure now--obfuscated C contest next.)
+13 header and footer optionally available at bottom in Tk view (Marty Leisner)
+19 "reflected" odd and even page headers&footers zapped
+20 keep count of sections and subsections, using smaller font for larger numbers
+ 1 Nov reverse compiles to Ensemble, except for character ranges
+ 4 started rman rewrite for cleaner support of multiple output targets, including: plain ascii, headers only, TkMan, [nt]roff, Ensemble, SGML, HTML
+ 5 line filtering separated from other logic despite greater sophistication, RosettaMan faster than bs2tk (!)
+28 Dec man page reference recognition (Michael Harrison)
+
+
+1994
+ 1 Jan identify descriptive lists by comparing scnt2 with s_avg
+ 3 tail-end table of contents in HTML documents
+ 5 -f <filter> and LaTeX output mode
+24 proof-of-concept RTF output mode
+26 handle man pages that don't have a header on the first page
+28 parse "handwritten" man pages
+22 Feb alpha version released
+ 6 Mar various bug fixes
+10 beta version released
+13 Jun fixed surious generation on <DL>'s (the existence of which pointed out by David Sibley)
+22 Jul table recognition experiment. works reasonably well, except for tables with centered headers
+ 3 Aug allow for off-by-one (and -two) in identification of header and footer
+ fixed problem with recurrent/leftover text with OSF/1 bold bullets (yeesh)
+12 Sep 2.0gamma released
+13 check for *third* header, possibly centered, possibly after blank lines (Charles Anderson)
+ fixed tag ranges for lines following blank lines (just \n) of pages with global indentation (Owen Rees)
+19 fixed two small problems with LaTeX (^ => \^, \bullet => $\bullet$) (Neal Becker)
+24 simple check for erroneously being fed roff source
+26 deal with bold +- as in ksh (ugh)
+30 2.0delta released
+ 9 Oct special check for OSF to guard against section head interpreted as footer
+ 8 Nov Perl pod output format (result still needs work, but not much)
+ 7 Dec 2.0epsilon released (last one before final 2.0)
+22 Happy Winter Solstice! 2.0 released
+ deprecated gets() replaced (Robert Withrow)
+25 TkMan module's $w.show => $t, saving about 9% in generated characters
+
+
+1995
+ 1 Jan experiment with TkMan output to take advantage of my hack to Tk text (i.e., $t insert end "text" => $t insert end "text1" tag1 "text2" tag2 ...); results => output size reduced about 25%, time reduced about 12-15%
+25 Mar back to old mark command for Tk module
+8 May hyphens in SEE ALSO section would confuse link-finder, so re-linebreak if necessary(!) (Greg Earle & Uri Guttman)
+ 4 Aug put formats and options into tables (inspired by Steve Maguire's Writing Solid Code)
+19 -V accepts colon-separated list of valid volume names (Dag Nygren)
+22 MIME output format that's usable in Emacs 19.29 (just three hours at hacking HTML module) (Neal Becker)
+ 9 Sep nits in HTML and better Solaris code snippets (Drazen Kacar)
+13 Nov Macintosh port by Matthias Neeracher <neeri@iis.ee.ethz.ch>
+18 Dec adapted to LaTeX2e, null manRef yields italicized man ref (H. Palme)
+28 allow long option names (Larry Schwimmer)
+
+
+1996
+22 Jan fixed problem with hyphenation supression and tabs in man page--sheesh! (H. Palme)
+23 May split TkMan format into Tk and TkMan (which calls Tk)
+25 in TkMan format, initial spaces converted to tabs
+24 Sep experiment with formatting from source's macros, for better transcription short of full nroff interpreter
+27 commented out Ensemble output format, which nobody used
+ 2 Oct >4000 lines
+11
+ 8 Nov release 3.0 alpha. source code parsing works well for Solaris, SunOS, HP-UX; in generating HTML
+25 recognize URLs (Mic Campanel)
+
+
+1997
+19 Mar bug fixes, more special characters (roff expert Larry Jones)
+ 8 Aug renamed to PolyglotMan
+ 4 Nov TkMan module: Rebus and NoteMark identification for paragraph lengths and command line options taken over from Tcl (still have search, highlight in Tcl, necessarily) (Chad Loder)
+ >5000 lines, or nearly 40X the lines of code of version 1.0 (which just supported TkMan)
+
+
+1998
+20 Mar automatic detection of Tcl/Tk source (within automatic detection of source; already had within formatted)
+ centralize casifying SH and SS for formatted and source
+ group exception table by category
+17 Apr in source translation, pass along comment lines too
+20 incorporate (RCS) versioning diff's, for HTML
+
+
+2000
+22 Jun eliminate last of encumbered code, release as Open Source
+ release version 3.0.9
+
+
+2002
+24 Aug used in Apple's OS X 10.2 (Jaguar) to convert manual pages for display in Project Builder
+
+
+2003
+28 Mar updated for groff 1.18's new escape codes
+ remove Ensemble output format, which is obsolete
+ remove Texinfo output format, which is not useful
+ HTML tags in lowercase
+ released version 3.1
+ 5 Jun applied Aaron Hawley's patches for DocBook XML
+ 6 Jul assume HTML browsers support full set of entity references
+ discontinue support for Mac OS 9 and earlier (compiles out of the box on OS X)
+25 tags well nested for troff source input (at last!)
+26 release version 3.2
diff --git a/nx-X11/extras/rman/MANIFEST b/nx-X11/extras/rman/MANIFEST
new file mode 100644
index 000000000..b7599bd4a
--- /dev/null
+++ b/nx-X11/extras/rman/MANIFEST
@@ -0,0 +1,25 @@
+gcksum crc length name
+---------- ------ ----
+719617051 139770 rman.c
+3816320114 2260 README-rman.txt
+696804442 4302 Makefile
+2527388467 11935 rman.1
+2005445684 13618 site/rman.html
+1619945447 6260 CHANGES
+3825874035 4647 contrib/README-contrib
+953283015 911 contrib/authried.txt
+641079878 13609 contrib/bennett.txt
+1827405570 1220 contrib/gzip.patch
+4230791356 250 contrib/hman.cgi
+1743159239 359 contrib/hman.ksh
+2919099478 8005 contrib/hman.pl
+1821945783 4978 contrib/http-rman.c
+3091246851 661 contrib/http-rman.html
+2646244070 350 contrib/lewis.pl
+2860919314 2049 contrib/man2html
+1315989744 6596 contrib/rman.pl
+3466647040 7531 contrib/rman_html_split
+75383086 2482 contrib/rman_html_split.1
+2032677288 150 contrib/sco-wrapper.sh
+884546947 3806 contrib/sutter.txt
+3112317992 5086 contrib/youki.pl
diff --git a/nx-X11/extras/rman/Makefile b/nx-X11/extras/rman/Makefile
new file mode 100644
index 000000000..4d65c10f8
--- /dev/null
+++ b/nx-X11/extras/rman/Makefile
@@ -0,0 +1,160 @@
+#
+# Makefile for PolyglotMan
+# It's helpful to read the README-rman.txt file first.
+# You should read over all parts of this file,
+# down to the "you shouldn't modify" line
+#
+# Tom Phelps (phelps@ACM.org)
+#
+
+
+### you need to localize the paths on these lines
+
+# The executable `rman' is placed in BINDIR.
+# If you're also installing TkMan (available separately--see README-rman.txt),
+# this must be a directory that's in your bin PATH.
+# MANDIR holds the man page.
+
+BINDIR = /opt/local/bin
+#BINDIR = /usr/local/bin
+#BINDIR = //C/bin
+MANDIR = /usr/local/man/man1
+# popular alternative
+#BINDIR = /opt/local/bin
+#MANDIR = /opt/local/man/man1
+
+
+### if you have GNU gcc, use these definitions
+CC = gcc
+CFLAGS = -O2 -finline-functions
+
+### if you just have a standard UNIX, use these instead of GNU.
+### CC must be an ANSI C compiler
+
+#CC = cc
+#CFLAGS = -O
+
+# Solaris and SysV people may need this
+#CFLAGS = -O2 -finline-functions
+
+# For HP-UX
+#CC = cc
+#CFLAGS = -Aa -O
+# HP-UX 10.20
+#CFLAGS = -Ae -O
+
+# DEC Alpha and Ultrix, -std1 needed to conform to ANSI C
+#CC = cc
+#CFLAGS = -std1 -O3 -Olimit 1000
+
+
+# list of valid volume numbers and letters
+# you can also set these at runtime with -V
+VOLLIST = "1:2:3:4:5:6:7:8:9:o:l:n:p"
+# SCO Unix has expanded set of volume letters
+#VOLLIST = "1:2:3:4:5:6:7:8:9:o:l:n:p:C:X:S:L:M:F:G:A:H"
+# SGI and UnixWare 2.0
+#VOLLIST = "1:2:3:4:5:6:7:8:9:o:l:n:p:D"
+
+
+# the printf strings used to set the HTML <TITLE> and
+# to set URL hyperlinks to referenced manual pages
+# can be defined at runtime. The defaults are defined below.
+# The first %s parameter is the manual page name,
+# the second the volume/section number.
+# you can set these at runtime with -l and -r, respectively
+
+MANTITLEPRINTF = "%s(%s) manual page"
+# relative link to pregenerated file in same directory
+MANREFPRINTF = "%s.%s"
+# on-the-fly through a cgi-bin script
+#MANREFPRINTF = "/cgi-bin/man2html?%s&%s"
+#MANREFPRINTF = "/cgi-bin/man2html?m=%s&n=%s"
+
+
+# # # these lines are probably fine
+
+CP = cp
+# or you can use GNU's cp and backup files that are about to be overwritten
+#CP = cp -b
+RM = rm
+
+
+#--------------------------------------------------
+#
+# you shouldn't modify anything below here
+#
+#--------------------------------------------------
+
+version = 3.2
+rman = rman-$(version)
+srcs = rman.c
+objs = rman
+defs = -DVOLLIST='$(VOLLIST)' -DMANTITLEPRINTF='$(MANTITLEPRINTF)' -DMANREFPRINTF='$(MANREFPRINTF)'
+libs =
+aux = README-rman.txt Makefile rman.1 site/rman.html CHANGES
+distrib = $(srcs) $(libs) $(aux) contrib
+
+
+all: rman
+ @echo 'Files made in current directory.'
+ @echo 'You should "make install".'
+
+# everyone but me zaps assertions with the -DNDEBUG flag
+rman: rman.c Makefile
+ $(CC) -DNDEBUG $(defs) -DPOLYGLOTMANVERSION=\"$(version)\" $(CFLAGS) -o rman rman.c
+
+
+debug:
+ $(CC) $(defs) -DDEBUG -DPOLYGLOTMANVERSION=\"debug\" -g -Wall -o rman rman.c
+
+prof:
+ quantify -cache-dir=/home/orodruin/h/bair/phelps/spine/rman/cache $(CC) -DNDEBUG $(defs) -DPOLYGLOTMANVERSION=\"QUANTIFY\" -g -o rman rman.c
+
+install: rman
+# $(INSTALL) -s rman $(BINDIR)
+ $(RM) -f $(BINDIR)/rman
+ $(CP) rman $(BINDIR)
+ $(RM) -f $(MANDIR)/rman.1
+ $(CP) rman.1 $(MANDIR)
+
+# test version includes assertions
+# ginstall rman $(BINDIR)/`arch`
+test: rman.c Makefile
+ $(CC) $(defs) -DPOLYGLOTMANVERSION=\"$(version)\" $(CFLAGS) -Wall -ansi -pedantic -o rman rman.c
+ ls -l rman
+ ginstall rman $(BINDIR)
+ rman -v
+ rman --help
+ @echo 'Assertion checks:'
+ rman -f html weirdman/hp-tbl.1 > /dev/null
+ rman -f html weirdman/Pnews.1 > /dev/null
+ nroff -man rman.1 | rman -f html > /dev/null
+
+sww:
+ rm -f rman $(wildcard ~/bin/{sun4,snake,alpha}/rman)
+ rman
+
+clean:
+ rm -f $(objs)
+
+dist:
+ rm -rf $(rman)*
+ mkdir $(rman)
+ $(CP) -RH $(distrib) $(rman)
+# expand -4 rman.c > $(rman)/rman.c
+ rm -f $(rman)/contrib/*~
+ @echo 'gcksum crc length name' > MANIFEST
+ @echo '---------- ------ ----' >> MANIFEST
+ @cksum $(filter-out contrib, $(filter-out %~, $(distrib) $(wildcard contrib/*))) | tee -a MANIFEST
+ mv MANIFEST $(rman)
+ tar chvf $(rman).tar $(rman)
+ gzip -9v $(rman).tar
+ rm -rf $(rman)
+# ANNOUNCE-rman rman.1
+ @echo "*** Did you remember to ci -l first?"
+
+uu: tar
+ gznew $(rman).tar.Z
+ echo 'uudecode, gunzip (from GNU), untar' > $(rman).tar.gz.uu
+ uuencode $(rman).tar.gz $(rman).tar.gz >> $(rman).tar.gz.uu
diff --git a/nx-X11/extras/rman/README-rman.txt b/nx-X11/extras/rman/README-rman.txt
new file mode 100644
index 000000000..4089a5d13
--- /dev/null
+++ b/nx-X11/extras/rman/README-rman.txt
@@ -0,0 +1,52 @@
+The home location for PolyglotMan is polyglotman.sourceforge.net
+
+
+*** INSTALLING ***
+
+Set BINDIR in the Makefile to where you keep your binaries and MANDIR
+to where you keep your man pages (in their source form). (If you're
+using PolyglotMan with TkMan, BINDIR needs to be a component of your
+bin PATH.) After properly editing the Makefile, type `make install'.
+Thereafter (perhaps after a `rehash') type `rman' to invoke PolyglotMan.
+PolyglotMan requires an ANSI C compiler. To compile on a Macintosh
+under MPW, use Makefile.mac.
+
+If you send me bug reports and/or suggestions for new features,
+include the version of PolyglotMan (available by typing `rman -v').
+PolyglotMan doesn't parse every aspect of every man page perfectly, but
+if it blows up spectacularly where it doesn't seem like it should, you
+can send me the man page (or a representative man page if it blows up
+on a class of man pages) in BOTH: (1) [tn]roff source form, from
+.../man/manX and (2) formatted form (as formatted by `nroff -man'),
+uuencoded to preserve the control characters, from .../man/catX.
+
+If you discover a bug and you obtained PolyglotMan at some other site,
+check the home site to see if a newer version has already fixed the problem.
+
+Be sure to look in the contrib directory for WWW server interfaces,
+a batch converter, and a wrapper for SCO.
+
+--------------------------------------------------
+
+*** NOTES ON CURRENT VERSION ***
+
+Help! I'm looking for people to help with the following projects.
+(1) Better RTF output format. The current one works, but could be
+made better. (2) Extending the macro sets for source recognition. If
+you write an output format or otherwise improve PolyglotMan, please
+send in your code so that I may share the wealth in future releases.
+(3) Fixing output for various (accented?) characters in the Latin1
+character set.
+
+--------------------------------------------------
+
+
+License
+
+This software is distributed under the Artistic License (see
+http://www.opensource.org/licenses/artistic-license.html).
+
+(This version of PolyglotMan represents a complete rewrite of bs2tk,
+which was packaged with TkMan in 1993, which is copyrighted by the
+Regents of the University of California, and therefore is not under
+their jurisdiction.)
diff --git a/nx-X11/extras/rman/contrib/README-contrib b/nx-X11/extras/rman/contrib/README-contrib
new file mode 100644
index 000000000..2d6885d91
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/README-contrib
@@ -0,0 +1,144 @@
+This directory contains files contributed by PolyglotMan users. These
+files are not installed, supported or regularly updated to work with
+new versions of PolyglotMan. They are included because some may find
+them useful, and if so they prevent duplication of effort.
+
+--
+
+* sutter.txt - "Edward L. Sutter" <els@sage.sage.att.com>
+
+"...converting "man" directories with their typical sub-directories of
+man1, man2, etc... to an equivalently structured "html" directory with
+the same sub-directory heirarchy."
+
+"I added an option to rman that allows it to search for the files over
+a specified set of directories. This allows (for example) manpages under
+man1 that reference something under man3 to be properly linked."
+
+--
+
+* bennett.txt - Anne Bennett <anne@alcor.concordia.ca>
+
+"... I applied the mods in contrib/sutter.txt, and then amplified
+them. I append the relevant context diffs. In short, I added options
+"-P" (a URL prefix for use with the paths found by "-S"), and "-H" and
+"-F" (header and footer HTML files to help adjust the style of the
+resulting page, for example by adding company logos,
+return-to-home-page buttons, etc.)."
+
+--
+
+* authried.txt - Erwin Authried <eauth@mail4u.atnet.at>
+
+"I wrote a small perl script (it's a quick hack) to view man-pages
+with the web-browser."
+
+--
+
+* gzip.patch - Todd Larason <jtl@molehill.org>
+
+"I keep several manpage hierarchies locally, for easy comparison when
+programming for multiple unix machines, most of which are across a
+relatively slow link. To save disk space, I keep them gzipped.
+
+"Here's a small patch to make .so handling work against gzipped files.
+It's a late-night-after-a-long-day hack, but it seems clean enough. If
+you think there might be any interest, feel free to include it either in
+rman itself or the contrib directory. It's against 3.0a3."
+
+--
+
+* man2html - Marc Donner (donner@fid.morgan.com)
+
+A Korn Shell script that is moderately generic. It takes all the
+files in a directory or a set of directories and does them one at a
+time, putting the html output somewhere appropriate. The only
+infelicity in the script is the stuff with localeo (local electronic
+office) which is a hack put together to tweak the URLs not to refer to
+localhost, which is broken right now, but directly to the local
+server's alias.
+
+---
+
+* sco-wrapper.sh - Dag Nygren <dag@newtech.fi>
+
+SCO puts the names of valid man page sections in the file /etc/default/man.
+This wrapper extracts the names from this file and passes them on to
+PolyglotMan for use in determining man page cross references.
+
+---
+
+* http-rman.{c,html} - Fredrik Lundh <fredrik@kalle.teragon.ivab.se>
+
+An HTTP server using PolyglotMan to produce hypertext renditions of
+man-pages on the fly.
+
+---
+
+* lewis.pl - Herb Lewis <herb@chomps.engr.sgi.com>
+
+CGI bin script written in Perl.
+
+---
+
+* hman.{cgi,ksh,pl} by teto@geocities.com
+A more recent version may be available at http://www.geocities.com/SiliconValley/Lakes/8777/hman.html
+
+ hman.cgi An example of a cgi-bin wrapper to launch hman.pl
+ Ideally, all customization should occur here
+ hman.ksh A stand-alone (non-browser) version of hman.cgi
+ hman.pl The core of the PolyglotMan front-end
+
+"I've written a man to html front-end that appears to have unique features:
+A second attempt to locate related man pages is made if the original
+inquiry fails
+
+"Since PolyglotMan can filter nroff's output or can work with raw
+nroff files, this viewer allows selection of the actual man page
+file. Thus either raw or cooked man pages can be selected directly.
+
+"The program is basic perl, but the implementation allows all customization
+to be embodied in enviroment variables that should be set in a cgi-bin
+wrapper."
+
+--
+
+* youki.pl - Youki Kadobayashi <youki@center.osaka-u.ac.jp>
+
+CGI bin script written in Perl 5, and using CGI.pm
+and thus "it can be accelerated with mod_perl".
+
+---
+
+rman_html_split - Robert Moniot <moniot@fordham.edu>
+rman_html_split.1
+
+Breaks up rman HTML output in file (or standard input) into separate
+section files, placing them into a directory. With manual page.
+
+---
+
+Other converters are not included in this directory, but rather are
+available over the net:
+
+* bsdi-man.pl - Fritz Heinrichmeyer
+
+Available at: http://ES-sun2.fernuni-hagen.de
+
+
+* bbc_man2html - Brooks Cutter (brooks@paradyne.com)
+
+Available at: http://www.stuff.com/~bcutter/home/programs/bbc_man2html.html
+
+
+* rman.pl - Alex Gagin
+
+Available at: http://www.jinr.dubna.su/~gagin/rman.pl.html
+
+(Be aware that the communications link is slow.)
+
+
+* manner.pl - Ray W. Hiltbrand
+
+Available at: ftp://ftp.eng.auburn.edu/pub/rayh/man2html/manner.pl
+
diff --git a/nx-X11/extras/rman/contrib/authried.txt b/nx-X11/extras/rman/contrib/authried.txt
new file mode 100644
index 000000000..7bdbc4023
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/authried.txt
@@ -0,0 +1,36 @@
+#!/usr/local/bin/perl
+
+require "common.pl";
+
+$webmaster="webadmin\@domain";
+$man_path="/usr/local/man:/usr/man:/usr/X11/man:/usr/lib/teTeX/man";
+$manpage_and_section = $ENV{"QUERY_STRING"};
+$rman="/usr/local/bin/rman -f HTML";
+
+($manpage,$section)=split("[&]",$manpage_and_section);
+
+
+ split(":",$man_path);
+ foreach(@_){
+ $file=join("", $_, "/man", $section,"/",$manpage,".",$section);
+
+# printf("try %s\n", $file);
+
+ if (-e $file) {
+ exec "echo Content-Type:text/html; echo; cat $file | $rman";
+ }
+ elsif (-e join("",$file,".gz")){
+ exec "echo Content-Type:text/html; echo; zcat $file | $rman";
+ }
+
+ $file=join("",$file,"x");
+ if (-e $file) {
+ exec "echo Content-Type:text/html; echo; cat $file | $rman";
+ }
+ elsif (-e join("",$file,".gz")){
+ exec "echo Content-Type:text/html; echo; zcat $file | $rman";
+ }
+
+ }
+
+&return_error(500,"man2html error","could not find manual page.");
diff --git a/nx-X11/extras/rman/contrib/bennett.txt b/nx-X11/extras/rman/contrib/bennett.txt
new file mode 100644
index 000000000..116d74d46
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/bennett.txt
@@ -0,0 +1,371 @@
+*** rman.c.original Tue Jul 16 21:19:49 1996
+--- rman.c Tue Aug 27 15:59:38 1996
+***************
+*** 1,5 ****
+--- 1,9 ----
+ static char rcsid[] = "$Header: /cvs/xorg/xc/extras/rman/contrib/bennett.txt,v 1.1.1.4 2004/03/14 08:29:12 eich Exp $";
+
++ /* ELS: SearchDirs by "Edward L. Sutter" <els@sage.sage.att.com> */
++ /* AB: HTMLHeader and HTMLFooter by Anne Bennett <anne@alcor.concordia.ca> */
++ /* AB: SearchDirsPrefix by Anne Bennett <anne@alcor.concordia.ca> */
++
+ /*
+ RosettaMan
+
+***************
+*** 265,271 ****
+--- 269,278 ----
+
+ /*** utility functions ***/
+
++ /* 1996/08/26 Anne Bennett patched */
++ int HrefSearch(char *manname, char *section);
+
++
+ /* case insensitive versions of strcmp and strncmp */
+
+ int
+***************
+*** 1338,1343 ****
+--- 1345,1355 ----
+ char *manTitle = MANTITLEPRINTF;
+ char *manRef = MANREFPRINTF;
+ int fmanRef=1; /* valid man ref? */
++ /* 1996/08/26 Anne Bennett patched */
++ char *SearchDirs=0; /* ELS: added for smarter external reference generator. */
++ char *SearchDirsPrefix=0; /* AB: added for HREF prefix to manpage path. */
++ char *HTMLHeader=0; /* AB: added for HTML header and footer files. */
++ char *HTMLFooter=0; /* AB: added for HTML header and footer files. */
+
+ /*
+ * HTML
+***************
+*** 1349,1354 ****
+--- 1361,1373 ----
+ int i,j;
+ int lasttoc;
+ char *p, *p0;
++ /* 1996/08/26 Anne Bennett patched */
++ /* AB: To support HTMLHeader and HTMLFooter */
++ #define SUB_MANNAME "@@MANPAGE_NAME@@"
++ #define SUB_MANSECT "@@MANPAGE_SECTION@@"
++ #define STRING_SIZE 1024
++ char line[STRING_SIZE];
++ FILE *fp;
+
+ /* always respond to these signals */
+ switch (cmd) {
+***************
+*** 1397,1402 ****
+--- 1416,1474 ----
+ /* better title possible? */
+ printf("<TITLE>"); printf(manTitle, manName, manSect); printf("</TITLE>\n");
+ printf("</HEAD>\n<BODY>\n");
++ /* 1996/08/26 Anne Bennett patched */
++ /* AB: added HTMLHeader file, if -H option is set */
++ if (HTMLHeader) {
++ if ((fp = fopen(HTMLHeader,"r")) == NULL) {
++ fprintf(stderr,"Could not open HTMLHeader file\n");
++ }
++ else {
++ /* Output the header file, replacing strings as needed */
++ while (fgets(line, STRING_SIZE, fp) != (char *)NULL) {
++ char *walker, *found;
++ int i;
++
++ /* replace man section */
++ walker = line;
++ while ( ( found = strstr(walker, SUB_MANSECT) ) != NULL ) {
++ if ( ( strlen(line) + strlen(manSect)
++ - strlen (SUB_MANSECT) ) > sizeof(line) ) {
++ fprintf(stderr,"Cannot substitute %s for %s; "
++ "line would be too long:\n "
++ "%s\n", manSect, SUB_MANSECT, line);
++ walker = found + strlen(SUB_MANSECT);
++ }
++ else {
++ (void) memmove(found+strlen(manSect),
++ found+strlen(SUB_MANSECT),
++ strlen(found+strlen(SUB_MANSECT))+1);
++ memcpy(found, manSect, strlen(manSect));
++ walker = found + strlen(manSect);
++ }
++ }
++ /* replace man name */
++ walker = line;
++ while ( ( found = strstr(walker, SUB_MANNAME) ) != NULL ) {
++ if ( ( strlen(line) + strlen(manName)
++ - strlen (SUB_MANNAME) ) > sizeof(line) ) {
++ fprintf(stderr,"Cannot substitute %s for %s; "
++ "line would be too long:\n "
++ "%s\n", manName, SUB_MANNAME, line);
++ walker = found + strlen(SUB_MANNAME);
++ }
++ else {
++ (void) memmove(found+strlen(manName),
++ found+strlen(SUB_MANNAME),
++ strlen(found+strlen(SUB_MANNAME))+1);
++ memcpy(found, manName, strlen(manName));
++ walker = found + strlen(manName);
++ }
++ }
++ printf("%s", line);
++ }
++ fclose(fp);
++ }
++ }
+ printf("<A HREF=\"#toc\">%s</A><P>\n", TABLEOFCONTENTS);
+ I=0;
+ break;
+***************
+*** 1424,1429 ****
+--- 1496,1514 ----
+ if (lasttoc==BEGINSUBSECTION) printf("</UL>");
+ printf("</UL>\n");
+ }
++ /* 1996/08/26 Anne Bennett patched */
++ /* AB: added HTMLFooter file, if -F option is set */
++ if (HTMLFooter) {
++ if ((fp = fopen(HTMLFooter,"r")) == NULL) {
++ fprintf(stderr,"Could not open HTMLFooter file\n");
++ }
++ else {
++ /* Output the footer file */
++ while (fgets(line, STRING_SIZE, fp) != (char *)NULL)
++ printf("%s", line);
++ fclose(fp);
++ }
++ }
+ printf("</BODY></HTML>\n");
+ break;
+ case BEGINBODY: break;
+***************
+*** 1500,1510 ****
+ *p++='\0'; p0=p;
+ for (; *p && *p!=')'; p++) /* empty */;
+ *p='\0';
+! if (fmanRef) { printf("<A HREF=\""); printf(manRef, hitxt, p0); printf("\">"); }
+ else printf("<I>");
+ break;
+ case ENDMANREF:
+! if (fmanRef) printf("</A>"); else printf("</I>");
+ break;
+
+ case BEGINSC: case ENDSC:
+--- 1585,1604 ----
+ *p++='\0'; p0=p;
+ for (; *p && *p!=')'; p++) /* empty */;
+ *p='\0';
+! /* 1996/08/26 Anne Bennett patched */
+! /* ELS: added a call to HrefSearch() if the -S option is set.. */
+! if (SearchDirs)
+! HrefSearch(hitxt,p0);
+! else if (fmanRef) {
+! printf("<A HREF=\"");
+! printf(manRef, hitxt, p0);
+! printf("\">");
+! }
+ else printf("<I>");
+ break;
+ case ENDMANREF:
+! /* 1996/08/26 Anne Bennett patched */
+! if (fmanRef || SearchDirs) printf("</A>"); else printf("</I>");
+ break;
+
+ case BEGINSC: case ENDSC:
+***************
+*** 2744,2754 ****
+--- 2838,2856 ----
+ extern char *optarg;
+ extern int optind, opterr;
+
++ /* 1996/08/26 Anne Bennett patched */
++ /* ELS: added the -S option: */
++ /* AB: added the -H and -F options */
++ /* AB: added the -P option */
+ char strgetopt[80];
+ /* options with an arg must have a '<' in the description */
+ struct { char letter; int arg; char *longnames; char *desc; } option[] = {
+ { 'f', 1, "filter", " <ASCII|roff|TkMan|Tk|Ensemble|Sections|HTML|SGML|MIME|LaTeX|LaTeX2e|RTF|pod>" },
+ { 'r', 1, "reference:manref:ref", " <man reference printf string>" },
++ { 'S', 1, "searchdirs", " <man reference search directories>" },
++ { 'P', 1, "prefix", " <prefix for manpage paths in -S>" },
++ { 'H', 1, "header", " <HTML header file>" },
++ { 'F', 1, "footer", " <HTML footer file>" },
+ { 'l', 1, "title", " <title printf string>" },
+ { 'b', 0, "subsections:sub", " (show subsections)" },
+ { 'n', 1, "name", "(ame of man page) <string>" },
+***************
+*** 2830,2835 ****
+--- 2932,2953 ----
+ case 'r': manRef = optarg;
+ if (strlen(manRef)==0 || strcmp(manRef,"-")==0 || strcmp(manRef,"off")==0) fmanRef=0;
+ break;
++ /* 1996/08/26 Anne Bennett patched */
++ /* ELS: added the -S option: */
++ /* AB: added the -H and -F options */
++ /* AB: added the -P option */
++ case 'S': SearchDirs = optarg;
++ if (strlen(SearchDirs)==0 ) SearchDirs=0;
++ break;
++ case 'P': SearchDirsPrefix = optarg;
++ if (strlen(SearchDirsPrefix)==0 ) SearchDirsPrefix=0;
++ break;
++ case 'H': HTMLHeader = optarg;
++ if (strlen(HTMLHeader)==0 ) HTMLHeader=0;
++ break;
++ case 'F': HTMLFooter = optarg;
++ if (strlen(HTMLFooter)==0 ) HTMLFooter=0;
++ break;
+ case 't': TabStops=atoi(optarg); break;
+ case 'm': fMan=0; break;
+ case 'T': fTable=1; break;
+***************
+*** 2904,2906 ****
+--- 3022,3126 ----
+ filter();
+ return 0;
+ }
++
++
++ /* 1996/08/26 Anne Bennett patched */
++ /* ELS...
++ HrefSearch():
++ Active only with command line option -S...
++ Called when rman -fHTML has determined that it is going to add a
++ hypertext link. The user tells rman where to search for the hypertext
++ links (local machine search only) and if HrefSearch() finds the file
++
++ SRCHDIR/manname.section
++
++ where
++ SRCHDIR is one of the colon-delimited paths specified with
++ the -S option;
++ manname is the text that rman found preceding a "manname(##)"
++ detection;
++ section is the string within the parens of the manname spec;
++
++
++ then it will use that path to build the HREF line. If not found,
++ then <A> is all that is inserted.
++ This is generally only helpful when you are simply attempting to
++ turn a man directory into an html directory.
++
++ Note that if the first char of SearchDirs is a colon, then if
++ HrefSearch does not find the reference, it defaults to what rman
++ used to do (use manRef, -r option); otherwise, it will not add
++ a hypertext link at all.
++ */
++ int HrefSearch(char *manname, char *section)
++ {
++ char *dir, *colon, tmp;
++ int DefaultToManRef;
++ FILE *fp;
++ static char path[256];
++
++ tmp = 0;
++
++ again:
++ if (SearchDirs[0] == ':') {
++ dir = &SearchDirs[1];
++ DefaultToManRef = 1;
++ }
++ else {
++ dir = SearchDirs;
++ DefaultToManRef = 0;
++ }
++
++ /* Make 2 passes on all search directories... */
++ /* First pass is with the path dir/manname.section */
++ /* Second pass is with the path dir/manname.section[0] */
++ /* This allows the spec manname(3x) to be found as manname.3 */
++ /* just in cast manname.3x doesn't exist. */
++ /* Note that the second pass is only necessary if the section */
++ /* string is more than one character in length. */
++ while(1) {
++ colon = strchr(dir,':');
++ if (colon) *colon = 0;
++ sprintf(path,"%s/%s.%s.html",dir,manname,section);
++ /* 1996/08/26 Anne: read-only, not rw, please. */
++ if ((fp = fopen(path,"r")) != NULL) {
++ printf("<A HREF=\"");
++ /* AB: Put in the manpage location prefix */
++ if (SearchDirsPrefix)
++ printf("%s",SearchDirsPrefix);
++ printf("%s",path);
++ printf("\">");
++ fclose(fp);
++ if (colon) *colon = ':';
++ fprintf(stderr,"HREF @ %s\n",path);
++ return(1);
++ }
++ if (colon) {
++ *colon = ':';
++ dir = colon+1;
++ }
++ else
++ break;
++ }
++ if (section[1]) {
++ tmp = section[1];
++ section[1] = 0;
++ dir = SearchDirs;
++ goto again;
++ }
++ if (tmp)
++ section[1] = tmp;
++
++ /* 1996/08/27 Anne Bennett: use manRef only if set */
++ if (DefaultToManRef && manRef) {
++ printf("<A HREF=\"");
++ printf(manRef, manname, section);
++ printf("\">");
++ }
++ else
++ printf("<A>");
++ return(1);
++ }
++
++ /* End ELS additions. */
++
+*** rman.1.original Tue Jul 16 21:19:49 1996
+--- rman.1 Tue Aug 27 15:16:29 1996
+***************
+*** 75,80 ****
+--- 75,109 ----
+ or `off', then man page references will not be HREFs, just set
+ in italics.
+ .TP 15
++ -S|--searchDirs \fIcolon-separated-directories \fR
++ Valid only with \fI-fHTML \fR, this option modifies the behaviour of
++ rman when inserting a hyperlink to a referenced manpage.
++ The directories indicate where to look
++ for a pre-HTMLized version of the referenced manpage under the name
++ " \fIname \fR. \fIsection \fR. \fIhtml \fR". If the file is not
++ found, no hypertext link is added, except if the first character of
++ the directories list is a colon, in which case a link is added using
++ manRef, ( \fI-r \fR option).
++ .TP 15
++ -P|--prefix \fIstring \fR
++ Valid only with \fI-S \fR, the string indicates what prefix to add to
++ the path when constructing the hyperlink for a referenced manpage.
++ The string will usually be
++ similar to that given with \fI-r \fR, except that there will be no
++ printf-style escapes, for example "http://localhost/manpages".
++ .TP 15
++ -H|--header \fIfilename \fR
++ Valid only with \fI-fHTML \fR, the filename refers to a file
++ containing an HTML "header", which might consist of, for example, a
++ company logo, or body color specifications. If the strings
++ "@@MANPAGE_NAME@@" or "@@MANPAGE_SECTION@@" are found in this file,
++ they are replaced by the appropriate manpage name and section.
++ .TP 15
++ -F|--footer \fIfilename \fR
++ Valid only with \fI-fHTML \fR, the filename refers to a file
++ containing an HTML "footer", which might consist of, for example, a
++ link back to the site's home page.
++ .TP 15
+ -s|section \fI# \fR
+ Set volume (aka section) number of man page (used in roff format).
+ .TP 15
+
diff --git a/nx-X11/extras/rman/contrib/gzip.patch b/nx-X11/extras/rman/contrib/gzip.patch
new file mode 100644
index 000000000..d10666b6a
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/gzip.patch
@@ -0,0 +1,46 @@
+--- rman.c.~1~ Wed Nov 20 13:33:52 1996
++++ rman.c Fri Oct 24 00:10:56 1997
+@@ -3583,6 +3583,43 @@
+ }
+ free(sobuf);
+ }
++ } else {
++#define GZIP "/bin/gzip"
++ char * gz = malloc(strlen(p)+3+1);
++ sprintf(gz, "%s.gz", p);
++ if (stat(gz, &fileinfo)==0) {
++ /* first, figure out how big */
++ char * cmd = malloc(strlen(gz) + strlen(GZIP) + 7 + 1);
++ char buffer[512];
++ unsigned long compr, uncomp;
++ FILE * proc;
++ sprintf(cmd, "%s -l \"%s\"", GZIP, gz);
++ proc = popen(cmd, "r");
++ fgets(buffer, sizeof buffer, proc); /* label line */
++ fgets(buffer, sizeof buffer, proc); /* length line */
++ sscanf(buffer, "%lu %lu", &compr, &uncomp);
++ fclose(proc);
++ /* Boy, don't you wish stat would do that? */
++ sobuf = malloc(uncomp + 1);
++ if (sobuf!=NULL) {
++ /* suck in entire file, as above */
++ sprintf(cmd, "%s -dc \"%s\"", GZIP, gz);
++ proc = popen(cmd, "r");
++ if (proc!=NULL) {
++ if(fread(sobuf, 1, uncomp, proc)) {
++ sobuf[uncomp]='\0';
++ for (q=sobuf; (q=strstr(q," \\}"))!=NULL; q+=3) *q='\n';
++ source_subfile(sobuf);
++ err = 0;
++ }
++ fclose(proc);
++ }
++ free(sobuf);
++ }
++ free(cmd);
++ }
++ free(gz);
++
+ }
+
+ if (err) {
diff --git a/nx-X11/extras/rman/contrib/hman.cgi b/nx-X11/extras/rman/contrib/hman.cgi
new file mode 100644
index 000000000..540899c03
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/hman.cgi
@@ -0,0 +1,7 @@
+#!/bin/ksh
+##########
+export MANPATH=/trane/mach/man:/trane/share/man:/usr/man:/usr/X11/man:/usr/openwin/man:/var/man
+export PATH=/trane/mach/bin:/trane/share/bin:$PATH
+export HMANPRG=rman
+export HMANOPT='-b -f html'
+exec /home/teto/dev/hman/hman.pl
diff --git a/nx-X11/extras/rman/contrib/hman.ksh b/nx-X11/extras/rman/contrib/hman.ksh
new file mode 100644
index 000000000..99df60107
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/hman.ksh
@@ -0,0 +1,9 @@
+#!/bin/ksh
+##########
+export MANPATH=/trane/mach/man:/trane/share/man:/usr/man:/usr/X11/man:/usr/openwin/man:/var/man
+export PATH=/trane/mach/bin:/trane/share/bin:$PATH
+export HMANPRG=rman
+export HMANOPT='-b -f html'
+export QUERY_STRING='DirectPath=/usr/man/cat4.Z/cdf.4'
+export QUERY_STRING='ManTopic=test&ManSection=key'
+perl -d /home/teto/dev/hman/hman.pl
diff --git a/nx-X11/extras/rman/contrib/hman.pl b/nx-X11/extras/rman/contrib/hman.pl
new file mode 100644
index 000000000..099db0417
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/hman.pl
@@ -0,0 +1,261 @@
+#!/usr/bin/perl -w
+#!/citi/gtfd/mach/bin/perl -w
+###############
+# $Id: hman.pl,v 1.1.1.4 2004/03/14 08:29:12 eich Exp $
+# $Source: /cvs/xorg/xc/extras/rman/contrib/hman.pl,v $
+############################################
+# TODO:
+# reorganize location of man pages - move 3x stuff from man3 to man3x
+# recurse - if 'man 3x curses' does not work try 'man 3 curses'
+# display more STDERR
+# Fix broken whatis entries - instead of
+# manpage section - description
+# manpage description section -
+# highlite keywords found
+# pass MANPATH as a command line argument
+############################################
+# Inspired by:
+# http://www.jinr.dubna.su/~gagin
+# http://thsun1.jinr.dubna.su/~gagin/rman.pl
+# http://thsun1.jinr.dubna.su/cgi-bin/rman.pl
+# http://www.jinr.dubna.su/~gagin/rman.pl.html
+#
+# CGI form interface to PolyglotMan program, which is available as
+# ftp://ftp.cs.berkeley.edu:/ucb/people/phelps/tcltk/rman.tar.Z
+#
+# The most recent version of this program available as
+# http://www.geocities.com/SiliconValley/Lakes/8777/hman.html
+#---------------------------------------------------------------------
+# This 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.
+#
+# hman 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 software; see the file COPYING. If not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+#
+# THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
+# CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
+# PERFOHMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
+# NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
+# SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
+# SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
+# PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").
+# ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES
+# IS SPECIFICALLY DISCLAIMED.
+#---------------------------------------------------------------------
+# Request form: hman.pl?ManTopic=SOMETOPIC&ManSection=SECTION
+# Request form: hman.pl?DirectPath=filename
+#
+#---------------------------------------------------------------------
+# Stuff to change
+
+# path to PolyglotMan program. "-b" is not nessesary
+$hman="$ENV{HMANPRG} $ENV{HMANOPT}";
+
+# path to man program
+$ManPrg='/usr/bin/man';
+
+# path to cat program
+$ENV{PAGER} = '/bin/cat';
+
+# path to man directories
+($ManPathFind = $ENV{MANPATH}) =~ s/:/ /g;
+
+# URL to this program
+$hmanpl='/cgi-bin/hman';
+
+# if man produced number of lines less then follows,
+# I assume that request failed
+$emptyman=5;
+
+# tail of every produced html document
+$HtmlTail='<hr><A HREF="' . $hmanpl . '">Back to Hman</a>';
+# $HtmlTitle="<title>CGI form interface to PolyglotMan</title>\n";
+$HtmlHdr="Content-type: text/html\n\n";
+
+# end changable things
+#----------------------------------------------------------------------
+@ManSections = (
+ '1', 'user commands',
+ '2', 'system calls',
+ '3', 'subroutines',
+ '4', 'devices',
+ '5', 'file formats',
+ '6', 'games',
+ '7', 'miscellanious',
+ '8', 'sys. admin.',
+ '9', 'Linux Internals',
+ 'n', 'section n'
+);
+
+# Set unbuffered I/O. Prevents buffering problems with
+# "system()" calls.
+select((select(STDOUT), $| = 1)[0]);
+print $HtmlHdr;
+
+$string = $ENV{QUERY_STRING};
+#
+# Initial Form
+#
+if($string eq "") { initialForm(); }
+
+#
+# Generic parameter parsing ...
+#
+$DirectPath = $ManSection = $ManTopic = "";
+$string =~ s/&/'; \$/g;
+$string =~ s/=/='/g;
+$string =~ s/^(.*)$/\$$1';/;
+eval $string;
+
+hmanDirect($DirectPath) if ($DirectPath ne "");
+
+if ($ManTopic eq "") { badness("<code>Topic for man search needed</code>\n"); }
+
+if ($ManSection eq "") { badness("<code>No section specified</code>\n"); }
+
+$ManSection =~ s/all//;
+if ($ManSection =~ /key/) { manKey($ManTopic); }
+
+findIt($ManTopic);
+open(MANOUT, "$ManPrg $ManSection $ManTopic |")
+ || die "$hmanpl: can't run \"$ManPrg Section $ManTopic |\", $!\n";
+for (0..$emptyman) {
+ $temp = <MANOUT> || last;
+ push @temp, $temp;
+}
+#
+if (@temp < $emptyman) {
+ close(MANOUT);
+ print"<strong>Request failed for topic $ManTopic:</strong>\n<code>";
+ for (@temp) {print;}
+ print "</code><br><h3>Let's try a keyword search:</h3><hr>\n";
+ manKey($ManTopic);
+}
+#
+$cmd = "$hman -r \"$hmanpl?ManTopic=%s&ManSection=%s\" -l \"Man page for $ManTopic";
+if ($ManSection eq "") {
+ $cmd .= '"';
+} else {
+ $cmd .= "($ManSection)\"";
+}
+#
+open(HMANIN, "| $cmd") || die "$hmanpl: can't open $cmd: $!\n";
+for (@temp) {print HMANIN;}
+while(<MANOUT>){print HMANIN;}
+close(MANOUT);
+close(HMANIN);
+
+exitIt();
+###############################################################################
+sub initialForm {
+ print <<EOF;
+<h1>Select a manual page:</h1>
+ <FORM METHOD="GET" action="$hmanpl">
+ <table border=0>
+ <tr>
+ <td align=right>Section:</td>
+ <td>
+ <select name=ManSection>
+ <OPTION value=all>All</option>
+ <OPTION value=key>Keyword Search</option>
+EOF
+ for ($ndx = 0; $ndx < @ManSections; $ndx += 2) {
+ print ' <OPTION value=' . $ManSections[$ndx] . '>'
+ . "$ManSections[$ndx] - $ManSections[$ndx + 1] "
+ . '</option>' . "\n";
+ }
+ print <<EOF;
+ </SELECT>
+ </td>
+ </tr>
+ <tr>
+ <td align=right>Topic:</td>
+ <td><input type="TEXT" name="ManTopic"></td>
+ </tr>
+ <tr>
+ <td align=right><INPUT TYPE="submit" VALUE="Search">
+ <td align=left><input type="reset" value="Reset">
+ </td>
+ </tr>
+ </table>
+ </FORM>
+EOF
+ exitIt();
+}
+sub findIt {
+ my($topic) = ($_[0]);
+ my($cmd, $mixedCase, $navigation, $zcat);
+ $mixedCase = '';
+ foreach (split(/\s*/, $topic)) {
+ $mixedCase .= "[" . $_ . uc($_) . "]";
+ }
+ $cmd = 'find ' . $ManPathFind . ' \( -type f -o -type l \) -name '
+ . $mixedCase .'\* | sort -t. +1';
+ open(FINDIN, "$cmd |") || die "can't open pipe \"$cmd |\": $!";
+ $navigation = 0;
+ while (<FINDIN>) {
+ if ($navigation == 0) {
+ print "<UL>\n";
+ $navigation = 1;
+ }
+ $_ =~ s/[\n\r]*$//;
+ print "<li><A HREF=\"$hmanpl?DirectPath=$_\">$_</a>\n";
+ }
+ close(FINDIN);
+ print "</UL><hr>\n" if ($navigation == 1);
+}
+sub hmanDirect {
+ my($path) = ($_[0], $_[1]);
+ my($cmd, $dir, $topic, $section);
+ ($dir = $path) =~ s/\.(gz|z|Z)$//;
+ ($topic = $dir) =~ s,^.*/,,;
+ $dir =~ s,/[^/]*/[^/]*$,,;
+ # $dir =~ s,/[^/]*$,,;
+ ($section=$topic)=~s/^.*\.([^\.]*)$/$1/;
+ $topic =~ s/\.[^\.]*$//;
+ findIt($topic);
+ $cmd = "cd $dir; (gzip -dc < $path 2>/dev/null || cat < $path) | $hman -r '"
+ . $hmanpl . '?ManTopic=%s&ManSection=%s' ."' -l 'Man page for $topic($section)'";
+ system($cmd) || warn "can't run command \"$cmd\": $!";
+ print $HtmlTail;
+ exit 0;
+}
+sub exitIt {
+ print $HtmlTail;
+ exit 0;
+}
+sub badness {
+ my($text) = ($_[0]);
+ print "<strong>Request failed:</strong> $text, Try again<hr>\n";
+ initialForm();
+}
+sub manKey {
+ my($topic) = ($_[0]);
+ open(TMPHTML,"$ManPrg -k $topic | sort -u |")
+ || die "can't open pipe \"$ManPrg -k $topic | sort -u |\": $!\n";
+ print "<title>Keyword search results for \"$topic\"</title>\n";
+ print "<h1>Keyword search results for \"$topic\"</h1><hr>\n";
+ while(<TMPHTML>) {
+ s/\( \)//g;
+ next if (! /^([^(]+)\s*\(([^)]+)[^-]+-\s(.*)[\n\r]*$/);
+ @topics=split(/, /,$1);
+ next if ($2 eq "");
+ print "<h2>$3:</h2>\n";
+ print "<UL>\n";
+ for $topic (@topics) {
+ print "<li><A HREF=\"$hmanpl?ManSection=$2&ManTopic=$topic\">$topic</a>($2)\n";
+ }
+ print "</UL>\n";
+ }
+ close(TMPHTML);
+ exitIt();
+}
diff --git a/nx-X11/extras/rman/contrib/http-rman.c b/nx-X11/extras/rman/contrib/http-rman.c
new file mode 100644
index 000000000..687a8fc36
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/http-rman.c
@@ -0,0 +1,200 @@
+/* $Id: http-rman.c,v 1.1.1.4 2004/03/14 08:29:12 eich Exp $
+ *
+ * Name:
+ * http-rman.c -- a rudimentary man-page HTTP server
+ *
+ * Description:
+ * This is a minimal HTTP server using RosettaMan by T.A. Phelps
+ * (phelps@ACM.org) to produce hypertext renditions
+ * of man-pages on the fly.
+ *
+ * This server processes URLs with the following syntax:
+ *
+ * [/man] ?<command> [ ?<section> ]
+ *
+ * For URLs matching this format, it pipes the output of
+ * man <section> <command> through rman and sends it to
+ * the HTTP client. For other URLs, it returns the document
+ * given as argv[1] (using cat(1). The leading /man is
+ * optional, but is strongly recommended.
+ *
+ * This server is shipped as two files, the http-rman.c
+ * sources and the http-rman.html sample frontpage. I have
+ * not included a Makefile; you can write your own or just
+ * type [g]cc -o http-rman http-rman.c
+ *
+ * What do I need to run this:
+ * If you don't have it, pick up RosettaMan by anonymous ftp
+ * from ftp.cs.berkeley.edu: /ucb/people/phelps/tcl/rman.tar.Z
+ *
+ * You'll also need an HTTP client such as NCSA Mosaic to talk
+ * to this server. Mosaic is available by anonymous FTP from
+ * ftp://ftp.ncsa.uiuc.edu/Mosaic
+ *
+ * Both RosettaMan (rman) and Mosaic are available from many
+ * other sites. Try Archie, or check your local or national net
+ * archive.
+ *
+ * How do I get it running:
+ * First, compile the server (see above), and install it
+ * somewhere.
+ *
+ * The server runs under inetd(8). Add a service to
+ * /etc/services, say:
+ *
+ * http-rman 4080/tcp
+ *
+ * If you're not about to install another HTTP server on your
+ * machine, you may use the default HTTP port, 80, instead.
+ *
+ * Then add an entry to /etc/inetd.conf, such as (on a single line):
+ *
+ * http-rman stream tcp nowait root /usr/local/bin/http-rman
+ * http-rman /usr/local/lib/rman/http-rman.html
+ *
+ * Change /usr/local/bin and /usr/local/lib/rman to where you
+ * installed the two files. In addition, you may wish to run
+ * the server as something other than root...
+ *
+ * Restart inetd(8) (use kill -HUP or kill it and start it again)
+ * and try the following:
+ *
+ * $ Mosaic http://localhost:4080
+ *
+ * If you don't have Mosaic, try the following instead:
+ *
+ * $ telnet localhost 4080
+ * Trying 127.0.0.1...
+ * Connected to localhost.
+ * Escape character is '^]'.
+ * GET /man?ls <return>
+ * <return>
+ * HTTP/1.0 200 OK
+ * ...
+ *
+ * Portability:
+ * You'll need an ANSI compiler (or an editor and some patience).
+ * As it stands right now, this code has been successfully
+ * compiled on OSF/1 AXP using cc, and on SunOS 4.1 using gcc.
+ * Might need some tuning for other platforms.
+ *
+ * Legal Issues:
+ * Check the external visibility of the http-rman service
+ * you choose. This server gives a user access to ALL man-
+ * pages on your machine. You may have installed copyrighted
+ * software (your operating system, for example) with
+ * man-pages that you are NOT allowed to make visible for
+ * anyone out there...
+ *
+ * History:
+ * 94-04-30 fl: created
+ * 94-05-13 fl: stripped away everything but rman support
+ *
+ * Copyright (c) Fredrik Lundh 1994 (fredrik_lundh@ivab.se)
+ * All rights reserved.
+ */
+
+
+#include <stdio.h> /* printf(), fflush(stdio) etc */
+#include <string.h> /* strrchr(), strcmp() etc */
+
+
+static int
+http_error(int error)
+{
+ char *p;
+
+ switch (error) {
+ case 400:
+ p = "Bad Request";
+ break;
+ case 404:
+ p = "Not Found";
+ break;
+ default:
+ p = "Error";
+ }
+ printf("HTTP/1.0 %d %s\r\n", error, p);
+ printf("MIME-version: 1.0\r\n");
+ printf("Content-Type: text/html\r\n\r\n");
+ printf("<head><title>%d %s</title></head>\r\n", error, p);
+ printf("<body><h1>%d %s</h1></body>\r\n", error, p);
+ return 0;
+}
+
+
+static int
+http_rman(char *url)
+{
+ char *pName;
+ char *pSection;
+ char buf[200];
+
+ /* parse URL: should be /man?command[?section] */
+ pSection = strrchr(url, '?');
+ if (!pSection) {
+ return -1;
+ }
+ pName = pSection-1;
+ *pSection++ = '\0';
+
+ pName = strrchr(url, '?');
+ if (!pName) {
+ pName = pSection;
+ pSection = "";
+ }
+ else
+ pName++;
+
+ sprintf(buf, "man %s %s | rman -r \"man?%%s?%%s\" -n %s -f html",
+ pSection, pName, pName);
+
+ return system(buf);
+}
+
+
+int
+main(int ac, char **av)
+{
+ char buf[200];
+ char url[200];
+ int status;
+ char *sFrontpage = "/usr/local/lib/rman/http-rman.html";
+
+/* check arguments */
+
+ if (ac > 1)
+ sFrontpage = av[1];
+
+/* just read in one line from stdin and make sure it is a GET
+command */
+
+ if (gets(buf)) {
+
+ /* read rest of command (just for the sake of it) */
+ while (gets(url) && url[0] != '\r')
+ ;
+
+ /* command should be GET <url> [HTTP/1.0] */
+ if (sscanf(buf, "GET %s", url) == 1) {
+
+ status = http_rman(url);
+
+ if (status < 0) {
+ sprintf(buf, "cat %s", sFrontpage);
+ if (system(buf) == 0)
+ status = 0;
+ }
+
+ if (status < 0)
+ http_error(404);
+
+ } else
+
+ http_error(400);
+ }
+
+ fflush(stdout);
+
+ exit(0);
+}
diff --git a/nx-X11/extras/rman/contrib/http-rman.html b/nx-X11/extras/rman/contrib/http-rman.html
new file mode 100644
index 000000000..ec4cb5973
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/http-rman.html
@@ -0,0 +1,21 @@
+HTTP/1.0 200 OK
+Server: http-rman 1.0
+MIME-Version: 1.0
+Content-Type: text/html
+Content-Transfer-Encoding: binary
+
+<html>
+<!-- this is a sample frontpage for the http-rman man-page server -->
+<!-- Copyright (c) 1994 Fredrik Lundh (fredrik_lundh@ivab.se) -->
+<head><title>RosettaMan Gateway</title></head>
+<h1>RosettaMan Gateway</h1>
+
+This is a gateway to the man pages on this machine. Please enter the
+function or command you want to know more about.
+<p>
+<isindex>
+<p>
+The hypertext man-pages are generated on the fly using the excellent
+<A HREF="/man?rman">RosettaMan</A> utility by T.A. Phelps. This minimal
+HTTP-server was written by Fredrik Lundh.
+</html>
diff --git a/nx-X11/extras/rman/contrib/lewis.pl b/nx-X11/extras/rman/contrib/lewis.pl
new file mode 100644
index 000000000..116b652c2
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/lewis.pl
@@ -0,0 +1,17 @@
+#!/usr/bin/perl
+
+# Syntax: man2html <topic> <section>
+
+# Print out a content-type for HTTP/1.0 compatibility
+print "Content-type: text/html\n\n";
+
+if( $ENV{'REQUEST_METHOD'} eq "GET" )
+{
+ $buffer=$ENV{'QUERY_STRING'} ;
+ @ARGV = split(/&/,$buffer) ;
+}
+
+@manpage = `man @ARGV[1] @ARGV[0] | rman -f html -n @ARGV[0] -s
+@ARGV[1]`;
+
+print "@manpage";
diff --git a/nx-X11/extras/rman/contrib/man2html b/nx-X11/extras/rman/contrib/man2html
new file mode 100644
index 000000000..3df77a3a8
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/man2html
@@ -0,0 +1,108 @@
+#!/bin/ksh
+
+# Take a man tree and make an html tree out of it
+
+DOMAIN=$(domainname)
+ARCH=$(arch)
+
+case ${DOMAIN} in
+ acf) localeo=reo1 ;;
+ bwfid) localeo=reo1 ;;
+ chfid) localeo=neo1 ;;
+ hkfid) localeo=teo1 ;;
+ lnfid) localeo=leo1 ;;
+ nyfid) localeo=neo1 ;;
+ psfid) localeo=leo1 ;;
+ sffid) localeo=neo1 ;;
+ tkfid) localeo=teo1 ;;
+ esac
+
+sections="{1,2,3,4,5,6,7,8}"
+from=/usr/man
+to=/u/eo/repository/system/unix/man
+
+function disambiguate
+{
+newbase=${1}
+newname="${newbase}.1"
+dis=2
+while [ -a "${newname}" ]
+ do
+ newname=$newbase"."$dis
+ dis=$(expr $dis + 1)
+ done
+}
+
+while getopts f:t:l:is:v c
+ do
+ case $c in
+ f) from=$OPTARG ;;
+ t) to=$OPTARG ;;
+ l) localeo=$OPTARG ;;
+ i) indexonly=1 ;;
+ s) sections=$OPTARG ;;
+ v) verbose=1 ;;
+ esac
+ done
+shift OPTIND-1
+
+if [ "${verbose}" ]
+ then
+ print "from: $from"
+ print "to: $to"
+ print "localeo: $localeo"
+ print "sections: $sections"
+ if [ "${indexonly}" ]
+ then
+ print "indexonly: 1"
+ fi
+ fi
+
+cd $from
+
+if [ ! "${indexonly}" ]
+ then
+ print "Processing the man pages ..."
+ for i in man${sections}/*
+ do
+ if [ "$verbose" ]
+ then
+ print $i
+ fi
+ # n=${i%.*}
+ name=${to}/${i}
+ if [ -a "${name}" ]
+ then
+ oldname=$name
+ disambiguate $name
+ name=$newname
+ print "Collision - ${oldname} will be stored as ${name}"
+ fi
+ eqn $i | tbl | nroff -man | rman -f HTML | sed -e "s/MS_LOCAL_HOST/${localeo}/g" > ${name}
+ done
+ fi
+
+print "Building the index.html files ..."
+cd $to
+for i in man${sections}
+ do
+ if [ "$verbose" ]
+ then
+ print $i
+ fi
+ cd $i
+ rm -f index.html
+ echo '<ul>' > ../new.html
+ for j in *
+ do
+ if [ "$verbose" ]
+ then
+ print -n "$j "
+ fi
+ print
+ print "<li> <a href=$j>$j</a>" >> ../new.html
+ done
+ echo '</ul>' >> ../new.html
+ mv ../new.html index.html
+ cd ..
+ done
diff --git a/nx-X11/extras/rman/contrib/rman_html_split b/nx-X11/extras/rman/contrib/rman_html_split
new file mode 100644
index 000000000..aafb023c5
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/rman_html_split
@@ -0,0 +1,324 @@
+#!/bin/sh
+#
+# Script to break up rman html output into separate sections in a directory.
+#
+# Author: Robert Moniot <moniot@fordham.edu>
+# Date: 4 Aug 1998
+#
+
+version="rman_html_split V1.0 (c) 1998 Robert K. Moniot"
+
+ # Usage function prints synopsis and exits
+Usage(){
+ myname=`echo $0 | sed -e 's,.*/,,'`
+cat <<EOF
+
+Usage: $myname [ options ] [ file ]
+
+Breaks up rman HTML output in file (or standard input) into separate
+section files, placing them into a directory.
+
+Options:
+ -d | --html-dir dir Place output into directory dir (default = html).
+ -m | --merge # Merge sections 0 thru # (default 1) into one file.
+ -t | --toc-first Link index.html to table of contents instead
+ of to sect0.html.
+ -T | --title "title" Use "title" as title on top of each page
+ instead of rman's title. "title" may be empty.
+ -h | --help Print synopsis and exit.
+ -V | --version Print version information and exit.
+EOF
+ exit 0
+}
+
+ # Version function prints version number and exits
+Version(){
+ echo "$version"
+ exit 0
+}
+
+ # This function puts out header needed by all but 1st page.
+do_header(){
+cat <<EOF
+<HTML>
+<HEAD>
+<TITLE>$*</TITLE>
+</HEAD>
+<BODY>
+EOF
+do_title
+}
+
+ # This function puts out the title with name of manpage
+do_title(){
+ if [ -n "$title" ]
+ then
+ echo "<H2>$title</H2>"
+ fi
+}
+
+ # This function puts out ref to table of contents that
+ # follows header for all but 1st and toc page.
+do_href_toc(){
+cat <<EOF
+<A HREF="toc.html">Table of Contents</A><P>
+EOF
+}
+
+ # This function puts out ref to previous section
+do_href_prev(){
+ echo "<P>Previous: <A HREF=\"$1.html\">$2</A><HR><P>"
+}
+
+ # This function puts out footer needed by all but last page.
+do_footer(){
+cat <<EOF
+</BODY></HTML>
+EOF
+}
+
+ # This function changes the trailing NAME anchor
+ # of a section into an href to the next section.
+ # The first edit is for sections. The second edit
+ # handles the toc anchor, which has no href and so
+ # is missed by the first edit.
+do_href_next(){
+ sed -e '$s,^.*<A NAME="\([^"]*\)" HREF=[^>]*>\([^<]*\).*$,<P><HR><P>Next: <A HREF="\1.html">\2</A>,' \
+ -e '$s,<A NAME="\(toc[^"]*\)",Next: <A HREF="\1.html",'
+}
+
+ # This function adapts internal refs from one-big-file
+ # form into multi-file format.
+ # First edit changes "#tocn" into "toc.html#tocn"
+ # Second edit changes "#sectn" into "sectn.html#sectn"
+ # Third edit changes "#toc" into "toc.html"
+change_hrefs(){
+ sed -e 's,HREF="#toc\([0-9][0-9]*\)",HREF="toc.html#toc\1",g' \
+ -e 's,HREF="#sect\([0-9][0-9]*\)",HREF="sect\1.html#sect\1",g' \
+ -e 's,HREF="#\(toc\)",HREF="\1.html",g'
+}
+
+
+# Execution begins here.
+
+ # Process the command-line options.
+htmldir="html"
+mergesect="1"
+
+while [ $# != 0 ]
+do
+ case $1 in
+
+ -d | --html-dir)
+ shift
+ if [ $# != 0 ]
+ then
+ htmldir="$1"
+ shift
+ fi
+ ;;
+
+ -m | --merge)
+ shift
+ if [ $# != 0 ]
+ then
+ mergesect="$1"
+ shift
+ fi
+ case $mergesect in
+ [0-9])
+ ;;
+ *)
+ echo "ERROR: merge section must be a digit from 0 to 9."
+ Usage
+ ;;
+ esac
+ ;;
+
+ -t | --toc-first)
+ shift
+ tocfirst="t"
+ ;;
+
+ -T | --title)
+ shift
+ if [ $# != 0 ]
+ then
+ title="$1"
+ shift
+ fi
+ if [ -z "$title" ] # If title is the null string, set notitle
+ then
+ notitle="t"
+ fi
+ ;;
+
+ -h | --help)
+ Usage
+ ;;
+
+ -V | --version)
+ Version
+ ;;
+
+ # Unrecognized flag.
+ -*)
+ echo "Unrecognized option: $1"
+ Usage
+ ;;
+
+ # Non-flag: go to process file.
+ *)
+ break
+ ;;
+ esac
+done
+
+ # At this point we should have at most one
+ # argument, the file name. Check it.
+if [ $# -gt 1 ]
+then
+ Usage
+fi
+
+if [ $# = 1 ]
+then
+ if [ ! -r "$1" ]
+ then
+ echo "ERROR: Cannot open file $1."
+ exit 1
+ fi
+fi
+
+ # Filter the input (file arg or stdin) thru a sed script
+ # that fixes cases where an anchor for a section has
+ # had its section title split across two or more lines.
+ # Put the result in a tmp file so it can be re-read.
+
+filename="/tmp/rman_html_split_$$.html"
+trap "rm -f $filename" 0
+sed -e ':top' \
+ -e '/^<H[1-9]><A NAME="sect.*[^>]$/N' \
+ -e '/^<LI><A NAME="toc.*[^>]$/N' \
+ -e 's/\n/ /' \
+ -e 't top' $1 > $filename
+
+ # If user did not supply title, get title for top of
+ # each page from rman-generated <TITLE> line. If user
+ # gave a blank title then leave it blank.
+if [ -z "$title" -a -z "$notitle" ]
+then
+ title=`sed -e '/^<TITLE>/q' $filename |
+ sed -n -e 's,^<TITLE>\([^<]*\).*$,\1,p'`
+fi
+
+ # Get a list of all the sections. Separate it into a
+ # list of merged sections and a list of all other sections.
+ # Merged sects are combined and get special treatment besides.
+allsects=`sed -n 's,^.*<A NAME="\(sect[0-9][0-9]*\)".*$,\1,p' $filename`
+
+mergesects=`echo $allsects | \
+ awk '{for(i=1; i<=NF && i<'"$mergesect"+2'; i++) print \$i;}'`
+
+sectlist=`echo $allsects |
+ awk '{for(i='"$mergesect"'+2; i<=NF; i++) print \$i;}'`
+
+
+# This little bit, copied from GNU configure, sets ac_n and ac_c such
+# that echo $ac_n "stuff $ac_c" yields "stuff " w/o following newline.
+if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
+ # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
+ if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
+ ac_n= ac_c='
+' ac_t=' '
+ else
+ ac_n=-n ac_c= ac_t=
+ fi
+else
+ ac_n= ac_c='\c' ac_t=
+fi
+
+ # Create html directory if it does not exist.
+if [ -d $htmldir ]
+then
+ echo "Re-using directory $htmldir."
+else
+ echo "Creating directory $htmldir..."
+ if mkdir $htmldir
+ then
+ true
+ else
+ echo "Failed!"
+ exit 1
+ fi
+fi
+
+echo "Creating section pages..."
+
+ # Produce index page. It is special, since it combines
+ # merged sections and uses the rman-generated header.
+nextsect=`echo $sectlist | awk '{print $1;}'`
+echo $ac_n $mergesects "$ac_c"
+(do_title ;
+ sed -n -e "1,/^<H[23]><A NAME=\"$nextsect\"/p" $filename | \
+ do_href_next | \
+ change_hrefs ;
+ do_footer) > $htmldir/sect0.html
+
+ # Produce pages for all other sections except toc.
+prevsect="sect$mergesect"
+prevtext=`sed -n 's,^<H[23]><A NAME="'$prevsect'" HREF="#toc[0-9][0-9]*">\([^<]*\).*$,\1,p' $filename | sed -e 's/ *$//'`
+for sect in $sectlist;
+do
+ echo $ac_n "$sect $ac_c"
+ headtext=`sed -n 's,^<H[23]><A NAME="'$sect'" HREF="#toc[0-9][0-9]*">\([^<]*\).*$,\1,p' $filename | sed -e 's/ *$//'`
+ (do_header $headtext ;
+ do_href_toc ;
+ do_href_prev "$prevsect" "$prevtext" ;
+ sed -n -e '/<A NAME="'$sect'"/,/<A NAME=/p' $filename |
+ do_href_next |
+ change_hrefs ;
+ do_footer) > $htmldir/$sect.html
+ prevsect="$sect"
+ prevtext="$headtext"
+done
+
+
+ # Produce table of contents
+echo "toc"
+(do_header Table of Contents ;
+ sed -n -e '/<A NAME="toc">/,$p' $filename | \
+ change_hrefs ;
+) > $htmldir/toc.html
+
+
+ # Finally, make sure the symlinks index.html and
+ # sect1.html -> sect0.html are in place, and if not,
+ # create them. If --tocfirst is not specified, then
+ # link index.html to section 0, otherwise link it to
+ # index.html
+
+echo "Doing symlinks..."
+cd $htmldir
+
+rm -f index.html
+if [ -z "$tocfirst" ]
+then
+ echo "Linking index.html -> sect0.html"
+ ln -s sect0.html index.html
+else
+ echo "Linking index.html -> toc.html"
+ ln -s toc.html index.html
+fi
+
+for sect in $mergesects
+do
+ if [ "$sect" != "sect0" ]
+ then
+ echo "Linking $sect.html -> sect0.html"
+ rm -f $sect.html
+ ln -fs sect0.html $sect.html
+ fi
+done
+
+echo "Done."
diff --git a/nx-X11/extras/rman/contrib/rman_html_split.1 b/nx-X11/extras/rman/contrib/rman_html_split.1
new file mode 100644
index 000000000..5d3cb4d59
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/rman_html_split.1
@@ -0,0 +1,71 @@
+.TH rman_html_split 1 "4 Aug 1998"
+.SH NAME
+rman_html_split \- split rman html output into separate sections
+.SH SYNOPSIS
+.B rman_html_split
+[
+.I options
+] [
+.I file
+]
+.SH DESCRIPTION
+The \fBrman_html_split\fP script reads a file containing HTML produced
+from a manual page by the \fBrman\fP(1) program, and splits it into a
+set of files, each containing one section or subsection of the manual.
+Each section file has added to it an optional header identifying the
+program described by the manual page, a link to the table of contents,
+and links to the previous section and the next section. The separate
+section files are placed in a subdirectory. A symbolic link named
+\fIindex.\|html\fP is created in this subdirectory, linked to either
+\fIsect0.\|html\fP (the first section) or \fItoc.\|html\fP (the table
+of contents section).
+.PP
+Use this script to split a large manual page into smaller, more
+manageable parts for use as online web-based documentation.
+.SH OPTIONS
+.TP
+.BR "\-d \fIdir\fP" " | " "\-\-html\-dir \fIdir\fP"
+Place output into directory \fIdir\fP. The default directory name is
+\fIhtml\fP.
+.TP
+.BR "\-m \fInum\fP" " | " "\-\-merge \fInum\fP"
+Merge sections 0 thru \fInum\fP into one file. The default for
+\fInum\fP is 1, since usually section 0 is the NAME section and
+section 1 is SYNOPSIS, which are usually both short and go well
+together. Set
+.I num
+to 0 to prevent merging, or set it to a larger number to merge more
+initial sections. Maximum value of \fInum\fP is 9. There is no
+provision for merging sections other than consecutive numbers from
+section 0.
+.TP
+.BR \-t " | " \-\-toc\-first
+Link \fIindex.\|html\fP to the table of contents. By default, it is
+linked to \fIsect0.\|html\fP. Use this if you prefer the initial page
+to be the table of contents rather than the first section of the
+manual page.
+.TP
+.BR "\-T \fItitle\fP" " | " "\-\-title \fItitle\fP"
+Use \fItitle\fP as a header on top of each page. This header is
+displayed using the H2 HTML tag. By default, \fBrman_html_split\fP uses
+the title generated by \fBrman\fP. By making \fItitle\fP the empty
+string (""), the header can be suppressed entirely.
+.TP
+.BR \-h " | " \-\-help
+Print synopsis and exit.
+.TP
+.BR \-V " | " \-\-version
+Print version information and exit.
+.SH SEE ALSO
+.BR man (1),
+.BR rman (1).
+.SH BUGS
+You tell me.
+.SH AUTHOR
+Robert K. Moniot <moniot@fordham.edu>
+.br
+Fordham University
+.br
+Department of Computer and Information Sciences
+.br
+New York, NY
diff --git a/nx-X11/extras/rman/contrib/sco-wrapper.sh b/nx-X11/extras/rman/contrib/sco-wrapper.sh
new file mode 100644
index 000000000..95d7610ed
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/sco-wrapper.sh
@@ -0,0 +1,6 @@
+#
+REALRMAN=/usr/local/bin/rman.real
+VOLLISTFILE=/etc/default/man
+
+VOLLIST=`grep '^ORDER' $VOLLISTFILE | cut -f2 -d=`
+exec $REALRMAN -V "=$VOLLIST" $*
diff --git a/nx-X11/extras/rman/contrib/sutter.txt b/nx-X11/extras/rman/contrib/sutter.txt
new file mode 100644
index 000000000..b467bb348
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/sutter.txt
@@ -0,0 +1,155 @@
+"Edward L. Sutter" <els@sage.sage.att.com>
+
+Perhaps there is already a better way to do this, but since I couldn'd find
+one, I'd like to make a suggestion that has helped me quite a bit for getting
+the proper hypertext links. Keep in mind that this is under the context of
+me converting "man" directories with their typical sub-directories of
+man1, man2, etc... to an equivalently structured "html" directory with
+the same sub-directory heirarchy.
+
+I added an option to rman that allows it to search for the files over
+a specified set of directories. This allows (for example) manpages under
+man1 that reference something under man3 to be properly linked.
+
+rman.c v2.4 ...
+
+...
+
+/* ELS: added to support a smarter external reference generator. */
+char *SearchDirs=0;
+int HrefSearch();
+
+...
+
+/* ELS: added the -S option: */
+ while ((c=getopt(argc,argv,"Kh?f:l:r:bckmTpvn:t:s:yS:"))!=-1)
+ switch (c) {
+ case 'k': fHeadfoot=1; break;
+ case 'b': fSubsections=1; break;
+ case 'c': fChangeleft=1; break;
+ case 'S': SearchDirs=optarg; break;
+
+
+...
+
+
+void
+HTML(enum command cmd) {
+
+...
+
+
+ case BEGINMANREF:
+ for (p=hitxt; *p && *p!='('; p++) /* empty */;
+ *p++='\0'; p0=p;
+ for (; *p && *p!=')'; p++) /* empty */;
+ *p='\0';
+/* ELS: added a call to HrefSearch() if the -S option is set.. */
+ if (SearchDirs)
+ HrefSearch(hitxt,p0);
+ else {
+ printf("<A HREF=\"");
+ printf(manRef, hitxt, p0);
+ printf("\">");
+ }
+ break;
+
+
+...
+
+
+/* ELS...
+ HrefSearch():
+ Active only with command line option -S...
+ Called when rman -fHTML has determined that it is going to add a
+ hypertext link. The user tells rman where to search for the hypertext
+ links (local machine search only) and if HrefSearch() finds the file
+
+ SRCHDIR/manname.section
+
+ where
+ SRCHDIR is one of the colon-delimited paths specified with
+ the -S option;
+ manname is the text that rman found preceding a "manname(##)"
+ detection;
+ section is the string within the parens of the manname spec;
+
+
+ then it will use that path to build the HREF line. If not found,
+ then <A> is all that is inserted.
+ This is generally only helpful when you are simply attempting to
+ turn a man directory into an html directory.
+
+ Note that if the first char of SearchDirs is a colon, then if
+ HrefSearch does not find the reference, it defaults to what rman
+ used to do (use manRef, -r option); otherwise, it will not add
+ a hypertext link at all.
+*/
+HrefSearch(manname,section)
+char *manname, *section;
+{
+ char *dir, *colon, tmp;
+ int DefaultToManRef;
+ FILE *fp;
+ static char path[256];
+
+ tmp = 0;
+
+again:
+ if (SearchDirs[0] == ':') {
+ dir = &SearchDirs[1];
+ DefaultToManRef = 1;
+ }
+ else {
+ dir = SearchDirs;
+ DefaultToManRef = 0;
+ }
+
+ /* Make 2 passes on all search directories... */
+ /* First pass is with the path dir/manname.section */
+ /* Second pass is with the path dir/manname.section[0] */
+ /* This allows the spec manname(3x) to be found as manname.3 */
+ /* just in cast manname.3x doesn't exist. */
+ /* Note that the second pass is only necessary if the section */
+ /* string is more than one character in length. */
+ while(1) {
+ colon = strchr(dir,':');
+ if (colon) *colon = 0;
+ sprintf(path,"%s/%s.%s.html",dir,manname,section);
+ if ((fp = fopen(path,"rw")) != NULL) {
+ printf("<A HREF=\"");
+ printf("%s",path);
+ printf("\">");
+ fclose(fp);
+ if (colon) *colon = ':';
+ fprintf(stderr,"HREF @ %s\n",path);
+ return(1);
+ }
+ if (colon) {
+ *colon = ':';
+ dir = colon+1;
+ }
+ else
+ break;
+ }
+ if (section[1]) {
+ tmp = section[1];
+ section[1] = 0;
+ dir = SearchDirs;
+ goto again;
+ }
+ if (tmp)
+ section[1] = tmp;
+
+ if (DefaultToManRef) {
+ printf("<A HREF=\"");
+ printf(manRef, manname, section);
+ printf("\">");
+ }
+ else
+ printf("<A>");
+ return(1);
+}
+
+/* End ELS additions. */
+
diff --git a/nx-X11/extras/rman/contrib/youki.pl b/nx-X11/extras/rman/contrib/youki.pl
new file mode 100644
index 000000000..8af5865d6
--- /dev/null
+++ b/nx-X11/extras/rman/contrib/youki.pl
@@ -0,0 +1,195 @@
+#!/usr/local/bin/perl5
+#
+# CGI script for translating manpage into html on the fly.
+# Front-end for PolyglotMan (formerly called RosettaMan)
+#
+# Author: Youki Kadobayashi <youki@center.osaka-u.ac.jp>
+#
+# NOTE: Replace 'CGI::Apache' with just 'CGI' for systems without mod_perl.
+#
+# ALSO: You may want to recompile rman like this:
+# MANREFPRINTF = "/mod-bin/cgi-rman.pl?keyword=%s&section=%s"
+#
+
+use CGI::Apache font; # for people with mod_perl and apache
+## use CGI font; # for people without mod_perl
+$par = "<P>\n";
+$brk = "<BR>\n";
+$bg = '#c0ffff';
+
+$query = new CGI::Apache; # for people with mod_perl and apache
+## $query = new CGI; # for people without mod_perl
+
+%mandatory = ('keyword' => 'Name or keyword',
+ 'section' => 'Manual page section');
+
+@given = $query->param;
+if ($#given < 0) {
+ &request_page;
+ exit 0;
+}
+
+foreach $field (keys %mandatory) {
+ if ($query->param($field) eq '') {
+ push(@missing, $mandatory{$field});
+ }
+}
+if ($#missing >= 0) {
+ &info_missing_page(@missing);
+} else {
+ if ($query->param('type') eq 'apropos') {
+ &apropos_page;
+ } else {
+ &manual_page;
+ }
+}
+exit 0;
+
+sub standout {
+ my ($level, $color, $string) = @_;
+
+ # As per CGI.pm documentation "Generating new HTML tags"
+ return $query->font({color => "$color"}, "<$level>$string</$level>");
+}
+
+sub error_page {
+ my ($message) = @_;
+
+# print $query->header,
+# $query->start_html(-title=>$message, -BGCOLOR=>$bg);
+
+ print &standout("H2", "brown", $message),
+ "The above error occured during the manual page generation",
+ " process. Please check keyword and section number,",
+ " then try again.", $par;
+
+# print $query->end_html;
+}
+
+sub info_missing_page {
+ my (@missing) = @_;
+
+ print $query->header,
+ $query->start_html(-title=>"Information is missing",
+ -BGCOLOR=>$bg);
+
+ print &standout("H2", "brown", "Information is missing"),
+ "Sorry but your request was not fulfilled because",
+ " the following information is missing in your entry:", $par,
+ join(' ', @missing), $par,
+ "Please go back and make sure to enter data on the missing field.";
+
+ print $query->end_html;
+}
+
+sub request_page {
+ print $query->header,
+ $query->start_html(-title=>'Hypertext Manual Page',
+ -author=>'Youki Kadobayashi',
+ -BGCOLOR=>$bg);
+
+ print &standout("H2", "green", "Hypertext Manual Page");
+
+ print $query->start_form,
+ "Type of Search: ",
+ $query->radio_group(-name=>'type',
+ -values=>['man', 'apropos'],
+ -default=>'man'), $brk,
+ "Name or Keyword: ",
+ $query->textfield(-name=>'keyword'), $brk,
+ "Manpage Section: ",
+ $query->popup_menu(-name=>'section',
+ -labels=>{
+ 0 => 'All Sections',
+ 1 => '1 - General Commands',
+ 2 => '2 - System Calls',
+ 3 => '3 - Library Functions',
+ 4 => '4 - Device Special Files',
+ 5 => '5 - File Formats',
+ 6 => '6 - Games',
+ 7 => '7 - Macros and Conventions',
+ 8 => '8 - System Administration',
+ 'pgsql' => 'PostgreSQL',
+ 'tcl' => 'Tcl/Tk',
+ 'mh' => 'Message Handler',
+ 'isode' => 'ISODE',
+ 'X11' => 'X Window System'},
+ -values=>[0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 'pgsql', 'tcl', 'mh',
+ 'isode', 'X11'],
+ -default=>0), $brk;
+
+ print $query->submit(-name=>'Submit'), $query->reset,
+ $query->end_form, $par;
+
+ print $query->end_html;
+}
+
+sub manual_page {
+ my $keyword = $query->param('keyword');
+ my $section = $query->param('section');
+ my $man = "man";
+ my $ok = "-a-zA-Z0-9._";
+
+ # sanitize for security
+ $section =~ s/[^$ok]+/_/go;
+ $keyword =~ s/[^$ok]+/_/go;
+
+ if ($section =~ /^[A-Za-z]/) {
+ $man .= " -M$section";
+ }
+ elsif ($section =~ /^\d/) {
+ $section =~ s/^(\d)\w*/\1/go;
+ $man .= " -s $section";
+ }
+ $man .= ' ' . $keyword;
+ open (MAN, "$man | /usr/local/bin/rman -f html -n $keyword -s $section |");
+
+ print $query->header;
+ # start_html and end_html not needed here, since rman tacks them.
+ print "<!-- text generated with '$man' by cgi-rman.pl -->\n";
+ while (<MAN>) {
+ print $_;
+ }
+ if ($? != 0 || $. < 15) {
+ &error_page("Your request for manual page '$keyword' failed.");
+# print "return code $? line $.\n";
+ close(MAN);
+ return;
+ }
+ close(MAN);
+}
+
+sub apropos_page {
+ my $keyword = $query->param('keyword');
+ my $section = $query->param('section'); # igored
+ my $man = "man -k";
+ my $matches = 0;
+
+ $man .= ' ' . $keyword;
+ open (MAN, "$man |");
+
+ $url = $query->url;
+ print $query->header, $query->start_html(-title=>$man);
+
+ while (<MAN>) {
+ if (/^([a-zA-Z0-9_.-]+)[, ][a-zA-Z0-9_., -]*\((\d)\w*\)/) {
+ print $`, qq{ <A HREF="$url?keyword=$1&section=$2&type=man"> },
+ $&, "</A>", $';
+ ++$matches;
+ } else {
+ print $_;
+ }
+ print $brk;
+ }
+ if ($? != 0 || $matches == 0) {
+ &error_page("Your search request with keyword '$keyword' failed.");
+# print "return code $? matches $matches\n";
+ close(MAN);
+ return;
+ }
+ close(MAN);
+
+ print $query->end_html;
+}
+
diff --git a/nx-X11/extras/rman/getopt.c b/nx-X11/extras/rman/getopt.c
new file mode 100644
index 000000000..89cae577a
--- /dev/null
+++ b/nx-X11/extras/rman/getopt.c
@@ -0,0 +1,80 @@
+/*
+Newsgroups: mod.std.unix
+Subject: public domain AT&T getopt source
+Date: 3 Nov 85 19:34:15 GMT
+
+Here's something you've all been waiting for: the AT&T public domain
+source for getopt(3). It is the code which was given out at the 1985
+UNIFORUM conference in Dallas. I obtained it by electronic mail
+directly from AT&T. The people there assure me that it is indeed
+in the public domain.
+*/
+/* $XFree86$ */
+
+/*LINTLIBRARY*/
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+
+#ifndef EOF
+#define EOF (-1)
+#endif
+#define ERR(s, c) if(opterr){\
+ char errbuf[2];\
+ errbuf[0] = c; errbuf[1] = '\n';\
+ (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
+ (void) write(2, s, (unsigned)strlen(s));\
+ (void) write(2, errbuf, 2);}
+
+
+int opterr = 1;
+int optind = 1;
+int optopt;
+char *optarg;
+
+int
+getopt(argc, argv, opts)
+int argc;
+char **argv, *opts;
+{
+ static int sp = 1;
+ register int c;
+ register char *cp;
+
+ if(sp == 1)
+ if(optind >= argc ||
+ argv[optind][0] != '-' || argv[optind][1] == '\0')
+ return(EOF);
+ else if(strcmp(argv[optind], "--") == NULL) {
+ optind++;
+ return(EOF);
+ }
+ optopt = c = argv[optind][sp];
+ if(c == ':' || (cp=strchr(opts, c)) == NULL) {
+ ERR(": illegal option -- ", c);
+ if(argv[optind][++sp] == '\0') {
+ optind++;
+ sp = 1;
+ }
+ return('?');
+ }
+ if(*++cp == ':') {
+ if(argv[optind][sp+1] != '\0')
+ optarg = &argv[optind++][sp+1];
+ else if(++optind >= argc) {
+ ERR(": option requires an argument -- ", c);
+ sp = 1;
+ return('?');
+ } else
+ optarg = argv[optind++];
+ sp = 1;
+ } else {
+ if(argv[optind][++sp] == '\0') {
+ sp = 1;
+ optind++;
+ }
+ optarg = NULL;
+ }
+ return(c);
+}
diff --git a/nx-X11/extras/rman/rman.1 b/nx-X11/extras/rman/rman.1
new file mode 100644
index 000000000..250e3e237
--- /dev/null
+++ b/nx-X11/extras/rman/rman.1
@@ -0,0 +1,273 @@
+.TH PolyglotMan 1
+.SH "NAME "
+PolyglotMan, rman - reverse compile man pages from formatted
+form to a number of source formats
+.SH "SYNOPSIS "
+rman [ \fIoptions \fR] [ \fIfile \fR]
+.SH "DESCRIPTION "
+Up-to-date instructions can be found at
+http://polyglotman.sourceforge.net/rman.html
+
+.PP
+\fIPolyglotMan \fR takes man pages from most of the popular flavors
+of UNIX and transforms them into any of a number of text source
+formats. PolyglotMan was formerly known as RosettaMan. The name
+of the binary is still called \fIrman \fR, for scripts that depend
+on that name; mnemonically, just think "reverse man". Previously \fI
+PolyglotMan \fR required pages to be formatted by nroff prior
+to its processing. With version 3.0, it \fIprefers [tn]roff source \fR
+and usually produces results that are better yet. And source
+processing is the only way to translate tables. Source format
+translation is not as mature as formatted, however, so try formatted
+translation as a backup.
+.PP
+In parsing [tn]roff source, one could implement an arbitrarily
+large subset of [tn]roff, which I did not and will not do, so
+the results can be off. I did implement a significant subset
+of those use in man pages, however, including tbl (but not eqn),
+if tests, and general macro definitions, so usually the results
+look great. If they don't, format the page with nroff before
+sending it to PolyglotMan. If PolyglotMan doesn't recognize a
+key macro used by a large class of pages, however, e-mail me
+the source and a uuencoded nroff-formatted page and I'll see
+what I can do. When running PolyglotMan with man page source
+that includes or redirects to other [tn]roff source using the .so (source
+or inclusion) macro, you should be in the parent directory of
+the page, since pages are written with this assumption. For example,
+if you are translating /usr/man/man1/ls.1, first cd into /usr/man.
+.PP
+\fIPolyglotMan \fR accepts man pages from: SunOS, Sun Solaris,
+Hewlett-Packard HP-UX, AT&T System V, OSF/1 aka Digital UNIX,
+DEC Ultrix, SGI IRIX, Linux, FreeBSD, SCO. Source processing
+works for: SunOS, Sun Solaris, Hewlett-Packard HP-UX, AT&T System
+V, OSF/1 aka Digital UNIX, DEC Ultrix. It can produce printable
+ASCII-only (control characters stripped), section headers-only,
+Tk, TkMan, [tn]roff (traditional man page source), SGML, HTML,
+MIME, LaTeX, LaTeX2e, RTF, Perl 5 POD. A modular architecture
+permits easy addition of additional output formats.
+.PP
+The latest version of PolyglotMan is available from \fI
+http://polyglotman.sourceforge.net/ \fR.
+.SH "OPTIONS "
+The following options should not be used with any others and
+exit PolyglotMan without processing any input.
+.TP 15
+-h|--help
+Show list of command line options and exit.
+.TP 15
+-v|--version
+Show version number and exit.
+.PP
+\fIYou should specify the filter first, as this sets a number
+of parameters, and then specify other options.
+.TP 15
+-f|--filter <ASCII|roff|TkMan|Tk|Sections|HTML|SGML|MIME|LaTeX|LaTeX2e|RTF|POD>
+Set the output filter. Defaults to ASCII.
+.TP 15
+-S|--source
+PolyglotMan tries to automatically determine whether its input
+is source or formatted; use this option to declare source input.
+.TP 15
+-F|--format|--formatted
+PolyglotMan tries to automatically determine whether its input
+is source or formatted; use this option to declare formatted
+input.
+.TP 15
+-l|--title \fIprintf-string \fR
+In HTML mode this sets the <TITLE> of the man pages, given the
+same parameters as \fI-r \fR.
+.TP 15
+-r|--reference|--manref \fIprintf-string \fR
+In HTML and SGML modes this sets the URL form by which to retrieve
+other man pages. The string can use two supplied parameters:
+the man page name and its section. (See the Examples section.)
+If the string is null (as if set from a shell by "-r ''"), `-'
+or `off', then man page references will not be HREFs, just set
+in italics. If your printf supports XPG3 positions specifier,
+this can be quite flexible.
+.TP 15
+-V|--volumes \fI<colon-separated list> \fR
+Set the list of valid volumes to check against when looking for
+cross-references to other man pages. Defaults to \fI1:2:3:4:5:6:7:8:9:o:l:n:p \fR(volume
+names can be multicharacter). If an non-whitespace string in
+the page is immediately followed by a left parenthesis, then
+one of the valid volumes, and ends with optional other characters
+and then a right parenthesis--then that string is reported as
+a reference to another manual page. If this -V string starts
+with an equals sign, then no optional characters are allowed
+between the match to the list of valids and the right parenthesis. (This
+option is needed for SCO UNIX.)
+.PP
+The following options apply only when formatted pages are given
+as input. They do not apply or are always handled correctly with
+the source.
+.TP 15
+-b|--subsections
+Try to recognize subsection titles in addition to section titles.
+This can cause problems on some UNIX flavors.
+.TP 15
+-K|--nobreak
+Indicate manual pages don't have page breaks, so don't look for
+footers and headers around them. (Older nroff -man macros always
+put in page breaks, but lately some vendors have realized that
+printout are made through troff, whereas nroff -man is used to
+format pages for reading on screen, and so have eliminated page
+breaks.) \fIPolyglotMan \fR usually gets this right even without
+this flag.
+.TP 15
+-k|--keep
+Keep headers and footers, as a canonical report at the end of
+the page. changeleft
+Move changebars, such as those found in the Tcl/Tk manual pages,
+to the left. --> notaggressive
+\fIDisable \fR aggressive man page parsing. Aggressive manual,
+which is on by default, page parsing elides headers and footers,
+identifies sections and more. -->
+.TP 15
+-n|--name \fIname \fR
+Set name of man page (used in roff format). If the filename is
+given in the form " \fIname \fR. \fIsection \fR", the name and
+section are automatically determined. If the page is being parsed
+from [tn]roff source and it has a .TH line, this information
+is extracted from that line.
+.TP 15
+-p|--paragraph
+paragraph mode toggle. The filter determines whether lines should
+be linebroken as they were by nroff, or whether lines should
+be flowed together into paragraphs. Mainly for internal use.
+.TP 15
+-s|section \fI# \fR
+Set volume (aka section) number of man page (used in roff format).
+tables
+Turn on aggressive table parsing. -->
+.TP 15
+-t|--tabstops \fI# \fR
+For those macros sets that use tabs in place of spaces where
+possible in order to reduce the number of characters used, set
+tabstops every \fI# \fR columns. Defaults to 8.
+.SH "NOTES ON FILTER TYPES "
+.SS "ROFF "
+Some flavors of UNIX ship man page without [tn]roff source, making
+one's laser printer little more than a laser-powered daisy wheel.
+This filer tries to intuit the original [tn]roff directives,
+which can then be recompiled by [tn]roff.
+.SS "TkMan "
+TkMan, a hypertext man page browser, uses \fIPolyglotMan \fR
+to show man pages without the (usually) useless headers and footers
+on each pages. It also collects section and (optionally) subsection
+heads for direct access from a pulldown menu. TkMan and Tcl/Tk,
+the toolkit in which it's written, are available via anonymous
+ftp from \fIftp://ftp.smli.com/pub/tcl/ \fR
+.SS "Tk "
+This option outputs the text in a series of Tcl lists consisting
+of text-tags pairs, where tag names roughly correspond to HTML.
+This output can be inserted into a Tk text widget by doing an \fI
+eval <textwidget> insert end <text> \fR. This format should be
+relatively easily parsible by other programs that want both the
+text and the tags. Also see ASCII.
+.SS "ASCII "
+When printed on a line printer, man pages try to produce special
+text effects by overstriking characters with themselves (to produce
+bold) and underscores (underlining). Other text processing software,
+such as text editors, searchers, and indexers, must counteract
+this. The ASCII filter strips away this formatting. Piping nroff
+output through \fIcol -b \fR also strips away this formatting,
+but it leaves behind unsightly page headers and footers. Also
+see Tk.
+.SS "Sections "
+Dumps section and (optionally) subsection titles. This might
+be useful for another program that processes man pages.
+.SS "HTML "
+With a simple extention to an HTTP server for Mosaic or other
+World Wide Web browser, \fIPolyglotMan \fR can produce high quality
+HTML on the fly. Several such extensions and pointers to several
+others are included in \fIPolyglotMan \fR's \fIcontrib \fR directory.
+.SS "SGML "
+This is appoaching the Docbook DTD, but I'm hoping that someone
+that someone with a real interest in this will polish the tags
+generated. Try it to see how close the tags are now.
+.SS "MIME "
+MIME (Multipurpose Internet Mail Extensions) as defined by RFC 1563,
+good for consumption by MIME-aware e-mailers or as Emacs (>=19.29)
+enriched documents.
+.SS "LaTeX and LaTeX2e "
+Why not?
+.SS "RTF "
+Use output on Mac or NeXT or whatever. Maybe take random man
+pages and integrate with NeXT's documentation system better.
+Maybe NeXT has own man page macros that do this.
+.SS "PostScript and FrameMaker "
+To produce PostScript, use \fIgroff \fR or \fIpsroff \fR. To
+produce FrameMaker MIF, use FrameMaker's builtin filter. In both
+cases you need \fI[tn]roff \fR source, so if you only have a
+formatted version of the manual page, use \fIPolyglotMan \fR's
+roff filter first.
+.SH "EXAMPLES "
+To convert the \fIformatted \fR man page named \fIls.1 \fR back
+into [tn]roff source form:
+.PP
+\fIrman -f roff /usr/local/man/cat1/ls.1 > /usr/local/man/man1/ls.1 \fR
+.br
+.PP
+Long man pages are often compressed to conserve space (compression
+is especially effective on formatted man pages as many of the
+characters are spaces). As it is a long man page, it probably
+has subsections, which we try to separate out (some macro sets
+don't distinguish subsections well enough for \fIPolyglotMan \fR
+to detect them). Let's convert this to LaTeX format:
+.br
+.PP
+\fIpcat /usr/catman/a_man/cat1/automount.z | rman -b -n automount -s 1 -f
+latex > automount.man \fR
+.br
+.PP
+Alternatively, \fIman 1 automount | rman -b -n automount -s 1 -f
+latex > automount.man \fR
+.br
+.PP
+For HTML/Mosaic users, \fIPolyglotMan \fR can, without modification
+of the source code, produce HTML links that point to other HTML
+man pages either pregenerated or generated on the fly. First
+let's assume pregenerated HTML versions of man pages stored in \fI/usr/man/html \fR.
+Generate these one-by-one with the following form:
+.br
+\fIrman -f html -r 'http:/usr/man/html/%s.%s.html' /usr/man/cat1/ls.1 > /usr/man/html/ls.1.html \fR
+.br
+.PP
+If you've extended your HTML client to generate HTML on the fly
+you should use something like:
+.br
+\fIrman -f html -r 'http:~/bin/man2html?%s:%s' /usr/man/cat1/ls.1 \fR
+.br
+when generating HTML.
+.SH "BUGS/INCOMPATIBILITIES "
+\fIPolyglotMan \fR is not perfect in all cases, but it usually
+does a good job, and in any case reduces the problem of converting
+man pages to light editing.
+.PP
+Tables in formatted pages, especially H-P's, aren't handled very
+well. Be sure to pass in source for the page to recognize tables.
+.PP
+The man pager \fIwoman \fR applies its own idea of formatting
+for man pages, which can confuse \fIPolyglotMan \fR. Bypass \fI
+woman \fR by passing the formatted manual page text directly
+into \fIPolyglotMan \fR.
+.PP
+The [tn]roff output format uses fB to turn on boldface. If your
+macro set requires .B, you'll have to a postprocess the \fIPolyglotMan \fR
+output.
+.SH "SEE ALSO "
+\fItkman(1) \fR, \fIxman(1) \fR, \fIman(1) \fR, \fIman(7) \fR
+or \fIman(5) \fR depending on your flavor of UNIX
+.SH "AUTHOR "
+PolyglotMan
+.br
+by Thomas A. Phelps ( \fIphelps@ACM.org \fR)
+.br
+developed at the
+.br
+University of California, Berkeley
+.br
+Computer Science Division
+.PP
+Manual page last updated on $Date: 2005/07/15 15:45:29 $
diff --git a/nx-X11/extras/rman/rman.c b/nx-X11/extras/rman/rman.c
new file mode 100644
index 000000000..1f0d540ba
--- /dev/null
+++ b/nx-X11/extras/rman/rman.c
@@ -0,0 +1,4974 @@
+#ifdef UNDEF
+static char cvsid[] = "Header: /usr/build/rman/rman-031225/phelps/RCS/rman.c,v 1.154 2003/07/26 19:00:48 phelps Exp $";
+#endif
+
+/*
+ PolyglotMan by Thomas A. Phelps (phelps@ACM.org)
+
+ accept man pages as formatted by (10)
+ Hewlett-Packard HP-UX, AT&T System V, SunOS, Sun Solaris, OSF/1,
+ DEC Ultrix, SGI IRIX, Linux, FreeBSD, SCO
+
+ output as (9)
+ printable ASCII, section headers only, TkMan, [tn]roff, HTML,
+ LaTeX, LaTeX2e, RTF, Perl pod, MIME, DocBook XML
+
+ written March 24, 1993
+ bs2tk generalized into RosettaMan November 4-5, 1993
+ source interpretation added September 24, 1996
+ renamed PolyglotMan due to lawsuit by Rosetta, Inc. August 8, 1997
+*/
+/* $XFree86: xc/extras/rman/rman.c,v 1.18 2003/10/22 19:50:36 tsi Exp $ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#if defined(Lynx) || defined(__QNXNTO__)
+extern int optind;
+extern char *optarg;
+#endif
+#ifdef __CYGWIN__
+#include <getopt.h>
+#endif
+
+/*** make #define's into consts? => can't because compilers not smart enough ***/
+/* maximum number of tags per line */
+#define MAXTAGS 50*100
+#define MAXBUF 2*5000
+#define MAXLINES 20000
+#define MAXTOC 500
+#define xputchar(c) (fcharout? putchar(c): (c))
+#define sputchar(c) (fcharout? plain[sI++]=(char)c: (char)(c))
+#define stagadd(tag) tagadd(tag,sI,0)
+enum { c_dagger='\xa7', c_bullet='\xb7', c_plusminus='\xb1' };
+
+
+/*** tag management ***/
+
+enum tagtype { NOTAG, TITLE, ITALICS, BOLD, SYMBOL, SMALLCAPS, BOLDITALICS, MONO, MANREF }; /* MANREF last */
+struct { enum tagtype type; int first; int last; } tags[MAXTAGS], tagtmp;
+int tagc=0;
+struct { char *text; int type; int line; } toc[MAXTOC];
+int tocc=0;
+
+
+/* characters in this list automatically prefixed by a backslash (set in output format function */
+char *escchars="";
+char *vollist = VOLLIST;
+const char *manvalid = "._-+:"; /* in addition to alphanumerics, valid characters to find in a man page name */
+char *manrefname;
+char *manrefsect;
+
+enum command {
+ NOCOMMAND=-1,
+
+ /*BEGINCHARTAGS,*/
+ CHARTAB='\t',
+ CHARPERIOD='.', CHARLSQUOTE='`', CHARRSQUOTE='\'', CHARGT='>', CHARLT='<',
+ CHARAMP='&', CHARBACKSLASH='\\', CHARDASH='-', CHARHAT='^', CHARVBAR='|',
+ CHARNBSP=0xa0, CHARCENT=0xa2, CHARSECT=0xa7, CHARCOPYR=0xa9, CHARNOT=0xac,
+ CHARDAGGER=0xad, CHARREGTM=0xae, CHARDEG=0xb0, CHARPLUSMINUS=0xb1,
+ CHARACUTE=0xb4, CHARBULLET=0xb7, CHAR14=0xbc, CHAR12=0xbd, CHAR34=0xbe,
+ CHARMUL=0xd7, CHARDIV=0xf7,
+ CHANGEBAR=0x100, CHARLQUOTE, CHARRQUOTE,
+ /*ENDCHARTAGS,*/
+
+ /*BEGINFONTTAGS,*/
+ BEGINBOLD, ENDBOLD, BEGINITALICS, ENDITALICS, BEGINBOLDITALICS, ENDBOLDITALICS,
+ BEGINSC, ENDSC, BEGINY, ENDY, BEGINCODE, ENDCODE, BEGINMANREF, ENDMANREF,
+ FONTSIZE,
+ /*ENDFONTTAGS*/
+
+ /*BEGINLAYOUTTAGS,*/
+ ITAB, BEGINCENTER, ENDCENTER, HR,
+ /*ENDLAYOUTTAGS,*/
+
+ /*BEGINSTRUCTTAGS,*/
+ BEGINDOC, ENDDOC, BEGINCOMMENT, ENDCOMMENT, COMMENTLINE, BEGINBODY, ENDBODY,
+ BEGINHEADER, ENDHEADER, BEGINFOOTER, ENDFOOTER, BEGINLINE, ENDLINE, SHORTLINE,
+ BEGINSECTION, ENDSECTION, BEGINSUBSECTION, ENDSUBSECTION,
+ BEGINSECTHEAD, ENDSECTHEAD, BEGINSUBSECTHEAD, ENDSUBSECTHEAD,
+ BEGINBULPAIR, ENDBULPAIR, BEGINBULLET, ENDBULLET, BEGINBULTXT, ENDBULTXT,
+ BEGINTABLE, ENDTABLE, BEGINTABLELINE, ENDTABLELINE, BEGINTABLEENTRY, ENDTABLEENTRY,
+ BEGININDENT, ENDINDENT, BEGINCODEBLOCK, ENDCODEBLOCK,
+
+ BEGINDIFFA, ENDDIFFA, BEGINDIFFD, ENDDIFFD
+ /*,*//*ENDSTRUCTTAGS,*/
+};
+
+const char *tcltkOP[] = { "Command-Line Name", "Database Name", "Database Class" };
+
+
+/* characters that need special handling in any output format, *more than just a backslash* */
+/* characters in this list need a corresponding case statement in each output format */
+/*char *trouble="\t.`'><&\\^|-\xa7\xb7\xb1";*/
+const unsigned char trouble[]= { CHARTAB, CHARPERIOD, CHARLSQUOTE, CHARRSQUOTE,
+ CHARGT, CHARLT, CHARAMP, CHARBACKSLASH, CHARDASH, CHARHAT, CHARVBAR, CHARCENT,
+ CHARSECT, CHARCOPYR, CHARNOT, CHARDAGGER, CHARREGTM, CHARDEG, CHARPLUSMINUS,
+ CHARACUTE, CHARBULLET, CHAR14, CHAR12, CHAR34, CHARMUL, CHARDIV,
+ 0 };
+
+
+enum command tagbeginend[][2] = { /* parallel to enum tagtype */
+ { NOCOMMAND, NOCOMMAND },
+ { NOCOMMAND, NOCOMMAND },
+ { BEGINITALICS, ENDITALICS },
+ { BEGINBOLD, ENDBOLD },
+ { BEGINY, ENDY },
+ { BEGINSC, ENDSC },
+ { BEGINBOLDITALICS, ENDBOLDITALICS },
+ { NOCOMMAND, NOCOMMAND },
+ { BEGINMANREF, ENDMANREF }
+};
+
+void (*fn)(enum command) = NULL;
+enum command prevcmd = BEGINDOC;
+
+
+/*** globals ***/
+
+int fSource=-1; /* -1 => not determined yet */
+int finlist=0;
+int fDiff=0;
+FILE *difffd;
+char diffline[MAXBUF];
+char diffline2[MAXBUF];
+char *message = NULL;
+int fontdelta=0;
+int intArg;
+
+int fPara=0; /* line or paragraph groupings of text */
+int fSubsections=0; /* extract subsection titles too? */
+int fChangeleft=0; /* move change bars to left? (-1 => delete them) */
+int fReflow=0;
+int fURL=0; /* scan for URLs too? */
+#if 0
+int fMan=1; /* invoke agressive man page filtering? */
+#endif
+int fQS=0; /* squeeze out spaces (scnt and interword)? */
+int fIQS=0; /* squeeze out initial spaces (controlled separately from fQS) */
+int fILQS=0; /* squeeze out spaces for usual indent */
+int fHeadfoot=0; /* show canonical header and footer at bottom? */
+int falluc=0;
+int itabcnt=0;
+int fQuiet=0;
+int fTclTk=0;
+
+/* patterns observed in section heads that don't conform to first-letter-uppercase-rest-lowercase pattern (stay all uc, or go all lc, or have subsequent uc) */
+int lcexceptionslen = -1; /* computed by system */
+char *lcexceptions[] = {
+/* new rule: double/all consonants == UC? */
+ /* articles, verbs, conjunctions, prepositions, pronouns */
+ "a", "an", "the",
+ "am", "are", "is", "were",
+ "and", "or",
+ "by", "for", "from", "in", "into", "it", "of", "on", "to", "with",
+ "that", "this",
+
+ /* terms */
+ "API", "CD", "GUI", "UI", /*I/O=>I/O already*/ "ID", "IDs", "OO",
+ "IOCTLs", "IPC", "RPC",
+
+ /* system names */
+ "AWK", "cvs", "rcs", "GL", "vi", "PGP", "QuickTime", "DDD", "XPG/3",
+ "NFS", "NIS", "NIS+", "AFS",
+ "UNIX", "SysV",
+ "Xorg", "XOrg", "X.Org", "XFree86", "ICCCM",
+ "MH", "MIME",
+ "TeX", "LaTeX", "PicTeX",
+ "PostScript", "EPS", "EPSF", "EPSI",
+ "HTML", "URL", "WWW",
+
+ /* institution names */
+ "ANSI", "CERN", "GNU", "ISO", "NCSA",
+
+ /* Sun-specific */
+ "MT-Level", "SPARC",
+
+ NULL
+};
+
+
+int TabStops=8;
+int hanging=0; /* location of hanging indent (if ==0, none) */
+enum { NAME, SYNOPSIS, DESCRIPTION, SEEALSO, FILES, AUTHOR, RANDOM/*last!*/ };
+char *sectheadname[] = {
+ "NAME:NOMBRE", "SYNOPSIS", "DESCRIPTION:INTRODUCTION", "SEE ALSO:RELATED INFORMATION", "FILES", "AUTHOR:AUTHORS", "RANDOM"
+};
+int sectheadid = RANDOM;
+int oldsectheadid = RANDOM;
+
+int fCodeline=0;
+int fNOHY=0; /* re-linebreak so no words are hyphenated; not used by TkMan, but gotta keep for people converting formatted text */
+int fNORM=0; /* normalize? initial space => tabs, no changebars, exactly one blank line between sections */
+const char TABLEOFCONTENTS[] = "Table of Contents";
+const char HEADERANDFOOTER[] = "Header and Footer";
+char manName[80] = "man page";
+char manSect[10] = "1";
+const char PROVENANCE[] =
+ "manual page source format generated by PolyglotMan v" POLYGLOTMANVERSION;
+const char HOME[] = "available at http://polyglotman.sourceforge.net/";
+const char horizontalrule[] = "------------------------------------------------------------";
+
+const int LINEBREAK = 70;
+int linelen = 0; /* length of result in plain[] */
+int spcsqz; /* number of spaces squeezed out */
+int ccnt = 0; /* # of changebars */
+int scnt, scnt2; /* counts of initial spaces in line */
+int s_sum, s_cnt;
+int bs_sum, bs_cnt;
+int ncnt=0, oncnt=0; /* count of interline newlines */
+int CurLine=1;
+int AbsLine=1-1; /* absolute line number */
+int indent=0; /* global indentation */
+int lindent=0; /* usual local indent */
+int auxindent=0; /* aux indent */
+int I; /* index into line/paragraph */
+int fcharout=1; /* show text or not */
+char lookahead;
+/*int tabgram[MAXBUF];*/ /* histogram of first character positions */
+char buf[MAXBUF];
+char plain[MAXBUF]; /* current text line with control characters stripped out */
+char hitxt[MAXBUF]; /* highlighted text (available at time of BEGIN<highlight> signal */
+
+char header[MAXBUF]; /* complete line */
+char header2[MAXBUF]; /* SGIs have two lines of headers and footers */
+char header3[MAXBUF]; /* GNU and some others have a third! */
+char footer[MAXBUF];
+char footer2[MAXBUF];
+#define CRUFTS 5
+char *cruft[CRUFTS] = { header, header2, header3, footer, footer2 };
+
+char *File, *in; /* File = pointer to full file contents, in = current file pointer */
+char *argv0;
+int finTable=0;
+char tableSep='\0'; /*\t';*/
+/*int fTable=0;
+int fotable=0;*/
+char *tblcellformat;
+int tblcellspan;
+/*int tblspanmax;*/
+int listtype=-1; /* current list type bogus to begin with */
+enum listtypes { DL, OL, UL };
+
+int fIP=0;
+
+
+
+/*** utility functions ***/
+
+
+/* case insensitive versions of strcmp and strncmp */
+
+static int
+stricmp(const char *s1, const char *s2)
+{
+ assert(s1!=NULL && s2!=NULL);
+ /*strincmp(s1, s2, strlen(s1)+1);*/
+
+ while (tolower(*s1)==tolower(*s2)) {
+ if (*s1=='\0' /*&& *s2=='\0'*/) return 0;
+ s1++; s2++;
+ }
+
+ if (tolower(*s1)<tolower(*s2)) return -1;
+ else return 1;
+}
+
+static int
+lcexceptionscmp(const void *a, const void *b)
+{
+ return stricmp(*(char **)a, *(char **)b);
+}
+
+static int
+strincmp(const char *s1, const char *s2, size_t n)
+{
+ assert(s1!=NULL && s2!=NULL && n>0);
+
+ while (n>0 && tolower(*s1)==tolower(*s2)) {
+ n--; s1++; s2++;
+ }
+ if (n==0) return 0;
+ else if (tolower(*s1)<tolower(*s2)) return -1;
+ else return 1;
+}
+
+/* compare string and a colon-separated list of strings */
+static int
+strcoloncmp2(char *candidate, int end, const char *list, int sen)
+{
+ const char *l = list;
+ char *c,c2;
+
+ assert(candidate!=NULL && list!=NULL);
+ assert(end>=-1 && end<=255);
+ assert(sen==0 || sen==1);
+
+ if (*l==':') l++; /* tolerate a leading colon */
+
+ /* invariant: c and v point to start of strings to compare */
+ while (*l) {
+ assert(l==list || l[-1]==':');
+ for (c=candidate; *c && *l; c++,l++)
+ if ((sen && *c!=*l) || (!sen && tolower(*c)!=tolower(*l)))
+ break;
+
+ /* if candidate matches a valid one as far as valid goes, it's a keeper */
+ if ((*l=='\0' || *l==':') && (*c==end || end==-1)) {
+ if (*c=='\b') {
+ c2 = c[-1];
+ while (*c=='\b' && c[1]==c2) c+=2;
+ }
+ /* no volume qualifiers with digits */
+ if (!isdigit(*c)) return 1;
+ }
+
+ /* bump to start of next valid */
+ while (*l && *l++!=':') /* nada */;
+ }
+
+ return 0;
+}
+
+static int
+strcoloncmp(char *candidate, int end, const char *list)
+{
+ int sen=1;
+ const char *l = list;
+
+ assert(candidate!=NULL && list!=NULL);
+ assert(end>=-1 && end<=255);
+
+ if (*l=='=') l++; else end=-1;
+ if (*l=='i') { sen=0; l++; }
+
+ return strcoloncmp2(candidate, end, l, sen);
+}
+
+/* strdup not universally available */
+static char *
+mystrdup(const char *p)
+{
+ char *q;
+
+ if (p==NULL) return NULL;
+
+ q = malloc(strlen(p)+1); /* +1 gives space for \0 that is not reported by strlen */
+ if (q!=NULL) strcpy(q,p);
+ return q;
+}
+
+
+/* given line of text, return "casified" version in place:
+ if word in exceptions list, return exception conversion
+ else uc first letter, lc rest
+*/
+static void
+casify(char *p)
+{
+ char tmpch, *q, **exp;
+ int fuc;
+
+ for (fuc=1; *p; p++) {
+ if (isspace(*p) || strchr("&/",*p)!=NULL) fuc=1;
+ else if (fuc) {
+ /* usually */
+ if (p[1] && isupper(p[1]) /*&& p[2] && isupper(p[2])*/) fuc=0;
+ /* check for exceptions */
+ for (q=p; *q && !isspace(*q); q++) /*nada*/;
+ tmpch = *q; *q='\0';
+ exp = (char **)bsearch(&p, lcexceptions, lcexceptionslen, sizeof(char *), lcexceptionscmp);
+ *q = tmpch;
+ if (exp!=NULL) {
+ for (q=*exp; *q; q++) *p++=*q;
+ fuc = 1;
+ }
+ } else *p=tolower(*p);
+ }
+}
+
+
+/* add an attribute tag to a range of characters */
+
+static void
+tagadd(int /*enum tagtype--abused in source parsing*/ type, int first, int last)
+{
+ assert(type!=NOTAG);
+
+ if (tagc<MAXTAGS) {
+ tags[tagc].type = (enum tagtype)type;
+ tags[tagc].first = first;
+ tags[tagc].last = last;
+ tagc++;
+ }
+}
+
+
+/*
+ collect all saves to string table one one place, so that
+ if decide to go with string table instead of multiple malloc, it's easy
+ (probably few enough malloc's that more sophistication is unnecessary)
+*/
+
+static void
+tocadd(char *text, enum command type, int line)
+{
+ char *r;
+
+ assert(text!=NULL && strlen(text)>0);
+ assert(type==BEGINSECTION || type==BEGINSUBSECTION);
+
+ if (tocc<MAXTOC) {
+ r = malloc(strlen(text)+1); if (r==NULL) return;
+ strcpy(r,text);
+ toc[tocc].text = r;
+ toc[tocc].type = type;
+ toc[tocc].line = line;
+ tocc++;
+ }
+}
+
+
+
+char *manTitle = MANTITLEPRINTF;
+char *manRef = MANREFPRINTF;
+char *href;
+int fmanRef=1; /* make 'em links or just show 'em? */
+
+static void
+manrefextract(char *p)
+{
+ char *p0;
+ static char *nonhref = "\">'";
+ static char *punct = ".,:;)]}?!";
+
+ while (*p==' ') p++;
+ if (strincmp(p,"http",4)==0) {
+ href="%s"; manrefname = p;
+ p+=4;
+ while (*p && !isspace(*p) && !strchr(nonhref,*p)) p++;
+ while (strchr(punct, *(p - 1))) p--;
+ } else {
+ href = manRef;
+
+ manrefname = p;
+ while (*p && *p!=' ' && *p!='(') p++; *p++='\0';
+ while (*p==' ' || *p=='(') p++; p0=p;
+#if defined(XOrg) || defined(XFree86)
+ /* Don't allow a letter after the man section number */
+ p++;
+#else
+ while (*p && *p!=')') p++;
+#endif
+ manrefsect = p0;
+ }
+ *p='\0';
+}
+
+
+
+
+/*
+ * OUTPUT FORMATS
+ */
+
+static void
+formattedonly(void)
+{
+ fprintf(stderr, "The output formats for Tk and TkMan require nroff-formatted input\n");
+ exit(1);
+}
+
+
+/*
+ * DefaultFormat -- in weak OO inheritance, top of hierarchy for everybody
+ */
+static void
+DefaultFormat(enum command cmd)
+{
+ int i;
+
+ switch (cmd) {
+ case ITAB:
+ for (i=0; i<itabcnt; i++) putchar('\t');
+ break;
+ default:
+ /* nada */
+ break;
+ }
+}
+
+
+/*
+ * DefaultLine -- in weak OO inheritance, top of hierarchy for line-based formats
+ * for output format to "inherit", have "default: DefaultLine(cmd)" and override case statement "methods"
+ */
+
+static void
+DefaultLine(enum command cmd) {
+ switch (cmd) {
+ default:
+ DefaultFormat(cmd);
+ }
+}
+
+
+/*
+ * DefaultPara -- top of hierarchy for output formats that are formatted by their viewers
+ */
+
+static void
+DefaultPara(enum command cmd)
+{
+ switch (cmd) {
+ default:
+ DefaultFormat(cmd);
+ }
+}
+
+
+
+/*
+ * Tk -- just emit list of text-tags pairs
+ */
+
+static void
+Tk(enum command cmd)
+{
+ static int skip=0; /* skip==1 when line has no text */
+ int i;
+
+ if (fSource) formattedonly();
+
+ /* invariant: always ready to insert text */
+
+ switch (cmd) {
+ case BEGINDOC:
+ I=0; CurLine=1;
+ escchars = "\"[]$";
+ printf(/*$t insert end */ "\"");
+ break;
+ case ENDDOC:
+ if (fHeadfoot) {
+/* grr, should have +mark syntax for Tk text widget! -- maybe just just +sect#, +subsect#
+ printf("\\n\\n\" {} \"%s\\n\" {+headfoot h2}\n", HEADERANDFOOTER);
+*/
+ printf("\\n\\n\" {} \"%s\\n\" h2\n",HEADERANDFOOTER);
+ /*printf("$t mark set headfoot %d.0\n", CurLine);*/
+ CurLine++;
+
+ for (i=0; i<CRUFTS; i++) {
+ if (*cruft[i]) {
+ printf(/*$t insert end */"{%s} sc \\n\n", cruft[i]);
+ CurLine++;
+ }
+ }
+ } else printf("\"\n");
+ break;
+
+ case COMMENTLINE: printf("# "); break;
+
+ case BEGINLINE:
+ /*I=0; -- need to do this at end of line so set for filterline() */
+ /* nothing to do at start of line except catch up on newlines */
+ for (i=0; i<ncnt; i++) printf("\\n");
+ CurLine+=ncnt;
+ /*if (fSource) for (i=0; i<indent; i++) putchar('\t');*/
+ break;
+ case ENDLINE:
+ /*if (!fSource) {*/
+ if (!skip) /*if (ncnt)*/ printf("\\n"); /*else xputchar(' ');*/
+ skip=0;
+ CurLine++; I=0;
+ /*
+ } else {
+ putchar(' '); I++;
+ }
+ */
+ break;
+
+ case ENDSECTHEAD:
+ printf("\\n\" h2 \"");
+ tagc=0;
+ skip=1;
+ break;
+ case ENDSUBSECTHEAD:
+ printf("\\n\" h3 \""); /* add h3? */
+ tagc=0;
+ skip=1;
+ break;
+ case HR: /*printf("\\n%s\\n", horizontalrule); CurLine+=2; I=0;*/ break;
+ case BEGINTABLEENTRY:
+ /*if (fSource) putchar('\t');*/
+ break;
+ case BEGINTABLELINE:
+ case ENDTABLEENTRY:
+ break;
+ case ENDTABLELINE:
+ printf("\" tt \"");
+ /*tagadd(MONO, 0, I);*/
+ break;
+
+ case CHANGEBAR: putchar('|'); I++; break;
+ case CHARLQUOTE:
+ case CHARRQUOTE:
+ putchar('\\'); putchar('"'); I++;
+ break;
+ case CHARLSQUOTE:
+ case CHARRSQUOTE:
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARLT:
+ case CHARGT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARAMP:
+ case CHARPLUSMINUS:
+ case CHARNBSP:
+ case CHARCENT:
+ case CHARSECT:
+ case CHARCOPYR:
+ case CHARNOT:
+ case CHARREGTM:
+ case CHARDEG:
+ case CHARACUTE:
+ case CHAR14:
+ case CHAR12:
+ case CHAR34:
+ case CHARMUL:
+ case CHARDIV:
+ putchar(cmd); I++; break;
+ case CHARDAGGER:
+ putchar('+'); I++; break;
+ case CHARBACKSLASH: printf("\\\\"); I++; break;
+ case CHARBULLET: printf("\" {} %c symbol \"",c_bullet); I++; break;
+
+
+ case BEGINSECTHEAD:
+ case BEGINSUBSECTHEAD:
+ /*if (fSource && sectheadid!=NAME) { printf("\\n\\n"); CurLine+=2; I=0; }*/
+ tagc=0; /* section and subsection formatting controlled descriptively */
+ /* no break;*/
+
+ case BEGINBOLD:
+ case BEGINITALICS:
+ case BEGINBOLDITALICS:
+ case BEGINCODE:
+ case BEGINY:
+ case BEGINSC:
+ case BEGINMANREF:
+ /* end text, begin attributed text */
+ printf("\" {} \"");
+ break;
+
+ /* rely on the fact that no more than one tag per range of text */
+ case ENDBOLD: printf("\" b \""); break;
+ case ENDITALICS: printf("\" i \""); break;
+ case ENDBOLDITALICS: printf("\" bi \""); break;
+ case ENDCODE: printf("\" tt \""); break;
+ case ENDY: printf("\" symbol \""); break;
+ case ENDSC: printf("\" sc \""); break;
+ case ENDMANREF: printf("\" manref \""); break;
+ /* presentation attributes dealt with at end of line */
+
+ case BEGINBODY:
+ /*if (fSource) { printf("\\n\\n"); CurLine+=2; I=0; }*/
+ break;
+ case SHORTLINE:
+ /*if (fSource) { printf("\\n"); CurLine++; I=0; }*/
+ break;
+ case ENDBODY:
+ case BEGINBULPAIR: case ENDBULPAIR:
+ /*if (fSource) { printf("\\n"); CurLine++; I=0; }*/
+ break;
+ case BEGINBULTXT:
+ /*if (fSource) putchar('\t');*/
+ break;
+ case BEGINBULLET: case ENDBULLET:
+ case ENDBULTXT:
+ case BEGINSECTION: case ENDSECTION:
+ case BEGINSUBSECTION: case ENDSUBSECTION:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case BEGINTABLE: case ENDTABLE:
+ case FONTSIZE:
+ case BEGININDENT: case ENDINDENT:
+ /* no action */
+ break;
+ default:
+ DefaultLine(cmd);
+ }
+}
+
+
+/*
+ * TkMan -- Tk format wrapped with commands
+ */
+
+int linetabcnt[MAXLINES]; /* don't want to bother with realloc */
+int clocnt=0, clo[MAXLINES];
+int paracnt=0, para[MAXLINES];
+int rebuscnt=0, rebus[MAXLINES];
+int rebuspatcnt=0, rebuspatlen[25];
+char *rebuspat[25];
+
+static void
+TkMan(enum command cmd)
+{
+ static int lastscnt=-1;
+ static int lastlinelen=-1;
+ static int lastsect=0;
+ /*static int coalese=0;*/
+ static int finflow=0;
+ int i;
+ char c,*p;
+
+ /* invariant: always ready to insert text */
+
+ switch (cmd) {
+ case BEGINDOC:
+ printf("$t insert end "); /* opening quote supplied in Tk() below */
+ Tk(cmd);
+ break;
+ case ENDDOC:
+ Tk(ENDLINE);
+
+ if (fHeadfoot) {
+/* grr, should have +mark syntax for Tk text widget!
+ printf("\\n\\n\" {} \"%s\\n\" {+headfoot h2}\n", HEADERANDFOOTER);
+*/
+ printf("\\n\\n\" {} \"%s\\n\" h2\n", HEADERANDFOOTER);
+/* printf("$t mark set headfoot end-2l\n");*/
+ CurLine++;
+
+ for (i=0; i<CRUFTS; i++) {
+ if (*cruft[i]) {
+ printf("$t insert end {%s} sc \\n\n", cruft[i]);
+ CurLine++;
+ }
+ }
+ } else printf("\"\n");
+
+/*
+ printf("$t insert 1.0 {");
+ for (i=0; i<MAXBUF; i++) if (tabgram[i]) printf("%d=%d, ", i, tabgram[i]);
+ printf("\\n\\n}\n");
+*/
+
+ printf("set manx(tabcnts) {"); for (i=1; i<CurLine; i++) printf("%d ", linetabcnt[i]); printf("}\n");
+ printf("set manx(clo) {"); for (i=0; i<clocnt; i++) printf("%d ", clo[i]); printf("}\n");
+ printf("set manx(para) {"); for (i=0; i<paracnt; i++) printf("%d ", para[i]); printf("}\n");
+ printf("set manx(reb) {"); for (i=0; i<rebuscnt; i++) printf("%d ", rebus[i]); printf("}\n");
+
+ break;
+
+ case BEGINCOMMENT: fcharout=0; break;
+ case ENDCOMMENT: fcharout=1; break;
+ case COMMENTLINE: break;
+
+ case ENDSECTHEAD:
+ case ENDSUBSECTHEAD:
+ lastsect=1;
+ Tk(cmd);
+ break;
+
+ case BEGINLINE:
+ Tk(cmd);
+ linetabcnt[CurLine] = itabcnt;
+ /* old pattern for command line options "^\\|*\[ \t\]+-\[^-\].*\[^ \t\]" */
+ c = plain[0];
+ if (linelen>=2 && ((c=='-' || c=='%' || c=='\\' || c=='$' /**/ /* not much talk of money in man pages so reasonable */) && (isalnum(plain[1]) /*<= plain[1]!='-'*//*no dash*/ || ncnt/*GNU long option*/) && plain[1]!=' ') ) clo[clocnt++] = CurLine;
+ /*
+ would like to require second letter to be a capital letter to cut down on number of matches,
+ but command names usually start with lowercase letter
+ maybe use a uppercase requirement as secondary strategy, but probably not
+ */
+ if ((ncnt || lastsect) && linelen>0 && scnt>0 && scnt<=7/*used to be <=5 until groff spontaneously started putting in 7*/) para[paracnt++] = CurLine;
+ lastsect=0;
+
+
+ /* rebus too, instead of search through whole Tk widget */
+ if (rebuspatcnt && scnt>=5 /* not sect or subsect heads */) {
+ for (p=plain; *p && *p!=' '; p++) /*empty*/; /* never first word */
+ while (*p) {
+ for (i=0; i<rebuspatcnt; i++) {
+ if (tolower(*p) == tolower(*rebuspat[i]) && strincmp(p, rebuspat[i], rebuspatlen[i])==0) {
+ /* don't interfere with man page refs */
+ for (; *p && !isspace(*p); p++) if (*p=='(') continue;
+ rebus[rebuscnt++] = CurLine;
+ p=""; /* break for outer */
+ break; /* just locating any line with any rebus, not exact positions */
+ }
+ }
+ /* just check start of words, though doesn't have to be full word (if did, could use strlen rather than strnlen) */
+ while (*p && *p!=' ') p++;
+ while (*p && *p==' ') p++;
+ }
+ }
+
+
+ if (fReflow && !ncnt && (finflow || lastlinelen>50) && (abs(scnt-lastscnt)<=1 || abs(scnt-hanging)<=1)) {
+ finflow=1;
+ putchar(' ');
+ } else {
+ Tk(ENDLINE);
+ /*if ((CurLine&0x3f)==0x3f) printf("\"\nupdate idletasks\n$t insert end \""); blows up some Tk text buffer, apparently, on long lines*/
+ if ((CurLine&0x1f)==0x1f) printf("\"\nupdate idletasks\n$t insert end \"");
+ finflow=0;
+
+ /*if (fCodeline) printf("CODE");*/
+ }
+ lastlinelen=linelen; lastscnt=scnt;
+ break;
+
+ case ENDLINE:
+ /* don't call Tk(ENDLINE) */
+ break;
+
+ default: /* if not caught above, it's the same as Tk */
+ Tk(cmd);
+ }
+}
+
+
+
+
+/*
+ * ASCII
+ */
+
+static void
+ASCII(enum command cmd)
+{
+ int i;
+
+ switch (cmd) {
+ case ENDDOC:
+ if (fHeadfoot) {
+ printf("\n%s\n", HEADERANDFOOTER);
+ for (i=0; i<CRUFTS; i++) if (*cruft[i]) printf("%s\n", cruft[i]);
+ }
+ break;
+ case CHARRQUOTE:
+ case CHARLQUOTE:
+ putchar('"');
+ break;
+ case CHARLSQUOTE:
+ putchar('`');
+ break;
+ case CHARRSQUOTE:
+ case CHARACUTE:
+ putchar('\'');
+ break;
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARLT:
+ case CHARAMP:
+ case CHARBACKSLASH:
+ case CHARGT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARNBSP:
+ putchar(cmd); break;
+ case CHARDAGGER: putchar('+'); break;
+ case CHARBULLET: putchar('*'); break;
+ case CHARPLUSMINUS: printf("+-"); break;
+ case CHANGEBAR: putchar('|'); break;
+ case CHARCENT: putchar('c'); break;
+ case CHARSECT: putchar('S'); break;
+ case CHARCOPYR: printf("(C)"); break;
+ case CHARNOT: putchar('~'); break;
+ case CHARREGTM: printf("(R)"); break;
+ case CHARDEG: putchar('o'); break;
+ case CHAR14: printf("1/4"); break;
+ case CHAR12: printf("1/2"); break;
+ case CHAR34: printf("3/4"); break;
+ case CHARMUL: putchar('X'); break;
+ case CHARDIV: putchar('/'); break;
+ case HR: printf("\n%s\n", horizontalrule); break;
+
+ case BEGINLINE:
+ for (i=0; i<ncnt; i++) putchar('\n');
+ break;
+ case BEGINBODY:
+ case SHORTLINE:
+ if (!fSource) break;
+ case ENDLINE:
+ putchar('\n');
+ CurLine++;
+ break;
+
+ case BEGINDOC:
+ case ENDBODY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case BEGINSECTION: case ENDSECTION:
+ case BEGINSECTHEAD: case ENDSECTHEAD:
+ case BEGINSUBSECTHEAD: case ENDSUBSECTHEAD:
+ case BEGINBULPAIR: case ENDBULPAIR:
+ case BEGINBULLET: case ENDBULLET:
+ case BEGINBULTXT: case ENDBULTXT:
+ case BEGINSUBSECTION: case ENDSUBSECTION:
+
+ case BEGINTABLE: case ENDTABLE:
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ case BEGINBOLD: case ENDBOLD:
+ case BEGINCODE: case ENDCODE:
+ case BEGINITALICS: case ENDITALICS:
+ case BEGINMANREF: case ENDMANREF:
+ case BEGINBOLDITALICS: case ENDBOLDITALICS:
+ case BEGINY: case ENDY:
+ case BEGINSC: case ENDSC:
+ /* nothing */
+ break;
+ default:
+ DefaultLine(cmd);
+ }
+}
+
+
+
+/*
+ * Perl 5 pod ("plain old documentation")
+ */
+
+static void
+pod(enum command cmd)
+{
+ static int curindent=0;
+ int i;
+
+ if (hanging==-1) {
+ if (curindent) hanging=curindent; else hanging=5;
+ }
+
+
+ if (cmd==BEGINBULPAIR) {
+ /* want to have multiply indented text */
+ if (curindent && hanging!=curindent) printf("\n=back\n\n");
+ if (hanging!=curindent) printf("\n=over %d\n\n",hanging);
+ curindent=hanging;
+ } else if (cmd==ENDBULPAIR) {
+ /* nothing--wait until next command */
+ } else if (cmd==BEGINLINE && !scnt) {
+ if (curindent) printf("\n=back\n\n");
+ curindent=0;
+ } else if (cmd==BEGINBODY) {
+ if (curindent) {
+ printf("\n=back\n\n");
+ curindent=0;
+ auxindent=0;
+ }
+ }
+/*
+ case BEGINBULPAIR:
+ printf("=over %d\n\n", hanging);
+ break;
+ case ENDBULPAIR:
+ printf("\n=back\n\n");
+ break;
+*/
+ switch (cmd) {
+ case BEGINDOC: I=0; break;
+
+ case BEGINCOMMENT: fcharout=0; break;
+ case ENDCOMMENT: fcharout=1; break;
+ case COMMENTLINE: break;
+
+ case CHARRQUOTE:
+ case CHARLQUOTE:
+ putchar('"');
+ break;
+ case CHARLSQUOTE:
+ putchar('`');
+ break;
+ case CHARRSQUOTE:
+ case CHARACUTE:
+ putchar('\'');
+ break;
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARLT:
+ case CHARAMP:
+ case CHARBACKSLASH:
+ case CHARGT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARNBSP:
+ putchar(cmd); break;
+ case CHARDAGGER: putchar('+'); break;
+ case CHARPLUSMINUS: printf("+-"); break;
+ case CHANGEBAR: putchar('|'); break;
+ case CHARCENT: putchar('c'); break;
+ case CHARSECT: putchar('S'); break;
+ case CHARCOPYR: printf("(C)"); break;
+ case CHARNOT: putchar('~'); break;
+ case CHARREGTM: printf("(R)"); break;
+ case CHARDEG: putchar('o'); break;
+ case CHAR14: printf("1/4"); break;
+ case CHAR12: printf("1/2"); break;
+ case CHAR34: printf("3/4"); break;
+ case CHARMUL: putchar('X'); break;
+ case CHARDIV: putchar('/'); break;
+ case HR: printf("\n%s\n", horizontalrule); break;
+ case CHARBULLET: putchar('*'); break;
+
+ case BEGINLINE:
+ for (i=0; i<ncnt; i++) putchar('\n');
+ CurLine+=ncnt;
+ break;
+ case ENDLINE:
+ putchar('\n');
+ CurLine++;
+ I=0;
+ break;
+
+ case BEGINSECTHEAD: printf("=head1 "); break;
+ case BEGINSUBSECTHEAD: printf("=head2 "); break;
+
+ case ENDSECTHEAD:
+ case ENDSUBSECTHEAD:
+ printf("\n");
+ break;
+
+ case BEGINCODE:
+ case BEGINBOLD: printf("B<"); break;
+ case BEGINITALICS: printf("I<"); break;
+ case BEGINMANREF: printf("L<"); break;
+
+ case ENDBOLD:
+ case ENDCODE:
+ case ENDITALICS:
+ case ENDMANREF:
+ printf(">");
+ break;
+
+ case BEGINBULLET:
+ printf("\n=item ");
+ break;
+ case ENDBULLET:
+ printf("\n\n");
+ fcharout=0;
+ break;
+ case BEGINBULTXT:
+ fcharout=1;
+ auxindent=hanging;
+ break;
+ case ENDBULTXT:
+ auxindent=0;
+ break;
+
+
+ case ENDDOC:
+ case BEGINBODY: case ENDBODY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case BEGINSECTION: case ENDSECTION:
+ case BEGINSUBSECTION: case ENDSUBSECTION:
+ case BEGINBULPAIR: case ENDBULPAIR:
+
+ case SHORTLINE:
+ case BEGINTABLE: case ENDTABLE:
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ case BEGINBOLDITALICS: case ENDBOLDITALICS:
+ case BEGINY: case ENDY:
+ case BEGINSC: case ENDSC:
+ /* nothing */
+ break;
+ default:
+ DefaultLine(cmd);
+ }
+}
+
+
+
+static void
+Sections(enum command cmd)
+{
+
+ switch (cmd) {
+ case ENDSECTHEAD:
+ case ENDSUBSECTHEAD:
+ putchar('\n');
+ case BEGINDOC:
+ fcharout=0;
+ break;
+
+ case BEGINCOMMENT: fcharout=0; break;
+ case ENDCOMMENT: fcharout=1; break;
+ case COMMENTLINE: break;
+
+ case BEGINSUBSECTHEAD:
+ printf(" ");
+ /* no break */
+ case BEGINSECTHEAD:
+ fcharout=1;
+ break;
+ case CHARRQUOTE:
+ case CHARLQUOTE:
+ xputchar('"');
+ break;
+ case CHARLSQUOTE:
+ xputchar('`');
+ break;
+ case CHARRSQUOTE:
+ case CHARACUTE:
+ xputchar('\'');
+ break;
+ case BEGINTABLE: case ENDTABLE:
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ break;
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARBACKSLASH:
+ case CHARLT:
+ case CHARGT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARAMP:
+ case CHARNBSP:
+ xputchar(cmd); break;
+ case CHARDAGGER: xputchar('+'); break;
+ case CHARBULLET: xputchar('*'); break;
+ case CHARPLUSMINUS: xputchar('+'); xputchar('-'); break;
+ case CHARCENT: xputchar('c'); break;
+ case CHARSECT: xputchar('S'); break;
+ case CHARCOPYR: xputchar('('); xputchar('C'); xputchar(')'); break;
+ case CHARNOT: xputchar('~'); break;
+ case CHARREGTM: xputchar('('); xputchar('R'); xputchar(')'); break;
+ case CHARDEG: xputchar('o'); break;
+ case CHAR14: xputchar('1'); xputchar('/'); xputchar('4'); break;
+ case CHAR12: xputchar('1'); xputchar('/'); xputchar('2'); break;
+ case CHAR34: xputchar('3'); xputchar('/'); xputchar('4'); break;
+ case CHARMUL: xputchar('X'); break;
+ case CHARDIV: xputchar('/'); break;
+ case ITAB: DefaultLine(cmd); break;
+
+
+ default:
+ /* nothing */
+ break;
+ }
+}
+
+
+
+static void
+Roff(enum command cmd)
+{
+ switch (cmd) {
+ case BEGINDOC:
+ I=1;
+ printf(".TH %s %s \"generated by PolyglotMan\" UCB\n", manName, manSect);
+ printf(".\\\" %s,\n", PROVENANCE);
+ printf(".\\\" %s\n", HOME);
+ CurLine=1;
+ break;
+ case BEGINBODY: printf(".LP\n"); break;
+
+ case BEGINCOMMENT:
+ case ENDCOMMENT:
+ break;
+ case COMMENTLINE: printf("'\\\" "); break;
+
+ case BEGINSECTHEAD: printf(".SH "); break;
+ case BEGINSUBSECTHEAD:printf(".SS "); break;
+ case BEGINBULPAIR: printf(".IP "); break;
+ case SHORTLINE: printf("\n.br"); break;
+ case BEGINBOLD: printf("\\fB"); break; /* \n.B -- grr! */
+ case ENDCODE:
+ case ENDBOLD: printf("\\fR"); break; /* putchar('\n'); */
+ case BEGINITALICS: printf("\\fI"); break;
+ case ENDITALICS: printf("\\fR"); break;
+ case BEGINCODE:
+ case BEGINBOLDITALICS:printf("\\f4"); break;
+ case ENDBOLDITALICS: printf("\\fR"); break;
+
+ case CHARLQUOTE: printf("\\*(rq"); break;
+ case CHARRQUOTE: printf("\\*(lq"); break;
+ case CHARNBSP: printf("\\|"); break;
+ case CHARLSQUOTE: putchar('`'); break;
+ case CHARRSQUOTE: putchar('\''); break;
+ case CHARPERIOD: if (I==1) printf("\\&"); putchar('.'); I++; break;
+ case CHARDASH: printf("\\-"); break;
+ case CHARTAB:
+ case CHARLT:
+ case CHARGT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARAMP:
+ putchar(cmd); break;
+ case CHARBULLET: printf("\\(bu"); break;
+ case CHARDAGGER: printf("\\(dg"); break;
+ case CHARPLUSMINUS: printf("\\(+-"); break;
+ case CHANGEBAR: putchar('|'); break;
+ case CHARCENT: printf("\\(ct"); break;
+ case CHARSECT: printf("\\(sc"); break;
+ case CHARCOPYR: printf("\\(co"); break;
+ case CHARNOT: printf("\\(no"); break;
+ case CHARREGTM: printf("\\(rg"); break;
+ case CHARDEG: printf("\\(de"); break;
+ case CHARACUTE: printf("\\(aa"); break;
+ case CHAR14: printf("\\(14"); break;
+ case CHAR12: printf("\\(12"); break;
+ case CHAR34: printf("\\(34"); break;
+ case CHARMUL: printf("\\(mu"); break;
+ case CHARDIV: printf("\\(di"); break;
+ case HR: /*printf("\n%s\n", horizontalrule);*/ break;
+ case CHARBACKSLASH: printf("\\\\"); break; /* correct? */
+
+ case BEGINLINE:
+ /*for (i=0; i<ncnt; i++) putchar('\n');*/
+ break;
+
+ case BEGINBULLET: putchar('"'); break;
+ case ENDBULLET: printf("\"\n"); break;
+
+ case ENDLINE:
+ CurLine++;
+ I=1;
+ /* no break */
+ case ENDSUBSECTHEAD:
+ case ENDSECTHEAD:
+ case ENDDOC:
+ putchar('\n');
+ break;
+
+ case BEGINCODEBLOCK: printf(".nf\n");
+ case ENDCODEBLOCK: printf(".fi\n");
+
+ case ENDBODY:
+ case ENDBULPAIR:
+ case BEGINBULTXT: case ENDBULTXT:
+ case BEGINSECTION: case ENDSECTION:
+ case BEGINSUBSECTION: case ENDSUBSECTION:
+ case BEGINY: case ENDY:
+ case BEGINSC: case ENDSC:
+ case BEGINTABLE: case ENDTABLE:
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case BEGINMANREF: case ENDMANREF:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+
+/*
+ * HTML
+ */
+
+static void
+HTML(enum command cmd)
+{
+ static int pre=0;
+ int i;
+ int lasttoc;
+
+ /* always respond to these signals */
+ switch (cmd) {
+ case CHARNBSP: printf("&nbsp;"); I++; break;
+ case CHARTAB: printf("<tt>&#32;</tt>&nbsp;<tt>&#32;</tt>&nbsp;"); break;
+#if defined(XOrg) || defined(XFree86)
+ /* using named entities for ASCII quote characters is redundant */
+ case CHARLQUOTE:
+ case CHARRQUOTE:
+ case CHARLSQUOTE:
+ case CHARRSQUOTE:
+ putchar(cmd); break;
+#else
+ case CHARLQUOTE: printf("&ldquo;"); break;
+ case CHARRQUOTE: printf("&rdquo;"); break;
+ case CHARLSQUOTE: printf("&lsquo;"); break;
+ case CHARRSQUOTE: printf("&rsquo;"); break;
+#endif
+ case CHARPERIOD:
+ case CHARDASH:
+ case CHARBACKSLASH:
+ case CHARVBAR: /*printf("&brvbar;"); -- broken bar no good */
+ case CHARHAT:
+ putchar(cmd);
+ break;
+ case CHARDAGGER: printf("&dagger;"); break;
+ case CHARBULLET: if (I>0 || !finlist) printf("&#183;"/*"&middot;"*//*&sect;--middot hardly visible*/);
+ break;
+ case CHARPLUSMINUS: printf("&plusmn;"); break;
+ case CHARGT: printf("&gt;"); break;
+ case CHARLT: printf("&lt;"); break;
+ case CHARAMP: printf("&amp;"); break;
+ case CHARCENT: printf("&cent;"); break;
+ case CHARSECT: printf("&sect;"); break;
+ case CHARCOPYR: printf("&copy;"); break;
+ case CHARNOT: printf("&not;"); break;
+ case CHARREGTM: printf("&reg;"); break;
+ case CHARDEG: printf("&deg;"); break;
+ case CHARACUTE: printf("&acute;"); break;
+ case CHAR14: printf("&frac14;"); break;
+ case CHAR12: printf("&frac12;"); break;
+ case CHAR34: printf("&frac34;"); break;
+ case CHARMUL: printf("&#215;"); break;
+ case CHARDIV: printf("&#247;"); break;
+ default:
+ break;
+ }
+
+ /* while in pre mode... */
+ if (pre) {
+ switch (cmd) {
+ case ENDLINE: I=0; CurLine++; if (!fPara && scnt) printf("<br>"); printf("\n"); break;
+ case ENDTABLE:
+ if (fSource) {
+ printf("</table>\n");
+ } else {
+ printf("</pre><br>\n"); pre=0; fQS=fIQS=fPara=1;
+ }
+ break;
+ case ENDCODEBLOCK: printf("</pre>"); pre=0; break;
+ case SHORTLINE:
+ case ENDBODY:
+ printf("\n");
+ break;
+ case BEGINBOLD: printf("<b>"); break;
+ case ENDBOLD: printf("</b>"); break;
+ case BEGINITALICS: printf("<i>"); break;
+ case ENDITALICS: printf("</i>"); break;
+ default:
+ /* nothing */
+ break;
+ }
+ return;
+ }
+
+ /* usual operation */
+ switch (cmd) {
+ case BEGINDOC:
+ /* escchars = ... => HTML doesn't backslash-quote metacharacters */
+ printf("<!-- %s, -->\n", PROVENANCE);
+ printf("<!-- %s -->\n\n", HOME);
+ printf("<html>\n<head>\n");
+/* printf("<isindex>\n");*/
+ /* better title possible? */
+ printf("<title>"); printf(manTitle, manName, manSect); printf("</title>\n");
+#if defined(XOrg) || defined(XFree86)
+ printf("</head>\n<body bgcolor='#efefef' text='black' "
+ "link='blue' vlink='#551A8B' alink='red'>\n");
+#else
+ printf("</head>\n<body bgcolor='white'>\n");
+#endif
+ printf("<a href='#toc'>%s</a><p>\n", TABLEOFCONTENTS);
+ I=0;
+ break;
+ case ENDDOC:
+ /* header and footer wanted? */
+ printf("<p>\n");
+ if (fHeadfoot) {
+ printf("<hr><h2>%s</h2>\n", HEADERANDFOOTER);
+ for (i=0; i<CRUFTS; i++) if (*cruft[i]) printf("%s<br>\n", cruft[i]);
+ }
+
+ if (!tocc) {
+ /*printf("\n<h1>ERROR: Empty man page</h1>\n");*/
+ } else {
+ printf("\n<hr><p>\n");
+ printf("<a name='toc'><b>%s</b></a><p>\n", TABLEOFCONTENTS);
+ printf("<ul>\n");
+ for (i=0, lasttoc=BEGINSECTION; i<tocc; lasttoc=toc[i].type, i++) {
+ if (lasttoc!=toc[i].type) {
+ if (toc[i].type==BEGINSUBSECTION) printf("<ul>\n");
+ else printf("</ul>\n");
+ }
+ printf("<li><a name='toc%d' href='#sect%d'>%s</a></li>\n", i, i, toc[i].text);
+ }
+ if (lasttoc==BEGINSUBSECTION) printf("</ul>");
+ printf("</ul>\n");
+ }
+ printf("</body>\n</html>\n");
+ break;
+ case BEGINBODY:
+ printf("<p>\n");
+ break;
+ case ENDBODY: break;
+
+ case BEGINCOMMENT: printf("\n<!--\n"); break;
+ case ENDCOMMENT: printf("\n-->\n"); break;
+ case COMMENTLINE: printf(" "); break;
+
+ case BEGINSECTHEAD:
+ printf("\n<h2><a name='sect%d' href='#toc%d'>", tocc, tocc);
+ break;
+ case ENDSECTHEAD:
+ printf("</a></h2>\n");
+ /* useful extraction from FILES, ENVIRONMENT? */
+ break;
+ case BEGINSUBSECTHEAD:
+ printf("\n<h3><a name='sect%d' href='#toc%d'>", tocc, tocc);
+ break;
+ case ENDSUBSECTHEAD:
+ printf("</a></h3>\n");
+ break;
+ case BEGINSECTION: break;
+ case ENDSECTION:
+ if (sectheadid==NAME && message!=NULL) printf(message);
+ break;
+ case BEGINSUBSECTION: break;
+ case ENDSUBSECTION: break;
+
+ case BEGINBULPAIR:
+ if (listtype==OL) printf("\n<ol>\n");
+ else if (listtype==UL) printf("\n<ul>\n");
+ else printf("\n<dl>\n");
+ break;
+ case ENDBULPAIR:
+ if (listtype==OL) printf("\n</ol>\n");
+ else if (listtype==UL) printf("\n</ul>\n");
+ else printf("</dl>\n");
+ break;
+ case BEGINBULLET:
+ if (listtype==OL || listtype==UL) fcharout=0;
+ else printf("\n<dt>");
+ break;
+ case ENDBULLET:
+ if (listtype==OL || listtype==UL) fcharout=1;
+ else printf("</dt>");
+ break;
+ case BEGINBULTXT:
+ if (listtype==OL || listtype==UL) printf("<li>");
+ else printf("\n<dd>");
+ break;
+ case ENDBULTXT:
+ if (listtype==OL || listtype==UL) printf("</li>");
+ else printf("</dd>\n");
+ break;
+
+ case BEGINLINE:
+ /* if (ncnt) printf("<p>\n"); -- if haven't already generated structural tag */
+ if (ncnt) printf("\n<p>");
+
+ /* trailing spaces already trimmed off, so look for eol now */
+ if (fCodeline) {
+ printf("<code>");
+ for (i=0; i<scnt-indent; i++) printf("&nbsp;"/*&#160;*/); /* ? */
+ tagc=0;
+
+ /* already have .tag=BOLDITALICS, .first=0 */
+ /* would be more elegant, but can't print initial spaces before first tag
+ tags[0].last = linelen;
+ tagc=1;
+ fIQS=0;
+ */
+ }
+
+ break;
+
+ case ENDLINE:
+ /*if (fCodeline) { fIQS=1; fCodeline=0; }*/
+ if (fCodeline) { printf("</code><br>"); fCodeline=0; }
+ I=0; CurLine++; if (!fPara && scnt) printf("<br>"); printf("\n");
+ break;
+
+ case SHORTLINE:
+ if (fCodeline) { printf("</code>"); fCodeline=0; }
+ if (!fIP) printf("<br>\n");
+ break;
+
+
+ case BEGINTABLE:
+ if (fSource) {
+ /*printf("<center><table border>\n");*/
+ printf("<table border='0'>\n");
+ } else {
+ printf("<br><pre>\n"); pre=1; fQS=fIQS=fPara=0;
+ }
+ break;
+ case ENDTABLE:
+ if (fSource) {
+ printf("</table>\n");
+ } else {
+ printf("</pre><br>\n"); pre=0; fQS=fIQS=fPara=1;
+ }
+ break;
+ case BEGINTABLELINE: printf("<tr>"); break;
+ case ENDTABLELINE: printf("</tr>\n"); break;
+ case BEGINTABLEENTRY:
+ printf("<td align='");
+ switch (tblcellformat[0]) {
+ case 'c': printf("center"); break;
+ case 'n': /*printf("decimal"); break; -- fall through to right for now */
+ case 'r': printf("right"); break;
+ case 'l':
+ default:
+ printf("left");
+ }
+ if (tblcellspan>1) printf(" colspan=%d", tblcellspan);
+ printf("'>");
+ break;
+ case ENDTABLEENTRY:
+ printf("</td>");
+ break;
+
+ /* something better with CSS */
+ case BEGININDENT: printf("<blockquote>"); break;
+ case ENDINDENT: printf("</blockquote>\n"); break;
+
+ case FONTSIZE:
+ /* HTML font step sizes are bigger than troff's */
+ if ((fontdelta+=intArg)!=0) printf("<font size='%c1'>", (intArg>0)?'+':'-'); else printf("</font>\n");
+ break;
+
+ case BEGINBOLD: printf("<b>"); break;
+ case ENDBOLD: printf("</b>"); break;
+ case BEGINITALICS: printf("<i>"); break;
+ case ENDITALICS: printf("</i>"); break;
+ case BEGINBOLDITALICS:
+ case BEGINCODE: printf("<code>"); break;
+ case ENDBOLDITALICS:
+ case ENDCODE: printf("</code>"); break;
+ case BEGINCODEBLOCK: printf("<pre>"); pre=1; break; /* wrong for two-column lists in kermit.1, pine.1, perl4.1 */
+ case ENDCODEBLOCK: printf("</pre>"); pre=0; break;
+ case BEGINCENTER: printf("<center>"); break;
+ case ENDCENTER: printf("</center>"); break;
+ case BEGINMANREF:
+ manrefextract(hitxt);
+ if (fmanRef) { printf("<a href='"); printf(href, manrefname, manrefsect); printf("'>"); }
+ else printf("<i>");
+ break;
+ case ENDMANREF:
+ if (fmanRef) printf("</a>\n"); else printf("</i>");
+ break;
+ case HR: printf("\n<hr>\n"); break;
+
+ /* U (was B, I), strike -- all temporary until HTML 4.0's INS and DEL widespread */
+ case BEGINDIFFA: printf("<ins><u>"); break;
+ case ENDDIFFA: printf("</u></ins>"); break;
+ case BEGINDIFFD: printf("<del><strike>"); break;
+ case ENDDIFFD: printf("</strike></del>"); break;
+
+ case BEGINSC: case ENDSC:
+ case BEGINY: case ENDY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case CHANGEBAR:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+
+/*
+ * DocBook XML
+ * improvements by Aaron Hawley applied 2003 June 5
+ *
+ * N.B. The framework for XML is in place but not done. If you
+ * are familiar with the DocBook DTD, however, it shouldn't be
+ * too difficult to finish it. If you do so, please send your
+ * code to me so that I may share the wealth in the next release.
+ */
+
+const char *DOCBOOKPATH = "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd";
+
+static void
+XML(enum command cmd)
+{
+ static int pre=0;
+ int i;
+ char *p;
+ static int fRefEntry=0;
+ static int fRefPurpose=0;
+ /*static char *bads => XML doesn't backslash-quote metacharacters */
+
+/*
+*/
+
+ /* always respond to these signals */
+ switch (cmd) {
+ case CHARLQUOTE: case CHARRQUOTE: printf("&quot;"); break;
+ case CHARBULLET: printf("&bull;"); break;
+ case CHARDAGGER: printf("&dagger;"); break;
+ case CHARPLUSMINUS: printf("&plusmn;"); break;
+ case CHARCOPYR: printf("&copy;"); break;
+ case CHARNOT: printf("&not;"); break;
+ case CHARMUL: printf("&times;"); break;
+ case CHARDIV: printf("&divide;"); break;
+ case CHARAMP: printf("&amp;"); break;
+ case CHARDASH:
+ if (sectheadid==NAME && !fRefPurpose) {
+ printf("</refname><refpurpose>");
+ fRefPurpose=1;
+ } else putchar('-');
+ break;
+ case CHARBACKSLASH: putchar('\\'); break;
+ case CHARGT: printf("&gt;"); break;
+ case CHARLT: printf("&lt;"); break;
+ case CHARLSQUOTE:
+ case CHARRSQUOTE:
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARNBSP:
+ case CHARCENT:
+ case CHARSECT:
+ case CHARREGTM:
+ case CHARDEG:
+ case CHARACUTE:
+ case CHAR14:
+ case CHAR12:
+ case CHAR34:
+ putchar(cmd);
+ break;
+ default:
+ break;
+ }
+
+ /* while in pre mode... */
+ if (pre) {
+ switch (cmd) {
+ case ENDLINE: I=0; CurLine++; if (!fPara && scnt) putchar(' '); break;
+ case ENDTABLE:
+ if (fSource) printf("</table>\n");
+ else { printf("</literallayout>\n"); pre=0; fQS=fIQS=fPara=1; }
+ break;
+ default:
+ /* nothing */
+ break;
+ }
+ return;
+ }
+
+ /* usual operation */
+ switch (cmd) {
+ case BEGINDOC:
+ printf("\n<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.1.2//EN\"\n");
+ printf(" \"%s\">\n", DOCBOOKPATH);
+
+ printf("<!--\n\n\tI am looking for help to finish DocBook XML.\n\n-->\n");
+
+ printf("<!-- %s\n", PROVENANCE);
+ printf(" %s -->\n\n",HOME);
+ /* better title possible? */
+ for (p=manName; *p; p++) *p = tolower(*p);
+ printf("<refentry id='%s.%s'>\n", manName, manSect);
+ printf("<refmeta>\n<refentrytitle>%s</refentrytitle>\n", manName);
+ printf("<manvolnum>%s</manvolnum>\n</refmeta>\n\n", manSect);
+
+ I=0;
+ break;
+
+ case ENDDOC:
+ /* header and footer wanted? */
+ if (fHeadfoot) {
+ printf("\n<refsect1>\n<title>%s</title>\n", HEADERANDFOOTER);
+ for (i=0; i<CRUFTS; i++) if (*cruft[i]) printf("<para>%s</para>\n", cruft[i]);
+ printf("\n</refsect1>");
+ }
+
+ /* table of contents, such as found in HTML, can be generated automatically by XML software */
+
+ printf("</refentry>\n");
+ break;
+ case BEGINBODY:
+ if (fPara) printf("\n</para>");
+ printf("<para>"); fPara = 1;
+ break;
+ case ENDBODY:
+ if (fRefPurpose) { printf("</refpurpose>"); fRefPurpose=0; }
+ else { printf("\n</para>"); fPara=0; }
+ break;
+
+ case BEGINCOMMENT: printf("\n<!--\n"); break;
+ case ENDCOMMENT: printf("\n-->\n"); break;
+ case COMMENTLINE: break;
+
+ case BEGINSECTHEAD:
+ case BEGINSUBSECTHEAD:
+ if (sectheadid != NAME && sectheadid != SYNOPSIS) printf("<title>");
+ break;
+ case ENDSECTHEAD:
+ case ENDSUBSECTHEAD:
+ if (sectheadid == NAME) printf("<refname>");
+ else if (sectheadid == SYNOPSIS) {}
+ else { printf("</title>\n<para>"); fPara=1; }
+ break;
+
+ case BEGINSECTION:
+ if (sectheadid==NAME) printf("<refnamediv>\n");
+ /*printf("<RefEntry>"); -- do lotsa parsing here for RefName, RefPurpose*/
+ else if (sectheadid==SYNOPSIS) printf("<refsynopsisdiv>\n<cmdsynopsis>\n");
+ else printf("\n<refsect1>\n");
+ break;
+ case ENDSECTION:
+ if (sectheadid==NAME) {
+ if (fRefPurpose) { printf("</refpurpose>"); fRefPurpose=0; }
+ printf("\n</refnamediv>\n\n");
+ } else if (sectheadid==SYNOPSIS) printf("\n</cmdsynopsis>\n</refsynopsisdiv>\n");
+ else {
+ if (fPara) { printf("\n</para>"); fPara=0; }
+ printf("\n</refsect1>\n");
+ }
+ break;
+
+ case BEGINSUBSECTION: printf("\n<refsect2>"); break;
+ case ENDSUBSECTION: printf("\n</refsect2>"); break;
+
+ /* need to update this for enumerated and plain lists */
+ case BEGINBULPAIR: printf("<variablelist>\n"); break;
+ case ENDBULPAIR: printf("</variablelist>\n"); break;
+ case BEGINBULLET: printf("<term>"); break;
+ case ENDBULLET: printf("</term>\n"); break;
+ case BEGINBULTXT: printf("<listitem>\n<para>"); break;
+ case ENDBULTXT: printf("\n</para></listitem>\n"); break;
+
+ case BEGINLINE:
+ /* remember, get BEGINBODY call at start of paragraph */
+ if (fRefEntry) {
+ if (fRefPurpose) {
+ for (p=plain; *p!='-'; p++) {
+ /* nothing?! */
+ }
+ }
+ }
+
+ break;
+
+ case ENDLINE:
+ /*if (fCodeline) { fIQS=1; fCodeline=0; }*/
+ if (fCodeline) { printf("</code>"); fCodeline=0; } /* */
+ I=0; CurLine++; if (!fPara && scnt) printf("<sbr/>"); else putchar(' ');
+ break;
+
+ case SHORTLINE:
+ if (fCodeline) { printf("</code>"); fCodeline=0; }
+ if (!fIP && !fPara) printf("<sbr/>\n");
+ break;
+
+ case BEGINTABLE:
+ if (fSource) printf("<table>\n");
+ else { printf("<literallayout>\n"); pre=1; fQS=fIQS=fPara=0; }
+ break;
+ case ENDTABLE:
+ if (fSource) printf("</table>\n");
+ else { printf("</literallayout>\n"); pre=0; fQS=fIQS=fPara=1; }
+ break;
+ case BEGINTABLELINE: printf("<row>"); break;
+ case ENDTABLELINE: printf("</row>\n"); break;
+ case BEGINTABLEENTRY: printf("<entry>"); break;
+ case ENDTABLEENTRY: printf("</entry>"); break;
+
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ break;
+
+ /* have to make some guess about bold and italics */
+ case BEGINBOLD: printf("<command>"); break;
+ case ENDBOLD: printf("</command>"); break;
+ case BEGINITALICS: printf("<emphasis>"); break; /* could be literal or arg */
+ case ENDITALICS: printf("</emphasis>"); break;
+ case BEGINBOLDITALICS: case BEGINCODE: printf("<literal>"); break;
+ case ENDBOLDITALICS: case ENDCODE: printf("</literal>"); break;
+ case BEGINMANREF:
+ manrefextract(hitxt);
+ if (fmanRef) { printf("<link linkend='"); printf(href, manrefname, manrefsect); printf("'>"); }
+ break;
+ case ENDMANREF:
+ if (fmanRef) printf("</link>");
+ break;
+
+ case HR:
+ case BEGINSC: case ENDSC:
+ case BEGINY: case ENDY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case CHANGEBAR:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+
+/* generates MIME compliant to RFC 1563 */
+
+static void
+MIME(enum command cmd)
+{
+ static int pre=0;
+ int i;
+
+ /* always respond to these signals */
+ switch (cmd) {
+ case CHARDASH:
+ case CHARAMP:
+ case CHARPERIOD:
+ case CHARTAB:
+ putchar(cmd); break;
+ case CHARLSQUOTE: putchar('`'); break;
+ case CHARACUTE:
+ case CHARRSQUOTE: putchar('\''); break;
+ case CHARBULLET: putchar('*'); break;
+ case CHARDAGGER: putchar('|'); break;
+ case CHARPLUSMINUS: printf("+-"); break;
+ case CHARNBSP: putchar(' '); break;
+ case CHARCENT: putchar('c'); break;
+ case CHARSECT: putchar('S'); break;
+ case CHARCOPYR: printf("(C)"); break;
+ case CHARNOT: putchar('~'); break;
+ case CHARREGTM: printf("(R)"); break;
+ case CHARDEG: putchar('o'); break;
+ case CHAR14: printf("1/4"); break;
+ case CHAR12: printf("1/2"); break;
+ case CHAR34: printf("3/4"); break;
+ case CHARMUL: putchar('X'); break;
+ case CHARDIV: putchar('/'); break;
+ case CHARLQUOTE:
+ case CHARRQUOTE:
+ putchar('"');
+ break;
+ case CHARBACKSLASH: /* these should be caught as escaped chars */
+ case CHARGT:
+ case CHARLT:
+#if 0
+ assert(1);
+#endif
+ break;
+ default:
+ break;
+ }
+
+ /* while in pre mode... */
+ if (pre) {
+ switch (cmd) {
+ case ENDLINE: I=0; CurLine++; if (!fPara && scnt) printf("\n\n"); break;
+ case ENDTABLE: printf("</fixed>\n\n"); pre=0; fQS=fIQS=fPara=1; break;
+ default:
+ /* nothing */
+ break;
+ }
+ return;
+ }
+
+ /* usual operation */
+ switch (cmd) {
+ case BEGINDOC:
+ printf("Content-Type: text/enriched\n");
+ printf("Text-Width: 60\n");
+ escchars = "<>\\";
+
+ I=0;
+ break;
+ case ENDDOC:
+ /* header and footer wanted? */
+ printf("\n\n");
+ if (fHeadfoot) {
+ printf("\n");
+ MIME(BEGINSECTHEAD); printf("%s",HEADERANDFOOTER); MIME(ENDSECTHEAD);
+ for (i=0; i<CRUFTS; i++) if (*cruft[i]) printf("\n%s\n", cruft[i]);
+ }
+
+/*
+ printf("\n<comment>\n");
+ printf("%s\n%s\n", PROVENANCE, HOME);
+ printf("</comment>\n\n");
+*/
+
+/*
+ printf("\n<HR><P>\n");
+ printf("<A NAME=\"toc\"><B>%s</B></A><P>\n", TABLEOFCONTENTS);
+ printf("<UL>\n");
+ for (i=0, lasttoc=BEGINSECTION; i<tocc; lasttoc=toc[i].type, i++) {
+ if (lasttoc!=toc[i].type) {
+ if (toc[i].type==BEGINSUBSECTION) printf("<UL>\n");
+ else printf("</UL>\n");
+ }
+ printf("<LI><A NAME=\"toc%d\" HREF=\"#sect%d\">%s</A></LI>\n", i, i, toc[i].text);
+ }
+ if (lasttoc==BEGINSUBSECTION) printf("</UL>");
+ printf("</UL>\n");
+ printf("</BODY></HTML>\n");
+*/
+ break;
+ case BEGINBODY:
+ printf("\n\n");
+ break;
+ case ENDBODY: break;
+
+ case BEGINCOMMENT: fcharout=0; break;
+ case ENDCOMMENT: fcharout=1; break;
+ case COMMENTLINE: break;
+
+ case BEGINSECTHEAD:
+ printf("\n<bigger><bigger><underline>");
+ /*A NAME=\"sect%d\" HREF=\"#toc%d\"><H2>", tocc, tocc);*/
+ break;
+ case ENDSECTHEAD:
+ printf("</underline></bigger></bigger>\n\n<indent>");
+ /* useful extraction from files, environment? */
+ break;
+ case BEGINSUBSECTHEAD:
+ printf("<bigger>");
+ /*\n<A NAME=\"sect%d\" HREF=\"#toc%d\"><H3>", tocc, tocc);*/
+ break;
+ case ENDSUBSECTHEAD:
+ printf("</bigger>\n\n</indent>");
+ break;
+ case BEGINSECTION:
+ case BEGINSUBSECTION:
+ break;
+ case ENDSECTION:
+ case ENDSUBSECTION:
+ printf("</indent>\n");
+ break;
+
+ case BEGINBULPAIR: break;
+ case ENDBULPAIR: break;
+ case BEGINBULLET: printf("<bold>"); break;
+ case ENDBULLET: printf("</bold>\t"); break;
+ case BEGINBULTXT:
+ case BEGININDENT:
+ printf("<indent>");
+ break;
+ case ENDBULTXT:
+ case ENDINDENT:
+ printf("</indent>\n");
+ break;
+
+ case FONTSIZE:
+ if ((fontdelta+=intArg)==0) {
+ if (intArg>0) printf("</smaller>"); else printf("</bigger>");
+ } else {
+ if (intArg>0) printf("<bigger>"); else printf("<smaller>");
+ }
+ break;
+
+ case BEGINLINE: /*if (ncnt) printf("\n\n");*/ break;
+ case ENDLINE: I=0; CurLine++; printf("\n"); break;
+ case SHORTLINE: if (!fIP) printf("\n\n"); break;
+ case BEGINTABLE: printf("<nl><fixed>\n"); pre=1; fQS=fIQS=fPara=0; break;
+ case ENDTABLE: printf("</fixed><nl>\n"); pre=0; fQS=fIQS=fPara=1; break;
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ break;
+ /* could use a new list type */
+
+ case BEGINBOLD: printf("<bold>"); break;
+ case ENDBOLD: printf("</bold>"); break;
+ case BEGINITALICS: printf("<italics>"); break;
+ case ENDITALICS: printf("</italics>"); break;
+ case BEGINCODE:
+ case BEGINBOLDITALICS:printf("<bold><italics>"); break;
+ case ENDCODE:
+ case ENDBOLDITALICS: printf("</bold></italics>"); break;
+ case BEGINMANREF:
+ printf("<x-color><param>blue</param>");
+/* how to make this hypertext?
+ manrefextract(hitxt);
+ if (fmanRef) { printf("<A HREF=\""); printf(href, manrefname, manrefsect); printf("\">\n"); }
+ else printf("<I>");
+ break;
+*/
+ break;
+ case ENDMANREF:
+ printf("</x-color>");
+ break;
+
+ case HR: printf("\n\n%s\n\n", horizontalrule); break;
+
+ case BEGINSC: case ENDSC:
+ case BEGINY: case ENDY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case CHANGEBAR:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+
+/*
+ * LaTeX
+ */
+
+static void
+LaTeX(enum command cmd)
+{
+
+ switch (cmd) {
+ case BEGINDOC:
+ escchars = "$&%#_{}"; /* and more to come? */
+ printf("%% %s,\n", PROVENANCE);
+ printf("%% %s\n\n", HOME);
+ /* definitions */
+ printf(
+ "\\documentstyle{article}\n"
+ "\\def\\thefootnote{\\fnsymbol{footnote}}\n"
+ "\\setlength{\\parindent}{0pt}\n"
+ "\\setlength{\\parskip}{0.5\\baselineskip plus 2pt minus 1pt}\n"
+ "\\begin{document}\n"
+ );
+ I=0;
+ break;
+ case ENDDOC:
+ /* header and footer wanted? */
+ printf("\n\\end{document}\n");
+
+ break;
+ case BEGINBODY:
+ printf("\n\n");
+ break;
+ case ENDBODY: break;
+
+ case BEGINCOMMENT:
+ case ENDCOMMENT:
+ break;
+ case COMMENTLINE: printf("%% "); break;
+
+
+ case BEGINSECTION: break;
+ case ENDSECTION: break;
+ case BEGINSECTHEAD: printf("\n\\section{"); tagc=0; break;
+ case ENDSECTHEAD:
+ printf("}");
+/*
+ if (CurLine==1) printf("\\footnote{"
+ "\\it conversion to \\LaTeX\ format by PolyglotMan "
+ "available via anonymous ftp from {\\tt ftp.berkeley.edu:/ucb/people/phelps/tcltk}}"
+ );
+*/
+ /* useful extraction from files, environment? */
+ printf("\n");
+ break;
+ case BEGINSUBSECTHEAD:printf("\n\\subsection{"); break;
+ case ENDSUBSECTHEAD:
+ printf("}");
+ break;
+ case BEGINSUBSECTION: break;
+ case ENDSUBSECTION: break;
+ case BEGINBULPAIR: printf("\\begin{itemize}\n"); break;
+ case ENDBULPAIR: printf("\\end{itemize}\n"); break;
+ case BEGINBULLET: printf("\\item ["); break;
+ case ENDBULLET: printf("] "); break;
+ case BEGINLINE: /*if (ncnt) printf("\n\n");*/ break;
+ case ENDLINE: I=0; putchar('\n'); CurLine++; break;
+ case BEGINTABLE: printf("\\begin{verbatim}\n"); break;
+ case ENDTABLE: printf("\\end{verbatim}\n"); break;
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ break;
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ break;
+ case SHORTLINE: if (!fIP) printf("\n\n"); break;
+ case BEGINBULTXT: break;
+ case ENDBULTXT: putchar('\n'); break;
+
+ case CHARLQUOTE: printf("``"); break;
+ case CHARRQUOTE: printf("''"); break;
+ case CHARLSQUOTE:
+ case CHARRSQUOTE:
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARNBSP:
+ putchar(cmd); break;
+ case CHARBACKSLASH: printf("$\\backslash$"); break;
+ case CHARGT: printf("$>$"); break;
+ case CHARLT: printf("$<$"); break;
+ case CHARHAT: printf("$\\char94{}$"); break;
+ case CHARVBAR: printf("$|$"); break;
+ case CHARAMP: printf("\\&"); break;
+ case CHARBULLET: printf("$\\bullet$ "); break;
+ case CHARDAGGER: printf("\\dag "); break;
+ case CHARPLUSMINUS: printf("\\pm "); break;
+ case CHARCENT: printf("\\hbox{\\rm\\rlap/c}"); break;
+ case CHARSECT: printf("\\S "); break;
+ case CHARCOPYR: printf("\\copyright "); break;
+ case CHARNOT: printf("$\\neg$"); break;
+ case CHARREGTM: printf("(R)"); break;
+ case CHARDEG: printf("$^\\circ$"); break;
+ case CHARACUTE: putchar('\''); break;
+ case CHAR14: printf("$\\frac{1}{4}$"); break;
+ case CHAR12: printf("$\\frac{1}{2}$"); break;
+ case CHAR34: printf("$\\frac{3}{4}$"); break;
+ case CHARMUL: printf("\\times "); break;
+ case CHARDIV: printf("\\div "); break;
+
+ case BEGINCODE:
+ case BEGINBOLD: printf("{\\bf "); break; /* } */
+ case BEGINSC: printf("{\\sc "); break; /* } */
+ case BEGINITALICS: printf("{\\it "); break; /* } */
+ case BEGINBOLDITALICS:printf("{\\bf\\it "); break; /* } */
+ case BEGINMANREF: printf("{\\sf "); break; /* } */
+ case ENDCODE:
+ case ENDBOLD:
+ case ENDSC:
+ case ENDITALICS:
+ case ENDBOLDITALICS:
+ case ENDMANREF: /* { */
+ putchar('}');
+ break;
+ case HR: /*printf("\n%s\n", horizontalrule);*/ break;
+
+ case BEGINY: case ENDY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case CHANGEBAR:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+static void
+LaTeX2e(enum command cmd)
+{
+ switch (cmd) {
+ /* replace selected commands ... */
+ case BEGINDOC:
+ escchars = "$&%#_{}";
+ printf("%% %s,\n", PROVENANCE);
+ printf("%% %s\n\n", HOME);
+ /* definitions */
+ printf(
+ "\\documentclass{article}\n"
+ "\\def\\thefootnote{\\fnsymbol{footnote}}\n"
+ "\\setlength{\\parindent}{0pt}\n"
+ "\\setlength{\\parskip}{0.5\\baselineskip plus 2pt minus 1pt}\n"
+ "\\begin{document}\n"
+ );
+ I=0;
+ break;
+ case BEGINCODE:
+ case BEGINBOLD: printf("\\textbf{"); break; /* } */
+ case BEGINSC: printf("\\textsc{"); break; /* } */
+ case BEGINITALICS: printf("\\textit{"); break; /* } */
+ case BEGINBOLDITALICS:printf("\\textbf{\\textit{"); break; /* }} */
+ case BEGINMANREF: printf("\\textsf{"); break; /* } {{ */
+ case ENDBOLDITALICS: printf("}}"); break;
+
+ /* ... rest same as old LaTeX */
+ default:
+ LaTeX(cmd);
+ }
+}
+
+
+
+/*
+ * Rich Text Format (RTF)
+ */
+
+/* RTF could use more work */
+
+static void
+RTF(enum command cmd)
+{
+
+ switch (cmd) {
+ case BEGINDOC:
+ escchars = "{}";
+ /* definitions */
+ printf(
+ /* fonts */
+ "{\\rtf1\\deff2 {\\fonttbl"
+ "{\\f20\\froman Times;}{\\f150\\fnil I Times Italic;}"
+ "{\\f151\\fnil B Times Bold;}{\\f152\\fnil BI Times BoldItalic;}"
+ "{\\f22\\fmodern Courier;}{\\f23\\ftech Symbol;}"
+ "{\\f135\\fnil I Courier Oblique;}{\\f136\\fnil B Courier Bold;}{\\f137\\fnil BI Courier BoldOblique;}"
+ "{\\f138\\fnil I Helvetica Oblique;}{\\f139\\fnil B Helvetica Bold;}}"
+ "\n"
+
+ /* style sheets */
+ "{\\stylesheet{\\li720\\sa120 \\f20 \\sbasedon222\\snext0 Normal;}"
+ "{\\s2\\sb200\\sa120 \\b\\f3\\fs20 \\sbasedon0\\snext2 section head;}"
+ "{\\s3\\li180\\sa120 \\b\\f20 \\sbasedon0\\snext3 subsection head;}"
+ "{\\s4\\fi-1440\\li2160\\sa240\\tx2160 \\f20 \\sbasedon0\\snext4 detailed list;}}"
+ "\n"
+
+/* more header to come--do undefined values default to nice values? */
+ );
+ I=0;
+ break;
+ case ENDDOC:
+ /* header and footer wanted? */
+ printf("\\par{\\f150 %s,\n%s}", PROVENANCE, HOME);
+ printf("}\n");
+ break;
+ case BEGINBODY:
+ printf("\n\n");
+ break;
+ case ENDBODY:
+ CurLine++;
+ printf("\\par\n");
+ tagc=0;
+ break;
+
+ case BEGINCOMMENT: fcharout=0; break;
+ case ENDCOMMENT: fcharout=1; break;
+ case COMMENTLINE: break;
+
+ case BEGINSECTION: break;
+ case ENDSECTION: printf("\n\\par\n"); break;
+ case BEGINSECTHEAD: printf("{\\s2 "); tagc=0; break;
+ case ENDSECTHEAD:
+ printf("}\\par");
+ /* useful extraction from files, environment? */
+ printf("\n");
+ break;
+ case BEGINSUBSECTHEAD:printf("{\\s3 "); break;
+ case ENDSUBSECTHEAD:
+ printf("}\\par\n");
+ break;
+ case BEGINSUBSECTION: break;
+ case ENDSUBSECTION: break;
+ case BEGINLINE: /*if (ncnt) printf("\n\n");*/ break;
+ case ENDLINE: I=0; putchar(' '); /*putchar('\n'); CurLine++;*/ break;
+ case SHORTLINE: if (!fIP) printf("\\line\n"); break;
+ case BEGINBULPAIR: printf("{\\s4 "); break;
+ case ENDBULPAIR: printf("}\\par\n"); break;
+ case BEGINBULLET: break;
+ case ENDBULLET: printf("\\tab "); fcharout=0; break;
+ case BEGINBULTXT: fcharout=1; break;
+ case ENDBULTXT: break;
+
+ case CHARLQUOTE: printf("``"); break;
+ case CHARRQUOTE: printf("''"); break;
+ case CHARLSQUOTE:
+ case CHARRSQUOTE:
+ case CHARPERIOD:
+ case CHARTAB:
+ case CHARDASH:
+ case CHARBACKSLASH:
+ case CHARGT:
+ case CHARLT:
+ case CHARHAT:
+ case CHARVBAR:
+ case CHARAMP:
+ case CHARNBSP:
+ case CHARCENT:
+ case CHARSECT:
+ case CHARCOPYR:
+ case CHARNOT:
+ case CHARREGTM:
+ case CHARDEG:
+ case CHARACUTE:
+ case CHAR14:
+ case CHAR12:
+ case CHAR34:
+ case CHARMUL:
+ case CHARDIV:
+ putchar(cmd); break;
+ case CHARBULLET: printf("\\bullet "); break;
+ case CHARDAGGER: printf("\\dag "); break;
+ case CHARPLUSMINUS: printf("\\pm "); break;
+
+ case BEGINCODE:
+ case BEGINBOLD: printf("{\\b "); break; /* } */
+ case BEGINSC: printf("{\\fs20 "); break; /* } */
+ case BEGINITALICS: printf("{\\i "); break; /* } */
+ case BEGINBOLDITALICS:printf("{\\b \\i "); break; /* } */
+ case BEGINMANREF: printf("{\\f22 "); break; /* } */
+ case ENDBOLD:
+ case ENDCODE:
+ case ENDSC:
+ case ENDITALICS:
+ case ENDBOLDITALICS:
+ case ENDMANREF: /* { */
+ putchar('}');
+ break;
+ case HR: printf("\n%s\n", horizontalrule); break;
+
+ case BEGINY: case ENDY:
+ case BEGINHEADER: case ENDHEADER:
+ case BEGINFOOTER: case ENDFOOTER:
+ case BEGINTABLE: case ENDTABLE:
+ case BEGINTABLELINE: case ENDTABLELINE: case BEGINTABLEENTRY: case ENDTABLEENTRY:
+ case BEGININDENT: case ENDINDENT:
+ case FONTSIZE:
+ case CHANGEBAR:
+ /* nothing */
+ break;
+ default:
+ DefaultPara(cmd);
+ }
+}
+
+
+
+/*
+ * pointers to existing tools
+ */
+
+static void
+PostScript(enum command cmd)
+{
+ fprintf(stderr, "Use groff or psroff to generate PostScript.\n");
+ exit(1);
+}
+
+
+static void
+FrameMaker(enum command cmd)
+{
+ fprintf(stderr, "FrameMaker comes with filters that convert from roff to MIF.\n");
+ exit(1);
+}
+
+
+
+
+/*
+ * Utilities common to both parses
+ */
+
+
+/*
+ level 0: DOC - need match
+ level 1: SECTION - need match
+ level 2: SUBSECTION | BODY | BULLETPAIR
+ level 3: BODY (within SUB) | BULLETPAIR (within SUB) | BULTXT (within BULLETPAIR)
+ level 4: BULTXT (within BULLETPAIR within SUBSECTION)
+
+ never see: SECTHEAD, SUBSECTHEAD, BULLET
+*/
+
+int Psect=0, Psub=0, Pbp=0, Pbt=0, Pb=0, Pbul=0;
+
+static void
+pop(enum command cmd)
+{
+ assert(cmd==ENDINDENT || cmd==BEGINBULLET || cmd==BEGINBULTXT || cmd==BEGINBULPAIR || cmd==BEGINBODY || cmd==BEGINSECTION || cmd==BEGINSUBSECTION || cmd==ENDDOC);
+/*
+ int i;
+ int p;
+ int match;
+
+ p=cmdp-1;
+ for (i=cmdp-1;i>=0; i--)
+ if (cmd==cmdstack[i]) { match=i; break; }
+*/
+
+ /* if match, pop off all up to and including match */
+ /* otherwise, pop off one level*/
+
+ if (Pbul) {
+ (*fn)(ENDBULLET); Pbul=0;
+ if (cmd==BEGINBULLET) return;
+ } /* else close off ENDBULTXT */
+
+ if (Pbt) { (*fn)(ENDBULTXT); Pbt=0; }
+ if (cmd==BEGINBULTXT || cmd==BEGINBULLET) return;
+
+ if (Pb && cmd==BEGINBULPAIR) { (*fn)(ENDBODY); Pb=0; } /* special */
+ if (Pbp) { (*fn)(ENDBULPAIR); Pbp=0; }
+ if (cmd==BEGINBULPAIR || cmd==ENDINDENT) return;
+
+ if (Pb) { (*fn)(ENDBODY); Pb=0; }
+ if (cmd==BEGINBODY) return;
+
+ if (Psub) { (*fn)(ENDSUBSECTION); Psub=0; }
+ if (cmd==BEGINSUBSECTION) return;
+
+ if (Psect) { (*fn)(ENDSECTION); Psect=0; }
+ if (cmd==BEGINSECTION) return;
+}
+
+
+static void
+poppush(enum command cmd)
+{
+ assert(cmd==ENDINDENT || cmd==BEGINBULLET || cmd==BEGINBULTXT || cmd==BEGINBULPAIR || cmd==BEGINBODY || cmd==BEGINSECTION || cmd==BEGINSUBSECTION);
+
+ pop(cmd);
+
+ switch (cmd) {
+ case BEGINBULLET: Pbul=1; break;
+ case BEGINBULTXT: Pbt=1; break;
+ case BEGINBULPAIR: Pbp=1; break;
+ case BEGINBODY: Pb=1; break;
+ case BEGINSECTION: Psect=1; break;
+ case BEGINSUBSECTION: Psub=1; break;
+ default:
+ if (!fQuiet) fprintf(stderr, "poppush: unrecognized code %d\n", cmd);
+ }
+
+ (*fn)(cmd);
+ prevcmd = cmd;
+}
+
+
+
+/*
+ * PREFORMATTED PAGES PARSING
+ */
+
+/* wrapper for getchar() that expands tabs, and sends maximum of n=40 consecutive spaces */
+
+static int
+getchartab(void)
+{
+ static int tabexp = 0;
+ static int charinline = 0;
+ static int cspccnt = 0;
+ char c;
+
+ c = lookahead;
+ if (tabexp) tabexp--;
+ else if (c=='\n') {
+ charinline=0;
+ cspccnt=0;
+ } else if (c=='\t') {
+ tabexp = TabStops-(charinline%TabStops); if (tabexp==TabStops) tabexp=0;
+ lookahead = c = ' ';
+ } else if (cspccnt>=40) {
+ if (*in==' ') {
+ while (*in==' '||*in=='\t') in++;
+ in--;
+ }
+ cspccnt=0;
+ }
+
+ if (!tabexp && lookahead) lookahead = *in++;
+ if (c=='\b') charinline--; else charinline++;
+ if (c==' ') cspccnt++;
+ return c;
+}
+
+
+/* replace gets. handles hyphenation too */
+static char *
+la_gets(char *buf)
+{
+ static char la_buf[MAXBUF]; /* can lookahead a full line, but nobody does now */
+ static int fla=0, hy=0;
+ char *ret,*p;
+ int c,i;
+
+ assert(buf!=NULL);
+
+ if (fla) {
+ /* could avoid copying if callers used return value */
+ strcpy(buf,la_buf); fla=0;
+ ret=buf; /* correct? */
+ } else {
+ /*ret=gets(buf); -- gets is deprecated (since it can read too much?) */
+ /* could do this...
+ ret=fgets(buf, MAXBUF, stdin);
+ buf[strlen(buf)-1]='\0';
+ ... but don't want to have to rescan line with strlen, so... */
+
+ i=0; p=buf;
+
+ /* recover spaces if re-linebreaking */
+ for (; hy; hy--) { *p++=' '; i++; }
+
+ while (lookahead && (c=getchartab())!='\n' && i<MAXBUF) { *p++=c; i++; }
+ assert(i<MAXBUF);
+
+#if 0
+ lookahead=ungetc(getchar(), stdin); /* only looking ahead one character for now */
+#endif
+
+ /* very special case: if in SEE ALSO section, re-linebreak so references aren't linebroken
+ (also do this if fNOHY flag is set) -- doesn't affect lookahead */
+ /* 0xad is an en dash on Linux? */
+ if ((fPara || sectheadid==SEEALSO || fNOHY) && p>buf && p[-1]=='-' && isspace(lookahead)) {
+ p--; /* zap hyphen */
+ /* zap boldfaced hyphens, gr! */
+ while (p[-1]=='\b' && p[-2]=='-') p-=2;
+
+ /* start getting next line, spaces first ... */
+ while (lookahead && isspace(lookahead) && lookahead!='\n') { getchartab(); hy++; }
+
+ /* ... append next nonspace string to previous ... */
+ while (lookahead && !isspace(lookahead) && i++<MAXBUF) *p++=getchartab();
+
+ /* gobble following spaces (until, perhaps including, end of line) */
+ while (lookahead && isspace(lookahead) && lookahead!='\n') getchartab();
+ if (lookahead=='\n') { getchartab(); hy=0; }
+ }
+
+ *p='\0';
+ ret=(lookahead)?buf:NULL;
+ }
+
+ AbsLine++;
+ return ret; /* change this to line length? (-1==old NULL) */
+}
+
+
+/*** Kong ***/
+
+char phrase[MAXBUF]; /* first "phrase" (space of >=3 spaces) */
+int phraselen;
+
+static void
+filterline(char *buf, char *plain)
+{
+ char *p,*q,*r;
+ char *ph;
+ int iq;
+ int i,j;
+ int hl=-1, hl2=-1;
+ int iscnt=0; /* interword space count */
+ int tagci;
+ int I0;
+ int etype;
+ int efirst;
+ enum tagtype tag = NOTAG;
+ int esccode;
+
+ assert(buf!=NULL && plain!=NULL);
+
+ etype=NOTAG;
+ efirst=-1;
+ tagci=tagc;
+ ph=phrase; phraselen=0;
+ scnt=scnt2=0;
+ s_sum=s_cnt=0;
+ bs_sum=bs_cnt=0;
+ ccnt=0;
+ spcsqz=0;
+
+ /* strip only certain \x1b's and only at very beginning of line */
+ for (p=buf; *p=='\x1b' && (p[1]=='8'||p[1]=='9'); p+=2)
+ /* nop */;
+
+ strcpy(plain,p);
+ q=&plain[strlen(p)];
+
+ /*** spaces and change bars ***/
+ for (scnt=0,p=plain; *p==' '; p++) scnt++; /* initial space count */
+ if (scnt>200) scnt=130-(q-p);
+
+ assert(*q=='\0');
+ q--;
+ if (fChangeleft)
+ for (; q-40>plain && *q=='|'; q--) { /* change bars */
+ if (fChangeleft!=-1) ccnt++;
+ while (q-2>=plain && q[-1]=='\b' && q[-2]=='|') q-=2; /* boldface changebars! */
+ }
+
+ /*if (q!=&plain[scnt-1])*/ /* zap trailing spaces */
+ for (; *q==' ' && q>plain; q--) /* nop */;
+
+ /* second changebar way out east! HACK HACK HACK */
+ if (q-plain>100 && *q=='|') {
+ while (*q=='|' && q>plain) { q--; if (fChangeleft!=-1) ccnt++; }
+ while ((*q==' ' || *q=='_' || *q=='-') && q>plain) q--;
+ }
+
+ for (r=q; (*r&0xff)==CHARDAGGER; r--) *r='-'; /* convert daggers at end of line to hyphens */
+
+ if (q-plain < scnt) scnt = q-plain+1;
+ q[1]='\0';
+
+ /* set I for tags below */
+ if (indent>=0 && scnt>=indent) scnt-=indent;
+ if (!fPara && !fIQS) {
+ if (fChangeleft) I+=(scnt>ccnt)?scnt:ccnt;
+ else I+=scnt;
+ }
+ I0=I;
+
+ /*** tags and filler spaces ***/
+
+ iq=0; falluc=1;
+ for (q=plain; *p; p++) {
+
+ iscnt=0;
+ if (*p==' ') {
+ for (r=p; *r==' '; r++) { iscnt++; spcsqz++; }
+ s_sum+=iscnt; s_cnt++;
+ if (iscnt>1 && !scnt2 && *p==' ') scnt2=iscnt;
+ if (iscnt>2) { bs_cnt++; bs_sum+=iscnt; } /* keep track of large gaps */
+ iscnt--; /* leave last space for tail portion of loop */
+
+ /* write out spaces */
+ if (fQS && iscnt<3) { p=r-1; iscnt=0; } /* reduce strings of <3 spaces to 1 */
+ /* else if (fQS && iscnt>=3) { replace with tab? } */
+ else {
+ for (i=0; i<iscnt; i++) { p++; *q++=' '; }
+ }
+ } /* need to go through if chain for closing off annotations */
+
+ /** backspace-related filtering **/
+
+ if (*p=='\b' && p[1]=='_' && q>plain && q[-1]=='+') {
+ /* bold plus/minus(!) */
+ q[-1]=c_plusminus;
+ while (*p=='\b' && p[1]=='_') p+=2;
+ continue;
+ } else if ((*p=='_' && p[1]=='\b' && p[2]!='_' && p[3]!='\b')
+ || (*p=='\b' && p[1]=='_')) {
+ /* italics */
+ if (tag!=ITALICS && hl>=0) { tagadd(tag, hl, I+iq); hl=-1; }
+ if (hl==-1) hl=I+iq;
+ tag=ITALICS;
+ p+=2;
+ } else if (*p=='_' && p[2]==p[4] && p[1]=='\b' && p[3]=='\b' && p[2]!='_') {
+ /* bold italics (for Solaris) */
+ for (p+=2; *p==p[2] && p[1]=='\b';) p+=2;
+ if (tag!=BOLDITALICS && hl>=0) { tagadd(tag, hl, I+iq); hl=-1; }
+ if (hl==-1) hl=I+iq;
+ tag=BOLDITALICS;
+ } else if (*p==p[2] && p[1]=='\b') {
+ /* boldface */
+ while (*p==p[2] && p[1]=='\b') p+=2;
+ if (tag!=BOLD && hl>=0) { tagadd(tag, hl, I+iq); hl=-1; }
+ if (hl==-1) hl=I+iq;
+ tag=BOLD;
+ } else if (p[1]=='\b' &&
+ ((*p=='o' && p[2]=='+') ||
+ (*p=='+' && p[2]=='o')) ) {
+ /* bullets */
+ p+=2;
+ while (p[1]=='\b' && (*p=='o' || p[2]=='+') ) p+=2; /* bold bullets(!) */
+ *q++=c_bullet; iq++;
+ continue;
+ } else if (*p=='\b' && p>plain && p[-1]=='o' && p[1]=='+') {
+ /* OSF bullets */
+ while (*p=='\b' && p[1]=='+') p+=2; /* bold bullets(!) */
+ q[-1]=c_bullet; p--;
+ continue;
+ } else if (p[1]=='\b' && *p=='+' && p[2]=='_') {
+ /* plus/minus */
+ p+=2;
+ *q++=c_plusminus; iq++;
+ continue;
+ } else if (p[1]=='\b' && *p=='|' && p[2]=='-') {
+ /* dagger */
+ *q++=c_dagger; iq++;
+ p+=2; continue;
+ } else if (*p=='\b') {
+ /* supress unattended backspaces */
+ continue;
+ } else if (*p=='\x1b') {
+ p++;
+ if (*p=='[' && isdigit(p[1])) { /* 0/1/22/24/.../8/9/... */
+ esccode=0; for (p++; isdigit(*p); p++) esccode = esccode * 10 + *p - '0';
+
+ if (efirst>=0 /*&& (esccode==0 || esccode==1 || esccode==4 || esccode==22 || esccode==24) **&& hl>=0 && hl2==-1 && tags[MAXTAGS].first<I+iq*/) {
+ /* doesn't catch tag if spans line -- just make tag and hl static? */
+ /*tagadd(tags[MAXTAGS].type, tags[MAXTAGS].first, I+iq);*/
+ if (hl==-1 && hl2==-1 && efirst!=-1/*<I+iq*/)
+ tagadd(etype, efirst, I+iq);
+ efirst=-1;
+ }
+
+ if (esccode==1 /*&& hl==-1*/) {
+ /* stash attributes in "invalid" array element */
+ efirst=I+iq; etype=BOLD;
+ /*hl=I+iq; tag=BOLD; -- faces immediate end of range */
+ } else if (esccode==4 /*&& hl==-1*/) {
+ efirst=I+iq; etype=ITALICS;
+
+ } /* else skip unrecognized escape codes like 8/9 */
+ }
+
+ /*assert(*p=='m'); OR if (*p == 'm') ? */
+ /*p++; ** ending 'm' -- inc done in overarching for */
+ continue;
+
+ } else if ((isupper(*p) /*|| *p=='_' || *p=='&'*/) &&
+ (hl>=0 || isupper(p[1]) || (p[1]=='_' && p[2]!='\b') || p[1]=='&')) {
+ if (hl==-1 && efirst==-1) { hl=I+iq; tag=SMALLCAPS; }
+ } else {
+ /* end of tag, one way or another */
+ /* collect tags in this pass, interspersed later if need be */
+ /* can't handle overlapping tags */
+ if (hl>=0) {
+ if (hl2==-1) tagadd(tag, hl, I+iq);
+ hl=-1;
+ }
+ }
+
+ /** non-backspace related filtering **/
+ /* case statement here in place of if chain? */
+/* Tk 3.x's text widget tabs too crazy
+ if (*p==' ' && strncmp(" ",p,5)==0) {
+ xputchar('\t'); i+=5-1; ci++; continue;
+ } else
+*/
+/* copyright symbol: too much work for so little
+ if (p[i]=='o' && (strncmp("opyright (C) 19",&p[i],15)==0
+ || strncmp("opyright (c) 19",&p[i],15)==0)) {
+ printf("opyright \xd3 19");
+ tagadd(SYMBOL, ci+9, ci+10);
+ i+=15-1; ci+=13; continue;
+ } else
+*/
+ if (*p=='(' && q>plain && (isalnum(q[-1])||strchr(manvalid/*"._-+"*/,q[-1])!=NULL)
+ && strcoloncmp(&p[1],')',vollist)
+ /* && p[1]!='s' && p[-1]!='`' && p[-1]!='\'' && p[-1]!='"'*/ ) {
+ hl2=I+iq;
+ for (r=q-1; r>=plain && (isalnum(*r)||strchr(manvalid/*"._-+:"*/,*r)!=NULL); r--)
+ hl2--;
+ /* else ref to a function? */
+ /* maybe save position of opening paren so don't highlight it later */
+ } else if (*p==')' && hl2!=-1) {
+ /* don't overlap tags on man page references */
+ while (tagc>0 && tags[tagc-1].last>hl2) tagc--;
+ tagadd(MANREF, hl2, I+iq+1);
+ hl2=hl=-1;
+ } else if (hl2!=-1) {
+ /* section names are alphanumic or '+' for C++ */
+ if (!isalnum(*p) && *p!='+') hl2=-1;
+ }
+
+
+ /*assert(*p!='\0');*/
+ if (!*p) break; /* not just safety check -- check out sgmls.1 */
+
+ *q++=*p;
+/* falluc = falluc && (isupper(*p) || isspace(*p) || isdigit(*p) || strchr("-+&_'/()?!.,;",*p)!=NULL);*/
+ falluc = falluc && !islower(*p);
+ if (!scnt2) { *ph++=*p; phraselen++; }
+ iq+=iscnt+1;
+ }
+ if (hl>=0) tagadd(tag, hl, I+iq);
+ else if (efirst>=0) tagadd(etype, efirst, I+iq);
+ *q=*ph='\0';
+ linelen=iq+ccnt;
+
+
+ /* special case for Solaris:
+ if line has ONLY <CODE> tags AND they SPAN line, convert to one tag */
+ fCodeline=0;
+ if (tagc && tags[0].first==0 && tags[tagc-1].last==linelen) {
+ fCodeline=1;
+ j=0;
+ /* invariant: at start of a tag */
+ for (i=0; fCodeline && i<tagc; i++) {
+ if (tags[i].type!=BOLDITALICS /*&& tags[i].type!=BOLD*/) fCodeline=0;
+ else if ((j=tags[i].last)<linelen) {
+ for (; j < tags[i+1].first ; j++)
+ if (!isspace(plain[j])) { fCodeline=0; break; }
+ }
+ }
+ }
+
+
+ /* verify tag lists -- in production, compiler should kill with dead code elimination */
+ for (i=tagci; i<tagc; i++) {
+ /* verify valid ranges */
+ assert(tags[i].type>NOTAG && tags[i].type<=MANREF);
+ assert(tags[i].first>=I0 && tags[i].last<=linelen+I0);
+ assert(tags[i].first<=tags[i].last);
+
+ /* verify for no overlap with other tags */
+ for (j=i+1; j<tagc; j++) {
+ assert(tags[i].last<=tags[j].first /*|| tags[i].first>=tags[j].last*/);
+ }
+ }
+}
+
+
+/*
+ buf[] == input text (read only)
+ plain[] == output (initial, trailing spaces stripped; tabs=>spaces;
+ underlines, overstrikes => tag array; spaces squeezed, if requested)
+ ccnt = count of changebars
+ scnt = count of initial spaces
+ linelen = length result in plain[]
+*/
+
+int fHead=0;
+int fFoot=0;
+
+static void
+preformatted_filter(void)
+{
+ const int MINRM=50; /* minimum column for right margin */
+ const int MINMID=20;
+ const int HEADFOOTSKIP=20;
+ const int HEADFOOTMAX=25;
+ int curtag;
+ char *p,*r;
+ char head[MAXBUF]=""; /* first "word" */
+ char foot[MAXBUF]="";
+ int header_m=0, footer_m=0;
+ int headlen=0, footlen=0;
+/* int line=1-1; */
+ int i,j,k,l,off;
+ int sect=0,subsect=0,bulpair=0,osubsect=0;
+ int title=1;
+ int oscnt=-1;
+ int empty=0;
+ int fcont=0;
+ int Pnew=0,I0;
+ float s_avg=0.0;
+ int spaceout;
+ int skiplines=0;
+ int c;
+
+ /* try to keep tabeginend[][] in parallel with enum tagtype */
+ assert(tagbeginend[ITALICS][0]==BEGINITALICS);
+ assert(tagbeginend[MANREF][1]==ENDMANREF);
+ in++; /* lookahead = current character, in points to following */
+
+ /* for (i=0; i<MAXBUF; i++) tabgram[i]=0;*/
+
+ /*if (fMan) */indent=-1;
+ I=1;
+ CurLine=1;
+ (*fn)(BEGINDOC); I0=I;
+
+ /* run through each line */
+ while (la_gets(buf)!=NULL) {
+ if (title) I=I0;
+ /* strip out Ousterhout box: it's confusing the section line counts in TkMan outlining */
+ if (fNORM && *buf=='_'
+ && strncmp(buf,"_________________________________________________________________",65)==0) {
+ fTclTk = 1;
+ if (fChangeleft==0) fChangeleft=1;
+ skiplines = 2;
+ }
+ if (skiplines) { skiplines--; AbsLine++; continue; }
+ filterline(buf,plain); /* ALL LINES ARE FILTERED */
+
+#if 0
+ /* dealing with tables in formatted pages is hopeless */
+ finTable = fTable &&
+ ((!ncnt && fotable) ||
+ (ncnt && bs_cnt>=2 && bs_cnt<=5 && ((float) bs_sum / (float) bs_cnt)>3.0));
+ if (finTable) {
+ if (!fotable) (*fn)(BEGINTABLE);
+ } else if (fotable) {
+ (*fn)(ENDTABLE);
+ I=I0; tagc=0; filterline(buf,plain); /* rescan first line out of table */
+ }
+#endif
+
+ s_avg=(float) s_sum;
+ if (s_cnt>=2) {
+ /* don't count large second space gap */
+ if (scnt2) s_avg= (float) (s_sum - scnt2) / (float) (s_cnt-1);
+ else s_avg= (float) (s_sum) / (float) (s_cnt);
+ }
+
+ p=plain; /* points to current character in plain */
+
+ /*** determine header and global indentation ***/
+ if (/*fMan && (*/!fHead || indent==-1/*)*/) {
+ if (!linelen) continue;
+ if (!*header) {
+ /* check for missing first header--but this doesn't catch subsequent pages */
+ if (stricmp(p,"NAME")==0 || stricmp(p,"NOMBRE")==0) { /* works because line already filtered */
+ indent=scnt; /*filterline(buf,plain);*/ scnt=0; I=I0; fHead=1;
+ } else {
+ fHead=1;
+ (*fn)(BEGINHEADER);
+ /* grab header and its first word */
+ strcpy(header,p);
+ if ((header_m=HEADFOOTSKIP)>linelen) header_m=0;
+ strcpy(head,phrase); headlen=phraselen;
+ la_gets(buf); filterline(buf,plain);
+ if (linelen) {
+ strcpy(header2,plain);
+ if (strincmp(plain,"Digital",7)==0 || strincmp(plain,"OSF",3)==0) {
+ fFoot=1;
+ fSubsections=0;
+ }
+ }
+ (*fn)(ENDHEADER); tagc=0;
+ continue;
+ }
+ } else {
+ /* some idiot pages have a *third* header line, possibly after a null line */
+ if (*header && scnt>MINMID) { strcpy(header3,p); ncnt=0; continue; }
+ /* indent of first line ("NAME") after header sets global indent */
+ /* check '<' for Plan 9(?) */
+ if (*p!='<') {
+ indent=scnt; I=I0; scnt=0;
+ } else continue;
+ }
+/* if (indent==-1) continue;*/
+ }
+ if (!lindent && scnt) lindent=scnt;
+/*printf("lindent = %d, scnt=%d\n", lindent,scnt);*/
+
+
+ /**** for each ordinary line... *****/
+
+ /*** skip over global indentation */
+ empty=(linelen==0);
+ if (empty) {ncnt++; continue;}
+
+ /*** strip out per-page titles ***/
+
+ if (/*fMan && (*/scnt==0 || scnt>MINMID/*)*/) {
+/*printf("***ncnt = %d, fFoot = %d, line = %d***", ncnt,fFoot,AbsLine);*/
+ if (!fFoot && !isspace(*p) && (scnt>5 || (*p!='-' && *p!='_')) &&
+ /* don't add ncnt -- AbsLine gets absolute line number */
+ (((ncnt>=2 && AbsLine/*+ncnt*/>=61/*was 58*/ && AbsLine/*+ncnt*/<70)
+ || (ncnt>=4 && AbsLine/*+ncnt*/>=59 && AbsLine/*+ncnt*/<74)
+ || (ncnt && AbsLine/*+ncnt*/>=61 && AbsLine/*+ncnt*/<=66))
+ && (/*lookahead!=' ' ||*/ (s_cnt>=1 && s_avg>1.1) || !falluc) )
+ ) {
+ (*fn)(BEGINFOOTER);
+ /* grab footer and its first word */
+ strcpy(footer,p);
+/* if ((footer_m=linelen-HEADFOOTSKIP)<0) footer_m=0;*/
+ if ((footer_m=HEADFOOTSKIP)>linelen) footer_m=0;
+ /*grabphrase(p);*/ strcpy(foot,phrase); footlen=phraselen;
+ /* permit variations at end, as for SGI "Page N", but keep minimum length */
+ if (footlen>3) footlen--;
+ la_gets(buf); filterline(buf,plain); if (linelen) strcpy(footer2,plain);
+ title=1;
+ (*fn)(ENDFOOTER); tagc=0;
+
+ /* if no header on first page, try again after first footer */
+ if (!fFoot && *header=='\0') fHead=0; /* this is dangerous */
+ fFoot=1;
+ continue;
+ } else
+ /* a lot of work, but only for a few lines (about 4%) */
+ if (fFoot && (scnt==0 || scnt+indent>MINMID) &&
+ ( (headlen && strncmp(head,p,headlen)==0)
+ || strcmp(header2,p)==0 || strcmp(header3,p)==0
+ || (footlen && strncmp(foot,p,footlen)==0)
+ || strcmp(footer2,p)==0
+ /* try to recognize lines with dates and page numbers */
+ /* skip into line */
+ || (header_m && header_m<linelen &&
+ strncmp(&header[header_m],&p[header_m],HEADFOOTMAX)==0)
+ || (footer_m && footer_m<linelen &&
+ strncmp(&footer[footer_m],&p[footer_m],HEADFOOTMAX)==0)
+ /* skip into line allowing for off-by-one */
+ || (header_m && header_m<linelen &&
+ strncmp(&header[header_m],&p[header_m+1],HEADFOOTMAX)==0)
+ || (footer_m && footer_m<linelen &&
+ strncmp(&footer[footer_m],&p[footer_m+1],HEADFOOTMAX)==0)
+ /* or two */
+ || (header_m && header_m<linelen &&
+ strncmp(&header[header_m],&p[header_m+2],HEADFOOTMAX)==0)
+ || (footer_m && footer_m<linelen &&
+ strncmp(&footer[footer_m],&p[footer_m+2],HEADFOOTMAX)==0)
+ /* or with reflected odd and even pages */
+ || (headlen && headlen<linelen &&
+ strncmp(head,&p[linelen-headlen],headlen)==0)
+ || (footlen && footlen<linelen &&
+ strncmp(foot,&p[linelen-footlen],footlen)==0)
+ )) {
+ tagc=0; title=1; continue;
+ }
+
+ /* page numbers at end of line */
+ for(i=0; p[i] && isdigit(p[i]); i++)
+ /* empty */;
+ if (&p[i]!=plain && !p[i]) {title=1; fFoot=1; continue;}
+ }
+
+ /*** interline spacing ***/
+ /* multiple \n: paragraph mode=>new paragraph, line mode=>blank lines */
+ /* need to chop up lines for Roff */
+
+ /*tabgram[scnt]++;*/
+ if (title) ncnt=(scnt!=oscnt || (/*scnt<4 &&*/ isupper(*p)));
+ itabcnt = scnt/5;
+ if (CurLine==1) {ncnt=0; tagc=0;} /* gobble all newlines before first text line */
+ sect = (scnt==0 && isupper(*p));
+ subsect = (fSubsections && (scnt==2||scnt==3));
+ if ((sect || subsect) && ncnt>1) ncnt=1; /* single blank line between sections */
+ (*fn)(BEGINLINE);
+ if (/*fPara &&*/ ncnt) Pnew=1;
+ title=0; /*ncnt=0;--moved down*/
+ /*if (finTable) (*fn)(BEGINTABLELINE);*/
+ oscnt=scnt; /*fotable=finTable;*/
+
+/* let output modules decide what to do at the start of a paragraph
+ if (fPara && !Pnew && (prevcmd==BEGINBODY || prevcmd==BEGINBULTXT)) {
+ putchar(' '); I++;
+ }
+*/
+
+ /*** identify structural sections and notify fn */
+
+ /*if (fMan) {*/
+/* bulpair = (scnt<7 && (*p==c_bullet || *p=='-'));*/
+ /* decode the below */
+ bulpair = ((!auxindent || scnt!=lindent+auxindent) /*!bulpair*/
+ && ((scnt>=2 && scnt2>5) || scnt>=5 || (tagc>0 && tags[0].first==scnt) ) /* scnt>=2?? */
+ && (((*p==c_bullet || strchr("-+.",*p)!=NULL || falluc) && (ncnt || scnt2>4)) ||
+ (scnt2-s_avg>=2 && phrase[phraselen-1]!='.') ||
+ (scnt2>3 && s_cnt==1)
+ ));
+ if (bulpair) {
+ if (tagc>0 && tags[0].first==scnt) {
+ k=tags[0].last;
+ for (l=1; l<tagc; l++) {
+ if (tags[l].first - k <=3)
+ k=tags[l].last;
+ else break;
+ }
+ phraselen=k-scnt;
+ for (k=phraselen; plain[k]==' ' && k<linelen; k++) /* nothing */;
+ if (k>=5 && k<linelen) hanging=k; else hanging=-1;
+ } else if (scnt2) hanging=phraselen+scnt2;
+ else hanging=5;
+ } else hanging=0;
+
+/* hanging = bulpair? phraselen+scnt2 : 0;*/
+/*if (bulpair) printf("hanging = %d\n", hanging);*/
+ /* maybe, bulpair=0 would be best */
+ /*end fMan}*/
+
+ /* certain sections (subsections too?) special, like SEE ALSO */
+ /* to make canonical name as plain, all lowercase */
+ if (sect /*||subsect -- no widespread subsection names*/) {
+ for (j=0; (sectheadid=j)<RANDOM; j++) if (strcoloncmp2(plain,'\0',sectheadname[j],0)) break;
+ }
+
+ /* normalized section headers are put into mixed case */
+ if (/*fNORM &&*/falluc && (sect || subsect)) casify(plain);
+
+ if (sect) {
+ poppush(BEGINSECTION); (*fn)(BEGINSECTHEAD);
+ tocadd(plain, BEGINSECTION, CurLine);
+ } else if (subsect && !osubsect) {
+ poppush(BEGINSUBSECTION); (*fn)(BEGINSUBSECTHEAD);
+ tocadd(plain, BEGINSUBSECTION, CurLine);
+ } else if (bulpair) {
+ /* used to be just poppush(BEGINBULPAIR); */
+ if (!Pbp) poppush(BEGINBULPAIR);
+ (poppush)(BEGINBULLET);
+ fIP=1; /*grabphrase(plain);*/
+ } else if (Pnew) {
+ poppush(BEGINBODY);
+ }
+ Pnew=0;
+ oldsectheadid = sectheadid;
+
+
+ /* move change bars to left */
+ if (fChangeleft && !fNORM) {
+ if (fPara) (*fn)(CHANGEBAR);
+ /* replace initial spaces with changebars */
+ else for (i=0; i<ccnt; i++) { /*xputchar('|'); */ (*fn)(CHANGEBAR); }
+ }
+
+ /* show initial spaces */
+ if (!fIQS && fcharout) {
+ spaceout = (scnt>ccnt)?(scnt-ccnt):0;
+ if (fILQS) { if (spaceout>=lindent) spaceout-=lindent; else spaceout=0; }
+ if (auxindent) { if (spaceout>=auxindent) spaceout-=auxindent; else spaceout=0; }
+ if (fNORM) {
+ if (itabcnt>0) (*fn)(ITAB);
+ for (i=0; i<(scnt%5); i++) putchar(' ');
+ } else printf("%*s",spaceout,"");
+ }
+
+
+ /*** iterate over each character in line, ***/
+ /*** handling underlining, tabbing, copyrights ***/
+
+ off=(!fIQS&&!fPara)?scnt:0;
+ for (i=0, p=plain, curtag=0, fcont=0; *p; p++,i++,fcont=0) {
+ /* interspersed presentation signals */
+ /* start tags in reverse order of addition (so structural first) */
+ if (curtag<tagc && i+I0+off==tags[curtag].first) {
+ for (r=hitxt, j=tags[curtag].last-tags[curtag].first, hitxt[j]='\0'; j; j--)
+ hitxt[j-1]=p[j-1];
+ (*fn)(tagbeginend[tags[curtag].type][0]);
+ }
+
+ /* special characters */
+ switch(*p) {
+ case '"':
+ if (p==plain || isspace(p[-1])) { (*fn)(CHARLQUOTE); fcont=1; }
+ else if (isspace(p[1])) { (*fn)(CHARRQUOTE); fcont=1; }
+ break;
+ case '\'':
+ if (p==plain || isspace(p[-1])) { (*fn)(CHARLSQUOTE); fcont=1; }
+ else if (isspace(p[1])) { (*fn)(CHARRSQUOTE); fcont=1; }
+ break;
+ case '-':
+ /* check for -opt => \-opt */
+ if (p==plain || (isspace(p[-1]) && !isspace(p[1]))) {
+ (*fn)(CHARDASH); fcont=1;
+ }
+ break;
+ }
+
+ /* troublemaker characters */
+ c = (*p)&0xff;
+ if (!fcont && fcharout) {
+ if (strchr(escchars,c)!=NULL) {
+ putchar('\\'); putchar(c); I++;
+ } else if (strchr((char *)trouble,c)!=NULL) {
+ (*fn)((enum command)c); fcont=1;
+ } else {
+ putchar(c); I++;
+ }
+ }
+
+/*default:*/
+ if (curtag<tagc && i+I0+off+1==tags[curtag].last) {
+ (*fn)(tagbeginend[tags[curtag].type][1]);
+ curtag++;
+ }
+
+ if (fIP && ((*p==' ' && i==phraselen) || *p=='\0')) {
+ p++; /* needed but why? */
+ (*fn)(ENDBULLET); fIP=0;
+ if (*p!='\0') {
+ /*oscnt+=phraselen;*/
+ oscnt+=i;
+ for (r=p; *r==' '; r++) {
+ oscnt++;
+/*
+ i++;
+ if (fQS || !fcharout) p++;
+*/
+ }
+ }
+ p--; /* to counteract increment in loop */
+
+ poppush(BEGINBULTXT);
+ }
+ }
+
+
+ /*** end of line in buf[] ***/
+ /*** deal with section titles, hyperlinks ***/
+
+ if (sect) { (*fn)(ENDSECTHEAD); Pnew=1; }
+ else if (subsect) { (*fn)(ENDSUBSECTHEAD); Pnew=1; }
+ else if (fIP) { (*fn)(ENDBULLET); fIP=0; poppush(BEGINBULTXT); }
+/* oscnt not right here */
+ else if (scnt+linelen+spcsqz<MINRM /*&& ncnt*/ && lookahead!='\n'
+ && prevcmd!=BEGINBULTXT && prevcmd!=ENDSUBSECTHEAD && prevcmd!=ENDSUBSECTHEAD)
+ (*fn)(SHORTLINE);
+ osubsect=subsect;
+
+ /*if (finTable) (*fn)(ENDTABLELINE);*/
+ /*if (!fPara)*/ (*fn)(ENDLINE); tagc=0;
+ ncnt=0;
+ I0=I; /* save I here in case skipping lines screws it up */
+ }
+
+ /* wrap up at end */
+ pop(ENDDOC); /* clear up all tags on stack */
+ (*fn)(ENDDOC);
+}
+
+
+
+/*
+ * SOURCE CODE PARSING
+ * for better transcription short of full nroff interpreter
+ *
+ * Macros derived empirically, except for weird register ones that were looked up in groff
+ *
+ * buffer usage
+ * buf = incoming text from man page file
+ * plain = "second pass" buffer used to identify man page references
+ *
+ * test pages
+ * Solaris: fdisk.1m, fcntl.2, curs_getwch.3x, locale.5 (numbered lists),
+ * getservbyname.3n (font size changes)
+ */
+
+/* macros */
+/* put as much in here, as opposed to in code, as possible.
+ less expensive and here they can be overridden by other macros */
+/*const int macromax=100; -- dumb compiler */
+#define MACROMAX 1000
+struct { char *key; char *subst; } macro[MACROMAX] = {
+ /* Solaris */
+ {"NA", ".SH NAME"},
+ {"SB", "\\s-2\\fB\\$1\\fR\\s0"},
+ /* HP-UX */
+#if 0
+ {"SM", "\\s-2\\$1\\s0"},
+ {"C", "\\f3\\$1\\fR"},
+ {"CR", "\\f3\\$1\\fR\\$2"},
+ {"CI", "\\f3\\$1\\fI\\$2\\fR"},
+ {"RC", "\\fR\\$1\\f3\\$2\\fR"},
+#endif
+ /* SGI -- doesn't ship man page source */
+
+ /* 4.4BSD - http://intergate.sonyinteractive.com/cgi-bin/manlink/7/mdoc */
+ /* scads more, but for them definition in -mandoc is sufficient */
+#if 0
+ {"Dt", ".TH \\$1 \\$2 \\$3"},
+ {"Sh", ".SH \\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9"},
+ {"Ss", ".SS \\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9"},
+ {"Pp", ".P"},
+ {"Nm", ".BR \\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9"}, /* name */
+ {"Ar", ".IR \\$1 \\$2 \\$3 \\$4 \\$5 \\$6 \\$7 \\$8 \\$9"},
+#endif
+ { NULL, NULL }
+};
+/* what all can be represented as a macro? */
+int macrocnt=-1; /* length of table counted at start */
+
+char *macnotfound[MACROMAX];
+int macnotcnt=0;
+
+#define SUBSTMAX 1000
+/* "*" or "*(" prefixed */
+struct { char *key; char *subst; } subst[SUBSTMAX] = {
+ {"rq", "'"}, {"lq", "`"}, {"L\"", "``"}, {"R\"", "''"},
+ {"L", "\\f3"}, {"E", "\\f2"}, {"V", "\\f4"}, {"O", "\\f1"}
+};
+int substcnt=8;
+
+#define REGISTERMAX 1000
+struct { char *name; char *value; } reg[REGISTERMAX];
+int regcnt=0;
+
+/* special characters */
+const struct { char key[4]; unsigned char subst[4]; } spec[] = {
+ { "**", "*" },
+ { "+-", { CHARPLUSMINUS, '\0' }},
+ { "12", { CHAR12, '\0' }},
+ { "14", { CHAR14, '\0' }},
+ { "34", { CHAR34, '\0' }},
+ { "aa", { CHARACUTE, '\0' }},
+ { "ap", "~" },
+ { "br", "|" },
+ { "bu", { CHARBULLET, '\0' }},
+ { "bv", "|" },
+ { "ci", "O" },
+ { "co", { CHARCOPYR, '\0' }},
+ { "ct", { CHARCENT, '\0' }},
+ { "de", { CHARDEG, '\0' }},
+ { "dg", { CHARDAGGER, '\0' }},
+ { "di", { CHARDIV, '\0' }},
+ { "em", "--" },
+ { "eq", "=" },
+ { "hy", "-" },
+ { "mi", "-" },
+ { "mu", { CHARMUL, '\0' }},
+ { "no", { CHARNOT, '\0' }},
+ { "or", "|" },
+ { "pl", "+" },
+ { "rg", { CHARREGTM, '\0' }},
+ { "ru", "_" },
+ { "sc", { CHARSECT, '\0' }},
+ { "sl", "/" },
+ { "ua", "^" },
+ { "ul", "_" }
+};
+#define speccnt (sizeof spec / sizeof spec[0])
+
+/* tbl line descriptions */
+char *tbl[20][20]; /* space enough for twenty description lines, twenty parts each */
+int tblc=0;
+int tbli;
+
+int fsourceTab = 0, fosourceTab=0;
+int supresseol=0;
+int finitDoc=0;
+int sublevel=0;
+
+static char *
+source_gets(void)
+{
+ char *p,*q;
+ char *ret = (*in)?buf:NULL;
+ int i;
+ char *begin;
+ char tmpbuf[MAXBUF];
+ char name[3];
+
+ if (!sublevel) AbsLine++;
+
+ p = tmpbuf;
+ falluc = 1;
+ while (1) {
+ /* collect characters in line */
+ while (*in && *in!='\n') {
+ if (p[0]=='\\' && p[1]=='\n') p+=2; /* \<newline> */
+ falluc = falluc && !islower(*in);
+ *p++ = *in++;
+ }
+ if (*in) in++;
+ *p='\0';
+
+ /* normalize commands */
+ p=tmpbuf; q=buf; /* copy from tmpbuf to buf */
+ /* no spaces between command-initiating period and command letters */
+ if (*p=='\'') { *p='.'; } /* what's the difference? */
+ if (*p=='.') { *q++ = *p++; while (isspace(*p)) p++; }
+
+
+ /* convert lines with tabs to tables? */
+ fsourceTab=0;
+
+ /* if comment at start of line, OK */
+ /* dynamically determine iff Tcl/Tk page by scanning comments */
+ begin = p;
+ if (*p=='\\' && *(p+1)=='"') {
+ if (!fTclTk && strstr(p+1,"supplemental macros used in Tcl/Tk")!=NULL) fTclTk=1;
+ if (fTclTk)
+ p+=2;
+ }
+
+ while (*p) {
+ if (*p=='\t') fsourceTab++;
+ if (*p=='\\') {
+ p++;
+ if (*p=='n') {
+ p++;
+ if (*p=='(') {
+ p++; name[0]=*p++; name[1]=*p++; name[2]='\0';
+ } else {
+ name[0]=*p++; name[1]='\0';
+ }
+ *q='0'; *(q+1)='\0'; /* defaults to 0, in case doesn't exist */
+ for (i=0; i<regcnt; i++) {
+ if (strcmp(reg[i].name,name)==0) {
+ strcpy(q, reg[i].value);
+ break;
+ }
+ }
+ q+=strlen(q);
+ } else if (*p=='"' && (p != begin+1)) { /* comment in Digital UNIX, OK elsewhere? */
+ *p='\0';
+ q--; while (q>buf && isspace(*q)) q--; /* trim tailing whitespace */
+ q++; *q='\0';
+ } else {
+ /* verbatim character (often a backslash) */
+ *q++ = '\\'; /* postpone interpretation (not the right thing but...) */
+ *q++ = *p++;
+ }
+ } else *q++ = *p++;
+ }
+
+ /* dumb Digital--later */
+ /*if (q-3>plain && q[-1]=='{' && q[-2]=='\\' && q[-3]==' ') q[-3]='\n'; }*/
+
+ /* close off buf */
+ *q='\0';
+
+#if 0
+ if (q>buf && q[-1]=='\\' && *in=='.') /* append next line * / else break;*/
+#endif
+ break;
+ }
+
+ /*printf("*ret = |%s|\n", ret!=NULL?ret : "NULL");*/
+ return ret;
+}
+
+
+/* dump characters from buffer, signalling right tags along the way */
+/* all this work to introduce an internal second pass to recognize man page references */
+/* now for HTTP references too */
+
+int sI=0;
+/* use int linelen from up top */
+int fFlush=1;
+
+static void
+source_flush(void)
+{
+ int i,j;
+ char *p,*q,*r;
+ int c;
+ int manoff,posn;
+
+ if (!sI) return;
+ plain[sI] = '\0';
+
+ /* flush called often enough that all man page references are at end of text to be flushed */
+ /* find man page ref */
+ if (sI>=4/*+1*/ && (plain[sI-(manoff=1)-1]==')' || plain[sI-(manoff=0)-1]==')')) {
+ for (q=&plain[sI-manoff-1-1]; q>plain && isalnum(*q) && *q!='('; q--) /* nada */;
+ if (*q=='(' && strcoloncmp(&q[1],')',vollist)) {
+ r=q-1;
+ if (*r==' ' && (sectheadid==SEEALSO || /*single letter volume */ *(q+2)==')' || *(q+3)==')')) r--; /* permitted single intervening space */
+ for ( ; r>=plain && (isalnum(*r) || strchr(manvalid,*r)!=NULL); r--) /* nada */;
+ r++;
+ if (isalpha(*r) && r<q) {
+ /* got one: clear out tags and spaces to make normalized form */
+ posn = r-plain;
+ /*while (tagc && tags[tagc-1].first >= posn) tagc--;*/
+
+ /* add MANREF tags */
+ strcpy(hitxt,r);
+ tagadd(BEGINMANREF, posn, 0);
+ /* already generated other start tags, so move BEGINMANREF to start in order to be well nested (ugh) */
+ tagtmp = tags[tagc-1]; for (j=tagc-1; j>0; j--) tags[j]=tags[j-1]; tags[0]=tagtmp;
+ tagadd(ENDMANREF, sI-manoff-1+1, 0);
+ }
+ }
+
+ /* HTML hyperlinks */
+ } else if (fURL && sI>=4 && (p=strstr(plain,"http"))!=NULL) {
+ i = p-plain;
+ tagadd(BEGINMANREF, i, 0); tagtmp = tags[tagc-1]; for (j=tagc-1; j>0; j--) tags[j]=tags[j-1]; tags[0]=tagtmp;
+ for (j=0; i<sI && !isspace(*p) && *p!='"' && *p!='>'; i++,j++) hitxt[j] = *p++;
+ hitxt[j]='\0';
+ tagadd(ENDMANREF, i, 0);
+ }
+
+ if (!fFlush) return;
+
+ /* output text */
+ for (i=0,j=0,p=plain; i<sI && *p; i++,p++) {
+ if (!linelen) (*fn)(BEGINLINE); /* issue BEGINLINE when know will be chars on line */
+
+ /* dump tags */
+ /*for ( ; j<tagc && tags[j].first == i; j++) (*fn)(tags[j].type);*/
+ for (j=0; j<tagc; j++) if (tags[j].first == i) (*fn)((enum command)tags[j].type);
+
+ /* dump text */
+ c = (*p)&0xff; /* just make c unsigned? */
+ if (strchr(escchars,c)!=NULL) {
+ xputchar('\\'); xputchar(c);
+ if (fcharout) linelen++;
+ } else if (strchr((char *)trouble,c)!=NULL) {
+ (*fn)((enum command)c);
+ } else if (linelen>=LINEBREAK && c==' ') { (*fn)(ENDLINE); linelen=0;
+ } else { /* normal character */
+ xputchar(c);
+ if (fcharout) linelen++;
+ }
+
+ /*if (linelen>=LINEBREAK && c==' ') { (*fn)(ENDLINE); linelen=0; } -- leaves space at end of line*/
+ }
+ /* dump tags at end */
+ /*for ( ; j<tagc && tags[j].first == sI; j++) (*fn)(tags[j].type);*/
+ for (j=0; j<tagc; j++) if (tags[j].first==sI) (*fn)((enum command)tags[j].type);
+
+ sI=0; tagc=0;
+}
+
+
+/* source_out stuffs characters in a buffer */
+static char *
+source_out0(const char *pin, char end)
+{
+ /* stack of character formattings */
+ static enum tagtype styles[20];
+ static int style=-1;
+ int funwind=0;
+ int i, j;
+ int len;
+ int sign;
+ char *p, *pstart;
+
+ pstart = p = mystrdup(pin);
+ while (*p && *p!=end) {
+ if (*p=='\\') { /* escape character */
+ switch (*++p) {
+ case '&': /* no space. used as a no-op sometimes */
+ case '^': /* 1/12 em space */
+ case '|': /* 1/6 em space */
+ case '%': /* hyphenation indicator */
+ /* just ignore it */
+ p++;
+ break;
+ case '0': /* digit width space */
+ p++;
+ sputchar(' ');
+ break;
+ case ' ': /* unpaddable space */
+ stagadd(CHARNBSP); /* nonbreaking space */
+ /*sputchar(' ');*/
+ p++;
+ break;
+ case 's': /* font size change */
+ p++;
+ sign=1;
+ if (*p=='-' || *p=='+') if (*p++=='-') sign=-1;
+ intArg = sign * ((*p++)-'0');
+ if (intArg==0) intArg = -fontdelta; /* s0 returns to normal height */
+ if (fontdelta || intArg) { source_flush(); (*fn)(FONTSIZE); }
+ break;
+ case 'v': /* vertical motion */
+ case 'h': /* horizontal motion */
+ case 'L': /* vertical line */
+ case 'l': /* horizontal line */
+ /* ignore */
+ p++;
+ if (*p=='\'') { p++; while (*p++!='\''); }
+ break;
+ case '"': /* comment */
+ *p='\0'; /* rest of line is comment */
+ break;
+ case 'f':
+ p++;
+ switch (*p++) {
+ case '3': case 'B': /* boldface */
+ styles[++style] = BOLD;
+ stagadd(BEGINBOLD);
+ break;
+ case '2': case 'I': /* italics */
+ styles[++style] = ITALICS;
+ stagadd(BEGINITALICS);
+ break;
+ case '4': /* bolditalics mode => program code */
+ styles[++style] = BOLDITALICS;
+ stagadd(BEGINBOLDITALICS);
+ break;
+ case '1': case '0': case 'R': case 'P': /* back to Roman */
+ /*sputchar(' '); -- taken out; not needed, I hope */
+ funwind=1;
+ break;
+ case '-':
+ p++;
+ break;
+ }
+ break;
+ case '(': /* multicharacter macros */
+ p++;
+ for (i=0; (unsigned)i<speccnt; i++) {
+ if (p[0]==spec[i].key[0] && p[1]==spec[i].key[1]) {
+ p+=2;
+ for (j=0; spec[i].subst[j]; j++) sputchar(spec[i].subst[j]);
+ break;
+ }
+ }
+ break;
+ case '*': /* strings */
+ p++;
+ if (*p!='(') { /* single character */
+ for (i=0; i<substcnt; i++) {
+ if (*p==subst[i].key[0] && subst[i].key[1]=='\0') {
+ source_out0(subst[i].subst,'\0');
+ break;
+ }
+ }
+ p++;
+ } else { /* multicharacter macros */
+ p++;
+ for (i=0; i<substcnt; i++) {
+ len = strlen(subst[i].key);
+ if (strncmp(p,subst[i].key,len)==0) {
+ source_out0(subst[i].subst,'\0');
+ p+=len;
+ break;
+ }
+ }
+ }
+ break;
+#if 0
+ case '|':
+ stagadd(CHARNBSP); /* nonbreaking space */
+#if 0
+ sputchar(' ');
+#endif
+ p++;
+#endif
+ case 'e': /* escape */
+ sputchar('\\');
+ p++;
+ break;
+ case 'c':
+ /* supress following carriage return-induced space */
+ /* handled in source_gets(); ignore within line => can't because next line might start with a command */
+ supresseol=1;
+ p++;
+ break;
+ case '-': /* minus sign */
+ sputchar(CHARDASH);
+ p++;
+ break;
+#if 0
+ case '^':
+ /* end stylings? (found in Solaris) */
+ p++;
+#endif
+ case 'N':
+ p++;
+ if (*p == '\'') {
+ char *tmp;
+ p++;
+ if ((tmp = strchr(p, '\'')) != NULL) {
+ sputchar(atoi(p));
+ p = tmp + 1;
+ }
+ }
+ break;
+ case 0:
+ /* ignore */
+ break;
+ default: /* unknown escaped character */
+ sputchar(*p++);
+ }
+
+ } else { /* normal character */
+ if (*p) sputchar(*p++);
+ }
+
+
+ /* unwind character formatting stack */
+ if (funwind) {
+ for ( ; style>=0; style--) {
+ if (styles[style]==BOLD) stagadd(ENDBOLD);
+ else if (styles[style]==ITALICS) stagadd(ENDITALICS);
+ else stagadd(ENDBOLDITALICS);
+ } /* else error */
+ assert(style==-1);
+
+ funwind=0;
+ }
+
+ /* check for man page reference and flush buffer if safe */
+ /* postpone check until after following character so catch closing tags */
+ if ((sI>=4+1 && plain[sI-1-1]==')') ||
+ /* (plain[sI-1]==' ' && (q=strchr(plain,' '))!=NULL && q<&plain[sI-1])) */
+ (sI>=2 && plain[sI-1]==' ' && !isalnum(plain[sI-1-1]))) {
+ /* regardless, flush buffer */
+ source_flush();
+ }
+ }
+
+ if (*p && *p!=' ') p++; /* skip over end character */
+ free(pstart);
+ return (char *)pin + (p - pstart);
+
+}
+
+/* oh, for function overloading. inlined by compiler, probably */
+static char *
+source_out(const char *p)
+{
+ return source_out0(p,'\0');
+}
+
+
+static char *
+source_out_word(const char *p)
+{
+ char end = ' ';
+
+ while (*p && isspace(*p)) p++;
+ if (*p=='"' /* || *p=='`' ? */) {
+ end = *p;
+ p++;
+ }
+ p = source_out0(p,end);
+ /*while (*p && isspace(*p)) p++;*/
+ return (char *)p;
+}
+
+
+static void
+source_struct(enum command cmd)
+{
+ source_out("\\fR\\s0"); /* don't let run-on stylings run past structural units */
+ source_flush();
+ if (cmd==SHORTLINE) linelen=0;
+ (*fn)(cmd);
+}
+
+#define checkcmd(str) strcmp(cmd,str)==0
+
+int finnf=0;
+
+static void source_line(char *p);
+
+static void
+source_subfile(char *newin)
+{
+ char *p;
+ char *oldin = in;
+
+ sublevel++;
+
+ in = newin;
+ while ((p=source_gets())!=NULL) {
+ source_line(p);
+ }
+ in = oldin;
+
+ sublevel--;
+}
+
+/* have to delay acquisition of list tag */
+static void
+source_list(void)
+{
+ static int oldlisttype; /* OK to have just one because nested lists done with RS/RE */
+ char *q;
+ int i;
+
+ /* guard against empty bullet */
+ for (i=0, q=plain; i<sI && isspace(*q); q++,i++) /* empty */;
+ if (i==sI) return;
+
+ assert(finlist);
+
+ fFlush=1;
+
+ /* try to determine type of list: DL, OL, UL */
+ q=plain; plain[sI]='\0';
+ if (/*c==CHARBULLET || q=='-' -- command line opts! ||*/ *q=='.' || *q&0x80) {
+ listtype=UL;
+ q++;
+ } else {
+ if (strchr("[(",*q)) q++;
+ while (isdigit(*q)) { listtype=OL; q++; } /* I hope this gives the right number */
+ if (*q=='.') q++;
+ if (strchr(")]",*q)) q++;
+ if (*q=='.') q++;
+ while (isspace(*q)) q++;
+ if (*q) listtype=DL;
+ }
+ oldlisttype = listtype;
+
+ /* interpretation left to output formats based on listtype (HTML: DL, OL, UL) */
+ i = sI; sI=0;
+ if (!Pbp || listtype!=oldlisttype) poppush(BEGINBULPAIR);
+ poppush(BEGINBULLET);
+ /*if (tphp) source_line(p); else source_out_word(p);*/
+ /*if (listtype!=OL && listtype!=UL)*/ sI=i;
+ source_struct(ENDBULLET); Pbul=0; /* handled immediately below */
+ poppush(BEGINBULTXT);
+
+ finlist=0;
+}
+
+static int inComment=0;
+static int isComment=0;
+
+static void
+source_command(char *p)
+{
+ static int lastif=1;
+ int mylastif;
+ char *cmd=p;
+ char *q;
+ int i,j,endch;
+ int fid;
+ struct stat fileinfo;
+ char *sobuf;
+ char *macroArg[9];
+ char endig[10];
+ int err=0;
+ char ch;
+ int tphp=0;
+ int ie=0;
+ int cond,invcond=0;
+ char delim,op;
+ char if0[MAXBUF], if1[MAXBUF];
+ float nif0, nif1;
+ int insertat;
+ char macrobuf[MAXBUF]; /* local so can have nested macros */
+ static char ft='\0';
+ static int fTableCenter=0;
+
+ /* should centralize command matching (binary search?), pointer bumping here
+ if for no other reason than to catch conflicts -- and allow overrides? */
+ /* parse out command */
+ while (*p && !isspace(*p)) p++;
+ if (*p) { *p='\0'; p++; }
+ /* should set up argv, argc for command arguments--it's regular enough that everyone doesn't have to do it itself */
+
+ isComment = (/*checkcmd("") ||*/ !strncmp(cmd, "\\\"", 2) || /*DEC triple dot*/checkcmd(".."));
+ if (inComment && !isComment) { source_struct(ENDCOMMENT); inComment=0; } /* special case to handle transition */
+
+ if (isComment) {
+ /* maybe have BEGINCOMMENT, ENDCOMMENT, COMMENTLINE */
+ supresseol=0;
+ if (!inComment) { source_flush(); source_struct(BEGINCOMMENT); inComment=1; }
+ source_struct(COMMENTLINE);
+ printf("%s\n", p); /* could contain --> or other comment closer, but unlikely */
+
+ /* structural commands */
+ } else if (checkcmd("TH")) {
+ /* sample: .TH CC 1 "Dec 1990" */
+ /* overrides command line -- should fix this */
+ if (!finitDoc) {
+ while (isspace(*p)) p++;
+ if (*p) {
+ /* name */
+ q=strchr(p, ' '); if (q!=NULL) *q++='\0';
+ strcpy(manName, p);
+ /* number */
+ p = q;
+ if (p!=NULL) {
+ while (isspace(*p)) p++;
+ if (*p) { q=strchr(p,' '); if (q!=NULL) *q++='\0'; }
+ }
+ strcpy(manSect, p!=NULL? p: "?");
+ }
+ sI=0;
+ finitDoc=1;
+ (*fn)(BEGINDOC);
+ /* emit information in .TH line? */
+ } /* else complain about multiple definitions? */
+
+ } else if (checkcmd("SH") || checkcmd("Sh")) { /* section title */
+ while (indent) { source_command("RE"); }
+ source_flush();
+
+ pop(BEGINSECTION); /* before reset sectheadid */
+
+ if (*p) {
+ if (*p=='"') { p++; q=p; while (*q && *q!='"') q++; *q='\0'; }
+ finnf=0;
+ for (j=0; (sectheadid=j)<RANDOM; j++) if (strcoloncmp2(p,'\0',sectheadname[j],0)) break;
+ if (!finitDoc) {
+ /* handle missing .TH */
+ /* if secthead!=NAME -- insist on this?
+ fprintf(stderr, "Bogus man page: no .TH or \".SH NAME\" lines\n");
+ exit(1);
+ */
+ (*fn)(BEGINDOC);
+ finitDoc=1;
+ }
+ poppush(BEGINSECTION); source_struct(BEGINSECTHEAD);
+ fFlush=0;
+ if (falluc) casify(p);
+ source_out(p); /* people forget the quotes around multiple words */
+ while (isspace(plain[--sI])) /*nada*/;
+ plain[++sI]='\0'; tocadd(plain, BEGINSECTION, CurLine); /* flushed with source_struct above */
+ fFlush=1;
+ source_struct(ENDSECTHEAD);
+ }
+ } else if (checkcmd("SS")) { /* subsection title */
+ while (indent) { source_command("RE"); }
+ source_flush();
+
+ if (*p) {
+ if (*p=='"') { p++; q=p; while (*q && *q!='"') q++; *q='\0'; }
+ finnf=0;
+ source_flush();
+ poppush(BEGINSUBSECTION); source_struct(BEGINSUBSECTHEAD);
+ fFlush=0;
+
+ if (falluc) casify(p);
+ source_out(p); /* people forget the quotes around multiple words */
+ while (isspace(plain[--sI])) /*nada*/;
+ plain[++sI]='\0'; tocadd(plain, BEGINSUBSECTION, CurLine);
+ fFlush=1;
+ source_struct(ENDSUBSECTHEAD);
+ }
+
+ } else if (checkcmd("P") || checkcmd("PP") || checkcmd("LP")) { /* new paragraph */
+ source_flush();
+ poppush(BEGINBODY);
+
+ } else if ((tphp=checkcmd("TP")) || (tphp=checkcmd("HP")) || checkcmd("IP") || checkcmd("LI")) {
+ /* TP, HP: indented paragraph, tag on next line (DL list) */
+ /* IP, LI: tag as argument */
+ source_flush();
+ fFlush=0;
+ finlist=1;
+ if (!tphp) { source_out_word(p); source_list(); }
+ /* lists terminated only at start of non-lists */
+ } else if (checkcmd("RS")) { /* set indent */
+ source_struct(BEGININDENT);
+ indent++;
+ } else if (checkcmd("RE")) {
+ if (indent) indent--;
+ pop(ENDINDENT);
+ source_struct(ENDINDENT);
+#if 0
+ } else if (checkcmd("Xr")) {
+ /* 4.4BSD man ref */
+ supresseol=0;
+ p=source_out_word(p);
+ source_out("(");
+ p=source_out_word(p);
+ source_out(")");
+#endif
+
+ } else if (checkcmd("nf")) {
+ source_struct(SHORTLINE);
+ finnf=1;
+ source_struct(BEGINCODEBLOCK);
+ } else if (checkcmd("fi")) {
+ source_struct(ENDCODEBLOCK);
+ finnf=0;
+ } else if (checkcmd("br")) {
+ source_struct(SHORTLINE);
+ } else if (checkcmd("sp") || checkcmd("SP")) { /* blank lines */
+ /*if (!finTable) {*/
+ if (finnf) source_struct(SHORTLINE); else source_struct(BEGINBODY);
+ /*}*/
+ } else if (checkcmd("ta")) { /* set tab stop(s?) */
+ /* argument is tab stop -- handle these as tables => leave to output format */
+ /* HTML handles tables but not tabs, Tk's text tabs but not tables */
+ /* does cause a linebreak */
+ stagadd(BEGINBODY);
+ } else if (checkcmd("ce")) {
+ /* get line count, recursively filter for that many lines */
+ if (sscanf(p, "%d", &i)) {
+ source_struct(BEGINCENTER);
+ for (; i>0 && (p=source_gets())!=NULL; i--) source_line(p);
+ source_struct(ENDCENTER);
+ }
+
+ /* limited selection of control structures */
+ } else if (checkcmd("if") || (checkcmd("ie"))) { /* if <test> cmd, if <test> command and else on next line */
+ supresseol=1;
+ ie = checkcmd("ie");
+ mylastif=lastif;
+
+ if (*p=='!') { invcond=1; p++; }
+
+ if (*p=='n') { cond=1; p++; } /* masquerading as nroff the right thing to do? */
+ else if (*p=='t') { cond=0; p++; }
+ else if (*p=='(' || *p=='-' || *p=='+' || isdigit(*p)) {
+ if (*p=='(') p++;
+ nif0=atof(p);
+ if (*p=='-' || *p=='+') p++; while (isdigit(*p)) p++;
+ op = *p++; /* operator: =, >, < */
+ if (op==' ') {
+ cond = (nif0!=0);
+ } else {
+ nif1=atoi(p);
+ while (isdigit(*p)) p++;
+ if (*p==')') p++;
+ if (op=='=') cond = (nif0==nif1);
+ else if (op=='<') cond = (nif0<nif1);
+ else /* op=='>' -- ignore >=, <= */ cond = (nif0>nif1);
+ }
+ } else if (!isalpha(*p)) { /* usually quote, ^G in Digital UNIX */
+ /* gobble up comparators between delimiters */
+ delim = *p++;
+ q = if0;
+ while (*p && *p!=delim) {
+ *q++=*p++;
+ }
+ *q='\0';
+ p++;
+ q = if1;
+ while (*p && *p!=delim) {
+ *q++=*p++;
+ }
+ *q='\0';
+ p++;
+ cond = (strcmp(if0,if1)==0);
+ } else cond=0; /* a guess, seems to be right bettern than half the time */
+ if (invcond) cond=1-cond;
+ while (isspace(*p)) p++;
+
+ lastif = cond;
+ if (strncmp(p,"\\{",2)==0) { /* rather than handle groups here, have turn on/off output flag? */
+ p+=2; while (isspace(*p)) p++; /* {{ */
+ while (strncmp(p,".\\}",3)!=0 || strncmp(p,"\\}",2)!=0 /*Solaris*/) {
+ if (cond) source_line(p);
+ if ((p=source_gets())==NULL) break;
+ }
+ } else if (cond) source_line(p);
+
+ if (ie) source_line(source_gets()); /* do else part with prevailing lastif */
+
+ lastif=mylastif;
+
+ } else if (checkcmd("el")) {
+ mylastif=lastif;
+
+ /* should centralize gobbling of groups */
+ cond = lastif = !lastif;
+ if (strncmp(p,"\\{",2)==0) {
+ p+=2; while (isspace(*p)) p++;
+ while (strncmp(p,".\\}",3)!=0 || strncmp(p,"\\}",2)!=0 /*Solaris*/) {
+ if (cond) source_line(p);
+ if ((p=source_gets())==NULL) break;
+ }
+ } else if (cond) source_line(p);
+
+ lastif=mylastif;
+
+ } else if (checkcmd("ig")) { /* "ignore group" */
+ strcpy(endig,".."); if (*p) { endig[0]='.'; strcpy(&endig[1],p); }
+ while ((p=source_gets())!=NULL) {
+ if (strcmp(p,endig)==0) break;
+ if (!lastif) source_line(p); /* usually ignore line, except in one weird case */
+ }
+
+
+ /* macros and substitutions */
+ } else if (checkcmd("de")) {
+ /* grab key */
+ q=p; while (*q && !isspace(*q)) q++; *q='\0';
+
+ /* if already have a macro of that name, override it */
+ /* could use a good dictionary class */
+ for (insertat=0; insertat<macrocnt; insertat++) {
+ if (strcmp(p,macro[insertat].key)==0) break;
+ }
+ if (insertat==macrocnt) macrocnt++;
+
+ /* should replace one with same name, if one exists */
+ macro[insertat].key = mystrdup(p);
+
+ /* build up macro in plain[] ... */
+ /* everything until ".." line part of macro */
+ q=plain; i=0;
+ while ((p=source_gets())!=NULL) {
+ if (strcmp(p,"..")==0) break;
+ while (*p) { /* append string, interpreting quotes along the way--just double backslash to single now */
+ if (*p=='\\' && p[1]=='\\') p++;
+ *q++=*p++;
+ }
+ *q++='\n';
+ }
+ *q='\0';
+
+ /* ... then copy once have whole thing */
+ macro[insertat].subst = mystrdup(plain);
+ /*fprintf(stderr, "defining macro %s as %s\n", macro[insertat].key, macro[insertat].subst);*/
+ sI=0;
+
+ } else if (checkcmd("rm")) { /* remove macro definition, can have multiple arguments */
+ for (i=0; i<macrocnt; i++) { /* moot as new definitions replace old when conflicts */
+ if (strcmp(p,macro[i].key)) {
+ macro[i] = macro[--macrocnt];
+ break;
+ }
+ }
+
+ } else if (checkcmd("ds")) { /* text substitutions (like macros) */
+ /* /usr/sww/man/man1/CC.1 a good test of this */
+ q = strchr(p,' ');
+ if (q!=NULL) {
+ *q='\0'; q++;
+#if 0
+ while (*++q) /*nada*/;
+#endif
+ if (*q=='"') q++;
+ if (substcnt<SUBSTMAX) {
+ subst[substcnt].key = mystrdup(p); subst[substcnt].subst = mystrdup(q); substcnt++;
+ }
+ /*fprintf(stderr, "defining substitution: name=%s, body=%s\n", p, q);*/
+ }
+
+ } else if (checkcmd("so")) {
+ /* assuming in .../man like nroff, source in file and execute it as nested file, */
+ /* so nested .so's OK */
+
+ err = 1; /* assume error unless successful */
+ if (fTclTk) {
+ err=0;
+ } else if (stat(p, &fileinfo)==0) {
+ sobuf = malloc(fileinfo.st_size + 1);
+ if (sobuf!=NULL) {
+ /* suck in entire file */
+ fid = open(p, O_RDONLY);
+ if (fid!=-1) {
+ if (read(fid, sobuf, fileinfo.st_size) == fileinfo.st_size) {
+ sobuf[fileinfo.st_size]='\0';
+ /* dumb Digital puts \\} closers on same line */
+ /* {{ */
+ for (q=sobuf; (q=strstr(q," \\}"))!=NULL; q+=3) *q='\n';
+ source_subfile(sobuf);
+ err = 0;
+ }
+ close(fid);
+ }
+ free(sobuf);
+ }
+ }
+
+ if (err) {
+ fprintf(stderr, "%s: couldn't read in referenced file %s.\n", argv0, p);
+ if (strchr(p,'/')==NULL) {
+ fprintf(stderr, "\tTry cd'ing into same directory of man page first.\n");
+ } else if (strchr(p,'/')==strrchr(p,'.')) {
+ fprintf(stderr, "\tTry cd'ing into parent directory of man page first.\n");
+ } else {
+ fprintf(stderr, "\tTry cd'ing into ancestor directory that makes relative path valid first.\n");
+ }
+ exit(1);
+ }
+
+
+ /* character formatting */
+ /* reencode m/any as macro definitions? would like to but the below don't have "words" */
+ } else if (checkcmd("ft")) { /* change font, next char is R,I,B. P=previous not supported */
+ if (ft=='B') stagadd(ENDBOLD); else if (ft=='I') stagadd(ENDITALICS);
+ ft = *p++;
+ if (ft=='B') stagadd(BEGINBOLD); else if (ft=='I') stagadd(BEGINITALICS);
+ } else if (checkcmd("B")) {
+ supresseol=0;
+ stagadd(BEGINBOLD); p = source_out_word(p); source_out(p); stagadd(ENDBOLD);
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("I")) {
+ supresseol=0;
+ stagadd(BEGINITALICS); p = source_out_word(p); stagadd(ENDITALICS);
+ source_out(p);
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("BI")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINBOLD); p = source_out_word(p); stagadd(ENDBOLD);
+ if (*p) { stagadd(BEGINITALICS); p = source_out_word(p); stagadd(ENDITALICS); }
+ }
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("IB")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINITALICS); p = source_out_word(p); stagadd(ENDITALICS);
+ if (*p) { stagadd(BEGINBOLD); p = source_out_word(p); stagadd(ENDBOLD); }
+ }
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("RB")) {
+ supresseol=0;
+ while (*p) {
+ p = source_out_word(p);
+ if (*p) { stagadd(BEGINBOLD); p = source_out_word(p); stagadd(ENDBOLD); }
+ }
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("BR")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINBOLD); p = source_out_word(p); stagadd(ENDBOLD);
+ p = source_out_word(p);
+ }
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("IR")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINITALICS); p=source_out_word(p); stagadd(ENDITALICS);
+ p=source_out_word(p);
+ }
+ if (finnf) source_struct(SHORTLINE);
+ } else if (checkcmd("RI")) {
+ supresseol=0;
+ while (*p) {
+ p=source_out_word(p);
+ stagadd(BEGINITALICS); p=source_out_word(p); stagadd(ENDITALICS);
+ }
+ if (finnf) source_struct(SHORTLINE);
+
+
+ /* HP-UX */
+ } else if (checkcmd("SM")) {
+ supresseol=0; source_out("\\s-1"); while (*p) p=source_out(p); source_out("\\s0");
+ } else if (checkcmd("C")) {
+ supresseol=0;
+ stagadd(BEGINCODE); while (*p) p=source_out_word(p); stagadd(ENDCODE);
+ } else if (checkcmd("CR")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINCODE); p=source_out_word(p); stagadd(ENDCODE);
+ if (*p) p=source_out_word(p);
+ }
+ } else if (checkcmd("RC")) {
+ supresseol=0;
+ while (*p) {
+ p=source_out_word(p);
+ if (*p) { stagadd(BEGINCODE); p=source_out_word(p); stagadd(ENDCODE); }
+ }
+ } else if (checkcmd("CI")) {
+ supresseol=0;
+ while (*p) {
+ stagadd(BEGINCODE); p=source_out_word(p); stagadd(ENDCODE);
+ if (*p) { stagadd(BEGINITALICS); p=source_out_word(p); stagadd(ENDITALICS); }
+ }
+
+
+ /* tables */
+ } else if (checkcmd("TS")) {
+ tblc=0; /*tblspanmax=0;*/ tableSep='\0'; /* need to reset each time because tabbed lines (.ta) made into tables too */
+ while ((p = source_gets())!=NULL) {
+ if ((q=strstr(p,"tab"))!=NULL) { /* "tab(" or "tab (". table entry separator */
+ p=(q+3); while (isspace(*p)) p++;
+ p++; /* jump over '(' */
+ tableSep=*p;
+ continue;
+ }
+ if (strincmp(p,"center",strlen("center"))==0) { /* center entire table; should look for "left" and "right", probably */
+ fTableCenter=1; source_struct(BEGINCENTER);
+ p+=strlen("center"); while (isspace(*p)) p++;
+ continue;
+ }
+ if (p[strlen(p)-1]==';') { tblc=0; continue; } /* HP has a prequel terminated by ';' */
+
+ for (i=0; *p; i++,p=q) {
+ if (*p=='.') break;
+ if (*p=='f') p+=2; /* DEC sets font here */
+ q=p+1;
+ if (strchr("lrcn",*q)==NULL) { /* dumb DEC doesn't put spaces between them */
+ while (*q && *q!='.' && !isspace(*q)) q++;
+ }
+ ch=*q; *q='\0';
+ tbl[tblc][i] = mystrdup(p);
+ tbl[tblc][i+1] = ""; /* mark end */
+ *q=ch;
+ while (*q && isspace(*q)) q++;
+ }
+ /*if (i>tblspanmax) tblspanmax=i;*/
+ tbl[tblc++][i]=""; /* mark end */
+ if (*p=='.') break;
+ }
+ tbli=0;
+ source_struct(BEGINTABLE);
+
+ while ((p=source_gets())!=NULL) {
+ if (strncmp(p,".TE",3)==0) break;
+ if (*p=='.') { source_line(p); continue; }
+
+ /* count number of entries on line. if >1, can use to set tableSep */
+ insertat=0; for (j=0; *tbl[tbli][j]; j++) if (*tbl[tbli][j]!='s') insertat++;
+ if (!tableSep && insertat>1) { if (fsourceTab) tableSep='\t'; else tableSep='@'; }
+ source_struct(BEGINTABLELINE);
+ if (strcmp(p,"_")==0 || /* double line */ strcmp(p,"=")==0) {
+ source_out(" ");
+ /*stagadd(HR);*/ /* empty row -- need ROWSPAN for HTML */
+ continue;
+ }
+
+ for (i=0; *tbl[tbli][i] && *p; i++) {
+ tblcellspan=1;
+ tblcellformat = tbl[tbli][i];
+ if (*tblcellformat=='^') { /* vertical span => blank entry */
+ tblcellformat="l";
+ } else if (*tblcellformat=='|') {
+ /* stagadd(VBAR); */
+ continue;
+ } else if (strchr("lrcn", *tblcellformat)==NULL) {
+ tblcellformat="l";
+ /*continue;*/
+ }
+
+ while (strncmp(tbl[tbli][i+1],"s",1)==0) { tblcellspan++; i++; }
+
+ source_struct(BEGINTABLEENTRY);
+ if (toupper(tblcellformat[1])=='B') stagadd(BEGINBOLD);
+ else if (toupper(tblcellformat[1])=='I') stagadd(BEGINITALICS);
+ /* not supporting DEC's w(<num><unit>) */
+
+ if (strcmp(p,"T{")==0) { /* DEC, HP */
+ while (strncmp(p=source_gets(),"T}",2)!=0) source_line(p);
+ p+=2; if (*p) p++;
+ } else {
+ p = source_out0(p, tableSep);
+ }
+ if (toupper(tblcellformat[1])=='B') stagadd(ENDBOLD);
+ else if (toupper(tblcellformat[1])=='I') stagadd(ENDITALICS);
+ source_struct(ENDTABLEENTRY);
+ }
+ if (tbli+1<tblc) tbli++;
+ source_struct(ENDTABLELINE);
+ }
+ source_struct(ENDTABLE);
+ if (fTableCenter) { source_struct(ENDCENTER); fTableCenter=0; }
+
+
+ } else if (checkcmd("nr")) {
+ q=p; while (*q && !isspace(*q)) q++; *q='\0'; q++;
+
+ for (insertat=0; insertat<regcnt; insertat++) {
+ if (strcmp(reg[insertat].name,p)==0) break;
+ }
+ if (insertat==regcnt) { regcnt++; reg[insertat].name = mystrdup(p); } /* else use same name */
+ p=q;
+ if (*q=='+' || *q=='-') q++; /* accept signed, floating point numbers */
+ if (*q=='.') q++;
+ if (!*q || isspace(*q)) { *q++='0'; *q++='\0'; }
+ while (isdigit(*q)) { q++; } *q='\0'; /* ignore units */
+ reg[insertat].value = mystrdup(p);
+
+ } else if (checkcmd("EQ")) { /* eqn not supported */
+ source_out("\\s-1\\fBeqn not supported\\fR\\s0");
+ while ((p=source_gets())!=NULL) {
+ if (strncmp(p,".EN",3)==0) break;
+ }
+
+
+
+ /* Tcl/Tk macros */
+ } else if (fTclTk && (checkcmd("VS") || checkcmd("VE"))) {
+ /* nothing for sidebars */
+ } else if (fTclTk && checkcmd("OP")) {
+ source_struct(BEGINBODY);
+ for (i=0; i<3; i++) {
+ if (fcharout) { source_out(tcltkOP[i]); source_out(": "); }
+ stagadd(BEGINBOLD); p=source_out_word(p); stagadd(ENDBOLD);
+ source_struct(SHORTLINE);
+ }
+ source_struct(BEGINBODY);
+
+ } else if (fTclTk && checkcmd("BS")) { /* box */
+ /*source_struct(HR); -- ugh, no Ouster box */
+ } else if (fTclTk && checkcmd("BE")) {
+ /*source_struct(HR);*/
+
+ } else if (fTclTk && (checkcmd("CS")||checkcmd("DS"))) { /* code excerpt */
+ /* respect line ends, set in teletype */
+ /* source_struct(SHORTLINE); -- done as part of CS's ENDLINE */
+ finnf=1;
+ source_struct(SHORTLINE);
+ if (checkcmd("DS")) source_line(".P");
+ stagadd(BEGINCODE);
+ } else if (fTclTk && (checkcmd("CE")||checkcmd("DE"))) {
+ stagadd(ENDCODE);
+ finnf=0;
+
+ } else if (fTclTk && checkcmd("SO")) {
+ source_struct(BEGINSECTION);
+ source_struct(BEGINSECTHEAD); source_out("STANDARD OPTIONS"); source_struct(ENDSECTHEAD);
+ tblc=1; tbl[0][0]=tbl[0][1]=tbl[0][2]="l"; tbl[0][3]="";
+ source_struct(BEGINTABLE);
+ while (1) {
+ p = source_gets();
+ if ((strncmp(p,".SE",3))==0) break;
+ tblcellformat = "l";
+ source_struct(BEGINTABLELINE);
+ if (*p=='.') {
+ source_command(p);
+ } else {
+ while (*p) {
+ source_struct(BEGINTABLEENTRY);
+ p = source_out0(p, '\t');
+ source_struct(ENDTABLEENTRY);
+ }
+ }
+ source_struct(ENDTABLELINE);
+ }
+ source_struct(ENDTABLE);
+ source_struct(ENDSECTION);
+
+ } else if (fTclTk && checkcmd("AP")) { /* arguments */
+ source_struct(BEGINBODY);
+ p = source_out_word(p); source_out(" ");
+ stagadd(BEGINITALICS); p = source_out_word(p); stagadd(ENDITALICS); source_out("\t");
+ source_out("("); p = source_out_word(p); source_out(")");
+ source_struct(SHORTLINE);
+ source_out("\t");
+ } else if (fTclTk && checkcmd("AS")) { /* arguments */
+
+#if 0
+/* let these be defined as macros. if they're not, they're just caught as unrecognized macros */
+ } else if (checkcmd("ll") || checkcmd("IX") ||
+ checkcmd("nh")||checkcmd("hy")||checkcmd("hc")||checkcmd("hw") /* hyphenation */
+ ) { /* unsupported macros -- usually roff specific */
+
+ fprintf(stderr, "macro \"%s\" not supported -- ignoring\n", cmd);
+#endif
+
+ } else { /* could be a macro definition */
+ supresseol=0;
+
+ for (i=0; i<macrocnt; i++) {
+ if (macro[i].key == NULL) continue; /* !!! how does this happen? */
+ if (checkcmd(macro[i].key)) {
+
+ /* it is, collect arguments */
+ for (j=0; j<9; j++) macroArg[j]="";
+ for (j=0; p!=NULL && *p && j<9; j++, p=q) {
+ endch=' '; if (*p=='"') { endch='"'; p++; }
+ q = strchr(p,endch);
+ if (q!=NULL) {
+ *q++='\0';
+ if (*q && endch!=' ') q++;
+ }
+ macroArg[j] = p;
+ }
+
+ /* instantiate that text, substituting \\[1-9]'s */
+ p = macro[i].subst;
+ q = macrobuf; /* allocated on stack */
+ while (*p) {
+ if (*p=='\\') {
+ p++;
+ if (*p=='t') {
+ *q++ = '\t';
+ p++;
+ } else if (*p=='$' && isdigit(p[1])) {
+ j = p[1]-'0'-1; /* convert to ASCII and align with macroArg array */
+ p+=2;
+ /* *q++='"'; -- no */
+ strcpy(q, macroArg[j]); q += strlen(q);
+ /* *q++='"'; -- no */
+
+ } else {
+ *q++ = '\\';
+ }
+ } else {
+ *q++ = *p++;
+ }
+ }
+ *q='\0';
+
+ /* execute that text */
+ /*fprintf(stderr, "for macro %s, substituted text is \n%s\n", macro[i].key, macrobuf);*/
+ source_subfile(macrobuf);
+
+ break;
+ }
+ }
+
+ /* macro not found */
+ if (i==macrocnt) {
+ /* report missing macros only once */
+ for (j=0; j<macnotcnt; j++) if (strcmp(macnotfound[j],cmd)==0) break;
+ if (j==macnotcnt) {
+ if (!fQuiet) fprintf(stderr, "macro \"%s\" not recognized -- ignoring\n", cmd);
+ q = malloc(strlen(cmd)+1); strcpy(q,cmd);
+ macnotfound[macnotcnt++] = q;
+ }
+ }
+ } /* else command is unrecognized -- ignore it: we're not a complete [tn]roff implementation */
+
+ /* popular but meaningless commands: .ne (need <n> lines--on infinite scroll */
+}
+
+
+static void
+source_line(char *p)
+{
+ /*stagadd(BEGINLINE);*/
+ char *cmd=p;
+ if (p==NULL) return; /* bug somewhere else, but where? */
+
+#if 0
+ if (*p!='.' && *p!='\'' && !finlist) {
+ if (fsourceTab && !fosourceTab) {
+ tblc=1; tbli=0; tableSep='\t';
+ tbl[0][0]=tbl[0][1]=tbl[0][2]=tbl[0][3]=tbl[0][4]=tbl[0][5]=tbl[0][6]=tbl[0][7]=tbl[0][8]="l";
+ source_struct(BEGINTABLE); finTable=1;
+ } else if (!fsourceTab && fosourceTab) {
+ source_struct(ENDTABLE); finTable=0;
+ }
+ fosourceTab=fsourceTab;
+ }
+#endif
+
+ if (*p=='.' /*|| *p=='\'' -- normalized */) { /* command == starts with "." */
+ p++;
+ supresseol=1;
+ source_command(p);
+
+ } else if (!*p) { /* blank line */
+ /*source_command("P");*/
+ ncnt=1; source_struct(BEGINLINE); ncnt=0; /* empty line => paragraph break */
+
+#if 0
+ } else if (fsourceTab && !finlist /* && pmode */) { /* can't handle tabs, so try tables */
+ source_struct(BEGINTABLE);
+ tblcellformat = "l";
+ do {
+ source_struct(BEGINTABLELINE);
+ while (*p) {
+ source_struct(BEGINTABLEENTRY);
+ p = source_out0(p, '\t');
+ source_struct(ENDTABLEENTRY);
+ }
+ source_struct(ENDTABLELINE);
+ } while ((p=source_gets())!=NULL && fsourceTab);
+ source_struct(ENDTABLE);
+ source_line(p);
+#endif
+
+ } else { /* otherwise normal text */
+ source_out(p);
+ if (finnf || isspace(*cmd)) source_struct(SHORTLINE);
+ }
+
+ if (!supresseol && !finnf) { source_out(" "); if (finlist) source_list(); }
+ supresseol=0;
+ /*stagadd(ENDLINE);*/
+}
+
+
+static void
+source_filter(void)
+{
+ char *p = in, *q;
+ char *oldv,*newv,*shiftp,*shiftq,*endq;
+ int lenp,lenq;
+ int i,on1,on2,nn1,nn2,first;
+ int insertcnt=0, deletecnt=0, insertcnt0;
+ int nextDiffLine=-1;
+ char diffcmd, tmpc, tmpendq;
+
+ AbsLine=0;
+
+ /* just count length of macro table! */
+ for (i=0; macro[i].key!=NULL; i++) /*empty*/;
+ macrocnt = i;
+
+ /* {{ dumb Digital puts \\} closers on same line */
+ for (p=in; (p=strstr(p," \\}"))!=NULL; p+=3) *p='\n';
+
+ sI=0;
+ /* (*fn)(BEGINDOC); -- done at .TH or first .SH */
+
+
+ /* was: source_subfile(in); */
+ while (fDiff && fgets(diffline, MAXBUF, difffd)!=NULL) {
+ /* requirements: no context lines, no errors in files, ...
+ change-command: 8a12,15 or 5,7c8,10 or 5,7d3
+ < from-file-line
+ < from-file-line...
+ --
+ > to-file-line
+ > to-file-line...
+ */
+ for (q=diffline; ; q++) { diffcmd=*q; if (diffcmd=='a'||diffcmd=='c'||diffcmd=='d') break; }
+ if (sscanf(diffline, "%d,%d", &on1,&on2)==1) on2=on1-1+(diffcmd=='d'||diffcmd=='c');
+ if (sscanf(++q, "%d,%d", &nn1,&nn2)==1) nn2=nn1-1+(diffcmd=='a'||diffcmd=='c');
+
+ deletecnt = on2-on1+1;
+ insertcnt = nn2-nn1+1;
+
+ nextDiffLine = nn1;
+ /*assert(nextDiffLine>=AbsLine); -- can happen if inside a macro? */
+ if (nextDiffLine<AbsLine) continue;
+
+ while (AbsLine<nextDiffLine && (p=source_gets())!=NULL) {
+ source_line(p);
+ }
+
+ insertcnt0=insertcnt+1; /* eat duplicate insert lines and '---' too */
+ diffline2[0] = '\0';
+ while (insertcnt && deletecnt) {
+ if (ungetc(fgetc(difffd),difffd)=='<') { fgetc(difffd); fgetc(difffd); } /* skip '<' */
+ /* fill buffer with old line -- but replace if command */
+ /* stay away from commands -- too careful if .B <word> */
+ do {
+ p = oldv = fgets(diffline, MAXBUF, difffd);
+ p[strlen(p)-1]='\0'; /* fgets's \n ending => \0 */
+ deletecnt--;
+ } while (deletecnt && *p=='.'); /* throw out commands in old version */
+
+ q = newv = source_gets();
+ insertcnt--;
+ while (insertcnt && *q=='.') {
+ source_line(q);
+ insertcnt--;
+ }
+
+ if (*p=='.' || *q=='.') break;
+
+
+ /* make larger chunk for better diff -- but still keep away from commands */
+ lenp=strlen(p); lenq=strlen(q);
+ while (deletecnt && MAXBUF-lenq>80*2) {
+ fgetc(difffd); fgetc(difffd); /* skip '<' */
+ if (ungetc(fgetc(difffd),difffd)=='.') break;
+ p=&diffline[lenp]; *p++=' '; lenp++;
+ fgets(p, MAXBUF-lenp, difffd); p[strlen(p)-1]='\0'; lenp+=strlen(p);
+ deletecnt--;
+ }
+
+ while (insertcnt && *in!='.' && MAXBUF-lenq>80*2) {
+ if (newv!=diffline2) { strcpy(diffline2,q); newv=diffline2; }
+ q=source_gets(); diffline2[lenq]=' '; lenq++;
+ strcpy(&diffline2[lenq],q); lenq+=strlen(q);
+ insertcnt--;
+ }
+
+ /* common endings */
+ p = &p[strlen(oldv)]; q=&q[strlen(newv)];
+ while (p>oldv && q>newv && p[-1]==q[-1]) { p--; q--; }
+ if ((p>oldv && p[-1]=='\\') || (q>newv && q[-1]=='\\'))
+ while (*p && *q && !isspace(*p)) { p++; q++; } /* steer clear of escapes */
+ tmpendq=*q; *p=*q='\0'; endq=q;
+
+ p=oldv; q=newv;
+ while (*p && *q) {
+ /* common starts */
+ newv=q; while (*p && *q && *p==*q) { p++; q++; }
+ if (q>newv) {
+ tmpc=*q; *q='\0'; source_line(newv); *q=tmpc;
+ }
+
+ /* too hard to read */
+ /* difference: try to find hunk of p in remainder of q */
+ if (strlen(p)<15 || (shiftp=strchr(&p[15],' ') /*|| shiftp-p>30*/)==NULL) break;
+ shiftp++; /* include the space */
+ tmpc=*shiftp; *shiftp='\0'; shiftq=strstr(q,p); *shiftp=tmpc; /* includes space */
+ if (shiftq!=NULL) {
+ /* call that part of q inserted */
+ tmpc=*shiftq; *shiftq='\0';
+ stagadd(BEGINDIFFA); source_line(q); stagadd(ENDDIFFA); source_line(" ");
+ *shiftq=tmpc; q=shiftq;
+ } else {
+ /* call that part of p deleted */
+ shiftp--; *shiftp='\0'; /* squash the trailing space */
+ stagadd(BEGINDIFFD); source_line(p); stagadd(ENDDIFFD); source_line(" ");
+ p=shiftp+1;
+ }
+/*#endif*/
+ }
+
+ if (*p) { stagadd(BEGINDIFFD); source_line(p); stagadd(ENDDIFFD); }
+ if (*q) { stagadd(BEGINDIFFA); source_line(q); stagadd(ENDDIFFA); }
+ if (tmpendq!='\0') { *endq=tmpendq; source_line(endq); }
+ source_line(" ");
+ }
+
+ /* even if diffcmd=='c', could still have remaining old version lines */
+ first=1;
+ while (deletecnt--) {
+ fgets(diffline, MAXBUF, difffd);
+ if (diffline[2]!='.') {
+ if (first) { stagadd(BEGINDIFFD); first=0; }
+ source_line(&diffline[2]); /* don't do commands; skip initial '<' */
+ }
+ }
+ if (!first) { stagadd(ENDDIFFD); source_line(" "); }
+
+ /* skip over duplicated from old */
+ if (diffcmd=='c') while (insertcnt0--) fgets(diffline, MAXBUF, difffd);
+
+ /* even if diffcmd=='c', could still have remaining new version lines */
+ first=1;
+ nextDiffLine = AbsLine + insertcnt;
+ while (insertcnt--) fgets(diffline, MAXBUF, difffd); /* eat duplicate text of above */
+ while (/*insertcnt--*/AbsLine<nextDiffLine && (p=source_gets())!=NULL) {
+ if (first && *p!='.') { stagadd(BEGINDIFFA); first=0; }
+ source_line(p);
+ }
+ if (!first) { stagadd(ENDDIFFA); source_line(" "); }
+ }
+ /* finish up remainder (identical to both) */
+ while ((p=source_gets())!=NULL) {
+ source_line(p);
+ }
+
+ source_flush();
+ pop(ENDDOC); (*fn)(ENDDOC);
+}
+
+
+
+/*
+ * STARTUP
+ */
+
+static int
+setFilterDefaults(char *outputformat)
+{
+ static struct {
+ void (*fn)(enum command);
+ int fPara; int fQS; int fIQS; int fNOHY; int fChangeleft; int fURL; char *names;
+ /* (could set parameters at BEGINDOC call...) */
+ } format[] = {
+ /*{default 0par 0qs 0iqs 0hy 0cl 0url "name"},*/
+ { ASCII, 0, 0, 0, 0, 0, 0, "ASCII" },
+ { TkMan, 0, 0, 0, 0, 0, 0, "TkMan" },
+ { Tk, 0, 0, 0, 0, 0, 0, "Tk:Tcl" },
+ { Sections, 0, 0, 0, 0, 0, 0, "sections" },
+ { Roff, 0, 1, 1, 1, -1, 0, "roff:troff:nroff" },
+ { HTML, 1, 1, 1, 1, 1, 1, "HTML:WWW:htm" },
+ { XML, 1, 1, 1, 1, 1, 1, "XML:docbook:DocBook" },
+ { MIME, 1, 1, 1, 1, 1, 0, "MIME:Emacs:enriched" },
+ { LaTeX, 1, 1, 1, 1, 1, 0, "LaTeX:LaTeX209:209:TeX" },
+ { LaTeX2e, 1, 1, 1, 1, 1, 0, "LaTeX2e:2e" },
+ { RTF, 1, 1, 1, 1, 1, 0, "RTF" },
+ { pod, 0, 0, 1, 0, -1, 0, "pod:Perl" },
+
+ { PostScript, 0, 0, 0, 0, 0, 0, "PostScript:ps" },
+ { FrameMaker, 0, 0, 0, 0, 0, 0, "FrameMaker:Frame:Maker:MIF" },
+
+ { NULL, 0, 0, 0, 0, 0, 0, NULL }
+ };
+
+ int i, found=0;
+ for (i=0; format[i].fn!=NULL; i++) {
+ if (strcoloncmp2(outputformat,'\0',format[i].names,0)) {
+ fn = format[i].fn;
+ fPara = format[i].fPara;
+ fQS = format[i].fQS;
+ fIQS = format[i].fIQS;
+ fNOHY = format[i].fNOHY;
+ fChangeleft = format[i].fChangeleft;
+ fURL = format[i].fURL;
+ found=1;
+ break;
+ }
+ }
+
+ return (found==0);
+}
+
+
+/* read in whole file. caller responsible for freeing memory */
+static char *
+filesuck(FILE *in)
+{
+ const int inc=1024*100; /* what's 100K these days? */
+ int len=0,cnt;
+ char *file = malloc(1); /*NULL -- relloc on NULL not reducing to malloc on some machines? */
+
+ do {
+ file = realloc(file, len+inc+1); /* what's the ANSI way to find the file size? */
+ cnt = fread(&file[len], 1, inc, in);
+ len+=cnt;
+ } while (cnt==inc);
+ file[len]='\0';
+
+ return file;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int c;
+ int i,j;
+ char *p,*oldp;
+ int fname=0;
+ const int helpbreak=75;
+ const int helpispace=4;
+ int helplen=0;
+ int desclen;
+ char **argvch; /* remapped argv */
+/* FILE *macros; -- interpret -man macros? */
+
+ char strgetopt[80];
+ /* options with an arg must have a '<' in the description */
+ static struct { char letter; int arg; char *longnames; char *desc; } option[] = {
+ { 'f', 1, "filter", " <ASCII|roff|TkMan|Tk|Sections|HTML|XML|MIME|LaTeX|LaTeX2e|RTF|pod>" },
+ { 'S', 0, "source", "(ource of man page passed in)" }, /* autodetected */
+ { 'F', 0, "formatted:format", "(ormatted man page passed in)" }, /* autodetected */
+
+ { 'r', 1, "reference:manref:ref", " <man reference printf string>" },
+ { 'l', 1, "title", " <title printf string>" },
+ { 'V', 1, "volumes:vol", "(olume) <colon-separated list>" },
+ { 'U', 0, "url:urls", "(RLs as hyperlinks)" },
+
+ /* following options apply to formatted pages only */
+ { 'b', 0, "subsections:sub", " (show subsections)" },
+ { 'k', 0, "keep:head:foot:header:footer", "(eep head/foot)" },
+ { 'n', 1, "name", "(ame of man page) <string>" },
+ { 's', 1, "section:sect", "(ection) <string>" },
+ { 'p', 0, "paragraph:para", "(aragraph mode toggle)" },
+ { 't', 1, "tabstop:tabstops", "(abstops spacing) <number>" },
+ { 'N', 0, "normalize:normal", "(ormalize spacing, changebars)" },
+ { 'y', 0, "zap:nohyphens", " (zap hyphens toggle)" },
+ { 'K', 0, "nobreak", " (declare that page has no breaks)" }, /* autodetected */
+ { 'd', 1, "diff", "(iff) <file> (diff of old page source to incorporate)" },
+ { 'M', 1, "message", "(essage) <text> (included verbatim at end of Name section)" },
+ /*{ 'l', 0, "number lines", "... can number lines in a pipe" } */
+ /*{ 'T', 0, "tables", "(able agressive parsing ON)" },*/
+/* { 'c', 0, "changeleft:changebar", "(hangebarstoleft toggle)" }, -- default is perfect */
+ /*{ 'R', 0, "reflow", "(eflow text lines)" },*/
+ { 'R', 1, "rebus", "(ebus words for TkMan)" },
+ { 'C', 0, "TclTk", " (enable Tcl/Tk formatting)" }, /* autodetected */
+
+ /*{ 'D', 0, "debug", "(ebugging mode)" }, -- dump unrecognized macros, e.g.*/
+ { 'o', 0, "noop", " (no op)" },
+ { 'O', 0, "noop", " <arg> (no op with arg)" },
+ { 'q', 0, "quiet", "(uiet--don't report warnings)" },
+ { 'h', 0, "help", "(elp)" },
+ /*{ '?', 0, "help", " (help)" }, -- getopt returns '?' as error flag */
+ { 'v', 0, "version", "(ersion)" },
+ { '\0', 0, "", NULL }
+ };
+
+ /* calculate strgetopt from options list */
+ for (i=0,p=strgetopt; option[i].letter!='\0'; i++) {
+ *p++ = option[i].letter;
+ /* check for duplicate option letters */
+ assert(strchr(strgetopt,option[i].letter)==&p[-1]);
+ if (option[i].arg) *p++=':';
+ }
+ *p='\0';
+
+ /* spot check construction of strgetopt */
+ assert(p<strgetopt+80);
+ assert(strlen(strgetopt)>10);
+ assert(strchr(strgetopt,'f')!=NULL);
+ assert(strchr(strgetopt,'v')!=NULL);
+ assert(strchr(strgetopt,':')!=NULL);
+
+ /* count, sort exception strings */
+ for (lcexceptionslen=0; (p=lcexceptions[lcexceptionslen])!=NULL; lcexceptionslen++) /*empty*/;
+ qsort(lcexceptions, lcexceptionslen, sizeof(char*), lcexceptionscmp);
+
+ /* map long option names to single letters for switching */
+ /* (GNU probably has a reusable function to do this...) */
+ /* deep six getopt in favor of integrated long names + letters? */
+ argvch = malloc(argc * sizeof(char*));
+ p = malloc(argc*3 * sizeof(char)); /* either -<char>'\0' or no space used */
+ for (i=0; i<argc; i++) argvch[i]=argv[i]; /* need argvch[0] for getopt? */
+ argv0 = mystrdup(argv[0]);
+ for (i=1; i<argc; i++) {
+ if (argv[i][0]=='-' && argv[i][1]=='-') {
+ if (argv[i][2]=='\0') break; /* end of options */
+ for (j=0; option[j].letter!='\0'; j++) {
+ if (strcoloncmp2(&argv[i][2],'\0',option[j].longnames,0)) {
+ argvch[i] = p;
+ *p++ = '-'; *p++ = option[j].letter; *p++ = '\0';
+ if (option[j].arg) i++; /* skip arguments of options */
+ break;
+ }
+ }
+ if (option[j].letter=='\0') fprintf(stderr, "%s: unknown option %s\n", argv[0], argv[i]);
+ }
+ }
+
+
+
+ /* pass through options to set defaults for chosen format */
+ setFilterDefaults("ASCII"); /* default to ASCII (used by TkMan's Glimpse indexing */
+
+ /* initialize header/footer buffers (save room in binary) */
+ for (i=0; i<CRUFTS; i++) { *cruft[i] = '\0'; } /* automatically done, guaranteed? */
+ /*for (i=0; i<MAXLINES; i++) { linetabcnt[i] = 0; } */
+
+ while ((c=getopt(argc,argvch,strgetopt))!=-1) {
+
+ switch (c) {
+ case 'k': fHeadfoot=1; break;
+ case 'b': fSubsections=1; break;
+/* case 'c': fChangeleft=1; break; -- obsolete */
+ /* case 'R': fReflow=1; break;*/
+ case 'n': strcpy(manName,optarg); fname=1; break; /* name & section for when using stdin */
+ case 's': strcpy(manSect,optarg); break;
+ /*case 'D': docbookpath = optarg; break;*/
+ case 'V': vollist = optarg; break;
+ case 'l': manTitle = optarg; break;
+ case 'r': manRef = optarg;
+ if (strlen(manRef)==0 || strcmp(manRef,"-")==0 || strcmp(manRef,"off")==0) fmanRef=0;
+ break;
+ case 't': TabStops=atoi(optarg); break;
+ /*case 'T': fTable=1; break; -- if preformatted doesn't work, if source automatic */
+ case 'p': fPara=!fPara; break;
+ case 'K': fFoot=1; break;
+ case 'y': fNOHY=1; break;
+ case 'N': fNORM=1; break;
+
+ case 'f': /* set format */
+ if (setFilterDefaults(optarg)) {
+ fprintf(stderr, "%s: unknown format: %s\n", argv0, optarg);
+ exit(1);
+ }
+ break;
+ case 'F': fSource=0; break;
+ case 'S': fSource=1; break;
+
+ case 'd':
+ difffd = fopen(optarg, "r");
+ if (difffd==NULL) { fprintf(stderr, "%s: can't open %s\n", argv0, optarg); exit(1); }
+/* read in a line at a time
+ diff = filesuck(fd);
+ fclose(fd);
+*/
+ fDiff=1;
+ break;
+
+ case 'M': message = optarg; break;
+
+ case 'C': fTclTk=1; break;
+ case 'R':
+ p = malloc(strlen(optarg)+1);
+ strcpy(p, optarg); /* string may not be in writable address space */
+ oldp = "";
+ for (; *p; oldp=p, p++) {
+ if (*oldp=='\0') rebuspat[rebuspatcnt++] = p;
+ if (*p=='|') *p='\0';
+ }
+ for (i=0; i<rebuspatcnt; i++) rebuspatlen[i] = strlen(rebuspat[i]); /* for strnlen() */
+ break;
+
+ case 'q': fQuiet=1; break;
+ case 'o': /*no op*/ break;
+ case 'O': /* no op with arg */ break;
+ case 'h':
+ printf("rman"); helplen=strlen("rman");
+
+ /* linebreak options */
+ assert(helplen>0);
+ for (i=0; option[i].letter!='\0'; i++) {
+ desclen = strlen(option[i].desc);
+ if (helplen+desclen+5 > helpbreak) { printf("\n%*s",helpispace,""); helplen=helpispace; }
+ printf(" [-%c%s]", option[i].letter, option[i].desc);
+ helplen += desclen+5;
+ }
+ if (helplen>helpispace) printf("\n");
+ printf("%*s [<filename>]\n",helpispace,"");
+ exit(0);
+
+ case 'v': /*case '?':*/
+ printf("PolyglotMan v" POLYGLOTMANVERSION "\n");
+ exit(0);
+
+ default:
+ fprintf(stderr, "%s: unidentified option -%c (-h for help)\n",argvch[0],c);
+ exit(2);
+ }
+ }
+
+
+
+ /* read from given file name(s) */
+ if (optind<argc) {
+ if (!fname) { /* if no name given, create from file name */
+ /* take name from tail of path */
+ if ((p=strrchr(argvch[optind],'/'))!=NULL) p++; else p=argvch[optind];
+ strcpy(manName,p);
+
+ /* search backward from end for final dot. split there */
+ if ((p=strrchr(manName,'.'))!=NULL) {
+ strcpy(manSect,p+1);
+ *p='\0';
+ }
+ }
+
+ strcpy(plain,argvch[optind]);
+
+ if (freopen(argvch[optind], "r", stdin)==NULL) {
+ fprintf(stderr, "%s: can't open %s\n", argvch[0], argvch[optind]);
+ exit(1);
+ }
+ }
+
+ /* need to read macros, ok if fail; from /usr/lib/tmac/an => needs to be set in Makefile, maybe a searchpath */
+ /*
+ if ((macros=fopen("/usr/lib/tmac/an", "r"))!=NULL) {
+ in = File = filesuck(macros);
+ lookahead = File[0];
+ source_filter();
+ free(File);
+ }
+ */
+
+ /* suck in whole file and just operate on pointers */
+ in = File = filesuck(stdin);
+
+
+ /* minimal check for roff source: first character dot command or apostrophe comment */
+ /* MUST initialize lookahead here, BEFORE first call to la_gets */
+ if (fSource==-1) {
+ lookahead = File[0];
+ fSource = (lookahead=='.' || lookahead=='\'' || /*dumb HP*/lookahead=='/'
+ /* HP needs this too but causes problems || isalpha(lookahead)--use --source flag*/);
+ }
+
+ if (fDiff && (!fSource || fn!=HTML)) {
+ fprintf(stderr, "diff incorporation supported for man page source, generating HTML\n");
+ exit(1);
+ }
+
+ if (fSource) source_filter(); else preformatted_filter();
+ if (fDiff) fclose(difffd);
+ /*free(File); -- let system clean up, perhaps more efficiently */
+
+ return 0;
+}
diff --git a/nx-X11/extras/rman/rman.html b/nx-X11/extras/rman/rman.html
new file mode 100644
index 000000000..746ee16fc
--- /dev/null
+++ b/nx-X11/extras/rman/rman.html
@@ -0,0 +1,342 @@
+<html>
+<head>
+<title>PolyglotMan Manual Page</title>
+</head>
+
+<body>
+<h1>Name</h1>
+
+PolyglotMan, rman - reverse compile man pages from formatted form to a number of source formats
+
+<h1>Synopsis</h1>
+
+rman [<i>options</i>] [<var>file</var>]
+
+<h1>Description</h1>
+
+<p><i>PolyglotMan</i> takes man pages from most of the
+popular flavors of UNIX and transforms them into any of a number of
+text source formats. PolyglotMan was formerly known as RosettaMan.
+The name of the binary is still called <tt>rman</tt>, for scripts
+that depend on that name; mnemonically, just think "reverse man".
+Previously <i>PolyglotMan</i> required pages to
+be formatted by nroff prior to its processing. With version 3.0, it <i>prefers
+[tn]roff source</i> and usually produces results that are better yet.
+And source processing is the only way to translate tables.
+Source format translation is not as mature as formatted, however, so
+try formatted translation as a backup.
+
+<p>In parsing [tn]roff source, one could implement an arbitrarily
+large subset of [tn]roff, which I did not and will not do, so the
+results can be off. I did implement a significant subset of those use
+in man pages, however, including tbl (but not eqn), if tests, and
+general macro definitions, so usually the results look great. If they
+don't, format the page with nroff before sending it to PolyglotMan. If
+PolyglotMan doesn't recognize a key macro used by a large class of
+pages, however, e-mail me the source and a uuencoded nroff-formatted
+page and I'll see what I can do. When running PolyglotMan with man
+page source that includes or redirects to other [tn]roff source using
+the .so (source or inclusion) macro, you should be in the parent
+directory of the page, since pages are written with this assumption.
+For example, if you are translating /usr/man/man1/ls.1, first cd into
+/usr/man.
+
+<p><i>PolyglotMan</i> accepts <em>formatted</em> man pages from:
+<blockquote>SunOS, Sun Solaris, Hewlett-Packard HP-UX,
+AT&amp;T System V, OSF/1 aka Digital UNIX, DEC Ultrix, SGI IRIX, Linux,
+FreeBSD, SCO.</blockquote>
+Man page <em>source</em> processing works for:
+<blockquote>SunOS, Sun Solaris, Hewlett-Packard HP-UX,
+AT&amp;T System V, OSF/1 aka Digital UNIX, DEC Ultrix.</blockquote>
+It can produce
+<blockquote>printable ASCII-only (control characters
+stripped), section headers-only,
+Tk, TkMan, [tn]roff (traditional man page source), partial DocBook XML, HTML, MIME,
+LaTeX, LaTeX2e, RTF, Perl 5 POD.</blockquote>
+A modular architecture permits easy addition of additional output
+formats.</p>
+
+<p>The latest version of PolyglotMan is available via
+<a href='http://polyglotman.sourceforge.net/'>http://polyglotman.sourceforge.net/</a>.
+
+
+<h1>Options</h1>
+
+<p>The following options should not be used with any others and exit PolyglotMan
+without processing any input.
+
+<dl>
+<dt>-h|--help</dt>
+<dd>Show list of command line options and exit.</dd>
+
+<dt>-v|--version</dt>
+<dd>Show version number and exit.</dd>
+</dl>
+
+
+<p><em>You should specify the filter first, as this sets a number of parameters,
+and then specify other options.</em>
+
+<dl>
+<dt>-f|--filter &lt;ASCII|roff|TkMan|Tk|Sections|HTML|MIME|LaTeX|LaTeX2e|RTF|POD&gt;</dt>
+
+<dd>Set the output filter. Defaults to ASCII.
+<!-- If you are converting
+from formatted roff source, it is recommended that you prevent hyphenation by using
+groff, making file with the contents ".hpm 20", can reading this in
+before the roff source, e.g., groff -Tascii -man <hpm-file> <roff-source>.
+-->
+</dd>
+
+<dt>-S|--source</dt>
+<dd>PolyglotMan tries to automatically determine whether its input is source or formatted;
+use this option to declare source input.</dd>
+
+<dt>-F|--format|--formatted</dt>
+<dd>PolyglotMan tries to automatically determine whether its input is source or formatted;
+use this option to declare formatted input.</dd>
+
+<dt>-l|--title <i>printf-string</i></dt>
+<dd>In HTML mode this sets the &lt;TITLE&gt; of the man pages, given the same
+parameters as <tt>-r</tt>.</dd>
+
+<dt>-r|--reference|--manref <i>printf-string</i></dt>
+<dd>In HTML <!--and SGML--> mode this sets the URL form by which to retrieve other man pages.
+The string can use two supplied parameters: the man page name and its section.
+(See the Examples section.) If the string is null (as if set from a shell
+by "-r ''"), `-' or `off', then man page references will not be HREFs, just set in italics.
+If your printf supports XPG3 positions specifier, this can be quite flexible.</dd>
+
+<dt>-V|--volumes <i>&lt;colon-separated list&gt;</i></dt>
+<dd>Set the list of valid volumes to check against when looking for
+cross-references to other man pages. Defaults to <tt>1:2:3:4:5:6:7:8:9:o:l:n:p</tt>
+(volume names can be multicharacter).
+If an non-whitespace string in the page is immediately followed by a left
+parenthesis, then one of the valid volumes, and ends with optional other
+characters and then a right parenthesis--then that string is reported as
+a reference to another manual page. If this -V string starts with an equals
+sign, then no optional characters are allowed between the match to the list of
+valids and the right parenthesis. (This option is needed for SCO UNIX.)
+</dd>
+
+</dl>
+
+
+<p>The following options apply only when formatted pages are given as input.
+They do not apply or are always handled correctly with the source.
+
+<dl>
+<dt>-b|--subsections</dt>
+<dd>Try to recognize subsection titles in addition to section titles.
+This can cause problems on some UNIX flavors.</dd>
+
+<dt>-K|--nobreak</dt>
+<dd>Indicate manual pages don't have page breaks, so don't look for footers and headers
+around them. (Older nroff -man macros always put in page breaks, but lately
+some vendors have realized that printout are made through troff, whereas
+nroff -man is used to format pages for reading on screen, and so have eliminated
+page breaks.) <i>PolyglotMan</i> usually gets this right even without this flag.</dd>
+
+<dt>-k|--keep</dt>
+<dd>Keep headers and footers, as a canonical report at the end of the page.</dd>
+
+<!-- this done automatically for Tcl/Tk pages; doesn't apply for others
+<dt>-c|--changeleft</dt>
+<dd>Move changebars, such as those found in the Tcl/Tk manual pages,
+to the left.</dd>
+-->
+
+<!-- agressive parsing works so well that this option has been removed
+<dt>-m|--notaggressive</dt>
+<dd><i>Disable</i> aggressive man page parsing. Aggressive manual,
+which is on by default, page parsing elides headers and footers,
+identifies sections and more.</dd>
+-->
+
+<dt>-n|--name <i>name</i></dt>
+<dd>Set name of man page (used in roff format).
+If the filename is given in the form "<i>name</i>.<i>section</i>", the name
+and section are automatically determined. If the page is being parsed from
+[tn]roff source and it has a .TH line, this information is extracted from that line.</dd>
+
+<dt>-p|--paragraph</dt>
+<dd>paragraph mode toggle. The filter determines whether lines should be linebroken
+as they were by nroff, or whether lines should be flowed together into paragraphs.
+Mainly for internal use.</dd>
+
+<dt>-s|section <i>#</i></dt>
+<dd>Set volume (aka section) number of man page (used in roff format).</dd>
+
+<!-- if in source automatic, if in preformatted really doesn't work
+<dt>-T|--tables</dt>
+<dd>Turn on aggressive table parsing.</dd>
+-->
+
+<dt>-t|--tabstops <i>#</i></dt>
+<dd>For those macros sets that use tabs in place of spaces where
+possible in order to reduce the number of characters used, set
+tabstops every <i>#</i> columns. Defaults to 8.</dd>
+
+
+</dl>
+
+
+<h1>Notes on Filter Types</h1>
+
+<h2>ROFF</h2>
+<p>Some flavors of UNIX ship man page without [tn]roff source, making one's laser printer
+little more than a laser-powered daisy wheel. This filer tries to intuit
+the original [tn]roff directives, which can then be recompiled by [tn]roff.</p>
+
+<h2>TkMan</h2>
+<p>TkMan, a hypertext man page browser, uses <i>PolyglotMan</i> to show
+man pages without the (usually) useless headers and footers on each
+pages. It also collects section and (optionally) subsection heads for
+direct access from a pulldown menu. TkMan and Tcl/Tk, the toolkit in
+which it's written, are available via anonymous ftp from
+<tt>ftp://ftp.smli.com/pub/tcl/</tt></p>
+
+<h2>Tk</h2>
+
+<p>This option outputs the text in a series of Tcl lists consisting of
+text-tags pairs, where tag names roughly correspond to HTML. This
+output can be inserted into a Tk text widget by doing an <tt>eval
+&lt;textwidget&gt; insert end &lt;text&gt;</tt>. This format should be relatively
+easily parsible by other programs that want both the text and the
+tags. Also see ASCII.</p>
+
+<h2>ASCII</h2>
+<p>When printed on a line printer, man pages try to produce special text effects
+by overstriking characters with themselves (to produce bold) and underscores
+(underlining). Other text processing software, such as text editors, searchers,
+and indexers, must counteract this. The ASCII filter strips away this formatting.
+Piping nroff output through <tt>col -b</tt> also strips away this formatting,
+but it leaves behind unsightly page headers and footers. Also see Tk.</p>
+
+<h2>Sections</h2>
+<p>Dumps section and (optionally) subsection titles. This might be useful for
+another program that processes man pages.</p>
+
+<h2>HTML</h2>
+<p>With a simple extention to an HTTP server for Mosaic or other World Wide Web
+browser, <i>PolyglotMan</i> can produce high quality HTML on the fly.
+Several such extensions and pointers to several others are included in <i>PolyglotMan</i>'s
+<tt>contrib</tt> directory.</p>
+
+<h2>XML</h2>
+<p>This is appoaching the Docbook DTD, but I'm hoping that someone that someone
+with a real interest in this will polish the tags generated. Try it to see
+how close the tags are now.</p>
+
+<p>Improved by Aaron Hawley, but still he notes
+<blockquote>
+Output requires human intervention to become proper
+DocBook format. This is a result of the fundamental
+nature of nroff and DocBook xml. One is marked for
+formating the other is marked for semantics (defining
+what the content is rather then what it should look
+like). For instance, italics and bold formatting are
+converted to emphasis and command DocBook elements
+respectively even though they should probably be marked
+up as command, option, literal, arg, option and other
+possible DocBook tags.
+</blockquote>
+</p>
+
+<h2>MIME</h2>
+<p>MIME (Multipurpose Internet Mail Extensions) as defined by RFC 1563,
+good for consumption by MIME-aware e-mailers or as Emacs (>=19.29)
+enriched documents.</p>
+
+<h2>LaTeX and LaTeX2e</h2>
+Why not?
+
+<h2>RTF</h2>
+<p>Use output on Mac or NeXT or whatever. Maybe take random man pages
+and integrate with NeXT's documentation system better. Maybe NeXT has
+own man page macros that do this.</p>
+
+<h2>PostScript and FrameMaker</h2>
+<p>To produce PostScript, use <tt>groff</tt> or <tt>psroff</tt>. To produce FrameMaker MIF,
+use FrameMaker's built-in filter. In both cases you need <tt>[tn]roff</tt> source,
+so if you only have a formatted version of the manual page, use <i>PolyglotMan</i>'s
+roff filter first.</p>
+
+
+<h1>Examples</h1>
+
+<p>To convert the <i>formatted</i> man page named <tt>ls.1</tt> back into
+[tn]roff source form:</p>
+
+<p>
+ <tt>rman -f roff /usr/local/man/cat1/ls.1 > /usr/local/man/man1/ls.1</tt><br>
+
+<p>Long man pages are often compressed to conserve space (compression is
+especially effective on formatted man pages as many of the characters
+are spaces). As it is a long man page, it probably has subsections,
+which we try to separate out (some macro sets don't distinguish
+subsections well enough for <i>PolyglotMan</i> to detect them). Let's convert
+this to LaTeX format:<br>
+
+<p>
+ <tt>pcat /usr/catman/a_man/cat1/automount.z | rman -b -n automount -s 1 -f latex > automount.man</tt><br>
+
+<p>Alternatively,
+
+ <tt>man 1 automount | rman -b -n automount -s 1 -f latex > automount.man</tt><br>
+
+<p>For HTML/Mosaic users, <i>PolyglotMan</i> can, without modification of the
+source code, produce HTML links that point to other HTML man pages
+either pregenerated or generated on the fly. First let's assume
+pregenerated HTML versions of man pages stored in <i>/usr/man/html</i>.
+Generate these one-by-one with the following form:<br>
+
+ <tt>rman -f html -r 'http:/usr/man/html/%s.%s.html' /usr/man/cat1/ls.1 > /usr/man/html/ls.1.html</tt><br>
+
+<p>If you've extended your HTML client to generate HTML on the fly you should use
+something like:<br>
+
+ <tt>rman -f html -r 'http:~/bin/man2html?%s:%s' /usr/man/cat1/ls.1</tt><br>
+
+when generating HTML.</p>
+
+
+<h1>Bugs/Incompatibilities</h1>
+
+<p><i>PolyglotMan</i> is not perfect in all cases, but it usually does a
+good job, and in any case reduces the problem of converting man pages
+to light editing.</p>
+
+<p>Tables in formatted pages, especially H-P's, aren't handled very well.
+Be sure to pass in source for the page to recognize tables.</p>
+
+<p>The man pager <i>woman</i> applies its own idea of formatting for
+man pages, which can confuse <i>PolyglotMan</i>. Bypass <i>woman</i>
+by passing the formatted manual page text directly into
+<i>PolyglotMan</i>.</p>
+
+<p>The [tn]roff output format uses fB to turn on boldface. If your macro set
+requires .B, you'll have to a postprocess the <i>PolyglotMan</i> output.</p>
+
+
+
+<h1>See Also</h1>
+
+<tt>tkman(1)</tt>, <tt>xman(1)</tt>, <tt>man(1)</tt>, <tt>man(7)</tt> or <tt>man(5)</tt> depending on your flavor of UNIX
+
+<p>GNU groff can now output to HTML.
+
+
+<h1>Author</h1>
+
+<p>PolyglotMan<br>
+Copyright (c) 1994-2003 T.A. Phelps<br />
+
+developed at the<br>
+University of California, Berkeley<br />
+Computer Science Division
+
+<p>Manual page last updated on $Date: 2005/07/15 15:45:29 $
+
+</body>
+</html>