CME脚本解释器初版

happy886rr

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. /*
   
3.         COPYRIGHT@2016~2018 BY HAPPY
   
4.         CME Script
   
5.         VERSION 1.0
   
6. */
   
7. #include   <stdio.h>
   
8. #include  <stdlib.h>
   
9. #include  <string.h>
   
10. #include <windows.h>
    
11. #include  <locale.h>
    
12. #include <stdbool.h>
    
13. #include   <conio.h>
    
14. #include  <direct.h>
    
15. #include   <tchar.h>
    
16. #include    <time.h>
    
17. #include<TlHelp32.h>
    
18. 
    
19. #define BUFF_SIZE 4096
    
20. #define CHECK_SIZE 16383
    
21. #define FOLLOW_SIZE 1000
    
22. #define FOLLOW_LINE 3
    
23. #define FOLLOW_WAIT 20
    
24. 
    
25. //全局变量
    
26. int fsize=0, position=0, FLAG=255, ECHOFF=0, ERRORLEVEL=0, L_SN=0, E_LANGUAGE=0;
    
27. int LAB[];
    
28. char* RAMread;
    
29. char ARG[16][255];
    
30. 
    
31. //类型定义
    
32. typedef HWND (WINAPI *PROCGETCONSOLEWINDOW)();
    
33. PROCGETCONSOLEWINDOW GetConsoleWindow;
    
34. 
    
35. //GETOPT参数变量
    
36. int OPTIND=1,OPTOPT;
    
37. char *OPTARG;
    
38. 
    
39. //添加关键词条目(请用小写定义),解释时不区分大小写。
    
40. 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", "易"};
    
41. static const char* SENSITIVE_CN_WORDS[]={"显示", "清屏", "暂停", "退出", "标题", "窗体", "位置", "颜色", "如果", "循环", "设置", "跳转", "输入", "计算", "目录", "进程", "杀死", "显文", "位图", "移窗", "注释", "关闭回显", "鼠标", "磁盘", "关机", "注销", "重启", "睡眠"};
    
42. //限制关键词数量                        
    
43. #define SENSITIVE_NUM 29
    
44. 
    
45. /***************解析函数群***************/
    
46. //关键词解析函数
    
47. inline int Identify_KeyWords()
    
48. {
    
49.         int i, SN;
    
50.         if(E_LANGUAGE==1){
    
51.                 for(SN=0; SN<SENSITIVE_NUM-1; SN++){
    
52.                         for(i=0; SENSITIVE_CN_WORDS[SN][i]!='\0'; i++){
    
53.                                 if(
    
54.                                          RAMread[position+i]   !=SENSITIVE_CN_WORDS[SN][i] &&
    
55.                                          RAMread[position+i]+32!=SENSITIVE_CN_WORDS[SN][i]
    
56.                                 
    
57.                                 ){
    
58.                                         break;
    
59.                                 }
    
60.                         }
    
61.                          if(
    
62.                                  (SENSITIVE_CN_WORDS[SN][i]=='\0' && FLAG!=0) &&
    
63.                                 (
    
64.                                         (RAMread[position+i]== ' ') ||
    
65.                                         (RAMread[position+i]== '.') ||
    
66.                                         (RAMread[position+i]== ';') ||
    
67.                                         (RAMread[position+i]=='\r') ||
    
68.                                         (RAMread[position+i]=='\n') ||
    
69.                                         (RAMread[position+i]=='\t') ||
    
70.                                         (RAMread[position+i]== '&') ||
    
71.                                         (position+i==fsize)
    
72.                                 )
    
73.                         ){
    
74.                                 position+=i;
    
75.                                 return SN;
    
76.                         }
    
77.                 }
    
78.                 return 255;
    
79.         }
    
80.         for(SN=0; SN<SENSITIVE_NUM; SN++){
    
81.                 for(i=0; SENSITIVE_WORDS[SN][i]!='\0'; i++){
    
82.                         if(
    
83.                                  RAMread[position+i]   !=SENSITIVE_WORDS[SN][i] &&
    
84.                                  RAMread[position+i]+32!=SENSITIVE_WORDS[SN][i]
    
85.                                 
    
86.                         ){
    
87.                                 break;
    
88.                         }
    
89.                 }
    
90.                  if(
    
91.                          (SENSITIVE_WORDS[SN][i]=='\0' && FLAG!=0) &&
    
92.                         (
    
93.                                 (RAMread[position+i]== ' ') ||
    
94.                                 (RAMread[position+i]== '.') ||
    
95.                                 (RAMread[position+i]== ';') ||
    
96.                                 (RAMread[position+i]=='\r') ||
    
97.                                 (RAMread[position+i]=='\n') ||
    
98.                                 (RAMread[position+i]=='\t') ||
    
99.                                 (RAMread[position+i]== '&') ||
    
100.                                 (position+i==fsize)
     
101.                         )
     
102.                 ){
     
103.                         position+=i;
     
104.                         return SN;
     
105.                 }
     
106.         }                               
     
107.         return 255;
     
108. }
     
109. //切分解析函数
     
110. inline int Analytic_Spli()
     
111. {
     
112.         int i=0;
     
113.         for(position++; position<fsize; position++){
     
114.                 if(
     
115.                         (RAMread[position]=='\r') ||
     
116.                         (RAMread[position]=='\n') ||
     
117.                         (RAMread[position]=='\0') ||
     
118.                         (RAMread[position]== '&') ||
     
119.                         (RAMread[position]== '|')
     
120.                 ){
     
121.                         break;
     
122.                 }
     
123.                 i++;
     
124.         }
     
125.         return i;
     
126. }
     
127. //命令行参数拆分
     
128. int Split_Argv()
     
129. {
     
130.         int i, j=0, L=0, MARK1=0, MARK2=0, AC=0;
     
131.         if((L=Analytic_Spli())<=1){return 0;}
     
132.         i=position-L;
     
133.         while(RAMread[i]==' '||RAMread[i]=='\t'){
     
134.                 i++;
     
135.         }
     
136.         for(; i<position; i++){
     
137.                 if(
     
138.                         (RAMread[i]!= ' ') &&
     
139.                         (RAMread[i]!='\t') &&
     
140.                         (MARK1==0)
     
141.                 ){       
     
142.                         if(RAMread[i]=='"'){
     
143.                                 i++, MARK2=1;
     
144.                         }
     
145.                         MARK1=1;
     
146.                 }else if(
     
147.                                 (RAMread[i]== ' ')||
     
148.                                 (RAMread[i]=='\t')||
     
149.                                 (RAMread[i]== '"')
     
150.                 ){
     
151.                         if(
     
152.                                 (MARK1==1) &&
     
153.                                 (MARK2==0) &&
     
154.                                 (RAMread[i]!='"')
     
155.                         ){
     
156.                                 ARG[AC][j]='\0';
     
157.                                 j=0, MARK1=0, AC++;
     
158.                         }
     
159.                         if(
     
160.                                 (RAMread[i]=='"') &&
     
161.                                 (MARK2==1)
     
162.                         ){
     
163.                                 MARK2=0;
     
164.                         }       
     
165.                 }       
     
166.                 if(
     
167.                         (MARK1==1) &&
     
168.                         (RAMread[i]!='"')
     
169.                 ){
     
170.                         ARG[AC][j++]=RAMread[i];
     
171.                 }
     
172.         }
     
173.         return AC+1;
     
174. }
     
175. 
     
176. /***************命令函数群***************/
     
177. //打印函数
     
178. inline int Shell_ECHO()
     
179. {
     
180.         int i=Analytic_Spli();
     
181.         fwrite(RAMread+position-i, i, 1, stdout);
     
182.         if(i){fputs("\r\n", stdout);}
     
183.         return 0;
     
184. }
     
185. //REM函数
     
186. inline int Shell_REM()
     
187. {
     
188.         if(ECHOFF==0){
     
189.                 position--;
     
190.                 fputs("REM", stdout);
     
191.                 Shell_ECHO();
     
192.                 return 1;
     
193.         }
     
194.         Analytic_Spli();
     
195.         return 0;
     
196. }
     
197. //清屏函数
     
198. int Shell_CLS()
     
199. {
     
200.         HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
     
201.         COORD coordScreen={0,0};
     
202.         DWORD cCharsWritten;
     
203.         CONSOLE_SCREEN_BUFFER_INFO csbi;
     
204.         GetConsoleScreenBufferInfo(hConsole, &csbi);
     
205.         FillConsoleOutputCharacter(hConsole,       (TCHAR)' ', csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);
     
206.         GetConsoleScreenBufferInfo(hConsole, &csbi);
     
207.         FillConsoleOutputAttribute(hConsole, csbi.wAttributes, csbi.dwSize.X*csbi.dwSize.Y, coordScreen, &cCharsWritten);
     
208.         SetConsoleCursorPosition(hConsole,coordScreen);
     
209.         return 0;
     
210. }
     
211. //暂停函数
     
212. int Shell_PAUSE()
     
213. {
     
214.         if(ECHOFF==0){
     
215.                 if(E_LANGUAGE=0){
     
216.                         fputs("\r\nPAUSE...", stdout);
     
217.                 }else{
     
218.                         fputs("\r\n请按任意键继续...", stdout);
     
219.                 }
     
220.         }
     
221.         getch();
     
222.         return 0;
     
223. }
     
224. //退出函数
     
225. int Shell_EXIT(int Exit_Code)
     
226. {
     
227.         exit(Exit_Code);
     
228. }
     
229. //标题函数
     
230. int Shell_TITLE(char* Str)
     
231. {
     
232.         SetConsoleTitle(Str);
     
233.         return 0;
     
234. }
     
235. //跳转函数
     
236. int Shell_GOTO(int len)
     
237. {
     
238.         int i, j;
     
239.         for(j=0; j<L_SN; j++){
     
240.                 for(i=0; i<len; i++){
     
241.                         printf("%c#####%c\n",RAMread[position-len+i],  RAMread[LAB[j]+i]);
     
242.                         RAMread[position-len+i]!=RAMread[LAB[j]+i];
     
243.                         break;
     
244.                 }
     
245.                 if(i==len){
     
246.                         position=RAMread[LAB[j]];
     
247.                         return 0;
     
248.                 }
     
249.         }
     
250.         fputs("Can not find label :" ,stdout);
     
251.         fwrite(RAMread+position-len, len, 1, stdout);
     
252.         return 1;
     
253. }
     
254. //光标函数
     
255. int Shell_POS(int x,int y)
     
256. {
     
257.         COORD pos;
     
258.         HANDLE hOutput;
     
259.         pos.X=x;
     
260.         pos.Y=y;
     
261.         hOutput=GetStdHandle(STD_OUTPUT_HANDLE);
     
262.         SetConsoleCursorPosition(hOutput,pos);
     
263.         return 0;
     
264. }
     
265. //睡眠函数
     
266. int Shell_SLEEP(int t)
     
267. {
     
268.         Sleep(t);
     
269.         return 0;
     
270. }
     
271. //按键函数
     
272. int Shell_KEY(clock_t delay)
     
273. {
     
274.         int i,KEY_V,start=clock();
     
275.         do{
     
276.                 if(kbhit()){
     
277.                          KEY_V=(int)(getch());
     
278.                         if(KEY_V<97){KEY_V+=32;}
     
279.                         return KEY_V;
     
280.                 }
     
281.                 for(i=0;i<=50;i++);
     
282.         }while((clock()-start)<delay);
     
283.         return -1;
     
284. }
     
285. //鼠标点击函数：KEY_V取值1、2对应鼠标左右键点击；当取值为0时则隐藏光标；
     
286. int Shell_MOUSE(int KEY_V)
     
287. {
     
288.         if(KEY_V==0){
     
289.                 CONSOLE_CURSOR_INFO cursor_info={1,0};
     
290.                 SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
     
291.                 return 0;
     
292.         }
     
293.         HANDLE StdIn=GetStdHandle(STD_INPUT_HANDLE);
     
294.         DWORD  OrgMode, Res;
     
295.         INPUT_RECORD InR;
     
296.         GetConsoleMode(StdIn, &OrgMode);
     
297.         SetConsoleMode(StdIn, OrgMode | ENABLE_WINDOW_INPUT |  ENABLE_MOUSE_INPUT);
     
298.         for(;;){
     
299.                 ReadConsoleInput(StdIn, &InR, 1, &Res);
     
300.                 if(
     
301.                         InR.Event.MouseEvent.dwEventFlags ==0  &&
     
302.                         InR.Event.MouseEvent.dwButtonState==KEY_V
     
303.                 ){
     
304.                         SetConsoleMode(StdIn, OrgMode);
     
305.                         return (InR.Event.MouseEvent.dwMousePosition.Y)*1000+(InR.Event.MouseEvent.dwMousePosition.X);
     
306.                 }
     
307.         }
     
308. }
     
309. //窗口大小
     
310. int Shell_MODE_CON(int x, int y)
     
311. {
     
312. 
     
313.         HANDLE StdOut=GetStdHandle(STD_OUTPUT_HANDLE);
     
314.         CONSOLE_SCREEN_BUFFER_INFO scbi;
     
315.         COORD size={x, 300};
     
316.         GetConsoleScreenBufferInfo(StdOut, &scbi);
     
317.         SetConsoleScreenBufferSize(StdOut, size);
     
318.         SMALL_RECT rc={0, 0, x-1, y-1};
     
319.         SetConsoleWindowInfo(StdOut, 1, &rc);
     
320.         CloseHandle(StdOut);
     
321.         return 0;
     
322. }
     
323. //列举文件
     
324. int Shell_LS(char* path)
     
325. {
     
326.         CHAR szFilePath[MAX_PATH];
     
327.         HANDLE hListFile;
     
328.         WIN32_FIND_DATA fileData;
     
329.         lstrcpy(szFilePath, path);
     
330.         lstrcat(szFilePath, "\\*");
     
331.         hListFile = FindFirstFile(szFilePath,&fileData);
     
332.         if(hListFile == INVALID_HANDLE_VALUE){return 1;}
     
333.         printf("FILE LIST:\r\n");
     
334.         do{
     
335.                 printf("\t%s\r\n", fileData.cFileName );
     
336.         }while(FindNextFile(hListFile, &fileData));
     
337.         return 0;
     
338. }
     
339. //列举进程
     
340. int Shell_PS()
     
341. {
     
342.         HANDLE hSnapshot;
     
343.         HANDLE hProcess;
     
344.         PROCESSENTRY32 pe32;
     
345.         hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
     
346.         if( hSnapshot == INVALID_HANDLE_VALUE )
     
347.         {
     
348.                 printf( "CreateToolhelp32Snapshot (of processes) failed\n" );
     
349.                 return 1;
     
350.         }
     
351.         pe32.dwSize = sizeof( PROCESSENTRY32 );
     
352.         if( !Process32First( hSnapshot, &pe32 ) )
     
353.         {
     
354.                 printf( "Process32First() failed\n" );
     
355.                 CloseHandle( hSnapshot );
     
356.                 return 1;
     
357.         }
     
358.         printf("                [PROCESS]   [PID]  [PPID]  [THRE]   [PRI]\r\n---------------------------------------------------------------\r");
     
359.         do{
     
360.                 printf( "\n%25s", pe32.szExeFile );
     
361.                 printf( "%8u", pe32.th32ProcessID );
     
362.                 printf( "%8u", pe32.th32ParentProcessID );
     
363.                 printf( "%8d", pe32.cntThreads );
     
364.                 printf( "%8d", pe32.pcPriClassBase );
     
365.         }while( Process32Next( hSnapshot, &pe32 ) );
     
366.         CloseHandle( hSnapshot );
     
367.         fputc('\n',stdout);
     
368.         return 0;
     
369. }
     
370. //结束进程
     
371. int Shell_KL(int ProcessID)
     
372. {
     
373.         HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)ProcessID);
     
374.         TerminateProcess(hProcess, 0);
     
375.         return 0;
     
376. }
     
377. //字体颜色: 1,2,4,8前景；16,32,64,128后景；
     
378. int Shell_COLOR(unsigned short A,unsigned short B,unsigned short C,unsigned short D)
     
379. {
     
380.         HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);
     
381.         CONSOLE_SCREEN_BUFFER_INFO csbi;
     
382.         GetConsoleScreenBufferInfo(handle_out, &csbi);
     
383.         SetConsoleTextAttribute(handle_out, A | B | C | D);
     
384.         return 0;
     
385. }
     
386. //位图显示
     
387. int Shell_BMP(
     
388. 
     
389.                 char* file ,         //位图文件；
     
390.                 int x,int y,         //相对窗口起始坐标x,y；
     
391.                 int W,int H,         //要粘贴的宽度高度W,H；
     
392.                 int X,int Y          //相对缓存DC的坐标X,Y；
     
393.                 )
     
394. {
     
395.         HMODULE hKernel32=GetModuleHandle("kernel32");
     
396.         GetConsoleWindow=(PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");
     
397.         HWND cmd=GetConsoleWindow();
     
398.         HDC dc=GetDC(cmd);
     
399.         HBITMAP hBitmap;
     
400.         hBitmap=(HBITMAP)LoadImage(NULL, file, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE | LR_CREATEDIBSECTION);
     
401.         HDC cmdmem=CreateCompatibleDC(dc);
     
402.         SelectObject(cmdmem, hBitmap);
     
403.         BitBlt(dc, x, y, W, H, cmdmem, X, Y, SRCCOPY);
     
404.         return 0;
     
405. }
     
406. //移动窗口
     
407. int Shell_MW(int x, int y)
     
408. {
     
409.         HMODULE hKernel32 = GetModuleHandle("kernel32");
     
410.         GetConsoleWindow= (PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");
     
411.         HWND cmd=GetConsoleWindow();
     
412.         SetWindowPos(cmd, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);       
     
413.         return 0;
     
414. }
     
415. //关机函数S取值r、l、p、空；对应重启、注销、关电源、关机；
     
416. int Shell_SHUTDOWN(char S)
     
417. {
     
418.         HANDLE hToken;
     
419.         TOKEN_PRIVILEGES tkp;
     
420.         if(!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)){
     
421.                 return 1;
     
422.         }
     
423.         LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
     
424.         tkp.PrivilegeCount=1;         
     
425.         tkp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
     
426.         AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
     
427.         if(GetLastError() !=ERROR_SUCCESS){
     
428.                 return 1;
     
429.         }
     
430.         if      (S=='r'||S=='R'){
     
431.                 ExitWindowsEx(EWX_REBOOT   | EWX_FORCE, 0);       
     
432.         }else if(S=='l'||S=='L'){
     
433.                 ExitWindowsEx(EWX_LOGOFF   | EWX_FORCE, 0);       
     
434.         }else if(S=='p'||S=='P'){
     
435.                 ExitWindowsEx(EWX_POWEROFF | EWX_FORCE, 0);       
     
436.         }else{
     
437.                 ExitWindowsEx(EWX_SHUTDOWN | EWX_FORCE, 0);
     
438.         }
     
439.         return 0;
     
440. }
     
441. //磁盘信息
     
442. void utoiRightJustified(TCHAR* szLeft, TCHAR* szRight, unsigned uVal)
     
443. {
     
444.         TCHAR* szCur = szRight;
     
445.         int nComma = 0;
     
446.         if (uVal) {
     
447.                 while (uVal && (szCur >= szLeft)) {
     
448.                         if (nComma == 3) {
     
449.                                 *szCur = ',';
     
450.                                 nComma = 0;
     
451.                         }else {
     
452.                                 *szCur = (uVal % 10) | 0x30;
     
453.                                 uVal /= 10;
     
454.                                 ++nComma;
     
455.                         }
     
456.                         --szCur;
     
457.                 }
     
458.         } else {
     
459.                 *szCur = '0';
     
460.                 --szCur;
     
461.         }
     
462. 
     
463.         if (uVal) {
     
464.                 szCur = szLeft;
     
465.                 while (szCur <= szRight) {
     
466.                         *szCur = '*';
     
467.                         ++szCur;
     
468.                 }
     
469.         }
     
470. }
     
471. int Shell_DISK(){
     
472.         DWORD dwDrive;
     
473.         INT nDrive;
     
474.         char dName[4] ;
     
475.         char* Driver;
     
476.         long GB = 1024*1024*1024;
     
477.         ULARGE_INTEGER Free ;
     
478.         ULARGE_INTEGER Total ;
     
479.         ULARGE_INTEGER TotalFree ;
     
480.         dwDrive = GetLogicalDrives();
     
481.         printf(
     
482.                 "  ------------------------------------\n"
     
483.                 "│DRIVE│FREE CAPACITY│TOTAL CAPACITY│                              DISK\n"
     
484.                 "  ------------------------------------\n"
     
485.                 "  ------------------------------------\n"       
     
486.         );
     
487.         for ( nDrive = 0 ; nDrive < 26 ; nDrive++ ){
     
488.                 if ( dwDrive & (1 << nDrive) ){
     
489.                         sprintf(dName,"%c:",(nDrive + 'A'));
     
490.                         Driver =(char*)dName;
     
491.                         if(GetDiskFreeSpaceEx(Driver, &Free, &Total, &TotalFree)){
     
492.                                 printf("│ %s  │    %3I64u GB   │     %3I64u GB   │\n",Driver,Free.QuadPart/GB,Total.QuadPart/GB);
     
493.                         }
     
494.                 }
     
495.         }
     
496.         printf("  ------------------------------------\n");
     
497.         TCHAR   g_szBorder[] = _T("  ------------------------------------------------------------------------\n");
     
498.         TCHAR   g_szTitle1[] = _T("│DRIVE│TOTAL CLUSTERS│AVAIL CLUSTERS│SECTORS / CLUSTER│BYTES / SECTOR│\n");
     
499.         TCHAR   g_szTitle2[] = _T("  ------------------------------------------------------------------------\n  ------------------------------------------------------------------------\n");
     
500.         TCHAR   g_szLine[]   = _T("│  :  │              │              │                 │              │\n");
     
501.         TCHAR szMsg[4200];
     
502.         struct _diskfree_t df = {0};
     
503.         ULONG uDriveMask = _getdrives();
     
504.         unsigned uErr, uLen, uDrive;
     
505.         printf(g_szBorder);
     
506.         printf(g_szTitle1);
     
507.         printf(g_szTitle2);
     
508.         for (uDrive=1; uDrive<=26; ++uDrive) {
     
509.                 if (uDriveMask & 1) {
     
510.                         uErr = _getdiskfree(uDrive, &df);
     
511.                         memcpy(szMsg, g_szLine, sizeof(g_szLine));
     
512.                         szMsg[3] = uDrive + 'A' - 1;
     
513.                         char lp[5] = "C://";
     
514.                         lp [0] = uDrive + 'A' - 1;
     
515.                         if (uErr == 0) {
     
516.                                     utoiRightJustified(szMsg+8,  szMsg+19, df.total_clusters);
     
517.                                     utoiRightJustified(szMsg+23, szMsg+34, df.avail_clusters);
     
518.                                     utoiRightJustified(szMsg+38, szMsg+52, df.sectors_per_cluster);
     
519.                                     utoiRightJustified(szMsg+56, szMsg+67, df.bytes_per_sector);
     
520.                         } else {
     
521.                                 uLen = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, uErr, 0, szMsg+8, 4100, NULL);
     
522.                                 szMsg[uLen+6] = ' ';
     
523.                                 szMsg[uLen+7] = ' ';
     
524.                                 szMsg[uLen+8] = ' ';
     
525.                         }
     
526.                         printf(szMsg);
     
527.                 }
     
528.                 uDriveMask >>= 1;
     
529.                 if (!uDriveMask)
     
530.                 break;
     
531.         }
     
532.         printf(g_szBorder);
     
533.         return 0;
     
534. }
     
535. 
     
536. /***************业务函数群***************/
     
537. //参数解析函数
     
538. int GETOPT(int nargc, char *nargv[], char *ostr)
     
539. {
     
540.         static char* place="";
     
541.         static char* lastostr=(char *) 0;
     
542.         register char* oli;
     
543.         char* index();
     
544.         if(ostr!=lastostr){
     
545.                 lastostr=ostr;
     
546.                 place="";
     
547.         }
     
548.         if(!*place){
     
549.                 if(
     
550.                         (OPTIND>=nargc)              ||
     
551.                         (*(place=nargv[OPTIND])!='/')||
     
552.                         (! *++place)
     
553.                 ){
     
554.                         place="";
     
555.                         return(EOF);
     
556.                 }
     
557.                 if (*place == '/' && place[1] == 0){
     
558.                         ++OPTIND;
     
559.                         return(EOF);
     
560.                 }
     
561.         }
     
562.         if ((OPTOPT=(int)*place++)==(int)':' || !(oli=strchr(ostr, OPTOPT))){
     
563.                 if(!*place){++OPTIND;}
     
564.         }
     
565.         if (*++oli!=':'){
     
566.                 OPTARG=NULL;
     
567.                 if(!*place){++OPTIND;}
     
568.         }
     
569.         else{
     
570.                 if(*place){
     
571.                         OPTARG=place;
     
572.                 }else if(nargc<=++OPTIND){
     
573.                         place="";
     
574.                 }else{
     
575.                         OPTARG=nargv[OPTIND];
     
576.                 }
     
577.                 place="";
     
578.                 ++OPTIND;
     
579.         }
     
580.         return(OPTOPT);
     
581. }
     
582. char* UnicodeToANSI(const wchar_t* Str)
     
583. {
     
584.         int L=WideCharToMultiByte(CP_ACP, 0, Str, -1, NULL, 0, NULL, NULL);
     
585.         char* Out=(char *)calloc(L+1, sizeof(char));
     
586.         WideCharToMultiByte(CP_ACP, 0, Str, -1, Out, L, NULL, NULL);
     
587.         return Out;
     
588. }
     
589. wchar_t* UTF8ToUnicode(const char* Str)
     
590. {
     
591.         int L=MultiByteToWideChar(CP_UTF8, 0, Str,-1, NULL, 0);
     
592.         wchar_t* Out=(wchar_t *)calloc(L+1, sizeof(wchar_t));
     
593.         MultiByteToWideChar(CP_UTF8, 0, Str, -1, (LPWSTR)Out, L);
     
594.         return Out;
     
595. }
     
596. wchar_t* BIG5ToUnicode(const char* Str)
     
597. {
     
598.         int L=MultiByteToWideChar(950, 0, Str,-1, NULL, 0);
     
599.         wchar_t* Out=(wchar_t *)calloc(L+1, sizeof(wchar_t));
     
600.         MultiByteToWideChar(950, 0, Str, -1, (LPWSTR)Out, L);
     
601.         return Out;
     
602. }
     
603. bool isUTF8(const char* Str)
     
604. {
     
605.         if(!Str){
     
606.                 return false;
     
607.         }
     
608.         const unsigned char* bytes=(const unsigned char *)Str;
     
609.         while(*bytes){
     
610.                 if(
     
611.                         (
     
612.                                  bytes[0]<=0x7F ||
     
613.                                 bytes[0]==0x09 ||
     
614.                                 bytes[0]==0x0A ||
     
615.                                 bytes[0]==0x0D ||
     
616.                                 (0x20<=bytes[0] && bytes[0]<=0x7E)
     
617.                         )
     
618.                 ){
     
619.                         bytes+=1;
     
620.                         continue;
     
621.                 }
     
622.                 if(
     
623.                          (
     
624.                                 (0xC2<=bytes[0] && bytes[0]<=0xDF) &&
     
625.                                 (0x80<=bytes[1] && bytes[1]<=0xBF)
     
626.                         )
     
627.                 ){
     
628.                         bytes+=2;
     
629.                         continue;
     
630.                 }
     
631.                 if(
     
632.                         (
     
633.                                                   (bytes[0]==0xE0) &&
     
634.                                 (0xA0<=bytes[1] && bytes[1]<=0xBF) &&
     
635.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
     
636.                         ) ||
     
637.                         (
     
638.                                 (
     
639.                                         (0xE1<=bytes[0] && bytes[0]<=0xEC)||
     
640.                                                            bytes[0]==0xEE ||
     
641.                                                            bytes[0]==0xEF
     
642.                                                                  ) &&
     
643.                                 (0x80<=bytes[1] && bytes[1]<=0xBF) &&
     
644.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
     
645.                         ) ||
     
646.                         (
     
647.                                                   (bytes[0]==0xED) &&
     
648.                                 (0x80<=bytes[1] && bytes[1]<=0x9F) &&
     
649.                                 (0x80<=bytes[2] && bytes[2]<=0xBF)
     
650.                         )
     
651.                 ){
     
652.                         bytes+=3;
     
653.                         continue;
     
654.                 }
     
655.                 if(
     
656.                         (
     
657.                                                   (bytes[0]==0xF0) &&
     
658.                                 (0x90<=bytes[1] && bytes[1]<=0xBF) &&
     
659.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
     
660.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
     
661.                         ) ||
     
662.                         (
     
663.                                 (0xF1<=bytes[0] && bytes[0]<=0xF3) &&
     
664.                                 (0x80<=bytes[1] && bytes[1]<=0xBF) &&
     
665.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
     
666.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
     
667.                         ) ||
     
668.                         (
     
669.                                                   (bytes[0]==0xF4) &&
     
670.                                 (0x80<=bytes[1] && bytes[1]<=0x8F) &&
     
671.                                 (0x80<=bytes[2] && bytes[2]<=0xBF) &&
     
672.                                 (0x80<=bytes[3] && bytes[3]<=0xBF)
     
673.                         )
     
674.                 ){
     
675.                         bytes+=4;
     
676.                         continue;
     
677.                 }
     
678.                 return false;
     
679.         }
     
680.         return true;
     
681. }
     
682. bool isGB2312(const char* Str)
     
683. {
     
684.         if(!Str){
     
685.                 return false;
     
686.         }
     
687.         const unsigned char* bytes=(const unsigned char *)Str;
     
688.         while(*bytes){
     
689.                 if(
     
690.                         (
     
691.                                  bytes[0]<=0x7F ||
     
692.                                 bytes[0]==0x09 ||
     
693.                                 bytes[0]==0x0A ||
     
694.                                 bytes[0]==0x0D ||
     
695.                                 (0x20<=bytes[0] && bytes[0]<=0x7E)
     
696.                         )
     
697.                 ){
     
698.                         bytes+=1;
     
699.                         continue;
     
700.                 }
     
701.                 if(
     
702.                         (0xA1<=bytes[0] && bytes[0]<=0xF7) &&
     
703.                         (0xA1<=bytes[1] && bytes[1]<=0xFE)
     
704.                 ){
     
705.                         bytes+=2;
     
706.                         continue;
     
707.                 }
     
708.                 return false;       
     
709.         }
     
710.         return true;
     
711. }
     
712. bool isBIG5(const char* Str)
     
713. {
     
714.         if(!Str){
     
715.                 return false;
     
716.         }
     
717.         const unsigned char* bytes=(const unsigned char *)Str;
     
718.         while(*bytes){
     
719.                 if(
     
720.                         (
     
721.                                  bytes[0]<=0x7F ||
     
722.                                 bytes[0]==0x09 ||
     
723.                                 bytes[0]==0x0A ||
     
724.                                 bytes[0]==0x0D ||
     
725.                                 (0x20<=bytes[0] && bytes[0]<=0x7E)
     
726.                         )
     
727.                 ){
     
728.                         bytes+=1;
     
729.                         continue;
     
730.                 }
     
731.                 if(
     
732.                         (0xA1<=bytes[0] && bytes[0]<=0xF9) &&
     
733.                         (
     
734.                                 (0x40<=bytes[1] && bytes[1]<=0x7E) ||
     
735.                                 (0xA1<=bytes[1] && bytes[1]<=0xFE)
     
736.                         )
     
737.                 ){
     
738.                         bytes+=2;
     
739.                         continue;
     
740.                 }
     
741.                 return false;       
     
742.         }
     
743.         return true;
     
744. }
     
745. int CheckBom(FILE* fp)
     
746. {
     
747.         unsigned char* buf=(unsigned char*)calloc(3,sizeof(unsigned char));
     
748.         unsigned char* buf2;
     
749.         fseeko64(fp, (__int64)0, SEEK_SET);
     
750.         fread(buf, sizeof(unsigned char), 3, fp);
     
751.              if(buf[0]==0xEF && buf[1]==0xBB && buf[2]==0xBF){return 3;}
     
752.         else if(buf[0]==0xFF && buf[1]==0xFE){return 5;}
     
753.         else if(buf[0]==0xFE && buf[1]==0xFF){return 6;}
     
754.         else{
     
755.                 fseeko64(fp, (__int64)0, SEEK_SET);
     
756.                 buf2=(unsigned char*)calloc(CHECK_SIZE,sizeof(unsigned char));
     
757.                 fread(buf2, sizeof(unsigned char), CHECK_SIZE, fp);
     
758.                 if(isUTF8(buf2)){
     
759.                         return 2;
     
760.                 }else if(isGB2312(buf2)){
     
761.                         return 1;
     
762.                 }else if(isBIG5(buf2)){
     
763.                         return 4;
     
764.                 }
     
765.         }
     
766.         return 1;
     
767. }
     
768. void Help_Information_Tl(FILE* stream, int a)
     
769. {
     
770.         fprintf(stream,
     
771.                 ">>>------------------------------------------------------------\n"
     
772.                 "DISPLAYS THE CONTENTS OF A TEXT FILE\n"
     
773.                 "VERSION 2.0\n"
     
774.                 "tl  [file] [-n&num1,num2]|[-p&per1,per2]|[-i]|[-d&num]\n"
     
775.                 "---------------------------------------------------------------\n\n"
     
776.                 "    -h  Show help information\n"
     
777.                 "    -n  Read lines from num1 to num2\n"
     
778.                 "    -p  Read lines from percent1 to percent2\n"
     
779.                 "    -i  Show file's information\n"
     
780.                 "    -d  Detection latest num lines \n"       
     
781.                 "---------------------------------------------------------------\n"
     
782.         );
     
783.         return;
     
784. }
     
785. int Getkey(int N,int T)
     
786. {
     
787.         int i,KEY_V,start=clock();
     
788.         do{
     
789.                 if(kbhit()){
     
790.                          KEY_V=(int)(getch());
     
791.                         if(KEY_V<97){KEY_V+=32;}
     
792.                         return KEY_V;
     
793.                 }
     
794.                 for(i=0;i<=N;i++);
     
795.         }while((clock()-start)<T);
     
796.         return -1;
     
797. }
     
798. int CountLines(FILE* fp)
     
799. {
     
800.         int i=0;
     
801.         char* line=(char *)malloc(BUFF_SIZE*sizeof(char));       
     
802.         while(!feof(fp)){
     
803.                 fgets(line, BUFF_SIZE, fp);
     
804.                 i++;
     
805.         }
     
806.         return i;
     
807. }
     
808. void File_Information(FILE* fp, char* fname)
     
809. {
     
810.         fseeko64(fp, (__int64)0, SEEK_END);
     
811.         __int64 fsize=ftello64(fp);
     
812.         fseeko64(fp, (__int64)0, SEEK_SET);
     
813.         int linenum=CountLines(fp);
     
814.         fprintf(stdout,
     
815.                 "FILE NAME : %s\n"
     
816.                 "FILE SIZE : %I64d\n"
     
817.                 "FILE LINES: %d\n"
     
818.                 ,fname, fsize, linenum
     
819.         );
     
820. }
     
821. int DisplayLine(FILE* fp, int flag, int N1, int N2, __int64 F1, __int64 F2)
     
822. {
     
823.         int i=0, n=0, BOM=0, EN=0;
     
824.         BOM=CheckBom(fp);
     
825.         if(BOM==1 || BOM==2 || BOM==4){
     
826.                 EN=0;
     
827.         }else if(BOM==5 || BOM==6){
     
828.                 EN=2;
     
829.         }else if(BOM==3){
     
830.                 EN=3;
     
831.         }
     
832.         if      (flag==0){
     
833.                         fseeko64(fp, (__int64)EN, SEEK_SET);
     
834.         }else if(flag==1||flag==3){
     
835.                         __int64 FD=(N1*BUFF_SIZE>F2)?F2:N1*BUFF_SIZE;
     
836.                         fseeko64(fp, -FD, SEEK_END);
     
837.                         N1=CountLines(fp)-N1+1;
     
838.                         fseeko64(fp, -FD, SEEK_END);
     
839.         }else if(flag==2){
     
840.                         fseeko64(fp,  F1, SEEK_SET);
     
841.         }
     
842.         if(BOM<5){
     
843.                 char* Line=(char *)malloc(BUFF_SIZE*sizeof(char));
     
844.                 while(!feof(fp)||flag==3){
     
845.                         memset(Line, 0, BUFF_SIZE*sizeof(char));
     
846.                         if(!fgets(Line, BUFF_SIZE, fp)){Sleep(1);}
     
847.                         i++;
     
848.                         if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){
     
849.                                 switch(BOM){
     
850.                                         case 1: //Ansi行显
     
851.                                                 fputs(Line, stdout);
     
852.                                                 break;
     
853.                                         case 2: //Utf8无BOM行显
     
854.                                         case 3: //Utf8行显
     
855.                                                 fputs(UnicodeToANSI(UTF8ToUnicode(Line)), stdout);
     
856.                                                 break;
     
857.                                         case 4: //Big5行显
     
858.                                                 fputs(UnicodeToANSI(BIG5ToUnicode(Line)), stdout);
     
859.                                                 break;
     
860.                                 }
     
861.                         }else if((i>N2) && (ftello64(fp)>=F2)){
     
862.                                 break;
     
863.                         }
     
864.                 }
     
865.         }else if(BOM==5){                       //Unicode行显
     
866.                 wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));
     
867.                 while(!feof(fp)||(flag==3)){
     
868.                         memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));
     
869.                         if(!fgetws(LineW, BUFF_SIZE, fp)){Sleep(1);}
     
870.                         i++;
     
871.                         if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){
     
872.                                 fputs(UnicodeToANSI(LineW), stdout);
     
873.                         }else if((i>N2) && (ftello64(fp)>=F2)){
     
874.                                 break;
     
875.                         }
     
876.                 }
     
877.         }else if(BOM==6){                       //Unicode big endian行显
     
878.                 wchar_t* LineW=(wchar_t *)calloc(BUFF_SIZE, sizeof(wchar_t));
     
879.                 while(!feof(fp)||(flag==3)){
     
880.                         memset(LineW, 0, BUFF_SIZE*sizeof(wchar_t));
     
881.                         if(!fgets(LineW, BUFF_SIZE, fp)){Sleep(1);}
     
882.                         i++;
     
883.                         if( ((N1<=i) && (i<=N2) && (F1<=ftello64(fp)) && (ftello64(fp)<=F2))||(flag==3) ){
     
884.                                 for(n=0;LineW[n]!=0x0000;n++){
     
885.                                         LineW[n]=(LineW[n]&0x00FF)<<8|(LineW[n]&0xFF00)>>8;
     
886.                                 }
     
887.                                 fputs(UnicodeToANSI(LineW), stdout);
     
888.                         }else if((i>N2) && (ftello64(fp)>=F2)){
     
889.                                 break;
     
890.                         }
     
891.                 }
     
892.         }
     
893.         fflush(stdout);
     
894.         return 0;
     
895. }
     
896. //TL函数入口
     
897. int Shell_TL(int argc)
     
898. {
     
899.         int N1=1, N2=2147483631, FLAG=0, i;
     
900.         __int64 fsize=0;
     
901.         float P1=0.0, P2=1.0;
     
902.         FILE* fp;
     
903.         char* delims;
     
904.         if((argc==2) && (ARG[1][0]=='-')){
     
905.                 switch(ARG[1][1]){
     
906.                         case 'H':
     
907.                         case 'h':
     
908.                                 Help_Information_Tl(stdout, 0);
     
909.                                 return 1;
     
910.                         case 'N':
     
911.                         case 'n':
     
912.                                 delims=(ARG[1]+2);
     
913.                                 N1=atoi(strtok(delims, ","));
     
914.                                 N2=atoi(strtok(NULL, ","));
     
915.                                 if(N2==0){N2=2147483631;}
     
916.                                 if((N1>N2) || (N1<0) || (N2<0)){Help_Information_Tl(stderr, 1);return 1;}
     
917.                                 break;
     
918.                         case 'P':
     
919.                         case 'p':
     
920.                                 delims=(ARG[1]+2);
     
921.                                 P1=atof(strtok(delims, ","));
     
922.                                 P2=atof(strtok(NULL, ","));
     
923.                                 if((P1>=P2) || (P1>1.0) || (P2>1.0) || (P1<0.0) || (P2<0.0) ){Help_Information_Tl(stderr, 1);return 1;}
     
924.                                 FLAG=2;
     
925.                                 break;
     
926.                         case 'I':
     
927.                         case 'i':
     
928.                                 if( (fp=fopen64(ARG[0], "rb"))==NULL ){fputs("Read failed.", stdout);return 3;}
     
929.                                 File_Information(fp, ARG[0]);
     
930.                                 fclose(fp);
     
931.                                 return 0;
     
932.                         case 'D':
     
933.                         case 'd':
     
934.                                 delims=(ARG[1]+2);
     
935.                                 N1=abs(atoi(delims)), N1=(N1>FOLLOW_SIZE)?1000:N1, FLAG=1;
     
936.                                 if(ARG[1][2]=='\0'){N1=FOLLOW_LINE,FLAG=3;}
     
937.                                 break;
     
938.                         default:
     
939.                                 Help_Information_Tl(stderr, 2);return 1;
     
940.                 }
     
941.         }else if(argc!=1){
     
942.                 Help_Information_Tl(stderr, 3);return 1;
     
943.         }
     
944.         if( (fp=fopen64(ARG[0], "rb"))==NULL ){
     
945.                 fputs("Read failed.", stdout);
     
946.                 return 3;
     
947.         }
     
948.         if(FLAG==1){
     
949. 
     
950.                 do{
     
951.                         fseeko64(fp, (__int64)0, SEEK_END);
     
952.                         if( fsize!=ftello64(fp)){
     
953.                                 fsize =ftello64(fp);
     
954.                                 system("cls");
     
955.                                 DisplayLine(fp, 1, N1, 2147483631, 0, fsize);
     
956.                         }
     
957.                 }while(Getkey(64,FOLLOW_WAIT)!=113);
     
958.                 fputs("\n", stdout);
     
959.                 fclose(fp);
     
960.                 return 0;
     
961.         }
     
962.         fseeko64(fp, (__int64)0, SEEK_END);
     
963.         fsize=ftello64(fp);
     
964.         DisplayLine(fp, FLAG, N1, N2, fsize*P1, fsize*P2);
     
965.         fclose(fp);
     
966.         return 0;
     
967. }
     
968. //帮助信息
     
969. void Help_Information(FILE* stream, int Exit_Code)
     
970. {
     
971.         fprintf(stream,
     
972.                 "==================================================\n"
     
973.                 "CME [VERSION 1.0]\n"
     
974.                 "==================================================\n"
     
975.                 "    [ECHO]      Display string\n"
     
976.                 "    [CLS]       Clear screen\n"
     
977.                 "    [PAUSE]     Time out\n"
     
978.                 "    [EXIT ]     Drop out\n"
     
979.                 "    [TITLE]     Set the title\n"
     
980.                 "    [MODE CON]  Window settings\n"
     
981.                 "    [POS]       Set the Cursor position\n"
     
982.                 "    [COLOR]     Font color\n"
     
983.                 "    [GOTO]      Tag jumps\n"
     
984.                 "    [LS]        List the specified directory files\n"
     
985.                 "    [PS]        List the processes\n"
     
986.                 "    [KL]        End a process\n"
     
987.                 "    [CAT]       View a txt file\n"
     
988.                 "    [BMP]       Displays a bitmap\n\n"
     
989.                 "==================================================\n"
     
990.                 "                                        1029TE0\n"
     
991.         );
     
992.         exit(Exit_Code);
     
993. }
     
994. //脚本解释函数
     
995. int CME()
     
996. {        int i=0;
     
997.         while(i++<fsize){
     
998.                 if(
     
999.                         (RAMread[i]== ' ') ||
     
1000.                         (RAMread[i]=='\r') ||
      
1001.                         (RAMread[i]=='\n') ||
      
1002.                         (RAMread[i]=='\t') ||
      
1003.                         (RAMread[i]== '&') ||
      
1004.                         (RAMread[i]== '|') ||
      
1005.                         (RAMread[i]=='\0')
      
1006.                 ){
      
1007.                         continue;
      
1008.                 }
      
1009.                 if(RAMread[i]==':'){
      
1010.                                 i+=Analytic_Spli();
      
1011.                                 LAB[L_SN++]=i;
      
1012.                 }
      
1013.         }
      
1014.         position=0;
      
1015.         while(position<fsize){
      
1016.                 if(
      
1017.                         (RAMread[position]== ' ') ||
      
1018.                         (RAMread[position]=='\r') ||
      
1019.                         (RAMread[position]=='\n') ||
      
1020.                         (RAMread[position]=='\t') ||
      
1021.                         (RAMread[position]== '&') ||
      
1022.                         (RAMread[position]== '|') ||
      
1023.                         (RAMread[position]=='\0')
      
1024.                 ){
      
1025.                         position++;FLAG=255;
      
1026.                         if(RAMread[position]==':'){
      
1027.                                 Analytic_Spli();
      
1028.                                 LAB[L_SN++]=position;
      
1029.                         }
      
1030.                         continue;
      
1031.                 }
      
1032.                 FLAG=Identify_KeyWords(position);
      
1033.                 switch(FLAG){
      
1034.                         case 255:
      
1035.                                 printf("ERROR [At this time should not have "");
      
1036.                                 fwrite(RAMread+position, 12, 1, stdout);
      
1037.                                 fputs(" "]\n", stdout);
      
1038.                                 Shell_PAUSE();
      
1039.                                 return 1;
      
1040.                         case 0:
      
1041.                                 Shell_ECHO();
      
1042.                                 break;
      
1043.                         case 1:
      
1044.                                 Shell_CLS();
      
1045.                                 break;
      
1046.                         case 2:
      
1047.                                 Shell_PAUSE();
      
1048.                                 break;
      
1049.                         case 3:
      
1050.                                 Shell_EXIT(0);
      
1051.                                 break;
      
1052.                         case 4:
      
1053.                                 if(Split_Argv()==1){
      
1054.                                         Shell_TITLE(ARG[0]);
      
1055.                                 }
      
1056.                                 break;
      
1057.                         case 5:
      
1058.                                 if(Split_Argv()==2){
      
1059.                                         Shell_MODE_CON(atoi(ARG[0]), atoi(ARG[1]));
      
1060.                                 }
      
1061.                                 break;
      
1062.                         case 6:
      
1063.                                 if(Split_Argv()==2){
      
1064.                                         Shell_POS(atoi(ARG[0]), atoi(ARG[1]));
      
1065.                                 }
      
1066.                                 break;
      
1067.                         case 7:
      
1068.                                 if(Split_Argv()==4){
      
1069.                                         Shell_COLOR(atoi(ARG[0]), atoi(ARG[1]), atoi(ARG[2]), atoi(ARG[3]));
      
1070.                                 }else{
      
1071.                                         Shell_COLOR(1,2,4,8);
      
1072.                                 }
      
1073.                                 break;
      
1074.                         case 8:
      
1075.                                 //Shell_IF();
      
1076.                                 break;
      
1077.                         case 9:
      
1078.                                 //Shell_FOR();
      
1079.                                 break;
      
1080.                         case 10:
      
1081.                                 //Shell_SET();
      
1082.                                 break;
      
1083.                         case 11:
      
1084.                                 //Shell_GOTO(Analytic_Spli());
      
1085.                                 break;
      
1086.                         case 12:
      
1087.                                 //Shell_SET/P();
      
1088.                                 break;
      
1089.                         case 13:
      
1090.                                 //Shell_SET/A();
      
1091.                                 break;
      
1092.                         case 14:
      
1093.                                 if(Split_Argv()==1){
      
1094.                                         Shell_LS(ARG[0]);
      
1095.                                 }else{
      
1096.                                         Shell_LS(".");
      
1097.                                 }
      
1098.                                 break;
      
1099.                         case 15:
      
1100.                                 Shell_PS();
      
1101.                                 break;
      
1102.                         case 16:
      
1103.                                 if(Split_Argv()==1){
      
1104.                                         Shell_KL(atoi(ARG[0]));
      
1105.                                 }
      
1106.                                 break;
      
1107.                         case 17:
      
1108.                                 Shell_TL(Split_Argv());
      
1109.                                 break;
      
1110.                         case 18:
      
1111.                                 if(Split_Argv()==7){
      
1112.                                         Shell_BMP(ARG[0], atoi(ARG[1]), atoi(ARG[2]), atoi(ARG[3]), atoi(ARG[4]), atoi(ARG[5]), atoi(ARG[6]));
      
1113.                                 }else{
      
1114.                                         Shell_BMP(ARG[0], 100, 100, 300, 300, 0, 0);
      
1115.                                 }
      
1116.                                 break;
      
1117.                         case 19:
      
1118.                                 if(Split_Argv()==2){
      
1119.                                         Shell_MW(atoi(ARG[0]), atoi(ARG[1]));
      
1120.                                 }
      
1121.                                 break;
      
1122.                         case 20:
      
1123.                                 Shell_REM();
      
1124.                                 break;
      
1125.                         case 21:
      
1126.                                 ECHOFF=1;
      
1127.                                 break;
      
1128.                         case 22:
      
1129.                                 if(Split_Argv()==1){
      
1130.                                         Shell_MOUSE(atoi(ARG[0]));
      
1131.                                 }
      
1132.                                 break;
      
1133.                         case 23:
      
1134.                                 Shell_DISK();
      
1135.                                 break;
      
1136.                         case 24:
      
1137.                                 if(Split_Argv()==0){
      
1138.                                         Shell_SHUTDOWN('\0');
      
1139.                                 }else{
      
1140.                                         Shell_SHUTDOWN(ARG[0][0]);
      
1141.                                 }
      
1142.                                 break;
      
1143.                         case 25:
      
1144.                                 if(Split_Argv()==0){
      
1145.                                         Shell_SHUTDOWN('L');
      
1146.                                 }
      
1147.                                 break;
      
1148.                         case 26:
      
1149.                                 if(Split_Argv()==0){
      
1150.                                         Shell_SHUTDOWN('R');
      
1151.                                 }
      
1152.                                 break;
      
1153.                         case 27:
      
1154.                                 if(Split_Argv()==1){
      
1155.                                         Shell_SLEEP(atoi(ARG[0]));
      
1156.                                 }
      
1157.                                 break;
      
1158.                         case 28:
      
1159.                                 E_LANGUAGE=1;
      
1160.                                 break;
      
1161.                 }
      
1162.         }
      
1163.         return 0;
      
1164. }
      
1165. 
      
1166. /*************MAIN主函数入口*************/
      
1167. int main(int argc, char** argv)
      
1168. {
      
1169.         if(argc!=2){Help_Information(stderr, 2);}
      
1170.         Shell_TITLE("CME Script");
      
1171.         FILE* fp;
      
1172.         if( (fp=fopen(argv[1], "rb"))==NULL ){
      
1173.                 fputs("Read Error.\n", stdout);
      
1174.         }
      
1175.         //测量尺寸
      
1176.         fseek(fp, 0, SEEK_END);
      
1177.         if( (fsize=ftell(fp))>2*1024*1024 ){
      
1178.                 fputs("The file is too large, out of memory.\n", stdout);
      
1179.                 return 1;
      
1180.         }
      
1181.         fseek(fp, 0, SEEK_SET);
      
1182.         //压入内存
      
1183.         RAMread=(char*)calloc(fsize, sizeof(char));
      
1184.         fread(RAMread, fsize, 1, fp);
      
1185.         fclose(fp);
      
1186.         //解析脚本
      
1187.         CME();
      
1188.         free(RAMread);
      
1189.         return 0;
      
1190. }
      

复制代码

yishuigege

为楼主喝彩！

codegay

这么NB是要上天啊。