public void visit(TryStmt n, Object arg) {
   n.getTryBlock().accept(this, arg);
   if (n.getCatchs() != null) {
     for (CatchClause c : n.getCatchs()) {
       c.accept(this, arg);
     }
   }
   if (n.getFinallyBlock() != null) {
     n.getFinallyBlock().accept(this, arg);
   }
 }
 /**
  * Highly recursive method that will parse a file into its semantical statements. Currently
  * identifies all often used Statements (if, for, while, try, etc.). Also every other non-flow
  * dependant statement like variable assignments, method calls, etc are considered Expression
  * Statements. As they are "primitive" in terms that cannot contain inner expressions, we just use
  * the default name of the class for them as the Token Type.
  *
  * <p>For more information and examples on how this parser actually works, please refer to the
  * documentation.
  *
  * @param stmt
  */
 private void parseStatement(Statement stmt) {
   // full list of all statements:
   // https://java.net/projects/jpjavaparser/sources/source-code-repository/show/src/japa/parser/ast/stmt
   if (stmt == null) {
     return;
   }
   // Block Statement is a List of statements
   if (stmt instanceof BlockStmt) {
     BlockStmt blockStmt = (BlockStmt) stmt;
     for (Statement st : blockStmt.getStmts()) {
       parseStatement(st);
     }
     // If Statement
   } else if (stmt instanceof IfStmt) {
     IfStmt ifStmt = (IfStmt) stmt;
     tokens.add(new Token(ifStmt.getCondition().toString(), getObjectType(ifStmt)));
     parseStatement(ifStmt.getThenStmt());
     parseStatement(ifStmt.getElseStmt());
     // For statement
   } else if (stmt instanceof ForStmt) {
     ForStmt forStmt = (ForStmt) stmt;
     if (forStmt.getInit() != null
         && forStmt.getCompare() != null
         && forStmt.getUpdate() != null) {
       tokens.add(
           new Token(
               forStmt.getInit().toString()
                   + ";"
                   + forStmt.getCompare().toString()
                   + ";"
                   + forStmt.getUpdate().toString(),
               getObjectType(forStmt)));
     } else {
       tokens.add(new Token("For", getObjectType(forStmt)));
     }
     parseStatement(forStmt.getBody());
     // Foreach Statement
   } else if (stmt instanceof ForeachStmt) {
     ForeachStmt foreachStmt = (ForeachStmt) stmt;
     tokens.add(
         new Token(
             foreachStmt.getVariable().toString() + ":" + foreachStmt.getIterable().toString(),
             getObjectType(foreachStmt)));
     parseStatement(foreachStmt.getBody());
     // While Statement
   } else if (stmt instanceof WhileStmt) {
     WhileStmt whileStmt = (WhileStmt) stmt;
     tokens.add(new Token(whileStmt.getCondition().toString(), getObjectType(whileStmt)));
     parseStatement(whileStmt.getBody());
     // Do Statement
   } else if (stmt instanceof DoStmt) {
     DoStmt doStmt = (DoStmt) stmt;
     tokens.add(new Token(doStmt.getCondition().toString(), getObjectType(doStmt)));
     parseStatement(doStmt.getBody());
     // Try Statement
   } else if (stmt instanceof TryStmt) {
     TryStmt tryStmt = (TryStmt) stmt;
     tokens.add(new Token("Try", getObjectType(tryStmt)));
     parseStatement(tryStmt.getTryBlock());
     // Return Statement
   } else if (stmt instanceof ReturnStmt) {
     ReturnStmt returnStmt = (ReturnStmt) stmt;
     if (returnStmt.getExpr() != null) {
       tokens.add(new Token(returnStmt.getExpr().toString(), getObjectType(returnStmt)));
     } else {
       tokens.add(new Token("Void", getObjectType(returnStmt)));
     }
     // Empty Statement
   } else if (stmt instanceof EmptyStmt) {
     tokens.add(new Token("", getObjectType(stmt)));
     // Continue Statement
   } else if (stmt instanceof ContinueStmt) {
     tokens.add(new Token("Continue", getObjectType(stmt)));
     // Break Statement
   } else if (stmt instanceof BreakStmt) {
     tokens.add(new Token("Break", getObjectType(stmt)));
     // Explicit Constructor Invocation Statement
   } else if (stmt instanceof ExplicitConstructorInvocationStmt) {
     ExplicitConstructorInvocationStmt eciStmt = (ExplicitConstructorInvocationStmt) stmt;
     tokens.add(new Token(eciStmt.getExpr().toString(), getObjectType(eciStmt)));
     // Expression Statement
   } else if (stmt instanceof ExpressionStmt) {
     ExpressionStmt exprStmt = (ExpressionStmt) stmt;
     tokens.add(new Token(exprStmt.toString(), getObjectType(exprStmt.getExpression())));
   } else {
     // this should never be called
     tokens.add(new Token(stmt.toString(), "OTHER"));
   }
 }