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