/contrib/tcsh/tcsh.man2html

https://bitbucket.org/freebsd/freebsd-head/ · Unknown · 850 lines · 692 code · 158 blank · 0 comment · 0 complexity · fc90b457ad7a8b413d31de35b250a768 MD5 · raw file 

    

  1. : # -*- perl -*-
    2. 

  2. # $tcsh: tcsh.man2html,v 1.15 2011/02/05 16:15:56 christos Exp $
    3. 

  3. 

  4. # tcsh.man2html, Dave Schweisguth <dcs@proton.chem.yale.edu>
    5. 

  5. #
    6. 

  6. # Notes:
    7. 

  7. #
    8. 

  8. # Always puts all files in the directory tcsh.html, creating it if necessary.
    9. 

  9. # tcsh.html/top.html is the entry point, and tcsh.html/index.html is a symlink
    10. 

  10. # to tcsh.html/top.html so one needn't specify a file at all if working through
    11. 

  11. # a typically configured server.
    12. 

  12. #
    13. 

  13. # Designed for tcsh manpage. Guaranteed not to work on manpages not written
    14. 

  14. # in the exact same style of nroff -man, i.e. any other manpage.
    15. 

  15. #
    16. 

  16. # Makes links FROM items which are both a) in particular sections (see
    17. 

  17. # Configuration) and b) marked with .B or .I. Makes links TO items which
    18. 

  18. # are marked with \fB ... \fR or \fI ... \fR.
    19. 

  19. #
    20. 

  20. # Designed with X Mosaic in mind and tested lightly with lynx. I've punted on
    21. 

  21. # HTML's lack of a .PD equivalent and lynx's different <menu> handling.
    22. 

  22. 

  23. # Emulate #!/usr/local/bin/perl on systems without #!
    24. 

  24. 

  25. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
    26. 

  26. & eval 'exec perl -S $0 $argv:q' if 0;
    27. 

  27. 

  28. ### Constants
    29. 

  29. 

  30. # Setup
    31. 

  31. 

  32. ($whatami = $0)	=~ s|.*/||;	# `basename $0`
    33. 

  33. $isatty		= -t STDIN;
    34. 

  34. 

  35. # Configuration
    36. 

  36. 

  37. $index		= 0;		# Don't make a searchable index CGI script
    38. 

  38. $cgibin		= 0;		# Look for $cgifile in $dir, not $cgibindir
    39. 

  39. $shortfiles	= 0;		# Use long filenames
    40. 

  40. $single		= 0;		# Make single page instead of top and sections
    41. 

  41. 

  42. $host		= '';		# host:port part of server URL ***
    43. 

  43. $updir		= '';		# Directories between $host and $dir ***
    44. 

  44. $dir		= 'tcsh';	# Directory in which to put the pieces *
    45. 

  45. $cgifile	= 'tcsh.cgi';	# CGI script name **
    46. 

  46. $cgibindir	= 'cgi-bin';	# CGI directory ***
    47. 

  47. $headerfile	= 'header';	# HTML file for initial comments *
    48. 

  48. $indexfile	= 'index';	# Symlink to $topfile *
    49. 

  49. $listsfile	= 'lists';	# Mailing list description HTML file *	
    50. 

  50. $outfile	= 'tcsh.man';	# Default input file and copy of input file
    51. 

  51. $script		= $whatami;	# Copy of script; filename length must be OK
    52. 

  52. $topfile	= 'top';	# Top-level HTML file *
    53. 

  53. 

  54. # *   .htm or .html suffix added later
    55. 

  55. # **  Only used with -i or -c
    56. 

  56. # *** Only used with -c
    57. 

  57. 

  58. # Sections to inline in the top page
    59. 

  59. 

  60. %inline_me	= ('NAME',	1,
    61. 

  61. 		   'SYNOPSIS',	1);
    62. 

  62. 

  63. # Sections in which to put name anchors and the font in which to look for
    64. 

  64. # links to those anchors
    65. 

  65. 

  66. %link_me	= ('Editor commands',		'I',
    67. 

  67. 		   'Builtin commands',		'I',
    68. 

  68. 		   'Special aliases',		'I',
    69. 

  69. 		   'Special shell variables',	'B',
    70. 

  70. 		   'ENVIRONMENT',		'B',
    71. 

  71. 		   'FILES',			'I');
    72. 

  72. 

  73. ### Arguments and error-checking
    74. 

  74. 

  75. # Parse args
    76. 

  76. 

  77. while ($#ARGV > -1 && (($first, $rest) = ($ARGV[0] =~ /^-(.)(.*)/))) {
    78. 

  78.     # Perl 5 lossage alert
    79. 

  79.     if ($first =~ /[CdDGh]/) {	# Switches with arguments
    80. 

  80.     	shift;
    81. 

  81.     	$arg = $rest ne '' ? $rest : $ARGV[0] ne '' ? shift :
    82. 

  82.       	    &usage("$whatami: -$first requires an argument.\n");
    83. 

  83.     } elsif ($rest ne '') {
    84. 

  84.     	$ARGV[0] = "-$rest";
    85. 

  85.     } else {
    86. 

  86. 	shift;
    87. 

  87.     }
    88. 

  88.     if	  ($first eq '1')   { $single = 1; }
    89. 

  89.     elsif ($first eq 'c')   { $cgibin = 1; }
    90. 

  90.     elsif ($first eq 'C')   { $cgibindir = $arg; }
    91. 

  91.     elsif ($first eq 'd')   { $updir = $arg; }
    92. 

  92.     elsif ($first eq 'D')   { $dir = $arg; }
    93. 

  93.     elsif ($first eq 'G')   { $cgifile = $arg; }
    94. 

  94.     elsif ($first eq 'h')   { $host = $arg; }
    95. 

  95.     elsif ($first eq 'i')   { $index = 1; }
    96. 

  96.     elsif ($first eq 's')   { $shortfiles = 1; }
    97. 

  97.     elsif ($first eq 'u')   { &usage(0); }
    98. 

  98.     else		    { &usage("$whatami: -$first is not an option.\n"); }
    99. 

  99. }
    100. 

  100. 

  101. if (@ARGV == 0) {
    102. 

  102.     if ($isatty) {
    103. 

  103.         $infile = $outfile;		# Default input file if interactive
    104. 

  104.     } else {
    105. 

  105. 	$infile = 'STDIN';		# Read STDIN if no args and not a tty
    106. 

  106.     }
    107. 

  107. } elsif (@ARGV == 1) {
    108. 

  108.     $infile = $ARGV[0];
    109. 

  109. } else {
    110. 

  110.     &usage("$whatami: Please specify one and only one file.\n");
    111. 

  111. }
    112. 

  112. 

  113. $index = $index || $cgibin;		# $index is true if $cgibin is true
    114. 

  114. 

  115. if ($cgibin && ! $host) {
    116. 

  116.     die "$whatami: Must specify host with -h if using -c.\n";
    117. 

  117. }
    118. 

  118. 

  119. # Decide on HTML suffix and append it to filenames
    120. 

  120. 

  121. $html = $shortfiles ? 'htm' : 'html';	# Max 3-character extension
    122. 

  122. $dir		.= ".$html";		# Directory in which to put the pieces
    123. 

  123. $headerfile	.= ".$html";		# HTML file for initial comments
    124. 

  124. $topfile	.= ".$html";		# Top-level HTML file (or moved notice)
    125. 

  125. $indexfile	.= ".$html";		# Symlink to $topfile
    126. 

  126. $listsfile	.= ".$html";		# Mailing list description HTML file
    127. 

  127. 

  128. # Check for input file
    129. 

  129. 

  130. unless ($infile eq 'STDIN') {
    131. 

  131.     die "$whatami: $infile doesn't exist!\n"	unless -e $infile;
    132. 

  132.     die "$whatami: $infile is unreadable!\n"	unless -r _;
    133. 

  133.     die "$whatami: $infile is empty!\n"		unless -s _;
    134. 

  134. }
    135. 

  135. 

  136. # Check for output directory and create if necessary
    137. 

  137. 

  138. if (-e $dir) {
    139. 

  139.     -d _ || die "$whatami: $dir is not a directory!\n";
    140. 

  140.     -r _ && -w _ && -x _ || die "$whatami: $dir is inaccessible!\n"
    141. 

  141. } else {
    142. 

  142.     mkdir($dir, 0755) || die "$whatami: Can't create $dir!\n";
    143. 

  143. }
    144. 

  144. 

  145. # Slurp manpage
    146. 

  146. 

  147. if ($infile eq 'STDIN') {
    148. 

  148.     @man = <STDIN>;
    149. 

  149. } else {
    150. 

  150.     open(MAN, $infile) || die "$whatami: Error opening $infile!\n";
    151. 

  151.     @man = <MAN>;
    152. 

  152.     close MAN;
    153. 

  153. }
    154. 

  154. 

  155. # Print manpage to HTML directory (can't use cp if we're reading from STDIN)
    156. 

  156. 

  157. open(MAN, ">$dir/$outfile") || die "$whatami: Can't open $dir/$outfile!\n";
    158. 

  158. print MAN @man;
    159. 

  159. close MAN;
    160. 

  160. 

  161. # Copy script to HTML directory
    162. 

  162. 

  163. (system("cp $0 $dir") >> 8) && die "$whatami: Can't copy $0 to $dir!\n";
    164. 

  164. 

  165. # Link top.html to index.html in case someone looks at tcsh.html/
    166. 

  166. 

  167. system("rm -f $dir/$indexfile");    # Some systems can't ln -sf
    168. 

  168. (system("ln -s $topfile $dir/$indexfile") >> 8)
    169. 

  169.     && die "$whatami: Can't link $topfile to $dir/$indexfile!\n";
    170. 

  170. 

  171. ### Get title and section headings
    172. 

  172. 

  173. $comment = 0;			    # 0 for text, 1 for ignored text
    174. 

  174. @sectionlines = (0);		    # First line of section
    175. 

  175. @sectiontypes = (0);		    # H or S
    176. 

  176. @sectiontexts = ('Header');	    # Text of section heading
    177. 

  177. @sectionfiles = ($headerfile);	    # Filename in which to store section
    178. 

  178. %name = ();			    # Array of name anchors
    179. 

  179. @name = () if $index;		    # Ordered array of name anchors
    180. 

  180. $font = '';		    	    # '' to not make names, 'B' or 'I' to do so
    181. 

  181. 

  182. $line = 0;
    183. 

  183. foreach (@man) {
    184. 

  184.     if (/^\.ig/) {		    # Start ignoring
    185. 

  185. 	$comment = 1;
    186. 

  186.     } elsif (/^\.\./) {		    # Stop ignoring
    187. 

  187. 	$comment = 0;
    188. 

  188.     } elsif (! $comment) {	    # Not in .ig'ed section; do stuff
    189. 

  189. 	
    190. 

  190. 	# nroff special characters
    191. 

  191. 	
    192. 

  192. 	s/\\-/-/g;		    # \-
    193. 

  193. 	s/\\^//g;		    # \^
    194. 

  194. 	s/^\\'/'/;		    # leading ' escape
    195. 

  195. 	s/^\\(\s)/$1/;		    # leading space escape
    196. 

  196. 	s/\\(e|\\)/\\/g;	    # \e, \\; must do this after other escapes
    197. 

  197. 

  198. 	# HTML special characters; deal with these before adding more
    199. 

  199. 	
    200. 

  200. 	s/&/&amp\;/g;
    201. 

  201. 	s/>/&gt\;/g;
    202. 

  202. 	s/</&lt\;/g;
    203. 

  203. 	
    204. 

  204. 	# Get title
    205. 

  205. 	
    206. 

  206. 	if (/^\.TH\s+(\w+)\s+(\w+)\s+\"([^\"]*)\"\s+\"([^\"]*)\"/) {
    207. 

  207. 	    $title = "$1($2) $4 ($3) $1($2)";
    208. 

  208. 	}
    209. 

  209. 	
    210. 

  210. 	# Build per-section info arrays
    211. 

  211. 	
    212. 

  212. 	if (($type, $text) = /^\.S([HS])\s+\"?([^\"]*)\"?/) {
    213. 

    214. 

  214. 	    push(@sectionlines, $line);	    # Index of first line of section
    215. 

  215. 	    push(@sectiontypes, $type eq 'H' ? 0 : 1);	# Type of section
    216. 

  216. 	    $text =~ s/\s*$//;		    # Remove trailing whitespace
    217. 

  217. 	    push(@sectiontexts, $text);	    # Title of section (key for href)
    218. 

  218. 	    $text =~ s/\s*\(\+\)$//;	    # Remove (+)
    219. 

  219. 	    if ($shortfiles) {
    220. 

  220. 		$file = $#sectionlines;	    # Short filenames; use number
    221. 

  221. 	    } else {
    222. 

  222. 		$file = $text;		    # Long filenames; use title
    223. 

  223. 		$file =~ s/[\s\/]+/_/g;	    # Replace whitespace and / with _
    224. 

  224. 	    }
    225. 

  225. 	    $file .= ".$html" unless $single;
    226. 

  226. 	    push(@sectionfiles, $file);	    # File in which to store section
    227. 

  227. 	    $name{"$text B"} = ($single ? '#' : '') . $file;
    228. 

  228. 					    # Index entry for &make_hrefs
    229. 

  229. 	    push(@name, "$text\t" . $name{"$text B"}) if $index;
    230. 

  230. 					    # Index entry for CGI script
    231. 

  231. 	    # Look for anchors in the rest of this section if $link_me{$text}
    232. 

  232. 	    # is non-null, and mark them with the font which is its value
    233. 

  233. 

  234. 	    $font = $link_me{$text};
    235. 

  235.     	}
    236. 

  236. 	&make_name(*name, *font, *file, *index, *_) if $font;
    237. 

  237.     }
    238. 

  238.     $line++;
    239. 

  239. }
    240. 

  240. 

  241. ### Make top page
    242. 

  242. 

  243. open(TOP, ">$dir/$topfile");
    244. 

  244. select TOP;
    245. 

  245. 

  246. # Top page header
    247. 

  247. 

  248. print <<EOP;
    249. 

  249. <HEAD>
    250. 

  250. <TITLE>$title</TITLE>
    251. 

  251. </HEAD>
    252. 

  252. <BODY>
    253. 

  253. <A NAME="top"></A>
    254. 

  254. <H1>$title</H1>
    255. 

  255. <HR>
    256. 

  256. EOP
    257. 

  257. 

  258. # FORM block, if we're making an index
    259. 

    260. 

  260. $action = $cgibin ? "http://$host/$cgibindir/$cgifile" : $cgifile;
    261. 

  261. 

  262. print <<EOP if $index;
    263. 

  263. <FORM METHOD="GET" ACTION="$action">
    264. 

  264. Go directly to a section, command or variable: <INPUT NAME="input">
    265. 

  265. </FORM>
    266. 

  266. EOP
    267. 

  267. 

  268. # Table of contents
    269. 

  269. 

  270. print <<EOP;
    271. 

  271. <H2>
    272. 

  272. EOP
    273. 

  273. 

  274. foreach $section (1 .. $#sectionlines) {
    275. 

  275.     if ($sectiontypes[$section - 1] < $sectiontypes[$section]) {
    276. 

  276. 	print "</H2> <menu>\n";	    # Indent, smaller font
    277. 

  277.     } elsif ($sectiontypes[$section - 1] > $sectiontypes[$section]) {
    278. 

  278. 	print "</menu> <H2>\n";	    # Outdent, larger font
    279. 

  279.     }
    280. 

  280.     if ($inline_me{$sectiontexts[$section]}) {    # Section is in %inline_me
    281. 

  281. 	
    282. 

  282. 	# Print section inline
    283. 

  283. 	
    284. 

  284. 	print "$sectiontexts[$section]\n";
    285. 

  285. 	print "</H2> <menu>\n";	    # Indent, smaller font
    286. 

  286. 	&printsectionbody(*man, *sectionlines, *section, *name);
    287. 

  287. 	print "</menu> <H2>\n";	    # Outdent, larger font
    288. 

  288.     } else {
    289. 

  289. 	
    290. 

  290. 	# Print link to section
    291. 

  291. 	
    292. 

  292. 	print "<A HREF=\"", $single ? '#' : '',
    293. 

  293. 	    "$sectionfiles[$section]\">$sectiontexts[$section]</A><BR>\n";
    294. 

  294.     }
    295. 

  295. }
    296. 

  296. 

  297. print <<EOP;
    298. 

  298. </H2>
    299. 

  299. EOP
    300. 

  300. 

  301. print "<HR>\n" if $single;
    302. 

  302. 

  303. ### Make sections
    304. 

  304. 

  305. foreach $section (0 .. $#sectionlines) {
    306. 

  306. 

  307.     # Skip inlined sections
    308. 

  308. 

  309.     next if $inline_me{$sectiontexts[$section]};
    310. 

  310.     
    311. 

  311.     if ($single) {
    312. 

  312. 

  313. 	# Header
    314. 

  314.     
    315. 

  315. 	print <<EOP if $section;	# Skip header section
    316. 

  316. <H2><A NAME="$sectionfiles[$section]">$sectiontexts[$section]</A></H2>
    317. 

  317. <menu>
    318. 

  318. EOP
    319. 

  319. 	&printsectionbody(*man, *sectionlines, *section, *name);
    320. 

  320. 	print <<EOP if $section;	# Skip header section
    321. 

  321. <A HREF="#top">Table of Contents</A>
    322. 

  322. </menu>
    323. 

  323. EOP
    324. 

  324. 

  325.     } else {
    326. 

  326. 

  327. 	# Make pointer line for header and trailer
    328. 

  328. 	
    329. 

  329. 	$pointers  = "<A HREF=\"$topfile\">Up</A>";
    330. 

  330. 	$pointers .= "\n<A HREF=\"$sectionfiles[$section + 1]\">Next</A>"
    331. 

  331. 	    if ($section < $#sectionlines) &&
    332. 

  332. 	    ! $inline_me{$sectiontexts[$section + 1]};
    333. 

  333. 	$pointers .= "\n<A HREF=\"$sectionfiles[$section - 1]\">Previous</A>"
    334. 

  334. 	    if ($section > 1) &&		# section 0 is initial comments
    335. 

  335. 	    ! $inline_me{$sectiontexts[$section - 1]};
    336. 

  336.     
    337. 

  337. 	# Header
    338. 

  338. 

  339. 	open(OUT, ">$dir/$sectionfiles[$section]");
    340. 

  340. 	select OUT;
    341. 

  341. 	print <<EOP;
    342. 

  342. <HEAD>
    343. 

  343. <TITLE>$sectiontexts[$section]</TITLE>
    344. 

  344. </HEAD>
    345. 

  345. <BODY>
    346. 

  346. $pointers
    347. 

  347. <H2>$sectiontexts[$section]</H2>
    348. 

  348. EOP
    349. 

  349. 	&printsectionbody(*man, *sectionlines, *section, *name);
    350. 

  350. 

  351. 	# Trailer
    352. 

  352. 

  353. 	print <<EOP;
    354. 

  354. $pointers
    355. 

  355. </BODY>
    356. 

  356. EOP
    357. 

  357. 

  358.     }
    359. 

  359. }
    360. 

  360. 

  361. select TOP unless $single;
    362. 

  362. 

  363. # Top page trailer
    364. 

  364. 

  365. print <<EOP;
    366. 

  366. </H2>
    367. 

  367. <HR>
    368. 

  368. Here are the <A HREF="$outfile">nroff manpage</A> (175K)
    369. 

  369. from which this HTML version was generated,
    370. 

  370. the <A HREF="$script">Perl script</A> which did the conversion
    371. 

  371. and the <A HREF="ftp://ftp.astron.com/pub/tcsh/">
    372. 

  372. complete source code</A> for <I>tcsh</I>.
    373. 

  373. <HR>
    374. 

  374. <I>tcsh</I> is maintained by
    375. 

  375. Christos Zoulas <A HREF="mailto:christos\@gw.com">&lt;christos\@gw.com&gt;</A>
    376. 

  376. and the <A HREF="$listsfile"><I>tcsh</I> maintainers' mailing list</A>.
    377. 

  377. Dave Schweisguth <A HREF="mailto:dcs\@proton.chem.yale.edu">&lt;dcs\@proton.chem.yale.edu&gt;</A>
    378. 

  378. wrote the manpage and the HTML conversion script.
    379. 

  379. </BODY>
    380. 

  380. EOP
    381. 

  381. 

  382. close TOP;
    383. 

  383. 

  384. ### Make lists page
    385. 

  385. 

  386. open(LISTS, ">$dir/$listsfile");
    387. 

  387. select LISTS;
    388. 

  388. while(($_ = <DATA>) ne "END\n") {   # Text stored after __END__
    389. 

  389.     s/TOPFILEHERE/$topfile/;
    390. 

  390.     print;
    391. 

  391. }
    392. 

  392. close LISTS;
    393. 

  393. 

  394. ### Make search script
    395. 

  395. 

  396. if ($index) {
    397. 

  397. 

  398.     # URL of $dir; see comments in search script
    399. 

  399. 

  400.     $root = $cgibin
    401. 

  401. 	? "'http://$host/" . ($updir ? "$updir/" : '') . "$dir/'"
    402. 

  402. 	: '"http://$ENV{\'SERVER_NAME\'}:$ENV{\'SERVER_PORT\'}" . (($_ = $ENV{\'SCRIPT_NAME\'}) =~ s|[^/]*$||, $_)';
    403. 

  403. 

  404.     # String for passing @name to search script
    405. 

  405. 

  406.     $name = join("',\n'", @name);
    407. 

  407. 

  408.     open(TOP, ">$dir/$cgifile");
    409. 

  409.     select TOP;
    410. 

  410.     while(($_ = <DATA>) ne "END\n") {   # Text stored after __END__
    411. 

  411. 	s/ROOTHERE/$root/;
    412. 

  412. 	s/NAMEHERE/$name/;
    413. 

  413. 	s/TOPFILEHERE/$topfile/;
    414. 

  414. 	print;
    415. 

  415.     }
    416. 

  416.     close TOP;
    417. 

  417.     chmod(0755, "$dir/$cgifile") ||
    418. 

  418. 	die "$whatami: Can't chmod 0755 $dir/$cgifile!\n";
    419. 

  419.     warn "$whatami: Don't forget to move $dir/$cgifile to /$cgibindir.\n"
    420. 

  420. 	if $cgibin;
    421. 

  421. }
    422. 

  422. 

  423. ### That's all, folks
    424. 

    425. 

  425. exit;
    426. 

  426. 

  427. ### Subroutines
    428. 

  428. 

  429. # Process and print the body of a section
    430. 

  430. 

  431. sub printsectionbody {
    432. 

  432. 

  433.     local(*man, *sectionlines, *sline, *name) = @_;	# Number of section
    434. 

  434.     local($sfirst, $slast, @paralines, @paratypes, $comment, $dl, $pline,
    435. 

  435. 	  $comment, $pfirst, $plast, @para, @tag, $changeindent);
    436. 

  436. 

  437.     # Define section boundaries
    438. 

  438. 

  439.     $sfirst = $sectionlines[$sline] + 1;
    440. 

  440.     if ($sline == $#sectionlines) {
    441. 

  441. 	$slast = $#man;
    442. 

  442.     } else {
    443. 

  443. 	$slast = $sectionlines[$sline + 1] - 1;
    444. 

  444.     }
    445. 

  445. 

  446.     # Find paragraph markers, ignoring those between '.ig' and '..'
    447. 

  447. 

  448.     if ($man[$sfirst] =~ /^\.[PIT]P/) {
    449. 

  449. 	@paralines = ();
    450. 

  450. 	@paratypes = ();
    451. 

  451.     } else {
    452. 

  452. 	@paralines = ($sfirst - 1);		# .P follows .S[HS] by default
    453. 

  453. 	@paratypes = ('P');
    454. 

  454.     }
    455. 

  455.     $comment = 0;
    456. 

  456.     foreach ($sfirst .. $slast) {
    457. 

  457. 	if ($man[$_] =~ /^\.ig/) {		# Start ignoring
    458. 

  458. 	    $comment = 1;
    459. 

  459. 	} elsif ($man[$_] =~ /^\.\./) {		# Stop ignoring
    460. 

  460. 	    $comment = 0;
    461. 

  461. 	} elsif (! $comment && $man[$_] =~ /^\.([PIT])P/) {
    462. 

  462. 	    push(@paralines, $_);
    463. 

  463. 	    push(@paratypes, $1);
    464. 

  464. 	}
    465. 

  465.     }
    466. 

  466. 

  467.     # Process paragraphs
    468. 

  468. 

  469.     $changeindent = 0;
    470. 

  470.     $dl = 0;
    471. 

  471.     foreach $pline (0 .. $#paralines) {
    472. 

  472. 

  473. 	@para = ();
    474. 

  474. 	$comment = 0;
    475. 

  475. 

  476. 	# Define para boundaries
    477. 

  477. 

  478. 	$pfirst = $paralines[$pline] + 1;
    479. 

  479. 	if ($pline == $#paralines) {
    480. 

  480. 	    $plast = $slast;
    481. 

  481. 	} else {
    482. 

  482. 	    $plast = $paralines[$pline + 1] - 1;
    483. 

  483. 	}
    484. 

  484. 

  485. 	foreach (@man[$pfirst .. $plast]) {
    486. 

  486. 	    if (/^\.ig/) {		    # nroff begin ignore
    487. 

  487. 		if ($comment == 0) {
    488. 

  488. 		    $comment = 2;
    489. 

  489. 		    push(@para, "<!--\n");
    490. 

  490. 		} elsif ($comment == 1) {
    491. 

  491. 		    $comment = 2;
    492. 

  492. 		} elsif ($comment == 2) {
    493. 

  493. 		    s/--/-/g;		    # Remove double-dashes in comments
    494. 

  494. 		    push(@para, $_);
    495. 

  495. 		}
    496. 

  496. 	    } elsif (/^\.\./) {		    # nroff end ignore
    497. 

  497. 		if ($comment == 0) {
    498. 

  498. 		    ;
    499. 

  499. 		} elsif ($comment == 1) {
    500. 

  500. 		    ;
    501. 

  501. 		} elsif ($comment == 2) {
    502. 

  502. 		    $comment = 1;
    503. 

  503. 		}
    504. 

  504. 	    } elsif (/^\.\\\"/) {	    # nroff comment
    505. 

  505. 		if ($comment == 0) {
    506. 

  506. 		    $comment = 1;
    507. 

  507. 		    push(@para, "<!--\n");
    508. 

  508. 		    s/^\.\\\"//;
    509. 

  509. 		} elsif ($comment == 1) {
    510. 

  510. 		    s/^\.\\\"//;
    511. 

  511. 		} elsif ($comment == 2) {
    512. 

  512. 		    ;
    513. 

  513. 		}
    514. 

  514. 		s/--/-/g;		    # Remove double-dashes in comments
    515. 

  515. 		push(@para, $_);
    516. 

  516. 	    } else {			    # Nothing to do with comments
    517. 

  517. 		if ($comment == 0) {
    518. 

  518. 		    ;
    519. 

  519.     		} elsif ($comment == 1) {
    520. 

  520. 		    $comment = 0;
    521. 

  521. 		    push(@para, "-->\n");
    522. 

  522. 		} elsif ($comment == 2) {
    523. 

  523. 		    s/--/-/g;		    # Remove double-dashes in comments
    524. 

  524. 		}
    525. 

  525. 

  526. 		unless ($comment) {
    527. 

  527. 		
    528. 

  528. 		    if (/^\.TH/) {	    # Title; got this already
    529. 

  529. 			next;
    530. 

  530. 		    } elsif (/^\.PD/) {	    # Para spacing; unimplemented
    531. 

  531. 			next;
    532. 

  532. 		    } elsif (/^\.RS/) {	    # Indent (one width only)
    533. 

  533. 			$changeindent++;
    534. 

  534. 			next;
    535. 

  535. 		    } elsif (/^\.RE/) {	    # Outdent
    536. 

  536. 			$changeindent--;
    537. 

  537. 			next;
    538. 

  538. 		    }
    539. 

  539. 

  540. 		    # Line break
    541. 

  541. 		    s/^\.br.*/<BR>/;
    542. 

  542. 

  543. 		    # More nroff special characters
    544. 

  544. 

  545. 		    s/^\\&amp\;//;	    # leading dot escape; save until
    546. 

  546. 					    #   now so leading dots aren't
    547. 

  547. 					    #   confused with ends of .igs
    548. 

  548. 

  549. 		    &make_hrefs(*name, *_);			
    550. 

  550. 		}
    551. 

  551. 		push(@para, $_);
    552. 

  552. 	    }
    553. 

  553. 	}
    554. 

  554. 	
    555. 

  555. 	push(@para, "-->\n") if $comment;   # Close open comment
    556. 

  556. 	
    557. 

  557.     	# Print paragraph
    558. 

  558. 

  559. 	if ($paratypes[$pline] eq 'P') {
    560. 

  560. 	    &font(*para);
    561. 

  561. 	    print   @para;
    562. 

  562. 	} elsif ($paratypes[$pline] eq 'I') {
    563. 

  563. 	    &font(*para);
    564. 

  564. 	    print   "<menu>\n",
    565. 

  565. 		    @para,
    566. 

  566. 		    "</menu>\n";
    567. 

  567. 	} else {			# T
    568. 

  568. 	    @tag = shift(@para);
    569. 

  569. 	    &font(*tag);
    570. 

  570. 	    &font(*para);
    571. 

  571. 	    print   "<DL compact>\n" unless $dl;
    572. 

  572. 	    print   "<DT>\n",
    573. 

  573. 		    @tag,
    574. 

  574. 		    "<DD>\n",
    575. 

  575. 		    @para;
    576. 

  576. 	    if ($pline == $#paratypes || $paratypes[$pline + 1] ne 'T') {
    577. 

  577. 		# Perl 5 lossage alert
    578. 

  578. 		# Next para is not a definition list
    579. 

  579. 		$dl = 0;		    # Close open definition list
    580. 

  580. 		print "</DL>\n";
    581. 

  581. 	    } else {
    582. 

  582. 		$dl = 1;		    # Leave definition list open
    583. 

  583. 	    }
    584. 

  584. 	}
    585. 

  585. 	print "<P>\n";
    586. 

  586. 	
    587. 

  587. 	# Indent/outdent the *next* para
    588. 

  588. 	
    589. 

  589. 	while ($changeindent > 0) {
    590. 

  590. 	    print "<menu>\n";
    591. 

  591. 	    $changeindent--;
    592. 

  592. 	}
    593. 

  593. 	while ($changeindent < 0) {
    594. 

  594. 	    print "</menu>\n";
    595. 

  595. 	    $changeindent++;
    596. 

  596. 	}
    597. 

  597.     }
    598. 

  598.     1;
    599. 

  599. }
    600. 

  600. 

  601. # Make one name anchor in a line; cue on fonts (.B or .I) but leave them alone
    602. 

  602. 

  603. sub make_name {
    604. 

  604. 

  605.     local(*name, *font, *file, *index, *line) = @_;
    606. 

  606.     local($text);
    607. 

  607. 

  608.     if (($text) = ($line =~ /^\.[BI]\s+([^\s\\]+)/)) {	# Found pattern
    609. 

  609. 

  610. 	if (
    611. 

  611. 	    $text !~ /^-/		    # Avoid lists of options
    612. 

  612. 	    && (length($text) > 1	    # and history escapes
    613. 

  613. 		||  $text =~ /^[%:@]$/)	    # Special pleading for %, :, @
    614. 

  614. 	    && ! $name{"$text $font"}	    # Skip if there's one already
    615. 

  615. 	) {
    616. 

  616. 	    # Record link
    617. 

  617. 	    
    618. 

  618. 	    $name{"$text $font"} = ($single ? '' : $file) . "#$text";
    619. 

  619. 	    push(@name, "$text\t" . $name{"$text $font"}) if $index;
    620. 

  620. 	    
    621. 

  621. 	    # Put in the name anchor
    622. 

  622.     
    623. 

  623. 	    $line =~ s/^(\.[BI]\s+)([^\s\\]+)/$1<A NAME=\"$text\">$2<\/A>/;
    624. 

  624. 	}
    625. 

  625.     }
    626. 

  626.     $line;
    627. 

  627. }
    628. 

  628. 

  629. # Make all the href anchors in a line; cue on fonts (\fB ... \fR or
    630. 

  630. # \fI ... \fR) but leave them alone
    631. 

  631. 

  632. sub make_hrefs {
    633. 

  633. 

  634.     local(*name, *line) = @_;
    635. 

  635.     local(@pieces, $piece);
    636. 

  636. 

  637.     @pieces = split(/(\\f[BI][^\\]*\\fR)/, $line);
    638. 

  638.     
    639. 

  639.     $piece = 0;
    640. 

  640.     foreach (@pieces) {
    641. 

  641. 	if (/\\f([BI])([^\\]*)\\fR/	# Found a possibility
    642. 

  642. 

  643. 	# It's not followed by (, i.e. it's not a manpage reference
    644. 

  644. 

  645. 	&& substr($pieces[$piece + 1], 0, 1) ne '(') {
    646. 

  646. 	    $key = "$2 $1";
    647. 

  647. 	    if ($name{$key}) {			# If there's a matching name
    648. 

  648. 		s/(\\f[BI])([^\\]*)(\\fR)/$1<A HREF=\"$name{$key}\">$2<\/A>$3/;
    649. 

  649. 	    }
    650. 

  650. 	}
    651. 

  651. 	$piece++;
    652. 

  652.     }
    653. 

  653.     $line = join('', @pieces);
    654. 

  654. }
    655. 

  655. 

  656. # Convert nroff font escapes to HTML
    657. 

  657. # Expects comments and breaks to be in HTML form already
    658. 

  658. 

  659. sub font {
    660. 

  660. 

  661.     local(*para) = @_;
    662. 

  662.     local($i, $j, @begin, @end, $part, @pieces, $bold, $italic);
    663. 

  663. 

  664.     return 0 if $#para == -1;   # Ignore empty paragraphs
    665. 

  665. 				# Perl 5 lossage alert
    666. 

  666. 

  667.     # Find beginning and end of each part between HTML comments
    668. 

  668. 

  669.     $i = 0;
    670. 

  670.     @begin = ();
    671. 

  671.     @end = ();
    672. 

  672.     foreach (@para) {
    673. 

  673. 	push(@begin, $i + 1) if /^-->/ || /^<BR>/;
    674. 

  674. 	push(@end, $i - 1) if /^<!--/ || /^<BR>/;
    675. 

  675. 	$i++;
    676. 

  676.     }
    677. 

  677.     if ($para[0] =~ /^<!--/ || $para[0] =~ /^<BR>/) {
    678. 

  678. 	shift(@end);
    679. 

  679.     } else {
    680. 

  680. 	unshift(@begin, 0);	# Begin at the beginning
    681. 

  681.     }
    682. 

  682.     if ($para[$#para] =~ /^-->/ || $para[$#para] =~ /^<BR>/) {
    683. 

  683. 	pop(@begin);
    684. 

  684.     } else {
    685. 

  685. 	push(@end, $#para);	# End at the end
    686. 

  686.     }
    687. 

  687. 

  688.     # Fontify each part
    689. 

  689. 

  690.     $bold = $italic = 0;
    691. 

  691.     foreach $i (0 .. $#begin) {
    692. 

  692. 	$part = join('', @para[$begin[$i] .. $end[$i]]);
    693. 

  693. 	$part =~ s/^\.([BI])\s+(.*)$/\\f$1$2\\fR/gm;	    # .B, .I
    694. 

  694. 	@pieces = split(/(\\f[BIR])/m, $part);
    695. 

  695. 	$part = '';
    696. 

  696. 	foreach $j (@pieces) {
    697. 

  697. 	    if ($j eq '\fB') {
    698. 

  698. 		if ($italic) {
    699. 

  699. 		    $italic = 0;
    700. 

  700. 		    $part .= '</I>';
    701. 

  701. 		}
    702. 

  702. 		unless ($bold) {
    703. 

  703. 		    $bold = 1;
    704. 

  704. 		    $part .= '<B>';
    705. 

  705. 		}
    706. 

  706. 	    } elsif ($j eq '\fI') {
    707. 

  707. 		if ($bold) {
    708. 

  708. 		    $bold = 0;
    709. 

  709. 		    $part .= '</B>';
    710. 

  710. 		}
    711. 

  711. 		unless ($italic) {
    712. 

  712. 		    $italic = 1;
    713. 

  713. 		    $part .= '<I>';
    714. 

  714. 		}
    715. 

  715. 	    } elsif ($j eq '\fR') {
    716. 

  716. 		if ($bold) {
    717. 

  717. 		    $bold = 0;
    718. 

  718. 		    $part .= '</B>';
    719. 

  719. 		} elsif ($italic) {
    720. 

  720. 		    $italic = 0;
    721. 

  721. 		    $part .= '</I>';
    722. 

  722. 		}
    723. 

  723. 	    } else {
    724. 

  724. 		$part .= $j;	
    725. 

  725. 	    }
    726. 

  726. 	}
    727. 

  727. 

  728. 	# Close bold/italic before break
    729. 

  729. 

  730. 	if ($end[$i] == $#para || $para[$end[$i] + 1] =~ /^<BR>/) {
    731. 

  731. 	    # Perl 5 lossage alert
    732. 

  732. 	    if ($bold) {
    733. 

  733. 		$bold = 0;
    734. 

  734. 		$part =~ s/(\n)?$/<\/B>$1\n/;
    735. 

  735. 	    } elsif ($italic) {
    736. 

  736. 		$italic = 0;
    737. 

  737. 		$part =~ s/(\n)?$/<\/I>$1\n/;
    738. 

  738. 	    }
    739. 

  739. 	}
    740. 

  740. 

  741. 	# Rebuild this section of @para
    742. 

  742. 

  743. 	foreach $j ($begin[$i] .. $end[$i]) {
    744. 

  744. 	    $part =~ s/^([^\n]*(\n|$))//;
    745. 

  745. 	    $para[$j] = $1;
    746. 

  746. 	}
    747. 

  747.     }
    748. 

  748. 

  749.     # Close bold/italic on last non-comment line
    750. 

  750.     # Do this only here because fonts pass through comments
    751. 

  751. 

  752.     $para[$end[$#end]] =~ s/(\n)?$/<\/B>$1/ if $bold;
    753. 

  753.     $para[$end[$#end]] =~ s/(\n)?$/<\/I>$1/ if $italic;
    754. 

  754. }
    755. 

  755. 

  756. sub usage {
    757. 

  757.     local ($message) = $_[0];
    758. 

  758. 

  759.     warn $message if $message;
    760. 

  760.     warn <<EOP;
    761. 

  761. Usage: $whatami [-1icsu] [-C dir] [-d dir] [-h host] [file]
    762. 

  762. Without [file], reads from tcsh.man or stdin.
    763. 

  763. -1	    Makes a single page instead of a table of contents and sections
    764. 

  764. -i	    Makes a CGI searchable index script, tcsh.html/tcsh.cgi, intended
    765. 

  765. 	    for a server which respects the .cgi extension in any directory.
    766. 

  766. -c	    Like -i,  but the CGI script is intended for a server which wants
    767. 

  767. 	    scripts in /cgi-bin (or some other privileged directory separate
    768. 

  768. 	    from the rest of the HTML) and must be moved there by hand.
    769. 

  769. -C dir	    Uses /dir instead of /cgi-bin as the CGI bin dir.
    770. 

  770. 	    Meaningless without -c.
    771. 

  771. -d dir	    Uses /dir/tcsh.html instead of /tcsh.html as the HTML dir.
    772. 

  772. 	    Meaningless without -c.
    773. 

  773. -D dir	    Uses /dir.html instead of /tcsh.html as the HTML dir.
    774. 

  774. 	    Meaningless without -c.
    775. 

  775. -G name	    Uses name instead of tcsh.cgi as the name of the CGI script.
    776. 

  776. 	    Meaningless without -c or -i.
    777. 

  777. -h host	    Uses host as the host:port part of the URL to the entry point.
    778. 

  778. 	    Meaningless without -c.
    779. 

  779. -s	    Filenames are shorter (max 8 + 3) but less descriptive.
    780. 

  780. -u	    This message
    781. 

  781. EOP
    782. 

  782.     exit !! $message;
    783. 

  783. }
    784. 

  784. 

  785. ### Inlined documents. Watch for *HERE tokens.
    786. 

  786. 

  787. __END__
    788. 

  788. <HEAD>
    789. 

  789. <TITLE>The tcsh mailing lists</TITLE>
    790. 

  790. </HEAD>
    791. 

  791. <BODY>
    792. 

  792. <A HREF="TOPFILEHERE">Up</A>
    793. 

  793. <H2>The <I>tcsh</I> mailing lists</H2>
    794. 

  794. There are three <I>tcsh</I> mailing lists:
    795. 

  795. <DL>
    796. 

  796. <DT>
    797. 

  797. <I>tcsh@mx.gw.com</I>
    798. 

  798. <DD>
    799. 

  799. The <I>tcsh</I> maintainers and testers' mailing list.
    800. 

  800. <DT>
    801. 

  801. <I>tcsh-bugs@mx.gw.com</I>
    802. 

  802. <DD>
    803. 

  803. Open bug and user comment discussion.
    804. 

  804. </DL>
    805. 

  805. You can subscribe to either of these lists by visiting
    806. 

  806. <I><A HREF="http://mx.gw.com/">http://mx.gw.com/</A></I>
    807. 

  807. <P>
    808. 

  808. To file a bug report or a feature suggestion (preferably
    809. 

  809. with code), please visit
    810. 

  810. <I><A HREF="http://bugs.gw.com/">http://bugs.gw.com/</A></I>
    811. 

  811. <P>
    812. 

  812. <A HREF="TOPFILEHERE">Up</A>
    813. 

  813. </BODY>
    814. 

  814. END
    815. 

  815. : # -*- perl -*-
    816. 

  816. 

  817. # Emulate #!/usr/local/bin/perl on systems without #!
    818. 

  818. 

  819. eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
    820. 

  820. & eval 'exec perl -S $0 $argv:q' if 0;
    821. 

  821. 

  822. # Setup
    823. 

  823. 

  824. # Location: doesn't work with relative URLs, so we need to know where to find
    825. 

  825. #   the top and section files.
    826. 

  826. # If the search engine is in /cgi-bin, we need a hard-coded URL.
    827. 

  827. # If the search engine is in the same directory, we can figure it out from CGI
    828. 

  828. #   environment variables.
    829. 

  829. 

  830. $root = ROOTHERE;
    831. 

  831. $topfile = 'TOPFILEHERE';
    832. 

  832. @name = (
    833. 

  833. 'NAMEHERE'
    834. 

  834. );
    835. 

  835. 

  836. # Do the search
    837. 

  837. 

  838. $input = $ENV{'QUERY_STRING'};
    839. 

  839. $input =~ s/^input=//;
    840. 

  840. $input =~ s/\+/ /g;
    841. 

  841. print "Status: 302 Found\n";
    842. 

  842. if ($input ne '' && ($key = (grep(/^$input/,  @name))[0] ||
    843. 

  843. 			    (grep(/^$input/i, @name))[0] ||
    844. 

  844. 			    (grep( /$input/i, @name))[0]   )) {
    845. 

  845.     $key =~ /\t([^\t]*)$/;
    846. 

  846.     print "Location: $root$1\n\n";
    847. 

  847. } else {
    848. 

  848.     print "Location: $root$topfile\n\n";
    849. 

  849. }
    850. 

  850. END
    851.