Subversion Repositories planix.SVN

/*

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;

}