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

StreamableTree (base) + debug value

Browse source
This commit is contained in:
jeffcheasey88 2024-10-01 16:56:33 +02:00
parent 65d454625d
commit 4cbf1be37b
17 changed files with 366 additions and 319 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/dev/peerat/parser/Bag.java
View file

@ -54,6 +54,7 @@ public class Bag{
public void set(String key, Object value){
this.map.put(key, value);
System.out.println("edit Bag "+this);
}
@Override

14
src/dev/peerat/parser/Token.java
View file

@ -33,13 +33,19 @@ public class Token{
//line & character start & end ?
public Token concat(Token token){
StackTraceElement[] stack = Thread.currentThread().getStackTrace();
System.out.println(token.getValue()+":");
for(int i = 1; i < stack.length; i++) System.out.println(stack[i]);
System.out.println();
return new Token(line, character, value+token.getValue(), TokenType.GROUP);
}
@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+"]";

8
src/dev/peerat/parser/TokenValidator.java
View file

@ -35,6 +35,12 @@ public class TokenValidator{
TOKENS = elements.length;
}
this.validated++;
StackTraceElement[] trace = Thread.currentThread().getStackTrace();
int current = 0;
while((current < trace.length) && (!(trace[++current].getClassName().endsWith("JavaParser"))));
System.out.println("[validate] "+trace[current]);
return true;
}
return false;
@ -49,7 +55,7 @@ public class TokenValidator{
}
public TokenValidator branch(){
TokenValidator branch = new TokenValidator(new Bag(bag));
TokenValidator branch = new TokenValidator(bag);
branch.elements = this.elements;
branch.index = Math.max(0, this.validated-1);
branch.validated = this.validated;

3
src/dev/peerat/parser/TreeStreamable.java Normal file
View file

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

23
src/dev/peerat/parser/java/Class.java
View file

@ -2,8 +2,12 @@ package dev.peerat.parser.java;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import dev.peerat.parser.Token;
import dev.peerat.parser.TreeStreamable;
import dev.peerat.parser.java.Function.FunctionStreamable;
import dev.peerat.parser.java.Variable.VariableStreamable;
public class Class extends ClassBase{
@ -103,4 +107,23 @@ public class Class extends ClassBase{
}
}
}
public ClassStreamable stream(){
return new ClassStreamable();
}
public class ClassStreamable implements TreeStreamable{
public ClassStreamable(){}
public FunctionStreamable functionFilter(Predicate<Function> filter){ return null; }
public FunctionStreamable constructorFilter(Predicate<Function> filter){ return null; }
public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
public ClassStreamable classFilter(Predicate<Class> filter){ return null; }
// public InterfaceStreamable interfaceFilter(Predicate<Interface> filter){ return null; }
// public EnumStreamable enumFilter(Predicate<Enumeration> filter){ return null; }
}
}

16
src/dev/peerat/parser/java/Function.java
View file

@ -3,14 +3,15 @@ package dev.peerat.parser.java;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import javax.xml.crypto.dsig.CanonicalizationMethod;
import java.util.function.Predicate;
import dev.peerat.parser.Token;
import dev.peerat.parser.TokenType;
import dev.peerat.parser.TreeStreamable;
import dev.peerat.parser.java.Annotation.Annotable;
import dev.peerat.parser.java.Operation.OperationContainer;
import dev.peerat.parser.java.Variable.VariableContainer;
import dev.peerat.parser.java.Variable.VariableStreamable;
public class Function extends Annotable implements VariableContainer, OperationContainer{
@ -159,4 +160,15 @@ public class Function extends Annotable implements VariableContainer, OperationC
}
}
}
public FunctionStreamable stream(){
return new FunctionStreamable();
}
public class FunctionStreamable implements TreeStreamable{
public FunctionStreamable(){}
public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
}
}

3
src/dev/peerat/parser/java/JavaElement.java
View file

@ -8,9 +8,6 @@ import dev.peerat.parser.ElementBuilder;
public abstract class JavaElement implements ElementBuilder{
// Bag bag; //to remove
public abstract <E extends JavaElement> E find(Function<JavaElement, Boolean> finder);
public abstract <E extends JavaElement> void findAll(Function<JavaElement, Boolean> finder, List<E> list);

1
src/dev/peerat/parser/java/JavaFile.java
View file

@ -102,4 +102,5 @@ public class JavaFile extends JavaElement implements ClassContainer, AnnotableBu
clazz.findAll(finder, list);
}
}
}

326
src/dev/peerat/parser/java/JavaParser.java
View file

@ -307,6 +307,8 @@ public class JavaParser extends Parser<JavaElement> {
//VALUE
BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
System.out.println("value_builder {");
System.out.println("begin: "+bag);
if(bag.has("right")){
if(!(bag.get("left") instanceof Value)) bag.set("left", new StaticValue(bag.<Token>get("left")));
@ -321,10 +323,17 @@ public class JavaParser extends Parser<JavaElement> {
bag.get("right"));
bag.set(result);
}
System.out.println("end: "+bag);
System.out.println("}");
return null;
};
BiConsumer<Bag, Bag> value_right = (global, local) -> {
System.out.println("merge{");
System.out.println("global: "+global);
System.out.println("local: "+local);
System.out.println("More than simple merge ? "+local.get().getClass());
System.out.println("}");
global.set("right", local.get("left"));
};
@ -370,10 +379,15 @@ public class JavaParser extends Parser<JavaElement> {
.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;
@ -499,6 +513,7 @@ public class JavaParser extends Parser<JavaElement> {
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
StateTree<JavaElement> value_inside = value_container.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_container, (global, local) -> global.set(null)))
@ -506,6 +521,7 @@ public class JavaParser extends Parser<JavaElement> {
.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;
@ -782,6 +798,10 @@ public class JavaParser extends Parser<JavaElement> {
StateTree<JavaElement> operation_if = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("if")))
.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
.then((v) -> {
System.out.println("inside IF");
return true;
})
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(local.get())))
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
.end((parent,bag) -> {
@ -1281,310 +1301,4 @@ public class JavaParser extends Parser<JavaElement> {
return 0;
}
// public static void main(String[] args) throws Exception{
// File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\peer-at-code-backend\\src\\dev\\peerat\\backend\\routes\\users\\ChangePassword.java");
//
// BufferedReader reader = new BufferedReader(new FileReader(file));
//
// time = System.currentTimeMillis();
//
// Parser<JavaElement> parser = new JavaParser();
// JavaFile jFile = new JavaFile();
// parser.parse(reader, jFile);
//
// List<Value> values = new ArrayList<>();
// jFile.findAll((e) -> e instanceof Value, values);
// System.out.println("Find "+values.size()+" values");
// for(Value v : values) System.out.println(v.getClass().getSimpleName()+" ->"+v);
//
//
// System.out.println((System.currentTimeMillis()-time)+"ms");
//
// System.out.println(TokenValidator.MAX_VALIDATE+" / "+TokenValidator.TOKENS);
//
//// parser.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
// Builder builder = new Builder();
// jFile.build(builder);
// builder.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
// }
/*
*
* VALUES
*
//VALUE
BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
if(bag.has("right")){
if(!(bag.get("left") instanceof Value)) bag.set("left", new Value(bag.<Token>get("left")));
if(!(bag.get("right") instanceof Value)) bag.set("right", new Value(bag.<Token>get("right")));
BiValue result = new BiValue(
bag.get("left"),
bag.get("action"),
bag.get("right"));
bag.set(result);
}
return null;
};
BiConsumer<Bag, Bag> value_right = (global, local) -> {
global.set("right", local.get("left"));
};
//STRING CONCAT
StateTree<JavaElement> value = new StateTree<>();
StateTree<JavaElement> value_container = new StateTree<>();
StateTree<JavaElement> value_list = new StateTree<>();
StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value_container, (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 Value(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) -> {
if(global.get() == null) global.set(local.get());
else global.set(global.<Token>get().concat(local.get()));
}));
value_name.end((parent,bag) -> {
Value result = new Value(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 Value(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_container, (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_container, (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_container.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_container, (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_container, (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_container, (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_container.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value_container);
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value_container);
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value_container);
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
StateTree<JavaElement> value_inside = value_container.then(new RedirectStateTree<>(value, (global, local) -> {
global.set("left", local.get());
}));
value_inside.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
.then(new RedirectStateTree<>(value_container, (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) -> {
if(bag.get("left") instanceof Value) bag.set(bag.get("left"));
else bag.set(new Value(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_container, value_right)).end(value_builder);
value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">="))).then(new RedirectStateTree<>(value_container, 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_container, 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_container, value_right)).end(value_builder);
value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
value_or.then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
value_and.then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value_container, 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_container, value_right)).end(value_builder);
value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
.then(new RedirectStateTree<>(value_container, value_right))
.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
.then(new RedirectStateTree<>(value_container, 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_container, (global, local) -> global.set(null)));
braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
.then(braces_array);
braces_array.end((a,b) -> a);
*
*
*
*/
}

75
src/dev/peerat/parser/java/Operation.java
View file

@ -1,5 +1,38 @@
package dev.peerat.parser.java;
import java.util.function.Predicate;
import dev.peerat.parser.TreeStreamable;
import dev.peerat.parser.java.Variable.VariableStreamable;
import dev.peerat.parser.java.operation.AssignOperation;
import dev.peerat.parser.java.operation.BreakOperation;
import dev.peerat.parser.java.operation.CatchOperation;
import dev.peerat.parser.java.operation.ContinueOperation;
import dev.peerat.parser.java.operation.DoOperation;
import dev.peerat.parser.java.operation.ElseOperation;
import dev.peerat.parser.java.operation.FinallyOperation;
import dev.peerat.parser.java.operation.ForOperation;
import dev.peerat.parser.java.operation.ForeachOperation;
import dev.peerat.parser.java.operation.IfOperation;
import dev.peerat.parser.java.operation.MethodCallOperation;
import dev.peerat.parser.java.operation.ReturnOperation;
import dev.peerat.parser.java.operation.SwitchOperation;
import dev.peerat.parser.java.operation.SynchronizedOperation;
import dev.peerat.parser.java.operation.ThrowOperation;
import dev.peerat.parser.java.operation.TryOperation;
import dev.peerat.parser.java.operation.WhileOperation;
import dev.peerat.parser.java.value.ArrayValue;
import dev.peerat.parser.java.value.BiValue;
import dev.peerat.parser.java.value.InnerElementValue;
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.Value;
import dev.peerat.parser.java.value.Value.ValueStreamable;
public abstract class Operation extends JavaElement{
public static interface OperationContainer{
@ -10,4 +43,46 @@ public abstract class Operation extends JavaElement{
public Operation(){}
public OperationStreamable stream(){
return new OperationStreamable();
}
public class OperationStreamable implements TreeStreamable{
public OperationStreamable(){}
public OperationStreamable operationFilter(Predicate<Operation> filter){ return null; }
public OperationStreamable assignOperationFilter(Predicate<AssignOperation> filter){ return null; }
public OperationStreamable breakOperationFilter(Predicate<BreakOperation> filter){ return null; }
public OperationStreamable catchOperationFilter(Predicate<CatchOperation> filter){ return null; }
public OperationStreamable continueOperationFilter(Predicate<ContinueOperation> filter){ return null; }
public OperationStreamable doOperationFilter(Predicate<DoOperation> filter){ return null; }
public OperationStreamable elseOperationFilter(Predicate<ElseOperation> filter){ return null; }
public OperationStreamable finallyOperationFilter(Predicate<FinallyOperation> filter){ return null; }
public OperationStreamable foreachOperationFilter(Predicate<ForeachOperation> filter){ return null; }
public OperationStreamable forOperationFilter(Predicate<ForOperation> filter){ return null; }
public OperationStreamable ifOperationFilter(Predicate<IfOperation> filter){ return null; }
public OperationStreamable methodCallOperationFilter(Predicate<MethodCallOperation> filter){ return null; }
public OperationStreamable returnOperationFilter(Predicate<ReturnOperation> filter){ return null; }
public OperationStreamable switchOperationFilter(Predicate<SwitchOperation> filter){ return null; }
public OperationStreamable synchronizedOperationFilter(Predicate<SynchronizedOperation> filter){ return null; }
public OperationStreamable throwOperationFilter(Predicate<ThrowOperation> filter){ return null; }
public OperationStreamable tryOperationFilter(Predicate<TryOperation> filter){ return null; }
public OperationStreamable whileOperationFilter(Predicate<WhileOperation> filter){ return null; }
public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
public VariableStreamable variableFilter(Predicate<Variable> filter){ return null; }
}
}

32
src/dev/peerat/parser/java/Variable.java
View file

@ -3,11 +3,23 @@ package dev.peerat.parser.java;
import java.lang.reflect.Modifier;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import dev.peerat.parser.Token;
import dev.peerat.parser.TokenType;
import dev.peerat.parser.TreeStreamable;
import dev.peerat.parser.java.Annotation.Annotable;
import dev.peerat.parser.java.value.ArrayValue;
import dev.peerat.parser.java.value.BiValue;
import dev.peerat.parser.java.value.InnerElementValue;
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.Value;
import dev.peerat.parser.java.value.Value.ValueStreamable;
public class Variable extends Annotable{
@ -98,4 +110,24 @@ public class Variable extends Annotable{
value.findAll(finder, list);
}
}
public VariableStreamable stream(){
return new VariableStreamable();
}
public class VariableStreamable implements TreeStreamable{
public VariableStreamable(){}
public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
}
}

4
src/dev/peerat/parser/java/value/BiValue.java
View file

@ -44,4 +44,8 @@ public class BiValue extends Value{
}
@Override
public String toString(){
return "[BiValue] "+left+" "+action+" "+right;
}
}

5
src/dev/peerat/parser/java/value/StaticValue.java
View file

@ -34,5 +34,8 @@ public class StaticValue extends Value{
}
@Override
public String toString(){
return "StaticValue["+token.getValue()+"]";
}
}

25
src/dev/peerat/parser/java/value/Value.java
View file

@ -1,5 +1,28 @@
package dev.peerat.parser.java.value;
import java.util.function.Predicate;
import dev.peerat.parser.java.JavaElement;
public abstract class Value extends JavaElement{}
public abstract class Value extends JavaElement{
public ValueStreamable stream(){
return new ValueStreamable();
}
public class ValueStreamable{
public ValueStreamable(){}
public ValueStreamable valueFilter(Predicate<Value> filter){ return null; }
public ValueStreamable arrayValueFilter(Predicate<ArrayValue> filter){ return null; }
public ValueStreamable biValueFilter(Predicate<BiValue> filter){ return null; }
public ValueStreamable innerElementValueFilter(Predicate<InnerElementValue> filter){ return null; }
public ValueStreamable instanceValueFilter(Predicate<InstanceValue> filter){ return null; }
public ValueStreamable lambdaValueFilter(Predicate<LambdaValue> filter){ return null; }
public ValueStreamable methodCallValueFilter(Predicate<MethodCallValue> filter){ return null; }
public ValueStreamable modifierValueFilter(Predicate<ModifierValue> filter){ return null; }
public ValueStreamable staticVFilter(Predicate<StaticValue> filter){ return null; }
public ValueStreamable triValueFilter(Predicate<TriValue> filter){ return null; }
}
}

10
src/dev/peerat/parser/state/RedirectStateTree.java
View file

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

34
test/dev/peerat/parser/java/element/BaseElementTests.java
View file

@ -2,7 +2,9 @@ package dev.peerat.parser.java.element;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
@ -10,6 +12,7 @@ import java.util.function.Consumer;
import org.junit.jupiter.api.Test;
import dev.peerat.parser.Parser;
import dev.peerat.parser.Token;
import dev.peerat.parser.java.Class;
import dev.peerat.parser.java.ClassBase;
import dev.peerat.parser.java.Enumeration;
@ -39,6 +42,7 @@ public class BaseElementTests{
try{
Parser<JavaElement> parser = new JavaParser();
for(int i = 0; i < size; i++){
System.out.printf("----------------------- Test %,4d ------------------------\n", (i+1));
JavaFile javaFile = new JavaFile();
parser.parse((text = texts.get(i)), javaFile);
checkers.get(i).accept(javaFile);
@ -50,6 +54,36 @@ public class BaseElementTests{
}
}
public void printObject(Object object){
try {
printObject(object, "");
}catch(Exception ex) {
ex.printStackTrace();
}
}
private void printObject(Object object, String spaces) throws Exception{
System.out.println(spaces+"["+object.getClass()+"]");
for(Field field : object.getClass().getDeclaredFields()){
field.setAccessible(true);
System.out.println(spaces+" - "+field.getName());
Object value = field.get(object);
if(value == null) System.out.println(spaces+"\tnull");
else{
if(value.getClass().getPackage().getName().startsWith("java.lang") || value.getClass().isEnum()){
System.out.println(spaces+"\t"+value);
continue;
}
printObject(value, spaces+"\t");
}
}
}
public void assertToken(String value, Token token){
assertNotNull(token);
assertEquals(value, token.getValue());
}
public Class checkClass(JavaFile javafile){
ClassBase clazzb = javafile.getMainClass();
assertNotNull(clazzb);

103
test/dev/peerat/parser/java/element/value/TypeOfValuesTests.java Normal file
View file

@ -0,0 +1,103 @@
package dev.peerat.parser.java.element.value;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import dev.peerat.parser.java.Function;
import dev.peerat.parser.java.JavaFile;
import dev.peerat.parser.java.Operation;
import dev.peerat.parser.java.element.BaseElementTests;
import dev.peerat.parser.java.operation.IfOperation;
import dev.peerat.parser.java.value.BiValue;
import dev.peerat.parser.java.value.StaticValue;
import dev.peerat.parser.java.value.Value;
public class TypeOfValuesTests extends BaseElementTests{
{
register(
"package be.jeffcheasey88;"
+ ""
+ "public static class Test{ "
+ " void test(){ "
+ " if(a){}"
+ "}"
+ "}",
(javafile) -> {
StaticValue value = gotoValue(javafile);
assertToken("a", value.getToken());
});
register(
"package be.jeffcheasey88;"
+ ""
+ "public static class Test{ "
+ " void test(){ "
+ " if(a > b){}"
+ "}"
+ "}",
(javafile) -> {
BiValue value = gotoValue(javafile);
StaticValue left = (StaticValue) value.left();
StaticValue right = (StaticValue) value.right(); //generic?
assertEquals("a", left.getToken().getValue());
assertEquals("b", right.getToken().getValue());
assertEquals(">", value.getAction());
});
register(
"package be.jeffcheasey88;"
+ ""
+ "public static class Test{ "
+ " void test(){ "
+ " if(((a) > (b))){}"
+ "}"
+ "}",
(javafile) -> {
BiValue value = gotoValue(javafile);
StaticValue left = (StaticValue) value.left();
StaticValue right = (StaticValue) value.right(); //generic?
assertEquals("a", left.getToken().getValue());
assertEquals("b", right.getToken().getValue());
assertEquals(">", value.getAction());
});
register(
"package be.jeffcheasey88;"
+ ""
+ "public static class Test{ "
+ " void test(){ "
+ " if(a && b == c){}"
+ "}"
+ "}",
(javafile) -> {
BiValue value = gotoValue(javafile);
printObject(value);
BiValue left = (BiValue) value.left();
StaticValue right = (StaticValue) value.right();
StaticValue leftLeft = (StaticValue) left.left();
StaticValue leftRight = (StaticValue) left.right();
assertToken("a", leftLeft.getToken());
assertEquals("&&", left.getAction());
assertToken("b", leftRight.getToken());
assertEquals("==", value.getAction());
assertToken("c", right.getToken());
});
}
private <T extends Value> T gotoValue(JavaFile javafile){
Function function = checkFunction(checkClass(javafile).getElements().get(0));
assertEquals(1, function.getElements().size());
Operation op = checkOperation(function.getElements().get(0));
assertTrue(op instanceof IfOperation);
IfOperation condition = (IfOperation)op;
Value value = condition.getCondition();
assertNotNull(value);
return (T) value;
}
}