From 73dd0f87cef2cfe90d90f3fd1300b5a5016626c7 Mon Sep 17 00:00:00 2001 From: jeffcheasey88 <66554203+jeffcheasey88@users.noreply.github.com> Date: Wed, 5 Jul 2023 10:31:14 +0200 Subject: [PATCH] First Commit, parser V2 --- .classpath | 6 + .gitignore | 3 + .../jeffcheasey88/peeratcode/parser/Bag.java | 32 +++ .../peeratcode/parser/Parser.java | 27 ++ .../peeratcode/parser/Token.java | 43 +++ .../peeratcode/parser/TokenType.java | 10 + .../peeratcode/parser/TokenValidator.java | 96 +++++++ .../peeratcode/parser/Tokenizer.java | 71 +++++ .../peeratcode/parser/java/Class.java | 24 ++ .../peeratcode/parser/java/Function.java | 19 ++ .../peeratcode/parser/java/JavaElement.java | 5 + .../peeratcode/parser/java/JavaFile.java | 36 +++ .../peeratcode/parser/java/JavaParser.java | 255 ++++++++++++++++++ .../peeratcode/parser/java/Variable.java | 6 + .../parser/state/BinaryStateTree.java | 34 +++ .../parser/state/BuilderStateTree.java | 26 ++ .../parser/state/RedirectStateTree.java | 44 +++ .../peeratcode/parser/state/StateTree.java | 78 ++++++ 18 files changed, 815 insertions(+) create mode 100644 .classpath create mode 100644 .gitignore create mode 100644 src/be/jeffcheasey88/peeratcode/parser/Bag.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/Parser.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/Token.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/TokenType.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/Tokenizer.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/Class.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/Function.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/java/Variable.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/state/BinaryStateTree.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java create mode 100644 src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..51a8bba --- /dev/null +++ b/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..54ac269 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.settings/ +bin/ +.project diff --git a/src/be/jeffcheasey88/peeratcode/parser/Bag.java b/src/be/jeffcheasey88/peeratcode/parser/Bag.java new file mode 100644 index 0000000..a5c028c --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/Bag.java @@ -0,0 +1,32 @@ +package be.jeffcheasey88.peeratcode.parser; + +import java.util.HashMap; +import java.util.Map; + +public class Bag{ + + private Map map; + + private Object value; + + public Bag(){ + this.map = new HashMap<>(); + } + + public E get(){ + return (E) this.value; + } + + public void set(Object value){ + this.value = value; + } + + public E get(String key){ + return (E) this.map.get(key); + } + + public void set(String key, Object value){ + this.map.put(key, value); + } + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/Parser.java b/src/be/jeffcheasey88/peeratcode/parser/Parser.java new file mode 100644 index 0000000..eb91ab8 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/Parser.java @@ -0,0 +1,27 @@ +package be.jeffcheasey88.peeratcode.parser; + +import java.io.BufferedReader; + +import be.jeffcheasey88.peeratcode.parser.state.StateTree; + +public class Parser{ + + private Tokenizer tokenizer; + private StateTree state; + + public Parser(){} + + public void setTokenizer(Tokenizer tokenizer){ + this.tokenizer = tokenizer; + } + + public void setStateTree(StateTree stateTree){ + this.state = stateTree; + } + + public final void parse(BufferedReader reader, E container) throws Exception{ + this.tokenizer.parse(reader); + + this.state.seed(this.tokenizer, container); + } +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/Token.java b/src/be/jeffcheasey88/peeratcode/parser/Token.java new file mode 100644 index 0000000..82f0234 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/Token.java @@ -0,0 +1,43 @@ +package be.jeffcheasey88.peeratcode.parser; + +public class Token{ + + private int line; + private int character; + private TokenType type; + + private String value; + + public Token(int line, int character, String value, TokenType type){ + this.line = line; + this.character = character; + this.value = value; + this.type = type; + } + + public int getLineNumber(){ + return this.line; + } + + public int getCharacterNumber(){ + return this.character; + } + + public TokenType getType(){ + return this.type; + } + + public String getValue(){ + return this.value; + } + + //line & character start & end ? + public Token concat(Token token){ + return new Token(line, character, value+token.getValue(), TokenType.GROUP); + } + + @Override + public String toString(){ + return "Token["+line+";"+character+";"+type+";"+value+"]"; + } +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/TokenType.java b/src/be/jeffcheasey88/peeratcode/parser/TokenType.java new file mode 100644 index 0000000..f4ff02d --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/TokenType.java @@ -0,0 +1,10 @@ +package be.jeffcheasey88.peeratcode.parser; + +public enum TokenType{ + + NAME, + DELIMITER, + SPACE, + GROUP + +} \ No newline at end of file diff --git a/src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java b/src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java new file mode 100644 index 0000000..fec3052 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java @@ -0,0 +1,96 @@ +package be.jeffcheasey88.peeratcode.parser; + +import java.util.Iterator; +import java.util.function.BiConsumer; +import java.util.function.Function; + +public class TokenValidator implements Iterator{ + + 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 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 action, BiConsumer 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; + } + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/Tokenizer.java b/src/be/jeffcheasey88/peeratcode/parser/Tokenizer.java new file mode 100644 index 0000000..6a6724f --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/Tokenizer.java @@ -0,0 +1,71 @@ +package be.jeffcheasey88.peeratcode.parser; + +import java.io.BufferedReader; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +public class Tokenizer { + + private List tokens; + + private boolean optionSpace; + private Consumer> postProcessor; + + public Tokenizer(){ + this.tokens = new ArrayList<>(); + } + + public Tokenizer takeSpacement(){ + this.optionSpace = true; + return this; + } + + public void postProcess(Consumer> postProcess){ + this.postProcessor = postProcess; + } + + public List getTokens(){ + return this.tokens; + } + + public void parse(BufferedReader reader) throws Exception{ + int lineNumber = 0; + String line; + while((line = reader.readLine()) != null){ + lineNumber++; + + for(int i = 0; i < line.length(); i++){ + char c = line.charAt(i); + Token token; + if(Character.isAlphabetic(c) || Character.isDigit(c)){ + String value = ""; + int j = i; + for(; j < line.length(); j++){ + c = line.charAt(j); + if(Character.isAlphabetic(c) || Character.isDigit(c)) value+=c; + else break; + } + token = new Token(lineNumber, 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(lineNumber, i+1, value, TokenType.SPACE); + i = j-1; + }else{ + token = new Token(lineNumber, i+1, ""+c, TokenType.DELIMITER); + } + this.tokens.add(token); + } + } + + if(this.postProcessor != null) this.postProcessor.accept(tokens); + } + +} \ No newline at end of file diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/Class.java b/src/be/jeffcheasey88/peeratcode/parser/java/Class.java new file mode 100644 index 0000000..44b5d1d --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/Class.java @@ -0,0 +1,24 @@ +package be.jeffcheasey88.peeratcode.parser.java; + +import be.jeffcheasey88.peeratcode.parser.Bag; +import be.jeffcheasey88.peeratcode.parser.Token; + +public class Class extends JavaElement{ + + private String name; + private String extend; + private String implement; + + public Class(Bag bag){ + this.name = bag.get("name").get().getValue(); + + Bag extendBag = bag.get("extend"); + if(extendBag != null) this.extend = extendBag.get().getValue(); + + Bag implementBag = bag.get("implement"); + if(implementBag != null) this.implement = implementBag.get().getValue(); + + System.out.println("public "+name+" extends "+extend+" implements "+implement+" {"); + } + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/Function.java b/src/be/jeffcheasey88/peeratcode/parser/java/Function.java new file mode 100644 index 0000000..8735481 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/Function.java @@ -0,0 +1,19 @@ +package be.jeffcheasey88.peeratcode.parser.java; + +import be.jeffcheasey88.peeratcode.parser.Bag; +import be.jeffcheasey88.peeratcode.parser.Token; + +public class Function extends JavaElement{ + + private String returnType; + private String name; + + public Function(Bag bag){ + this.returnType = bag.get("return").get().getValue(); + if(JavaParser.getModifier(this.returnType) > 0) this.returnType = null; + this.name = bag.get("name").getValue(); + + System.out.println(returnType+" "+name+" (){"); + } + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java b/src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java new file mode 100644 index 0000000..edfd466 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java @@ -0,0 +1,5 @@ +package be.jeffcheasey88.peeratcode.parser.java; + +public class JavaElement { + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java b/src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java new file mode 100644 index 0000000..fc7579d --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java @@ -0,0 +1,36 @@ +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 imports; + private Class clazz; + + public JavaFile(){ + this.imports = new ArrayList<>(); + } + + JavaFile setPackage(Bag bag){ + this.pack = bag.get("package").getValue(); + System.out.println("setPackage "+pack); + return this; + } + + JavaFile addImport(Bag bag){ + this.imports.add(bag.get("import").getValue()); + System.out.println("addImport "+imports.get(imports.size()-1)); + return this; + } + + Class setClass(Class clazz){ + this.clazz = clazz; + System.out.println("setClass "+clazz); + return clazz; + } +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java b/src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java new file mode 100644 index 0000000..fedd706 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java @@ -0,0 +1,255 @@ +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.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.state.RedirectStateTree; +import be.jeffcheasey88.peeratcode.parser.state.StateTree; + +public class JavaParser extends Parser { + + 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 parser = new JavaParser(); + JavaFile jFile = new JavaFile(); + parser.parse(reader, jFile); + + System.out.println((System.currentTimeMillis()-time)+"ms"); + } + + private static final + Function + 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 + END_PACKAGE = ((javafile, validator) -> javafile.setPackage(validator.getBag())), + END_IMPORT = ((javafile, validator) -> javafile.addImport(validator.getBag())); + BiFunction + END_CLASS = ((javafile, validator) -> javafile.setClass(new Class(validator.getBag()))); + BiFunction + END_TYPE = ((javafile, validator) -> { + System.out.println("return token "+validator.getBag().get()); + return validator.getBag().get(); + }); + BiFunction + END_VAR = ((javafile, validator) -> { + System.out.println("new var"); + return new Variable(); + }); + BiFunction + END_FUNC = ((javafile, validator) -> { + System.out.println("new function"); + return new be.jeffcheasey88.peeratcode.parser.java.Function(validator.getBag()); + }); + BiFunction + END_MODIFIER = ((javafile, validator) ->{ + return validator.getBag().get(); + }); + + public JavaParser(){ + Tokenizer tokenizer = new Tokenizer(); + + Function LAMBDA_0 = (v) -> v.validate((t) -> t.getValue().equals("package")); + Function LAMBDA_1 = (v) -> v.validate((t) -> t.getValue().equals(";")); + Function LAMBDA_3 = (v) -> v.validate((t) -> t.getValue().equals("import")); + Function LAMBDA_4 = (v) -> v.validate((t) -> t.getValue().equals("static"), (bag, token) -> bag.set("static", "bool")); + Function LAMBDA_5 = (v) -> v.validate((t) -> t.getValue().equals("<")); + Function LAMBDA_6 = (v) -> v.validate((t) -> t.getValue().equals(">")); + Function LAMBDA_7 = (v) -> v.validate((t) -> t.getValue().equals(",")); + Function LAMBDA_8 = (v) -> v.validate((t) -> t.getValue().equals("{value}")); + Function LAMBDA_9 = (v) -> v.validate((t) -> t.getValue().equals("=")); + BiFunction END_10 = ((javaelement, validator) -> null); + Function LAMBDA_11 = (v) -> v.validate((t) -> t.getValue().equals(".")); + Function LAMBDA_12 = (v) -> v.validate((t) -> t.getValue().equals("if")); + Function LAMBDA_13 = (v) -> v.validate((t) -> t.getValue().equals("(")); + Function LAMBDA_14 = (v) -> v.validate((t) -> t.getValue().equals(")")); + Function LAMBDA_15 = (v) -> v.validate((t) -> t.getValue().equals("for")); + Function LAMBDA_16 = (v) -> v.validate((t) -> t.getValue().equals("while")); + Function LAMBDA_17 = (v) -> v.validate((t) -> t.getValue().equals("return")); + Function LAMBDA_18 = (v) -> v.validate((t) -> t.getValue().equals("synchronized")); + Function LAMBDA_19 = (v) -> v.validate((t) -> t.getValue().equals("continue")); + Function LAMBDA_20 = (v) -> v.validate((t) -> t.getValue().equals("throw")); + Function LAMBDA_21 = (v) -> v.validate((t) -> t.getValue().equals("break")); + Function LAMBDA_22 = (v) -> v.validate((t) -> t.getValue().equals("try")); + Function LAMBDA_23 = (v) -> v.validate((t) -> t.getValue().equals("do")); + Function LAMBDA_24 = (v) -> v.validate((t) -> t.getValue().equals("{")); + Function LAMBDA_25 = (v) -> v.validate((t) -> t.getValue().equals("}")); + Function LAMBDA_28 = (v) -> v.validate((t) -> t.getValue().equals("throws")); + Function LAMBDA_30 = (v) -> v.validate((t) -> t.getValue().equals("class")); + Function LAMBDA_31 = (v) -> v.validate((t) -> t.getValue().equals("implements")); + Function LAMBDA_32 = (v) -> v.validate((t) -> t.getValue().equals("extends")); + + StateTree main = new StateTree<>(); + StateTree package_q0 = new StateTree<>(); + package_q0.then(LAMBDA_0).then((v) -> v.validate((t) -> !t.getValue().equals(";"), groupToken("package"))).loop().then(LAMBDA_1).end(END_PACKAGE); + + StateTree import_q0 = new StateTree<>(); + StateTree import_q1 = import_q0.then(LAMBDA_3); + StateTree import_q3 = import_q1.then((v) -> v.validate((t) -> !t.getValue().equals(";"), groupToken("import"))).loop(); + import_q3.then(LAMBDA_1).end(END_IMPORT); + StateTree import_q2 = import_q1.then(LAMBDA_4); + import_q2.then(import_q3); + + StateTree modifier_q0 = new StateTree<>(); + modifier_q0.then(LAMBDA_mod).end(END_MODIFIER); + + StateTree type_q0 = new StateTree<>(); + StateTree type_q1 = type_q0.then(LAMBDA_name); + StateTree type_q3 = type_q1.then(LAMBDA_5); + StateTree type_q4 = type_q3.then(LAMBDA_name); + StateTree type_q5 = type_q4.then(LAMBDA_6).loop(); + type_q5.end(END_TYPE); + StateTree type_q6 = type_q4.then(LAMBDA_7); + type_q5.then(type_q6); + type_q5.then(type_q4); + type_q6.then(type_q4); + type_q4.then(type_q3); + type_q1.end(END_TYPE); + + StateTree variable_q0 = new StateTree<>(); + StateTree variable_q1 = variable_q0.then(new RedirectStateTree<>(type_q0,(bag) -> "type")); + StateTree variable_q2 = variable_q1.then(LAMBDA_name); + StateTree variable_q5 = variable_q2.then(LAMBDA_7); + StateTree variable_q7 = variable_q2.then(LAMBDA_9).then(LAMBDA_8); + variable_q7.then(variable_q5); + variable_q2.then(LAMBDA_1).end(END_VAR); + variable_q7.then(LAMBDA_1).end(END_VAR); + variable_q5.then(variable_q2); + StateTree variable_q10 = variable_q0.then(new RedirectStateTree<>(modifier_q0,(bag) -> "modifier")); + variable_q10.then(variable_q1); + + StateTree operation_q0 = new StateTree<>(); + StateTree operation_q1 = operation_q0.then(LAMBDA_name); + operation_q1.then(LAMBDA_9).then(LAMBDA_8).end(END_10); + StateTree operation_q5 = operation_q1.then(LAMBDA_11); + operation_q5.then(operation_q1); + operation_q0.then(LAMBDA_12).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).end(END_10); + operation_q0.then(LAMBDA_15).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).end(END_10); + operation_q0.then(LAMBDA_16).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).end(END_10); + operation_q0.then(LAMBDA_17).then(LAMBDA_8).then(LAMBDA_1).end(END_10); + operation_q0.then(LAMBDA_18).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).end(END_10); + operation_q0.then(LAMBDA_19).then(LAMBDA_1).end(END_10); + operation_q0.then(LAMBDA_20).then(LAMBDA_8).then(LAMBDA_1).end(END_10); + operation_q0.then(LAMBDA_21).then(LAMBDA_1).end(END_10); + operation_q0.then(LAMBDA_22).end(END_10); + + StateTree function_q17 = new StateTree<>(); + StateTree function_q18 = function_q17.then(LAMBDA_24); + function_q18.then(LAMBDA_25).end((a,b) -> null); + StateTree function_q22 = function_q18.then(new RedirectStateTree<>(operation_q0,(bag) -> "operation")); + function_q22.then(function_q18); + StateTree function_q21 = function_q18.then(new RedirectStateTree<>(variable_q0,(bag) -> "variable")); + function_q21.then(function_q18); + StateTree function_q0 = new StateTree<>(); + StateTree function_q1 = function_q0.then(new RedirectStateTree<>(type_q0,(bag) -> "return")); + function_q1.then(LAMBDA_24).end(END_FUNC).then(function_q17); + StateTree function_q3 = function_q1.then((v) -> v.validate( + (t) -> t.getType().equals(TokenType.NAME), + (bag, token) -> bag.set("name", token))).then(LAMBDA_13); + StateTree function_q4 = function_q3.then(LAMBDA_14); + StateTree function_q10 = function_q4.then(LAMBDA_28).then(new RedirectStateTree<>(type_q0,(bag) -> "type")); + function_q10.end(END_FUNC).then(function_q17); + StateTree function_q11 = function_q10.then(LAMBDA_7); + function_q11.then(function_q10); + function_q4.end(END_FUNC).then(function_q17); + StateTree function_q7 = function_q3.then(new RedirectStateTree<>(type_q0,(bag) -> "type")).then(LAMBDA_name); + function_q7.then(function_q4); + StateTree function_q6 = function_q3.then(new RedirectStateTree<>(type_q0,(bag) -> "type")); + StateTree function_q8 = function_q7.then(LAMBDA_7); + function_q8.then(function_q6); + StateTree function_q15 = function_q0.then(new RedirectStateTree<>(modifier_q0,(bag) -> "modifier")); + function_q15.then(function_q1); + + StateTree class_q16 = new StateTree<>(); + StateTree class_q18 = class_q16.then(new RedirectStateTree<>(variable_q0,(bag) -> "?")); + class_q18.then(class_q16); + StateTree class_q19 = class_q16.then(new RedirectStateTree<>(function_q0,(bag) -> "?")); + class_q19.then(class_q16); + StateTree class_q0 = new StateTree<>(); + StateTree class_q1 = class_q0.then(LAMBDA_30); + StateTree class_q2 = class_q1.then(new RedirectStateTree<>(type_q0,(bag) -> "name")); + StateTree class_q9 = class_q2.then(LAMBDA_31); + StateTree class_q11 = class_q9.then(new RedirectStateTree<>(type_q0,(bag) -> "implement")); + class_q11.then(LAMBDA_24).end(END_CLASS).then(class_q16); + StateTree class_q12 = class_q11.then(LAMBDA_7); + class_q12.then(class_q11); + StateTree class_q7 = class_q2.then(LAMBDA_32).then(new RedirectStateTree<>(type_q0,(bag) -> "extend")); + class_q7.then(class_q9); + class_q7.then(LAMBDA_24).end(END_CLASS).then(class_q16); + class_q2.then(LAMBDA_24).end(END_CLASS).then(class_q16); + StateTree class_q3 = class_q0.then(new RedirectStateTree<>(modifier_q0,(bag) -> "modifier")); + class_q3.then(class_q1); + + main.then(new RedirectStateTree<>(package_q0, (b) -> null)).then(main); + main.then(new RedirectStateTree<>(import_q0, (b) -> null)).then(main); + main.then(new RedirectStateTree<>(class_q0, (b) -> null)).then(main); + + + + System.out.println((System.currentTimeMillis()-time)+"ms"); + +// try { +// DebugServer server = new DebugServer(main); +// } catch (Exception e) { +// e.printStackTrace(); +// } + + setTokenizer(tokenizer); + setStateTree(main); + } + + private BiConsumer 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; + } + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/java/Variable.java b/src/be/jeffcheasey88/peeratcode/parser/java/Variable.java new file mode 100644 index 0000000..55f8381 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/java/Variable.java @@ -0,0 +1,6 @@ +package be.jeffcheasey88.peeratcode.parser.java; + +public class Variable extends JavaElement{ + + +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/state/BinaryStateTree.java b/src/be/jeffcheasey88/peeratcode/parser/state/BinaryStateTree.java new file mode 100644 index 0000000..ae66494 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/state/BinaryStateTree.java @@ -0,0 +1,34 @@ +package be.jeffcheasey88.peeratcode.parser.state; + +import java.util.function.Function; + +import be.jeffcheasey88.peeratcode.parser.TokenValidator; + +public class BinaryStateTree extends StateTree{ + + private Function condition; + + private StateTree success; + private StateTree fail; + + public BinaryStateTree(Function checker){ + super(); + + this.condition = checker; + } + + @Override + B internalSeed(TokenValidator validator, E element){ + return ((this.condition.apply(validator)) ? success : fail).internalSeed(validator, element); + } + + public StateTree success(StateTree state){ + success = state; + return state; + } + + public StateTree fail(StateTree state){ + fail = state; + return state; + } +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java b/src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java new file mode 100644 index 0000000..7670072 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java @@ -0,0 +1,26 @@ +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 extends StateTree{ + + private BiFunction builder; + + public BuilderStateTree(BiFunction 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; + } +} diff --git a/src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java b/src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java new file mode 100644 index 0000000..e3f9fb6 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java @@ -0,0 +1,44 @@ +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 extends StateTree{ + + private StateTree redirect; + private Function group; + + public RedirectStateTree(StateTree redirect, Function group){ + super(); + this.redirect = redirect; + this.group = group; + } + + @Override + 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); + } +} + diff --git a/src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java b/src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java new file mode 100644 index 0000000..ffcaeb1 --- /dev/null +++ b/src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java @@ -0,0 +1,78 @@ +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{ + + private List> childs; + + Function checker; + private BuilderStateTree 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 internalSeed(TokenValidator validator, E element){ + for(StateTree 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 > StateTree then(StateTree child){ + childs.add(child); + return child; + } + + public > StateTree then(Function checker){ + StateTree state = new StateTree<>(); + state.checker = checker; + this.childs.add(state); + return state; + } + + public > StateTree loop(){ + this.childs.add(this); + return this; + } + + public StateTree end(BiFunction builder){ + BuilderStateTree builderState = new BuilderStateTree<>(builder); + this.builder = builderState; + return builderState; + } + +}