Board logo

标题: CME脚本解释器初版 [打印本页]
作者: happy886rr    时间: 2016-10-31 23:11     标题: CME脚本解释器初版

本帖最后由 happy886rr 于 2016-10-31 23:21 编辑

CME is CMD and 易 for me.模仿cmd和易语言的脚本解释器，功能不是很多，只实现了基础的命令。支持中英文编程。
比如CME的注销用户脚本可以这样写
  1. 易

  2. 注销

  3. 暂停
复制代码
显示文本
  1. 易

  2. 显文 "要显示的.txt"

  3. 暂停
复制代码
易代表中文编程，如果不写易，则只识别类批处理风格英文关键词
  1. @echo off

  2. shutdown L

  3. pause
复制代码
  1. @echo off

  2. REM 移动窗口

  3. MW 100 300

  4. sleep 3000

  5. ps

  6. kl 1

  7. pause
复制代码
再如混合脚本
  1. @echo off

  2. color 1 2 0 8

  3. REM 查看当前进程

  4. PS

  5. SLEEP 1500

  6. color 4 2 0 8

  7. cls

  8. REM 查看磁盘信息

  9. DISK

  10. SLEEP 1500

  11. REM 切换编程语言

  12. 易

  13. 颜色 1 4 0 8

  14. 移窗 500 20

  15. 标题 CME脚本

  16. 显示 CME1.0脚本处理器

  17. 暂停
复制代码
因时间比较紧迫，1.0版的CME暂不开放set、if、for语句、goto语句还有点小问题还在测试。以后将提供兼容50%以上的标准cmd脚本，并提供一个cme编译器。目前支持的命令全部为集成命令。部分函数版权归原作者所有，如bmp、磁盘信息统计、一些windowsAPI函数版权归微软、还有一些参考的函数无法追忆版权归初始作者所有，除此之外剩余的70%的代码版权归本人所有。
部分功能请自行测试，主要支持双语编程，echo的速度比cmd的快一倍。
外链地址，图片存为a.zip解压即是。

源码
  1. /*

  2. 	COPYRIGHT@2016~2018 BY HAPPY

  3. 	CME Script

  4. 	VERSION 1.0

  5. */

  6. #include   <stdio.h>

  7. #include  <stdlib.h>

  8. #include  <string.h>

  9. #include <windows.h>

  10. #include  <locale.h>

  11. #include <stdbool.h>

  12. #include   <conio.h>

  13. #include  <direct.h>

  14. #include   <tchar.h>

  15. #include    <time.h>

  16. #include<TlHelp32.h>

  17. 

  18. #define BUFF_SIZE 4096

  19. #define CHECK_SIZE 16383

  20. #define FOLLOW_SIZE 1000

  21. #define FOLLOW_LINE 3

  22. #define FOLLOW_WAIT 20

  23. 

  24. //全局变量

  25. int fsize=0, position=0, FLAG=255, ECHOFF=0, ERRORLEVEL=0, L_SN=0, E_LANGUAGE=0;

  26. int LAB[];

  27. char* RAMread;

  28. char ARG[16][255];

  29. 

  30. //类型定义

  31. typedef HWND (WINAPI *PROCGETCONSOLEWINDOW)();

  32. PROCGETCONSOLEWINDOW GetConsoleWindow;

  33. 

  34. //GETOPT参数变量

  35. int OPTIND=1,OPTOPT;

  36. char *OPTARG;

  37. 

  38. //添加关键词条目(请用小写定义),解释时不区分大小写。 

  39. static const char* SENSITIVE_WORDS[]   ={"echo", "cls", "pause", "exit", "title", "mode con", "pos", "color", "if", "for", "set", "goto", "set/p", "set/a", "ls", "ps", "kl", "tl", "bmp", "mw", "rem", "@echo off", "mouse", "disk", "shutdown", "#$~*&NULL", "#$~*&NULL", "sleep", "易"};

  40. static const char* SENSITIVE_CN_WORDS[]={"显示", "清屏", "暂停", "退出", "标题", "窗体", "位置", "颜色", "如果", "循环", "设置", "跳转", "输入", "计算", "目录", "进程", "杀死", "显文", "位图", "移窗", "注释", "关闭回显", "鼠标", "磁盘", "关机", "注销", "重启", "睡眠"};

  41. //限制关键词数量                         

  42. #define SENSITIVE_NUM 29

  43. 

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

  45. //关键词解析函数

  46. inline int Identify_KeyWords()

  47. {

  48. 	int i, SN;

  49. 	if(E_LANGUAGE==1){

  50. 		for(SN=0; SN<SENSITIVE_NUM-1; SN++){

  51. 			for(i=0; SENSITIVE_CN_WORDS[SN][i]!='\0'; i++){

  52. 				if(

  53. 		 			RAMread[position+i]   !=SENSITIVE_CN_WORDS[SN][i] &&

  54. 		 			RAMread[position+i]+32!=SENSITIVE_CN_WORDS[SN][i]

  55. 		 		

  56. 				){

  57. 					break;

  58. 				}

  59. 			}

  60. 	 		if(

  61. 	 			(SENSITIVE_CN_WORDS[SN][i]=='\0' && FLAG!=0) &&

  62. 				(

  63. 					(RAMread[position+i]== ' ') ||

  64. 					(RAMread[position+i]== '.') ||

  65. 					(RAMread[position+i]== ';') ||

  66. 					(RAMread[position+i]=='\r') ||

  67. 					(RAMread[position+i]=='\n') ||

  68. 					(RAMread[position+i]=='\t') ||

  69. 					(RAMread[position+i]== '&') ||

  70. 					(position+i==fsize)

  71. 				)

  72. 			){

  73. 				position+=i;

  74. 				return SN;

  75. 			}

  76. 		}

  77. 		return 255;

  78. 	}

  79. 	for(SN=0; SN<SENSITIVE_NUM; SN++){

  80. 		for(i=0; SENSITIVE_WORDS[SN][i]!='\0'; i++){

  81. 			if(

  82. 		 		RAMread[position+i]   !=SENSITIVE_WORDS[SN][i] &&

  83. 		 		RAMread[position+i]+32!=SENSITIVE_WORDS[SN][i]

  84. 		 		

  85. 			){

  86. 				break;

  87. 			}

  88. 		}

  89. 	 	if(

  90. 	 		(SENSITIVE_WORDS[SN][i]=='\0' && FLAG!=0) &&

  91. 			(

  92. 				(RAMread[position+i]== ' ') ||

  93. 				(RAMread[position+i]== '.') ||

  94. 				(RAMread[position+i]== ';') ||

  95. 				(RAMread[position+i]=='\r') ||

  96. 				(RAMread[position+i]=='\n') ||

  97. 				(RAMread[position+i]=='\t') ||

  98. 				(RAMread[position+i]== '&') ||

  99. 				(position+i==fsize)

  100. 			)

  101. 		){

  102. 			position+=i;

  103. 			return SN;

  104. 		}

  105. 	}				

  106. 	return 255;

  107. }

  108. //切分解析函数

  109. inline int Analytic_Spli()

  110. {

  111. 	int i=0;

  112. 	for(position++; position<fsize; position++){

  113. 		if(

  114. 			(RAMread[position]=='\r') ||

  115. 			(RAMread[position]=='\n') ||

  116. 			(RAMread[position]=='\0') ||

  117. 			(RAMread[position]== '&') ||

  118. 			(RAMread[position]== '|')

  119. 		){

  120. 			break;

  121. 		}

  122. 		i++;

  123. 	}

  124. 	return i;

  125. }

  126. //命令行参数拆分

  127. int Split_Argv()

  128. {

  129. 	int i, j=0, L=0, MARK1=0, MARK2=0, AC=0;

  130. 	if((L=Analytic_Spli())<=1){return 0;}

  131. 	i=position-L;

  132. 	while(RAMread[i]==' '||RAMread[i]=='\t'){

  133. 		i++;

  134. 	}

  135. 	for(; i<position; i++){

  136. 		if(

  137. 			(RAMread[i]!= ' ') &&

  138. 			(RAMread[i]!='\t') &&

  139. 			(MARK1==0)

  140. 		){	

  141. 			if(RAMread[i]=='"'){

  142. 				i++, MARK2=1;

  143. 			}

  144. 			MARK1=1;

  145. 		}else if(

  146. 				(RAMread[i]== ' ')||

  147. 				(RAMread[i]=='\t')||

  148. 				(RAMread[i]== '"')

  149. 		){

  150. 			if(

  151. 				(MARK1==1) &&

  152. 				(MARK2==0) &&

  153. 				(RAMread[i]!='"')

  154. 			){

  155. 				ARG[AC][j]='\0';

  156. 				j=0, MARK1=0, AC++;

  157. 			}

  158. 			if(

  159. 				(RAMread[i]=='"') &&

  160. 				(MARK2==1)

  161. 			){

  162. 				MARK2=0;

  163. 			}	

  164. 		}	

  165. 		if(

  166. 			(MARK1==1) &&

  167. 			(RAMread[i]!='"')

  168. 		){

  169. 			ARG[AC][j++]=RAMread[i];

  170. 		}

  171. 	}

  172. 	return AC+1;

  173. }

  174. 

  175. /***************命令函数群***************/

  176. //打印函数

  177. inline int Shell_ECHO()

  178. {

  179. 	int i=Analytic_Spli();

  180. 	fwrite(RAMread+position-i, i, 1, stdout);

  181. 	if(i){fputs("\r\n", stdout);}

  182. 	return 0;

  183. }

  184. //REM函数

  185. inline int Shell_REM()

  186. {

  187. 	if(ECHOFF==0){

  188. 		position--;

  189. 		fputs("REM", stdout);

  190. 		Shell_ECHO();

  191. 		return 1;

  192. 	}

  193. 	Analytic_Spli();

  194. 	return 0;

  195. }

  196. //清屏函数

  197. int Shell_CLS()

  198. {

  199. 	HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);

  200. 	COORD coordScreen={0,0};

  201. 	DWORD cCharsWritten;

  202. 	CONSOLE_SCREEN_BUFFER_INFO csbi;

  203. 	GetConsoleScreenBufferInfo(hConsole, &csbi);

  204. 	FillConsoleOutputCharacter(hConsole,       (TCHAR)' ', csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);

  205. 	GetConsoleScreenBufferInfo(hConsole, &csbi);

  206. 	FillConsoleOutputAttribute(hConsole, csbi.wAttributes, csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);

  207. 	SetConsoleCursorPosition(hConsole,coordScreen);

  208. 	return 0;

  209. }

  210. //暂停函数

  211. int Shell_PAUSE()

  212. {

  213. 	if(ECHOFF==0){

  214. 		if(E_LANGUAGE=0){

  215. 			fputs("\r\nPAUSE...", stdout);

  216. 		}else{

  217. 			fputs("\r\n请按任意键继续...", stdout);

  218. 		}

  219. 	}

  220. 	getch();

  221. 	return 0; 

  222. }

  223. //退出函数

  224. int Shell_EXIT(int Exit_Code)

  225. {

  226. 	exit(Exit_Code);

  227. }

  228. //标题函数

  229. int Shell_TITLE(char* Str)

  230. {

  231. 	SetConsoleTitle(Str);

  232. 	return 0; 

  233. }

  234. //跳转函数

  235. int Shell_GOTO(int len)

  236. {

  237. 	int i, j;

  238. 	for(j=0; j<L_SN; j++){

  239. 		for(i=0; i<len; i++){

  240. 			printf("%c#####%c\n",RAMread[position-len+i],  RAMread[LAB[j]+i]);

  241. 			RAMread[position-len+i]!=RAMread[LAB[j]+i];

  242. 			break;

  243. 		}

  244. 		if(i==len){

  245. 			position=RAMread[LAB[j]];

  246. 			return 0;

  247. 		}

  248. 	}

  249. 	fputs("Can not find label :" ,stdout);

  250. 	fwrite(RAMread+position-len, len, 1, stdout);

  251. 	return 1;

  252. }

  253. //光标函数

  254. int Shell_POS(int x,int y)

  255. {

  256. 	COORD pos;

  257. 	HANDLE hOutput;

  258. 	pos.X=x;

  259. 	pos.Y=y;

  260. 	hOutput=GetStdHandle(STD_OUTPUT_HANDLE);

  261. 	SetConsoleCursorPosition(hOutput,pos);

  262. 	return 0;

  263. }

  264. //睡眠函数

  265. int Shell_SLEEP(int t)

  266. {

  267. 	Sleep(t);

  268. 	return 0;

  269. }

  270. //按键函数

  271. int Shell_KEY(clock_t delay)

  272. {

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

  274.  	do{

  275.  		if(kbhit()){

  276. 	 		KEY_V=(int)(getch());

  277.  			if(KEY_V<97){KEY_V+=32;}

  278.  			return KEY_V;

  279.  		}

  280. 		for(i=0;i<=50;i++);

  281. 	}while((clock()-start)<delay);

  282. 	return -1;

  283. }

  284. //鼠标点击函数：KEY_V取值1、2对应鼠标左右键点击；当取值为0时则隐藏光标；

  285. int Shell_MOUSE(int KEY_V)

  286. {

  287. 	if(KEY_V==0){

  288.         	CONSOLE_CURSOR_INFO cursor_info={1,0}; 

  289.         	SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);

  290. 		return 0;

  291. 	}

  292. 	HANDLE StdIn=GetStdHandle(STD_INPUT_HANDLE);

  293. 	DWORD  OrgMode, Res;

  294. 	INPUT_RECORD InR;

  295. 	GetConsoleMode(StdIn, &OrgMode);

  296. 	SetConsoleMode(StdIn, OrgMode | ENABLE_WINDOW_INPUT |  ENABLE_MOUSE_INPUT); 

  297. 	for(;;){

  298. 		ReadConsoleInput(StdIn, &InR, 1, &Res); 

  299. 		if(

  300. 			InR.Event.MouseEvent.dwEventFlags ==0  &&

  301. 			InR.Event.MouseEvent.dwButtonState==KEY_V

  302. 		){

  303. 			SetConsoleMode(StdIn, OrgMode);

  304. 			return (InR.Event.MouseEvent.dwMousePosition.Y)*1000+(InR.Event.MouseEvent.dwMousePosition.X);

  305. 		}

  306. 	}

  307. }

  308. //窗口大小

  309. int Shell_MODE_CON(int x, int y)

  310. {

  311. 

  312. 	HANDLE StdOut=GetStdHandle(STD_OUTPUT_HANDLE);

  313. 	CONSOLE_SCREEN_BUFFER_INFO scbi;

  314. 	COORD size={x, 300};

  315. 	GetConsoleScreenBufferInfo(StdOut, &scbi);

  316. 	SetConsoleScreenBufferSize(StdOut, size);

  317. 	SMALL_RECT rc={0, 0, x-1, y-1};

  318. 	SetConsoleWindowInfo(StdOut, 1, &rc);

  319. 	CloseHandle(StdOut);

  320. 	return 0;

  321. }

  322. //列举文件

  323. int Shell_LS(char* path)

  324. {

  325. 	CHAR szFilePath[MAX_PATH];

  326. 	HANDLE hListFile;

  327. 	WIN32_FIND_DATA fileData;

  328. 	lstrcpy(szFilePath, path);

  329. 	lstrcat(szFilePath, "\\*");

  330. 	hListFile = FindFirstFile(szFilePath,&fileData);

  331. 	if(hListFile == INVALID_HANDLE_VALUE){return 1;}

  332. 	printf("FILE LIST:\r\n");

  333. 	do{

  334. 		printf("\t%s\r\n", fileData.cFileName );

  335. 	}while(FindNextFile(hListFile, &fileData));

  336. 	return 0;

  337. }

  338. //列举进程

  339. int Shell_PS()

  340. {

  341. 	HANDLE hSnapshot;

  342. 	HANDLE hProcess;

  343. 	PROCESSENTRY32 pe32;

  344. 	hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

  345. 	if( hSnapshot == INVALID_HANDLE_VALUE )

  346. 	{

  347. 		printf( "CreateToolhelp32Snapshot (of processes) failed\n" );

  348. 		return 1;

  349. 	}

  350. 	pe32.dwSize = sizeof( PROCESSENTRY32 );

  351. 	if( !Process32First( hSnapshot, &pe32 ) )

  352. 	{

  353. 		printf( "Process32First() failed\n" );

  354. 		CloseHandle( hSnapshot );

  355. 		return 1;

  356. 	}

  357. 	printf("                [PROCESS]   [PID]  [PPID]  [THRE]   [PRI]\r\n---------------------------------------------------------------\r");

  358. 	do{

  359. 		printf( "\n%25s", pe32.szExeFile );

  360. 		printf( "%8u", pe32.th32ProcessID );

  361. 		printf( "%8u", pe32.th32ParentProcessID );

  362. 		printf( "%8d", pe32.cntThreads );

  363. 		printf( "%8d", pe32.pcPriClassBase );

  364. 	}while( Process32Next( hSnapshot, &pe32 ) );

  365. 	CloseHandle( hSnapshot );

  366. 	fputc('\n',stdout);

  367. 	return 0;

  368. }

  369. //结束进程

  370. int Shell_KL(int ProcessID)

  371. {

  372. 	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)ProcessID);

  373. 	TerminateProcess(hProcess, 0);

  374. 	return 0;

  375. }

  376. //字体颜色: 1,2,4,8前景；16,32,64,128后景； 

  377. int Shell_COLOR(unsigned short A,unsigned short B,unsigned short C,unsigned short D)

  378. {

  379. 	HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);

  380. 	CONSOLE_SCREEN_BUFFER_INFO csbi;

  381. 	GetConsoleScreenBufferInfo(handle_out, &csbi);

  382. 	SetConsoleTextAttribute(handle_out, A | B | C | D);

  383. 	return 0;

  384. }

  385. //位图显示

  386. int Shell_BMP(

  387. 

  388. 		char* file ,         //位图文件；

  389. 		int x,int y,         //相对窗口起始坐标x,y；

  390. 		int W,int H,         //要粘贴的宽度高度W,H；

  391. 		int X,int Y          //相对缓存DC的坐标X,Y；

  392. 		)

  393. {

  394. 	HMODULE hKernel32=GetModuleHandle("kernel32");

  395. 	GetConsoleWindow=(PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");

  396. 	HWND cmd=GetConsoleWindow();

  397. 	HDC dc=GetDC(cmd);

  398. 	HBITMAP hBitmap;

  399. 	hBitmap=(HBITMAP)LoadImage(NULL, file, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);

  400. 	HDC cmdmem=CreateCompatibleDC(dc);

  401. 	SelectObject(cmdmem, hBitmap);

  402. 	BitBlt(dc, x, y, W, H, cmdmem, X, Y, SRCCOPY);

  403. 	return 0;

  404. }

  405. //移动窗口

  406. int Shell_MW(int x, int y)

  407. {

  408. 	HMODULE hKernel32 = GetModuleHandle("kernel32");

  409. 	GetConsoleWindow= (PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");

  410. 	HWND cmd=GetConsoleWindow();

  411. 	SetWindowPos(cmd, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);	

  412. 	return 0;

  413. }

  414. //关机函数S取值r、l、p、空；对应重启、注销、关电源、关机；

  415. int Shell_SHUTDOWN(char S)

  416. {

  417. 	HANDLE hToken; 

  418. 	TOKEN_PRIVILEGES tkp; 

  419. 	if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)){

  420. 		return 1;

  421. 	}

  422. 	LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid); 

  423. 	tkp.PrivilegeCount=1;	 

  424. 	tkp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED; 

  425. 	AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0); 

  426. 	if(GetLastError() !=ERROR_SUCCESS){

  427. 		return 1; 

  428. 	}

  429. 	if      (S=='r'||S=='R'){

  430. 		ExitWindowsEx(EWX_REBOOT   | EWX_FORCE, 0);	

  431. 	}else if(S=='l'||S=='L'){

  432. 		ExitWindowsEx(EWX_LOGOFF   | EWX_FORCE, 0);	

  433. 	}else if(S=='p'||S=='P'){

  434. 		ExitWindowsEx(EWX_POWEROFF | EWX_FORCE, 0);	

  435. 	}else{

  436. 		ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE, 0);

  437. 	}

  438. 	return 0;

  439. }

  440. //磁盘信息

  441. void utoiRightJustified(TCHAR* szLeft, TCHAR* szRight, unsigned uVal)

  442. {

  443. 	TCHAR* szCur = szRight;

  444. 	int nComma = 0;

  445. 	if (uVal) {

  446. 		while (uVal && (szCur >= szLeft)) {

  447. 			if (nComma == 3) {

  448. 				*szCur = ',';

  449. 				nComma = 0;

  450. 			}else {

  451. 				*szCur = (uVal % 10) | 0x30;

  452. 				uVal /= 10;

  453. 				++nComma;

  454. 			}

  455. 			--szCur;

  456. 		}

  457. 	} else {

  458. 		*szCur = '0';

  459. 		--szCur;

  460. 	}

  461.  

  462. 	if (uVal) {

  463. 		szCur = szLeft;

  464. 		while (szCur <= szRight) {

  465. 			*szCur = '*';

  466. 			++szCur;

  467. 		}

  468. 	}

  469. }

  470. int Shell_DISK(){

  471. 	DWORD dwDrive;

  472. 	INT nDrive;

  473. 	char dName[4] ;

  474. 	char* Driver;

  475. 	long GB = 1024*1024*1024;

  476. 	ULARGE_INTEGER Free ;

  477. 	ULARGE_INTEGER Total ;

  478. 	ULARGE_INTEGER TotalFree ;

  479. 	dwDrive = GetLogicalDrives();

  480. 	printf(

  481. 		"  ------------------------------------\n"

  482. 		"│DRIVE│FREE CAPACITY│TOTAL CAPACITY│                              DISK\n"

  483. 		"  ------------------------------------\n"

  484. 		"  ------------------------------------\n"	

  485. 	);

  486. 	for ( nDrive = 0 ; nDrive < 26 ; nDrive++ ){

  487. 		if ( dwDrive & (1 << nDrive) ){

  488. 			sprintf(dName,"%c:",(nDrive + 'A'));

  489. 			Driver =(char*)dName;

  490. 			if(GetDiskFreeSpaceEx(Driver, &Free, &Total, &TotalFree)){

  491. 				printf("│ %s  │    %3I64u GB   │     %3I64u GB   │\n",Driver,Free.QuadPart/GB,Total.QuadPart/GB);

  492. 			}

  493. 		}

  494. 	}

  495. 	printf("  ------------------------------------\n");

  496. 	TCHAR   g_szBorder[] = _T("  ------------------------------------------------------------------------\n");

  497. 	TCHAR   g_szTitle1[] = _T("│DRIVE│TOTAL CLUSTERS│AVAIL CLUSTERS│SECTORS / CLUSTER│BYTES / SECTOR│\n");

  498. 	TCHAR   g_szTitle2[] = _T("  ------------------------------------------------------------------------\n  ------------------------------------------------------------------------\n");

  499. 	TCHAR   g_szLine[]   = _T("│  :  │              │              │                 │              │\n");

  500. 	TCHAR szMsg[4200];

  501. 	struct _diskfree_t df = {0};

  502. 	ULONG uDriveMask = _getdrives();

  503. 	unsigned uErr, uLen, uDrive;

  504. 	printf(g_szBorder);

  505. 	printf(g_szTitle1);

  506. 	printf(g_szTitle2);

  507. 	for (uDrive=1; uDrive<=26; ++uDrive) {

  508. 		if (uDriveMask & 1) {

  509. 			uErr = _getdiskfree(uDrive, &df);

  510. 			memcpy(szMsg, g_szLine, sizeof(g_szLine));

  511. 			szMsg[3] = uDrive + 'A' - 1;

  512. 			char lp[5] = "C://";

  513. 			lp [0] = uDrive + 'A' - 1;

  514. 			if (uErr == 0) {

  515.     				utoiRightJustified(szMsg+8,  szMsg+19, df.total_clusters);

  516.     				utoiRightJustified(szMsg+23, szMsg+34, df.avail_clusters);

  517.     				utoiRightJustified(szMsg+38, szMsg+52, df.sectors_per_cluster);

  518.     				utoiRightJustified(szMsg+56, szMsg+67, df.bytes_per_sector);

  519. 			} else {

  520. 				uLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, uErr, 0, szMsg+8, 4100, NULL);

  521. 				szMsg[uLen+6] = ' ';

  522. 				szMsg[uLen+7] = ' ';

  523. 				szMsg[uLen+8] = ' ';

  524. 			}

  525. 			printf(szMsg);

  526. 		}

  527. 		uDriveMask >>= 1;

  528. 		if (!uDriveMask)

  529. 		break;

  530. 	}

  531. 	printf(g_szBorder);

  532. 	return 0;

  533. }

  534. 

  535. /***************业务函数群***************/

  536. //参数解析函数

  537. int GETOPT(int nargc, char *nargv[], char *ostr)

  538. {

  539. 	static char* place="";

  540. 	static char* lastostr=(char *) 0;

  541. 	register char* oli;

  542. 	char* index();

  543. 	if(ostr!=lastostr){

  544. 		lastostr=ostr;

  545. 		place="";

  546. 	}

  547. 	if(!*place){

  548. 		if(

  549. 			(OPTIND>=nargc)              || 

  550. 			(*(place=nargv[OPTIND])!='/')|| 

  551. 			(! *++place)

  552. 		){

  553. 			place="";

  554. 			return(EOF);

  555. 		}

  556. 		if (*place == '/' && place[1] == 0){

  557. 			++OPTIND;

  558. 			return(EOF);

  559. 		}

  560. 	}

  561. 	if ((OPTOPT=(int)*place++)==(int)':' || !(oli=strchr(ostr, OPTOPT))){

  562. 		if(!*place){++OPTIND;}

  563. 	}

  564. 	if (*++oli!=':'){

  565. 		OPTARG=NULL;

  566. 		if(!*place){++OPTIND;}

  567. 	}

  568. 	else{

  569. 		if(*place){

  570. 			OPTARG=place;

  571. 		}else if(nargc<=++OPTIND){

  572. 			place="";

  573. 		}else{

  574. 			OPTARG=nargv[OPTIND];

  575. 		}

  576. 		place="";

  577. 		++OPTIND;

  578. 	}

  579. 	return(OPTOPT);

  580. }

  581. char* UnicodeToANSI(const wchar_t* Str) 

  582. { 

  583. 	int L=WideCharToMultiByte(CP_ACP, 0, Str, -1, NULL, 0, NULL, NULL); 

  584. 	char* Out=(char *)calloc(L+1, sizeof(char));

  585. 	WideCharToMultiByte(CP_ACP, 0, Str, -1, Out, L, NULL, NULL); 

  586. 	return Out; 

  587. }

  588. wchar_t* UTF8ToUnicode(const char* Str) 

  589. { 

  590. 	int L=MultiByteToWideChar(CP_UTF8, 0, Str,-1, NULL, 0); 

  591. 	wchar_t* Out=(wchar_t *)calloc(L+1, sizeof(wchar_t)); 

  592. 	MultiByteToWideChar(CP_UTF8, 0, Str, -1, (LPWSTR)Out, L); 

  593. 	return Out; 

  594. }

  595. wchar_t* BIG5ToUnicode(const char* Str) 

  596. {

  597. 	int L=MultiByteToWideChar(950, 0, Str,-1, NULL, 0); 

  598. 	wchar_t* Out=(wchar_t *)calloc(L+1, sizeof(wchar_t)); 

  599. 	MultiByteToWideChar(950, 0, Str, -1, (LPWSTR)Out, L); 

  600. 	return Out; 

  601. }

  602. bool isUTF8(const char* Str)

  603. {

  604. 	if(!Str){

  605. 		return false;

  606. 	}

  607. 	const unsigned char* bytes=(const unsigned char *)Str;

  608. 	while(*bytes){

  609. 		if( 

  610. 			(

  611. 			 	bytes[0]<=0x7F ||

  612. 				bytes[0]==0x09 ||

  613. 				bytes[0]==0x0A ||

  614. 				bytes[0]==0x0D ||

  615. 				(0x20<=bytes[0] && bytes[0]<=0x7E)

  616. 			)

  617. 		){

  618. 			bytes+=1;

  619. 			continue;

  620. 		}

  621. 		if(

  622. 		 	(

  623. 				(0xC2<=bytes[0] && bytes[0]<=0xDF) &&

  624. 				(0x80<=bytes[1] && bytes[1]<=0xBF)

  625. 			)

  626. 		){

  627. 			bytes+=2;

  628. 			continue;

  629. 		}

  630. 		if(

  631. 			(

  632. 						  (bytes[0]==0xE0) &&

  633. 				(0xA0<=bytes[1] && bytes[1]<=0xBF) &&

  634. 				(0x80<=bytes[2] && bytes[2]<=0xBF)

  635. 			) ||

  636. 			(

  637. 				(

  638. 					(0xE1<=bytes[0] && bytes[0]<=0xEC)||

  639. 					                   bytes[0]==0xEE ||

  640. 					                   bytes[0]==0xEF

  641. 								 ) &&

  642. 				(0x80<=bytes[1] && bytes[1]<=0xBF) &&

  643. 				(0x80<=bytes[2] && bytes[2]<=0xBF)

  644. 			) ||

  645. 			(

  646. 						  (bytes[0]==0xED) &&

  647. 				(0x80<=bytes[1] && bytes[1]<=0x9F) &&

  648. 				(0x80<=bytes[2] && bytes[2]<=0xBF)

  649. 			)

  650. 		){

  651. 			bytes+=3;

  652. 			continue;

  653. 		}

  654. 		if(

  655. 			(

  656. 						  (bytes[0]==0xF0) &&

  657. 				(0x90<=bytes[1] && bytes[1]<=0xBF) &&

  658. 				(0x80<=bytes[2] && bytes[2]<=0xBF) &&

  659. 				(0x80<=bytes[3] && bytes[3]<=0xBF)

  660. 			) ||

  661. 			(

  662. 				(0xF1<=bytes[0] && bytes[0]<=0xF3) &&

  663. 				(0x80<=bytes[1] && bytes[1]<=0xBF) &&

  664. 				(0x80<=bytes[2] && bytes[2]<=0xBF) &&

  665. 				(0x80<=bytes[3] && bytes[3]<=0xBF)

  666. 			) ||

  667. 			(

  668. 						  (bytes[0]==0xF4) &&

  669. 				(0x80<=bytes[1] && bytes[1]<=0x8F) &&

  670. 				(0x80<=bytes[2] && bytes[2]<=0xBF) &&

  671. 				(0x80<=bytes[3] && bytes[3]<=0xBF)

  672. 			)

  673. 		){

  674. 			bytes+=4;

  675. 			continue;

  676. 		}

  677. 		return false;

  678. 	}

  679. 	return true;

  680. }

  681. bool isGB2312(const char* Str)

  682. {

  683. 	if(!Str){

  684. 		return false;

  685. 	}

  686. 	const unsigned char* bytes=(const unsigned char *)Str;

  687. 	while(*bytes){

  688. 		if( 

  689. 			(

  690. 			 	bytes[0]<=0x7F ||

  691. 				bytes[0]==0x09 ||

  692. 				bytes[0]==0x0A ||

  693. 				bytes[0]==0x0D ||

  694. 				(0x20<=bytes[0] && bytes[0]<=0x7E)

  695. 			)

  696. 		){

  697. 			bytes+=1;

  698. 			continue;

  699. 		}

  700. 		if(

  701. 			(0xA1<=bytes[0] && bytes[0]<=0xF7) &&

  702. 			(0xA1<=bytes[1] && bytes[1]<=0xFE)

  703. 		){

  704. 			bytes+=2;

  705. 			continue;

  706. 		}

  707. 		return false;	

  708. 	}

  709. 	return true;

  710. }

  711. bool isBIG5(const char* Str)

  712. {

  713. 	if(!Str){

  714. 		return false;

  715. 	}

  716. 	const unsigned char* bytes=(const unsigned char *)Str;

  717. 	while(*bytes){

  718. 		if( 

  719. 			(

  720. 			 	bytes[0]<=0x7F ||

  721. 				bytes[0]==0x09 ||

  722. 				bytes[0]==0x0A ||

  723. 				bytes[0]==0x0D ||

  724. 				(0x20<=bytes[0] && bytes[0]<=0x7E)

  725. 			)

  726. 		){

  727. 			bytes+=1;

  728. 			continue;

  729. 		}

  730. 		if(

  731. 			(0xA1<=bytes[0] && bytes[0]<=0xF9) &&

  732. 			(

  733. 				(0x40<=bytes[1] && bytes[1]<=0x7E) ||

  734. 				(0xA1<=bytes[1] && bytes[1]<=0xFE)

  735. 			)

  736. 		){

  737. 			bytes+=2;

  738. 			continue;

  739. 		}

  740. 		return false;	

  741. 	}

  742. 	return true;

  743. } 

  744. int CheckBom(FILE* fp)

  745. {

  746. 	unsigned char* buf=(unsigned char*)calloc(3,sizeof(unsigned char));

  747. 	unsigned char* buf2;

  748. 	fseeko64(fp, (__int64)0, SEEK_SET);

  749. 	fread(buf, sizeof(unsigned char), 3, fp);

  750. 	     if(buf[0]==0xEF && buf[1]==0xBB && buf[2]==0xBF){return 3;}

  751. 	else if(buf[0]==0xFF && buf[1]==0xFE){return 5;}

  752. 	else if(buf[0]==0xFE && buf[1]==0xFF){return 6;}

  753. 	else{

  754. 		fseeko64(fp, (__int64)0, SEEK_SET);

  755. 		buf2=(unsigned char*)calloc(CHECK_SIZE,sizeof(unsigned char));

  756. 		fread(buf2, sizeof(unsigned char), CHECK_SIZE, fp);

  757. 		if(isUTF8(buf2)){

  758. 			return 2;

  759. 		}else if(isGB2312(buf2)){

  760. 			return 1;

  761. 		}else if(isBIG5(buf2)){

  762. 			return 4;

  763. 		}

  764. 	}

  765. 	return 1;

  766. }

  767. void Help_Information_Tl(FILE* stream, int a)

  768. {

  769. 	fprintf(stream,

  770. 		">>>------------------------------------------------------------\n"

  771. 		"DISPLAYS THE CONTENTS OF A TEXT FILE\n"

  772. 		"VERSION 2.0\n"

  773. 		"tl  [file] [-n&num1,num2]|[-p&per1,per2]|[-i]|[-d&num]\n"

  774. 		"---------------------------------------------------------------\n\n"

  775. 		"    -h  Show help information\n"

  776. 		"    -n  Read lines from num1 to num2\n"

  777. 		"    -p  Read lines from percent1 to percent2\n"

  778. 		"    -i  Show file's information\n"

  779. 		"    -d  Detection latest num lines \n"	

  780. 		"---------------------------------------------------------------\n"

  781. 	);

  782. 	return;

  783. }

  784. int Getkey(int N,int T)

  785. {

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

  787.  	do{

  788.  		if(kbhit()){

  789. 	 		KEY_V=(int)(getch());

  790.  			if(KEY_V<97){KEY_V+=32;}

  791.  			return KEY_V;

  792.  		}

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

  794. 	}while((clock()-start)<T);

  795. 	return -1;

  796. }

  797. int CountLines(FILE* fp)

  798. {

  799. 	int i=0;

  800. 	char* line=(char *)malloc(BUFF_SIZE*sizeof(char));	

  801. 	while(!feof(fp)){

  802. 		fgets(line, BUFF_SIZE, fp);

  803. 		i++;

  804. 	}

  805. 	return i;

  806. }

  807. void File_Information(FILE* fp, char* fname)

  808. {

  809. 	fseeko64(fp, (__int64)0, SEEK_END);

  810. 	__int64 fsize=ftello64(fp);

  811. 	fseeko64(fp, (__int64)0, SEEK_SET);

  812. 	int linenum=CountLines(fp);

  813. 	fprintf(stdout,

  814. 		"FILE NAME : %s\n"

  815. 		"FILE SIZE : %I64d\n"

  816. 		"FILE LINES: %d\n"

  817. 		,fname, fsize, linenum

  818. 	);

  819. }

  820. int DisplayLine(FILE* fp, int flag, int N1, int N2, __int64 F1, __int64 F2)

  821. {

  822. 	int i=0, n=0, BOM=0, EN=0;

  823. 	BOM=CheckBom(fp);

  824. 	if(BOM==1 || BOM==2 || BOM==4){

  825. 		EN=0;

  826. 	}else if(BOM==5 || BOM==6){

  827. 		EN=2;

  828. 	}else if(BOM==3){

  829. 		EN=3;

  830. 	}

  831. 	if      (flag==0){

  832. 			fseeko64(fp, (__int64)EN, SEEK_SET);

  833. 	}else if(flag==1||flag==3){

  834. 			__int64 FD=(N1*BUFF_SIZE>F2)?F2:N1*BUFF_SIZE;

  835. 			fseeko64(fp, -FD, SEEK_END);

  836. 			N1=CountLines(fp)-N1+1;

  837. 			fseeko64(fp, -FD, SEEK_END);

  838. 	}else if(flag==2){

  839. 			fseeko64(fp,  F1, SEEK_SET);

  840. 	}

  841. 	if(BOM<5){

  842. 		char* Line=(char *)malloc(BUFF_SIZE*sizeof(char));

  843. 		while(!feof(fp)||flag==3){

  844. 			memset(Line, 0, BUFF_SIZE*sizeof(char));

  845. 			if(!fgets(Line, BUFF_SIZE, fp)){Sleep(1);}

  846. 			i++;

  847. 			if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){

  848. 				switch(BOM){

  849. 					case 1: //Ansi行显

  850. 						fputs(Line, stdout);

  851. 						break;

  852. 					case 2: //Utf8无BOM行显

  853. 					case 3: //Utf8行显

  854. 						fputs(UnicodeToANSI(UTF8ToUnicode(Line)), stdout);

  855. 						break;

  856. 					case 4: //Big5行显

  857. 						fputs(UnicodeToANSI(BIG5ToUnicode(Line)), stdout);

  858. 						break;

  859. 				}

  860. 			}else if((i>N2) && (ftello64(fp)>=F2)){

  861. 				break;

  862. 			}

  863. 		}

  864. 	}else if(BOM==5){                       //Unicode行显

  865. 		wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));

  866. 		while(!feof(fp)||(flag==3)){

  867. 			memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));

  868. 			if(!fgetws(LineW, BUFF_SIZE, fp)){Sleep(1);}

  869. 			i++;

  870. 			if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){

  871. 				fputs(UnicodeToANSI(LineW), stdout);

  872. 			}else if((i>N2) && (ftello64(fp)>=F2)){

  873. 				break;

  874. 			}

  875. 		}

  876. 	}else if(BOM==6){                       //Unicode big endian行显

  877. 		wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));

  878. 		while(!feof(fp)||(flag==3)){

  879. 			memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));

  880. 			if(!fgets(LineW, BUFF_SIZE, fp)){Sleep(1);}

  881. 			i++;

  882. 			if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){

  883. 				for(n=0;LineW[n]!=0x0000;n++){

  884. 					LineW[n]=(LineW[n]&0x00FF)<<8|(LineW[n]&0xFF00)>>8;

  885. 				}

  886. 				fputs(UnicodeToANSI(LineW), stdout);

  887. 			}else if((i>N2) && (ftello64(fp)>=F2)){

  888. 				break;

  889. 			}

  890. 		}

  891. 	}

  892. 	fflush(stdout);

  893. 	return 0;

  894. }

  895. //TL函数入口

  896. int Shell_TL(int argc) 

  897. {

  898. 	int N1=1, N2=2147483631, FLAG=0, i;

  899. 	__int64 fsize=0;

  900. 	float P1=0.0, P2=1.0;

  901. 	FILE* fp;

  902. 	char* delims;

  903. 	if((argc==2) && (ARG[1][0]=='-')){

  904. 		switch(ARG[1][1]){

  905. 			case 'H':

  906. 			case 'h':

  907. 				Help_Information_Tl(stdout, 0);

  908. 				return 1;

  909. 			case 'N':

  910. 			case 'n':

  911. 				delims=(ARG[1]+2);

  912. 				N1=atoi(strtok(delims, ","));

  913. 				N2=atoi(strtok(NULL, ","));

  914. 				if(N2==0){N2=2147483631;}

  915. 				if((N1>N2) || (N1<0) || (N2<0)){Help_Information_Tl(stderr, 1);return 1;}

  916. 				break;

  917. 			case 'P':

  918. 			case 'p':

  919. 				delims=(ARG[1]+2);

  920. 				P1=atof(strtok(delims, ","));

  921. 				P2=atof(strtok(NULL, ","));

  922. 				if((P1>=P2) || (P1>1.0) || (P2>1.0) || (P1<0.0) || (P2<0.0) ){Help_Information_Tl(stderr, 1);return 1;}

  923. 				FLAG=2;

  924. 				break;

  925. 			case 'I':

  926. 			case 'i':

  927. 				if( (fp=fopen64(ARG[0], "rb"))==NULL ){fputs("Read failed.", stdout);return 3;}

  928. 				File_Information(fp, ARG[0]);

  929. 				fclose(fp);

  930. 				return 0;

  931. 			case 'D':

  932. 			case 'd':

  933. 				delims=(ARG[1]+2);

  934. 				N1=abs(atoi(delims)), N1=(N1>FOLLOW_SIZE)?1000:N1, FLAG=1;

  935. 				if(ARG[1][2]=='\0'){N1=FOLLOW_LINE,FLAG=3;}

  936. 				break;

  937. 			default:

  938. 				Help_Information_Tl(stderr, 2);return 1;

  939. 		}

  940. 	}else if(argc!=1){

  941. 		Help_Information_Tl(stderr, 3);return 1;

  942. 	}

  943. 	if( (fp=fopen64(ARG[0], "rb"))==NULL ){

  944. 		fputs("Read failed.", stdout);

  945. 		return 3;

  946. 	}

  947. 	if(FLAG==1){

  948. 

  949. 		do{

  950. 			fseeko64(fp, (__int64)0, SEEK_END);

  951. 			if( fsize!=ftello64(fp)){

  952. 				fsize =ftello64(fp);

  953. 				system("cls");

  954. 				DisplayLine(fp, 1, N1, 2147483631, 0, fsize);

  955. 			}

  956. 		}while(Getkey(64,FOLLOW_WAIT)!=113);

  957. 		fputs("\n", stdout);

  958. 		fclose(fp);

  959. 		return 0;

  960. 	}

  961. 	fseeko64(fp, (__int64)0, SEEK_END);

  962. 	fsize=ftello64(fp);

  963. 	DisplayLine(fp, FLAG, N1, N2, fsize*P1, fsize*P2);

  964. 	fclose(fp);

  965. 	return 0;

  966. }

  967. //帮助信息

  968. void Help_Information(FILE* stream, int Exit_Code)

  969. {

  970. 	fprintf(stream,

  971. 		"==================================================\n"

  972. 		"CME [VERSION 1.0]\n"

  973. 		"==================================================\n"

  974. 		"    [ECHO]      Display string\n"

  975. 		"    [CLS]       Clear screen\n"

  976. 		"    [PAUSE]     Time out\n"

  977. 		"    [EXIT ]     Drop out\n"

  978. 		"    [TITLE]     Set the title\n"

  979. 		"    [MODE CON]  Window settings\n"

  980. 		"    [POS]       Set the Cursor position\n"

  981. 		"    [COLOR]     Font color\n"

  982. 		"    [GOTO]      Tag jumps\n"

  983. 		"    [LS]        List the specified directory files\n"

  984. 		"    [PS]        List the processes\n"

  985. 		"    [KL]        End a process\n"

  986. 		"    [CAT]       View a txt file\n"

  987. 		"    [BMP]       Displays a bitmap\n\n"

  988. 		"==================================================\n"

  989. 		"                                        1029TE0\n"

  990. 	);

  991. 	exit(Exit_Code);

  992. }

  993. //脚本解释函数

  994. int CME()

  995. {	int i=0;

  996. 	while(i++<fsize){

  997. 		if(

  998. 			(RAMread[i]== ' ') ||

  999. 			(RAMread[i]=='\r') ||

  1000. 			(RAMread[i]=='\n') ||

  1001. 			(RAMread[i]=='\t') ||

  1002. 			(RAMread[i]== '&') ||

  1003. 			(RAMread[i]== '|') ||

  1004. 			(RAMread[i]=='\0')

  1005. 		){

  1006. 			continue;

  1007. 		}

  1008. 		if(RAMread[i]==':'){

  1009. 				i+=Analytic_Spli();

  1010. 				LAB[L_SN++]=i;

  1011. 		}

  1012. 	}

  1013. 	position=0;

  1014.  	while(position<fsize){

  1015. 		if(

  1016. 			(RAMread[position]== ' ') ||

  1017. 			(RAMread[position]=='\r') ||

  1018. 			(RAMread[position]=='\n') ||

  1019. 			(RAMread[position]=='\t') ||

  1020. 			(RAMread[position]== '&') ||

  1021. 			(RAMread[position]== '|') ||

  1022. 			(RAMread[position]=='\0')

  1023. 		){

  1024. 			position++;FLAG=255;

  1025. 			if(RAMread[position]==':'){

  1026. 				Analytic_Spli();

  1027. 				LAB[L_SN++]=position;

  1028. 			}

  1029. 			continue;

  1030. 		}

  1031.  		FLAG=Identify_KeyWords(position);

  1032. 		switch(FLAG){

  1033. 			case 255:

  1034. 				printf("ERROR [At this time should not have \"");

  1035. 				fwrite(RAMread+position, 12, 1, stdout);

  1036. 				fputs(" \"]\n", stdout);

  1037. 				Shell_PAUSE();

  1038. 				return 1;

  1039. 			case 0:

  1040. 				Shell_ECHO();

  1041. 				break;

  1042. 			case 1:

  1043. 				Shell_CLS();

  1044. 				break;

  1045. 			case 2:

  1046. 				Shell_PAUSE();

  1047. 				break;

  1048. 			case 3:

  1049. 				Shell_EXIT(0);

  1050. 				break;

  1051. 			case 4:

  1052. 				if(Split_Argv()==1){

  1053. 					Shell_TITLE(ARG[0]);

  1054. 				}

  1055. 				break;

  1056. 			case 5:

  1057. 				if(Split_Argv()==2){

  1058. 					Shell_MODE_CON(atoi(ARG[0]), atoi(ARG[1]));

  1059. 				}

  1060. 				break;

  1061. 			case 6:

  1062. 				if(Split_Argv()==2){

  1063. 					Shell_POS(atoi(ARG[0]), atoi(ARG[1]));

  1064. 				}

  1065. 				break;

  1066. 			case 7:

  1067. 				if(Split_Argv()==4){

  1068. 					Shell_COLOR(atoi(ARG[0]), atoi(ARG[1]), atoi(ARG[2]), atoi(ARG[3]));

  1069. 				}else{

  1070. 					Shell_COLOR(1,2,4,8);

  1071. 				}

  1072. 				break;

  1073. 			case 8:

  1074. 				//Shell_IF();

  1075. 				break;

  1076. 			case 9:

  1077. 				//Shell_FOR();

  1078. 				break;

  1079. 			case 10:

  1080. 				//Shell_SET();

  1081. 				break;

  1082. 			case 11:

  1083. 				//Shell_GOTO(Analytic_Spli());

  1084. 				break;

  1085. 			case 12:

  1086. 				//Shell_SET/P();

  1087. 				break;

  1088. 			case 13:

  1089. 				//Shell_SET/A();

  1090. 				break;

  1091. 			case 14:

  1092. 				if(Split_Argv()==1){

  1093. 					Shell_LS(ARG[0]);

  1094. 				}else{

  1095. 					Shell_LS(".");

  1096. 				}

  1097. 				break;

  1098. 			case 15:

  1099. 				Shell_PS();

  1100. 				break;

  1101. 			case 16:

  1102. 				if(Split_Argv()==1){

  1103. 					Shell_KL(atoi(ARG[0]));

  1104. 				}

  1105. 				break;

  1106. 			case 17:

  1107. 				Shell_TL(Split_Argv());

  1108. 				break;

  1109. 			case 18:

  1110. 				if(Split_Argv()==7){

  1111. 					Shell_BMP(ARG[0], atoi(ARG[1]), atoi(ARG[2]), atoi(ARG[3]), atoi(ARG[4]), atoi(ARG[5]), atoi(ARG[6]));

  1112. 				}else{

  1113. 					Shell_BMP(ARG[0], 100, 100, 300, 300, 0, 0);

  1114. 				}

  1115. 				break;

  1116. 			case 19:

  1117. 				if(Split_Argv()==2){

  1118. 					Shell_MW(atoi(ARG[0]), atoi(ARG[1]));

  1119. 				}

  1120. 				break;

  1121. 			case 20:

  1122. 				Shell_REM();

  1123. 				break;

  1124. 			case 21:

  1125. 				ECHOFF=1;

  1126. 				break;

  1127. 			case 22:

  1128. 				if(Split_Argv()==1){

  1129. 					Shell_MOUSE(atoi(ARG[0]));

  1130. 				}

  1131. 				break;

  1132. 			case 23:

  1133. 				Shell_DISK();

  1134. 				break;

  1135. 			case 24:

  1136. 				if(Split_Argv()==0){

  1137. 					Shell_SHUTDOWN('\0');

  1138. 				}else{

  1139. 					Shell_SHUTDOWN(ARG[0][0]);

  1140. 				}

  1141. 				break;

  1142. 			case 25:

  1143. 				if(Split_Argv()==0){

  1144. 					Shell_SHUTDOWN('L');

  1145. 				}

  1146. 				break;

  1147. 			case 26:

  1148. 				if(Split_Argv()==0){

  1149. 					Shell_SHUTDOWN('R');

  1150. 				}

  1151. 				break;

  1152. 			case 27:

  1153. 				if(Split_Argv()==1){

  1154. 					Shell_SLEEP(atoi(ARG[0]));

  1155. 				}

  1156. 				break;

  1157. 			case 28:

  1158. 				E_LANGUAGE=1;

  1159. 				break;

  1160. 		}

  1161.  	}

  1162. 	return 0;

  1163. }

  1164. 

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

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

  1167. {

  1168. 	if(argc!=2){Help_Information(stderr, 2);}

  1169. 	Shell_TITLE("CME Script");

  1170. 	FILE* fp;

  1171. 	if( (fp=fopen(argv[1], "rb"))==NULL ){

  1172. 		fputs("Read Error.\n", stdout);

  1173. 	}

  1174. 	//测量尺寸

  1175. 	fseek(fp, 0, SEEK_END);

  1176. 	if( (fsize=ftell(fp))>2*1024*1024 ){

  1177. 		fputs("The file is too large, out of memory.\n", stdout);

  1178. 		return 1;

  1179. 	}

  1180. 	fseek(fp, 0, SEEK_SET);

  1181. 	//压入内存

  1182. 	RAMread=(char*)calloc(fsize, sizeof(char));

  1183. 	fread(RAMread, fsize, 1, fp);

  1184. 	fclose(fp);

  1185. 	//解析脚本

  1186. 	CME();

  1187. 	free(RAMread);

  1188. 	return 0;

  1189. }
复制代码
作者: yishuigege    时间: 2016-11-1 09:03

为楼主喝彩！
作者: codegay    时间: 2016-11-1 15:49


这么NB是要上天啊。



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