home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume3 / ff / part02 / ff.c
C/C++ Source or Header  |  1986-11-30  |  29KB  |  1,089 lines
  1. /*COPYRIGHT (c) 1985 Wang Institute, Tyngsboro, MA 01879 USA */
  2. /*DISCLAIMER:    No guarantees of performance are made. */
  3. /*MODULE    ff: "fast formatter" "Sun 01 Sep 1985" */
  4. /*PGMR      ff: "Gary Perlman" "Wang Institute, Tyngsboro, MA 01879 USA" */
  5. /*VER       $Header: ff.c,v 1.3 85/09/01 21:23:38 perlman Exp $ */
  6. /*COMP      ff: see makefile */
  7.  
  8. /*MANUAL.TH FF 1 "August 10, 1985" "Wang Institute" "UNIX User's Manual"
  9. .\" $Compile: iroff -man.new %f
  10. .SH NAME
  11. ff \- fast text formatter
  12. .SH USAGE
  13. .B ff
  14. [options] [-] [files]
  15. .SH DESCRIPTION
  16. .I ff
  17. is a simple text formatter for flexible uniform formatting of
  18. input files.
  19. Program options are used to control formatting.
  20. This is in contrast to text formatters like
  21. .I nroff (1)
  22. that require special format requests to be part of their input files.
  23. Besides avoiding cryptic format requests in text,
  24. .I ff
  25. is considerably faster than traditional formatters like
  26. .I nroff (1)
  27. and even simple formatters like
  28. .I fmt (1).
  29. .PP
  30. The most complicated concept with
  31. .I ff
  32. is that of a line break.
  33. A line break causes an interruption in the filling
  34. (evening out of the text lines).
  35. Line breaks occur when special characters are seen at the beginnings
  36. of lines, or when all lines are broken.
  37. By default, any non-alphanumeric character will cause a break,
  38. but this can be controlled with the
  39. .B -B
  40. option.
  41. A blank line always causes a break.
  42. */
  43.  
  44.  
  45. #include <stdio.h>
  46. #include <ctype.h>
  47. #include <strings.h>
  48.  
  49. typedef    int     Status;
  50. #define    SUCCESS   ((Status) 0)
  51. #define    FAILURE   ((Status) 1)
  52. typedef    int     Boole;
  53. #define    TRUE      ((Boole) 1)
  54. #define    FALSE     ((Boole) 0)
  55.  
  56. #define    TAB       '\t'
  57. #define    EOL       '\n'
  58. #define    FF        '\f'
  59. #define    EOS       '\0'
  60. #define    SP        ' '
  61. #define    MAXLEN    128                  /* max length of lines */
  62. #define    MAXLINES  200                  /* max # lines on pages */
  63.  
  64. /* Alphabetical listing of this file's functions */
  65. void    beginline ();  /* process text at the beginning of lines */
  66. void    beginpage ();  /* handle pagination at page breaks */
  67. Status    dobreak ();    /* handle broken lines, if appropriate */
  68. void    dofill ();     /* do the text filling */
  69. char    *dotab ();     /* return expanded tabs in line */
  70. void    endpage ();    /* handle pagination at page ends */
  71. char    *expand ();    /* expand strings in three part titles */
  72. Status    ff ();         /* main formatting routine */
  73. int     initial ();    /* set options and check consistency */
  74. char    *itoa ();      /* convert integer to ascii format, with padding */
  75. void    dojustify ();  /* even out (justify) the right margin of filled lines */
  76. char    *preprocess ();/* handle blank trimming and titling */
  77. void    println ();    /* print a line, watching for page boundaries */
  78. void    repeat ();     /* repeatedly print a character */
  79. Status    setint ();     /* check type & convert a string to an integer */
  80. char    *threepart (); /* build three part titles */
  81. void    usage ();      /* print usage summary */
  82.  
  83. /* GLOBALS */
  84. char    *Argv0;              /* will be name of program */
  85. int     Curpos;              /* current position on output line */
  86. char    *Filename;           /* current input file name */
  87. Boole    Filling;             /* is text being filled right now */
  88. char    Justbuf[MAXLEN];     /* buffer for justified text */
  89. int     Justpos;             /* current position in justification buffer */
  90. int     Outline;             /* output line number */
  91. int     Pageline;            /* line number on current output page */
  92. int     Pagenum;             /* current page number */
  93.  
  94. /* Default values of options */
  95. #define    MAXTAB     20                  /* max # of tab stops */
  96. #define    FOOTSIZE    5                  /* default footer size */
  97. #define    HEADSIZE    5                  /* default header size */
  98. #define    NUMWIDTH    4                  /* default width of line numbers */
  99. #define    PAGESIZE   66                  /* default length of page */
  100. #define    WIDTH      72                  /* default width of page */
  101. #define    PAGENUM   '%'                  /* expands to page number in titles */
  102. #define    FILENAME  '*'                  /* expands to file name in title */
  103. #define    HEADER      "|File: *||Page: %|" /* default page header */
  104.  
  105. /*MANUAL.SH OPTIONS
  106. There are many, many options to allow control of
  107. indentation, line width, line spacing, filling,
  108. pagination with headers and footers,
  109. line numbering, right justification,
  110. and perhaps some other things.
  111. They have extensive type and range checking
  112. that produces diagnostic error messages,
  113. so warnings of obviously wrong options will not be discussed here.
  114. In general, options that imply the use of others
  115. work the way they should; if the page size is set,
  116. then pagination is automatically assumed.
  117. Some combinations of options give impressive, even artistic, effects.
  118. Making a small text file and playing with it is the easiest
  119. way to learn how the options interact.
  120. .de OP
  121. .TP
  122. .B -\\$1 \\$2
  123. ..
  124. */
  125.  
  126.     Boole    Breaklines = FALSE; /*MANUAL.OP b
  127. Break all lines of text.
  128. That is, don't even-out lines by filling.
  129. By default, text lines are filled.
  130. */
  131.  
  132.     char    *Breakchars = NULL; /*MANUAL.OP B breakchars
  133. Change the set of characters that cause line breaks at the start of lines to
  134. .I breakchars.
  135. By default, any characters but letters and numbers cause a break.
  136. A good choice for break characters might be "*-+" and TABS
  137. that might be used for lists.
  138. */
  139.  
  140.     Boole    Center = FALSE; /*MANUAL.OP c
  141. Center all lines of text.
  142. This option stops all filling of text.
  143. */
  144.  
  145.     Boole    Delspace = FALSE; /*MANUAL.OP d
  146. Delete white space at the beginning and end of lines.
  147. This option is useful to help un-format text to be re-formatted.
  148. */
  149.  
  150.     Boole    Delline = FALSE; /*MANUAL.OP D
  151. Delete empty input lines.
  152. An input line is empty if it has no characters,
  153. not even invisible character like tabs or spaces.
  154. This option can be combined with the option to remove white space
  155. to delete visibly blank lines.
  156. */
  157.  
  158.     char    *Footer = NULL; /*MANUAL.OP f footer
  159. Set the page footer to the string
  160. .I footer.
  161. This can be any string,
  162. but if the first character is not a letter or a digit,
  163. but a punctuation character like /,
  164. then that character separates the left,
  165. center, and right fields of a title.
  166. For example, the title
  167. .ce
  168. "/ff: fast formatter//1985/"
  169. would have "ff: fast formatter" as a left justified field
  170. and 1985 as a right justified field on each page.
  171. Note that there is no middle field in this example,
  172. but there could have been, between the two consecutive /'s.
  173. There are two special characters, % and *,
  174. that respectively are variables for the page number
  175. and the input file name.
  176. The default page footer is blank.
  177. */
  178.  
  179.     int     Footsize = FOOTSIZE; /*MANUAL.OP F footersize
  180. Set the number of blank lines at the bottom of the page.
  181. The footer, if any, is placed in the middle of the space,
  182. which by default, is five lines.
  183. If
  184. .I footersize
  185. is 0, no footer will be printed.
  186. */
  187.  
  188.     char    *Header = HEADER; /*MANUAL.OP h header
  189. Set the page header.
  190. See the description of three-part titles for the
  191. .B -f footer
  192. option.
  193. The default page header is
  194. .ce
  195. "|File: *||Page: %|".
  196. */
  197.  
  198.     int     Headsize = HEADSIZE; /*MANUAL.OP H headersize
  199. See the description of the footer size.
  200. */
  201.  
  202.     int     Indent = 0; /*MANUAL.OP i indent
  203. Set the indentation of the text to
  204. .I indent
  205. spaces.
  206. Note that this effectively reduces the usable width of the page.
  207. */
  208.  
  209.     int     Tindent = 0; /*MANUAL.OP I tempindent
  210. Set the temporary indent.
  211. This causes filled text found immediately after a break to
  212. be indented for one line.
  213. It is useful for indenting the first lines of paragraphs.
  214. If
  215. .I tempindent
  216. is negative,
  217. the the temporary indent will be relative to the current
  218. .I indent
  219. value.
  220. If the
  221. .I tempindent
  222. value is more negative than the
  223. .I indent
  224. value is positive,
  225. .I ff
  226. will automatically increase
  227. .I indent.
  228. */
  229.  
  230.     Boole    Justify = FALSE; /*MANUAL.OP j
  231. Justify the text.
  232. That is, even the right margin by inserting spaces in the line.
  233. Only filled text can be justified.
  234. */
  235.  
  236.     Boole    Numlines = FALSE; /*MANUAL.OP n
  237. Number all output lines produced by the input text.
  238. Lines from multiple line spacing or pagination will not
  239. be numbered.
  240. */
  241.  
  242.     int     Numwidth = NUMWIDTH; /*MANUAL.OP N numberwidth
  243. Set the width of the line numbers.
  244. The default is to take up 4 spaces.
  245. Note that this effectively reduces the usable part of the page.
  246. */
  247.  
  248.     Boole    Paginate = FALSE; /*MANUAL.OP p
  249. Paginate the output.
  250. See the options for page header and footer control.
  251. */
  252.  
  253.     int     Pagesize = PAGESIZE; /*MANUAL.OP P pagesize
  254. Set the number of lines in a page to
  255. .I pagesize.
  256. By default, the standard 66 line page is assumed.
  257. */
  258.  
  259.     int     Spacing = 1; /*MANUAL.OP s spacing
  260. Set the line spacing.
  261. By default, text is single spaced (\fIspacing\fR equals 1).
  262. */
  263.  
  264.     int     Tab[MAXTAB];
  265.     int     Ntabs = 0; /*MANUAL.OP t tab
  266. Set individual absolute and relative tab stops.
  267. These values tell the formatter
  268. where to put the text (from an unfilled line)
  269. that follows a tab character.
  270. Each tab stop is supplied with its own
  271. .B -t
  272. option; there is no way to bundle them.
  273. .I tab
  274. values can be integers without a plus sign.
  275. These are \fIabsolute\fR tab settings;
  276. the tabs go to that position.
  277. The values must increase monotonically.
  278. If a
  279. .I tab
  280. value is preceded by a plus sign,
  281. then it is interpreted \fIrelative\fR to the previous tab setting.
  282. For example, a tab setting of 40 followed by one of +20
  283. will set the second tab stop to 60.
  284. */
  285.  
  286.     int     Alltabs = 0; /*MANUAL.OP T tabs
  287. Set tab stops to every
  288. .I tabs
  289. spaces.
  290. It is useful to get equally spaced tabs.
  291. This option cannot be used with the other tab setting option.
  292. */
  293.  
  294.     Boole    Uppercase = FALSE; /*MANUAL.OP u
  295. Print All Input Text As Initial Upper-Case Titles,
  296. Like This Sentence.
  297. This option goes well with the one for centering lines.
  298. */
  299.  
  300.     /*MANUAL.OP U
  301. Print a usage summary of all the options and stop.
  302. */
  303.  
  304.     int     Width = WIDTH; /*MANUAL.OP w width
  305. Set the page width.
  306. By default, the page width is 72 characters.
  307. Note that the usable line length is sometimes less
  308. than the page width.
  309. If line numbering or indentation is requested,
  310. these subtract from the line length.
  311. */
  312.  
  313. /*MANUAL.SH EXAMPLES
  314. Some of these examples can make shell scripts or aliases.
  315. .nf
  316. .ta .5i
  317. .sp
  318. Centered Titles: title
  319.     ff -dcu $*
  320. Double Spaced Unfilled Paginated indented (for editing): draft
  321.     ff -s 2 -b -p -f "`date`" -i 8 $*
  322. Program Listing: cpr
  323.     H="@        Dir: `pwd`@@File: *@"
  324.     F="@        $NAME@`date`@Page %@"
  325.     ff -b -N 8 -H 3 -h "$H" -F 3 -f "$F" -T 4 -w 79 -i 2 $*
  326. Reformat Paragraphed Text: nr
  327.     ff -jd -I 5 -i 10 -w 65 -B "TAB SP'*.@" $*
  328. .fi
  329. */
  330. /*MANUAL.SH DIAGNOSTICS
  331. Some options are incompatible with others.
  332. For example, centered text cannot be right-justified.
  333. .I ff
  334. will not allow inconsistent combinations of options.
  335. */
  336. /*MANUAL.SH "SEE ALSO"
  337. fmt(1), nroff(1), scribe(1w)
  338. */
  339. /*MANUAL.SH AUTHOR
  340. Gary Perlman (with help from many students)
  341. */
  342. /*MANUAL.SH STATUS
  343. Pretty well tested.
  344. */
  345.  
  346. /* Macro Functions */
  347. /*MACRO isendsent: is the character one that ends a sentence? */
  348. #define    isendsent(c) ((c) == '.' || (c) == '?' || (c) == '!')
  349.  
  350. /*MACRO justchar: add char to a buffer that will later be flushed */
  351. #define    justchar(c) (Justbuf[Justpos++] = (c))
  352.  
  353. /*MACRO fillchar: save to justify if necessary, else output */
  354. #define fillchar(c) \
  355.     { \
  356.     if (Justify == TRUE) justchar (c); \
  357.     else putc (c, stdout); \
  358.     }
  359.  
  360. /*FUNCTION main: loop through files in classic UNIX filter style */
  361. main (argc, argv)
  362. int     argc;     /* argument count */
  363. char    **argv;   /* argument vector */
  364.     {
  365.     Status     ff ();      /* ff (file, ioptr) will filter files */
  366.     Status    status;     /* return status of filter () */
  367.     int     firstfile;  /* first file name index returned by initial */
  368.  
  369.     firstfile = initial (argc, argv);
  370.     status = filter (argc, argv, firstfile, ff);
  371.     exit (status);
  372.     }
  373.  
  374. /*FUNCTION setint: check type, convert string, and set integer option */
  375. Status
  376. setint (flag, value, var, min, max)
  377. int     flag;    /* the single character option name */
  378. char    *value;  /* the candidate value, in string format */
  379. int     *var;    /* ptr to variable to stuff in answer */
  380. int     min;     /* minimum allowed value */
  381. int     max;     /* maximum allowed value */
  382.     {
  383.     int     tmpvar;
  384.     if (number (value) == 1) /* number returns 1 for integers, 2 for reals */
  385.         {
  386.         tmpvar = atoi (value);
  387.         if (tmpvar >= min && tmpvar <= max)
  388.             {
  389.             *var = tmpvar;
  390.             return (SUCCESS);
  391.             }
  392.         fprintf (stderr, "%s: -%c option value must be between %d and %d\n",
  393.             Argv0, flag, min, max);
  394.         return (FAILURE);
  395.         }
  396.     fprintf (stderr, "%s: -%c option requires an integer value\n", Argv0, flag);
  397.     return (FAILURE);
  398.     }
  399.  
  400. /*FUNCTION usage: print help menu */
  401. void
  402. usage (ioptr)
  403. FILE    *ioptr;
  404.     {
  405.     fprintf (ioptr, "%s: fast text formatter options:\n", Argv0);
  406.     fprintf (ioptr, "-b      break all lines of text--do no filling\n");
  407.     fprintf (ioptr, "-B s    line break characters\n");
  408.     fprintf (ioptr, "-c      center all text lines\n");
  409.     fprintf (ioptr, "-d      delete blank space around input lines\n");
  410.     fprintf (ioptr, "-D      delete blank input lines\n");
  411.     fprintf (ioptr, "-f s    page footer three-part title\n");
  412.     fprintf (ioptr, "-F i    page footer size (%d lines)\n", Footsize);
  413.     fprintf (ioptr, "-h s    page header three-part title (%s)\n", Header);
  414.     fprintf (ioptr, "-H i    page header size (%d lines)\n", Headsize);
  415.     fprintf (ioptr, "-i i    text indentation (%d spaces)\n", Indent);
  416.     fprintf (ioptr, "-I i    indent after line breaks (%d spaces)\n", Tindent);
  417.     fprintf (ioptr, "-j      justify the right margin of the text\n");
  418.     fprintf (ioptr, "-n      number output text lines\n");
  419.     fprintf (ioptr, "-N i    width of line numbers (%d spaces)\n", Numwidth);
  420.     fprintf (ioptr, "-p      paginate output\n");
  421.     fprintf (ioptr, "-P i    page size (%d lines)\n", Pagesize);
  422.     fprintf (ioptr, "-s i    line spacing (%d line)\n", Spacing);
  423.     fprintf (ioptr, "-t i    absolute or relative tab stop\n");
  424.     fprintf (ioptr, "-T i    uniform tab stops\n");
  425.     fprintf (ioptr, "-u      show text with upper-case initial letters\n");
  426.     fprintf (ioptr, "-U      print long usage synopsis for this command\n");
  427.     fprintf (ioptr, "-w i    page line width (%d spaces)\n", Width);
  428.     }
  429.  
  430. /*FUNCTION initial: set options */
  431. int
  432. initial (argc, argv) char **argv;
  433.     {
  434.     extern    char    *optarg;   /* string value to option set by getopt */
  435.     extern    int     optind;    /* will be index of first command operand */
  436.     int     errcount = 0;        /* count of number of errors */
  437.     int     flag;              /* options flag names read in here */
  438.     char    *optstring =       /* Boolean flags and integer options with : */
  439.         "bcdDjnpuUB:f:F:h:H:i:I:N:P:s:t:T:w:";
  440.  
  441.     Argv0 = argv[0];
  442.     while ((flag = getopt (argc, argv, optstring)) != EOF)
  443.         switch (flag)
  444.         {
  445.         default:
  446.             errcount++;
  447.             break;
  448.  
  449.         case 'b':
  450.             Breaklines = TRUE;
  451.             break;
  452.  
  453.         case 'B':
  454.             Breakchars = optarg;
  455.             break;
  456.  
  457.         case 'c':
  458.             Center = TRUE;
  459.             Breaklines = TRUE;
  460.             break;
  461.  
  462.         case 'd':
  463.             Delspace = TRUE;
  464.             break;
  465.  
  466.         case 'D':
  467.             Delline = TRUE;
  468.             break;
  469.  
  470.         case 'f':
  471.             Footer = optarg;
  472.             Paginate = TRUE;
  473.             break;
  474.  
  475.         case 'F':
  476.             if (setint (flag, optarg, &Footsize, 0, MAXLINES) == FAILURE)
  477.                 errcount++;
  478.             Paginate = TRUE;
  479.             break;
  480.  
  481.         case 'h':
  482.             Header = optarg;
  483.             Paginate = TRUE;
  484.             break;
  485.  
  486.         case 'H':
  487.             if (setint (flag, optarg, &Headsize, 0, MAXLINES) == FAILURE)
  488.                 errcount++;
  489.             Paginate = TRUE;
  490.             break;
  491.  
  492.         case 'i':
  493.             if (setint (flag, optarg, &Indent, 0, MAXLEN) == FAILURE)
  494.                 errcount++;
  495.             break;
  496.  
  497.         case 'I':
  498.             if (setint (flag, optarg, &Tindent, -MAXLEN, MAXLEN) == FAILURE)
  499.                 errcount++;
  500.             break;
  501.  
  502.         case 'j':
  503.             Justify = TRUE;
  504.             break;
  505.  
  506.         case 'N':
  507.             if (setint (flag, optarg, &Numwidth, 1, MAXLEN) == FAILURE)
  508.                 errcount++;
  509.             /* FALLTHROUGH */
  510.  
  511.         case 'n':
  512.             Numlines = TRUE;
  513.             break;
  514.  
  515.         case 'P':
  516.             if (setint (flag, optarg, &Pagesize, 1, MAXLINES) == FAILURE)
  517.                 errcount++;
  518.             /* FALLTHROUGH */
  519.  
  520.         case 'p':
  521.             Paginate = TRUE;
  522.             break;
  523.  
  524.         case 's':
  525.             if (setint (flag, optarg, &Spacing, 1, MAXLINES) == FAILURE)
  526.                 errcount++;
  527.             break;
  528.  
  529.         case 't':
  530.             if (Ntabs >= MAXTAB)
  531.                 {
  532.                 fprintf (stderr, "%s: at most %d -%c options allowed\n",
  533.                     Argv0, MAXTAB, flag);
  534.                 errcount++;
  535.                 }
  536.             else if (setint (flag, optarg, &Tab[Ntabs], 0, MAXLEN) == FAILURE)
  537.                 errcount++;
  538.             else if (Ntabs > 0)
  539.                 {
  540.                 if (*optarg == '+')
  541.                     Tab[Ntabs] += Tab[Ntabs-1];
  542.                 else if (Tab[Ntabs] <= Tab[Ntabs-1])
  543.                     {
  544.                     fprintf (stderr, "%s: -%c values must increase\n",
  545.                         Argv0, flag);
  546.                     errcount++;
  547.                     }
  548.                 }
  549.             if (Tab[Ntabs] >= MAXLEN)
  550.                 {
  551.                 fprintf (stderr, "%s: -%c values must be < %d\n",
  552.                     Argv0, flag, MAXLEN);
  553.                 errcount++;
  554.                 }
  555.             Ntabs++;
  556.             break;
  557.  
  558.         case 'T':
  559.             if (setint (flag, optarg, &Alltabs, 1, MAXLEN) == FAILURE)
  560.                 errcount++;
  561.             break;
  562.  
  563.         case 'u':
  564.             Uppercase = TRUE;
  565.             break;
  566.  
  567.         case 'U':
  568.             usage (stdout);
  569.             exit (0);
  570.  
  571.         case 'w':
  572.             if (setint (flag, optarg, &Width, 1, MAXLEN) == FAILURE)
  573.                 errcount++;
  574.             break;
  575.         }
  576.  
  577.     /* Now check validity of option settings */
  578.     if (Tindent < 0 && Indent < (-Tindent))
  579.         Indent = (-Tindent);
  580.     if (Ntabs > 0 && Alltabs > 0)
  581.         {
  582.         fprintf (stderr, "%s: can't set individual and all tabs\n", Argv0);
  583.         errcount++;
  584.         }
  585.     if (Center == TRUE && Justify == TRUE)
  586.         {
  587.         fprintf (stderr, "%s: centering and justifying incompatible\n", Argv0);
  588.         errcount++;
  589.         }
  590.     else if (Breaklines == TRUE && Justify == TRUE)
  591.         {
  592.         fprintf (stderr, "%s: breaking and justifying incompatible\n", Argv0);
  593.         errcount++;
  594.         }
  595.     if (Ntabs > 0 && Center == TRUE)
  596.         {
  597.         fprintf (stderr,"%s: centering and setting tabs incompatible\n", Argv0);
  598.         errcount++;
  599.         }
  600.     if ((Ntabs > 0 || Alltabs > 0) && (Justify == TRUE))
  601.         {
  602.         fprintf (stderr, "%s: tabstops and justifying incompatible\n", Argv0);
  603.         errcount++;
  604.         }
  605.  
  606.     /* Print an error message and exit or return index to first file name */
  607.     if (errcount > 0)
  608.         {
  609.         fprintf (stderr, "Usage: %s [options] [-] [files]\n", Argv0);
  610.         exit (FAILURE);
  611.         }
  612.     return (optind);
  613.     }
  614.  
  615. /*FUNCTION repeat: repeat a character some number of times */
  616. void
  617. repeat (c, n)
  618. int     c;     /* character to print */
  619. int     n;     /* number of times to print c */
  620.     {
  621.     while (n-- > 0)
  622.         putc (c, stdout);
  623.     }
  624.  
  625. /*FUNCTION dotab: expand tabs to spaces to tab stops, returns static buffer */
  626. /*ALGORITHM
  627.     if all tabs are set to the same value (Alltabs > 0)
  628.         then advance on a tab to the next tab stop
  629.     else if there are individual tabs set (Ntabs > tabno)
  630.         then advance (possibly retreat!) to next set tab
  631.     else just treat the tab like a space character
  632. */
  633. char *
  634. dotab (line)
  635. register    char    *line;
  636.     {
  637.     static    char outline[MAXLEN];   /* new line will be built here */
  638.     register char *lptr;            /* pointer to current position in outline */
  639.     register char *nextptr;         /* position of next tab stop */
  640.     int     tabno = 0;              /* how many tabs have been processed */
  641.  
  642.     for (lptr = outline; *line != EOS && *line != EOL; line++)
  643.         {
  644.         if (*line == TAB)
  645.             {
  646.             if (Alltabs > 0)
  647.                 nextptr = lptr + Alltabs - ((lptr - outline) % Alltabs);
  648.             else if (Ntabs > tabno) /* move to next set tab */
  649.                 nextptr = outline + Tab[tabno++];
  650.             else
  651.                 nextptr = lptr + 1;
  652.             if (lptr < nextptr)
  653.                 do    {
  654.                     *lptr++ = SP;
  655.                 } while (lptr < nextptr);
  656.             else lptr = nextptr;
  657.             }
  658.         else
  659.             *lptr++ = *line;
  660.  
  661.         /* check for line overflow */
  662.         if (lptr >= (outline + MAXLEN))
  663.             return (NULL);
  664.         }
  665.  
  666.     /* end the expanded tab string and return */
  667.     *lptr = EOS;
  668.     return (outline);
  669.     }
  670.  
  671. /*FUNCTION dojustify: even the right margin for all lines */
  672. /*ALGORITHM
  673.         directly output any indenting spaces (this is not expanded)
  674.         trim trailing spaces (don't want to pad at end)
  675.         count number of spaces inside line (where extra spaces will be inserted)
  676.         distribute the extra spaces needed among the spaces there
  677.     Note: if we are not filling (e.g., last line of output before a break)
  678.         then we do not justfy the right margin.
  679. */
  680. void
  681. dojustify ()
  682.     {
  683.     register char *line;       /* will point to first non-space char on line */
  684.     int     width;             /* width of line to pad - #'s and indent */
  685.     register char *lptr;       /* zips through the line */
  686.     int     pad;               /* will need to pad with this many spaces */
  687.     int     spaces = 0;        /* will be number of embedded spaces in line */
  688.     register int i;            /* used inside inner loop */
  689.     int     n = 0;
  690.  
  691.     if (Justpos == 0)          /* nothing to justify, so bail out */
  692.         return;
  693.  
  694.     /* strip spaces from end of line and end with EOS */
  695.     for (lptr = Justbuf+Justpos; lptr>Justbuf && isspace(lptr[-1]); lptr--);
  696.     *lptr = EOS;
  697.  
  698.     width = Width - (Numlines == TRUE ? Numwidth : 0);
  699.     pad = width - (lptr - Justbuf);
  700.  
  701.     for (line = Justbuf; *line == SP; line++)
  702.         putc (*line, stdout);
  703.  
  704.     if (Filling == TRUE && pad > 0) /* might not fill last line of output */
  705.         for (lptr = line; *lptr != EOS; lptr++)
  706.             if (*lptr == SP)
  707.                 spaces++;
  708.  
  709.     if (spaces > 0) /* we have places to insert spaces */
  710.         {
  711.         for (lptr = line; *lptr != EOS; lptr++)
  712.             {
  713.             if (*lptr == SP)
  714.                 for (i = 0; i < pad; i++)
  715.                     if (++n == spaces)
  716.                         {
  717.                         putc (SP, stdout);
  718.                         n = 0;
  719.                         }
  720.             putc (*lptr, stdout);
  721.             }
  722.         }
  723.     else /* just output the line */
  724.         for (lptr = line; *lptr != EOS; lptr++)
  725.             putc (*lptr, stdout);
  726.  
  727.     Justpos = 0; /* reset buffer position for next line */
  728.     }
  729.  
  730. /*FUNCTION println: print lines while watching for page boundaries */
  731. void
  732. println (count)
  733. int     count;    /* how many lines to print (== Spacing) */
  734.     {
  735.     Curpos = 0;
  736.     while (count-- > 0)
  737.         {
  738.         putc (EOL, stdout);
  739.         Pageline++;
  740.         if (Paginate == TRUE && ((Pagesize - Pageline) == Footsize))
  741.             {
  742.             endpage (TRUE);
  743.             return;
  744.             }
  745.         }
  746.     }
  747.  
  748. /*FUNCTION beginline: do any needed justification, paginate if requested, */
  749. /*  handle line numbering, temp and regular indents based on prev. filling */
  750. void
  751. beginline (filling)
  752. Boole    filling;     /* are we filling now? */
  753.     {
  754.     int     count;
  755.     Boole    newfill = (Filling == FALSE && filling == TRUE);
  756.  
  757.     Filling = filling;
  758.     if (Justify == TRUE)
  759.         dojustify ();
  760.     Outline++;
  761.     Curpos = 0;
  762.  
  763.     if (Paginate == TRUE && Pageline == 0)
  764.         beginpage ();
  765.     else if (Outline > 1)
  766.         println (Spacing);
  767.  
  768.     if (Numlines == TRUE)
  769.         {
  770.         char    *ptr = itoa (Outline, Numwidth - 1);
  771.         Curpos += Numwidth;
  772.         while (*ptr)
  773.             putc (*ptr++, stdout);
  774.         putc (SP, stdout);
  775.         }
  776.  
  777.     count = Indent;
  778.     if (newfill == TRUE)
  779.         count += Tindent;
  780.     Curpos += count;
  781.  
  782.     if (Justify == TRUE)
  783.         while (count-- > 0)
  784.             justchar (SP);
  785.     else
  786.         repeat (SP, count);
  787.     }
  788.  
  789. /*FUNCTION itoa: integer to ascii conversion */
  790. char *
  791. itoa (n, pad)
  792. register int n;    /* the integer to be printed as a string */
  793. int     pad;       /* amount of space to pad number to */
  794.     {
  795.     static char numbuf[MAXLEN]; /* answer built in here */
  796.     register char *nptr;        /* will be pointer to beginning of number */
  797.     Boole    negflg = FALSE;     /* is the number a negative value? */
  798.  
  799.     /* static numbuf is initialized to 0's, so numbuf[MAXLEN-1] == EOS */
  800.     if (n == 0)
  801.         {
  802.         nptr = &numbuf[MAXLEN-1];
  803.         *--nptr = '0';
  804.         }
  805.     else
  806.         {
  807.         if (n < 0)
  808.             {
  809.             n = (-n);
  810.             negflg = TRUE;
  811.             }
  812.         for (nptr = &numbuf[MAXLEN-1]; n != 0; n /= 10)
  813.             *--nptr = (n % 10) + '0';
  814.         if (negflg == TRUE)
  815.             *--nptr = '-';
  816.         }
  817.  
  818.     while (pad > numbuf+MAXLEN-1-nptr)
  819.         *--nptr = SP;
  820.  
  821.     return (nptr);
  822.     }
  823.  
  824. /*FUNCTION expand: insert file/page for characters in field of 3part title */
  825. char *
  826. expand (title, page, file)
  827. register    char    *title;   /* the title to be expanded */
  828. int     page;                 /* the current page number */
  829. char    *file;                /* the name of the current file */
  830.     {
  831.     static     char answer[MAXLEN];  /* title expanded into this buffer */
  832.     register     char *aptr;       /* pointer to answer buf */
  833.     register    char *ptr;        /* generic string handling pointer */
  834.  
  835.     for (aptr = answer; *title != EOS; title++)
  836.         switch (*title)
  837.         {
  838.         default: 
  839.             *aptr++ = *title;
  840.             break;
  841.  
  842.         case PAGENUM:
  843.             ptr = itoa (page, 0);
  844.             while (*ptr != EOS)
  845.                 *aptr++ = *ptr++;
  846.             break;
  847.  
  848.         case FILENAME:
  849.             for (ptr = file; *ptr != EOS; ptr++)
  850.                 *aptr++ = *ptr;
  851.             break;
  852.         }
  853.     *aptr = EOS;
  854.     return (answer);
  855.     }
  856.  
  857. /*FUNCTION threepart: 3-part title with left/center/right justified fields */
  858. /*  any punctuation character can be the title delimiter: see nroff(1) */
  859. char *
  860. threepart (title, page, file, width)
  861. char    *title;   /* the three part title */
  862. int     page;     /* the current page number */
  863. char    *file;    /* the current file name */
  864. int     width;    /* the current page width */
  865.     {
  866.     static char answer[MAXLEN];   /* answer stuffed in here */
  867.     register char *aptr;          /* pointer to answer buffer */
  868.     int     delim;                /* title delimiter character */
  869.  
  870.     title = expand (title, page, file);
  871.     if (!ispunct (*title))
  872.         return (title);
  873.     for (aptr = answer; aptr < answer + width; aptr++)
  874.         *aptr = SP;
  875.     aptr = answer;
  876.     delim = *title++;
  877.     while (*title != EOS && *title != delim)
  878.         *aptr++ = *title++;
  879.     if (*title++ != EOS) /* now do center */
  880.         {
  881.         char    *lptr = title;
  882.         while (*lptr != EOS && *lptr != delim)
  883.             lptr++;
  884.         aptr = answer + (width - (lptr - title)) / 2;
  885.         if (aptr >= answer)
  886.             while (*title != EOS && *title != delim)
  887.                 *aptr++ = *title++;
  888.         else
  889.             while (*title != EOS && *title != delim)
  890.                 title++;
  891.         if (*title++ != EOS) /* now do left part */
  892.             {
  893.             char    *eptr = title;
  894.             while (*eptr != EOS && *eptr != delim)
  895.                 eptr++;
  896.             eptr--;
  897.             aptr = answer + width - 1;
  898.             while (eptr >= title)
  899.                 *aptr-- = *eptr--;
  900.             }
  901.         }
  902.     answer[width] = EOS;
  903.     return (answer);
  904.     }
  905.  
  906. /*FUNCTION beginpage: handle page header */
  907. void
  908. beginpage ()
  909.     {
  910.     Pagenum++;
  911.     if (Paginate == TRUE && Headsize > 0)
  912.         {
  913.         int     space1 = Headsize / 2;
  914.         int     space2 = Headsize - space1;
  915.         char    *optr = threepart (Header, Pagenum, Filename, Width);
  916.  
  917.         repeat (EOL, space1);
  918.         while (*optr != EOS)
  919.             putc (*optr++, stdout);
  920.         repeat (EOL, space2);
  921.         Pageline = Headsize;
  922.         }
  923.     }
  924.  
  925. /*FUNCTION endpage: break filling (output justified text) print footer */
  926. /* begin a new page if there is more */
  927. void
  928. endpage (more)
  929. Boole    more;
  930.     {
  931.     if (Justify == TRUE)
  932.         dojustify ();
  933.  
  934.     if (Paginate == TRUE)
  935.         {
  936.         int     space1 = Footsize / 2;
  937.         int     space2 = Footsize - space1;
  938.         char    *optr = threepart (Footer, Pagenum, Filename, Width);
  939.  
  940.         repeat (EOL, Pagesize - Pageline - space2);
  941.         while (*optr != EOS)
  942.             putc (*optr++, stdout);
  943.         repeat (EOL, space2);
  944.         Pageline = 0;
  945.         }
  946.     else if (Curpos > 0 || Indent > 0 || Numlines == TRUE)
  947.         putc (EOL, stdout);
  948.  
  949.     if (more == TRUE)
  950.         beginpage ();
  951.     }
  952.  
  953. /*FUNCTION preprocess: trim space, find blank lines, do titling */
  954. char *
  955. preprocess (line)
  956. register    char    *line;
  957.     {
  958.     register    char    *lptr;
  959.     if (Paginate == TRUE && *line == FF)
  960.         {
  961.         line++;
  962.         endpage (TRUE);
  963.         }
  964.     if (Delspace == TRUE) /* delete blank space */
  965.         {
  966.         while (isspace (*line))
  967.             line++;
  968.         for (lptr = line; *lptr != EOS; lptr++);
  969.         while (lptr > line && isspace (*(lptr-1)))
  970.             lptr--;
  971.         *lptr = EOS;
  972.         }
  973.     if (Delline == TRUE && (*line == EOL || *line == EOS))
  974.         return (NULL);
  975.     if (Uppercase == TRUE)
  976.         {
  977.         Boole     newword;    /* are we at the start of a new word? */
  978.         for (lptr = line, newword = TRUE; *lptr != EOS; lptr++)
  979.             {
  980.             if (newword && islower (*lptr))
  981.                 *lptr = toupper (*lptr);
  982.             newword = !isalnum (*lptr);
  983.             }
  984.         }
  985.     return (line);
  986.     }
  987.  
  988. /*FUNCTION dobreak: process broken line & return success status */
  989. Status
  990. dobreak (lptr)
  991. register char *lptr;    /* line to print out */
  992.     {
  993.     /* break: do tabs, or centering, and then dump the line out */
  994.     beginline (FALSE);
  995.     if (Alltabs > 0 || Ntabs > 0) /* some tabs have been set */
  996.         {
  997.         if ((lptr = dotab (lptr)) == NULL)
  998.             {
  999.             fprintf (stderr, "%s: malformed tab in %s at line %d\n",
  1000.                 Argv0, Filename, Outline);
  1001.             return (FAILURE);
  1002.             }
  1003.         }
  1004.     else if (Center == TRUE && *lptr != EOS && *lptr != EOL)
  1005.         repeat (SP, (Width - strlen (lptr)) / 2);
  1006.     while (*lptr != EOS && *lptr != EOL)
  1007.         putc (*lptr++, stdout);
  1008.     Curpos = Width; /* signal end of line */
  1009.     return (SUCCESS);
  1010.     }
  1011.  
  1012. /*FUNCTION dofill: do line filling */
  1013. void
  1014. dofill (lptr)
  1015. register    char    *lptr;
  1016.     {
  1017.     register char *eptr;       /* pointer to end of filled words */
  1018.     register int wordlen;      /* length of words */
  1019.  
  1020.     while (isspace (*lptr))
  1021.         lptr++;
  1022.     while (*lptr != EOS) /* fill text by picking up word by word */
  1023.         {
  1024.         eptr = lptr;
  1025.         while (*eptr != EOS && !isspace (*eptr))
  1026.             eptr++;
  1027.         wordlen = eptr - lptr;
  1028.         if ((Outline == 0) || (Curpos + wordlen) >= Width)
  1029.             beginline (TRUE);
  1030.         else if (Curpos < Width) /* space before word */
  1031.             {
  1032.             fillchar (SP);
  1033.             Curpos++;
  1034.             }
  1035.         for (Curpos += wordlen; lptr < eptr; lptr++)
  1036.             fillchar (*lptr);
  1037.         while (isspace (*lptr))
  1038.             lptr++;
  1039.  
  1040.         /* extra space at sentence ends (.?!) */
  1041.         if ((Curpos < Width) && isendsent (*(eptr-1)) && wordlen > 2)
  1042.             {
  1043.             fillchar (SP);
  1044.             Curpos++;
  1045.             }
  1046.         }
  1047.     }
  1048.  
  1049. /*FUNCTION ff: main formatting routine */
  1050. /*
  1051.     initializes for each new file, reads lines, trims space and blank lines
  1052.     switches between filling and non filling based on breakchars
  1053. */
  1054. Status
  1055. ff (file, ioptr)
  1056. char    *file;    /* file name */
  1057. FILE    *ioptr;   /* opened input pointer */
  1058.     {
  1059.     char    line[BUFSIZ];      /* lines read in here */
  1060.     register char *lptr;       /* pointer used to go through line */
  1061.     Status    status = SUCCESS;
  1062.  
  1063.     Outline = Pagenum = Pageline = Curpos = 0;
  1064.     Filename = file;
  1065.     Filling = FALSE;
  1066.  
  1067.     while (fgets (lptr = line, sizeof (line), ioptr))
  1068.         {
  1069.         if ((lptr = preprocess (lptr)) == NULL)
  1070.             continue;
  1071.  
  1072.         if ((Breaklines == TRUE)
  1073.         || (*lptr == EOL)
  1074.         || (Breakchars ? index (Breakchars, *lptr) != NULL : !isalnum (*lptr)))
  1075.             {
  1076.             if (dobreak (lptr) == FAILURE)
  1077.                 return (FAILURE);
  1078.             }
  1079.  
  1080.         else
  1081.  
  1082.             dofill (lptr);
  1083.         }
  1084.  
  1085.     Filling = FALSE;
  1086.     endpage (FALSE);
  1087.     return (status);
  1088.     }
  1089.