unit test for TriValue

src/dev/peerat/parser/Bag.java

@@ -38,6 +38,7 @@ public class Bag{
 	
 	public void set(Object value){
 		this.value = value;
+//		System.out.println("edit Bag "+this);
 	}
 	
 	public <E> E get(String key){
@@ -54,7 +55,7 @@ public class Bag{
 	
 	public void set(String key, Object value){
 		this.map.put(key, value);
-		System.out.println("edit Bag "+this);
+//		System.out.println("edit Bag "+this);
 	}
 	
 	@Override
@@ -62,6 +63,6 @@ public class Bag{
 		String map = "";
 		for(Entry<String, Object> entry : this.map.entrySet()) map+=","+(entry.getKey())+" -> "+entry.getValue();
 		if(map.length() > 0) map = map.substring(1);
-		return "([bag] | value="+value+" | map["+Arrays.toString(this.map.keySet().toArray())+"]="+map+" )";
+		return "([bag] "+(value != null ? "| value="+value+" ":"")+"| map["+Arrays.toString(this.map.keySet().toArray())+"]="+map+" )";
 	}
 }

src/dev/peerat/parser/TokenValidator.java

@@ -36,10 +36,10 @@ public class TokenValidator{
 			}
 			this.validated++;
 			
-			StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+//			StackTraceElement[] trace = Thread.currentThread().getStackTrace();
-			int current = 0;
+//			int current = 0;
-			while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
+//			while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
-			System.out.println("[validate] "+trace[current]);
+//			System.out.println("[validate] "+trace[current]);
 			
 			return true;
 		}

src/dev/peerat/parser/TreeStreamable.java

@@ -1,3 +0,0 @@
-package dev.peerat.parser;
-
-public interface TreeStreamable{}

src/dev/peerat/parser/java/Class.java

@@ -5,7 +5,7 @@ import java.util.List;
 import java.util.function.Predicate;
 
 import dev.peerat.parser.Token;
-import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.StreamableTree;
 import dev.peerat.parser.java.Function.FunctionStreamable;
 import dev.peerat.parser.java.Variable.VariableStreamable;
 
@@ -112,7 +112,7 @@ public class Class extends ClassBase{
 		return new ClassStreamable();
 	}
 
-	public class ClassStreamable implements TreeStreamable{
+	public class ClassStreamable implements StreamableTree{
 		
 		public ClassStreamable(){}
 		

src/dev/peerat/parser/java/ClassBase.java

@@ -8,11 +8,6 @@ import dev.peerat.parser.java.Annotation.AnnotableBuffer;
 import dev.peerat.parser.java.Function.FunctionContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
 
-interface ClassContainer{
-	
-	void addClass(ClassBase clazz);
-	
-}
 
 public abstract class ClassBase extends Annotable implements AnnotableBuffer, ClassContainer, FunctionContainer, VariableContainer{
 	
@@ -33,5 +28,4 @@ public abstract class ClassBase extends Annotable implements AnnotableBuffer, Cl
 		this.annotationBuffer = null;
 		return list;
 	}
-
 }

src/dev/peerat/parser/java/ClassContainer.java

@@ -0,0 +1,7 @@
+package dev.peerat.parser.java;
+
+public interface ClassContainer{
+	
+	void addClass(ClassBase clazz);
+	
+}

src/dev/peerat/parser/java/Function.java

@@ -7,7 +7,7 @@ import java.util.function.Predicate;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.TokenType;
-import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.StreamableTree;
 import dev.peerat.parser.java.Annotation.Annotable;
 import dev.peerat.parser.java.Operation.OperationContainer;
 import dev.peerat.parser.java.Variable.VariableContainer;
@@ -165,7 +165,7 @@ public class Function extends Annotable implements VariableContainer, OperationC
 		return new FunctionStreamable();
 	}
 
-	public class FunctionStreamable implements TreeStreamable{
+	public class FunctionStreamable implements StreamableTree{
 		
 		public FunctionStreamable(){}
 		

src/dev/peerat/parser/java/JavaElement.java

@@ -3,7 +3,6 @@ package dev.peerat.parser.java;
 import java.util.List;
 import java.util.function.Function;
 
-import dev.peerat.parser.Bag;
 import dev.peerat.parser.ElementBuilder;
 
 public abstract class JavaElement implements ElementBuilder{	

src/dev/peerat/parser/java/JavaTokenizer.java

@@ -0,0 +1,171 @@
+package dev.peerat.parser.java;
+
+import java.io.BufferedReader;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.Tokenizer;
+
+public class JavaTokenizer extends Tokenizer{
+	
+	@Override
+	public void parse(BufferedReader reader) throws Exception{
+		int lineNumber = 0;
+		String line;
+		boolean longCommentary = false;
+		while((line = reader.readLine()) != null){
+			lineNumber++;
+			
+			for(int i = 0; i < line.length(); i++){
+				char c = line.charAt(i);
+				if(longCommentary){
+					if(c == '*' && (i < line.length()-1 && line.charAt(i+1) == '/')){
+						longCommentary = false;
+						i++;
+					}
+//					System.out.print(c);
+					continue;
+				}
+				Token token;
+				if(isNameValid(c)){
+					String value = "";
+					int j = i;
+					for(; j < line.length(); j++){
+						c = line.charAt(j);
+						if(isNameValid(c)) value+=c;
+						else break;
+					}
+					token = new Token(lineNumber, i+1, value, TokenType.NAME);
+					i = j-1;
+				}else if(Character.isWhitespace(c)) continue;
+				else{
+					if(c == '"'){
+						String value = "\"";
+						int j = i+1;
+						for(; j < line.length(); j++){
+							c = line.charAt(j);
+							if(c == '"'){
+								value+=c;
+								j++;
+								break;
+							}else if(c == '\\'){
+								value+=c+line.charAt(++j);
+							}else{
+								value+=c;
+							}
+						}
+						token = new Token(lineNumber, i+1, value, TokenType.STRING);
+						i = j-1;
+					}else if(c == '\''){
+						String value = "'";
+						int j = i+1;
+						for(; j < line.length(); j++){
+							c = line.charAt(j);
+							if(c == '\''){
+								value+=c;
+								j++;
+								break;
+							}else if(c == '\\'){
+								value+=c+line.charAt(++j);
+							}else{
+								value+=c;
+							}
+						}
+						token = new Token(lineNumber, i+1, value, TokenType.CHAR);
+						i = j-1;
+					}else{
+						if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '/')) break;
+						if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '*')){
+							longCommentary = true;
+							continue;
+						}
+						token = new Token(lineNumber, i+1, ""+c, TokenType.DELIMITER);
+					}
+				}
+				getTokens().add(token);
+			}
+		}
+	}
+	
+	@Override
+	public void parse(String line){
+		System.out.println("tokenizer");
+		int lineNumber = 1;
+		boolean longCommentary = false;
+		for(int i = 0; i < line.length(); i++){
+			char c = line.charAt(i);
+			if(longCommentary){
+				if(c == '*' && (i < line.length()-1 && line.charAt(i+1) == '/')){
+					longCommentary = false;
+					i++;
+				}
+//				System.out.print(c);
+				continue;
+			}
+			Token token;
+			if(isNameValid(c)){
+				String value = "";
+				int j = i;
+				for(; j < line.length(); j++){
+					c = line.charAt(j);
+					if(isNameValid(c)) value+=c;
+					else break;
+				}
+				token = new Token(lineNumber, i+1, value, TokenType.NAME);
+				i = j-1;
+			}else if(Character.isWhitespace(c)) continue;
+			else{
+				if(c == '"'){
+					String value = "\"";
+					int j = i+1;
+					for(; j < line.length(); j++){
+						c = line.charAt(j);
+						if(c == '"'){
+							value+=c;
+							j++;
+							break;
+						}else if(c == '\\'){
+							value+=c+line.charAt(++j);
+						}else{
+							value+=c;
+						}
+					}
+					token = new Token(lineNumber, i+1, value, TokenType.STRING);
+					i = j-1;
+					System.out.println(token);
+				}else if(c == '\''){
+					String value = "'";
+					int j = i+1;
+					for(; j < line.length(); j++){
+						c = line.charAt(j);
+						if(c == '\''){
+							value+=c;
+							j++;
+							break;
+						}else if(c == '\\'){
+							value+=c+line.charAt(++j);
+						}else{
+							value+=c;
+						}
+					}
+					token = new Token(lineNumber, i+1, value, TokenType.CHAR);
+					i = j-1;
+					System.out.println(token);
+				}else{
+					if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '/')) break;
+					if(c == '/' && (i < line.length()-1 && line.charAt(i+1) == '*')){
+						longCommentary = true;
+						continue;
+					}
+					token = new Token(lineNumber, i+1, ""+c, TokenType.DELIMITER);
+				}
+			}
+			getTokens().add(token);
+		}
+	}
+	
+	private boolean isNameValid(char c) {
+		return Character.isAlphabetic(c) || Character.isDigit(c) || c == '_' || c == '$';
+	}
+
+}

src/dev/peerat/parser/java/Operation.java

@@ -2,7 +2,7 @@ package dev.peerat.parser.java;
 
 import java.util.function.Predicate;
 
-import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.StreamableTree;
 import dev.peerat.parser.java.Variable.VariableStreamable;
 import dev.peerat.parser.java.operation.AssignOperation;
 import dev.peerat.parser.java.operation.BreakOperation;
@@ -14,7 +14,6 @@ import dev.peerat.parser.java.operation.FinallyOperation;
 import dev.peerat.parser.java.operation.ForOperation;
 import dev.peerat.parser.java.operation.ForeachOperation;
 import dev.peerat.parser.java.operation.IfOperation;
-import dev.peerat.parser.java.operation.MethodCallOperation;
 import dev.peerat.parser.java.operation.ReturnOperation;
 import dev.peerat.parser.java.operation.SwitchOperation;
 import dev.peerat.parser.java.operation.SynchronizedOperation;
@@ -47,7 +46,7 @@ public abstract class Operation extends JavaElement{
 		return new OperationStreamable();
 	}
 	
-	public class OperationStreamable implements TreeStreamable{
+	public class OperationStreamable implements StreamableTree{
 		
 		public OperationStreamable(){}
 		
@@ -62,7 +61,6 @@ public abstract class Operation extends JavaElement{
 		public OperationStreamable foreachOperationFilter(Predicate<ForeachOperation> filter){ return null; }
 		public OperationStreamable forOperationFilter(Predicate<ForOperation> filter){ return null; }
 		public OperationStreamable ifOperationFilter(Predicate<IfOperation> filter){ return null; }
-		public OperationStreamable methodCallOperationFilter(Predicate<MethodCallOperation> filter){ return null; }
 		public OperationStreamable returnOperationFilter(Predicate<ReturnOperation> filter){ return null; }
 		public OperationStreamable switchOperationFilter(Predicate<SwitchOperation> filter){ return null; }
 		public OperationStreamable synchronizedOperationFilter(Predicate<SynchronizedOperation> filter){ return null; }

src/dev/peerat/parser/java/Variable.java

@@ -7,7 +7,7 @@ import java.util.function.Predicate;
 
 import dev.peerat.parser.Token;
 import dev.peerat.parser.TokenType;
-import dev.peerat.parser.TreeStreamable;
+import dev.peerat.parser.StreamableTree;
 import dev.peerat.parser.java.Annotation.Annotable;
 import dev.peerat.parser.java.value.ArrayValue;
 import dev.peerat.parser.java.value.BiValue;
@@ -115,7 +115,7 @@ public class Variable extends Annotable{
 		return new VariableStreamable();
 	}
 
-	public class VariableStreamable implements TreeStreamable{
+	public class VariableStreamable implements StreamableTree{
 		
 		public VariableStreamable(){}
 		

src/dev/peerat/parser/java/operation/MethodCallOperation.java

@@ -1,76 +0,0 @@
-package dev.peerat.parser.java.operation;
-
-import java.util.List;
-import java.util.function.Function;
-
-import dev.peerat.parser.Token;
-import dev.peerat.parser.java.JavaElement;
-import dev.peerat.parser.java.Operation;
-import dev.peerat.parser.java.value.Value;
-
-public class MethodCallOperation extends Operation{
-	
-	private Value start;
-	private MethodCallOperation previous;
-	private Token path;
-	private List<Value> parameters;
-	
-	public MethodCallOperation(Value start, Token path, List<Value> parameters){
-		this.start = start;
-		this.path = path;
-		this.parameters = parameters;
-	}
-	
-	public MethodCallOperation(MethodCallOperation previous, Token path, List<Value> parameters){
-		this((Value)null, path, parameters);
-		this.previous = previous;
-	}
-	
-	public MethodCallOperation getPrevious(){
-		return this.previous;
-	}
-	
-	public Token getPath(){
-		return path;
-	}
-	
-	public List<Value> getParameters(){
-		return this.parameters;
-	}
-	
-	@Override
-	public void build(Builder builder) throws Exception{
-		if(previous != null) previous.build(builder);
-		//todo
-	}
-
-	@Override
-	public <E extends JavaElement> E find(Function<JavaElement, Boolean> finder) {
-		if(start != null && finder.apply(start)) return (E)start;
-		if(previous != null) if(finder.apply(previous)) return (E) previous;
-		if(this.parameters != null){
-			for(Value param : this.parameters){
-				if(finder.apply(param)) return (E)param;
-			}
-		}
-		return null;
-	}
-
-	@Override
-	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list){
-		if(start != null){
-			if(finder.apply(start)) list.add((E)start);
-			start.findAll(finder, list);
-		}
-		if(previous != null){
-			if(finder.apply(previous)) list.add((E) previous);
-			previous.findAll(finder, list);
-		}
-		if(this.parameters != null){
-			for(Value param : this.parameters){
-				if(finder.apply(param)) list.add((E)param);
-				param.findAll(finder, list);
-			}
-		}
-	}
-}

src/dev/peerat/parser/java/tree/AnnotationClassTree.java

@@ -0,0 +1,44 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.AnnotationClass;
+import dev.peerat.parser.java.ClassContainer;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class AnnotationClassTree extends SyntaxTree<JavaElement> {
+
+	public AnnotationClassTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> clazz_container = registery.getNode(ClassContainerTree.class);
+		ClassBaseTree clazz_ = registery.getTree(ClassBaseTree.class);
+		// ANNOTATION CLAZZ
+		StateTree<JavaElement> def_annos = this.current;
+		StateTree<JavaElement> def_anno_base = def_annos
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("@"))
+						&& validator.validate((token) -> token.getValue().equals("interface")))
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.set("name", token)));
+		def_anno_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					AnnotationClass current = new AnnotationClass((((AnnotableBuffer) parent).getAnnotationBuffer()),
+							bag.get("name"));
+					if (parent instanceof ClassContainer)
+						((ClassContainer) parent).addClass(current);
+					return current;
+				}).multiple(clazz_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		clazz_.getNode().then(def_annos);
+		clazz_.getModifierNode().then(def_annos);
+	}
+
+}

src/dev/peerat/parser/java/tree/AnnotationTree.java

@@ -0,0 +1,91 @@
+package dev.peerat.parser.java.tree;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class AnnotationTree extends SyntaxTree<JavaElement> {
+
+	public AnnotationTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> value = registery.getNode(ValueTree.class);
+		// ANNOTATION
+		StateTree<JavaElement> annotation = this.current;
+		StateTree<JavaElement> annotation_name = annotation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("@"))
+						&& !validator.validate((token) -> token.getValue().equals("interface")))
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> {
+							Token name = bag.get("name");
+							if (name == null)
+								bag.set("name", token);
+							else
+								bag.set("name", name.concat(token));
+						}));
+		annotation_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("."), (bag, token) -> {
+					Token name = bag.get("name");
+					if (name == null)
+						bag.set("name", token);
+					else
+						bag.set("name", name.concat(token));
+				})).then(annotation_name);
+		annotation_name.end((parent, bag) -> {
+			Annotation result = new Annotation(bag.get("name"));
+			bag.set(result);
+			if (parent instanceof AnnotableBuffer)
+				((AnnotableBuffer) parent).addAnnotationBuffer(result);
+			return null;
+		});
+		StateTree<JavaElement> annotation_begin = annotation_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
+		StateTree<JavaElement> annotation_end = annotation_begin
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		annotation_end.end((parent, bag) -> {
+			Annotation result = new Annotation(bag.get("name"), bag.get("values"));
+			bag.set(result);
+			if (parent instanceof AnnotableBuffer)
+				((AnnotableBuffer) parent).addAnnotationBuffer(result);
+			return null;
+		});
+		StateTree<JavaElement> annotation_var = annotation_begin.then((validator) -> validator
+				.validate((token) -> token.getType().equals(TokenType.NAME), (bag, token) -> bag.set("index", token)));
+		StateTree<JavaElement> annotation_value = annotation_var
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
+				.then(new RedirectStateTree<>(value, (global, local) -> {
+					Map<Token, Value> map = global.get("values");
+					if (map == null) {
+						map = new LinkedHashMap<>();
+						global.set("values", map);
+					}
+					map.put(global.get("index"), local.get());
+				}));
+		annotation_value.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+				.then(annotation_var);
+		annotation_value.then(annotation_end);
+		annotation_begin.then(new RedirectStateTree<>(value, (global, local) -> {
+			Map<Token, Value> map = global.get("values");
+			if (map == null) {
+				map = new LinkedHashMap<>();
+				global.set("values", map);
+			}
+			map.put(null, local.get());
+		})).then(annotation_end);
+	}
+
+}

src/dev/peerat/parser/java/tree/ClassBaseTree.java

@@ -0,0 +1,30 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ClassBaseTree extends SyntaxTree<JavaElement> {
+	
+	private StateTree<JavaElement> modifierState;
+
+	public ClassBaseTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+
+		StateTree<JavaElement> clazz_ = this.current;
+		this.modifierState = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
+	}
+	
+	public StateTree<JavaElement> getModifierNode(){
+		return this.modifierState;
+	}
+
+}

src/dev/peerat/parser/java/tree/ClassContainerTree.java

@@ -0,0 +1,38 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ClassContainerTree extends SyntaxTree<JavaElement> {
+
+	public ClassContainerTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init(){
+		StateTree<JavaElement> clazz_ = this.registery.getNode(ClassBaseTree.class);
+		StateTree<JavaElement> function = this.registery.getNode(FunctionTree.class);
+		StateTree<JavaElement> variable = this.registery.getNode(VariableTree.class);
+		StateTree<JavaElement> function_container = this.registery.getNode(FunctionContainerTree.class);
+		
+		StateTree<JavaElement> clazz_container = this.current;
+		clazz_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end((a, b) -> a);
+		
+		clazz_container.then(function);
+		clazz_container.then(variable);
+		
+		clazz_container.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+			.end((a,b) -> a)
+				.multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.end((a,b) -> a);
+		
+		clazz_container.then(clazz_);
+	}
+
+}

src/dev/peerat/parser/java/tree/ClassTree.java

@@ -0,0 +1,81 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.Class;
+import dev.peerat.parser.java.ClassContainer;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ClassTree extends SyntaxTree<JavaElement> {
+
+	public ClassTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> clazz_container = registery.getNode(ClassContainerTree.class);
+		ClassBaseTree clazz_ = registery.getTree(ClassBaseTree.class);
+		// CLASS
+		StateTree<JavaElement> clazz = this.current;
+
+		StateTree<JavaElement> clazz_base = clazz
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("class")))
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("name", local.get())));
+		clazz_base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					Class current = new Class((((AnnotableBuffer) parent).getAnnotationBuffer()), bag.get("name"));
+					if (parent instanceof ClassContainer)
+						((ClassContainer) parent).addClass(current);
+					return current;
+				}).multiple(clazz_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+		StateTree<JavaElement> clazz_implement = clazz_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("implements")));
+		StateTree<JavaElement> clazz_implement_name = clazz_implement
+				.then(new RedirectStateTree<>(type, (global, local) -> {
+					Token token = global.get("implement");
+					if (token == null)
+						global.set("implement", local.get());
+					else
+						global.set("implement", token.concat(local.get()));
+				}));
+		clazz_implement_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(","),
+						(bag, token) -> bag.set("implement", bag.<Token>get("implement").concat(token))))
+				.then(clazz_implement_name);
+		clazz_implement_name.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					Class current = new Class((((AnnotableBuffer) parent).getAnnotationBuffer()), bag.get("name"),
+							bag.get("extend"), bag.get("implement"));
+					if (parent instanceof ClassContainer)
+						((ClassContainer) parent).addClass(current);
+					return current;
+				}).multiple(clazz_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+		StateTree<JavaElement> clazz_extend = clazz_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("extend", local.get())));
+		clazz_extend.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					Class current = new Class((((AnnotableBuffer) parent).getAnnotationBuffer()), bag.get("name"),
+							bag.get("extend"), bag.get("implement"));
+					if (parent instanceof ClassContainer)
+						((ClassContainer) parent).addClass(current);
+					return current;
+				}).multiple(clazz_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+		clazz_extend.then(clazz_implement);
+
+		
+		clazz_.getNode().then(clazz);
+		clazz_.getModifierNode().then(clazz);
+	}
+
+}

src/dev/peerat/parser/java/tree/EnumTree.java

@@ -0,0 +1,72 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.ClassContainer;
+import dev.peerat.parser.java.Enumeration;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class EnumTree extends SyntaxTree<JavaElement> {
+
+	public EnumTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> enum_value = registery.getNode(EnumValueTree.class);
+		StateTree<JavaElement> clazz_ = registery.getNode(ClassBaseTree.class);
+		// ENUM
+		StateTree<JavaElement> enums = this.current;
+		StateTree<JavaElement> enum_base = enums
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("enum")))
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.set("name", token)));
+
+		StateTree<JavaElement> enum_start = enum_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
+		enum_start.<JavaElement>end((parent, bag) -> {
+			Enumeration current = new Enumeration((((AnnotableBuffer) parent).getAnnotationBuffer()), bag.get("name"),
+					bag.get("implement"));
+			if (parent instanceof ClassContainer)
+				((ClassContainer) parent).addClass(current);
+			return current;
+		}).unique(enum_value)
+//					.unique(mult_clazz_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> enum_implement = enum_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("implements")));
+		StateTree<JavaElement> enum_implement_name = enum_implement
+				.then(new RedirectStateTree<>(type, (global, local) -> {
+					Token token = global.get("implement");
+					if (token == null)
+						token = local.get();
+					else
+						token = token.concat(local.get());
+					global.set("implement", token);
+				}));
+		enum_implement_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+				.then(enum_implement_name);
+		enum_implement_name.then(enum_start);
+		StateTree<JavaElement> enum_extend = enum_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("extend", local.get())));
+		enum_extend.then(enum_start);
+		enum_extend.then(enum_implement);
+
+		StateTree<JavaElement> enum_mod = clazz_
+				.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
+		clazz_.then(enums);
+		enum_mod.then(enums);
+	}
+
+}

src/dev/peerat/parser/java/tree/EnumValueTree.java

@@ -0,0 +1,39 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class EnumValueTree extends SyntaxTree<JavaElement> {
+
+	public EnumValueTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> value = registery.getNode(ValueTree.class);
+
+		// ENUM VALUE
+		StateTree<JavaElement> enum_value = this.current;
+		StateTree<JavaElement> enum_name = enum_value
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
+		enum_name.end((a, b) -> a);
+		enum_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a, b) -> a);
+		enum_name.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_name);
+		StateTree<JavaElement> enum_arg = enum_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
+		StateTree<JavaElement> enum_end = enum_arg
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		enum_end.end((a, b) -> a);
+		enum_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a, b) -> a);
+		enum_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_arg);
+		enum_end.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(enum_name);
+	}
+
+}

src/dev/peerat/parser/java/tree/FunctionContainerTree.java

@@ -0,0 +1,28 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class FunctionContainerTree extends SyntaxTree<JavaElement> {
+
+	public FunctionContainerTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> variable = this.registery.getNode(VariableTree.class);
+		StateTree<JavaElement> operation = this.registery.getNode(OperationTree.class);
+		
+		StateTree<JavaElement> function_container = this.current;
+		function_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end((a, b) -> a);
+		
+		function_container.then(variable);
+		function_container.then(operation);
+	}
+
+}

src/dev/peerat/parser/java/tree/FunctionTree.java

@@ -0,0 +1,173 @@
+package dev.peerat.parser.java.tree;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+
+import dev.peerat.parser.Bag;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.Function.FunctionContainer;
+import dev.peerat.parser.state.BuilderStateTree;
+import dev.peerat.parser.state.InitialStateTree;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class FunctionTree extends SyntaxTree<JavaElement> {
+
+	public FunctionTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new InitialStateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> gen = registery.getNode(GenericTree.class);
+		StateTree<JavaElement> value = registery.getNode(ValueTree.class);
+		StateTree<JavaElement> annotation = registery.getNode(AnnotationTree.class);
+		StateTree<JavaElement> function_container = registery.getNode(FunctionContainerTree.class);
+		
+		// FUNCTION
+		BiFunction<JavaElement, Bag, JavaElement> function_builder = (parent, bag) -> {
+			buildVariable(bag);
+			Integer mod = bag.get("mod");
+			List<Annotation> annotations = null;
+			if (parent instanceof AnnotableBuffer)
+				annotations = (((AnnotableBuffer) parent).getAnnotationBuffer());
+			Function function = new Function(annotations, mod == null ? 0 : mod, bag.get("generic"), bag.get("type"),
+					bag.get("name"), bag.get("param"), bag.get("throws"));
+			if (parent instanceof FunctionContainer)
+				((FunctionContainer) parent).addFunction(function);
+			return function;
+		};
+
+		InitialStateTree<JavaElement> function = (InitialStateTree<JavaElement>) this.current;
+		function.multiple(annotation);
+		BuilderStateTree<JavaElement, JavaElement> function_static = function
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("static"))
+						&& validator.validate((token) -> token.getValue().equals("{")))
+				.end((parent, bag) -> {
+					Function build = new Function((((AnnotableBuffer) parent).getAnnotationBuffer()), Modifier.STATIC,
+							null, null);
+					if (parent instanceof FunctionContainer)
+						((FunctionContainer) parent).addFunction(build);
+					return build;
+				});
+		function_static.multiple(function_container);
+		function_static.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		StateTree<JavaElement> function_mod = function.then(new RedirectStateTree<>(modifier, (global, local) -> {
+			Integer mod = global.get("mod");
+			if (mod == null)
+				global.set("mod", local.get());
+			else
+				global.set("mod", mod + local.<Integer>get());
+		}));
+		StateTree<JavaElement> function_generic = function
+				.then(new RedirectStateTree<>(gen, (global, local) -> global.set("generic", local.get())));
+		StateTree<JavaElement> function_type = function
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local.get())));
+		function_mod.then(function_mod);
+		function_mod.then(function_generic);
+		function_mod.then(function_type);
+		function_generic.then(function_type);
+
+		StateTree<JavaElement> function_name = function.then((validator) -> validator
+				.validate((token) -> token.getType().equals(TokenType.NAME), (bag, token) -> bag.set("name", token)));
+		function_type.then(function_name);
+		function_mod.then(function_name);
+		StateTree<JavaElement> function_begin = function_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
+		StateTree<JavaElement> function_end = function_begin
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.end(function_builder).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end();
+		function_end.then((validator) -> validator.validate((token) -> token.getValue().equals("default")))
+				.then(new RedirectStateTree<>(value, (global, local) -> System.out.println("TODO DEFAULT IN FUNCTION")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end(function_builder);
+
+		StateTree<JavaElement> function_throws = function_end
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("throws")))
+				.then(new RedirectStateTree<>(type, (global, local) -> {
+					List<Token> throwables = global.get("throws");
+					if (throwables == null) {
+						throwables = new ArrayList<>();
+						global.set("throws", throwables);
+					}
+					throwables.add(local.get());
+				}));
+		BuilderStateTree<JavaElement, JavaElement> function_start_throws = function_throws
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end(function_builder);
+		function_start_throws.multiple(function_container);
+		function_start_throws.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+				.then(function_throws);
+		function_throws.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end(function_builder);
+
+		StateTree<JavaElement> function_arg_mod = function_begin.then((validator) -> validator
+				.validate((token) -> token.getValue().equals("final"), (bag, token) -> bag.set("arg_mod", true)));
+		StateTree<JavaElement> function_arg_type = function_begin
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("arg_type", local.get())));
+		function_arg_mod.then(function_arg_type);
+		StateTree<JavaElement> function_arg_type_array_begin = function_arg_type
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("["),
+						(bag, token) -> bag.set("arg_type", bag.<Token>get("arg_type").concat(token))));
+		StateTree<JavaElement> function_arg_type_array_end = function_arg_type_array_begin
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("]"),
+						(bag, token) -> bag.set("arg_type", bag.<Token>get("arg_type").concat(token))));
+		function_arg_type_array_end.then(function_arg_type_array_begin);
+		StateTree<JavaElement> function_arg_name = function_arg_type
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.set("arg_name", token)));
+		function_arg_type_array_end.then(function_arg_name);
+		function_arg_type
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("."))
+						&& validator.validate((token) -> token.getValue().equals(".")) && validator.validate(
+								(token) -> token.getValue().equals("."), (bag, token) -> bag.set("arg_elips", true)))
+				.then(function_arg_name);
+		StateTree<JavaElement> function_arg_split = function_arg_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(","), (bag, token) -> {
+					buildVariable(bag);
+				}));
+		function_arg_split.then(function_arg_mod);
+		function_arg_split.then(function_arg_type);
+		function_arg_name.then(function_end);
+	}
+
+	// TAKE ANNOTATIONS ???????
+	private static void buildVariable(Bag bag) {
+		if (!bag.has("arg_name"))
+			return;
+
+		List<Variable> parameters = bag.get("param");
+		if (parameters == null) {
+			parameters = new ArrayList<>();
+			bag.set("param", parameters);
+		}
+
+		Integer mod = bag.get("arg_mod");
+
+		Variable variable = new Variable(null, mod == null ? 0 : mod, bag.<Token>get("arg_type"),
+				bag.<Token>get("arg_name"), bag.get("arg_elips") == Boolean.TRUE);
+		bag.remove("arg_name");
+		bag.remove("arg_mod");
+		bag.remove("arg_type");
+		bag.remove("arg_name");
+		bag.remove("arg_elips");
+
+		parameters.add(variable);
+	}
+
+}

src/dev/peerat/parser/java/tree/GenericTree.java

@@ -0,0 +1,80 @@
+package dev.peerat.parser.java.tree;
+
+import java.util.function.BiConsumer;
+
+import dev.peerat.parser.Bag;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class GenericTree extends SyntaxTree<JavaElement> {
+
+	public GenericTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+
+		BiConsumer<Bag, Token> concat = (bag, token) -> {
+			Token value = bag.get();
+			if (value == null)
+				bag.set(token);
+			else
+				bag.set(value.concat(token));
+		};
+
+		StateTree<JavaElement> gen = this.current;
+		StateTree<JavaElement> type_begin = gen
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), concat));
+		StateTree<JavaElement> type_generic = type_begin.then(
+				new RedirectStateTree<>(type, (global, local) -> global.set(global.<Token>get().concat(local.get()))));
+		StateTree<JavaElement> type_generic_end = type_generic
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), concat));
+		StateTree<JavaElement> type_generic_split = type_generic
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(","), concat));
+		type_generic_split.then(type_generic);
+
+		type_begin.then(type_generic_end); // remove ?
+
+		StateTree<JavaElement> type_generic_unknow = type_begin
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("?"), concat));
+		type_generic_unknow.then(type_generic_end);
+		type_generic_split.then(type_generic_unknow);
+		type_generic_unknow.then(type_generic_split);
+		StateTree<JavaElement> type_generic_unknow_extends = type_generic_unknow
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("extends"), concat))
+				.then(new RedirectStateTree<>(type,
+						(global, local) -> global.set(global.<Token>get().concat(local.get()))));
+		type_generic_unknow_extends.then(type_generic_end);
+		type_generic_unknow_extends.then(type_generic_split);
+		StateTree<JavaElement> type_generic_unknow_super = type_generic_unknow
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("super"), concat))
+				.then(new RedirectStateTree<>(type,
+						(global, local) -> global.set(global.<Token>get().concat(local.get()))));
+		type_generic_unknow_super.then(type_generic_end);
+		type_generic_unknow_super.then(type_generic_split);
+
+		StateTree<JavaElement> type_generic_named_extends = type_generic
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("extends"), concat))
+				.then(new RedirectStateTree<>(type,
+						(global, local) -> global.set(global.<Token>get().concat(local.get()))));
+		type_generic_named_extends.then(type_generic_end);
+		type_generic_named_extends.then(type_generic_split);
+		StateTree<JavaElement> type_generic_named_super = type_generic
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("super"), concat))
+				.then(new RedirectStateTree<>(type,
+						(global, local) -> global.set(global.<Token>get().concat(local.get()))));
+		type_generic_named_super.then(type_generic_end);
+		type_generic_named_super.then(type_generic_split);
+
+		type_generic_end.end();
+	}
+
+}

src/dev/peerat/parser/java/tree/InterfaceTree.java

@@ -0,0 +1,56 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.ClassContainer;
+import dev.peerat.parser.java.Interface;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.state.InitialStateTree;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class InterfaceTree extends SyntaxTree<JavaElement> {
+
+	public InterfaceTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> clazz_container = registery.getNode(ClassContainerTree.class);
+		// INTERFACE
+		StateTree<JavaElement> interfaces = this.current;
+		StateTree<JavaElement> interface_base = interfaces
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("interface")))
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.set("name", token)));
+		StateTree<JavaElement> interface_start = interface_base
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
+		interface_start.<JavaElement>end((parent, bag) -> {
+			Interface current = new Interface((((AnnotableBuffer) parent).getAnnotationBuffer()), bag.get("name"),
+					bag.get("extend"));
+			if (parent instanceof ClassContainer)
+				((ClassContainer) parent).addClass(current);
+			return current;
+		}).multiple(clazz_container).unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
+				.end((a, b) -> a);
+
+		interface_base.then((validator) -> validator.validate((token) -> token.getValue().equals("extends")))
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("extend", local.get())))
+				.then(interface_start);
+
+//				StateTree<JavaElement> interface_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
+//				clazz_.then(interfaces);
+//				interface_mod.then(interfaces);
+
+		InitialStateTree<JavaElement> mult_clazz_container = new InitialStateTree<>();
+		mult_clazz_container.multiple(clazz_container);
+		mult_clazz_container.end((a, b) -> a);
+	}
+
+}

src/dev/peerat/parser/java/tree/JavaTreeType.java

@@ -0,0 +1,33 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.tree.TreeType;
+
+public enum JavaTreeType implements TreeType{
+	
+	ALL(null),
+	CLASS_BASE(ClassBaseTree.class),
+	CLASS(ClassTree.class),
+	INTERFACE(InterfaceTree.class),
+	ENUMERATION(EnumTree.class),
+	ANNOTATION_CLASS(AnnotationClassTree.class),
+	FUNCTION(FunctionTree.class),
+	OPERATION(OperationTree.class),
+	VARIABLE(VariableTree.class),
+	ANNOTATION(AnnotationTree.class),
+	VALUE(ValueTree.class),
+	TYPE(TypeTree.class),
+	GENERIC(GenericTree.class),
+	MODIFIER(ModifierTree.class);
+	
+	private Class<?> type;
+	
+	JavaTreeType(Class<?> type){
+		this.type = type;
+	}
+
+	@Override
+	public Class<?> getType(){
+		return type;
+	}
+	
+}

src/dev/peerat/parser/java/tree/ModifierTree.java

@@ -0,0 +1,62 @@
+package dev.peerat.parser.java.tree;
+
+import java.lang.reflect.Modifier;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ModifierTree extends SyntaxTree<JavaElement> {
+
+	public ModifierTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		this.current.then((validator) -> {
+			boolean mod = false;
+			while (validator.validate((token) -> getModifier(token.getValue()) > 0, (bag, token) -> {
+				int m = getModifier(token.getValue());
+				Integer current = bag.get();
+				bag.set(current == null ? m : current + m);
+			}))
+				mod = true;
+			return mod;
+		}).end();
+	}
+
+	private int getModifier(String modifier) {
+		switch (modifier) {
+		case "public":
+			return Modifier.PUBLIC;
+		case "private":
+			return Modifier.PRIVATE;
+		case "protected":
+			return Modifier.PROTECTED;
+		case "static":
+			return Modifier.STATIC;
+		case "final":
+			return Modifier.FINAL;
+		case "synchronized":
+			return Modifier.SYNCHRONIZED;
+		case "volatile":
+			return Modifier.VOLATILE;
+		case "transient":
+			return Modifier.TRANSIENT;
+		case "native":
+			return Modifier.NATIVE;
+		case "abstract":
+			return Modifier.ABSTRACT;
+		case "strictfp":
+			return Modifier.STRICT;
+		case "default":
+			return Modifier.STRICT;
+		default:
+			break;
+		}
+		return 0;
+	}
+}

src/dev/peerat/parser/java/tree/OperationTree.java

@@ -0,0 +1,296 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Operation.OperationContainer;
+import dev.peerat.parser.java.operation.AssignOperation;
+import dev.peerat.parser.java.operation.BreakOperation;
+import dev.peerat.parser.java.operation.ContinueOperation;
+import dev.peerat.parser.java.operation.ForOperation;
+import dev.peerat.parser.java.operation.IfOperation;
+import dev.peerat.parser.java.operation.ReturnOperation;
+import dev.peerat.parser.java.operation.SynchronizedOperation;
+import dev.peerat.parser.java.operation.ThrowOperation;
+import dev.peerat.parser.java.operation.WhileOperation;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class OperationTree extends SyntaxTree<JavaElement> {
+
+	public OperationTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> value = registery.getNode(ValueTree.class);
+		StateTree<JavaElement> variable = registery.getNode(VariableTree.class);
+		StateTree<JavaElement> function_container = registery.getNode(FunctionContainerTree.class);
+
+		// OPERATION
+		StateTree<JavaElement> operation = this.current;
+
+		StateTree<JavaElement> operation_return = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("return")));
+		operation_return.then(new RedirectStateTree<>(value, (global, local) -> global.set(local.get())))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((parent, bag) -> {
+					ReturnOperation op = new ReturnOperation(bag.get());
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return null;
+				});
+
+		operation_return.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end((parent, bag) -> {
+					ReturnOperation op = new ReturnOperation(bag.get());
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return null;
+				});
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("throw")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(local.get())))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((parent, bag) -> {
+					ThrowOperation op = new ThrowOperation(bag.get());
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return null;
+				});
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("do")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end((a, b) -> a)
+				.multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_else = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("else"))).end((a, b) -> a);
+		operation_else.then(operation);
+		operation_else.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end((a, b) -> a)
+				.multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_try = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("try")));
+		StateTree<JavaElement> operation_try_base = operation_try
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")));
+		operation_try.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(variable, (global, local) -> global.set(null)))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
+				.then(operation_try_base);
+		StateTree<JavaElement> operation_try_end = operation_try_base.end((a, b) -> a).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_finally = operation_try_end
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("finally")));
+		operation_finally.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.end((a, b) -> a).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_catch_named = operation_try_end
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("catch")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
+		operation_catch_named.then((validator) -> validator.validate((token) -> token.getValue().equals("|")))
+				.then(operation_catch_named);
+		StateTree<JavaElement> operation_catch = operation_catch_named
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end((a, b) -> a)
+				.multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+		operation_catch.then(operation_finally);
+		operation_catch.then(operation_catch_named);
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("continue")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((parent, bag) -> {
+					ContinueOperation op = new ContinueOperation();
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return null;
+				});
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("break")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((parent, bag) -> {
+					System.out.println("break");
+					BreakOperation op = new BreakOperation();
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return null;
+				});
+
+		StateTree<JavaElement> operation_if = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("if")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("("))).then((v) -> {
+					System.out.println("inside IF");
+					return true;
+				}).then(new RedirectStateTree<>(value, (global, local) -> global.set(local.get())))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")"))).end((parent, bag) -> {
+					System.out.println("if " + bag);
+					IfOperation op = new IfOperation(bag.get());
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return op;
+				});
+		operation_if.then(operation);
+		operation_if.then((validator) -> validator.validate((token) -> token.getValue().equals("{"))).end((a, b) -> a)
+				.multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> switch_cases = new StateTree<>();
+		StateTree<JavaElement> switch_case_begin = switch_cases
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("case")));
+		StateTree<JavaElement> switch_case = switch_case_begin
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(":")));
+		switch_case.then(switch_case_begin);
+		switch_case.end((a, b) -> a).multiple(function_container);
+
+		switch_cases.then((validator) -> validator.validate((token) -> token.getValue().equals("default")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(":"))).end((a, b) -> a)
+				.multiple(function_container);
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("switch")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")"))
+						&& validator.validate((token) -> token.getValue().equals("{")))
+				.end((a, b) -> a).multiple(switch_cases)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_for = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("for")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
+
+		StateTree<JavaElement> operation_for_first_part = operation_for
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";")));
+
+		StateTree<JavaElement> operation_for_modifier = operation_for.then(new RedirectStateTree<>(modifier, null));
+		operation_for_modifier.then(operation_for_modifier);
+
+		StateTree<JavaElement> operation_for_type = operation_for
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)));
+		operation_for_modifier.then(operation_for_type);
+
+		StateTree<JavaElement> operation_for_assign = operation_for
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
+		operation_for_modifier.then(operation_for_assign);
+		operation_for_type.then(operation_for_assign);
+
+		StateTree<JavaElement> operation_for_assign_end = operation_for_assign
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
+
+		operation_for_assign.then(operation_for_assign);
+		operation_for_assign.then(operation_for_first_part);
+
+		operation_for_assign_end.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+				.then(operation_for_assign);
+		operation_for_assign_end.then(operation_for_first_part);
+
+		StateTree<JavaElement> operation_for_second_part = operation_for_first_part
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(";")));
+
+		operation_for_first_part.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)))
+				.then(operation_for_second_part);
+
+		StateTree<JavaElement> operation_for_end = operation_for_second_part
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		operation_for_end.<JavaElement>end((parent, bag) -> {
+			ForOperation op = new ForOperation(null, null, null, null);
+			if (parent instanceof OperationContainer)
+				((OperationContainer) parent).addOperation(op);
+			System.out.println("FOOOR");
+			return op;
+		}).then(operation);
+
+		operation_for_end.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					ForOperation op = new ForOperation(null, null, null, null);
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return op;
+				}).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		operation_for_assign.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null))).then(operation_for_end);
+
+		StateTree<JavaElement> operation_for_update = operation_for_second_part
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
+		operation_for_update.then(operation_for_end);
+		operation_for_update.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+				.then(operation_for_update);
+
+		StateTree<JavaElement> operation_while = operation
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("while")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		operation_while.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					WhileOperation op = new WhileOperation(null);
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return op;
+				}).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		operation_while.<JavaElement>end((parent, bag) -> {
+			WhileOperation op = new WhileOperation(null);
+			if (parent instanceof OperationContainer)
+				((OperationContainer) parent).addOperation(op);
+			return op;
+		}).then(operation);
+
+		operation.then((validator) -> validator.validate((token) -> token.getValue().equals("synchronized")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(local.get())))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.<JavaElement>end((parent, bag) -> {
+					SynchronizedOperation op = new SynchronizedOperation(bag.get());
+					if (parent instanceof OperationContainer)
+						((OperationContainer) parent).addOperation(op);
+					return op;
+				}).multiple(function_container)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a, b) -> a);
+
+		StateTree<JavaElement> operation_name = operation
+				.then(new RedirectStateTree<>(value, (global, local) -> global.set(local.get())));
+		operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
+		.then(new RedirectStateTree<>(value, (global, local) -> global.set("newer", local.get())))
+		.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+		.end((parent, bag) -> parent);
+		
+		operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end((parent, bag) -> {
+					Value action = bag.get();
+					if (action instanceof BiValue) {
+						BiValue assign = (BiValue) action;
+						AssignOperation op = new AssignOperation(assign.left(), assign.right());
+						if (parent instanceof OperationContainer)
+							((OperationContainer) parent).addOperation(op);
+					}
+					if (action instanceof MethodCallValue) {
+						MethodCallValue call = (MethodCallValue) action;
+//						MethodCallOperation op = new MethodCallOperation((Value) null, call.getToken(),
+//								call.getParameters());
+//						if (parent instanceof OperationContainer)
+//							((OperationContainer) parent).addOperation(op);
+					}
+					return null;
+				});
+
+		function_container.then(variable);
+		function_container.then(operation);
+	}
+
+}

src/dev/peerat/parser/java/tree/TypeTree.java

@@ -0,0 +1,49 @@
+package dev.peerat.parser.java.tree;
+
+import java.util.function.BiConsumer;
+
+import dev.peerat.parser.Bag;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class TypeTree extends SyntaxTree<JavaElement> {
+
+	public TypeTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> gen = registery.getNode(GenericTree.class);
+		// TYPE
+		BiConsumer<Bag, Token> concat = (bag, token) -> {
+			Token value = bag.get();
+			if (value == null)
+				bag.set(token);
+			else
+				bag.set(value.concat(token));
+		};
+
+		StateTree<JavaElement> type = this.current;
+		StateTree<JavaElement> type_ = type
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME), concat));
+//				type_.then((validator) -> validator.validate((token) -> token.getValue().equals("."), concat)) //only dot?
+//					.then(type_);
+		type_.then(gen);
+
+		StateTree<JavaElement> type_array_begin = type_
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
+		StateTree<JavaElement> type_array_end = type_array_begin
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
+		type_array_end.then(type_array_begin);
+		type_array_end.end();
+
+		type_.end();
+	}
+
+}

src/dev/peerat/parser/java/tree/ValueTree.java

@@ -0,0 +1,172 @@
+package dev.peerat.parser.java.tree;
+
+import java.util.function.BiFunction;
+
+import dev.peerat.parser.Bag;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.Value.ValueContainer;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ValueTree extends SyntaxTree<JavaElement> {
+
+	public ValueTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init(){
+		StateTree<JavaElement> type = this.registery.getNode(TypeTree.class);
+		StateTree<JavaElement> function_container = this.registery.getNode(FunctionContainerTree.class);
+		StateTree<JavaElement> class_container = this.registery.getNode(ClassContainerTree.class);
+		// VALUE
+		StateTree<JavaElement> value = this.current;
+		StateTree<JavaElement> unary_value = new StateTree<>();
+		StateTree<JavaElement> value_operation = new StateTree<>();
+		
+		value.then((v) -> {
+			return v.validate((t) -> {
+				System.out.println("entry value "+t);
+				return false;
+			});
+		});
+		
+		BiFunction<JavaElement, Bag, JavaElement> operationBuilder = (parent, bag) -> {
+			System.out.println("operationBuilder "+bag);
+			if (bag.has("current")) {
+				bag.set(new BiValue(new StaticValue(bag.get("current")), bag.get("action"), bag.get("right")));
+			} else {
+				bag.set(new BiValue(bag.get(), bag.get("action"), bag.get("right")));
+			}
+			System.out.println("value_op " + bag);
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(bag.get());
+			return null;
+		};
+		
+		BiFunction<JavaElement, Bag, JavaElement> staticValueBuilder = (parent, bag) -> {
+			System.out.println("staticValueBuilder "+bag);
+			StaticValue result = new StaticValue(bag.get("current"));
+			bag.set(result);
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(result);
+			return null;
+		};
+		
+		StateTree<JavaElement> redirectRight = new RedirectStateTree<>(value, (global, local) -> {
+			System.out.println("redirectRight g="+global+" ,l="+local);
+			global.set("right", local.get());
+		});
+
+		StateTree<JavaElement> value_instance = unary_value.equals("new");
+		StateTree<JavaElement> value_instance_type = value_instance.redirect(type);
+		StateTree<JavaElement> value_instance_params = value_instance_type.equals("(");
+		StateTree<JavaElement> value_instance_params_end = value_instance_params.equals(")");
+		StateTree<JavaElement> value_instance_param = value_instance_params.redirect(value);
+		value_instance_param.then(value_instance_params_end);
+		value_instance_param.equals(",").then(value_instance_param);
+		value_instance_params_end.<JavaElement>end();
+		value_instance_params_end.equals("{")
+		.<JavaElement>end().multiple(class_container)
+		.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		
+		StateTree<JavaElement> value_instance_array_init = value_instance_type.equals("{");
+		StateTree<JavaElement> value_instance_array_init_value = value_instance_array_init.redirect(value);
+		value_instance_array_init_value.equals(",").then(value_instance_array_init_value);
+		value_instance_array_init_value.equals("}").end();
+		
+		StateTree<JavaElement> value_instance_array = value_instance_type.equals("[");
+		StateTree<JavaElement> value_instance_array_value = value_instance_array.redirect(value);
+		StateTree<JavaElement> value_instance_array_end = value_instance_array_value.equals("]");
+		value_instance_array.then(value_instance_array_end);
+		value_instance_array_end.end();
+		value_instance_array_end.then(value_instance_array);
+		
+		StateTree<JavaElement> value_name = unary_value
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.set("current", token)));
+		value_name.end(staticValueBuilder);
+		value_name.then(value_operation);
+		
+		unary_value.then((validator) -> validator.validate(
+				(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
+				(bag, token) -> bag.set("current", token)))
+			.end(staticValueBuilder);
+
+		value_operation.equals(">","action",">").then(redirectRight).end(operationBuilder);
+		value_operation.equals("<","action","<").then(redirectRight).end(operationBuilder);
+		value_operation.equals("<","action","<").equals("<","action","<<").then(redirectRight).end(operationBuilder);
+		value_operation.equals("+","action","+").then(redirectRight).end(operationBuilder);
+		StateTree<JavaElement> value_operation_bit_and = value_operation.equals("&","action","&");
+		value_operation_bit_and.then(redirectRight).end(operationBuilder);
+		value_operation_bit_and.equals("&","action","&&").then(redirectRight).end(operationBuilder);
+		StateTree<JavaElement> value_operation_bit_or = value_operation.equals("|","action","|");
+		value_operation_bit_or.then(redirectRight).end(operationBuilder);
+		value_operation_bit_or.equals("|","action","||").then(redirectRight).end(operationBuilder);
+		
+		value.equals("!").redirect(value).end();
+		
+		StateTree<JavaElement> left_value = value.redirect(unary_value);
+		left_value.end((parent, bag) -> {
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(bag.get());
+			return null;
+		});
+		left_value.equals("?")
+			.redirect(value, (global, local) -> global.set("success", local.get()))
+			.equals(":")
+			.redirect(value, (global, local) -> global.set("fail", local.get()))
+			.end((parent, bag) -> {
+				System.out.println("tri value "+bag);
+				bag.set(new TriValue(bag.get(), bag.get("success"), bag.get("fail")));
+				if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(bag.get());
+				return null;
+			});
+		
+		StateTree<JavaElement> value_array = left_value.equals("[");
+		StateTree<JavaElement> value_array_value = value_array.redirect(value);
+		StateTree<JavaElement> value_array_end = value_array_value.equals("]");
+		value_array_end.end();
+		value_array_end.then(value_array);
+		
+		StateTree<JavaElement> operation_call = value_name.equals(".");
+		operation_call.then(value_name);
+		StateTree<JavaElement> operation_begin = value_name.equals("(");
+		StateTree<JavaElement> operation_end = operation_begin.equals(")");
+		operation_end.then(operation_call);
+		operation_end.end();
+		StateTree<JavaElement> operation_value = operation_begin.redirect(value);
+		operation_value.then(operation_end);
+		operation_value.equals(",")
+				.then(operation_value);
+		
+		StateTree<JavaElement> value_parenthesis = unary_value.equals("(");
+		StateTree<JavaElement> value_parenthesis_close = value_parenthesis.equals(")");
+		StateTree<JavaElement> value_inside = value_parenthesis.redirect(value);
+		StateTree<JavaElement> value_inside_type = value_parenthesis.redirect(type);
+		
+		value_inside_type.then(value_inside);
+		StateTree<JavaElement> value_inside_splitter = value_inside.equals(",");
+		value_inside_splitter.then(value_inside_type);
+		value_inside_splitter.then(value_inside);
+		
+		value_inside.then(value_parenthesis_close);
+		value_inside.then(value_operation);
+		value_parenthesis_close.end();
+		value_parenthesis_close.then(value_operation);
+		
+		StateTree<JavaElement> value_lambda = value_parenthesis_close.then((validator) -> validator.validate((token) -> token.getValue().equals("-")) && validator.validate((token) -> token.getValue().equals(">")));
+		value_lambda.equals("{")
+			.<JavaElement>end().multiple(function_container)
+			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		
+		value_lambda.redirect(unary_value).end();
+		
+	}
+
+}

src/dev/peerat/parser/java/tree/VariableTree.java

@@ -0,0 +1,89 @@
+package dev.peerat.parser.java.tree;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.BiFunction;
+
+import dev.peerat.parser.Bag;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.state.InitialStateTree;
+import dev.peerat.parser.state.RedirectStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class VariableTree extends SyntaxTree<JavaElement> {
+
+	public VariableTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new InitialStateTree<>();
+	}
+
+	@Override
+	public void init() {
+		StateTree<JavaElement> modifier = registery.getNode(ModifierTree.class);
+		StateTree<JavaElement> type = registery.getNode(TypeTree.class);
+		StateTree<JavaElement> value = registery.getNode(ValueTree.class);
+		StateTree<JavaElement> annotation = registery.getNode(AnnotationTree.class);
+
+		// VARIABLE
+		BiFunction<JavaElement, Bag, JavaElement> variable_builder = (parent, bag) -> {
+			Integer mod = bag.get("mod");
+			Token vtype = bag.get("type");
+			Map<Token, Value> map = bag.get("vars");
+			for (Entry<Token, Value> vars : map.entrySet()) {
+				List<Annotation> annotations = null;
+				if (parent instanceof AnnotableBuffer)
+					annotations = (((AnnotableBuffer) parent).getAnnotationBuffer());
+				Variable result = new Variable(annotations, mod == null ? 0 : mod, vtype, vars.getKey(), false,
+						vars.getValue());
+				bag.set(result);
+				if (parent instanceof VariableContainer)
+					((VariableContainer) parent).addVariable(result);
+			}
+			return null;
+		};
+
+		InitialStateTree<JavaElement> variable = (InitialStateTree<JavaElement>) this.current;
+		variable.multiple(annotation);
+		StateTree<JavaElement> variable_mod = variable
+				.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("mod", local.get())));
+		StateTree<JavaElement> variable_type = variable
+				.then(new RedirectStateTree<>(type, (global, local) -> global.set("type", local.get())));
+		variable_mod.then(variable_type);
+		StateTree<JavaElement> variable_name = variable_type.then(
+				(validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME), (bag, token) -> {
+					Map<Token, Value> map = bag.get("vars");
+					if (map == null) {
+						map = new LinkedHashMap<>();
+						bag.set("vars", map);
+					}
+					bag.set("last", token);
+					map.put(token, null);
+				}));
+		variable_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end(variable_builder);
+		StateTree<JavaElement> variable_split = variable_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
+		variable_split.then(variable_name);
+		StateTree<JavaElement> variable_value = variable_name
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
+				.then(new RedirectStateTree<>(value, (global, local) -> {
+					global.<Map<Token, Value>>get("vars").put(global.get("last"), local.get());
+				}));
+		variable_value.then(variable_split);
+		variable_value.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
+				.end(variable_builder);
+		variable_value.end(variable_builder);
+	}
+
+}

src/dev/peerat/parser/java/value/TriValue.java

@@ -43,5 +43,10 @@ public class TriValue extends Value{
 	public <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list) {
 		
 	}
+	
+	@Override
+	public String toString(){
+		return "[TriValue] "+check+" ? "+success+" : "+fail;
+	}
 
 }

src/dev/peerat/parser/java/value/Value.java

@@ -6,6 +6,13 @@ import dev.peerat.parser.java.JavaElement;
 
 public abstract class Value extends JavaElement{
 	
+	//Only for TESTS purpose!
+	public static interface ValueContainer{
+		
+		void addValue(Value value);
+		
+	}
+	
 	public ValueStreamable stream(){
 		return new ValueStreamable();
 	}

src/dev/peerat/parser/state/RedirectStateTree.java

@@ -10,18 +10,18 @@ public class RedirectStateTree<E, T extends E> extends StateTree<T>{
 	private StateTree<E> redirect;
 	private BiConsumer<Bag, Bag> group;
 	
-	private StackTraceElement calling;
+//	private StackTraceElement calling;
 
 	public RedirectStateTree(StateTree<E> redirect, BiConsumer<Bag, Bag> group){
 		super();
 		this.redirect = redirect;
 		this.group = group;
 		
-		StackTraceElement[] trace = Thread.currentThread().getStackTrace();
+//		StackTraceElement[] trace = Thread.currentThread().getStackTrace();
-		int current = 0;
+//		int current = 0;
-		while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
+//		while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
 		
-		this.calling = trace[current];
+//		this.calling = trace[current];
 	}
 	
 	@Override
@@ -35,7 +35,7 @@ public class RedirectStateTree<E, T extends E> extends StateTree<T>{
 		if(builded == null) return null;
 		builded.build(branch, element);
 		
-		System.out.println("[redirect done] "+calling);
+//		System.out.println("[redirect done] "+calling);
 
 		this.group.accept(currentBag, localBag);
 		branch.setBag(currentBag);

src/dev/peerat/parser/state/StateTree.java

@@ -2,6 +2,7 @@ package dev.peerat.parser.state;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
@@ -77,4 +78,24 @@ public class StateTree<E>{
 		return builderState;
 	}
 	
+	//maybe remove later
+	public StateTree<E> equals(String value){
+		return then((validator) -> validator.validate((token) -> token.getValue().equals(value)));
+	}
+	
+	public StateTree<E> equals(String value, String key){
+		return then((validator) -> validator.validate((token) -> token.getValue().equals(value), (bag, token) -> bag.set(key, token)));
+	}
+	
+	public StateTree<E> equals(String value, String key, String val){
+		return then((validator) -> validator.validate((token) -> token.getValue().equals(value), (bag, token) -> bag.set(key, val)));
+	}
+	
+	public StateTree<E> redirect(StateTree<E> target){
+		return then(new RedirectStateTree<>(target, (global, local) -> global.set(local.get())));
+	}
+	
+	public StateTree<E> redirect(StateTree<E> target, BiConsumer<Bag, Bag> group){
+		return then(new RedirectStateTree<>(target, group));
+	}
 }

src/dev/peerat/parser/tree/SyntaxTree.java

@@ -0,0 +1,29 @@
+package dev.peerat.parser.tree;
+
+import dev.peerat.parser.state.StateTree;
+
+public abstract class SyntaxTree<E>{
+
+	protected SyntaxTreeRegistery<E> registery;
+	protected StateTree<E> current;
+	private boolean init;
+	
+	public SyntaxTree(SyntaxTreeRegistery<E> registery){
+		this.registery = registery;
+	}
+	
+	public StateTree<E> getNode(){
+		return this.current;
+	}
+	
+	public void checkInit(){
+		if(!init){
+			init();
+			this.init = true;
+		}
+	}
+	
+	public abstract void init();
+	
+	
+}

src/dev/peerat/parser/tree/SyntaxTreeRegistery.java

@@ -0,0 +1,35 @@
+package dev.peerat.parser.tree;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import dev.peerat.parser.state.StateTree;
+
+public class SyntaxTreeRegistery<E>{
+	
+	private Map<Class<?>, SyntaxTree<E>> registery;
+
+	public SyntaxTreeRegistery(){
+		this.registery = new HashMap<>();
+	}
+	
+	public void register(SyntaxTree<E> node){
+		this.registery.put(node.getClass(), node);
+	}
+	
+	public StateTree<E> getNode(Class<?> clazz){
+		return this.registery.get(clazz).getNode();
+	}
+	
+	public <T extends SyntaxTree<E>> T getTree(Class<?> clazz){
+		T result = (T) this.registery.get(clazz);
+		result.checkInit();
+		return result;
+	}
+	
+	public void init(){
+		for(SyntaxTree<E> tree : registery.values()){
+			tree.checkInit();
+		}
+	}
+}

src/dev/peerat/parser/tree/TreeType.java

@@ -0,0 +1,6 @@
+package dev.peerat.parser.tree;
+
+public interface TreeType{
+	
+	Class<?> getType();
+}

test/dev/peerat/parser/java/element/BaseElementTests.java

@@ -50,7 +50,7 @@ public class BaseElementTests{
 			System.out.println("["+getClass().getSimpleName()+"] passed "+size+" tests");
 		}catch(Exception|AssertionError e){
 			System.err.println("["+getClass().getSimpleName()+"] failed "+text+" for cause "+e.getMessage());
-			e.printStackTrace();
+			throw new RuntimeException(e);
 		}
 	}
 	

test/dev/peerat/parser/java/element/value/TypeOfValuesTests.java

@@ -71,6 +71,31 @@ public class TypeOfValuesTests extends BaseElementTests{
 				+ "        if(a && b == c){}"
 				+ "}"
 				+ "}",
+				(javafile) -> {
+					BiValue value = gotoValue(javafile);
+					printObject(value);
+					StaticValue left = (StaticValue) value.left();
+					BiValue right = (BiValue) value.right();
+					
+					StaticValue rightLeft = (StaticValue) right.left();
+					StaticValue rightRight = (StaticValue) right.right();
+					
+					assertToken("a", left.getToken());
+					assertEquals("&&", value.getAction());
+					assertToken("b", rightLeft.getToken());
+					
+					assertEquals("==", right.getAction());
+					assertToken("c", rightRight.getToken());
+				});
+		
+		register(
+				"package be.jeffcheasey88;"
+				+ ""
+				+ "public static class Test{ "
+				+ "    void test(){ "
+				+ "        if((a && b) == c){}"
+				+ "}"
+				+ "}",
 				(javafile) -> {
 					BiValue value = gotoValue(javafile);
 					printObject(value);