Brainfuck语言

介绍

Brainfuck是一种极小化的计算机语言，它是由Urban Müller在1993年创建的。

Müller的目标是创建一种简单的、可以用最小的编译器来实现的、符合图灵完全思想的编程语言。

这种语言基于一个简单的机器模型，除了指令，这个机器还包括：一个以字节为单位、被初始化为零的数组、一个指向该数组的指针（初始时指向数组的第一个字节）、以及用于输入输出的两个字节流。

下面是这八种状态的描述，其中每个状态由一个字符标识：

字符	含义
>	指针加一
<	指针减一
+	指针指向的字节的值加一
-	指针指向的字节的值减一
.	输出指针指向的单元内容（ASCII码）
,	输入内容到指针指向的单元（ASCII码）
[	如果指针指向的单元值为零，向后跳转到对应的]指令的次一指令处
]	如果指针指向的单元值不为零，向前跳转到对应的[指令的次一指令处

解释器(C语言实现)

/**
 * Brainfuck Compiler
 * Written By Skygr, Feb 5th, 2015.
 * Last Modified Feb 5th, 2015.
 * Email: [email protected]
 * FileName: bf.c
 * Usage:
 *      gcc bf.c -o Brainfuck && ./Brainfuck [BF-SourceFile]
 */

#include 
#include 

struct node {
    char value;
    struct node *prev, *next;
} *data, *code;

FILE *source;

char symbol;

int count;

int main ( int argc, char **argv ) {
    if ( argc < 2 ) {
        fprintf( stderr, "Usage: Brainfuck [Brainfuck-Source]\n" ); 
    } else {
        if ( ( source = fopen( argv[1], "r" ) ) == NULL ) {
            fprintf( stderr, "Cannot Find %s\n", argv[1] );
        } else {
            for ( code = NULL ; ( symbol = fgetc( source ) ) != EOF ; ) {
                switch ( symbol ) {
                    case '>':
                    case '<':
                    case '+':
                    case '-':
                    case '.':
                    case ',':
                    case '[':
                    case ']':
                        if ( code == NULL ) {
                            code = (struct node*)malloc( sizeof( struct node ) );
                            code->prev = NULL;
                            code->next = NULL;
                            code->value = symbol;
                        } else {
                            code->next = (struct node*)malloc( sizeof( struct node ) );
                            code->next->prev = code;
                            code->next->next = NULL;
                            code->next->value = symbol;
                            code = code->next;
                        }
                }
            }
            for ( ; code != NULL && code->prev != NULL ; ) {
                code = code->prev;
            }
            data = (struct node*)malloc( sizeof( struct node ) );
            data->prev = NULL;
            data->next = NULL;
            data->value = 0;
            for ( ; code != NULL ; code = code->next ) {
                switch ( code->value ) {
                    case '>':
                        if ( data->next == NULL ) {
                            data->next = (struct node*)malloc( sizeof( struct node ) );
                            data->next->prev = data;
                            data->next->next = NULL;
                            data->next->value = 0;
                        }
                        data = data->next;
                        break;
                    case '<':
                        if ( data->prev == NULL ) {
                            fprintf( stderr, "\nPointer OverFlow!\n" );
                            exit( 0 );  
                        }
                        data = data->prev;
                        break;
                    case '+':
                        data->value++;
                        break;
                    case '-':
                        data->value--;
                        break;
                    case '.':
                        putchar( data->value );
                        break;
                    case ',':
                        data->value = getchar();
                        break;
                    case '[':
                        if ( data->value == 0 ) {
                            for( count = 0 ; code != NULL ; code = code->next ) {
                                switch ( code->value ) {
                                    case '[':
                                        count++;
                                        break;
                                    case ']':
                                        count--;
                                        break;
                                }
                                if ( count == 0 )
                                    break;
                            }
                            if ( count != 0 ) {
                                fprintf( stderr, "\nSyntax Error!\n" );
                                exit( 0 );
                            }
                        }
                        break;
                    case ']':
                        if ( data->value != 0 ) {
                            for( count = 0; code != NULL ; code = code->prev ) {
                                switch ( code->value ) {
                                    case '[':
                                        count--;
                                        break;
                                    case ']':
                                        count++;
                                        break;
                                }
                                if ( count == 0 )
                                    break;
                            }
                            if ( count != 0 ) {
                                fprintf( stderr, "\nSyntax Error!\n" );
                                exit( 0 );
                            }
                        }
                        break;
                }
            }
        }
    }
    return 0;
}