]>
git.cameronkatri.com Git - mandoc.git/blob - term_ps.c
1 /* $Id: term_ps.c,v 1.50 2011/05/15 00:58:48 kristaps Exp $ */
3 * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv>
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.
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.
21 #include <sys/types.h>
37 /* These work the buffer used by the header and footer. */
38 #define PS_BUFSLOP 128
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))
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))
49 unsigned short wx
; /* WX in AFM */
53 const char *name
; /* FontName in AFM */
54 #define MAXCHAR 95 /* total characters we can handle */
55 struct glyph gly
[MAXCHAR
]; /* glyph metrics */
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 */
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);
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.
112 static const struct font fonts
[TERMFONT__MAX
] = {
407 pdf_alloc(char *outopts
)
411 if (NULL
!= (p
= pspdf_alloc(outopts
)))
412 p
->type
= TERMTYPE_PDF
;
418 ps_alloc(char *outopts
)
422 if (NULL
!= (p
= pspdf_alloc(outopts
)))
423 p
->type
= TERMTYPE_PS
;
428 static struct termp
*
429 pspdf_alloc(char *outopts
)
432 size_t pagex
, pagey
, marginx
, marginy
, lineheight
;
437 p
= term_alloc(TERMENC_ASCII
);
438 p
->ps
= mandoc_calloc(1, sizeof(struct termp_ps
));
440 p
->advance
= ps_advance
;
443 p
->endline
= ps_endline
;
445 p
->letter
= ps_letter
;
453 while (outopts
&& *outopts
)
454 switch (getsubopt(&outopts
, UNCONST(toks
), &v
)) {
462 /* Default to US letter (millimetres). */
468 * The ISO-269 paper sizes can be calculated automatically, but
469 * it would require bringing in -lm for pow() and I'd rather not
470 * do that. So just do it the easy way for now. Since this
471 * only happens once, I'm not terribly concerned.
474 if (pp
&& strcasecmp(pp
, "letter")) {
475 if (0 == strcasecmp(pp
, "a3")) {
478 } else if (0 == strcasecmp(pp
, "a4")) {
481 } else if (0 == strcasecmp(pp
, "a5")) {
484 } else if (0 == strcasecmp(pp
, "legal")) {
487 } else if (2 != sscanf(pp
, "%zux%zu", &pagex
, &pagey
))
488 fprintf(stderr
, "%s: Unknown paper\n", pp
);
489 } else if (NULL
== pp
)
493 * This MUST be defined before any PNT2AFM or AFM2PNT
494 * calculations occur.
499 /* Remember millimetres -> AFM units. */
501 pagex
= PNT2AFM(p
, ((double)pagex
* 2.834));
502 pagey
= PNT2AFM(p
, ((double)pagey
* 2.834));
504 /* Margins are 1/9 the page x and y. */
506 marginx
= /* LINTED */
507 (size_t)((double)pagex
/ 9.0);
508 marginy
= /* LINTED */
509 (size_t)((double)pagey
/ 9.0);
511 /* Line-height is 1.4em. */
513 lineheight
= PNT2AFM(p
, ((double)p
->ps
->scale
* 1.4));
515 p
->ps
->width
= pagex
;
516 p
->ps
->height
= pagey
;
517 p
->ps
->header
= pagey
- (marginy
/ 2) - (lineheight
/ 2);
518 p
->ps
->top
= pagey
- marginy
;
519 p
->ps
->footer
= (marginy
/ 2) - (lineheight
/ 2);
520 p
->ps
->bottom
= marginy
;
521 p
->ps
->left
= marginx
;
522 p
->ps
->lineheight
= lineheight
;
524 p
->defrmargin
= pagex
- (marginx
* 2);
530 pspdf_free(void *arg
)
534 p
= (struct termp
*)arg
;
539 free(p
->ps
->pdfobjs
);
547 ps_printf(struct termp
*p
, const char *fmt
, ...)
555 * If we're running in regular mode, then pipe directly into
556 * vprintf(). If we're processing margins, then push the data
557 * into our growable margin buffer.
560 if ( ! (PS_MARGINS
& p
->ps
->flags
)) {
561 len
= vprintf(fmt
, ap
);
563 p
->ps
->pdfbytes
+= /* LINTED */
564 len
< 0 ? 0 : (size_t)len
;
569 * XXX: I assume that the in-margin print won't exceed
570 * PS_BUFSLOP (128 bytes), which is reasonable but still an
571 * assumption that will cause pukeage if it's not the case.
574 ps_growbuf(p
, PS_BUFSLOP
);
576 pos
= (int)p
->ps
->psmargcur
;
577 len
= vsnprintf(&p
->ps
->psmarg
[pos
], PS_BUFSLOP
, fmt
, ap
);
581 p
->ps
->psmargcur
= strlen(p
->ps
->psmarg
);
586 ps_putchar(struct termp
*p
, char c
)
590 /* See ps_printf(). */
592 if ( ! (PS_MARGINS
& p
->ps
->flags
)) {
601 pos
= (int)p
->ps
->psmargcur
++;
602 p
->ps
->psmarg
[pos
++] = c
;
603 p
->ps
->psmarg
[pos
] = '\0';
608 pdf_obj(struct termp
*p
, size_t obj
)
613 if ((obj
- 1) >= p
->ps
->pdfobjsz
) {
614 p
->ps
->pdfobjsz
= obj
+ 128;
615 p
->ps
->pdfobjs
= realloc
617 p
->ps
->pdfobjsz
* sizeof(size_t));
618 if (NULL
== p
->ps
->pdfobjs
) {
620 exit((int)MANDOCLEVEL_SYSERR
);
624 p
->ps
->pdfobjs
[(int)obj
- 1] = p
->ps
->pdfbytes
;
625 ps_printf(p
, "%zu 0 obj\n", obj
);
630 ps_closepage(struct termp
*p
)
636 * Close out a page that we've already flushed to output. In
637 * PostScript, we simply note that the page must be showed. In
638 * PDF, we must now create the Length, Resource, and Page node
639 * for the page contents.
642 assert(p
->ps
->psmarg
&& p
->ps
->psmarg
[0]);
643 ps_printf(p
, "%s", p
->ps
->psmarg
);
645 if (TERMTYPE_PS
!= p
->type
) {
646 ps_printf(p
, "ET\n");
648 len
= p
->ps
->pdfbytes
- p
->ps
->pdflastpg
;
649 base
= p
->ps
->pages
* 4 + p
->ps
->pdfbody
;
651 ps_printf(p
, "endstream\nendobj\n");
653 /* Length of content. */
654 pdf_obj(p
, base
+ 1);
655 ps_printf(p
, "%zu\nendobj\n", len
);
657 /* Resource for content. */
658 pdf_obj(p
, base
+ 2);
659 ps_printf(p
, "<<\n/ProcSet [/PDF /Text]\n");
660 ps_printf(p
, "/Font <<\n");
661 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++)
662 ps_printf(p
, "/F%d %d 0 R\n", i
, 3 + i
);
663 ps_printf(p
, ">>\n>>\n");
666 pdf_obj(p
, base
+ 3);
667 ps_printf(p
, "<<\n");
668 ps_printf(p
, "/Type /Page\n");
669 ps_printf(p
, "/Parent 2 0 R\n");
670 ps_printf(p
, "/Resources %zu 0 R\n", base
+ 2);
671 ps_printf(p
, "/Contents %zu 0 R\n", base
);
672 ps_printf(p
, ">>\nendobj\n");
674 ps_printf(p
, "showpage\n");
677 p
->ps
->psrow
= p
->ps
->top
;
678 assert( ! (PS_NEWPAGE
& p
->ps
->flags
));
679 p
->ps
->flags
|= PS_NEWPAGE
;
685 ps_end(struct termp
*p
)
687 size_t i
, xref
, base
;
690 * At the end of the file, do one last showpage. This is the
691 * same behaviour as groff(1) and works for multiple pages as
695 if ( ! (PS_NEWPAGE
& p
->ps
->flags
)) {
696 assert(0 == p
->ps
->flags
);
697 assert('\0' == p
->ps
->last
);
701 if (TERMTYPE_PS
== p
->type
) {
702 ps_printf(p
, "%%%%Trailer\n");
703 ps_printf(p
, "%%%%Pages: %zu\n", p
->ps
->pages
);
704 ps_printf(p
, "%%%%EOF\n");
709 ps_printf(p
, "<<\n/Type /Pages\n");
710 ps_printf(p
, "/MediaBox [0 0 %zu %zu]\n",
711 (size_t)AFM2PNT(p
, p
->ps
->width
),
712 (size_t)AFM2PNT(p
, p
->ps
->height
));
714 ps_printf(p
, "/Count %zu\n", p
->ps
->pages
);
715 ps_printf(p
, "/Kids [");
717 for (i
= 0; i
< p
->ps
->pages
; i
++)
718 ps_printf(p
, " %zu 0 R", i
* 4 +
721 base
= (p
->ps
->pages
- 1) * 4 +
724 ps_printf(p
, "]\n>>\nendobj\n");
726 ps_printf(p
, "<<\n");
727 ps_printf(p
, "/Type /Catalog\n");
728 ps_printf(p
, "/Pages 2 0 R\n");
729 ps_printf(p
, ">>\n");
730 xref
= p
->ps
->pdfbytes
;
731 ps_printf(p
, "xref\n");
732 ps_printf(p
, "0 %zu\n", base
+ 1);
733 ps_printf(p
, "0000000000 65535 f \n");
735 for (i
= 0; i
< base
; i
++)
736 ps_printf(p
, "%.10zu 00000 n \n",
737 p
->ps
->pdfobjs
[(int)i
]);
739 ps_printf(p
, "trailer\n");
740 ps_printf(p
, "<<\n");
741 ps_printf(p
, "/Size %zu\n", base
+ 1);
742 ps_printf(p
, "/Root %zu 0 R\n", base
);
743 ps_printf(p
, "/Info 1 0 R\n");
744 ps_printf(p
, ">>\n");
745 ps_printf(p
, "startxref\n");
746 ps_printf(p
, "%zu\n", xref
);
747 ps_printf(p
, "%%%%EOF\n");
752 ps_begin(struct termp
*p
)
758 * Print margins into margin buffer. Nothing gets output to the
759 * screen yet, so we don't need to initialise the primary state.
763 assert(p
->ps
->psmargsz
);
764 p
->ps
->psmarg
[0] = '\0';
767 /*p->ps->pdfbytes = 0;*/
768 p
->ps
->psmargcur
= 0;
769 p
->ps
->flags
= PS_MARGINS
;
770 p
->ps
->pscol
= p
->ps
->left
;
771 p
->ps
->psrow
= p
->ps
->header
;
773 ps_setfont(p
, TERMFONT_NONE
);
775 (*p
->headf
)(p
, p
->argf
);
778 p
->ps
->pscol
= p
->ps
->left
;
779 p
->ps
->psrow
= p
->ps
->footer
;
781 (*p
->footf
)(p
, p
->argf
);
784 p
->ps
->flags
&= ~PS_MARGINS
;
786 assert(0 == p
->ps
->flags
);
787 assert(p
->ps
->psmarg
);
788 assert('\0' != p
->ps
->psmarg
[0]);
791 * Print header and initialise page state. Following this,
792 * stuff gets printed to the screen, so make sure we're sane.
797 if (TERMTYPE_PS
== p
->type
) {
798 ps_printf(p
, "%%!PS-Adobe-3.0\n");
799 ps_printf(p
, "%%%%CreationDate: %s", ctime(&t
));
800 ps_printf(p
, "%%%%DocumentData: Clean7Bit\n");
801 ps_printf(p
, "%%%%Orientation: Portrait\n");
802 ps_printf(p
, "%%%%Pages: (atend)\n");
803 ps_printf(p
, "%%%%PageOrder: Ascend\n");
804 ps_printf(p
, "%%%%DocumentMedia: "
805 "Default %zu %zu 0 () ()\n",
806 (size_t)AFM2PNT(p
, p
->ps
->width
),
807 (size_t)AFM2PNT(p
, p
->ps
->height
));
808 ps_printf(p
, "%%%%DocumentNeededResources: font");
810 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++)
811 ps_printf(p
, " %s", fonts
[i
].name
);
813 ps_printf(p
, "\n%%%%EndComments\n");
815 ps_printf(p
, "%%PDF-1.1\n");
817 ps_printf(p
, "<<\n");
818 ps_printf(p
, ">>\n");
819 ps_printf(p
, "endobj\n");
821 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++) {
822 pdf_obj(p
, (size_t)i
+ 3);
823 ps_printf(p
, "<<\n");
824 ps_printf(p
, "/Type /Font\n");
825 ps_printf(p
, "/Subtype /Type1\n");
826 ps_printf(p
, "/Name /F%zu\n", i
);
827 ps_printf(p
, "/BaseFont /%s\n", fonts
[i
].name
);
828 ps_printf(p
, ">>\n");
832 p
->ps
->pdfbody
= (size_t)TERMFONT__MAX
+ 3;
833 p
->ps
->pscol
= p
->ps
->left
;
834 p
->ps
->psrow
= p
->ps
->top
;
835 p
->ps
->flags
|= PS_NEWPAGE
;
836 ps_setfont(p
, TERMFONT_NONE
);
841 ps_pletter(struct termp
*p
, int c
)
846 * If we haven't opened a page context, then output that we're
847 * in a new page and make sure the font is correctly set.
850 if (PS_NEWPAGE
& p
->ps
->flags
) {
851 if (TERMTYPE_PS
== p
->type
) {
852 ps_printf(p
, "%%%%Page: %zu %zu\n",
855 ps_printf(p
, "/%s %zu selectfont\n",
856 fonts
[(int)p
->ps
->lastf
].name
,
859 pdf_obj(p
, p
->ps
->pdfbody
+
861 ps_printf(p
, "<<\n");
862 ps_printf(p
, "/Length %zu 0 R\n",
865 ps_printf(p
, ">>\nstream\n");
867 p
->ps
->pdflastpg
= p
->ps
->pdfbytes
;
868 p
->ps
->flags
&= ~PS_NEWPAGE
;
872 * If we're not in a PostScript "word" context, then open one
873 * now at the current cursor.
876 if ( ! (PS_INLINE
& p
->ps
->flags
)) {
877 if (TERMTYPE_PS
!= p
->type
) {
878 ps_printf(p
, "BT\n/F%d %zu Tf\n",
881 ps_printf(p
, "%.3f %.3f Td\n(",
882 AFM2PNT(p
, p
->ps
->pscol
),
883 AFM2PNT(p
, p
->ps
->psrow
));
885 ps_printf(p
, "%.3f %.3f moveto\n(",
886 AFM2PNT(p
, p
->ps
->pscol
),
887 AFM2PNT(p
, p
->ps
->psrow
));
888 p
->ps
->flags
|= PS_INLINE
;
891 assert( ! (PS_NEWPAGE
& p
->ps
->flags
));
894 * We need to escape these characters as per the PostScript
895 * specification. We would also escape non-graphable characters
896 * (like tabs), but none of them would get to this point and
897 * it's superfluous to abort() on them.
912 /* Write the character and adjust where we are on the page. */
914 f
= (int)p
->ps
->lastf
;
916 if (c
<= 32 || (c
- 32 >= MAXCHAR
)) {
918 p
->ps
->pscol
+= (size_t)fonts
[f
].gly
[0].wx
;
922 ps_putchar(p
, (char)c
);
924 p
->ps
->pscol
+= (size_t)fonts
[f
].gly
[c
].wx
;
929 ps_pclose(struct termp
*p
)
933 * Spit out that we're exiting a word context (this is a
934 * "partial close" because we don't check the last-char buffer
938 if ( ! (PS_INLINE
& p
->ps
->flags
))
941 if (TERMTYPE_PS
!= p
->type
) {
942 ps_printf(p
, ") Tj\nET\n");
944 ps_printf(p
, ") show\n");
946 p
->ps
->flags
&= ~PS_INLINE
;
951 ps_fclose(struct termp
*p
)
955 * Strong closure: if we have a last-char, spit it out after
956 * checking that we're in the right font mode. This will of
957 * course open a new scope, if applicable.
959 * Following this, close out any scope that's open.
962 if ('\0' != p
->ps
->last
) {
963 if (p
->ps
->lastf
!= TERMFONT_NONE
) {
965 ps_setfont(p
, TERMFONT_NONE
);
967 ps_pletter(p
, p
->ps
->last
);
971 if ( ! (PS_INLINE
& p
->ps
->flags
))
979 ps_letter(struct termp
*p
, int arg
)
984 c
= arg
>= 128 || arg
<= 0 ? '?' : arg
;
987 * State machine dictates whether to buffer the last character
988 * or not. Basically, encoded words are detected by checking if
989 * we're an "8" and switching on the buffer. Then we put "8" in
990 * our buffer, and on the next charater, flush both character
991 * and buffer. Thus, "regular" words are detected by having a
992 * regular character and a regular buffer character.
995 if ('\0' == p
->ps
->last
) {
999 } else if (8 == p
->ps
->last
) {
1002 } else if (8 == c
) {
1003 assert(8 != p
->ps
->last
);
1004 if ('_' == p
->ps
->last
) {
1005 if (p
->ps
->lastf
!= TERMFONT_UNDER
) {
1007 ps_setfont(p
, TERMFONT_UNDER
);
1009 } else if (p
->ps
->lastf
!= TERMFONT_BOLD
) {
1011 ps_setfont(p
, TERMFONT_BOLD
);
1016 if (p
->ps
->lastf
!= TERMFONT_NONE
) {
1018 ps_setfont(p
, TERMFONT_NONE
);
1030 ps_advance(struct termp
*p
, size_t len
)
1034 * Advance some spaces. This can probably be made smarter,
1035 * i.e., to have multiple space-separated words in the same
1036 * scope, but this is easier: just close out the current scope
1037 * and readjust our column settings.
1041 p
->ps
->pscol
+= len
;
1046 ps_endline(struct termp
*p
)
1049 /* Close out any scopes we have open: we're at eoln. */
1054 * If we're in the margin, don't try to recalculate our current
1055 * row. XXX: if the column tries to be fancy with multiple
1056 * lines, we'll do nasty stuff.
1059 if (PS_MARGINS
& p
->ps
->flags
)
1064 p
->ps
->pscol
= p
->ps
->left
;
1066 /* If we haven't printed anything, return. */
1068 if (PS_NEWPAGE
& p
->ps
->flags
)
1072 * Put us down a line. If we're at the page bottom, spit out a
1073 * showpage and restart our row.
1076 if (p
->ps
->psrow
>= p
->ps
->lineheight
+
1078 p
->ps
->psrow
-= p
->ps
->lineheight
;
1087 ps_setfont(struct termp
*p
, enum termfont f
)
1090 assert(f
< TERMFONT__MAX
);
1094 * If we're still at the top of the page, let the font-setting
1095 * be delayed until we actually have stuff to print.
1098 if (PS_NEWPAGE
& p
->ps
->flags
)
1101 if (TERMTYPE_PS
== p
->type
)
1102 ps_printf(p
, "/%s %zu selectfont\n",
1106 ps_printf(p
, "/F%d %zu Tf\n",
1114 ps_width(const struct termp
*p
, int c
)
1117 if (c
<= 32 || c
- 32 >= MAXCHAR
)
1118 return((size_t)fonts
[(int)TERMFONT_NONE
].gly
[0].wx
);
1121 return((size_t)fonts
[(int)TERMFONT_NONE
].gly
[c
].wx
);
1126 ps_hspan(const struct termp
*p
, const struct roffsu
*su
)
1131 * All of these measurements are derived by converting from the
1132 * native measurement to AFM units.
1137 r
= PNT2AFM(p
, su
->scale
* 28.34);
1140 r
= PNT2AFM(p
, su
->scale
* 72);
1143 r
= PNT2AFM(p
, su
->scale
* 12);
1146 r
= PNT2AFM(p
, su
->scale
* 100);
1150 fonts
[(int)TERMFONT_NONE
].gly
[109 - 32].wx
;
1153 r
= PNT2AFM(p
, su
->scale
* 2.834);
1157 fonts
[(int)TERMFONT_NONE
].gly
[110 - 32].wx
;
1160 r
= su
->scale
* p
->ps
->lineheight
;
1171 ps_growbuf(struct termp
*p
, size_t sz
)
1173 if (p
->ps
->psmargcur
+ sz
<= p
->ps
->psmargsz
)
1176 if (sz
< PS_BUFSLOP
)
1179 p
->ps
->psmargsz
+= sz
;
1181 p
->ps
->psmarg
= mandoc_realloc
1182 (p
->ps
->psmarg
, p
->ps
->psmargsz
);