xref: /freebsd/usr.bin/units/units.c (revision 65b71c48d226f3ef3eb1c4452dccc678a7d2ac96) 
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
19 static const char rcsid[] =
20   "$FreeBSD$";
21 #endif /* not lint */
22 
23 #include <ctype.h>
24 #include <err.h>
25 #include <errno.h>
26 #include <histedit.h>
27 #include <getopt.h>
28 #include <stdbool.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include <sys/capsicum.h>
35 
36 #include "pathnames.h"
37 
38 #ifndef UNITSFILE
39 #define UNITSFILE _PATH_UNITSLIB
40 #endif
41 
42 #define MAXUNITS 1000
43 #define MAXPREFIXES 100
44 
45 #define MAXSUBUNITS 500
46 
47 #define PRIMITIVECHAR '!'
48 
49 static const char *powerstring = "^";
50 
51 static struct {
52 	char *uname;
53 	char *uval;
54 }      unittable[MAXUNITS];
55 
56 struct unittype {
57 	char *numerator[MAXSUBUNITS];
58 	char *denominator[MAXSUBUNITS];
59 	double factor;
60 	double offset;
61 	int quantity;
62 };
63 
64 static struct {
65 	char *prefixname;
66 	char *prefixval;
67 }      prefixtable[MAXPREFIXES];
68 
69 
70 static char NULLUNIT[] = "";
71 
72 #define SEPARATOR      ":"
73 
74 static int unitcount;
75 static int prefixcount;
76 static bool verbose = false;
77 static bool terse = false;
78 static const char * outputformat;
79 static const char * havestr;
80 static const char * wantstr;
81 
82 static int	 addsubunit(char *product[], char *toadd);
83 static int	 addunit(struct unittype *theunit, const char *toadd, int flip, int quantity);
84 static void	 cancelunit(struct unittype * theunit);
85 static int	 compare(const void *item1, const void *item2);
86 static int	 compareproducts(char **one, char **two);
87 static int	 compareunits(struct unittype * first, struct unittype * second);
88 static int	 completereduce(struct unittype * unit);
89 static char	*dupstr(const char *str);
90 static void	 initializeunit(struct unittype * theunit);
91 static char	*lookupunit(const char *unit);
92 static void	 readunits(const char *userfile);
93 static int	 reduceproduct(struct unittype * theunit, int flip);
94 static int	 reduceunit(struct unittype * theunit);
95 static void	 showanswer(struct unittype * have, struct unittype * want);
96 static void	 showunit(struct unittype * theunit);
97 static void	 sortunit(struct unittype * theunit);
98 static void	 usage(void);
99 static void	 zeroerror(void);
100 
101 static const char* promptstr = "";
102 
103 static const char * prompt(EditLine *e __unused) {
104 	return promptstr;
105 }
106 
107 static char *
108 dupstr(const char *str)
109 {
110 	char *ret;
111 
112 	ret = strdup(str);
113 	if (!ret)
114 		err(3, "dupstr");
115 	return (ret);
116 }
117 
118 
119 static void
120 readunits(const char *userfile)
121 {
122 	FILE *unitfile;
123 	char line[512], *lineptr;
124 	int len, linenum, i;
125 	cap_rights_t unitfilerights;
126 
127 	unitcount = 0;
128 	linenum = 0;
129 
130 	if (userfile) {
131 		unitfile = fopen(userfile, "rt");
132 		if (!unitfile)
133 			errx(1, "unable to open units file '%s'", userfile);
134 	}
135 	else {
136 		unitfile = fopen(UNITSFILE, "rt");
137 		if (!unitfile) {
138 			char *direc, *env;
139 			char filename[1000];
140 
141 			env = getenv("PATH");
142 			if (env) {
143 				direc = strtok(env, SEPARATOR);
144 				while (direc) {
145 					snprintf(filename, sizeof(filename),
146 					    "%s/%s", direc, UNITSFILE);
147 					unitfile = fopen(filename, "rt");
148 					if (unitfile)
149 						break;
150 					direc = strtok(NULL, SEPARATOR);
151 				}
152 			}
153 			if (!unitfile)
154 				errx(1, "can't find units file '%s'", UNITSFILE);
155 		}
156 	}
157 	cap_rights_init(&unitfilerights, CAP_READ, CAP_FSTAT);
158 	if (cap_rights_limit(fileno(unitfile), &unitfilerights) < 0
159 		&& errno != ENOSYS)
160 		err(1, "cap_rights_limit() failed");
161 	while (!feof(unitfile)) {
162 		if (!fgets(line, sizeof(line), unitfile))
163 			break;
164 		linenum++;
165 		lineptr = line;
166 		if (*lineptr == '/' || *lineptr == '#')
167 			continue;
168 		lineptr += strspn(lineptr, " \n\t");
169 		len = strcspn(lineptr, " \n\t");
170 		lineptr[len] = 0;
171 		if (!strlen(lineptr))
172 			continue;
173 		if (lineptr[strlen(lineptr) - 1] == '-') { /* it's a prefix */
174 			if (prefixcount == MAXPREFIXES) {
175 				warnx("memory for prefixes exceeded in line %d", linenum);
176 				continue;
177 			}
178 			lineptr[strlen(lineptr) - 1] = 0;
179 			prefixtable[prefixcount].prefixname = dupstr(lineptr);
180 			for (i = 0; i < prefixcount; i++)
181 				if (!strcmp(prefixtable[i].prefixname, lineptr)) {
182 					warnx("redefinition of prefix '%s' on line %d ignored",
183 					    lineptr, linenum);
184 					continue;
185 				}
186 			lineptr += len + 1;
187 			lineptr += strspn(lineptr, " \n\t");
188 			len = strcspn(lineptr, "\n\t");
189 			if (len == 0) {
190 				warnx("unexpected end of prefix on line %d",
191 				    linenum);
192 				continue;
193 			}
194 			lineptr[len] = 0;
195 			prefixtable[prefixcount++].prefixval = dupstr(lineptr);
196 		}
197 		else {		/* it's not a prefix */
198 			if (unitcount == MAXUNITS) {
199 				warnx("memory for units exceeded in line %d", linenum);
200 				continue;
201 			}
202 			unittable[unitcount].uname = dupstr(lineptr);
203 			for (i = 0; i < unitcount; i++)
204 				if (!strcmp(unittable[i].uname, lineptr)) {
205 					warnx("redefinition of unit '%s' on line %d ignored",
206 					    lineptr, linenum);
207 					continue;
208 				}
209 			lineptr += len + 1;
210 			lineptr += strspn(lineptr, " \n\t");
211 			if (!strlen(lineptr)) {
212 				warnx("unexpected end of unit on line %d",
213 				    linenum);
214 				continue;
215 			}
216 			len = strcspn(lineptr, "\n\t");
217 			lineptr[len] = 0;
218 			unittable[unitcount++].uval = dupstr(lineptr);
219 		}
220 	}
221 	fclose(unitfile);
222 }
223 
224 static void
225 initializeunit(struct unittype * theunit)
226 {
227 	theunit->numerator[0] = theunit->denominator[0] = NULL;
228 	theunit->factor = 1.0;
229 	theunit->offset = 0.0;
230 	theunit->quantity = 0;
231 }
232 
233 
234 static int
235 addsubunit(char *product[], char *toadd)
236 {
237 	char **ptr;
238 
239 	for (ptr = product; *ptr && *ptr != NULLUNIT; ptr++);
240 	if (ptr >= product + MAXSUBUNITS) {
241 		warnx("memory overflow in unit reduction");
242 		return 1;
243 	}
244 	if (!*ptr)
245 		*(ptr + 1) = NULL;
246 	*ptr = dupstr(toadd);
247 	return 0;
248 }
249 
250 
251 static void
252 showunit(struct unittype * theunit)
253 {
254 	char **ptr;
255 	int printedslash;
256 	int counter = 1;
257 
258 	printf("%.8g", theunit->factor);
259 	if (theunit->offset)
260 		printf("&%.8g", theunit->offset);
261 	for (ptr = theunit->numerator; *ptr; ptr++) {
262 		if (ptr > theunit->numerator && **ptr &&
263 		    !strcmp(*ptr, *(ptr - 1)))
264 			counter++;
265 		else {
266 			if (counter > 1)
267 				printf("%s%d", powerstring, counter);
268 			if (**ptr)
269 				printf(" %s", *ptr);
270 			counter = 1;
271 		}
272 	}
273 	if (counter > 1)
274 		printf("%s%d", powerstring, counter);
275 	counter = 1;
276 	printedslash = 0;
277 	for (ptr = theunit->denominator; *ptr; ptr++) {
278 		if (ptr > theunit->denominator && **ptr &&
279 		    !strcmp(*ptr, *(ptr - 1)))
280 			counter++;
281 		else {
282 			if (counter > 1)
283 				printf("%s%d", powerstring, counter);
284 			if (**ptr) {
285 				if (!printedslash)
286 					printf(" /");
287 				printedslash = 1;
288 				printf(" %s", *ptr);
289 			}
290 			counter = 1;
291 		}
292 	}
293 	if (counter > 1)
294 		printf("%s%d", powerstring, counter);
295 	printf("\n");
296 }
297 
298 
299 void
300 zeroerror(void)
301 {
302 	warnx("unit reduces to zero");
303 }
304 
305 /*
306    Adds the specified string to the unit.
307    Flip is 0 for adding normally, 1 for adding reciprocal.
308    Quantity is 1 if this is a quantity to be converted rather than a pure unit.
309 
310    Returns 0 for successful addition, nonzero on error.
311 */
312 
313 static int
314 addunit(struct unittype * theunit, const char *toadd, int flip, int quantity)
315 {
316 	char *scratch, *savescr;
317 	char *item;
318 	char *divider, *slash, *offset;
319 	int doingtop;
320 
321 	if (!strlen(toadd))
322 		return 1;
323 
324 	savescr = scratch = dupstr(toadd);
325 	for (slash = scratch + 1; *slash; slash++)
326 		if (*slash == '-' &&
327 		    (tolower(*(slash - 1)) != 'e' ||
328 		    !strchr(".0123456789", *(slash + 1))))
329 			*slash = ' ';
330 	slash = strchr(scratch, '/');
331 	if (slash)
332 		*slash = 0;
333 	doingtop = 1;
334 	do {
335 		item = strtok(scratch, " *\t\n/");
336 		while (item) {
337 			if (strchr("0123456789.", *item)) { /* item is a number */
338 				double num, offsetnum;
339 
340 				if (quantity)
341 					theunit->quantity = 1;
342 
343 				offset = strchr(item, '&');
344 				if (offset) {
345 					*offset = 0;
346 					offsetnum = atof(offset+1);
347 				} else
348 					offsetnum = 0.0;
349 
350 				divider = strchr(item, '|');
351 				if (divider) {
352 					*divider = 0;
353 					num = atof(item);
354 					if (!num) {
355 						zeroerror();
356 						return 1;
357 					}
358 					if (doingtop ^ flip) {
359 						theunit->factor *= num;
360 						theunit->offset *= num;
361 					} else {
362 						theunit->factor /= num;
363 						theunit->offset /= num;
364 					}
365 					num = atof(divider + 1);
366 					if (!num) {
367 						zeroerror();
368 						return 1;
369 					}
370 					if (doingtop ^ flip) {
371 						theunit->factor /= num;
372 						theunit->offset /= num;
373 					} else {
374 						theunit->factor *= num;
375 						theunit->offset *= num;
376 					}
377 				}
378 				else {
379 					num = atof(item);
380 					if (!num) {
381 						zeroerror();
382 						return 1;
383 					}
384 					if (doingtop ^ flip) {
385 						theunit->factor *= num;
386 						theunit->offset *= num;
387 					} else {
388 						theunit->factor /= num;
389 						theunit->offset /= num;
390 					}
391 				}
392 				if (doingtop ^ flip)
393 					theunit->offset += offsetnum;
394 			}
395 			else {	/* item is not a number */
396 				int repeat = 1;
397 
398 				if (strchr("23456789",
399 				    item[strlen(item) - 1])) {
400 					repeat = item[strlen(item) - 1] - '0';
401 					item[strlen(item) - 1] = 0;
402 				}
403 				for (; repeat; repeat--)
404 					if (addsubunit(doingtop ^ flip ? theunit->numerator : theunit->denominator, item))
405 						return 1;
406 			}
407 			item = strtok(NULL, " *\t/\n");
408 		}
409 		doingtop--;
410 		if (slash) {
411 			scratch = slash + 1;
412 		}
413 		else
414 			doingtop--;
415 	} while (doingtop >= 0);
416 	free(savescr);
417 	return 0;
418 }
419 
420 
421 static int
422 compare(const void *item1, const void *item2)
423 {
424 	return strcmp(*(const char * const *)item1, *(const char * const *)item2);
425 }
426 
427 
428 static void
429 sortunit(struct unittype * theunit)
430 {
431 	char **ptr;
432 	unsigned int count;
433 
434 	for (count = 0, ptr = theunit->numerator; *ptr; ptr++, count++);
435 	qsort(theunit->numerator, count, sizeof(char *), compare);
436 	for (count = 0, ptr = theunit->denominator; *ptr; ptr++, count++);
437 	qsort(theunit->denominator, count, sizeof(char *), compare);
438 }
439 
440 
441 void
442 cancelunit(struct unittype * theunit)
443 {
444 	char **den, **num;
445 	int comp;
446 
447 	den = theunit->denominator;
448 	num = theunit->numerator;
449 
450 	while (*num && *den) {
451 		comp = strcmp(*den, *num);
452 		if (!comp) {
453 /*      if (*den!=NULLUNIT) free(*den);
454       if (*num!=NULLUNIT) free(*num);*/
455 			*den++ = NULLUNIT;
456 			*num++ = NULLUNIT;
457 		}
458 		else if (comp < 0)
459 			den++;
460 		else
461 			num++;
462 	}
463 }
464 
465 
466 
467 
468 /*
469    Looks up the definition for the specified unit.
470    Returns a pointer to the definition or a null pointer
471    if the specified unit does not appear in the units table.
472 */
473 
474 static char buffer[100];	/* buffer for lookupunit answers with
475 				   prefixes */
476 
477 char *
478 lookupunit(const char *unit)
479 {
480 	int i;
481 	char *copy;
482 
483 	for (i = 0; i < unitcount; i++) {
484 		if (!strcmp(unittable[i].uname, unit))
485 			return unittable[i].uval;
486 	}
487 
488 	if (unit[strlen(unit) - 1] == '^') {
489 		copy = dupstr(unit);
490 		copy[strlen(copy) - 1] = 0;
491 		for (i = 0; i < unitcount; i++) {
492 			if (!strcmp(unittable[i].uname, copy)) {
493 				strlcpy(buffer, copy, sizeof(buffer));
494 				free(copy);
495 				return buffer;
496 			}
497 		}
498 		free(copy);
499 	}
500 	if (unit[strlen(unit) - 1] == 's') {
501 		copy = dupstr(unit);
502 		copy[strlen(copy) - 1] = 0;
503 		for (i = 0; i < unitcount; i++) {
504 			if (!strcmp(unittable[i].uname, copy)) {
505 				strlcpy(buffer, copy, sizeof(buffer));
506 				free(copy);
507 				return buffer;
508 			}
509 		}
510 		if (copy[strlen(copy) - 1] == 'e') {
511 			copy[strlen(copy) - 1] = 0;
512 			for (i = 0; i < unitcount; i++) {
513 				if (!strcmp(unittable[i].uname, copy)) {
514 					strlcpy(buffer, copy, sizeof(buffer));
515 					free(copy);
516 					return buffer;
517 				}
518 			}
519 		}
520 		free(copy);
521 	}
522 	for (i = 0; i < prefixcount; i++) {
523 		size_t len = strlen(prefixtable[i].prefixname);
524 		if (!strncmp(prefixtable[i].prefixname, unit, len)) {
525 			if (!strlen(unit + len) || lookupunit(unit + len)) {
526 				snprintf(buffer, sizeof(buffer), "%s %s",
527 				    prefixtable[i].prefixval, unit + len);
528 				return buffer;
529 			}
530 		}
531 	}
532 	return 0;
533 }
534 
535 
536 
537 /*
538    reduces a product of symbolic units to primitive units.
539    The three low bits are used to return flags:
540 
541      bit 0 (1) set on if reductions were performed without error.
542      bit 1 (2) set on if no reductions are performed.
543      bit 2 (4) set on if an unknown unit is discovered.
544 */
545 
546 
547 #define ERROR 4
548 
549 static int
550 reduceproduct(struct unittype * theunit, int flip)
551 {
552 
553 	char *toadd;
554 	char **product;
555 	int didsomething = 2;
556 
557 	if (flip)
558 		product = theunit->denominator;
559 	else
560 		product = theunit->numerator;
561 
562 	for (; *product; product++) {
563 
564 		for (;;) {
565 			if (!strlen(*product))
566 				break;
567 			toadd = lookupunit(*product);
568 			if (!toadd) {
569 				printf("unknown unit '%s'\n", *product);
570 				return ERROR;
571 			}
572 			if (strchr(toadd, PRIMITIVECHAR))
573 				break;
574 			didsomething = 1;
575 			if (*product != NULLUNIT) {
576 				free(*product);
577 				*product = NULLUNIT;
578 			}
579 			if (addunit(theunit, toadd, flip, 0))
580 				return ERROR;
581 		}
582 	}
583 	return didsomething;
584 }
585 
586 
587 /*
588    Reduces numerator and denominator of the specified unit.
589    Returns 0 on success, or 1 on unknown unit error.
590 */
591 
592 static int
593 reduceunit(struct unittype * theunit)
594 {
595 	int ret;
596 
597 	ret = 1;
598 	while (ret & 1) {
599 		ret = reduceproduct(theunit, 0) | reduceproduct(theunit, 1);
600 		if (ret & 4)
601 			return 1;
602 	}
603 	return 0;
604 }
605 
606 
607 static int
608 compareproducts(char **one, char **two)
609 {
610 	while (*one || *two) {
611 		if (!*one && *two != NULLUNIT)
612 			return 1;
613 		if (!*two && *one != NULLUNIT)
614 			return 1;
615 		if (*one == NULLUNIT)
616 			one++;
617 		else if (*two == NULLUNIT)
618 			two++;
619 		else if (strcmp(*one, *two))
620 			return 1;
621 		else
622 			one++, two++;
623 	}
624 	return 0;
625 }
626 
627 
628 /* Return zero if units are compatible, nonzero otherwise */
629 
630 static int
631 compareunits(struct unittype * first, struct unittype * second)
632 {
633 	return
634 	compareproducts(first->numerator, second->numerator) ||
635 	compareproducts(first->denominator, second->denominator);
636 }
637 
638 
639 static int
640 completereduce(struct unittype * unit)
641 {
642 	if (reduceunit(unit))
643 		return 1;
644 	sortunit(unit);
645 	cancelunit(unit);
646 	return 0;
647 }
648 
649 static void
650 showanswer(struct unittype * have, struct unittype * want)
651 {
652 	double ans;
653 	char* oformat;
654 
655 	if (compareunits(have, want)) {
656 		printf("conformability error\n");
657 		if (verbose)
658 			printf("\t%s = ", havestr);
659 		else if (!terse)
660 			printf("\t");
661 		showunit(have);
662 		if (!terse) {
663 			if (verbose)
664 				printf("\t%s = ", wantstr);
665 			else
666 				printf("\t");
667 			showunit(want);
668 		}
669 	}
670 	else if (have->offset != want->offset) {
671 		if (want->quantity)
672 			printf("WARNING: conversion of non-proportional quantities.\n");
673 		if (have->quantity) {
674 			asprintf(&oformat, "\t%s\n", outputformat);
675 			printf(oformat,
676 			    (have->factor + have->offset-want->offset)/want->factor);
677 			free(oformat);
678 		}
679 		else {
680 			asprintf(&oformat, "\t (-> x*%sg %sg)\n\t (<- y*%sg %sg)\n",
681 			    outputformat, outputformat, outputformat, outputformat);
682 			printf(oformat,
683 			    have->factor / want->factor,
684 			    (have->offset-want->offset)/want->factor,
685 			    want->factor / have->factor,
686 			    (want->offset - have->offset)/have->factor);
687 		}
688 	}
689 	else {
690 		ans = have->factor / want->factor;
691 
692 		if (verbose) {
693 			printf("\t%s = ", havestr);
694 			printf(outputformat, ans);
695 			printf(" * %s", wantstr);
696 			printf("\n");
697 		}
698 		else if (terse) {
699 			printf(outputformat, ans);
700 			printf("\n");
701 		}
702 		else {
703 			printf("\t* ");
704 			printf(outputformat, ans);
705 			printf("\n");
706 		}
707 
708 		if (verbose) {
709 			printf("\t%s = (1 / ", havestr);
710 			printf(outputformat, 1/ans);
711 			printf(") * %s\n", wantstr);
712 		}
713 		else if (!terse) {
714 			printf("\t/ ");
715 			printf(outputformat, 1/ans);
716 			printf("\n");
717 		}
718 	}
719 }
720 
721 
722 static void
723 usage(void)
724 {
725 	fprintf(stderr,
726 		"usage: units [-f unitsfile] [-UVq] [from-unit to-unit]\n");
727 	exit(3);
728 }
729 
730 static struct option longopts[] = {
731 	{"help", no_argument, NULL, 'h'},
732 	{"exponential", no_argument, NULL, 'e'},
733 	{"file", required_argument, NULL, 'f'},
734 	{"output-format", required_argument, NULL, 'o'},
735 	{"quiet", no_argument, NULL, 'q'},
736 	{"terse", no_argument, NULL, 't'},
737 	{"unitsfile", no_argument, NULL, 'U'},
738 	{"verbose", no_argument, NULL, 'v'},
739 	{"version", no_argument, NULL, 'V'},
740 	{ 0, 0, 0, 0 }
741 };
742 
743 
744 int
745 main(int argc, char **argv)
746 {
747 
748 	struct unittype have, want;
749 	int optchar;
750 	bool quiet;
751 	bool readfile;
752 	History *inhistory;
753 	EditLine *el;
754 	HistEvent ev;
755 	int inputsz;
756 
757 	quiet = false;
758 	readfile = false;
759 	outputformat = "%.8g";
760 	while ((optchar = getopt_long(argc, argv, "+ehf:oqtvUV", longopts, NULL)) != -1) {
761 		switch (optchar) {
762 		case 'e':
763 			outputformat = "%6e";
764 			break;
765 		case 'f':
766 			readfile = true;
767 			if (strlen(optarg) == 0)
768 				readunits(NULL);
769 			else
770 				readunits(optarg);
771 			break;
772 		case 'q':
773 			quiet = true;
774 			break;
775 		case 't':
776 			terse = true;
777 			break;
778 		case 'o':
779 			outputformat = optarg;
780 			break;
781 		case 'v':
782 			verbose = true;
783 			break;
784 		case 'V':
785 			fprintf(stderr, "FreeBSD units\n");
786 			/* FALLTHROUGH */
787 		case 'U':
788 			if (access(UNITSFILE, F_OK) == 0)
789 				printf("%s\n", UNITSFILE);
790 			else
791 				printf("Units data file not found");
792 			exit(0);
793 			break;
794 		case 'h':
795 			/* FALLTHROUGH */
796 
797 		default:
798 			usage();
799 		}
800 	}
801 
802 	if (!readfile)
803 		readunits(NULL);
804 
805 	if (optind == argc - 2) {
806 		if (cap_enter() < 0 && errno != ENOSYS)
807 			err(1, "unable to enter capability mode");
808 
809 		havestr = argv[optind];
810 		wantstr = argv[optind + 1];
811 		initializeunit(&have);
812 		addunit(&have, havestr, 0, 1);
813 		completereduce(&have);
814 		initializeunit(&want);
815 		addunit(&want, wantstr, 0, 1);
816 		completereduce(&want);
817 		showanswer(&have, &want);
818 	} else {
819 		inhistory = history_init();
820 		el = el_init(argv[0], stdin, stdout, stderr);
821 		el_set(el, EL_PROMPT, &prompt);
822 		el_set(el, EL_EDITOR, "emacs");
823 		el_set(el, EL_SIGNAL, 1);
824 		el_set(el, EL_HIST, history, inhistory);
825 		el_source(el, NULL);
826 		history(inhistory, &ev, H_SETSIZE, 800);
827 		if (inhistory == 0)
828 			err(1, "Could not initialize history");
829 
830 		if (cap_enter() < 0 && errno != ENOSYS)
831 			err(1, "unable to enter capability mode");
832 
833 		if (!quiet)
834 			printf("%d units, %d prefixes\n", unitcount,
835 			    prefixcount);
836 		for (;;) {
837 			do {
838 				initializeunit(&have);
839 				if (!quiet)
840 					promptstr = "You have: ";
841 				havestr = el_gets(el, &inputsz);
842 				if (havestr == NULL)
843 					exit(0);
844 				if (inputsz > 0)
845 					history(inhistory, &ev, H_ENTER,
846 					havestr);
847 			} while (addunit(&have, havestr, 0, 1) ||
848 			    completereduce(&have));
849 			do {
850 				initializeunit(&want);
851 				if (!quiet)
852 					promptstr = "You want: ";
853 				wantstr = el_gets(el, &inputsz);
854 				if (wantstr == NULL)
855 					exit(0);
856 				if (inputsz > 0)
857 					history(inhistory, &ev, H_ENTER,
858 					wantstr);
859 			} while (addunit(&want, wantstr, 0, 1) ||
860 			    completereduce(&want));
861 			showanswer(&have, &want);
862 		}
863 
864 		history_end(inhistory);
865 		el_end(el);
866 	}
867 
868 	return (0);
869 }
870