=================================================================== RCS file: /cvs/mandoc/term_ps.c,v retrieving revision 1.40 retrieving revision 1.83 diff -u -p -r1.40 -r1.83 --- mandoc/term_ps.c 2010/08/01 15:46:18 1.40 +++ mandoc/term_ps.c 2017/02/17 14:31:52 1.83 @@ -1,45 +1,51 @@ -/* $Id: term_ps.c,v 1.40 2010/08/01 15:46:18 joerg Exp $ */ +/* $Id: term_ps.c,v 1.83 2017/02/17 14:31:52 schwarze Exp $ */ /* - * Copyright (c) 2010 Kristaps Dzonsons + * Copyright (c) 2010, 2011 Kristaps Dzonsons + * Copyright (c) 2014, 2015, 2016 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif -#include +#include #include +#if HAVE_ERR +#include +#endif #include #include #include #include #include -#include #include +#include "mandoc_aux.h" #include "out.h" -#include "main.h" #include "term.h" +#include "manconf.h" +#include "main.h" +/* These work the buffer used by the header and footer. */ +#define PS_BUFSLOP 128 + /* Convert PostScript point "x" to an AFM unit. */ -#define PNT2AFM(p, x) /* LINTED */ \ - (size_t)((double)(x) * (1000.0 / (double)(p)->engine.ps.scale)) +#define PNT2AFM(p, x) \ + (size_t)((double)(x) * (1000.0 / (double)(p)->ps->scale)) /* Convert an AFM unit "x" to a PostScript points */ -#define AFM2PNT(p, x) /* LINTED */ \ - ((double)(x) / (1000.0 / (double)(p)->engine.ps.scale)) +#define AFM2PNT(p, x) \ + ((double)(x) / (1000.0 / (double)(p)->ps->scale)) struct glyph { unsigned short wx; /* WX in AFM */ @@ -51,6 +57,60 @@ struct font { struct glyph gly[MAXCHAR]; /* glyph metrics */ }; +struct termp_ps { + int flags; +#define PS_INLINE (1 << 0) /* we're in a word */ +#define PS_MARGINS (1 << 1) /* we're in the margins */ +#define PS_NEWPAGE (1 << 2) /* new page, no words yet */ +#define PS_BACKSP (1 << 3) /* last character was backspace */ + size_t pscol; /* visible column (AFM units) */ + size_t pscolnext; /* used for overstrike */ + size_t psrow; /* visible row (AFM units) */ + char *psmarg; /* margin buf */ + size_t psmargsz; /* margin buf size */ + size_t psmargcur; /* cur index in margin buf */ + char last; /* last non-backspace seen */ + enum termfont lastf; /* last set font */ + enum termfont nextf; /* building next font here */ + size_t scale; /* font scaling factor */ + size_t pages; /* number of pages shown */ + size_t lineheight; /* line height (AFM units) */ + size_t top; /* body top (AFM units) */ + size_t bottom; /* body bottom (AFM units) */ + size_t height; /* page height (AFM units */ + size_t width; /* page width (AFM units) */ + size_t lastwidth; /* page width before last ll */ + size_t left; /* body left (AFM units) */ + size_t header; /* header pos (AFM units) */ + size_t footer; /* footer pos (AFM units) */ + size_t pdfbytes; /* current output byte */ + size_t pdflastpg; /* byte of last page mark */ + size_t pdfbody; /* start of body object */ + size_t *pdfobjs; /* table of object offsets */ + size_t pdfobjsz; /* size of pdfobjs */ +}; + +static int ps_hspan(const struct termp *, + const struct roffsu *); +static size_t ps_width(const struct termp *, int); +static void ps_advance(struct termp *, size_t); +static void ps_begin(struct termp *); +static void ps_closepage(struct termp *); +static void ps_end(struct termp *); +static void ps_endline(struct termp *); +static void ps_growbuf(struct termp *, size_t); +static void ps_letter(struct termp *, int); +static void ps_pclose(struct termp *); +static void ps_plast(struct termp *); +static void ps_pletter(struct termp *, int); +static void ps_printf(struct termp *, const char *, ...) + __attribute__((__format__ (__printf__, 2, 3))); +static void ps_putchar(struct termp *, char); +static void ps_setfont(struct termp *, enum termfont); +static void ps_setwidth(struct termp *, int, int); +static struct termp *pspdf_alloc(const struct manoutput *); +static void pdf_obj(struct termp *, size_t); + /* * We define, for the time being, three fonts: bold, oblique/italic, and * normal (roman). The following table hard-codes the font metrics for @@ -349,82 +409,141 @@ static const struct font fonts[TERMFONT__MAX] = { { 400 }, { 541 }, } }, + { "Times-BoldItalic", { + { 250 }, + { 389 }, + { 555 }, + { 500 }, + { 500 }, + { 833 }, + { 778 }, + { 333 }, + { 333 }, + { 333 }, + { 500 }, + { 570 }, + { 250 }, + { 333 }, + { 250 }, + { 278 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 333 }, + { 333 }, + { 570 }, + { 570 }, + { 570 }, + { 500 }, + { 832 }, + { 667 }, + { 667 }, + { 667 }, + { 722 }, + { 667 }, + { 667 }, + { 722 }, + { 778 }, + { 389 }, + { 500 }, + { 667 }, + { 611 }, + { 889 }, + { 722 }, + { 722 }, + { 611 }, + { 722 }, + { 667 }, + { 556 }, + { 611 }, + { 722 }, + { 667 }, + { 889 }, + { 667 }, + { 611 }, + { 611 }, + { 333 }, + { 278 }, + { 333 }, + { 570 }, + { 500 }, + { 333 }, + { 500 }, + { 500 }, + { 444 }, + { 500 }, + { 444 }, + { 333 }, + { 500 }, + { 556 }, + { 278 }, + { 278 }, + { 500 }, + { 278 }, + { 778 }, + { 556 }, + { 500 }, + { 500 }, + { 500 }, + { 389 }, + { 389 }, + { 278 }, + { 556 }, + { 444 }, + { 667 }, + { 500 }, + { 444 }, + { 389 }, + { 348 }, + { 220 }, + { 348 }, + { 570 }, + } }, }; -/* These work the buffer used by the header and footer. */ -#define PS_BUFSLOP 128 - -static void -ps_growbuf(struct termp *p, size_t sz) -{ - if (p->engine.ps.psmargcur + sz <= p->engine.ps.psmargsz) - return; - - if (sz < PS_BUFSLOP) - sz = PS_BUFSLOP; - p->engine.ps.psmargsz += sz; - - p->engine.ps.psmarg = realloc(p->engine.ps.psmarg, - p->engine.ps.psmargsz); - if (NULL == p->engine.ps.psmarg) - perror(NULL); - exit(EXIT_FAILURE); -} - -static double ps_hspan(const struct termp *, - const struct roffsu *); -static size_t ps_width(const struct termp *, char); -static void ps_advance(struct termp *, size_t); -static void ps_begin(struct termp *); -static void ps_closepage(struct termp *); -static void ps_end(struct termp *); -static void ps_endline(struct termp *); -static void ps_fclose(struct termp *); -static void ps_letter(struct termp *, char); -static void ps_pclose(struct termp *); -static void ps_pletter(struct termp *, int); -static void ps_printf(struct termp *, const char *, ...); -static void ps_putchar(struct termp *, char); -static void ps_setfont(struct termp *, enum termfont); -static struct termp *pspdf_alloc(char *); -static void pdf_obj(struct termp *, size_t); - - void * -pdf_alloc(char *outopts) +pdf_alloc(const struct manoutput *outopts) { struct termp *p; if (NULL != (p = pspdf_alloc(outopts))) p->type = TERMTYPE_PDF; - return(p); + return p; } - void * -ps_alloc(char *outopts) +ps_alloc(const struct manoutput *outopts) { struct termp *p; if (NULL != (p = pspdf_alloc(outopts))) p->type = TERMTYPE_PS; - return(p); + return p; } - static struct termp * -pspdf_alloc(char *outopts) +pspdf_alloc(const struct manoutput *outopts) { struct termp *p; - size_t pagex, pagey, marginx, marginy, lineheight; - const char *toks[2]; + unsigned int pagex, pagey; + size_t marginx, marginy, lineheight; const char *pp; - char *v; - if (NULL == (p = term_alloc(TERMENC_ASCII))) - return(NULL); + p = mandoc_calloc(1, sizeof(struct termp)); + p->enc = TERMENC_ASCII; + p->fontq = mandoc_reallocarray(NULL, + (p->fontsz = 8), sizeof(enum termfont)); + p->fontq[0] = p->fontl = TERMFONT_NONE; + p->ps = mandoc_calloc(1, sizeof(struct termp_ps)); p->advance = ps_advance; p->begin = ps_begin; @@ -432,22 +551,9 @@ pspdf_alloc(char *outopts) p->endline = ps_endline; p->hspan = ps_hspan; p->letter = ps_letter; + p->setwidth = ps_setwidth; p->width = ps_width; - - toks[0] = "paper"; - toks[1] = NULL; - pp = NULL; - - while (outopts && *outopts) - switch (getsubopt(&outopts, UNCONST(toks), &v)) { - case (0): - pp = v; - break; - default: - break; - } - /* Default to US letter (millimetres). */ pagex = 216; @@ -460,6 +566,7 @@ pspdf_alloc(char *outopts) * only happens once, I'm not terribly concerned. */ + pp = outopts->paper; if (pp && strcasecmp(pp, "letter")) { if (0 == strcasecmp(pp, "a3")) { pagex = 297; @@ -473,17 +580,16 @@ pspdf_alloc(char *outopts) } else if (0 == strcasecmp(pp, "legal")) { pagex = 216; pagey = 356; - } else if (2 != sscanf(pp, "%zux%zu", &pagex, &pagey)) - fprintf(stderr, "%s: Unknown paper\n", pp); - } else if (NULL == pp) - pp = "letter"; + } else if (2 != sscanf(pp, "%ux%u", &pagex, &pagey)) + warnx("%s: Unknown paper", pp); + } - /* + /* * This MUST be defined before any PNT2AFM or AFM2PNT * calculations occur. */ - p->engine.ps.scale = 11; + p->ps->scale = 11; /* Remember millimetres -> AFM units. */ @@ -492,29 +598,43 @@ pspdf_alloc(char *outopts) /* Margins are 1/9 the page x and y. */ - marginx = /* LINTED */ - (size_t)((double)pagex / 9.0); - marginy = /* LINTED */ - (size_t)((double)pagey / 9.0); + marginx = (size_t)((double)pagex / 9.0); + marginy = (size_t)((double)pagey / 9.0); /* Line-height is 1.4em. */ - lineheight = PNT2AFM(p, ((double)p->engine.ps.scale * 1.4)); + lineheight = PNT2AFM(p, ((double)p->ps->scale * 1.4)); - p->engine.ps.width = pagex; - p->engine.ps.height = pagey; - p->engine.ps.header = pagey - (marginy / 2) - (lineheight / 2); - p->engine.ps.top = pagey - marginy; - p->engine.ps.footer = (marginy / 2) - (lineheight / 2); - p->engine.ps.bottom = marginy; - p->engine.ps.left = marginx; - p->engine.ps.lineheight = lineheight; + p->ps->width = p->ps->lastwidth = (size_t)pagex; + p->ps->height = (size_t)pagey; + p->ps->header = pagey - (marginy / 2) - (lineheight / 2); + p->ps->top = pagey - marginy; + p->ps->footer = (marginy / 2) - (lineheight / 2); + p->ps->bottom = marginy; + p->ps->left = marginx; + p->ps->lineheight = lineheight; p->defrmargin = pagex - (marginx * 2); - return(p); + return p; } +static void +ps_setwidth(struct termp *p, int iop, int width) +{ + size_t lastwidth; + lastwidth = p->ps->width; + if (iop > 0) + p->ps->width += width; + else if (iop == 0) + p->ps->width = width ? (size_t)width : p->ps->lastwidth; + else if (p->ps->width > (size_t)width) + p->ps->width -= width; + else + p->ps->width = 0; + p->ps->lastwidth = lastwidth; +} + void pspdf_free(void *arg) { @@ -522,15 +642,13 @@ pspdf_free(void *arg) p = (struct termp *)arg; - if (p->engine.ps.psmarg) - free(p->engine.ps.psmarg); - if (p->engine.ps.pdfobjs) - free(p->engine.ps.pdfobjs); + free(p->ps->psmarg); + free(p->ps->pdfobjs); + free(p->ps); term_free(p); } - static void ps_printf(struct termp *p, const char *fmt, ...) { @@ -545,15 +663,14 @@ ps_printf(struct termp *p, const char *fmt, ...) * into our growable margin buffer. */ - if ( ! (PS_MARGINS & p->engine.ps.flags)) { + if ( ! (PS_MARGINS & p->ps->flags)) { len = vprintf(fmt, ap); va_end(ap); - p->engine.ps.pdfbytes += /* LINTED */ - len < 0 ? 0 : (size_t)len; + p->ps->pdfbytes += len < 0 ? 0 : (size_t)len; return; } - /* + /* * XXX: I assume that the in-margin print won't exceed * PS_BUFSLOP (128 bytes), which is reasonable but still an * assumption that will cause pukeage if it's not the case. @@ -561,15 +678,14 @@ ps_printf(struct termp *p, const char *fmt, ...) ps_growbuf(p, PS_BUFSLOP); - pos = (int)p->engine.ps.psmargcur; - len = vsnprintf(&p->engine.ps.psmarg[pos], PS_BUFSLOP, fmt, ap); + pos = (int)p->ps->psmargcur; + vsnprintf(&p->ps->psmarg[pos], PS_BUFSLOP, fmt, ap); va_end(ap); - p->engine.ps.psmargcur = strlen(p->engine.ps.psmarg); + p->ps->psmargcur = strlen(p->ps->psmarg); } - static void ps_putchar(struct termp *p, char c) { @@ -577,42 +693,35 @@ ps_putchar(struct termp *p, char c) /* See ps_printf(). */ - if ( ! (PS_MARGINS & p->engine.ps.flags)) { + if ( ! (PS_MARGINS & p->ps->flags)) { putchar(c); - p->engine.ps.pdfbytes++; + p->ps->pdfbytes++; return; } ps_growbuf(p, 2); - pos = (int)p->engine.ps.psmargcur++; - p->engine.ps.psmarg[pos++] = c; - p->engine.ps.psmarg[pos] = '\0'; + pos = (int)p->ps->psmargcur++; + p->ps->psmarg[pos++] = c; + p->ps->psmarg[pos] = '\0'; } - static void pdf_obj(struct termp *p, size_t obj) { assert(obj > 0); - if ((obj - 1) >= p->engine.ps.pdfobjsz) { - p->engine.ps.pdfobjsz = obj + 128; - p->engine.ps.pdfobjs = realloc - (p->engine.ps.pdfobjs, - p->engine.ps.pdfobjsz * sizeof(size_t)); - if (NULL == p->engine.ps.pdfobjs) { - perror(NULL); - exit(EXIT_FAILURE); - } + if ((obj - 1) >= p->ps->pdfobjsz) { + p->ps->pdfobjsz = obj + 128; + p->ps->pdfobjs = mandoc_reallocarray(p->ps->pdfobjs, + p->ps->pdfobjsz, sizeof(size_t)); } - p->engine.ps.pdfobjs[(int)obj - 1] = p->engine.ps.pdfbytes; + p->ps->pdfobjs[(int)obj - 1] = p->ps->pdfbytes; ps_printf(p, "%zu 0 obj\n", obj); } - static void ps_closepage(struct termp *p) { @@ -626,14 +735,14 @@ ps_closepage(struct termp *p) * for the page contents. */ - assert(p->engine.ps.psmarg && p->engine.ps.psmarg[0]); - ps_printf(p, "%s", p->engine.ps.psmarg); + assert(p->ps->psmarg && p->ps->psmarg[0]); + ps_printf(p, "%s", p->ps->psmarg); if (TERMTYPE_PS != p->type) { ps_printf(p, "ET\n"); - len = p->engine.ps.pdfbytes - p->engine.ps.pdflastpg; - base = p->engine.ps.pages * 4 + p->engine.ps.pdfbody; + len = p->ps->pdfbytes - p->ps->pdflastpg; + base = p->ps->pages * 4 + p->ps->pdfbody; ps_printf(p, "endstream\nendobj\n"); @@ -645,7 +754,7 @@ ps_closepage(struct termp *p) pdf_obj(p, base + 2); ps_printf(p, "<<\n/ProcSet [/PDF /Text]\n"); ps_printf(p, "/Font <<\n"); - for (i = 0; i < (int)TERMFONT__MAX; i++) + for (i = 0; i < (int)TERMFONT__MAX; i++) ps_printf(p, "/F%d %d 0 R\n", i, 3 + i); ps_printf(p, ">>\n>>\n"); @@ -660,53 +769,52 @@ ps_closepage(struct termp *p) } else ps_printf(p, "showpage\n"); - p->engine.ps.pages++; - p->engine.ps.psrow = p->engine.ps.top; - assert( ! (PS_NEWPAGE & p->engine.ps.flags)); - p->engine.ps.flags |= PS_NEWPAGE; + p->ps->pages++; + p->ps->psrow = p->ps->top; + assert( ! (PS_NEWPAGE & p->ps->flags)); + p->ps->flags |= PS_NEWPAGE; } - -/* ARGSUSED */ static void ps_end(struct termp *p) { size_t i, xref, base; + ps_plast(p); + ps_pclose(p); + /* * At the end of the file, do one last showpage. This is the * same behaviour as groff(1) and works for multiple pages as * well as just one. */ - if ( ! (PS_NEWPAGE & p->engine.ps.flags)) { - assert(0 == p->engine.ps.flags); - assert('\0' == p->engine.ps.last); + if ( ! (PS_NEWPAGE & p->ps->flags)) { + assert(0 == p->ps->flags); + assert('\0' == p->ps->last); ps_closepage(p); } if (TERMTYPE_PS == p->type) { ps_printf(p, "%%%%Trailer\n"); - ps_printf(p, "%%%%Pages: %zu\n", p->engine.ps.pages); + ps_printf(p, "%%%%Pages: %zu\n", p->ps->pages); ps_printf(p, "%%%%EOF\n"); return; - } + } pdf_obj(p, 2); ps_printf(p, "<<\n/Type /Pages\n"); ps_printf(p, "/MediaBox [0 0 %zu %zu]\n", - (size_t)AFM2PNT(p, p->engine.ps.width), - (size_t)AFM2PNT(p, p->engine.ps.height)); + (size_t)AFM2PNT(p, p->ps->width), + (size_t)AFM2PNT(p, p->ps->height)); - ps_printf(p, "/Count %zu\n", p->engine.ps.pages); + ps_printf(p, "/Count %zu\n", p->ps->pages); ps_printf(p, "/Kids ["); - for (i = 0; i < p->engine.ps.pages; i++) - ps_printf(p, " %zu 0 R", i * 4 + - p->engine.ps.pdfbody + 3); + for (i = 0; i < p->ps->pages; i++) + ps_printf(p, " %zu 0 R", i * 4 + p->ps->pdfbody + 3); - base = (p->engine.ps.pages - 1) * 4 + - p->engine.ps.pdfbody + 4; + base = (p->ps->pages - 1) * 4 + p->ps->pdfbody + 4; ps_printf(p, "]\n>>\nendobj\n"); pdf_obj(p, base); @@ -714,14 +822,14 @@ ps_end(struct termp *p) ps_printf(p, "/Type /Catalog\n"); ps_printf(p, "/Pages 2 0 R\n"); ps_printf(p, ">>\n"); - xref = p->engine.ps.pdfbytes; + xref = p->ps->pdfbytes; ps_printf(p, "xref\n"); ps_printf(p, "0 %zu\n", base + 1); ps_printf(p, "0000000000 65535 f \n"); for (i = 0; i < base; i++) - ps_printf(p, "%.10zu 00000 n \n", - p->engine.ps.pdfobjs[(int)i]); + ps_printf(p, "%.10zu 00000 n \n", + p->ps->pdfobjs[(int)i]); ps_printf(p, "trailer\n"); ps_printf(p, "<<\n"); @@ -734,65 +842,59 @@ ps_end(struct termp *p) ps_printf(p, "%%%%EOF\n"); } - static void ps_begin(struct termp *p) { - time_t t; int i; - /* + /* * Print margins into margin buffer. Nothing gets output to the * screen yet, so we don't need to initialise the primary state. */ - if (p->engine.ps.psmarg) { - assert(p->engine.ps.psmargsz); - p->engine.ps.psmarg[0] = '\0'; + if (p->ps->psmarg) { + assert(p->ps->psmargsz); + p->ps->psmarg[0] = '\0'; } - /*p->engine.ps.pdfbytes = 0;*/ - p->engine.ps.psmargcur = 0; - p->engine.ps.flags = PS_MARGINS; - p->engine.ps.pscol = p->engine.ps.left; - p->engine.ps.psrow = p->engine.ps.header; + /*p->ps->pdfbytes = 0;*/ + p->ps->psmargcur = 0; + p->ps->flags = PS_MARGINS; + p->ps->pscol = p->ps->left; + p->ps->psrow = p->ps->header; ps_setfont(p, TERMFONT_NONE); (*p->headf)(p, p->argf); (*p->endline)(p); - p->engine.ps.pscol = p->engine.ps.left; - p->engine.ps.psrow = p->engine.ps.footer; + p->ps->pscol = p->ps->left; + p->ps->psrow = p->ps->footer; (*p->footf)(p, p->argf); (*p->endline)(p); - p->engine.ps.flags &= ~PS_MARGINS; + p->ps->flags &= ~PS_MARGINS; - assert(0 == p->engine.ps.flags); - assert(p->engine.ps.psmarg); - assert('\0' != p->engine.ps.psmarg[0]); + assert(0 == p->ps->flags); + assert(p->ps->psmarg); + assert('\0' != p->ps->psmarg[0]); - /* + /* * Print header and initialise page state. Following this, * stuff gets printed to the screen, so make sure we're sane. */ - t = time(NULL); - if (TERMTYPE_PS == p->type) { ps_printf(p, "%%!PS-Adobe-3.0\n"); - ps_printf(p, "%%%%Creator: mandoc-%s\n", VERSION); - ps_printf(p, "%%%%CreationDate: %s", ctime(&t)); ps_printf(p, "%%%%DocumentData: Clean7Bit\n"); ps_printf(p, "%%%%Orientation: Portrait\n"); ps_printf(p, "%%%%Pages: (atend)\n"); ps_printf(p, "%%%%PageOrder: Ascend\n"); ps_printf(p, "%%%%DocumentMedia: " - "Default %zu %zu 0 () ()\n", - (size_t)AFM2PNT(p, p->engine.ps.width), - (size_t)AFM2PNT(p, p->engine.ps.height)); + "Default %zu %zu 0 () ()\n", + (size_t)AFM2PNT(p, p->ps->width), + (size_t)AFM2PNT(p, p->ps->height)); ps_printf(p, "%%%%DocumentNeededResources: font"); for (i = 0; i < (int)TERMFONT__MAX; i++) @@ -803,7 +905,6 @@ ps_begin(struct termp *p) ps_printf(p, "%%PDF-1.1\n"); pdf_obj(p, 1); ps_printf(p, "<<\n"); - ps_printf(p, "/Creator mandoc-%s\n", VERSION); ps_printf(p, ">>\n"); ps_printf(p, "endobj\n"); @@ -812,20 +913,19 @@ ps_begin(struct termp *p) ps_printf(p, "<<\n"); ps_printf(p, "/Type /Font\n"); ps_printf(p, "/Subtype /Type1\n"); - ps_printf(p, "/Name /F%zu\n", i); + ps_printf(p, "/Name /F%d\n", i); ps_printf(p, "/BaseFont /%s\n", fonts[i].name); ps_printf(p, ">>\n"); } } - p->engine.ps.pdfbody = (size_t)TERMFONT__MAX + 3; - p->engine.ps.pscol = p->engine.ps.left; - p->engine.ps.psrow = p->engine.ps.top; - p->engine.ps.flags |= PS_NEWPAGE; + p->ps->pdfbody = (size_t)TERMFONT__MAX + 3; + p->ps->pscol = p->ps->left; + p->ps->psrow = p->ps->top; + p->ps->flags |= PS_NEWPAGE; ps_setfont(p, TERMFONT_NONE); } - static void ps_pletter(struct termp *p, int c) { @@ -836,48 +936,45 @@ ps_pletter(struct termp *p, int c) * in a new page and make sure the font is correctly set. */ - if (PS_NEWPAGE & p->engine.ps.flags) { + if (PS_NEWPAGE & p->ps->flags) { if (TERMTYPE_PS == p->type) { - ps_printf(p, "%%%%Page: %zu %zu\n", - p->engine.ps.pages + 1, - p->engine.ps.pages + 1); - ps_printf(p, "/%s %zu selectfont\n", - fonts[(int)p->engine.ps.lastf].name, - p->engine.ps.scale); + ps_printf(p, "%%%%Page: %zu %zu\n", + p->ps->pages + 1, p->ps->pages + 1); + ps_printf(p, "/%s %zu selectfont\n", + fonts[(int)p->ps->lastf].name, + p->ps->scale); } else { - pdf_obj(p, p->engine.ps.pdfbody + - p->engine.ps.pages * 4); + pdf_obj(p, p->ps->pdfbody + + p->ps->pages * 4); ps_printf(p, "<<\n"); - ps_printf(p, "/Length %zu 0 R\n", - p->engine.ps.pdfbody + 1 + - p->engine.ps.pages * 4); + ps_printf(p, "/Length %zu 0 R\n", + p->ps->pdfbody + 1 + p->ps->pages * 4); ps_printf(p, ">>\nstream\n"); } - p->engine.ps.pdflastpg = p->engine.ps.pdfbytes; - p->engine.ps.flags &= ~PS_NEWPAGE; + p->ps->pdflastpg = p->ps->pdfbytes; + p->ps->flags &= ~PS_NEWPAGE; } - + /* * If we're not in a PostScript "word" context, then open one * now at the current cursor. */ - if ( ! (PS_INLINE & p->engine.ps.flags)) { + if ( ! (PS_INLINE & p->ps->flags)) { if (TERMTYPE_PS != p->type) { - ps_printf(p, "BT\n/F%d %zu Tf\n", - (int)p->engine.ps.lastf, - p->engine.ps.scale); + ps_printf(p, "BT\n/F%d %zu Tf\n", + (int)p->ps->lastf, p->ps->scale); ps_printf(p, "%.3f %.3f Td\n(", - AFM2PNT(p, p->engine.ps.pscol), - AFM2PNT(p, p->engine.ps.psrow)); + AFM2PNT(p, p->ps->pscol), + AFM2PNT(p, p->ps->psrow)); } else - ps_printf(p, "%.3f %.3f moveto\n(", - AFM2PNT(p, p->engine.ps.pscol), - AFM2PNT(p, p->engine.ps.psrow)); - p->engine.ps.flags |= PS_INLINE; + ps_printf(p, "%.3f %.3f moveto\n(", + AFM2PNT(p, p->ps->pscol), + AFM2PNT(p, p->ps->psrow)); + p->ps->flags |= PS_INLINE; } - assert( ! (PS_NEWPAGE & p->engine.ps.flags)); + assert( ! (PS_NEWPAGE & p->ps->flags)); /* * We need to escape these characters as per the PostScript @@ -887,11 +984,9 @@ ps_pletter(struct termp *p, int c) */ switch (c) { - case ('('): - /* FALLTHROUGH */ - case (')'): - /* FALLTHROUGH */ - case ('\\'): + case '(': + case ')': + case '\\': ps_putchar(p, '\\'); break; default: @@ -900,118 +995,176 @@ ps_pletter(struct termp *p, int c) /* Write the character and adjust where we are on the page. */ - f = (int)p->engine.ps.lastf; + f = (int)p->ps->lastf; - if (c <= 32 || (c - 32 > MAXCHAR)) { - ps_putchar(p, ' '); - p->engine.ps.pscol += (size_t)fonts[f].gly[0].wx; - return; - } + if (c <= 32 || c - 32 >= MAXCHAR) + c = 32; ps_putchar(p, (char)c); c -= 32; - p->engine.ps.pscol += (size_t)fonts[f].gly[c].wx; + p->ps->pscol += (size_t)fonts[f].gly[c].wx; } - static void ps_pclose(struct termp *p) { - /* + /* * Spit out that we're exiting a word context (this is a * "partial close" because we don't check the last-char buffer * or anything). */ - if ( ! (PS_INLINE & p->engine.ps.flags)) + if ( ! (PS_INLINE & p->ps->flags)) return; - + if (TERMTYPE_PS != p->type) { ps_printf(p, ") Tj\nET\n"); } else ps_printf(p, ") show\n"); - p->engine.ps.flags &= ~PS_INLINE; + p->ps->flags &= ~PS_INLINE; } - +/* If we have a `last' char that wasn't printed yet, print it now. */ static void -ps_fclose(struct termp *p) +ps_plast(struct termp *p) { + size_t wx; + if (p->ps->last == '\0') + return; + + /* Check the font mode; open a new scope if it doesn't match. */ + + if (p->ps->nextf != p->ps->lastf) { + ps_pclose(p); + ps_setfont(p, p->ps->nextf); + } + p->ps->nextf = TERMFONT_NONE; + /* - * Strong closure: if we have a last-char, spit it out after - * checking that we're in the right font mode. This will of - * course open a new scope, if applicable. - * - * Following this, close out any scope that's open. + * For an overstrike, if a previous character + * was wider, advance to center the new one. */ - if ('\0' != p->engine.ps.last) { - if (p->engine.ps.lastf != TERMFONT_NONE) { - ps_pclose(p); - ps_setfont(p, TERMFONT_NONE); - } - ps_pletter(p, p->engine.ps.last); - p->engine.ps.last = '\0'; + if (p->ps->pscolnext) { + wx = fonts[p->ps->lastf].gly[(int)p->ps->last-32].wx; + if (p->ps->pscol + wx < p->ps->pscolnext) + p->ps->pscol = (p->ps->pscol + + p->ps->pscolnext - wx) / 2; } - if ( ! (PS_INLINE & p->engine.ps.flags)) - return; + ps_pletter(p, p->ps->last); + p->ps->last = '\0'; - ps_pclose(p); + /* + * For an overstrike, if a previous character + * was wider, advance to the end of the old one. + */ + + if (p->ps->pscol < p->ps->pscolnext) { + ps_pclose(p); + p->ps->pscol = p->ps->pscolnext; + } } - static void -ps_letter(struct termp *p, char c) +ps_letter(struct termp *p, int arg) { - char cc; + size_t savecol; + char c; + c = arg >= 128 || arg <= 0 ? '?' : arg; + /* - * State machine dictates whether to buffer the last character - * or not. Basically, encoded words are detected by checking if - * we're an "8" and switching on the buffer. Then we put "8" in - * our buffer, and on the next charater, flush both character - * and buffer. Thus, "regular" words are detected by having a - * regular character and a regular buffer character. + * When receiving a backspace, merely flag it. + * We don't know yet whether it is + * a font instruction or an overstrike. */ - if ('\0' == p->engine.ps.last) { - assert(8 != c); - p->engine.ps.last = c; + if (c == '\b') { + assert(p->ps->last != '\0'); + assert( ! (p->ps->flags & PS_BACKSP)); + p->ps->flags |= PS_BACKSP; return; - } else if (8 == p->engine.ps.last) { - assert(8 != c); - p->engine.ps.last = '\0'; - } else if (8 == c) { - assert(8 != p->engine.ps.last); - if ('_' == p->engine.ps.last) { - if (p->engine.ps.lastf != TERMFONT_UNDER) { - ps_pclose(p); - ps_setfont(p, TERMFONT_UNDER); + } + + /* + * Decode font instructions. + */ + + if (p->ps->flags & PS_BACKSP) { + if (p->ps->last == '_') { + switch (p->ps->nextf) { + case TERMFONT_BI: + break; + case TERMFONT_BOLD: + p->ps->nextf = TERMFONT_BI; + break; + default: + p->ps->nextf = TERMFONT_UNDER; } - } else if (p->engine.ps.lastf != TERMFONT_BOLD) { - ps_pclose(p); - ps_setfont(p, TERMFONT_BOLD); + p->ps->last = c; + p->ps->flags &= ~PS_BACKSP; + return; } - p->engine.ps.last = c; - return; - } else { - if (p->engine.ps.lastf != TERMFONT_NONE) { - ps_pclose(p); - ps_setfont(p, TERMFONT_NONE); + if (p->ps->last == c) { + switch (p->ps->nextf) { + case TERMFONT_BI: + break; + case TERMFONT_UNDER: + p->ps->nextf = TERMFONT_BI; + break; + default: + p->ps->nextf = TERMFONT_BOLD; + } + p->ps->flags &= ~PS_BACKSP; + return; } - cc = p->engine.ps.last; - p->engine.ps.last = c; - c = cc; - } - ps_pletter(p, c); -} + /* + * This is not a font instruction, but rather + * the next character. Prepare for overstrike. + */ + savecol = p->ps->pscol; + } else + savecol = SIZE_MAX; + /* + * We found the next character, so the font instructions + * for the previous one are complete. + * Use them and print it. + */ + + ps_plast(p); + + /* + * Do not print the current character yet because font + * instructions might follow; only remember the character. + * It will get printed later from ps_plast(). + */ + + p->ps->last = c; + + /* + * For an overstrike, back up to the previous position. + * If the previous character is wider than any it overstrikes, + * remember the current position, because it might also be + * wider than all that will overstrike it. + */ + + if (savecol != SIZE_MAX) { + if (p->ps->pscolnext < p->ps->pscol) + p->ps->pscolnext = p->ps->pscol; + ps_pclose(p); + p->ps->pscol = savecol; + p->ps->flags &= ~PS_BACKSP; + } else + p->ps->pscolnext = 0; +} + static void ps_advance(struct termp *p, size_t len) { @@ -1023,35 +1176,36 @@ ps_advance(struct termp *p, size_t len) * and readjust our column settings. */ - ps_fclose(p); - p->engine.ps.pscol += len; + ps_plast(p); + ps_pclose(p); + p->ps->pscol += len; } - static void ps_endline(struct termp *p) { /* Close out any scopes we have open: we're at eoln. */ - ps_fclose(p); + ps_plast(p); + ps_pclose(p); /* * If we're in the margin, don't try to recalculate our current * row. XXX: if the column tries to be fancy with multiple - * lines, we'll do nasty stuff. + * lines, we'll do nasty stuff. */ - if (PS_MARGINS & p->engine.ps.flags) + if (PS_MARGINS & p->ps->flags) return; /* Left-justify. */ - p->engine.ps.pscol = p->engine.ps.left; + p->ps->pscol = p->ps->left; /* If we haven't printed anything, return. */ - if (PS_NEWPAGE & p->engine.ps.flags) + if (PS_NEWPAGE & p->ps->flags) return; /* @@ -1059,97 +1213,113 @@ ps_endline(struct termp *p) * showpage and restart our row. */ - if (p->engine.ps.psrow >= p->engine.ps.lineheight + - p->engine.ps.bottom) { - p->engine.ps.psrow -= p->engine.ps.lineheight; + if (p->ps->psrow >= p->ps->lineheight + p->ps->bottom) { + p->ps->psrow -= p->ps->lineheight; return; } ps_closepage(p); } - static void ps_setfont(struct termp *p, enum termfont f) { assert(f < TERMFONT__MAX); - p->engine.ps.lastf = f; - + p->ps->lastf = f; + /* * If we're still at the top of the page, let the font-setting * be delayed until we actually have stuff to print. */ - if (PS_NEWPAGE & p->engine.ps.flags) + if (PS_NEWPAGE & p->ps->flags) return; if (TERMTYPE_PS == p->type) - ps_printf(p, "/%s %zu selectfont\n", - fonts[(int)f].name, - p->engine.ps.scale); + ps_printf(p, "/%s %zu selectfont\n", + fonts[(int)f].name, p->ps->scale); else - ps_printf(p, "/F%d %zu Tf\n", - (int)f, - p->engine.ps.scale); + ps_printf(p, "/F%d %zu Tf\n", + (int)f, p->ps->scale); } - -/* ARGSUSED */ static size_t -ps_width(const struct termp *p, char c) +ps_width(const struct termp *p, int c) { if (c <= 32 || c - 32 >= MAXCHAR) - return((size_t)fonts[(int)TERMFONT_NONE].gly[0].wx); + c = 0; + else + c -= 32; - c -= 32; - return((size_t)fonts[(int)TERMFONT_NONE].gly[(int)c].wx); + return (size_t)fonts[(int)TERMFONT_NONE].gly[c].wx; } - -static double +static int ps_hspan(const struct termp *p, const struct roffsu *su) { double r; - + /* * All of these measurements are derived by converting from the * native measurement to AFM units. */ - switch (su->unit) { - case (SCALE_CM): - r = PNT2AFM(p, su->scale * 28.34); + case SCALE_BU: + /* + * Traditionally, the default unit is fixed to the + * output media. So this would refer to the point. In + * mandoc(1), however, we stick to the default terminal + * scaling unit so that output is the same regardless + * the media. + */ + r = PNT2AFM(p, su->scale * 72.0 / 240.0); break; - case (SCALE_IN): - r = PNT2AFM(p, su->scale * 72); + case SCALE_CM: + r = PNT2AFM(p, su->scale * 72.0 / 2.54); break; - case (SCALE_PC): - r = PNT2AFM(p, su->scale * 12); + case SCALE_EM: + r = su->scale * + fonts[(int)TERMFONT_NONE].gly[109 - 32].wx; break; - case (SCALE_PT): - r = PNT2AFM(p, su->scale * 100); - break; - case (SCALE_EM): + case SCALE_EN: r = su->scale * - fonts[(int)TERMFONT_NONE].gly[109 - 32].wx; + fonts[(int)TERMFONT_NONE].gly[110 - 32].wx; break; - case (SCALE_MM): - r = PNT2AFM(p, su->scale * 2.834); + case SCALE_IN: + r = PNT2AFM(p, su->scale * 72.0); break; - case (SCALE_EN): + case SCALE_MM: r = su->scale * - fonts[(int)TERMFONT_NONE].gly[110 - 32].wx; + fonts[(int)TERMFONT_NONE].gly[109 - 32].wx / 100.0; break; - case (SCALE_VS): - r = su->scale * p->engine.ps.lineheight; + case SCALE_PC: + r = PNT2AFM(p, su->scale * 12.0); break; + case SCALE_PT: + r = PNT2AFM(p, su->scale * 1.0); + break; + case SCALE_VS: + r = su->scale * p->ps->lineheight; + break; default: r = su->scale; break; } - return(r); + return r * 24.0; } +static void +ps_growbuf(struct termp *p, size_t sz) +{ + if (p->ps->psmargcur + sz <= p->ps->psmargsz) + return; + + if (sz < PS_BUFSLOP) + sz = PS_BUFSLOP; + + p->ps->psmargsz += sz; + p->ps->psmarg = mandoc_realloc(p->ps->psmarg, p->ps->psmargsz); +}