Subversion Repositories planix.SVN

#include "a.h"

/*

 * 8. Number Registers

 * (Reg register implementation is also here.)

 */

/*

 *	\nx		N

 *	\n(xx	N

 *	\n+x		N+=M

 *	\n-x		N-=M

 *

 *	.nr R ±N M

 *	.af R c

 *

 *	formats

 *		1	0, 1, 2, 3, ...

 *		001	001, 002, 003, ...

 *		i	0, i, ii, iii, iv, v, ...

 *		I	0, I, II, III, IV, V, ...

 *		a	0, a, b, ..., aa, ab, ..., zz, aaa, ...

 *		A	0, A, B, ..., AA, AB, ..., ZZ, AAA, ...

 *

 *	\gx \g(xx return format of number register

 *

 *	.rr R

 */

typedef struct Reg Reg;

struct Reg

{

	Reg *next;

	Rune *name;

	Rune *val;

	Rune *fmt;

	int inc;

};

Reg *dslist;

Reg *nrlist;

/*

 * Define strings and numbers.

 */

void

dsnr(Rune *name, Rune *val, Reg **l)

{

	Reg *s;

	for(s = *l; s != nil; s = *l){

		if(runestrcmp(s->name, name) == 0)

			break;

		l = &s->next;

	}

	if(val == nil){

		if(s){

			*l = s->next;

			free(s->val);

			free(s->fmt);

			free(s);

		}

		return;

	}

	if(s == nil){

		s = emalloc(sizeof(Reg));

		*l = s;

		s->name = erunestrdup(name);

	}else

		free(s->val);

	s->val = erunestrdup(val);

}

Rune*

getdsnr(Rune *name, Reg *list)

{

	Reg *s;

	for(s=list; s; s=s->next)

		if(runestrcmp(name, s->name) == 0)

			return s->val;

	return nil;

}

void

ds(Rune *name, Rune *val)

{

	dsnr(name, val, &dslist);

}

void

as(Rune *name, Rune *val)

{

	Rune *p, *q;

	p = getds(name);

	if(p == nil)

		p = L("");

	q = runemalloc(runestrlen(p)+runestrlen(val)+1);

	runestrcpy(q, p);

	runestrcat(q, val);

	ds(name, q);

	free(q);

}

Rune*

getds(Rune *name)

{

	return getdsnr(name, dslist);

}

void

printds(int t)

{

	int n, total;

	Reg *s;

	total = 0;

	for(s=dslist; s; s=s->next){

		if(s->val)

			n = runestrlen(s->val);

		else

			n = 0;

		total += n;

		if(!t)

			fprint(2, "%S\t%d\n", s->name, n);

	}

	fprint(2, "total\t%d\n", total);

}

void

nr(Rune *name, int val)

{

	Rune buf[20];

	runesnprint(buf, nelem(buf), "%d", val);

	_nr(name, buf);

}

void

af(Rune *name, Rune *fmt)

{

	Reg *s;

	if(_getnr(name) == nil)

		_nr(name, L("0"));

	for(s=nrlist; s; s=s->next)

		if(runestrcmp(s->name, name) == 0)

			s->fmt = erunestrdup(fmt);

}

Rune*

getaf(Rune *name)

{

	Reg *s;

	for(s=nrlist; s; s=s->next)

		if(runestrcmp(s->name, name) == 0)

			return s->fmt;

	return nil;

}

void

printnr(void)

{

	Reg *r;

	for(r=nrlist; r; r=r->next)

		fprint(2, "%S %S %d\n", r->name, r->val, r->inc);

}

/*

 * Some internal number registers are actually strings,

 * so provide _ versions to get at them.

 */

void

_nr(Rune *name, Rune *val)

{

	dsnr(name, val, &nrlist);

}

Rune*

_getnr(Rune *name)

{

	return getdsnr(name, nrlist);

}

int

getnr(Rune *name)

{

	Rune *p;

	p = _getnr(name);

	if(p == nil)

		return 0;

	return eval(p);

}

/* new register */

void

r_nr(int argc, Rune **argv)

{

	Reg *s;

	if(argc < 2)

		return;

	if(argc < 3)

		nr(argv[1], 0);

	else{

		if(argv[2][0] == '+')

			nr(argv[1], getnr(argv[1])+eval(argv[2]+1));

		else if(argv[2][0] == '-')

			nr(argv[1], getnr(argv[1])-eval(argv[2]+1));

		else

			nr(argv[1], eval(argv[2]));

	}

	if(argc > 3){

		for(s=nrlist; s; s=s->next)

			if(runestrcmp(s->name, argv[1]) == 0)

				s->inc = eval(argv[3]);

	}

}

/* assign format */

void

r_af(int argc, Rune **argv)

{

	USED(argc);

	af(argv[1], argv[2]);

}

/* remove register */

void

r_rr(int argc, Rune **argv)

{

	int i;

	for(i=1; i<argc; i++)

		_nr(argv[i], nil);

}

/* fmt integer in base 26 */

void

alpha(Rune *buf, int n, int a)

{

	int i, v;

	i = 1;

	for(v=n; v>0; v/=26)

		i++;

	if(i == 0)

		i = 1;

	buf[i] = 0;

	while(i > 0){

		buf[--i] = a+n%26;

		n /= 26;

	}

}

struct romanv {

	char *s;

	int v;

} romanv[] =

{

	"m",	1000,

	"cm", 900,

	"d", 500,

	"cd", 400,

	"c", 100,

	"xc", 90,

	"l", 50,

	"xl", 40,

	"x", 10,

	"ix", 9,

	"v", 5,

	"iv", 4,

	"i", 1

};

/* fmt integer in roman numerals! */

void

roman(Rune *buf, int n, int upper)

{

	Rune *p;

	char *q;

	struct romanv *r;

	if(upper)

		upper = 'A' - 'a';

	if(n >= 5000 || n <= 0){

		runestrcpy(buf, L("-"));

		return;

	}

	p = buf;

	r = romanv;

	while(n > 0){

		while(n >= r->v){

			for(q=r->s; *q; q++)

				*p++ = *q + upper;

			n -= r->v;

		}

		r++;

	}

	*p = 0;

}

Rune*

getname(void)

{

	int i, c, cc;

	static Rune buf[100];

	/* XXX add [name] syntax as in groff */

	c = getnext();

	if(c < 0)

		return L("");

	if(c == '\n'){

		warn("newline in name\n");

		ungetnext(c);

		return L("");

	}

	if(c == '['){

		for(i=0; i<nelem(buf)-1; i++){

			if((c = getrune()) < 0)

				return L("");

			if(c == ']'){

				buf[i] = 0;

				return buf;

			}

			buf[i] = c;

		}

		return L("");

	}

	if(c != '('){

		buf[0] = c;

		buf[1] = 0;

		return buf;

	}

	c = getnext();

	cc = getnext();

	if(c < 0 || cc < 0)

		return L("");

	if(c == '\n' | cc == '\n'){

		warn("newline in \\n");

		ungetnext(cc);

		if(c == '\n')

			ungetnext(c);

	}

	buf[0] = c;

	buf[1] = cc;

	buf[2] = 0;

	return buf;

}

/* \n - return number register */

int

e_n(void)

{

	int inc, v, l;

	Rune *name, *fmt, buf[100];

	Reg *s;

	inc = getnext();

	if(inc < 0)

		return -1;

	if(inc != '+' && inc != '-'){

		ungetnext(inc);

		inc = 0;

	}

	name = getname();

	if(_getnr(name) == nil)

		_nr(name, L("0"));

	for(s=nrlist; s; s=s->next){

		if(runestrcmp(s->name, name) == 0){

			if(s->fmt == nil && !inc && s->val[0]){

				/* might be a string! */

				pushinputstring(s->val);

				return 0;

			}

			v = eval(s->val);

			if(inc){

				if(inc == '+')

					v += s->inc;

				else

					v -= s->inc;

				runesnprint(buf, nelem(buf), "%d", v);

				free(s->val);

				s->val = erunestrdup(buf);

			}

			fmt = s->fmt;

			if(fmt == nil)

				fmt = L("1");

			switch(fmt[0]){

			case 'i':

			case 'I':

				roman(buf, v, fmt[0]=='I');

				break;

			case 'a':

			case 'A':

				alpha(buf, v, fmt[0]);

				break;

			default:

				l = runestrlen(fmt);

				if(l == 0)

					l = 1;

				runesnprint(buf, sizeof buf, "%0*d", l, v);

				break;

			}

			pushinputstring(buf);

			return 0;

		}

	}

	pushinputstring(L(""));

	return 0;

}

/* \g - number register format */

int

e_g(void)

{

	Rune *p;

	p = getaf(getname());

	if(p == nil)

		p = L("1");

	pushinputstring(p);

	return 0;

}

void

r_pnr(int argc, Rune **argv)

{

	USED(argc);

	USED(argv);

	printnr();

}

void

t8init(void)

{

	addreq(L("nr"), r_nr, -1);

	addreq(L("af"), r_af, 2);

	addreq(L("rr"), r_rr, -1);

	addreq(L("pnr"), r_pnr, 0);

	addesc('n', e_n, CopyMode|ArgMode|HtmlMode);

	addesc('g', e_g, 0);

}