Annotation of capa/capa51/pProj/capaFormula.y, revision 1.1

1.1     ! albertel    1: 
        !             2: /* ====================================================== */
        !             3: /*      capaFormula.y  created by Isaac Tsai @ Feb 1999   */
        !             4: /*      copyrighted by Isaac Tsai    1999                 */
        !             5: /*  TODO: checking user inputs   2/27/99      IT          */
        !             6: /* ====================================================== */
        !             7: %{
        !             8: #include <stdio.h>
        !             9: #include <ctype.h>
        !            10: #include <string.h>
        !            11: #include <math.h>
        !            12: #include "capaParser.h"   /* _symbol structure def */
        !            13: #include "capaCommon.h"
        !            14: #include "capaFunction.h"
        !            15: #include "capaToken.h"
        !            16: 
        !            17: #ifdef __hpux
        !            18: #include <stdlib.h>
        !            19: #include <alloca.h>
        !            20: #endif
        !            21: 
        !            22: #ifdef   FML_DBUG
        !            23: #define  FMLDBUG_PR1(xx)        { printf(xx);    fflush(stdout); }
        !            24: #define  FMLDBUG_PR2(xx,yy)     { printf(xx,yy); fflush(stdout); }
        !            25: #define  FMLDBUG_PR3(xx,yy,zz)  { printf(xx,yy,zz); fflush(stdout); }
        !            26: #else
        !            27: #define  FMLDBUG_PR1(xx)        { }
        !            28: #define  FMLDBUG_PR2(xx,yy)     { }
        !            29: #define  FMLDBUG_PR3(xx,yy,zz)  { }
        !            30: #endif
        !            31: 
        !            32: #define ADD_op          1
        !            33: #define SUB_op          2
        !            34: #define MUL_op          3
        !            35: #define DIV_op          4
        !            36: #define IDIV_op         5
        !            37: #define NOT_DEFINED_op  9
        !            38: 
        !            39: #ifdef  YYSTYPE
        !            40: #undef  YYSTYPE
        !            41: #endif
        !            42: #define YYSTYPE  Symbol_p
        !            43: 
        !            44: /* =============================================================== */
        !            45: 
        !            46: extern      int         Func_idx;
        !            47: extern      Symbol      FuncStack[MAX_FUNC_NEST];
        !            48: 
        !            49: double      FormulaVal;
        !            50: int         FormulaParseOK=1;
        !            51: 
        !            52: %}
        !            53: 
        !            54: 
        !            55: %token    F_NUMBER    V_ID      F_ID     EoI      F_ERROR 
        !            56: %left     F_PLUS      F_MINUS   
        !            57: %left     F_MULT      F_DIV     F_MOD
        !            58: %token    F_POW       F_LPAR    F_RPAR   F_COMMA 
        !            59: 
        !            60: 
        !            61: %start    f_expr
        !            62: 
        !            63: 
        !            64: %%
        !            65: 
        !            66: f_expr       : block                             { switch($1->s_type) {
        !            67:                                                       case I_VAR:
        !            68:                                                       case I_CONSTANT: FormulaVal = (double)($1->s_int);
        !            69:                                                           break;
        !            70:                                                       case R_VAR: 
        !            71:                                                       case R_CONSTANT: FormulaVal = $1->s_real;
        !            72:                                                           break;
        !            73:                                                       case S_VAR:
        !            74:                                                       case S_CONSTANT: FormulaParseOK = 0;
        !            75:                                                           break;
        !            76:                                                       default:         FormulaParseOK = 0;
        !            77:                                                           break;
        !            78:                                                     }
        !            79:                                                     capa_mfree((char *)$1);
        !            80:                                                     FMLDBUG_PR1("[f_expr <= block ]\n");
        !            81:                                                   }
        !            82:              ;
        !            83: 
        !            84: block        : block F_PLUS   term                { $$ = symbols_op($1, $3, ADD_op);  }
        !            85:              | block F_MINUS  term                { $$ = symbols_op($1, $3, SUB_op);  }
        !            86:              | term                               { $$ = $1; }
        !            87:              | F_ERROR                            { FormulaParseOK = 0; FMLDBUG_PR1("[F_ERROR]\n"); return 0;}
        !            88:              | error                              { FormulaParseOK = 0; FMLDBUG_PR1("[ERROR]\n"); return 0;  }
        !            89:              ;
        !            90: 
        !            91: term         : term    F_MULT  basic_constr       { $$ = symbols_op($1, $3, MUL_op);  }
        !            92:              | term    F_DIV   basic_constr       { $$ = symbols_op($1, $3, DIV_op);  }
        !            93:              | term    F_MOD   basic_constr       { $$ = symbols_op($1, $3, IDIV_op); }
        !            94:              | basic_constr                       { $$ = $1; }
        !            95:              ;
        !            96: 
        !            97: basic_constr : basic_constr  F_POW   basic_item   { $$ = f_symbol_pow($1,$3);
        !            98:                                                     FMLDBUG_PR3("[%.16g ^ %.16g] ",$1->s_real,$3->s_real);       }
        !            99:              | basic_item                         { $$ = $1; }
        !           100:              ;
        !           101: 
        !           102: arg_list     : arg_list F_COMMA  block            { $$ = $1;
        !           103:                                                     $$->s_argc++;
        !           104:                                                     $$->s_argp = addto_arglist($1->s_argp, $3);
        !           105:                                                   }
        !           106:              | block                              { $$ = $1;
        !           107:                                                     $$->s_argc = 1;
        !           108:                                                     $$->s_argp = new_arglist($1);
        !           109:                                                   }
        !           110:              ;
        !           111: 
        !           112: basic_item   : F_ID F_LPAR F_RPAR                 {  int tmp;
        !           113:                                          
        !           114:                                                      Func_idx--;
        !           115:                                                      if(Func_idx >= 0 ) {
        !           116:                                                        tmp = match_function(FuncStack[Func_idx].s_name,0);
        !           117:                                                        $$ = do_function(tmp, 0, NULL );
        !           118:                                                        capa_mfree(FuncStack[Func_idx].s_name);
        !           119:                                                      }
        !           120:                                                   }
        !           121:              | F_ID F_LPAR arg_list  F_RPAR       {  int  tmp;
        !           122:                                          
        !           123:                                                      Func_idx--;
        !           124:                                                      if(Func_idx >= 0 ) {
        !           125:                                                         tmp = match_function(FuncStack[Func_idx].s_name,$3->s_argc);
        !           126: 					                $$ = do_function(tmp, $3->s_argc, $3->s_argp);
        !           127: 					                capa_mfree(FuncStack[Func_idx].s_name);
        !           128: 					                free_arglist($3->s_argp);
        !           129:                                                       }
        !           130:                                                   }
        !           131:              | V_ID                               { FMLDBUG_PR3("[V %s = %.16g] ",$1->s_name, $1->s_real);
        !           132:                                                     $$ = $1;
        !           133:                                                   }
        !           134:              | F_MINUS  basic_item                { $$ = $2;
        !           135:                                                     switch($2->s_type) {
        !           136:                                                       case I_VAR:      $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
        !           137:                                                              $$->s_type = I_CONSTANT;
        !           138:                                                       case I_CONSTANT: $$->s_int =    - $2->s_int; break;
        !           139:                                                       case R_VAR: $$ = (Symbol *)capa_malloc(sizeof(Symbol),1);
        !           140:                                                              $$->s_type = R_CONSTANT;
        !           141:                                                       case R_CONSTANT: $$->s_real =   (-1.0)*($2->s_real); 
        !           142:                                                              break;
        !           143:                                                       case S_VAR:
        !           144:                                                       case S_CONSTANT: break;
        !           145:                                                       default:         break;
        !           146:                                                     }
        !           147:                                                   }
        !           148:              | F_PLUS  basic_item                 { $$ = $2; }
        !           149:              | F_NUMBER                           { FMLDBUG_PR2("[F %.16g] ",$1->s_real);
        !           150:                                                     $$ = $1;
        !           151:                                                   }
        !           152:              | F_LPAR   block  F_RPAR             { $$ = $2; }
        !           153:              ;
        !           154: %%
        !           155: void
        !           156: fml_error(char *msg)
        !           157: {
        !           158:   FormulaParseOK=0;
        !           159:   printf("Error Parsing: %s\n",msg);
        !           160:   
        !           161: }
        !           162: /* ---------------------------------------------------- */
        !           163: Symbol *
        !           164: f_symbol_pow(ap,bp) Symbol *ap; Symbol *bp;
        !           165: {
        !           166:   Symbol *cp;
        !           167:   double  a, b;
        !           168:   int     error = 0;
        !           169:   
        !           170:   cp = NULL;
        !           171:   switch(ap->s_type) {
        !           172:      case I_VAR:      a = (double)(ap->s_int);
        !           173:          break;
        !           174:      case I_CONSTANT: a = (double)(ap->s_int); capa_mfree((char *)ap);
        !           175:          break;
        !           176:      case R_VAR:      a = ap->s_real;
        !           177:          break;
        !           178:      case R_CONSTANT: a = ap->s_real;   capa_mfree((char *)ap);
        !           179:          break;
        !           180:      case S_VAR:
        !           181:      case S_CONSTANT: 
        !           182:      default:         error = 1;  break;
        !           183:   }
        !           184:   switch(bp->s_type) {
        !           185:      case I_VAR:      b = (double)(bp->s_int);
        !           186:          break;
        !           187:      case I_CONSTANT: b = (double)(bp->s_int);  capa_mfree((char *)bp);
        !           188:          break;
        !           189:      case R_VAR:      b = bp->s_real;
        !           190:          break;
        !           191:      case R_CONSTANT: b = bp->s_real;   capa_mfree((char *)bp);
        !           192:          break;
        !           193:      case S_VAR:
        !           194:      case S_CONSTANT: 
        !           195:      default:         error = 1; break;
        !           196:   }
        !           197:   if (!error) {
        !           198:     cp = (Symbol *)capa_malloc(sizeof(Symbol),1);
        !           199:     cp->s_type = R_CONSTANT;
        !           200:     cp->s_real = pow(a,b);
        !           201:     
        !           202:   }
        !           203:   return (cp);
        !           204: }
        !           205: 
        !           206: /* ============================================================================= */

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