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