【YUKI】简单解释器而已…

cnzym

高中时编写了一个简单的解释器，取名INF，功能特别弱。
现在大一，由于课程设计要求制作一个中缀式计算器，于是顺便写了一个解释器，取名YUKI。
INF解释器是用C语言编写的，有些功能的确难以在C语言条件下实现。由于大一系统地学习了C++，YUKI解释器采用了面向对象的编程思路，功能提高极大。但是……但是……我没有学过编译原理-_-|||，所以不要苛求太多^_-!

该解释器可以解释自创的过程式语言，其特性（或者说是缺陷）有：
——几乎没有错误提示（既然是解释器那就将就一下吧-_-||）；
——支持自定义函数调用及其递归调用；
——内置若干种数学函数，以及功能可观的输出函数；
——由于希望将该解释器用MFC的方式实现，所以暂时没有设计输入语句；
——无数据类型（确切地说是均为double）；
——变量有local和global两种存储类别；
——只支持一维数组；
——每个语句占一行，行尾无分号；
——支持空格缩进；
——不支持自定义函数调用中的函数调用（例如：func(1,func(2,3))）；
——源代码文件末尾要加单独一行的“#”才能被正确读入；
……

今天将刚刚学习C语言时编写的简单日历C语言代码用Yuki重写，在该解释器中解释运行，效果如下：



其Yuki代码为：

1. // 使用Yuki语言编写的一个简单日历
   
2. // 2014.5.18
   
3. // cnzym @ cnCalc.org
   
4. 
   
5. // 行输出
   
6. func:println(m,n)
   
7. {
   
8.     local:i:=m
   
9.     while(i<=n)
   
10.     {
    
11.         printNum(i)
    
12.         print("  ")
    
13.         i:=i+1
    
14.     }
    
15. }
    
16. // 数字输出
    
17. func: printNum(x)
    
18. {
    
19.     if( x>=1 && x<=9 )
    
20.     {
    
21.         print(" ",x)
    
22.     }
    
23.     else
    
24.     {
    
25.         if( x>=10 && x<=31 )
    
26.         {
    
27.             print(x)
    
28.         }
    
29.         else
    
30.         {
    
31.             print("xx")
    
32.         }
    
33.     }
    
34. }
    
35. func: printhln(start_index)
    
36. {
    
37.     local:i:=1
    
38.     while(i<=(start_index-1)*2)
    
39.     {
    
40.         print("  ")
    
41.         i:=i+1
    
42.     }
    
43.     i:=1
    
44.     while(i<=8-start_index)
    
45.     {
    
46.         printNum(i)
    
47.         print("  ")
    
48.         i:=i+1
    
49.     }
    
50. }
    
51. func: pprint(start_index, md)
    
52. {
    
53.     local:j:=0
    
54.     printhln(start_index)
    
55.     print("\n")
    
56.     while(j<(md+(start_index-1))/7-2)
    
57.     {
    
58.         println(9-start_index+7*j,15-start_index+7*j)
    
59.         print("\n")
    
60.         j:=j+1
    
61.     }
    
62.     println(md-((md+start_index-1)%7)+1,md)
    
63.     print("\n")
    
64. }
    
65. func:islpyr(y)
    
66. {
    
67.     if(y%100!=0 && y%4==0)
    
68.     {
    
69.         return:1
    
70.     }
    
71.     if(y%100==0 && y%400==0)
    
72.     {
    
73.         return:1
    
74.     }
    
75.     if((y%4!=0 && y%100!=0)||(y%100==0 && y%400!=0))
    
76.     {
    
77.         return:0
    
78.     }
    
79. }
    
80. func: mdays(m, y)
    
81. {
    
82.     local:lp:=islpyr(y)
    
83.     if(m==1)
    
84.     {
    
85.         return:31
    
86.     }
    
87.     if(m==3)
    
88.     {
    
89.         return:31
    
90.     }
    
91.     if(m==4)
    
92.     {
    
93.         return:30
    
94.     }
    
95.     if(m==5)
    
96.     {
    
97.         return:31
    
98.     }
    
99.     if(m==6)
    
100.     {
     
101.         return:30
     
102.     }
     
103.     if(m==7)
     
104.     {
     
105.         return:31
     
106.     }
     
107.     if(m==8)
     
108.     {
     
109.         return:31
     
110.     }
     
111.     if(m==9)
     
112.     {
     
113.         return:30
     
114.     }
     
115.     if(m==10)
     
116.     {
     
117.         return:30
     
118.     }
     
119.     if(m==11)
     
120.     {
     
121.         return:31
     
122.     }
     
123.     if(m==2 && lp==1)
     
124.         return:29
     
125.     if(m==2 && lp==0)
     
126.         return:28
     
127. }
     
128. func:dsum(m,y)
     
129. {
     
130.     local:ds:=0
     
131.     local:j:=0
     
132.     if(m>0)
     
133.     {
     
134.         j:=1
     
135.         while(j<=m)
     
136.         {
     
137.             local:md:=mdays(j,y)
     
138.             ds:=ds+md
     
139.             j:=j+1
     
140.         }
     
141.         return:ds
     
142.     }
     
143.     if(m==0)
     
144.     {
     
145.         return:0
     
146.     }
     
147. }
     
148. func:ydays(y)
     
149. {
     
150.     local:lp:=islpyr(y)
     
151.     if(lp==0)
     
152.     {
     
153.         return:365
     
154.     }
     
155.     if(lp==1)
     
156.     {
     
157.         return:366
     
158.     }
     
159. }
     
160. 
     
161. func: week(y,m)
     
162. {
     
163.     local:i:=0
     
164.     local:dss:=1
     
165.     if(y>2010)
     
166.     {
     
167.         i:=2010
     
168.         while(i<y)
     
169.         {
     
170.             local:yd:=ydays(i)
     
171.             dss:=dss+yd
     
172.             i:=i+1
     
173.         }
     
174.         local:_dsum:=dsum(m-1,y)
     
175.         dss:=dss+_dsum
     
176.         local:a:=(dss-4)%7+1
     
177.         return:(dss-4)%7+1
     
178.     }
     
179.     if(y<2010)
     
180.     {
     
181.         i:=y
     
182.         while(i<=2009)
     
183.         {
     
184.             local:yd:=ydays(i)
     
185.             dss:=dss+yd
     
186.             i:=i+1
     
187.         }
     
188.         local:_dsum:=dsum(m-1,y)
     
189.         dss:=dss-_dsum
     
190.         if((dss-5)%7==0)
     
191.         {
     
192.             return:1
     
193.         }
     
194.         else
     
195.         {
     
196.             return:8-(dss-5)%7
     
197.         }
     
198.     }
     
199.     if(y==2010)
     
200.     {
     
201.         if(m==1)
     
202.         {
     
203.             return:5
     
204.         }
     
205.         local:_dsum:=dsum(m-1,2010)
     
206.         dss:=dss+_dsum
     
207.         dss:=dss+1
     
208.         return:(dss-4)%7
     
209.     }
     
210. }
     
211. 
     
212. func: main()
     
213. {
     
214.     local:year:=2014
     
215.     local:month:=5
     
216.     print("请注意：日历第一列是星期一！\n")
     
217.     print(year, "年", month, "月\n")
     
218.     local:wk:=week(year,month)
     
219.     //print(wk, "\n")
     
220.     local:md:=mdays(month,year)
     
221.     print("==========================\n")
     
222.     print("一  二  三  四  五  六  日\n")
     
223.     print("==========================\n")
     
224.     pprint(wk,md)
     
225.     print("==========================\n")
     
226.     #about
     
227. }
     
228. #
     

复制代码

代码和几个例子在附件中，如果各位发现了bug（觉得一定会很多……）或者有什么改进建议，欢迎指出~

Cursor

看起来很厉害。。。(/ω＼)

hikari.uiharu

推荐《编程语言实现模式》，
比编译原理要实用一些

HHX-XXM

直接链接成字节码?

cnzym

HHX-XXM 发表于 2014-5-18 19:26
直接链接成字节码?

解释器而已

rourou_Jun

Yuki  这让我想到了酷市场的那只妹子

Nero

把token用eval和apply两个函数互相递归来做会很方便地支持函数内的函数调用。
可以先看看SICP，算是最简单的一本讲语言解释的了。

HHX-XXM

rourou_Jun 发表于 2014-5-19 00:31
Yuki  这让我想到了酷市场的那只妹子

我倒是想起了有希..是不是yuki来着

cnzym

Nero 发表于 2014-5-19 11:28
把token用eval和apply两个函数互相递归来做会很方便地支持函数内的函数调用。
可以先看看SICP，算是最简单 ...

好的⊙▽⊙有时间了解一下

_14522

楼主如果知道NOIP或者ACM的话，可以看看LRJ白书厚的那本有一组题，实现MUA