Peer-at-Code/peer-at-code-parser-java
5
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

First Commit, parser V2

Browse source
This commit is contained in:
jeffcheasey88 2023-07-05 10:31:14 +02:00
commit 73dd0f87ce
18 changed files with 815 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.classpath Normal file
View file

@ -0,0 +1,6 @@
<?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="output" path="bin"/>
</classpath>

3
.gitignore vendored Normal file
View file

@ -0,0 +1,3 @@
.settings/
bin/
.project

32
src/be/jeffcheasey88/peeratcode/parser/Bag.java Normal file
View file

@ -0,0 +1,32 @@
package be.jeffcheasey88.peeratcode.parser;
import java.util.HashMap;
import java.util.Map;
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);
}
}

27
src/be/jeffcheasey88/peeratcode/parser/Parser.java Normal file
View file

@ -0,0 +1,27 @@
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);
}
}

43
src/be/jeffcheasey88/peeratcode/parser/Token.java Normal file
View file

@ -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+"]";
}
}

10
src/be/jeffcheasey88/peeratcode/parser/TokenType.java Normal file
View file

@ -0,0 +1,10 @@
package be.jeffcheasey88.peeratcode.parser;
public enum TokenType{
NAME,
DELIMITER,
SPACE,
GROUP
}

96
src/be/jeffcheasey88/peeratcode/parser/TokenValidator.java Normal file
View file

@ -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<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;
}
}

71
src/be/jeffcheasey88/peeratcode/parser/Tokenizer.java Normal file
View file

@ -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<Token> tokens;
private boolean optionSpace;
private Consumer<List<Token>> postProcessor;
public Tokenizer(){
this.tokens = new ArrayList<>();
}
public Tokenizer takeSpacement(){
this.optionSpace = true;
return this;
}
public void postProcess(Consumer<List<Token>> postProcess){
this.postProcessor = postProcess;
}
public List<Token> 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);
}
}

24
src/be/jeffcheasey88/peeratcode/parser/java/Class.java Normal file
View file

@ -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.<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();
System.out.println("public "+name+" extends "+extend+" implements "+implement+" {");
}
}

19
src/be/jeffcheasey88/peeratcode/parser/java/Function.java Normal file
View file

@ -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.<Bag>get("return").<Token>get().getValue();
if(JavaParser.getModifier(this.returnType) > 0) this.returnType = null;
this.name = bag.<Token>get("name").getValue();
System.out.println(returnType+" "+name+" (){");
}
}

5
src/be/jeffcheasey88/peeratcode/parser/java/JavaElement.java Normal file
View file

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

36
src/be/jeffcheasey88/peeratcode/parser/java/JavaFile.java Normal file
View file

@ -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<String> imports;
private Class clazz;
public JavaFile(){
this.imports = 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.clazz = clazz;
System.out.println("setClass "+clazz);
return clazz;
}
}

255
src/be/jeffcheasey88/peeratcode/parser/java/JavaParser.java Normal file
View file

@ -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<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();
});
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("{value}"));
Function<TokenValidator, Boolean> LAMBDA_9 = (v) -> v.validate((t) -> t.getValue().equals("="));
BiFunction<JavaElement, TokenValidator, JavaElement> END_10 = ((javaelement, validator) -> null);
Function<TokenValidator, Boolean> LAMBDA_11 = (v) -> v.validate((t) -> t.getValue().equals("."));
Function<TokenValidator, Boolean> LAMBDA_12 = (v) -> v.validate((t) -> t.getValue().equals("if"));
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("for"));
Function<TokenValidator, Boolean> LAMBDA_16 = (v) -> v.validate((t) -> t.getValue().equals("while"));
Function<TokenValidator, Boolean> LAMBDA_17 = (v) -> v.validate((t) -> t.getValue().equals("return"));
Function<TokenValidator, Boolean> LAMBDA_18 = (v) -> v.validate((t) -> t.getValue().equals("synchronized"));
Function<TokenValidator, Boolean> LAMBDA_19 = (v) -> v.validate((t) -> t.getValue().equals("continue"));
Function<TokenValidator, Boolean> LAMBDA_20 = (v) -> v.validate((t) -> t.getValue().equals("throw"));
Function<TokenValidator, Boolean> LAMBDA_21 = (v) -> v.validate((t) -> t.getValue().equals("break"));
Function<TokenValidator, Boolean> LAMBDA_22 = (v) -> v.validate((t) -> t.getValue().equals("try"));
Function<TokenValidator, Boolean> LAMBDA_23 = (v) -> v.validate((t) -> t.getValue().equals("do"));
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_28 = (v) -> v.validate((t) -> t.getValue().equals("throws"));
Function<TokenValidator, Boolean> LAMBDA_30 = (v) -> v.validate((t) -> t.getValue().equals("class"));
Function<TokenValidator, Boolean> LAMBDA_31 = (v) -> v.validate((t) -> t.getValue().equals("implements"));
Function<TokenValidator, Boolean> LAMBDA_32 = (v) -> v.validate((t) -> t.getValue().equals("extends"));
StateTree<JavaFile> main = new StateTree<>();
StateTree<JavaFile> package_q0 = new StateTree<>();
package_q0.then(LAMBDA_0).then((v) -> v.validate((t) -> !t.getValue().equals(";"), groupToken("package"))).loop().then(LAMBDA_1).<JavaFile>end(END_PACKAGE);
StateTree<JavaFile> import_q0 = new StateTree<>();
StateTree<JavaFile> import_q1 = import_q0.then(LAMBDA_3);
StateTree<JavaFile> import_q3 = import_q1.then((v) -> v.validate((t) -> !t.getValue().equals(";"), groupToken("import"))).loop();
import_q3.then(LAMBDA_1).<JavaFile>end(END_IMPORT);
StateTree<JavaFile> import_q2 = import_q1.then(LAMBDA_4);
import_q2.then(import_q3);
StateTree<JavaElement> modifier_q0 = new StateTree<>();
modifier_q0.then(LAMBDA_mod).<Integer>end(END_MODIFIER);
StateTree<JavaElement> type_q0 = new StateTree<>();
StateTree<JavaElement> type_q1 = type_q0.then(LAMBDA_name);
StateTree<JavaElement> type_q3 = type_q1.then(LAMBDA_5);
StateTree<JavaElement> type_q4 = type_q3.then(LAMBDA_name);
StateTree<JavaElement> type_q5 = type_q4.then(LAMBDA_6).loop();
type_q5.<Token>end(END_TYPE);
StateTree<JavaElement> 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.<Token>end(END_TYPE);
StateTree<JavaElement> variable_q0 = new StateTree<>();
StateTree<JavaElement> variable_q1 = variable_q0.then(new RedirectStateTree<>(type_q0,(bag) -> "type"));
StateTree<JavaElement> variable_q2 = variable_q1.then(LAMBDA_name);
StateTree<JavaElement> variable_q5 = variable_q2.then(LAMBDA_7);
StateTree<JavaElement> variable_q7 = variable_q2.then(LAMBDA_9).then(LAMBDA_8);
variable_q7.then(variable_q5);
variable_q2.then(LAMBDA_1).<Variable>end(END_VAR);
variable_q7.then(LAMBDA_1).<Variable>end(END_VAR);
variable_q5.then(variable_q2);
StateTree<JavaElement> variable_q10 = variable_q0.then(new RedirectStateTree<>(modifier_q0,(bag) -> "modifier"));
variable_q10.then(variable_q1);
StateTree<JavaElement> operation_q0 = new StateTree<>();
StateTree<JavaElement> operation_q1 = operation_q0.then(LAMBDA_name);
operation_q1.then(LAMBDA_9).then(LAMBDA_8).<JavaElement>end(END_10);
StateTree<JavaElement> 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).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_15).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_16).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_17).then(LAMBDA_8).then(LAMBDA_1).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_18).then(LAMBDA_13).then(LAMBDA_8).then(LAMBDA_14).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_19).then(LAMBDA_1).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_20).then(LAMBDA_8).then(LAMBDA_1).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_21).then(LAMBDA_1).<JavaElement>end(END_10);
operation_q0.then(LAMBDA_22).<JavaElement>end(END_10);
StateTree<be.jeffcheasey88.peeratcode.parser.java.Function> function_q17 = new StateTree<>();
StateTree<be.jeffcheasey88.peeratcode.parser.java.Function> function_q18 = function_q17.then(LAMBDA_24);
function_q18.then(LAMBDA_25).<Object>end((a,b) -> null);
StateTree<be.jeffcheasey88.peeratcode.parser.java.Function> function_q22 = function_q18.then(new RedirectStateTree<>(operation_q0,(bag) -> "operation"));
function_q22.then(function_q18);
StateTree<be.jeffcheasey88.peeratcode.parser.java.Function> function_q21 = function_q18.then(new RedirectStateTree<>(variable_q0,(bag) -> "variable"));
function_q21.then(function_q18);
StateTree<JavaElement> function_q0 = new StateTree<>();
StateTree<JavaElement> function_q1 = function_q0.then(new RedirectStateTree<>(type_q0,(bag) -> "return"));
function_q1.then(LAMBDA_24).<be.jeffcheasey88.peeratcode.parser.java.Function>end(END_FUNC).then(function_q17);
StateTree<JavaElement> function_q3 = function_q1.then((v) -> v.validate(
(t) -> t.getType().equals(TokenType.NAME),
(bag, token) -> bag.set("name", token))).then(LAMBDA_13);
StateTree<JavaElement> function_q4 = function_q3.then(LAMBDA_14);
StateTree<JavaElement> function_q10 = function_q4.then(LAMBDA_28).then(new RedirectStateTree<>(type_q0,(bag) -> "type"));
function_q10.<be.jeffcheasey88.peeratcode.parser.java.Function>end(END_FUNC).then(function_q17);
StateTree<JavaElement> function_q11 = function_q10.then(LAMBDA_7);
function_q11.then(function_q10);
function_q4.<be.jeffcheasey88.peeratcode.parser.java.Function>end(END_FUNC).then(function_q17);
StateTree<JavaElement> function_q7 = function_q3.then(new RedirectStateTree<>(type_q0,(bag) -> "type")).then(LAMBDA_name);
function_q7.then(function_q4);
StateTree<JavaElement> function_q6 = function_q3.then(new RedirectStateTree<>(type_q0,(bag) -> "type"));
StateTree<JavaElement> function_q8 = function_q7.then(LAMBDA_7);
function_q8.then(function_q6);
StateTree<JavaElement> function_q15 = function_q0.then(new RedirectStateTree<>(modifier_q0,(bag) -> "modifier"));
function_q15.then(function_q1);
StateTree<Class> class_q16 = new StateTree<>();
StateTree<Class> class_q18 = class_q16.then(new RedirectStateTree<>(variable_q0,(bag) -> "?"));
class_q18.then(class_q16);
StateTree<Class> class_q19 = class_q16.then(new RedirectStateTree<>(function_q0,(bag) -> "?"));
class_q19.then(class_q16);
StateTree<JavaFile> class_q0 = new StateTree<>();
StateTree<JavaFile> class_q1 = class_q0.then(LAMBDA_30);
StateTree<JavaFile> class_q2 = class_q1.then(new RedirectStateTree<>(type_q0,(bag) -> "name"));
StateTree<JavaFile> class_q9 = class_q2.then(LAMBDA_31);
StateTree<JavaFile> class_q11 = class_q9.then(new RedirectStateTree<>(type_q0,(bag) -> "implement"));
class_q11.then(LAMBDA_24).<Class>end(END_CLASS).then(class_q16);
StateTree<JavaFile> class_q12 = class_q11.then(LAMBDA_7);
class_q12.then(class_q11);
StateTree<JavaFile> class_q7 = class_q2.then(LAMBDA_32).then(new RedirectStateTree<>(type_q0,(bag) -> "extend"));
class_q7.then(class_q9);
class_q7.then(LAMBDA_24).<Class>end(END_CLASS).then(class_q16);
class_q2.then(LAMBDA_24).<Class>end(END_CLASS).then(class_q16);
StateTree<JavaFile> 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<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;
}
}

6
src/be/jeffcheasey88/peeratcode/parser/java/Variable.java Normal file
View file

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

34
src/be/jeffcheasey88/peeratcode/parser/state/BinaryStateTree.java Normal file
View file

@ -0,0 +1,34 @@
package be.jeffcheasey88.peeratcode.parser.state;
import java.util.function.Function;
import be.jeffcheasey88.peeratcode.parser.TokenValidator;
public class BinaryStateTree<E> extends StateTree<E>{
private Function<TokenValidator, Boolean> condition;
private StateTree<E> success;
private StateTree<E> fail;
public BinaryStateTree(Function<TokenValidator, Boolean> checker){
super();
this.condition = checker;
}
@Override
<B> B internalSeed(TokenValidator validator, E element){
return ((this.condition.apply(validator)) ? success : fail).internalSeed(validator, element);
}
public StateTree<E> success(StateTree<E> state){
success = state;
return state;
}
public StateTree<E> fail(StateTree<E> state){
fail = state;
return state;
}
}

26
src/be/jeffcheasey88/peeratcode/parser/state/BuilderStateTree.java Normal file
View file

@ -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<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;
}
}

44
src/be/jeffcheasey88/peeratcode/parser/state/RedirectStateTree.java Normal file
View file

@ -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<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);
}
}

78
src/be/jeffcheasey88/peeratcode/parser/state/StateTree.java Normal file
View file

@ -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<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;
}
}