1/*	$Id: term_ps.c,v 1.80 2015/12/23 20:50:13 schwarze Exp $ */
2/*
3 * Copyright (c) 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18#include "config.h"
19
20#include <sys/types.h>
21
22#include <assert.h>
23#if HAVE_ERR
24#include <err.h>
25#endif
26#include <stdarg.h>
27#include <stdint.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31#include <unistd.h>
32
33#include "mandoc_aux.h"
34#include "out.h"
35#include "term.h"
36#include "manconf.h"
37#include "main.h"
38
39/* These work the buffer used by the header and footer. */
40#define	PS_BUFSLOP	  128
41
42/* Convert PostScript point "x" to an AFM unit. */
43#define	PNT2AFM(p, x) \
44	(size_t)((double)(x) * (1000.0 / (double)(p)->ps->scale))
45
46/* Convert an AFM unit "x" to a PostScript points */
47#define	AFM2PNT(p, x) \
48	((double)(x) / (1000.0 / (double)(p)->ps->scale))
49
50struct	glyph {
51	unsigned short	  wx; /* WX in AFM */
52};
53
54struct	font {
55	const char	 *name; /* FontName in AFM */
56#define	MAXCHAR		  95 /* total characters we can handle */
57	struct glyph	  gly[MAXCHAR]; /* glyph metrics */
58};
59
60struct	termp_ps {
61	int		  flags;
62#define	PS_INLINE	 (1 << 0)	/* we're in a word */
63#define	PS_MARGINS	 (1 << 1)	/* we're in the margins */
64#define	PS_NEWPAGE	 (1 << 2)	/* new page, no words yet */
65#define	PS_BACKSP	 (1 << 3)	/* last character was backspace */
66	size_t		  pscol;	/* visible column (AFM units) */
67	size_t		  pscolnext;	/* used for overstrike */
68	size_t		  psrow;	/* visible row (AFM units) */
69	char		 *psmarg;	/* margin buf */
70	size_t		  psmargsz;	/* margin buf size */
71	size_t		  psmargcur;	/* cur index in margin buf */
72	char		  last;		/* last non-backspace seen */
73	enum termfont	  lastf;	/* last set font */
74	enum termfont	  nextf;	/* building next font here */
75	size_t		  scale;	/* font scaling factor */
76	size_t		  pages;	/* number of pages shown */
77	size_t		  lineheight;	/* line height (AFM units) */
78	size_t		  top;		/* body top (AFM units) */
79	size_t		  bottom;	/* body bottom (AFM units) */
80	size_t		  height;	/* page height (AFM units */
81	size_t		  width;	/* page width (AFM units) */
82	size_t		  lastwidth;	/* page width before last ll */
83	size_t		  left;		/* body left (AFM units) */
84	size_t		  header;	/* header pos (AFM units) */
85	size_t		  footer;	/* footer pos (AFM units) */
86	size_t		  pdfbytes;	/* current output byte */
87	size_t		  pdflastpg;	/* byte of last page mark */
88	size_t		  pdfbody;	/* start of body object */
89	size_t		 *pdfobjs;	/* table of object offsets */
90	size_t		  pdfobjsz;	/* size of pdfobjs */
91};
92
93static	int		  ps_hspan(const struct termp *,
94				const struct roffsu *);
95static	size_t		  ps_width(const struct termp *, int);
96static	void		  ps_advance(struct termp *, size_t);
97static	void		  ps_begin(struct termp *);
98static	void		  ps_closepage(struct termp *);
99static	void		  ps_end(struct termp *);
100static	void		  ps_endline(struct termp *);
101static	void		  ps_fclose(struct termp *);
102static	void		  ps_growbuf(struct termp *, size_t);
103static	void		  ps_letter(struct termp *, int);
104static	void		  ps_pclose(struct termp *);
105static	void		  ps_pletter(struct termp *, int);
106#if __GNUC__ - 0 >= 4
107__attribute__((__format__ (__printf__, 2, 3)))
108#endif
109static	void		  ps_printf(struct termp *, const char *, ...);
110static	void		  ps_putchar(struct termp *, char);
111static	void		  ps_setfont(struct termp *, enum termfont);
112static	void		  ps_setwidth(struct termp *, int, int);
113static	struct termp	 *pspdf_alloc(const struct manoutput *);
114static	void		  pdf_obj(struct termp *, size_t);
115
116/*
117 * We define, for the time being, three fonts: bold, oblique/italic, and
118 * normal (roman).  The following table hard-codes the font metrics for
119 * ASCII, i.e., 32--127.
120 */
121
122static	const struct font fonts[TERMFONT__MAX] = {
123	{ "Times-Roman", {
124		{ 250 },
125		{ 333 },
126		{ 408 },
127		{ 500 },
128		{ 500 },
129		{ 833 },
130		{ 778 },
131		{ 333 },
132		{ 333 },
133		{ 333 },
134		{ 500 },
135		{ 564 },
136		{ 250 },
137		{ 333 },
138		{ 250 },
139		{ 278 },
140		{ 500 },
141		{ 500 },
142		{ 500 },
143		{ 500 },
144		{ 500 },
145		{ 500 },
146		{ 500 },
147		{ 500 },
148		{ 500 },
149		{ 500 },
150		{ 278 },
151		{ 278 },
152		{ 564 },
153		{ 564 },
154		{ 564 },
155		{ 444 },
156		{ 921 },
157		{ 722 },
158		{ 667 },
159		{ 667 },
160		{ 722 },
161		{ 611 },
162		{ 556 },
163		{ 722 },
164		{ 722 },
165		{ 333 },
166		{ 389 },
167		{ 722 },
168		{ 611 },
169		{ 889 },
170		{ 722 },
171		{ 722 },
172		{ 556 },
173		{ 722 },
174		{ 667 },
175		{ 556 },
176		{ 611 },
177		{ 722 },
178		{ 722 },
179		{ 944 },
180		{ 722 },
181		{ 722 },
182		{ 611 },
183		{ 333 },
184		{ 278 },
185		{ 333 },
186		{ 469 },
187		{ 500 },
188		{ 333 },
189		{ 444 },
190		{ 500 },
191		{ 444 },
192		{  500},
193		{  444},
194		{  333},
195		{  500},
196		{  500},
197		{  278},
198		{  278},
199		{  500},
200		{  278},
201		{  778},
202		{  500},
203		{  500},
204		{  500},
205		{  500},
206		{  333},
207		{  389},
208		{  278},
209		{  500},
210		{  500},
211		{  722},
212		{  500},
213		{  500},
214		{  444},
215		{  480},
216		{  200},
217		{  480},
218		{  541},
219	} },
220	{ "Times-Bold", {
221		{ 250  },
222		{ 333  },
223		{ 555  },
224		{ 500  },
225		{ 500  },
226		{ 1000 },
227		{ 833  },
228		{ 333  },
229		{ 333  },
230		{ 333  },
231		{ 500  },
232		{ 570  },
233		{ 250  },
234		{ 333  },
235		{ 250  },
236		{ 278  },
237		{ 500  },
238		{ 500  },
239		{ 500  },
240		{ 500  },
241		{ 500  },
242		{ 500  },
243		{ 500  },
244		{ 500  },
245		{ 500  },
246		{ 500  },
247		{ 333  },
248		{ 333  },
249		{ 570  },
250		{ 570  },
251		{ 570  },
252		{ 500  },
253		{ 930  },
254		{ 722  },
255		{ 667  },
256		{ 722  },
257		{ 722  },
258		{ 667  },
259		{ 611  },
260		{ 778  },
261		{ 778  },
262		{ 389  },
263		{ 500  },
264		{ 778  },
265		{ 667  },
266		{ 944  },
267		{ 722  },
268		{ 778  },
269		{ 611  },
270		{ 778  },
271		{ 722  },
272		{ 556  },
273		{ 667  },
274		{ 722  },
275		{ 722  },
276		{ 1000 },
277		{ 722  },
278		{ 722  },
279		{ 667  },
280		{ 333  },
281		{ 278  },
282		{ 333  },
283		{ 581  },
284		{ 500  },
285		{ 333  },
286		{ 500  },
287		{ 556  },
288		{ 444  },
289		{  556 },
290		{  444 },
291		{  333 },
292		{  500 },
293		{  556 },
294		{  278 },
295		{  333 },
296		{  556 },
297		{  278 },
298		{  833 },
299		{  556 },
300		{  500 },
301		{  556 },
302		{  556 },
303		{  444 },
304		{  389 },
305		{  333 },
306		{  556 },
307		{  500 },
308		{  722 },
309		{  500 },
310		{  500 },
311		{  444 },
312		{  394 },
313		{  220 },
314		{  394 },
315		{  520 },
316	} },
317	{ "Times-Italic", {
318		{ 250  },
319		{ 333  },
320		{ 420  },
321		{ 500  },
322		{ 500  },
323		{ 833  },
324		{ 778  },
325		{ 333  },
326		{ 333  },
327		{ 333  },
328		{ 500  },
329		{ 675  },
330		{ 250  },
331		{ 333  },
332		{ 250  },
333		{ 278  },
334		{ 500  },
335		{ 500  },
336		{ 500  },
337		{ 500  },
338		{ 500  },
339		{ 500  },
340		{ 500  },
341		{ 500  },
342		{ 500  },
343		{ 500  },
344		{ 333  },
345		{ 333  },
346		{ 675  },
347		{ 675  },
348		{ 675  },
349		{ 500  },
350		{ 920  },
351		{ 611  },
352		{ 611  },
353		{ 667  },
354		{ 722  },
355		{ 611  },
356		{ 611  },
357		{ 722  },
358		{ 722  },
359		{ 333  },
360		{ 444  },
361		{ 667  },
362		{ 556  },
363		{ 833  },
364		{ 667  },
365		{ 722  },
366		{ 611  },
367		{ 722  },
368		{ 611  },
369		{ 500  },
370		{ 556  },
371		{ 722  },
372		{ 611  },
373		{ 833  },
374		{ 611  },
375		{ 556  },
376		{ 556  },
377		{ 389  },
378		{ 278  },
379		{ 389  },
380		{ 422  },
381		{ 500  },
382		{ 333  },
383		{ 500  },
384		{ 500  },
385		{ 444  },
386		{  500 },
387		{  444 },
388		{  278 },
389		{  500 },
390		{  500 },
391		{  278 },
392		{  278 },
393		{  444 },
394		{  278 },
395		{  722 },
396		{  500 },
397		{  500 },
398		{  500 },
399		{  500 },
400		{  389 },
401		{  389 },
402		{  278 },
403		{  500 },
404		{  444 },
405		{  667 },
406		{  444 },
407		{  444 },
408		{  389 },
409		{  400 },
410		{  275 },
411		{  400 },
412		{  541 },
413	} },
414	{ "Times-BoldItalic", {
415		{  250 },
416		{  389 },
417		{  555 },
418		{  500 },
419		{  500 },
420		{  833 },
421		{  778 },
422		{  333 },
423		{  333 },
424		{  333 },
425		{  500 },
426		{  570 },
427		{  250 },
428		{  333 },
429		{  250 },
430		{  278 },
431		{  500 },
432		{  500 },
433		{  500 },
434		{  500 },
435		{  500 },
436		{  500 },
437		{  500 },
438		{  500 },
439		{  500 },
440		{  500 },
441		{  333 },
442		{  333 },
443		{  570 },
444		{  570 },
445		{  570 },
446		{  500 },
447		{  832 },
448		{  667 },
449		{  667 },
450		{  667 },
451		{  722 },
452		{  667 },
453		{  667 },
454		{  722 },
455		{  778 },
456		{  389 },
457		{  500 },
458		{  667 },
459		{  611 },
460		{  889 },
461		{  722 },
462		{  722 },
463		{  611 },
464		{  722 },
465		{  667 },
466		{  556 },
467		{  611 },
468		{  722 },
469		{  667 },
470		{  889 },
471		{  667 },
472		{  611 },
473		{  611 },
474		{  333 },
475		{  278 },
476		{  333 },
477		{  570 },
478		{  500 },
479		{  333 },
480		{  500 },
481		{  500 },
482		{  444 },
483		{  500 },
484		{  444 },
485		{  333 },
486		{  500 },
487		{  556 },
488		{  278 },
489		{  278 },
490		{  500 },
491		{  278 },
492		{  778 },
493		{  556 },
494		{  500 },
495		{  500 },
496		{  500 },
497		{  389 },
498		{  389 },
499		{  278 },
500		{  556 },
501		{  444 },
502		{  667 },
503		{  500 },
504		{  444 },
505		{  389 },
506		{  348 },
507		{  220 },
508		{  348 },
509		{  570 },
510	} },
511};
512
513void *
514pdf_alloc(const struct manoutput *outopts)
515{
516	struct termp	*p;
517
518	if (NULL != (p = pspdf_alloc(outopts)))
519		p->type = TERMTYPE_PDF;
520
521	return p;
522}
523
524void *
525ps_alloc(const struct manoutput *outopts)
526{
527	struct termp	*p;
528
529	if (NULL != (p = pspdf_alloc(outopts)))
530		p->type = TERMTYPE_PS;
531
532	return p;
533}
534
535static struct termp *
536pspdf_alloc(const struct manoutput *outopts)
537{
538	struct termp	*p;
539	unsigned int	 pagex, pagey;
540	size_t		 marginx, marginy, lineheight;
541	const char	*pp;
542
543	p = mandoc_calloc(1, sizeof(struct termp));
544	p->enc = TERMENC_ASCII;
545	p->fontq = mandoc_reallocarray(NULL,
546	    (p->fontsz = 8), sizeof(enum termfont));
547	p->fontq[0] = p->fontl = TERMFONT_NONE;
548	p->ps = mandoc_calloc(1, sizeof(struct termp_ps));
549
550	p->advance = ps_advance;
551	p->begin = ps_begin;
552	p->end = ps_end;
553	p->endline = ps_endline;
554	p->hspan = ps_hspan;
555	p->letter = ps_letter;
556	p->setwidth = ps_setwidth;
557	p->width = ps_width;
558
559	/* Default to US letter (millimetres). */
560
561	pagex = 216;
562	pagey = 279;
563
564	/*
565	 * The ISO-269 paper sizes can be calculated automatically, but
566	 * it would require bringing in -lm for pow() and I'd rather not
567	 * do that.  So just do it the easy way for now.  Since this
568	 * only happens once, I'm not terribly concerned.
569	 */
570
571	pp = outopts->paper;
572	if (pp && strcasecmp(pp, "letter")) {
573		if (0 == strcasecmp(pp, "a3")) {
574			pagex = 297;
575			pagey = 420;
576		} else if (0 == strcasecmp(pp, "a4")) {
577			pagex = 210;
578			pagey = 297;
579		} else if (0 == strcasecmp(pp, "a5")) {
580			pagex = 148;
581			pagey = 210;
582		} else if (0 == strcasecmp(pp, "legal")) {
583			pagex = 216;
584			pagey = 356;
585		} else if (2 != sscanf(pp, "%ux%u", &pagex, &pagey))
586			warnx("%s: Unknown paper", pp);
587	}
588
589	/*
590	 * This MUST be defined before any PNT2AFM or AFM2PNT
591	 * calculations occur.
592	 */
593
594	p->ps->scale = 11;
595
596	/* Remember millimetres -> AFM units. */
597
598	pagex = PNT2AFM(p, ((double)pagex * 2.834));
599	pagey = PNT2AFM(p, ((double)pagey * 2.834));
600
601	/* Margins are 1/9 the page x and y. */
602
603	marginx = (size_t)((double)pagex / 9.0);
604	marginy = (size_t)((double)pagey / 9.0);
605
606	/* Line-height is 1.4em. */
607
608	lineheight = PNT2AFM(p, ((double)p->ps->scale * 1.4));
609
610	p->ps->width = p->ps->lastwidth = (size_t)pagex;
611	p->ps->height = (size_t)pagey;
612	p->ps->header = pagey - (marginy / 2) - (lineheight / 2);
613	p->ps->top = pagey - marginy;
614	p->ps->footer = (marginy / 2) - (lineheight / 2);
615	p->ps->bottom = marginy;
616	p->ps->left = marginx;
617	p->ps->lineheight = lineheight;
618
619	p->defrmargin = pagex - (marginx * 2);
620	return p;
621}
622
623static void
624ps_setwidth(struct termp *p, int iop, int width)
625{
626	size_t	 lastwidth;
627
628	lastwidth = p->ps->width;
629	if (iop > 0)
630		p->ps->width += width;
631	else if (iop == 0)
632		p->ps->width = width ? (size_t)width : p->ps->lastwidth;
633	else if (p->ps->width > (size_t)width)
634		p->ps->width -= width;
635	else
636		p->ps->width = 0;
637	p->ps->lastwidth = lastwidth;
638}
639
640void
641pspdf_free(void *arg)
642{
643	struct termp	*p;
644
645	p = (struct termp *)arg;
646
647	free(p->ps->psmarg);
648	free(p->ps->pdfobjs);
649
650	free(p->ps);
651	term_free(p);
652}
653
654static void
655ps_printf(struct termp *p, const char *fmt, ...)
656{
657	va_list		 ap;
658	int		 pos, len;
659
660	va_start(ap, fmt);
661
662	/*
663	 * If we're running in regular mode, then pipe directly into
664	 * vprintf().  If we're processing margins, then push the data
665	 * into our growable margin buffer.
666	 */
667
668	if ( ! (PS_MARGINS & p->ps->flags)) {
669		len = vprintf(fmt, ap);
670		va_end(ap);
671		p->ps->pdfbytes += len < 0 ? 0 : (size_t)len;
672		return;
673	}
674
675	/*
676	 * XXX: I assume that the in-margin print won't exceed
677	 * PS_BUFSLOP (128 bytes), which is reasonable but still an
678	 * assumption that will cause pukeage if it's not the case.
679	 */
680
681	ps_growbuf(p, PS_BUFSLOP);
682
683	pos = (int)p->ps->psmargcur;
684	vsnprintf(&p->ps->psmarg[pos], PS_BUFSLOP, fmt, ap);
685
686	va_end(ap);
687
688	p->ps->psmargcur = strlen(p->ps->psmarg);
689}
690
691static void
692ps_putchar(struct termp *p, char c)
693{
694	int		 pos;
695
696	/* See ps_printf(). */
697
698	if ( ! (PS_MARGINS & p->ps->flags)) {
699		putchar(c);
700		p->ps->pdfbytes++;
701		return;
702	}
703
704	ps_growbuf(p, 2);
705
706	pos = (int)p->ps->psmargcur++;
707	p->ps->psmarg[pos++] = c;
708	p->ps->psmarg[pos] = '\0';
709}
710
711static void
712pdf_obj(struct termp *p, size_t obj)
713{
714
715	assert(obj > 0);
716
717	if ((obj - 1) >= p->ps->pdfobjsz) {
718		p->ps->pdfobjsz = obj + 128;
719		p->ps->pdfobjs = mandoc_reallocarray(p->ps->pdfobjs,
720		    p->ps->pdfobjsz, sizeof(size_t));
721	}
722
723	p->ps->pdfobjs[(int)obj - 1] = p->ps->pdfbytes;
724	ps_printf(p, "%zu 0 obj\n", obj);
725}
726
727static void
728ps_closepage(struct termp *p)
729{
730	int		 i;
731	size_t		 len, base;
732
733	/*
734	 * Close out a page that we've already flushed to output.  In
735	 * PostScript, we simply note that the page must be showed.  In
736	 * PDF, we must now create the Length, Resource, and Page node
737	 * for the page contents.
738	 */
739
740	assert(p->ps->psmarg && p->ps->psmarg[0]);
741	ps_printf(p, "%s", p->ps->psmarg);
742
743	if (TERMTYPE_PS != p->type) {
744		ps_printf(p, "ET\n");
745
746		len = p->ps->pdfbytes - p->ps->pdflastpg;
747		base = p->ps->pages * 4 + p->ps->pdfbody;
748
749		ps_printf(p, "endstream\nendobj\n");
750
751		/* Length of content. */
752		pdf_obj(p, base + 1);
753		ps_printf(p, "%zu\nendobj\n", len);
754
755		/* Resource for content. */
756		pdf_obj(p, base + 2);
757		ps_printf(p, "<<\n/ProcSet [/PDF /Text]\n");
758		ps_printf(p, "/Font <<\n");
759		for (i = 0; i < (int)TERMFONT__MAX; i++)
760			ps_printf(p, "/F%d %d 0 R\n", i, 3 + i);
761		ps_printf(p, ">>\n>>\n");
762
763		/* Page node. */
764		pdf_obj(p, base + 3);
765		ps_printf(p, "<<\n");
766		ps_printf(p, "/Type /Page\n");
767		ps_printf(p, "/Parent 2 0 R\n");
768		ps_printf(p, "/Resources %zu 0 R\n", base + 2);
769		ps_printf(p, "/Contents %zu 0 R\n", base);
770		ps_printf(p, ">>\nendobj\n");
771	} else
772		ps_printf(p, "showpage\n");
773
774	p->ps->pages++;
775	p->ps->psrow = p->ps->top;
776	assert( ! (PS_NEWPAGE & p->ps->flags));
777	p->ps->flags |= PS_NEWPAGE;
778}
779
780static void
781ps_end(struct termp *p)
782{
783	size_t		 i, xref, base;
784
785	/*
786	 * At the end of the file, do one last showpage.  This is the
787	 * same behaviour as groff(1) and works for multiple pages as
788	 * well as just one.
789	 */
790
791	if ( ! (PS_NEWPAGE & p->ps->flags)) {
792		assert(0 == p->ps->flags);
793		assert('\0' == p->ps->last);
794		ps_closepage(p);
795	}
796
797	if (TERMTYPE_PS == p->type) {
798		ps_printf(p, "%%%%Trailer\n");
799		ps_printf(p, "%%%%Pages: %zu\n", p->ps->pages);
800		ps_printf(p, "%%%%EOF\n");
801		return;
802	}
803
804	pdf_obj(p, 2);
805	ps_printf(p, "<<\n/Type /Pages\n");
806	ps_printf(p, "/MediaBox [0 0 %zu %zu]\n",
807			(size_t)AFM2PNT(p, p->ps->width),
808			(size_t)AFM2PNT(p, p->ps->height));
809
810	ps_printf(p, "/Count %zu\n", p->ps->pages);
811	ps_printf(p, "/Kids [");
812
813	for (i = 0; i < p->ps->pages; i++)
814		ps_printf(p, " %zu 0 R", i * 4 + p->ps->pdfbody + 3);
815
816	base = (p->ps->pages - 1) * 4 + p->ps->pdfbody + 4;
817
818	ps_printf(p, "]\n>>\nendobj\n");
819	pdf_obj(p, base);
820	ps_printf(p, "<<\n");
821	ps_printf(p, "/Type /Catalog\n");
822	ps_printf(p, "/Pages 2 0 R\n");
823	ps_printf(p, ">>\n");
824	xref = p->ps->pdfbytes;
825	ps_printf(p, "xref\n");
826	ps_printf(p, "0 %zu\n", base + 1);
827	ps_printf(p, "0000000000 65535 f \n");
828
829	for (i = 0; i < base; i++)
830		ps_printf(p, "%.10zu 00000 n \n",
831		    p->ps->pdfobjs[(int)i]);
832
833	ps_printf(p, "trailer\n");
834	ps_printf(p, "<<\n");
835	ps_printf(p, "/Size %zu\n", base + 1);
836	ps_printf(p, "/Root %zu 0 R\n", base);
837	ps_printf(p, "/Info 1 0 R\n");
838	ps_printf(p, ">>\n");
839	ps_printf(p, "startxref\n");
840	ps_printf(p, "%zu\n", xref);
841	ps_printf(p, "%%%%EOF\n");
842}
843
844static void
845ps_begin(struct termp *p)
846{
847	int		 i;
848
849	/*
850	 * Print margins into margin buffer.  Nothing gets output to the
851	 * screen yet, so we don't need to initialise the primary state.
852	 */
853
854	if (p->ps->psmarg) {
855		assert(p->ps->psmargsz);
856		p->ps->psmarg[0] = '\0';
857	}
858
859	/*p->ps->pdfbytes = 0;*/
860	p->ps->psmargcur = 0;
861	p->ps->flags = PS_MARGINS;
862	p->ps->pscol = p->ps->left;
863	p->ps->psrow = p->ps->header;
864
865	ps_setfont(p, TERMFONT_NONE);
866
867	(*p->headf)(p, p->argf);
868	(*p->endline)(p);
869
870	p->ps->pscol = p->ps->left;
871	p->ps->psrow = p->ps->footer;
872
873	(*p->footf)(p, p->argf);
874	(*p->endline)(p);
875
876	p->ps->flags &= ~PS_MARGINS;
877
878	assert(0 == p->ps->flags);
879	assert(p->ps->psmarg);
880	assert('\0' != p->ps->psmarg[0]);
881
882	/*
883	 * Print header and initialise page state.  Following this,
884	 * stuff gets printed to the screen, so make sure we're sane.
885	 */
886
887	if (TERMTYPE_PS == p->type) {
888		ps_printf(p, "%%!PS-Adobe-3.0\n");
889		ps_printf(p, "%%%%DocumentData: Clean7Bit\n");
890		ps_printf(p, "%%%%Orientation: Portrait\n");
891		ps_printf(p, "%%%%Pages: (atend)\n");
892		ps_printf(p, "%%%%PageOrder: Ascend\n");
893		ps_printf(p, "%%%%DocumentMedia: "
894		    "Default %zu %zu 0 () ()\n",
895		    (size_t)AFM2PNT(p, p->ps->width),
896		    (size_t)AFM2PNT(p, p->ps->height));
897		ps_printf(p, "%%%%DocumentNeededResources: font");
898
899		for (i = 0; i < (int)TERMFONT__MAX; i++)
900			ps_printf(p, " %s", fonts[i].name);
901
902		ps_printf(p, "\n%%%%EndComments\n");
903	} else {
904		ps_printf(p, "%%PDF-1.1\n");
905		pdf_obj(p, 1);
906		ps_printf(p, "<<\n");
907		ps_printf(p, ">>\n");
908		ps_printf(p, "endobj\n");
909
910		for (i = 0; i < (int)TERMFONT__MAX; i++) {
911			pdf_obj(p, (size_t)i + 3);
912			ps_printf(p, "<<\n");
913			ps_printf(p, "/Type /Font\n");
914			ps_printf(p, "/Subtype /Type1\n");
915			ps_printf(p, "/Name /F%d\n", i);
916			ps_printf(p, "/BaseFont /%s\n", fonts[i].name);
917			ps_printf(p, ">>\n");
918		}
919	}
920
921	p->ps->pdfbody = (size_t)TERMFONT__MAX + 3;
922	p->ps->pscol = p->ps->left;
923	p->ps->psrow = p->ps->top;
924	p->ps->flags |= PS_NEWPAGE;
925	ps_setfont(p, TERMFONT_NONE);
926}
927
928static void
929ps_pletter(struct termp *p, int c)
930{
931	int		 f;
932
933	/*
934	 * If we haven't opened a page context, then output that we're
935	 * in a new page and make sure the font is correctly set.
936	 */
937
938	if (PS_NEWPAGE & p->ps->flags) {
939		if (TERMTYPE_PS == p->type) {
940			ps_printf(p, "%%%%Page: %zu %zu\n",
941			    p->ps->pages + 1, p->ps->pages + 1);
942			ps_printf(p, "/%s %zu selectfont\n",
943			    fonts[(int)p->ps->lastf].name,
944			    p->ps->scale);
945		} else {
946			pdf_obj(p, p->ps->pdfbody +
947			    p->ps->pages * 4);
948			ps_printf(p, "<<\n");
949			ps_printf(p, "/Length %zu 0 R\n",
950			    p->ps->pdfbody + 1 + p->ps->pages * 4);
951			ps_printf(p, ">>\nstream\n");
952		}
953		p->ps->pdflastpg = p->ps->pdfbytes;
954		p->ps->flags &= ~PS_NEWPAGE;
955	}
956
957	/*
958	 * If we're not in a PostScript "word" context, then open one
959	 * now at the current cursor.
960	 */
961
962	if ( ! (PS_INLINE & p->ps->flags)) {
963		if (TERMTYPE_PS != p->type) {
964			ps_printf(p, "BT\n/F%d %zu Tf\n",
965			    (int)p->ps->lastf, p->ps->scale);
966			ps_printf(p, "%.3f %.3f Td\n(",
967			    AFM2PNT(p, p->ps->pscol),
968			    AFM2PNT(p, p->ps->psrow));
969		} else
970			ps_printf(p, "%.3f %.3f moveto\n(",
971			    AFM2PNT(p, p->ps->pscol),
972			    AFM2PNT(p, p->ps->psrow));
973		p->ps->flags |= PS_INLINE;
974	}
975
976	assert( ! (PS_NEWPAGE & p->ps->flags));
977
978	/*
979	 * We need to escape these characters as per the PostScript
980	 * specification.  We would also escape non-graphable characters
981	 * (like tabs), but none of them would get to this point and
982	 * it's superfluous to abort() on them.
983	 */
984
985	switch (c) {
986	case '(':
987	case ')':
988	case '\\':
989		ps_putchar(p, '\\');
990		break;
991	default:
992		break;
993	}
994
995	/* Write the character and adjust where we are on the page. */
996
997	f = (int)p->ps->lastf;
998
999	if (c <= 32 || c - 32 >= MAXCHAR)
1000		c = 32;
1001
1002	ps_putchar(p, (char)c);
1003	c -= 32;
1004	p->ps->pscol += (size_t)fonts[f].gly[c].wx;
1005}
1006
1007static void
1008ps_pclose(struct termp *p)
1009{
1010
1011	/*
1012	 * Spit out that we're exiting a word context (this is a
1013	 * "partial close" because we don't check the last-char buffer
1014	 * or anything).
1015	 */
1016
1017	if ( ! (PS_INLINE & p->ps->flags))
1018		return;
1019
1020	if (TERMTYPE_PS != p->type) {
1021		ps_printf(p, ") Tj\nET\n");
1022	} else
1023		ps_printf(p, ") show\n");
1024
1025	p->ps->flags &= ~PS_INLINE;
1026}
1027
1028static void
1029ps_fclose(struct termp *p)
1030{
1031
1032	/*
1033	 * Strong closure: if we have a last-char, spit it out after
1034	 * checking that we're in the right font mode.  This will of
1035	 * course open a new scope, if applicable.
1036	 *
1037	 * Following this, close out any scope that's open.
1038	 */
1039
1040	if (p->ps->last != '\0') {
1041		assert( ! (p->ps->flags & PS_BACKSP));
1042		if (p->ps->nextf != p->ps->lastf) {
1043			ps_pclose(p);
1044			ps_setfont(p, p->ps->nextf);
1045		}
1046		p->ps->nextf = TERMFONT_NONE;
1047		ps_pletter(p, p->ps->last);
1048		p->ps->last = '\0';
1049	}
1050
1051	if ( ! (PS_INLINE & p->ps->flags))
1052		return;
1053
1054	ps_pclose(p);
1055}
1056
1057static void
1058ps_letter(struct termp *p, int arg)
1059{
1060	size_t		savecol, wx;
1061	char		c;
1062
1063	c = arg >= 128 || arg <= 0 ? '?' : arg;
1064
1065	/*
1066	 * When receiving a backspace, merely flag it.
1067	 * We don't know yet whether it is
1068	 * a font instruction or an overstrike.
1069	 */
1070
1071	if (c == '\b') {
1072		assert(p->ps->last != '\0');
1073		assert( ! (p->ps->flags & PS_BACKSP));
1074		p->ps->flags |= PS_BACKSP;
1075		return;
1076	}
1077
1078	/*
1079	 * Decode font instructions.
1080	 */
1081
1082	if (p->ps->flags & PS_BACKSP) {
1083		if (p->ps->last == '_') {
1084			switch (p->ps->nextf) {
1085			case TERMFONT_BI:
1086				break;
1087			case TERMFONT_BOLD:
1088				p->ps->nextf = TERMFONT_BI;
1089				break;
1090			default:
1091				p->ps->nextf = TERMFONT_UNDER;
1092			}
1093			p->ps->last = c;
1094			p->ps->flags &= ~PS_BACKSP;
1095			return;
1096		}
1097		if (p->ps->last == c) {
1098			switch (p->ps->nextf) {
1099			case TERMFONT_BI:
1100				break;
1101			case TERMFONT_UNDER:
1102				p->ps->nextf = TERMFONT_BI;
1103				break;
1104			default:
1105				p->ps->nextf = TERMFONT_BOLD;
1106			}
1107			p->ps->flags &= ~PS_BACKSP;
1108			return;
1109		}
1110
1111		/*
1112		 * This is not a font instruction, but rather
1113		 * the next character.  Prepare for overstrike.
1114		 */
1115
1116		savecol = p->ps->pscol;
1117	} else
1118		savecol = SIZE_MAX;
1119
1120	/*
1121	 * We found the next character, so the font instructions
1122	 * for the previous one are complete.
1123	 * Use them and print it.
1124	 */
1125
1126	if (p->ps->last != '\0') {
1127		if (p->ps->nextf != p->ps->lastf) {
1128			ps_pclose(p);
1129			ps_setfont(p, p->ps->nextf);
1130		}
1131		p->ps->nextf = TERMFONT_NONE;
1132
1133		/*
1134		 * For an overstrike, if a previous character
1135		 * was wider, advance to center the new one.
1136		 */
1137
1138		if (p->ps->pscolnext) {
1139			wx = fonts[p->ps->lastf].gly[(int)p->ps->last-32].wx;
1140			if (p->ps->pscol + wx < p->ps->pscolnext)
1141				p->ps->pscol = (p->ps->pscol +
1142				    p->ps->pscolnext - wx) / 2;
1143		}
1144
1145		ps_pletter(p, p->ps->last);
1146
1147		/*
1148		 * For an overstrike, if a previous character
1149		 * was wider, advance to the end of the old one.
1150		 */
1151
1152		if (p->ps->pscol < p->ps->pscolnext) {
1153			ps_pclose(p);
1154			p->ps->pscol = p->ps->pscolnext;
1155		}
1156	}
1157
1158	/*
1159	 * Do not print the current character yet because font
1160	 * instructions might follow; only remember it.
1161	 * For the first character, nothing else is done.
1162	 * The final character will get printed from ps_fclose().
1163	 */
1164
1165	p->ps->last = c;
1166
1167	/*
1168	 * For an overstrike, back up to the previous position.
1169	 * If the previous character is wider than any it overstrikes,
1170	 * remember the current position, because it might also be
1171	 * wider than all that will overstrike it.
1172	 */
1173
1174	if (savecol != SIZE_MAX) {
1175		if (p->ps->pscolnext < p->ps->pscol)
1176			p->ps->pscolnext = p->ps->pscol;
1177		ps_pclose(p);
1178		p->ps->pscol = savecol;
1179		p->ps->flags &= ~PS_BACKSP;
1180	} else
1181		p->ps->pscolnext = 0;
1182}
1183
1184static void
1185ps_advance(struct termp *p, size_t len)
1186{
1187
1188	/*
1189	 * Advance some spaces.  This can probably be made smarter,
1190	 * i.e., to have multiple space-separated words in the same
1191	 * scope, but this is easier:  just close out the current scope
1192	 * and readjust our column settings.
1193	 */
1194
1195	ps_fclose(p);
1196	p->ps->pscol += len;
1197}
1198
1199static void
1200ps_endline(struct termp *p)
1201{
1202
1203	/* Close out any scopes we have open: we're at eoln. */
1204
1205	ps_fclose(p);
1206
1207	/*
1208	 * If we're in the margin, don't try to recalculate our current
1209	 * row.  XXX: if the column tries to be fancy with multiple
1210	 * lines, we'll do nasty stuff.
1211	 */
1212
1213	if (PS_MARGINS & p->ps->flags)
1214		return;
1215
1216	/* Left-justify. */
1217
1218	p->ps->pscol = p->ps->left;
1219
1220	/* If we haven't printed anything, return. */
1221
1222	if (PS_NEWPAGE & p->ps->flags)
1223		return;
1224
1225	/*
1226	 * Put us down a line.  If we're at the page bottom, spit out a
1227	 * showpage and restart our row.
1228	 */
1229
1230	if (p->ps->psrow >= p->ps->lineheight + p->ps->bottom) {
1231		p->ps->psrow -= p->ps->lineheight;
1232		return;
1233	}
1234
1235	ps_closepage(p);
1236}
1237
1238static void
1239ps_setfont(struct termp *p, enum termfont f)
1240{
1241
1242	assert(f < TERMFONT__MAX);
1243	p->ps->lastf = f;
1244
1245	/*
1246	 * If we're still at the top of the page, let the font-setting
1247	 * be delayed until we actually have stuff to print.
1248	 */
1249
1250	if (PS_NEWPAGE & p->ps->flags)
1251		return;
1252
1253	if (TERMTYPE_PS == p->type)
1254		ps_printf(p, "/%s %zu selectfont\n",
1255		    fonts[(int)f].name, p->ps->scale);
1256	else
1257		ps_printf(p, "/F%d %zu Tf\n",
1258		    (int)f, p->ps->scale);
1259}
1260
1261static size_t
1262ps_width(const struct termp *p, int c)
1263{
1264
1265	if (c <= 32 || c - 32 >= MAXCHAR)
1266		c = 0;
1267	else
1268		c -= 32;
1269
1270	return (size_t)fonts[(int)TERMFONT_NONE].gly[c].wx;
1271}
1272
1273static int
1274ps_hspan(const struct termp *p, const struct roffsu *su)
1275{
1276	double		 r;
1277
1278	/*
1279	 * All of these measurements are derived by converting from the
1280	 * native measurement to AFM units.
1281	 */
1282	switch (su->unit) {
1283	case SCALE_BU:
1284		/*
1285		 * Traditionally, the default unit is fixed to the
1286		 * output media.  So this would refer to the point.  In
1287		 * mandoc(1), however, we stick to the default terminal
1288		 * scaling unit so that output is the same regardless
1289		 * the media.
1290		 */
1291		r = PNT2AFM(p, su->scale * 72.0 / 240.0);
1292		break;
1293	case SCALE_CM:
1294		r = PNT2AFM(p, su->scale * 72.0 / 2.54);
1295		break;
1296	case SCALE_EM:
1297		r = su->scale *
1298		    fonts[(int)TERMFONT_NONE].gly[109 - 32].wx;
1299		break;
1300	case SCALE_EN:
1301		r = su->scale *
1302		    fonts[(int)TERMFONT_NONE].gly[110 - 32].wx;
1303		break;
1304	case SCALE_IN:
1305		r = PNT2AFM(p, su->scale * 72.0);
1306		break;
1307	case SCALE_MM:
1308		r = su->scale *
1309		    fonts[(int)TERMFONT_NONE].gly[109 - 32].wx / 100.0;
1310		break;
1311	case SCALE_PC:
1312		r = PNT2AFM(p, su->scale * 12.0);
1313		break;
1314	case SCALE_PT:
1315		r = PNT2AFM(p, su->scale * 1.0);
1316		break;
1317	case SCALE_VS:
1318		r = su->scale * p->ps->lineheight;
1319		break;
1320	default:
1321		r = su->scale;
1322		break;
1323	}
1324
1325	return r * 24.0;
1326}
1327
1328static void
1329ps_growbuf(struct termp *p, size_t sz)
1330{
1331	if (p->ps->psmargcur + sz <= p->ps->psmargsz)
1332		return;
1333
1334	if (sz < PS_BUFSLOP)
1335		sz = PS_BUFSLOP;
1336
1337	p->ps->psmargsz += sz;
1338	p->ps->psmarg = mandoc_realloc(p->ps->psmarg, p->ps->psmargsz);
1339}
1340