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