免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
最近访问板块 发新帖
楼主: cjaizss

娱乐一下,介绍一种语言——brainfuck [复制链接]

论坛徽章:
0
发表于 2008-06-02 09:58 |显示全部楼层
这语言虽小但是还五脏俱全哈哈,写得好啊!

论坛徽章:
3
2015年迎新春徽章
日期:2015-03-04 09:56:11数据库技术版块每日发帖之星
日期:2016-08-03 06:20:00数据库技术版块每日发帖之星
日期:2016-08-04 06:20:00
发表于 2008-06-02 14:25 |显示全部楼层
解释器又做了优化

  1. /*bf.c*/
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. char s[30000]={0};
  5. char code[100000];
  6. int len = 0;
  7. int  stack[100];
  8. int stack_len=0;
  9. int main(int argc,char**argv)
  10. {
  11.         char c;
  12.         int i,j,k,x=0;
  13.         int m,n;
  14.         FILE* f;
  15.         char* p=s+10000;
  16.         if(argc==2) {
  17.                 f=fopen(argv[1],"r");
  18.                 if(f==NULL) {
  19.                         perror("fopen");
  20.                                 return 1;
  21.                 }
  22.                 if((len=fread(code,1,sizeof(code),f))==0) {
  23.                         return 4;
  24.                 }
  25.         } else return 2;

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

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

论坛徽章:
6
CU大牛徽章
日期:2013-04-17 10:59:39CU大牛徽章
日期:2013-04-17 11:01:45CU大牛徽章
日期:2013-04-17 11:02:15CU大牛徽章
日期:2013-04-17 11:02:36CU大牛徽章
日期:2013-04-17 11:02:582015年辞旧岁徽章
日期:2015-03-03 16:54:15
发表于 2008-06-03 20:46 |显示全部楼层
化简为繁?

论坛徽章:
0
发表于 2008-06-03 21:55 |显示全部楼层
上来佩服一下, 楼主的思维太牛了

论坛徽章:
0
发表于 2008-06-03 21:59 |显示全部楼层
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
这些头文件在我电脑的.NET2005上为什么没有啊

论坛徽章:
0
发表于 2008-06-03 22:40 |显示全部楼层
LZ的编码风格也不错!
顶一下.

论坛徽章:
3
2015年迎新春徽章
日期:2015-03-04 09:56:11数据库技术版块每日发帖之星
日期:2016-08-03 06:20:00数据库技术版块每日发帖之星
日期:2016-08-04 06:20:00
发表于 2008-06-03 22:46 |显示全部楼层

回复 #15 teamstar 的帖子

这几个头文件可以不要

论坛徽章:
3
2015年迎新春徽章
日期:2015-03-04 09:56:11数据库技术版块每日发帖之星
日期:2016-08-03 06:20:00数据库技术版块每日发帖之星
日期:2016-08-04 06:20:00
发表于 2008-06-04 00:40 |显示全部楼层
随着我对这个语言的理解越来越多,我会把这个解释器优化的越来越好

论坛徽章:
26
处女座
日期:2016-04-18 14:00:4515-16赛季CBA联赛之深圳
日期:2020-06-02 10:10:5015-16赛季CBA联赛之广夏
日期:2019-07-23 16:59:452016科比退役纪念章
日期:2019-06-26 16:59:1315-16赛季CBA联赛之天津
日期:2019-05-28 14:25:1915-16赛季CBA联赛之青岛
日期:2019-05-16 10:14:082016科比退役纪念章
日期:2019-01-11 14:44:062016科比退役纪念章
日期:2018-07-18 16:17:4015-16赛季CBA联赛之上海
日期:2017-08-22 18:18:5515-16赛季CBA联赛之江苏
日期:2017-08-04 17:00:4715-16赛季CBA联赛之佛山
日期:2017-02-20 18:21:1315-16赛季CBA联赛之天津
日期:2016-12-12 10:44:23
发表于 2008-06-04 11:38 |显示全部楼层
原帖由 teamstar 于 2008-6-3 21:59 发表
#include
#include
#include
#include
这些头文件在我电脑的.NET2005上为什么没有啊


那几个头文件是类UNIX操作系统里才有的,你也可以去下一些其他的编译器,有些自带 ~

论坛徽章:
0
发表于 2008-06-04 14:05 |显示全部楼层
感觉像莫尔斯密码,支持楼主
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们:huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP