用C#实现的简单PL0 to C 编译器

 用C#实现的简单PL0  to C编译器
作者:yxin1322
 blog:http://blog.csdn.net/yxin1322  转载请注明出处

         这个程序是我《编译原理》的期末大作业,要求实现PL0到C语言的编译器,其实叫翻译器更贴切点。程序的实现目标是能把具有基本Pascal语法的pl0语言源程序转换成C语言程序。pl0支持变量定义、条件语句、循环语句、赋值语句,变量的控制台输入与输出。翻译出的C语言程序需能被常见的C编译器编译通过。

         本程序分为两大模块:词法分析模块和语法制导翻译及输出模块。

         词法分析模块:通过程序指定一个由pl0语言编写的程序源文件,词法分析器能够将源文件内容分解为一组单词序列,并判别每个单词的所属类别(分别有运算符、分界符、关键字、变量名和数字),当遇到非法字符串时,能报出错误发生的位置。如果分析成功而未遇到任何错误,则词法分析器返回给编译程序一个单词集合,以用来做语法分析。每个单词存放在一个WordTableEntry结果中。
        
词法分析模块代码如下:
GETSYM.CS
1    
7    
8    
9      ;
10     .;
11     ..;
12     .;
13    
14     GETSYM
15    {
16    	
17    	
18    	
19    	  GETSYM
20    	{
21    		  [] OperatorList={,,,,,,
22                    ,,,,,,}; 
23    		  [] Bound_OperatorList={,,,,};  
24    		  [] Reserved_WordsList=
25                              {,,,,,,,
26                               CALLWHILE",,,,}; 
27    
28    
29    		 ArrayList WordTable; 
30    		  pl0FilePath; 
31    
32    		
33    		 GETSYM()
34    		{
35    			WordTable= ArrayList();
36    			PL0FilePath=;
37    		}
38    
39    		
40    		 GETSYM( filepath)
41    		{
42    			WordTable= ArrayList();
43    			PL0FilePath=filepath;
44    		}
45    
46    		
47    		  PL0FilePath
48    		{
49    			get{ pl0FilePath;}
50    			set{pl0FilePath=value;}
51    		}
52    
53    		
54    		  WriteSYMToFile()
55    		{
56    			(pl0FilePath.Equals())
57    			{
58    				.Console.WriteLine();
59    				 ;
60    			}
61    
62    			 temfilename=Regex.Replace(PL0FilePath,@,);
63    			 OutPutFileName=temfilename+;
64    
65    			..StreamWriter sw=;
66    
67    			sw=File.CreateText(OutPutFileName);
68    
69    			sw.WriteLine("
70    			sw.WriteLine("
71    			sw.WriteLine("
72    			sw.WriteLine("
73    			sw.WriteLine("
74    
75    			.Console.WriteLine();
76    			( i=;i<WordTable.Count;i++)
77    			{
78    				sw.WriteLine(,((WordTableEntry)WordTable[i]).WordType.ToString(),
79                                                 ((WordTableEntry)WordTable[i]).Word);
80    			}
81    			sw.Close();
82    
83    			.Console.WriteLine(,OutPutFileName);
84    		}
85    
86    		
87    		  getSYM()
88    		{
89    			.Console.WriteLine();
90    			.Console.WriteLine();
91    			.Console.WriteLine();
92    
93    			ArrayList ErrorList= ArrayList();
94    			(pl0FilePath.Equals())
95    			{
96    				.Console.WriteLine();
97    				 ;
98    			}
99    			(!File.Exists(pl0FilePath))
100    			{
101    				.Console.WriteLine();
102    				 ;
103    			}
104    			
105    			{
106    				.Console.WriteLine();
107    				StreamReader sr=File.OpenText(PL0FilePath);
108    
109    				 LineNum=; 
110    				 Line=sr.ReadLine();
111    
112    				LineNum++;
113    				(Line!=)
114    				{
115    					(Regex.IsMatch(Line,@)) 
116    					{
117    						Line=sr.ReadLine();
118    						LineNum++;
119    					}
120    
121    					
122    					{
123    						Line=Regex.Replace(Line,@"
124    
125    						( i=;i<OperatorList.Length;i++)  
126    							Line=Line.Replace(OperatorList[i],+OperatorList[i]+);
127    						( i=;i<Bound_OperatorList.Length;i++)
128    							Line=Line.Replace(Bound_OperatorList[i],+Bound_OperatorList[i]+);
129    
130    						Line=Regex.Replace(Line,@,);
131    						Line=Line.Trim(); 
132    
133    						 [] WordSplit=Regex.Split(Line,);
134    						( k=;k<WordSplit.Length;k++)
135    						{
136    							 str1=WordSplit[k];
137    							 str2=(k<WordSplit.Length-)?WordSplit[k+]:;
138    
139    							(str1.Equals())
140    								;
141    							(GETSYM.IsOperator( str1,str2, k))
142    								WordTable.Add( WordTableEntry(Word_Type.,str1));
143    							 (GETSYM.IsNumber(str1))
144    								WordTable.Add( WordTableEntry(Word_Type.Number,str1));
145    							 (GETSYM.IsBound_Operator(str1))
146    								WordTable.Add( WordTableEntry(Word_Type.Bound_Operator,str1));
147    							 (GETSYM.IsReserved_Words(str1))
148    								WordTable.Add( WordTableEntry(Word_Type.Reserved_Words,str1));
149    							 (GETSYM.IsIdentifier(str1))
150    								WordTable.Add( WordTableEntry(Word_Type.Identifier,str1));
151    							
152    							{
153    								 error=+LineNum++str1+;
154    								ErrorList.Add(error);
155    							}
156    
157    						}
158    
159    					
160    						Line=sr.ReadLine();
161    						LineNum++;
162    					}
163    
164    				}
165    				sr.Close();
166    			 }
167    			(ErrorList.Count==)
168    				 ;
169    			
170    			{
171    				( i=;i<ErrorList.Count;i++)
172    					Console.WriteLine(()ErrorList[i]);
173    				 ;
174    			}
175    		}
176    
177    		   IsBound_Operator( a)
178    		{
179    			( str  Bound_OperatorList)
180    			{
181    				(a.Equals(str))
182    					 ;
183    			}
184    			 ;
185    		}
186    
187    		   IsOperator(  a, b,  c)
188    		{
189    			 tem=a+b;
190    			( str  OperatorList)
191    			{
192    				(tem.Equals(str))
193    				{
194    					a=a+b;
195    					c++;
196    					 ;
197    				}
198    			}
199    			( str  OperatorList)
200    			{
201    				(a.Equals(str))
202    					 ;
203    			}
204    			 ;
205    
206    		}
207    
208    		   IsReserved_Words( a)
209    		{
210    			( str  Reserved_WordsList)
211    			{
212    				((a.ToUpper()).Equals(str))
213    					 ;
214    			}
215    			 ;
216    		}
217    
218    		   IsNumber( str)
219    		{
220    			Regex r= Regex(@);
221    			(r.IsMatch(str))
222    				 ;
223    			
224    				 ;
225    		}
226    		   IsIdentifier( str)
227    		{
228    			Regex r= Regex(@);
229    			(r.IsMatch(str))
230    				 ;
231    			
232    				 ;
233    
234    		}
235    
236    	}
237    }
WordTableEntry.CS
1    
6    
7     ;
8    
9    
10      Word_Type{Reserved_Words,Number,,Bound_Operator,Identifier,other}
11     GETSYM
12    {
13    
14    
15    	
16    	
17    	
18    	  WordTableEntry
19    	{
20    
21    
22    
23    		 Word_Type wordtype;
24    		  word;
25    
26    		 WordTableEntry() 
27    		{
28    			wordtype=Word_Type.other;
29    			word=;
30    		}
31    
32    		 WordTableEntry(Word_Type a, b)
33    		{
34    			wordtype=a;
35    			word=b;
36    		}
37    
38    		  Word 
39    		{
40    			get
41    			{
42    				 word;
43    			}
44    			set
45    			{
46    				word=value;
47    			}
48    		}
49    
50    		 Word_Type WordType 
51    		{
52    			get
53    			{
54    				 wordtype;
55    			}
56    			set
57    			{
58    				wordtype=value;
59    			}
60    		}
61    
62    
63    	}
64    }
         语法制导翻译及输出模块:为了翻译的简便,我采用了语法制导翻译的方式,即一边进行语法分析,一边将pl0语言翻译成C语言,若遇到语法错误则停止翻译,报告错误。在实现方式上采用了递归子程序法,递归子程序法简单直观,只要分析出了pl0语言的语法范式(EBNF),就能为每个范式构造对应的子程序。这里我已经得到了pl0语言的EBNF,如下:

  〈程序〉∷=〈分程序〉.
  〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉
  〈常量说明部分〉∷=CONST〈常量定义〉 {,〈常量定义〉};
  〈常量定义〉∷=〈标识符〉=〈无符号整数〉
  〈无符号整数〉∷=〈数字〉{〈数字〉}
  〈变量说明部分〉∷=VAR〈标识符〉{,〈标识符〉};
  〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}
  〈过程说明部分〉∷=〈过程首部〉〈分程序〉{;〈过程说明部分〉};
  〈过程首部〉∷=PROCEDURE〈标识符〉;
  〈语句〉∷=〈赋值语句〉|〈条件语句〉|〈当型循环语句〉|
        〈过程调用语句〉|〈读语句〉|〈写语句〉|〈复合语句〉|〈空〉
  〈赋值语句〉∷=〈标识符〉∶=〈表达式〉
  〈复合语句〉∷=BEGIN〈语句〉{;〈语句〉}END
  〈条件〉∷=〈表达式〉〈关系运算符〉〈表达式〉|ODD〈表达式〉
  〈表达式〉∷=[+|-]〈项〉{〈加法运算符〉〈项〉}
  〈项〉∷=〈因子〉{〈乘法运算符〉〈因子〉}
  〈因子〉∷=〈标识符〉|〈无符号整数〉|'('〈表达式〉')'
  〈加法运算符〉∷=+|-
  〈乘法运算符〉∷=*|/
  〈关系运算符〉∷=#|=|<|<=|>|>=
  〈条件语句〉∷=IF〈条件〉THEN〈语句〉
  〈过程调用语句〉∷=CALL〈标识符〉
  〈当型循环语句〉∷=WHILE〈条件〉DO〈语句〉
  〈读语句〉∷=READ'('〈标识符〉{,〈标识符〉}')'
  〈写语句〉∷=WRITE'('〈表达式〉{,〈表达式〉}')'
  〈字母〉∷=a|b|…|X|Y|Z
  〈数字〉∷=0|1|2|…|8|9

         根据EBNF就可以很快写出语法分析和翻译程序,代码如下:
1    
9    
10     ;
11     .;
12     .;
13     ..;
14     GETSYM;
15    
16     Pascal_to_C_Convertor
17    {
18    	
19    	
20    	
21    	
22    	  Pascal_to_C
23    	{
24    		  pascal_file_name;
25    		   word_count;
26    		 ArrayList pascal_word_table;
27    		 ArrayList C_Source;
28    		 ArrayList ErrorList;
29    
30    
31    		 Pascal_to_C()
32    		{
33    			.pascal_file_name=;
34    			word_count=-;
35    			.pascal_word_table= ArrayList();
36    			.C_Source= ArrayList();
37    			.ErrorList= ArrayList();
38    
39    		}
40    
41    		 Pascal_to_C( filename)
42    		{
43    			.PascalFileName=filename;
44    			word_count=-;
45    			.pascal_word_table= ArrayList();
46    			.C_Source= ArrayList();
47    			.ErrorList= ArrayList();
48    		}
49    
50    		  PascalFileName
51    		{
52    			get{ .pascal_file_name;}
53    			set{.pascal_file_name=value;}
54    		}
55    
56    		
57    		 ArrayList LoadWordTableFromFile()		
58    		{
59    			GETSYM.GETSYM gs= GETSYM.GETSYM(.PascalFileName);
60    			(gs.getSYM())
61    				 gs.WordTable;
62    			
63    				 ;
64    		}
65    
66    		  CreateCSourceCode()
67    		{
68    			.pascal_word_table=.LoadWordTableFromFile();
69    
70    			(.pascal_word_table==)
71    			{
72    				 ;
73    			}
74    			.pascal_word_table.Add( WordTableEntry(Word_Type.other,));
75    
76    			WordTableEntry w=.getNextWord();
77    
78    			.Console.WriteLine();
79    
80    			.Program( w);  
81    			(word_count==.pascal_word_table.Count- && ErrorList.Count==)
82    			{
83    				 ;
84    			}
85    			
86    			{
87    				.PrintErrorList();
88    				 ;
89    			}
90    		}
91    
92    		
93    		 WordTableEntry getNextWord()
94    		{
95    			word_count++;
96    			 ((WordTableEntry).pascal_word_table[word_count]);
97    		}
98    
99    		
100    		
101    		
102    		
103    		  Program( WordTableEntry w)
104    		{
105    			Subprogram( w);
106    			(!w.Word.Equals())
107    			{
108    				ErrorList.Add();
109    			}
110    			
111    			{
112    				.C_Source.Add();
113    
114    				w=.getNextWord();
115    			}
116    			
117    		}
118    
119    		
120    		
121    		  Subprogram( WordTableEntry w)
122    		{
123    			(w.Word.ToUpper().Equals())
124    				.ConstValueExplain( w);
125    			(w.Word.ToUpper().Equals())
126    				.VariableExplain( w);
127    			(w.Word.ToUpper().Equals())
128    				.ProcedureExplain( w);
129    			.Sentence( w);
130    
131    		}
132    
133    		
134    		
135    		  ConstValueExplain( WordTableEntry w)
136    		{
137    			(w.Word.ToUpper().Equals())
138    			{
139    				.C_Source.Add();
140    
141    				w=.getNextWord();
142    				.ConstValue( w);
143    				(w.Word.ToUpper().Equals())
144    				{
145    					.C_Source.Add();
146    
147    					w=.getNextWord();
148    					.ConstValue( w);
149    				}
150    				(!w.Word.Equals())
151    				{
152    					ErrorList.Add();
153    				}
154    				
155    				{
156    					.C_Source.Add();
157    					w=.getNextWord();
158    				}
159    
160    			}
161    		}
162    
163    		
164    		
165    		  ConstValue( WordTableEntry w)
166    		{
167    			.Identifier( w);
168    
169    			(w.Word.Equals())
170    			{
171    				.C_Source.Add();
172    
173    				w=.getNextWord();
174    				.UnsignedNumber( w);
175    			}
176    			
177    			{
178    				.ErrorList.Add();
179    			}
180    		}
181    
182    		
183    		
184    		  UnsignedNumber( WordTableEntry w)
185    		{
186    			(w.WordType==Word_Type.Number)
187    			{
188    				.C_Source.Add(w.Word);
189    
190    				w=.getNextWord();
191    			}
192    			
193    				ErrorList.Add();
194    		}
195    
196    		
197    		
198    		  VariableExplain( WordTableEntry w)
199    		{
200    			(w.Word.ToUpper().Equals())
201    			{
202    				.C_Source.Add();
203    
204    				w=.getNextWord();
205    				.Identifier( w);
206    					(w.Word.ToUpper().Equals())
207    					{
208    						.C_Source.Add();
209    
210    						w=.getNextWord();
211    						.Identifier( w);
212    					}
213    				(!w.Word.Equals())
214    				{
215    					ErrorList.Add();
216    				}
217    				
218    				{
219    					.C_Source.Add();
220    
221    					w=.getNextWord();
222    				}
223    
224    			}
225    		}
226    
227    		
228    		
229    		  Identifier( WordTableEntry w)
230    		{
231    			 (w.WordType==Word_Type.Identifier)
232    			{
233    				.C_Source.Add(w.Word);
234    
235    				w=.getNextWord();
236    			}
237    			
238    			{
239    				ErrorList.Add();
240    													 }
241    		}
242    
243    		
244    		
245    		  ProcedureExplain( WordTableEntry w)
246    		{
247    			.ProcedureHead( w);
248    
249    			.C_Source.Add();
250    
251    			.Subprogram( w);
252    			(w.Word.Equals()) 
253    			{
254    				.C_Source.Add();
255    
256    				w=.getNextWord();
257    				.ProcedureExplain( w);
258    			}
259    			 (!w.Word.Equals())
260    			{
261    				ErrorList.Add();
262    			}
263    			
264    			{
265    				.C_Source.Add();
266    
267    				w=.getNextWord();
268    			}
269    		}
270    
271    		
272    		
273    		  ProcedureHead( WordTableEntry w)
274    		{
275    			(w.Word.ToUpper().Equals())
276    			{
277    				.C_Source.Add();
278    
279    				w=.getNextWord();
280    				.Identifier( w);
281    				 (!w.Word.Equals())
282    				{
283    					ErrorList.Add();
284    				}
285    				
286    				{
287    					.C_Source.Add();
288    					w=.getNextWord();
289    				}
290    			}
291    			
292    				ErrorList.Add();
293    		}
294    
295    		
296    		
297    		  Sentence( WordTableEntry w)
298    		{
299    			 (w.WordType==Word_Type.Identifier) 
300    			{
301    				.EvaluateSentence( w);
302    			}
303    			  (w.Word.ToUpper().Equals())
304    			{
305    				.ConditionSentence( w);
306    			}
307    			  (w.Word.ToUpper().Equals())
308    			{
309    				.WhileSentence( w);
310    			}
311    			  (w.Word.ToUpper().Equals())
312    			{
313    				.WhileSentence( w);
314    			}
315    			  (w.Word.ToUpper().Equals())
316    			{
317    				.ReadSentence( w);
318    			}
319    			  (w.Word.ToUpper().Equals())
320    			{
321    				.WriteSentence( w);
322    			}
323    			  (w.Word.ToUpper().Equals())
324    			{
325    				.ComplexSentence( w);
326    			}
327    			
328    			{
329    				;
330    			}
331    		}
332    
333    		
334    		
335    		  EvaluateSentence( WordTableEntry w)
336    		{
337    			.Identifier( w);
338    			 (w.Word.Equals())
339    			{
340    				.C_Source.Add();
341    
342    				w=.getNextWord();
343    				.Expression( w);
344    			}
345    			
346    				ErrorList.Add();
347    		}
348    
349    		
350    		
351    		  ComplexSentence( WordTableEntry w)
352    		{
353    			 (w.Word.ToUpper().Equals())
354    			{
355    				.C_Source.Add();
356    
357    				w=.getNextWord();
358    				.Sentence( w);
359    				(w.Word.Equals())
360    				{
361    					.C_Source.Add();
362    
363    					w=.getNextWord();
364    					.Sentence( w);
365    				}
366    
367    				.C_Source.Add();
368    
369    				 (!w.Word.ToUpper().Equals())
370    				{
371    					ErrorList.Add();
372    				}
373    				
374    				{
375    					.C_Source.Add();
376    
377    					w=.getNextWord();
378    				}
379    			}
380    
381    		}
382    
383    		
384    		
385    		  Condition( WordTableEntry w)
386    		{
387    			 ((w.Word.Equals() || w.Word.Equals()) || w.WordType==Word_Type.Identifier) 
388    			{
389    				.Expression( w);
390    				.RelationSymbol( w);
391    				.Expression( w);
392    			}
393    			  (w.Word.ToUpper().Equals())
394    			{
395    				.C_Source.Add();
396    
397    				w=.getNextWord();
398    				.Expression( w);
399    
400    				.C_Source.Add();
401    			}
402    			
403    				ErrorList.Add();
404    		}
405    
406    		
407    		
408    		  Expression( WordTableEntry w)
409    		{
410    			 (w.Word.Equals())
411    			{
412    				.C_Source.Add();
413    
414    				w=.getNextWord();
415    			}
416    			  (w.Word.Equals())
417    			{
418    				.C_Source.Add();
419    
420    				w=.getNextWord();
421    			}
422    			
423    			{
424    				;
425    			}
426    			.ExpressionItem( w);
427    			 (w.Word.Equals() || w.Word.Equals())
428    			{
429    				.AdditiveSymbol( w);
430    				.ExpressionItem( w);
431    			}
432    		}
433    
434    		
435    		
436    		  ExpressionItem( WordTableEntry w)
437    		{
438    			.Gene( w);
439    			 (w.Word.Equals() || w.Word.Equals())
440    			{
441    				.MultiplicativeSymbol( w);
442    				.Gene( w);
443    			}
444    		}
445    
446    		
447    		
448    		  Gene( WordTableEntry w)
449    		{
450    			 (w.WordType==Word_Type.Identifier)
451    			{
452    
453    				.Identifier( w);
454    			}
455    			  (w.WordType==Word_Type.Number)
456    			{
457    
458    				.UnsignedNumber( w);
459    			}
460    			  (w.Word.Equals())
461    			{
462    				.C_Source.Add();
463    
464    				w=.getNextWord();
465    				.Expression( w);
466    				 (!w.Word.Equals())
467    				{
468    					ErrorList.Add();
469    				}
470    				
471    				{
472    					.C_Source.Add();
473    
474    					w=.getNextWord();
475    				}
476    			}
477    			
478    				ErrorList.Add();
479    		}
480    
481    		
482    		
483    		  AdditiveSymbol( WordTableEntry w)
484    		{
485    			 (w.Word.Equals() || w.Word.Equals())
486    			{
487    				.C_Source.Add(w.Word);
488    
489    				w=.getNextWord();
490    			}
491    			
492    				ErrorList.Add();
493    		}
494    
495    		
496    		
497    		  MultiplicativeSymbol( WordTableEntry w)
498    		{
499    			 (w.Word.Equals() || w.Word.Equals())
500    			{
501    				.C_Source.Add(w.Word);
502    
503    				w=.getNextWord();
504    			}
505    			
506    				ErrorList.Add();
507    		}
508    
509    		
510    		
511    		  RelationSymbol( WordTableEntry w)
512    		{
513    			 (w.Word.Equals() || w.Word.Equals())
514    			{
515    				.C_Source.Add(w.Word);
516    
517    				w=.getNextWord();
518    			}
519    			  (w.Word.Equals() || w.Word.Equals())
520    			{
521    				.C_Source.Add(w.Word);
522    
523    				w=.getNextWord();
524    			}
525    			  (w.Word.Equals() || w.Word.Equals())
526    			{
527    				.C_Source.Add(w.Word);
528    
529    				w=.getNextWord();
530    			}
531    			
532    				ErrorList.Add();
533    		}
534    
535    		
536    		
537    		  ConditionSentence( WordTableEntry w)
538    		{
539    			 (w.Word.ToUpper().Equals())
540    			{
541    				.C_Source.Add();
542    
543    				w=.getNextWord();
544    				.Condition( w);
545    
546    				.C_Source.Add();
547    
548    				 (w.Word.ToUpper().Equals())
549    				{
550    					.C_Source.Add();
551    
552    					w=.getNextWord();
553    					.Sentence( w);
554    
555    					.C_Source.Add();
556    				}
557    				
558    					ErrorList.Add();
559    			}
560    			
561    				ErrorList.Add();
562    		}
563    
564    		
565    		
566    		  ProcedureCall( WordTableEntry w)
567    		{
568    			(w.Word.ToUpper().Equals())
569    			{
570    				w=.getNextWord();
571    				.Identifier( w);
572    
573    				.C_Source.Add();
574    			}
575    
576    		}
577    
578    		
579    		
580    		  WhileSentence( WordTableEntry w)
581    		{
582    			 (w.Word.ToUpper().Equals())
583    			{
584    				.C_Source.Add();
585    
586    				w=.getNextWord();
587    				.Condition( w);
588    
589    				.C_Source.Add();
590    
591    				 (w.Word.ToUpper().Equals())
592    				{
593    					.C_Source.Add();
594    
595    					w=.getNextWord();
596    					.Sentence( w);
597    
598    					.C_Source.Add();
599    				}
600    				
601    					ErrorList.Add();
602    			}
603    			
604    				ErrorList.Add();
605    		}
606    
607    		
608    		
609    		  ReadSentence( WordTableEntry w)
610    		{
611    			 (w.Word.ToUpper().Equals())
612    			{
613    				w=.getNextWord();
614    				 (w.Word.Equals())
615    				{
616    					w=.getNextWord();
617    
618    					.C_Source.Add(%d/);
619    
620    					.Identifier( w);
621    					.C_Source.Add();
622    
623    					 (w.Word.Equals())
624    					{
625    						.C_Source.Add(%d/);
626    
627    						w=.getNextWord();
628    						.Identifier( w);
629    
630    						.C_Source.Add();
631    
632    					}
633    					 (!w.Word.Equals())
634    					{
635    						ErrorList.Add();
636    					}
637    					
638    						w=.getNextWord();
639    				}
640    				
641    					ErrorList.Add();
642    			}
643    		}
644    
645    		
646    		
647    		  WriteSentence( WordTableEntry w)
648    		{
649    			 (w.Word.ToUpper().Equals())
650    			{
651    				w=.getNextWord();
652    				 (w.Word.Equals())
653    				{
654    					.C_Source.Add(%d//n/);
655    
656    					w=.getNextWord();
657    					.Expression( w);
658    
659    					.C_Source.Add();
660    
661    					 (w.Word.Equals())
662    					{
663    						.C_Source.Add(%d//n/);
664    
665    						w=.getNextWord();
666    						.Expression( w);
667    
668    						.C_Source.Add();
669    					}
670    					 (!w.Word.Equals())
671    					{
672    						ErrorList.Add();
673    					}
674    					
675    						w=.getNextWord();
676    				}
677    				
678    					ErrorList.Add();
679    			}
680    		}
681    
682    		
683    		
684    		
685    		  PrintErrorList()
686    		{
687    			.Console.WriteLine();
688    			(ErrorList.Count==)
689    				.Console.WriteLine();
690    			( i=;i<ErrorList.Count;i++)
691    			{
692    				.Console.WriteLine(,i,()ErrorList[i]);
693    			}
694    		}
695    
696    		
697    		  SaveToCFile()
698    		{
699    			(.PascalFileName.Equals())
700    			{
701    				.Console.WriteLine();
702    				 ;
703    			}
704    
705    			 temfilename=Regex.Replace(.PascalFileName,@,);
706    			 OutPutFileName=temfilename+;
707    
708    			..StreamWriter sw=;
709    
710    			sw=File.CreateText(OutPutFileName);
711    
712    			sw.WriteLine("/*");
717    
718    			.Console.WriteLine();
719    
720    			sw.WriteLine();
721    			sw.WriteLine();
722    
723    
724    			( i=;i<this.C_Source.Count;i++)
725    			{
726    				sw.Write(,.C_Source[i]);
727    			}
728    			sw.WriteLine();
729    			sw.Close();
730    
731    
732    			.Console.WriteLine(,OutPutFileName);
733    		}
734    
735    		   Main([] args)
736    		{
737    			 pl0FileName;
738    			(args.Length==)
739    			{
740    				.Console.WriteLine();
741    				.Console.WriteLine();
742    				.Console.WriteLine();
743    				.Console.WriteLine();
744    
745    				.Console.Write();
746    				pl0FileName=.Console.ReadLine();
747    			}
748    			
749    			{
750    				pl0FileName=args[];
751    			}
752    
753    			.Console.WriteLine(pl0FileName);
754    			Pascal_to_C p2c= Pascal_to_C(pl0FileName);
755    			
756    			(p2c.CreateCSourceCode())
757    				p2c.SaveToCFile();
758    			
759    			.Console.ReadLine();
760    		}
761    	}
762    }

程序打包下载地址:http://free5.ys168.com/?yxin1322
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页