[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发帖
happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
1楼 跳转到 » 倒序看帖
打印
tT
发表于 2017-5-3 12:22 | 只看该作者

基于CLGO的COOL解释器发布

本帖最后由 happy886rr 于 2017-5-3 12:31 编辑

COOL解释器基于CLGO，但核心架构完全重写了一次，增加按键支持，改进了变量表识别机制，改进了语法体系，总代码量也突破1800行，跟CLGO语法和运行机制不再一样。此次发布的是COOL解释器1.0版。并附上一个测试：希尔波特催眠术。
百度网盘下载：https://pan.baidu.com/s/1i4ZswEL
图片均为外链


希尔波特催眠术脚本
  1. @echo off

  2. mode con cols=100 lines=30

  3. cool "%~f0"

  4. exit

  5. 

  6. //主函数入口

  7. to main

  8. 	make :penw=3

  9. 	for  :a 5 7

  10. 	(

  11. 		make :penx=500 :peny=-500

  12. 		hilbert_curve 1000/(2^:a-1) :a 90

  13. 	)

  14. 	for  :a 6 3

  15. 	(

  16. 		make :penx=500 :peny=-500

  17. 		hilbert_curve 1000/(2^:a-1) :a 90

  18. 	)-1

  19. 	functions_img 1

  20. 	exit

  21. 

  22. //希尔波特曲线

  23. to hilbert_curve :len :recursive_times :angle

  24. 

  25. 	if :recursive_times=0

  26. 	(

  27. 		stop

  28. 	)

  29. 

  30. 	if :recursive_times/3=1

  31. 	(

  32. 		make :penc=rand(15)+1

  33. 	)

  34. 

  35. 	if or :penc=9 :penc=10

  36. 	(

  37. 		make :penc=7

  38. 	)

  39. 

  40. 	lt :angle

  41. 	hilbert_curve :len :recursive_times-1 -:angle

  42. 

  43. 	fd :len 

  44. 	rt :angle

  45. 	hilbert_curve :len :recursive_times-1  :angle

  46. 

  47. 	fd :len				

  48. 	hilbert_curve :len :recursive_times-1  :angle

  49. 

  50. 	rt :angle  

  51. 	fd :len  

  52. 	hilbert_curve :len :recursive_times-1 -:angle

  53. 	lt :angle

  54. 

  55. //旋转体系

  56. to functions_img :add

  57. 	memuse

  58. 	for :a 1 36000

  59. 	(

  60. 		make :penx=0 :peny=0

  61. 		rote :a

  62. 		memsee

  63. 	):add

  64. 	memout
复制代码
COOL解释器源码（仅支持gcc编译器）：
  1. /*

  2. 	COOL SCRIPT, COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0

  3. 	COOL.EXE

  4. 	LINK: -L./ -lgdi32 -lgdiplus

  5. */

  6. #include <cmath>

  7. #include <stdio.h>

  8. #include <stdlib.h>

  9. #include <string.h>

  10. #include <ctype.h>

  11. #include <windows.h>

  12. #include <wincon.h>

  13. #include <io.h>

  14. #include <conio.h>

  15. #include <time.h>

  16. #include <gdiplus\gdiplus.h>

  17. 

  18. //定义isINF和isNAN

  19. #ifndef Nan__

  20. #define Nan__

  21. #define NAN log(-1.0) //无效值NAN

  22. #define isNAN(x) ((x)!=(x))

  23. #define NINF log(0.0) //负无穷大

  24. #define INF -NINF //无穷大

  25. #define PINF -NINF //正无穷大

  26. #define isINF(x) (((x)==PINF)||((x)==NINF))

  27. #define isPINF(x) ((x)==PINF)

  28. #define isNINF(x) ((x)==NINF)

  29. #endif

  30. 

  31. //声明函数

  32. extern "C" HWND WINAPI GetConsoleWindow();

  33. 

  34. //使用GDI+

  35. using namespace Gdiplus;

  36. 

  37. /***************定义宏变量***************/

  38. //堆栈尺寸

  39. #define STACK_SIZE         1024

  40. //循环体最大层数

  41. #define LOOP_LEVELS        64

  42. //变量名最大长度

  43. #define MAX_WORDS_SIZE     64

  44. //绘图系关键词数

  45. #define KEY_SIZE           23

  46. //循环系关键词数

  47. #define CYC_SIZE           5

  48. //逻辑系关键词

  49. #define LGC_SIZE           3

  50. //全局变量解释数

  51. #define GLOBAL_SIZE        18

  52. 

  53. /***************全局类变量***************/

  54. //主窗区域

  55. RECT     winRECT= {0};

  56. LPRECT   lrRECT;

  57. double   base_X, base_Y;

  58. //主窗句柄

  59. HWND  hCMD;

  60. HWND  hWND2;

  61. HWND  hWND3;

  62. //当前行行号

  63. int   CUR_LINENUM;

  64. //当前行指针

  65. char* CUR_LINEPOINTER;

  66. //画布句柄

  67. HDC   hDC;

  68. HDC   hDC1;

  69. HDC   hDC2;

  70. HDC   hDC3;

  71. 

  72. //内存变量

  73. char* tRAM;

  74. //缓存容器

  75. char  CacheTain[1024]= {0};

  76. //辅助容器

  77. char  Auxiliary[1024]= {0};

  78. //画线是否可见

  79. BOOL  penMODE=TRUE;

  80. //启用内存背景

  81. BOOL  memMODE=FALSE;

  82. 

  83. /***************关键词类目***************/

  84. //运算符栈

  85. char   STACK1[STACK_SIZE]= {0};

  86. //逆波兰栈

  87. char   STACK2[STACK_SIZE]= {0};

  88. //浮点数栈

  89. double STACK3[STACK_SIZE]= {0};

  90. //数学函数关键词

  91. static const char* MATH_WORDS[]= {"TIME", "PI", "SQRT", "LG", "LN", "SIN", "COS", "TAN", "ARCSIN", "ARCCOS", "ARCTAN", "DEG", "ABS", "ROUND", "READ", "CEIL", "EXP", "SINH", "COSH", "TANH", "ARCSINH", "ARCCOSH", "ARCTANH", "RAND", "INT", "FACT", NULL};

  92. //绘图系关键词

  93. static const char* KEY_WORDS[]= {"FD", "BK", "LT", "RT", "PU", "PD", "PE", "CS", "PR", "HM", "STOP", "EXIT", "FILL", "TEXT", "WAIT", "ROTE", "MEMUSE", "MEMSEE", "MEMOUT", "MAKE", "SETXY", "OVAL", "RECT"};

  94. static const char  KEY_LLENS[]= {   2,    2,    2,    2,    2,    2,    2,    2,    2,    2,      4,      4,      4,      4,      4,      4,        4,        4,        4,      4,      5,       4,      4};

  95. //循环系关键词

  96. static const char* CYC_WORDS[]= {"IF", "REPEAT", "WHILE", "FOR", "ELIF"};

  97. static const char  CYC_LLENS[]= {   2,        6,       5,     3,      4};

  98. //逻辑系关键词

  99. static const char* LGC_WORDS[]= {"NOT", "AND", "OR"};

  100. static const char  LGC_LLENS[]= {   3,      3,    2};

  101. //定义解释器全局变量

  102. static const char* GLOBAL_WORDS[]= {":PENX", ":PENY", ":HEADING", ":PENB", ":PENW", ":PENC", ":PENS", ":PENA", ":PEN0", ":PEN1", ":PEN2", ":PEN3", ":PEN4", ":PEN5", ":PEN6", ":PEN7", ":PEN8", ":PEN9"};

  103. double  GLOBAL_VALUE[]= {      0,       0,          0,       0,       1,      15,       0,     255,       0,       0,       0,       0,       0,       0,       0,       0,       0,       0};

  104. 

  105. /***************申明函数类***************/

  106. int     Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring);

  107. double  RevPolishCore(const char* expression, int PRO_NUM, char** WORDS, double* VALUE);

  108. 

  109. /***************RGB 结构体***************/

  110. typedef struct

  111. {

  112. 	BYTE R;

  113. 	BYTE G;

  114. 	BYTE B;

  115. 	COLORREF VALUE;

  116. } STRGB;

  117. //十六色系数组

  118. STRGB LOGO_RGB[16]=

  119. {

  120. 	{  0,  0,  0,RGB(  0,  0,  0)}, //黑色

  121. 	{  0,  0,255,RGB(  0,  0,255)}, //蓝色

  122. 	{  0,255,  0,RGB(  0,255,  0)}, //绿色

  123. 	{  0,255,255,RGB(  0,255,255)}, //青色

  124. 	{255,  0,  0,RGB(255,  0,  0)}, //红色

  125. 	{238,130,238,RGB(238,130,238)}, //紫兰

  126. 	{165, 42, 42,RGB(165, 42, 42)}, //棕色

  127. 	{211,211,211,RGB(211,211,211)}, //浅灰

  128. 	{169,169,169,RGB(169,169,169)}, //深灰

  129. 	{173,216,230,RGB(173,216,230)}, //淡蓝

  130. 	{144,238,144,RGB(144,238,144)}, //浅绿

  131. 	{224,255,255,RGB(224,255,255)}, //淡青

  132. 	{248, 29, 56,RGB(248, 29, 56)}, //亮红

  133. 	{255,  0,255,RGB(255,  0,255)}, //洋紫

  134. 	{255,255,  0,RGB(255,255,  0)}, //黄色

  135. 	{255,255,255,RGB(255,255,255)}  //白色

  136. };

  137. 

  138. /***************辅助函数群***************/

  139. //获取时间

  140. int getTIME(int i)

  141. {

  142. 	time_t timep;

  143. 	struct tm *p;

  144. 	time(&timep);

  145. 	p=localtime(&timep);

  146. 

  147. 	switch(i)

  148. 	{

  149. 	case 0:

  150. 		return p->tm_year+1900;

  151. 	case 1:

  152. 		return p->tm_mon+1;

  153. 	case 2:

  154. 		return p->tm_mday;

  155. 	case 3:

  156. 		return p->tm_hour;

  157. 	case 4:

  158. 		return p->tm_min;

  159. 	case 5:

  160. 		return p->tm_sec;

  161. 	default:

  162. 		break;

  163. 	}

  164. }

  165. //按键获取

  166. int getKEY(int N,int T)

  167. {

  168. 	int i,KEY_V,start=clock();

  169. 	do

  170. 	{

  171. 		if(_kbhit())

  172. 		{

  173. 			KEY_V=(int)(_getch());

  174. 			if(KEY_V<97)

  175. 			{

  176. 				KEY_V+=32;

  177. 			}

  178. 			return KEY_V;

  179. 		}

  180. 		for(i=0; i<=N; i++);

  181. 	}

  182. 	while((clock()-start)<T);

  183. 	return -1;

  184. }

  185. //转码函数

  186. static WCHAR  Tainer[1024]= {0};

  187. WCHAR* AnsiToWCHAR(const CHAR* str)

  188. {

  189. 	if(!str)

  190. 	{

  191. 		return NULL;

  192. 	}

  193. 	int wLen=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, NULL, 0);

  194. 	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, Tainer, wLen);

  195. 	Tainer[wLen]='\0';

  196. 	return Tainer;

  197. }

  198. //阶乘函数

  199. long long fact(long long n)

  200. {

  201. 	return (n<2) ?1 :n*(fact(n-1));

  202. }

  203. //测空字符

  204. inline BOOL isEND(const char c,const char* endstring)

  205. {

  206. 	if(c=='\0')

  207. 	{

  208. 		return TRUE;

  209. 	}

  210. 

  211. 	while(*endstring!='\0')

  212. 	{

  213. 		if(c==*(endstring++))

  214. 		{

  215. 			return TRUE;

  216. 		}

  217. 	}

  218. 	return FALSE;

  219. }

  220. //过滤行TAB缩进或前空格

  221. char* passNULL(char* Str)

  222. {

  223. 	if(Str!=NULL)

  224. 	{

  225. 		while(*Str=='\t' ||*Str==' ')

  226. 		{

  227. 			Str++;

  228. 		}

  229. 	}

  230. 	return Str;

  231. }

  232. //错误反馈

  233. inline int errorEXIT(char* errorTYPE)

  234. {

  235. 	fprintf(stderr, "[%d]:%s    '%s\n", CUR_LINENUM, errorTYPE, passNULL(CUR_LINEPOINTER));

  236. 	exit(1);

  237. }

  238. //识别关键字

  239. BOOL isKEY(char* Line, char* key, const char* endstring)

  240. {

  241. 	char *op=Line, *kp=key;

  242. 	while(*kp!='\0')

  243. 	{

  244. 		if((('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp))

  245. 		{

  246. 			break;

  247. 		}

  248. 		op++;

  249. 		kp++;

  250. 	}

  251. 	if(

  252. 	    *kp=='\0' &&

  253. 	    isEND(*op, endstring)

  254. 	)

  255. 	{

  256. 		return TRUE;

  257. 	}

  258. 	return FALSE;

  259. }

  260. //切分变量名

  261. int ARGS(char* Str, char** WORDS, int PRO_NUM, int LineNUM, char* Line)

  262. {

  263. 	if(PRO_NUM==0)

  264. 	{

  265. 		return 0;

  266. 	}

  267. 

  268. 	int i=0;

  269. 	char* lp=Str;

  270. 

  271. 	char* tp;

  272. 	strtok(lp, " \t");

  273. 

  274. 	WORDS[0]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));

  275. 	strcpy(WORDS[0], ":\n");

  276. 

  277. 	while((++i)<PRO_NUM)

  278. 	{

  279. 		if((tp=strtok(NULL, " \t"))==NULL)

  280. 		{

  281. 			break;

  282. 		}

  283. 		WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));

  284. 		strcpy(WORDS[i], tp);

  285. 	}

  286. 

  287. 	//参数不匹配时则退出

  288. 	if(i<PRO_NUM)

  289. 	{

  290. 		errorEXIT("Missing parameter");

  291. 	}

  292. 

  293. 	return i;

  294. }

  295. //切分参数

  296. int ARGP(char* Str, double* WVALUE, int PRO_NUM, char** PRO_WORDS, double* PRO_VALUE)

  297. {

  298. 	int i=0;

  299. 	char* tp;

  300. 	strtok(Str, " \t");

  301. 	while((tp=strtok(NULL, " \t"))!=NULL && *tp!='\0')

  302. 	{

  303. 		WVALUE[++i]=RevPolishCore(tp, PRO_NUM, PRO_WORDS, PRO_VALUE);

  304. 	}

  305. 	return i+1;

  306. }

  307. //关键词解析函数

  308. int Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring)

  309. {

  310. 	int SN;

  311. 	for(SN=0; SN<SENSITIVE_NUM; SN++)

  312. 	{

  313. 		char *op=Line, *kp=WORDS[SN];

  314. 		while(*kp!='\0')

  315. 		{

  316. 			if(

  317. 			    (('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)

  318. 			)

  319. 			{

  320. 				break;

  321. 			}

  322. 			op++;

  323. 			kp++;

  324. 		}

  325. 		if(

  326. 		    *kp=='\0' &&

  327. 		    isEND(*op, endstring)

  328. 		)

  329. 		{

  330. 			return SN;

  331. 		}

  332. 	}

  333. 	return -1;

  334. }

  335. 

  336. /***************计算函数群***************/

  337. //逆波兰核心

  338. double RevPolishCore(const char* expression, int PRO_NUM, char** WORDS, double* VALUE)

  339. {

  340. 	STACK3[0]=0;

  341. 	int si, brackets=0;

  342. 	char   *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;

  343. 	double *S3=STACK3, di, ni;

  344. 

  345. 	//生成逆波兰

  346. 	while(*op!='\0' && *op!=' ' && *op!='\t')

  347. 	{

  348. 		switch(*op)

  349. 		{

  350. 		case ' ' :

  351. 		case '\t':

  352. 			//过滤空字符

  353. 			op++;

  354. 			continue;

  355. 

  356. 		case 'a':

  357. 		case 'b':

  358. 		case 'c':

  359. 		case 'd':

  360. 		case 'e':

  361. 		case 'f':

  362. 		case 'g':

  363. 		case 'h':

  364. 		case 'i':

  365. 		case 'j':

  366. 		case 'k':

  367. 		case 'l':

  368. 		case 'm':

  369. 		case 'n':

  370. 		case 'o':

  371. 		case 'p':

  372. 		case 'q':

  373. 		case 'r':

  374. 		case 's':

  375. 		case 't':

  376. 		case 'u':

  377. 		case 'v':

  378. 		case 'w':

  379. 		case 'x':

  380. 		case 'y':

  381. 		case 'z':

  382. 		case 'A':

  383. 		case 'B':

  384. 		case 'C':

  385. 		case 'D':

  386. 		case 'E':

  387. 		case 'F':

  388. 		case 'G':

  389. 		case 'H':

  390. 		case 'I':

  391. 		case 'J':

  392. 		case 'K':

  393. 		case 'L':

  394. 		case 'M':

  395. 		case 'N':

  396. 		case 'O':

  397. 		case 'P':

  398. 		case 'Q':

  399. 		case 'R':

  400. 		case 'S':

  401. 		case 'T':

  402. 		case 'U':

  403. 		case 'V':

  404. 		case 'W':

  405. 		case 'X':

  406. 		case 'Y':

  407. 		case 'Z':

  408. 			//识别数学函数关键词

  409. 			key=(char**)MATH_WORDS;

  410. 			while(*key !=NULL)

  411. 			{

  412. 				cp=op, kp=*key;

  413. 				//比对关键词字母

  414. 				while((*cp==*kp||*cp==*kp+32) && *kp!='\0')

  415. 				{

  416. 					cp++, kp++;

  417. 				}

  418. 				//验证关键词结尾

  419. 				if( ((*cp<'A')||('Z'<*cp && *cp<'a')||(*cp>'z')) && (*kp=='\0') )

  420. 				{

  421. 					op=cp;

  422. 					break;

  423. 				}

  424. 				key++;

  425. 			}

  426. 			//构建伪双目

  427. 			if(*key !=NULL)

  428. 			{

  429. 				*(S2++)='.';

  430. 				*(S2++)=' ';

  431. 				//伪双目入栈

  432. 				while( ('A'<=(*S1) && (*S1)<='Z') )

  433. 				{

  434. 					*(S2++)=*(S1--);

  435. 				}

  436. 				*(++S1)=key-(char**)MATH_WORDS+65;

  437. 				continue;

  438. 			}

  439. 			else

  440. 			{

  441. 				//无法识别的数学函数

  442. 				errorEXIT("Unrecognized math function");

  443. 			}

  444. 			break;

  445. 

  446. 		case '(':

  447. 			brackets++;

  448. 			*(++S1)=*op;

  449. 			if(*(op+1)=='-' || *(op+1)=='+')

  450. 			{

  451. 				*(S2++)='0', *(S2++)=' ';

  452. 			}

  453. 			break;

  454. 

  455. 		case ')':

  456. 			brackets--;

  457. 			while(*S1!='(')

  458. 			{

  459. 				*(S2++)=*(S1--);

  460. 			}

  461. 			//舍弃'('

  462. 			S1--;

  463. 			break;

  464. 

  465. 		case '+':

  466. 		case '-':

  467. 			while(S1!=STACK1 && *S1!='(')

  468. 			{

  469. 				*(S2++)=*(S1--);

  470. 			}

  471. 			*(++S1)=*op;

  472. 			break;

  473. 

  474. 		case '^':

  475. 			//指数符

  476. 			while( ('A'<=(*S1) && (*S1)<='Z') )

  477. 			{

  478. 				*(S2++)=*(S1--);

  479. 			}

  480. 			*(++S1)=*op;

  481. 			break;

  482. 

  483. 		case '%':

  484. 		case '*':

  485. 		case '/':

  486. 			while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^')

  487. 			{

  488. 				*(S2++)=*(S1--);

  489. 			}

  490. 			*(++S1)=*op;

  491. 			break;

  492. 

  493. 		case ':':

  494. 			//识别变量 :VAR

  495. 			for(si=PRO_NUM-1; si>=0-GLOBAL_SIZE; si--)

  496. 			{

  497. 				cp=op, kp=(si<0)?(char *)GLOBAL_WORDS[-1-si]:WORDS[si];

  498. 				//比对变量字母

  499. 				while((*cp==*kp||*cp==*kp+32) && *kp!='\0')

  500. 				{

  501. 					cp++, kp++;

  502. 				}

  503. 				//验证变量结尾

  504. 				if(!(('a'<=*cp && *cp<='z')||('A'<=*cp && *cp<='Z')||('0'<=*cp && *cp<='9')||(*cp=='_' || *cp=='#')) && (*kp=='\0'))

  505. 				{

  506. 					op=cp-1;

  507. 					break;

  508. 				}

  509. 			}

  510. 			//判断变量是否存在

  511. 			if(si>=0-GLOBAL_SIZE)

  512. 			{

  513. 				//变量 :VAR入栈

  514. 				*(S2++)=':', *(S2++)=si, *(S2++)=' ';

  515. 			}

  516. 			else

  517. 			{

  518. 				//变量 :VAR无效

  519. 				errorEXIT("Variable  not exist");

  520. 			}

  521. 			break;

  522. 

  523. 		default :

  524. 			if((*op<'0' || *op>'9') && (*op!='.'))

  525. 			{

  526. 				//无法识别的数字

  527. 				errorEXIT("Unrecognized number");

  528. 			}

  529. 			//浮点数入栈

  530. 			while(('0'<=*op && *op<='9') ||*op=='.')

  531. 			{

  532. 				*(S2++)=*(op++);

  533. 			}

  534. 			op--;

  535. 			*(S2++)=' ';

  536. 			break;

  537. 		}

  538. 		op++;

  539. 	}

  540. 

  541. 	//验证括号是否闭合

  542. 	if(brackets)

  543. 	{

  544. 		errorEXIT("The brackets '(' or ')' are not closed");

  545. 	}

  546. 

  547. 	//收尾逆波兰

  548. 	while(S1 !=STACK1)

  549. 	{

  550. 		*(S2++)=*(S1--);

  551. 	}

  552. 	*S2=' ';

  553. 

  554. 	//计算逆波兰

  555. 	op=STACK2;

  556. 	while(*op!=' ')

  557. 	{

  558. 		switch(*op)

  559. 		{

  560. 		case 'A':

  561. 			if(*S3 <0 || *S3 >5)

  562. 			{

  563. 				//time(n)函数需要一个整形自变量介于0到5

  564. 				errorEXIT("The 'time(n)' requires 'n' between 0 to 5");

  565. 			}

  566. 			*(S3-1)=getTIME((int)*S3);

  567. 			S3--;

  568. 			break;

  569. 		case 'B':

  570. 			*S3=3.1415926535897932;

  571. 			break;

  572. 		case 'C':

  573. 			if(*S3 <0)

  574. 			{

  575. 				//负数没有平方根

  576. 				errorEXIT("Negative numbers have no square root");

  577. 			}

  578. 			*(S3-1)=sqrt(*S3);

  579. 			S3--;

  580. 			break;

  581. 		case 'D':

  582. 			if(*S3 <0)

  583. 			{

  584. 				//负数没有对数

  585. 				errorEXIT("Negative numbers are not logarithmic");

  586. 			}

  587. 			*(S3-1)=log10(*S3);

  588. 			S3--;

  589. 			break;

  590. 		case 'E':

  591. 			if(*S3 <0)

  592. 			{

  593. 				//负数没有自然对数

  594. 				errorEXIT("Negative numbers have no natural logarithms");

  595. 			}

  596. 			*(S3-1)=log(*S3);

  597. 			S3--;

  598. 			break;

  599. 		case 'F':

  600. 			*(S3-1)=sin(*S3);

  601. 			S3--;

  602. 			break;

  603. 		case 'G':

  604. 			*(S3-1)=cos(*S3);

  605. 			S3--;

  606. 			break;

  607. 		case 'H':

  608. 			if(*S3==3.1415926535897932/2)

  609. 			{

  610. 				//π/2没有正切值

  611. 				errorEXIT("The pi/2 has no tangent");

  612. 			}

  613. 			*(S3-1)=tan(*S3);

  614. 			S3--;

  615. 			break;

  616. 		case 'I':

  617. 			*(S3-1)=asin(*S3);

  618. 			S3--;

  619. 			break;

  620. 		case 'J':

  621. 			*(S3-1)=acos(*S3);

  622. 			S3--;

  623. 			break;

  624. 		case 'K':

  625. 			*(S3-1)=atan(*S3);

  626. 			S3--;

  627. 			break;

  628. 		case 'L':

  629. 			*(S3-1)=(*S3)*3.1415926535897932/180.0;

  630. 			S3--;

  631. 			break;

  632. 		case 'M':

  633. 			*(S3-1)=fabs(*S3);

  634. 			S3--;

  635. 			break;

  636. 		case 'N':

  637. 			*(S3-1)=(*S3<=0)?(int)(*S3-0.5):(int)(*S3+0.5);

  638. 			S3--;

  639. 			break;

  640. 		case 'O':

  641. 			*(S3-1)=getKEY(50, (int)fabs(*S3));

  642. 			S3--;

  643. 			break;

  644. 		case 'P':

  645. 			*(S3-1)=ceil(*S3);

  646. 			S3--;

  647. 			break;

  648. 		case 'Q':

  649. 			*(S3-1)=exp(*S3);

  650. 			S3--;

  651. 			break;

  652. 		case 'R':

  653. 			*(S3-1)=sinh(*S3);

  654. 			S3--;

  655. 			break;

  656. 		case 'S':

  657. 			*(S3-1)=cosh(*S3);

  658. 			S3--;

  659. 			break;

  660. 		case 'T':

  661. 			*(S3-1)=tanh(*S3);

  662. 			S3--;

  663. 			break;

  664. 		case 'U':

  665. 			*(S3-1)=log(*S3+sqrt((*S3)*(*S3)+1));

  666. 			S3--;

  667. 			break;

  668. 		case 'V':

  669. 			*(S3-1)=log(*S3+sqrt((*S3)*(*S3)-1));

  670. 			S3--;

  671. 			break;

  672. 		case 'W':

  673. 			*(S3-1)=log((1+(*S3))/(1-(*S3)))/2;

  674. 			S3--;

  675. 			break;

  676. 		case 'X':

  677. 			//随机数生成器

  678. 			if(*S3 <0)

  679. 			{

  680. 				//负数不能作为随机数的上限

  681. 				errorEXIT("A negative number can not be used as a random upper bound");

  682. 			}

  683. 			else if(*S3 <2)

  684. 			{

  685. 				//小于2的随机数为0~1之间的小数

  686. 				*(S3-1)=rand() % 1024 /1024.0;

  687. 			}

  688. 			else

  689. 			{

  690. 				*(S3-1)=rand() % (int)(*S3);

  691. 			}

  692. 			S3--;

  693. 			break;

  694. 		case 'Y':

  695. 			*(S3-1)=(int)(*S3);

  696. 			S3--;

  697. 			break;

  698. 		case 'Z':

  699. 			if(*S3 <0)

  700. 			{

  701. 				//负数没有阶乘

  702. 				errorEXIT("Negative numbers have no factorial");

  703. 			}

  704. 			*(S3-1)=fact((*S3));

  705. 			S3--;

  706. 			break;

  707. 		case '+':

  708. 			*(S3-1)+=*S3;

  709. 			S3--;

  710. 			break;

  711. 		case '-':

  712. 			*(S3-1)-=*S3;

  713. 			S3--;

  714. 			break;

  715. 		case '*':

  716. 			*(S3-1)*=*S3;

  717. 			S3--;

  718. 			break;

  719. 		case '%':

  720. 		case '/':

  721. 			if(*S3 !=0)

  722. 			{

  723. 				if(*op=='%')

  724. 				{

  725. 					//取余数

  726. 					*(S3-1)=(int)*(S3-1) % (int)*S3;

  727. 				}

  728. 				else

  729. 				{

  730. 					*(S3-1)/=*S3;

  731. 				}

  732. 

  733. 			}

  734. 			else

  735. 			{

  736. 				//除数不能为零

  737. 				errorEXIT("Divisor is zero error");

  738. 			}

  739. 			S3--;

  740. 			break;

  741. 		case '^':

  742. 			if(*(S3-1)==0 && *S3<0)

  743. 			{

  744. 				//除数不能为零

  745. 				errorEXIT("Function pow's divisor is zero error");

  746. 			}

  747. 			*(S3-1)=pow(*(S3-1), *S3);

  748. 			S3--;

  749. 			break;

  750. 		case ':':

  751. 			op++;

  752. 			*(++S3)=(*op<0)?GLOBAL_VALUE[-1-(*op)]:VALUE[*op];

  753. 			op++;

  754. 			break;

  755. 

  756. 		default :

  757. 			//字符串转浮点

  758. 			di=0, ni=1;

  759. 			while('0'<=*op && *op<='9')

  760. 			{

  761. 				di=10*di+(*op)-'0';

  762. 				op++;

  763. 			}

  764. 			if(*op=='.')

  765. 			{

  766. 				op++;

  767. 				while('0'<=*op && *op<='9')

  768. 				{

  769. 					di=10*di+(*op)-'0';

  770. 					op++, ni*=10;

  771. 				}

  772. 			}

  773. 			*(++S3)=di/ni;

  774. 			break;

  775. 		}

  776. 		op++;

  777. 	}

  778. 

  779. 	if(isINF(*S3)||isNAN(*S3))

  780. 	{

  781. 		errorEXIT("Overflow or illegal operation is calculated");

  782. 	}

  783. 

  784. 	//返回计算结果

  785. 	return *S3;

  786. }

  787. //赋值函数

  788. BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, double* VALUE)

  789. {

  790. 	char *op=(char*)exp, *ep=op, *cp, *kp;

  791. 	int si, i;

  792. 

  793. 	//寻找等号

  794. 	while(!isEND(*(ep++), "=")) {;}

  795. 	//查找变量

  796. 	if(op[0]==':')

  797. 	{

  798. 		if(op[1]==':')

  799. 		{

  800. 			//循环中的瞬时变量::VAR不可赋值

  801. 			errorEXIT("The loop variables '::' are not assignable");

  802. 		}

  803. 

  804. 		//识别变量 :VAR

  805. 		for(si=PRO_NUM-1; si>=0-GLOBAL_SIZE; si--)

  806. 		{

  807. 			cp=op, kp=(si<0)?(char *)GLOBAL_WORDS[-1-si]:WORDS[si];

  808. 			//比对变量字母

  809. 			while((*cp==*kp||*cp==*kp+32) && *kp!='\0')

  810. 			{

  811. 				cp++, kp++;

  812. 			}

  813. 			//验证变量结尾

  814. 			if( ((*cp==' ')||(*cp=='\t')||(*cp=='=')) && (*kp=='\0') )

  815. 			{

  816. 				op=cp-1;

  817. 				break;

  818. 			}

  819. 		}

  820. 		//判断变量是否存在

  821. 		if(si>=0-GLOBAL_SIZE)

  822. 		{

  823. 			//笔属性变量赋值

  824. 			if(si<0)

  825. 			{

  826. 				i=-1-si;

  827. 				GLOBAL_VALUE[i]=RevPolishCore(ep, PRO_NUM, WORDS, VALUE);

  828. 				STRGB* bgRGB;

  829. 				HBRUSH m_brush;

  830. 				switch(i)

  831. 				{

  832. 				case 3:

  833. 					if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>15)

  834. 					{

  835. 						//:PENB变量代表背景色，取值只能在0~15之间

  836. 						errorEXIT("The ':PENB' represents the background color, and only be between 0 to 15");

  837. 					}

  838. 					bgRGB=&LOGO_RGB[(int)GLOBAL_VALUE[i]];

  839. 					//创建画刷

  840. 					m_brush=CreateSolidBrush(bgRGB->VALUE);

  841. 					//填充背景

  842. 					FillRect(hDC1, lrRECT, m_brush);

  843. 					//删除画刷

  844. 					DeleteObject(m_brush);

  845. 					break;

  846. 				case 4:

  847. 					if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>99)

  848. 					{

  849. 						//:PENW变量代表笔粗细，取值只能在0~99之间

  850. 						errorEXIT("The ':PENW' represents the width of the pen, and only be between 0 to 99");

  851. 					}

  852. 					break;

  853. 				case 5:

  854. 					if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>15)

  855. 					{

  856. 						//:PENC变量代表笔颜色，取值只能在0~15之间

  857. 						errorEXIT("The ':PENC' represents the color of the pen, and only be between 0 to 15");

  858. 					}

  859. 					break;

  860. 				case 6:

  861. 					if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>5)

  862. 					{

  863. 						//:PENS变量代表笔光滑，取值只能在0~5之间

  864. 						errorEXIT("The ':PENS' represents the smooth of the pen, and only be between 0 to 5");

  865. 					}

  866. 					break;

  867. 				case 7:

  868. 					if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>255)

  869. 					{

  870. 						//:PENA变量代表笔透明，取值只能在0~255之间

  871. 						errorEXIT("The ':PENA' represents the alpha of the pen, and only be between 0 to 255");

  872. 					}

  873. 					break;

  874. 				default:

  875. 					break;

  876. 				}

  877. 

  878. 			}

  879. 			else

  880. 			{

  881. 				//普通变量赋值

  882. 				VALUE[si]=RevPolishCore(ep, PRO_NUM, WORDS, VALUE);

  883. 			}

  884. 

  885. 		}

  886. 		else

  887. 		{

  888. 			//无效变量

  889. 			errorEXIT("Variable  not exist");

  890. 		}

  891. 	}

  892. 	return TRUE;

  893. }

  894. //批量赋值

  895. BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, double* VALUE)

  896. {

  897. 	if(Line[0] !=':')

  898. 	{

  899. 		errorEXIT("Variable  not exist");

  900. 	}

  901. 	char *gp=(char*)Line;

  902. 	while(isEND(*gp, ":"))

  903. 	{

  904. 		AssignMent(gp, PRO_NUM, WORDS, VALUE);

  905. 		gp++;

  906. 		while(!isEND(*gp, " \t\0"))

  907. 		{

  908. 			gp++;

  909. 		}

  910. 		while(!isEND(*gp, ":\0"))

  911. 		{

  912. 			gp++;

  913. 		}

  914. 		if(*gp=='\0')

  915. 		{

  916. 			return TRUE;

  917. 		}

  918. 	}

  919. 	return TRUE;

  920. }

  921. //测FOR循环

  922. inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, double* VALUE, int CYC)

  923. {

  924. 	if(CYC ==0)

  925. 	{

  926. 		return TRUE;

  927. 	}

  928. 	char *pCHA1, *pCHA2, *pCHA3;

  929. 	pCHA1=strtok((char*)Line, " \t");

  930. 	pCHA2=strtok(       NULL, " \t");

  931. 	pCHA3=strtok(       NULL, " \t");

  932. 	if(pCHA3 !=NULL)

  933. 	{

  934. 		int i=Identify_KeyWords(pCHA1, PRO_NUM, WORDS, " \t");

  935. 		if(i==-1)

  936. 		{

  937. 			errorEXIT("Variable  not exist");

  938. 		}

  939. 		int staNUM=RevPolishCore(pCHA2, PRO_NUM, WORDS, VALUE);

  940. 		int endNUM=RevPolishCore(pCHA3, PRO_NUM, WORDS, VALUE);

  941. 		int var   =VALUE[i];

  942. 		if(staNUM-endNUM<0)

  943. 		{

  944. 			return (var<=endNUM)?TRUE:FALSE;

  945. 		}

  946. 		return (var>=endNUM)?TRUE:FALSE;

  947. 	}

  948. 	else

  949. 	{

  950. 		errorEXIT("Needs more parameters");

  951. 	}

  952. }

  953. //真值条件判断

  954. BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, double* VALUE)

  955. {

  956. 	char* op=CacheTain;

  957. 	char* cp=(char*)exp;

  958. 

  959. 	//过滤行TAB缩进或空格

  960. 	while(*cp=='\t'|| *cp==' ')

  961. 	{

  962. 		cp++;

  963. 	}

  964. 

  965. 	if(*cp =='\0')

  966. 	{

  967. 		return TRUE;

  968. 	}

  969. 

  970. 	char* Line_Cache=op;

  971. 	int   i=-1, flag=0;

  972. 

  973. 	while(!isEND(*cp, " \t\0"))

  974. 	{

  975. 

  976. 		switch(*cp)

  977. 		{

  978. 		case '!':

  979. 			flag+=8;

  980. 			break;

  981. 		case '>':

  982. 			if(flag==0||flag==8)

  983. 			{

  984. 				*(op++)='-', *(op++)='(';

  985. 			}

  986. 			flag+=4;

  987. 			break;

  988. 		case '<':

  989. 			if(flag==0||flag==8)

  990. 			{

  991. 				*(op++)='-', *(op++)='(';

  992. 			}

  993. 			flag+=2;

  994. 			break;

  995. 		case '=':

  996. 			if(flag==0||flag==8)

  997. 			{

  998. 				*(op++)='-', *(op++)='(';

  999. 			}

  1000. 			flag+=1;

  1001. 			break;

  1002. 		default:

  1003. 			*(op++)=*(cp++);

  1004. 			continue;

  1005. 		}

  1006. 		cp++;

  1007. 	}

  1008. 	//闭合括号

  1009. 	*(op++)=(flag!=8)?')':'\0';

  1010. 	*op='\0' ;

  1011. 

  1012. 	float m=RevPolishCore(Line_Cache, PRO_NUM, WORDS, VALUE);

  1013. 

  1014. 	switch(flag)

  1015. 	{

  1016. 	case 8:

  1017. 		//逻辑非

  1018. 		return (m==0)?TRUE:FALSE;

  1019. 	case 4:

  1020. 		return (m >0)?TRUE:FALSE;

  1021. 		break;

  1022. 	case 2:

  1023. 		return (m <0)?TRUE:FALSE;

  1024. 		break;

  1025. 	case 1:

  1026. 		return (m==0)?TRUE:FALSE;

  1027. 		break;

  1028. 	case 3:

  1029. 	case 12:

  1030. 		return (m<=0)?TRUE:FALSE;

  1031. 		break;

  1032. 	case 5:

  1033. 	case 10:

  1034. 		return (m>=0)?TRUE:FALSE;

  1035. 		break;

  1036. 	case 6:

  1037. 	case 9:

  1038. 		return (m!=0)?TRUE:FALSE;

  1039. 		break;

  1040. 

  1041. 	default:

  1042. 		errorEXIT("Wrong logic");

  1043. 	}

  1044. }

  1045. //批量真值判断

  1046. BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, double* VALUE)

  1047. {

  1048. 	char *gp=(char*)Line;

  1049. 	int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");

  1050. 	if(li !=-1)

  1051. 	{

  1052. 		gp+=LGC_LLENS[li];

  1053. 	}

  1054. 

  1055. 	do

  1056. 	{

  1057. 		while(isEND(*gp, " \t"))

  1058. 		{

  1059. 			gp++;

  1060. 		}

  1061. 		if(JudgMent(gp, PRO_NUM, WORDS, VALUE))

  1062. 		{

  1063. 

  1064. 			switch(li)

  1065. 			{

  1066. 			case 0:

  1067. 				return FALSE;

  1068. 			case 1:

  1069. 				break;

  1070. 			case 2:

  1071. 				return TRUE;

  1072. 			default:

  1073. 				return TRUE;

  1074. 			}

  1075. 		}

  1076. 		else

  1077. 		{

  1078. 			switch(li)

  1079. 			{

  1080. 			case 0:

  1081. 				break;

  1082. 			case 1:

  1083. 				return FALSE;

  1084. 			case 2:

  1085. 				break;

  1086. 			default:

  1087. 				return FALSE;

  1088. 			}

  1089. 		}

  1090. 		while(!isEND(*gp, " \t\0"))

  1091. 		{

  1092. 			gp++;

  1093. 		}

  1094. 		if(*gp=='\0')

  1095. 		{

  1096. 			switch(li)

  1097. 			{

  1098. 			case 0:

  1099. 				return TRUE;

  1100. 			case 1:

  1101. 				return TRUE;

  1102. 			case 2:

  1103. 				return FALSE;

  1104. 			}

  1105. 		}

  1106. 		while(isEND(*gp, " \t"))

  1107. 		{

  1108. 			gp++;

  1109. 		}

  1110. 

  1111. 	}

  1112. 	while(*gp !='\0');

  1113. }

  1114. //PR输出函数

  1115. char* SuperPrintf(const char* pline, int PRO_NUM, char** WORDS, double* VALUE)

  1116. {

  1117. 	char* op=(char*)pline;

  1118. 	char* cp;

  1119. 	char* sp=Auxiliary;

  1120. 	while(*op !='\0')

  1121. 	{

  1122. 

  1123. 		switch(*op)

  1124. 		{

  1125. 		case '\\':

  1126. 			switch(*(++op))

  1127. 			{

  1128. 			case 'b':

  1129. 			case 'B':

  1130. 				*(sp++)='\b';

  1131. 				break;

  1132. 			case 'e':

  1133. 			case 'E':

  1134. 				*(sp++)='\0';

  1135. 				break;

  1136. 			case 'r':

  1137. 			case 'R':

  1138. 				*(sp++)='\r';

  1139. 				break;

  1140. 			case 'n':

  1141. 			case 'N':

  1142. 				*(sp++)='\n';

  1143. 				break;

  1144. 			case 't':

  1145. 			case 'T':

  1146. 				*(sp++)='\t';

  1147. 				break;

  1148. 			case '{':

  1149. 			case '}':

  1150. 				*(sp++)=*op;

  1151. 				break;

  1152. 			case '\\':

  1153. 				*(sp++)='\\';

  1154. 				break;

  1155. 			default:

  1156. 				errorEXIT("Uninterpreted characters");

  1157. 			}

  1158. 			break;

  1159. 		case '{':

  1160. 			op++, cp=CacheTain;

  1161. 			while(*op!='\0' && *op!='}')

  1162. 			{

  1163. 				*(cp++)=*(op++);

  1164. 			}

  1165. 			if(*op=='\0')

  1166. 			{

  1167. 				errorEXIT("Missing '}'");

  1168. 			}

  1169. 

  1170. 			*cp='\0';

  1171. 			sprintf(sp, "%.12g", RevPolishCore(CacheTain, PRO_NUM, WORDS, VALUE));

  1172. 			while(*(sp++)!='\0') {;}

  1173. 			sp--;

  1174. 			break;

  1175. 		default:

  1176. 			*(sp++)=*(op);

  1177. 			break;

  1178. 		}

  1179. 		op++;

  1180. 	}

  1181. 	*(sp++)='\n', *(sp++)='\0';

  1182. 	return Auxiliary;

  1183. }

  1184. /***************绘图函数群***************/

  1185. //隐藏光标

  1186. BOOL SizeCursor(int size)

  1187. {

  1188. 	CONSOLE_CURSOR_INFO cursor_info = {(DWORD)((size==0)?25:size), (size==0)?FALSE:TRUE};

  1189. 	return SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);

  1190. }

  1191. //平滑画线函数

  1192. void drawSMOOTHLINE(HDC hDC, float penWith, SmoothingMode mode, BYTE sharpMODE, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2, float angel)

  1193. {

  1194. 	Graphics gp(hDC);

  1195. 	gp.SetSmoothingMode(mode);

  1196. 	Pen pen(Color(alpha,penRGB->R,penRGB->G,penRGB->B), penWith);

  1197. 

  1198. 	if(angel !=0)

  1199. 	{

  1200. 		Matrix matrix;

  1201. 		matrix.RotateAt(angel, PointF(x1, y1)); // 旋转angel度

  1202. 		gp.SetTransform(&matrix);

  1203. 	}

  1204. 	switch(sharpMODE)

  1205. 	{

  1206. 	case 0:

  1207. 		gp.DrawLine(&pen, PointF(x1, y1), PointF(x2, y2));

  1208. 		break;

  1209. 	case 1:

  1210. 		gp.DrawEllipse(&pen, RectF(x1-x2,y1-y2,x2*2,y2*2));

  1211. 		break;

  1212. 	case 2:

  1213. 		gp.DrawRectangle(&pen, RectF(x1-x2,y1-y2,x2*2,y2*2));

  1214. 		break;

  1215. 	}

  1216. 	DeleteObject(&pen);

  1217. }

  1218. //画线函数，实现FD

  1219. BOOL drawLINE(HDC hDC, float d)

  1220. {

  1221. 	float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];

  1222. 	GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);

  1223. 	GLOBAL_VALUE[1]+=d * cos(GLOBAL_VALUE[2]*0.017453292519943);

  1224. 

  1225. 	//当为PU抬笔时，不做绘图

  1226. 	if(!penMODE)

  1227. 	{

  1228. 		return FALSE;

  1229. 	}

  1230. 	drawSMOOTHLINE(hDC, (float)GLOBAL_VALUE[4], (SmoothingMode)(int)GLOBAL_VALUE[6], 0, (BYTE)GLOBAL_VALUE[7], &LOGO_RGB[(int)GLOBAL_VALUE[5]], base_X+x1, base_Y-y1, base_X+GLOBAL_VALUE[0], base_Y-GLOBAL_VALUE[1], 0);

  1231. 	return TRUE;

  1232. }

  1233. //退步函数，实现BK

  1234. void backWARD(float d)

  1235. {

  1236. 	GLOBAL_VALUE[0]-=d * sin(GLOBAL_VALUE[2]*0.017453292519943);

  1237. 	GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);

  1238. }

  1239. //图形旋转

  1240. int RotateDC(HDC hDC, double angle)

  1241. {

  1242. 	if(angle==0)

  1243. 	{

  1244. 		return 1;

  1245. 	}

  1246. 	XFORM Matrix;

  1247. 	double rad =-angle * 0.017453292519943, rtmp1=base_X+GLOBAL_VALUE[0], rtmp2=base_Y-GLOBAL_VALUE[1];

  1248. 	Matrix.eM11 = (float)cos(rad);

  1249. 	Matrix.eM12 = (float)sin(rad);

  1250. 	Matrix.eM21 =-(float)sin(rad);

  1251. 	Matrix.eM22 = (float)cos(rad);

  1252. 	Matrix.eDx  = (float)(rtmp1-cos(rad)*rtmp1+sin(rad)*rtmp2);

  1253. 	Matrix.eDy  = (float)(rtmp2-cos(rad)*rtmp2-sin(rad)*rtmp1);

  1254. 	SetGraphicsMode(hDC, GM_ADVANCED);

  1255. 	SetWorldTransform(hDC, &Matrix);

  1256. 	return 0;

  1257. }

  1258. //文字绘制

  1259. void drawTEXT(HDC hDC, int fontSIZE, int fontSTYLE, int fontCOLOR, char* fontNAME, char* pSTRING)

  1260. {

  1261. 	Graphics graphicsp(hDC), *graph=&graphicsp;

  1262. 	FontFamily fontFAMILY(AnsiToWCHAR(fontNAME));

  1263. 	Font fontp(&fontFAMILY, fontSIZE, (FontStyle)fontSTYLE, UnitPixel);

  1264. 	STRGB* txRGB=&LOGO_RGB[fontCOLOR];

  1265. 	SolidBrush brushp(Color((int)GLOBAL_VALUE[7], txRGB->R, txRGB->G, txRGB->B));

  1266. 	graph->DrawString(AnsiToWCHAR(pSTRING), -1, &fontp, PointF(base_X+GLOBAL_VALUE[0],base_Y-GLOBAL_VALUE[1]), &brushp);

  1267. 	//清理绘图工具

  1268. 	DeleteObject(&brushp);

  1269. 	DeleteObject(&fontp);

  1270. 	DeleteObject(&fontFAMILY);

  1271. 	DeleteObject(&graphicsp);

  1272. }

  1273. 

  1274. /***************解析函数群***************/

  1275. //脚本解析函数

  1276. BOOL FileScript(char* prossName, int PRO_NUM, double* PRO_VALUE)

  1277. {

  1278. 	//初始参数，其中KLevel为当前循环层号；

  1279. 	int i=0, j=0, ki, KLevel=0, SN=-1, Line_LEN=0, fcolor=-1, BASE_VAR_NUM=PRO_NUM;

  1280. 	float pTMP1, pTMP2, pTMP3, pTMP4, pTMP5, wTIME;

  1281. 	char *prepos=NULL, *pCHA1, *pCHA2, *pCHA3, *pCHA4, *pCHA5;

  1282. 	double tpadd;

  1283. 

  1284. 	//定义过程变量存储容器，即定义 :A型变量，后接 ::A型变量

  1285. 	char** PRO_WORDS=(char**)calloc(LOOP_LEVELS, sizeof(char*));

  1286. 

  1287. 	//初始化开关参数，SFLAG[0]==1开始；

  1288. 	char* SFLAG=(char*)calloc(8, sizeof(char));

  1289. 	SFLAG[2]=-1;

  1290. 

  1291. 	//初始化循环参量数组

  1292. 	int*   FORI_CYCL=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));

  1293. 	int*   FORI_LNUM=(int  *)calloc(LOOP_LEVELS,   sizeof(int  ));

  1294. 	char** FORI_FTEL=(char**)calloc(LOOP_LEVELS,   sizeof(char*));

  1295. 	char** FORI_FEND=(char**)calloc(LOOP_LEVELS,   sizeof(char*));

  1296. 	BOOL*  FORI_IFOT=(BOOL *)calloc(LOOP_LEVELS,   sizeof(BOOL ));

  1297. 

  1298. 	//分配行容器

  1299. 	char* LCache=(char*)calloc(1025, sizeof(char));

  1300. 	//用于错误反馈的行指针标记

  1301. 	CUR_LINEPOINTER=LCache;

  1302. 

  1303. 	//辅助行指针

  1304. 	char* Line;

  1305. 

  1306. 	//辅助流指针

  1307. 	char* tmpfp=tRAM;

  1308. 

  1309. 	while(*tmpfp !='\0')

  1310. 	{

  1311. 

  1312. 		//记录位置

  1313. 		char* prepos=tmpfp;

  1314. 

  1315. 		//指针置换

  1316. 		Line=LCache;

  1317. 

  1318. 		while(*tmpfp !='\n' && *tmpfp !='\0')

  1319. 		{

  1320. 			*(Line++)=*(tmpfp++);

  1321. 		}

  1322. 		if(*tmpfp =='\n')

  1323. 		{

  1324. 			tmpfp++;

  1325. 		}

  1326. 		*Line='\0';

  1327. 		//指针回首

  1328. 		Line=LCache;

  1329. 

  1330. 		//行计数器

  1331. 		i++, CUR_LINENUM=i;

  1332. 

  1333. 		//过滤行TAB缩进或前空格

  1334. 		while(*Line=='\t'|| *Line==' ')

  1335. 		{

  1336. 			Line++;

  1337. 		}

  1338. 

  1339. 		//过滤空行或行注释

  1340. 		if(

  1341. 		    (Line[0]=='\0')                 ||

  1342. 		    (Line[0]=='/' && Line[1]=='/')

  1343. 		)

  1344. 		{

  1345. 			continue;

  1346. 		}

  1347. 

  1348. 		//过滤段间注释

  1349. 		if(

  1350. 		    (Line[0]=='/' &&Line[1]=='*')

  1351. 		)

  1352. 		{

  1353. 			SFLAG[3]=1;

  1354. 			continue;

  1355. 

  1356. 		}

  1357. 		else if(

  1358. 		    (Line[0]=='*' &&Line[1]=='/')

  1359. 		)

  1360. 		{

  1361. 			SFLAG[3]=0;

  1362. 			continue;

  1363. 

  1364. 		}

  1365. 

  1366. 		//识别子过程名

  1367. 		if(

  1368. 		    (isEND(Line[2], " \t\0") )      &&

  1369. 		    (Line[0]=='T' || Line[0]=='t')  &&

  1370. 		    (Line[1]=='O' || Line[1]=='o')

  1371. 

  1372. 		)

  1373. 		{

  1374. 			Line+=2;

  1375. 

  1376. 			//过滤TO后TAB缩进，或TO后空格

  1377. 			while(*Line=='\t'|| *Line==' ')

  1378. 			{

  1379. 				Line++;

  1380. 			}

  1381. 

  1382. 			if(isKEY(Line, prossName, " \t\0"))

  1383. 			{

  1384. 				SFLAG[0]=1, SFLAG[4]=1;

  1385. 				ARGS(Line, PRO_WORDS, PRO_NUM, i, Line);

  1386. 			}

  1387. 			else

  1388. 			{

  1389. 				SFLAG[0]=0;

  1390. 			}

  1391. 			continue;

  1392. 		}

  1393. 

  1394. 		//开始开关未打开，或遇到段注释，或遇到空行

  1395. 		if(

  1396. 		    SFLAG[0]==0		       ||

  1397. 		    SFLAG[3]==1		       ||

  1398. 		    Line[0]=='('

  1399. 

  1400. 		)

  1401. 		{

  1402. 			continue;

  1403. 		}

  1404. 

  1405. 		//IF...ELIF连带性分析

  1406. 

  1407. 		if(

  1408. 		    (FORI_IFOT[KLevel+1] && SFLAG[1]==0) &&

  1409. 		    (Line[0]!='E'&&Line[0]!='e')   ||

  1410. 		    (Line[1]!='L'&&Line[1]!='l')   ||

  1411. 		    (Line[2]!='I'&&Line[2]!='i')   ||

  1412. 		    (Line[3]!='F'&&Line[3]!='f')

  1413. 

  1414. 		)

  1415. 		{

  1416. 			FORI_IFOT[KLevel+1]=FALSE;

  1417. 		}

  1418. 

  1419. 		//解析循环结束标签，循环加速

  1420. 		if(Line[0]==')')

  1421. 		{

  1422. 			if(KLevel>SFLAG[1])

  1423. 			{

  1424. 				if(FORI_CYCL[KLevel] <0)

  1425. 				{

  1426. 					tpadd=RevPolishCore(Line+1, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1427. 					PRO_VALUE[0-FORI_CYCL[KLevel]]+=(tpadd==0)?1:tpadd;

  1428. 				}

  1429. 				if(FORI_FEND[KLevel]==NULL)

  1430. 				{

  1431. 					FORI_FEND[KLevel]=tmpfp;

  1432. 				}

  1433. 				tmpfp=FORI_FTEL[KLevel];

  1434. 				i=FORI_LNUM[KLevel];

  1435. 

  1436. 			}

  1437. 			else

  1438. 			{

  1439. 

  1440. 

  1441. 				FORI_FTEL[KLevel]=NULL;

  1442. 				FORI_FEND[KLevel]=NULL;

  1443. 				FORI_CYCL[KLevel]=0;

  1444. 				SFLAG[1]=0;

  1445. 			}

  1446. 			KLevel--;

  1447. 			continue;

  1448. 

  1449. 		}

  1450. 		else

  1451. 		{

  1452. 			if((ki=Identify_KeyWords(Line, CYC_SIZE, (char**)CYC_WORDS, " \t\0")) !=-1)

  1453. 			{

  1454. 				Line=passNULL(Line+CYC_LLENS[ki]);

  1455. 				KLevel++;

  1456. 				//解析循环

  1457. 				if(

  1458. 				    ki==0 && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)                     ||

  1459. 				    ki==1 && FORI_CYCL[KLevel]<RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)                         ||

  1460. 				    ki==2 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)                                            ||

  1461. 				    ki==3 && isForTrue(Line, PRO_NUM, PRO_WORDS, PRO_VALUE,  FORI_CYCL[KLevel])                           ||

  1462. 				    ki==4 && (FORI_IFOT[KLevel]) && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)

  1463. 

  1464. 				)

  1465. 				{

  1466. 					if( FORI_FTEL[KLevel]==NULL )

  1467. 					{

  1468. 						FORI_FTEL[KLevel]=prepos;

  1469. 						FORI_LNUM[KLevel]=i-1;

  1470. 						if(ki==3)

  1471. 						{

  1472. 							char *tp1, *tp2;

  1473. 							//提取瞬时变量名

  1474. 							if((tp1=strtok(Line, " \t"))==NULL)

  1475. 							{

  1476. 								errorEXIT("Missing parameter");

  1477. 							}

  1478. 							PRO_WORDS[PRO_NUM]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));

  1479. 							strcpy(PRO_WORDS[PRO_NUM], tp1);

  1480. 							//提取始步

  1481. 							if((tp2=strtok(NULL, " \t"))==NULL)

  1482. 							{

  1483. 								errorEXIT("Missing parameter");

  1484. 							}

  1485. 							PRO_VALUE[PRO_NUM]=RevPolishCore(tp2, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1486. 							FORI_CYCL[KLevel] =0-PRO_NUM;

  1487. 							PRO_NUM++;

  1488. 

  1489. 						}

  1490. 						if(ki==0 || ki==4)

  1491. 						{

  1492. 							FORI_IFOT[KLevel]=FALSE;

  1493. 						}

  1494. 					}

  1495. 

  1496. 					if(ki !=3)

  1497. 					{

  1498. 						FORI_CYCL[KLevel]  ++;

  1499. 					}

  1500. 

  1501. 				}

  1502. 				else

  1503. 				{

  1504. 					if((ki==0) && FORI_CYCL[KLevel]==0)

  1505. 					{

  1506. 						FORI_IFOT[KLevel]=TRUE;

  1507. 					}

  1508. 					if(FORI_FEND[KLevel] !=NULL)

  1509. 					{

  1510. 						if(FORI_CYCL[KLevel] <0)

  1511. 						{

  1512. 							free(PRO_WORDS[PRO_NUM]);

  1513. 							PRO_NUM-=1;

  1514. 						}

  1515. 						tmpfp=FORI_FEND[KLevel];

  1516. 						i=FORI_LNUM[KLevel]-1;

  1517. 						FORI_FTEL[KLevel]=NULL;

  1518. 						FORI_FEND[KLevel]=NULL;

  1519. 						FORI_CYCL[KLevel]=0;

  1520. 						KLevel--;

  1521. 					}

  1522. 					else

  1523. 					{

  1524. 						SFLAG[1]=KLevel;

  1525. 					}

  1526. 				}

  1527. 				continue;

  1528. 			}

  1529. 		}

  1530. 

  1531. 		//语句块循环开关

  1532. 		if(SFLAG[1]!=0)

  1533. 		{

  1534. 			continue;

  1535. 		}

  1536. 

  1537. 		//解析命令行

  1538. 		if((SN=Identify_KeyWords(Line, KEY_SIZE, (char**)KEY_WORDS, " \t\0")) !=-1)

  1539. 		{

  1540. 			Line=(SN==8)?Line+KEY_LLENS[SN]+1:passNULL(Line+KEY_LLENS[SN]);

  1541. 		}

  1542. 		else

  1543. 		{

  1544. 

  1545. 			//定义过程传参容器

  1546. 			double* PAR_VALUE=(double*)calloc(LOOP_LEVELS, sizeof(double));

  1547. 			//调用子过程

  1548. 			if(! FileScript(Line,    ARGP(Line, PAR_VALUE, PRO_NUM, PRO_WORDS, PRO_VALUE),    PAR_VALUE) )

  1549. 			{

  1550. 				fprintf(stderr, "[%d]:Undefined procedure name    '%s\n", i, passNULL(LCache));

  1551. 				exit(1);

  1552. 			}

  1553. 			free(PAR_VALUE);

  1554. 			continue;

  1555. 

  1556. 		}

  1557. 		switch(SN)

  1558. 		{

  1559. 		case  0:

  1560. 			//FD

  1561. 			drawLINE(hDC, RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));

  1562. 			break;

  1563. 		case  1:

  1564. 			//BK

  1565. 			backWARD(RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));

  1566. 			break;

  1567. 		case  2:

  1568. 			//LT

  1569. 			GLOBAL_VALUE[2]-=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1570. 			break;

  1571. 		case  3:

  1572. 			//RT

  1573. 			GLOBAL_VALUE[2]+=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1574. 			break;

  1575. 		case  4:

  1576. 			//PU

  1577. 			penMODE=FALSE;

  1578. 			break;

  1579. 		case  5:

  1580. 			//PD

  1581. 			if(SFLAG[2] !=-1)

  1582. 			{

  1583. 				GLOBAL_VALUE[5]=SFLAG[2];

  1584. 				SFLAG[2] =-1;

  1585. 			}

  1586. 			penMODE=TRUE;

  1587. 			break;

  1588. 		case  6:

  1589. 			//PE

  1590. 			if(SFLAG[2] ==-1)

  1591. 			{

  1592. 				SFLAG[2]=GLOBAL_VALUE[5];

  1593. 				GLOBAL_VALUE[5]=GLOBAL_VALUE[3];

  1594. 			}

  1595. 			break;

  1596. 		case  7:

  1597. 			//CS

  1598. 			InvalidateRect(hCMD, NULL, FALSE);

  1599. 			GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;

  1600. 			break;

  1601. 		case  8:

  1602. 			//PR, 打印输出

  1603. 			fputs(SuperPrintf(Line, PRO_NUM, PRO_WORDS, PRO_VALUE), stdout);

  1604. 			break;

  1605. 		case  9:

  1606. 			//HM

  1607. 			GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;

  1608. 			break;

  1609. 		case 10:

  1610. 			//STOP

  1611. 			free(PRO_WORDS);

  1612. 			free(SFLAG);

  1613. 			free(FORI_CYCL);

  1614. 			free(FORI_LNUM);

  1615. 			free(FORI_FTEL);

  1616. 			free(FORI_IFOT);

  1617. 			free(LCache);

  1618. 			return TRUE;

  1619. 		case 11:

  1620. 			//EXIT

  1621. 			exit(0);

  1622. 		case 12:

  1623. 			//FILL

  1624. 			if((fcolor=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)) !=-1)

  1625. 			{

  1626. 				//创建画刷

  1627. 				STRGB* bgRGB=&LOGO_RGB[fcolor];

  1628. 				HBRUSH m_brush=CreateSolidBrush(bgRGB->VALUE);

  1629. 				SelectObject(hDC1, m_brush);

  1630. 				ExtFloodFill(hDC1,  base_X+GLOBAL_VALUE[0], base_Y-GLOBAL_VALUE[1],  GetPixel(hDC1,base_X+GLOBAL_VALUE[0],base_Y-GLOBAL_VALUE[1]),FLOODFILLSURFACE);

  1631. 				//删除画刷

  1632. 				DeleteObject(m_brush);

  1633. 			}

  1634. 			break;

  1635. 		case 13:

  1636. 			//TEXT

  1637. 			pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t"), pCHA4=strtok(NULL, " \t"), pCHA5=strtok(NULL, " \t");

  1638. 			if(pCHA5 !=NULL)

  1639. 			{

  1640. 				pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1641. 				pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1642. 				pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1643. 				drawTEXT(hDC, (int)fabs(pTMP1), (int)fabs(pTMP2)%5, (int)fabs(pTMP3)%16, pCHA4, SuperPrintf(pCHA5, PRO_NUM, PRO_WORDS, PRO_VALUE));

  1644. 			}

  1645. 			else

  1646. 			{

  1647. 				errorEXIT("Needs more parameters");

  1648. 			}

  1649. 			break;

  1650. 		case 14:

  1651. 			//WAIT

  1652. 			wTIME=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1653. 			if(wTIME>0)

  1654. 			{

  1655. 				Sleep(wTIME);

  1656. 			}

  1657. 			else

  1658. 			{

  1659. 				getch();

  1660. 			}

  1661. 			break;

  1662. 		case 15:

  1663. 			//ROTE

  1664. 			RotateDC(hDC1, (double)RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));

  1665. 			break;

  1666. 		case 16:

  1667. 			//MEMUSE，开辟内存画布

  1668. 			if(!memMODE)

  1669. 			{

  1670. 				BitBlt(hDC3,0,0,lrRECT->right,lrRECT->bottom, hDC1,0,0,SRCCOPY);

  1671. 				memMODE=TRUE;

  1672. 			}

  1673. 			BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);

  1674. 			hDC=hDC2;

  1675. 			break;

  1676. 		case 17:

  1677. 			//MEMSEE，展示内存画布

  1678. 			BitBlt(hDC1,0,0,lrRECT->right,lrRECT->bottom, hDC2,0,0,SRCCOPY);

  1679. 			BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);

  1680. 			break;

  1681. 		case 18:

  1682. 			//MEMOUT，丢弃内存画布

  1683. 			memMODE=FALSE;

  1684. 			hDC=hDC1;

  1685. 			break;

  1686. 		case 19:

  1687. 			//MAKE，  赋值

  1688. 			MoreAssignMent(passNULL(Line), PRO_NUM, PRO_WORDS, PRO_VALUE);

  1689. 			break;

  1690. 		case 20:

  1691. 			//SETXY，画线函数

  1692. 			pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t");

  1693. 			if(pCHA2 !=NULL)

  1694. 			{

  1695. 				pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1696. 				pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1697. 				if(penMODE)

  1698. 				{

  1699. 					drawSMOOTHLINE(hDC, (float)GLOBAL_VALUE[4], (SmoothingMode)(int)GLOBAL_VALUE[6], 0, (BYTE)GLOBAL_VALUE[7], &LOGO_RGB[(int)GLOBAL_VALUE[5]], base_X+GLOBAL_VALUE[0], base_Y-GLOBAL_VALUE[1], base_X+pTMP1, base_Y-pTMP2, 0);

  1700. 				}

  1701. 				GLOBAL_VALUE[0]=pTMP1, GLOBAL_VALUE[1]=pTMP2;

  1702. 

  1703. 			}

  1704. 			else

  1705. 			{

  1706. 				errorEXIT("Needs more parameters");

  1707. 			}

  1708. 			break;

  1709. 		case 21:

  1710. 			//RECT，画方函数

  1711. 			pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t");

  1712. 			if(pCHA3 !=NULL)

  1713. 			{

  1714. 				pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1715. 				pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1716. 				pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1717. 				drawSMOOTHLINE(hDC, (float)GLOBAL_VALUE[4], (SmoothingMode)(int)GLOBAL_VALUE[6], 1, (BYTE)GLOBAL_VALUE[7], &LOGO_RGB[(int)GLOBAL_VALUE[5]], base_X+GLOBAL_VALUE[0], base_Y-GLOBAL_VALUE[1], pTMP1, pTMP2, pTMP3);

  1718. 

  1719. 			}

  1720. 			else

  1721. 			{

  1722. 				errorEXIT("Needs more parameters");

  1723. 			}

  1724. 			break;

  1725. 		case 22:

  1726. 			//OVAL，画圆函数

  1727. 			pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t");

  1728. 			if(pCHA3 !=NULL)

  1729. 			{

  1730. 				pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1731. 				pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1732. 				pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);

  1733. 				drawSMOOTHLINE(hDC, (float)GLOBAL_VALUE[4], (SmoothingMode)(int)GLOBAL_VALUE[6], 2, (BYTE)GLOBAL_VALUE[7], &LOGO_RGB[(int)GLOBAL_VALUE[5]], base_X+GLOBAL_VALUE[0], base_Y-GLOBAL_VALUE[1], pTMP1, pTMP2, pTMP3);

  1734. 

  1735. 			}

  1736. 			else

  1737. 			{

  1738. 				errorEXIT("Needs more parameters");

  1739. 			}

  1740. 			break;

  1741. 

  1742. 		default:

  1743. 			errorEXIT("Error line");

  1744. 		}

  1745. 	}

  1746. 	if(!(BOOL)SFLAG[4])

  1747. 	{

  1748. 		return FALSE;

  1749. 	}

  1750. 	free(PRO_WORDS);

  1751. 	free(SFLAG);

  1752. 	free(FORI_CYCL);

  1753. 	free(FORI_LNUM);

  1754. 	free(FORI_FTEL);

  1755. 	free(FORI_IFOT);

  1756. 	free(LCache);

  1757. 	return TRUE;

  1758. }

  1759. 

  1760. /*************MAIN主函数入口*************/

  1761. int main(int argc, char** argv)

  1762. {

  1763. 	if(argc!=2)

  1764. 	{

  1765. 		//异常则抛出使用说明

  1766. 		fputs("COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0\nUSAGE: COOL [FILE]\n", stdout);

  1767. 		return 1;

  1768. 	}

  1769. 

  1770. 	//读文件流

  1771. 	FILE* fp=fopen(argv[1], "r");

  1772. 	if(fp==NULL)

  1773. 	{

  1774. 		fputs("Failed to read file.", stdout);

  1775. 		return 2;

  1776. 	}

  1777. 	//隐藏光标

  1778. 	SizeCursor(0);

  1779. 

  1780. 	//测量尺寸

  1781. 	int fsize=0;

  1782. 	fseek(fp, 0, SEEK_END);

  1783. 	fsize=ftell(fp);

  1784. 	//指针复原

  1785. 	fseek(fp, 0, SEEK_SET);

  1786. 	//超过1M的脚本，拒绝执行

  1787. 	if(fsize > 1*1024*1024)

  1788. 	{

  1789. 		fputs("File size is too large, out of memory.", stdout);

  1790. 		return 1;

  1791. 	}

  1792. 

  1793. 	//读入内存

  1794. 	tRAM=(char*)malloc((fsize+1)*sizeof(char));

  1795. 	fread(tRAM, fsize, 1, fp);

  1796. 	tRAM[fsize]='\0';

  1797. 	//释放文件

  1798. 	fclose(fp);

  1799. 

  1800. 	//初始化随机种子

  1801. 	srand((unsigned)time(NULL));

  1802. 

  1803. 	//初始化GdiPlus

  1804. 	ULONG_PTR gdipludToken;

  1805. 	GdiplusStartupInput gdiplusInput;

  1806. 	GdiplusStartup(&gdipludToken,&gdiplusInput,NULL);

  1807. 

  1808. 	{

  1809. 		//获取CMD窗口句柄

  1810. 		hCMD=GetConsoleWindow();

  1811. 		//获取CMD窗口大小

  1812. 		lrRECT=&winRECT;

  1813. 		GetClientRect(hCMD, lrRECT);

  1814. 		//获取像素坐标基值

  1815. 		base_X=lrRECT->right/2, base_Y=lrRECT->bottom/2;

  1816. 		lrRECT->right=base_X*2, lrRECT->bottom=base_Y*2;

  1817. 

  1818. 		//CMD画布

  1819. 		hDC1=GetDC(hCMD);

  1820. 		HBITMAP hBitmap1=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);

  1821. 		SelectObject(hDC1, hBitmap1);

  1822. 

  1823. 		//内存画布

  1824. 		hWND2=NULL;

  1825. 		hDC2=CreateCompatibleDC(GetDC(hWND2));

  1826. 		HBITMAP hBitmap2=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);

  1827. 		SelectObject(hDC2, hBitmap2);

  1828. 

  1829. 		//辅助画布

  1830. 		hWND3=NULL;

  1831. 		hDC3=CreateCompatibleDC(GetDC(hWND3));

  1832. 		HBITMAP hBitmap3=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);

  1833. 		SelectObject(hDC3, hBitmap3);

  1834. 

  1835. 		//运行脚本

  1836. 		double* PAR_VALUE=(double*)calloc(LOOP_LEVELS, sizeof(double));

  1837. 

  1838. 		//主DC选择CMD画布

  1839. 		hDC=hDC1;

  1840. 

  1841. 		//寻找主函数入口点

  1842. 		FileScript("MAIN", 1, PAR_VALUE);

  1843. 

  1844. 		//释放DC

  1845. 		ReleaseDC(NULL, hDC3);

  1846. 		ReleaseDC(NULL, hDC2);

  1847. 		ReleaseDC(hCMD, hDC1);

  1848. 		DeleteDC(hDC3);

  1849. 		DeleteDC(hDC2);

  1850. 		DeleteDC(hDC1);

  1851. 		DeleteObject(hBitmap3);

  1852. 		DeleteObject(hBitmap2);

  1853. 		DeleteObject(hBitmap1);

  1854. 		//释放内存

  1855. 		free(PAR_VALUE);

  1856. 		free(tRAM);

  1857. 	}

  1858. 

  1859. 	//关闭GdiPlus

  1860. 	GdiplusShutdown(gdipludToken);

  1861. 	return 0;

  1862. }
复制代码
1

评分人数

    • 老刘1号: 沉迷于绘图无法自拔的happy兄技术 + 1
收藏 分享

返回列表