[分享]Basic程序解释器及编译原理的简单化

songfei

这是CMake的源代码.主要负责词汇的提取
你可以调用它的CMake::get_token(),返回个CToken的类.

1. /////////////////////////////////////////////////////
   
2. // Make.h
   
3. ///////////////////////////////////////////////////
   
4. 
   
5. enum token_types{DELIMITER,VARIABLE,NUMBER,COMMAND,
   
6.              STRING,QUOTE,FINISHED,NONE,ENTER};         // 标记类型集合
   
7. 
   
8. 
   
9. #define TOKEN_MAX 80
   
10. #define STRDELIMITER "+-*^/=;(),><" // 符号集合
    
11. #define DIM     11 // Dim
    
12. #define AS      12 // As
    
13. #define INTEGER 13 // Integer
    
14. #define PRINT   14 // Print
    
15. 
    
16. class CToken
    
17. {
    
18. public:
    
19. char token[TOKEN_MAX];
    
20. int token_type;
    
21. int tok;
    
22. };
    
23. 
    
24. class CMake  
    
25. {
    
26. public:
    
27. CMake(char *Prog,int Proglength);
    
28. virtual ~CMake();
    
29. public:
    
30.     char *prog;
    
31. int proglength;
    
32. int isdelim(char c);     // 如果是运算符号返回1,不是则返回0
    
33. int iswhite(char c);     // 是空格返回1,不是则返回0
    
34. int look_up(char *c);    // 返回COMMAND类型,c是COMMAND字符串的指针
    
35. CToken get_token(void);   // 得到标记
    
36. int findchar(char *str,char ch); // 从str里找到ch,返回其在str里的引索;如果str里没有ch,则返回-1
    
37. };
    
38. 
    
39. /////////////////////////////////////////////////////////////////////
    
40. 
    
41. 
    
42. 
    
43. 
    
44. 
    
45. // Make.cpp: implementation of the CMake class.
    
46. //
    
47. //////////////////////////////////////////////////////////////////////
    
48. 
    
49. #include "stdafx.h"
    
50. #include "Make.h"
    
51. 
    
52. //////////////////////////////////////////////////////////////////////
    
53. // Construction/Destruction
    
54. //////////////////////////////////////////////////////////////////////
    
55. 
    
56. CMake::CMake(char *Prog,int Proglength)
    
57. {
    
58.   proglength=Proglength;
    
59.   prog=new char[Proglength+1];
    
60.   strcpy(prog,Prog);
    
61. }
    
62. 
    
63. CMake::~CMake()
    
64. {
    
65. 
    
66. }
    
67. 
    
68. 
    
69. CToken CMake::get_token(void)
    
70. {
    
71. register char *temp;
    
72. CToken m_token;
    
73.     m_token.token_type=0;
    
74. m_token.tok=0;
    
75. temp=m_token.token;
    
76. if(*prog=='\0')
    
77. {
    
78.   *m_token.token='\0';
    
79.   m_token.tok=0;
    
80.   m_token.token_type=FINISHED;
    
81.   return m_token;
    
82. }
    
83. while(iswhite(*prog)) ++prog;
    
84.    
    
85. if(*prog=='\r') // 如果是换行符
    
86. {
    
87.   m_token.token[0]=*prog;
    
88.   m_token.token[1]='\0';
    
89.   m_token.token_type=ENTER;
    
90.   prog++;
    
91.   return m_token;
    
92. }
    
93. if( isdelim(*prog)) // 如果找得到运算符号标记
    
94. {
    
95.     *m_token.token=*prog;
    
96.     *(m_token.token+1)='\0';
    
97.     m_token.tok=0;
    
98.     m_token.token_type=DELIMITER;
    
99.     prog++;
    
100.     return m_token;            // 譬如 token[0]='+' token[1]='\0';
     
101. }
     
102. 
     
103. if(*prog=='"')   // 如果是字符串
     
104. {
     
105.   prog++;
     
106.   int i=0;
     
107.   while(*prog!='"' && *prog!='\r')
     
108.   {
     
109.    m_token.token[i]=*prog;
     
110.    i++;
     
111.    prog++;
     
112.   }
     
113.   prog++;
     
114.   m_token.token[i]='\0';
     
115.   m_token.token_type=QUOTE;
     
116.   return m_token;
     
117. }
     
118. 
     
119. if( isdigit(*prog)) // 如果找到数字标记
     
120. {
     
121.   int i=0;
     
122.   while(isdigit(*prog) && i<TOKEN_MAX) // 小于token最长为80个字符
     
123.   {
     
124.    m_token.token[i]=*prog;
     
125.    i++;
     
126.    prog++;
     
127.   }
     
128.   m_token.token[i]='\0';
     
129.   m_token.token_type=NUMBER;
     
130.   return m_token;
     
131. }
     
132. if( isalpha(*prog)) // 如果是命令COMMAND或是一般标记STRING
     
133. {
     
134.   int i=0;
     
135.   while(!isdelim(*prog) && *prog!=' ') // 不能是运算符号和空格
     
136.   {
     
137.    m_token.token[i]=*prog;
     
138.    i++;
     
139.    prog++;
     
140.   }
     
141.   m_token.token[i]='\0';
     
142.   if(look_up(m_token.token)) // 如果能查到它是命令COMMAND
     
143.   {
     
144.    m_token.token_type=COMMAND;
     
145.    m_token.tok=look_up(m_token.token);
     
146.   }
     
147.   else
     
148.   {
     
149.    m_token.token_type=STRING;
     
150.   }
     
151.   return m_token;
     
152. }
     
153. 
     
154. 
     
155. m_token.token_type=NONE;
     
156. prog++;
     
157. return m_token;
     
158. }
     
159. 
     
160. int CMake::iswhite(char c)
     
161. {
     
162. if(c==' '||c=='\t') return 1;
     
163. else return 0;
     
164. }
     
165. 
     
166. int CMake::isdelim(char c)
     
167. {
     
168. if( findchar(STRDELIMITER,*prog) >= 0 || c==9 || c=='\r' || c==0)
     
169.   return 1;
     
170. return 0;
     
171. }
     
172. 
     
173. int CMake::findchar(char *str,char ch)
     
174. {
     
175. int length=strlen(str);
     
176. if(length>0)
     
177. {
     
178.   for(int i=0;i<length;i++)
     
179.    if(str[i]==ch)
     
180.       return i;
     
181.    return -1;
     
182. }
     
183. else return -1;
     
184. }
     
185. 
     
186. int CMake::look_up(char *c)
     
187. {
     
188. if(strcmp(c,"print")==0)
     
189.   return PRINT;
     
190.     if(strcmp(c,"Integer")==0)
     
191.   return INTEGER;
     
192. if(strcmp(c,"Dim")==0)
     
193.   return DIM;
     
194. if(strcmp(c,"As")==0)
     
195.   return AS;
     
196. 
     
197.     return 0;
     
198. }
     
199. 
     
200. 这是执行代码的CExecutable封装
     
201. 
     
202. //////////////////////////////////////////////////
     
203. // CExecutable.h
     
204. ////////////////////////////////////////////////
     
205. 
     
206. class CintMember
     
207. {
     
208. public:
     
209. char name[64];
     
210. int value;
     
211. };
     
212. 
     
213. class CExecutable  
     
214. {
     
215. public:
     
216. CExecutable(vector <CToken> tokens);
     
217. virtual ~CExecutable();
     
218. void Run();
     
219. private:
     
220. vector <CToken> m_tokens; [url]file://装[/url]所有标记的数据库
     
221. vector <CintMember> m_intArray; [url]file://装[/url]所有int类型的变量
     
222. void Run_Print(int *index); [url]file://*[/url]index是重要的m_tokens里的指针
     
223. void Run_Dim(int *index); [url]file://~~[/url]
     
224. void Run_Assignment(int *index);// 赋值语句
     
225. [url]file://Ai[/url]是辅助的意思,Ai_*()是辅助函数
     
226. int Ai_GetNextValue(void* result,int type,int *index); [url]file://得[/url]到代数式的值result
     
227. int Ai_GetVarNo(char *name,int *result,int type);//得到变量在Array中的引索result
     
228. void get_exp(int *result,int *index);
     
229. void level2(int *result,int *index);
     
230. void level3(int *result,int *index);
     
231. void level4(int *result,int *index);
     
232. void level5(int *result,int *index);
     
233.     void level6(int *result,int *index);
     
234. void primitive(int *result,int *index);
     
235. void arith(char o,int *r,int *h);
     
236. void serror(int error);
     
237. int look_up(char *c);
     
238. int find_var(char *var_name,void *value); // 查找变量,将变量值装在*value
     
239. int Isvar(char *name); // 看name是否是变量,返回变量类型 0:什么都不是,1:Integer,2:string
     
240. };
     
241. 
     
242. 
     
243. /////////////////////////////////////////
     
244. 
     
245. // Executable.cpp: implementation of the CExecutable class.
     
246. //
     
247. //////////////////////////////////////////////////////////////////////
     
248. 
     
249. #include "stdafx.h"
     
250. #include "Executable.h"
     
251. 
     
252. //////////////////////////////////////////////////////////////////////
     
253. // Construction/Destruction
     
254. //////////////////////////////////////////////////////////////////////
     
255. 
     
256. CExecutable::CExecutable(vector <CToken> tokens)
     
257. {
     
258. m_tokens=tokens;
     
259. }
     
260. 
     
261. CExecutable::~CExecutable()
     
262. {
     
263. m_intArray.clear();
     
264. m_tokens.clear();
     
265. }
     
266. 
     
267. void CExecutable::Run(void)
     
268. {
     
269.    for(int i=0;i<=m_tokens.size()-1;i++)//注意:i是个十分重要的读取指针
     
270.    {
     
271.   if(m_tokens.at(i).token_type==COMMAND)
     
272.   {
     
273.    switch(m_tokens.at(i).tok) [url]file://tok[/url]表示是什么命令
     
274.    {
     
275.    case PRINT: Run_Print(&i);
     
276.          break;
     
277.    case DIM:   Run_Dim(&i);
     
278.             break;
     
279.    default:   break;
     
280.    }
     
281.   }
     
282.   [url]file://赋[/url]值语句一定要在最后来判断,因为这样如果是if后的条件判断就可以在
     
283.   [url]file://前[/url]面的if命令中跳过
     
284.   if(*m_tokens.at(i).token=='=') [url]file://如[/url]果是赋值语句
     
285.    Run_Assignment(&i);
     
286.    }
     
287. }
     
288. 
     
289. void CExecutable::Run_Print(int *index) [url]file://*[/url]index是m_tokens里的指针
     
290. {
     
291. if(*index<m_tokens.size()-1) // 如果下面还有token
     
292. {   
     
293.   if(m_tokens.at((*index)+1).token_type==ENTER) [url]file://如[/url]果接下来是命令
     
294.   {
     
295.    printf("\n");
     
296.    return;
     
297.   }
     
298.   (*index)++;   
     
299.   int token_type=m_tokens.at(*index).token_type;
     
300.   if(Isvar(m_tokens.at(*index).token)) [url]file://如[/url]果接下来是变量
     
301.    token_type=VARIABLE;
     
302.         
     
303.   switch(token_type)
     
304.   {
     
305.   case QUOTE: [url]file://如[/url]果是要打印字符串
     
306.    {
     
307.     printf(m_tokens.at(*index).token);
     
308.     return;
     
309.    }
     
310.   case VARIABLE:  [url]file://打[/url]印代数式 type只要不是COMMAND就是可以当代数式处理
     
311.   case NUMBER:
     
312.   case DELIMITER:     
     
313.    {
     
314.     int result;
     
315.           Ai_GetNextValue(&result,INTEGER,index);
     
316.     printf("%d",result);
     
317.     return;
     
318.    }
     
319.   default: printf("\n");
     
320.      return;
     
321.   }
     
322. }
     
323. printf("\n");
     
324. 
     
325. }
     
326. 
     
327. void CExecutable::Run_Dim(int *index) [url]file://~~[/url]
     
328. {
     
329. int i=*index;
     
330. if(i<m_tokens.size()-1)//~~
     
331.   if(m_tokens.at(i+1).token_type==STRING)
     
332.   {
     
333.    if(i<m_tokens.size()-3) [url]file://如[/url]果下面还应该有 变量名,As,类型 三个tokens
     
334.    {
     
335.     CintMember member;
     
336.     if(m_tokens.at(i+2).token_type==COMMAND &&
     
337.      m_tokens.at(i+2).tok==AS) [url]file://如[/url]果接下来的token是As
     
338.     {
     
339.     if(m_tokens.at(i+3).token_type==COMMAND)//接下来是变量类型
     
340.      switch(m_tokens.at(i+3).tok) [url]file://看[/url]看是什么变量类型
     
341.      {
     
342.           case INTEGER: // 如果是Integer类型
     
343.         strcpy(member.name,m_tokens.at(i+1).token);
     
344.         member.value=0;
     
345.         m_intArray.push_back(member);
     
346.         *index+=3; // 将m_tokens里的指针跳3个
     
347.         break;
     
348.           default:     
     
349.         break;
     
350.      }
     
351.     }
     
352.    }
     
353.   }
     
354. }
     
355. 
     
356. void CExecutable::Run_Assignment(int *index) [url]file://index[/url]必须指到'='的token
     
357. {
     
358. int var_type=Isvar(m_tokens.at(*index - 1).token);
     
359. if(!var_type) // 如果等号前面不是个变量
     
360. {
     
361.   serror(0);
     
362.   return;
     
363. }
     
364. switch(var_type)
     
365. {
     
366. case INTEGER:
     
367.   {
     
368.    int Var_No,value;
     
369.    if(!Ai_GetVarNo(m_tokens.at(*index-1).token,&Var_No,INTEGER))
     
370.                break;
     
371.    (*index)++;
     
372.             if(!Ai_GetNextValue(&value,INTEGER,index))
     
373.       break;
     
374.    m_intArray.at(Var_No).value=value;
     
375.    break;
     
376.   }
     
377. default: break;
     
378. }
     
379. }
     
380. 
     
381. 
     
382. 
     
383. int CExecutable::Ai_GetNextValue(void *result,int type,int *index) [url]file://index[/url]指到代数式的第一个token
     
384. {
     
385. switch(type)
     
386. {
     
387. case INTEGER: get_exp((int*)result,index);
     
388.             return 1;
     
389. default:    return 0;
     
390. }
     
391. 
     
392. }
     
393. 
     
394. int CExecutable::Ai_GetVarNo(char *name,int *result,int type)
     
395. {
     
396. switch(type)
     
397. {
     
398. case INTEGER:
     
399.   {
     
400.    if(m_intArray.size()==0)
     
401.     return 0;
     
402.    for(int i=0;i<=m_intArray.size()-1;i++)
     
403.     if(!strcmp(name,m_intArray.at(i).name))
     
404.      *result=i;
     
405.     return 1;
     
406.   }
     
407. default: return 0;
     
408. }
     
409. 
     
410. }
     
411. void CExecutable::get_exp(int *result,int *index)
     
412. {
     
413.     if (!*m_tokens.at(*index).token)
     
414. {
     
415.         serror(2);
     
416.         return;
     
417.     }
     
418.     level2(result,index);
     
419.    
     
420. }
     
421. 
     
422. 
     
423. /* add or subtract two terms */
     
424. void CExecutable::level2(int *result,int *index)
     
425. {
     
426.     register char op;
     
427.     int hold;
     
428.     level3(result,index);
     
429.     while ((op = *m_tokens.at(*index).token) =='+' || op == '-')  
     
430. {
     
431.         (*index)++;
     
432.         level3(&hold,index);
     
433.         arith(op,result,&hold);
     
434.     }
     
435. }
     
436. 
     
437. 
     
438. /* multiply or divide two factors */
     
439. void CExecutable::level3(int *result,int *index)
     
440. {
     
441. register char op;
     
442.     int hold;
     
443.     level4(result,index);
     
444.     while ((op = *m_tokens.at(*index).token) == '*' || op == '/' || op == '%')  
     
445. {
     
446.         (*index)++;
     
447.         level3(&hold,index);
     
448.         arith(op,result,&hold);
     
449.     }
     
450. }
     
451. 
     
452. 
     
453. /* process integer exponent */
     
454. void CExecutable::level4(int *result,int *index)
     
455. {
     
456. register char op;
     
457.     int hold;
     
458.     level5(result,index);
     
459.     if ((op = *m_tokens.at(*index).token) == '^')
     
460. {
     
461.         (*index)++;
     
462.         level5(&hold,index);
     
463.         arith(op,result,&hold);
     
464.     }
     
465. }
     
466.               
     
467. 
     
468. /* is a unary + or - */              
     
469. void CExecutable::level5(int *result,int *index)
     
470. {
     
471.     register char op;
     
472.     op = 0;
     
473.     if ((m_tokens.at(*index).token_type==DELIMITER) &&
     
474.   *m_tokens.at(*index).token == '+' ||
     
475.   *m_tokens.at(*index).token == '-' )  
     
476. {
     
477.         op = *m_tokens.at(*index).token;
     
478.         (*index)++;
     
479.     }
     
480.     level6(result,index);
     
481.     if (op)  
     
482.   if(op=='-')
     
483.    *result=-(*result);
     
484. }
     
485.                
     
486. 
     
487. /* process parenthesized expression */               
     
488. void CExecutable::level6(int *result,int *index)
     
489. {
     
490. if ((*m_tokens.at(*index).token == '(') && (m_tokens.at(*index).token_type == DELIMITER))  
     
491. {
     
492.         (*index)++;
     
493.         level2(result,index);
     
494.         if (*m_tokens.at(*index).token!=')')
     
495.             serror(1);
     
496.         (*index)++;
     
497.     }
     
498.     else
     
499.         primitive(result,index);
     
500. }
     
501. 
     
502. /* find value of number or variable */
     
503. void CExecutable::primitive(int *result,int *index)
     
504. {
     
505. int token_type=m_tokens.at(*index).token_type;
     
506.     if(Isvar(m_tokens.at(*index).token))  
     
507.   token_type=VARIABLE;
     
508.     switch (token_type)  {
     
509.         case VARIABLE:
     
510.             find_var(m_tokens.at(*index).token,result);
     
511.             (*index)++;
     
512.             return;
     
513.         case NUMBER:
     
514.             *result = atoi(m_tokens.at(*index).token);
     
515.             (*index)++;
     
516.             return;
     
517.         default:
     
518.             serror(0);
     
519.     }
     
520. }
     
521. 
     
522. int CExecutable::find_var(char *var_name,void *value)
     
523. {
     
524. for(int i=0;i<=m_intArray.size()-1;i++)
     
525.   if(!strcmp(var_name,m_intArray.at(i).name))
     
526.   {
     
527.    int *int_value=(int *)value;
     
528.    *int_value=m_intArray.at(i).value;
     
529.    return 1;
     
530.   }
     
531.     return 0;
     
532. }
     
533. 
     
534. int CExecutable::Isvar(char *name)
     
535. {
     
536. if(m_intArray.size()==0)
     
537.   return 0;
     
538. for(int i=0;i<=m_intArray.size()-1;i++)
     
539.   if(!strcmp(name,m_intArray.at(i).name))
     
540.         return INTEGER;
     
541. return 0;
     
542. }
     
543. 
     
544. /* perform the specified arithmetic */
     
545. void CExecutable::arith(char o,int *r,int *h)
     
546. {
     
547.     /*register*/ int t,ex;
     
548.    
     
549.     switch (o)  {
     
550.         case '-':
     
551.             *r = *r-*h;
     
552.             break;
     
553.         case '+':
     
554.             *r = *r+*h;
     
555.             break;
     
556.         case '*':
     
557.             *r = *r**h;
     
558.             break;
     
559.         case '/':
     
560.             *r = (*r)/(*h);
     
561.             break;
     
562.         case '%':
     
563.             *r = (*r)%(*h);
     
564.             break;
     
565.         case '^':
     
566.             ex = *r;
     
567.             if (*h==0)  {
     
568.                 *r = 1;
     
569.                 break;
     
570.             }
     
571.             for (t=*h-1;t>0;--t)  *r=(*r)*ex;
     
572.             break;
     
573.     }
     
574. }
     
575. 
     
576. int CExecutable::look_up(char *c)
     
577. {
     
578. if(strcmp(c,"print")==0)
     
579.   return PRINT;
     
580.     if(strcmp(c,"Integer")==0)
     
581.   return INTEGER;
     
582. if(strcmp(c,"Dim")==0)
     
583.   return DIM;
     
584. if(strcmp(c,"As")==0)
     
585.   return AS;
     
586.     return 0;
     
587. }
     
588. 
     
589. void CExecutable::serror(int error)
     
590. {
     
591. char *e[] = {
     
592.         "syntax error",
     
593.         "unbalanced parentheses",
     
594.         "no expression present",
     
595.         "equal sign expected",
     
596.         "not a variable",
     
597.         "label table full",
     
598.         "duplicate label",
     
599.         "undefined label",
     
600.         "THEN expected",
     
601.         "TO expected",
     
602.         "too many nested FOR loops",
     
603.         "NEXT without FOR",
     
604.         "too many nested GOSUB",
     
605.         "RETURN without GOSUB"
     
606.     };
     
607. 
     
608.     printf ("%s\n",e[error]);
     
609. }

复制代码

songfei

在网上,看到还是有部分程序爱好者希望能编出自己的编译器.当然,这的确是件难事,许多人都说要去看什么编译原理和精通汇编语言,结果让这些爱好者都望而却步.但是,当我们亲手去做做后,发现要做一个简单的程序解释器(就像Java和Basic)那样,还是挺容易的.你根本不用去看那些东西,只要你懂C语言,在看了本文后,就可以完成那样的解释器.

在网上,有许多大型C语言,Perl语言的编译器源代码.但当你下载后看看,竟发现点都看不懂.其实那些东西还是不看为妙.看了本文后,我相信你宁愿自己动手编,也不愿意去领会那些庞大的源代码了.

少说费话了,我们开始讲解.

这一篇Basic解释器的代码.十分经典.而且十分简单化.

get_token()是词汇提取,譬如 PRINT A+B

通过调用一次get_token(),就在 字符串token里装上PRINT
再调用一次get_token(),token里就装上A
再调用一次get_token(),token里就装上+
再调用一次get_token(),token里就装上B

很简单吧!

putback()是将prog指针向回移动一格.其中包含了词发分析和十分关键的代数式求值get_exp(int *result)

关于它的代数式求值get_exp(int *result),用到递归函数

void get_exp(),level2(),level3(),level4(),level5();
void level6(),primitive(),arith(),unary();

,确实难看懂,不过你尽管拿来用就是了.

话不多说,你看源代码就是了.最后,我将给你看看C++中完整的源代码

1. /*
   
2.    recursive descent parser for integer expression
   
3.    which may include variables
   
4. */
   
5. 
   
6. #include <STDIO.H>
   
7. #include <SETJMP.H>
   
8. #include <MATH.H>
   
9. #include <CTYPE.H>
   
10. #include <STDLIB.H>
    
11. 
    
12. #define DELIMITER 1
    
13. #define VARIABLE 2
    
14. #define NUMBER 3
    
15. #define COMMAND 4
    
16. #define STRING 5
    
17. #define QUOTE 6
    
18. 
    
19. #define EOL 9
    
20. #define FINISHED 10
    
21. 
    
22. extern char *prog;  /* holds expression to be analyzed */
    
23. 
    
24. extern jmp_buf e_buf;  /* hold enviroment */
    
25. extern int variables[26];  /* variables */
    
26. extern struct commands {
    
27.     char command[20];
    
28.     char tok;
    
29. } table[];
    
30. 
    
31. extern char token[80];  /* holds string representation of token */
    
32. extern char token_type;  /* contains type of token */
    
33. extern char tok;  /* holds the internal representation of token */
    
34. 
    
35. void get_exp(),level2(),level3(),level4(),level5();
    
36. void level6(),primitive(),arith(),unary();
    
37. void serror(),putback();
    
38. 
    
39. 
    
40. /* entry point into parser */
    
41. void get_exp(int *result)
    
42. {
    
43.     get_token();
    
44.     if (!*token) {
    
45.         serror(2);
    
46.         return;
    
47.     }
    
48.     level2(result);
    
49.     putback();  /*return last token read to input stream */
    
50. }
    
51. 
    
52. 
    
53. /* add or subtract two terms */
    
54. void level2(int *result)
    
55. {
    
56.     register char op;
    
57.     int hold;
    
58. 
    
59.     level3(result);
    
60.     while ((op = *token) =='+' || op == '-')  {
    
61.         get_token();
    
62.         level3(&hold);
    
63.         arith(op,result,&hold);
    
64.     }
    
65. }
    
66. 
    
67. 
    
68. /* multiply or divide two factors */
    
69. void level3(int *result)
    
70. {
    
71.     register char op;
    
72.     int hold;
    
73. 
    
74.     level4(result);
    
75.     while ((op = *token) == '*' || op == '/' || op == '%')  {
    
76.         get_token();
    
77.         level3(&hold);
    
78.         arith(op,result,&hold);
    
79.     }
    
80. }
    
81. 
    
82. 
    
83. /* process integer exponent */
    
84. void level4(int *result)
    
85. {
    
86.     register char op;
    
87.     int hold;
    
88. 
    
89.     level5(result);
    
90.     if (*token == '^') {
    
91.         get_token();
    
92.         level4(&hold);
    
93.         arith(op,result,&hold);
    
94.     }
    
95. }
    
96. 
    
97. 
    
98. /* is a unary + or - */
    
99. void level5(int *result)
    
100. {
     
101.     register char op;
     
102. 
     
103.     op = 0;
     
104.     if ((token_type==DELIMITER) && *token == '+' || *token == '-' )  {
     
105.         op = *token;
     
106.         get_token();
     
107.     }
     
108.     level6(result);
     
109.     if (op)  unary(op,result);
     
110. }
     
111. 
     
112. 
     
113. /* process parenthesized expression */
     
114. void level6(int *result)
     
115. {
     
116.     if ((*token == '(') && (token_type == DELIMITER))  {
     
117.         get_token();
     
118.         level2(result);
     
119.         if (*token!=')')
     
120.             serror(1);
     
121.         get_token();
     
122.     }
     
123.     else
     
124.         primitive(result);
     
125. }
     
126. 
     
127. 
     
128. /* find value of number or variable */
     
129. void primitive(int *result)
     
130. {
     
131.     switch (token_type)  {
     
132.         case VARIABLE:
     
133.             *result = find_var(token);
     
134.             get_token();
     
135.             return;
     
136.         case NUMBER:
     
137.             *result = atoi(token);
     
138.             get_token();
     
139.             return;
     
140.         default:
     
141.             serror(0);
     
142.     }
     
143. }
     
144. 
     
145. 
     
146. /* perform the specified arithmetic */
     
147. void arith(char o,int *r,int *h)
     
148. {
     
149.     register int t,ex;
     
150. 
     
151.     switch (o)  {
     
152.         case '-':
     
153.             *r = *r-*h;
     
154.             break;
     
155.         case '+':
     
156.             *r = *r+*h;
     
157.             break;
     
158.         case '*':
     
159.             *r = *r**h;
     
160.             break;
     
161.         case '/':
     
162.             *r = (*r)/(*h);
     
163.             break;
     
164.         case '%':
     
165.             *r = (*r)%(*h);
     
166.             break;
     
167.         case '^':
     
168.             ex = *r;
     
169.             if (*h==0)  {
     
170.                 *r = 1;
     
171.                 break;
     
172.             }
     
173.             for (t=*h-1;t>0;--t)  *r=(*r)*ex;
     
174.             break;
     
175.     }
     
176. }
     
177. 
     
178. 
     
179. /* reverse the sign */
     
180. void unary(char o,int *r)
     
181. {
     
182.     if (o=='-')  *r = -(*r);
     
183. }
     
184. 
     
185. 
     
186. /* find the value of a variable */
     
187. int find_var(char *s)
     
188. {
     
189.     if (!isalpha(*s))  {
     
190.         serror(4);  /* not a variable */
     
191.         return 0;
     
192.     }
     
193.     return variables[toupper(*token)-'A'];
     
194. }
     
195. 
     
196. 
     
197. /* display an error message */
     
198. void serror(int error)
     
199. {
     
200.     char *e[] = {
     
201.         "syntax error",
     
202.         "unbalanced parentheses",
     
203.         "no expression present",
     
204.         "equal sign expected",
     
205.         "not a variable",
     
206.         "label table full",
     
207.         "duplicate label",
     
208.         "undefined label",
     
209.         "THEN expected",
     
210.         "TO expected",
     
211.         "too many nested FOR loops",
     
212.         "NEXT without FOR",
     
213.         "too many nested GOSUB",
     
214.         "RETURN without GOSUB"
     
215.     };
     
216. 
     
217.     printf ("%s\n",e[error]);
     
218.     longjmp(e_buf,1);  /* return to save point */
     
219. }
     
220. 
     
221. 
     
222. /* get a token */
     
223. get_token()
     
224. {
     
225.     register char *temp;
     
226. 
     
227.     token_type = 0;tok = 0;
     
228.     temp = token;
     
229. 
     
230.     if (*prog == '\0')  {   /* end of file */
     
231.         *token = 0;
     
232.         tok = FINISHED;
     
233.         return (token_type = DELIMITER);
     
234.     }
     
235. 
     
236.     while (iswhite(*prog))  ++prog;  /* skip over white space */
     
237. 
     
238.     if (*prog == '\r')  {   /* CR LF */
     
239.         ++prog;++prog;
     
240.         tok = EOL;*token = '\r';
     
241.         token[1] = '\n';token[2] = 0;
     
242.         return (token_type = DELIMITER);
     
243.     }
     
244. 
     
245.     if (strchr("+-*^/%=;(),><",*prog))  {  /* delimiter */
     
246.         *temp = *prog;
     
247.         prog++;  /* advance to next position */
     
248.         temp++;
     
249.         *temp=0;
     
250.         return (token_type = DELIMITER);
     
251.     }
     
252. 
     
253.     if (*prog == '"')  {   /* quote string */
     
254.         prog++;
     
255.         while (*prog!='"'&&*prog!='\r')  *temp++=*prog++;
     
256.         if (*prog=='\r')  serror(1);
     
257.         prog++;*temp=0;
     
258.         return (token_type = QUOTE);
     
259.     }
     
260. 
     
261.     if (isdigit(*prog))  {   /* number */
     
262.         while (!isdelim(*prog))  *temp++=*prog++;
     
263.         *temp = '\0';
     
264.         return (token_type = NUMBER);
     
265.     }
     
266. 
     
267.     if (isalpha(*prog))  {   /* var or command */
     
268.         while (!isdelim(*prog))  *temp++=*prog++;
     
269.         token_type = STRING;
     
270.     }
     
271. 
     
272.     *temp = '\0';
     
273. 
     
274.     /* see if a string is a command or a variable */
     
275.     if (token_type == STRING)  {
     
276.         tok = look_up(token);  /* convert to internal rep */
     
277.         if (!tok)  token_type = VARIABLE;
     
278.         else token_type = COMMAND;  /* is a command */
     
279.     }
     
280.     return token_type;
     
281. }
     
282. 
     
283. 
     
284. /* return a token to input stream */
     
285. void putback()
     
286. {
     
287.     char *t;
     
288.     t = token;
     
289.     for (;*t;t++)  prog--;
     
290. }
     
291. 
     
292. 
     
293. look_up(char *s)
     
294. {
     
295.     register int i,j;
     
296.     char *p;
     
297. 
     
298.     /* convert to lowercase */
     
299.     p = s;
     
300.     while (*p)  { *p = tolower(*p); p++;  }
     
301. 
     
302.     /* see if token is in table */
     
303.     for (i=0;*table[i].command;i++)
     
304.         if (!strcmp(table[i].command,s))  return table[i].tok;
     
305.     return 0;   /* unknown command */
     
306. }
     
307. 
     
308. 
     
309. /* return true if c is a delimiter */
     
310. isdelim(char c)
     
311. {
     
312.     if (strchr(";,+-<>/*%^=() ",c)||c==9||c=='\r'||c==0)
     
313.         return 1;
     
314.     return 0;
     
315. }
     
316. 
     
317. 
     
318. iswhite (char c)
     
319. {
     
320.     if (c==' '||c=='\t')  return 1;
     
321.     else return 0;
     
322. }

复制代码

xkzhouzhi

对我来说，真的很难懂