[BACK]Return to capaUnit.c CVS log [TXT] [DIR] Up to [LON-CAPA] / capa / capa51 / pProj

Diff for /capa/capa51/pProj/capaUnit.c between versions 1.2 and 1.12

version 1.2, 2000/02/09 22:10:24 version 1.12, 2004/03/26 20:02:03
Line 1 Line 1
   /* functions to handle the unit parser/comparison engine
      Copyright (C) 1992-2000 Michigan State University
   
      The CAPA system is free software; you can redistribute it and/or
      modify it under the terms of the GNU General Public License as
      published by the Free Software Foundation; either version 2 of the
      License, or (at your option) any later version.
   
      The CAPA system is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
   
      You should have received a copy of the GNU General Public
      License along with the CAPA system; see the file COPYING.  If not,
      write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
   
      As a special exception, you have permission to link this program
      with the TtH/TtM library and distribute executables, as long as you
      follow the requirements of the GNU GPL in regard to all of the
      software in the executable aside from TtH/TtM.
   */
   
 /* =||>|===================== capaUnit.c   =====================|<||= */  /* =||>|===================== capaUnit.c   =====================|<||= */
 /*   created by Isaac Tsai   1997                                    */  /*   created by Isaac Tsai   1997                                    */
 /*   copyrighted by Isaac Tsai 1997, 1998, 1999                      */  /*   by Isaac Tsai 1997, 1998, 1999                      */
 /* =||>|========================================================|<||= */  /* =||>|========================================================|<||= */
 #include <stdio.h>        /* fopen()  */  #include <stdio.h>        /* fopen()  */
 #include <stdlib.h>  #include <stdlib.h>
 #include <ctype.h>        /* isalnum()   */  #include <ctype.h>        /* isalnum()   */
 #include <string.h>  #include <string.h>
 #include <math.h>  #include <math.h>
   #include <float.h>
   
 #include "capaParser.h"  #include "capaParser.h"
   
Line 632  postorder_utree(node_p) Unit_t  *node_p; Line 656  postorder_utree(node_p) Unit_t  *node_p;
   return (result);    return (result);
 }  }
   
   /* returns 1 on okay, 2 on error*/
 int  int
 postwalk_utree(Unit_t  *n_p)  postwalk_utree(Unit_t  *n_p)
 {  {
Line 640  postwalk_utree(Unit_t  *n_p) Line 665  postwalk_utree(Unit_t  *n_p)
   if( n_p == NULL )  return (1);    if( n_p == NULL )  return (1);
       
   result = postwalk_utree(U_LEFT(n_p));    result = postwalk_utree(U_LEFT(n_p));
   if( result ) result = postwalk_utree(U_RIGHT(n_p));    if (result !=2) {
   if( result ) {      if( result ) result = postwalk_utree(U_RIGHT(n_p));
     switch(U_TYPE(n_p)) {      if (result !=2) {
       case U_DERIVED:   Ptopidx++; Pstack[Ptopidx] = n_p;  /* push into stack */        if( result ) {
             break;   switch(U_TYPE(n_p)) {
       case U_CONSTANT:  Ptopidx++; Pstack[Ptopidx] = n_p;  /* push into stack */   case U_DERIVED:   Ptopidx++; Pstack[Ptopidx] = n_p;  /* push into stack */
             break;    break;
       case U_OP_POWER:  printf("^");   case U_CONSTANT:  Ptopidx++; Pstack[Ptopidx] = n_p;  /* push into stack */
             break;    break;
       case U_OP_TIMES:  process_op(U_OP_TIMES);        /* process operator */   case U_UNKNOWN:   result=2; 
             break;    /*push into stack anyway, try to parse rest of tree */
       case U_OP_PLUS:   printf("+");    break;
             break;   case U_OP_POWER:  printf("^"); result=2;
       case U_OP_MINUS:  printf("-");    break;
             break;   case U_OP_TIMES:  process_op(U_OP_TIMES);        /* process operator */
       case U_OP_DIVIDE: process_op(U_OP_DIVIDE);       /* process operator */    break;
             break;   case U_OP_PLUS:   printf("+"); result=2;
       default:          printf("()");    break;
             break;     case U_OP_MINUS:  printf("-"); result=2;
     break;
    case U_OP_DIVIDE: process_op(U_OP_DIVIDE);       /* process operator */
     break;
    default:          printf("()"); result=2;
     break;  
    }
         }
     }      }
   }    }
   return (result);    return (result);
Line 727  int  check_correct_unit(char *u_symb,Uni Line 759  int  check_correct_unit(char *u_symb,Uni
   int       result=UNIT_OK;    int       result=UNIT_OK;
   
 #ifdef UNIT_DBUG  #ifdef UNIT_DBUG
    if ((ufp=fopen("unit.DBUG","a"))==NULL) { fprintf(stderr,"Error: can't open login debug\n"); return; }     if ((ufp=fopen("unit.DBUG","a"))==NULL) { fprintf(stderr,"Error: can't open login debug\n"); return UNIT_FAIL; }
 #endif   #endif 
   
   while( isspace(*u_symb) )  u_symb++;    while( isspace(*u_symb) )  u_symb++; 
     /* <= change this to search from the end of string */
     /* or to get rid of all the white spaces */
   
   
   ap = parse_unit_expr(u_symb);    ap = parse_unit_expr(u_symb);
   Ptopidx=0;    Ptopidx=0;
   postwalk_utree(ap);  
     if (postwalk_utree(ap)==1) {
 #ifdef UNIT_DBUG  #ifdef UNIT_DBUG
   fprintf(ufp,"Ptopidx %d\n",Ptopidx);      fprintf(ufp,"Ptopidx %d\n",Ptopidx);
 #endif  #endif
   if( Ptopidx == 1 ) {      if( Ptopidx == 1 ) {
     simplify_unit(Pstack[Ptopidx]);        simplify_unit(Pstack[Ptopidx]);
             
     if( (Pstack[Ptopidx]->u_count != 0) ||        if( (Pstack[Ptopidx]->u_count != 0) ||
         (Pstack[Ptopidx]->u_count == t->u_count) ) { /* has unit */    (Pstack[Ptopidx]->u_count == t->u_count) ) { /* has unit */
       *scale = units_ratio(Pstack[Ptopidx], t);   *scale = units_ratio(Pstack[Ptopidx], t);
       if( *scale == 0.0 ) {   if( *scale == 0.0 ) {
         result = UNIT_FAIL;    result = UNIT_IRRECONCIBLE;
    }
    free_utree(ap);
         } else {
    result = UNIT_INVALID_STUDENT3;
       }        }
       free_utree(ap);      } else { /* invalid unit representation */
     } else {        result = UNIT_INVALID_STUDENT2;
       result = UNIT_FAIL;  
     }      }
   } else { /* invalid unit representation */    } else {
     result = UNIT_FAIL;      result = UNIT_INVALID_STUDENT1;
   }    }
 #ifdef UNIT_DBUG  #ifdef UNIT_DBUG
   fclose(ufp);    fclose(ufp);
Line 872  u_copy_unit(Unit_t *a_p, Unit_t *b_p, do Line 912  u_copy_unit(Unit_t *a_p, Unit_t *b_p, do
       a_p->u_count++;        a_p->u_count++;
     } else if( b_p->u_type == U_DERIVED) {      } else if( b_p->u_type == U_DERIVED) {
       /* derived units but without any units elements (scalar) */        /* derived units but without any units elements (scalar) */
       /* do nothing, ignore this units  */        /*a_p->u_count++;*/
         scale = pow(b_p->u_scale, exp_scale);
         a_p->u_scale = a_p->u_scale * scale;
     } else if( b_p->u_type == U_CONSTANT ) {      } else if( b_p->u_type == U_CONSTANT ) {
       scale = pow(b_p->u_scale, exp_scale);        scale = pow(b_p->u_scale, exp_scale);
       a_p->u_scale = a_p->u_scale * scale;        a_p->u_scale = a_p->u_scale * scale;
Line 1366  u_insert_derived(n_p,s_p,c_p,u_p)char  * Line 1408  u_insert_derived(n_p,s_p,c_p,u_p)char  *
   strcpy(new_p->u_comment,c_p);    strcpy(new_p->u_comment,c_p);
       
   simplify_unit(new_p);    simplify_unit(new_p);
   /*  #ifdef UNIT_DBUG
   printf("Derived Unit:%s\n",new_p->u_name);    printf("Derived Unit:%s\n",new_p->u_name);
   print_unit_t(new_p);     print_unit_t(new_p); 
   */  #endif
   if (c_result < 0 ) {    if (c_result < 0 ) {
     new_p->u_left = t->u_left; new_p->u_right = t;      new_p->u_left = t->u_left; new_p->u_right = t;
     t->u_left = NULL;      t->u_left = NULL;
Line 1700  p_new_unit(Unit_t *left_p, Unit_t *right Line 1742  p_new_unit(Unit_t *left_p, Unit_t *right
           } else { /* unit *tmp_str not found */            } else { /* unit *tmp_str not found */
             /* printf(" not found\n"); */              /* printf(" not found\n"); */
             err_code = 3;              err_code = 3;
       cu_p->u_type   = U_UNKNOWN;
           }            }
         } else {          } else { /* symb_str is not in <prefix><units> form */
           /* printf("<<%s>>", symb_str); */            /* printf("<<%s>>", symb_str); */
           err_code = 2;            err_code = 2;
     cu_p->u_type   = U_UNKNOWN;
         }          }
       } else {/* len == 1 */        } else {/* len == 1 */
         /* printf(" not found\n"); */          /* printf(" not found in symbol tree \n"); */
         err_code = 1;          err_code = 1;
    cu_p->u_type   = U_UNKNOWN;
       }        }
     }      }
   } else {    } else { /* why would we have a length less than zero symb_str ? */
     err_code = 4;      err_code = 4;
   }    }
       
Removed from v.1.2  
changed lines
  Added in v.1.12

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>