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 #define _PATH_UNITSLIB "/usr/share/misc/units.lib" 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