Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/units/units.c	Lines:	0	326	0.0 %
Date:	2016-12-06	Branches:	0	250	0.0 %


/*	$OpenBSD: units.c,v 1.22 2015/10/09 01:37:09 deraadt Exp $	*/
/*	$NetBSD: units.c,v 1.6 1996/04/06 06:01:03 thorpej Exp $	*/

/*
 * units.c   Copyright (c) 1993 by Adrian Mariano (adrian@cam.cornell.edu)
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 * Disclaimer:  This software is provided by the author "as is".  The author
 * shall not be liable for any damages caused in any way by this software.
 *
 * I would appreciate (though I do not require) receiving a copy of any
 * improvements you might make to this program.
 */

#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>

#define UNITSFILE "/usr/share/misc/units.lib"

#define VERSION "1.0"

#define MAXUNITS 1000
#define MAXPREFIXES 100

#define MAXSUBUNITS 500

#define PRIMITIVECHAR '!'

char *powerstring = "^";

struct {
	char *uname;
	char *uval;
} unittable[MAXUNITS];

struct unittype {
	char *numerator[MAXSUBUNITS];
	char *denominator[MAXSUBUNITS];
	double factor;
};

struct {
	char *prefixname;
	char *prefixval;
} prefixtable[MAXPREFIXES];


char *NULLUNIT = "";

int unitcount;
int prefixcount;

char *dupstr(char *);
void readunits(char *);
void initializeunit(struct unittype *);
int addsubunit(char *[], char *);
void showunit(struct unittype *);
void zeroerror(void);
int addunit(struct unittype *, char *, int);
int compare(const void *, const void *);
void sortunit(struct unittype *);
void cancelunit(struct unittype *);
char *lookupunit(char *);
int reduceproduct(struct unittype *, int);
int reduceunit(struct unittype *);
int compareproducts(char **, char **);
int compareunits(struct unittype *, struct unittype *);
int completereduce(struct unittype *);
void showanswer(struct unittype *, struct unittype *);
void usage(void);

char *
dupstr(char *str)
{
	char *ret;

	ret = strdup(str);
	if (!ret) {
		fprintf(stderr, "Memory allocation error\n");
		exit(3);
	}
	return (ret);
}


void
readunits(char *userfile)
{
	char line[512], *lineptr;
	int len, linenum, i;
	FILE *unitfile;

	unitcount = 0;
	linenum = 0;

	if (userfile) {
		unitfile = fopen(userfile, "r");
		if (!unitfile) {
			fprintf(stderr, "Unable to open units file '%s'\n",
			    userfile);
			exit(1);
		}
	} else {
		unitfile = fopen(UNITSFILE, "r");
		if (!unitfile) {
			fprintf(stderr, "Can't find units file '%s'\n",
			    UNITSFILE);
			exit(1);
		}
	}
	while (!feof(unitfile)) {
		if (!fgets(line, sizeof(line), unitfile))
			break;
		linenum++;
		lineptr = line;
		if (*lineptr == '/')
			continue;
		lineptr += strspn(lineptr, " \n\t");
		len = strcspn(lineptr, " \n\t");
		lineptr[len] = 0;
		if (!strlen(lineptr))
			continue;
		if (lineptr[strlen(lineptr) - 1] == '-') { /* it's a prefix */
			if (prefixcount == MAXPREFIXES) {
				fprintf(stderr,
				    "Memory for prefixes exceeded in line %d\n",
				    linenum);
				continue;
			}

			lineptr[strlen(lineptr) - 1] = 0;
			for (i = 0; i < prefixcount; i++) {
				if (!strcmp(prefixtable[i].prefixname, lineptr))
					break;
			}
			if (i < prefixcount) {
				fprintf(stderr, "Redefinition of prefix '%s' "
				    "on line %d ignored\n", lineptr, linenum);
				continue;	/* skip duplicate prefix */
			}

			prefixtable[prefixcount].prefixname = dupstr(lineptr);
			lineptr += len + 1;
			lineptr += strspn(lineptr, " \n\t");
			len = strcspn(lineptr, "\n\t");
			if (len == 0) {
				fprintf(stderr, "Unexpected end of prefix on "
				    "line %d\n", linenum);
				free(prefixtable[prefixcount].prefixname);
				continue;
			}
			lineptr[len] = 0;
			prefixtable[prefixcount++].prefixval = dupstr(lineptr);
		} else {		/* it's not a prefix */
			if (unitcount == MAXUNITS) {
				fprintf(stderr,
				    "Memory for units exceeded in line %d\n",
				    linenum);
				continue;
			}

			for (i = 0; i < unitcount; i++) {
				if (!strcmp(unittable[i].uname, lineptr))
					break;
			}
			if (i < unitcount) {
				fprintf(stderr, "Redefinition of unit '%s' "
				    "on line %d ignored\n", lineptr, linenum);
				continue;	/* skip duplicate unit */
			}

			unittable[unitcount].uname = dupstr(lineptr);
			lineptr += len + 1;
			lineptr += strspn(lineptr, " \n\t");
			if (!strlen(lineptr)) {
				fprintf(stderr, "Unexpected end of unit on "
				    "line %d\n", linenum);
				free(unittable[unitcount].uname);
				continue;
			}
			len = strcspn(lineptr, "\n\t");
			lineptr[len] = 0;
			unittable[unitcount++].uval = dupstr(lineptr);
		}
	}
	fclose(unitfile);
}

void
initializeunit(struct unittype *theunit)
{
	theunit->factor = 1.0;
	theunit->numerator[0] = theunit->denominator[0] = NULL;
}


int
addsubunit(char *product[], char *toadd)
{
	char **ptr;

	for (ptr = product; *ptr && *ptr != NULLUNIT; ptr++);
	if (ptr >= product + MAXSUBUNITS) {
		fprintf(stderr, "Memory overflow in unit reduction\n");
		return 1;
	}
	if (!*ptr)
		*(ptr + 1) = 0;
	*ptr = dupstr(toadd);
	return 0;
}


void
showunit(struct unittype *theunit)
{
	char **ptr;
	int printedslash;
	int counter = 1;

	printf("\t%.8g", theunit->factor);
	for (ptr = theunit->numerator; *ptr; ptr++) {
		if (ptr > theunit->numerator && **ptr &&
		    !strcmp(*ptr, *(ptr - 1)))
			counter++;
		else {
			if (counter > 1)
				printf("%s%d", powerstring, counter);
			if (**ptr)
				printf(" %s", *ptr);
			counter = 1;
		}
	}
	if (counter > 1)
		printf("%s%d", powerstring, counter);
	counter = 1;
	printedslash = 0;
	for (ptr = theunit->denominator; *ptr; ptr++) {
		if (ptr > theunit->denominator && **ptr &&
		    !strcmp(*ptr, *(ptr - 1)))
			counter++;
		else {
			if (counter > 1)
				printf("%s%d", powerstring, counter);
			if (**ptr) {
				if (!printedslash)
					printf(" /");
				printedslash = 1;
				printf(" %s", *ptr);
			}
			counter = 1;
		}
	}
	if (counter > 1)
		printf("%s%d", powerstring, counter);
	printf("\n");
}


void
zeroerror(void)
{
	fprintf(stderr, "Unit reduces to zero\n");
}

/*
   Adds the specified string to the unit.
   Flip is 0 for adding normally, 1 for adding reciprocal.

   Returns 0 for successful addition, nonzero on error.
*/

int
addunit(struct unittype *theunit, char *toadd, int flip)
{
	char *scratch, *savescr;
	char *item;
	char *divider, *slash;
	int doingtop;

	savescr = scratch = dupstr(toadd);
	for (slash = scratch + 1; *slash; slash++)
		if (*slash == '-' &&
		    (tolower((unsigned char)*(slash - 1)) != 'e' ||
		    !strchr(".0123456789", *(slash + 1))))
			*slash = ' ';
	slash = strchr(scratch, '/');
	if (slash)
		*slash = 0;
	doingtop = 1;
	do {
		item = strtok(scratch, " *\t\n/");
		while (item) {
			if (strchr("0123456789.", *item)) { /* item is a number */
				double num;

				divider = strchr(item, '|');
				if (divider) {
					*divider = 0;
					num = atof(item);
					if (!num) {
						zeroerror();
						free(savescr);
						return 1;
					}
					if (doingtop ^ flip)
						theunit->factor *= num;
					else
						theunit->factor /= num;
					num = atof(divider + 1);
					if (!num) {
						zeroerror();
						free(savescr);
						return 1;
					}
					if (doingtop ^ flip)
						theunit->factor /= num;
					else
						theunit->factor *= num;
				} else {
					num = atof(item);
					if (!num) {
						zeroerror();
						free(savescr);
						return 1;
					}
					if (doingtop ^ flip)
						theunit->factor *= num;
					else
						theunit->factor /= num;

				}
			} else {	/* item is not a number */
				int repeat = 1;

				if (strchr("23456789",
				    item[strlen(item) - 1])) {
					repeat = item[strlen(item) - 1] - '0';
					item[strlen(item) - 1] = 0;
				}
				for (; repeat; repeat--)
					if (addsubunit(doingtop ^ flip
					    ? theunit->numerator
					    : theunit->denominator, item)) {
						free(savescr);
						return 1;
					}
			}
			item = strtok(NULL, " *\t/\n");
		}
		doingtop--;
		if (slash) {
			scratch = slash + 1;
		} else
			doingtop--;
	} while (doingtop >= 0);
	free(savescr);
	return 0;
}


int
compare(const void *item1, const void *item2)
{
	return strcmp(*(char **) item1, *(char **) item2);
}


void
sortunit(struct unittype *theunit)
{
	char **ptr;
	int count;

	for (count = 0, ptr = theunit->numerator; *ptr; ptr++, count++);
	qsort(theunit->numerator, count, sizeof(char *), compare);
	for (count = 0, ptr = theunit->denominator; *ptr; ptr++, count++);
	qsort(theunit->denominator, count, sizeof(char *), compare);
}


void
cancelunit(struct unittype *theunit)
{
	char **den, **num;
	int comp;

	den = theunit->denominator;
	num = theunit->numerator;

	while (*num && *den) {
		comp = strcmp(*den, *num);
		if (!comp) {
			*den++ = NULLUNIT;
			*num++ = NULLUNIT;
		} else if (comp < 0)
			den++;
		else
			num++;
	}
}




/*
   Looks up the definition for the specified unit.
   Returns a pointer to the definition or a null pointer
   if the specified unit does not appear in the units table.
*/

static char buffer[500];	/* buffer for lookupunit answers with
				   prefixes */

char *
lookupunit(char *unit)
{
	size_t len;
	int i;
	char *copy;

	for (i = 0; i < unitcount; i++) {
		if (!strcmp(unittable[i].uname, unit))
			return unittable[i].uval;
	}

	len = strlen(unit);
	if (len == 0)
		return NULL;
	if (unit[len - 1] == '^') {
		copy = dupstr(unit);
		copy[len - 1] = '\0';
		for (i = 0; i < unitcount; i++) {
			if (!strcmp(unittable[i].uname, copy)) {
				strlcpy(buffer, copy, sizeof(buffer));
				free(copy);
				return buffer;
			}
		}
		free(copy);
	}
	if (unit[len - 1] == 's') {
		copy = dupstr(unit);
		copy[len - 1] = '\0';
		--len;
		for (i = 0; i < unitcount; i++) {
			if (!strcmp(unittable[i].uname, copy)) {
				strlcpy(buffer, copy, sizeof(buffer));
				free(copy);
				return buffer;
			}
		}
		if (len != 0 && copy[len - 1] == 'e') {
			copy[len - 1] = 0;
			for (i = 0; i < unitcount; i++) {
				if (!strcmp(unittable[i].uname, copy)) {
					strlcpy(buffer, copy, sizeof(buffer));
					free(copy);
					return buffer;
				}
			}
		}
		free(copy);
	}
	for (i = 0; i < prefixcount; i++) {
		len = strlen(prefixtable[i].prefixname);
		if (!strncmp(prefixtable[i].prefixname, unit, len)) {
			if (!strlen(unit + len) || lookupunit(unit + len)) {
				snprintf(buffer, sizeof(buffer), "%s %s",
				    prefixtable[i].prefixval, unit + len);
				return buffer;
			}
		}
	}
	return NULL;
}



/*
   reduces a product of symbolic units to primitive units.
   The three low bits are used to return flags:

     bit 0 (1) set on if reductions were performed without error.
     bit 1 (2) set on if no reductions are performed.
     bit 2 (4) set on if an unknown unit is discovered.
*/


#define ERROR 4

int
reduceproduct(struct unittype *theunit, int flip)
{
	char *toadd, **product;
	int didsomething = 2;

	if (flip)
		product = theunit->denominator;
	else
		product = theunit->numerator;

	for (; *product; product++) {

		for (;;) {
			if (!strlen(*product))
				break;
			toadd = lookupunit(*product);
			if (!toadd) {
				printf("unknown unit '%s'\n", *product);
				return ERROR;
			}
			if (strchr(toadd, PRIMITIVECHAR))
				break;
			didsomething = 1;
			if (*product != NULLUNIT) {
				free(*product);
				*product = NULLUNIT;
			}
			if (addunit(theunit, toadd, flip))
				return ERROR;
		}
	}
	return didsomething;
}


/*
   Reduces numerator and denominator of the specified unit.
   Returns 0 on success, or 1 on unknown unit error.
*/

int
reduceunit(struct unittype *theunit)
{
	int ret;

	ret = 1;
	while (ret & 1) {
		ret = reduceproduct(theunit, 0) | reduceproduct(theunit, 1);
		if (ret & 4)
			return 1;
	}
	return 0;
}


int
compareproducts(char **one, char **two)
{
	while (*one || *two) {
		if (!*one && *two != NULLUNIT)
			return 1;
		if (!*two && *one != NULLUNIT)
			return 1;
		if (*one == NULLUNIT)
			one++;
		else if (*two == NULLUNIT)
			two++;
		else if (strcmp(*one, *two))
			return 1;
		else
			one++, two++;
	}
	return 0;
}


/* Return zero if units are compatible, nonzero otherwise */

int
compareunits(struct unittype *first, struct unittype *second)
{
	return compareproducts(first->numerator, second->numerator) ||
	    compareproducts(first->denominator, second->denominator);
}


int
completereduce(struct unittype *unit)
{
	if (reduceunit(unit))
		return 1;
	sortunit(unit);
	cancelunit(unit);
	return 0;
}


void
showanswer(struct unittype *have, struct unittype *want)
{
	if (compareunits(have, want)) {
		printf("conformability error\n");
		showunit(have);
		showunit(want);
	} else
		printf("\t* %.8g\n\t/ %.8g\n", have->factor / want->factor,
		    want->factor / have->factor);
}


void
usage(void)
{
	fprintf(stderr,
	    "usage: units [-qv] [-f filename] [[count] from-unit to-unit]\n");
	exit(3);
}


int
main(int argc, char **argv)
{

	struct unittype have, want;
	char havestr[81], wantstr[81];
	int optchar;
	char *userfile = 0;
	int quiet = 0;

	extern char *optarg;
	extern int optind;

	if (pledge("stdio rpath wpath cpath", NULL) == -1)
		err(1, "pledge");

	while ((optchar = getopt(argc, argv, "vqf:")) != -1) {
		switch (optchar) {
		case 'f':
			userfile = optarg;
			break;
		case 'q':
			quiet = 1;
			break;
		case 'v':
			fprintf(stderr,
			    "units version %s Copyright (c) 1993 by Adrian Mariano\n",
			    VERSION);
			fprintf(stderr,
			    "This program may be freely distributed\n");
			usage();
		default:
			usage();
			break;
		}
	}

	argc -= optind;
	argv += optind;

	if (argc != 3 && argc != 2 && argc != 0)
		usage();

	readunits(userfile);

	if (pledge("stdio wpath cpath rpath", NULL) == -1)
		err(1, "pledge");

	if (argc == 3) {
		strlcpy(havestr, argv[0], sizeof(havestr));
		strlcat(havestr, " ", sizeof(havestr));
		strlcat(havestr, argv[1], sizeof(havestr));
		argc--;
		argv++;
		argv[0] = havestr;
	}

	if (argc == 2) {
		strlcpy(havestr, argv[0], sizeof(havestr));
		strlcpy(wantstr, argv[1], sizeof(wantstr));
		initializeunit(&have);
		addunit(&have, havestr, 0);
		completereduce(&have);
		initializeunit(&want);
		addunit(&want, wantstr, 0);
		completereduce(&want);
		showanswer(&have, &want);
	} else {
		if (!quiet)
			printf("%d units, %d prefixes\n", unitcount,
			    prefixcount);
		for (;;) {
			do {
				initializeunit(&have);
				if (!quiet)
					printf("You have: ");
				if (!fgets(havestr, sizeof(havestr), stdin)) {
					if (!quiet)
						putchar('\n');
					exit(0);
				}
			} while (addunit(&have, havestr, 0) ||
			    completereduce(&have));
			do {
				initializeunit(&want);
				if (!quiet)
					printf("You want: ");
				if (!fgets(wantstr, sizeof(wantstr), stdin)) {
					if (!quiet)
						putchar('\n');
					exit(0);
				}
			} while (addunit(&want, wantstr, 0) ||
			    completereduce(&want));
			showanswer(&have, &want);
		}
	}
	return (0);
}


Generated by: GCOVR (Version 3.3)

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