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