home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / calculat / units_am.zip / UNITS.C < prev    next >
C/C++ Source or Header  |  1993-07-17  |  14KB  |  593 lines
  1. /* 
  2.    units.c   Copyright (c) 1993 by Adrian Mariano
  3.  
  4.    This program can be freely distributed as long as no money is
  5.    charged for it. 
  6. */
  7.  
  8.  
  9. #include<stdio.h>
  10. #include<string.h>
  11. #include<stdlib.h>
  12.  
  13. #define VERSION "1.0"
  14.  
  15. #ifndef UNITSFILE
  16. #define UNITSFILE "units.lib"
  17. #endif
  18.  
  19. #define MAXUNITS 1000
  20. #define MAXPREFIXES 50
  21.  
  22. #define MAXSUBUNITS 500
  23.  
  24. #define PRIMITIVECHAR '!'
  25.  
  26. char *powerstring="^";
  27.  
  28. struct {
  29.    char *uname;
  30.    char *uval;
  31. } unittable[MAXUNITS];
  32.  
  33. struct unittype {
  34.    char *numerator[MAXSUBUNITS];
  35.    char *denominator[MAXSUBUNITS];
  36.    double factor;
  37. };
  38.  
  39. struct {
  40.    char *prefixname;
  41.    char *prefixval;
  42. } prefixtable[MAXPREFIXES];
  43.  
  44.  
  45. char *NULLUNIT="";
  46.  
  47. int unitcount;
  48. int prefixcount;
  49.  
  50.  
  51. char *dupstr(char *str)
  52. {
  53.   char *ret;
  54.   ret=malloc(strlen(str)+1);
  55.   if (!ret) {
  56.     fprintf(stderr,"Memory allocation error\n");
  57.     exit(3);
  58.   }
  59.   strcpy(ret,str);
  60.   return(ret);
  61. } 
  62.  
  63.  
  64. void readerror(int linenum)
  65. {
  66.   fprintf(stderr,"Error in units file '%s' line %d\n",UNITSFILE,linenum);
  67. }
  68.  
  69.  
  70. void readunits(char *userfile)
  71. {
  72.   FILE *unitfile;
  73.   char line[80],*lineptr;
  74.   int len,linenum,i;
  75.  
  76.   unitcount=0;
  77.   linenum=0;
  78.  
  79.   if (userfile){
  80.     unitfile=fopen(userfile,"rt");
  81.     if (!unitfile) {
  82.       fprintf(stderr,"Unable to open units file '%s'\n",userfile);
  83.       exit(1);
  84.     }
  85.   } else {
  86.     unitfile=fopen(UNITSFILE,"rt");
  87.     if (!unitfile) { 
  88.       char *direc,*env;
  89.       char filename[1000];
  90.       char separator[2];
  91.       env=getenv("PATH");
  92.       if (env){
  93.         if (strchr(env,';')) strcpy(separator,";");
  94.         else strcpy(separator,":");
  95.         direc=strtok(env,separator);
  96.         while(direc){
  97.           strcpy(filename,"");
  98.           strncat(filename,direc,999);
  99.           strncat(filename,"/",999-strlen(filename));
  100.           strncat(filename,UNITSFILE,999-strlen(filename));
  101.           unitfile=fopen(filename,"rt");
  102.           if (unitfile) break;
  103.           direc=strtok(NULL,separator);
  104.         }
  105.       }
  106.       if (!unitfile){
  107.         fprintf(stderr,"Can't find units file '%s'\n",UNITSFILE);
  108.         exit(1);
  109.       }
  110.     }
  111.   }
  112.   while (!feof(unitfile)){
  113.     if (!fgets(line,79,unitfile)) break;
  114.     linenum++;
  115.     lineptr=line;
  116.     if (*lineptr=='/') continue;
  117.     lineptr+=strspn(lineptr," \n\t");
  118.     len = strcspn(lineptr, " \n\t");
  119.     lineptr[len]=0;
  120.     if (!strlen(lineptr)) continue;
  121.     if (lineptr[strlen(lineptr)-1]=='-'){   /* it's a prefix */
  122.       if (prefixcount==MAXPREFIXES) {
  123.         fprintf(stderr,"Memory for prefixes exceeded in line %d\n",linenum);
  124.         continue;
  125.       }
  126.       lineptr[strlen(lineptr)-1]=0;
  127.       prefixtable[prefixcount].prefixname=dupstr(lineptr);
  128.       for(i=0;i<prefixcount;i++) 
  129.         if (!strcmp(prefixtable[i].prefixname,lineptr)){
  130.         fprintf(stderr,"Redefinition of prefix '%s' on line %d ignored\n",
  131.             lineptr,linenum);
  132.     continue;
  133.       }
  134.       lineptr+=len+1;
  135.       if (!strlen(lineptr)) { readerror(linenum); continue;}
  136.       lineptr+=strspn(lineptr," \n\t");
  137.       len = strcspn(lineptr, "\n\t");
  138.       lineptr[len]=0;
  139.       prefixtable[prefixcount++].prefixval=dupstr(lineptr);
  140.     } else {  /* it's not a prefix */
  141.       if (unitcount==MAXUNITS) {
  142.         fprintf(stderr,"Memory for units exceeded in line %d\n",linenum);
  143.         continue;
  144.       }
  145.       unittable[unitcount].uname=dupstr(lineptr);
  146.       for(i=0;i<unitcount;i++) if (!strcmp(unittable[i].uname,lineptr)){
  147.         fprintf(stderr,"Redefinition of unit '%s' on line %d ignored\n",
  148.             lineptr,linenum);
  149.     continue;
  150.       }
  151.       lineptr+=len+1;
  152.       lineptr+=strspn(lineptr," \n\t");
  153.       if (!strlen(lineptr)) { readerror(linenum); continue;}
  154.       len = strcspn(lineptr, "\n\t");
  155.       lineptr[len]=0;
  156.       unittable[unitcount++].uval=dupstr(lineptr);
  157.     }
  158.   }
  159.   fclose(unitfile);
  160. }
  161.  
  162. void initializeunit(struct unittype *theunit)
  163. {
  164.   theunit->factor=1.0;
  165.   theunit->numerator[0]=theunit->denominator[0]=NULL;
  166. }
  167.  
  168.  
  169. int addsubunit(char *product[], char *toadd)
  170. {
  171.   char **ptr;
  172.  
  173.   for(ptr=product;*ptr && *ptr!=NULLUNIT;ptr++);
  174.   if (ptr>=product+MAXSUBUNITS){
  175.     fprintf(stderr,"Memory overflow in unit reduction\n");
  176.     return 1;
  177.   }
  178.   if (!*ptr) *(ptr+1)=0;
  179.   *ptr=dupstr(toadd);
  180.   return 0;
  181. }
  182.  
  183.  
  184. void showunit(struct unittype *theunit)
  185. {
  186.   char **ptr;
  187.   int printedslash;
  188.   int counter=1;
  189.  
  190.   printf("\t%.8g",theunit->factor);
  191.   for(ptr=theunit->numerator;*ptr;ptr++){
  192.     if (ptr>theunit->numerator && **ptr &&
  193.        !strcmp(*ptr,*(ptr-1))) counter++;
  194.       else {
  195.         if (counter>1) printf("%s%d",powerstring,counter);
  196.         if (**ptr) printf(" %s",*ptr);
  197.     counter=1;
  198.       }
  199.   }
  200.   if (counter>1) printf("%s%d",powerstring,counter);
  201.   counter=1;
  202.   printedslash=0;
  203.   for(ptr=theunit->denominator;*ptr;ptr++){
  204.     if (ptr>theunit->denominator && **ptr && 
  205.          !strcmp(*ptr,*(ptr-1))) counter++;
  206.       else {
  207.         if (counter>1) printf("%s%d",powerstring,counter);
  208.         if (**ptr) { 
  209.       if (!printedslash) printf(" /");
  210.       printedslash=1;
  211.           printf(" %s",*ptr);
  212.     }
  213.     counter=1;
  214.       }
  215.   }
  216.   if (counter>1) printf("%s%d",powerstring,counter);
  217.   printf("\n");
  218. }
  219.  
  220.  
  221. void zeroerror()
  222. {
  223.    fprintf(stderr,"Unit reduces to zero\n");
  224. }   
  225.  
  226. /* 
  227.    Adds the specified string to the unit. 
  228.    Flip is 0 for adding normally, 1 for adding reciprocal.
  229.  
  230.    Returns 0 for successful addition, nonzero on error.
  231. */
  232.  
  233. int addunit(struct unittype *theunit,char *toadd,int flip)
  234. {
  235.   char *scratch,*savescr;
  236.   char *item;
  237.   char *divider,*subunit,*slash;
  238.   int doingtop;
  239.  
  240.   savescr=scratch=dupstr(toadd);
  241.   for(slash=scratch+1;*slash;slash++) 
  242.     if (*slash=='-' && 
  243.       (tolower(*(slash-1))!='e' || !strchr(".0123456789",*(slash+1))))
  244.       *slash=' ';
  245.   slash=strchr(scratch,'/');
  246.   if (slash) *slash=0;
  247.   doingtop=1;
  248.   do{
  249.   item=strtok(scratch," *\t\n/");
  250.   while(item){
  251.     if (strchr("0123456789.",*item)){  /* item is a number */
  252.       double num;
  253.  
  254.       divider=strchr(item,'|');
  255.       if (divider){
  256.     *divider=0;
  257.     num=atof(item);
  258.     if (!num) {
  259.           zeroerror();
  260.           return 1;
  261.         }
  262.     if (doingtop^flip) theunit->factor *= num;
  263.          else  theunit->factor /=num;
  264.     num=atof(divider+1);
  265.     if (!num)  {
  266.           zeroerror();
  267.           return 1;
  268.         }
  269.     if (doingtop^flip) theunit->factor /= num;
  270.      else theunit->factor *= num;
  271.       } else {
  272.     num=atof(item);
  273.     if (!num)  {
  274.           zeroerror();
  275.           return 1;
  276.         }
  277.     if (doingtop^flip) theunit->factor *= num;
  278.     else theunit->factor /= num;
  279.  
  280.       }
  281.     } else {                         /* item is not a number */
  282.       int repeat=1;
  283.       if (strchr("23456789",item[strlen(item)-1])){
  284.     repeat=item[strlen(item)-1]-'0';
  285.     item[strlen(item)-1]=0;
  286.       }
  287.       for(;repeat;repeat--)
  288.     if (addsubunit(doingtop^flip?theunit->numerator:theunit->denominator,item))
  289.   return 1;
  290.     }
  291.     item=strtok(NULL," *\t/\n");
  292.   }
  293.   doingtop--;
  294.   if (slash){
  295.     scratch=slash+1;
  296.   } else doingtop--;
  297.   }while (doingtop>=0 );
  298.   free(savescr);
  299.   return 0;
  300. }
  301.  
  302.  
  303. int compare(const void *item1, const void *item2)
  304. {
  305.   return strcmp(*(char **) item1, * (char **) item2);
  306. }
  307.  
  308.  
  309. void sortunit(struct unittype *theunit)
  310. {
  311.   char **ptr;
  312.   int count;
  313.  
  314.   for(count=0,ptr=theunit->numerator;*ptr;ptr++,count++);
  315.   qsort(theunit->numerator, count, sizeof(char *), compare);
  316.   for(count=0,ptr=theunit->denominator;*ptr;ptr++,count++);
  317.   qsort(theunit->denominator, count, sizeof(char *), compare);
  318. }
  319.  
  320.  
  321. void cancelunit(struct unittype *theunit)
  322. {
  323.   char **den,**num;
  324.   int comp;
  325.  
  326.   den=theunit->denominator;
  327.   num=theunit->numerator;
  328.  
  329.   while(*num && *den){
  330.     comp=strcmp(*den,*num);
  331.     if (!comp) {
  332. /*      if (*den!=NULLUNIT) free(*den);
  333.       if (*num!=NULLUNIT) free(*num);*/
  334.       *den++=NULLUNIT;
  335.       *num++=NULLUNIT;
  336.     }
  337.     else if (comp<0) den++;
  338.     else num++;
  339.   }
  340. }
  341.  
  342.  
  343.  
  344.  
  345. /*
  346.    Looks up the definition for the specified unit.  
  347.    Returns a pointer to the definition or a null pointer
  348.    if the specified unit does not appear in the units table.
  349. */
  350.  
  351. static char buffer[100];  /* buffer for lookupunit answers with prefixes */
  352.  
  353. char *lookupunit(char *unit)
  354. {
  355.   int i;
  356.   char *copy;
  357.  
  358.   for(i=0;i<unitcount;i++){
  359.     if (!strcmp(unittable[i].uname,unit)) return unittable[i].uval;
  360.   }
  361.  
  362.   if (unit[strlen(unit)-1]=='^') {
  363.     copy=dupstr(unit);
  364.     copy[strlen(copy)-1]=0;
  365.     for(i=0;i<unitcount;i++){
  366.       if (!strcmp(unittable[i].uname,copy)) {
  367.         strcpy(buffer,copy);
  368.         free(copy);
  369.         return buffer;
  370.       }
  371.     } 
  372.     free(copy);
  373.   }
  374.   if (unit[strlen(unit)-1]=='s') {
  375.     copy=dupstr(unit);
  376.     copy[strlen(copy)-1]=0;
  377.     for(i=0;i<unitcount;i++){
  378.       if (!strcmp(unittable[i].uname,copy)) {
  379.         strcpy(buffer,copy);
  380.         free(copy);
  381.         return buffer;
  382.       }
  383.     }
  384.     if (copy[strlen(copy)-1]=='e') {
  385.       copy[strlen(copy)-1]=0;
  386.       for(i=0;i<unitcount;i++){
  387.         if (!strcmp(unittable[i].uname,copy)){
  388.           strcpy(buffer,copy);
  389.           free(copy);
  390.           return buffer;
  391.         }
  392.       }
  393.     }
  394.     free(copy);
  395.   }
  396.   for(i=0;i<prefixcount;i++){
  397.     if (!strncmp(prefixtable[i].prefixname,unit,
  398.         strlen(prefixtable[i].prefixname))) {
  399.       unit += strlen(prefixtable[i].prefixname);
  400.       if (!strlen(unit) || lookupunit(unit)){
  401.         strcpy(buffer,prefixtable[i].prefixval);
  402.         strcat(buffer," ");
  403.         strcat(buffer,unit);
  404.         return buffer;
  405.       }
  406.     }
  407.   }
  408.   return 0;
  409. }
  410.  
  411.  
  412.  
  413. /*
  414.    reduces a product of symbolic units to primitive units. 
  415.    The three low bits are used to return flags:
  416.  
  417.      bit 0 (1) set on if reductions were performed without error.
  418.      bit 1 (2) set on if no reductions are performed.
  419.      bit 2 (4) set on if an unknown unit is discovered.
  420. */
  421.  
  422.  
  423. #define ERROR 4
  424.  
  425. int reduceproduct(struct unittype *theunit, int flip)
  426. {
  427.  
  428.   char *toadd;
  429.   char **product;
  430.   int didsomething=2;
  431.  
  432.   if (flip) product=theunit->denominator;
  433.   else product=theunit->numerator;
  434.  
  435.   for(;*product;product++){
  436.     
  437.     for(;;){
  438.       if (!strlen(*product)) break;
  439.       toadd=lookupunit(*product);
  440.       if (!toadd) { 
  441.         printf("unknown unit '%s'\n",*product);
  442.         return ERROR;
  443.       }
  444.       if (strchr(toadd,PRIMITIVECHAR)) break;
  445.       didsomething=1;
  446.       if (*product!=NULLUNIT) {
  447.         free (*product);
  448.         *product=NULLUNIT;
  449.       }
  450.       if (addunit(theunit, toadd, flip)) return ERROR;
  451.     }
  452.   }
  453.   return didsomething;
  454. }
  455.  
  456.  
  457. /* 
  458.    Reduces numerator and denominator of the specified unit.
  459.    Returns 0 on success, or 1 on unknown unit error.
  460. */
  461.  
  462. int reduceunit(struct unittype *theunit)
  463. {
  464.   int ret;
  465.   ret=1;
  466.   while(ret & 1){
  467.     ret = reduceproduct(theunit,0) | reduceproduct(theunit,1);
  468.     if (ret & 4) return 1;
  469.   }
  470.   return 0;
  471. }
  472.  
  473.  
  474. int compareproducts(char **one,char **two)
  475. {
  476.   while(*one || *two){
  477.     if (!*one && *two!=NULLUNIT) return 1;
  478.     if (!*two && *one!=NULLUNIT) return 1;
  479.     if (*one==NULLUNIT) one++;
  480.     else if (*two==NULLUNIT) two++;
  481.     else if (strcmp(*one,*two)) return 1;
  482.     else one++,two++;
  483.   }
  484.   return 0;
  485. }
  486.  
  487.  
  488. /* Return zero if units are compatible, nonzero otherwise */
  489.  
  490. int compareunits(struct unittype *first, struct unittype *second)
  491. {
  492.   return 
  493.     compareproducts(first->numerator,second->numerator) ||
  494.     compareproducts(first->denominator,second->denominator);
  495. }
  496.  
  497.  
  498. int completereduce(struct unittype *unit)
  499. {
  500.   if (reduceunit(unit)) return 1;
  501.   sortunit(unit);
  502.   cancelunit(unit);
  503.   return 0;
  504. }
  505.  
  506.  
  507. void showanswer(struct unittype *have, struct unittype *want)
  508. {
  509.   if (compareunits(have,want)) {
  510.     printf("conformability error\n");
  511.     showunit(have);
  512.     showunit(want);
  513.   }
  514.   else printf("\t* %.8g\n\t/ %.8g\n",have->factor/want->factor,
  515.                            want->factor/have->factor);
  516. }
  517.  
  518.  
  519. void usage()
  520. {
  521.   fprintf(stderr,"\nunits [-f unitsfile] [-q] [-v] [from-unit to-unit]\n");
  522.   fprintf(stderr,"\n    -f specify units file\n");
  523.   fprintf(stderr,"    -q supress prompting (quiet)\n");
  524.   fprintf(stderr,"    -v print version number\n");
  525.   exit(3);
  526. }
  527.  
  528.  
  529. void main(int argc, char **argv){
  530.  
  531.   struct unittype have,want;
  532.   char havestr[81],wantstr[81];
  533.   char optchar;
  534.   char *userfile=0;
  535.   int quiet=0;
  536.  
  537.   extern char *optarg;
  538.   extern int optind;
  539.  
  540.   while (EOF != (optchar = getopt(argc,argv,"vqf:"))) {
  541.     switch(optchar) {
  542.       case 'f':
  543.         userfile=optarg;
  544.         break;
  545.       case 'q':
  546.         quiet=1;
  547.         break;
  548.       case 'v':
  549.         fprintf(stderr,"\n  units version %s  Copyright (c) 1993 by Adrian Mariano\n",VERSION);
  550.         fprintf(stderr,"                    This program may be freely distributed\n");
  551.         usage();
  552.       default:
  553.         usage();
  554.         break;
  555.      }
  556.   }
  557.     
  558.   if (optind != argc-2 && optind!=argc) usage();
  559.  
  560.   readunits(userfile);
  561.  
  562.   if (optind==argc-2){
  563.     strcpy(havestr,argv[optind]);
  564.     strcpy(wantstr,argv[optind+1]);
  565.     initializeunit(&have);
  566.     addunit(&have,havestr,0);
  567.     completereduce(&have);
  568.     initializeunit(&want);
  569.     addunit(&want,wantstr,0);
  570.     completereduce(&want);
  571.     showanswer(&have,&want);
  572.   } else {
  573.     if (!quiet) printf("%d units, %d prefixes\n\n",unitcount,prefixcount);
  574.     for(;;){
  575.       do{
  576.         initializeunit(&have);
  577.         if (!quiet) printf("You have: ");
  578.         if (!fgets(havestr,80,stdin)) { if (!quiet);putchar('\n');exit(0);}
  579.       } while(addunit(&have,havestr,0) || completereduce(&have));
  580.       do{
  581.         initializeunit(&want);
  582.         if (!quiet) printf("You want: ");
  583.         if (!fgets(wantstr,80,stdin)) {if (!quiet) putchar('\n');exit(0);}
  584.       } while(addunit(&want,wantstr,0) || completereduce(&want));
  585.       showanswer(&have,&want);
  586.     }
  587.   }
  588. }
  589.  
  590.  
  591.  
  592.  
  593.