[sgt/halibut] / bk_man.c

/*
 * man page backend for Halibut
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "halibut.h"

static void man_text(FILE *, word *, int newline, int quote_props);
static void man_codepara(FILE *, word *);

#define QUOTE_INITCTRL 1 /* quote initial . and ' on a line */
#define QUOTE_QUOTES   2 /* quote double quotes by doubling them */

void man_backend(paragraph *sourceform, keywordlist *keywords,
		 indexdata *idx) {
    paragraph *p;
    FILE *fp;
    char const *sep;

    IGNORE(keywords);		       /* we don't happen to need this */
    IGNORE(idx);		       /* or this */

    /*
     * Determine the output file name, and open the output file
     *
     * FIXME: want configurable output file names here. For the
     * moment, we'll just call it `output.1'.
     */
    fp = fopen("output.1", "w");
    if (!fp) {
	error(err_cantopenw, "output.1");
	return;
    }

    /* Do the version ID */
    for (p = sourceform; p; p = p->next)
	if (p->type == para_VersionID) {
	    fprintf(fp, ".\\\" ");
	    man_text(fp, p->words, TRUE, 0);
	}

    /* FIXME: .TH name-of-program manual-section */
    fprintf(fp, ".TH FIXME 1\n");

    fprintf(fp, ".UC\n");

    /* Do the preamble and copyright */
    sep = "";
    for (p = sourceform; p; p = p->next)
	if (p->type == para_Preamble) {
	    fprintf(fp, "%s", sep);
	    man_text(fp, p->words, TRUE, 0);
	    sep = "\n";
	}
    for (p = sourceform; p; p = p->next)
	if (p->type == para_Copyright) {
	    fprintf(fp, "%s", sep);
	    man_text(fp, p->words, TRUE, 0);
	    sep = "\n";
	}

    /*
     * FIXME:
     * 
     *  - figure out precisely what needs to be escaped.
     * 	   * A dot or apostrophe at the start of a line wants to be
     * 	     preceded by `\&', which is a zero-width space.
     *     * Literal backslashes always want doubling.
     * 	   * Within double quotes, a double quote needs doubling
     * 	     too.
     * 
     *  - work out what to do about hyphens / minuses...
     */
    for (p = sourceform; p; p = p->next) switch (p->type) {
	/*
	 * Things we ignore because we've already processed them or
	 * aren't going to touch them in this pass.
	 */
      case para_IM:
      case para_BR:
      case para_Biblio:		       /* only touch BiblioCited */
      case para_VersionID:
      case para_Copyright:
      case para_Preamble:
      case para_NoCite:
      case para_Title:
	break;

	/*
	 * Headings.
	 */
      case para_Chapter:
      case para_Appendix:
      case para_UnnumberedChapter:
      case para_Heading:
      case para_Subsect:
	fprintf(fp, ".SH \"");
	/* FIXME: disable this, at _least_ by default */
	if (p->kwtext)
	    man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
	fprintf(fp, " ");
	man_text(fp, p->words, FALSE, QUOTE_QUOTES);
	fprintf(fp, "\"\n");
	break;

	/*
	 * Code paragraphs.
	 */
      case para_Code:
	fprintf(fp, ".PP\n");
	man_codepara(fp, p->words);
	break;

	/*
	 * Normal paragraphs.
	 */
      case para_Normal:
	fprintf(fp, ".PP\n");
	man_text(fp, p->words, TRUE, 0);
	break;

	/*
	 * List paragraphs.
	 */
      case para_Description:
      case para_BiblioCited:
      case para_Bullet:
      case para_NumberedList:
	if (p->type == para_Bullet) {
	    fprintf(fp, ".IP \"\\fBo\\fP\"\n");   /* FIXME: configurable? */
	} else if (p->type == para_NumberedList) {
	    fprintf(fp, ".IP \"");
	    man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
	    fprintf(fp, "\"\n");
	} else if (p->type == para_Description) {
	    /*
	     * Do nothing; the .xP for this paragraph is the .IP
	     * which has come before it in the DescribedThing.
	     */
	} else if (p->type == para_BiblioCited) {
	    fprintf(fp, ".IP \"");
	    man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
	    fprintf(fp, "\"\n");
	}
	man_text(fp, p->words, TRUE, 0);
	break;

      case para_DescribedThing:
	fprintf(fp, ".IP \"");
	man_text(fp, p->words, FALSE, QUOTE_QUOTES);
	fprintf(fp, "\"\n");
	break;

      case para_Rule:
	/*
	 * FIXME.
	 */
	break;

      case para_LcontPush:
	fprintf(fp, ".RS\n");
      	break;
      case para_LcontPop:
	fprintf(fp, ".RE\n");
	break;
    }

    /*
     * Tidy up.
     */
    fclose(fp);
}

/*
 * Convert a wide string into a string of chars. If `result' is
 * non-NULL, mallocs the resulting string and stores a pointer to
 * it in `*result'. If `result' is NULL, merely checks whether all
 * characters in the string are feasible for the output character
 * set.
 *
 * Return is nonzero if all characters are OK. If not all
 * characters are OK but `result' is non-NULL, a result _will_
 * still be generated!
 * 
 * FIXME: Here is probably also a good place to do escaping sorts
 * of things. I know I at least need to escape backslash, and full
 * stops at the starts of words are probably trouble as well.
 */
static int man_convert(wchar_t *s, char **result, int quote_props) {
    /*
     * FIXME. Currently this is ISO8859-1 only.
     */
    int doing = (result != 0);
    int ok = TRUE;
    char *p = NULL;
    int plen = 0, psize = 0;

    for (; *s; s++) {
	wchar_t c = *s;
	char outc;

	if ((c >= 32 && c <= 126) ||
	    (c >= 160 && c <= 255)) {
	    /* Char is OK. */
	    outc = (char)c;
	} else {
	    /* Char is not OK. */
	    ok = FALSE;
	    outc = 0xBF;	       /* approximate the good old DEC `uh?' */
	}
	if (doing) {
	    if (plen+3 >= psize) {
		psize = plen + 256;
		p = resize(p, psize);
	    }
	    if (plen == 0 && (outc == '.' || outc == '\'') &&
		(quote_props & QUOTE_INITCTRL)) {
		/*
		 * Control character (. or ') at the start of a
		 * line. Quote it by putting \& (troff zero-width
		 * space) before it.
		 */
		p[plen++] = '\\';
		p[plen++] = '&';
	    } else if (outc == '\\') {
		/*
		 * Quote backslashes by doubling them, always.
		 */
		p[plen++] = '\\';
	    } else if (outc == '"' && (quote_props & QUOTE_QUOTES)) {
		/*
		 * Double quote within double quotes. Quote it by
		 * doubling.
		 */
		p[plen++] = '"';
	    }
	    p[plen++] = outc;
	}
    }
    if (doing) {
	p = resize(p, plen+1);
	p[plen] = '\0';
	*result = p;
    }
    return ok;
}

static void man_rdaddwc(rdstringc *rs, word *text, word *end,
			int quote_props) {
    char *c;

    for (; text && text != end; text = text->next) switch (text->type) {
      case word_HyperLink:
      case word_HyperEnd:
      case word_UpperXref:
      case word_LowerXref:
      case word_XrefEnd:
      case word_IndexRef:
	break;

      case word_Normal:
      case word_Emph:
      case word_Code:
      case word_WeakCode:
      case word_WhiteSpace:
      case word_EmphSpace:
      case word_CodeSpace:
      case word_WkCodeSpace:
      case word_Quote:
      case word_EmphQuote:
      case word_CodeQuote:
      case word_WkCodeQuote:
	assert(text->type != word_CodeQuote &&
	       text->type != word_WkCodeQuote);
	if (towordstyle(text->type) == word_Emph &&
	    (attraux(text->aux) == attr_First ||
	     attraux(text->aux) == attr_Only))
	    rdaddsc(rs, "\\fI");
	else if (towordstyle(text->type) == word_Code &&
		 (attraux(text->aux) == attr_First ||
		  attraux(text->aux) == attr_Only))
	    rdaddsc(rs, "\\fB");
	if (removeattr(text->type) == word_Normal) {
	    if (rs->pos > 0)
		quote_props &= ~QUOTE_INITCTRL;   /* not at start any more */
	    if (man_convert(text->text, &c, quote_props))
		rdaddsc(rs, c);
	    else
		man_rdaddwc(rs, text->alt, NULL, quote_props);
	    sfree(c);
	} else if (removeattr(text->type) == word_WhiteSpace) {
	    rdaddc(rs, ' ');
	} else if (removeattr(text->type) == word_Quote) {
	    rdaddc(rs, quoteaux(text->aux) == quote_Open ? '`' : '\'');
				       /* FIXME: configurability */
	}
	if (towordstyle(text->type) == word_Emph &&
	    (attraux(text->aux) == attr_Last ||
	     attraux(text->aux) == attr_Only))
	    rdaddsc(rs, "\\fP");
	else if (towordstyle(text->type) == word_Code &&
		 (attraux(text->aux) == attr_Last ||
		  attraux(text->aux) == attr_Only))
	    rdaddsc(rs, "\\fP");
	break;
    }
}

static void man_text(FILE *fp, word *text, int newline, int quote_props) {
    rdstringc t = { 0, 0, NULL };

    man_rdaddwc(&t, text, NULL, quote_props | QUOTE_INITCTRL);
    fprintf(fp, "%s", t.text);
    sfree(t.text);
    if (newline)
	fputc('\n', fp);
}

static void man_codepara(FILE *fp, word *text) {
    fprintf(fp, ".nf\n");
    for (; text; text = text->next) if (text->type == word_WeakCode) {
	char *c;
	man_convert(text->text, &c, QUOTE_INITCTRL);
	fprintf(fp, "%s\n", c);
	sfree(c);
    }
    fprintf(fp, ".fi\n");
}
Commit	Line	Data
7136a6c7	1	/*
	2	* man page backend for Halibut
	3	*/
	4
	5	#include <stdio.h>
	6	#include <stdlib.h>
	7	#include <assert.h>
	8	#include "halibut.h"
	9
	10	static void man_text(FILE , word , int newline, int quote_props);
	11	static void man_codepara(FILE , word );
	12
	13	#define QUOTE_INITCTRL 1 /* quote initial . and ' on a line */
	14	#define QUOTE_QUOTES 2 /* quote double quotes by doubling them */
	15
	16	void man_backend(paragraph sourceform, keywordlist keywords,
	17	indexdata *idx) {
	18	paragraph *p;
	19	FILE *fp;
	20	char const *sep;
	21
	22	IGNORE(keywords); /* we don't happen to need this */
	23	IGNORE(idx); /* or this */
	24
	25	/*
	26	* Determine the output file name, and open the output file
	27	*
	28	* FIXME: want configurable output file names here. For the
	29	* moment, we'll just call it `output.1'.
	30	*/
	31	fp = fopen("output.1", "w");
	32	if (!fp) {
	33	error(err_cantopenw, "output.1");
	34	return;
	35	}
	36
	37	/* Do the version ID */
	38	for (p = sourceform; p; p = p->next)
	39	if (p->type == para_VersionID) {
	40	fprintf(fp, ".\\\" ");
	41	man_text(fp, p->words, TRUE, 0);
	42	}
	43
	44	/* FIXME: .TH name-of-program manual-section */
	45	fprintf(fp, ".TH FIXME 1\n");
	46
	47	fprintf(fp, ".UC\n");
	48
	49	/* Do the preamble and copyright */
	50	sep = "";
	51	for (p = sourceform; p; p = p->next)
	52	if (p->type == para_Preamble) {
	53	fprintf(fp, "%s", sep);
	54	man_text(fp, p->words, TRUE, 0);
	55	sep = "\n";
	56	}
	57	for (p = sourceform; p; p = p->next)
	58	if (p->type == para_Copyright) {
	59	fprintf(fp, "%s", sep);
	60	man_text(fp, p->words, TRUE, 0);
	61	sep = "\n";
	62	}
	63
	64	/*
65	* FIXME:
66	*
67	* - figure out precisely what needs to be escaped.
68	* * A dot or apostrophe at the start of a line wants to be
69	* preceded by `\&', which is a zero-width space.
70	* * Literal backslashes always want doubling.
71	* * Within double quotes, a double quote needs doubling
72	* too.
73	*
74	* - work out what to do about hyphens / minuses...
75	*/
76	for (p = sourceform; p; p = p->next) switch (p->type) {
77	/*
78	* Things we ignore because we've already processed them or
79	* aren't going to touch them in this pass.
80	*/
81	case para_IM:
82	case para_BR:
83	case para_Biblio: /* only touch BiblioCited */
84	case para_VersionID:
85	case para_Copyright:
86	case para_Preamble:
87	case para_NoCite:
88	case para_Title:
89	break;
90
91	/*
92	* Headings.
93	*/
94	case para_Chapter:
95	case para_Appendix:
96	case para_UnnumberedChapter:
97	case para_Heading:
98	case para_Subsect:
99	fprintf(fp, ".SH \"");
100	/* FIXME: disable this, at _least_ by default */
101	if (p->kwtext)
102	man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
103	fprintf(fp, " ");
104	man_text(fp, p->words, FALSE, QUOTE_QUOTES);
105	fprintf(fp, "\"\n");
106	break;
107
108	/*
109	* Code paragraphs.
110	*/
111	case para_Code:
112	fprintf(fp, ".PP\n");
113	man_codepara(fp, p->words);
114	break;
115
116	/*
117	* Normal paragraphs.
118	*/
119	case para_Normal:
120	fprintf(fp, ".PP\n");
121	man_text(fp, p->words, TRUE, 0);
122	break;
123
124	/*
125	* List paragraphs.
126	*/
127	case para_Description:
128	case para_BiblioCited:
129	case para_Bullet:
130	case para_NumberedList:
131	if (p->type == para_Bullet) {
132	fprintf(fp, ".IP \"\\fBo\\fP\"\n"); /* FIXME: configurable? */
133	} else if (p->type == para_NumberedList) {
134	fprintf(fp, ".IP \"");
135	man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
136	fprintf(fp, "\"\n");
137	} else if (p->type == para_Description) {
138	/*
139	* Do nothing; the .xP for this paragraph is the .IP
140	* which has come before it in the DescribedThing.
141	*/
142	} else if (p->type == para_BiblioCited) {
143	fprintf(fp, ".IP \"");
144	man_text(fp, p->kwtext, FALSE, QUOTE_QUOTES);
145	fprintf(fp, "\"\n");
146	}
147	man_text(fp, p->words, TRUE, 0);
148	break;
149
150	case para_DescribedThing:
151	fprintf(fp, ".IP \"");
152	man_text(fp, p->words, FALSE, QUOTE_QUOTES);
153	fprintf(fp, "\"\n");
154	break;
155
156	case para_Rule:
157	/*
158	* FIXME.
159	*/
160	break;
161
162	case para_LcontPush:
163	fprintf(fp, ".RS\n");
164	break;
165	case para_LcontPop:
166	fprintf(fp, ".RE\n");
167	break;
168	}
169
170	/*
171	* Tidy up.
172	*/
173	fclose(fp);
174	}
175
176	/*
177	* Convert a wide string into a string of chars. If `result' is
178	* non-NULL, mallocs the resulting string and stores a pointer to
179	* it in `*result'. If `result' is NULL, merely checks whether all
180	* characters in the string are feasible for the output character
181	* set.
182	*
183	* Return is nonzero if all characters are OK. If not all
184	* characters are OK but `result' is non-NULL, a result _will_
185	* still be generated!
186	*
187	* FIXME: Here is probably also a good place to do escaping sorts
188	* of things. I know I at least need to escape backslash, and full
189	* stops at the starts of words are probably trouble as well.
190	*/
191	static int man_convert(wchar_t s, char *result, int quote_props) {
192	/*
193	* FIXME. Currently this is ISO8859-1 only.
194	*/
195	int doing = (result != 0);
196	int ok = TRUE;
197	char *p = NULL;
198	int plen = 0, psize = 0;
199
200	for (; *s; s++) {
201	wchar_t c = *s;
202	char outc;
203
204	if ((c >= 32 && c <= 126) \|\|
205	(c >= 160 && c <= 255)) {
206	/* Char is OK. */
207	outc = (char)c;
208	} else {
209	/* Char is not OK. */
210	ok = FALSE;
211	outc = 0xBF; /* approximate the good old DEC `uh?' */
212	}
213	if (doing) {
214	if (plen+3 >= psize) {
215	psize = plen + 256;
216	p = resize(p, psize);
217	}
218	if (plen == 0 && (outc == '.' \|\| outc == '\'') &&
219	(quote_props & QUOTE_INITCTRL)) {
220	/*
221	* Control character (. or ') at the start of a
222	* line. Quote it by putting \& (troff zero-width
223	* space) before it.
224	*/
225	p[plen++] = '\\';
226	p[plen++] = '&';
227	} else if (outc == '\\') {
228	/*
229	* Quote backslashes by doubling them, always.
230	*/
231	p[plen++] = '\\';
232	} else if (outc == '"' && (quote_props & QUOTE_QUOTES)) {
233	/*
234	* Double quote within double quotes. Quote it by
235	* doubling.
236	*/
237	p[plen++] = '"';
238	}
239	p[plen++] = outc;
240	}
241	}
242	if (doing) {
243	p = resize(p, plen+1);
244	p[plen] = '\0';
245	*result = p;
246	}
247	return ok;
248	}
249
250	static void man_rdaddwc(rdstringc rs, word text, word *end,
251	int quote_props) {
252	char *c;
253
254	for (; text && text != end; text = text->next) switch (text->type) {
255	case word_HyperLink:
256	case word_HyperEnd:
257	case word_UpperXref:
258	case word_LowerXref:
259	case word_XrefEnd:
260	case word_IndexRef:
261	break;
262
263	case word_Normal:
264	case word_Emph:
265	case word_Code:
266	case word_WeakCode:
267	case word_WhiteSpace:
268	case word_EmphSpace:
269	case word_CodeSpace:
270	case word_WkCodeSpace:
271	case word_Quote:
272	case word_EmphQuote:
273	case word_CodeQuote:
274	case word_WkCodeQuote:
275	assert(text->type != word_CodeQuote &&
276	text->type != word_WkCodeQuote);
277	if (towordstyle(text->type) == word_Emph &&
278	(attraux(text->aux) == attr_First \|\|
279	attraux(text->aux) == attr_Only))
280	rdaddsc(rs, "\\fI");
281	else if (towordstyle(text->type) == word_Code &&
282	(attraux(text->aux) == attr_First \|\|
283	attraux(text->aux) == attr_Only))
284	rdaddsc(rs, "\\fB");
285	if (removeattr(text->type) == word_Normal) {
286	if (rs->pos > 0)
287	quote_props &= ~QUOTE_INITCTRL; /* not at start any more */
288	if (man_convert(text->text, &c, quote_props))
289	rdaddsc(rs, c);
290	else
291	man_rdaddwc(rs, text->alt, NULL, quote_props);
292	sfree(c);
293	} else if (removeattr(text->type) == word_WhiteSpace) {
294	rdaddc(rs, ' ');
295	} else if (removeattr(text->type) == word_Quote) {
296	rdaddc(rs, quoteaux(text->aux) == quote_Open ? '`' : '\'');
297	/* FIXME: configurability */
298	}
299	if (towordstyle(text->type) == word_Emph &&
300	(attraux(text->aux) == attr_Last \|\|
301	attraux(text->aux) == attr_Only))
302	rdaddsc(rs, "\\fP");
303	else if (towordstyle(text->type) == word_Code &&
304	(attraux(text->aux) == attr_Last \|\|
305	attraux(text->aux) == attr_Only))
306	rdaddsc(rs, "\\fP");
307	break;
308	}
309	}
310
311	static void man_text(FILE fp, word text, int newline, int quote_props) {
312	rdstringc t = { 0, 0, NULL };
313
314	man_rdaddwc(&t, text, NULL, quote_props \| QUOTE_INITCTRL);
315	fprintf(fp, "%s", t.text);
316	sfree(t.text);
317	if (newline)
318	fputc('\n', fp);
319	}
320
321	static void man_codepara(FILE fp, word text) {
322	fprintf(fp, ".nf\n");
323	for (; text; text = text->next) if (text->type == word_WeakCode) {
324	char *c;
325	man_convert(text->text, &c, QUOTE_INITCTRL);
326	fprintf(fp, "%s\n", c);
327	sfree(c);
328	}
329	fprintf(fp, ".fi\n");
330	}