Menu
What's new
By:
Filters

Brainf*ck

zenogais

zenogais

New member
I stumbled upon this language a long time ago, but never really did anything with it. Then yesterday I wrote a simple interpreter, and thought this might be a fun "very very basic" interpreted programing language for everyone on these forums to try out. You can find the documentation on the basic language here, and if anyone comes up with an interesting new instruction to add to the language, be sure to share. It shouldn't take more than 30 minutes - 1 hour to write and its a neat language to play around with.

I've attached my Python version, and I'll probably be writing others in C++ and Java just for fun pretty soon. And here's a little sample of the language:

Code: 
++++++++++[>+++++++<-]>++.
 
Last edited:
_Chrono_

_Chrono_

aka Chrono Archangel
(taken from Wikipedia)

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

It took me a while to understand it lol
Very interesting :)
 
smcd

smcd

Active member
I just used the stuff from http://www.muppetlabs.com/~breadbox/bf/
A Brainfuck program has an implicit byte pointer, called "the pointer", which is free to move around within an array of 30000 bytes, initially all set to zero. The pointer itself is initialized to point to the beginning of this array.

The Brainfuck programming language consists of eight commands, each of which is represented as a single character.

> Increment the pointer.
< Decrement the pointer.
+ Increment the byte at the pointer.
- Decrement the byte at the pointer.
. Output the byte at the pointer.
, Input a byte and store it in the byte at the pointer.
[ Jump forward past the matching ] if the byte at the pointer is zero.
] Jump backward to the matching [ unless the byte at the pointer is zero.

The semantics of the Brainfuck commands can also be succinctly expressed in terms of C, as follows (assuming that p has been previously defined as a char*):

> becomes ++p;
< becomes --p;
+ becomes ++*p;
- becomes --*p;
. becomes putchar(*p);
, becomes *p = getchar();
[ becomes while (*p) {
] becomes }
Click to expand...

here it is, no error checking and whatnot, and the formatting code isn't very efficient but it works :p

Code: 
#include<stdio.h>
#include<string.h>

const char *header = {
						"#include<stdio.h>\r\n"
						"int main(){\r\n"
						"\tchar *ptr;\r\n"
						"\tchar data[30000]={\'\\0\'};\r\n"
						"\tptr=data;\r\n\r\n"

					};
const char *footer = {
						"\treturn 0;\r\n"
						"}\r\n"
					};

int main(int argc, char *argv[])
{
	char c;
	FILE *in;
	FILE *out;
	int i=0;
	int brace=1;

	if(argc!=2)
	{
		puts("bfc infile");
		return 0;
	}
	in=fopen(argv[1], "rb");
	if(!in)
	{
		puts("fatal can't open file");
		return 0;
	}
	out=fopen("bfgen.c", "wb");
	if(!out)
	{
		puts("fatal can't open file");
		return 0;
	}
	fputs(header, out);
	while(fread(&c,1,1,in)>0)
	{
		switch(c)
		{
			case '+':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("++*ptr;\r\n", out);
				break;
			case '-':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("--*ptr;\r\n", out);
				break;
			case '>':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("++ptr;\r\n", out);
				break;
			case '<':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("--ptr;\r\n", out);
				break;
			case ',':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("*ptr=getchar();\r\n", out);
				break;
			case '.':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("putchar(*ptr);\r\n", out);
				break;
			case '[':
				for(i=0;i<brace;i++)
					fputc('\t', out);
				brace++;
				fputs("while(*ptr) {\r\n", out);
				break;
			case ']':
				brace--;
				for(i=0;i<brace;i++)
					fputc('\t', out);
				fputs("}\r\n", out);
				break;
		}
	}
	fputs(footer, out);
	fclose(in);
	fclose(out);
	return 0;
}


Here's a generated hello, world!:
Code: 
#include<stdio.h>
int main(){
	char *ptr;
	char data[30000]={'\0'};
	ptr=data;

	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	putchar(*ptr);
	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	++*ptr;
	putchar(*ptr);
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	putchar(*ptr);
	putchar(*ptr);
	++*ptr;
	++*ptr;
	++*ptr;
	putchar(*ptr);
	while(*ptr) {
		--*ptr;
	}
	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	putchar(*ptr);
	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	putchar(*ptr);
	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	putchar(*ptr);
	++*ptr;
	++*ptr;
	++*ptr;
	putchar(*ptr);
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	putchar(*ptr);
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	--*ptr;
	putchar(*ptr);
	while(*ptr) {
		--*ptr;
	}
	++ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	while(*ptr) {
		--ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++*ptr;
		++ptr;
		--*ptr;
	}
	--ptr;
	++*ptr;
	putchar(*ptr);
	while(*ptr) {
		--*ptr;
	}
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	++*ptr;
	putchar(*ptr);
	return 0;
}
 
M

mono

New member
Here's a BF interpreter I made a long time ago in C...

Code: 
#include <stdio.h>
#include <stdlib.h>

#define ARRAY_SIZE 30000

int main(int argc, char *argv[])
{
	FILE *f;
	int c;
	unsigned char *code;
	int size;
	int i;
	signed char array[ARRAY_SIZE];
	signed char *ptr = array;
	int level = 0;

	if (argc != 2)
	{
		puts("Usage: bfi FILE");
		exit(1);
	}

	f = fopen(argv[1], "r");

	if (f == NULL)
	{
		printf("Unable to open \"%s\".\n", argv[1]);
		exit(1);
	}

	fseek(f, 0, SEEK_END);
	size = ftell(f);
	fseek(f, 0, SEEK_SET);
	code = malloc(size);

	i = 0;

	while ((c = fgetc(f)) != EOF)
	{
		if (c == '>'
		 || c == '<'
		 || c == '+'
		 || c == '-'
		 || c == '.'
		 || c == ','
		 || c == '['
		 || c == ']')
		{
			code[i++] = c;
		}
	}

	size = i;
	fclose(f);

	for (i = 0; i < size; ++i)
	{
		switch (code[i])
		{
			case '>':
				++ptr;
				break;
			case '<':
				--ptr;
				break;
			case '+':
				++*ptr;
				break;
			case '-':
				--*ptr;
				break;
			case '.':
				putchar(*ptr);
				break;
			case ',':
				*ptr = getchar();
				break;
			case '[':
				if (!*ptr)
				{
					++i;

					while (level > 0 || code[i] != ']')
					{
						switch (code[i])
						{
							case '[':
								++level;
								break;
							case ']':
								--level;
								break;
						}

						++i;
					}
				}
				break;
			case ']':
				--i;

				while (level > 0 || code[i] != '[')
				{
					switch (code[i])
					{
						case ']':
							++level;
							break;
						case '[':
							--level;
							break;
					}

					--i;
				}
				--i;
				break;
		}
	}

	free(code);
	return 0;
}
 
Last edited:
hap

hap

New member
Awesome
Code: 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

/* brainduck interpreter */

typedef unsigned char field;

int main(int argc, char *argv[])
{
	FILE* f;
	field d[30000];		/* data array */
	int p=0;		/* the pointer */
	int i=0;		/* program pointer */
	char* prg=NULL;		/* brainduck program */
	int len=0;		/* bf program length */
	
	if ((argc!=2)||((f=fopen(argv[1],"rb"))==NULL)) { printf("couldn't open file!\n"); return 1; }
	else {
		int flen;
		fseek(f,0,SEEK_END); flen=ftell(f); fseek(f,0,SEEK_SET);
		if ((flen==0)||(flen>1000000)||((prg=malloc(flen))==NULL)||(!fread(prg,1,flen,f))) {
			if (prg) free(prg);
			clearerr(f); fclose(f);
			printf("couldn't read file!\n"); return 1;
		}
		else {
			for (i=0;i<flen;i++) {
				switch (prg[i]) {
					case '.': case ',': case '<': case '>': case '-': case '+': case '[': case ']': prg[len++]=prg[i]; break;
					default: break;
				}
			}
			clearerr(f); fclose(f);
			if (len==0) { printf("invalid file!\n"); free(prg); return 1; }
			memset(d,0,sizeof(field)*30000);
		}
	}
	
	for (i=0;;) {
		switch (prg[i]) {
			case '.': putchar(d[p]); break;
			case ',': fflush(stdin); d[p]=getch(); break;
			case '<': p--; break;
			case '>': p++; break;
			case '-': d[p]--; break;
			case '+': d[p]++; break;
			
			/* these are a bit more complicated */
			case '[':
				if (d[p]==0) {
					int loops=0;
					for (;i<len;i++) {
						loops-=(prg[i]==']');
						loops+=(prg[i]=='[');
						if (loops==0) break;
					}
				}
				break;
			case ']':
				if (d[p]) {
					int loops=0;
					for (;i>=0;i--) {
						loops-=(prg[i]=='[');
						loops+=(prg[i]==']');
						if (loops==0) break;
					}
				}
				break;
			
			default: break; /* shouldn't get here */
		}
		if ((i<0)||(i>=len)) { printf("\n\nEND\n"); break; } /* end */
		if ((p<0)||(p>=30000)) { printf("\n\nOB!\n"); break; } /* out of bounds */
		
		i++;
	}
	
	fflush(stdin);
	free(prg);
	return 0;
}







D:\Docs\Programming\brainduck>bf PI16.BF
0
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
3
2
3
8
4


END






D:\Docs\Programming\brainduck>bf mandelbrot.b
AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDEGFFEEEEDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAABBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDEEEFGIIGFFEEEDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEFFFI KHGGGHGEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAABBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEFFGHIMTKLZOGFEEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEFGGHHIKPPKIHGFFEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBBBB
AAAAAAAAAABBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGHIJKS  X KHHGFEEEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBB
AAAAAAAAABBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGQPUVOTY   ZQL[MHFEEEEEEEDDDDDDDCCCCCCCCCCCBBBBBBBBBBBBBB
AAAAAAAABBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEFFFFFGGHJLZ         UKHGFFEEEEEEEEDDDDDCCCCCCCCCCCCBBBBBBBBBBBB
AAAAAAABBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEFFFFFFGGGGHIKP           KHHGGFFFFEEEEEEDDDDDCCCCCCCCCCCBBBBBBBBBBB
AAAAAAABBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEEFGGHIIHHHHHIIIJKMR        VMKJIHHHGFFFFFFGSGEDDDDCCCCCCCCCCCCBBBBBBBBB
AAAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEFFGHK   MKJIJO  N R  X      YUSR PLV LHHHGGHIOJGFEDDDCCCCCCCCCCCCBBBBBBBB
AAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEFFFFGH O    TN S                       NKJKR LLQMNHEEDDDCCCCCCCCCCCCBBBBBBB
AAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDEEEEEEEEEEEEFFFFFGHHIN                                 Q     UMWGEEEDDDCCCCCCCCCCCCBBBBBB
AAAABBCCCCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEFFFFFFGHIJKLOT                                     [JGFFEEEDDCCCCCCCCCCCCCBBBBB
AAAABCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEEFFFFFFGGHYV RQU                                     QMJHGGFEEEDDDCCCCCCCCCCCCCBBBB
AAABCCCCCCCCCCCCCCCCCDDDDDDDEEFJIHFFFFFFFFFFFFFFGGGGGGHIJN                                            JHHGFEEDDDDCCCCCCCCCCCCCBBB
AAABCCCCCCCCCCCDDDDDDDDDDEEEEFFHLKHHGGGGHHMJHGGGGGGHHHIKRR                                           UQ L HFEDDDDCCCCCCCCCCCCCCBB
AABCCCCCCCCDDDDDDDDDDDEEEEEEFFFHKQMRKNJIJLVS JJKIIIIIIJLR                                               YNHFEDDDDDCCCCCCCCCCCCCBB
AABCCCCCDDDDDDDDDDDDEEEEEEEFFGGHIJKOU  O O   PR LLJJJKL                                                OIHFFEDDDDDCCCCCCCCCCCCCCB
AACCCDDDDDDDDDDDDDEEEEEEEEEFGGGHIJMR              RMLMN                                                 NTFEEDDDDDDCCCCCCCCCCCCCB
AACCDDDDDDDDDDDDEEEEEEEEEFGGGHHKONSZ                QPR                                                NJGFEEDDDDDDCCCCCCCCCCCCCC
ABCDDDDDDDDDDDEEEEEFFFFFGIPJIIJKMQ                   VX                                                 HFFEEDDDDDDCCCCCCCCCCCCCC
ACDDDDDDDDDDEFFFFFFFGGGGHIKZOOPPS                                                                      HGFEEEDDDDDDCCCCCCCCCCCCCC
ADEEEEFFFGHIGGGGGGHHHHIJJLNY                                                                        TJHGFFEEEDDDDDDDCCCCCCCCCCCCC
A                                                                                                 PLJHGGFFEEEDDDDDDDCCCCCCCCCCCCC
ADEEEEFFFGHIGGGGGGHHHHIJJLNY                                                                        TJHGFFEEEDDDDDDDCCCCCCCCCCCCC
ACDDDDDDDDDDEFFFFFFFGGGGHIKZOOPPS                                                                      HGFEEEDDDDDDCCCCCCCCCCCCCC
ABCDDDDDDDDDDDEEEEEFFFFFGIPJIIJKMQ                   VX                                                 HFFEEDDDDDDCCCCCCCCCCCCCC
AACCDDDDDDDDDDDDEEEEEEEEEFGGGHHKONSZ                QPR                                                NJGFEEDDDDDDCCCCCCCCCCCCCC
AACCCDDDDDDDDDDDDDEEEEEEEEEFGGGHIJMR              RMLMN                                                 NTFEEDDDDDDCCCCCCCCCCCCCB
AABCCCCCDDDDDDDDDDDDEEEEEEEFFGGHIJKOU  O O   PR LLJJJKL                                                OIHFFEDDDDDCCCCCCCCCCCCCCB
AABCCCCCCCCDDDDDDDDDDDEEEEEEFFFHKQMRKNJIJLVS JJKIIIIIIJLR                                               YNHFEDDDDDCCCCCCCCCCCCCBB
AAABCCCCCCCCCCCDDDDDDDDDDEEEEFFHLKHHGGGGHHMJHGGGGGGHHHIKRR                                           UQ L HFEDDDDCCCCCCCCCCCCCCBB
AAABCCCCCCCCCCCCCCCCCDDDDDDDEEFJIHFFFFFFFFFFFFFFGGGGGGHIJN                                            JHHGFEEDDDDCCCCCCCCCCCCCBBB
AAAABCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEEFFFFFFGGHYV RQU                                     QMJHGGFEEEDDDCCCCCCCCCCCCCBBBB
AAAABBCCCCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEFFFFFFGHIJKLOT                                     [JGFFEEEDDCCCCCCCCCCCCCBBBBB
AAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDEEEEEEEEEEEEFFFFFGHHIN                                 Q     UMWGEEEDDDCCCCCCCCCCCCBBBBBB
AAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEFFFFGH O    TN S                       NKJKR LLQMNHEEDDDCCCCCCCCCCCCBBBBBBB
AAAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEFFGHK   MKJIJO  N R  X      YUSR PLV LHHHGGHIOJGFEDDDCCCCCCCCCCCCBBBBBBBB
AAAAAAABBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEEFGGHIIHHHHHIIIJKMR        VMKJIHHHGFFFFFFGSGEDDDDCCCCCCCCCCCCBBBBBBBBB
AAAAAAABBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEFFFFFFGGGGHIKP           KHHGGFFFFEEEEEEDDDDDCCCCCCCCCCCBBBBBBBBBBB
AAAAAAAABBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEFFFFFGGHJLZ         UKHGFFEEEEEEEEDDDDDCCCCCCCCCCCCBBBBBBBBBBBB
AAAAAAAAABBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGQPUVOTY   ZQL[MHFEEEEEEEDDDDDDDCCCCCCCCCCCBBBBBBBBBBBBBB
AAAAAAAAAABBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGHIJKS  X KHHGFEEEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBB
AAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEFGGHHIKPPKIHGFFEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAABBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEFFGHIMTKLZOGFEEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEFFFI KHGGGHGEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAABBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDEEEFGIIGFFEEEDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBB

Instead of chip8, creating a brainduck interpreter would be a much better/easier to grasp project if someone into emulation wants to start programming their first emulator. Of course the next step would still be chip8 ;p
 
Last edited:
smcd

smcd

Active member
It was designed to be a small/simple turing-complete language, maybe that's why ;) For real headaches, check out other obscure langauges like dis, ook, whitespace, and intercal

Check out http://www.99-bottles-of-beer.net/ for some examples of various langauges
 
O

OmegaDeus

New member
Think that's bad?

Think that's bad?
Check out malbolge... now that's a programming language that could put hair on barbie's chest just by being in the same state as ken when he wrote a program in it.
 
T

Tronix

New member
Hi all. Sorry for up old thread.
Not so long ago I write my brainfk interpreter. I used Virtual Pascal 2.1 to compile, you may try Free Pascal or Delphi if you want. Full sources applicated.

Features:
The interpreter has pre-processor. Pre-processor at step one delete all non-brainfk characters and on step two optimize standart instructions: [-], [+] - set current cell to zero, [>] and [<] - find first rigth or left zero cell and long combination of +++++, -----, >>>>>, <<<<< - run at one cycle.

Also, my interpreter has ANSI esc-codes support, it will be run programs such a
hanoi.bf (with cursor gotoXY and colors).

You may download it from http://tronix286.pochta.ru/soft/brainfk.zip with sources and some demo-programs.

-----
Home page is: http://tronix286.pochta.ru/brainfk/index.htm (in Russian)

PS: Sorry for my bad English.

bf.png
bf2.png
 
You must log in or register to reply here.

Top