diff --git a/src/ast/ast.c b/src/ast/ast.c
index 69d48fb..a554b35 100644
--- a/src/ast/ast.c
+++ b/src/ast/ast.c
@@ -70,11 +70,15 @@ void AST_init() {
   lookup_table[AST_Box] = "box";
   lookup_table[AST_Fun] = "fun";
 
+  lookup_table[AST_Call] = "funcall";
   lookup_table[AST_Typecast] = "cast";
   lookup_table[AST_Transmute] = "as";
   lookup_table[AST_Condition] = "condition";
   lookup_table[AST_List] = "list";
   lookup_table[AST_Type] = "type";
+  lookup_table[AST_Negate] = "-";
+  lookup_table[AST_Parameter] = "parameter";
+  lookup_table[AST_ParamDecl] = "parameter-declaration";
 }
 
 const char* AST_node_to_string(const struct AST_Node_t* node) {
@@ -90,11 +94,11 @@ const char* AST_node_to_string(const struct AST_Node_t* node) {
     case AST_Ident:
     case AST_Macro:
     case AST_Import:
-    case AST_Call:
     case AST_Storage:
     case AST_Typekind:
     case AST_Sign:
     case AST_Scale:
+    case AST_Qualifyier:
       string = node->value;
       break;
     default:
diff --git a/src/ast/ast.h b/src/ast/ast.h
index 430f284..e42e0c9 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -59,14 +59,18 @@ enum AST_SyntaxElement_t {
   AST_Fun,
   AST_Import,
   // amount of variants
-  // in this enum
-  AST_ELEMENT_COUNT,
+  // in this enums
   AST_List,
   AST_Storage,
   AST_Type,
   AST_Typekind,
   AST_Sign,
-  AST_Scale
+  AST_Scale,
+  AST_Negate,
+  AST_Parameter,
+  AST_Qualifyier,
+  AST_ParamDecl,
+  AST_ELEMENT_COUNT
 };
 
 /**
diff --git a/src/yacc/parser.y b/src/yacc/parser.y
index ce25bc4..e654eff 100644
--- a/src/yacc/parser.y
+++ b/src/yacc/parser.y
@@ -1,4 +1,4 @@
-%{
+%code requires {
     #include <sys/log.h>
     #include <ast/ast.h>
     extern int yylineno;
@@ -6,39 +6,56 @@
     int yyerror(char*);
 
     extern int yylex();
-%}
+
+    
+}
 
 %union {
     char *string;
+    AST_NODE_PTR node_ptr;
 }
 
-%type <AST_NODE_PTR> expr
-%type <AST_NODE_PTR> operation
-%type <AST_NODE_PTR> boxaccess
-%type <AST_NODE_PTR> boxselfaccess
-%type <AST_NODE_PTR> statement
-%type <AST_NODE_PTR> statementlist
-%type <AST_NODE_PTR> assign
-%type <AST_NODE_PTR> oparith
-%type <AST_NODE_PTR> decl
-%type <AST_NODE_PTR> definition
-%type <AST_NODE_PTR> while
-%type <AST_NODE_PTR> branch
-%type <AST_NODE_PTR> funcall
-%type <AST_NODE_PTR> boxcall
-%type <AST_NODE_PTR> branchelseifs
-%type <AST_NODE_PTR> branchelse
-%type <AST_NODE_PTR> branchelseif
-%type <AST_NODE_PTR> branchif
-%type <AST_NODE_PTR> type
-%type <AST_NODE_PTR> identlist
-%type <AST_NODE_PTR> storagequalifier
-%type <AST_NODE_PTR> typekind
-%type <AST_NODE_PTR> scale
-%type <AST_NODE_PTR> sign
-%type <AST_NODE_PTR> oplogic
-%type <AST_NODE_PTR> opbool
-%type <AST_NODE_PTR> opbit
+%type <node_ptr> operation
+%type <node_ptr> boxaccess
+%type <node_ptr> boxselfaccess
+%type <node_ptr> statement
+%type <node_ptr> statementlist
+%type <node_ptr> assign
+%type <node_ptr> oparith
+%type <node_ptr> decl
+%type <node_ptr> definition
+%type <node_ptr> while
+%type <node_ptr> branch
+%type <node_ptr> funcall
+%type <node_ptr> boxcall
+%type <node_ptr> branchelseifs
+%type <node_ptr> branchelse
+%type <node_ptr> branchelseif
+%type <node_ptr> branchif
+%type <node_ptr> type
+%type <node_ptr> identlist
+%type <node_ptr> storagequalifier
+%type <node_ptr> typekind
+%type <node_ptr> scale
+%type <node_ptr> sign
+%type <node_ptr> expr
+%type <node_ptr> oplogic
+%type <node_ptr> opbool
+%type <node_ptr> opbit
+%type <node_ptr> moduleimport
+%type <node_ptr> programbody
+%type <node_ptr> fundef
+%type <node_ptr> box
+%type <node_ptr> typedef
+%type <node_ptr> exprlist
+%type <node_ptr> argumentlist
+%type <node_ptr> paramlist
+%type <node_ptr> params
+%type <node_ptr> IOqualifyier
+%type <node_ptr> paramdecl 
+%type <node_ptr> boxbody
+%type <node_ptr> boxcontent
+%type <node_ptr> program
 
 
 %token KeyInt
@@ -94,78 +111,172 @@
 %left OpBitand OpBitor OpBitxor OpBitnot
 
 %%
-program: program programbody
+program: program programbody {AST_push_node($1, $2);
+                              FILE *file = fopen("test.txt", "w");
+                              AST_fprint_graphviz(file, $1);
+                              fclose(file);}
        | programbody {AST_NODE_PTR program = AST_new_node(AST_Module, NULL);
-                      AST_fprint_graphviz(stdout, program);  };
+                      AST_push_node(program, $1);
+                      FILE *file = fopen("test.txt", "w");
+                      AST_fprint_graphviz(file, program);
+                      fclose(file); };
 
-programbody: moduleimport
-       | fundef
-       | box
-       | definition
-       | decl
-       | typedef;
+programbody: moduleimport {$$ = $1;}
+       | fundef{$$ = $1;}
+       | box{$$ = $1;}
+       | definition{$$ = $1;}
+       | decl{$$ = $1;}
+       | typedef{$$ = $1;};
 
 
 
-expr: ValFloat {$$ = AST_new_node{AST_Float, $1};}
-    | ValInt    {$$ = AST_new_node{AST_Int, $1};}
-    | ValMultistr   {$$ = AST_new_node{AST_String, $1};}
-    | ValStr    {$$ = AST_new_node{AST_String, $1};}
-    | Ident     {$$ = AST_new_node{AST_Ident, $1};}
+expr: ValFloat {$$ = AST_new_node(AST_Float, $1);}
+    | ValInt    {$$ = AST_new_node(AST_Int, $1);}
+    | ValMultistr   {$$ = AST_new_node(AST_String, $1);}
+    | ValStr    {$$ = AST_new_node(AST_String, $1);}
+    | Ident     {$$ = AST_new_node(AST_Ident, $1);}
     | operation {$$ = $1;}
     | boxaccess {$$ = $1;}
     | boxselfaccess{$$ = $1;};
 
-exprlist: expr ',' exprlist
-        | expr ;
+exprlist: expr ',' exprlist {AST_push_node($3, $1);
+                             $$ = $3;}
+        | expr {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                AST_push_node(list, $1);
+                $$ = list;};
 
-argumentlist: argumentlist '(' exprlist ')'
-    | ;
+argumentlist: argumentlist '(' exprlist ')' {AST_push_node($1, $3);
+                                             $$ = $1;}
+    | '(' exprlist ')'{AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                AST_push_node(list, $2);
+                $$ = list;};
 
 
-fundef: KeyFun Ident paramlist '{' statementlist'}' { DEBUG("Function");};
+fundef: KeyFun Ident paramlist '{' statementlist'}' {AST_NODE_PTR fun = AST_new_node(AST_Fun, NULL);
+                                                     AST_NODE_PTR ident = AST_new_node(AST_Ident, $2);
+                                                     AST_push_node(fun, ident);
+                                                     AST_push_node(fun, $3);
+                                                     AST_push_node(fun, $5);
+                                                     $$ = fun;
+                                                            DEBUG("Function");};
 
-paramlist: paramlist '(' params ')'
-         |  paramlist '(' ')'
-         | '(' params ')'
-         | '(' ')';
+paramlist: paramlist '(' params ')' {AST_push_node($1, $3);
+                                     $$ = $1;}
+         |  paramlist '(' ')'{$$ = $1;}
+         | '(' params ')' {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                           AST_push_node(list, $2);}
+         | '(' ')' {$$ = AST_new_node(AST_List, NULL);};
 
-params: IOqualifyier paramdecl ',' params
-      | IOqualifyier paramdecl;
+params: IOqualifyier paramdecl ',' params {AST_NODE_PTR parameter = AST_new_node(AST_Parameter, NULL);
+                                AST_push_node(parameter, $1);
+                                AST_push_node(parameter, $2);
+                                AST_push_node($4, parameter);
+                                $$ = $4;}
+      | IOqualifyier paramdecl {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                                AST_NODE_PTR parameter = AST_new_node(AST_Parameter, NULL);
+                                AST_push_node(parameter, $1);
+                                AST_push_node(parameter, $2);
+                                AST_push_node(list, parameter);
+                                $$ = list;};
 
-IOqualifyier: KeyIn
-            | KeyOut
-            | KeyIn KeyOut
-            | KeyOut KeyIn
-            | ;
+IOqualifyier: KeyIn { AST_NODE_PTR in = AST_new_node(AST_Qualifyier, "in");
+                      AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                      AST_push_node(list, in);
+                      $$ = list;}
+            | KeyOut{ AST_NODE_PTR out = AST_new_node(AST_Qualifyier, "out");
+                      AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                      AST_push_node(list, out);
+                      $$ = list;}
+            | KeyIn KeyOut{ AST_NODE_PTR in = AST_new_node(AST_Qualifyier, "in");
+                      AST_NODE_PTR out = AST_new_node(AST_Qualifyier, "out");
+                      AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                      AST_push_node(list, in);
+                      AST_push_node(list, out);
+                      $$ = list;}
+            | KeyOut KeyIn{ AST_NODE_PTR in = AST_new_node(AST_Qualifyier, "in");
+                      AST_NODE_PTR out = AST_new_node(AST_Qualifyier, "out");
+                      AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                      AST_push_node(list, in);
+                      AST_push_node(list, out);
+                      $$ = list;}
+            | {$$ = AST_new_node(AST_List, NULL);};
 
-paramdecl: type ':' Ident { DEBUG("Param-Declaration"); };
+paramdecl: type ':' Ident { AST_NODE_PTR paramdecl = AST_new_node(AST_ParamDecl, NULL);
+                            AST_push_node(paramdecl, $1);
+                            AST_NODE_PTR ident = AST_new_node(AST_Ident, $3);
+                            AST_push_node(paramdecl, ident);
+                            $$ = paramdecl;
+    DEBUG("Param-Declaration"); };
 
-box: KeyType KeyBox ':' Ident '{' boxbody '}' { DEBUG("Box"); }
-   | KeyType KeyBox ':' Ident '{' '}';
+box: KeyType KeyBox ':' Ident '{' boxbody '}' {AST_NODE_PTR box = AST_new_node(AST_Box, NULL);
+                                       AST_NODE_PTR ident = AST_new_node(AST_Ident, $4);
+                                       AST_push_node(box, ident);
+                                       AST_push_node(box, $6);
+                                       $$ = box; 
+    DEBUG("Box"); }
+   | KeyType KeyBox ':' Ident '{' '}' {AST_NODE_PTR box = AST_new_node(AST_Box, NULL);
+                                       AST_NODE_PTR ident = AST_new_node(AST_Ident, $4);
+                                       AST_push_node(box, ident);
+                                       $$ = box;};
 
-boxbody: boxbody boxcontent
-       | boxcontent;
+boxbody: boxbody boxcontent {AST_push_node($1, $2);
+                             $$ = $1;}
+       | boxcontent {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                     AST_push_node(list, $1);
+                     $$ = list;};
 
-boxcontent: decl { DEBUG("Box decl Content"); }
-          | definition { DEBUG("Box def Content"); }
-          | fundef { DEBUG("Box fun Content"); };
+boxcontent: decl { $$ = $1;DEBUG("Box decl Content"); }
+          | definition { $$ = $1;DEBUG("Box def Content"); }
+          | fundef { $$ = $1;DEBUG("Box fun Content"); };
 
-boxselfaccess: KeySelf '.' Ident {$$ = AST_new_node(AST_Call, NULL);}
-             | KeySelf '.' boxaccess {$$ = AST_new_node(AST_Call, NULL);};
+boxselfaccess: KeySelf '.' Ident {AST_NODE_PTR boxselfaccess = AST_new_node(AST_List, NULL);
+                                      AST_NODE_PTR self = AST_new_node(AST_Ident, "self");
+                                      AST_push_node(boxselfaccess, self);
+                                      AST_NODE_PTR identlist = AST_new_node(AST_List, NULL);
+                                      AST_NODE_PTR ident = AST_new_node(AST_Ident, $3);
+                                      AST_push_node(identlist,ident);
+                                      AST_push_node(boxselfaccess, identlist);
+                                      $$ = boxselfaccess;}
+             | KeySelf '.' boxaccess {AST_NODE_PTR boxselfaccess = AST_new_node(AST_List, NULL);
+                                      AST_NODE_PTR self = AST_new_node(AST_Ident, "self");
+                                      AST_push_node(boxselfaccess, self);
+                                      AST_push_node(boxselfaccess, $3);
+                                      $$ = boxselfaccess;};
 
-boxaccess: Ident '.' Ident {$$ = AST_new_node(AST_Call, NULL);}
-         | Ident '.' boxaccess {$$ = AST_new_node(AST_Ident, $1);};
+boxaccess: Ident '.' Ident {AST_NODE_PTR identlist = AST_new_node(AST_List, NULL);
+                                      AST_NODE_PTR ident1 = AST_new_node(AST_Ident, $1);
+                                      AST_NODE_PTR ident2 = AST_new_node(AST_Ident, $3);
+                                      AST_push_node(identlist,ident1);
+                                      AST_push_node(identlist,ident2);
+                                      $$ = identlist;}
+         | Ident '.' boxaccess {AST_NODE_PTR ident = AST_new_node(AST_Ident, $1);
+                                      AST_push_node($3,ident);
+                                      $$ = $3;};
 
-boxcall: boxaccess argumentlist
-       | boxselfaccess argumentlist;
+boxcall: boxaccess argumentlist {AST_NODE_PTR boxcall = AST_new_node(AST_Call, NULL);
+                                 AST_push_node(boxcall, $1);
+                                 AST_push_node(boxcall, $2);
+                                 $$ = boxcall;}
+       | boxselfaccess argumentlist {AST_NODE_PTR boxcall = AST_new_node(AST_Call, NULL);
+                                 AST_push_node(boxcall, $1);
+                                 AST_push_node(boxcall, $2);
+                                 $$ = boxcall;};
 
-funcall: Ident argumentlist { DEBUG("Function call"); };
+funcall: Ident argumentlist {AST_NODE_PTR funcall = AST_new_node(AST_Call, NULL);
+                             AST_NODE_PTR ident = AST_new_node(AST_Ident, $1);
+                             AST_push_node(funcall, ident);
+                             AST_push_node(funcall, $2);
+                             $$ = funcall;
+                             DEBUG("Function call"); };
 
-moduleimport: KeyImport ValStr { DEBUG("Module-Import"); };
+moduleimport: KeyImport ValStr {$$ = AST_new_node(AST_Import, $2);
+                                 DEBUG("Module-Import"); };
 
-statementlist: statement statementlist
-    | statement {$$ = $1;};
+statementlist: statementlist statement  {AST_push_node($1, $2);
+                                        $$ = $1;}
+    | statement {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
+                 AST_push_node(list, $1);
+        $$ = list;};
 
 statement: assign {$$ = $1;}
         | decl {$$ = $1;}
@@ -190,14 +301,20 @@ branch: branchif branchelseifs {AST_NODE_PTR branch = AST_new_node(AST_Stmt, NUL
                                 AST_push_node(branch, $2);
                                 $$ = branch;}
 
-    | branchif branchelseifs branchelse { AST_NODE_PTR branch = AST_new_node(AST_IF, NULL);};
+    | branchif branchelseifs branchelse { AST_NODE_PTR branch = AST_new_node(AST_Stmt, NULL);
+                                          AST_push_node(branch, $1);
+                                          AST_push_node(branch, $2);
+                                          AST_push_node(branch, $3);
+                                          $$ = branch;};
 
 while: KeyWhile expr '{' statementlist '}' { DEBUG("while"); };
 
-identlist: Ident ',' identlist {AST_push_node($3, $1);
+identlist: Ident ',' identlist {AST_NODE_PTR ident = AST_new_node(AST_Ident, $1);
+                                AST_push_node($3, ident);
                                 $$ = $3;}
         | Ident {AST_NODE_PTR list = AST_new_node(AST_List, NULL);
-                 AST_push_node(list, $1);
+                 AST_NODE_PTR ident = AST_new_node(AST_Ident, $1);
+                 AST_push_node(list, ident);
                  $$ = list;};               
 
 decl: type ':' identlist {AST_NODE_PTR decl = AST_new_node(AST_Decl, NULL);
@@ -211,7 +328,11 @@ decl: type ':' identlist {AST_NODE_PTR decl = AST_new_node(AST_Decl, NULL);
                                            $$ = decl;}
 
 
-definition: decl '=' expr { DEBUG("Definition"); };
+definition: decl '=' expr { AST_NODE_PTR def = AST_new_node(AST_Def, NULL);
+                            AST_push_node(def, $1);
+                            AST_push_node(def, $3);
+                            $$ = def;
+    DEBUG("Definition"); };
 
 storagequalifier: KeyGlobal {$$ = AST_new_node(AST_Storage, "global");}
         | KeyStatic {$$ = AST_new_node(AST_Storage, "static");}
@@ -229,7 +350,11 @@ assign: Ident '=' expr { AST_NODE_PTR assign = AST_new_node(AST_Assign, NULL);
 sign: KeySigned {$$ = AST_new_node(AST_Sign, "signed");}
     | KeyUnsigned{$$ = AST_new_node(AST_Sign, "unsigned");};
 
-typedef: KeyType type':' Ident;
+typedef: KeyType type':' Ident {AST_NODE_PTR typeDef = AST_new_node(AST_Typedef, NULL);
+                                AST_push_node(typeDef, $2);
+                                AST_NODE_PTR ident = AST_new_node(AST_Ident, $4);
+                                AST_push_node(typeDef, ident);
+                                $$ = typeDef;};
 
 scale: scale KeyShort {AST_NODE_PTR shortnode = AST_new_node(AST_Scale, "short");
                        AST_push_node($1, shortnode);
@@ -264,18 +389,18 @@ typekind: Ident {$$ = AST_new_node(AST_Typekind, $1);}
     | KeyInt {$$ = AST_new_node(AST_Typekind, "int");}
     | KeyFloat {$$ = AST_new_node(AST_Typekind, "float");};
 
-type: typekind {AST_NODE_PTR type = AST_new_node(AST_type, NULL);
+type: typekind {AST_NODE_PTR type = AST_new_node(AST_Type, NULL);
                 AST_push_node(type, $1);
                 $$ = type;}
-    | scale typekind {AST_NODE_PTR type = AST_new_node(AST_type, NULL);
+    | scale typekind {AST_NODE_PTR type = AST_new_node(AST_Type, NULL);
                 AST_push_node(type, $1);
                 AST_push_node(type, $2);
                 $$ = type;}
-    | sign typekind {AST_NODE_PTR type = AST_new_node(AST_type, NULL);
+    | sign typekind {AST_NODE_PTR type = AST_new_node(AST_Type, NULL);
                 AST_push_node(type, $1);
                 AST_push_node(type, $2);
                 $$ = type;}
-    | sign scale typekind {AST_NODE_PTR type = AST_new_node(AST_type, NULL);
+    | sign scale typekind {AST_NODE_PTR type = AST_new_node(AST_Type, NULL);
                 AST_push_node(type, $1);
                 AST_push_node(type, $2);
                 AST_push_node(type, $3);
@@ -286,37 +411,70 @@ operation: oparith {$$ = $1;}
     | opbool {$$ = $1;}
     | opbit {$$ = $1;};
 
-oparith: expr '+' expr {AST_NODE_PTR add = AST_new_node{AST_Add, NULL};
+oparith: expr '+' expr {AST_NODE_PTR add = AST_new_node(AST_Add, NULL);
                         AST_push_node(add, $1);
                         AST_push_node(add, $3);
                         $$ = add;}
-    | expr '-' expr    {AST_NODE_PTR subtract = AST_new_node{AST_Sub, NULL};
+    | expr '-' expr    {AST_NODE_PTR subtract = AST_new_node(AST_Sub, NULL);
                         AST_push_node(subtract, $1);
                         AST_push_node(subtract, $3);
                         $$ = subtract;}
-    | expr '*' expr     {AST_NODE_PTR mul = AST_new_node{AST_Mul, NULL};
+    | expr '*' expr     {AST_NODE_PTR mul = AST_new_node(AST_Mul, NULL);
                         AST_push_node(mul, $1);
                         AST_push_node(mul, $3);
                         $$ = mul;}
-    | expr '/' expr     {AST_NODE_PTR div = AST_new_node{AST_Div, NULL};
+    | expr '/' expr     {AST_NODE_PTR div = AST_new_node(AST_Div, NULL);
                         AST_push_node(div, $1);
                         AST_push_node(div, $3);
                         $$ = div;}
-    | '-' expr %prec '*';
+    | '-' expr %prec '*'{AST_NODE_PTR negator = AST_new_node(AST_Negate, NULL);
+                        AST_push_node(negator, $2);
+                        $$ = negator;};
 
-oplogic: expr OpEquals expr
-    | expr '<' expr
-    | expr '>' expr;
+oplogic: expr OpEquals expr {AST_NODE_PTR equals = AST_new_node(AST_Eq, NULL);
+                             AST_push_node(equals, $1);
+                             AST_push_node(equals, $3);
+                             $$ = equals;}
+    | expr '<' expr {AST_NODE_PTR less = AST_new_node(AST_Less, NULL);
+                             AST_push_node(less, $1);
+                             AST_push_node(less, $3);
+                             $$ = less;}
+    | expr '>' expr{AST_NODE_PTR greater = AST_new_node(AST_Greater, NULL);
+                             AST_push_node(greater, $1);
+                             AST_push_node(greater, $3);
+                             $$ = greater;};
 
-opbool: expr OpAnd expr
-    | expr OpOr expr
-    | expr OpXor expr
-    | OpNot expr %prec OpAnd;
+opbool: expr OpAnd expr {AST_NODE_PTR and = AST_new_node(AST_BoolAnd, NULL);
+                             AST_push_node(and, $1);
+                             AST_push_node(and, $3);
+                             $$ = and;}
+    | expr OpOr expr{AST_NODE_PTR or = AST_new_node(AST_BoolOr, NULL);
+                             AST_push_node(or, $1);
+                             AST_push_node(or, $3);
+                             $$ = or;}
+    | expr OpXor expr{AST_NODE_PTR xor = AST_new_node(AST_BoolXor, NULL);
+                             AST_push_node(xor, $1);
+                             AST_push_node(xor, $3);
+                             $$ = xor;}
+    | OpNot expr %prec OpAnd{AST_NODE_PTR not = AST_new_node(AST_BoolNot, NULL);
+                             AST_push_node(not, $2);
+                             $$ = not;};
 
-opbit: expr OpBitand expr
-    | expr OpBitor expr
-    | expr OpBitxor expr
-    | OpBitnot expr %prec OpBitand;
+opbit: expr OpBitand expr {AST_NODE_PTR and = AST_new_node(AST_BitAnd, NULL);
+                             AST_push_node(and, $1);
+                             AST_push_node(and, $3);
+                             $$ = and;}
+    | expr OpBitor expr{AST_NODE_PTR or = AST_new_node(AST_BitOr, NULL);
+                             AST_push_node(or, $1);
+                             AST_push_node(or, $3);
+                             $$ = or;}
+    | expr OpBitxor expr{AST_NODE_PTR xor = AST_new_node(AST_BitXor, NULL);
+                             AST_push_node(xor, $1);
+                             AST_push_node(xor, $3);
+                             $$ = xor;}
+    | OpBitnot expr %prec OpBitand{AST_NODE_PTR not = AST_new_node(AST_BitNot, NULL);
+                             AST_push_node(not, $2);
+                             $$ = not;};
 %%
 
 int yyerror(char *s) {