Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## rj.tools.jcsc
Class JavaCodingStandardChecker

    java.lang.Object
      |
      +--rj.tools.jcsc.JavaCodingStandardChecker

All Implemented Interfaces:
  JavaCodingStandardCheckerConstants

public class JavaCodingStandardChecker
extends java.lang.Object
implements JavaCodingStandardCheckerConstants

This JavaCC grammar and program are to check Java source against specific rules

Version:
  $Revision: 1.26 $
Author:
  Ralph Jocham

Field Summary
`Token` | `jj_nt`
`boolean` | `lookingAhead`
`static java.util.ArrayList` | `sAuthors`
`static int` | `sCCNCount` counter to keep track of CCS (cyclomatic complexity number)
`static rj.tools.jcsc.JavaCodingStandardChecker.CurrentState` | `sCurrentState` State of the current class declaration.
`static java.lang.String` | `sJVMVersion` jvm spec version
`static java.lang.StringBuffer` | `sLastComment` last read comment block
`static java.lang.String` | `sLastJavaDoc` last read java doc
`static java.util.ArrayList` | `sMethodMetrics`
`static int` | `sMethodsCount` counter to keep track of methods
`static int` | `sNCSSCount` counter to keep track of NCSS (non commenting source statements)
`static boolean` | `sNewLine` true if \n was lexed; has to be set to false on own accord
`static boolean` | `sReturn` true if return statement was the last one
`static int` | `sSpaceCount` counter to keep track of spaces after statement keyword
`static int` | `sUnitTestClassCount` counter to keep track of unit test classes
`static int` | `sUnitTestsCount` counter to keep track of unit tests
`static java.util.ArrayList` | `sViolations`
`Token` | `token`
`JavaCodingStandardCheckerTokenManager` | `token_source`

Fields inherited from interface rj.tools.jcsc.JavaCodingStandardCheckerConstants
`_DEFAULT, ABSTRACT, ANDASSIGN, ASSERT, ASSIGN, BANG, BIT_AND, BIT_OR, BOOLEAN, BREAK, BYTE, CASE, CATCH, CHAR, CHARACTER_LITERAL, CLASS, COLON, COMMA, CONST, CONTINUE, DECIMAL_LITERAL, DECR, DEFAULT, DIGIT, DO, DOT, DOUBLE, ELSE, EOF, EQ, EXPONENT, EXTENDS, FALSE, FINAL, FINALLY, FLOAT, FLOATING_POINT_LITERAL, FOR, GE, GOTO, GT, HEX_LITERAL, HOOK, IDENTIFIER, IF, IMPLEMENTS, IMPORT, IN_JAVADOC_COMMENT, IN_MULTI_LINE_COMMENT, IN_SINGLE_LINE_COMMENT, INCR, INSTANCEOF, INT, INTEGER_LITERAL, INTERFACE, JAVADOC_COMMENT, LBRACE, LBRACKET, LE, LETTER, LONG, LPAREN, LSHIFT, LSHIFTASSIGN, LT, MINUS, MINUSASSIGN, MULTI_LINE_COMMENT, NATIVE, NE, NEW, NULL, OCTAL_LITERAL, ORASSIGN, PACKAGE, PLUS, PLUSASSIGN, PRIVATE, PROTECTED, PUBLIC, RBRACE, RBRACKET, REM, REMASSIGN, RETURN, RPAREN, RSIGNEDSHIFT, RSIGNEDSHIFTASSIGN, RUNSIGNEDSHIFT, RUNSIGNEDSHIFTASSIGN, SC_AND, SC_OR, SEMICOLON, SHORT, SINGLE_LINE_COMMENT, SLASH, SLASHASSIGN, STAR, STARASSIGN, STATIC, STRICTFP, STRING_LITERAL, SUPER, SWITCH, SYNCHRONIZED, THIS, THROW, THROWS, TILDE, tokenImage, TRANSIENT, TRUE, TRY, VOID, VOLATILE, WHILE, XOR, XORASSIGN`

Constructor Summary
`JavaCodingStandardChecker(java.io.InputStream stream)`
`JavaCodingStandardChecker(JavaCodingStandardCheckerTokenManager tm)`
`JavaCodingStandardChecker(java.io.Reader stream)`

Method Summary
`void` | `AdditiveExpression()`
`void` | `AllocationExpression()`
`void` | `AndExpression()`
`static void` | `appendComment(java.lang.String comment)`
`void` | `ArgumentList()`
`void` | `Arguments()`
`void` | `ArrayDimsAndInits()`
`void` | `ArrayInitializer()`
`void` | `AssertStatement()`
`void` | `AssignmentOperator()`
`void` | `Block()`
`void` | `BlockStatement()`
`void` | `BooleanLiteral()`
`void` | `BreakStatement()`
`void` | `CastExpression()`
`void` | `CastLookahead()`
`void` | `CatchBlock()`
`void` | `ClassBody()`
`void` | `ClassBodyDeclaration()`
`java.lang.String` | `ClassDeclaration()`
`void` | `CompilationUnit()` THE JAVA LANGUAGE GRAMMAR STARTS HERE *
`void` | `ConditionalAndExpression()`
`void` | `ConditionalExpression()`
`void` | `ConditionalOrExpression()`
`void` | `ConstructorDeclaration()`
`void` | `ContinueStatement()`
`void` | `disable_tracing()`
`void` | `DoStatement()`
`void` | `EmptyStatement()`
`void` | `enable_tracing()`
`void` | `EqualityExpression()`
`void` | `ExclusiveOrExpression()`
`void` | `ExplicitConstructorInvocation()`
`void` | `Expression()`
`void` | `FieldDeclaration()`
`void` | `FinallyBlock()`
`void` | `ForInit()`
`Return.FormalParameterReturn` | `FormalParameter()`
`int` | `FormalParameters()`
`void` | `ForStatement()`
`void` | `ForUpdate()`
`ParseException` | `generateParseException()`
`java.util.List` | `getAuthors()` `getAuthors` - get list of all @authors as a comma separated string
`int` | `getMethodsCount()` `getMethodsCount` - call this method after a successful parse to obtain the number of methods
`int` | `getNCSS()` `getNCSS` - get the count of NCSS non commenting source statements
`Token` | `getNextToken()`
`Token` | `getToken(int index)`
`int` | `getUnitTestClassCount()` `getUnitTestClassCount` - call this method after a successful parse to obtain the number of Unit test classes
`int` | `getUnitTestsCount()` `getUnitTestsCount` - call this method after a successful parse to obtain the number of Unit tests
`java.util.List` | `getViolations()` `getViolations` - call this method after a successful parse to obtain a List of violations.
`int` | `getViolationsCount()` `getViolationsCount` - call this method after a successful parse to obtain the number of violations
`static void` | `handleComplexLoopExpression(java.lang.StringBuffer pExpression, int pLine, int pColumn)` `handleComplexLoopExpression` checks break condition is based on an operation rather then on a constant
`static void` | `handleConditionalExpression(int pLine, int pColumn)` `handleConditionalExpression` checks if cond expression are allowd or not
`static void` | `handleConstructorDeclarationJavaDoc(java.lang.String pDoc, java.lang.StringBuffer pAccess, int pParaCount, java.util.ArrayList pExcpts, int pLine, int pColumn)` `handleConstructorDeclarationJavaDoc` handles the javadoc for constructor declarations.
`static void` | `handleFieldDeclarationJavaDoc(java.lang.String pDoc, java.lang.StringBuffer pAccess, int pLine, int pColumn)` `handleFieldDeclarationJavaDoc` handles the javadoc for field declarations.
`static void` | `handleJavaDocTagOrder(JavaDocParser pJdp, int pLine, int pColumn)` `handleJavaDocTagOrder` handles if the javadoc tag order correct
`static void` | `handleMethodDeclarationJavaDoc(java.lang.String pDoc, java.lang.StringBuffer pAccess, java.lang.StringBuffer pReturn, int pParaCount, java.util.ArrayList pExcpts, int pLine, int pColumn)` `handleMethodDeclarationJavaDoc` handles the javadoc for method declarations.
`static void` | `handleParaRegExp(java.lang.StringBuffer pAccess, java.lang.StringBuffer pName, int pLine, int pColumn)` Checks if parameter does have the correct prefix
`static void` | `handleSpaceAfterMethodName(java.lang.String pName, int pLine, int pColumn)` `handleSpaceAfterMethodName` checks if the space count is not '0'.
`static void` | `handleSpaceAfterStatementKeyword(java.lang.String pKind, int pLine, int pColumn)` `handleSpaceAfterStatementKeyword` checks if the space count is not '0'.
`static void` | `handleSpaceAroundBinaryExpression(java.lang.String pPlace, java.lang.String pKind, int pLine, int pColumn)` `handleSpaceAroundBinaryExpression` checks space Around Binary Expression
`static void` | `handleStringLiteral(java.lang.String pLiteral, int pLine, int pColumn)` `handleStringLiteral` checks if String literal is allowed
`static void` | `handleTypeDeclarationJavaDoc(java.lang.String pDoc, java.lang.StringBuffer pAccess, java.lang.String pType, int pLine, int pColumn)` `handleTypeDeclarationJavaDoc` handles the javadoc for class declarations.
`static void` | `handleTypeHeaderExpression(java.lang.StringBuffer pHeader, int pLine, int pColumn)` `handleTypeHeaderExpression` handles if the type (class/i-face) do start with the correct header
`void` | `IfStatement()`
`void` | `ImportDeclaration()`
`void` | `InclusiveOrExpression()`
`static void` | `incrementSpace()` `incrementSpace` is called by the tokenizer when a space is read
`void` | `Initializer()`
`void` | `InstanceOfExpression()`
`java.lang.String` | `InterfaceDeclaration()`
`void` | `InterfaceMemberDeclaration()`
`static boolean` | `isRegexpMatch(java.lang.Object regexp, java.lang.Object value)` `isRegexpMatch` return whether the regexp matches the value.
`void` | `LabeledStatement()`
`void` | `Literal()`
`void` | `LocalVariableDeclaration()`
`void` | `LoopExpression()`
`static void` | `main(java.lang.String[] args)` Main - The starting point
`void` | `MethodDeclaration()`
`void` | `MethodDeclarationLookahead()`
`Return.MethodDeclaratorReturn` | `MethodDeclarator()`
`void` | `MultiplicativeExpression()`
`java.lang.StringBuffer` | `Name()`
`java.util.ArrayList` | `NameList()`
`void` | `NestedClassDeclaration()`
`void` | `NestedInterfaceDeclaration()`
`void` | `NullLiteral()`
`static void` | `overviewClassResults()` During parsing global issues are checked whose result is here generated
`void` | `PackageDeclaration()`
`void` | `parse()` `parse` - do the parsing!!!
`void` | `PostfixExpression()`
`void` | `PreDecrementExpression()`
`void` | `PreIncrementExpression()`
`void` | `PrimaryExpression()`
`java.lang.StringBuffer` | `PrimaryPrefix()`
`java.lang.StringBuffer` | `PrimarySuffix()`
`java.lang.StringBuffer` | `PrimitiveType()`
`void` | `ReInit(java.io.InputStream stream)`
`void` | `ReInit(JavaCodingStandardCheckerTokenManager tm)`
`void` | `ReInit(java.io.Reader stream)`
`void` | `RelationalExpression()`
`static void` | `resetNewLine()` `resetNewLine` resets the new line flag to false
`static void` | `resetSpaceCount()` `resetSpaceCount` resets the current space count to '0'
`java.lang.StringBuffer` | `ResultType()`
`void` | `ReturnStatement()`
`void` | `setFileName(java.lang.String fileName)` `setFileName` - set the absolute path of the file to be parsed
`static void` | `setLastJavaDoc(java.lang.String doc)` `setLastJavaDoc` set the last JavaDoc of the current class
`static void` | `setNewLine()` `setNewLine` resets the new line flag to true
`void` | `setResultsFormatter(ResultsFormatter resultsFormatter)` `setResultsFormatter` - set the resulsthander to handle the violations.
`void` | `setRules(java.util.Map cache)` Set the checking rules according to a property file
`void` | `ShiftExpression()`
`void` | `SpecialStatementBlock(java.lang.String pKind)`
`void` | `Statement()`
`void` | `StatementExpression()`
`void` | `StatementExpressionList()`
`boolean` | `SwitchLabel()`
`void` | `SwitchStatement()`
`void` | `SynchronizedStatement()`
`void` | `ThrowStatement()`
`void` | `TryStatement()`
`java.lang.StringBuffer` | `Type()`
`java.lang.String` | `TypeDeclaration()`
`void` | `UnaryExpression()`
`void` | `UnaryExpressionNotPlusMinus()`
`java.lang.String` | `UnmodifiedClassDeclaration(java.lang.StringBuffer pAccess)`
`java.lang.String` | `UnmodifiedInterfaceDeclaration(java.lang.StringBuffer pAccess)`
`java.lang.StringBuffer` | `VariableDeclarator()`
`java.lang.StringBuffer` | `VariableDeclaratorId()`
`void` | `VariableInitializer()`
`void` | `WhileStatement()`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### sAuthors

    public static java.util.ArrayList sAuthors

### sViolations

    public static java.util.ArrayList sViolations

### sMethodMetrics

    public static java.util.ArrayList sMethodMetrics

### sJVMVersion

    public static java.lang.String sJVMVersion

  jvm spec version

### sLastJavaDoc

    public static java.lang.String sLastJavaDoc

  last read java doc

### sLastComment

    public static java.lang.StringBuffer sLastComment

  last read comment block

### sSpaceCount

    public static int sSpaceCount

  counter to keep track of spaces after statement keyword

### sUnitTestClassCount

    public static int sUnitTestClassCount

  counter to keep track of unit test classes

### sUnitTestsCount

    public static int sUnitTestsCount

  counter to keep track of unit tests

### sMethodsCount

    public static int sMethodsCount

  counter to keep track of methods

### sNCSSCount

    public static int sNCSSCount

  counter to keep track of NCSS (non commenting source statements)

### sCCNCount

    public static int sCCNCount

  counter to keep track of CCS (cyclomatic complexity number)

### sReturn

    public static boolean sReturn

  true if return statement was the last one

### sNewLine

    public static boolean sNewLine

  true if \n was lexed; has to be set to false on own accord

### sCurrentState

    public static rj.tools.jcsc.JavaCodingStandardChecker.CurrentState sCurrentState

  State of the current class declaration. Pushed/Poped from Stack.

### token_source

    public JavaCodingStandardCheckerTokenManager token_source

### token

    public Token token

### jj_nt

    public Token jj_nt

### lookingAhead

    public boolean lookingAhead

Constructor Detail

### JavaCodingStandardChecker

    public JavaCodingStandardChecker(java.io.InputStream stream)

### JavaCodingStandardChecker

    public JavaCodingStandardChecker(java.io.Reader stream)

### JavaCodingStandardChecker

    public JavaCodingStandardChecker(JavaCodingStandardCheckerTokenManager tm)

Method Detail

### main

    public static void main(java.lang.String[] args)

  Main - The starting point
  Parameters:
    `args` - a `String[]` value - the arguments

### parse

    public void parse()

  `parse` - do the parsing!!!

### getViolations

    public java.util.List getViolations()

  `getViolations` - call this method after a successful parse to obtain a List of violations. The violations are sorted accorind to the configuration.
  Returns:
    an `int` value

### getViolationsCount

    public int getViolationsCount()

  `getViolationsCount` - call this method after a successful parse to obtain the number of violations
  Returns:
    an `int` value

### getUnitTestClassCount

    public int getUnitTestClassCount()

  `getUnitTestClassCount` - call this method after a successful parse to obtain the number of Unit test classes
  Returns:
    an `int` value

### getUnitTestsCount

    public int getUnitTestsCount()

  `getUnitTestsCount` - call this method after a successful parse to obtain the number of Unit tests
  Returns:
    an `int` value

### getMethodsCount

    public int getMethodsCount()

  `getMethodsCount` - call this method after a successful parse to obtain the number of methods
  Returns:
    an `int` value

### getAuthors

    public java.util.List getAuthors()

  `getAuthors` - get list of all @authors as a comma separated string
  Returns:
    an `List` value

### getNCSS

    public int getNCSS()

  `getNCSS` - get the count of NCSS non commenting source statements
  Returns:
    an `Stirng` value

### setResultsFormatter

    public void setResultsFormatter(ResultsFormatter resultsFormatter)

  `setResultsFormatter` - set the resulsthander to handle the violations. The results handler uses the output stream.
  Parameters:
    `resultsFormatter` - a `ResultsFormatter` value

### setFileName

    public void setFileName(java.lang.String fileName)

  `setFileName` - set the absolute path of the file to be parsed
  Parameters:
    `fileName` - a `String` value

### setRules

    public void setRules(java.util.Map cache)

  Set the checking rules according to a property file

### isRegexpMatch

    public static boolean isRegexpMatch(java.lang.Object regexp,
                                        java.lang.Object value)

  `isRegexpMatch` return whether the regexp matches the value. toString() is called on either of the parameters to get the string representation
  Parameters:
    `regexp` - a `Object` value
    `value` - a `Object` value
  Returns:
    a `boolean` value

### handleTypeHeaderExpression

    public static void handleTypeHeaderExpression(java.lang.StringBuffer pHeader,
                                                  int pLine,
                                                  int pColumn)

  `handleTypeHeaderExpression` handles if the type (class/i-face) do start with the correct header
  Parameters:
    `pHeader` - a `StringBuffer` value
    `pLine` - an `int` value
    `pColumn` - an `int` value

### handleParaRegExp

    public static void handleParaRegExp(java.lang.StringBuffer pAccess,
                                        java.lang.StringBuffer pName,
                                        int pLine,
                                        int pColumn)

  Checks if parameter does have the correct prefix
  Parameters:
    `pName` - a value of type 'StringBuffer'
    `pLine` - a value of type 'int'

### overviewClassResults

    public static void overviewClassResults()

  During parsing global issues are checked whose result is here generated

### incrementSpace

    public static void incrementSpace()

  `incrementSpace` is called by the tokenizer when a space is read

### resetSpaceCount

    public static void resetSpaceCount()

  `resetSpaceCount` resets the current space count to '0'

### resetNewLine

    public static void resetNewLine()

  `resetNewLine` resets the new line flag to false

### setNewLine

    public static void setNewLine()

  `setNewLine` resets the new line flag to true

### setLastJavaDoc

    public static void setLastJavaDoc(java.lang.String doc)

  `setLastJavaDoc` set the last JavaDoc of the current class

### appendComment

    public static void appendComment(java.lang.String comment)

### handleSpaceAfterStatementKeyword

    public static void handleSpaceAfterStatementKeyword(java.lang.String pKind,
                                                        int pLine,
                                                        int pColumn)

  `handleSpaceAfterStatementKeyword` checks if the space count is not '0'.
  Parameters:
    `pLine` - an `int` value is current line number
    `pKind` - a `String` value is the type of the statement

### handleSpaceAfterMethodName

    public static void handleSpaceAfterMethodName(java.lang.String pName,
                                                  int pLine,
                                                  int pColumn)

  `handleSpaceAfterMethodName` checks if the space count is not '0'.
  Parameters:
    `pLine` - an `int` value is current line number
    `pKind` - a `String` value is the type of the statement

### handleSpaceAroundBinaryExpression

    public static void handleSpaceAroundBinaryExpression(java.lang.String pPlace,
                                                         java.lang.String pKind,
                                                         int pLine,
                                                         int pColumn)

  `handleSpaceAroundBinaryExpression` checks space Around Binary Expression
  Parameters:
    `pLine` - an `int` value is the current line number
    `pPlace` - a `String` value indicates BEFORE_BINARY or AFTER_BINARY
    `pKind` - a `String` value is the type of the binary expression

### handleStringLiteral

    public static void handleStringLiteral(java.lang.String pLiteral,
                                           int pLine,
                                           int pColumn)

  `handleStringLiteral` checks if String literal is allowed
  Parameters:
    `pLine` - an `int` value is the current line number
    `pLiteral` - a `String` value is the string literl

### handleComplexLoopExpression

    public static void handleComplexLoopExpression(java.lang.StringBuffer pExpression,
                                                   int pLine,
                                                   int pColumn)

  `handleComplexLoopExpression` checks break condition is based on an operation rather then on a constant
  Parameters:
    `pExpression` - a `StringBuffer` value is the complex loop expr
    `pLine` - a `int` line number
    `pColumn` - an `int` column number

### handleConditionalExpression

    public static void handleConditionalExpression(int pLine,
                                                   int pColumn)

  `handleConditionalExpression` checks if cond expression are allowd or not
  Parameters:
    `pLine` - a `int` line number
    `pColumn` - an `int` column number

### handleTypeDeclarationJavaDoc

    public static void handleTypeDeclarationJavaDoc(java.lang.String pDoc,
                                                    java.lang.StringBuffer pAccess,
                                                    java.lang.String pType,
                                                    int pLine,
                                                    int pColumn)

  `handleTypeDeclarationJavaDoc` handles the javadoc for class declarations.
  Parameters:
    `pDoc` - a `String` value
    `pAccess` - a `StringBuffer` value
    `pType` - a `String` value

### handleConstructorDeclarationJavaDoc

    public static void handleConstructorDeclarationJavaDoc(java.lang.String pDoc,
                                                           java.lang.StringBuffer pAccess,
                                                           int pParaCount,
                                                           java.util.ArrayList pExcpts,
                                                           int pLine,
                                                           int pColumn)

  `handleConstructorDeclarationJavaDoc` handles the javadoc for constructor declarations.
  Parameters:
    `doc` - a `String` value

### handleMethodDeclarationJavaDoc

    public static void handleMethodDeclarationJavaDoc(java.lang.String pDoc,
                                                      java.lang.StringBuffer pAccess,
                                                      java.lang.StringBuffer pReturn,
                                                      int pParaCount,
                                                      java.util.ArrayList pExcpts,
                                                      int pLine,
                                                      int pColumn)

  `handleMethodDeclarationJavaDoc` handles the javadoc for method declarations.
  Parameters:
    `doc` - a `String` value

### handleFieldDeclarationJavaDoc

    public static void handleFieldDeclarationJavaDoc(java.lang.String pDoc,
                                                     java.lang.StringBuffer pAccess,
                                                     int pLine,
                                                     int pColumn)

  `handleFieldDeclarationJavaDoc` handles the javadoc for field declarations.
  Parameters:
    `doc` - a `String` value

### handleJavaDocTagOrder

    public static void handleJavaDocTagOrder(JavaDocParser pJdp,
                                             int pLine,
                                             int pColumn)

  `handleJavaDocTagOrder` handles if the javadoc tag order correct
  Parameters:
    `pJdp` - a `JavaDocParser` value
    `pLine` - an `int` value
    `pColumn` - an `int` value

### CompilationUnit

    public final void CompilationUnit()
                               throws ParseException

  THE JAVA LANGUAGE GRAMMAR STARTS HERE *

### PackageDeclaration

    public final void PackageDeclaration()
                                  throws ParseException

### ImportDeclaration

    public final void ImportDeclaration()
                                 throws ParseException

### TypeDeclaration

    public final java.lang.String TypeDeclaration()
                                           throws ParseException

### ClassDeclaration

    public final java.lang.String ClassDeclaration()
                                            throws ParseException

### UnmodifiedClassDeclaration

    public final java.lang.String UnmodifiedClassDeclaration(java.lang.StringBuffer pAccess)
                                                      throws ParseException

### ClassBody

    public final void ClassBody()
                         throws ParseException

### NestedClassDeclaration

    public final void NestedClassDeclaration()
                                      throws ParseException

### ClassBodyDeclaration

    public final void ClassBodyDeclaration()
                                    throws ParseException

### MethodDeclarationLookahead

    public final void MethodDeclarationLookahead()
                                          throws ParseException

### InterfaceDeclaration

    public final java.lang.String InterfaceDeclaration()
                                                throws ParseException

### NestedInterfaceDeclaration

    public final void NestedInterfaceDeclaration()
                                          throws ParseException

### UnmodifiedInterfaceDeclaration

    public final java.lang.String UnmodifiedInterfaceDeclaration(java.lang.StringBuffer pAccess)
                                                          throws ParseException

### InterfaceMemberDeclaration

    public final void InterfaceMemberDeclaration()
                                          throws ParseException

### FieldDeclaration

    public final void FieldDeclaration()
                                throws ParseException

### VariableDeclarator

    public final java.lang.StringBuffer VariableDeclarator()
                                                    throws ParseException

### VariableDeclaratorId

    public final java.lang.StringBuffer VariableDeclaratorId()
                                                      throws ParseException

### VariableInitializer

    public final void VariableInitializer()
                                   throws ParseException

### ArrayInitializer

    public final void ArrayInitializer()
                                throws ParseException

### MethodDeclaration

    public final void MethodDeclaration()
                                 throws ParseException

### MethodDeclarator

    public final Return.MethodDeclaratorReturn MethodDeclarator()
                                                         throws ParseException

### FormalParameters

    public final int FormalParameters()
                               throws ParseException

### FormalParameter

    public final Return.FormalParameterReturn FormalParameter()
                                                       throws ParseException

### ConstructorDeclaration

    public final void ConstructorDeclaration()
                                      throws ParseException

### ExplicitConstructorInvocation

    public final void ExplicitConstructorInvocation()
                                             throws ParseException

### Initializer

    public final void Initializer()
                           throws ParseException

### Type

    public final java.lang.StringBuffer Type()
                                      throws ParseException

### PrimitiveType

    public final java.lang.StringBuffer PrimitiveType()
                                               throws ParseException

### ResultType

    public final java.lang.StringBuffer ResultType()
                                            throws ParseException

### Name

    public final java.lang.StringBuffer Name()
                                      throws ParseException

### NameList

    public final java.util.ArrayList NameList()
                                       throws ParseException

### Expression

    public final void Expression()
                          throws ParseException

### AssignmentOperator

    public final void AssignmentOperator()
                                  throws ParseException

### ConditionalExpression

    public final void ConditionalExpression()
                                     throws ParseException

### ConditionalOrExpression

    public final void ConditionalOrExpression()
                                       throws ParseException

### ConditionalAndExpression

    public final void ConditionalAndExpression()
                                        throws ParseException

### InclusiveOrExpression

    public final void InclusiveOrExpression()
                                     throws ParseException

### ExclusiveOrExpression

    public final void ExclusiveOrExpression()
                                     throws ParseException

### AndExpression

    public final void AndExpression()
                             throws ParseException

### EqualityExpression

    public final void EqualityExpression()
                                  throws ParseException

### InstanceOfExpression

    public final void InstanceOfExpression()
                                    throws ParseException

### RelationalExpression

    public final void RelationalExpression()
                                    throws ParseException

### ShiftExpression

    public final void ShiftExpression()
                               throws ParseException

### AdditiveExpression

    public final void AdditiveExpression()
                                  throws ParseException

### MultiplicativeExpression

    public final void MultiplicativeExpression()
                                        throws ParseException

### UnaryExpression

    public final void UnaryExpression()
                               throws ParseException

### PreIncrementExpression

    public final void PreIncrementExpression()
                                      throws ParseException

### PreDecrementExpression

    public final void PreDecrementExpression()
                                      throws ParseException

### UnaryExpressionNotPlusMinus

    public final void UnaryExpressionNotPlusMinus()
                                           throws ParseException

### CastLookahead

    public final void CastLookahead()
                             throws ParseException

### PostfixExpression

    public final void PostfixExpression()
                                 throws ParseException

### CastExpression

    public final void CastExpression()
                              throws ParseException

### PrimaryExpression

    public final void PrimaryExpression()
                                 throws ParseException

### PrimaryPrefix

    public final java.lang.StringBuffer PrimaryPrefix()
                                               throws ParseException

### PrimarySuffix

    public final java.lang.StringBuffer PrimarySuffix()
                                               throws ParseException

### Literal

    public final void Literal()
                       throws ParseException

### BooleanLiteral

    public final void BooleanLiteral()
                              throws ParseException

### NullLiteral

    public final void NullLiteral()
                           throws ParseException

### Arguments

    public final void Arguments()
                         throws ParseException

### ArgumentList

    public final void ArgumentList()
                            throws ParseException

### AllocationExpression

    public final void AllocationExpression()
                                    throws ParseException

### ArrayDimsAndInits

    public final void ArrayDimsAndInits()
                                 throws ParseException

### Statement

    public final void Statement()
                         throws ParseException

### LabeledStatement

    public final void LabeledStatement()
                                throws ParseException

### Block

    public final void Block()
                     throws ParseException

### BlockStatement

    public final void BlockStatement()
                              throws ParseException

### LocalVariableDeclaration

    public final void LocalVariableDeclaration()
                                        throws ParseException

### EmptyStatement

    public final void EmptyStatement()
                              throws ParseException

### StatementExpression

    public final void StatementExpression()
                                   throws ParseException

### SwitchStatement

    public final void SwitchStatement()
                               throws ParseException

### SwitchLabel

    public final boolean SwitchLabel()
                              throws ParseException

### SpecialStatementBlock

    public final void SpecialStatementBlock(java.lang.String pKind)
                                     throws ParseException

### IfStatement

    public final void IfStatement()
                           throws ParseException

### WhileStatement

    public final void WhileStatement()
                              throws ParseException

### DoStatement

    public final void DoStatement()
                           throws ParseException

### ForStatement

    public final void ForStatement()
                            throws ParseException

### ForInit

    public final void ForInit()
                       throws ParseException

### LoopExpression

    public final void LoopExpression()
                              throws ParseException

### StatementExpressionList

    public final void StatementExpressionList()
                                       throws ParseException

### ForUpdate

    public final void ForUpdate()
                         throws ParseException

### BreakStatement

    public final void BreakStatement()
                              throws ParseException

### ContinueStatement

    public final void ContinueStatement()
                                 throws ParseException

### ReturnStatement

    public final void ReturnStatement()
                               throws ParseException

### ThrowStatement

    public final void ThrowStatement()
                              throws ParseException

### SynchronizedStatement

    public final void SynchronizedStatement()
                                     throws ParseException

### TryStatement

    public final void TryStatement()
                            throws ParseException

### CatchBlock

    public final void CatchBlock()
                          throws ParseException

### FinallyBlock

    public final void FinallyBlock()
                            throws ParseException

### AssertStatement

    public final void AssertStatement()
                               throws ParseException

### ReInit

    public void ReInit(java.io.InputStream stream)

### ReInit

    public void ReInit(java.io.Reader stream)

### ReInit

    public void ReInit(JavaCodingStandardCheckerTokenManager tm)

### getNextToken

    public final Token getNextToken()

### getToken

    public final Token getToken(int index)

### generateParseException

    public final ParseException generateParseException()

### enable_tracing

    public final void enable_tracing()

### disable_tracing

    public final void disable_tracing()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

(c) 1999-2004 by Ralph Jocham (rjocham72@netscape.net)
JCSC is released under the terms of the GNU General Public License