Subversion Repositories Kolibri OS

Rev

Rev 1005 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2.  
  3. #include "func.h"
  4. #include "parser.h"
  5.  
  6. // token types
  7. #define DELIMITER 1
  8. #define VARIABLE 2
  9. #define NUMBER 3
  10. #define FUNCTION 4
  11. #define FINISHED 10
  12.  
  13. // error codes
  14. #define ERR_BADFUNCTION -1
  15. #define ERR_BADNUMER -2
  16. #define ERR_GENERAL -3
  17. #define ERR_NOBRACKET -4
  18. #define ERR_BADVARIABLE -5
  19. #define ERR_OVERFLOW -6
  20.  
  21. double __cdecl tg(double d)
  22. {
  23.         return sin(d) / cos(d);
  24. }
  25.  
  26. double __cdecl ctg(double d)
  27. {
  28.         return cos(d) / sin(d);
  29. }
  30.  
  31. double __cdecl exp(double x)
  32. {
  33.         __asm {
  34.                 fld     x
  35.                 FLDL2E
  36.                 FMUL
  37.  
  38.                 FLD st(0)
  39.  
  40.                 FLD1
  41.  
  42.                 FXCH
  43.                 FPREM
  44.                 F2XM1
  45.                 fadd
  46.                 FSCALE
  47.                 FSTP st(1)
  48.         }
  49.        
  50. }
  51.  
  52. double __cdecl log(double x)
  53. {
  54.         //return 0.0;
  55.         __asm {
  56.                 FLD1
  57.                 FLD     x
  58.                 FYL2X
  59.                 FLDLN2
  60.                 FMUL
  61.         }
  62. }
  63.  
  64. double __cdecl sqrt(double x)
  65. {
  66.         __asm {
  67.                 fld x
  68.                 fsqrt
  69.         }
  70. }
  71.  
  72. double __cdecl atan(double x)
  73. {
  74.         return 0.0; // т ыюь
  75. }
  76.  
  77. double pow(double x, double y)
  78. {
  79.         return 0.0; // т ыюь, яєёърщ ёўшЄр■Є ўхЁхї exp ш log
  80. }
  81.  
  82.  
  83. // represents general mathematical function
  84. typedef double(__cdecl*matfunc)(double);
  85.  
  86. // used to link function name to the function
  87. typedef struct  
  88. {
  89.         char name[10];
  90.         matfunc f;
  91. } func;
  92.  
  93. // the list of functions
  94. const int max_func = 12;
  95. func functions[max_func] =
  96. {
  97.         "", NULL,
  98.         "sin", &sin,
  99.         "cos", &cos,
  100.         "exp", &exp,
  101.         "sqrt", &sqrt,
  102.         "log", &log,
  103.         "tg", &tg,
  104.         "ctg", &ctg,
  105.         "arcsin", &asin,
  106.         "arccos", &acos,
  107.         "arctg", &atan,
  108.         "abs", &fabs
  109. };
  110.  
  111. // all delimiters
  112. const char *delim="+-*^/%=;(),><";              // not bad words
  113.  
  114. // structure for most parser functions
  115.  
  116.         char token[80];
  117.         int token_type;
  118.         char *prog;
  119.         double x_value;
  120.   int code;    // error code
  121.  
  122. int isdelim(char c)
  123. {
  124.         //return strchr(delim, c) != 0;
  125.         for (int i = 0; i < 14; i++)
  126.                 if (c == delim[i])
  127.                         return 1;
  128.         return 0;
  129. }
  130.  
  131. int isdigit(char c)
  132. {
  133.         return (c >= '0' && c <= '9');
  134. }
  135.  
  136. int isalpha2(char c)
  137. {
  138.         return ((c >= 'a' && c <= 'z')
  139.                 || (c >= 'A' && c <= 'Z'));
  140. }
  141.  
  142. int iswhite(char c)
  143. {
  144.         return (c==' ' || c=='\t');
  145. }
  146.  
  147.  
  148. void serror(int code)
  149. {
  150.         ::code = code;
  151. //  longjmp(j, code);
  152. }
  153.  
  154. void set_exp(char *exp, double x)
  155. {
  156.         prog = exp;
  157.         x_value = x;
  158. }
  159.  
  160. int get_token()
  161. {
  162.         int tok;
  163.         char *temp;
  164.         (token_type) = 0;
  165.         tok = 0;
  166.         temp = (token);
  167.  
  168.         if (*(prog) == '\0')
  169.         {
  170.                 *(token) = 0;
  171.                 tok = FINISHED;
  172.                 return ((token_type) = DELIMITER);
  173.         }
  174.         while (iswhite(*(prog))) ++(prog);
  175.         if (isdelim(*(prog)))
  176.         {
  177.                 *temp = *(prog);
  178.                 (prog)++;
  179.                 temp++;
  180.                 *temp = 0;
  181.                 return ((token_type) = DELIMITER);
  182.         }
  183.         if (isdigit(*(prog)))
  184.         {
  185.                 while (!isdelim(*(prog)))
  186.                         *temp++=*(prog)++;
  187.                 *temp = '\0';
  188.                 return ((token_type) = NUMBER);
  189.         }
  190.         if (isalpha2(*(prog)))
  191.         {
  192.                 while (!isdelim(*(prog)))
  193.                         *temp++=*(prog)++;
  194.                 (token_type) = VARIABLE;
  195.         }
  196.         *temp = '\0';
  197.         if ((token_type) == VARIABLE)
  198.         {
  199.                 tok = look_up((token));
  200.                 if (tok)
  201.                         (token_type) = FUNCTION;
  202.         }
  203.         return (token_type);
  204. }
  205.  
  206. int sign(double d)
  207. {
  208.   if (d > 0.0)
  209.     return 1.0;
  210.   if (d < 0.0)
  211.     return -1.0;
  212.   return 0.0;
  213. }
  214.  
  215. void putback()
  216. {
  217.         char *t;
  218.         t = (token);
  219.         for (;*t;t++)
  220.                 (prog)--;
  221. }
  222.  
  223. int get_exp(double *hold)
  224. {
  225.   int res;
  226.   code = 0;
  227. //  if (res = setjmp(j) != 0)
  228. //    return code;
  229.         get_token();
  230.         if (!*(token))
  231.         {
  232.                 return 0;
  233.         }
  234.         level2( hold);
  235.         putback();
  236.   return 0;
  237. }
  238.  
  239. void level2(double *hold)
  240. {
  241.         char op;
  242.         double h;
  243.  
  244.         level3( hold);
  245.         while ((op=*(token)) == '+' || op == '-')
  246.         {
  247.                 get_token();
  248.                 level3( &h);
  249.                 arith(op, hold, &h);
  250.         }
  251. }
  252.  
  253. void level3(double *hold)
  254. {
  255.         char op;
  256.         double h;
  257.  
  258.         level4( hold);
  259.         while ((op=*(token)) == '*' || op == '/' || op == '%')
  260.         {
  261.                 get_token();
  262.                 level4( &h);
  263.                 arith( op, hold, &h);
  264.         }
  265. }
  266.  
  267. void level4(double *hold)
  268. {
  269.         double h;
  270.         level5( hold);
  271.  
  272.         if (*(token) == '^')
  273.         {
  274.                 get_token();
  275.                 level5( &h);
  276.                 arith( '^', hold, &h);
  277.         }
  278. }
  279.  
  280. void level5(double *hold)
  281. {
  282.         char op;
  283.  
  284.         op = 0;
  285.         if (((token_type) == DELIMITER) && *(token) == '+' || *(token) == '-')
  286.         {
  287.                 op = *(token);
  288.                 get_token();
  289.         }
  290.         level6( hold);
  291.  
  292.         if (op)
  293.                 unary(op, hold);
  294. }
  295.  
  296. void level6(double *hold)
  297. {
  298.         if ((*(token) == '(') && ((token_type) == DELIMITER))
  299.         {
  300.                 get_token();
  301.                 level2( hold);
  302.                 if (*(token) != ')')
  303.       serror( ERR_NOBRACKET);
  304.                 get_token();
  305.         }
  306.         else
  307.                 primitive( hold);
  308. }
  309.  
  310. void calc_function(double *hold)
  311. {
  312.   double d;
  313.         int i;
  314.  
  315.         i = look_up(token);
  316.  
  317.         if (i == 0)
  318.                 serror(ERR_BADFUNCTION);        // error
  319.  
  320.         get_token();
  321.         if (*(token) != '(')
  322.                 serror(ERR_NOBRACKET);  // error
  323.         get_token();
  324.         level2(hold);
  325.         get_token();
  326.  
  327.   d = functions[i].f(*hold);
  328.   *hold = (functions[i].f)(*hold);
  329. //  else
  330. //    serror( ERR_OVERFLOW);
  331.  
  332. }
  333.  
  334. void primitive(double *hold)
  335. {
  336.         switch (token_type)
  337.         {
  338.         case VARIABLE:
  339.                 *hold = find_var(token);
  340.                 get_token();
  341.                 return;
  342.         case NUMBER:
  343.     //
  344.                 //*hold = atof((token));
  345.     //if (sscanf(token, "%lf", hold) != 1)
  346.         *hold = convert(token);
  347.         if (*hold == ERROR)
  348.       serror( ERR_BADNUMER);
  349.                 get_token();
  350.                 return;
  351.         case FUNCTION:
  352.                 calc_function( hold);
  353.                 return;
  354.         default:        // error
  355.                 return;
  356.         }
  357. }
  358.  
  359. void arith(char op, double *r, double *h)
  360. {
  361.         double t;
  362.         switch(op)
  363.         {
  364.         case '-':
  365.                 *r = *r - *h;
  366.                 break;
  367.         case '+':
  368.                 *r = *r + *h;
  369.                 break;
  370.         case '*':
  371.                 *r = *r * *h;
  372.                 break;
  373.         case '/':
  374.     if (*h == 0)
  375.       serror( ERR_OVERFLOW);
  376.     else
  377.                   *r = (*r) / (*h);
  378.                 break;
  379.         case '%':
  380.                 t = (*r) / (*h);
  381.                 *r = *r - (t * (*h));
  382.                 break;
  383.         case '^':
  384.                 *r = pow(*r, *h);
  385.                 break;
  386.         }
  387. }
  388.  
  389. void unary(char op, double *r)
  390. {
  391.         if (op == '-')
  392.                 *r = -(*r);
  393. }
  394.  
  395. double find_var(char *s)
  396. {
  397.         //return 0;     // not imp
  398.         //int i;
  399.  
  400.         //for (i = 0; i < kvar; i++)
  401.         //      if (strcmp(vars[i].name, s) == 0)
  402.         //              return vars[i].value;
  403.  
  404.         if (s[1] == '\0' && (s[0] == 'x' || s[0] == 'X'))
  405.         //if (strcmp(s,"x") == 0 || strcmp(s,"X") == 0)
  406.                 return x_value;
  407.  
  408.         serror( ERR_BADVARIABLE);
  409.   return 0; // to make compiler very happy
  410.  
  411.         //printf("\nPlease enter value for variable \"%s\": ", s);
  412.         //scanf("%lf", &vars[kvar].value);
  413.         //strcpy(vars[kvar].name, s);
  414.         //kvar++;
  415.         //return vars[kvar - 1].value;
  416. }
  417.  
  418. bool strcmp(char *s1, char *s2)
  419. {
  420.         int i;
  421.  
  422.         for (i = 0;;i++)
  423.         {
  424.                 if (s1[i] == '\0')
  425.                         if (s2[i] == '\0')
  426.                                 return 0;
  427.                         else
  428.                                 return 1;
  429.                 else
  430.                         if (s2[i] == '\0')
  431.                                 return 1;
  432.                         else
  433.                         {
  434.                                 if (s1[i] != s2[i])
  435.                                         return 1;
  436.                         }
  437.         }
  438. }
  439.  
  440. int look_up(char *s)
  441. {
  442.         int i;
  443.  
  444.         for (i = 0; i < max_func; i++)
  445.                 if (strcmp(s, functions[i].name) == 0)
  446.                         return i;
  447.         return 0;       // search command/function name
  448. }
  449.  
  450. /*
  451. void delete_white(char *buf)
  452. {
  453.         int len = strlen(buf);
  454.         char *d = (char *)malloc(len + 1);
  455.         char *t = buf;
  456.         strcpy(d, buf);
  457.         d[len] = '\0';
  458.  
  459.         int i;
  460.  
  461.         for (i = 0; i < len; i++)
  462.                 if (!iswhite(d[i]))
  463.                         *t++=d[i];
  464.         *t++='\0';
  465.         free(d);
  466. }
  467. */
  468.  
  469. /*
  470. void main(void)
  471. {
  472.  
  473.          = (parser_struct)malloc(sizeof(parser_struct));
  474.         double a;
  475.         char buffer[256];
  476.  
  477.  
  478.         printf("Enter expression: ");
  479.         memset(buffer, 0, 256);
  480.         gets(buffer);
  481.  
  482.         prog = buffer;
  483.         delete_white(buffer);
  484.  
  485.         a = 0;
  486.         x_value = 3;
  487.         get_exp( &a);
  488.  
  489.         printf("result: %lg\n", a);
  490.         getch();
  491.  
  492. }
  493. */