数学研发网设为首页收藏本站
切换到窄版

 找回密码
 欢迎注册
数学研发论坛»论坛 › 【算法研发】 › 开发应用 › 落叶高精度表达式计算器v1.0版
1234
返回列表 发新帖
楼主: 落叶

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

[复制链接]
happysxyf
发表于 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")){

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

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

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

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

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

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

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

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

  139.         if(isEND(*cp, "\r\n\0")){
  140.                 return TRUE;
  141.         }

  143.         char* Line_Cache=op;
  144.         int   i=-1, flag=0;

  146.         while(!isEND(*cp, " \t\r\n\0")){
  147.                 if      (*cp=='>'){
  148.                         flag+=4;
  149.                         *(op++)='-';
  150.                         *(op++)='(';
  151.                         cp++;
  152.                         continue;

  154.                 }else if(*cp=='<'){
  155.                         flag+=2;
  156.                         *(op++)='-';
  157.                         *(op++)='(';
  158.                         cp++;
  159.                         continue;

  161.                 }else if(*cp=='='){
  162.                         flag+=1;
  163.                         if(flag==1){
  164.                                 *(op++)='-';
  165.                                 *(op++)='(';
  166.                         }
  167.                         cp++;
  168.                         continue;

  170.                 }else if(*cp!=':'&& *cp!='){
  171.                         *(op++)=*(cp++);
  172.                         continue;
  173.                 }

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

  180.                 }else if((*cp==') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  181.                         char* tmp=(char*)calloc(16, sizeof(char));
  182.                         if(i==16){
  183.                                 strcpy(tmp, "3.141592653590");
  184.                         }else if(i==17){
  185.                                 itoa(rand(), tmp, 10);
  186.                         }else{
  187.                                 itoa(GLOBAL_VALUE[i], tmp, 10);
  188.                         }
  189.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  190.                         cp+=GLOBAL_LLENS[i];
  191.                 }else{
  192.                         return FALSE;
  193.                 }

  195.         }
  196.         *(op++)=')';
  197.         int m=(int)CalculateExpression(Line_Cache);

  199.         if(
  200.                 (m >0 && (flag==4||flag==5         )) ||
  201.                 (m <0 && (flag==2||flag==3         )) ||
  202.                 (m==0 && (flag==1||flag==3||flag==5||flag==0))
  203.         ){
  204.                 return TRUE;
  205.         }
  206.         return FALSE;
  207. }
  208. //批量真值判断
  209. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  210. {
  211.         char *gp=(char*)Line;
  212.         int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
  213.         if(li !=-1){gp+=LGC_LLENS[li];}

  215.         do{
  216.                 while(isEND(*gp, " \t")){
  217.                         gp++;
  218.                 }
  219.                 if(JudgMent(gp, PRO_NUM, WORDS, VALUE, endstring)){

  221.                         switch(li){
  222.                         case 0:
  223.                                 return FALSE;
  224.                         case 1:
  225.                                 break;
  226.                         case 2:
  227.                                 return TRUE;
  228.                         default:
  229.                                 return TRUE;
  230.                         }
  231.                 }else{
  232.                         switch(li){
  233.                         case 0:
  234.                                 break;
  235.                         case 1:
  236.                                 return FALSE;
  237.                         case 2:
  238.                                 break;
  239.                         default:
  240.                                 return FALSE;
  241.                         }
  242.                 }
  243.                 while(!isEND(*gp, " \t\0"  )){gp++;}
  244.                 if(*gp=='\0'){return TRUE;}
  245.                 while( isEND(*gp, " \t\r\n")){gp++;}

  247.         }while(*gp !='\0');
  248. }

  250. /***************绘图函数群***************/
  251. //平滑画线函数，C++连接库
  252. void drawSMOOTHLINE(HDC hDC, int penWith, int mode, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2);
  253. //封闭区域填充函数，C++连接库
  254. void fillAREA(HDC hDC, BYTE alpha, STRGB* penRGB, float fill_X, float fill_Y);
  255. //快速画线函数
  256. BOOL drawLINE(HDC hDC, int d)
  257. {
  258.         float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
  259.         GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  260.         GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  261.         if(!penMODE){
  262.                 return FALSE;
  263.         }
  264.         STRGB* penRGB=&LRGB[(int)GLOBAL_VALUE[5]];
  265.         drawSMOOTHLINE(hDC, (int)GLOBAL_VALUE[4], (int)GLOBAL_VALUE[18], (int)GLOBAL_VALUE[25], penRGB, x1, y1, GLOBAL_VALUE[0], GLOBAL_VALUE[1]);
  266.         return TRUE;
复制代码
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

happysxyf
发表于 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 编辑

安卓版你是用专用编译器编译的吗？
你说你的加减乘除都写好了，你想过把加减法乘除加上小数，指数功能吗？虽然网上对大数加减乘除有了很多论述，实例，但我还没查到加上了这两个功能的实例源码，这个是大数综合运算需要的基础。
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

happysxyf
发表于 2017-1-11 23:19:26 | 显示全部楼层
落叶 发表于 2017-1-8 19:18
安卓版你是用专用编译器编译的吗？
你说你的加减乘除都写好了，你想过把加减法乘除加上小数，指数功能吗？ ...

我的在手机上是用的手机的那个C4droid编译器编译的
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

happysxyf
发表于 2017-1-11 23:19:37 | 显示全部楼层
落叶 发表于 2017-1-8 19:18
安卓版你是用专用编译器编译的吗？
你说你的加减乘除都写好了，你想过把加减法乘除加上小数，指数功能吗？ ...


我的在手机上是用的手机的那个C4droid编译器编译的，手机上的体验很好，基本上能取代自带的安卓计算器。因为这是表达式计算，速度也快。
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

happysxyf
发表于 2017-1-11 23:22:20 | 显示全部楼层
落叶 发表于 2017-1-8 19:14
定义函数我也有了一个大致的思路，不过只支持可以用表达式表示的函数，不知道实用价值怎么样？


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

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

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

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

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

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

  55. //内存变量
  56. char* tRAM;
  57. //缓存容器
  58. char  cacheTain[1025]={0};
  59. //画线可见，可见即PD，不可见即PU
  60. BOOL  penMODE=TRUE;
  61. //启用内存背景
  62. BOOL  memMODE=FALSE;

  64. /***************关键词类目***************/
  65. //运算符栈
  66. char   STACK1[STACK_SIZE]={0};
  67. //逆波兰栈
  68. char   STACK2[STACK_SIZE]={0};
  69. //浮点数栈
  70. double STACK3[STACK_SIZE]={0};
  71. //数学函数关键词
  72. 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};
  73. //绘图系关键词
  74. 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"};
  75. 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};
  76. //循环系关键词
  77. static const char* CYC_WORDS[]={"IF", "REPEAT", "WHILE", "FOR", "ELIF"};
  78. static const char  CYC_LLENS[]={   2,        6,       5,     3,      4};
  79. //逻辑系关键词
  80. static const char* LGC_WORDS[]={"NOT", "AND", "OR"};
  81. static const char  LGC_LLENS[]={   3,      3,    2};
  82. //定义解释器全局变量
  83. 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"};
  84. 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};
  85.            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};

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

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

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

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

  207.                 case ')':
  208.                         while(*S1!='(')
  209.                         {
  210.                                 *(S2++)=*(S1--);
  211.                         }               
  212.                         //舍弃'('
  213.                         S1--;               
  214.                         break;

  216.                 case '+':
  217.                 case '-':
  218.                         while(S1!=STACK1 && *S1!='(')
  219.                         {
  220.                                 *(S2++)=*(S1--);
  221.                         }
  222.                         *(++S1)=*op;
  223.                         break;

  225.                 case '^':
  226.                         //指数符
  227.                         while('A'<=(*S1) && (*S1)<='Z')
  228.                         {
  229.                                 *(S2++)=*(S1--);
  230.                         }
  231.                         *(++S1)=*op;
  232.                         break;

  234.                 case '!':
  235.                         //阶乘符
  236.                         *(S2++)=*op;
  237.                         break;

  239.                 case '%':
  240.                 case '*':
  241.                 case '/':
  242.                         while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){
  243.                                 *(S2++)=*(S1--);
  244.                         }
  245.                         *(++S1)=*op;
  246.                         break;

  248.                 default :
  249.                         if((*op<'0' || *op>'9') && (*op!='.')){
  250.                                 //无法识别的运算符
  251.                                 fputs("Unrecognized operator\n", stderr);
  252.                                 exit(1);
  253.                         }
  254.                         //浮点数入栈
  255.                         while(('0'<=*op && *op<='9') ||*op=='.'){
  256.                                 *(S2++)=*(op++);
  257.                         }
  258.                         op--;
  259.                         *(S2++)=' ';
  260.                         break;
  261.                 }
  262.                 op++;
  263.         }
  264.         //收尾逆波兰
  265.         while(S1 !=STACK1){*(S2++)=*(S1--);}
  266.         *S2=' ';

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

  448.         //返回计算结果
  449.         return *S3;
  450. }

  452. /***************辅助函数群***************/
  453. //获取时间
  454. inline int getTIME(int i)
  455. {
  456.         time_t timep;  
  457.         struct tm *p;  
  458.         time(&timep);  
  459.         p=localtime(&timep);

  461.         switch(i){

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

  583.                 if(!isEND(*cp, ":$ \t\r\n\0")){
  584.                         *(op++)=*(cp++);
  585.                         continue;
  586.                 }

  588.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  589.                         char* tmp=VALUE[i];
  590.                         *op++='(';
  591.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  592.                         *op++=')';
  593.                         cp+=strlen(WORDS[i]);                       

  595.                 }else if((*cp==') && (i=Identify_KeyWords(cp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, endstring))!=-1){
  596.                        
  597.                         //准备临时容器
  598.                         char* tmp=(char*)calloc(16, sizeof(char));
  599.                         //解析变量名
  600.                         switch(i){
  601.                         case 8:
  602.                                 itoa(rand(), tmp, 10);
  603.                                 break;
  604.                         case 9:
  605.                         case 10:
  606.                         case 11:
  607.                         case 12:
  608.                         case 13:
  609.                         case 14:
  610.                                 itoa(getTIME(i), tmp, 10);
  611.                                 break;
  612.                         default:       
  613.                                 _gcvt(GLOBAL_VALUE[i], 10, tmp);
  614.                                 break;
  615.                         }
  616.                         *op++='(';
  617.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  618.                         *op++=')';
  619.                         free(tmp);
  620.                         cp+=GLOBAL_LLENS[i];
  621.                 }
  622.         }
  623.         *op='\0' ;
  624.         return (float)RevPolishCore(Line_Cache);
  625. }
  626. //赋值函数
  627. BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  628. {
  629.         char *gp=(char*)exp, *cp=gp;
  630.         while(!isEND(*cp, "=")){
  631.                 cp++;
  632.         }
  633.         cp++;

  635.         int i=-1;
  636.         if(gp[0]==':'){
  637.                 if(gp[1]==':'){return TRUE;}
  638.                 i=Identify_KeyWords(gp, PRO_NUM, WORDS, " \t=");
  639.                 itoa(EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring), VALUE[i], 10);
  640.         }else if(gp[0]=='){
  641.                 i=Identify_KeyWords(gp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, " \t=");
  642.                 GLOBAL_VALUE[i]=EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring);

  644.                 switch(i){
  645.                 case 3:
  646.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :16+(int)GLOBAL_VALUE[i]%16;
  647.                         STRGB* bgRGB=&LOGO_RGB[(int)GLOBAL_VALUE[i]];
  648.                         //创建画刷
  649.                         HBRUSH m_brush=CreateSolidBrush(bgRGB->VALUE);
  650.                         //填充背景
  651.                         FillRect(hDC1, lrRECT, m_brush);
  652.                         //删除画刷
  653.                         DeleteObject(m_brush);
  654.                         break;

  656.                         break;
  657.                 case 4:
  658.                         if(GLOBAL_VALUE[i]<0){GLOBAL_VALUE[i]=-GLOBAL_VALUE[i];}
  659.                         break;
  660.                 case 5:
  661.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :360+(int)GLOBAL_VALUE[i]%16;
  662.                         break;
  663.                 case 6:
  664.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%6 :(0-(int)GLOBAL_VALUE[i])%6;
  665.                         break;
  666.                 case 7:
  667.                         GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%255 :(0-(int)GLOBAL_VALUE[i])%255;
  668.                         break;
  669.                 default:
  670.                         break;
  671.                 }

  673.                
  674.         }
  675.         return TRUE;
  676. }
  677. //批量赋值
  678. BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  679. {
  680.         char *gp=(char*)Line;
  681.         while(isEND(*gp, ":$")){
  682.                 AssignMent(gp, PRO_NUM, WORDS, VALUE, endstring);
  683.                 gp++;
  684.                 while(!isEND(*gp, " \t\0")){
  685.                         gp++;
  686.                 }
  687.                 while(!isEND(*gp, ":$\0")){gp++;}
  688.                 if(*gp=='\0'){return TRUE;}
  689.         }
  690.         return TRUE;
  691. }
  692. //测FOR循环
  693. inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, int CYC)
  694. {
  695.         if(CYC ==0){return TRUE;}
  696.         int i=-1;
  697.         if((i=Identify_KeyWords(strtok((char*)Line, " "), PRO_NUM, WORDS, " \t")) !=-1){
  698.                 int staNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  699.                 int endNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  700.                 int var   =atoi(VALUE[i]);
  701.                 if(staNUM-endNUM<0){return (var<=endNUM)?TRUE:FALSE;}
  702.                 return (var>=endNUM)?TRUE:FALSE;
  703.         }
  704.         return FALSE;
  705. }
  706. //真值条件判断
  707. BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  708. {
  709.         char* op=cacheTain;
  710.         char* cp=(char*)exp;

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

  715.         if(isEND(*cp, "\r\n\0")){
  716.                 return TRUE;
  717.         }

  719.         char* Line_Cache=op;
  720.         int   i=-1, flag=0;

  722.         while(!isEND(*cp, " \t\r\n\0")){
  723.                 if      (*cp=='>'){
  724.                         flag+=4;
  725.                         *(op++)='-';
  726.                         *(op++)='(';
  727.                         cp++;
  728.                         continue;

  730.                 }else if(*cp=='<'){
  731.                         flag+=2;
  732.                         *(op++)='-';
  733.                         *(op++)='(';
  734.                         cp++;
  735.                         continue;

  737.                 }else if(*cp=='='){
  738.                         flag+=1;
  739.                         if(flag==1){
  740.                                 *(op++)='-';
  741.                                 *(op++)='(';
  742.                         }
  743.                         cp++;
  744.                         continue;

  746.                 }else if(*cp!=':'&& *cp!='){
  747.                         *(op++)=*(cp++);
  748.                         continue;
  749.                 }

  751.                 if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  752.                         char* tmp=VALUE[i];
  753.                         *op++='(';
  754.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  755.                         *op++=')';               
  756.                         cp+=strlen(WORDS[i]);                       

  758.                 }else if((*cp==') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  759.                         char* tmp=(char*)calloc(16, sizeof(char));
  760.                         if(i==8){
  761.                                 itoa(rand(), tmp, 10);

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

  766.                         }else{
  767.                                 _gcvt(GLOBAL_VALUE[i], 10, tmp);

  769.                         }
  770.                         *op++='(';
  771.                         while(*tmp!='\0'){*(op++)=*(tmp++);}
  772.                         *op++=')';
  773.                         cp+=GLOBAL_LLENS[i];
  774.                 }else{
  775.                         return FALSE;
  776.                 }

  778.         }
  779.         *(op++)=')';
  780.         *op='\0' ;
  781.         int m=(int)RevPolishCore(Line_Cache);

  783.         if(
  784.                 (m >0 && (flag==4||flag==5         )) ||
  785.                 (m <0 && (flag==2||flag==3         )) ||
  786.                 (m==0 && (flag==1||flag==3||flag==5||flag==0))
  787.         ){
  788.                 return TRUE;
  789.         }
  790.         return FALSE;
  791. }
  792. //批量真值判断
  793. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  794. {
  795.         char *gp=(char*)Line;
  796.         int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
  797.         if(li !=-1){gp+=LGC_LLENS[li];}

  799.         do{
  800.                 while(isEND(*gp, " \t")){
  801.                         gp++;
  802.                 }
  803.                 if(JudgMent(gp, PRO_NUM, WORDS, VALUE, endstring)){

  805.                         switch(li){
  806.                         case 0:
  807.                                 return FALSE;
  808.                         case 1:
  809.                                 break;
  810.                         case 2:
  811.                                 return TRUE;
  812.                         default:
  813.                                 return TRUE;
  814.                         }
  815.                 }else{
  816.                         switch(li){
  817.                         case 0:
  818.                                 break;
  819.                         case 1:
  820.                                 return FALSE;
  821.                         case 2:
  822.                                 break;
  823.                         default:
  824.                                 return FALSE;
  825.                         }
  826.                 }
  827.                 while(!isEND(*gp, " \t\0"  )){gp++;}
  828.                 if(*gp=='\0'){return TRUE;}
  829.                 while( isEND(*gp, " \t\r\n")){gp++;}

  831.         }while(*gp !='\0');
  832. }

  834. /***************绘图函数群***************/
  835. //隐藏光标
  836. BOOL SizeCursor(int size)
  837. {
  838.     CONSOLE_CURSOR_INFO cursor_info = {(DWORD)((size==0)?25:size), (size==0)?FALSE:TRUE};
  839.     return SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
  840. }
  841. //平滑画线函数，C++连接库
  842. void drawSMOOTHLINE(HDC hDC, int penWith, int mode, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2);
  843. //封闭区域填充函数，C++连接库
  844. void fillAREA(HDC hDC, BYTE alpha, STRGB* penRGB, float fill_X, float fill_Y);
  845. //快速画线函数
  846. BOOL drawLINE(HDC hDC, int d)
  847. {
  848.         float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
  849.         GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  850.         GLOBAL_VALUE[1]+=d * cos(GLOBAL_VALUE[2]*0.017453292519943);

  852.         //当为PU抬笔时，不做绘图
  853.         if(!penMODE){
  854.                 return FALSE;
  855.         }
  856.         STRGB* penRGB=&LOGO_RGB[(int)GLOBAL_VALUE[5]];
  857.         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]);
  858.         return TRUE;
  859. }
  860. //退步函数，实现BK
  861. void backWARD(int d)
  862. {
  863.         GLOBAL_VALUE[0]-=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  864.         GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  865. }
  866. //图形旋转
  867. int RotateDC(HDC hDC, int angle)  
  868. {
  869.         if(angle==0){return 1;}
  870.         XFORM Matrix;
  871.         double rad =-angle * 0.017453292519943;
  872.         Matrix.eM11 = (float)cos(rad);  
  873.         Matrix.eM12 = (float)sin(rad);  
  874.         Matrix.eM21 =-(float)sin(rad);
  875.         Matrix.eM22 = (float)cos(rad);  
  876.         Matrix.eDx  = (float)(GLOBAL_VALUE[0]-cos(rad)*GLOBAL_VALUE[0]+sin(rad)*GLOBAL_VALUE[1]);  
  877.         Matrix.eDy  = (float)(GLOBAL_VALUE[1]-cos(rad)*GLOBAL_VALUE[1]-sin(rad)*GLOBAL_VALUE[0]);
  878.         SetGraphicsMode(hDC, GM_ADVANCED);
  879.         SetWorldTransform(hDC, &Matrix);
  880.         return 0;
  881. }

  883. /***************解析函数群***************/
  884. //脚本解析函数
  885. int FileScript(char* prossName, int PRO_NUM, char** PRO_VALUE)
  886. {       
  887.         //初始参数，其中KLevel为当前循环层号；
  888.         int i=0, j=0, KLevel=0, SN=-1, Line_LEN=0, fcolor=-1, BASE_VAR_NUM=PRO_NUM;
  889.         char* prepos=NULL;

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

  894.         //初始化开关参数，SFLAG[0]==1开始；
  895.         char* SFLAG=(char*)calloc(8, sizeof(char));
  896.         SFLAG[2]=-1;

  898.         //初始化循环参量数组
  899.         int*   FORI_CYCL=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  900.         int*   FORI_LNUM=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  901.         char** FORI_FTEL=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  902.         char** FORI_FEND=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  903.         BOOL*  FORI_IFOT=(BOOL *)calloc(LOOP_LEVELS,   sizeof(BOOL ));

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

  908.         //辅助行指针
  909.         char* Line;

  911.         //辅助流指针
  912.         char* tmpfp=tRAM;

  914.         while(*tmpfp !='\0'){
  915.                
  916.                 //记录位置
  917.                 char* prepos=tmpfp;

  919.                 //指针置换
  920.                 Line=LCache;

  922.                 while(*tmpfp !='\n' && *tmpfp !='\0'){
  923.                         *(Line++)=*(tmpfp++);
  924.                 }
  925.                 if(*tmpfp =='\n'){*(Line++)=*(tmpfp++);}
  926.                  *Line='\0';
  927.                 //指针回首
  928.                 Line=LCache;
  929.                
  930.                 //行计数器
  931.                 i++;
  932.                
  933.                 //过滤行TAB缩进或前空格
  934.                 while(*Line=='\t'|| *Line==' '){Line++;}

  936.                 //过滤空行或行注释
  937.                 if(
  938.                         (Line[0]=='\r')                ||
  939.                         (Line[0]=='\n')                ||
  940.                         (Line[0]=='/' && Line[1]=='/')
  941.                 ){
  942.                         continue;
  943.                 }

  945.                 //过滤段间注释
  946.                 if(
  947.                         (Line[0]=='/' &&Line[1]=='*')
  948.                 ){
  949.                         SFLAG[0]=0;
  950.                         continue;
  951.                        
  952.                 }else if(
  953.                         (Line[0]=='*' &&Line[1]=='/')
  954.                 ){
  955.                         SFLAG[0]=1;
  956.                         continue;
  957.                        
  958.                 }

  960.                 //识别子过程名
  961.                 if(
  962.                         (isEND(Line[2], " \t\r\n\0") )  &&
  963.                         (Line[0]=='T' || Line[0]=='t')  &&
  964.                         (Line[1]=='O' || Line[1]=='o')

  966.                 ){
  967.                         Line+=2;
  968.                         //过滤TO后TAB缩进，或TO后空格
  969.                         while(*Line=='\t'|| *Line==' '){Line++;}               
  970.                         if(isKEY(Line, prossName, " \t\r\n\0")){
  971.                                 SFLAG[0]=1;
  972.                                 ARGS(Line, PRO_WORDS, PRO_NUM, i, Line);
  973.                         }else{
  974.                                 SFLAG[0]=0;
  975.                         }
  976.                         continue;
  977.                 }

  979.                 //开始开关未打开，或遇到空行
  980.                 if(
  981.                         SFLAG[0]==0                    ||
  982.                         isEND(Line[0], "\r\n[")

  984.                 ){continue;}

  986.                 //IF...ELIF连带性分析
  987.                 if(
  988.                         (FORI_IFOT[KLevel+1]       )   &&
  989.                         (Line[0]!='E'&&Line[0]!='e')   &&
  990.                         (Line[1]!='L'&&Line[1]!='l')   &&
  991.                         (Line[2]!='I'&&Line[2]!='i')   &&
  992.                         (Line[3]!='F'&&Line[3]!='f')

  994.                 ){
  995.                         FORI_IFOT[KLevel+1]=FALSE;
  996.                 }

  998.                 //解析循环结束标签，循环加速
  999.                 if(Line[0]==']'){
  1000.                         if(KLevel>SFLAG[1]){
  1001.                                 if(FORI_CYCL[KLevel] <0){
  1002.                                         int tpadd=EvalLine(Line+1, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1003.                                         if(tpadd==0){tpadd=1;}
  1004.                                         itoa(atoi(PRO_VALUE[0-FORI_CYCL[KLevel]])+tpadd, PRO_VALUE[0-FORI_CYCL[KLevel]], 10);                               
  1005.                                 }
  1006.                                 if(FORI_FEND[KLevel]==NULL){FORI_FEND[KLevel]=tmpfp;}
  1007.                                 tmpfp=FORI_FTEL[KLevel];
  1008.                                 i=FORI_LNUM[KLevel]-1;

  1010.                         }else{
  1011.                                 FORI_FTEL[KLevel]=NULL;
  1012.                                 FORI_FEND[KLevel]=NULL;
  1013.                                 FORI_CYCL[KLevel]=0;
  1014.                                 SFLAG[1]=0;
  1015.                         }
  1016.                         KLevel--;
  1017.                         continue;

  1019.                 }else{
  1020.                         int ki =Identify_KeyWords(Line, CYC_SIZE, (char**)CYC_WORDS, " \t\r\n\0");
  1021.                         if( ki!=-1){
  1022.                                 Line=passNULL(Line+CYC_LLENS[ki]);
  1023.                                 KLevel++;
  1024.                                 //解析循环
  1025.                                 if(
  1026.                                         ki==0 && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n") ||
  1027.                                         ki==1 && FORI_CYCL[KLevel]<EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"   )         ||
  1028.                                         ki==2 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")                        ||
  1029.                                         ki==3 && isForTrue(Line, PRO_NUM, PRO_WORDS, PRO_VALUE,  FORI_CYCL[KLevel])                           ||
  1030.                                         ki==4 && (FORI_IFOT[KLevel]) && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")

  1032.                                 ){
  1033.                                         if( FORI_FTEL[KLevel]==NULL ){
  1034.                                                 FORI_FTEL[KLevel]=prepos;
  1035.                                                 FORI_LNUM[KLevel]=i+1;
  1036.                                                 if(ki==3){
  1037.                                                         char *tp1, *tp2;
  1038.                                                         //提取瞬时变量名
  1039.                                                         if((tp1=strtok(Line, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  1040.                                                         PRO_WORDS[PRO_NUM]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
  1041.                                                         strcpy(PRO_WORDS[PRO_NUM], tp1);
  1042.                                                         //提取始步
  1043.                                                         if((tp2=strtok(NULL, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  1044.                                                         PRO_VALUE[PRO_NUM]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));
  1045.                                                         itoa(EvalLine(tp2, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"), PRO_VALUE[PRO_NUM], 10);
  1046.                                                         FORI_CYCL[KLevel] =0-PRO_NUM;
  1047.                                                         PRO_NUM++;

  1049.                                                 }
  1050.                                                 if(ki==0 || ki==4){
  1051.                                                         FORI_IFOT[KLevel]=FALSE;
  1052.                                                 }
  1053.                                         }

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

  1057.                                 }else{
  1058.                                         if((ki==0||ki==4) && FORI_CYCL[KLevel]==0){
  1059.                                                 FORI_IFOT[KLevel]=TRUE;
  1060.                                         }
  1061.                                         if(FORI_FEND[KLevel] !=NULL){
  1062.                                                 if(FORI_CYCL[KLevel] <0){
  1063.                                                         free(PRO_WORDS[PRO_NUM]);
  1064.                                                         free(PRO_VALUE[PRO_NUM]);
  1065.                                                         PRO_NUM-=1;
  1066.                                                 }
  1067.                                                 tmpfp=FORI_FEND[KLevel];
  1068.                                                 i=FORI_LNUM[KLevel]-1;
  1069.                                                 FORI_FTEL[KLevel]=NULL;
  1070.                                                 FORI_FEND[KLevel]=NULL;
  1071.                                                 FORI_CYCL[KLevel]=0;
  1072.                                                 KLevel--;
  1073.                                         }else{
  1074.                                                 SFLAG[1]=KLevel;
  1075.                                         }
  1076.                                 }
  1077.                                 continue;
  1078.                         }
  1079.                 }

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

  1084.                 //变量赋值
  1085.                 if(Line[0]==':'||Line[0]=='){
  1086.                         MoreAssignMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1087.                         continue;
  1088.                 }

  1090.                 //调用子过程
  1091.                 if(Line[0]=='.'){
  1092.                         //定义过程传参容器
  1093.                         char** PAR_VALUE=(char**)calloc(LOOP_LEVELS, sizeof(char*));
  1094.                         int PAR_NUM=ARGP(Line, PAR_VALUE, PRO_NUM, PRO_WORDS, PRO_VALUE);
  1095.                         FileScript(Line+1, PAR_NUM, PAR_VALUE);
  1096.                         free(PAR_VALUE);
  1097.                         continue;
  1098.                 }

  1100.                 //过滤回车符
  1101.                 if((Line_LEN=strlen(Line))==2){
  1102.                         continue;
  1103.                 }else{
  1104.                         Line[Line_LEN-2]='\0';
  1105.                 }

  1107.                 //解析命令行
  1108.                 if((SN=Identify_KeyWords(Line, KEY_SIZE, (char**)KEY_WORDS, " \t\r\n\0")) !=-1){
  1109.                         Line=passNULL(Line+KEY_LLENS[SN]);
  1110.                 }else{
  1111.                         printf("[%d]:EEEOR LINE "%s"\n", i, Line);
  1112.                         exit(1);
  1113.                 }
  1114.                 switch(SN)
  1115.                 {
  1116.                 case  0:
  1117.                         //FD
  1118.                         drawLINE(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1119.                         break;
  1120.                 case  1:
  1121.                         //BK
  1122.                         backWARD(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1123.                         break;
  1124.                 case  2:
  1125.                         //LT
  1126.                         GLOBAL_VALUE[2]-=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1127.                         break;
  1128.                 case  3:
  1129.                         //RT
  1130.                         GLOBAL_VALUE[2]+=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1131.                         break;
  1132.                 case  4:
  1133.                         //PU
  1134.                         penMODE=FALSE;
  1135.                         break;
  1136.                 case  5:
  1137.                         //PD
  1138.                         if(SFLAG[2] !=-1){
  1139.                                 GLOBAL_VALUE[5]=SFLAG[2];
  1140.                                 SFLAG[2] =-1;
  1141.                         }
  1142.                         penMODE=TRUE;
  1143.                         break;
  1144.                 case  6:
  1145.                         //PE
  1146.                         if(SFLAG[2] ==-1){
  1147.                                 SFLAG[2]=GLOBAL_VALUE[5];
  1148.                                 GLOBAL_VALUE[5]=GLOBAL_VALUE[3];
  1149.                         }
  1150.                         break;
  1151.                 case  7:
  1152.                         //CLEAN
  1153.                         InvalidateRect(hCMD,NULL,FALSE);
  1154.                         break;
  1155.                 case  8:
  1156.                         //ECHO, 输出字符串
  1157.                         printf("%s\n", Line);
  1158.                         break;
  1159.                 case  9:
  1160.                         //HOME
  1161.                         GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;
  1162.                         break;
  1163.                 case 10:
  1164.                         //STOP
  1165.                         return 0;
  1166.                 case 11:
  1167.                         //EXIT
  1168.                         exit(0);
  1169.                 case 12:
  1170.                         //FILL
  1171.                         if((fcolor=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n")) !=-1){
  1172.                                 fillAREA(hDC,  (BYTE)((int)GLOBAL_VALUE[7]&0xFF), &LOGO_RGB[fcolor],  lrRECT->right/2+GLOBAL_VALUE[0],  lrRECT->bottom/2-GLOBAL_VALUE[1]);
  1173.                         }
  1174.                         break;
  1175.                 case 13:
  1176.                         //PAUSE
  1177.                         getch();
  1178.                         break;
  1179.                 case 14:
  1180.                         //WAIT
  1181.                         Sleep(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1182.                         break;
  1183.                 case 15:
  1184.                         //ROTE
  1185.                         //将内存画布拷屏到CMD窗口
  1186.                         //BitBlt(hDC,0,0,WINDOW_WIDTH,WINDOW_HEIGHT, hDC1,0,0,SRCCOPY);
  1187.                         RotateDC(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1188.                         break;
  1189.                 case 16:
  1190.                         //MEMUSE，开辟内存画布
  1191.                         if(!memMODE){
  1192.                                 BitBlt(hDC3,0,0,lrRECT->right,lrRECT->bottom, hDC1,0,0,SRCCOPY);
  1193.                                 memMODE=TRUE;
  1194.                         }
  1195.                         BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1196.                         hDC=hDC2;
  1197.                         break;
  1198.                 case 17:
  1199.                         //MEMSEE，展示内存画布
  1200.                         BitBlt(hDC1,0,0,lrRECT->right,lrRECT->bottom, hDC2,0,0,SRCCOPY);
  1201.                         BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1202.                         break;
  1203.                 case 18:
  1204.                         //MEMOUT，丢弃内存画布
  1205.                         memMODE=FALSE;
  1206.                         hDC=hDC1;
  1207.                         break;
  1208.                 case 19:
  1209.                         //EVAL，表达式计算输出
  1210.                         printf("%.12g\n", EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1211.                         break;
  1212.                 default:
  1213.                         printf("[%d]:EEEOR LINE 。\n", i);
  1214.                         exit(1);
  1215.                         break;
  1216.                 }
  1217.         }
  1218.         free(PRO_WORDS);
  1219.         free(SFLAG);
  1220.         free(FORI_CYCL);
  1221.         free(FORI_LNUM);
  1222.         free(FORI_FTEL);
  1223.         free(FORI_FEND);
  1224.         free(FORI_IFOT);
  1225.         free(LCache);
  1226.         return 0;
  1227. }

  1229. /*************MAIN主函数入口*************/
  1230. int main(int argc, char** argv)
  1231. {
  1232.         if(argc==2){

  1234.                 //隐藏光标
  1235.                 SizeCursor(0);

  1237.                 //初始化变量
  1238.                 int fsize=0;
  1239.                
  1240.                 //初始化随机种子
  1241.                 srand((unsigned)time(NULL));

  1243.                 //读文件流
  1244.                 FILE* fp;
  1245.                 if( (fp=fopen(argv[1], "rb"))==NULL ){
  1246.                         fputs("Failed to read file.", stdout);
  1247.                         return 2;
  1248.                 }

  1250.                 //测量尺寸
  1251.                 fseek(fp, 0, SEEK_END);
  1252.                 fsize=ftell(fp);

  1254.                 //超过1M的脚本，拒绝执行
  1255.                 if(fsize > 1*1024*1024){
  1256.                         fputs("File size is too large, out of memory.", stdout);
  1257.                         return 1;

  1259.                 //小于10字节的，拒绝执行
  1260.                 }else if(fsize < 10){
  1261.                         fputs("File size is too small,  in of memory.", stdout);
  1262.                         return 1;
  1263.                 }

  1265.                 //指针复原
  1266.                 fseek(fp, 0, SEEK_SET);
  1267.                 //读入内存
  1268.                 tRAM=(char*)calloc(fsize+3, sizeof(char));
  1269.                 tRAM[fsize]='\r', tRAM[fsize+1]='\n', tRAM[fsize+2]='\0';
  1270.                 fread(tRAM, fsize, 1, fp);
  1271.                 //释放文件
  1272.                 fclose(fp);
  1273.                
  1274.                 //获取CMD窗口句柄
  1275.                 hCMD=GetConsoleWindow();
  1276.                 //获取CMD窗口大小
  1277.                 lrRECT=&winRECT;
  1278.                 GetClientRect(hCMD, lrRECT);
  1279.                
  1280.                 //CMD画布
  1281.                 hDC1=GetDC(hCMD);
  1282.                 HBITMAP hBitmap1=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1283.                 SelectObject(hDC1, hBitmap1);
  1284.        
  1285.                 //内存画布
  1286.                 hWND2=NULL;
  1287.                 hDC2=CreateCompatibleDC(GetDC(hWND2));
  1288.                 HBITMAP hBitmap2=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1289.                 SelectObject(hDC2, hBitmap2);

  1291.                 //辅助画布
  1292.                 hWND3=NULL;
  1293.                 hDC3=CreateCompatibleDC(GetDC(hWND3));
  1294.                 HBITMAP hBitmap3=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1295.                 SelectObject(hDC3, hBitmap3);

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

  1300.                 //主DC选择CMD画布
  1301.                 hDC=hDC1;

  1303.                 //寻找主函数入口点
  1304.                 FileScript("MAIN", 1, PAR_VALUE);
  1305.                
  1306.                 //释放DC
  1307.                 ReleaseDC(NULL, hDC3);
  1308.                 ReleaseDC(NULL, hDC2);
  1309.                 ReleaseDC(hCMD, hDC1);
  1310.                 DeleteDC(hDC3);
  1311.                 DeleteDC(hDC2);
  1312.                 DeleteDC(hDC1);       
  1313.                 DeleteObject(hBitmap3);
  1314.                 DeleteObject(hBitmap2);
  1315.                 DeleteObject(hBitmap1);
  1316.                 //释放内存
  1317.                 free(PAR_VALUE);
  1318.                 free(tRAM);
  1319.                 return 0;
  1320.         }

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

点评

落叶
好家伙，这么长，等我把这个计算器完善了，就开始用c 写程序，正好拿你的程序练手！  发表于 2017-1-13 10:46
毋因群疑而阻独见　　毋任己意而废人言
毋私小惠而伤大体　　毋借公论以快私情
回复 支持 反对

使用道具 举报

1234
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 欢迎注册

本版积分规则

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

GMT+8, 2024-12-18 12:13 , Processed in 0.044486 second(s), 18 queries .

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

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