Board logo

标题: CLGO脚本语言 [打印本页]

作者: happy886rr    时间: 2017-1-10 21:00     标题: CLGO脚本语言

C、C++、Java、js都是别人发明的语言,感觉不是很合自己的胃口。为什么不按照自己的口味,创造一个语法规则,建造一门脚本语言。于是、花费少许时间,CLGO语言问世了,有很深的LOGO语言的影子,当然也有很深的C语言的影子。没办法,if、for、while这些关键词我总不能换成别的词吧,就好比三角函数sin我总不能用S来表示吧,个别关键词只是同名,但这绝对是门独立的语言与其他语言的工作原理完全不一样。另外这些关键词随着加载的库的不同可以发挥不同的作用,如果加载了正则库,那他就是类似gawk的正则脚本,加载了gdi他就是一门绘图脚本语言,加载了文件流库,那就是文本处理语言类似sed,加载了其他库就具有其他的功能,加载了按键模拟那就是类似ahk的脚本语言。初版默认只加载绘图库,也是为了压缩包能控制在25KB以下。
CLGO SCRIPT
_____________________________________________________________________________
CLGO SCRIPT控制台绘图脚本语言,具有类似C语言的函数定义、函数调用、递归、循环、
逻辑判断等语法功能。在内存中解释运行,速度迅猛。同时,CLGO语言具有非常简单的
语法结构、关键词、非常适合快速上手。简短的语句就能绘出美妙的画面。
_____________________________________________________________________________
下载:[attach]10383[/attach]










命令:
-----------------------------------------------------------------------------
关键词(不区分大小写)        中文释义                    用法说明
-----------------------------------------------------------------------------
___________________________________全局变量__________________________________
$PENX                       横坐标
$PENY                       纵坐标
$PENW                       笔宽                        取值0-255
$PENC                       笔色                        取值0-15
$PENB                       笔背景色                    取值0-15
$PENS                       笔光滑度                    取值0-6
$PENA                       笔透明度                    取值0-255
$HEADING                    笔头角度                    取值0-360
$RANDOM                     随机数                      取值随机
$YEAR、$MONTH、$DAY、$HOUR、$MINUTE、$SECOND            时间变量
$TP0 - $TP9                 用户变量                    供用户使用的全局变量
___________________________________绘图命令___________________________________
FD                          前进                        FD 100    //前进100步
BK                          后退                        BK 100    //后退100步
LT                          左转                        LT 90     //左转 90度
RT                          右转                        RT 90           //右转 90度
PU                          抬笔                        PU        //抬笔
PD                          落笔                        PD        //落笔
PE                          笔擦                        PE        //笔擦
HOME                        回家                        笔归位至中央、笔头朝上
CLEAN                       清图                        清除绘图区
___________________________________语句命令___________________________________
IF~ELIF                     如果~再则                  条件指令
REPEAT                      重复                        RP 4[循环体]
WHILE                       当                          WHILE 条件[循环体]
FOR                         循环                        FOR 变量 初值 终值[循环体]步长
___________________________________语句词语___________________________________
NOT                         逻辑否
AND                         逻辑与
OR                          逻辑或
___________________________________扩展命令___________________________________
PAUSE                       暂停                        请按任意键继续
WAIT                        等待                        WAIT 3000 //等待3秒
STOP                        停止                        停止子过程
EXIT                        退出                        退出整个脚本
FILL                        颜色填充                    用颜色填充笔所在的封闭区域
ECHO                        显示字符                    ECHO 你好
EVAL                        计算表达式值                EVAL sin(pi/6)+cos(pi/3)
READ                        获取按键                    
OVAL                        画椭圆                      OVAL 100 50  //画横向半径为100,纵向半径为50的椭圆
RECT                        画矩形                      RECT 100 50  //画横向长度为100,纵向长度为50的矩形
ROTE                        旋转                        ROTE 30   //画布旋转30度
MEMUSE                      启用内存画布
MEMSEE                      查看内存画布
MEMOUT                      抛弃内存画布
-----------------------------------------------------------------------------


释符:          
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
行注释  //        行内容
段注释  /*     
                段内容
        */
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


数学类关键词(必须小写):
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
常数类
        pi    3.1415926535897932
        e     2.7182818284590452
通用类
        round 四舍五入
        floor 整取
        abs   绝对值
        ceil  向上舍入
        deg   角度转弧度
        exp   e的次幂
        sqrt  开方
        fac   阶乘
        lg    常用对数,以10为底
        ln    自然对数
        +     加
        -     减
        *     乘
        /     除
        %     取余数
        ^     次方
        !     阶乘

三角函数类
        sin、cos、tan   
        arcsin、arccos、arctan
双曲函数类
        sinh、cosh、tanh
        arcsinh、arccosh、arctanh
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


十六色系:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        {  0,  0,  0,RGB(  0,  0,  0)}, //黑色
        {  0,  0,255,RGB(  0,  0,255)}, //蓝色
        {  0,255,  0,RGB(  0,255,  0)}, //绿色
        {  0,255,255,RGB(  0,255,255)}, //青色
        {255,  0,  0,RGB(255,  0,  0)}, //红色
        {238,130,238,RGB(238,130,238)}, //紫兰
        {165, 42, 42,RGB(165, 42, 42)}, //棕色
        {211,211,211,RGB(211,211,211)}, //浅灰
        {169,169,169,RGB(169,169,169)}, //深灰
        {173,216,230,RGB(173,216,230)}, //淡蓝
        {144,238,144,RGB(144,238,144)}, //浅绿
        {224,255,255,RGB(224,255,255)}, //淡青
        {248, 29, 56,RGB(248, 29, 56)}, //亮红
        {255,  0,255,RGB(255,  0,255)}, //洋紫
        {255,255,  0,RGB(255,255,  0)}, //黄色
        {255,255,255,RGB(255,255,255)}  //白色
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


核心代码
  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. while(*op!='\0'){
  122. switch(*op){
  123. case ' ' :
  124. case '\t':
  125. case '\r':
  126. case '\n':
  127. //过滤空字符
  128. op++;
  129. continue;
  130. case 'a':
  131. case 'b':
  132. case 'c':
  133. case 'd':
  134. case 'e':
  135. case 'f':
  136. case 'g':
  137. case 'h':
  138. case 'i':
  139. case 'j':
  140. case 'k':
  141. case 'l':
  142. case 'm':
  143. case 'n':
  144. case 'o':
  145. case 'p':
  146. case 'q':
  147. case 'r':
  148. case 's':
  149. case 't':
  150. case 'u':
  151. case 'v':
  152. case 'w':
  153. case 'x':
  154. case 'y':
  155. case 'z':
  156. //识别数学函数关键词
  157. key=(char**)MATH_WORDS;
  158. while(*key !=NULL){
  159. cp=op, kp=*key;
  160. //比对关键词字母
  161. while(*cp==*kp && *kp!='\0'){
  162. cp++, kp++;
  163. }
  164. //验证关键词结尾
  165. if((*cp<'a'||*cp>'z') && (*kp=='\0')){
  166. op=cp;
  167. break;
  168. }
  169. key++;
  170. }
  171. //构建伪双目
  172. if(*key !=NULL){
  173. *(S2++)='.';
  174. *(S2++)=' ';
  175. //伪双目入栈
  176. while('A'<=(*S1) && (*S1)<='Z'){
  177. *(S2++)=*(S1--);
  178. }
  179. *(++S1)=key-(char**)MATH_WORDS+65;
  180. continue;
  181. }else{
  182. //无法识别的数学函数
  183. fputs("Unrecognized math function\n", stderr);
  184. exit(1);
  185. }
  186. break;
  187. case '(':
  188. *(++S1)=*op;
  189. if(*(op+1)=='-' || *(op+1)=='+'){
  190. *(S2++)='0', *(S2++)=' ';
  191. }
  192. break;
  193. case ')':
  194. while(*S1!='(')
  195. {
  196. *(S2++)=*(S1--);
  197. }
  198. //舍弃'('
  199. S1--;
  200. break;
  201. case '+':
  202. case '-':
  203. while(S1!=STACK1 && *S1!='(')
  204. {
  205. *(S2++)=*(S1--);
  206. }
  207. *(++S1)=*op;
  208. break;
  209. case '^':
  210. //指数符
  211. while('A'<=(*S1) && (*S1)<='Z')
  212. {
  213. *(S2++)=*(S1--);
  214. }
  215. *(++S1)=*op;
  216. break;
  217. case '!':
  218. //阶乘符
  219. *(S2++)=*op;
  220. break;
  221. case '%':
  222. case '*':
  223. case '/':
  224. while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^'){
  225. *(S2++)=*(S1--);
  226. }
  227. *(++S1)=*op;
  228. break;
  229. default :
  230. if((*op<'0' || *op>'9') && (*op!='.')){
  231. //无法识别的运算符
  232. fputs("Unrecognized operator\n", stderr);
  233. exit(1);
  234. }
  235. //浮点数入栈
  236. while(('0'<=*op && *op<='9') ||*op=='.'){
  237. *(S2++)=*(op++);
  238. }
  239. op--;
  240. *(S2++)=' ';
  241. break;
  242. }
  243. op++;
  244. }
  245. //收尾逆波兰
  246. while(S1 !=STACK1){*(S2++)=*(S1--);}
  247. *S2=' ';
  248. //计算逆波兰
  249. op=STACK2;
  250. while(*op!=' '){
  251. switch(*op){
  252. case 'A':
  253. *S3=2.7182818284590452;
  254. break;
  255. case 'B':
  256. *S3=3.1415926535897932;
  257. break;
  258. case 'C':
  259. if(*S3 <0){
  260. //负数没有平方根
  261. fputs("Negative numbers have no square root\n", stderr);
  262. exit(1);
  263. }
  264. *(S3-1)=sqrt(*S3);
  265. S3--;
  266. break;
  267. case 'D':
  268. if(*S3 <0){
  269. //负数没有对数
  270. fputs("Negative numbers are not logarithmic\n", stderr);
  271. exit(1);
  272. }
  273. *(S3-1)=log10(*S3);
  274. S3--;
  275. break;
  276. case 'E':
  277. if(*S3 <0){
  278. //负数没有自然对数
  279. fputs("Negative numbers have no natural logarithms\n", stderr);
  280. exit(1);
  281. }
  282. *(S3-1)=log(*S3);
  283. S3--;
  284. break;
  285. case 'F':
  286. *(S3-1)=sin(*S3);
  287. S3--;
  288. break;
  289. case 'G':
  290. *(S3-1)=cos(*S3);
  291. S3--;
  292. break;
  293. case 'H':
  294. if(*S3==3.1415926535897932/2){
  295. //π/2没有正切值
  296. fputs("The pi/2 has no tangent\n", stderr);
  297. exit(1);
  298. }
  299. *(S3-1)=tan(*S3);
  300. S3--;
  301. break;
  302. case 'I':
  303. *(S3-1)=asin(*S3);
  304. S3--;
  305. break;
  306. case 'J':
  307. *(S3-1)=acos(*S3);
  308. S3--;
  309. break;
  310. case 'K':
  311. *(S3-1)=atan(*S3);
  312. S3--;
  313. break;
  314. case 'L':
  315. *(S3-1)=(*S3)*3.1415926535897932/180.0;
  316. S3--;
  317. break;
  318. case 'M':
  319. *(S3-1)=(*S3<0)?(-(*S3)):(*S3);
  320. S3--;
  321. break;
  322. case 'N':
  323. *(S3-1)=round(*S3);
  324. S3--;
  325. break;
  326. case 'O':
  327. *(S3-1)=floor(*S3);
  328. S3--;
  329. break;
  330. case 'P':
  331. *(S3-1)=ceil(*S3);
  332. S3--;
  333. break;
  334. case 'Q':
  335. *(S3-1)=exp(*S3);
  336. S3--;
  337. break;
  338. case 'R':
  339. *(S3-1)=sinh(*S3);
  340. S3--;
  341. break;
  342. case 'S':
  343. *(S3-1)=cosh(*S3);
  344. S3--;
  345. break;
  346. case 'T':
  347. *(S3-1)=tanh(*S3);
  348. S3--;
  349. break;
  350. case 'U':
  351. *(S3-1)=asinh(*S3);
  352. S3--;
  353. break;
  354. case 'V':
  355. *(S3-1)=acosh(*S3);
  356. S3--;
  357. break;
  358. case 'W':
  359. *(S3-1)=atanh(*S3);
  360. S3--;
  361. break;
  362. case '+':
  363. *(S3-1)+=*S3;
  364. S3--;
  365. break;
  366. case '-':
  367.        *(S3-1)-=*S3;
  368.        S3--;
  369. break;
  370. case '*':
  371. *(S3-1)*=*S3;
  372. S3--;
  373. break;
  374. case '%':
  375. case '/':
  376. if(*S3 !=0){
  377. if(*op=='%'){
  378. //取余数
  379. *(S3-1)=(int)*(S3-1) % (int)*S3;
  380. }else{
  381. *(S3-1)/=*S3;
  382. }
  383. }else{
  384. //除数不能为零
  385. fputs("Divisor is zero error\n", stderr);
  386. exit(1);
  387. }
  388. S3--;
  389. break;
  390. case '^':
  391. if(*(S3-1)==0 && *S3<0){
  392. //除数不能为零
  393. fputs("Function pow's divisor is zero error\n", stderr);
  394. exit(1);
  395. }
  396. *(S3-1)=pow(*(S3-1), *S3);
  397. S3--;
  398. break;
  399. case '!':
  400. if(*S3 <0){
  401. //负数没有阶乘
  402. fputs("Negative numbers have no factorial\n", stderr);
  403. exit(1);
  404. }
  405. *S3=fact((long long)(*S3));
  406. break;
  407. default :
  408. //字符串转浮点
  409. di=0, ni=1;
  410. while('0'<=*op && *op<='9'){
  411. di=10*di+(*op)-'0';
  412. op++;
  413. }
  414. if(*op=='.'){
  415. op++;
  416. while('0'<=*op && *op<='9'){
  417. di=10*di+(*op)-'0';
  418. op++, ni*=10;
  419. }
  420. }
  421. *(++S3)=di/ni;
  422. break;
  423. }
  424. op++;
  425. }
  426. //返回计算结果
  427. return *S3;
  428. }
  429. /***************辅助函数群***************/
  430. //获取时间
  431. inline int getTIME(int i)
  432. {
  433. time_t timep;  
  434. struct tm *p;  
  435. time(&timep);  
  436. p=localtime(&timep);
  437. switch(i){
  438. case  9:
  439. return p->tm_year+1900;
  440. case 10:
  441. return p->tm_mon+1;
  442. case 11:
  443. return p->tm_mday;
  444. case 12:
  445. return p->tm_hour;
  446. case 13:
  447. return p->tm_min;
  448. case 14:
  449. return p->tm_sec;
  450. default:
  451. return -1;
  452. }
  453. return -1;
  454. }
  455. //测空字符
  456. inline BOOL isEND(const char c,const char* endstring)
  457. {
  458. if(c=='\0'){return TRUE;}
  459. while(*endstring!='\0'){
  460. if(c==*(endstring++)){
  461. return TRUE;
  462. }
  463. }
  464. return FALSE;
  465. }
  466. //过滤行TAB缩进或前空格
  467. char* passNULL(char* Str)
  468. {
  469. if(Str!=NULL){
  470. while(*Str=='\t' ||*Str==' '){Str++;}
  471. }
  472. return Str;
  473. }
  474. //识别关键字
  475. BOOL isKEY(char* Line, char* key, const char* endstring)
  476. {
  477. char *op=Line, *kp=key;
  478. while(*kp!='\0'){
  479. if((('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)){break;}
  480. op++;kp++;
  481. }
  482. if(
  483. *kp=='\0' &&
  484. isEND(*op, endstring)
  485. ){
  486. return TRUE;
  487. }
  488. return FALSE;
  489. }
  490. //切分变量名
  491. int ARGS(char* Str, char** WORDS, int PRO_NUM, int LineNUM, char* Line)
  492. {
  493. if(PRO_NUM==0){return 0;}
  494. //过滤回车符
  495. Str[strlen(Str)-2]='\0';
  496. int  i=0;
  497. char* lp=Str;
  498. char* tp;
  499. strtok(lp, " ");
  500. while(i<PRO_NUM){
  501. WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
  502. if((tp=strtok(NULL, " "))==NULL){break;}
  503. strcpy(WORDS[i++], tp);
  504. }
  505. if(i==0){WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char)); return 1;}
  506. if(i<PRO_NUM){fprintf(stdout, "[%d]:Missing Parameter %s\n", LineNUM, Line);exit(1);}
  507. return i;
  508. }
  509. //切分参数
  510. int ARGP(char* Str, char** WORDS, int PRO_NUM, char** PRO_WORDS, char** PRO_VALUE)
  511. {
  512. int i=-1;
  513. char* tp;
  514. strtok(Str, " ");
  515. while((tp=strtok(NULL, " "))!=NULL && *tp!='\r'){
  516. WORDS[++i]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));
  517. itoa(EvalLine(tp, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"), WORDS[i], 10);
  518. }
  519. if(i==-1){WORDS[++i]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));}
  520. return i+1;
  521. }
  522. //关键词解析函数
  523. int Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring)
  524. {
  525. int i, SN;
  526. for(SN=0; SN<SENSITIVE_NUM; SN++){
  527. char *op=Line, *kp=WORDS[SN];
  528. while(*kp!='\0'){
  529. if(
  530. (('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)
  531. ){
  532. break;
  533. }
  534. op++;kp++;
  535. }
  536. if(
  537. *kp=='\0' &&
  538. isEND(*op, endstring)
  539. ){
  540. return SN;
  541. }
  542. }
  543. return -1;
  544. }
  545. //计算含变量表达式函数
  546. float EvalLine(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  547. {
  548. char* op=cacheTain;
  549. char* cp=(char*)exp;
  550. char* Line_Cache=op;
  551. int   i=-1;
  552. while(!isEND(*cp, " \t\r\n\0")){
  553. if(!isEND(*cp, ":$ \t\r\n\0")){
  554. *(op++)=*(cp++);
  555. continue;
  556. }
  557. if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  558. char* tmp=VALUE[i];
  559. *op++='(';
  560. while(*tmp!='\0'){*(op++)=*(tmp++);}
  561. *op++=')';
  562. cp+=strlen(WORDS[i]);
  563. }else if((*cp=='$') && (i=Identify_KeyWords(cp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, endstring))!=-1){
  564. //准备临时容器
  565. char* tmp=(char*)calloc(16, sizeof(char));
  566. //解析变量名
  567. switch(i){
  568. case 8:
  569. itoa(rand(), tmp, 10);
  570. break;
  571. case 9:
  572. case 10:
  573. case 11:
  574. case 12:
  575. case 13:
  576. case 14:
  577. itoa(getTIME(i), tmp, 10);
  578. break;
  579. default:
  580. _gcvt(GLOBAL_VALUE[i], 10, tmp);
  581. break;
  582. }
  583. *op++='(';
  584. while(*tmp!='\0'){*(op++)=*(tmp++);}
  585. *op++=')';
  586. free(tmp);
  587. cp+=GLOBAL_LLENS[i];
  588. }
  589. }
  590. *op='\0' ;
  591. return (float)RevPolishCore(Line_Cache);
  592. }
  593. //赋值函数
  594. BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  595. {
  596. char *gp=(char*)exp, *cp=gp;
  597. while(!isEND(*cp, "=")){
  598. cp++;
  599. }
  600. cp++;
  601. int i=-1;
  602. if(gp[0]==':'){
  603. if(gp[1]==':'){return TRUE;}
  604. i=Identify_KeyWords(gp, PRO_NUM, WORDS, " \t=");
  605. itoa(EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring), VALUE[i], 10);
  606. }else if(gp[0]=='$'){
  607. i=Identify_KeyWords(gp, GLOBAL_SIZE, (char**)GLOBAL_WORDS, " \t=");
  608. GLOBAL_VALUE[i]=EvalLine(cp, PRO_NUM, WORDS, VALUE, endstring);
  609. switch(i){
  610. case 3:
  611. GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :16+(int)GLOBAL_VALUE[i]%16;
  612. STRGB* bgRGB=&LOGO_RGB[(int)GLOBAL_VALUE[i]];
  613. //创建画刷
  614. HBRUSH m_brush=CreateSolidBrush(bgRGB->VALUE);
  615. //填充背景
  616. FillRect(hDC1, lrRECT, m_brush);
  617. //删除画刷
  618. DeleteObject(m_brush);
  619. break;
  620. break;
  621. case 4:
  622. if(GLOBAL_VALUE[i]<0){GLOBAL_VALUE[i]=-GLOBAL_VALUE[i];}
  623. break;
  624. case 5:
  625. GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%16 :360+(int)GLOBAL_VALUE[i]%16;
  626. break;
  627. case 6:
  628. GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%6 :(0-(int)GLOBAL_VALUE[i])%6;
  629. break;
  630. case 7:
  631. GLOBAL_VALUE[i]=(GLOBAL_VALUE[i]>=0) ?(int)GLOBAL_VALUE[i]%255 :(0-(int)GLOBAL_VALUE[i])%255;
  632. break;
  633. default:
  634. break;
  635. }
  636. }
  637. return TRUE;
  638. }
  639. //批量赋值
  640. BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  641. {
  642. char *gp=(char*)Line;
  643. while(isEND(*gp, ":$")){
  644. AssignMent(gp, PRO_NUM, WORDS, VALUE, endstring);
  645. gp++;
  646. while(!isEND(*gp, " \t\0")){
  647. gp++;
  648. }
  649. while(!isEND(*gp, ":$\0")){gp++;}
  650. if(*gp=='\0'){return TRUE;}
  651. }
  652. return TRUE;
  653. }
  654. //测FOR循环
  655. inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, int CYC)
  656. {
  657. if(CYC ==0){return TRUE;}
  658. int i=-1;
  659. if((i=Identify_KeyWords(strtok((char*)Line, " "), PRO_NUM, WORDS, " \t")) !=-1){
  660. int staNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  661. int endNUM=EvalLine(strtok(NULL, " "), PRO_NUM, WORDS, VALUE, "()+-*%/ \t\r\n");
  662. int var   =atoi(VALUE[i]);
  663. if(staNUM-endNUM<0){return (var<=endNUM)?TRUE:FALSE;}
  664. return (var>=endNUM)?TRUE:FALSE;
  665. }
  666. return FALSE;
  667. }
  668. //真值条件判断
  669. BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  670. {
  671. char* op=cacheTain;
  672. char* cp=(char*)exp;
  673. //过滤行TAB缩进或空格
  674. while(*cp=='\t'|| *cp==' '){cp++;}
  675. if(isEND(*cp, "\r\n\0")){
  676. return TRUE;
  677. }
  678. char* Line_Cache=op;
  679. int   i=-1, flag=0;
  680. while(!isEND(*cp, " \t\r\n\0")){
  681. if      (*cp=='>'){
  682. flag+=4;
  683. *(op++)='-';
  684. *(op++)='(';
  685. cp++;
  686. continue;
  687. }else if(*cp=='<'){
  688. flag+=2;
  689. *(op++)='-';
  690. *(op++)='(';
  691. cp++;
  692. continue;
  693. }else if(*cp=='='){
  694. flag+=1;
  695. if(flag==1){
  696. *(op++)='-';
  697. *(op++)='(';
  698. }
  699. cp++;
  700. continue;
  701. }else if(*cp!=':'&& *cp!='$'){
  702. *(op++)=*(cp++);
  703. continue;
  704. }
  705. if((*cp==':') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  706. char* tmp=VALUE[i];
  707. *op++='(';
  708. while(*tmp!='\0'){*(op++)=*(tmp++);}
  709. *op++=')';
  710. cp+=strlen(WORDS[i]);
  711. }else if((*cp=='$') && (i=Identify_KeyWords(cp, PRO_NUM, WORDS, endstring))!=-1){
  712. char* tmp=(char*)calloc(16, sizeof(char));
  713. if(i==8){
  714. itoa(rand(), tmp, 10);
  715. }else if(9<=i && i<=14){
  716. itoa(getTIME(i), tmp, 10);
  717. }else{
  718. _gcvt(GLOBAL_VALUE[i], 10, tmp);
  719. }
  720. *op++='(';
  721. while(*tmp!='\0'){*(op++)=*(tmp++);}
  722. *op++=')';
  723. cp+=GLOBAL_LLENS[i];
  724. }else{
  725. return FALSE;
  726. }
  727. }
  728. *(op++)=')';
  729. *op='\0' ;
  730. int m=(int)RevPolishCore(Line_Cache);
  731. if(
  732. (m >0 && (flag==4||flag==5 )) ||
  733. (m <0 && (flag==2||flag==3 )) ||
  734. (m==0 && (flag==1||flag==3||flag==5||flag==0))
  735. ){
  736. return TRUE;
  737. }
  738. return FALSE;
  739. }
  740. //批量真值判断
  741. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, char** VALUE, const char* endstring)
  742. {
  743. char *gp=(char*)Line;
  744. int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
  745. if(li !=-1){gp+=LGC_LLENS[li];}
  746. do{
  747. while(isEND(*gp, " \t")){
  748. gp++;
  749. }
  750. if(JudgMent(gp, PRO_NUM, WORDS, VALUE, endstring)){
  751. switch(li){
  752. case 0:
  753. return FALSE;
  754. case 1:
  755. break;
  756. case 2:
  757. return TRUE;
  758. default:
  759. return TRUE;
  760. }
  761. }else{
  762. switch(li){
  763. case 0:
  764. break;
  765. case 1:
  766. return FALSE;
  767. case 2:
  768. break;
  769. default:
  770. return FALSE;
  771. }
  772. }
  773. while(!isEND(*gp, " \t\0"  )){gp++;}
  774. if(*gp=='\0'){return TRUE;}
  775. while( isEND(*gp, " \t\r\n")){gp++;}
  776. }while(*gp !='\0');
  777. }
  778. /***************绘图函数群***************/
  779. //隐藏光标
  780. BOOL SizeCursor(int size)
  781. {
  782.     CONSOLE_CURSOR_INFO cursor_info = {(DWORD)((size==0)?25:size), (size==0)?FALSE:TRUE};
  783.     return SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
  784. }
  785. //平滑画线函数,C++连接库
  786. void drawSMOOTHLINE(HDC hDC, int penWith, int mode, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2);
  787. //封闭区域填充函数,C++连接库
  788. void fillAREA(HDC hDC, BYTE alpha, STRGB* penRGB, float fill_X, float fill_Y);
  789. //快速画线函数
  790. BOOL drawLINE(HDC hDC, int d)
  791. {
  792. float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
  793. GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  794. GLOBAL_VALUE[1]+=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  795. //当为PU抬笔时,不做绘图
  796. if(!penMODE){
  797. return FALSE;
  798. }
  799. STRGB* penRGB=&LOGO_RGB[(int)GLOBAL_VALUE[5]];
  800. 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]);
  801. return TRUE;
  802. }
  803. //退步函数,实现BK
  804. void backWARD(int d)
  805. {
  806. GLOBAL_VALUE[0]-=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
  807. GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
  808. }
  809. //图形旋转
  810. int RotateDC(HDC hDC, int angle)  
  811. {
  812. if(angle==0){return 1;}
  813. XFORM Matrix;
  814. double rad =-angle * 0.017453292519943;
  815. Matrix.eM11 = (float)cos(rad);  
  816. Matrix.eM12 = (float)sin(rad);  
  817. Matrix.eM21 =-(float)sin(rad);
  818. Matrix.eM22 = (float)cos(rad);  
  819. Matrix.eDx  = (float)(GLOBAL_VALUE[0]-cos(rad)*GLOBAL_VALUE[0]+sin(rad)*GLOBAL_VALUE[1]);  
  820. Matrix.eDy  = (float)(GLOBAL_VALUE[1]-cos(rad)*GLOBAL_VALUE[1]-sin(rad)*GLOBAL_VALUE[0]);
  821. SetGraphicsMode(hDC, GM_ADVANCED);
  822. SetWorldTransform(hDC, &Matrix);
  823. return 0;
  824. }
  825. /***************解析函数群***************/
  826. //脚本解析函数
  827. int FileScript(char* prossName, int PRO_NUM, char** PRO_VALUE)
  828. {
  829. //初始参数,其中KLevel为当前循环层号;
  830. int i=0, j=0, KLevel=0, SN=-1, Line_LEN=0, fcolor=-1, BASE_VAR_NUM=PRO_NUM;
  831. char* prepos=NULL;
  832. //定义过程变量存储容器,即定义 :A型变量,后接 ::A型变量
  833. char** PRO_WORDS=(char**)calloc(LOOP_LEVELS, sizeof(char*));
  834. //初始化开关参数,SFLAG[0]==1开始;
  835. char* SFLAG=(char*)calloc(8, sizeof(char));
  836. SFLAG[2]=-1;
  837. //初始化循环参量数组
  838. int*   FORI_CYCL=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  839. int*   FORI_LNUM=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));
  840. char** FORI_FTEL=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  841. char** FORI_FEND=(char**)calloc(LOOP_LEVELS,   sizeof(char*));
  842. BOOL*  FORI_IFOT=(BOOL *)calloc(LOOP_LEVELS,   sizeof(BOOL ));
  843. //分配行容器
  844. char* LCache=(char*)calloc(1025, sizeof(char));
  845. //辅助行指针
  846. char* Line;
  847. //辅助流指针
  848. char* tmpfp=tRAM;
  849. while(*tmpfp !='\0'){
  850. //记录位置
  851. char* prepos=tmpfp;
  852. //指针置换
  853. Line=LCache;
  854. while(*tmpfp !='\n' && *tmpfp !='\0'){
  855. *(Line++)=*(tmpfp++);
  856. }
  857. if(*tmpfp =='\n'){*(Line++)=*(tmpfp++);}
  858. *Line='\0';
  859. //指针回首
  860. Line=LCache;
  861. //行计数器
  862. i++;
  863. //过滤行TAB缩进或前空格
  864. while(*Line=='\t'|| *Line==' '){Line++;}
  865. //过滤空行或行注释
  866. if(
  867. (Line[0]=='\r')                ||
  868. (Line[0]=='\n')                ||
  869. (Line[0]=='/' && Line[1]=='/')
  870. ){
  871. continue;
  872. }
  873. //过滤段间注释
  874. if(
  875. (Line[0]=='/' &&Line[1]=='*')
  876. ){
  877. SFLAG[0]=0;
  878. continue;
  879. }else if(
  880. (Line[0]=='*' &&Line[1]=='/')
  881. ){
  882. SFLAG[0]=1;
  883. continue;
  884. }
  885. //识别子过程名
  886. if(
  887. (isEND(Line[2], " \t\r\n\0") )  &&
  888. (Line[0]=='T' || Line[0]=='t')  &&
  889. (Line[1]=='O' || Line[1]=='o')
  890. ){
  891. Line+=2;
  892. //过滤TO后TAB缩进,或TO后空格
  893. while(*Line=='\t'|| *Line==' '){Line++;}
  894. if(isKEY(Line, prossName, " \t\r\n\0")){
  895. SFLAG[0]=1;
  896. ARGS(Line, PRO_WORDS, PRO_NUM, i, Line);
  897. }else{
  898. SFLAG[0]=0;
  899. }
  900. continue;
  901. }
  902. //开始开关未打开,或遇到空行
  903. if(
  904. SFLAG[0]==0     ||
  905. isEND(Line[0], "\r\n[")
  906. ){continue;}
  907. //IF...ELIF连带性分析
  908. if(
  909. (FORI_IFOT[KLevel+1]       )   &&
  910. (Line[0]!='E'&&Line[0]!='e')   &&
  911. (Line[1]!='L'&&Line[1]!='l')   &&
  912. (Line[2]!='I'&&Line[2]!='i')   &&
  913. (Line[3]!='F'&&Line[3]!='f')
  914. ){
  915. FORI_IFOT[KLevel+1]=FALSE;
  916. }
  917. //解析循环结束标签,循环加速
  918. if(Line[0]==']'){
  919. if(KLevel>SFLAG[1]){
  920. if(FORI_CYCL[KLevel] <0){
  921. int tpadd=EvalLine(Line+1, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  922. if(tpadd==0){tpadd=1;}
  923. itoa(atoi(PRO_VALUE[0-FORI_CYCL[KLevel]])+tpadd, PRO_VALUE[0-FORI_CYCL[KLevel]], 10);
  924. }
  925. if(FORI_FEND[KLevel]==NULL){FORI_FEND[KLevel]=tmpfp;}
  926. tmpfp=FORI_FTEL[KLevel];
  927. i=FORI_LNUM[KLevel]-1;
  928. }else{
  929. FORI_FTEL[KLevel]=NULL;
  930. FORI_FEND[KLevel]=NULL;
  931. FORI_CYCL[KLevel]=0;
  932. SFLAG[1]=0;
  933. }
  934. KLevel--;
  935. continue;
  936. }else{
  937. int ki =Identify_KeyWords(Line, CYC_SIZE, (char**)CYC_WORDS, " \t\r\n\0");
  938. if( ki!=-1){
  939. Line=passNULL(Line+CYC_LLENS[ki]);
  940. KLevel++;
  941. //解析循环
  942. if(
  943. ki==0 && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n") ||
  944. ki==1 && FORI_CYCL[KLevel]<EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"   )         ||
  945. ki==2 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")                        ||
  946. ki==3 && isForTrue(Line, PRO_NUM, PRO_WORDS, PRO_VALUE,  FORI_CYCL[KLevel])                           ||
  947. ki==4 && (FORI_IFOT[KLevel]) && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*/><= \t\r\n")
  948. ){
  949. if( FORI_FTEL[KLevel]==NULL ){
  950. FORI_FTEL[KLevel]=prepos;
  951. FORI_LNUM[KLevel]=i+1;
  952. if(ki==3){
  953. char *tp1, *tp2;
  954. //提取瞬时变量名
  955. if((tp1=strtok(Line, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  956. PRO_WORDS[PRO_NUM]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
  957. strcpy(PRO_WORDS[PRO_NUM], tp1);
  958. //提取始步
  959. if((tp2=strtok(NULL, " "))==NULL){fprintf(stdout, "[%d]:Missing Parameter %s\n", i, Line);exit(1);}
  960. PRO_VALUE[PRO_NUM]=(char*)calloc(MAX_VALUE_SIZE, sizeof(char));
  961. itoa(EvalLine(tp2, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"), PRO_VALUE[PRO_NUM], 10);
  962. FORI_CYCL[KLevel] =0-PRO_NUM;
  963. PRO_NUM++;
  964. }
  965. if(ki==0 || ki==4){
  966. FORI_IFOT[KLevel]=FALSE;
  967. }
  968. }
  969. if(ki !=3){FORI_CYCL[KLevel]  ++;}
  970. }else{
  971. if((ki==0||ki==4) && FORI_CYCL[KLevel]==0){
  972. FORI_IFOT[KLevel]=TRUE;
  973. }
  974. if(FORI_FEND[KLevel] !=NULL){
  975. if(FORI_CYCL[KLevel] <0){
  976. free(PRO_WORDS[PRO_NUM]);
  977. free(PRO_VALUE[PRO_NUM]);
  978. PRO_NUM-=1;
  979. }
  980. tmpfp=FORI_FEND[KLevel];
  981. i=FORI_LNUM[KLevel]-1;
  982. FORI_FTEL[KLevel]=NULL;
  983. FORI_FEND[KLevel]=NULL;
  984. FORI_CYCL[KLevel]=0;
  985. KLevel--;
  986. }else{
  987. SFLAG[1]=KLevel;
  988. }
  989. }
  990. continue;
  991. }
  992. }
  993. //语句块循环开关
  994. if(SFLAG[1]!=0){continue;}
  995. //变量赋值
  996. if(Line[0]==':'||Line[0]=='$'){
  997. MoreAssignMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  998. continue;
  999. }
  1000. //调用子过程
  1001. if(Line[0]=='.'){
  1002. //定义过程传参容器
  1003. char** PAR_VALUE=(char**)calloc(LOOP_LEVELS, sizeof(char*));
  1004. int PAR_NUM=ARGP(Line, PAR_VALUE, PRO_NUM, PRO_WORDS, PRO_VALUE);
  1005. FileScript(Line+1, PAR_NUM, PAR_VALUE);
  1006. free(PAR_VALUE);
  1007. continue;
  1008. }
  1009. //过滤回车符
  1010. if((Line_LEN=strlen(Line))==2){
  1011. continue;
  1012. }else{
  1013. Line[Line_LEN-2]='\0';
  1014. }
  1015. //解析命令行
  1016. if((SN=Identify_KeyWords(Line, KEY_SIZE, (char**)KEY_WORDS, " \t\r\n\0")) !=-1){
  1017. Line=passNULL(Line+KEY_LLENS[SN]);
  1018. }else{
  1019. printf("[%d]:EEEOR LINE \"%s\"\n", i, Line);
  1020. exit(1);
  1021. }
  1022. switch(SN)
  1023. {
  1024. case  0:
  1025. //FD
  1026. drawLINE(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1027. break;
  1028. case  1:
  1029. //BK
  1030. backWARD(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1031. break;
  1032. case  2:
  1033. //LT
  1034. GLOBAL_VALUE[2]-=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1035. break;
  1036. case  3:
  1037. //RT
  1038. GLOBAL_VALUE[2]+=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n");
  1039. break;
  1040. case  4:
  1041. //PU
  1042. penMODE=FALSE;
  1043. break;
  1044. case  5:
  1045. //PD
  1046. if(SFLAG[2] !=-1){
  1047. GLOBAL_VALUE[5]=SFLAG[2];
  1048. SFLAG[2] =-1;
  1049. }
  1050. penMODE=TRUE;
  1051. break;
  1052. case  6:
  1053. //PE
  1054. if(SFLAG[2] ==-1){
  1055. SFLAG[2]=GLOBAL_VALUE[5];
  1056. GLOBAL_VALUE[5]=GLOBAL_VALUE[3];
  1057. }
  1058. break;
  1059. case  7:
  1060. //CLEAN
  1061. InvalidateRect(hCMD,NULL,FALSE);
  1062. break;
  1063. case  8:
  1064. //ECHO, 输出字符串
  1065. printf("%s\n", Line);
  1066. break;
  1067. case  9:
  1068. //HOME
  1069. GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;
  1070. break;
  1071. case 10:
  1072. //STOP
  1073. return 0;
  1074. case 11:
  1075. //EXIT
  1076. exit(0);
  1077. case 12:
  1078. //FILL
  1079. if((fcolor=EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n")) !=-1){
  1080. fillAREA(hDC,  (BYTE)((int)GLOBAL_VALUE[7]&0xFF), &LOGO_RGB[fcolor],  lrRECT->right/2+GLOBAL_VALUE[0],  lrRECT->bottom/2-GLOBAL_VALUE[1]);
  1081. }
  1082. break;
  1083. case 13:
  1084. //PAUSE
  1085. getch();
  1086. break;
  1087. case 14:
  1088. //WAIT
  1089. Sleep(EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1090. break;
  1091. case 15:
  1092. //ROTE
  1093. //将内存画布拷屏到CMD窗口
  1094. //BitBlt(hDC,0,0,WINDOW_WIDTH,WINDOW_HEIGHT, hDC1,0,0,SRCCOPY);
  1095. RotateDC(hDC, EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1096. break;
  1097. case 16:
  1098. //MEMUSE,开辟内存画布
  1099. if(!memMODE){
  1100. BitBlt(hDC3,0,0,lrRECT->right,lrRECT->bottom, hDC1,0,0,SRCCOPY);
  1101. memMODE=TRUE;
  1102. }
  1103. BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1104. hDC=hDC2;
  1105. break;
  1106. case 17:
  1107. //MEMSEE,展示内存画布
  1108. BitBlt(hDC1,0,0,lrRECT->right,lrRECT->bottom, hDC2,0,0,SRCCOPY);
  1109. BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
  1110. break;
  1111. case 18:
  1112. //MEMOUT,丢弃内存画布
  1113. memMODE=FALSE;
  1114. hDC=hDC1;
  1115. break;
  1116. case 19:
  1117. //EVAL,表达式计算输出
  1118. printf("%.12g\n", EvalLine(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, "()+-*%/ \t\r\n"));
  1119. break;
  1120. default:
  1121. printf("[%d]:EEEOR LINE 。\n", i);
  1122. exit(1);
  1123. break;
  1124. }
  1125. }
  1126. free(PRO_WORDS);
  1127. free(SFLAG);
  1128. free(FORI_CYCL);
  1129. free(FORI_LNUM);
  1130. free(FORI_FTEL);
  1131. free(FORI_FEND);
  1132. free(FORI_IFOT);
  1133. free(LCache);
  1134. return 0;
  1135. }
  1136. /*************MAIN主函数入口*************/
  1137. int main(int argc, char** argv)
  1138. {
  1139. if(argc==2){
  1140. //隐藏光标
  1141. SizeCursor(0);
  1142. //初始化变量
  1143. int fsize=0;
  1144. //初始化随机种子
  1145. srand((unsigned)time(NULL));
  1146. //读文件流
  1147. FILE* fp;
  1148. if( (fp=fopen(argv[1], "rb"))==NULL ){
  1149. fputs("Failed to read file.", stdout);
  1150. return 2;
  1151. }
  1152. //测量尺寸
  1153. fseek(fp, 0, SEEK_END);
  1154. fsize=ftell(fp);
  1155. //超过1M的脚本,拒绝执行
  1156. if(fsize > 1*1024*1024){
  1157. fputs("File size is too large, out of memory.", stdout);
  1158. return 1;
  1159. //小于10字节的,拒绝执行
  1160. }else if(fsize < 10){
  1161. fputs("File size is too small,  in of memory.", stdout);
  1162. return 1;
  1163. }
  1164. //指针复原
  1165. fseek(fp, 0, SEEK_SET);
  1166. //读入内存
  1167. tRAM=(char*)calloc(fsize+3, sizeof(char));
  1168. tRAM[fsize]='\r', tRAM[fsize+1]='\n', tRAM[fsize+2]='\0';
  1169. fread(tRAM, fsize, 1, fp);
  1170. //释放文件
  1171. fclose(fp);
  1172. //获取CMD窗口句柄
  1173. hCMD=GetConsoleWindow();
  1174. //获取CMD窗口大小
  1175. lrRECT=&winRECT;
  1176. GetClientRect(hCMD, lrRECT);
  1177. //CMD画布
  1178. hDC1=GetDC(hCMD);
  1179. HBITMAP hBitmap1=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1180. SelectObject(hDC1, hBitmap1);
  1181. //内存画布
  1182. hWND2=NULL;
  1183. hDC2=CreateCompatibleDC(GetDC(hWND2));
  1184. HBITMAP hBitmap2=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1185. SelectObject(hDC2, hBitmap2);
  1186. //辅助画布
  1187. hWND3=NULL;
  1188. hDC3=CreateCompatibleDC(GetDC(hWND3));
  1189. HBITMAP hBitmap3=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
  1190. SelectObject(hDC3, hBitmap3);
  1191. //运行脚本
  1192. char** PAR_VALUE=(char**)calloc(LOOP_LEVELS, sizeof(char*));
  1193. //主DC选择CMD画布
  1194. hDC=hDC1;
  1195. //寻找主函数入口点
  1196. FileScript("MAIN", 1, PAR_VALUE);
  1197. //释放DC
  1198. ReleaseDC(NULL, hDC3);
  1199. ReleaseDC(NULL, hDC2);
  1200. ReleaseDC(hCMD, hDC1);
  1201. DeleteDC(hDC3);
  1202. DeleteDC(hDC2);
  1203. DeleteDC(hDC1);
  1204. DeleteObject(hBitmap3);
  1205. DeleteObject(hBitmap2);
  1206. DeleteObject(hBitmap1);
  1207. //释放内存
  1208. free(PAR_VALUE);
  1209. free(tRAM);
  1210. return 0;
  1211. }
  1212. //异常则抛出使用说明
  1213. fputs("COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0\nUSAGE: CLGO [FILE]\n", stdout);
  1214. return 1;
  1215. }
复制代码
批处理调用示例
  1. /*
  2. @ECHO OFF&CLS&COLOR 0F&MODE CON COLS=100 LINES=30&CLGO "%~F0"&PAUSE>NUL&EXIT /B
  3. COPYRIGHT@2017~2019 BY HAPPY
  4. */
  5. TO MAIN
  6. $PENX=-36 $PENY=126 $PENS=2 $PENW=2 $PENA=180 $HEADING=12
  7. //MEMUSE
  8. REPEAT 12
  9. [
  10. $PENC=$RANDOM%15+1
  11. REPEAT 75
  12. [
  13. FD 100
  14. BK 100
  15. RT 2
  16. ]
  17. FD 250
  18. ]
  19. //MEMSEE
  20. //MEMOUT
复制代码
CLGO语言能绘图、能计算、能做动画、能开发游戏、能制作窗体菜单,1.0版由于时间仓促功能不是很多,bug也在所难免,但之后的版本会发生质的改变,敬请期待。




欢迎光临 批处理之家 (http://www.bathome.net/) Powered by Discuz! 7.2