usr.bin/units/units.c

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