[unix-history] / usr / src / usr.bin / units.c

static char *sccsid = "@(#)units.c	4.1 (Berkeley) 10/1/80";
#include <stdio.h>

#define	NDIM	10
#define	NTAB	601
char	*dfile	= "/usr/lib/units";
char	*unames[NDIM];
double	getflt();
int	fperr();
struct	table	*hash();
struct unit
{
	double	factor;
	char	dim[NDIM];
};

struct table
{
	double	factor;
	char	dim[NDIM];
	char	*name;
} table[NTAB];
char	names[NTAB*10];
struct prefix
{
	double	factor;
	char	*pname;
} prefix[] = 
{
	1e-18,	"atto",
	1e-15,	"femto",
	1e-12,	"pico",
	1e-9,	"nano",
	1e-6,	"micro",
	1e-3,	"milli",
	1e-2,	"centi",
	1e-1,	"deci",
	1e1,	"deka",
	1e2,	"hecta",
	1e2,	"hecto",
	1e3,	"kilo",
	1e6,	"mega",
	1e6,	"meg",
	1e9,	"giga",
	1e12,	"tera",
	0.0,	0
};
FILE	*inp;
int	fperrc;
int	peekc;
int	dumpflg;

main(argc, argv)
char *argv[];
{
	register i;
	register char *file;
	struct unit u1, u2;
	double f;

	if(argc>1 && *argv[1]=='-') {
		argc--;
		argv++;
		dumpflg++;
	}
	file = dfile;
	if(argc > 1)
		file = argv[1];
	if ((inp = fopen(file, "r")) == NULL) {
		printf("no table\n");
		exit(1);
	}
	signal(8, fperr);
	init();

loop:
	fperrc = 0;
	printf("you have: ");
	if(convr(&u1))
		goto loop;
	if(fperrc)
		goto fp;
loop1:
	printf("you want: ");
	if(convr(&u2))
		goto loop1;
	for(i=0; i<NDIM; i++)
		if(u1.dim[i] != u2.dim[i])
			goto conform;
	f = u1.factor/u2.factor;
	if(fperrc)
		goto fp;
	printf("\t* %e\n", f);
	printf("\t/ %e\n", 1./f);
	goto loop;

conform:
	if(fperrc)
		goto fp;
	printf("conformability\n");
	units(&u1);
	units(&u2);
	goto loop;

fp:
	printf("underflow or overflow\n");
	goto loop;
}

units(up)
struct unit *up;
{
	register struct unit *p;
	register f, i;

	p = up;
	printf("\t%e ", p->factor);
	f = 0;
	for(i=0; i<NDIM; i++)
		f |= pu(p->dim[i], i, f);
	if(f&1) {
		putchar('/');
		f = 0;
		for(i=0; i<NDIM; i++)
			f |= pu(-p->dim[i], i, f);
	}
	putchar('\n');
}

pu(u, i, f)
{

	if(u > 0) {
		if(f&2)
			putchar('-');
		if(unames[i])
			printf("%s", unames[i]); else
			printf("*%c*", i+'a');
		if(u > 1)
			putchar(u+'0');
			return(2);
	}
	if(u < 0)
		return(1);
	return(0);
}

convr(up)
struct unit *up;
{
	register struct unit *p;
	register c;
	register char *cp;
	char name[20];
	int den, err;

	p = up;
	for(c=0; c<NDIM; c++)
		p->dim[c] = 0;
	p->factor = getflt();
	if(p->factor == 0.)
		p->factor = 1.0;
	err = 0;
	den = 0;
	cp = name;

loop:
	switch(c=get()) {

	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	case '-':
	case '/':
	case ' ':
	case '\t':
	case '\n':
		if(cp != name) {
			*cp++ = 0;
			cp = name;
			err |= lookup(cp, p, den, c);
		}
		if(c == '/')
			den++;
		if(c == '\n')
			return(err);
		goto loop;
	}
	*cp++ = c;
	goto loop;
}

lookup(name, up, den, c)
char *name;
struct unit *up;
{
	register struct unit *p;
	register struct table *q;
	register i;
	char *cp1, *cp2;
	double e;

	p = up;
	e = 1.0;

loop:
	q = hash(name);
	if(q->name) {
		l1:
		if(den) {
			p->factor /= q->factor*e;
			for(i=0; i<NDIM; i++)
				p->dim[i] -= q->dim[i];
		} else {
			p->factor *= q->factor*e;
			for(i=0; i<NDIM; i++)
				p->dim[i] += q->dim[i];
		}
		if(c >= '2' && c <= '9') {
			c--;
			goto l1;
		}
		return(0);
	}
	for(i=0; cp1 = prefix[i].pname; i++) {
		cp2 = name;
		while(*cp1 == *cp2++)
			if(*cp1++ == 0) {
				cp1--;
				break;
			}
		if(*cp1 == 0) {
			e *= prefix[i].factor;
			name = cp2-1;
			goto loop;
		}
	}
	for(cp1 = name; *cp1; cp1++);
	if(cp1 > name+1 && *--cp1 == 's') {
		*cp1 = 0;
		goto loop;
	}
	printf("cannot recognize %s\n", name);
	return(1);
}

equal(s1, s2)
char *s1, *s2;
{
	register char *c1, *c2;

	c1 = s1;
	c2 = s2;
	while(*c1++ == *c2)
		if(*c2++ == 0)
			return(1);
	return(0);
}

init()
{
	register char *cp;
	register struct table *tp, *lp;
	int c, i, f, t;
	char *np;

	cp = names;
	for(i=0; i<NDIM; i++) {
		np = cp;
		*cp++ = '*';
		*cp++ = i+'a';
		*cp++ = '*';
		*cp++ = 0;
		lp = hash(np);
		lp->name = np;
		lp->factor = 1.0;
		lp->dim[i] = 1;
	}
	lp = hash("");
	lp->name = cp-1;
	lp->factor = 1.0;

l0:
	c = get();
	if(c == 0) {
		printf("%d units; %d bytes\n\n", i, cp-names);
		if(dumpflg)
		for(tp = &table[0]; tp < &table[NTAB]; tp++) {
			if(tp->name == 0)
				continue;
			printf("%s", tp->name);
			units(tp);
		}
		fclose(inp);
		inp = stdin;
		return;
	}
	if(c == '/') {
		while(c != '\n' && c != 0)
			c = get();
		goto l0;
	}
	if(c == '\n')
		goto l0;
	np = cp;
	while(c != ' ' && c != '\t') {
		*cp++ = c;
		c = get();
		if (c==0)
			goto l0;
		if(c == '\n') {
			*cp++ = 0;
			tp = hash(np);
			if(tp->name)
				goto redef;
			tp->name = np;
			tp->factor = lp->factor;
			for(c=0; c<NDIM; c++)
				tp->dim[c] = lp->dim[c];
			i++;
			goto l0;
		}
	}
	*cp++ = 0;
	lp = hash(np);
	if(lp->name)
		goto redef;
	convr(lp);
	lp->name = np;
	f = 0;
	i++;
	if(lp->factor != 1.0)
		goto l0;
	for(c=0; c<NDIM; c++) {
		t = lp->dim[c];
		if(t>1 || (f>0 && t!=0))
			goto l0;
		if(f==0 && t==1) {
			if(unames[c])
				goto l0;
			f = c+1;
		}
	}
	if(f>0)
		unames[f-1] = np;
	goto l0;

redef:
	printf("redefinition %s\n", np);
	goto l0;
}

double
getflt()
{
	register c, i, dp;
	double d, e;
	int f;

	d = 0.;
	dp = 0;
	do
		c = get();
	while(c == ' ' || c == '\t');

l1:
	if(c >= '0' && c <= '9') {
		d = d*10. + c-'0';
		if(dp)
			dp++;
		c = get();
		goto l1;
	}
	if(c == '.') {
		dp++;
		c = get();
		goto l1;
	}
	if(dp)
		dp--;
	if(c == '+' || c == '-') {
		f = 0;
		if(c == '-')
			f++;
		i = 0;
		c = get();
		while(c >= '0' && c <= '9') {
			i = i*10 + c-'0';
			c = get();
		}
		if(f)
			i = -i;
		dp -= i;
	}
	e = 1.;
	i = dp;
	if(i < 0)
		i = -i;
	while(i--)
		e *= 10.;
	if(dp < 0)
		d *= e; else
		d /= e;
	if(c == '|')
		return(d/getflt());
	peekc = c;
	return(d);
}

get()
{
	register c;

	if(c=peekc) {
		peekc = 0;
		return(c);
	}
	c = getc(inp);
	if (c == EOF) {
		if (inp == stdin) {
			printf("\n");
			exit(0);
		}
		return(0);
	}
	return(c);
}

struct table *
hash(name)
char *name;
{
	register struct table *tp;
	register char *np;
	register unsigned h;

	h = 0;
	np = name;
	while(*np)
		h = h*57 + *np++ - '0';
	if( ((int)h)<0) h= -(int)h;
	h %= NTAB;
	tp = &table[h];
l0:
	if(tp->name == 0)
		return(tp);
	if(equal(name, tp->name))
		return(tp);
	tp++;
	if(tp >= &table[NTAB])
		tp = table;
	goto l0;
}

fperr()
{

	signal(8, fperr);
	fperrc++;
}
Commit	Line	Data
31cef89c	1	static char *sccsid = "@(#)units.c 4.1 (Berkeley) 10/1/80";
b3bb7316 BJ	2	#include <stdio.h>
	3
	4	#define NDIM 10
	5	#define NTAB 601
	6	char *dfile = "/usr/lib/units";
	7	char *unames[NDIM];
	8	double getflt();
	9	int fperr();
	10	struct table *hash();
	11	struct unit
	12	{
	13	double factor;
	14	char dim[NDIM];
	15	};
	16
	17	struct table
	18	{
	19	double factor;
	20	char dim[NDIM];
	21	char *name;
	22	} table[NTAB];
	23	char names[NTAB*10];
	24	struct prefix
	25	{
	26	double factor;
	27	char *pname;
	28	} prefix[] =
	29	{
	30	1e-18, "atto",
	31	1e-15, "femto",
	32	1e-12, "pico",
	33	1e-9, "nano",
	34	1e-6, "micro",
	35	1e-3, "milli",
	36	1e-2, "centi",
	37	1e-1, "deci",
	38	1e1, "deka",
	39	1e2, "hecta",
	40	1e2, "hecto",
	41	1e3, "kilo",
	42	1e6, "mega",
	43	1e6, "meg",
	44	1e9, "giga",
	45	1e12, "tera",
	46	0.0, 0
	47	};
	48	FILE *inp;
	49	int fperrc;
	50	int peekc;
	51	int dumpflg;
	52
	53	main(argc, argv)
	54	char *argv[];
	55	{
	56	register i;
	57	register char *file;
	58	struct unit u1, u2;
	59	double f;
	60
	61	if(argc>1 && *argv[1]=='-') {
	62	argc--;
	63	argv++;
	64	dumpflg++;
	65	}
66	file = dfile;
67	if(argc > 1)
68	file = argv[1];
69	if ((inp = fopen(file, "r")) == NULL) {
70	printf("no table\n");
71	exit(1);
72	}
73	signal(8, fperr);
74	init();
75
76	loop:
77	fperrc = 0;
78	printf("you have: ");
79	if(convr(&u1))
80	goto loop;
81	if(fperrc)
82	goto fp;
83	loop1:
84	printf("you want: ");
85	if(convr(&u2))
86	goto loop1;
87	for(i=0; i<NDIM; i++)
88	if(u1.dim[i] != u2.dim[i])
89	goto conform;
90	f = u1.factor/u2.factor;
91	if(fperrc)
92	goto fp;
93	printf("\t* %e\n", f);
94	printf("\t/ %e\n", 1./f);
95	goto loop;
96
97	conform:
98	if(fperrc)
99	goto fp;
100	printf("conformability\n");
101	units(&u1);
102	units(&u2);
103	goto loop;
104
105	fp:
106	printf("underflow or overflow\n");
107	goto loop;
108	}
109
110	units(up)
111	struct unit *up;
112	{
113	register struct unit *p;
114	register f, i;
115
116	p = up;
117	printf("\t%e ", p->factor);
118	f = 0;
119	for(i=0; i<NDIM; i++)
120	f \|= pu(p->dim[i], i, f);
121	if(f&1) {
122	putchar('/');
123	f = 0;
124	for(i=0; i<NDIM; i++)
125	f \|= pu(-p->dim[i], i, f);
126	}
127	putchar('\n');
128	}
129
130	pu(u, i, f)
131	{
132
133	if(u > 0) {
134	if(f&2)
135	putchar('-');
136	if(unames[i])
137	printf("%s", unames[i]); else
138	printf("%c", i+'a');
139	if(u > 1)
140	putchar(u+'0');
141	return(2);
142	}
143	if(u < 0)
144	return(1);
145	return(0);
146	}
147
148	convr(up)
149	struct unit *up;
150	{
151	register struct unit *p;
152	register c;
153	register char *cp;
154	char name[20];
155	int den, err;
156
157	p = up;
158	for(c=0; c<NDIM; c++)
159	p->dim[c] = 0;
160	p->factor = getflt();
161	if(p->factor == 0.)
162	p->factor = 1.0;
163	err = 0;
164	den = 0;
165	cp = name;
166
167	loop:
168	switch(c=get()) {
169
170	case '1':
171	case '2':
172	case '3':
173	case '4':
174	case '5':
175	case '6':
176	case '7':
177	case '8':
178	case '9':
179	case '-':
180	case '/':
181	case ' ':
182	case '\t':
183	case '\n':
184	if(cp != name) {
185	*cp++ = 0;
186	cp = name;
187	err \|= lookup(cp, p, den, c);
188	}
189	if(c == '/')
190	den++;
191	if(c == '\n')
192	return(err);
193	goto loop;
194	}
195	*cp++ = c;
196	goto loop;
197	}
198
199	lookup(name, up, den, c)
200	char *name;
201	struct unit *up;
202	{
203	register struct unit *p;
204	register struct table *q;
205	register i;
206	char cp1, cp2;
207	double e;
208
209	p = up;
210	e = 1.0;
211
212	loop:
213	q = hash(name);
214	if(q->name) {
215	l1:
216	if(den) {
217	p->factor /= q->factor*e;
218	for(i=0; i<NDIM; i++)
219	p->dim[i] -= q->dim[i];
220	} else {
221	p->factor = q->factore;
222	for(i=0; i<NDIM; i++)
223	p->dim[i] += q->dim[i];
224	}
225	if(c >= '2' && c <= '9') {
226	c--;
227	goto l1;
228	}
229	return(0);
230	}
231	for(i=0; cp1 = prefix[i].pname; i++) {
232	cp2 = name;
233	while(cp1 == cp2++)
234	if(*cp1++ == 0) {
235	cp1--;
236	break;
237	}
238	if(*cp1 == 0) {
239	e *= prefix[i].factor;
240	name = cp2-1;
241	goto loop;
242	}
243	}
244	for(cp1 = name; *cp1; cp1++);
245	if(cp1 > name+1 && *--cp1 == 's') {
246	*cp1 = 0;
247	goto loop;
248	}
249	printf("cannot recognize %s\n", name);
250	return(1);
251	}
252
253	equal(s1, s2)
254	char s1, s2;
255	{
256	register char c1, c2;
257
258	c1 = s1;
259	c2 = s2;
260	while(c1++ == c2)
261	if(*c2++ == 0)
262	return(1);
263	return(0);
264	}
265
266	init()
267	{
268	register char *cp;
269	register struct table tp, lp;
270	int c, i, f, t;
271	char *np;
272
273	cp = names;
274	for(i=0; i<NDIM; i++) {
275	np = cp;
276	cp++ = '';
277	*cp++ = i+'a';
278	cp++ = '';
279	*cp++ = 0;
280	lp = hash(np);
281	lp->name = np;
282	lp->factor = 1.0;
283	lp->dim[i] = 1;
284	}
285	lp = hash("");
286	lp->name = cp-1;
287	lp->factor = 1.0;
288
289	l0:
290	c = get();
291	if(c == 0) {
292	printf("%d units; %d bytes\n\n", i, cp-names);
293	if(dumpflg)
294	for(tp = &table[0]; tp < &table[NTAB]; tp++) {
295	if(tp->name == 0)
296	continue;
297	printf("%s", tp->name);
298	units(tp);
299	}
300	fclose(inp);
301	inp = stdin;
302	return;
303	}
304	if(c == '/') {
305	while(c != '\n' && c != 0)
306	c = get();
307	goto l0;
308	}
309	if(c == '\n')
310	goto l0;
311	np = cp;
312	while(c != ' ' && c != '\t') {
313	*cp++ = c;
314	c = get();
315	if (c==0)
316	goto l0;
317	if(c == '\n') {
318	*cp++ = 0;
319	tp = hash(np);
320	if(tp->name)
321	goto redef;
322	tp->name = np;
323	tp->factor = lp->factor;
324	for(c=0; c<NDIM; c++)
325	tp->dim[c] = lp->dim[c];
326	i++;
327	goto l0;
328	}
329	}
330	*cp++ = 0;
331	lp = hash(np);
332	if(lp->name)
333	goto redef;
334	convr(lp);
335	lp->name = np;
336	f = 0;
337	i++;
338	if(lp->factor != 1.0)
339	goto l0;
340	for(c=0; c<NDIM; c++) {
341	t = lp->dim[c];
342	if(t>1 \|\| (f>0 && t!=0))
343	goto l0;
344	if(f==0 && t==1) {
345	if(unames[c])
346	goto l0;
347	f = c+1;
348	}
349	}
350	if(f>0)
351	unames[f-1] = np;
352	goto l0;
353
354	redef:
355	printf("redefinition %s\n", np);
356	goto l0;
357	}
358
359	double
360	getflt()
361	{
362	register c, i, dp;
363	double d, e;
364	int f;
365
366	d = 0.;
367	dp = 0;
368	do
369	c = get();
370	while(c == ' ' \|\| c == '\t');
371
372	l1:
373	if(c >= '0' && c <= '9') {
374	d = d*10. + c-'0';
375	if(dp)
376	dp++;
377	c = get();
378	goto l1;
379	}
380	if(c == '.') {
381	dp++;
382	c = get();
383	goto l1;
384	}
385	if(dp)
386	dp--;
387	if(c == '+' \|\| c == '-') {
388	f = 0;
389	if(c == '-')
390	f++;
391	i = 0;
392	c = get();
393	while(c >= '0' && c <= '9') {
394	i = i*10 + c-'0';
395	c = get();
396	}
397	if(f)
398	i = -i;
399	dp -= i;
400	}
401	e = 1.;
402	i = dp;
403	if(i < 0)
404	i = -i;
405	while(i--)
406	e *= 10.;
407	if(dp < 0)
408	d *= e; else
409	d /= e;
410	if(c == '\|')
411	return(d/getflt());
412	peekc = c;
413	return(d);
414	}
415
416	get()
417	{
418	register c;
419
420	if(c=peekc) {
421	peekc = 0;
422	return(c);
423	}
424	c = getc(inp);
425	if (c == EOF) {
426	if (inp == stdin) {
427	printf("\n");
428	exit(0);
429	}
430	return(0);
431	}
432	return(c);
433	}
434
435	struct table *
436	hash(name)
437	char *name;
438	{
439	register struct table *tp;
440	register char *np;
441	register unsigned h;
442
443	h = 0;
444	np = name;
445	while(*np)
446	h = h57 + np++ - '0';
447	if( ((int)h)<0) h= -(int)h;
448	h %= NTAB;
449	tp = &table[h];
450	l0:
451	if(tp->name == 0)
452	return(tp);
453	if(equal(name, tp->name))
454	return(tp);
455	tp++;
456	if(tp >= &table[NTAB])
457	tp = table;
458	goto l0;
459	}
460
461	fperr()
462	{
463
464	signal(8, fperr);
465	fperrc++;
466	}