基于CLGO的COOL解释器发布

happy886rr · 发表于 2017-5-3 12:22:08

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

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

希尔波特催眠术脚本

@echo off
mode con cols=100 lines=30
cool "%~f0"
exit
//主函数入口
to main
make :penw=3
for :a 5 7
(
make :penx=500 :peny=-500
hilbert_curve 1000/(2^:a-1) :a 90
)
for :a 6 3
(
make :penx=500 :peny=-500
hilbert_curve 1000/(2^:a-1) :a 90
)-1
functions_img 1
exit
//希尔波特曲线
to hilbert_curve :len :recursive_times :angle
if :recursive_times=0
(
stop
)
if :recursive_times/3=1
(
make :penc=rand(15)+1
)
if or :penc=9 :penc=10
(
make :penc=7
)
lt :angle
hilbert_curve :len :recursive_times-1 -:angle
fd :len
rt :angle
hilbert_curve :len :recursive_times-1 :angle
fd :len
hilbert_curve :len :recursive_times-1 :angle
rt :angle
fd :len
hilbert_curve :len :recursive_times-1 -:angle
lt :angle
//旋转体系
to functions_img :add
memuse
for :a 1 36000
(
make :penx=0 :peny=0
rote :a
memsee
):add
memout

复制代码

COOL解释器源码（仅支持gcc编译器）：

/*
COOL.EXE
LINK: -L./ -lgdi32 -lgdiplus
*/
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <windows.h>
#include <wincon.h>
#include <io.h>
#include <conio.h>
#include <time.h>
#include <gdiplus\gdiplus.h>
//定义isINF和isNAN
#ifndef Nan__
#define Nan__
#define NAN log(-1.0) //无效值NAN
#define isNAN(x) ((x)!=(x))
#define NINF log(0.0) //负无穷大
#define INF -NINF //无穷大
#define PINF -NINF //正无穷大
#define isINF(x) (((x)==PINF)||((x)==NINF))
#define isPINF(x) ((x)==PINF)
#define isNINF(x) ((x)==NINF)
#endif
//声明函数
extern "C" HWND WINAPI GetConsoleWindow();
//使用GDI+
using namespace Gdiplus;
/***************定义宏变量***************/
//堆栈尺寸
#define STACK_SIZE 1024
//循环体最大层数
#define LOOP_LEVELS 64
//变量名最大长度
#define MAX_WORDS_SIZE 64
//绘图系关键词数
#define KEY_SIZE 23
//循环系关键词数
#define CYC_SIZE 5
//逻辑系关键词
#define LGC_SIZE 3
//全局变量解释数
#define GLOBAL_SIZE 18
/***************全局类变量***************/
//主窗区域
RECT winRECT= {0};
LPRECT lrRECT;
double base_X, base_Y;
//主窗句柄
HWND hCMD;
HWND hWND2;
HWND hWND3;
//当前行行号
int CUR_LINENUM;
//当前行指针
char* CUR_LINEPOINTER;
//画布句柄
HDC hDC;
HDC hDC1;
HDC hDC2;
HDC hDC3;
//内存变量
char* tRAM;
//缓存容器
char CacheTain[1024]= {0};
//辅助容器
char Auxiliary[1024]= {0};
//画线是否可见
BOOL penMODE=TRUE;
//启用内存背景
BOOL memMODE=FALSE;
/***************关键词类目***************/
//运算符栈
char STACK1[STACK_SIZE]= {0};
//逆波兰栈
char STACK2[STACK_SIZE]= {0};
//浮点数栈
double STACK3[STACK_SIZE]= {0};
//数学函数关键词
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};
//绘图系关键词
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"};
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};
//循环系关键词
static const char* CYC_WORDS[]= {"IF", "REPEAT", "WHILE", "FOR", "ELIF"};
static const char CYC_LLENS[]= { 2, 6, 5, 3, 4};
//逻辑系关键词
static const char* LGC_WORDS[]= {"NOT", "AND", "OR"};
static const char LGC_LLENS[]= { 3, 3, 2};
//定义解释器全局变量
static const char* GLOBAL_WORDS[]= {":PENX", ":PENY", ":HEADING", ":PENB", ":PENW", ":PENC", ":PENS", ":PENA", ":PEN0", ":PEN1", ":PEN2", ":PEN3", ":PEN4", ":PEN5", ":PEN6", ":PEN7", ":PEN8", ":PEN9"};
double GLOBAL_VALUE[]= { 0, 0, 0, 0, 1, 15, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
/***************申明函数类***************/
int Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring);
double RevPolishCore(const char* expression, int PRO_NUM, char** WORDS, double* VALUE);
/***************RGB 结构体***************/
typedef struct
{
BYTE R;
BYTE G;
BYTE B;
COLORREF VALUE;
} STRGB;
//十六色系数组
STRGB LOGO_RGB[16]=
{
{ 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)} //白色
};
/***************辅助函数群***************/
//获取时间
int getTIME(int i)
{
time_t timep;
struct tm *p;
time(&timep);
p=localtime(&timep);
switch(i)
{
case 0:
return p->tm_year+1900;
case 1:
return p->tm_mon+1;
case 2:
return p->tm_mday;
case 3:
return p->tm_hour;
case 4:
return p->tm_min;
case 5:
return p->tm_sec;
default:
break;
}
}
//按键获取
int getKEY(int N,int T)
{
int i,KEY_V,start=clock();
do
{
if(_kbhit())
{
KEY_V=(int)(_getch());
if(KEY_V<97)
{
KEY_V+=32;
}
return KEY_V;
}
for(i=0; i<=N; i++);
}
while((clock()-start)<T);
return -1;
}
//转码函数
static WCHAR Tainer[1024]= {0};
WCHAR* AnsiToWCHAR(const CHAR* str)
{
if(!str)
{
return NULL;
}
int wLen=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, NULL, 0);
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str, -1, Tainer, wLen);
Tainer[wLen]='\0';
return Tainer;
}
//阶乘函数
long long fact(long long n)
{
return (n<2) ?1 :n*(fact(n-1));
}
//测空字符
inline BOOL isEND(const char c,const char* endstring)
{
if(c=='\0')
{
return TRUE;
}
while(*endstring!='\0')
{
if(c==*(endstring++))
{
return TRUE;
}
}
return FALSE;
}
//过滤行TAB缩进或前空格
char* passNULL(char* Str)
{
if(Str!=NULL)
{
while(*Str=='\t' ||*Str==' ')
{
Str++;
}
}
return Str;
}
//错误反馈
inline int errorEXIT(char* errorTYPE)
{
fprintf(stderr, "[%d]:%s '%s\n", CUR_LINENUM, errorTYPE, passNULL(CUR_LINEPOINTER));
exit(1);
}
//识别关键字
BOOL isKEY(char* Line, char* key, const char* endstring)
{
char *op=Line, *kp=key;
while(*kp!='\0')
{
if((('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp))
{
break;
}
op++;
kp++;
}
if(
*kp=='\0' &&
isEND(*op, endstring)
)
{
return TRUE;
}
return FALSE;
}
//切分变量名
int ARGS(char* Str, char** WORDS, int PRO_NUM, int LineNUM, char* Line)
{
if(PRO_NUM==0)
{
return 0;
}
int i=0;
char* lp=Str;
char* tp;
strtok(lp, " \t");
WORDS[0]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
strcpy(WORDS[0], ":\n");
while((++i)<PRO_NUM)
{
if((tp=strtok(NULL, " \t"))==NULL)
{
break;
}
WORDS[i]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
strcpy(WORDS[i], tp);
}
//参数不匹配时则退出
if(i<PRO_NUM)
{
errorEXIT("Missing parameter");
}
return i;
}
//切分参数
int ARGP(char* Str, double* WVALUE, int PRO_NUM, char** PRO_WORDS, double* PRO_VALUE)
{
int i=0;
char* tp;
strtok(Str, " \t");
while((tp=strtok(NULL, " \t"))!=NULL && *tp!='\0')
{
WVALUE[++i]=RevPolishCore(tp, PRO_NUM, PRO_WORDS, PRO_VALUE);
}
return i+1;
}
//关键词解析函数
int Identify_KeyWords(char* Line, int SENSITIVE_NUM, char** WORDS, const char* endstring)
{
int SN;
for(SN=0; SN<SENSITIVE_NUM; SN++)
{
char *op=Line, *kp=WORDS[SN];
while(*kp!='\0')
{
if(
(('a'<= *op && *op<='z')?*op-32:*op) != (('a'<= *kp && *kp<='z')?*kp-32:*kp)
)
{
break;
}
op++;
kp++;
}
if(
*kp=='\0' &&
isEND(*op, endstring)
)
{
return SN;
}
}
return -1;
}
/***************计算函数群***************/
//逆波兰核心
double RevPolishCore(const char* expression, int PRO_NUM, char** WORDS, double* VALUE)
{
STACK3[0]=0;
int si, brackets=0;
char *op=(char*)expression, *S1=STACK1, *S2=STACK2, **key, *cp, *kp;
double *S3=STACK3, di, ni;
//生成逆波兰
while(*op!='\0' && *op!=' ' && *op!='\t')
{
switch(*op)
{
case ' ' :
case '\t':
//过滤空字符
op++;
continue;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z':
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
//识别数学函数关键词
key=(char**)MATH_WORDS;
while(*key !=NULL)
{
cp=op, kp=*key;
//比对关键词字母
while((*cp==*kp||*cp==*kp+32) && *kp!='\0')
{
cp++, kp++;
}
//验证关键词结尾
if( ((*cp<'A')||('Z'<*cp && *cp<'a')||(*cp>'z')) && (*kp=='\0') )
{
op=cp;
break;
}
key++;
}
//构建伪双目
if(*key !=NULL)
{
*(S2++)='.';
*(S2++)=' ';
//伪双目入栈
while( ('A'<=(*S1) && (*S1)<='Z') )
{
*(S2++)=*(S1--);
}
*(++S1)=key-(char**)MATH_WORDS+65;
continue;
}
else
{
//无法识别的数学函数
errorEXIT("Unrecognized math function");
}
break;
case '(':
brackets++;
*(++S1)=*op;
if(*(op+1)=='-' || *(op+1)=='+')
{
*(S2++)='0', *(S2++)=' ';
}
break;
case ')':
brackets--;
while(*S1!='(')
{
*(S2++)=*(S1--);
}
//舍弃'('
S1--;
break;
case '+':
case '-':
while(S1!=STACK1 && *S1!='(')
{
*(S2++)=*(S1--);
}
*(++S1)=*op;
break;
case '^':
//指数符
while( ('A'<=(*S1) && (*S1)<='Z') )
{
*(S2++)=*(S1--);
}
*(++S1)=*op;
break;
case '%':
case '*':
case '/':
while(('A'<=(*S1) && (*S1)<='Z') ||*S1=='%' ||*S1=='*' ||*S1=='/' ||*S1=='^')
{
*(S2++)=*(S1--);
}
*(++S1)=*op;
break;
case ':':
//识别变量 :VAR
for(si=PRO_NUM-1; si>=0-GLOBAL_SIZE; si--)
{
cp=op, kp=(si<0)?(char *)GLOBAL_WORDS[-1-si]:WORDS[si];
//比对变量字母
while((*cp==*kp||*cp==*kp+32) && *kp!='\0')
{
cp++, kp++;
}
//验证变量结尾
if(!(('a'<=*cp && *cp<='z')||('A'<=*cp && *cp<='Z')||('0'<=*cp && *cp<='9')||(*cp=='_' || *cp=='#')) && (*kp=='\0'))
{
op=cp-1;
break;
}
}
//判断变量是否存在
if(si>=0-GLOBAL_SIZE)
{
//变量 :VAR入栈
*(S2++)=':', *(S2++)=si, *(S2++)=' ';
}
else
{
//变量 :VAR无效
errorEXIT("Variable not exist");
}
break;
default :
if((*op<'0' || *op>'9') && (*op!='.'))
{
//无法识别的数字
errorEXIT("Unrecognized number");
}
//浮点数入栈
while(('0'<=*op && *op<='9') ||*op=='.')
{
*(S2++)=*(op++);
}
op--;
*(S2++)=' ';
break;
}
op++;
}
//验证括号是否闭合
if(brackets)
{
errorEXIT("The brackets '(' or ')' are not closed");
}
//收尾逆波兰
while(S1 !=STACK1)
{
*(S2++)=*(S1--);
}
*S2=' ';
//计算逆波兰
op=STACK2;
while(*op!=' ')
{
switch(*op)
{
case 'A':
if(*S3 <0 || *S3 >5)
{
//time(n)函数需要一个整形自变量介于0到5
errorEXIT("The 'time(n)' requires 'n' between 0 to 5");
}
*(S3-1)=getTIME((int)*S3);
S3--;
break;
case 'B':
*S3=3.1415926535897932;
break;
case 'C':
if(*S3 <0)
{
//负数没有平方根
errorEXIT("Negative numbers have no square root");
}
*(S3-1)=sqrt(*S3);
S3--;
break;
case 'D':
if(*S3 <0)
{
//负数没有对数
errorEXIT("Negative numbers are not logarithmic");
}
*(S3-1)=log10(*S3);
S3--;
break;
case 'E':
if(*S3 <0)
{
//负数没有自然对数
errorEXIT("Negative numbers have no natural logarithms");
}
*(S3-1)=log(*S3);
S3--;
break;
case 'F':
*(S3-1)=sin(*S3);
S3--;
break;
case 'G':
*(S3-1)=cos(*S3);
S3--;
break;
case 'H':
if(*S3==3.1415926535897932/2)
{
//π/2没有正切值
errorEXIT("The pi/2 has no tangent");
}
*(S3-1)=tan(*S3);
S3--;
break;
case 'I':
*(S3-1)=asin(*S3);
S3--;
break;
case 'J':
*(S3-1)=acos(*S3);
S3--;
break;
case 'K':
*(S3-1)=atan(*S3);
S3--;
break;
case 'L':
*(S3-1)=(*S3)*3.1415926535897932/180.0;
S3--;
break;
case 'M':
*(S3-1)=fabs(*S3);
S3--;
break;
case 'N':
*(S3-1)=(*S3<=0)?(int)(*S3-0.5):(int)(*S3+0.5);
S3--;
break;
case 'O':
*(S3-1)=getKEY(50, (int)fabs(*S3));
S3--;
break;
case 'P':
*(S3-1)=ceil(*S3);
S3--;
break;
case 'Q':
*(S3-1)=exp(*S3);
S3--;
break;
case 'R':
*(S3-1)=sinh(*S3);
S3--;
break;
case 'S':
*(S3-1)=cosh(*S3);
S3--;
break;
case 'T':
*(S3-1)=tanh(*S3);
S3--;
break;
case 'U':
*(S3-1)=log(*S3+sqrt((*S3)*(*S3)+1));
S3--;
break;
case 'V':
*(S3-1)=log(*S3+sqrt((*S3)*(*S3)-1));
S3--;
break;
case 'W':
*(S3-1)=log((1+(*S3))/(1-(*S3)))/2;
S3--;
break;
case 'X':
//随机数生成器
if(*S3 <0)
{
//负数不能作为随机数的上限
errorEXIT("A negative number can not be used as a random upper bound");
}
else if(*S3 <2)
{
//小于2的随机数为0~1之间的小数
*(S3-1)=rand() % 1024 /1024.0;
}
else
{
*(S3-1)=rand() % (int)(*S3);
}
S3--;
break;
case 'Y':
*(S3-1)=(int)(*S3);
S3--;
break;
case 'Z':
if(*S3 <0)
{
//负数没有阶乘
errorEXIT("Negative numbers have no factorial");
}
*(S3-1)=fact((*S3));
S3--;
break;
case '+':
*(S3-1)+=*S3;
S3--;
break;
case '-':
*(S3-1)-=*S3;
S3--;
break;
case '*':
*(S3-1)*=*S3;
S3--;
break;
case '%':
case '/':
if(*S3 !=0)
{
if(*op=='%')
{
//取余数
*(S3-1)=(int)*(S3-1) % (int)*S3;
}
else
{
*(S3-1)/=*S3;
}
}
else
{
//除数不能为零
errorEXIT("Divisor is zero error");
}
S3--;
break;
case '^':
if(*(S3-1)==0 && *S3<0)
{
//除数不能为零
errorEXIT("Function pow's divisor is zero error");
}
*(S3-1)=pow(*(S3-1), *S3);
S3--;
break;
case ':':
op++;
*(++S3)=(*op<0)?GLOBAL_VALUE[-1-(*op)]:VALUE[*op];
op++;
break;
default :
//字符串转浮点
di=0, ni=1;
while('0'<=*op && *op<='9')
{
di=10*di+(*op)-'0';
op++;
}
if(*op=='.')
{
op++;
while('0'<=*op && *op<='9')
{
di=10*di+(*op)-'0';
op++, ni*=10;
}
}
*(++S3)=di/ni;
break;
}
op++;
}
if(isINF(*S3)||isNAN(*S3))
{
errorEXIT("Overflow or illegal operation is calculated");
}
//返回计算结果
return *S3;
}
//赋值函数
BOOL AssignMent(const char* exp, int PRO_NUM, char** WORDS, double* VALUE)
{
char *op=(char*)exp, *ep=op, *cp, *kp;
int si, i;
//寻找等号
while(!isEND(*(ep++), "=")) {;}
//查找变量
if(op[0]==':')
{
if(op[1]==':')
{
//循环中的瞬时变量::VAR不可赋值
errorEXIT("The loop variables '::' are not assignable");
}
//识别变量 :VAR
for(si=PRO_NUM-1; si>=0-GLOBAL_SIZE; si--)
{
cp=op, kp=(si<0)?(char *)GLOBAL_WORDS[-1-si]:WORDS[si];
//比对变量字母
while((*cp==*kp||*cp==*kp+32) && *kp!='\0')
{
cp++, kp++;
}
//验证变量结尾
if( ((*cp==' ')||(*cp=='\t')||(*cp=='=')) && (*kp=='\0') )
{
op=cp-1;
break;
}
}
//判断变量是否存在
if(si>=0-GLOBAL_SIZE)
{
//笔属性变量赋值
if(si<0)
{
i=-1-si;
GLOBAL_VALUE[i]=RevPolishCore(ep, PRO_NUM, WORDS, VALUE);
STRGB* bgRGB;
HBRUSH m_brush;
switch(i)
{
case 3:
if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>15)
{
//:PENB变量代表背景色，取值只能在0~15之间
errorEXIT("The ':PENB' represents the background color, and only be between 0 to 15");
}
bgRGB=&LOGO_RGB[(int)GLOBAL_VALUE[i]];
//创建画刷
m_brush=CreateSolidBrush(bgRGB->VALUE);
//填充背景
FillRect(hDC1, lrRECT, m_brush);
//删除画刷
DeleteObject(m_brush);
break;
case 4:
if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>99)
{
//:PENW变量代表笔粗细，取值只能在0~99之间
errorEXIT("The ':PENW' represents the width of the pen, and only be between 0 to 99");
}
break;
case 5:
if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>15)
{
//:PENC变量代表笔颜色，取值只能在0~15之间
errorEXIT("The ':PENC' represents the color of the pen, and only be between 0 to 15");
}
break;
case 6:
if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>5)
{
//:PENS变量代表笔光滑，取值只能在0~5之间
errorEXIT("The ':PENS' represents the smooth of the pen, and only be between 0 to 5");
}
break;
case 7:
if(GLOBAL_VALUE[i]<0 ||GLOBAL_VALUE[i]>255)
{
//:PENA变量代表笔透明，取值只能在0~255之间
errorEXIT("The ':PENA' represents the alpha of the pen, and only be between 0 to 255");
}
break;
default:
break;
}
}
else
{
//普通变量赋值
VALUE[si]=RevPolishCore(ep, PRO_NUM, WORDS, VALUE);
}
}
else
{
//无效变量
errorEXIT("Variable not exist");
}
}
return TRUE;
}
//批量赋值
BOOL MoreAssignMent(const char* Line, int PRO_NUM, char** WORDS, double* VALUE)
{
if(Line[0] !=':')
{
errorEXIT("Variable not exist");
}
char *gp=(char*)Line;
while(isEND(*gp, ":"))
{
AssignMent(gp, PRO_NUM, WORDS, VALUE);
gp++;
while(!isEND(*gp, " \t\0"))
{
gp++;
}
while(!isEND(*gp, ":\0"))
{
gp++;
}
if(*gp=='\0')
{
return TRUE;
}
}
return TRUE;
}
//测FOR循环
inline BOOL isForTrue(const char* Line, int PRO_NUM, char** WORDS, double* VALUE, int CYC)
{
if(CYC ==0)
{
return TRUE;
}
char *pCHA1, *pCHA2, *pCHA3;
pCHA1=strtok((char*)Line, " \t");
pCHA2=strtok( NULL, " \t");
pCHA3=strtok( NULL, " \t");
if(pCHA3 !=NULL)
{
int i=Identify_KeyWords(pCHA1, PRO_NUM, WORDS, " \t");
if(i==-1)
{
errorEXIT("Variable not exist");
}
int staNUM=RevPolishCore(pCHA2, PRO_NUM, WORDS, VALUE);
int endNUM=RevPolishCore(pCHA3, PRO_NUM, WORDS, VALUE);
int var =VALUE[i];
if(staNUM-endNUM<0)
{
return (var<=endNUM)?TRUE:FALSE;
}
return (var>=endNUM)?TRUE:FALSE;
}
else
{
errorEXIT("Needs more parameters");
}
}
//真值条件判断
BOOL JudgMent(const char* exp, int PRO_NUM, char** WORDS, double* VALUE)
{
char* op=CacheTain;
char* cp=(char*)exp;
//过滤行TAB缩进或空格
while(*cp=='\t'|| *cp==' ')
{
cp++;
}
if(*cp =='\0')
{
return TRUE;
}
char* Line_Cache=op;
int i=-1, flag=0;
while(!isEND(*cp, " \t\0"))
{
switch(*cp)
{
case '!':
flag+=8;
break;
case '>':
if(flag==0||flag==8)
{
*(op++)='-', *(op++)='(';
}
flag+=4;
break;
case '<':
if(flag==0||flag==8)
{
*(op++)='-', *(op++)='(';
}
flag+=2;
break;
case '=':
if(flag==0||flag==8)
{
*(op++)='-', *(op++)='(';
}
flag+=1;
break;
default:
*(op++)=*(cp++);
continue;
}
cp++;
}
//闭合括号
*(op++)=(flag!=8)?')':'\0';
*op='\0' ;
float m=RevPolishCore(Line_Cache, PRO_NUM, WORDS, VALUE);
switch(flag)
{
case 8:
//逻辑非
return (m==0)?TRUE:FALSE;
case 4:
return (m >0)?TRUE:FALSE;
break;
case 2:
return (m <0)?TRUE:FALSE;
break;
case 1:
return (m==0)?TRUE:FALSE;
break;
case 3:
case 12:
return (m<=0)?TRUE:FALSE;
break;
case 5:
case 10:
return (m>=0)?TRUE:FALSE;
break;
case 6:
case 9:
return (m!=0)?TRUE:FALSE;
break;
default:
errorEXIT("Wrong logic");
}
}
//批量真值判断
BOOL MoreJudgMent(const char* Line, int PRO_NUM, char** WORDS, double* VALUE)
{
char *gp=(char*)Line;
int li=Identify_KeyWords(gp, LGC_SIZE, (char**)LGC_WORDS, " \t");
if(li !=-1)
{
gp+=LGC_LLENS[li];
}
do
{
while(isEND(*gp, " \t"))
{
gp++;
}
if(JudgMent(gp, PRO_NUM, WORDS, VALUE))
{
switch(li)
{
case 0:
return FALSE;
case 1:
break;
case 2:
return TRUE;
default:
return TRUE;
}
}
else
{
switch(li)
{
case 0:
break;
case 1:
return FALSE;
case 2:
break;
default:
return FALSE;
}
}
while(!isEND(*gp, " \t\0"))
{
gp++;
}
if(*gp=='\0')
{
switch(li)
{
case 0:
return TRUE;
case 1:
return TRUE;
case 2:
return FALSE;
}
}
while(isEND(*gp, " \t"))
{
gp++;
}
}
while(*gp !='\0');
}
//PR输出函数
char* SuperPrintf(const char* pline, int PRO_NUM, char** WORDS, double* VALUE)
{
char* op=(char*)pline;
char* cp;
char* sp=Auxiliary;
while(*op !='\0')
{
switch(*op)
{
case '\\':
switch(*(++op))
{
case 'b':
case 'B':
*(sp++)='\b';
break;
case 'e':
case 'E':
*(sp++)='\0';
break;
case 'r':
case 'R':
*(sp++)='\r';
break;
case 'n':
case 'N':
*(sp++)='\n';
break;
case 't':
case 'T':
*(sp++)='\t';
break;
case '{':
case '}':
*(sp++)=*op;
break;
case '\\':
*(sp++)='\\';
break;
default:
errorEXIT("Uninterpreted characters");
}
break;
case '{':
op++, cp=CacheTain;
while(*op!='\0' && *op!='}')
{
*(cp++)=*(op++);
}
if(*op=='\0')
{
errorEXIT("Missing '}'");
}
*cp='\0';
sprintf(sp, "%.12g", RevPolishCore(CacheTain, PRO_NUM, WORDS, VALUE));
while(*(sp++)!='\0') {;}
sp--;
break;
default:
*(sp++)=*(op);
break;
}
op++;
}
*(sp++)='\n', *(sp++)='\0';
return Auxiliary;
}
/***************绘图函数群***************/
//隐藏光标
BOOL SizeCursor(int size)
{
CONSOLE_CURSOR_INFO cursor_info = {(DWORD)((size==0)?25:size), (size==0)?FALSE:TRUE};
return SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}
//平滑画线函数
void drawSMOOTHLINE(HDC hDC, float penWith, SmoothingMode mode, BYTE sharpMODE, BYTE alpha, STRGB* penRGB, float x1, float y1, float x2, float y2, float angel)
{
Graphics gp(hDC);
gp.SetSmoothingMode(mode);
Pen pen(Color(alpha,penRGB->R,penRGB->G,penRGB->B), penWith);
if(angel !=0)
{
Matrix matrix;
matrix.RotateAt(angel, PointF(x1, y1)); // 旋转angel度
gp.SetTransform(&matrix);
}
switch(sharpMODE)
{
case 0:
gp.DrawLine(&pen, PointF(x1, y1), PointF(x2, y2));
break;
case 1:
gp.DrawEllipse(&pen, RectF(x1-x2,y1-y2,x2*2,y2*2));
break;
case 2:
gp.DrawRectangle(&pen, RectF(x1-x2,y1-y2,x2*2,y2*2));
break;
}
DeleteObject(&pen);
}
//画线函数，实现FD
BOOL drawLINE(HDC hDC, float d)
{
float x1=GLOBAL_VALUE[0], y1=GLOBAL_VALUE[1];
GLOBAL_VALUE[0]+=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
GLOBAL_VALUE[1]+=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
//当为PU抬笔时，不做绘图
if(!penMODE)
{
return FALSE;
}
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);
return TRUE;
}
//退步函数，实现BK
void backWARD(float d)
{
GLOBAL_VALUE[0]-=d * sin(GLOBAL_VALUE[2]*0.017453292519943);
GLOBAL_VALUE[1]-=d * cos(GLOBAL_VALUE[2]*0.017453292519943);
}
//图形旋转
int RotateDC(HDC hDC, double angle)
{
if(angle==0)
{
return 1;
}
XFORM Matrix;
double rad =-angle * 0.017453292519943, rtmp1=base_X+GLOBAL_VALUE[0], rtmp2=base_Y-GLOBAL_VALUE[1];
Matrix.eM11 = (float)cos(rad);
Matrix.eM12 = (float)sin(rad);
Matrix.eM21 =-(float)sin(rad);
Matrix.eM22 = (float)cos(rad);
Matrix.eDx = (float)(rtmp1-cos(rad)*rtmp1+sin(rad)*rtmp2);
Matrix.eDy = (float)(rtmp2-cos(rad)*rtmp2-sin(rad)*rtmp1);
SetGraphicsMode(hDC, GM_ADVANCED);
SetWorldTransform(hDC, &Matrix);
return 0;
}
//文字绘制
void drawTEXT(HDC hDC, int fontSIZE, int fontSTYLE, int fontCOLOR, char* fontNAME, char* pSTRING)
{
Graphics graphicsp(hDC), *graph=&graphicsp;
FontFamily fontFAMILY(AnsiToWCHAR(fontNAME));
Font fontp(&fontFAMILY, fontSIZE, (FontStyle)fontSTYLE, UnitPixel);
STRGB* txRGB=&LOGO_RGB[fontCOLOR];
SolidBrush brushp(Color((int)GLOBAL_VALUE[7], txRGB->R, txRGB->G, txRGB->B));
graph->DrawString(AnsiToWCHAR(pSTRING), -1, &fontp, PointF(base_X+GLOBAL_VALUE[0],base_Y-GLOBAL_VALUE[1]), &brushp);
//清理绘图工具
DeleteObject(&brushp);
DeleteObject(&fontp);
DeleteObject(&fontFAMILY);
DeleteObject(&graphicsp);
}
/***************解析函数群***************/
//脚本解析函数
BOOL FileScript(char* prossName, int PRO_NUM, double* PRO_VALUE)
{
//初始参数，其中KLevel为当前循环层号；
int i=0, j=0, ki, KLevel=0, SN=-1, Line_LEN=0, fcolor=-1, BASE_VAR_NUM=PRO_NUM;
float pTMP1, pTMP2, pTMP3, pTMP4, pTMP5, wTIME;
char *prepos=NULL, *pCHA1, *pCHA2, *pCHA3, *pCHA4, *pCHA5;
double tpadd;
//定义过程变量存储容器，即定义 :A型变量，后接 ::A型变量
char** PRO_WORDS=(char**)calloc(LOOP_LEVELS, sizeof(char*));
//初始化开关参数，SFLAG[0]==1开始；
char* SFLAG=(char*)calloc(8, sizeof(char));
SFLAG[2]=-1;
//初始化循环参量数组
int* FORI_CYCL=(int *)calloc(LOOP_LEVELS, sizeof(int ));
int* FORI_LNUM=(int *)calloc(LOOP_LEVELS, sizeof(int ));
char** FORI_FTEL=(char**)calloc(LOOP_LEVELS, sizeof(char*));
char** FORI_FEND=(char**)calloc(LOOP_LEVELS, sizeof(char*));
BOOL* FORI_IFOT=(BOOL *)calloc(LOOP_LEVELS, sizeof(BOOL ));
//分配行容器
char* LCache=(char*)calloc(1025, sizeof(char));
//用于错误反馈的行指针标记
CUR_LINEPOINTER=LCache;
//辅助行指针
char* Line;
//辅助流指针
char* tmpfp=tRAM;
while(*tmpfp !='\0')
{
//记录位置
char* prepos=tmpfp;
//指针置换
Line=LCache;
while(*tmpfp !='\n' && *tmpfp !='\0')
{
*(Line++)=*(tmpfp++);
}
if(*tmpfp =='\n')
{
tmpfp++;
}
*Line='\0';
//指针回首
Line=LCache;
//行计数器
i++, CUR_LINENUM=i;
//过滤行TAB缩进或前空格
while(*Line=='\t'|| *Line==' ')
{
Line++;
}
//过滤空行或行注释
if(
(Line[0]=='\0') ||
(Line[0]=='/' && Line[1]=='/')
)
{
continue;
}
//过滤段间注释
if(
(Line[0]=='/' &&Line[1]=='*')
)
{
SFLAG[3]=1;
continue;
}
else if(
(Line[0]=='*' &&Line[1]=='/')
)
{
SFLAG[3]=0;
continue;
}
//识别子过程名
if(
(isEND(Line[2], " \t\0") ) &&
(Line[0]=='T' || Line[0]=='t') &&
(Line[1]=='O' || Line[1]=='o')
)
{
Line+=2;
//过滤TO后TAB缩进，或TO后空格
while(*Line=='\t'|| *Line==' ')
{
Line++;
}
if(isKEY(Line, prossName, " \t\0"))
{
SFLAG[0]=1, SFLAG[4]=1;
ARGS(Line, PRO_WORDS, PRO_NUM, i, Line);
}
else
{
SFLAG[0]=0;
}
continue;
}
//开始开关未打开，或遇到段注释，或遇到空行
if(
SFLAG[0]==0 ||
SFLAG[3]==1 ||
Line[0]=='('
)
{
continue;
}
//IF...ELIF连带性分析
if(
(FORI_IFOT[KLevel+1] && SFLAG[1]==0) &&
(Line[0]!='E'&&Line[0]!='e') ||
(Line[1]!='L'&&Line[1]!='l') ||
(Line[2]!='I'&&Line[2]!='i') ||
(Line[3]!='F'&&Line[3]!='f')
)
{
FORI_IFOT[KLevel+1]=FALSE;
}
//解析循环结束标签，循环加速
if(Line[0]==')')
{
if(KLevel>SFLAG[1])
{
if(FORI_CYCL[KLevel] <0)
{
tpadd=RevPolishCore(Line+1, PRO_NUM, PRO_WORDS, PRO_VALUE);
PRO_VALUE[0-FORI_CYCL[KLevel]]+=(tpadd==0)?1:tpadd;
}
if(FORI_FEND[KLevel]==NULL)
{
FORI_FEND[KLevel]=tmpfp;
}
tmpfp=FORI_FTEL[KLevel];
i=FORI_LNUM[KLevel];
}
else
{
FORI_FTEL[KLevel]=NULL;
FORI_FEND[KLevel]=NULL;
FORI_CYCL[KLevel]=0;
SFLAG[1]=0;
}
KLevel--;
continue;
}
else
{
if((ki=Identify_KeyWords(Line, CYC_SIZE, (char**)CYC_WORDS, " \t\0")) !=-1)
{
Line=passNULL(Line+CYC_LLENS[ki]);
KLevel++;
//解析循环
if(
ki==0 && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE) ||
ki==1 && FORI_CYCL[KLevel]<RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE) ||
ki==2 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE) ||
ki==3 && isForTrue(Line, PRO_NUM, PRO_WORDS, PRO_VALUE, FORI_CYCL[KLevel]) ||
ki==4 && (FORI_IFOT[KLevel]) && FORI_CYCL[KLevel]<1 && MoreJudgMent(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)
)
{
if( FORI_FTEL[KLevel]==NULL )
{
FORI_FTEL[KLevel]=prepos;
FORI_LNUM[KLevel]=i-1;
if(ki==3)
{
char *tp1, *tp2;
//提取瞬时变量名
if((tp1=strtok(Line, " \t"))==NULL)
{
errorEXIT("Missing parameter");
}
PRO_WORDS[PRO_NUM]=(char*)calloc(MAX_WORDS_SIZE, sizeof(char));
strcpy(PRO_WORDS[PRO_NUM], tp1);
//提取始步
if((tp2=strtok(NULL, " \t"))==NULL)
{
errorEXIT("Missing parameter");
}
PRO_VALUE[PRO_NUM]=RevPolishCore(tp2, PRO_NUM, PRO_WORDS, PRO_VALUE);
FORI_CYCL[KLevel] =0-PRO_NUM;
PRO_NUM++;
}
if(ki==0 || ki==4)
{
FORI_IFOT[KLevel]=FALSE;
}
}
if(ki !=3)
{
FORI_CYCL[KLevel] ++;
}
}
else
{
if((ki==0) && FORI_CYCL[KLevel]==0)
{
FORI_IFOT[KLevel]=TRUE;
}
if(FORI_FEND[KLevel] !=NULL)
{
if(FORI_CYCL[KLevel] <0)
{
free(PRO_WORDS[PRO_NUM]);
PRO_NUM-=1;
}
tmpfp=FORI_FEND[KLevel];
i=FORI_LNUM[KLevel]-1;
FORI_FTEL[KLevel]=NULL;
FORI_FEND[KLevel]=NULL;
FORI_CYCL[KLevel]=0;
KLevel--;
}
else
{
SFLAG[1]=KLevel;
}
}
continue;
}
}
//语句块循环开关
if(SFLAG[1]!=0)
{
continue;
}
//解析命令行
if((SN=Identify_KeyWords(Line, KEY_SIZE, (char**)KEY_WORDS, " \t\0")) !=-1)
{
Line=(SN==8)?Line+KEY_LLENS[SN]+1:passNULL(Line+KEY_LLENS[SN]);
}
else
{
//定义过程传参容器
double* PAR_VALUE=(double*)calloc(LOOP_LEVELS, sizeof(double));
//调用子过程
if(! FileScript(Line, ARGP(Line, PAR_VALUE, PRO_NUM, PRO_WORDS, PRO_VALUE), PAR_VALUE) )
{
fprintf(stderr, "[%d]:Undefined procedure name '%s\n", i, passNULL(LCache));
exit(1);
}
free(PAR_VALUE);
continue;
}
switch(SN)
{
case 0:
//FD
drawLINE(hDC, RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));
break;
case 1:
//BK
backWARD(RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));
break;
case 2:
//LT
GLOBAL_VALUE[2]-=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);
break;
case 3:
//RT
GLOBAL_VALUE[2]+=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);
break;
case 4:
//PU
penMODE=FALSE;
break;
case 5:
//PD
if(SFLAG[2] !=-1)
{
GLOBAL_VALUE[5]=SFLAG[2];
SFLAG[2] =-1;
}
penMODE=TRUE;
break;
case 6:
//PE
if(SFLAG[2] ==-1)
{
SFLAG[2]=GLOBAL_VALUE[5];
GLOBAL_VALUE[5]=GLOBAL_VALUE[3];
}
break;
case 7:
//CS
InvalidateRect(hCMD, NULL, FALSE);
GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;
break;
case 8:
//PR, 打印输出
fputs(SuperPrintf(Line, PRO_NUM, PRO_WORDS, PRO_VALUE), stdout);
break;
case 9:
//HM
GLOBAL_VALUE[0]=GLOBAL_VALUE[1]=GLOBAL_VALUE[2]=0;
break;
case 10:
//STOP
free(PRO_WORDS);
free(SFLAG);
free(FORI_CYCL);
free(FORI_LNUM);
free(FORI_FTEL);
free(FORI_IFOT);
free(LCache);
return TRUE;
case 11:
//EXIT
exit(0);
case 12:
//FILL
if((fcolor=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE)) !=-1)
{
//创建画刷
STRGB* bgRGB=&LOGO_RGB[fcolor];
HBRUSH m_brush=CreateSolidBrush(bgRGB->VALUE);
SelectObject(hDC1, m_brush);
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);
//删除画刷
DeleteObject(m_brush);
}
break;
case 13:
//TEXT
pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t"), pCHA4=strtok(NULL, " \t"), pCHA5=strtok(NULL, " \t");
if(pCHA5 !=NULL)
{
pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);
drawTEXT(hDC, (int)fabs(pTMP1), (int)fabs(pTMP2)%5, (int)fabs(pTMP3)%16, pCHA4, SuperPrintf(pCHA5, PRO_NUM, PRO_WORDS, PRO_VALUE));
}
else
{
errorEXIT("Needs more parameters");
}
break;
case 14:
//WAIT
wTIME=RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE);
if(wTIME>0)
{
Sleep(wTIME);
}
else
{
getch();
}
break;
case 15:
//ROTE
RotateDC(hDC1, (double)RevPolishCore(Line, PRO_NUM, PRO_WORDS, PRO_VALUE));
break;
case 16:
//MEMUSE，开辟内存画布
if(!memMODE)
{
BitBlt(hDC3,0,0,lrRECT->right,lrRECT->bottom, hDC1,0,0,SRCCOPY);
memMODE=TRUE;
}
BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
hDC=hDC2;
break;
case 17:
//MEMSEE，展示内存画布
BitBlt(hDC1,0,0,lrRECT->right,lrRECT->bottom, hDC2,0,0,SRCCOPY);
BitBlt(hDC2,0,0,lrRECT->right,lrRECT->bottom, hDC3,0,0,SRCCOPY);
break;
case 18:
//MEMOUT，丢弃内存画布
memMODE=FALSE;
hDC=hDC1;
break;
case 19:
//MAKE，赋值
MoreAssignMent(passNULL(Line), PRO_NUM, PRO_WORDS, PRO_VALUE);
break;
case 20:
//SETXY，画线函数
pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t");
if(pCHA2 !=NULL)
{
pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);
if(penMODE)
{
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);
}
GLOBAL_VALUE[0]=pTMP1, GLOBAL_VALUE[1]=pTMP2;
}
else
{
errorEXIT("Needs more parameters");
}
break;
case 21:
//RECT，画方函数
pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t");
if(pCHA3 !=NULL)
{
pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);
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);
}
else
{
errorEXIT("Needs more parameters");
}
break;
case 22:
//OVAL，画圆函数
pCHA1=strtok(Line, " \t"), pCHA2=strtok(NULL, " \t"), pCHA3=strtok(NULL, " \t");
if(pCHA3 !=NULL)
{
pTMP1=RevPolishCore(pCHA1, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP2=RevPolishCore(pCHA2, PRO_NUM, PRO_WORDS, PRO_VALUE);
pTMP3=RevPolishCore(pCHA3, PRO_NUM, PRO_WORDS, PRO_VALUE);
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);
}
else
{
errorEXIT("Needs more parameters");
}
break;
default:
errorEXIT("Error line");
}
}
if(!(BOOL)SFLAG[4])
{
return FALSE;
}
free(PRO_WORDS);
free(SFLAG);
free(FORI_CYCL);
free(FORI_LNUM);
free(FORI_FTEL);
free(FORI_IFOT);
free(LCache);
return TRUE;
}
/*************MAIN主函数入口*************/
int main(int argc, char** argv)
{
if(argc!=2)
{
//异常则抛出使用说明
fputs("COPYRIGHT@2017~2019 BY HAPPY, VERSION 1.0\nUSAGE: COOL [FILE]\n", stdout);
return 1;
}
//读文件流
FILE* fp=fopen(argv[1], "r");
if(fp==NULL)
{
fputs("Failed to read file.", stdout);
return 2;
}
//隐藏光标
SizeCursor(0);
//测量尺寸
int fsize=0;
fseek(fp, 0, SEEK_END);
fsize=ftell(fp);
//指针复原
fseek(fp, 0, SEEK_SET);
//超过1M的脚本，拒绝执行
if(fsize > 1*1024*1024)
{
fputs("File size is too large, out of memory.", stdout);
return 1;
}
//读入内存
tRAM=(char*)malloc((fsize+1)*sizeof(char));
fread(tRAM, fsize, 1, fp);
tRAM[fsize]='\0';
//释放文件
fclose(fp);
//初始化随机种子
srand((unsigned)time(NULL));
//初始化GdiPlus
ULONG_PTR gdipludToken;
GdiplusStartupInput gdiplusInput;
GdiplusStartup(&gdipludToken,&gdiplusInput,NULL);
{
//获取CMD窗口句柄
hCMD=GetConsoleWindow();
//获取CMD窗口大小
lrRECT=&winRECT;
GetClientRect(hCMD, lrRECT);
//获取像素坐标基值
base_X=lrRECT->right/2, base_Y=lrRECT->bottom/2;
lrRECT->right=base_X*2, lrRECT->bottom=base_Y*2;
//CMD画布
hDC1=GetDC(hCMD);
HBITMAP hBitmap1=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
SelectObject(hDC1, hBitmap1);
//内存画布
hWND2=NULL;
hDC2=CreateCompatibleDC(GetDC(hWND2));
HBITMAP hBitmap2=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
SelectObject(hDC2, hBitmap2);
//辅助画布
hWND3=NULL;
hDC3=CreateCompatibleDC(GetDC(hWND3));
HBITMAP hBitmap3=CreateCompatibleBitmap(hDC1, lrRECT->right, lrRECT->bottom);
SelectObject(hDC3, hBitmap3);
//运行脚本
double* PAR_VALUE=(double*)calloc(LOOP_LEVELS, sizeof(double));
//主DC选择CMD画布
hDC=hDC1;
//寻找主函数入口点
FileScript("MAIN", 1, PAR_VALUE);
//释放DC
ReleaseDC(NULL, hDC3);
ReleaseDC(NULL, hDC2);
ReleaseDC(hCMD, hDC1);
DeleteDC(hDC3);
DeleteDC(hDC2);
DeleteDC(hDC1);
DeleteObject(hBitmap3);
DeleteObject(hBitmap2);
DeleteObject(hBitmap1);
//释放内存
free(PAR_VALUE);
free(tRAM);
}
//关闭GdiPlus
GdiplusShutdown(gdipludToken);
return 0;
}

复制代码

		自动登录	找回密码
密码			注册

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

基于CLGO的COOL解释器发布

评分

浏览过的版块