mirror of
https://github.com/9fans/plan9port.git
synced 2025-01-15 11:20:03 +00:00
259 lines
6.3 KiB
C
259 lines
6.3 KiB
C
/*
|
|
output language from troff:
|
|
all numbers are character strings
|
|
|
|
sn size in points
|
|
fn font as number from 1-n
|
|
cx ascii character x
|
|
Cxyz funny char xyz. terminated by white space
|
|
Nn absolute character number n on this font. ditto
|
|
Hn go to absolute horizontal position n
|
|
Vn go to absolute vertical position n (down is positive)
|
|
hn go n units horizontally (relative)
|
|
vn ditto vertically
|
|
nnc move right nn, then print c (exactly 2 digits!)
|
|
(this wart is an optimization that shrinks output file size
|
|
about 35% and run-time about 15% while preserving ascii-ness)
|
|
Dt ...\n draw operation 't':
|
|
Dl x y line from here by x,y
|
|
Dc d circle of diameter d with left side here
|
|
De x y ellipse of axes x,y with left side here
|
|
Da dx dy dx dy arc counter-clockwise, center at dx,dx, end at dx,dy
|
|
D~ x y x y ... wiggly line by x,y then x,y ...
|
|
nb a end of line (information only -- no action needed)
|
|
w paddable word space -- no action needed
|
|
b = space before line, a = after
|
|
p new page begins -- set v to 0
|
|
#...\n comment
|
|
x ...\n device control functions:
|
|
x i init
|
|
x T s name of device is s
|
|
x r n h v resolution is n/inch
|
|
h = min horizontal motion, v = min vert
|
|
x p pause (can restart)
|
|
x s stop -- done for ever
|
|
x t generate trailer
|
|
x f n s font position n contains font s
|
|
x H n set character height to n
|
|
x S n set slant to N
|
|
|
|
Subcommands like "i" are often spelled out like "init".
|
|
*/
|
|
|
|
#include <u.h>
|
|
#include <libc.h>
|
|
#include <draw.h>
|
|
#include <bio.h>
|
|
|
|
#define hmot(n) hpos += n
|
|
#define hgoto(n) hpos = n
|
|
#define vmot(n) vgoto(vpos + n)
|
|
#define vgoto(n) vpos = n
|
|
|
|
#define putchar(x) Bprint(&bout, "%C", x)
|
|
|
|
int hpos; /* horizontal position where we are supposed to be next (left = 0) */
|
|
int vpos; /* current vertical position (down positive) */
|
|
char *fontfile = "/lib/font/bit/pelm/unicode.9x24.font";
|
|
|
|
char *pschar(char *, char *hex, int *wid, int *ht);
|
|
int kanji(char *);
|
|
void Bgetstr(Biobuf *bp, char *s);
|
|
void Bgetline(Biobuf *bp, char *s);
|
|
void Bgetint(Biobuf *bp, int *n);
|
|
|
|
Biobuf bin, bout;
|
|
|
|
void
|
|
main(void)
|
|
{
|
|
int c, n;
|
|
char str[100], *args[10];
|
|
int jfont, curfont;
|
|
|
|
if(initdraw(0, fontfile, 0) < 0){
|
|
fprint(2, "mnihongo: can't initialize display: %r\n");
|
|
exits("open");
|
|
}
|
|
Binit(&bin, 0, OREAD);
|
|
Binit(&bout, 1, OWRITE);
|
|
|
|
jfont = -1;
|
|
curfont = 1;
|
|
while ((c = Bgetc(&bin)) >= 0) {
|
|
switch (c) {
|
|
case '\n': /* when input is text */
|
|
case ' ':
|
|
case '\0': /* occasional noise creeps in */
|
|
putchar(c);
|
|
break;
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
/* two motion digits plus a character */
|
|
putchar(c); /* digit 1 */
|
|
n = (c-'0')*10;
|
|
c = Bgetc(&bin);
|
|
putchar(c); /* digit 2 */
|
|
n += c - '0';
|
|
hmot(n);
|
|
putchar(Bgetc(&bin)); /* char itself */
|
|
break;
|
|
case 'c': /* single character */
|
|
c = Bgetrune(&bin);
|
|
if(c==' ') /* why does this happen? it's troff - bwk */
|
|
break;
|
|
else if(jfont == curfont){
|
|
Bungetrune(&bin);
|
|
Bgetstr(&bin, str);
|
|
kanji(str);
|
|
}else{
|
|
putchar('c');
|
|
putchar(c);
|
|
}
|
|
break;
|
|
case 'C':
|
|
Bgetstr(&bin, str);
|
|
Bprint(&bout, "C%s", str);
|
|
break;
|
|
case 'f':
|
|
Bgetstr(&bin, str);
|
|
curfont = atoi(str);
|
|
if(curfont < 0 || curfont > 20)
|
|
curfont = 1; /* sanity */
|
|
Bprint(&bout, "%c%s", c, str);
|
|
break;
|
|
case 'N': /* absolute character number */
|
|
case 's':
|
|
case 'p': /* new page */
|
|
Bgetint(&bin, &n);
|
|
Bprint(&bout, "%c%d", c, n);
|
|
break;
|
|
case 'H': /* absolute horizontal motion */
|
|
Bgetint(&bin, &n);
|
|
Bprint(&bout, "%c%d", c, n);
|
|
hgoto(n);
|
|
break;
|
|
case 'h': /* relative horizontal motion */
|
|
Bgetint(&bin, &n);
|
|
Bprint(&bout, "%c%d", c, n);
|
|
hmot(n);
|
|
break;
|
|
case 'V':
|
|
Bgetint(&bin, &n);
|
|
Bprint(&bout, "%c%d", c, n);
|
|
vgoto(n);
|
|
break;
|
|
case 'v':
|
|
Bgetint(&bin, &n);
|
|
Bprint(&bout, "%c%d", c, n);
|
|
vmot(n);
|
|
break;
|
|
|
|
case 'w': /* word space */
|
|
putchar(c);
|
|
break;
|
|
|
|
case 'x': /* device control */
|
|
Bgetline(&bin, str);
|
|
Bprint(&bout, "%c%s", c, str);
|
|
if(tokenize(str, args, 10)>2 && args[0][0]=='f' && ('0'<=args[1][0] && args[1][0]<='9')){
|
|
if(strncmp(args[2], "Jp", 2) == 0)
|
|
jfont = atoi(args[1]);
|
|
else if(atoi(args[1]) == jfont)
|
|
jfont = -1;
|
|
}
|
|
break;
|
|
|
|
case 'D': /* draw function */
|
|
case 'n': /* end of line */
|
|
case '#': /* comment */
|
|
Bgetline(&bin, str);
|
|
Bprint(&bout, "%c%s", c, str);
|
|
break;
|
|
default:
|
|
fprint(2, "mnihongo: unknown input character %o %c\n", c, c);
|
|
exits("error");
|
|
}
|
|
}
|
|
}
|
|
|
|
int kanji(char *s) /* very special pleading */
|
|
{ /* dump as kanji char if looks like one */
|
|
Rune r;
|
|
char hex[500];
|
|
int size = 10, ht, wid;
|
|
|
|
chartorune(&r, s);
|
|
pschar(s, hex, &wid, &ht);
|
|
Bprint(&bout, "x X PS save %d %d m\n", hpos, vpos);
|
|
Bprint(&bout, "x X PS currentpoint translate %d %d scale ptsize dup scale\n", size, size);
|
|
Bprint(&bout, "x X PS %d %d true [%d 0 0 -%d 0 %d]\n",
|
|
wid, ht, wid, wid, ht-2); /* kludge; ought to use ->ascent */
|
|
Bprint(&bout, "x X PS {<%s>}\n", hex);
|
|
Bprint(&bout, "x X PS imagemask restore\n");
|
|
return 1;
|
|
}
|
|
|
|
char *pschar(char *s, char *hex, int *wid, int *ht)
|
|
{
|
|
Point chpt, spt;
|
|
Image *b;
|
|
uchar rowdata[100];
|
|
char *hp = hex;
|
|
int y, i;
|
|
|
|
chpt = stringsize(font, s); /* bounding box of char */
|
|
*wid = ((chpt.x+7) / 8) * 8;
|
|
*ht = chpt.y;
|
|
/* postscript is backwards to video, so draw white (ones) on black (zeros) */
|
|
b = allocimage(display, Rpt(ZP, chpt), GREY1, 0, DBlack); /* place to put it */
|
|
spt = string(b, Pt(0,0), display->white, ZP, font, s); /* put it there */
|
|
/* Bprint(&bout, "chpt %P, spt %P, wid,ht %d,%d\n", chpt, spt, *wid, *ht);
|
|
/* Bflush(&bout); */
|
|
for (y = 0; y < chpt.y; y++) { /* read bits a row at a time */
|
|
memset(rowdata, 0, sizeof rowdata);
|
|
unloadimage(b, Rect(0, y, chpt.x, y+1), rowdata, sizeof rowdata);
|
|
for (i = 0; i < spt.x; i += 8) { /* 8 == byte */
|
|
sprint(hp, "%2.2x", rowdata[i/8]);
|
|
hp += 2;
|
|
}
|
|
}
|
|
*hp = 0;
|
|
freeimage(b);
|
|
return hex;
|
|
}
|
|
|
|
|
|
void Bgetstr(Biobuf *bp, char *s) /* get a string */
|
|
{
|
|
int c;
|
|
|
|
while ((c = Bgetc(bp)) >= 0) {
|
|
if (c == ' ' || c == '\t' || c == '\n') {
|
|
Bungetc(bp);
|
|
break;
|
|
}
|
|
*s++ = c;
|
|
}
|
|
*s = 0;
|
|
}
|
|
|
|
void Bgetline(Biobuf *bp, char *s) /* get a line, including newline */
|
|
{
|
|
int c;
|
|
|
|
while ((c = Bgetc(bp)) >= 0) {
|
|
*s++ = c;
|
|
if (c == '\n')
|
|
break;
|
|
}
|
|
*s = 0;
|
|
}
|
|
|
|
void Bgetint(Biobuf *bp, int *n) /* get an integer */
|
|
{
|
|
double d;
|
|
|
|
Bgetd(bp, &d);
|
|
*n = d;
|
|
}
|