1112 lines
59 KiB
Java
1112 lines
59 KiB
Java
package dev.peerat.parser.java;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.BufferedWriter;
|
|
import java.io.File;
|
|
import java.io.FileReader;
|
|
import java.io.FileWriter;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.function.BiConsumer;
|
|
import java.util.function.BiFunction;
|
|
|
|
import dev.peerat.parser.Bag;
|
|
import dev.peerat.parser.ElementBuilder.Builder;
|
|
import dev.peerat.parser.Parser;
|
|
import dev.peerat.parser.Token;
|
|
import dev.peerat.parser.TokenType;
|
|
import dev.peerat.parser.TokenValidator;
|
|
import dev.peerat.parser.Tokenizer;
|
|
import dev.peerat.parser.java.Annotation.AnnotableBuffer;
|
|
import dev.peerat.parser.java.Function.FunctionContainer;
|
|
import dev.peerat.parser.java.Operation.OperationContainer;
|
|
import dev.peerat.parser.java.Value.BiValue;
|
|
import dev.peerat.parser.java.Variable.VariableContainer;
|
|
import dev.peerat.parser.java.operation.ReturnOperation;
|
|
import dev.peerat.parser.state.BuilderStateTree;
|
|
import dev.peerat.parser.state.InitialStateTree;
|
|
import dev.peerat.parser.state.RedirectStateTree;
|
|
import dev.peerat.parser.state.StateTree;
|
|
|
|
public class JavaParser extends Parser<JavaElement> {
|
|
|
|
public static long time;
|
|
|
|
static {
|
|
time = System.currentTimeMillis();
|
|
}
|
|
|
|
public JavaParser(){
|
|
Tokenizer tokenizer = new 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;
|
|
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 == '$';
|
|
}
|
|
};
|
|
|
|
|
|
//SUMMARY
|
|
//- Modifier
|
|
//- Type
|
|
//- Value
|
|
//- Enum Value
|
|
//- Annotation
|
|
//- Variable
|
|
//- Operation
|
|
//- Function
|
|
//- Class
|
|
//- Interface
|
|
//- Enum
|
|
//- Annotation Clazz
|
|
//- Import
|
|
//- Package
|
|
|
|
//MODIFIER
|
|
StateTree<JavaElement> modifier = new StateTree<JavaElement>();
|
|
modifier.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();
|
|
|
|
//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 = new StateTree<JavaElement>();
|
|
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))
|
|
.then(type_);
|
|
StateTree<JavaElement> gen = new StateTree<>();
|
|
type_.then(gen);
|
|
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);
|
|
|
|
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();
|
|
type_generic_end.end();
|
|
|
|
|
|
StateTree<JavaElement> clazz_container = new StateTree<>();
|
|
clazz_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
|
|
StateTree<JavaElement> braces_container = new StateTree<>();
|
|
|
|
StateTree<JavaElement> function_container = new StateTree<>();
|
|
function_container.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
|
|
|
|
//VALUE
|
|
BiFunction<JavaElement, Bag, JavaElement> value_builder = (parent, bag) -> {
|
|
System.out.println(bag);
|
|
if(bag.has("right")){
|
|
|
|
BiValue result = new BiValue(
|
|
|
|
bag.get("left"),
|
|
|
|
bag.get("action"),
|
|
|
|
bag.get("right"));
|
|
bag.set(result);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
BiConsumer<Bag, Bag> value_right = (global, local) -> {
|
|
global.set("right", local.get("left"));
|
|
};
|
|
|
|
StateTree<JavaElement> value = new StateTree<>();
|
|
|
|
StateTree<JavaElement> value_container = new StateTree<>();
|
|
|
|
StateTree<JavaElement> value_list = new StateTree<>();
|
|
StateTree<JavaElement> value_list_element = value_list.then(new RedirectStateTree<>(value_container, (global, local) -> {
|
|
List<Value> list = global.get();
|
|
if(list == null){
|
|
list = new ArrayList<>();
|
|
global.set(list);
|
|
}
|
|
list.add(local.get());
|
|
}));
|
|
value_list_element.end();
|
|
value_list_element.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
|
|
.then(value_list_element);
|
|
|
|
value.then((validator) -> validator.validate(
|
|
(token) -> token.getType().equals(TokenType.STRING) || token.getType().equals(TokenType.CHAR),
|
|
(bag, token) -> bag.set(token)))
|
|
.end((parent,bag) -> {
|
|
bag.set(new Value(bag.<Token>get()));
|
|
return null;
|
|
});
|
|
|
|
StateTree<JavaElement> value_instance = value.then((validator) -> validator.validate((token) -> token.getValue().equals("new")));
|
|
StateTree<JavaElement> value_name = new StateTree<JavaElement>();
|
|
value.then(value_name);
|
|
value_instance.then(new RedirectStateTree<>(value_name, (global, local) -> global.set(null)))
|
|
.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) -> global.set(local.get())));
|
|
value_name.end((parent,bag) -> {
|
|
Value result = new Value(bag.<Token>get());
|
|
bag.set(result);
|
|
return null;
|
|
});
|
|
|
|
value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(":")) && validator.validate((token) -> token.getValue().equals(":")))
|
|
.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)))
|
|
.end((a,b) -> a);
|
|
|
|
StateTree<JavaElement> value_call = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals(".")));
|
|
value_call.end((a,b) -> a);
|
|
value_call.then(value_name);
|
|
StateTree<JavaElement> value_array_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("[")));
|
|
StateTree<JavaElement> value_array_end = value_array_begin.then((validator) -> validator.validate((token) -> token.getValue().equals("]")));
|
|
value_array_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("inside", local)))
|
|
.then(value_array_end);
|
|
value_array_end.end((a,b) -> a)
|
|
.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("(")));
|
|
StateTree<JavaElement> value_arg_end = value_arg_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
|
|
value_arg_end.end((a,b) -> a);
|
|
value_arg_end.then(value_call);
|
|
value_arg_end.then(value_array_begin);
|
|
StateTree<JavaElement> value_generic_begin = value_name.then((validator) -> validator.validate((token) -> token.getValue().equals("<")));
|
|
StateTree<JavaElement> value_generic_name = value_generic_begin.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
|
|
StateTree<JavaElement> value_generic_split = value_generic_name.then((validator) -> validator.validate((token) -> token.getValue().equals(",")));
|
|
StateTree<JavaElement> value_generic_end = value_generic_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(">")));
|
|
value_generic_end.then(value_arg_begin);
|
|
value_generic_end.then(value_generic_name);
|
|
value_generic_end.then(value_generic_split);
|
|
value_generic_name.then(value_generic_begin);
|
|
value_generic_name.then(value_generic_end);
|
|
value_generic_split.then(value_generic_name);
|
|
StateTree<JavaElement> value_arg = value_arg_begin.then(new RedirectStateTree<>(value_container, (global, local) -> {
|
|
Integer count = global.get("args");
|
|
if(count == null) count = 0;
|
|
global.set("arg"+count, local);
|
|
global.set("args", (count+1));
|
|
System.out.println("ah "+local);
|
|
}));
|
|
value_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
|
|
.then(value_arg);
|
|
value_arg.then(value_arg_end);
|
|
|
|
StateTree<JavaElement> value_left = new StateTree<>();
|
|
|
|
StateTree<JavaElement> value_parenthesis = value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
|
|
StateTree<JavaElement> value_cast = value_parenthesis.then(new RedirectStateTree<>(type, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
|
|
value_cast.then(value_left);
|
|
StateTree<JavaElement> value_lambda_arg = value_parenthesis.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME)));
|
|
value_lambda_arg.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
|
|
.then(value_lambda_arg);
|
|
StateTree<JavaElement> value_lambda = value_parenthesis.then((validator) ->
|
|
validator.validate((token) -> token.getValue().equals(")")) &&
|
|
validator.validate((token) -> token.getValue().equals("-")) &&
|
|
validator.validate((token) -> token.getValue().equals(">")));
|
|
value_lambda.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
|
|
.end((a,b) -> a).end((a,b) -> a)
|
|
.multiple(function_container)
|
|
.unique((validator) -> validator.validate((token) -> token.getValue().equals("}"))).end((a,b) -> a);
|
|
value_lambda.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null))).end((a,b) -> a);
|
|
value_lambda_arg.then(value_lambda);
|
|
StateTree<JavaElement> value_parenthesis_end = value_parenthesis.then(new RedirectStateTree<>(value_container, (global, local) -> global.set("left", local.get())))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
|
|
value_parenthesis_end.end();
|
|
value_parenthesis_end.then(value_call);
|
|
value_parenthesis_end.then(value_left);
|
|
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("!"))).then(value_container);
|
|
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("-"))).then(value_container);
|
|
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("+"))).then(value_container);
|
|
value_container.then((validator) -> validator.validate((token) -> token.getValue().equals("~"))).then(value_container);
|
|
StateTree<JavaElement> value_inside = value_container.then(new RedirectStateTree<>(value, (global, local) -> {
|
|
System.out.println("captured "+local);
|
|
global.set("left", local.get());
|
|
}));
|
|
value_inside.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals("]")))
|
|
.then(value_left);
|
|
value_inside.then(value_left);
|
|
value_left.end((parent, bag) -> {
|
|
if(bag.get() == null) bag.set(bag.get("left"));
|
|
return null;
|
|
});
|
|
StateTree<JavaElement> value_equals = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=")));
|
|
value_equals.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_equals.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "=="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_minus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("<"), (bag, token) -> bag.set("action", "<?"))).loop();
|
|
value_minus.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_minus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "<?="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_max = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals(">"), (bag, token) -> bag.set("action", ">?"))).loop();
|
|
value_max.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_max.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", ">?="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("!")) && validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "!="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_or = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "|")));
|
|
value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("|"), (bag, token) -> bag.set("action", "||"))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_or.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "|="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_or.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_and = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&")));
|
|
value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("&"), (bag, token) -> bag.set("action", "&&"))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_and.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "&="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_and.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_plus = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "+")));
|
|
value_plus.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "+="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_plus.then((validator) -> validator.validate((token) -> token.getValue().equals("+"), (bag, token) -> bag.set("action", "++"))).end(value_builder);
|
|
StateTree<JavaElement> value_min = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "-")));
|
|
value_min.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "-="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_min.then((validator) -> validator.validate((token) -> token.getValue().equals("-"), (bag, token) -> bag.set("action", "--"))).end(value_builder);
|
|
StateTree<JavaElement> value_div = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("/"), (bag, token) -> bag.set("action", "/")));
|
|
value_div.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_div.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "/="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_mod = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("%"), (bag, token) -> bag.set("action", "%")));
|
|
value_mod.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_mod.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "%="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_xor = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("^"), (bag, token) -> bag.set("action", "^")));
|
|
value_xor.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_xor.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "^="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
StateTree<JavaElement> value_mult = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("*"), (bag, token) -> bag.set("action", "*")));
|
|
value_mult.then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_mult.then((validator) -> validator.validate((token) -> token.getValue().equals("="), (bag, token) -> bag.set("action", "*="))).then(new RedirectStateTree<>(value_container, value_right)).end(value_builder);
|
|
value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("?")))
|
|
.then(new RedirectStateTree<>(value_container, value_right))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(":"), (bag, token) -> bag.set("action", "?:")))
|
|
.then(new RedirectStateTree<>(value_container, value_right))
|
|
.end(value_builder);
|
|
StateTree<JavaElement> value_instanceof = value_left.then((validator) -> validator.validate((token) -> token.getValue().equals("instanceof"), (bag, token) -> bag.set("action", "instanceof")))
|
|
.then(new RedirectStateTree<>(type, value_right));
|
|
value_instanceof.end(value_builder);
|
|
value_instanceof.then(value_left);
|
|
|
|
braces_container.then(clazz_container);
|
|
StateTree<JavaElement> braces_array = braces_container.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
|
|
braces_array.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
|
|
.then(braces_array);
|
|
braces_array.end((a,b) -> a);
|
|
|
|
//ENUM VALUE
|
|
StateTree<JavaElement> enum_value = new StateTree<>();
|
|
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_container, (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);
|
|
|
|
//ANNOTATION
|
|
StateTree<JavaElement> annotation = new StateTree<>();
|
|
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_container, (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);
|
|
|
|
//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 = new InitialStateTree<>();
|
|
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_container, (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);
|
|
|
|
//OPERATION
|
|
StateTree<JavaElement> operation = new StateTree<>();
|
|
StateTree<JavaElement> operation_name = operation.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
|
|
operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals(";"))).end((a,b) -> a);
|
|
operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("=")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
|
|
.end((a,b) -> a);
|
|
StateTree<JavaElement> operation_call = operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals(".")));
|
|
operation_call.then(operation_name);
|
|
StateTree<JavaElement> operation_begin = operation_name.then((validator) -> validator.validate((token) -> token.getValue().equals("(")));
|
|
StateTree<JavaElement> operation_end = operation_begin.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
|
|
operation_end.then(operation_call);
|
|
operation_end.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
|
|
.end((a,b) -> a);
|
|
StateTree<JavaElement> operation_value = operation_begin.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)));
|
|
operation_value.then(operation_end);
|
|
operation_value.then((validator) -> validator.validate((token) -> token.getValue().equals(","))).then(operation_value);
|
|
|
|
StateTree<JavaElement> operation_return = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("return")));
|
|
operation_return.then(new RedirectStateTree<>(value_container, (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_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
|
|
.end((a,b) -> a);
|
|
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((a,b) -> a);
|
|
operation.then((validator) -> validator.validate((token) -> token.getValue().equals("break")))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
|
|
.end((a,b) -> a);
|
|
StateTree<JavaElement> operation_if = operation.then((validator) -> validator.validate((token) -> token.getValue().equals("if")))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
|
|
.end((a,b) -> a);
|
|
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_container, (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_container, (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((validator) -> validator.validate((token) -> getModifier(token.getValue()) > 0));
|
|
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_container, (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_container, (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.end((a,b) -> a);
|
|
|
|
operation_for_end.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_for_assign.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
|
|
.then(operation_for_end);
|
|
|
|
StateTree<JavaElement> operation_for_update = operation_for_second_part.then(new RedirectStateTree<>(value_container, (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_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")));
|
|
operation_while.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_while.then(new RedirectStateTree<>(operation, (global, local) -> global.set(null)))
|
|
.end((a,b) -> a);
|
|
|
|
operation_while.then((validator) -> validator.validate((token) -> token.getValue().equals(";")))
|
|
.end((a,b) -> a);
|
|
|
|
operation.then((validator) -> validator.validate((token) -> token.getValue().equals("synchronized")))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals("(")))
|
|
.then(new RedirectStateTree<>(value_container, (global, local) -> global.set(null)))
|
|
.then((validator) -> validator.validate((token) -> token.getValue().equals(")")))
|
|
.then((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);
|
|
|
|
function_container.then(variable);
|
|
function_container.then(operation);
|
|
|
|
//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 = new InitialStateTree<>();
|
|
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);
|
|
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_container, (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);
|
|
|
|
|
|
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);
|
|
|
|
//CLASS
|
|
StateTree<JavaElement> clazz_ = new StateTree<>();
|
|
StateTree<JavaElement> clazz = new StateTree<>();
|
|
|
|
clazz_container.then(clazz_);
|
|
|
|
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("implements"));
|
|
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("implements"));
|
|
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);
|
|
|
|
|
|
StateTree<JavaElement> clazz_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
|
|
clazz_.then(clazz);
|
|
clazz_mod.then(clazz);
|
|
|
|
//INTERFACE
|
|
StateTree<JavaElement> interfaces = new StateTree<>();
|
|
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"));
|
|
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(null)))
|
|
.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);
|
|
|
|
//ENUM
|
|
StateTree<JavaElement> enums = new StateTree<>();
|
|
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"));
|
|
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);
|
|
|
|
//ANNOTATION CLAZZ
|
|
StateTree<JavaElement> def_annos = new StateTree<>();
|
|
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);
|
|
|
|
StateTree<JavaElement> def_anno_mod = clazz_.then(new RedirectStateTree<>(modifier, (global, local) -> global.set("modifier", local)));
|
|
clazz_.then(def_annos);
|
|
def_anno_mod.then(def_annos);
|
|
|
|
//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(tokenizer);
|
|
setStateTree(main);
|
|
|
|
System.out.println("init");
|
|
}
|
|
|
|
//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);
|
|
}
|
|
|
|
public static int getModifier(String modifier){
|
|
switch(modifier){
|
|
case "public": return Modifier.PUBLIC;
|
|
case "private": return Modifier.PRIVATE;
|
|
case "protected": return Modifier.PROTECTED;
|
|
case "static": return Modifier.STATIC;
|
|
case "final": return Modifier.FINAL;
|
|
case "synchronized": return Modifier.SYNCHRONIZED;
|
|
case "volatile": return Modifier.VOLATILE;
|
|
case "transient": return Modifier.TRANSIENT;
|
|
case "native": return Modifier.NATIVE;
|
|
case "abstract": return Modifier.ABSTRACT;
|
|
case "strictfp": return Modifier.STRICT;
|
|
case "default": return Modifier.STRICT;
|
|
default: break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception{
|
|
File file = new File("C:\\Users\\jeffc\\eclipse-workspace\\peer-at-code-backend\\src\\dev\\peerat\\backend\\routes\\users\\Register.java");
|
|
|
|
BufferedReader reader = new BufferedReader(new FileReader(file));
|
|
|
|
time = System.currentTimeMillis();
|
|
|
|
Parser<JavaElement> parser = new JavaParser();
|
|
JavaFile jFile = new JavaFile();
|
|
parser.parse(reader, jFile);
|
|
|
|
System.out.println();
|
|
|
|
jFile.find((e) -> {
|
|
System.out.println(e);
|
|
return false;
|
|
});
|
|
|
|
System.out.println((System.currentTimeMillis()-time)+"ms");
|
|
|
|
System.out.println(TokenValidator.MAX_VALIDATE+" / "+TokenValidator.TOKENS);
|
|
|
|
// parser.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
|
|
Builder builder = new Builder();
|
|
jFile.build(builder);
|
|
builder.build(new BufferedWriter(new FileWriter(new File("/home/ParserV2.txt"))));
|
|
}
|
|
}
|