娛樂(lè)一下,介紹一種語(yǔ)言——brainfuck

nicolas.shen

這語(yǔ)言雖小但是還五臟俱全哈哈，寫得好�。�

cjaizss

解釋器又做了優(yōu)化

1. 
   
2. /*bf.c*/
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. char s[30000]={0};
   
6. char code[100000];
   
7. int len = 0;
   
8. int  stack[100];
   
9. int stack_len=0;
   
10. int main(int argc,char**argv)
    
11. {
    
12.         char c;
    
13.         int i,j,k,x=0;
    
14.         int m,n;
    
15.         FILE* f;
    
16.         char* p=s+10000;
    
17.         if(argc==2) {
    
18.                 f=fopen(argv[1],"r");
    
19.                 if(f==NULL) {
    
20.                         perror("fopen");
    
21.                                 return 1;
    
22.                 }
    
23.                 if((len=fread(code,1,sizeof(code),f))==0) {
    
24.                         return 4;
    
25.                 }
    
26.         } else return 2;
    
27. 
    
28.         /*optimization*/
    
29.         /*We can prove that n is never greater than m.So we can use the same memory*/
    
30.         for(m=0,n=0,c=0,j=0;m<len;m++) {
    
31.                 switch(code[m]) {
    
32.                         case '+':
    
33.                                 switch (j) {
    
34.                                         case 1:
    
35.                                                 code[n++]='>';
    
36.                                                 break;
    
37.                                         case -1:
    
38.                                                 code[n++]='<';
    
39.                                                 break;
    
40.                                         case 0:
    
41.                                                 break;
    
42.                                         default:
    
43.                                                 code[n++]='p';
    
44.                                                 code[n++]=j;
    
45.                                                 break;
    
46.                                 }
    
47.                                 j=0;
    
48.                                 c++;
    
49.                                 break;
    
50.                         case '-':
    
51.                                 switch (j) {
    
52.                                         case 1:
    
53.                                                 code[n++]='>';
    
54.                                                 break;
    
55.                                         case -1:
    
56.                                                 code[n++]='<';
    
57.                                                 break;
    
58.                                         case 0:
    
59.                                                 break;
    
60.                                         default:
    
61.                                                 code[n++]='p';
    
62.                                                 code[n++]=j;
    
63.                                                 break;
    
64.                                 }
    
65.                                 j=0;
    
66.                                 c--;
    
67.                                 break;
    
68.                         case '>':
    
69.                                 switch (c) {
    
70.                                         case ((char)1):
    
71.                                                 code[n++]='+';
    
72.                                                 break;
    
73.                                         case ((char)(-1)):
    
74.                                                 code[n++]='-';
    
75.                                                 break;
    
76.                                         case ((char)0):
    
77.                                                 break;
    
78.                                         default:
    
79.                                                 code[n++]='a';
    
80.                                                 code[n++]=c;
    
81.                                                 break;
    
82.                                 }
    
83.                                 c=0;
    
84.                                 j++;
    
85.                                 if(j==0x7f) {
    
86.                                         code[n++]='p';
    
87.                                         code[n++]=0x7f;
    
88.                                         j=0;
    
89.                                 }
    
90.                                 break;
    
91.                         case '<':
    
92.                                 switch (c) {
    
93.                                         case ((char)1):
    
94.                                                 code[n++]='+';
    
95.                                                 break;
    
96.                                         case ((char)(-1)):
    
97.                                                 code[n++]='-';
    
98.                                                 break;
    
99.                                         case ((char)0):
    
100.                                                 break;
     
101.                                         default:
     
102.                                                 code[n++]='a';
     
103.                                                 code[n++]=c;
     
104.                                                 break;
     
105.                                 }
     
106.                                 c=0;
     
107.                                 j--;
     
108.                                 if(j==-128) {
     
109.                                         code[n++]='p';
     
110.                                         code[n++]=-128;
     
111.                                         j=0;
     
112.                                 }
     
113.                                 break;
     
114.                         case '.':
     
115.                         case ',':
     
116.                         case '[':
     
117.                                 switch (c) {
     
118.                                         case ((char)1):
     
119.                                                 code[n++]='+';
     
120.                                                 break;
     
121.                                         case ((char)(-1)):
     
122.                                                 code[n++]='-';
     
123.                                                 break;
     
124.                                         case ((char)0):
     
125.                                                 break;
     
126.                                         default:
     
127.                                                 code[n++]='a';
     
128.                                                 code[n++]=c;
     
129.                                                 break;
     
130.                                 }
     
131.                                 c=0;
     
132.                                 switch (j) {
     
133.                                         case 1:
     
134.                                                 code[n++]='>';
     
135.                                                 break;
     
136.                                         case -1:
     
137.                                                 code[n++]='<';
     
138.                                                 break;
     
139.                                         case 0:
     
140.                                                 break;
     
141.                                         default:
     
142.                                                 code[n++]='p';
     
143.                                                 code[n++]=j;
     
144.                                                 break;
     
145.                                 }
     
146.                                 j=0;
     
147.                                 code[n++]=code[m];
     
148.                                 break;
     
149.                         case ']':
     
150.                                 switch (c) {
     
151.                                         case ((char)1):
     
152.                                                 code[n++]='+';
     
153.                                                 break;
     
154.                                         case ((char)(-1)):
     
155.                                                 code[n++]='-';
     
156.                                                 break;
     
157.                                         case ((char)0):
     
158.                                                 break;
     
159.                                         default:
     
160.                                                 code[n++]='a';
     
161.                                                 code[n++]=c;
     
162.                                                 break;
     
163.                                 }
     
164.                                 c=0;
     
165.                                 switch (j) {
     
166.                                         case 1:
     
167.                                                 code[n++]='>';
     
168.                                                 break;
     
169.                                         case -1:
     
170.                                                 code[n++]='<';
     
171.                                                 break;
     
172.                                         case 0:
     
173.                                                 break;
     
174.                                         default:
     
175.                                                 code[n++]='p';
     
176.                                                 code[n++]=j;
     
177.                                                 break;
     
178.                                 }
     
179.                                 j=0;
     
180.                                 if(n-1>=0&&n-2>=0&&code[n-2]=='['&&(code[n-1]=='+'||code[n-2]=='-')) {
     
181.                                         code[n-2]='0';
     
182.                                         n--;
     
183.                                 } else {
     
184.                                         code[n++]=code[m];
     
185.                                 }
     
186.                                 break;
     
187.                         default:
     
188.                                 break;
     
189.                 }
     
190.         }
     
191.         len=n;
     
192.         setbuf(stdout,NULL);
     
193. #if 0
     
194.         for(i=0;i<len;i++)
     
195.                 putchar(code[i]);
     
196.         return 0;
     
197. #endif
     
198.         i=0;
     
199.         while(i<len) {
     
200.                 switch(code[i]) {
     
201.                         case '0':
     
202.                                 *p=0;
     
203.                                 break;
     
204.                         case 'a':
     
205.                                 i++;
     
206.                                 *p+=code[i];
     
207.                                 break;
     
208.                         case 'p':
     
209.                                 i++;
     
210.                                 p+=code[i];
     
211.                                 break;
     
212.                         case '+':
     
213.                                 (*p)++;
     
214.                                 break;
     
215.                         case '-':
     
216.                                 (*p)--;
     
217.                                 break;
     
218.                         case '>':
     
219.                                 p++;
     
220.                                 break;
     
221.                         case '<':
     
222.                                 p--;
     
223.                                 break;
     
224.                         case '.':
     
225.                                 putchar((int)(*p));
     
226.                                 //printf("put:%hd\n",*p);
     
227.                                 break;
     
228.                         case ',':
     
229.                                 *p=getchar();
     
230.                                 break;
     
231.                         case '[':
     
232.                                 if(*p) {
     
233.                                         stack[stack_len++]=i;
     
234.                                 } else {
     
235.                                         for(k=i,j=0;k<len;k++) {
     
236.                                                 if(code[k]=='a'||code[k]=='p') {
     
237.                                                         k++;
     
238.                                                         continue;
     
239.                                                 }
     
240.                                                 code[k]=='['&&j++;
     
241.                                                 code[k]==']'&&j--;
     
242.                                                 if(j==0)break;
     
243.                                         }
     
244.                                         if(j==0)
     
245.                                                 i=k;
     
246.                                         else {
     
247.                                                 fprintf(stderr,"%s:%d\n",__FILE__,__LINE__);
     
248.                                                 return 3;
     
249.                                         }
     
250.                                 }
     
251.                                 break;
     
252.                         case ']':
     
253.                                 if(*p) {
     
254.                                         i=stack[stack_len - 1];
     
255.                                         #if 0
     
256.                                         if(code[i] != '[') {
     
257.                                                 fprintf(stderr,"%s:%d\n",__FILE__,__LINE__);
     
258.                                                 return 0;
     
259.                                         }
     
260.                                         #endif
     
261.                                 } else {
     
262.                                         stack_len--;
     
263.                                 }
     
264.                                 break;
     
265.                         default:
     
266.                                 break;
     
267.                 }
     
268.                 i++;
     
269.                 //x++;
     
270.                 //printf("%d : i=%d\n",x,i);
     
271.         }
     
272.         return 0;
     
273. }
     

復(fù)制代碼

[ 本帖最后由 cjaizss 于 2008-6-7 12:38 編輯 ]

realmon

化簡(jiǎn)為繁？

oklqh

上來(lái)佩服一下， 樓主的思維太牛了

teamstar

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
這些頭文件在我電腦的.NET2005上為什么沒(méi)有啊

system888net

LZ的編碼風(fēng)格也不錯(cuò)!
頂一下.

cjaizss

這幾個(gè)頭文件可以不要

cjaizss

隨著我對(duì)這個(gè)語(yǔ)言的理解越來(lái)越多,我會(huì)把這個(gè)解釋器優(yōu)化的越來(lái)越好

evaspring

原帖由 teamstar 于 2008-6-3 21:59 發(fā)表
#include
#include
#include
#include
這些頭文件在我電腦的.NET2005上為什么沒(méi)有啊

那幾個(gè)頭文件是類UNIX操作系統(tǒng)里才有的，你也可以去下一些其他的編譯器，有些自帶 ~

coneagoe

感覺(jué)像莫爾斯密碼，支持樓主