[sgt/halibut] / bk_ps.c

/*
 * PostScript backend for Halibut
 */

#include <assert.h>
#include "halibut.h"
#include "paper.h"

static void ps_comment(FILE *fp, char const *leader, word *words);

paragraph *ps_config_filename(char *filename)
{
    return cmdline_cfg_simple("ps-filename", filename, NULL);
}

void ps_backend(paragraph *sourceform, keywordlist *keywords,
		indexdata *idx, void *vdoc) {
    document *doc = (document *)vdoc;
    int font_index;
    font_encoding *fe;
    page_data *page;
    int pageno;
    FILE *fp;
    char *filename;
    paragraph *p;

    IGNORE(keywords);
    IGNORE(idx);

    filename = dupstr("output.ps");
    for (p = sourceform; p; p = p->next) {
	if (p->type == para_Config) {
	    if (!ustricmp(p->keyword, L"ps-filename")) {
		sfree(filename);
		filename = dupstr(adv(p->origkeyword));
	    }
	}
    }

    fp = fopen(filename, "w");
    if (!fp) {
	error(err_cantopenw, filename);
	return;
    }

    fprintf(fp, "%%!PS-Adobe-3.0\n");
    fprintf(fp, "%%%%Creator: Halibut, %s\n", version);
    fprintf(fp, "%%%%DocumentData: Clean8Bit\n");
    fprintf(fp, "%%%%LanguageLevel: 1\n");
    for (pageno = 0, page = doc->pages; page; page = page->next)
	pageno++;
    fprintf(fp, "%%%%Pages: %d\n", pageno);
    for (p = sourceform; p; p = p->next)
	if (p->type == para_Title)
	    ps_comment(fp, "%%Title: ", p->words);
    fprintf(fp, "%%%%DocumentNeededResources:\n");
    for (fe = doc->fonts->head; fe; fe = fe->next)
	/* XXX This may request the same font multiple times. */
	if (!fe->font->info->fp)
	    fprintf(fp, "%%%%+ font %s\n", fe->font->info->name);
    fprintf(fp, "%%%%DocumentSuppliedResources: procset Halibut 0 0\n");
    for (fe = doc->fonts->head; fe; fe = fe->next)
	/* XXX This may request the same font multiple times. */
	if (fe->font->info->fp)
	    fprintf(fp, "%%%%+ font %s\n", fe->font->info->name);
    fprintf(fp, "%%%%EndComments\n");

    fprintf(fp, "%%%%BeginProlog\n");
    fprintf(fp, "%%%%BeginResource: procset Halibut 0 0\n");
    /*
     * Supply a prologue function which allows a reasonably
     * compressed representation of the text on the pages.
     * 
     * Expects two arguments: a y-coordinate, and then an array.
     * Elements of the array are processed sequentially as follows:
     * 
     *  - a number is treated as an x-coordinate
     *  - an array is treated as a (font, size) pair
     *  - a string is shown
     */
    fprintf(fp,
	    "/tdict 4 dict dup begin\n"
	    "  /arraytype {aload pop scalefont setfont} bind def\n"
	    "  /realtype {1 index moveto} bind def\n"
	    "  /integertype /realtype load def\n"
	    "  /stringtype {show} bind def\n"
	    "end def\n"
	    "/t { tdict begin {dup type exec} forall end pop } bind def\n");

    fprintf(fp, "%%%%EndResource\n");
    fprintf(fp, "%%%%EndProlog\n");

    fprintf(fp, "%%%%BeginSetup\n");

    /*
     * This is as good a place as any to put version IDs.
     */
    for (p = sourceform; p; p = p->next)
	if (p->type == para_VersionID)
	    ps_comment(fp, "% ", p->words);

    /*
     * Request the correct page size.  We might want to bracket this
     * with "%%BeginFeature: *PageSize A4" or similar, and "%%EndFeature",
     * but that would require us to have a way of getting the name of
     * the page size given its dimensions.
     */
    fprintf(fp, "/setpagedevice where {\n");
    fprintf(fp, "  pop 2 dict dup /PageSize [%g %g] put setpagedevice\n",
	    doc->paper_width / FUNITS_PER_PT,
	    doc->paper_height / FUNITS_PER_PT);
    fprintf(fp, "} if\n");

    for (fe = doc->fonts->head; fe; fe = fe->next) {
	/* XXX This may request the same font multiple times. */
	if (fe->font->info->fp) {
	    char buf[512];
	    size_t len;
	    fprintf(fp, "%%%%BeginResource: font %s\n", fe->font->info->name);
	    rewind(fe->font->info->fp);
	    do {
		len = fread(buf, 1, sizeof(buf), fe->font->info->fp);
		fwrite(buf, 1, len, fp);
	    } while (len == sizeof(buf));
	    fprintf(fp, "%%%%EndResource\n");
	} else {
	    fprintf(fp, "%%%%IncludeResource: font %s\n",
		    fe->font->info->name);
	}
    }

    /*
     * Re-encode the fonts.
     */
    font_index = 0;
    for (fe = doc->fonts->head; fe; fe = fe->next) {
	char fname[40];
	int i;

	sprintf(fname, "f%d", font_index++);
	fe->name = dupstr(fname);

	fprintf(fp, "/%s findfont dup length dict begin\n",
	    fe->font->info->name);
	fprintf(fp, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
	fprintf(fp, "/Encoding [\n");
	for (i = 0; i < 256; i++)
	    fprintf(fp, "/%s%c", fe->vector[i] ? fe->vector[i] : ".notdef",
		    i % 4 == 3 ? '\n' : ' ');
	fprintf(fp, "] def\n");
	fprintf(fp, "currentdict end\n");
	fprintf(fp, "/fontname-%s exch definefont /%s exch def\n\n",
	       fe->name, fe->name);
    }
    fprintf(fp, "%%%%EndSetup\n");

    /*
     * Output the text and graphics.
     */
    pageno = 0;
    for (page = doc->pages; page; page = page->next) {
	text_fragment *frag, *frag_end;
	rect *r;
	font_encoding *fe;
	int fs;

	pageno++;
	fprintf(fp, "%%%%Page: %d %d\n", pageno, pageno);
	fprintf(fp, "save\n");

#if 0
	{
	    xref *xr;
	    /*
	     * I used this diagnostic briefly to ensure that
	     * cross-reference rectangles were being put where they
	     * should be.
	     */
	    for (xr = page->first_xref; xr; xr = xr->next) {
		fprintf(fp, "gsave 0.7 setgray %g %g moveto",
			xr->lx/FUNITS_PER_PT, xr->ty/FUNITS_PER_PT);
		fprintf(fp, " %g %g lineto %g %g lineto",
			xr->lx/FUNITS_PER_PT, xr->by/FUNITS_PER_PT,
			xr->rx/FUNITS_PER_PT, xr->by/FUNITS_PER_PT);
		fprintf(fp, " %g %g lineto closepath fill grestore\n",
			xr->rx/FUNITS_PER_PT, xr->ty/FUNITS_PER_PT);
	    }
	}
#endif

	for (r = page->first_rect; r; r = r->next) {
	    fprintf(fp, "%g %g moveto %g 0 rlineto 0 %g rlineto "
		    "-%g 0 rlineto closepath fill\n",
		    r->x / FUNITS_PER_PT, r->y / FUNITS_PER_PT,
		    r->w / FUNITS_PER_PT, r->h / FUNITS_PER_PT,
		    r->w / FUNITS_PER_PT);
	}

	frag = page->first_text;
	fe = NULL;
	fs = -1;
	while (frag) {
	    char *c;

	    /*
	     * Collect all the adjacent text fragments with the
	     * same y-coordinate.
	     */
	    for (frag_end = frag;
		 frag_end && frag_end->y == frag->y;
		 frag_end = frag_end->next);

	    fprintf(fp, "%g[", frag->y / FUNITS_PER_PT);

	    while (frag && frag != frag_end) {

		if (frag->fe != fe || frag->fontsize != fs)
		    fprintf(fp, "[%s %d]", frag->fe->name, frag->fontsize);
		fe = frag->fe;
		fs = frag->fontsize;

		fprintf(fp, "%g(", frag->x/FUNITS_PER_PT);
		for (c = frag->text; *c; c++) {
		    if (*c == '(' || *c == ')' || *c == '\\')
			fputc('\\', fp);
		    fputc(*c, fp);
		}
		fprintf(fp, ")");

		frag = frag->next;
	    }

	    fprintf(fp, "]t\n");
	}

	fprintf(fp, "restore showpage\n");
    }

    fprintf(fp, "%%%%EOF\n");

    fclose(fp);

    sfree(filename);
}

static void ps_comment(FILE *fp, char const *leader, word *words)
{
    fprintf(fp, "%s", leader);

    for (; words; words = words->next) {
	char *text;
	int type;

	switch (words->type) {
	  case word_HyperLink:
	  case word_HyperEnd:
	  case word_UpperXref:
	  case word_LowerXref:
	  case word_XrefEnd:
	  case word_IndexRef:
	    continue;
	}

	type = removeattr(words->type);

	switch (type) {
	  case word_Normal:
	    text = utoa_dup(words->text, CS_ASCII);
	    break;
	  case word_WhiteSpace:
	    text = dupstr(" ");
	    break;
	  case word_Quote:
	    text = dupstr("'");
	    break;
	}

	fputs(text, fp);
	sfree(text);
    }

    fprintf(fp, "\n");
}
Commit	Line	Data
43341922	1	/*
	2	* PostScript backend for Halibut
	3	*/
	4
	5	#include <assert.h>
	6	#include "halibut.h"
	7	#include "paper.h"
	8
b0f1f943	9	static void ps_comment(FILE fp, char const leader, word *words);
09358aa7	10
43341922	11	paragraph ps_config_filename(char filename)
43341922	12	{
e4ea58f8	13	return cmdline_cfg_simple("ps-filename", filename, NULL);
43341922	14	}
	15
	16	void ps_backend(paragraph sourceform, keywordlist keywords,
	17	indexdata idx, void vdoc) {
	18	document doc = (document )vdoc;
	19	int font_index;
	20	font_encoding *fe;
	21	page_data *page;
	22	int pageno;
	23	FILE *fp;
	24	char *filename;
	25	paragraph *p;
	26
	27	IGNORE(keywords);
	28	IGNORE(idx);
	29
	30	filename = dupstr("output.ps");
	31	for (p = sourceform; p; p = p->next) {
7738a2fb	32	if (p->type == para_Config) {
43341922	33	if (!ustricmp(p->keyword, L"ps-filename")) {
43341922	34	sfree(filename);
e4ea58f8	35	filename = dupstr(adv(p->origkeyword));
43341922	36	}
	37	}
	38	}
	39
	40	fp = fopen(filename, "w");
	41	if (!fp) {
	42	error(err_cantopenw, filename);
	43	return;
	44	}
	45
b0f1f943	46	fprintf(fp, "%%!PS-Adobe-3.0\n");
	47	fprintf(fp, "%%%%Creator: Halibut, %s\n", version);
	48	fprintf(fp, "%%%%DocumentData: Clean8Bit\n");
	49	fprintf(fp, "%%%%LanguageLevel: 1\n");
43341922	50	for (pageno = 0, page = doc->pages; page; page = page->next)
	51	pageno++;
	52	fprintf(fp, "%%%%Pages: %d\n", pageno);
b0f1f943	53	for (p = sourceform; p; p = p->next)
	54	if (p->type == para_Title)
	55	ps_comment(fp, "%%Title: ", p->words);
	56	fprintf(fp, "%%%%DocumentNeededResources:\n");
	57	for (fe = doc->fonts->head; fe; fe = fe->next)
	58	/* XXX This may request the same font multiple times. */
44407fea	59	if (!fe->font->info->fp)
44407fea	60	fprintf(fp, "%%%%+ font %s\n", fe->font->info->name);
b0f1f943	61	fprintf(fp, "%%%%DocumentSuppliedResources: procset Halibut 0 0\n");
44407fea	62	for (fe = doc->fonts->head; fe; fe = fe->next)
	63	/* XXX This may request the same font multiple times. */
	64	if (fe->font->info->fp)
	65	fprintf(fp, "%%%%+ font %s\n", fe->font->info->name);
43341922	66	fprintf(fp, "%%%%EndComments\n");
	67
	68	fprintf(fp, "%%%%BeginProlog\n");
b0f1f943	69	fprintf(fp, "%%%%BeginResource: procset Halibut 0 0\n");
7c8c4239	70	/*
	71	* Supply a prologue function which allows a reasonably
	72	* compressed representation of the text on the pages.
	73	*
	74	* Expects two arguments: a y-coordinate, and then an array.
	75	* Elements of the array are processed sequentially as follows:
	76	*
	77	* - a number is treated as an x-coordinate
	78	* - an array is treated as a (font, size) pair
	79	* - a string is shown
	80	*/
	81	fprintf(fp,
67f13fa7	82	"/tdict 4 dict dup begin\n"
	83	" /arraytype {aload pop scalefont setfont} bind def\n"
	84	" /realtype {1 index moveto} bind def\n"
	85	" /integertype /realtype load def\n"
	86	" /stringtype {show} bind def\n"
	87	"end def\n"
ac71b3f5	88	"/t { tdict begin {dup type exec} forall end pop } bind def\n");
7c8c4239	89
b0f1f943	90	fprintf(fp, "%%%%EndResource\n");
43341922	91	fprintf(fp, "%%%%EndProlog\n");
	92
	93	fprintf(fp, "%%%%BeginSetup\n");
09358aa7	94
	95	/*
	96	* This is as good a place as any to put version IDs.
	97	*/
	98	for (p = sourceform; p; p = p->next)
	99	if (p->type == para_VersionID)
b0f1f943	100	ps_comment(fp, "% ", p->words);
b0f1f943	101
a10f193f	102	/*
	103	* Request the correct page size. We might want to bracket this
	104	* with "%%BeginFeature: *PageSize A4" or similar, and "%%EndFeature",
	105	* but that would require us to have a way of getting the name of
	106	* the page size given its dimensions.
	107	*/
	108	fprintf(fp, "/setpagedevice where {\n");
	109	fprintf(fp, " pop 2 dict dup /PageSize [%g %g] put setpagedevice\n",
	110	doc->paper_width / FUNITS_PER_PT,
	111	doc->paper_height / FUNITS_PER_PT);
	112	fprintf(fp, "} if\n");
	113
44407fea	114	for (fe = doc->fonts->head; fe; fe = fe->next) {
b0f1f943	115	/* XXX This may request the same font multiple times. */
44407fea	116	if (fe->font->info->fp) {
	117	char buf[512];
	118	size_t len;
	119	fprintf(fp, "%%%%BeginResource: font %s\n", fe->font->info->name);
	120	rewind(fe->font->info->fp);
	121	do {
	122	len = fread(buf, 1, sizeof(buf), fe->font->info->fp);
	123	fwrite(buf, 1, len, fp);
	124	} while (len == sizeof(buf));
	125	fprintf(fp, "%%%%EndResource\n");
	126	} else {
	127	fprintf(fp, "%%%%IncludeResource: font %s\n",
	128	fe->font->info->name);
	129	}
	130	}
09358aa7	131
43341922	132	/*
32ca74bb	133	* Re-encode the fonts.
43341922	134	*/
	135	font_index = 0;
	136	for (fe = doc->fonts->head; fe; fe = fe->next) {
	137	char fname[40];
	138	int i;
	139
	140	sprintf(fname, "f%d", font_index++);
	141	fe->name = dupstr(fname);
	142
ba0fe3ec	143	fprintf(fp, "/%s findfont dup length dict begin\n",
ba0fe3ec	144	fe->font->info->name);
43341922	145	fprintf(fp, "{1 index /FID ne {def} {pop pop} ifelse} forall\n");
	146	fprintf(fp, "/Encoding [\n");
	147	for (i = 0; i < 256; i++)
17c71b41	148	fprintf(fp, "/%s%c", fe->vector[i] ? fe->vector[i] : ".notdef",
17c71b41	149	i % 4 == 3 ? '\n' : ' ');
32ca74bb	150	fprintf(fp, "] def\n");
32ca74bb	151	fprintf(fp, "currentdict end\n");
43341922	152	fprintf(fp, "/fontname-%s exch definefont /%s exch def\n\n",
	153	fe->name, fe->name);
	154	}
	155	fprintf(fp, "%%%%EndSetup\n");
	156
	157	/*
23765aeb	158	* Output the text and graphics.
43341922	159	*/
	160	pageno = 0;
	161	for (page = doc->pages; page; page = page->next) {
7c8c4239	162	text_fragment frag, frag_end;
23765aeb	163	rect *r;
3e32e06c	164	font_encoding *fe;
3e32e06c	165	int fs;
43341922	166
	167	pageno++;
	168	fprintf(fp, "%%%%Page: %d %d\n", pageno, pageno);
ae52aa5d	169	fprintf(fp, "save\n");
43341922	170
138d7ffb	171	#if 0
	172	{
	173	xref *xr;
	174	/*
	175	* I used this diagnostic briefly to ensure that
	176	* cross-reference rectangles were being put where they
	177	* should be.
	178	*/
	179	for (xr = page->first_xref; xr; xr = xr->next) {
	180	fprintf(fp, "gsave 0.7 setgray %g %g moveto",
17c71b41	181	xr->lx/FUNITS_PER_PT, xr->ty/FUNITS_PER_PT);
138d7ffb	182	fprintf(fp, " %g %g lineto %g %g lineto",
17c71b41	183	xr->lx/FUNITS_PER_PT, xr->by/FUNITS_PER_PT,
17c71b41	184	xr->rx/FUNITS_PER_PT, xr->by/FUNITS_PER_PT);
138d7ffb	185	fprintf(fp, " %g %g lineto closepath fill grestore\n",
17c71b41	186	xr->rx/FUNITS_PER_PT, xr->ty/FUNITS_PER_PT);
138d7ffb	187	}
	188	}
	189	#endif
	190
23765aeb	191	for (r = page->first_rect; r; r = r->next) {
	192	fprintf(fp, "%g %g moveto %g 0 rlineto 0 %g rlineto "
	193	"-%g 0 rlineto closepath fill\n",
17c71b41	194	r->x / FUNITS_PER_PT, r->y / FUNITS_PER_PT,
	195	r->w / FUNITS_PER_PT, r->h / FUNITS_PER_PT,
	196	r->w / FUNITS_PER_PT);
23765aeb	197	}
23765aeb	198
7c8c4239	199	frag = page->first_text;
3e32e06c	200	fe = NULL;
3e32e06c	201	fs = -1;
7c8c4239	202	while (frag) {
43341922	203	char *c;
43341922	204
7c8c4239	205	/*
	206	* Collect all the adjacent text fragments with the
	207	* same y-coordinate.
	208	*/
	209	for (frag_end = frag;
	210	frag_end && frag_end->y == frag->y;
	211	frag_end = frag_end->next);
	212
17c71b41	213	fprintf(fp, "%g[", frag->y / FUNITS_PER_PT);
7c8c4239	214
7c8c4239	215	while (frag && frag != frag_end) {
	216
	217	if (frag->fe != fe \|\| frag->fontsize != fs)
	218	fprintf(fp, "[%s %d]", frag->fe->name, frag->fontsize);
	219	fe = frag->fe;
	220	fs = frag->fontsize;
	221
17c71b41	222	fprintf(fp, "%g(", frag->x/FUNITS_PER_PT);
7c8c4239	223	for (c = frag->text; *c; c++) {
	224	if (c == '(' \|\| c == ')' \|\| *c == '\\')
	225	fputc('\\', fp);
	226	fputc(*c, fp);
	227	}
	228	fprintf(fp, ")");
43341922	229
7c8c4239	230	frag = frag->next;
43341922	231	}
43341922	232
7c8c4239	233	fprintf(fp, "]t\n");
43341922	234	}
43341922	235
ae52aa5d	236	fprintf(fp, "restore showpage\n");
43341922	237	}
	238
	239	fprintf(fp, "%%%%EOF\n");
	240
	241	fclose(fp);
	242
	243	sfree(filename);
	244	}
09358aa7	245
b0f1f943	246	static void ps_comment(FILE fp, char const leader, word *words)
09358aa7	247	{
b0f1f943	248	fprintf(fp, "%s", leader);
09358aa7	249
	250	for (; words; words = words->next) {
	251	char *text;
	252	int type;
	253
	254	switch (words->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	continue;
	262	}
	263
	264	type = removeattr(words->type);
	265
	266	switch (type) {
	267	case word_Normal:
e4ea58f8	268	text = utoa_dup(words->text, CS_ASCII);
09358aa7	269	break;
	270	case word_WhiteSpace:
	271	text = dupstr(" ");
	272	break;
	273	case word_Quote:
	274	text = dupstr("'");
	275	break;
	276	}
	277
	278	fputs(text, fp);
	279	sfree(text);
	280	}
	281
	282	fprintf(fp, "\n");
	283	}