Add the java javaparser

https://github.com/javaparser/javaparser/
Invisible tag: javaparser-1.0.6

parser/html/java/javaparser/LICENSE

@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

parser/html/java/javaparser/ant/build.xml

@@ -0,0 +1,86 @@
+<project name="JavaParserBuilder" default="all">
+
+	<!-- current version -->
+	<property name="version" value="1.0.6" />
+
+	<!-- package build properties -->
+	<property name="source.dir" location="../" />
+	<property name="temp.dir" value="${user.home}/Desktop/" />
+	<property name="file.name" value="javaparser-${version}" />
+
+	<property name="src.file.name" value="${file.name}-src.zip" />
+	<property name="bin.jar.name" value="${file.name}.jar" />
+	<property name="bin.file.name" value="${file.name}.zip" />
+
+	<property name="src.temp.file" value="${temp.dir}/${src.file.name}" />
+	<property name="bin.temp.file" value="${temp.dir}/${bin.file.name}" />
+	<property name="bin.temp.jar" value="${temp.dir}/${bin.jar.name}" />
+
+
+	<!-- googlecode properties -->
+	<taskdef classname="net.bluecow.googlecode.ant.GoogleCodeUploadTask" classpath="ant-googlecode-0.0.1.jar" name="gcupload" />
+	<property name="googlecode.user" value="jgesser" />
+	<!-- the file must have a property named "googlecode.password" -->
+	<property file="../../JavaParser-ant/pass.txt" />
+	<property name="googlecode.project" value="javaparser" />
+	<property name="googlecode.file.summary.src" value="Java1.5 parser and AST release ${version} (source)" />
+	<property name="googlecode.file.summary.bin" value="Java1.5 parser and AST release ${version} (binary)" />
+	<property name="googlecode.file.labels.src" value="Featured, Type-Source, OpSys-All" />
+	<property name="googlecode.file.labels.bin" value="Featured, Type-Archive, OpSys-All" />
+
+	<target name="build-src">
+		<zip destfile="${src.temp.file}" level="9">
+			<fileset dir="${source.dir}">
+				<exclude name=".*" />
+				<exclude name="bin/**" />
+				<exclude name="ant/**" />
+				<exclude name="test/ignore/**" />
+			</fileset>
+		</zip>
+	</target>
+
+	<target name="build-bin">
+		<jar destfile="${bin.temp.jar}">
+			<fileset dir="${source.dir}/bin">
+				<exclude name="TestRunner*.class" />
+				<exclude name="**/test/**/*" />
+			</fileset>
+		</jar>
+
+		<zip destfile="${bin.temp.file}" level="9">
+			<fileset dir="${source.dir}">
+				<include name="COPYING" />
+				<include name="COPYING.LESSER" />
+				<include name="readme.txt" />
+			</fileset>
+			<fileset file="${bin.temp.jar}" />
+		</zip>
+	</target>
+
+	<target name="upload-src">
+		<gcupload username="${googlecode.user}" password="${googlecode.password}" projectname="${googlecode.project}" filename="${src.temp.file}" targetfilename="${src.file.name}" summary="${googlecode.file.summary.src}" labels="${googlecode.file.labels.src}" />
+	</target>
+
+	<target name="upload-bin">
+		<gcupload username="${googlecode.user}" password="${googlecode.password}" projectname="${googlecode.project}" filename="${bin.temp.file}" targetfilename="${bin.file.name}" summary="${googlecode.file.summary.bin}" labels="${googlecode.file.labels.bin}" />
+	</target>
+
+	<target name="clean">
+		<delete file="${src.temp.file}" failonerror="true" />
+		<delete file="${bin.temp.file}" failonerror="true" />
+		<delete file="${bin.temp.jar}" failonerror="true" />
+	</target>
+
+	<target name="all" description="default">
+		<antcall target="clean" />
+
+		<antcall target="build-src" />
+		<antcall target="build-bin" />
+
+		<antcall target="upload-src" />
+		<antcall target="upload-bin" />
+
+		<antcall target="clean" />
+	</target>
+
+</project>

parser/html/java/javaparser/readme.txt

@@ -0,0 +1,138 @@
++-------------------------------------------------------------------------------+
+|  Java 1.5 parser and Abstract Syntax Tree.                                    |
++-------------------------------------------------------------------------------+
+|  Copyright (C) 2007 Júlio Vilmar Gesser                                       |
+|  jgesser@gmail.com                                                            |
+|  http://code.google.com/p/javaparser/                                         |
++-------------------------------------------------------------------------------+
+|  This program is free software: you can redistribute it and/or modify         |
+|  it under the terms of the GNU Lesser General Public License as published by  |
+|  the Free Software Foundation, either version 3 of the License, or            |
+|  (at your option) any later version.                                          |
+|                                                                               |
+|  This program is distributed in the hope that it will be useful,              |
+|  but WITHOUT ANY WARRANTY; without even the implied warranty of               |
+|  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                |
+|  GNU Lesser General Public License for more details.                          |
+|                                                                               |
+|  You should have received a copy of the GNU Lesser General Public License     |
+|  along with this program.  If not, see <http://www.gnu.org/licenses/>.        |
++-------------------------------------------------------------------------------+    
+
+This package contains a Java 1.5 Parser with AST generation and visitor support. 
+The AST records the source code structure, javadoc and comments. Soon will be 
+possible change the AST nodes or create new ones to modify source code like refactoring.
+This parser is based on Sreenivasa Viswanadha Java 1.5 parser.
+
+Visit the project site, there you can get help, view some sample codes, report 
+bugs and feature enhacement and download the latest version:
+ 	http://code.google.com/p/javaparser/
+
+
+Version history
+---------------
+
+1.0.6 (2009-01-11)
+- Issue 11 fixed: changed method get/setPakage to get/setPackage in the class CompilationUnit
+- Created new visitor adapter to help AST modification: ModifierVisitorAdapter
+- Changed visitor adapters to abstract  
+
+1.0.5 (2008-10-26)
+- Created simplified constructors in the nodes of the AST (without positional arguments) 
+- Created ASTHelper class with some helpful methods (more methods are still needed)
+
+1.0.4 (2008-10-07)
+- Moved to javacc 4.1.
+- The java_1_5.jj can be build alone without compilation errors
+
+1.0.3 (2008-09-06)
+- Removed SuperMemberAccessExpr class, it was no longer used
+- Removed the methods get/setTypeArgs() from ArrayCreationExpr, this node shouldn't have these methods.
+- Fixed the bug with start/end position of the nodes IntegerLiteralMinValueExpr and LongLiteralMinValueExpr  
+- The methods get/setAnnotations() from all BodyDeclaration subclasses were pushed down to BodyDeclaration class 
+
+1.0.2 (2008-07-20)
+  Issue fixed: Issue 1: Add support for editing AST nodes or create new ones
+
+1.0.1 (2008-07-01)
+- Issue fixed: Issue 5: end line and end column equal to begin line and begin column
+
+1.0.0 (2008-06-25)
+- Changed version numbering, starting version 1.0.0
+- Javadoc done for packages:
+    - japa.parser
+    - japa.parser.ast
+- Corrected bug when parsing in multithread: 
+    - JavaParser.setCacheParser(false) must be called before to use the parser concurrent 
+
+2008-06-19
+- No code changes, added binary distribution to download page 
+
+2008-06-11
+- Bug corrected: NPE in VoidVisitorAdapter 
+	- http://code.google.com/p/javaparser/issues/detail?id=2
+
+2008-06-09
+- Added Adapters for de visitors
+
+2008-05-28
+- This project now is published at Google Code:
+	- http://code.google.com/p/javaparser/
+
+2008-05-25
+- Added support for comments and javadoc to the tree. 
+	- Javadocs are stored directly to members (BodyDeclaration and all deriveds (classes, methods, fields, etc.)), accessible by the method getJavadoc().
+	- All comments are stored in the CompilationUnit, accessible by the method getComments().
+
+2008-04-01
+- Changed all nodes public attributes to be private and created getters to access them
+- Changed the methods of the Node getLine e getColumn to getBeginLine and getBeginColumn
+- Added the methods getEndLine and getEndColumn to the Node class (works only in the BlockNode)
+
+2007-12-22
+- Corrected ConditionalExpression bug
+
+2007-10-21
+- Added LGPL License
+
+2007-10-21
+- Bugs corrected:  
+  - Created PackageDeclaration member of CompilationUnit to add suport for annotations in the package declaration
+  - Parameterized anonymous constructor invocation
+  - Explicit constructor invotation Type Arguments
+  - ctrl+z ("\u001A") ar end of compilation unit
+
+2007-10-09
+- EnumConstantDeclaration annotation support corrected
+- Parssing Java Unicode escape characters suport added
+
+2007-10-03
+- Bug corrected: "MotifComboPopup.this.super()" statement was generating parser error
+	                    
+2007-10-01
+- Bug corrected: Casting signed primitive values
+	double d = (double) -1;
+	                    ^
+
+2007-08-06
+- Bug with the ingle line comments in the final of the unit corrected
+
+2007-07-31
+- Fixed the bug with the following expression:
+	Class c = (int.class);
+
+2007-06-26
+- Bug fixes from Leon Poyyayil work
+	- suport for hex floating point
+	- unicode digits in indentifier 
+	- MemberValueArrayInitializer
+
+2007-03-09
+- Long and Integer literal MIN_VALUE bug	
+
+2007-02-24
+- '\0' bug fixed	
+
+2007-02-01
+- Many bug fixes
+- Added line/column to nodes

parser/html/java/javaparser/src/japa/parser/ASTHelper.java

@@ -0,0 +1,264 @@
+package japa.parser;
+
+import japa.parser.ast.CompilationUnit;
+import japa.parser.ast.body.BodyDeclaration;
+import japa.parser.ast.body.FieldDeclaration;
+import japa.parser.ast.body.MethodDeclaration;
+import japa.parser.ast.body.Parameter;
+import japa.parser.ast.body.TypeDeclaration;
+import japa.parser.ast.body.VariableDeclarator;
+import japa.parser.ast.body.VariableDeclaratorId;
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.expr.MethodCallExpr;
+import japa.parser.ast.expr.NameExpr;
+import japa.parser.ast.expr.QualifiedNameExpr;
+import japa.parser.ast.expr.VariableDeclarationExpr;
+import japa.parser.ast.stmt.BlockStmt;
+import japa.parser.ast.stmt.ExpressionStmt;
+import japa.parser.ast.stmt.Statement;
+import japa.parser.ast.type.ClassOrInterfaceType;
+import japa.parser.ast.type.PrimitiveType;
+import japa.parser.ast.type.ReferenceType;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.type.VoidType;
+import japa.parser.ast.type.PrimitiveType.Primitive;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class helps to construct new nodes.
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class ASTHelper {
+
+    public static final PrimitiveType BYTE_TYPE = new PrimitiveType(Primitive.Byte);
+
+    public static final PrimitiveType SHORT_TYPE = new PrimitiveType(Primitive.Short);
+
+    public static final PrimitiveType INT_TYPE = new PrimitiveType(Primitive.Int);
+
+    public static final PrimitiveType LONG_TYPE = new PrimitiveType(Primitive.Long);
+
+    public static final PrimitiveType FLOAT_TYPE = new PrimitiveType(Primitive.Float);
+
+    public static final PrimitiveType DOUBLE_TYPE = new PrimitiveType(Primitive.Double);
+
+    public static final PrimitiveType BOOLEAN_TYPE = new PrimitiveType(Primitive.Boolean);
+
+    public static final PrimitiveType CHAR_TYPE = new PrimitiveType(Primitive.Char);
+
+    public static final VoidType VOID_TYPE = new VoidType();
+
+    private ASTHelper() {
+        // nop
+    }
+
+    /**
+     * Creates a new {@link NameExpr} from a qualified name.<br>
+     * The qualified name can contains "." (dot) characters.
+     * 
+     * @param qualifiedName
+     *            qualified name
+     * @return instanceof {@link NameExpr}
+     */
+    public static NameExpr createNameExpr(String qualifiedName) {
+        String[] split = qualifiedName.split("\\.");
+        NameExpr ret = new NameExpr(split[0]);
+        for (int i = 1; i < split.length; i++) {
+            ret = new QualifiedNameExpr(ret, split[i]);
+        }
+        return ret;
+    }
+
+    /**
+     * Creates a new {@link Parameter}.
+     * 
+     * @param type
+     *            type of the parameter
+     * @param name
+     *            name of the parameter
+     * @return instance of {@link Parameter}
+     */
+    public static Parameter createParameter(Type type, String name) {
+        return new Parameter(type, new VariableDeclaratorId(name));
+    }
+
+    /**
+     * Creates a {@link FieldDeclaration}.
+     * 
+     * @param modifiers
+     *            modifiers
+     * @param type
+     *            type
+     * @param variable
+     *            variable declarator
+     * @return instance of {@link FieldDeclaration}
+     */
+    public static FieldDeclaration createFieldDeclaration(int modifiers, Type type, VariableDeclarator variable) {
+        List<VariableDeclarator> variables = new ArrayList<VariableDeclarator>();
+        variables.add(variable);
+        FieldDeclaration ret = new FieldDeclaration(modifiers, type, variables);
+        return ret;
+    }
+
+    /**
+     * Creates a {@link FieldDeclaration}.
+     * 
+     * @param modifiers
+     *            modifiers
+     * @param type
+     *            type
+     * @param name
+     *            field name
+     * @return instance of {@link FieldDeclaration}
+     */
+    public static FieldDeclaration createFieldDeclaration(int modifiers, Type type, String name) {
+        VariableDeclaratorId id = new VariableDeclaratorId(name);
+        VariableDeclarator variable = new VariableDeclarator(id);
+        return createFieldDeclaration(modifiers, type, variable);
+    }
+
+    /**
+     * Creates a {@link VariableDeclarationExpr}.
+     * 
+     * @param type
+     *            type
+     * @param name
+     *            name
+     * @return instance of {@link VariableDeclarationExpr}
+     */
+    public static VariableDeclarationExpr createVariableDeclarationExpr(Type type, String name) {
+        List<VariableDeclarator> vars = new ArrayList<VariableDeclarator>();
+        vars.add(new VariableDeclarator(new VariableDeclaratorId(name)));
+        return new VariableDeclarationExpr(type, vars);
+    }
+
+    /**
+     * Adds the given parameter to the method. The list of parameters will be
+     * initialized if it is <code>null</code>.
+     * 
+     * @param method
+     *            method
+     * @param parameter
+     *            parameter
+     */
+    public static void addParameter(MethodDeclaration method, Parameter parameter) {
+        List<Parameter> parameters = method.getParameters();
+        if (parameters == null) {
+            parameters = new ArrayList<Parameter>();
+            method.setParameters(parameters);
+        }
+        parameters.add(parameter);
+    }
+
+    /**
+     * Adds the given argument to the method call. The list of arguments will be
+     * initialized if it is <code>null</code>.
+     * 
+     * @param call
+     *            method call
+     * @param arg
+     *            argument value
+     */
+    public static void addArgument(MethodCallExpr call, Expression arg) {
+        List<Expression> args = call.getArgs();
+        if (args == null) {
+            args = new ArrayList<Expression>();
+            call.setArgs(args);
+        }
+        args.add(arg);
+    }
+
+    /**
+     * Adds the given type declaration to the compilation unit. The list of
+     * types will be initialized if it is <code>null</code>.
+     * 
+     * @param cu
+     *            compilation unit
+     * @param type
+     *            type declaration
+     */
+    public static void addTypeDeclaration(CompilationUnit cu, TypeDeclaration type) {
+        List<TypeDeclaration> types = cu.getTypes();
+        if (types == null) {
+            types = new ArrayList<TypeDeclaration>();
+            cu.setTypes(types);
+        }
+        types.add(type);
+
+    }
+
+    /**
+     * Creates a new {@link ReferenceType} for a class or interface.
+     * 
+     * @param name
+     *            name of the class or interface
+     * @param arrayCount
+     *            number os arrays or <code>0</code> if is not a array.
+     * @return instanceof {@link ReferenceType}
+     */
+    public static ReferenceType createReferenceType(String name, int arrayCount) {
+        return new ReferenceType(new ClassOrInterfaceType(name), arrayCount);
+    }
+
+    /**
+     * Creates a new {@link ReferenceType} for the given primitive type.
+     * 
+     * @param type
+     *            primitive type
+     * @param arrayCount
+     *            number os arrays or <code>0</code> if is not a array.
+     * @return instanceof {@link ReferenceType}
+     */
+    public static ReferenceType createReferenceType(PrimitiveType type, int arrayCount) {
+        return new ReferenceType(type, arrayCount);
+    }
+
+    /**
+     * Adds the given statement to the specified block. The list of statements
+     * will be initialized if it is <code>null</code>.
+     * 
+     * @param block
+     * @param stmt
+     */
+    public static void addStmt(BlockStmt block, Statement stmt) {
+        List<Statement> stmts = block.getStmts();
+        if (stmts == null) {
+            stmts = new ArrayList<Statement>();
+            block.setStmts(stmts);
+        }
+        stmts.add(stmt);
+    }
+
+    /**
+     * Adds the given expression to the specified block. The list of statements
+     * will be initialized if it is <code>null</code>.
+     * 
+     * @param block
+     * @param stmt
+     */
+    public static void addStmt(BlockStmt block, Expression expr) {
+        addStmt(block, new ExpressionStmt(expr));
+    }
+
+    /**
+     * Adds the given declaration to the specified type. The list of members
+     * will be initialized if it is <code>null</code>.
+     * 
+     * @param type
+     *            type declaration
+     * @param decl
+     *            member declaration
+     */
+    public static void addMember(TypeDeclaration type, BodyDeclaration decl) {
+        List<BodyDeclaration> members = type.getMembers();
+        if (members == null) {
+            members = new ArrayList<BodyDeclaration>();
+            type.setMembers(members);
+        }
+        members.add(decl);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ASTParserConstants.java

@@ -0,0 +1,410 @@
+/* Generated By:JavaCC: Do not edit this line. ASTParserConstants.java */
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser;
+
+
+/** 
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface ASTParserConstants {
+
+  /** End of File. */
+  int EOF = 0;
+  /** RegularExpression Id. */
+  int SINGLE_LINE_COMMENT = 6;
+  /** RegularExpression Id. */
+  int JAVA_DOC_COMMENT = 9;
+  /** RegularExpression Id. */
+  int MULTI_LINE_COMMENT = 10;
+  /** RegularExpression Id. */
+  int ABSTRACT = 12;
+  /** RegularExpression Id. */
+  int ASSERT = 13;
+  /** RegularExpression Id. */
+  int BOOLEAN = 14;
+  /** RegularExpression Id. */
+  int BREAK = 15;
+  /** RegularExpression Id. */
+  int BYTE = 16;
+  /** RegularExpression Id. */
+  int CASE = 17;
+  /** RegularExpression Id. */
+  int CATCH = 18;
+  /** RegularExpression Id. */
+  int CHAR = 19;
+  /** RegularExpression Id. */
+  int CLASS = 20;
+  /** RegularExpression Id. */
+  int CONST = 21;
+  /** RegularExpression Id. */
+  int CONTINUE = 22;
+  /** RegularExpression Id. */
+  int _DEFAULT = 23;
+  /** RegularExpression Id. */
+  int DO = 24;
+  /** RegularExpression Id. */
+  int DOUBLE = 25;
+  /** RegularExpression Id. */
+  int ELSE = 26;
+  /** RegularExpression Id. */
+  int ENUM = 27;
+  /** RegularExpression Id. */
+  int EXTENDS = 28;
+  /** RegularExpression Id. */
+  int FALSE = 29;
+  /** RegularExpression Id. */
+  int FINAL = 30;
+  /** RegularExpression Id. */
+  int FINALLY = 31;
+  /** RegularExpression Id. */
+  int FLOAT = 32;
+  /** RegularExpression Id. */
+  int FOR = 33;
+  /** RegularExpression Id. */
+  int GOTO = 34;
+  /** RegularExpression Id. */
+  int IF = 35;
+  /** RegularExpression Id. */
+  int IMPLEMENTS = 36;
+  /** RegularExpression Id. */
+  int IMPORT = 37;
+  /** RegularExpression Id. */
+  int INSTANCEOF = 38;
+  /** RegularExpression Id. */
+  int INT = 39;
+  /** RegularExpression Id. */
+  int INTERFACE = 40;
+  /** RegularExpression Id. */
+  int LONG = 41;
+  /** RegularExpression Id. */
+  int NATIVE = 42;
+  /** RegularExpression Id. */
+  int NEW = 43;
+  /** RegularExpression Id. */
+  int NULL = 44;
+  /** RegularExpression Id. */
+  int PACKAGE = 45;
+  /** RegularExpression Id. */
+  int PRIVATE = 46;
+  /** RegularExpression Id. */
+  int PROTECTED = 47;
+  /** RegularExpression Id. */
+  int PUBLIC = 48;
+  /** RegularExpression Id. */
+  int RETURN = 49;
+  /** RegularExpression Id. */
+  int SHORT = 50;
+  /** RegularExpression Id. */
+  int STATIC = 51;
+  /** RegularExpression Id. */
+  int STRICTFP = 52;
+  /** RegularExpression Id. */
+  int SUPER = 53;
+  /** RegularExpression Id. */
+  int SWITCH = 54;
+  /** RegularExpression Id. */
+  int SYNCHRONIZED = 55;
+  /** RegularExpression Id. */
+  int THIS = 56;
+  /** RegularExpression Id. */
+  int THROW = 57;
+  /** RegularExpression Id. */
+  int THROWS = 58;
+  /** RegularExpression Id. */
+  int TRANSIENT = 59;
+  /** RegularExpression Id. */
+  int TRUE = 60;
+  /** RegularExpression Id. */
+  int TRY = 61;
+  /** RegularExpression Id. */
+  int VOID = 62;
+  /** RegularExpression Id. */
+  int VOLATILE = 63;
+  /** RegularExpression Id. */
+  int WHILE = 64;
+  /** RegularExpression Id. */
+  int LONG_LITERAL = 65;
+  /** RegularExpression Id. */
+  int INTEGER_LITERAL = 66;
+  /** RegularExpression Id. */
+  int DECIMAL_LITERAL = 67;
+  /** RegularExpression Id. */
+  int HEX_LITERAL = 68;
+  /** RegularExpression Id. */
+  int OCTAL_LITERAL = 69;
+  /** RegularExpression Id. */
+  int FLOATING_POINT_LITERAL = 70;
+  /** RegularExpression Id. */
+  int DECIMAL_FLOATING_POINT_LITERAL = 71;
+  /** RegularExpression Id. */
+  int DECIMAL_EXPONENT = 72;
+  /** RegularExpression Id. */
+  int HEXADECIMAL_FLOATING_POINT_LITERAL = 73;
+  /** RegularExpression Id. */
+  int HEXADECIMAL_EXPONENT = 74;
+  /** RegularExpression Id. */
+  int CHARACTER_LITERAL = 75;
+  /** RegularExpression Id. */
+  int STRING_LITERAL = 76;
+  /** RegularExpression Id. */
+  int IDENTIFIER = 77;
+  /** RegularExpression Id. */
+  int LETTER = 78;
+  /** RegularExpression Id. */
+  int PART_LETTER = 79;
+  /** RegularExpression Id. */
+  int LPAREN = 80;
+  /** RegularExpression Id. */
+  int RPAREN = 81;
+  /** RegularExpression Id. */
+  int LBRACE = 82;
+  /** RegularExpression Id. */
+  int RBRACE = 83;
+  /** RegularExpression Id. */
+  int LBRACKET = 84;
+  /** RegularExpression Id. */
+  int RBRACKET = 85;
+  /** RegularExpression Id. */
+  int SEMICOLON = 86;
+  /** RegularExpression Id. */
+  int COMMA = 87;
+  /** RegularExpression Id. */
+  int DOT = 88;
+  /** RegularExpression Id. */
+  int AT = 89;
+  /** RegularExpression Id. */
+  int ASSIGN = 90;
+  /** RegularExpression Id. */
+  int LT = 91;
+  /** RegularExpression Id. */
+  int BANG = 92;
+  /** RegularExpression Id. */
+  int TILDE = 93;
+  /** RegularExpression Id. */
+  int HOOK = 94;
+  /** RegularExpression Id. */
+  int COLON = 95;
+  /** RegularExpression Id. */
+  int EQ = 96;
+  /** RegularExpression Id. */
+  int LE = 97;
+  /** RegularExpression Id. */
+  int GE = 98;
+  /** RegularExpression Id. */
+  int NE = 99;
+  /** RegularExpression Id. */
+  int SC_OR = 100;
+  /** RegularExpression Id. */
+  int SC_AND = 101;
+  /** RegularExpression Id. */
+  int INCR = 102;
+  /** RegularExpression Id. */
+  int DECR = 103;
+  /** RegularExpression Id. */
+  int PLUS = 104;
+  /** RegularExpression Id. */
+  int MINUS = 105;
+  /** RegularExpression Id. */
+  int STAR = 106;
+  /** RegularExpression Id. */
+  int SLASH = 107;
+  /** RegularExpression Id. */
+  int BIT_AND = 108;
+  /** RegularExpression Id. */
+  int BIT_OR = 109;
+  /** RegularExpression Id. */
+  int XOR = 110;
+  /** RegularExpression Id. */
+  int REM = 111;
+  /** RegularExpression Id. */
+  int LSHIFT = 112;
+  /** RegularExpression Id. */
+  int PLUSASSIGN = 113;
+  /** RegularExpression Id. */
+  int MINUSASSIGN = 114;
+  /** RegularExpression Id. */
+  int STARASSIGN = 115;
+  /** RegularExpression Id. */
+  int SLASHASSIGN = 116;
+  /** RegularExpression Id. */
+  int ANDASSIGN = 117;
+  /** RegularExpression Id. */
+  int ORASSIGN = 118;
+  /** RegularExpression Id. */
+  int XORASSIGN = 119;
+  /** RegularExpression Id. */
+  int REMASSIGN = 120;
+  /** RegularExpression Id. */
+  int LSHIFTASSIGN = 121;
+  /** RegularExpression Id. */
+  int RSIGNEDSHIFTASSIGN = 122;
+  /** RegularExpression Id. */
+  int RUNSIGNEDSHIFTASSIGN = 123;
+  /** RegularExpression Id. */
+  int ELLIPSIS = 124;
+  /** RegularExpression Id. */
+  int RUNSIGNEDSHIFT = 125;
+  /** RegularExpression Id. */
+  int RSIGNEDSHIFT = 126;
+  /** RegularExpression Id. */
+  int GT = 127;
+
+  /** Lexical state. */
+  int DEFAULT = 0;
+  /** Lexical state. */
+  int IN_JAVA_DOC_COMMENT = 1;
+  /** Lexical state. */
+  int IN_MULTI_LINE_COMMENT = 2;
+
+  /** Literal token values. */
+  String[] tokenImage = {
+    "<EOF>",
+    "\" \"",
+    "\"\\t\"",
+    "\"\\n\"",
+    "\"\\r\"",
+    "\"\\f\"",
+    "<SINGLE_LINE_COMMENT>",
+    "<token of kind 7>",
+    "\"/*\"",
+    "\"*/\"",
+    "\"*/\"",
+    "<token of kind 11>",
+    "\"abstract\"",
+    "\"assert\"",
+    "\"boolean\"",
+    "\"break\"",
+    "\"byte\"",
+    "\"case\"",
+    "\"catch\"",
+    "\"char\"",
+    "\"class\"",
+    "\"const\"",
+    "\"continue\"",
+    "\"default\"",
+    "\"do\"",
+    "\"double\"",
+    "\"else\"",
+    "\"enum\"",
+    "\"extends\"",
+    "\"false\"",
+    "\"final\"",
+    "\"finally\"",
+    "\"float\"",
+    "\"for\"",
+    "\"goto\"",
+    "\"if\"",
+    "\"implements\"",
+    "\"import\"",
+    "\"instanceof\"",
+    "\"int\"",
+    "\"interface\"",
+    "\"long\"",
+    "\"native\"",
+    "\"new\"",
+    "\"null\"",
+    "\"package\"",
+    "\"private\"",
+    "\"protected\"",
+    "\"public\"",
+    "\"return\"",
+    "\"short\"",
+    "\"static\"",
+    "\"strictfp\"",
+    "\"super\"",
+    "\"switch\"",
+    "\"synchronized\"",
+    "\"this\"",
+    "\"throw\"",
+    "\"throws\"",
+    "\"transient\"",
+    "\"true\"",
+    "\"try\"",
+    "\"void\"",
+    "\"volatile\"",
+    "\"while\"",
+    "<LONG_LITERAL>",
+    "<INTEGER_LITERAL>",
+    "<DECIMAL_LITERAL>",
+    "<HEX_LITERAL>",
+    "<OCTAL_LITERAL>",
+    "<FLOATING_POINT_LITERAL>",
+    "<DECIMAL_FLOATING_POINT_LITERAL>",
+    "<DECIMAL_EXPONENT>",
+    "<HEXADECIMAL_FLOATING_POINT_LITERAL>",
+    "<HEXADECIMAL_EXPONENT>",
+    "<CHARACTER_LITERAL>",
+    "<STRING_LITERAL>",
+    "<IDENTIFIER>",
+    "<LETTER>",
+    "<PART_LETTER>",
+    "\"(\"",
+    "\")\"",
+    "\"{\"",
+    "\"}\"",
+    "\"[\"",
+    "\"]\"",
+    "\";\"",
+    "\",\"",
+    "\".\"",
+    "\"@\"",
+    "\"=\"",
+    "\"<\"",
+    "\"!\"",
+    "\"~\"",
+    "\"?\"",
+    "\":\"",
+    "\"==\"",
+    "\"<=\"",
+    "\">=\"",
+    "\"!=\"",
+    "\"||\"",
+    "\"&&\"",
+    "\"++\"",
+    "\"--\"",
+    "\"+\"",
+    "\"-\"",
+    "\"*\"",
+    "\"/\"",
+    "\"&\"",
+    "\"|\"",
+    "\"^\"",
+    "\"%\"",
+    "\"<<\"",
+    "\"+=\"",
+    "\"-=\"",
+    "\"*=\"",
+    "\"/=\"",
+    "\"&=\"",
+    "\"|=\"",
+    "\"^=\"",
+    "\"%=\"",
+    "\"<<=\"",
+    "\">>=\"",
+    "\">>>=\"",
+    "\"...\"",
+    "\">>>\"",
+    "\">>\"",
+    "\">\"",
+    "\"\\u001a\"",
+  };
+
+}

parser/html/java/javaparser/src/japa/parser/JavaCharStream.java

@@ -0,0 +1,634 @@
+/* Generated By:JavaCC: Do not edit this line. JavaCharStream.java Version 4.1 */
+/* JavaCCOptions:STATIC=false */
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser;
+
+/**
+ * An implementation of interface CharStream, where the stream is assumed to
+ * contain only ASCII characters (with java-like unicode escape processing).
+ */
+
+public class JavaCharStream
+{
+/** Whether parser is static. */
+  public static final boolean staticFlag = false;
+  static final int hexval(char c) throws java.io.IOException {
+    switch(c)
+    {
+       case '0' :
+          return 0;
+       case '1' :
+          return 1;
+       case '2' :
+          return 2;
+       case '3' :
+          return 3;
+       case '4' :
+          return 4;
+       case '5' :
+          return 5;
+       case '6' :
+          return 6;
+       case '7' :
+          return 7;
+       case '8' :
+          return 8;
+       case '9' :
+          return 9;
+
+       case 'a' :
+       case 'A' :
+          return 10;
+       case 'b' :
+       case 'B' :
+          return 11;
+       case 'c' :
+       case 'C' :
+          return 12;
+       case 'd' :
+       case 'D' :
+          return 13;
+       case 'e' :
+       case 'E' :
+          return 14;
+       case 'f' :
+       case 'F' :
+          return 15;
+    }
+
+    throw new java.io.IOException(); // Should never come here
+  }
+
+/** Position in buffer. */
+  public int bufpos = -1;
+  int bufsize;
+  int available;
+  int tokenBegin;
+  protected int bufline[];
+  protected int bufcolumn[];
+
+  protected int column = 0;
+  protected int line = 1;
+
+  protected boolean prevCharIsCR = false;
+  protected boolean prevCharIsLF = false;
+
+  protected java.io.Reader inputStream;
+
+  protected char[] nextCharBuf;
+  protected char[] buffer;
+  protected int maxNextCharInd = 0;
+  protected int nextCharInd = -1;
+  protected int inBuf = 0;
+  protected int tabSize = 8;
+
+  protected void setTabSize(int i) { tabSize = i; }
+  protected int getTabSize(int i) { return tabSize; }
+
+  protected void ExpandBuff(boolean wrapAround)
+  {
+     char[] newbuffer = new char[bufsize + 2048];
+     int newbufline[] = new int[bufsize + 2048];
+     int newbufcolumn[] = new int[bufsize + 2048];
+
+     try
+     {
+        if (wrapAround)
+        {
+           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+           System.arraycopy(buffer, 0, newbuffer,
+                                             bufsize - tokenBegin, bufpos);
+           buffer = newbuffer;
+
+           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
+           bufline = newbufline;
+
+           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
+           bufcolumn = newbufcolumn;
+
+           bufpos += (bufsize - tokenBegin);
+        }
+        else
+        {
+           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
+           buffer = newbuffer;
+
+           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
+           bufline = newbufline;
+
+           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
+           bufcolumn = newbufcolumn;
+
+           bufpos -= tokenBegin;
+        }
+     }
+     catch (Throwable t)
+     {
+        throw new Error(t.getMessage());
+     }
+
+     available = (bufsize += 2048);
+     tokenBegin = 0;
+  }
+
+  protected void FillBuff() throws java.io.IOException
+  {
+     int i;
+     if (maxNextCharInd == 4096)
+        maxNextCharInd = nextCharInd = 0;
+
+     try {
+        if ((i = inputStream.read(nextCharBuf, maxNextCharInd,
+                                            4096 - maxNextCharInd)) == -1)
+        {
+           inputStream.close();
+           throw new java.io.IOException();
+        }
+        else
+           maxNextCharInd += i;
+        return;
+     }
+     catch(java.io.IOException e) {
+        if (bufpos != 0)
+        {
+           --bufpos;
+           backup(0);
+        }
+        else
+        {
+           bufline[bufpos] = line;
+           bufcolumn[bufpos] = column;
+        }
+        throw e;
+     }
+  }
+
+  protected char ReadByte() throws java.io.IOException
+  {
+     if (++nextCharInd >= maxNextCharInd)
+        FillBuff();
+
+     return nextCharBuf[nextCharInd];
+  }
+
+/** @return starting character for token. */
+  public char BeginToken() throws java.io.IOException
+  {     
+     if (inBuf > 0)
+     {
+        --inBuf;
+
+        if (++bufpos == bufsize)
+           bufpos = 0;
+
+        tokenBegin = bufpos;
+        return buffer[bufpos];
+     }
+
+     tokenBegin = 0;
+     bufpos = -1;
+
+     return readChar();
+  }     
+
+  protected void AdjustBuffSize()
+  {
+     if (available == bufsize)
+     {
+        if (tokenBegin > 2048)
+        {
+           bufpos = 0;
+           available = tokenBegin;
+        }
+        else
+           ExpandBuff(false);
+     }
+     else if (available > tokenBegin)
+        available = bufsize;
+     else if ((tokenBegin - available) < 2048)
+        ExpandBuff(true);
+     else
+        available = tokenBegin;
+  }
+
+  protected void UpdateLineColumn(char c)
+  {
+     column++;
+
+     if (prevCharIsLF)
+     {
+        prevCharIsLF = false;
+        line += (column = 1);
+     }
+     else if (prevCharIsCR)
+     {
+        prevCharIsCR = false;
+        if (c == '\n')
+        {
+           prevCharIsLF = true;
+        }
+        else
+           line += (column = 1);
+     }
+
+     switch (c)
+     {
+        case '\r' :
+           prevCharIsCR = true;
+           break;
+        case '\n' :
+           prevCharIsLF = true;
+           break;
+        case '\t' :
+           column--;
+           column += (tabSize - (column % tabSize));
+           break;
+        default :
+           break;
+     }
+
+     bufline[bufpos] = line;
+     bufcolumn[bufpos] = column;
+  }
+
+/** Read a character. */
+  public char readChar() throws java.io.IOException
+  {
+     if (inBuf > 0)
+     {
+        --inBuf;
+
+        if (++bufpos == bufsize)
+           bufpos = 0;
+
+        return buffer[bufpos];
+     }
+
+     char c;
+
+     if (++bufpos == available)
+        AdjustBuffSize();
+
+     if ((buffer[bufpos] = c = ReadByte()) == '\\')
+     {
+        UpdateLineColumn(c);
+
+        int backSlashCnt = 1;
+
+        for (;;) // Read all the backslashes
+        {
+           if (++bufpos == available)
+              AdjustBuffSize();
+
+           try
+           {
+              if ((buffer[bufpos] = c = ReadByte()) != '\\')
+              {
+                 UpdateLineColumn(c);
+                 // found a non-backslash char.
+                 if ((c == 'u') && ((backSlashCnt & 1) == 1))
+                 {
+                    if (--bufpos < 0)
+                       bufpos = bufsize - 1;
+
+                    break;
+                 }
+
+                 backup(backSlashCnt);
+                 return '\\';
+              }
+           }
+           catch(java.io.IOException e)
+           {
+              if (backSlashCnt > 1)
+                 backup(backSlashCnt-1);
+
+              return '\\';
+           }
+
+           UpdateLineColumn(c);
+           backSlashCnt++;
+        }
+
+        // Here, we have seen an odd number of backslash's followed by a 'u'
+        try
+        {
+           while ((c = ReadByte()) == 'u')
+              ++column;
+
+           buffer[bufpos] = c = (char)(hexval(c) << 12 |
+                                       hexval(ReadByte()) << 8 |
+                                       hexval(ReadByte()) << 4 |
+                                       hexval(ReadByte()));
+
+           column += 4;
+        }
+        catch(java.io.IOException e)
+        {
+           throw new Error("Invalid escape character at line " + line +
+                                         " column " + column + ".");
+        }
+
+        if (backSlashCnt == 1)
+           return c;
+        else
+        {
+           backup(backSlashCnt - 1);
+           return '\\';
+        }
+     }
+     else
+     {
+        UpdateLineColumn(c);
+        return c;
+     }
+  }
+
+  @Deprecated
+  /**
+   * @deprecated 
+   * @see #getEndColumn
+   */
+  public int getColumn() {
+     return bufcolumn[bufpos];
+  }
+
+  @Deprecated
+  /**
+   * @deprecated 
+   * @see #getEndLine
+   */
+  public int getLine() {
+     return bufline[bufpos];
+  }
+
+/** Get end column. */
+  public int getEndColumn() {
+     return bufcolumn[bufpos];
+  }
+
+/** Get end line. */
+  public int getEndLine() {
+     return bufline[bufpos];
+  }
+
+/** @return column of token start */
+  public int getBeginColumn() {
+     return bufcolumn[tokenBegin];
+  }
+
+/** @return line number of token start */
+  public int getBeginLine() {
+     return bufline[tokenBegin];
+  }
+
+/** Retreat. */
+  public void backup(int amount) {
+
+    inBuf += amount;
+    if ((bufpos -= amount) < 0)
+       bufpos += bufsize;
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.Reader dstream,
+                 int startline, int startcolumn, int buffersize)
+  {
+    inputStream = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    available = bufsize = buffersize;
+    buffer = new char[buffersize];
+    bufline = new int[buffersize];
+    bufcolumn = new int[buffersize];
+    nextCharBuf = new char[4096];
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.Reader dstream,
+                                        int startline, int startcolumn)
+  {
+     this(dstream, startline, startcolumn, 4096);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.Reader dstream)
+  {
+     this(dstream, 1, 1, 4096);
+  }
+/** Reinitialise. */
+  public void ReInit(java.io.Reader dstream,
+                 int startline, int startcolumn, int buffersize)
+  {
+    inputStream = dstream;
+    line = startline;
+    column = startcolumn - 1;
+
+    if (buffer == null || buffersize != buffer.length)
+    {
+      available = bufsize = buffersize;
+      buffer = new char[buffersize];
+      bufline = new int[buffersize];
+      bufcolumn = new int[buffersize];
+      nextCharBuf = new char[4096];
+    }
+    prevCharIsLF = prevCharIsCR = false;
+    tokenBegin = inBuf = maxNextCharInd = 0;
+    nextCharInd = bufpos = -1;
+  }
+
+/** Reinitialise. */
+  public void ReInit(java.io.Reader dstream,
+                                        int startline, int startcolumn)
+  {
+     ReInit(dstream, startline, startcolumn, 4096);
+  }
+
+/** Reinitialise. */
+  public void ReInit(java.io.Reader dstream)
+  {
+     ReInit(dstream, 1, 1, 4096);
+  }
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
+  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
+  {
+     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream, int startline,
+  int startcolumn, int buffersize)
+  {
+     this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream, String encoding, int startline,
+                        int startcolumn) throws java.io.UnsupportedEncodingException
+  {
+     this(dstream, encoding, startline, startcolumn, 4096);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream, int startline,
+                        int startcolumn)
+  {
+     this(dstream, startline, startcolumn, 4096);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
+  {
+     this(dstream, encoding, 1, 1, 4096);
+  }
+
+/** Constructor. */
+  public JavaCharStream(java.io.InputStream dstream)
+  {
+     this(dstream, 1, 1, 4096);
+  }
+
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
+  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException
+  {
+     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
+  }
+
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream, int startline,
+  int startcolumn, int buffersize)
+  {
+     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);
+  }
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream, String encoding, int startline,
+                     int startcolumn) throws java.io.UnsupportedEncodingException
+  {
+     ReInit(dstream, encoding, startline, startcolumn, 4096);
+  }
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream, int startline,
+                     int startcolumn)
+  {
+     ReInit(dstream, startline, startcolumn, 4096);
+  }
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException
+  {
+     ReInit(dstream, encoding, 1, 1, 4096);
+  }
+
+/** Reinitialise. */
+  public void ReInit(java.io.InputStream dstream)
+  {
+     ReInit(dstream, 1, 1, 4096);
+  }
+
+  /** @return token image as String */
+  public String GetImage()
+  {
+     if (bufpos >= tokenBegin)
+        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
+     else
+        return new String(buffer, tokenBegin, bufsize - tokenBegin) +
+                              new String(buffer, 0, bufpos + 1);
+  }
+
+  /** @return suffix */
+  public char[] GetSuffix(int len)
+  {
+     char[] ret = new char[len];
+
+     if ((bufpos + 1) >= len)
+        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
+     else
+     {
+        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
+                                                          len - bufpos - 1);
+        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
+     }
+
+     return ret;
+  }
+
+  /** Set buffers back to null when finished. */
+  public void Done()
+  {
+     nextCharBuf = null;
+     buffer = null;
+     bufline = null;
+     bufcolumn = null;
+  }
+
+  /**
+   * Method to adjust line and column numbers for the start of a token.
+   */
+  public void adjustBeginLineColumn(int newLine, int newCol)
+  {
+     int start = tokenBegin;
+     int len;
+
+     if (bufpos >= tokenBegin)
+     {
+        len = bufpos - tokenBegin + inBuf + 1;
+     }
+     else
+     {
+        len = bufsize - tokenBegin + bufpos + 1 + inBuf;
+     }
+
+     int i = 0, j = 0, k = 0;
+     int nextColDiff = 0, columnDiff = 0;
+
+     while (i < len &&
+            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
+     {
+        bufline[j] = newLine;
+        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
+        bufcolumn[j] = newCol + columnDiff;
+        columnDiff = nextColDiff;
+        i++;
+     } 
+
+     if (i < len)
+     {
+        bufline[j] = newLine++;
+        bufcolumn[j] = newCol + columnDiff;
+
+        while (i++ < len)
+        {
+           if (bufline[j = start % bufsize] != bufline[++start % bufsize])
+              bufline[j] = newLine++;
+           else
+              bufline[j] = newLine;
+        }
+     }
+
+     line = bufline[j];
+     column = bufcolumn[j];
+  }
+
+}
+/* JavaCC - OriginalChecksum=46aebc46574be349188fc26719761bcb (do not edit this line) */

parser/html/java/javaparser/src/japa/parser/JavaParser.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ *
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser;
+
+import japa.parser.ast.CompilationUnit;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * <p>This class was generated automatically by javacc, do not edit.</p>
+ * <p>Parse Java 1.5 source code and creates Abstract Syntax Tree classes.</p>
+ * <p><b>Note:</b> To use this parser asynchronously, disable de parser cache
+ * by calling the method {@link setCacheParser} with <code>false</code>
+ * as argument.</p>
+ *
+ * @author Júlio Vilmar Gesser
+ */
+public final class JavaParser {
+
+    private static ASTParser parser;
+
+    private static boolean cacheParser = true;
+
+    private JavaParser() {
+        // hide the constructor
+    }
+
+    /**
+     * Changes the way that the parser acts when starts to parse. If the 
+     * parser cache is enabled, only one insance of this object will be 
+     * used in every call to parse methods.
+     * If this parser is intend to be used asynchonously, the cache must 
+     * be disabled setting this flag to <code>false</code>.
+     * By default, the cache is enabled.
+     * @param value <code>false</code> to disable the parser instance cache. 
+     */
+    public static void setCacheParser(boolean value) {
+        cacheParser = value;
+        if (!value) {
+            parser = null;
+        }
+    }
+
+    /**
+     * Parses the Java code contained in the {@link InputStream} and returns 
+     * a {@link CompilationUnit} that represents it. 
+     * @param in {@link InputStream} containing Java source code
+     * @param encoding encoding of the source code
+     * @return CompilationUnit representing the Java source code
+     * @throws ParseException if the source code has parser errors
+     */
+    public static CompilationUnit parse(InputStream in, String encoding) throws ParseException {
+        if (cacheParser) {
+            if (parser == null) {
+                parser = new ASTParser(in, encoding);
+            } else {
+                parser.reset(in, encoding);
+            }
+            return parser.CompilationUnit();
+        }
+        return new ASTParser(in, encoding).CompilationUnit();
+    }
+
+    /**
+     * Parses the Java code contained in the {@link InputStream} and returns 
+     * a {@link CompilationUnit} that represents it. 
+     * @param in {@link InputStream} containing Java source code
+     * @return CompilationUnit representing the Java source code
+     * @throws ParseException if the source code has parser errors
+     */
+    public static CompilationUnit parse(InputStream in) throws ParseException {
+        return parse(in, null);
+    }
+
+    /**
+     * Parses the Java code contained in a {@link File} and returns 
+     * a {@link CompilationUnit} that represents it. 
+     * @param file {@link File} containing Java source code
+     * @param encoding encoding of the source code
+     * @return CompilationUnit representing the Java source code
+     * @throws ParseException if the source code has parser errors
+     * @throws IOException 
+     */
+    public static CompilationUnit parse(File file, String encoding) throws ParseException, IOException {
+        FileInputStream in = new FileInputStream(file);
+        try {
+            return parse(in, encoding);
+        } finally {
+            in.close();
+        }
+    }
+
+    /**
+     * Parses the Java code contained in a {@link File} and returns 
+     * a {@link CompilationUnit} that represents it. 
+     * @param file {@link File} containing Java source code
+     * @return CompilationUnit representing the Java source code
+     * @throws ParseException if the source code has parser errors
+     * @throws IOException 
+     */
+    public static CompilationUnit parse(File file) throws ParseException, IOException {
+        return parse(file, null);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ParseException.java

@@ -0,0 +1,216 @@
+/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 4.1 */
+/* JavaCCOptions:KEEP_LINE_COL=null */
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser;
+
+/**
+ * This exception is thrown when parse errors are encountered.
+ * You can explicitly create objects of this exception type by
+ * calling the method generateParseException in the generated
+ * parser.
+ *
+ * You can modify this class to customize your error reporting
+ * mechanisms so long as you retain the public fields.
+ */
+public class ParseException extends Exception {
+
+  /**
+   * This constructor is used by the method "generateParseException"
+   * in the generated parser.  Calling this constructor generates
+   * a new object of this type with the fields "currentToken",
+   * "expectedTokenSequences", and "tokenImage" set.  The boolean
+   * flag "specialConstructor" is also set to true to indicate that
+   * this constructor was used to create this object.
+   * This constructor calls its super class with the empty string
+   * to force the "toString" method of parent class "Throwable" to
+   * print the error message in the form:
+   *     ParseException: <result of getMessage>
+   */
+  public ParseException(Token currentTokenVal,
+                        int[][] expectedTokenSequencesVal,
+                        String[] tokenImageVal
+                       )
+  {
+    super("");
+    specialConstructor = true;
+    currentToken = currentTokenVal;
+    expectedTokenSequences = expectedTokenSequencesVal;
+    tokenImage = tokenImageVal;
+  }
+
+  /**
+   * The following constructors are for use by you for whatever
+   * purpose you can think of.  Constructing the exception in this
+   * manner makes the exception behave in the normal way - i.e., as
+   * documented in the class "Throwable".  The fields "errorToken",
+   * "expectedTokenSequences", and "tokenImage" do not contain
+   * relevant information.  The JavaCC generated code does not use
+   * these constructors.
+   */
+
+  public ParseException() {
+    super();
+    specialConstructor = false;
+  }
+
+  /** Constructor with message. */
+  public ParseException(String message) {
+    super(message);
+    specialConstructor = false;
+  }
+
+  /**
+   * This variable determines which constructor was used to create
+   * this object and thereby affects the semantics of the
+   * "getMessage" method (see below).
+   */
+  protected boolean specialConstructor;
+
+  /**
+   * This is the last token that has been consumed successfully.  If
+   * this object has been created due to a parse error, the token
+   * followng this token will (therefore) be the first error token.
+   */
+  public Token currentToken;
+
+  /**
+   * Each entry in this array is an array of integers.  Each array
+   * of integers represents a sequence of tokens (by their ordinal
+   * values) that is expected at this point of the parse.
+   */
+  public int[][] expectedTokenSequences;
+
+  /**
+   * This is a reference to the "tokenImage" array of the generated
+   * parser within which the parse error occurred.  This array is
+   * defined in the generated ...Constants interface.
+   */
+  public String[] tokenImage;
+
+  /**
+   * This method has the standard behavior when this object has been
+   * created using the standard constructors.  Otherwise, it uses
+   * "currentToken" and "expectedTokenSequences" to generate a parse
+   * error message and returns it.  If this object has been created
+   * due to a parse error, and you do not catch it (it gets thrown
+   * from the parser), then this method is called during the printing
+   * of the final stack trace, and hence the correct error message
+   * gets displayed.
+   */
+  public String getMessage() {
+    if (!specialConstructor) {
+      return super.getMessage();
+    }
+    StringBuffer expected = new StringBuffer();
+    int maxSize = 0;
+    for (int i = 0; i < expectedTokenSequences.length; i++) {
+      if (maxSize < expectedTokenSequences[i].length) {
+        maxSize = expectedTokenSequences[i].length;
+      }
+      for (int j = 0; j < expectedTokenSequences[i].length; j++) {
+        expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');
+      }
+      if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {
+        expected.append("...");
+      }
+      expected.append(eol).append("    ");
+    }
+    String retval = "Encountered \"";
+    Token tok = currentToken.next;
+    for (int i = 0; i < maxSize; i++) {
+      if (i != 0) retval += " ";
+      if (tok.kind == 0) {
+        retval += tokenImage[0];
+        break;
+      }
+      retval += " " + tokenImage[tok.kind];
+      retval += " \"";
+      retval += add_escapes(tok.image);
+      retval += " \"";
+      tok = tok.next; 
+    }
+    retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;
+    retval += "." + eol;
+    if (expectedTokenSequences.length == 1) {
+      retval += "Was expecting:" + eol + "    ";
+    } else {
+      retval += "Was expecting one of:" + eol + "    ";
+    }
+    retval += expected.toString();
+    return retval;
+  }
+
+  /**
+   * The end of line string for this machine.
+   */
+  protected String eol = System.getProperty("line.separator", "\n");
+ 
+  /**
+   * Used to convert raw characters to their escaped version
+   * when these raw version cannot be used as part of an ASCII
+   * string literal.
+   */
+  protected String add_escapes(String str) {
+      StringBuffer retval = new StringBuffer();
+      char ch;
+      for (int i = 0; i < str.length(); i++) {
+        switch (str.charAt(i))
+        {
+           case 0 :
+              continue;
+           case '\b':
+              retval.append("\\b");
+              continue;
+           case '\t':
+              retval.append("\\t");
+              continue;
+           case '\n':
+              retval.append("\\n");
+              continue;
+           case '\f':
+              retval.append("\\f");
+              continue;
+           case '\r':
+              retval.append("\\r");
+              continue;
+           case '\"':
+              retval.append("\\\"");
+              continue;
+           case '\'':
+              retval.append("\\\'");
+              continue;
+           case '\\':
+              retval.append("\\\\");
+              continue;
+           default:
+              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+                 String s = "0000" + Integer.toString(ch, 16);
+                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+              } else {
+                 retval.append(ch);
+              }
+              continue;
+        }
+      }
+      return retval.toString();
+   }
+
+}
+/* JavaCC - OriginalChecksum=1164e36971d84a0433c5f702fcb960dd (do not edit this line) */

parser/html/java/javaparser/src/japa/parser/Token.java

@@ -0,0 +1,142 @@
+/* Generated By:JavaCC: Do not edit this line. Token.java Version 4.1 */
+/* JavaCCOptions:TOKEN_EXTENDS=,KEEP_LINE_COL=null */
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser;
+
+/**
+ * Describes the input token stream.
+ */
+
+public class Token {
+
+  /**
+   * An integer that describes the kind of this token.  This numbering
+   * system is determined by JavaCCParser, and a table of these numbers is
+   * stored in the file ...Constants.java.
+   */
+  public int kind;
+
+  /** The line number of the first character of this Token. */
+  public int beginLine;
+  /** The column number of the first character of this Token. */
+  public int beginColumn;
+  /** The line number of the last character of this Token. */
+  public int endLine;
+  /** The column number of the last character of this Token. */
+  public int endColumn;
+
+  /**
+   * The string image of the token.
+   */
+  public String image;
+
+  /**
+   * A reference to the next regular (non-special) token from the input
+   * stream.  If this is the last token from the input stream, or if the
+   * token manager has not read tokens beyond this one, this field is
+   * set to null.  This is true only if this token is also a regular
+   * token.  Otherwise, see below for a description of the contents of
+   * this field.
+   */
+  public Token next;
+
+  /**
+   * This field is used to access special tokens that occur prior to this
+   * token, but after the immediately preceding regular (non-special) token.
+   * If there are no such special tokens, this field is set to null.
+   * When there are more than one such special token, this field refers
+   * to the last of these special tokens, which in turn refers to the next
+   * previous special token through its specialToken field, and so on
+   * until the first special token (whose specialToken field is null).
+   * The next fields of special tokens refer to other special tokens that
+   * immediately follow it (without an intervening regular token).  If there
+   * is no such token, this field is null.
+   */
+  public Token specialToken;
+
+  /**
+   * An optional attribute value of the Token.
+   * Tokens which are not used as syntactic sugar will often contain
+   * meaningful values that will be used later on by the compiler or
+   * interpreter. This attribute value is often different from the image.
+   * Any subclass of Token that actually wants to return a non-null value can
+   * override this method as appropriate.
+   */
+  public Object getValue() {
+    return null;
+  }
+
+  /**
+   * No-argument constructor
+   */
+  public Token() {}
+
+  /**
+   * Constructs a new token for the specified Image.
+   */
+  public Token(int kind)
+  {
+     this(kind, null);
+  }
+
+  /**
+   * Constructs a new token for the specified Image and Kind.
+   */
+  public Token(int kind, String image)
+  {
+     this.kind = kind;
+     this.image = image;
+  }
+
+  /**
+   * Returns the image.
+   */
+  public String toString()
+  {
+     return image;
+  }
+
+  /**
+   * Returns a new Token object, by default. However, if you want, you
+   * can create and return subclass objects based on the value of ofKind.
+   * Simply add the cases to the switch for all those special cases.
+   * For example, if you have a subclass of Token called IDToken that
+   * you want to create if ofKind is ID, simply add something like :
+   *
+   *    case MyParserConstants.ID : return new IDToken(ofKind, image);
+   *
+   * to the following switch statement. Then you can cast matchedToken
+   * variable to the appropriate type and use sit in your lexical actions.
+   */
+  public static Token newToken(int ofKind, String image)
+  {
+     switch(ofKind)
+     {
+       default : return new Token(ofKind, image);
+     }
+  }
+
+  public static Token newToken(int ofKind)
+  {
+     return newToken(ofKind, null);
+  }
+
+}
+/* JavaCC - OriginalChecksum=36e116391da53a8cb5fc7d23289ae0c7 (do not edit this line) */

parser/html/java/javaparser/src/japa/parser/TokenMgrError.java

@@ -0,0 +1,159 @@
+/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 4.1 */
+/* JavaCCOptions: */
+/*
+ * Copyright (C) 2008 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser;
+
+/** Token Manager Error. */
+@SuppressWarnings("serial")
+public class TokenMgrError extends Error
+{
+
+   /*
+    * Ordinals for various reasons why an Error of this type can be thrown.
+    */
+
+   /**
+    * Lexical error occurred.
+    */
+   static final int LEXICAL_ERROR = 0;
+
+   /**
+    * An attempt was made to create a second instance of a static token manager.
+    */
+   static final int STATIC_LEXER_ERROR = 1;
+
+   /**
+    * Tried to change to an invalid lexical state.
+    */
+   static final int INVALID_LEXICAL_STATE = 2;
+
+   /**
+    * Detected (and bailed out of) an infinite loop in the token manager.
+    */
+   static final int LOOP_DETECTED = 3;
+
+   /**
+    * Indicates the reason why the exception is thrown. It will have
+    * one of the above 4 values.
+    */
+   int errorCode;
+
+   /**
+    * Replaces unprintable characters by their escaped (or unicode escaped)
+    * equivalents in the given string
+    */
+   protected static final String addEscapes(String str) {
+      StringBuffer retval = new StringBuffer();
+      char ch;
+      for (int i = 0; i < str.length(); i++) {
+        switch (str.charAt(i))
+        {
+           case 0 :
+              continue;
+           case '\b':
+              retval.append("\\b");
+              continue;
+           case '\t':
+              retval.append("\\t");
+              continue;
+           case '\n':
+              retval.append("\\n");
+              continue;
+           case '\f':
+              retval.append("\\f");
+              continue;
+           case '\r':
+              retval.append("\\r");
+              continue;
+           case '\"':
+              retval.append("\\\"");
+              continue;
+           case '\'':
+              retval.append("\\\'");
+              continue;
+           case '\\':
+              retval.append("\\\\");
+              continue;
+           default:
+              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
+                 String s = "0000" + Integer.toString(ch, 16);
+                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
+              } else {
+                 retval.append(ch);
+              }
+              continue;
+        }
+      }
+      return retval.toString();
+   }
+
+   /**
+    * Returns a detailed message for the Error when it is thrown by the
+    * token manager to indicate a lexical error.
+    * Parameters : 
+    *    EOFSeen     : indicates if EOF caused the lexical error
+    *    curLexState : lexical state in which this error occurred
+    *    errorLine   : line number when the error occurred
+    *    errorColumn : column number when the error occurred
+    *    errorAfter  : prefix that was seen before this error occurred
+    *    curchar     : the offending character
+    * Note: You can customize the lexical error message by modifying this method.
+    */
+   protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {
+      return("Lexical error at line " +
+           errorLine + ", column " +
+           errorColumn + ".  Encountered: " +
+           (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +
+           "after : \"" + addEscapes(errorAfter) + "\"");
+   }
+
+   /**
+    * You can also modify the body of this method to customize your error messages.
+    * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+    * of end-users concern, so you can return something like : 
+    *
+    *     "Internal Error : Please file a bug report .... "
+    *
+    * from this method for such cases in the release version of your parser.
+    */
+   public String getMessage() {
+      return super.getMessage();
+   }
+
+   /*
+    * Constructors of various flavors follow.
+    */
+
+   /** No arg constructor. */
+   public TokenMgrError() {
+   }
+
+   /** Constructor with message and reason. */
+   public TokenMgrError(String message, int reason) {
+      super(message);
+      errorCode = reason;
+   }
+
+   /** Full Constructor. */
+   public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {
+      this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);
+   }
+}
+/* JavaCC - OriginalChecksum=c0bde2b885c772c9db66b8a6b4f07329 (do not edit this line) */

parser/html/java/javaparser/src/japa/parser/ast/BlockComment.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 23/05/2008
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * <p>
+ * AST node that represent block comments.
+ * </p>
+ * Block comments can has multi lines and are delimited by "/&#42;" and
+ * "&#42;/".
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class BlockComment extends Comment {
+
+    public BlockComment() {
+    }
+
+    public BlockComment(String content) {
+        super(content);
+    }
+
+    public BlockComment(int beginLine, int beginColumn, int endLine, int endColumn, String content) {
+        super(beginLine, beginColumn, endLine, endColumn, content);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/Comment.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 23/05/2008
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.body.JavadocComment;
+
+/**
+ * Abstract class for all AST nodes that represent comments.
+ * 
+ * @see BlockComment
+ * @see LineComment
+ * @see JavadocComment
+ * @author Julio Vilmar Gesser
+ */
+public abstract class Comment extends Node {
+
+    private String content;
+
+    public Comment() {
+    }
+
+    public Comment(String content) {
+        this.content = content;
+    }
+
+    public Comment(int beginLine, int beginColumn, int endLine, int endColumn, String content) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.content = content;
+    }
+
+    /**
+     * Return the text of the comment.
+     * 
+     * @return text of the comment
+     */
+    public final String getContent() {
+        return content;
+    }
+
+    /**
+     * Sets the text of the comment.
+     * 
+     * @param content
+     *            the text of the comment to set
+     */
+    public void setContent(String content) {
+        this.content = content;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/CompilationUnit.java

@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.body.AnnotationDeclaration;
+import japa.parser.ast.body.ClassOrInterfaceDeclaration;
+import japa.parser.ast.body.EmptyTypeDeclaration;
+import japa.parser.ast.body.EnumDeclaration;
+import japa.parser.ast.body.JavadocComment;
+import japa.parser.ast.body.TypeDeclaration;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * <p>
+ * This class represents the entire compilation unit. Each java file denotes a
+ * compilation unit.
+ * </p>
+ * The CompilationUnit is constructed following the syntax:<br>
+ * <code>
+ * <table>
+ * <tr valign=baseline>
+ *   <td align=right>CompilationUnit</td>
+ *   <td align=center>::=</td>
+ *   <td align=left>
+ *   ( {@link PackageDeclaration} )?<br> 
+ *   ( {@link ImportDeclaration} )*<br>
+ *   ( {@link TypeDeclaration} )*<br>
+ *   </td>
+ * </tr>
+ * </table> 
+ * </code>
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class CompilationUnit extends Node {
+
+    private PackageDeclaration pakage;
+
+    private List<ImportDeclaration> imports;
+
+    private List<TypeDeclaration> types;
+
+    private List<Comment> comments;
+
+    public CompilationUnit() {
+    }
+
+    public CompilationUnit(PackageDeclaration pakage, List<ImportDeclaration> imports, List<TypeDeclaration> types, List<Comment> comments) {
+        this.pakage = pakage;
+        this.imports = imports;
+        this.types = types;
+        this.comments = comments;
+    }
+
+    public CompilationUnit(int beginLine, int beginColumn, int endLine, int endColumn, PackageDeclaration pakage, List<ImportDeclaration> imports, List<TypeDeclaration> types, List<Comment> comments) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.pakage = pakage;
+        this.imports = imports;
+        this.types = types;
+        this.comments = comments;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    /**
+     * Return a list containing all comments declared in this compilation unit.
+     * Including javadocs, line comments and block comments of all types,
+     * inner-classes and other members.<br>
+     * If there is no comment, <code>null</code> is returned.
+     * 
+     * @return list with all comments of this compilation unit or
+     *         <code>null</code>
+     * @see JavadocComment
+     * @see LineComment
+     * @see BlockComment
+     */
+    public List<Comment> getComments() {
+        return comments;
+    }
+
+    /**
+     * Retrieves the list of imports declared in this compilation unit or
+     * <code>null</code> if there is no import.
+     * 
+     * @return the list of imports or <code>null</code> if there is no import
+     */
+    public List<ImportDeclaration> getImports() {
+        return imports;
+    }
+
+    /**
+     * Retrieves the package declaration of this compilation unit.<br>
+     * If this compilation unit has no package declaration (default package),
+     * <code>null</code> is returned.
+     * 
+     * @return the package declaration or <code>null</code>
+     */
+    public PackageDeclaration getPackage() {
+        return pakage;
+    }
+
+    /**
+     * Return the list of types declared in this compilation unit.<br>
+     * If there is no types declared, <code>null</code> is returned.
+     * 
+     * @return the list of types or <code>null</code> null if there is no type
+     * @see AnnotationDeclaration
+     * @see ClassOrInterfaceDeclaration
+     * @see EmptyTypeDeclaration
+     * @see EnumDeclaration
+     */
+    public List<TypeDeclaration> getTypes() {
+        return types;
+    }
+
+    /**
+     * Sets the list of comments of this compilation unit.
+     * 
+     * @param comments
+     *            the list of comments
+     */
+    public void setComments(List<Comment> comments) {
+        this.comments = comments;
+    }
+
+    /**
+     * Sets the list of imports of this compilation unit. The list is initially
+     * <code>null</code>.
+     * 
+     * @param imports
+     *            the list of imports
+     */
+    public void setImports(List<ImportDeclaration> imports) {
+        this.imports = imports;
+    }
+
+    /**
+     * Sets or clear the package declarations of this compilation unit.
+     * 
+     * @param pakage
+     *            the pakage declaration to set or <code>null</code> to default
+     *            package
+     */
+    public void setPackage(PackageDeclaration pakage) {
+        this.pakage = pakage;
+    }
+
+    /**
+     * Sets the list of types declared in this compilation unit.
+     * 
+     * @param types
+     *            the lis of types
+     */
+    public void setTypes(List<TypeDeclaration> types) {
+        this.types = types;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/ImportDeclaration.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.expr.NameExpr;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * <p>
+ * This class represents a import declaration. Imports are optional for the
+ * {@link CompilationUnit}.
+ * </p>
+ * The ImportDeclaration is constructed following the syntax:<br>
+ * <code>
+ * <table>
+ * <tr valign=baseline>
+ *   <td align=right>ImportDeclaration</td>
+ *   <td align=center>::=</td>
+ *   <td align=left>
+ *       "import" ( "static" )? {@link NameExpr} ( "." "*" )? ";"
+ *   </td>
+ * </tr>
+ * </table> 
+ * </code>
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class ImportDeclaration extends Node {
+
+    private NameExpr name;
+
+    private boolean static_;
+
+    private boolean asterisk;
+
+    public ImportDeclaration() {
+    }
+
+    public ImportDeclaration(NameExpr name, boolean isStatic, boolean isAsterisk) {
+        this.name = name;
+        this.static_ = isStatic;
+        this.asterisk = isAsterisk;
+    }
+
+    public ImportDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, NameExpr name, boolean isStatic, boolean isAsterisk) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.static_ = isStatic;
+        this.asterisk = isAsterisk;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    /**
+     * Retrieves the name of the import.
+     * 
+     * @return the name of the import
+     */
+    public NameExpr getName() {
+        return name;
+    }
+
+    /**
+     * Return if the import ends with "*".
+     * 
+     * @return <code>true</code> if the import ends with "*", <code>false</code>
+     *         otherwise
+     */
+    public boolean isAsterisk() {
+        return asterisk;
+    }
+
+    /**
+     * Return if the import is static.
+     * 
+     * @return <code>true</code> if the import is static, <code>false</code>
+     *         otherwise
+     */
+    public boolean isStatic() {
+        return static_;
+    }
+
+    /**
+     * Sets if this import is asterisk.
+     * 
+     * @param asterisk
+     *            <code>true</code> if this import is asterisk
+     */
+    public void setAsterisk(boolean asterisk) {
+        this.asterisk = asterisk;
+    }
+
+    /**
+     * Sets the name this import.
+     * 
+     * @param name
+     *            the name to set
+     */
+    public void setName(NameExpr name) {
+        this.name = name;
+    }
+
+    /**
+     * Sets if this import is static.
+     * 
+     * @param static_
+     *            <code>true</code> if this import is static
+     */
+    public void setStatic(boolean static_) {
+        this.static_ = static_;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/LineComment.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 23/05/2008
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * <p>
+ * AST node that represent line comments.
+ * </p>
+ * Line comments are started with "//" and finish at the end of the line ("\n").
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class LineComment extends Comment {
+
+    public LineComment() {
+    }
+
+    public LineComment(String content) {
+        super(content);
+    }
+
+    public LineComment(int beginLine, int beginColumn, int endLine, int endColumn, String content) {
+        super(beginLine, beginColumn, endLine, endColumn, content);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/Node.java

@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ *
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.visitor.DumpVisitor;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * Abstract class for all nodes of the AST.
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public abstract class Node {
+
+    private int beginLine;
+
+    private int beginColumn;
+
+    private int endLine;
+
+    private int endColumn;
+
+    /**
+     * This attribute can store additional information from semantic analysis.
+     */
+    private Object data;
+
+    public Node() {
+    }
+
+    public Node(int beginLine, int beginColumn, int endLine, int endColumn) {
+        this.beginLine = beginLine;
+        this.beginColumn = beginColumn;
+        this.endLine = endLine;
+        this.endColumn = endColumn;
+    }
+
+    /**
+     * Accept method for visitor support.
+     * 
+     * @param <R>
+     *            the type the return value of the visitor
+     * @param <A>
+     *            the type the argument passed for the visitor
+     * @param v
+     *            the visitor implementation
+     * @param arg
+     *            any value relevant for the visitor
+     * @return the result of the visit
+     */
+    public abstract <R, A> R accept(GenericVisitor<R, A> v, A arg);
+
+    /**
+     * Accept method for visitor support.
+     * 
+     * @param <A>
+     *            the type the argument passed for the visitor
+     * @param v
+     *            the visitor implementation
+     * @param arg
+     *            any value relevant for the visitor
+     */
+    public abstract <A> void accept(VoidVisitor<A> v, A arg);
+
+    /**
+     * Return the begin column of this node.
+     * 
+     * @return the begin column of this node
+     */
+    public final int getBeginColumn() {
+        return beginColumn;
+    }
+
+    /**
+     * Return the begin line of this node.
+     * 
+     * @return the begin line of this node
+     */
+    public final int getBeginLine() {
+        return beginLine;
+    }
+
+    /**
+     * Use this to retrieve additional information associated to this node.
+     */
+    public final Object getData() {
+        return data;
+    }
+
+    /**
+     * Return the end column of this node.
+     * 
+     * @return the end column of this node
+     */
+    public final int getEndColumn() {
+        return endColumn;
+    }
+
+    /**
+     * Return the end line of this node.
+     * 
+     * @return the end line of this node
+     */
+    public final int getEndLine() {
+        return endLine;
+    }
+
+    /**
+     * Sets the begin column of this node.
+     * 
+     * @param beginColumn
+     *            the begin column of this node
+     */
+    public final void setBeginColumn(int beginColumn) {
+        this.beginColumn = beginColumn;
+    }
+
+    /**
+     * Sets the begin line of this node.
+     * 
+     * @param beginLine
+     *            the begin line of this node
+     */
+    public final void setBeginLine(int beginLine) {
+        this.beginLine = beginLine;
+    }
+
+    /**
+     * Use this to store additional information to this node.
+     */
+    public final void setData(Object data) {
+        this.data = data;
+    }
+
+    /**
+     * Sets the end column of this node.
+     * 
+     * @param endColumn
+     *            the end column of this node
+     */
+    public final void setEndColumn(int endColumn) {
+        this.endColumn = endColumn;
+    }
+
+    /**
+     * Sets the end line of this node.
+     * 
+     * @param endLine
+     *            the end line of this node
+     */
+    public final void setEndLine(int endLine) {
+        this.endLine = endLine;
+    }
+
+    /**
+     * Return the String representation of this node.
+     * 
+     * @return the String representation of this node
+     */
+    @Override
+    public final String toString() {
+        DumpVisitor visitor = new DumpVisitor();
+        accept(visitor, null);
+        return visitor.getSource();
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/PackageDeclaration.java

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 17/10/2007
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.expr.NameExpr;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * <p>
+ * This class represents the package declaration. The package declaration is
+ * optional for the {@link CompilationUnit}.
+ * </p>
+ * The PackageDeclaration is constructed following the syntax:<br>
+ * <code>
+ * <table>
+ * <tr valign=baseline>
+ *   <td align=right>PackageDeclaration</td>
+ *   <td align=center>::=</td>
+ *   <td align=left>
+ *       ( {@link AnnotationExpr} )* "package" {@link NameExpr} ) ";"
+ *   </td>
+ * </tr>
+ * </table> 
+ * </code>
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class PackageDeclaration extends Node {
+
+    private List<AnnotationExpr> annotations;
+
+    private NameExpr name;
+
+    public PackageDeclaration() {
+    }
+
+    public PackageDeclaration(NameExpr name) {
+        this.name = name;
+    }
+
+    public PackageDeclaration(List<AnnotationExpr> annotations, NameExpr name) {
+        this.annotations = annotations;
+        this.name = name;
+    }
+
+    public PackageDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, List<AnnotationExpr> annotations, NameExpr name) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.annotations = annotations;
+        this.name = name;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    /**
+     * Retrieves the list of annotations declared before the package
+     * declaration. Return <code>null</code> if there are no annotations.
+     * 
+     * @return list of annotations or <code>null</code>
+     */
+    public List<AnnotationExpr> getAnnotations() {
+        return annotations;
+    }
+
+    /**
+     * Return the name of the package.
+     * 
+     * @return the name of the package
+     */
+    public NameExpr getName() {
+        return name;
+    }
+
+    /**
+     * @param annotations
+     *            the annotations to set
+     */
+    public void setAnnotations(List<AnnotationExpr> annotations) {
+        this.annotations = annotations;
+    }
+
+    /**
+     * Sets the name of this package declaration.
+     * 
+     * @param name
+     *            the name to set
+     */
+    public void setName(NameExpr name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/TypeParameter.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast;
+
+import japa.parser.ast.type.ClassOrInterfaceType;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * <p>
+ * This class represents the declaration of a genetics argument.
+ * </p>
+ * The TypeParameter is constructed following the syntax:<br>
+ * <code>
+ * <table>
+ * <tr valign=baseline>
+ *   <td align=right>TypeParameter</td>
+ *   <td align=center>::=</td>
+ *   <td align=left>
+ *       &lt;IDENTIFIER&gt; ( "extends" {@link ClassOrInterfaceType} ( "&" {@link ClassOrInterfaceType} )* )?
+ *   </td>
+ * </tr>
+ * </table> 
+ * </code>
+ * 
+ * @author Julio Vilmar Gesser
+ */
+public final class TypeParameter extends Node {
+
+    private String name;
+
+    private List<ClassOrInterfaceType> typeBound;
+
+    public TypeParameter() {
+    }
+
+    public TypeParameter(String name, List<ClassOrInterfaceType> typeBound) {
+        this.name = name;
+        this.typeBound = typeBound;
+    }
+
+    public TypeParameter(int beginLine, int beginColumn, int endLine, int endColumn, String name, List<ClassOrInterfaceType> typeBound) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.typeBound = typeBound;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    /**
+     * Return the name of the paramenter.
+     * 
+     * @return the name of the paramenter
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Return the list of {@link ClassOrInterfaceType} that this parameter
+     * extends. Return <code>null</code> null if there are no type.
+     * 
+     * @return list of types that this paramente extends or <code>null</code>
+     */
+    public List<ClassOrInterfaceType> getTypeBound() {
+        return typeBound;
+    }
+
+    /**
+     * Sets the name of this type parameter.
+     * 
+     * @param name
+     *            the name to set
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Sets the list o types.
+     * 
+     * @param typeBound
+     *            the typeBound to set
+     */
+    public void setTypeBound(List<ClassOrInterfaceType> typeBound) {
+        this.typeBound = typeBound;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/body/AnnotationDeclaration.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class AnnotationDeclaration extends TypeDeclaration {
+
+    public AnnotationDeclaration() {
+    }
+
+    public AnnotationDeclaration(int modifiers, String name) {
+        super(modifiers, name);
+    }
+
+    public AnnotationDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, String name, List<BodyDeclaration> members) {
+        super(annotations, javaDoc, modifiers, name, members);
+    }
+
+    public AnnotationDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, String name, List<BodyDeclaration> members) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc, modifiers, name, members);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/body/AnnotationMemberDeclaration.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class AnnotationMemberDeclaration extends BodyDeclaration {
+
+    private int modifiers;
+
+    private Type type;
+
+    private String name;
+
+    private Expression defaultValue;
+
+    public AnnotationMemberDeclaration() {
+    }
+
+    public AnnotationMemberDeclaration(int modifiers, Type type, String name, Expression defaultValue) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.name = name;
+        this.defaultValue = defaultValue;
+    }
+
+    public AnnotationMemberDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, Type type, String name, Expression defaultValue) {
+        super(annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.type = type;
+        this.name = name;
+        this.defaultValue = defaultValue;
+    }
+
+    public AnnotationMemberDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, Type type, String name, Expression defaultValue) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.type = type;
+        this.name = name;
+        this.defaultValue = defaultValue;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getDefaultValue() {
+        return defaultValue;
+    }
+
+    /**
+     * Return the modifiers of this member declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setDefaultValue(Expression defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/BodyDeclaration.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.expr.AnnotationExpr;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class BodyDeclaration extends Node {
+
+    private JavadocComment javaDoc;
+
+    private List<AnnotationExpr> annotations;
+
+    public BodyDeclaration() {
+    }
+
+    public BodyDeclaration(List<AnnotationExpr> annotations, JavadocComment javaDoc) {
+        this.javaDoc = javaDoc;
+        this.annotations = annotations;
+    }
+
+    public BodyDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, List<AnnotationExpr> annotations, JavadocComment javaDoc) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.javaDoc = javaDoc;
+        this.annotations = annotations;
+    }
+
+    public final JavadocComment getJavaDoc() {
+        return javaDoc;
+    }
+
+    public final List<AnnotationExpr> getAnnotations() {
+        return annotations;
+    }
+
+    public final void setJavaDoc(JavadocComment javaDoc) {
+        this.javaDoc = javaDoc;
+    }
+
+    public final void setAnnotations(List<AnnotationExpr> annotations) {
+        this.annotations = annotations;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/body/ClassOrInterfaceDeclaration.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.TypeParameter;
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.type.ClassOrInterfaceType;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ClassOrInterfaceDeclaration extends TypeDeclaration {
+
+    private boolean interface_;
+
+    private List<TypeParameter> typeParameters;
+
+    private List<ClassOrInterfaceType> extendsList;
+
+    private List<ClassOrInterfaceType> implementsList;
+
+    public ClassOrInterfaceDeclaration() {
+    }
+
+    public ClassOrInterfaceDeclaration(int modifiers, boolean isInterface, String name) {
+        super(modifiers, name);
+        this.interface_ = isInterface;
+    }
+
+    public ClassOrInterfaceDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, boolean isInterface, String name, List<TypeParameter> typeParameters, List<ClassOrInterfaceType> extendsList, List<ClassOrInterfaceType> implementsList, List<BodyDeclaration> members) {
+        super(annotations, javaDoc, modifiers, name, members);
+        this.interface_ = isInterface;
+        this.typeParameters = typeParameters;
+        this.extendsList = extendsList;
+        this.implementsList = implementsList;
+    }
+
+    public ClassOrInterfaceDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, boolean isInterface, String name, List<TypeParameter> typeParameters, List<ClassOrInterfaceType> extendsList, List<ClassOrInterfaceType> implementsList, List<BodyDeclaration> members) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc, modifiers, name, members);
+        this.interface_ = isInterface;
+        this.typeParameters = typeParameters;
+        this.extendsList = extendsList;
+        this.implementsList = implementsList;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<ClassOrInterfaceType> getExtends() {
+        return extendsList;
+    }
+
+    public List<ClassOrInterfaceType> getImplements() {
+        return implementsList;
+    }
+
+    public List<TypeParameter> getTypeParameters() {
+        return typeParameters;
+    }
+
+    public boolean isInterface() {
+        return interface_;
+    }
+
+    public void setExtends(List<ClassOrInterfaceType> extendsList) {
+        this.extendsList = extendsList;
+    }
+
+    public void setImplements(List<ClassOrInterfaceType> implementsList) {
+        this.implementsList = implementsList;
+    }
+
+    public void setInterface(boolean interface_) {
+        this.interface_ = interface_;
+    }
+
+    public void setTypeParameters(List<TypeParameter> typeParameters) {
+        this.typeParameters = typeParameters;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/ConstructorDeclaration.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.TypeParameter;
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.expr.NameExpr;
+import japa.parser.ast.stmt.BlockStmt;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ConstructorDeclaration extends BodyDeclaration {
+
+    private int modifiers;
+
+    private List<TypeParameter> typeParameters;
+
+    private String name;
+
+    private List<Parameter> parameters;
+
+    private List<NameExpr> throws_;
+
+    private BlockStmt block;
+
+    public ConstructorDeclaration() {
+    }
+
+    public ConstructorDeclaration(int modifiers, String name) {
+        this.modifiers = modifiers;
+        this.name = name;
+    }
+
+    public ConstructorDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, String name, List<Parameter> parameters, List<NameExpr> throws_, BlockStmt block) {
+        super(annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.typeParameters = typeParameters;
+        this.name = name;
+        this.parameters = parameters;
+        this.throws_ = throws_;
+        this.block = block;
+    }
+
+    public ConstructorDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, String name, List<Parameter> parameters, List<NameExpr> throws_, BlockStmt block) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.typeParameters = typeParameters;
+        this.name = name;
+        this.parameters = parameters;
+        this.throws_ = throws_;
+        this.block = block;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public BlockStmt getBlock() {
+        return block;
+    }
+
+    /**
+     * Return the modifiers of this member declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Parameter> getParameters() {
+        return parameters;
+    }
+
+    public List<NameExpr> getThrows() {
+        return throws_;
+    }
+
+    public List<TypeParameter> getTypeParameters() {
+        return typeParameters;
+    }
+
+    public void setBlock(BlockStmt block) {
+        this.block = block;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setParameters(List<Parameter> parameters) {
+        this.parameters = parameters;
+    }
+
+    public void setThrows(List<NameExpr> throws_) {
+        this.throws_ = throws_;
+    }
+
+    public void setTypeParameters(List<TypeParameter> typeParameters) {
+        this.typeParameters = typeParameters;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/EmptyMemberDeclaration.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EmptyMemberDeclaration extends BodyDeclaration {
+
+    public EmptyMemberDeclaration() {
+    }
+
+    public EmptyMemberDeclaration(JavadocComment javaDoc) {
+        super(null, javaDoc);
+    }
+
+    public EmptyMemberDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc) {
+        super(beginLine, beginColumn, endLine, endColumn, null, javaDoc);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/EmptyTypeDeclaration.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 20/01/2007
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EmptyTypeDeclaration extends TypeDeclaration {
+
+    public EmptyTypeDeclaration() {
+    }
+
+    public EmptyTypeDeclaration(JavadocComment javaDoc) {
+        super(null, javaDoc, 0, null, null);
+    }
+
+    public EmptyTypeDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc) {
+        super(beginLine, beginColumn, endLine, endColumn, null, javaDoc, 0, null, null);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/EnumConstantDeclaration.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EnumConstantDeclaration extends BodyDeclaration {
+
+    private String name;
+
+    private List<Expression> args;
+
+    private List<BodyDeclaration> classBody;
+
+    public EnumConstantDeclaration() {
+    }
+
+    public EnumConstantDeclaration(String name) {
+        this.name = name;
+    }
+
+    public EnumConstantDeclaration(JavadocComment javaDoc, List<AnnotationExpr> annotations, String name, List<Expression> args, List<BodyDeclaration> classBody) {
+        super(annotations, javaDoc);
+        this.name = name;
+        this.args = args;
+        this.classBody = classBody;
+    }
+
+    public EnumConstantDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, List<AnnotationExpr> annotations, String name, List<Expression> args, List<BodyDeclaration> classBody) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.name = name;
+        this.args = args;
+        this.classBody = classBody;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<Expression> getArgs() {
+        return args;
+    }
+
+    public List<BodyDeclaration> getClassBody() {
+        return classBody;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setArgs(List<Expression> args) {
+        this.args = args;
+    }
+
+    public void setClassBody(List<BodyDeclaration> classBody) {
+        this.classBody = classBody;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/EnumDeclaration.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.type.ClassOrInterfaceType;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EnumDeclaration extends TypeDeclaration {
+
+    private List<ClassOrInterfaceType> implementsList;
+
+    private List<EnumConstantDeclaration> entries;
+
+    public EnumDeclaration() {
+    }
+
+    public EnumDeclaration(int modifiers, String name) {
+        super(modifiers, name);
+    }
+
+    public EnumDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, String name, List<ClassOrInterfaceType> implementsList, List<EnumConstantDeclaration> entries, List<BodyDeclaration> members) {
+        super(annotations, javaDoc, modifiers, name, members);
+        this.implementsList = implementsList;
+        this.entries = entries;
+    }
+
+    public EnumDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, String name, List<ClassOrInterfaceType> implementsList, List<EnumConstantDeclaration> entries, List<BodyDeclaration> members) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc, modifiers, name, members);
+        this.implementsList = implementsList;
+        this.entries = entries;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<EnumConstantDeclaration> getEntries() {
+        return entries;
+    }
+
+    public List<ClassOrInterfaceType> getImplements() {
+        return implementsList;
+    }
+
+    public void setEntries(List<EnumConstantDeclaration> entries) {
+        this.entries = entries;
+    }
+
+    public void setImplements(List<ClassOrInterfaceType> implementsList) {
+        this.implementsList = implementsList;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/FieldDeclaration.java

@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class FieldDeclaration extends BodyDeclaration {
+
+    private int modifiers;
+
+    private Type type;
+
+    private List<VariableDeclarator> variables;
+
+    public FieldDeclaration() {
+    }
+
+    public FieldDeclaration(int modifiers, Type type, VariableDeclarator variable) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.variables = new ArrayList<VariableDeclarator>();
+        this.variables.add(variable);
+    }
+
+    public FieldDeclaration(int modifiers, Type type, List<VariableDeclarator> variables) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.variables = variables;
+    }
+
+    public FieldDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, Type type, List<VariableDeclarator> variables) {
+        super(annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.type = type;
+        this.variables = variables;
+    }
+
+    public FieldDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, Type type, List<VariableDeclarator> variables) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.type = type;
+        this.variables = variables;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    /**
+     * Return the modifiers of this member declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public List<VariableDeclarator> getVariables() {
+        return variables;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public void setVariables(List<VariableDeclarator> variables) {
+        this.variables = variables;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/InitializerDeclaration.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.stmt.BlockStmt;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class InitializerDeclaration extends BodyDeclaration {
+
+    private boolean isStatic;
+
+    private BlockStmt block;
+
+    public InitializerDeclaration() {
+    }
+
+    public InitializerDeclaration(boolean isStatic, BlockStmt block) {
+        this.isStatic = isStatic;
+        this.block = block;
+    }
+
+    public InitializerDeclaration(JavadocComment javaDoc, boolean isStatic, BlockStmt block) {
+        super(null, javaDoc);
+        this.isStatic = isStatic;
+        this.block = block;
+    }
+
+    public InitializerDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, boolean isStatic, BlockStmt block) {
+        super(beginLine, beginColumn, endLine, endColumn, null, javaDoc);
+        this.isStatic = isStatic;
+        this.block = block;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public BlockStmt getBlock() {
+        return block;
+    }
+
+    public boolean isStatic() {
+        return isStatic;
+    }
+
+    public void setBlock(BlockStmt block) {
+        this.block = block;
+    }
+
+    public void setStatic(boolean isStatic) {
+        this.isStatic = isStatic;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/JavadocComment.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 23/05/2008
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.Comment;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class JavadocComment extends Comment {
+
+    public JavadocComment() {
+    }
+
+    public JavadocComment(String content) {
+        super(content);
+    }
+
+    public JavadocComment(int beginLine, int beginColumn, int endLine, int endColumn, String content) {
+        super(beginLine, beginColumn, endLine, endColumn, content);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/MethodDeclaration.java

@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.TypeParameter;
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.expr.NameExpr;
+import japa.parser.ast.stmt.BlockStmt;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class MethodDeclaration extends BodyDeclaration {
+
+    private int modifiers;
+
+    private List<TypeParameter> typeParameters;
+
+    private Type type;
+
+    private String name;
+
+    private List<Parameter> parameters;
+
+    private int arrayCount;
+
+    private List<NameExpr> throws_;
+
+    private BlockStmt body;
+
+    public MethodDeclaration() {
+    }
+
+    public MethodDeclaration(int modifiers, Type type, String name) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.name = name;
+    }
+
+    public MethodDeclaration(int modifiers, Type type, String name, List<Parameter> parameters) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.name = name;
+        this.parameters = parameters;
+    }
+
+    public MethodDeclaration(JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, Type type, String name, List<Parameter> parameters, int arrayCount, List<NameExpr> throws_, BlockStmt block) {
+        super(annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.typeParameters = typeParameters;
+        this.type = type;
+        this.name = name;
+        this.parameters = parameters;
+        this.arrayCount = arrayCount;
+        this.throws_ = throws_;
+        this.body = block;
+    }
+
+    public MethodDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, JavadocComment javaDoc, int modifiers, List<AnnotationExpr> annotations, List<TypeParameter> typeParameters, Type type, String name, List<Parameter> parameters, int arrayCount, List<NameExpr> throws_, BlockStmt block) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.modifiers = modifiers;
+        this.typeParameters = typeParameters;
+        this.type = type;
+        this.name = name;
+        this.parameters = parameters;
+        this.arrayCount = arrayCount;
+        this.throws_ = throws_;
+        this.body = block;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public int getArrayCount() {
+        return arrayCount;
+    }
+
+    public BlockStmt getBody() {
+        return body;
+    }
+
+    /**
+     * Return the modifiers of this member declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Parameter> getParameters() {
+        return parameters;
+    }
+
+    public List<NameExpr> getThrows() {
+        return throws_;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public List<TypeParameter> getTypeParameters() {
+        return typeParameters;
+    }
+
+    public void setArrayCount(int arrayCount) {
+        this.arrayCount = arrayCount;
+    }
+
+    public void setBody(BlockStmt body) {
+        this.body = body;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setParameters(List<Parameter> parameters) {
+        this.parameters = parameters;
+    }
+
+    public void setThrows(List<NameExpr> throws_) {
+        this.throws_ = throws_;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public void setTypeParameters(List<TypeParameter> typeParameters) {
+        this.typeParameters = typeParameters;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/ModifierSet.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package japa.parser.ast.body;
+
+/**
+ * Class to hold modifiers.
+ */
+public final class ModifierSet {
+
+    /* Definitions of the bits in the modifiers field.  */
+    public static final int PUBLIC = 0x0001;
+
+    public static final int PROTECTED = 0x0002;
+
+    public static final int PRIVATE = 0x0004;
+
+    public static final int ABSTRACT = 0x0008;
+
+    public static final int STATIC = 0x0010;
+
+    public static final int FINAL = 0x0020;
+
+    public static final int SYNCHRONIZED = 0x0040;
+
+    public static final int NATIVE = 0x0080;
+
+    public static final int TRANSIENT = 0x0100;
+
+    public static final int VOLATILE = 0x0200;
+
+    public static final int STRICTFP = 0x1000;
+
+    /**
+     * Adds the given modifier.
+     */
+    public static int addModifier(int modifiers, int mod) {
+        return modifiers |= mod;
+    }
+
+    public static boolean hasModifier(int modifiers, int modifier) {
+        return (modifiers & modifier) != 0;
+    }
+
+    public static boolean isAbstract(int modifiers) {
+        return (modifiers & ABSTRACT) != 0;
+    }
+
+    public static boolean isFinal(int modifiers) {
+        return (modifiers & FINAL) != 0;
+    }
+
+    public static boolean isNative(int modifiers) {
+        return (modifiers & NATIVE) != 0;
+    }
+
+    public static boolean isPrivate(int modifiers) {
+        return (modifiers & PRIVATE) != 0;
+    }
+
+    public static boolean isProtected(int modifiers) {
+        return (modifiers & PROTECTED) != 0;
+    }
+
+    /**
+     * A set of accessors that indicate whether the specified modifier is in the
+     * set.
+     */
+
+    public static boolean isPublic(int modifiers) {
+        return (modifiers & PUBLIC) != 0;
+    }
+
+    public static boolean isStatic(int modifiers) {
+        return (modifiers & STATIC) != 0;
+    }
+
+    public static boolean isStrictfp(int modifiers) {
+        return (modifiers & STRICTFP) != 0;
+    }
+
+    public static boolean isSynchronized(int modifiers) {
+        return (modifiers & SYNCHRONIZED) != 0;
+    }
+
+    public static boolean isTransient(int modifiers) {
+        return (modifiers & TRANSIENT) != 0;
+    }
+
+    public static boolean isVolatile(int modifiers) {
+        return (modifiers & VOLATILE) != 0;
+    }
+
+    /**
+     * Removes the given modifier.
+     */
+    public static int removeModifier(int modifiers, int mod) {
+        return modifiers &= ~mod;
+    }
+
+    private ModifierSet() {
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/Parameter.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 03/11/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.expr.AnnotationExpr;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class Parameter extends Node {
+
+    private int modifiers;
+
+    private List<AnnotationExpr> annotations;
+
+    private Type type;
+
+    private boolean isVarArgs;
+
+    private VariableDeclaratorId id;
+
+    public Parameter() {
+    }
+
+    public Parameter(Type type, VariableDeclaratorId id) {
+        this.type = type;
+        this.id = id;
+    }
+
+    public Parameter(int modifiers, Type type, VariableDeclaratorId id) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.id = id;
+    }
+
+    public Parameter(int beginLine, int beginColumn, int endLine, int endColumn, int modifiers, List<AnnotationExpr> annotations, Type type, boolean isVarArgs, VariableDeclaratorId id) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.modifiers = modifiers;
+        this.annotations = annotations;
+        this.type = type;
+        this.isVarArgs = isVarArgs;
+        this.id = id;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<AnnotationExpr> getAnnotations() {
+        return annotations;
+    }
+
+    public VariableDeclaratorId getId() {
+        return id;
+    }
+
+    /**
+     * Return the modifiers of this parameter declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public boolean isVarArgs() {
+        return isVarArgs;
+    }
+
+    public void setAnnotations(List<AnnotationExpr> annotations) {
+        this.annotations = annotations;
+    }
+
+    public void setId(VariableDeclaratorId id) {
+        this.id = id;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public void setVarArgs(boolean isVarArgs) {
+        this.isVarArgs = isVarArgs;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/TypeDeclaration.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.expr.AnnotationExpr;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class TypeDeclaration extends BodyDeclaration {
+
+    private String name;
+
+    private int modifiers;
+
+    private List<BodyDeclaration> members;
+
+    public TypeDeclaration() {
+    }
+
+    public TypeDeclaration(int modifiers, String name) {
+        this.name = name;
+        this.modifiers = modifiers;
+    }
+
+    public TypeDeclaration(List<AnnotationExpr> annotations, JavadocComment javaDoc, int modifiers, String name, List<BodyDeclaration> members) {
+        super(annotations, javaDoc);
+        this.name = name;
+        this.modifiers = modifiers;
+        this.members = members;
+    }
+
+    public TypeDeclaration(int beginLine, int beginColumn, int endLine, int endColumn, List<AnnotationExpr> annotations, JavadocComment javaDoc, int modifiers, String name, List<BodyDeclaration> members) {
+        super(beginLine, beginColumn, endLine, endColumn, annotations, javaDoc);
+        this.name = name;
+        this.modifiers = modifiers;
+        this.members = members;
+    }
+
+    public final List<BodyDeclaration> getMembers() {
+        return members;
+    }
+
+    /**
+     * Return the modifiers of this type declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public final int getModifiers() {
+        return modifiers;
+    }
+
+    public final String getName() {
+        return name;
+    }
+
+    public void setMembers(List<BodyDeclaration> members) {
+        this.members = members;
+    }
+
+    public final void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public final void setName(String name) {
+        this.name = name;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/body/VariableDeclarator.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class VariableDeclarator extends Node {
+
+    private VariableDeclaratorId id;
+
+    private Expression init;
+
+    public VariableDeclarator() {
+    }
+
+    public VariableDeclarator(VariableDeclaratorId id) {
+        this.id = id;
+    }
+
+    public VariableDeclarator(VariableDeclaratorId id, Expression init) {
+        this.id = id;
+        this.init = init;
+    }
+
+    public VariableDeclarator(int beginLine, int beginColumn, int endLine, int endColumn, VariableDeclaratorId id, Expression init) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.id = id;
+        this.init = init;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public VariableDeclaratorId getId() {
+        return id;
+    }
+
+    public Expression getInit() {
+        return init;
+    }
+
+    public void setId(VariableDeclaratorId id) {
+        this.id = id;
+    }
+
+    public void setInit(Expression init) {
+        this.init = init;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/body/VariableDeclaratorId.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.body;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class VariableDeclaratorId extends Node {
+
+    private String name;
+
+    private int arrayCount;
+
+    public VariableDeclaratorId() {
+    }
+
+    public VariableDeclaratorId(String name) {
+        this.name = name;
+    }
+
+    public VariableDeclaratorId(int beginLine, int beginColumn, int endLine, int endColumn, String name, int arrayCount) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.arrayCount = arrayCount;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public int getArrayCount() {
+        return arrayCount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setArrayCount(int arrayCount) {
+        this.arrayCount = arrayCount;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/AnnotationExpr.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.expr;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class AnnotationExpr extends Expression {
+
+    public AnnotationExpr() {
+    }
+
+    public AnnotationExpr(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ArrayAccessExpr.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ArrayAccessExpr extends Expression {
+
+    private Expression name;
+
+    private Expression index;
+
+    public ArrayAccessExpr() {
+    }
+
+    public ArrayAccessExpr(Expression name, Expression index) {
+        this.name = name;
+        this.index = index;
+    }
+
+    public ArrayAccessExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression name, Expression index) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.index = index;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getIndex() {
+        return index;
+    }
+
+    public Expression getName() {
+        return name;
+    }
+
+    public void setIndex(Expression index) {
+        this.index = index;
+    }
+
+    public void setName(Expression name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ArrayCreationExpr.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ArrayCreationExpr extends Expression {
+
+    private Type type;
+
+    private int arrayCount;
+
+    private ArrayInitializerExpr initializer;
+
+    private List<Expression> dimensions;
+
+    public ArrayCreationExpr() {
+    }
+
+    public ArrayCreationExpr(Type type, int arrayCount, ArrayInitializerExpr initializer) {
+        this.type = type;
+        this.arrayCount = arrayCount;
+        this.initializer = initializer;
+        this.dimensions = null;
+    }
+
+    public ArrayCreationExpr(int beginLine, int beginColumn, int endLine, int endColumn, Type type, int arrayCount, ArrayInitializerExpr initializer) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+        this.arrayCount = arrayCount;
+        this.initializer = initializer;
+        this.dimensions = null;
+    }
+
+    public ArrayCreationExpr(Type type, List<Expression> dimensions, int arrayCount) {
+        this.type = type;
+        this.arrayCount = arrayCount;
+        this.dimensions = dimensions;
+        this.initializer = null;
+    }
+
+    public ArrayCreationExpr(int beginLine, int beginColumn, int endLine, int endColumn, Type type, List<Expression> dimensions, int arrayCount) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+        this.arrayCount = arrayCount;
+        this.dimensions = dimensions;
+        this.initializer = null;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public int getArrayCount() {
+        return arrayCount;
+    }
+
+    public List<Expression> getDimensions() {
+        return dimensions;
+    }
+
+    public ArrayInitializerExpr getInitializer() {
+        return initializer;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setArrayCount(int arrayCount) {
+        this.arrayCount = arrayCount;
+    }
+
+    public void setDimensions(List<Expression> dimensions) {
+        this.dimensions = dimensions;
+    }
+
+    public void setInitializer(ArrayInitializerExpr initializer) {
+        this.initializer = initializer;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ArrayInitializerExpr.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ArrayInitializerExpr extends Expression {
+
+    private List<Expression> values;
+
+    public ArrayInitializerExpr() {
+    }
+
+    public ArrayInitializerExpr(List<Expression> values) {
+        this.values = values;
+    }
+
+    public ArrayInitializerExpr(int beginLine, int beginColumn, int endLine, int endColumn, List<Expression> values) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.values = values;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<Expression> getValues() {
+        return values;
+    }
+
+    public void setValues(List<Expression> values) {
+        this.values = values;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/AssignExpr.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class AssignExpr extends Expression {
+
+    public static enum Operator {
+        assign, // =
+        plus, // +=
+        minus, // -=
+        star, // *=
+        slash, // /=
+        and, // &=
+        or, // |=
+        xor, // ^=
+        rem, // %=
+        lShift, // <<=
+        rSignedShift, // >>=
+        rUnsignedShift, // >>>=
+    }
+
+    private Expression target;
+
+    private Expression value;
+
+    private Operator op;
+
+    public AssignExpr() {
+    }
+
+    public AssignExpr(Expression target, Expression value, Operator op) {
+        this.target = target;
+        this.value = value;
+        this.op = op;
+    }
+
+    public AssignExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression target, Expression value, Operator op) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.target = target;
+        this.value = value;
+        this.op = op;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Operator getOperator() {
+        return op;
+    }
+
+    public Expression getTarget() {
+        return target;
+    }
+
+    public Expression getValue() {
+        return value;
+    }
+
+    public void setOperator(Operator op) {
+        this.op = op;
+    }
+
+    public void setTarget(Expression target) {
+        this.target = target;
+    }
+
+    public void setValue(Expression value) {
+        this.value = value;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/BinaryExpr.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class BinaryExpr extends Expression {
+
+    public static enum Operator {
+        or, // ||
+        and, // &&
+        binOr, // |
+        binAnd, // &
+        xor, // ^
+        equals, // ==
+        notEquals, // !=
+        less, // <
+        greater, // >
+        lessEquals, // <=
+        greaterEquals, // >=
+        lShift, // <<
+        rSignedShift, // >>
+        rUnsignedShift, // >>>
+        plus, // +
+        minus, // -
+        times, // *
+        divide, // /
+        remainder, // %
+    }
+
+    private Expression left;
+
+    private Expression right;
+
+    private Operator op;
+
+    public BinaryExpr() {
+    }
+
+    public BinaryExpr(Expression left, Expression right, Operator op) {
+        this.left = left;
+        this.right = right;
+        this.op = op;
+    }
+
+    public BinaryExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression left, Expression right, Operator op) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.left = left;
+        this.right = right;
+        this.op = op;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getLeft() {
+        return left;
+    }
+
+    public Operator getOperator() {
+        return op;
+    }
+
+    public Expression getRight() {
+        return right;
+    }
+
+    public void setLeft(Expression left) {
+        this.left = left;
+    }
+
+    public void setOperator(Operator op) {
+        this.op = op;
+    }
+
+    public void setRight(Expression right) {
+        this.right = right;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/BooleanLiteralExpr.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class BooleanLiteralExpr extends LiteralExpr {
+
+    private boolean value;
+
+    public BooleanLiteralExpr() {
+    }
+
+    public BooleanLiteralExpr(boolean value) {
+        this.value = value;
+    }
+
+    public BooleanLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, boolean value) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.value = value;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public boolean getValue() {
+        return value;
+    }
+
+    public void setValue(boolean value) {
+        this.value = value;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/CastExpr.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class CastExpr extends Expression {
+
+    private Type type;
+
+    private Expression expr;
+
+    public CastExpr() {
+    }
+
+    public CastExpr(Type type, Expression expr) {
+        this.type = type;
+        this.expr = expr;
+    }
+
+    public CastExpr(int beginLine, int beginColumn, int endLine, int endColumn, Type type, Expression expr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+        this.expr = expr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/CharLiteralExpr.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class CharLiteralExpr extends StringLiteralExpr {
+
+    public CharLiteralExpr() {
+    }
+
+    public CharLiteralExpr(String value) {
+        super(value);
+    }
+
+    public CharLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, String value) {
+        super(beginLine, beginColumn, endLine, endColumn, value);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ClassExpr.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ClassExpr extends Expression {
+
+    private Type type;
+
+    public ClassExpr() {
+    }
+
+    public ClassExpr(Type type) {
+        this.type = type;
+    }
+
+    public ClassExpr(int beginLine, int beginColumn, int endLine, int endColumn, Type type) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ConditionalExpr.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ConditionalExpr extends Expression {
+
+    private Expression condition;
+
+    private Expression thenExpr;
+
+    private Expression elseExpr;
+
+    public ConditionalExpr() {
+    }
+
+    public ConditionalExpr(Expression condition, Expression thenExpr, Expression elseExpr) {
+        this.condition = condition;
+        this.thenExpr = thenExpr;
+        this.elseExpr = elseExpr;
+    }
+
+    public ConditionalExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression condition, Expression thenExpr, Expression elseExpr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.condition = condition;
+        this.thenExpr = thenExpr;
+        this.elseExpr = elseExpr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getCondition() {
+        return condition;
+    }
+
+    public Expression getElseExpr() {
+        return elseExpr;
+    }
+
+    public Expression getThenExpr() {
+        return thenExpr;
+    }
+
+    public void setCondition(Expression condition) {
+        this.condition = condition;
+    }
+
+    public void setElseExpr(Expression elseExpr) {
+        this.elseExpr = elseExpr;
+    }
+
+    public void setThenExpr(Expression thenExpr) {
+        this.thenExpr = thenExpr;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/DoubleLiteralExpr.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class DoubleLiteralExpr extends StringLiteralExpr {
+
+    public DoubleLiteralExpr() {
+    }
+
+    public DoubleLiteralExpr(String value) {
+        super(value);
+    }
+
+    public DoubleLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, String value) {
+        super(beginLine, beginColumn, endLine, endColumn, value);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/EnclosedExpr.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EnclosedExpr extends Expression {
+
+    private Expression inner;
+
+    public EnclosedExpr() {
+    }
+
+    public EnclosedExpr(Expression inner) {
+        this.inner = inner;
+    }
+
+    public EnclosedExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression inner) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.inner = inner;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getInner() {
+        return inner;
+    }
+
+    public void setInner(Expression inner) {
+        this.inner = inner;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/Expression.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 10/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.Node;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class Expression extends Node {
+
+    public Expression() {
+    }
+
+    public Expression(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/FieldAccessExpr.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class FieldAccessExpr extends Expression {
+
+    private Expression scope;
+
+    private List<Type> typeArgs;
+
+    private String field;
+
+    public FieldAccessExpr() {
+    }
+
+    public FieldAccessExpr(Expression scope, String field) {
+        this.scope = scope;
+        this.field = field;
+    }
+
+    public FieldAccessExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression scope, List<Type> typeArgs, String field) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.scope = scope;
+        this.typeArgs = typeArgs;
+        this.field = field;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    public Expression getScope() {
+        return scope;
+    }
+
+    public List<Type> getTypeArgs() {
+        return typeArgs;
+    }
+
+    public void setField(String field) {
+        this.field = field;
+    }
+
+    public void setScope(Expression scope) {
+        this.scope = scope;
+    }
+
+    public void setTypeArgs(List<Type> typeArgs) {
+        this.typeArgs = typeArgs;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/InstanceOfExpr.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class InstanceOfExpr extends Expression {
+
+    private Expression expr;
+
+    private Type type;
+
+    public InstanceOfExpr() {
+    }
+
+    public InstanceOfExpr(Expression expr, Type type) {
+        this.expr = expr;
+        this.type = type;
+    }
+
+    public InstanceOfExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr, Type type) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+        this.type = type;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/IntegerLiteralExpr.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public class IntegerLiteralExpr extends StringLiteralExpr {
+
+    private static final String UNSIGNED_MIN_VALUE = "2147483648";
+
+    protected static final String MIN_VALUE = "-" + UNSIGNED_MIN_VALUE;
+
+    public IntegerLiteralExpr() {
+    }
+
+    public IntegerLiteralExpr(String value) {
+        super(value);
+    }
+
+    public IntegerLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, String value) {
+        super(beginLine, beginColumn, endLine, endColumn, value);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public final boolean isMinValue() {
+        return value != null && //
+                value.length() == 10 && //
+                value.equals(UNSIGNED_MIN_VALUE);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/IntegerLiteralMinValueExpr.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 09/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class IntegerLiteralMinValueExpr extends IntegerLiteralExpr {
+
+    public IntegerLiteralMinValueExpr() {
+        super(MIN_VALUE);
+    }
+
+    public IntegerLiteralMinValueExpr(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn, MIN_VALUE);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/LiteralExpr.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class LiteralExpr extends Expression {
+
+    public LiteralExpr() {
+    }
+
+    public LiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/LongLiteralExpr.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public class LongLiteralExpr extends StringLiteralExpr {
+
+    private static final String UNSIGNED_MIN_VALUE = "9223372036854775808";
+
+    protected static final String MIN_VALUE = "-" + UNSIGNED_MIN_VALUE + "L";
+
+    public LongLiteralExpr() {
+    }
+
+    public LongLiteralExpr(String value) {
+        super(value);
+    }
+
+    public LongLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, String value) {
+        super(beginLine, beginColumn, endLine, endColumn, value);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public final boolean isMinValue() {
+        return value != null && //
+                value.length() == 20 && //
+                value.startsWith(UNSIGNED_MIN_VALUE) && //
+                (value.charAt(19) == 'L' || value.charAt(19) == 'l');
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/LongLiteralMinValueExpr.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 09/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class LongLiteralMinValueExpr extends LongLiteralExpr {
+
+    public LongLiteralMinValueExpr() {
+        super(MIN_VALUE);
+    }
+
+    public LongLiteralMinValueExpr(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn, MIN_VALUE);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/MarkerAnnotationExpr.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class MarkerAnnotationExpr extends AnnotationExpr {
+
+    private NameExpr name;
+
+    public MarkerAnnotationExpr() {
+    }
+
+    public MarkerAnnotationExpr(NameExpr name) {
+        this.name = name;
+    }
+
+    public MarkerAnnotationExpr(int beginLine, int beginColumn, int endLine, int endColumn, NameExpr name) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public NameExpr getName() {
+        return name;
+    }
+
+    public void setName(NameExpr name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/MemberValuePair.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class MemberValuePair extends Node {
+
+    private String name;
+
+    private Expression value;
+
+    public MemberValuePair() {
+    }
+
+    public MemberValuePair(String name, Expression value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    public MemberValuePair(int beginLine, int beginColumn, int endLine, int endColumn, String name, Expression value) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.value = value;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Expression getValue() {
+        return value;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setValue(Expression value) {
+        this.value = value;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/MethodCallExpr.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class MethodCallExpr extends Expression {
+
+    private Expression scope;
+
+    private List<Type> typeArgs;
+
+    private String name;
+
+    private List<Expression> args;
+
+    public MethodCallExpr() {
+    }
+
+    public MethodCallExpr(Expression scope, String name) {
+        this.scope = scope;
+        this.name = name;
+    }
+
+    public MethodCallExpr(Expression scope, String name, List<Expression> args) {
+        this.scope = scope;
+        this.name = name;
+        this.args = args;
+    }
+
+    public MethodCallExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression scope, List<Type> typeArgs, String name, List<Expression> args) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.scope = scope;
+        this.typeArgs = typeArgs;
+        this.name = name;
+        this.args = args;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<Expression> getArgs() {
+        return args;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Expression getScope() {
+        return scope;
+    }
+
+    public List<Type> getTypeArgs() {
+        return typeArgs;
+    }
+
+    public void setArgs(List<Expression> args) {
+        this.args = args;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setScope(Expression scope) {
+        this.scope = scope;
+    }
+
+    public void setTypeArgs(List<Type> typeArgs) {
+        this.typeArgs = typeArgs;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/NameExpr.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public class NameExpr extends Expression {
+
+    private String name;
+
+    public NameExpr() {
+    }
+
+    public NameExpr(String name) {
+        this.name = name;
+    }
+
+    public NameExpr(int beginLine, int beginColumn, int endLine, int endColumn, String name) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public final String getName() {
+        return name;
+    }
+
+    public final void setName(String name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/NormalAnnotationExpr.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class NormalAnnotationExpr extends AnnotationExpr {
+
+    private NameExpr name;
+
+    private List<MemberValuePair> pairs;
+
+    public NormalAnnotationExpr() {
+    }
+
+    public NormalAnnotationExpr(NameExpr name, List<MemberValuePair> pairs) {
+        this.name = name;
+        this.pairs = pairs;
+    }
+
+    public NormalAnnotationExpr(int beginLine, int beginColumn, int endLine, int endColumn, NameExpr name, List<MemberValuePair> pairs) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.pairs = pairs;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public NameExpr getName() {
+        return name;
+    }
+
+    public List<MemberValuePair> getPairs() {
+        return pairs;
+    }
+
+    public void setName(NameExpr name) {
+        this.name = name;
+    }
+
+    public void setPairs(List<MemberValuePair> pairs) {
+        this.pairs = pairs;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/NullLiteralExpr.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class NullLiteralExpr extends LiteralExpr {
+
+    public NullLiteralExpr() {
+    }
+
+    public NullLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ObjectCreationExpr.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.body.BodyDeclaration;
+import japa.parser.ast.type.ClassOrInterfaceType;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ObjectCreationExpr extends Expression {
+
+    private Expression scope;
+
+    private ClassOrInterfaceType type;
+
+    private List<Type> typeArgs;
+
+    private List<Expression> args;
+
+    private List<BodyDeclaration> anonymousClassBody;
+
+    public ObjectCreationExpr() {
+    }
+
+    public ObjectCreationExpr(Expression scope, ClassOrInterfaceType type, List<Expression> args) {
+        this.scope = scope;
+        this.type = type;
+        this.args = args;
+    }
+
+    public ObjectCreationExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression scope, ClassOrInterfaceType type, List<Type> typeArgs, List<Expression> args, List<BodyDeclaration> anonymousBody) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.scope = scope;
+        this.type = type;
+        this.typeArgs = typeArgs;
+        this.args = args;
+        this.anonymousClassBody = anonymousBody;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<BodyDeclaration> getAnonymousClassBody() {
+        return anonymousClassBody;
+    }
+
+    public List<Expression> getArgs() {
+        return args;
+    }
+
+    public Expression getScope() {
+        return scope;
+    }
+
+    public ClassOrInterfaceType getType() {
+        return type;
+    }
+
+    public List<Type> getTypeArgs() {
+        return typeArgs;
+    }
+
+    public void setAnonymousClassBody(List<BodyDeclaration> anonymousClassBody) {
+        this.anonymousClassBody = anonymousClassBody;
+    }
+
+    public void setArgs(List<Expression> args) {
+        this.args = args;
+    }
+
+    public void setScope(Expression scope) {
+        this.scope = scope;
+    }
+
+    public void setType(ClassOrInterfaceType type) {
+        this.type = type;
+    }
+
+    public void setTypeArgs(List<Type> typeArgs) {
+        this.typeArgs = typeArgs;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/QualifiedNameExpr.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class QualifiedNameExpr extends NameExpr {
+
+    private NameExpr qualifier;
+
+    public QualifiedNameExpr() {
+    }
+
+    public QualifiedNameExpr(NameExpr scope, String name) {
+        super(name);
+        this.qualifier = scope;
+    }
+
+    public QualifiedNameExpr(int beginLine, int beginColumn, int endLine, int endColumn, NameExpr scope, String name) {
+        super(beginLine, beginColumn, endLine, endColumn, name);
+        this.qualifier = scope;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public NameExpr getQualifier() {
+        return qualifier;
+    }
+
+    public void setQualifier(NameExpr qualifier) {
+        this.qualifier = qualifier;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/SingleMemberAnnotationExpr.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 21/11/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class SingleMemberAnnotationExpr extends AnnotationExpr {
+
+    private NameExpr name;
+
+    private Expression memberValue;
+
+    public SingleMemberAnnotationExpr() {
+    }
+
+    public SingleMemberAnnotationExpr(NameExpr name, Expression memberValue) {
+        this.name = name;
+        this.memberValue = memberValue;
+    }
+
+    public SingleMemberAnnotationExpr(int beginLine, int beginColumn, int endLine, int endColumn, NameExpr name, Expression memberValue) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.name = name;
+        this.memberValue = memberValue;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getMemberValue() {
+        return memberValue;
+    }
+
+    public NameExpr getName() {
+        return name;
+    }
+
+    public void setMemberValue(Expression memberValue) {
+        this.memberValue = memberValue;
+    }
+
+    public void setName(NameExpr name) {
+        this.name = name;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/StringLiteralExpr.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 02/03/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public class StringLiteralExpr extends LiteralExpr {
+
+    protected String value;
+
+    public StringLiteralExpr() {
+    }
+
+    public StringLiteralExpr(String value) {
+        this.value = value;
+    }
+
+    public StringLiteralExpr(int beginLine, int beginColumn, int endLine, int endColumn, String value) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.value = value;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public final String getValue() {
+        return value;
+    }
+
+    public final void setValue(String value) {
+        this.value = value;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/SuperExpr.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 20/01/2007
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class SuperExpr extends Expression {
+
+    private Expression classExpr;
+
+    public SuperExpr() {
+    }
+
+    public SuperExpr(Expression classExpr) {
+        this.classExpr = classExpr;
+    }
+
+    public SuperExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression classExpr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.classExpr = classExpr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getClassExpr() {
+        return classExpr;
+    }
+
+    public void setClassExpr(Expression classExpr) {
+        this.classExpr = classExpr;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/ThisExpr.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ThisExpr extends Expression {
+
+    private Expression classExpr;
+
+    public ThisExpr() {
+    }
+
+    public ThisExpr(Expression classExpr) {
+        this.classExpr = classExpr;
+    }
+
+    public ThisExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression classExpr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.classExpr = classExpr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getClassExpr() {
+        return classExpr;
+    }
+
+    public void setClassExpr(Expression classExpr) {
+        this.classExpr = classExpr;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/UnaryExpr.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class UnaryExpr extends Expression {
+
+    public static enum Operator {
+        positive, // +
+        negative, // -
+        preIncrement, // ++
+        preDecrement, // --
+        not, // !
+        inverse, // ~
+        posIncrement, // ++
+        posDecrement, // --
+    }
+
+    private Expression expr;
+
+    private Operator op;
+
+    public UnaryExpr() {
+    }
+
+    public UnaryExpr(Expression expr, Operator op) {
+        this.expr = expr;
+        this.op = op;
+    }
+
+    public UnaryExpr(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr, Operator op) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+        this.op = op;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public Operator getOperator() {
+        return op;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+
+    public void setOperator(Operator op) {
+        this.op = op;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/expr/VariableDeclarationExpr.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 03/11/2006
+ */
+package japa.parser.ast.expr;
+
+import japa.parser.ast.body.ModifierSet;
+import japa.parser.ast.body.VariableDeclarator;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class VariableDeclarationExpr extends Expression {
+
+    private int modifiers;
+
+    private List<AnnotationExpr> annotations;
+
+    private Type type;
+
+    private List<VariableDeclarator> vars;
+
+    public VariableDeclarationExpr() {
+    }
+
+    public VariableDeclarationExpr(Type type, List<VariableDeclarator> vars) {
+        this.type = type;
+        this.vars = vars;
+    }
+
+    public VariableDeclarationExpr(int modifiers, Type type, List<VariableDeclarator> vars) {
+        this.modifiers = modifiers;
+        this.type = type;
+        this.vars = vars;
+    }
+
+    public VariableDeclarationExpr(int beginLine, int beginColumn, int endLine, int endColumn, int modifiers, List<AnnotationExpr> annotations, Type type, List<VariableDeclarator> vars) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.modifiers = modifiers;
+        this.annotations = annotations;
+        this.type = type;
+        this.vars = vars;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<AnnotationExpr> getAnnotations() {
+        return annotations;
+    }
+
+    /**
+     * Return the modifiers of this variable declaration.
+     * 
+     * @see ModifierSet
+     * @return modifiers
+     */
+    public int getModifiers() {
+        return modifiers;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public List<VariableDeclarator> getVars() {
+        return vars;
+    }
+
+    public void setAnnotations(List<AnnotationExpr> annotations) {
+        this.annotations = annotations;
+    }
+
+    public void setModifiers(int modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+    public void setVars(List<VariableDeclarator> vars) {
+        this.vars = vars;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/AssertStmt.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class AssertStmt extends Statement {
+
+    private Expression check;
+
+    private Expression msg;
+
+    public AssertStmt() {
+    }
+
+    public AssertStmt(Expression check) {
+        this.check = check;
+    }
+
+    public AssertStmt(Expression check, Expression msg) {
+        this.check = check;
+        this.msg = msg;
+    }
+
+    public AssertStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression check, Expression msg) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.check = check;
+        this.msg = msg;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getCheck() {
+        return check;
+    }
+
+    public Expression getMessage() {
+        return msg;
+    }
+
+    public void setCheck(Expression check) {
+        this.check = check;
+    }
+
+    public void setMessage(Expression msg) {
+        this.msg = msg;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/BlockStmt.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class BlockStmt extends Statement {
+
+    private List<Statement> stmts;
+
+    public BlockStmt() {
+    }
+
+    public BlockStmt(List<Statement> stmts) {
+        this.stmts = stmts;
+    }
+
+    public BlockStmt(int beginLine, int beginColumn, int endLine, int endColumn, List<Statement> stmts) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.stmts = stmts;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<Statement> getStmts() {
+        return stmts;
+    }
+
+    public void setStmts(List<Statement> stmts) {
+        this.stmts = stmts;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/BreakStmt.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class BreakStmt extends Statement {
+
+    private String id;
+
+    public BreakStmt() {
+    }
+
+    public BreakStmt(String id) {
+        this.id = id;
+    }
+
+    public BreakStmt(int beginLine, int beginColumn, int endLine, int endColumn, String id) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.id = id;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/CatchClause.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 18/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.Node;
+import japa.parser.ast.body.Parameter;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class CatchClause extends Node {
+
+    private Parameter except;
+
+    private BlockStmt catchBlock;
+
+    public CatchClause() {
+    }
+
+    public CatchClause(Parameter except, BlockStmt catchBlock) {
+        this.except = except;
+        this.catchBlock = catchBlock;
+    }
+
+    public CatchClause(int beginLine, int beginColumn, int endLine, int endColumn, Parameter except, BlockStmt catchBlock) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.except = except;
+        this.catchBlock = catchBlock;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public BlockStmt getCatchBlock() {
+        return catchBlock;
+    }
+
+    public Parameter getExcept() {
+        return except;
+    }
+
+    public void setCatchBlock(BlockStmt catchBlock) {
+        this.catchBlock = catchBlock;
+    }
+
+    public void setExcept(Parameter except) {
+        this.except = except;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ContinueStmt.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ContinueStmt extends Statement {
+
+    private String id;
+
+    public ContinueStmt() {
+    }
+
+    public ContinueStmt(String id) {
+        this.id = id;
+    }
+
+    public ContinueStmt(int beginLine, int beginColumn, int endLine, int endColumn, String id) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.id = id;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/DoStmt.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class DoStmt extends Statement {
+
+    private Statement body;
+
+    private Expression condition;
+
+    public DoStmt() {
+    }
+
+    public DoStmt(Statement body, Expression condition) {
+        this.body = body;
+        this.condition = condition;
+    }
+
+    public DoStmt(int beginLine, int beginColumn, int endLine, int endColumn, Statement body, Expression condition) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.body = body;
+        this.condition = condition;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Statement getBody() {
+        return body;
+    }
+
+    public Expression getCondition() {
+        return condition;
+    }
+
+    public void setBody(Statement body) {
+        this.body = body;
+    }
+
+    public void setCondition(Expression condition) {
+        this.condition = condition;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/EmptyStmt.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class EmptyStmt extends Statement {
+
+    public EmptyStmt() {
+    }
+
+    public EmptyStmt(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ExplicitConstructorInvocationStmt.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 03/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.type.Type;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ExplicitConstructorInvocationStmt extends Statement {
+
+    private List<Type> typeArgs;
+
+    private boolean isThis;
+
+    private Expression expr;
+
+    private List<Expression> args;
+
+    public ExplicitConstructorInvocationStmt() {
+    }
+
+    public ExplicitConstructorInvocationStmt(boolean isThis, Expression expr, List<Expression> args) {
+        this.isThis = isThis;
+        this.expr = expr;
+        this.args = args;
+    }
+
+    public ExplicitConstructorInvocationStmt(int beginLine, int beginColumn, int endLine, int endColumn, List<Type> typeArgs, boolean isThis, Expression expr, List<Expression> args) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.typeArgs = typeArgs;
+        this.isThis = isThis;
+        this.expr = expr;
+        this.args = args;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<Expression> getArgs() {
+        return args;
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public List<Type> getTypeArgs() {
+        return typeArgs;
+    }
+
+    public boolean isThis() {
+        return isThis;
+    }
+
+    public void setArgs(List<Expression> args) {
+        this.args = args;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+
+    public void setThis(boolean isThis) {
+        this.isThis = isThis;
+    }
+
+    public void setTypeArgs(List<Type> typeArgs) {
+        this.typeArgs = typeArgs;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ExpressionStmt.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ExpressionStmt extends Statement {
+
+    private Expression expr;
+
+    public ExpressionStmt() {
+    }
+
+    public ExpressionStmt(Expression expr) {
+        this.expr = expr;
+    }
+
+    public ExpressionStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpression() {
+        return expr;
+    }
+
+    public void setExpression(Expression expr) {
+        this.expr = expr;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ForStmt.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ForStmt extends Statement {
+
+    private List<Expression> init;
+
+    private Expression compare;
+
+    private List<Expression> update;
+
+    private Statement body;
+
+    public ForStmt() {
+    }
+
+    public ForStmt(List<Expression> init, Expression compare, List<Expression> update, Statement body) {
+        this.compare = compare;
+        this.init = init;
+        this.update = update;
+        this.body = body;
+    }
+
+    public ForStmt(int beginLine, int beginColumn, int endLine, int endColumn, List<Expression> init, Expression compare, List<Expression> update, Statement body) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.compare = compare;
+        this.init = init;
+        this.update = update;
+        this.body = body;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Statement getBody() {
+        return body;
+    }
+
+    public Expression getCompare() {
+        return compare;
+    }
+
+    public List<Expression> getInit() {
+        return init;
+    }
+
+    public List<Expression> getUpdate() {
+        return update;
+    }
+
+    public void setBody(Statement body) {
+        this.body = body;
+    }
+
+    public void setCompare(Expression compare) {
+        this.compare = compare;
+    }
+
+    public void setInit(List<Expression> init) {
+        this.init = init;
+    }
+
+    public void setUpdate(List<Expression> update) {
+        this.update = update;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ForeachStmt.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.expr.VariableDeclarationExpr;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ForeachStmt extends Statement {
+
+    private VariableDeclarationExpr var;
+
+    private Expression iterable;
+
+    private Statement body;
+
+    public ForeachStmt() {
+    }
+
+    public ForeachStmt(VariableDeclarationExpr var, Expression iterable, Statement body) {
+        this.var = var;
+        this.iterable = iterable;
+        this.body = body;
+    }
+
+    public ForeachStmt(int beginLine, int beginColumn, int endLine, int endColumn, VariableDeclarationExpr var, Expression iterable, Statement body) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.var = var;
+        this.iterable = iterable;
+        this.body = body;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Statement getBody() {
+        return body;
+    }
+
+    public Expression getIterable() {
+        return iterable;
+    }
+
+    public VariableDeclarationExpr getVariable() {
+        return var;
+    }
+
+    public void setBody(Statement body) {
+        this.body = body;
+    }
+
+    public void setIterable(Expression iterable) {
+        this.iterable = iterable;
+    }
+
+    public void setVariable(VariableDeclarationExpr var) {
+        this.var = var;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/IfStmt.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class IfStmt extends Statement {
+
+    private Expression condition;
+
+    private Statement thenStmt;
+
+    private Statement elseStmt;
+
+    public IfStmt() {
+    }
+
+    public IfStmt(Expression condition, Statement thenStmt, Statement elseStmt) {
+        this.condition = condition;
+        this.thenStmt = thenStmt;
+        this.elseStmt = elseStmt;
+    }
+
+    public IfStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression condition, Statement thenStmt, Statement elseStmt) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.condition = condition;
+        this.thenStmt = thenStmt;
+        this.elseStmt = elseStmt;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getCondition() {
+        return condition;
+    }
+
+    public Statement getElseStmt() {
+        return elseStmt;
+    }
+
+    public Statement getThenStmt() {
+        return thenStmt;
+    }
+
+    public void setCondition(Expression condition) {
+        this.condition = condition;
+    }
+
+    public void setElseStmt(Statement elseStmt) {
+        this.elseStmt = elseStmt;
+    }
+
+    public void setThenStmt(Statement thenStmt) {
+        this.thenStmt = thenStmt;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/LabeledStmt.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class LabeledStmt extends Statement {
+
+    private String label;
+
+    private Statement stmt;
+
+    public LabeledStmt() {
+    }
+
+    public LabeledStmt(String label, Statement stmt) {
+        this.label = label;
+        this.stmt = stmt;
+    }
+
+    public LabeledStmt(int beginLine, int beginColumn, int endLine, int endColumn, String label, Statement stmt) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.label = label;
+        this.stmt = stmt;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public Statement getStmt() {
+        return stmt;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public void setStmt(Statement stmt) {
+        this.stmt = stmt;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ReturnStmt.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ReturnStmt extends Statement {
+
+    private Expression expr;
+
+    public ReturnStmt() {
+    }
+
+    public ReturnStmt(Expression expr) {
+        this.expr = expr;
+    }
+
+    public ReturnStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/Statement.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ *
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 03/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.Node;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class Statement extends Node {
+
+    public Statement() {
+    }
+
+    public Statement(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/SwitchEntryStmt.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class SwitchEntryStmt extends Statement {
+
+    private Expression label;
+
+    private List<Statement> stmts;
+
+    public SwitchEntryStmt() {
+    }
+
+    public SwitchEntryStmt(Expression label, List<Statement> stmts) {
+        this.label = label;
+        this.stmts = stmts;
+    }
+
+    public SwitchEntryStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression label, List<Statement> stmts) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.label = label;
+        this.stmts = stmts;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getLabel() {
+        return label;
+    }
+
+    public List<Statement> getStmts() {
+        return stmts;
+    }
+
+    public void setLabel(Expression label) {
+        this.label = label;
+    }
+
+    public void setStmts(List<Statement> stmts) {
+        this.stmts = stmts;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/SwitchStmt.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class SwitchStmt extends Statement {
+
+    private Expression selector;
+
+    private List<SwitchEntryStmt> entries;
+
+    public SwitchStmt() {
+    }
+
+    public SwitchStmt(Expression selector, List<SwitchEntryStmt> entries) {
+        this.selector = selector;
+        this.entries = entries;
+    }
+
+    public SwitchStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression selector, List<SwitchEntryStmt> entries) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.selector = selector;
+        this.entries = entries;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<SwitchEntryStmt> getEntries() {
+        return entries;
+    }
+
+    public Expression getSelector() {
+        return selector;
+    }
+
+    public void setEntries(List<SwitchEntryStmt> entries) {
+        this.entries = entries;
+    }
+
+    public void setSelector(Expression selector) {
+        this.selector = selector;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/SynchronizedStmt.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 18/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class SynchronizedStmt extends Statement {
+
+    private Expression expr;
+
+    private BlockStmt block;
+
+    public SynchronizedStmt() {
+    }
+
+    public SynchronizedStmt(Expression expr, BlockStmt block) {
+        this.expr = expr;
+        this.block = block;
+    }
+
+    public SynchronizedStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr, BlockStmt block) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+        this.block = block;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public BlockStmt getBlock() {
+        return block;
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public void setBlock(BlockStmt block) {
+        this.block = block;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/ThrowStmt.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 18/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ThrowStmt extends Statement {
+
+    private Expression expr;
+
+    public ThrowStmt() {
+    }
+
+    public ThrowStmt(Expression expr) {
+        this.expr = expr;
+    }
+
+    public ThrowStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression expr) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.expr = expr;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Expression getExpr() {
+        return expr;
+    }
+
+    public void setExpr(Expression expr) {
+        this.expr = expr;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/TryStmt.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 18/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class TryStmt extends Statement {
+
+    private BlockStmt tryBlock;
+
+    private List<CatchClause> catchs;
+
+    private BlockStmt finallyBlock;
+
+    public TryStmt() {
+    }
+
+    public TryStmt(BlockStmt tryBlock, List<CatchClause> catchs, BlockStmt finallyBlock) {
+        this.tryBlock = tryBlock;
+        this.catchs = catchs;
+        this.finallyBlock = finallyBlock;
+    }
+
+    public TryStmt(int beginLine, int beginColumn, int endLine, int endColumn, BlockStmt tryBlock, List<CatchClause> catchs, BlockStmt finallyBlock) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.tryBlock = tryBlock;
+        this.catchs = catchs;
+        this.finallyBlock = finallyBlock;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public List<CatchClause> getCatchs() {
+        return catchs;
+    }
+
+    public BlockStmt getFinallyBlock() {
+        return finallyBlock;
+    }
+
+    public BlockStmt getTryBlock() {
+        return tryBlock;
+    }
+
+    public void setCatchs(List<CatchClause> catchs) {
+        this.catchs = catchs;
+    }
+
+    public void setFinallyBlock(BlockStmt finallyBlock) {
+        this.finallyBlock = finallyBlock;
+    }
+
+    public void setTryBlock(BlockStmt tryBlock) {
+        this.tryBlock = tryBlock;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/TypeDeclarationStmt.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 04/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.body.TypeDeclaration;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class TypeDeclarationStmt extends Statement {
+
+    private TypeDeclaration typeDecl;
+
+    public TypeDeclarationStmt() {
+    }
+
+    public TypeDeclarationStmt(TypeDeclaration typeDecl) {
+        this.typeDecl = typeDecl;
+    }
+
+    public TypeDeclarationStmt(int beginLine, int beginColumn, int endLine, int endColumn, TypeDeclaration typeDecl) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.typeDecl = typeDecl;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public TypeDeclaration getTypeDeclaration() {
+        return typeDecl;
+    }
+
+    public void setTypeDeclaration(TypeDeclaration typeDecl) {
+        this.typeDecl = typeDecl;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/stmt/WhileStmt.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 07/11/2006
+ */
+package japa.parser.ast.stmt;
+
+import japa.parser.ast.expr.Expression;
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class WhileStmt extends Statement {
+
+    private Expression condition;
+
+    private Statement body;
+
+    public WhileStmt() {
+    }
+
+    public WhileStmt(Expression condition, Statement body) {
+        this.condition = condition;
+        this.body = body;
+    }
+
+    public WhileStmt(int beginLine, int beginColumn, int endLine, int endColumn, Expression condition, Statement body) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.condition = condition;
+        this.body = body;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Statement getBody() {
+        return body;
+    }
+
+    public Expression getCondition() {
+        return condition;
+    }
+
+    public void setBody(Statement body) {
+        this.body = body;
+    }
+
+    public void setCondition(Expression condition) {
+        this.condition = condition;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/type/ClassOrInterfaceType.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.type;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+import java.util.List;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ClassOrInterfaceType extends Type {
+
+    private ClassOrInterfaceType scope;
+
+    private String name;
+
+    private List<Type> typeArgs;
+
+    public ClassOrInterfaceType() {
+    }
+
+    public ClassOrInterfaceType(String name) {
+        this.name = name;
+    }
+
+    public ClassOrInterfaceType(ClassOrInterfaceType scope, String name) {
+        this.scope = scope;
+        this.name = name;
+    }
+
+    public ClassOrInterfaceType(int beginLine, int beginColumn, int endLine, int endColumn, ClassOrInterfaceType scope, String name, List<Type> typeArgs) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.scope = scope;
+        this.name = name;
+        this.typeArgs = typeArgs;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public ClassOrInterfaceType getScope() {
+        return scope;
+    }
+
+    public List<Type> getTypeArgs() {
+        return typeArgs;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setScope(ClassOrInterfaceType scope) {
+        this.scope = scope;
+    }
+
+    public void setTypeArgs(List<Type> typeArgs) {
+        this.typeArgs = typeArgs;
+    }
+}

parser/html/java/javaparser/src/japa/parser/ast/type/PrimitiveType.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.type;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class PrimitiveType extends Type {
+
+    public enum Primitive {
+        Boolean, Char, Byte, Short, Int, Long, Float, Double
+    }
+
+    private Primitive type;
+
+    public PrimitiveType() {
+    }
+
+    public PrimitiveType(Primitive type) {
+        this.type = type;
+    }
+
+    public PrimitiveType(int beginLine, int beginColumn, int endLine, int endColumn, Primitive type) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public Primitive getType() {
+        return type;
+    }
+
+    public void setType(Primitive type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/type/ReferenceType.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.type;
+
+import japa.parser.ast.visitor.GenericVisitor;
+import japa.parser.ast.visitor.VoidVisitor;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public final class ReferenceType extends Type {
+
+    private Type type;
+
+    private int arrayCount;
+
+    public ReferenceType() {
+    }
+
+    public ReferenceType(Type type) {
+        this.type = type;
+    }
+
+    public ReferenceType(Type type, int arrayCount) {
+        this.type = type;
+        this.arrayCount = arrayCount;
+    }
+
+    public ReferenceType(int beginLine, int beginColumn, int endLine, int endColumn, Type type, int arrayCount) {
+        super(beginLine, beginColumn, endLine, endColumn);
+        this.type = type;
+        this.arrayCount = arrayCount;
+    }
+
+    @Override
+    public <R, A> R accept(GenericVisitor<R, A> v, A arg) {
+        return v.visit(this, arg);
+    }
+
+    @Override
+    public <A> void accept(VoidVisitor<A> v, A arg) {
+        v.visit(this, arg);
+    }
+
+    public int getArrayCount() {
+        return arrayCount;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public void setArrayCount(int arrayCount) {
+        this.arrayCount = arrayCount;
+    }
+
+    public void setType(Type type) {
+        this.type = type;
+    }
+
+}

parser/html/java/javaparser/src/japa/parser/ast/type/Type.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2007 Júlio Vilmar Gesser.
+ * 
+ * This file is part of Java 1.5 parser and Abstract Syntax Tree.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Java 1.5 parser and Abstract Syntax Tree is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Java 1.5 parser and Abstract Syntax Tree.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+ * Created on 05/10/2006
+ */
+package japa.parser.ast.type;
+
+import japa.parser.ast.Node;
+
+/**
+ * @author Julio Vilmar Gesser
+ */
+public abstract class Type extends Node {
+
+    public Type() {
+    }
+
+    public Type(int beginLine, int beginColumn, int endLine, int endColumn) {
+        super(beginLine, beginColumn, endLine, endColumn);
+    }
+
+}