这个程序是我《编译原理》的期末大作业，要求实现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
〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉
〈常量说明部分〉∷=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