=================================================================== RCS file: /cvs/mandoc/term_ps.c,v retrieving revision 1.18 retrieving revision 1.51 diff -u -p -r1.18 -r1.51 --- mandoc/term_ps.c 2010/06/30 11:45:21 1.18 +++ mandoc/term_ps.c 2011/05/17 14:38:34 1.51 @@ -1,6 +1,6 @@ -/* $Id: term_ps.c,v 1.18 2010/06/30 11:45:21 kristaps Exp $ */ +/* $Id: term_ps.c,v 1.51 2011/05/17 14:38:34 kristaps Exp $ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons + * Copyright (c) 2010 Kristaps Dzonsons * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,7 +18,7 @@ #include "config.h" #endif -#include +#include #include #include @@ -27,13 +27,26 @@ #include #include #include +#include +#include "mandoc.h" #include "out.h" #include "main.h" #include "term.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)->ps->scale)) + +/* Convert an AFM unit "x" to a PostScript points */ +#define AFM2PNT(p, x) /* LINTED */ \ + ((double)(x) / (1000.0 / (double)(p)->ps->scale)) + struct glyph { - int wx; /* WX in AFM */ + unsigned short wx; /* WX in AFM */ }; struct font { @@ -42,6 +55,54 @@ 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 */ + size_t pscol; /* visible column (AFM units) */ + 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; /* character buffer */ + enum termfont lastf; /* last set font */ + 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 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 double 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_fclose(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_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); + /* * We define, for the time being, three fonts: bold, oblique/italic, and * normal (roman). The following table hard-codes the font metrics for @@ -49,400 +110,436 @@ struct font { */ static const struct font fonts[TERMFONT__MAX] = { - { "Courier", { - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, + { "Times-Roman", { + { 250 }, + { 333 }, + { 408 }, + { 500 }, + { 500 }, + { 833 }, + { 778 }, + { 333 }, + { 333 }, + { 333 }, + { 500 }, + { 564 }, + { 250 }, + { 333 }, + { 250 }, + { 278 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 278 }, + { 278 }, + { 564 }, + { 564 }, + { 564 }, + { 444 }, + { 921 }, + { 722 }, + { 667 }, + { 667 }, + { 722 }, + { 611 }, + { 556 }, + { 722 }, + { 722 }, + { 333 }, + { 389 }, + { 722 }, + { 611 }, + { 889 }, + { 722 }, + { 722 }, + { 556 }, + { 722 }, + { 667 }, + { 556 }, + { 611 }, + { 722 }, + { 722 }, + { 944 }, + { 722 }, + { 722 }, + { 611 }, + { 333 }, + { 278 }, + { 333 }, + { 469 }, + { 500 }, + { 333 }, + { 444 }, + { 500 }, + { 444 }, + { 500}, + { 444}, + { 333}, + { 500}, + { 500}, + { 278}, + { 278}, + { 500}, + { 278}, + { 778}, + { 500}, + { 500}, + { 500}, + { 500}, + { 333}, + { 389}, + { 278}, + { 500}, + { 500}, + { 722}, + { 500}, + { 500}, + { 444}, + { 480}, + { 200}, + { 480}, + { 541}, } }, - { "Courier-Bold", { - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, + { "Times-Bold", { + { 250 }, + { 333 }, + { 555 }, + { 500 }, + { 500 }, + { 1000 }, + { 833 }, + { 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 }, + { 930 }, + { 722 }, + { 667 }, + { 722 }, + { 722 }, + { 667 }, + { 611 }, + { 778 }, + { 778 }, + { 389 }, + { 500 }, + { 778 }, + { 667 }, + { 944 }, + { 722 }, + { 778 }, + { 611 }, + { 778 }, + { 722 }, + { 556 }, + { 667 }, + { 722 }, + { 722 }, + { 1000 }, + { 722 }, + { 722 }, + { 667 }, + { 333 }, + { 278 }, + { 333 }, + { 581 }, + { 500 }, + { 333 }, + { 500 }, + { 556 }, + { 444 }, + { 556 }, + { 444 }, + { 333 }, + { 500 }, + { 556 }, + { 278 }, + { 333 }, + { 556 }, + { 278 }, + { 833 }, + { 556 }, + { 500 }, + { 556 }, + { 556 }, + { 444 }, + { 389 }, + { 333 }, + { 556 }, + { 500 }, + { 722 }, + { 500 }, + { 500 }, + { 444 }, + { 394 }, + { 220 }, + { 394 }, + { 520 }, } }, - { "Courier-Oblique", { - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, - { 600 }, + { "Times-Italic", { + { 250 }, + { 333 }, + { 420 }, + { 500 }, + { 500 }, + { 833 }, + { 778 }, + { 333 }, + { 333 }, + { 333 }, + { 500 }, + { 675 }, + { 250 }, + { 333 }, + { 250 }, + { 278 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 333 }, + { 333 }, + { 675 }, + { 675 }, + { 675 }, + { 500 }, + { 920 }, + { 611 }, + { 611 }, + { 667 }, + { 722 }, + { 611 }, + { 611 }, + { 722 }, + { 722 }, + { 333 }, + { 444 }, + { 667 }, + { 556 }, + { 833 }, + { 667 }, + { 722 }, + { 611 }, + { 722 }, + { 611 }, + { 500 }, + { 556 }, + { 722 }, + { 611 }, + { 833 }, + { 611 }, + { 556 }, + { 556 }, + { 389 }, + { 278 }, + { 389 }, + { 422 }, + { 500 }, + { 333 }, + { 500 }, + { 500 }, + { 444 }, + { 500 }, + { 444 }, + { 278 }, + { 500 }, + { 500 }, + { 278 }, + { 278 }, + { 444 }, + { 278 }, + { 722 }, + { 500 }, + { 500 }, + { 500 }, + { 500 }, + { 389 }, + { 389 }, + { 278 }, + { 500 }, + { 444 }, + { 667 }, + { 444 }, + { 444 }, + { 389 }, + { 400 }, + { 275 }, + { 400 }, + { 541 }, } }, }; -/* These work the buffer used by the header and footer. */ -#define PS_BUFSLOP 128 -#define PS_GROWBUF(p, sz) \ - do if ((p)->engine.ps.psmargcur + (sz) > \ - (p)->engine.ps.psmargsz) { \ - (p)->engine.ps.psmargsz += /* CONSTCOND */ \ - MAX(PS_BUFSLOP, (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); \ - } \ - } while (/* CONSTCOND */ 0) +void * +pdf_alloc(char *outopts) +{ + struct termp *p; + if (NULL != (p = pspdf_alloc(outopts))) + p->type = TERMTYPE_PDF; -static void ps_letter(struct termp *, char); -static void ps_begin(struct termp *); -static void ps_end(struct termp *); -static void ps_advance(struct termp *, size_t); -static void ps_endline(struct termp *); -static void ps_fclose(struct termp *); -static size_t ps_width(const 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); + return(p); +} - void * ps_alloc(char *outopts) { struct termp *p; - size_t pagex, pagey, margin, lineheight; + + if (NULL != (p = pspdf_alloc(outopts))) + p->type = TERMTYPE_PS; + + return(p); +} + +static struct termp * +pspdf_alloc(char *outopts) +{ + struct termp *p; + size_t pagex, pagey, marginx, marginy, lineheight; const char *toks[2]; - const char *paper; + 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->ps = mandoc_calloc(1, sizeof(struct termp_ps)); - p->type = TERMTYPE_PS; - p->letter = ps_letter; + p->advance = ps_advance; p->begin = ps_begin; p->end = ps_end; - p->advance = ps_advance; p->endline = ps_endline; + p->hspan = ps_hspan; + p->letter = ps_letter; p->width = ps_width; - + toks[0] = "paper"; toks[1] = NULL; + pp = NULL; + while (outopts && *outopts) switch (getsubopt(&outopts, UNCONST(toks), &v)) { case (0): - paper = v; + pp = v; break; default: break; } - if (0 == strcasecmp(paper, "a4")) { - pagex = 595 * 100; - pagey = 842 * 100; - } else { - pagex = 612 * 100; - pagey = 792 * 100; - } + /* Default to US letter (millimetres). */ - margin = 72 * 100; - lineheight = 12 * 100; + pagex = 216; + pagey = 279; - assert(margin * 2 < pagex); - assert(margin * 2 < pagey); + /* + * The ISO-269 paper sizes can be calculated automatically, but + * it would require bringing in -lm for pow() and I'd rather not + * do that. So just do it the easy way for now. Since this + * only happens once, I'm not terribly concerned. + */ - p->engine.ps.width = pagex; - p->engine.ps.height = pagey; - p->engine.ps.header = pagey - (margin / 2); - p->engine.ps.top = pagey - margin; - p->engine.ps.footer = (margin / 2); - p->engine.ps.bottom = margin; - p->engine.ps.left = margin; - p->engine.ps.lineheight = lineheight; + if (pp && strcasecmp(pp, "letter")) { + if (0 == strcasecmp(pp, "a3")) { + pagex = 297; + pagey = 420; + } else if (0 == strcasecmp(pp, "a4")) { + pagex = 210; + pagey = 297; + } else if (0 == strcasecmp(pp, "a5")) { + pagex = 148; + pagey = 210; + } 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"; - p->defrmargin = pagex - (margin * 2); + /* + * This MUST be defined before any PNT2AFM or AFM2PNT + * calculations occur. + */ + + p->ps->scale = 11; + + /* Remember millimetres -> AFM units. */ + + pagex = PNT2AFM(p, ((double)pagex * 2.834)); + pagey = PNT2AFM(p, ((double)pagey * 2.834)); + + /* 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); + + /* Line-height is 1.4em. */ + + lineheight = PNT2AFM(p, ((double)p->ps->scale * 1.4)); + + p->ps->width = pagex; + p->ps->height = 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); } void -ps_free(void *arg) +pspdf_free(void *arg) { struct termp *p; p = (struct termp *)arg; - if (p->engine.ps.psmarg) - free(p->engine.ps.psmarg); + if (p->ps->psmarg) + free(p->ps->psmarg); + if (p->ps->pdfobjs) + free(p->ps->pdfobjs); + free(p->ps); term_free(p); } @@ -451,7 +548,7 @@ static void ps_printf(struct termp *p, const char *fmt, ...) { va_list ap; - int pos; + int pos, len; va_start(ap, fmt); @@ -461,9 +558,11 @@ ps_printf(struct termp *p, const char *fmt, ...) * into our growable margin buffer. */ - if ( ! (PS_MARGINS & p->engine.ps.psstate)) { - vprintf(fmt, ap); + if ( ! (PS_MARGINS & p->ps->flags)) { + len = vprintf(fmt, ap); va_end(ap); + p->ps->pdfbytes += /* LINTED */ + len < 0 ? 0 : (size_t)len; return; } @@ -473,13 +572,14 @@ ps_printf(struct termp *p, const char *fmt, ...) * assumption that will cause pukeage if it's not the case. */ - PS_GROWBUF(p, PS_BUFSLOP); + ps_growbuf(p, PS_BUFSLOP); - pos = (int)p->engine.ps.psmargcur; - vsnprintf(&p->engine.ps.psmarg[pos], PS_BUFSLOP, fmt, ap); - p->engine.ps.psmargcur = strlen(p->engine.ps.psmarg); + pos = (int)p->ps->psmargcur; + len = vsnprintf(&p->ps->psmarg[pos], PS_BUFSLOP, fmt, ap); va_end(ap); + + p->ps->psmargcur = strlen(p->ps->psmarg); } @@ -490,23 +590,102 @@ ps_putchar(struct termp *p, char c) /* See ps_printf(). */ - if ( ! (PS_MARGINS & p->engine.ps.psstate)) { + if ( ! (PS_MARGINS & p->ps->flags)) { + /* LINTED */ putchar(c); + p->ps->pdfbytes++; return; } - PS_GROWBUF(p, 2); + 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->ps->pdfobjsz) { + p->ps->pdfobjsz = obj + 128; + p->ps->pdfobjs = realloc + (p->ps->pdfobjs, + p->ps->pdfobjsz * sizeof(size_t)); + if (NULL == p->ps->pdfobjs) { + perror(NULL); + exit((int)MANDOCLEVEL_SYSERR); + } + } + + p->ps->pdfobjs[(int)obj - 1] = p->ps->pdfbytes; + ps_printf(p, "%zu 0 obj\n", obj); +} + + +static void +ps_closepage(struct termp *p) +{ + int i; + size_t len, base; + + /* + * Close out a page that we've already flushed to output. In + * PostScript, we simply note that the page must be showed. In + * PDF, we must now create the Length, Resource, and Page node + * for the page contents. + */ + + 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->ps->pdfbytes - p->ps->pdflastpg; + base = p->ps->pages * 4 + p->ps->pdfbody; + + ps_printf(p, "endstream\nendobj\n"); + + /* Length of content. */ + pdf_obj(p, base + 1); + ps_printf(p, "%zu\nendobj\n", len); + + /* Resource for content. */ + 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++) + ps_printf(p, "/F%d %d 0 R\n", i, 3 + i); + ps_printf(p, ">>\n>>\n"); + + /* Page node. */ + pdf_obj(p, base + 3); + ps_printf(p, "<<\n"); + ps_printf(p, "/Type /Page\n"); + ps_printf(p, "/Parent 2 0 R\n"); + ps_printf(p, "/Resources %zu 0 R\n", base + 2); + ps_printf(p, "/Contents %zu 0 R\n", base); + ps_printf(p, ">>\nendobj\n"); + } else + ps_printf(p, "showpage\n"); + + 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; /* * At the end of the file, do one last showpage. This is the @@ -514,16 +693,59 @@ ps_end(struct termp *p) * well as just one. */ - assert(0 == p->engine.ps.psstate); - assert('\0' == p->engine.ps.last); - assert(p->engine.ps.psmarg && p->engine.ps.psmarg[0]); - printf("%s", p->engine.ps.psmarg); - p->engine.ps.pages++; - printf("showpage\n"); + if ( ! (PS_NEWPAGE & p->ps->flags)) { + assert(0 == p->ps->flags); + assert('\0' == p->ps->last); + ps_closepage(p); + } - printf("%%%%Trailer\n"); - printf("%%%%Pages: %zu\n", p->engine.ps.pages); - printf("%%%%EOF\n"); + if (TERMTYPE_PS == p->type) { + ps_printf(p, "%%%%Trailer\n"); + 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->ps->width), + (size_t)AFM2PNT(p, p->ps->height)); + + ps_printf(p, "/Count %zu\n", p->ps->pages); + ps_printf(p, "/Kids ["); + + for (i = 0; i < p->ps->pages; i++) + ps_printf(p, " %zu 0 R", i * 4 + + p->ps->pdfbody + 3); + + base = (p->ps->pages - 1) * 4 + + p->ps->pdfbody + 4; + + ps_printf(p, "]\n>>\nendobj\n"); + pdf_obj(p, base); + ps_printf(p, "<<\n"); + ps_printf(p, "/Type /Catalog\n"); + ps_printf(p, "/Pages 2 0 R\n"); + ps_printf(p, ">>\n"); + 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->ps->pdfobjs[(int)i]); + + ps_printf(p, "trailer\n"); + ps_printf(p, "<<\n"); + ps_printf(p, "/Size %zu\n", base + 1); + ps_printf(p, "/Root %zu 0 R\n", base); + ps_printf(p, "/Info 1 0 R\n"); + ps_printf(p, ">>\n"); + ps_printf(p, "startxref\n"); + ps_printf(p, "%zu\n", xref); + ps_printf(p, "%%%%EOF\n"); } @@ -538,32 +760,33 @@ ps_begin(struct termp *p) * 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.psmargcur = 0; - p->engine.ps.psstate = 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.psstate &= ~PS_MARGINS; + p->ps->flags &= ~PS_MARGINS; - assert(0 == p->engine.ps.psstate); - 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, @@ -572,29 +795,46 @@ ps_begin(struct termp *p) t = time(NULL); - printf("%%!PS-Adobe-3.0\n"); - printf("%%%%Creator: mandoc-%s\n", VERSION); - printf("%%%%CreationDate: %s", ctime(&t)); - printf("%%%%DocumentData: Clean7Bit\n"); - printf("%%%%Orientation: Portrait\n"); - printf("%%%%Pages: (atend)\n"); - printf("%%%%PageOrder: Ascend\n"); - printf("%%%%Orientation: Portrait\n"); - printf("%%%%DocumentMedia: Default %zu %zu 0 () ()\n", - p->engine.ps.width, - p->engine.ps.height); - printf("%%%%DocumentNeededResources: font"); - for (i = 0; i < (int)TERMFONT__MAX; i++) - printf(" %s", fonts[i].name); - printf("\n%%%%EndComments\n"); + if (TERMTYPE_PS == p->type) { + ps_printf(p, "%%!PS-Adobe-3.0\n"); + 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->ps->width), + (size_t)AFM2PNT(p, p->ps->height)); + ps_printf(p, "%%%%DocumentNeededResources: font"); - printf("%%%%Page: %zu %zu\n", - p->engine.ps.pages + 1, - p->engine.ps.pages + 1); + for (i = 0; i < (int)TERMFONT__MAX; i++) + ps_printf(p, " %s", fonts[i].name); + ps_printf(p, "\n%%%%EndComments\n"); + } else { + ps_printf(p, "%%PDF-1.1\n"); + pdf_obj(p, 1); + ps_printf(p, "<<\n"); + ps_printf(p, ">>\n"); + ps_printf(p, "endobj\n"); + + for (i = 0; i < (int)TERMFONT__MAX; i++) { + pdf_obj(p, (size_t)i + 3); + 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, "/BaseFont /%s\n", fonts[i].name); + ps_printf(p, ">>\n"); + } + } + + 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); - p->engine.ps.pscol = p->engine.ps.left; - p->engine.ps.psrow = p->engine.ps.top; } @@ -602,19 +842,55 @@ static void ps_pletter(struct termp *p, int c) { int f; + + /* + * If we haven't opened a page context, then output that we're + * in a new page and make sure the font is correctly set. + */ + + if (PS_NEWPAGE & p->ps->flags) { + if (TERMTYPE_PS == p->type) { + 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->ps->pdfbody + + p->ps->pages * 4); + ps_printf(p, "<<\n"); + ps_printf(p, "/Length %zu 0 R\n", + p->ps->pdfbody + 1 + + p->ps->pages * 4); + ps_printf(p, ">>\nstream\n"); + } + 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.psstate)) { - ps_printf(p, "%zu %zu moveto\n(", - (size_t)(p->engine.ps.pscol / 100), - (size_t)(p->engine.ps.psrow / 100)); - p->engine.ps.psstate |= PS_INLINE; + if ( ! (PS_INLINE & p->ps->flags)) { + if (TERMTYPE_PS != p->type) { + 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->ps->pscol), + AFM2PNT(p, p->ps->psrow)); + } else + 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->ps->flags)); + /* * We need to escape these characters as per the PostScript * specification. We would also escape non-graphable characters @@ -636,17 +912,17 @@ 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)) { + if (c <= 32 || (c - 32 >= MAXCHAR)) { ps_putchar(p, ' '); - p->engine.ps.pscol += fonts[f].gly[0].wx; + p->ps->pscol += (size_t)fonts[f].gly[0].wx; return; } - ps_putchar(p, c); + ps_putchar(p, (char)c); c -= 32; - p->engine.ps.pscol += fonts[f].gly[c].wx; + p->ps->pscol += (size_t)fonts[f].gly[c].wx; } @@ -660,11 +936,15 @@ ps_pclose(struct termp *p) * or anything). */ - if ( ! (PS_INLINE & p->engine.ps.psstate)) + if ( ! (PS_INLINE & p->ps->flags)) return; - ps_printf(p, ") show\n"); - p->engine.ps.psstate &= ~PS_INLINE; + if (TERMTYPE_PS != p->type) { + ps_printf(p, ") Tj\nET\n"); + } else + ps_printf(p, ") show\n"); + + p->ps->flags &= ~PS_INLINE; } @@ -680,16 +960,16 @@ ps_fclose(struct termp *p) * Following this, close out any scope that's open. */ - if ('\0' != p->engine.ps.last) { - if (p->engine.ps.lastf != TERMFONT_NONE) { + if ('\0' != p->ps->last) { + if (p->ps->lastf != TERMFONT_NONE) { ps_pclose(p); ps_setfont(p, TERMFONT_NONE); } - ps_pletter(p, p->engine.ps.last); - p->engine.ps.last = '\0'; + ps_pletter(p, p->ps->last); + p->ps->last = '\0'; } - if ( ! (PS_INLINE & p->engine.ps.psstate)) + if ( ! (PS_INLINE & p->ps->flags)) return; ps_pclose(p); @@ -697,10 +977,13 @@ ps_fclose(struct termp *p) static void -ps_letter(struct termp *p, char c) +ps_letter(struct termp *p, int arg) { - char cc; + char cc, c; + /* LINTED */ + 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 @@ -710,33 +993,33 @@ ps_letter(struct termp *p, char c) * regular character and a regular buffer character. */ - if ('\0' == p->engine.ps.last) { + if ('\0' == p->ps->last) { assert(8 != c); - p->engine.ps.last = c; + p->ps->last = c; return; - } else if (8 == p->engine.ps.last) { + } else if (8 == p->ps->last) { assert(8 != c); - p->engine.ps.last = '\0'; + p->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) { + assert(8 != p->ps->last); + if ('_' == p->ps->last) { + if (p->ps->lastf != TERMFONT_UNDER) { ps_pclose(p); ps_setfont(p, TERMFONT_UNDER); } - } else if (p->engine.ps.lastf != TERMFONT_BOLD) { + } else if (p->ps->lastf != TERMFONT_BOLD) { ps_pclose(p); ps_setfont(p, TERMFONT_BOLD); } - p->engine.ps.last = c; + p->ps->last = c; return; } else { - if (p->engine.ps.lastf != TERMFONT_NONE) { + if (p->ps->lastf != TERMFONT_NONE) { ps_pclose(p); ps_setfont(p, TERMFONT_NONE); } - cc = p->engine.ps.last; - p->engine.ps.last = c; + cc = p->ps->last; + p->ps->last = c; c = cc; } @@ -756,7 +1039,7 @@ ps_advance(struct termp *p, size_t len) */ ps_fclose(p); - p->engine.ps.pscol += len; + p->ps->pscol += len; } @@ -774,29 +1057,30 @@ ps_endline(struct termp *p) * lines, we'll do nasty stuff. */ - if (PS_MARGINS & p->engine.ps.psstate) + if (PS_MARGINS & p->ps->flags) return; + /* Left-justify. */ + + p->ps->pscol = p->ps->left; + + /* If we haven't printed anything, return. */ + + if (PS_NEWPAGE & p->ps->flags) + return; + /* * Put us down a line. If we're at the page bottom, spit out a * showpage and restart our row. */ - p->engine.ps.pscol = p->engine.ps.left; - 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; } - assert(p->engine.ps.psmarg && p->engine.ps.psmarg[0]); - printf("%s", p->engine.ps.psmarg); - printf("%%%%Page: %zu %zu\n", - p->engine.ps.pages + 1, - p->engine.ps.pages + 1); - printf("showpage\n"); - p->engine.ps.pages++; - p->engine.ps.psrow = p->engine.ps.top; + ps_closepage(p); } @@ -805,19 +1089,97 @@ ps_setfont(struct termp *p, enum termfont f) { assert(f < TERMFONT__MAX); - ps_printf(p, "/%s 10 selectfont\n", fonts[(int)f].name); - 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->ps->flags) + return; + + if (TERMTYPE_PS == p->type) + 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->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(fonts[(int)TERMFONT_NONE].gly[0].wx); + return((size_t)fonts[(int)TERMFONT_NONE].gly[0].wx); c -= 32; - return(fonts[(int)TERMFONT_NONE].gly[(int)c].wx); + return((size_t)fonts[(int)TERMFONT_NONE].gly[c].wx); } + + +static double +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); + break; + case (SCALE_IN): + r = PNT2AFM(p, su->scale * 72); + break; + case (SCALE_PC): + r = PNT2AFM(p, su->scale * 12); + break; + case (SCALE_PT): + r = PNT2AFM(p, su->scale * 100); + break; + case (SCALE_EM): + r = su->scale * + fonts[(int)TERMFONT_NONE].gly[109 - 32].wx; + break; + case (SCALE_MM): + r = PNT2AFM(p, su->scale * 2.834); + break; + case (SCALE_EN): + r = su->scale * + fonts[(int)TERMFONT_NONE].gly[110 - 32].wx; + break; + case (SCALE_VS): + r = su->scale * p->ps->lineheight; + break; + default: + r = su->scale; + break; + } + + return(r); +} + +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); +} +