找回密码
 欢迎注册
楼主: 落叶

[原创] 落叶高精度表达式计算器v1.0版

[复制链接]
发表于 2017-1-7 19:39:05 | 显示全部楼层
本帖最后由 happysxyf 于 2017-1-7 20:20 编辑
落叶 发表于 2017-1-7 17:17
那个绘图就没办法了,那需要团队合作,我既使免强做出一点,也会画虎不成反类猫,个人开发,只能专而精, ...


全部原创,那个代码除了C语言是别人发明的,所有代码均为自己原创。因为别人写的代码都效率非常低下,连库函数atof也是那么慢,所以我自己写的atof使得速度提高2倍。
还有函数绘图,我也实现了,只是没有整理,目前只能绘制平面函数的图,3维空间的函数,我还在继续写矩阵视角算法。最后我要实现能画3维曲线才行,并且是动态的旋转、缩放。全部C语言调用GDI plus库实现,由于总代码达到3万行,只贴出部分代码。3d绘图的算法非常复杂,还在继续优化中。说白了就是自己实现的3D绘图引擎。本来可以调用openGL,但是我想自己实现。

部分代码
  1. //图形旋转
  2. int RotateDC(HDC hDC, int angle)  
  3. {
  4.         if(angle==0){return 1;}
  5.         XFORM Matrix;
  6.         double rad =-angle * 0.017453292519943;
  7.         Matrix.eM11 = (float)cos(rad);  
  8.         Matrix.eM12 = (float)sin(rad);  
  9.         Matrix.eM21 =-(float)sin(rad);
  10.         Matrix.eM22 = (float)cos(rad);  
  11.         Matrix.eDx  = (float)(GLOBAL_VALUE[0]-cos(rad)*GLOBAL_VALUE[0]+sin(rad)*GLOBAL_VALUE[1]);  
  12.         Matrix.eDy  = (float)(GLOBAL_VALUE[1]-cos(rad)*GLOBAL_VALUE[1]-sin(rad)*GLOBAL_VALUE[0]);
  13.         SetGraphicsMode(hDC, GM_ADVANCED);
  14.         SetWorldTransform(hDC, &Matrix);
  15.         return 0;
  16. }
复制代码


  1. //计算含变量表达式函数
  2. float EvalLine(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  3. {
  4.         memset(cacheTain, 0, 1024);
  5.         char* op=cacheTain;
  6.         char* cp=(char*)exp;
  7.         char* Line_Cache=op;
  8.         int   i=-1;
  9.        
  10.         while(!isEND(*cp, " \t\r\n\0")){

  11.                 if(!isEND(*cp, ":$ \t\r\n\0")){
  12.                         *(op++)=*(cp++);
  13.                         continue;
  14.                 }

  15.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  16.                         char* tmp=VALUE[i];
  17.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  18.                         cp+=strlen(WORDS[i]);                       

  19.                 }else if((*cp==') && (i=Identify_KeyWords(cp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, endstring))!=-1){
  20.                        
  21.                         //准备临时容器
  22.                         char* tmp=(char*)calloc(16, sizeof(char));
  23.                         //解析变量名
  24.                         switch(i){
  25.                         case 16:
  26.                                 strcpy(tmp, "3.14159");
  27.                                 break;
  28.                         case 17:
  29.                                 itoa(rand(), tmp, 10);
  30.                                 break;
  31.                         case 19:
  32.                         case 20:
  33.                         case 21:
  34.                         case 22:
  35.                         case 23:
  36.                         case 24:
  37.                                 itoa(getTIME(i), tmp, 10);
  38.                                 break;
  39.                         default:       
  40.                                 itoa(GLOBAL_VALUE[i], tmp, 10);
  41.                                 break;
  42.                         }

  43.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  44.                         free(tmp);
  45.                         cp+=GLOBAL_LLENS[i];
  46.                 }
  47.         }
  48.         return CalculateExpression(Line_Cache);
  49. }
  50. //赋值函数
  51. BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  52. {
  53.         char *gp=(char*)exp, *cp=gp;
  54.         while(!isEND(*cp, "=")){
  55.                 cp++;
  56.         }
  57.         cp++;

  58.         int i=-1;
  59.         if(gp[0]==':'){
  60.                 if(gp[1]==':'){return TRUE;}
  61.                 i=Identify_KeyWords(gp, PRO_NUM, WORDS, " \t=");
  62.                 itoa(EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring), VALUE[i], 10);
  63.         }else if(gp[0]=='){
  64.                 i=Identify_KeyWords(gp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, " \t=");
  65.                 GLOBAL_VALUE[i]=EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring);

  66.                 switch(i){
  67.                 case  3:
  68.                         GLOBAL_VALUE[3]=(GLOBAL_VALUE[3]>=0) ?(int)GLOBAL_VALUE[3]%16 :16+(int)GLOBAL_VALUE[3]%16;
  69.                         char* tmp=(char*)calloc(16, sizeof(char));
  70.                         sprintf(tmp, "color %xF", GLOBAL_VALUE[3]);
  71.                         system(tmp);
  72.                         free(tmp);
  73.                         break;
  74.                 case  4:
  75.                         if(GLOBAL_VALUE[4]<0){GLOBAL_VALUE[4]=-GLOBAL_VALUE[4];}
  76.                         break;
  77.                 case  5:
  78.                         GLOBAL_VALUE[5]=(GLOBAL_VALUE[5]>=0) ?(int)GLOBAL_VALUE[5]%16 :360+(int)GLOBAL_VALUE[5]%16;
  79.                         break;
  80.                 case 18:
  81.                         GLOBAL_VALUE[18]=(GLOBAL_VALUE[18]>=0) ?(int)GLOBAL_VALUE[18]%6 :(0-(int)GLOBAL_VALUE[18])%6;
  82.                         break;
  83.                 case 25:
  84.                         GLOBAL_VALUE[25]=(GLOBAL_VALUE[25]>=0) ?(int)GLOBAL_VALUE[25]%255 :(0-(int)GLOBAL_VALUE[25])%255;
  85.                         break;
  86.                 default:
  87.                         break;
  88.                 }

  89.                
  90.         }
  91.         return TRUE;
  92. }
  93. //批量赋值
  94. BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  95. {
  96.         char *gp=(char*)Line;
  97.         while(isEND(*gp, ":$")){
  98.                 AssignMent(gp, PRO_NUM, WORDS, VALUE, endstring);
  99.                 gp++;
  100.                 while(!isEND(*gp, " \t\0")){
  101.                         gp++;
  102.                 }
  103.                 while(!isEND(*gp, ":$\0")){gp++;}
  104.                 if(*gp=='\0'){return TRUE;}
  105.         }
  106.         return TRUE;
  107. }
  108. //测FOR循环
  109. inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, int CYC)
  110. {
  111.         if(CYC ==0){return TRUE;}
  112.         int i=-1;
  113.         if((i=Identify_KeyWords(strtok((char*)Line, " "), PRO_NUM, WORDS, " \t")) !=-1){
  114.                 int staNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  115.                 int endNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  116.                 int var   =atoi(VALUE[i]);
  117.                 if(staNUM-endNUM<0){return (var<=endNUM)?TRUE:FALSE;}
  118.                 return (var>=endNUM)?TRUE:FALSE;
  119.         }
  120.         return FALSE;
  121. }
  122. //真值条件判断
  123. BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  124. {
  125.         memset(cacheTain, 0, 1024);
  126.         char* op=cacheTain;
  127.         char* cp=(char*)exp;

  128.         //过滤行TAB缩进或空格
  129.         while(*cp=='\t'|| *cp==' '){cp++;}

  130.         if(isEND(*cp, "\r\n\0")){
  131.                 return TRUE;
  132.         }

  133.         char* Line_Cache=op;
  134.         int   i=-1, flag=0;

  135.         while(!isEND(*cp, " \t\r\n\0")){
  136.                 if      (*cp=='>'){
  137.                         flag+=4;
  138.                         *(op++)='-';
  139.                         *(op++)='(';
  140.                         cp++;
  141.                         continue;

  142.                 }else if(*cp=='<'){
  143.                         flag+=2;
  144.                         *(op++)='-';
  145.                         *(op++)='(';
  146.                         cp++;
  147.                         continue;

  148.                 }else if(*cp=='='){
  149.                         flag+=1;
  150.                         if(flag==1){
  151.                                 *(op++)='-';
  152.                                 *(op++)='(';
  153.                         }
  154.                         cp++;
  155.                         continue;

  156.                 }else if(*cp!=':'&& *cp!='){
  157.                         *(op++)=*(cp++);
  158.                         continue;
  159.                 }

  160.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  161.                         char* tmp=VALUE[i];
  162.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  163.                         cp+=strlen(WORDS[i]);                       

  164.                 }else if((*cp==') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  165.                         char* tmp=(char*)calloc(16, sizeof(char));
  166.                         if(i==16){
  167.                                 strcpy(tmp, "3.141592653590");
  168.                         }else if(i==17){
  169.                                 itoa(rand(), tmp, 10);
  170.                         }else{
  171.                                 itoa(GLOBAL_VALUE[i], tmp, 10);
  172.                         }
  173.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  174.                         cp+=GLOBAL_LLENS[i];
  175.                 }else{
  176.                         return FALSE;
  177.                 }

  178.         }
  179.         *(op++)=')';
  180.         int m=(int)CalculateExpression(Line_Cache);

  181.         if(
  182.                 (m >0 && (flag==4||flag==5         )) ||
  183.                 (m <0 && (flag==2||flag==3         )) ||
  184.                 (m==0 && (flag==1||flag==3||flag==5||flag==0))
  185.         ){
  186.                 return TRUE;
  187.         }
  188.         return FALSE;
  189. }
  190. //批量真值判断
  191. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  192. {
  193.         char *gp=(char*)Line;
  194.         int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
  195.         if(li !=-1){gp+=LGC_LLENS[li];}

  196.         do{
  197.                 while(isEND(*gp, " \t")){
  198.                         gp++;
  199.                 }
  200.                 if(JudgMent(gp, PRO_NUM, WORDS, VALUE, endstring)){

  201.                         switch(li){
  202.                         case 0:
  203.                                 return FALSE;
  204.                         case 1:
  205.                                 break;
  206.                         case 2:
  207.                                 return TRUE;
  208.                         default:
  209.                                 return TRUE;
  210.                         }
  211.                 }else{
  212.                         switch(li){
  213.                         case 0:
  214.                                 break;
  215.                         case 1:
  216.                                 return FALSE;
  217.                         case 2:
  218.                                 break;
  219.                         default:
  220.                                 return FALSE;
  221.                         }
  222.                 }
  223.                 while(!isEND(*gp, " \t\0"  )){gp++;}
  224.                 if(*gp=='\0'){return TRUE;}
  225.                 while( isEND(*gp, " \t\r\n")){gp++;}

  226.         }while(*gp !='\0');
  227. }

  228. /***************绘图函数群***************/
  229. //平滑画线函数,C++连接库
  230. void drawSMOOTHLINE(HDC hDC, int penWith, int mode, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2);
  231. //封闭区域填充函数,C++连接库
  232. void fillAREA(HDC hDC, BYTE alpha, STRGB* penRGB, float fill_X, float fill_Y);
  233. //快速画线函数
  234. BOOL drawLINE(HDC hDC, int d)
  235. {
  236.         float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
  237.         GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  238.         GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  239.         if(!penMODE){
  240.                 return FALSE;
  241.         }
  242.         STRGB* penRGB=&LRGB[(int)GLOBAL_VALUE[5]];
  243.         drawSMOOTHLINE(hDC, (int)GLOBAL_VALUE[4], (int)GLOBAL_VALUE[18], (int)GLOBAL_VALUE[25], penRGB, x1, y1, GLOBAL_VALUE[0], GLOBAL_VALUE[1]);
  244.         return TRUE;
复制代码
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2017-1-8 18:28:26 | 显示全部楼层
本帖最后由 happysxyf 于 2017-1-8 18:47 编辑

arm版
下载: revpolish

安卓版
3.png
下载: revpolish.apk

点评

把你的程序在手机上测试了一下,用起来还不错,程序可以很好的独立运行,表达式解析也正确。  发表于 2017-1-10 18:45
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2017-1-8 19:14:34 | 显示全部楼层
定义函数我也有了一个大致的思路,不过只支持可以用表达式表示的函数,不知道实用价值怎么样?
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
 楼主| 发表于 2017-1-8 19:18:43 | 显示全部楼层
本帖最后由 落叶 于 2017-1-8 20:04 编辑

安卓版你是用专用编译器编译的吗?
你说你的加减乘除都写好了,你想过把加减法乘除加上小数,指数功能吗?虽然网上对大数加减乘除有了很多论述,实例,但我还没查到加上了这两个功能的实例源码,这个是大数综合运算需要的基础。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2017-1-11 23:19:26 | 显示全部楼层
落叶 发表于 2017-1-8 19:18
安卓版你是用专用编译器编译的吗?
你说你的加减乘除都写好了,你想过把加减法乘除加上小数,指数功能吗? ...

我的在手机上是用的手机的那个C4droid编译器编译的
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2017-1-11 23:19:37 | 显示全部楼层
落叶 发表于 2017-1-8 19:18
安卓版你是用专用编译器编译的吗?
你说你的加减乘除都写好了,你想过把加减法乘除加上小数,指数功能吗? ...


我的在手机上是用的手机的那个C4droid编译器编译的,手机上的体验很好,基本上能取代自带的安卓计算器。因为这是表达式计算,速度也快。
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
发表于 2017-1-11 23:22:20 | 显示全部楼层
落叶 发表于 2017-1-8 19:14
定义函数我也有了一个大致的思路,不过只支持可以用表达式表示的函数,不知道实用价值怎么样?


再给你个我写的CLGO解释器的代码1300行

  1. /*
  2.         CLGO SCRIPT, COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0
  3.         CLGO.EXE       
  4.         LINK: -lline -L./ -lgdi32 -lgdiplus
  5. */

  6. #include    <stdio.h>
  7. #include   <stdlib.h>
  8. #include   <string.h>
  9. #include    <ctype.h>
  10. #include  <stdbool.h>
  11. #include  <windows.h>
  12. #include   <wincon.h>
  13. #include       <io.h>
  14. #include    <conio.h>
  15. #include     <math.h>
  16. #include     <time.h>
  17. #include   <unistd.h>
  18. #include <gdiplus\gdiplus.h>

  19. /***************定义宏变量***************/
  20. //堆栈尺寸
  21. #define STACK_SIZE         1024
  22. //循环体最大层数
  23. #define LOOP_LEVELS        64
  24. //变量名最大长度
  25. #define MAX_WORDS_SIZE     64
  26. //定义变量值最大长度
  27. #define MAX_VALUE_SIZE     16

  28. //绘图系关键词数
  29. #define KEY_SIZE           20
  30. //循环系关键词数
  31. #define CYC_SIZE           5
  32. //逻辑系关键词
  33. #define LGC_SIZE           3
  34. //全局变量解释数
  35. #define GLOBAL_SIZE        25

  36. /***************全局类变量***************/
  37. //主窗句柄
  38. HWND  hCMD;
  39. HWND  hWND2;
  40. HWND  hWND3;
  41. //主窗区域
  42. RECT  winRECT={0};
  43. LPRECT lrRECT;
  44. //画布句柄
  45. HDC   hDC;
  46. HDC   hDC1;
  47. HDC   hDC2;
  48. HDC   hDC3;

  49. //内存变量
  50. char* tRAM;
  51. //缓存容器
  52. char  cacheTain[1025]={0};
  53. //画线可见,可见即PD,不可见即PU
  54. BOOL  penMODE=TRUE;
  55. //启用内存背景
  56. BOOL  memMODE=FALSE;

  57. /***************关键词类目***************/
  58. //运算符栈
  59. char   STACK1[STACK_SIZE]={0};
  60. //逆波兰栈
  61. char   STACK2[STACK_SIZE]={0};
  62. //浮点数栈
  63. double STACK3[STACK_SIZE]={0};
  64. //数学函数关键词
  65. static const char* MATH_WORDS[]={"e", "pi", "sqrt", "lg", "ln", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "deg", "abs", "round", "floor", "ceil", "exp", "sinh", "cosh", "tanh", "arcsinh", "arccosh", "arctanh", NULL};
  66. //绘图系关键词
  67. static const char* KEY_WORDS[]={"FD", "BK", "LT", "RT", "PU", "PD", "PE", "CLEAN", "ECHO", "HOME", "STOP", "EXIT", "FILL", "PAUSE", "WAIT", "ROTE", "MEMUSE", "MEMSEE", "MEMOUT", "EVAL"};
  68. static const char  KEY_LLENS[]={   2,    2,    2,    2,    2,    2,    2,       5,      4,      4,      4,      4,      4,       5,      4,      4,        6,        6,        6,      4};
  69. //循环系关键词
  70. static const char* CYC_WORDS[]={"IF", "REPEAT", "WHILE", "FOR", "ELIF"};
  71. static const char  CYC_LLENS[]={   2,        6,       5,     3,      4};
  72. //逻辑系关键词
  73. static const char* LGC_WORDS[]={"NOT", "AND", "OR"};
  74. static const char  LGC_LLENS[]={   3,      3,    2};
  75. //定义解释器全局变量
  76. static const char* GLOBAL_WORDS[]={"$PENX", "$PENY", "$HEADING", "$PENB", "$PENW", "$PENC", "$PENS", "$PENA", "$RANDOM", "$YEAR", "$MONTH", "$DAY", "$HOUR", "$MINUTE", "$SECOND", "$TP0", "$TP1", "$TP2", "$TP3", "$TP4", "$TP5", "$TP6", "$TP7", "$TP8", "$TP9"};
  77. static const char  GLOBAL_LLENS[]={      5,       5,          8,       5,       5,       5,       5,       5,         7,       5,        6,      4,       5,         7,         7,      4,      4,      4,      4,      4,      4,      4,      4,      4,      4};
  78.            double  GLOBAL_VALUE[]={      0,       0,          0,       0,       1,       15,      0,     255,         0,       0,        0,      0,       0,         0,         0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0};

  79. /***************申明函数类***************/
  80. HWND    WINAPI GetConsoleWindow();
  81. float   EvalLine(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring);

  82. /***************RGB 结构体***************/
  83. typedef struct{
  84.         BYTE R;
  85.         BYTE G;
  86.         BYTE B;
  87.         COLORREF VALUE;
  88. }STRGB;
  89. //十六色系数组
  90. STRGB LOGO_RGB[16]={
  91.         {  0,  0,  0,RGB(  0,  0,  0)}, //黑色
  92.         {  0,  0,255,RGB(  0,  0,255)}, //蓝色
  93.         {  0,255,  0,RGB(  0,255,  0)}, //绿色
  94.         {  0,255,255,RGB(  0,255,255)}, //青色
  95.         {255,  0,  0,RGB(255,  0,  0)}, //红色
  96.         {238,130,238,RGB(238,130,238)}, //紫兰
  97.         {165, 42, 42,RGB(165, 42, 42)}, //棕色
  98.         {211,211,211,RGB(211,211,211)}, //浅灰
  99.         {169,169,169,RGB(169,169,169)}, //深灰
  100.         {173,216,230,RGB(173,216,230)}, //淡蓝
  101.         {144,238,144,RGB(144,238,144)}, //浅绿
  102.         {224,255,255,RGB(224,255,255)}, //淡青
  103.         {248, 29, 56,RGB(248, 29, 56)}, //亮红
  104.         {255,  0,255,RGB(255,  0,255)}, //洋紫
  105.         {255,255,  0,RGB(255,255,  0)}, //黄色
  106.         {255,255,255,RGB(255,255,255)}  //白色
  107. };

  108. /***************计算函数群***************/
  109. //阶乘函数
  110. long long fact(long long n)
  111. {
  112.         return (n<2) ?1 :n*(fact(n-1));
  113. }
  114. //逆波兰核心
  115. double RevPolishCore(const char* expression)
  116. {
  117.         STACK3[0]=0;
  118.         char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;
  119.         double *S3=STACK3, di, ni;
  120.        
  121.         //生成逆波兰       
  122.         while(*op!='\0'){               
  123.                 switch(*op){
  124.                 case ' ' :
  125.                 case '\t':
  126.                 case '\r':
  127.                 case '\n':
  128.                         //过滤空字符
  129.                         op++;
  130.                         continue;

  131.                 case 'a':
  132.                 case 'b':
  133.                 case 'c':
  134.                 case 'd':
  135.                 case 'e':
  136.                 case 'f':
  137.                 case 'g':
  138.                 case 'h':
  139.                 case 'i':
  140.                 case 'j':
  141.                 case 'k':
  142.                 case 'l':
  143.                 case 'm':
  144.                 case 'n':
  145.                 case 'o':
  146.                 case 'p':
  147.                 case 'q':
  148.                 case 'r':
  149.                 case 's':
  150.                 case 't':
  151.                 case 'u':
  152.                 case 'v':
  153.                 case 'w':
  154.                 case 'x':
  155.                 case 'y':
  156.                 case 'z':
  157.                         //识别数学函数关键词
  158.                         key=(char**)MATH_WORDS;
  159.                         while(*key !=NULL){       
  160.                                 cp=op, kp=*key;
  161.                                 //比对关键词字母
  162.                                 while(*cp==*kp && *kp!='\0'){
  163.                                         cp++, kp++;
  164.                                 }
  165.                                 //验证关键词结尾
  166.                                  if((*cp<'a'||*cp>'z') && (*kp=='\0')){
  167.                                          op=cp;
  168.                                         break;
  169.                                 }
  170.                                 key++;
  171.                         }
  172.                         //构建伪双目
  173.                         if(*key !=NULL){                               
  174.                                 *(S2++)='.';
  175.                                 *(S2++)=' ';
  176.                                 //伪双目入栈
  177.                                 while('A'<=(*S1) && (*S1)<='Z'){
  178.                                         *(S2++)=*(S1--);
  179.                                 }
  180.                                 *(++S1)=key-(char**)MATH_WORDS+65;
  181.                                 continue;
  182.                         }else{
  183.                                 //无法识别的数学函数
  184.                                 fputs("Unrecognized math function\n", stderr);
  185.                                 exit(1);
  186.                         }
  187.                         break;
  188.                
  189.                 case '(':
  190.                         *(++S1)=*op;
  191.                         if(*(op+1)=='-' || *(op+1)=='+'){
  192.                                 *(S2++)='0', *(S2++)=' ';
  193.                         }
  194.                         break;

  195.                 case ')':
  196.                         while(*S1!='(')
  197.                         {
  198.                                 *(S2++)=*(S1--);
  199.                         }               
  200.                         //舍弃'('
  201.                         S1--;               
  202.                         break;

  203.                 case '+':
  204.                 case '-':
  205.                         while(S1!=STACK1 && *S1!='(')
  206.                         {
  207.                                 *(S2++)=*(S1--);
  208.                         }
  209.                         *(++S1)=*op;
  210.                         break;

  211.                 case '^':
  212.                         //指数符
  213.                         while('A'<=(*S1) && (*S1)<='Z')
  214.                         {
  215.                                 *(S2++)=*(S1--);
  216.                         }
  217.                         *(++S1)=*op;
  218.                         break;

  219.                 case '!':
  220.                         //阶乘符
  221.                         *(S2++)=*op;
  222.                         break;

  223.                 case '%':
  224.                 case '*':
  225.                 case '/':
  226.                         while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){
  227.                                 *(S2++)=*(S1--);
  228.                         }
  229.                         *(++S1)=*op;
  230.                         break;

  231.                 default :
  232.                         if((*op<'0' || *op>'9') && (*op!='.')){
  233.                                 //无法识别的运算符
  234.                                 fputs("Unrecognized operator\n", stderr);
  235.                                 exit(1);
  236.                         }
  237.                         //浮点数入栈
  238.                         while(('0'<=*op && *op<='9') ||*op=='.'){
  239.                                 *(S2++)=*(op++);
  240.                         }
  241.                         op--;
  242.                         *(S2++)=' ';
  243.                         break;
  244.                 }
  245.                 op++;
  246.         }
  247.         //收尾逆波兰
  248.         while(S1 !=STACK1){*(S2++)=*(S1--);}
  249.         *S2=' ';

  250.         //计算逆波兰
  251.         op=STACK2;
  252.         while(*op!=' '){
  253.                 switch(*op){
  254.                 case 'A':
  255.                         *S3=2.7182818284590452;
  256.                         break;
  257.                 case 'B':
  258.                         *S3=3.1415926535897932;
  259.                         break;
  260.                 case 'C':
  261.                         if(*S3 <0){
  262.                                 //负数没有平方根
  263.                                 fputs("Negative numbers have no square root\n", stderr);
  264.                                 exit(1);
  265.                         }
  266.                         *(S3-1)=sqrt(*S3);
  267.                         S3--;
  268.                         break;
  269.                 case 'D':
  270.                         if(*S3 <0){
  271.                                 //负数没有对数
  272.                                 fputs("Negative numbers are not logarithmic\n", stderr);
  273.                                 exit(1);
  274.                         }
  275.                         *(S3-1)=log10(*S3);
  276.                         S3--;
  277.                         break;
  278.                 case 'E':
  279.                         if(*S3 <0){
  280.                                 //负数没有自然对数
  281.                                 fputs("Negative numbers have no natural logarithms\n", stderr);
  282.                                 exit(1);
  283.                         }
  284.                         *(S3-1)=log(*S3);
  285.                         S3--;
  286.                         break;
  287.                 case 'F':
  288.                         *(S3-1)=sin(*S3);
  289.                         S3--;
  290.                         break;
  291.                 case 'G':
  292.                         *(S3-1)=cos(*S3);
  293.                         S3--;
  294.                         break;
  295.                 case 'H':
  296.                         if(*S3==3.1415926535897932/2){
  297.                                 //π/2没有正切值
  298.                                 fputs("The pi/2 has no tangent\n", stderr);
  299.                                 exit(1);
  300.                         }
  301.                         *(S3-1)=tan(*S3);
  302.                         S3--;
  303.                         break;
  304.                 case 'I':
  305.                         *(S3-1)=asin(*S3);
  306.                         S3--;
  307.                         break;
  308.                 case 'J':
  309.                         *(S3-1)=acos(*S3);
  310.                         S3--;
  311.                         break;
  312.                 case 'K':
  313.                         *(S3-1)=atan(*S3);
  314.                         S3--;
  315.                         break;
  316.                 case 'L':
  317.                         *(S3-1)=(*S3)*3.1415926535897932/180.0;
  318.                         S3--;
  319.                         break;
  320.                 case 'M':
  321.                         *(S3-1)=(*S3<0)?(-(*S3)):(*S3);
  322.                         S3--;
  323.                         break;
  324.                 case 'N':
  325.                         *(S3-1)=round(*S3);
  326.                         S3--;
  327.                         break;
  328.                 case 'O':
  329.                         *(S3-1)=floor(*S3);
  330.                         S3--;
  331.                         break;
  332.                 case 'P':
  333.                         *(S3-1)=ceil(*S3);
  334.                         S3--;
  335.                         break;
  336.                 case 'Q':
  337.                         *(S3-1)=exp(*S3);
  338.                         S3--;
  339.                         break;
  340.                 case 'R':
  341.                         *(S3-1)=sinh(*S3);
  342.                         S3--;
  343.                         break;
  344.                 case 'S':
  345.                         *(S3-1)=cosh(*S3);
  346.                         S3--;
  347.                         break;
  348.                 case 'T':
  349.                         *(S3-1)=tanh(*S3);
  350.                         S3--;
  351.                         break;
  352.                 case 'U':
  353.                         *(S3-1)=asinh(*S3);
  354.                         S3--;
  355.                         break;
  356.                 case 'V':
  357.                         *(S3-1)=acosh(*S3);
  358.                         S3--;
  359.                         break;
  360.                 case 'W':
  361.                         *(S3-1)=atanh(*S3);
  362.                         S3--;
  363.                         break;
  364.                 case '+':
  365.                         *(S3-1)+=*S3;
  366.                         S3--;
  367.                         break;
  368.                 case '-':
  369.                                        *(S3-1)-=*S3;
  370.                                        S3--;
  371.                         break;
  372.                 case '*':
  373.                         *(S3-1)*=*S3;
  374.                         S3--;
  375.                         break;
  376.                 case '%':
  377.                 case '/':
  378.                         if(*S3 !=0){
  379.                                 if(*op=='%'){
  380.                                         //取余数
  381.                                         *(S3-1)=(int)*(S3-1) % (int)*S3;
  382.                                 }else{
  383.                                         *(S3-1)/=*S3;
  384.                                 }
  385.                                
  386.                         }else{
  387.                                 //除数不能为零
  388.                                 fputs("Divisor is zero error\n", stderr);
  389.                                 exit(1);
  390.                         }
  391.                         S3--;
  392.                         break;
  393.                 case '^':
  394.                         if(*(S3-1)==0 && *S3<0){
  395.                                 //除数不能为零
  396.                                 fputs("Function pow's divisor is zero error\n", stderr);
  397.                                 exit(1);
  398.                         }
  399.                         *(S3-1)=pow(*(S3-1), *S3);
  400.                         S3--;
  401.                         break;
  402.                 case '!':
  403.                         if(*S3 <0){
  404.                                 //负数没有阶乘
  405.                                 fputs("Negative numbers have no factorial\n", stderr);
  406.                                 exit(1);
  407.                         }
  408.                         *S3=fact((long long)(*S3));
  409.                         break;
  410.                 default :
  411.                         //字符串转浮点
  412.                         di=0, ni=1;
  413.                         while('0'<=*op && *op<='9'){
  414.                                 di=10*di+(*op)-'0';
  415.                                 op++;
  416.                         }       
  417.                         if(*op=='.'){
  418.                                 op++;
  419.                                 while('0'<=*op && *op<='9'){
  420.                                         di=10*di+(*op)-'0';
  421.                                         op++, ni*=10;
  422.                                 }       
  423.                         }
  424.                         *(++S3)=di/ni;
  425.                         break;
  426.                 }
  427.                 op++;
  428.         }

  429.         //返回计算结果
  430.         return *S3;
  431. }

  432. /***************辅助函数群***************/
  433. //获取时间
  434. inline int getTIME(int i)
  435. {
  436.         time_t timep;  
  437.         struct tm *p;  
  438.         time(&timep);  
  439.         p=localtime(&timep);

  440.         switch(i){

  441.         case  9:
  442.                 return p->tm_year+1900;
  443.         case 10:
  444.                 return p->tm_mon+1;
  445.         case 11:
  446.                 return p->tm_mday;
  447.         case 12:
  448.                 return p->tm_hour;
  449.         case 13:
  450.                 return p->tm_min;
  451.         case 14:
  452.                 return p->tm_sec;
  453.         default:       
  454.                 return -1;
  455.         }
  456.         return -1;
  457. }
  458. //测空字符
  459. inline BOOL isEND(const char c,const char* endstring)
  460. {
  461.         if(c=='\0'){return TRUE;}
  462.        
  463.         while(*endstring!='\0'){
  464.                 if(c==*(endstring++)){
  465.                         return TRUE;
  466.                 }
  467.         }
  468.         return FALSE;
  469. }
  470. //过滤行TAB缩进或前空格
  471. char* passNULL(char* Str)
  472. {
  473.         if(Str!=NULL){
  474.                 while(*Str=='\t' ||*Str==' '){Str++;}
  475.         }
  476.         return Str;
  477. }
  478. //识别关键字
  479. BOOL isKEY(char* Line, char* key, const char* endstring)
  480. {
  481.         char *op=Line, *kp=key;
  482.         while(*kp!='\0'){
  483.                 if((('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)){break;}
  484.                 op++;kp++;
  485.         }
  486.         if(
  487.                 *kp=='\0' &&
  488.                 isEND(*op, endstring)
  489.         ){
  490.                 return TRUE;
  491.         }                               
  492.         return FALSE;
  493. }
  494. //切分变量名
  495. int ARGS(char* Str, char** WORDS, int PRO_NUM, int LineNUM, char* Line)
  496. {
  497.         if(PRO_NUM==0){return 0;}
  498.         //过滤回车符       
  499.         Str[strlen(Str)-2]='\0';
  500.        
  501.         int  i=0;
  502.         char* lp=Str;
  503.        
  504.         char* tp;
  505.         strtok(lp, " ");
  506.         while(i<PRO_NUM){
  507.                 WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
  508.                 if((tp=strtok(NULL, " "))==NULL){break;}
  509.                 strcpy(WORDS[i++], tp);
  510.         }
  511.         if(i==0){WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char)); return 1;}
  512.         if(i<PRO_NUM){fprintf(stdout, "[%d]:Missing Parameter %s\n", LineNUM, Line);exit(1);}       
  513.         return i;
  514. }
  515. //切分参数
  516. int ARGP(char* Str, char** WORDS, int PRO_NUM, char** PRO_WORDS, char** PRO_VALUE)
  517. {
  518.         int i=-1;
  519.         char* tp;
  520.         strtok(Str, " ");
  521.         while((tp=strtok(NULL, " "))!=NULL && *tp!='\r'){
  522.                 WORDS[++i]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));
  523.                 itoa(EvalLine(tp, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"), WORDS[i], 10);
  524.         }
  525.         if(i==-1){WORDS[++i]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));}
  526.         return i+1;
  527. }
  528. //关键词解析函数
  529. int Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring)
  530. {
  531.         int i, SN;
  532.         for(SN=0; SN<SENSITIVE_NUM; SN++){
  533.                 char *op=Line, *kp=WORDS[SN];
  534.                 while(*kp!='\0'){
  535.                         if(
  536.                                 (('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)
  537.                         ){
  538.                                 break;
  539.                         }
  540.                         op++;kp++;
  541.                 }
  542.                  if(
  543.                          *kp=='\0' &&
  544.                         isEND(*op, endstring)
  545.                 ){
  546.                         return SN;
  547.                 }
  548.         }                               
  549.         return -1;
  550. }
  551. //计算含变量表达式函数
  552. float EvalLine(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  553. {
  554.         char* op=cacheTain;
  555.         char* cp=(char*)exp;
  556.         char* Line_Cache=op;
  557.         int   i=-1;
  558.        
  559.         while(!isEND(*cp, " \t\r\n\0")){

  560.                 if(!isEND(*cp, ":$ \t\r\n\0")){
  561.                         *(op++)=*(cp++);
  562.                         continue;
  563.                 }

  564.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  565.                         char* tmp=VALUE[i];
  566.                         *op++='(';
  567.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  568.                         *op++=')';
  569.                         cp+=strlen(WORDS[i]);                       

  570.                 }else if((*cp==') && (i=Identify_KeyWords(cp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, endstring))!=-1){
  571.                        
  572.                         //准备临时容器
  573.                         char* tmp=(char*)calloc(16, sizeof(char));
  574.                         //解析变量名
  575.                         switch(i){
  576.                         case 8:
  577.                                 itoa(rand(), tmp, 10);
  578.                                 break;
  579.                         case 9:
  580.                         case 10:
  581.                         case 11:
  582.                         case 12:
  583.                         case 13:
  584.                         case 14:
  585.                                 itoa(getTIME(i), tmp, 10);
  586.                                 break;
  587.                         default:       
  588.                                 _gcvt(GLOBAL_VALUE[i], 10, tmp);
  589.                                 break;
  590.                         }
  591.                         *op++='(';
  592.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  593.                         *op++=')';
  594.                         free(tmp);
  595.                         cp+=GLOBAL_LLENS[i];
  596.                 }
  597.         }
  598.         *op='\0' ;
  599.         return (float)RevPolishCore(Line_Cache);
  600. }
  601. //赋值函数
  602. BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  603. {
  604.         char *gp=(char*)exp, *cp=gp;
  605.         while(!isEND(*cp, "=")){
  606.                 cp++;
  607.         }
  608.         cp++;

  609.         int i=-1;
  610.         if(gp[0]==':'){
  611.                 if(gp[1]==':'){return TRUE;}
  612.                 i=Identify_KeyWords(gp, PRO_NUM, WORDS, " \t=");
  613.                 itoa(EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring), VALUE[i], 10);
  614.         }else if(gp[0]=='){
  615.                 i=Identify_KeyWords(gp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, " \t=");
  616.                 GLOBAL_VALUE[i]=EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring);

  617.                 switch(i){
  618.                 case 3:
  619.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :16+(int)GLOBAL_VALUE[i]%16;
  620.                         STRGB* bgRGB=&LOGO_RGB[(int)GLOBAL_VALUE[i]];
  621.                         //创建画刷
  622.                         HBRUSH m_brush=CreateSolidBrush(bgRGB->VALUE);
  623.                         //填充背景
  624.                         FillRect(hDC1, lrRECT, m_brush);
  625.                         //删除画刷
  626.                         DeleteObject(m_brush);
  627.                         break;

  628.                         break;
  629.                 case 4:
  630.                         if(GLOBAL_VALUE[i]<0){GLOBAL_VALUE[i]=-GLOBAL_VALUE[i];}
  631.                         break;
  632.                 case 5:
  633.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :360+(int)GLOBAL_VALUE[i]%16;
  634.                         break;
  635.                 case 6:
  636.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%6 :(0-(int)GLOBAL_VALUE[i])%6;
  637.                         break;
  638.                 case 7:
  639.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%255 :(0-(int)GLOBAL_VALUE[i])%255;
  640.                         break;
  641.                 default:
  642.                         break;
  643.                 }

  644.                
  645.         }
  646.         return TRUE;
  647. }
  648. //批量赋值
  649. BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  650. {
  651.         char *gp=(char*)Line;
  652.         while(isEND(*gp, ":$")){
  653.                 AssignMent(gp, PRO_NUM, WORDS, VALUE, endstring);
  654.                 gp++;
  655.                 while(!isEND(*gp, " \t\0")){
  656.                         gp++;
  657.                 }
  658.                 while(!isEND(*gp, ":$\0")){gp++;}
  659.                 if(*gp=='\0'){return TRUE;}
  660.         }
  661.         return TRUE;
  662. }
  663. //测FOR循环
  664. inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, int CYC)
  665. {
  666.         if(CYC ==0){return TRUE;}
  667.         int i=-1;
  668.         if((i=Identify_KeyWords(strtok((char*)Line, " "), PRO_NUM, WORDS, " \t")) !=-1){
  669.                 int staNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  670.                 int endNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  671.                 int var   =atoi(VALUE[i]);
  672.                 if(staNUM-endNUM<0){return (var<=endNUM)?TRUE:FALSE;}
  673.                 return (var>=endNUM)?TRUE:FALSE;
  674.         }
  675.         return FALSE;
  676. }
  677. //真值条件判断
  678. BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  679. {
  680.         char* op=cacheTain;
  681.         char* cp=(char*)exp;

  682.         //过滤行TAB缩进或空格
  683.         while(*cp=='\t'|| *cp==' '){cp++;}

  684.         if(isEND(*cp, "\r\n\0")){
  685.                 return TRUE;
  686.         }

  687.         char* Line_Cache=op;
  688.         int   i=-1, flag=0;

  689.         while(!isEND(*cp, " \t\r\n\0")){
  690.                 if      (*cp=='>'){
  691.                         flag+=4;
  692.                         *(op++)='-';
  693.                         *(op++)='(';
  694.                         cp++;
  695.                         continue;

  696.                 }else if(*cp=='<'){
  697.                         flag+=2;
  698.                         *(op++)='-';
  699.                         *(op++)='(';
  700.                         cp++;
  701.                         continue;

  702.                 }else if(*cp=='='){
  703.                         flag+=1;
  704.                         if(flag==1){
  705.                                 *(op++)='-';
  706.                                 *(op++)='(';
  707.                         }
  708.                         cp++;
  709.                         continue;

  710.                 }else if(*cp!=':'&& *cp!='){
  711.                         *(op++)=*(cp++);
  712.                         continue;
  713.                 }

  714.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  715.                         char* tmp=VALUE[i];
  716.                         *op++='(';
  717.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  718.                         *op++=')';               
  719.                         cp+=strlen(WORDS[i]);                       

  720.                 }else if((*cp==') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  721.                         char* tmp=(char*)calloc(16, sizeof(char));
  722.                         if(i==8){
  723.                                 itoa(rand(), tmp, 10);

  724.                         }else if(9<=i && i<=14){
  725.                                 itoa(getTIME(i), tmp, 10);

  726.                         }else{
  727.                                 _gcvt(GLOBAL_VALUE[i], 10, tmp);

  728.                         }
  729.                         *op++='(';
  730.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  731.                         *op++=')';
  732.                         cp+=GLOBAL_LLENS[i];
  733.                 }else{
  734.                         return FALSE;
  735.                 }

  736.         }
  737.         *(op++)=')';
  738.         *op='\0' ;
  739.         int m=(int)RevPolishCore(Line_Cache);

  740.         if(
  741.                 (m >0 && (flag==4||flag==5         )) ||
  742.                 (m <0 && (flag==2||flag==3         )) ||
  743.                 (m==0 && (flag==1||flag==3||flag==5||flag==0))
  744.         ){
  745.                 return TRUE;
  746.         }
  747.         return FALSE;
  748. }
  749. //批量真值判断
  750. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  751. {
  752.         char *gp=(char*)Line;
  753.         int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
  754.         if(li !=-1){gp+=LGC_LLENS[li];}

  755.         do{
  756.                 while(isEND(*gp, " \t")){
  757.                         gp++;
  758.                 }
  759.                 if(JudgMent(gp, PRO_NUM, WORDS, VALUE, endstring)){

  760.                         switch(li){
  761.                         case 0:
  762.                                 return FALSE;
  763.                         case 1:
  764.                                 break;
  765.                         case 2:
  766.                                 return TRUE;
  767.                         default:
  768.                                 return TRUE;
  769.                         }
  770.                 }else{
  771.                         switch(li){
  772.                         case 0:
  773.                                 break;
  774.                         case 1:
  775.                                 return FALSE;
  776.                         case 2:
  777.                                 break;
  778.                         default:
  779.                                 return FALSE;
  780.                         }
  781.                 }
  782.                 while(!isEND(*gp, " \t\0"  )){gp++;}
  783.                 if(*gp=='\0'){return TRUE;}
  784.                 while( isEND(*gp, " \t\r\n")){gp++;}

  785.         }while(*gp !='\0');
  786. }

  787. /***************绘图函数群***************/
  788. //隐藏光标
  789. BOOL SizeCursor(int size)
  790. {
  791.     CONSOLE_CURSOR_INFO cursor_info = {(DWORD)((size==0)?25:size), (size==0)?FALSE:TRUE};
  792.     return SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
  793. }
  794. //平滑画线函数,C++连接库
  795. void drawSMOOTHLINE(HDC hDC, int penWith, int mode, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2);
  796. //封闭区域填充函数,C++连接库
  797. void fillAREA(HDC hDC, BYTE alpha, STRGB* penRGB, float fill_X, float fill_Y);
  798. //快速画线函数
  799. BOOL drawLINE(HDC hDC, int d)
  800. {
  801.         float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
  802.         GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  803.         GLOBAL_VALUE[1]+=d * cos(GLOBAL_VALUE[2]*0.017453292519943);

  804.         //当为PU抬笔时,不做绘图
  805.         if(!penMODE){
  806.                 return FALSE;
  807.         }
  808.         STRGB* penRGB=&LOGO_RGB[(int)GLOBAL_VALUE[5]];
  809.         drawSMOOTHLINE(hDC, (int)GLOBAL_VALUE[4], (int)GLOBAL_VALUE[6], (int)GLOBAL_VALUE[7], penRGB, lrRECT->right/2+x1, lrRECT->bottom/2-y1, lrRECT->right/2+GLOBAL_VALUE[0], lrRECT->bottom/2-GLOBAL_VALUE[1]);
  810.         return TRUE;
  811. }
  812. //退步函数,实现BK
  813. void backWARD(int d)
  814. {
  815.         GLOBAL_VALUE[0]-=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  816.         GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  817. }
  818. //图形旋转
  819. int RotateDC(HDC hDC, int angle)  
  820. {
  821.         if(angle==0){return 1;}
  822.         XFORM Matrix;
  823.         double rad =-angle * 0.017453292519943;
  824.         Matrix.eM11 = (float)cos(rad);  
  825.         Matrix.eM12 = (float)sin(rad);  
  826.         Matrix.eM21 =-(float)sin(rad);
  827.         Matrix.eM22 = (float)cos(rad);  
  828.         Matrix.eDx  = (float)(GLOBAL_VALUE[0]-cos(rad)*GLOBAL_VALUE[0]+sin(rad)*GLOBAL_VALUE[1]);  
  829.         Matrix.eDy  = (float)(GLOBAL_VALUE[1]-cos(rad)*GLOBAL_VALUE[1]-sin(rad)*GLOBAL_VALUE[0]);
  830.         SetGraphicsMode(hDC, GM_ADVANCED);
  831.         SetWorldTransform(hDC, &Matrix);
  832.         return 0;
  833. }

  834. /***************解析函数群***************/
  835. //脚本解析函数
  836. int FileScript(char* prossName, int PRO_NUM, char** PRO_VALUE)
  837. {       
  838.         //初始参数,其中KLevel为当前循环层号;
  839.         int i=0, j=0, KLevel=0, SN=-1, Line_LEN=0, fcolor=-1, BASE_VAR_NUM=PRO_NUM;
  840.         char* prepos=NULL;

  841.         //定义过程变量存储容器,即定义 :A型变量,后接 ::A型变量
  842.         char** PRO_WORDS=(char**)calloc(LOOP_LEVELS, sizeof(char*));

  843.         //初始化开关参数,SFLAG[0]==1开始;
  844.         char* SFLAG=(char*)calloc(8, sizeof(char));
  845.         SFLAG[2]=-1;

  846.         //初始化循环参量数组
  847.         int*   FORI_CYCL=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  848.         int*   FORI_LNUM=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  849.         char** FORI_FTEL=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  850.         char** FORI_FEND=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  851.         BOOL*  FORI_IFOT=(BOOL *)calloc(LOOP_LEVELS,   sizeof(BOOL ));

  852.         //分配行容器
  853.         char* LCache=(char*)calloc(1025, sizeof(char));

  854.         //辅助行指针
  855.         char* Line;

  856.         //辅助流指针
  857.         char* tmpfp=tRAM;

  858.         while(*tmpfp !='\0'){
  859.                
  860.                 //记录位置
  861.                 char* prepos=tmpfp;

  862.                 //指针置换
  863.                 Line=LCache;

  864.                 while(*tmpfp !='\n' && *tmpfp !='\0'){
  865.                         *(Line++)=*(tmpfp++);
  866.                 }
  867.                 if(*tmpfp =='\n'){*(Line++)=*(tmpfp++);}
  868.                  *Line='\0';
  869.                 //指针回首
  870.                 Line=LCache;
  871.                
  872.                 //行计数器
  873.                 i++;
  874.                
  875.                 //过滤行TAB缩进或前空格
  876.                 while(*Line=='\t'|| *Line==' '){Line++;}

  877.                 //过滤空行或行注释
  878.                 if(
  879.                         (Line[0]=='\r')                ||
  880.                         (Line[0]=='\n')                ||
  881.                         (Line[0]=='/' && Line[1]=='/')
  882.                 ){
  883.                         continue;
  884.                 }

  885.                 //过滤段间注释
  886.                 if(
  887.                         (Line[0]=='/' &&Line[1]=='*')
  888.                 ){
  889.                         SFLAG[0]=0;
  890.                         continue;
  891.                        
  892.                 }else if(
  893.                         (Line[0]=='*' &&Line[1]=='/')
  894.                 ){
  895.                         SFLAG[0]=1;
  896.                         continue;
  897.                        
  898.                 }

  899.                 //识别子过程名
  900.                 if(
  901.                         (isEND(Line[2], " \t\r\n\0") )  &&
  902.                         (Line[0]=='T' || Line[0]=='t')  &&
  903.                         (Line[1]=='O' || Line[1]=='o')

  904.                 ){
  905.                         Line+=2;
  906.                         //过滤TO后TAB缩进,或TO后空格
  907.                         while(*Line=='\t'|| *Line==' '){Line++;}               
  908.                         if(isKEY(Line, prossName, " \t\r\n\0")){
  909.                                 SFLAG[0]=1;
  910.                                 ARGS(Line, PRO_WORDS, PRO_NUM, i, Line);
  911.                         }else{
  912.                                 SFLAG[0]=0;
  913.                         }
  914.                         continue;
  915.                 }

  916.                 //开始开关未打开,或遇到空行
  917.                 if(
  918.                         SFLAG[0]==0                    ||
  919.                         isEND(Line[0], "\r\n[")

  920.                 ){continue;}

  921.                 //IF...ELIF连带性分析
  922.                 if(
  923.                         (FORI_IFOT[KLevel+1]       )   &&
  924.                         (Line[0]!='E'&&Line[0]!='e')   &&
  925.                         (Line[1]!='L'&&Line[1]!='l')   &&
  926.                         (Line[2]!='I'&&Line[2]!='i')   &&
  927.                         (Line[3]!='F'&&Line[3]!='f')

  928.                 ){
  929.                         FORI_IFOT[KLevel+1]=FALSE;
  930.                 }

  931.                 //解析循环结束标签,循环加速
  932.                 if(Line[0]==']'){
  933.                         if(KLevel>SFLAG[1]){
  934.                                 if(FORI_CYCL[KLevel] <0){
  935.                                         int tpadd=EvalLine(Line+1, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  936.                                         if(tpadd==0){tpadd=1;}
  937.                                         itoa(atoi(PRO_VALUE[0-FORI_CYCL[KLevel]])+tpadd, PRO_VALUE[0-FORI_CYCL[KLevel]], 10);                               
  938.                                 }
  939.                                 if(FORI_FEND[KLevel]==NULL){FORI_FEND[KLevel]=tmpfp;}
  940.                                 tmpfp=FORI_FTEL[KLevel];
  941.                                 i=FORI_LNUM[KLevel]-1;

  942.                         }else{
  943.                                 FORI_FTEL[KLevel]=NULL;
  944.                                 FORI_FEND[KLevel]=NULL;
  945.                                 FORI_CYCL[KLevel]=0;
  946.                                 SFLAG[1]=0;
  947.                         }
  948.                         KLevel--;
  949.                         continue;

  950.                 }else{
  951.                         int ki =Identify_KeyWords(Line, CYC_SIZE, (char**)CYC_WORDS, " \t\r\n\0");
  952.                         if( ki!=-1){
  953.                                 Line=passNULL(Line+CYC_LLENS[ki]);
  954.                                 KLevel++;
  955.                                 //解析循环
  956.                                 if(
  957.                                         ki==0 && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n") ||
  958.                                         ki==1 && FORI_CYCL[KLevel]<EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"   )         ||
  959.                                         ki==2 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")                        ||
  960.                                         ki==3 && isForTrue(Line, PRO_NUM, PRO_WORDS, PRO_VALUE,  FORI_CYCL[KLevel])                           ||
  961.                                         ki==4 && (FORI_IFOT[KLevel]) && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")

  962.                                 ){
  963.                                         if( FORI_FTEL[KLevel]==NULL ){
  964.                                                 FORI_FTEL[KLevel]=prepos;
  965.                                                 FORI_LNUM[KLevel]=i+1;
  966.                                                 if(ki==3){
  967.                                                         char *tp1, *tp2;
  968.                                                         //提取瞬时变量名
  969.                                                         if((tp1=strtok(Line, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  970.                                                         PRO_WORDS[PRO_NUM]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
  971.                                                         strcpy(PRO_WORDS[PRO_NUM], tp1);
  972.                                                         //提取始步
  973.                                                         if((tp2=strtok(NULL, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  974.                                                         PRO_VALUE[PRO_NUM]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));
  975.                                                         itoa(EvalLine(tp2, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"), PRO_VALUE[PRO_NUM], 10);
  976.                                                         FORI_CYCL[KLevel] =0-PRO_NUM;
  977.                                                         PRO_NUM++;

  978.                                                 }
  979.                                                 if(ki==0 || ki==4){
  980.                                                         FORI_IFOT[KLevel]=FALSE;
  981.                                                 }
  982.                                         }

  983.                                         if(ki !=3){FORI_CYCL[KLevel]  ++;}

  984.                                 }else{
  985.                                         if((ki==0||ki==4) && FORI_CYCL[KLevel]==0){
  986.                                                 FORI_IFOT[KLevel]=TRUE;
  987.                                         }
  988.                                         if(FORI_FEND[KLevel] !=NULL){
  989.                                                 if(FORI_CYCL[KLevel] <0){
  990.                                                         free(PRO_WORDS[PRO_NUM]);
  991.                                                         free(PRO_VALUE[PRO_NUM]);
  992.                                                         PRO_NUM-=1;
  993.                                                 }
  994.                                                 tmpfp=FORI_FEND[KLevel];
  995.                                                 i=FORI_LNUM[KLevel]-1;
  996.                                                 FORI_FTEL[KLevel]=NULL;
  997.                                                 FORI_FEND[KLevel]=NULL;
  998.                                                 FORI_CYCL[KLevel]=0;
  999.                                                 KLevel--;
  1000.                                         }else{
  1001.                                                 SFLAG[1]=KLevel;
  1002.                                         }
  1003.                                 }
  1004.                                 continue;
  1005.                         }
  1006.                 }

  1007.                 //语句块循环开关
  1008.                 if(SFLAG[1]!=0){continue;}

  1009.                 //变量赋值
  1010.                 if(Line[0]==':'||Line[0]=='){
  1011.                         MoreAssignMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1012.                         continue;
  1013.                 }

  1014.                 //调用子过程
  1015.                 if(Line[0]=='.'){
  1016.                         //定义过程传参容器
  1017.                         char** PAR_VALUE=(char**)calloc(LOOP_LEVELS, sizeof(char*));
  1018.                         int PAR_NUM=ARGP(Line, PAR_VALUE, PRO_NUM, PRO_WORDS, PRO_VALUE);
  1019.                         FileScript(Line+1, PAR_NUM, PAR_VALUE);
  1020.                         free(PAR_VALUE);
  1021.                         continue;
  1022.                 }

  1023.                 //过滤回车符
  1024.                 if((Line_LEN=strlen(Line))==2){
  1025.                         continue;
  1026.                 }else{
  1027.                         Line[Line_LEN-2]='\0';
  1028.                 }

  1029.                 //解析命令行
  1030.                 if((SN=Identify_KeyWords(Line, KEY_SIZE, (char**)KEY_WORDS, " \t\r\n\0")) !=-1){
  1031.                         Line=passNULL(Line+KEY_LLENS[SN]);
  1032.                 }else{
  1033.                         printf("[%d]:EEEOR LINE "%s"\n", i, Line);
  1034.                         exit(1);
  1035.                 }
  1036.                 switch(SN)
  1037.                 {
  1038.                 case  0:
  1039.                         //FD
  1040.                         drawLINE(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1041.                         break;
  1042.                 case  1:
  1043.                         //BK
  1044.                         backWARD(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1045.                         break;
  1046.                 case  2:
  1047.                         //LT
  1048.                         GLOBAL_VALUE[2]-=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1049.                         break;
  1050.                 case  3:
  1051.                         //RT
  1052.                         GLOBAL_VALUE[2]+=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1053.                         break;
  1054.                 case  4:
  1055.                         //PU
  1056.                         penMODE=FALSE;
  1057.                         break;
  1058.                 case  5:
  1059.                         //PD
  1060.                         if(SFLAG[2] !=-1){
  1061.                                 GLOBAL_VALUE[5]=SFLAG[2];
  1062.                                 SFLAG[2] =-1;
  1063.                         }
  1064.                         penMODE=TRUE;
  1065.                         break;
  1066.                 case  6:
  1067.                         //PE
  1068.                         if(SFLAG[2] ==-1){
  1069.                                 SFLAG[2]=GLOBAL_VALUE[5];
  1070.                                 GLOBAL_VALUE[5]=GLOBAL_VALUE[3];
  1071.                         }
  1072.                         break;
  1073.                 case  7:
  1074.                         //CLEAN
  1075.                         InvalidateRect(hCMD,NULL,FALSE);
  1076.                         break;
  1077.                 case  8:
  1078.                         //ECHO, 输出字符串
  1079.                         printf("%s\n", Line);
  1080.                         break;
  1081.                 case  9:
  1082.                         //HOME
  1083.                         GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;
  1084.                         break;
  1085.                 case 10:
  1086.                         //STOP
  1087.                         return 0;
  1088.                 case 11:
  1089.                         //EXIT
  1090.                         exit(0);
  1091.                 case 12:
  1092.                         //FILL
  1093.                         if((fcolor=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n")) !=-1){
  1094.                                 fillAREA(hDC,  (BYTE)((int)GLOBAL_VALUE[7]&0xFF), &LOGO_RGB[fcolor],  lrRECT->right/2+GLOBAL_VALUE[0],  lrRECT->bottom/2-GLOBAL_VALUE[1]);
  1095.                         }
  1096.                         break;
  1097.                 case 13:
  1098.                         //PAUSE
  1099.                         getch();
  1100.                         break;
  1101.                 case 14:
  1102.                         //WAIT
  1103.                         Sleep(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1104.                         break;
  1105.                 case 15:
  1106.                         //ROTE
  1107.                         //将内存画布拷屏到CMD窗口
  1108.                         //BitBlt(hDC,0,0,WINDOW_WIDTH,WINDOW_HEIGHT, hDC1,0,0,SRCCOPY);
  1109.                         RotateDC(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1110.                         break;
  1111.                 case 16:
  1112.                         //MEMUSE,开辟内存画布
  1113.                         if(!memMODE){
  1114.                                 BitBlt(hDC3,0,0,lrRECT->right,lrRECT->bottom, hDC1,0,0,SRCCOPY);
  1115.                                 memMODE=TRUE;
  1116.                         }
  1117.                         BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1118.                         hDC=hDC2;
  1119.                         break;
  1120.                 case 17:
  1121.                         //MEMSEE,展示内存画布
  1122.                         BitBlt(hDC1,0,0,lrRECT->right,lrRECT->bottom, hDC2,0,0,SRCCOPY);
  1123.                         BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1124.                         break;
  1125.                 case 18:
  1126.                         //MEMOUT,丢弃内存画布
  1127.                         memMODE=FALSE;
  1128.                         hDC=hDC1;
  1129.                         break;
  1130.                 case 19:
  1131.                         //EVAL,表达式计算输出
  1132.                         printf("%.12g\n", EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1133.                         break;
  1134.                 default:
  1135.                         printf("[%d]:EEEOR LINE 。\n", i);
  1136.                         exit(1);
  1137.                         break;
  1138.                 }
  1139.         }
  1140.         free(PRO_WORDS);
  1141.         free(SFLAG);
  1142.         free(FORI_CYCL);
  1143.         free(FORI_LNUM);
  1144.         free(FORI_FTEL);
  1145.         free(FORI_FEND);
  1146.         free(FORI_IFOT);
  1147.         free(LCache);
  1148.         return 0;
  1149. }

  1150. /*************MAIN主函数入口*************/
  1151. int main(int argc, char** argv)
  1152. {
  1153.         if(argc==2){

  1154.                 //隐藏光标
  1155.                 SizeCursor(0);

  1156.                 //初始化变量
  1157.                 int fsize=0;
  1158.                
  1159.                 //初始化随机种子
  1160.                 srand((unsigned)time(NULL));

  1161.                 //读文件流
  1162.                 FILE* fp;
  1163.                 if( (fp=fopen(argv[1], "rb"))==NULL ){
  1164.                         fputs("Failed to read file.", stdout);
  1165.                         return 2;
  1166.                 }

  1167.                 //测量尺寸
  1168.                 fseek(fp, 0, SEEK_END);
  1169.                 fsize=ftell(fp);

  1170.                 //超过1M的脚本,拒绝执行
  1171.                 if(fsize > 1*1024*1024){
  1172.                         fputs("File size is too large, out of memory.", stdout);
  1173.                         return 1;

  1174.                 //小于10字节的,拒绝执行
  1175.                 }else if(fsize < 10){
  1176.                         fputs("File size is too small,  in of memory.", stdout);
  1177.                         return 1;
  1178.                 }

  1179.                 //指针复原
  1180.                 fseek(fp, 0, SEEK_SET);
  1181.                 //读入内存
  1182.                 tRAM=(char*)calloc(fsize+3, sizeof(char));
  1183.                 tRAM[fsize]='\r', tRAM[fsize+1]='\n', tRAM[fsize+2]='\0';
  1184.                 fread(tRAM, fsize, 1, fp);
  1185.                 //释放文件
  1186.                 fclose(fp);
  1187.                
  1188.                 //获取CMD窗口句柄
  1189.                 hCMD=GetConsoleWindow();
  1190.                 //获取CMD窗口大小
  1191.                 lrRECT=&winRECT;
  1192.                 GetClientRect(hCMD, lrRECT);
  1193.                
  1194.                 //CMD画布
  1195.                 hDC1=GetDC(hCMD);
  1196.                 HBITMAP hBitmap1=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1197.                 SelectObject(hDC1, hBitmap1);
  1198.        
  1199.                 //内存画布
  1200.                 hWND2=NULL;
  1201.                 hDC2=CreateCompatibleDC(GetDC(hWND2));
  1202.                 HBITMAP hBitmap2=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1203.                 SelectObject(hDC2, hBitmap2);

  1204.                 //辅助画布
  1205.                 hWND3=NULL;
  1206.                 hDC3=CreateCompatibleDC(GetDC(hWND3));
  1207.                 HBITMAP hBitmap3=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1208.                 SelectObject(hDC3, hBitmap3);

  1209.                 //运行脚本
  1210.                 char** PAR_VALUE=(char**)calloc(LOOP_LEVELS, sizeof(char*));

  1211.                 //主DC选择CMD画布
  1212.                 hDC=hDC1;

  1213.                 //寻找主函数入口点
  1214.                 FileScript("MAIN", 1, PAR_VALUE);
  1215.                
  1216.                 //释放DC
  1217.                 ReleaseDC(NULL, hDC3);
  1218.                 ReleaseDC(NULL, hDC2);
  1219.                 ReleaseDC(hCMD, hDC1);
  1220.                 DeleteDC(hDC3);
  1221.                 DeleteDC(hDC2);
  1222.                 DeleteDC(hDC1);       
  1223.                 DeleteObject(hBitmap3);
  1224.                 DeleteObject(hBitmap2);
  1225.                 DeleteObject(hBitmap1);
  1226.                 //释放内存
  1227.                 free(PAR_VALUE);
  1228.                 free(tRAM);
  1229.                 return 0;
  1230.         }

  1231.         //异常则抛出使用说明
  1232.         fputs("COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0\nUSAGE: CLGO [FILE]\n", stdout);
  1233.         return 1;
  1234. }
复制代码

点评

好家伙,这么长,等我把这个计算器完善了,就开始用c 写程序,正好拿你的程序练手!  发表于 2017-1-13 10:46
毋因群疑而阻独见  毋任己意而废人言
毋私小惠而伤大体  毋借公论以快私情
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

小黑屋|手机版|数学研发网 ( 苏ICP备07505100号 )

GMT+8, 2024-3-29 21:25 , Processed in 0.053358 second(s), 18 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表