version 1.3, 2000/02/22 18:19:02
|
version 1.7, 2000/08/07 20:47:29
|
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> |
Line 632 postorder_utree(node_p) Unit_t *node_p;
|
Line 655 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 664 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 758 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++; |
Line 737 int check_correct_unit(char *u_symb,Uni
|
Line 768 int check_correct_unit(char *u_symb,Uni
|
|
|
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_FAIL; |
|
} |
|
free_utree(ap); |
|
} else { |
|
result = UNIT_FAIL; |
} |
} |
free_utree(ap); |
} else { /* invalid unit representation */ |
} else { |
|
result = UNIT_FAIL; |
result = UNIT_FAIL; |
} |
} |
} else { /* invalid unit representation */ |
} else { |
result = UNIT_FAIL; |
result = UNIT_FAIL; |
} |
} |
#ifdef UNIT_DBUG |
#ifdef UNIT_DBUG |
Line 876 u_copy_unit(Unit_t *a_p, Unit_t *b_p, do
|
Line 911 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 */ |
/* do nothing, ignore this units WE REALLY MEAN THIS DON'T DO THE NEXT LINE!*/ |
|
/*a_p->u_count++;*/ |
} 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 1704 p_new_unit(Unit_t *left_p, Unit_t *right
|
Line 1740 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 { |
/* 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\n"); */ |
err_code = 1; |
err_code = 1; |
|
cu_p->u_type = U_UNKNOWN; |
} |
} |
} |
} |
} else { |
} else { |