private ArrayList<Class> classes;

private String sourceCode;

//**************************************************************************

//** main

//**************************************************************************

public static void main(String[] arr) throws Exception {

HashMap<String, String> args = console.parseArgs(arr);

//Get input file or directory

String path = args.get("-input");

if (path==null){

if (arr.length>0){

path = arr[0];

}

else{

System.out.println("-input file or directory is required");

return;

}

}

//Get test file as needed

String expectedOutput = null;

String test = args.get("-test");

if (test!=null) expectedOutput = new javaxt.io.File(test).getText();

//Generate output

java.io.File input = new java.io.File(path);

if (input.isFile()){

String output = parse(new javaxt.io.File(input));

if (expectedOutput==null){

System.out.print(output);

}

else{

if (output.equals(expectedOutput)){

System.out.println(input + " [PASS]");

}

else{

System.out.println(input + " [FAILED] <------");

}

}

}

else{

String[] filter = new String[]{"*.js", "*.java"};

for (javaxt.io.File file : new javaxt.io.Directory(input).getFiles(filter, true)){

String output = parse(file);

if (expectedOutput==null){

System.out.print(output);

}

else{

String t = expectedOutput.substring(0, output.length());

if (t.equals(output)){

System.out.println(file + " [PASS]");

expectedOutput = expectedOutput.substring(output.length());

}

else{

System.out.println(file + " [FAILED] <------");

for (int i=0; i<output.length(); i++){

char a = output.charAt(i);

char b = expectedOutput.charAt(i);

if (a!=b){

int start = i-50;

if (start<0) start = 0;

int end = Math.min(i + 50, output.length());

//, expectedOutput.length()

System.out.println(output.substring(start, i) + "|" + output.substring(i, end));

System.out.println("--------------------------------------------");

System.out.println(expectedOutput.substring(start, i) + "|" + expectedOutput.substring(i, end));

break;

}

}

break;

}

}

}

}

}

//**************************************************************************

//** Constructor

//**************************************************************************

public Parser(javaxt.io.File file) throws Exception {

this(file.getText(), file.getExtension());

}

//**************************************************************************

//** Constructor

//**************************************************************************

public Parser(String text, String type) throws Exception {

parse(text, type);

}

//**************************************************************************

//** getClasses

//**************************************************************************

public ArrayList<Class> getClasses(){

return classes;

}

//**************************************************************************

//** getSourceCode

//**************************************************************************

public String getSourceCode(){

return sourceCode;

}

//**************************************************************************

//** parse

//**************************************************************************

private void parse(String s, String ext){

sourceCode = s;

if (ext==null) ext = "";

else ext = ext.trim().toLowerCase();

if (ext.equals("js") || ext.equals("javascript")){

classes = getClasses(s);

if (classes.isEmpty()){

classes = getStaticFunctions(s);

}

}

else if (ext.equals("java")) {

classes = new ArrayList<>();

String packageName = null;

int i=0;

Word word, p1 = null, p2 = null;

while ((word = getNextWord(s, i))!=null){

String str = word.toString();

if (str.endsWith("package") && packageName==null){

Word nextWord = getNextWord(s, word.end);

packageName = nextWord.toString();

int idx = packageName.indexOf(";");

if (idx>-1){

packageName = packageName.substring(0, idx);

i = (nextWord.end-idx)+1;

}

else{

i = nextWord.end+1;

}

}

else if (str.endsWith("class") || str.endsWith("interface")){

int start = getStartBacket(s, i, '{');

int end = getEndBacket(s, start, '{');

Word nextWord = getNextWord(s, word.end);

String name = nextWord.toString();

Class cls = new Class(name);

cls.setNamespace(packageName);

addModifiers(cls, word, p1, p2);

addExtensions(cls, s.substring(word.end, start));

boolean isInterface = str.contains("interface");

cls.setInterface(isInterface);

addMembers(cls, s.substring(start, end));

cls.setPosition(i);

classes.add(cls);

i = end+1;

}

else{

i = word.end+1;

}

p2 = p1;

p1 = word;

}

}

else{

throw new IllegalArgumentException("Unsupported file type: " + ext);

}

}

//**************************************************************************

//** addMembers

//**************************************************************************

/** Used to find Java methods and properties and add them to the given class

private static void addMembers(Class cls, String s){

s = s.trim();

if (s.startsWith("{") && s.endsWith("}")) s = s.substring(1, s.length()-1).trim();

int i=0;

Word word;

while ((word = getNextWord(s, i))!=null){

String str = word.toString();

if (str.equals("public") || str.equals("private") || str.equals("protected")

|| str.equals("class") || str.equals("interface")

){

boolean isPublic = !(str.equals("private") || str.equals("protected"));

Comment comment = parseComment(word.lastComment);

int a = getStartBacket(s, i, '(');

int b = getStartBacket(s, i, ';');

int c = getStartBacket(s, i, '{');

int d = getStartBacket(s, i, '=');

if (a==-1) a = Integer.MAX_VALUE;

if (b==-1) b = Integer.MAX_VALUE;

if (c==-1) c = Integer.MAX_VALUE;

if (d==-1) d = Integer.MAX_VALUE;

if (c<a && c<b && c<d){ //found class or interface

int start = c;

int end = getEndBacket(s, start, '{');

String fn = s.substring(i, start);

ArrayList<Word> words = new ArrayList<>();

int j=0, idx=-1;

Word w;

while ((w = getNextWord(fn, j))!=null){

String wd = w.toString();

if (!wd.isEmpty()){

words.add(w);

if (wd.equals("class") || wd.equals("interface")){

idx = words.size()-1;

}

}

j = w.end+1;

}

if (idx>-1){

word = words.get(idx);

Word nextWord = words.get(idx+1);

String name = nextWord.toString();

Word p1 = idx>0 ? words.get(idx-1) : null;

Word p2 = idx>1 ? words.get(idx-2) : null;

String extensions = "";

for (j=idx+1; j<words.size(); j++){

if (!extensions.isEmpty()) extensions += " ";

extensions += words.get(j).toString();

}

Class innerClass = new Class(name);

addModifiers(innerClass, word, p1, p2);

addExtensions(innerClass, extensions);

boolean isInterface = word.toString().equals("interface");

innerClass.setInterface(isInterface);

addMembers(innerClass, s.substring(start, end));

innerClass.setPosition(nextWord.end);

cls.addMember(innerClass);

}

i = end+1;

}

else{ //found method or property

if (a<b && a<d){ //found method

//Get parameters

int start = a;

int end = getEndBacket(s, start, '(');

String params = s.substring(start, end);

//Get keywords before the parameters

String fn = s.substring(word.end, a);

ArrayList<String> arr = new ArrayList<>();

int j=0;

Word w;

while ((w = getNextWord(fn, j))!=null){

arr.add(w.toString().trim());

j = w.end+1;

}

//Get method name

String name = arr.get(arr.size()-1);

//Get return type

String returnType = null;

boolean isStatic = false;

if (arr.size()>1){

for (int k=0; k<arr.size()-1; k++){

String t = arr.get(k);

if (t.equals("final") || t.equals("static") || t.equals("abstract")){

if (t.equals("static")){

isStatic = true;

}

}

else{

if (returnType==null) returnType = t;

else returnType += " " + t;

}

}

returnType = returnType.trim();

if (returnType.isEmpty()) returnType = null;

}

//Create method

Method method;

if (returnType==null){

method = new Constructor(name);

}

else{

method = new Method(name);

method.setReturnType(returnType);

}

method.setPublic(isPublic);

method.setDescription(comment.getDescription());

method.setPosition(word.end);

cls.addMember(method);

//Add modifiers

method.setStatic(isStatic);

ArrayList<String> annotations = comment.getAnnotations();

for (String annotation : annotations){

if (annotation.startsWith("@deprecated")){

String additionalInfo = annotation.substring("@deprecated".length()).trim();

method.setDeprecated(true, additionalInfo);

}

}

//Add parameters

for (Parameter parameter : getParameters(params, annotations)){

method.addParameter(parameter);

}

//Find end of function

a = getStartBacket(s, end, '{');

b = getStartBacket(s, end, ';');

if (a==-1) a = Integer.MAX_VALUE;

if (b==-1) b = Integer.MAX_VALUE;

if (a<b){

end = getEndBacket(s, a, '{');

}

else if (b<a){

end = b;

}

i = end+1;

}

else if (b<a || d<a){ //found property or class

if (b<c){ //found property

String p = s.substring(word.end, b);

StringBuilder prop = new StringBuilder();

int j=0;

Word w;

while ((w = getNextWord(p, j))!=null){

String wd = w.toString();

if (!wd.isEmpty()){

if (prop.length()>0) prop.append(" ");

prop.append(wd);

}

j = w.end+1;

}

p = prop.toString().trim();

String defaultValue = null;

int idx = getStartBacket(p, 0, '=');

if (idx>-1){

defaultValue = p.substring(idx+1).trim();

p = p.substring(0, idx).trim();

}

ArrayList<String> arr = new ArrayList<>();

j=0;

while ((w = getNextWord(p, j))!=null){

arr.add(w.toString().trim());

j = w.end+1;

}

//Get property name

String name = arr.get(arr.size()-1);

//Get property type

String type = null;

boolean isStatic = false;

if (arr.size()>1){

for (int k=0; k<arr.size()-1; k++){

String t = arr.get(k);

if (t.equals("final") || t.equals("static") || t.equals("abstract")){

if (t.equals("static")){

isStatic = true;

}

}

else{

if (type==null) type = t;

else type += " " + t;

}

}

type = type.trim();

if (type.isEmpty()) type = null;

}

//console.log(cls.toString() + " - " + name + " (" + type + ") " +"|"+defaultValue);

Property property = new Property(name);

property.setPublic(isPublic);

property.setDescription(comment.getDescription());

property.setType(type);

property.setStatic(isStatic);

property.setDefaultValue(defaultValue);

property.setPosition(word.end);

cls.addMember(property);

i = b+1;

}

else{

i = word.end+1;

}

}

else{

i = word.end+1;

}

}

}

else{

i = word.end+1;

}

}

}

//**************************************************************************

//** addModifiers

//**************************************************************************

private static void addModifiers(Class cls, Word word, Word p1, Word p2){

String lastComment = word.lastComment;

if (lastComment==null){

if (p1!=null){

String type = p1.toString();

int idx = type.lastIndexOf(";");

if (idx>-1) type = type.substring(idx+1);

idx = type.lastIndexOf("}");

if (idx>-1) type = type.substring(idx+1);

if (type.equals("private") || type.equals("protected")){

cls.setPublic(false);

p2 = null;

}

else if (type.equals("public")){

p2 = null;

}

lastComment = p1.lastComment;

if (lastComment==null){

if (p2!=null){

type = p2.toString();

idx = type.lastIndexOf(";");

if (idx>-1) type = type.substring(idx+1);

idx = type.lastIndexOf("}");

if (idx>-1) type = type.substring(idx+1);

if (type.equals("private") || type.equals("protected")){

cls.setPublic(false);

}

lastComment = p2.lastComment;

}

}

}

}

if (lastComment!=null){

cls.setDescription(parseComment(lastComment).getDescription());

}

}

//**************************************************************************

//** addExtensions

//**************************************************************************

/** Used to search for "extends" and "implements" keywords after a Java

private static void addExtensions(Class cls, String fn){

if (fn==null) return;

fn = fn.trim();

if (fn.isEmpty()) return;

ArrayList<String> arr = new ArrayList<>();

int j=0;

Word word;

while ((word = getNextWord(fn, j))!=null){

arr.add(word.toString());

j = word.end+1;

}

//Add extensions

for (int x=1; x<arr.size(); x++){

String wd = arr.get(x);

if (wd.equals("extends")){

for (int y=x+1; y<arr.size(); y++){

String w = arr.get(y);

if (w.equals("implements")) break;

cls.addSuper(w);

}

}

if (wd.equals("implements")){

for (int y=x+1; y<arr.size(); y++){

String w = arr.get(y);

if (w.equals("extends")) break;

cls.addInterface(w);

}

}

}

}

//**************************************************************************

//** readLine

//**************************************************************************

/** Returns a string starting at a given index to the next line break

private static String readLine(String s, int offset){

StringBuilder str = new StringBuilder();

for (int i=offset; i<s.length(); i++){

char c = s.charAt(i);

str.append(c);

if (c=='\n') break;

}

return str.toString();

}

//**************************************************************************

//** readQuote

//**************************************************************************

/** Returns a string encapsulated by either a single or double quote,

private static String readQuote(String s, int i, char t){

StringBuilder str = new StringBuilder();

str.append(s.charAt(i));

boolean escaped = false;

for (int x=i+1; x<s.length(); x++){

char q = s.charAt(x);

str.append(q);

if (q==t){

if (!escaped){

break;

}

else{

escaped = false;

}

}

else if (q=='\\'){

escaped = !escaped;

}

else{

escaped = false;

}

}

return str.toString();

}

//**************************************************************************

//** getStartBacket

//**************************************************************************

private static int getStartBacket(String s, int offset, char startBracket){

boolean insideComment = false;

for (int i=offset; i<s.length(); i++){

char c = s.charAt(i);

char n = i==s.length()-1 ? ' ' : s.charAt(i+1);

if (c=='/' && n=='/'){

if (insideComment){

i = i+1;

}

else{

String comment = readLine(s, i);

i += comment.length()-1;

}

}

else if (c=='/' && n=='*'){

if (!insideComment){

insideComment = true;

}

i = i+1;

}

else if (c=='*' && n=='/'){

i = i+1;

if (insideComment){

insideComment = false;

}

}

else if (c=='"' || c=='\''){

if (!insideComment){

String quote = readQuote(s, i, c);

i = i+quote.length()-1;

}

}

else{

if (!insideComment){

if (c==startBracket) return i;

}

}

}

return -1;

}

//**************************************************************************

//** getEndBacket

//**************************************************************************

/** Returns the position of the last enclosing bracket in a block of text.

private static int getEndBacket(String s, int offset, char startBracket){

char endBracket;

if (startBracket=='{') endBracket = '}';

else if (startBracket=='(') endBracket = ')';

else if (startBracket=='[') endBracket = ']';

else return -1;

int numBrackets = 0;

boolean insideComment = false;

for (int i=offset; i<s.length(); i++){

char c = s.charAt(i);

char n = i==s.length()-1 ? ' ' : s.charAt(i+1);

if (c=='/' && n=='/'){

if (insideComment){

i = i+1;

}

else{

String comment = readLine(s, i);

i += comment.length()-1;

}

}

else if (c=='/' && n=='*'){

if (!insideComment){

insideComment = true;

}

i = i+1;

}

else if (c=='*' && n=='/'){

i = i+1;

if (insideComment){

insideComment = false;

}

}

else if (c=='"' || c=='\''){

if (!insideComment){

String quote = readQuote(s, i, c);

i = i+quote.length()-1;

}

}

else{

if (!insideComment){

if (c==startBracket){

numBrackets++;

}

if (c==endBracket){

numBrackets--;

if (numBrackets==0){

return i+1;

}

}

}

}

}

return -1;

}

//**************************************************************************

//** getNextWord

//**************************************************************************

/** Returns the next word in the given string that is not inside a comment

private static Word getNextWord(String s, int offset){

if (offset+1>s.length()) return null;

StringBuilder code = new StringBuilder();

boolean insideComment = false;

StringBuilder currComment = new StringBuilder();

String lastComment = null;

int lastCommentIndex = 0;

int i=offset;

for (; i<s.length(); i++){

char c = s.charAt(i);

char n = i==s.length()-1 ? ' ' : s.charAt(i+1);

if (c=='/' && n=='/'){

if (insideComment){

currComment.append("//");

i = i+1;

}

else{

String comment = readLine(s, i);

i += comment.length()-1;

code.append("\n");

}

}

else if (c=='/' && n=='*'){

if (!insideComment){

insideComment = true;

}

currComment.append("/*");

i = i+1;

}

else if (c=='*' && n=='/'){

currComment.append("*/");

i = i+1;

if (insideComment){

lastComment = currComment.toString();

lastCommentIndex = i;

//console.log(lastComment);

currComment.delete(0, currComment.length());

insideComment = false;

}

}

else if (c=='"' || c=='\''){

if (insideComment){

currComment.append(c);

}

else{

String quote = readQuote(s, i, c);

code.append(quote);

i = i+quote.length()-1;

}

}

else{

if (insideComment){

currComment.append(c);

}

else{

if ((c==' ' || c=='\r' || c=='\n' || c=='\t') && code.length()>0){

//Find start of the word

int idx = -1;

boolean foundEnd = false;

for (int j=code.length()-1; j>-1; j--){

int t = code.charAt(j);

if (t==' ' || c=='\r' || c=='\n' || c=='\t'){

if (foundEnd){

idx = j+1;

break;

}

}

else{

foundEnd = true;

}

}

//Get word

String word;

if (idx>-1){

word = code.substring(idx);

}

else{

word = code.toString();

}

if (!word.isBlank()){

return new Word(word.trim(), i, lastComment, lastCommentIndex);

}

else{

code = new StringBuilder();

}

}

code.append(c);

}

}

}

if (insideComment) return null;

String word = code.toString().trim();

if (word.isBlank()) return null;

return new Word(word, i, lastComment, lastCommentIndex);

}

//**************************************************************************

//** parseComment

//**************************************************************************

private static Comment parseComment(String comment){

if (comment==null) comment = "";

comment = comment.trim();

if (comment.startsWith("/*")) comment = comment.substring(2);

if (comment.endsWith("*/")) comment = comment.substring(0, comment.length()-2);

boolean insidePre = false;

StringBuilder str = new StringBuilder();

for (String row : comment.split("\n")){

if (!insidePre){

row = row.trim();

while (row.startsWith("*")) row = row.substring(1).trim();

insidePre = (row.contains("<pre>") && !row.contains("</pre>"));

}

else{

if (row.contains("</pre>")) insidePre = false;

}

if (str.length()>0){

if (insidePre) str.append("\n");

else{

if (row.startsWith("@")) str.append("\n");

else str.append(" ");

}

}

str.append(row);

}

String comments = str.toString().trim();

//Parse comments separating description from annotations

String description = null;

ArrayList<String> annotations = new ArrayList<>();

if (comments!=null){

int idx = 0;

ArrayList<Integer> indexes = new ArrayList<>();

for (String row : comments.split("\n")){

if (row.startsWith("@")) indexes.add(idx);

idx+=row.length()+1;

}

if (indexes.isEmpty()){

description = comments;

}

else{

int firstComment = indexes.get(0);

if (firstComment>0){

description = comments.substring(0, firstComment);

}

for (int i=0; i<indexes.size(); i++){

idx = indexes.get(i);

if (i==indexes.size()-1){

annotations.add(comments.substring(idx).trim());

}

else{

annotations.add(comments.substring(idx, indexes.get(i+1)).trim());

}

}

}

}

return new Comment(description, annotations);

}

//**************************************************************************

//** getClasses

//**************************************************************************

/** Used to extract classes from a given block of JavaScript. This parser

private static ArrayList<Class> getClasses(String s){

ArrayList<Class> classes = new ArrayList<>();

int i=0;

Word word, p1 = null, p2 = null;

while ((word = getNextWord(s, i))!=null){

String str = word.toString();

if (str.contains("function")){

//Get function name

JSONObject fn = getFunctionName(word, p1, p2);

//Get parameters

int start = getStartBacket(s, i, '(');

int end = getEndBacket(s, start, '(');

String params = s.substring(start, end);

//Read function

start = getStartBacket(s, i, '{');

end = getEndBacket(s, start, '{');

str = s.substring(start, end);

if (fn!=null){

String functionName = fn.get("name").toString();

if (functionName.contains(".")){ //function with a namespace

//Update functionName

String namespace = functionName.substring(0, functionName.lastIndexOf("."));

functionName = functionName.substring(namespace.length()+1);

//Create class

Class cls = new Class(functionName);