/usr.bin/units/units.c

  1/*
  2 * units.c   Copyright (c) 1993 by Adrian Mariano (adrian@cam.cornell.edu)
  3 *
  4 * Redistribution and use in source and binary forms, with or without
  5 * modification, are permitted provided that the following conditions
  6 * are met:
  7 * 1. Redistributions of source code must retain the above copyright
  8 *    notice, this list of conditions and the following disclaimer.
  9 * 2. The name of the author may not be used to endorse or promote products
 10 *    derived from this software without specific prior written permission.
 11 * Disclaimer:  This software is provided by the author "as is".  The author
 12 * shall not be liable for any damages caused in any way by this software.
 13 *
 14 * I would appreciate (though I do not require) receiving a copy of any
 15 * improvements you might make to this program.
 16 */
 17
 18#ifndef lint
 19static const char rcsid[] =
 20  "$FreeBSD$";
 21#endif /* not lint */
 22
 23#include <ctype.h>
 24#include <err.h>
 25#include <stdio.h>
 26#include <stdlib.h>
 27#include <string.h>
 28#include <unistd.h>
 29
 30#include "pathnames.h"
 31
 32#define VERSION "1.0"
 33
 34#ifndef UNITSFILE
 35#define UNITSFILE _PATH_UNITSLIB
 36#endif
 37
 38#define MAXUNITS 1000
 39#define MAXPREFIXES 100
 40
 41#define MAXSUBUNITS 500
 42
 43#define PRIMITIVECHAR '!'
 44
 45static const char *powerstring = "^";
 46
 47static struct {
 48	char *uname;
 49	char *uval;
 50}      unittable[MAXUNITS];
 51
 52struct unittype {
 53	char *numerator[MAXSUBUNITS];
 54	char *denominator[MAXSUBUNITS];
 55	double factor;
 56	double offset;
 57	int quantity;
 58};
 59
 60static struct {
 61	char *prefixname;
 62	char *prefixval;
 63}      prefixtable[MAXPREFIXES];
 64
 65
 66static char NULLUNIT[] = "";
 67
 68#ifdef MSDOS
 69#define SEPARATOR      ";"
 70#else
 71#define SEPARATOR      ":"
 72#endif
 73
 74static int unitcount;
 75static int prefixcount;
 76
 77char	*dupstr(const char *str);
 78void	 readunits(const char *userfile);
 79void	 initializeunit(struct unittype * theunit);
 80int	 addsubunit(char *product[], char *toadd);
 81void	 showunit(struct unittype * theunit);
 82void	 zeroerror(void);
 83int	 addunit(struct unittype *theunit, char *toadd, int flip, int quantity);
 84int	 compare(const void *item1, const void *item2);
 85void	 sortunit(struct unittype * theunit);
 86void	 cancelunit(struct unittype * theunit);
 87char	*lookupunit(const char *unit);
 88int	 reduceproduct(struct unittype * theunit, int flip);
 89int	 reduceunit(struct unittype * theunit);
 90int	 compareproducts(char **one, char **two);
 91int	 compareunits(struct unittype * first, struct unittype * second);
 92int	 completereduce(struct unittype * unit);
 93void	 showanswer(struct unittype * have, struct unittype * want);
 94void	 usage(void);
 95
 96char *
 97dupstr(const char *str)
 98{
 99	char *ret;
100
101	ret = malloc(strlen(str) + 1);
102	if (!ret)
103		errx(3, "memory allocation error");
104	strcpy(ret, str);
105	return (ret);
106}
107
108
109void 
110readunits(const char *userfile)
111{
112	FILE *unitfile;
113	char line[512], *lineptr;
114	int len, linenum, i;
115
116	unitcount = 0;
117	linenum = 0;
118
119	if (userfile) {
120		unitfile = fopen(userfile, "rt");
121		if (!unitfile)
122			errx(1, "unable to open units file '%s'", userfile);
123	}
124	else {
125		unitfile = fopen(UNITSFILE, "rt");
126		if (!unitfile) {
127			char *direc, *env;
128			char filename[1000];
129
130			env = getenv("PATH");
131			if (env) {
132				direc = strtok(env, SEPARATOR);
133				while (direc) {
134					snprintf(filename, sizeof(filename),
135					    "%s/%s", direc, UNITSFILE);
136					unitfile = fopen(filename, "rt");
137					if (unitfile)
138						break;
139					direc = strtok(NULL, SEPARATOR);
140				}
141			}
142			if (!unitfile)
143				errx(1, "can't find units file '%s'", UNITSFILE);
144		}
145	}
146	while (!feof(unitfile)) {
147		if (!fgets(line, sizeof(line), unitfile))
148			break;
149		linenum++;
150		lineptr = line;
151		if (*lineptr == '/')
152			continue;
153		lineptr += strspn(lineptr, " \n\t");
154		len = strcspn(lineptr, " \n\t");
155		lineptr[len] = 0;
156		if (!strlen(lineptr))
157			continue;
158		if (lineptr[strlen(lineptr) - 1] == '-') { /* it's a prefix */
159			if (prefixcount == MAXPREFIXES) {
160				warnx("memory for prefixes exceeded in line %d", linenum);
161				continue;
162			}
163			lineptr[strlen(lineptr) - 1] = 0;
164			prefixtable[prefixcount].prefixname = dupstr(lineptr);
165			for (i = 0; i < prefixcount; i++)
166				if (!strcmp(prefixtable[i].prefixname, lineptr)) {
167					warnx("redefinition of prefix '%s' on line %d ignored",
168					    lineptr, linenum);
169					continue;
170				}
171			lineptr += len + 1;
172			lineptr += strspn(lineptr, " \n\t");
173			len = strcspn(lineptr, "\n\t");
174			if (len == 0) {
175				warnx("unexpected end of prefix on line %d",
176				    linenum);
177				continue;
178			}
179			lineptr[len] = 0;
180			prefixtable[prefixcount++].prefixval = dupstr(lineptr);
181		}
182		else {		/* it's not a prefix */
183			if (unitcount == MAXUNITS) {
184				warnx("memory for units exceeded in line %d", linenum);
185				continue;
186			}
187			unittable[unitcount].uname = dupstr(lineptr);
188			for (i = 0; i < unitcount; i++)
189				if (!strcmp(unittable[i].uname, lineptr)) {
190					warnx("redefinition of unit '%s' on line %d ignored",
191					    lineptr, linenum);
192					continue;
193				}
194			lineptr += len + 1;
195			lineptr += strspn(lineptr, " \n\t");
196			if (!strlen(lineptr)) {
197				warnx("unexpected end of unit on line %d",
198				    linenum);
199				continue;
200			}
201			len = strcspn(lineptr, "\n\t");
202			lineptr[len] = 0;
203			unittable[unitcount++].uval = dupstr(lineptr);
204		}
205	}
206	fclose(unitfile);
207}
208
209void 
210initializeunit(struct unittype * theunit)
211{
212	theunit->numerator[0] = theunit->denominator[0] = NULL;
213	theunit->factor = 1.0;
214	theunit->offset = 0.0;
215	theunit->quantity = 0;
216}
217
218
219int 
220addsubunit(char *product[], char *toadd)
221{
222	char **ptr;
223
224	for (ptr = product; *ptr && *ptr != NULLUNIT; ptr++);
225	if (ptr >= product + MAXSUBUNITS) {
226		warnx("memory overflow in unit reduction");
227		return 1;
228	}
229	if (!*ptr)
230		*(ptr + 1) = 0;
231	*ptr = dupstr(toadd);
232	return 0;
233}
234
235
236void 
237showunit(struct unittype * theunit)
238{
239	char **ptr;
240	int printedslash;
241	int counter = 1;
242
243	printf("\t%.8g", theunit->factor);
244	if (theunit->offset)
245		printf("&%.8g", theunit->offset);
246	for (ptr = theunit->numerator; *ptr; ptr++) {
247		if (ptr > theunit->numerator && **ptr &&
248		    !strcmp(*ptr, *(ptr - 1)))
249			counter++;
250		else {
251			if (counter > 1)
252				printf("%s%d", powerstring, counter);
253			if (**ptr)
254				printf(" %s", *ptr);
255			counter = 1;
256		}
257	}
258	if (counter > 1)
259		printf("%s%d", powerstring, counter);
260	counter = 1;
261	printedslash = 0;
262	for (ptr = theunit->denominator; *ptr; ptr++) {
263		if (ptr > theunit->denominator && **ptr &&
264		    !strcmp(*ptr, *(ptr - 1)))
265			counter++;
266		else {
267			if (counter > 1)
268				printf("%s%d", powerstring, counter);
269			if (**ptr) {
270				if (!printedslash)
271					printf(" /");
272				printedslash = 1;
273				printf(" %s", *ptr);
274			}
275			counter = 1;
276		}
277	}
278	if (counter > 1)
279		printf("%s%d", powerstring, counter);
280	printf("\n");
281}
282
283
284void 
285zeroerror(void)
286{
287	warnx("unit reduces to zero");
288}
289
290/*
291   Adds the specified string to the unit.
292   Flip is 0 for adding normally, 1 for adding reciprocal.
293   Quantity is 1 if this is a quantity to be converted rather than a pure unit.
294
295   Returns 0 for successful addition, nonzero on error.
296*/
297
298int 
299addunit(struct unittype * theunit, char *toadd, int flip, int quantity)
300{
301	char *scratch, *savescr;
302	char *item;
303	char *divider, *slash, *offset;
304	int doingtop;
305
306	if (!strlen(toadd))
307		return 1;
308	
309	savescr = scratch = dupstr(toadd);
310	for (slash = scratch + 1; *slash; slash++)
311		if (*slash == '-' &&
312		    (tolower(*(slash - 1)) != 'e' ||
313		    !strchr(".0123456789", *(slash + 1))))
314			*slash = ' ';
315	slash = strchr(scratch, '/');
316	if (slash)
317		*slash = 0;
318	doingtop = 1;
319	do {
320		item = strtok(scratch, " *\t\n/");
321		while (item) {
322			if (strchr("0123456789.", *item)) { /* item is a number */
323				double num, offsetnum;
324
325				if (quantity)
326					theunit->quantity = 1;
327
328				offset = strchr(item, '&');
329				if (offset) {
330					*offset = 0;
331					offsetnum = atof(offset+1);
332				} else
333					offsetnum = 0.0;
334
335				divider = strchr(item, '|');
336				if (divider) {
337					*divider = 0;
338					num = atof(item);
339					if (!num) {
340						zeroerror();
341						return 1;
342					}
343					if (doingtop ^ flip) {
344						theunit->factor *= num;
345						theunit->offset *= num;
346					} else {
347						theunit->factor /= num;
348						theunit->offset /= num;
349					}
350					num = atof(divider + 1);
351					if (!num) {
352						zeroerror();
353						return 1;
354					}
355					if (doingtop ^ flip) {
356						theunit->factor /= num;
357						theunit->offset /= num;
358					} else {
359						theunit->factor *= num;
360						theunit->offset *= num;
361					}
362				}
363				else {
364					num = atof(item);
365					if (!num) {
366						zeroerror();
367						return 1;
368					}
369					if (doingtop ^ flip) {
370						theunit->factor *= num;
371						theunit->offset *= num;
372					} else {
373						theunit->factor /= num;
374						theunit->offset /= num;
375					}
376				}
377				if (doingtop ^ flip)
378					theunit->offset += offsetnum;
379			}
380			else {	/* item is not a number */
381				int repeat = 1;
382
383				if (strchr("23456789",
384				    item[strlen(item) - 1])) {
385					repeat = item[strlen(item) - 1] - '0';
386					item[strlen(item) - 1] = 0;
387				}
388				for (; repeat; repeat--)
389					if (addsubunit(doingtop ^ flip ? theunit->numerator : theunit->denominator, item))
390						return 1;
391			}
392			item = strtok(NULL, " *\t/\n");
393		}
394		doingtop--;
395		if (slash) {
396			scratch = slash + 1;
397		}
398		else
399			doingtop--;
400	} while (doingtop >= 0);
401	free(savescr);
402	return 0;
403}
404
405
406int 
407compare(const void *item1, const void *item2)
408{
409	return strcmp(*(const char * const *)item1, *(const char * const *)item2);
410}
411
412
413void 
414sortunit(struct unittype * theunit)
415{
416	char **ptr;
417	unsigned int count;
418
419	for (count = 0, ptr = theunit->numerator; *ptr; ptr++, count++);
420	qsort(theunit->numerator, count, sizeof(char *), compare);
421	for (count = 0, ptr = theunit->denominator; *ptr; ptr++, count++);
422	qsort(theunit->denominator, count, sizeof(char *), compare);
423}
424
425
426void 
427cancelunit(struct unittype * theunit)
428{
429	char **den, **num;
430	int comp;
431
432	den = theunit->denominator;
433	num = theunit->numerator;
434
435	while (*num && *den) {
436		comp = strcmp(*den, *num);
437		if (!comp) {
438/*      if (*den!=NULLUNIT) free(*den);
439      if (*num!=NULLUNIT) free(*num);*/
440			*den++ = NULLUNIT;
441			*num++ = NULLUNIT;
442		}
443		else if (comp < 0)
444			den++;
445		else
446			num++;
447	}
448}
449
450
451
452
453/*
454   Looks up the definition for the specified unit.
455   Returns a pointer to the definition or a null pointer
456   if the specified unit does not appear in the units table.
457*/
458
459static char buffer[100];	/* buffer for lookupunit answers with
460				   prefixes */
461
462char *
463lookupunit(const char *unit)
464{
465	int i;
466	char *copy;
467
468	for (i = 0; i < unitcount; i++) {
469		if (!strcmp(unittable[i].uname, unit))
470			return unittable[i].uval;
471	}
472
473	if (unit[strlen(unit) - 1] == '^') {
474		copy = dupstr(unit);
475		copy[strlen(copy) - 1] = 0;
476		for (i = 0; i < unitcount; i++) {
477			if (!strcmp(unittable[i].uname, copy)) {
478				strlcpy(buffer, copy, sizeof(buffer));
479				free(copy);
480				return buffer;
481			}
482		}
483		free(copy);
484	}
485	if (unit[strlen(unit) - 1] == 's') {
486		copy = dupstr(unit);
487		copy[strlen(copy) - 1] = 0;
488		for (i = 0; i < unitcount; i++) {
489			if (!strcmp(unittable[i].uname, copy)) {
490				strlcpy(buffer, copy, sizeof(buffer));
491				free(copy);
492				return buffer;
493			}
494		}
495		if (copy[strlen(copy) - 1] == 'e') {
496			copy[strlen(copy) - 1] = 0;
497			for (i = 0; i < unitcount; i++) {
498				if (!strcmp(unittable[i].uname, copy)) {
499					strlcpy(buffer, copy, sizeof(buffer));
500					free(copy);
501					return buffer;
502				}
503			}
504		}
505		free(copy);
506	}
507	for (i = 0; i < prefixcount; i++) {
508		size_t len = strlen(prefixtable[i].prefixname);
509		if (!strncmp(prefixtable[i].prefixname, unit, len)) {
510			if (!strlen(unit + len) || lookupunit(unit + len)) {
511				snprintf(buffer, sizeof(buffer), "%s %s",
512				    prefixtable[i].prefixval, unit + len);
513				return buffer;
514			}
515		}
516	}
517	return 0;
518}
519
520
521
522/*
523   reduces a product of symbolic units to primitive units.
524   The three low bits are used to return flags:
525
526     bit 0 (1) set on if reductions were performed without error.
527     bit 1 (2) set on if no reductions are performed.
528     bit 2 (4) set on if an unknown unit is discovered.
529*/
530
531
532#define ERROR 4
533
534int 
535reduceproduct(struct unittype * theunit, int flip)
536{
537
538	char *toadd;
539	char **product;
540	int didsomething = 2;
541
542	if (flip)
543		product = theunit->denominator;
544	else
545		product = theunit->numerator;
546
547	for (; *product; product++) {
548
549		for (;;) {
550			if (!strlen(*product))
551				break;
552			toadd = lookupunit(*product);
553			if (!toadd) {
554				printf("unknown unit '%s'\n", *product);
555				return ERROR;
556			}
557			if (strchr(toadd, PRIMITIVECHAR))
558				break;
559			didsomething = 1;
560			if (*product != NULLUNIT) {
561				free(*product);
562				*product = NULLUNIT;
563			}
564			if (addunit(theunit, toadd, flip, 0))
565				return ERROR;
566		}
567	}
568	return didsomething;
569}
570
571
572/*
573   Reduces numerator and denominator of the specified unit.
574   Returns 0 on success, or 1 on unknown unit error.
575*/
576
577int 
578reduceunit(struct unittype * theunit)
579{
580	int ret;
581
582	ret = 1;
583	while (ret & 1) {
584		ret = reduceproduct(theunit, 0) | reduceproduct(theunit, 1);
585		if (ret & 4)
586			return 1;
587	}
588	return 0;
589}
590
591
592int 
593compareproducts(char **one, char **two)
594{
595	while (*one || *two) {
596		if (!*one && *two != NULLUNIT)
597			return 1;
598		if (!*two && *one != NULLUNIT)
599			return 1;
600		if (*one == NULLUNIT)
601			one++;
602		else if (*two == NULLUNIT)
603			two++;
604		else if (strcmp(*one, *two))
605			return 1;
606		else
607			one++, two++;
608	}
609	return 0;
610}
611
612
613/* Return zero if units are compatible, nonzero otherwise */
614
615int 
616compareunits(struct unittype * first, struct unittype * second)
617{
618	return
619	compareproducts(first->numerator, second->numerator) ||
620	compareproducts(first->denominator, second->denominator);
621}
622
623
624int 
625completereduce(struct unittype * unit)
626{
627	if (reduceunit(unit))
628		return 1;
629	sortunit(unit);
630	cancelunit(unit);
631	return 0;
632}
633
634
635void 
636showanswer(struct unittype * have, struct unittype * want)
637{
638	if (compareunits(have, want)) {
639		printf("conformability error\n");
640		showunit(have);
641		showunit(want);
642	}
643	else if (have->offset != want->offset) {
644		if (want->quantity)
645			printf("WARNING: conversion of non-proportional quantities.\n");
646		printf("\t");
647		if (have->quantity)
648			printf("%.8g\n",
649			    (have->factor + have->offset-want->offset)/want->factor);
650		else
651			printf(" (-> x*%.8g %+.8g)\n\t (<- y*%.8g %+.8g)\n",
652			    have->factor / want->factor,
653			    (have->offset-want->offset)/want->factor,
654			    want->factor / have->factor,
655			    (want->offset - have->offset)/have->factor);
656	}
657	else
658		printf("\t* %.8g\n\t/ %.8g\n", have->factor / want->factor,
659		    want->factor / have->factor);
660}
661
662
663void 
664usage(void)
665{
666	fprintf(stderr,
667		"usage: units [-f unitsfile] [-q] [-v] [from-unit to-unit]\n");
668	exit(3);
669}
670
671
672int
673main(int argc, char **argv)
674{
675
676	struct unittype have, want;
677	char havestr[81], wantstr[81];
678	int optchar;
679	char *userfile = 0;
680	int quiet = 0;
681
682	while ((optchar = getopt(argc, argv, "vqf:")) != -1) {
683		switch (optchar) {
684		case 'f':
685			userfile = optarg;
686			break;
687		case 'q':
688			quiet = 1;
689			break;
690		case 'v':
691			fprintf(stderr, "\n  units version %s  Copyright (c) 1993 by Adrian Mariano\n",
692			    VERSION);
693			fprintf(stderr, "                    This program may be freely distributed\n");
694			usage();
695		default:
696			usage();
697			break;
698		}
699	}
700
701	if (optind != argc - 2 && optind != argc)
702		usage();
703
704	readunits(userfile);
705
706	if (optind == argc - 2) {
707		strlcpy(havestr, argv[optind], sizeof(havestr));
708		strlcpy(wantstr, argv[optind + 1], sizeof(wantstr));
709		initializeunit(&have);
710		addunit(&have, havestr, 0, 1);
711		completereduce(&have);
712		initializeunit(&want);
713		addunit(&want, wantstr, 0, 1);
714		completereduce(&want);
715		showanswer(&have, &want);
716	}
717	else {
718		if (!quiet)
719			printf("%d units, %d prefixes\n", unitcount,
720			    prefixcount);
721		for (;;) {
722			do {
723				initializeunit(&have);
724				if (!quiet)
725					printf("You have: ");
726				if (!fgets(havestr, sizeof(havestr), stdin)) {
727					if (!quiet)
728						putchar('\n');
729					exit(0);
730				}
731			} while (addunit(&have, havestr, 0, 1) ||
732			    completereduce(&have));
733			do {
734				initializeunit(&want);
735				if (!quiet)
736					printf("You want: ");
737				if (!fgets(wantstr, sizeof(wantstr), stdin)) {
738					if (!quiet)
739						putchar('\n');
740					exit(0);
741				}
742			} while (addunit(&want, wantstr, 0, 1) ||
743			    completereduce(&want));
744			showanswer(&have, &want);
745		}
746	}
747
748	return(0);
749}