]>
git.cameronkatri.com Git - mandoc.git/blob - term_ps.c
1 /* $Id: term_ps.c,v 1.81 2016/07/19 13:36:13 schwarze Exp $ */
3 * Copyright (c) 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
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.
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.
20 #include <sys/types.h>
33 #include "mandoc_aux.h"
39 /* These work the buffer used by the header and footer. */
40 #define PS_BUFSLOP 128
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))
46 /* Convert an AFM unit "x" to a PostScript points */
47 #define AFM2PNT(p, x) \
48 ((double)(x) / (1000.0 / (double)(p)->ps->scale))
51 unsigned short wx
; /* WX in AFM */
55 const char *name
; /* FontName in AFM */
56 #define MAXCHAR 95 /* total characters we can handle */
57 struct glyph gly
[MAXCHAR
]; /* glyph metrics */
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 */
93 static int ps_hspan(const struct termp
*,
94 const struct roffsu
*);
95 static size_t ps_width(const struct termp
*, int);
96 static void ps_advance(struct termp
*, size_t);
97 static void ps_begin(struct termp
*);
98 static void ps_closepage(struct termp
*);
99 static void ps_end(struct termp
*);
100 static void ps_endline(struct termp
*);
101 static void ps_fclose(struct termp
*);
102 static void ps_growbuf(struct termp
*, size_t);
103 static void ps_letter(struct termp
*, int);
104 static void ps_pclose(struct termp
*);
105 static void ps_pletter(struct termp
*, int);
106 static void ps_printf(struct termp
*, const char *, ...)
107 __attribute__((__format__ (printf
, 2, 3)));
108 static void ps_putchar(struct termp
*, char);
109 static void ps_setfont(struct termp
*, enum termfont
);
110 static void ps_setwidth(struct termp
*, int, int);
111 static struct termp
*pspdf_alloc(const struct manoutput
*);
112 static void pdf_obj(struct termp
*, size_t);
115 * We define, for the time being, three fonts: bold, oblique/italic, and
116 * normal (roman). The following table hard-codes the font metrics for
117 * ASCII, i.e., 32--127.
120 static const struct font fonts
[TERMFONT__MAX
] = {
412 { "Times-BoldItalic", {
512 pdf_alloc(const struct manoutput
*outopts
)
516 if (NULL
!= (p
= pspdf_alloc(outopts
)))
517 p
->type
= TERMTYPE_PDF
;
523 ps_alloc(const struct manoutput
*outopts
)
527 if (NULL
!= (p
= pspdf_alloc(outopts
)))
528 p
->type
= TERMTYPE_PS
;
533 static struct termp
*
534 pspdf_alloc(const struct manoutput
*outopts
)
537 unsigned int pagex
, pagey
;
538 size_t marginx
, marginy
, lineheight
;
541 p
= mandoc_calloc(1, sizeof(struct termp
));
542 p
->enc
= TERMENC_ASCII
;
543 p
->fontq
= mandoc_reallocarray(NULL
,
544 (p
->fontsz
= 8), sizeof(enum termfont
));
545 p
->fontq
[0] = p
->fontl
= TERMFONT_NONE
;
546 p
->ps
= mandoc_calloc(1, sizeof(struct termp_ps
));
548 p
->advance
= ps_advance
;
551 p
->endline
= ps_endline
;
553 p
->letter
= ps_letter
;
554 p
->setwidth
= ps_setwidth
;
557 /* Default to US letter (millimetres). */
563 * The ISO-269 paper sizes can be calculated automatically, but
564 * it would require bringing in -lm for pow() and I'd rather not
565 * do that. So just do it the easy way for now. Since this
566 * only happens once, I'm not terribly concerned.
570 if (pp
&& strcasecmp(pp
, "letter")) {
571 if (0 == strcasecmp(pp
, "a3")) {
574 } else if (0 == strcasecmp(pp
, "a4")) {
577 } else if (0 == strcasecmp(pp
, "a5")) {
580 } else if (0 == strcasecmp(pp
, "legal")) {
583 } else if (2 != sscanf(pp
, "%ux%u", &pagex
, &pagey
))
584 warnx("%s: Unknown paper", pp
);
588 * This MUST be defined before any PNT2AFM or AFM2PNT
589 * calculations occur.
594 /* Remember millimetres -> AFM units. */
596 pagex
= PNT2AFM(p
, ((double)pagex
* 2.834));
597 pagey
= PNT2AFM(p
, ((double)pagey
* 2.834));
599 /* Margins are 1/9 the page x and y. */
601 marginx
= (size_t)((double)pagex
/ 9.0);
602 marginy
= (size_t)((double)pagey
/ 9.0);
604 /* Line-height is 1.4em. */
606 lineheight
= PNT2AFM(p
, ((double)p
->ps
->scale
* 1.4));
608 p
->ps
->width
= p
->ps
->lastwidth
= (size_t)pagex
;
609 p
->ps
->height
= (size_t)pagey
;
610 p
->ps
->header
= pagey
- (marginy
/ 2) - (lineheight
/ 2);
611 p
->ps
->top
= pagey
- marginy
;
612 p
->ps
->footer
= (marginy
/ 2) - (lineheight
/ 2);
613 p
->ps
->bottom
= marginy
;
614 p
->ps
->left
= marginx
;
615 p
->ps
->lineheight
= lineheight
;
617 p
->defrmargin
= pagex
- (marginx
* 2);
622 ps_setwidth(struct termp
*p
, int iop
, int width
)
626 lastwidth
= p
->ps
->width
;
628 p
->ps
->width
+= width
;
630 p
->ps
->width
= width
? (size_t)width
: p
->ps
->lastwidth
;
631 else if (p
->ps
->width
> (size_t)width
)
632 p
->ps
->width
-= width
;
635 p
->ps
->lastwidth
= lastwidth
;
639 pspdf_free(void *arg
)
643 p
= (struct termp
*)arg
;
646 free(p
->ps
->pdfobjs
);
653 ps_printf(struct termp
*p
, const char *fmt
, ...)
661 * If we're running in regular mode, then pipe directly into
662 * vprintf(). If we're processing margins, then push the data
663 * into our growable margin buffer.
666 if ( ! (PS_MARGINS
& p
->ps
->flags
)) {
667 len
= vprintf(fmt
, ap
);
669 p
->ps
->pdfbytes
+= len
< 0 ? 0 : (size_t)len
;
674 * XXX: I assume that the in-margin print won't exceed
675 * PS_BUFSLOP (128 bytes), which is reasonable but still an
676 * assumption that will cause pukeage if it's not the case.
679 ps_growbuf(p
, PS_BUFSLOP
);
681 pos
= (int)p
->ps
->psmargcur
;
682 vsnprintf(&p
->ps
->psmarg
[pos
], PS_BUFSLOP
, fmt
, ap
);
686 p
->ps
->psmargcur
= strlen(p
->ps
->psmarg
);
690 ps_putchar(struct termp
*p
, char c
)
694 /* See ps_printf(). */
696 if ( ! (PS_MARGINS
& p
->ps
->flags
)) {
704 pos
= (int)p
->ps
->psmargcur
++;
705 p
->ps
->psmarg
[pos
++] = c
;
706 p
->ps
->psmarg
[pos
] = '\0';
710 pdf_obj(struct termp
*p
, size_t obj
)
715 if ((obj
- 1) >= p
->ps
->pdfobjsz
) {
716 p
->ps
->pdfobjsz
= obj
+ 128;
717 p
->ps
->pdfobjs
= mandoc_reallocarray(p
->ps
->pdfobjs
,
718 p
->ps
->pdfobjsz
, sizeof(size_t));
721 p
->ps
->pdfobjs
[(int)obj
- 1] = p
->ps
->pdfbytes
;
722 ps_printf(p
, "%zu 0 obj\n", obj
);
726 ps_closepage(struct termp
*p
)
732 * Close out a page that we've already flushed to output. In
733 * PostScript, we simply note that the page must be showed. In
734 * PDF, we must now create the Length, Resource, and Page node
735 * for the page contents.
738 assert(p
->ps
->psmarg
&& p
->ps
->psmarg
[0]);
739 ps_printf(p
, "%s", p
->ps
->psmarg
);
741 if (TERMTYPE_PS
!= p
->type
) {
742 ps_printf(p
, "ET\n");
744 len
= p
->ps
->pdfbytes
- p
->ps
->pdflastpg
;
745 base
= p
->ps
->pages
* 4 + p
->ps
->pdfbody
;
747 ps_printf(p
, "endstream\nendobj\n");
749 /* Length of content. */
750 pdf_obj(p
, base
+ 1);
751 ps_printf(p
, "%zu\nendobj\n", len
);
753 /* Resource for content. */
754 pdf_obj(p
, base
+ 2);
755 ps_printf(p
, "<<\n/ProcSet [/PDF /Text]\n");
756 ps_printf(p
, "/Font <<\n");
757 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++)
758 ps_printf(p
, "/F%d %d 0 R\n", i
, 3 + i
);
759 ps_printf(p
, ">>\n>>\n");
762 pdf_obj(p
, base
+ 3);
763 ps_printf(p
, "<<\n");
764 ps_printf(p
, "/Type /Page\n");
765 ps_printf(p
, "/Parent 2 0 R\n");
766 ps_printf(p
, "/Resources %zu 0 R\n", base
+ 2);
767 ps_printf(p
, "/Contents %zu 0 R\n", base
);
768 ps_printf(p
, ">>\nendobj\n");
770 ps_printf(p
, "showpage\n");
773 p
->ps
->psrow
= p
->ps
->top
;
774 assert( ! (PS_NEWPAGE
& p
->ps
->flags
));
775 p
->ps
->flags
|= PS_NEWPAGE
;
779 ps_end(struct termp
*p
)
781 size_t i
, xref
, base
;
784 * At the end of the file, do one last showpage. This is the
785 * same behaviour as groff(1) and works for multiple pages as
789 if ( ! (PS_NEWPAGE
& p
->ps
->flags
)) {
790 assert(0 == p
->ps
->flags
);
791 assert('\0' == p
->ps
->last
);
795 if (TERMTYPE_PS
== p
->type
) {
796 ps_printf(p
, "%%%%Trailer\n");
797 ps_printf(p
, "%%%%Pages: %zu\n", p
->ps
->pages
);
798 ps_printf(p
, "%%%%EOF\n");
803 ps_printf(p
, "<<\n/Type /Pages\n");
804 ps_printf(p
, "/MediaBox [0 0 %zu %zu]\n",
805 (size_t)AFM2PNT(p
, p
->ps
->width
),
806 (size_t)AFM2PNT(p
, p
->ps
->height
));
808 ps_printf(p
, "/Count %zu\n", p
->ps
->pages
);
809 ps_printf(p
, "/Kids [");
811 for (i
= 0; i
< p
->ps
->pages
; i
++)
812 ps_printf(p
, " %zu 0 R", i
* 4 + p
->ps
->pdfbody
+ 3);
814 base
= (p
->ps
->pages
- 1) * 4 + p
->ps
->pdfbody
+ 4;
816 ps_printf(p
, "]\n>>\nendobj\n");
818 ps_printf(p
, "<<\n");
819 ps_printf(p
, "/Type /Catalog\n");
820 ps_printf(p
, "/Pages 2 0 R\n");
821 ps_printf(p
, ">>\n");
822 xref
= p
->ps
->pdfbytes
;
823 ps_printf(p
, "xref\n");
824 ps_printf(p
, "0 %zu\n", base
+ 1);
825 ps_printf(p
, "0000000000 65535 f \n");
827 for (i
= 0; i
< base
; i
++)
828 ps_printf(p
, "%.10zu 00000 n \n",
829 p
->ps
->pdfobjs
[(int)i
]);
831 ps_printf(p
, "trailer\n");
832 ps_printf(p
, "<<\n");
833 ps_printf(p
, "/Size %zu\n", base
+ 1);
834 ps_printf(p
, "/Root %zu 0 R\n", base
);
835 ps_printf(p
, "/Info 1 0 R\n");
836 ps_printf(p
, ">>\n");
837 ps_printf(p
, "startxref\n");
838 ps_printf(p
, "%zu\n", xref
);
839 ps_printf(p
, "%%%%EOF\n");
843 ps_begin(struct termp
*p
)
848 * Print margins into margin buffer. Nothing gets output to the
849 * screen yet, so we don't need to initialise the primary state.
853 assert(p
->ps
->psmargsz
);
854 p
->ps
->psmarg
[0] = '\0';
857 /*p->ps->pdfbytes = 0;*/
858 p
->ps
->psmargcur
= 0;
859 p
->ps
->flags
= PS_MARGINS
;
860 p
->ps
->pscol
= p
->ps
->left
;
861 p
->ps
->psrow
= p
->ps
->header
;
863 ps_setfont(p
, TERMFONT_NONE
);
865 (*p
->headf
)(p
, p
->argf
);
868 p
->ps
->pscol
= p
->ps
->left
;
869 p
->ps
->psrow
= p
->ps
->footer
;
871 (*p
->footf
)(p
, p
->argf
);
874 p
->ps
->flags
&= ~PS_MARGINS
;
876 assert(0 == p
->ps
->flags
);
877 assert(p
->ps
->psmarg
);
878 assert('\0' != p
->ps
->psmarg
[0]);
881 * Print header and initialise page state. Following this,
882 * stuff gets printed to the screen, so make sure we're sane.
885 if (TERMTYPE_PS
== p
->type
) {
886 ps_printf(p
, "%%!PS-Adobe-3.0\n");
887 ps_printf(p
, "%%%%DocumentData: Clean7Bit\n");
888 ps_printf(p
, "%%%%Orientation: Portrait\n");
889 ps_printf(p
, "%%%%Pages: (atend)\n");
890 ps_printf(p
, "%%%%PageOrder: Ascend\n");
891 ps_printf(p
, "%%%%DocumentMedia: "
892 "Default %zu %zu 0 () ()\n",
893 (size_t)AFM2PNT(p
, p
->ps
->width
),
894 (size_t)AFM2PNT(p
, p
->ps
->height
));
895 ps_printf(p
, "%%%%DocumentNeededResources: font");
897 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++)
898 ps_printf(p
, " %s", fonts
[i
].name
);
900 ps_printf(p
, "\n%%%%EndComments\n");
902 ps_printf(p
, "%%PDF-1.1\n");
904 ps_printf(p
, "<<\n");
905 ps_printf(p
, ">>\n");
906 ps_printf(p
, "endobj\n");
908 for (i
= 0; i
< (int)TERMFONT__MAX
; i
++) {
909 pdf_obj(p
, (size_t)i
+ 3);
910 ps_printf(p
, "<<\n");
911 ps_printf(p
, "/Type /Font\n");
912 ps_printf(p
, "/Subtype /Type1\n");
913 ps_printf(p
, "/Name /F%d\n", i
);
914 ps_printf(p
, "/BaseFont /%s\n", fonts
[i
].name
);
915 ps_printf(p
, ">>\n");
919 p
->ps
->pdfbody
= (size_t)TERMFONT__MAX
+ 3;
920 p
->ps
->pscol
= p
->ps
->left
;
921 p
->ps
->psrow
= p
->ps
->top
;
922 p
->ps
->flags
|= PS_NEWPAGE
;
923 ps_setfont(p
, TERMFONT_NONE
);
927 ps_pletter(struct termp
*p
, int c
)
932 * If we haven't opened a page context, then output that we're
933 * in a new page and make sure the font is correctly set.
936 if (PS_NEWPAGE
& p
->ps
->flags
) {
937 if (TERMTYPE_PS
== p
->type
) {
938 ps_printf(p
, "%%%%Page: %zu %zu\n",
939 p
->ps
->pages
+ 1, p
->ps
->pages
+ 1);
940 ps_printf(p
, "/%s %zu selectfont\n",
941 fonts
[(int)p
->ps
->lastf
].name
,
944 pdf_obj(p
, p
->ps
->pdfbody
+
946 ps_printf(p
, "<<\n");
947 ps_printf(p
, "/Length %zu 0 R\n",
948 p
->ps
->pdfbody
+ 1 + p
->ps
->pages
* 4);
949 ps_printf(p
, ">>\nstream\n");
951 p
->ps
->pdflastpg
= p
->ps
->pdfbytes
;
952 p
->ps
->flags
&= ~PS_NEWPAGE
;
956 * If we're not in a PostScript "word" context, then open one
957 * now at the current cursor.
960 if ( ! (PS_INLINE
& p
->ps
->flags
)) {
961 if (TERMTYPE_PS
!= p
->type
) {
962 ps_printf(p
, "BT\n/F%d %zu Tf\n",
963 (int)p
->ps
->lastf
, p
->ps
->scale
);
964 ps_printf(p
, "%.3f %.3f Td\n(",
965 AFM2PNT(p
, p
->ps
->pscol
),
966 AFM2PNT(p
, p
->ps
->psrow
));
968 ps_printf(p
, "%.3f %.3f moveto\n(",
969 AFM2PNT(p
, p
->ps
->pscol
),
970 AFM2PNT(p
, p
->ps
->psrow
));
971 p
->ps
->flags
|= PS_INLINE
;
974 assert( ! (PS_NEWPAGE
& p
->ps
->flags
));
977 * We need to escape these characters as per the PostScript
978 * specification. We would also escape non-graphable characters
979 * (like tabs), but none of them would get to this point and
980 * it's superfluous to abort() on them.
993 /* Write the character and adjust where we are on the page. */
995 f
= (int)p
->ps
->lastf
;
997 if (c
<= 32 || c
- 32 >= MAXCHAR
)
1000 ps_putchar(p
, (char)c
);
1002 p
->ps
->pscol
+= (size_t)fonts
[f
].gly
[c
].wx
;
1006 ps_pclose(struct termp
*p
)
1010 * Spit out that we're exiting a word context (this is a
1011 * "partial close" because we don't check the last-char buffer
1015 if ( ! (PS_INLINE
& p
->ps
->flags
))
1018 if (TERMTYPE_PS
!= p
->type
) {
1019 ps_printf(p
, ") Tj\nET\n");
1021 ps_printf(p
, ") show\n");
1023 p
->ps
->flags
&= ~PS_INLINE
;
1027 ps_fclose(struct termp
*p
)
1031 * Strong closure: if we have a last-char, spit it out after
1032 * checking that we're in the right font mode. This will of
1033 * course open a new scope, if applicable.
1035 * Following this, close out any scope that's open.
1038 if (p
->ps
->last
!= '\0') {
1039 assert( ! (p
->ps
->flags
& PS_BACKSP
));
1040 if (p
->ps
->nextf
!= p
->ps
->lastf
) {
1042 ps_setfont(p
, p
->ps
->nextf
);
1044 p
->ps
->nextf
= TERMFONT_NONE
;
1045 ps_pletter(p
, p
->ps
->last
);
1049 if ( ! (PS_INLINE
& p
->ps
->flags
))
1056 ps_letter(struct termp
*p
, int arg
)
1061 c
= arg
>= 128 || arg
<= 0 ? '?' : arg
;
1064 * When receiving a backspace, merely flag it.
1065 * We don't know yet whether it is
1066 * a font instruction or an overstrike.
1070 assert(p
->ps
->last
!= '\0');
1071 assert( ! (p
->ps
->flags
& PS_BACKSP
));
1072 p
->ps
->flags
|= PS_BACKSP
;
1077 * Decode font instructions.
1080 if (p
->ps
->flags
& PS_BACKSP
) {
1081 if (p
->ps
->last
== '_') {
1082 switch (p
->ps
->nextf
) {
1086 p
->ps
->nextf
= TERMFONT_BI
;
1089 p
->ps
->nextf
= TERMFONT_UNDER
;
1092 p
->ps
->flags
&= ~PS_BACKSP
;
1095 if (p
->ps
->last
== c
) {
1096 switch (p
->ps
->nextf
) {
1099 case TERMFONT_UNDER
:
1100 p
->ps
->nextf
= TERMFONT_BI
;
1103 p
->ps
->nextf
= TERMFONT_BOLD
;
1105 p
->ps
->flags
&= ~PS_BACKSP
;
1110 * This is not a font instruction, but rather
1111 * the next character. Prepare for overstrike.
1114 savecol
= p
->ps
->pscol
;
1119 * We found the next character, so the font instructions
1120 * for the previous one are complete.
1121 * Use them and print it.
1124 if (p
->ps
->last
!= '\0') {
1125 if (p
->ps
->nextf
!= p
->ps
->lastf
) {
1127 ps_setfont(p
, p
->ps
->nextf
);
1129 p
->ps
->nextf
= TERMFONT_NONE
;
1132 * For an overstrike, if a previous character
1133 * was wider, advance to center the new one.
1136 if (p
->ps
->pscolnext
) {
1137 wx
= fonts
[p
->ps
->lastf
].gly
[(int)p
->ps
->last
-32].wx
;
1138 if (p
->ps
->pscol
+ wx
< p
->ps
->pscolnext
)
1139 p
->ps
->pscol
= (p
->ps
->pscol
+
1140 p
->ps
->pscolnext
- wx
) / 2;
1143 ps_pletter(p
, p
->ps
->last
);
1146 * For an overstrike, if a previous character
1147 * was wider, advance to the end of the old one.
1150 if (p
->ps
->pscol
< p
->ps
->pscolnext
) {
1152 p
->ps
->pscol
= p
->ps
->pscolnext
;
1157 * Do not print the current character yet because font
1158 * instructions might follow; only remember it.
1159 * For the first character, nothing else is done.
1160 * The final character will get printed from ps_fclose().
1166 * For an overstrike, back up to the previous position.
1167 * If the previous character is wider than any it overstrikes,
1168 * remember the current position, because it might also be
1169 * wider than all that will overstrike it.
1172 if (savecol
!= SIZE_MAX
) {
1173 if (p
->ps
->pscolnext
< p
->ps
->pscol
)
1174 p
->ps
->pscolnext
= p
->ps
->pscol
;
1176 p
->ps
->pscol
= savecol
;
1177 p
->ps
->flags
&= ~PS_BACKSP
;
1179 p
->ps
->pscolnext
= 0;
1183 ps_advance(struct termp
*p
, size_t len
)
1187 * Advance some spaces. This can probably be made smarter,
1188 * i.e., to have multiple space-separated words in the same
1189 * scope, but this is easier: just close out the current scope
1190 * and readjust our column settings.
1194 p
->ps
->pscol
+= len
;
1198 ps_endline(struct termp
*p
)
1201 /* Close out any scopes we have open: we're at eoln. */
1206 * If we're in the margin, don't try to recalculate our current
1207 * row. XXX: if the column tries to be fancy with multiple
1208 * lines, we'll do nasty stuff.
1211 if (PS_MARGINS
& p
->ps
->flags
)
1216 p
->ps
->pscol
= p
->ps
->left
;
1218 /* If we haven't printed anything, return. */
1220 if (PS_NEWPAGE
& p
->ps
->flags
)
1224 * Put us down a line. If we're at the page bottom, spit out a
1225 * showpage and restart our row.
1228 if (p
->ps
->psrow
>= p
->ps
->lineheight
+ p
->ps
->bottom
) {
1229 p
->ps
->psrow
-= p
->ps
->lineheight
;
1237 ps_setfont(struct termp
*p
, enum termfont f
)
1240 assert(f
< TERMFONT__MAX
);
1244 * If we're still at the top of the page, let the font-setting
1245 * be delayed until we actually have stuff to print.
1248 if (PS_NEWPAGE
& p
->ps
->flags
)
1251 if (TERMTYPE_PS
== p
->type
)
1252 ps_printf(p
, "/%s %zu selectfont\n",
1253 fonts
[(int)f
].name
, p
->ps
->scale
);
1255 ps_printf(p
, "/F%d %zu Tf\n",
1256 (int)f
, p
->ps
->scale
);
1260 ps_width(const struct termp
*p
, int c
)
1263 if (c
<= 32 || c
- 32 >= MAXCHAR
)
1268 return (size_t)fonts
[(int)TERMFONT_NONE
].gly
[c
].wx
;
1272 ps_hspan(const struct termp
*p
, const struct roffsu
*su
)
1277 * All of these measurements are derived by converting from the
1278 * native measurement to AFM units.
1283 * Traditionally, the default unit is fixed to the
1284 * output media. So this would refer to the point. In
1285 * mandoc(1), however, we stick to the default terminal
1286 * scaling unit so that output is the same regardless
1289 r
= PNT2AFM(p
, su
->scale
* 72.0 / 240.0);
1292 r
= PNT2AFM(p
, su
->scale
* 72.0 / 2.54);
1296 fonts
[(int)TERMFONT_NONE
].gly
[109 - 32].wx
;
1300 fonts
[(int)TERMFONT_NONE
].gly
[110 - 32].wx
;
1303 r
= PNT2AFM(p
, su
->scale
* 72.0);
1307 fonts
[(int)TERMFONT_NONE
].gly
[109 - 32].wx
/ 100.0;
1310 r
= PNT2AFM(p
, su
->scale
* 12.0);
1313 r
= PNT2AFM(p
, su
->scale
* 1.0);
1316 r
= su
->scale
* p
->ps
->lineheight
;
1327 ps_growbuf(struct termp
*p
, size_t sz
)
1329 if (p
->ps
->psmargcur
+ sz
<= p
->ps
->psmargsz
)
1332 if (sz
< PS_BUFSLOP
)
1335 p
->ps
->psmargsz
+= sz
;
1336 p
->ps
->psmarg
= mandoc_realloc(p
->ps
->psmarg
, p
->ps
->psmargsz
);