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

BIG COMMIT, refractor + A starting of value refractor -> unit test for StaticValue + BiValue

Browse source
This commit is contained in:
jeffcheasey88 2025-02-11 15:58:03 +01:00
parent ab2ef0f3f1
commit 95d2ecf89c
36 changed files with 1936 additions and 1167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -38,7 +38,7 @@ public class Bag{
public void set(Object value){
this.value = value;
System.out.println("edit Bag "+this);
// System.out.println("edit Bag "+this);
}
public <E> E get(String key){
@ -55,7 +55,7 @@ public class Bag{
public void set(String key, Object value){
this.map.put(key, value);
System.out.println("edit Bag "+this);
// System.out.println("edit Bag "+this);
}
@Override

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

@ -36,10 +36,10 @@ public class TokenValidator{
}
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]);
// 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;
}

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

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

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

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

6
src/dev/peerat/parser/java/ClassBase.java
View file

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

7
src/dev/peerat/parser/java/ClassContainer.java Normal file
View file

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

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

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

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

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

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

File diff suppressed because it is too large Load diff

171
src/dev/peerat/parser/java/JavaTokenizer.java Normal file
View file

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

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

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

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

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

76
src/dev/peerat/parser/java/operation/MethodCallOperation.java
View file

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

44
src/dev/peerat/parser/java/tree/AnnotationClassTree.java Normal file
View file

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

91
src/dev/peerat/parser/java/tree/AnnotationTree.java Normal file
View file

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

30
src/dev/peerat/parser/java/tree/ClassBaseTree.java Normal file
View file

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

38
src/dev/peerat/parser/java/tree/ClassContainerTree.java Normal file
View file

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

81
src/dev/peerat/parser/java/tree/ClassTree.java Normal file
View file

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

72
src/dev/peerat/parser/java/tree/EnumTree.java Normal file
View file

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

39
src/dev/peerat/parser/java/tree/EnumValueTree.java Normal file
View file

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

28
src/dev/peerat/parser/java/tree/FunctionContainerTree.java Normal file
View file

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

173
src/dev/peerat/parser/java/tree/FunctionTree.java Normal file
View file

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

80
src/dev/peerat/parser/java/tree/GenericTree.java Normal file
View file

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

56
src/dev/peerat/parser/java/tree/InterfaceTree.java Normal file
View file

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

33
src/dev/peerat/parser/java/tree/JavaTreeType.java Normal file
View file

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

62
src/dev/peerat/parser/java/tree/ModifierTree.java Normal file
View file

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

296
src/dev/peerat/parser/java/tree/OperationTree.java Normal file
View file

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

49
src/dev/peerat/parser/java/tree/TypeTree.java Normal file
View file

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

170
src/dev/peerat/parser/java/tree/ValueTree.java Normal file
View file

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

89
src/dev/peerat/parser/java/tree/VariableTree.java Normal file
View file

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

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

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

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

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

21
src/dev/peerat/parser/state/StateTree.java
View file

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

29
src/dev/peerat/parser/tree/SyntaxTree.java Normal file
View file

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

35
src/dev/peerat/parser/tree/SyntaxTreeRegistery.java Normal file
View file

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

6
src/dev/peerat/parser/tree/TreeType.java Normal file
View file

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