mandoc/term_ps.c - diff

Return to term_ps.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/term_ps.c between version 1.58 and 1.59

version 1.58, 2014/03/30 21:28:01

version 1.59, 2014/04/20 16:46:05

Line 40

#define PS_BUFSLOP 128

/* Convert PostScript point "x" to an AFM unit. */

#define PNT2AFM(p, x) /* LINTED */ \

#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 */ \

#define AFM2PNT(p, x) \

((double)(x) / (1000.0 / (double)(p)->ps->scale))

struct glyph {

Line 80 struct termp_ps {

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 */

Line 454 pspdf_alloc(char *outopts)

p->letter = ps_letter;

p->setwidth = ps_setwidth;

p->width = ps_width;

toks[0] = "paper";

toks[1] = NULL;

Line 462 pspdf_alloc(char *outopts)

while (outopts && *outopts)

switch (getsubopt(&outopts, UNCONST(toks), &v)) {

case (0):

case 0:

pp = v;

break;

default:

Line 498 pspdf_alloc(char *outopts)

fprintf(stderr, "%s: Unknown paper\n", pp);

}

* This MUST be defined before any PNT2AFM or AFM2PNT

* calculations occur.

Line 512 pspdf_alloc(char *outopts)

/* Margins are 1/9 the page x and y. */

marginx = /* LINTED */

marginx = (size_t)((double)pagex / 9.0);

(size_t)((double)pagex / 9.0);

marginy = (size_t)((double)pagey / 9.0);

marginy = /* LINTED */

(size_t)((double)pagey / 9.0);

/* Line-height is 1.4em. */

Line 534 pspdf_alloc(char *outopts)

Line 532 pspdf_alloc(char *outopts)

return(p);

}

static void

ps_setwidth(struct termp *p, int iop, size_t width)

{

Line 550 ps_setwidth(struct termp *p, int iop, size_t width)

Line 547 ps_setwidth(struct termp *p, int iop, size_t width)

p->ps->lastwidth = lastwidth;

}

void

pspdf_free(void *arg)

{

Line 567 pspdf_free(void *arg)

Line 563 pspdf_free(void *arg)

term_free(p);

}

static void

ps_printf(struct termp *p, const char *fmt, ...)

{

Line 585 ps_printf(struct termp *p, const char *fmt, ...)

Line 580 ps_printf(struct termp *p, const char *fmt, ...)

if ( ! (PS_MARGINS & p->ps->flags)) {

len = vprintf(fmt, ap);

va_end(ap);

p->ps->pdfbytes += /* LINTED */

p->ps->pdfbytes += len < 0 ? 0 : (size_t)len;

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.

Line 606 ps_printf(struct termp *p, const char *fmt, ...)

Line 600 ps_printf(struct termp *p, const char *fmt, ...)

p->ps->psmargcur = strlen(p->ps->psmarg);

}

static void

ps_putchar(struct termp *p, char c)

{

Line 615 ps_putchar(struct termp *p, char c)

Line 608 ps_putchar(struct termp *p, char c)

/* See ps_printf(). */

if ( ! (PS_MARGINS & p->ps->flags)) {

/* LINTED */

putchar(c);

p->ps->pdfbytes++;

return;

Line 628 ps_putchar(struct termp *p, char c)

Line 620 ps_putchar(struct termp *p, char c)

p->ps->psmarg[pos] = '\0';

}

static void

pdf_obj(struct termp *p, size_t obj)

{

Line 637 pdf_obj(struct termp *p, size_t obj)

Line 628 pdf_obj(struct termp *p, size_t obj)

if ((obj - 1) >= p->ps->pdfobjsz) {

p->ps->pdfobjsz = obj + 128;

p->ps->pdfobjs = realloc

p->ps->pdfobjs = realloc(p->ps->pdfobjs,

(p->ps->pdfobjs,

p->ps->pdfobjsz * sizeof(size_t));

if (NULL == p->ps->pdfobjs) {

perror(NULL);

exit((int)MANDOCLEVEL_SYSERR);

Line 650 pdf_obj(struct termp *p, size_t obj)

Line 640 pdf_obj(struct termp *p, size_t obj)

ps_printf(p, "%zu 0 obj\n", obj);

}

static void

ps_closepage(struct termp *p)

{

Line 683 ps_closepage(struct termp *p)

Line 672 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++)

ps_printf(p, "/F%d %d 0 R\n", i, 3 + i);

ps_printf(p, ">>\n>>\n");

Line 704 ps_closepage(struct termp *p)

Line 693 ps_closepage(struct termp *p)

p->ps->flags |= PS_NEWPAGE;

}

/* ARGSUSED */

static void

ps_end(struct termp *p)

{

Line 728 ps_end(struct termp *p)

Line 715 ps_end(struct termp *p)

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");

Line 740 ps_end(struct termp *p)

Line 727 ps_end(struct termp *p)

ps_printf(p, "/Kids [");

for (i = 0; i < p->ps->pages; i++)

ps_printf(p, " %zu 0 R", i * 4 +

ps_printf(p, " %zu 0 R", i * 4 + p->ps->pdfbody + 3);

p->ps->pdfbody + 3);

base = (p->ps->pages - 1) * 4 +

base = (p->ps->pages - 1) * 4 + p->ps->pdfbody + 4;

p->ps->pdfbody + 4;

ps_printf(p, "]\n>>\nendobj\n");

pdf_obj(p, base);

Line 758 ps_end(struct termp *p)

Line 743 ps_end(struct termp *p)

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");

Line 772 ps_end(struct termp *p)

Line 757 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.

Line 812 ps_begin(struct termp *p)

Line 796 ps_begin(struct termp *p)

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.

Line 827 ps_begin(struct termp *p)

Line 811 ps_begin(struct termp *p)

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");

for (i = 0; i < (int)TERMFONT__MAX; i++)

Line 861 ps_begin(struct termp *p)

Line 845 ps_begin(struct termp *p)

ps_setfont(p, TERMFONT_NONE);

}

static void

ps_pletter(struct termp *p, int c)

{

Line 874 ps_pletter(struct termp *p, int c)

Line 857 ps_pletter(struct termp *p, int c)

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, 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->pdfbody + 1 + p->ps->pages * 4);

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.

Line 900 ps_pletter(struct termp *p, int c)

Line 881 ps_pletter(struct termp *p, int c)

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,

(int)p->ps->lastf, p->ps->scale);

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;

}

Line 923 ps_pletter(struct termp *p, int c)

Line 903 ps_pletter(struct termp *p, int c)

switch (c) {

case ('('):

case '(':

/* FALLTHROUGH */

case (')'):

case ')':

/* FALLTHROUGH */

case ('\\'):

case '\\':

ps_putchar(p, '\\');

break;

default:

Line 942 ps_pletter(struct termp *p, int c)

Line 922 ps_pletter(struct termp *p, int c)

ps_putchar(p, ' ');

p->ps->pscol += (size_t)fonts[f].gly[0].wx;

return;

}

ps_putchar(p, (char)c);

c -= 32;

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).

Line 962 ps_pclose(struct termp *p)

Line 941 ps_pclose(struct termp *p)

if ( ! (PS_INLINE & p->ps->flags))

return;

if (TERMTYPE_PS != p->type) {

ps_printf(p, ") Tj\nET\n");

} else

Line 971 ps_pclose(struct termp *p)

Line 950 ps_pclose(struct termp *p)

p->ps->flags &= ~PS_INLINE;

}

static void

ps_fclose(struct termp *p)

{

Line 999 ps_fclose(struct termp *p)

Line 977 ps_fclose(struct termp *p)

ps_pclose(p);

}

static void

ps_letter(struct termp *p, int arg)

{

char cc, c;

/* LINTED */

c = arg >= 128 || arg <= 0 ? '?' : arg;

Line 1050 ps_letter(struct termp *p, int arg)

Line 1026 ps_letter(struct termp *p, int arg)

ps_pletter(p, c);

}

static void

ps_advance(struct termp *p, size_t len)

{

Line 1066 ps_advance(struct termp *p, size_t len)

Line 1041 ps_advance(struct termp *p, size_t len)

p->ps->pscol += len;

}

static void

ps_endline(struct termp *p)

{

Line 1078 ps_endline(struct termp *p)

Line 1052 ps_endline(struct termp *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.

if (PS_MARGINS & p->ps->flags)

Line 1098 ps_endline(struct termp *p)

Line 1072 ps_endline(struct termp *p)

* showpage and restart our row.

if (p->ps->psrow >= p->ps->lineheight +

if (p->ps->psrow >= p->ps->lineheight + p->ps->bottom) {

p->ps->bottom) {

p->ps->psrow -= p->ps->lineheight;

return;

}

Line 1107 ps_endline(struct termp *p)

Line 1080 ps_endline(struct termp *p)

ps_closepage(p);

}

static void

ps_setfont(struct termp *p, enum termfont f)

{

assert(f < TERMFONT__MAX);

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.

Line 1124 ps_setfont(struct termp *p, enum termfont f)

Line 1096 ps_setfont(struct termp *p, enum termfont f)

return;

if (TERMTYPE_PS == p->type)

ps_printf(p, "/%s %zu selectfont\n",

fonts[(int)f].name,

fonts[(int)f].name, p->ps->scale);

p->ps->scale);

else

ps_printf(p, "/F%d %zu Tf\n",

(int)f,

(int)f, p->ps->scale);

p->ps->scale);

}

/* ARGSUSED */

static size_t

ps_width(const struct termp *p, int c)

{

Line 1146 ps_width(const struct termp *p, int c)

Line 1114 ps_width(const struct termp *p, int c)

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):

case SCALE_CM:

r = PNT2AFM(p, su->scale * 28.34);

break;

case (SCALE_IN):

case SCALE_IN:

r = PNT2AFM(p, su->scale * 72);

break;

case (SCALE_PC):

case SCALE_PC:

r = PNT2AFM(p, su->scale * 12);

break;

case (SCALE_PT):

case SCALE_PT:

r = PNT2AFM(p, su->scale * 100);

break;

case (SCALE_EM):

case SCALE_EM:

r = su->scale *

fonts[(int)TERMFONT_NONE].gly[109 - 32].wx;

break;

case (SCALE_MM):

case SCALE_MM:

r = PNT2AFM(p, su->scale * 2.834);

break;

case (SCALE_EN):

case SCALE_EN:

r = su->scale *

fonts[(int)TERMFONT_NONE].gly[110 - 32].wx;

break;

case (SCALE_VS):

case SCALE_VS:

r = su->scale * p->ps->lineheight;

break;

default:

Line 1206 ps_growbuf(struct termp *p, size_t sz)

Line 1173 ps_growbuf(struct termp *p, size_t sz)

p->ps->psmarg = mandoc_realloc

(p->ps->psmarg, p->ps->psmargsz);

}

CVSweb