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