数学表达式解析器-(一)初期体验

元始天尊

学了堆栈以后，书上说可以用后缀表达式计算复杂数学表达式，因此想试试，既然开始探索，自然难度不能太低。这次选择表达式支持这些：
目的是可以计算sin(tan(x)*x)这种复杂表达式，给定定义域并画出图形
考虑到重用，因此先生成后缀表达式，因为后缀表达式是随着输入表达式固定的，而计算的时候只需要把x换成相应的值即可。
下面这些代码还处于理论阶段，因此现在称为初期体验，相信做出来以后还是蛮有用的

1. 
   
2. enum type
   
3. {
   
4.         //LEVEL0        0 1 2 3 4 5 6 7 8 9 . PI E
   
5.         LEVEL0,
   
6.         TYPE_INVALID=LEVEL0,//无效数
   
7.         TYPE_UNKNOWN,                //未知数
   
8.         TYPE_INTEGER,                //整数
   
9.         TYPE_DECIMAL,                //小数
   
10. 
    
11.         //LEVEL1        ()+() ()-()
    
12.         LEVEL1,
    
13.         TYPE_ADD=LEVEL1,        //和
    
14.         TYPE_SUB,                        //差
    
15. 
    
16.         //LEVEL2                        ()*() ()/()
    
17.         LEVEL2,
    
18.         TYPE_MUL=LEVEL2,        //积
    
19.         TYPE_DIV,                        //商
    
20. 
    
21.         //LEVEL3                        ()^()
    
22.         LEVEL3,
    
23.         TYPE_POW=LEVEL3,        //乘方
    
24. 
    
25.         //LEVEL4                        MOD() SIN() COS() TAN() ASIN() ACOS() ATAN() SINH() COSH() TANH() SQRT() LN() LOG10() EXP() CEIL() FLOOR() SGN()
    
26.         //                                        () [] {} ||  
    
27.         //                                        ()!   (-())取反
    
28.         LEVEL4,
    
29.         //括号模式
    
30.         TYPE_MOD=LEVEL4,//取模
    
31.         TYPE_SIN,                //正弦
    
32.         TYPE_COS,                //余弦
    
33.         TYPE_TAN,                //正切
    
34.         TYPE_ASIN,                //反正弦
    
35.         TYPE_ACOS,                //反余弦
    
36.         TYPE_ATAN,                //反正切
    
37.         TYPE_SINH,                //双曲正弦
    
38.         TYPE_COSH,                //双曲余弦
    
39.         TYPE_TANH,                //双曲正切
    
40.         TYPE_SQRT,                //开平方
    
41.         TYPE_LN,                //自然对数
    
42.         TYPE_LOG10,                //以10为底的对数
    
43.         TYPE_EXP,                //自然指数
    
44.         TYPE_CEIL,                //向上取整
    
45.         TYPE_FLOOR,                //向下取整
    
46.         TYPE_SGN,                //符号函数
    
47.         TYPE_BRACKET,        //括号
    
48. 
    
49.         TYPE_ABS,                //绝对值
    
50.         TYPE_FACTORIAL,        //阶乘
    
51.         TYPE_NEG,                //取反
    
52. 
    
53.         LEVEL5,
    
54. };

复制代码

现在仅写了如下代码，还在完善

1. 
   
2. struct numberstackdata
   
3. {
   
4.         type type;
   
5.         union
   
6.         {
   
7.                 int                integer;//TYPE_INTEGER
   
8.                 double        decimal;//TYPE_DECIMAL
   
9.         }data;
   
10. };
    
11. 
    
12. struct point
    
13. {
    
14.         int x;
    
15.         int y;
    
16. };
    
17. 
    
18. list<point> globalPTs;
    
19. 
    
20. int resolvenum(char* pos,double& data)
    
21. {//由字符串解析出小数
    
22.         bool negative=false;
    
23.         char* origin=pos;
    
24.         if(*pos == '-' || * pos == '+')
    
25.         {
    
26.                 pos++;
    
27.                 if(*pos == '-')
    
28.                         negative=true;
    
29.         }
    
30.         int integer=0;
    
31.         double decimal=0;
    
32.         while(*pos >= '0' && *pos <= '9')
    
33.         {
    
34.                 integer=integer*10 + *pos - '0';
    
35.                 pos++;
    
36.         }
    
37.         if(*pos == '.')
    
38.         {
    
39.                 pos++;
    
40.                 while(*pos >= '0' && *pos <= '9')
    
41.                 {
    
42.                         decimal=decimal*10 + *pos - '0';
    
43.                         pos++;
    
44.                 }
    
45.         }
    
46.         while(decimal >= 1.0)
    
47.         {
    
48.                 decimal /= 10;
    
49.         }
    
50. 
    
51.         data=integer+decimal;
    
52.         if(pos-origin > 1)
    
53.                 return pos-origin;
    
54.         else
    
55.                 return 1;
    
56. }
    
57. 
    
58. 
    
59. bool compare(char A,char B)
    
60. {//优先级A<=B true     A>B false
    
61.         switch(A)
    
62.         {
    
63.                 case '+':
    
64.                 case '-':
    
65.                         switch(B)
    
66.                         {
    
67.                                 case '+':
    
68.                                 case '-':
    
69.                                         return true;
    
70.                                 case '*':
    
71.                                 case '/':
    
72.                                         return true;
    
73.                         }
    
74.                 case '*':
    
75.                 case '/':
    
76.                         switch(B)
    
77.                         {
    
78.                                 case '+':
    
79.                                 case '-':
    
80.                                         return false;
    
81.                                 case '*':
    
82.                                 case '/':
    
83.                                         return true;
    
84.                         }
    
85.                 case '(':
    
86.                         return true;
    
87.         }
    
88. }
    
89. //MOD()    SIN()    COS()    TAN()    ACOS()    ASIN()    ATAN()    COSH()    SINH()    TANH()    SQRT()   
    
90. //()^()             ()!        LN()      EXP()     ()+()            ()-()           ()*()           ()/()        {}[]().    PI    E       |()| (-())
    
91. void main()
    
92. {//由普通表达式生成后缀表达式
    
93.         stack<char> sigstack;
    
94.         list<string> output;
    
95.         char str[]="9+(3-1)*3+10/2";//9 3 1 - 3 * + 10 2 / +
    
96.        
    
97.         int pos1=0,pos2=0;
    
98.         while(pos1<sizeof(str)-1)
    
99.         {
    
100.                 if(str[pos1] >= '0' && str[pos1] <= '9')
     
101.                 {
     
102.                         int endp=pos1;
     
103.                         while(str[endp] >= '0' && str[endp] <= '9')
     
104.                         {
     
105.                                 endp++;
     
106.                         }
     
107.                         if(str[endp] == '.')
     
108.                         {
     
109.                                 endp++;
     
110.                                 while(str[endp] >= '0' && str[endp] <= '9')
     
111.                                 {
     
112.                                         endp++;
     
113.                                 }
     
114.                         }
     
115.                         string temp;
     
116.                         temp.append(str+pos1,endp-pos1);
     
117.                         output.push_back(temp);
     
118.                         pos1=endp;
     
119.                 }
     
120.                 else if(str[pos1] == '+' || str[pos1] == '-' || str[pos1] == '*' || str[pos1] == '/')
     
121.                 {
     
122.                         if(sigstack.empty())
     
123.                         {
     
124.                                 sigstack.push(str[pos1]);
     
125.                         }
     
126.                         else
     
127.                         {
     
128.                                 if(!compare(sigstack.top(),str[pos1]))//若优先级A<B 则push
     
129.                                 {
     
130.                                         while(!sigstack.empty() && !compare(sigstack.top(),str[pos1]))
     
131.                                         {
     
132.                                                 output.push_back(string(1,sigstack.top()));
     
133.                                                 sigstack.pop();
     
134.                                         }
     
135.                                         output.push_back(string(1,str[pos1]));
     
136.                                 }
     
137.                                 else
     
138.                                 {
     
139.                                         sigstack.push(str[pos1]);
     
140.                                 }
     
141.                         }
     
142.                         pos1++;
     
143.                 }
     
144.                 else if(str[pos1] == '(' || str[pos1] == ')')
     
145.                 {
     
146.                         if(str[pos1] == '(')
     
147.                         {
     
148.                                 sigstack.push('(');
     
149.                         }
     
150.                         else
     
151.                         {
     
152.                                 while(sigstack.top() != '(')
     
153.                                 {
     
154.                                         output.push_back(string(1,sigstack.top()));
     
155.                                         sigstack.pop();
     
156.                                 }
     
157.                                 sigstack.pop();
     
158.                         }
     
159.                         pos1++;
     
160.                 }
     
161.         }
     
162. }
     
163. 
     
164. 
     
165. int func(list<string>& str)//由后缀表达式计算结果
     
166. {
     
167.         stack<double> numstack;
     
168. //        char str[]="9 3.1 1.2 - 3.3 * + 10.4 2.5 / +";
     
169.         int len=str.size();
     
170.         for(int pos=0;pos<len;)
     
171.         {
     
172.                 if(str[pos] >= '0' && str[pos] <= '9')
     
173.                 {
     
174.                         double data=0;
     
175.                         pos += resolvenum(str+pos,data);
     
176.                         numstack.push(data);
     
177.                 }
     
178.                 else if(str[pos] == '+' || str[pos] == '-' || str[pos] == '*' || str[pos]== '/')
     
179.                 {
     
180.                         double num=numstack.top();
     
181.                         numstack.pop();
     
182.                         if(str[pos] == '+')
     
183.                                 numstack.top() += num;
     
184.                         else if(str[pos] == '-')
     
185.                                 numstack.top() -= num;
     
186.                         else if(str[pos] == '*')
     
187.                                 numstack.top() *= num;
     
188.                         else
     
189.                                 numstack.top() /= num;
     
190.                         pos++;
     
191.                 }
     
192.                 else
     
193.                         pos++;
     
194.         }
     
195.         cout<<numstack.top()<<endl;
     
196. }
     
197. 
     

复制代码

cyycoish

基于栈的表达式计算，弄了好几个月，现在分享一下

1. /*
   
2. Calculation Engine Kernel v1.0[Static Edition]
   
3. Created By CYY 20140201
   
4. Copyright (C) 2014 Ctechnology Corporation
   
5. All Rights Resaved.
   
6. [email]cyycoish@hotmail.com[/email]
   
7. 201402042139
   
8. 201402241352
   
9. 201403061734--func
   
10. 201403140144--x1
    
11. 201403202105--no add end
    
12. 201404091752SAT--ALL END
    
13. 注意：AddConstants必须在AddFunc前使用
    
14. */
    
15. //包含部分
    
16. #include <stdio.h>
    
17. #include <stdlib.h>
    
18. #include <string.h>
    
19. //#include <Windows.h>
    
20. #include <math.h>
    
21. #include <time.h>
    
22. //#include <iostream>
    
23. //宏定义部分
    
24. #define N 4096//输入总长
    
25. #define M 1024//输入总长
    
26. #define S_NUM_MAX 4096//单个数字大小
    
27. #define S_OPR_MAX 4096//单个运算符大小
    
28. #define OFUN_NUM  63  //运算符数量
    
29. #define CST_CTR   5   //常数个数
    
30. 
    
31. #define FUN_MAX   1024//运算符数量
    
32. #define PAR_MAX   1024//函数参数数量
    
33. #define UFN_MAX   1024//自定义函数数量
    
34. 
    
35. #define MPI 3.1415926535897932384626433832795028841971693993751058
    
36. #define MEE 2.7182818284590452353602874713526624977572470936999595
    
37. //#define SFUN_NUM  10//自定义运算符数量
    
38. //声明部分
    
39. double CALC_main(char *exp);
    
40. char *InputScanner(char *exp);
    
41. void Debug_Print_Para(void);
    
42. //
    
43. int intFunParCount = 0;//函数参数个数
    
44. double Answ = 0;//保存前一个运算结果
    
45. double pa[M] = { 0 };//函数参数
    
46. int ix = 0;//位置标记
    
47. 
    
48. int iUserFun = 0;//自定义函数数量
    
49. int iParCtr = 0;//函数参数数量
    
50. int iUserCnt = 0;//自定义常量数量
    
51. 
    
52. enum DEGSCALE{//角度度量
    
53.         S_Rad,//弧度制
    
54.         S_Deg,//角度制
    
55.         S_Gra //梯度制
    
56. };
    
57. DEGSCALE degScale = S_Rad;//角度度量默认弧度
    
58. //错误代码
    
59. int ERR_NUM = 0;
    
60. enum ERRORNUM{
    
61.         NoError,
    
62.         MathError,
    
63.         StackError,
    
64.         SyntaxError,
    
65.         UnknownError,
    
66. };
    
67. typedef struct{
    
68.         ERRORNUM num;
    
69.         int pos;
    
70. }ERRSTRU;
    
71. ERRSTRU Error(ERRORNUM E){
    
72.         ERRSTRU ERRNUMr;
    
73.         ERRNUMr.num = E;
    
74.         ERRNUMr.pos = ix;
    
75.         return ERRNUMr;
    
76. }
    
77. //常数
    
78. typedef struct{
    
79.         char *name;
    
80.         double value;
    
81.         int number;
    
82. }CONSTANT;
    
83. //运算符结合性
    
84. enum OPRCAL{
    
85.         DoubleCalOpr,//双目运算符
    
86.         FrontCalOpr, //前缀运算符
    
87.         RearCalOpr,  //后缀运算符
    
88.         IsBracket,   //是括号
    
89.         Specific,    //特殊 ,
    
90.         Functio,     //函数
    
91.         UserFun,     //自定义函数
    
92.         //VarCon       //变量/常数
    
93. };
    
94. //运算符类型
    
95. typedef struct{
    
96.         char *name;//运算符名称
    
97.         int level;//优先级
    
98.         OPRCAL ctype;//运算符结合性
    
99.         /*
    
100.         ctype取值:
     
101.         0:双目运算符
     
102.         1.前缀运算符
     
103.         2.后缀运算符
     
104.         3.括号
     
105.         */
     
106.         int number;//标识符
     
107.         char *expr;//函数表达式
     
108.         //double value;
     
109. }OTYPE;
     
110. //数栈
     
111. typedef struct{
     
112.         double stack[N];
     
113.         int top;
     
114. }NumSTACK;
     
115. //二级数栈存放函数参数[操作对象函数CALC_fun]
     
116. typedef struct{
     
117.         double stack[N];
     
118.         int top;
     
119. }NumSTACK_fun;
     
120. //符栈
     
121. typedef struct{
     
122.         OTYPE stack[M];
     
123.         int top;
     
124. }OprSTACK;
     
125. //初始化数栈
     
126. void InitNumSTACK(NumSTACK* s){
     
127.         (*s).top = 0;
     
128. }
     
129. //进数栈
     
130. bool NPush(NumSTACK* s, double n)
     
131. {
     
132.         //如果栈满则报错退出程序
     
133.         if ((*s).top == N - 1){
     
134.                 Error(StackError);
     
135.                 return false;
     
136.         }
     
137.         (*s).stack[(*s).top] = n;
     
138.         (*s).top++;
     
139.         return true;
     
140. }
     
141. //出数栈
     
142. double NPop(NumSTACK* s)
     
143. {
     
144.         //如果栈空则报错退出程序
     
145.         if ((*s).top == 0){
     
146.                 Error(StackError);
     
147.                 return 0;
     
148.         }
     
149.         else{
     
150.                 (*s).top--;
     
151.                 return (*s).stack[(*s).top];
     
152.         }
     
153. }
     
154. //初始化符栈
     
155. void InitOprSTACK(OprSTACK* s){
     
156.         (*s).top = 0;
     
157. }
     
158. //进符栈
     
159. bool OPush(OprSTACK* s, OTYPE* sign)
     
160. {
     
161.         //如果栈满则报错退出程序
     
162.         if ((*s).top == M - 1){
     
163.                 Error(SyntaxError);
     
164.                 return false;
     
165.         }
     
166.         (*s).stack[(*s).top] = *sign;
     
167.         (*s).top++;
     
168.         return true;
     
169. }
     
170. //出符栈
     
171. OTYPE OPop(OprSTACK *s)
     
172. {
     
173.         //栈空则报错退出程序
     
174.         if ((*s).top == 0){
     
175.                 Error(SyntaxError);
     
176.         }
     
177.         else{
     
178.                 (*s).top--;
     
179.                 //return (*s).stack[M-((*s).top)];
     
180.                 return (*s).stack[(*s).top];
     
181.         }
     
182. }
     
183. //运算符表
     
184. OTYPE oper[FUN_MAX];
     
185. bool InitOperTable(void){
     
186.         /*
     
187.         oper[0].name="#";     oper[0].level=1;  oper[0].ctype=DoubleCalOpr; oper[0].number=1;
     
188.         oper[1].name="NOT";   oper[1].level=2;  oper[1].ctype=FrontCalOpr;  oper[1].number=2;
     
189.         oper[2].name="~NOT";  oper[2].level=7;  oper[2].ctype=FrontCalOpr;  oper[2].number=3;
     
190.         oper[3].name="^";     oper[3].level=14; oper[3].ctype=DoubleCalOpr; oper[3].number=4;
     
191.         oper[4].name="!";     oper[4].level=15; oper[4].ctype=RearCalOpr;   oper[4].number=5;
     
192.         oper[5].name="*";     oper[5].level=13; oper[5].ctype=DoubleCalOpr; oper[5].number=6;
     
193.         oper[6].name="/";     oper[6].level=13; oper[6].ctype=DoubleCalOpr; oper[6].number=7;
     
194.         oper[7].name="MOD";   oper[7].level=13; oper[7].ctype=DoubleCalOpr; oper[7].number=8;
     
195.         oper[8].name="AND";   oper[8].level=8;  oper[8].ctype=DoubleCalOpr; oper[8].number=9;
     
196.         oper[9].name="~AND";  oper[9].level=3;  oper[9].ctype=DoubleCalOpr; oper[9].number=10;
     
197.         oper[10].name="+";    oper[10].level=12;oper[10].ctype=DoubleCalOpr;oper[10].number=11;
     
198.         //oper[11].name="-";    oper[11].level=4;oper[11].ctype=DoubleCalOpr;oper[11].number=12;
     
199.         oper[11].name="OR";   oper[11].level=9; oper[11].ctype=DoubleCalOpr;oper[11].number=12;
     
200.         oper[12].name="~OR";  oper[12].level=4; oper[12].ctype=DoubleCalOpr;oper[12].number=13;
     
201.         oper[13].name="XOR";  oper[13].level=10;oper[13].ctype=DoubleCalOpr;oper[13].number=14;
     
202.         oper[14].name="~XOR"; oper[14].level=5; oper[14].ctype=DoubleCalOpr;oper[14].number=15;
     
203.         oper[15].name="XNOR"; oper[15].level=11;oper[15].ctype=DoubleCalOpr;oper[15].number=16;
     
204.         oper[16].name="~XNOR";oper[16].level=6; oper[16].ctype=DoubleCalOpr;oper[16].number=17;
     
205.         oper[17].name="=";    oper[17].level=16;oper[17].ctype=DoubleCalOpr;oper[17].number=18;
     
206.         oper[18].name=";";    oper[18].level=17;oper[18].ctype=RearCalOpr;  oper[18].number=19;
     
207.         oper[19].name="(";    oper[19].level=-1;oper[19].ctype=IsBracket;   oper[19].number=20;
     
208.         oper[20].name=")";    oper[20].level=0; oper[20].ctype=IsBracket;   oper[20].number=21;
     
209.         oper[21].name=",";    oper[21].level=0; oper[21].ctype=IsBracket;   oper[21].number=22;
     
210.         */
     
211.         oper[0].name = "NAN";   oper[0].level = 100; oper[0].ctype = Specific;     oper[0].number = -1;
     
212.         oper[1].name = "NOT";   oper[1].level = 25;  oper[1].ctype = FrontCalOpr;  oper[1].number = 2;
     
213.         oper[2].name = "~NOT";  oper[2].level = 24;  oper[2].ctype = FrontCalOpr;  oper[2].number = 3;
     
214.         oper[3].name = "^";     oper[3].level = 14;  oper[3].ctype = DoubleCalOpr; oper[3].number = 4;
     
215.         oper[4].name = "!";     oper[4].level = 15;  oper[4].ctype = RearCalOpr;   oper[4].number = 5;
     
216.         oper[5].name = "*";     oper[5].level = 13;  oper[5].ctype = DoubleCalOpr; oper[5].number = 6;
     
217.         oper[6].name = "/";     oper[6].level = 13;  oper[6].ctype = DoubleCalOpr; oper[6].number = 7;
     
218.         oper[7].name = "MOD";   oper[7].level = 13;  oper[7].ctype = DoubleCalOpr; oper[7].number = 8;
     
219.         oper[8].name = "AND";   oper[8].level = 23;  oper[8].ctype = DoubleCalOpr; oper[8].number = 9;
     
220.         oper[9].name = "~AND";  oper[9].level = 22;  oper[9].ctype = DoubleCalOpr; oper[9].number = 10;
     
221.         oper[10].name = "+";    oper[10].level = 12; oper[10].ctype = DoubleCalOpr; oper[10].number = 11;
     
222.         oper[11].name = "OR";   oper[11].level = 21; oper[11].ctype = DoubleCalOpr; oper[11].number = 12;
     
223.         oper[12].name = "~OR";  oper[12].level = 20; oper[12].ctype = DoubleCalOpr; oper[12].number = 13;
     
224.         oper[13].name = "XOR";  oper[13].level = 19; oper[13].ctype = DoubleCalOpr; oper[13].number = 14;
     
225.         oper[14].name = "~XOR"; oper[14].level = 18; oper[14].ctype = DoubleCalOpr; oper[14].number = 15;
     
226.         oper[15].name = "XNOR"; oper[15].level = 17; oper[15].ctype = DoubleCalOpr; oper[15].number = 16;
     
227.         oper[16].name = "~XNOR"; oper[16].level = 16; oper[16].ctype = DoubleCalOpr; oper[16].number = 17;
     
228.         oper[17].name = ">>";   oper[17].level = 9;  oper[17].ctype = DoubleCalOpr; oper[17].number = 18;
     
229.         oper[18].name = ";";    oper[18].level = 17; oper[18].ctype = RearCalOpr;   oper[18].number = 19;
     
230.         oper[19].name = "(";    oper[19].level = -1; oper[19].ctype = IsBracket;    oper[19].number = 20;
     
231.         oper[20].name = ")";    oper[20].level = 0;  oper[20].ctype = IsBracket;    oper[20].number = 21;
     
232.         oper[21].name = ",";    oper[21].level = 0;  oper[21].ctype = IsBracket;    oper[21].number = 22;
     
233. 
     
234.         oper[22].name = "ADD";  oper[22].level = 99; oper[22].ctype = Functio;      oper[22].number = 23;
     
235.         oper[23].name = "SIN";  oper[23].level = 99; oper[23].ctype = FrontCalOpr;  oper[23].number = 24;
     
236.         oper[24].name = "%";    oper[24].level = 26; oper[24].ctype = RearCalOpr;   oper[24].number = 1;
     
237.         oper[25].name = "COS";  oper[25].level = 99; oper[25].ctype = FrontCalOpr;  oper[25].number = 25;
     
238.         oper[26].name = "TAN";  oper[26].level = 99; oper[26].ctype = FrontCalOpr;  oper[26].number = 26;
     
239. 
     
240.         oper[27].name = "~>";   oper[27].level = 11; oper[27].ctype = DoubleCalOpr; oper[27].number = 27;
     
241.         oper[28].name = "~<";   oper[28].level = 11; oper[28].ctype = DoubleCalOpr; oper[28].number = 28;
     
242.         oper[29].name = ">=";   oper[29].level = 11; oper[29].ctype = DoubleCalOpr; oper[29].number = 27;
     
243.         oper[30].name = "<=";   oper[30].level = 11; oper[30].ctype = DoubleCalOpr; oper[30].number = 30;
     
244.         oper[31].name = "==";   oper[31].level = 10; oper[31].ctype = DoubleCalOpr; oper[31].number = 31;
     
245.         oper[32].name = "<>";   oper[32].level = 10; oper[32].ctype = DoubleCalOpr; oper[32].number = 32;
     
246. 
     
247.         oper[33].name = "ARCSIN";  oper[33].level = 99; oper[33].ctype = FrontCalOpr;  oper[33].number = 33;
     
248.         oper[34].name = "ARCCOS";  oper[34].level = 99; oper[34].ctype = FrontCalOpr;  oper[34].number = 34;
     
249.         oper[35].name = "ARCTAN";  oper[35].level = 99; oper[35].ctype = FrontCalOpr;  oper[35].number = 35;
     
250.         oper[36].name = "ABS";     oper[36].level = 99; oper[36].ctype = FrontCalOpr;  oper[36].number = 36;
     
251. 
     
252.         oper[37].name = "SINH";    oper[37].level = 99; oper[37].ctype = FrontCalOpr;  oper[37].number = 37;
     
253.         oper[38].name = "COSH";    oper[38].level = 99; oper[38].ctype = FrontCalOpr;  oper[38].number = 38;
     
254.         oper[39].name = "TANH";    oper[39].level = 99; oper[39].ctype = FrontCalOpr;  oper[39].number = 39;
     
255. 
     
256.         oper[40].name = "ARCSINH"; oper[40].level = 99; oper[40].ctype = FrontCalOpr;  oper[40].number = 40;
     
257.         oper[41].name = "ARCCOSH"; oper[41].level = 99; oper[41].ctype = FrontCalOpr;  oper[41].number = 41;
     
258.         oper[42].name = "ARCTANH"; oper[42].level = 99; oper[42].ctype = FrontCalOpr;  oper[42].number = 42;
     
259. 
     
260.         oper[43].name = "LG";      oper[43].level = 99; oper[43].ctype = FrontCalOpr;  oper[43].number = 43;
     
261.         oper[44].name = "LN";      oper[44].level = 99; oper[44].ctype = FrontCalOpr;  oper[44].number = 44;
     
262.         oper[45].name = "LOG";     oper[45].level = 99; oper[45].ctype = Functio;      oper[45].number = 45;
     
263.         oper[46].name = "SGN";     oper[46].level = 99; oper[46].ctype = FrontCalOpr;  oper[46].number = 46;
     
264. 
     
265.         oper[47].name = "SQR";     oper[47].level = 99; oper[47].ctype = FrontCalOpr;  oper[47].number = 47;
     
266.         oper[48].name = "INT";     oper[48].level = 99; oper[48].ctype = FrontCalOpr;  oper[48].number = 48;
     
267. 
     
268.         oper[49].name = "SEC";     oper[49].level = 99; oper[49].ctype = FrontCalOpr;  oper[49].number = 49;
     
269.         oper[50].name = "CSC";     oper[50].level = 99; oper[50].ctype = FrontCalOpr;  oper[50].number = 50;
     
270.         oper[51].name = "COT";     oper[51].level = 99; oper[51].ctype = FrontCalOpr;  oper[51].number = 51;
     
271.         oper[52].name = "ARCSEC";  oper[52].level = 99; oper[52].ctype = FrontCalOpr;  oper[52].number = 52;
     
272.         oper[53].name = "ARCCSC";  oper[53].level = 99; oper[53].ctype = FrontCalOpr;  oper[53].number = 53;
     
273.         oper[54].name = "ARCCOT";  oper[54].level = 99; oper[54].ctype = FrontCalOpr;  oper[54].number = 54;
     
274.         oper[55].name = "SECH";    oper[55].level = 99; oper[55].ctype = FrontCalOpr;  oper[55].number = 55;
     
275.         oper[56].name = "CSCH";    oper[56].level = 99; oper[56].ctype = FrontCalOpr;  oper[56].number = 56;
     
276.         oper[57].name = "COTH";    oper[57].level = 99; oper[57].ctype = FrontCalOpr;  oper[57].number = 57;
     
277.         oper[58].name = "ARCSECH"; oper[58].level = 99; oper[58].ctype = FrontCalOpr;  oper[58].number = 58;
     
278.         oper[59].name = "ARCCSCH"; oper[59].level = 99; oper[59].ctype = FrontCalOpr;  oper[59].number = 59;
     
279.         oper[60].name = "ARCCOTH"; oper[60].level = 99; oper[60].ctype = FrontCalOpr;  oper[60].number = 60;
     
280.         oper[61].name = "ROOT";    oper[61].level = 99; oper[61].ctype = Functio;      oper[61].number = 61;
     
281. 
     
282.         oper[62].name = "AVG";     oper[62].level = 99; oper[62].ctype = Functio;      oper[62].number = 62;
     
283.         oper[63].name = "INT";     oper[63].level = 99; oper[63].ctype = FrontCalOpr;  oper[63].number = 63;
     
284.         //oper[25].name = "PI";   oper[25].level = 100; oper[25].ctype = VarCon;     oper[25].number = 25; oper[25].value = 3.14;
     
285.         return true;
     
286. }
     
287. //常数表
     
288. CONSTANT constants[CST_CTR];//常数变量
     
289. CONSTANT functpara[PAR_MAX];//函数参数
     
290. void InitParaTable(void){
     
291.         register int i = 0;
     
292.         for (i = 0; i < PAR_MAX; i++){
     
293.                 functpara[i].name = "";
     
294.                 functpara[i].number = 0;
     
295.                 functpara[i].value = 0;
     
296.         }
     
297. }
     
298. bool InitConstTable(void){
     
299.         constants[0].name = "NULL"; constants[0].value = 0;   constants[0].number = 1;
     
300.         constants[1].name = "PI";   constants[1].value = MPI; constants[1].number = 2;
     
301.         constants[2].name = "E";    constants[2].value = MEE; constants[2].number = 3;
     
302.         constants[3].name = "ANS";  constants[3].value = 0;   constants[3].number = 4;
     
303.         constants[4].name = "RND";  constants[4].value = 0;   constants[4].number = 5;
     
304.         return true;
     
305. }
     
306. /////////////////
     
307. double Sgn(double x){
     
308.         if (x > 0)
     
309.                 return 1.0;
     
310.         else if (x == 0)
     
311.                 return 0.0;
     
312.         else
     
313.                 return -1.0;
     
314. }
     
315. //运算符运算过程表
     
316. double DOprCal(double b, double a, int number){//双目运算符运算
     
317.         switch (number){
     
318.         case 4://^
     
319.                 //printf("%s\n","hello^");////////////////////
     
320.                 return powf(a, b);
     
321.         case 6://*
     
322.                 //printf("%s\n","hello*");////////////////////
     
323.                 return a*b;
     
324.         case 7:///
     
325.                 if (b != 0)
     
326.                         return a / b;
     
327.                 else{
     
328.                         Error(MathError);
     
329.                         return 0;
     
330.                 }
     
331.         case 8://MOD
     
332.                 return (int)a % (int)b;
     
333.         case 9://AND
     
334.                 return a&&b;
     
335.         case 10://~AND
     
336.                 return (int)a&(int)b;
     
337.         case 11://+
     
338.                 //printf("%s\n","hello+");////////////////////
     
339.                 return a + b;
     
340.                 //case 12://-
     
341.                 //return a-b;
     
342.         case 12://OR
     
343.                 //printf("%s\n","hello or");////////////////////
     
344.                 return a || b;
     
345.         case 13://~OR
     
346.                 return (int)a | (int)b;
     
347.         case 14://XOR
     
348.                 if (a == b)
     
349.                         return 0;
     
350.                 else
     
351.                         return 1;
     
352.         case 15://~XOR
     
353.                 return (int)a ^ (int)b;
     
354.         case 16://XNOR
     
355.                 if (a == b)
     
356.                         return 1;
     
357.                 else
     
358.                         return 0;
     
359.         case 17://~XNOR
     
360.                 return ~((int)a ^ (int)b);
     
361.         case 18://=
     
362.                 if (a == b)
     
363.                         return 1;
     
364.                 else
     
365.                         return 0;
     
366.         case 27:
     
367.                 if (a > b)
     
368.                         return 1;
     
369.                 else
     
370.                         return 0;
     
371.         case 28:
     
372.                 if (a < b)
     
373.                         return 1;
     
374.                 else
     
375.                         return 0;
     
376.         case 29:
     
377.                 if (a >= b)
     
378.                         return 1;
     
379.                 else
     
380.                         return 0;
     
381.         case 30:
     
382.                 if (a <= b)
     
383.                         return 1;
     
384.                 else
     
385.                         return 0;
     
386.         case 31:
     
387.                 if (a == b)
     
388.                         return 1;
     
389.                 else
     
390.                         return 0;
     
391.         case 32:
     
392.                 if (a != b)
     
393.                         return 1;
     
394.                 else
     
395.                         return 0;
     
396.         }
     
397. }
     
398. double FOprCal(int number, double a = 0){//单目前缀运算符运算
     
399.         int j = 0; double x = 0; char tStr[N] = { '\0' };
     
400.         //printf("入FO的数字代码:%s\n",number);/////////////////////////
     
401.         switch (number){
     
402.         case 2://NOT
     
403.                 if (a != 0)
     
404.                         return 0;
     
405.                 else
     
406.                         return 1;
     
407.         case 3://~NOT
     
408.                 return ~((int)a);
     
409.         case 23://add
     
410.                 for (j = 0; j <= intFunParCount; j++)
     
411.                         x += pa[j];
     
412.                 return x;
     
413.         case 24://sin
     
414.                 switch (degScale){
     
415.                 case S_Rad:
     
416.                         return sin(a);
     
417.                 case S_Deg:
     
418.                         return sin(MPI / 180 * a);
     
419.                 case S_Gra:
     
420.                         return sin(MPI / 200 * a);
     
421.                 }
     
422.         case 25://cos
     
423.                 switch (degScale){
     
424.                 case S_Rad:
     
425.                         return cos(a);
     
426.                 case S_Deg:
     
427.                         return cos(MPI / 180 * a);
     
428.                 case S_Gra:
     
429.                         return cos(MPI / 200 * a);
     
430.                 }
     
431.         case 26:
     
432.                 switch (degScale){
     
433.                 case S_Rad:
     
434.                         return tan(a);
     
435.                 case S_Deg:
     
436.                         return tan(MPI / 180 * a);
     
437.                 case S_Gra:
     
438.                         return tan(MPI / 200 * a);
     
439.                 }
     
440.         case 33:
     
441.                 x = asin(a);
     
442.                 switch (degScale){
     
443.                 case S_Rad:
     
444.                         return x;
     
445.                 case S_Deg:
     
446.                         return MPI / 180 * x;
     
447.                 case S_Gra:
     
448.                         return MPI / 200 * x;
     
449.                 }
     
450.         case 34:
     
451.                 x = acos(a);
     
452.                 switch (degScale){
     
453.                 case S_Rad:
     
454.                         return x;
     
455.                 case S_Deg:
     
456.                         return MPI / 180 * x;
     
457.                 case S_Gra:
     
458.                         return MPI / 200 * x;
     
459.                 }
     
460.         case 35:
     
461.                 x = atan(a);
     
462.                 switch (degScale){
     
463.                 case S_Rad:
     
464.                         return x;
     
465.                 case S_Deg:
     
466.                         return MPI / 180 * x;
     
467.                 case S_Gra:
     
468.                         return MPI / 200 * x;
     
469.                 }
     
470.         case 36:
     
471.                 return fabs(a);
     
472.         case 37://sinh
     
473.                 return (exp(a) - exp(-a)) / 2;
     
474.         case 38://cosh
     
475.                 return (exp(a) + exp(-a)) / 2;
     
476.         case 39://tanh
     
477.                 return  (exp(a) - exp(-a)) / (exp(a) + exp(-a));
     
478.         case 40://arcsinh
     
479.                 return log(a + sqrt(a * a + 1));
     
480.         case 41://arccosh
     
481.                 return log(a + sqrt(a * a - 1));
     
482.         case 42://arctanh
     
483.                 return log((1 + a) / (1 - a)) / 2;
     
484.         case 43://lg
     
485.                 return log(a) / log(10.0);
     
486.         case 44://ln
     
487.                 return log(a) / log(MEE);
     
488.         case 45://log
     
489.                 return log(pa[0]) / log(pa[1]);
     
490.         case 46://sgn
     
491.                 return Sgn(a);
     
492.         case 47://sqr
     
493.                 return sqrt(a);
     
494.         case 48://int
     
495.                 return (double)int(a);
     
496.         case 49://sec
     
497.                 if (a == 0)
     
498.                         return 1.0;
     
499.                 else
     
500.                         x = 1 / cos(a);
     
501.                 switch (degScale){
     
502.                 case S_Rad:
     
503.                         return x;
     
504.                 case S_Deg:
     
505.                         return MPI / 180 * x;
     
506.                 case S_Gra:
     
507.                         return MPI / 200 * x;
     
508.                 }
     
509.         case 50://csc
     
510.                 x = 1 / sin(a);
     
511.                 switch (degScale){
     
512.                 case S_Rad:
     
513.                         return x;
     
514.                 case S_Deg:
     
515.                         return MPI / 180 * x;
     
516.                 case S_Gra:
     
517.                         return MPI / 200 * x;
     
518.                 }
     
519.         case 51://cot
     
520.                 x = 1 / tan(a);
     
521.                 switch (degScale){
     
522.                 case S_Rad:
     
523.                         return x;
     
524.                 case S_Deg:
     
525.                         return MPI / 180 * x;
     
526.                 case S_Gra:
     
527.                         return MPI / 200 * x;
     
528.                 }
     
529.         case 52://arc sec
     
530.                 if (a == 1)
     
531.                         return 0.0;
     
532.                 else
     
533.                         x = atan(a / sqrt(a * a - 1)) + Sgn((a)-1) * (2 * atan(1.0));
     
534.                 switch (degScale){
     
535.                 case S_Rad:
     
536.                         return x;
     
537.                 case S_Deg:
     
538.                         return MPI / 180 * x;
     
539.                 case S_Gra:
     
540.                         return MPI / 200 * x;
     
541.                 }
     
542.         case 53://arc csc
     
543.                 x = atan(a / sqrt(a * a - 1)) + (Sgn(a) - 1) * (2 * atan(1.0));
     
544.                 switch (degScale){
     
545.                 case S_Rad:
     
546.                         return x;
     
547.                 case S_Deg:
     
548.                         return MPI / 180 * x;
     
549.                 case S_Gra:
     
550.                         return MPI / 200 * x;
     
551.                 }
     
552.         case 54://arc cot
     
553.                 x = atan(a) + 2 * atan(1.0);
     
554.                 switch (degScale){
     
555.                 case S_Rad:
     
556.                         return x;
     
557.                 case S_Deg:
     
558.                         return MPI / 180 * x;
     
559.                 case S_Gra:
     
560.                         return MPI / 200 * x;
     
561.                 }
     
562.         case 55://sech
     
563.                 if (a == 0)
     
564.                         return 1;
     
565.                 else
     
566.                         x = 2 / (exp(a) + exp(-a));
     
567.         case 56://scsh
     
568.                 x = 2 / (exp(a) - exp(-a));
     
569.         case 57://coth
     
570.                 x = (exp(a) + exp(-a)) / (exp(a) - exp(-a));
     
571.         case 58://arc sech
     
572.                 x = log((sqrt(-a * a + 1) + 1) / a);
     
573.         case 59://arc scsh
     
574.                 x = log((Sgn(a) * sqrt(a * a + 1) + 1) / a);
     
575.         case 60://arc coth
     
576.                 x = log((a + 1) / (a - 1)) / 2;
     
577.         case 61:
     
578.                 return powf(pa[0], 1 / pa[1]);
     
579.         case 62:
     
580.                 for (j = 0; j <= intFunParCount; j++)
     
581.                         x += pa[j];
     
582.                 return x / (intFunParCount + 1);
     
583.         case 63:
     
584.                 return (double)int(a);
     
585.         default:
     
586.                 //Debug_Print_Para();
     
587.                 //double xxxz = 0;
     
588.                 //char *cah;
     
589.                 strcpy(tStr, InputScanner(oper[number].expr));
     
590.                 //printf("\tA1st::\'%s\'\n", tStr);/////////////////////////////////////////InputScanner(oper[number].expr)
     
591.                 return CALC_main(tStr);
     
592.         }
     
593. }
     
594. double ROprCal(double a, int number){//单目后缀运算符运算
     
595.         int k;
     
596.         double r = 1.0;
     
597.         switch (number){
     
598.         case 1:
     
599.                 return (a / 100);
     
600.                 //printf("hello");
     
601.         case 5://!
     
602. 
     
603.                 for (k = 1; k <= (int)a; k++)
     
604.                         r = r*(double)k;
     
605.                 return r;
     
606.         case 19://;
     
607.                 ;
     
608.         }
     
609. }
     
610. //查找运算符
     
611. int IsOper(char *s){
     
612.         register int i = 0;
     
613.         //printf("iUserFun:%d\n", iUserFun);////////////////////
     
614.         for (i = 0; i <= (OFUN_NUM + iUserFun); i++){
     
615.                 //printf("比较前：%s\n", oper[i].name);
     
616.                 //if (i == 63) printf("hello\n");//////////////////////////////////
     
617.                 if ((s[0] != '\0') && (strcmp(s, oper[i].name) == 0)){
     
618.                         //printf("找到的:%d\n",i);/////////////////////////////////////////
     
619.                         return i;
     
620.                 }
     
621.         }
     
622.         //printf("LAST:%d\n", i);/////////////////////////////////////////
     
623.         return 0;
     
624. }
     
625. //查找函数参数变量
     
626. int IsPara(char *s){
     
627.         register int i = 1;
     
628.         for (i = 1; i <= iParCtr; i++){
     
629.                 if ((s[0] != '\0'))
     
630.                         if ((strcmp(s, functpara[i].name) == 0))
     
631.                                 return i;
     
632.         }
     
633.         return 0;
     
634. }
     
635. //查找常数
     
636. int IsConst(char *s){
     
637.         register int i = 1;
     
638.         for (i = 1; i < CST_CTR + iUserCnt; i++){
     
639.                 if ((s[0] != '\0') && (strcmp(s, constants[i].name) == 0)){
     
640.                         return i;
     
641.                 }
     
642.         }
     
643.         return 0;
     
644. }
     
645. //符栈看栈顶
     
646. OTYPE OPeek(OprSTACK *s){
     
647.         OTYPE r;
     
648.         if ((*s).top == 0){//判栈空，空则赋等级0值
     
649.                 r.level = 0;
     
650.                 return r;
     
651.         }
     
652.         else
     
653.                 return(*s).stack[(*s).top - 1];
     
654. }
     
655. ///////////////////////////////
     
656. //字符串函数
     
657. char *Mid(char *String, long Start, long Length = -1){
     
658.         long i = 0, j = 0;
     
659.         char string[N] = { '\0' }; strcpy(string, String);
     
660.         if (Length == -1)
     
661.                 Length = strlen(string) - Start + 1;
     
662.         string[Start + Length - 1] = '\0';
     
663.         for (i = 0, j = Start - 1; i <= strlen(string); i++, j++)
     
664.                 string[i] = string[j];
     
665.         return string;
     
666. }
     
667. ///////////////////////////////
     
668. bool AddFunc(char *name, char para[][M], char *expr){
     
669.         int i = 0;
     
670.         if (IsOper(name) != 0)
     
671.                 return false;
     
672.         ++iUserFun;
     
673. 
     
674.         //printf("\t\\%s\\\n", oper[OFUN_NUM + iUserFun].name);///////////////////////////////////
     
675.         oper[OFUN_NUM + iUserFun].ctype = UserFun;
     
676.         oper[OFUN_NUM + iUserFun].level = 99;
     
677.         oper[OFUN_NUM + iUserFun].name = name;
     
678.         oper[OFUN_NUM + iUserFun].number = OFUN_NUM + iUserFun;
     
679.         oper[OFUN_NUM + iUserFun].expr = expr;
     
680.         //printf("自定义函数:"%s"\n", oper[OFUN_NUM + iUserFun].name);////////////////////
     
681.         //oper[OFUN_NUM + iUserFun]
     
682.         for (i = 0; i < PAR_MAX; i++){
     
683.                 //printf("参数:"%s"\n", para[i]);////////////////////////////////////////
     
684.                 if ((IsConst(para[i]) == 0) && (IsPara(para[i]) == 0) && (para[i][0] != '\0')){
     
685.                         //printf("参数:"%s"\n", para[i]);////////////////////////////////////////
     
686.                         functpara[i + 1].name = para[i];
     
687.                         //iParCtr++;
     
688.                 }
     
689.                 else{
     
690.                         break;
     
691.                 }
     
692.         }
     
693.         return true;
     
694.         //printf("自定义函数:%s\n", oper[OFUN_NUM + iUserFun].name);////////////////////
     
695. }
     
696. void SetPara(double value){
     
697.         ++iParCtr;
     
698.         functpara[iParCtr].number = iParCtr;
     
699.         functpara[iParCtr].value = value;
     
700. }
     
701. bool ClearAllFunc(void){
     
702.         int i = 0;
     
703.         for (i = 0; i <= iUserFun; i++){
     
704.                 oper[OFUN_NUM + iUserFun].name = "";
     
705.                 oper[OFUN_NUM + iUserFun].number = 0;
     
706.         }
     
707.         iUserFun = 0;
     
708.         iParCtr = 0;
     
709.         return true;
     
710. }
     
711. //////
     
712. bool AddConstant(char *cname, double value){
     
713.         int i = 0;
     
714.         if (IsConst(cname) != 0)
     
715.                 return false;
     
716.         if (IsPara(cname) != 0)
     
717.                 return false;
     
718.         if (IsOper(cname) != 0)
     
719.                 return false;
     
720.         ++iUserCnt;
     
721.         //printf("CST HELLO!\t%d\n", CST_CTR + iUserCnt);///////////////////////////////
     
722.         constants[CST_CTR + iUserCnt].name = cname;
     
723.         constants[CST_CTR + iUserCnt].value = value;
     
724.         constants[CST_CTR + iUserCnt].number = CST_CTR + iUserCnt;
     
725.         return true;
     
726. }
     
727. bool ClearAllConst(void){
     
728.         int i = 0;
     
729.         for (i = 0; i <= iUserCnt; i++){
     
730.                 constants[CST_CTR + iUserCnt].name = "";
     
731.                 constants[CST_CTR + iUserCnt].number = 0;
     
732.         }
     
733.         iUserCnt = 0;
     
734.         return true;
     
735. }
     
736. ///////////////////////////////
     
737. void CALC_simple(OTYPE OTOpr, NumSTACK* dblStack, bool isFun = false){
     
738.         double tmpNumA = 0.0, tmpNumB = 0.0, tmpNumR = 0.0;
     
739.         int j = 0;
     
740.         //printf("CALC_simple hello\n");///////////////////////////////
     
741.         //printf("\t运算符出栈:%s\n",OTOpr.name);/////////////////////////////////
     
742.         switch (OTOpr.ctype){//检测运算符类型
     
743.         case DoubleCalOpr:
     
744.                 tmpNumA = NPop(dblStack);//取出一个操作数
     
745.                 //printf("\t数栈出栈A:%f\n",tmpNumA);////////////////////////////
     
746.                 tmpNumB = NPop(dblStack);//取出一个操作数
     
747.                 //printf("\t数栈出栈B:%f\n",tmpNumB);////////////////////////////
     
748.                 tmpNumR = DOprCal(tmpNumA, tmpNumB, OTOpr.number);//双目运算符运算
     
749.                 break;
     
750.         case FrontCalOpr:
     
751.                 tmpNumA = NPop(dblStack);//取出一个操作数1
     
752.                 //printf("\t数栈出栈A2:%f\n",tmpNumA);////////////////////////////
     
753.                 tmpNumB = NPop(dblStack);//取出一个操作数2
     
754.                 //printf("\t数栈出栈B2:%f\n",tmpNumB);////////////////////////////
     
755.                 tmpNumR = FOprCal(OTOpr.number, tmpNumA);
     
756.                 NPush(dblStack, tmpNumB);//操作数1进栈
     
757.                 //printf("\t内进栈:%f\n",tmpNumB);////////////////////////////
     
758.                 break;
     
759.         case RearCalOpr:
     
760.                 tmpNumA = NPop(dblStack);//取出一个操作数1
     
761.                 tmpNumR = ROprCal(tmpNumA, OTOpr.number);
     
762.                 break;
     
763.         case Functio:
     
764.                 for (j = 0; j <= intFunParCount; j++){
     
765.                         pa[j] = NPop(dblStack);//取出一个操作数1
     
766.                         //printf("\t数栈出栈AF:%f\n", tmpNumA);////////////////////////////
     
767.                 }
     
768.                 tmpNumR = FOprCal(OTOpr.number);
     
769.                 break;
     
770.         case UserFun:
     
771.                 for (j = 0; j <= intFunParCount; j++)
     
772.                         SetPara(NPop(dblStack));//取出一个操作数
     
773.                 tmpNumR = FOprCal(OTOpr.number);
     
774.                 break;
     
775.         }
     
776.         NPush(dblStack, tmpNumR);//运算结果进栈
     
777.         //printf("数栈进栈 内:%f\n",tmpNumR);////////////////////////////
     
778. }
     
779. double CALC_main(char *exp){//计算
     
780.         //初始化
     
781.         //InitOperTable();
     
782.         //定义栈
     
783.         NumSTACK nStack;
     
784.         OprSTACK oStack;
     
785.         //初始化栈
     
786.         InitNumSTACK(&nStack);
     
787.         InitOprSTACK(&oStack);
     
788.         char sTmpNum[S_NUM_MAX] = { 0 };//用于[数字整合]的临时变量
     
789.         char sTmpOpr[S_OPR_MAX] = { 0 };//用于[运算符整合]临时变量
     
790.         char cTmpDblChar[2] = { 0, 0 };//临时存放单个字符
     
791.         OTYPE y, w;//
     
792.         int iWhichOpr = 0;//记录运算符返回值
     
793.         //主循环
     
794.         //ix = 0;//位置标记
     
795.         if (exp == "")return 0;//空串返零
     
796.         //exp = strupr(exp);//全转为大写
     
797.         for (ix = 0; ix <= strlen(exp); ix++){
     
798.                 if ((exp[ix] >= '0'&&exp[ix] <= '9') || exp[ix] == '-' || exp[ix] == '.'){//区分操作数和运算符及其进栈
     
799.                         //数字整合
     
800.                         cTmpDblChar[0] = exp[ix];
     
801.                         strcat(sTmpNum, cTmpDblChar);
     
802.                         if ((exp[ix + 1] >= '0'&&exp[ix + 1] <= '9') || exp[ix + 1] == '-' || exp[ix + 1] == '.'){
     
803.                                 continue;
     
804.                         }
     
805.                         else{//数字进栈
     
806.                                 double x = atof(sTmpNum);//转换
     
807.                                 NPush(&nStack, x);//数字进栈
     
808.                                 //printf("数字进栈A:%f\n",x);/////////////////////////////////
     
809.                                 sTmpNum[0] = '\0';//进栈后的临时数串清零
     
810.                         }
     
811.                 }
     
812.                 else{//运算符整合及运算
     
813.                         //运算符整合
     
814.                         cTmpDblChar[0] = exp[ix];
     
815.                         strcat(sTmpOpr, cTmpDblChar);
     
816.                         //printf("符号:%s\n", sTmpOpr);////////////////////////////////////////////////////////
     
817.                         //printf("yname==%d\n", IsOper(sTmpOpr));/////////////////////////////////////////////////////
     
818.                         if (iWhichOpr = IsOper(sTmpOpr)){
     
819.                                 y = oper[iWhichOpr];
     
820.                                 //printf("yname==%s\n",y.name);/////////////////////////////////////////////////////
     
821.                                 sTmpOpr[0] = '\0';
     
822.                                 if (y.ctype != IsBracket){
     
823.                                         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     
824.                                         while (OPeek(&oStack).level >= y.level&&oStack.top > 0 && OPeek(&oStack).level > 0){//当栈中符的等级大于当前等级时则取出符进行运算
     
825.                                                 w = OPop(&oStack);//出栈一个运算符
     
826.                                                 //printf("\t运算符出栈1:%s\n",w.name);/////////////////////////////////
     
827.                                                 CALC_simple(w, &nStack);
     
828.                                                 intFunParCount = 0;
     
829.                                         }
     
830.                                         OPush(&oStack, &y);//直到无法运算将当前符放入栈中
     
831.                                         //printf("运算符进栈1:%s\n",y.name);/////////////////////////////////
     
832.                                         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
     
833.                                 }
     
834.                                 else{
     
835.                                         if (y.number == 20){//如果是左括号则无条件进栈
     
836.                                                 OPush(&oStack, &y);//进栈后等级为-1，以便遇到右括号出栈
     
837.                                                 //printf("运算符进栈2:%s\n",y.name);/////////////////////////////////
     
838.                                         }
     
839.                                         else if (y.number == 21){//右括号计算
     
840.                                                 while (OPeek(&oStack).level != -1){//遇到右括号则计算直到左括号
     
841.                                                         w = OPop(&oStack);//出栈一个运算符
     
842.                                                         //printf("\t运算符出栈2:%s\n", w.name);/////////////////////////////////
     
843.                                                         CALC_simple(w, &nStack);
     
844.                                                 }
     
845.                                                 OPop(&oStack);//直到遇到左括号将左括号出栈
     
846.                                         }
     
847.                                         else if (y.number == 22){
     
848.                                                 intFunParCount++;
     
849.                                         }
     
850.                                 }
     
851.                         }
     
852.                         else{
     
853.                                 continue;
     
854.                         }
     
855.                 }
     
856.         }
     
857.         while (OPeek(&oStack).level != 0){//表达式结束后对栈进行操作直到栈空
     
858.                 if (OPeek(&oStack).level == -1){//如果有为用掉的左括号则报错退出程序
     
859.                         Error(SyntaxError);
     
860.                         return 0;
     
861.                 }
     
862.                 //printf("\t\t运算符1:%s\n",OPeek(&oStack).name);/////////////////////////////////
     
863.                 w = OPop(&oStack);//取出两个数和一个符进行计算
     
864.                 //printf("\t运算符出栈3:%s\n",w.name);/////////////////////////////////
     
865.                 CALC_simple(w, &nStack);
     
866.                 intFunParCount = 0;
     
867.         }
     
868.         Answ = NPop(&nStack);
     
869.         //constants[3].value = Answ;
     
870.         return Answ;
     
871. }
     
872. ///////////////////////////////
     
873. //功能
     
874. //角度弧度梯度制转换
     
875. inline void ChangeScaleEnv(int x){
     
876.         if (x == 0)
     
877.                 degScale = S_Rad;
     
878.         else if (x == 2)
     
879.                 degScale = S_Deg;
     
880.         else
     
881.                 degScale = S_Gra;
     
882. }
     
883. //Preprocesser Debugger
     
884. char *InputScanner(char *exp){
     
885.         srand((int)time(NULL));
     
886.         register int i = 0, j = 0, z = 0, h = 0;//循环计数器
     
887.         //初始化
     
888.         //InitOperTable();
     
889.         //InitConstTable();
     
890.         constants[4].value = rand();
     
891.         if (InitConstTable) constants[3].value = Answ;
     
892. 
     
893.         char sTmpOpr[S_OPR_MAX] = { 0 };//用于[运算符整合]临时变量
     
894.         char cTmpDblChar[2] = { 0, 0 };//临时存放单个字符
     
895.         register int iWhichOpr = 0;//记录运算符返回值
     
896.         //int iWhichCst = 0;//记录常数
     
897.         OTYPE y; bool bEnvIsTrue = false; CONSTANT c;
     
898.         int absCtrAll = 0;//记录"|"的总数
     
899. 
     
900.         char tStr[N] = { '\0' }, ttStr[N] = { '\0' }, ttStrB[N] = { '\0' };
     
901.         for (i = 0; i <= strlen(exp); i++){
     
902.                 if (exp[i] == ' ')//跳过空格
     
903.                         continue;
     
904.                 if (exp[i] >= 'a'&&exp[i] <= 'z'){
     
905.                         tStr[j] = exp[i] - 32;
     
906.                 }
     
907.                 else{
     
908.                         tStr[j] = exp[i];
     
909.                 }
     
910.                 if (exp[i] == '|')
     
911.                         absCtrAll++;
     
912.                 j++;
     
913.         }
     
914.         tStr[j + 1] = '\0';
     
915.         strcpy(ttStr, tStr);
     
916.         //处理绝对值 将|-1|转换为ABS(-1)
     
917.         if (absCtrAll % 2 != 0){
     
918.                 Error(SyntaxError);
     
919.                 return "";
     
920.         }
     
921.         for (i = 0; i <= strlen(tStr); i++){
     
922.                 if (tStr[i] == '|'){
     
923.                         if (h < absCtrAll / 2){
     
924.                                 z = 0;
     
925.                                 strcpy(ttStr, Mid(tStr, 1, i));
     
926.                                 strcpy(ttStrB, Mid(tStr, i + 2));
     
927.                                 tStr[0] = '\0';
     
928.                                 strcat(tStr, ttStr);
     
929.                                 strcat(tStr, "ABS(");
     
930.                                 strcat(tStr, ttStrB);
     
931.                                 //printf("\t%s\n", tStr);//////////////////
     
932.                                 h++;
     
933.                         }
     
934.                         else
     
935.                                 tStr[i] = ')';
     
936.                 }
     
937.         }
     
938.         /*
     
939.         for (i = 0; i <= strlen(tStr); i++)
     
940.         if (tStr[i] == '|')
     
941.         tStr[i] = ')';
     
942.         */
     
943.         //
     
944.         i = 0; j = 0; z = 0; h = 0;
     
945.         ttStr[0] = '\0'; ttStrB[0] = '\0';
     
946.         //将减法转换为加法 a-b == a+-b
     
947.         for (i = 0; i <= strlen(tStr); i++){
     
948.                 if ((tStr[0] != NULL) && (i >= 1) && ((tStr[i - 1] >= '0'&&tStr[i - 1] <= '9' || tStr[i - 1] == ')') && (tStr[i] == '-') && ((tStr[i + 1] >= '0'&&tStr[i + 1] <= '9') || tStr[i + 1] == '.' || tStr[i + 1] == '('))){
     
949.                         z = 0;
     
950.                         ttStr[i] = '+';
     
951.                         for (z = i; z <= strlen(tStr); z++)
     
952.                                 ttStr[z + 1] = tStr[z];
     
953.                         ttStr[z + 1] = '\0';
     
954.                         for (z = 0; z <= strlen(ttStr); z++)
     
955.                                 tStr[z] = ttStr[z];
     
956.                         i++;
     
957.                 }
     
958.         }
     
959.         //将+-()转换为+-1*()
     
960.         for (i = 0; i <= strlen(tStr); i++){
     
961.                 if ((tStr[0] != NULL) && (tStr[i - 1] == '-' && (tStr[i] == '(' || (tStr[i] >= 'a'&&tStr[i] <= 'z' || tStr[i] >= 'A'&&tStr[i] <= 'Z')))){
     
962.                         z = 0;
     
963.                         for (z = 0; z < i; z++)
     
964.                                 ttStr[z] = tStr[z];
     
965.                         ttStr[z] = '1';
     
966.                         ttStr[++z] = '*';
     
967.                         for (z = i + 2; tStr[z - 2] != NULL; z++)
     
968.                                 ttStr[z] = tStr[z - 2];
     
969.                         strcpy(tStr, ttStr);
     
970.                         i += 2;
     
971.                 }
     
972.         }
     
973.         //printf("1 hello!!\n");//////////////////////////////////////
     
974.         //将:2sin变成2*sin
     
975.         for (i = 0; i <= strlen(tStr); i++){
     
976.                 if ((tStr[i] >= '0'&&tStr[i] <= '9') || tStr[i] == '-' || tStr[i] == '.'){//区分操作数和运算符
     
977.                         bEnvIsTrue = true;
     
978.                         sTmpOpr[0] = '\0';///////////////////////////WARNING!!!
     
979.                 }
     
980.                 else{
     
981.                         cTmpDblChar[0] = tStr[i];
     
982.                         strcat(sTmpOpr, cTmpDblChar);
     
983.                         if (iWhichOpr = IsOper(sTmpOpr)){
     
984.                                 y = oper[iWhichOpr];
     
985.                                 sTmpOpr[0] = '\0';
     
986.                                 if ((y.ctype == FrontCalOpr || y.ctype == Functio) && bEnvIsTrue){
     
987.                                         z = 0;
     
988.                                         ttStr[i - strlen(y.name) + 1] = '*';
     
989.                                         for (z = i - strlen(y.name) + 1; z <= strlen(tStr); z++)
     
990.                                                 ttStr[z + 1] = tStr[z];
     
991.                                         ttStr[z + 1] = '\0';
     
992.                                         for (z = 0; z <= strlen(ttStr); z++)
     
993.                                                 tStr[z] = ttStr[z];
     
994.                                         i++;
     
995.                                 }
     
996.                                 bEnvIsTrue = false;
     
997.                         }
     
998.                 }
     
999.         }
     
1000.         //printf("2 hello!!\n");//////////////////////////////////////
      
1001. 
      
1002.         //printf("3 hello!!\n");//////////////////////////////////////
      
1003.         //将2pi转换成2*pi
      
1004.         bEnvIsTrue = false; sTmpOpr[0] = '\0';
      
1005.         for (i = 0; i <= strlen(tStr); i++){
      
1006.                 if ((tStr[i] >= '0'&&tStr[i] <= '9') || tStr[i] == '-' || tStr[i] == '.'){//区分操作数和运算符
      
1007.                         bEnvIsTrue = true;
      
1008.                         sTmpOpr[0] = '\0';
      
1009.                 }
      
1010.                 else{
      
1011.                         //printf("hello\n");///////////////////////////
      
1012.                         cTmpDblChar[0] = tStr[i];
      
1013.                         strcat(sTmpOpr, cTmpDblChar);
      
1014.                         //printf("%s\n",sTmpOpr);////////////////////////////
      
1015.                         if (iWhichOpr = IsConst(sTmpOpr)){
      
1016.                                 //printf("hello\n");///////////////////////////
      
1017.                                 c = constants[iWhichOpr];
      
1018.                                 sTmpOpr[0] = '\0';
      
1019.                                 if (bEnvIsTrue){
      
1020.                                         /*
      
1021.                                         z = 0;
      
1022.                                         ttStr[i - strlen(c.name) + 1] = '*';
      
1023.                                         for (z = i - strlen(c.name) + 1; z <= strlen(tStr); z++)
      
1024.                                         ttStr[z + 1] = tStr[z];
      
1025.                                         ttStr[z + 1] = '\0';
      
1026.                                         for (z = 0; z <= strlen(ttStr); z++)
      
1027.                                         tStr[z] = ttStr[z];
      
1028.                                         i++;
      
1029.                                         */
      
1030.                                         strcpy(ttStr, Mid(tStr, 1, i - strlen(c.name) + 1));
      
1031.                                         //printf("A\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1032.                                         strcat(ttStr, "*");
      
1033.                                         //printf("B\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1034.                                         //printf("BA\tttStr %s\n", Mid(tStr, i)); system("pause");////////////////////////////////////
      
1035.                                         strcat(ttStr, Mid(tStr, i));
      
1036.                                         //printf("C\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1037.                                         i = i - strlen(c.name) + 1;
      
1038.                                         strcpy(tStr, ttStr);
      
1039.                                 }
      
1040.                                 bEnvIsTrue = false;
      
1041.                         }
      
1042.                 }
      
1043.         }
      
1044.         //printf("\t"%s"\n", tStr);/////////////////////////////////////////////////////////
      
1045.         //
      
1046. 
      
1047.         //printf("::::%s\n", tStr);/////////////////////////////////////////////////////i <= strlen(tStr)
      
1048.         //将函数参数替换成数值
      
1049.         sTmpOpr[0] = '\0'; bEnvIsTrue = true;
      
1050.         for (i = 0; i <= strlen(tStr); i++){
      
1051.                 if ((tStr[i] >= '0'&&tStr[i] <= '9') || tStr[i] == '-' || tStr[i] == '.'){//区分操作数和运算符
      
1052.                         //bEnvIsTrue = true;
      
1053.                         sTmpOpr[0] = '\0';
      
1054.                 }
      
1055.                 else{
      
1056.                         //printf("tstr %s\n", tStr);
      
1057.                         //printf("i==%d\n", i);///////////////////////////////////////////////////////////////////////
      
1058.                         //printf("\t%c\n",tStr[i]);////////////////////////////////////////////
      
1059.                         //if ((tStr[i] >= 'A') && (tStr[i] <= 'Z')){//区分操作数和运算符
      
1060.                         //printf("1A,%d====%s\n", i, sTmpOpr);///////////////////////////////////////////
      
1061.                         cTmpDblChar[0] = tStr[i];
      
1062.                         //if (cTmpDblChar[0] >= '0' || cTmpDblChar[0] <= '9')sTmpOpr[0] = '\0';///////////////////////////////////////////
      
1063.                         strcat(sTmpOpr, cTmpDblChar);
      
1064.                         //printf("XX %s\n",sTmpOpr);///////////////////////////////////////////////////////////
      
1065.                         //printf("IsPara %d\n", IsPara(sTmpOpr));////////////////////////////////////////////////
      
1066.                         //printf("\t\tEnv %d\n", bEnvIsTrue);/////////////////////////////////////////////////////
      
1067.                         //if (strcmp(sTmpOpr, "PI") == 0) printf("ok\n");
      
1068.                         if (IsOper(sTmpOpr)){
      
1069.                                 sTmpOpr[0] = '\0';
      
1070.                                 bEnvIsTrue = true;
      
1071.                         }
      
1072.                         else if ((iWhichOpr = IsConst(sTmpOpr)) && bEnvIsTrue){
      
1073.                                 //printf("sTmpOpr \'%s\'\n", sTmpOpr);//////////////////////////////////////////////////显示字符串
      
1074.                                 sTmpOpr[0] = '\0';
      
1075.                                 bEnvIsTrue = false;
      
1076.                                 c = constants[iWhichOpr];
      
1077.                                 //printf("替换hello\n");
      
1078.                                 printf("替换 %s\n",c.name);
      
1079.                                 strcpy(ttStr, Mid(tStr, 1, i - strlen(c.name) + 1));
      
1080.                                 //printf("A\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1081.                                 j = sprintf(ttStrB, "%.16f", c.value);
      
1082.                                 strcat(ttStr, ttStrB);
      
1083.                                 //printf("B\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1084.                                 strcat(ttStr, Mid(tStr, i + strlen(c.name)));
      
1085.                                 //printf("C\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1086.                                 i = i - strlen(c.name) + j;
      
1087.                                 strcpy(tStr, ttStr);
      
1088. 
      
1089.                                 //printf("tStr %s\n", tStr);
      
1090.                                 //printf("i %d\n", i + strlen(c.name)+j);
      
1091.                                 //i += (j + (i - (strlen(c.name) + 1)));
      
1092.                                 //i += strlen(c.name) + j;
      
1093.                         }
      
1094.                 }
      
1095.         }
      
1096.         //将函数参数替换成数值B
      
1097.         sTmpOpr[0] = '\0'; bEnvIsTrue = true;
      
1098.         for (i = 0; i <= strlen(tStr); i++){
      
1099.                 if ((tStr[i] >= '0'&&tStr[i] <= '9') || tStr[i] == '-' || tStr[i] == '.'){//区分操作数和运算符
      
1100.                         sTmpOpr[0] = '\0';
      
1101.                 }
      
1102.                 else{
      
1103.                         cTmpDblChar[0] = tStr[i];
      
1104.                         strcat(sTmpOpr, cTmpDblChar);
      
1105. 
      
1106.                         if (IsOper(sTmpOpr)){
      
1107.                                 sTmpOpr[0] = '\0';
      
1108.                                 bEnvIsTrue = true;
      
1109.                         }
      
1110.                         else if ((iWhichOpr = IsPara(sTmpOpr)) && bEnvIsTrue){
      
1111.                                 sTmpOpr[0] = '\0';
      
1112.                                 bEnvIsTrue = false;
      
1113.                                 c = functpara[iWhichOpr];
      
1114. 
      
1115.                                 strcpy(ttStr, Mid(tStr, 1, i - strlen(c.name) + 1));
      
1116.                                 //printf("A\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1117.                                 j = sprintf(ttStrB, "%.16f", c.value);
      
1118.                                 strcat(ttStr, ttStrB);
      
1119.                                 //printf("B\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1120.                                 strcat(ttStr, Mid(tStr, i + strlen(c.name)));
      
1121.                                 //printf("C\tttStr %s\n", ttStr); system("pause");////////////////////////////////////
      
1122.                                 i = i - strlen(c.name) + j;
      
1123.                                 strcpy(tStr, ttStr);
      
1124.                         }
      
1125.                 }
      
1126.         }
      
1127.         return tStr;
      
1128. }
      
1129. ///////////////////////////////
      
1130. void Debug_Print_Para(void){
      
1131.         int i = 0;
      
1132.         for (i = 0; i <= CST_CTR + iUserCnt; i++){
      
1133.                 //printf("参数:"%s"\n", para[i]);////////////////////////////////////////
      
1134.                 //printf("参数:"%s"\n", para[i]);////////////////////////////////////////
      
1135.                 //printf("\t%s %f\n", functpara[i].name, functpara[i].value);
      
1136.                 printf("\t%s\n", constants[i].name);
      
1137.                 //iParCtr++;
      
1138.         }
      
1139. }
      
1140. //主函数
      
1141. void PrintTitle(void){
      
1142.         printf("Calculation Engine Kernel Alpha\n");
      
1143.         printf("Copyright (C) 2014 Ctechnology Corporation & TZR Lab.\n");
      
1144.         printf("All Rights Resaved.\n");
      
1145. }
      
1146. int main(){
      
1147.         //////freopen("C:\\Users\\Cosh Cage\\Desktop\\t.txt","r",stdin);
      
1148.         //////char* a="16.714+56";
      
1149.         InitOperTable();
      
1150.         InitConstTable();
      
1151.         InitParaTable();
      
1152. 
      
1153.         char a[N] = { 0 };
      
1154.         //Debug_Print_Para();
      
1155.         AddConstant("ZZZ", 3.0);
      
1156.         //Debug_Print_Para();
      
1157.         char par[10][M] = { '\0' };
      
1158.         strcat(par[0], "AA");
      
1159.         strcat(par[1], "BB");
      
1160.         strcat(par[2], "CC");
      
1161. 
      
1162.         AddFunc("SSUM", par, "AA+BB+CC");
      
1163. 
      
1164.         //printf("??%d\n", IsConst("ZZ"));//////////////////////////////////
      
1165.         //printf("!! %s\n", constants[5].name);/////////////////////////////////////////////
      
1166.         //ClearAllFunc();
      
1167.         //printf("Calculation Engine Kernel Alpha\n");
      
1168.         //printf("Copyright (C) 2014 Ctechnology Corporation & TZR Lab.\n");
      
1169.         //printf("All Rights Resaved.\n");
      
1170.         /*
      
1171.         do{
      
1172.         printf("?"); gets(a);
      
1173.         //////////std::cin >> a;
      
1174.         strcpy(a, InputScanner(a));
      
1175.         printf("%s\n", a);
      
1176.         printf("ANS=%f\n", CALC_main(a));
      
1177.         } while (a[0] != NULL);
      
1178.         */
      
1179.         //15+6-8/2*5\n3+8*6-13\n9-2*3*3+8-6+5
      
1180.         //printf("2*(1+2)\n");
      
1181.         //printf("9-2-6\n");
      
1182.         //8+2-(7-4)*2//3+2*(5-2)-4//3+4-(6+2)*2
      
1183.         /////////////////////InitConstTable();
      
1184.         //////////////////////printf("%d\n", IsConst("PIP\0"));//////////////////
      
1185. 
      
1186.         //strcpy(a, InputScanner("zz+1"));
      
1187.         //printf(""%s"\n", a);
      
1188.         //printf("ANS=%f\n", CALC_main(a));
      
1189. 
      
1190.         //Debug_Print_Para();
      
1191.         //printf("IsPara %d\n", IsPara("AA"));////////////////////////////////////////////////
      
1192.         //printf("\n");
      
1193.         //printf("End:%s\n", InputScanner("AA+BB+CC"));
      
1194. 
      
1195.         //system("Pause");
      
1196. 
      
1197.         int i = 0; double localAns;
      
1198.         char *fn; char str[M];
      
1199.         PrintTitle();
      
1200.         do{
      
1201.                 printf("?"); gets(a);
      
1202.                 if (strcmp(strupr(a), "ADDFUN") == 0){
      
1203.                         do{
      
1204.                                 printf("\tFunction Name?"); gets(a);
      
1205.                                 fn = a;
      
1206.                                 for (i = 0; i < 10; i++){
      
1207.                                         printf("\tFunction Parament?"); gets(a);
      
1208.                                         if (a[0] == '\0'){
      
1209.                                                 break;
      
1210.                                         }
      
1211.                                         else{
      
1212.                                                 strcat(par[0], a);
      
1213.                                         }
      
1214.                                 }
      
1215.                                 printf("\tFunction Expression?"); gets(a);
      
1216.                                 AddFunc(fn, par, a); printf("\tAdded OK!\n");
      
1217.                                 printf("\tFunction Name?"); gets(a);
      
1218.                         } while (a[0] != NULL);
      
1219.                         printf("?"); gets(a);
      
1220.                 }
      
1221.                 else if (strcmp(strupr(a), "ADDVAR") == 0){
      
1222.                         do{
      
1223.                                 printf("\tVar Name?"); gets(a);
      
1224.                                 fn = a;
      
1225.                                 printf("\tVar Value?"); gets(a);
      
1226.                                 AddConstant(fn, atof(a)); printf("\tAdded OK!\n");
      
1227.                                 printf("\tVar Name?"); gets(a);
      
1228.                         } while (a[0] != NULL);
      
1229.                         printf("?"); gets(a);
      
1230.                 }
      
1231.                 else if (strcmp(strupr(a), "DELALLFUN") == 0){
      
1232.                         ClearAllFunc(); printf("Done!\n");
      
1233.                         printf("?"); gets(a);
      
1234.                 }
      
1235.                 else if (strcmp(strupr(a), "DELALLVAR") == 0){
      
1236.                         ClearAllConst(); printf("Done!\n");
      
1237.                         printf("?"); gets(a);
      
1238.                 }
      
1239.                 else if (strcmp(strupr(a), "SCALE") == 0){
      
1240.                         do{
      
1241.                                 printf("\t\t0:Rad\n\t\t2:Deg\n\t\tAny:Gra\n\tScale?"); gets(a);
      
1242.                                 ChangeScaleEnv(atoi(a));
      
1243.                         } while (a[0] != NULL);
      
1244.                         printf("?"); gets(a);
      
1245.                 }
      
1246.                 else if (strcmp(strupr(a), "CLS") == 0){
      
1247.                         system("cls");
      
1248.                         PrintTitle();
      
1249.                 }
      
1250.                 else{
      
1251.                         //////////std::cin >> a;
      
1252.                         strcpy(a, InputScanner(a));
      
1253.                         localAns = CALC_main(a);
      
1254.                         //printf("%s\n", a);
      
1255.                         str[0] = '\0';
      
1256.                         if (ERR_NUM != NoError){
      
1257.                                 for (i = 1; i <= ix - 2; i++){
      
1258.                                         strcat(str, " ");
      
1259.                                 }
      
1260.                                 strcat(str, "^\n");
      
1261.                                 if (ERR_NUM == MathError){
      
1262.                                         strcat(str, "MathError!");
      
1263.                                 }
      
1264.                                 else if (ERR_NUM == StackError){
      
1265.                                         strcat(str, "StackError!");
      
1266.                                 }
      
1267.                                 else if (ERR_NUM == SyntaxError){
      
1268.                                         strcat(str, "SyntaxError!");
      
1269.                                 }
      
1270.                                 else if (ERR_NUM == UnknownError){
      
1271.                                         strcat(str, "UnknownError!");
      
1272.                                 }
      
1273.                                 printf("%s\n", a);
      
1274.                                 printf("%s\n", str);
      
1275.                         }
      
1276.                         printf("ANS=%f\n", localAns);
      
1277.                 }
      
1278.         } while (a[0] != NULL);
      
1279. 
      
1280.         return 0;
      
1281. }
      
1282. //////////END///////////////////

复制代码

cyycoish

天哪，上边怎么回事？我的代码呢！？

cyycoish

calengknl.zip (9.43 KB, 下载次数: 6)

2014-11-18 22:55 上传

点击文件名下载附件

0xAA55

哈哈 这个好