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