TokenVisitor + ImportTree + refractor JavaTree into new class (was in JavaParser) + Value MethodCall -> generic call + TokenUpdater (V1)

.classpath

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="test"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/5"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

java.pc

@@ -0,0 +1,25 @@
+import(
+	[import](
+		:static,
+		:normal
+	);
+	static:[static](
+		:normal
+	);
+	normal:[!;]* -> concat(import)
+	[;]=;
+	
+	import
+)
+
+package(
+	[package]
+	[!;]* -> concat(package)
+	[;]=;
+	
+	import
+)
+
+main(
+	package
+)

src/be/jeffcheasey88/peeratcode/parser/Bag.java

@@ -1,40 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-public class Bag{
-	
-	private Map<String, Object> map;
-	
-	private Object value;
-	
-	public Bag(){
-		this.map = new HashMap<>();
-	}
-	
-	public <E> E get(){
-		return (E) this.value;
-	}
-	
-	public void set(Object value){
-		this.value = value;
-	}
-	
-	public <E> E get(String key){
-		return (E) this.map.get(key);
-	}
-	
-	public void set(String key, Object value){
-		this.map.put(key, value);
-	}
-	
-	@Override
-	public String toString(){
-		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="+map+" )";
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/Parser.java

@@ -1,27 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser;
-
-import java.io.BufferedReader;
-
-import be.jeffcheasey88.peeratcode.parser.state.StateTree;
-
-public class Parser<E>{
-
-	private Tokenizer tokenizer;
-	private StateTree<E> state;
-	
-	public Parser(){}
-	
-	public void setTokenizer(Tokenizer tokenizer){
-		this.tokenizer = tokenizer;
-	}
-	
-	public void setStateTree(StateTree<E> stateTree){
-		this.state = stateTree;
-	}
-	
-	public final void parse(BufferedReader reader, E container) throws Exception{
-		this.tokenizer.parse(reader);
-		
-		this.state.seed(this.tokenizer, container);
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java

@@ -1,96 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser;
-
-import java.util.Iterator;
-import java.util.function.BiConsumer;
-import java.util.function.Function;
-
-public class TokenValidator implements Iterator<Token>{
-
-	private Token[] elements;
-	private int index;
-	private int validated;
-	
-	private Bag bag;
-	
-	public TokenValidator(Token[] tokens){
-		this.elements = tokens;
-		this.validated = -1;
-		this.bag = new Bag();
-	}
-	
-	@Override
-	public boolean hasNext(){
-		return index < elements.length;
-	}
-
-	@Override
-	public Token next(){
-		return elements[index++];
-	}
-	
-	public boolean validate(Function<Token, Boolean> action){
-		if(index >= this.elements.length) return false;
-		if(action.apply(this.elements[index])){
-			System.out.println("validate "+elements[index]);
-			this.validated = index;
-			next();
-			return true;
-		}
-		return false;
-	}
-	
-	public boolean validate(Function<Token, Boolean> action, BiConsumer<Bag, Token> filler){
-		if(validate(action)){
-			filler.accept(bag, elements[index-1]);
-			return true;
-		}
-		return false;
-	}
-	
-	public void rollbackValidate(){
-		this.index = validated+1;
-	}
-	
-	public TokenValidator pullValidated(){
-		Token[] validated = new Token[this.validated+1];
-		System.arraycopy(this.elements, 0, validated, 0, validated.length);
-		TokenValidator tk = new TokenValidator(validated);
-		tk.bag = bag;
-		return tk;
-	}
-	
-	public void pushValidated(){
-		Token[] validated = new Token[this.elements.length-(this.validated+1)];
-		System.arraycopy(this.elements, this.validated+1, validated, 0, validated.length);
-		this.elements = validated;
-		this.index = 0;
-		this.validated = -1;
-	}
-	
-	public TokenValidator branch(){
-		pushValidated();
-		TokenValidator branch = new TokenValidator(this.elements);
-		branch.bag = this.bag;
-		return branch;
-	}
-	
-	public void merge(TokenValidator branch){
-		branch.pushValidated();
-		this.elements = branch.elements;
-		this.index = 0;
-		this.validated = -1;
-	}
-	
-	public Token[] toArray(){
-		return this.elements;
-	}
-	
-	public void setBag(Bag bag){
-		this.bag = bag;
-	}
-	
-	public Bag getBag(){
-		return this.bag;
-	}
-	
-}

src/be/jeffcheasey88/peeratcode/parser/java/Annotation.java

@@ -1,11 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-
-public class Annotation{
-	
-	public Annotation(Bag bag){
-		
-	}
-
-}

src/be/jeffcheasey88/peeratcode/parser/java/Class.java

@@ -1,34 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.Token;
-
-public class Class extends JavaElement{
-	
-	private List<Annotation> annotations;
-	
-	private String name;
-	private String extend;
-	private String implement;
-	
-	private List<JavaElement> elements;
-	
-	public Class(Bag bag){
-		this.name = bag.<Bag>get("name").<Token>get().getValue();
-		
-		Bag extendBag = bag.<Bag>get("extend");
-		if(extendBag != null) this.extend = extendBag.<Token>get().getValue();
-		
-		Bag implementBag = bag.<Bag>get("implement");
-		if(implementBag != null) this.implement = implementBag.<Token>get().getValue();
-	
-		this.annotations = new ArrayList<>();
-		this.elements = new ArrayList<>();
-	}
-	
-	
-
-}

src/be/jeffcheasey88/peeratcode/parser/java/Function.java

@@ -1,27 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.Token;
-
-public class Function extends JavaElement{
-	
-	private List<Annotation> annotations;
-	
-	private String returnType;
-	private String name;
-	
-	private List<JavaElement> elements;
-	
-	public Function(Bag bag){
-		this.returnType = bag.<Bag>get("return").<Token>get().getValue();
-		if(JavaParser.getModifier(this.returnType) > 0) this.returnType = null;
-		this.name = bag.<Token>get("name").getValue();
-		
-		this.annotations = new ArrayList<>();
-		this.elements = new ArrayList<>();
-	}
-
-}

src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java

@@ -1,5 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-public class JavaElement {
-
-}

src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java

@@ -1,38 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.Token;
-
-public class JavaFile extends JavaElement{
-	
-	private String pack;
-	private List<String> imports;
-	private Class mainClazz;
-	private List<Class> subClazz;
-	
-	public JavaFile(){
-		this.imports = new ArrayList<>();
-		this.subClazz = new ArrayList<>();
-	}
-	
-	JavaFile setPackage(Bag bag){
-		this.pack = bag.<Token>get("package").getValue();
-		System.out.println("setPackage "+pack);
-		return this;
-	}
-	
-	JavaFile addImport(Bag bag){
-		this.imports.add(bag.<Token>get("import").getValue());
-		System.out.println("addImport "+imports.get(imports.size()-1));
-		return this;
-	}
-	
-	Class setClass(Class clazz){
-		this.mainClazz = clazz;
-		System.out.println("setClass "+clazz);
-		return clazz;
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java

@@ -1,296 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.Parser;
-import be.jeffcheasey88.peeratcode.parser.Token;
-import be.jeffcheasey88.peeratcode.parser.TokenType;
-import be.jeffcheasey88.peeratcode.parser.TokenValidator;
-import be.jeffcheasey88.peeratcode.parser.Tokenizer;
-import be.jeffcheasey88.peeratcode.parser.java.Value.BiValue;
-import be.jeffcheasey88.peeratcode.parser.java.Value.TriValue;
-import be.jeffcheasey88.peeratcode.parser.state.RedirectStateTree;
-import be.jeffcheasey88.peeratcode.parser.state.StateTree;
-
-public class JavaParser  extends Parser<JavaFile> {
-	
-	public static long time;
-	
-	public static void main(String[] args) throws Exception{
-		File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\peer-at-code-backend\\src\\be\\jeffcheasey88\\peeratcode\\routes\\Result.java");
-		BufferedReader reader = new BufferedReader(new FileReader(file));
-		
-		time = System.currentTimeMillis();
-		
-		Parser<JavaFile> parser = new JavaParser();
-		JavaFile jFile = new JavaFile();
-		parser.parse(reader, jFile);
-
-		System.out.println((System.currentTimeMillis()-time)+"ms");
-	}
-	
-	private static final
-		Function<TokenValidator, Boolean>
-		LAMBDA_name = (v) -> v.validate((t) -> t.getType().equals(TokenType.NAME), (bag, token) -> {
-			Token base = bag.get();
-			if(base == null) bag.set(token);
-			else bag.set(base.concat(token));
-		}),
-//		LAMBDA_name = (v) -> v.validate((t) -> {if(t.getType().equals(TokenType.NAME) && JavaParser.getModifier(t.getValue()) == 0) { System.out.println("valid type name --> "+t.getValue()); return true;}else return false;}),
-		LAMBDA_mod = (v) -> v.validate((t) ->
-			JavaParser.getModifier(t.getValue()) > 0,
-				(bag, token) -> {
-					Integer modifier = bag.get();
-					if(modifier == null) modifier = 0;
-					bag.set(modifier+JavaParser.getModifier(token.getValue()));
-		});
-		BiFunction<JavaFile, TokenValidator, JavaFile>
-		END_PACKAGE = ((javafile, validator) -> javafile.setPackage(validator.getBag())),
-		END_IMPORT = ((javafile, validator) -> javafile.addImport(validator.getBag()));
-		BiFunction<JavaFile, TokenValidator, Class>
-		END_CLASS = ((javafile, validator) -> javafile.setClass(new Class(validator.getBag())));
-		BiFunction<JavaElement, TokenValidator, Token>
-		END_TYPE = ((javafile, validator) -> {
-			System.out.println("return token "+validator.getBag().get());
-			return validator.getBag().get();
-		});
-		BiFunction<JavaElement, TokenValidator, Variable>
-		END_VAR = ((javafile, validator) -> {
-			System.out.println("new var");
-			return new Variable(validator.getBag());
-		});
-		BiFunction<JavaElement, TokenValidator, be.jeffcheasey88.peeratcode.parser.java.Function>
-		END_FUNC = ((javafile, validator) -> {
-			System.out.println("new function");
-			return new be.jeffcheasey88.peeratcode.parser.java.Function(validator.getBag());
-		});
-		BiFunction<JavaElement, TokenValidator, Integer>
-		END_MODIFIER = ((javafile, validator) ->{
-			return validator.getBag().get();
-		});
-
-	public JavaParser(){
-		Tokenizer tokenizer = new Tokenizer();
-
-		Function<TokenValidator, Boolean> LAMBDA_0 = (v) -> v.validate((t) -> t.getValue().equals("package"));
-		Function<TokenValidator, Boolean> LAMBDA_1 = (v) -> v.validate((t) -> t.getValue().equals(";"));
-		Function<TokenValidator, Boolean> LAMBDA_3 = (v) -> v.validate((t) -> t.getValue().equals("import"));
-		Function<TokenValidator, Boolean> LAMBDA_4 = (v) -> v.validate((t) -> t.getValue().equals("static"), (bag, token) -> bag.set("static", "bool"));
-		Function<TokenValidator, Boolean> LAMBDA_5 = (v) -> v.validate((t) -> t.getValue().equals("<"));
-		Function<TokenValidator, Boolean> LAMBDA_6 = (v) -> v.validate((t) -> t.getValue().equals(">"));
-		Function<TokenValidator, Boolean> LAMBDA_7 = (v) -> v.validate((t) -> t.getValue().equals(","));
-		Function<TokenValidator, Boolean> LAMBDA_8 = (v) -> v.validate((t) -> t.getValue().equals("="));
-		Function<TokenValidator, Boolean> LAMBDA_10 = (v) -> v.validate((t) -> t.getValue().equals("!"));
-		Function<TokenValidator, Boolean> LAMBDA_11 = (v) -> v.validate((t) -> t.getValue().equals("?"));
-		Function<TokenValidator, Boolean> LAMBDA_12 = (v) -> v.validate((t) -> t.getValue().equals(":"));
-		Function<TokenValidator, Boolean> LAMBDA_13 = (v) -> v.validate((t) -> t.getValue().equals("~"));
-		Function<TokenValidator, Boolean> LAMBDA_14 = (v) -> v.validate((t) -> t.getValue().equals("+"));
-		Function<TokenValidator, Boolean> LAMBDA_15 = (v) -> v.validate((t) -> t.getValue().equals("-"));
-		Function<TokenValidator, Boolean> LAMBDA_16 = (v) -> v.validate((t) -> t.getValue().equals("/"));
-		Function<TokenValidator, Boolean> LAMBDA_17 = (v) -> v.validate((t) -> t.getValue().equals("*"));
-		Function<TokenValidator, Boolean> LAMBDA_18 = (v) -> v.validate((t) -> t.getValue().equals("&"));
-		Function<TokenValidator, Boolean> LAMBDA_19 = (v) -> v.validate((t) -> t.getValue().equals("|"));
-		Function<TokenValidator, Boolean> LAMBDA_20 = (v) -> v.validate((t) -> t.getValue().equals("^"));
-		Function<TokenValidator, Boolean> LAMBDA_21 = (v) -> v.validate((t) -> t.getValue().equals("%"));
-		Function<TokenValidator, Boolean> LAMBDA_23 = (v) -> v.validate((t) -> t.getValue().equals("("));
-		Function<TokenValidator, Boolean> LAMBDA_24 = (v) -> v.validate((t) -> t.getValue().equals(")"));
-		Function<TokenValidator, Boolean> LAMBDA_25 = (v) -> v.validate((t) -> t.getValue().equals("."));
-		Function<TokenValidator, Boolean> LAMBDA_26 = (v) -> v.validate((t) -> t.getValue().equals("\""));
-		Function<TokenValidator, Boolean> LAMBDA_27 = (v) -> v.validate((t) -> !t.getValue().equals("\""));
-		Function<TokenValidator, Boolean> LAMBDA_28 = (v) -> v.validate((t) -> t.getValue().equals("'"));
-		Function<TokenValidator, Boolean> LAMBDA_29 = (v) -> v.validate((t) -> t.getValue().equals("oneChar"));
-		Function<TokenValidator, Boolean> LAMBDA_30 = (v) -> v.validate((t) -> t.getValue().equals("if"));
-		Function<TokenValidator, Boolean> LAMBDA_31 = (v) -> v.validate((t) -> t.getValue().equals("for"));
-		Function<TokenValidator, Boolean> LAMBDA_32 = (v) -> v.validate((t) -> t.getValue().equals("while"));
-		Function<TokenValidator, Boolean> LAMBDA_33 = (v) -> v.validate((t) -> t.getValue().equals("return"));
-		Function<TokenValidator, Boolean> LAMBDA_34 = (v) -> v.validate((t) -> t.getValue().equals("do"));
-		Function<TokenValidator, Boolean> LAMBDA_35 = (v) -> v.validate((t) -> t.getValue().equals("synchronized"));
-		Function<TokenValidator, Boolean> LAMBDA_36 = (v) -> v.validate((t) -> t.getValue().equals("continue"));
-		Function<TokenValidator, Boolean> LAMBDA_37 = (v) -> v.validate((t) -> t.getValue().equals("throw"));
-		Function<TokenValidator, Boolean> LAMBDA_38 = (v) -> v.validate((t) -> t.getValue().equals("break"));
-		Function<TokenValidator, Boolean> LAMBDA_39 = (v) -> v.validate((t) -> t.getValue().equals("try"));
-		Function<TokenValidator, Boolean> LAMBDA_40 = (v) -> v.validate((t) -> t.getValue().equals("{"));
-		Function<TokenValidator, Boolean> LAMBDA_41 = (v) -> v.validate((t) -> t.getValue().equals("}"));
-		Function<TokenValidator, Boolean> LAMBDA_44 = (v) -> v.validate((t) -> t.getValue().equals("throws"));
-		Function<TokenValidator, Boolean> LAMBDA_46 = (v) -> v.validate((t) -> t.getValue().equals("class"));
-		Function<TokenValidator, Boolean> LAMBDA_47 = (v) -> v.validate((t) -> t.getValue().equals("implements"));
-		Function<TokenValidator, Boolean> LAMBDA_48 = (v) -> v.validate((t) -> t.getValue().equals("extends"));
-
-		StateTree<JavaFile> main = new StateTree<>();
-		StateTree<JavaElement> value_q0 = value(LAMBDA_5, LAMBDA_6, LAMBDA_7, LAMBDA_8, LAMBDA_10, LAMBDA_11, LAMBDA_12, LAMBDA_13, LAMBDA_14, LAMBDA_15, LAMBDA_16, LAMBDA_17, LAMBDA_18, LAMBDA_19, LAMBDA_20, LAMBDA_21, LAMBDA_23, LAMBDA_24, LAMBDA_25, LAMBDA_26, LAMBDA_27, LAMBDA_28, LAMBDA_29);
-		
-		System.out.println("----");
-		//(ab = (cd & 3))
-		tokenizer.getTokens().addAll(build("(","ab","=","(","cd","&","34",")",")"));
-		value_q0.seed(tokenizer, null);
-		System.out.println("----");
-		
-		System.out.println((System.currentTimeMillis()-time)+"ms");
-		
-//		try {
-//			DebugServer server = new DebugServer(main);
-//		} catch (Exception e) {
-//			e.printStackTrace();
-//		}
-		
-		setTokenizer(tokenizer);
-		setStateTree(main);
-	}
-	
-	private List<Token> build(String... values){
-		List<Token> list = new ArrayList<>();
-		for(String value : values) list.add(new Token(0, 0, value, value.length() > 1 ? TokenType.NAME : TokenType.DELIMITER));
-		return list;
-	}
-	
-	private BiConsumer<Bag, Token> groupToken(String group){
-		return (bag, token) -> {
-			Token base = bag.get(group);
-			if(base == null) bag.set(group, token);
-			else bag.set(group, base.concat(token));
-		};
-	}
-	
-	public static 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;
-			default: break;
-		}
-		return 0;
-	}
-	
-	private StateTree<JavaElement> value(
-			Function<TokenValidator, Boolean> LAMBDA_5,
-			Function<TokenValidator, Boolean> LAMBDA_6,
-			Function<TokenValidator, Boolean> LAMBDA_7,
-			Function<TokenValidator, Boolean> LAMBDA_8,
-			Function<TokenValidator, Boolean> LAMBDA_10,
-			Function<TokenValidator, Boolean> LAMBDA_11,
-			Function<TokenValidator, Boolean> LAMBDA_12,
-			Function<TokenValidator, Boolean> LAMBDA_13,
-			Function<TokenValidator, Boolean> LAMBDA_14,
-			Function<TokenValidator, Boolean> LAMBDA_15,
-			Function<TokenValidator, Boolean> LAMBDA_16,
-			Function<TokenValidator, Boolean> LAMBDA_17,
-			Function<TokenValidator, Boolean> LAMBDA_18,
-			Function<TokenValidator, Boolean> LAMBDA_19,
-			Function<TokenValidator, Boolean> LAMBDA_20,
-			Function<TokenValidator, Boolean> LAMBDA_21,
-			Function<TokenValidator, Boolean> LAMBDA_23,
-			Function<TokenValidator, Boolean> LAMBDA_24,
-			Function<TokenValidator, Boolean> LAMBDA_25,
-			Function<TokenValidator, Boolean> LAMBDA_26,
-			Function<TokenValidator, Boolean> LAMBDA_27,
-			Function<TokenValidator, Boolean> LAMBDA_28,
-			Function<TokenValidator, Boolean> LAMBDA_29
-			){
-		BiFunction<JavaElement, TokenValidator, JavaElement> END_VALUE = (element, validator) -> {
-			//single value
-			System.out.println("end value "+validator.getBag());
-			Bag bag = validator.getBag();
-			Value v = new Value(bag);
-			bag.set("result",v);
-			return v;
-		};
-		BiFunction<JavaElement, TokenValidator, JavaElement> END_BIVALUE = (element, validator) -> {
-			//create new value from parent & created single value
-			System.out.println("end bi value "+validator.getBag());
-			Bag bag = validator.getBag();
-			return new BiValue((Value)element, bag.<Bag>get("?").get("result"));
-		};
-		BiFunction<JavaElement, TokenValidator, JavaElement> END_TRIVALUE = (element, validator) -> {
-			//same but for val ? val : val 
-			System.out.println("end tri value "+validator.getBag());
-			Bag bag = validator.getBag();
-			return new TriValue(bag);
-		};
-		StateTree<JavaElement> value_q0 = new StateTree<>();
-		StateTree<JavaElement> value_q22 = new StateTree<>();
-		StateTree<JavaElement> value_q23 = value_q22.then(LAMBDA_8);
-		value_q23.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE); 			// ==
-		value_q23.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// =
-		StateTree<JavaElement> value_q24 = value_q22.then(LAMBDA_5);
-		value_q24.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// <
-		value_q24.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// <=
-		StateTree<JavaElement> value_q41 = value_q24.then(LAMBDA_5);
-		value_q41.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// <<
-		value_q41.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// <<=
-		StateTree<JavaElement> value_q25 = value_q22.then(LAMBDA_6);
-		value_q25.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// >
-		value_q25.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// >=
-		StateTree<JavaElement> value_q55 = value_q25.then(LAMBDA_6);
-		value_q55.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// >>
-		value_q55.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// >>=
-		StateTree<JavaElement> value_q61 = value_q55.then(LAMBDA_6);
-		value_q61.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// >>>
-		value_q61.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// >>>=
-		StateTree<JavaElement> value_q26 = value_q22.then(LAMBDA_10);
-		value_q26.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// !
-		value_q26.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// !=
-		value_q22.then(LAMBDA_11).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).then(LAMBDA_12).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_TRIVALUE); //? : 
-		value_q22.then(LAMBDA_13).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// ~
-		StateTree<JavaElement> value_q29 = value_q22.then(LAMBDA_14);
-		value_q29.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// +
-		value_q29.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// +=
-		value_q29.then(LAMBDA_14).<JavaElement>end(END_VALUE);																// ++
-		StateTree<JavaElement> value_q30 = value_q22.then(LAMBDA_15);
-		value_q30.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// -
-		value_q30.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// -=
-		value_q30.then(LAMBDA_15).<JavaElement>end(END_VALUE);																// --
-		StateTree<JavaElement> value_q31 = value_q22.then(LAMBDA_16);
-		value_q31.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// /
-		value_q31.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// /=
-		StateTree<JavaElement> value_q32 = value_q22.then(LAMBDA_17);
-		value_q32.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// *
-		value_q32.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// *=
-		StateTree<JavaElement> value_q33 = value_q22.then(LAMBDA_18);
-		value_q33.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// &
-		value_q33.then(LAMBDA_18).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// &&
-		value_q33.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// &=
-		StateTree<JavaElement> value_q34 = value_q22.then(LAMBDA_19);
-		value_q34.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// |
-		value_q34.then(LAMBDA_19).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// ||
-		value_q34.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// |=
-		StateTree<JavaElement> value_q35 = value_q22.then(LAMBDA_20);
-		value_q35.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// ^
-		value_q35.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// ^=
-		StateTree<JavaElement> value_q36 = value_q22.then(LAMBDA_21);
-		value_q36.then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);							// %
-		value_q36.then(LAMBDA_8).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).<JavaElement>end(END_BIVALUE);			// %=
-		StateTree<JavaElement> value_q1 = value_q0.then(LAMBDA_name);
-		StateTree<JavaElement> value_q12 = value_q1.then(LAMBDA_23);
-		StateTree<JavaElement> value_q13 = value_q12.then(new RedirectStateTree<>(value_q0,(bag) -> "?"));
-		StateTree<JavaElement> value_q15 = value_q13.then(LAMBDA_24);
-		value_q15.<JavaElement>end(END_VALUE).then(value_q22);
-		value_q12.then(value_q15);
-		StateTree<JavaElement> value_q14 = value_q13.then(LAMBDA_7);
-		value_q14.then(value_q13);
-		value_q1.<JavaElement>end(END_VALUE).then(value_q22);
-		StateTree<JavaElement> value_q11 = value_q1.then(LAMBDA_25);
-		value_q11.then(value_q1);
-		value_q0.then(LAMBDA_23).then(new RedirectStateTree<>(value_q0,(bag) -> "?")).then(LAMBDA_24).<JavaElement>end(END_VALUE).then(value_q22);
-		value_q0.then(LAMBDA_26).then(LAMBDA_27).then(LAMBDA_26).<JavaElement>end(END_VALUE).then(value_q22);
-		value_q0.then(LAMBDA_28).then(LAMBDA_29).then(LAMBDA_28).<JavaElement>end(END_VALUE).then(value_q22);
-		return value_q0;
-	}
-	
-}

src/be/jeffcheasey88/peeratcode/parser/java/Operation.java

@@ -1,11 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-
-public class Operation extends JavaElement{
-	
-	public Operation(Bag bag){
-		
-	}
-
-}

src/be/jeffcheasey88/peeratcode/parser/java/Value.java

@@ -1,41 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.Token;
-
-public class Value extends JavaElement{
-
-	private Token token;
-	
-	protected Value(){}
-	
-	public Value(Bag bag){
-		this.token = bag.get();
-		System.out.println("NEW value "+token);
-	}
-	
-	@Override
-	public String toString(){
-		return "[Value="+token+"]";
-	}
-	
-	public static class BiValue extends Value{
-		
-		private Value left;
-		private Value right;
-		
-		public BiValue(Value left, Value right){
-			this.left = left;
-			this.right = right;
-			System.out.println("NEW BiValue "+left+"|"+right);
-		}
-		
-	}
-	
-	public static class TriValue extends Value{
-		
-		public TriValue(Bag bag){
-			super(bag);
-		}
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/java/Variable.java

@@ -1,15 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.java;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-
-public class Variable extends JavaElement{
-
-	private List<Annotation> annotations;
-	
-	public Variable(Bag bag){
-		this.annotations = new ArrayList<>();
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java

@@ -1,26 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.state;
-
-import java.util.function.BiFunction;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.TokenValidator;
-
-public class BuilderStateTree<E, B> extends StateTree<B>{
-	
-	private BiFunction<E, TokenValidator, B> builder;
-
-	public BuilderStateTree(BiFunction<E, TokenValidator, B> builder){
-		super();
-		this.builder = builder;
-	}
-	
-	B build(TokenValidator validator, E element){
-		B build = this.builder.apply(element, validator.pullValidated());
-		validator.pushValidated();
-		validator.setBag(new Bag());
-		
-		super.internalSeed(validator, build);
-		
-		return build;
-	}
-}

src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java

@@ -1,44 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.state;
-
-import java.util.function.Function;
-
-import be.jeffcheasey88.peeratcode.parser.Bag;
-import be.jeffcheasey88.peeratcode.parser.TokenValidator;
-
-public class RedirectStateTree<E, T extends E> extends StateTree<T>{
-	
-	private StateTree<E> redirect;
-	private Function<Bag, String> group;
-
-	public RedirectStateTree(StateTree<E> redirect, Function<Bag, String> group){
-		super();
-		this.redirect = redirect;
-		this.group = group;
-	}
-	
-	@Override
-	<B> B internalSeed(TokenValidator validator, T element){
-		Bag currentBag = validator.getBag();
-		Bag localBag = new Bag();
-		
-		String g = group.apply(currentBag);
-		System.out.println("redirect "+g);
-		currentBag.set(g, localBag);
-		validator.setBag(localBag);
-		
-		TokenValidator branch = validator.branch();
-		branch.validate((t) -> {
-			System.out.println(t);
-			return false;
-		});
-		Object builded = redirect.internalSeed(branch, (E) element);
-//		System.out.println("redirect builded "+builded);
-		if(builded == null) return null;
-		
-		validator.merge(branch);
-		validator.setBag(currentBag);
-		
-		return super.internalSeed(validator, element);
-	}
-}
-

src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java

@@ -1,78 +0,0 @@
-package be.jeffcheasey88.peeratcode.parser.state;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-import be.jeffcheasey88.peeratcode.parser.Token;
-import be.jeffcheasey88.peeratcode.parser.TokenValidator;
-import be.jeffcheasey88.peeratcode.parser.Tokenizer;
-
-public class StateTree<E>{
-	
-	private List<StateTree<E>> childs;
-	
-	Function<TokenValidator, Boolean> checker;
-	private BuilderStateTree<E, ?> builder;
-	
-	public StateTree(){
-		this.childs = new ArrayList<>();
-	}
-	
-	public void seed(Tokenizer tokenizer, E container){
-		TokenValidator validator = new TokenValidator(tokenizer.getTokens().toArray(new Token[0]));
-		while(validator.hasNext()) {
-			System.out.println("seed");
-			E build = internalSeed(validator, container);
-			if(build == null) break;
-		}
-	}
-	
-	<B> B internalSeed(TokenValidator validator, E element){
-		for(StateTree<E> child : this.childs){
-			TokenValidator branch = validator.branch();
-			if(child.checker == null){
-				E builded = child.internalSeed(branch, element);
-				if(builded != null){
-					validator.merge(branch);
-					return (B) builded;
-				}
-				continue;
-			}
-			if(child.checker.apply(branch)){
-				E builded = child.internalSeed(branch, element);
-				if(builded != null){
-					validator.merge(branch);
-					return (B) builded;
-				}
-			}
-		}
-		if(this.builder != null) return (B) this.builder.build(validator, element);
-		return null;
-	}
-
-	public <T extends StateTree<E>> StateTree<E> then(StateTree<E> child){
-		childs.add(child);
-		return child;
-	}
-	
-	public <T extends StateTree<E>> StateTree<E> then(Function<TokenValidator, Boolean> checker){
-		StateTree<E> state = new StateTree<>();
-		state.checker = checker;
-		this.childs.add(state);
-		return state;
-	}
-	
-	public <T extends StateTree<E>> StateTree<E> loop(){
-		this.childs.add(this);
-		return this;
-	}
-	
-	public <B> StateTree<B> end(BiFunction<E, TokenValidator, B> builder){
-		BuilderStateTree<E, B> builderState = new BuilderStateTree<>(builder);
-		this.builder = builderState;
-		return builderState;
-	}
-	
-}

src/dev/peerat/parser/Bag.java

@@ -0,0 +1,67 @@
+package dev.peerat.parser;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class Bag{
+	
+	private Map<String, Object> map;
+	
+	private Object value;
+	
+//	private String path = "";
+	
+	public Bag(){
+		this.map = new HashMap<>();
+//		path = Thread.currentThread().getStackTrace()[2].toString();
+	}
+	
+	public Bag(Bag bag){
+		this.map = new HashMap<>(bag.map);
+		this.value = bag.value;
+//		this.path = bag.path;
+	}
+	
+	public <E> E get(){
+		return (E) this.value;
+	}
+	
+//	public void addPath(String s){
+//		path+=s;
+//	}
+//	
+//	public String path(){
+//		return this.path;
+//	}
+	
+	public void set(Object value){
+		this.value = value;
+	}
+	
+	public <E> E get(String key){
+		return (E) this.map.get(key);
+	}
+	
+	public boolean has(String key){
+		return this.map.containsKey(key);
+	}
+	
+	public void remove(String key){
+		this.map.remove(key);
+	}
+	
+	public void set(String key, Object value){
+		this.map.put(key, value);
+//		System.out.println("edit Bag "+this);
+	}
+	
+	@Override
+	public String toString(){
+		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 "+hashCode()+"] "+(value != null ? "| value="+value+" ":"")+"| map["+Arrays.toString(this.map.keySet().toArray())+"]="+map+" )";
+	}
+}

src/dev/peerat/parser/Parser.java

@@ -0,0 +1,60 @@
+package dev.peerat.parser;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+
+import dev.peerat.parser.state.StateTree;
+
+public class Parser<E>{
+
+	private Tokenizer tokenizer;
+	private StateTree<E> state;
+	
+	public Parser(){}
+	
+	public void setTokenizer(Tokenizer tokenizer){
+		this.tokenizer = tokenizer;
+	}
+	
+	public void setStateTree(StateTree<E> stateTree){
+		this.state = stateTree;
+	}
+	
+	public final TokenValidator parse(BufferedReader reader, E container) throws Exception{
+		this.tokenizer.reset();
+		this.tokenizer.parse(reader);
+		TokenValidator validator = new TokenValidator(tokenizer.getTokens().toArray(new Token[0]));
+		this.state.seed(validator, container);
+		return validator;
+	}
+	
+	public final TokenValidator parse(String line, E container) throws Exception{
+		this.tokenizer.reset();
+		this.tokenizer.parse(line);
+		TokenValidator validator = new TokenValidator(tokenizer.getTokens().toArray(new Token[0]));
+		this.state.seed(validator, container);
+		return validator;
+	}
+	
+	//tmp
+	public void build(BufferedWriter writer, TokenValidator validator) throws Exception{
+		Token[] confirmed = new Token[validator.getTokenCount()];
+		System.arraycopy(tokenizer.getTokens().toArray(), 0, confirmed, 0, confirmed.length);
+		int line = 1;
+		int character = 1;
+		for(Token token : confirmed){
+			while(token.getLineNumber() != line){
+				writer.write("\n"+(++line));
+				character = 1;
+			}
+			while(token.getCharacterNumber() != character){
+				writer.write(" ");
+				character++;
+			}
+			writer.write(token.getValue());
+			character+=token.getValue().length();
+		}
+		writer.flush();
+		writer.close();
+	}
+}

src/dev/peerat/parser/SyntaxMissMatchException.java

@@ -0,0 +1,27 @@
+package dev.peerat.parser;
+
+public class SyntaxMissMatchException extends Exception{
+	
+	private static final long serialVersionUID = -635419322226790786L;
+	
+	private TokenValidator validator;
+	
+	public SyntaxMissMatchException(TokenValidator validator){
+		this.validator = validator;
+	}
+
+	@Override
+	public String getMessage(){
+		return "Only "+validator.getValidatedTokenCount()+" out "+validator.getTokenCount()+" of tokens parsed !";
+	}
+	
+	public String locateEndOfParsing(){
+		int last = validator.getValidatedTokenCount();
+		return "Last Token Validated: "+validator.getToken(last).toString()+" near to "+getTokenValue(last-2)+" "+getTokenValue(last-1)+" "+getTokenValue(last)+" "+getTokenValue(last+1)+" "+getTokenValue(last+2);
+	}
+	
+	private String getTokenValue(int index){
+		if(index < 0 || index >= validator.getTokenCount()) return "";
+		return validator.getToken(index).getValue();
+	}
+}

src/dev/peerat/parser/Token.java

@@ -1,4 +1,4 @@
-package be.jeffcheasey88.peeratcode.parser;
+package dev.peerat.parser;
 
 public class Token{
 	
@@ -36,6 +36,32 @@ public class Token{
 		return new Token(line, character, value+token.getValue(), TokenType.GROUP);
 	}
 	
+	void setLine(int value){
+		this.line = value;
+	}
+	
+	void setCharacter(int value){
+		this.character = value;
+	}
+	
+	void setValue(String value){
+		this.value = value;
+	}
+	
+	void setType(TokenType value){
+		this.type = value;
+	}
+	
+	@Override
+	public boolean equals(Object obj){
+		if(obj == null) return false;
+		if(obj instanceof Token){
+			Token token = (Token)obj;
+			return this.line == token.line && this.character == token.character && ((this.value == null && token.value == null) || (this.value.equals(token.value))) && this.type.equals(token.type);
+		}
+		return false;
+	}
+	
 	@Override
 	public String toString(){
 		return "Token["+line+";"+character+";"+type+";"+value+"]";

src/dev/peerat/parser/TokenType.java

@@ -1,10 +1,12 @@
-package be.jeffcheasey88.peeratcode.parser;
+package dev.peerat.parser;
 
 public enum TokenType{
 	
 	NAME,
 	DELIMITER,
 	SPACE,
-	GROUP
+	GROUP,
+	STRING,
+	CHAR
 	
 }

src/dev/peerat/parser/TokenUpdater.java

@@ -0,0 +1,84 @@
+package dev.peerat.parser;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.Consumer;
+
+public class TokenUpdater{
+	
+	private Map<Token, Consumer<Token>> map;
+	private Token[] tokens;
+	
+	//tmp
+	public TokenUpdater(){
+		this.map = new HashMap<>();
+	}
+	
+	public TokenUpdater(Token[] tokens){
+		this.map = new HashMap<>();
+		this.tokens = tokens;
+	}
+	
+	public void setValue(Token token, String value){
+		Consumer<Token> consumer = (current) -> current.setValue(value);
+		Consumer<Token> current = this.map.get(token);
+		map.put(token, current == null ? consumer : current.andThen(consumer));
+	}
+	
+	public void setType(Token token, TokenType value){
+		Consumer<Token> consumer = (current) -> current.setType(value);
+		Consumer<Token> current = this.map.get(token);
+		map.put(token, current == null ? consumer : current.andThen(consumer));
+	}
+	
+	public void setLine(Token token, int value){
+		Consumer<Token> consumer = (current) -> current.setLine(value);
+		Consumer<Token> current = this.map.get(token);
+		map.put(token, current == null ? consumer : current.andThen(consumer));
+	}
+	
+	public void setCharacter(Token token, int value){
+		Consumer<Token> consumer = (current) -> current.setCharacter(value);
+		Consumer<Token> current = this.map.get(token);
+		map.put(token, current == null ? consumer : current.andThen(consumer));
+	}
+	
+	public void pushUpdates(){
+		
+		//tmp
+		if(this.tokens == null){
+			for(Entry<Token, Consumer<Token>> entry : this.map.entrySet()) entry.getValue().accept(entry.getKey());
+			return;
+		}
+		
+		for(int index = 0; index < this.tokens.length; index++){
+			Token token = this.tokens[index];
+			Consumer<Token> consumer = this.map.remove(token);
+			if(consumer != null){
+				int line = token.getLineNumber();
+				int character = token.getCharacterNumber();
+				String value = token.getValue();
+				consumer.accept(token);
+				
+				if(token.getLineNumber() != line){
+					int dif = token.getLineNumber()-line;
+					for(int next = index+1; next < this.tokens.length; next++){
+						Token update = this.tokens[next];
+						if(update.getLineNumber() < line) break;
+						update.setLine(update.getLineNumber()+dif);
+					}
+				}
+				if(token.getCharacterNumber() != character || value.length() != token.getValue().length()){
+					int dif = ((token.getCharacterNumber()+token.getValue().length())-(character+value.length()));
+					for(int next = index+1; next < this.tokens.length; next++){
+						Token update = this.tokens[next];
+						if(update.getLineNumber() > line) break;
+						update.setCharacter(update.getCharacterNumber()+dif);
+					}
+				}
+			}
+		}
+		//warn -> if map not empty -> tried to update non-tracked token, like group on concat,...
+	}
+}

src/dev/peerat/parser/TokenValidator.java

@@ -0,0 +1,81 @@
+package dev.peerat.parser;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+public class TokenValidator{
+	
+	private Token[] elements;
+	private int validated;
+	
+	private Bag bag;
+	
+	private TokenValidator(Bag bag){
+		this.bag = bag;
+	}
+	
+	public TokenValidator(Token[] elements){
+		this.elements = elements;
+		this.bag = new Bag();
+	}
+	
+	public int getTokenCount(){
+		return this.elements.length;
+	}
+	
+	public int getValidatedTokenCount(){
+		return this.validated;
+	}
+	
+	public TokenUpdater toUpdater(){
+		return new TokenUpdater(elements);
+	}
+	
+	
+	//NO NEED FOR TREE !
+	Token getToken(int index){
+		return this.elements[index];
+	}
+	
+	public boolean hasNext(){
+		return validated < elements.length;
+	}
+	
+	public boolean validate(Function<Token, Boolean> action){
+		if(validated >= this.elements.length) return false;
+		if(action.apply(this.elements[validated])){
+			this.validated++;
+			return true;
+		}
+		return false;
+	}
+	
+	public boolean validate(Function<Token, Boolean> action, BiConsumer<Bag, Token> filler){
+		if(validate(action)){
+			filler.accept(bag, elements[validated-1]);
+			return true;
+		}
+		return false;
+	}
+	
+	public TokenValidator branch(){
+		TokenValidator branch = new TokenValidator(bag);
+		branch.elements = this.elements;
+		branch.validated = this.validated;
+		return branch;
+	}
+	
+	public void merge(TokenValidator branch){
+		this.validated = branch.validated;
+		this.bag = branch.bag;
+	}
+	
+	public void setBag(Bag bag){
+		this.bag = bag;
+	}
+	
+	public Bag getBag(){
+		return this.bag;
+	}
+	
+}

src/dev/peerat/parser/Tokenizer.java

@@ -1,4 +1,4 @@
-package be.jeffcheasey88.peeratcode.parser;
+package dev.peerat.parser;
 
 import java.io.BufferedReader;
 import java.util.ArrayList;
@@ -29,6 +29,10 @@ public class Tokenizer {
 		return this.tokens;
 	}
 	
+	public void reset(){
+		this.tokens.clear();
+	}
+	
 	public void parse(BufferedReader reader) throws Exception{
 		int lineNumber = 0;
 		String line;
@@ -68,4 +72,37 @@ public class Tokenizer {
 		if(this.postProcessor != null) this.postProcessor.accept(tokens);
 	}
 	
+	public void parse(String line){
+		if(this.postProcessor != null) this.postProcessor.accept(tokens);
+		
+		for(int i = 0; i < line.length(); i++){
+			char c = line.charAt(i);
+			Token token;
+			if(Character.isAlphabetic(c) || Character.isDigit(c) || c == '_' || c == '$'){
+				String value = "";
+				int j = i;
+				for(; j < line.length(); j++){
+					c = line.charAt(j);
+					if(Character.isAlphabetic(c) || Character.isDigit(c) || c == '_' || c == '$') value+=c;
+					else break;
+				}
+				token = new Token(1, i+1, value, TokenType.NAME);
+				i = j-1;
+			}else if(Character.isWhitespace(c)){
+				if(!optionSpace) continue;
+				String value = "";
+				int j = i;
+				for(; j < line.length(); j++){
+					c = line.charAt(j);
+					if(!Character.isWhitespace(c)) break;
+				}
+				token = new Token(1, i+1, value, TokenType.SPACE);
+				i = j-1;
+			}else{
+				token = new Token(1, i+1, ""+c, TokenType.DELIMITER);
+			}
+			this.tokens.add(token);
+		}
+	}
+	
 }

src/dev/peerat/parser/java/Annotation.java

@@ -0,0 +1,136 @@
+package dev.peerat.parser.java;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Annotation implements JavaElement{
+	
+	public static interface AnnotableBuffer{
+		
+		void addAnnotationBuffer(Annotation annotation);
+		
+		List<Annotation> getAnnotationBuffer();
+		
+	}
+	
+	public static abstract class Annotable implements JavaElement{
+		
+		private List<Annotation> annotations;
+		
+		public Annotable(List<Annotation> annotations){
+			this.annotations = annotations;
+		}
+		
+		public List<Annotation> getAnnotations(){
+			return this.annotations;
+		}
+		
+		public Annotation findAnnotation(Function<Annotation, Boolean> finder){
+			if(annotations != null){
+				for(Annotation annotation : this.annotations){
+					if(finder.apply(annotation)) return annotation;
+				}
+			}
+			return null;
+		}
+		
+		public boolean hasAnnotation(Function<Annotation, Boolean> finder){
+			if(annotations != null){
+				for(Annotation annotation : this.annotations){
+					if(finder.apply(annotation)) return true;
+				}
+			}
+			return false;
+		}
+		
+		@Override
+		public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+			if(annotations != null){
+				for(Annotation annotation : this.annotations){
+					if(finder.test(annotation)) return (E) annotation;
+				}
+			}
+			return null;
+		}
+		
+		@Override
+		public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+			if(annotations != null){
+				for(Annotation annotation : this.annotations){
+					if(finder.test(annotation)) collector.add((E) annotation);
+					annotation.findAll(finder, collector);
+				}
+			}
+		}
+	}
+	
+	private Token name;
+	private Map<Token, Value> values; //TODO works with key null ?
+	
+	public Annotation(Token name){
+		this.name = name;
+	}
+	
+	public Annotation(Token name, Map<Token, Value> values){
+		this(name);
+		this.values =  values;
+	}
+	
+	public Token getName(){
+		return name;
+	}
+	
+	public Map<Token, Value> getParameters(){
+		return this.values;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(this.values != null){
+			for(Value value : this.values.values()){
+				if(finder.test(value)) return (E)value;
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(this.values != null){
+			for(Value value : this.values.values()){
+				if(finder.test(value)) collector.add((E)value);
+				value.findAll(finder, collector);
+			}
+		}
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		if(this.values != null)
+			for(Value value : this.values.values()){
+				bag.merge(value.visit(visitor));
+			}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

src/dev/peerat/parser/java/AnnotationClass.java

@@ -0,0 +1,92 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class AnnotationClass extends ClassBase{
+	
+	private Token extend; //TODO verify?
+	
+	private List<JavaElement> elements;
+	
+	public AnnotationClass(List<Annotation> annotations, int mod, Token name){
+		super(annotations, mod, name);
+		this.elements = new ArrayList<>();
+	}
+	
+	@Override
+	public void addFunction(Function function) {
+		this.elements.add(function);
+	}
+
+	@Override
+	public void addVariable(Variable variable) {
+		this.elements.add(variable);
+	}
+
+	@Override
+	public void addClass(ClassBase clazz){
+		this.elements.add(clazz);
+	}
+	
+	public Token getExtension(){
+		return this.extend;
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) return (E) element;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) collector.add((E) element);
+				element.findAll(finder, collector);
+			}
+		}
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		bag.merge(super.visit(visitor));
+		
+		for(JavaElement element : this.elements){
+			bag.merge(element.visit(visitor));
+		}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,104 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Class extends ClassBase{
+	
+	private Token extend;
+	private Token implement;
+	
+	private List<JavaElement> elements;
+	
+	public Class(List<Annotation> annotations, int mod, Token name){
+		super(annotations, mod, name);
+		this.elements = new ArrayList<>();
+	}
+	
+	public Class(List<Annotation> annotations, int mod, Token name, Token extend, Token implement){
+		this(annotations, mod, name);
+		this.extend = extend;
+		this.implement = implement;
+	}
+
+	@Override
+	public void addFunction(Function function) {
+		this.elements.add(function);
+	}
+
+	@Override
+	public void addVariable(Variable variable) {
+		this.elements.add(variable);
+	}
+
+	@Override
+	public void addClass(ClassBase clazz){
+		this.elements.add(clazz);
+	}
+	
+	public Token getExtension(){
+		return this.extend;
+	}
+	
+	public Token getImplementations(){
+		return this.implement;
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) return (E) element;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) collector.add((E) element);
+				element.findAll(finder, collector);
+			}
+		}
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		VisitorBag bag = super.visit(visitor);
+		if(!bag.isValidated()){
+			if(visitor.canVisit(getClass())){
+				bag.merge(visitor.visit(this));
+				if(!visitor.canPropagate()) return bag;
+			}
+		}
+		
+		for(JavaElement element : this.elements){
+			bag.merge(element.visit(visitor));
+		}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,63 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.Annotable;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.Function.FunctionContainer;
+import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+
+public abstract class ClassBase extends Annotable implements AnnotableBuffer, ClassContainer, FunctionContainer, VariableContainer{
+	
+	
+	private List<Annotation> annotationBuffer;
+
+	private int mod;
+	private Token name;
+	
+	public ClassBase(List<Annotation> annotations, int mod, Token name){
+		super(annotations);
+		this.mod = mod;
+		this.name = name;
+	}
+	
+	public int getModifier(){
+		return this.mod;
+	}
+	
+	public Token getName(){
+		return this.name;
+	}
+	
+	@Override
+	public void addAnnotationBuffer(Annotation annotation){
+		if(annotationBuffer == null) annotationBuffer = new ArrayList<>();
+		annotationBuffer.add(annotation);
+	}
+	
+	public List<Annotation> getAnnotationBuffer(){
+		List<Annotation> list = this.annotationBuffer;
+		this.annotationBuffer = null;
+		return list;
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.merge(annotation.visit(visitor));
+			}
+		return bag;
+	}
+}

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/Enumeration.java

@@ -0,0 +1,98 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Enumeration extends ClassBase{
+	
+	private Token extend;
+	
+	private List<JavaElement> elements;
+	
+	public Enumeration(List<Annotation> annotations, int mod, Token name){
+		super(annotations, mod, name);
+		this.elements = new ArrayList<>();
+	}
+	
+	public Enumeration(List<Annotation> annotations, int mod, Token name, Token extend){
+		this(annotations, mod, name);
+		this.extend = extend;
+	}
+
+	@Override
+	public void addFunction(Function function) {
+		this.elements.add(function);
+	}
+
+	@Override
+	public void addVariable(Variable variable) {
+		this.elements.add(variable);
+	}
+
+	@Override
+	public void addClass(ClassBase clazz){
+		this.elements.add(clazz);
+	}
+	
+	public Token getExtension(){
+		return this.extend;
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) return (E) element;
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) collector.add((E) element);
+				element.findAll(finder, collector);
+			}
+		}
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		bag.merge(super.visit(visitor));
+		
+		for(JavaElement element : this.elements){
+			bag.merge(element.visit(visitor));
+		}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,169 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.Annotable;
+import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.operation.Operation;
+import dev.peerat.parser.java.operation.Operation.OperationContainer;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.Value.ValueContainer;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Function extends Annotable implements VariableContainer, OperationContainer, ValueContainer{
+	
+	public static interface FunctionContainer{
+		
+		void addFunction(Function function);
+		
+	}
+	
+	private int mod;
+	private Token generic;
+	private Token type;
+	private Token name;
+	private List<Variable> parameters;
+	private List<Token> throwables;
+	
+	private List<JavaElement> elements;
+	
+	public Function(List<Annotation> annotations, int mod, Token type, Token name){
+		super(annotations);
+		this.mod = mod;
+		this.type = type;
+		this.name = name;
+		this.elements = new ArrayList<>();
+	}
+	
+	public Function(List<Annotation> annotations, int mod, Token generic, Token type, Token name){
+		this(annotations, mod, type, name);
+		this.generic = generic;
+	}
+	
+	public Function(List<Annotation> annotations, int mod, Token generic, Token type, Token name, List<Variable> parameters){
+		this(annotations, mod, generic, type, name);
+		this.parameters = parameters;
+	}
+	
+	public Function(List<Annotation> annotations, int mod, Token generic, Token type, Token name, List<Variable> parameters, List<Token> throwables){
+		this(annotations, mod, generic, type, name, parameters);
+		this.throwables = throwables;
+	}
+
+	@Override
+	public void addVariable(Variable variable) {
+		this.elements.add(variable);
+	}
+
+	@Override
+	public void addOperation(Operation operation) {
+		this.elements.add(operation);
+	}
+	
+	@Override
+	public void addValue(Value value) {
+		this.elements.add(value);
+	}
+	
+	public int getModifier(){
+		return this.mod;
+	}
+	
+	public Token getGeneric(){
+		return this.generic;
+	}
+	
+	public Token getReturnType(){
+		return this.type;
+	}
+	
+	public Token getName(){
+		return this.name;
+	}
+	
+	public List<Variable> getParameters(){
+		return this.parameters;
+	}
+	
+	public List<Token> getThrowables(){
+		return this.throwables;
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		if(parameters != null){
+			for(Variable param : this.parameters){
+				if(finder.test(param)) return (E) param;
+			}
+		}
+		if(elements != null){
+			for(JavaElement content : this.elements){
+				if(finder.test(content)) return (E) content;
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(parameters != null){
+			for(Variable param : this.parameters){
+				if(finder.test(param)) collector.add((E) param);
+				param.findAll(finder, collector);
+			}
+		}
+		if(elements != null){
+			for(JavaElement content : this.elements){
+				if(finder.test(content)) collector.add((E) content);
+				content.findAll(finder, collector);
+			}
+		}
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.merge(annotation.visit(visitor));
+			}
+		
+		if(this.parameters != null)
+			for(Variable variable : this.parameters){
+				bag.merge(variable.visit(visitor));
+			}
+		
+		for(JavaElement element : this.elements){
+			bag.merge(element.visit(visitor));
+		}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		if(this.generic != null) bag.merge(visitor.visit(this.generic));
+		bag.merge(visitor.visit(this.type));
+		bag.merge(visitor.visit(this.name));
+		return bag;
+	}
+}

src/dev/peerat/parser/java/Import.java

@@ -0,0 +1,54 @@
+package dev.peerat.parser.java;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Import implements JavaElement{
+	
+	private boolean isStatic;
+	private Token value;
+	
+	public Import(boolean isStatic, Token value){
+		this.isStatic = isStatic;
+		this.value = value;
+	}
+	
+	public boolean isStatic(){
+		return this.isStatic;
+	}
+	
+	public Token getValue(){
+		return this.value;
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return new VisitorBag();
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

src/dev/peerat/parser/java/Interface.java

@@ -0,0 +1,95 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Interface extends ClassBase{
+	
+	private Token extend;
+	
+	private List<JavaElement> elements;
+	
+	public Interface(List<Annotation> annotations, int mod, Token name){
+		super(annotations, mod, name);
+		this.elements = new ArrayList<>();
+	}
+	
+	public Interface(List<Annotation> annotations, int mod,  Token name, Token extend){
+		this(annotations, mod, name);
+		this.extend = extend;
+	}
+
+	@Override
+	public void addFunction(Function function) {
+		this.elements.add(function);
+	}
+
+	@Override
+	public void addVariable(Variable variable) {
+		this.elements.add(variable);
+	}
+
+	@Override
+	public void addClass(ClassBase clazz){
+		this.elements.add(clazz);
+	}
+	
+	public Token getExtension(){
+		return this.extend;
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) return (E) element;
+			}
+		}
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) collector.add((E) element);
+				element.findAll(finder, collector);
+			}
+		}
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		bag.merge(super.visit(visitor));
+		
+		for(JavaElement element : this.elements) bag.merge(element.visit(visitor));
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,19 @@
+package dev.peerat.parser.java;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public interface JavaElement{
+	
+	<E extends JavaElement> E find(Predicate<JavaElement> finder);
+	
+	<E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector);
+
+	VisitorBag visit(Visitor<JavaElement> visitor);
+	
+	VisitorBag visit(TokenVisitor visitor);
+}

src/dev/peerat/parser/java/JavaFile.java

@@ -0,0 +1,121 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.AnnotableBuffer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class JavaFile implements JavaElement, ClassContainer, AnnotableBuffer{
+	
+	private List<Annotation> annotationBuffer;
+	
+	private Token pack;
+	private List<Import> imports;
+	private ClassBase mainClazz;
+	private List<ClassBase> subClazz;
+	
+	public JavaFile(){
+		this.imports = new ArrayList<>();
+		this.subClazz = new ArrayList<>();
+	}
+	
+	public void setPackage(Token token){
+		this.pack = token;
+	}
+	
+	public void addImport(Import value){
+		this.imports.add(value);
+	}
+	
+	@Override
+	public void addClass(ClassBase clazz){
+		if(mainClazz == null) this.mainClazz = clazz;
+		else subClazz.add(clazz);
+	}
+	
+	public Token getPackage(){
+		return this.pack;
+	}
+	
+	public List<Import> getImports(){
+		return this.imports;
+	}
+	
+	public ClassBase getMainClass(){
+		return this.mainClazz;
+	}
+	
+	public List<ClassBase> getSubClasses(){
+		return this.subClazz;
+	}
+	
+	@Override
+	public void addAnnotationBuffer(Annotation annotation){
+		if(annotationBuffer == null) annotationBuffer = new ArrayList<>();
+		annotationBuffer.add(annotation);
+	}
+	
+	public List<Annotation> getAnnotationBuffer(){
+		List<Annotation> list = this.annotationBuffer;
+		this.annotationBuffer = null;
+		return list;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(finder.test(mainClazz)) return (E) mainClazz;
+		for(ClassBase clazz : subClazz){
+			if(finder.test(clazz)) return (E) clazz;
+		}
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(mainClazz)) collector.add((E) mainClazz);
+		mainClazz.findAll(finder, collector);
+		for(ClassBase clazz : subClazz){
+			if(finder.test(clazz)) collector.add((E) clazz);
+			clazz.findAll(finder, collector);
+		}
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		VisitorBag bag;
+		if(visitor.canVisit(getClass())){
+			bag = visitor.visit(this);
+			if(!visitor.canPropagate()) return bag;
+		}else bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		if(this.imports != null)
+			for(Import imp : this.imports){
+				bag.merge(imp.visit(visitor));
+			}
+		
+		bag.merge(mainClazz.visit(visitor));
+		
+		if(this.subClazz != null)
+			for(ClassBase clazz : this.subClazz){
+				bag.merge(clazz.visit(visitor));
+			}
+		
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+	
+}

src/dev/peerat/parser/java/JavaParser.java

@@ -0,0 +1,460 @@
+package dev.peerat.parser.java;
+
+import dev.peerat.parser.Parser;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.tree.AnnotationClassTree;
+import dev.peerat.parser.java.tree.AnnotationTree;
+import dev.peerat.parser.java.tree.ClassBaseTree;
+import dev.peerat.parser.java.tree.ClassContainerTree;
+import dev.peerat.parser.java.tree.ClassTree;
+import dev.peerat.parser.java.tree.EnumTree;
+import dev.peerat.parser.java.tree.EnumValueTree;
+import dev.peerat.parser.java.tree.FunctionContainerTree;
+import dev.peerat.parser.java.tree.FunctionTree;
+import dev.peerat.parser.java.tree.GenericTree;
+import dev.peerat.parser.java.tree.ImportTree;
+import dev.peerat.parser.java.tree.InterfaceTree;
+import dev.peerat.parser.java.tree.JavaTree;
+import dev.peerat.parser.java.tree.JavaTreeType;
+import dev.peerat.parser.java.tree.ModifierTree;
+import dev.peerat.parser.java.tree.OperationTree;
+import dev.peerat.parser.java.tree.TypeTree;
+import dev.peerat.parser.java.tree.ValueTree;
+import dev.peerat.parser.java.tree.VariableTree;
+import dev.peerat.parser.state.InitialStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class JavaParser extends Parser<JavaElement>{
+	
+	
+	//TODO
+	/**
+	 * Visitor:
+	 * 	All Visitor Types with all possible (wanted) queries
+	 * 	VisitorBag -> collecter ce qui doit être collecter only + 1 element, n elements, n pair d'element,...
+	 * 	VisitorBag -> validation de sous-ensemble, et non capture pour autant.
+	 * 	VisitorBag -> Operators
+	 * AST:
+	 * 	Terminer les arbres
+	 * 	Bind correctement tout (déplacer les noms & modifiers des classes dans ClassBase)
+	 * 	
+	 * 
+	 * 
+	 * Find a way to simplify the way of using the Tree, like Value..., without the need of casting, checking,... A Easy Way to Walk And Build.
+	 * Benchmark, check how to optimise. Like changing node order, capturing Token,...
+	 * Builder package -> look to only load what is needed ! (same for the whole program)
+	 * 
+	 * Review choice of implementation, is ArrayList a good choice for all case needed ? (spoiler : no), is null a good idea for some cases ? review it.
+	 * Check thr whole tree, match with current Java Version
+	 * 	Complete SwitchOperation
+	 * Do Generic interface for case, like a generic interface for Class, for exemple, InstanceValue can contains class, annotation, method, variable,...
+	 * Remove Value.ValueContainer class
+	 * Do All build, find and visitor for all JavaElement
+	 * 
+	 *
+	 */
+	
+//	public static void main(String[] args) throws Exception{
+//		Timing main = Timing.of();
+//	
+//		Parser<JavaElement> parser = new JavaParser();
+//		BufferedReader reader = new BufferedReader(new FileReader(new File("/tmp/example.txt")));
+//		
+//		Timing parse = Timing.of();
+//		JavaFile container = new JavaFile();
+//		parser.parse(reader, container);
+//		parse.takeTiming("[Parsing] %dms");
+//		System.out.println(TokenValidator.MAX_VALIDATE+" / "+TokenValidator.TOKENS+" ("+((TokenValidator.MAX_VALIDATE/(double)TokenValidator.TOKENS)*100.0)+"%)");
+//		
+//		reader.close();
+//		
+//		main.takeTiming("End with %dms");
+//		
+//		File out = new File("/tmp/dataObserve.txt");
+//		BufferedWriter writer = new BufferedWriter(new FileWriter(out));
+//		writer.write(TokenValidator.MAX_VALIDATE+" "+TokenValidator.TOKENS);
+//		writer.flush();
+//		writer.close();
+//	}
+	
+	static class Timing{
+		
+		public static Timing of(){
+			return new Timing();
+		}
+		
+		private long time;
+		
+		Timing(){
+			this.time = System.currentTimeMillis();
+		}
+		
+		void takeTiming(String text){
+			long result = System.currentTimeMillis()-time;
+			System.out.printf(text+"\n", result);
+		}
+	}
+	
+	
+	public JavaParser(){
+		this(JavaTreeType.ALL);
+	}
+	
+	public JavaParser(JavaTreeType level){
+		
+		Timing tRegistery = Timing.of();
+		
+		SyntaxTreeRegistery<JavaElement> registery = new SyntaxTreeRegistery<>();
+		registery.register(new ModifierTree(registery));
+		registery.register(new ImportTree(registery));
+		registery.register(new TypeTree(registery));
+		registery.register(new GenericTree(registery));
+		registery.register(new ValueTree(registery));
+		registery.register(new EnumValueTree(registery));
+		registery.register(new AnnotationTree(registery));
+		registery.register(new VariableTree(registery));
+		registery.register(new ClassContainerTree(registery));
+		registery.register(new FunctionContainerTree(registery));
+		registery.register(new OperationTree(registery));
+		registery.register(new FunctionTree(registery));
+		registery.register(new ClassBaseTree(registery));
+		registery.register(new ClassTree(registery));
+		registery.register(new InterfaceTree(registery));
+		registery.register(new EnumTree(registery));
+		registery.register(new AnnotationClassTree(registery));
+		registery.register(new JavaTree(registery));
+		
+		registery.init();
+		
+		tRegistery.takeTiming("[Registery] %dms");
+		Timing load = Timing.of();
+		
+//		//SUMMARY
+//		//- Import
+//		//- Package
+//		
+//
+////		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);
+//		
+//		//IMPORT
+//		StateTree<JavaElement> importState = new StateTree<>();
+//		importState.then((validator) -> {
+//			if(validator.validate(
+//					(token) -> token.getValue().equals("import"))){
+//				
+//				validator.validate(
+//						(token) -> token.getValue().equals("static"),
+//						(bag, token) -> bag.set("static", null));
+//				
+//				while(validator.validate(
+//						(token) -> !token.getValue().equals(";"),
+//						(bag, token) -> {
+//							Token current = bag.get();
+//							if(current == null) bag.set(token);
+//							else bag.set(current.concat(token));
+//						})
+//					);
+//				
+//				return validator.validate((token) -> token.getValue().equals(";"));
+//			}
+//			return false;
+//		}).<JavaElement>end((parent, bag) -> {
+//			((JavaFile)parent).addImport(new Import(bag.has("static"), bag.get()));
+//			return parent;
+//		});
+//
+//		
+//		InitialStateTree<JavaElement> main = new InitialStateTree<>();
+//		
+//		//PACKAGE
+//		StateTree<JavaElement> pack = main.then((validator) -> {	
+//			if(validator.validate(
+//					(token) -> token.getValue().equals("package"))){
+//				
+//				while(validator.validate(
+//						(token) -> !token.getValue().equals(";"),
+//						(bag, token) -> {
+//							Token current = bag.get();
+//							if(current == null) bag.set(token);
+//							else bag.set(current.concat(token));
+//						})
+//					);
+//				return validator.validate((token) -> token.getValue().equals(";"));
+//			}
+//			return false;
+//		}).end((parent, bag) -> {
+//			((JavaFile)parent).setPackage(bag);
+//			return parent;
+//		});
+//		main.multiple(pack);
+//		main.multiple(importState);
+////		main.multiple(annotation);
+////		main.multiple(clazz_);
+		
+		
+//		System.out.println((System.currentTimeMillis()-time)+"ms");
+		
+		setTokenizer(new JavaTokenizer());
+		setStateTree(registery.getNode(level.getType()));
+		
+		load.takeTiming("[load] %dms");
+	}
+	
+	
+	/*
+	 
+	 
+	 StateTree<JavaElement> value = new StateTree<>();
+		
+		StateTree<JavaElement> value_list = new StateTree<>();
+		StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value, (global, local) -> {
+			List<Value> list = global.get();
+			if(list == null){
+				list = new ArrayList<>();
+				global.set(list);
+			}
+			list.add(local.get());
+		}));
+		value_list_element.end();
+		value_list_element.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(value_list_element);
+		
+		value.then((validator) -> validator.validate(
+				(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
+				(bag, token) -> bag.set(token)))
+		.end((parent,bag) -> {
+			bag.set(new StaticValue(bag.<Token>get()));
+			return null;
+		});
+		
+		StateTree<JavaElement> value_instance = value.then((validator) -> validator.validate(
+				(token) -> token.getValue().equals("new"),
+				(bag, token) -> bag.set("newit", token)));
+		StateTree<JavaElement> value_name = new StateTree<JavaElement>();
+		value.then(value_name);
+		value_instance.then(new RedirectStateTree<>(value_name, (global, local) -> {
+			System.out.println(local.get()+"");
+			if(global.has("newit")) global.set(new InstanceValue(global.<Token>get("newit"), local.<MethodCallValue>get().getToken(), local.<MethodCallValue>get().getParameters()));
+			else global.set(local.get());
+		}))
+			.end((a,b) -> a)
+				.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+				.end((a,b) -> a)
+					.multiple(braces_container)
+					.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
+		value_name = value_name.then(new RedirectStateTree<>(type, (global, local) -> {
+			System.out.println("value_name {");
+			System.out.println("global: "+global);
+			System.out.println("local: "+local);
+			System.out.println("}");
+			if(global.get() == null) global.set(local.get());
+			else global.set(global.<Token>get().concat(local.get()));
+		}));
+		value_name.end((parent,bag) -> {
+			System.out.println("{value_name} "+bag);
+			Value result = new StaticValue(bag.<Token>get());
+			bag.set(result);
+			return null;
+		});
+		
+		value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(":")) && validator.validate((token) -> token.getValue().equals(":")))
+			.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
+			.end((a,b) -> a);
+		
+		StateTree<JavaElement> value_call = value_name.then((validator) -> validator.validate(
+				(token) -> token.getValue().equals("."),
+				(bag, token) -> {
+					Value prev = bag.get("prev");
+					if(prev == null){
+						bag.set("prev", new StaticValue(bag.<Token>get()));
+					}else{
+						Integer paramters = bag.get("args");
+						List<Value> list = null;
+						if(paramters != null){
+							list = new ArrayList<>();
+							for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
+							bag.remove("args");
+						}
+						MethodCallValue methodCall = new MethodCallValue(prev, bag.get("gen"), bag.get(), list);
+						bag.set("prev", methodCall);
+						bag.remove("gen");
+					}
+					bag.set(new Token(token.getLineNumber(), token.getCharacterNumber(), "", TokenType.GROUP));
+				}));
+		value_call.end((a,b) -> a);
+		value_call.then(new RedirectStateTree<>(gen, (global, local) -> global.set("gen", global.<Token>get().concat(local.get())))).then(value_name);
+		value_call.then(value_name);
+		StateTree<JavaElement> value_array_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
+		StateTree<JavaElement> value_array_end = value_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
+		value_array_begin.then(new RedirectStateTree<>(value, (global, local) -> global.set("inside", local)))
+			.then(value_array_end);
+		value_array_end.end((parent,bag) -> {
+			//to change
+			bag.set(new MethodCallValue(null, null, bag.get(), null));
+			return parent;
+		})
+			.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+			.end((a,b) -> a)
+				.multiple(value_list)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
+		value_array_end.then(value_call);
+		value_array_end.then(value_array_begin);
+		
+		StateTree<JavaElement> value_arg_begin = value_name.then((validator) -> validator.validate(
+				(token) -> token.getValue().equals("("),
+				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
+		StateTree<JavaElement> value_arg_end = value_arg_begin.then((validator) -> validator.validate(
+				(token) -> token.getValue().equals(")"),
+				(bag, token) -> bag.set(bag.<Token>get().concat(token))));
+		value_arg_end.end((parent,bag) -> {
+			Integer paramters = bag.get("args");
+			List<Value> list = null;
+			if(paramters != null){
+				list = new ArrayList<>();
+				for(int i = 0; i < paramters; i++) list.add(bag.<Bag>get("arg"+i).get());
+			}
+			
+			MethodCallValue methodCall = new MethodCallValue(bag.get("prev"), bag.get("gen"), bag.get(), list);
+			bag.set(methodCall);
+			return null;
+		});
+		value_arg_end.then(value_call);
+		value_arg_end.then(value_array_begin);
+		StateTree<JavaElement> value_generic_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("<")));
+		StateTree<JavaElement> value_generic_name = value_generic_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
+		StateTree<JavaElement> value_generic_split = value_generic_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
+		StateTree<JavaElement> value_generic_end = value_generic_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(">")));
+		value_generic_end.then(value_arg_begin);
+		value_generic_end.then(value_generic_name);
+		value_generic_end.then(value_generic_split);
+		value_generic_name.then(value_generic_begin);
+		value_generic_name.then(value_generic_end);
+		value_generic_split.then(value_generic_name);
+		StateTree<JavaElement> value_arg = value_arg_begin.then(new RedirectStateTree<>(value, (global, local) -> {
+			Integer count = global.get("args");
+			if(count == null) count = 0;
+			global.set("arg"+count, local);
+			global.set("args", (count+1));
+		}));
+		value_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(value_arg);
+		value_arg.then(value_arg_end);
+		
+		StateTree<JavaElement> value_left = new StateTree<>();
+		
+		StateTree<JavaElement> value_parenthesis = value.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
+		StateTree<JavaElement> value_cast = value_parenthesis.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
+			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
+			.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
+		value_cast.then(value_left);
+		StateTree<JavaElement> value_lambda_arg = value_parenthesis.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
+		value_lambda_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(value_lambda_arg);
+		StateTree<JavaElement> value_lambda = value_parenthesis.then((validator) ->
+			validator.validate((token) -> token.getValue().equals(")")) &&
+			validator.validate((token) -> token.getValue().equals("-")) &&
+			validator.validate((token) -> token.getValue().equals(">")));
+		value_lambda.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+			.<JavaElement>end((a,bag) -> {
+				bag.set(new LambdaValue(null, new ArrayList<>()));
+				return a;
+			})
+			.multiple(function_container)
+			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
+		value_lambda.then(new RedirectStateTree<>(value, (global, local) -> global.set("in", local.get()))).end((a,bag) ->{
+			bag.set(new LambdaValue(null, bag.<Value>get("in")));
+			return a;
+		});
+		value_lambda_arg.then(value_lambda);
+		StateTree<JavaElement> value_parenthesis_end = value_parenthesis.then(new RedirectStateTree<>(value, (global, local) -> global.set("left", local.get())))
+			.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
+		value_parenthesis_end.end();
+		value_parenthesis_end.then(value_call);
+		value_parenthesis_end.then(value_left);
+		value.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value);
+		value.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value);
+		value.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value);
+		value.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value);
+		StateTree<JavaElement> value_inside = value.then(new RedirectStateTree<>(value, (global, local) -> {
+			global.set("left", local.get());
+			System.out.println("value_inside "+global);
+		}));
+		value_inside.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("]")))
+			.then(value_left);
+		value_inside.then(value_left);
+		value_left.end((parent, bag) -> {
+			System.out.println("value_left -> end "+bag);
+			if(bag.get("left") instanceof Value) bag.set(bag.get("left"));
+			else bag.set(new StaticValue(bag.<Token>get("left")));
+			return null;
+		});
+		StateTree<JavaElement> value_equals = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=")));
+		value_equals.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_minus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), (bag, token) -> bag.set("action", "<"))).loop();
+		value_minus.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_max = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), (bag, token) -> bag.set("action", ">"))).loop();
+		value_max.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("!")) && validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "!="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_or = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "|")));
+		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "||"))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_or.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_and = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&")));
+		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&&"))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_and.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_plus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "+")));
+		value_plus.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "++"))).end(value_builder);
+		StateTree<JavaElement> value_min = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "-")));
+		value_min.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "--"))).end(value_builder);
+		StateTree<JavaElement> value_div = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("/"), (bag, token) -> bag.set("action", "/")));
+		value_div.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_mod = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("%"), (bag, token) -> bag.set("action", "%")));
+		value_mod.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_xor = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("^"), (bag, token) -> bag.set("action", "^")));
+		value_xor.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		StateTree<JavaElement> value_mult = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("*"), (bag, token) -> bag.set("action", "*")));
+		value_mult.then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value, value_right)).end(value_builder);
+		value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
+			.then(new RedirectStateTree<>(value, value_right))
+			.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
+			.then(new RedirectStateTree<>(value, value_right))
+			.end(value_builder);
+		StateTree<JavaElement> value_instanceof = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("instanceof"), (bag, token) -> bag.set("action", "instanceof")))
+			.then(new RedirectStateTree<>(type, value_right));
+		value_instanceof.end(value_builder);
+		value_instanceof.then(value_left);
+		
+		braces_container.then(clazz_container);
+		StateTree<JavaElement> braces_array = braces_container.then(new RedirectStateTree<>(value, (global, local) -> global.set(null)));
+		braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(braces_array);
+		braces_array.end((a,b) -> a);
+	 
+	 
+	 
+	 
+	 */
+	
+}

src/dev/peerat/parser/java/JavaProject.java

@@ -0,0 +1,52 @@
+package dev.peerat.parser.java;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class JavaProject implements JavaElement{
+	
+	private List<JavaFile> files;
+	
+	public JavaProject(){
+		this.files = new ArrayList<>();
+	}
+	
+	public void addFile(JavaFile file){
+		this.files.add(file);
+	}
+
+	public List<JavaFile> getFiles(){
+		return this.files;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		VisitorBag bag = new VisitorBag();
+		for(JavaFile file : this.files) bag.merge(file.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+	
+	
+}

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

@@ -0,0 +1,169 @@
+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 "+line);
+		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;
+				}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);
+		}
+	}
+	
+	private boolean isNameValid(char c) {
+		return Character.isAlphabetic(c) || Character.isDigit(c) || c == '_' || c == '$';
+	}
+
+}

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

@@ -0,0 +1,111 @@
+package dev.peerat.parser.java;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation.Annotable;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class Variable extends Annotable{
+	
+	public static interface VariableContainer{
+		
+		void addVariable(Variable variable);
+		
+	}
+
+	private int mod;
+	private Token type;		//TODO change to an independant objet ? to split package, name and generic
+	private Token name;
+	private boolean elips;
+	private Value value;
+	
+	public Variable(List<Annotation> annotations, int mod, Token type, Token name){
+		super(annotations);
+		this.mod = mod;
+		this.type = type;
+		this.name = name;
+	}
+	
+	public Variable(List<Annotation> annotations, int mod, Token type, Token name, boolean elips){
+		this(annotations, mod, type, name);
+		this.elips = elips;
+	}
+	
+	public Variable(List<Annotation> annotations, int mod, Token type, Token name, boolean elips, Value value){
+		this(annotations, mod, type, name, elips);
+		this.value = value;
+	}
+	
+	@Override
+	public String toString(){
+		return "Variable[mod="+mod+", type="+type+", name="+name+", elips="+elips+", value="+value+"]";
+	}
+	
+	public int getModifier(){
+		return this.mod;
+	}
+	
+	public Token getType(){
+		return this.type;
+	}
+	
+	public Token getName(){
+		return this.name;
+	}
+	
+	public boolean isElipsis(){
+		return this.elips;
+	}
+	
+	public Value getValue(){
+		return this.value;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		E annotation = super.find(finder);
+		if(annotation != null) return annotation;
+		
+		return value != null ? finder.test(value) ? (E)value : null : null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		super.findAll(finder, collector);
+		if(value != null){
+			if(finder.test(value)) collector.add((E)value);
+			value.findAll(finder, collector);
+		}
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(!visitor.canPropagate()) return bag;
+		
+		List<Annotation> annotations = getAnnotations();
+		if(annotations != null)
+			for(Annotation annotation : annotations){
+				bag.merge(annotation.visit(visitor));
+			}
+		
+		if(this.value != null) bag.merge(this.value.visit(visitor));
+		
+		return bag;
+	}
+
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

src/dev/peerat/parser/java/builder/JavaAnnotationBuilder.java

@@ -0,0 +1,56 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaAnnotationBuilder extends JavaBuilder<Annotation>{
+
+	private String name;
+	private Map<String, Value> values;
+	
+	public JavaAnnotationBuilder setName(String name){
+		this.name = name;
+		return this;
+	}
+	
+	public JavaAnnotationBuilder parameter(String key, Value value){
+		if(this.values == null) this.values = new HashMap<>();
+		this.values.put(key, value);
+		return this;
+	}
+	
+	public JavaAnnotationBuilder uniqueParameter(Value value){
+		return parameter(null, value);
+	}
+	
+	public JavaAnnotationBuilder normalize(Annotation annotation){
+		setName(annotation.getName().getValue());
+		Map<Token, Value> parameters = annotation.getParameters();
+		if(parameters != null){
+			if(this.values == null) this.values = new HashMap<>();
+			for(Entry<Token, Value> entry : parameters.entrySet()){
+				this.values.put(entry.getKey() == null ? null : entry.getKey().getValue(), JavaValueBuilder.normalize(entry.getValue()));
+			}
+		}
+		return this;
+	}
+	
+	@Override
+	public Annotation build(){
+		Map<Token, Value> map = null;
+		if(values != null){
+			map = new HashMap<>();
+			for(Entry<String, Value> entry : values.entrySet()){
+				map.put(entry.getKey() == null ? null : new Token(0,0,entry.getKey(), null), entry.getValue());
+			}
+		}
+		return new Annotation(new Token(0,0,name, null), map);
+	}
+
+}

src/dev/peerat/parser/java/builder/JavaBuilder.java

@@ -0,0 +1,97 @@
+package dev.peerat.parser.java.builder;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.operation.Operation;
+import dev.peerat.parser.java.value.Value;
+
+public abstract class JavaBuilder<T extends JavaElement>{
+	
+	//TODO WHEN TAKE BUILDER, TAKE ALSO BUILDED TYPE
+	
+	public static JavaFileBuilder ofFile(){
+		return new JavaFileBuilder();
+	}
+	
+	public static JavaFileBuilder ofFile(String pack){
+		return ofFile().setPackage(pack);
+	}
+	
+	public static JavaFileBuilder ofFile(JavaFile file){
+		return ofFile(); //TODO COMPLETE ALL BY DOM VALUES
+	}
+	
+	public static JavaImportBuilder ofImport(){
+		return new JavaImportBuilder();
+	}
+	
+	public static JavaImportBuilder ofImport(boolean isStatic, String value){
+		JavaImportBuilder builder = ofImport().setImport(value);
+		return isStatic ? builder.setStatic() : builder;
+	}
+	
+	public static JavaClassBuilder ofClass(){
+		return new JavaClassBuilder();
+	}
+	
+	public static JavaClassBuilder ofClass(String name){
+		return ofClass().setName(name);
+	}
+	
+	public static JavaAnnotationBuilder ofAnnotation(){
+		return new JavaAnnotationBuilder();
+	}
+	
+	public static JavaAnnotationBuilder ofAnnotation(String name){
+		return ofAnnotation().setName(name);
+	}
+	
+	public static JavaAnnotationBuilder ofAnnotation(String name, Value paramter){
+		return ofAnnotation(name).uniqueParameter(paramter);
+	}
+	
+	public static JavaVariableBuilder ofVariable(){
+		return new JavaVariableBuilder();
+	}
+	
+	public static JavaVariableBuilder ofVariable(String type, String name){
+		return ofVariable().setType(type).setName(name);
+	}
+	
+	public static JavaVariableBuilder ofVariable(String type, String name, Value value){
+		return ofVariable(type, name).setValue(value);
+	}
+	
+	public static JavaFunctionBuilder ofFunction(){
+		return new JavaFunctionBuilder();
+	}
+	
+	public static JavaFunctionBuilder ofFunction(String type, String name){
+		return ofFunction().setType(type).setName(name);
+	}
+	
+	public static JavaFunctionBuilder ofFunction(String generic, String type, String name){
+		return ofFunction(type, name).setGeneric(generic);
+	}
+	
+	public static Operation ofOperation(String operation){
+		try{
+			return new JavaOperationBuilder(operation).build();
+		}catch(Exception e){
+			throw new IllegalArgumentException("Failed to parse Operation "+operation, e);
+		}
+	}
+	
+	public static Value ofValue(String value){
+		try{
+			return new JavaValueBuilder(value).build();
+		}catch(Exception e){
+			throw new IllegalArgumentException("Failed to parse Value "+value, e);
+		}
+	}
+	
+	public abstract T build();
+	
+	public boolean filterEquals(JavaElement element){ return false;} //TODO ABSTRACT
+	
+}

src/dev/peerat/parser/java/builder/JavaClassBuilder.java

@@ -0,0 +1,86 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Class;
+import dev.peerat.parser.java.JavaElement;
+
+public class JavaClassBuilder extends JavaModifiableBuilder<JavaClassBuilder, dev.peerat.parser.java.Class>{
+
+	private List<Annotation> annotations;
+	private String name;
+	private String extend;
+	private String implement;
+	
+	private List<JavaElement> elements;
+	
+	public JavaClassBuilder annotate(JavaAnnotationBuilder annotation){
+		if(this.annotations == null) this.annotations = new ArrayList<>();
+		this.annotations.add(annotation.build());
+		return this;
+	}
+	
+	public JavaClassBuilder setName(String name){
+		this.name = name;
+		return this;
+	}
+	
+	public JavaClassBuilder extend(String type){
+		this.extend = type;
+		return this;
+	}
+	
+	public JavaClassBuilder implement(String type){
+		if(implement == null) this.implement = type;
+		else this.implement+=","+type;
+		return this;
+	}
+	
+	public <T extends JavaElement> JavaClassBuilder element(JavaBuilder<T> builder){
+		if(this.elements == null) this.elements = new ArrayList<>();
+		this.elements.add(builder.build());
+		return this;
+	}
+	
+	public JavaClassBuilder normalize(dev.peerat.parser.java.Class clazz){
+		normalizeAnnotations(clazz);
+		normalizeSignature(clazz);
+		//elements
+		return this;
+	}
+	
+	public JavaClassBuilder normalizeAnnotations(dev.peerat.parser.java.Class clazz){
+		List<Annotation> annotations = clazz.getAnnotations();
+		if(annotations != null && annotations.size() > 0){
+			if(this.annotations == null) this.annotations = new ArrayList<>();
+			for(Annotation annotation : annotations){
+				this.annotations.add(JavaBuilder.ofAnnotation().normalize(annotation).build());
+			}
+		}
+		return this;
+	}
+	
+	public JavaClassBuilder normalizeSignature(dev.peerat.parser.java.Class clazz){
+		this.mod = clazz.getModifier();
+		this.name = clazz.getName().getValue();
+		if(clazz.getExtension() != null) this.extend = clazz.getExtension().getValue();
+		if(clazz.getImplementations() != null) this.implement = this.implement == null ? clazz.getImplementations().getValue() : ","+clazz.getImplementations().getValue();
+		return this;
+	}
+	
+	public JavaClassBuilder clearAnnotations(){
+		this.annotations = null;
+		return this;
+	}
+	
+	@Override
+	public Class build(){
+		dev.peerat.parser.java.Class result = new dev.peerat.parser.java.Class(this.annotations, this.mod, new Token(0,0,name, null), extend == null ? null : new Token(0,0,extend, null), implement == null ? null : new Token(0,0, implement, null));
+		if(elements != null) result.getElements().addAll(elements);
+		return result;
+	}
+
+}

src/dev/peerat/parser/java/builder/JavaFileBuilder.java

@@ -0,0 +1,61 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.ClassBase;
+import dev.peerat.parser.java.Import;
+import dev.peerat.parser.java.JavaFile;
+
+public class JavaFileBuilder extends JavaBuilder<JavaFile>{
+	
+	private String pack;
+	private List<Import> imports;
+	private List<ClassBase> classes;
+	
+	public JavaFileBuilder setPackage(String value){
+		this.pack = value;
+		return this;
+	}
+	
+	public JavaFileBuilder doImport(String value, boolean isStatic){
+		if(this.imports == null) this.imports = new ArrayList<>();
+		this.imports.add(new Import(isStatic, new Token(0,0, value, null)));
+		return this;
+	}
+	
+	public <T extends ClassBase> JavaFileBuilder clazz(JavaBuilder<T> builder){
+		if(this.classes == null) this.classes = new ArrayList<>();
+		this.classes.add(builder.build());
+		return this;
+	}
+	
+	public JavaFileBuilder normalize(JavaFile file){
+		if(file.getPackage() != null) this.pack = file.getPackage().getValue();
+		List<Import> imports = file.getImports();
+		if(imports != null && imports.size() > 0){
+			if(this.imports == null) this.imports = new ArrayList<>();
+			for(Import imp : imports) this.imports.add(JavaBuilder.ofImport().normalize(imp).build());
+		}
+		//classes
+		return this;
+	}
+	
+
+	@Override
+	public JavaFile build(){
+		JavaFile result = new JavaFile();
+		result.setPackage(new Token(0,0, this.pack, null));
+		if(this.imports != null)
+			for(Import imp : this.imports){
+				result.addImport(imp);
+			}
+		if(this.classes != null)
+			for(ClassBase clazz : this.classes){
+				result.addClass(clazz);
+			}
+		return result;
+	}
+}
+

src/dev/peerat/parser/java/builder/JavaFunctionBuilder.java

@@ -0,0 +1,120 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+
+public class JavaFunctionBuilder extends JavaModifiableBuilder<JavaFunctionBuilder, Function>{
+
+	private List<Annotation> annotations;
+	private String generic;
+	private String type;
+	private String name;
+	private List<Variable> parameters;
+	private List<Token> throwables;
+	
+	private List<JavaElement> elements;
+	
+	public JavaFunctionBuilder annotate(JavaAnnotationBuilder annotation){
+		if(this.annotations == null) this.annotations = new ArrayList<>();
+		this.annotations.add(annotation.build());
+		return this;
+	}
+	
+	public JavaFunctionBuilder setGeneric(String generic){
+		this.generic = generic;
+		return this;
+	}
+	
+	public JavaFunctionBuilder setType(String type){
+		this.type = type;
+		return this;
+	}
+	
+	public JavaFunctionBuilder setName(String name){
+		this.name = name;
+		return this;
+	}
+	
+	public JavaFunctionBuilder parameter(JavaVariableBuilder builder){
+		if(this.parameters == null) this.parameters = new ArrayList<>();
+		this.parameters.add(builder.build());
+		return this;
+	}
+	
+	public JavaFunctionBuilder throwable(String throwable){
+		if(this.throwables == null) this.throwables = new ArrayList<>();
+		this.throwables.add(new Token(0,0,throwable, null));
+		return this;
+	}
+	
+	public JavaFunctionBuilder element(JavaElement element){
+		if(this.elements == null) this.elements = new ArrayList<>();
+		this.elements.add(element);
+		return this;
+	}
+	
+	public JavaFunctionBuilder normalize(Function func){
+		normalizeAnnotations(func);
+		normalizeSignature(func);
+		//elements
+		return this;
+	}
+	
+	public JavaFunctionBuilder normalizeAnnotations(Function func){
+		List<Annotation> annotations = func.getAnnotations();
+		if(annotations != null && annotations.size() > 0){
+			if(this.annotations == null) this.annotations = new ArrayList<>();
+			for(Annotation annotation : annotations){
+				this.annotations.add(JavaBuilder.ofAnnotation().normalize(annotation).build());
+			}
+		}
+		return this;
+	}
+	
+	public JavaFunctionBuilder normalizeSignature(Function func){
+		this.mod = func.getModifier();
+		if(func.getGeneric() != null) this.generic = func.getGeneric().getValue();
+		if(func.getReturnType() != null) this.type = func.getReturnType().getValue();
+		if(func.getName() != null) this.name = func.getName().getValue();
+		List<Variable> parameters = func.getParameters();
+		if(parameters != null && parameters.size() > 0){
+			if(this.parameters == null) this.parameters = new ArrayList<>();
+			for(Variable param : parameters) this.parameters.add(JavaBuilder.ofVariable().normalize(param).build());
+		}
+		List<Token> throwables = func.getThrowables();
+		if(throwables != null && throwables.size() > 0){
+			if(this.throwables == null) this.throwables = new ArrayList<>();
+			for(Token token : throwables) this.throwables.add(new Token(0,0, token.getValue(), null));
+		}
+		return this;
+	}
+	
+	public JavaFunctionBuilder clearAnnotations(){
+		this.annotations = null;
+		return this;
+	}
+	
+	@Override
+	public Function build(){
+		Function result = new Function(
+				this.annotations,
+				this.mod,
+				this.generic == null ? null : new Token(0,0, this.generic, null),
+				this.type == null ? null : new Token(0,0, this.type, null),
+				new Token(0,0, this.name, null),
+				this.parameters,
+				this.throwables
+				);
+		result.getElements().addAll(elements);
+		return result;
+	}
+	
+	
+
+}

src/dev/peerat/parser/java/builder/JavaImportBuilder.java

@@ -0,0 +1,32 @@
+package dev.peerat.parser.java.builder;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Import;
+
+public class JavaImportBuilder extends JavaBuilder<Import>{
+
+	private boolean isStatic;
+	private String value;
+	
+	public JavaImportBuilder setStatic(){
+		this.isStatic = true;
+		return this;
+	}
+	
+	public JavaImportBuilder setImport(String value){
+		this.value = value;
+		return this;
+	}
+	
+	public JavaImportBuilder normalize(Import imp){
+		this.isStatic = imp.isStatic();
+		this.value = imp.getValue().getValue();
+		return this;
+	}
+	
+	@Override
+	public Import build(){
+		return new Import(this.isStatic, new Token(0,0,this.value, null));
+	}
+
+}

src/dev/peerat/parser/java/builder/JavaModifiableBuilder.java

@@ -0,0 +1,70 @@
+package dev.peerat.parser.java.builder;
+
+import dev.peerat.parser.java.JavaElement;
+
+public abstract class JavaModifiableBuilder<T, E extends JavaElement> extends JavaBuilder<E>{
+	
+	//TODO TO TEST
+	protected int mod;
+	
+	public T setPublic(){
+		this.mod += 0x1;
+		return (T) this;
+	}
+	
+	public T setPrivate(){
+		this.mod += 0x2;
+		return (T) this;
+	}
+	
+	public T setProtected(){
+		this.mod += 0x4;
+		return (T) this;
+	}
+	
+	public T setStatic(){
+		this.mod += 0x8;
+		return (T) this;
+	}
+	
+	public T setFinal(){
+		this.mod += 0x10;
+		return (T) this;
+	}
+	
+	public T setSynchronized(){
+		this.mod += 0x20;
+		return (T) this;
+	}
+	
+	public T setVolatile(){
+		this.mod += 0x40;
+		return (T) this;
+	}
+	
+	public T setTransient(){
+		this.mod += 0x80;
+		return (T) this;
+	}
+	
+	public T setNative(){
+		this.mod += 0x100;
+		return (T) this;
+	}
+	
+	public T setAbstract(){
+		this.mod += 0x400;
+		return (T) this;
+	}
+	
+	public T setStrict(){
+		this.mod += 0x800;
+		return (T) this;
+	}
+	
+	public T setPackageLevel(){
+//		this.mod += 0x1;
+		return (T) this;
+	}
+
+}

src/dev/peerat/parser/java/builder/JavaOperationBuilder.java

@@ -0,0 +1,63 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Parser;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaParser;
+import dev.peerat.parser.java.operation.Operation;
+import dev.peerat.parser.java.operation.Operation.OperationContainer;
+import dev.peerat.parser.java.tree.JavaTreeType;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class JavaOperationBuilder extends JavaBuilder<Operation>{
+
+	private static Parser<JavaElement> PARSER = new JavaParser(JavaTreeType.OPERATION);
+	
+	private Operation operation;
+	
+	public JavaOperationBuilder(String operation) throws Exception{
+		PARSER.parse(operation, new Container());
+	}
+
+	@Override
+	public Operation build(){
+		return this.operation;
+	}
+
+	class Container implements JavaElement, OperationContainer{
+
+		@Override
+		public void addOperation(Operation operation){
+			JavaOperationBuilder.this.operation = operation;
+		}
+		
+		@Override
+		public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+			// TODO Auto-generated method stub
+			return null;
+		}
+		
+		@Override
+		public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+			// TODO Auto-generated method stub
+			
+		}
+
+		@Override
+		public VisitorBag visit(Visitor<JavaElement> visitor) {
+			return null;
+		}
+		
+		@Override
+		public VisitorBag visit(TokenVisitor visitor){
+			return null;
+		}
+	}
+}

src/dev/peerat/parser/java/builder/JavaValueBuilder.java

@@ -0,0 +1,153 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Parser;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaParser;
+import dev.peerat.parser.java.tree.JavaTreeType;
+import dev.peerat.parser.java.value.ArrayAccessValue;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.LambdaValue.LambdaParameter;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.VariableAccessValue;
+import dev.peerat.parser.java.value.Value.ValueContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class JavaValueBuilder extends JavaBuilder<Value>{
+
+	private static Parser<JavaElement> PARSER = new JavaParser(JavaTreeType.VALUE);
+	
+	static Value normalize(Value value){
+		if(value == null) return null;
+		if(value instanceof StaticValue) return normalizeStatic((StaticValue) value);
+		if(value instanceof BiValue) return normalizeBi((BiValue) value);
+		if(value instanceof TriValue) return normalizeTri((TriValue) value);
+		if(value instanceof ArrayAccessValue) return normalizeArrayAccess((ArrayAccessValue) value);
+		if(value instanceof ArrayValue) return normalizeArray((ArrayValue) value);
+		if(value instanceof CastValue) return normalizeCast((CastValue) value);
+		if(value instanceof InstanceValue) return normalizeInstance((InstanceValue) value);
+		if(value instanceof LambdaValue) return normalizeLambda((LambdaValue) value);
+		if(value instanceof MethodCallValue) return normalizeMethodCall((MethodCallValue) value);
+		if(value instanceof ModifierValue) return normalizeModifier((ModifierValue) value);
+		if(value instanceof VariableAccessValue) return normalizeVariableAccess((VariableAccessValue) value);
+		return null;
+	}
+	
+	static Value normalizeStatic(StaticValue value){
+		return new StaticValue(new Token(0,0,value.getToken().getValue(), null));
+	}
+	
+	static Value normalizeBi(BiValue value){
+		return new BiValue(normalize(value.left()), value.getAction(), normalize(value.right()));
+	}
+	
+	static Value normalizeTri(TriValue value){
+		return new TriValue(normalize(value.getChecker()), normalize(value.success()), normalize(value.fail()));
+	}
+	
+	static Value normalizeArrayAccess(ArrayAccessValue value){
+		return new ArrayAccessValue(normalize(value.base()), normalize(value.getAccessor()));
+	}
+	
+	static Value normalizeArray(ArrayValue value){
+		Value[] values = value.getValues();
+		Value[] result = new Value[values.length];
+		for(int i = 0; i < values.length; i++){
+			result[i] = normalize(values[i]);
+		}
+		return new ArrayValue(result);
+	}
+	
+	static Value normalizeCast(CastValue value){
+		return new CastValue(new Token(0,0,value.getType().getValue(), null), normalize(value.getValue()));
+	}
+	
+	static Value normalizeInstance(InstanceValue value){
+		List<Value> params = value.getParameters();
+		List<Value> nparams = new ArrayList<>();
+		for(Value param : params) nparams.add(normalize(param));
+		InstanceValue result = new InstanceValue(new Token(0,0,value.getToken().getValue(), null), nparams);
+		//elements
+		return result;
+	}
+	
+	static Value normalizeLambda(LambdaValue value){
+		List<LambdaParameter> params = value.getParameters();
+		List<LambdaParameter> nparams = new ArrayList<>();
+		for(LambdaParameter param : params) nparams.add(new LambdaParameter(new Token(0,0,param.getType().getValue(), null), new Token(0,0,param.getName().getValue(), null)));
+		LambdaValue result = new LambdaValue(nparams);
+		//elements
+		return result;
+	}
+	
+	static Value normalizeMethodCall(MethodCallValue value){
+		List<Value> params = value.getParameters();
+		List<Value> nparams = new ArrayList<>();
+		for(Value param : params) nparams.add(normalize(param));
+		return new MethodCallValue(normalize(value.base()), value.getGeneric() == null ? null : new Token(0,0,value.getGeneric().getValue(), null), new Token(0,0,value.getToken().getValue(), null), nparams);
+	}
+	
+	static Value normalizeModifier(ModifierValue value){
+		return new ModifierValue(new Token(0,0,value.getModifier().getValue(), null), normalize(value.getValue()));
+	}
+	
+	static Value normalizeVariableAccess(VariableAccessValue value){
+		return new VariableAccessValue(normalize(value.base()), new Token(0,0, value.getVariable().getValue(), null));
+	}
+	
+	
+	private Value value;
+	
+	public JavaValueBuilder(String value) throws Exception{
+		PARSER.parse(value, new Container());
+	}
+
+	@Override
+	public Value build(){
+		return this.value;
+	}
+
+	class Container implements JavaElement, ValueContainer{
+
+		@Override
+		public void addValue(Value value) {
+			JavaValueBuilder.this.value = value;
+		}
+		
+		@Override
+		public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+			return null;
+		}
+		
+		@Override
+		public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {}
+
+		@Override
+		public VisitorBag visit(Visitor<JavaElement> visitor) {
+			return null;
+		}
+		
+		@Override
+		public VisitorBag visit(TokenVisitor visitor){
+			return null;
+		}
+		
+	}
+}

src/dev/peerat/parser/java/builder/JavaVariableBuilder.java

@@ -0,0 +1,69 @@
+package dev.peerat.parser.java.builder;
+
+import java.util.ArrayList;
+import java.util.List;
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaVariableBuilder extends JavaModifiableBuilder<JavaVariableBuilder, Variable>{
+
+	private List<Annotation> annotations;
+	private String type;
+	private String name;
+	private boolean elipse;
+	private Value value;
+	
+	public JavaVariableBuilder annotate(JavaAnnotationBuilder annotation){
+		if(this.annotations == null) this.annotations = new ArrayList<>();
+		this.annotations.add(annotation.build());
+		return this;
+	}
+	
+	public JavaVariableBuilder setType(String type){
+		this.type = type;
+		this.elipse = type.endsWith("...");
+		return this;
+	}
+	
+	public JavaVariableBuilder setName(String name){
+		this.name = name;
+		return this;
+	}
+	
+	public JavaVariableBuilder setValue(Value value){
+		this.value = value;
+		return this;
+	}
+	
+	public JavaVariableBuilder normalize(Variable variable){
+		normalizeAnnotations(variable);
+		setType(variable.getType().getValue());
+		setName(variable.getName().getValue());
+		setValue(JavaValueBuilder.normalize(variable.getValue()));
+		return this;
+	}
+	
+	public JavaVariableBuilder normalizeAnnotations(Variable variable){
+		List<Annotation> annotations = variable.getAnnotations();
+		if(annotations != null && annotations.size() > 0){
+			if(this.annotations == null) this.annotations = new ArrayList<>();
+			for(Annotation annotation : annotations){
+				this.annotations.add(JavaBuilder.ofAnnotation().normalize(annotation).build());
+			}
+		}
+		return this;
+	}
+	
+	public JavaVariableBuilder clearAnnotations(){
+		this.annotations = null;
+		return this;
+	}
+	
+	@Override
+	public Variable build(){
+		return new Variable(annotations, mod, new Token(0,0, type, null), new Token(0,0, name, null), elipse, value);
+	}
+
+}

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

@@ -0,0 +1,57 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class AssignOperation extends Operation{
+	
+	private Value left;
+	private Value right;
+	
+	public AssignOperation(Value left, Value right){
+		this.left = left;
+		this.right = right;
+	}
+	
+	public Value left(){
+		return left;
+	}
+	
+	public Value right(){
+		return right;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return finder.test(left) ? (E)left : finder.test(right) ? (E)right : null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(left)) collector.add((E) left);
+		left.findAll(finder, collector);
+		if(finder.test(right)) collector.add((E) right);
+		right.findAll(finder, collector);
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(left.visit(visitor));
+		bag.merge(right.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,42 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class BreakOperation extends Operation{
+	
+	public BreakOperation(){}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,43 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.List;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class CatchOperation extends OperationBag{
+	
+	private List<Token> types;
+	private Token name;
+	
+	public CatchOperation(List<Token> types, Token name){
+		super();
+		this.types = types;
+		this.name = name;
+	}
+	
+	public List<Token> getTypes(){
+		return this.types;
+	}
+	
+	public Token getName(){
+		return this.name;
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,39 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ContinueOperation extends Operation{
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,22 @@
+package dev.peerat.parser.java.operation;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class DoOperation extends OperationBag{
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,23 @@
+package dev.peerat.parser.java.operation;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ElseOperation extends OperationBag{
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,23 @@
+package dev.peerat.parser.java.operation;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class FinallyOperation extends OperationBag{
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return super.visit(visitor);
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,126 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ForOperation extends OperationBag{
+	
+	private List<Variable> init_vars;
+	private List<Value> init_values;
+	
+	private Value condition;
+	
+	private List<Value> updates;
+	
+	public ForOperation(List<Variable> init_vars, List<Value> init_values, Value condition, List<Value> updates){
+		super();
+		
+		this.init_vars = init_vars;
+		this.init_values = init_values;
+		
+		this.condition = condition;
+		this.updates = updates;
+	}
+	
+	public List<Variable> initVars(){
+		return this.init_vars;
+	}
+	
+	public List<Value> initValues(){
+		return this.init_values;
+	}
+	
+	public Value getCondition(){
+		return this.condition;
+	}
+	
+	public List<Value> getUpdates(){
+		return this.updates;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(init_vars != null){
+			for(Variable variable : this.init_vars){
+				if(finder.test(variable)) return (E)variable;
+			}
+		}
+		if(init_values != null){
+			for(Value value : this.init_values){
+				if(finder.test(value)) return (E)value;
+			}
+		}
+		if(finder.test(condition)) return (E)condition;
+		if(this.updates != null){
+			for(Value value : this.updates){
+				if(finder.test(value)) return (E)value;
+			}
+		}
+		return super.find(finder);
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(init_vars != null){
+			for(Variable variable : this.init_vars){
+				if(finder.test(variable)) collector.add((E)variable);
+				variable.findAll(finder, collector);
+			}
+		}
+		if(init_values != null){
+			for(Value value : this.init_values){
+				if(finder.test(value)) collector.add((E)value);
+				value.findAll(finder, collector);
+			}
+		}
+		if(finder.test(condition)) collector.add((E)condition);
+		if(this.updates != null){
+			for(Value value : this.updates){
+				if(finder.test(value)) collector.add((E)value);
+				value.findAll(finder, collector);
+			}
+		}
+		super.findAll(finder, collector);
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(init_vars != null)
+			for(Variable variable : this.init_vars){
+				bag.merge(variable.visit(visitor));
+			}
+		
+		if(init_values != null)
+			for(Value value : this.init_values){
+				bag.merge(value.visit(visitor));
+			}
+		
+		bag.merge(condition.visit(visitor));
+		
+		if(this.updates != null)
+			for(Value value : this.updates){
+				bag.merge(value.visit(visitor));
+			}
+		
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,68 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ForeachOperation extends OperationBag{
+	
+	private Token type;
+	private Token name;
+	private Value iterator;
+	
+	public ForeachOperation(Token type, Token name, Value iterator){
+		super();
+		
+		this.type = type;
+		this.name = name;
+		this.iterator = iterator;
+	}
+	
+	public Token getType(){
+		return this.type;
+	}
+	
+	public Token getName(){
+		return this.name;
+	}
+	
+	public Value getIterator(){
+		return this.iterator;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return super.find(finder);
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		super.findAll(finder, collector);
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.iterator.visit(visitor));
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,57 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class IfOperation extends OperationBag{
+	
+	private Value condition;
+	
+	public IfOperation(Value condition){
+		super();
+		this.condition = condition;
+	}
+	
+	public Value getCondition(){
+		return this.condition;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(finder.test(condition)) return (E)condition;
+		return super.find(finder);
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(condition)) collector.add((E)condition);
+		condition.findAll(finder, collector);
+		super.findAll(finder, collector);
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		VisitorBag bag;
+		if(visitor.canVisit(getClass())){
+			bag = visitor.visit(this);
+			if(!visitor.canPropagate()) return bag;
+		}else bag = new VisitorBag();
+		bag.merge(condition.visit(visitor));
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		return new VisitorBag();
+	}
+}

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

@@ -0,0 +1,15 @@
+package dev.peerat.parser.java.operation;
+
+import dev.peerat.parser.java.JavaElement;
+
+public abstract class Operation implements JavaElement{
+	
+	public static interface OperationContainer{
+		
+		void addOperation(Operation operation);
+		
+	}
+	
+	public Operation(){}
+
+}

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

@@ -0,0 +1,76 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.Variable.VariableContainer;
+import dev.peerat.parser.java.operation.Operation.OperationContainer;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.Value.ValueContainer;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public abstract class OperationBag extends Operation implements VariableContainer, OperationContainer, ValueContainer{
+
+	private List<JavaElement> elements;
+	
+	public OperationBag(){
+		this.elements = new ArrayList<>();
+	}
+	
+	@Override
+	public void addVariable(Variable variable){
+		this.elements.add(variable);
+	}
+	
+	@Override
+	public void addOperation(Operation operation){
+		this.elements.add(operation);
+	}
+	
+	@Override
+	public void addValue(Value value) {
+		this.elements.add(value);
+	}
+	
+	public List<JavaElement> getElements(){
+		return this.elements;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) return (E)element;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(elements != null){
+			for(JavaElement element : this.elements){
+				if(finder.test(element)) collector.add((E)element);
+				element.findAll(finder, collector);
+			}
+		}
+	}
+	
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor){
+		VisitorBag bag = new VisitorBag();
+		for(JavaElement element : this.elements){
+			bag.merge(element.visit(visitor));
+		}
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,53 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ReturnOperation extends Operation{
+	
+	private Value value;
+	
+	public ReturnOperation(Value value){
+		this.value = value;
+	}
+	
+	public Value getValue(){
+		return this.value;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return value != null ? finder.test(value) ? (E)value : null : null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(value != null){
+			if(finder.test(value)) collector.add((E) value);
+			value.findAll(finder, collector);
+		}
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(this.value != null) bag.merge(this.value.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,41 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class SwitchOperation extends Operation{
+	
+	//+ AND OBJECT FOR CONTAINING EVERY CASE OP
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		return null;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,55 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class SynchronizedOperation extends OperationBag{
+	
+	private Value value;
+	
+	public SynchronizedOperation(Value value){
+		super();
+		this.value = value;
+	}
+	
+	public Value getValue(){
+		return this.value;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(finder.test(value)) return (E)value;
+		return super.find(finder);
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(value)) collector.add((E)value);
+		value.findAll(finder, collector);
+		super.findAll(finder, collector);
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.value.visit(visitor));
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,51 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ThrowOperation extends Operation{
+	
+	private Value value;
+	
+	public ThrowOperation(Value value){
+		this.value = value;
+	}
+	
+	public Value getValue(){
+		return this.value;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return finder.test(value) ? (E)value : null;
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(value)) collector.add((E) value);
+		value.findAll(finder, collector);
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.value.visit(visitor));
+		return bag;
+	}
+
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,60 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class TryOperation extends OperationBag{
+
+	private Variable resource;
+	
+	public TryOperation(){
+		super();
+	}
+	
+	public TryOperation(Variable resource){
+		this();
+		this.resource = resource;
+	}
+	
+	public Variable getResource(){
+		return this.resource;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		return resource != null ? finder.test(resource) ? (E)resource : super.find(finder) : super.find(finder);
+	}
+
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(resource != null){
+			if(finder.test(resource)) collector.add((E) resource);
+			resource.findAll(finder, collector);
+		}
+		super.findAll(finder, collector);
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		if(this.resource != null) bag.merge(this.resource.visit(visitor));
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

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

@@ -0,0 +1,54 @@
+package dev.peerat.parser.java.operation;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class WhileOperation extends OperationBag{
+	
+	private Value condition;
+	
+	public WhileOperation(Value condition){
+		this.condition = condition;
+	}
+	
+	public Value getCondition(){
+		return this.condition;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		if(finder.test(condition)) return (E)condition;
+		return super.find(finder);
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		if(finder.test(condition)) collector.add((E) condition);
+		condition.findAll(finder, collector);
+		super.findAll(finder, collector);
+	}
+	
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.condition.visit(visitor));
+		bag.merge(super.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+}

src/dev/peerat/parser/java/printer/JavaAnnotationPrinter.java

@@ -0,0 +1,35 @@
+package dev.peerat.parser.java.printer;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaAnnotationPrinter extends JavaPrinter<Annotation>{
+	
+	@Override
+	public void print(Annotation element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		writer.write(buffer);
+		writer.write("@");
+		writer.write(element.getName());
+		Map<Token, Value> map = element.getParameters();
+		if(map != null && !map.isEmpty()){
+			writer.write("(");
+			Iterator<Entry<Token, Value>> iterator = map.entrySet().iterator();
+			while(iterator.hasNext()){
+				Entry<Token, Value> entry = iterator.next();
+				writer.write(entry.getKey());
+				writer.write("=");
+				Value value = entry.getValue();
+				provider.getPrinter(value).print(value, writer, buffer, provider);
+				if(iterator.hasNext()) writer.write(",");
+			}
+			writer.write(")");
+		}
+		writer.write("\n");
+	}
+	
+}

src/dev/peerat/parser/java/printer/JavaClassPrinter.java

@@ -0,0 +1,32 @@
+package dev.peerat.parser.java.printer;
+
+import java.lang.reflect.Modifier;
+
+import dev.peerat.parser.java.Class;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+
+public class JavaClassPrinter extends JavaPrinter<dev.peerat.parser.java.Class>{
+
+	@Override
+	public void print(Class element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		writer.write(buffer+Modifier.toString(element.getModifier())+" class ");
+		writer.write(element.getName());
+		if(element.getExtension() != null){
+			writer.write(" extends ");
+			writer.write(element.getExtension());
+		}
+		if(element.getImplementations() != null){
+			writer.write(" implements ");
+			writer.write(element.getImplementations());
+		}
+		writer.write("{\n");
+		for(JavaElement content : element.getElements()){
+			provider.getPrinter(content).print(content, writer, buffer+"\t", provider);
+			if(content instanceof Variable) writer.write(";");
+			writer.write("\n");
+		}
+		writer.write("}\n");
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaFilePrinter.java

@@ -0,0 +1,29 @@
+package dev.peerat.parser.java.printer;
+
+import dev.peerat.parser.java.ClassBase;
+import dev.peerat.parser.java.Import;
+import dev.peerat.parser.java.JavaFile;
+
+public class JavaFilePrinter extends JavaPrinter<JavaFile>{
+
+	@Override
+	public void print(JavaFile element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		if(element.getPackage() != null){
+			writer.write("package ");
+			writer.write(element.getPackage());
+			writer.write(";\n");
+		}
+		for(Import imp : element.getImports()){
+			provider.getPrinter(imp).print(imp, writer, buffer, provider);
+			writer.write("\n");
+		}
+		
+		ClassBase clazz = element.getMainClass();
+		provider.getPrinter(clazz).print(clazz, writer, buffer, provider);
+		
+		for(ClassBase classes : element.getSubClasses()){
+			provider.getPrinter(classes).print(classes, writer, buffer, provider);
+		}
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaFunctionPrinter.java

@@ -0,0 +1,56 @@
+package dev.peerat.parser.java.printer;
+
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaFunctionPrinter extends JavaPrinter<Function>{
+	
+	@Override
+	public void print(Function element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		writer.write(buffer+Modifier.toString(element.getModifier())+" ");
+		if(element.getGeneric() != null){
+			writer.write(element.getGeneric());
+			writer.write(" ");
+		}
+		if(element.getReturnType() != null){
+			writer.write(element.getReturnType());
+			writer.write(" ");
+		}
+		writer.write(element.getName());
+		writer.write("(");
+		if(element.getParameters() != null){
+			Iterator<Variable> parameters = element.getParameters().iterator();
+			while(parameters.hasNext()){
+				Variable parameter = parameters.next();
+				provider.getPrinter(parameter).print(parameter, writer, "", provider);
+				if(parameters.hasNext()) writer.write(", ");
+			}
+		}
+		writer.write(")");
+		if(element.getThrowables() != null){
+			Iterator<Token> throwables = element.getThrowables().iterator();
+			if(throwables.hasNext()){
+				writer.write(" throws ");
+				while(throwables.hasNext()){
+					Token token = throwables.next();
+					writer.write(token);
+					if(throwables.hasNext()) writer.write(",");
+				}
+			}
+		}
+		writer.write("{\n");
+		for(JavaElement content : element.getElements()){
+			provider.getPrinter(content).print(content, writer, buffer+"\t", provider);
+			if(content instanceof Value) writer.write(";");
+			writer.write("\n");
+		}
+		writer.write(buffer+"}");
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaImportPrinter.java

@@ -0,0 +1,15 @@
+package dev.peerat.parser.java.printer;
+
+import dev.peerat.parser.java.Import;
+
+public class JavaImportPrinter extends JavaPrinter<Import>{
+
+	@Override
+	public void print(Import element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		writer.write("import ");
+		if(element.isStatic()) writer.write("static ");
+		writer.write(element.getValue());
+		writer.write(";");
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaOperationPrinter.java

@@ -0,0 +1,57 @@
+package dev.peerat.parser.java.printer;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.operation.IfOperation;
+import dev.peerat.parser.java.operation.ReturnOperation;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaOperationPrinter{
+	
+	public static class JavaOperationReturnPrinter extends JavaPrinter<ReturnOperation>{
+
+		@Override
+		public void print(ReturnOperation element, Writer writer, String buffer, JavaPrintProvider provider)throws Exception {
+			writer.write(buffer+"return");
+			Value value = element.getValue();
+			if(value == null){
+				writer.write(";");
+				return;
+			}
+			writer.write(" ");
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write(";");
+		}
+		
+	}
+	
+	public static class JavaOperationIfPrinter extends JavaPrinter<IfOperation>{
+		
+		@Override
+		public void print(IfOperation element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer+"if(");
+			Value condition = element.getCondition();
+			provider.getPrinter(condition).print(condition, writer, "", provider);
+			writer.write(")");
+			int size = element.getElements().size();
+			if(size == 0){
+				writer.write(";");
+				return;
+			}
+			if(size == 1){
+				writer.write(" ");
+				JavaElement subElement = element.getElements().get(0);
+				provider.getPrinter(subElement).print(subElement, writer, "", provider);
+				writer.write(";");
+				return;
+			}
+			writer.write("{\n");
+			for(JavaElement subElement : element.getElements()){
+				provider.getPrinter(subElement).print(subElement, writer, buffer+"\t", provider);
+				writer.write("\n");
+			}
+			writer.write(buffer+"}\n");
+		}
+		
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaPrinter.java

@@ -0,0 +1,110 @@
+package dev.peerat.parser.java.printer;
+
+import java.io.BufferedWriter;
+import java.util.HashMap;
+import java.util.Map;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Annotation;
+import dev.peerat.parser.java.Function;
+import dev.peerat.parser.java.Import;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.operation.IfOperation;
+import dev.peerat.parser.java.operation.ReturnOperation;
+import dev.peerat.parser.java.printer.JavaOperationPrinter.JavaOperationIfPrinter;
+import dev.peerat.parser.java.printer.JavaOperationPrinter.JavaOperationReturnPrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaArrayAccessValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaArrayValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaBiValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaCastValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaInstanceValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaLambdaValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaMethodCallValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaModifierValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaStaticValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaTriValuePrinter;
+import dev.peerat.parser.java.printer.JavaValuePrinter.JavaVariableAccessValuePrinter;
+import dev.peerat.parser.java.value.ArrayAccessValue;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.VariableAccessValue;
+
+public abstract class JavaPrinter<T extends JavaElement>{
+	
+	public static JavaPrintProvider getProvider(){
+		JavaPrintProvider provider = new JavaPrintProvider();
+		provider.register(ArrayAccessValue.class, new JavaArrayAccessValuePrinter());
+		provider.register(ArrayValue.class, new JavaArrayValuePrinter());
+		provider.register(BiValue.class, new JavaBiValuePrinter());
+		provider.register(CastValue.class, new JavaCastValuePrinter());
+		provider.register(InstanceValue.class, new JavaInstanceValuePrinter());
+		provider.register(LambdaValue.class, new JavaLambdaValuePrinter());
+		provider.register(MethodCallValue.class, new JavaMethodCallValuePrinter());
+		provider.register(ModifierValue.class, new JavaModifierValuePrinter());
+		provider.register(StaticValue.class, new JavaStaticValuePrinter());
+		provider.register(TriValue.class, new JavaTriValuePrinter());
+		provider.register(VariableAccessValue.class, new JavaVariableAccessValuePrinter());
+		
+		provider.register(ReturnOperation.class, new JavaOperationReturnPrinter());
+		provider.register(IfOperation.class, new JavaOperationIfPrinter());
+		
+		provider.register(Import.class, new JavaImportPrinter());
+		provider.register(Annotation.class, new JavaAnnotationPrinter());
+		provider.register(Variable.class, new JavaVariablePrinter());
+		provider.register(Function.class, new JavaFunctionPrinter());
+		provider.register(dev.peerat.parser.java.Class.class, new JavaClassPrinter());
+		provider.register(JavaFile.class, new JavaFilePrinter());
+		return provider;
+	}
+	
+	public abstract void print(T element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception;
+	
+	public static class JavaPrintProvider{
+		
+		private Map<Class<?>, JavaPrinter<?>> map;
+		
+		public JavaPrintProvider(){
+			this.map = new HashMap<>();
+		}
+		
+		public void register(Class<?> type, JavaPrinter<?> printer){
+			this.map.put(type, printer);
+		}
+		
+		public <T extends JavaElement> JavaPrinter<T> getPrinter(T type){
+			return (JavaPrinter<T>) getPrinter(type.getClass());
+		}
+		
+		public <T extends JavaElement> JavaPrinter<T> getPrinter(Class<T> type){
+			JavaPrinter<T> result = (JavaPrinter<T>) this.map.get(type);
+			if(result == null) throw new IllegalArgumentException("No Print Provider for type "+type+".");
+			return result;
+		}
+	}
+	
+	public static class Writer{
+		
+		private BufferedWriter writer;
+		
+		public Writer(BufferedWriter writer){
+			this.writer = writer;
+		}
+		
+		public void write(String value) throws Exception{
+			this.writer.write(value);
+		}
+		
+		public void write(Token token) throws Exception{
+			write(token.getValue());
+		}
+	}
+}

src/dev/peerat/parser/java/printer/JavaValuePrinter.java

@@ -0,0 +1,208 @@
+package dev.peerat.parser.java.printer;
+
+import java.util.Iterator;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.value.ArrayAccessValue;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.LambdaValue.LambdaParameter;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.VariableAccessValue;
+
+public class JavaValuePrinter{
+	
+	public static class JavaStaticValuePrinter extends JavaPrinter<StaticValue>{
+		
+		public void print(StaticValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer);
+			writer.write(element.getToken());
+		}
+		
+	}
+	
+	public static class JavaBiValuePrinter extends JavaPrinter<BiValue>{
+		
+		public void print(BiValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer);
+			Value left = element.left();
+			provider.getPrinter(left).print(left, writer, "", provider);
+			
+			writer.write(" "+element.getAction()+" ");
+			
+			Value right = element.right();
+			provider.getPrinter(right).print(right, writer, "", provider);
+		}
+		
+	}
+	
+	public static class JavaTriValuePrinter extends JavaPrinter<TriValue>{
+		
+		public void print(TriValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer);
+			Value value = element.getChecker();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			
+			writer.write(" ? ");
+			
+			value = element.success();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			
+			writer.write(" : ");
+			
+			value = element.fail();
+			provider.getPrinter(value).print(value, writer, "", provider);
+		}
+		
+	}
+	
+	public static class JavaArrayAccessValuePrinter extends JavaPrinter<ArrayAccessValue>{
+		
+		public void print(ArrayAccessValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer);
+			Value value = element.base();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write("[");
+			value = element.getAccessor();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write("]");
+		}
+		
+	}
+	
+	public static class JavaArrayValuePrinter extends JavaPrinter<ArrayValue>{
+		
+		public void print(ArrayValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer+"{");
+			Value[] values = element.getValues();
+			for(int i = 0; i < values.length; i++){
+				Value value = values[i];
+				provider.getPrinter(value).print(value, writer, "", provider);
+				if(i < values.length-1) writer.write(", ");
+			}
+			writer.write("}");
+		}
+		
+	}
+	
+	public static class JavaCastValuePrinter extends JavaPrinter<CastValue>{
+		
+		public void print(CastValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer+"(");
+			writer.write("(");
+			writer.write(element.getType());
+			writer.write(")");
+			Value value = element.getValue();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write(")");
+		}
+		
+	}
+	
+	public static class JavaInstanceValuePrinter extends JavaPrinter<InstanceValue>{
+		
+		public void print(InstanceValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer+"new ");
+			writer.write(element.getToken());
+			writer.write("(");
+			Iterator<Value> parameters = element.getParameters().iterator();
+			while(parameters.hasNext()){
+				Value value = parameters.next();
+				provider.getPrinter(value).print(value, writer, "", provider);
+				if(parameters.hasNext()) writer.write(", ");
+			}
+			writer.write(")");
+		}
+		
+	}
+	
+	public static class JavaLambdaValuePrinter extends JavaPrinter<LambdaValue>{
+		
+		public void print(LambdaValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer+"(");
+			Iterator<LambdaParameter> parameters = element.getParameters().iterator();
+			while(parameters.hasNext()){
+				LambdaParameter parameter = parameters.next();
+				if(parameter.getType() != null){
+					writer.write(parameter.getType());
+					writer.write(" ");
+				}
+				writer.write(parameter.getName());
+				if(parameters.hasNext()) writer.write(", ");
+			}
+			writer.write(") -> ");
+			if(element.getOperations().size() == 1){
+				JavaElement value = element.getOperations().get(0);
+				provider.getPrinter(value).print(value, writer, "", provider);
+			}else{
+				writer.write("{\n");
+				Iterator<JavaElement> operations = element.getOperations().iterator();
+				while(operations.hasNext()){
+					JavaElement operation = operations.next();
+					provider.getPrinter(operation).print(operation, writer, buffer+"\t", provider);
+					if(operation instanceof Value) writer.write(";");
+					writer.write("\n");
+				}
+				writer.write("}");
+			}
+		}
+		
+	}
+	
+	public static class JavaMethodCallValuePrinter extends JavaPrinter<MethodCallValue>{
+		
+		public void print(MethodCallValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+			writer.write(buffer);
+			Value base = element.base();
+			if(base != null){
+				provider.getPrinter(base).print(base, writer, "", provider);
+				writer.write(".");
+			}
+			if(element.getGeneric() != null){
+				writer.write("<");
+				writer.write(element.getGeneric());
+				writer.write(">");
+			}
+			writer.write(element.getToken());
+			writer.write("(");
+			Iterator<Value> parameters = element.getParameters().iterator();
+			while(parameters.hasNext()){
+				Value value = parameters.next();
+				provider.getPrinter(value).print(value, writer, "", provider);
+				if(parameters.hasNext()) writer.write(", ");
+			}
+			writer.write(")");
+		}
+		
+	}
+	
+	public static class JavaModifierValuePrinter extends JavaPrinter<ModifierValue>{
+		
+		public void print(ModifierValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer+element.getModifier());
+			Value value = element.getValue();
+			provider.getPrinter(value).print(value, writer, "", provider);
+		}
+		
+	}
+	
+	public static class JavaVariableAccessValuePrinter extends JavaPrinter<VariableAccessValue>{
+		
+		public void print(VariableAccessValue element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception{
+			writer.write(buffer);
+			Value value = element.base();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write(".");
+			writer.write(element.getVariable());
+		}
+		
+	}
+
+}

src/dev/peerat/parser/java/printer/JavaVariablePrinter.java

@@ -0,0 +1,24 @@
+package dev.peerat.parser.java.printer;
+
+import java.lang.reflect.Modifier;
+
+import dev.peerat.parser.java.Variable;
+import dev.peerat.parser.java.value.Value;
+
+public class JavaVariablePrinter extends JavaPrinter<Variable>{
+
+	@Override
+	public void print(Variable element, Writer writer, String buffer, JavaPrintProvider provider) throws Exception {
+		writer.write(buffer+Modifier.toString(element.getModifier())+" ");
+		writer.write(element.getType());
+		writer.write(" ");
+		writer.write(element.getName());
+		if(element.getValue() != null){
+			writer.write(" = ");
+			Value value = element.getValue();
+			provider.getPrinter(value).print(value, writer, "", provider);
+			writer.write(";");
+		}
+	}
+
+}

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

@@ -0,0 +1,45 @@
+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("modifier") == null ? 0 : bag.get("modifier"),
+							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))).loop();
+	}
+	
+	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,86 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.Bag;
+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("modifier") == null ? 0 : bag.<Bag>get("modifier").get(),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("modifier") == null ? 0 : bag.<Bag>get("modifier").get(),
+							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("modifier") == null ? 0 : bag.<Bag>get("modifier").get(),
+							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,30 @@
+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> value = this.registery.getNode(ValueTree.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);
+		function_container.then(value);
+	}
+
+}

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/ImportTree.java

@@ -0,0 +1,45 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.Import;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class ImportTree extends SyntaxTree<JavaElement> {
+
+	public ImportTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init() {
+		this.current.then((validator) -> {
+			if(validator.validate(
+					(token) -> token.getValue().equals("import"))){
+				
+				validator.validate(
+						(token) -> token.getValue().equals("static"),
+						(bag, token) -> bag.set("static", null));
+				
+				while(validator.validate(
+						(token) -> !token.getValue().equals(";"),
+						(bag, token) -> {
+							Token current = bag.get();
+							if(current == null) bag.set(token);
+							else bag.set(current.concat(token));
+						})
+					);
+				
+				return validator.validate((token) -> token.getValue().equals(";"));
+			}
+			return false;
+		}).<JavaElement>end((parent, bag) -> {
+			((JavaFile)parent).addImport(new Import(bag.has("static"), bag.get()));
+			return parent;
+		});
+	}
+}

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

@@ -0,0 +1,55 @@
+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> 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/JavaTree.java

@@ -0,0 +1,47 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.JavaFile;
+import dev.peerat.parser.state.InitialStateTree;
+import dev.peerat.parser.state.StateTree;
+import dev.peerat.parser.tree.SyntaxTree;
+import dev.peerat.parser.tree.SyntaxTreeRegistery;
+
+public class JavaTree extends SyntaxTree<JavaElement> {
+
+	public JavaTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new InitialStateTree<>();
+	}
+
+	@Override
+	public void init() {
+		InitialStateTree<JavaElement> main = (InitialStateTree<JavaElement>) this.current;
+		StateTree<JavaElement> pack = main.then((validator) -> {
+			if(validator.validate(
+					(token) -> token.getValue().equals("package"))){
+				
+				while(validator.validate(
+						(token) -> !token.getValue().equals(";"),
+						(bag, token) -> {
+							Token current = bag.get();
+							if(current == null) bag.set(token);
+							else bag.set(current.concat(token));
+						})
+					);
+				return validator.validate((token) -> token.getValue().equals(";"));
+			}
+			return false;
+		}).end((parent, bag) -> {
+			((JavaFile)parent).setPackage(bag.get());
+			return parent;
+		});
+		
+//		base.multiple(pack);
+		main.multiple(registery.getNode(ImportTree.class));
+		main.multiple(registery.getNode(AnnotationTree.class));
+		main.multiple(registery.getNode(ClassBaseTree.class));
+	}
+
+}

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

@@ -0,0 +1,34 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.tree.TreeType;
+
+public enum JavaTreeType implements TreeType{
+	
+	ALL(JavaTree.class),
+	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),
+	IMPORT(ImportTree.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,297 @@
+package dev.peerat.parser.java.tree;
+
+import dev.peerat.parser.TokenType;
+import dev.peerat.parser.java.JavaElement;
+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.operation.Operation.OperationContainer;
+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(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());
+//					System.out.println(" "+global);
+				}));
+		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.redirect(variable).end();
+		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,446 @@
+package dev.peerat.parser.java.tree;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+
+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.ArrayAccessValue;
+import dev.peerat.parser.java.value.ArrayValue;
+import dev.peerat.parser.java.value.BiValue;
+import dev.peerat.parser.java.value.CastValue;
+import dev.peerat.parser.java.value.InstanceValue;
+import dev.peerat.parser.java.value.LambdaValue;
+import dev.peerat.parser.java.value.LambdaValue.LambdaParameter;
+import dev.peerat.parser.java.value.MethodCallValue;
+import dev.peerat.parser.java.value.ModifierValue;
+import dev.peerat.parser.java.value.StaticValue;
+import dev.peerat.parser.java.value.TriValue;
+import dev.peerat.parser.java.value.Value;
+import dev.peerat.parser.java.value.Value.ValueContainer;
+import dev.peerat.parser.java.value.VariableAccessValue;
+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> { //TODO order tree by more used branch ? to not check a whole tree to go on the last branch...
+
+	//TODO PRIORIY OF OPERATION ? BECAUSE OF != null + ?:
+	
+	public ValueTree(SyntaxTreeRegistery<JavaElement> registery) {
+		super(registery);
+		this.current = new StateTree<>();
+	}
+
+	@Override
+	public void init(){
+		StateTree<JavaElement> generic = this.registery.getNode(GenericTree.class);
+		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.then((validator) -> {
+			validator.getBag().set(new ValueChainBuilder());
+			return true;
+		});
+		StateTree<JavaElement> unary_value = new StateTree<>();
+		StateTree<JavaElement> value_operation = new StateTree<>();
+		
+		StateTree<JavaElement> redirectRight = new RedirectStateTree<>(this.current, (global, local) -> {
+			global.<ValueChainBuilder>get().right(local.get());
+		});
+		
+		//TODO -> Array and dot after a new Instance...event with {}
+		StateTree<JavaElement> value_instance = unary_value.equals("new");
+		StateTree<JavaElement> value_instance_type = value_instance.redirect(type, (global, local) -> global.set("type", local.get()));
+		StateTree<JavaElement> value_instance_params = value_instance_type.equals("(");
+		StateTree<JavaElement> value_instance_params_end = value_instance_params.equals(")", (bag, token) -> {
+			ValueChainBuilder builder = new ValueChainBuilder();
+			List<Value> parameters = bag.get("params");
+			builder.rebase(new InstanceValue(bag.get("type"), parameters == null ? new ArrayList<>() : parameters));
+			bag.remove("type");
+			bag.remove("params");
+			bag.set(builder);
+		});
+		StateTree<JavaElement> value_instance_param = value_instance_params.redirect(this.current, (global, local) -> {
+			List<Value> list = global.get("params");
+			if(list == null){
+				list = new ArrayList<>();
+				global.set("params", list);
+			}
+			list.add(local.get());
+		});
+		value_instance_param.then(value_instance_params_end);
+		value_instance_param.equals(",").then(value_instance_param);
+		value_instance_params_end.<JavaElement>end(ValueChainBuilder.build(false));
+		value_instance_params_end.equals("{")
+		.<JavaElement>end(ValueChainBuilder.build(true)).multiple(class_container)
+		.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		
+		StateTree<JavaElement> value_instance_array = value_instance_type.equals("[");
+		StateTree<JavaElement> value_instance_array_value = value_instance_array.redirect(this.current);
+		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_instance_array_init = value_instance_array_end.equals("{");
+		StateTree<JavaElement> value_instance_array_init_value = value_instance_array_init.redirect(this.current, (global, local) -> {
+			List<Value> list = global.get("array");
+			if(list == null){
+				list = new ArrayList<>();
+				global.set("array", list);
+			}
+			list.add(local.get());
+		});
+		value.equals("{").then(value_instance_array_init_value);
+		value_instance_array_init_value.equals(",").then(value_instance_array_init_value);
+		StateTree<JavaElement> value_instance_array_value_end = value_instance_array_init_value.equals("}");
+		value_instance_array_value_end.end((parent, bag) -> {
+			ArrayValue result = new ArrayValue(bag.<List<Value>>get("array").toArray(new Value[0]));
+			bag.set(result);
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(result);
+			return null;
+		});
+		
+		StateTree<JavaElement> value_name = unary_value.then((validator) -> {
+			validator.getBag().set(new ValueChainBuilder());
+			return true;
+		})
+				.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME),
+						(bag, token) -> bag.<ValueChainBuilder>get().nameValue(token)));
+		value_name.end(ValueChainBuilder.build((builder) -> builder.dot(), false));
+		value_name.then(value_operation);
+		
+		StateTree<JavaElement> value_generic_call = unary_value.then((validator) -> {
+			validator.getBag().set(new ValueChainBuilder());
+			return true;
+		}).redirect(generic, (global, local) -> global.<ValueChainBuilder>get().generic(local.get()));
+		value_generic_call.then(value_name);
+		
+		StateTree<JavaElement> value_instance_array_dot = value_instance_array_value_end.equals(".", (bag, token) -> { bag.<ValueChainBuilder>get().rebase(new ArrayValue(bag.<List<Value>>get("array").toArray(new Value[0]))); bag.remove("array"); });
+		value_instance_array_dot.then(value_name);
+		value_instance_array_dot.then(value_generic_call);
+		
+		StateTree<JavaElement> string_value = unary_value.then((validator) -> {
+			validator.getBag().set(new ValueChainBuilder());
+			return true;
+		}).then((validator) -> validator.validate(
+				(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
+				(bag, token) -> bag.<ValueChainBuilder>get().constantValue(token)));
+		string_value.end(ValueChainBuilder.build((builder) -> builder.buildStatic(), false));
+		string_value.then(value_operation);
+
+		value_operation.equals(">", action(">")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("=", action("=")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("<",action("<")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("!",action("!")).equals("=",action("!=")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("=",action("=")).equals("=",action("==")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("<",action("<")).equals("<","action","<<").then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("+",action("+")).equals("=", action("+=")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation.equals("+",action("+")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		
+		value_operation.equals("instanceof", action("instanceof")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		
+		StateTree<JavaElement> value_operation_bit_and = value_operation.equals("&",action("&"));
+		value_operation_bit_and.then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation_bit_and.equals("&",action("&&")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		StateTree<JavaElement> value_operation_bit_or = value_operation.equals("|",action("|"));
+		value_operation_bit_or.then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		value_operation_bit_or.equals("|",action("||")).then(redirectRight).end(ValueChainBuilder.build((builder) -> builder.buildOperation(), false));
+		
+		value.equals("!",modifier()).redirect(this.current, (global, local) -> global.<ValueChainBuilder>get().rebase(local.get())).end(ValueChainBuilder.build((builder) -> builder.buildModifier(), false));
+		
+		StateTree<JavaElement> left_value = value.redirect(unary_value, (global, local) -> { if(local.get() instanceof ValueChainBuilder) { global.set(local.get()); global.<ValueChainBuilder>get().extractLambda(); return;} global.<ValueChainBuilder>get().rebase(local.get());});
+		left_value.end(ValueChainBuilder.build(true));
+		left_value.equals("?")
+			.redirect(this.current, (global, local) -> global.set("success", local.get()))
+			.equals(":")
+			.redirect(this.current, (global, local) -> global.set("fail", local.get()))
+			.end((parent, bag) -> {
+				bag.set(new TriValue(bag.<ValueChainBuilder>get().base, 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(this.current, (global, local) -> global.<ValueChainBuilder>get().arrayAccess(local.get()));
+		StateTree<JavaElement> value_array_end = value_array_value.equals("]");
+		value_array_end.end(ValueChainBuilder.build(false));
+		value_array_end.then(value_array);
+		StateTree<JavaElement> value_array_dot = value_array_end.equals(".", (bag, token) -> bag.<ValueChainBuilder>get().dot());
+		value_array_dot.then(value_name);
+		value_array_dot.then(value_generic_call);
+		
+		value_instance_array_value_end.then(value_array);
+		
+		StateTree<JavaElement> operation_call = value_name.equals(".", (bag, token) -> bag.<ValueChainBuilder>get().dot());
+		operation_call.then(value_name);
+		operation_call.then(value_generic_call);
+		StateTree<JavaElement> operation_begin = value_name.equals("(", (bag, token) -> bag.<ValueChainBuilder>get().parameter());
+		StateTree<JavaElement> operation_end = operation_begin.equals(")", (bag, token) -> bag.<ValueChainBuilder>get().parameter());
+		operation_end.then(operation_call);
+		operation_end.then(value_operation);
+		operation_end.end(ValueChainBuilder.build((builder) -> builder.buildMethodCall(), false));
+		StateTree<JavaElement> operation_value = operation_begin.redirect(this.current, (global, local) -> global.<ValueChainBuilder>get().parameter(local.get()));
+		operation_value.then(operation_end);
+		operation_value.equals(",")
+				.then(operation_value);
+		
+		StateTree<JavaElement> value_parenthesis = unary_value.then((validator) -> {
+			validator.getBag().set(new ValueChainBuilder());
+			return true;
+		}).equals("(");
+		StateTree<JavaElement> value_parenthesis_close = value_parenthesis.equals(")");
+		
+		StateTree<JavaElement> value_inside_type = value_parenthesis.redirect(type, (global, local) -> global.set("type", local.get()));
+		
+		StateTree<JavaElement> value_inside = value_parenthesis.redirect(this.current, (global, local) -> {
+			if(local.get() instanceof StaticValue){
+				Token lambdaVariable = local.<StaticValue>get().getToken();
+				Token lambdaType = global.get("type");
+				if(lambdaVariable.equals(lambdaType)) lambdaType = null;
+				global.<ValueChainBuilder>get().lambda(new LambdaParameter(lambdaType, lambdaVariable));
+				global.remove("type");
+				return;
+			}
+			global.set(local.get());
+		});
+		
+		StateTree<JavaElement> cast = value_inside_type.equals(")").redirect(this.current, (global, local) -> {
+			global.<ValueChainBuilder>get().rebase(new CastValue(global.get("type"), local.get()));
+			global.remove("type");
+		});
+		
+		
+		cast.end(ValueChainBuilder.build(false));
+		StateTree<JavaElement> cast_dot = cast.equals(".");
+		cast_dot.then(value_name);
+		cast_dot.then(value_generic_call);
+		cast.then(value_array);
+		
+		value_inside_type.then(value_inside);
+		StateTree<JavaElement> value_inside_splitter = value_inside.equals(",");
+		value_inside_splitter.then(value_inside);
+		value_inside_splitter.then(value_inside_type);
+		
+		value_inside.then(value_parenthesis_close);
+		value_inside.then(value_operation);
+		value_parenthesis_close.end();
+		value_parenthesis_close.then(value_operation);
+		StateTree<JavaElement> value_parenthesis_dot = value_parenthesis_close.equals(".", (bag, token) -> {
+			ValueChainBuilder builder = new ValueChainBuilder();
+			builder.rebase(bag.get());
+			bag.set(builder);
+		});
+		value_parenthesis_dot.then(value_generic_call);
+		value_parenthesis_dot.then(value_name);
+		
+		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(
+					ValueChainBuilder.build((builder) -> builder.buildLambda(), true)
+					).multiple(function_container)
+			.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end();
+		
+		value_lambda.redirect(unary_value, (global, local) -> {
+			global.<ValueChainBuilder>get().buildLambda(local.get());
+		}).end(ValueChainBuilder.build(false));
+		
+	}
+	
+	private BiConsumer<Bag, Token> action(String action){
+		return (bag, token) -> {
+			if(!(bag.get() instanceof ValueChainBuilder)){
+				ValueChainBuilder builder = new ValueChainBuilder();
+				builder.rebase(bag.get());
+				builder.action(action);
+				bag.set(builder);
+				return;
+			}
+			bag.<ValueChainBuilder>get().action(action);
+		};
+	}
+	
+	private BiConsumer<Bag, Token> modifier(){
+		return (bag, token) -> bag.<ValueChainBuilder>get().modifier(token);
+	}
+	
+	private static class ValueChainBuilder{
+		
+		static BiFunction<JavaElement, Bag, JavaElement> build(Consumer<ValueChainBuilder> builder, boolean returnValue){
+			return (parent, bag) -> {
+				ValueChainBuilder chainBuilder = bag.get();
+				builder.accept(chainBuilder);
+				chainBuilder.build(parent, bag);
+				return returnValue ? bag.get() : null;
+			};
+		}
+		
+		static BiFunction<JavaElement, Bag, JavaElement> build(boolean returnValue){
+			return (parent, bag) -> {
+				ValueChainBuilder chainBuilder = bag.get();
+				chainBuilder.build(parent, bag);
+				return returnValue ? bag.get() : null;
+			};
+		}
+		
+		//TODO fall back branch problem cause one instance in multiple branch's bag ?
+		private Value base;
+		
+		private Token current;
+		
+		private Token generic;
+		
+		private Token modifier;
+		
+		private String action;
+		private Value right;
+
+		private List<Value> parameters;
+		
+		private List<LambdaParameter> lambda;
+		
+		ValueChainBuilder(){
+			
+		}
+		
+		public void rebase(Value base){
+			this.base = base;
+		}
+		
+		public void nameValue(Token token) {
+			this.current = token;
+		}
+		
+		public void constantValue(Token token){
+			this.current = token;
+		}
+		
+		public void action(String action){
+			this.action = action;
+		}
+		
+		public void right(Value value){
+			this.right = value;
+		}
+		
+		public void generic(Token token){
+			this.generic = token;
+		}
+		
+		public void modifier(Token token){
+			this.modifier = token;
+		}
+		
+		public void dot(){
+			if(this.base == null){
+				buildStatic();
+				this.current = null;
+				return;
+			}
+			if(this.current != null){
+				buildVariableAccess();
+				this.current = null;
+			}
+		}
+		
+		public void parameter(Value value){
+			this.parameters.add(value);
+		}
+		
+		public void parameter(){
+			if(this.parameters == null){
+				this.parameters = new ArrayList<>();
+				return;
+			}
+			buildMethodCall();
+			this.current = null;
+			this.parameters = null;
+		}
+		
+		public void arrayAccess(Value value){
+			this.base = new ArrayAccessValue(this.base, value);
+		}
+		
+		public void lambda(LambdaParameter value){
+			if(this.lambda == null) this.lambda = new ArrayList<>();
+			else{
+				LambdaParameter last = this.lambda.get(this.lambda.size()-1);
+				if(last.getName().equals(value.getType())) this.lambda.remove(this.lambda.size()-1);
+			}
+			this.lambda.add(value);
+		}
+		
+		public void buildModifier(){
+			if(this.base == null) return; //TODO throws exception in this case
+			this.base = new ModifierValue(this.modifier, this.base);
+		}
+		
+		public void buildStatic(){
+			if(this.current == null) return;
+			this.base = new StaticValue(this.current);
+		}
+		
+		public void buildOperation(){
+			if(this.base != null && this.current != null) buildVariableAccess();
+			if(this.lambda != null) extractLambda();
+			this.base = new BiValue(current == null ? base : new StaticValue(current), action, right);
+		}
+		
+		public void buildMethodCall(){
+			if(this.current == null) return;
+			this.base = new MethodCallValue(this.base, this.generic, this.current, this.parameters);
+			this.generic = null;
+			this.current = null;
+			this.parameters = null;
+		}
+		
+		public void buildVariableAccess(){
+			this.base = new VariableAccessValue(this.base, this.current);
+			this.current = null;
+		}
+		
+		public void buildLambda(){
+			this.base = new LambdaValue(this.lambda == null ? new ArrayList<>() : this.lambda);
+			this.lambda = null;
+		}
+		
+		public void buildLambda(Value value){
+			this.base = new LambdaValue(this.lambda == null ? new ArrayList<>() : this.lambda, value);
+			this.lambda = null;
+		}
+		
+		public void extractLambda(){
+			this.base = new StaticValue(this.lambda.get(0).getName());
+		}
+		
+		public void build(JavaElement parent, Bag bag){
+			bag.set(base);
+			if(parent instanceof ValueContainer) ((ValueContainer)parent).addValue(base);
+		}
+		
+		@Override
+		public String toString(){
+			String result = "ValueChainBuilder{";
+			try{
+				for(Field field : getClass().getDeclaredFields()){
+					result+="\n\t"+field.getName()+"="+field.get(this);
+				}
+			}catch(Exception ex){}
+			
+			return result+"\n}";
+		}
+	}
+	
+}

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/ArrayAccessValue.java

@@ -0,0 +1,60 @@
+package dev.peerat.parser.java.value;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ArrayAccessValue extends Value{
+	
+	private Value base;
+	private Value access;
+	
+	public ArrayAccessValue(Value base, Value access){
+		this.base = base;
+		this.access = access;
+	}
+	
+	public Value base(){
+		return this.base;
+	}
+	
+	public Value getAccessor(){
+		return this.access;
+	}
+	
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.base.visit(visitor));
+		bag.merge(this.access.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		bag.merge(this.base.visit(visitor));
+		bag.merge(this.access.visit(visitor));
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,52 @@
+package dev.peerat.parser.java.value;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class ArrayValue extends Value{
+	
+	private Value[] values;
+	
+	public ArrayValue(Value[] values){
+		this.values = values;
+	}
+	
+	public Value[] getValues(){
+		return this.values;
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		for(Value value : this.values) bag.merge(value.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		for(Value value : this.values) bag.merge(value.visit(visitor));
+		return bag;
+	}
+
+}

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

@@ -0,0 +1,68 @@
+package dev.peerat.parser.java.value;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.java.visitor.JavaVisitor;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class BiValue extends Value{
+	
+	private Value left;
+	private String action;
+	private Value right;
+	
+	public BiValue(Value left, String action, Value right){
+		this.left = left;
+		this.action = action;
+		this.right = right;
+	}
+	
+	public Value left(){
+		return left;
+	}
+	
+	public String getAction(){
+		return this.action;
+	}
+	
+	public Value right(){
+		return right;
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public String toString(){
+		return "[BiValue] "+left+" "+action+" "+right;
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(left.visit(visitor));
+		bag.merge(right.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		return new VisitorBag();
+	}
+}

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

@@ -0,0 +1,63 @@
+package dev.peerat.parser.java.value;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import dev.peerat.parser.Token;
+import dev.peerat.parser.java.JavaElement;
+import dev.peerat.parser.visitor.TokenVisitor;
+import dev.peerat.parser.visitor.Visitor;
+import dev.peerat.parser.visitor.VisitorBag;
+
+public class CastValue extends Value{
+	
+	private Token type;
+	private Value value;
+	
+	public CastValue(Token type, Value value){
+		this.type = type;
+		this.value = value;
+	}
+	
+	public Token getType(){
+		return this.type;
+	}
+	
+	public Value getValue(){
+		return this.value;
+	}
+
+	@Override
+	public <E extends JavaElement> E find(Predicate<JavaElement> finder) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+	@Override
+	public <E extends JavaElement> void findAll(Predicate<JavaElement> finder, Collection<E> collector) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public VisitorBag visit(Visitor<JavaElement> visitor) {
+		if(visitor.canVisit(getClass())) return visitor.visit(this);
+		VisitorBag bag = new VisitorBag();
+		bag.merge(value.visit(visitor));
+		return bag;
+	}
+	
+	@Override
+	public String toString(){
+		return "[CastValue] (("+type+") "+value+")";
+	}
+	
+	@Override
+	public VisitorBag visit(TokenVisitor visitor){
+		VisitorBag bag = new VisitorBag();
+		return bag;
+	}
+
+}