deleted file mode 100644
--- a/parser/Makefile
+++ /dev/null
@@ -1,36 +0,0 @@
-CC=gcc
-LD=ld
-YACC=bison -y
-FLEX=flex
-CFLAGS=-Wall -O2 -ansi 
-LDFLAGS=
-INCLUDE=include
-OBJECTS=main.o parser.o lexer.o
-TARGET=parser
-
-.SUFFIXES: .c .yy .ll
-
-.c.o: 
-	$(CC) -c $(CFLAGS) -I$(INCLUDE) $(CONFIG) $<
-
-.yy.c:
-	$(YACC) -d $< -o $@
-
-.ll.c:
-	$(FLEX) -o $@ $<
-
-all: $(TARGET)
-
-
-$(TARGET): $(OBJECTS)
-	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
-
-.PHONY: distclean clean
-
-clean:
-	rm -f *.[oae];
-	rm -f *~;
-
-distclean:
-	make clean
-	rm -f $(TARGET)

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/Makefile
@@ -0,0 +1,46 @@
+CC=gcc
+LD=ld
+YACC=bison -v
+FLEX=flex
+CFLAGS=-Wall -O2 -ansi -D_XOPEN_SOURCE=500
+LDFLAGS=
+INCLUDE=include
+OBJECTS=main.o parser.o lexer.o
+TARGET=mcc
+
+.SUFFIXES: .c .y .l
+
+.c.o:
+	$(CC) -c $(CFLAGS) -I$(INCLUDE) $(CONFIG) $<
+
+.y.c:
+	$(YACC) -d $< -o $@
+
+.l.c:
+	$(FLEX) -o $@ $<
+
+all: $(TARGET)
+
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
+
+.PHONY: distclean clean indent
+
+clean:
+	rm -f *.[oae];
+	rm -f *~;
+
+distclean:
+	make clean
+	rm -f $(TARGET)
+	rm -f parser.h
+	rm -f parser.output
+
+indent:
+	indent *.c *.h
+	eraser *.c *.h
+
+install: $(TARGET)
+	[[ -x ~/bin/ ]] && cp -f $(TARGET) ~/bin
+

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/include/prototypes.h
@@ -0,0 +1,14 @@
+#ifndef PROTOTYPES_H
+#define PROTOTYPES_H
+
+int yyparse();
+int yylex();
+void yyerror(char*);
+int yywrap();
+int count();
+int check_type();
+void comment();
+
+#define YYSTYPE char*
+#endif
+

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/lexer.l
@@ -0,0 +1,151 @@
+%{
+	#include <prototypes.h>
+	#include "parser.h"
+	int column = 0;
+	int c;
+%}
+
+D						[0-9]
+L						[a-zA-Z_]
+H						[a-fA-F0-9]
+E						[Ee][+-]?{D}+
+FS						(f|F|l|L)
+IS						(u|U|l|L)*
+
+%%
+"/*"           			{ comment(); }
+"#include <"			{ c = input(); while ( c != '>') c = input();  }
+"#include \""			{ c = input(); while ( c != '\"') c = input(); }
+
+"auto"					{ count(); return(AUTO); }
+"break"					{ count(); return(BREAK); }
+"case"					{ count(); return(CASE); }
+"char"					{ count(); return(CHAR); }
+"const"					{ count(); return(CONST); }
+"continue"				{ count(); return(CONTINUE); }
+"default"				{ count(); return(DEFAULT); }
+"do"					{ count(); return(DO); }
+"double"				{ count(); return(DOUBLE); }
+"else"					{ count(); return(ELSE); }
+"enum"					{ count(); return(ENUM); }
+"extern"				{ count(); return(EXTERN); }
+"float"					{ count(); return(FLOAT); }
+"for"					{ count(); return(FOR); }
+"goto"					{ count(); return(GOTO); }
+"if"					{ count(); return(IF); }
+"int"					{ count(); return(INT); }
+"long"					{ count(); return(LONG); }
+"register"				{ count(); return(REGISTER); }
+"return"				{ count(); return(RETURN); }
+"short"					{ count(); return(SHORT); }
+"signed"					{ count(); return(SIGNED); }
+"sizeof"				{ count(); return(SIZEOF); }
+"static"				{ count(); return(STATIC); }
+"struct"				{ count(); return(STRUCT); }
+"switch"				{ count(); return(SWITCH); }
+"typedef"				{ count(); return(TYPEDEF); }
+"union"					{ count(); return(UNION); }
+"unsigned"				{ count(); return(UNSIGNED); }
+"void"					{ count(); return(VOID); }
+"volatile"				{ count(); return(VOLATILE); }
+"while"					{ count(); return(WHILE); }
+
+{L}({L}|{D})*			{ count(); return(check_type()); }
+0[xX]{H}+{IS}?			{ count(); return(CONSTANT); }
+0{D}+{IS}?				{ count(); return(CONSTANT); }
+{D}+{IS}?				{ count(); return(CONSTANT); }
+'(\\.|[^\\'])+'			{ count(); return(CONSTANT); }
+
+{D}+{E}{FS}?			{ count(); return(CONSTANT); }
+{D}*"."{D}+({E})?{FS}?	{ count(); return(CONSTANT); }
+{D}+"."{D}*({E})?{FS}?	{ count(); return(CONSTANT); }
+
+\"(\\.|[^\\"])*\"		{ count(); return(STRING_LITERAL); }
+
+">>="					{ count(); return(RIGHT_ASSIGN); }
+"<<="					{ count(); return(LEFT_ASSIGN); }
+"+="					{ count(); return(ADD_ASSIGN); }
+"-="					{ count(); return(SUB_ASSIGN); }
+"*="					{ count(); return(MUL_ASSIGN); }
+"/="					{ count(); return(DIV_ASSIGN); }
+"%="					{ count(); return(MOD_ASSIGN); }
+"&="					{ count(); return(AND_ASSIGN); }
+"^="					{ count(); return(XOR_ASSIGN); }
+"|="					{ count(); return(OR_ASSIGN); }
+">>"					{ count(); return(RIGHT_OP); }
+"<<"					{ count(); return(LEFT_OP); }
+"++"					{ count(); return(INC_OP); }
+"--"					{ count(); return(DEC_OP); }
+"->"					{ count(); return(PTR_OP); }
+"&&"					{ count(); return(AND_OP); }
+"||"					{ count(); return(OR_OP); }
+"<="					{ count(); return(LE_OP); }
+">="					{ count(); return(GE_OP); }
+"=="					{ count(); return(EQ_OP); }
+"!="					{ count(); return(NE_OP); }
+";"						{ count(); return(';'); }
+"{"						{ count(); return('{'); }
+"}"						{ count(); return('}'); }
+","						{ count(); return(','); }
+":"						{ count(); return(':'); }
+"="						{ count(); return('='); }
+"("						{ count(); return('('); }
+")"						{ count(); return(')'); }
+"["						{ count(); return('['); }
+"]"						{ count(); return(']'); }
+"."						{ count(); return('.'); }
+"&"						{ count(); return('&'); }
+"!"						{ count(); return('!'); }
+"~"						{ count(); return('~'); }
+"-"						{ count(); return('-'); }
+"+"						{ count(); return('+'); }
+"*"						{ count(); return('*'); }
+"/"						{ count(); return('/'); }
+"%"						{ count(); return('%'); }
+"<"						{ count(); return('<'); }
+">"						{ count(); return('>'); }
+"^"						{ count(); return('^'); }
+"|"						{ count(); return('|'); }
+"?"						{ count(); return('?'); }
+
+[ \t\v\n\f]				{ count(); }
+.						{ printf ("Unknown Token: %s\n", yytext); }
+%%
+
+int yywrap()
+{
+	/* stop after eof */
+	return 1;
+}
+
+int count()
+{
+	int i;
+
+	for (i = 0; yytext[i] != '\0'; i++)
+		if (yytext[i] == '\n')
+			column = 0;
+		else if (yytext[i] == '\t')
+			column += 4 - (column % 4);
+		else
+			column++;
+
+	return column;
+}
+
+int check_type()
+{
+	return IDENTIFIER;
+}
+
+void comment() 
+{
+	int c;
+
+	c = input(); 
+	do { 
+		while ( c != '*') 
+			c = input();
+		c=input();
+	} while(c != '/');
+}

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/main.c
@@ -0,0 +1,39 @@
+/**
+ * test/demos/parser/c_compiler/main.c
+ * Copyright (C) 2008 Markus Broeker
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <prototypes.h>
+
+extern FILE *yyin;
+
+void usage (char *cmd)
+{
+    printf ("Usage: %s <options> <source files>\n", cmd);
+}
+
+int main (int argc, char **argv)
+{
+    FILE *fp;
+
+    if (argc < 2) {
+        usage (argv[0]);
+        return EXIT_SUCCESS;
+    }
+
+    if ((fp = fopen (argv[1], "r")) == NULL) {
+        perror ("FOPEN");
+        return EXIT_FAILURE;
+    }
+
+    yyin = fp;
+    yyparse ();
+
+    fclose (fp);
+
+    return EXIT_SUCCESS;
+}

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/parser.y
@@ -0,0 +1,435 @@
+%{
+	#include "prototypes.h"
+%}
+%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
+%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
+%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
+%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
+%token XOR_ASSIGN OR_ASSIGN TYPE_NAME
+
+%token TYPEDEF EXTERN STATIC AUTO REGISTER
+%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
+%token STRUCT UNION ENUM ELIPSIS RANGE
+
+%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
+
+%start file
+%%
+
+primary_expr
+	: identifier
+	| CONSTANT
+	| STRING_LITERAL
+	| '(' expr ')'
+	;
+
+postfix_expr
+	: primary_expr
+	| postfix_expr '[' expr ']'
+	| postfix_expr '(' ')'
+	| postfix_expr '(' argument_expr_list ')'
+	| postfix_expr '.' identifier
+	| postfix_expr PTR_OP identifier
+	| postfix_expr INC_OP
+	| postfix_expr DEC_OP
+	;
+
+argument_expr_list
+	: assignment_expr
+	| argument_expr_list ',' assignment_expr
+	;
+
+unary_expr
+	: postfix_expr
+	| INC_OP unary_expr
+	| DEC_OP unary_expr
+	| unary_operator cast_expr
+	| SIZEOF unary_expr
+	| SIZEOF '(' type_name ')'
+	;
+
+unary_operator
+	: '&'
+	| '*'
+	| '+'
+	| '-'
+	| '~'
+	| '!'
+	;
+
+cast_expr
+	: unary_expr
+	| '(' type_name ')' cast_expr
+	;
+
+multiplicative_expr
+	: cast_expr
+	| multiplicative_expr '*' cast_expr
+	| multiplicative_expr '/' cast_expr
+	| multiplicative_expr '%' cast_expr
+	;
+
+additive_expr
+	: multiplicative_expr
+	| additive_expr '+' multiplicative_expr
+	| additive_expr '-' multiplicative_expr
+	;
+
+shift_expr
+	: additive_expr
+	| shift_expr LEFT_OP additive_expr
+	| shift_expr RIGHT_OP additive_expr
+	;
+
+relational_expr
+	: shift_expr
+	| relational_expr '<' shift_expr
+	| relational_expr '>' shift_expr
+	| relational_expr LE_OP shift_expr
+	| relational_expr GE_OP shift_expr
+	;
+
+equality_expr
+	: relational_expr
+	| equality_expr EQ_OP relational_expr
+	| equality_expr NE_OP relational_expr
+	;
+
+and_expr
+	: equality_expr
+	| and_expr '&' equality_expr
+	;
+
+exclusive_or_expr
+	: and_expr
+	| exclusive_or_expr '^' and_expr
+	;
+
+inclusive_or_expr
+	: exclusive_or_expr
+	| inclusive_or_expr '|' exclusive_or_expr
+	;
+
+logical_and_expr
+	: inclusive_or_expr
+	| logical_and_expr AND_OP inclusive_or_expr
+	;
+
+logical_or_expr
+	: logical_and_expr
+	| logical_or_expr OR_OP logical_and_expr
+	;
+
+conditional_expr
+	: logical_or_expr
+	| logical_or_expr '?' logical_or_expr ':' conditional_expr
+	;
+
+assignment_expr
+	: conditional_expr
+	| unary_expr assignment_operator assignment_expr
+	;
+
+assignment_operator
+	: '='
+	| MUL_ASSIGN
+	| DIV_ASSIGN
+	| MOD_ASSIGN
+	| ADD_ASSIGN
+	| SUB_ASSIGN
+	| LEFT_ASSIGN
+	| RIGHT_ASSIGN
+	| AND_ASSIGN
+	| XOR_ASSIGN
+	| OR_ASSIGN
+	;
+
+expr
+	: assignment_expr
+	| expr ',' assignment_expr
+	;
+
+constant_expr
+	: conditional_expr
+	;
+
+declaration
+	: declaration_specifiers ';'
+	| declaration_specifiers init_declarator_list ';'
+	;
+
+declaration_specifiers
+	: storage_class_specifier
+	| storage_class_specifier declaration_specifiers
+	| type_specifier
+	| type_specifier declaration_specifiers
+	;
+
+init_declarator_list
+	: init_declarator
+	| init_declarator_list ',' init_declarator
+	;
+
+init_declarator
+	: declarator
+	| declarator '=' initializer
+	;
+
+storage_class_specifier
+	: TYPEDEF
+	| EXTERN
+	| STATIC
+	| AUTO
+	| REGISTER
+	;
+
+type_specifier
+	: CHAR
+	| SHORT
+	| INT
+	| LONG
+	| SIGNED
+	| UNSIGNED
+	| FLOAT
+	| DOUBLE
+	| CONST
+	| VOLATILE
+	| VOID
+	| struct_or_union_specifier
+	| enum_specifier
+	| TYPE_NAME
+	;
+
+struct_or_union_specifier
+	: struct_or_union identifier '{' struct_declaration_list '}'
+	| struct_or_union '{' struct_declaration_list '}'
+	| struct_or_union identifier
+	;
+
+struct_or_union
+	: STRUCT
+	| UNION
+	;
+
+struct_declaration_list
+	: struct_declaration
+	| struct_declaration_list struct_declaration
+	;
+
+struct_declaration
+	: type_specifier_list struct_declarator_list ';'
+	;
+
+struct_declarator_list
+	: struct_declarator
+	| struct_declarator_list ',' struct_declarator
+	;
+
+struct_declarator
+	: declarator
+	| ':' constant_expr
+	| declarator ':' constant_expr
+	;
+
+enum_specifier
+	: ENUM '{' enumerator_list '}'
+	| ENUM identifier '{' enumerator_list '}'
+	| ENUM identifier
+	;
+
+enumerator_list
+	: enumerator
+	| enumerator_list ',' enumerator
+	;
+
+enumerator
+	: identifier
+	| identifier '=' constant_expr
+	;
+
+declarator
+	: declarator2
+	| pointer declarator2
+	;
+
+declarator2
+	: identifier
+	| '(' declarator ')'
+	| declarator2 '[' ']'
+	| declarator2 '[' constant_expr ']'
+	| declarator2 '(' ')'
+	| declarator2 '(' parameter_type_list ')'
+	| declarator2 '(' parameter_identifier_list ')'
+	;
+
+pointer
+	: '*'
+	| '*' type_specifier_list
+	| '*' pointer
+	| '*' type_specifier_list pointer
+	;
+
+type_specifier_list
+	: type_specifier
+	| type_specifier_list type_specifier
+	;
+
+parameter_identifier_list
+	: identifier_list
+	| identifier_list ',' ELIPSIS
+	;
+
+identifier_list
+	: identifier
+	| identifier_list ',' identifier
+	;
+
+parameter_type_list
+	: parameter_list
+	| parameter_list ',' ELIPSIS
+	;
+
+parameter_list
+	: parameter_declaration
+	| parameter_list ',' parameter_declaration
+	;
+
+parameter_declaration
+	: type_specifier_list declarator
+	| type_name
+	;
+
+type_name
+	: type_specifier_list
+	| type_specifier_list abstract_declarator
+	;
+
+abstract_declarator
+	: pointer
+	| abstract_declarator2
+	| pointer abstract_declarator2
+	;
+
+abstract_declarator2
+	: '(' abstract_declarator ')'
+	| '[' ']'
+	| '[' constant_expr ']'
+	| abstract_declarator2 '[' ']'
+	| abstract_declarator2 '[' constant_expr ']'
+	| '(' ')'
+	| '(' parameter_type_list ')'
+	| abstract_declarator2 '(' ')'
+	| abstract_declarator2 '(' parameter_type_list ')'
+	;
+
+initializer
+	: assignment_expr
+	| '{' initializer_list '}'
+	| '{' initializer_list ',' '}'
+	;
+
+initializer_list
+	: initializer
+	| initializer_list ',' initializer
+	;
+
+statement
+	: labeled_statement
+	| compound_statement
+	| expression_statement
+	| selection_statement
+	| iteration_statement
+	| jump_statement
+	;
+
+labeled_statement
+	: identifier ':' statement
+	| CASE constant_expr ':' statement
+	| DEFAULT ':' statement
+	;
+
+compound_statement
+	: '{' '}'
+	| '{' statement_list '}'
+	| '{' declaration_list '}'
+	| '{' declaration_list statement_list '}'
+	;
+
+declaration_list
+	: declaration
+	| declaration_list declaration
+	;
+
+statement_list
+	: statement
+	| statement_list statement
+	;
+
+expression_statement
+	: ';'
+	| expr ';'
+	;
+
+selection_statement
+	: IF '(' expr ')' statement
+	| IF '(' expr ')' statement ELSE statement
+	| SWITCH '(' expr ')' statement
+	;
+
+iteration_statement
+	: WHILE '(' expr ')' statement
+	| DO statement WHILE '(' expr ')' ';'
+	| FOR '(' ';' ';' ')' statement
+	| FOR '(' ';' ';' expr ')' statement
+	| FOR '(' ';' expr ';' ')' statement
+	| FOR '(' ';' expr ';' expr ')' statement
+	| FOR '(' expr ';' ';' ')' statement
+	| FOR '(' expr ';' ';' expr ')' statement
+	| FOR '(' expr ';' expr ';' ')' statement
+	| FOR '(' expr ';' expr ';' expr ')' statement
+	;
+
+jump_statement
+	: GOTO identifier ';'
+	| CONTINUE ';'
+	| BREAK ';'
+	| RETURN ';'
+	| RETURN expr ';'
+	;
+
+file
+	: external_definition
+	| file external_definition
+	;
+
+external_definition
+	: function_definition
+	| declaration
+	;
+
+function_definition
+	: declarator function_body
+	| declaration_specifiers declarator function_body
+	;
+
+function_body
+	: compound_statement
+	| declaration_list compound_statement
+	;
+
+identifier
+	: IDENTIFIER
+	;
+%%
+
+#include <stdio.h>
+
+extern YYSTYPE yytext;
+extern int column;
+
+void yyerror(char *s)
+{
+	fflush(stdout);
+	printf("[%4d]: %s\n", column, yytext);
+	printf("\n%*s\n%*s\n", column, "^", column, s);
+}

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/test/error.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv)
+{
+	FILE *fp;
+
+	printf ("Hello, world\n")
+
+	return EXIT_SUCCESS;
+}

new file mode 100644
--- /dev/null
+++ b/parser/c_compiler/test/test.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv)
+{
+	FILE *fp;
+
+	printf ("Hello, world\n");
+
+	return EXIT_SUCCESS;
+}

new file mode 100644
--- /dev/null
+++ b/parser/calc/Makefile
@@ -0,0 +1,36 @@
+CC=gcc
+LD=ld
+YACC=bison -y
+FLEX=flex
+CFLAGS=-Wall -O2 -ansi 
+LDFLAGS=
+INCLUDE=include
+OBJECTS=main.o parser.o lexer.o
+TARGET=parser
+
+.SUFFIXES: .c .yy .ll
+
+.c.o: 
+	$(CC) -c $(CFLAGS) -I$(INCLUDE) $(CONFIG) $<
+
+.yy.c:
+	$(YACC) -d $< -o $@
+
+.ll.c:
+	$(FLEX) -o $@ $<
+
+all: $(TARGET)
+
+
+$(TARGET): $(OBJECTS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) -o $@
+
+.PHONY: distclean clean
+
+clean:
+	rm -f *.[oae];
+	rm -f *~;
+
+distclean:
+	make clean
+	rm -f $(TARGET)

new file mode 100644
--- /dev/null
+++ b/parser/calc/lexer.l
@@ -0,0 +1,23 @@
+/**
+ * test/demos/parser/lexer.ll
+ * Copyright (C) 2008 Markus Broeker
+ */
+
+%{
+	#include <stdio.h>
+	#include "parser.h"
+%}
+
+%%
+
+[0-9]+			{ yylval = atoi(yytext); return DIGIT;    }
+[a-zA-Z]		{ yylval = yytext[0]; return LETTER;      }
+"+"			return PLUS;	     
+"-"			return MINUS;       
+"*"			return MUL;         
+"/"			return DIV;       
+"("|")"|"="		return yytext[0]; 
+[ \t]+			;
+\n			return yytext[0];
+.			printf("FEHLER: %s\n", yytext);
+%%

new file mode 100644
--- /dev/null
+++ b/parser/calc/main.c
@@ -0,0 +1,14 @@
+/**
+ * test/demos/parser/main.c
+ * Copyright (C) 2008 Markus Broeker
+ */
+
+#include <stdio.h>
+
+extern int yyparse ();
+
+int main (int argc, char **argv)
+{
+    yyparse ();
+    return 0;
+}

new file mode 100644
--- /dev/null
+++ b/parser/calc/parser.y
@@ -0,0 +1,84 @@
+/**
+ * test/demos/parser/parser.yy
+ * Copyright (C) 2008 Markus Broeker
+ */
+
+%{
+   #include <stdio.h>
+   #include <ctype.h>
+
+   int regs[26]; 
+   int base;
+	
+   int yyerror();
+   int yylex();
+%}
+
+%start list
+%token DIGIT LETTER
+%left MINUS PLUS MUL DIV
+%left UMINUS
+%%
+
+list : /* empty */ 
+	| list stat '\n' 
+	| list error '\n' { yyerrok; };
+
+stat : 
+	expr { (void) printf( "RESULT: %d\n", $1 ); } 
+	| LETTER '=' expr { regs[$1] = $3; }
+	;
+
+   expr      :  '(' expr ')'
+             {
+                   $$ = $2;
+             }
+             |  expr PLUS expr
+             {
+                   $$ = $1 + $3;
+             }
+             |  expr MINUS expr
+             {
+                   $$ = $1 - $3;
+             }
+             |  expr MUL expr
+             { 
+                   $$ = $1 * $3;
+             }
+             |  expr DIV expr
+             {
+                   $$ = $1 / $3;
+             }
+             |  MINUS expr  %prec UMINUS
+             {
+                   $$ = -$2;
+             }
+             |  LETTER
+             {
+                   $$ = regs[$1];
+             }
+             |  number
+             ;
+
+   number    :   DIGIT
+             {
+                    $$ = $1; base = ($1==0) ? 8 : 10;
+             }
+             |   number DIGIT
+             {
+                    $$ = base * $1 + $2;
+             }
+             ;
+   
+%%
+
+int yyerror() 
+{
+	printf("ERROR\n");
+	return 0;
+}
+
+int yywrap() 
+{
+	return 1;
+}

deleted file mode 100644
--- a/parser/lexer.ll
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * test/demos/parser/lexer.ll
- * Copyright (C) 2008 Markus Broeker
- */
-
-%{
-	#include <stdio.h>
-	#include "parser.h"
-%}
-
-%%
-
-[0-9]+			{ yylval = atoi(yytext); return DIGIT;    }
-[a-zA-Z]		{ yylval = yytext[0]; return LETTER;      }
-"+"			return PLUS;	     
-"-"			return MINUS;       
-"*"			return MUL;         
-"/"			return DIV;       
-"("|")"|"="		return yytext[0]; 
-[ \t]+			;
-\n			return yytext[0];
-.			printf("FEHLER: %s\n", yytext);
-%%

deleted file mode 100644
--- a/parser/main.c
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * test/demos/parser/main.c
- * Copyright (C) 2008 Markus Broeker
- */
-
-#include <stdio.h>
-
-extern int yyparse ();
-
-int main (int argc, char **argv)
-{
-    yyparse ();
-    return 0;
-}

deleted file mode 100644
--- a/parser/parser.yy
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * test/demos/parser/parser.yy
- * Copyright (C) 2008 Markus Broeker
- */
-
-%{
-   #include <stdio.h>
-   #include <ctype.h>
-
-   int regs[26]; 
-   int base;
-	
-   int yyerror();
-   int yylex();
-%}
-
-%start list
-%token DIGIT LETTER
-%left MINUS PLUS MUL DIV
-%left UMINUS
-%%
-
-list : /* empty */ 
-	| list stat '\n' 
-	| list error '\n' { yyerrok; };
-
-stat : 
-	expr { (void) printf( "RESULT: %d\n", $1 ); } 
-	| LETTER '=' expr { regs[$1] = $3; }
-	;
-
-   expr      :  '(' expr ')'
-             {
-                   $$ = $2;
-             }
-             |  expr PLUS expr
-             {
-                   $$ = $1 + $3;
-             }
-             |  expr MINUS expr
-             {
-                   $$ = $1 - $3;
-             }
-             |  expr MUL expr
-             { 
-                   $$ = $1 * $3;
-             }
-             |  expr DIV expr
-             {
-                   $$ = $1 / $3;
-             }
-             |  MINUS expr  %prec UMINUS
-             {
-                   $$ = -$2;
-             }
-             |  LETTER
-             {
-                   $$ = regs[$1];
-             }
-             |  number
-             ;
-
-   number    :   DIGIT
-             {
-                    $$ = $1; base = ($1==0) ? 8 : 10;
-             }
-             |   number DIGIT
-             {
-                    $$ = base * $1 + $2;
-             }
-             ;
-   
-%%
-
-int yyerror() 
-{
-	printf("ERROR\n");
-	return 0;
-}
-
-int yywrap() 
-{
-	return 1;
-}