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